diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..83bec44be8e9e7926d9d8454d92422079ef1df4a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,15 @@
+*.dat
+*.asv
+*.autosave
+*.xlsx
+*.xls
+*.png
+*.fig
+*.pdf
+*.h
+*.c
+*.slxc
+*.out
+*.log
+Resultfigures_*
+*bestpatients*
\ No newline at end of file
diff --git a/Data/inputdata_avatarmodel_P1.mat b/Data/inputdata_avatarmodel_P1.mat
new file mode 100644
index 0000000000000000000000000000000000000000..258c0cce1dd80bfd4f03e5b862b4f3056147169d
Binary files /dev/null and b/Data/inputdata_avatarmodel_P1.mat differ
diff --git a/Data/inputdata_avatarmodel_P10.mat b/Data/inputdata_avatarmodel_P10.mat
new file mode 100644
index 0000000000000000000000000000000000000000..0f81ab5aca7c14cf616aa6e8ec1fdb8e55dd19a8
Binary files /dev/null and b/Data/inputdata_avatarmodel_P10.mat differ
diff --git a/Data/inputdata_avatarmodel_P11.mat b/Data/inputdata_avatarmodel_P11.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e42fd9c35f572d0f5f9bf2a46e0ca6dbcd63b676
Binary files /dev/null and b/Data/inputdata_avatarmodel_P11.mat differ
diff --git a/Data/inputdata_avatarmodel_P12.mat b/Data/inputdata_avatarmodel_P12.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c6de67d79a169fb9a4d3ea812b14b4143de84fa4
Binary files /dev/null and b/Data/inputdata_avatarmodel_P12.mat differ
diff --git a/Data/inputdata_avatarmodel_P13.mat b/Data/inputdata_avatarmodel_P13.mat
new file mode 100644
index 0000000000000000000000000000000000000000..49d3bad42bb3e13627504b01a506c0d470de2ecd
Binary files /dev/null and b/Data/inputdata_avatarmodel_P13.mat differ
diff --git a/Data/inputdata_avatarmodel_P14.mat b/Data/inputdata_avatarmodel_P14.mat
new file mode 100644
index 0000000000000000000000000000000000000000..b3bc855d5146400377289b7e52f0c79187d70b45
Binary files /dev/null and b/Data/inputdata_avatarmodel_P14.mat differ
diff --git a/Data/inputdata_avatarmodel_P15.mat b/Data/inputdata_avatarmodel_P15.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f4afbef27fdb4cd776c19c72fe47d6de7ab6cff5
Binary files /dev/null and b/Data/inputdata_avatarmodel_P15.mat differ
diff --git a/Data/inputdata_avatarmodel_P16.mat b/Data/inputdata_avatarmodel_P16.mat
new file mode 100644
index 0000000000000000000000000000000000000000..762eebeba71e7d697ecd259de13779b9f4f6e5b6
Binary files /dev/null and b/Data/inputdata_avatarmodel_P16.mat differ
diff --git a/Data/inputdata_avatarmodel_P17.mat b/Data/inputdata_avatarmodel_P17.mat
new file mode 100644
index 0000000000000000000000000000000000000000..59b70ce3ec516a3211710423f42e762116c6dd68
Binary files /dev/null and b/Data/inputdata_avatarmodel_P17.mat differ
diff --git a/Data/inputdata_avatarmodel_P18.mat b/Data/inputdata_avatarmodel_P18.mat
new file mode 100644
index 0000000000000000000000000000000000000000..ac101b4f34c41b975a7f3ae0e14eca80f9f62aab
Binary files /dev/null and b/Data/inputdata_avatarmodel_P18.mat differ
diff --git a/Data/inputdata_avatarmodel_P19.mat b/Data/inputdata_avatarmodel_P19.mat
new file mode 100644
index 0000000000000000000000000000000000000000..70711fcfa3f62e6d4ea8f7e3fad24d06bffee140
Binary files /dev/null and b/Data/inputdata_avatarmodel_P19.mat differ
diff --git a/Data/inputdata_avatarmodel_P2.mat b/Data/inputdata_avatarmodel_P2.mat
new file mode 100644
index 0000000000000000000000000000000000000000..b01c9f4ca409cc758589076e39f4d8b9cf8516b6
Binary files /dev/null and b/Data/inputdata_avatarmodel_P2.mat differ
diff --git a/Data/inputdata_avatarmodel_P20.mat b/Data/inputdata_avatarmodel_P20.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e415804c413d63e783060ab1d45a3a2138320cf4
Binary files /dev/null and b/Data/inputdata_avatarmodel_P20.mat differ
diff --git a/Data/inputdata_avatarmodel_P21.mat b/Data/inputdata_avatarmodel_P21.mat
new file mode 100644
index 0000000000000000000000000000000000000000..97a5660c680e876f28236cd951256dc2b546885f
Binary files /dev/null and b/Data/inputdata_avatarmodel_P21.mat differ
diff --git a/Data/inputdata_avatarmodel_P22.mat b/Data/inputdata_avatarmodel_P22.mat
new file mode 100644
index 0000000000000000000000000000000000000000..3f05bac8341072a62e5019bfb84f6f9b27421095
Binary files /dev/null and b/Data/inputdata_avatarmodel_P22.mat differ
diff --git a/Data/inputdata_avatarmodel_P23.mat b/Data/inputdata_avatarmodel_P23.mat
new file mode 100644
index 0000000000000000000000000000000000000000..12d95639d6fc98cd79b454f61db8a45c97551e27
Binary files /dev/null and b/Data/inputdata_avatarmodel_P23.mat differ
diff --git a/Data/inputdata_avatarmodel_P24.mat b/Data/inputdata_avatarmodel_P24.mat
new file mode 100644
index 0000000000000000000000000000000000000000..3e0ab9fe991ba1379a3d89487d21c4ca9a3de38a
Binary files /dev/null and b/Data/inputdata_avatarmodel_P24.mat differ
diff --git a/Data/inputdata_avatarmodel_P25.mat b/Data/inputdata_avatarmodel_P25.mat
new file mode 100644
index 0000000000000000000000000000000000000000..61fc6f214edd689e15172a7878df8a9c4c06d83d
Binary files /dev/null and b/Data/inputdata_avatarmodel_P25.mat differ
diff --git a/Data/inputdata_avatarmodel_P26.mat b/Data/inputdata_avatarmodel_P26.mat
new file mode 100644
index 0000000000000000000000000000000000000000..a3bea9dc7dd398f71c7f7153782b785d0ee12198
Binary files /dev/null and b/Data/inputdata_avatarmodel_P26.mat differ
diff --git a/Data/inputdata_avatarmodel_P27.mat b/Data/inputdata_avatarmodel_P27.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8bef6d05ec13ebd892000e5d2d694a0745102558
Binary files /dev/null and b/Data/inputdata_avatarmodel_P27.mat differ
diff --git a/Data/inputdata_avatarmodel_P28.mat b/Data/inputdata_avatarmodel_P28.mat
new file mode 100644
index 0000000000000000000000000000000000000000..cb442f3696d60b90028f1a4e46a5e30ac5517f30
Binary files /dev/null and b/Data/inputdata_avatarmodel_P28.mat differ
diff --git a/Data/inputdata_avatarmodel_P29.mat b/Data/inputdata_avatarmodel_P29.mat
new file mode 100644
index 0000000000000000000000000000000000000000..4a31da00682721a4abe55d5c925deea920e2bad1
Binary files /dev/null and b/Data/inputdata_avatarmodel_P29.mat differ
diff --git a/Data/inputdata_avatarmodel_P3.mat b/Data/inputdata_avatarmodel_P3.mat
new file mode 100644
index 0000000000000000000000000000000000000000..eeeecdafa9a3ff469f9e60a1e5593c4c305e45dc
Binary files /dev/null and b/Data/inputdata_avatarmodel_P3.mat differ
diff --git a/Data/inputdata_avatarmodel_P30.mat b/Data/inputdata_avatarmodel_P30.mat
new file mode 100644
index 0000000000000000000000000000000000000000..24261159b90e372cca2fc204a283c2b51c5784cc
Binary files /dev/null and b/Data/inputdata_avatarmodel_P30.mat differ
diff --git a/Data/inputdata_avatarmodel_P31.mat b/Data/inputdata_avatarmodel_P31.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c957b37fb00ea6bfb7fd8311ece50698e953eb91
Binary files /dev/null and b/Data/inputdata_avatarmodel_P31.mat differ
diff --git a/Data/inputdata_avatarmodel_P32.mat b/Data/inputdata_avatarmodel_P32.mat
new file mode 100644
index 0000000000000000000000000000000000000000..5809e547192edea986d887df76a6a060ff4f851a
Binary files /dev/null and b/Data/inputdata_avatarmodel_P32.mat differ
diff --git a/Data/inputdata_avatarmodel_P33.mat b/Data/inputdata_avatarmodel_P33.mat
new file mode 100644
index 0000000000000000000000000000000000000000..64762366135b2f3f28d2aee0389b4973334ed7a6
Binary files /dev/null and b/Data/inputdata_avatarmodel_P33.mat differ
diff --git a/Data/inputdata_avatarmodel_P34.mat b/Data/inputdata_avatarmodel_P34.mat
new file mode 100644
index 0000000000000000000000000000000000000000..90803fd18015dc320ebed6ff664541ad8ffab555
Binary files /dev/null and b/Data/inputdata_avatarmodel_P34.mat differ
diff --git a/Data/inputdata_avatarmodel_P35.mat b/Data/inputdata_avatarmodel_P35.mat
new file mode 100644
index 0000000000000000000000000000000000000000..cf38c44bbd46c6aeeaf1d93202b2d31d61b5fd34
Binary files /dev/null and b/Data/inputdata_avatarmodel_P35.mat differ
diff --git a/Data/inputdata_avatarmodel_P36.mat b/Data/inputdata_avatarmodel_P36.mat
new file mode 100644
index 0000000000000000000000000000000000000000..807e7f7626f46f0cc73a8568c6b383f2de780d70
Binary files /dev/null and b/Data/inputdata_avatarmodel_P36.mat differ
diff --git a/Data/inputdata_avatarmodel_P37.mat b/Data/inputdata_avatarmodel_P37.mat
new file mode 100644
index 0000000000000000000000000000000000000000..91a83cf82385523c447f915926b158935eb22efa
Binary files /dev/null and b/Data/inputdata_avatarmodel_P37.mat differ
diff --git a/Data/inputdata_avatarmodel_P38.mat b/Data/inputdata_avatarmodel_P38.mat
new file mode 100644
index 0000000000000000000000000000000000000000..6ba864a501e18c22eca768bcb9b1206f3bc79c0b
Binary files /dev/null and b/Data/inputdata_avatarmodel_P38.mat differ
diff --git a/Data/inputdata_avatarmodel_P39.mat b/Data/inputdata_avatarmodel_P39.mat
new file mode 100644
index 0000000000000000000000000000000000000000..09ba22999f08cce61ec4bc49486f298a74004e6b
Binary files /dev/null and b/Data/inputdata_avatarmodel_P39.mat differ
diff --git a/Data/inputdata_avatarmodel_P4.mat b/Data/inputdata_avatarmodel_P4.mat
new file mode 100644
index 0000000000000000000000000000000000000000..381014af2de2890b7720c5b14399c299e981d241
Binary files /dev/null and b/Data/inputdata_avatarmodel_P4.mat differ
diff --git a/Data/inputdata_avatarmodel_P40.mat b/Data/inputdata_avatarmodel_P40.mat
new file mode 100644
index 0000000000000000000000000000000000000000..212fff742a8586e2d01f8e94012633a487eb01ff
Binary files /dev/null and b/Data/inputdata_avatarmodel_P40.mat differ
diff --git a/Data/inputdata_avatarmodel_P41.mat b/Data/inputdata_avatarmodel_P41.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9dfc0a0ff13e3ce01897b77eb39666a60ce52f38
Binary files /dev/null and b/Data/inputdata_avatarmodel_P41.mat differ
diff --git a/Data/inputdata_avatarmodel_P42.mat b/Data/inputdata_avatarmodel_P42.mat
new file mode 100644
index 0000000000000000000000000000000000000000..90349554254884316a021ffb468dd825a07a3cd0
Binary files /dev/null and b/Data/inputdata_avatarmodel_P42.mat differ
diff --git a/Data/inputdata_avatarmodel_P43.mat b/Data/inputdata_avatarmodel_P43.mat
new file mode 100644
index 0000000000000000000000000000000000000000..403177f1f99421c67d16b0b5001013550f1dac2e
Binary files /dev/null and b/Data/inputdata_avatarmodel_P43.mat differ
diff --git a/Data/inputdata_avatarmodel_P44.mat b/Data/inputdata_avatarmodel_P44.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8dd2c4717623fdb2ebbfdab8bb4457a5aea700ba
Binary files /dev/null and b/Data/inputdata_avatarmodel_P44.mat differ
diff --git a/Data/inputdata_avatarmodel_P45.mat b/Data/inputdata_avatarmodel_P45.mat
new file mode 100644
index 0000000000000000000000000000000000000000..7db3e8f1dfefa521d1a2158477a7838c61154f09
Binary files /dev/null and b/Data/inputdata_avatarmodel_P45.mat differ
diff --git a/Data/inputdata_avatarmodel_P46.mat b/Data/inputdata_avatarmodel_P46.mat
new file mode 100644
index 0000000000000000000000000000000000000000..aa73c879a0fa1b7d4dfbeea06d82a20a0dd8fa44
Binary files /dev/null and b/Data/inputdata_avatarmodel_P46.mat differ
diff --git a/Data/inputdata_avatarmodel_P47.mat b/Data/inputdata_avatarmodel_P47.mat
new file mode 100644
index 0000000000000000000000000000000000000000..7579a89d743ae3926ba5e79aa02367dc3c7b77f5
Binary files /dev/null and b/Data/inputdata_avatarmodel_P47.mat differ
diff --git a/Data/inputdata_avatarmodel_P48.mat b/Data/inputdata_avatarmodel_P48.mat
new file mode 100644
index 0000000000000000000000000000000000000000..676ff9c844d36628918e6f213b01e8bfbd358ba8
Binary files /dev/null and b/Data/inputdata_avatarmodel_P48.mat differ
diff --git a/Data/inputdata_avatarmodel_P49.mat b/Data/inputdata_avatarmodel_P49.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8fb687377640b39e4aca2f3ffcafda05e17824d4
Binary files /dev/null and b/Data/inputdata_avatarmodel_P49.mat differ
diff --git a/Data/inputdata_avatarmodel_P5.mat b/Data/inputdata_avatarmodel_P5.mat
new file mode 100644
index 0000000000000000000000000000000000000000..303cfcfc3d90716807bed5b79bc6fc5b24d126d1
Binary files /dev/null and b/Data/inputdata_avatarmodel_P5.mat differ
diff --git a/Data/inputdata_avatarmodel_P50.mat b/Data/inputdata_avatarmodel_P50.mat
new file mode 100644
index 0000000000000000000000000000000000000000..b246db703b9307f98041a8d0449b17645b9cff9a
Binary files /dev/null and b/Data/inputdata_avatarmodel_P50.mat differ
diff --git a/Data/inputdata_avatarmodel_P51.mat b/Data/inputdata_avatarmodel_P51.mat
new file mode 100644
index 0000000000000000000000000000000000000000..a452ba49f38c8b5803126df312486fdccb2e384f
Binary files /dev/null and b/Data/inputdata_avatarmodel_P51.mat differ
diff --git a/Data/inputdata_avatarmodel_P52.mat b/Data/inputdata_avatarmodel_P52.mat
new file mode 100644
index 0000000000000000000000000000000000000000..6e4e18b876b10da0938f302a51e84292c3755bb2
Binary files /dev/null and b/Data/inputdata_avatarmodel_P52.mat differ
diff --git a/Data/inputdata_avatarmodel_P53.mat b/Data/inputdata_avatarmodel_P53.mat
new file mode 100644
index 0000000000000000000000000000000000000000..faef22171f8539983152beb4344a8f182c23ec33
Binary files /dev/null and b/Data/inputdata_avatarmodel_P53.mat differ
diff --git a/Data/inputdata_avatarmodel_P54.mat b/Data/inputdata_avatarmodel_P54.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9dbcc393224baee0348e37664a574d0d9231f02e
Binary files /dev/null and b/Data/inputdata_avatarmodel_P54.mat differ
diff --git a/Data/inputdata_avatarmodel_P55.mat b/Data/inputdata_avatarmodel_P55.mat
new file mode 100644
index 0000000000000000000000000000000000000000..ec24e390d20413680d13a7146d5713c2e17cfb25
Binary files /dev/null and b/Data/inputdata_avatarmodel_P55.mat differ
diff --git a/Data/inputdata_avatarmodel_P56.mat b/Data/inputdata_avatarmodel_P56.mat
new file mode 100644
index 0000000000000000000000000000000000000000..aeb3474d042fb912c52e2bba074509c1de2330ed
Binary files /dev/null and b/Data/inputdata_avatarmodel_P56.mat differ
diff --git a/Data/inputdata_avatarmodel_P57.mat b/Data/inputdata_avatarmodel_P57.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f4ee657292d3c292ba37427d2e96c1101d22d5aa
Binary files /dev/null and b/Data/inputdata_avatarmodel_P57.mat differ
diff --git a/Data/inputdata_avatarmodel_P58.mat b/Data/inputdata_avatarmodel_P58.mat
new file mode 100644
index 0000000000000000000000000000000000000000..cf2e1df6d38c7550b023abbe0f8009391da830c4
Binary files /dev/null and b/Data/inputdata_avatarmodel_P58.mat differ
diff --git a/Data/inputdata_avatarmodel_P59.mat b/Data/inputdata_avatarmodel_P59.mat
new file mode 100644
index 0000000000000000000000000000000000000000..ef8b104ce8b8c0bb7a4c6e70de3641609f177d21
Binary files /dev/null and b/Data/inputdata_avatarmodel_P59.mat differ
diff --git a/Data/inputdata_avatarmodel_P6.mat b/Data/inputdata_avatarmodel_P6.mat
new file mode 100644
index 0000000000000000000000000000000000000000..7e98e8fb16eab23853eafc34e08e7f7aa9d01dcc
Binary files /dev/null and b/Data/inputdata_avatarmodel_P6.mat differ
diff --git a/Data/inputdata_avatarmodel_P60.mat b/Data/inputdata_avatarmodel_P60.mat
new file mode 100644
index 0000000000000000000000000000000000000000..fbbe7f23982a92108f8c48cde6499c80602047e0
Binary files /dev/null and b/Data/inputdata_avatarmodel_P60.mat differ
diff --git a/Data/inputdata_avatarmodel_P61.mat b/Data/inputdata_avatarmodel_P61.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9a776f5b1dbd75fef58ded7267e5f8e0f3fdc1f7
Binary files /dev/null and b/Data/inputdata_avatarmodel_P61.mat differ
diff --git a/Data/inputdata_avatarmodel_P62.mat b/Data/inputdata_avatarmodel_P62.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9b09e7b7c9db8e647fdae2f09962f80982470c9c
Binary files /dev/null and b/Data/inputdata_avatarmodel_P62.mat differ
diff --git a/Data/inputdata_avatarmodel_P63.mat b/Data/inputdata_avatarmodel_P63.mat
new file mode 100644
index 0000000000000000000000000000000000000000..b05d926ea4806b8af354de6ff0d38f3ca0e2f505
Binary files /dev/null and b/Data/inputdata_avatarmodel_P63.mat differ
diff --git a/Data/inputdata_avatarmodel_P64.mat b/Data/inputdata_avatarmodel_P64.mat
new file mode 100644
index 0000000000000000000000000000000000000000..1c7d390ccbc1578b91ba693ab64e5b3cfc595e4b
Binary files /dev/null and b/Data/inputdata_avatarmodel_P64.mat differ
diff --git a/Data/inputdata_avatarmodel_P65.mat b/Data/inputdata_avatarmodel_P65.mat
new file mode 100644
index 0000000000000000000000000000000000000000..4c724649411ec5e8964e91189b835c793db91c48
Binary files /dev/null and b/Data/inputdata_avatarmodel_P65.mat differ
diff --git a/Data/inputdata_avatarmodel_P66.mat b/Data/inputdata_avatarmodel_P66.mat
new file mode 100644
index 0000000000000000000000000000000000000000..353663808530a30499d1e6a7ae5fa637a9de3326
Binary files /dev/null and b/Data/inputdata_avatarmodel_P66.mat differ
diff --git a/Data/inputdata_avatarmodel_P67.mat b/Data/inputdata_avatarmodel_P67.mat
new file mode 100644
index 0000000000000000000000000000000000000000..54ce442cff6b20c7e4acce97eef5061cac1a6658
Binary files /dev/null and b/Data/inputdata_avatarmodel_P67.mat differ
diff --git a/Data/inputdata_avatarmodel_P68.mat b/Data/inputdata_avatarmodel_P68.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9ce02cfabb948a71692f154e42e29f334afc1fa8
Binary files /dev/null and b/Data/inputdata_avatarmodel_P68.mat differ
diff --git a/Data/inputdata_avatarmodel_P69.mat b/Data/inputdata_avatarmodel_P69.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c9edee131967db4b985d772180d68ad8ea60c8ff
Binary files /dev/null and b/Data/inputdata_avatarmodel_P69.mat differ
diff --git a/Data/inputdata_avatarmodel_P7.mat b/Data/inputdata_avatarmodel_P7.mat
new file mode 100644
index 0000000000000000000000000000000000000000..0acb7e5ec25779779e148bd32b2d981b4fa4b444
Binary files /dev/null and b/Data/inputdata_avatarmodel_P7.mat differ
diff --git a/Data/inputdata_avatarmodel_P70.mat b/Data/inputdata_avatarmodel_P70.mat
new file mode 100644
index 0000000000000000000000000000000000000000..aa56a277970d92b79c5e05ef308140cfbdac7278
Binary files /dev/null and b/Data/inputdata_avatarmodel_P70.mat differ
diff --git a/Data/inputdata_avatarmodel_P71.mat b/Data/inputdata_avatarmodel_P71.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f1e3d4cb6a39b6f38b79518301d3e834b6f7af39
Binary files /dev/null and b/Data/inputdata_avatarmodel_P71.mat differ
diff --git a/Data/inputdata_avatarmodel_P72.mat b/Data/inputdata_avatarmodel_P72.mat
new file mode 100644
index 0000000000000000000000000000000000000000..aff128c01bbed0117708d318fa65850cb871f065
Binary files /dev/null and b/Data/inputdata_avatarmodel_P72.mat differ
diff --git a/Data/inputdata_avatarmodel_P73.mat b/Data/inputdata_avatarmodel_P73.mat
new file mode 100644
index 0000000000000000000000000000000000000000..eeba81e9cfcc6068c520c668cc44e6a69adba6e6
Binary files /dev/null and b/Data/inputdata_avatarmodel_P73.mat differ
diff --git a/Data/inputdata_avatarmodel_P74.mat b/Data/inputdata_avatarmodel_P74.mat
new file mode 100644
index 0000000000000000000000000000000000000000..dc18a0e3bc7c3441c2233bc97b79eec651c13e63
Binary files /dev/null and b/Data/inputdata_avatarmodel_P74.mat differ
diff --git a/Data/inputdata_avatarmodel_P75.mat b/Data/inputdata_avatarmodel_P75.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8016964d095489fae10545fff8c07d179b883532
Binary files /dev/null and b/Data/inputdata_avatarmodel_P75.mat differ
diff --git a/Data/inputdata_avatarmodel_P76.mat b/Data/inputdata_avatarmodel_P76.mat
new file mode 100644
index 0000000000000000000000000000000000000000..58a20fc663efe9a02dd2740457f2c1e361fc7f88
Binary files /dev/null and b/Data/inputdata_avatarmodel_P76.mat differ
diff --git a/Data/inputdata_avatarmodel_P77.mat b/Data/inputdata_avatarmodel_P77.mat
new file mode 100644
index 0000000000000000000000000000000000000000..fbc584a85224d8fc3e50dad38d948bbffd93decf
Binary files /dev/null and b/Data/inputdata_avatarmodel_P77.mat differ
diff --git a/Data/inputdata_avatarmodel_P78.mat b/Data/inputdata_avatarmodel_P78.mat
new file mode 100644
index 0000000000000000000000000000000000000000..b0389ad3443de3f41421e634e7762b053cbd5116
Binary files /dev/null and b/Data/inputdata_avatarmodel_P78.mat differ
diff --git a/Data/inputdata_avatarmodel_P79.mat b/Data/inputdata_avatarmodel_P79.mat
new file mode 100644
index 0000000000000000000000000000000000000000..2d6d3c3d0524e34be040d66e3f24789109b28155
Binary files /dev/null and b/Data/inputdata_avatarmodel_P79.mat differ
diff --git a/Data/inputdata_avatarmodel_P8.mat b/Data/inputdata_avatarmodel_P8.mat
new file mode 100644
index 0000000000000000000000000000000000000000..388abaab9df37dafa78ff53547f0b89496eeb98d
Binary files /dev/null and b/Data/inputdata_avatarmodel_P8.mat differ
diff --git a/Data/inputdata_avatarmodel_P80.mat b/Data/inputdata_avatarmodel_P80.mat
new file mode 100644
index 0000000000000000000000000000000000000000..4e0753f650c112b14bca78a823e6769b7f1188ab
Binary files /dev/null and b/Data/inputdata_avatarmodel_P80.mat differ
diff --git a/Data/inputdata_avatarmodel_P9.mat b/Data/inputdata_avatarmodel_P9.mat
new file mode 100644
index 0000000000000000000000000000000000000000..a052a9073e7e6c37bf9fe921928a4dc99b091008
Binary files /dev/null and b/Data/inputdata_avatarmodel_P9.mat differ
diff --git a/Data/scapisdata_HEALTH.mat b/Data/scapisdata_HEALTH.mat
new file mode 100644
index 0000000000000000000000000000000000000000..165c234994c6260a24cfc819f845d05199ef6d9a
Binary files /dev/null and b/Data/scapisdata_HEALTH.mat differ
diff --git a/Modelfiles/GenerateModels.m b/Modelfiles/GenerateModels.m
new file mode 100644
index 0000000000000000000000000000000000000000..674126d9860d37bbe0b190de57664502ed897b2f
--- /dev/null
+++ b/Modelfiles/GenerateModels.m
@@ -0,0 +1,13 @@
+% Compile model files into mexfiles
+% This automatically creates the files: amai_avatar_HEALTH_fast.mex.. and simulate_avatar_HEALTH_fast.m
+clear 
+clear mex
+startup
+
+path = pwd;
+
+amiwrap('avatar_HEALTH_fast','avatar_HEALTH_syms_fast',path); 
+
+disp('model generated')
+
+
diff --git a/Modelfiles/ami_avatar_HEALTH_fast.mexw64 b/Modelfiles/ami_avatar_HEALTH_fast.mexw64
new file mode 100644
index 0000000000000000000000000000000000000000..68afb9baa7dfd88b13ddaf20647859e258f56c07
Binary files /dev/null and b/Modelfiles/ami_avatar_HEALTH_fast.mexw64 differ
diff --git a/Modelfiles/avatar_HEALTH_syms_fast.m b/Modelfiles/avatar_HEALTH_syms_fast.m
new file mode 100644
index 0000000000000000000000000000000000000000..61727fb643726b70f1b091be908cd647b0403449
--- /dev/null
+++ b/Modelfiles/avatar_HEALTH_syms_fast.m
@@ -0,0 +1,173 @@
+function [model] = avatar_HEALTH_syms_fast()
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'lin';
+
+%%
+% STATES
+% create state syms 
+syms Ppvc Qpv Vla Qmv Vlv Qav Paa Qaa Ppc mv_open av_open
+% create state vector
+model.sym.x = [Ppvc Qpv Vla Qmv Vlv Qav Paa Qaa Ppc mv_open av_open];
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms        
+syms Cpvc Rpu Rpv Lpv Rtot Ctot ElCo Caa Emax_LA Emax_LV Emin_LA Emin_LV Lao Lav Lmv Ppu Rao Rmv k_diast_LA k_diast_LV k_syst_LA k_syst_LV m1_LA m1_LV m2_LA m2_LV onset_LA onset_LV
+% create parameter vector 
+model.sym.p = [Cpvc Rpu Rpv Lpv Rtot Ctot ElCo Caa Emax_LA Emax_LV Emin_LA Emin_LV Lao Lav Lmv Ppu Rao Rmv k_diast_LA k_diast_LV k_syst_LA k_syst_LV m1_LA m1_LV m2_LA m2_LV onset_LA onset_LV];
+%%  
+% CONSTANTS ( for these no sensitivities will be computed )
+
+% create constant parameter syms
+syms  aaCorr avCorr mvCorr tdiast Ks_LA Ks_LV  V0_LA V0_LV RLAvisc RLVvisc Raa Rpc Rpvc T rho_blood norm_factor_LA norm_factor_LV
+
+% create constant parameter vector  
+model.sym.k = [ aaCorr avCorr mvCorr tdiast Ks_LA Ks_LV  V0_LA V0_LV RLAvisc RLVvisc Raa Rpc Rpvc T rho_blood norm_factor_LA norm_factor_LV];
+
+%%
+% SYSTEM EQUATIONS
+% create symbolic variable for time
+syms t 
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+%% Elastance equations
+syms P_LA P_LV
+
+Ts_LA = k_syst_LA*T;
+Td_LA = k_diast_LA*T;
+ula = t - onset_LA*T;
+
+Ts_LV = k_syst_LV*T;
+Td_LV = k_diast_LV*T;
+ulv = t - onset_LV*T;
+
+nLV = am_if(am_gt(ulv,T),1,0) + am_if(am_gt(ulv,T*2),1,0);
+tlv = ulv - nLV*T;
+g1_LV = (tlv/Ts_LV)^m1_LV;
+g2_LV = (tlv/Td_LV)^m2_LV;
+Elv = (1/norm_factor_LV)*(Emax_LV-Emin_LV)*(g1_LV/(1+ g1_LV)) *(1./(1 + g2_LV)) + Emin_LV;
+
+nLA = am_if(am_gt(ula,T),1,0) + am_if(am_gt(ula,T*2),1,0);
+tla = ula - nLA*T;
+g1_LA = (tla/Ts_LA)^m1_LA;
+g2_LA = (tla/Td_LA)^m2_LA;
+Ela = (1/norm_factor_LA)*(Emax_LA-Emin_LA)*(g1_LA/(1+ g1_LA)) *(1/(1 + g2_LA)) + Emin_LA;
+
+qLA = Qpv - Qmv;
+P_LA = Ela*(Vla - V0_LA)*(1-Ks_LA*qLA);
+
+qLV = Qmv - Qav;
+P_LV = Elv*(Vlv - V0_LV)*(1-Ks_LV*qLV);
+
+%% Pulmonary venous system
+model.sym.xdot(1) = (Ppu - Rpu*Qpv - Ppvc)/(Cpvc*(Rpu + Rpvc)); % Ppvc pulm pressure change
+Qpvc = ((Ppu - Rpu*Qpv - Ppvc)/(Rpu + Rpvc));
+model.sym.xdot(2) = (Ppvc + Rpvc*Qpvc - Rpv*Qpv - P_LA)/Lpv; %Qpv pulm flow change
+
+P_Pulmvein =P_LA + Qpv*Rpv;
+
+%% Left atrium
+model.sym.xdot(3) = Qpv - Qmv; %Vla
+
+%% Mitral valve
+Vf =0.00001;
+Ron = 0.00001; %1.0000e-05
+Goff = 1e-08;
+Pvalve = Vf*(1-Ron*Goff);%1.0000e-05
+
+P_Dmv = mv_open*(Qmv*Ron + Pvalve)  + (1-mv_open)*(Qmv*(1/Goff));
+model.sym.xdot(4) = (P_LA - (RLAvisc+Rmv)*Qmv - P_Dmv - P_LV)/Lmv;%Qmv
+
+%% Left ventricle
+model.sym.xdot(5) = Qmv-Qav ; % Vlv
+
+%% Aortic valve
+%ElCo = (EOA_av*A_ao)/(A_ao-EOA_av);
+Rav = Qav * rho_blood/(2*ElCo^2)* (0.06/133.322);
+Qcaa = Qav - Qaa;
+
+P_Dav = av_open*(Qav*Ron + Pvalve)  + (1-av_open)*(Qav*(1/Goff));
+model.sym.xdot(6) = (P_LV - (RLVvisc+Rav)*Qav - P_Dav - Raa*Qcaa - Paa)/Lav; %Qav
+
+
+%% Ascending aorta
+model.sym.xdot(7) = (Qav-Qaa)/Caa; %Paa 
+P_Aortic = Raa*(Qav - Qaa)  + Paa; %Raa constant
+Cpc = Ctot-Caa;
+Rpr = Rtot-Rao;
+Qpc = (Qaa*Rpr - Ppc)/(Rpr+Rpc);
+model.sym.xdot(8) = (Paa + Raa*Qcaa - Rao*Qaa - Rpc*Qpc - Ppc)/Lao; %Qaa
+
+
+P_Brachial = P_Aortic;%conversion of SBP using SBPdiff is done outside the model
+
+%% Peripheral arteries/Vascular bed
+model.sym.xdot(9) = (Qaa*Rpr - Ppc)/(Cpc*(Rpr+Rpc));   %Ppc
+Pperipheral = Ppc + Rpc*Qpc;
+
+model.sym.xdot(10) = 0;%mv_open
+model.sym.xdot(11) = 0;%av_open
+
+%%
+% INITIAL CONDITIONS
+% Ppvc Qpv Vla Qmv Vlv Qav Paa Qaa Ppc 
+model.sym.x0(1) = 10.6845;
+model.sym.x0(2) = 11.3164;
+model.sym.x0(3) = 89.4388; %LA
+model.sym.x0(4) = 11.3164;
+model.sym.x0(5) = 17.5520; % LV
+model.sym.x0(6) = 11.3164;
+model.sym.x0(7) = 10.6218;
+model.sym.x0(8) = 11.3164;
+model.sym.x0(9) = 9.7165; %Ppc
+model.sym.x0(10) = 1;
+model.sym.x0(11) = 1;
+
+model.sym.dx0 = sym(zeros(size(model.sym.x)));
+
+
+% OBSERVALES
+%'P ascAo','P peripheral','Pressgrad MV calc','Dmv','mv_open','Dav','av open','pressgrad AV calc','Ela','Elv'
+model.sym.y = sym(zeros(25,1)); 
+model.sym.y(1) = P_Aortic;
+model.sym.y(2) = Pperipheral;
+model.sym.y(3) = P_LA - RLAvisc*Qmv - P_LV; %pressGrad_MV
+model.sym.y(4) = P_Dmv;
+model.sym.y(5) = mv_open;
+model.sym.y(6) = P_Dav;
+model.sym.y(7) = av_open;
+model.sym.y(8) = P_LV + RLVvisc*Qav + Raa*Caa*((Qav-Qaa)/Caa);%pressGrad_AV;
+model.sym.y(9) = Ela;
+model.sym.y(10) = Elv;
+model.sym.y(11) = Qcaa;
+model.sym.y(12) = Qpc;
+model.sym.y(13) = P_Pulmvein;
+model.sym.y(14) = Qpvc;
+model.sym.y(15) = qLA;
+model.sym.y(16) = qLV;
+model.sym.y(17) = P_LA;
+model.sym.y(18) = P_LV;
+model.sym.y(19) = Qaa + am_max(0,am_min(1,Qaa-5))*am_max(0,(tdiast-tlv)/abs(tdiast-tlv))*aaCorr;
+model.sym.y(20) = Qav + am_max(0,am_min(1,Qav-5))*am_max(0,(tdiast-tlv)/abs(tdiast-tlv))*avCorr;
+model.sym.y(21) = Qmv + am_max(0,am_min(1,Qmv-5))*am_max(0,(tlv-tdiast)/abs(tlv-tdiast))*mvCorr;
+model.sym.y(22) = Qpv; 
+model.sym.y(23) = Vla; 
+model.sym.y(24) = Vlv; 
+model.sym.y(25) = P_Brachial;
+
+%%
+%-- EVENTS
+%syms t
+
+% events fire when there is a -zero crossing of the root function
+% events are used to automatically open and close the valves
+%Ppvc Qpv Vla Qmv Vlv Qav Paa Qaa Ppc mv_open av_open
+
+model.event(1) = amievent(P_Dmv - Vf,[0 0 0 0 0 0 0 0 0 1 0],[]);
+model.event(2) = amievent(-P_Dmv + Vf,[0 0 0 0 0 0 0 0 0 -1 0],[]);
+model.event(3) = amievent(P_Dav - Vf,[0 0 0 0 0 0 0 0 0 0 1],[]);
+model.event(4) = amievent(-P_Dav + Vf,[0 0 0 0 0 0 0 0 0 0 -1],[]);
+
+end
\ No newline at end of file
diff --git a/Modelfiles/simulate_avatar_HEALTH_fast.m b/Modelfiles/simulate_avatar_HEALTH_fast.m
new file mode 100644
index 0000000000000000000000000000000000000000..fc3febd82fccf526dbc7b0a5237fb4b73f481a47
--- /dev/null
+++ b/Modelfiles/simulate_avatar_HEALTH_fast.m
@@ -0,0 +1,256 @@
+% simulate_avatar_HEALTH_fast.m is the matlab interface to the cvodes mex
+%   which simulates the ordinary differential equation and respective
+%   sensitivities according to user specifications.
+%   this routine was generated using AMICI commit # in branch unknown branch in repo unknown repository.
+%
+% USAGE:
+% ======
+% [...] = simulate_avatar_HEALTH_fast(tout,theta)
+% [...] = simulate_avatar_HEALTH_fast(tout,theta,kappa,data,options)
+% [status,tout,x,y,sx,sy] = simulate_avatar_HEALTH_fast(...)
+%
+% INPUTS:
+% =======
+% tout ... 1 dimensional vector of timepoints at which a solution to the ODE is desired
+% theta ... 1 dimensional parameter vector of parameters for which sensitivities are desired.
+%           this corresponds to the specification in model.sym.p
+% kappa ... 1 dimensional parameter vector of parameters for which sensitivities are not desired.
+%           this corresponds to the specification in model.sym.k
+% data ... struct containing the following fields:
+%     Y ... 2 dimensional matrix containing data.
+%           columns must correspond to observables and rows to time-points
+%     Sigma_Y ... 2 dimensional matrix containing standard deviation of data.
+%           columns must correspond to observables and rows to time-points
+%     T ... (optional) 2 dimensional matrix containing events.
+%           columns must correspond to event-types and rows to possible event-times
+%     Sigma_T ... (optional) 2 dimensional matrix containing standard deviation of events.
+%           columns must correspond to event-types and rows to possible event-times
+% options ... additional options to pass to the cvodes solver. Refer to the cvodes guide for more documentation.
+%    .atol ... absolute tolerance for the solver. default is specified in the user-provided syms function.
+%        default value is 1e-16
+%    .rtol ... relative tolerance for the solver. default is specified in the user-provided syms function.
+%        default value is 1e-8
+%    .maxsteps    ... maximal number of integration steps. default is specified in the user-provided syms function.
+%        default value is 1e4
+%    .tstart    ... start of integration. for all timepoints before this, values will be set to initial value.
+%        default value is 0
+%    .sens_ind ... 1 dimensional vector of indexes for which sensitivities must be computed.
+%        default value is 1:length(theta).
+%    .x0 ... user-provided state initialisation. This should be a vector of dimension [#states, 1].
+%        default is state initialisation based on the model definition.
+%    .sx0 ... user-provided sensitivity initialisation. this should be a matrix of dimension [#states x #parameters].
+%        default is sensitivity initialisation based on the derivative of the state initialisation.
+%    .lmm    ... linear multistep method for forward problem.
+%        1: Adams-Bashford
+%        2: BDF (DEFAULT)
+%    .iter    ... iteration method for linear multistep.
+%        1: Functional
+%        2: Newton (DEFAULT)
+%    .linsol   ... linear solver module.
+%        direct solvers:
+%        1: Dense
+%        2: Band (not implemented)
+%        3: LAPACK Dense (not implemented)
+%        4: LAPACK Band  (not implemented)
+%        5: Diag (not implemented)
+%        implicit krylov solvers:
+%        6: SPGMR
+%        7: SPBCG
+%        8: SPTFQMR
+%        sparse solvers:
+%        9: KLU (DEFAULT)
+%    .stldet   ... flag for stability limit detection. this should be turned on for stiff problems.
+%        0: OFF
+%        1: ON (DEFAULT)
+%    .sensi   ... sensitivity order.
+%        0: OFF (DEFAULT)
+%        1: first
+%        2: second
+%    .sensi_meth   ... method for sensitivity analysis.
+%        0: no sensitivity analysis
+%        1 or 'forward': forward sensitivity analysis (DEFAULT)
+%        2 or 'adjoint': adjoint sensitivity analysis 
+%        3 or 'ss': defined but not documented 
+%    .adjoint   ... flag for adjoint sensitivity analysis.
+%        true: on 
+%        false: off (DEFAULT)
+%        NO LONGER USED: Replaced by sensi_meth
+%    .ism   ... only available for sensi_meth == 1. Method for computation of forward sensitivities.
+%        1: Simultaneous (DEFAULT)
+%        2: Staggered
+%        3: Staggered1
+%    .Nd   ... only available for sensi_meth == 2. Number of Interpolation nodes for forward solution. 
+%        default is 1000. 
+%    .interpType   ... only available for sensi_meth == 2. Interpolation method for forward solution.
+%        1: Hermite (DEFAULT for problems without discontinuities)
+%        2: Polynomial (DEFAULT for problems with discontinuities)
+%    .ordering   ... online state reordering.
+%        0: AMD reordering (default)
+%        1: COLAMD reordering
+%        2: natural reordering
+%    .newton_maxsteps   ... maximum newton steps
+%        default value is 40
+%        a value of 0 will disable the newton solver
+%    .newton_maxlinsteps   ... maximum linear steps
+%        default value is 100
+%    .newton_preeq   ... preequilibration of system via newton solver
+%        default value is false
+%    .pscale   ... parameter scaling
+%        []: (DEFAULT) use value specified in the model (fallback: 'lin')
+%        0 or 'lin': linear
+%        1 or 'log': natural log (base e)
+%        2 or 'log10': log to the base 10
+%
+% Outputs:
+% ========
+% sol.status ... flag for status of integration. generally status<0 for failed integration
+% sol.t ... vector at which the solution was computed
+% sol.llh ... likelihood value
+% sol.chi2 ... chi2 value
+% sol.sllh ... gradient of likelihood
+% sol.s2llh ... hessian or hessian-vector-product of likelihood
+% sol.x ... time-resolved state vector
+% sol.y ... time-resolved output vector
+% sol.sx ... time-resolved state sensitivity vector
+% sol.sy ... time-resolved output sensitivity vector
+% sol.z ... event output
+% sol.sz ... sensitivity of event output
+function varargout = simulate_avatar_HEALTH_fast(varargin)
+
+% DO NOT CHANGE ANYTHING IN THIS FILE UNLESS YOU ARE VERY SURE ABOUT WHAT YOU ARE DOING
+% MANUAL CHANGES TO THIS FILE CAN RESULT IN WRONG SOLUTIONS AND CRASHING OF MATLAB
+if(nargin<2)
+    error('Not enough input arguments.');
+else
+    tout=varargin{1};
+    theta=varargin{2};
+end
+if(nargin>=3)
+    kappa=varargin{3};
+else
+    kappa=[];
+end
+
+if(length(theta)<28)
+    error('provided parameter vector is too short');
+end
+
+
+xscale = [];
+if(nargin>=5)
+    if(isa(varargin{5},'amioption'))
+        options_ami = varargin{5};
+    else
+        options_ami = amioption(varargin{5});
+    end
+else
+    options_ami = amioption();
+end
+if(isempty(options_ami.sens_ind))
+    options_ami.sens_ind = 1:28;
+end
+if(options_ami.sensi>1)
+    error('Second order sensitivities were requested but not computed');
+end
+
+if(isempty(options_ami.pscale))
+    options_ami.pscale = 'lin' ;
+end
+if(nargout>1)
+    if(nargout>4)
+        options_ami.sensi = 1;
+        options_ami.sensi_meth = 'forward';
+    else
+        options_ami.sensi = 0;
+    end
+end
+nplist = length(options_ami.sens_ind); % MUST NOT CHANGE THIS VALUE
+if(nplist == 0)
+    options_ami.sensi = 0;
+end
+nxfull = 11;
+plist = options_ami.sens_ind-1;
+if(nargin>=4)
+    if(isempty(varargin{4}))
+        data=[];
+    else
+        if(isa(varargin{4},'amidata'))
+             data=varargin{4};
+        else
+            data=amidata(varargin{4});
+        end
+        if(data.ne>0)
+            options_ami.nmaxevent = data.ne;
+        else
+            data.ne = options_ami.nmaxevent;
+        end
+        if(isempty(kappa))
+            kappa = data.condition;
+        end
+        if(isempty(tout))
+            tout = data.t;
+        end
+    end
+else
+    data=[];
+end
+if(~all(tout==sort(tout)))
+    error('Provided time vector is not monotonically increasing!');
+end
+if(max(options_ami.sens_ind)>28)
+    error('Sensitivity index exceeds parameter dimension!')
+end
+if(length(kappa)<17)
+    error('provided condition vector is too short');
+end
+init = struct();
+if(~isempty(options_ami.x0))
+    if(size(options_ami.x0,2)~=1)
+        error('x0 field must be a column vector!');
+    end
+    if(size(options_ami.x0,1)~=nxfull)
+        error('Number of rows in x0 field does not agree with number of states!');
+    end
+    init.x0 = options_ami.x0;
+end
+if(~isempty(options_ami.sx0))
+    if(size(options_ami.sx0,2)~=nplist)
+        error('Number of columns in sx0 field does not agree with number of model parameters!');
+    end
+    if(size(options_ami.sx0,1)~=nxfull)
+        error('Number of rows in sx0 field does not agree with number of states!');
+    end
+end
+sol = ami_avatar_HEALTH_fast(tout,theta(1:28),kappa(1:17),options_ami,plist,xscale,init,data);
+if(nargout>1)
+    varargout{1} = sol.status;
+    varargout{2} = sol.t;
+    varargout{3} = sol.x;
+    varargout{4} = sol.y;
+    if(nargout>4)
+        varargout{5} = sol.sx;
+        varargout{6} = sol.sy;
+    end
+else
+    varargout{1} = sol;
+end
+function chainRuleFactors = getChainRuleFactors(pscale, theta, sens_ind)
+    if(length(pscale) == 1 && length(sens_ind) ~= length(pscale))
+        chainRuleFactors = arrayfun(@(x, ip) getChainRuleFactor(x, theta(ip)), repmat(pscale, 1, length(sens_ind)), sens_ind);
+    else
+        chainRuleFactors = arrayfun(@(x, ip) getChainRuleFactor(x, theta(ip)), pscale, sens_ind);
+    end
+end
+
+function chainRuleFactor = getChainRuleFactor(pscale, parameterValue)
+    switch (pscale)
+        case 1
+            chainRuleFactor = exp(parameterValue);
+        case 2
+            chainRuleFactor = 10.^parameterValue*log(10);
+        otherwise
+            chainRuleFactor = 1.0;
+    end
+end
+
+end
diff --git a/Modelfiles/startup.m b/Modelfiles/startup.m
new file mode 100644
index 0000000000000000000000000000000000000000..f9143aed3259f08acd07baadd5bde8391df30e29
--- /dev/null
+++ b/Modelfiles/startup.m
@@ -0,0 +1,7 @@
+%% Adds paths to toolboxes needed for simulations
+addpath('..\Requirements\PESTO-1.1.0')
+addpath('..\Requirements\AMICI-0.10.11_SS_eventFix\matlab')
+addpath('..\Requirements\MEIGO')
+
+run('..\Requirements\AMICI-0.10.11_SS_eventFix\matlab\installAMICI.m')
+run('..\Requirements\MEIGO\install_MEIGO.m')
\ No newline at end of file
diff --git a/Optimization/EstimateParametersESS_HEALTH.m b/Optimization/EstimateParametersESS_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..08d2c2be3453648b2caeb79d834df807f5174c3d
--- /dev/null
+++ b/Optimization/EstimateParametersESS_HEALTH.m
@@ -0,0 +1,167 @@
+function [] =  EstimateParametersESS_HEALTH(loopNumber,dateStart,patientNums,modelName,patrange,dataFolder,randomstart)
+%% Setup
+s=rng('shuffle'); %do not note remove this line
+d = datestr(now,'YYmmDD-HHMMSSFFF'); %creating different seed for each start
+s=rng(s.Seed+loopNumber*sum(d)); %do not note remove this line
+
+pathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+pathbase = [pathbase{1},filesep, 'cardiovascularavatar_T2D_HT'];
+
+addpath(genpath(pathbase))
+addpath([pathbase filesep 'Parameters'])
+addpath([pathbase filesep 'Modelfiles'])
+
+addpath([pathbase filesep 'Requirements' filesep 'PESTO-1.1.0'])
+addpath([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab'])
+addpath([pathbase filesep 'Requirements' filesep 'MEIGO'])
+
+run([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab' filesep 'installAMICI.m'])
+run([pathbase filesep 'Requirements' filesep 'MEIGO' filesep 'install_MEIGO.m'])
+
+%% Choose which subject to simulate based on the range of subjects and which loop number you are in
+patientNums = findPatientRange(patientNums,patrange,dataFolder);
+num = mod(loopNumber,length(patientNums))+1;
+patientNum = patientNums{num};
+disp(['----------------------- P' patientNum ' ---------------------------------'])
+
+
+if randomstart
+    disp('Random start')
+    randomstring = 'random';
+    numRepeats = 5; % number of repetitions of running ESS optimizaton - don't run too much in case you are stuck in a terrible solution
+else
+    disp('No random start')
+    randomstring = 'loaded';
+    numRepeats = 20; % number of repetitions of running ESS optimizaton - run until not improving enough
+end
+
+%% ESS options
+% MEIGO OPTIONS I (COMMON TO ALL SOLVERS):
+opts.ndiverse     = 'auto'; %100; %500; %5; %
+opts.maxtime      = 600; % MAX-Time of optmization, i.e how long the optimization will last %Maximum CPU time in seconds (Default 60)
+opts.maxeval      = 1e8; % max number of evals, i.e cost function calls (Default 1000)
+opts.log_var      = [];  %skip this
+
+opts.local.solver = 'dhc'; %'dhc'; %'fmincon'; %'nl2sol'; %'mix'; % local solver, fmincon works in my experience best
+opts.local.finish = opts.local.solver; %uses the local solver to check the best p-vector
+opts.local.bestx = 0; % read the documentation, think it's best to leave at zero for now.
+problem.f   = 'costFunction_HEALTH'; % %name of cost-function
+opts.iterprint = 0;
+
+% MEIGO OPTIONS II (FOR ESS AND MULTISTART):
+opts.local.iterprint = 0; % prints what going on during optimization
+
+% MEIGO OPTIONS III (FOR ESS ONLY):
+opts.dim_refset   = 'auto'; % leave to auto for now
+
+% OPTIONS AUTOMATICALLY SET AS A RESULT OF PREVIOUS OPTIONS:
+if(strcmp(opts.local.solver,'fmincon'))
+    opts.local.use_gradient_for_finish = 1; %DW: provide gradient to fmincon
+else
+    opts.local.use_gradient_for_finish = 0; %DW: provide gradient to fmincon
+end
+opts.local.check_gradient_for_finish = 0; %DW: gradient checker
+
+
+%% Load parameters and data
+resultsfolder = [pathbase filesep 'Parameters' filesep 'ESS'];
+[~,data,~,~,constants,paramNames,constantsNames,ynames,xnames,simOptions,ind,origParamvalues] = setup_simulations_HEALTH({patientNum},resultsfolder,1);
+% settings for the cost function:
+numHeartBeats = 20;
+doPlot = 0;
+dispErrors = 0;
+%% Set bounds (separate for each subject, since paramdata is individual)
+[lbOrig,ubOrig] = loadParamBounds_HEALTH(ind,data.params);
+lb = log10(lbOrig);
+ub = log10(ubOrig);
+problem.x_L       = lb; % essOPT uses a problem structure where crucial information is specified
+problem.x_U       = ub;
+
+%% Find startguess
+loadsummaryfile=0;
+folders = dir(fullfile(pathbase,'Parameters','ESS',['P' patientNum '_*']));
+[~,latestfolderInd] = max([folders.datenum]);
+foldernames = {folders.name};
+folderpaths = {folders.folder};
+currentResultsFolder = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd})
+if ~randomstart
+    [optParam,loadedoptcost,~,loadedconstants] = findBestParams(currentResultsFolder,loadsummaryfile,length(paramNames)); %load from current results folder
+end
+if ~randomstart && sum(isnan(optParam))==0 %if there are current results and random start is not applied 
+    fprintf('Estimateparameters: Loaded startguess from current results folder with cost %0.2f\n',loadedoptcost)
+    optParam = optParam.*(rand(1, length(optParam))./20+0.975); %add small random change in the loaded parametes (+-2.5% at max)
+else 
+    folders = dir(fullfile('Parameters','ESS',['P' patientNum '*_']));
+    if randomstart || isempty(folders) || length(folders) < 2 %load random start guess
+        nParams = length(lb);
+        optParam=(ubOrig-lbOrig).*rand(1, nParams)+lbOrig;
+        disp('Estimateparameters: Loaded random startguess')
+%         optParam = origParamvalues.*(rand(1, length(origParamvalues))./8+0.9375);
+%         disp('Estimateparameters: Loaded random startguess based on origParamvalues')
+    else % load from a previous optimization
+        [~,latestfolderInd] = max([folders.datenum]);
+        latestfolderInd = latestfolderInd+1; %not the latest = this opt, but the one before
+        if latestfolderInd > length(folders)
+            latestfolderInd = latestfolderInd-2;
+        end
+        foldernames = {folders.name};
+        folderpaths = {folders.folder};
+        loadfolderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+        [optParam,loadedoptcost,~,loadedconstants] = findBestParams(loadfolderName,loadsummaryfile,length(paramNames));
+        fprintf('Estimateparameters: Loaded paramvalues with cost %0.2f from %s\n',loadedoptcost,loadfolderName)
+        optParam = optParam.*(rand(1, length(optParam))./8+0.9375);% +-6.25% at max
+    end
+end
+
+optParam = max(optParam,lbOrig);%make sure the startguess is within the bounds
+optParam = min(optParam,ubOrig);%make sure the startguess is within the bounds
+allparams = optParam;
+ind.estParams = 1:length(allparams);
+
+optParam = log10(optParam);
+optParam = max(optParam,lb);%make sure the startguess is within the bounds
+optParam = min(optParam,ub);%make sure the startguess is within the bounds
+problem.x_0=optParam;
+
+%% Run optimization
+format long
+format compact
+warning('off','all') % AMICI prints error-messages for all simulations (if they fail) so this will fix that annoying orange text form appearing
+save(sprintf('%s/testsave-%i%s-%s.mat',currentResultsFolder,loopNumber,randomstring,dateStart) ,'dateStart')
+for r = 1:numRepeats
+    disp(['-----P' patientNum 'repetition num' num2str(r) ' of ' num2str(numRepeats) ' -----------------------'])
+    
+    %% Solve with ESS
+    optim_algorithm = 'ess';
+    Results = MEIGO(problem,opts,optim_algorithm,constants,allparams,simOptions,numHeartBeats,data,ind,dispErrors,doPlot); % Run the optimization
+    %% Save results
+    fitting_speed     = Results.time(end);
+    bestcost          = Results.fbest;
+    optParam          = Results.xbest;
+    
+    %update the start guess
+    problem.x_0=optParam;
+    
+    % Save the results.
+    optParam = 10.^(optParam); % scale bestparam back to it's original size
+    bounds.lb = 10.^lb;
+    bounds.ub = 10.^ub;
+    dateEnd = datestr(now,'yymmdd-HHMMSS');
+    save(sprintf('%s%sopt-ESS(%.3f)-%i%s-r%i.mat',currentResultsFolder,filesep,bestcost,loopNumber,randomstring,r) ,'optParam','bestcost','bounds','constants','ind','paramNames','simOptions','dateStart','dateEnd','fitting_speed','modelName','s','Results','problem')
+    
+    %exit after 2 rounds if cost is not improving enough or after 1 round if much
+    %worse than the loaded cost
+    if ~randomstart && bestcost - loadedoptcost > 2
+        break
+    elseif r>1 && randomstart && bestcost-prevcost > -0.001
+        break
+    elseif r>1 && ~randomstart && (bestcost - loadedoptcost > 0.001 || bestcost-prevcost > -0.001)
+        break
+    else
+        prevcost = bestcost;
+    end
+end
+warning ('on','all'); % yay error messages again
+
+
+end
diff --git a/Optimization/EstimateParametersESS_HEALTH_lastrun.m b/Optimization/EstimateParametersESS_HEALTH_lastrun.m
new file mode 100644
index 0000000000000000000000000000000000000000..87443531188ecc53670ee5e4290b04da60211160
--- /dev/null
+++ b/Optimization/EstimateParametersESS_HEALTH_lastrun.m
@@ -0,0 +1,126 @@
+function [] =  EstimateParametersESS_HEALTH_lastrun(loopNumber,dateStart,patientNums,modelName,patrange,dataFolder)
+s=rng('shuffle'); %do not note remove this line
+d = datestr(now,'YYmmDD-HHMMSSFFF'); %creating different seed for each start
+s=rng(s.Seed+loopNumber*sum(d)); %do not note remove this line
+
+pathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+pathbase = [pathbase{1},filesep, 'cardiovascularavatar_T2D_HT'];
+
+addpath(genpath(pathbase))
+addpath([pathbase filesep 'Parameters'])
+addpath([pathbase filesep 'Modelfiles'])
+
+addpath([pathbase filesep 'Requirements' filesep 'PESTO-1.1.0'])
+addpath([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab'])
+addpath([pathbase filesep 'Requirements' filesep 'MEIGO'])
+
+run([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab' filesep 'installAMICI.m'])
+run([pathbase filesep 'Requirements' filesep 'MEIGO' filesep 'install_MEIGO.m'])
+
+
+patientNums = findPatientRange(patientNums,patrange,dataFolder);
+num = mod(loopNumber,length(patientNums))+1;
+patientNum = patientNums{num};
+disp(['-----------------------LAST RUN P' patientNum ' ---------------------------------'])
+
+
+%% ESS options
+% MEIGO OPTIONS I (COMMON TO ALL SOLVERS):
+opts.ndiverse     = 'auto'; %100; %500; %5; %
+opts.maxtime      = 3600; % MAX-Time of optmization, i.e how long the optimization will last %3600=1h
+opts.maxeval      = 1e8; % max number of evals, i.e cost function calls
+opts.log_var      = [];  %skip this
+
+opts.local.solver = 'dhc'; %'dhc'; %'fmincon'; %'nl2sol'; %'mix'; % local solver, fmincon works in my experience best
+opts.local.finish = opts.local.solver; %uses the local solver to check the best p-vector
+opts.local.bestx = 0; % read the documentation, think it's best to leave at zero for now.
+problem.f   = 'costFunction_HEALTH'; % %name of cost-function
+opts.iterprint = 0;
+
+% MEIGO OPTIONS II (FOR ESS AND MULTISTART):
+opts.local.iterprint = 0; % prints what going on during optimization
+
+% MEIGO OPTIONS III (FOR ESS ONLY):
+opts.dim_refset   = 'auto'; % leave to auto for now
+
+% OPTIONS AUTOMATICALLY SET AS A RESULT OF PREVIOUS OPTIONS:
+if(strcmp(opts.local.solver,'fmincon'))
+    opts.local.use_gradient_for_finish = 1; %DW: provide gradient to fmincon
+else
+    opts.local.use_gradient_for_finish = 0; %DW: provide gradient to fmincon
+end
+opts.local.check_gradient_for_finish = 0; %DW: gradient checker
+
+
+%% Load parameters and data
+resultsfolder = [pathbase filesep 'Parameters' filesep 'ESS'];
+[~,data,~,~,constants,paramNames,constantsNames,ynames,xnames,simOptions,ind,origParamvalues] = setup_simulations_HEALTH({patientNum},resultsfolder,1);
+% settings for the cost function:
+numHeartBeats = 20;
+doPlot = 0;
+dispErrors = 0;
+%% Set bounds (separate for each subject, since paramdata is individual)
+[lbOrig,ubOrig] = loadParamBounds_HEALTH(ind,data.params);
+lb = log10(lbOrig);
+ub = log10(ubOrig);
+problem.x_L       = lb; % essOPT uses a problem structure where crucial information is specified
+problem.x_U       = ub;
+
+%% Find startguess
+loadsummaryfile=0;
+folders = dir(fullfile(pathbase,'Parameters','ESS',['P' patientNum '_*']));
+[~,latestfolderInd] = max([folders.datenum]);
+foldernames = {folders.name};
+folderpaths = {folders.folder};
+currentResultsFolder = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd})
+[optParam,loadedoptcost,~,loadedconstants] = findBestParams(currentResultsFolder,loadsummaryfile,length(paramNames)); %load from current results folder
+fprintf('Estimateparameters: Loaded startguess from current results folder with cost %0.2f\n',loadedoptcost)
+if sum(isnan(optParam))>0 % load from a previous optimization if current result is empty
+    disp('Current results folder empty')
+    [~,latestfolderInd] = max([folders.datenum]);
+    latestfolderInd = latestfolderInd+1; %not the latest = this opt, but the one before
+    if latestfolderInd > length(folders)
+        latestfolderInd = latestfolderInd-2;
+    end
+    foldernames = {folders.name};
+    folderpaths = {folders.folder};
+    loadfolderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+    [optParam,loadedoptcost,~,loadedconstants] = findBestParams(loadfolderName,loadsummaryfile,length(paramNames));
+    fprintf('Estimateparameters: Loaded startguess with cost %0.2f from %s\n',loadedoptcost,loadfolderName)
+end
+
+optParam = max(optParam,lbOrig);%make sure the startguess is within the bounds
+optParam = min(optParam,ubOrig);%make sure the startguess is within the bounds
+allparams = optParam;
+ind.estParams = 1:length(allparams);
+
+optParam = log10(optParam);
+optParam = max(optParam,lb);%make sure the startguess is within the bounds
+optParam = min(optParam,ub);%make sure the startguess is within the bounds
+problem.x_0=optParam;
+
+%% Run optimization
+format long
+format compact
+warning('off','all') % AMICI prints error-messages for all simulations (if they fail) so this will fix that annoying orange text form appearing
+save(sprintf('%s/testsave-%i%s-%s.mat',currentResultsFolder,loopNumber,'lastrun',dateStart) ,'dateStart')
+
+%% Solve with ESS
+optim_algorithm = 'ess'; % 'multistart'; %  'cess'; % ESS IS BEST EVAH
+Results = MEIGO(problem,opts,optim_algorithm,constants,allparams,simOptions,numHeartBeats,data,ind,dispErrors,doPlot); % Run the optimization
+%% Save results
+fitting_speed     = Results.time(end);
+bestcost          = Results.fbest;
+optParam          = Results.xbest;
+
+% Save the results.
+optParam = 10.^(optParam); % scale bestparam back to it's original size
+bounds.lb = 10.^lb;
+bounds.ub = 10.^ub;
+dateEnd = datestr(now,'yymmdd-HHMMSS');
+    save(sprintf('%s%sopt-ESS(%.3f)-%i%s-r%i.mat',currentResultsFolder,filesep,bestcost,loopNumber,randomstring,r) ,'optParam','bestcost','bounds','constants','ind','paramNames','simOptions','dateStart','dateEnd','fitting_speed','modelName','s','Results','problem')
+
+warning ('on','all'); % yay error messages again
+
+
+end
diff --git a/Optimization/EstimateParametersMCMC_HEALTH.m b/Optimization/EstimateParametersMCMC_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..c7c638c30d88aee954fd212c8711c1a842a31cbf
--- /dev/null
+++ b/Optimization/EstimateParametersMCMC_HEALTH.m
@@ -0,0 +1,217 @@
+function [] =  EstimateParametersMCMC_HEALTH(loopNumber,dateStart,patientNums,patrange,dataFolder,continueMCMC)
+%% Setup
+doMultiStart = 0;
+doSensitivites = 0;
+
+s=rng('shuffle'); %do not note remove this line
+d = datestr(now,'YYmmDD-HHMMSSFFF'); %creating different seed for each start
+rngSettings=rng(s.Seed+loopNumber*sum(d)); %do not note remove this line
+
+pathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+pathbase = [pathbase{1},filesep, 'cardiovascularavatar_T2D_HT'];
+
+addpath(genpath(pathbase))
+addpath([pathbase filesep 'Parameters'])
+addpath([pathbase filesep 'Modelfiles'])
+
+addpath([pathbase filesep 'Requirements' filesep 'PESTO-1.1.0'])
+addpath([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab'])
+addpath([pathbase filesep 'Requirements' filesep 'MEIGO'])
+
+run([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab' filesep 'installAMICI.m'])
+run([pathbase filesep 'Requirements' filesep 'MEIGO' filesep 'install_MEIGO.m'])
+
+%% Choose which subject to simulate based on the range of subjects and which loop number you are in
+patientNums = findPatientRange(patientNums,patrange,dataFolder);
+num = mod(loopNumber,length(patientNums))+1;
+patientNum = patientNums{num};
+disp(['----------------------- P' patientNum ' ---------------------------------'])
+
+%% Load parameters and data
+resultsFolder = [pathbase 'Parameters' filesep 'ESS'];
+[~,data,~,pvaluessetup,constants,paramNames,constantsNames,ynames,xnames,simOptions,ind,origParamvalues] = setup_simulations_HEALTH({patientNum},resultsFolder,1);
+% settings for the cost function:
+numHeartBeats = 20;
+doPlot = 0;
+dispErrors = 0;
+%% Set bounds (separate for each subject, since paramdata is individual)
+[lbOrig,ubOrig] = loadParamBounds_HEALTH(ind,data.params);
+lbOrig = lbOrig';%mcmc wants format n x 1
+ubOrig = ubOrig';
+lb = log10(lbOrig);
+ub = log10(ubOrig);
+parameters.min = lb;
+parameters.max = ub;
+parameters.name = paramNames';%mcmc wants format n x 1
+% the toolbox PESTO uses this parameters structure, list all parameters names for automatic plottning
+parameters.number = length(parameters.name); % number of parameters
+
+%% Find save folder
+savefolders = dir([pathbase filesep 'Parameters' filesep 'MCMC' filesep 'P' patientNum '_*']);
+[~,latestfolderInd] = max([savefolders.datenum]);
+foldernames = {savefolders.name};
+folderpaths = {savefolders.folder};
+savefolder = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd})
+
+%% MCMC options
+ % Options
+optionsPesto = PestoOptions();% loads optimization options and options for everything basically
+optionsPesto.obj_type = 'negative log-posterior';  % Works with least squares cost which we typically been using, i.e the goal is the minimize. so keep it as is
+optionsPesto.n_starts = 50; % number of multi-starts optimization performed
+optionsPesto.mode = 'visual'; %visual it will plot the results itteratively.    * 'text': optimization results for multi-start are printed on screen* 'silent': no output during the multi-start local optimization
+optionsPesto.comp_type = 'sequential'; % no parallel computing
+
+% Setup for how awesome you are, if using SBtoolbox, set =1, if using AMICI
+% and can return dJ/dp set =2, if superduper-awesome cool and can calculate
+% hessian, set to =3 (J=cost)
+% i.e, this is the number of output arguments you can have from your
+% objective-function, 1=cost only, 2=cost & dJ/dp, 3=cost &dJ/dp & hessian
+% (in that order).
+if doSensitivites
+    optionsPesto.objOutNumber=2;
+else
+    optionsPesto.objOutNumber=1;
+end
+    
+%% Markov Chain Monte Carlo sampling -- Parameters
+% Values for the parameters are sampled by using an Parallel Tempering (PT)
+% algorithm. This way, the underlying probability density of the parameter 
+% distribution can be captured. Since only one temperature is used, this is
+% effectively an adapted Metropolis algorithm single-chain algorithm.
+
+% Building a struct covering all sampling options:
+optionsPesto.MCMC = PestoSamplingOptions();
+optionsPesto.MCMC.nIterations = 1e5;% This is the most important setting, covering how many iterations to be performed, here i think the minimum is 1e5 and above, especially now, as we only want the really good (i.e significant) parameter vectors
+optionsPesto.MCMC.mode = optionsPesto.mode;
+
+optionsPesto.MCMC.saveEach = 1;
+if continueMCMC
+    continuenames = dir(sprintf('%s%sMCMCrun_P%s_*',savefolder,filesep,patientNum));
+    continuesavefile=fullfile(continuenames(1).folder,continuenames(1).name);
+    % OBS performRAMPART adds the .mat, if included here it can't find it
+    continuesavefile = strrep(continuesavefile,'.mat','');
+    fprintf('Continuing mcmc from file %s \n',continuesavefile)
+    optionsPesto.MCMC.saveFileName = continuesavefile;
+else
+    memory_address = system_dependent('getpid'); % create an unuqie name for the save file
+    optionsPesto.MCMC.saveFileName = sprintf('%s%sMCMCrun_P%s_%diter-%i%i',savefolder,filesep,patientNum,optionsPesto.MCMC.nIterations,loopNumber,memory_address);
+end
+optionsPesto.MCMC.PT.nTemps = parameters.number;
+
+%% Using RAMPART  Most of this should be left as is, however look in the file called RAMPARTOPTIONS in @RAMPARTOPTIONS folder to see what each setting does
+optionsPesto.MCMC.samplingAlgorithm     = 'RAMPART';
+optionsPesto.MCMC.RAMPART.nTemps           =  parameters.number;
+optionsPesto.MCMC.RAMPART.exponentT        = 1000;
+optionsPesto.MCMC.RAMPART.maxT             = 2000;
+optionsPesto.MCMC.RAMPART.alpha            = 0.51;
+optionsPesto.MCMC.RAMPART.temperatureNu    = 1e3;
+optionsPesto.MCMC.RAMPART.memoryLength     = 1;
+optionsPesto.MCMC.RAMPART.regFactor        = 1e-8;
+optionsPesto.MCMC.RAMPART.temperatureEta   = 10;
+
+optionsPesto.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+optionsPesto.MCMC.RAMPART.nTrainReplicates = 5;
+
+optionsPesto.MCMC.RAMPART.RPOpt.rng                  = 1;
+optionsPesto.MCMC.RAMPART.RPOpt.nSample              = floor(optionsPesto.MCMC.nIterations*optionsPesto.MCMC.RAMPART.trainPhaseFrac)-1;
+optionsPesto.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+optionsPesto.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:20;
+optionsPesto.MCMC.RAMPART.RPOpt.displayMode          = 'silent';%'text';
+optionsPesto.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+%       optionsPesto.MCMC.RAMPART.RPOpt.nDim                 = parameters.number;
+optionsPesto.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+%       optionsPesto.MCMC.RAMPART.RPOpt.lowerBound           = parameters.min;
+%       optionsPesto.MCMC.RAMPART.RPOpt.upperBound           = parameters.max;
+% tolMu & tolSigma --> Break if terminiation condition was reached before i == nAlg 'Terminated because movement tolerances were reached.'
+%       optionsPesto.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (parameters.max(1)-parameters.min(1));
+%       optionsPesto.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (parameters.max(1)-parameters.min(1));
+optionsPesto.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+%       optionsPesto.MCMC.RAMPART.RPOpt.isInformative        = [1,1,ones(1,optionsPesto.MCMC.RAMPART.RPOpt.nDim-2)];
+
+%% define rest of RAMPART settings
+optionsPesto.MCMC.RAMPART.RPOpt.isInformative        = ones(1,length(parameters.min)); %[1,1,ones(1,optionsPesto.MCMC.RAMPART.RPOpt.nDim-2)];
+optionsPesto.MCMC.RAMPART.RPOpt.nDim                 = parameters.number;
+optionsPesto.MCMC.RAMPART.RPOpt.lowerBound           = parameters.min;
+optionsPesto.MCMC.RAMPART.RPOpt.upperBound           = parameters.max;
+optionsPesto.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (parameters.max(1)-parameters.min(1));
+optionsPesto.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (parameters.max(1)-parameters.min(1));
+
+%%
+warning('off','all') % AMICI prints error-messages for all simulations (if they fail) so this will fix that annoying orange text form appearing
+format long
+format compact
+
+
+if doMultiStart
+    %% Performs the multi-start optimization (skip this if the results aren't great (i.e the same cost as you have in your optimal parameter set)
+    allparams = pvaluessetup;
+    ind.estParams = 1:length(allparams);
+    objectiveFunction = @(p) costFunction_HEALTH(p,constants,allparams,simOptions,numHeartBeats,data,ind,dispErrors,doPlot);
+    tic
+    parameters = getMultiStarts(parameters, objectiveFunction, optionsPesto);
+    timemultistart = toc
+    %% Here important part, these two lines are only valid if you have done the multi-start opt
+    optionsPesto.MCMC.theta0 = parameters.MS.par(:,1);
+    optionsPesto.MCMC.sigma0 = 0.5 * inv(squeeze(parameters.MS.hessian(:,:,1)));
+else
+    % Find startguess if not multistart
+    %take latest result from previous ess optimization
+    loadfolders = dir(fullfile(pathbase,'Parameters','MCMC',['P' patientNum '_*']));
+    [~,latestfolderInd] = max([loadfolders.datenum]);
+    foldernames = {loadfolders.name};
+    folderpaths = {loadfolders.folder};
+    loadfolderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+    loadsummaryfile=0;
+    [optParam,loadedoptcost,~,loadedconstants] = findBestParams(loadfolderName,loadsummaryfile,length(paramNames));
+    fprintf('Estimateparameters: Loaded paramvalues with cost %0.2f from %s\n',loadedoptcost,loadfolderName)
+    optParam = max(optParam,lbOrig);%make sure the startguess is within the bounds
+    optParam = min(optParam,ubOrig);%make sure the startguess is within the bounds
+    allparams = optParam;
+    ind.estParams = 1:length(allparams);
+    optParam = log10(optParam);
+    optParam = max(optParam,lb);%make sure the startguess is within the bounds
+    optParam = min(optParam,ub);%make sure the startguess is within the bounds
+    
+    % if multi-start does not work use best param
+    optionsPesto.MCMC.theta0 = optParam;
+    % if no sigma given by user, it is set to deafault: this.sigma0 = 1e4 * diag(ones(1,par.number));
+    optionsPesto.MCMC.sigma0 = 1e5*eye(length(optParam));
+    objectiveFunction = @(p) costFunction_HEALTH(p,constants,allparams,simOptions,numHeartBeats,data,ind,dispErrors,doPlot);
+end
+save(sprintf('%s/testsave-%i-%s.mat',savefolder,loopNumber,dateStart) ,'dateStart')
+
+%% Sample with MCMC
+%Please make sure opt.theta0, the par.number and opt.PT.nTemps are consistent.
+tic
+% try
+    parameters = getParameterSamples(parameters, objectiveFunction, optionsPesto);
+% catch ME
+%     disp(['ERROR - pat ' patientNum ' failed getParameterSamples:'])
+%     disp(ME.identifier)
+% end
+timeMCMC = toc;
+hoursMCMC = toc/3600;
+
+%% Save results & settings to folder
+bounds.lb = 10.^lb;
+bounds.ub = 10.^ub;
+dateEnd = datestr(now,'yymmdd-HHMMSS');
+save(sprintf('%s%sparameters-%i.mat',savefolder,filesep,loopNumber),'parameters','bounds')
+save(sprintf('%s%soptionsPesto-%i.mat',savefolder,filesep,loopNumber),'optionsPesto')
+save(sprintf('%s%srngSettings-%i.mat',savefolder,filesep,loopNumber),'rngSettings')
+save(sprintf('%s%stimeforMCMC-%i.mat',savefolder,filesep,loopNumber),'timeMCMC','hoursMCMC')
+save(sprintf('%s%sextrainfoMCMC-%i.mat',savefolder,filesep,loopNumber),'constants','constantsNames','ind','paramNames','simOptions','dateStart','dateEnd')
+w = warning ('on','all'); % yay error messages again
+
+%% Save all open plots
+disp('SAVING PLOTS...')
+FigList = findobj(allchild(0), 'flat', 'Type', 'figure');
+for fig = 1:length(FigList)
+    currFig = FigList(fig);
+    figName = currFig.Name;
+    saveas(currFig, fullfile(savefolder,[figName,'.png']))
+%     saveas(currFig, fullfile(savefolder,[figName,'.fig'])) %fig takes too
+%     much memory
+end
+    
+end
diff --git a/Optimization/findAllPatientNums.m b/Optimization/findAllPatientNums.m
new file mode 100644
index 0000000000000000000000000000000000000000..6eeb1f50a30898dee5d32e6af2b381092297b6b1
--- /dev/null
+++ b/Optimization/findAllPatientNums.m
@@ -0,0 +1,20 @@
+function patNums = findAllPatientNums(dataFolder,range)
+if nargin <1
+    dataFolder = 'Data';
+end
+
+folders = dir([dataFolder '/*_P*']);
+names = {folders.name};
+patNums = cell(1,length(names));
+for n = 1:length(names)
+    patNums{n} = names{n}(end-5:end-4);
+    if strcmp(patNums{n}(1),'P')
+        patNums{n} = patNums{n}(2);
+    end
+end
+
+if nargin > 1
+    patNums = patNums(range);
+end
+
+end
\ No newline at end of file
diff --git a/Optimization/findPatientRange.m b/Optimization/findPatientRange.m
new file mode 100644
index 0000000000000000000000000000000000000000..dafb97de0dccad1dd095e8afdf7b215c85efdf43
--- /dev/null
+++ b/Optimization/findPatientRange.m
@@ -0,0 +1,22 @@
+function patientNums = findPatientRange(patientNums,patRange,dataFolder)
+
+if isempty(patientNums)
+    disp('patientNums is empty')
+    if isempty(patRange)
+        patientNums = findAllPatientNums(dataFolder);
+    elseif ismember(':',patRange)
+        nums = split(patRange,':');
+        patRange = str2double(nums{1}):str2double(nums{2});
+        patientNums = findAllPatientNums(dataFolder,patRange);
+    elseif ismember(',',patRange)
+        nums = split(patRange,',');
+        patRange = str2double(nums);
+        patientNums = findAllPatientNums(dataFolder,patRange);
+    else
+        patientNums = findAllPatientNums(dataFolder,patRange);
+    end
+elseif ischar(patientNums) %if only one pat, eg '47' adn not {'47','48'}
+    patientNums = {patientNums};
+end
+
+end
\ No newline at end of file
diff --git a/Optimization/runParallel_several_MCMC_1_32.sh b/Optimization/runParallel_several_MCMC_1_32.sh
new file mode 100644
index 0000000000000000000000000000000000000000..627a06f0421f56dd877e311ce26895c18896ca18
--- /dev/null
+++ b/Optimization/runParallel_several_MCMC_1_32.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# Use 1 node, i.e. 1x32 cores, for 72 hours
+#batch1: 1:32
+#SBATCH -N 1
+#SBATCH -t 156:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='1:32'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='MCMC'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersMCMC_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+seq 1 32| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}','${patRange}', '${dataFolder}',$continueMCMC);exit\""
+
+# End of script
diff --git a/Optimization/runParallel_several_MCMC_33_64.sh b/Optimization/runParallel_several_MCMC_33_64.sh
new file mode 100644
index 0000000000000000000000000000000000000000..758d19a3ffe18dfa560955189bc58d46e1110886
--- /dev/null
+++ b/Optimization/runParallel_several_MCMC_33_64.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# Use 1 node, i.e. 1x32 cores, for 72 hours
+#batch2: 33:64
+#SBATCH -N 1
+#SBATCH -t 156:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='33:64'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='MCMC'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersMCMC_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+seq 1 32| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}','${patRange}', '${dataFolder}',$continueMCMC);exit\""
+
+# End of script
diff --git a/Optimization/runParallel_several_MCMC_65_80.sh b/Optimization/runParallel_several_MCMC_65_80.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9cc262e2b217e22ea9e4fe6b548916a17549a36b
--- /dev/null
+++ b/Optimization/runParallel_several_MCMC_65_80.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# Use 1 node, i.e. 1x32 cores, for 72 hours
+#batch3: 65:80
+#SBATCH -N 1
+#SBATCH -t 156:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='65:80'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='MCMC'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersMCMC_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+seq 1 16| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}','${patRange}', '${dataFolder}',$continueMCMC);exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall1_1to10.sh b/Optimization/runParallell_ESS_HEALTH_combosmall1_1to10.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d5cccab1a39d123cd9c0c3e1126e6c00110e2ba7
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall1_1to10.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART1: pat 1-10.
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='1:10'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall2_11to20.sh b/Optimization/runParallell_ESS_HEALTH_combosmall2_11to20.sh
new file mode 100644
index 0000000000000000000000000000000000000000..03770a38b5793ce367ead8c8428f8e6bfeb5ea67
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall2_11to20.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART2: pat 11-20. 
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='11:20'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall3_21to30.sh b/Optimization/runParallell_ESS_HEALTH_combosmall3_21to30.sh
new file mode 100644
index 0000000000000000000000000000000000000000..49d07534a1bc1b38412a9fc4a38fdb9c6917c1a1
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall3_21to30.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART3: pat 21-30. 
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='21:30'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall4_31to40.sh b/Optimization/runParallell_ESS_HEALTH_combosmall4_31to40.sh
new file mode 100644
index 0000000000000000000000000000000000000000..26d4a37376293e8ce0a0ad650d4fbe2be33c0a1c
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall4_31to40.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART4: pat 31-40. 
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='31:40'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall5_41to50.sh b/Optimization/runParallell_ESS_HEALTH_combosmall5_41to50.sh
new file mode 100644
index 0000000000000000000000000000000000000000..fc2ab5bc87f6105e86d24539a8dcf434960315bf
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall5_41to50.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART5: pat 41-50.
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='41:50'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall6_51to60.sh b/Optimization/runParallell_ESS_HEALTH_combosmall6_51to60.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f849c654be675c37be917a3d815fe2b036ecf991
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall6_51to60.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART6: pat 51-60.
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='51:60'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall7_61to70.sh b/Optimization/runParallell_ESS_HEALTH_combosmall7_61to70.sh
new file mode 100644
index 0000000000000000000000000000000000000000..747f1e5ca2e3e234aa5b77425f3e6f52782d0a6f
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall7_61to70.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART7: pat 61-70.
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='61:70'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_combosmall8_71to80.sh b/Optimization/runParallell_ESS_HEALTH_combosmall8_71to80.sh
new file mode 100644
index 0000000000000000000000000000000000000000..bd32b69ef7a8d77530ac557cc7a81172df91afec
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_combosmall8_71to80.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# PART8: pat 71-80.
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours.
+#SBATCH -N 3
+#SBATCH -t 22:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='71:80'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# random start guess - 40 runs * 10 pats
+randomstart=1
+seq 1 400| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# load start guess - 10 runs * 10 pats
+randomstart=0
+seq 1 100| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}',$randomstart);exit\""
+
+# last run one long opt 1 run * 10 pats
+job=EstimateParametersESS_HEALTH_lastrun
+seq 1 10| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParallell_ESS_HEALTH_lastrun.sh b/Optimization/runParallell_ESS_HEALTH_lastrun.sh
new file mode 100644
index 0000000000000000000000000000000000000000..3b9f0c8635b6dc5f03a7cd76345b65a44245a12e
--- /dev/null
+++ b/Optimization/runParallell_ESS_HEALTH_lastrun.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+#
+# run all 80 pats
+# Use 3 nodes, i.e. 3x32 cores, for 22 hours. takes ish 2hours.
+#SBATCH -N 3
+#SBATCH -t 5:00:00
+#SBATCH --exclusive
+
+# Update the project if possible. 
+#git pull
+
+
+# Setup parameters for the scripts
+modelName='avatarHEALTH'
+dataFolder='Data'
+#range in the format: 5,6,7  or 1:5 (empty = run all patients)
+patRange='1:80'
+doParamEst=1
+patNums=''
+doPV=1
+continueMCMC=0
+now=$(date '+%Y%m%d-%H%M%S')
+method='HEALTH'
+cdprojpath="cd('/proj/add your path');"
+
+#Use hidden matlab r2017 module to compile AMICII models
+module load MATLAB/.R2017b-nsc1
+MATLAB_0='matlab -nodesktop -nodisplay -singleCompThread'
+module load buildenv-gcc/2018a-eb
+${MATLAB_0} -r "GenerateModels; exit"
+# run setup script to create results folders
+${MATLAB_0} -r "Setup('${patNums}',$doParamEst,'${now}','${patRange}','${dataFolder}',$doPV,'${method}',$continueMCMC); exit"
+
+# Load the Matlab module
+module load MATLAB/R2020a-nsc1 
+module load parallel/20181122-nsc1
+#module add gcc/8.2.0 
+MATLAB='matlab -nodesktop -nodisplay -singleCompThread'
+
+# The name of the Matlab script (without .m)
+job=EstimateParametersESS_HEALTH_lastrun
+
+# Run main task. Note the explicit "exit" to exit Matlab.
+# last run one long opt 1 run * 80 pats
+seq 1 80| parallel --ssh=jobsh -S $(hostlist -e -s',' -d  -p "$SLURM_CPUS_ON_NODE/" $SLURM_JOB_NODELIST) ${MATLAB} -r "\"$cdprojpath  ${job}({},'${now}','${patNums}', '${modelName}','${patRange}', '${dataFolder}');exit\""
+
+# End of script
diff --git a/Optimization/runParamEstimationSeveral_ESS_asNSC.m b/Optimization/runParamEstimationSeveral_ESS_asNSC.m
new file mode 100644
index 0000000000000000000000000000000000000000..4c15e7086065a3b78ce900103e18e164271b9283
--- /dev/null
+++ b/Optimization/runParamEstimationSeveral_ESS_asNSC.m
@@ -0,0 +1,48 @@
+%runParamEstimationSeveral_ESS_asNSC
+clear
+close all
+
+rng('shuffle')
+
+addpath(genpath(['..' filesep]))
+
+%% Set variables
+modelName = 'Avatar_HEALTH';
+inputpathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+dataFolder = [inputpathbase{1},filesep 'cardiovascularavatar_T2D_HT' filesep 'Data'];
+patNums = '';%eg: '16', if only one subject should be optimized
+patrange = '1:10';%eg: '1:10', if you want to optimize several subjects
+patientNums = findPatientRange([],patrange,dataFolder);
+numpats = length(patientNums);
+doPV=1; % include data of flow in pulmonary vein or not
+method = 'HEALTH';
+continueMCMC = 0;
+doParamEst=1;
+datename = datestr(now,'yymmdd-HHMMSS');
+Setup(patNums,doParamEst,datename,patrange,dataFolder,doPV,method,continueMCMC)
+
+restoredefaultpath
+
+%% Run optimizations
+tic
+randomstart = 1; 
+disp('***Starting optimization run 1 - random starts***')
+parfor i = 1:(40*numpats) %40 per subject
+    EstimateParametersESS_HEALTH(i,datename,patNums,modelName,patrange,dataFolder,randomstart) 
+end
+randomstart = 0; 
+disp('***Starting optimization run 2 - from previous results***')
+parfor i = 1:(10*numpats) %10 per subject, startguess from previous results
+    EstimateParametersESS_HEALTH(i,datename,patNums,modelName,patrange,dataFolder,randomstart) 
+end
+disp('***Starting final optimization run***')
+parfor i = 1:numpats %1 per subject, last run
+    EstimateParametersESS_HEALTH_lastrun(i,datename,patNums,modelName,patrange,dataFolder) 
+end
+
+%% Information about the time of optimization
+timetotalOpt = toc
+timetotalOpt_minutes = timetotalOpt/60
+timetotalOpt_hours = timetotalOpt_minutes/60
+
+
diff --git a/Optimization/runParamEstimationSeveral_MCMC_asNSC.m b/Optimization/runParamEstimationSeveral_MCMC_asNSC.m
new file mode 100644
index 0000000000000000000000000000000000000000..24b5b85c534a68b3e213b6452849b58abde252ae
--- /dev/null
+++ b/Optimization/runParamEstimationSeveral_MCMC_asNSC.m
@@ -0,0 +1,35 @@
+%runParamEstimationSeveral_MCMC_asNSC
+clear
+close all
+
+rng('shuffle')
+addpath(genpath(['..' filesep]))
+
+%% Set variables
+modelName = 'Avatar_HEALTH';
+patNums = '';%eg: '16'
+patrange = '1:32';%eg: 1:5
+numberOfSubjects = 32;
+inputpathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+dataFolder = [inputpathbase{1},filesep 'cardiovascularavatar_T2D_HT' filesep 'Data'];
+doPV=1; % include data of flow in pulmonary vein or not
+method = 'MCMC';
+continueMCMC = 0; %1=load old MCMC optimization file
+doParamEst=1;
+datename = datestr(now,'yymmdd-HHMMSS');
+Setup(patNums,doParamEst,datename,patrange,dataFolder,doPV,method,continueMCMC)
+
+restoredefaultpath
+
+%% Run optimizations
+tic
+parfor i = 1:numberOfSubjects
+    EstimateParametersMCMC_HEALTH(i,datename,patNums,patrange,dataFolder,continueMCMC)
+end
+
+%% Information about the time of optimization
+timetotalOpt = toc
+timetotalOpt_minutes = timetotalOpt/60
+timetotalOpt_hours = timetotalOpt_minutes/60
+
+
diff --git a/Parameters/MCMC/allokparams_230216-1142.mat b/Parameters/MCMC/allokparams_230216-1142.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e05f76c484f5031a496f2e30411e1bbc4218d70c
Binary files /dev/null and b/Parameters/MCMC/allokparams_230216-1142.mat differ
diff --git a/Parameters/MCMC/minmaxsims_230128-2146.mat b/Parameters/MCMC/minmaxsims_230128-2146.mat
new file mode 100644
index 0000000000000000000000000000000000000000..84857bbaeb031b27114c0ee3fc876810325789c7
Binary files /dev/null and b/Parameters/MCMC/minmaxsims_230128-2146.mat differ
diff --git a/Plotting/clusterCalculation.m b/Plotting/clusterCalculation.m
new file mode 100644
index 0000000000000000000000000000000000000000..11919a94befd7591bd515d347972c23ba0d1befb
--- /dev/null
+++ b/Plotting/clusterCalculation.m
@@ -0,0 +1,508 @@
+function [clusterfinaltable,groupedinbothFinal] = clusterCalculation(paramValues,constants,nGroups,paramNames,constantsNames,patNums,plotFolderName)
+% PCA analyis and clustering with k-means and hiearchical clustering --> 2
+% clusters.
+% Based on the method in https://doi.org/10.1113/JP281845 jones et al 2021
+
+%% Load groups
+[groups] = loadGroupIndexes(patNums);
+
+m2_lvs = paramValues(strcmp(paramNames,'m2_LV'),:);
+Cpvcs = paramValues(strcmp(paramNames,'Cpvc'),:);
+
+%% Set colors
+%magma
+addpath '..\Requirements\matplotlib'
+magmacols = flip(magma(4));
+colors4groups = magmacols;
+fourgroups = {groups.C_NT_home,groups.T2D_NT_home,groups.C_HT_home,groups.T2D_HT_home};
+
+%% Prepare the parameter matrix: standardize the values
+%centering:
+% "Before any of the
+% clustering methods are applied, each column is centred
+% by subtracting the average of each column from each
+% element in that column. " jones et al 2021
+% "Because our clinical data and
+% optimized parameters had different units within their
+% respective matrices, we normalized each clinical measure
+% or parameter by its standard deviation." jones et al 2021
+
+% standardize the params
+standardizedParams = paramValues';
+for c = 1:size(standardizedParams,2)
+    standardizedParams(:,c) = (standardizedParams(:,c)-mean(standardizedParams(:,c)))./std(standardizedParams(:,c));
+end
+
+%% PCA
+% PCA centers the data by itself, but we already did that, so we set it to
+% false to not do it twice
+[coeff,score,latent,tsquared,explained,mu] = pca(standardizedParams,'Centered',false); 
+twofirstpcsexplainedpercent = sum(explained(1:2));
+firstPCAexplainedpercent = explained(1);
+secondPCAexplainedpercent = explained(2);
+
+pca1= score(:,1);
+pca2 = score(:,2);
+
+% Plot result
+figure('Visible', 'off','Name','clustering_PCA')
+xdim_CM = 17;
+ydim_CM = 16;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+tiledlayout(1,2,'TileSpacing','loose','Padding','compact');
+breakpoint = 9;
+nexttile
+hold on
+plot(1:length(explained),latent,'-*')
+xline(breakpoint);
+xlabel('Num component')
+ylabel('eigenvalue')
+title(sprintf('%0.2f%% explained by the first %d components',sum(explained(1:breakpoint)),breakpoint))
+
+nexttile
+hold on
+plot(1:length(explained),explained,'-*')
+plot(1:length(explained),cumsum(explained),'--*')
+yline(50);
+fiftypercexplaind = find(cumsum(explained)>50,1);
+xline(fiftypercexplaind);
+xlabel('Num component')
+ylabel('explained%')
+title(sprintf('%0.2f%% explained by the first %d components',sum(explained(1:fiftypercexplaind)),fiftypercexplaind))
+legend({'Explained % per component','Cumulative explained %'},'Position',[0.638865999370241 0.188457301332931 0.30171072432079 0.0570247919106287])
+
+% Create table with all coefficients
+pcacoefficienttable = table([coeff(:,1);firstPCAexplainedpercent],[coeff(:,2);secondPCAexplainedpercent],[coeff(:,1)+coeff(:,2);twofirstpcsexplainedpercent],'Rownames',[paramNames,{'% explained'}],'Variablenames',{'PCA1','PCA2','Sum'});
+pcacoefficienttablefull = array2table(coeff,'Rownames',paramNames);
+
+% Create biplot to show spread of coefficients in the first 2 PCs
+figure('Visible', 'off','Name','cluster_PCA_biplot')
+xdim_CM = 17; 
+ydim_CM = 16;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+
+h=biplot(coeff(:,1:2),'Scores',score(:,1:2),'VarLabels',paramNames,'MarkerSize',15,'color',[0.3 0.3 0.3]);
+hold on
+idx = zeros(size(fourgroups{1}));
+idx(fourgroups{1}) = 1;
+idx(fourgroups{2}) = 2;
+idx(fourgroups{3}) = 3;
+idx(fourgroups{4}) = 4;
+for p = 1:size(standardizedParams,1)
+    h(p + size(standardizedParams,2)*3).MarkerEdgeColor = colors4groups(idx(p),:); % change the color of data 
+end
+
+%% hiearchical clustering
+% "To do this in MATLAB, the linkage function is used, and the Ward metric (Ward, 1963) is selected to group the two clusters together at each step that minimize the total in-cluster variation. Using the dendrogram, we partitioned our patients into two clusters by cutting the dendrogram halfway between the second-from-last and last linkages."jones et al 2021 
+Y = pdist(standardizedParams);
+Z = linkage(Y,'ward');
+%Column 1 and 2 of Z contain cluster indices linked in pairs to form a binary tree. 
+%"Using the dendrogram, we
+% partitioned our patients into two clusters by cutting the
+% dendrogram halfway between the second-from-last and
+% last linkages." jones et al 2021
+hiearchicalClusters = cluster(Z,'maxclust',nGroups);
+
+figure('Visible', 'off','Name','Clustering_hiearchical_Dendrogram')
+dendrogram(Z)
+
+%make sure the largest cluster is named cluster 1 to be able to more easily
+%compare it to the k-means clustering
+numones = sum(hiearchicalClusters == 1);
+numtwoes = sum(hiearchicalClusters == 2);
+if numtwoes>numones
+    hiearchicalClusters(hiearchicalClusters == 1) = 20;%will be set to 2
+    hiearchicalClusters(hiearchicalClusters == 2) = 1;
+    hiearchicalClusters(hiearchicalClusters == 20) = 2;
+end
+
+
+%% k-means clustering
+%"This method is dependent on the random initial cluster centroids selected, 
+%so we run this process 20 times and select the clustering result that has
+%the smallest total cluster variance" jones et al 2021
+numrepeats = 100;%20 was not stable enough with this data, increased to 100.
+clusters = cell(1,numrepeats);
+withinClusterDistancesum = zeros(1,numrepeats);
+for i = 1:numrepeats
+    [clusters{i},C,sumd] = kmeans(standardizedParams,nGroups);
+    withinClusterDistancesum(i) = sum(sumd);
+end
+[mindistanceKmeans,mindistanceInd] = min(withinClusterDistancesum);
+kmeansClusters = clusters{mindistanceInd};
+
+%make sure the largest cluster is named cluster 1 to be able to more easily
+%compare it to the hierarchical clustering
+numones = sum(kmeansClusters == 1);
+numtwoes = sum(kmeansClusters == 2);
+if numtwoes>numones
+    kmeansClusters(kmeansClusters == 1) = 20;%will be set to 2
+    kmeansClusters(kmeansClusters == 2) = 1;
+    kmeansClusters(kmeansClusters == 20) = 2;
+end
+
+%% Combining hearchical and kmeans clusters
+%if clustered into the same group in both hiearchical and kmeans clusters,
+%they are in the same group
+groupedinboth = nan(length(patNums),1);
+for p = 1:length(patNums)
+    for pcomp = 1:length(patNums)
+        %if not looked at before and not comparing a patient with itself
+        if isnan(groupedinboth(p)) &&(pcomp ~= p)
+            %if they are in same group in both methods
+            if (hiearchicalClusters(p) == hiearchicalClusters(pcomp)) && ...
+                    (kmeansClusters(p) == kmeansClusters(pcomp))
+                groupedinboth(p) = str2double([num2str(kmeansClusters(p)) num2str(hiearchicalClusters(p))]);
+                groupedinboth(pcomp) = str2double([num2str(kmeansClusters(p)) num2str(hiearchicalClusters(p))]);
+                break
+            end
+        end
+    end
+end
+allgroups = unique(groupedinboth(~isnan(groupedinboth)));
+
+%% Using the convex pca hull to check if subjects are HT+T2D-like (creating a  HT+T2D group vs a non-HT+T2D group)
+a = pca1(groups.T2D_HT_home);
+b = pca2(groups.T2D_HT_home);
+pcaHullT2DHT = convhull(a,b); %computes the 2-D convex hull of the points in column vectors x and y.
+inHTT2Dhull = inpolygon(pca1,pca2,a(pcaHullT2DHT),b(pcaHullT2DHT));
+
+HTgroups = zeros(size(inHTT2Dhull));
+HTgroups(inHTT2Dhull) = 4;%within the hull of hypertension AND diabetes
+HTgroups(groups.T2D_HT_home) = 3;%hypertension AND diabetes only
+
+groupedinbothFinal = nan(length(patNums),1);
+for p = 1:length(patNums)
+    for pcomp = 1:length(patNums)
+        %if not looked at before and not comparing a patient with itself
+        if isnan(groupedinbothFinal(p)) &&(pcomp ~= p)
+            %if they are in same group in both methods
+            if (HTgroups(p) == HTgroups(pcomp)) && ...
+                    (groupedinboth(p) == groupedinboth(pcomp))
+                groupedinbothFinal(p) = str2double([num2str(groupedinboth(p)) num2str(HTgroups(p))]);
+                groupedinbothFinal(pcomp) = str2double([num2str(groupedinboth(p)) num2str(HTgroups(p))]);
+                break
+            end
+        end
+    end
+end
+
+%find clusters with HT+T2D subjects in, and select the largest one as HTT2Dcluster
+HTT2Dclusters = [113,223];%we do not want 123 or 213 since they are not consistently clustered.
+groupsize = size(HTT2Dclusters);
+for i = 1:length(HTT2Dclusters)
+    groupsize(i) = sum(groupedinbothFinal == HTT2Dclusters(i));
+end
+[numInHTT2Dcluster,indmax] = max(groupsize);
+HTT2Dcluster = HTT2Dclusters(indmax);
+
+diseaselikecluster = HTT2Dcluster-3+4;%should end with 4 but the first two groupings should be the same as the HT+T2D-like cluster
+numIndiseaselikecluster = sum(groupedinbothFinal == diseaselikecluster);
+
+if HTT2Dcluster  == 113
+    numHTT2D_notinHtT2Dcluster = sum(groupedinbothFinal == 223);
+    nondiseasecluster = 220;
+else
+    numHTT2D_notinHtT2Dcluster = sum(groupedinbothFinal == 113);
+    nondiseasecluster = 110;
+end
+numInnondiseaselikecluster = sum(groupedinbothFinal == nondiseasecluster);
+
+numHTT2D_NCC = sum(groups.T2D_HT_home) - numHTT2D_notinHtT2Dcluster - numInHTT2Dcluster;
+
+%inconsistently clustered with k-means and hiearchical
+NCCdiseaselikecluster = HTT2Dcluster-3;%in disease cluster but not in disease hull (ends with 0)
+NCCnondiseaselikecluster = nondiseasecluster+4;%not in disease cluster but in disease hull (ends with 4)
+NCCclusters = [120,210,124,214,NCCdiseaselikecluster,NCCnondiseaselikecluster];
+
+%summarize new groups
+finalclusters = cell(size(groupedinbothFinal));
+for f = 1:length(finalclusters)
+    if HTgroups(f) == 3
+        finalclusters{f} = 'HTT2D';
+    elseif ismember(groupedinbothFinal(f),NCCclusters)
+        finalclusters{f} = 'NCC';
+    elseif groupedinbothFinal(f) == nondiseasecluster
+        finalclusters{f} = 'non-HTT2D-like';
+    elseif groupedinbothFinal(f) == diseaselikecluster
+        finalclusters{f} = 'HTT2D-like';
+    elseif isnan(groupedinbothFinal(f))
+        finalclusters{f} = 'NCC';
+    else
+        disp(groupedinbothFinal(f))
+    end
+end
+numinNCCcluster = sum(ismember(finalclusters,'NCC'));
+
+clusternamesfinal = {'NCC','non-HTT2D-like','HTT2D-like','HTT2D'};
+clustercolorsfinal = {[0.5 0.5 0.5],[0.2 0.5 0.2],[0.2 0.2 0.5],colors4groups(4,:)};
+clustermarkersfinal = {'+','^','o','*'};
+clustermarkers = {'*','+','x','o','^','v','<','>'};
+
+clustercolors = {[0.1 0.4 0.1],[0.2 0.2 0.5],[0.5 0.2 0.2],[0.2 0.2 0.2],[0.2 0.2 0.2]};
+
+% Create result table
+clusterfinaltable = table(groups.fourgroupsHBP,groupedinbothFinal,kmeansClusters,hiearchicalClusters,inHTT2Dhull,finalclusters,'Rownames',patNums,'Variablenames',{'Subject group','kmeans, hiearchical,hull','kmeans','hiearchical','PCA hull','final clustered group'});
+clusterfinaltablesorted = sortrows(clusterfinaltable,1);
+
+%% Plot final clusters
+figure('Visible', 'off','Name','clusters_final')
+global fzlarge 
+global fzsmall 
+global fzsupersmall 
+fzlarge = 14;
+fzsmall = 10;
+fzsupersmall = 8;
+set(gcf,'Color','white')
+xdim_CM = 17;
+ydim_CM = 14;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+tiledlayout(2,2,'TileSpacing','loose','Padding','compact');
+
+%PCAs
+nexttile
+hold on
+for i = 1:length(fourgroups)
+    a = pca1(fourgroups{i});
+    b = pca2(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1);
+end
+for i = 1:length(allgroups)
+    plot(pca1(groupedinboth==allgroups(i)),pca2(groupedinboth==allgroups(i)),clustermarkers{i},'color',[0.5 0.5 0.5],'LineWidth',1,'Markersize',5);
+end
+set(gca,'FontSize',fzsmall)
+xlabel('1st Principal Component','FontSize',fzsmall)
+ylabel('2nd Principal Component','FontSize',fzsmall)
+hold off
+
+%cpvc
+nexttile
+hold on
+for i = 1:length(fourgroups)
+    a = m2_lvs(fourgroups{i});
+    b = Cpvcs(fourgroups{i});
+    hullN = convhull(a,b); 
+    diseasegroups(i) = fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1);
+end
+for i = 1:length(allgroups) 
+    clustergroups(i)=plot(m2_lvs(groupedinboth==allgroups(i)),Cpvcs(groupedinboth==allgroups(i)),clustermarkers{i},'color',[0.5 0.5 0.5],'LineWidth',1,'Markersize',5);
+    namestring = num2str(allgroups(i));
+    clusternames{i} = sprintf('Cluster %d (%s,%s)',i,namestring(1),namestring(2));
+end
+set(gca,'FontSize',fzsmall)
+xlabel('LV relaxation rate (-)','FontSize',fzsmall)
+ylabel(sprintf('Pulmonary venous compliance\n(mmHg/mL)'),'FontSize',fzsmall)
+legend([clustergroups,diseasegroups],[clusternames,{'Control hull','T2D hull','HT hull','HT & T2D hull'}],'FontSize',7,...
+    'Position',[0.802190942086316 0.833414502411537 0.144634523714312 0.129629626042313])
+hold off
+
+
+nexttile
+hold on
+for i = 1:length(fourgroups)
+    a = pca1(fourgroups{i});
+    b = pca2(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1)
+end
+for i = 1:length(clusternamesfinal)
+    a = pca1(ismember(finalclusters,clusternamesfinal{i}));
+    b = pca2(ismember(finalclusters,clusternamesfinal{i}));
+    plot(a,b,clustermarkersfinal{i},'color',clustercolorsfinal{i},'LineWidth',1,'Markersize',5);
+end
+set(gca,'FontSize',fzsmall)
+xlabel('1st Principal Component','FontSize',fzsmall)
+ylabel('2nd Principal Component','FontSize',fzsmall)
+hold off
+
+%cpvc
+nexttile
+hold on
+for i = 1:length(fourgroups)
+    a = m2_lvs(fourgroups{i});
+    b = Cpvcs(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1)
+end
+for i = 1:length(clusternamesfinal)
+    a = m2_lvs(ismember(finalclusters,clusternamesfinal{i}));
+    b = Cpvcs(ismember(finalclusters,clusternamesfinal{i}));
+    plot(a,b,clustermarkersfinal{i},'color',clustercolorsfinal{i},'LineWidth',1,'Markersize',5);
+end
+set(gca,'FontSize',fzsmall)
+xlabel('LV relaxation rate (-)','FontSize',fzsmall)
+ylabel(sprintf('Pulmonary venous compliance\n(mmHg/mL)'),'FontSize',fzsmall)
+l = legend([{'Control hull','T2D hull','HT hull','T2D+HT hull'},clusternamesfinal],...
+    'FontSize',7,'NumColumns',2,'Position',[0.683478143201293 0.382888873886038 0.24 0.0840000000000001]);%[0.22 0.57 0.24 0.084]
+
+
+%% PLOT all clusters
+global fzlarge 
+global fzsmall 
+global fzsupersmall 
+fzlarge = 14;
+fzsmall = 10;
+fzsupersmall = 8;
+
+clustercols = {[0 0.4470 0.7410],[0.8500 0.3250 0.0980]};
+
+figure('Visible', 'off','Name','Clustering')
+set(gcf,'Color','white')
+xdim_CM = 21;
+ydim_CM = 25;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+tiledlayout(3,2,'TileSpacing','tight','Padding','compact');
+clf
+%----------- kmeans and hiearchical plotted against PCAs ---------------
+nexttile
+title('Grouped on kmeans','FontSize',fzlarge)
+hold on
+clusternames = cell(1,nGroups);
+for i = 1:length(fourgroups)
+    a = pca1(fourgroups{i});
+    b = pca2(fourgroups{i});
+    hullN = convhull(a,b);
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1.5)
+end
+for i = 1:nGroups
+    hold on
+    clusternames{i} = num2str(i);
+    clusterplot(i) = plot(pca1(kmeansClusters==i),pca2(kmeansClusters==i),'*','LineWidth',2,'color',clustercols{i});
+end
+set(gca,'FontSize',fzsmall)
+xlabel('1st Principal Component')
+ylabel('2nd Principal Component')
+l = legend(clusterplot,clusternames,'FontSize',fzsupersmall);
+l.BoxFace.ColorType='truecoloralpha';
+l.BoxFace.ColorData=uint8(255*[1 1 1 0.6]');
+hold off
+
+nexttile
+title('Grouped on hiearchical','FontSize',fzlarge)
+hold on
+for i = 1:length(fourgroups)
+    a = pca1(fourgroups{i});
+    b = pca2(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1.5)
+end
+for i = 1:nGroups
+    hold on
+    clusterplot(i) = plot(pca1(hiearchicalClusters==i),pca2(hiearchicalClusters==i),'*','LineWidth',2,'color',clustercols{i});
+    clusternames{i} = num2str(i);
+end
+set(gca,'FontSize',fzsmall)
+xlabel('1st Principal Component','FontSize',fzsmall)
+ylabel('2nd Principal Component','FontSize',fzsmall)
+l = legend(clusterplot,clusternames,'FontSize',fzsupersmall);
+l.BoxFace.ColorType='truecoloralpha';
+l.BoxFace.ColorData=uint8(255*[1 1 1 0.6]');
+hold off
+
+%--------------- kmeans and hiearcical plotted against selected parameters ---------------
+nexttile
+hold on
+title('Grouped on kmeans','FontSize',fzlarge)
+for i = 1:length(fourgroups)
+    a = Cpvcs(fourgroups{i});
+    b = m2_lvs(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1.5)
+end
+for i = 1:nGroups
+    clusterplot(i) =plot(Cpvcs(kmeansClusters==i),m2_lvs(kmeansClusters==i),'*','LineWidth',2,'color',clustercols{i});
+    clusternames{i} = num2str(i);
+end
+set(gca,'FontSize',fzsmall)
+xlabel('Cpvc','FontSize',fzsmall)
+ylabel('m2 LV','FontSize',fzsmall)
+l = legend(clusterplot,clusternames,'FontSize',fzsupersmall);
+l.BoxFace.ColorType='truecoloralpha';
+l.BoxFace.ColorData=uint8(255*[1 1 1 0.6]');
+hold off
+
+nexttile
+hold on
+title('Grouped on hiearchical','FontSize',fzlarge)
+for i = 1:length(fourgroups)
+    a = Cpvcs(fourgroups{i});
+    b = m2_lvs(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1.5)
+end
+for i = 1:nGroups
+     clusterplot(i) = plot(Cpvcs(hiearchicalClusters==i),m2_lvs(hiearchicalClusters==i),'*','LineWidth',2,'color',clustercols{i});
+     clusternames{i} = num2str(i);
+end
+set(gca,'FontSize',fzsmall)
+xlabel('Cpvc','FontSize',fzsmall)
+ylabel('m2 LV','FontSize',fzsmall)
+l = legend(clusterplot,clusternames,'FontSize',fzsupersmall);
+l.BoxFace.ColorType='truecoloralpha';
+l.BoxFace.ColorData=uint8(255*[1 1 1 0.6]');
+hold off
+
+% --------------- Grouped in both methods (final clusters) ---------------
+nexttile
+hold on
+title('Grouped in both methods','FontSize',fzlarge)
+for i = 1:length(fourgroups)
+    a = Cpvcs(fourgroups{i});
+    b = m2_lvs(fourgroups{i});
+    hullN = convhull(a,b); 
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.1,'EdgeColor',colors4groups(i,:),'LineWidth',1.5)
+end
+for i = 1:length(allgroups) 
+    clusterplot(i) =plot(Cpvcs(groupedinboth==allgroups(i)),m2_lvs(groupedinboth==allgroups(i)),clustermarkersfinal{i},'color',clustercolors{i},'LineWidth',1,'MarkerSize',5);
+    clusternames{i} = num2str(allgroups(i));
+end
+set(gca,'FontSize',fzsmall)
+xlabel('Cpvc','FontSize',fzsmall)
+ylabel('m2 LV','FontSize',fzsmall)
+l = legend(clusterplot,clusternames,'FontSize',fzsupersmall);
+l.BoxFace.ColorType='truecoloralpha';
+l.BoxFace.ColorData=uint8(255*[1 1 1 0.6]');
+hold off
+
+
+nexttile
+title('Grouped in both methods','FontSize',fzlarge)
+hold on
+for i = 1:length(fourgroups)
+    a = pca1(fourgroups{i});
+    b = pca2(fourgroups{i});
+    hullN = convhull(a,b); %computes the 2-D convex hull of the points in column vectors x and y.
+    fill(a(hullN),b(hullN),colors4groups(i,:),'FaceAlpha',0.07,'EdgeColor',colors4groups(i,:),'LineWidth',1)
+end
+
+for i = 1:length(allgroups)
+    clusterplot(i) = plot(pca1(groupedinboth==allgroups(i)),pca2(groupedinboth==allgroups(i)),clustermarkersfinal{i},...
+        'color',clustercolors{i},'LineWidth',1,'Markersize',5);
+    clusternames{i} = num2str(allgroups(i));
+end
+set(gca,'FontSize',fzsmall)
+xlabel('1st Principal Component','FontSize',fzsmall)
+ylabel('2nd Principal Component','FontSize',fzsmall)
+l = legend(clusterplot,clusternames,'FontSize',fzsupersmall);
+l.BoxFace.ColorType='truecoloralpha';
+l.BoxFace.ColorData=uint8(255*[1 1 1 0.6]');
+
+% Add legend
+nums = [numIndiseaselikecluster;numInnondiseaselikecluster;numinNCCcluster;numInHTT2Dcluster;numHTT2D_notinHtT2Dcluster;numHTT2D_NCC];
+cluster_counts = table([nums;sum(nums)],...
+    'Rownames',{'HT+T2D-like cluster','non-HT+T2D-like cluster','NCC cluster','HT+T2D in HT+T2D cluster','HT+T2D not in HT+T2D cluster','HT+T2D in NCC cluster','Sum'},'Variablenames',{'Number of subjects'});
+
+%% Save figures and tables
+saveAllFigures(plotFolderName)
+
+writetable(pcacoefficienttablefull,fullfile(plotFolderName,'cluster_pcacoefficients_all.xlsx'),"WriteRowNames",1)
+writetable(pcacoefficienttable,fullfile(plotFolderName,'cluster_pcacoefficients.xlsx'),"WriteRowNames",1)
+writetable(clusterfinaltablesorted,fullfile(plotFolderName,'clusterfinaltablesorted.xlsx'),"WriteRowNames",1)
+writetable(cluster_counts,fullfile(plotFolderName,'cluster_counts.xlsx'),"WriteRowNames",1)
+
+
diff --git a/Plotting/createBlandAltmanPlot_uncertainty.m b/Plotting/createBlandAltmanPlot_uncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..b90c93d22784baa8c83b1a0cf5cb9420df33b820
--- /dev/null
+++ b/Plotting/createBlandAltmanPlot_uncertainty.m
@@ -0,0 +1,54 @@
+function createBlandAltmanPlot_uncertainty(t,tiles,data,simulation,dotcolor,linecolor,linewidth,xlabelname,ylabelname,lettertowrite,uncertainty,paramind)
+
+isvariable = isstruct(uncertainty);
+%uncertainty is saved in allokparams if parameter, or in minmaxsims.variable if
+%variable
+
+average = (data+simulation)./2;
+difference = (data-simulation);
+average = average(~isnan(average));
+difference = difference(~isnan(difference));
+
+maxx = max(average)*1.1;
+minx = min(average)*0.9;
+high = mean(difference)+std(difference)*1.96;
+low = mean(difference)-std(difference)*1.96;
+
+plot(t,average,difference,'.','color',dotcolor,'LineWidth',1,'Markersize',10);
+hold on
+%uncertainty
+for p = 1:length(data)
+    if isvariable
+        minpdiff = data(p)-uncertainty.min{p};
+        maxpdiff = data(p)-uncertainty.max{p};
+    else
+        minpdiff = data(p)-min(uncertainty{p}(:,paramind));
+        maxpdiff = data(p)-max(uncertainty{p}(:,paramind));
+    end
+    diffmax = max([minpdiff,maxpdiff,difference(p)]);
+    diffmin = min([minpdiff,maxpdiff,difference(p)]);
+    e=errorbar(average(p),difference(p),abs(difference(p)-diffmin),abs(diffmax-difference(p)),'color',dotcolor,'LineWidth',0.9);
+    set([e.Bar, e.Line], 'ColorType', 'truecoloralpha', 'ColorData', [e.Line.ColorData(1:3); 255*0.3]);
+end
+yline(t,mean(difference),'-','color',linecolor,'LineWidth',linewidth);
+yline(t,low,'--','color',linecolor,'LineWidth',linewidth);
+yline(t,high,'--','color',linecolor,'LineWidth',linewidth);
+
+ylabel(t,ylabelname)
+xlabel(t,xlabelname)
+xlim(t,[minx maxx])
+
+% Print letter
+TilePos = tiles.Children.InnerPosition;
+chnum = size(tiles.Children);
+if chnum(1)>1
+    h=TilePos(2)+1.15*TilePos(4);
+else
+    h=TilePos(2)+1.05*TilePos(4);
+end
+if h>1
+    h=0.98;
+end
+annotation('textbox',[TilePos(1)-0.035 h .015 .015],'String',lettertowrite,'Linestyle','none','FitBoxToText','on','BackgroundColor','none');
+
+end
\ No newline at end of file
diff --git a/Plotting/createSummaryCorrelationPlot.m b/Plotting/createSummaryCorrelationPlot.m
new file mode 100644
index 0000000000000000000000000000000000000000..3b400cb234fcb187a0e530cca31e8ad3eb62db81
--- /dev/null
+++ b/Plotting/createSummaryCorrelationPlot.m
@@ -0,0 +1,79 @@
+function [pValues,r2Values,rhos,numObservations,testtype] = createSummaryCorrelationPlot(titlename,corrvarnames,corrvars,xorig)
+paramcolor = [21,96,122]./255;%blue
+paramcolor2 = [255 181 95]./255;%yellow
+colororder([paramcolor;paramcolor2.*0.8])
+pValues = zeros(size(corrvars));
+r2Values = zeros(size(corrvars));
+rhos = zeros(size(corrvars));
+numObservations = zeros(size(corrvars));
+testtype = cell(size(corrvars));
+
+title(titlename)
+hold on
+for corrvar = 1:length(corrvars)
+    x = xorig;
+    y = corrvars{corrvar};
+    
+    %remove NaN values
+    CheckNaN_X = isnan(x);
+    CheckNaN_Y = isnan(y);
+    y(CheckNaN_X)= NaN;
+    x(CheckNaN_Y)= NaN;
+    x(isnan(x)) = [];
+    y(isnan(y)) = [];
+    
+    % linear correlation to get r2
+    mdl = fitlm(x,y);
+    numObservations(corrvar) = length(x);
+    r2 = mdl.Rsquared.Ordinary;
+    
+    %check normal distribution
+    try
+        [isnormalx, pvalNormality, ~] = swtest(x, 0.005);
+        [isnormaly, pvalNormality, ~] = swtest(y, 0.005);
+    catch
+        disp('sw normality test failed')
+        isnormalx = 0;isnormaly = 0;
+    end
+    
+    % Calculate p-value for the correlation
+    if isnormalx && isnormaly
+        %pearson correlation for normally distributed parameters
+        [rhos(corrvar),p] = corr(x',y','type','Pearson');
+        testtype{corrvar} = 'Pearson';
+    else
+        %spearman correlation for unparmaetric variables
+        [rhos(corrvar),p] = corr(x',y','type','Spearman');
+        testtype{corrvar} = 'Spearman';
+    end
+
+    yyaxis left
+    bar(corrvar-0.01,1-p,'FaceColor',paramcolor,'EdgeColor','none','FaceAlpha',0.8)
+    
+    yyaxis right
+    bar(corrvar+0.01,r2,'FaceColor',paramcolor2,'EdgeColor','none','FaceAlpha',0.5)
+    plot(corrvar,r2,'.','color',paramcolor2,'Markersize',10)
+    
+    yyaxis left
+    plot(corrvar,1-p,'.','color',paramcolor,'Markersize',10)
+    
+    pValues(corrvar) = p;
+    r2Values(corrvar) = r2;
+end
+xticks(1:length(corrvars))
+xticklabels(corrvarnames)
+xtickangle(-20)
+yyaxis left
+ylabel('p-value')
+ylim([0.8 1])
+% ylim([0 0.2])
+
+yyaxis right
+ylim([0 1])
+ylabel('r^2')
+
+ax = gca;
+ax.XGrid = 'off';
+ax.YGrid = 'on';
+
+end
\ No newline at end of file
diff --git a/Plotting/groupTitle.m b/Plotting/groupTitle.m
new file mode 100644
index 0000000000000000000000000000000000000000..b2570abca7550f2537ae2cc2f9f162d8fd031506
--- /dev/null
+++ b/Plotting/groupTitle.m
@@ -0,0 +1,38 @@
+function title = groupTitle(groups,p,patNums,realPatNums,number)
+% get a title for which group the subject belongs to based on home blood pressure measurement and T2d or not
+pat = num2str(p);
+if groups.T2D_HT_home(p)
+    if realPatNums
+        title = [patNums{p} ' T2D+HT'];
+    elseif nargin >4
+        title = [number ' T2D+HT'];
+    else
+        title = [pat ' T2D+HT'];
+    end
+elseif groups.T2D_NT_home(p)
+    if realPatNums
+        title = [patNums{p} ' T2D'];
+    elseif nargin >4
+        title = [number ' T2D'];
+    else
+        title = [pat ' T2D'];
+    end
+elseif groups.C_HT_home(p)
+    if realPatNums
+        title = [patNums{p} ' HT'];
+    elseif nargin >4
+        title = [number ' HT'];
+    else
+        title = [pat ' HT'];
+    end
+else
+    if realPatNums
+        title = [patNums{p} ' Control'];
+    elseif nargin >4
+        title = [number ' Control'];
+    else
+        title = [pat ' Control'];
+    end
+end
+
+end
\ No newline at end of file
diff --git a/Plotting/plot4groups.m b/Plotting/plot4groups.m
new file mode 100644
index 0000000000000000000000000000000000000000..deccb05776d51ba40cfc902ac21d1b2f4e5739fd
--- /dev/null
+++ b/Plotting/plot4groups.m
@@ -0,0 +1,201 @@
+function plot4groups(comptitles,indSignComp,groups4,mean4,sd4,statisticsTable,allParamValues,paramNamesMarked,bounds,units,plotMedian,names,colors)
+% plots box plots or errorbar plots of 4 groups.
+
+% Font sizes
+global fzlarge 
+global fzsmall
+
+% Find significantly different parameters
+allParamValues = allParamValues';
+rejects = cell(1,6);rejectsfind=rejects;
+rejectsCorrected = cell(1,6);
+for c = 1:6
+    if ~isempty(comptitles{c})
+        rejects{c} = statisticsTable.reject{strcmp(comptitles{c},statisticsTable.groupComparisonNames)};
+        rejectsfind{c}=rejects{c};
+        rejectsCorrected{c} = statisticsTable.rejectBenjH2{strcmp(comptitles{c},statisticsTable.groupComparisonNames)};
+    else
+        rejects{c} = nan(1,length(paramNamesMarked));
+        rejectsfind{c} = zeros(1,length(paramNamesMarked));
+        rejectsCorrected{c} = nan(1,length(paramNamesMarked));
+    end
+end
+indSignThis = find(or(rejectsfind{1},or(rejectsfind{2},or(rejectsfind{3},or(rejectsfind{4},or(rejectsfind{5},rejectsfind{6}))))));
+if isempty(indSignComp)
+    differentInds =  [];
+    indSign = indSignThis;
+else
+    indSign = unique([indSignComp,indSignThis],'stable');
+    differentInds = indSignThis(~ismember(indSignThis,indSignComp));
+end
+
+
+% Plot
+if plotMedian
+    figure('Visible', 'off','Name',[names.figname '_median'])
+else
+    figure('Visible', 'off','Name',[names.figname '_mean'])
+end
+set(gcf,'Color','white')
+if length(indSign) > 16
+    tiles = tiledlayout(7,4,'TileSpacing','tight','Padding','compact');
+    xdim_CM = 17;
+    ydim_CM = 29;
+    rowboundary = 6*4;
+    legendposition=[0.0809834738580603 0.106126702239051 0.798908480268682 0.0620588235294119];
+else
+    tiles = tiledlayout(5,4,'TileSpacing','tight','Padding','compact');
+    xdim_CM = 17.2;
+    ydim_CM = 12.5+(12.5/4);
+    rowboundary = 4*4;
+    legendposition=[0.0436898230644095 0.143818554090903 0.798908480268682 0.0620588235294118];
+end
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+letters = ['C':'Z' 'a':'z'];
+
+% Create a plot for each significant parameter
+for param = 1:length(indSign)
+    t=nexttile;
+    hold on
+    % Plot values for all of the subjects
+    % control normotensive
+    swarmchart(0.1.*ones(size(allParamValues(groups4{1},indSign(param)))),allParamValues(groups4{1},indSign(param)),2,colors{1},'*','XJitterWidth',0.08)
+    % t2d normotensive
+    swarmchart(0.2.*ones(size(allParamValues(groups4{2},indSign(param)))),allParamValues(groups4{2},indSign(param)),2,colors{2},'*','XJitterWidth',0.08)
+    % control hypertensive
+    swarmchart(0.3.*ones(size(allParamValues(groups4{3},indSign(param)))),allParamValues(groups4{3},indSign(param)),2,colors{3},'*','XJitterWidth',0.08)
+    % t2d hypertensive
+    swarmchart(0.4.*ones(size(allParamValues(groups4{4},indSign(param)))),allParamValues(groups4{4},indSign(param)),2,colors{4},'*','XJitterWidth',0.08)
+    
+    if plotMedian
+         % box plot of median values
+        cnormal = boxchart(0.1.*ones(size(allParamValues(groups4{1},indSign(param)))),allParamValues(groups4{1},indSign(param)),'BoxWidth',0.08,'BoxFaceColor',colors{1},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+        t2dnormal = boxchart(0.2.*ones(size(allParamValues(groups4{2},indSign(param)))),allParamValues(groups4{2},indSign(param)),'BoxWidth',0.08,'BoxFaceColor',colors{2},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+        chigh = boxchart(0.3.*ones(size(allParamValues(groups4{3},indSign(param)))),allParamValues(groups4{3},indSign(param)),'BoxWidth',0.08,'BoxFaceColor',colors{3},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+        t2dhigh = boxchart(0.4.*ones(size(allParamValues(groups4{4},indSign(param)))),allParamValues(groups4{4},indSign(param)),'BoxWidth',0.08,'BoxFaceColor',colors{4},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+    else
+        %error bars mean+-sd
+        cnormal = errorbar(0.1,mean4{1}(indSign(param)),sd4{1}(indSign(param)),'*','color',colors{1},'LineWidth',2);
+        t2dnormal=errorbar(0.2,mean4{2}(indSign(param)),sd4{2}(indSign(param)),'*','color',colors{2},'LineWidth',2);
+        chigh=errorbar(0.3,mean4{3}(indSign(param)),sd4{3}(indSign(param)),'*','color',colors{3},'LineWidth',2);
+        t2dhigh=errorbar(0.4,mean4{4}(indSign(param)),sd4{4}(indSign(param)),'*','color',colors{4},'LineWidth',2);
+    end
+    xlim([0 0.5])
+    
+    %find minimim and maximum y values
+    if plotMedian
+        ymax = max([max(allParamValues(groups4{1},indSign(param))),max(allParamValues(groups4{2},indSign(param))),max(allParamValues(groups4{3},indSign(param))),max(allParamValues(groups4{4},indSign(param)))]);
+        ymin = min([min(allParamValues(groups4{1},indSign(param))),min(allParamValues(groups4{2},indSign(param))),min(allParamValues(groups4{3},indSign(param))),min(allParamValues(groups4{4},indSign(param)))]);
+    else
+        max1 = 1.05*max(mean4{1}(indSign(param))+sd4{1}(indSign(param)),mean4{3}(indSign(param))+sd4{3}(indSign(param)));
+        min1 = min(mean4{1}(indSign(param))-sd4{1}(indSign(param)),mean4{3}(indSign(param))-sd4{3}(indSign(param)));
+        max2 = 1.05*max(mean4{2}(indSign(param))+sd4{2}(indSign(param)),mean4{4}(indSign(param))+sd4{4}(indSign(param)));
+        min2 = min(mean4{2}(indSign(param))-sd4{2}(indSign(param)),mean4{4}(indSign(param))-sd4{4}(indSign(param)));
+        ymax = max([allParamValues(:,indSign(param));max1;max2]);
+        ymin = min([allParamValues(:,indSign(param));min1;min2]);
+    end
+    
+    % calculate which y bounds to use and where to plot the p-values
+    if bounds.ub(indSign(param)) < ymax*1.2 %bounds close enough to values
+        plotboundsU = 1;
+        ymax = max([ymax*1.1,bounds.ub(indSign(param))*1.04]);
+    else
+        ymax = ymax*1.1;
+        plotboundsU = 0;
+    end
+    
+    if bounds.lb(indSign(param)) > ymin*0.9 %bounds close enough to values
+        plotboundsL = 1;
+        ymin = min([ymin,bounds.lb(indSign(param))*0.95]);
+    else
+        ymin = ymin*0.9;
+        plotboundsL = 0;
+    end
+    
+    y1 = 1;
+    ytext = 0.12;
+    y2 = (y1+ytext+0.15);
+    y3 = (y2+ytext+ 0.15);
+    y4 = (y3+ytext+ 0.15);
+    pvalsize = 8;
+    
+    ylim([ymin,ymax*(y4+ytext+0.01)])
+    
+
+    linecoordinates = {[0.1 0.28],[0.22 0.4],[0.32 0.4],[0.1 0.18],[0.22 0.3],[0.1 0.4]};
+    yvals = [y3,y2,y3,y2,y1,y4];
+    xvals = [0.06,0.24,0.32,0.06,0.24,0.06];
+    
+    % get p-values and print them
+    pvals = zeros(1,6);
+    for i = 1:6
+        if ~isempty(comptitles{i})
+            pvals(i) = statisticsTable.pvalues{strcmp(comptitles{i},statisticsTable.groupComparisonNames)}(indSign(param));
+            print_pval(t,xvals(i),yvals(i),linecoordinates{i},pvals(i),indSign(param),rejects{i},rejectsCorrected{i},pvalsize,ymax,ytext)
+        else
+            pvals(i) = NaN;
+        end
+    end
+    
+    % plot parameter bounds
+    if plotboundsU
+        bound=yline(bounds.ub(indSign(param)),'--');
+    else
+        bound=plot(NaN,NaN,'k--');
+    end
+    if plotboundsL
+        yline(bounds.lb(indSign(param)),'--');
+    end
+    
+    sign = plot(NaN,NaN,'w*','LineWidth',1);
+    sign2 = plot(NaN,NaN,'w*','LineWidth',1);
+    indvalue = plot(NaN,NaN,'k.','LineWidth',2);
+    outlier = plot(NaN,NaN,'k+','LineWidth',1);
+    xticklabels({});
+    xticks([0.1 0.2 0.3 0.41])
+    lastrow = (floor(length(indSign)/4))*4;
+    if mod(length(indSign),4) == 0
+        lastrow = (floor(length(indSign)/4)-1)*4;
+    end
+    if param > lastrow
+        xticklabels(names.xtick)
+        xtickangle(names.xtickangle)
+    else
+        xticklabels({});
+    end
+    ylabel(units.param(indSign(param)),'FontName','Calibri')
+    ax = gca;
+    ax.FontSize = fzsmall;
+    ax.FontName = 'Calibri';
+    if ismember(indSign(param),differentInds)
+        title(paramNamesMarked(indSign(param)),'FontSize',fzlarge,'color',[0 0 0.7],'FontName','Calibri')
+    elseif  sum(pvals(~isnan(pvals))<0.05) == 0
+        title(paramNamesMarked(indSign(param)),'FontSize',fzlarge,'color',[1 0 0],'FontName','Calibri')
+    else
+        title(paramNamesMarked(indSign(param)),'FontSize',fzlarge,'FontName','Calibri')
+    end
+    TilePos = tiles.Children.InnerPosition;
+    letter = annotation('textbox',[TilePos(1)-0.035 TilePos(2)+1.15*TilePos(4) .015 .015],'String',letters(param),'Linestyle','none','FitBoxToText','on','BackgroundColor','none','FontSize',fzlarge*1.1,'FontName','Calibri');
+end
+
+% Plot legend
+if plotMedian && (floor(length(indSign)/4))*4 <= rowboundary
+    legend([cnormal,t2dnormal,chigh,t2dhigh,bound,indvalue,outlier,sign],{...
+        sprintf('%s (N=%d)',names.legend{1},sum(groups4{1})),...
+        sprintf('%s (N=%d)',names.legend{2},sum(groups4{2})),...
+        sprintf('%s (N=%d)',names.legend{3},sum(groups4{3})),...
+        sprintf('%s (N=%d)',names.legend{4},sum(groups4{4})),...
+        'Litterature-based parameter bounds','Individual subject value','Outlier','*Significant with correction'},...
+        'FontSize',fzsmall,'Numcolumns',3,'Position',legendposition,'FontName','Calibri')
+elseif (floor(length(indSign)/4))*4 <= rowboundary
+    legend([cnormal,t2dnormal,chigh,t2dhigh,bound,indvalue],{...
+        sprintf('%s (N=%d)',names.legend{1},sum(groups4{1})),...
+        sprintf('%s (N=%d)',names.legend{2},sum(groups4{2})),...
+        sprintf('%s (N=%d)',names.legend{3},sum(groups4{3})),...
+        sprintf('%s (N=%d)',names.legend{4},sum(groups4{4})),...
+        'Litterature-based parameter bounds','Individual subject value'},...
+        'FontSize',fzsmall,'Numcolumns',3,'Position',legendposition,'FontName','Calibri')
+end
+
+end
\ No newline at end of file
diff --git a/Plotting/plot4groups_variables.m b/Plotting/plot4groups_variables.m
new file mode 100644
index 0000000000000000000000000000000000000000..ae8b5a5ef25348768c92dcadb5afacd344c6fc13
--- /dev/null
+++ b/Plotting/plot4groups_variables.m
@@ -0,0 +1,172 @@
+function plot4groups_variables(indSignComp,comptitles,groups4,mean4,sd4,statisticsTable,allValues,varnamesMarked,units,plotMedian,names,colors)
+% Define font sizes
+fzlarge = 10;
+fzsmall = 8;
+
+% Find the significantly different variables
+rejects = cell(1,6);
+rejectsCorrected = cell(1,6);
+for c = 1:6
+    if ~isempty(comptitles{c})
+        rejects{c} = statisticsTable.reject{strcmp(comptitles{c},statisticsTable.groupComparisonNames)};
+        try
+            rejectsCorrected{c} = statisticsTable.rejectBenjH2{strcmp(comptitles{c},statisticsTable.groupComparisonNames)};
+        catch
+            rejectsCorrected{c} = nan(1,length(varnamesMarked));
+        end
+    else
+        rejects{c} = nan(1,length(varnamesMarked));
+        rejectsCorrected{c} = nan(1,length(varnamesMarked));
+    end
+end
+rejectsfind = rejects;
+for c = 1:6
+    rejectsfind{c}(isnan(rejects{c})) = 0;
+end
+indSignThis = find(or(rejectsfind{1},or(rejectsfind{2},or(rejectsfind{3},or(rejectsfind{4},or(rejectsfind{5},rejectsfind{6}))))));
+if isempty(indSignComp)
+    differentInds =  [];
+    indSign = indSignThis;
+else
+    indSign = unique([indSignComp,indSignThis],'stable');
+    differentInds = indSignThis(~ismember(indSignThis,indSignComp));
+end
+
+
+% Plot
+if plotMedian
+    figure('Visible', 'off','Name',[names.figname '_median'])
+else
+    figure('Visible', 'off','Name',[names.figname '_mean'])
+end
+set(gcf,'Color','white')
+if length(indSign) > 16
+    tiledlayout(7,4,'TileSpacing','tight','Padding','compact');
+    xdim_CM = 21;
+    ydim_CM = 29;
+    rowboundary = 6*4;
+    legendposition=[0.0809834738580603 0.106126702239051 0.798908480268682 0.0620588235294119];
+elseif length(indSign) > 4
+    tiles = tiledlayout(5,4,'TileSpacing','tight','Padding','compact');
+    xdim_CM = 21;
+    ydim_CM = 15+(15/4);
+    rowboundary = 4*4;
+    legendposition=[0.0436898230644095 0.143818554090903 0.798908480268682 0.0620588235294118];
+else
+    tiles = tiledlayout(2,2,'TileSpacing','tight','Padding','compact');
+    xdim_CM = 9.5;
+    ydim_CM = 7;
+    rowboundary = 1*2;
+    legendposition=[0.0436898230644095 0.143818554090903 0.798908480268682 0.0620588235294118];
+end
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+letters = ['A':'Z' 'a':'z'];
+% create a subplot for each variable
+for var = 1:length(indSign)
+    t=nexttile;
+    hold on
+    % Plot variable values for all subjects
+    % control normotensive
+    swarmchart(0.1.*ones(size(allValues(groups4{1},indSign(var)))),allValues(groups4{1},indSign(var)),2,colors{1},'*','XJitterWidth',0.08)
+    % t2d normotensive
+    swarmchart(0.2.*ones(size(allValues(groups4{2},indSign(var)))),allValues(groups4{2},indSign(var)),2,colors{2},'*','XJitterWidth',0.08)
+    % control hypertensive
+    swarmchart(0.3.*ones(size(allValues(groups4{3},indSign(var)))),allValues(groups4{3},indSign(var)),2,colors{3},'*','XJitterWidth',0.08)
+    % t2d hypertensive
+    swarmchart(0.4.*ones(size(allValues(groups4{4},indSign(var)))),allValues(groups4{4},indSign(var)),2,colors{4},'*','XJitterWidth',0.08)
+    
+    if plotMedian
+        % box plot of median values
+        cnormal = boxchart(0.1.*ones(size(allValues(groups4{1},indSign(var)))),allValues(groups4{1},indSign(var)),'BoxWidth',0.08,'BoxFaceColor',colors{1},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+        t2dnormal = boxchart(0.2.*ones(size(allValues(groups4{2},indSign(var)))),allValues(groups4{2},indSign(var)),'BoxWidth',0.08,'BoxFaceColor',colors{2},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+        chigh = boxchart(0.3.*ones(size(allValues(groups4{3},indSign(var)))),allValues(groups4{3},indSign(var)),'BoxWidth',0.08,'BoxFaceColor',colors{3},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+        t2dhigh = boxchart(0.4.*ones(size(allValues(groups4{4},indSign(var)))),allValues(groups4{4},indSign(var)),'BoxWidth',0.08,'BoxFaceColor',colors{4},'MarkerStyle','+','MarkerColor',[0 0 0],'Notch','off');
+    else
+        %error bars mean+-sd
+        cnormal = errorbar(0.1,mean4{1}(indSign(var)),sd4{1}(indSign(var)),'*','color',colors{1},'LineWidth',2);
+        t2dnormal=errorbar(0.2,mean4{2}(indSign(var)),sd4{2}(indSign(var)),'*','color',colors{2},'LineWidth',2);
+        chigh=errorbar(0.3,mean4{3}(indSign(var)),sd4{3}(indSign(var)),'*','color',colors{3},'LineWidth',2);
+        t2dhigh=errorbar(0.4,mean4{4}(indSign(var)),sd4{4}(indSign(var)),'*','color',colors{4},'LineWidth',2);
+    end
+    xlim([0 0.5])
+    
+    %find minimim and maximum y values
+    max1 = 1.05*max(mean4{1}(indSign(var))+sd4{1}(indSign(var)),mean4{3}(indSign(var))+sd4{3}(indSign(var)));
+    min1 = min(mean4{1}(indSign(var))-sd4{1}(indSign(var)),mean4{3}(indSign(var))-sd4{3}(indSign(var)));
+    max2 = 1.05*max(mean4{2}(indSign(var))+sd4{2}(indSign(var)),mean4{4}(indSign(var))+sd4{4}(indSign(var)));
+    min2 = min(mean4{2}(indSign(var))-sd4{2}(indSign(var)),mean4{4}(indSign(var))-sd4{4}(indSign(var)));
+    ymax = max([allValues(:,indSign(var));max1;max2]);
+    ymin = min([allValues(:,indSign(var));min1;min2]);
+    ymin = ymin*0.9;
+    ymax = ymax*1.05;
+    
+    
+    % calculate which y bounds to use and where to plot the p-values
+    y1 = 1;
+    ytext = 0.09;
+    y2 = (y1+ytext+0.1);
+    y3 = (y2+ytext+ 0.1);
+    y4 = (y3+ytext+ 0.1);
+    pvalsize = 8;
+    
+    ylim([ymin,ymax*(y4+ytext+0.01)])
+    
+    pvals = zeros(1,6);
+
+    linecoordinates = {[0.1 0.28],[0.22 0.4],[0.32 0.4],[0.1 0.18],[0.22 0.3],[0.1 0.4]};
+    yvals = [y3,y2,y3,y2,y1,y4];
+    xvals = [0.06,0.24,0.32,0.06,0.24,0.06];
+    
+     % get p-values and print them
+    for i = 1:6
+        if ~isempty(comptitles{i})
+            pvals(i) = statisticsTable.pvalues{strcmp(comptitles{i},statisticsTable.groupComparisonNames)}(indSign(var));
+            print_pval(t,xvals(i),yvals(i),linecoordinates{i},pvals(i),indSign(var),rejects{i},rejectsCorrected{i},pvalsize,ymax,ytext)
+        else
+            pvals(i) = NaN;
+        end
+    end
+    
+    sign = plot(NaN,NaN,'w*','LineWidth',1);
+    indvalue = plot(NaN,NaN,'k.','LineWidth',2);
+    outlier = plot(NaN,NaN,'k+','LineWidth',1);
+    xticklabels({});
+    xticks([0.1 0.2 0.3 0.41])
+    lastrow = (floor(length(indSign)/4))*4;%4*4
+    if mod(length(indSign),4) == 0
+        lastrow = (floor(length(indSign)/4)-1)*4;
+    end
+    if var > lastrow
+        xticklabels(names.xtick)
+        xtickangle(names.xtickangle)
+    else
+        xticklabels({});
+    end
+    ylabel(sprintf('%s\n%s',varnamesMarked{indSign(var)},units{indSign(var)}))
+    
+    ax = gca;
+    ax.FontSize = fzsmall;
+    ax.FontName = 'Calibri';
+end
+
+% Plot legend
+if plotMedian && (floor(length(indSign)/4))*4 <= rowboundary
+    legend([cnormal,t2dnormal,chigh,t2dhigh,indvalue,outlier,sign],{...
+        sprintf('%s (N=%d)',names.legend{1},sum(groups4{1})),...
+        sprintf('%s (N=%d)',names.legend{2},sum(groups4{2})),...
+        sprintf('%s (N=%d)',names.legend{3},sum(groups4{3})),...
+        sprintf('%s (N=%d)',names.legend{4},sum(groups4{4})),...
+        'Individual subject value','Outlier','*Significant with correction'},...
+        'FontSize',fzsmall,'Numcolumns',3,'Position',legendposition)
+elseif (floor(length(indSign)/4))*4 <= rowboundary
+    legend([cnormal,t2dnormal,chigh,t2dhigh,indvalue],{...
+        sprintf('%s (N=%d)',names.legend{1},sum(groups4{1})),...
+        sprintf('%s (N=%d)',names.legend{2},sum(groups4{2})),...
+        sprintf('%s (N=%d)',names.legend{3},sum(groups4{3})),...
+        sprintf('%s (N=%d)',names.legend{4},sum(groups4{4})),...
+        'Individual subject value'},...
+        'FontSize',fzsmall,'Numcolumns',3,'Position',legendposition)
+end
+
+end
\ No newline at end of file
diff --git a/Plotting/plotPredictionUncertaintyNice.m b/Plotting/plotPredictionUncertaintyNice.m
new file mode 100644
index 0000000000000000000000000000000000000000..bd31c736ab7b06ea6933fcb1ffa61346eb79b8aa
--- /dev/null
+++ b/Plotting/plotPredictionUncertaintyNice.m
@@ -0,0 +1,120 @@
+function plotPredictionUncertaintyNice(simulations,simulationNames,xnames,ynames,figureName,colors)
+orange = [255 123 83]./255;
+blue = [0 176 240]./255;
+orange2 = [246 202 184]./255;
+blue2 = [173 210 231]./255;
+liuLilac = [137 129 211]./255;
+liuOrange = [255 100 65]./255;
+liuBlue = [0 185 231]./255;
+if nargin <6
+    colors = {[0 0 0],liuOrange,liuBlue,liuLilac,orange2,blue2};
+end
+fz1 = 8.5;
+fz2 = 10;
+
+r = 3;c=2;
+figure('Name',figureName,'Visible','off')
+set(gcf,'Color','white')
+set(gcf, 'InvertHardCopy', 'off'); % setting 'grid color reset' off
+xdim_CM = 17;
+ydim_CM = 12.75;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+tiles=tiledlayout(r,c,'TileSpacing','loose','Padding','compact');
+
+nexttile
+yInd = strcmp('mvCorr',ynames);
+hold on
+for s = 1:length(simulations)
+    for p = 1:length(simulations{s}.time)
+        tend = simulations{s}.time{p}(end);
+        t = 100.*[simulations{s}.time{p}./tend;flipud(simulations{s}.time{p}./tend)];
+        yvals = [simulations{s}.Observables.min{p}(:,yInd);flipud(simulations{s}.Observables.max{p}(:,yInd))];
+        fill(t,yvals,colors{s},'FaceAlpha',0.4,'EdgeColor','none');
+        plot(100.*simulations{s}.time{p}./tend,simulations{s}.Observables.best{p}(:,yInd),'-','color',colors{s},'LineWidth',2.2)
+    end
+end
+xlabel('% of cardiac cycle','FontSize',fz1)
+ylabel('Flow in mitral valve (ml/s)','FontSize',fz1)
+set(gca,'FontSize',fz1)
+
+nexttile
+hold on
+yInd = strcmp('avCorr',ynames);
+for s = 1:length(simulations)
+    for p = 1:length(simulations{s}.time)
+        tend = simulations{s}.time{p}(end);
+        t = 100.*[simulations{s}.time{p}./tend;flipud(simulations{s}.time{p}./tend)];
+        yvals = [simulations{s}.Observables.min{p}(:,yInd);flipud(simulations{s}.Observables.max{p}(:,yInd))];
+        sims(s)=fill(t,yvals,colors{s},'FaceAlpha',0.4,'EdgeColor','none');
+        plot(100.*simulations{s}.time{p}./tend,simulations{s}.Observables.best{p}(:,yInd),'-','color',colors{s},'LineWidth',2.2)
+    end
+end
+xlabel('% of cardiac cycle','FontSize',fz1)
+ylabel('Flow in aortic valve (ml/s)','FontSize',fz1)
+set(gca,'FontSize',fz1)
+
+t1=nexttile;
+colororder(t1,{'k','k'})%y axis colors
+yInd = strcmp('Ela',ynames);
+hold on
+yyaxis right
+ymax = 0;
+for s = 1:length(simulations)
+    for p = 1:length(simulations{s}.time)
+        tend = simulations{s}.time{p}(end);
+        t = 100.*[simulations{s}.time{p}./tend;flipud(simulations{s}.time{p}./tend)];
+        yvals = [simulations{s}.Observables.min{p}(:,yInd);flipud(simulations{s}.Observables.max{p}(:,yInd))];
+        fill(t,yvals,colors{s},'FaceAlpha',0.4,'EdgeColor','none')
+        plot(100.*simulations{s}.time{p}./tend,simulations{s}.Observables.best{p}(:,yInd),'-','color',colors{s},'LineWidth',2.2)
+        ymax = max([ymax,max(simulations{s}.Observables.max{p}(:,yInd))]);
+    end
+end
+ylim([-ymax ymax])
+
+yyaxis left
+yInd = strcmp('Elv',ynames);
+ymax=0;
+for s = 1:length(simulations)
+    for p = 1:length(simulations{s}.time)
+        tend = simulations{s}.time{p}(end);
+        t = 100.*[simulations{s}.time{p}./tend;flipud(simulations{s}.time{p}./tend)];
+        yvals = [simulations{s}.Observables.min{p}(:,yInd);flipud(simulations{s}.Observables.max{p}(:,yInd))];
+        fill(t,yvals,colors{s},'FaceAlpha',0.4,'EdgeColor','none')
+        plot(100.*simulations{s}.time{p}./tend,simulations{s}.Observables.best{p}(:,yInd),'-','color',colors{s},'LineWidth',2.2)
+        ymax = max([ymax,max(simulations{s}.Observables.max{p}(:,yInd))]);
+    end
+end
+ylim([0 ymax*2])
+xlabel('% of cardiac cycle','FontSize',fz1)
+yyaxis left
+ylabel(sprintf('Time-varying elastance\nin LV (mmHg/ml)'),'FontSize',fz1)
+yyaxis right
+ylabel(sprintf('Time-varying elastance\nin LA (mmHg/ml)'),'FontSize',fz1)
+set(gca,'FontSize',fz1)
+xlim([0 100])
+
+yparamsToPlot = {'P_Aortic','pLA','pLV'};
+ylabels = {'Aortic pressure (mmHg)','Pressure in LA (mmHg)','Pressure in LV (mmHg)'};
+for y = 1:length(yparamsToPlot)
+    nexttile
+    yInd = strcmp(yparamsToPlot{y},ynames);
+    hold on
+    for s = 1:length(simulations)
+        for p = 1:length(simulations{s}.time)
+            tend = simulations{s}.time{p}(end);
+            t = 100.*[simulations{s}.time{p}./tend;flipud(simulations{s}.time{p}./tend)];
+            yvals = [simulations{s}.Observables.min{p}(:,yInd);flipud(simulations{s}.Observables.max{p}(:,yInd))];
+            fill(t,yvals,colors{s},'FaceAlpha',0.4,'EdgeColor','none')%0.6
+            plot(100.*simulations{s}.time{p}./tend,simulations{s}.Observables.best{p}(:,yInd),'-','color',colors{s},'LineWidth',2.2)
+        end
+    end
+    xlabel('% of cardiac cycle','FontSize',fz1)
+    ylabel(ylabels{y},'FontSize',fz1)
+    set(gca,'FontSize',fz1)
+    xlim([0 100])
+end
+l=legend(sims,simulationNames,'Location','NorthEast','FontSize',8);
+set(l,'position',[0.765074192528902 0.802419119653766 0.189153435526702 0.154320983396847]);
+
+end
\ No newline at end of file
diff --git a/Plotting/plot_fitToData_uncertainty.m b/Plotting/plot_fitToData_uncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..7ab7e914401540ae1c58b231c6b30ef31e846f94
--- /dev/null
+++ b/Plotting/plot_fitToData_uncertainty.m
@@ -0,0 +1,419 @@
+function plot_fitToData_uncertainty(minmaxSim,patNums,bestparams,paramuncertainty,paramNames,data,inds,bestcost,plotFolderName)
+
+%% Define colors, setup
+paramcol = [21,96,122]./255;%blue
+paramcol2 = [255 181 95]./255;%yellow
+colorParams = paramcol;
+
+bluescale = {[208,209,230]./255,[200,188,220]./255,[166,189,219]./255,[116,169,207]./255,[54,144,192]./255,[5,112,176]./255,[3,78,123]./255};
+namesavatar = {'pulmonary','LA','MV','LV','AV','AA','peripheral'};
+colororder = {'MV','AV','AA','pulmonary','LA','LV','peripheral'};
+[~,colind] = ismember(colororder,namesavatar);
+bluescaleordered = bluescale(colind);
+colors = bluescaleordered;
+
+% set font sizes
+fz1 = 10;
+fzsmall = 7;
+letters = 'A':'P';
+
+%load groups
+[groups] = loadGroupIndexes(patNums);
+
+%% Find the subjects with worst, median, and best fit to data
+comparisoncost = bestcost;
+% best
+[bestcost,pbest] = min(comparisoncost);
+% median
+pmedianorder = round(length(comparisoncost)/2);
+[sorttotalcost,sortpatstotalcost] = sort(comparisoncost);
+mediancost = sorttotalcost(pmedianorder);
+pmedian = sortpatstotalcost(pmedianorder);
+% worst
+[worstcost,pworst] = max(comparisoncost);
+
+%% Find the subjects with best fit to data within each group
+% hypertension is defined both during MR and home BP
+% best t2d+hypertensive
+costT2Dhyp = comparisoncost(groups.T2D_HT_home & groups.hypertensionMR);
+[bestcostT2Dh,pbestT2Dh] = min(costT2Dhyp);
+patNumsT2DHT = patNums(groups.T2D_HT_home & groups.hypertensionMR);
+pbestT2Dh=patNumsT2DHT{pbestT2Dh};
+
+% best t2d
+costT2Dnormal = comparisoncost(groups.T2D_NT_home & groups.nothypertensionMR);
+[bestcostT2Dn,pbestT2Dn] = min(costT2Dnormal);
+patNumsT2D = patNums(groups.T2D_NT_home & groups.nothypertensionMR);
+pbestT2Dn=patNumsT2D{pbestT2Dn};
+
+% best control
+costCnormal = comparisoncost(groups.C_NT_home & groups.nothypertensionMR);
+[bestcostCn,pbestCn] = min(costCnormal);
+patNumsC= patNums(groups.C_NT_home & groups.nothypertensionMR);
+pbestCn=patNumsC{pbestCn};
+
+% best hypertensive
+costChigh = comparisoncost(groups.C_HT_home & groups.hypertensionMR);
+[bestcostCh,pbestCh] = min(costChigh);
+patNumsHT= patNums(groups.C_HT_home & groups.hypertensionMR);
+pbestCh=patNumsHT{pbestCh};
+
+
+save('../Parameters/bestpatients.mat','pbestT2Dh','pbestT2Dn','pbestCn','pbestCh')
+
+
+%% Plot the blood flow simulation vs data for 3 example subjects
+selectedNums = [pbest,pmedian,pworst];
+titles = {sprintf('Best fit to data (V=%0.1f)',bestcost),...
+    sprintf('Median fit to data (V=%0.1f)',mediancost),...
+    sprintf('Worst fit to data (V=%0.1f)',worstcost)};
+
+figure('Visible', 'off','Name','Flows - data vs simulation 3 examples uncertainty');
+set(gcf,'Color','white')
+xdim_CM = 21;
+ydim_CM = 6;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+tiles=tiledlayout(1,3,'TileSpacing','loose','Padding','compact');
+for pat = 1:length(selectedNums)
+    p = selectedNums(pat);
+    nexttile(tiles)
+    hold on
+    simtime = minmaxSim.time{p};
+    datatime = data{p}.MV(:,1);
+    tend = datatime(end);
+    tstart = datatime(1);
+    indd = data{p}.indtdiast;
+    
+    %Plot the data
+    cdat(1)=plot(datatime(indd:end,1),data{p}.MV(indd:end,2),'o','color',colors{1},'LineWidth',1.5);
+    cdat(2)=plot(datatime(1:indd),data{p}.AV(1:indd,2),'^','color',colors{2},'LineWidth',1.5);
+    cdat(3)=plot(datatime(1:indd),data{p}.AC(1:indd,2),'square','color',colors{3},'LineWidth',1.5);
+    cdat(4)=plot(datatime,data{p}.PV(:,2),'diamond','color',colors{4},'LineWidth',1.5);
+    
+    % Plot the simulation uncertainty
+    t = [simtime;flipud(minmaxSim.time{p})];
+    MV = [minmaxSim.States.min{p}(:,inds{p}.MV);flipud(minmaxSim.States.max{p}(:,inds{p}.MV))];
+    fill(t,MV,colors{1},'FaceAlpha',0.6,'EdgeColor','none')
+    AA = [minmaxSim.States.min{p}(:,inds{p}.AC);flipud(minmaxSim.States.max{p}(:,inds{p}.AC))];
+    fill(t,AA,colors{3},'FaceAlpha',0.8,'EdgeColor','none')
+    AV = [minmaxSim.States.min{p}(:,inds{p}.AV);flipud(minmaxSim.States.max{p}(:,inds{p}.AV))];
+    fill(t,AV,colors{2},'FaceAlpha',0.6,'EdgeColor','none')
+    PV = [minmaxSim.States.min{p}(:,inds{p}.PV);flipud(minmaxSim.States.max{p}(:,inds{p}.PV))];
+    fill(t,PV,colors{4},'FaceAlpha',0.6,'EdgeColor','none')
+    
+    % Plot the simulation that best fit to data
+    plot(simtime,minmaxSim.States.best{p}(:,inds{p}.MV),'-','color',0.9.*colors{1},'LineWidth',2)
+    plot(simtime,minmaxSim.States.best{p}(:,inds{p}.AV),'-','color',0.9.*colors{2},'LineWidth',2)
+    plot(simtime,minmaxSim.States.best{p}(:,inds{p}.AC),'-','color',0.9.*colors{3},'LineWidth',2)
+    plot(simtime,minmaxSim.States.best{p}(:,inds{p}.PV),'-','color',0.9.*colors{4},'LineWidth',2)
+    
+    xlim([tstart tend])
+    xticks(0:0.1:tend)
+    alllabels = strsplit(num2str(0:0.1:tend));
+    alllabels(2:2:end-2) = {''};
+    xticklabels(alllabels)
+    xtickangle(0)
+    ylim([-100 425])
+    yticks(-100:100:425)
+    yticklabels({'-100','0','','200','','400','','600'})
+    
+    set(gca,'FontSize',fz1)
+    xlabel('Time (s)','FontSize',fz1)
+    ylabel('Flow volume (ml/s)','FontSize',fz1)
+    title(titles{pat},'FontSize',fz1)
+    TilePos = tiles.Children.InnerPosition;
+    letter = annotation('textbox',[TilePos(1)-0.045 TilePos(2)+1.15*TilePos(4) .015 .015],'String',letters(pat),'Linestyle','none','FitBoxToText','on','BackgroundColor','none');
+end
+s=plot(NaN,NaN,'k-','linewidth',2);
+legend([s,cdat],{'Simulation','Data MV','Data AV','Data AA','Data PV'},'FontSize',8,'NumColumns',2,...
+                'Position',[0.120675725046687 0.719565923782884 0.2 0.17])
+legend('boxoff')
+
+
+%% Plot the fit to data in the one subjects with best overall fit to data (used in the method figure)
+% Fit to parameter data
+figure('Visible', 'off','Name','Parameters fit to data (best fit)');
+xdim_CM = 10; 
+ydim_CM = 6;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+dataparams = {'Emax_LV','Caa','Ctot','Rtot','ElCo'};
+pat = pbest;
+ind = inds{pat};
+ymin = 0;
+ymax = 0;
+hold on
+[lb,ub] = loadParamBounds_HEALTH(ind,data{pat}.params);
+lb = log10(lb);ub=log10(ub);
+
+maxparpat = paramuncertainty.maxValuesparams(:,pat);
+minparpat = paramuncertainty.minValuesparams(:,pat);
+plotparpat = bestparams(:,pat);
+for p = 1:length(dataparams)
+    pvalmin = minparpat(ind.(dataparams{p}));
+    pvalmax = maxparpat(ind.(dataparams{p}));
+    pvalbest = plotparpat(ind.(dataparams{p}));
+    dval = data{pat}.params.(dataparams{p});
+    emin = abs(log10(pvalbest)-log10(pvalmin));
+    emax = abs(log10(pvalmax)-log10(pvalbest));
+    errorbar(p,log10(pvalbest),emin,emax,'.','color',colorParams,'LineWidth',1.5,'MarkerSize',20)
+    plot(p,log10(dval(1)),'ko','LineWidth',1)
+    plot([p-0.5,p+0.5],[lb(ind.(dataparams{p})),lb(ind.(dataparams{p}))],'k--')
+    plot([p-0.5,p+0.5],[ub(ind.(dataparams{p})),ub(ind.(dataparams{p}))],'k--')
+    ymin = min(ymin,lb(ind.(dataparams{p})));
+    ymax = max(ymax,ub(ind.(dataparams{p})));
+end
+%sbp
+emin = abs(log10(minmaxSim.SBP.best{p})-log10(minmaxSim.SBP.min{p}));
+emax = abs(log10(minmaxSim.SBP.max{p})-log10(minmaxSim.SBP.best{p}));
+errorbar(length(dataparams)+1,log10(minmaxSim.SBP.best{p}),emin,emax,'.','color',colorParams,'LineWidth',1.5,'MarkerSize',20)
+plot(length(dataparams)+1,log10(data{pat}.SBP),'ko','LineWidth',1)
+
+%dbp
+emin = log10(minmaxSim.DBP.best{p})-log10(minmaxSim.DBP.min{p});
+emax = log10(minmaxSim.DBP.max{p})-log10(minmaxSim.DBP.best{p});
+errorbar(length(dataparams)+2,log10(minmaxSim.DBP.best{p}),max(0,emin),max(0,emax),'.','color',colorParams,'LineWidth',1.5,'MarkerSize',20)
+plot(length(dataparams)+2,log10(data{pat}.DBP),'ko','LineWidth',1)
+ymax = max([ymax,log10(data{pat}.SBP),log10(minmaxSim.SBP.max{p})]);
+ymin = min([ymin,log10(data{pat}.DBP),log10(minmaxSim.DBP.min{p})]);
+    
+ylim([ymin*1.1,ymax*1.1])
+xlim([0,length(dataparams)+1+2])
+xticks(1:length(dataparams)+2)
+dataparamsNames = {'Emax LV','Caa','Ctot','Rtot','ElCo','SBP','DBP'};
+xticklabels(dataparamsNames);
+ylabel(sprintf('Parameter value\n(log10)'))
+set(gca,'FontSize',12)
+
+% Fit to blood flow data
+figure('Visible', 'off','Name','Flows fit to data (best fit)');
+set(gcf,'Color','white')
+xdim_CM = 24; 
+ydim_CM = 6;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+p = pbest;
+hold on
+simtime = minmaxSim.time{p};
+datatime = data{p}.time;
+tend = datatime(end);
+tstart = datatime(1);
+indd = data{p}.indtdiast;
+% Plot data
+plot(datatime(indd:end),data{p}.MV(indd:end,2),'o','color',colors{1},'LineWidth',1.5);
+plot(datatime(1:indd),data{p}.AV(1:indd,2),'^','color',colors{2},'LineWidth',1.5);
+plot(datatime(1:indd),data{p}.AC(1:indd,2),'square','color',colors{3},'LineWidth',1.5);
+plot(datatime,data{p}.PV(:,2),'diamond','color',colors{4},'LineWidth',1.5);
+
+% Plot simulation uncertainty
+t = [simtime;flipud(minmaxSim.time{p})];
+MV = [minmaxSim.States.min{p}(:,inds{p}.MV);flipud(minmaxSim.States.max{p}(:,inds{p}.MV))];
+fill(t,MV,colors{1},'FaceAlpha',0.6,'EdgeColor','none')
+AA = [minmaxSim.States.min{p}(:,inds{p}.AC);flipud(minmaxSim.States.max{p}(:,inds{p}.AC))];
+fill(t,AA,colors{3},'FaceAlpha',0.8,'EdgeColor','none')
+AV = [minmaxSim.States.min{p}(:,inds{p}.AV);flipud(minmaxSim.States.max{p}(:,inds{p}.AV))];
+fill(t,AV,colors{2},'FaceAlpha',0.6,'EdgeColor','none')
+PV = [minmaxSim.States.min{p}(:,inds{p}.PV);flipud(minmaxSim.States.max{p}(:,inds{p}.PV))];
+fill(t,PV,colors{4},'FaceAlpha',0.6,'EdgeColor','none')
+
+% Plot simulation with best fit to data
+plot(simtime,minmaxSim.States.best{p}(:,inds{p}.MV),'-','color',0.9.*colors{1},'LineWidth',2)
+plot(simtime,minmaxSim.States.best{p}(:,inds{p}.AV),'-','color',0.9.*colors{2},'LineWidth',2)
+plot(simtime,minmaxSim.States.best{p}(:,inds{p}.AC),'-','color',0.9.*colors{3},'LineWidth',2)
+plot(simtime,minmaxSim.States.best{p}(:,inds{p}.PV),'-','color',0.9.*colors{4},'LineWidth',2)
+
+xlim([tstart round(tend,1)])
+ymax=  max([minmaxSim.States.max{p}(:,inds{p}.AV);minmaxSim.States.max{p}(:,inds{p}.AC);data{p}.AV(:,2);data{p}.AC(:,2)]);
+ymin = min([minmaxSim.States.min{p}(:,inds{p}.AC);minmaxSim.States.min{p}(:,inds{p}.AV);minmaxSim.States.min{p}(:,inds{p}.PV);data{p}.PV(:,2)]);
+ylim([ymin,ymax])
+if round(ymin,-1)<0
+    yticks([round(ymin,-1),[0:100:round(ymax,-2)]])
+else
+    yticks([0:100:round(ymax,-2)])
+end
+xticks([tstart,tend/2,round(tend,1)]);
+xticklabels({num2str(tstart),'',num2str(round(tend,1))})
+xlabel('Time (s)')
+ylabel('Flow (ml/s)')
+set(gca,'FontSize',12)
+
+%% Create plots of fit to parameter data for all subjects
+% Collect the parameter data from all sujbects
+dvalsDataparams = cell(size(dataparams));
+pvalsDataparams = cell(size(dataparams));
+
+for param = 1:length(dataparams)
+    pvals = zeros(size(patNums));
+    dvals = zeros(size(patNums));
+    for pat = 1:length(patNums)
+        theta = bestparams(:,pat);
+        pvals(pat) = theta(ind.(dataparams{param}));
+        dval = data{pat}.params.(dataparams{param});
+        dvals(pat) = dval(1);
+    end
+    dvalsDataparams{param} = dvals;
+    pvalsDataparams{param} = pvals;
+end
+
+DBP = zeros(size(patNums));
+SBP = DBP;dataDBP=DBP;dataSBP=DBP;
+for p = 1:length(patNums)
+    DBP(p) = minmaxSim.DBP.best{p};
+    SBP(p) = minmaxSim.SBP.best{p};
+    dataDBP(p) = data{p}.DBP;
+    dataSBP(p) = data{p}.SBP;
+end
+
+% Create bland altman plot of parameters fit to data 
+figure('Visible', 'off','Name','Parameters fit to data compact bland altman uncertainty');
+LW=1;
+set(gcf,'Color','white')
+xdim_CM = 21; 
+ydim_CM = 15;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+dataparams = {'Emax_LV','Caa','Ctot','Rtot','ElCo'};
+dataparamsTitles = {'Emax_L_V','Caa','Ctot','Rtot','ElCo'};
+dataparamsUnits = {'mmHg/mL','mL/mmHg','mL/mmHg','mmHg·s/mL','cm^2'};
+tiles=tiledlayout(2,3,'TileSpacing','loose','Padding','compact');
+t1=nexttile;
+TilePos = tiles.Children.InnerPosition;
+annotation('textbox',[TilePos(1)-0.035 TilePos(2)+1.05*TilePos(4) .015 .015],'String',letters(1),'Linestyle','none','FitBoxToText','on','BackgroundColor','none');
+hold on
+
+%SBP
+averageS = (dataSBP+SBP)./2;
+differenceS = (dataSBP-SBP);
+averageD = (dataDBP+DBP)./2;
+differenceD = (dataDBP-DBP);
+maxx = max(averageS)*1.1;
+minx = min(averageD)*0.9;
+sbpplot=plot(averageS,differenceS,'.','color',paramcol2,'LineWidth',1,'Markersize',10);
+yline(mean(differenceS),'-','color',paramcol2,'LineWidth',LW*2);
+high = mean(differenceS)+std(differenceS)*1.96;
+low = mean(differenceS)-std(differenceS)*1.96;
+fill([minx,minx,maxx,maxx],[low,high,high,low],paramcol2,'FaceAlpha',0.3,'LineStyle','None')
+
+%DBP
+dbpplot=plot(averageD,differenceD,'.','color',paramcol,'LineWidth',1,'Markersize',10);
+yline(mean(differenceD),'-','color',paramcol,'LineWidth',LW*2);
+high = mean(differenceD)+std(differenceD)*1.96;
+low = mean(differenceD)-std(differenceD)*1.96;
+fill([minx,minx,maxx,maxx],[low,high,high,low],paramcol,'FaceAlpha',0.15,'LineStyle','None')
+for p = 1:length(patNums)
+    diff1 = dataSBP(p)-minmaxSim.SBP.min{p};
+    diff2 = dataSBP(p)-minmaxSim.SBP.max{p};
+    diffmax = max([diff1,diff2,differenceS(p)]);
+    diffmin = min([diff1,diff2,differenceS(p)]);
+    es=errorbar(averageS(p),differenceS(p),differenceS(p)-diffmin,diffmax-differenceS(p),'.','color',paramcol2,'LineWidth',0.9);
+    set([es.Bar, es.Line], 'ColorType', 'truecoloralpha', 'ColorData', [es.Line.ColorData(1:3); 255*0.3]);
+    diff1 = dataDBP(p)-minmaxSim.DBP.min{p};
+    diff2 = dataDBP(p)-minmaxSim.DBP.max{p};
+    diffmax = max([diff1,diff2,differenceD(p)]);
+    diffmin = min([diff1,diff2,differenceD(p)]);
+    ed=errorbar(averageD(p),differenceD(p),differenceD(p)-diffmin,diffmax-differenceD(p),'.','color',paramcol,'LineWidth',0.9);
+    set([ed.Bar, ed.Line], 'ColorType', 'truecoloralpha', 'ColorData', [ed.Line.ColorData(1:3); 255*0.3]);
+end 
+xlabel('Average (mmHg)','FontSize',fz1)
+ylabel(sprintf('Brachial pressure (mmHg)\nData - Simulation'),'FontSize',fz1)
+xlim([minx maxx])
+set(gca,'FontSize',fz1)
+
+% The data-based parameters
+for param = 1:length(dataparams)
+    t=nexttile;
+    paramind = strcmp(paramNames,dataparams{param});
+    createBlandAltmanPlot_uncertainty(t,tiles,dvalsDataparams{param},pvalsDataparams{param},paramcol,[0 0 0],LW,['Average (' dataparamsUnits{param} ')'],sprintf('%s (%s)\nData - Parameter value', dataparamsTitles{param},dataparamsUnits{param}),letters(param+1),paramuncertainty.allokParams,paramind)
+    set(gca,'FontSize',fz1)
+end
+
+legend(t1,[ed,sbpplot,dbpplot],{'Uncertainty','SBP','DBP'},'FontSize',7,...
+    'Position',[0.196000225159964 0.889744944420004 0.12 0.07]);
+
+%% Plot the fit to blood flow data in ALL subjects (supplementary figure)
+realPatNumsTitles = 0;
+LWsim = 1.5;
+LWdata = 1;
+figure('Visible', 'off','Name','Flows - data vs simulation ALL uncertainty');
+set(gcf,'Color','white')
+xdim_CM = 20;
+ydim_CM = (20/21)*29.7;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+c=6;
+r = ceil(length(patNums)/c);
+tiles = tiledlayout(r,c);
+tiles.Padding = 'none';
+tiles.TileSpacing = 'tight';
+for pnum = 1:length(sortpatstotalcost)
+    p = sortpatstotalcost(pnum);
+     nexttile
+     hold on
+    simtime = minmaxSim.time{p};
+    datatime = data{p}.MV(:,1);
+    tend = datatime(end);
+    indd = data{p}.indtdiast;
+    
+    maxflow = max([minmaxSim.States.max{p}(:,inds{p}.MV);...
+        minmaxSim.States.max{p}(:,inds{p}.AV);...
+        minmaxSim.States.max{p}(:,inds{p}.AC);...
+        minmaxSim.States.max{p}(:,inds{p}.PV);...
+        data{p}.MV(indd:end,2);data{p}.AV(1:indd,2);data{p}.AC(1:indd,2);data{p}.PV(:,2)]);
+    
+    % Plot simulation uncertainty
+    t = [100*simtime./tend;flipud(100*simtime./tend)];
+    MV = [minmaxSim.States.min{p}(:,inds{p}.MV);flipud(minmaxSim.States.max{p}(:,inds{p}.MV))];
+    fill(t,100*MV./maxflow,colors{1},'FaceAlpha',0.6,'EdgeColor','none')
+    AA = [minmaxSim.States.min{p}(:,inds{p}.AC);flipud(minmaxSim.States.max{p}(:,inds{p}.AC))];
+    fill(t,100*AA./maxflow,colors{3},'FaceAlpha',0.8,'EdgeColor','none')
+    AV = [minmaxSim.States.min{p}(:,inds{p}.AV);flipud(minmaxSim.States.max{p}(:,inds{p}.AV))];
+    fill(t,100*AV./maxflow,colors{2},'FaceAlpha',0.6,'EdgeColor','none')
+    PV = [minmaxSim.States.min{p}(:,inds{p}.PV);flipud(minmaxSim.States.max{p}(:,inds{p}.PV))];
+    fill(t,100*PV./maxflow,colors{4},'FaceAlpha',0.6,'EdgeColor','none')
+    
+    % Plot simulation with best fit to data
+    plot(100*simtime./tend,minmaxSim.States.best{p}(:,inds{p}.MV)./maxflow,'-','color',0.9.*colors{1},'LineWidth',LWsim)
+    plot(100*simtime./tend,minmaxSim.States.best{p}(:,inds{p}.AV)./maxflow,'-','color',0.9.*colors{2},'LineWidth',LWsim)
+    plot(100*simtime./tend,minmaxSim.States.best{p}(:,inds{p}.AC)./maxflow,'-','color',0.9.*colors{3},'LineWidth',LWsim)
+    plot(100*simtime./tend,minmaxSim.States.best{p}(:,inds{p}.PV)./maxflow,'-','color',0.9.*colors{4},'LineWidth',LWsim)
+    
+    % Plot data
+    d(1)=plot(100*datatime(indd:end,1)./tend,100*data{p}.MV(indd:end,2)./maxflow,'o','color',colors{1},'LineWidth',LWdata,'MarkerSize',2);
+    d(2)=plot(100*datatime(1:indd)./tend,100*data{p}.AV(1:indd,2)./maxflow,'^','color',colors{2},'LineWidth',LWdata,'MarkerSize',2);
+    d(3)=plot(100*datatime(1:indd)./tend,100*data{p}.AC(1:indd,2)./maxflow,'square','color',colors{3},'LineWidth',LWdata,'MarkerSize',2);
+    d(4)=plot(100*datatime./tend,100*data{p}.PV(:,2)./maxflow,'diamond','color',colors{4},'LineWidth',LWdata,'MarkerSize',2);
+    
+    xlim([0 100])
+    ylim([-30 100])
+    set(gca,'FontSize',fzsmall)
+    if pnum > c*(r-1)
+        xlabel('% of cardiac cycle','FontSize',fzsmall)
+        xticks([0 50 100])
+    else
+        xticks([])
+    end
+    if mod(pnum,c) == 1
+        yticks([-30 0 50 100])
+        ylabel('% of max flow','FontSize',fzsmall)
+    else
+        yticks([])
+    end
+    titlename = groupTitle(groups,p,patNums,realPatNumsTitles,num2str(pnum)); 
+    title(titlename,'FontSize',fzsmall)
+    hold off
+end
+tiles.Padding = 'none';
+tiles.TileSpacing = 'tight';
+hold on
+sim = plot(NaN,NaN,'k-','Linewidth',1);
+unc = fill(NaN,NaN,[0.5 0.5 0.5]);
+legend([sim,unc,d],{'Simulation: best fit to data',...
+    'Simulation uncertainty','Data MV','Data AV','Data AA','Data PV'},'FontSize',8,'Position',[0.415961204816109 0.00345895415058883 0.23015872530994 0.0846585570594995])
+
+%% Save all figures
+saveAllFigures(plotFolderName)
+
+clear minmaxSim
+
+end
\ No newline at end of file
diff --git a/Plotting/plot_parameterCorrelations.m b/Plotting/plot_parameterCorrelations.m
new file mode 100644
index 0000000000000000000000000000000000000000..406bd714865dd614d85f0a85a297a3002a771946
--- /dev/null
+++ b/Plotting/plot_parameterCorrelations.m
@@ -0,0 +1,109 @@
+function plot_parameterCorrelations(paramValues,constants,paramNames,simLast,ind,data,extradata,patNums,ynames,plotFolderName)
+
+%% Set values
+%Pre-define vectors
+Caas = zeros(1,length(patNums));
+EmaxLVs = zeros(1,length(patNums));
+Cpvcs = zeros(1,length(patNums));
+Raos = zeros(1,length(patNums));
+m2LVs = zeros(1,length(patNums));
+m1LVs = zeros(1,length(patNums));
+k_syst_LVs=zeros(1,length(patNums));
+k_diast_LVs=zeros(1,length(patNums));
+
+HbA1c=zeros(1,length(patNums));HR = zeros(1,length(patNums));
+diabduration=zeros(1,length(patNums));
+SBPhome=zeros(1,length(patNums));DBPhome=zeros(1,length(patNums));
+SBPduringMRI_data=zeros(1,length(patNums));
+
+% Get values for each subject
+for p = 1:length(patNums)
+    % Parameters
+    EmaxLVs(p) = paramValues(ind.Emax_LV,p);
+    Raos(p) = paramValues(strcmp(paramNames,'Rao'),p);
+    Caas(p) = paramValues(ind.Caa,p);
+    m2LVs(p) = paramValues(strcmp(paramNames,'m2_LV'),p);
+    m1LVs(p) = paramValues(strcmp(paramNames,'m1_LV'),p);
+    k_syst_LVs(p) = paramValues(strcmp(paramNames,'k_syst_LV'),p);
+    k_diast_LVs(p) = paramValues(strcmp(paramNames,'k_diast_LV'),p);
+    Cpvcs(p) =  paramValues(strcmp(paramNames,'Cpvc'),p);
+    
+    % Long- and shortterm markers
+    HR(p) = 60/constants(ind.T,p);
+    HbA1c(p) = extradata{p}.SCAPIS.hbA1c;
+    diabduration(p) = extradata{p}.SCAPIS.diabDuration;
+    SBPhome(p) = extradata{p}.HomeBP.SBPmean;
+    DBPhome(p) = extradata{p}.HomeBP.DBPmean;
+    SBPduringMRI_data(p)=data{p}.SBP;
+end
+
+%% Calculate and plot correlations
+figure('Visible', 'off','Name','Correlations_summary');
+set(gcf,'Color','white')
+xdim_CM = 20;
+ydim_CM = 15;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+t = tiledlayout(3,2,'TileSpacing','Compact','Padding','compact');
+corrvarnames = {'m2LV','Cpvc','k_s_y_s_t_L_V','k_d_i_a_s_t_L_V','m1LV','EmaxLV','Rao','Caa'};
+corrvars = {m2LVs,Cpvcs, k_syst_LVs,k_diast_LVs,m1LVs,EmaxLVs,Raos,Caas};
+p = zeros(6,length(corrvars)); 
+r2 = zeros(6,length(corrvars));
+rho = zeros(6,length(corrvars));
+numobs = zeros(6,length(corrvars));
+testtype=cell(6,length(corrvars));
+nexttile(t);
+[p(1,:),r2(1,:),rho(1,:),numobs(1,:),testtype(1,:)] = createSummaryCorrelationPlot('Correlation with heartrate during MRI',corrvarnames,corrvars,HR);
+
+nexttile(t);
+x = SBPduringMRI_data;
+[p(2,:),r2(2,:),rho(2,:),numobs(2,:),testtype(2,:)] =createSummaryCorrelationPlot('Correlation with SBP during MRI',corrvarnames,corrvars,x);
+
+nexttile(t);
+[p(3,:),r2(3,:),rho(3,:),numobs(3,:),testtype(3,:)] =createSummaryCorrelationPlot('Correlation with HbA1c',corrvarnames,corrvars,HbA1c);
+
+nexttile(t);
+[p(4,:),r2(4,:),rho(4,:),numobs(4,:),testtype(4,:)] =createSummaryCorrelationPlot('Correlation with Diabetes duration',corrvarnames,corrvars,diabduration);
+
+nexttile(t);
+[p(5,:),r2(5,:),rho(5,:),numobs(5,:),testtype(5,:)] =createSummaryCorrelationPlot('Correlation with home SBP',corrvarnames,corrvars,SBPhome);
+
+nexttile(t);
+[p(6,:),r2(6,:),rho(6,:),numobs(6,:),testtype(6,:)] =createSummaryCorrelationPlot('Correlation with home DBP',corrvarnames,corrvars,DBPhome);
+
+%% Save figures
+saveAllFigures(plotFolderName)
+
+%% Create summary table of the correlations
+correlationTablesummary = table;
+corrnames = {'HR','SBP MR','Hba1c','diabdur','SBPhome','DBPhome'};
+correlationTablesummary.corr = cell(length(corrnames)*length(corrvarnames),1);
+correlationTablesummary.corrvar = cell(length(corrnames)*length(corrvarnames),1);
+correlationTablesummary.n = cell(length(corrnames)*length(corrvarnames),1);
+correlationTablesummary.rho = cell(length(corrnames)*length(corrvarnames),1);
+correlationTablesummary.p = cell(length(corrnames)*length(corrvarnames),1);
+correlationTablesummary.r2 = cell(length(corrnames)*length(corrvarnames),1);
+correlationTablesummary.testtype = cell(length(corrnames)*length(corrvarnames),1);
+n=1;
+for c = 1:length(corrnames)
+    correlationTablesummary.corr{n} = corrnames{c};
+    for v = 1:length(corrvarnames)
+        correlationTablesummary.corrvar{n} = corrvarnames{v};
+        if p(c,v) < 0.0001
+            correlationTablesummary.p{n} = '<0.0001';
+        else
+            correlationTablesummary.p{n} = sprintf('%0.4f',p(c,v));
+        end
+        correlationTablesummary.n{n} = numobs(c,v);
+        correlationTablesummary.testtype{n} = testtype{c,v};
+        correlationTablesummary.r2{n} = sprintf('%0.4f',r2(c,v));
+        correlationTablesummary.rho{n} = sprintf('%0.4f',rho(c,v));
+        n=n+1;
+    end
+end
+
+%save table for statistical summary document
+writetable(correlationTablesummary,fullfile(plotFolderName,'statisticssummary_correlations.xlsx'))
+
+
+end
diff --git a/Plotting/plot_parameterDifferences.m b/Plotting/plot_parameterDifferences.m
new file mode 100644
index 0000000000000000000000000000000000000000..dbe3b064c1d881e53216ef68c225f413d5a45946
--- /dev/null
+++ b/Plotting/plot_parameterDifferences.m
@@ -0,0 +1,76 @@
+function [ttestTableParameters,meantableParameters,medianTableParameters,...
+    statisticsTable,numRejectedHyp] = plot_parameterDifferences(paramNames,allParamValues,patNums,bounds,ind,units,plotFolderName)
+
+%% Set colors
+global colnormal
+global colhigh
+global colT2Dnormal
+global colT2Dhigh
+
+magmacols = magma(4);
+colors4groupsHBP  = flip(magmacols);
+colnormal = colors4groupsHBP(1,:);
+colT2Dnormal = colors4groupsHBP(2,:);
+colhigh = colors4groupsHBP(3,:);
+colT2Dhigh = colors4groupsHBP(4,:);
+colors4groupsHBP  = {colnormal,colT2Dnormal,colhigh,colT2Dhigh};
+
+%Set font size in figures
+global fzlarge
+global fzsmall
+fzlarge = 11;
+fzsmall = 8;
+
+%% set parameter values to their actual values (as when simulating)
+allParamValues(ind.onset_LV,:) = allParamValues(ind.onset_LV,:) - 1.5;
+allParamValues(ind.onset_LA,:) = 1 + allParamValues(ind.onset_LV,:) - allParamValues(ind.onset_LA,:);
+
+bounds.lb(ind.onset_LV) = bounds.lb(ind.onset_LV) - 1.5;
+bounds.ub(ind.onset_LV) = bounds.ub(ind.onset_LV) - 1.5;
+
+lbLA = bounds.lb(ind.onset_LA) ;
+bounds.lb(ind.onset_LA) = 1 + bounds.lb(ind.onset_LV) - bounds.ub(ind.onset_LA);
+bounds.ub(ind.onset_LA) = 1 + bounds.ub(ind.onset_LV) - lbLA;
+
+paramNamesOrig = paramNames;
+paramNames =  removeUnderscore(paramNames,' ');
+
+%% Load groups
+[groups] = loadGroupIndexes(patNums);
+
+%% Run statistical tests
+for param = 1:length(paramNamesOrig)
+    paramvaluesStruct.(paramNamesOrig{param}) = allParamValues(param,:);
+end
+[ttestTableParameters,statisticsTable,meantableParameters,~,~,numRejectedHyp,~,medianTableParameters,~,statdocumenttable] = runStatisticalComparison('numeric',patNums,paramvaluesStruct,paramNamesOrig,paramNamesOrig);
+
+%save table for statistical summary document
+writetable(statdocumenttable,fullfile(plotFolderName,'statisticssummary_params.xlsx'))
+
+
+%% Create box plots of the differences between the 4 groups
+correctedRejection4groupsHBP = numRejectedHyp.HBP.rBenjH2>0;
+paramNamesMarkedHBP = paramNames;
+paramNamesMarkedHBP(correctedRejection4groupsHBP) = strcat(paramNamesMarkedHBP(correctedRejection4groupsHBP),'*');
+comptitles = {'HBP: control vs hypertensive', ...
+    'HBP: T2D vs hypertensive T2D',...
+    'HBP: Hypertensive vs hypertensive & T2D',...
+    'HBP: control vs T2D',...
+    'HBP: Hypertensive vs T2D',...
+    'HBP: control vs hypertensive T2D'};
+groups4HBP = {groups.C_NT_home,groups.T2D_NT_home,groups.C_HT_home,groups.T2D_HT_home};
+
+names.xtick = {'C','T2D','HT','T2D+HT'};
+names.xtickangle = 0;
+names.legend = {'Control','T2D','Hypertensive','T2D & hypertensive'};
+names.figname = 'Params_Groups_significant_4groups_HBP';
+plotMedian = 1;
+plot4groups(comptitles,[],groups4HBP,[],[],...
+    statisticsTable,allParamValues,paramNamesMarkedHBP,...
+    bounds,units,plotMedian,names,colors4groupsHBP)
+
+
+%% Save figures
+saveAllFigures(plotFolderName)
+
+end
\ No newline at end of file
diff --git a/Plotting/plot_predictionDifferences.m b/Plotting/plot_predictionDifferences.m
new file mode 100644
index 0000000000000000000000000000000000000000..655dd9f4bc880effb778f2a966666d55c9ce13dc
--- /dev/null
+++ b/Plotting/plot_predictionDifferences.m
@@ -0,0 +1,97 @@
+function [ttestTablePredictions] = plot_predictionDifferences(simulations,patNums,ynames,plotFolderName)
+% Compares model predictions of the maximum and minimum pressures in the LA
+% and LV between the four groups.
+
+%% Setup colors and font size
+magmacols = flip(magma(4));
+colors4groups=num2cell(magmacols,2);
+global fzlarge 
+global fzsmall 
+global fzsupersmall 
+fzlarge = 14;
+fzsmall = 10;
+fzsupersmall = 8;
+
+%% Prepare for statistical test - calculate prediction variables
+% Maximum pressures
+units = {'mmHg','mmHg'};
+predictionNames= {'maxpLA','maxpLV'};
+predictionNamesNice = {'Maximum LA pressure','Maximum LV pressure'};
+ypredNames = {'pLA','pLV'};
+allVariableValues = zeros(length(patNums),length(predictionNames));
+for pred = 1:length(predictionNames)
+    predictionStruct.(predictionNames{pred}) = zeros(size(patNums));
+    for pat = 1:length(patNums)
+        predind = strcmp(ynames,ypredNames{pred});
+        predictionStruct.(predictionNames{pred})(pat) = max(simulations{pat}.y(:,predind));
+        allVariableValues(pat,pred) = predictionStruct.(predictionNames{pred})(pat);
+    end
+end
+npred = length(ypredNames);
+
+% Minimum pressures
+prevpredind = pred;
+units = [units,{'mmHg','mmHg'}];
+predictionNames= [predictionNames,{'minpLA','minpLV'}];
+predictionNamesNice= [predictionNamesNice,{'Minimum LA pressure','Minimum LV pressure'}];
+for pred = 1:length(ypredNames)
+    predictionStruct.(predictionNames{npred+pred}) = zeros(size(patNums));
+    for pat = 1:length(patNums)
+        predind = strcmp(ynames,ypredNames{pred});
+        predictionStruct.(predictionNames{npred+pred})(pat) = min(simulations{pat}.y(:,predind));
+        allVariableValues(pat,pred+prevpredind) = predictionStruct.(predictionNames{npred+pred})(pat);
+    end
+end
+
+%% Run statistical test to compare groups
+% Setup groups
+[groups] = loadGroupIndexes(patNums);
+
+% Run test
+[ttestTablePredictions,statisticsTable,predMean,...
+    ~,~,numRejectedHyp,~,~,...
+    ~,statdocumenttable] = runStatisticalComparison(...
+    'numeric',patNums,predictionStruct,predictionNames,predictionNames);
+
+% Save a table for the statistical summary document
+writetable(statdocumenttable,fullfile(plotFolderName,'statisticssummary_predictions.xlsx'))
+
+%% Box plots
+plotMedian=1;
+%Compare the 4 groups
+comptitles = {'HBP: control vs hypertensive', ...
+    'HBP: T2D vs hypertensive T2D',...
+    'HBP: Hypertensive vs hypertensive & T2D',...
+    'HBP: control vs T2D',...
+    'HBP: Hypertensive vs T2D',...
+    'HBP: control vs hypertensive T2D'};
+rejects = cell(size(comptitles));
+for c = 1:length(comptitles)
+    rejects{c} = statisticsTable.reject{strcmp(comptitles{c},statisticsTable.groupComparisonNames)};
+    rejects{c}(isnan(rejects{c})) = 0;
+end
+correctedrejection4groups = numRejectedHyp.HBP.rBenjH2>0;
+predictionNamesNice(correctedrejection4groups) = strcat(predictionNamesNice(correctedrejection4groups),'*');
+
+groups4 = {groups.C_NT_home,groups.T2D_NT_home,groups.C_HT_home,groups.T2D_HT_home};
+meanT2DHBP = table2array(predMean(strcmp(predMean.Group,'T2D HBP'),3:length(predictionNames)+2));%2 first are groupName and N
+sdT2DHBP = table2array(predMean(strcmp(predMean.Group,'T2D HBP'),3+length(predictionNames):end-2));
+meanT2DhighHBP = table2array(predMean(strcmp(predMean.Group,'Hypertensive T2D HBP'),3:length(predictionNames)+2));%2 first are groupName and N
+sdT2DhighHBP = table2array(predMean(strcmp(predMean.Group,'Hypertensive T2D HBP'),3+length(predictionNames):end-2));
+meanCHBP = table2array(predMean(strcmp(predMean.Group,'Controls HBP'),3:length(predictionNames)+2));%2 first are groupName and N
+sdCHBP = table2array(predMean(strcmp(predMean.Group,'Controls HBP'),3+length(predictionNames):end-2));
+meanChighHBP = table2array(predMean(strcmp(predMean.Group,'Hypertensive HBP'),3:length(predictionNames)+2));%2 first are groupName and N
+sdChighHBP = table2array(predMean(strcmp(predMean.Group,'Hypertensive HBP'),3+length(predictionNames):end-2));
+mean4 = {meanCHBP,meanT2DHBP,meanChighHBP,meanT2DhighHBP};
+sd4 = {sdCHBP,sdT2DHBP,sdChighHBP,sdT2DhighHBP};
+names.xtick = {'C','T2D','HT','T2D+HT'};
+names.xtickangle = 0;
+names.legend = {'Control','T2D','Hypertensive','T2D & hypertensive'};
+names.figname ='predictions_4groups';
+plot4groups_variables(1:length(predictionNamesNice),comptitles,groups4,mean4,sd4,statisticsTable,allVariableValues,predictionNamesNice,units,plotMedian,names,colors4groups)
+
+%% Save figures
+saveAllFigures(plotFolderName)
+
+end
+
diff --git a/Plotting/plot_spiderparams.m b/Plotting/plot_spiderparams.m
new file mode 100644
index 0000000000000000000000000000000000000000..98286450b927cb740ea944ba6610d566bf5e6219
--- /dev/null
+++ b/Plotting/plot_spiderparams.m
@@ -0,0 +1,157 @@
+function plot_spiderparams(paramNamesPlot,allParamValues,patNums,bounds,ind,plotFolderName,statisticsTable,numRejectedHyp,mediantableParameters)
+% Creates two spider plots of parameter values in the 4 groups. 
+% If not provided in the input, a statistical test is runned to determine 
+% which of the 28 parameters to plot.
+
+%% Set colors
+addpath '..\Requirements\spider_plot'
+
+magmacols = magma(4);
+colors4groupshbp=flip(magmacols);
+
+%% set parameter values to their actual values used when simulating
+allParamValues(ind.onset_LV,:) = allParamValues(ind.onset_LV,:) - 1.5;
+allParamValues(ind.onset_LA,:) = 1 + allParamValues(ind.onset_LV,:) - allParamValues(ind.onset_LA,:);
+
+bounds.lb(ind.onset_LV) = bounds.lb(ind.onset_LV) - 1.5;
+bounds.ub(ind.onset_LV) = bounds.ub(ind.onset_LV) - 1.5;
+
+lbLA = bounds.lb(ind.onset_LA) ;
+bounds.lb(ind.onset_LA) = 1 + bounds.lb(ind.onset_LV) - bounds.ub(ind.onset_LA);
+bounds.ub(ind.onset_LA) = 1 + bounds.ub(ind.onset_LV) - lbLA;
+
+paramNamesOrig = paramNamesPlot;
+paramNamesPlot = fixUnderscore(paramNamesPlot);
+
+%% physiological order of parameters
+PVparams = {'Ppu','Rpu','Cpvc','Lpv','Rpv'};
+LAparams = {'Emax_LA','Emin_LA','k_diast_LA','k_syst_LA','m1_LA','m2_LA','onset_LA','V0_LA'};
+MVparams = {'Lmv','Rmv'};
+LVparams= {'Emax_LV','Emin_LV','k_diast_LV','k_syst_LV','m1_LV','m2_LV','onset_LV','V0_LV'};
+AVparams = {'Lav','ElCo'};
+Aortaparams = {'Caa','Lao','Rao'};
+Perparams = {'Rtot','Ctot','SBPdiff'};
+paramNamesPhysOrder = [PVparams,LAparams,MVparams,LVparams,AVparams,Aortaparams,Perparams];
+
+%% functional order of parameters
+hrparamsLA = {'Emax_LA','Emin_LA','k_diast_LA','k_syst_LA','m1_LA','m2_LA','onset_LA'};
+hrparamsLV = {'Emax_LV','Emin_LV','k_diast_LV','k_syst_LV','m1_LV','m2_LV','onset_LV'};
+Rparams = {'Rpu','Rpv','Rmv','Rao','Rtot'};
+Cparams = {'Cpvc','Caa','Ctot'};
+Lparams = {'Lpv','Lmv','Lav','Lao'};
+Vparams = {'V0_LA','V0_LV'};
+restparams = {'Ppu','ElCo','SBPdiff'};
+paramNamesFunctionOrder = [hrparamsLA,hrparamsLV,Rparams,Cparams,Lparams,Vparams,restparams];
+
+
+%% Calculate statistics
+if nargin < 7
+    % Structure data
+    for param = 1:length(paramNamesOrig)
+        paramvaluesStruct.(paramNamesOrig{param}) = allParamValues(param,:);
+    end
+    % Run statistical tests
+    [~,statisticsTable,meantableParameters,~,~,numRejectedHyp,~,mediantableParameters,~] = runStatisticalComparison('numeric',patNums,paramvaluesStruct,paramNamesOrig,paramNamesOrig);
+end
+
+%number of subjects in each group
+nControlHypHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'Hypertensive HBP'),2));%meantableParameters
+nControlNormHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'Controls HBP'),2));
+nT2DHypHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'Hypertensive T2D HBP'),2));
+nT2DNormHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'T2D HBP'),2));
+
+% Add * to the predictions that contain significant differences
+correctedRejection4groupsHBP = numRejectedHyp.HBP.rBenjH2>0;
+paramNamesPlotHBP = paramNamesPlot;
+paramNamesPlotHBP(correctedRejection4groupsHBP) = strcat(paramNamesPlot(correctedRejection4groupsHBP),'*');
+
+% extract the median values
+medianT2DnormalHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'T2D HBP'),3:length(paramNamesPlot)+2));%2 first are groupName and N
+medianT2DhighHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'Hypertensive T2D HBP'),3:length(paramNamesPlot)+2));%2 first are groupName and N
+medianCnormalHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'Controls HBP'),3:length(paramNamesPlot)+2));%2 first are groupName and N
+medianChighHBP = table2array(mediantableParameters(strcmp(mediantableParameters.Group,'Hypertensive HBP'),3:length(paramNamesPlot)+2));%2 first are groupName and N
+
+%Index of the parameters to plot, with any p<0.05
+rejectHTdiabetes_HBP = statisticsTable.reject{strcmp('HBP: T2D vs hypertensive T2D',statisticsTable.groupComparisonNames)};
+rejectHTcontrol_HBP = statisticsTable.reject{strcmp('HBP: control vs hypertensive',statisticsTable.groupComparisonNames)};
+rejectHTcontrolT2D_HBP = statisticsTable.reject{strcmp('HBP: Hypertensive vs hypertensive & T2D',statisticsTable.groupComparisonNames)};
+rejectNTconrolT2D_HBP = statisticsTable.reject{strcmp('HBP: control vs T2D',statisticsTable.groupComparisonNames)};
+rejectControlT2DHT_HBP = statisticsTable.reject{strcmp('HBP: control vs hypertensive T2D',statisticsTable.groupComparisonNames)};
+rejectHTT2D_HBP = statisticsTable.reject{strcmp('HBP: Hypertensive vs T2D',statisticsTable.groupComparisonNames)};
+indSign4hbp = find(or(rejectNTconrolT2D_HBP,or(rejectHTcontrolT2D_HBP,or(rejectHTcontrol_HBP,or(rejectHTdiabetes_HBP,or(rejectControlT2DHT_HBP,rejectHTT2D_HBP))))));
+
+%% PLOT
+fzsmall = 10;
+P2 = [medianCnormalHBP(indSign4hbp);medianT2DnormalHBP(indSign4hbp);medianChighHBP(indSign4hbp);medianT2DhighHBP(indSign4hbp)];
+names2 = paramNamesPlotHBP(indSign4hbp);
+% sort in physiological order
+[~,nameind] = ismember(paramNamesPhysOrder,paramNamesOrig(indSign4hbp));
+nameind(nameind==0) = [];
+names2 = names2(nameind);
+P2 = P2(:,nameind);
+%shift 2 steps
+P2 = circshift(P2,[0,-2]);
+precision = spider_findprecision(P2);
+names2 = circshift(names2,-2);
+figure('Name','Spider_4groups','Visible','off') 
+set(gcf,'Color','white')
+xdim_CM = 25; %A4: 21x29.7
+ydim_CM = 14;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+tiles=tiledlayout(1,2,'Padding','compact','TileSpacing','loose');
+nexttile
+spider_plot(P2,...
+    'AxesLabels', names2,...
+    'AxesInterval', 1,...
+    'AxesPrecision',precision,...
+    'FillOption', {'on', 'on', 'on','on'},...
+    'FillTransparency', [0.12, 0.12, 0.12,0.12],...
+    'Color', colors4groupshbp,...
+    'LineStyle', {'-', '-', '-','-'},...
+    'AxesFontSize', fzsmall,...
+    'LabelFontSize', fzsmall,...
+    'AxesLabelsRotate', 'on',...
+    'AxesLabelsEdge', 'none',...
+    'AxesLabelsOffset', 0.1,...
+    'AxesLimits', [min(P2);max(P2)],...
+    'LineWidth',2,'MarkerSize',1);
+set(gca,'FontSize',fzsmall)
+
+%  functional
+P2 = [medianCnormalHBP(indSign4hbp);medianT2DnormalHBP(indSign4hbp);medianChighHBP(indSign4hbp);medianT2DhighHBP(indSign4hbp)];
+names2 = paramNamesPlotHBP(indSign4hbp);
+% sort in functional order
+[~,nameind] = ismember(paramNamesFunctionOrder,paramNamesOrig(indSign4hbp));
+nameind(nameind==0) = [];
+names2 = names2(nameind);
+P2 = P2(:,nameind);
+%shift 2 steps
+P2 = circshift(P2,[0,-2]);
+precision = spider_findprecision(P2);
+names2 = circshift(names2,-2);
+nexttile
+spider_plot(P2,...
+    'AxesLabels', names2,...
+    'AxesInterval', 1,...
+    'AxesPrecision',precision,...
+    'FillOption', {'on', 'on', 'on','on'},...
+    'FillTransparency', [0.12, 0.12, 0.12,0.12],...
+    'Color', colors4groupshbp,...
+    'LineStyle', {'-', '-', '-','-'},...
+    'AxesFontSize', fzsmall,...
+    'LabelFontSize', fzsmall,...
+    'AxesLabelsRotate', 'on',...
+    'AxesLabelsEdge', 'none',...
+    'AxesLabelsOffset', 0.1,...
+    'AxesLimits', [min(P2);max(P2)],...
+    'LineWidth',2,'MarkerSize',1);
+set(gca,'FontSize',fzsmall) 
+legend({sprintf('Control (N = %d)',nControlNormHBP),sprintf('T2D (N = %d)',nT2DNormHBP),sprintf('Hypertensive (N = %d)',nControlHypHBP),sprintf('T2D and hypertensive (N = %d)',nT2DHypHBP)},...
+    'FontSize',fzsmall,'Position',[0.4135478003012 0.0984478719265485 0.275818639798489 0.117941176470588]);
+legend('boxoff')
+
+%% Save figures
+saveAllFigures(plotFolderName)
+
+end
\ No newline at end of file
diff --git a/Plotting/plot_validation_uncertainty.m b/Plotting/plot_validation_uncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..948b7ad4dff19361bb01ed2583ae9965628b9cea
--- /dev/null
+++ b/Plotting/plot_validation_uncertainty.m
@@ -0,0 +1,102 @@
+function []=plot_validation_uncertainty(minmaxSim,paramuncertainty,bestparams,constants,simLast,indexes,options,data,extradata,patNums,xnames,plotFolderName)
+%% Setup colors
+colornames = {'MV','AV','AA','pulmonary','LA','LV','peripheral'};
+namesavatar = {'pulmonary','LA','MV','LV','AV','AA','peripheral'};
+bluescale = {[208,209,230]./255,[200,188,220]./255,[166,189,219]./255,[116,169,207]./255,[54,144,192]./255,[5,112,176]./255,[3,78,123]./255};
+[~,colind] = ismember(colornames,namesavatar);
+bluescaleordered = bluescale(colind);
+colors = bluescaleordered;
+colorLV = colors{strcmp('LV',colornames)};
+
+
+%% Extract the simulated and measured stroke volumes for each subject
+SVmvDat = zeros(size(patNums));
+SVacDat = zeros(size(patNums));
+SVavDat = zeros(size(patNums));
+SVmriDat = zeros(size(patNums));
+SVsim = zeros(size(patNums));
+
+for p = 1:length(patNums)
+    SVmriDat(p)=data{p}.EDV-data{p}.ESV;
+    SVmvDat(p)=extradata{p}.SV_MV;
+    SVavDat(p)=extradata{p}.SV_AV;
+    SVacDat(p)=extradata{p}.SV_AC;
+    SVsim(p)=trapz(simLast{p}.t,simLast{p}.x(:,strcmp(xnames,'Qav')));
+end
+
+%% Create valiation plot with prediction vs data
+figure('Visible', 'off','Name','validation_predictionVSdata_uncertainty');
+set(gcf,'Color','white')
+xdim_CM = 21;
+ydim_CM = 20;
+set(gcf,'Units','centimeters','Position',[0 0 xdim_CM ydim_CM])
+set(gcf,'PaperUnits', 'centimeters', 'PaperSize', [xdim_CM, ydim_CM])
+LW = 1.5;
+tiles=tiledlayout(4,2,'Padding','compact','TileSpacing','Compact');
+t=nexttile;
+createValidationPlot_uncertainty(t,tiles,SVmvDat,SVsim,colors{1},[0.3 0.3 0.3],LW,'Volume (ml)','A',minmaxSim.SV)
+title('SV mitral valve (blood flow data)')
+
+t=nexttile;
+createValidationPlot_uncertainty(t,tiles,SVavDat,SVsim,colors{2},[0.3 0.3 0.3],LW,'Volume (ml)','B',minmaxSim.SV)
+title('SV aortic valve (blood flow data)')
+
+t=nexttile;
+createValidationPlot_uncertainty(t,tiles,SVacDat,SVsim,colors{3},[0.3 0.3 0.3],LW,'Volume (ml)','C',minmaxSim.SV)
+title('SV ascending aorta (blood flow data)')
+
+t=nexttile;
+createValidationPlot_uncertainty(t,tiles,SVmriDat,SVsim,colorLV,[0.3 0.3 0.3],LW,'Volume (ml)','D',minmaxSim.SV)
+title('Validation: SV left ventricle (3D cine MRI data)')
+
+legend([t.Children(1),t.Children(2)],'Data','Simulation uncertainty','Position',[0.554274030341607 0.673662299047534 0.198336696744927 0.0419312177890192])
+
+%% Save figures
+saveAllFigures(plotFolderName)
+
+end
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%
+function createValidationPlot_uncertainty(t,tiles,S1,S2,dotcolor,linecolor,linewidth,ylabelname,lettertowrite,uncertainty)
+
+average = (S1+S2)./2;
+nonans = ~isnan(average) & ~isnan(S1) & ~isnan(S2);
+average = average(nonans);
+S1 = S1(nonans);
+S2 = S2(nonans);
+
+[~,patorder] = sort(average);
+S2sorted = S2(patorder);
+unc_min_sorted = uncertainty.min(patorder);
+unc_max_sorted = uncertainty.max(patorder);
+
+hold on
+% Plot simulation
+for p = 1:length(S2)
+    minp = unc_min_sorted{p};
+    maxp = unc_max_sorted{p};
+    errorbar(t,p,S2sorted(p),S2sorted(p)-minp,maxp-S2sorted(p),'.','color',dotcolor,'LineWidth',1,'Markersize',linewidth*10)
+end
+% Plot data
+plot(t,1:length(S1),S1(patorder),'o','color',linecolor,'LineWidth',1,'Markersize',linewidth*4);
+
+ylabel(t,ylabelname)
+xlim(t,[0 length(patorder)+1])
+xticks([1 round(length(patorder)/2) length(patorder)])
+xticklabels({'1','Subject number',num2str(length(average))})
+
+TilePos = tiles.Children.InnerPosition;
+chnum = size(tiles.Children);
+if chnum(1)>1
+    h=TilePos(2)+1.15*TilePos(4);
+else
+    h=TilePos(2)+1.05*TilePos(4);
+end
+if h>1
+    h=0.98;
+end
+letter = annotation('textbox',[TilePos(1)-0.035 h .015 .015],'String',lettertowrite,'Linestyle','none','FitBoxToText','on','BackgroundColor','none');
+
+
+end
diff --git a/Plotting/print_pval.m b/Plotting/print_pval.m
new file mode 100644
index 0000000000000000000000000000000000000000..969110845bdc7c2b5398736c54201a0fbd1a6448
--- /dev/null
+++ b/Plotting/print_pval.m
@@ -0,0 +1,29 @@
+function print_pval(t,xpos,ypos,xlinepos,pval,indSign,reject,rejectCorrected, pvalsize,ymax,ytext)
+
+plot(t,xlinepos, [1 1]*ypos*ymax, '-k')
+
+if isempty(rejectCorrected)
+    if ~isnan(reject(indSign)) && reject(indSign)
+        if pval < 0.001
+            text(t,xpos,ymax*(ypos+ytext),'p<0.001*','FontSize',pvalsize,'FontName','Calibri')
+        else
+            text(t,xpos,ymax*(ypos+ytext),sprintf('p=%0.3f*',pval),'FontSize',pvalsize,'FontName','Calibri')
+        end
+    elseif ~isnan(pval)
+        text(t,xpos,ymax*(ypos+ytext),sprintf('p=%0.3f',pval),'FontSize',pvalsize,'FontName','Calibri') 
+    end
+else
+    if ~isnan(rejectCorrected(indSign)) && rejectCorrected(indSign) %significant also after correction
+        if pval < 0.001
+            text(t,xpos,ymax*(ypos+ytext),'p<0.001*','FontSize',pvalsize,'FontName','Calibri')
+        else
+            text(t,xpos,ymax*(ypos+ytext),sprintf('p=%0.3f*',pval),'FontSize',pvalsize,'FontName','Calibri')
+        end
+    elseif ~isnan(reject(indSign)) && reject(indSign) %significant only before correction
+        text(t,xpos,ymax*(ypos+ytext),sprintf('p=%0.3f',pval),'FontSize',pvalsize,'FontName','Calibri')
+    elseif ~isnan(pval) %not significant
+        text(t,xpos,ymax*(ypos+ytext),sprintf('p=%0.3f',pval),'FontSize',pvalsize,'FontName','Calibri')
+    end
+end
+
+end
\ No newline at end of file
diff --git a/Plotting/spider_findprecision.m b/Plotting/spider_findprecision.m
new file mode 100644
index 0000000000000000000000000000000000000000..f748b8ec3248008bf46a451cfbe15b9170862785
--- /dev/null
+++ b/Plotting/spider_findprecision.m
@@ -0,0 +1,11 @@
+function precision  = spider_findprecision(P)
+
+minvals = min(P);
+precision = ones(size(minvals));
+precision(minvals>10) = 0;
+precision(minvals<1) = 2;
+precision(minvals<0.01) = 3;
+precision(minvals<0.001) = 4;
+precision(minvals<0.0001) = 5;
+
+end
\ No newline at end of file
diff --git a/README.md b/README.md
index 7247d785159652d7c5eefe2efa98a18fdbbb01ea..d7c26cb35419be53c5bd2bdb79a091ad254d3678 100644
--- a/README.md
+++ b/README.md
@@ -1,25 +1,30 @@
 # Cardiovascular Avatar T2D HT
 These are the scripts to reproduce the results in the publication *"Hemodynamic effects of hypertension and type 2 diabetes - insights through a 4D flow MRI-based personalized cardiovascular model"*.
 
+If you use this implementation in your academic projects, please cite this paper.
+
+The cardiovascular model file with all model equations is located in Modelfiles/avatar_HEALTH_syms_fast.m.
+
 # Requirements
-The model is created in the [AMICI toolbox](https://doi.org/10.1093/bioinformatics/btab227) in MATLAB. To compile the model, MATLAB 2017b or earlier is needed, but to run the already compiled model any later matlab verison works. The provided compiled model is compiled on Windows and Linux. To re-compile: run GenerateModels in the folder Modelfiles. To compile the model, you need a valid C-compiler (run mex -setup to check if you have an installed compiler in matlab) and the MATLAB Symbolic Math Toolbox.
-To run the other scripts, the following MATLAB toolboxes are needed: Statistics and Machine Learning Toolbox, Optimization Toolbox, Parallel Computing Toolbox, Symbolic Math Toolbox, Signal Processing Toolbox.
+The model is created in the [AMICI toolbox](https://doi.org/10.1093/bioinformatics/btab227) in MATLAB. To compile the model, MATLAB 2017b or earlier is needed, but to run the already compiled model any later matlab verison works. The provided compiled model is compiled on Windows, but will not work on Linux or macOS. To re-compile: run GenerateModels in the folder Modelfiles. To compile the model, you need a valid C-compiler (such as xcode on Mac or MinGW on Windows. Run mex -setup to check if you have an installed compiler in matlab) and the MATLAB Symbolic Math Toolbox.
+
+To run the other scripts, the following MATLAB toolboxes are needed: Statistics and Machine Learning Toolbox, Optimization Toolbox, Parallel Computing Toolbox, Symbolic Math Toolbox, Signal Processing Toolbox. The code was created with Matlab R2021a. Earlier matlab versions might not be compatible with many of the scripts.
 
 Additionally, the following toolboxes are included in the folder Requirements and are needed to reproduce the results:
 * For simulation, the [AMICI toolbox](https://doi.org/10.1093/bioinformatics/btab227) is needed. 
 * For optimization with eSS, the [MEIGO toolbox](https://doi.org/10.1186/1471-2105-15-136) is needed.
 * For optimization with MCMC, the [PESTO toolbox](https://doi.org/10.1093/bioinformatics/btx676) is needed.
-* For spider plots, the [spider_plot](https://github.com/NewGuy012/spider_plot/releases/tag/19.4) function is needed
-* For the color palette magma, [MatPlotLib Perceptually Uniform Colormaps](https://www.mathworks.com/matlabcentral/fileexchange/62729-matplotlib-perceptually-uniform-colormaps) is needed
-* For Shapiro-Wilk test, the function [swtest](https://www.mathworks.com/matlabcentral/fileexchange/13964-shapiro-wilk-and-shapiro-francia-normality-tests) is needed (in the folder Statistical_tests)
+* For spider plots, the [spider_plot](https://github.com/NewGuy012/spider_plot/releases/tag/19.4) function is needed.
+* For the color palette magma, [MatPlotLib Perceptually Uniform Colormaps](https://www.mathworks.com/matlabcentral/fileexchange/62729-matplotlib-perceptually-uniform-colormaps) is needed.
+* For Shapiro-Wilk test, the function [swtest](https://www.mathworks.com/matlabcentral/fileexchange/13964-shapiro-wilk-and-shapiro-francia-normality-tests) is needed (in the folder Statistical_tests).
 
 # Re-create result figures
-Re-create the main results: Run the script createFigures_hypertensionT2D. This will take a while, since it takes time to save the figures in high resolution. 
+Re-create the main results: Run the script *createFigures_hypertensionT2D*. This will take a while, since it takes time to save the figures in high resolution. 
 
-Re-create the subject-specific predictions: run createFigures_hypertensionT2D_predictions. This will take several minutes, since all parameter sets will be simulated for each subject. It also takes time to save the figures in high resolution.
+Re-create the subject-specific predictions: run *createFigures_hypertensionT2D_predictions*. This will take several minutes, since all parameter sets will be simulated for each subject. It also takes time to save the figures in high resolution.
 
-Figure 6 - correlation with long- and shortterm markers - was created with the script plot_parameterCorrelations in the folder Plotting. However, the data needed to re-create the plot is not publically available.
-Similarly, Table 1 - cohort characteristics - was created with the script cohortTable in the folder Plotting, but the data is not publically available.
+Figure 6 - correlations - was created with the script plot_parameterCorrelations in the folder Plotting. However, the data needed to re-create the plot is not publically available due to ethical restrictions.
+Similarly, Table 1 - cohort characteristics - was created with the script cohortTable in the folder Plotting, but the data is not publically available due to ethical restrictions.
 
 # Optimization
 All scripts for parameter estimation are found in the folder Optimzation.
@@ -29,6 +34,10 @@ The optimization ran in 8 batches of 10 subjects at a time at the Swedish NSC. T
 
 To re-run the MCMC sampling, run runParamEstimationSeveral_MCMC_asNSC. The MCMC sampling ran in 3 batches at the swedish NSC: subject 1-32, subject 33-64, and subject 65-80. The script runParamEstimationSeveral_ESS_asNSC runs the optimization in the same way as it was done at the NSC - but you need to manually change the variables patrange and numberOfSubjects. On a normal workstation, this could take days or weeks.
 
+# Simulation
+An example of using the model to do a simple simulation can be found in the script *simpleModelSimulation.m*.
+The model file is found in the folder Modelfiles (*avatar_HEALTH_syms_fast.m*).
+
 ## Author
 Kajsa Tunedal (kajsa.tunedal@liu.se)
 
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/.clang-format b/Requirements/AMICI-0.10.11_SS_eventFix/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..3d4a7682cba952a87ac00e1294668ae437946542
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/.clang-format
@@ -0,0 +1,96 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:   
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '$'
+IndentCaseLabels: false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never
+...
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/.gitignore b/Requirements/AMICI-0.10.11_SS_eventFix/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..772a1536451ca910891d048b401cf5feb2cd8d9e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/.gitignore
@@ -0,0 +1,163 @@
+CMakeFiles/*
+
+build/*
+build-debug/*
+build_xcode/*
+swig/python/build/*
+tests/cpputest/build/*
+tests/cpputest/build_xcode/*
+tests/cpputest/Testing/*
+
+doc/*
+fonts/*
+images/*
+stylesheets/*
+
+sed-ml/*
+
+models/*
+!models/model_dirac
+models/model_dirac/build/*
+!models/model_steadystate
+models/model_steadystate/build/*
+!models/model_jakstat_adjoint
+models/model_jakstat_adjoint/build/*
+!models/model_jakstat_adjoint_o2
+models/model_jakstat_adjoint_o2/build/*
+!models/model_neuron
+models/model_neuron/build/*
+!models/model_neuron_o2
+models/model_neuron_o2/build/*
+!models/model_events
+models/model_events/build/*
+!models/model_nested_events
+models/model_nested_events/build/*
+!models/model_robertson
+models/model_robertson/build/*
+!models/model_calvetti
+models/model_calvetti/build/*
+
+simulate_model_*_hdf.m
+simulate_model_*.m
+
+index.html
+
+AMICI.mlappinstall
+
+Makefile
+cmake_install.cmake
+CMakeCache.txt
+CMakeLists.txt.user
+
+.coveralls.yml
+.directory
+.project
+.pydevproject
+.settings/
+.idea/*
+.DS_Store
+.ipynb_checkpoints/
+python/.idea/*
+
+*.a
+*.info
+*.o
+*.obj
+*.eps
+*.mexmaci64
+*.mexa64
+*.mexw64
+*.mexmaci32
+*.mexa32
+*.mexw32
+*.eps
+*.md5
+*.json
+*.mat
+*.m~
+*.plist
+*.make
+*.bin
+*.csv
+*.log
+*.pyc
+*.so
+*.bak
+*.sav
+
+matlab/mtoc/config/latexextras.sty-e
+matlab/mtoc/config/latexextras.sty
+matlab/mtoc/config/Doxyfile-e
+
+cppcheck.txt
+coverage_py.xml
+testSuite.txt
+
+__pycache__
+
+/misc.xml
+
+python/testSpeedy.py
+python/test.txt
+
+tests/test/*
+tests/test_model_steadystate_scaled/*
+tests/test_model_presimulation/*
+tests/test_model_presimulation_pysb/*
+tests/test_model_presimulation_sbml/*
+tests/test_likelihoods/*
+tests/bax_pore_sequential_amici/*
+tests/bax_pore_amici/*
+tests/bngwiki_egfr_simple_amici/*
+tests/bngwiki_egfr_simple_deletemolecules_amici/*
+tests/earm_1_3_amici/*
+tests/earm_1_0_amici/*
+tests/expression_observables_amici/*
+tests/robertson_amici/*
+tests/tyson_oscillator_amici/*
+tests/bngwiki_simple_amici/*
+tests/bngwiki_enzymatic_cycle_mm_amici/*
+tests/move_connected_amici/*
+tests/michment_amici/*
+tests/kinase_cascade_amici/*
+tests/hello_pysb_amici/*
+tests/fricker_2010_apoptosis_amici/*
+tests/explicit_amici/*
+tests/fixed_initial_amici/*
+tests/cpputest/writeResults.h5
+tests/cpputest/writeResults.h5.bak
+tests/sbml-test-suite/*
+tests/sbml-test-suite/
+tests/sedml-test-suite/
+*/sbml-semantic-test-cases/*
+tests/SBMLTestModels/
+/python/test/amici-SBMLTest*/
+
+python/examples/example_steadystate/model_steadystate_scaled/*
+python/examples/example_presimulation/model_presimulation/*
+python/examples/example_presimulation/model_presimulation_re/*
+
+python/sdist/amici.egg-info/*
+python/sdist/amici/version.txt
+python/sdist/amici/amici.py
+python/sdist/amici/amici_wrap.cxx
+python/sdist/amici/amici_without_hdf5.py
+python/sdist/amici/amici_wrap_without_hdf5.cxx
+
+python/sdist/build/*
+python/sdist/amici/git_version.txt
+
+python/sdist/dist
+
+AMICI_guide.pdf
+
+ThirdParty/bionetgen.tar.gz
+ThirdParty/BioNetGen-*
+ThirdParty/cpputest-master*
+ThirdParty/mtocpp-master*
+ThirdParty/sundials/build/*
+ThirdParty/SuiteSparse/lib/*
+ThirdParty/SuiteSparse/share/*
+ThirdParty/SuperLU_MT_3.1/
+ThirdParty/superlu_mt_3.1.tar.gz
+ThirdParty/swig-*
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/.travis.yml b/Requirements/AMICI-0.10.11_SS_eventFix/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a11d417e50c7b62c7d1d4a48fa1b93ea95f4c8c2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/.travis.yml
@@ -0,0 +1,136 @@
+branches:
+  only:
+    - master
+    - develop
+    # Version tags
+    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
+
+matrix:
+  fast_finish: true
+  include:
+    - os: linux
+      dist: bionic
+      language: python
+      python: 3.7
+      compiler: gcc
+      addons:
+        apt:
+          packages:
+            - libhdf5-serial-dev
+            - zlib1g-dev
+            - libatlas-base-dev
+            - lcov
+            - libboost-serialization-dev
+            - swig3.0
+            - g++-5
+            - libc6-dbg
+      env:
+        - ENABLE_GCOV_COVERAGE=TRUE
+        - CI_MODE=test
+      before_install:
+        - ./scripts/buildValgrind.sh
+      after_script:
+        - bash <(curl -s https://codecov.io/bash) -f coverage.info -X fix -F cpp
+        - bash <(curl -s https://codecov.io/bash) -f coverage_py.xml -F python
+      before_deploy:
+        - cd $BASE_DIR
+      deploy:
+        skip_cleanup: true
+        provider: script
+        script: scripts/deployPyPi.sh
+        on:
+          branch: master
+          tags: true
+
+    - os: osx
+      osx_image: xcode11
+      language: minimal
+      compiler: clang
+      env:
+        - CI_MODE=test
+      addons:
+        homebrew:
+          packages:
+            - hdf5
+            - swig
+            - gcc
+            - cppcheck
+          update: true
+      before_install:
+        - travis_wait brew link --overwrite gcc # fix linker warning regarding /usr/local/include/c++
+        - export -f travis_fold travis_nanoseconds travis_time_start travis_time_finish
+        - pip3 install --user -U numpy
+      after_success:
+        - cd $BASE_DIR # cd to base dir for correct relative path in deploy
+
+    - os: osx
+      osx_image: xcode11
+      language: minimal
+      compiler: clang
+      env:
+        - CI_MODE=deploy
+      addons:
+        homebrew:
+          casks:
+            - mactex
+          packages:
+            - doxygen
+            - ragel
+            - graphviz
+          update: true
+      before_install:
+        - export PATH=/Users/travis/Library/Python/3.7/bin:/Library/TeX/texbin:$PATH
+        - export -f travis_fold travis_nanoseconds travis_time_start travis_time_finish
+      after_success:
+        - cd $BASE_DIR # cd to base dir for correct relative path in deploy
+      deploy:
+        provider: pages
+        local-dir: doc
+        skip-cleanup: true
+        github-token: $GITHUB_TOKEN  # Set in the settings page of your repository, as a secure variable
+        keep-history: false
+        verbose: true
+        on:
+          branch: master
+
+install:
+    - export BASE_DIR=`pwd`
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then mkdir -p ~/bin/ && ln -s /usr/bin/swig3.0 ~/bin/swig && export PATH=~/bin/:$PATH; fi # Python distutils only looks for `swig` and does not find `swig3.0`
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export PYTHON_EXECUTABLE=$(which python3); fi # cmake wont be able to find python3 on its own ...
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CI_MODE" == "test" ]]; then pip3 install --upgrade pip==9.0.3 setuptools wheel pkgconfig scipy; fi
+    - if [[ "$TRAVIS_OS_NAME" != "linux" ]] && [[ "$CI_MODE" == "test" ]]; then pip3 install --user --upgrade pip==9.0.3 setuptools wheel pkgconfig scipy; fi
+    - if [[ "$CI_MODE" == "deploy" ]]; then pip3 install --user --upgrade pip==9.0.3 doxypypy; fi # pinning pip because of https://github.com/pypa/pip/issues/5240
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/buildSuiteSparse.sh; fi
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/buildSundials.sh; fi
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/buildCpputest.sh; fi
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/buildBNGL.sh; fi
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/buildAmici.sh; fi
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/installAmiciArchive.sh; fi
+    - if [[ "$CI_MODE" == "test" ]]; then ./scripts/installAmiciSource.sh; fi
+
+script:
+    - export -f travis_fold travis_nanoseconds travis_time_start travis_time_finish
+    - export FOLD=$BASE_DIR/scripts/travis_wrap.sh
+    - cd $BASE_DIR
+    - if [[ "$CI_MODE" == "test" ]]; then $FOLD notebooks "cd $BASE_DIR && scripts/runNotebook.sh python/examples/example_*/"; fi
+    - if [[ "$TRAVIS_OS_NAME" != "linux" ]] && [[ "$CI_MODE" == "test" ]]; then $FOLD cpputest ./scripts/run-cpputest.sh; fi
+    - if [[ "$TRAVIS_OS_NAME" != "linux" ]] && [[ "$CI_MODE" == "test" ]]; then $FOLD python-tests ./scripts/run-python-tests.sh; fi
+    - if [[ "$TRAVIS_OS_NAME" != "linux" ]] && [[ "$CI_MODE" == "test" ]]; then $FOLD cmake ./tests/testCMakeCompilation.sh; fi
+    - if [[ "$CI_MODE" == "deploy" ]]; then $FOLD doxygen ./scripts/run-doxygen.sh; fi
+    - if [[ "$TRAVIS_OS_NAME" != "linux" ]] && [[ "$CI_MODE" == "test" ]]; then $FOLD cppcheck ./scripts/run-cppcheck.sh; fi
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CI_MODE" == "test" ]]; then $FOLD valgrind ./scripts/run-valgrind.sh; fi
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CI_MODE" == "test" ]]; then $FOLD codecov ./scripts/run-codecov.sh; fi
+
+after_failure:
+    - $FOLD ls -alR
+
+# cache dependencies
+cache:
+  directories:
+    - $HOME/Library/Caches/Homebrew
+    - $HOME/Library/Caches/pip
+    - $HOME/.cache/pip
+  timeout: 1200
+
+before_cache:
+  - brew cleanup
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..06086641093ac85a4e1ab38c05998bef9fbdb874
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/CMakeLists.txt
@@ -0,0 +1,255 @@
+#
+# Build AMICI library
+#
+cmake_minimum_required(VERSION 3.3)
+
+if(POLICY CMP0065)
+  cmake_policy(SET CMP0065 NEW)
+endif(POLICY CMP0065)
+if(POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif(POLICY CMP0077)
+if(POLICY CMP0074)
+  # Use package_ROOT environment variables
+  cmake_policy(SET CMP0074 NEW)
+endif(POLICY CMP0074)
+
+project(amici)
+
+set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_CXX_STANDARD 11)
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    # require at least gcc 4.9, otherwise regex wont work properly
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
+        message(FATAL_ERROR "GCC version must be at least 4.9!")
+    endif()
+endif()
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(ENABLE_SWIG ON)
+
+# Compiler flags
+include(CheckCXXCompilerFlag)
+set(MY_CXX_FLAGS -Wall)
+foreach(FLAG ${MY_CXX_FLAGS})
+    unset(CUR_FLAG_SUPPORTED CACHE)
+    CHECK_CXX_COMPILER_FLAG(${FLAG} CUR_FLAG_SUPPORTED)
+    if(${CUR_FLAG_SUPPORTED})
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}")
+    endif()
+endforeach(FLAG)
+
+# find dependencies
+include(GNUInstallDirs)
+find_package(HDF5 COMPONENTS C HL CXX REQUIRED)
+set(HDF5_LIBRARIES ${HDF5_HL_LIBRARIES} ${HDF5_C_LIBRARIES} ${HDF5_CXX_LIBRARIES})
+set(SUITESPARSE_DIR "${CMAKE_SOURCE_DIR}/ThirdParty/SuiteSparse/")
+set(SUITESPARSE_INCLUDE_DIRS "${SUITESPARSE_DIR}/include" "${CMAKE_SOURCE_DIR}/ThirdParty/sundials/src")
+set(SUITESPARSE_LIBRARIES
+    ${SUITESPARSE_DIR}/KLU/Lib/libklu${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUITESPARSE_DIR}/COLAMD/Lib/libcolamd${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUITESPARSE_DIR}/BTF/Lib/libbtf${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUITESPARSE_DIR}/AMD/Lib/libamd${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUITESPARSE_DIR}/SuiteSparse_config/libsuitesparseconfig${CMAKE_STATIC_LIBRARY_SUFFIX}
+    )
+
+set(SUNDIALS_LIB_DIR "${CMAKE_SOURCE_DIR}/ThirdParty/sundials/build/${CMAKE_INSTALL_LIBDIR}")
+set(SUNDIALS_LIBRARIES
+    ${SUNDIALS_LIB_DIR}/libsundials_nvecserial${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunlinsolband${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunlinsolklu${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunlinsolpcg${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunlinsolspbcgs${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunlinsolspfgmr${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunmatrixband${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunmatrixdense${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunmatrixsparse${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunnonlinsolfixedpoint${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_sunnonlinsolnewton${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_cvodes${CMAKE_STATIC_LIBRARY_SUFFIX}
+    ${SUNDIALS_LIB_DIR}/libsundials_idas${CMAKE_STATIC_LIBRARY_SUFFIX}
+    )
+set(SUNDIALS_INCLUDE_DIRS "${CMAKE_SOURCE_DIR}/ThirdParty/sundials/build/include")
+
+option(SUNDIALS_SUPERLUMT_ENABLE "Enable sundials SuperLUMT?" OFF)
+if(SUNDIALS_SUPERLUMT_ENABLE)
+    set(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARIES}
+        ${SUNDIALS_LIB_DIR}/libsundials_sunlinsolsuperlumt${CMAKE_STATIC_LIBRARY_SUFFIX}
+        ${CMAKE_SOURCE_DIR}/ThirdParty/SuperLU_MT_3.1/lib/libsuperlu_mt_PTHREAD${CMAKE_STATIC_LIBRARY_SUFFIX}
+        -lblas
+        )
+    set(SUNDIALS_INCLUDE_DIRS ${SUNDIALS_INCLUDE_DIRS}
+        "${CMAKE_SOURCE_DIR}/ThirdParty/SuperLU_MT_3.1/SRC/")
+endif()
+
+set(GSL_LITE_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/ThirdParty/gsl")
+
+# AMICI requires BLAS, currently Intel MKL, CBLAS or MATLAB BLAS can be used.
+# The latter is not supported via CMake yet.
+set(BLAS "CBLAS" CACHE STRING "BLAS library to use")
+set_property(CACHE BLAS PROPERTY STRINGS "CBLAS" "MKL" "ACCELERATE")
+if(${BLAS} STREQUAL "MKL" OR DEFINED ENV{MKLROOT})
+    if(DEFINED ENV{MKLROOT})
+        # This is set by Environment Modules
+        message(STATUS "Using MKL_INCDIR and MKL_LIB from environment module")
+        set(BLAS "MKL" CACHE STRING "BLAS library to use" FORCE)
+        set(BLAS_INCLUDE_DIRS "$ENV{MKL_INCDIR}" CACHE STRING "" FORCE)
+        set(BLAS_LIBRARIES "$ENV{MKL_LIB}" CACHE STRING "" FORCE)
+    else()
+        set(BLAS_INCLUDE_DIRS "" CACHE STRING "")
+        set(BLAS_LIBRARIES -lmkl CACHE STRING "")
+    endif()
+else()
+    set(BLAS_INCLUDE_DIRS "" CACHE STRING "")
+    set(BLAS_LIBRARIES -lcblas CACHE STRING "")
+endif()
+add_definitions(-DAMICI_BLAS_${BLAS})
+
+# Add target to create version file
+add_custom_target(
+    version
+    ${CMAKE_COMMAND} -D SRC=${CMAKE_SOURCE_DIR}/include/amici/version.in.h
+    -D DST=${CMAKE_BINARY_DIR}/include/amici/version.h
+    -P ${CMAKE_SOURCE_DIR}/cmake/configureVersion.cmake
+    )
+
+# Library source files
+set(AMICI_SRC_LIST
+    ${CMAKE_SOURCE_DIR}/src/symbolic_functions.cpp
+    ${CMAKE_SOURCE_DIR}/src/cblas.cpp
+    ${CMAKE_SOURCE_DIR}/src/amici.cpp
+    ${CMAKE_SOURCE_DIR}/src/misc.cpp
+    ${CMAKE_SOURCE_DIR}/src/rdata.cpp
+    ${CMAKE_SOURCE_DIR}/src/edata.cpp
+    ${CMAKE_SOURCE_DIR}/src/exception.cpp
+    ${CMAKE_SOURCE_DIR}/src/hdf5.cpp
+    ${CMAKE_SOURCE_DIR}/src/spline.cpp
+    ${CMAKE_SOURCE_DIR}/src/solver.cpp
+    ${CMAKE_SOURCE_DIR}/src/solver_cvodes.cpp
+    ${CMAKE_SOURCE_DIR}/src/solver_idas.cpp
+    ${CMAKE_SOURCE_DIR}/src/model.cpp
+    ${CMAKE_SOURCE_DIR}/src/model_ode.cpp
+    ${CMAKE_SOURCE_DIR}/src/model_dae.cpp
+    ${CMAKE_SOURCE_DIR}/src/newton_solver.cpp
+    ${CMAKE_SOURCE_DIR}/src/forwardproblem.cpp
+    ${CMAKE_SOURCE_DIR}/src/steadystateproblem.cpp
+    ${CMAKE_SOURCE_DIR}/src/backwardproblem.cpp
+    ${CMAKE_SOURCE_DIR}/src/sundials_matrix_wrapper.cpp
+    ${CMAKE_SOURCE_DIR}/src/sundials_linsol_wrapper.cpp
+    ${CMAKE_SOURCE_DIR}/src/abstract_model.cpp
+    ${CMAKE_SOURCE_DIR}/src/vector.cpp
+    )
+
+add_library(${PROJECT_NAME} ${AMICI_SRC_LIST})
+add_dependencies(${PROJECT_NAME} version)
+file(GLOB PUBLIC_HEADERS include/amici/*.h)
+set_target_properties(${PROJECT_NAME} PROPERTIES PUBLIC_HEADER "${PUBLIC_HEADERS}")
+target_include_directories(${PROJECT_NAME}
+    PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    PUBLIC $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
+    PUBLIC swig
+    PUBLIC ${GSL_LITE_INCLUDE_DIR}
+    PUBLIC ${SUNDIALS_INCLUDE_DIRS}
+    PUBLIC ${SUITESPARSE_INCLUDE_DIRS}
+    PUBLIC ${HDF5_INCLUDE_DIRS}
+    )
+
+if(NOT "${BLAS_INCLUDE_DIRS}" STREQUAL "")
+    target_include_directories(${PROJECT_NAME} PUBLIC ${BLAS_INCLUDE_DIRS})
+endif()
+
+target_link_libraries(${PROJECT_NAME}
+    PUBLIC ${SUNDIALS_LIBRARIES}
+    PUBLIC ${SUITESPARSE_LIBRARIES}
+    PUBLIC ${HDF5_LIBRARIES}
+    PUBLIC ${BLAS_LIBRARIES}
+    )
+
+# Create targets to make the sources show up in IDEs for convenience
+
+# For matlab interface
+add_custom_target(matlabInterface
+    SOURCES src/interface_matlab.cpp src/returndata_matlab.cpp)
+set_target_properties(matlabInterface
+    PROPERTIES INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/include/")
+find_package(Matlab)
+if (${Matlab_FOUND})
+    # In case we can find Matlab, use the respective include directories
+    # for better IDE integration (set Matlab_ROOT_DIR cmake variable
+    # if CMake cannot find your Matlab installation)
+    set_property(TARGET matlabInterface APPEND
+        PROPERTY INCLUDE_DIRECTORIES "${Matlab_INCLUDE_DIRS}")
+endif()
+
+# For template files
+add_custom_target(
+    fileTemplates
+    SOURCES
+    src/CMakeLists.template.cmake
+    src/main.template.cpp
+    src/model_header.ODE_template.h
+    src/wrapfunctions.ODE_template.h
+    src/wrapfunctions.template.cpp
+    swig/CMakeLists_model.cmake
+    swig/modelname.template.i
+    )
+
+
+if($ENV{ENABLE_GCOV_COVERAGE})
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 --coverage")
+endif()
+
+include(clang-tools)
+
+set(AUTHORS "Fabian Froehlich, Jan Hasenauer, Daniel Weindl and Paul Stapor")
+set(AUTHOR_EMAIL "fabian.froehlich@helmholtz-muenchen.de")
+
+# <Export cmake configuration>
+install(TARGETS ${PROJECT_NAME} EXPORT AmiciTargets
+    ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/amici
+)
+export(EXPORT AmiciTargets FILE AmiciTargets.cmake
+    NAMESPACE Upstream::
+    )
+configure_file(cmake/AmiciConfig.cmake
+    "${CMAKE_CURRENT_BINARY_DIR}/AmiciConfig.cmake"
+    @ONLY
+    )
+include(CMakePackageConfigHelpers)
+include(version)
+write_basic_package_version_file(AmiciConfigVersion.cmake COMPATIBILITY ExactVersion)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/AmiciConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/AmiciTargets.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/AmiciConfigVersion.cmake
+    DESTINATION share/Amici/cmake )
+# Register package
+
+option(EXPORT_PACKAGE "Export AMICI library to CMake package registry?" ON)
+if(EXPORT_PACKAGE)
+    export(PACKAGE Amici)
+endif()
+# </Export cmake configuration>
+
+
+# build interfaces for other languages
+option(ENABLE_SWIG "Build AMICI swig library?" ON)
+if(ENABLE_SWIG)
+    add_subdirectory(swig)
+endif()
+
+option(ENABLE_PYTHON "Create Python module?" ON)
+if(ENABLE_PYTHON)
+    add_subdirectory(python)
+endif()
+
+option(BUILD_TESTS "Build integration tests?" ON)
+if(BUILD_TESTS)
+    enable_testing()
+
+    add_subdirectory(tests/cpputest)
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/CONTRIBUTING.md b/Requirements/AMICI-0.10.11_SS_eventFix/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..f11322ff2e7f77f1f32971901b7aa3a1a2cb9692
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/CONTRIBUTING.md
@@ -0,0 +1,12 @@
+# How to contribute
+
+We are happy about contributions to AMICI in any form, be it new functionality,
+documentation, bug reports, or anything else.
+
+If you would to contribute to AMICI, a good start is looking for issues tagged
+[`good first issue`](https://github.com/ICB-DCM/AMICI/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
+or [`help wanted`](https://github.com/ICB-DCM/AMICI/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22).
+For other ideas or questions, just post an issue.
+
+For code contributions, please read our
+[developer's guide](documentation/development.md) first.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/INSTALL.md b/Requirements/AMICI-0.10.11_SS_eventFix/INSTALL.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8ddcee0923c9c57d420efea9633cd6529132505
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/INSTALL.md
@@ -0,0 +1,398 @@
+# Installation
+
+## Table of Contents
+1. [Availability](#availability)
+2. [Python](#python)
+3. [MATLAB](#matlab)
+4. [C++ only](#cpp)
+5. [Dependencies](#dependencies)
+
+
+<a name="availability"></a>
+## Availability
+
+The sources for AMICI are available as
+- Source  [tarball](https://github.com/ICB-DCM/AMICI/tarball/master)
+- Source  [zip](https://github.com/ICB-DCM/AMICI/zipball/master)
+- GIT repository on  [github](https://github.com/ICB-DCM/AMICI)
+
+A Python package is available on pypi, see below.
+
+If AMICI was downloaded as a zip, it needs to be unpacked in a
+convenient directory. If AMICI was obtained via cloning of the git
+repository, no further unpacking is necessary.
+
+### Obtaining AMICI via the GIT version control system
+In order to always stay up-to-date with the latest AMICI versions,
+simply pull it from our GIT repository and recompile it when a new
+release is available. For more information about GIT checkout their
+[website](http://git-scm.com/)
+
+The GIT repository can currently be found at 
+[https://github.com/ICB-DCM/AMICI](https://github.com/ICB-DCM/AMICI)
+and a direct clone is possible via
+
+    git clone https://github.com/ICB-DCM/AMICI.git AMICI
+
+
+<a name="python"></a>
+## Python
+
+To use AMICI from python, install the module and all other requirements
+using pip:
+
+    pip3 install amici
+
+You can now import it as python module:
+
+    import amici
+
+For cases where this installation fails, check below for special setups
+and custom installations.
+For Python-AMICI usage see 
+[https://github.com/ICB-DCM/AMICI/blob/master/documentation/PYTHON.md](https://github.com/ICB-DCM/AMICI/blob/master/documentation/PYTHON.md).
+
+### Light installation 
+
+In case you only want to use the AMICI Python package for generating model code
+for use with Matlab or C++ and don't want to bothered with any unnecessary 
+dependencies, you can run
+
+    pip3 install --install-option --no-clibs amici
+
+Note, however, that you will not be able to compile any model into a 
+Python extension with this installation.
+
+NOTE: If you run into an error with above installation command, install
+all AMICI dependencies listed in 
+[`setup.py`](https://github.com/ICB-DCM/AMICI/blob/master/python/sdist/setup.py)
+manually, and try again. (This is because `pip` `--install-option`s are
+applied to *all* installed packages, including dependencies.)
+
+### Anaconda
+
+To use an Anaconda installation of python 
+([https://www.anaconda.com/distribution/](https://www.anaconda.com/distribution/),
+Python>=3.6), proceed as follows:
+
+Since Anaconda provides own versions of some packages which might not
+work with amici (in particular the gcc compiler), create a minimal
+virtual environment via:
+
+    conda create --name ENV_NAME pip python
+
+Here, replace ENV_NAME by some name for the environment. To activate the
+environment, do:
+
+    source activate ENV_NAME
+
+(and `conda deactivate` later to deactivate it again).
+
+SWIG must be installed and available in your `PATH`, and a
+CBLAS-compatible BLAS must be available. You can also use conda to
+install the latter locally, using:
+
+    conda install -c conda-forge openblas
+
+To install AMICI, now do:
+
+    pip install amici
+
+The option `--no-cache` may be helpful here to make sure the
+installation is done completely anew.
+
+Now, you are ready to use AMICI in the virtual environment.
+
+#### Anaconda on Mac
+
+If the above installation does not work for you, try installing AMICI
+via:
+
+    CFLAGS="-stdlib=libc++" CC=clang CXX=clang pip3 install --verbose amici
+
+This will use the `clang` compiler.
+
+You will have to pass the same options when compiling any model later
+on. This can be done by inserting the following code before calling
+`sbml2amici`:
+    
+    import os
+    os.environ['CC'] = 'clang'
+    os.environ['CXX'] = 'clang'
+    os.environ['CFLAGS'] = '-stdlib=libc++'
+
+(For further discussion see https://github.com/ICB-DCM/AMICI/issues/357)
+
+
+### Windows
+
+To install AMICI on Windows using python, you can proceed as follows:
+
+Some general remarks:
+
+* Install all libraries in a path not containing white spaces,
+  e.g. directly under C:.
+* Replace the following paths according to your installation.
+* Slashes can be preferable to backslashes for some environment
+  variables.
+* See also [#425](https://github.com/icb-dcm/amici/issues/425) for
+  further discussion.
+
+Then, follow these steps:
+
+* A python environment for Windows is required. We recommend
+  [Anaconda](https://www.anaconda.com/distribution/) with python >=3.6.
+* Install [mingw64](https://sourceforge.net/projects/mingw-w64/files/latest/download)
+  (32bit will succeed to compile, but fail during linking).
+  During installation, select Version=8.1.0, Architecture=x64_64.
+  Add the following directory to `PATH`:
+    + `C:\mingw-w64\x86_64-8.1.0-posix-sjlj-rt_v6-rev0\mingw64\bin`
+* Make sure that this is the compiler that is found by the system
+  (e.g. `where gcc` in a `cmd` should point to this installation).
+* Download CBLAS headers and libraries, e.g.
+  [OpenBLAS](https://sourceforge.net/projects/openblas/files/v0.2.19/),
+  binary distribution 0.2.19. Set the following environment variables:
+    + `BLAS_CFLAGS=-IC:/OpenBLAS-v0.2.19-Win64-int32/include`
+    + `BLAS_LIBS=-Wl,-Bstatic -LC:/OpenBLAS-v0.2.19-Win64-int32/lib -lopenblas -Wl,-Bdynamic`
+* Install [SWIG](http://www.swig.org/download.html)
+  (version swigwin-3.0.12 worked) and add the following directory to 
+  `PATH`:
+    + `C:\swigwin-3.0.12`
+* Install AMICI using:
+
+    `pip install --global-option="build_clib" --global-option="--compiler=mingw32" --global-option="build_ext" --global-option="--compiler=mingw32" amici --no-cache-dir --verbose`
+
+Possible sources of errors:
+
+* On recent Windows versions,
+  `anaconda3\Lib\distutils\cygwinccompiler.py` fails linking
+  `msvcr140.dll` with 
+  `[...] x86_64-w64-mingw32/bin/ld.exe: cannot find -lmsvcr140`.
+  This is not required for amici, so in `cygwinccompiler.py` 
+  `return ['msvcr140']` can be changed to `return []`.
+* If you use a python version where 
+  [python/cpython#880](https://github.com/python/cpython/pull/880)
+  has not been fixed yet, you need to disable 
+  `define hypot _hypot in anaconda3\include/pyconfig.h` yourself.
+* `import amici` in python resulting in the very informative 
+  
+  > ImportError: DLL load failed: The specified module could not be found.
+  
+  means that some amici module dependencies were not found (not the
+  AMICI module itself).
+  [DependencyWalker](http://www.dependencywalker.com/) will show you
+  which ones.
+
+### Custom installation
+
+AMICI Python package installation can be customized using a number of
+environment variables:
+
+|Variable | Purpose | Example |
+|---|---|---|
+|`CC`| Setting the C(++) compiler | `CC=/usr/bin/g++`| 
+|`CFLAGS`| Extra compiler flags used in every compiler call | | 
+|`BLAS_CFLAGS`| Compiler flags for, e.g. BLAS include directories | | 
+|`BLAS_LIBS`| Flags for linking BLAS | | 
+|`ENABLE_GCOV_COVERAGE`| Set to build AMICI to provide code coverage information | `ENABLE_GCOV_COVERAGE=TRUE`| 
+|`ENABLE_AMICI_DEBUGGING`| Set to build AMICI with debugging symbols | `ENABLE_AMICI_DEBUGGING=TRUE`| 
+|`AMICI_PARALLEL_COMPILE`| Set to the number of parallel processes to be used for C(++) file compilation (defaults to 1)| `AMICI_PARALLEL_COMPILE=4`|
+
+
+<a name="matlab"></a>
+## MATLAB
+
+To use AMICI from MATLAB, start MATLAB and add the `AMICI/matlab`
+directory to the MATLAB path. To add all toolbox directories to the
+MATLAB path, execute the matlab script
+
+    installAMICI.m
+
+To store the installation for further MATLAB session, the path can be
+saved via
+
+    savepath
+
+For the compilation of .mex files, MATLAB needs to be configured with a
+working C++ compiler. The C++ compiler needs to be installed and
+configured via:
+
+    mex -setup c++
+
+For a list of supported compilers we refer to the mathworks 
+documentation: 
+[mathworks.com](http://mathworks.com/support/compilers/R2018b/index.html)
+Note that Microsoft Visual Studio compilers are currently not supported.
+
+
+<a name="cpp"></a>
+## C++ only
+
+To use AMICI from C++, run the
+
+    ./scripts/buildSundials.sh
+    ./scripts/buildSuitesparse.sh
+    ./scripts/buildAmici.sh
+
+script to compile AMICI library.
+
+**NOTE**: On some systems, the CMake executable may be named something
+other than `cmake`. In this case, set the `CMAKE` environment variable
+to the correct name (e.g. `export CMAKE=cmake3`, in case you have CMake
+available as `cmake3`).
+
+The static library file can then be linked from
+
+    ./build/libamici.a
+
+In CMake-based packages, amici can be linked via
+
+    find_package(Amici)
+
+### Optional SuperLU_MT support
+
+To build AMICI with SuperLU_MT support, run
+
+    ./scripts/buildSuperLUMT.sh
+    ./scripts/buildSundials.sh
+    cd build/
+    cmake -DSUNDIALS_SUPERLUMT_ENABLE=ON ..
+    make
+
+
+<a name="dependencies"></a>
+## Dependencies
+
+### General
+
+The tools SUNDIALS and SuiteSparse shipped with AMICI do __not__ require
+explicit installation.
+
+AMICI uses the following packages from SUNDIALS:
+
+__CVODES__: the sensitivity-enabled ODE solver in SUNDIALS. Radu Serban
+and Alan C. Hindmarsh. _ASME 2005 International Design Engineering
+Technical Conferences and Computers and Information in Engineering
+Conference._ American Society of Mechanical Engineers, 2005. 
+[PDF](http://proceedings.asmedigitalcollection.asme.org/proceeding.aspx?articleid=1588657)
+
+__IDAS__
+
+AMICI uses the following packages from SuiteSparse:
+
+__Algorithm 907: KLU__, A Direct Sparse Solver for Circuit Simulation
+Problems. Timothy A. Davis, Ekanathan Palamadai Natarajan, 
+_ACM Transactions on Mathematical Software_, Vol 37, Issue 6, 2010,
+pp 36:1 - 36:17. [PDF](http://dl.acm.org/authorize?305534)
+
+__Algorithm 837: AMD__, an approximate minimum degree ordering
+algorithm, Patrick R. Amestoy, Timothy A. Davis, Iain S. Duff,
+_ACM Transactions on Mathematical Software_, Vol 30, Issue 3, 2004,
+pp 381 - 388. [PDF](http://dl.acm.org/authorize?733169)
+
+__Algorithm 836: COLAMD__, a column approximate minimum degree ordering
+algorithm, Timothy A. Davis, John R. Gilbert, Stefan I. Larimore,
+Esmond G. Ng _ACM Transactions on Mathematical Software_, Vol 30,
+Issue 3, 2004, pp 377 - 380. [PDF](http://dl.acm.org/authorize?734450)
+
+#### libsbml
+
+To import Systems Biology Markup Language ([SBML](http://sbml.org/))
+models, AMICI relies on the Python or MATLAB SBML library.
+
+#### Math Kernel Library (MKL)
+
+The python and C++ interfaces require a system installation of a `BLAS`.
+AMICI has been tested with various native and general purpose MKL
+implementations such as Accelerate, Intel MKL, cblas, openblas, atlas.
+The matlab interface uses the MATLAB MKL, which requires no separate
+installation.
+
+#### C++ compiler
+
+All AMICI installations require a C++11-compatible C++ compiler.
+AMICI has been tested with g++, mingw, clang and the Intel compiler.
+Visual C++ is not officially supported, but may work.
+
+#### HDF5
+
+The python and C++ interfaces provide routines to read and write options
+and results in [hdf5](https://support.hdfgroup.org/HDF5/) format. 
+For the python interface, the installation of hdf5 is optional, but for
+the C++ interace it is currently required.
+
+HDF5 can be installed using package managers such as
+[brew](https://brew.sh) or [apt](https://wiki.debian.org/Apt):
+
+    brew install hdf5
+
+or
+
+    apt-get install libhdf5-serial-dev
+
+#### SWIG
+
+The python interface requires [SWIG](http://www.swig.org), which has to
+be installed by the user. As root user, SWIG can be installed using
+package managers such as [brew](https://brew.sh) or
+[apt](https://wiki.debian.org/Apt):
+
+    brew install swig
+
+or
+
+    apt-get install swig3.0
+
+Or by non-root users, using `scripts/downloadAndBuildSwig.sh` from the
+AMICI repository (not included in the PyPI package). The binary
+directory has to be added to the `PATH` environment variable, or `SWIG`
+has to be set as described in the following section.
+
+
+##### Using a non-default SWIG executable
+
+We note here that some linux package managers may provide swig
+executables as `swig3.0`, but installation as `swig` is required. This
+can be fixed as root user using, e.g., symbolic links:
+
+    mkdir -p ~/bin/ && ln -s $(which swig3.0) ~/bin/swig && export PATH=~/bin/:$PATH
+
+Non-root users can set the `SWIG` environment variable to the full
+path of the desired SWIG executable. This variable has be set during
+AMICI package installation as well as during model compilation.
+
+### Matlab
+
+The MATLAB interface requires the Mathworks Symbolic Toolbox for model
+generation via `amiwrap(...)`, but not for execution of precompiled
+models. Currently MATLAB R2018a or newer is not supported (see 
+[https://github.com/ICB-DCM/AMICI/issues/307](https://github.com/ICB-DCM/AMICI/issues/307)).
+
+The Symbolic Toolbox requirement can be circumvented by performing model
+import using the Python interface. The result code can then be used from
+Matlab. 
+
+
+### Python
+
+The python interface requires python 3.6 or newer and a cblas-compatible
+BLAS library to be installed. Windows installations via pip are
+currently not supported, but users may try to install amici using the
+build scripts provided for the C++ interface (these will by default
+automatically install the python module).
+
+The python interface depends on some additional packages, e.g. `numpy`.
+They are automatically installed when installing the python package.
+
+### C++
+
+The C++ interface requires `cmake` and a cblas-compatible BLAS to be
+installed.
+
+
+### Optional
+
+__SuperLU_MT__, "a general purpose library for the direct solution of large,
+sparse, nonsymmetric systems of linear equations"
+(https://crd-legacy.lbl.gov/~xiaoye/SuperLU/#superlu_mt).
+SuperLU_MT is optional and is so far only available from the C++ interface.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/LICENSE.md b/Requirements/AMICI-0.10.11_SS_eventFix/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..a10792e80e6b93c3921d9da2ea1b7e7e7963ec04
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/LICENSE.md
@@ -0,0 +1,14 @@
+# License Conditions
+
+Copyright (c) 2015-2018, Fabian Fröhlich, Jan Hasenauer, Daniel Weindl and Paul Stapor
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/README.md b/Requirements/AMICI-0.10.11_SS_eventFix/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..750fc1b2c66dc39b0fea70270ae489bbe8dd66dc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/README.md
@@ -0,0 +1,133 @@
+# About AMICI
+
+AMICI provides a multi-language (Python, C++, Matlab) interface for the
+[SUNDIALS](https://computing.llnl.gov/projects/sundials/) solvers
+[CVODES](https://computing.llnl.gov/projects/sundials/cvodes)
+(for ordinary differential equations) and
+[IDAS](https://computing.llnl.gov/projects/sundials/idas)
+(for algebraic differential equations). AMICI allows the user to read
+differential equation models specified as [SBML](http://sbml.org/)
+and automatically compiles such models as `.mex` simulation files
+(Matlab), C++ executables or Python modules.
+
+In contrast to the (no longer maintained)
+[sundialsTB](https://computing.llnl.gov/projects/sundials/sundials-software)
+Matlab interface, all necessary functions are transformed into native
+C++ code, which allows for a significantly faster simulation.
+
+Beyond forward integration, the compiled simulation file also allows for
+forward sensitivity analysis, steady state sensitivity analysis and
+adjoint sensitivity analysis for likelihood based output functions.
+
+The interface was designed to provide routines for efficient gradient
+computation in parameter estimation of biochemical reaction models but
+it is also applicable to a wider range of differential equation
+constrained optimization problems.
+
+
+## Features
+
+* SBML import (see details below)
+* Generation of C++ code for model simulation and sensitivity
+  computation
+* Access to and high customizability of CVODES and IDAS solver
+* Python, C++, Matlab interface
+* Sensitivity analysis
+  * forward
+  * steady state
+  * adjoint
+  * first- and second-order
+* Pre-equilibration and pre-simulation conditions
+* Support for
+  [discrete events and logical operations](https://academic.oup.com/bioinformatics/article/33/7/1049/2769435)
+
+
+## Interfaces & workflow
+
+The AMICI workflow starts with importing a model from either
+[SBML](http://sbml.org/) (Matlab, Python) or a Matlab definition of the
+model (Matlab-only). From this input, all equations for model simulation
+are derived symbolically and C++ code is generated. This code is then
+compiled into a C++ library, a Python module, or a Matlab `.mex` file and
+is then used for model simulation.
+
+![AMICI workflow](https://raw.githubusercontent.com/ICB-DCM/AMICI/master/documentation/gfx/amici_workflow.png)
+
+## Getting started
+
+AMICI installation instructions are provided
+[here](http://icb-dcm.github.io/AMICI/md__i_n_s_t_a_l_l.html).
+
+To get you started with Python-AMICI the best way might be this
+[Jupyter notebook](https://github.com/ICB-DCM/AMICI/blob/master/python/examples/example_steadystate/ExampleSteadystate.ipynb).
+
+For Matlab, various examples are available
+[here](https://github.com/ICB-DCM/AMICI/tree/master/matlab/examples).
+
+
+Comprehensive documentation on installation and usage of AMICI is available
+online at [http://icb-dcm.github.io/AMICI/](http://icb-dcm.github.io/AMICI/).
+
+Any contributions to AMICI are welcome, read more contributing
+[here](http://icb-dcm.github.io/AMICI/md__c_o_n_t_r_i_b_u_t_i_n_g.html).
+
+
+### Getting help
+
+In case of questions or problems with using AMICI, feel free to post an
+[issue](https://github.com/ICB-DCM/AMICI/issues) on Github. We are trying to
+get back to you quickly.
+
+## Publications
+
+**Citeable DOI for the latest AMICI release:**
+[![DOI](https://zenodo.org/badge/43677177.svg)](https://zenodo.org/badge/latestdoi/43677177)
+
+There is a list of [publications using AMICI](documentation/references.md).
+If you used AMICI in your work, we are happy to include
+your project, please let us know via a Github issue.
+
+When using AMICI in your project, please cite
+* [Fröhlich, F., Kaltenbacher, B., Theis, F. J., & Hasenauer, J. (2017). Scalable Parameter Estimation for Genome-Scale Biochemical Reaction Networks.   Plos Computational Biology, 13(1), e1005331. doi: 10.1371/journal.pcbi.1005331](https://doi.org/10.1371/journal.pcbi.1005331)
+and/or
+* [Fröhlich, F., Theis, F. J., Rädler, J. O., & Hasenauer, J. (2017). Parameter estimation for dynamical systems with discrete events and logical operations. Bioinformatics, 33(7), 1049-1056. doi: 10.1093/bioinformatics/btw764](https://doi.org/10.1093/bioinformatics/btw764)
+
+
+## Status of SBML support in Python-AMICI
+
+Python-AMICI currently passes 494 out of the 1780 (~28%) test cases from
+the semantic
+[SBML Test Suite](https://github.com/sbmlteam/sbml-test-suite/).
+
+In additional, we currently plan to add support for the following features
+(see corresponding issues for details and progress):
+
+- Events (currently Matlab-only)
+- Rate rules
+- Algebraic rules
+- Species assignment rules
+- Compartment assignment rules
+- Models without species
+- Logical operators
+
+contributions are welcome.
+
+However, the following features are unlikely to be supported:
+
+- SBML extensions
+- `factorial()`, `ceil()`, `floor()`, due to incompatibility with
+  symbolic sensitivity computations
+- initial assignments for parameters
+- `delay()` due to missing SUNDIALS solver support
+
+
+## Current build status
+
+<a href="https://badge.fury.io/py/amici" alt="PyPI version">
+  <img src="https://badge.fury.io/py/amici.svg"></a>
+<a href="https://travis-ci.com/ICB-DCM/AMICI" alt="Build Status">
+  <img src="https://travis-ci.com/ICB-DCM/AMICI.svg?branch=master"></a>
+<a href="https://codecov.io/gh/ICB-DCM/AMICI" alt="CodeCov">
+  <img src="https://codecov.io/gh/ICB-DCM/AMICI/branch/master/graph/badge.svg"></a>
+<a href="https://www.codacy.com/app/FFroehlich/AMICI" alt="Codacy">
+  <img src="https://api.codacy.com/project/badge/Grade/945235766e344a7fa36278feab915ff6"></a>
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77cross.f b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77cross.f
new file mode 100644
index 0000000000000000000000000000000000000000..b79920d802a5f8c482d9752462f495ac7b38a76b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77cross.f
@@ -0,0 +1,50 @@
+C ======================================================================
+C === AMD_cross ========================================================
+C ======================================================================
+
+C ----------------------------------------------------------------------
+C AMD, Copyright (c) by Timothy A. Davis, Patrick R.
+C Amestoy, and Iain S. Duff.  See ../README.txt for License.
+C email: DrTimothyAldenDavis@gmail.com
+C ----------------------------------------------------------------------
+
+C This program provides an example of how to call the C version of AMD
+C from a Fortran program.  It is HIGHLY non-portable.
+
+C The amd_order routine returns PERM (1) < 0 if an error occurs.
+C (-1: out of memory, -2: invalid matrix)
+
+C Note that the input matrix is 0-based.  From Fortran, column j of the
+C matrix is in AI (AP (I)+1 ... AP (I+1)).  The row indices in this
+C set are in the range 0 to N-1.  To demonstrate this translation,
+C the input matrix is printed in 1-based form.  This program uses
+C the same 5-by-5 test matrix as amd_simple.c.
+
+        INTEGER N, NZ, K, P
+        PARAMETER (N = 5, NZ = 14)
+        INTEGER AP (N+1), AI (NZ), PERM (N)
+        DATA AP / 0,   2,       6,       10,  12, 14 /
+        DATA AI / 0,1, 0,1,2,4, 1,2,3,4, 2,3, 1,4    /
+        DOUBLE PRECISION CONTROL (5), INFO (20)
+
+C       print the input matrix
+        PRINT 10, N, N, NZ
+10      FORMAT ('Input matrix:', I2, '-by-', I2, ' with',I3,' entries')
+        DO 40 J = 1, N
+            PRINT 20, J, AP (J+1) - AP (J), AP (J)+1, AP (J+1)
+20          FORMAT ( /, 'Column: ', I2, ' number of entries: ', I2,
+     $          ' with row indices in AI (', I3, ' ... ', I3, ')')
+            PRINT 30, ((AI (P) + 1), P = AP (J) + 1, AP (J+1))
+30          FORMAT ('    row indices: ', 24I3)
+40      CONTINUE
+
+        CALL AMDDEFAULTS (CONTROL)
+        CALL AMDORDER (N, AP, AI, PERM, CONTROL, INFO)
+        CALL AMDINFO (INFO)
+
+        DO 60 K = 1, N
+            PRINT 50, K, PERM (K) + 1
+50          FORMAT ('PERM (',I2,') = ', I2)
+60      CONTINUE
+        END
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77demo.f b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77demo.f
new file mode 100644
index 0000000000000000000000000000000000000000..6aa6296a2e7619d170147b484fb967c000958706
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77demo.f
@@ -0,0 +1,160 @@
+C ======================================================================
+C === Fortran AMD demo main program ====================================
+C ======================================================================
+
+C ----------------------------------------------------------------------
+C AMD, Copyright (c) by Timothy A. Davis, Patrick R.
+C Amestoy, and Iain S. Duff.  See ../README.txt for License.
+C email: DrTimothyAldenDavis@gmail.com
+C ----------------------------------------------------------------------
+
+C A simple Fortran 77 main program that illustrates the use of the
+C Fortran version of AMD (both the AMD and AMDBAR routines).  Note
+C that aggressive absorption has no effect on this particular matrix.
+
+C       AP and AI contain the symmetric can_24 Harwell/Boeing matrix,
+C       including upper and lower triangular parts, but excluding the
+C       diagonal entries.  Note that this matrix is 1-based, with row
+C       and column indices in the range 1 to N.
+
+        INTEGER N, NZ, IWLEN, PFREE, I, J, K, JNEW, P, INEW,
+     $      METHOD, NCMPA
+        PARAMETER (N = 24, NZ = 136, IWLEN = 200)
+        INTEGER PE (N), DEGREE (N), NV (N), NEXT (N), PERM (N), W (N),
+     $      HEAD (N), PINV (N), LEN (N), AP (N+1), AI (NZ), IW (IWLEN)
+        CHARACTER A (24,24)
+
+        DATA AP
+     $      / 1, 9, 14, 19, 24, 29, 34, 42, 50, 53, 61, 66, 71,
+     $       76, 81, 86, 91, 94, 102, 110, 118, 123, 131, 134, 137 /
+        DATA AI /
+     $      6, 7, 13, 14, 18, 19, 20, 22,
+     $      9, 10, 14, 15, 18,
+     $      7, 12, 21, 22, 23,
+     $      8, 11, 16, 19, 20,
+     $      8, 10, 15, 16, 17,
+     $      1, 7, 13, 14, 18,
+     $      1, 3, 6, 12, 13, 20, 22, 24,
+     $      4, 5, 10, 15, 16, 17, 18, 19,
+     $      2, 10, 15,
+     $      2, 5, 8, 9, 14, 15, 18, 19,
+     $      4, 19, 20, 21, 22,
+     $      3, 7, 13, 22, 24,
+     $      1, 6, 7, 12, 24,
+     $      1, 2, 6, 10, 18,
+     $      2, 5, 8, 9, 10,
+     $      4, 5, 8, 17, 19,
+     $      5, 8, 16,
+     $      1, 2, 6, 8, 10, 14, 19, 20,
+     $      1, 4, 8, 10, 11, 16, 18, 20,
+     $      1, 4, 7, 11, 18, 19, 21, 22,
+     $      3, 11, 20, 22, 23,
+     $      1, 3, 7, 11, 12, 20, 21, 23,
+     $      3, 21, 22,
+     $      7, 12, 13 /
+
+C       print the input matrix
+        PRINT 11, N, N, NZ
+11      FORMAT ('AMD Fortran 77 demo, with the 24-by-24',
+     $      ' Harwell/Boeing matrix, can_24:'
+     $      /, 'Input matrix: ', I2, '-by-', I2,' with ',I3,' entries',
+     $      /, 'Note that the Fortran version of AMD requires that'
+     $      /, 'no diagonal entries be present.')
+        DO 20 J = 1, N
+            PRINT 21, J, AP (J+1) - AP (J), AP (J), AP (J+1)-1
+21          FORMAT ( /, 'Column: ', I2, ' number of entries: ', I2,
+     $          ' with row indices in AI (', I3, ' ... ', I3, ')')
+            PRINT 10, ((AI (P)), P = AP (J), AP (J+1) - 1)
+10          FORMAT ('    row indices: ', 24I3)
+20      CONTINUE
+
+C       print a character plot of the input matrix.  This is only
+C       reasonable because the matrix is small.
+        PRINT 31
+31      FORMAT ('Plot of input matrix pattern:')
+        DO 50 J = 1,N
+            DO 30 I = 1,N
+                A (I, J) = '.'
+30          CONTINUE
+C           add the diagonal entry to the plot
+            A (J, J) = 'X'
+            DO 40 P = AP (J), AP (J+1) - 1
+                I = AI (P)
+                A (I, J) = 'X'
+40          CONTINUE
+50      CONTINUE
+        PRINT 60, ((MOD (J, 10)), J = 1,N)
+60      FORMAT ('     ', 24I2)
+        DO 80 I = 1,N
+            PRINT 70, I, (A (I, J), J = 1,N)
+70          FORMAT (' ', I2, ': ', 24A2)
+80      CONTINUE
+
+        DO 190 METHOD = 1,2
+
+C           load the matrix into AMD's workspace
+            DO 90 J = 1,N
+                PE (J) = AP (J)
+                LEN (J) = AP (J+1) - AP (J)
+90          CONTINUE
+            DO 100 P = 1,NZ
+                IW (P) = AI (P)
+100         CONTINUE
+            PFREE = NZ + 1
+
+C           order the matrix using AMD or AMDBAR
+            IF (METHOD .EQ. 1) THEN
+                PRINT 101 
+101             FORMAT (/, '------------------------------------------',
+     $                  /, 'ordering the matrix with AMD',
+     $                  /, '------------------------------------------')
+                CALL AMD (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT,
+     $              PERM, HEAD, PINV, DEGREE, NCMPA, W)
+            ELSE
+                PRINT 102 
+102             FORMAT (/, '------------------------------------------',
+     $                  /, 'ordering the matrix with AMDBAR',
+     $                  /, '------------------------------------------')
+                CALL AMDBAR (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT,
+     $              PERM, HEAD, PINV, DEGREE, NCMPA, W)
+            ENDIF
+
+C           print the permutation vector, PERM, and its inverse, PINV.
+C           row/column J = PERM (K) is the Kth row/column in the
+C           permuted matrix.
+            PRINT 110, (PERM (K), K = 1,N)
+110         FORMAT (/, 'Permutation vector: ', /, 24I3)
+            PRINT 120, (PINV (J), J = 1,N)
+120         FORMAT (/, 'Inverse permutation vector: ', /, 24I3)
+
+C           print a character plot of the permuted matrix.
+            PRINT 121
+121         FORMAT ('Plot of permuted matrix pattern:')
+            DO 150 JNEW = 1,N
+                J = PERM (JNEW)
+                DO 130 INEW = 1,N
+                    A (INEW, JNEW) = '.'
+130             CONTINUE
+C               add the diagonal entry to the plot
+                A (JNEW, JNEW) = 'X'
+                DO 140 P = AP (J), AP (J+1) - 1
+                    INEW = PINV (AI (P))
+                    A (INEW, JNEW) = 'X'
+140             CONTINUE
+150         CONTINUE
+            PRINT 60, ((MOD (J, 10)), J = 1,N)
+            DO 160 I = 1,N
+                PRINT 70, I, (A (I, J), J = 1,N)
+160         CONTINUE
+
+C           print the permuted matrix, PERM*A*PERM'
+            DO 180 JNEW = 1,N
+                J = PERM (JNEW)
+                PRINT 171, JNEW, J, AP (J+1) - AP (J)
+171             FORMAT (/, 'New column: ', I2, ' old column: ', I2,
+     $              ' number of entries: ', I2)
+                PRINT 170, (PINV (AI (P)), P = AP (J), AP (J+1) - 1)
+170             FORMAT ('    new row indices: ', 24I3)
+180         CONTINUE
+190     CONTINUE
+        END
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77simple.f b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77simple.f
new file mode 100644
index 0000000000000000000000000000000000000000..8f39606e6ebaa9d450babfd3042db9804d8f97a7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Demo/amd_f77simple.f
@@ -0,0 +1,37 @@
+C ----------------------------------------------------------------------
+C AMD, Copyright (c) by Timothy A. Davis, Patrick R.
+C Amestoy, and Iain S. Duff.  See ../README.txt for License.
+C email: DrTimothyAldenDavis@gmail.com
+C ----------------------------------------------------------------------
+
+C This program provides an example of how to call the Fortran version
+C of AMD.  It uses the same matrix as the amd_simple.c demo (in C).
+C Note that the diagonal entries are not present, and the matrix is
+C symmetric.
+
+        INTEGER N, NZ, J, K, P, IWLEN, PFREE, NCMPA
+        PARAMETER (N = 5, NZ = 10, IWLEN = 17)
+        INTEGER AP (N+1), AI (NZ), LAST (N), PE (N), LEN (N), ELEN (N),
+     $      IW (IWLEN), DEGREE (N), NV (N), NEXT (N), HEAD (N), W (N)
+        DATA AP / 1, 2,     5,     8,  9,  11/
+        DATA AI / 2, 1,3,5, 2,4,5, 3,  2,3   /
+
+C       load the matrix into the AMD workspace
+        DO 10 J = 1,N
+            PE (J) = AP (J)
+            LEN (J) = AP (J+1) - AP (J)
+10      CONTINUE
+        DO 20 P = 1,NZ
+            IW (P) = AI (P)
+20      CONTINUE
+        PFREE = NZ + 1
+
+C       order the matrix (destroys the copy of A in IW, PE, and LEN)
+        CALL AMD (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT, LAST, HEAD,
+     $      ELEN, DEGREE, NCMPA, W)
+
+        DO 60 K = 1, N
+            PRINT 50, K, LAST (K)
+50          FORMAT ('P (',I2,') = ', I2)
+60      CONTINUE
+        END
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/AMD_UserGuide.bib b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/AMD_UserGuide.bib
new file mode 100644
index 0000000000000000000000000000000000000000..03fbfa8f7625e0628fe5327488475def3a89c62a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/AMD_UserGuide.bib
@@ -0,0 +1,98 @@
+@string{SIREV       = "{SIAM} Review"}
+@string{SIMAX       = "{SIAM} J. Matrix Anal. Applic."}
+@string{SIAMJSC     = "{SIAM} J. Sci. Comput."}
+@string{TOMS        = "{ACM} Trans. Math. Softw."}
+
+@article{schu:01,
+	author    = {J. Schulze},
+	title     = {Towards a tighter coupling of bottom-up and top-down sparse matrix ordering methods},
+	journal   = {BIT},
+	volume    = {41},
+	number    = {4},
+	pages     = "800--841",
+	year      = {2001}
+	}
+
+@article{GeorgeLiu89,
+	author={George, A. and Liu, J. W. H.},
+	year={1989},
+	title={The Evolution of the Minimum Degree Ordering Algorithm},
+	journal=SIREV,
+	volume={31},
+	number={1},
+	pages={1--19}}
+
+@article{AmestoyDavisDuff96,
+	author={Amestoy, P. R. and Davis, T. A. and Duff, I. S.},
+	title={An approximate minimum degree ordering algorithm},
+	journal=SIMAX,
+	year={1996}
+	,volume={17}
+	,number={4}
+	,pages={886-905}
+	}
+
+@article{AmestoyDavisDuff04,
+	author={Amestoy, P. R. and Davis, T. A. and Duff, I. S.},
+	title={Algorithm 837: An approximate minimum degree ordering algorithm},
+	journal=TOMS,
+	year={2004}
+	,volume={30}
+	,number={3}
+	,pages={381-388}
+	}
+
+@misc{hsl:2002,
+ author = {HSL},
+  title = "{HSL} 2002: {A} collection of {F}ortran codes for large
+           scale scientific computation",
+  note = {{\tt www.cse.clrc.ac.uk/nag/hsl}},
+  year = 2002}
+
+
+@article{RothbergEisenstat98,
+	author={Rothberg, E. and Eisenstat, S. C.},
+	title={Node selection strategies for bottom-up sparse matrix orderings},
+	journal=SIMAX,
+	year={1998}
+	,volume={19}
+	,number={3}
+	,pages={682-695}
+	}
+
+@article{KarypisKumar98e,
+	author={Karypis, G. and Kumar, V.},
+	title={A fast and high quality multilevel scheme for partitioning irregular graphs},
+	journal=SIAMJSC,
+	year={1998}
+	,volume={20}
+	,pages={359-392}
+	}
+
+@article{Chaco,
+	author={B. Hendrickson and E. Rothberg},
+	title={Improving the runtime and quality of nested dissection ordering},
+	journal=SIAMJSC,
+	year={1999}
+	,volume={20}
+	,pages={468--489}
+	}
+
+@article{PellegriniRomanAmestoy00,
+	author={Pellegrini, F. and Roman, J. and Amestoy, P.},
+	title={Hybridizing nested dissection and halo approximate minimum degree for efficient sparse matrix ordering},
+	journal={Concurrency: Practice and Experience},
+	year={2000}
+	,volume={12}
+	,pages={68-84}
+	}
+
+@article{DavisGilbertLarimoreNg04,
+	author={Davis, T. A. and Gilbert, J. R. and Larimore, S. I. and Ng, E. G.},
+	title={A column approximate minimum degree ordering algorithm},
+	journal=TOMS,
+	year={2004}
+	,volume={30}
+	,pages={353-376}
+	}
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/AMD_UserGuide.tex b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/AMD_UserGuide.tex
new file mode 100644
index 0000000000000000000000000000000000000000..862ad69c87ebfe7dcd74ec512ef23a6e9169b9a9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/AMD_UserGuide.tex
@@ -0,0 +1,769 @@
+\documentclass[11pt]{article}
+
+\newcommand{\m}[1]{{\bf{#1}}}       % for matrices and vectors
+\newcommand{\tr}{^{\sf T}}          % transpose
+
+\topmargin 0in
+\textheight 9in
+\oddsidemargin 0pt
+\evensidemargin 0pt
+\textwidth 6.5in
+
+%------------------------------------------------------------------------------
+\begin{document}
+%------------------------------------------------------------------------------
+
+\title{AMD User Guide}
+\author{Patrick R. Amestoy\thanks{ENSEEIHT-IRIT,
+2 rue Camichel 31017 Toulouse, France.
+email: amestoy@enseeiht.fr.  http://www.enseeiht.fr/$\sim$amestoy.}
+\and Timothy A. Davis\thanks{
+email: DrTimothyAldenDavis@gmail.com,
+http://www.suitesparse.com.
+This work was supported by the National
+Science Foundation, under grants ASC-9111263, DMS-9223088, and CCR-0203270.
+Portions of the work were done while on sabbatical at Stanford University
+and Lawrence Berkeley National Laboratory (with funding from Stanford
+University and the SciDAC program).
+}
+\and Iain S. Duff\thanks{Rutherford Appleton Laboratory, Chilton, Didcot, 
+Oxon OX11 0QX, England. email: i.s.duff@rl.ac.uk.  
+http://www.numerical.rl.ac.uk/people/isd/isd.html.
+This work was supported by the EPSRC under grant GR/R46441.
+}}
+
+\date{VERSION 2.4.6, May 4, 2016}
+\maketitle
+
+%------------------------------------------------------------------------------
+\begin{abstract}
+AMD is a set of routines that implements the approximate minimum degree ordering
+algorithm to permute sparse matrices prior to
+numerical factorization.
+There are versions written in both C and Fortran 77.
+A MATLAB interface is included.
+\end{abstract}
+%------------------------------------------------------------------------------
+
+AMD Copyright\copyright 2013 by Timothy A.
+Davis, Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+AMD is available under alternate licences; contact T. Davis for details.
+
+{\bf AMD License:} Refer to the AMD/Doc/License.txt file for the license
+for your particular copy of AMD.
+
+{\bf Availability:}
+    http://www.suitesparse.com
+
+{\bf Acknowledgments:}
+
+    This work was supported by the National Science Foundation, under
+    grants ASC-9111263 and DMS-9223088 and CCR-0203270.
+    The conversion to C, the addition of the elimination tree
+    post-ordering, and the handling of dense rows and columns
+    were done while Davis was on sabbatical at
+    Stanford University and Lawrence Berkeley National Laboratory.
+
+%------------------------------------------------------------------------------
+\newpage
+\section{Overview}
+%------------------------------------------------------------------------------
+
+AMD is a set of routines for preordering a sparse matrix prior to
+numerical factorization.  It uses an approximate minimum degree ordering
+algorithm \cite{AmestoyDavisDuff96,AmestoyDavisDuff04}
+to find a permutation matrix $\m{P}$
+so that the Cholesky factorization $\m{PAP}\tr=\m{LL}\tr$ has fewer
+(often much fewer) nonzero entries than the Cholesky factorization of $\m{A}$.
+The algorithm is typically much faster than other ordering methods
+and  minimum degree ordering
+algorithms that compute an exact degree \cite{GeorgeLiu89}.
+Some methods, such as approximate deficiency
+\cite{RothbergEisenstat98} and graph-partitioning based methods
+\cite{Chaco,KarypisKumar98e,PellegriniRomanAmestoy00,schu:01}
+can produce better orderings, depending on the matrix.
+
+The algorithm starts with an undirected graph representation of a
+symmetric sparse matrix $\m{A}$.  Node $i$ in the graph corresponds to row
+and column $i$ of the matrix, and there is an edge $(i,j)$ in the graph if
+$a_{ij}$ is nonzero.
+The degree of a node is initialized to the number of off-diagonal nonzeros
+in row $i$, which is the size of the set of nodes
+adjacent to $i$ in the graph.
+
+The selection of a pivot $a_{ii}$ from the diagonal of $\m{A}$ and the first
+step of Gaussian elimination corresponds to one step of graph elimination.
+Numerical fill-in causes new nonzero entries in the matrix
+(fill-in refers to
+nonzeros in $\m{L}$ that are not in $\m{A}$).
+Node $i$ is eliminated and edges are added to its neighbors
+so that they form a clique (or {\em element}).  To reduce fill-in,
+node $i$ is selected as the node of least degree in the graph.
+This process repeats until the graph is eliminated.
+
+The clique is represented implicitly.  Rather than listing all the
+new edges in the graph, a single list of nodes is kept which represents
+the clique.  This list corresponds to the nonzero pattern of the first
+column of $\m{L}$.  As the elimination proceeds, some of these cliques
+become subsets of subsequent cliques, and are removed.   This graph
+can be stored in place, that is
+using the same amount of memory as the original graph.
+
+The most costly part of the minimum degree algorithm is the recomputation
+of the degrees of nodes adjacent to the current pivot element.
+Rather than keep track of the exact degree, the approximate minimum degree
+algorithm finds an upper bound on the degree that is easier to compute.
+For nodes of least degree, this bound tends to be tight.  Using the
+approximate degree instead of the exact degree leads to a substantial savings
+in run time, particularly for very irregularly structured matrices.
+It has no effect on the quality of the ordering.
+
+In the C version of AMD, the elimination phase is followed by an
+elimination tree post-ordering.  This has no effect on fill-in, but
+reorganizes the ordering so that the subsequent numerical factorization is
+more efficient.  It also includes a pre-processing phase in which nodes of
+very high degree are removed (without causing fill-in), and placed last in the
+permutation $\m{P}$.  This reduces the run time substantially if the matrix
+has a few rows with many nonzero entries, and has little effect on the quality
+of the ordering.
+The C version operates on the
+symmetric nonzero pattern of $\m{A}+\m{A}\tr$, so it can be given
+an unsymmetric matrix, or either the lower or upper triangular part of
+a symmetric matrix.
+
+The two Fortran versions of AMD are essentially identical to two versions of
+the AMD algorithm discussed in an earlier paper \cite{AmestoyDavisDuff96}
+(approximate minimum external degree, both with and without aggressive
+absorption).
+For a discussion of the long history of the minimum degree algorithm,
+see \cite{GeorgeLiu89}.
+
+%------------------------------------------------------------------------------
+\section{Availability}
+%------------------------------------------------------------------------------
+
+In addition to appearing as a Collected Algorithm of the ACM, \newline
+AMD is available at http://www.suitesparse.com.
+The Fortran version is available as the routine {\tt MC47} in HSL
+(formerly the Harwell Subroutine Library) \cite{hsl:2002}.
+
+%------------------------------------------------------------------------------
+\section{Using AMD in MATLAB}
+%------------------------------------------------------------------------------
+
+The MATLAB function {\tt amd} is now a built-in function in MATLAB 7.3
+(R2006b).  The built-in {\tt amd} and the {\tt amd2} function provided here
+differ in how the optional parameters are passed
+(the 2nd input parameter).
+
+To use AMD2 in MATLAB, you must first compile the AMD2 mexFunction.
+Just type {\tt make} in the Unix system shell, while in the {\tt AMD/MATLAB}
+directory.  You can also type {\tt amd\_make} in MATLAB, while in the
+{\tt AMD/MATLAB} directory.  Place the {\tt AMD/MATLAB} directory in your
+MATLAB path.  This can be done on any system with MATLAB, including Windows.
+See Section~\ref{Install} for more details on how to install AMD.
+
+The MATLAB statement {\tt p=amd(A)} finds a permutation vector {\tt p} such
+that the Cholesky factorization {\tt chol(A(p,p))} is typically sparser than
+{\tt chol(A)}.
+If {\tt A} is unsymmetric, {\tt amd(A)} is identical to {\tt amd(A+A')}
+(ignoring numerical cancellation).
+If {\tt A} is not symmetric positive definite,
+but has substantial diagonal entries and a mostly symmetric nonzero pattern,
+then this ordering is also suitable for LU factorization.  A partial pivoting
+threshold may be required to prevent pivots from being selected off the
+diagonal, such as the statement {\tt [L,U,P] = lu (A (p,p), 0.1)}.
+Type {\tt help lu} for more details.
+The statement {\tt [L,U,P,Q] = lu (A (p,p))} in MATLAB 6.5 is
+not suitable, however, because it uses UMFPACK Version 4.0 and thus
+does not attempt to select pivots from the diagonal.
+UMFPACK Version 4.1 in MATLAB 7.0 and later
+uses several strategies, including a symmetric pivoting strategy, and
+will give you better results if you want to factorize an unsymmetric matrix
+of this type.  Refer to the UMFPACK User Guide for more details, at
+http://www.suitesparse.com.
+
+The AMD mexFunction is much faster than the built-in MATLAB symmetric minimum
+degree ordering methods, SYMAMD and SYMMMD.  Its ordering quality is
+comparable to SYMAMD, and better than SYMMMD
+\cite{DavisGilbertLarimoreNg04}.
+
+An optional input argument can be used to modify the control parameters for
+AMD (aggressive absorption, dense row/column handling, and printing of
+statistics).  An optional output
+argument provides statistics on the ordering, including an analysis of the
+fill-in and the floating-point operation count for a subsequent factorization.
+For more details (once AMD is installed),
+type {\tt help amd} in the MATLAB command window.
+
+%------------------------------------------------------------------------------
+\section{Using AMD in a C program}
+\label{Cversion}
+%------------------------------------------------------------------------------
+
+The C-callable AMD library consists of seven user-callable routines and one
+include file.  There are two versions of each of the routines, with
+{\tt int} and {\tt long} integers.
+The routines with prefix
+{\tt amd\_l\_} use {\tt long} integer arguments; the others use
+{\tt int} integer arguments.  If you compile AMD in the standard
+ILP32 mode (32-bit {\tt int}'s, {\tt long}'s, and pointers) then the versions
+are essentially identical.  You will be able to solve problems using up to 2GB
+of memory.  If you compile AMD in the standard LP64 mode, the size of an
+{\tt int} remains 32-bits, but the size of a {\tt long} and a pointer both get
+promoted to 64-bits.
+
+The following routines are fully described in Section~\ref{Primary}:
+
+\begin{itemize}
+\item {\tt amd\_order}
+({\tt long} version: {\tt amd\_l\_order})
+    {\footnotesize
+    \begin{verbatim}
+    #include "amd.h"
+    int n, Ap [n+1], Ai [nz], P [n] ;
+    double Control [AMD_CONTROL], Info [AMD_INFO] ;
+    int result = amd_order (n, Ap, Ai, P, Control, Info) ;
+    \end{verbatim}
+    }
+    Computes the approximate minimum degree ordering of an $n$-by-$n$ matrix
+    $\m{A}$.  Returns a permutation vector {\tt P} of size {\tt n}, where
+    {\tt P[k] = i} if row and column {\tt i} are the {\tt k}th row and
+    column in the permuted matrix.
+    This routine allocates its own memory of size $1.2e+9n$ integers,
+    where $e$ is the number of nonzeros in $\m{A}+\m{A}\tr$.
+    It computes statistics about the matrix $\m{A}$, such as the symmetry of
+    its nonzero pattern, the number of nonzeros in $\m{L}$,
+    and the number of floating-point operations required for Cholesky and LU
+    factorizations (which are returned in the {\tt Info} array).
+    The user's input matrix is not modified.
+    It returns {\tt AMD\_OK} if successful,
+    {\tt AMD\_OK\_BUT\_JUMBLED} if successful (but the matrix had unsorted
+    and/or duplicate row indices),
+    {\tt AMD\_INVALID} if the matrix is invalid,
+    {\tt AMD\_OUT\_OF\_MEMORY} if out of memory.
+
+\item {\tt amd\_defaults}
+({\tt long} version: {\tt amd\_l\_defaults})
+    {\footnotesize
+    \begin{verbatim}
+    #include "amd.h"
+    double Control [AMD_CONTROL] ;
+    amd_defaults (Control) ;
+    \end{verbatim}
+    }
+    Sets the default control parameters in the {\tt Control} array.  These can
+    then be modified as desired before passing the array to the other AMD
+    routines.
+
+\item {\tt amd\_control}
+({\tt long} version: {\tt amd\_l\_control})
+    {\footnotesize
+    \begin{verbatim}
+    #include "amd.h"
+    double Control [AMD_CONTROL] ;
+    amd_control (Control) ;
+    \end{verbatim}
+    }
+    Prints a description of the control parameters, and their values.
+
+\item {\tt amd\_info}
+({\tt long} version: {\tt amd\_l\_info})
+    {\footnotesize
+    \begin{verbatim}
+    #include "amd.h"
+    double Info [AMD_INFO] ;
+    amd_info (Info) ;
+    \end{verbatim}
+    }
+    Prints a description of the statistics computed by AMD, and their values.
+
+\item {\tt amd\_valid}
+({\tt long} version: {\tt amd\_valid})
+    {\footnotesize
+    \begin{verbatim}
+    #include "amd.h"
+    int n, Ap [n+1], Ai [nz] ;
+    int result = amd_valid (n, n, Ap, Ai) ;
+    \end{verbatim}
+    }
+    Returns {\tt AMD\_OK} or {\tt AMD\_OK\_BUT\_JUMBLED}
+    if the matrix is valid as input to {\tt amd\_order};
+    the latter is returned if the matrix has unsorted and/or duplicate
+    row indices in one or more columns. 
+    Returns {\tt AMD\_INVALID} if the matrix cannot be passed to
+    {\tt amd\_order}.
+    For {\tt amd\_order}, the matrix must
+    also be square.  The first two arguments are the number of rows and the
+    number of columns of the matrix.  For its use in AMD, these must both
+    equal {\tt n}.
+
+\item {\tt amd\_2}
+({\tt long} version: {\tt amd\_l2})
+    AMD ordering kernel.  It is faster than {\tt amd\_order}, and
+    can be called by the user, but it is difficult to use.
+    It does not check its inputs for errors.
+    It does not require the columns of its input matrix to be sorted,
+    but it destroys the matrix on output.  Additional workspace must be passed.
+    Refer to the source file {\tt AMD/Source/amd\_2.c} for a description.
+
+\end{itemize}
+
+The nonzero pattern of the matrix $\m{A}$ is represented in compressed column
+form.
+For an $n$-by-$n$ matrix $\m{A}$ with {\tt nz} nonzero entries, the
+representation consists of two arrays: {\tt Ap} of size {\tt n+1} and {\tt Ai}
+of size {\tt nz}.  The row indices of entries in column {\tt j} are stored in
+    {\tt Ai[Ap[j]} $\ldots$ {\tt Ap[j+1]-1]}.
+For {\tt amd\_order},
+if duplicate row indices are present, or if the row indices in any given
+column are not sorted in ascending order, then {\tt amd\_order} creates
+an internal copy of the matrix with sorted rows and no duplicate entries,
+and orders the copy.  This adds slightly to the time and memory usage of
+{\tt amd\_order}, but is not an error condition.
+
+The matrix is 0-based, and thus
+row indices must be in the range {\tt 0} to {\tt n-1}.
+The first entry {\tt Ap[0]} must be zero.
+The total number of entries in the matrix is thus {\tt nz = Ap[n]}.
+
+The matrix must be square, but it does not need to be symmetric.
+The {\tt amd\_order} routine constructs the nonzero pattern of
+$\m{B} = \m{A}+\m{A}\tr$ (without forming $\m{A}\tr$ explicitly if
+$\m{A}$ has sorted columns and no duplicate entries),
+and then orders the matrix $\m{B}$.  Thus, either the
+lower triangular part of $\m{A}$, the upper triangular part,
+or any combination may be passed.  The transpose $\m{A}\tr$ may also be
+passed to {\tt amd\_order}.
+The diagonal entries may be present, but are ignored.
+
+%------------------------------------------------------------------------------
+\subsection{Control parameters}
+\label{control_param}
+%------------------------------------------------------------------------------
+
+Control parameters are set in an optional {\tt Control} array.
+It is optional in the sense that if
+a {\tt NULL} pointer is passed for the {\tt Control} input argument,
+then default control parameters are used.
+%
+\begin{itemize}
+\item {\tt Control[AMD\_DENSE]} (or {\tt Control(1)} in MATLAB):
+controls the threshold for ``dense''
+rows/columns.  A dense row/column in $\m{A}+\m{A}\tr$
+can cause AMD to spend significant time
+in ordering the matrix.  If {\tt Control[AMD\_DENSE]} $\ge 0$,
+rows/columns with
+more than {\tt Control[AMD\_DENSE]} $\sqrt{n}$ entries are ignored during
+the ordering, and placed last in the output order.  The default
+value of {\tt Control[AMD\_DENSE]} is 10.  If negative, no rows/columns
+are treated as ``dense.''  Rows/columns with 16 or fewer off-diagonal
+entries are never considered ``dense.''
+%
+\item {\tt Control[AMD\_AGGRESSIVE]} (or {\tt Control(2)} in MATLAB):
+controls whether or not to use
+aggressive absorption, in which a prior element is absorbed into the current
+element if it is a subset of the current element, even if it is not
+adjacent to the current pivot element (refer
+to \cite{AmestoyDavisDuff96,AmestoyDavisDuff04}
+for more details).  The default value is nonzero,
+which means that aggressive absorption will be performed.  This nearly always
+leads to a better ordering (because the approximate degrees are more
+accurate) and a lower execution time.  There are cases where it can
+lead to a slightly worse ordering, however.  To turn it off, set
+{\tt Control[AMD\_AGGRESSIVE]} to 0.
+%
+\end{itemize}
+
+Statistics are returned in the {\tt Info} array
+(if {\tt Info} is {\tt NULL}, then no statistics are returned).
+Refer to {\tt amd.h} file, for more details
+(14 different statistics are returned, so the list is not included here).
+
+%------------------------------------------------------------------------------
+\subsection{Sample C program}
+%------------------------------------------------------------------------------
+
+The following program, {\tt amd\_demo.c}, illustrates the basic use of AMD.
+See Section~\ref{Synopsis} for a short description
+of each calling sequence.
+
+{\footnotesize
+\begin{verbatim}
+#include <stdio.h>
+#include "amd.h"
+
+int n = 5 ;
+int Ap [ ] = { 0,   2,       6,       10,  12, 14} ;
+int Ai [ ] = { 0,1, 0,1,2,4, 1,2,3,4, 2,3, 1,4   } ;
+int P [5] ;
+
+int main (void)
+{
+    int k ;
+    (void) amd_order (n, Ap, Ai, P, (double *) NULL, (double *) NULL) ;
+    for (k = 0 ; k < n ; k++) printf ("P [%d] = %d\n", k, P [k]) ;
+    return (0) ;
+}
+\end{verbatim}
+}
+
+The {\tt Ap} and {\tt Ai} arrays represent the binary matrix
+\[
+\m{A} = \left[
+\begin{array}{rrrrr}
+ 1 &  1 &  0 &  0 &  0 \\
+ 1 &  1 &  1 &  0 &  1 \\
+ 0 &  1 &  1 &  1 &  0 \\
+ 0 &  0 &  1 &  1 &  0 \\
+ 0 &  1 &  1 &  0 &  1 \\
+\end{array}
+\right].
+\]
+The diagonal entries are ignored.
+%
+AMD constructs the pattern of $\m{A}+\m{A}\tr$,
+and returns a permutation vector of $(0, 3, 1, 4, 2)$.
+%
+Since the matrix is unsymmetric but with a mostly symmetric nonzero
+pattern, this would be a suitable permutation for an LU factorization of a
+matrix with this nonzero pattern and whose diagonal entries are not too small.
+The program uses default control settings and does not return any statistics
+about the ordering, factorization, or solution ({\tt Control} and {\tt Info}
+are both {\tt (double *) NULL}).  It also ignores the status value returned by
+{\tt amd\_order}.
+
+More example programs are included with the AMD package.
+The {\tt amd\_demo.c} program provides a more detailed demo of AMD.
+Another example is the AMD mexFunction, {\tt amd\_mex.c}.
+
+%------------------------------------------------------------------------------
+\subsection{A note about zero-sized arrays}
+%------------------------------------------------------------------------------
+
+AMD uses several user-provided arrays of size {\tt n} or {\tt nz}.
+Either {\tt n} or {\tt nz} can be zero.
+If you attempt to {\tt malloc} an array of size zero,
+however, {\tt malloc} will return a null pointer which AMD will report
+as invalid.  If you {\tt malloc} an array of
+size {\tt n} or {\tt nz} to pass to AMD, make sure that you handle the
+{\tt n} = 0 and {\tt nz = 0} cases correctly.
+
+%------------------------------------------------------------------------------
+\section{Synopsis of C-callable routines}
+\label{Synopsis}
+%------------------------------------------------------------------------------
+
+The matrix $\m{A}$ is {\tt n}-by-{\tt n} with {\tt nz} entries.
+
+{\footnotesize
+\begin{verbatim}
+#include "amd.h"
+int n, status, Ap [n+1], Ai [nz], P [n] ;
+double Control [AMD_CONTROL], Info [AMD_INFO] ;
+amd_defaults (Control) ;
+status = amd_order (n, Ap, Ai, P, Control, Info) ;
+amd_control (Control) ;
+amd_info (Info) ;
+status = amd_valid (n, n, Ap, Ai) ;
+\end{verbatim}
+}
+
+The {\tt amd\_l\_*} routines are identical, except that all {\tt int}
+arguments become {\tt long}:
+
+{\footnotesize
+\begin{verbatim}
+#include "amd.h"
+long n, status, Ap [n+1], Ai [nz], P [n] ;
+double Control [AMD_CONTROL], Info [AMD_INFO] ;
+amd_l_defaults (Control) ;
+status = amd_l_order (n, Ap, Ai, P, Control, Info) ;
+amd_l_control (Control) ;
+amd_l_info (Info) ;
+status = amd_l_valid (n, n, Ap, Ai) ;
+\end{verbatim}
+}
+
+%------------------------------------------------------------------------------
+\section{Using AMD in a Fortran program}
+%------------------------------------------------------------------------------
+
+Two Fortran versions of AMD are provided.  The {\tt AMD} routine computes the
+approximate minimum degree ordering, using aggressive absorption.  The
+{\tt AMDBAR} routine is identical, except that it does not perform aggressive
+absorption.  The {\tt AMD} routine is essentially identical to the HSL
+routine {\tt MC47B/BD}.
+Note that earlier versions of the Fortran
+{\tt AMD} and {\tt AMDBAR} routines included an {\tt IOVFLO} argument,
+which is no longer present.
+
+In contrast to the C version, the Fortran routines require a symmetric
+nonzero pattern, with no diagonal entries present although the {\tt MC47A/AD}
+wrapper in HSL allows duplicates, ignores out-of-range entries, and only
+uses entries from the upper triangular part of the matrix.  Although we
+have an experimental Fortran code for treating ``dense'' rows, the Fortran
+codes in this release do not treat
+``dense'' rows and columns of $\m{A}$ differently, and thus their run time
+can be high if there are a few dense rows and columns in the matrix.
+They do not perform a post-ordering of the elimination tree,
+compute statistics on the ordering, or check the validity of their input
+arguments. These facilities are provided by {\tt MC47A/AD} and other
+subroutines from HSL.
+Only one {\tt integer}
+version of each Fortran routine is provided.  
+Both Fortran routines overwrite the user's input
+matrix, in contrast to the C version.  
+%
+The C version does not return the elimination or assembly tree.
+The Fortran version returns an assembly tree;
+refer to the User Guide for details.
+The following is the syntax of the {\tt AMD} Fortran routine.
+The {\tt AMDBAR} routine is identical except for the routine name.
+
+{\footnotesize
+\begin{verbatim}
+        INTEGER N, IWLEN, PFREE, NCMPA, IW (IWLEN), PE (N), DEGREE (N), NV (N),
+     $          NEXT (N), LAST (N), HEAD (N), ELEN (N), W (N), LEN (N)
+        CALL AMD (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT,
+     $          LAST, HEAD, ELEN, DEGREE, NCMPA, W)
+        CALL AMDBAR (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT,
+     $          LAST, HEAD, ELEN, DEGREE, NCMPA, W)
+\end{verbatim}
+}
+
+The input matrix is provided to {\tt AMD} and {\tt AMDBAR}
+in three arrays, {\tt PE}, of size {\tt N},
+{\tt LEN}, of size {\tt N}, and {\tt IW}, of size {\tt IWLEN}.  The size of
+{\tt IW} must be at least {\tt NZ+N}.  The recommended size is
+{\tt 1.2*NZ + N}.
+On input, the indices of nonzero entries in row {\tt I} are stored in {\tt IW}.
+{\tt PE(I)} is the index in {\tt IW} of the start of row {\tt I}.
+{\tt LEN(I)} is the number of entries in row {\tt I}.
+The matrix is 1-based, with row and column indices in the range 1 to {\tt N}.
+Row {\tt I} is contained in
+{\tt IW (PE(I)} $\ldots \:$ {\tt PE(I) + LEN(I) - 1)}.
+The diagonal entries must not be present.  The indices within each row must
+not contain any duplicates, but they need not be sorted.  The rows
+themselves need not be in any particular order, and there may be empty space
+between the rows.  If {\tt LEN(I)} is zero, then there are no off-diagonal
+entries in row {\tt I}, and {\tt PE(I)} is ignored.  The integer
+{\tt PFREE} defines what part of {\tt IW} contains the user's input matrix,
+which is held in {\tt IW(1}~$\ldots~\:${\tt PFREE-1)}.
+The contents of {\tt IW} and {\tt LEN} are undefined on output,
+and {\tt PE} is modified to contain information about the ordering.
+
+As the algorithm proceeds, it modifies the {\tt IW} array, placing the
+pattern of the partially eliminated matrix in
+{\tt IW(PFREE} $\ldots \:${\tt IWLEN)}.
+If this space is exhausted, the space is compressed.
+The number of compressions performed on the {\tt IW} array is
+returned in the scalar {\tt NCMPA}.  The value of {\tt PFREE} on output is the
+length of {\tt IW} required for no compressions to be needed.
+
+The output permutation is returned in the array {\tt LAST}, of size {\tt N}.
+If {\tt I=LAST(K)}, then {\tt I} is the {\tt K}th row in the permuted
+matrix.  The inverse permutation is returned in the array {\tt ELEN}, where
+{\tt K=ELEN(I)} if {\tt I} is the {\tt K}th row in the permuted matrix.
+On output, the {\tt PE} and {\tt NV} arrays hold the assembly tree,
+a supernodal elimination tree that represents the relationship between
+columns of the Cholesky factor $\m{L}$.
+If {\tt NV(I)} $> 0$, then {\tt I} is a node in the assembly
+tree, and the parent of {\tt I} is {\tt -PE(I)}.  If {\tt I} is a root of
+the tree, then {\tt PE(I)} is zero.  The value of {\tt NV(I)} is the
+number of entries in the corresponding column of $\m{L}$, including the
+diagonal.
+If {\tt NV(I)} is zero, then {\tt I} is a non-principal node that is
+not in the assembly tree.  Node {\tt -PE(I)} is the parent of node {\tt I}
+in a subtree, the root of which is a node in the assembly tree.  All nodes
+in one subtree belong to the same supernode in the assembly tree.
+The other size {\tt N} arrays
+({\tt DEGREE}, {\tt HEAD}, {\tt NEXT}, and {\tt W}) are used as workspace,
+and are not defined on input or output.
+
+If you want to use a simpler user-interface and compute the elimination
+tree post-ordering, you should be able to call the C routines {\tt amd\_order}
+or {\tt amd\_l\_order} from a Fortran program.   Just be sure to take into
+account the 0-based indexing in the {\tt P}, {\tt Ap}, and {\tt Ai} arguments
+to {\tt amd\_order} and {\tt amd\_l\_order}.  A sample interface is provided
+in the files {\tt AMD/Demo/amd\_f77cross.f} and
+{\tt AMD/Demo/amd\_f77wrapper.c}.  To compile the {\tt amd\_f77cross} program,
+type {\tt make cross} in the {\tt AMD/Demo} directory.  The
+Fortran-to-C calling conventions are highly non-portable, so this example
+is not guaranteed to work with your compiler C and Fortran compilers.
+The output of {\tt amd\_f77cross} is in {\tt amd\_f77cross.out}.
+
+%------------------------------------------------------------------------------
+\section{Sample Fortran main program}
+%------------------------------------------------------------------------------
+
+The following program illustrates the basic usage of the Fortran version of AMD.
+The {\tt AP} and {\tt AI} arrays represent the binary matrix
+\[
+\m{A} = \left[
+\begin{array}{rrrrr}
+ 1 &  1 &  0 &  0 &  0 \\
+ 1 &  1 &  1 &  0 &  1 \\
+ 0 &  1 &  1 &  1 &  1 \\
+ 0 &  0 &  1 &  1 &  0 \\
+ 0 &  1 &  1 &  0 &  1 \\
+\end{array}
+\right]
+\]
+in a conventional 1-based column-oriented form,
+except that the diagonal entries are not present.
+The matrix has the same as nonzero pattern of $\m{A}+\m{A}\tr$ in the C
+program, in Section~\ref{Cversion}.
+The output permutation is $(4, 1, 3, 5, 2)$.
+It differs from the permutation returned by the C routine {\tt amd\_order}
+because a post-order of the elimination tree has not yet been performed.
+
+{\footnotesize
+\begin{verbatim}
+        INTEGER N, NZ, J, K, P, IWLEN, PFREE, NCMPA
+        PARAMETER (N = 5, NZ = 10, IWLEN = 17)
+        INTEGER AP (N+1), AI (NZ), LAST (N), PE (N), LEN (N), ELEN (N),
+     $      IW (IWLEN), DEGREE (N), NV (N), NEXT (N), HEAD (N), W (N)
+        DATA AP / 1, 2,     5,     8,  9,  11/
+        DATA AI / 2, 1,3,5, 2,4,5, 3,  2,3   /
+C       load the matrix into the AMD workspace
+        DO 10 J = 1,N
+            PE (J) = AP (J)
+            LEN (J) = AP (J+1) - AP (J)
+10      CONTINUE
+        DO 20 P = 1,NZ
+            IW (P) = AI (P)
+20      CONTINUE
+        PFREE = NZ + 1
+C       order the matrix (destroys the copy of A in IW, PE, and LEN)
+        CALL AMD (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT, LAST, HEAD,
+     $      ELEN, DEGREE, NCMPA, W)
+        DO 60 K = 1, N
+            PRINT 50, K, LAST (K)
+50          FORMAT ('P (',I2,') = ', I2)
+60      CONTINUE
+        END
+\end{verbatim}
+}
+
+The {\tt Demo} directory contains an example of how the C version
+may be called from a Fortran program, but this is highly non-portable.
+For this reason, it is placed in the {\tt Demo} directory, not in the
+primary {\tt Source} directory.
+
+%------------------------------------------------------------------------------
+\section{Installation}
+\label{Install}
+%------------------------------------------------------------------------------
+
+The following discussion assumes you have the {\tt make} program, either in
+Unix, or in Windows with Cygwin.
+
+System-dependent configurations are in the
+{\tt ../SuiteSparse\_config/SuiteSparse\_config.mk}
+file.  You can edit that file to customize the compilation.  The default
+settings will work on most systems.
+Sample configuration files are provided
+for Mac, Linux, Sun Solaris, and IBM AIX.
+The system you are on is detected automatically.
+
+To compile and install the C-callable AMD library,
+go to the {\tt AMD} directory and type {\tt make}.
+A dynamic library is placed in
+in {\tt AMD/Lib/libamd.so.*}, ({\tt *.dylib} for the Mac).
+Three demo programs of the AMD ordering routine will be compiled and tested in
+the {\tt AMD/Demo} directory.
+The outputs of these demo programs will then be compared with output
+files in the distribution.
+
+To compile and install the Fortran-callable AMD library,
+go to the {\tt AMD} directory and type {\tt make fortran}.
+The library will be placed in {\tt AMD/Lib/libamdf77.a}.
+A demo program will be compiled and tested in the {\tt AMD/Demo} directory.
+The output will be compared with an output file in the distribution.
+
+Typing {\tt make clean} will remove all but the final compiled libraries
+and demo programs.  Typing {\tt make purge} or {\tt make distclean}
+removes all files not in the original distribution.
+If you compile AMD and then later change the
+{\tt ../SuiteSparse\_config/SuiteSparse\_config.mk} file
+then you should type {\tt make purge} and then {\tt make} to recompile.
+
+When you compile your program that uses the C-callable AMD library,
+you need to add the {\tt AMD/Lib/libamd.*} library
+and you need to tell your compiler to look in the
+{\tt AMD/Include} directory for include
+files.   To compile a Fortran program that calls the Fortran AMD library,
+you need to add the {\tt AMD/Lib/libamdf77.a} library.
+See {\tt AMD/Demo/Makefile} for an example.
+
+By doing {\tt make}, all compiled dynamic libraries are also copied into {\tt
+SuiteSparse/lib} the include files are coped into {\tt SuiteSparse/include},
+and documentation is copied into {\tt SuiteSparse/doc}.
+
+Alternatively, you can install the shared library
+and include files in /usr/local/lib and /usr/local/include, and
+the documenation in /usr/local/doc.
+Just do {\tt make} then {\tt make install}.
+Now you can simply use {\tt -lamd} when you compile your own program.
+
+If all you want to use is the AMD2 mexFunction in MATLAB, you can skip
+the use of the {\tt make} command entirely.  Simply type
+{\tt amd\_make} in MATLAB while in the {\tt AMD/MATLAB} directory.
+This works on any system with MATLAB, including Windows.
+Alternately, type {\tt make} in the {\tt AMD/MATLAB} directory,
+or just use the built-in {\tt amd} in MATLAB 7.3 or later.
+
+If you are including AMD as a subset of a larger library and do not want
+to link the C standard I/O library, or if you simply do not need to use
+them, you can safely remove the {\tt amd\_control.c} and {\tt amd\_info.c}
+files.  Similarly, if you use default parameters (or define your
+own {\tt Control} array), then you can exclude the {\tt amd\_defaults.c}
+file.
+Each of these files contains the user-callable routines of the same
+name.  None of these auxiliary routines are directly called by
+{\tt amd\_order}.
+The {\tt amd\_dump.c} file contains debugging routines
+that are neither used nor compiled unless debugging is enabled.
+The {\tt amd\_internal.h} file must be edited to enable debugging;
+refer to the instructions in that file.
+The bare minimum files required to use just {\tt amd\_order} are
+{\tt amd.h} and {\tt amd\_internal.h}
+in the {\tt Include} directory,
+and
+{\tt amd\_1.c},
+{\tt amd\_2.c},
+{\tt amd\_aat.c},
+{\tt amd\_global.c},
+{\tt and\_order.c},
+{\tt amd\_postorder.c},
+{\tt amd\_post\_tree.c},
+{\tt amd\_preprocess.c},
+and
+{\tt amd\_valid.c}
+in the {\tt Source} directory.
+
+%------------------------------------------------------------------------------
+\newpage
+\section{The AMD routines}
+\label{Primary}
+%------------------------------------------------------------------------------
+
+The file {\tt AMD/Include/amd.h} listed below
+describes each user-callable routine in the C version of AMD,
+and gives details on their use.
+
+{\footnotesize
+\input{amd_h.tex}
+}
+
+
+%------------------------------------------------------------------------------
+\newpage
+% References
+%------------------------------------------------------------------------------
+
+\bibliographystyle{plain}
+\bibliography{AMD_UserGuide}
+
+\end{document}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/ChangeLog b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/ChangeLog
new file mode 100644
index 0000000000000000000000000000000000000000..27868a7b65272068d73f528813f36c7931e15c8c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/ChangeLog
@@ -0,0 +1,180 @@
+May 4, 2016: version 2.4.6
+
+    * minor changes to Makefile
+
+Apr 1, 2016: version 2.4.5
+
+    * licensing simplified (no other change); refer to AMD/Doc/License.txt
+
+Feb 1, 2016: version 2.4.4
+
+    * update to Makefiles
+
+Jan 30, 2016: version 2.4.3
+
+    * modifications to Makefiles
+
+Jan 1, 2016: version 2.4.2
+
+    * modified Makefile to create shared libraries
+        No change to C code except version number
+
+Oct 10, 2014: version 2.4.1
+
+    modified MATLAB/amd_make.m.  No change to C code except version number.
+
+July 31, 2013: version 2.4.0
+
+    * changed malloc and printf pointers to use SuiteSparse_config
+
+Jun 20, 2012: verison 2.3.1
+
+    * minor update for Windows (removed filesep)
+
+Jun 1, 2012: version 2.3.0
+
+    * changed from UFconfig to SuiteSparse_config
+
+May 15, 2012: version 2.2.4
+
+    * minor fix to SIZE_T_MAX definition (finicky compiler workaround)
+
+Dec 7, 2011: version 2.2.3
+
+    * fixed the Makefile to better align with CFLAGS and other standards
+
+Jan 25, 2011: version 2.2.2
+
+    * minor fix to "make install"
+
+Nov 30, 2009: version 2.2.1
+
+    * added "make install" and "make uninstall"
+
+May 31, 2007: version 2.2.0
+
+    * port to 64-bit MATLAB
+
+    * Makefile moved from Source/ to Lib/
+
+    * minor changes to printing routines (amd_control.c, amd_info.c)
+
+Dec 12, 2006, version 2.0.4
+
+    * minor MATLAB code cleanup
+
+Nov 29, 2006, version 2.0.3
+
+    * changed MATLAB function name to amd2, so as not to conflict with
+	the now built-in version of AMD in MATLAB (which is the same thing
+	as the AMD here...).
+
+Sept 28, 2006, version 2.0.2
+
+    * #define SIZE_T_MAX not done if already defined (Mac OSX).
+
+Aug 31, 2006:
+
+    * trivial change to comments in amd.m
+
+Apr 30, 2006: AMD Version 2.0:
+
+    * long integer redefined as UF_long, controlled by UFconfig.h.
+
+    * amd_order no longer requires its input to have sorted columns.  It can
+	also tolerate duplicate entries in each column.  If these conditions
+	hold, but the matrix is otherwise valid, amd_order returns
+	AMD_OK_BUT_JUMBLED (a warning, not an error).
+
+    * amd_preprocess no longer deemed user-callable, since it is no longer
+	needed (it was used to ensure the input matrix had sorted columns with
+	no duplicate entries).  It still exists, with additional parameters,
+	and is called by amd_order if necessary.  amd_wpreprocess and
+	amd_preprocess_valid removed.  Fortran interface routine amdpreproc
+	removed.
+
+    * Integer overflow computations modified, to extend the size of problem
+	that the "int" version can solve when used in an LP64 compilation.
+
+    * amd_demo2.c simplified (it tests AMD with a jumbled matrix).
+
+    * amd_valid returned TRUE/FALSE in v1.2.  It now returns AMD_OK,
+	AMD_OK_BUT_JUMBLED, or AMD_INVALID.  Only in the latter case is the
+	matrix unsuitable as input to amd_order.
+
+    * amd_internal.h include file moved from AMD/Source to AMD/Include.
+
+Nov 15, 2005:
+
+    * minor editting of comments; version number (1.2) unchanged.
+
+Aug. 30, 2005: AMD Version 1.2
+
+    * AMD v1.2 is upward compatible with v1.1 and v1.0, except that v1.2 no
+	longer includes the compile-time redefinition of malloc and free.
+
+    * Makefile modified to use UFconfig.mk.  "Make" directory removed.
+
+    * Easier inclusion in C++ programs.
+
+    * option to allow compile-time redefinition of malloc and free
+	(added to v1.1) removed for v1.2.  Replaced with a run-time
+	redefinition.  AMD includes function pointers for malloc, free,
+	calloc, realloc, and printf, so that all those routines can be
+	redefined at compile time.  These function pointers are global
+	variables, and so are not technically thread-safe, unless you
+	use defaults and don't need to change them (the common case)
+	or if you change them in one thread before using them in other
+	threads.
+
+    * added #define'd version number
+
+    * minor modification to AMD_2 to ensure all lines can be tested, without
+	conditional compilation.
+
+    * moved the prototype for AMD_2 from amd_internal.h to amd.h
+
+    * moved the prototype for AMD_valid from amd_internal.h to amd.h
+
+    * MATLAB mexFunction uses libamd.a (compiled with cc) instead of compiling
+	each AMD source file with the mex command
+
+    * long demo (amd_l_demo.c) added.
+
+Jan. 21, 2004: AMD Version 1.1
+
+    * No bugs found or fixed - new features added, only
+    * amd_preprocess added, to allow for more general input of the matrix A.
+    * ME=0 added to amd*.f, unused DEXT variable removed from amdbar.f,
+	to avoid spurious compiler warnings (this was not a bug).
+    * amd_demo2.c and amd_demo2.out added, to test/demo amd_preprocess.
+    * option to allow compile-time redefinition of malloc, free, printf added
+    * amd_demo.c shortened slightly (removed printing of PAP')
+    * User Guide modified (more details added)
+    * linewidth reduced from 80 to 79 columns
+
+Oct. 7, 2003:  AMD version 1.0.1.
+
+    * MATLAB mexFunction modified, to remove call to mexCallMATLAB function.
+      This function can take a long time to call, particularly if you are
+      ordering many small matrices.
+
+May 6, 2003:  AMD Version 1.0 released.
+
+    * converted to C (compare amd.f and amdbar.f with amd_2.c)
+    * dense rows/column removed prior to ordering
+    * elimination tree post-ordering added
+    * demos, user guide written
+    * statistics added (nz in L, flop count, symmetry of A)
+    * computes the pattern of A+A' if A is unsymmetric
+    * user's input matrix no longer overwritten
+    * degree lists initialized differently
+    * IOVFLO argument removed from Fortran versions (amd.f and amdbar.f)
+    * parameters added (dense row/column detection, aggressive absorption)
+    * MATLAB mexFunction added
+
+Jan, 1996:
+
+    * amdbar.f posted at http://www.netlib.org (with a restricted License)
+    * amd.f appears as MC47B/BD in the Harwell Subroutine Library
+	(without the IOVFLO argument)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/License.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..05f154c83613d37d6f2e8fa25915ecacc48e255a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/License.txt
@@ -0,0 +1,91 @@
+AMD, Copyright (c), 1996-2015, Timothy A. Davis,
+Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+
+AMD License: At the user's option, you may use AMD under either the LGPL
+version 2.1 license, or the BSD 3-clause license.  You may not use both
+licenses, nor may you mix-and-match clauses from each license.  To use a
+license, in the documentation for your application simply state either of the
+following, replacing <YOUR APPLICATION> with the name of your application:
+
+    AMD, Copyright (c), 1996-2015, Timothy A. Davis,
+    Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+    Used in <YOUR APPLICATION> under the BSD 3-clause license.
+
+or
+
+    AMD, Copyright (c), 1996-2015, Timothy A. Davis,
+    Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+    Used in <YOUR APPLICATION> under the LGPL v2.1 license.
+
+In the event that your package <A> includes another package <B> by another
+author, and <A> and <B> use AMD under different licenses, you may select
+one license to apply to both uses of AMD in the combined application.
+
+Availability:
+
+    http://www.suitesparse.com
+
+-------------------------------------------------------------------------------
+BSD 3-clause:
+-------------------------------------------------------------------------------
+
+    Copyright (c), 1996-2015, Timothy A. Davis,
+    Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of the organizations to which the authors are
+          affiliated, nor the names of its contributors may be used to endorse
+          or promote products derived from this software without specific prior
+          written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+    DAMAGE.
+
+-------------------------------------------------------------------------------
+LGPL version 2.1:
+-------------------------------------------------------------------------------
+
+    Your use or distribution of AMD or any modified version of
+    AMD implies that you agree to this License.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+    USA
+
+    Permission is hereby granted to use or copy this program under the
+    terms of the GNU LGPL, provided that the Copyright, this License,
+    and the Availability of the original version is retained on all copies.
+    User documentation of any code that uses this code or any modified
+    version of this code must cite the Copyright, this License, the
+    Availability note, and "Used by permission." Permission to modify
+    the code and to distribute modified code is granted, provided the
+    Copyright, this License, and the Availability note are retained,
+    and a notice that the code was modified is included.
+
+-------------------------------------------------------------------------------
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/lesser.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/lesser.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8add30ad590a65db7e5914f5417eac39a64402a3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Doc/lesser.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/Contents.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..c9c5eec4e7822ec605408e84b3086a46e4b9bd8e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/Contents.m
@@ -0,0 +1,18 @@
+%Contents of the AMD sparse matrix ordering package:
+%
+% amd2          - p = amd2 (A), the approximate minimum degree ordering of A
+% amd_demo      - a demo of amd2, using the can_24 matrix
+% amd_make      - to compile amd2 for use in MATLAB
+% amd_install   - compile and install amd2 for use in MATLAB
+%
+% See also:  amd, amd2, colamd, symamd, colmmd, symmmd, umfpack
+%
+% Note that amd2 and the built-in amd function in MATLAB 7.3 and later are one
+% and the same.
+%
+% Example:
+%   p = amd2 (A) ;
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, and Iain S. Duff. 
+
+help Contents
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd2.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd2.m
new file mode 100644
index 0000000000000000000000000000000000000000..60e09d5e55ec01f77e8f7d73ff18b36dd96e36b9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd2.m
@@ -0,0 +1,72 @@
+function [p, Info] = amd2 (A, Control)					    %#ok
+%AMD2 p = amd2 (A), the approximate minimum degree ordering of A
+%    P = AMD2 (S) returns the approximate minimum degree permutation vector for
+%    the sparse matrix C = S+S'.  The Cholesky factorization of C (P,P), or
+%    S (P,P), tends to be sparser than that of C or S.  AMD tends to be faster
+%    than SYMMMD and SYMAMD, and tends to return better orderings than SYMMMD.
+%    S must be square. If S is full, amd(S) is equivalent to amd(sparse(S)).
+%
+%    Note that the built-in AMD routine in MATLAB is identical to AMD2,
+%    except that AMD in MATLAB allows for a struct input to set the parameters.
+%
+%    Usage:  P = amd2 (S) ;                  % finds the ordering
+%            [P, Info] = amd2 (S, Control) ; % optional parameters & statistics
+%            Control = amd2 ;                % returns default parameters
+%            amd2 ;                          % prints default parameters.
+%
+%       Control (1); If S is n-by-n, then rows/columns with more than
+%           max (16, (Control (1))* sqrt(n)) entries in S+S' are considered
+%           "dense", and ignored during ordering.  They are placed last in the
+%           output permutation.  The default is 10.0 if Control is not present.
+%       Control (2): If nonzero, then aggressive absorption is performed.
+%           This is the default if Control is not present.
+%       Control (3): If nonzero, print statistics about the ordering.
+%
+%       Info (1): status (0: ok, -1: out of memory, -2: matrix invalid)
+%       Info (2): n = size (A,1)
+%       Info (3): nnz (A)
+%       Info (4): the symmetry of the matrix S (0.0 means purely unsymmetric,
+%           1.0 means purely symmetric).  Computed as:
+%           B = tril (S, -1) + triu (S, 1) ; symmetry = nnz (B & B') / nnz (B);
+%       Info (5): nnz (diag (S))
+%       Info (6): nnz in S+S', excluding the diagonal (= nnz (B+B'))
+%       Info (7): number "dense" rows/columns in S+S'
+%       Info (8): the amount of memory used by AMD, in bytes
+%       Info (9): the number of memory compactions performed by AMD
+%
+%    The following statistics are slight upper bounds because of the
+%    approximate degree in AMD.  The bounds are looser if "dense" rows/columns
+%    are ignored during ordering (Info (7) > 0).  The statistics are for a
+%    subsequent factorization of the matrix C (P,P).  The LU factorization
+%    statistics assume no pivoting.
+%
+%       Info (10): the number of nonzeros in L, excluding the diagonal
+%       Info (11): the number of divide operations for LL', LDL', or LU
+%       Info (12): the number of multiply-subtract pairs for LL' or LDL'
+%       Info (13): the number of multiply-subtract pairs for LU
+%       Info (14): the max # of nonzeros in any column of L (incl. diagonal)
+%       Info (15:20): unused, reserved for future use
+%
+%    An assembly tree post-ordering is performed, which is typically the same
+%    as an elimination tree post-ordering.  It is not always identical because
+%    of the approximate degree update used, and because "dense" rows/columns
+%    do not take part in the post-order.  It well-suited for a subsequent
+%    "chol", however.  If you require a precise elimination tree post-ordering,
+%    then see the example below:
+%
+% Example:
+%
+%       P = amd2 (S) ;
+%       C = spones (S) + spones (S') ;  % skip this if S already symmetric
+%       [ignore, Q] = etree (C (P,P)) ;
+%       P = P (Q) ;
+%
+% See also AMD, COLMMD, COLAMD, COLPERM, SYMAMD, SYMMMD, SYMRCM.
+
+% Copyright 1994-2012, Timothy A. Davis, http://www.suitesparse.com,
+% Patrick R. Amestoy, and Iain S. Duff.  See ../README.txt for License.
+%
+%    Acknowledgements: This work was supported by the National Science
+%       Foundation, under grants ASC-9111263, DMS-9223088, and CCR-0203270.
+
+error ('amd2 mexFunction not found') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_demo.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_demo.m
new file mode 100644
index 0000000000000000000000000000000000000000..06deba22121adeac7318ded869ebafb1676e4a6b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_demo.m
@@ -0,0 +1,80 @@
+function amd_demo
+%AMD_DEMO a demo of amd2, using the can_24 matrix
+%
+% A demo of AMD for MATLAB.
+%
+% Example:
+%   amd_demo
+%
+% See also: amd, amd2, amd_make
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, and Iain S. Duff. 
+
+% This orders the same matrix as the ANSI C demo, amd_demo.c.  It includes an
+% additional analysis of the matrix via MATLAB's symbfact routine.
+
+% First, print the help information for AMD
+help amd2
+
+% Get the Harwell/Boeing can_24 matrix.
+
+load can_24
+A = spconvert (can_24) ;
+
+n = size (A,1) ;
+
+clf
+subplot (2,2,1) ;
+spy (A)
+title ('HB/can24 matrix') ;
+
+% order the matrix.  Note that the Info argument is optional.
+fprintf ('\nIf the next step fails, then you have\n') ;
+fprintf ('not yet compiled the AMD mexFunction.\n') ;
+[p, Info] = amd2 (A) ;		%#ok
+
+% order again, but this time print some statistics
+[p, Info] = amd2 (A, [10 1 1]) ;
+
+fprintf ('Permutation vector:\n') ;
+fprintf (' %2d', p) ;
+fprintf ('\n\n') ;
+
+subplot (2,2,2) ;
+spy (A (p,p)) ;
+title ('Permuted matrix') ;
+
+% The amd_demo.c program stops here.
+
+fprintf ('Analyze A(p,p) with MATLAB''s symbfact routine:\n') ;
+[cn, height, parent, post, R] = symbfact (A (p,p)) ;
+
+subplot (2,2,3) ;
+spy (R') ; 
+title ('Cholesky factor, L') ;
+
+subplot (2,2,4) ;
+treeplot (parent) ;
+title ('elimination tree') ;
+
+% results from symbfact
+lnz = sum (cn) ;                % number of nonzeros in L, incl. diagonal
+cn = cn - 1 ;                   % get the count of off-diagonal entries
+fl = n + sum (cn.^2 + 2*cn) ;   % flop count for chol (A (p,p)
+fprintf ('number of nonzeros in L (including diagonal):      %d\n', lnz) ;
+fprintf ('floating point operation count for chol (A (p,p)): %d\n', fl) ;
+
+% approximations from amd:
+lnz2 = n + Info (10) ;
+fl2 = n + Info (11) + 2 * Info (12) ;
+fprintf ('\nResults from AMD''s approximate analysis:\n') ;
+fprintf ('number of nonzeros in L (including diagonal):      %d\n', lnz2) ;
+fprintf ('floating point operation count for chol (A (p,p)): %d\n\n', fl2) ;
+
+if (lnz2 ~= lnz | fl ~= fl2)						    %#ok
+    fprintf ('Note that the nonzero and flop counts from AMD are slight\n') ;
+    fprintf ('upper bounds.  This is due to the approximate minimum degree\n');
+    fprintf ('method used, in conjunction with "mass elimination".\n') ;
+    fprintf ('See the discussion about mass elimination in amd.h and\n') ;
+    fprintf ('amd_2.c for more details.\n') ;
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_install.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_install.m
new file mode 100644
index 0000000000000000000000000000000000000000..6b9f3628d9bd10653a3f9540064c76a2a05b00b5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_install.m
@@ -0,0 +1,19 @@
+function amd_install
+%AMD_INSTALL compile and install amd2 for use in MATLAB
+%   Your current directory must be AMD/MATLAB for this function to work.
+%
+% Example:
+%   amd_install
+%
+% See also amd, amd2.
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, and Iain S. Duff. 
+
+% This orders the same matrix as the ANSI C demo, amd_demo.c.  It includes an
+
+amd_make
+addpath (pwd)
+fprintf ('\nThe following path has been added.  You may wish to add it\n') ;
+fprintf ('permanently, using the MATLAB pathtool command.\n') ;
+fprintf ('%s\n\n', pwd) ;
+amd_demo
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_make.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_make.m
new file mode 100644
index 0000000000000000000000000000000000000000..e43ec87b30eb0dc6ea874af26a99ffe6781d50ef
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/amd_make.m
@@ -0,0 +1,43 @@
+function amd_make
+%AMD_MAKE to compile amd2 for use in MATLAB
+%
+% Example:
+%   amd_make
+%
+% See also amd, amd2.
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, and Iain S. Duff. 
+
+details = 0 ;	    % 1 if details of each command are to be printed
+
+d = '' ;
+if (~isempty (strfind (computer, '64')))
+    d = '-largeArrayDims' ;
+end
+
+% MATLAB 8.3.0 now has a -silent option to keep 'mex' from burbling too much
+if (~verLessThan ('matlab', '8.3.0'))
+    d = ['-silent ' d] ;
+end
+
+i = sprintf ('-I../Include -I../../SuiteSparse_config') ;
+cmd = sprintf ('mex -O %s -DDLONG -output amd2 %s amd_mex.c %s', d, i, ...
+    '../../SuiteSparse_config/SuiteSparse_config.c') ;
+files = {'amd_order', 'amd_dump', 'amd_postorder', 'amd_post_tree', ...
+    'amd_aat', 'amd_2', 'amd_1', 'amd_defaults', 'amd_control', ...
+    'amd_info', 'amd_valid', 'amd_preprocess' } ;
+for i = 1 : length (files)
+    cmd = sprintf ('%s ../Source/%s.c', cmd, files {i}) ;
+end
+if (details)
+    fprintf ('%s\n', cmd) ;
+end
+
+if (~(ispc || ismac))
+    % for POSIX timing routine
+    cmd = [cmd ' -lrt'] ;
+end
+
+eval (cmd) ;
+
+fprintf ('AMD successfully compiled.\n') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/can_24 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/can_24
new file mode 100644
index 0000000000000000000000000000000000000000..38158a159a64c761911df18d6b8d2a7fbed5e02d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/MATLAB/can_24
@@ -0,0 +1,160 @@
+ 1  1 1
+ 6  1 1
+ 7  1 1
+13  1 1
+14  1 1
+18  1 1
+19  1 1
+20  1 1
+22  1 1
+ 2  2 1
+ 9  2 1
+10  2 1
+14  2 1
+15  2 1
+18  2 1
+ 3  3 1
+ 7  3 1
+12  3 1
+21  3 1
+22  3 1
+23  3 1
+ 4  4 1
+ 8  4 1
+11  4 1
+16  4 1
+19  4 1
+20  4 1
+ 5  5 1
+ 8  5 1
+10  5 1
+15  5 1
+16  5 1
+17  5 1
+ 1  6 1
+ 6  6 1
+ 7  6 1
+13  6 1
+14  6 1
+18  6 1
+ 1  7 1
+ 3  7 1
+ 6  7 1
+ 7  7 1
+12  7 1
+13  7 1
+20  7 1
+22  7 1
+24  7 1
+ 4  8 1
+ 5  8 1
+ 8  8 1
+10  8 1
+15  8 1
+16  8 1
+17  8 1
+18  8 1
+19  8 1
+ 2  9 1
+ 9  9 1
+10  9 1
+15  9 1
+ 2 10 1
+ 5 10 1
+ 8 10 1
+ 9 10 1
+10 10 1
+14 10 1
+15 10 1
+18 10 1
+19 10 1
+ 4 11 1
+11 11 1
+19 11 1
+20 11 1
+21 11 1
+22 11 1
+ 3 12 1
+ 7 12 1
+12 12 1
+13 12 1
+22 12 1
+24 12 1
+ 1 13 1
+ 6 13 1
+ 7 13 1
+12 13 1
+13 13 1
+24 13 1
+ 1 14 1
+ 2 14 1
+ 6 14 1
+10 14 1
+14 14 1
+18 14 1
+ 2 15 1
+ 5 15 1
+ 8 15 1
+ 9 15 1
+10 15 1
+15 15 1
+ 4 16 1
+ 5 16 1
+ 8 16 1
+16 16 1
+17 16 1
+19 16 1
+ 5 17 1
+ 8 17 1
+16 17 1
+17 17 1
+ 1 18 1
+ 2 18 1
+ 6 18 1
+ 8 18 1
+10 18 1
+14 18 1
+18 18 1
+19 18 1
+20 18 1
+ 1 19 1
+ 4 19 1
+ 8 19 1
+10 19 1
+11 19 1
+16 19 1
+18 19 1
+19 19 1
+20 19 1
+ 1 20 1
+ 4 20 1
+ 7 20 1
+11 20 1
+18 20 1
+19 20 1
+20 20 1
+21 20 1
+22 20 1
+ 3 21 1
+11 21 1
+20 21 1
+21 21 1
+22 21 1
+23 21 1
+ 1 22 1
+ 3 22 1
+ 7 22 1
+11 22 1
+12 22 1
+20 22 1
+21 22 1
+22 22 1
+23 22 1
+ 3 23 1
+21 23 1
+22 23 1
+23 23 1
+ 7 24 1
+12 24 1
+13 24 1
+24 24 1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5aa64c473ccc7e39d9518049d0b52b71c1d2c2de
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/README.txt
@@ -0,0 +1,180 @@
+AMD, Copyright (c) 2009-2013 by Timothy A. Davis (http://www.suitesparse.com),
+Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.  AMD is available
+under alternate licences; contact T. Davis for details.
+
+AMD:  a set of routines for permuting sparse matrices prior to
+    factorization.  Includes a version in C, a version in Fortran, and a MATLAB
+    mexFunction.
+
+Requires SuiteSparse_config, in the ../SuiteSparse_config directory relative to
+this directory.
+
+Quick start (Unix, or Windows with Cygwin):
+
+    To compile, test, and install AMD, you may wish to first configure the
+    installation by editting the ../SuiteSparse_config/SuiteSparse_config.mk
+    file.  Next, cd to this directory (AMD) and type "make" (or "make lib" if
+    you do not have MATLAB).  To compile and run a demo program for the Fortran
+    version, type "make fortran".  When done, type "make clean" to remove
+    unused *.o files (keeps the compiled libraries and demo programs).  See the
+    User Guide (Doc/AMD_UserGuide.pdf), or
+    ../SuiteSparse_config/SuiteSparse_config.mk for more details.
+    To install do "make install"
+
+Quick start (for MATLAB users);
+
+    To compile, test, and install the AMD mexFunction, cd to the
+    AMD/MATLAB directory and type amd_make at the MATLAB prompt.
+
+-------------------------------------------------------------------------------
+
+AMD License:  refer to the AMD/Doc/License.txt file for the license.
+
+Availability:
+
+    http://www.suitesparse.com
+
+-------------------------------------------------------------------------------
+
+This is the AMD README file.  It is a terse overview of AMD.
+Refer to the User Guide (Doc/AMD_UserGuide.pdf) for how to install
+and use AMD.
+
+Description:
+
+    AMD is a set of routines for pre-ordering sparse matrices prior to Cholesky
+    or LU factorization, using the approximate minimum degree ordering
+    algorithm.  Written in ANSI/ISO C with a MATLAB interface, and in
+    Fortran 77.
+
+Authors:
+
+    Timothy A. Davis (DrTimothyAldenDavis@gmail.com)
+    Patrick R. Amestory, ENSEEIHT, Toulouse, France.
+    Iain S. Duff, Rutherford Appleton Laboratory, UK.
+
+Acknowledgements:
+
+    This work was supported by the National Science Foundation, under
+    grants DMS-9504974, DMS-9803599, and CCR-0203270.
+
+    Portions of this work were done while on sabbatical at Stanford University
+    and Lawrence Berkeley National Laboratory (with funding from the SciDAC
+    program).  I would like to thank Gene Golub, Esmond Ng, and Horst Simon
+    for making this sabbatical possible.
+
+-------------------------------------------------------------------------------
+Files and directories in the AMD distribution:
+-------------------------------------------------------------------------------
+
+    ---------------------------------------------------------------------------
+    Subdirectories of the AMD directory:
+    ---------------------------------------------------------------------------
+
+    Doc		documentation
+    Source	primary source code
+    Include	include file for use in your code that calls AMD
+    Demo	demo programs.  also serves as test of the AMD installation.
+    MATLAB	AMD mexFunction for MATLAB, and supporting m-files
+    Lib		where the compiled C-callable and Fortran-callable
+		AMD libraries placed.
+
+    ---------------------------------------------------------------------------
+    Files in the AMD directory:
+    ---------------------------------------------------------------------------
+
+    Makefile	top-level Makefile
+		Windows users would require Cygwin to use "make"
+
+    README.txt	this file
+
+    ---------------------------------------------------------------------------
+    Doc directory: documentation
+    ---------------------------------------------------------------------------
+
+    ChangeLog			change log
+    License.txt			the AMD License
+    Makefile			for creating the documentation
+    AMD_UserGuide.bib		AMD User Guide (references)
+    AMD_UserGuide.tex		AMD User Guide (LaTeX)
+    AMD_UserGuide.pdf		AMD User Guide (PDF)
+
+    ---------------------------------------------------------------------------
+    Source directory:
+    ---------------------------------------------------------------------------
+
+    amd_order.c			user-callable, primary AMD ordering routine
+    amd_control.c		user-callable, prints the control parameters
+    amd_defaults.c		user-callable, sets default control parameters
+    amd_info.c			user-callable, prints the statistics from AMD
+
+    amd_1.c			non-user-callable, construct A+A'
+    amd_2.c			user-callable, primary ordering kernel
+				(a C version of amd.f and amdbar.f, with
+				post-ordering added)
+    amd_aat.c			non-user-callable, computes nnz (A+A')
+    amd_dump.c			non-user-callable, debugging routines
+    amd_postorder.c		non-user-callable, postorder
+    amd_post_tree.c		non-user-callable, postorder just one tree
+    amd_valid.c			non-user-callable, verifies a matrix
+    amd_preprocess.c		non-user-callable, computes A', removes duplic
+
+    amd.f			user-callable Fortran 77 version
+    amdbar.f			user-callable Fortran 77 version
+
+    ---------------------------------------------------------------------------
+    Include directory:
+    ---------------------------------------------------------------------------
+
+    amd.h			include file for C programs that use AMD
+    amd_internal.h		non-user-callable, include file for AMD
+
+    ---------------------------------------------------------------------------
+    Demo directory:
+    ---------------------------------------------------------------------------
+
+    Makefile                    to compile the demos
+    amd_demo.c			C demo program for AMD
+    amd_demo.out		output of amd_demo.c
+
+    amd_demo2.c			C demo program for AMD, jumbled matrix
+    amd_demo2.out		output of amd_demo2.c
+
+    amd_l_demo.c		C demo program for AMD (long integer version)
+    amd_l_demo.out		output of amd_l_demo.c
+
+    amd_simple.c		simple C demo program for AMD
+    amd_simple.out		output of amd_simple.c
+
+    amd_f77demo.f		Fortran 77 demo program for AMD
+    amd_f77demo.out		output of amd_f77demo.f
+
+    amd_f77simple.c		simple Fortran 77 demo program for AMD
+    amd_f77simple.out		output of amd_f77simple.f
+
+    amd_f77cross.f		Fortran 77 demo, calls the C version of AMD
+    amd_f77cross.out		output of amd_f77cross.f
+    amd_f77wrapper.c		Fortran-callable wrapper for C version of AMD
+
+    ---------------------------------------------------------------------------
+    MATLAB directory:
+    ---------------------------------------------------------------------------
+
+    Contents.m			for "help amd2" listing of toolbox contents
+
+    amd2.m			MATLAB help file for AMD
+    amd_make.m			MATLAB m-file for compiling AMD mexFunction
+    amd_install.m		compile and install the AMD mexFunction
+
+    amd_mex.c			AMD mexFunction for MATLAB
+
+    amd_demo.m			MATLAB demo for AMD
+    amd_demo.m.out		diary output of amd_demo.m
+    can_24.mat			input file for AMD demo
+
+    ---------------------------------------------------------------------------
+    Lib directory:  libamd.a and libamd.so library placed here
+    ---------------------------------------------------------------------------
+
+    Makefile			Makefile for both shared and static libraries
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Source/amd.f b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Source/amd.f
new file mode 100644
index 0000000000000000000000000000000000000000..ccfe3e8c9faf3ffb1f0741ee97110e561b21c038
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Source/amd.f
@@ -0,0 +1,1214 @@
+C-----------------------------------------------------------------------
+C AMD:  approximate minimum degree, with aggressive absorption
+C-----------------------------------------------------------------------
+
+        SUBROUTINE AMD
+     $          (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT,
+     $          LAST, HEAD, ELEN, DEGREE, NCMPA, W)
+
+        INTEGER N, IWLEN, PFREE, NCMPA, IW (IWLEN), PE (N),
+     $          DEGREE (N), NV (N), NEXT (N), LAST (N), HEAD (N),
+     $          ELEN (N), W (N), LEN (N)
+
+C Given a representation of the nonzero pattern of a symmetric matrix,
+C       A, (excluding the diagonal) perform an approximate minimum
+C       (UMFPACK/MA38-style) degree ordering to compute a pivot order
+C       such that the introduction of nonzeros (fill-in) in the Cholesky
+C       factors A = LL^T are kept low.  At each step, the pivot
+C       selected is the one with the minimum UMFPACK/MA38-style
+C       upper-bound on the external degree.
+C
+C       Aggresive absorption is used to tighten the bound on the degree.
+
+C **********************************************************************
+C ***** CAUTION:  ARGUMENTS ARE NOT CHECKED FOR ERRORS ON INPUT.  ******
+C **********************************************************************
+
+C       References:
+C
+C       [1] Timothy A. Davis and Iain Duff, "An unsymmetric-pattern
+C           multifrontal method for sparse LU factorization", SIAM J.
+C           Matrix Analysis and Applications, vol. 18, no. 1, pp.
+C           140-158.  Discusses UMFPACK / MA38, which first introduced
+C           the approximate minimum degree used by this routine.
+C
+C       [2] Patrick Amestoy, Timothy A. Davis, and Iain S. Duff, "An
+C           approximate degree ordering algorithm," SIAM J. Matrix
+C           Analysis and Applications, vol. 17, no. 4, pp. 886-905,
+C           1996.  Discusses AMD, AMDBAR, and MC47B.
+C
+C       [3] Alan George and Joseph Liu, "The evolution of the minimum
+C           degree ordering algorithm," SIAM Review, vol. 31, no. 1,
+C           pp. 1-19, 1989.  We list below the features mentioned in
+C           that paper that this code includes:
+C
+C       mass elimination:
+C               Yes.  MA27 relied on supervariable detection for mass
+C               elimination.
+C       indistinguishable nodes:
+C               Yes (we call these "supervariables").  This was also in
+C               the MA27 code - although we modified the method of
+C               detecting them (the previous hash was the true degree,
+C               which we no longer keep track of).  A supervariable is
+C               a set of rows with identical nonzero pattern.  All
+C               variables in a supervariable are eliminated together.
+C               Each supervariable has as its numerical name that of
+C               one of its variables (its principal variable).
+C       quotient graph representation:
+C               Yes.  We use the term "element" for the cliques formed
+C               during elimination.  This was also in the MA27 code.
+C               The algorithm can operate in place, but it will work
+C               more efficiently if given some "elbow room."
+C       element absorption:
+C               Yes.  This was also in the MA27 code.
+C       external degree:
+C               Yes.  The MA27 code was based on the true degree.
+C       incomplete degree update and multiple elimination:
+C               No.  This was not in MA27, either.  Our method of
+C               degree update within MC47B/BD is element-based, not
+C               variable-based.  It is thus not well-suited for use
+C               with incomplete degree update or multiple elimination.
+
+C-----------------------------------------------------------------------
+C Authors, and Copyright (C) 1995 by:
+C       Timothy A. Davis, Patrick Amestoy, Iain S. Duff, & John K. Reid.
+C
+C Acknowledgements:
+C       This work (and the UMFPACK package) was supported by the
+C       National Science Foundation (ASC-9111263 and DMS-9223088).
+C       The UMFPACK/MA38 approximate degree update algorithm, the
+C       unsymmetric analog which forms the basis of MC47B/BD, was
+C       developed while Tim Davis was supported by CERFACS (Toulouse,
+C       France) in a post-doctoral position.
+C
+C Date:  September, 1995
+C-----------------------------------------------------------------------
+
+C-----------------------------------------------------------------------
+C INPUT ARGUMENTS (unaltered):
+C-----------------------------------------------------------------------
+
+C n:    The matrix order.
+C
+C       Restriction:  1 .le. n .lt. (iovflo/2)-2, where iovflo is
+C       the largest positive integer that your computer can represent.
+
+C iwlen:        The length of iw (1..iwlen).  On input, the matrix is
+C       stored in iw (1..pfree-1).  However, iw (1..iwlen) should be
+C       slightly larger than what is required to hold the matrix, at
+C       least iwlen .ge. pfree + n is recommended.  Otherwise,
+C       excessive compressions will take place.
+C       *** We do not recommend running this algorithm with ***
+C       ***      iwlen .lt. pfree + n.                      ***
+C       *** Better performance will be obtained if          ***
+C       ***      iwlen .ge. pfree + n                       ***
+C       *** or better yet                                   ***
+C       ***      iwlen .gt. 1.2 * pfree                     ***
+C       *** (where pfree is its value on input).            ***
+C       The algorithm will not run at all if iwlen .lt. pfree-1.
+C
+C       Restriction: iwlen .ge. pfree-1
+
+C-----------------------------------------------------------------------
+C INPUT/OUPUT ARGUMENTS:
+C-----------------------------------------------------------------------
+
+C pe:   On input, pe (i) is the index in iw of the start of row i, or
+C       zero if row i has no off-diagonal non-zeros.
+C
+C       During execution, it is used for both supervariables and
+C       elements:
+C
+C       * Principal supervariable i:  index into iw of the
+C               description of supervariable i.  A supervariable
+C               represents one or more rows of the matrix
+C               with identical nonzero pattern.
+C       * Non-principal supervariable i:  if i has been absorbed
+C               into another supervariable j, then pe (i) = -j.
+C               That is, j has the same pattern as i.
+C               Note that j might later be absorbed into another
+C               supervariable j2, in which case pe (i) is still -j,
+C               and pe (j) = -j2.
+C       * Unabsorbed element e:  the index into iw of the description
+C               of element e, if e has not yet been absorbed by a
+C               subsequent element.  Element e is created when
+C               the supervariable of the same name is selected as
+C               the pivot.
+C       * Absorbed element e:  if element e is absorbed into element
+C               e2, then pe (e) = -e2.  This occurs when the pattern of
+C               e (that is, Le) is found to be a subset of the pattern
+C               of e2 (that is, Le2).  If element e is "null" (it has
+C               no nonzeros outside its pivot block), then pe (e) = 0.
+C
+C       On output, pe holds the assembly tree/forest, which implicitly
+C       represents a pivot order with identical fill-in as the actual
+C       order (via a depth-first search of the tree).
+C
+C       On output:
+C       If nv (i) .gt. 0, then i represents a node in the assembly tree,
+C       and the parent of i is -pe (i), or zero if i is a root.
+C       If nv (i) = 0, then (i,-pe (i)) represents an edge in a
+C       subtree, the root of which is a node in the assembly tree.
+
+C pfree:        On input the tail end of the array, iw (pfree..iwlen),
+C       is empty, and the matrix is stored in iw (1..pfree-1).
+C       During execution, additional data is placed in iw, and pfree
+C       is modified so that iw (pfree..iwlen) is always the unused part
+C       of iw.  On output, pfree is set equal to the size of iw that
+C       would have been needed for no compressions to occur.  If
+C       ncmpa is zero, then pfree (on output) is less than or equal to
+C       iwlen, and the space iw (pfree+1 ... iwlen) was not used.
+C       Otherwise, pfree (on output) is greater than iwlen, and all the
+C       memory in iw was used.
+
+C-----------------------------------------------------------------------
+C INPUT/MODIFIED (undefined on output):
+C-----------------------------------------------------------------------
+
+C len:  On input, len (i) holds the number of entries in row i of the
+C       matrix, excluding the diagonal.  The contents of len (1..n)
+C       are undefined on output.
+
+C iw:   On input, iw (1..pfree-1) holds the description of each row i
+C       in the matrix.  The matrix must be symmetric, and both upper
+C       and lower triangular parts must be present.  The diagonal must
+C       not be present.  Row i is held as follows:
+C
+C               len (i):  the length of the row i data structure
+C               iw (pe (i) ... pe (i) + len (i) - 1):
+C                       the list of column indices for nonzeros
+C                       in row i (simple supervariables), excluding
+C                       the diagonal.  All supervariables start with
+C                       one row/column each (supervariable i is just
+C                       row i).
+C               if len (i) is zero on input, then pe (i) is ignored
+C               on input.
+C
+C               Note that the rows need not be in any particular order,
+C               and there may be empty space between the rows.
+C
+C       During execution, the supervariable i experiences fill-in.
+C       This is represented by placing in i a list of the elements
+C       that cause fill-in in supervariable i:
+C
+C               len (i):  the length of supervariable i
+C               iw (pe (i) ... pe (i) + elen (i) - 1):
+C                       the list of elements that contain i.  This list
+C                       is kept short by removing absorbed elements.
+C               iw (pe (i) + elen (i) ... pe (i) + len (i) - 1):
+C                       the list of supervariables in i.  This list
+C                       is kept short by removing nonprincipal
+C                       variables, and any entry j that is also
+C                       contained in at least one of the elements
+C                       (j in Le) in the list for i (e in row i).
+C
+C       When supervariable i is selected as pivot, we create an
+C       element e of the same name (e=i):
+C
+C               len (e):  the length of element e
+C               iw (pe (e) ... pe (e) + len (e) - 1):
+C                       the list of supervariables in element e.
+C
+C       An element represents the fill-in that occurs when supervariable
+C       i is selected as pivot (which represents the selection of row i
+C       and all non-principal variables whose principal variable is i).
+C       We use the term Le to denote the set of all supervariables
+C       in element e.  Absorbed supervariables and elements are pruned
+C       from these lists when computationally convenient.
+C
+C       CAUTION:  THE INPUT MATRIX IS OVERWRITTEN DURING COMPUTATION.
+C       The contents of iw are undefined on output.
+
+C-----------------------------------------------------------------------
+C OUTPUT (need not be set on input):
+C-----------------------------------------------------------------------
+
+C nv:   During execution, abs (nv (i)) is equal to the number of rows
+C       that are represented by the principal supervariable i.  If i is
+C       a nonprincipal variable, then nv (i) = 0.  Initially,
+C       nv (i) = 1 for all i.  nv (i) .lt. 0 signifies that i is a
+C       principal variable in the pattern Lme of the current pivot
+C       element me.  On output, nv (e) holds the true degree of element
+C       e at the time it was created (including the diagonal part).
+
+C ncmpa:        The number of times iw was compressed.  If this is
+C       excessive, then the execution took longer than what could have
+C       been.  To reduce ncmpa, try increasing iwlen to be 10% or 20%
+C       larger than the value of pfree on input (or at least
+C       iwlen .ge. pfree + n).  The fastest performance will be
+C       obtained when ncmpa is returned as zero.  If iwlen is set to
+C       the value returned by pfree on *output*, then no compressions
+C       will occur.
+
+C elen: See the description of iw above.  At the start of execution,
+C       elen (i) is set to zero.  During execution, elen (i) is the
+C       number of elements in the list for supervariable i.  When e
+C       becomes an element, elen (e) = -nel is set, where nel is the
+C       current step of factorization.  elen (i) = 0 is done when i
+C       becomes nonprincipal.
+C
+C       For variables, elen (i) .ge. 0 holds until just before the
+C       permutation vectors are computed.  For elements,
+C       elen (e) .lt. 0 holds.
+C
+C       On output elen (1..n) holds the inverse permutation (the same
+C       as the 'INVP' argument in Sparspak).  That is, if k = elen (i),
+C       then row i is the kth pivot row.  Row i of A appears as the
+C       (elen(i))-th row in the permuted matrix, PAP^T.
+
+C last: In a degree list, last (i) is the supervariable preceding i,
+C       or zero if i is the head of the list.  In a hash bucket,
+C       last (i) is the hash key for i.  last (head (hash)) is also
+C       used as the head of a hash bucket if head (hash) contains a
+C       degree list (see head, below).
+C
+C       On output, last (1..n) holds the permutation (the same as the
+C       'PERM' argument in Sparspak).  That is, if i = last (k), then
+C       row i is the kth pivot row.  Row last (k) of A is the k-th row
+C       in the permuted matrix, PAP^T.
+
+C-----------------------------------------------------------------------
+C LOCAL (not input or output - used only during execution):
+C-----------------------------------------------------------------------
+
+C degree:       If i is a supervariable, then degree (i) holds the
+C       current approximation of the external degree of row i (an upper
+C       bound).  The external degree is the number of nonzeros in row i,
+C       minus abs (nv (i)) (the diagonal part).  The bound is equal to
+C       the external degree if elen (i) is less than or equal to two.
+C
+C       We also use the term "external degree" for elements e to refer
+C       to |Le \ Lme|.  If e is an element, then degree (e) holds |Le|,
+C       which is the degree of the off-diagonal part of the element e
+C       (not including the diagonal part).
+
+C head: head is used for degree lists.  head (deg) is the first
+C       supervariable in a degree list (all supervariables i in a
+C       degree list deg have the same approximate degree, namely,
+C       deg = degree (i)).  If the list deg is empty then
+C       head (deg) = 0.
+C
+C       During supervariable detection head (hash) also serves as a
+C       pointer to a hash bucket.
+C       If head (hash) .gt. 0, there is a degree list of degree hash.
+C               The hash bucket head pointer is last (head (hash)).
+C       If head (hash) = 0, then the degree list and hash bucket are
+C               both empty.
+C       If head (hash) .lt. 0, then the degree list is empty, and
+C               -head (hash) is the head of the hash bucket.
+C       After supervariable detection is complete, all hash buckets
+C       are empty, and the (last (head (hash)) = 0) condition is
+C       restored for the non-empty degree lists.
+
+C next: next (i) is the supervariable following i in a link list, or
+C       zero if i is the last in the list.  Used for two kinds of
+C       lists:  degree lists and hash buckets (a supervariable can be
+C       in only one kind of list at a time).
+
+C w:    The flag array w determines the status of elements and
+C       variables, and the external degree of elements.
+C
+C       for elements:
+C          if w (e) = 0, then the element e is absorbed
+C          if w (e) .ge. wflg, then w (e) - wflg is the size of
+C               the set |Le \ Lme|, in terms of nonzeros (the
+C               sum of abs (nv (i)) for each principal variable i that
+C               is both in the pattern of element e and NOT in the
+C               pattern of the current pivot element, me).
+C          if wflg .gt. w (e) .gt. 0, then e is not absorbed and has
+C               not yet been seen in the scan of the element lists in
+C               the computation of |Le\Lme| in loop 150 below.
+C
+C       for variables:
+C          during supervariable detection, if w (j) .ne. wflg then j is
+C          not in the pattern of variable i
+C
+C       The w array is initialized by setting w (i) = 1 for all i,
+C       and by setting wflg = 2.  It is reinitialized if wflg becomes
+C       too large (to ensure that wflg+n does not cause integer
+C       overflow).
+
+C-----------------------------------------------------------------------
+C LOCAL INTEGERS:
+C-----------------------------------------------------------------------
+
+        INTEGER DEG, DEGME, DEXT, DMAX, E, ELENME, ELN, HASH, HMOD, I,
+     $          ILAST, INEXT, J, JLAST, JNEXT, K, KNT1, KNT2, KNT3,
+     $          LENJ, LN, MAXMEM, ME, MEM, MINDEG, NEL, NEWMEM,
+     $          NLEFT, NVI, NVJ, NVPIV, SLENME, WE, WFLG, WNVI, X
+
+C deg:          the degree of a variable or element
+C degme:        size, |Lme|, of the current element, me (= degree (me))
+C dext:         external degree, |Le \ Lme|, of some element e
+C dmax:         largest |Le| seen so far
+C e:            an element
+C elenme:       the length, elen (me), of element list of pivotal var.
+C eln:          the length, elen (...), of an element list
+C hash:         the computed value of the hash function
+C hmod:         the hash function is computed modulo hmod = max (1,n-1)
+C i:            a supervariable
+C ilast:        the entry in a link list preceding i
+C inext:        the entry in a link list following i
+C j:            a supervariable
+C jlast:        the entry in a link list preceding j
+C jnext:        the entry in a link list, or path, following j
+C k:            the pivot order of an element or variable
+C knt1:         loop counter used during element construction
+C knt2:         loop counter used during element construction
+C knt3:         loop counter used during compression
+C lenj:         len (j)
+C ln:           length of a supervariable list
+C maxmem:       amount of memory needed for no compressions
+C me:           current supervariable being eliminated, and the
+C                       current element created by eliminating that
+C                       supervariable
+C mem:          memory in use assuming no compressions have occurred
+C mindeg:       current minimum degree
+C nel:          number of pivots selected so far
+C newmem:       amount of new memory needed for current pivot element
+C nleft:        n - nel, the number of nonpivotal rows/columns remaining
+C nvi:          the number of variables in a supervariable i (= nv (i))
+C nvj:          the number of variables in a supervariable j (= nv (j))
+C nvpiv:        number of pivots in current element
+C slenme:       number of variables in variable list of pivotal variable
+C we:           w (e)
+C wflg:         used for flagging the w array.  See description of iw.
+C wnvi:         wflg - nv (i)
+C x:            either a supervariable or an element
+
+C-----------------------------------------------------------------------
+C LOCAL POINTERS:
+C-----------------------------------------------------------------------
+
+        INTEGER P, P1, P2, P3, PDST, PEND, PJ, PME, PME1, PME2, PN, PSRC
+
+C               Any parameter (pe (...) or pfree) or local variable
+C               starting with "p" (for Pointer) is an index into iw,
+C               and all indices into iw use variables starting with
+C               "p."  The only exception to this rule is the iwlen
+C               input argument.
+
+C p:            pointer into lots of things
+C p1:           pe (i) for some variable i (start of element list)
+C p2:           pe (i) + elen (i) -  1 for some var. i (end of el. list)
+C p3:           index of first supervariable in clean list
+C pdst:         destination pointer, for compression
+C pend:         end of memory to compress
+C pj:           pointer into an element or variable
+C pme:          pointer into the current element (pme1...pme2)
+C pme1:         the current element, me, is stored in iw (pme1...pme2)
+C pme2:         the end of the current element
+C pn:           pointer into a "clean" variable, also used to compress
+C psrc:         source pointer, for compression
+
+C-----------------------------------------------------------------------
+C  FUNCTIONS CALLED:
+C-----------------------------------------------------------------------
+
+        INTRINSIC MAX, MIN, MOD
+
+C=======================================================================
+C  INITIALIZATIONS
+C=======================================================================
+
+        WFLG = 2
+        MINDEG = 1
+        NCMPA = 0
+        NEL = 0
+        HMOD = MAX (1, N-1)
+        DMAX = 0
+        MEM = PFREE - 1
+        MAXMEM = MEM
+	ME = 0
+
+        DO 10 I = 1, N
+           LAST (I) = 0
+           HEAD (I) = 0
+           NV (I) = 1
+           W (I) = 1
+           ELEN (I) = 0
+           DEGREE (I) = LEN (I)
+10         CONTINUE
+
+C       ----------------------------------------------------------------
+C       initialize degree lists and eliminate rows with no off-diag. nz.
+C       ----------------------------------------------------------------
+
+        DO 20 I = 1, N
+
+           DEG = DEGREE (I)
+
+           IF (DEG .GT. 0) THEN
+
+C             ----------------------------------------------------------
+C             place i in the degree list corresponding to its degree
+C             ----------------------------------------------------------
+
+              INEXT = HEAD (DEG)
+              IF (INEXT .NE. 0) LAST (INEXT) = I
+              NEXT (I) = INEXT
+              HEAD (DEG) = I
+
+           ELSE
+
+C             ----------------------------------------------------------
+C             we have a variable that can be eliminated at once because
+C             there is no off-diagonal non-zero in its row.
+C             ----------------------------------------------------------
+
+              NEL = NEL + 1
+              ELEN (I) = -NEL
+              PE (I) = 0
+              W (I) = 0
+
+              ENDIF
+
+20         CONTINUE
+
+C=======================================================================
+C  WHILE (selecting pivots) DO
+C=======================================================================
+
+30      CONTINUE
+        IF (NEL .LT. N) THEN
+
+C=======================================================================
+C  GET PIVOT OF MINIMUM DEGREE
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          find next supervariable for elimination
+C          -------------------------------------------------------------
+
+           DO 40 DEG = MINDEG, N
+              ME = HEAD (DEG)
+              IF (ME .GT. 0) GOTO 50
+40            CONTINUE
+50         CONTINUE
+           MINDEG = DEG
+
+C          -------------------------------------------------------------
+C          remove chosen variable from link list
+C          -------------------------------------------------------------
+
+           INEXT = NEXT (ME)
+           IF (INEXT .NE. 0) LAST (INEXT) = 0
+           HEAD (DEG) = INEXT
+
+C          -------------------------------------------------------------
+C          me represents the elimination of pivots nel+1 to nel+nv(me).
+C          place me itself as the first in this set.  It will be moved
+C          to the nel+nv(me) position when the permutation vectors are
+C          computed.
+C          -------------------------------------------------------------
+
+           ELENME = ELEN (ME)
+           ELEN (ME) = - (NEL + 1)
+           NVPIV = NV (ME)
+           NEL = NEL + NVPIV
+
+C=======================================================================
+C  CONSTRUCT NEW ELEMENT
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          At this point, me is the pivotal supervariable.  It will be
+C          converted into the current element.  Scan list of the
+C          pivotal supervariable, me, setting tree pointers and
+C          constructing new list of supervariables for the new element,
+C          me.  p is a pointer to the current position in the old list.
+C          -------------------------------------------------------------
+
+C          flag the variable "me" as being in Lme by negating nv (me)
+           NV (ME) = -NVPIV
+           DEGME = 0
+
+           IF (ELENME .EQ. 0) THEN
+
+C             ----------------------------------------------------------
+C             construct the new element in place
+C             ----------------------------------------------------------
+
+              PME1 = PE (ME)
+              PME2 = PME1 - 1
+
+              DO 60 P = PME1, PME1 + LEN (ME) - 1
+                 I = IW (P)
+                 NVI = NV (I)
+                 IF (NVI .GT. 0) THEN
+
+C                   ----------------------------------------------------
+C                   i is a principal variable not yet placed in Lme.
+C                   store i in new list
+C                   ----------------------------------------------------
+
+                    DEGME = DEGME + NVI
+C                   flag i as being in Lme by negating nv (i)
+                    NV (I) = -NVI
+                    PME2 = PME2 + 1
+                    IW (PME2) = I
+
+C                   ----------------------------------------------------
+C                   remove variable i from degree list.
+C                   ----------------------------------------------------
+
+                    ILAST = LAST (I)
+                    INEXT = NEXT (I)
+                    IF (INEXT .NE. 0) LAST (INEXT) = ILAST
+                    IF (ILAST .NE. 0) THEN
+                       NEXT (ILAST) = INEXT
+                    ELSE
+C                      i is at the head of the degree list
+                       HEAD (DEGREE (I)) = INEXT
+                       ENDIF
+
+                    ENDIF
+60               CONTINUE
+C             this element takes no new memory in iw:
+              NEWMEM = 0
+
+           ELSE
+
+C             ----------------------------------------------------------
+C             construct the new element in empty space, iw (pfree ...)
+C             ----------------------------------------------------------
+
+              P = PE (ME)
+              PME1 = PFREE
+              SLENME = LEN (ME) - ELENME
+
+              DO 120 KNT1 = 1, ELENME + 1
+
+                 IF (KNT1 .GT. ELENME) THEN
+C                   search the supervariables in me.
+                    E = ME
+                    PJ = P
+                    LN = SLENME
+                 ELSE
+C                   search the elements in me.
+                    E = IW (P)
+                    P = P + 1
+                    PJ = PE (E)
+                    LN = LEN (E)
+                    ENDIF
+
+C                -------------------------------------------------------
+C                search for different supervariables and add them to the
+C                new list, compressing when necessary. this loop is
+C                executed once for each element in the list and once for
+C                all the supervariables in the list.
+C                -------------------------------------------------------
+
+                 DO 110 KNT2 = 1, LN
+                    I = IW (PJ)
+                    PJ = PJ + 1
+                    NVI = NV (I)
+                    IF (NVI .GT. 0) THEN
+
+C                      -------------------------------------------------
+C                      compress iw, if necessary
+C                      -------------------------------------------------
+
+                       IF (PFREE .GT. IWLEN) THEN
+C                         prepare for compressing iw by adjusting
+C                         pointers and lengths so that the lists being
+C                         searched in the inner and outer loops contain
+C                         only the remaining entries.
+
+                          PE (ME) = P
+                          LEN (ME) = LEN (ME) - KNT1
+                          IF (LEN (ME) .EQ. 0) THEN
+C                            nothing left of supervariable me
+                             PE (ME) = 0
+                             ENDIF
+                          PE (E) = PJ
+                          LEN (E) = LN - KNT2
+                          IF (LEN (E) .EQ. 0) THEN
+C                            nothing left of element e
+                             PE (E) = 0
+                             ENDIF
+
+                          NCMPA = NCMPA + 1
+C                         store first item in pe
+C                         set first entry to -item
+                          DO 70 J = 1, N
+                             PN = PE (J)
+                             IF (PN .GT. 0) THEN
+                                PE (J) = IW (PN)
+                                IW (PN) = -J
+                                ENDIF
+70                           CONTINUE
+
+C                         psrc/pdst point to source/destination
+                          PDST = 1
+                          PSRC = 1
+                          PEND = PME1 - 1
+
+C                         while loop:
+80                        CONTINUE
+                          IF (PSRC .LE. PEND) THEN
+C                            search for next negative entry
+                             J = -IW (PSRC)
+                             PSRC = PSRC + 1
+                             IF (J .GT. 0) THEN
+                                IW (PDST) = PE (J)
+                                PE (J) = PDST
+                                PDST = PDST + 1
+C                               copy from source to destination
+                                LENJ = LEN (J)
+                                DO 90 KNT3 = 0, LENJ - 2
+                                   IW (PDST + KNT3) = IW (PSRC + KNT3)
+90                                 CONTINUE
+                                PDST = PDST + LENJ - 1
+                                PSRC = PSRC + LENJ - 1
+                                ENDIF
+                             GOTO 80
+                             ENDIF
+
+C                         move the new partially-constructed element
+                          P1 = PDST
+                          DO 100 PSRC = PME1, PFREE - 1
+                             IW (PDST) = IW (PSRC)
+                             PDST = PDST + 1
+100                          CONTINUE
+                          PME1 = P1
+                          PFREE = PDST
+                          PJ = PE (E)
+                          P = PE (ME)
+                          ENDIF
+
+C                      -------------------------------------------------
+C                      i is a principal variable not yet placed in Lme
+C                      store i in new list
+C                      -------------------------------------------------
+
+                       DEGME = DEGME + NVI
+C                      flag i as being in Lme by negating nv (i)
+                       NV (I) = -NVI
+                       IW (PFREE) = I
+                       PFREE = PFREE + 1
+
+C                      -------------------------------------------------
+C                      remove variable i from degree link list
+C                      -------------------------------------------------
+
+                       ILAST = LAST (I)
+                       INEXT = NEXT (I)
+                       IF (INEXT .NE. 0) LAST (INEXT) = ILAST
+                       IF (ILAST .NE. 0) THEN
+                          NEXT (ILAST) = INEXT
+                       ELSE
+C                         i is at the head of the degree list
+                          HEAD (DEGREE (I)) = INEXT
+                          ENDIF
+
+                       ENDIF
+110                 CONTINUE
+
+                 IF (E .NE. ME) THEN
+C                   set tree pointer and flag to indicate element e is
+C                   absorbed into new element me (the parent of e is me)
+                    PE (E) = -ME
+                    W (E) = 0
+                    ENDIF
+120              CONTINUE
+
+              PME2 = PFREE - 1
+C             this element takes newmem new memory in iw (possibly zero)
+              NEWMEM = PFREE - PME1
+              MEM = MEM + NEWMEM
+              MAXMEM = MAX (MAXMEM, MEM)
+              ENDIF
+
+C          -------------------------------------------------------------
+C          me has now been converted into an element in iw (pme1..pme2)
+C          -------------------------------------------------------------
+
+C          degme holds the external degree of new element
+           DEGREE (ME) = DEGME
+           PE (ME) = PME1
+           LEN (ME) = PME2 - PME1 + 1
+
+C          -------------------------------------------------------------
+C          make sure that wflg is not too large.  With the current
+C          value of wflg, wflg+n must not cause integer overflow
+C          -------------------------------------------------------------
+
+           IF (WFLG + N .LE. WFLG) THEN
+              DO 130 X = 1, N
+                 IF (W (X) .NE. 0) W (X) = 1
+130              CONTINUE
+              WFLG = 2
+              ENDIF
+
+C=======================================================================
+C  COMPUTE (w (e) - wflg) = |Le\Lme| FOR ALL ELEMENTS
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          Scan 1:  compute the external degrees of previous elements
+C          with respect to the current element.  That is:
+C               (w (e) - wflg) = |Le \ Lme|
+C          for each element e that appears in any supervariable in Lme.
+C          The notation Le refers to the pattern (list of
+C          supervariables) of a previous element e, where e is not yet
+C          absorbed, stored in iw (pe (e) + 1 ... pe (e) + iw (pe (e))).
+C          The notation Lme refers to the pattern of the current element
+C          (stored in iw (pme1..pme2)).   If (w (e) - wflg) becomes
+C          zero, then the element e will be absorbed in scan 2.
+C          -------------------------------------------------------------
+
+           DO 150 PME = PME1, PME2
+              I = IW (PME)
+              ELN = ELEN (I)
+              IF (ELN .GT. 0) THEN
+C                note that nv (i) has been negated to denote i in Lme:
+                 NVI = -NV (I)
+                 WNVI = WFLG - NVI
+                 DO 140 P = PE (I), PE (I) + ELN - 1
+                    E = IW (P)
+                    WE = W (E)
+                    IF (WE .GE. WFLG) THEN
+C                      unabsorbed element e has been seen in this loop
+                       WE = WE - NVI
+                    ELSE IF (WE .NE. 0) THEN
+C                      e is an unabsorbed element
+C                      this is the first we have seen e in all of Scan 1
+                       WE = DEGREE (E) + WNVI
+                       ENDIF
+                    W (E) = WE
+140                 CONTINUE
+                 ENDIF
+150           CONTINUE
+
+C=======================================================================
+C  DEGREE UPDATE AND ELEMENT ABSORPTION
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          Scan 2:  for each i in Lme, sum up the degree of Lme (which
+C          is degme), plus the sum of the external degrees of each Le
+C          for the elements e appearing within i, plus the
+C          supervariables in i.  Place i in hash list.
+C          -------------------------------------------------------------
+
+           DO 180 PME = PME1, PME2
+              I = IW (PME)
+              P1 = PE (I)
+              P2 = P1 + ELEN (I) - 1
+              PN = P1
+              HASH = 0
+              DEG = 0
+
+C             ----------------------------------------------------------
+C             scan the element list associated with supervariable i
+C             ----------------------------------------------------------
+
+              DO 160 P = P1, P2
+                 E = IW (P)
+C                dext = | Le \ Lme |
+                 DEXT = W (E) - WFLG
+                 IF (DEXT .GT. 0) THEN
+                    DEG = DEG + DEXT
+                    IW (PN) = E
+                    PN = PN + 1
+                    HASH = HASH + E
+                 ELSE IF (DEXT .EQ. 0) THEN
+C                   aggressive absorption: e is not adjacent to me, but
+C                   the |Le \ Lme| is 0, so absorb it into me
+                    PE (E) = -ME
+                    W (E) = 0
+                 ELSE
+C                   element e has already been absorbed, due to
+C                   regular absorption, in do loop 120 above. Ignore it.
+                    CONTINUE
+                    ENDIF
+160              CONTINUE
+
+C             count the number of elements in i (including me):
+              ELEN (I) = PN - P1 + 1
+
+C             ----------------------------------------------------------
+C             scan the supervariables in the list associated with i
+C             ----------------------------------------------------------
+
+              P3 = PN
+              DO 170 P = P2 + 1, P1 + LEN (I) - 1
+                 J = IW (P)
+                 NVJ = NV (J)
+                 IF (NVJ .GT. 0) THEN
+C                   j is unabsorbed, and not in Lme.
+C                   add to degree and add to new list
+                    DEG = DEG + NVJ
+                    IW (PN) = J
+                    PN = PN + 1
+                    HASH = HASH + J
+                    ENDIF
+170              CONTINUE
+
+C             ----------------------------------------------------------
+C             update the degree and check for mass elimination
+C             ----------------------------------------------------------
+
+              IF (DEG .EQ. 0) THEN
+
+C                -------------------------------------------------------
+C                mass elimination
+C                -------------------------------------------------------
+
+C                There is nothing left of this node except for an
+C                edge to the current pivot element.  elen (i) is 1,
+C                and there are no variables adjacent to node i.
+C                Absorb i into the current pivot element, me.
+
+                 PE (I) = -ME
+                 NVI = -NV (I)
+                 DEGME = DEGME - NVI
+                 NVPIV = NVPIV + NVI
+                 NEL = NEL + NVI
+                 NV (I) = 0
+                 ELEN (I) = 0
+
+              ELSE
+
+C                -------------------------------------------------------
+C                update the upper-bound degree of i
+C                -------------------------------------------------------
+
+C                the following degree does not yet include the size
+C                of the current element, which is added later:
+                 DEGREE (I) = MIN (DEGREE (I), DEG)
+
+C                -------------------------------------------------------
+C                add me to the list for i
+C                -------------------------------------------------------
+
+C                move first supervariable to end of list
+                 IW (PN) = IW (P3)
+C                move first element to end of element part of list
+                 IW (P3) = IW (P1)
+C                add new element to front of list.
+                 IW (P1) = ME
+C                store the new length of the list in len (i)
+                 LEN (I) = PN - P1 + 1
+
+C                -------------------------------------------------------
+C                place in hash bucket.  Save hash key of i in last (i).
+C                -------------------------------------------------------
+
+                 HASH = MOD (HASH, HMOD) + 1
+                 J = HEAD (HASH)
+                 IF (J .LE. 0) THEN
+C                   the degree list is empty, hash head is -j
+                    NEXT (I) = -J
+                    HEAD (HASH) = -I
+                 ELSE
+C                   degree list is not empty
+C                   use last (head (hash)) as hash head
+                    NEXT (I) = LAST (J)
+                    LAST (J) = I
+                    ENDIF
+                 LAST (I) = HASH
+                 ENDIF
+180           CONTINUE
+
+           DEGREE (ME) = DEGME
+
+C          -------------------------------------------------------------
+C          Clear the counter array, w (...), by incrementing wflg.
+C          -------------------------------------------------------------
+
+           DMAX = MAX (DMAX, DEGME)
+           WFLG = WFLG + DMAX
+
+C          make sure that wflg+n does not cause integer overflow
+           IF (WFLG + N .LE. WFLG) THEN
+              DO 190 X = 1, N
+                 IF (W (X) .NE. 0) W (X) = 1
+190              CONTINUE
+              WFLG = 2
+              ENDIF
+C          at this point, w (1..n) .lt. wflg holds
+
+C=======================================================================
+C  SUPERVARIABLE DETECTION
+C=======================================================================
+
+           DO 250 PME = PME1, PME2
+              I = IW (PME)
+              IF (NV (I) .LT. 0) THEN
+C                i is a principal variable in Lme
+
+C                -------------------------------------------------------
+C                examine all hash buckets with 2 or more variables.  We
+C                do this by examing all unique hash keys for super-
+C                variables in the pattern Lme of the current element, me
+C                -------------------------------------------------------
+
+                 HASH = LAST (I)
+C                let i = head of hash bucket, and empty the hash bucket
+                 J = HEAD (HASH)
+                 IF (J .EQ. 0) GOTO 250
+                 IF (J .LT. 0) THEN
+C                   degree list is empty
+                    I = -J
+                    HEAD (HASH) = 0
+                 ELSE
+C                   degree list is not empty, restore last () of head
+                    I = LAST (J)
+                    LAST (J) = 0
+                    ENDIF
+                 IF (I .EQ. 0) GOTO 250
+
+C                while loop:
+200              CONTINUE
+                 IF (NEXT (I) .NE. 0) THEN
+
+C                   ----------------------------------------------------
+C                   this bucket has one or more variables following i.
+C                   scan all of them to see if i can absorb any entries
+C                   that follow i in hash bucket.  Scatter i into w.
+C                   ----------------------------------------------------
+
+                    LN = LEN (I)
+                    ELN = ELEN (I)
+C                   do not flag the first element in the list (me)
+                    DO 210 P = PE (I) + 1, PE (I) + LN - 1
+                       W (IW (P)) = WFLG
+210                    CONTINUE
+
+C                   ----------------------------------------------------
+C                   scan every other entry j following i in bucket
+C                   ----------------------------------------------------
+
+                    JLAST = I
+                    J = NEXT (I)
+
+C                   while loop:
+220                 CONTINUE
+                    IF (J .NE. 0) THEN
+
+C                      -------------------------------------------------
+C                      check if j and i have identical nonzero pattern
+C                      -------------------------------------------------
+
+                       IF (LEN (J) .NE. LN) THEN
+C                         i and j do not have same size data structure
+                          GOTO 240
+                          ENDIF
+                       IF (ELEN (J) .NE. ELN) THEN
+C                         i and j do not have same number of adjacent el
+                          GOTO 240
+                          ENDIF
+C                      do not flag the first element in the list (me)
+                       DO 230 P = PE (J) + 1, PE (J) + LN - 1
+                          IF (W (IW (P)) .NE. WFLG) THEN
+C                            an entry (iw(p)) is in j but not in i
+                             GOTO 240
+                             ENDIF
+230                       CONTINUE
+
+C                      -------------------------------------------------
+C                      found it!  j can be absorbed into i
+C                      -------------------------------------------------
+
+                       PE (J) = -I
+C                      both nv (i) and nv (j) are negated since they
+C                      are in Lme, and the absolute values of each
+C                      are the number of variables in i and j:
+                       NV (I) = NV (I) + NV (J)
+                       NV (J) = 0
+                       ELEN (J) = 0
+C                      delete j from hash bucket
+                       J = NEXT (J)
+                       NEXT (JLAST) = J
+                       GOTO 220
+
+C                      -------------------------------------------------
+240                    CONTINUE
+C                      j cannot be absorbed into i
+C                      -------------------------------------------------
+
+                       JLAST = J
+                       J = NEXT (J)
+                       GOTO 220
+                       ENDIF
+
+C                   ----------------------------------------------------
+C                   no more variables can be absorbed into i
+C                   go to next i in bucket and clear flag array
+C                   ----------------------------------------------------
+
+                    WFLG = WFLG + 1
+                    I = NEXT (I)
+                    IF (I .NE. 0) GOTO 200
+                    ENDIF
+                 ENDIF
+250           CONTINUE
+
+C=======================================================================
+C  RESTORE DEGREE LISTS AND REMOVE NONPRINCIPAL SUPERVAR. FROM ELEMENT
+C=======================================================================
+
+           P = PME1
+           NLEFT = N - NEL
+           DO 260 PME = PME1, PME2
+              I = IW (PME)
+              NVI = -NV (I)
+              IF (NVI .GT. 0) THEN
+C                i is a principal variable in Lme
+C                restore nv (i) to signify that i is principal
+                 NV (I) = NVI
+
+C                -------------------------------------------------------
+C                compute the external degree (add size of current elem)
+C                -------------------------------------------------------
+
+                 DEG = MIN (DEGREE (I) + DEGME - NVI, NLEFT - NVI)
+
+C                -------------------------------------------------------
+C                place the supervariable at the head of the degree list
+C                -------------------------------------------------------
+
+                 INEXT = HEAD (DEG)
+                 IF (INEXT .NE. 0) LAST (INEXT) = I
+                 NEXT (I) = INEXT
+                 LAST (I) = 0
+                 HEAD (DEG) = I
+
+C                -------------------------------------------------------
+C                save the new degree, and find the minimum degree
+C                -------------------------------------------------------
+
+                 MINDEG = MIN (MINDEG, DEG)
+                 DEGREE (I) = DEG
+
+C                -------------------------------------------------------
+C                place the supervariable in the element pattern
+C                -------------------------------------------------------
+
+                 IW (P) = I
+                 P = P + 1
+                 ENDIF
+260           CONTINUE
+
+C=======================================================================
+C  FINALIZE THE NEW ELEMENT
+C=======================================================================
+
+           NV (ME) = NVPIV + DEGME
+C          nv (me) is now the degree of pivot (including diagonal part)
+C          save the length of the list for the new element me
+           LEN (ME) = P - PME1
+           IF (LEN (ME) .EQ. 0) THEN
+C             there is nothing left of the current pivot element
+              PE (ME) = 0
+              W (ME) = 0
+              ENDIF
+           IF (NEWMEM .NE. 0) THEN
+C             element was not constructed in place: deallocate part
+C             of it (final size is less than or equal to newmem,
+C             since newly nonprincipal variables have been removed).
+              PFREE = P
+              MEM = MEM - NEWMEM + LEN (ME)
+              ENDIF
+
+C=======================================================================
+C          END WHILE (selecting pivots)
+           GOTO 30
+           ENDIF
+C=======================================================================
+
+C=======================================================================
+C  COMPUTE THE PERMUTATION VECTORS
+C=======================================================================
+
+C       ----------------------------------------------------------------
+C       The time taken by the following code is O(n).  At this
+C       point, elen (e) = -k has been done for all elements e,
+C       and elen (i) = 0 has been done for all nonprincipal
+C       variables i.  At this point, there are no principal
+C       supervariables left, and all elements are absorbed.
+C       ----------------------------------------------------------------
+
+C       ----------------------------------------------------------------
+C       compute the ordering of unordered nonprincipal variables
+C       ----------------------------------------------------------------
+
+        DO 290 I = 1, N
+           IF (ELEN (I) .EQ. 0) THEN
+
+C             ----------------------------------------------------------
+C             i is an un-ordered row.  Traverse the tree from i until
+C             reaching an element, e.  The element, e, was the
+C             principal supervariable of i and all nodes in the path
+C             from i to when e was selected as pivot.
+C             ----------------------------------------------------------
+
+              J = -PE (I)
+C             while (j is a variable) do:
+270           CONTINUE
+              IF (ELEN (J) .GE. 0) THEN
+                 J = -PE (J)
+                 GOTO 270
+                 ENDIF
+              E = J
+
+C             ----------------------------------------------------------
+C             get the current pivot ordering of e
+C             ----------------------------------------------------------
+
+              K = -ELEN (E)
+
+C             ----------------------------------------------------------
+C             traverse the path again from i to e, and compress the
+C             path (all nodes point to e).  Path compression allows
+C             this code to compute in O(n) time.  Order the unordered
+C             nodes in the path, and place the element e at the end.
+C             ----------------------------------------------------------
+
+              J = I
+C             while (j is a variable) do:
+280           CONTINUE
+              IF (ELEN (J) .GE. 0) THEN
+                 JNEXT = -PE (J)
+                 PE (J) = -E
+                 IF (ELEN (J) .EQ. 0) THEN
+C                   j is an unordered row
+                    ELEN (J) = K
+                    K = K + 1
+                    ENDIF
+                 J = JNEXT
+                 GOTO 280
+                 ENDIF
+C             leave elen (e) negative, so we know it is an element
+              ELEN (E) = -K
+              ENDIF
+290        CONTINUE
+
+C       ----------------------------------------------------------------
+C       reset the inverse permutation (elen (1..n)) to be positive,
+C       and compute the permutation (last (1..n)).
+C       ----------------------------------------------------------------
+
+        DO 300 I = 1, N
+           K = ABS (ELEN (I))
+           LAST (K) = I
+           ELEN (I) = K
+300        CONTINUE
+
+C=======================================================================
+C  RETURN THE MEMORY USAGE IN IW
+C=======================================================================
+
+C       If maxmem is less than or equal to iwlen, then no compressions
+C       occurred, and iw (maxmem+1 ... iwlen) was unused.  Otherwise
+C       compressions did occur, and iwlen would have had to have been
+C       greater than or equal to maxmem for no compressions to occur.
+C       Return the value of maxmem in the pfree argument.
+
+        PFREE = MAXMEM
+
+        RETURN
+        END
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Source/amdbar.f b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Source/amdbar.f
new file mode 100644
index 0000000000000000000000000000000000000000..13843928ba148d0322ca2f48e6cccfc57427881b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/AMD/Source/amdbar.f
@@ -0,0 +1,1206 @@
+C-----------------------------------------------------------------------
+C AMDBAR:  approximate minimum degree, without aggressive absorption
+C-----------------------------------------------------------------------
+
+        SUBROUTINE AMDBAR
+     $          (N, PE, IW, LEN, IWLEN, PFREE, NV, NEXT,
+     $          LAST, HEAD, ELEN, DEGREE, NCMPA, W)
+
+        INTEGER N, IWLEN, PFREE, NCMPA, IW (IWLEN), PE (N),
+     $          DEGREE (N), NV (N), NEXT (N), LAST (N), HEAD (N),
+     $          ELEN (N), W (N), LEN (N)
+
+C Given a representation of the nonzero pattern of a symmetric matrix,
+C       A, (excluding the diagonal) perform an approximate minimum
+C       (UMFPACK/MA38-style) degree ordering to compute a pivot order
+C       such that the introduction of nonzeros (fill-in) in the Cholesky
+C       factors A = LL^T are kept low.  At each step, the pivot
+C       selected is the one with the minimum UMFPACK/MA38-style
+C       upper-bound on the external degree.
+C
+C       This routine does not do aggresive absorption (as done by AMD).
+
+C **********************************************************************
+C ***** CAUTION:  ARGUMENTS ARE NOT CHECKED FOR ERRORS ON INPUT.  ******
+C **********************************************************************
+
+C       References:
+C
+C       [1] Timothy A. Davis and Iain Duff, "An unsymmetric-pattern
+C           multifrontal method for sparse LU factorization", SIAM J.
+C           Matrix Analysis and Applications, vol. 18, no. 1, pp.
+C           140-158.  Discusses UMFPACK / MA38, which first introduced
+C           the approximate minimum degree used by this routine.
+C
+C       [2] Patrick Amestoy, Timothy A. Davis, and Iain S. Duff, "An
+C           approximate degree ordering algorithm," SIAM J. Matrix
+C           Analysis and Applications, vol. 17, no. 4, pp. 886-905,
+C           1996.  Discusses AMD, AMDBAR, and MC47B.
+C
+C       [3] Alan George and Joseph Liu, "The evolution of the minimum
+C           degree ordering algorithm," SIAM Review, vol. 31, no. 1,
+C           pp. 1-19, 1989.  We list below the features mentioned in
+C           that paper that this code includes:
+C
+C       mass elimination:
+C               Yes.  MA27 relied on supervariable detection for mass
+C               elimination.
+C       indistinguishable nodes:
+C               Yes (we call these "supervariables").  This was also in
+C               the MA27 code - although we modified the method of
+C               detecting them (the previous hash was the true degree,
+C               which we no longer keep track of).  A supervariable is
+C               a set of rows with identical nonzero pattern.  All
+C               variables in a supervariable are eliminated together.
+C               Each supervariable has as its numerical name that of
+C               one of its variables (its principal variable).
+C       quotient graph representation:
+C               Yes.  We use the term "element" for the cliques formed
+C               during elimination.  This was also in the MA27 code.
+C               The algorithm can operate in place, but it will work
+C               more efficiently if given some "elbow room."
+C       element absorption:
+C               Yes.  This was also in the MA27 code.
+C       external degree:
+C               Yes.  The MA27 code was based on the true degree.
+C       incomplete degree update and multiple elimination:
+C               No.  This was not in MA27, either.  Our method of
+C               degree update within MC47B/BD is element-based, not
+C               variable-based.  It is thus not well-suited for use
+C               with incomplete degree update or multiple elimination.
+
+C-----------------------------------------------------------------------
+C Authors, and Copyright (C) 1995 by:
+C       Timothy A. Davis, Patrick Amestoy, Iain S. Duff, & John K. Reid.
+C
+C Acknowledgements:
+C       This work (and the UMFPACK package) was supported by the
+C       National Science Foundation (ASC-9111263 and DMS-9223088).
+C       The UMFPACK/MA38 approximate degree update algorithm, the
+C       unsymmetric analog which forms the basis of MC47B/BD, was
+C       developed while Tim Davis was supported by CERFACS (Toulouse,
+C       France) in a post-doctoral position.
+C
+C Date:  September, 1995
+C-----------------------------------------------------------------------
+
+C-----------------------------------------------------------------------
+C INPUT ARGUMENTS (unaltered):
+C-----------------------------------------------------------------------
+
+C n:    The matrix order.
+C
+C       Restriction:  1 .le. n .lt. (iovflo/2)-2, where iovflo is
+C       the largest positive integer that your computer can represent.
+
+C iwlen:        The length of iw (1..iwlen).  On input, the matrix is
+C       stored in iw (1..pfree-1).  However, iw (1..iwlen) should be
+C       slightly larger than what is required to hold the matrix, at
+C       least iwlen .ge. pfree + n is recommended.  Otherwise,
+C       excessive compressions will take place.
+C       *** We do not recommend running this algorithm with ***
+C       ***      iwlen .lt. pfree + n.                      ***
+C       *** Better performance will be obtained if          ***
+C       ***      iwlen .ge. pfree + n                       ***
+C       *** or better yet                                   ***
+C       ***      iwlen .gt. 1.2 * pfree                     ***
+C       *** (where pfree is its value on input).            ***
+C       The algorithm will not run at all if iwlen .lt. pfree-1.
+C
+C       Restriction: iwlen .ge. pfree-1
+
+C-----------------------------------------------------------------------
+C INPUT/OUPUT ARGUMENTS:
+C-----------------------------------------------------------------------
+
+C pe:   On input, pe (i) is the index in iw of the start of row i, or
+C       zero if row i has no off-diagonal non-zeros.
+C
+C       During execution, it is used for both supervariables and
+C       elements:
+C
+C       * Principal supervariable i:  index into iw of the
+C               description of supervariable i.  A supervariable
+C               represents one or more rows of the matrix
+C               with identical nonzero pattern.
+C       * Non-principal supervariable i:  if i has been absorbed
+C               into another supervariable j, then pe (i) = -j.
+C               That is, j has the same pattern as i.
+C               Note that j might later be absorbed into another
+C               supervariable j2, in which case pe (i) is still -j,
+C               and pe (j) = -j2.
+C       * Unabsorbed element e:  the index into iw of the description
+C               of element e, if e has not yet been absorbed by a
+C               subsequent element.  Element e is created when
+C               the supervariable of the same name is selected as
+C               the pivot.
+C       * Absorbed element e:  if element e is absorbed into element
+C               e2, then pe (e) = -e2.  This occurs when the pattern of
+C               e (that is, Le) is found to be a subset of the pattern
+C               of e2 (that is, Le2).  If element e is "null" (it has
+C               no nonzeros outside its pivot block), then pe (e) = 0.
+C
+C       On output, pe holds the assembly tree/forest, which implicitly
+C       represents a pivot order with identical fill-in as the actual
+C       order (via a depth-first search of the tree).
+C
+C       On output:
+C       If nv (i) .gt. 0, then i represents a node in the assembly tree,
+C       and the parent of i is -pe (i), or zero if i is a root.
+C       If nv (i) = 0, then (i,-pe (i)) represents an edge in a
+C       subtree, the root of which is a node in the assembly tree.
+
+C pfree:        On input the tail end of the array, iw (pfree..iwlen),
+C       is empty, and the matrix is stored in iw (1..pfree-1).
+C       During execution, additional data is placed in iw, and pfree
+C       is modified so that iw (pfree..iwlen) is always the unused part
+C       of iw.  On output, pfree is set equal to the size of iw that
+C       would have been needed for no compressions to occur.  If
+C       ncmpa is zero, then pfree (on output) is less than or equal to
+C       iwlen, and the space iw (pfree+1 ... iwlen) was not used.
+C       Otherwise, pfree (on output) is greater than iwlen, and all the
+C       memory in iw was used.
+
+C-----------------------------------------------------------------------
+C INPUT/MODIFIED (undefined on output):
+C-----------------------------------------------------------------------
+
+C len:  On input, len (i) holds the number of entries in row i of the
+C       matrix, excluding the diagonal.  The contents of len (1..n)
+C       are undefined on output.
+
+C iw:   On input, iw (1..pfree-1) holds the description of each row i
+C       in the matrix.  The matrix must be symmetric, and both upper
+C       and lower triangular parts must be present.  The diagonal must
+C       not be present.  Row i is held as follows:
+C
+C               len (i):  the length of the row i data structure
+C               iw (pe (i) ... pe (i) + len (i) - 1):
+C                       the list of column indices for nonzeros
+C                       in row i (simple supervariables), excluding
+C                       the diagonal.  All supervariables start with
+C                       one row/column each (supervariable i is just
+C                       row i).
+C               if len (i) is zero on input, then pe (i) is ignored
+C               on input.
+C
+C               Note that the rows need not be in any particular order,
+C               and there may be empty space between the rows.
+C
+C       During execution, the supervariable i experiences fill-in.
+C       This is represented by placing in i a list of the elements
+C       that cause fill-in in supervariable i:
+C
+C               len (i):  the length of supervariable i
+C               iw (pe (i) ... pe (i) + elen (i) - 1):
+C                       the list of elements that contain i.  This list
+C                       is kept short by removing absorbed elements.
+C               iw (pe (i) + elen (i) ... pe (i) + len (i) - 1):
+C                       the list of supervariables in i.  This list
+C                       is kept short by removing nonprincipal
+C                       variables, and any entry j that is also
+C                       contained in at least one of the elements
+C                       (j in Le) in the list for i (e in row i).
+C
+C       When supervariable i is selected as pivot, we create an
+C       element e of the same name (e=i):
+C
+C               len (e):  the length of element e
+C               iw (pe (e) ... pe (e) + len (e) - 1):
+C                       the list of supervariables in element e.
+C
+C       An element represents the fill-in that occurs when supervariable
+C       i is selected as pivot (which represents the selection of row i
+C       and all non-principal variables whose principal variable is i).
+C       We use the term Le to denote the set of all supervariables
+C       in element e.  Absorbed supervariables and elements are pruned
+C       from these lists when computationally convenient.
+C
+C       CAUTION:  THE INPUT MATRIX IS OVERWRITTEN DURING COMPUTATION.
+C       The contents of iw are undefined on output.
+
+C-----------------------------------------------------------------------
+C OUTPUT (need not be set on input):
+C-----------------------------------------------------------------------
+
+C nv:   During execution, abs (nv (i)) is equal to the number of rows
+C       that are represented by the principal supervariable i.  If i is
+C       a nonprincipal variable, then nv (i) = 0.  Initially,
+C       nv (i) = 1 for all i.  nv (i) .lt. 0 signifies that i is a
+C       principal variable in the pattern Lme of the current pivot
+C       element me.  On output, nv (e) holds the true degree of element
+C       e at the time it was created (including the diagonal part).
+
+C ncmpa:        The number of times iw was compressed.  If this is
+C       excessive, then the execution took longer than what could have
+C       been.  To reduce ncmpa, try increasing iwlen to be 10% or 20%
+C       larger than the value of pfree on input (or at least
+C       iwlen .ge. pfree + n).  The fastest performance will be
+C       obtained when ncmpa is returned as zero.  If iwlen is set to
+C       the value returned by pfree on *output*, then no compressions
+C       will occur.
+
+C elen: See the description of iw above.  At the start of execution,
+C       elen (i) is set to zero.  During execution, elen (i) is the
+C       number of elements in the list for supervariable i.  When e
+C       becomes an element, elen (e) = -nel is set, where nel is the
+C       current step of factorization.  elen (i) = 0 is done when i
+C       becomes nonprincipal.
+C
+C       For variables, elen (i) .ge. 0 holds until just before the
+C       permutation vectors are computed.  For elements,
+C       elen (e) .lt. 0 holds.
+C
+C       On output elen (1..n) holds the inverse permutation (the same
+C       as the 'INVP' argument in Sparspak).  That is, if k = elen (i),
+C       then row i is the kth pivot row.  Row i of A appears as the
+C       (elen(i))-th row in the permuted matrix, PAP^T.
+
+C last: In a degree list, last (i) is the supervariable preceding i,
+C       or zero if i is the head of the list.  In a hash bucket,
+C       last (i) is the hash key for i.  last (head (hash)) is also
+C       used as the head of a hash bucket if head (hash) contains a
+C       degree list (see head, below).
+C
+C       On output, last (1..n) holds the permutation (the same as the
+C       'PERM' argument in Sparspak).  That is, if i = last (k), then
+C       row i is the kth pivot row.  Row last (k) of A is the k-th row
+C       in the permuted matrix, PAP^T.
+
+C-----------------------------------------------------------------------
+C LOCAL (not input or output - used only during execution):
+C-----------------------------------------------------------------------
+
+C degree:       If i is a supervariable, then degree (i) holds the
+C       current approximation of the external degree of row i (an upper
+C       bound).  The external degree is the number of nonzeros in row i,
+C       minus abs (nv (i)) (the diagonal part).  The bound is equal to
+C       the external degree if elen (i) is less than or equal to two.
+C
+C       We also use the term "external degree" for elements e to refer
+C       to |Le \ Lme|.  If e is an element, then degree (e) holds |Le|,
+C       which is the degree of the off-diagonal part of the element e
+C       (not including the diagonal part).
+
+C head: head is used for degree lists.  head (deg) is the first
+C       supervariable in a degree list (all supervariables i in a
+C       degree list deg have the same approximate degree, namely,
+C       deg = degree (i)).  If the list deg is empty then
+C       head (deg) = 0.
+C
+C       During supervariable detection head (hash) also serves as a
+C       pointer to a hash bucket.
+C       If head (hash) .gt. 0, there is a degree list of degree hash.
+C               The hash bucket head pointer is last (head (hash)).
+C       If head (hash) = 0, then the degree list and hash bucket are
+C               both empty.
+C       If head (hash) .lt. 0, then the degree list is empty, and
+C               -head (hash) is the head of the hash bucket.
+C       After supervariable detection is complete, all hash buckets
+C       are empty, and the (last (head (hash)) = 0) condition is
+C       restored for the non-empty degree lists.
+
+C next: next (i) is the supervariable following i in a link list, or
+C       zero if i is the last in the list.  Used for two kinds of
+C       lists:  degree lists and hash buckets (a supervariable can be
+C       in only one kind of list at a time).
+
+C w:    The flag array w determines the status of elements and
+C       variables, and the external degree of elements.
+C
+C       for elements:
+C          if w (e) = 0, then the element e is absorbed
+C          if w (e) .ge. wflg, then w (e) - wflg is the size of
+C               the set |Le \ Lme|, in terms of nonzeros (the
+C               sum of abs (nv (i)) for each principal variable i that
+C               is both in the pattern of element e and NOT in the
+C               pattern of the current pivot element, me).
+C          if wflg .gt. w (e) .gt. 0, then e is not absorbed and has
+C               not yet been seen in the scan of the element lists in
+C               the computation of |Le\Lme| in loop 150 below.
+C
+C       for variables:
+C          during supervariable detection, if w (j) .ne. wflg then j is
+C          not in the pattern of variable i
+C
+C       The w array is initialized by setting w (i) = 1 for all i,
+C       and by setting wflg = 2.  It is reinitialized if wflg becomes
+C       too large (to ensure that wflg+n does not cause integer
+C       overflow).
+
+C-----------------------------------------------------------------------
+C LOCAL INTEGERS:
+C-----------------------------------------------------------------------
+
+        INTEGER DEG, DEGME, DMAX, E, ELENME, ELN, HASH, HMOD, I,
+     $          ILAST, INEXT, J, JLAST, JNEXT, K, KNT1, KNT2, KNT3,
+     $          LENJ, LN, MAXMEM, ME, MEM, MINDEG, NEL, NEWMEM,
+     $          NLEFT, NVI, NVJ, NVPIV, SLENME, WE, WFLG, WNVI, X
+
+C deg:          the degree of a variable or element
+C degme:        size, |Lme|, of the current element, me (= degree (me))
+C dext:         external degree, |Le \ Lme|, of some element e
+C dmax:         largest |Le| seen so far
+C e:            an element
+C elenme:       the length, elen (me), of element list of pivotal var.
+C eln:          the length, elen (...), of an element list
+C hash:         the computed value of the hash function
+C hmod:         the hash function is computed modulo hmod = max (1,n-1)
+C i:            a supervariable
+C ilast:        the entry in a link list preceding i
+C inext:        the entry in a link list following i
+C j:            a supervariable
+C jlast:        the entry in a link list preceding j
+C jnext:        the entry in a link list, or path, following j
+C k:            the pivot order of an element or variable
+C knt1:         loop counter used during element construction
+C knt2:         loop counter used during element construction
+C knt3:         loop counter used during compression
+C lenj:         len (j)
+C ln:           length of a supervariable list
+C maxmem:       amount of memory needed for no compressions
+C me:           current supervariable being eliminated, and the
+C                       current element created by eliminating that
+C                       supervariable
+C mem:          memory in use assuming no compressions have occurred
+C mindeg:       current minimum degree
+C nel:          number of pivots selected so far
+C newmem:       amount of new memory needed for current pivot element
+C nleft:        n - nel, the number of nonpivotal rows/columns remaining
+C nvi:          the number of variables in a supervariable i (= nv (i))
+C nvj:          the number of variables in a supervariable j (= nv (j))
+C nvpiv:        number of pivots in current element
+C slenme:       number of variables in variable list of pivotal variable
+C we:           w (e)
+C wflg:         used for flagging the w array.  See description of iw.
+C wnvi:         wflg - nv (i)
+C x:            either a supervariable or an element
+
+C-----------------------------------------------------------------------
+C LOCAL POINTERS:
+C-----------------------------------------------------------------------
+
+        INTEGER P, P1, P2, P3, PDST, PEND, PJ, PME, PME1, PME2, PN, PSRC
+
+C               Any parameter (pe (...) or pfree) or local variable
+C               starting with "p" (for Pointer) is an index into iw,
+C               and all indices into iw use variables starting with
+C               "p."  The only exception to this rule is the iwlen
+C               input argument.
+
+C p:            pointer into lots of things
+C p1:           pe (i) for some variable i (start of element list)
+C p2:           pe (i) + elen (i) -  1 for some var. i (end of el. list)
+C p3:           index of first supervariable in clean list
+C pdst:         destination pointer, for compression
+C pend:         end of memory to compress
+C pj:           pointer into an element or variable
+C pme:          pointer into the current element (pme1...pme2)
+C pme1:         the current element, me, is stored in iw (pme1...pme2)
+C pme2:         the end of the current element
+C pn:           pointer into a "clean" variable, also used to compress
+C psrc:         source pointer, for compression
+
+C-----------------------------------------------------------------------
+C  FUNCTIONS CALLED:
+C-----------------------------------------------------------------------
+
+        INTRINSIC MAX, MIN, MOD
+
+C=======================================================================
+C  INITIALIZATIONS
+C=======================================================================
+
+        WFLG = 2
+        MINDEG = 1
+        NCMPA = 0
+        NEL = 0
+        HMOD = MAX (1, N-1)
+        DMAX = 0
+        MEM = PFREE - 1
+        MAXMEM = MEM
+	ME = 0
+
+        DO 10 I = 1, N
+           LAST (I) = 0
+           HEAD (I) = 0
+           NV (I) = 1
+           W (I) = 1
+           ELEN (I) = 0
+           DEGREE (I) = LEN (I)
+10         CONTINUE
+
+C       ----------------------------------------------------------------
+C       initialize degree lists and eliminate rows with no off-diag. nz.
+C       ----------------------------------------------------------------
+
+        DO 20 I = 1, N
+
+           DEG = DEGREE (I)
+
+           IF (DEG .GT. 0) THEN
+
+C             ----------------------------------------------------------
+C             place i in the degree list corresponding to its degree
+C             ----------------------------------------------------------
+
+              INEXT = HEAD (DEG)
+              IF (INEXT .NE. 0) LAST (INEXT) = I
+              NEXT (I) = INEXT
+              HEAD (DEG) = I
+
+           ELSE
+
+C             ----------------------------------------------------------
+C             we have a variable that can be eliminated at once because
+C             there is no off-diagonal non-zero in its row.
+C             ----------------------------------------------------------
+
+              NEL = NEL + 1
+              ELEN (I) = -NEL
+              PE (I) = 0
+              W (I) = 0
+
+              ENDIF
+
+20         CONTINUE
+
+C=======================================================================
+C  WHILE (selecting pivots) DO
+C=======================================================================
+
+30      CONTINUE
+        IF (NEL .LT. N) THEN
+
+C=======================================================================
+C  GET PIVOT OF MINIMUM DEGREE
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          find next supervariable for elimination
+C          -------------------------------------------------------------
+
+           DO 40 DEG = MINDEG, N
+              ME = HEAD (DEG)
+              IF (ME .GT. 0) GOTO 50
+40            CONTINUE
+50         CONTINUE
+           MINDEG = DEG
+
+C          -------------------------------------------------------------
+C          remove chosen variable from link list
+C          -------------------------------------------------------------
+
+           INEXT = NEXT (ME)
+           IF (INEXT .NE. 0) LAST (INEXT) = 0
+           HEAD (DEG) = INEXT
+
+C          -------------------------------------------------------------
+C          me represents the elimination of pivots nel+1 to nel+nv(me).
+C          place me itself as the first in this set.  It will be moved
+C          to the nel+nv(me) position when the permutation vectors are
+C          computed.
+C          -------------------------------------------------------------
+
+           ELENME = ELEN (ME)
+           ELEN (ME) = - (NEL + 1)
+           NVPIV = NV (ME)
+           NEL = NEL + NVPIV
+
+C=======================================================================
+C  CONSTRUCT NEW ELEMENT
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          At this point, me is the pivotal supervariable.  It will be
+C          converted into the current element.  Scan list of the
+C          pivotal supervariable, me, setting tree pointers and
+C          constructing new list of supervariables for the new element,
+C          me.  p is a pointer to the current position in the old list.
+C          -------------------------------------------------------------
+
+C          flag the variable "me" as being in Lme by negating nv (me)
+           NV (ME) = -NVPIV
+           DEGME = 0
+
+           IF (ELENME .EQ. 0) THEN
+
+C             ----------------------------------------------------------
+C             construct the new element in place
+C             ----------------------------------------------------------
+
+              PME1 = PE (ME)
+              PME2 = PME1 - 1
+
+              DO 60 P = PME1, PME1 + LEN (ME) - 1
+                 I = IW (P)
+                 NVI = NV (I)
+                 IF (NVI .GT. 0) THEN
+
+C                   ----------------------------------------------------
+C                   i is a principal variable not yet placed in Lme.
+C                   store i in new list
+C                   ----------------------------------------------------
+
+                    DEGME = DEGME + NVI
+C                   flag i as being in Lme by negating nv (i)
+                    NV (I) = -NVI
+                    PME2 = PME2 + 1
+                    IW (PME2) = I
+
+C                   ----------------------------------------------------
+C                   remove variable i from degree list.
+C                   ----------------------------------------------------
+
+                    ILAST = LAST (I)
+                    INEXT = NEXT (I)
+                    IF (INEXT .NE. 0) LAST (INEXT) = ILAST
+                    IF (ILAST .NE. 0) THEN
+                       NEXT (ILAST) = INEXT
+                    ELSE
+C                      i is at the head of the degree list
+                       HEAD (DEGREE (I)) = INEXT
+                       ENDIF
+
+                    ENDIF
+60               CONTINUE
+C             this element takes no new memory in iw:
+              NEWMEM = 0
+
+           ELSE
+
+C             ----------------------------------------------------------
+C             construct the new element in empty space, iw (pfree ...)
+C             ----------------------------------------------------------
+
+              P = PE (ME)
+              PME1 = PFREE
+              SLENME = LEN (ME) - ELENME
+
+              DO 120 KNT1 = 1, ELENME + 1
+
+                 IF (KNT1 .GT. ELENME) THEN
+C                   search the supervariables in me.
+                    E = ME
+                    PJ = P
+                    LN = SLENME
+                 ELSE
+C                   search the elements in me.
+                    E = IW (P)
+                    P = P + 1
+                    PJ = PE (E)
+                    LN = LEN (E)
+                    ENDIF
+
+C                -------------------------------------------------------
+C                search for different supervariables and add them to the
+C                new list, compressing when necessary. this loop is
+C                executed once for each element in the list and once for
+C                all the supervariables in the list.
+C                -------------------------------------------------------
+
+                 DO 110 KNT2 = 1, LN
+                    I = IW (PJ)
+                    PJ = PJ + 1
+                    NVI = NV (I)
+                    IF (NVI .GT. 0) THEN
+
+C                      -------------------------------------------------
+C                      compress iw, if necessary
+C                      -------------------------------------------------
+
+                       IF (PFREE .GT. IWLEN) THEN
+C                         prepare for compressing iw by adjusting
+C                         pointers and lengths so that the lists being
+C                         searched in the inner and outer loops contain
+C                         only the remaining entries.
+
+                          PE (ME) = P
+                          LEN (ME) = LEN (ME) - KNT1
+                          IF (LEN (ME) .EQ. 0) THEN
+C                            nothing left of supervariable me
+                             PE (ME) = 0
+                             ENDIF
+                          PE (E) = PJ
+                          LEN (E) = LN - KNT2
+                          IF (LEN (E) .EQ. 0) THEN
+C                            nothing left of element e
+                             PE (E) = 0
+                             ENDIF
+
+                          NCMPA = NCMPA + 1
+C                         store first item in pe
+C                         set first entry to -item
+                          DO 70 J = 1, N
+                             PN = PE (J)
+                             IF (PN .GT. 0) THEN
+                                PE (J) = IW (PN)
+                                IW (PN) = -J
+                                ENDIF
+70                           CONTINUE
+
+C                         psrc/pdst point to source/destination
+                          PDST = 1
+                          PSRC = 1
+                          PEND = PME1 - 1
+
+C                         while loop:
+80                        CONTINUE
+                          IF (PSRC .LE. PEND) THEN
+C                            search for next negative entry
+                             J = -IW (PSRC)
+                             PSRC = PSRC + 1
+                             IF (J .GT. 0) THEN
+                                IW (PDST) = PE (J)
+                                PE (J) = PDST
+                                PDST = PDST + 1
+C                               copy from source to destination
+                                LENJ = LEN (J)
+                                DO 90 KNT3 = 0, LENJ - 2
+                                   IW (PDST + KNT3) = IW (PSRC + KNT3)
+90                                 CONTINUE
+                                PDST = PDST + LENJ - 1
+                                PSRC = PSRC + LENJ - 1
+                                ENDIF
+                             GOTO 80
+                             ENDIF
+
+C                         move the new partially-constructed element
+                          P1 = PDST
+                          DO 100 PSRC = PME1, PFREE - 1
+                             IW (PDST) = IW (PSRC)
+                             PDST = PDST + 1
+100                          CONTINUE
+                          PME1 = P1
+                          PFREE = PDST
+                          PJ = PE (E)
+                          P = PE (ME)
+                          ENDIF
+
+C                      -------------------------------------------------
+C                      i is a principal variable not yet placed in Lme
+C                      store i in new list
+C                      -------------------------------------------------
+
+                       DEGME = DEGME + NVI
+C                      flag i as being in Lme by negating nv (i)
+                       NV (I) = -NVI
+                       IW (PFREE) = I
+                       PFREE = PFREE + 1
+
+C                      -------------------------------------------------
+C                      remove variable i from degree link list
+C                      -------------------------------------------------
+
+                       ILAST = LAST (I)
+                       INEXT = NEXT (I)
+                       IF (INEXT .NE. 0) LAST (INEXT) = ILAST
+                       IF (ILAST .NE. 0) THEN
+                          NEXT (ILAST) = INEXT
+                       ELSE
+C                         i is at the head of the degree list
+                          HEAD (DEGREE (I)) = INEXT
+                          ENDIF
+
+                       ENDIF
+110                 CONTINUE
+
+                 IF (E .NE. ME) THEN
+C                   set tree pointer and flag to indicate element e is
+C                   absorbed into new element me (the parent of e is me)
+                    PE (E) = -ME
+                    W (E) = 0
+                    ENDIF
+120              CONTINUE
+
+              PME2 = PFREE - 1
+C             this element takes newmem new memory in iw (possibly zero)
+              NEWMEM = PFREE - PME1
+              MEM = MEM + NEWMEM
+              MAXMEM = MAX (MAXMEM, MEM)
+              ENDIF
+
+C          -------------------------------------------------------------
+C          me has now been converted into an element in iw (pme1..pme2)
+C          -------------------------------------------------------------
+
+C          degme holds the external degree of new element
+           DEGREE (ME) = DEGME
+           PE (ME) = PME1
+           LEN (ME) = PME2 - PME1 + 1
+
+C          -------------------------------------------------------------
+C          make sure that wflg is not too large.  With the current
+C          value of wflg, wflg+n must not cause integer overflow
+C          -------------------------------------------------------------
+
+           IF (WFLG + N .LE. WFLG) THEN
+              DO 130 X = 1, N
+                 IF (W (X) .NE. 0) W (X) = 1
+130              CONTINUE
+              WFLG = 2
+              ENDIF
+
+C=======================================================================
+C  COMPUTE (w (e) - wflg) = |Le\Lme| FOR ALL ELEMENTS
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          Scan 1:  compute the external degrees of previous elements
+C          with respect to the current element.  That is:
+C               (w (e) - wflg) = |Le \ Lme|
+C          for each element e that appears in any supervariable in Lme.
+C          The notation Le refers to the pattern (list of
+C          supervariables) of a previous element e, where e is not yet
+C          absorbed, stored in iw (pe (e) + 1 ... pe (e) + iw (pe (e))).
+C          The notation Lme refers to the pattern of the current element
+C          (stored in iw (pme1..pme2)).   If (w (e) - wflg) becomes
+C          zero, then the element e will be absorbed in scan 2.
+C          -------------------------------------------------------------
+
+           DO 150 PME = PME1, PME2
+              I = IW (PME)
+              ELN = ELEN (I)
+              IF (ELN .GT. 0) THEN
+C                note that nv (i) has been negated to denote i in Lme:
+                 NVI = -NV (I)
+                 WNVI = WFLG - NVI
+                 DO 140 P = PE (I), PE (I) + ELN - 1
+                    E = IW (P)
+                    WE = W (E)
+                    IF (WE .GE. WFLG) THEN
+C                      unabsorbed element e has been seen in this loop
+                       WE = WE - NVI
+                    ELSE IF (WE .NE. 0) THEN
+C                      e is an unabsorbed element
+C                      this is the first we have seen e in all of Scan 1
+                       WE = DEGREE (E) + WNVI
+                       ENDIF
+                    W (E) = WE
+140                 CONTINUE
+                 ENDIF
+150           CONTINUE
+
+C=======================================================================
+C  DEGREE UPDATE AND ELEMENT ABSORPTION
+C=======================================================================
+
+C          -------------------------------------------------------------
+C          Scan 2:  for each i in Lme, sum up the degree of Lme (which
+C          is degme), plus the sum of the external degrees of each Le
+C          for the elements e appearing within i, plus the
+C          supervariables in i.  Place i in hash list.
+C          -------------------------------------------------------------
+
+           DO 180 PME = PME1, PME2
+              I = IW (PME)
+              P1 = PE (I)
+              P2 = P1 + ELEN (I) - 1
+              PN = P1
+              HASH = 0
+              DEG = 0
+
+C             ----------------------------------------------------------
+C             scan the element list associated with supervariable i
+C             ----------------------------------------------------------
+
+C             UMFPACK/MA38-style approximate degree:
+              DO 160 P = P1, P2
+                 E = IW (P)
+                 WE = W (E)
+                 IF (WE .NE. 0) THEN
+C                   e is an unabsorbed element
+                    DEG = DEG + WE - WFLG
+                    IW (PN) = E
+                    PN = PN + 1
+                    HASH = HASH + E
+                    ENDIF
+160              CONTINUE
+
+C             count the number of elements in i (including me):
+              ELEN (I) = PN - P1 + 1
+
+C             ----------------------------------------------------------
+C             scan the supervariables in the list associated with i
+C             ----------------------------------------------------------
+
+              P3 = PN
+              DO 170 P = P2 + 1, P1 + LEN (I) - 1
+                 J = IW (P)
+                 NVJ = NV (J)
+                 IF (NVJ .GT. 0) THEN
+C                   j is unabsorbed, and not in Lme.
+C                   add to degree and add to new list
+                    DEG = DEG + NVJ
+                    IW (PN) = J
+                    PN = PN + 1
+                    HASH = HASH + J
+                    ENDIF
+170              CONTINUE
+
+C             ----------------------------------------------------------
+C             update the degree and check for mass elimination
+C             ----------------------------------------------------------
+
+              IF (ELEN (I) .EQ. 1 .AND. P3 .EQ. PN) THEN
+
+C                -------------------------------------------------------
+C                mass elimination
+C                -------------------------------------------------------
+
+C                There is nothing left of this node except for an
+C                edge to the current pivot element.  elen (i) is 1,
+C                and there are no variables adjacent to node i.
+C                Absorb i into the current pivot element, me.
+
+                 PE (I) = -ME
+                 NVI = -NV (I)
+                 DEGME = DEGME - NVI
+                 NVPIV = NVPIV + NVI
+                 NEL = NEL + NVI
+                 NV (I) = 0
+                 ELEN (I) = 0
+
+              ELSE
+
+C                -------------------------------------------------------
+C                update the upper-bound degree of i
+C                -------------------------------------------------------
+
+C                the following degree does not yet include the size
+C                of the current element, which is added later:
+                 DEGREE (I) = MIN (DEGREE (I), DEG)
+
+C                -------------------------------------------------------
+C                add me to the list for i
+C                -------------------------------------------------------
+
+C                move first supervariable to end of list
+                 IW (PN) = IW (P3)
+C                move first element to end of element part of list
+                 IW (P3) = IW (P1)
+C                add new element to front of list.
+                 IW (P1) = ME
+C                store the new length of the list in len (i)
+                 LEN (I) = PN - P1 + 1
+
+C                -------------------------------------------------------
+C                place in hash bucket.  Save hash key of i in last (i).
+C                -------------------------------------------------------
+
+                 HASH = MOD (HASH, HMOD) + 1
+                 J = HEAD (HASH)
+                 IF (J .LE. 0) THEN
+C                   the degree list is empty, hash head is -j
+                    NEXT (I) = -J
+                    HEAD (HASH) = -I
+                 ELSE
+C                   degree list is not empty
+C                   use last (head (hash)) as hash head
+                    NEXT (I) = LAST (J)
+                    LAST (J) = I
+                    ENDIF
+                 LAST (I) = HASH
+                 ENDIF
+180           CONTINUE
+
+           DEGREE (ME) = DEGME
+
+C          -------------------------------------------------------------
+C          Clear the counter array, w (...), by incrementing wflg.
+C          -------------------------------------------------------------
+
+           DMAX = MAX (DMAX, DEGME)
+           WFLG = WFLG + DMAX
+
+C          make sure that wflg+n does not cause integer overflow
+           IF (WFLG + N .LE. WFLG) THEN
+              DO 190 X = 1, N
+                 IF (W (X) .NE. 0) W (X) = 1
+190              CONTINUE
+              WFLG = 2
+              ENDIF
+C          at this point, w (1..n) .lt. wflg holds
+
+C=======================================================================
+C  SUPERVARIABLE DETECTION
+C=======================================================================
+
+           DO 250 PME = PME1, PME2
+              I = IW (PME)
+              IF (NV (I) .LT. 0) THEN
+C                i is a principal variable in Lme
+
+C                -------------------------------------------------------
+C                examine all hash buckets with 2 or more variables.  We
+C                do this by examing all unique hash keys for super-
+C                variables in the pattern Lme of the current element, me
+C                -------------------------------------------------------
+
+                 HASH = LAST (I)
+C                let i = head of hash bucket, and empty the hash bucket
+                 J = HEAD (HASH)
+                 IF (J .EQ. 0) GOTO 250
+                 IF (J .LT. 0) THEN
+C                   degree list is empty
+                    I = -J
+                    HEAD (HASH) = 0
+                 ELSE
+C                   degree list is not empty, restore last () of head
+                    I = LAST (J)
+                    LAST (J) = 0
+                    ENDIF
+                 IF (I .EQ. 0) GOTO 250
+
+C                while loop:
+200              CONTINUE
+                 IF (NEXT (I) .NE. 0) THEN
+
+C                   ----------------------------------------------------
+C                   this bucket has one or more variables following i.
+C                   scan all of them to see if i can absorb any entries
+C                   that follow i in hash bucket.  Scatter i into w.
+C                   ----------------------------------------------------
+
+                    LN = LEN (I)
+                    ELN = ELEN (I)
+C                   do not flag the first element in the list (me)
+                    DO 210 P = PE (I) + 1, PE (I) + LN - 1
+                       W (IW (P)) = WFLG
+210                    CONTINUE
+
+C                   ----------------------------------------------------
+C                   scan every other entry j following i in bucket
+C                   ----------------------------------------------------
+
+                    JLAST = I
+                    J = NEXT (I)
+
+C                   while loop:
+220                 CONTINUE
+                    IF (J .NE. 0) THEN
+
+C                      -------------------------------------------------
+C                      check if j and i have identical nonzero pattern
+C                      -------------------------------------------------
+
+                       IF (LEN (J) .NE. LN) THEN
+C                         i and j do not have same size data structure
+                          GOTO 240
+                          ENDIF
+                       IF (ELEN (J) .NE. ELN) THEN
+C                         i and j do not have same number of adjacent el
+                          GOTO 240
+                          ENDIF
+C                      do not flag the first element in the list (me)
+                       DO 230 P = PE (J) + 1, PE (J) + LN - 1
+                          IF (W (IW (P)) .NE. WFLG) THEN
+C                            an entry (iw(p)) is in j but not in i
+                             GOTO 240
+                             ENDIF
+230                       CONTINUE
+
+C                      -------------------------------------------------
+C                      found it!  j can be absorbed into i
+C                      -------------------------------------------------
+
+                       PE (J) = -I
+C                      both nv (i) and nv (j) are negated since they
+C                      are in Lme, and the absolute values of each
+C                      are the number of variables in i and j:
+                       NV (I) = NV (I) + NV (J)
+                       NV (J) = 0
+                       ELEN (J) = 0
+C                      delete j from hash bucket
+                       J = NEXT (J)
+                       NEXT (JLAST) = J
+                       GOTO 220
+
+C                      -------------------------------------------------
+240                    CONTINUE
+C                      j cannot be absorbed into i
+C                      -------------------------------------------------
+
+                       JLAST = J
+                       J = NEXT (J)
+                       GOTO 220
+                       ENDIF
+
+C                   ----------------------------------------------------
+C                   no more variables can be absorbed into i
+C                   go to next i in bucket and clear flag array
+C                   ----------------------------------------------------
+
+                    WFLG = WFLG + 1
+                    I = NEXT (I)
+                    IF (I .NE. 0) GOTO 200
+                    ENDIF
+                 ENDIF
+250           CONTINUE
+
+C=======================================================================
+C  RESTORE DEGREE LISTS AND REMOVE NONPRINCIPAL SUPERVAR. FROM ELEMENT
+C=======================================================================
+
+           P = PME1
+           NLEFT = N - NEL
+           DO 260 PME = PME1, PME2
+              I = IW (PME)
+              NVI = -NV (I)
+              IF (NVI .GT. 0) THEN
+C                i is a principal variable in Lme
+C                restore nv (i) to signify that i is principal
+                 NV (I) = NVI
+
+C                -------------------------------------------------------
+C                compute the external degree (add size of current elem)
+C                -------------------------------------------------------
+
+                 DEG = MAX (1, MIN (DEGREE (I) + DEGME-NVI, NLEFT-NVI))
+
+C                -------------------------------------------------------
+C                place the supervariable at the head of the degree list
+C                -------------------------------------------------------
+
+                 INEXT = HEAD (DEG)
+                 IF (INEXT .NE. 0) LAST (INEXT) = I
+                 NEXT (I) = INEXT
+                 LAST (I) = 0
+                 HEAD (DEG) = I
+
+C                -------------------------------------------------------
+C                save the new degree, and find the minimum degree
+C                -------------------------------------------------------
+
+                 MINDEG = MIN (MINDEG, DEG)
+                 DEGREE (I) = DEG
+
+C                -------------------------------------------------------
+C                place the supervariable in the element pattern
+C                -------------------------------------------------------
+
+                 IW (P) = I
+                 P = P + 1
+                 ENDIF
+260           CONTINUE
+
+C=======================================================================
+C  FINALIZE THE NEW ELEMENT
+C=======================================================================
+
+           NV (ME) = NVPIV + DEGME
+C          nv (me) is now the degree of pivot (including diagonal part)
+C          save the length of the list for the new element me
+           LEN (ME) = P - PME1
+           IF (LEN (ME) .EQ. 0) THEN
+C             there is nothing left of the current pivot element
+              PE (ME) = 0
+              W (ME) = 0
+              ENDIF
+           IF (NEWMEM .NE. 0) THEN
+C             element was not constructed in place: deallocate part
+C             of it (final size is less than or equal to newmem,
+C             since newly nonprincipal variables have been removed).
+              PFREE = P
+              MEM = MEM - NEWMEM + LEN (ME)
+              ENDIF
+
+C=======================================================================
+C          END WHILE (selecting pivots)
+           GOTO 30
+           ENDIF
+C=======================================================================
+
+C=======================================================================
+C  COMPUTE THE PERMUTATION VECTORS
+C=======================================================================
+
+C       ----------------------------------------------------------------
+C       The time taken by the following code is O(n).  At this
+C       point, elen (e) = -k has been done for all elements e,
+C       and elen (i) = 0 has been done for all nonprincipal
+C       variables i.  At this point, there are no principal
+C       supervariables left, and all elements are absorbed.
+C       ----------------------------------------------------------------
+
+C       ----------------------------------------------------------------
+C       compute the ordering of unordered nonprincipal variables
+C       ----------------------------------------------------------------
+
+        DO 290 I = 1, N
+           IF (ELEN (I) .EQ. 0) THEN
+
+C             ----------------------------------------------------------
+C             i is an un-ordered row.  Traverse the tree from i until
+C             reaching an element, e.  The element, e, was the
+C             principal supervariable of i and all nodes in the path
+C             from i to when e was selected as pivot.
+C             ----------------------------------------------------------
+
+              J = -PE (I)
+C             while (j is a variable) do:
+270           CONTINUE
+              IF (ELEN (J) .GE. 0) THEN
+                 J = -PE (J)
+                 GOTO 270
+                 ENDIF
+              E = J
+
+C             ----------------------------------------------------------
+C             get the current pivot ordering of e
+C             ----------------------------------------------------------
+
+              K = -ELEN (E)
+
+C             ----------------------------------------------------------
+C             traverse the path again from i to e, and compress the
+C             path (all nodes point to e).  Path compression allows
+C             this code to compute in O(n) time.  Order the unordered
+C             nodes in the path, and place the element e at the end.
+C             ----------------------------------------------------------
+
+              J = I
+C             while (j is a variable) do:
+280           CONTINUE
+              IF (ELEN (J) .GE. 0) THEN
+                 JNEXT = -PE (J)
+                 PE (J) = -E
+                 IF (ELEN (J) .EQ. 0) THEN
+C                   j is an unordered row
+                    ELEN (J) = K
+                    K = K + 1
+                    ENDIF
+                 J = JNEXT
+                 GOTO 280
+                 ENDIF
+C             leave elen (e) negative, so we know it is an element
+              ELEN (E) = -K
+              ENDIF
+290        CONTINUE
+
+C       ----------------------------------------------------------------
+C       reset the inverse permutation (elen (1..n)) to be positive,
+C       and compute the permutation (last (1..n)).
+C       ----------------------------------------------------------------
+
+        DO 300 I = 1, N
+           K = ABS (ELEN (I))
+           LAST (K) = I
+           ELEN (I) = K
+300        CONTINUE
+
+C=======================================================================
+C  RETURN THE MEMORY USAGE IN IW
+C=======================================================================
+
+C       If maxmem is less than or equal to iwlen, then no compressions
+C       occurred, and iw (maxmem+1 ... iwlen) was unused.  Otherwise
+C       compressions did occur, and iwlen would have had to have been
+C       greater than or equal to maxmem for no compressions to occur.
+C       Return the value of maxmem in the pfree argument.
+
+        PFREE = MAXMEM
+
+        RETURN
+        END
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/ChangeLog b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/ChangeLog
new file mode 100644
index 0000000000000000000000000000000000000000..f454b151e673d3652128f661b899bd6d969a5a1f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/ChangeLog
@@ -0,0 +1,83 @@
+May 4, 2016: version 1.2.6
+
+    * minor changes to Makefile
+
+Apr 1, 2016: version 1.2.5
+
+    * licensing simplified (no other change); refer to BTF/Doc/License.txt
+
+Feb 1, 2016: version 1.2.4
+
+    * update to Makefiles
+
+Jan 30, 2016: version 1.2.3
+
+    * modifications to Makefiles
+
+Jan 1, 2016: version 1.2.2
+
+    * modified Makefile to create shared libraries
+        No change to C code except version number
+
+Oct 10, 2014: version 1.2.1
+
+    modified MATLAB/btf_make.m.  No change to C code except version number.
+
+Jun 1, 2012: version 1.2.0
+
+    * changed from UFconfig to SuiteSparse_config
+
+Dec 7, 2011: version 1.1.3
+
+    * fixed the Makefile to better align with CFLAGS and other standards
+
+Jan 25, 2011: version 1.1.2
+
+    * minor fix to "make install"
+
+Nov 30, 2009: version 1.1.1
+
+    * added "make install" and "make uninstall"
+
+Mar 24, 2009: version 1.1.0
+
+    * tabs expanded to 8 spaces; version number updated to stay in sync with KLU
+
+Nov 1, 2007: version 1.0.1
+
+    * trivial change to BTF/MATLAB/btf.c mexFunction: unused variable removed.
+
+May 31, 2007:  version 1.0 released
+
+    * the C application program interface has been modified (see below)
+
+    * maxtrans function renamed to btf_maxtrans
+
+    * strongcomp function renamed to btf_strongcomp
+
+    * full statement coverage tests (KLU/Tcov)
+
+    * maxwork parameter added to btf_maxtrans and btf_order
+
+    * btf_maxtrans modified; now returns Q[i] = -1 if row i is unmatched;
+        code to complete the permutation moved to btf_order.  This also
+        changes the maxtrans mexFunction.
+
+    * btf_install added for easy MATLAB installation
+
+    * illustrative recursive version of maxtrans removed (see the recursive
+        version of cs_maxtrans in CSparse instead)
+
+    * MAXTRANS_* macros renamed BTF_*
+
+    * no bug fixes in this release
+
+Dec 12, 2006: version 0.11
+
+    * minor MATLAB cleanup
+
+Apr 30, 2006:
+
+    * minor editing of comments.  dmperm.c moved to MATLAB directory, since
+        it requires MATLAB.  Version number not changed.
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/License.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4dfd7f28eac7b52766f1eaa86dafac0913de8029
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/License.txt
@@ -0,0 +1,20 @@
+BTF, Copyright (C) 2004-2013, University of Florida
+by Timothy A. Davis and Ekanathan Palamadai.
+BTF is also available under other licenses; contact authors for details.
+http://www.suitesparse.com
+
+--------------------------------------------------------------------------------
+
+BTF is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+BTF is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this Module; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/lesser.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/lesser.txt
new file mode 100644
index 0000000000000000000000000000000000000000..783bd5e9c7c34348a347537a6b77d2736b801943
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/Doc/lesser.txt
@@ -0,0 +1,504 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Contents.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..bc535b049e947497b05c57a276eda905e256e4b5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Contents.m
@@ -0,0 +1,20 @@
+% BTF ordering toolbox:
+%
+% Primary functions:
+%
+%   btf        - permute a square sparse matrix into upper block triangular form
+%   maxtrans   - permute the columns of a sparse matrix so it has a zero-free diagonal
+%   strongcomp - symmetric permutation to upper block triangular form
+%
+% Other:
+%   btf_install - compile and install BTF for use in MATLAB.
+%   btf_demo    - demo for BTF
+%   drawbtf     - plot the BTF form of a matrix
+%   btf_make    - compile BTF for use in MATLAB
+%
+% Example:
+%   q = maxtrans (A)
+%   [p,q,r] = btf (A)
+%   [p,r] = strongcomp (A)
+
+% Copyright 2004-2007, University of Florida
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/btf_test.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/btf_test.m
new file mode 100644
index 0000000000000000000000000000000000000000..c0ede02b7c7f210ea8d009129fe146fa000c3466
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/btf_test.m
@@ -0,0 +1,19 @@
+function btf_test (nmat)
+%BTF_TEST test for BTF
+% Requires CSparse (or CXSparse) and UFget
+% Example:
+%   btf_test
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5, test6.
+
+if (nargin < 1)
+    nmat = 200 ;
+end
+
+test1 (nmat) ;
+test2 (nmat) ;
+test3 (nmat) ;
+test4 (nmat) ;
+test5 (nmat) ;
+test6 ;
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/checkbtf.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/checkbtf.m
new file mode 100644
index 0000000000000000000000000000000000000000..1ba99dfd7598a72c1d2bcc7033c880b2813e5d35
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/checkbtf.m
@@ -0,0 +1,46 @@
+function checkbtf (A, p, q, r)
+%CHECKBTF ensure A(p,q) is in BTF form
+%
+% A(p,q) is in BTF form, r the block boundaries
+%
+% Example:
+%   [p,q,r] = dmperm (A)
+%   checkbtf (A, p, q, r)
+%
+% See also drawbtf, maxtrans, strongcomp.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+[m n] = size (A) ;
+if (m ~= n)
+    error ('A must be square') ;
+end
+
+if (any (sort (p) ~= 1:n))
+    error ('p not a permutation') ;
+end
+
+if (any (sort (q) ~= 1:n))
+    error ('q not a permutation') ;
+end
+
+nblocks = length (r) - 1 ;
+
+if (r (1) ~= 1)
+    error ('r(1) not one') ;
+end
+
+if (r (end) ~= n+1)
+    error ('r(end) not n+1') ;
+end
+
+if (nblocks < 1 | nblocks > n)                                              %#ok
+    error ('nblocks wrong') ;
+end
+
+nblocks = length (r) - 1 ;
+rdiff = r (2:(nblocks+1)) - r (1:nblocks) ;
+if (any (rdiff < 1) | any (rdiff > n))                                      %#ok
+    error ('r bad')
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test1.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test1.m
new file mode 100644
index 0000000000000000000000000000000000000000..e97d1785968e709859ef6565b1f647b146a7d5bb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test1.m
@@ -0,0 +1,141 @@
+function test1 (nmat)
+%TEST1 test for BTF
+% Requires CSparse and UFget
+% Example:
+%   test1
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+index = UFget ;
+% f = find (index.sprank < min (index.nrows, index.ncols)) ;
+f = 1:length (index.nrows) ;
+
+% too much time:
+skip = [1514 1297 1876 1301] ;
+
+f = setdiff (f, skip) ;
+
+[ignore i] = sort (index.nnz (f)) ;
+f = f (i) ;
+
+if (nargin < 1)
+    nmat = 1000 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+T0 = zeros (nmat,1) ;
+T1 = zeros (nmat,1) ;
+Anz = zeros (nmat,1) ;
+MN = zeros (nmat, 2) ;
+Nzdiag = zeros (nmat,1) ;
+clf
+
+% warmup
+p = maxtrans (sparse (1)) ;         %#ok
+p = cs_dmperm (sparse (1)) ;        %#ok
+a = cs_transpose (sparse (1)) ;     %#ok
+
+h = waitbar (0, 'BTF test 1 of 6') ;
+
+try
+
+    for k = 1:nmat
+
+        Prob = UFget (f (k), index) ;
+        A = Prob.A ;
+        clear Prob
+        t = 0 ;
+
+        waitbar (k/nmat, h) ;
+
+        r = full (sum (spones (A), 2)) ;
+        c = full (sum (spones (A))) ;
+        m2 = length (find (r > 0)) ;
+        n2 = length (find (c > 0)) ;
+
+        if (m2 < n2)
+            tic
+            A = cs_transpose (A) ;
+            t = toc ;
+        end
+
+        Nzdiag (k) = nnz (diag (A)) ;
+
+        [m n] = size (A) ;
+        Anz (k) = nnz (A) ;
+        MN (k,:) = [m n] ;
+
+        tic
+        q = maxtrans (A) ;
+        t0 = toc ;
+        s0 = sum (q > 0) ;
+        T0 (k) = max (1e-9, t0) ;
+
+        tic
+        p = cs_dmperm (A) ;
+        t1 = toc ;
+        s1 = sum (p > 0) ;
+        T1 (k) = max (1e-9, t1) ;
+
+        fprintf (...
+            '%4d maxtrans %10.6f %10.6f  cs_dmperm %10.6f m/n %8.2f', ...
+            f(k), t, t0, t1, m/n) ;
+        if (t1 ~= 0)
+            fprintf (' rel: %8.4f', t0 / t1) ;
+        end
+        fprintf ('\n') ;
+        if (s0 ~= s1)
+            error ('!') ;
+        end
+
+        if (s0 == n & m == n)                                               %#ok
+            B = A (:, q) ;
+            subplot (2,2,1) ;
+            cspy (B) ;
+            if (nnz (diag (B)) ~= n)
+                error ('?')
+            end
+            clear B
+        else
+            cspy (0) ;
+        end
+
+        maxnz = nnz (A) ;
+
+        zfree  = find (MN (1:k,1) == MN (1:k,2) & Nzdiag (1:k) == MN(1:k,1)) ;
+        square = find (MN (1:k,1) == MN (1:k,2) & Nzdiag (1:k) ~= MN(1:k,1)) ;
+        tall   = find (MN (1:k,1) >  MN (1:k,2)) ;
+        squat  = find (MN (1:k,1) <  MN (1:k,2)) ;
+
+        subplot (2,2,2) ;
+        loglog (Anz (square), T0 (square) ./ T1 (square), ...
+            'o', [1 maxnz], [1 1], 'r-') ;
+        title ('square') ;
+        subplot (2,2,3) ;
+        loglog (Anz (tall), T0 (tall) ./ T1 (tall), ...
+            'o', [1 maxnz], [1 1], 'r-') ;
+        title ('tall') ;
+        subplot (2,2,4) ;
+        title ('square, intially zero-free') ;
+        loglog (Anz (zfree), T0 (zfree) ./ T1 (zfree), ...
+            'o', [1 maxnz], [1 1], 'r-') ;
+        title ('square, zero-free diag') ;
+
+        drawnow
+
+    end
+
+catch
+    % out-of-memory is OK, other errors are not
+    disp (lasterr) ;
+    if (isempty (strfind (lasterr, 'Out of memory')))
+        error (lasterr) ;                                                   %#ok
+    else
+        fprintf ('test terminated early, but otherwise OK\n') ;
+    end
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test2.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test2.m
new file mode 100644
index 0000000000000000000000000000000000000000..20e1ad68c8017b35010a50a9750eb37d0bf6b0bc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test2.m
@@ -0,0 +1,108 @@
+function test2 (nmat)
+%TEST2 test for BTF
+% Requires CSparse and UFget
+% Example:
+%   test2
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+index = UFget ;
+f = find (index.nrows == index.ncols) ;
+
+% too much time:
+skip = [1514 1297 1876 1301] ;
+f = setdiff (f, skip) ;
+
+[ignore i] = sort (index.nnz (f)) ;
+f = f (i) ;
+
+if (nargin < 1)
+    nmat = 1000 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+T0 = zeros (nmat,1) ;
+T1 = zeros (nmat,1) ;
+Anz = zeros (nmat,1) ;
+MN = zeros (nmat, 2) ;
+Nzdiag = zeros (nmat,1) ;
+clf
+
+% warmup
+p = maxtrans (sparse (1)) ;             %#ok
+p = btf (sparse (1)) ;                  %#ok
+p = cs_dmperm (sparse (1)) ;            %#ok
+a = cs_transpose (sparse (1)) ;         %#ok
+
+h = waitbar (0, 'BTF test 2 of 6') ;
+
+try
+    for k = 1:nmat
+
+        Prob = UFget (f (k), index) ;
+        A = Prob.A ;
+
+        waitbar (k/nmat, h) ;
+
+        Nzdiag (k) = nnz (diag (A)) ;
+
+        [m n] = size (A) ;
+        Anz (k) = nnz (A) ;
+        MN (k,:) = [m n] ;
+
+        tic
+        [p,q,r] = btf (A) ;
+        t0 = toc ;
+        s0 = sum (q > 0) ;
+        T0 (k) = max (1e-9, t0) ;
+
+        tic
+        [p2,q2,r2] = cs_dmperm (A) ;
+        t1 = toc ;
+        s1 = sum (dmperm (A) > 0) ;
+        T1 (k) = max (1e-9, t1) ;
+
+        fprintf ('%4d btf %10.6f cs_dmperm %10.6f', f(k), t0, t1) ;
+        if (t1 ~= 0)
+            fprintf (' rel: %8.4f', t0 / t1) ;
+        end
+        fprintf ('\n') ;
+
+        if (s0 ~= s1)
+            error ('!') ;
+        end
+
+        C = A (p, abs (q)) ;
+        subplot (1,2,1) ;
+        cspy (C) ;
+        z = find (q < 0) ;
+        zd = nnz (diag (C (z,z))) ;
+        if (zd > 0)
+            error ('?') ;
+        end
+
+        minnz = Anz (1) ;
+        maxnz = nnz (A) ;
+
+        subplot (1,2,2) ;
+        loglog (Anz (1:k), T0 (1:k) ./ T1 (1:k), ...
+            'o', [minnz maxnz], [1 1], 'r-') ;
+        drawnow
+
+        clear C A Prob
+    end
+
+catch
+    % out-of-memory is OK, other errors are not
+    disp (lasterr) ;
+    if (isempty (strfind (lasterr, 'Out of memory')))
+        error (lasterr) ;                                                   %#ok
+    else
+        fprintf ('test terminated early, but otherwise OK\n') ;
+    end
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test3.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test3.m
new file mode 100644
index 0000000000000000000000000000000000000000..408033aabfbcb0f9f04d58f89a7ca6e871b4ee08
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test3.m
@@ -0,0 +1,527 @@
+function test3 (nmat)
+%TEST3 test for BTF
+% Requires UFget
+% Example:
+%   test3
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+doplot = 1 ;
+dopause = 0 ;
+dostrong = 1 ;
+
+index = UFget ;
+f = find (index.nrows == index.ncols) ;
+[ignore i] = sort (index.nnz (f)) ;
+f = f (i) ;
+clear i
+
+% short test set: seg faults, lots of blocks, lots of work, and so on:
+nasty = [
+        % --- various test matrices (no seg fault, quick run time)
+    -(1:8)'  % generated matrices
+    904 % vanHeukelum/cage3 (5-by-5)
+    819 % Simon/raefsky6 (permuted triangular matrix)
+        %
+        % --- older seg faults:
+    264 % HB/west0156, causes older strongcomp_recursive to fail
+    824 % TOKAMAK/utm300 (300-by-300), causes older code to fail
+    868 % Pothen/bodyy4
+        %
+        % --- seg faults in old MATLAB dmperm
+    290 % Averous/epb3
+    983 % Sanghavi/ecl32
+    885 % Pothen/tandem_dual
+    879 % Pothen/onera_dual
+    955 % Schenk_IBMSDS/2D_54019_highK
+    957 % Schenk_IBMSDS/3D_51448_3D
+    958 % Schenk_IBMSDS/ibm_matrix_2
+    912 % vanHeukelum/cage11
+    924 % Andrews/Andrews
+    960 % Schenk_IBMSDS/matrix-new_3
+    862 % Kim/kim1
+    544 % Hamm/scircuit
+    897 % Norris/torso2
+    801 % Ronis/xenon1
+     53 % HB/bcsstk31
+    958 % Schenk_IBMSDS/matrix_9
+    844 % Cunningham/qa8fk
+    845 % Cunningham/qa8fk
+    821 % Simon/venkat25
+    822 % Simon/venkat50
+    820 % Simon/venkat01
+    812 % Simon/bbmat
+    804 % Rothberg/cfd1
+     54 % HB/bcsstk32
+    913 % vanHeukelum/cage12
+    846 % Boeing/bcsstk39
+    972 % Schenk_IBMSDS/para-10
+    974 % Schenk_IBMSDS/para-5
+    975 % Schenk_IBMSDS/para-6
+    976 % Schenk_IBMSDS/para-7
+    977 % Schenk_IBMSDS/para-8
+    978 % Schenk_IBMSDS/para-9
+    961 % Schenk_ISEI/barrier2-10
+    962 % Schenk_ISEI/barrier2-11
+    963 % Schenk_ISEI/barrier2-12
+    964 % Schenk_ISEI/barrier2-1
+    965 % Schenk_ISEI/barrier2-2
+    966 % Schenk_ISEI/barrier2-3
+    967 % Schenk_ISEI/barrier2-4
+    968 % Schenk_ISEI/barrier2-9
+    851 % Chen/pkustk05
+    979 % Kamvar/Stanford
+    374 % Bova/rma10
+        %
+        % --- lots of time:
+    395 % DRIVCAV/cavity16
+    396 % DRIVCAV/cavity17
+    397 % DRIVCAV/cavity18
+    398 % DRIVCAV/cavity19
+    399 % DRIVCAV/cavity20
+    400 % DRIVCAV/cavity21
+    401 % DRIVCAV/cavity22
+    402 % DRIVCAV/cavity23
+    403 % DRIVCAV/cavity24
+    404 % DRIVCAV/cavity25
+    405 % DRIVCAV/cavity26
+    1109 % Sandia/mult_dcop_01
+    1110 % Sandia/mult_dcop_02
+    1111 % Sandia/mult_dcop_03
+    376 % Brethour/coater2
+    284 % ATandT/onetone2
+    588 % Hollinger/mark3jac100
+    589 % Hollinger/mark3jac100sc
+    452 % Grund/bayer01
+    920 % Hohn/sinc12
+    590 % Hollinger/mark3jac120
+    591 % Hollinger/mark3jac120sc
+    809 % Shyy/shyy161
+    448 % Graham/graham1
+    283 % ATandT/onetone1
+    445 % Garon/garon2
+    541 % Hamm/bcircuit
+    592 % Hollinger/mark3jac140
+    593 % Hollinger/mark3jac140sc
+    435 % FIDAP/ex40
+    912 % Hohn/sinc15
+    894 % Norris/lung2
+    542 % Hamm/hcircuit
+    752 % Mulvey/finan512
+    753 % Mulvey/pfinan512
+    564 % Hollinger/g7jac180
+    565 % Hollinger/g7jac180sc
+    566 % Hollinger/g7jac200
+    567 % Hollinger/g7jac200sc
+    748 % Mallya/lhr34
+    749 % Mallya/lhr34c
+    922 % Hohn/sinc18
+    447 % Goodwin/rim
+    807 % Rothberg/struct3
+    286 % ATandT/twotone
+    982 % Tromble/language
+    953 % Schenk_IBMNA/c-73
+    890 % Norris/heart1
+    750 % Mallya/lhr71
+    751 % Mallya/lhr71c
+    925 % FEMLAB/ns3Da
+    827 % Vavasis/av41092
+    931 % FEMLAB/sme3Db
+   1297 % GHS_index/boyd2
+   1301 % GHS_indef/cont-300
+        %
+        % --- lots of time, and seg faults:
+    285 % ATandT/pre2
+        % --- huge matrix, turn off plotting
+    940 % Shenk/af_shell1, memory leak in plot, after call to btf, once.
+        % ----
+]' ;
+
+% maxtrans_recursive causes a seg fault on these matrices, because of
+% stack overflow (this is expected)
+skip_list_maxtrans_recursive = 285 ;
+
+% p = dmperm (A) in MATLAB 7.4 causes a seg fault on these matrices:
+skip_list_dmperm = [285 1301 1231 1251 1232 1241] ;
+
+% [p,q,r] = dmperm (A) in MATLAB 7.4 causes a seg fault on these matrices:
+skip_list_dmperm_btf = ...
+[    285 879 885 290 955 957 958     924 960         897        959 844 845 ...
+ 821 822 820     804    913 846 972 974:978 961:968  979 940 ...
+ 1422 1513 1412 1510 1301 1231 1251 1434 1213 1232 1241 1357 1579 1431 1281] ;
+% length(skip_list_dmperm_btf)
+
+% time intensive
+skip_costly = [1514 1297 1876 1301] ;
+
+% strongcomp (recursive) causes a seg fault on these matrices because of
+% stack overflow (this is expected).
+skip_list_strongcomp_recursive     = ...
+[983 285 879 885 290 955 957 958 912 924 960 862 544 897 801 53 959 844 845 ...
+ 821 822 820 812 804 54 913 846 972 974:978 961:968 851     374 940] ;
+skip_list_strongcomp_recursive     = ...
+[ skip_list_strongcomp_recursive 592 593 752 753 807 286 982 855 566 567 ] ;
+
+% matrices with the largest # of nonzeros in the set (untested)
+toobig = [
+928   853   852   356   761   368   973   895   805   849   932 ...
+803   854   936   802   850   537   856   898   857   859   971   937 ...
+914   858   980   896   806   538   863   369   938   860   941   942 ...
+943   944   945   946   947   948   915   939   916 ] ;
+
+f = [ -(1:8) f ] ;
+% f = nasty ;
+
+h = waitbar (0, 'BTF test 3 of 6') ;
+
+if (nargin < 1)
+    nmat = 1000 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+try
+
+    for matnum = 1:nmat
+
+        waitbar (matnum/nmat, h) ;
+
+        j = f (matnum) ;
+
+        if (any (j == toobig) | any (j == skip_costly))                     %#ok
+            fprintf ('\n%4d: %3d %s/%s too big\n', ...
+                matnum, j, index.Group{j}, index.Name{j}) ;
+            continue ;
+        end
+
+        rand ('state', 0) ;
+
+        % clear all unused variables.
+        % nothing here is left that is proportional to the matrix size
+        clear A p1 p2 p3 q3 r3 match1 match2 match4 pa ra sa qa B C pb rb pc rc
+        clear jumble B11 B12 B13 B21 B22 B23 B31 B32 B33 pjumble qjumble ans
+        clear c kbad kgood
+        % whos
+        % pause
+
+        if (j > 0)
+            Problem = UFget (j, index) ;
+            name = Problem.name ;
+            A = Problem.A ;
+            clear Problem
+        else
+            % construct the jth test matrix
+            j = -j ;
+            if (j == 1 | j == 2)                                            %#ok
+                B11 = UFget ('Grund/b1_ss') ;       % 7-by-7 diagonal block
+                B11 = B11.A ;
+                B12 = sparse (zeros (7,2)) ;
+                B12 (3,2) = 1 ;
+                B13 = sparse (ones  (7,5)) ;
+                B21 = sparse (zeros (2,7)) ;
+                B22 = sparse (ones  (2,2)) ;        % 2-by-2 diagonal block
+                B23 = sparse (ones  (2,5)) ;
+                B31 = sparse (zeros (5,7)) ;
+                B32 = sparse (zeros (5,2)) ;
+                B33 = UFget ('vanHeukelum/cage3') ;    % 5-by-5 diagonal block
+                B33 = B33.A ;
+                A = [ B11 B12 B13 ; B21 B22 B23 ; B31 B32 B33 ] ;
+                name = '(j=1 test matrix)' ;
+            end
+            if (j == 2)
+                pjumble = [ 10 7 11 1 13 12 8 2 5 14 9 6 4 3 ] ;
+                qjumble = [ 3 14 2 11 1 8 5 7 10 12 4 13 9 6 ] ;
+                A = A (pjumble, qjumble) ;
+                name = '(j=2 test matrix)' ;
+            elseif (j == 3)
+                A = sparse (1) ;
+            elseif (j == 4)
+                A = sparse (0) ;
+            elseif (j == 5)
+                A = sparse (ones (2)) ;
+            elseif (j == 6)
+                A = sparse (2,2) ;
+            elseif (j == 7)
+                A = speye (2) ;
+            elseif (j == 8)
+                A = sparse (2,2) ;
+                A (2,1) = 1 ;
+            end
+            if (j > 2)
+                full (A)
+            end
+        end
+
+        [m n] = size (A) ;
+        if (m ~= n)
+            continue ;
+        end
+        fprintf ('\n%4d: ', matnum) ;
+        fprintf (' =========================== Matrix: %3d %s\n', j, name) ;
+        fprintf ('n: %d nz: %d\n', n, nnz (A)) ;
+
+        if (nnz (A) > 6e6)
+            doplot = 0 ;
+        end
+
+        %-----------------------------------------------------------------------
+        % now try maxtrans
+        tic
+        match1 = maxtrans (A) ;
+        t = toc ;
+        s1 = sum (match1 > 0) ;
+        fprintf ('n-sprank: %d\n', n-s1) ;
+        fprintf ('maxtrans:                %8.2f seconds\n', t) ;
+        singular = s1 < n ;
+
+        if (doplot)
+            clf
+            subplot (2,4,1)
+            spy (A)
+            title (name) ;
+        end
+
+        p1 = match1 ;
+        if (any (p1 <= 0))
+            % complete the permutation
+            badrow = find (p1 <= 0) ;
+
+            badcol = ones (1,n) ;
+            badcol (p1 (p1 > 0)) = 0 ;
+            badcol = find (badcol) ;
+
+            p1 (badrow) = badcol ;
+
+            % construct the older form of match1
+            match1 (badrow) = -p1 (badrow) ;
+        end
+        if (any (sort (p1) ~= 1:n))
+            error ('!!') ;
+        end
+
+        B = A (:,p1) ;
+
+        if (doplot)
+            subplot (2,4,2)
+            hold off
+            spy (B)
+            hold on
+            badcol = find (match1 < 0) ;
+            Junk = sparse (badcol, badcol, ones (length (badcol), 1), n, n) ;
+            % if (~isempty (A))
+                % spy (Junk, 'ro') ;
+            % end
+            title ('maxtrans') ;
+        end
+
+        d = nnz (diag (B)) ;
+        if (d ~= s1)
+            error ('bad sprank') ;
+        end
+        clear B
+
+        %-----------------------------------------------------------------------
+        % try p = dmperm(A)
+        skip_dmperm = any (j == skip_list_dmperm) ;
+
+        if (~skip_dmperm)
+            tic
+            match4 = dmperm (A) ;
+            t = toc ;
+            fprintf ('p=dmperm(A):             %8.2f seconds\n', t) ;
+            s4 = sum (match4 > 0) ;
+            singular4 = (s4 < n) ;
+
+            if (doplot)
+                if (~singular4)
+                    subplot (2,4,3)
+                    spy (A (match4,:))
+                    title ('dmperm') ;
+                end
+            end
+            if (singular ~= singular4)
+                error ('s4?') ; 
+            end
+            if (s1 ~= s4)
+                error ('bad sprank') ;
+            end
+        else
+            fprintf ('p=dmperm(A): skip\n') ;
+        end
+
+        %-----------------------------------------------------------------------
+        nblocks = -1 ;
+        skip_dmperm_btf = any (j == skip_list_dmperm_btf) ;
+        if (~skip_dmperm_btf)
+            % get btf form
+            tic
+            [pa,qa,ra,sa] = dmperm (A) ;
+            t = toc ;
+            fprintf ('[p,q,r,s]=dmperm(A):     %8.2f seconds\n', t) ;
+            nblocks = length (ra) - 1 ;
+            fprintf ('nblocks: %d\n', nblocks) ;
+            if (~singular4)
+                checkbtf (A, pa, qa, ra) ;
+                if (doplot)
+                    subplot (2,4,4)
+                    drawbtf (A, pa, qa, ra)
+                    title ('dmperm blocks') 
+                end
+            end
+        else
+            fprintf ('[p,q,r,s]=dmperm(A): skip\n') ;
+        end
+
+        jumble = randperm (n) ;
+
+        %-----------------------------------------------------------------------
+        % try strongcomp, non-recursive version
+
+            %-------------------------------------------------------------------
+            % try strongcomp on original matrix
+            B = A (:,p1) ;
+            tic ;
+            [pb,rb] = strongcomp (B) ;
+            t = toc ;
+            fprintf ('strongcomp               %8.2f seconds\n', t) ;
+            if (~singular & ~skip_dmperm_btf & (length (rb) ~= nblocks+1))  %#ok
+                error ('BTF:invalid (rb)') ;
+            end
+            checkbtf (B, pb, pb, rb) ;
+            if (doplot)
+                subplot (2,4,5)
+                drawbtf (B, pb, pb, rb) ;
+                title ('strongcomp') ;
+            end
+
+            %-------------------------------------------------------------------
+            % try btf on original matrix
+            tic ;
+            [pw,qw,rw] = btf (A) ;
+            t = toc ;
+            fprintf ('btf                      %8.2f seconds nblocks %d\n', ...
+                t, length (rw)-1) ;
+
+            if (any (pw ~= pb))
+                error ('pw') ;
+            end
+            if (any (rw ~= rb))
+                error ('rw') ;
+            end
+            if (any (abs (qw) ~= p1 (pw)))
+                error ('qw') ;
+            end
+            c = diag (A (pw,abs (qw))) ;
+            if (~singular & ~skip_dmperm_btf & (length (rw) ~= nblocks+1))  %#ok
+                error ('BTF:invalid (rw)') ;
+            end
+            checkbtf (A, pw, abs (qw), rw) ;
+
+            kbad  = find (qw < 0) ;
+            kgood = find (qw > 0) ;
+            if (any (c (kbad) ~= 0))
+                error ('kbad') ;
+            end
+            if (any (c (kgood) == 0))       %#ok
+                error ('kgood') ;
+            end
+
+            if (doplot)
+                subplot (2,4,6)
+                drawbtf (A, pw, abs (qw), rw) ;
+                if (n < 500)
+                    for k = kbad
+                        plot ([k (k+1) (k+1) k k]-.5, ...
+                            [k k (k+1) (k+1) k]-.5, 'r') ;
+                    end
+                end
+                title ('btf') ;
+            end
+
+            %-------------------------------------------------------------------
+            % try [p,q,r] = strongcomp (A, qin) form
+            tic
+            [pz,qz,rz] = strongcomp (A, match1) ;
+            t = toc ;
+            fprintf ('[p,q,r]=strongcomp(A,qin)%8.2f seconds\n', t) ;
+            if (any (pz ~= pb))
+                error ('pz') ;
+            end
+            if (any (rz ~= rb))
+                error ('rz') ;
+            end
+            if (any (abs (qz) ~= p1 (pz)))
+                error ('qz') ;
+            end
+            c = diag (A (pz,abs (qz))) ;
+            if (~singular & ~skip_dmperm_btf & (length (rz) ~= nblocks+1))  %#ok
+                error ('BTF:invalid (rz)') ;
+            end
+            checkbtf (A, pz, abs (qz), rz) ;
+
+            kbad  = find (qz < 0) ;
+            kgood = find (qz > 0) ;
+            if (any (c (kbad) ~= 0))
+                error ('kbad') ;
+            end
+            if (any (c (kgood) == 0))                                       %#ok
+                error ('kgood') ;
+            end
+
+            if (doplot)
+                subplot (2,4,7)
+                drawbtf (A, pz, abs (qz), rz) ;
+                if (n < 500)
+                    for k = kbad
+                        plot ([k (k+1) (k+1) k k]-.5, ...
+                            [k k (k+1) (k+1) k]-.5, 'r') ;
+                    end
+                end
+                title ('strongcomp(A,qin)') ;
+            end
+
+            %-------------------------------------------------------------------
+            % try strongcomp again, on a randomly jumbled matrix
+            C = sparse (B (jumble, jumble)) ;
+            tic ;
+            [pc,rc] = strongcomp (C) ;
+            t = toc ;
+            fprintf ('strongcomp       (rand)  %8.2f seconds\n', t) ;
+            if (~singular & ~skip_dmperm_btf & (length (rc) ~= nblocks+1))  %#ok
+                error ('BTF:invalid (rc)') ;
+            end
+            checkbtf (C, pc, pc, rc) ;
+            if (doplot)
+                subplot (2,4,8)
+                drawbtf (C, pc, pc, rc) ;
+                title ('strongcomp(rand)') ;
+            end
+
+            if (length (rc) ~= length (rb))
+                error ('strongcomp random mismatch') ;
+            end
+
+        %-----------------------------------------------------------------------
+        if (doplot)
+            drawnow
+        end
+
+        if (matnum ~= nmat & dopause)                                       %#ok
+            input ('Hit enter: ') ;
+        end
+
+    end
+
+catch
+    % out-of-memory is OK, other errors are not
+    disp (lasterr) ;
+    if (isempty (strfind (lasterr, 'Out of memory')))
+        error (lasterr) ;                                                   %#ok
+    else
+        fprintf ('test terminated early, but otherwise OK\n') ;
+    end
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test4.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test4.m
new file mode 100644
index 0000000000000000000000000000000000000000..c67273ad53c658add5d2edc43bda99992427ca90
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test4.m
@@ -0,0 +1,86 @@
+function test4 (nmat)
+%TEST4 test for BTF
+% Requires UFget
+% Example:
+%   test4
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+index = UFget ;
+f = find (index.nrows == index.ncols) ;
+[ignore i] = sort (index.nnz (f)) ;
+f = f (i) ;
+
+% time intensive
+skip_costly = [1514 1297 1876 1301] ;
+f = setdiff (f, skip_costly) ;
+
+if (nargin < 1)
+    nmat = 1000 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+h = waitbar (0, 'BTF test 4 of 6') ;
+
+try
+    for k = 1:nmat
+
+        Prob = UFget (f (k), index) ;
+        A = Prob.A ;
+
+        waitbar (k/nmat, h) ;
+
+        for tr = [1 -1]
+
+            if (tr == -1)
+                AT = A' ;
+                [m n] = size (A) ;
+                if (m == n)
+                    if (nnz (spones (AT) - spones (A)) == 0)
+                        fprintf ('skip transpose\n') ;
+                        continue ;
+                    end
+                end
+                A = AT ;
+            end
+
+            tic
+            [p1,q1,r1,work1] = btf (A) ;
+            t1 = toc ;
+            n1 = length (r1) - 1 ;
+
+            tic
+            [p2,q2,r2,work2] = btf (A, 10) ;
+            t2 = toc ;
+            n2 = length (r2) - 1 ;
+
+            fprintf (...
+                '%4d %4d : %10.4f %8d  %8g : %10.4f %8d  %8g :', ...
+                k, f(k), t1, n1, work1, t2, n2, work2) ;
+            if (t2 ~= 0)
+                fprintf (' rel %8.4f %8.4f' , t1 / t2, n2 / (max (1, n1))) ;
+            end
+            fprintf ('\n') ;
+
+            if (n1 ~= n2 | work1 ~= work2)                                  %#ok
+                disp (Prob) ;
+                fprintf ('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n') ;
+            end
+
+        end
+    end
+
+catch
+    % out-of-memory is OK, other errors are not
+    disp (lasterr) ;
+    if (isempty (strfind (lasterr, 'Out of memory')))
+        error (lasterr) ;                                                   %#ok
+    else
+        fprintf ('test terminated early, but otherwise OK\n') ;
+    end
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test5.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test5.m
new file mode 100644
index 0000000000000000000000000000000000000000..0118ed4235ea8a36ad4edf585f733d2439c5c614
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test5.m
@@ -0,0 +1,86 @@
+function test5 (nmat)
+%TEST5 test for BTF
+% Requires UFget
+% Example:
+%   test5
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+index = UFget ;
+
+[ignore f] = sort (index.nnz) ;
+
+% time intensive
+skip_costly = [1514 1297 1876 1301] ;
+f = setdiff (f, skip_costly) ;
+
+if (nargin < 1)
+    nmat = 1000 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+h = waitbar (0, 'BTF test 5 of 6') ;
+
+try
+    for k = 1:nmat
+
+        i = f(k) ;
+        Prob = UFget (i, index) ;
+        A = Prob.A ;
+
+        waitbar (k/nmat, h) ;
+
+        for tr = [1 -1]
+
+            if (tr == -1)
+                AT = A' ;
+                [m n] = size (A) ;
+                if (m == n)
+                    if (nnz (spones (AT) - spones (A)) == 0)
+                        fprintf ('skip test with transpose\n') ;
+                        continue ;
+                    end
+                end
+                A = AT ;
+            end
+
+            tic
+            q1 = maxtrans (A) ;
+            t1 = toc ;
+            r1 = sum (q1 > 0) ;
+
+            tic
+            q2 = maxtrans (A, 10) ;
+            t2 = toc ;
+            r2 = sum (q2 > 0) ;
+
+            fprintf (...
+                '%4d %4d : %10.4f %8d  : %10.4f %8d', k, f(k), t1, r1, t2, r2) ;
+            fprintf (' rel sprank %8.4f', r2 / (max (1, r1))) ;
+            if (t2 ~= 0)
+                fprintf (': rel time %8.4f', t1 / t2) ;
+            end
+            fprintf ('\n') ;
+
+            if (r1 ~= r2)
+                disp (Prob) ;
+                fprintf ('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n') ;
+            end
+
+        end
+    end
+
+catch
+    % out-of-memory is OK, other errors are not
+    disp (lasterr) ;
+    if (isempty (strfind (lasterr, 'Out of memory')))
+        error (lasterr) ;                                                   %#ok
+    else
+        fprintf ('test terminated early, but otherwise OK\n') ;
+    end
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test6.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test6.m
new file mode 100644
index 0000000000000000000000000000000000000000..0a643ec775e77369ccac6d8b5cf9e4fa9b5547e7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/Test/test6.m
@@ -0,0 +1,138 @@
+function test6
+%TEST6 test for BTF
+% Requires UFget
+% Example:
+%   test6
+% See also btf, maxtrans, strongcomp, dmperm, UFget,
+%   test1, test2, test3, test4, test5.
+
+% Copyright 2007, Timothy A. Davis, http://www.suitesparse.com
+
+quick2 = [ ...
+ 1522 -272  1463  1521   460 1507  -838 1533 -1533 -1456 -1512   734   211 ...
+ -385 -735   394  -397  1109 -744  ...
+ -734 -375 -1200 -1536  -837  519  -519  520  -520   189  -189   454   385 ...
+  387 -387   384  -384   386 -386   388 -388   525  -525   526  -526   735 ...
+ 1508  209   210  1243 -1243 1534  -840 1234 -1234   390  -390   392  -392 ...
+ -394 1472  1242 -1242   389 -389   391 -391   393  -393  1215 -1215  1216 ...
+-1216  736  -736   737  -737  455  -455 -224  -839  1426 -1426 -1473   396 ...
+ -396  398  -398   400  -400  402  -402  404  -404 -1531   395  -395   397 ...
+  399 -399   401  -401   403 -403   405 -405  -738  -739  1459 -1459  1111 ...
+ 1110  376  -376   284  -284 -740  -742 -741  -743  1293 -1293   452   920 ...
+ -745 -446  1462 -1461   448 -448   283 -283  1502 -1502  1292 -1292  1503 ...
+-1503 1291 -1291   445  -445 -746  -747 1300 -1300   435  -435 -1343 -1345 ...
+-1344 1305 -1305   921 -1513 1307 -1307 1369 -1369  1374 -1374  1377 ...
+-1377  748  -748  -749  1510  922  -922 ] ;
+
+index = UFget ;
+nmat = length (quick2) ;
+dopause = 0 ;
+
+h = waitbar (0, 'BTF test 6 of 6') ;
+
+try
+
+    for k = 1:nmat
+
+        waitbar (k/nmat, h) ;
+
+        i = quick2 (k) ;
+        Prob = UFget (abs (i), index) ;
+        disp (Prob) ;
+        if (i < 0)
+            fprintf ('transposed\n') ;
+            A = Prob.A' ;
+            [m n] = size (A) ;
+            if (m == n)
+                if (nnz (spones (A) - spones (Prob.A)) == 0)
+                    fprintf ('skip...\n') ;
+                    continue ;
+                end
+            end
+        else
+            A = Prob.A ;
+        end
+
+        tic
+        [p1,q1,r1,work1] = btf (A) ;
+        t1 = toc ;
+        n1 = length (r1) - 1 ;
+        m1 = nnz (diag (A (p1, abs (q1)))) ;
+
+        limit = work1/nnz(A) ;
+
+        fprintf ('full search: %g * nnz(A)\n', limit) ;
+
+        works = linspace(0,limit,9) ;
+        works (1) = eps ;
+        nw = length (works) ;
+
+        T2 = zeros (nw, 1) ;
+        N2 = zeros (nw, 1) ;
+        M2 = zeros (nw, 1) ;
+
+        T2 (end) = t1 ;
+        N2 (end) = n1 ;
+        M2 (end) = m1 ;
+
+        fprintf ('full time %10.4f   blocks %8d  nnz(diag) %8d\n\n', t1, n1, m1) ;
+
+        subplot (3,4,4) ;
+        drawbtf (A, p1, abs (q1), r1) ;
+        title (Prob.name, 'Interpreter', 'none') ;
+
+        for j = 1:nw-1
+
+            maxwork = works (j) ;
+
+            tic
+            [p2,q2,r2,work2] = btf (A, maxwork) ;
+            t2 = toc ;
+            n2 = length (r2) - 1 ;
+            m2 = nnz (diag (A (p2, abs (q2)))) ;
+            T2 (j) = t2 ;
+            N2 (j) = n2 ;
+            M2 (j) = m2 ;
+
+            fprintf ('%9.1f %10.4f   blocks %8d  nnz(diag) %8d\n', ...
+                maxwork, t2, n2, m2) ;
+
+            subplot (3,4,4+j) ;
+            drawbtf (A, p2, abs (q2), r2) ;
+            title (sprintf ('%g', maxwork)) ;
+
+            ss = [1:j nw] ;
+
+            subplot (3,4,1) ;
+            plot (works(ss), T2(ss), 'o-') ;  title ('time vs work') ;
+            axis ([0 limit 0 max(0.1,max(T2))]) ;
+
+            subplot (3,4,2) ;
+            plot (works(ss), N2(ss), 'o-') ; title ('blocks vs work') ;
+            axis ([0 limit 0 n1]) ;
+
+            subplot (3,4,3) ;
+            plot (works(ss), M2(ss), 'o-') ; title ('nnz(diag) vs work') ;
+            axis ([0 limit 0 m1]) ;
+            drawnow
+
+        end
+        fprintf ('full time %10.4f   blocks %8d  nnz(diag) %8d\n', t1, n1, m1) ;
+
+        if (dopause)
+            input ('hit enter: ') ;
+        end
+
+    end
+
+catch
+    % out-of-memory is OK, other errors are not
+    disp (lasterr) ;
+    if (isempty (strfind (lasterr, 'Out of memory')))
+        error (lasterr) ;                                                   %#ok
+    else
+        fprintf ('test terminated early, but otherwise OK\n') ;
+    end
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf.m
new file mode 100644
index 0000000000000000000000000000000000000000..a4d1c113898b2009d8f5da4f879b432308693a59
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf.m
@@ -0,0 +1,38 @@
+function [p,q,r] = btf (A)                                                  %#ok
+%BTF permute a square sparse matrix into upper block triangular form
+% with a zero-free diagonal, or with a maximum number of nonzeros along the
+% diagonal if a zero-free permutation does not exist.
+%
+% Example:
+%       [p,q,r] = btf (A) ;
+%       [p,q,r] = btf (A,maxwork) ;
+%
+% If the matrix has structural full rank, this is essentially identical to
+%
+%       [p,q,r] = dmperm (A)
+%
+% except that p, q, and r will differ in trivial ways.  Both return an upper
+% block triangular form with a zero-free diagonal, if the matrix is
+% structurally non-singular.  The number and sizes of the blocks will be
+% identical, but the order of the blocks, and the ordering within the blocks,
+% can be different.
+% 
+% If the matrix is structurally singular, the q from btf will contain negative
+% entries.  The permuted matrix is C = A(p,abs(q)), and find(q<0) gives a list
+% of indices of the diagonal of C that are equal to zero.  This differs from
+% dmperm, which does not place the maximum matching along the main diagonal
+% of C=A(p,q), but places it above the diagonal instead.
+%
+% The second input limits the maximum amount of work the function does to
+% be maxwork*nnz(A), or no limit at all if maxwork <= 0.  If the function
+% terminates early as a result, a maximum matching may not be found, and the
+% diagonal of A(p,abs(q)) might not have the maximum number of nonzeros
+% possible.  Also, the number of blocks (length(r)-1) may be larger than
+% what btf(A) or dmperm(A) would compute.
+%
+% See also maxtrans, strongcomp, dmperm, sprank
+
+% Copyright 2004-2007, University of Florida
+% with support from Sandia National Laboratories.  All Rights Reserved.
+
+error ('btf mexFunction not found') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_demo.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_demo.m
new file mode 100644
index 0000000000000000000000000000000000000000..6f0901dcf4a73d7584ece4ef3b45aad69269deca
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_demo.m
@@ -0,0 +1,47 @@
+%BTF_DEMO demo for BTF
+%
+% Example:
+%   btf_demo
+%
+% See also btf, dmperm, strongcomp, maxtrans
+
+% Copyright 2004-2007, University of Florida
+
+load west0479 ;
+A = west0479 ;
+
+clf
+
+subplot (2,3,1) ;
+spy (A)
+title ('west0479') ;
+
+subplot (2,3,2) ;
+[p, q, r] = btf (A) ;
+% spy (A (p, abs(q))) ;
+drawbtf (A, p, q, r) ;
+title ('btf') ;
+
+fprintf ('\nbtf_demo: n %d nnz(A) %d  # of blocks %d\n', ...
+    size (A,1), nnz (A), length (r) - 1) ;
+
+subplot (2,3,3) ;
+[p, q, r, s] = dmperm (A) ;
+drawbtf (A, p, q, r) ;
+title ('dmperm btf') 
+
+subplot (2,3,4) ;
+[p, r] = strongcomp (A) ;
+% spy (A (p, abs(q))) ;
+drawbtf (A, p, p, r) ;
+title ('strongly conn. comp.') ;
+
+subplot (2,3,5) ;
+q = maxtrans (A) ;
+spy (A (:,q))
+title ('max transversal') ;
+
+subplot (2,3,6) ;
+p = dmperm (A) ;
+spy (A (p,:))
+title ('dmperm maxtrans') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_install.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_install.m
new file mode 100644
index 0000000000000000000000000000000000000000..d0b8b0fffe8233e554e08f5c7c2e2e410f3f1736
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_install.m
@@ -0,0 +1,17 @@
+function btf_install
+%BTF_INSTALL compile and install BTF for use in MATLAB.
+% Your current working directory must be BTF/MATLAB for this function to work.
+%
+% Example:
+%   btf_install
+%
+% See also btf, maxtrans, stroncomp, dmperm.
+
+% Copyright 2004-2007, University of Florida
+
+btf_make
+addpath (pwd) ;
+fprintf ('BTF has been compiled and installed.  The path:\n') ;
+disp (pwd) ;
+fprintf ('has been added to your path.  Use pathtool to add it permanently.\n');
+btf_demo
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_make.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_make.m
new file mode 100644
index 0000000000000000000000000000000000000000..a222bbb3ff0c3c9c5c2b4dfb8dac2f89b3912872
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/btf_make.m
@@ -0,0 +1,42 @@
+function btf_make
+%BTF_MAKE compile BTF for use in MATLAB
+% Your current working directory must be BTF/MATLAB for this function to work.
+%
+% Example:
+%   btf_make
+%
+% See also btf, maxtrans, stroncomp, dmperm.
+
+% Copyright 2004-2007, University of Florida
+
+details = 0 ;       % if 1, print details of each command
+
+mexcmd = 'mex -O -DDLONG -I../Include -I../../SuiteSparse_config ' ;
+if (~isempty (strfind (computer, '64')))
+    mexcmd = [mexcmd '-largeArrayDims '] ;
+end
+
+% MATLAB 8.3.0 now has a -silent option to keep 'mex' from burbling too much
+if (~verLessThan ('matlab', '8.3.0'))
+    mexcmd = [mexcmd ' -silent '] ;
+end
+
+s = [mexcmd 'maxtrans.c ../Source/btf_maxtrans.c'] ;
+if (details)
+    fprintf ('%s\n', s) ;
+end
+eval (s) ;
+
+s = [mexcmd 'strongcomp.c ../Source/btf_strongcomp.c'] ;
+if (details)
+    fprintf ('%s\n', s) ;
+end
+eval (s) ;
+
+s = [mexcmd 'btf.c ../Source/btf_maxtrans.c ../Source/btf_strongcomp.c ../Source/btf_order.c'] ;
+if (details)
+    fprintf ('%s\n', s) ;
+end
+eval (s) ;
+
+fprintf ('BTF successfully compiled.\n') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/drawbtf.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/drawbtf.m
new file mode 100644
index 0000000000000000000000000000000000000000..96a7bc52471dec118277f5557b7a75099f8b0ca4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/drawbtf.m
@@ -0,0 +1,27 @@
+function drawbtf (A, p, q, r)
+%DRAWBTF plot the BTF form of a matrix
+%
+% A(p,q) is in BTF form, r the block boundaries
+%
+% Example:
+%   [p,q,r] = dmperm (A)
+%   drawbtf (A, p, q, r)
+%
+% See also btf, maxtrans, strongcomp, dmperm.
+
+% Copyright 2004-2007, University of Florida
+
+nblocks = length (r) - 1 ;
+
+hold off
+spy (A (p,abs(q)))
+hold on
+
+for k = 1:nblocks
+    k1 = r (k) ;
+    k2 = r (k+1) ;
+    nk = k2 - k1 ;
+    if (nk > 1)
+        plot ([k1 k2 k2 k1 k1]-.5, [k1 k1 k2 k2 k1]-.5, 'r') ;
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/maxtrans.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/maxtrans.m
new file mode 100644
index 0000000000000000000000000000000000000000..aba591a41e258ad850f9392986674c2191f177b3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/maxtrans.m
@@ -0,0 +1,30 @@
+function q = maxtrans (A)                                                   %#ok
+%MAXTRANS permute the columns of a sparse matrix so it has a zero-free diagonal
+% (if it exists).   If no zero-free diagonal exists, then a maximum matching is
+% found.  Note that this differs from p=dmperm(A), which returns a row
+% permutation.
+%
+% Example:
+%   q = maxtrans (A)
+%   q = maxtrans (A,maxwork)
+%
+% If row i and column j are matched, then q(i) = j.  Otherwise, if row is
+% unmatched, then q(i) = 0.  This is similar to dmperm, except that
+% p = dmperm(A) returns p(j)=i if row i and column j are matched, or p(j)=0 if
+% column j is unmatched.
+%
+% If A is structurally nonsingular, then A(:,maxtrans(A)) has a zero-free
+% diagonal, as does A (dmperm(A),:).
+%
+% The second input limits the maximum amount of work the function does
+% (excluding the O(nnz(A)) cheap match phase) to be maxwork*nnz(A), or no limit
+% at all if maxwork <= 0.  If the function terminates early as a result, a
+% maximum matching may not be found.  An optional second output
+% [q,work] = maxtrans (...) returns the amount of work performed, or -1 if the
+% maximum work limit is reached.
+%
+% See also: btf, strongcomp, dmperm, sprank
+
+% Copyright 2004-2007, University of Florida
+
+error ('maxtrans mexfunction not found') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/strongcomp.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/strongcomp.m
new file mode 100644
index 0000000000000000000000000000000000000000..b20f1b87ebb68ed15a4787577de4501c43f93cfd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/MATLAB/strongcomp.m
@@ -0,0 +1,45 @@
+function [p,q,r] = strongcomp (A, qin)                                      %#ok
+%STRONGCOMP symmetric permutation to upper block triangular form
+% The matrix must be sparse and square.
+%
+% Example:
+%    [p,r] = strongcomp (A) ;
+%    [p,q,r] = strongcomp (A,qin) ;
+%
+% In the first usage, the permuted matrix is C = A (p,p).  In the second usage,
+% the matrix A (:,qin) is symmetrically permuted to upper block triangular
+% form, where qin is an input column permutation, and the final permuted
+% matrix is C = A (p,q).  This second usage is equivalent to
+%
+%    [p,r] = strongcomp (A (:,qin)) ;
+%    q = qin (p) ;
+%
+% That is, if qin is not present it is assumed to be qin = 1:n.
+%
+% C is the permuted matrix, with a number of blocks equal to length(r)-1.
+% The kth block is from row/col r(k) to row/col r(k+1)-1 of C.
+% r(1) is one and the last entry in r is equal to n+1.
+% The diagonal of A (or A (:,qin)) is ignored.
+%
+% strongcomp is normally proceeded by a maximum transversal.
+% Assuming A is square and structurally nonsingular,
+%
+%    [p,q,r] = strongcomp (A, maxtrans (A))
+%
+% is essentially identical to
+%
+%    [p,q,r] = dmperm (A)
+%
+% except that p, q, and r will differ.  Both return an upper block triangular
+% form with a zero-free diagonal.  The number and sizes of the blocks will be
+% identical, but the order of the blocks, and the ordering within the blocks,
+% can be different.  If the matrix is structurally singular, both strongcomp
+% and maxtrans return a vector q containing negative entries.  abs(q) is a
+% permutation of 1:n, and find(q<0) gives a list of the indices of the
+% diagonal of A(p,q) that are zero.
+%
+% See also btf, maxtrans, dmperm
+
+% Copyright 2004-2007, University of Florida
+
+error ('strongcomp mexFunction not found') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e1032544ee8f9dbcd85454eb56721047328f84df
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/BTF/README.txt
@@ -0,0 +1,92 @@
+BTF, by Timothy A. Davis, Copyright (C) 2004-2016, University of Florida
+BTF is also available under other licenses; contact the author for details.
+http://www.suitesparse.com
+
+See BTF/Doc/License.txt for the license.
+
+BTF is a software package for permuting a matrix into block upper triangular
+form.  It includes a maximum transversal algorithm, which finds a permutation
+of a square or rectangular matrix so that it has a zero-free diagonal (if one
+exists); otherwise, it finds a maximal matching which maximizes the number of
+nonzeros on the diagonal.  The package also includes a method for finding the
+strongly connected components of a graph.  These two methods together give the
+permutation to block upper triangular form.
+
+Requires SuiteSparse_config, in the ../SuiteSparse_config directory relative to
+this directory.  KLU relies on the BTF package to permute the matrix prior to
+factorization.
+
+To compile the libbtf.a and libbtf.so library (*.dylib on the Mac), type
+"make".  The compiled library is located in BTF/Lib.  Compile code that uses
+BTF with -IBTF/Include.  Type "make install" to install the library in
+/usr/local/lib and /usr/local/include, and "make uninstall" to remove it.
+
+Type "make clean" to remove all but the compiled library, and "make distclean"
+to remove all files not in the original distribution.
+
+This package does not include a statement coverage test (Tcov directory) or
+demo program (Demo directory).  See the KLU package for both.  The BTF package
+does include a MATLAB interface, a MATLAB test suite (in the MATLAB/Test
+directory), and a MATLAB demo.
+
+See BTF/Include/btf.h for documentation on how to use the C-callable functions.
+Use "help btf", "help maxtrans" and "help strongcomp" in MATLAB, for details on
+how to use the MATLAB-callable functions.  Additional details on the use of BTF
+are given in the KLU User Guide, normally in ../KLU/Doc/KLU_UserGuide.pdf
+relative to this directory.
+
+--------------------------------------------------------------------------------
+
+Files and directories in the BTF package:
+
+    Doc             documentation and license
+    Include         include files
+    Lib             compiled BTF library
+    Makefile        Makefile for C and MATLAB versions
+    MATLAB          MATLAB interface
+    README.txt      this file
+    Source          BTF source code
+
+./Doc:
+
+    ChangeLog       changes in BTF
+
+./Include:
+
+    btf.h           primary user include file
+    btf_internal.h  internal include file, not for user programs
+
+./Lib:
+
+    Makefile        Makefile for C library
+
+./MATLAB:
+
+    btf.c           btf mexFunction
+    btf_install.m   compile and install BTF for use in MATLAB
+    btf.m           btf help
+    Contents.m      contents of MATLAB interface
+    Makefile        Makefile for MATLAB functions
+    maxtrans.c      maxtrans mexFunction
+    maxtrans.m      maxtrans help
+    strongcomp.c    strongcomp mexFunction
+    strongcomp.m    strongcomp help
+    Test            MATLAB test directory
+
+./MATLAB/Test:
+
+    checkbtf.m      check a BTF ordering
+    drawbtf.m       plot a BTF ordering
+    test1.m         compare maxtrans and cs_dmperm
+    test2.m         compare btf and cs_dmperm
+    test3.m         extensive test (maxtrans, strongcomp, and btf)
+    test4b.m        test btf maxwork option
+    test4.m         test btf maxwork option
+    test5.m         test maxtrans maxwork option
+
+./Source:
+
+    btf_maxtrans.c      btf_maxtrans C function
+    btf_order.c         btf_order C function
+    btf_strongcomp.c    btf_strongcomp C function
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/CAMD_UserGuide.bib b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/CAMD_UserGuide.bib
new file mode 100644
index 0000000000000000000000000000000000000000..03fbfa8f7625e0628fe5327488475def3a89c62a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/CAMD_UserGuide.bib
@@ -0,0 +1,98 @@
+@string{SIREV       = "{SIAM} Review"}
+@string{SIMAX       = "{SIAM} J. Matrix Anal. Applic."}
+@string{SIAMJSC     = "{SIAM} J. Sci. Comput."}
+@string{TOMS        = "{ACM} Trans. Math. Softw."}
+
+@article{schu:01,
+	author    = {J. Schulze},
+	title     = {Towards a tighter coupling of bottom-up and top-down sparse matrix ordering methods},
+	journal   = {BIT},
+	volume    = {41},
+	number    = {4},
+	pages     = "800--841",
+	year      = {2001}
+	}
+
+@article{GeorgeLiu89,
+	author={George, A. and Liu, J. W. H.},
+	year={1989},
+	title={The Evolution of the Minimum Degree Ordering Algorithm},
+	journal=SIREV,
+	volume={31},
+	number={1},
+	pages={1--19}}
+
+@article{AmestoyDavisDuff96,
+	author={Amestoy, P. R. and Davis, T. A. and Duff, I. S.},
+	title={An approximate minimum degree ordering algorithm},
+	journal=SIMAX,
+	year={1996}
+	,volume={17}
+	,number={4}
+	,pages={886-905}
+	}
+
+@article{AmestoyDavisDuff04,
+	author={Amestoy, P. R. and Davis, T. A. and Duff, I. S.},
+	title={Algorithm 837: An approximate minimum degree ordering algorithm},
+	journal=TOMS,
+	year={2004}
+	,volume={30}
+	,number={3}
+	,pages={381-388}
+	}
+
+@misc{hsl:2002,
+ author = {HSL},
+  title = "{HSL} 2002: {A} collection of {F}ortran codes for large
+           scale scientific computation",
+  note = {{\tt www.cse.clrc.ac.uk/nag/hsl}},
+  year = 2002}
+
+
+@article{RothbergEisenstat98,
+	author={Rothberg, E. and Eisenstat, S. C.},
+	title={Node selection strategies for bottom-up sparse matrix orderings},
+	journal=SIMAX,
+	year={1998}
+	,volume={19}
+	,number={3}
+	,pages={682-695}
+	}
+
+@article{KarypisKumar98e,
+	author={Karypis, G. and Kumar, V.},
+	title={A fast and high quality multilevel scheme for partitioning irregular graphs},
+	journal=SIAMJSC,
+	year={1998}
+	,volume={20}
+	,pages={359-392}
+	}
+
+@article{Chaco,
+	author={B. Hendrickson and E. Rothberg},
+	title={Improving the runtime and quality of nested dissection ordering},
+	journal=SIAMJSC,
+	year={1999}
+	,volume={20}
+	,pages={468--489}
+	}
+
+@article{PellegriniRomanAmestoy00,
+	author={Pellegrini, F. and Roman, J. and Amestoy, P.},
+	title={Hybridizing nested dissection and halo approximate minimum degree for efficient sparse matrix ordering},
+	journal={Concurrency: Practice and Experience},
+	year={2000}
+	,volume={12}
+	,pages={68-84}
+	}
+
+@article{DavisGilbertLarimoreNg04,
+	author={Davis, T. A. and Gilbert, J. R. and Larimore, S. I. and Ng, E. G.},
+	title={A column approximate minimum degree ordering algorithm},
+	journal=TOMS,
+	year={2004}
+	,volume={30}
+	,pages={353-376}
+	}
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/CAMD_UserGuide.tex b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/CAMD_UserGuide.tex
new file mode 100644
index 0000000000000000000000000000000000000000..00396ebe6df27d9d5091ffc3e670337be81592f4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/CAMD_UserGuide.tex
@@ -0,0 +1,610 @@
+\documentclass[11pt]{article}
+
+\newcommand{\m}[1]{{\bf{#1}}}       % for matrices and vectors
+\newcommand{\tr}{^{\sf T}}          % transpose
+
+\topmargin 0in
+\textheight 9in
+\oddsidemargin 0pt
+\evensidemargin 0pt
+\textwidth 6.5in
+
+%------------------------------------------------------------------------------
+\begin{document}
+%------------------------------------------------------------------------------
+
+\title{CAMD User Guide}
+\author{Patrick R. Amestoy\thanks{ENSEEIHT-IRIT,
+2 rue Camichel 31017 Toulouse, France.
+email: amestoy@enseeiht.fr.  http://www.enseeiht.fr/$\sim$amestoy.}
+\and Yanqing (Morris) Chen
+\and Timothy A. Davis\thanks{
+email: DrTimothyAldenDavis@gmail.com,
+http://www.suitesparse.com.
+This work was supported by the National
+Science Foundation, under grants ASC-9111263, DMS-9223088, and CCR-0203270.
+Portions of the work were done while on sabbatical at Stanford University
+and Lawrence Berkeley National Laboratory (with funding from Stanford
+University and the SciDAC program).  Ordering constraints added with
+support from Sandia National Laboratory (Dept. of Energy).
+}
+\and Iain S. Duff\thanks{Rutherford Appleton Laboratory, Chilton, Didcot, 
+Oxon OX11 0QX, England. email: i.s.duff@rl.ac.uk.  
+http://www.numerical.rl.ac.uk/people/isd/isd.html.
+This work was supported by the EPSRC under grant GR/R46441.
+}}
+
+\date{VERSION 2.4.6, May 4, 2016}
+\maketitle
+
+%------------------------------------------------------------------------------
+\begin{abstract}
+CAMD is a set of ANSI C routines that implements the approximate minimum degree
+ordering algorithm to permute sparse matrices prior to
+numerical factorization.  Ordering constraints can be optionally provided.
+A MATLAB interface is included.
+\end{abstract}
+%------------------------------------------------------------------------------
+
+CAMD Copyright\copyright 2013 by Timothy A.  Davis,
+Yanqing (Morris) Chen,
+Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+CAMD is available under alternate licences; contact T. Davis for details.
+
+{\bf CAMD License:} Refer to CAMD/Doc/License.txt for the license.
+
+{\bf Availability:}
+    http://www.suitesparse.com.
+
+{\bf Acknowledgments:}
+
+    This work was supported by the National Science Foundation, under
+    grants ASC-9111263 and DMS-9223088 and CCR-0203270, and by Sandia
+    National Labs (a grant from DOE).
+    The conversion to C, the addition of the elimination tree
+    post-ordering, and the handling of dense rows and columns
+    were done while Davis was on sabbatical at
+    Stanford University and Lawrence Berkeley National Laboratory.
+    The ordering constraints were added by Chen and Davis.
+
+%------------------------------------------------------------------------------
+\newpage
+\section{Overview}
+%------------------------------------------------------------------------------
+
+CAMD is a set of routines for preordering a sparse matrix prior to
+numerical factorization.  It uses an approximate minimum degree ordering
+algorithm \cite{AmestoyDavisDuff96,AmestoyDavisDuff04}
+to find a permutation matrix $\m{P}$
+so that the Cholesky factorization $\m{PAP}\tr=\m{LL}\tr$ has fewer
+(often much fewer) nonzero entries than the Cholesky factorization of $\m{A}$.
+The algorithm is typically much faster than other ordering methods
+and  minimum degree ordering
+algorithms that compute an exact degree \cite{GeorgeLiu89}.
+Some methods, such as approximate deficiency
+\cite{RothbergEisenstat98} and graph-partitioning based methods
+\cite{Chaco,KarypisKumar98e,PellegriniRomanAmestoy00,schu:01}
+can produce better orderings, depending on the matrix.
+
+The algorithm starts with an undirected graph representation of a
+symmetric sparse matrix $\m{A}$.  Node $i$ in the graph corresponds to row
+and column $i$ of the matrix, and there is an edge $(i,j)$ in the graph if
+$a_{ij}$ is nonzero.
+The degree of a node is initialized to the number of off-diagonal nonzeros
+in row $i$, which is the size of the set of nodes
+adjacent to $i$ in the graph.
+
+The selection of a pivot $a_{ii}$ from the diagonal of $\m{A}$ and the first
+step of Gaussian elimination corresponds to one step of graph elimination.
+Numerical fill-in causes new nonzero entries in the matrix
+(fill-in refers to
+nonzeros in $\m{L}$ that are not in $\m{A}$).
+Node $i$ is eliminated and edges are added to its neighbors
+so that they form a clique (or {\em element}).  To reduce fill-in,
+node $i$ is selected as the node of least degree in the graph.
+This process repeats until the graph is eliminated.
+
+The clique is represented implicitly.  Rather than listing all the
+new edges in the graph, a single list of nodes is kept which represents
+the clique.  This list corresponds to the nonzero pattern of the first
+column of $\m{L}$.  As the elimination proceeds, some of these cliques
+become subsets of subsequent cliques, and are removed.   This graph
+can be stored in place, that is
+using the same amount of memory as the original graph.
+
+The most costly part of the minimum degree algorithm is the recomputation
+of the degrees of nodes adjacent to the current pivot element.
+Rather than keep track of the exact degree, the approximate minimum degree
+algorithm finds an upper bound on the degree that is easier to compute.
+For nodes of least degree, this bound tends to be tight.  Using the
+approximate degree instead of the exact degree leads to a substantial savings
+in run time, particularly for very irregularly structured matrices.
+It has no effect on the quality of the ordering.
+
+The elimination phase is followed by an
+elimination tree post-ordering.  This has no effect on fill-in, but
+reorganizes the ordering so that the subsequent numerical factorization is
+more efficient.  It also includes a pre-processing phase in which nodes of
+very high degree are removed (without causing fill-in), and placed last in the
+permutation $\m{P}$ (subject to the constraints).
+This reduces the run time substantially if the matrix
+has a few rows with many nonzero entries, and has little effect on the quality
+of the ordering.
+CAMD operates on the
+symmetric nonzero pattern of $\m{A}+\m{A}\tr$, so it can be given
+an unsymmetric matrix, or either the lower or upper triangular part of
+a symmetric matrix.
+
+CAMD has the ability to order the matrix with constraints.  Each
+node $i$ in the graph (row/column $i$ in the matrix) has a constraint,
+{\tt C[i]}, which is in the range {\tt 0} to {\tt n-1}.  All nodes with
+{\tt C[i] = 0} are
+ordered first, followed by all nodes with constraint {\tt 1}, and so on.
+That is, {\tt C[P[k]]} is monotonically non-decreasing as {\tt k} varies from
+{\tt 0} to {\tt n-1}.  If {\tt C} is NULL, no
+constraints are used (the ordering will be similar to AMD's ordering,
+except that the postordering is different).
+The optional {\tt C} parameter is also provided in the MATLAB interface,
+({\tt p = camd (A,Control,C)}).
+
+For a discussion of the long history of the minimum degree algorithm,
+see \cite{GeorgeLiu89}.
+
+%------------------------------------------------------------------------------
+\section{Availability}
+%------------------------------------------------------------------------------
+
+CAMD is available at http://www.suitesparse.com.
+The Fortran version is available as the routine {\tt MC47} in HSL
+(formerly the Harwell Subroutine Library) \cite{hsl:2002}. {\tt MC47} does
+not include ordering constraints.
+
+%------------------------------------------------------------------------------
+\section{Using CAMD in MATLAB}
+%------------------------------------------------------------------------------
+
+To use CAMD in MATLAB, you must first compile the CAMD mexFunction.
+Just type {\tt make} in the Unix system shell, while in the {\tt CAMD}
+directory.  You can also type {\tt camd\_make} in MATLAB, while in the
+{\tt CAMD/MATLAB} directory.  Place the {\tt CAMD/MATLAB} directory in your
+MATLAB path.  This can be done on any system with MATLAB, including Windows.
+See Section~\ref{Install} for more details on how to install CAMD.
+
+The MATLAB statement {\tt p=camd(A)} finds a permutation vector {\tt p} such
+that the Cholesky factorization {\tt chol(A(p,p))} is typically sparser than
+{\tt chol(A)}.
+If {\tt A} is unsymmetric, {\tt camd(A)} is identical to {\tt camd(A+A')}
+(ignoring numerical cancellation).
+If {\tt A} is not symmetric positive definite,
+but has substantial diagonal entries and a mostly symmetric nonzero pattern,
+then this ordering is also suitable for LU factorization.  A partial pivoting
+threshold may be required to prevent pivots from being selected off the
+diagonal, such as the statement {\tt [L,U,P] = lu (A (p,p), 0.1)}.
+Type {\tt help lu} for more details.
+The statement {\tt [L,U,P,Q] = lu (A (p,p))} in MATLAB 6.5 is
+not suitable, however, because it uses UMFPACK Version 4.0 and thus
+does not attempt to select pivots from the diagonal.
+UMFPACK Version 4.1 in MATLAB 7.0 and later
+uses several strategies, including a symmetric pivoting strategy, and
+will give you better results if you want to factorize an unsymmetric matrix
+of this type.  Refer to the UMFPACK User Guide for more details, at
+http://www.suitesparse.com.
+
+The CAMD mexFunction is much faster than the built-in MATLAB symmetric minimum
+degree ordering methods, SYMAMD and SYMMMD.  Its ordering quality is
+essentially identical to AMD, comparable to SYMAMD, and better than SYMMMD
+\cite{DavisGilbertLarimoreNg04}.
+
+An optional input argument can be used to modify the control parameters for
+CAMD (aggressive absorption, dense row/column handling, and printing of
+statistics).  An optional output
+argument provides statistics on the ordering, including an analysis of the
+fill-in and the floating-point operation count for a subsequent factorization.
+For more details (once CAMD is installed),
+type {\tt help camd} in the MATLAB command window.
+
+%------------------------------------------------------------------------------
+\section{Using CAMD in a C program}
+\label{Cversion}
+%------------------------------------------------------------------------------
+
+The C-callable CAMD library consists of seven user-callable routines and one
+include file.  There are two versions of each of the routines, with
+{\tt int} and {\tt long} integers.
+The routines with prefix
+{\tt camd\_l\_} use {\tt long} integer arguments; the others use
+{\tt int} integer arguments.  If you compile CAMD in the standard
+ILP32 mode (32-bit {\tt int}'s, {\tt long}'s, and pointers) then the versions
+are essentially identical.  You will be able to solve problems using up to 2GB
+of memory.  If you compile CAMD in the standard LP64 mode, the size of an
+{\tt int} remains 32-bits, but the size of a {\tt long} and a pointer both get
+promoted to 64-bits.
+
+The following routines are fully described in Section~\ref{Primary}:
+
+\begin{itemize}
+\item {\tt camd\_order}
+({\tt long} version: {\tt camd\_l\_order})
+    {\footnotesize
+    \begin{verbatim}
+    #include "camd.h"
+    int n, Ap [n+1], Ai [nz], P [n], C [n] ;
+    double Control [CAMD_CONTROL], Info [CAMD_INFO] ;
+    int result = camd_order (n, Ap, Ai, P, Control, Info, C) ;
+    \end{verbatim}
+    }
+    Computes the approximate minimum degree ordering of an $n$-by-$n$ matrix
+    $\m{A}$.  Returns a permutation vector {\tt P} of size {\tt n}, where
+    {\tt P[k] = i} if row and column {\tt i} are the {\tt k}th row and
+    column in the permuted matrix.
+    This routine allocates its own memory of size $1.2e+9n$ integers,
+    where $e$ is the number of nonzeros in $\m{A}+\m{A}\tr$.
+    It computes statistics about the matrix $\m{A}$, such as the symmetry of
+    its nonzero pattern, the number of nonzeros in $\m{L}$,
+    and the number of floating-point operations required for Cholesky and LU
+    factorizations (which are returned in the {\tt Info} array).
+    The user's input matrix is not modified.
+    It returns {\tt CAMD\_OK} if successful,
+    {\tt CAMD\_OK\_BUT\_JUMBLED} if successful (but the matrix had unsorted
+    and/or duplicate row indices),
+    {\tt CAMD\_INVALID} if the matrix is invalid,
+    {\tt CAMD\_OUT\_OF\_MEMORY} if out of memory.
+
+    The array {\tt C} provides the ordering constraints.
+    On input, {\tt C} may be null (to denote no constraints);
+    otherwise, it must be an array size {\tt n}, with entries in the range
+    {\tt 0} to {\tt n-1}.
+    On output, {\tt C[P[0..n-1]]} is monotonically non-descreasing.  
+
+\item {\tt camd\_defaults}
+({\tt long} version: {\tt camd\_l\_defaults})
+    {\footnotesize
+    \begin{verbatim}
+    #include "camd.h"
+    double Control [CAMD_CONTROL] ;
+    camd_defaults (Control) ;
+    \end{verbatim}
+    }
+    Sets the default control parameters in the {\tt Control} array.  These can
+    then be modified as desired before passing the array to the other CAMD
+    routines.
+
+\item {\tt camd\_control}
+({\tt long} version: {\tt camd\_l\_control})
+    {\footnotesize
+    \begin{verbatim}
+    #include "camd.h"
+    double Control [CAMD_CONTROL] ;
+    camd_control (Control) ;
+    \end{verbatim}
+    }
+    Prints a description of the control parameters, and their values.
+
+\item {\tt camd\_info}
+({\tt long} version: {\tt camd\_l\_info})
+    {\footnotesize
+    \begin{verbatim}
+    #include "camd.h"
+    double Info [CAMD_INFO] ;
+    camd_info (Info) ;
+    \end{verbatim}
+    }
+    Prints a description of the statistics computed by CAMD, and their values.
+
+\item {\tt camd\_valid}
+({\tt long} version: {\tt camd\_valid})
+    {\footnotesize
+    \begin{verbatim}
+    #include "camd.h"
+    int n, Ap [n+1], Ai [nz] ;
+    int result = camd_valid (n, n, Ap, Ai) ;
+    \end{verbatim}
+    }
+    Returns {\tt CAMD\_OK} or {\tt CAMD\_OK\_BUT\_JUMBLED}
+    if the matrix is valid as input to {\tt camd\_order};
+    the latter is returned if the matrix has unsorted and/or duplicate
+    row indices in one or more columns. 
+    Returns {\tt CAMD\_INVALID} if the matrix cannot be passed to
+    {\tt camd\_order}.
+    For {\tt camd\_order}, the matrix must
+    also be square.  The first two arguments are the number of rows and the
+    number of columns of the matrix.  For its use in CAMD, these must both
+    equal {\tt n}.
+
+\item {\tt camd\_2}
+({\tt long} version: {\tt camd\_l2})
+    CAMD ordering kernel.  It is faster than {\tt camd\_order}, and
+    can be called by the user, but it is difficult to use.
+    It does not check its inputs for errors.
+    It does not require the columns of its input matrix to be sorted,
+    but it destroys the matrix on output.  Additional workspace must be passed.
+    Refer to the source file {\tt CAMD/Source/camd\_2.c} for a description.
+
+\end{itemize}
+
+The nonzero pattern of the matrix $\m{A}$ is represented in compressed column
+form.
+For an $n$-by-$n$ matrix $\m{A}$ with {\tt nz} nonzero entries, the
+representation consists of two arrays: {\tt Ap} of size {\tt n+1} and {\tt Ai}
+of size {\tt nz}.  The row indices of entries in column {\tt j} are stored in
+    {\tt Ai[Ap[j]} $\ldots$ {\tt Ap[j+1]-1]}.
+For {\tt camd\_order},
+if duplicate row indices are present, or if the row indices in any given
+column are not sorted in ascending order, then {\tt camd\_order} creates
+an internal copy of the matrix with sorted rows and no duplicate entries,
+and orders the copy.  This adds slightly to the time and memory usage of
+{\tt camd\_order}, but is not an error condition.
+
+The matrix is 0-based, and thus
+row indices must be in the range {\tt 0} to {\tt n-1}.
+The first entry {\tt Ap[0]} must be zero.
+The total number of entries in the matrix is thus {\tt nz = Ap[n]}.
+
+The matrix must be square, but it does not need to be symmetric.
+The {\tt camd\_order} routine constructs the nonzero pattern of
+$\m{B} = \m{A}+\m{A}\tr$ (without forming $\m{A}\tr$ explicitly if
+$\m{A}$ has sorted columns and no duplicate entries),
+and then orders the matrix $\m{B}$.  Thus, either the
+lower triangular part of $\m{A}$, the upper triangular part,
+or any combination may be passed.  The transpose $\m{A}\tr$ may also be
+passed to {\tt camd\_order}.
+The diagonal entries may be present, but are ignored.
+
+%------------------------------------------------------------------------------
+\subsection{Control parameters}
+\label{control_param}
+%------------------------------------------------------------------------------
+
+Control parameters are set in an optional {\tt Control} array.
+It is optional in the sense that if
+a {\tt NULL} pointer is passed for the {\tt Control} input argument,
+then default control parameters are used.
+%
+\begin{itemize}
+\item {\tt Control[CAMD\_DENSE]} (or {\tt Control(1)} in MATLAB):
+controls the threshold for ``dense''
+rows/columns.  A dense row/column in $\m{A}+\m{A}\tr$
+can cause CAMD to spend significant time
+in ordering the matrix.  If {\tt Control[CAMD\_DENSE]} $\ge 0$,
+rows/columns with
+more than {\tt Control[CAMD\_DENSE]} $\sqrt{n}$ entries are ignored during
+the ordering, and placed last in the output order.  The default
+value of {\tt Control[CAMD\_DENSE]} is 10.  If negative, no rows/columns
+are treated as ``dense.''  Rows/columns with 16 or fewer off-diagonal
+entries are never considered ``dense.''
+%
+\item {\tt Control[CAMD\_AGGRESSIVE]} (or {\tt Control(2)} in MATLAB):
+controls whether or not to use
+aggressive absorption, in which a prior element is absorbed into the current
+element if it is a subset of the current element, even if it is not
+adjacent to the current pivot element (refer
+to \cite{AmestoyDavisDuff96,AmestoyDavisDuff04}
+for more details).  The default value is nonzero,
+which means that aggressive absorption will be performed.  This nearly always
+leads to a better ordering (because the approximate degrees are more
+accurate) and a lower execution time.  There are cases where it can
+lead to a slightly worse ordering, however.  To turn it off, set
+{\tt Control[CAMD\_AGGRESSIVE]} to 0.
+%
+\end{itemize}
+
+Statistics are returned in the {\tt Info} array
+(if {\tt Info} is {\tt NULL}, then no statistics are returned).
+Refer to {\tt camd.h} file, for more details
+(14 different statistics are returned, so the list is not included here).
+
+%------------------------------------------------------------------------------
+\subsection{Sample C program}
+%------------------------------------------------------------------------------
+
+The following program, {\tt camd\_demo.c}, illustrates the basic use of CAMD.
+See Section~\ref{Synopsis} for a short description
+of each calling sequence.
+
+{\footnotesize
+\begin{verbatim}
+#include <stdio.h>
+#include "camd.h"
+
+int n = 5 ;
+int Ap [ ] = { 0,   2,       6,       10,  12, 14} ;
+int Ai [ ] = { 0,1, 0,1,2,4, 1,2,3,4, 2,3, 1,4   } ;
+int C [ ] = { 2, 0, 0, 0, 1 } ;
+int P [5] ;
+
+int main (void)
+{
+    int k ;
+    (void) camd_order (n, Ap, Ai, P, (double *) NULL, (double *) NULL, C) ;
+    for (k = 0 ; k < n ; k++) printf ("P [%d] = %d\n", k, P [k]) ;
+    return (0) ;
+}
+
+\end{verbatim}
+}
+
+The {\tt Ap} and {\tt Ai} arrays represent the binary matrix
+\[
+\m{A} = \left[
+\begin{array}{rrrrr}
+ 1 &  1 &  0 &  0 &  0 \\
+ 1 &  1 &  1 &  0 &  1 \\
+ 0 &  1 &  1 &  1 &  0 \\
+ 0 &  0 &  1 &  1 &  0 \\
+ 0 &  1 &  1 &  0 &  1 \\
+\end{array}
+\right].
+\]
+The diagonal entries are ignored.
+%
+CAMD constructs the pattern of $\m{A}+\m{A}\tr$,
+and returns a permutation vector of $(3, 2, 1, 4, 0)$.
+Note that nodes 1, 2, and 3 appear first (they are in the constraint set 0),
+node 4 appears next (since {\tt C[4] = 1}), and node 0 appears last.
+%
+Since the matrix is unsymmetric but with a mostly symmetric nonzero
+pattern, this would be a suitable permutation for an LU factorization of a
+matrix with this nonzero pattern and whose diagonal entries are not too small.
+The program uses default control settings and does not return any statistics
+about the ordering, factorization, or solution ({\tt Control} and {\tt Info}
+are both {\tt (double *) NULL}).  It also ignores the status value returned by
+{\tt camd\_order}.
+
+More example programs are included with the CAMD package.
+The {\tt camd\_demo.c} program provides a more detailed demo of CAMD.
+Another example is the CAMD mexFunction, {\tt camd\_mex.c}.
+
+%------------------------------------------------------------------------------
+\subsection{A note about zero-sized arrays}
+%------------------------------------------------------------------------------
+
+CAMD uses several user-provided arrays of size {\tt n} or {\tt nz}.
+Either {\tt n} or {\tt nz} can be zero.
+If you attempt to {\tt malloc} an array of size zero,
+however, {\tt malloc} will return a null pointer which CAMD will report
+as invalid.  If you {\tt malloc} an array of
+size {\tt n} or {\tt nz} to pass to CAMD, make sure that you handle the
+{\tt n} = 0 and {\tt nz = 0} cases correctly.
+
+%------------------------------------------------------------------------------
+\section{Synopsis of C-callable routines}
+\label{Synopsis}
+%------------------------------------------------------------------------------
+
+The matrix $\m{A}$ is {\tt n}-by-{\tt n} with {\tt nz} entries.
+
+{\footnotesize
+\begin{verbatim}
+#include "camd.h"
+int n, status, Ap [n+1], Ai [nz], P [n], C [n] ;
+double Control [CAMD_CONTROL], Info [CAMD_INFO] ;
+camd_defaults (Control) ;
+status = camd_order (n, Ap, Ai, P, Control, Info, C) ;
+camd_control (Control) ;
+camd_info (Info) ;
+status = camd_valid (n, n, Ap, Ai) ;
+\end{verbatim}
+}
+
+The {\tt camd\_l\_*} routines are identical, except that all {\tt int}
+arguments become {\tt long}:
+
+{\footnotesize
+\begin{verbatim}
+#include "camd.h"
+long n, status, Ap [n+1], Ai [nz], P [n], C [n] ;
+double Control [CAMD_CONTROL], Info [CAMD_INFO] ;
+camd_l_defaults (Control) ;
+status = camd_l_order (n, Ap, Ai, P, Control, Info, C) ;
+camd_l_control (Control) ;
+camd_l_info (Info) ;
+status = camd_l_valid (n, n, Ap, Ai) ;
+\end{verbatim}
+}
+
+%------------------------------------------------------------------------------
+\section{Installation}
+\label{Install}
+%------------------------------------------------------------------------------
+
+The following discussion assumes you have the {\tt make} program, either in
+Unix, or in Windows with Cygwin.
+
+System-dependent configurations are in the
+{\tt ../SuiteSparse\_config/SuiteSparse\_config.mk}
+file.  You can edit that file to customize the compilation.  The default
+settings will work on most systems.
+Sample configuration files are provided
+for Mac, Linux, Sun Solaris, and IBM AIX.
+The system you are on is detected automatically.
+
+To compile and install the C-callable CAMD library,
+go to the {\tt CAMD} directory and type {\tt make}.
+A dynamic library is placed in
+in {\tt AMD/Lib/libcamd.so.*}, ({\tt *.dylib} for the Mac).
+Three demo programs of the AMD ordering routine will be compiled and tested in
+the {\tt CAMD/Demo} directory.
+The outputs of these demo programs will then be compared with output
+files in the distribution.
+
+Typing {\tt make clean} will remove all but the final compiled libraries
+and demo programs.  Typing {\tt make purge} or {\tt make distclean}
+removes all files not in the original distribution.
+If you compile CAMD and then later change the
+{\tt ../SuiteSparse\_config/SuiteSparse\_config.mk} file
+then you should type {\tt make purge} and then {\tt make} to recompile.
+
+When you compile your program that uses the C-callable CAMD library,
+you need to add the {\tt CAMD/Lib/libcamd.*} library
+and you need to tell your compiler to look in the
+{\tt CAMD/Include} directory for include
+files.
+See {\tt CAMD/Demo/Makefile} for an example.
+
+By doing {\tt make}, all compiled dynamic libraries are also copied into {\tt
+SuiteSparse/lib} the include files are coped into {\tt SuiteSparse/include},
+and documentation is copied into {\tt SuiteSparse/doc}.
+
+Alternatively, you can install the shared library
+and include files in /usr/local/lib and /usr/local/include, and
+the documenation in /usr/local/doc.
+Just do {\tt make} then {\tt make install}.
+Now you can simply use {\tt -lcamd} when you compile your own program.
+
+If all you want to use is the CAMD mexFunction in MATLAB, you can skip
+the use of the {\tt make} command entirely.  Simply type
+{\tt camd\_make} in MATLAB while in the {\tt CAMD/MATLAB} directory.
+This works on any system with MATLAB, including Windows.
+Alternately, type {\tt make} in the {\tt CAMD/MATLAB} directory.
+
+If you are including CAMD as a subset of a larger library and do not want
+to link the C standard I/O library, or if you simply do not need to use
+them, you can safely remove the {\tt camd\_control.c} and {\tt camd\_info.c}
+files.  Similarly, if you use default parameters (or define your
+own {\tt Control} array), then you can exclude the {\tt camd\_defaults.c}
+file.
+Each of these files contains the user-callable routines of the same
+name.  None of these auxiliary routines are directly called by
+{\tt camd\_order}.
+The {\tt camd\_dump.c} file contains debugging routines
+that are neither used nor compiled unless debugging is enabled.
+The {\tt camd\_internal.h} file must be edited to enable debugging;
+refer to the instructions in that file.
+The bare minimum files required to use just {\tt camd\_order} are
+{\tt camd.h} and {\tt camd\_internal.h}
+in the {\tt Include} directory,
+and
+{\tt camd\_1.c},
+{\tt camd\_2.c},
+{\tt camd\_aat.c},
+{\tt camd\_global.c},
+{\tt and\_order.c},
+{\tt camd\_postorder.c},
+{\tt camd\_preprocess.c},
+and
+{\tt camd\_valid.c}
+in the {\tt Source} directory.
+
+%------------------------------------------------------------------------------
+\newpage
+\section{The CAMD routines}
+\label{Primary}
+%------------------------------------------------------------------------------
+
+The file {\tt CAMD/Include/camd.h} listed below
+describes each user-callable routine in CAMD,
+and gives details on their use.
+
+{\footnotesize
+\input{camd_h.tex}
+}
+
+%------------------------------------------------------------------------------
+\newpage
+% References
+%------------------------------------------------------------------------------
+
+\bibliographystyle{plain}
+\bibliography{CAMD_UserGuide}
+
+\end{document}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/ChangeLog b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/ChangeLog
new file mode 100644
index 0000000000000000000000000000000000000000..3309a935b24bff39d589caae1a9db907464a7767
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/ChangeLog
@@ -0,0 +1,107 @@
+May 4, 2016: version 2.4.6
+
+    * minor changes to Makefile
+
+Apr 1, 2016: version 2.4.5
+
+    * licensing simplified (no other change); refer to CAMD/Doc/License.txt
+
+Feb 1, 2016: version 2.4.4
+
+    * update to Makefiles
+
+Jan 30, 2016: version 2.4.3
+
+    * modifications to Makefiles
+
+Jan 1, 2016: version 2.4.2
+
+    * modified Makefile to create shared libraries
+            No change to C code except version number
+
+Oct 10, 2014: version 2.4.1
+
+    modified MATLAB/camd_make.m.  No change to C code except version number.
+
+July 31, 2013: version 2.4.0
+
+    * changed malloc and printf pointers to use SuiteSparse_config
+
+Jun 20, 2012: verison 2.3.1
+
+    * minor update for Windows (removed filesep)
+
+Jun 1, 2012: version 2.3.0
+
+    * changed from UFconfig to SuiteSparse_config
+
+May 15, 2012: version 2.2.4
+
+    * minor fix to SIZE_T_MAX definition (finicky compiler workaround)
+
+Dec 7, 2011: version 2.2.3
+
+    * fixed the Makefile to better align with CFLAGS and other standards
+
+Jan 25, 2011: version 2.2.2
+
+    * minor fix to "make install"
+
+Nov 30, 2009: version 2.2.1
+
+    * added "make install" and "make uninstall"
+
+May 31, 2007: version 2.2.0
+
+    * port to 64-bit MATLAB
+
+    * Makefile moved from Source/ to Lib/
+
+Dec 12, 2006, v2.1.3
+
+    * minor MATLAB cleanup
+
+Sept 28, 2006, v2.1.2
+
+    * #define SIZE_T_MAX not done if already defined (Mac OSX).
+
+Aug 31, 2006: v2.1.1
+
+    * trivial change to comments in camd.m
+
+June 27, 2006: CAMD Version 2.1
+
+    * bug fix.  Ordering constraints not always met if dense and/or empty
+	nodes are present in the matrix.
+
+Apr. 30, 2006: CAMD Version 2.0
+
+    * CAMD released, based on AMD v2.0.  To compare the two codes, type the
+	command ./docdiff in this directory (the "CAMD" and "camd" strings
+	are replaced with "AMD" and "amd" when the two packages are compared,
+	to make more evident the substantive differences between the packages).
+
+	Primary differences with AMD v2.0:
+
+	CAMD adds the ability to order the matrix with constraints.  Each
+	node i in the graph (row/column i in the matrix) has a constraint,
+	C[i], which is in the range 0 to n-1.  All nodes with C[i] = 0 are
+	ordered first, followed by all nodes with constraint 1, and so on.
+	That is, C[P[k]] is monotonically non-decreasing as k varies from 0
+	to n-1.  camd_order has an additional C parameter; if NULL, no
+	constraints are used (the ordering will be similar to AMD's ordering).
+	The optional C parameter is also added to the MATLAB interface,
+	p = camd (A,Control,C).
+
+	Since the C parameter is optional, CAMD can replace AMD in any
+	application that uses AMD.  Just pass C = NULL (or omit C in the MATLAB
+	interface).  There is no Fortran version of CAMD, however.
+
+	The postordering is different, and there is no camd_post_tree.c file.
+
+	A new routine, camd_cvalid, has been added to check the validity of C.
+
+	CAMD requires more workspace than AMD (n+1 integers).
+
+	All user-visible names AMD* and amd* replaced with CAMD* and camd*.
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/License.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9f3faa0cdcfbb2bdded1a7153664448e3b170607
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/License.txt
@@ -0,0 +1,40 @@
+CAMD, Copyright (c) by Timothy A. Davis,
+Yanqing Chen,
+Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+CAMD is available under alternate licenses, contact T. Davis for details.
+
+CAMD License:
+
+    Your use or distribution of CAMD or any modified version of
+    CAMD implies that you agree to this License.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+    USA
+
+    Permission is hereby granted to use or copy this program under the
+    terms of the GNU LGPL, provided that the Copyright, this License,
+    and the Availability of the original version is retained on all copies.
+    User documentation of any code that uses this code or any modified
+    version of this code must cite the Copyright, this License, the
+    Availability note, and "Used by permission." Permission to modify
+    the code and to distribute modified code is granted, provided the
+    Copyright, this License, and the Availability note are retained,
+    and a notice that the code was modified is included.
+
+Availability:
+
+    http://www.suitesparse.com
+
+-------------------------------------------------------------------------------
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/camd.sed b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/camd.sed
new file mode 100644
index 0000000000000000000000000000000000000000..877e3f068f6f1ae593f9e3a788ab5168c9a08a4c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/camd.sed
@@ -0,0 +1,2 @@
+s/CAMD/AMD/g
+s/camd/amd/g
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/cdiff b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/cdiff
new file mode 100644
index 0000000000000000000000000000000000000000..7d477e213287e43b11f2799fc2f1b78036bcf522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/cdiff
@@ -0,0 +1,4 @@
+#
+echo diff $1 $2
+sed -f camd.sed < $1 > camd_temp
+diff camd_temp $2
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/docdiff b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/docdiff
new file mode 100644
index 0000000000000000000000000000000000000000..539522c353ecc3cf36f27c03d0bd423ac83a61f0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/docdiff
@@ -0,0 +1,35 @@
+./cdiff  ../Demo/camd_demo2.c ../../AMD/Demo/amd_demo2.c
+./cdiff  ../Demo/camd_demo.c ../../AMD/Demo/amd_demo.c
+./cdiff  ../Demo/camd_l_demo.c ../../AMD/Demo/amd_l_demo.c
+./cdiff  ../Demo/camd_simple.c ../../AMD/Demo/amd_simple.c
+./cdiff  ../Demo/Makefile ../../AMD/Demo/Makefile
+./cdiff  ../Doc/CAMD_UserGuide.bib ../../AMD/Doc/AMD_UserGuide.bib
+./cdiff  ../Doc/CAMD_UserGuide.tex ../../AMD/Doc/AMD_UserGuide.tex
+./cdiff  ../Doc/License.txt ../../AMD/Doc/License.txt
+./cdiff  ../Doc/Makefile ../../AMD/Doc/Makefile
+./cdiff  ../Include/camd.h ../../AMD/Include/amd.h
+./cdiff  ../Include/camd_internal.h ../../AMD/Include/amd_internal.h
+./cdiff  ../Lib/libcamd.def ../../AMD/Lib/libamd.def
+./cdiff  ../MATLAB/camd_demo.m ../../AMD/MATLAB/amd_demo.m
+./cdiff  ../MATLAB/camd.m ../../AMD/MATLAB/amd2.m
+./cdiff  ../MATLAB/camd_make.m ../../AMD/MATLAB/amd_make.m
+./cdiff  ../MATLAB/camd_mex.c ../../AMD/MATLAB/amd_mex.c
+./cdiff  ../MATLAB/can_24 ../../AMD/MATLAB/can_24
+./cdiff  ../MATLAB/Contents.m ../../AMD/MATLAB/Contents.m
+./cdiff  ../MATLAB/Makefile ../../AMD/MATLAB/Makefile
+./cdiff  ../Source/camd_1.c ../../AMD/Source/amd_1.c
+./cdiff  ../Source/camd_2.c ../../AMD/Source/amd_2.c
+./cdiff  ../Source/camd_aat.c ../../AMD/Source/amd_aat.c
+./cdiff  ../Source/camd_control.c ../../AMD/Source/amd_control.c
+./cdiff  ../Source/camd_defaults.c ../../AMD/Source/amd_defaults.c
+./cdiff  ../Source/camd_dump.c ../../AMD/Source/amd_dump.c
+./cdiff  ../Source/camd_global.c ../../AMD/Source/amd_global.c
+./cdiff  ../Source/camd_info.c ../../AMD/Source/amd_info.c
+./cdiff  ../Source/camd_order.c ../../AMD/Source/amd_order.c
+./cdiff  ../Source/camd_postorder.c ../../AMD/Source/amd_postorder.c
+# ./cdiff  ../Source/camd_post_tree.c ../../AMD/Source/amd_post_tree.c
+./cdiff  ../Source/camd_preprocess.c ../../AMD/Source/amd_preprocess.c
+./cdiff  ../Source/camd_valid.c ../../AMD/Source/amd_valid.c
+./cdiff  ../Source/Makefile ../../AMD/Source/Makefile
+./cdiff  ../Makefile ../../AMD/Makefile
+./cdiff  ../README.txt ../../AMD/README.txt
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/lesser.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/lesser.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8add30ad590a65db7e5914f5417eac39a64402a3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/Doc/lesser.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/Contents.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..ba35d1bd15f3777e8589d92c8e28670e287724f8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/Contents.m
@@ -0,0 +1,14 @@
+%Contents of the CAMD sparse matrix ordering package:
+%
+% camd        - p = camd (A), the approximate minimum degree ordering of A
+% camd_demo   - a demo of camd, using the can_24 matrix
+% camd_make   - to compile camd for use in MATLAB
+%
+% Example:
+%   p = camd(A)
+%
+% See also:  camd, amd, colamd, symamd, colmmd, symmmd, umfpack
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, Iain S. Duff, and Y. Chen.
+
+help Contents
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd.m
new file mode 100644
index 0000000000000000000000000000000000000000..de430967bf4813a10e44001c63af2e46c9d6dd83
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd.m
@@ -0,0 +1,79 @@
+function [p, Info] = camd (A, Control, C)				    %#ok
+%CAMD p = camd (A), the approximate minimum degree ordering of A
+%    P = CAMD (S) returns the approximate minimum degree permutation vector for
+%    the sparse matrix C = S+S'.  The Cholesky factorization of C (P,P), or
+%    S (P,P), tends to be sparser than that of C or S.  CAMD tends to be faster
+%    than SYMMMD and SYMAMD, and tends to return better orderings than SYMMMD.
+%    S must be square. If S is full, camd(S) is equivalent to camd(sparse(S)).
+%
+%    Usage:  P = camd (S) ;                   % finds the ordering
+%            [P, Info] = camd (S,Control,C) ; % optional parameters & statistics
+%            Control = camd ;                 % returns default parameters
+%            camd ;                           % prints default parameters.
+%
+%       Control (1); If S is n-by-n, then rows/columns with more than
+%           max (16, (Control (1))* sqrt(n)) entries in S+S' are considered
+%           "dense", and ignored during ordering.  They are placed last in the
+%           output permutation.  The default is 10.0 if Control is not present.
+%       Control (2): If nonzero, then aggressive absorption is performed.
+%           This is the default if Control is not present.
+%       Control (3): If nonzero, print statistics about the ordering.
+%
+%       Info (1): status (0: ok, -1: out of memory, -2: matrix invalid)
+%       Info (2): n = size (A,1)
+%       Info (3): nnz (A)
+%       Info (4): the symmetry of the matrix S (0.0 means purely unsymmetric,
+%           1.0 means purely symmetric).  Computed as:
+%           B = tril (S, -1) + triu (S, 1) ; symmetry = nnz (B & B') / nnz (B);
+%       Info (5): nnz (diag (S))
+%       Info (6): nnz in S+S', excluding the diagonal (= nnz (B+B'))
+%       Info (7): number "dense" rows/columns in S+S'
+%       Info (8): the amount of memory used by CAMD, in bytes
+%       Info (9): the number of memory compactions performed by CAMD
+%
+%    The following statistics are slight upper bounds because of the
+%    approximate degree in CAMD.  The bounds are looser if "dense" rows/columns
+%    are ignored during ordering (Info (7) > 0).  The statistics are for a
+%    subsequent factorization of the matrix C (P,P).  The LU factorization
+%    statistics assume no pivoting.
+%
+%       Info (10): the number of nonzeros in L, excluding the diagonal
+%       Info (11): the number of divide operations for LL', LDL', or LU
+%       Info (12): the number of multiply-subtract pairs for LL' or LDL'
+%       Info (13): the number of multiply-subtract pairs for LU
+%       Info (14): the max # of nonzeros in any column of L (incl. diagonal)
+%       Info (15:20): unused, reserved for future use
+%
+%    An assembly tree post-ordering is performed, which is typically the same
+%    as an elimination tree post-ordering.  It is not always identical because
+%    of the approximate degree update used, and because "dense" rows/columns
+%    do not take part in the post-order.  It well-suited for a subsequent
+%    "chol", however.  If you require a precise elimination tree post-ordering,
+%    then do the following:
+%
+%    Example:
+%       P = camd (S) ;
+%       C = spones (S) + spones (S') ;  % skip this if S already symmetric
+%       [ignore, Q] = etree (C (P,P)) ;
+%       P = P (Q) ;
+%
+%    CAMD has the ability to order the matrix with constraints.  Each
+%    node i in the graph (row/column i in the matrix) has a constraint,
+%    C(i), which is in the range 1 to n.  All nodes with C(i) = 1 are
+%    ordered first, followed by all nodes with constraint 2, and so on.
+%    That is, C(P) is monotonically non-decreasing.  If C is not provided,
+%    no constraints are used (the ordering will be similar to AMD's ordering,
+%    except that the postordering is different).
+%
+%    See also AMD, COLMMD, COLAMD, COLPERM, SYMAMD, SYMMMD, SYMRCM.
+
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, Iain S. Duff, and Y. Chen.
+%
+%    Acknowledgements: This work was supported by the National Science
+%       Foundation, under grants ASC-9111263, DMS-9223088, and CCR-0203270,
+%       and by Sandia National Laboratories.
+%
+
+help camd
+error ('camd mexFunction not found!  Type "camd_make" in MATLAB to compile camd');
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd_demo.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd_demo.m
new file mode 100644
index 0000000000000000000000000000000000000000..5b5c177cbd0cc0e6caa7fb9438361baafefc33ad
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd_demo.m
@@ -0,0 +1,114 @@
+function camd_demo
+%CAMD_DEMO a demo of camd, using the can_24 matrix
+%
+% A demo of CAMD for MATLAB.
+%
+% Example:
+%   camd_demo
+%
+% See also: camd, camd_make
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, Iain S. Duff, and Y. Chen.
+
+% This orders the same matrix as the ANSI C demo, camd_demo.c.  It includes an
+% additional analysis of the matrix via MATLAB's symbfact routine.
+
+% First, print the help information for CAMD
+help camd
+
+% Get the Harwell/Boeing can_24 matrix.
+
+load can_24
+A = spconvert (can_24) ;
+
+n = size (A,1) ;
+
+rand ('state', 0) ;
+C = irand (6, n) ;
+
+clf
+hold off
+subplot (2,2,1) ;
+spy (A)
+title ('HB/can24 matrix') ;
+
+% print the details during CAMD ordering and SYMBFACT
+% spparms ('spumoni', 1) ;
+
+% order the matrix.  Note that the Info argument is optional.
+fprintf ('\nIf the next step fails, then you have\n') ;
+fprintf ('not yet compiled the CAMD mexFunction.\n') ;
+[p, Info] = camd (A) ;          %#ok
+
+% order again, but this time print some statistics
+[p, camd_Info] = camd (A, [10 1 1], C) ;
+
+fprintf ('Permutation vector:\n') ;
+fprintf (' %2d', p) ;
+
+fprintf ('\n\n') ;
+fprintf ('Corresponding constraint sets:\n') ;
+
+if (any (sort (C (p)) ~= C (p)))
+    error ('Error!') ;
+end
+
+for j = 1:n
+    fprintf (' %2d', C (p (j))) ;
+end
+fprintf ('\n\n\n') ;
+
+subplot (2,2,2) ;
+spy (A (p,p)) ;
+title ('Permuted matrix') ;
+
+% The camd_demo.c program stops here.
+
+fprintf ('Analyze A(p,p) with MATLAB symbfact routine:\n') ;
+[cn, height, parent, post, R] = symbfact (A(p,p)) ;
+
+subplot (2,2,3) ;
+spy (R') ; 
+title ('Cholesky factor L') ;
+
+subplot (2,2,4) ;
+treeplot (parent) ;
+title ('etree') ;
+
+% results from symbfact
+lnz = sum (cn) ;                % number of nonzeros in L, incl. diagonal
+cn = cn - 1 ;                   % get the count of off-diagonal entries
+fl = n + sum (cn.^2 + 2*cn) ;   % flop count for chol (A (p,p)
+fprintf ('number of nonzeros in L (including diagonal):      %d\n', lnz) ;
+fprintf ('floating point operation count for chol (A (p,p)): %d\n', fl) ;
+
+% approximations from camd:
+lnz2 = n + camd_Info (10) ;
+fl2 = n + camd_Info (11) + 2 * camd_Info (12) ;
+fprintf ('\nResults from CAMD''s approximate analysis:\n') ;
+fprintf ('number of nonzeros in L (including diagonal):      %d\n', lnz2) ;
+fprintf ('floating point operation count for chol (A (p,p)): %d\n\n', fl2) ;
+
+fprintf ('\nNote that the ordering quality is not as good as p=amd(A).\n') ;
+fprintf ('This is only because the ordering constraints, C, have been\n') ;
+fprintf ('randomly selected.\n') ;
+
+if (lnz2 ~= lnz | fl ~= fl2)						    %#ok
+    fprintf ('Note that the nonzero and flop counts from CAMD are slight\n') ;
+    fprintf ('upper bounds.  This is due to the approximate minimum degree\n');
+    fprintf ('method used, in conjunction with "mass elimination".\n') ;
+    fprintf ('See the discussion about mass elimination in camd.h and\n') ;
+    fprintf ('camd_2.c for more details.\n') ;
+end
+
+% turn off diagnostic output in MATLAB's sparse matrix routines
+% spparms ('spumoni', 0) ;
+
+%-------------------------------------------------------------------------------
+
+function i = irand (n,s)
+% irand: return a random vector of size s, with values between 1 and n
+if (nargin == 1)
+    s = 1 ;
+end
+i = min (n, 1 + floor (rand (1,s) * n)) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd_make.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd_make.m
new file mode 100644
index 0000000000000000000000000000000000000000..7b959bfc0468a3a570d04eb155d2237688a21b8d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/camd_make.m
@@ -0,0 +1,43 @@
+function camd_make
+%CAMD_MAKE to compile camd for use in MATLAB
+%
+% Example:
+%   camd_make
+%
+% See also camd.
+
+% Copyright 1994-2007, Tim Davis, Patrick R. Amestoy, Iain S. Duff, and Y. Chen.
+
+details = 0 ;	    % 1 if details of each command are to be printed
+
+d = '' ;
+if (~isempty (strfind (computer, '64')))
+    d = '-largeArrayDims' ;
+end
+
+% MATLAB 8.3.0 now has a -silent option to keep 'mex' from burbling too much
+if (~verLessThan ('matlab', '8.3.0'))
+    d = ['-silent ' d] ;
+end
+
+i = sprintf ('-I../Include -I../../SuiteSparse_config') ;
+cmd = sprintf ('mex -O %s -DDLONG -output camd %s camd_mex.c %s', d, i, ...
+    '../../SuiteSparse_config/SuiteSparse_config.c') ;
+files = {'camd_order', 'camd_dump', 'camd_postorder', ...
+    'camd_aat', 'camd_2', 'camd_1', 'camd_defaults', 'camd_control', ...
+    'camd_info', 'camd_valid', 'camd_preprocess' } ;
+for i = 1 : length (files)
+    cmd = sprintf ('%s ../Source/%s.c', cmd, files {i}) ;
+end
+if (details)
+    fprintf ('%s\n', cmd) ;
+end
+
+if (~(ispc || ismac))
+    % for POSIX timing routine
+    cmd = [cmd ' -lrt'] ;
+end
+
+eval (cmd) ;
+
+fprintf ('CAMD successfully compiled.\n') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/can_24 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/can_24
new file mode 100644
index 0000000000000000000000000000000000000000..38158a159a64c761911df18d6b8d2a7fbed5e02d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/MATLAB/can_24
@@ -0,0 +1,160 @@
+ 1  1 1
+ 6  1 1
+ 7  1 1
+13  1 1
+14  1 1
+18  1 1
+19  1 1
+20  1 1
+22  1 1
+ 2  2 1
+ 9  2 1
+10  2 1
+14  2 1
+15  2 1
+18  2 1
+ 3  3 1
+ 7  3 1
+12  3 1
+21  3 1
+22  3 1
+23  3 1
+ 4  4 1
+ 8  4 1
+11  4 1
+16  4 1
+19  4 1
+20  4 1
+ 5  5 1
+ 8  5 1
+10  5 1
+15  5 1
+16  5 1
+17  5 1
+ 1  6 1
+ 6  6 1
+ 7  6 1
+13  6 1
+14  6 1
+18  6 1
+ 1  7 1
+ 3  7 1
+ 6  7 1
+ 7  7 1
+12  7 1
+13  7 1
+20  7 1
+22  7 1
+24  7 1
+ 4  8 1
+ 5  8 1
+ 8  8 1
+10  8 1
+15  8 1
+16  8 1
+17  8 1
+18  8 1
+19  8 1
+ 2  9 1
+ 9  9 1
+10  9 1
+15  9 1
+ 2 10 1
+ 5 10 1
+ 8 10 1
+ 9 10 1
+10 10 1
+14 10 1
+15 10 1
+18 10 1
+19 10 1
+ 4 11 1
+11 11 1
+19 11 1
+20 11 1
+21 11 1
+22 11 1
+ 3 12 1
+ 7 12 1
+12 12 1
+13 12 1
+22 12 1
+24 12 1
+ 1 13 1
+ 6 13 1
+ 7 13 1
+12 13 1
+13 13 1
+24 13 1
+ 1 14 1
+ 2 14 1
+ 6 14 1
+10 14 1
+14 14 1
+18 14 1
+ 2 15 1
+ 5 15 1
+ 8 15 1
+ 9 15 1
+10 15 1
+15 15 1
+ 4 16 1
+ 5 16 1
+ 8 16 1
+16 16 1
+17 16 1
+19 16 1
+ 5 17 1
+ 8 17 1
+16 17 1
+17 17 1
+ 1 18 1
+ 2 18 1
+ 6 18 1
+ 8 18 1
+10 18 1
+14 18 1
+18 18 1
+19 18 1
+20 18 1
+ 1 19 1
+ 4 19 1
+ 8 19 1
+10 19 1
+11 19 1
+16 19 1
+18 19 1
+19 19 1
+20 19 1
+ 1 20 1
+ 4 20 1
+ 7 20 1
+11 20 1
+18 20 1
+19 20 1
+20 20 1
+21 20 1
+22 20 1
+ 3 21 1
+11 21 1
+20 21 1
+21 21 1
+22 21 1
+23 21 1
+ 1 22 1
+ 3 22 1
+ 7 22 1
+11 22 1
+12 22 1
+20 22 1
+21 22 1
+22 22 1
+23 22 1
+ 3 23 1
+21 23 1
+22 23 1
+23 23 1
+ 7 24 1
+12 24 1
+13 24 1
+24 24 1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..68c033497d71dad21ca8902eaea59d2a3ae887af
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CAMD/README.txt
@@ -0,0 +1,171 @@
+CAMD, Copyright (c) 2007-2013, University of Florida.
+Written by Timothy A. Davis (http://www.suitesparse.com), Yanqing Chen, Patrick
+R. Amestoy, and Iain S. Duff.  All Rights Reserved.  CAMD is available under
+alternate licences; contact T. Davis for details.
+
+CAMD:  a set of routines for permuting sparse matrices prior to
+    factorization.  Includes a version in C, a version in Fortran, and a MATLAB
+    mexFunction.
+
+Requires SuiteSparse_config, in the ../SuiteSparse_config directory relative to
+this directory.
+
+Quick start (Unix, or Windows with Cygwin):
+
+    To compile, test, and install CAMD, you may wish to first configure the
+    installation by editting the ../SuiteSparse_config/SuiteSparse_config.mk
+    file.  Next, cd to this directory (CAMD) and type "make" (or "make lib" if
+    you do not have MATLAB).  When done, type "make clean" to remove unused *.o
+    files (keeps the compiled libraries and demo programs).  See the User Guide
+    (Doc/CAMD_UserGuide.pdf), or ../SuiteSparse_config/SuiteSparse_config.mk
+    for more details.  To install do "make install".
+
+Quick start (for MATLAB users);
+
+    To compile, test, and install the CAMD mexFunction, cd to the
+    CAMD/MATLAB directory and type camd_make at the MATLAB prompt.
+
+-------------------------------------------------------------------------------
+
+CAMD License: refer to CAMD/Doc/License.txt
+
+Availability:
+
+    http://www.suitesparse.com
+
+-------------------------------------------------------------------------------
+
+This is the CAMD README file.  It is a terse overview of CAMD.
+Refer to the User Guide (Doc/CAMD_UserGuide.pdf) for how to install
+and use CAMD.
+
+Description:
+
+    CAMD is a set of routines for pre-ordering sparse matrices prior to Cholesky
+    or LU factorization, using the approximate minimum degree ordering
+    algorithm with optional ordering constraints.  Written in ANSI/ISO C with
+    a MATLAB interface.
+
+Authors:
+
+    Timothy A. Davis (DrTimothyAldenDavis@gmail.com)
+    Patrick R. Amestory, ENSEEIHT, Toulouse, France.
+    Iain S. Duff, Rutherford Appleton Laboratory, UK.
+
+Acknowledgements:
+
+    This work was supported by the National Science Foundation, under
+    grants DMS-9504974, DMS-9803599, and CCR-0203270.
+
+    Portions of this work were done while on sabbatical at Stanford University
+    and Lawrence Berkeley National Laboratory (with funding from the SciDAC
+    program).  I would like to thank Gene Golub, Esmond Ng, and Horst Simon
+    for making this sabbatical possible.
+
+-------------------------------------------------------------------------------
+Files and directories in the CAMD distribution:
+-------------------------------------------------------------------------------
+
+    ---------------------------------------------------------------------------
+    Subdirectories of the CAMD directory:
+    ---------------------------------------------------------------------------
+
+    Doc		documentation
+    Source	primary source code
+    Include	include file for use in your code that calls CAMD
+    Demo	demo programs.  also serves as test of the CAMD installation.
+    MATLAB	CAMD mexFunction for MATLAB, and supporting m-files
+    Lib		where the compiled C-callable and Fortran-callable
+		CAMD libraries placed.
+
+    ---------------------------------------------------------------------------
+    Files in the CAMD directory:
+    ---------------------------------------------------------------------------
+
+    Makefile	top-level Makefile.
+		Windows users would require Cygwin to use "make"
+
+    README.txt	this file
+
+    ---------------------------------------------------------------------------
+    Doc directory: documentation
+    ---------------------------------------------------------------------------
+
+    ChangeLog			change log
+    License.txt			the CAMD License
+    Makefile			for creating the documentation
+    CAMD_UserGuide.bib		CAMD User Guide (references)
+    CAMD_UserGuide.tex		CAMD User Guide (LaTeX)
+    CAMD_UserGuide.pdf		CAMD User Guide (PDF)
+
+    docdiff			tools for comparing CAMD with AMD
+    cdiff
+    camd.sed
+
+    ---------------------------------------------------------------------------
+    Source directory:
+    ---------------------------------------------------------------------------
+
+    camd_order.c		user-callable, primary CAMD ordering routine
+    camd_control.c		user-callable, prints the control parameters
+    camd_defaults.c		user-callable, sets default control parameters
+    camd_info.c			user-callable, prints the statistics from CAMD
+
+    camd_1.c			non-user-callable, construct A+A'
+    camd_2.c			user-callable, primary ordering kernel
+				(a C version of camd.f and camdbar.f, with
+				post-ordering added)
+    camd_aat.c			non-user-callable, computes nnz (A+A')
+    camd_dump.c			non-user-callable, debugging routines
+    camd_postorder.c		non-user-callable, postorder
+    camd_valid.c		non-user-callable, verifies a matrix
+    camd_preprocess.c		non-user-callable, computes A', removes duplic
+
+    ---------------------------------------------------------------------------
+    Include directory:
+    ---------------------------------------------------------------------------
+
+    camd.h			include file for C programs that use CAMD
+    camd_internal.h		non-user-callable, include file for CAMD
+
+    ---------------------------------------------------------------------------
+    Demo directory:
+    ---------------------------------------------------------------------------
+
+    Makefile			to compile the demos
+
+    camd_demo.c			C demo program for CAMD
+    camd_demo.out		output of camd_demo.c
+
+    camd_demo2.c		C demo program for CAMD, jumbled matrix
+    camd_demo2.out		output of camd_demo2.c
+
+    camd_l_demo.c		C demo program for CAMD ("long" version)
+    camd_l_demo.out		output of camd_l_demo.c
+
+    camd_simple.c		simple C demo program for CAMD
+    camd_simple.out		output of camd_simple.c
+
+    ---------------------------------------------------------------------------
+    MATLAB directory:
+    ---------------------------------------------------------------------------
+
+    Contents.m			for "help camd" listing of toolbox contents
+
+    camd.m			MATLAB help file for CAMD
+    camd_make.m			MATLAB m-file for compiling CAMD mexFunction
+    camd_install.m		compile and install CAMD mexFunctions
+
+    camd_mex.c			CAMD mexFunction for MATLAB
+
+    camd_demo.m			MATLAB demo for CAMD
+    camd_demo.m.out		diary output of camd_demo.m
+    can_24.mat			input file for CAMD demo
+
+    ---------------------------------------------------------------------------
+    Lib directory:  libcamd.a and libcamd.so library placed here
+    ---------------------------------------------------------------------------
+
+    Makefile			Makefile for both shared and static libraries
+    old/                        old version of Makefiles
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/ChangeLog b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/ChangeLog
new file mode 100644
index 0000000000000000000000000000000000000000..7640c626bb9826e2ae2fd6298a67e9b27ea44c71
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/ChangeLog
@@ -0,0 +1,175 @@
+May 4, 2016: version 2.9.6
+
+    * minor changes to Makefile
+
+Apr 1, 2016: version 2.9.5
+
+    * licensing simplified (no other change); refer to COLAMD/Doc/License.txt
+
+Feb 1, 2016: version 2.9.4
+
+    * update to Makefiles
+
+Jan 30, 2016: version 2.9.3
+
+    * modifications to Makefiles
+
+Jan 1, 2016: version 2.9.2
+
+    * modified Makefile to create shared libraries
+        No change to C code except version number.
+        The empty file colamd_global.c removed.
+
+Oct 10, 2014: version 2.9.1
+
+    modified MATLAB/colamd_make.m.  No change to C code except version number.
+
+July 31, 2013: version 2.9.0
+
+    * changed malloc and printf pointers to use SuiteSparse_config
+
+Jun 1, 2012: version 2.8.0
+
+    * UFconfig replaced with SuiteSparse_config
+
+Dec 7, 2011: version 2.7.4
+
+    * fixed the Makefile to better align with CFLAGS and other standards
+
+Jan 25, 2011: version 2.7.3
+
+    * minor fix to "make install"
+
+Nov 30, 2009: version 2.7.2
+
+    * added "make install" and "make uninstall"
+
+May 31, 2007: version 2.7.0
+
+    * ported to 64-bit MATLAB
+
+    * subdirectories added (Source/, Include/, Lib/, Doc/, MATLAB/, Demo/)
+
+Dec 12, 2006, version 2.5.2
+
+    * minor MATLAB cleanup.  MATLAB functions renamed colamd2 and symamd2,
+	so that they do not conflict with the built-in versions.  Note that
+	the MATLAB built-in functions colamd and symamd are identical to
+	the colamd and symamd functions here.
+
+Aug 31, 2006: Version 2.5.1
+
+    * minor change to colamd.m and symamd.m, to use etree instead
+	of sparsfun.
+
+Apr. 30, 2006: Version 2.5
+
+    * colamd_recommended modified, to do more careful integer overflow
+	checking.  It now returns size_t, not int.  colamd_l_recommended
+	also returns size_t.  A zero is returned if an error occurs.  A
+	postive return value denotes success.  In v2.4 and earlier,
+	-1 was returned on error (an int or long).
+
+    * long replaced with UF_long integer, which is long except on WIN64.
+
+Nov 15, 2005:
+
+    * minor editting of comments; version number (2.4) unchanged.
+
+Changes from Version 2.3 to 2.4 (Aug 30, 2005)
+
+    * Makefile now relies on ../UFconfig/UFconfig.mk
+
+    * changed the dense row/col detection.  The meaning of the knobs
+	has thus changed.
+
+    * added an option to turn off aggressive absorption.  It was
+	always on in versions 2.3 and earlier.
+
+    * added a #define'd version number
+
+    * added a function pointer (colamd_printf) for COLAMD's printing.
+
+    * added a -DNPRINT option, to turn off printing at compile-time.
+
+    * added a check for integer overflow in colamd_recommended
+
+    * minor changes to allow for more simpler 100% test coverage
+
+    * bug fix.  If symamd v2.3 fails to allocate its copy of the input
+	matrix, then it erroneously frees a calloc'd workspace twice.
+	This bug has no effect on the MATLAB symamd mexFunction, since
+	mxCalloc terminates the mexFunction if it fails to allocate
+	memory.  Similarly, UMFPACK is not affected because it does not
+	use symamd.  The bug has no effect on the colamd ordering
+	routine in v2.3.
+
+Changes from Version 2.2 to 2.3 (Sept. 8, 2003)
+
+    * removed the call to the MATLAB spparms ('spumoni') function.
+	This can take a lot of time if you are ordering many small
+	matrices.  Only affects the MATLAB interface (colamdmex.c,
+	symamdmex.c, colamdtestmex.c, and symamdtestmex.c).  The
+	usage of the optional 2nd argument to the colamd and symamd
+	mexFunctions was changed accordingly.
+
+Changes from Version 2.1 to 2.2 (Sept. 23, 2002)
+
+    * extensive testing routines added (colamd_test.m, colamdtestmex.c,
+	and symamdtestmex.c), and the Makefile modified accordingly.
+
+    * a few typos in the comments corrected 
+
+    * use of the MATLAB "flops" command removed from colamd_demo, and an
+	m-file routine luflops.m added.
+
+    * an explicit typecast from unsigned to int added, for COLAMD_C and
+	COLAMD_R in colamd.h.
+
+    * #include <stdio.h> added to colamd_example.c
+
+
+Changes from Version 2.0 to 2.1 (May 4, 2001)
+
+    * TRUE and FALSE are predefined on some systems, so they are defined
+	    here only if not already defined.
+    
+    * web site changed
+
+    * UNIX Makefile modified, to handle the case if "." is not in your path.
+
+
+Changes from Version 1.0 to 2.0 (January 31, 2000)
+
+    No bugs were found in version 1.1.  These changes merely add new
+    functionality.
+
+    * added the COLAMD_RECOMMENDED (nnz, n_row, n_col) macro.
+
+    * moved the output statistics, from A, to a separate output argument.
+	    The arguments changed for the C-callable routines.
+
+    * added colamd_report and symamd_report.
+
+    * added a C-callable symamd routine.  Formerly, symamd was only
+	    available as a mexFunction from MATLAB.
+
+    * added error-checking to symamd.  Formerly, it assumed its input
+	    was error-free.
+
+    * added the optional stats and knobs arguments to the symamd mexFunction
+
+    * deleted colamd_help.  A help message is still available from
+	    "help colamd" and "help symamd" in MATLAB.
+
+    * deleted colamdtree.m and symamdtree.m.  Now, colamd.m and symamd.m
+	    also do the elimination tree post-ordering.  The Version 1.1
+	    colamd and symamd mexFunctions, which do not do the post-
+	    ordering, are now visible as colamdmex and symamdmex from
+	    MATLAB.  Essentialy, the post-ordering is now the default
+	    behavior of colamd.m and symamd.m, to match the behavior of
+	    colmmd and symmmd.  The post-ordering is only available in the
+	    MATLAB interface, not the C-callable interface.
+
+    * made a slight change to the dense row/column detection in symamd,
+	    to match the stated specifications.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/License.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..07bde42fed23208c91738ee787d3818a3d108ea3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/License.txt
@@ -0,0 +1,18 @@
+COLAMD, Copyright 1998-2016, Timothy A. Davis.  http://www.suitesparse.com
+http://www.suitesparse.com
+
+--------------------------------------------------------------------------------
+
+COLAMD is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+COLAMD is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this Module; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/lesser.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/lesser.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8add30ad590a65db7e5914f5417eac39a64402a3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/Doc/lesser.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/Contents.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..960fd14727d94972d3eae2d3e307cf83edef9fe4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/Contents.m
@@ -0,0 +1,19 @@
+% COLAMD, column approximate minimum degree ordering
+%
+% Primary:
+%   colamd2     - Column approximate minimum degree permutation.
+%   symamd2     - SYMAMD Symmetric approximate minimum degree permutation.
+%
+% helper and test functions:
+%   colamd_demo - demo for colamd, column approx minimum degree ordering algorithm
+%   colamd_make - compiles COLAMD2 and SYMAMD2 for MATLAB
+%   colamd_make - compiles and installs COLAMD2 and SYMAMD2 for MATLAB
+%   colamd_test - test colamd2 and symamd2
+%   luflops     - compute the flop count for sparse LU factorization
+%
+% Example:
+%   p = colamd2 (A)
+%
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd2.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd2.m
new file mode 100644
index 0000000000000000000000000000000000000000..9916cc7f9b8668592cbefd6ffc24d5f5791b6fb5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd2.m
@@ -0,0 +1,87 @@
+function [p,stats] = colamd2 (S, knobs)
+%COLAMD2 Column approximate minimum degree permutation.
+%    P = COLAMD2(S) returns the column approximate minimum degree permutation
+%    vector for the sparse matrix S.  For a non-symmetric matrix S, S(:,P)
+%    tends to have sparser LU factors than S.  The Cholesky factorization of
+%    S(:,P)'*S(:,P) also tends to be sparser than that of S'*S.  The ordering
+%    is followed by a column elimination tree post-ordering.
+%
+%    Note that this function is the source code for the built-in MATLAB colamd
+%    function.  It has been renamed here to colamd2 to avoid a filename clash.
+%    colamd and colamd2 are identical.
+%
+%    See also COLAMD, AMD, SYMAMD, SYMAMD2.
+%
+%    Example:
+%            P = colamd2 (S)
+%            [P, stats] = colamd2 (S, knobs)
+%
+%    knobs is an optional one- to three-element input vector.  If S is m-by-n,
+%    then rows with more than max(16,knobs(1)*sqrt(n)) entries are ignored.
+%    Columns with more than max(16,knobs(2)*sqrt(min(m,n))) entries are
+%    removed prior to ordering, and ordered last in the output permutation P.
+%    Only completely dense rows or columns are removed if knobs(1) and knobs(2)
+%    are < 0, respectively.  If knobs(3) is nonzero, stats and knobs are
+%    printed.  The default is knobs = [10 10 0].  Note that knobs differs from
+%    earlier versions of colamd.
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
+%
+%    Acknowledgements: This work was supported by the National Science
+%       Foundation, under grants DMS-9504974 and DMS-9803599.
+
+%-------------------------------------------------------------------------------
+% Perform the colamd ordering:
+%-------------------------------------------------------------------------------
+
+if (nargout <= 1 & nargin == 1)						    %#ok
+    p = colamd2mex (S) ;
+elseif (nargout <= 1 & nargin == 2)					    %#ok
+    p = colamd2mex (S, knobs) ;
+elseif (nargout == 2 & nargin == 1)					    %#ok
+    [p, stats] = colamd2mex (S) ;
+elseif (nargout == 2 & nargin == 2)					    %#ok
+    [p, stats] = colamd2mex (S, knobs) ;
+else
+    error ('colamd:  incorrect number of input and/or output arguments') ;
+end
+
+%-------------------------------------------------------------------------------
+% column elimination tree post-ordering:
+%-------------------------------------------------------------------------------
+
+[ignore, q] = etree (S (:,p), 'col') ;
+p = p (q) ;
+
+%    stats is an optional 20-element output vector that provides data about the
+%    ordering and the validity of the input matrix S.  Ordering statistics are
+%    in stats (1:3).  stats (1) and stats (2) are the number of dense or empty
+%    rows and columns ignored by COLAMD and stats (3) is the number of
+%    garbage collections performed on the internal data structure used by
+%    COLAMD (roughly of size 2.2*nnz(S) + 4*m + 7*n integers).
+%
+%    MATLAB built-in functions are intended to generate valid sparse matrices,
+%    with no duplicate entries, with ascending row indices of the nonzeros
+%    in each column, with a non-negative number of entries in each column (!)
+%    and so on.  If a matrix is invalid, then COLAMD may or may not be able
+%    to continue.  If there are duplicate entries (a row index appears two or
+%    more times in the same column) or if the row indices in a column are out
+%    of order, then COLAMD can correct these errors by ignoring the duplicate
+%    entries and sorting each column of its internal copy of the matrix S (the
+%    input matrix S is not repaired, however).  If a matrix is invalid in other
+%    ways then COLAMD cannot continue, an error message is printed, and no
+%    output arguments (P or stats) are returned.  COLAMD is thus a simple way
+%    to check a sparse matrix to see if it's valid.
+%
+%    stats (4:7) provide information if COLAMD was able to continue.  The
+%    matrix is OK if stats (4) is zero, or 1 if invalid.  stats (5) is the
+%    rightmost column index that is unsorted or contains duplicate entries,
+%    or zero if no such column exists.  stats (6) is the last seen duplicate
+%    or out-of-order row index in the column index given by stats (5), or zero
+%    if no such row index exists.  stats (7) is the number of duplicate or
+%    out-of-order row indices.
+%
+%    stats (8:20) is always zero in the current version of COLAMD (reserved
+%    for future use).
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_demo.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_demo.m
new file mode 100644
index 0000000000000000000000000000000000000000..47176f4ad8fd56cc646e4c14ab4cd0075cd82b8f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_demo.m
@@ -0,0 +1,178 @@
+%COLAMD_DEMO demo for colamd, column approx minimum degree ordering algorithm
+%
+% Example:
+%   colamd_demo
+% 
+% The following m-files and mexFunctions provide alternative sparse matrix
+% ordering methods for MATLAB.  They are typically faster (sometimes much
+% faster) and typically provide better orderings than their MATLAB counterparts:
+% 
+%       colamd          a replacement for colmmd.
+%
+%                       Typical usage:  p = colamd (A) ;
+%
+%       symamd          a replacement for symmmd.  Based on colamd.
+%
+%                       Typical usage:  p = symamd (A) ;
+%
+% For a description of the methods used, see the colamd.c file.
+% http://www.suitesparse.com
+%
+% See also colamd, symamd
+
+% Minor changes:  in MATLAB 7, symmmd and colmmd are flagged as "obsolete".
+% This demo checks if they exist, so it should still work when they are removed.
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
+
+%-------------------------------------------------------------------------------
+% Print the introduction, the help info, and compile the mexFunctions
+%-------------------------------------------------------------------------------
+
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, 'Colamd2/symamd2 demo.') ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+help colamd_demo ;
+
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, 'Colamd help information:') ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+help colamd2 ;
+
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, 'Symamd help information:') ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+help symamd2 ;
+
+%-------------------------------------------------------------------------------
+% Solving Ax=b
+%-------------------------------------------------------------------------------
+
+n = 100 ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, 'Solving Ax=b for a small %d-by-%d random matrix:', n, n) ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, '\nNote: Random sparse matrices are AWFUL test cases.\n') ;
+fprintf (1, 'They''re just easy to generate in a demo.\n') ;
+
+% set up the system
+
+rand ('state', 0) ;
+randn ('state', 0) ;
+spparms ('default') ;
+A = sprandn (n, n, 5/n) + speye (n) ;
+b = (1:n)' ;
+
+fprintf (1, '\n\nSolving via lu (PAQ = LU), where Q is from colamd2:\n') ;
+q = colamd2 (A) ;
+I = speye (n) ;
+Q = I (:, q) ;
+[L,U,P] = lu (A*Q) ;
+fl = luflops (L, U) ;
+x = Q * (U \ (L \ (P * b))) ;
+fprintf (1, '\nFlop count for [L,U,P] = lu (A*Q):          %d\n', fl) ;
+fprintf (1, 'residual:                                     %e\n', norm (A*x-b));
+
+try
+    fprintf (1, '\n\nSolving via lu (PAQ = LU), where Q is from colmmd:\n') ;
+    q = colmmd (A) ;
+    I = speye (n) ;
+    Q = I (:, q) ;
+    [L,U,P] = lu (A*Q) ;
+    fl = luflops (L, U) ;
+    x = Q * (U \ (L \ (P * b))) ;
+    fprintf (1, '\nFlop count for [L,U,P] = lu (A*Q):          %d\n', fl) ;
+    fprintf (1, 'residual:                                     %e\n', ...
+	norm (A*x-b)) ;
+catch
+    fprintf (1, 'colmmd is obsolete; test skipped\n') ;
+end
+
+fprintf (1, '\n\nSolving via lu (PA = LU), without regard for sparsity:\n') ;
+[L,U,P] = lu (A) ;
+fl = luflops (L, U) ;
+x = U \ (L \ (P * b)) ;
+fprintf (1, '\nFlop count for [L,U,P] = lu (A*Q):          %d\n', fl) ;
+fprintf (1, 'residual:                                     %e\n', norm (A*x-b));
+
+%-------------------------------------------------------------------------------
+% Large demo for colamd2
+%-------------------------------------------------------------------------------
+
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, 'Large demo for colamd2 (symbolic analysis only):') ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+
+rand ('state', 0) ;
+randn ('state', 0) ;
+spparms ('default') ;
+n = 1000 ;
+fprintf (1, 'Generating a random %d-by-%d sparse matrix.\n', n, n) ;
+A = sprandn (n, n, 5/n) + speye (n) ;
+
+fprintf (1, '\n\nUnordered matrix:\n') ;
+lnz = symbfact (A, 'col') ;
+fprintf (1, 'nz in Cholesky factors of A''A:            %d\n', sum (lnz)) ;
+fprintf (1, 'flop count for Cholesky of A''A:           %d\n', sum (lnz.^2)) ;
+
+tic ;
+p = colamd2 (A) ;
+t = toc ;
+lnz = symbfact (A (:,p), 'col') ;
+fprintf (1, '\n\nColamd run time:                          %f\n', t) ;
+fprintf (1, 'colamd2 ordering quality: \n') ;
+fprintf (1, 'nz in Cholesky factors of A(:,p)''A(:,p):  %d\n', sum (lnz)) ;
+fprintf (1, 'flop count for Cholesky of A(:,p)''A(:,p): %d\n', sum (lnz.^2)) ;
+
+try
+    tic ;
+    p = colmmd (A) ;
+    t = toc ;
+    lnz = symbfact (A (:,p), 'col') ;
+    fprintf (1, '\n\nColmmd run time:                          %f\n', t) ;
+    fprintf (1, 'colmmd ordering quality: \n') ;
+    fprintf (1, 'nz in Cholesky factors of A(:,p)''A(:,p):  %d\n', sum (lnz)) ;
+    fprintf (1, 'flop count for Cholesky of A(:,p)''A(:,p): %d\n', ...
+	sum (lnz.^2)) ;
+catch
+    fprintf (1, 'colmmd is obsolete; test skipped\n') ;
+end
+
+%-------------------------------------------------------------------------------
+% Large demo for symamd2
+%-------------------------------------------------------------------------------
+
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+fprintf (1, 'Large demo for symamd2 (symbolic analysis only):') ;
+fprintf (1, '\n-----------------------------------------------------------\n') ;
+
+fprintf (1, 'Generating a random symmetric %d-by-%d sparse matrix.\n', n, n) ;
+A = A+A' ;
+
+fprintf (1, '\n\nUnordered matrix:\n') ;
+lnz = symbfact (A, 'sym') ;
+fprintf (1, 'nz in Cholesky factors of A:       %d\n', sum (lnz)) ;
+fprintf (1, 'flop count for Cholesky of A:      %d\n', sum (lnz.^2)) ;
+
+tic ;
+p = symamd2 (A) ;
+t = toc ;
+lnz = symbfact (A (p,p), 'sym') ;
+fprintf (1, '\n\nSymamd run time:                   %f\n', t) ;
+fprintf (1, 'symamd2 ordering quality: \n') ;
+fprintf (1, 'nz in Cholesky factors of A(p,p):  %d\n', sum (lnz)) ;
+fprintf (1, 'flop count for Cholesky of A(p,p): %d\n', sum (lnz.^2)) ;
+
+try
+    tic ;
+    p = symmmd (A) ;
+    t = toc ;
+    lnz = symbfact (A (p,p), 'sym') ;
+    fprintf (1, '\n\nSymmmd run time:                   %f\n', t) ;
+    fprintf (1, 'symmmd ordering quality: \n') ;
+    fprintf (1, 'nz in Cholesky factors of A(p,p):  %d\n', sum (lnz)) ;
+    fprintf (1, 'flop count for Cholesky of A(p,p): %d\n', sum (lnz.^2)) ;
+catch
+    fprintf (1, 'symmmd is obsolete\n') ;
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_install.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_install.m
new file mode 100644
index 0000000000000000000000000000000000000000..7ac0110b95dad16af62d888a1a8c8a29e7bd8cb3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_install.m
@@ -0,0 +1,18 @@
+function colamd_install
+%COLAMD_MAKE to compile and install the colamd2 and symamd2 mexFunction.
+%   Your current directory must be COLAMD/MATLAB for this function to work.
+%
+% Example:
+%   colamd_install
+%
+% See also colamd2, symamd2.
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
+
+colamd_make
+addpath (pwd)
+fprintf ('\nThe following path has been added.  You may wish to add it\n') ;
+fprintf ('permanently, using the MATLAB pathtool command.\n') ;
+fprintf ('%s\n\n', pwd) ;
+colamd_demo
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_make.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_make.m
new file mode 100644
index 0000000000000000000000000000000000000000..1491cf191f36b20fa705fa8694717e1fed2f4694
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_make.m
@@ -0,0 +1,48 @@
+function colamd_make
+%COLAMD_MAKE compiles COLAMD2 and SYMAMD2 for MATLAB
+%
+% Example:
+%   colamd_make
+%
+% See also colamd, symamd
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
+
+details = 0 ;	    % 1 if details of each command are to be printed
+d = '' ;
+if (~isempty (strfind (computer, '64')))
+    d = '-largeArrayDims' ;
+end
+
+% MATLAB 8.3.0 now has a -silent option to keep 'mex' from burbling too much
+if (~verLessThan ('matlab', '8.3.0'))
+    d = ['-silent ' d] ;
+end
+
+src = '../Source/colamd.c ../../SuiteSparse_config/SuiteSparse_config.c' ;
+cmd = sprintf ( ...
+    'mex -DDLONG -O %s -I../../SuiteSparse_config -I../Include -output ', d) ;
+s = [cmd 'colamd2mex colamdmex.c ' src] ;
+
+if (~(ispc || ismac))
+    % for POSIX timing routine
+    s = [s ' -lrt'] ;
+end
+
+if (details)
+    fprintf ('%s\n', s) ;
+end
+eval (s) ;
+s = [cmd 'symamd2mex symamdmex.c ' src] ;
+
+if (~(ispc || ismac))
+    % for POSIX timing routine
+    s = [s ' -lrt'] ;
+end
+
+if (details)
+    fprintf ('%s\n', s) ;
+end
+eval (s) ;
+fprintf ('COLAMD2 and SYMAMD2 successfully compiled.\n') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_test.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_test.m
new file mode 100644
index 0000000000000000000000000000000000000000..6c6dac51cb8bbbb3bce604a75f3a517350b71e1c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/colamd_test.m
@@ -0,0 +1,510 @@
+function colamd_test
+%COLAMD_TEST test colamd2 and symamd2
+% Example:
+%   colamd_test
+%
+% COLAMD and SYMAMD testing function.  Here we try to give colamd2 and symamd2
+% every possible type of matrix and erroneous input that they may encounter. 
+% We want either a valid permutation returned or we want them to fail
+% gracefully.
+%
+% You are prompted as to whether or not the colamd2 and symand routines and
+% the test mexFunctions are to be compiled.
+%
+% See also colamd2, symamd2
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
+
+
+help colamd_test
+
+
+    fprintf ('Compiling colamd2, symamd2, and test mexFunctions.\n') ;
+    colamd_make ;
+
+    d = '' ;
+    if (~isempty (strfind (computer, '64')))
+	d = '-largeArrayDims' ;
+    end
+    cmd = sprintf (...
+        'mex -DDLONG -O %s -I../../SuiteSparse_config -I../Include ', d) ;
+    src = '../Source/colamd.c ../../SuiteSparse_config/SuiteSparse_config.c' ;
+    if (~(ispc || ismac))
+        % for POSIX timing routine
+        src = [src ' -lrt'] ;
+    end
+    eval ([cmd 'colamdtestmex.c ' src]) ;
+    eval ([cmd 'symamdtestmex.c ' src]) ;
+    fprintf ('Done compiling.\n') ; 
+
+
+fprintf ('\nThe following codes will be tested:\n') ;
+which colamd2 
+which symamd2
+which colamd2mex
+which symamd2mex
+which colamdtestmex
+which symamdtestmex
+
+fprintf ('\nStarting the tests.  Please be patient.\n') ;
+
+h = waitbar (0, 'COLAMD test') ;
+
+rand ('state', 0) ;
+randn ('state', 0) ;
+
+A = sprandn (500,500,0.4) ;
+
+p = colamd2 (A, [10 10 1]) ; check_perm (p, A) ;
+p = colamd2 (A, [2  7  1]) ; check_perm (p, A) ;
+p = symamd2 (A, [10 1]) ; check_perm (p, A) ;
+p = symamd2 (A, [7  1]) ; check_perm (p, A) ;
+p = symamd2 (A, [4  1]) ; check_perm (p, A) ;
+
+
+fprintf ('Null matrices') ;
+A = zeros (0,0) ;
+A = sparse (A) ;
+
+[p, stats] = colamd2 (A, [10 10 0]) ;					    %#ok
+check_perm (p, A) ;
+
+[p, stats] = symamd2 (A, [10 0]) ;					    %#ok
+check_perm (p, A) ;
+
+A = zeros (0, 100) ;
+A = sparse (A) ;
+[p, stats] = colamd2 (A, [10 10 0]) ;					    %#ok
+check_perm (p, A) ;
+
+A = zeros (100, 0) ;
+A = sparse (A) ;
+[p, stats] = colamd2 (A, [10 10 0]) ;
+check_perm (p, A) ;
+fprintf (' OK\n') ;
+
+
+fprintf ('Matrices with a few dense row/cols\n') ;
+
+for trial = 1:20
+
+    waitbar (trial/20, h, 'COLAMD: with dense rows/cols') ;
+
+    % random square unsymmetric matrix
+    A = rand_matrix (1000, 1000, 1, 10, 20) ;
+
+    for tol = [0:.1:2 3:20 1e6]
+
+	[p, stats] = colamd2 (A, [tol tol 0]) ;				    %#ok
+	check_perm (p, A) ;
+
+	B = A + A' ;
+	[p, stats] = symamd2 (B, [tol 0]) ;				    %#ok
+	check_perm (p, A) ;
+
+	[p, stats] = colamd2 (A, [tol 1 0]) ;				    %#ok
+	check_perm (p, A) ;
+
+	[p, stats] = colamd2 (A, [1 tol 0]) ;				    %#ok
+	check_perm (p, A) ;
+    end
+end
+fprintf (' OK\n') ;
+
+fprintf ('General matrices\n') ;
+for trial = 1:400
+
+    waitbar (trial/400, h, 'COLAMD: general') ;
+
+    % matrix of random mtype
+    mtype = irand (3) ;
+    A = rand_matrix (2000, 2000, mtype, 0, 0) ;
+    p = colamd2 (A) ;
+    check_perm (p, A) ;
+    if (mtype == 3)
+	p = symamd2 (A) ;
+	check_perm (p, A) ;
+    end
+
+end
+fprintf (' OK\n') ;
+
+fprintf ('Test error handling with invalid inputs\n') ;
+
+% Check different erroneous input.
+for trial = 1:30
+
+    waitbar (trial/30, h, 'COLAMD: error handling') ;
+
+    A = rand_matrix (1000, 1000, 2, 0, 0) ;
+    [m n] = size (A) ;
+
+    for err = 1:13
+
+        p = Tcolamd (A, [n n 0 0 err]) ;
+        if (p ~= -1)							    %#ok
+	    check_perm (p, A) ;
+	end
+
+	if (err == 1)
+	    % check different (valid) input args to colamd2
+	    p = Acolamd (A) ;
+
+	    p2 = Acolamd (A, [10 10 0 0 0]) ;
+	    if (any (p ~= p2))
+		error ('colamd2: mismatch 1!') ;
+	    end
+	    [p2 stats] = Acolamd (A) ;					    %#ok
+	    if (any (p ~= p2))
+		error ('colamd2: mismatch 2!') ;
+	    end
+	    [p2 stats] = Acolamd (A, [10 10 0 0 0]) ;
+	    if (any (p ~= p2))
+		error ('colamd2: mismatch 3!') ;
+	    end
+	end
+
+	B = A'*A ;
+        p = Tsymamd (B, [n 0 err]) ;
+        if (p ~= -1)							    %#ok
+	    check_perm (p, A) ;
+	end
+
+	if (err == 1)
+
+	    % check different (valid) input args to symamd2
+	    p = Asymamd (B) ;
+	    check_perm (p, A) ;
+	    p2 = Asymamd (B, [10 0 0]) ;
+	    if (any (p ~= p2))
+		error ('symamd2: mismatch 1!') ;
+	    end
+	    [p2 stats] = Asymamd (B) ;					    %#ok
+	    if (any (p ~= p2))
+		error ('symamd2: mismatch 2!') ;
+	    end
+	    [p2 stats] = Asymamd (B, [10 0 0]) ;			    %#ok
+	    if (any (p ~= p2))
+		error ('symamd2: mismatch 3!') ;
+	    end
+	end
+
+    end
+
+end
+fprintf (' OK\n') ;
+
+fprintf ('Matrices with a few empty columns\n') ;
+
+for trial = 1:400
+
+    % some are square, some are rectangular
+    n = 0 ;
+    while (n < 5)
+	A = rand_matrix (1000, 1000, irand (2), 0, 0) ;
+	[m n] = size (A) ;
+    end
+
+    % Add 5 null columns at random locations.
+    null_col = randperm (n) ;
+    null_col = sort (null_col (1:5)) ;
+    A (:, null_col) = 0 ;
+
+    % Order the matrix and make sure that the null columns are ordered last.
+    [p, stats] = colamd2 (A, [1e6 1e6 0]) ;
+    check_perm (p, A) ;
+
+%    if (stats (2) ~= 5)
+%	stats (2)
+%	error ('colamd2: wrong number of null columns') ;
+%    end
+
+    % find all null columns in A
+    null_col = find (sum (spones (A), 1) == 0) ;
+    nnull = length (null_col) ;						    %#ok
+    if (any (null_col ~= p ((n-4):n)))
+	error ('colamd2: Null cols are not ordered last in natural order') ;
+    end
+
+
+end
+fprintf (' OK\n') ;
+
+fprintf ('Matrices with a few empty rows and columns\n') ;
+
+for trial = 1:400
+
+    waitbar (trial/400, h, 'COLAMD: with empty rows/cols') ;
+
+    % symmetric matrices
+    n = 0 ;
+    while (n < 5)
+	A = rand_matrix (1000, 1000, 3, 0, 0) ;
+	[m n] = size (A) ;
+    end
+
+    % Add 5 null columns and rows at random locations.
+    null_col = randperm (n) ;
+    null_col = sort (null_col (1:5)) ;
+    A (:, null_col) = 0 ;
+    A (null_col, :) = 0 ;
+
+    % Order the matrix and make sure that the null rows/cols are ordered last.
+    [p,stats] = symamd2 (A, [10 0]) ;
+    check_perm (p, A) ;
+
+    % find actual number of null rows and columns
+    Alo = tril (A, -1) ;
+    nnull = length (find (sum (Alo') == 0 & sum (Alo) == 0)) ;		    %#ok
+
+    if (stats (2) ~= nnull | nnull < 5)					    %#ok
+	error ('symamd2: wrong number of null columns') ;
+    end
+    if (any (null_col ~= p ((n-4):n)))
+	error ('symamd2: Null cols are not ordered last in natural order') ;
+    end
+
+end
+fprintf (' OK\n') ;
+
+fprintf ('Matrices with a few empty rows\n') ;
+
+% Test matrices with null rows inserted.
+
+for trial = 1:400
+
+    waitbar (trial/400, h, 'COLAMD: with null rows') ;
+
+    m = 0 ;
+    while (m < 5)
+	A = rand_matrix (1000, 1000, 2, 0, 0) ;
+	[m n] = size (A) ;						    %#ok
+    end
+
+    % Add 5 null rows at random locations.
+    null_row = randperm (m) ;
+    null_row = sort (null_row (1:5)) ;
+    A (null_row, :) = 0 ;
+
+    p = colamd2 (A, [10 10 0]) ;
+    check_perm (p, A) ;
+    if (stats (1) ~= 5)
+	error ('colamd2: wrong number of null rows') ;
+    end
+
+end
+fprintf (' OK\n') ;
+
+
+fprintf ('\ncolamd2 and symamd2:  all tests passed\n\n') ;
+close (h) ;
+
+%-------------------------------------------------------------------------------
+
+function [p,stats] = Acolamd (S, knobs)
+% Acolamd:  compare colamd2 and Tcolamd results
+
+if (nargin < 3)
+    if (nargout == 1)
+	[p] = colamd2 (S) ;
+	[p1] = Tcolamd (S, [10 10 0 0 0]) ;
+    else
+	[p, stats] = colamd2 (S) ;
+	[p1, stats1] = Tcolamd (S, [10 10 0 0 0]) ;			    %#ok
+    end
+else
+    if (nargout == 1)
+	[p] = colamd2 (S, knobs (1:3)) ;
+	[p1] = Tcolamd (S, knobs) ;
+    else
+	[p, stats] = colamd2 (S, knobs (1:3)) ;
+	[p1, stats1] = Tcolamd (S, knobs) ;			    %#ok
+    end
+end
+
+check_perm (p, S) ;
+check_perm (p1, S) ;
+
+if (any (p1 ~= p))
+    error ('Acolamd mismatch!') ;
+end
+
+
+%-------------------------------------------------------------------------------
+
+function [p,stats] = Asymamd (S, knobs)
+% Asymamd:  compare symamd2 and Tsymamd results
+
+if (nargin < 3)
+    if (nargout == 1)
+	[p] = symamd2 (S) ;
+	[p1] = Tsymamd (S, [10 0 0]) ;
+    else
+	[p, stats] = symamd2 (S) ;
+	[p1, stats1] = Tsymamd (S, [10 0 0]) ;				%#ok
+    end
+else
+    if (nargout == 1)
+	[p] = symamd2 (S, knobs (1:2)) ;
+	[p1] = Tsymamd (S, knobs) ;
+    else
+	[p, stats] = symamd2 (S, knobs (1:2)) ;
+	[p1, stats1] = Tsymamd (S, knobs) ;			    %#ok
+    end
+end
+
+if (any (p1 ~= p))
+    error ('Asymamd mismatch!') ;
+end
+
+
+%-------------------------------------------------------------------------------
+
+function check_perm (p, A)
+% check_perm:  check for a valid permutation vector
+
+if (isempty (A) & isempty (p))						    %#ok
+    % empty permutation vectors of empty matrices are OK
+    return
+end
+
+if (isempty (p))
+    error ('bad permutation: cannot be empty') ;
+end
+
+[m n] = size (A) ;
+[pm pn] = size (p) ;
+if (pn == 1)
+    % force p to be a row vector
+    p = p' ;
+    [pm pn] = size (p) ;
+end
+
+if (n ~= pn)
+    error ('bad permutation: wrong size') ;
+end
+
+if (pm ~= 1) ;
+    % p must be a vector
+    error ('bad permutation: not a vector') ;
+else
+    if (any (sort (p) - (1:pn)))
+	error ('bad permutation') ;
+    end
+end
+
+%-------------------------------------------------------------------------------
+
+function i = irand (n)
+% irand: return a random integer between 1 and n
+i = min (n, 1 + floor (rand * n)) ;
+
+%-------------------------------------------------------------------------------
+
+function A = rand_matrix (nmax, mmax, mtype, drows, dcols)
+% rand_matrix:  return a random sparse matrix
+%
+% A = rand_matrix (nmax, mmax, mtype, drows, dcols)
+%
+% A binary matrix of random size, at most nmax-by-mmax, with drows dense rows
+% and dcols dense columns.
+%
+% mtype 1: square unsymmetric (mmax is ignored)
+% mtype 2: rectangular
+% mtype 3: symmetric (mmax is ignored)
+
+n = irand (nmax) ;
+if (mtype ~= 2)
+    % square
+    m = n ;
+else
+    m = irand (mmax) ;
+end
+
+A = sprand (m, n, 10 / max (m,n)) ;
+
+if (drows > 0)
+    % add dense rows
+    for k = 1:drows
+	i = irand (m) ;
+	nz = irand (n) ;
+	p = randperm (n) ;
+	p = p (1:nz) ;
+	A (i,p) = 1 ;
+    end
+end
+
+if (dcols > 0)
+    % add dense cols
+    for k = 1:dcols
+	j = irand (n) ;
+	nz = irand (m) ;
+	p = randperm (m) ;
+	p = p (1:nz) ;
+	A (p,j) = 1 ;
+    end
+end
+
+A = spones (A) ;
+
+% ensure that there are no empty columns
+d = find (full (sum (A)) == 0) ;					    %#ok
+A (m,d) = 1 ;								    %#ok
+
+% ensure that there are no empty rows
+d = find (full (sum (A,2)) == 0) ;					    %#ok
+A (d,n) = 1 ;								    %#ok
+
+if (mtype == 3)
+    % symmetric
+    A = A + A' + speye (n) ;
+end
+
+A = spones (A) ;
+
+%-------------------------------------------------------------------------------
+
+function [p,stats] = Tcolamd (S, knobs)
+% Tcolamd:  run colamd2 in a testing mode
+
+if (nargout <= 1 & nargin == 1)						    %#ok
+    p = colamdtestmex (S) ;
+elseif (nargout <= 1 & nargin == 2)					    %#ok
+    p = colamdtestmex (S, knobs) ;
+elseif (nargout == 2 & nargin == 1)					    %#ok
+    [p, stats] = colamdtestmex (S) ;
+elseif (nargout == 2 & nargin == 2)					    %#ok
+    [p, stats] = colamdtestmex (S, knobs) ;
+else
+    error ('colamd2:  incorrect number of input and/or output arguments') ;
+end
+
+if (p (1) ~= -1)
+    [ignore, q] = etree (S (:,p), 'col') ;
+    p = p (q) ;
+    check_perm (p, S) ;
+end
+
+%-------------------------------------------------------------------------------
+
+function [p, stats] = Tsymamd (S, knobs)
+% Tsymamd: run symamd2 in a testing mode
+
+if (nargout <= 1 & nargin == 1)						    %#ok
+    p = symamdtestmex (S) ;
+elseif (nargout <= 1 & nargin == 2)					    %#ok
+    p = symamdtestmex (S, knobs) ;
+elseif (nargout == 2 & nargin == 1)					    %#ok
+    [p, stats] = symamdtestmex (S) ;
+elseif (nargout == 2 & nargin == 2)					    %#ok
+    [p, stats] = symamdtestmex (S, knobs) ;
+else
+    error ('symamd2:  incorrect number of input and/or output arguments') ;
+end
+
+if (p (1) ~= -1)
+    [ignore, q] = etree (S (p,p)) ;
+    p = p (q) ;
+    check_perm (p, S) ;
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/luflops.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/luflops.m
new file mode 100644
index 0000000000000000000000000000000000000000..f3c9e453bb5f6b5d6b97342d0422bae10234fd4e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/luflops.m
@@ -0,0 +1,34 @@
+function fl = luflops (L, U)
+%LUFLOPS compute the flop count for sparse LU factorization
+%
+%  Example:
+%      fl = luflops (L,U)
+%
+%  Given a sparse LU factorization (L and U), return the flop count required
+%  by a conventional LU factorization algorithm to compute it.   L and U can
+%  be either sparse or full matrices.  L must be lower triangular and U must
+%  be upper triangular.  Do not attempt to use this on the permuted L from
+%  [L,U] = lu (A).  Instead, use [L,U,P] = lu (A) or [L,U,P,Q] = lu (A).
+%
+%  Note that there is a subtle undercount in this estimate.  Suppose A is
+%  completely dense, but during LU factorization exact cancellation occurs,
+%  causing some of the entries in L and U to become identically zero.  The
+%  flop count returned by this routine is an undercount.  There is a simple
+%  way to fix this (L = spones (L) + spones (tril (A))), but the fix is partial.
+%  It can also occur that some entry in L is a "symbolic" fill-in (zero in
+%  A, but a fill-in entry and thus must be computed), but numerically
+%  zero.  The only way to get a reliable LU factorization would be to do a
+%  purely symbolic factorization of A.  This cannot be done with
+%  symbfact (A, 'col').
+%
+%  See NA Digest, Vol 00, #50, Tuesday, Dec. 5, 2000
+%
+% See also symbfact
+
+%    Copyright 1998-2007, Timothy A. Davis
+
+
+Lnz = full (sum (spones (L))) - 1 ;	% off diagonal nz in cols of L
+Unz = full (sum (spones (U')))' - 1 ;	% off diagonal nz in rows of U
+fl = 2*Lnz*Unz + sum (Lnz) ;
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/symamd2.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/symamd2.m
new file mode 100644
index 0000000000000000000000000000000000000000..ecae450be597091bdffb4e065f3bd3d0297cee09
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/MATLAB/symamd2.m
@@ -0,0 +1,86 @@
+function [p, stats] = symamd2 (S, knobs)
+%SYMAMD Symmetric approximate minimum degree permutation.
+%    P = SYMAMD2(S) for a symmetric positive definite matrix S, returns the
+%    permutation vector p such that S(p,p) tends to have a sparser Cholesky
+%    factor than S.  Sometimes SYMAMD works well for symmetric indefinite
+%    matrices too.  The matrix S is assumed to be symmetric; only the
+%    strictly lower triangular part is referenced.   S must be square.
+%    Note that p = amd(S) is much faster and generates comparable orderings.
+%    The ordering is followed by an elimination tree post-ordering.
+%
+%    Note that this function is source code for the built-in MATLAB symamd
+%    function.  It has been renamed here to symamd2 to avoid a filename clash.
+%    symamd and symamd2 are identical.
+%
+%    See also SYMAMD, AMD, COLAMD, COLAMD2.
+%
+%    Example:
+%            P = symamd2 (S)
+%            [P, stats] = symamd2 (S, knobs)
+%
+%    knobs is an optional one- to two-element input vector.  If S is n-by-n,
+%    then rows and columns with more than max(16,knobs(1)*sqrt(n)) entries are
+%    removed prior to ordering, and ordered last in the output permutation P.
+%    No rows/columns are removed if knobs(1)<0.  If knobs(2) is nonzero, stats
+%    and knobs are printed.  The default is knobs = [10 0].  Note that knobs
+%    differs from earlier versions of symamd.
+
+%    Copyright 1998-2007, Timothy A. Davis, and Stefan Larimore
+%    Developed in collaboration with J. Gilbert and E. Ng.
+%    Acknowledgements: This work was supported by the National Science
+%       Foundation, under grants DMS-9504974 and DMS-9803599.
+
+%-------------------------------------------------------------------------------
+% perform the symamd ordering:
+%-------------------------------------------------------------------------------
+
+if (nargout <= 1 & nargin == 1)						    %#ok
+    p = symamd2mex (S) ;
+elseif (nargout <= 1 & nargin == 2)					    %#ok
+    p = symamd2mex (S, knobs) ;
+elseif (nargout == 2 & nargin == 1)					    %#ok
+    [p, stats] = symamd2mex (S) ;
+elseif (nargout == 2 & nargin == 2)					    %#ok
+    [p, stats] = symamd2mex (S, knobs) ;
+else
+    error('symamd:  incorrect number of input and/or output arguments.') ;
+end
+
+%-------------------------------------------------------------------------------
+% symmetric elimination tree post-ordering:
+%-------------------------------------------------------------------------------
+
+[ignore, q] = etree (S (p,p)) ;
+p = p (q) ;
+
+
+%    stats is an optional 20-element output vector that provides data about the
+%    ordering and the validity of the input matrix S.  Ordering statistics are
+%    in stats (1:3).  stats (1) = stats (2) is the number of dense or empty
+%    rows and columns ignored by SYMAMD and stats (3) is the number of
+%    garbage collections performed on the internal data structure used by
+%    SYMAMD (roughly of size 8.4*nnz(tril(S,-1)) + 9*n integers).
+%
+%    MATLAB built-in functions are intended to generate valid sparse matrices,
+%    with no duplicate entries, with ascending row indices of the nonzeros
+%    in each column, with a non-negative number of entries in each column (!)
+%    and so on.  If a matrix is invalid, then SYMAMD may or may not be able
+%    to continue.  If there are duplicate entries (a row index appears two or
+%    more times in the same column) or if the row indices in a column are out
+%    of order, then SYMAMD can correct these errors by ignoring the duplicate
+%    entries and sorting each column of its internal copy of the matrix S (the
+%    input matrix S is not repaired, however).  If a matrix is invalid in other
+%    ways then SYMAMD cannot continue, an error message is printed, and no
+%    output arguments (P or stats) are returned.  SYMAMD is thus a simple way
+%    to check a sparse matrix to see if it's valid.
+%
+%    stats (4:7) provide information if SYMAMD was able to continue.  The
+%    matrix is OK if stats (4) is zero, or 1 if invalid.  stats (5) is the
+%    rightmost column index that is unsorted or contains duplicate entries,
+%    or zero if no such column exists.  stats (6) is the last seen duplicate
+%    or out-of-order row index in the column index given by stats (5), or zero
+%    if no such row index exists.  stats (7) is the number of duplicate or
+%    out-of-order row indices.
+%
+%    stats (8:20) is always zero in the current version of SYMAMD (reserved
+%    for future use).
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c79343fa5572c9f1c2e7c95ecf7ba1830e25109
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/COLAMD/README.txt
@@ -0,0 +1,128 @@
+COLAMD, Copyright 1998-2016, Timothy A. Davis.  http://www.suitesparse.com
+-------------------------------------------------------------------------------
+
+The COLAMD column approximate minimum degree ordering algorithm computes
+a permutation vector P such that the LU factorization of A (:,P)
+tends to be sparser than that of A.  The Cholesky factorization of
+(A (:,P))'*(A (:,P)) will also tend to be sparser than that of A'*A.
+SYMAMD is a symmetric minimum degree ordering method based on COLAMD,
+available as a MATLAB-callable function.  It constructs a matrix M such
+that M'*M has the same pattern as A, and then uses COLAMD to compute a column
+ordering of M.  Colamd and symamd tend to be faster and generate better
+orderings than their MATLAB counterparts, colmmd and symmmd.
+
+To compile and test the colamd m-files and mexFunctions, just unpack the
+COLAMD/ directory from the COLAMD.tar.gz file, and run MATLAB from
+within that directory.  Next, type colamd_test to compile and test colamd
+and symamd.  This will work on any computer with MATLAB (Unix, PC, or Mac).
+Alternatively, type "make" (in Unix) to compile and run a simple example C
+code, without using MATLAB.
+
+To compile and install the colamd m-files and mexFunctions, just cd to
+COLAMD/MATLAB and type colamd_install in the MATLAB command window.
+A short demo will run.  Optionally, type colamd_test to run an extensive tests.
+Type "make" in Unix in the COLAMD directory to compile the C-callable
+library and to run a short demo.
+
+Colamd is a built-in routine in MATLAB, available from The 
+Mathworks, Inc.  Under most cases, the compiled COLAMD from Versions 2.0 to the
+current version do not differ.  Colamd Versions 2.2 and 2.3 differ only in their
+mexFunction interaces to MATLAB.  v2.4 fixes a bug in the symamd routine in
+v2.3.  The bug (in v2.3 and earlier) has no effect on the MATLAB symamd
+mexFunction.  v2.5 adds additional checks for integer overflow, so that
+the "int" version can be safely used with 64-bit pointers.  Refer to the
+ChangeLog for more details.
+
+Other "make" targets:
+
+    make library	compiles a C-callable library containing colamd
+    make clean		removes all files not in the distribution,
+                            but keeps the compiled libraries.
+    make distclean	removes all files not in the distribution
+    make install        installs the library in /usr/local/lib and
+                            /usr/local/include
+    make uninstall      uninstalls the library from /usr/local/lib and
+                            /usr/local/include
+
+To use colamd and symamd within an application written in C, all you need are
+colamd.c, and colamd.h, which are the C-callable
+colamd/symamd codes.  See colamd.c for more information on how to call
+colamd from a C program.
+
+Requires SuiteSparse_config, in the ../SuiteSparse_config directory relative to
+this directory.
+
+See COLAMD/Doc/License.txt for the License.
+
+Related papers:
+
+	T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, An approximate column
+	minimum degree ordering algorithm, ACM Transactions on Mathematical
+	Software, vol. 30, no. 3., pp. 353-376, 2004.
+
+	T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, Algorithm 836: COLAMD,
+	an approximate column minimum degree ordering algorithm, ACM
+	Transactions on Mathematical Software, vol. 30, no. 3., pp. 377-380,
+	2004.
+
+	"An approximate minimum degree column ordering algorithm",
+	S. I. Larimore, MS Thesis, Dept. of Computer and Information
+	Science and Engineering, University of Florida, Gainesville, FL,
+	1998.  CISE Tech Report TR-98-016.
+
+	Approximate Deficiency for Ordering the Columns of a Matrix,
+	J. L. Kern, Senior Thesis, Dept. of Computer and Information
+	Science and Engineering, University of Florida, Gainesville, FL,
+	1999.
+
+
+Authors:  Stefan I. Larimore and Timothy A. Davis,
+in collaboration with John Gilbert, Xerox PARC (now at UC Santa Barbara),
+and Esmong Ng, Lawrence Berkeley National Laboratory (much of this work
+he did while at Oak Ridge National Laboratory). 
+
+COLAMD files:
+
+    Demo	    simple demo
+    Doc		    additional documentation (see colamd.c for more)
+    Include	    include file
+    Lib		    compiled C-callable library
+    Makefile	    primary Unix Makefile
+    MATLAB	    MATLAB functions
+    README.txt	    this file
+    Source	    C source code
+
+    ./Demo:
+    colamd_example.c	    simple example
+    colamd_example.out	    output of colamd_example.c
+    colamd_l_example.c	    simple example, long integers
+    colamd_l_example.out    output of colamd_l_example.c
+    Makefile		    Makefile for C demos
+
+    ./Doc:
+    ChangeLog	    change log
+    License.txt     license
+
+    ./Include:
+    colamd.h	    include file
+
+    ./Lib:
+    Makefile	    Makefile for C-callable library
+
+    ./MATLAB:
+    colamd2.m		MATLAB interface for colamd2
+    colamd_demo.m	simple demo
+    colamd_install.m	compile and install colamd2 and symamd2
+    colamd_make.m	compile colamd2 and symamd2
+    colamdmex.ca	MATLAB mexFunction for colamd2
+    colamd_test.m	extensive test
+    colamdtestmex.c	test function for colamd
+    Contents.m		contents of the MATLAB directory
+    luflops.m		test code
+    Makefile		Makefile for MATLAB functions
+    symamd2.m		MATLAB interface for symamd2
+    symamdmex.c		MATLAB mexFunction for symamd2
+    symamdtestmex.c	test function for symamd
+
+    ./Source:
+    colamd.c		primary source code
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CSparse_to_CXSparse b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CSparse_to_CXSparse
new file mode 100644
index 0000000000000000000000000000000000000000..21be29b216dcaac8a86ade7b340454e8e4e5f2dc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/CSparse_to_CXSparse
@@ -0,0 +1,342 @@
+#! /usr/bin/perl
+# Constructs the CXSparse package from CSparse, adding four different sets of
+# functions (int/cs_long_t, and double/complex).  Backward compatible
+# with CSparse.  No MATLAB interface is provided for CXSparse, however.
+#
+# To create CXSparse from CSparse, the ./CXSparse directory should not (yet)
+# exist.  Use the following commands, where CSparse is the CSparse directory:
+#
+#   ./CSparse_to_CXSparse CSparse CXSparse CXSparse_newfiles.tar.gz
+#   cd CXSparse/Demo
+#   make > cs_demo.out
+#
+# Alternatively, use "make cx" in the SuiteSparse directory.
+#
+# Created by David Bateman, Feb. 2006, David dot Bateman atsign motorola dot
+# com, and released by him to Tim Davis' copyright.  Modified by Tim Davis,
+# 2006-2012, http://www.suitesparse.com.
+
+use strict;
+use Cwd;
+use File::Find;
+use File::Basename;
+use Text::Wrap;
+use FileHandle;
+use IPC::Open3;
+
+my $in_dir = @ARGV[0];
+my $out_dir = @ARGV[1];
+my $tar_file = @ARGV[2];
+
+#-------------------------------------------------------------------------------
+# copy all files from CSparse to CXSparse
+#-------------------------------------------------------------------------------
+
+system ("cp -pr $in_dir $out_dir") ;
+
+#-------------------------------------------------------------------------------
+# Add the new files from the tar file given by the third argument
+#-------------------------------------------------------------------------------
+
+my $old_pwd = cwd();
+chdir($out_dir);
+system ("tar xpBvzf $old_pwd/$tar_file");
+chdir($old_pwd);
+
+#-------------------------------------------------------------------------------
+# Convert Demo/* files
+#-------------------------------------------------------------------------------
+
+# convert demo *.[ch] files into the four different versions (di, dl, ci, cl)
+my @demo_files = ('demo1.c', 'demo2.c', 'demo3.c', 'demo.c', 'demo.h') ;
+
+foreach my $fff ( @demo_files )
+{
+    my $infile  = sprintf ("%s/Demo/cs_%s", $in_dir, $fff) ;
+
+    # create the plain version
+    my $outfile = sprintf ("%s/Demo/cs_%s", $out_dir, $fff) ;
+    printf ("%s to %s\n", $infile, $outfile) ;
+    if (open (OUT, ">$outfile"))
+    {
+	if (open (IN, $infile))
+	{
+	    while (<IN>)
+	    {
+		# change csi to int
+		s/\bcsi\b/int/g;
+		print OUT $_;
+	    }
+	    close (IN);
+	}
+	close (OUT);
+    }
+
+    # create di version
+    my $outfile = sprintf ("%s/Demo/cs_di_%s", $out_dir, $fff) ;
+    printf ("%s to %s\n", $infile, $outfile) ;
+    if (open (OUT, ">$outfile"))
+    {
+	if (open (IN, $infile))
+	{
+	    while (<IN>)
+	    {
+		# change csi to int
+		s/\bcsi\b/int/g;
+		# change all "cs*" names to "cs_di*", except #include "cs.h"
+		s/\bcs/cs_di/g ;
+		s/cs_di\.h/cs.h/ ;
+		print OUT $_;
+	    }
+	    close (IN);
+	}
+	close (OUT);
+    }
+
+    # create dl version
+    my $outfile = sprintf ("%s/Demo/cs_dl_%s", $out_dir, $fff) ;
+    printf ("%s to %s\n", $infile, $outfile) ;
+    if (open (OUT, ">$outfile"))
+    {
+	if (open (IN, $infile))
+	{
+	    while (<IN>)
+	    {
+		# change csi to cs_long_t
+		s/\bcsi\b/cs_long_t/g;
+		# change all "cs*" names to "cs_dl*", except #include "cs.h"
+		s/\bcs/cs_dl/g ;
+		s/cs_dl_long_t/cs_long_t/g;
+		s/cs_dl\.h/cs.h/ ;
+		print OUT $_;
+	    }
+	    close (IN);
+	}
+	close (OUT);
+    }
+
+    # create ci version
+    my $outfile = sprintf ("%s/Demo/cs_ci_%s", $out_dir, $fff) ;
+    printf ("%s to %s\n", $infile, $outfile) ;
+    if (open (OUT, ">$outfile"))
+    {
+	if (open (IN, $infile))
+	{
+	    while (<IN>)
+	    {
+		# change csi to int
+		s/\bcsi\b/int/g;
+		# change all "cs*" names to "cs_ci*", except #include "cs.h"
+		s/\bcs/cs_ci/g ;
+		s/cs_ci_long_t/cs_long_t/g;
+		s/cs_ci\.h/cs.h/ ;
+		# fabs becomes cabs
+		s/fabs/cabs/g;
+		# change double to cs_complex_t
+		s/\bdouble\b/cs_complex_t/g;
+		# (double) typecasts stay double
+		s/\(cs_complex_t\) /(double) /g;
+		# tic, toc, tol, and norm are double, not cs_complex_t
+		s/cs_complex_t norm/double norm/;
+		s/cs_complex_t tic/double tic/;
+		s/cs_complex_t toc \(cs_complex_t/double toc (double/;
+		s/cs_complex_t s = tic/double s = tic/;
+		s/cs_complex_t tol/double tol/;
+		# cumsum, S->lnz, S->unz are double
+		s/cs_complex_t lnz/double lnz/;
+		s/cs_complex_t unz/double unz/;
+		s/cs_complex_t cs_cumsum/double cs_cumsum/;
+		# local variable declarations that stay double
+		s/,  / ;\n    double / ;
+		print OUT $_;
+	    }
+	    close (IN);
+	}
+	close (OUT);
+    }
+
+    # create cl version
+    my $outfile = sprintf ("%s/Demo/cs_cl_%s", $out_dir, $fff) ;
+    printf ("%s to %s\n", $infile, $outfile) ;
+    if (open (OUT, ">$outfile"))
+    {
+	if (open (IN, $infile))
+	{
+	    while (<IN>)
+	    {
+		# change csi to cs_long_t
+		s/\bcsi\b/cs_long_t/g;
+		# change all "cs*" names to "cs_cl*", except #include "cs.h"
+		s/\bcs/cs_cl/g ;
+		s/cs_cl_long_t/cs_long_t/g;
+		s/cs_cl\.h/cs.h/ ;
+		# fabs becomes cabs
+		s/fabs/cabs/g;
+		# change double to cs_complex_t
+		s/\bdouble\b/cs_complex_t/g;
+		# (double) typecasts stay double
+		s/\(cs_complex_t\) /(double) /g;
+		# tic, toc, tol, and norm are double, not cs_complex_t
+		s/cs_complex_t norm/double norm/;
+		s/cs_complex_t tic/double tic/;
+		s/cs_complex_t toc \(cs_complex_t/double toc (double/;
+		s/cs_complex_t s = tic/double s = tic/;
+		s/cs_complex_t tol/double tol/;
+		# cumsum, S->lnz, S->unz are double
+		s/cs_complex_t lnz/double lnz/;
+		s/cs_complex_t unz/double unz/;
+		s/cs_complex_t cs_cumsum/double cs_cumsum/;
+		# local variable declarations that stay double
+		s/,  / ;\n    double / ;
+		print OUT $_;
+	    }
+	    close (IN);
+	}
+	close (OUT);
+    }
+}
+
+#-------------------------------------------------------------------------------
+# Convert Source/*.c files (except cs_house.c, cs_print.c, and cs_load.c)
+#-------------------------------------------------------------------------------
+
+# note that cs.h, cs_house.c, cs_updown.c, ...
+# are not included in this list
+my @src_files = ('Source/cs_add.c', 'Source/cs_amd.c', 'Source/cs_chol.c',
+    'Source/cs_cholsol.c', 'Source/cs_counts.c', 'Source/cs_cumsum.c',
+    'Source/cs_dfs.c', 'Source/cs_dmperm.c', 'Source/cs_droptol.c',
+    'Source/cs_dropzeros.c', 'Source/cs_dupl.c', 'Source/cs_entry.c',
+    'Source/cs_etree.c', 'Source/cs_fkeep.c', 'Source/cs_gaxpy.c',
+    'Source/cs_happly.c', 'Source/cs_ipvec.c',
+    'Source/cs_lsolve.c', 'Source/cs_ltsolve.c', 'Source/cs_lu.c',
+    'Source/cs_lusol.c', 'Source/cs_malloc.c', 'Source/cs_maxtrans.c',
+    'Source/cs_multiply.c', 'Source/cs_norm.c', 'Source/cs_permute.c',
+    'Source/cs_pinv.c', 'Source/cs_post.c',
+    'Source/cs_pvec.c', 'Source/cs_qr.c', 'Source/cs_qrsol.c',
+    'Source/cs_scatter.c', 'Source/cs_scc.c', 'Source/cs_schol.c',
+    'Source/cs_sqr.c', 'Source/cs_symperm.c', 'Source/cs_tdfs.c',
+    'Source/cs_transpose.c', 'Source/cs_compress.c',
+    'Source/cs_usolve.c', 'Source/cs_util.c', 'Source/cs_utsolve.c',
+    'Source/cs_reach.c', 'Source/cs_spsolve.c', 'Source/cs_leaf.c',
+    'Source/cs_ereach.c', 'Source/cs_randperm.c' ) ;
+
+foreach my $file ( @src_files )
+{
+    my $infile  = sprintf ("%s/%s", $in_dir, $file) ;
+    my $outfile = sprintf ("%s/%s", $out_dir, $file) ;
+    my $fbase = basename($file,('.c'));
+
+    if (open(OUT,">$outfile"))
+    {
+	if (open(IN,$infile))
+	{
+	    # my $qrsol_beta_seen = 0;
+	    while (<IN>)
+	    {
+
+		# change the name of the package (for cs_print.c)
+		s/CSparse/CXSparse/g;
+
+		# fabs becomes CS_ABS
+		s/fabs/CS_ABS/g;
+
+		# change csi to CS_INT
+		s/\bcsi\b/CS_INT/g;
+
+		# change double to CS_ENTRY
+		s/\bdouble\b/CS_ENTRY/g;
+
+		# (double) and (double *) typecasts stay double,
+		# tol and vnz for cs_vcount stays double
+		s/\(CS_ENTRY\) /(double) /g;
+		s/\(CS_ENTRY \*\) /(double \*) /;
+		s/CS_ENTRY tol/double tol/;
+		s/CS_ENTRY \*vnz/double \*vnz/;
+
+		# local variable declarations that stay double
+		s/,  / ;\n    double / ;
+
+		#---------------------------------------------------------------
+		# Special cases.  Some undo changes made above.
+		#---------------------------------------------------------------
+
+		# cs_mex.c
+		if ($fbase =~ /cs_mex/)
+		{
+		    s/matrix must be CS_ENTRY/matrix must be double/;
+		    s/A->p =/A->p = (CS_INT *)/;
+		    s/A->i =/A->i = (CS_INT *)/;
+		    s/, A->p/, (mwIndex *) A->p/;
+		    s/, A->i/, (mwIndex *) A->i/;
+		}
+
+		# fix comments in cs_add_mex.c and cs_permute_mex.c
+		if ($fbase =~ /cs_add_mex/ || $fbase =~ /cs_permute_mex/)
+		{
+		    s/via CS_ENTRY transpose/via double transpose/;
+		}
+
+		# cs_chol
+		if ($fbase =~ /cs_chol/)
+		{
+		    s/\(d <= 0\)/(CS_REAL (d) <= 0 || CS_IMAG (d) != 0)\n\t   /;
+		    s/lki \* lki/lki * CS_CONJ (lki)/;
+		    s/ = lki/ = CS_CONJ (lki)/;
+		}
+
+		# cs_norm
+		if ($fbase =~ /cs_norm/)
+		{
+		    s/^CS_ENTRY cs_norm/double cs_norm/;
+		}
+
+		# cs_cumsum
+		if ($fbase =~ /cs_cumsum/)
+		{
+		    s/CS_ENTRY/double/;
+		}
+
+		# cs_transpose
+		if ($fbase =~ /cs_transpose/)
+		{
+		    s/Ax \[p\]/(values > 0) ? CS_CONJ (Ax [p]) : Ax [p]/;
+		}
+
+		# cs_symperm
+		if ($fbase =~ /cs_symperm/)
+		{
+		    s/Ax \[p\]/(i2 <= j2) ? Ax [p] : CS_CONJ (Ax [p])/;
+		}
+
+		# cs_qr
+		if ($fbase =~ /cs_qr/)
+		{
+		    s/n, sizeof \(CS_ENTRY\)/n, sizeof (double)/;
+		}
+
+		# cs_happly
+		if ($fbase =~ /cs_happly/)
+		{
+		    s/^(.*tau.*)(Vx\s*\[p\])/$1CS_CONJ ($2)/;
+		    s/CS_ENTRY beta/double beta/;
+		}
+
+		# cs_ltsolve
+		if ($fbase =~ /cs_ltsolve/)
+		{
+		    s/(Lx \[.*?\])(\s+[\*;])/CS_CONJ ($1)$2/;
+		}
+
+		# cs_utsolve
+		if ($fbase =~ /cs_utsolve/)
+		{
+		    s/(Ux \[.*?\])(\s+[\*;])/CS_CONJ ($1)$2/;
+		}
+
+		print OUT $_;
+	    }
+	    close (IN);
+	}
+	close (OUT);
+    }
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/ChangeLog b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/ChangeLog
new file mode 100644
index 0000000000000000000000000000000000000000..331a34e15907738fbc5de594b2215ecee201099c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/ChangeLog
@@ -0,0 +1,553 @@
+May 4, 2016: SuiteSparse 4.5.3
+
+    * minor changes to Makefiles
+
+Apr 1, 2016: SuiteSparse 4.5.2
+
+    * licensing simplified (no other change); refer to PACKAGE/Doc/License.txt
+        for the license for each package.
+
+Feb 1, 2016: SuiteSparse 4.5.1
+
+    * update to Makefiles.  Version 4.5.0 is broken on the Mac.
+	That version also compiles *.so libraries on Linux with
+	underlinked dependencies to other libraries in SuiteSparse.
+	For example, AMD requires SuiteSparse_config.  The links to
+	required libraries are now explicitly included in each library,
+	in SuiteSparse 4.5.1.
+    * minor change to CHOLMOD/Check/cholmod_write.c, when compiling with
+	options that disable specific modules
+
+Jan 30, 2016: SuiteSparse 4.5.0
+
+    * better Makefiles for creating and installing shared libraries
+    * CHOLMOD now uses METIS 5.1.0, which is distributed with SuiteSparse
+    * fix for MATLAB R2015b, which changed how it creates empty matrices,
+	as compared to prior versions of MATLAB.  This change in MATLAB
+	breaks many of the mexFunctions in prior versions of SuiteSparse.
+	If you use MATLAB R2015b, you must upgrade to SuiteSparse 4.5.0
+	or later.
+
+Jan 1, 2016: SuiteSparse 4.4.7
+
+    * note that this minor update fails on the Mac, so its
+        listed on my web page as a 'beta' release.
+    * Improved the Makefiles of all packages.  They now create *.so
+        shared libraries (*.dylib on the Mac).  Also, there is now
+        only a single SuiteSparse_config.mk file.  It now determines
+        your system automatically, and whether or not you have METIS
+        and CUDA.  It also automatically detects if you have the Intel
+        compiler or not, and uses it if it finds it.  There should be
+        no need to edit this file for most cases, but you may need to
+        for your particular system.  With this release, there are almost
+        no changes to the source code, except for the VERSION numbers
+        defined in the various include *.h files for each package.
+
+Aug 2015: SuiteSparse version 4.4.6
+
+    * SPQR: changed default tol when A has infs, from inf to realmax (~1e308)
+
+July 2015: SuiteSparse version 4.4.5
+
+    * CHOLMOD 3.0.6:
+        - minor fix to CHOLMOD (disabling modules did not work as expected)
+        - added MATLAB interface for row add/delete (lurowmod)
+    * KLU 1.3.3: Fix for klu_dump.c (debugging case only)
+    * UFcollection:  added additional stats for matrix collection
+    * AMD: changed the default license.  See AMD/Doc/License.txt for details.
+
+Mar 24, 2015: SuiteSparse version 4.4.4
+
+    * CHOLMOD version number corrected.  In 4.4.3, the CHOLMOD_SUBSUB_VERSION
+        string was left at '4' (it should have been '5', for CHOLMOD 3.0.5).
+        This version of SuiteSparse corrects this glitch.
+    * Minor changes to comments in SuiteSparse_config.
+    * SPQR version 2.0.1 released (minor update to documentation)
+
+Jan 19, 2015: SuiteSparse version 4.4.3
+
+    * CHOLMOD 3.0.5: minor bug fix to MatrixOps/cholmod_symmetry
+
+Jan 7, 2015: SuiteSparse version 4.4.2
+
+    * CHOLMOD 3.0.4: serious bug fix in supernodal factorization,
+	introduced in CHOLMOD 3.0.0 (SuiteSparse 4.3.0).  Can cause segfault,
+	and has no user workaround.
+
+Oct 23, 2014: SuiteSparse version 4.4.1
+    Minor update:  two bug fixes (affecting Windows only)
+
+    * CHOLMOD 3.0.3:
+        minor update to CHOLMOD (non-ANSI C usage in one *.c file, affects
+        Windows only)
+    * KLU 1.3.2:
+        minor fix to MATLAB install; no change to C except version nubmer
+
+
+Oct 10, 2014: SuiteSparse version 4.4.0
+    MAJOR UPDATE:  new GPU-acceleration for SPQR
+
+    * AMD 2.4.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * BTF 1.2.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CAMD 2.4.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CCOLAMD 2.9.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CHOLMOD 3.0.2:
+        update to accomodate GPU-accelerated SPQR
+        added CHOLMOD/Include/cholmod_function.h
+    * COLAMD 2.9.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CSparse 3.1.4:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CXSparse 3.1.4:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * GPUQREngine 1.0.0:
+        FIRST RELEASE.  Used by SPQR 2.0.0
+    * KLU 1.3.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+        update to KLU/Tcov/Makefile
+    * LDL 2.2.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * RBio 2.2.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * SPQR 2.0.0:
+        MAJOR UPDATE.  added GPU support.  Up to 11x faster than on CPU
+    * SuiteSparse_GPURuntime 1.0.0:
+        FIRST RELEASE.  Used by SPQR 2.0.0
+    * UMFPACK 5.7.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * MATLAB_Tools:
+        modified SSMULT/ssmult_install.m.  No change to C code
+
+
+July 18, 2014: SuiteSparse version 4.3.1
+    Minor update:  added cholmod_rowfac_mask2 function to CHOLMOD
+
+    * CHOLMOD 3.0.1:
+        added cholmod_rowfac_mask2 function.  Minor fix to build process
+    * SPQR 1.3.3:
+        minor fix to build process
+
+
+March 26, 2014: SuiteSparse version 4.3.0
+    MAJOR UPDATE: first release of CHOLMOD GPU acceleration
+    minor update: modified all packages to use SuiteSparse_config for
+        malloc/calloc/realloc/free, printf, hypot, and divcomplex
+        function pointers.
+
+    * AMD 2.4.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * CAMD 2.4.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * CCOLAMD 2.9.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * CHOLMOD 3.0.0:
+        MAJOR UPDATE to GPU acceleration.  Released at GTC 2014.
+    * COLAMD 2.9.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * CSparse 3.1.3:
+        minor update to UFget
+    * CXSparse 3.1.3:
+        minor update to UFget
+    * KLU 1.3.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * LDL 2.2.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * RBio 2.2.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * SPQR 1.3.2:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * UMFPACK 5.7.0:
+        changed malloc/printf pointers to use SuiteSparse_config
+    * MATLAB_Tools:
+        added stats to UFcollection, revised commends in SFMULT,
+        minor update to spok
+
+
+April 25, 2013: SuiteSparse version 4.2.1
+    minor update
+
+    * CHOLMOD 2.1.2:
+        minor update to Cholesky/*solve*c (for Windows compiler)
+    * UMFPACK 5.6.2:
+        bug fix in Demo/Makefile for Fortran interface
+    * MATLAB_Tools:
+        minor update to sparseinv
+
+
+April 16, 2013: SuiteSparse version 4.2.0
+    minor update and bug fix
+
+    * CHOLMOD 2.1.1:
+        minor changes to GPU accelerated version, fixed GPU memory leak
+    * CSparse 3.1.2:
+        minor update to cs_sqr.c; no affect on functionality
+    * CXSparse 3.1.2:
+        minor update to cs_sqr.c; no affect on functionality
+
+March 27, 2013: SuiteSparse version 4.1.0
+    new features added to CHOLMOD
+
+    * CHOLMOD 2.1.0:
+        added new features and functions to forward/backsolve:
+        cholmod_lsolve_pattern, cholmod_solve2, cholmod_ensure_dense.
+    * MATLAB_Tools:
+        added SFMULT.  minor update to Factorize, problems added to dimacs10
+
+July 17, 2012: SuiteSparse version 4.0.2
+    major update to MATLAB_Tools/Factorize.  No change to any C code.
+
+    * MATLAB_Tools:
+        major update to Factorize, minor update to sparseinv
+
+
+June 20, 2012: SuiteSparse version 4.0.1
+
+    * AMD 2.3.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CAMD 2.3.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CHOLMOD 2.0.1:
+        bug fix for GPU code, when the matrix is singular
+        minor fix to MATLAB install
+    * CSparse 3.1.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * CXSparse 3.1.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * KLU 1.2.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * RBio 2.1.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * SPQR 1.3.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * UMFPACK 5.6.1:
+        minor fix to MATLAB install; no change to C except version nubmer
+    * MATLAB_Tools:
+        update to UFcollection (filesep) 
+
+
+June 1, 2012: SuiteSparse version 4.0.0
+    MAJOR UPDATE: First GPU version for CHOLMOD.
+    UFconfig renamed to SuiteSparse_config.
+
+    * AMD 2.3.0:
+        replaced UFconfig with SuiteSparse_config
+    * BTF 1.2.0:
+        replaced UFconfig with SuiteSparse_config
+    * CAMD 2.3.0:
+        replaced UFconfig with SuiteSparse_config
+    * CCOLAMD 2.8.0:
+        replaced UFconfig with SuiteSparse_config
+    * CHOLMOD 2.0.0:
+        replaced UFconfig with SuiteSparse_config
+        first GPU-accelerated version.
+    * COLAMD 2.8.0:
+        replaced UFconfig with SuiteSparse_config
+    * CSparse 3.1.0:
+        minor changes to enable creation of CXSparse 3.1.0
+    * CXSparse 3.1.0:
+        replaced UFconfig with SuiteSparse_config
+    * KLU 1.2.0:
+        replaced UFconfig with SuiteSparse_config
+    * LDL 2.1.0:
+        replaced UFconfig with SuiteSparse_config
+    * RBio 2.1.0:
+        replaced UFconfig with SuiteSparse_config
+    * SPQR 1.3.0:
+        replaced UFconfig with SuiteSparse_config
+        removed spqr_time; using SuiteSparse timing routines instead
+    * UMFPACK 5.6.0:
+        replaced UFconfig with SuiteSparse_config
+    * MATLAB_Tools:
+        update to documentation for Factorize, update to UFcollection
+
+May 15, 2012: SuiteSparse version 3.7.1
+    minor update
+
+    * AMD 2.2.4:
+        minor compiler workaround
+    * CAMD 2.2.4:
+        minor compiler workaround
+    * KLU 1.1.4:
+        bug fix in the case of Int overflow
+    * MATLAB_Tools:
+        minor update to spqr_rank and UFcollection
+
+Dec 15, 2011: SuiteSparse version 3.7.0
+    MAJOR UPDATE: added spqr_rank and sparseinv to MATLAB_Tools
+    major update to Factorize package in MATLAB_Tools
+    minor update to Makefiles for C code.
+
+    * AMD 2.2.3:
+        Makefile updated
+    * BTF 1.1.3:
+        Makefile updated
+    * CAMD 2.2.3:
+        Makefile updated
+    * CCOLAMD 2.7.4:
+        Makefile updated
+    * CHOLMOD 1.7.4:
+        Makefile updated
+    * COLAMD 2.7.4:
+        Makefile updated
+    * CSparse 3.0.2:
+        Makefile updated.  Fix to MATLAB install.  Now as CSparse (not CSparse3)
+    * KLU 1.1.3:
+        Makefile updated.  minor fix to MATLAB mexFunction
+    * LDL 2.0.4:
+        Makefile updated.  Update to demo program
+    * RBio 2.0.2:
+        Makefile updated.  Update to MATLAB mexFunction
+    * SPQR 1.2.3
+        Makefile updated.  Update to MATLAB install
+    * UMFPACK 5.5.2:
+        Makefile updated.  Update to MATLAB install
+    * MATLAB_Tools:
+        added spqr_rank and sparseinv.  Major update to Factorize, dimacs10
+
+
+
+May 10, 2011: SuiteSparse version 3.6.1
+    minor update
+
+    * SPQR 1.2.2:
+        minor fix, compiler workaround
+    * CSparse 3.0.1:
+        Added as the CSparse3 directory (original date Jan 19, 2010;
+        added to SuiteSparse on May 10, 2011.  Note that CSparse v2.x.x.
+        was also distributed)
+    * MATLAB_Tools:
+        added dimacs10.  Minor update to spok.
+
+
+Jan 25, 2011: SuiteSparse version 3.6.0
+    minor update
+
+    * AMD 2.2.2:
+        Makefile updated.
+    * BTF 1.1.2:
+        Makefile updated.
+    * CAMD 2.2.2:
+        Makefile updated.
+    * CCOLAMD 2.7.3:
+        Makefile updated.  Minor fix to stats printout
+    * CHOLMOD 1.7.3:
+        Makefile updated.  Minor fix, compiler workaround
+    * COLAMD 2.7.3:
+        Makefile updated
+    * CSparse 2.2.5:
+        Makefile updated.  minor fixes to UFget, cs_util.c.
+    * KLU 1.1.2:
+        Makefile updated.  ported Tcov to Mac.
+    * LDL 2.0.3:
+        Makefile updated.
+    * RBio 2.0.1:
+        Makefile updated.
+    * SPQR 1.2.1:
+        Makefile updated.  Added examples.  Fixed error handling.
+    * UMFPACK 5.5.1:
+        Makefile updated.
+    * MATLAB_Tools:
+        minor update to spok
+
+Nov 30, 2009: SuiteSparse version 3.5.0
+    major update to SPQR and RBio; minor updates to Makefiles.
+
+    * AMD 2.2.1:
+        Makefile updated.
+    * BTF 1.1.1
+        Makefile updated.
+    * CAMD 2.2.1:
+        Makefile updated.
+    * CCOLAMD 2.7.2:
+        Makefile updated.
+    * CHOLMOD 1.7.2:
+        Makefile updated.  Fixed 64-bit BLAS for MATLAB 7.8.
+    * COLAMD 2.7.2:
+        Makefile updated.
+    * CSparse 2.2.4
+        Makefile updated.  MATLAB install updated.
+    * KLU 1.1.1:
+        Makefile updated.
+    * LDL 2.0.2:
+        Makefile updated.
+    * RBio 2.0.0:
+        major update: rewritten in C.  No longer in Fortran.
+        Makefile updated.
+    * SPQR 1.2.0:
+        major update: added features required by MATLAB package spqr_rank,
+        changed default ordering to COLAMD.
+        Makefile updated.
+    * UMFPACK 5.5.0:
+        major update.  Added user-ordering function, interface to CHOLMOD
+        orderings, option to disable singleton search to allow L to be
+        well-conditioned.
+        Makefile updated.
+    * MATLAB_Tools:
+        major update to Factorize.  Minor updates to GEE, getversion, spok.
+
+
+May 20, 2009: SuiteSparse version 3.4.0
+    MAJOR UPDATE: added Factorize package to MATLAB_TOols
+    major update to UMFPACK (removed 2-by-2 strategy)
+
+    * RBio 1.1.2:
+        update to MATLAB install
+    * SPQR 1.1.2:
+        added more examples.  Mac compiler workaround.
+    * UMFPACK 5.4.0:
+        removed 2-by-2 strategy.  update to MATLAB install.
+    * MATLAB_Tools:
+        added Factorize
+
+
+March 24, 2009: SuiteSparse version 3.3.0
+    minor update
+
+    * BTF 1.1.0:
+        minor update.
+    * CHOLMOD 1.7.1:
+        bug fix for cholmod_symmetry
+    * CSparse 2.2.3:
+        cs_gaxpy example fixed.  Minor change to MATLAB cs_sparse interface
+    * CXSparse 2.2.3:
+        cs_gaxpy example fixed.  Minor change to MATLAB cs_sparse interface
+    * KLU 1.1.0:
+        minor update.
+    * SPQR 1.1.1:
+        minor update (compiler workaround)
+    * UMFPACK 5.3.0:
+        compiler workaround.  added timer options.
+        bug fix for 2-by-2 strategy (subsequently removed in v5.4.0)
+
+Sept 20, 2008: SuiteSparse version 3.2.0
+    MAJOR UPDATE: first release of SPQR
+
+    * CHOLMOD 1.7.0:
+        major update for SPQR.
+    * CXSparse 2.2.2:
+        update to MATLAB install
+    * CSparse 2.2.2:
+        update to MATLAB install
+    * SPQR 1.1.0:
+        FIRST RELEASE in SuiteSparse.
+    * MATLAB_TOOLS:
+        added: GEE, find_components, spok
+
+Nov 1, 2007: SuiteSparse version 3.1.0
+    minor update
+
+    * BTF 1.0.1:
+        minor update.
+    * CCOLAMD 2.7.1:
+        minor changes to MATLAB test code.
+    * CHOLMOD 1.6.0:
+        bug fix to cholmod_symmetry.  Performance fix for cholmod_nesdis.
+        port to MATLAB 7.5 and many minor changes in MATLAB interface.
+    * COLAMD 2.7.1:
+        minor changes to MATLAB test code.
+    * CSparse 2.2.1:
+        minor update.
+    * CXSparse 2.2.1:
+    * KLU 1.0.1:
+        minor lint cleanup.
+    * RBio 1.1.1:
+        minor lint cleanup.
+        minor update.
+    * UMFPACK 5.2.0:
+        change of default license.  minor lint cleanup.
+        port to MATLAB 7.5.
+    * MATLAB_Tools:
+        added: LINFACTOR, MESHND, SSMULT, getversion, gipper, hprintf,
+            pagerankdemo, shellgui, and waitmex
+
+May 31, 2007: SuiteSparse version 3.0.0
+    MAJOR UPDATE: first stable release of KLU and BTF
+    other packages ported to 64-bit MATLAB.
+
+    * AMD 2.2.0:
+        port to 64-bit MATLAB.  minor changes in printing.
+    * BTF 1.0.0:
+        FIRST STABLE RELEASE
+    * CAMD 2.2.0:
+        port to 64-bit MATLAB.  minor changes in printing.
+    * CCOLAMD 2.7.0:
+        port to 64-bit MATLAB.  restructured directories
+    * CHOLMOD 1.5.0:
+        port to 64-bit MATLAB.  update to Makefile.
+        bug fix for BLAS int, update to cholmod_updown.
+    * COLAMD 2.7.0:
+        port to 64-bit MATLAB.  restructured directories
+    * CSparse 2.2.0:
+        update to MATLAB interface.  restructured directories
+    * LDL 2.0.0:
+        major update:  added 64bit version, restructured directories
+    * RBio 1.1.0:
+        port to 64-bit MATLAB.
+    * UMFPACK 5.1.0:
+        port to 64-bit MATLAB.  minor changes in printing.
+
+Dec 13, 2006: SuiteSparse version 2.4.0
+    minor update
+
+    * AMD 2.0.4:
+        minor MATLAB cleanup
+    * CAMD 2.1.2:
+        minor MATLAB cleanup
+    * CCOLAMD 2.5.2
+        minor MATLAB cleanup
+    * CHOLMOD 1.4.0:
+        added support for large files.  Renamed MATLAB interface to cholmod2.
+        minor MATLAB cleanup.
+    * COLAMD 2.5.2:
+        minor MATLAB cleanup
+    * CSparse 2.0.7:
+        minor MATLAB cleanup
+    * CXSparse 2.0.7:
+        minor MATLAB cleanup
+    * LDL 1.3.4:
+        minor MATLAB cleanup
+    * UMFPACK 5.0.3:
+        minor MATLAB cleanup
+
+Dec 7, 2006: SuiteSparse version 2.3.1
+    minor update
+
+    * CSparse 2.0.6:
+        update to UFget
+    * CXSparse 2.0.6:
+        update to UFget
+
+Dec 2, 2006: SuiteSparse version 2.3.0
+    MAJOR UPDATE
+
+    * CHOLMOD 1.3.0:
+        major update to file IO functions, added cholmod_symmetry,
+        minor fix to cholmod_analyze_odering and cholmod_dense.c.
+    * MATLAB_Tools:
+        added UFcollection
+
+Sept 11, 2006: SuiteSparse version 2.1.1
+
+    * AMD 2.0.1:
+        minor update
+    * CAMD 2.1.1:
+        minor update
+    * CHOLMOD 1.2.0:
+        performance improvements.  Added ordering options to MATLAB interface
+    * COLAMD 2.5.1:
+        minor update
+    * CCOLAMD 2.5.1:
+        minor update
+    * CSparse 2.0.2:
+        minor update to MATLAB interface
+    * CXSparse 2.0.2:
+        minor update to MATLAB interface
+    * LDL 1.3.1:
+        minor update to MATLAB interface
+    * UMFPACK 5.0.1:
+        minor update
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/Contents.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..8d2902b3e98c26e450ccdf5f9dc2b97b9d507a75
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/Contents.m
@@ -0,0 +1,149 @@
+% Welcome to SuiteSparse : a Suite of Sparse matrix packages, containing a
+% collection of sparse matrix packages authored or co-authored by Tim Davis.
+% Only the primary MATLAB functions are listed below.
+%
+% Example:
+%   SuiteSparse_install
+% compiles and installs all of SuiteSparse, and runs several demos and tests.
+%
+%-------------------------------------------------------------------------------
+% Ordering methods:
+%-------------------------------------------------------------------------------
+%
+%   amd2         - approximate minimum degree ordering.
+%   colamd2      - column approximate minimum degree ordering.
+%   symamd2      - symmetrix approximate min degree ordering based on colamd.
+%   camd         - constrained amd.
+%   ccolamd      - constrained colamd.
+%   csymamd      - constrained symamd.
+%
+%-------------------------------------------------------------------------------
+% CHOLMOD: a sparse supernodal Cholesky update/downdate package:
+%-------------------------------------------------------------------------------
+%
+%   cholmod2     - computes x=A\b when A is symmetric and positive definite.
+%   chol2        - same as MATLAB chol(sparse(A)), just faster.
+%   lchol        - computes an LL' factorization.
+%   ldlchol      - computes an LDL' factorization.
+%   ldlupdate    - updates an LDL' factorization.
+%   resymbol     - recomputes symbolic LL or LDL' factorization.
+%   ldlsolve     - solves Ax=b using an LDL' factorization.
+%   ldlsplit     - splits LD into L and D.
+%   metis        - interface to METIS node-nested-dissection.
+%   nesdis       - interface to CHOLMOD's nested-dissection (based on METIS).
+%   septree      - prune a separator tree.
+%   bisect       - interface to METIS' node bisector.
+%   analyze      - order and analyze using CHOLMOD.
+%   etree2       - same as MATLAB "etree", just faster and more reliable.
+%   sparse2      - same as MATLAB "sparse", just faster.
+%   symbfact2    - same as MATLAB "symbfact", just faster and more reliable.
+%   sdmult       - same as MATLAB S*F or S'*F (S sparse, F full), just faster.
+%   ldl_normest  - compute error in LDL' factorization.
+%   lu_normest   - compute error in LU factorization.
+%   mread        - read a sparse matrix in Matrix Market format
+%   mwrite       - write a sparse matrix in Matrix Market format
+%   spsym        - determine the symmetry of a sparse matrix
+%
+%-------------------------------------------------------------------------------
+% CSPARSE / CXSPARSE: a Concise Sparse matrix package:
+%-------------------------------------------------------------------------------
+%
+%   Matrices used in CSparse must in general be either sparse and real, or
+%   dense vectors.  Ordering methods can accept any sparse matrix.  CXSparse
+%   supports complex matrices and 64-bit MATLAB; it is installed by default.
+%
+%   cs_add       - sparse matrix addition.
+%   cs_amd       - approximate minimum degree ordering.
+%   cs_chol      - sparse Cholesky factorization.
+%   cs_cholsol   - solve A*x=b using a sparse Cholesky factorization.
+%   cs_counts    - column counts for sparse Cholesky factor L.
+%   cs_dmperm    - maximum matching or Dulmage-Mendelsohn permutation.
+%   cs_dmsol     - x=A\b using the coarse Dulmage-Mendelsohn decomposition.
+%   cs_dmspy     - plot the Dulmage-Mendelsohn decomposition of a matrix.
+%   cs_droptol   - remove small entries from a sparse matrix.
+%   cs_esep      - find an edge separator of a symmetric matrix A
+%   cs_etree     - elimination tree of A or A'*A.
+%   cs_gaxpy     - sparse matrix times vector.
+%   cs_lsolve    - solve a sparse lower triangular system L*x=b.
+%   cs_ltsolve   - solve a sparse upper triangular system L'*x=b.
+%   cs_lu        - sparse LU factorization, with fill-reducing ordering.
+%   cs_lusol     - solve Ax=b using LU factorization.
+%   cs_make      - compiles CSparse for use in MATLAB.
+%   cs_multiply  - sparse matrix multiply.
+%   cs_nd        - generalized nested dissection ordering.
+%   cs_nsep      - find a node separator of a symmetric matrix A.
+%   cs_permute   - permute a sparse matrix.
+%   cs_print     - print the contents of a sparse matrix.
+%   cs_qr        - sparse QR factorization.
+%   cs_qleft     - apply Householder vectors on the left.
+%   cs_qright    - apply Householder vectors on the right.
+%   cs_qrsol     - solve a sparse least-squares problem.
+%   cs_randperm  - random permutation.
+%   cs_sep       - convert an edge separator into a node separator.
+%   cs_scc       - strongly-connected components of a square sparse matrix.
+%   cs_scc2      - cs_scc, or connected components of a bipartite graph.
+%   cs_sparse    - convert a triplet form into a sparse matrix.
+%   cs_sqr       - symbolic sparse QR factorization.
+%   cs_symperm   - symmetric permutation of a symmetric matrix.
+%   cs_transpose - transpose a sparse matrix.
+%   cs_updown    - rank-1 update/downdate of a sparse Cholesky factorization.
+%   cs_usolve    - solve a sparse upper triangular system U*x=b.
+%   cs_utsolve   - solve a sparse lower triangular system U'*x=b.
+%   cspy         - plot a sparse matrix in color.
+%   ccspy        - plot the connected components of a matrix.
+%
+%-------------------------------------------------------------------------------
+% LDL: Sparse LDL factorization:
+%-------------------------------------------------------------------------------
+% 
+%   ldlsparse   - LDL' factorization of a real, sparse, symmetric matrix.
+%   ldlrow      - an m-file description of the algorithm used by LDL.
+%
+%-------------------------------------------------------------------------------
+% UMFPACK: the Unsymmetric MultiFrontal Package:
+%-------------------------------------------------------------------------------
+%
+%   umfpack2          - computes x=A\b, x=A/b, or lu (A) for a sparse matrix A
+%   umfpack_details   - details on all the options for using umfpack in MATLAB
+%   umfpack_report    - prints optional control settings and statistics
+%   umfpack_btf       - factorize A using a block triangular form
+%   umfpack_solve     - x = A\b or x = b/A
+%   lu_normest        - estimates norm (L*U-A,1) without forming L*U-A
+%                       (duplicate of CHOLMOD/lu_normest, for completeness)
+%   luflop            - given L and U, computes # of flops required
+%
+%-------------------------------------------------------------------------------
+% SuiteSparseQR: multifrontal rank-revealing sparse QR
+%-------------------------------------------------------------------------------
+%
+%   spqr            - sparse QR
+%   spqr_solve      - x=A\b using SuiteSparseQR
+%   spqr_qmult      - y=Q*x, Q'*x, x*Q, or x*Q' using Q in Householder form
+%
+%-------------------------------------------------------------------------------
+% Other packages:
+%-------------------------------------------------------------------------------
+%
+%   MATLAB_Tools    various MATLAB tools, most in M, some as C mexFunctions:
+%
+%       ssmult          sparse matrix times sparse matrix
+%       meshnd          nested dissection of regular 2D and 3D meshes
+%       linfactor       solve Ax=b using LU or CHOL
+%       dimacs10        MATLAB interface for the DIMACS10 collection
+%       factorize       object-oriented system solver
+%       sparseinv       sparse inverse subset
+%       spqr_rank       toolbox for sparse rank-deficient matrices
+%
+%   UFcollection    for managing the UF Sparse Matrix Collection
+%   RBio            for reading/writing Rutherford/Boeing sparse matrices
+%   UFget           MATLAB interface to the UF Sparse Matrix Collection,
+%                   located in C*Sparse*/MATLAB
+%
+%-------------------------------------------------------------------------------
+%
+% For help on compiling SuiteSparse or the demos, testing functions, etc.,
+% please see the help for each individual package.
+%
+% Copyright 2014, Timothy A. Davis, http://www.suitesparse.com.
+
+help SuiteSparse
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/ChangeLog b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/ChangeLog
new file mode 100644
index 0000000000000000000000000000000000000000..a98c9d33b5b1cfc623dbd0e6b5f75a797f96667f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/ChangeLog
@@ -0,0 +1,123 @@
+May 4, 2016: version 1.3.8
+
+    * minor changes to Makefile
+
+Apr 1, 2016: version 1.3.7
+
+    * licensing simplified (no other change); refer to KLU/Doc/License.txt
+
+Feb 1, 2016: version 1.3.6
+
+    * update to Makefiles
+
+Jan 30, 2016: version 1.3.5
+
+    * modifications to Makefiles
+
+Jan 1, 2016: version 1.3.4
+
+    * modified Makefile to create shared libraries
+        No change to C code except version number
+
+June 3, 2015: version 1.3.3
+
+    * fix to klu_dump.c, only when debugging is enabled.
+	No affect on production code.
+
+Oct 23, 2014: version 1.3.2
+
+    * modified MATLAB/klu_make.m.  No change to C source code.
+
+Oct 10, 2014: version 1.3.1
+
+    * modified MATLAB/klu_make.m.
+    * trivial change to Tcov/Makefile to allow the Tcov test to work when
+        CHOLMOD is compiled with GPU acceleration.  No change to source
+        code of KLU proper (except for the version number).
+
+July 31, 2013: version 1.3.0
+
+    * changed malloc and printf pointers to use SuiteSparse_config
+
+Jun 20, 2012: verison 1,2,1
+
+    * minor update for Windows (removed filesep)
+
+Jun 1, 2012: version 1.2.0
+
+    * changed from UFconfig to SuiteSparse_config
+
+Jan 20, 2012: version 1.1.4
+
+    * bug fix:  INT_MAX changed to Int_MAX (used for checking Int overflow).
+
+Dec 7, 2011: version 1.1.3
+
+    * fixed the Makefile to better align with CFLAGS and other standards
+    * minor fix to KLU mexFunction
+
+Jan 25, 2011: version 1.1.2
+
+    * minor fix to "make install"
+    * port of Tcov to Mac OSX 10.6.6
+
+Nov 30, 2009: version 1.1.1
+
+    * added "make install" and "make uninstall"
+
+March 24, 2009, version 1.1.0
+
+    * updates to documentation
+    * tabs expanded to spaces in all source code files
+
+Nov 1, 2007, version 1.0.1
+
+    * minor lint cleanup
+
+May 31, 2007, version 1.0
+
+    * Overview:  this is the first clean release of KLU.  Only one bug was
+	fixed since in the last pre-1.0 version (see below).  This release adds
+	a 64-bit version, a better Demo, a 100% statement coverage test, new
+	parameters and statistics in the KLU Common object, reduced memory
+	usage, a method for limiting worst-case work in the BTF ordering, and a
+	completely redesigned MATLAB interface.
+
+    * scaling default changed from no scaling, to max row scaling
+
+    * C-callable API modified for klu_malloc, klu_free, klu_realloc, klu_rcond,
+	klu_rgrowth, klu_condest.  API of other user-callable KLU functions not
+	modified.
+
+    * user ordering function prototype modified (final argument is now
+	klu_common, not Common->user_data)
+
+    * User Guide added.
+
+    * KLU Demo completely rewritten.  Now depends on CHOLMOD to read in its
+	matrices, in Matrix Market format.
+
+    * port to 64-bit version
+
+    * reduction in memory usage, particularly when the BTF form results in
+	many small diagonal blocks
+
+    * new Common parameter (maxwork) and statistics (work, memusage, mempeak)
+
+    * Makefile and object files (*.o) now placed in KLU/Lib, not KLU/Source
+
+    * added klu_install.m, klu_demo.m, klu_make.m to KLU/MATLAB.
+
+    * klu mexFunction now returns a struct for LU, not a lengthy list of
+	matrices.  MATLAB interface completely rewritten.
+
+    * Tcov tests completely rewritten
+
+    * bug fix in complex klu_z_refactor, when both btf and scaling are in use
+
+    * bug fix in klu_rgrowth, when the matrix is scaled
+
+Dec 12, 2006: version 0.11
+
+    * minor MATLAB cleanup
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/KLU_UserGuide.bib b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/KLU_UserGuide.bib
new file mode 100644
index 0000000000000000000000000000000000000000..123d88e42403a683b4305021bdfb91be0dddc6c4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/KLU_UserGuide.bib
@@ -0,0 +1,152 @@
+%-------------------------------------------------------------------------------
+
+@string{TOMS        = "{ACM} Trans. Math. Software"}
+@string{SIAMJSSC    = "{SIAM} J. Sci. Statist. Comput."}
+@string{SIMAX       = "{SIAM} J. Matrix Anal. Appl."}
+@string{SICOMP= "{SIAM} J. Comput."}
+@string{SIAMJSC     = "{SIAM} J. Sci. Comput."}
+
+@techreport{NagelPederson,
+    author={Nagel, L. W and Pederson, D. O.},
+    title={{SPICE} (Simulation Program with Integrated Circuit Emphasis)},
+    number={Memorandum No. ERL-M382},
+    address={University of California, Berkeley}, year={1973}}
+
+@incollection{Kundert86,
+     author={Kundert, K. S.},
+     year={1986},
+     title={Sparse Matrix Techniques and Their Applications to Circuit Simulation},
+     editor={Ruehli, A. E.},
+     booktitle={Circuit Analysis, Simulation and Design},
+     publisher={New York:  North-Holland}}
+
+@techreport{KundertSangiovanniVincentelli85,
+	author={Kundert, K. S. and Sangiovanni-Vincentelli, A.},
+	month={Oct.},
+	year={1985},
+	title={User's Guide: Sparse1.2},
+	institution={Dept.~of EE and CS, UC Berkeley},
+	keywords={ 31 Sparse1.2 software package direct methods}}
+
+@phdthesis{Quarles:M89/42,
+    Author = {Thomas L. Quarles},
+    Title = {Analysis of Performance and Convergence Issues for Circuit Simulation},
+    School = {EECS Department, University of California, Berkeley},
+    Year = {1989},
+    URL = {http://www.eecs.berkeley.edu/Pubs/TechRpts/1989/1216.html},
+    Number = {UCB/ERL M89/42}}
+
+@book{Davis06book,
+	author={T. A. Davis},
+	title={Direct Methods for Sparse Linear Systems},
+	publisher={SIAM}, year={2006}, address={Philadelphia, PA}}
+
+@article{GilbertPeierls88,
+	author={Gilbert, J. R. and Peierls, T.},
+	year={1988},
+	title={Sparse Partial Pivoting in Time Proportional to Arithmetic Operations},
+	journal=SIAMJSSC, volume={9}, pages={862-874}}
+
+@article{Duff78a,
+	author={Duff, I. S. and Reid, J. K.},
+	year={1978},
+	title={An Implementation of {Tarjan}'s Algorithm for the Block Triangularization of a Matrix},
+	journal=TOMS, volume={4}, pages={137-147}}
+
+@article{Duff81,
+	author={Duff, I. S.},
+	year={1981},
+	title={On Algorithms for Obtaining a Maximum Transversal},
+	journal=TOMS, volume={7}, pages={315-330}}
+
+@article{AmestoyDavisDuff96,
+	author={Amestoy, P. R. and Davis, T. A. and Duff, I. S.},
+	title={An approximate minimum degree ordering algorithm},
+	journal=SIMAX, year={1996}, volume={17}, pages={886--905}}
+
+@article{AmestoyDavisDuff03,
+	author={Amestoy, P. R. and Davis, T. A. and Duff, I. S.},
+	title={Algorithm 837: {AMD}, an approximate minimum degree ordering algorithm},
+	journal=TOMS, year={2004}, volume={30}, pages={381-388}}
+
+@article{Tarjan72,
+	author={Tarjan, R. E.},
+	title={Depth first search and linear graph algorithms},
+	journal=SICOMP, year={1972}, volume={1}, pages={146--160}}
+
+@article{DavisGilbertLarimoreNg00,
+	author={Davis, T. A. and Gilbert, J. R. and Larimore, S. I. and Ng, E. G.},
+	title={A column approximate minimum degree ordering algorithm},
+	journal=TOMS, year={2004}, volume={30}, pages={353-376}}
+
+@article{DavisGilbertLarimoreNg00_algo,
+	author={Davis, T. A. and Gilbert, J. R. and Larimore, S. I. and Ng, E. G.},
+	title={Algorithm 836:  {COLAMD}, a column approximate minimum degree ordering algorithm},
+	journal=TOMS, year={2004}, volume={30}, pages={377-380}}
+
+@article{ChenDavisHagerRajamanickam06,
+	author={Chen, Y. and Davis, T. A. and Hager, W. W. and Rajamanickam, S.},
+	title={Algorithm 887: {CHOLMOD}, supernodal sparse {Cholesky} factorization and update/downdate},
+	journal=TOMS, year={2009}, volume={35}, number={3}}
+
+@article{KarypisKumar98e,
+	author={Karypis, G. and Kumar, V.},
+	title={A fast and high quality multilevel scheme for partitioning irregular graphs},
+	journal=SIAMJSC, year={1998}, volume={20}}
+
+@article{ACM679a,
+	author={Dongarra, J. J. and {Du Croz}, J. and Duff, I. S. and Hammarling, S.},
+	title={A set of level-3 basic linear algebra subprograms},
+	journal=TOMS, year={1990}, volume={16}, pages={1--17}}
+
+@article{SuperLU99,
+	author={Demmel, J. W. and Eisenstat, S. C. and Gilbert, J. R. and Li, X. S. and Liu, J. W. H.},
+	title={A supernodal approach to sparse partial pivoting},
+	journal=SIMAX, year={1999}, volume={20}, pages={720-755} }
+
+@article{Davis03,
+	author={Davis, T. A.},
+	title={A column pre-ordering strategy for the unsymmetric-pattern multifrontal method},
+	journal=TOMS, year={2004}, volume={30}, pages={165--195}}
+
+@article{Davis03_algo,
+	author={Davis, T. A.},
+	title={Algorithm 832:  {UMFPACK V4.3}, an unsymmetric-pattern multifrontal method},
+	journal=TOMS, year={2002}, volume={30}, pages={196--199}}
+
+@article{Hager84,
+	author={Hager, W. W.},
+	title={Condition estimates},
+	journal=SIAMJSSC, year={1984},volume={5}, pages={311-316}}
+
+@article{HighamTisseur00,
+	author={Higham, N. J. and Tisseur, F.},
+	title={A block algorithm for matrix 1-norm estimation with an application to 1-norm pseudospectra},
+	journal=SIMAX, year={2000},volume={21},pages={1185--1201} }
+
+@techreport{Palamadai05,
+	author={Palamadai, E.},
+	title={{KLU} - a high performance sparse linear system solver for
+	    circuit simulation problems},
+	note={M.S. Thesis},
+	address={CISE Department, Univ. of Florida}}
+
+@article{DavisNatarajan10,
+    author = {Davis, Timothy A. and Palamadai Natarajan, Ekanathan},
+    title = {Algorithm 907: {KLU}, A Direct Sparse Solver for Circuit Simulation Problems},
+    journal = {ACM Trans. Math. Softw.},
+    volume = {37},
+    issue = {3},
+    month = {September},
+    year = {2010},
+    issn = {0098-3500},
+    pages = {36:1--36:17},
+    articleno = {36},
+    numpages = {17},
+    url = {http://doi.acm.org/10.1145/1824801.1824814},
+    doi = {http://doi.acm.org/10.1145/1824801.1824814},
+    acmid = {1824814},
+    publisher = {ACM},
+    address = {New York, NY, USA},
+    keywords = {LU factorization, circuit simulation, sparse matrices},
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/KLU_UserGuide.tex b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/KLU_UserGuide.tex
new file mode 100644
index 0000000000000000000000000000000000000000..4dbcd5eb8411064cb6b869d199e33b8030073197
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/KLU_UserGuide.tex
@@ -0,0 +1,1302 @@
+\documentclass[11pt]{article}
+
+\newcommand{\m}[1]{{\bf{#1}}}       % for matrices and vectors
+\newcommand{\tr}{^{\sf T}}          % transpose
+
+\topmargin 0in
+\textheight 9in
+\oddsidemargin 0pt
+\evensidemargin 0pt
+\textwidth 6.5in
+
+%------------------------------------------------------------------------------
+\begin{document}
+%------------------------------------------------------------------------------
+
+\title{User Guide for KLU and BTF}
+\author{
+Timothy A. Davis\thanks{
+DrTimothyAldenDavis@gmail.com,
+http://www.suitesparse.com.
+This work was supported by Sandia National Labs, and the National
+Science Foundation.
+Portions of the work were done while on sabbatical at Stanford University
+and Lawrence Berkeley National Laboratory (with funding from Stanford
+University and the SciDAC program).
+}
+\and Eka Palamadai Natarajan}
+
+\date{VERSION 1.3.8, May 4, 2016}
+\maketitle
+
+%------------------------------------------------------------------------------
+\begin{abstract}
+KLU is a set of routines for solving sparse linear systems of equations.
+It is particularly well-suited to matrices arising in SPICE-like circuit
+simulation applications.
+It relies on a permutation to block triangular form (BTF), several methods
+for finding a fill-reducing ordering (variants of approximate minimum degree,
+and nested dissection), and a sparse left-looking LU factorization method
+to factorize each block.  A MATLAB interface is included.
+KLU appears as Collected Algorithm 907 of the ACM \cite{DavisNatarajan10}.
+\end{abstract}
+%------------------------------------------------------------------------------
+
+\newpage
+\tableofcontents
+\newpage
+
+%------------------------------------------------------------------------------
+\section{License and Copyright}
+%------------------------------------------------------------------------------
+
+KLU, Copyright\copyright 2004-2011 University of Florida.
+All Rights Reserved.
+KLU is available under alternate licenses; contact T. Davis for details.
+
+{\bf KLU License:} see KLU/Doc/License.txt for the license.
+
+{\bf Availability:} {\tt http://www.suitesparse.com}
+
+{\bf Acknowledgments:}
+
+    This work was supported by Sandia National Laboratories (Mike Heroux)
+    and the National Science Foundation under grants 0203270 and 0620286.
+
+
+%------------------------------------------------------------------------------
+\newpage
+\section{Overview}
+%------------------------------------------------------------------------------
+
+KLU is a set of routines for solving sparse linear systems of equations.  It
+first permutes the matrix into upper block triangular form, via the BTF
+package.  This is done by first finding a permutation for a zero-free diagonal
+(a maximum transversal) \cite{Duff81}. If there is no such permutation, then
+the matrix is structurally rank-deficient, and is numerically singular.  Next,
+Tarjan's method \cite{Duff78a,Tarjan72} is used to find the strongly-connected
+components of the graph.  The block triangular form is essentially unique; any
+method will lead to the same number and sizes of blocks, although the ordering
+of the blocks may vary (consider a diagonal matrix, for example).  Assuming the
+matrix has full structural rank, the permuted matrix has the following form:
+\[
+PAQ =
+\left[
+\begin{array}{ccc}
+A_{11} & \cdots & A_{1k} \\
+       & \ddots & \vdots \\
+       &        & A_{kk} \\
+\end{array}
+\right],
+\]
+where each diagonal block is square with a zero-free diagonal.
+
+Next, each diagonal block is factorized with a sparse left-looking method
+\cite{GilbertPeierls88}.  The kernel of this factorization method is an
+efficient method for solving $Lx=b$ when $L$, $x$, and $b$ are all sparse.
+This kernel is used to compute each column of $L$ and $U$, one column at a time.
+The total work performed by this method is always proportional to the number of
+floating-point operations, something that is not true of any other sparse LU
+factorization method.
+
+Prior to factorizing each diagonal block, the blocks are ordered to reduce
+fill-in.  By default, the symmetric approximate minimum degree (AMD) ordering
+is used on $A_{ii}+A_{ii}^T$ \cite{AmestoyDavisDuff96,AmestoyDavisDuff03}.
+Another ordering option is to find a column ordering via COLAMD
+\cite{DavisGilbertLarimoreNg00_algo,DavisGilbertLarimoreNg00}.
+Alternatively, a permutation can be provided by the user, or a pointer to
+a user-provided ordering function can be passed, which is then used to order
+each block.
+
+Only the diagonal blocks need to be factorized.  Consider a linear system where
+the matrix is permuted into three blocks, for example:
+\[
+\left[
+\begin{array}{ccc}
+A_{11} & A_{12} & A_{13} \\
+       & A_{22} & A_{23} \\
+       &        & A_{33} \\
+\end{array}
+\right]
+\left[
+\begin{array}{c}
+x_{1} \\
+x_{2} \\
+x_{3} \\
+\end{array}
+\right]
+=
+\left[
+\begin{array}{c}
+b_{1} \\
+b_{2} \\
+b_{3} \\
+\end{array}
+\right].
+\]
+
+The non-singular system $A_{33} x_{3} = b_{3}$ can first be solved for $x_{3}$.
+After a block back substitution, the resulting system becomes
+\[
+\left[
+\begin{array}{cc}
+A_{11} & A_{12} \\
+       & A_{22} \\
+\end{array}
+\right]
+\left[
+\begin{array}{c}
+x_{1} \\
+x_{2} \\
+\end{array}
+\right]
+=
+\left[
+\begin{array}{c}
+b_{1} - A_{13} x_{3}\\
+b_{2} - A_{23} x_{3}\\
+\end{array}
+\right]
+=
+\left[
+\begin{array}{c}
+b'_{1} \\
+b'_{2} \\
+\end{array}
+\right]
+\]
+and the $A_{22} x_{2} = b'_{2}$ system can be solved for $x_{2}$.  The primary
+advantage of this method is that no fill-in occurs in the off-diagonal blocks
+($A_{12}$, $A_{13}$, and $A_{23}$).  This is particular critical for sparse
+linear systems arising in SPICE-like circuit simulation
+\cite{Kundert86,KundertSangiovanniVincentelli85,NagelPederson,Quarles:M89/42}.
+Circuit matrices are typically permutable into block triangular form, with many
+singletons (1-by-1 blocks).  They also often have a handful of rows and columns
+with many nonzero entries, due to voltage and current sources.  These rows and
+columns are pushed into the upper block triangular form, and related to the
+singleton blocks (for example, $A_{33}$ in the above system is 1-by-1, and the
+column in $A_{13}$ and $A_{23}$ has many nonzero entries).  Since these
+nearly-dense rows and columns do not appear in the LU factorization of the
+diagonal blocks, they cause no fill-in.
+
+The structural rank of a matrix is based solely on the pattern of its entries,
+not their numerical values.  With random entries, the two ranks are equal with
+probability one.   The structural rank of any matrix is an upper bound on the
+numerical rank.  The maximum transversal algorithm in the BTF package is useful
+in determining if a matrix is structurally rank deficient, and if so, it
+reveals a (non-unique) set of rows and columns that contribute to that rank
+deficiency.  This is useful in determining what parts of a circuit are poorly
+formulated (such as dangling components).
+
+When ordered and factorized with KLU, very little fill-in occurs in the
+resulting LU factors, which means that there is little scope for use of the
+BLAS \cite{ACM679a}.  Sparse LU factorization methods that use the BLAS (such
+as SuperLU \cite{SuperLU99} amd UMFPACK \cite{Davis03_algo,Davis03}) are slower
+than KLU when applied to sparse matrices arising in circuit simulation.  Both
+KLU and SuperLU are based on Gilbert and Peierl's left-looking method
+\cite{GilbertPeierls88}.  SuperLU uses supernodes, but KLU does not; thus the
+name {\em KLU} refers to a ``Clark Kent'' LU factorization algorithm (what
+SuperLU was before it became Super).
+
+For details of the permutation to block triangular form, left-looking sparse
+LU factorization, and approximate minimum degree, refer to \cite{Davis06book}.
+Concise versions of these methods can be found in the CSparse package.  KLU is
+also the topic of a Master's thesis by Palamadai Natarajan \cite{Palamadai05};
+a copy of
+the thesis can be found in the {\tt KLU/Doc} directory.  It includes a
+description of an earlier version of KLU; some of the function names and
+parameter lists have changed in this version.  The descriptions of the methods
+used still applies to the current version of KLU, however.
+
+KLU appears as {\em Algorithm 907: KLU, a direct sparse solver for circuit
+simulation problems}, ACM Transactions on Mathematical Software, vol 37, no 3,
+2010.
+
+%------------------------------------------------------------------------------
+\section{Availability}
+%------------------------------------------------------------------------------
+
+KLU and its required ordering packages (BTF, COLAMD, AMD, and
+SuiteSparse\_config) are
+available at \newline {\tt http://www.suitesparse.com.}  In
+addition, KLU can make use of any user-provided ordering function.  One such
+function is included, which provides KLU with an interface to the ordering
+methods used in CHOLMOD \cite{ChenDavisHagerRajamanickam06}, such as METIS, a
+nested dissection method \cite{KarypisKumar98e}.  After permutation to block
+triangular form, circuit matrices have very good node separators, and are thus
+excellent candidates for nested dissection.  The METIS ordering takes much more
+time to compute than the AMD ordering, but if the ordering is reused many times
+(typical in circuit simulation) the better-quality ordering can pay off in
+lower total simulation time. 
+
+To use KLU, you must obtain the KLU, BTF, SuiteSparse\_config,
+AMD, and COLAMD packages
+in the SuiteSparse suite of sparse matrix libraries.  See 
+{\tt http://www.suitesparse.com} for each of these packages.
+They are also all contained within the single {\tt SuiteSparse.zip} or
+{\tt SuiteSparse.tar.gz} distribution.
+
+%------------------------------------------------------------------------------
+\section{Using KLU and BTF in MATLAB}
+%------------------------------------------------------------------------------
+
+KLU has a single MATLAB interface which provides several options for factorizing
+a matrix and/or using the factors to solve a linear system.  The following is
+a synopsis of its use.  For more details, type {\tt help klu} in MATLAB.
+
+{\footnotesize
+\begin{verbatim}
+   LU = klu (A)            factorizes R\A(p,q) into L*U+F, returning a struct
+   x = klu (A,'\',b)       x = A\b
+   x = klu (b,'/',A)       x = b/A
+   x = klu (LU,'\',b)      x = A\b, where LU = klu(A)
+   x = klu (b,'/',LU)      x = b/A, where LU = klu(A)
+\end{verbatim}
+}
+
+With a single input {\tt klu(A)} returns a MATLAB struct containing the LU
+factors.  The factorization is in the form \verb'L*U + F = R \ A(p,q)'
+where {\tt L*U} is the LU factorization of just the diagonal blocks of the
+block triangular form, {\tt F} is a sparse matrix containing the entries in
+the off-diagonal blocks, {\tt R} is a diagonal matrix containing the row
+scale factors, and {\tt p} and {\tt q} are permutation vectors.  The {\tt LU}
+struct also contains a vector {\tt r} which describes the block boundaries
+(the same as the third output parameter of {\tt dmperm}).  The {\tt k}th
+block consists of rows and columns {\tt r(k)} to {\tt r(k+1)-1} in the
+permuted matrix {\tt A(p,q)} and the factors {\tt L} and {\tt U}.
+
+An optional final input argument ({\tt klu(A,opts)} for example) provides a
+way of modifying KLU's user-definable parameters, including a partial pivoting
+tolerance and ordering options.  A second output argument
+({\tt [LU,info] = klu ( ... )}) provides statistics on the factorization.
+
+The BTF package includes three user-callable MATLAB functions which replicate
+most of features of the MATLAB built-in {\tt dmperm} function, and provide an
+additional option which can significantly limit the worst-case time taken by
+{\tt dmperm}.  For more details, type {\tt help btf}, {\tt help maxtrans},
+and {\tt help strongcomp} in MATLAB.  Additional information about how
+these functions work can be found in \cite{Davis06book}.
+
+{\footnotesize
+\begin{verbatim}
+   [p,q,r] = btf (A)         similar to [p,q,r] = dmperm (A)
+   q = maxtrans (A)          similar to q = dmperm (A')
+   [p,r] = strongcomp (A)    similar to [p,q,r] = dmperm (A + speye(n))
+\end{verbatim}
+}
+
+Both {\tt btf} and {\tt maxtrans} include a second option input, {\tt maxwork},
+which limits the total work performed in the maximum transversal to
+{\tt maxwork * nnz(A)}.  The worst-case time taken by the algorithm is
+$O$ ({\tt n * nnz(A)}), where the matrix {\tt A} is {\tt n}-by-{\tt n}, but
+this worst-case time is rarely reached in practice.
+
+To use the KLU and BTF functions in MATLAB, you must first compile and install
+them.  In the {\tt BTF/MATLAB} directory, type {\tt btf\_install}, and then
+type {\tt klu\_install} in the {\tt KLU/MATLAB} directory.  Alternatively, if
+you have the entire SuiteSparse, simply run the {\tt SuiteSparse\_install}
+function in the {\tt SuiteSparse} directory.
+
+After running the installation scripts, type {\tt pathtool} and save your path
+for future MATLAB sessions.  If you cannot save your path because of file
+permissions, edit your {\tt startup.m} by adding {\tt addpath} commands (type
+{\tt doc startup} and {\tt doc addpath} for more information).
+
+%------------------------------------------------------------------------------
+\section{Using KLU and BTF in a C program}
+\label{Cversion}
+%------------------------------------------------------------------------------
+
+KLU and BTF include the following C-callable functions.  Each function is
+available in two or four versions: with {\tt int} or {\tt long} integers, and
+(for functions that deal with numerical values), with {\tt double} or complex
+{\tt double} values.  The {\tt long} integer is actually a {\tt SuiteSparse\_long},
+which is typically a {\tt long}, defined with a {\tt \#define} statement.  It
+becomes an {\tt \_\_int64} on Microsoft Windows 64, however.
+
+The usage of real and complex, and {\tt int} and {\tt SuiteSparse\_long}, must not be
+mixed, except that some functions can be used for both real and complex cases.
+
+%------------------------------------------------------------------------------
+\subsection{KLU Common object}
+%------------------------------------------------------------------------------
+
+The {\tt klu\_common} object ({\tt klu\_l\_common} for the {\tt SuiteSparse\_long}
+version) contains user-definable parameters and statistics returned from
+KLU functions.  This object appears in every KLU function as the last
+parameter.  Details are given in the {\tt klu.h} include file, which also
+appears below in Section~\ref{klu_include}.  Primary parameters and statistics
+are summarized below.  The defaults are chosen specifically for circuit
+simulation matrices.
+
+\begin{itemize}
+\item {\tt tol}: partial pivoting tolerance.  If the diagonal entry has a
+magnitude greater than or equal to {\tt tol} times the largest magnitude
+of entries in the pivot column, then the diagonal entry is chosen.
+Default value: 0.001.
+
+\item {\tt ordering}: which fill-reducing ordering to use: 0 for AMD,
+1 for COLAMD, 2 for a user-provided permutation {\tt P} and {\tt Q}
+(or a natural ordering if {\tt P} and {\tt Q} are NULL), or 3 for
+the {\tt user\_order} function.  Default: 0 (AMD).
+
+\item {\tt scale}: whether or not the matrix should be scaled.
+If {\tt scale < 0}, then no scaling is performed and the input matrix
+is not checked for errors.  If {\tt scale >= 0}, the input matrix is
+check for errors.
+If {\tt scale=0}, then no scaling is performed.
+If {\tt scale=1}, then each row of {\tt A} is divided by the sum of
+the absolute values in that row.
+If {\tt scale=2}, then each row of {\tt A} is divided by the maximum
+absolute value in that row.  Default: 2.
+
+\item {\tt btf}:  if nonzero, then BTF is used to permute the input matrix
+into block upper triangular form.  This step is skipped if {\tt Common.btf}
+is zero.  Default: 1.
+
+\item {\tt maxwork}: sets an upper limit on the amount of work performed in
+{\tt btf\_maxtrans} to \newline {\tt maxwork*nnz(A)}.  If the limit is reached,
+a partial zero-free diagonal might be found.  This has no effect on whether or
+not the matrix can be factorized, since the matrix can be factorized with no
+BTF pre-ordering at all.  This option provides a tradeoff between the
+effectiveness of the BTF ordering and the cost to compute it.  A partial result
+can result in fewer, and larger, blocks in the BTF form, resulting to more work
+required to factorize the matrix.  No limit is enforced if {\tt maxwork <= 0}.
+Default: 0.
+
+\item {\tt user\_order}: a pointer to a function that can be provided by the
+application that uses KLU, to redefine the fill-reducing ordering used by KLU
+for each diagonal block.  The {\tt int} and {\tt SuiteSparse\_long} prototypes must be
+as follows:
+
+{\footnotesize
+\begin{verbatim}
+int my_ordering_function (int n, int Ap [ ], int Ai [ ], int Perm [ ], klu_common *Common) ;
+
+
+SuiteSparse_long my_long_ordering_function (SuiteSparse_long n,
+    SuiteSparse_long Ap [ ], SuiteSparse_long Ai [ ],
+    SuiteSparse_long Perm [ ], klu_l_common *Common);
+\end{verbatim}
+}
+
+The function should return 0 if an error occurred, and either -1 or a positive
+(nonzero) value if no error occurred.  If greater than zero, then the return
+value is interpreted by KLU as an estimate of the number of nonzeros in $L$ or
+$U$ (whichever is greater), when the permuted matrix is factorized.  Only an
+estimate is possible, since partial pivoting with row interchanges is performed
+during numerical factorization.  The input matrix is provided to the function
+in the parameters {\tt n}, {\tt Ap}, and {\tt Ai}, in compressed-column form.
+The matrix {\tt A} is {\tt n}-by-{\tt n}.  The {\tt Ap} array is of size {\tt
+n+1}; the {\tt j}th column of {\tt A} has row indices {\tt Ai[Ap[j] ...
+Ap[j+1]-1]}.  The {\tt Ai} array is of size {\tt Ap[n]}.  The first column
+pointer {\tt Ap[0]} is zero.  The row indices might not appear sorted in each
+column, but no duplicates will appear.
+
+The output permutation is to be passed back in the {\tt Perm} array, where
+{\tt Perm[k]=j} means that row and column {\tt j} of {\tt A} will appear as
+the {\tt k}th row and column of the permuted matrix factorized by KLU.  The
+{\tt Perm} array is already allocated when it is passed to the user function.
+
+The user function may use, and optionally modify, the contents of the {\tt
+klu\_common Common} object.  In particular, prior to calling KLU, the user
+application can set both {\tt Common.user\_order} and {\tt Common.user\_data}.
+The latter is a {\tt void *} pointer that KLU does not use, except to pass to
+the user ordering function pointed to by {\tt Common.user\_order}.  This is a
+mechanism for passing additional arguments to the user function.
+
+An example user function is provided in the {\tt KLU/User} directory, which
+provides an interface to the ordering method in CHOLMOD.
+
+\end{itemize}
+
+%------------------------------------------------------------------------------
+\subsection{KLU Symbolic object}
+%------------------------------------------------------------------------------
+
+KLU performs its sparse LU factorization in two steps.  The first is purely
+symbolic, and does not depend on the numerical values.  This analysis returns a
+{\tt klu\_symbolic} object ({\tt klu\_l\_symbolic} in the {\tt SuiteSparse\_long}
+version).  The {\tt Symbolic} object contains a pre-ordering which combines the
+block triangular form with the fill-reducing ordering, and an estimate of the
+number of nonzeros in the factors of each block.  Its size is thus modest, only
+proportional to {\tt n}, the dimension of {\tt A}.  It can be reused multiple
+times for the factorization of a sequence of matrices with identical nonzero
+pattern.  Note: a {\em nonzero} in this sense is an entry present in the data
+structure of {\tt A}; such entries may in fact be numerically zero.
+
+%------------------------------------------------------------------------------
+\subsection{KLU Numeric object}
+%------------------------------------------------------------------------------
+
+The {\tt Numeric} object contains the numeric sparse LU factorization, including
+the final pivot permutations.  To solve a linear system, both the {\tt Symbolic}
+and {\tt Numeric} objects are required.
+
+%------------------------------------------------------------------------------
+\subsection{A sparse matrix in KLU}
+%------------------------------------------------------------------------------
+
+% From here on, only the {\tt int} version is described.  In the {\tt SuiteSparse\_long}
+% version, the function names change slightly ({\tt klu\_factor} becomes
+% {\tt klu\_l\_factor}, and the {\tt int}/complex version {\tt klu\_z\_factor}
+% becomes {\tt klu\_zl\_factor}, for example).  For more details on the
+% {\tt SuiteSparse\_long} version, refer to Section~\ref{klu_include}.
+
+The input matrix provided to KLU is in sparse compressed-column form, which is
+the same data structure used internally in MATLAB, except that the version used
+here allows for the row indices to appear in any ordering, and this version
+also allows explicit zero entries to appear in the data structure.  The same
+data structure is used in CSparse, which is fully documented in
+\cite{Davis06book}.  If you wish to use a simpler input data structure,
+consider creating a triplet matrix in CSparse (or CXSparse if you use the long
+and/or complex versions of KLU), and then convert this data structure into a
+sparse compressed-column data structure, using the CSparse {\tt cs\_compress}
+and {\tt cs\_dupl} functions.  Similar functions are available in CHOLMOD
+{\tt cholmod\_triplet\_to\_sparse}.
+
+The matrix is described with four parameters:
+
+\begin{itemize}
+\item {\tt n}: an integer scalar.  The matrix is {\tt n}-by-{\tt n}.  Note that
+KLU only operates on square matrices.
+
+\item {\tt Ap}: an integer array of size {\tt n+1}.  The first entry is {\tt
+Ap[0]=0}, and the last entry {\tt nz=Ap[n]} is equal to the number of entries
+in the matrix.
+
+\item {\tt Ai}: an integer array of size {\tt nz = Ap[n]}.
+The row indices of entries in column {\tt j} of {\tt A} are located in
+{\tt Ai [Ap [j] ... Ap [j+1]-1]}.  The matrix is zero-based; row and column
+indices are in the range 0 to {\tt n-1}.
+
+\item {\tt Ax}: a {\tt double} array of size {\tt nz} for the real case, or
+{\tt 2*nz} for the complex case.  For the complex case, the real and imaginary
+parts are interleaved, compatible with Fortran and the ANSI C99 Complex data
+type.  KLU does not rely on the ANSI C99 data type, however, for portability
+reasons.  The numerical values in column {\tt j} of a real matrix are located
+in {\tt Ax [Ap [j] ... Ap [j+1]-1]}.  For a complex matrix, they appear in {\tt
+Ax [2*Ap [j] ... 2*Ap [j+1]-1]}, as real/imaginary pairs (the real part appears
+first, followed by the imaginary part).
+
+\end{itemize}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_defaults}: set default parameters}
+%-------------------------------------------------------------------------------
+
+This function sets the default parameters for KLU and clears the statistics.
+It may be used for either the real or complex cases.  A value of 0 is returned
+if an error occurs, 1 otherwise.  This function {\bf must} be called before
+any other KLU function can be called.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok ;
+    klu_common Common ;
+    ok = klu_defaults (&Common) ;                                             /* real or complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok ;
+    klu_l_common Common ;
+    ok = klu_l_defaults (&Common) ;                                           /* real or complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_analyze}: order and analyze a matrix}
+%-------------------------------------------------------------------------------
+
+The following usage returns a {\tt Symbolic} object that contains the
+fill-reducing ordering needed to factorize the matrix {\tt A}.  A NULL pointer
+is returned if a failure occurs.  The error status for this function, and all
+others, is returned in {\tt Common.status}.  These functions may be used for
+both real and complex cases.  The AMD ordering is used if {\tt Common.ordering
+= 0}, COLAMD is used if it is 1, the natural ordering is used if it is 2, and
+the user-provided {\tt Common.user\_ordering} is used if it is 3.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int n, Ap [n+1], Ai [nz] ;
+    klu_symbolic *Symbolic ;
+    klu_common Common ;
+    Symbolic = klu_analyze (n, Ap, Ai, &Common) ;                             /* real or complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long n, Ap [n+1], Ai [nz] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_common Common ;
+    Symbolic = klu_l_analyze (n, Ap, Ai, &Common) ;                           /* real or complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_analyze\_given}: order and analyze a matrix}
+%-------------------------------------------------------------------------------
+
+In this routine, the fill-reducing ordering is provided by the user ({\tt
+Common.ordering} is ignored).  Instead, the row permutation {\tt P} and column
+permutation {\tt Q} are used.  These are integer arrays of size {\tt n}.  If
+NULL, a natural ordering is used (so to provide just a column ordering, pass
+{\tt Q} as non-NULL and {\tt P} as NULL).  A NULL pointer is returned if an
+error occurs.  These functions may be used for both real and complex cases.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int n, Ap [n+1], Ai [nz], P [n], Q [n] ;
+    klu_symbolic *Symbolic ;
+    klu_common Common ;
+    Symbolic = klu_analyze_given (n, Ap, Ai, P, Q, &Common) ;                 /* real or complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long n, Ap [n+1], Ai [nz], P [n], Q [n] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_common Common ;
+    Symbolic = klu_l_analyze_given (n, Ap, Ai, P, Q, &Common) ;               /* real or complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_factor}: numerical factorization}
+%-------------------------------------------------------------------------------
+
+The {\tt klu\_factor} function factorizes a matrix, using a sparse left-looking
+method with threshold partial pivoting.  The inputs {\tt Ap} and {\tt Ai} must
+be unchanged from the previous call to {\tt klu\_analyze} that created the {\tt
+Symbolic} object.  A NULL pointer is returned if an error occurs.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int Ap [n+1], Ai [nz] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    Numeric = klu_factor (Ap, Ai, Ax, Symbolic, &Common) ;                            /* real */
+    Numeric = klu_z_factor (Ap, Ai, Az, Symbolic, &Common) ;                          /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long Ap [n+1], Ai [nz] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    Numeric = klu_l_factor (Ap, Ai, Ax, Symbolic, &Common) ;                          /* real */
+    Numeric = klu_zl_factor (Ap, Ai, Az, Symbolic, &Common) ;                         /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_solve}: solve a linear system}
+%-------------------------------------------------------------------------------
+
+Solves the linear system $Ax=b$, using the {\tt Symbolic} and  {\tt Numeric}
+objects.  The right-hand side {\tt B} is overwritten with the solution on
+output.  The array {\tt B} is stored in column major order, with a leading
+dimension of {\tt ldim}, and {\tt nrhs} columns.  Thus, the real entry $b_{ij}$
+is stored in {\tt B [i+j*ldim]}, where {\tt ldim >= n} must hold.  A complex
+entry $b_{ij}$ is stored in {\tt B [2*(i+j*ldim)]} and {\tt B [2*(i+j*ldim)+1]}
+(for the real and imaginary parts, respectively).  Returns 1 if successful,
+0 if an error occurs.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ldim, nrhs, ok ;
+    double B [ldim*nrhs], Bz [2*ldim*nrhs] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_solve (Symbolic, Numeric, ldim, nrhs, B, &Common) ;                      /* real */
+    ok = klu_z_solve (Symbolic, Numeric, ldim, nrhs, Bz, &Common) ;                   /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ldim, nrhs, ok ;
+    double B [ldim*nrhs], Bz [2*ldim*nrhs] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_l_solve (Symbolic, Numeric, ldim, nrhs, B, &Common) ;                    /* real */
+    ok = klu_zl_solve (Symbolic, Numeric, ldim, nrhs, Bz, &Common) ;                  /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_tsolve}: solve a transposed linear system}
+%-------------------------------------------------------------------------------
+
+Solves the linear system $A^Tx=b$ or $A^Hx=b$.  The {\tt conj\_solve} input
+is 0 for $A^Tx=b$, or nonzero for $A^Hx=b$.  Otherwise, the function is
+identical to {\tt klu\_solve}.
+
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ldim, nrhs, ok ;
+    double B [ldim*nrhs], Bz [2*ldim*nrhs] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_tsolve (Symbolic, Numeric, ldim, nrhs, B, &Common) ;                     /* real */
+    ok = klu_z_tsolve (Symbolic, Numeric, ldim, nrhs, Bz, conj_solve, &Common) ;      /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ldim, nrhs, ok ;
+    double B [ldim*nrhs], Bz [2*ldim*nrhs] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_l_tsolve (Symbolic, Numeric, ldim, nrhs, B, &Common) ;                   /* real */
+    ok = klu_zl_tsolve (Symbolic, Numeric, ldim, nrhs, Bz, conj_solve, &Common) ;     /* complex */
+\end{verbatim}
+}
+
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_refactor}: numerical refactorization}
+%-------------------------------------------------------------------------------
+
+The {\tt klu\_refactor} function takes as input the {\tt Numeric} object
+created by {\tt klu\_factor} (or as modified by a previous call to {\tt
+klu\_refactor}).  It factorizes a new matrix with the same nonzero pattern as
+that given to the call to {\tt klu\_factor} which created it.  The same pivot
+order is used.  Since this can lead to numeric instability, the use of {\tt
+klu\_rcond}, {\tt klu\_rgrowth}, or {\tt klu\_condest} is recommended to check
+the accuracy of the resulting factorization.  The inputs {\tt Ap} and {\tt Ai}
+must be unmodified since the call to {\tt klu\_factor} that first created the
+{\tt Numeric} object.  This is function is much faster than {\tt klu\_factor},
+and requires no dynamic memory allocation.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok, Ap [n+1], Ai [nz] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_refactor (Ap, Ai, Ax, Symbolic, Numeric, &Common) ;                      /* real */
+    ok = klu_z_refactor (Ap, Ai, Az, Symbolic, Numeric, &Common) ;                    /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok, Ap [n+1], Ai [nz] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_refactor (Ap, Ai, Ax, Symbolic, Numeric, &Common) ;                    /* real */
+    ok = klu_zl_refactor (Ap, Ai, Az, Symbolic, Numeric, &Common) ;                   /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_free\_symbolic}: destroy the {\tt Symbolic} object}
+%-------------------------------------------------------------------------------
+
+It is the user's responsibility to destroy the {\tt Symbolic} object when it is
+no longer needed, or else a memory leak will occur.  It is safe to pass a NULL
+{\tt Symbolic} pointer.  These functions may be used for both real and complex
+cases.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    klu_symbolic *Symbolic ;
+    klu_common Common ;
+    klu_free_symbolic (&Symbolic, &Common) ;                                  /* real or complex */
+
+
+    #include "klu.h"
+    klu_l_symbolic *Symbolic ;
+    klu_l_common Common ;
+    klu_l_free_symbolic (&Symbolic, &Common) ;                                /* real or complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_free\_numeric}: destroy the {\tt Numeric} object}
+%-------------------------------------------------------------------------------
+
+It is the user's responsibility to destroy the {\tt Numeric} object when it is
+no longer needed, or else a memory leak will occur.  It is safe to pass a NULL
+{\tt Numeric} pointer.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    klu_free_numeric (&Numeric, &Common) ;                                            /* real */
+    klu_z_free_numeric (&Numeric, &Common) ;                                          /* complex */
+
+
+    #include "klu.h"
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    klu_l_free_numeric (&Numeric, &Common) ;                                          /* real */
+    klu_zl_free_numeric (&Numeric, &Common) ;                                         /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_sort}: sort the columns of L and U}
+%-------------------------------------------------------------------------------
+
+The {\tt klu\_factor} function creates a {\tt Numeric} object with factors
+{\tt L} and {\tt U} stored in a compressed-column form (not the same data
+structure as {\tt A}, but similar).  The columns typically contain lists of
+row indices in unsorted order.  This function sorts these indices, for two
+purposes:  (1) to return {\tt L} and {\tt U} to MATLAB, which expects its
+sparse matrices to have sorted columns, and (2) to slightly improve the
+performance of subsequent calls to {\tt klu\_solve} and {\tt klu\_tsolve}.
+Except within a MATLAB mexFunction (see {\tt KLU/MATLAB/klu\_mex.c}, the use
+of this function is optional.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_sort (Symbolic, Numeric, &Common) ;                                      /* real */
+    ok = klu_z_sort (Symbolic, Numeric, &Common) ;                                    /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_sort (Symbolic, Numeric, &Common) ;                                    /* real */
+    ok = klu_zl_sort (Symbolic, Numeric, &Common) ;                                   /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_flops}: determine the flop count}
+%-------------------------------------------------------------------------------
+
+This function determines the number of floating-point operations performed
+when the matrix was factorized by {\tt klu\_factor} or {\tt klu\_refactor}.
+The result is returned in {\tt Common.flops}.
+
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_flops (Symbolic, Numeric, &Common) ;                                     /* real */
+    ok = klu_z_flops (Symbolic, Numeric, &Common) ;                                   /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_flops (Symbolic, Numeric, &Common) ;                                   /* real */
+    ok = klu_zl_flops (Symbolic, Numeric, &Common) ;                                  /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_rgrowth}: determine the pivot growth}
+%-------------------------------------------------------------------------------
+
+Computes the reciprocal pivot growth,
+$\mbox{\em rgrowth} = \min_j (( \max_i |c_{ij}| ) / ( \max_i |u_{ij}| ))$,
+where $c_{ij}$ is a scaled entry in a diagonal block of the block triangular
+form.  In MATLAB notation:
+\begin{verbatim}
+    rgrowth = min (max (abs (R\A(p,q) - F)) ./ max (abs (U)))
+\end{verbatim}
+where the factorization is \verb'L*U + F = R \ A(p,q)'.
+This function returns 0 if an error occurred, 1 otherwise.  If {\tt rgrowth} is
+very small, an inaccurate factorization may have been performed.  The inputs
+{\tt Ap}, {\tt Ai}, and {\tt Ax}  ({\tt Az} in the complex case) must be
+unchanged since the last call to {\tt klu\_factor} or {\tt klu\_refactor}.  The
+result is returned in {\tt Common.rgrowth}.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok, Ap [n+1], Ai [nz] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_rgrowth (Ap, Ai, Ax, Symbolic, Numeric, &Common) ;                       /* real */
+    ok = klu_z_rgrowth (Ap, Ai, Az, Symbolic, Numeric, &Common) ;                     /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok, Ap [n+1], Ai [nz] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_rgrowth (Ap, Ai, Ax, Symbolic, Numeric, &Common) ;                     /* real */
+    ok = klu_zl_rgrowth (Ap, Ai, Az, Symbolic, Numeric, &Common) ;                    /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_condest}: accurate condition number estimation}
+%-------------------------------------------------------------------------------
+
+This function is essentially the same as the MATLAB {\tt condest} function.  It
+computes an estimate of the 1-norm condition number, using Hager's method
+\cite{Hager84} and the generalization by Higham and Tisseur
+\cite{HighamTisseur00}.  The inputs {\tt Ap}, and {\tt Ax} ({\tt Az} in the
+complex case) must be unchanged since the last call to {\tt klu\_factor} or
+{\tt klu\_refactor}.  The result is returned in {\tt Common.condest}.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok, Ap [n+1] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_condest (Ap, Ax, Symbolic, Numeric, &Common) ;                           /* real */
+    ok = klu_z_condest (Ap, Az, Symbolic, Numeric, &Common) ;                         /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok, Ap [n+1] ;
+    double Ax [nz], Az [2*nz] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_condest (Ap, Ax, Symbolic, Numeric, &Common) ;                         /* real */
+    ok = klu_zl_condest (Ap, Az, Symbolic, Numeric, &Common) ;                        /* complex */
+\end{verbatim}
+}
+
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_rcond}: cheap reciprocal condition number estimation}
+%-------------------------------------------------------------------------------
+
+This function returns the smallest diagonal entry of {\tt U} divided by the
+largest, which is a very crude estimate of the reciprocal of the condition
+number of the matrix {\tt A}.  It is very cheap to compute, however.
+In MATLAB notation, {\tt rcond = min(abs(diag(U))) / max(abs(diag(U)))}.
+If the matrix is singular, {\tt rcond} will be zero.  The result is returned
+in {\tt Common.rcond}.
+
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_rcond (Symbolic, Numeric, &Common) ;                                     /* real */
+    ok = klu_z_rcond (Symbolic, Numeric, &Common) ;                                   /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_rcond (Symbolic, Numeric, &Common) ;                                   /* real */
+    ok = klu_zl_rcond (Symbolic, Numeric, &Common) ;                                  /* complex */
+\end{verbatim}
+}
+
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_scale}: scale and check a sparse matrix}
+%-------------------------------------------------------------------------------
+
+This function computes the row scaling factors of a matrix and checks to see if
+it is a valid sparse matrix.  It can perform two kinds of scaling, computing
+either the largest magnitude in each row, or the sum of the magnitudes of the
+entries each row.  KLU calls this function itself, depending upon the {\tt
+Common.scale} parameter, where {\tt scale < 0} means no scaling, {\tt scale=1}
+means the sum, and {\tt scale=2} means the maximum.  That is, in MATLAB
+notation, {\tt Rs = sum(abs(A'))} or {\tt Rs = max(abs(A'))}.  KLU then divides
+each row of {\tt A} by its corresponding scale factor.  The function returns 0
+if the matrix is invalid, or 1 otherwise.  A valid sparse matrix must meet the
+following conditions:
+
+\begin{enumerate}
+\item {\tt n > 0}.  Note that KLU does not handle empty (0-by-0) matrices.
+\item {\tt Ap}, {\tt Ai}, and {\tt Ax} ({\tt Az} for the complex case) must not be NULL.
+\item {\tt Ap[0]=0}, and {\tt Ap [j] <= Ap [j+1]} for all {\tt j} in the range 0 to {\tt n-1}.
+\item The row indices in each column, {\tt Ai [Ap [j] ... Ap [j+1]-1]}, must be in
+the range 0 to {\tt n-1}, and no duplicates can appear.  If the workspace {\tt W} is
+NULL on input, the check for duplicate entries is skipped.
+\end{enumerate}
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int scale, ok, n, Ap [n+1], Ai [nz], W [n] ;
+    double Ax [nz], Az [2*nz], Rs [n] ;
+    klu_common Common ;
+    ok = klu_scale (scale, n, Ap, Ai, Ax, Symbolic, Numeric, &Common) ;               /* real */
+    ok = klu_z_scale (scale, n, Ap, Ai, Az, Symbolic, Numeric, &Common) ;             /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long scale, ok, n, Ap [n+1], Ai [nz], W [n] ;
+    double Ax [nz], Az [2*nz], Rs [n] ;
+    klu_l_common Common ;
+    ok = klu_l_scale (scale, n, Ap, Ai, Ax, Symbolic, Numeric, &Common) ;             /* real */
+    ok = klu_zl_scale (scale, n, Ap, Ai, Az, Symbolic, Numeric, &Common) ;            /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_extract}: extract the LU factorization}
+%-------------------------------------------------------------------------------
+
+This function extracts the LU factorization into a set of data structures
+suitable for passing back to MATLAB, with matrices in conventional
+compressed-column form.  The {\tt klu\_sort} function should be called first if
+the row indices should be returned sorted.  The factorization is returned in
+caller-provided arrays; if any of them are NULL, that part of the factorization
+is not extracted (this is not an error).  Returns 1 if successful, 0 otherwise.
+
+The sizes of {\tt Li}, {\tt Lx}, and {\tt Lz} are {\tt Numeric->lnz},
+{\tt Ui}, {\tt Ux}, and {\tt Uz} are of size {\tt Numeric->unz}, and
+{\tt Fi}, {\tt Fx}, and {\tt Fz} are of size {\tt Numeric->nzoff}.
+Note that in the complex versions, the real and imaginary parts are returned
+in separate arrays, to be compatible with how MATLAB stores complex matrices.
+
+This function is not required to solve a linear system with KLU.  KLU does not
+itself make use of the extracted LU factorization returned by this function.
+It is only provided to simplify the MATLAB interface to KLU, and it may be of
+use to the end user who wishes to examine the contents of the LU factors.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    int ok, Lp [n+1], Li [lnz], Up [n+1], Ui [unz], Fp [n+1], Fi [nzoff], P [n], Q [n], R [n] ;
+    double Lx [lnz], Lz [lnz], Ux [unz], Uz [unz], Fx [nzoff], Fz [nzoff], Rs [n] ;
+    klu_symbolic *Symbolic ;
+    klu_numeric *Numeric ;
+    klu_common Common ;
+    ok = klu_extract (Numeric, Symbolic,
+        Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, &Common) ;                   /* real */
+    ok = klu_z_extract (Numeric, Symbolic,
+        Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, &Common) ;       /* complex */
+
+
+    #include "klu.h"
+    SuiteSparse_long ok, Lp [n+1], Li [lnz], Up [n+1], Ui [unz], Fp [n+1],
+        Fi [nzoff], P [n], Q [n], R [n] ;
+    double Lx [lnz], Lz [lnz], Ux [unz], Uz [unz], Fx [nzoff], Fz [nzoff], Rs [n] ;
+    klu_l_symbolic *Symbolic ;
+    klu_l_numeric *Numeric ;
+    klu_l_common Common ;
+    ok = klu_l_extract (Numeric, Symbolic,
+        Lp, Li, Lx, Up, Ui, Ux, Fp, Fi, Fx, P, Q, Rs, R, &Common) ;                   /* real */
+    ok = klu_zl_extract (Numeric, Symbolic,
+        Lp, Li, Lx, Lz, Up, Ui, Ux, Uz, Fp, Fi, Fx, Fz, P, Q, Rs, R, &Common) ;       /* complex */
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt klu\_malloc}, {\tt klu\_free}, {\tt klu\_realloc}:
+memory management}
+%-------------------------------------------------------------------------------
+
+KLU uses a set of wrapper routines for {\tt malloc}, {\tt free}, and {\tt
+realloc}.  By default, these wrapper routines call the ANSI C versions of these
+functions.  However, pointers to functions in {\tt Common} can be modified
+after calling {\tt klu\_defaults} to allow the use of other memory management
+functions (such as the MATLAB {\tt mxMalloc}, {\tt mxFree}, and {\tt
+mxRealloc}.  These wrapper functions keep track of the current and peak memory
+usage of KLU.  They can be called by the user.
+
+{\tt klu\_malloc} is essentially the same as {\tt p = malloc (n * sizeof
+(size))}, {\tt klu\_free} is essentially the same as {\tt free(p)} except that
+{\tt klu\_free} returns NULL which can then be assigned to {\tt p}.  {\tt
+klu\_realloc} is similar to {\tt realloc}, except that if the reallocation
+fails, {\tt p} is returned unchanged.  Failure conditions are returned in {\tt
+Common.status}.
+
+{\footnotesize
+\begin{verbatim}
+    #include "klu.h"
+    size_t n, nnew, nold, size ;
+    void *p ;
+    klu_common Common ;
+    p = klu_malloc (n, size, &Common) ;
+    p = klu_free (p, n, size, &Common) ;
+    p = klu_realloc (nnew, nold, size, p, &Common) ;
+
+
+    #include "klu.h"
+    size_t n, nnew, nold, size ;
+    void *p ;
+    klu_l_common Common ;
+    p = klu_l_malloc (n, size, &Common) ;
+    p = klu_l_free (p, n, size, &Common) ;
+    p = klu_l_realloc (nnew, nold, size, p, &Common) ;
+    \end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt btf\_maxtrans}: maximum transversal}
+%-------------------------------------------------------------------------------
+
+The BTF package includes three user-callable functions (each with {\tt int}
+and {\tt SuiteSparse\_long} versions).  They do not need to be called directly by an
+application that uses KLU.  KLU will call these functions to perform the
+permutation into upper block triangular form.
+
+The {\tt btf\_maxtrans} function finds a column permutation {\tt Q} that gives
+{\tt A*Q} a zero-free diagonal, if one exists.  If row {\tt i} is matched to
+column {\tt j}, then {\tt Match[i]=j}.  If the matrix is structurally singular,
+there will be some unmatched rows.  If row {\tt i} is unmatched, then {\tt
+Match[i]=-1}.  If the matrix is square and structurally non-singular, then {\tt
+Q=Match} is the column permutation.  The {\tt btf\_maxtrans} function can
+accept as input a rectangular matrix; it operates on the bipartite graph of
+{\tt A}.  It returns the number of columns matched.  Unlike the KLU
+user-callable functions, the BTF functions do not check its inputs at all; a
+segmentation fault will occur if any input pointers are NULL, for example.
+
+The function can require up to $O$({\tt n*nnz(A)}) time (excluding the {\em
+cheap match} phase, which takes another $O$({\tt nnz(A)}) time.  If {\tt
+maxwork > 0} on input, the work is limited to $O$({\tt maxwork*nnz(A)})
+(excluding the cheap match), but the maximum transversal might not be found if
+the limit is reached.
+
+The {\tt Work} array is workspace required by the methods; its contents
+are undefined on input and output.
+
+{\footnotesize
+\begin{verbatim}
+    int nrow, ncol, Ap [ncol+1], Ai [nz], Match [nrow], Work [5*ncol], nmatch ;
+    double maxwork, work ;
+    nmatch = btf_maxtrans (nrow, ncol, Ap, Ai, maxwork, &work, Match, Work) ;
+
+
+    SuiteSparse_long nrow, ncol, Ap [ncol+1], Ai [nz], Match [nrow], Work [5*ncol], nmatch ;
+    double maxwork, work ;
+    nmatch = btf_l_maxtrans (nrow, ncol, Ap, Ai, maxwork, &work, Match, Work) ;
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt btf\_strongcomp}: strongly connected components}
+%-------------------------------------------------------------------------------
+
+The {\tt btf\_strongcomp} function finds the strongly connected components of a
+directed graph, returning a symmetric permutation {\tt P}.  The matrix {\tt A}
+must be square.  The diagonal of {\tt A} (or {\tt A*Q} if a column permutation
+is given on input) is ignored.  If {\tt Q} is NULL on input, the matrix
+{\tt P*A*P'} is in upper block triangular form.  Otherwise, {\tt Q} is modified
+on output so that {\tt P*A*Q} is in upper block triangular form.  The vector
+{\tt R} gives the block boundaries, where the {\tt k}th block consists of
+rows and columns {\tt R[k]} through {\tt R[k+1]-1} in the permuted matrix.
+The function returns the number of strongly connected components found
+(the diagonal blocks in the block triangular form).
+
+{\footnotesize
+\begin{verbatim}
+    int n, Ap [n+1], Ai [nz], Q [n], P [n], R [n+1], Work [4*n], ncomp ;
+    ncomp = btf_strongcomp (n, Ap, Ai, Q, P, R, Work) ;
+
+
+    SuiteSparse_long n, Ap [n+1], Ai [nz], Q [n], P [n], R [n+1], Work [4*n], ncomp ;
+    ncomp = btf_l_strongcomp (n, Ap, Ai, Q, P, R, Work) ;
+\end{verbatim}
+}
+
+%-------------------------------------------------------------------------------
+\subsection{{\tt btf\_order}: permutation to block triangular form}
+%-------------------------------------------------------------------------------
+
+
+The {\tt btf\_order} function combines the above two functions, first finding a
+maximum transversal and then permuting the resulting matrix into upper block
+triangular form.  Unlike {\tt dmperm} in MATLAB, it always reveals the maximum
+matching along the diagonal, even if the matrix is structurally singular.
+
+On output, {\tt P} and {\tt Q} are the row and column permutations, where
+{\tt i = P[k]} if row {\tt i} of {\tt A} is the {\tt k}th row of {\tt P*A*Q},
+and {\tt j = BTF\_UNFLIP(Q[k])} if column {\tt j} of {\tt A} is the {\tt k}th
+column of {\tt P*A*Q}.  If {\tt Q[k] < 0}, then the {\tt (k,k)}th entry in
+{\tt P*A*Q} is structurally zero.  The vector {\tt R}, and the return value,
+are the same as {\tt btf\_strongcomp}.
+
+{\footnotesize
+\begin{verbatim}
+    int n, Ap [n+1], Ai [nz], P [n], Q [n], R [n+1], nfound, Work [5*n], ncomp, nfound ;
+    double maxwork, work ;
+    ncomp = btf_order (n, Ap, Ai, maxwork, &work, P, Q, R, &nfound, Work) ;
+
+
+    SuiteSparse_long n, Ap [n+1], Ai [nz], P [n], Q [n], R [n+1], nfound, Work [5*n], ncomp, nfound ;
+    double maxwork, work ;
+    ncomp = btf_l_order (n, Ap, Ai, maxwork, &work, P, Q, R, &nfound, Work) ;
+\end{verbatim}
+}
+
+%------------------------------------------------------------------------------
+\subsection{Sample C programs that use KLU}
+%------------------------------------------------------------------------------
+
+Here is a simple main program, {\tt klu\_simple.c}, that illustrates the basic
+usage of KLU.  It uses KLU, and indirectly makes use of BTF and AMD.  COLAMD is
+required to compile the demo, but it is not called by this example.  It uses
+statically defined global variables for the sparse matrix {\tt A}, which would
+not be typical of a complete application.  It just makes for a simpler example.
+
+{\footnotesize
+\input{klu_simple_c.tex}
+}
+
+The {\tt Ap}, {\tt Ai}, and {\tt Ax} arrays represent the matrix
+\[
+A = \left[
+\begin{array}{ccccc}
+ 2 &  3 &  0 &  0 &  0 \\
+ 3 &  0 &  4 &  0 &  6 \\
+ 0 & -1 & -3 &  2 &  0 \\
+ 0 &  0 &  1 &  0 &  0 \\
+ 0 &  4 &  2 &  0 &  1 \\
+\end{array}
+\right].
+\]
+The solution to $Ax=b$ is $x = [1 \, 2 \, 3 \, 4 \, 5]^T$.  The program
+uses default control settings (no scaling, permutation to block triangular
+form, and the AMD ordering).  It ignores the error codes in the return values
+and {\tt Common.status}.
+
+The block triangular form found by {\tt btf\_order} for this matrix is
+given below
+\[
+PAQ = \left[
+\begin{array}{c|ccc|c}
+2 & 0 & 0 & -1 & -3 \\
+\hline
+  & 2 & 0 & 3 & 0 \\
+  & 3 & 6 & 0 & 4 \\
+  & 0 & 1 & 4 & 1 \\
+\hline
+  &   &   &   & 1 \\
+\end{array}
+\right].
+\]
+This ordering is not modified by the AMD ordering because the 3-by-3 matrix
+$A_{22} + A_{22}^T$ happens to be a dense matrix.  No partial pivoting happens
+to occur during LU factorization; all pivots are selected along the diagonal of
+each block.  The matrix contains two singletons, which are the original entries
+$a_{34}=2$ and $a_{43}=1$, and one 3-by-3 diagonal block (in which a single
+fill-in entry occurs during factorization: the $u_{23}$ entry of this 3-by-3
+matrix).
+
+For a more complete program that uses KLU, see {\tt KLU/Demo/kludemo.c} for an
+{\tt int} version, and {\tt KLU/Demo/kluldemo.c} for a version that uses {\tt
+SuiteSparse\_long} instead.  The top-level main routine uses CHOLMOD to read in a
+compressed-column sparse matrix from a Matrix Market file, because KLU does not
+include such a function.  Otherwise, no CHOLMOD functions are used.  Unlike
+{\tt klu\_simple.c}, CHOLMOD is required to run the {\tt kludemo.c} and {\tt
+kluldemo.c} programs.
+
+%------------------------------------------------------------------------------
+\section{Installation}
+\label{Install}
+%------------------------------------------------------------------------------
+
+Installation of the C-callable interface requires the {\tt make} utility, in
+Linux/Unix.  Alternatively, you can use the Cygwin {\tt make} in Windows.
+The MATLAB installation in any platform, including Windows is simple; just
+type {\tt klu\_install} to compile and install KLU, BTF, AMD, and COLAMD.
+
+For {\tt make}, system-dependent configurations are in the {\tt
+../SuiteSparse\_config/SuiteSparse\_config.mk} file.
+You can edit that file to customize the
+compilation, but it now automatically detecs your system (Linux, Mac, etc).
+So it's not likely that you will need to edit that file.
+
+To compile and install the C-callable KLU, BTF, AMD, and COLAMD libraries, go
+to the {\tt KLU} directory and type {\tt make}.  The KLU and BTF libraries are
+placed in {\tt KLU/Lib/libklu.*} and {\tt BTF/Lib/libbtf.*}.
+Two KLU demo
+programs will be compiled and tested in the {\tt KLU/Demo} directory.  You can
+compare the output of {\tt make} with the results in the KLU distribution, {\tt
+kludemo.out}.
+
+Typing {\tt make clean} will remove all but the final compiled libraries and
+demo programs.  Typing {\tt make purge} or {\tt make distclean} removes all
+files not in the original distribution.  If you compile KLU or BTF and then
+later change the {\tt ../SuiteSparse\_config/SuiteSparse\_config.mk}
+file then you should type {\tt
+make purge} and then {\tt make} to recompile.
+
+When you compile your program that uses the C-callable KLU library, you need to
+add the {\tt KLU/Lib/libklu.*}, {\tt BTF/Lib/libbtf.*}, {\tt AMD/Lib/libamd.*},
+and {\tt COLAMD/Lib/libcolamd.*} libraries, and you need to tell your compiler to
+look in the {\tt KLU/Include} and {\tt BTF/Include} directory for include
+files.
+Alternatively, do {\tt make install}, and KLU will be installed in
+/usr/local/lib and /usr/local/include, and documentation is placed in
+/usr/local/doc.  These installation locations can be changed;
+see {\tt SuiteSparse/README.txt} for details.
+
+If all you want to use is the KLU mexFunction in MATLAB, you can skip the use
+of the {\tt make} command entirely.  Simply type {\tt klu\_install} in the
+MATLAB command window while in the {\tt KLU/MATLAB} directory.  This works on
+any system with MATLAB, including Windows.
+
+%------------------------------------------------------------------------------
+\newpage
+\section{The KLU routines}
+\label{klu_include}
+%------------------------------------------------------------------------------
+
+The file {\tt KLU/Include/klu.h} listed below describes each user-callable
+routine in the C version of KLU, and gives details on their use.
+
+{\footnotesize
+\input{klu_h.tex}
+}
+
+%------------------------------------------------------------------------------
+\newpage
+\section{The BTF routines}
+\label{btf_include}
+%------------------------------------------------------------------------------
+
+The file {\tt BTF/Include/btf.h} listed below describes each user-callable
+routine in the C version of BTF, and gives details on their use.
+
+{\footnotesize
+\input{btf_h.tex}
+}
+
+%------------------------------------------------------------------------------
+\newpage
+% References
+%------------------------------------------------------------------------------
+
+\bibliographystyle{plain}
+\bibliography{KLU_UserGuide}
+
+\end{document}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/License.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..82113cabc562a4d8553ae89caea6d9a9f133bae8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/License.txt
@@ -0,0 +1,20 @@
+KLU, Copyright (C) 2004-2013, University of Florida
+by Timothy A. Davis and Ekanathan Palamadai.
+KLU is also available under other licenses; contact authors for details.
+http://www.suitesparse.com
+
+--------------------------------------------------------------------------------
+
+KLU is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+KLU is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this Module; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/lesser.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/lesser.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8add30ad590a65db7e5914f5417eac39a64402a3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Doc/lesser.txt
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Contents.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..ee6c1802db94f9a459cde9802a63d78a66b383ff
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Contents.m
@@ -0,0 +1,16 @@
+% KLU:  a "Clark Kent" LU factorization algorithm
+%
+%   klu         - sparse left-looking LU factorization, using a block triangular form.
+%   klu_install - compiles and installs the KLU, BTF, AMD, and COLAMD mexFunctions
+%   klu_demo    - KLU demo
+%   klu_make    - compiles the KLU mexFunctions
+%
+% Example:
+%   
+%   LU = klu (A) ;
+%   x = klu (A, '\', b) ;
+%   x = klu (LU, '\', b) ;
+%
+% Copyright 2004-2009, Univ. of Florida
+% KLU Version 1.0.
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/klu_test.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/klu_test.m
new file mode 100644
index 0000000000000000000000000000000000000000..f6f0ceb9ba532b54b2290d5bd7a401f6d4d2ee8b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/klu_test.m
@@ -0,0 +1,18 @@
+function klu_test (nmat)
+%klu_test KLU test
+% Example:
+%   klu_test
+%
+% See also klu
+
+% Copyright 2004-2012, University of Florida
+
+if (nargin < 1)
+    nmat = 200 ;
+end
+
+test1 (nmat) ;
+test2 (nmat) ;
+test3 ;
+test4 (nmat) ;
+test5  ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test1.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test1.m
new file mode 100644
index 0000000000000000000000000000000000000000..8c8e493a23b850c5439ca81422d0b759c3a820ba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test1.m
@@ -0,0 +1,114 @@
+function test1 (nmat)
+%test1: KLU test
+% Example:
+%   test1
+%
+% See also klu
+
+% Copyright 2004-2012, University of Florida
+
+clear functions
+% rand ('state', 0) ;
+
+index = UFget ;
+f = find (index.nrows == index.ncols & index.isReal) ;
+[ignore i] = sort (index.nnz (f)) ;                                         %#ok
+f = f (i) ;
+
+h = waitbar (0, 'KLU test 1 of 5') ;
+
+if (nargin < 1)
+    nmat = 500 ;
+end
+nmat = min (nmat, length (f)) ;
+
+% just use the first 100 matrices
+nmat = min (nmat, 100) ;
+
+f = f (1:nmat) ;
+
+% f = 274
+% f = 101       ; % MATLAB condest is poor
+
+nmat = length (f) ;
+
+conds_klu = ones (1,nmat) ;
+conds_matlab = ones (1,nmat) ;
+
+clf
+
+% try
+
+    for k = 1:nmat
+
+        waitbar (k/nmat, h) ;
+
+        i = f (k) ;
+%       try
+            c = -1 ;
+            blocks = 0 ;
+            rho = 0 ;
+            c2 = 0 ;
+            r1 = 0 ;
+            r2 = 0 ;
+            err = 0 ;
+
+            Prob = UFget (i,index) ;
+            A = Prob.A ;
+            c = condest (A) ;
+            fprintf ('condest %8.2e :', c) ;
+            if (c > 1e20)
+                fprintf ('skipped\n') ;
+                continue
+            end
+            % klu (A)
+            % [L,U,p,q,R,F,r,info] = klu (A) ;
+
+            [LU, info, c2] = klu (A) ;
+
+            L = LU.L ;
+            U = LU.U ;
+            p = LU.p ;
+            q = LU.q ;
+            R = LU.R ;
+            F = LU.F ;
+            r = LU.r ;
+            blocks = length (r) - 1 ;
+
+            n = size (A,1) ;
+            b = rand (n,1) ;
+            x = klu (LU,'\',b) ;
+            err = norm (A*x-b,1) / norm (A,1) ;
+
+            % info
+            rho = lu_normest (R\A(p,q) - F, L, U) ;
+            r1 = info.rcond ;
+            r2 = full (min (abs (diag (U))) / max (abs (diag (U)))) ;
+
+            if (r1 ~= r2)
+                fprintf ('!\n') ;
+                pause
+            end
+
+            conds_klu (k) = c2 ;
+            conds_matlab (k) = c ;
+
+%       catch me
+%           disp (me.message) ;
+%       end
+
+        fprintf (...
+        'blocks %6d err %8.2e %8.2e rcond %8.2e %8.2e err %8.2e\n', ...
+        blocks, rho, c2, r1, r2, err) ;
+
+    end
+
+    k = nmat ;
+    plot (1:k, log10 (conds_klu (1:k) ./ conds_matlab (1:k)), 'o') ;
+    drawnow
+
+% catch me
+%     disp (me.message) ;
+% end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test2.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test2.m
new file mode 100644
index 0000000000000000000000000000000000000000..aad51228fe5790c898f17785bc20e544aac87692
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test2.m
@@ -0,0 +1,173 @@
+function test2 (nmat)
+%test2: KLU test
+% Example:
+%   test2
+% See also klu
+
+% Copyright 2004-2012, University of Florida
+
+clear functions
+% rand ('state', 0) ;
+% warning ('off', 'MATLAB:singularMatrix') ;
+% warning ('off', 'MATLAB:nearlySingularMatrix') ;
+% warning ('off', 'MATLAB:divideByZero') ;
+
+index = UFget ;
+f = find (index.nrows == index.ncols) ;
+[ignore i] = sort (index.nnz (f)) ;                                         %#ok
+f = f (i) ;
+
+if (nargin < 1)
+    nmat = 500 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+if (~isempty (strfind (computer, '64')))
+    is64 = 1 ;
+else
+    is64 = 0 ;
+end
+
+Tklu = 1e-6 * ones (2*nmat,1) ;
+Tmatlab = zeros (2*nmat,1) ;
+Tcsparse = zeros (2*nmat,1) ;
+LUnz = zeros (2*nmat, 1) ;
+k = 0 ;
+
+h = waitbar (0, 'KLU test 2 of 5') ;
+
+clf
+
+% try
+
+    for kk = 1:nmat
+
+        Prob = UFget (f (kk), index) ;
+
+        waitbar (kk/nmat, h) ;
+
+        disp (Prob) ;
+        if (isfield (Prob, 'kind'))
+            if (~isempty (strfind (Prob.kind, 'subsequent')))
+                fprintf ('skip ...\n') ;
+                continue
+            end
+        end
+        A = Prob.A ;
+
+        for do_complex = 0:1
+            
+            k = k + 1 ;
+            if (do_complex)
+                A = sprand (A) + 1i * sprand (A) ;
+            end
+
+            try
+                [L,U,p,q] = lu (A, 'vector') ;
+            catch                                                           %#ok
+                % older version of MATLAB, which doesn't have 'vector' option
+                [L,U,P,Q] = lu (A) ;
+                [p ignore1 ignore2] = find (P') ;                           %#ok
+                [q ignore1 ignore2] = find (Q) ;                            %#ok
+                clear ignore1 ignore2 P Q
+            end
+
+            LU.L = L ;
+            LU.U = U ;
+            if (is64)
+                LU.p = int64 (p) ;
+                LU.q = int64 (q) ;
+            else
+                LU.p = int32 (p) ;
+                LU.q = int32 (q) ;
+            end
+            LUnz (k) = nnz (L) + nnz (U) ;
+
+            n = size (A,1) ;
+
+            do_klu = (nnz (diag (U)) == n) ;
+            if (do_klu)
+
+                fprintf ('klu...\n') ;
+                err = 0 ;
+                erc = 0 ;
+                er2 = 0 ;
+                for nrhs = 10:-1:1
+
+                    b = rand (n,nrhs) ;
+
+                    tic ;
+                    x = klu (LU,'\',b) ;
+                    Tklu (k) = max (1e-6, toc) ;
+
+                    tic ;
+                    y = U \ (L \ b (p,:)) ;
+                    y (q,:) = y ;
+                    Tmatlab (k) = max (1e-6, toc) ;
+
+                    if (nrhs == 1 & isreal (U) & isreal (L) & isreal (b))   %#ok
+                        tic ;
+                        z = cs_usolve (U, cs_lsolve (L, b (p))) ;
+                        z (q) = z ;
+                        Tcsparse (k) = max (1e-6, toc) ;
+                        erc = norm (A*z-b,1) / norm (A,1) ;
+                    end
+
+                    err = max (err, norm (A*x-b,1) / norm (A,1)) ;
+                    er2 = max (er2, norm (A*y-b,1) / norm (A,1)) ;
+                    if (err > 100*er2)
+                        fprintf ('error %g %g\n', err, er2) ;
+                        error ('?') ;
+                    end
+                end
+
+                fprintf ('klu... with randomized scaling for L\n') ;
+                er3 = 0 ;
+                er4 = 0 ;
+                D = spdiags (rand (n,1), 0, n, n) ;
+                LU.L = D * L ;
+                A2 = D * A (p,q) ;
+                if (is64)
+                    LU.p = int64 (1:n) ;
+                    LU.q = int64 (1:n) ;
+                else
+                    LU.p = int32 (1:n) ;
+                    LU.q = int32 (1:n) ;
+                end
+                for nrhs = 1:10
+                    b = rand (n,nrhs) ;
+                    x = klu (LU,'\',b) ;
+                    y = U \ (LU.L \ b) ;
+                    er3 = max (er3, norm (A2*x-b,1) / norm (A,1)) ;
+                    er4 = max (er4, norm (A2*y-b,1) / norm (A,1)) ;
+                    if (er3 > 1e3*er4)
+                        fprintf ('error %g %g\n', er3, er4) ;
+                        error ('?') ;
+                    end
+                end
+
+
+            else
+                err = Inf ;
+                er2 = Inf ;
+                erc = Inf ;
+            end
+
+            lumax = max (LUnz (1:k)) ;
+            loglog (...
+                LUnz (1:k), Tmatlab (1:k) ./ Tklu (1:k), 'o', ...
+                LUnz (1:k), Tcsparse (1:k) ./ Tklu (1:k), 'x', ...
+                [20 lumax], [1 1], 'r-') ;
+            axis ([20 lumax .1 20]) ;
+            drawnow
+
+            fprintf ('err %g %g %g\n', err, er2, erc) ;
+        end
+    end
+
+% catch me
+%     disp (me.message) ;
+% end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test3.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test3.m
new file mode 100644
index 0000000000000000000000000000000000000000..f0a48212f640d45bc310fbc64ede43d2ec4f9970
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test3.m
@@ -0,0 +1,61 @@
+function test3
+%test3: KLU test
+% Example:
+%   test3
+% See also klu
+
+% Copyright 2004-2012, University of Florida
+
+h = waitbar (1/12, 'KLU test 3 of 5') ;
+
+% rand ('state', 0) ;
+
+load west0479
+A = west0479 ;
+% A = sparse (rand (4)) ;
+% A (3:4, 1:2) = 0 ;
+
+n = size (A,1) ;
+b = rand (n,1) ;
+spparms ('spumoni',2)
+x = A\b ;
+spparms ('spumoni',0)
+fprintf ('MATLAB resid %g\n', norm (A*x-b,1)) ;
+
+[LU,info,cond_estimate] = klu (A) ;
+fprintf ('\nLU = \n') ; disp (LU) ;
+fprintf ('\ninfo = \n') ; disp (info) ;
+fprintf ('KLU condest    %g\n', cond_estimate) ;
+matlab_condest = condest (A) ;
+matlab_cond = cond (full (A)) ;
+fprintf ('MATLAB condest %g cond %g\n', matlab_condest, matlab_cond) ;
+
+for nrhs = 1:10
+    waitbar (nrhs/12, h) ;
+    b = rand (n,nrhs) ;
+    x = klu (LU,'\',b) ;
+    fprintf ('nrhs: %d resid: %g\n', ...
+        nrhs, norm (A*x-b,1) / norm (A,1)) ;
+end
+
+[x,info,cond_estimate] = klu (A, '\', b) ;                                  %#ok
+fprintf ('\ninfo = \n') ; disp (info) ;
+fprintf ('KLU cond_estimate %g\n', cond_estimate) ;
+
+waitbar (11/12, h) ;
+
+[x,info] = klu (A, '\', b, struct ('ordering',1)) ;                         %#ok
+fprintf ('\ninfo = \n') ; disp (info) ;
+[x,info,cond_estimate] = klu (A, '\', b, struct ('ordering',2)) ;           %#ok
+fprintf ('\ninfo = \n') ; disp (info) ;
+try
+    [x,info,cond_estimate] = klu (A, '\', b, struct ('ordering',3)) ;       %#ok
+    fprintf ('\ninfo = \n') ; disp (info) ;
+    [x,info,cond_estimate] = klu (A, '\', b, struct ('ordering',4)) ;       %#ok
+    fprintf ('\ninfo = \n') ; disp (info) ;
+catch me
+    disp (me.message) ;
+    fprintf ('test with CHOLMOD skipped (CHOLMOD or METIS not installed)\n') ;
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test4.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test4.m
new file mode 100644
index 0000000000000000000000000000000000000000..5534de205194a32c729f2f2fb671e546e87cc51c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test4.m
@@ -0,0 +1,213 @@
+function test4 (nmat)
+%test4: KLU test
+% Example:
+%   test4
+% See also klu
+
+% Copyright 2004-2012, University of Florida
+
+% rand ('state', 0) ;
+% warning ('off', 'MATLAB:singularMatrix') ;
+% warning ('off', 'MATLAB:nearlySingularMatrix') ;
+% warning ('off', 'KLU:rcond') ;
+% warning ('off', 'MATLAB:Axes:NegativeDataInLogAxis') ;
+
+index = UFget ;
+f = find (index.nrows == index.ncols & index.isReal & index.amd_lnz > 0) ;
+[ignore i] = sort (index.amd_lnz (f)) ;                                     %#ok
+f = f (i) ;
+% f = f (1:100) ;
+
+if (nargin < 1)
+    nmat = 500 ;
+end
+nmat = min (nmat, length (f)) ;
+f = f (1:nmat) ;
+
+if (1)
+    Tlu = -ones (nmat,1) ;
+    Tklu = -ones (nmat,1) ;
+    Tklu2 = -ones (nmat,1) ;
+    LUnz = -ones (nmat,1) ;
+    k = 0 ;
+end
+
+if (~isempty (strfind (computer, '64')))
+    is64 = 1 ;
+else
+    is64 = 0 ;
+end
+
+% 589: Sieber
+
+h = waitbar (0, 'KLU test 4 of 5') ;
+
+clf
+
+% try
+
+    for kk = 1:nmat
+
+        Prob = UFget (f (kk), index) ;
+
+        waitbar (kk/nmat, h) ;
+
+        disp (Prob) ;
+        if (isfield (Prob, 'kind'))
+            if (~isempty (strfind (Prob.kind, 'subsequent')))
+                fprintf ('skip ...\n') ;
+                continue
+            end
+            if (~isempty (strfind (Prob.kind, 'random')))
+                fprintf ('skip ...\n') ;
+                continue
+            end
+        end
+        k = k + 1 ;
+        A = Prob.A ;
+        n = size (A,1) ;
+        err1 = 0 ;
+        err2 = 0 ;
+        err4 = 0 ;
+        terr1 = 0 ;
+        terr2 = 0 ;
+        terr4 = 0 ;
+
+
+        for do_imag = 0:1
+            if (do_imag)
+                A = sprand (A) + 1i * sprand (A) ;
+            end
+
+            % compare with UMFPACK
+            try
+                tic
+                [L,U,p,q,R1] = lu (A, 'vector') ;
+                t1 = max (1e-6, toc) ;
+            catch                                                           %#ok
+                % older version of MATLAB, which doesn't have 'vector' option
+                tic
+                [L,U,P,Q] = lu (A) ;
+                t1 = max (1e-6, toc) ;
+                [p ignore1 ignore2] = find (P') ;                           %#ok
+                [q ignore1 ignore2] = find (Q) ;                            %#ok
+                clear ignore1 ignore2 P Q
+                R1 = speye (n) ;
+            end
+
+            if (Tlu (k) == -1)
+                Tlu (k) = t1 ;
+                LUnz (k) = nnz (L) + nnz (U) ;
+            end
+
+            % note that the scaling R1 and R2 are different with KLU and UMFPACK
+            % UMFPACK:  L*U-P*(R1\A)*Q
+            % KLU:      L*U-R2\(P*A*Q)
+            %
+            % R1 and R2 are related, via P, where R2 = P*R*P', or equivalently
+            % R2 = R1 (p,p).
+
+            rcond = min (abs (diag (U))) / max (abs (diag (U))) ;
+            if (rcond < 1e-15)
+                fprintf ('skip...\n') ;
+                break ;
+            end
+
+            F.L = L ;
+            F.U = U ;
+            if (is64)
+                F.p = int64(p) ;
+                F.q = int64(q) ;
+            else
+                F.p = int32(p) ;
+                F.q = int32(q) ;
+            end
+
+            F.R = R1(p,p) ;
+            b = rand (n,1) ;
+            x = klu (F, '\', b) ;
+            y = klu (b', '/', F) ;
+
+            fprintf ('solve with klu %g\n', ...
+                norm (A*x-b,1)/norm(A,1)) ;
+            fprintf ('solve with klu %g transpose\n', ...
+                norm (y*A-b',1)/norm(A,1)) ;
+
+
+            for nrhs = 1:10
+                for do_b_imag = 0:1
+                    b = rand (n, nrhs) ;
+                    if (do_b_imag)
+                        b = b + 1i * rand (n, nrhs) ;
+                    end
+
+                    % KLU backslash
+                    tic ;
+                    x = klu (A,'\',b) ;
+                    t2 = max (1e-6, toc) ;
+
+                    % KLU slash
+                    xt = klu (b','/',A) ;
+
+                    % KLU backslash with precomputed LU
+                    tic
+                    LU = klu (A) ;
+                    z = klu (LU,'\',b) ;
+                    t4 = max (1e-6, toc) ;
+
+                    % KLU slash with precomputed LU
+                    zt = klu (b','/',LU) ;
+
+                    % UMFPACK
+                    tic
+                    rb = R1 \ b ;
+                    y = U \ (L \ rb (p,:)) ;
+                    y (q,:) = y ;
+                    t3 = max (1e-6, toc) ;
+
+                    yt = (L' \ (U' \ b (q,:))) ;
+                    yt (p,:) = yt ;
+                    yt = R1 \ yt ;
+                    yt = yt' ;
+
+                    if (Tklu (k) == -1)
+                        Tlu (k) = Tlu (k) + t3 ;
+                        Tklu (k) = t2 ;
+                        Tklu2 (k) = t4 ;
+                    end
+
+                    err1 = max (err1, norm (A*x-b,1) / norm (A,1)) ;
+                    err2 = max (err2, norm (A*y-b,1) / norm (A,1)) ;
+                    err4 = max (err4, norm (A*z-b,1) / norm (A,1)) ;
+
+                    terr1 = max (terr1, norm (xt*A-b',1) / norm (A,1)) ;
+                    terr2 = max (terr2, norm (yt*A-b',1) / norm (A,1)) ;
+                    terr4 = max (terr4, norm (zt*A-b',1) / norm (A,1)) ;
+                end
+            end
+        end
+
+        fprintf ('err %g %g %g\n', err1, err2, err4) ;
+        if (err1 > 1e4*err2 | err4 > 1e4*err2)                              %#ok
+            fprintf ('warning: KLU inaccurate!\n')
+        end
+
+        fprintf ('terr %g %g %g\n', terr1, terr2, terr4) ;
+        if (terr1 > 1e4*terr2 | terr4 > 1e4*terr2)                          %#ok
+            fprintf ('warning: KLU T inaccurate!\n')
+        end
+
+        lunzmax = max (LUnz (1:k)) ;
+        loglog ( ...
+            LUnz (1:k), Tklu (1:k) ./ Tlu (1:k), 'o', ...
+            LUnz (1:k), Tklu2 (1:k) ./ Tlu (1:k), 'x', ...
+            [10 lunzmax], [1 1], 'r-') ;
+        drawnow
+
+    end
+
+% catch me
+%     disp (me.message) ;
+% end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test5.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test5.m
new file mode 100644
index 0000000000000000000000000000000000000000..9457c4c81f03bd2e31c923c8c176cdbea78fc53f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/Test/test5.m
@@ -0,0 +1,174 @@
+function test5
+%test5: KLU test
+% Example:
+%   test5
+%
+% test circuit matrices in the UF sparse matrix collection.
+%
+% See also klu
+
+% Copyright 2004-2012, University of Florida
+
+do_diary = 0 ;
+
+if (do_diary)
+    diary off
+    s = date ;
+    t = clock ;
+    s = sprintf ('diary test5_%s_%d-%d-%d.txt\n', s, t (4), t(5), fix(t(6)));
+    eval (s) ;
+end
+
+% ATandT frequency-domain circuits, exclude these:
+% freq = [ 283     284     285     286      ] ;
+
+% sorted in order of MATLAB 7.3 x=A\b time on storm
+% (AMD Opteron, 64-bit, 8GB mem, 2 cores)
+circ = [
+1195    % Rajat/rajat11 n: 135 nz 665
+1198    % Rajat/rajat14 n: 180 nz 1475
+1189    % Rajat/rajat05 n: 301 nz 1250
+1169    % Sandia/oscil_trans_01 n: 430 nz 1614
+1112    % Sandia/oscil_dcop_01 n: 430 nz 1544
+1346    % Rajat/rajat19 n: 1157 nz 3699
+1199    % Hamrle/Hamrle1 n: 32 nz 98
+1106    % Sandia/fpga_trans_01 n: 1220 nz 7382
+1188    % Rajat/rajat04 n: 1041 nz 8725
+1055    % Sandia/fpga_dcop_01 n: 1220 nz 5892
+1108    % Sandia/init_adder1 n: 1813 nz 11156
+1196    % Rajat/rajat12 n: 1879 nz 12818
+1053    % Sandia/adder_trans_01 n: 1814 nz 14579
+539     % Hamm/add20 n: 2395 nz 13151
+371     % Bomhof/circuit_2 n: 4510 nz 21199
+540     % Hamm/add32 n: 4960 nz 19848
+1186    % Rajat/rajat02 n: 1960 nz 11187
+466     % Grund/meg4 n: 5860 nz 25258
+465     % Grund/meg1 n: 2904 nz 58142
+370     % Bomhof/circuit_1 n: 2624 nz 35823
+1200    % Hamrle/Hamrle2 n: 5952 nz 22162
+1197    % Rajat/rajat13 n: 7598 nz 48762
+1187    % Rajat/rajat03 n: 7602 nz 32653
+372     % Bomhof/circuit_3 n: 12127 nz 48137
+1185    % Rajat/rajat01 n: 6833 nz 43250
+1183    % IBM_Austin/coupled n: 11341 nz 97193
+1376    % Rajat/rajat27 n: 20640 nz 97353
+543     % Hamm/memplus n: 17758 nz 99147
+1109    % Sandia/mult_dcop_01 n: 25187 nz 193276
+1371    % Rajat/rajat22 n: 39899 nz 195429
+1375    % Rajat/rajat26 n: 51032 nz 247528
+1414    % IBM_EDA/ckt11752_tr_0 n: 49702 nz 332807
+541     % Hamm/bcircuit n: 68902 nz 375558
+1413    % IBM_EDA/ckt11752_dc_1 n: 49702 nz 333029
+542     % Hamm/hcircuit n: 105676 nz 513072
+1316    % Rajat/rajat15 n: 37261 nz 443573
+1190    % Rajat/rajat06 n: 10922 nz 46983
+1191    % Rajat/rajat07 n: 14842 nz 63913
+1372    % Rajat/rajat23 n: 110355 nz 555441
+373     % Bomhof/circuit_4 n: 80209 nz 307604
+544     % Hamm/scircuit n: 170998 nz 958936
+1412    % AMD/G2_circuit n: 150102 nz 726674    is this solid state device?
+1415    % Sandia/ASIC_100k n: 99340 nz 940621
+1416    % Sandia/ASIC_100ks n: 99190 nz 578890
+1420    % Sandia/ASIC_680ks n: 682712 nz 1693767
+1192    % Rajat/rajat08 n: 19362 nz 83443
+1193    % Rajat/rajat09 n: 24482 nz 105573
+1323    % IBM_EDA/trans4 n: 116835 nz 749800
+1320    % IBM_EDA/dc1 n: 116835 nz 766396
+1194    % Rajat/rajat10 n: 30202 nz 130303
+1418    % Sandia/ASIC_320ks n: 321671 nz 1316085
+1417    % Sandia/ASIC_320k n: 321821 nz 1931828
+1343    % Rajat/rajat16 n: 94294 nz 476766
+1345    % Rajat/rajat18 n: 94294 nz 479151
+1344    % Rajat/rajat17 n: 94294 nz 479246
+1377    % Rajat/rajat28 n: 87190 nz 606489
+1369    % Rajat/rajat20 n: 86916 nz 604299
+1374    % Rajat/rajat25 n: 87190 nz 606489
+1370    % Rajat/rajat21 n: 411676 nz 1876011
+1419    % Sandia/ASIC_680k n: 682862 nz 2638997
+% these are large, so are skipped for this test:
+% 1396    % Rajat/rajat29 n: 643994 nz 3760246
+% 1201    % Hamrle/Hamrle3 n: 1447360 nz 5514242
+% 1397    % Rajat/rajat30 n: 643994 nz 6175244
+% 1421    % AMD/G3_circuit n: 1585478 nz 7660826
+% 1398    % Rajat/rajat31 n: 4690002 nz 20316253
+% 1373    % Rajat/rajat24 n: 358172 nz 1946979
+]' ;
+
+fprintf ('Running KLU on %d circuits.\n', length (circ)) ;
+
+index = UFget ;
+
+opts_noscale.scale = -1 ;
+opts_sum.scale = 1 ;
+opts_max.scale = 2 ;            % default scaling
+
+h = waitbar (0, 'KLU test 5 of 5') ;
+nmat = length (circ) ;
+
+try
+
+    for kk = 1:nmat
+
+        k = circ (kk) ;
+        Prob = UFget (k, index) ;
+
+        waitbar (kk/nmat, h) ;
+
+        A = Prob.A ;
+        n = size (A,1) ;
+        b = rand (n,1) ;
+        fprintf ('\n%d : %s n: %d nz %d\n', k, Prob.name, n, nnz (A)) ;
+
+        try
+            tic ;
+            x2 = klu (A, '\', b, opts_noscale) ;
+            t2 = toc ;
+            e2 = norm (A*x2-b) ;
+        catch                                                               %#ok
+            t2 = inf ;
+            e2 = inf ;
+        end
+        fprintf ('KLU no scale:  err %8.2e t: %8.4f\n', e2, t2) ;
+
+        try
+            tic ;
+            x4 = klu (A, '\', b, opts_max) ;
+            t4 = toc ;
+            e4 = norm (A*x4-b) ;
+        catch                                                               %#ok
+            t4 = inf ;
+            e4 = inf ;
+        end
+        fprintf ('KLU max scale: err %8.2e t: %8.4f\n', e4, t4) ;
+
+        try
+            tic ;
+            x3 = klu (A, '\', b, opts_sum) ;
+            t3 = toc ;
+            e3 = norm (A*x3-b) ;
+        catch                                                               %#ok
+            t3 = inf ;
+            e3 = inf ;
+        end
+        fprintf ('KLU sum scale: err %8.2e t: %8.4f\n', e3, t3) ;
+
+        tic
+        x1 = A\b ;
+        t1 = toc ;
+        e1 = norm (A*x1-b) ;
+        fprintf ('matlab:        err %8.2e t: %8.4f\n', e1, t1) ;
+
+        fprintf ('                                 speedup %8.2f\n', t1 / t4) ;
+        clear Prob
+
+        if (do_diary)
+            diary off
+            diary on
+        end
+    end
+
+catch me
+    disp (me.message) ;
+end
+
+close (h) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu.m
new file mode 100644
index 0000000000000000000000000000000000000000..73794fd803f38a23018c4443d94e5c134330334d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu.m
@@ -0,0 +1,72 @@
+function [LU_or_x,info,c] = klu (A,operation,b,opts)                        %#ok
+%KLU sparse left-looking LU factorization, using a block triangular form.
+%
+%   Example:
+%   LU = klu (A)            factorizes R\A(p,q) into L*U+F, returning a struct
+%   x = klu (A,'\',b)       x = A\b, using KLU
+%   x = klu (b,'/',A)       x = b/A, using KLU
+%   x = klu (LU,'\',b)      x = A\b, where LU = klu(A)
+%   x = klu (b,'/',LU)      x = b/A, where LU = klu(A)
+%
+%   KLU(A) factorizes a square sparse matrix, L*U+F = R\A(p,q), where L and U
+%   are the factors of the diagonal blocks of the block, F are the entries
+%   above the diagonal blocks.  r corresponds to the 3rd output of dmperm; it
+%   specifies where the block boundaries are.  The kth block consists of
+%   rows/columns r(k) to r(k+1)-1 of A(p,q).
+%
+%   Note that the use of the scale factor R differs between KLU and UMFPACK
+%   (and the LU function, which is based on UMFPACK).  In LU, the factorization
+%   is L*U = P*(R1\A)*Q; in KLU it is L*U+F = R2\(P*A*Q).  R1 and R2 are related
+%   via R2 = P*R1*P', or equivalently R2 = R1(p,p).
+%
+%   The LU output is a struct containing members L, U, p, q, R, F, and r.
+%
+%   opts is an optional input struct which appears as the last input argument.
+%   Entries not present are set to their defaults:
+%
+%                       default
+%       opts.tol        0.001   partial pivoting tolerance; valid range 0 to 1.
+%       opts.btf        1       use block triangular form (BTF) if nonzero
+%       opts.ordering   0       how each block is ordered:
+%                               0: AMD, 1: COLAMD, 2: natural,
+%                               3: CHOLMOD's ordering of (A'*A),
+%                               4: CHOLMOD's ordering of (A+A')
+%       opts.scale      2       1: R = diag(sum(abs(A)')), row-sum
+%                               2: R = diag(max(abs(A)')), max in each row
+%                               otherwise: none (R=I)
+%       opts.maxwork    0       if > 0, limit work in BTF ordering to
+%                               opts.maxwork*nnz(A); no limit if <= 0.
+%
+%       The CHOLMOD ordering is to try AMD (for A+A') or COLAMD (for A'*A)
+%       first.  If the fill-in with AMD or COLAMD is high, METIS is tried (on
+%       A+A' or A'*A), and the best ordering found is selected.  CHOLMOD, METIS,
+%       CAMD, and CCOLAMD are required.  If not available, only ordering options
+%       0, 1, and 2 may be used (AMD and COLAMD are always required by KLU).
+%
+%   Two optional outputs, [LU,info,c] = klu (A) or [x,info,c] = klu (A,'\',b)
+%   provide statistics about the factorization:
+%
+%       info.noffdiag   number of off-diagonal pivots chosen (after preordering)
+%       info.nrealloc   number of memory reallocations of L and U
+%       info.rcond      a very cheap estimate of 1/(condition number)
+%       info.rgrowth    reciprocal pivot growth
+%       info.flops      flop count
+%       info.nblocks    # of blocks in BTF form (1 if not computed)
+%       info.ordering   AMD, COLAMD, natural, cholmod(AA'), cholmod(A+A')
+%       info.scale      scaling (<=0: none, 1: sum, 2: max)
+%       info.lnz        nnz(L), including diagonal
+%       info.unz        nnz(U), including diagonal
+%       info.offnz      nnz(F)
+%       info.tol        pivot tolerance used
+%       info.memory     peak memory usage in bytes
+%       c               the same as MATLAB's condest
+%
+%   info and c are relevant only if the matrix is factorized (LU = klu (A),
+%   x = klu (A,'/',b), or x = klu (b,'/',A) usages).
+%
+%   See also BTF, LU, DMPERM, CONDEST, CHOLMOD, AMD, COLAMD, CAMD, CCOLAMD.
+
+% Copyright 2004-2009, Univ. of Florida
+% http://www.suitesparse.com
+
+error ('klu mexFunction not found') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_demo.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_demo.m
new file mode 100644
index 0000000000000000000000000000000000000000..9c5c9126551121d96fda01c4b07d59ba8eb050a6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_demo.m
@@ -0,0 +1,79 @@
+function klu_demo
+% KLU demo
+%
+% Example:
+%   klu_demo
+%
+% See also klu, btf
+
+% Copyright 2004-2009, Univ. of Florida
+
+load west0479
+A = west0479 ;
+
+n = size (A,1) ;
+b = rand (n,1) ;
+
+clf
+subplot (2,2,1) ;
+spy (A)
+title ('west0479') ;
+
+subplot (2,2,2) ;
+[p, q, r] = btf (A) ;
+drawbtf (A, p, q, r) ;
+title ('BTF form') ;
+
+[x,info,c] = klu (A, '\', b) ;
+matlab_condest = condest (A) ;
+matlab_cond = cond (full (A)) ;
+fprintf ('MATLAB condest: %g KLU condest: %g cond: %g\n', ...
+    matlab_condest, c, matlab_cond) ;
+
+fprintf ('\nKLU with scaling, AMD ordering and condition number estimate:\n') ;
+[LU,info] = klu (A, struct ('ordering',0, 'scale', 1)) ;
+x = klu (LU, '\', b) ;
+resid = norm (A*x-b,1) / norm (A,1) ;
+rgrowth = full (min (max (abs ((LU.R \ A (LU.p,LU.q)) - LU.F)) ./ ...
+    max (abs (LU.U)))) ;
+fprintf ('resid: %g KLU condest: %g rgrowth: %g\n', resid, c, rgrowth) ;
+disp (info) ;
+
+subplot (2,2,3) ;
+spy (LU.L + LU.U + LU.F) ;
+title ('KLU+AMD factors') ;
+
+fprintf ('\nKLU with COLAMD ordering\n') ;
+[LU,info] = klu (A, struct ('ordering',1)) ;
+x = klu (LU, '\', b) ;
+resid = norm (A*x-b,1) / norm (A,1) ;
+fprintf ('resid: %g\n', resid) ;
+disp (info) ;
+
+subplot (2,2,4) ;
+spy (LU.L + LU.U + LU.F) ;
+title ('KLU+COLAMD factors') ;
+
+fprintf ('\nKLU with natural ordering (lots of fillin)\n') ;
+[x,info] = klu (A, '\', b, struct ('ordering',2)) ;
+resid = norm (A*x-b,1) / norm (A,1) ;
+fprintf ('resid: %g\n', resid) ;
+disp (info) ;
+
+try
+
+    fprintf ('\nKLU with CHOLMOD(A''*A) ordering\n') ;
+    [x,info] = klu (A, '\', b, struct ('ordering',3)) ;
+    resid = norm (A*x-b,1) / norm (A,1) ;
+    fprintf ('resid: %g\n', resid) ;
+    disp (info) ;
+
+    fprintf ('\nKLU with CHOLMOD(A+A'') ordering\n') ;
+    [x,info] = klu (A, '\', b, struct ('ordering',4)) ;
+    resid = norm (A*x-b,1) / norm (A,1) ;
+    fprintf ('resid: %g\n', resid) ;
+    disp (info) ;
+
+catch
+    fprintf ('KLU test with CHOLMOD skipped (CHOLMOD not installed)\n') ;
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_install.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_install.m
new file mode 100644
index 0000000000000000000000000000000000000000..fff7521843178a12fc6bdfc0476118b3413c22f1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_install.m
@@ -0,0 +1,56 @@
+function klu_install (metis_path)
+%KLU_INSTALL compiles and installs the KLU, BTF, AMD, and COLAMD mexFunctions
+%
+% Example:
+%   klu_install
+%
+% KLU relies on AMD, COLAMD, and BTF for its ordering options, and can
+% optionally use CHOLMOD, CCOLAMD, CAMD, and METIS as well.  By default,
+% CHOLMOD, CCOLAMD, CAMD, and METIS are compiled and used by KLU.
+%
+% You must type the klu_install command while in the KLU/MATLAB directory.
+%
+% See also klu, btf
+
+% Copyright 2004-2016, Univ. of Florida
+
+if (nargin < 1)
+    metis_path = ['../../metis-5.1.0'] ;
+end
+
+% compile KLU and add to the path
+klu_make (metis_path) ;
+klu_path = pwd ;
+addpath (klu_path)
+
+fprintf ('\nNow compiling the AMD, COLAMD, and BTF mexFunctions:\n') ;
+
+% compile BTF and add to the path
+cd ../../BTF/MATLAB
+btf_make
+btf_path = pwd ;
+addpath (btf_path)
+
+% compile AMD and add to the path
+cd ../../AMD/MATLAB
+amd_make
+amd_path = pwd ;
+addpath (amd_path)
+
+% compile COLAMD and add to the path
+cd ../../COLAMD/MATLAB
+colamd_make
+colamd_path = pwd ;
+addpath (colamd_path)
+
+cd (klu_path)
+
+fprintf ('\nThe following paths have been added.  You may wish to add them\n') ;
+fprintf ('permanently, using the MATLAB pathtool command.\n') ;
+fprintf ('%s\n', klu_path) ;
+fprintf ('%s\n', amd_path) ;
+fprintf ('%s\n', colamd_path) ;
+fprintf ('%s\n', btf_path) ;
+
+fprintf ('\nTo try your new mexFunctions, cut-and-paste this command:\n') ;
+fprintf ('klu_demo, btf_demo, amd_demo, colamd_demo\n') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_make.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_make.m
new file mode 100644
index 0000000000000000000000000000000000000000..72fe8eeae95429acbb458c4e9a57f903fb50d912
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/MATLAB/klu_make.m
@@ -0,0 +1,402 @@
+function klu_make (metis_path)
+%KLU_MAKE compiles the KLU mexFunctions
+%
+% Example:
+%   klu_make
+%
+% KLU relies on AMD, COLAMD, and BTF for its ordering options, and can
+% optionally use CHOLMOD, CCOLAMD, CAMD, and METIS as well.
+%
+% You must type the klu_make command while in the KLU/MATLAB directory.
+%
+% See also klu.
+
+% Copyright 2004-2016, Univ. of Florida
+
+if (nargin < 1)
+    metis_path = '../../metis-5.1.0' ;
+end
+with_cholmod = exist (metis_path, 'dir') ;
+
+details = 0 ;       % if 1, print details of each command
+
+d = '' ;
+if (~isempty (strfind (computer, '64')))
+    % 64-bit MATLAB
+    d = '-largeArrayDims' ;
+end
+
+% MATLAB 8.3.0 now has a -silent option to keep 'mex' from burbling too much
+if (~verLessThan ('matlab', '8.3.0'))
+    d = ['-silent ' d] ;
+end
+
+fprintf ('Compiling KLU ') ;
+kk = 0 ; 
+
+include = '-I. -I../../AMD/Include -I../../COLAMD/Include -I../Include -I../../SuiteSparse_config -I../../BTF/Include' ;
+
+if (with_cholmod)
+    include = [include ' -I../../CCOLAMD/Include -I../../CAMD/Include -I../../CHOLMOD/Include -I../../SuiteSparse_config -I../User'] ;
+    include = [include ' -I' metis_path '/include'] ;
+    include = [include ' -I' metis_path '/GKlib'] ;
+    include = [include ' -I' metis_path '/libmetis'] ;
+end
+
+% do not attempt to compile CHOLMOD with large file support (not needed)
+include = [include ' -DNLARGEFILE'] ;
+
+% fix the METIS 4.0.1 rename.h file
+if (with_cholmod)
+    fprintf ('with CHOLMOD, CAMD, CCOLAMD, and METIS\n') ;
+    include = ['-DNSUPERNODAL -DNMODIFY -DNMATRIXOPS -DNCHECK ' include] ;
+else
+    fprintf ('without CHOLMOD, CAMD, CCOLAMD, and METIS\n') ;
+    include = ['-DNCHOLMOD ' include] ;
+end
+
+suitesparse_src = { '../../SuiteSparse_config/SuiteSparse_config' } ;
+
+amd_src = { ...
+    '../../AMD/Source/amd_1', ...
+    '../../AMD/Source/amd_2', ...
+    '../../AMD/Source/amd_aat', ...
+    '../../AMD/Source/amd_control', ...
+    '../../AMD/Source/amd_defaults', ...
+    '../../AMD/Source/amd_dump', ...
+    '../../AMD/Source/amd_global', ...
+    '../../AMD/Source/amd_info', ...
+    '../../AMD/Source/amd_order', ...
+    '../../AMD/Source/amd_postorder', ...
+    '../../AMD/Source/amd_post_tree', ...
+    '../../AMD/Source/amd_preprocess', ...
+    '../../AMD/Source/amd_valid' } ;
+
+colamd_src = {
+    '../../COLAMD/Source/colamd' } ;
+
+if (with_cholmod)
+
+    camd_src = { ...
+        '../../CAMD/Source/camd_1', ...
+        '../../CAMD/Source/camd_2', ...
+        '../../CAMD/Source/camd_aat', ...
+        '../../CAMD/Source/camd_control', ...
+        '../../CAMD/Source/camd_defaults', ...
+        '../../CAMD/Source/camd_dump', ...
+        '../../CAMD/Source/camd_global', ...
+        '../../CAMD/Source/camd_info', ...
+        '../../CAMD/Source/camd_order', ...
+        '../../CAMD/Source/camd_postorder', ...
+        '../../CAMD/Source/camd_preprocess', ...
+        '../../CAMD/Source/camd_valid' } ;
+
+    ccolamd_src = {
+        '../../CCOLAMD/Source/ccolamd' } ;
+
+    metis_src = {
+        'GKlib/b64', ...
+        'GKlib/blas', ...
+        'GKlib/csr', ...
+        'GKlib/error', ...
+        'GKlib/evaluate', ...
+        'GKlib/fkvkselect', ...
+        'GKlib/fs', ...
+        'GKlib/getopt', ...
+        'GKlib/gkregex', ...
+        'GKlib/graph', ...
+        'GKlib/htable', ...
+        'GKlib/io', ...
+        'GKlib/itemsets', ...
+        'GKlib/mcore', ...
+        'GKlib/memory', ...
+        'GKlib/omp', ...
+        'GKlib/pdb', ...
+        'GKlib/pqueue', ...
+        'GKlib/random', ...
+        'GKlib/rw', ...
+        'GKlib/seq', ...
+        'GKlib/sort', ...
+        'GKlib/string', ...
+        'GKlib/timers', ...
+        'GKlib/tokenizer', ...
+        'GKlib/util', ...
+        'libmetis/auxapi', ...
+        'libmetis/balance', ...
+        'libmetis/bucketsort', ...
+        'libmetis/checkgraph', ...
+        'libmetis/coarsen', ...
+        'libmetis/compress', ...
+        'libmetis/contig', ...
+        'libmetis/debug', ...
+        'libmetis/fm', ...
+        'libmetis/fortran', ...
+        'libmetis/frename', ...
+        'libmetis/gklib', ...
+        'libmetis/graph', ...
+        'libmetis/initpart', ...
+        'libmetis/kmetis', ...
+        'libmetis/kwayfm', ...
+        'libmetis/kwayrefine', ...
+        'libmetis/mcutil', ...
+        'libmetis/mesh', ...
+        'libmetis/meshpart', ...
+        'libmetis/minconn', ...
+        'libmetis/mincover', ...
+        'libmetis/mmd', ...
+        'libmetis/ometis', ...
+        'libmetis/options', ...
+        'libmetis/parmetis', ...
+        'libmetis/pmetis', ...
+        'libmetis/refine', ...
+        'libmetis/separator', ...
+        'libmetis/sfm', ...
+        'libmetis/srefine', ...
+        'libmetis/stat', ...
+        'libmetis/timing', ...
+        'libmetis/util', ...
+        'libmetis/wspace', ...
+    } ;
+
+    for i = 1:length (metis_src)
+        metis_src {i} = [metis_path '/' metis_src{i}] ;
+    end
+
+    cholmod_src = {
+        '../../CHOLMOD/Core/cholmod_aat', ...
+        '../../CHOLMOD/Core/cholmod_add', ...
+        '../../CHOLMOD/Core/cholmod_band', ...
+        '../../CHOLMOD/Core/cholmod_change_factor', ...
+        '../../CHOLMOD/Core/cholmod_common', ...
+        '../../CHOLMOD/Core/cholmod_complex', ...
+        '../../CHOLMOD/Core/cholmod_copy', ...
+        '../../CHOLMOD/Core/cholmod_dense', ...
+        '../../CHOLMOD/Core/cholmod_error', ...
+        '../../CHOLMOD/Core/cholmod_factor', ...
+        '../../CHOLMOD/Core/cholmod_memory', ...
+        '../../CHOLMOD/Core/cholmod_sparse', ...
+        '../../CHOLMOD/Core/cholmod_transpose', ...
+        '../../CHOLMOD/Core/cholmod_triplet', ...
+        '../../CHOLMOD/Cholesky/cholmod_amd', ...
+        '../../CHOLMOD/Cholesky/cholmod_analyze', ...
+        '../../CHOLMOD/Cholesky/cholmod_colamd', ...
+        '../../CHOLMOD/Cholesky/cholmod_etree', ...
+        '../../CHOLMOD/Cholesky/cholmod_postorder', ...
+        '../../CHOLMOD/Cholesky/cholmod_rowcolcounts', ...
+        '../../CHOLMOD/Partition/cholmod_ccolamd', ...
+        '../../CHOLMOD/Partition/cholmod_csymamd', ...
+        '../../CHOLMOD/Partition/cholmod_camd', ...
+        '../../CHOLMOD/Partition/cholmod_metis', ...
+        '../../CHOLMOD/Partition/cholmod_nesdis' } ;
+
+else
+    camd_src = { } ;
+    ccolamd_src = { } ;
+    metis_src = { } ;
+    cholmod_src = { } ;
+end
+
+btf_src = {
+    '../../BTF/Source/btf_maxtrans', ...
+    '../../BTF/Source/btf_order', ...
+    '../../BTF/Source/btf_strongcomp' } ;
+
+klu_src = {
+    '../Source/klu_free_symbolic', ...
+    '../Source/klu_defaults', ...
+    '../Source/klu_analyze_given', ...
+    '../Source/klu_analyze', ...
+    '../Source/klu_memory' } ;
+
+if (with_cholmod)
+    klu_src = [klu_src { '../User/klu_l_cholmod' }] ;                       %#ok
+end
+
+klu_zlsrc = {
+    '../Source/klu', ...
+    '../Source/klu_kernel', ...
+    '../Source/klu_dump', ...
+    '../Source/klu_factor', ...
+    '../Source/klu_free_numeric', ...
+    '../Source/klu_solve', ...
+    '../Source/klu_scale', ...
+    '../Source/klu_refactor', ...
+    '../Source/klu_tsolve', ...
+    '../Source/klu_diagnostics', ...
+    '../Source/klu_sort', ...
+    '../Source/klu_extract', ...
+    } ;
+
+klu_lobj = {
+    'klu_l', ...
+    'klu_l_kernel', ...
+    'klu_l_dump', ...
+    'klu_l_factor', ...
+    'klu_l_free_numeric', ...
+    'klu_l_solve', ...
+    'klu_l_scale', ...
+    'klu_l_refactor', ...
+    'klu_l_tsolve', ...
+    'klu_l_diagnostics', ...
+    'klu_l_sort', ...
+    'klu_l_extract', ...
+    } ;
+
+klu_zlobj = {
+    'klu_zl', ...
+    'klu_zl_kernel', ...
+    'klu_zl_dump', ...
+    'klu_zl_factor', ...
+    'klu_zl_free_numeric', ...
+    'klu_zl_solve', ...
+    'klu_zl_scale', ...
+    'klu_zl_refactor', ...
+    'klu_zl_tsolve', ...
+    'klu_zl_diagnostics', ...
+    'klu_zl_sort', ...
+    'klu_zl_extract', ...
+    } ;
+
+try
+    % ispc does not appear in MATLAB 5.3
+    pc = ispc ;
+catch
+    % if ispc fails, assume we are on a Windows PC if it's not unix
+    pc = ~isunix ;
+end
+
+if (pc)
+    % Windows does not have drand48 and srand48, required by METIS.  Use
+    % drand48 and srand48 in CHOLMOD/MATLAB/Windows/rand48.c instead.
+    obj_extension = '.obj' ;
+    cholmod_src = [cholmod_src {'../../CHOLMOD/MATLAB/Windows/rand48'}] ;
+    include = [include ' -I../../CHOLMOD/MATLAB/Windows'] ;
+else
+    obj_extension = '.o' ;
+end
+
+% compile each library source file
+obj = ' ' ;
+
+source = [suitesparse_src amd_src btf_src klu_src colamd_src] ;
+if (with_cholmod)
+    source = [metis_src ccolamd_src camd_src cholmod_src source] ;
+end
+
+for f = source
+    ff = f {1} ;
+    if (isequal (ff, [metis_path '/GKlib/util']))
+        % special case, since a file with the same name also exists in libmetis
+        copyfile ([ff '.c'], 'GKlib_util.c', 'f') ;
+        ff = 'GKlib_util' ;
+        o = 'GKlib_util' ;
+    elseif (isequal (ff, [metis_path '/GKlib/graph']))
+        % special case, since a file with the same name also exist in libmetis
+        copyfile ([ff '.c'], 'GKlib_graph.c', 'f') ;
+        ff = 'GKlib_graph' ;
+        o = 'GKlib_graph' ;
+    else
+        slash = strfind (ff, '/') ;
+        if (isempty (slash))
+            slash = 1 ;
+        else
+            slash = slash (end) + 1 ;
+        end
+        o = ff (slash:end) ;
+    end
+    % fprintf ('%s\n', o) ;
+    o = [o obj_extension] ;
+    obj = [obj  ' ' o] ;					            %#ok
+    s = sprintf ('mex %s -DDLONG -O %s -c %s.c', d, include, ff) ;
+    kk = do_cmd (s, kk, details) ;
+end
+
+for k = 1:length(klu_zlsrc)
+    ff = klu_zlsrc {k} ;
+    slash = strfind (ff, '/') ;
+    if (isempty (slash))
+        slash = 1 ;
+    else
+        slash = slash (end) + 1 ;
+    end
+    o = ff (slash:end) ;
+    s = sprintf ('mex %s -DDLONG -O %s -c %s.c', d, include, ff) ;
+    kk = do_cmd (s, kk, details) ;
+    lobj = klu_lobj {k} ;
+    obj = [obj  ' ' lobj obj_extension] ;                                   %#ok
+    mvfile ([o obj_extension], [lobj obj_extension]) ;
+    s = sprintf ('mex %s -DDLONG -DCOMPLEX -O %s -c %s.c', d, include, ff) ;
+    kk = do_cmd (s, kk, details) ;
+    zlobj = klu_zlobj {k} ;
+    obj = [obj  ' ' zlobj obj_extension] ;                                  %#ok
+    mvfile ([o obj_extension], [zlobj obj_extension]) ;
+end
+
+% compile the KLU mexFunction
+s = sprintf ('mex %s -DDLONG -O %s -output klu klu_mex.c', d, include) ;
+s = [s obj] ;                                                               %#ok
+
+if (~(ispc || ismac))
+    % for POSIX timing routine
+    s = [s ' -lrt'] ;
+end
+
+kk = do_cmd (s, kk, details) ;
+
+% clean up
+s = ['delete ' obj] ;
+do_cmd (s, kk, details) ;
+
+rmfile ('GKlib_util.c') ;
+rmfile ('GKlib_graph.c') ;
+
+fprintf ('\nKLU successfully compiled\n') ;
+
+%-------------------------------------------------------------------------------
+
+function rmfile (file)
+% rmfile:  delete a file, but only if it exists
+if (length (dir (file)) > 0)                                                %#ok
+    delete (file) ;
+end
+
+%-------------------------------------------------------------------------------
+
+function cpfile (src, dst)
+% cpfile:  copy the src file to the filename dst, overwriting dst if it exists
+rmfile (dst)
+if (length (dir (src)) == 0)    %#ok
+    fprintf ('File does not exist: %s\n', src) ;
+    error ('File does not exist') ;
+end
+try
+    copyfile (src, dst) ;
+catch ME
+    % ignore errors of the form "cp: preserving permissions: ...
+    % Operation not supported".  rethrow all other errors.
+    if (isempty (strfind (ME.message, 'Operation not supported')))
+        rethrow (ME) ;
+    end
+end
+
+%-------------------------------------------------------------------------------
+
+function mvfile (src, dst)
+% mvfile:  move the src file to the filename dst, overwriting dst if it exists
+cpfile (src, dst) ;
+rmfile (src) ;
+
+%-------------------------------------------------------------------------------
+function kk = do_cmd (s, kk, details)
+%DO_CMD: evaluate a command, and either print it or print a "."
+if (details)
+    fprintf ('%s\n', s) ;
+else
+    if (mod (kk, 60) == 0)
+        fprintf ('\n') ;
+    end
+    kk = kk + 1 ;
+    fprintf ('.') ;
+end
+eval (s) ;
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/1c.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/1c.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..b9da4241592f17950b139b8c0e0846731bb0724b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/1c.mtx
@@ -0,0 +1,3 @@
+%%MatrixMarket matrix coordinate complex general
+1 1 1
+1 1 1 1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/GD99_cc.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/GD99_cc.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..4f5baec19ffbb22ca3ff89da4da8168f28ca9cc1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/GD99_cc.mtx
@@ -0,0 +1,152 @@
+%%MatrixMarket matrix coordinate complex general
+% imaginary part is Pajek/GD99_c, real part is zero
+105 105 149
+6 1 0 1
+5 2 0 1
+7 2 0 1
+4 3 0 1
+8 3 0 1
+5 4 0 1
+1 5 0 1
+24 6 0 1
+6 7 0 1
+7 8 0 1
+26 9 0 1
+105 10 0 1
+94 11 0 1
+40 12 0 1
+26 13 0 1
+16 14 0 1
+26 15 0 1
+26 16 0 1
+16 17 0 1
+16 19 0 1
+16 20 0 1
+57 21 0 1
+15 22 0 1
+31 22 0 1
+13 23 0 1
+15 24 0 1
+13 25 0 1
+9 26 0 1
+16 26 0 1
+57 26 0 1
+24 27 0 1
+85 28 0 1
+85 29 0 1
+32 30 0 1
+86 30 0 1
+22 31 0 1
+45 31 0 1
+57 31 0 1
+22 32 0 1
+85 32 0 1
+54 33 0 1
+88 33 0 1
+91 33 0 1
+91 34 0 1
+92 34 0 1
+95 35 0 1
+50 36 0 1
+98 37 0 1
+98 38 0 1
+38 39 0 1
+38 40 0 1
+102 41 0 1
+101 42 0 1
+103 43 0 1
+100 44 0 1
+104 44 0 1
+31 45 0 1
+93 45 0 1
+28 46 0 1
+50 47 0 1
+87 47 0 1
+100 47 0 1
+53 48 0 1
+99 48 0 1
+87 49 0 1
+89 49 0 1
+45 50 0 1
+94 50 0 1
+31 51 0 1
+104 51 0 1
+48 52 0 1
+90 52 0 1
+91 52 0 1
+89 53 0 1
+87 54 0 1
+90 54 0 1
+93 54 0 1
+99 55 0 1
+29 56 0 1
+18 57 0 1
+21 57 0 1
+26 57 0 1
+31 57 0 1
+95 58 0 1
+45 59 0 1
+103 59 0 1
+59 60 0 1
+102 61 0 1
+61 62 0 1
+61 63 0 1
+53 64 0 1
+64 65 0 1
+65 66 0 1
+64 67 0 1
+91 67 0 1
+92 67 0 1
+88 68 0 1
+97 69 0 1
+96 70 0 1
+97 70 0 1
+96 71 0 1
+92 72 0 1
+48 73 0 1
+64 73 0 1
+98 73 0 1
+40 74 0 1
+86 75 0 1
+96 76 0 1
+86 77 0 1
+82 78 0 1
+78 79 0 1
+82 79 0 1
+81 80 0 1
+84 80 0 1
+78 81 0 1
+33 82 0 1
+82 83 0 1
+83 84 0 1
+32 85 0 1
+30 86 0 1
+47 87 0 1
+54 87 0 1
+33 88 0 1
+97 88 0 1
+49 89 0 1
+99 89 0 1
+52 90 0 1
+55 90 0 1
+33 91 0 1
+67 91 0 1
+34 92 0 1
+50 93 0 1
+50 94 0 1
+95 94 0 1
+94 95 0 1
+70 96 0 1
+88 97 0 1
+73 98 0 1
+55 99 0 1
+89 99 0 1
+47 100 0 1
+101 100 0 1
+100 101 0 1
+102 101 0 1
+101 102 0 1
+59 103 0 1
+105 103 0 1
+105 104 0 1
+104 105 0 1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/arrow.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/arrow.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..27419e4a44f8b24a3016675a0df0ad532b02d96a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/arrow.mtx
@@ -0,0 +1,300 @@
+%%MatrixMarket matrix coordinate integer general
+100 100 298
+1 1 2
+2 1 1
+3 1 1
+4 1 1
+5 1 1
+6 1 1
+7 1 1
+8 1 1
+9 1 1
+10 1 1
+11 1 1
+12 1 1
+13 1 1
+14 1 1
+15 1 1
+16 1 1
+17 1 1
+18 1 1
+19 1 1
+20 1 1
+21 1 1
+22 1 1
+23 1 1
+24 1 1
+25 1 1
+26 1 1
+27 1 1
+28 1 1
+29 1 1
+30 1 1
+31 1 1
+32 1 1
+33 1 1
+34 1 1
+35 1 1
+36 1 1
+37 1 1
+38 1 1
+39 1 1
+40 1 1
+41 1 1
+42 1 1
+43 1 1
+44 1 1
+45 1 1
+46 1 1
+47 1 1
+48 1 1
+49 1 1
+50 1 1
+51 1 1
+52 1 1
+53 1 1
+54 1 1
+55 1 1
+56 1 1
+57 1 1
+58 1 1
+59 1 1
+60 1 1
+61 1 1
+62 1 1
+63 1 1
+64 1 1
+65 1 1
+66 1 1
+67 1 1
+68 1 1
+69 1 1
+70 1 1
+71 1 1
+72 1 1
+73 1 1
+74 1 1
+75 1 1
+76 1 1
+77 1 1
+78 1 1
+79 1 1
+80 1 1
+81 1 1
+82 1 1
+83 1 1
+84 1 1
+85 1 1
+86 1 1
+87 1 1
+88 1 1
+89 1 1
+90 1 1
+91 1 1
+92 1 1
+93 1 1
+94 1 1
+95 1 1
+96 1 1
+97 1 1
+98 1 1
+99 1 1
+100 1 1
+1 2 2
+2 2 1
+1 3 1
+3 3 1
+1 4 1
+4 4 1
+1 5 1
+5 5 1
+1 6 1
+6 6 1
+1 7 1
+7 7 1
+1 8 1
+8 8 1
+1 9 1
+9 9 1
+1 10 1
+10 10 1
+1 11 1
+11 11 1
+1 12 1
+12 12 1
+1 13 1
+13 13 1
+1 14 1
+14 14 1
+1 15 1
+15 15 1
+1 16 1
+16 16 1
+1 17 1
+17 17 1
+1 18 1
+18 18 1
+1 19 1
+19 19 1
+1 20 1
+20 20 1
+1 21 1
+21 21 1
+1 22 1
+22 22 1
+1 23 1
+23 23 1
+1 24 1
+24 24 1
+1 25 1
+25 25 1
+1 26 1
+26 26 1
+1 27 1
+27 27 1
+1 28 1
+28 28 1
+1 29 1
+29 29 1
+1 30 1
+30 30 1
+1 31 1
+31 31 1
+1 32 1
+32 32 1
+1 33 1
+33 33 1
+1 34 1
+34 34 1
+1 35 1
+35 35 1
+1 36 1
+36 36 1
+1 37 1
+37 37 1
+1 38 1
+38 38 1
+1 39 1
+39 39 1
+1 40 1
+40 40 1
+1 41 1
+41 41 1
+1 42 1
+42 42 1
+1 43 1
+43 43 1
+1 44 1
+44 44 1
+1 45 1
+45 45 1
+1 46 1
+46 46 1
+1 47 1
+47 47 1
+1 48 1
+48 48 1
+1 49 1
+49 49 1
+1 50 1
+50 50 1
+1 51 1
+51 51 1
+1 52 1
+52 52 1
+1 53 1
+53 53 1
+1 54 1
+54 54 1
+1 55 1
+55 55 1
+1 56 1
+56 56 1
+1 57 1
+57 57 1
+1 58 1
+58 58 1
+1 59 1
+59 59 1
+1 60 1
+60 60 1
+1 61 1
+61 61 1
+1 62 1
+62 62 1
+1 63 1
+63 63 1
+1 64 1
+64 64 1
+1 65 1
+65 65 1
+1 66 1
+66 66 1
+1 67 1
+67 67 1
+1 68 1
+68 68 1
+1 69 1
+69 69 1
+1 70 1
+70 70 1
+1 71 1
+71 71 1
+1 72 1
+72 72 1
+1 73 1
+73 73 1
+1 74 1
+74 74 1
+1 75 1
+75 75 1
+1 76 1
+76 76 1
+1 77 1
+77 77 1
+1 78 1
+78 78 1
+1 79 1
+79 79 1
+1 80 1
+80 80 1
+1 81 1
+81 81 1
+1 82 1
+82 82 1
+1 83 1
+83 83 1
+1 84 1
+84 84 1
+1 85 1
+85 85 1
+1 86 1
+86 86 1
+1 87 1
+87 87 1
+1 88 1
+88 88 1
+1 89 1
+89 89 1
+1 90 1
+90 90 1
+1 91 1
+91 91 1
+1 92 1
+92 92 1
+1 93 1
+93 93 1
+1 94 1
+94 94 1
+1 95 1
+95 95 1
+1 96 1
+96 96 1
+1 97 1
+97 97 1
+1 98 1
+98 98 1
+1 99 1
+99 99 1
+1 100 1
+100 100 1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/arrowc.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/arrowc.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..bf4d3c50bf1c5d619436bf71b46a70227ba10288
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/arrowc.mtx
@@ -0,0 +1,300 @@
+%%MatrixMarket matrix coordinate complex general
+100 100 298
+1 1 0 1
+2 1 1 0
+3 1 1 0
+4 1 1 0
+5 1 1 0
+6 1 1 0
+7 1 1 0
+8 1 1 0
+9 1 1 0
+10 1 1 0
+11 1 1 0
+12 1 1 0
+13 1 1 0
+14 1 1 0
+15 1 1 0
+16 1 1 0
+17 1 1 0
+18 1 1 0
+19 1 1 0
+20 1 1 0
+21 1 1 0
+22 1 1 0
+23 1 1 0
+24 1 1 0
+25 1 1 0
+26 1 1 0
+27 1 1 0
+28 1 1 0
+29 1 1 0
+30 1 1 0
+31 1 1 0
+32 1 1 0
+33 1 1 0
+34 1 1 0
+35 1 1 0
+36 1 1 0
+37 1 1 0
+38 1 1 0
+39 1 1 0
+40 1 1 0
+41 1 1 0
+42 1 1 0
+43 1 1 0
+44 1 1 0
+45 1 1 0
+46 1 1 0
+47 1 1 0
+48 1 1 0
+49 1 1 0
+50 1 1 0
+51 1 1 0
+52 1 1 0
+53 1 1 0
+54 1 1 0
+55 1 1 0
+56 1 1 0
+57 1 1 0
+58 1 1 0
+59 1 1 0
+60 1 1 0
+61 1 1 0
+62 1 1 0
+63 1 1 0
+64 1 1 0
+65 1 1 0
+66 1 1 0
+67 1 1 0
+68 1 1 0
+69 1 1 0
+70 1 1 0
+71 1 1 0
+72 1 1 0
+73 1 1 0
+74 1 1 0
+75 1 1 0
+76 1 1 0
+77 1 1 0
+78 1 1 0
+79 1 1 0
+80 1 1 0
+81 1 1 0
+82 1 1 0
+83 1 1 0
+84 1 1 0
+85 1 1 0
+86 1 1 0
+87 1 1 0
+88 1 1 0
+89 1 1 0
+90 1 1 0
+91 1 1 0
+92 1 1 0
+93 1 1 0
+94 1 1 0
+95 1 1 0
+96 1 1 0
+97 1 1 0
+98 1 1 0
+99 1 1 0
+100 1 1 0
+1 2 2 0
+2 2 1 0
+1 3 1 0
+3 3 1 0
+1 4 1 0
+4 4 1 0
+1 5 1 0
+5 5 1 0
+1 6 1 0
+6 6 1 0
+1 7 1 0
+7 7 1 0
+1 8 1 0
+8 8 1 0
+1 9 1 0
+9 9 1 0
+1 10 1 0
+10 10 1 0
+1 11 1 0
+11 11 1 0
+1 12 1 0
+12 12 1 0
+1 13 1 0
+13 13 1 0
+1 14 1 0
+14 14 1 0
+1 15 1 0
+15 15 1 0
+1 16 1 0
+16 16 1 0
+1 17 1 0
+17 17 1 0
+1 18 1 0
+18 18 1 0
+1 19 1 0
+19 19 1 0
+1 20 1 0
+20 20 1 0
+1 21 1 0
+21 21 1 0
+1 22 1 0
+22 22 1 0
+1 23 1 0
+23 23 1 0
+1 24 1 0
+24 24 1 0
+1 25 1 0
+25 25 1 0
+1 26 1 0
+26 26 1 0
+1 27 1 0
+27 27 1 0
+1 28 1 0
+28 28 1 0
+1 29 1 0
+29 29 1 0
+1 30 1 0
+30 30 1 0
+1 31 1 0
+31 31 1 0
+1 32 1 0
+32 32 1 0
+1 33 1 0
+33 33 1 0
+1 34 1 0
+34 34 1 0
+1 35 1 0
+35 35 1 0
+1 36 1 0
+36 36 1 0
+1 37 1 0
+37 37 1 0
+1 38 1 0
+38 38 1 0
+1 39 1 0
+39 39 1 0
+1 40 1 0
+40 40 1 0
+1 41 1 0
+41 41 1 0
+1 42 1 0
+42 42 1 0
+1 43 1 0
+43 43 1 0
+1 44 1 0
+44 44 1 0
+1 45 1 0
+45 45 1 0
+1 46 1 0
+46 46 1 0
+1 47 1 0
+47 47 1 0
+1 48 1 0
+48 48 1 0
+1 49 1 0
+49 49 1 0
+1 50 1 0
+50 50 1 0
+1 51 1 0
+51 51 1 0
+1 52 1 0
+52 52 1 0
+1 53 1 0
+53 53 1 0
+1 54 1 0
+54 54 1 0
+1 55 1 0
+55 55 1 0
+1 56 1 0
+56 56 1 0
+1 57 1 0
+57 57 1 0
+1 58 1 0
+58 58 1 0
+1 59 1 0
+59 59 1 0
+1 60 1 0
+60 60 1 0
+1 61 1 0
+61 61 1 0
+1 62 1 0
+62 62 1 0
+1 63 1 0
+63 63 1 0
+1 64 1 0
+64 64 1 0
+1 65 1 0
+65 65 1 0
+1 66 1 0
+66 66 1 0
+1 67 1 0
+67 67 1 0
+1 68 1 0
+68 68 1 0
+1 69 1 0
+69 69 1 0
+1 70 1 0
+70 70 1 0
+1 71 1 0
+71 71 1 0
+1 72 1 0
+72 72 1 0
+1 73 1 0
+73 73 1 0
+1 74 1 0
+74 74 1 0
+1 75 1 0
+75 75 1 0
+1 76 1 0
+76 76 1 0
+1 77 1 0
+77 77 1 0
+1 78 1 0
+78 78 1 0
+1 79 1 0
+79 79 1 0
+1 80 1 0
+80 80 1 0
+1 81 1 0
+81 81 1 0
+1 82 1 0
+82 82 1 0
+1 83 1 0
+83 83 1 0
+1 84 1 0
+84 84 1 0
+1 85 1 0
+85 85 1 0
+1 86 1 0
+86 86 1 0
+1 87 1 0
+87 87 1 0
+1 88 1 0
+88 88 1 0
+1 89 1 0
+89 89 1 0
+1 90 1 0
+90 90 1 0
+1 91 1 0
+91 91 1 0
+1 92 1 0
+92 92 1 0
+1 93 1 0
+93 93 1 0
+1 94 1 0
+94 94 1 0
+1 95 1 0
+95 95 1 0
+1 96 1 0
+96 96 1 0
+1 97 1 0
+97 97 1 0
+1 98 1 0
+98 98 1 0
+1 99 1 0
+99 99 1 0
+1 100 1 0
+100 100 1 0
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/ctina.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/ctina.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..3773ee163851b3b38c04c8224f2d033d9740828d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/ctina.mtx
@@ -0,0 +1,39 @@
+%%MatrixMarket matrix coordinate complex general
+% complex matrix with same nonzero pattern as Pajek/Tina_AskCog
+11 11 36
+3 1 0 1
+6 1 0 1
+10 1 0 1
+1 2 0 1
+3 2 0 1
+5 2 0 1
+6 2 0 1
+8 2 0 1
+9 2 0 1
+10 2 0 1
+1 3 0 1
+6 3 0 1
+10 3 0 1
+2 4 0 1
+6 4 0 1
+7 4 0 1
+8 4 0 1
+11 4 0 1
+6 5 0 1
+10 5 0 1
+5 6 0 1
+11 6 0 1
+4 7 0 1
+6 7 0 1
+9 7 0 1
+2 8 0 1
+4 8 0 1
+5 8 0 1
+6 8 0 1
+7 8 0 1
+9 8 0 1
+11 8 0 1
+7 9 0 1
+3 10 0 1
+5 10 0 1
+8 11 0 1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/impcol_a.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/impcol_a.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..49952a6631005afeb15a5afe280b9e9e132dd6d7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/impcol_a.mtx
@@ -0,0 +1,586 @@
+%%MatrixMarket matrix coordinate real general
+%-------------------------------------------------------------------------------
+% UF Sparse Matrix Collection, Tim Davis
+% http://www.cise.ufl.edu/research/sparse/matrices/HB/impcol_a
+% name: HB/impcol_a
+% [UNSYMMETRIC MATRIX - HEAT EXCHANGER NETWORK (CHEM ENG) ,1982]
+% id: 171
+% date: 1982
+% author: D. Bogle
+% ed: I. Duff, R. Grimes, J. Lewis
+% fields: title A name id date author ed kind
+% kind: chemical process simulation problem
+%-------------------------------------------------------------------------------
+207 207 572
+5 1 -1
+6 1 -1
+8 1 -1
+11 1 .0662129
+12 1 .1634
+1 2 1
+2 2 1
+11 2 -.579712
+12 2 -.422521
+3 3 1
+4 3 1
+10 3 -1
+11 3 17.8775
+12 3 44.1179
+5 4 -1
+65 4 1
+66 4 .5
+1 5 -1
+62 5 -1
+3 6 -1
+64 6 -1
+6 7 680
+7 8 1
+9 9 1
+8 10 1
+14 10 -1
+17 10 .00297937
+18 10 .0247819
+12 11 1
+17 11 -.220568
+18 11 -.808841
+10 12 1
+16 12 -1
+17 12 .804429
+18 12 6.69112
+11 13 .0708967
+12 13 -.0706236
+13 14 -1
+17 14 -.0323714
+18 14 -.00352409
+23 14 -1
+24 14 -1
+17 15 -.779432
+18 15 -.191159
+19 15 1
+20 15 1
+15 16 -1
+17 16 -7.57491
+18 16 -.824638
+21 16 1
+22 16 1
+13 17 1
+31 17 -1
+33 17 -150
+17 18 1
+33 18 -234
+15 19 1
+32 19 -1
+14 20 1
+34 20 -1
+36 20 -126.8
+16 21 1
+17 22 .104857
+18 22 -.0908757
+23 23 -1
+26 23 -1
+29 23 -.0311679
+30 23 -.103571
+19 24 -1
+29 24 -.757389
+30 24 -.625946
+21 25 -1
+28 25 -1
+29 25 -10.7841
+30 25 -35.8356
+24 26 580
+25 27 1
+27 28 1
+26 29 1
+31 29 -1
+33 29 -142.6
+28 30 1
+29 31 -.0979613
+30 31 .0483804
+31 32 1
+33 32 145.6
+33 33 580
+32 34 1
+34 35 -1
+36 35 -161
+38 35 1
+35 36 -1
+40 36 1
+34 37 -1
+36 37 -152.2
+203 37 1
+205 38 1
+34 39 -1
+36 39 -136.3
+197 39 1
+199 40 1
+34 41 -1
+36 41 -108.6
+98 41 1
+100 42 1
+34 43 -1
+36 43 -120.7
+67 43 1
+69 44 1
+34 45 1
+36 45 128
+95 45 1
+96 45 .2
+36 46 680
+92 46 -1
+35 47 1
+94 47 -1
+38 48 -1
+41 48 1.65272
+42 48 2.82163
+47 48 -1
+41 49 -.607865
+42 49 -.263986
+43 49 -1
+40 50 -1
+41 50 36.3599
+42 50 62.0759
+45 50 -1
+37 51 1
+39 52 1
+41 53 .559606
+42 53 -.677581
+47 54 1
+48 54 .7
+53 54 -1
+44 55 -1
+49 55 -1
+46 56 -1
+51 56 -1
+47 57 -1
+48 57 -1
+203 57 -1
+206 57 .478232
+207 57 1.21868
+43 58 1
+44 58 1
+206 58 -.330881
+207 58 -.280695
+45 59 1
+46 59 1
+205 59 -1
+206 59 21.9987
+207 59 56.0594
+48 60 68
+53 61 1
+54 61 .6
+59 61 -1
+50 62 -1
+55 62 -1
+52 63 -1
+57 63 -1
+53 64 -1
+54 64 -1
+197 64 -1
+200 64 .27161
+201 64 .629158
+49 65 1
+50 65 1
+200 65 -.561642
+201 65 -.382811
+51 66 1
+52 66 1
+199 66 -1
+200 66 24.7165
+201 66 57.2534
+54 67 159
+59 68 1
+60 68 .2
+65 68 -1
+56 69 -1
+61 69 -1
+58 70 -1
+63 70 -1
+59 71 -1
+60 71 -1
+98 71 -1
+101 71 .244371
+102 71 1.02444
+55 72 1
+56 72 1
+101 72 -.272351
+102 72 -.432602
+57 73 1
+58 73 1
+100 73 -1
+101 73 11.7298
+102 73 49.1733
+60 74 207
+65 75 -1
+66 75 -1
+67 75 -1
+71 75 .232813
+72 75 .061436
+61 76 1
+62 76 1
+71 76 -.573583
+72 76 -.869891
+63 77 1
+64 77 1
+69 77 -1
+71 77 47.4938
+72 77 12.5329
+66 78 411
+68 79 -1
+71 79 -.341668
+72 79 -.40286
+74 79 1
+70 80 -1
+71 80 -34.1668
+72 80 -40.286
+76 80 1
+68 81 1
+70 82 1
+71 83 -.0459958
+72 83 .0938315
+73 84 -1
+77 84 .179968
+78 84 .0328426
+83 84 -1
+84 84 -1
+77 85 -.53763
+78 85 -.943234
+79 85 1
+80 85 1
+75 86 -1
+77 86 36.7135
+78 86 6.69988
+81 86 1
+82 86 1
+74 87 -1
+77 87 -.311136
+78 87 -.186857
+164 87 1
+76 88 -1
+77 88 -31.1136
+78 88 -18.6857
+166 88 1
+73 89 1
+109 89 -1
+111 89 -201
+75 90 1
+77 91 -.012899
+78 91 .026314
+83 92 1
+84 92 .4
+89 92 -1
+80 93 -1
+85 93 -1
+82 94 -1
+87 94 -1
+83 95 -1
+131 95 -1
+134 95 .0222685
+135 95 .0916503
+79 96 -1
+134 96 -.852598
+135 96 -.686678
+81 97 -1
+133 97 -1
+134 97 6.30198
+135 97 25.937
+84 98 487
+89 99 1
+90 99 .1
+95 99 -1
+86 100 -1
+91 100 -1
+88 101 -1
+93 101 -1
+89 102 -1
+90 102 -1
+104 102 -1
+107 102 .306796
+108 102 1.72865
+85 103 1
+86 103 1
+107 103 -.953179
+108 103 -.478015
+87 104 1
+88 104 1
+106 104 -1
+107 104 14.7262
+108 104 82.9751
+90 105 535
+95 106 -1
+96 106 -1
+122 106 1
+123 106 .6
+91 107 1
+92 107 1
+119 107 -1
+93 108 1
+94 108 1
+121 108 -1
+96 109 680
+97 110 -1
+101 110 -.312836
+102 110 -.082762
+103 110 1
+99 111 -1
+101 111 -31.2836
+102 111 -8.2762
+105 111 1
+97 112 1
+99 113 1
+101 114 .409192
+102 114 -.852483
+104 115 1
+109 115 -1
+111 115 -273.9
+106 116 1
+107 117 .147934
+108 117 -.0810126
+109 118 -1
+111 118 -176.9
+131 118 1
+110 119 -1
+133 119 1
+109 120 -1
+111 120 -209.1
+125 120 1
+127 121 1
+109 122 -1
+111 122 -193
+113 122 1
+111 123 -54
+117 123 1
+115 124 1
+109 125 1
+111 125 197
+161 125 1
+162 125 .6
+111 126 680
+158 126 -1
+110 127 1
+160 127 -1
+113 128 -1
+116 128 .250032
+117 128 .597517
+122 128 -1
+116 129 -.585577
+117 129 -.406865
+118 129 -1
+115 130 -1
+116 130 13.5017
+117 130 32.2659
+120 130 -1
+112 131 1
+202 131 -1
+206 131 -.419796
+207 131 -.122705
+114 132 1
+204 132 -1
+206 132 -41.9796
+207 132 -12.2705
+116 133 .239041
+117 133 -.242126
+122 134 -1
+123 134 -1
+125 134 -1
+128 134 .158767
+129 134 .340658
+118 135 1
+119 135 1
+128 135 -.588216
+129 135 -.353609
+120 136 1
+121 136 1
+127 136 -1
+128 136 14.4478
+129 136 30.9999
+123 137 145
+124 138 -1
+128 138 -.307616
+129 138 -.130446
+190 138 1
+128 139 -.411784
+129 139 -.646391
+194 139 1
+126 140 -1
+128 140 -30.7616
+129 140 -13.0446
+192 140 1
+124 141 1
+196 141 -1
+200 141 -.562373
+201 141 -.225697
+126 142 1
+198 142 -1
+200 142 -56.2373
+201 142 -22.5697
+128 143 .10564
+129 143 -.116088
+130 144 -1
+134 144 -.276727
+135 144 -.171445
+140 144 -1
+141 144 -1
+134 145 -.147402
+135 145 -.313322
+136 145 1
+137 145 1
+132 146 -1
+134 146 -28.7796
+135 146 -17.8303
+138 146 1
+139 146 1
+130 147 1
+154 147 -1
+156 147 -193.6
+132 148 1
+155 148 -1
+134 149 .087773
+135 149 -.0322558
+140 150 -1
+143 150 -1
+146 150 -.0323781
+147 150 -.0683179
+136 151 -1
+146 151 -.60537
+147 151 -.349597
+138 152 -1
+145 152 -1
+146 152 -12.1741
+147 152 -25.6875
+141 153 480
+142 154 1
+144 155 1
+143 156 1
+149 156 -1
+152 156 -.00472003
+153 156 -.0317473
+147 157 1
+152 157 -.934841
+153 157 -.792495
+145 158 1
+151 158 -1
+152 158 -1.77473
+153 158 -11.937
+146 159 -.0203625
+147 159 .0218773
+148 160 1
+150 161 1
+149 162 1
+154 162 -1
+156 162 -198
+153 163 1
+156 163 -376
+151 164 1
+152 165 -.0366465
+153 165 .00813435
+154 166 1
+156 166 197.2
+155 167 1
+161 168 -1
+162 168 -1
+163 168 -1
+167 168 .0165562
+168 168 .00408216
+157 169 1
+158 169 1
+167 169 -.832633
+168 169 -.729721
+159 170 1
+160 170 1
+165 170 -1
+167 170 7.21849
+168 170 1.77982
+161 171 -1
+191 171 -1
+194 171 .00193333
+195 171 .0781847
+157 172 -1
+194 172 -.995803
+195 172 -.705952
+159 173 -1
+193 173 -1
+194 173 .471732
+195 173 19.0771
+162 174 680
+164 175 -1
+167 175 -.0379488
+168 175 -.16853
+170 175 1
+167 176 -.167367
+168 176 -.270279
+174 176 1
+166 177 -1
+167 177 -3.79488
+168 177 -16.853
+172 177 1
+163 178 1
+185 178 -1
+188 178 .0406846
+189 178 .100421
+165 179 1
+187 179 -1
+188 179 17.7385
+189 179 43.7834
+167 180 -.0235888
+168 180 .102847
+169 181 -1
+173 181 .123883
+174 181 .0243372
+191 181 1
+171 182 -1
+173 182 30.2273
+174 182 5.93828
+193 182 1
+170 183 -1
+173 183 -.242234
+174 183 -.211144
+176 183 1
+173 184 -.3775
+174 184 -.0788991
+180 184 1
+172 185 -1
+173 185 -24.2234
+174 185 -21.1144
+178 185 1
+169 186 1
+181 186 -1
+183 186 -281.7
+171 187 1
+182 187 -1
+173 188 -.0173768
+174 188 .0423995
+175 189 -1
+179 189 .0149554
+180 189 .00262203
+181 189 1
+183 189 291
+179 190 -.825997
+180 190 -.904947
+183 190 680
+177 191 -1
+179 191 10.1696
+180 191 1.78298
+182 191 1
+175 192 1
+177 193 1
+179 194 -.00696415
+180 194 .0362189
+181 195 -1
+183 195 -296
+185 195 1
+187 196 1
+184 197 1
+188 198 1
+186 199 1
+188 200 .0382256
+189 200 -.0306734
+194 201 .00264546
+195 201 -.000781169
+196 202 1
+198 203 1
+200 204 .229712
+201 204 -.25243
+202 205 1
+204 206 1
+206 207 .27097
+207 207 -.589066
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/one.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/one.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..ef0989175110daba3b444a5624772291905574f6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/one.mtx
@@ -0,0 +1,6 @@
+%%MatrixMarket matrix coordinate real general
+2 2 4
+1 1 0
+1 2 0
+2 1 0
+2 2 0
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/onec.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/onec.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..59c8534cef546d62d7079cf906b0c2c770d1cd2d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/onec.mtx
@@ -0,0 +1,6 @@
+%%MatrixMarket matrix coordinate complex general
+2 2 4
+1 1 0 0
+1 2 0 0
+2 1 0 0
+2 2 0 0
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/two.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/two.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..7457e818fb711460946c4975f611f433c8b14210
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/two.mtx
@@ -0,0 +1,3 @@
+%%MatrixMarket matrix coordinate real general
+2 2 1
+1 1 3
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/w156.mtx b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/w156.mtx
new file mode 100644
index 0000000000000000000000000000000000000000..658309ceea0b09d8a0e47e57a8615fd5cc808cab
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Matrix/w156.mtx
@@ -0,0 +1,365 @@
+%%MatrixMarket matrix coordinate complex general
+% complex matrix with the same real part, and same pattern, as HB/west0156
+156 156 362
+147 1 1 -89.00615831818635
+148 2 1 19.968263502718298
+149 2 -.1632648 -21.370801333956592
+59 3 -1.16206 -56.926762937042156
+134 3 -.8122999 -63.520075069490886
+149 3 1 -84.64919515773938
+52 4 1 -98.51526079522304
+53 5 1 57.75659925548426
+54 5 -.2166122 -96.44247397535688
+54 6 1 75.58829308886945
+59 6 -.1 -29.491646321365707
+118 7 1 44.42795357432983
+119 8 1 93.69016787815801
+120 8 -.2113848 -68.86640328523129
+59 9 1 -67.40889160696356
+105 9 .699017 -37.32052633277537
+120 9 1 -94.12369035075191
+150 10 1.009263 -28.474976610167545
+151 10 11.46533 -94.56192034360119
+150 11 .9908224 58.733403730195796
+152 11 -.5284282 99.84615089171123
+153 11 -.4980997 -77.95229509053108
+156 11 -.06675177 24.520231739121968
+152 12 1 -73.48563095366146
+153 13 1 -37.99404220990422
+155 13 -.8429148 -73.0424624342159
+154 14 1 -55.33473746935735
+156 14 -.0344062 -20.690642338915623
+155 15 1 -72.97130102560114
+156 15 -.00102006 -51.78826211728082
+134 16 5.047402 85.50322996314317
+156 16 1 -21.779825201968972
+138 17 -1.052632 2.25255469346175
+141 17 -.6666667 -81.42077676767339
+141 18 1 -95.66021714041189
+143 18 -.4480102 -68.09303466517918
+143 19 -2.988037 68.90318876644317
+143 20 1 75.83069648519695
+145 20 1 -62.60209482759951
+146 20 -1 98.26098380691137
+2 21 -.0535949 42.4059682333364
+144 21 2 74.27292331881648
+131 22 1 -4.0737630474247055
+133 22 -.9965392 -.7990146886149518
+132 23 1 -42.493627158378786
+133 23 -.003460798 -87.811709810653
+133 24 1 -47.506459158247225
+135 24 1 -62.747796590550934
+134 25 1 83.41795736466501
+135 25 1 -75.34426113632455
+137 26 .07513964 -97.31092337989851
+138 26 1 -26.06185629381749
+144 27 -5.47842 39.72822166458327
+145 27 -3.3405 77.86944264650091
+142 28 1 18.754103827151415
+146 28 -1 -68.66182065372685
+121 29 1.006185 -36.66211626227418
+122 29 10.73614 -53.320902834444595
+121 30 .9938532 -98.31558725078405
+123 30 -.5209677 -20.61924162618064
+124 30 -.4971525 29.973626118500405
+127 30 -.07339495 -82.99987875707477
+123 31 1 53.761900651751795
+124 32 1 93.94034099433995
+126 32 -.8391701 42.95944637524101
+125 33 1 56.39236839209942
+127 33 -.0258101 -52.4869835919564
+126 34 1 -60.85384724334488
+127 34 -.00199955 -47.357216964877104
+105 35 -5.396799 42.757012919227776
+127 35 1 95.51994788712943
+109 36 -.5263158 27.42438816918027
+112 36 -.3333333 9.184831019804385
+112 37 1 69.61144488338648
+114 37 -1.265049 60.41953169602192
+114 38 -1.778183 33.66128201334357
+114 39 1 34.19652679396956
+116 39 1 64.12873645714785
+117 39 -1 94.09447492182123
+2 40 -.0535949 -2.615000891619801
+115 40 2 63.49370710939066
+102 41 1 28.314233569200088
+104 41 -.9965392 -38.73012809722005
+103 42 1 32.186426447893
+104 42 -.003460798 -28.396577322438276
+104 43 1 87.63988602024271
+106 43 1 -2.4666050470267376
+105 44 1 -81.8019284512067
+106 44 1 34.7668233724147
+108 45 .1709599 2.976063797565698
+109 45 1 -55.68413072287828
+115 46 -5.47842 45.001874190444255
+116 46 -3.3405 -86.35067780598133
+113 47 1 92.82485367450755
+117 47 -1 -58.46868232626774
+55 48 -1 -67.77635488972467
+111 48 -1 27.644276518549617
+120 48 -1 -99.9543654216764
+118 49 -.5238095 -32.87341132956595
+120 49 -2.325233 -44.9800357067578
+55 50 -.2113848 -91.09449592159396
+56 50 1 -81.22070048053217
+101 50 -1 -18.000520045594502
+120 50 -.2113848 63.37846389879085
+4 51 -1 74.1034143618639
+17 51 -1 -95.48897590879422
+19 51 3.328735e-12 45.435396739586366
+20 51 1 69.60188961279125
+5 52 -1 45.72003820360473
+23 52 1 91.01972665502697
+24 52 1 31.27022211937156
+15 53 -1 48.46102670181145
+17 53 -.2113848 -31.006797219415848
+18 53 1 76.80438993503029
+61 54 -1 -30.551182700157376
+102 54 1 -88.10466389149548
+103 54 1 43.682918215884015
+110 54 -1 91.64285858148136
+117 54 1 -68.63302698512894
+63 55 -1 -16.72937877072226
+107 55 -1 -81.19302620544275
+66 56 -1 -10.010709210238765
+99 56 -1 73.83048511517521
+102 56 1.009514 -21.676555467798853
+113 56 -1.008042 -49.443269787795316
+67 57 -1 -29.123614686250242
+100 57 -1 48.59559363996606
+103 57 106.1112 30.166404491500764
+113 57 -.1547227 87.9586081050228
+60 58 1 66.5598249196907
+76 58 -1 -6.004426629012382
+139 58 1 25.973121452632107
+62 59 1 -88.36243043738105
+136 59 1 8.437479459481146
+64 60 1 -8.854807545659217
+76 60 -.9795877 72.61737844345258
+128 60 1 71.03939394472891
+65 61 1 -5.548863487187949
+76 61 -3.145565 57.38487793395959
+129 61 1 31.19642765119832
+34 62 -.008064516 -99.99202208021522
+36 63 1.974212 -73.75256764965177
+37 63 -.8416949 -1.0250487994832636
+37 64 1 -92.33336856681214
+38 64 -.008525207 -54.512838099295834
+38 65 1 -34.42340854356044
+39 65 -1 79.89375753843836
+47 65 -1 -37.25390248725466
+39 66 1 -49.66479762290302
+40 66 -1 -13.402173664778449
+40 67 1.895931 68.47644730738057
+41 67 -.9987282 -63.10220167747585
+41 68 1 1.6358424738914135
+42 68 2.087875 -9.552066657022863
+42 69 -1 -34.88311211669629
+46 69 -1 -23.984738606508827
+43 70 5.616771 77.29599272885395
+44 70 7.392325 52.252152063678636
+44 71 1 76.75326698731126
+45 71 7.20301 -8.51874880007002
+45 72 -1 59.84045826963149
+46 72 -.3258084 -73.18457603806863
+2 73 -2.146936 -86.93726233197341
+46 73 1 -24.971068398888395
+1 74 -6.821893 -25.29540601492628
+47 74 1 -3.1955205789929164
+91 75 2.431413 93.89184641063227
+93 75 -1 -31.58778114773145
+91 76 -2.431413 -49.4621487710556
+92 76 1 16.977383351584187
+93 77 1 4.740718882261197
+94 77 -1.26 -67.31619071487106
+2 78 -.8858734 -2.7203702821855025
+94 78 2 -.7878501044749853
+95 79 1 68.63881664718761
+96 79 -1 61.23964308235974
+1 80 -.02308312 71.5571192607996
+96 80 1 21.950827565571494
+82 81 1 13.146073550568627
+84 81 .9638 22.379704330589135
+97 81 1 -79.40469554532865
+84 82 .9905759 -68.33681654633787
+98 82 1 -17.27002806448744
+5 83 1.068219 12.082089707594035
+16 83 -1 -46.26454171200754
+6 84 9.305934e-22 56.85083285313337
+7 84 -.19106 -22.425843053832928
+8 84 -.3460553 -93.8032758232799
+7 85 1 17.10036588328181
+9 85 -.2113848 11.711705644935023
+9 86 1 -59.860885505008746
+10 86 -1 -82.51562297274859
+14 86 -1 86.64597186070104
+10 87 1 -48.124005287383966
+11 87 -1 -59.165721082767206
+12 88 1 -90.15831162239165
+13 88 -5.165179 21.23218795450579
+11 89 2.109794 9.269748032162251
+12 89 -.4423309 -80.83251277071686
+2 90 -1.200652 27.39912937614759
+13 90 1 -11.410334391483856
+1 91 -2.151087 -86.72360822705714
+14 91 1 -25.141483188003487
+7 92 -3.221332 -50.17945514204103
+8 92 -.08256881 84.9750583295307
+16 92 1.030078 25.899858515648553
+68 93 .00729927 75.66175530017894
+69 94 .009933775 28.334886205187427
+70 95 2.109489 59.67812719925334
+71 96 1.923841 -12.994792290221335
+72 97 1 96.2280502631985
+76 97 -.9703559 -80.80844033399066
+73 98 1 5.496479792736464
+76 98 -.02964405 9.129164943297008
+74 99 1 -43.131448638051594
+77 99 -.9703559 -25.83946813902346
+75 100 1 -87.06147957359738
+77 100 -.02964405 8.961812886476107
+76 101 1 67.27512065071366
+77 101 1 -70.93560166316104
+79 101 1 -65.69594863822117
+78 102 .009933775 -86.39056354840274
+79 102 -.3 64.80230680396102
+79 103 -3.333333 -73.2058484284056
+81 103 1 76.95725769618616
+2 104 -.3581659 2.947479893374072
+80 104 .9144476 92.7271192399364
+80 105 -2.355064 -75.90106649225966
+81 105 -2.599699 -90.342023563869
+1 106 1 -23.969599224575187
+3 106 -.5 -17.441756388313255
+2 107 1 -19.721740669438702
+3 107 -.5 -15.800573906372883
+3 108 1 -24.609261720375176
+110 109 1 81.46730529244041
+131 109 -.9431611 34.03242893843479
+132 109 -.5 92.36770491956567
+139 109 -1 -67.40413278123356
+146 109 1 49.72988179123301
+107 110 1 -25.186855192188627
+136 110 -1 -9.152697748159888
+99 111 1 -92.28786082587108
+128 111 -1 12.486401290146553
+131 111 -.9521341 -25.537570672597443
+142 111 -1.008042 58.55674146933576
+100 112 1 59.046194569800136
+129 112 -1 -23.417105544732607
+132 112 -53.05558 -49.44203913337082
+142 112 -.1547227 -31.414428806369965
+4 113 1 93.56089866913022
+9 113 -1.098983 -4.038321887840279
+111 113 1 -26.334487417080844
+127 113 -1.006101 52.91343104779358
+15 114 1 -24.570205949318236
+101 114 1 80.06124313084004
+127 114 -.2126745 -63.313589410507554
+17 115 3.875969e-8 -26.336536744115246
+19 115 -1 83.49140785169018
+21 116 -.9939418 3.183211228849636
+23 117 -1 -81.93854756530253
+17 118 2.727302e-20 47.06229753702564
+18 118 -1 -99.05756753456353
+17 119 1 20.62462338921529
+20 119 -1 91.37333280835817
+25 119 -1 -20.513614148643057
+27 119 .9972523 46.310157066657176
+28 119 1.02473 36.92776530123669
+22 120 -.9939418 95.70060448966404
+29 120 1 -59.24296668628066
+30 120 1 18.66056780239591
+24 121 -1 90.31250335814364
+31 121 1 -47.94551850968427
+32 121 1 2.9355241818408873
+17 122 .2113848 27.26637973052666
+25 122 -.2113848 -19.808178764946284
+26 122 1 -2.677737852379014
+19 123 5453728 50.091622636210076
+20 123 -.2113848 -74.7606532733799
+25 124 .9 -91.38750367809608
+27 124 -1 -25.812131278013382
+140 124 -1 38.66042415449142
+156 124 -1.009619 87.16498856941061
+29 125 -1 -4.484878166369444
+153 125 -.5019003 -74.17998047268341
+156 125 -.2294135 -3.2337575851525746
+31 126 -1 89.11943234297857
+137 126 -1 -26.45117330526361
+151 126 1 -34.30288621503337
+25 127 .1897236 54.575096067325134
+26 127 -1 -40.54519558973049
+130 127 -1 -64.42912801819011
+156 127 -.2128317 38.15983229583313
+25 128 .1 -47.211028939720535
+28 128 -1 -8.452188579330155
+33 128 1 68.73848491242163
+38 128 -1.007626 76.29973210306002
+30 129 -1 40.00399128013372
+36 129 -1 51.13819898638041
+38 129 -.2680827 94.90296027698403
+32 130 -1 -19.569463307138236
+34 130 1 -73.74427235921586
+25 131 .02166122 44.94677740033393
+35 131 1 79.903641471542
+38 131 -.2182642 -65.85973708326853
+27 132 .234872 -91.3942617588595
+28 132 -2.113848 -4.168155014702535
+55 133 .9 -81.21274304896602
+140 133 1 30.009966330192217
+149 133 -.7744864 90.45550778420308
+57 134 1.052135 -8.457460121512772
+137 134 .9248604 7.376129401205689
+55 135 .1897236 -86.70257083968079
+130 135 1 -1.2259832834904283
+149 135 -.1632648 -16.491805524055003
+33 136 -1 -41.548589946331724
+48 136 1 -42.06721249302474
+35 137 -1 50.769199337537785
+51 137 1 -80.6408576103972
+48 138 -1 -84.6165978311754
+54 138 -1 44.18300600646185
+55 138 .1 52.982301945926324
+49 139 -1 31.588984823676935
+52 139 -.5238095 62.08170441145384
+54 139 -2.382735 -25.151381648928016
+50 140 -.991453 -38.7537048036034
+58 140 1.06422 -25.86008018285866
+51 141 -1 41.34942373575503
+54 141 -.2166122 -66.32674228356838
+55 141 .02166122 62.744201350248474
+50 142 -.06837607 -6.7543369226229055
+60 143 -1 44.45713521489259
+85 143 175966.4 98.97378279407572
+86 143 -1 -27.499396494334206
+91 143 -2.431413 46.16562887690614
+95 143 -1 29.933482992494255
+69 144 .9900662 36.26781509331472
+70 144 -1.091241 -98.47761599001427
+76 144 -13 30.829860743864714
+78 144 .9900662 89.04702870503172
+87 144 1 22.65420709853554
+88 144 1 56.585595081575036
+62 145 -1 -99.36930257401184
+89 145 1 59.39156971639217
+90 145 -1 28.363331197466945
+64 146 -1 -64.30427579759511
+82 146 -1 5.880145934392633
+84 146 -.9638 -56.25129719765649
+95 146 -1.009514 9.61048763756911
+97 146 -1 -88.35252745679256
+65 147 -1 17.51741912019611
+85 147 1.8672e7 -16.77928832091964
+92 147 -106.1112 -62.7109528243285
+86 148 .7396663 -87.21785589638561
+87 149 -1 -85.04344448822249
+89 150 -.6169444 -37.992508436142
+82 151 .9905759 88.81698357390519
+83 152 1 96.14532626091892
+85 153 -175966.4 11.023098151583245
+86 153 .2603337 97.70512729352296
+88 154 -1 38.311980523494384
+90 155 1 -51.66782743196781
+84 156 .9905759 61.96273642788614
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..708d1bab4fb88eb2ba83424d21fa2fb37beca188
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/README.txt
@@ -0,0 +1,131 @@
+KLU, Copyright (C) 2004-2013, University of Florida
+by Timothy A. Davis and Ekanathan Palamadai.
+KLU is also available under other licenses; contact authors for details.
+http://www.suitesparse.com
+
+Requires the AMD, COLAMD, and BTF libraries, in ../AMD, ../COLAMD, and ../BTF,
+respectively.  Requires the ../SuiteSparse_config/SuiteSparse_config.mk
+configuration file.  Optionally uses CHOLMOD (KLU/User example ordering).  The
+Tcov tests and the one of the programs in the Demo require CHOLMOD.
+
+To compile the libklu.a library, type "make".  The compiled library is located
+in KLU/Lib/libklu.a.  Compile code that uses KLU with -IKLU/Include.
+To compile a simple demo (without CHOLMOD), cd to the Demo directory and
+type "make klu_simple".
+
+Type "make clean" to remove all but the compiled library, and "make distclean"
+to remove all files not in the original distribution.
+
+--------------------------------------------------------------------------------
+
+See KLU/Doc/License.txt for the license.
+
+--------------------------------------------------------------------------------
+
+Files in this distribution:
+
+    Demo                example programs that use KLU (requires CHOLMOD)
+    Doc                 documentation
+    Include             include files
+    Lib                 compiled library
+    Makefile            top-level Makefile
+    MATLAB              MATLAB interface
+    Matrix              test matrices
+    README.txt          this file
+    Source              source code
+    Tcov                exhaustive test of KLU and BTF
+    User                example user ordering function (interface to CHOLMOD)
+
+./Demo:
+    klu_simple.c        a simple demo (does not require CHOLMOD)
+                        compile with "make klu_simple"
+    klu_simple.out      output of klu_simple
+    kludemo.c           KLU demo (int version)
+    kludemo.out         output of "make" in this directory
+    kluldemo.c          KLU demo (SuiteSparse_long version)
+    Makefile            Makefile for compiling the demo
+
+./Doc:
+    ChangeLog
+    KLU_UserGuide.bib   Bibiography
+    KLU_UserGuide.pdf   PDF version of KLU User Guide
+    KLU_UserGuide.tex   TEX source of KLU User Guide
+    License.txt         license
+    Makefile            Makefile for creating the User Guide
+    palamadai_e.pdf     Eka Palamadai's MS thesis
+
+./Include:
+    klu.h               user include file
+    klu_internal.h      internal include file, not needed by the user
+    klu_version.h       internal include file, not needed by the user
+
+./Lib:
+    Makefile            Makefile for compiling the KLU C-callable library
+                        (with or without CHOLMOD)
+
+./MATLAB:
+    Contents.m          list of MATLAB functions in KLU
+    klu_demo.m          MATLAB demo
+    klu_demo.m.out      output of MATLAB demo (with CHOLMOD)
+    klu_install.m       compiles and installs KLU for use in MATLAB, runs demo
+    klu.m               MATLAB help for KLU
+    klu_make.m          compiles KLU for use in MATLAB
+    klu_mex.c           MATLAB mexFunction interface for KLU
+    Makefile            Makefile for KLU mexFunction, with CHOLMOD
+    Makefile_no_CHOLMOD Makefile for KLU mexFunction, without CHOLMOD
+    Test                MATLAB tests
+
+./MATLAB/Test:          KLU tests, requires UFget
+    test1.m             
+    test2.m
+    test3.m
+    test4.m
+    test5.m
+
+./Matrix:               test matrices for programs in ./Demo and ./Tcov
+    1c.mtx
+    arrowc.mtx
+    arrow.mtx
+    ctina.mtx
+    GD99_cc.mtx
+    impcol_a.mtx
+    onec.mtx
+    one.mtx
+    two.mtx
+    w156.mtx
+
+./Source:
+    klu_analyze.c       klu_analyze and supporting functions
+    klu_analyze_given.c klu_analyze_given and supporting functions
+    klu.c               kernel factor/solve functions, not user-callable
+    klu_defaults.c      klu_defaults function
+    klu_diagnostics.c   klu_rcond, klu_condest, klu_rgrowth, kluflops
+    klu_dump.c          debugging functions
+    klu_extract.c       klu_extract
+    klu_factor.c        klu_factor and supporting functions
+    klu_free_numeric.c  klu_free_numeric function
+    klu_free_symbolic.c klu_free_symbolic function
+    klu_kernel.c        kernel factor functions, not user-callable
+    klu_memory.c        klu_malloc, klu_free, klu_realloc, and supporing func.
+    klu_refactor.c      klu_refactor function
+    klu_scale.c         klu_scale function
+    klu_solve.c         klu_solve function
+    klu_sort.c          klu_sort and supporting functions
+    klu_tsolve.c        klu_tsovle function
+
+./Tcov:                 exhaustive test suite; requires Linux/Unix
+    coverage            determine statement coverage
+    klultests           KLU SuiteSparse_long tests
+    klutest.c           KLU test program
+    klutests            KLU int tests
+    Makefile            Makefile for compiling and running the tests
+    README.txt          README file for Tcov
+    vklutests           KLU int tests, using valgrind
+    vklultests          KLU SuiteSparse_long tests, using valgrind
+
+./User:
+    klu_cholmod.c       sample KLU user ordering function (int version)
+    klu_cholmod.h       include file for klu_cholmod and klu_l_cholmod
+    klu_l_cholmod.c     sample KLU user ordering function (SuiteSparse_long) 
+    Makefile            Makefile for compiling the user ordering functions
+    README.txt          README for User directory
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e8c862b91685bb0e893a4dc5c885f27c49862db0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/README.txt
@@ -0,0 +1,7 @@
+Test suite for KLU
+
+To compile and run the test suite, first type "make" in the Linux/Unix shell.
+The libraries must be compiled first (if they aren't use "make libs").
+"make clean" or "make distclean" will remove all unnecessary files.
+
+Timothy A. Davis, http://www.suitesparse.com
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/coverage b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/coverage
new file mode 100644
index 0000000000000000000000000000000000000000..c08158828652e71ff4a8bf3a53cecd44c9abb961
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/coverage
@@ -0,0 +1,4 @@
+#!/bin/csh
+gcov cov*.c >& /dev/null
+echo -n 'statements not covered: '
+grep "#####"  *.c.gcov | wc -l
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/klultests b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/klultests
new file mode 100644
index 0000000000000000000000000000000000000000..98f2734aae8c85702d5d954eef459673ea9210ca
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/klultests
@@ -0,0 +1,31 @@
+#!/bin/csh
+
+# 57 unique statements:
+./klultest < ../Matrix/impcol_a.mtx
+
+# 20:
+./klultest < ../Matrix/GD99_cc.mtx
+
+# 17:
+./klultest < ../Matrix/two.mtx
+
+# 10:
+./klultest < ../Matrix/w156.mtx
+
+# 3, xsize memgrow in klu_kernel
+./klultest < ../Matrix/arrow.mtx
+
+# 3, xsize memgrow in klu_kernel, 1 in klu_z_condest,
+./klultest < ../Matrix/arrowc.mtx
+
+# 2 in klu_z_kernel (if pivot == 0 and halt_if_singular, and in complex divide)
+./klultest < ../Matrix/onec.mtx
+
+# 1 in klu_kernel (if pivot == 0 and halt if singular)
+./klultest < ../Matrix/one.mtx
+
+# 1 in klu_z_condest:
+./klultest < ../Matrix/1c.mtx
+
+# 1 in klu_z_condest:
+./klultest < ../Matrix/ctina.mtx
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/klutests b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/klutests
new file mode 100644
index 0000000000000000000000000000000000000000..9b110bd34c880342cb83ece27605247e4d23b2d2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/klutests
@@ -0,0 +1,31 @@
+#!/bin/csh
+
+# 57 unique statements:
+./klutest < ../Matrix/impcol_a.mtx
+
+# 20:
+./klutest < ../Matrix/GD99_cc.mtx
+
+# 17:
+./klutest < ../Matrix/two.mtx
+
+# 10:
+./klutest < ../Matrix/w156.mtx
+
+# 3, xsize memgrow in klu_kernel
+./klutest < ../Matrix/arrow.mtx
+
+# 3, xsize memgrow in klu_kernel, 1 in klu_z_condest,
+./klutest < ../Matrix/arrowc.mtx
+
+# 2 in klu_z_kernel (if pivot == 0 and halt_if_singular, and in complex divide)
+./klutest < ../Matrix/onec.mtx
+
+# 1 in klu_kernel (if pivot == 0 and halt if singular)
+./klutest < ../Matrix/one.mtx
+
+# 1 in klu_z_condest:
+./klutest < ../Matrix/1c.mtx
+
+# 1 in klu_z_condest:
+./klutest < ../Matrix/ctina.mtx
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/vklultests b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/vklultests
new file mode 100644
index 0000000000000000000000000000000000000000..8aa8dcf5405ae6e66d7480d0ba92782596e889a9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/vklultests
@@ -0,0 +1,31 @@
+#!/bin/csh
+
+# 57 unique statements:
+valgrind ./klultest < ../Matrix/impcol_a.mtx
+
+# 20:
+valgrind ./klultest < ../Matrix/GD99_cc.mtx
+
+# 17:
+valgrind ./klultest < ../Matrix/two.mtx
+
+# 10:
+valgrind ./klultest < ../Matrix/w156.mtx
+
+# 3, xsize memgrow in klu_kernel
+valgrind ./klultest < ../Matrix/arrow.mtx
+
+# 3, xsize memgrow in klu_kernel, 1 in klu_z_condest,
+valgrind ./klultest < ../Matrix/arrowc.mtx
+
+# 2 in klu_z_kernel (if pivot == 0 and halt_if_singular, and in complex divide)
+valgrind ./klultest < ../Matrix/onec.mtx
+
+# 1 in klu_kernel (if pivot == 0 and halt if singular)
+valgrind ./klultest < ../Matrix/one.mtx
+
+# 1 in klu_z_condest:
+valgrind ./klultest < ../Matrix/1c.mtx
+
+# 1 in klu_z_condest:
+valgrind ./klultest < ../Matrix/ctina.mtx
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/vklutests b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/vklutests
new file mode 100644
index 0000000000000000000000000000000000000000..7dfada9023b2f957a6a5401d803bc74ec069d17b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/Tcov/vklutests
@@ -0,0 +1,31 @@
+#!/bin/csh
+
+# 57 unique statements:
+valgrind ./klutest < ../Matrix/impcol_a.mtx
+
+# 20:
+valgrind ./klutest < ../Matrix/GD99_cc.mtx
+
+# 17:
+valgrind ./klutest < ../Matrix/two.mtx
+
+# 10:
+valgrind ./klutest < ../Matrix/w156.mtx
+
+# 3, xsize memgrow in klu_kernel
+valgrind ./klutest < ../Matrix/arrow.mtx
+
+# 3, xsize memgrow in klu_kernel, 1 in klu_z_condest,
+valgrind ./klutest < ../Matrix/arrowc.mtx
+
+# 2 in klu_z_kernel (if pivot == 0 and halt_if_singular, and in complex divide)
+valgrind ./klutest < ../Matrix/onec.mtx
+
+# 1 in klu_kernel (if pivot == 0 and halt if singular)
+valgrind ./klutest < ../Matrix/one.mtx
+
+# 1 in klu_z_condest:
+valgrind ./klutest < ../Matrix/1c.mtx
+
+# 1 in klu_z_condest:
+valgrind ./klutest < ../Matrix/ctina.mtx
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/User/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/User/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..04195b8e1228781dd2b60e951312a4ad17053a67
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/KLU/User/README.txt
@@ -0,0 +1,4 @@
+This directory contains a sample user-ordering function, klu_cholmod.
+Its use (and the use of CHOLMOD) is optional.
+
+Timothy A. Davis, http://www.suitesparse.com
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/LICENSE.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..101db2442cce844c478028a70c9af18a0434e928
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/LICENSE.txt
@@ -0,0 +1,955 @@
+==> AMD/Doc/License.txt <==
+    AMD, Copyright (c), 1996-2015, Timothy A. Davis,
+    Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+
+    AMD License: At the user's option, you may use AMD under either the LGPL
+    version 2.1 license, or the BSD 3-clause license.  You may not use both
+    licenses, nor may you mix-and-match clauses from each license.  To use a
+    license, in the documentation for your application simply state either of the
+    following, replacing <YOUR APPLICATION> with the name of your application:
+
+        AMD, Copyright (c), 1996-2015, Timothy A. Davis,
+        Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+        Used in <YOUR APPLICATION> under the BSD 3-clause license.
+
+    or
+
+        AMD, Copyright (c), 1996-2015, Timothy A. Davis,
+        Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+        Used in <YOUR APPLICATION> under the LGPL v2.1 license.
+
+    In the event that your package <A> includes another package <B> by another
+    author, and <A> and <B> use AMD under different licenses, you may select
+    one license to apply to both uses of AMD in the combined application.
+
+    Availability:
+
+        http://www.suitesparse.com
+
+    -------------------------------------------------------------------------------
+    BSD 3-clause:
+    -------------------------------------------------------------------------------
+
+        Copyright (c), 1996-2015, Timothy A. Davis,
+        Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+            * Redistributions of source code must retain the above copyright
+              notice, this list of conditions and the following disclaimer.
+            * Redistributions in binary form must reproduce the above copyright
+              notice, this list of conditions and the following disclaimer in the
+              documentation and/or other materials provided with the distribution.
+            * Neither the name of the organizations to which the authors are
+              affiliated, nor the names of its contributors may be used to endorse
+              or promote products derived from this software without specific prior
+              written permission.
+
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+        ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+        DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+        LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+        OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+        DAMAGE.
+
+    -------------------------------------------------------------------------------
+    LGPL version 2.1:
+    -------------------------------------------------------------------------------
+
+        Your use or distribution of AMD or any modified version of
+        AMD implies that you agree to this License.
+
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public
+        License as published by the Free Software Foundation; either
+        version 2.1 of the License, or (at your option) any later version.
+
+        This library is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+        Lesser General Public License for more details.
+
+        You should have received a copy of the GNU Lesser General Public
+        License along with this library; if not, write to the Free Software
+        Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+        USA
+
+        Permission is hereby granted to use or copy this program under the
+        terms of the GNU LGPL, provided that the Copyright, this License,
+        and the Availability of the original version is retained on all copies.
+        User documentation of any code that uses this code or any modified
+        version of this code must cite the Copyright, this License, the
+        Availability note, and "Used by permission." Permission to modify
+        the code and to distribute modified code is granted, provided the
+        Copyright, this License, and the Availability note are retained,
+        and a notice that the code was modified is included.
+
+    -------------------------------------------------------------------------------
+
+==> BTF/Doc/License.txt <==
+    BTF, Copyright (C) 2004-2013, University of Florida
+    by Timothy A. Davis and Ekanathan Palamadai.
+    BTF is also available under other licenses; contact authors for details.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    BTF is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    BTF is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> CAMD/Doc/License.txt <==
+    CAMD, Copyright (c) by Timothy A. Davis,
+    Yanqing Chen,
+    Patrick R. Amestoy, and Iain S. Duff.  All Rights Reserved.
+    CAMD is available under alternate licenses, contact T. Davis for details.
+
+    CAMD License:
+
+        Your use or distribution of CAMD or any modified version of
+        CAMD implies that you agree to this License.
+
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public
+        License as published by the Free Software Foundation; either
+        version 2.1 of the License, or (at your option) any later version.
+
+        This library is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+        Lesser General Public License for more details.
+
+        You should have received a copy of the GNU Lesser General Public
+        License along with this library; if not, write to the Free Software
+        Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+        USA
+
+        Permission is hereby granted to use or copy this program under the
+        terms of the GNU LGPL, provided that the Copyright, this License,
+        and the Availability of the original version is retained on all copies.
+        User documentation of any code that uses this code or any modified
+        version of this code must cite the Copyright, this License, the
+        Availability note, and "Used by permission." Permission to modify
+        the code and to distribute modified code is granted, provided the
+        Copyright, this License, and the Availability note are retained,
+        and a notice that the code was modified is included.
+
+    Availability:
+
+        http://www.suitesparse.com
+
+    -------------------------------------------------------------------------------
+
+==> CCOLAMD/Doc/License.txt <==
+    CCOLAMD: constrained column approximate minimum degree ordering
+    Copyright (C) 2005-2016, Univ. of Florida.  Authors: Timothy A. Davis,
+    Sivasankaran Rajamanickam, and Stefan Larimore.  Closely based on COLAMD by
+    Davis, Stefan Larimore, in collaboration with Esmond Ng, and John Gilbert.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    CCOLAMD is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    CCOLAMD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> CHOLMOD/Doc/License.txt <==
+        --------------------------------------------------------------------------------
+        ==> Check/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Check Module.  Copyright (C) 2005-2006, Timothy A. Davis CHOLMOD is
+            also available under other licenses; contact authors for details.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Check module only.
+            All CHOLMOD modules are licensed separately.
+
+            ----------------------------------------------------------------------------
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU Lesser General Public
+            License as published by the Free Software Foundation; either
+            version 2.1 of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+            Lesser General Public License for more details.
+
+            You should have received a copy of the GNU Lesser General Public
+            License along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+        --------------------------------------------------------------------------------
+        ==> Cholesky/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Cholesky module, Copyright (C) 2005-2006, Timothy A. Davis.
+            CHOLMOD is also available under other licenses; contact authors for
+            details.  http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Cholesky module only.
+            All CHOLMOD modules are licensed separately.
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU Lesser General Public
+            License as published by the Free Software Foundation; either
+            version 2.1 of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+            Lesser General Public License for more details.
+
+            You should have received a copy of the GNU Lesser General Public
+            License along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+        --------------------------------------------------------------------------------
+        ==> Core/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Core Module.  Copyright (C) 2005-2006, Univ. of Florida.  Author:
+            Timothy A. Davis.  CHOLMOD is also available under other licenses; contact
+            authors for details.  http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Core module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU Lesser General Public
+            License as published by the Free Software Foundation; either
+            version 2.1 of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+            Lesser General Public License for more details.
+
+            You should have received a copy of the GNU Lesser General Public
+            License along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+        --------------------------------------------------------------------------------
+        ==> Demo/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Demo Module.  Copyright (C) 2005-2006, Timothy A. Davis.  CHOLMOD
+            is also available under other licenses; contact authors for details.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Demo module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+        --------------------------------------------------------------------------------
+        ==> Include/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Include/* files.  Copyright (C) 2005-2006, either Univ. of Florida
+            or T. Davis, depending on the file.
+
+            Each file is licensed separately, according to the Module for which it
+            contains definitions and prototypes:
+
+            Include/cholmod.h               LGPL
+            Include/cholmod_blas.h          LGPL
+            Include/cholmod_camd.h          part of Partition module
+            Include/cholmod_check.h         part of Check module
+            Include/cholmod_cholesky.h      part of Cholesky module
+            Include/cholmod_complexity.h    LGPL
+            Include/cholmod_config.h        LGPL
+            Include/cholmod_core.h          part of Core module
+            Include/cholmod_function.h      no license; freely usable, no restrictions
+            Include/cholmod_gpu.h           part of GPU module
+            Include/cholmod_gpu_kernels.h   part of GPU module
+            Include/cholmod_internal.h      LGPL
+            Include/cholmod_io64.h          LGPL
+            Include/cholmod_matrixops.h     part of MatrixOps module
+            Include/cholmod_modify.h        part of Modify module
+            Include/cholmod_partition.h     part of Partition module
+            Include/cholmod_supernodal.h    part of Supernodal module
+            Include/cholmod_template.h      LGPL
+
+        --------------------------------------------------------------------------------
+        ==> MATLAB/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/MATLAB Module.  Copyright (C) 2005-2006, Timothy A. Davis.  CHOLMOD
+            is also available under other licenses; contact authors for details.
+            MATLAB(tm) is a Registered Trademark of The MathWorks, Inc.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/MATLAB module only.
+            All CHOLMOD modules are licensed separately.
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+        --------------------------------------------------------------------------------
+        ==> MatrixOps/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/MatrixOps Module.  Copyright (C) 2005-2006, Timothy A. Davis.
+            CHOLMOD is also available under other licenses; contact authors for
+            details.  http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/MatrixOps module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+        --------------------------------------------------------------------------------
+        ==> Modify/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Modify Module.  Copyright (C) 2005-2006, Timothy A. Davis and
+            William W. Hager.  CHOLMOD is also available under other licenses; contact
+            authors for details.  http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Modify module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+        --------------------------------------------------------------------------------
+        ==> Partition/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Partition Module.
+            Copyright (C) 2005-2006, Univ. of Florida.  Author: Timothy A. Davis
+            CHOLMOD is also available under other licenses; contact authors for details.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Partition module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU Lesser General Public
+            License as published by the Free Software Foundation; either
+            version 2.1 of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+            Lesser General Public License for more details.
+
+            You should have received a copy of the GNU Lesser General Public
+            License along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+        --------------------------------------------------------------------------------
+        ==> Supernodal/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Supernodal Module.
+            Copyright (C) 2005-2006, Timothy A. Davis
+            CHOLMOD is also available under other licenses; contact authors for details.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Supernodal module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+        --------------------------------------------------------------------------------
+        ==> Tcov/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Tcov Module.  Copyright (C) 2005-2006, Timothy A. Davis
+            CHOLMOD is also available under other licenses; contact authors for details.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Tcov module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+        --------------------------------------------------------------------------------
+        ==> Valgrind/License.txt <==
+        --------------------------------------------------------------------------------
+
+            CHOLMOD/Valgrind Module.  Copyright (C) 2005-2006, Timothy A. Davis.
+            CHOLMOD is also available under other licenses; contact authors for details.
+            http://www.suitesparse.com
+
+            Note that this license is for the CHOLMOD/Valgrind module only.
+            All CHOLMOD modules are licensed separately.
+
+
+            ----------------------------------------------------------------------------
+
+
+            This Module is free software; you can redistribute it and/or
+            modify it under the terms of the GNU General Public License
+            as published by the Free Software Foundation; either version 2
+            of the License, or (at your option) any later version.
+
+            This Module is distributed in the hope that it will be useful,
+            but WITHOUT ANY WARRANTY; without even the implied warranty of
+            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            GNU General Public License for more details.
+
+            You should have received a copy of the GNU General Public License
+            along with this Module; if not, write to the Free Software
+            Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
+
+==> COLAMD/Doc/License.txt <==
+    COLAMD, Copyright 1998-2016, Timothy A. Davis.  http://www.suitesparse.com
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    COLAMD is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    COLAMD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> CSparse/Doc/License.txt <==
+    CSparse: a Concise Sparse matrix package.
+    Copyright (c) 2006, Timothy A. Davis.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    CSparse is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    CSparse is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> CXSparse/Doc/License.txt <==
+    CXSparse: a Concise Sparse matrix package - Extended.
+    Copyright (c) 2006, Timothy A. Davis.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    CXSparse is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    CXSparse is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> CXSparse_newfiles/Doc/License.txt <==
+    CXSparse: a Concise Sparse matrix package - Extended.
+    Copyright (c) 2006, Timothy A. Davis.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    CXSparse is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    CXSparse is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> GPUQREngine/Doc/License.txt <==
+    GPUQREngine Copyright (c) 2013, Timothy A. Davis, Sencer Nuri Yeralan,
+    and Sanjay Ranka.
+    http://www.suitesparse.com
+
+    GPUQREngine is free software; you can redistribute it and/or modify it under
+    the terms of the GNU General Public License as published by the Free Software
+    Foundation; either version 2 of the License, or (at your option) any later
+    version.
+
+    GPUQREngine is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along with
+    this Module; if not, write to the Free Software Foundation, Inc., 51 Franklin
+    Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+
+==> KLU/Doc/License.txt <==
+    KLU, Copyright (C) 2004-2013, University of Florida
+    by Timothy A. Davis and Ekanathan Palamadai.
+    KLU is also available under other licenses; contact authors for details.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    KLU is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    KLU is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> LDL/Doc/License.txt <==
+    LDL Copyright (c) 2005-2013 by Timothy A. Davis.
+    LDL is also available under other licenses; contact the author for details.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    LDL is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    LDL is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+==> MATLAB_Tools/Doc/License.txt <==
+    The MATLAB_Tools collection of packages is
+    Copyright (c), Timothy A. Davis, All Rights Reserved,
+    with the exception of the spqr_rank package, which is
+    Copyright (c), Timothy A. Davis and Les Foster, All Rights Reserved,
+
+    All packages are available under alternative licenses.
+    Contact the authors for details.
+
+    --------------------------------------------------------------------------------
+    MATLAB_Tools License, with the exception of SSMULT and UFcollection:
+    --------------------------------------------------------------------------------
+
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+            * Redistributions of source code must retain the above copyright
+              notice, this list of conditions and the following disclaimer.
+            * Redistributions in binary form must reproduce the above copyright
+              notice, this list of conditions and the following disclaimer in the
+              documentation and/or other materials provided with the distribution.
+            * Neither the name of the organizations to which the authors are
+              affiliated, nor the names of its contributors may be used to endorse
+              or promote products derived from this software without specific prior
+              written permission.
+
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+        ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+        DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+        LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+        OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+        DAMAGE.
+
+    --------------------------------------------------------------------------------
+    UFcollection License:
+    --------------------------------------------------------------------------------
+
+        UFcollection is free software; you can redistribute it and/or
+        modify it under the terms of the GNU General Public License
+        as published by the Free Software Foundation; either version 2
+        of the License, or (at your option) any later version.
+
+        UFcollection is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+
+        You should have received a copy of the GNU General Public License
+        along with this package; if not, write to the Free Software Foundation,
+        Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+    --------------------------------------------------------------------------------
+    SSMULT License:
+    --------------------------------------------------------------------------------
+
+        SSMULT, Copyright (c) 2007-2011, Timothy A. Davis,
+        http://www.suitesparse.com.
+
+        SSMULT is free software; you can redistribute it and/or modify it under the
+        terms of the GNU General Public License as published by the Free Software
+        Foundation; either version 2 of the License, or (at your option) any later
+        version.
+
+        SSMULT is distributed in the hope that it will be useful, but WITHOUT ANY
+        WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+        FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+        details.
+
+        You should have received a copy of the GNU General Public License along
+        with this package; if not, write to the Free Software Foundation, Inc., 51
+        Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+
+==> RBio/Doc/License.txt <==
+    RBio toolbox.  Copyright (C) 2006-2009, Timothy A. Davis
+    RBio is also available under other licenses; contact authors for details.
+    http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    RBio is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 2
+    of the License, or (at your option) any later version.
+
+    RBio is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this Module; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+
+==> SPQR/Doc/License.txt <==
+    SPQR, Copyright 2008-2016 by Timothy A. Davis.
+    All Rights Reserved.
+    SPQR is available under alternate licenses, contact T. Davis for details.
+
+    SPQR License:
+
+        Your use or distribution of SPQR or any modified version of
+        SPQR implies that you agree to this License.
+
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU General Public
+        License as published by the Free Software Foundation; either
+        version 2 of the License, or (at your option) any later version.
+
+        This library is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+        General Public License for more details.
+
+        You should have received a copy of the GNU General Public
+        License along with this library; if not, write to the Free Software
+        Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+        USA
+
+        Permission is hereby granted to use or copy this program under the
+        terms of the GNU GPL, provided that the Copyright, this License,
+        and the Availability of the original version is retained on all copies.
+        User documentation of any code that uses this code or any modified
+        version of this code must cite the Copyright, this License, the
+        Availability note, and "Used by permission." Permission to modify
+        the code and to distribute modified code is granted, provided the
+        Copyright, this License, and the Availability note are retained,
+        and a notice that the code was modified is included.
+
+    Availability:
+
+        http://www.suitesparse.com
+
+
+==> SuiteSparse_GPURuntime/Doc/License.txt <==
+    SuiteSparse_GPURuntime Copyright (c) 2013-2016, Timothy A. Davis,
+    Sencer Nuri Yeralan, and Sanjay Ranka.  http://www.suitesparse.com
+
+    --------------------------------------------------------------------------------
+
+    SuiteSparse_GPURuntime is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option) any
+    later version.
+
+    SuiteSparse_GPURuntime is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+    details.
+
+    You should have received a copy of the GNU General Public License along with
+    this Module; if not, write to the Free Software Foundation, Inc., 51 Franklin
+    Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+==> UFget/Doc/License.txt <==
+    Copyright (c), 2009-2016, Timothy A. Davis, All Rights Reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of the organizations to which the authors are
+          affiliated, nor the names of its contributors may be used to endorse
+          or promote products derived from this software without specific prior
+          written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+    DAMAGE.
+
+
+==> UMFPACK/Doc/License.txt <==
+    UMFPACK, Copyright 1995-2009 by Timothy A. Davis.
+    All Rights Reserved.
+    UMFPACK is available under alternate licenses, contact T. Davis for details.
+
+    UMFPACK License:
+
+        Your use or distribution of UMFPACK or any modified version of
+        UMFPACK implies that you agree to this License.
+
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU General Public
+        License as published by the Free Software Foundation; either
+        version 2 of the License, or (at your option) any later version.
+
+        This library is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+        General Public License for more details.
+
+        You should have received a copy of the GNU General Public
+        License along with this library; if not, write to the Free Software
+        Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+        USA
+
+        Permission is hereby granted to use or copy this program under the
+        terms of the GNU GPL, provided that the Copyright, this License,
+        and the Availability of the original version is retained on all copies.
+        User documentation of any code that uses this code or any modified
+        version of this code must cite the Copyright, this License, the
+        Availability note, and "Used by permission." Permission to modify
+        the code and to distribute modified code is granted, provided the
+        Copyright, this License, and the Availability note are retained,
+        and a notice that the code was modified is included.
+
+    Availability:
+
+        http://www.suitesparse.com
+
+
+==> CSparse/MATLAB/UFget/Doc/License.txt <==
+    Copyright (c), 2009-2016, Timothy A. Davis, All Rights Reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of the organizations to which the authors are
+          affiliated, nor the names of its contributors may be used to endorse
+          or promote products derived from this software without specific prior
+          written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+    DAMAGE.
+
+
+==> CXSparse/MATLAB/UFget/Doc/License.txt <==
+    Copyright (c), 2009-2016, Timothy A. Davis, All Rights Reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of the organizations to which the authors are
+          affiliated, nor the names of its contributors may be used to endorse
+          or promote products derived from this software without specific prior
+          written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+    DAMAGE.
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08c2313abc581e38f2e0a6b3a793636e9d1e3486
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/README.txt
@@ -0,0 +1,321 @@
+SuiteSparse:  A Suite of Sparse matrix packages at http://www.suitesparse.com
+
+May 4, 2016.  SuiteSparse VERSION 4.5.3
+
+------------------
+SuiteSparse/README
+------------------
+
+================================================================================
+Packages in SuiteSparse, and files in this directory:
+================================================================================
+
+    AMD         approximate minimum degree ordering.  This is the built-in AMD
+                function in MATLAB.
+
+    bin         where the metis-5.1.0 programs are placed when METIS is compiled
+
+    BTF         permutation to block triangular form
+
+    CAMD        constrained approximate minimum degree ordering
+
+    CCOLAMD     constrained column approximate minimum degree ordering
+
+    ChangeLog   a summary of changes to SuiteSparse.  See */Doc/ChangeLog
+                for details for each package.
+
+    CHOLMOD     sparse Cholesky factorization.  Requires AMD, COLAMD, CCOLAMD,
+                the BLAS, and LAPACK.  Optionally uses METIS.  This is chol and
+                x=A\b in MATLAB.
+
+    COLAMD      column approximate minimum degree ordering.  This is the
+                built-in COLAMD function in MATLAB.
+
+    Contents.m  a list of contents for 'help SuiteSparse' in MATLAB.
+
+    CSparse     a concise sparse matrix package, developed for my
+                book, "Direct Methods for Sparse Linear Systems",
+                published by SIAM.  Intended primarily for teaching.
+                It does have a 'make install' but I recommend using
+                CXSparse instead.  In particular, both CSparse and CXSparse
+                have the same include filename: cs.h.
+
+                This package is used for the built-in DMPERM in MATLAB.
+
+    CSparse_to_CXSparse
+                a Perl script to create CXSparse from CSparse and
+                CXSparse_newfiles
+
+    CXSparse    CSparse Extended.  Includes support for complex matrices
+                and both int or long integers.  Use this instead of CSparse
+                for production use; it creates a libcsparse.so (or *dylib on
+                the Mac) with the same name as CSparse.  It is a superset
+                of CSparse.  Any code that links against CSparse should
+                also be able to link against CXSparse instead.
+
+    CXSparse_newfiles
+                Files unique to CXSparse
+
+    share       'make' places documentation for each package here
+
+    GPUQREngine GPU support package for SPQR (not built into MATLAB, however)
+
+    include     'make' places user-visible include fomes for each package here
+
+    KLU         sparse LU factorization, primarily for circuit simulation.
+                Requires AMD, COLAMD, and BTF.  Optionally uses CHOLMOD,
+                CAMD, CCOLAMD, and METIS.
+
+    LDL         a very concise LDL' factorization package
+
+    lib         'make' places shared libraries for each package here
+
+    Makefile    to compile all of SuiteSparse:
+                make            compiles SuiteSparse libraries and runs demos
+                make install    compiles SuiteSparse and installs in /usr/local
+                make uninstall  undoes 'make install'
+                make library    compiles SuiteSparse libraries (not demos)
+                make distclean  removes all files not in distribution, including
+                                ./bin, ./share, ./lib, and ./include.
+                make purge      same as 'make distclean'
+                make clean      removes all files not in distribution, but
+                                keeps compiled libraries and demoes, ./lib,
+                                ./share, and ./include.
+                make config     displays parameter settings; does not compile
+
+                Each individual package also has each of the above 'make'
+                targets.  Doing 'make config' in each package */Lib directory
+                displays the exact shared and static library names.
+
+                Things you don't need to do:
+                make cx         creates CXSparse from CSparse
+                make docs       creates user guides from LaTeX files
+                make cov        runs statement coverage tests (Linux only)
+                make metis      compiles METIS (also done by 'make')
+
+    MATLAB_Tools    various m-files for use in MATLAB
+
+                Contents.m      list of contents
+                dimacs10        loads matrices for DIMACS10 collection
+                Factorize       object-oriented x=A\b for MATLAB
+                find_components finds connected components in an image
+                GEE             simple Gaussian elimination
+                getversion.m    determine MATLAB version
+                gipper.m        create MATLAB archive
+                hprintf.m       print hyperlinks in command window
+                LINFACTOR       predecessor to Factorize package
+                MESHND          nested dissection ordering of regular meshes
+                pagerankdemo.m  illustrates how PageRank works
+                SFMULT          C=S*F where S is sparse and F is full
+                shellgui        display a seashell
+                sparseinv       sparse inverse subset
+                spok            check if a sparse matrix is valid
+                spqr_rank       SPQR_RANK package.  MATLAB toolbox for rank
+                                deficient sparse matrices: null spaces,
+                                reliable factorizations, etc.  With Leslie
+                                Foster, San Jose State Univ.
+                SSMULT          C=A*B where A and B are both sparse
+                UFcollection    maitains the SuiteSparse matrix collection
+                waitmex         waitbar for use inside a mexFunction
+
+                The SSMULT and SFMULT functions are the basis for the
+                built-in C=A*B functions in MATLAB.
+
+    metis-5.1.0 a modified version of METIS.  See the README.txt files for
+                details.
+
+    RBio        read/write sparse matrices in Rutherford/Boeing format
+
+    README.txt  this file
+
+    SPQR        sparse QR factorization.  This the built-in qr and x=A\b in
+                MATLAB.
+
+    SuiteSparse_config    configuration file for all the above packages.  The
+                SuiteSparse_config/SuiteSparse_config.mk is included in the
+                Makefile's of all packages.  CSparse and MATLAB_Tools do not
+                use SuiteSparse_config.
+
+    SuiteSparse_GPURuntime      GPU support package for SPQR
+                (not builtin to MATLAB, however).
+
+    SuiteSparse_install.m       install SuiteSparse for MATLAB
+
+    SuiteSparse_test.m          exhaustive test for SuiteSparse in MATLAB
+
+    UFget       MATLAB interface to the SuiteSparse Matrix Collection
+                (formerly called the UF Sparse Matrix Collection).
+
+    UMFPACK     sparse LU factorization.  Requires AMD and the BLAS.
+                This is the built-in lu and x=A\b in MATLAB.
+
+Some codes optionally use METIS 5.1.0.  This package is located in SuiteSparse
+in the metis-5.1.0 directory.  Its use is optional, so you can remove it before
+compiling SuiteSparse, if you desire.  The use of METIS will improve the
+ordering quality.  METIS has been slightly modified for use in SuiteSparse; see
+the metis-5.1.0/README.txt file for details.  SuiteSparse can use the
+unmodified METIS 5.1.0, however.  To use your own copy of METIS, or a
+pre-installed copy of METIS use 'make MY_METIS_LIB=-lmymetis' or
+'make MY_METIS_LIB=/my/stuff/metis-5.1.0/whereeveritis/libmetis.so 
+      MY_METIS_INC=/my/stuff/metis-5.1.0/include'.
+If you want to use METIS in MATLAB, however, you MUST use the version provided
+here, in SuiteSparse/metis-5.1.0.  The MATLAB interface to METIS required some
+small changes in METIS itself to get it to work.  The original METIS 5.1.0
+will segfault MATLAB.
+
+Refer to each package for license, copyright, and author information.  All
+codes are authored or co-authored by Timothy A. Davis.
+email: davis@tamu.edu
+
+Licenses for each package are located in the following files, all in
+PACKAGENAME/Doc/License.txt:
+
+    AMD/Doc/License.txt
+    BTF/Doc/License.txt
+    CAMD/Doc/License.txt
+    CCOLAMD/Doc/License.txt
+    CHOLMOD/Doc/License.txt
+    COLAMD/Doc/License.txt
+    CSparse/Doc/License.txt
+    CXSparse/Doc/License.txt
+    GPUQREngine/Doc/License.txt
+    KLU/Doc/License.txt
+    LDL/Doc/License.txt
+    MATLAB_Tools/Doc/License.txt
+    RBio/Doc/License.txt
+    SPQR/Doc/License.txt
+    SuiteSparse_GPURuntime/Doc/License.txt
+    UFget/Doc/License.txt
+    UMFPACK/Doc/License.txt
+
+These files are also present, but they are simply copies of the above license
+files for CXSparse and UFget:
+
+    CXSparse_newfiles/Doc/License.txt
+    CSparse/MATLAB/UFget/Doc/License.txt
+    CXSparse/MATLAB/UFget/Doc/License.txt
+
+METIS 5.0.1 is distributed with SuiteSparse, and is Copyright (c)
+by George Karypis.  Please refer to that package for its License.
+
+================================================================================
+QUICK START FOR MATLAB USERS (Linux, Mac, or Windows):  uncompress the
+SuiteSparse.zip or SuiteSparse.tar.gz archive file (they contain the same
+thing), then in the MATLAB Command Window, cd to the SuiteSparse directory and
+type SuiteSparse_install.  All packages will be compiled, and several demos
+will be run.  To run a (long!) exhaustive test, do SuiteSparse_test.
+================================================================================
+
+
+================================================================================
+QUICK START FOR THE C/C++ LIBRARIES:  Just type 'make' in this directory.  All
+libraries will be created and copied into SuiteSparse/lib.  All include files
+need by the applications that use SuiteSparse are copied into
+SuiteSparse/include.   All user documenation is copied into SuiteSparse/doc.
+Any program that uses SuiteSparse can thus use a simpler rule as compared to
+earlier versions of SuiteSparse.  If you add /home/myself/SuiteSparse/lib to
+your library search patch, you can do the following (for example):
+
+    S = /home/myself/SuiteSparse
+    cc myprogram.c -I$(S)/include -lumfpack -lamd -lcholmod -lsuitesparseconfig -lm
+
+Do 'make install' if you want to install the libraries and include files in
+SuiteSparse/lib and SuiteSparse/include, and the documentation in
+SuiteSparse/doc/suitesparse-VERSION.
+This will work on Linux/Unix and the Mac.  It should automatically detect if
+you have the Intel compilers or not, and whether or not you have CUDA.  If this
+fails, see the SuiteSparse_config/SuiteSparse_config.mk file.  There are many
+options that you can either list on the 'make' command line, or you can just
+edit that file.  For example, to compile with your own BLAS:
+
+    make BLAS=-lmyblaslibraryhere
+
+To list all configuration options (but not compile anything), do:
+
+    make config
+
+Any parameter you see in the output of 'make config' with an equal sign
+can be modified at the 'make' command line.
+
+If you do "make install" by itself, then the packages are all installed in
+SuiteSparse/lib (libraries), SuiteSparse/include (include *.h files), and
+SuiteSparse/doc/suitesparse-VERSION (documentation).  If you want to install
+elsewhere, do:
+
+    make install INSTALL=/my/path
+
+which puts the files in /my/path/lib, /my/path/include, and /my/path/doc.
+If you want to selectively put the libraries, include files, and doc files
+in different locations, do:
+
+    make install INSTALL_LIB=/my/libs INSTALL_INCLUDE=/myotherstuff/include INSTALL_DOC=/mydocs
+
+for example.  Any term not defined will be set to its default, so if you don't
+want to install the documentation, but wish to install the libraries and
+includes in /usr/local/lib and /usr/local/include, do:
+
+    make install INSTALL_DOC=/tmp/doc
+
+which copies the documentation to /tmp/doc where you can then remove it later.
+
+Both the static (*.a) and shared (*.so) libraries are compiled.  The *.a
+libraries are left in the package Lib folder (AMD/Lib/libamd.a for example).
+The main exception to this rule is the SuiteSparse_config library, which is in
+SuiteSparse/libsuiteSparseconfig.a.  SuiteSparse_config is required by all
+packages.  The (extremely) optional xerbla library is also an exception, but it
+is highly unlikely that you need that library.
+
+The 'make uninstall' takes the same command-line arguments.
+
+----------------------------------
+Step-by-step details:
+----------------------------------
+
+(1) Use the right BLAS and LAPACK libraries
+
+    Determine where your BLAS and LAPACK libraries are.  If the default
+    'make' does not find them, use
+    'make BLAS=-lmyblaslibraryhere LAPACK=-lmylapackgoeshere'
+
+(2) Install Intel's Threading Building Blocks (TBB)
+
+    This is optionally used by SuiteSparseQR.  Refer to the User Guide in 
+    SuiteSparse/SPQR/Doc/spqr_user_guide.pdf for details.
+
+(3) Determine what other command line options you need for 'make'.  All options
+    can be set at the 'make' command line without the need to edit this file.
+    Browse that file to see what options you can control.  If you choose
+    different options and wish to recompile, be sure to do 'make distclean' in
+    this directory first, to remove all files not in the original distribution.
+
+(4) Type "make" in this directory.  All packages will be be compiled.  METIS
+    5.1.0 will be compiled if you have it (note that METIS require CMake to
+    build it).  Several demos will be run.
+
+    To compile just the libraries, without running any demos, use
+    "make library".
+
+    The libraries will appear in */Lib/*.so.* (*.dylib for the Mac).  Include
+    files, as needed by user programs that use CHOLMOD, AMD, CAMD, COLAMD,
+    CCOLAMD, BTF, KLU, UMFPACK, LDL, etc. are in */Include/*.h.  The include
+    files required by user programs are then copied into SuiteSparse/include,
+    and the compiled libraries are copied into SuiteSparse/lib.  Documentation
+    is copied into SuiteSparse/doc.
+
+    NOTE: on Linux, you may see some errors when you compile METIS
+    ('make: *** No rule to make target 'w'.).  You can safely ignore those
+    errors.
+
+(6) To install, type "make install".  This will place copies of all
+    libraries in SuiteSparse/lib, and all include files in SuiteSparse/include,
+    and all documentation in SuiteSparse/doc/suitesparse-VERSION.  You can
+    change the install location by "make install INSTALL=/my/path" which puts
+    the libraries in /my/path/lib, the include files in /my/path/include, and
+    documentation in /my/path/doc.  These directories are created if they do
+    not already exist.
+
+(7) To uninstall, type "make uninstall", which reverses "make install"
+    by removing the SuiteSparse libraries, include files, and documentation
+    from the place they were installed.  If you pass INSTALL_***= options
+    to 'make install', you must pass the same to 'make uninstall'.
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/README.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a76a5fab68ec0095a53b2986891dc510978f7041
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/README.txt
@@ -0,0 +1,51 @@
+SuiteSparse_config, 2016, Timothy A. Davis, http://www.suitesparse.com
+(formerly the UFconfig package)
+
+This directory contains a default SuiteSparse_config.mk file.  It tries to
+detect your system (Linux, SunOS, or Mac), which compiler to use (icc or cc),
+which BLAS and LAPACK library to use (OpenBLAS or MKL), and whether or not to
+compile with CUDA.
+
+For alternatives, see the comments in the SuiteSparse_config.mk file.
+
+License: No licensing restrictions apply to this file or to the
+SuiteSparse_config directory.
+
+--------------------------------------------------------------------------------
+
+SuiteSparse_config contains configuration settings for all many of the software
+packages that I develop or co-author.  Note that older versions of some of
+these packages do not require SuiteSparse_config.
+
+  Package  Description
+  -------  -----------
+  AMD      approximate minimum degree ordering
+  CAMD     constrained AMD
+  COLAMD   column approximate minimum degree ordering
+  CCOLAMD  constrained approximate minimum degree ordering
+  UMFPACK  sparse LU factorization, with the BLAS
+  CXSparse int/long/real/complex version of CSparse
+  CHOLMOD  sparse Cholesky factorization, update/downdate
+  KLU      sparse LU factorization, BLAS-free
+  BTF      permutation to block triangular form
+  LDL      concise sparse LDL'
+  LPDASA   LP Dual Active Set Algorithm
+  RBio     read/write files in Rutherford/Boeing format
+  SPQR     sparse QR factorization (full name: SuiteSparseQR)
+
+SuiteSparse_config is not required by these packages:
+
+  CSparse       a Concise Sparse matrix package
+  MATLAB_Tools  toolboxes for use in MATLAB
+
+In addition, the xerbla/ directory contains Fortan and C versions of the
+BLAS/LAPACK xerbla routine, which is called when an invalid input is passed to
+the BLAS or LAPACK.  The xerbla provided here does not print any message, so
+the entire Fortran I/O library does not need to be linked into a C application.
+Most versions of the BLAS contain xerbla, but those from K. Goto do not.  Use
+this if you need too.
+
+If you edit this directory (SuiteSparse_config.mk in particular) then you
+must do "make purge ; make" in the parent directory to recompile all of
+SuiteSparse.  Otherwise, the changes will not necessarily be applied.
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/SuiteSparse_config.mk b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/SuiteSparse_config.mk
new file mode 100644
index 0000000000000000000000000000000000000000..67894c3737eeece3acc62061aa3c46dee2aa360e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/SuiteSparse_config.mk
@@ -0,0 +1,602 @@
+#===============================================================================
+# SuiteSparse_config.mk:  common configuration file for the SuiteSparse
+#===============================================================================
+
+# This file contains all configuration settings for all packages in SuiteSparse,
+# except for CSparse (which is stand-alone) and the packages in MATLAB_Tools.
+
+SUITESPARSE_VERSION = 4.5.3
+
+#===============================================================================
+# Options you can change without editing this file:
+#===============================================================================
+
+    # To list the options you can modify at the 'make' command line, type
+    # 'make config', which also lists their default values.  You can then
+    # change them with 'make OPTION=value'.  For example, to use an INSTALL
+    # path of /my/path, and to use your own BLAS and LAPACK libraries, do:
+    #
+    #   make install INSTALL=/my/path BLAS=-lmyblas LAPACK=-lmylapackgoeshere
+    #
+    # which will install the package into /my/path/lib and /my/path/include,
+    # and use -lmyblas -lmylapackgoes here when building the demo program.
+
+#===============================================================================
+# Defaults for any system
+#===============================================================================
+
+    #---------------------------------------------------------------------------
+    # SuiteSparse root directory
+    #---------------------------------------------------------------------------
+
+    # Most Makefiles are in SuiteSparse/Pkg/Lib or SuiteSparse/Pkg/Demo, so
+    # the top-level of SuiteSparse is in ../.. unless otherwise specified.
+    # This is true for all but the SuiteSparse_config package.
+    SUITESPARSE ?= $(realpath $(CURDIR)/../..)
+
+    #---------------------------------------------------------------------------
+    # installation location
+    #---------------------------------------------------------------------------
+
+    # For "make install" and "make uninstall", the default location is
+    # SuiteSparse/lib, SuiteSparse/include, and
+    # SuiteSparse/share/doc/suitesparse-x.y.z
+    # If you do this:
+    #    make install INSTALL=/usr/local
+    # then the libraries are installed in /usr/local/lib, include files in
+    # /usr/local/include, and documentation in
+    # /usr/local/share/doc/suitesparse-x.y.z.
+    # You can instead specify the install location of each of these 3 components
+    # separately, via (for example):
+    #    make install INSTALL_LIB=/yada/mylibs INSTALL_INCLUDE=/yoda/myinc  \
+    #                 INSTALL_DOC=/solo/mydox
+    # which puts the libraries in /yada/mylibs, include files in /yoda/myinc,
+    # and documentation in /solo/mydox.
+    INSTALL ?= $(SUITESPARSE)
+    INSTALL_LIB ?= $(INSTALL)/lib
+    INSTALL_INCLUDE ?= $(INSTALL)/include
+    INSTALL_DOC ?= $(INSTALL)/share/doc/suitesparse-$(SUITESPARSE_VERSION)
+
+    #---------------------------------------------------------------------------
+    # optimization level
+    #---------------------------------------------------------------------------
+
+    OPTIMIZATION ?= -O3
+
+    #---------------------------------------------------------------------------
+    # statement coverage for */Tcov
+    #---------------------------------------------------------------------------
+
+    ifeq ($(TCOV),yes)
+        # Each package has a */Tcov directory for extensive testing, including
+        # statement coverage.  The Tcov tests require Linux and gcc, and use
+        # the vanilla BLAS.  For those tests, the packages use 'make TCOV=yes',
+        # which overrides the following settings:
+        MKLROOT =
+        AUTOCC = no
+        CC = gcc
+        CXX = g++
+        BLAS = -lrefblas -lgfortran -lstdc++
+        LAPACK = -llapack
+	CFLAGS += --coverage
+	OPTIMIZATION = -g
+	LDFLAGS += --coverage
+    endif
+
+    #---------------------------------------------------------------------------
+    # CFLAGS for the C/C++ compiler
+    #---------------------------------------------------------------------------
+
+    # The CF macro is used by SuiteSparse Makefiles as a combination of
+    # CFLAGS, CPPFLAGS, TARGET_ARCH, and system-dependent settings.
+    CF ?= $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) $(OPTIMIZATION) -fexceptions -fPIC
+
+    #---------------------------------------------------------------------------
+    # OpenMP is used in CHOLMOD
+    #---------------------------------------------------------------------------
+
+    # with gcc, enable OpenMP directives via -fopenmp
+    # This is not supported on Darwin, so this string is cleared, below.
+    CFOPENMP ?= -fopenmp
+
+    #---------------------------------------------------------------------------
+    # compiler
+    #---------------------------------------------------------------------------
+
+    # By default, look for the Intel compilers.  If present, they are used
+    # instead of $(CC), $(CXX), and $(F77).  To disable this feature and
+    # use the $(CC), $(CXX), and $(F77) compilers, use 'make AUTOCC=no'
+
+    AUTOCC ?= yes
+
+    ifneq ($(AUTOCC),no)
+        ifneq ($(shell which icc 2>/dev/null),)
+            # use the Intel icc compiler for C codes, and -qopenmp for OpenMP
+            CC = icc -D_GNU_SOURCE
+            CXX = $(CC)
+            CFOPENMP = -qopenmp -I$(MKLROOT)/include
+        endif
+        ifneq ($(shell which ifort 2>/dev/null),)
+            # use the Intel ifort compiler for Fortran codes
+            F77 = ifort
+        endif
+    endif
+
+    #---------------------------------------------------------------------------
+    # code formatting (for Tcov only)
+    #---------------------------------------------------------------------------
+
+    PRETTY ?= grep -v "^\#" | indent -bl -nce -bli0 -i4 -sob -l120
+
+    #---------------------------------------------------------------------------
+    # required libraries
+    #---------------------------------------------------------------------------
+
+    # SuiteSparse requires the BLAS, LAPACK, and -lm (Math) libraries.
+    # It places its shared *.so libraries in SuiteSparse/lib.
+    # Linux also requires the -lrt library (see below)
+    LDLIBS ?= -lm
+    LDFLAGS += -L$(INSTALL_LIB)
+
+    # See http://www.openblas.net for a recent and freely available optimzed
+    # BLAS.  LAPACK is at http://www.netlib.org/lapack/ .  You can use the
+    # standard Fortran LAPACK along with OpenBLAS to obtain very good
+    # performance.  This script can also detect if the Intel MKL BLAS is
+    # installed.
+
+    LAPACK ?= -llapack
+
+    ifndef BLAS
+        ifdef MKLROOT
+            # use the Intel MKL for BLAS and LAPACK
+            # using static linking:
+            # BLAS = -Wl,--start-group \
+            #   $(MKLROOT)/lib/intel64/libmkl_intel_lp64.a \
+            #   $(MKLROOT)/lib/intel64/libmkl_core.a \
+            #   $(MKLROOT)/lib/intel64/libmkl_intel_thread.a \
+            #   -Wl,--end-group -lpthread -lm
+            # using dynamic linking:
+            BLAS = -lmkl_intel_lp64 -lmkl_core -lmkl_intel_thread -lpthread -lm
+            LAPACK =
+        else
+            # use the OpenBLAS at http://www.openblas.net
+            BLAS = -lopenblas
+        endif
+    endif
+
+    # For ACML, use this instead:
+    #   make BLAS='-lacml -lgfortran'
+
+    #---------------------------------------------------------------------------
+    # shell commands
+    #---------------------------------------------------------------------------
+
+    # ranlib, and ar, for generating libraries.  If you don't need ranlib,
+    # just change it to RANLAB = echo
+    RANLIB ?= ranlib
+    ARCHIVE ?= $(AR) $(ARFLAGS)
+    CP ?= cp -f
+    MV ?= mv -f
+
+    #---------------------------------------------------------------------------
+    # Fortran compiler (not required for 'make' or 'make library')
+    #---------------------------------------------------------------------------
+
+    # A Fortran compiler is optional.  Only required for the optional Fortran
+    # interfaces to AMD and UMFPACK.  Not needed by 'make' or 'make install'
+    F77 ?= gfortran
+    F77FLAGS ?= $(FFLAGS) $(OPTIMIZATION)
+
+    #---------------------------------------------------------------------------
+    # NVIDIA CUDA configuration for CHOLMOD and SPQR
+    #---------------------------------------------------------------------------
+
+    # CUDA is detected automatically, and used if found.  To disable CUDA,
+    # use CUDA=no
+
+    ifneq ($(CUDA),no)
+        CUDA_PATH = $(shell which nvcc 2>/dev/null | sed "s/\/bin\/nvcc//")
+    endif
+
+    ifeq ($(wildcard $(CUDA_PATH)),)
+        # CUDA is not present
+        CUDA_PATH     =
+        GPU_BLAS_PATH =
+        GPU_CONFIG    =
+        CUDART_LIB    =
+        CUBLAS_LIB    =
+        CUDA_INC_PATH =
+        CUDA_INC      =
+        NVCC          = echo
+        NVCCFLAGS     =
+    else
+        # with CUDA for CHOLMOD and SPQR
+        GPU_BLAS_PATH = $(CUDA_PATH)
+        # GPU_CONFIG must include -DGPU_BLAS to compile SuiteSparse for the
+        # GPU.  You can add additional GPU-related flags to it as well.
+        # with 4 cores (default):
+        GPU_CONFIG    = -DGPU_BLAS
+        # For example, to compile CHOLMOD for 10 CPU cores when using the GPU:
+        # GPU_CONFIG  = -DGPU_BLAS -DCHOLMOD_OMP_NUM_THREADS=10
+        CUDART_LIB    = $(CUDA_PATH)/lib64/libcudart.so
+        CUBLAS_LIB    = $(CUDA_PATH)/lib64/libcublas.so
+        CUDA_INC_PATH = $(CUDA_PATH)/include/
+        CUDA_INC      = -I$(CUDA_INC_PATH)
+        NVCC          = $(CUDA_PATH)/bin/nvcc
+        NVCCFLAGS     = -Xcompiler -fPIC -O3 \
+                            -gencode=arch=compute_20,code=sm_20 \
+                            -gencode=arch=compute_30,code=sm_30 \
+                            -gencode=arch=compute_35,code=sm_35 \
+                            -gencode=arch=compute_50,code=sm_50 \
+                            -gencode=arch=compute_50,code=compute_50
+    endif
+
+    #---------------------------------------------------------------------------
+    # UMFPACK configuration:
+    #---------------------------------------------------------------------------
+
+    # Configuration for UMFPACK.  See UMFPACK/Source/umf_config.h for details.
+    #
+    # -DNBLAS       do not use the BLAS.  UMFPACK will be very slow.
+    # -D'LONGBLAS=long' or -DLONGBLAS='long long' defines the integers used by
+    #               LAPACK and the BLAS (defaults to 'int')
+    # -DNSUNPERF    do not use the Sun Perf. Library on Solaris
+    # -DNRECIPROCAL do not multiply by the reciprocal
+    # -DNO_DIVIDE_BY_ZERO   do not divide by zero
+    # -DNCHOLMOD    do not use CHOLMOD as a ordering method.  If -DNCHOLMOD is
+    #               included in UMFPACK_CONFIG, then UMFPACK does not rely on
+    #               CHOLMOD, CAMD, CCOLAMD, COLAMD, and METIS.
+
+    UMFPACK_CONFIG ?=
+
+    # For example, uncomment this line to compile UMFPACK without CHOLMOD:
+    # UMFPACK_CONFIG = -DNCHOLMOD
+    # or use 'make UMFPACK_CONFIG=-DNCHOLMOD'
+
+    #---------------------------------------------------------------------------
+    # CHOLMOD configuration
+    #---------------------------------------------------------------------------
+
+    # CHOLMOD Library Modules, which appear in -lcholmod
+    # Core       requires: none
+    # Check      requires: Core
+    # Cholesky   requires: Core, AMD, COLAMD. optional: Partition, Supernodal
+    # MatrixOps  requires: Core
+    # Modify     requires: Core
+    # Partition  requires: Core, CCOLAMD, METIS.  optional: Cholesky
+    # Supernodal requires: Core, BLAS, LAPACK
+    #
+    # CHOLMOD test/demo Modules (these do not appear in -lcholmod):
+    # Tcov       requires: Core, Check, Cholesky, MatrixOps, Modify, Supernodal
+    #            optional: Partition
+    # Valgrind   same as Tcov
+    # Demo       requires: Core, Check, Cholesky, MatrixOps, Supernodal
+    #            optional: Partition
+    #
+    # Configuration flags:
+    # -DNCHECK      do not include the Check module.
+    # -DNCHOLESKY   do not include the Cholesky module.
+    # -DNPARTITION  do not include the Partition module.
+    #               also do not include METIS.
+    # -DNCAMD       do not use CAMD & CCOLAMD in Parition Module.
+    # -DNMATRIXOPS  do not include the MatrixOps module.
+    # -DNMODIFY     do not include the Modify module.
+    # -DNSUPERNODAL do not include the Supernodal module.
+    #
+    # -DNPRINT      do not print anything.
+    # -D'LONGBLAS=long' or -DLONGBLAS='long long' defines the integers used by
+    #               LAPACK and the BLAS (defaults to 'int')
+    # -DNSUNPERF    for Solaris only.  If defined, do not use the Sun
+    #               Performance Library
+    # -DGPU_BLAS    enable the use of the CUDA BLAS
+
+    CHOLMOD_CONFIG ?= $(GPU_CONFIG)
+
+    #---------------------------------------------------------------------------
+    # SuiteSparseQR configuration:
+    #---------------------------------------------------------------------------
+
+    # The SuiteSparseQR library can be compiled with the following options:
+    #
+    # -DNPARTITION      do not include the CHOLMOD partition module
+    # -DNEXPERT         do not include the functions in SuiteSparseQR_expert.cpp
+    # -DHAVE_TBB        enable the use of Intel's Threading Building Blocks
+    # -DGPU_BLAS        enable the use of the CUDA BLAS
+
+    SPQR_CONFIG ?= $(GPU_CONFIG)
+
+    # to compile with Intel's TBB, use TBB=-ltbb SPQR_CONFIG=-DHAVE_TBB
+    TBB ?=
+
+    # TODO: this *mk file should auto-detect the presence of Intel's TBB,
+    # and set the compiler flags accordingly.
+
+#===============================================================================
+# System-dependent configurations
+#===============================================================================
+
+    #---------------------------------------------------------------------------
+    # determine what system we are on
+    #---------------------------------------------------------------------------
+
+    # To disable these auto configurations, use 'make UNAME=custom'
+
+    ifndef UNAME
+        ifeq ($(OS),Windows_NT)
+            # Cygwin Make on Windows has an $(OS) variable, but not uname.
+            # Note that this option is untested.
+            UNAME = Windows
+        else
+            # Linux and Darwin (Mac OSX) have been tested.
+            UNAME := $(shell uname)
+        endif
+    endif
+
+    #---------------------------------------------------------------------------
+    # Linux
+    #---------------------------------------------------------------------------
+
+    ifeq ($(UNAME),Linux)
+        # add the realtime library, librt, and SuiteSparse/lib
+        LDLIBS += -lrt -Wl,-rpath=$(INSTALL_LIB)
+    endif
+
+    #---------------------------------------------------------------------------
+    # Mac
+    #---------------------------------------------------------------------------
+
+    ifeq ($(UNAME), Darwin)
+        # To compile on the Mac, you must install Xcode.  Then do this at the
+        # command line in the Terminal, before doing 'make':
+        # xcode-select --install
+        CF += -fno-common
+        BLAS = -framework Accelerate
+        LAPACK = -framework Accelerate
+        # OpenMP is not yet supported by default in clang
+        CFOPENMP =
+    endif
+
+    #---------------------------------------------------------------------------
+    # Solaris
+    #---------------------------------------------------------------------------
+
+    ifeq ($(UNAME), SunOS)
+        # Using the Sun compiler and the Sun Performance Library
+        # This hasn't been tested recently.
+        # I leave it here in case you need it.  It likely needs updating.
+        CF += -fast -KPIC -xc99=%none -xlibmieee -xlibmil -m64 -Xc
+        F77FLAGS = -O -fast -KPIC -dalign -xlibmil -m64
+        BLAS = -xlic_lib=sunperf
+        LAPACK =
+        # Using the GCC compiler and the reference BLAS
+        ## CC = gcc
+        ## CXX = g++
+        ## MAKE = gmake
+        ## BLAS = -lrefblas -lgfortran
+        ## LAPACK = -llapack
+    endif
+
+    #---------------------------------------------------------------------------
+    # IBM AIX
+    #---------------------------------------------------------------------------
+
+    ifeq ($(UNAME), AIX)
+        # hasn't been tested for a very long time...
+        # I leave it here in case you need it.  It likely needs updating.
+        CF += -O4 -qipa -qmaxmem=16384 -q64 -qproto -DBLAS_NO_UNDERSCORE
+        F77FLAGS =  -O4 -qipa -qmaxmem=16384 -q64
+        BLAS = -lessl
+        LAPACK =
+    endif
+
+#===============================================================================
+# finalize the CF compiler flags
+#===============================================================================
+
+    CF += $(CFOPENMP)
+
+#===============================================================================
+# internal configuration
+#===============================================================================
+
+    # The user should not have to change these definitions, and they are
+    # not displayed by 'make config'
+
+    #---------------------------------------------------------------------------
+    # for removing files not in the distribution
+    #---------------------------------------------------------------------------
+
+    # remove object files, but keep compiled libraries via 'make clean'
+    CLEAN = *.o *.obj *.ln *.bb *.bbg *.da *.tcov *.gcov gmon.out *.bak *.d \
+        *.gcda *.gcno *.aux *.bbl *.blg *.log *.toc *.dvi *.lof *.lot
+
+    # also remove compiled libraries, via 'make distclean'
+    PURGE = *.so* *.a *.dll *.dylib *.dSYM
+
+    # location of TCOV test output
+    TCOV_TMP ?= /tmp
+
+#===============================================================================
+# Building the shared and static libraries
+#===============================================================================
+
+# How to build/install shared and static libraries for Mac and Linux/Unix.
+# This assumes that LIBRARY and VERSION have already been defined by the
+# Makefile that includes this file.
+
+SO_OPTS = $(LDFLAGS)
+
+ifeq ($(UNAME),Windows)
+    # Cygwin Make on Windows (untested)
+    AR_TARGET = $(LIBRARY).lib
+    SO_PLAIN  = $(LIBRARY).dll
+    SO_MAIN   = $(LIBRARY).$(SO_VERSION).dll
+    SO_TARGET = $(LIBRARY).$(VERSION).dll
+    SO_OPTS  += -shared \
+		-L$(SUITESPARSE)/lib
+    SO_INSTALL_NAME = echo
+else
+    # Mac or Linux/Unix
+    AR_TARGET = $(LIBRARY).a
+    ifeq ($(UNAME),Darwin)
+        # Mac
+        SO_PLAIN  = $(LIBRARY).dylib
+        SO_MAIN   = $(LIBRARY).$(SO_VERSION).dylib
+        SO_TARGET = $(LIBRARY).$(VERSION).dylib
+        SO_OPTS  += -dynamiclib -compatibility_version $(SO_VERSION) \
+                    -current_version $(VERSION) \
+                    -shared -undefined dynamic_lookup
+        # When a Mac *.dylib file is moved, this command is required
+        # to change its internal name to match its location in the filesystem:
+        SO_INSTALL_NAME = install_name_tool -id
+    else
+        # Linux and other variants of Unix
+        SO_PLAIN  = $(LIBRARY).so
+        SO_MAIN   = $(LIBRARY).so.$(SO_VERSION)
+        SO_TARGET = $(LIBRARY).so.$(VERSION)
+        SO_OPTS  += -shared -Wl,-soname -Wl,$(SO_MAIN) -Wl,--no-undefined
+        # Linux/Unix *.so files can be moved without modification:
+        SO_INSTALL_NAME = echo
+    endif
+endif
+
+#===============================================================================
+# Configure CHOLMOD/Partition module with METIS, CAMD, and CCOLAMD
+#===============================================================================
+
+# By default, SuiteSparse uses METIS 5.1.0 in the SuiteSparse/metis-5.1.0
+# directory.  SuiteSparse's interface to METIS is only through the
+# SuiteSparse/CHOLMOD/Partition module, which also requires SuiteSparse/CAMD
+# and SuiteSparse/CCOLAMD.
+#
+# If you wish to use your own pre-installed copy of METIS, use the MY_METIS_LIB
+# and MY_METIS_INC options passed to 'make'.  For example:
+#       make MY_METIS_LIB=-lmetis
+#       make MY_METIS_LIB=/home/myself/mylibraries/libmetis.so
+#       make MY_METIS_LIB='-L/home/myself/mylibraries -lmetis'
+# If you need to tell the compiler where to find the metis.h include file,
+# then add MY_METIS_INC=/home/myself/metis-5.1.0/include as well, which points
+# to the directory containing metis.h.  If metis.h is already installed in
+# a location known to the compiler (/usr/local/include/metis.h for example)
+# then you do not need to add MY_METIS_INC.
+
+I_WITH_PARTITION =
+LIB_WITH_PARTITION =
+CONFIG_PARTITION = -DNPARTITION -DNCAMD
+# check if CAMD/CCOLAMD and METIS are requested and available
+ifeq (,$(findstring -DNCAMD, $(CHOLMOD_CONFIG)))
+    # CAMD and CCOLAMD are requested.  See if they are available in
+    # SuiteSparse/CAMD and SuiteSparse/CCOLAMD
+    ifneq (, $(wildcard $(SUITESPARSE)/CAMD))
+        ifneq (, $(wildcard $(SUITESPARSE)/CCOLAMD))
+            # CAMD and CCOLAMD are requested and available
+            LIB_WITH_PARTITION = -lccolamd -lcamd
+            I_WITH_PARTITION = -I$(SUITESPARSE)/CCOLAMD/Include -I$(SUITESPARSE)/CAMD/Include
+            CONFIG_PARTITION = -DNPARTITION
+            # check if METIS is requested and available
+            ifeq (,$(findstring -DNPARTITION, $(CHOLMOD_CONFIG)))
+                # METIS is requested.  See if it is available.
+                ifneq (,$(MY_METIS_LIB))
+                    # METIS 5.1.0 is provided elsewhere, and we are not using
+                    # SuiteSparse/metis-5.1.0. To do so, we link with
+                    # $(MY_METIS_LIB) and add the -I$(MY_METIS_INC) option for
+                    # the compiler.  The latter can be empty if you have METIS
+                    # installed in a place where the compiler can find the
+                    # metis.h include file by itself without any -I option
+                    # (/usr/local/include/metis.h for example). 
+                    LIB_WITH_PARTITION += $(MY_METIS_LIB)
+                    ifneq (,$(MY_METIS_INC))
+                        I_WITH_PARTITION += -I$(MY_METIS_INC)
+                    endif
+                    CONFIG_PARTITION =
+                else
+                    # see if METIS is in SuiteSparse/metis-5.1.0
+                    ifneq (, $(wildcard $(SUITESPARSE)/metis-5.1.0))
+                        # SuiteSparse/metis5.1.0 is available
+                        ifeq ($(UNAME), Darwin)
+                            LIB_WITH_PARTITION += $(SUITESPARSE)/lib/libmetis.dylib
+                        else
+                            LIB_WITH_PARTITION += -lmetis
+                        endif
+                        I_WITH_PARTITION += -I$(SUITESPARSE)/metis-5.1.0/include
+                        CONFIG_PARTITION =
+                    endif
+                endif
+            endif
+        endif
+    endif
+endif
+
+#===============================================================================
+# display configuration
+#===============================================================================
+
+ifeq ($(LIBRARY),)
+    # placeholders, for 'make config' in the top-level SuiteSparse
+    LIBRARY=PackageNameWillGoHere
+    VERSION=x.y.z
+    SO_VERSION=x
+endif
+
+# 'make config' lists the primary installation options
+config:
+	@echo ' '
+	@echo '----------------------------------------------------------------'
+	@echo 'SuiteSparse package compilation options:'
+	@echo '----------------------------------------------------------------'
+	@echo ' '
+	@echo 'SuiteSparse Version:     ' '$(SUITESPARSE_VERSION)'
+	@echo 'SuiteSparse top folder:  ' '$(SUITESPARSE)'
+	@echo 'Package:                  LIBRARY=        ' '$(LIBRARY)'
+	@echo 'Version:                  VERSION=        ' '$(VERSION)'
+	@echo 'SO version:               SO_VERSION=     ' '$(SO_VERSION)'
+	@echo 'System:                   UNAME=          ' '$(UNAME)'
+	@echo 'Install directory:        INSTALL=        ' '$(INSTALL)'
+	@echo 'Install libraries in:     INSTALL_LIB=    ' '$(INSTALL_LIB)'
+	@echo 'Install include files in: INSTALL_INCLUDE=' '$(INSTALL_INCLUDE)'
+	@echo 'Install documentation in: INSTALL_DOC=    ' '$(INSTALL_DOC)'
+	@echo 'Optimization level:       OPTIMIZATION=   ' '$(OPTIMIZATION)'
+	@echo 'BLAS library:             BLAS=           ' '$(BLAS)'
+	@echo 'LAPACK library:           LAPACK=         ' '$(LAPACK)'
+	@echo 'Intel TBB library:        TBB=            ' '$(TBB)'
+	@echo 'Other libraries:          LDLIBS=         ' '$(LDLIBS)'
+	@echo 'static library:           AR_TARGET=      ' '$(AR_TARGET)'
+	@echo 'shared library (full):    SO_TARGET=      ' '$(SO_TARGET)'
+	@echo 'shared library (main):    SO_MAIN=        ' '$(SO_MAIN)'
+	@echo 'shared library (short):   SO_PLAIN=       ' '$(SO_PLAIN)'
+	@echo 'shared library options:   SO_OPTS=        ' '$(SO_OPTS)'
+	@echo 'shared library name tool: SO_INSTALL_NAME=' '$(SO_INSTALL_NAME)'
+	@echo 'ranlib, for static libs:  RANLIB=         ' '$(RANLIB)'
+	@echo 'static library command:   ARCHIVE=        ' '$(ARCHIVE)'
+	@echo 'copy file:                CP=             ' '$(CP)'
+	@echo 'move file:                MV=             ' '$(MV)'
+	@echo 'remove file:              RM=             ' '$(RM)'
+	@echo 'pretty (for Tcov tests):  PRETTY=         ' '$(PRETTY)'
+	@echo 'C compiler:               CC=             ' '$(CC)'
+	@echo 'C++ compiler:             CXX=            ' '$(CXX)'
+	@echo 'CUDA compiler:            NVCC=           ' '$(NVCC)'
+	@echo 'CUDA root directory:      CUDA_PATH=      ' '$(CUDA_PATH)'
+	@echo 'OpenMP flags:             CFOPENMP=       ' '$(CFOPENMP)'
+	@echo 'C/C++ compiler flags:     CF=             ' '$(CF)'
+	@echo 'LD flags:                 LDFLAGS=        ' '$(LDFLAGS)'
+	@echo 'Fortran compiler:         F77=            ' '$(F77)'
+	@echo 'Fortran flags:            F77FLAGS=       ' '$(F77FLAGS)'
+	@echo 'Intel MKL root:           MKLROOT=        ' '$(MKLROOT)'
+	@echo 'Auto detect Intel icc:    AUTOCC=         ' '$(AUTOCC)'
+	@echo 'UMFPACK config:           UMFPACK_CONFIG= ' '$(UMFPACK_CONFIG)'
+	@echo 'CHOLMOD config:           CHOLMOD_CONFIG= ' '$(CHOLMOD_CONFIG)'
+	@echo 'SuiteSparseQR config:     SPQR_CONFIG=    ' '$(SPQR_CONFIG)'
+	@echo 'CUDA library:             CUDART_LIB=     ' '$(CUDART_LIB)'
+	@echo 'CUBLAS library:           CUBLAS_LIB=     ' '$(CUBLAS_LIB)'
+	@echo 'METIS and CHOLMOD/Partition configuration:'
+	@echo 'Your METIS library:       MY_METIS_LIB=   ' '$(MY_METIS_LIB)'
+	@echo 'Your metis.h is in:       MY_METIS_INC=   ' '$(MY_METIS_INC)'
+	@echo 'METIS is used via the CHOLMOD/Partition module, configured as follows.'
+	@echo 'If the next line has -DNPARTITION then METIS will not be used:'
+	@echo 'CHOLMOD Partition config: ' '$(CONFIG_PARTITION)'
+	@echo 'CHOLMOD Partition libs:   ' '$(LIB_WITH_PARTITION)'
+	@echo 'CHOLMOD Partition include:' '$(I_WITH_PARTITION)'
+ifeq ($(TCOV),yes)
+	@echo 'TCOV=yes, for extensive testing only (gcc, g++, vanilla BLAS)'
+endif
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/xerbla/xerbla.f b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/xerbla/xerbla.f
new file mode 100644
index 0000000000000000000000000000000000000000..42720048acc0bb86e4eca97c08b17c93c7df91de
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_config/xerbla/xerbla.f
@@ -0,0 +1,46 @@
+      SUBROUTINE XERBLA( SRNAME, INFO )
+*
+*  -- LAPACK auxiliary routine (version 3.0) --
+*     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+*     Courant Institute, Argonne National Lab, and Rice University
+*     September 30, 1994
+*
+*     .. Scalar Arguments ..
+      CHARACTER*6        SRNAME
+      INTEGER            INFO
+*     ..
+*
+*  Purpose
+*  =======
+*
+*  XERBLA  is an error handler for the LAPACK routines.
+*  It is called by an LAPACK routine if an input parameter has an
+*  invalid value.  A message is printed and execution stops.
+*
+*  Installers may consider modifying the STOP statement in order to
+*  call system-specific exception-handling facilities.
+*
+*  Arguments
+*  =========
+*
+*  SRNAME  (input) CHARACTER*6
+*          The name of the routine which called XERBLA.
+*
+*  INFO    (input) INTEGER
+*          The position of the invalid parameter in the parameter list
+*          of the calling routine.
+*
+* =====================================================================
+*
+*     .. Executable Statements ..
+*
+*****      WRITE( *, FMT = 9999 )SRNAME, INFO
+*
+*****      STOP
+*
+***** 9999 FORMAT( ' ** On entry to ', A6, ' parameter number ', I2, ' had ',
+*****     $      'an illegal value' )
+*
+*     End of XERBLA
+*
+      END
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_demo.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_demo.m
new file mode 100644
index 0000000000000000000000000000000000000000..2dd77e264665aee1967574fb4f2c75f3da7aebe0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_demo.m
@@ -0,0 +1,190 @@
+function SuiteSparse_demo (matrixpath, dopause)
+%SUITESPARSE_DEMO a demo of all packages in SuiteSparse
+%
+% Example:
+%   SuiteSparse_demo
+%
+% See also umfpack, cholmod, amd, camd, colamd, ccolamd, btf, klu, spqr,
+%   CSparse, CXSparse, ldlsparse
+
+% Copyright 2015, Timothy A. Davis, http://www.suitesparse.com.
+
+if (nargin < 1 || isempty (matrixpath) || ~ischar (matrixpath))
+    try
+	% older versions of MATLAB do not have an input argument to mfilename
+	p = mfilename ('fullpath') ;
+	t = strfind (p, '/') ;
+	matrixpath = [ p(1:t(end)) 'CXSparse/Matrix' ] ;
+    catch me    %#ok
+	% mfilename failed, assume we're in the SuiteSparse directory
+	matrixpath = 'CXSparse/Matrix' ;
+    end
+end
+
+if (nargin < 2)
+    dopause = false ;
+end
+
+if (dopause)
+    input ('Hit enter to run the CXSparse demo: ', 's') ;
+end
+try
+    cs_demo (0, matrixpath)
+catch me
+    disp (me.message) ;
+    fprintf ('\nIf you have an older version of MATLAB, you must run the\n') ;
+    fprintf ('SuiteSparse_demo while in the SuiteSparse directory.\n\n') ;
+    fprintf ('CXSparse demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the UMFPACK demo: ', 's') ;
+end
+try
+    umfpack_demo (1)
+catch me
+    disp (me.message) ;
+    fprintf ('UMFPACK demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the CHOLMOD demo: ', 's') ;
+end
+try
+    cholmod_demo
+catch me
+    disp (me.message) ;
+    fprintf ('CHOLMOD demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the CHOLMOD graph partitioning demo: ', 's') ;
+end
+try
+    graph_demo
+catch me
+    disp (me.message) ;
+    fprintf ('graph_demo failed, probably because METIS not installed\n') ;
+end
+
+if (dopause)
+    input ('Hit enter to run the AMD demo: ', 's') ;
+end
+try
+    amd_demo
+catch me
+    disp (me.message) ;
+    fprintf ('AMD demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the CAMD demo: ', 's') ;
+end
+try
+    camd_demo
+catch me
+    disp (me.message) ;
+    fprintf ('CAMD demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the COLAMD demo: ', 's') ;
+end
+try
+    colamd_demo
+catch me
+    disp (me.message) ;
+    fprintf ('COLAMD demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the CCOLAMD demo: ', 's') ;
+end
+try
+    ccolamd_demo
+catch me
+    disp (me.message) ;
+    fprintf ('CCOLAMD demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the BTF demo: ', 's') ;
+end
+try
+    btf_demo
+catch me
+    disp (me.message) ;
+    fprintf ('BTF demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the KLU demo: ', 's') ;
+end
+try
+    klu_demo
+catch me
+    disp (me.message) ;
+    fprintf ('KLU demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the LDL demo: ', 's') ;
+end
+try
+    ldldemo
+catch me
+    disp (me.message) ;
+    fprintf ('LDL demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the SSMULT demo: ', 's') ;
+end
+try
+    ssmult_demo
+catch me
+    disp (me.message) ;
+    fprintf ('SSMULT demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the MESHND demo: ', 's') ;
+end
+try
+    meshnd_example
+catch me
+    disp (me.message) ;
+    fprintf ('MESHND demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the SPARSEINV demo: ', 's') ;
+end
+try
+    sparseinv_test
+catch me
+    disp (me.message) ;
+    fprintf ('SPARSEINV demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the SuiteSparseQR demo: ', 's') ;
+end
+try
+    spqr_demo
+catch me
+    disp (me.message) ;
+    fprintf ('SuiteSparseQR demo failed\n' )
+end
+
+if (dopause)
+    input ('Hit enter to run the quick spqr_rank demo: ', 's') ;
+end
+try
+    quickdemo_spqr_rank
+catch me
+    disp (me.message) ;
+    fprintf ('spqr_rank demo failed\n' )
+end
+
+fprintf ('\n\n---- SuiteSparse demos complete\n') ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_install.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_install.m
new file mode 100644
index 0000000000000000000000000000000000000000..4a5cdda4ce6585500ae33bc112a1fc0a03de4e47
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_install.m
@@ -0,0 +1,319 @@
+function SuiteSparse_install (do_demo)
+%SuiteSparse_install: compiles and installs all of SuiteSparse
+% A Suite of Sparse matrix packages, authored or co-authored by Tim Davis.
+%
+% Packages in SuiteSparse:
+%
+% UMFPACK        sparse LU factorization (multifrontal)
+% CHOLMOD        sparse Cholesky factorization, and many other operations
+% AMD            sparse symmetric approximate minimum degree ordering
+% COLAMD         sparse column approximate minimum degree ordering
+% CAMD           constrained AMD
+% CCOLAMD        constrained COLAMD
+% CSparse        a Concise Sparse matrix package (32-bit or 64-bit, real only)
+% CXSparse       extended version of CSparse (32-bit/64-bit/real/complex)
+% UFget          interface to UF Sparse Matrix Collection (MATLAB 7.0 or later)
+% KLU            sparse LU factorization (left-looking)
+% BTF            permutation to block triangular form (like dmperm)
+% LDL            sparse LDL' factorization
+% UFcollection   tools for managing the UF Sparse Matrix Collection
+% RBio           read/write Rutherford/Boeing files
+% SSMULT         sparse matrix times sparse matrix
+% MESHND         2D and 3D regular mesh generation and nested dissection
+% FACTORIZE      an object-oriented solver for x=A\b
+% SPARSEINV      sparse inverse subset; computes entries of inv(sparse(A))
+% MATLAB_Tools   various simple m-files and demos
+% SuiteSparseQR  sparse QR factorization
+% spqr_rank      MATLAB toolbox for sparse rank deficient matrices
+%
+% Example:
+%    SuiteSparse_install        % compile and prompt to run each package's demo
+%    SuiteSparse_install(0)     % compile but do not run the demo
+%    SuiteSparse_install(1)     % compile and run the demos with no prompts
+%    help SuiteSparse           % for more details
+%
+% See also AMD, COLAMD, CAMD, CCOLAMD, CHOLMOD, UMFPACK, CSPARSE, CXSPARSE,
+%      UFget, RBio, UFcollection, KLU, BTF, MESHND, SSMULT, LINFACTOR, SPOK,
+%      SPQR_RANK, SuiteSparse, SPQR, PATHTOOL, PATH, FACTORIZE, SPARSEINV.
+%
+% This script installs the full-featured CXSparse rather than CSparse.
+%
+% Copyright 1990-2015, Timothy A. Davis, http://www.suitesparse.com.
+% In collaboration with Patrick Amestoy, Yanqing Chen, Iain Duff, John Gilbert,
+% Steve Hadfield, William Hager, Stefan Larimore, Leslie Foster, Eka Palamadai
+% Natarajan, Esmond Ng, Siva Rajamanickam, Nuri Yeralan, and Sanjay Ranka.
+
+%-------------------------------------------------------------------------------
+% initializations
+%-------------------------------------------------------------------------------
+
+paths = { } ;
+SuiteSparse = pwd ;
+
+% determine the MATLAB version (6.1, 6.5, 7.0, ...)
+v = version ;
+pc = ispc ;
+
+% print the introduction
+help SuiteSparse_install
+
+fprintf ('\nInstalling SuiteSparse for MATLAB version %s\n\n', v) ;
+
+% add SuiteSparse to the path
+paths = add_to_path (paths, SuiteSparse) ;
+
+%-------------------------------------------------------------------------------
+% compile and install the packages
+%-------------------------------------------------------------------------------
+
+% compile and install UMFPACK
+try
+    paths = add_to_path (paths, [SuiteSparse '/UMFPACK/MATLAB']) ;
+    umfpack_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('UMFPACK not installed\n') ;
+end
+
+% compile and install CHOLMOD
+try
+    paths = add_to_path (paths, [SuiteSparse '/CHOLMOD/MATLAB']) ;
+    cholmod_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('CHOLMOD not installed\n') ;
+end
+
+% compile and install AMD
+try
+    paths = add_to_path (paths, [SuiteSparse '/AMD/MATLAB']) ;
+    amd_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('AMD not installed\n') ;
+end
+
+% compile and install COLAMD
+try
+    paths = add_to_path (paths, [SuiteSparse '/COLAMD/MATLAB']) ;
+    colamd_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('COLAMD not installed\n') ;
+end
+
+% compile and install CCOLAMD
+try
+    paths = add_to_path (paths, [SuiteSparse '/CCOLAMD/MATLAB']) ;
+    ccolamd_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('CCOLAMD not installed\n') ;
+end
+
+% compile and install CAMD
+try
+    paths = add_to_path (paths, [SuiteSparse '/CAMD/MATLAB']) ;
+    camd_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('CAMD not installed\n') ;
+end
+
+% install UFget, unless it's already in the path
+try
+    % if this fails, then UFget is not yet installed
+    index = UFget ;
+    fprintf ('UFget already installed:\n') ;
+    which UFget
+catch
+    index = [ ] ;
+end
+if (isempty (index))
+    % UFget is not installed.  Use SuiteSparse/UFget
+    fprintf ('Installing SuiteSparse/UFget\n') ;
+    try
+        paths = add_to_path (paths, [SuiteSparse '/UFget']) ;
+    catch me
+        disp (me.message) ;
+        fprintf ('UFget not installed\n') ;
+    end
+end
+
+% compile and install CXSparse
+try
+    paths = add_to_path (paths, [SuiteSparse '/CXSparse/MATLAB/Demo']) ;
+    paths = add_to_path (paths, [SuiteSparse '/CXSparse/MATLAB/CSparse']) ;
+    fprintf ('Compiling CXSparse:\n') ;
+    if (pc)
+	% Windows does not support ANSI C99 complex, which CXSparse requires
+	cs_make (1, 0) ;
+    else
+	cs_make (1) ;
+    end
+catch me
+    disp (me.message) ;
+    fprintf ('CXSparse not installed\n') ;
+end
+
+% compile and install LDL
+try
+    paths = add_to_path (paths, [SuiteSparse '/LDL/MATLAB']) ;
+    ldl_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('LDL not installed\n') ;
+end
+
+% compile and install BTF
+try
+    paths = add_to_path (paths, [SuiteSparse '/BTF/MATLAB']) ;
+    btf_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('BTF not installed\n') ;
+end
+
+% compile and install KLU
+try
+    paths = add_to_path (paths, [SuiteSparse '/KLU/MATLAB']) ;
+    klu_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('KLU not installed\n') ;
+end
+
+% compile and install SuiteSparseQR
+try
+    if (pc)
+        fprintf ('Note that SuiteSparseQR will not compile with the lcc\n') ;
+        fprintf ('compiler provided with MATLAB on Windows\n') ;
+    end
+    paths = add_to_path (paths, [SuiteSparse '/SPQR/MATLAB']) ;
+    spqr_make ;
+catch me
+    disp (me.message) ;
+    fprintf ('SuiteSparseQR not installed\n') ;
+end
+
+% compile and install RBio
+try
+    paths = add_to_path (paths, [SuiteSparse '/RBio/RBio']) ;
+    RBmake ;
+catch me
+    disp (me.message) ;
+    fprintf ('RBio not installed.\n') ;
+end
+
+% install MATLAB_Tools/*
+try
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/Factorize']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/MESHND']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/LINFACTOR']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/find_components']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/GEE']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/shellgui']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/waitmex']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/spqr_rank']) ;
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/spqr_rank/SJget']) ;
+    fprintf ('MATLAB_Tools installed\n') ;
+catch me
+    disp (me.message) ;
+    fprintf ('MATLAB_Tools not installed\n') ;
+end
+
+% compile and install UFcollection
+try
+    % do not try to compile with large-file I/O for MATLAB 6.5 or earlier
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/UFcollection']) ;
+    UFcollection_install (verLessThan ('matlab', '7.0')) ;
+catch me
+    disp (me.message) ;
+    fprintf ('UFcollection not installed\n') ;
+end
+
+% compile and install SSMULT
+try
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/SSMULT']) ;
+    ssmult_install ;
+catch me
+    disp (me.message) ;
+    fprintf ('SSMULT not installed\n') ;
+end
+
+% compile and install dimacs10
+try
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/dimacs10']) ;
+    dimacs10_install (0) ;
+catch me
+    disp (me.message) ;
+    fprintf ('MATLAB_Tools/dimacs10 not installed\n') ;
+end
+
+% compile and install spok
+try
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/spok']) ;
+    spok_install ;
+catch me
+    disp (me.message) ;
+    fprintf ('MATLAB_Tools/spok not installed\n') ;
+end
+
+% compile and install sparsinv
+try
+    paths = add_to_path (paths, [SuiteSparse '/MATLAB_Tools/sparseinv']) ;
+    sparseinv_install ;
+catch me
+    disp (me.message) ;
+    fprintf ('MATLAB_Tools/sparseinv not installed\n') ;
+end
+
+%-------------------------------------------------------------------------------
+% post-install wrapup
+%-------------------------------------------------------------------------------
+
+cd (SuiteSparse)
+fprintf ('SuiteSparse is now installed.\n\n') ;
+
+% run the demo, if requested
+if (nargin < 1)
+    % ask if demo should be run
+    y = input ('Hit enter to run the SuiteSparse demo (or "n" to quit): ', 's');
+    if (isempty (y))
+        y = 'y' ;
+    end
+    do_demo = (y (1) ~= 'n') ;
+    do_pause = true ;
+else
+    % run the demo without pausing
+    do_pause = false ;
+end
+if (do_demo)
+    try
+	SuiteSparse_demo ([ ], do_pause) ;
+    catch me
+        disp (me.message) ;
+	fprintf ('SuiteSparse demo failed\n') ;
+    end
+end
+
+% print the list of new directories added to the path
+fprintf ('\nSuiteSparse installation is complete.  The following paths\n') ;
+fprintf ('have been added for this session.  Use pathtool to add them\n') ;
+fprintf ('permanently.  If you cannot save the new path because of file\n');
+fprintf ('permissions, then add these commands to your startup.m file.\n') ;
+fprintf ('Type "doc startup" and "doc pathtool" for more information.\n\n') ;
+for k = 1:length (paths)
+    fprintf ('addpath %s\n', paths {k}) ;
+end
+cd (SuiteSparse)
+
+fprintf ('\nSuiteSparse for MATLAB %s installation complete\n', v) ;
+
+%-------------------------------------------------------------------------------
+function paths = add_to_path (paths, newpath)
+% add a path
+cd (newpath) ;
+addpath (newpath) ;
+paths = [paths { newpath } ] ;						    %#ok
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_test.m b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_test.m
new file mode 100644
index 0000000000000000000000000000000000000000..f277b764d2ca58680f2cb1098b05c2141bf11e2d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/SuiteSparse/SuiteSparse_test.m
@@ -0,0 +1,219 @@
+function SuiteSparse_test
+% SuiteSparse_test exhaustive test of all SuiteSparse packages
+%
+% Your current directory must be SuiteSparse for this function to work.
+% SuiteSparse_install must be run prior to running this test.  Warning:
+% this test takes a *** long **** time.
+%
+% Example:
+%   SuiteSparse_test
+%
+% See also SuiteSparse_install, SuiteSparse_demo.
+
+% Copyright 1990-2015, Timothy A. Davis, http://www.suitesparse.com.
+
+help SuiteSparse_test
+
+npackages = 18 ;
+h = waitbar (0, 'SuiteSparse test:') ;
+SuiteSparse = pwd ;
+package = 0 ;
+
+try
+
+    %---------------------------------------------------------------------------
+    % CSparse
+    %---------------------------------------------------------------------------
+
+    % compile and install CSparse (not installed by SuiteSparse_install)
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: CSparse') ;
+    addpath ([SuiteSparse '/CSparse/MATLAB/CSparse']) ;
+    addpath ([SuiteSparse '/CSparse/MATLAB/Demo']) ;
+    cd ([SuiteSparse '/CSparse/MATLAB/CSparse']) ;
+    cs_make ;
+    % test CSparse
+    cd ([SuiteSparse '/CSparse/MATLAB/Test']) ;
+    testall ;
+    % uninstall CSparse by removing it from path
+    rmpath ([SuiteSparse '/CSparse/MATLAB/CSparse']) ;
+    rmpath ([SuiteSparse '/CSparse/MATLAB/Demo']) ;
+    rmpath ([SuiteSparse '/CSparse/MATLAB/UFget']) ;
+
+    %---------------------------------------------------------------------------
+    % CXSparse
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: CXSparse') ;
+    cd ([SuiteSparse '/CXSparse/MATLAB/Test']) ;
+    testall ;
+
+    %---------------------------------------------------------------------------
+    % COLAMD
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: COLAMD') ;
+    cd ([SuiteSparse '/COLAMD/MATLAB']) ;
+    colamd_test ;
+
+    %---------------------------------------------------------------------------
+    % CCOLAMD
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: CCOLAMD') ;
+    cd ([SuiteSparse '/CCOLAMD/MATLAB']) ;
+    ccolamd_test ;
+
+    %---------------------------------------------------------------------------
+    % UMFPACK
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: UMFPACK') ;
+    cd ([SuiteSparse '/UMFPACK/MATLAB']) ;
+    umfpack_test (100) ;
+
+    %---------------------------------------------------------------------------
+    % CHOLMOD
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: CHOLMOD') ;
+    cd ([SuiteSparse '/CHOLMOD/MATLAB/Test']) ;
+    cholmod_test ;
+
+    %---------------------------------------------------------------------------
+    % BTF
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: BTF') ;
+    cd ([SuiteSparse '/BTF/MATLAB/Test']) ;
+    btf_test ;
+
+    %---------------------------------------------------------------------------
+    % KLU
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: KLU') ;
+    cd ([SuiteSparse '/KLU/MATLAB/Test']) ;
+    klu_test (100) ;
+
+    %---------------------------------------------------------------------------
+    % LDL
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: LDL') ;
+    cd ([SuiteSparse '/LDL/MATLAB']) ;
+    ldlmain2 ;
+    ldltest ;
+
+    %---------------------------------------------------------------------------
+    % LINFACTOR:  MATLAB 7.3 (R2006b) or later required
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    if (verLessThan ('matlab', '7.3'))
+        % skip test of LINFACTOR
+    else
+        waitbar (package/(npackages+1), h, 'SuiteSparse test: LINFACTOR') ;
+        cd ([SuiteSparse '/MATLAB_Tools/LINFACTOR']) ;
+        lintests ;
+    end
+
+    %---------------------------------------------------------------------------
+    % MESHND
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: MESHND') ;
+    cd ([SuiteSparse '/MATLAB_Tools/MESHND']) ;
+    meshnd_quality ;
+
+    %---------------------------------------------------------------------------
+    % SSMULT
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: SSMULT') ;
+    cd ([SuiteSparse '/MATLAB_Tools/SSMULT']) ;
+    sstest3 ;
+
+    %---------------------------------------------------------------------------
+    % other MATLAB_Tools
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: MATLAB Tools') ;
+    cd ([SuiteSparse '/MATLAB_Tools']) ;
+    fprintf ('getversion: %g\n', getversion) ;
+    seashell ;
+    shellgui ;
+    cd ([SuiteSparse '/MATLAB_Tools/waitmex']) ;
+    waitmex ;
+    url = 'http://www.suitesparse.com' ;
+    fprintf ('<a href="%s">Click here for more details</a>\n', url) ;
+    hprintf ('or see <a href="%s">\n', url) ;
+    cd ([SuiteSparse '/MATLAB_Tools/find_components']) ;
+    find_components_example (1, 0) ;
+    cd ([SuiteSparse '/MATLAB_Tools/spok']) ;
+    spok_test ;
+
+    %---------------------------------------------------------------------------
+    % FACTORIZE
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: FACTORIZE') ;
+    cd ([SuiteSparse '/MATLAB_Tools/Factorize/Test']) ;
+    test_all ;
+
+    %---------------------------------------------------------------------------
+    % SPARSEINV
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: SPARSEINV') ;
+    cd ([SuiteSparse '/MATLAB_Tools/sparseinv']) ;
+    sparseinv_test
+
+    %---------------------------------------------------------------------------
+    % SPQR_RANK
+    %---------------------------------------------------------------------------
+
+    package = package + 1 ;
+    waitbar (package/(npackages+1), h, 'SuiteSparse test: spqr_rank') ;
+    cd ([SuiteSparse '/MATLAB_Tools/spqr_rank']) ;
+    demo_spqr_rank ;
+
+    %---------------------------------------------------------------------------
+    % AMD, CAMD, UFcollection, UFget
+    %---------------------------------------------------------------------------
+
+    % no exhaustive tests; tested via other packages
+
+catch                                                                       %#ok
+
+    %---------------------------------------------------------------------------
+    % test failure
+    %---------------------------------------------------------------------------
+
+    cd (SuiteSparse) ;
+    disp (lasterr) ;                                                        %#ok
+    fprintf ('SuiteSparse test: FAILED\n') ;
+    return
+
+end
+
+%-------------------------------------------------------------------------------
+% test OK
+%-------------------------------------------------------------------------------
+
+close (h) ;
+fprintf ('SuiteSparse test: OK\n') ;
+cd (SuiteSparse) ;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/gsl/gsl/gsl-lite.hpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/gsl/gsl/gsl-lite.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..825087cabd40f95415db8b25487822cb954fd510
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/gsl/gsl/gsl-lite.hpp
@@ -0,0 +1,2857 @@
+//
+// gsl-lite is based on GSL: Guidelines Support Library.
+// For more information see https://github.com/martinmoene/gsl-lite
+//
+// Copyright (c) 2015-2018 Martin Moene
+// Copyright (c) 2015-2018 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma once
+
+#ifndef GSL_GSL_LITE_HPP_INCLUDED
+#define GSL_GSL_LITE_HPP_INCLUDED
+
+#include <algorithm>
+#include <exception>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#define  gsl_lite_MAJOR  0
+#define  gsl_lite_MINOR  34
+#define  gsl_lite_PATCH  0
+
+#define  gsl_lite_VERSION  gsl_STRINGIFY(gsl_lite_MAJOR) "." gsl_STRINGIFY(gsl_lite_MINOR) "." gsl_STRINGIFY(gsl_lite_PATCH)
+
+// gsl-lite backward compatibility:
+
+#ifdef gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
+# define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR  gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
+# pragma message ("gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR is deprecated since gsl-lite 0.7.0; replace with gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR, or consider span(with_container, cont).")
+#endif
+
+// M-GSL compatibility:
+
+#if defined( GSL_THROW_ON_CONTRACT_VIOLATION )
+# define gsl_CONFIG_CONTRACT_VIOLATION_THROWS  1
+#endif
+
+#if defined( GSL_TERMINATE_ON_CONTRACT_VIOLATION )
+# define gsl_CONFIG_CONTRACT_VIOLATION_THROWS  0
+#endif
+
+#if defined( GSL_UNENFORCED_ON_CONTRACT_VIOLATION )
+# define gsl_CONFIG_CONTRACT_LEVEL_OFF  1
+#endif
+
+// Configuration: Features
+
+#ifndef  gsl_FEATURE_WITH_CONTAINER_TO_STD
+# define gsl_FEATURE_WITH_CONTAINER_TO_STD  99
+#endif
+
+#ifndef  gsl_FEATURE_MAKE_SPAN_TO_STD
+# define gsl_FEATURE_MAKE_SPAN_TO_STD  99
+#endif
+
+#ifndef  gsl_FEATURE_BYTE_SPAN_TO_STD
+# define gsl_FEATURE_BYTE_SPAN_TO_STD  99
+#endif
+
+#ifndef  gsl_FEATURE_IMPLICIT_MACRO
+# define gsl_FEATURE_IMPLICIT_MACRO  1
+#endif
+
+#ifndef  gsl_FEATURE_OWNER_MACRO
+# define gsl_FEATURE_OWNER_MACRO  1
+#endif
+
+#ifndef  gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD
+# define gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD  0
+#endif
+
+// Configuration: Other
+
+#ifndef  gsl_CONFIG_DEPRECATE_TO_LEVEL
+# define gsl_CONFIG_DEPRECATE_TO_LEVEL  0
+#endif
+
+#ifndef  gsl_CONFIG_SPAN_INDEX_TYPE
+# define gsl_CONFIG_SPAN_INDEX_TYPE  size_t
+#endif
+
+#ifndef  gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR
+# define gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR  0
+#endif
+
+#ifndef  gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF
+# define gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF  0
+#endif
+
+#ifndef  gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS
+# define gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS  0
+#endif
+
+#ifndef  gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON
+# define gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON  1
+#endif
+
+#ifndef  gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR
+# define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR  0
+#endif
+
+#if    defined( gsl_CONFIG_CONTRACT_LEVEL_ON )
+# define        gsl_CONFIG_CONTRACT_LEVEL_MASK  0x11
+#elif  defined( gsl_CONFIG_CONTRACT_LEVEL_OFF )
+# define        gsl_CONFIG_CONTRACT_LEVEL_MASK  0x00
+#elif  defined( gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY )
+# define        gsl_CONFIG_CONTRACT_LEVEL_MASK  0x01
+#elif  defined( gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY )
+# define        gsl_CONFIG_CONTRACT_LEVEL_MASK  0x10
+#else
+# define        gsl_CONFIG_CONTRACT_LEVEL_MASK  0x11
+#endif
+
+#if   !defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS     ) && \
+      !defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES )
+# define        gsl_CONFIG_CONTRACT_VIOLATION_THROWS_V 0
+#elif  defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS     ) && \
+      !defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES )
+# define        gsl_CONFIG_CONTRACT_VIOLATION_THROWS_V 1
+#elif !defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS     ) && \
+       defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES )
+# define        gsl_CONFIG_CONTRACT_VIOLATION_THROWS_V 0
+#else
+# error only one of gsl_CONFIG_CONTRACT_VIOLATION_THROWS and gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES may be defined.
+#endif
+
+// C++ language version detection (C++20 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef   gsl_CPLUSPLUS
+# if defined(_MSVC_LANG ) && !defined(__clang__)
+#  define gsl_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
+# else
+#  define gsl_CPLUSPLUS  __cplusplus
+# endif
+#endif
+
+#define gsl_CPP98_OR_GREATER  ( gsl_CPLUSPLUS >= 199711L )
+#define gsl_CPP11_OR_GREATER  ( gsl_CPLUSPLUS >= 201103L )
+#define gsl_CPP14_OR_GREATER  ( gsl_CPLUSPLUS >= 201402L )
+#define gsl_CPP17_OR_GREATER  ( gsl_CPLUSPLUS >= 201703L )
+#define gsl_CPP20_OR_GREATER  ( gsl_CPLUSPLUS >= 202000L )
+
+// C++ language version (represent 98 as 3):
+
+#define gsl_CPLUSPLUS_V  ( gsl_CPLUSPLUS / 100 - (gsl_CPLUSPLUS > 200000 ? 2000 : 1994) )
+
+// half-open range [lo..hi):
+#define gsl_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
+
+// Compiler versions:
+//
+// MSVC++ 6.0  _MSC_VER == 1200 (Visual Studio 6.0)
+// MSVC++ 7.0  _MSC_VER == 1300 (Visual Studio .NET 2002)
+// MSVC++ 7.1  _MSC_VER == 1310 (Visual Studio .NET 2003)
+// MSVC++ 8.0  _MSC_VER == 1400 (Visual Studio 2005)
+// MSVC++ 9.0  _MSC_VER == 1500 (Visual Studio 2008)
+// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010)
+// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012)
+// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
+// MSVC++ 14.1 _MSC_VER >= 1910 (Visual Studio 2017)
+
+#if defined(_MSC_VER ) && !defined(__clang__)
+# define gsl_COMPILER_MSVC_VER      (_MSC_VER )
+# define gsl_COMPILER_MSVC_VERSION  (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
+#else
+# define gsl_COMPILER_MSVC_VER      0
+# define gsl_COMPILER_MSVC_VERSION  0
+#endif
+
+#define gsl_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
+
+#if defined(__clang__)
+# define gsl_COMPILER_CLANG_VERSION gsl_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )
+#else
+# define gsl_COMPILER_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+# define gsl_COMPILER_GNUC_VERSION gsl_COMPILER_VERSION( __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ )
+#else
+# define gsl_COMPILER_GNUC_VERSION 0
+#endif
+
+// Method enabling (C++98, VC120 (VS2013) cannot use __VA_ARGS__)
+
+#define gsl_REQUIRES_0(VA) \
+    template< bool B = (VA), typename std::enable_if<B, int>::type = 0 >
+
+#define gsl_REQUIRES_T(VA) \
+    , typename = typename std::enable_if< (VA), gsl::detail::enabler >::type
+
+#define gsl_REQUIRES_R(R, VA) \
+    typename std::enable_if<VA, R>::type
+
+#define gsl_REQUIRES_A(VA) \
+    , typename std::enable_if<VA, void*>::type = nullptr
+
+// Compiler non-strict aliasing:
+
+#if defined(__clang__) || defined(__GNUC__)
+# define gsl_may_alias  __attribute__((__may_alias__))
+#else
+# define gsl_may_alias
+#endif
+
+// Presence of gsl, language and library features:
+
+#define gsl_IN_STD( v )  ( ((v) == 98 ? 3 : (v)) >= gsl_CPLUSPLUS_V )
+
+#define gsl_DEPRECATE_TO_LEVEL( level )  ( level <= gsl_CONFIG_DEPRECATE_TO_LEVEL )
+#define gsl_FEATURE_TO_STD(   feature )  ( gsl_IN_STD( gsl_FEATURE( feature##_TO_STD ) ) )
+#define gsl_FEATURE(          feature )  ( gsl_FEATURE_##feature )
+#define gsl_CONFIG(           feature )  ( gsl_CONFIG_##feature )
+#define gsl_HAVE(             feature )  ( gsl_HAVE_##feature )
+
+// Presence of wide character support:
+
+#ifdef __DJGPP__
+# define gsl_HAVE_WCHAR 0
+#else
+# define gsl_HAVE_WCHAR 1
+#endif
+
+// Presence of language & library features:
+
+#ifdef _HAS_CPP0X
+# define gsl_HAS_CPP0X  _HAS_CPP0X
+#else
+# define gsl_HAS_CPP0X  0
+#endif
+
+#define gsl_CPP11_100  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1600)
+#define gsl_CPP11_110  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1700)
+#define gsl_CPP11_120  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
+#define gsl_CPP11_140  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+
+#define gsl_CPP14_000  (gsl_CPP14_OR_GREATER)
+#define gsl_CPP14_120  (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
+#define gsl_CPP14_140  (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+
+#define gsl_CPP17_000  (gsl_CPP17_OR_GREATER)
+#define gsl_CPP17_140  (gsl_CPP17_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+
+#define gsl_CPP11_140_CPP0X_90   (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1500 && gsl_HAS_CPP0X))
+#define gsl_CPP11_140_CPP0X_100  (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1600 && gsl_HAS_CPP0X))
+
+// Presence of C++11 language features:
+
+#define gsl_HAVE_AUTO                   gsl_CPP11_100
+#define gsl_HAVE_NULLPTR                gsl_CPP11_100
+#define gsl_HAVE_RVALUE_REFERENCE       gsl_CPP11_100
+
+#define gsl_HAVE_ENUM_CLASS             gsl_CPP11_110
+
+#define gsl_HAVE_ALIAS_TEMPLATE         gsl_CPP11_120
+#define gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG  gsl_CPP11_120
+#define gsl_HAVE_EXPLICIT               gsl_CPP11_120
+#define gsl_HAVE_INITIALIZER_LIST       gsl_CPP11_120
+
+#define gsl_HAVE_CONSTEXPR_11           gsl_CPP11_140
+#define gsl_HAVE_IS_DEFAULT             gsl_CPP11_140
+#define gsl_HAVE_IS_DELETE              gsl_CPP11_140
+#define gsl_HAVE_NOEXCEPT               gsl_CPP11_140
+
+#if gsl_CPP11_OR_GREATER
+// see above
+#endif
+
+// Presence of C++14 language features:
+
+#define gsl_HAVE_CONSTEXPR_14           gsl_CPP14_000
+#define gsl_HAVE_DECLTYPE_AUTO          gsl_CPP14_140
+
+// Presence of C++17 language features:
+// MSVC: template parameter deduction guides since Visual Studio 2017 v15.7
+
+#define gsl_HAVE_ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE  gsl_CPP17_000
+#define gsl_HAVE_DEDUCTION_GUIDES      (gsl_CPP17_000 && ! gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 999 ) )
+
+// Presence of C++ library features:
+
+#define gsl_HAVE_ADDRESSOF              gsl_CPP17_000
+#define gsl_HAVE_ARRAY                  gsl_CPP11_110
+#define gsl_HAVE_TYPE_TRAITS            gsl_CPP11_110
+#define gsl_HAVE_TR1_TYPE_TRAITS        gsl_CPP11_110
+
+#define gsl_HAVE_CONTAINER_DATA_METHOD  gsl_CPP11_140_CPP0X_90
+#define gsl_HAVE_STD_DATA               gsl_CPP17_000
+
+#define gsl_HAVE_SIZED_TYPES            gsl_CPP11_140
+
+#define gsl_HAVE_MAKE_SHARED            gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_SHARED_PTR             gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_UNIQUE_PTR             gsl_CPP11_140_CPP0X_100
+
+#define gsl_HAVE_MAKE_UNIQUE            gsl_CPP14_120
+
+#define gsl_HAVE_UNCAUGHT_EXCEPTIONS    gsl_CPP17_140
+
+#define gsl_HAVE_ADD_CONST              gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_INTEGRAL_CONSTANT      gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_CONST           gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_REFERENCE       gsl_HAVE_TYPE_TRAITS
+
+#define gsl_HAVE_TR1_ADD_CONST          gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_INTEGRAL_CONSTANT  gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_REMOVE_CONST       gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_REMOVE_REFERENCE   gsl_HAVE_TR1_TYPE_TRAITS
+
+// C++ feature usage:
+
+#if gsl_HAVE( ADDRESSOF )
+# define gsl_ADDRESSOF(x)  std::addressof(x)
+#else
+# define gsl_ADDRESSOF(x)  (&x)
+#endif
+
+#if gsl_HAVE( CONSTEXPR_11 )
+# define gsl_constexpr constexpr
+#else
+# define gsl_constexpr /*constexpr*/
+#endif
+
+#if gsl_HAVE( CONSTEXPR_14 )
+# define gsl_constexpr14 constexpr
+#else
+# define gsl_constexpr14 /*constexpr*/
+#endif
+
+#if gsl_HAVE( EXPLICIT )
+# define gsl_explicit explicit
+#else
+# define gsl_explicit /*explicit*/
+#endif
+
+#if gsl_FEATURE( IMPLICIT_MACRO )
+# define implicit /*implicit*/
+#endif
+
+#if gsl_HAVE( IS_DELETE )
+# define gsl_is_delete = delete
+#else
+# define gsl_is_delete
+#endif
+
+#if gsl_HAVE( IS_DELETE )
+# define gsl_is_delete_access public
+#else
+# define gsl_is_delete_access private
+#endif
+
+#if !gsl_HAVE( NOEXCEPT ) || gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+# define gsl_noexcept /*noexcept*/
+#else
+# define gsl_noexcept noexcept
+#endif
+
+#if gsl_HAVE( NULLPTR )
+# define gsl_nullptr  nullptr
+#else
+# define gsl_nullptr  NULL
+#endif
+
+#define gsl_DIMENSION_OF( a ) ( sizeof(a) / sizeof(0[a]) )
+
+// Other features:
+
+#define gsl_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR  \
+    ( gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG && gsl_HAVE_CONTAINER_DATA_METHOD )
+
+// Note: !defined(__NVCC__) doesn't work with nvcc here:
+#define gsl_HAVE_UNCONSTRAINED_SPAN_CONTAINER_CTOR  \
+    ( gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR && (__NVCC__== 0) )
+
+// GSL API (e.g. for CUDA platform):
+
+#ifndef   gsl_api
+# ifdef   __CUDACC__
+#  define gsl_api __host__ __device__
+# else
+#  define gsl_api /*gsl_api*/
+# endif
+#endif
+
+// Additional includes:
+
+#if gsl_HAVE( ARRAY )
+# include <array>
+#endif
+
+#if gsl_HAVE( TYPE_TRAITS )
+# include <type_traits>
+#elif gsl_HAVE( TR1_TYPE_TRAITS )
+# include <tr1/type_traits>
+#endif
+
+#if gsl_HAVE( SIZED_TYPES )
+# include <cstdint>
+#endif
+
+// MSVC warning suppression macros:
+
+#if gsl_COMPILER_MSVC_VERSION >= 140
+# define gsl_SUPPRESS_MSGSL_WARNING(expr)        [[gsl::suppress(expr)]]
+# define gsl_SUPPRESS_MSVC_WARNING(code, descr)  __pragma(warning(suppress: code) )
+# define gsl_DISABLE_MSVC_WARNINGS(codes)        __pragma(warning(push))  __pragma(warning(disable: codes))
+# define gsl_RESTORE_MSVC_WARNINGS()             __pragma(warning(pop ))
+#else
+# define gsl_SUPPRESS_MSGSL_WARNING(expr)
+# define gsl_SUPPRESS_MSVC_WARNING(code, descr)
+# define gsl_DISABLE_MSVC_WARNINGS(codes)
+# define gsl_RESTORE_MSVC_WARNINGS()
+#endif
+
+// Suppress the following MSVC GSL warnings:
+// - C26410: gsl::r.32: the parameter 'ptr' is a reference to const unique pointer, use const T* or const T& instead
+// - C26415: gsl::r.30: smart pointer parameter 'ptr' is used only to access contained pointer. Use T* or T& instead
+// - C26418: gsl::r.36: shared pointer parameter 'ptr' is not copied or moved. Use T* or T& instead
+// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions;
+//                      use brace initialization, gsl::narrow_cast or gsl::narow
+// - C26439, gsl::f.6 : special function 'function' can be declared 'noexcept'
+// - C26440, gsl::f.6 : function 'function' can be declared 'noexcept'
+// - C26473: gsl::t.1 : don't cast between pointer types where the source type and the target type are the same
+// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead
+// - C26482, gsl::b.2 : only index into arrays using constant expressions
+// - C26490: gsl::t.1 : don't use reinterpret_cast
+
+gsl_DISABLE_MSVC_WARNINGS( 26410 26415 26418 26472 26439 26440 26473 26481 26482 26490 )
+
+namespace gsl {
+
+// forward declare span<>:
+
+template< class T >
+class span;
+
+// C++11 emulation:
+
+namespace std11 {
+
+#if gsl_HAVE( ADD_CONST )
+
+using std::add_const;
+
+#elif gsl_HAVE( TR1_ADD_CONST )
+
+using std::tr1::add_const;
+
+#else
+
+template< class T > struct add_const { typedef const T type; };
+
+#endif // gsl_HAVE( ADD_CONST )
+
+#if gsl_HAVE( REMOVE_CONST )
+
+using std::remove_cv;
+using std::remove_const;
+using std::remove_volatile;
+
+#elif gsl_HAVE( TR1_REMOVE_CONST )
+
+using std::tr1::remove_cv;
+using std::tr1::remove_const;
+using std::tr1::remove_volatile;
+
+#else
+
+template< class T > struct remove_const          { typedef T type; };
+template< class T > struct remove_const<T const> { typedef T type; };
+
+template< class T > struct remove_volatile             { typedef T type; };
+template< class T > struct remove_volatile<T volatile> { typedef T type; };
+
+template< class T >
+struct remove_cv
+{
+    typedef typename remove_volatile<typename remove_const<T>::type>::type type;
+};
+
+#endif // gsl_HAVE( REMOVE_CONST )
+
+#if gsl_HAVE( INTEGRAL_CONSTANT )
+
+using std::integral_constant;
+using std::true_type;
+using std::false_type;
+
+#elif gsl_HAVE( TR1_INTEGRAL_CONSTANT )
+
+using std::tr1::integral_constant;
+using std::tr1::true_type;
+using std::tr1::false_type;
+
+#else
+
+template< int v > struct integral_constant { enum { value = v }; };
+typedef integral_constant< true  > true_type;
+typedef integral_constant< false > false_type;
+
+#endif
+
+} // namespace std11
+
+namespace detail {
+
+/// for nsel_REQUIRES_T
+
+/*enum*/ class enabler{};
+
+#if gsl_HAVE( TYPE_TRAITS )
+
+template< class Q >
+struct is_span_oracle : std11::false_type{};
+
+template< class T>
+struct is_span_oracle< span<T> > : std11::true_type{};
+
+template< class Q >
+struct is_span : is_span_oracle< typename std11::remove_cv<Q>::type >{};
+
+template< class Q >
+struct is_std_array_oracle : std11::false_type{};
+
+#if gsl_HAVE( ARRAY )
+
+template< class T, std::size_t Extent >
+struct is_std_array_oracle< std::array<T, Extent> > : std11::true_type{};
+
+#endif
+
+template< class Q >
+struct is_std_array : is_std_array_oracle< typename std11::remove_cv<Q>::type >{};
+
+template< class Q >
+struct is_array : std11::false_type {};
+
+template< class T >
+struct is_array<T[]> : std11::true_type {};
+
+template< class T, std::size_t N >
+struct is_array<T[N]> : std11::true_type {};
+
+#endif // gsl_HAVE( TYPE_TRAITS )
+
+} // namespace detail
+
+//
+// GSL.util: utilities
+//
+
+// index type for all container indexes/subscripts/sizes
+typedef gsl_CONFIG_SPAN_INDEX_TYPE index;   // p0122r3 uses std::ptrdiff_t
+
+//
+// GSL.owner: ownership pointers
+//
+#if gsl_HAVE( SHARED_PTR )
+  using std::unique_ptr;
+  using std::shared_ptr;
+  using std::make_shared;
+# if gsl_HAVE( MAKE_UNIQUE )
+  using std::make_unique;
+# endif
+#endif
+
+#if  gsl_HAVE( ALIAS_TEMPLATE )
+# if gsl_HAVE( TYPE_TRAITS )
+  template< class T
+    gsl_REQUIRES_T( std::is_pointer<T>::value )
+  >
+  using owner = T;
+# else
+  template< class T > using owner = T;
+# endif
+#else
+  template< class T > struct owner { typedef T type; };
+#endif
+
+#define gsl_HAVE_OWNER_TEMPLATE  gsl_HAVE_ALIAS_TEMPLATE
+
+#if gsl_FEATURE( OWNER_MACRO )
+# if gsl_HAVE( OWNER_TEMPLATE )
+#  define Owner(t)  ::gsl::owner<t>
+# else
+#  define Owner(t)  ::gsl::owner<t>::type
+# endif
+#endif
+
+//
+// GSL.assert: assertions
+//
+
+#define gsl_ELIDE_CONTRACT_EXPECTS  ( 0 == ( gsl_CONFIG_CONTRACT_LEVEL_MASK & 0x01 ) )
+#define gsl_ELIDE_CONTRACT_ENSURES  ( 0 == ( gsl_CONFIG_CONTRACT_LEVEL_MASK & 0x10 ) )
+
+#if gsl_ELIDE_CONTRACT_EXPECTS
+# define Expects( x )  /* Expects elided */
+#elif gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+# define Expects( x )  ::gsl::fail_fast_assert( (x), "GSL: Precondition failure at " __FILE__ ":" gsl_STRINGIFY(__LINE__) );
+#else
+# define Expects( x )  ::gsl::fail_fast_assert( (x) )
+#endif
+
+#if gsl_ELIDE_CONTRACT_EXPECTS
+# define gsl_EXPECTS_UNUSED_PARAM( x )  /* Make param unnamed if Expects elided */
+#else
+# define gsl_EXPECTS_UNUSED_PARAM( x )  x
+#endif
+
+#if gsl_ELIDE_CONTRACT_ENSURES
+# define Ensures( x )  /* Ensures elided */
+#elif gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+# define Ensures( x )  ::gsl::fail_fast_assert( (x), "GSL: Postcondition failure at " __FILE__ ":" gsl_STRINGIFY(__LINE__) );
+#else
+# define Ensures( x )  ::gsl::fail_fast_assert( (x) )
+#endif
+
+#define gsl_STRINGIFY(  x )  gsl_STRINGIFY_( x )
+#define gsl_STRINGIFY_( x )  #x
+
+struct fail_fast : public std::logic_error
+{
+    gsl_api explicit fail_fast( char const * const message )
+    : std::logic_error( message ) {}
+};
+
+// workaround for gcc 5 throw/terminate constexpr bug:
+
+#if gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 430, 600 ) && gsl_HAVE( CONSTEXPR_14 )
+
+# if gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+
+gsl_api inline gsl_constexpr14 auto fail_fast_assert( bool cond, char const * const message ) -> void
+{
+    !cond ? throw fail_fast( message ) : 0;
+}
+
+# else
+
+gsl_api inline gsl_constexpr14 auto fail_fast_assert( bool cond ) -> void
+{
+    struct F { static gsl_constexpr14 void f(){}; };
+
+    !cond ? std::terminate() : F::f();
+}
+
+# endif
+
+#else // workaround
+
+# if gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+
+gsl_api inline gsl_constexpr14 void fail_fast_assert( bool cond, char const * const message )
+{
+    if ( !cond )
+        throw fail_fast( message );
+}
+
+# else
+
+gsl_api inline gsl_constexpr14 void fail_fast_assert( bool cond ) gsl_noexcept
+{
+    if ( !cond )
+        std::terminate();
+}
+
+# endif
+#endif // workaround
+
+//
+// GSL.util: utilities
+//
+
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+// Add uncaught_exceptions for pre-2017 MSVC, GCC and Clang
+// Return unsigned char to save stack space, uncaught_exceptions can only increase by 1 in a scope
+
+namespace detail {
+
+inline unsigned char to_uchar( unsigned x ) gsl_noexcept
+{
+    return static_cast<unsigned char>( x );
+}
+
+} // namespace detail
+
+namespace std11 {
+
+#if gsl_HAVE( UNCAUGHT_EXCEPTIONS )
+
+inline unsigned char uncaught_exceptions() gsl_noexcept
+{
+    return detail::to_uchar( std::uncaught_exceptions() );
+}
+
+#elif gsl_COMPILER_MSVC_VERSION
+
+extern "C" char * __cdecl _getptd();
+inline unsigned char uncaught_exceptions() gsl_noexcept
+{
+    return detail::to_uchar( *reinterpret_cast<unsigned*>(_getptd() + (sizeof(void*) == 8 ? 0x100 : 0x90) ) );
+}
+
+#elif gsl_COMPILER_CLANG_VERSION || gsl_COMPILER_GNUC_VERSION
+
+extern "C" char * __cxa_get_globals();
+inline unsigned char uncaught_exceptions() gsl_noexcept
+{
+    return detail::to_uchar( *reinterpret_cast<unsigned*>(__cxa_get_globals() + sizeof(void*) ) );
+}
+#endif
+} // namespace std11
+#endif
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
+
+template< class F >
+class final_action
+{
+public:
+    gsl_api explicit final_action( F action ) gsl_noexcept
+        : action_( std::move( action ) )
+        , invoke_( true )
+    {}
+
+    gsl_api final_action( final_action && other ) gsl_noexcept
+        : action_( std::move( other.action_ ) )
+        , invoke_( other.invoke_ )
+    {
+        other.invoke_ = false;
+    }
+
+    gsl_api virtual ~final_action() gsl_noexcept
+    {
+        if ( invoke_ )
+            action_();
+    }
+
+gsl_is_delete_access:
+    gsl_api final_action( final_action const  & ) gsl_is_delete;
+    gsl_api final_action & operator=( final_action const & ) gsl_is_delete;
+    gsl_api final_action & operator=( final_action && ) gsl_is_delete;
+
+protected:
+    gsl_api void dismiss() gsl_noexcept
+    {
+        invoke_ = false;
+    }
+
+private:
+    F action_;
+    bool invoke_;
+};
+
+template< class F >
+gsl_api inline final_action<F> finally( F const & action ) gsl_noexcept
+{
+    return final_action<F>( action );
+}
+
+template< class F >
+gsl_api inline final_action<F> finally( F && action ) gsl_noexcept
+{
+    return final_action<F>( std::forward<F>( action ) );
+}
+
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+template< class F >
+class final_action_return : public final_action<F>
+{
+public:
+    gsl_api explicit final_action_return( F && action ) gsl_noexcept
+        : final_action<F>( std::move( action ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    gsl_api final_action_return( final_action_return && other ) gsl_noexcept
+        : final_action<F>( std::move( other ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    gsl_api ~final_action_return() override
+    {
+        if ( std11::uncaught_exceptions() != exception_count )
+            this->dismiss();
+    }
+
+gsl_is_delete_access:
+    gsl_api final_action_return( final_action_return const & ) gsl_is_delete;
+    gsl_api final_action_return & operator=( final_action_return const & ) gsl_is_delete;
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+gsl_api inline final_action_return<F> on_return( F const & action ) gsl_noexcept
+{
+    return final_action_return<F>( action );
+}
+
+template< class F >
+gsl_api inline final_action_return<F> on_return( F && action ) gsl_noexcept
+{
+    return final_action_return<F>( std::forward<F>( action ) );
+}
+
+template< class F >
+class final_action_error : public final_action<F>
+{
+public:
+    gsl_api explicit final_action_error( F && action ) gsl_noexcept
+        : final_action<F>( std::move( action ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    gsl_api final_action_error( final_action_error && other ) gsl_noexcept
+        : final_action<F>( std::move( other ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    gsl_api ~final_action_error() override
+    {
+        if ( std11::uncaught_exceptions() == exception_count )
+            this->dismiss();
+    }
+
+gsl_is_delete_access:
+    gsl_api final_action_error( final_action_error const & ) gsl_is_delete;
+    gsl_api final_action_error & operator=( final_action_error const & ) gsl_is_delete;
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+gsl_api inline final_action_error<F> on_error( F const & action ) gsl_noexcept
+{
+    return final_action_error<F>( action );
+}
+
+template< class F >
+gsl_api inline final_action_error<F> on_error( F && action ) gsl_noexcept
+{
+    return final_action_error<F>( std::forward<F>( action ) );
+}
+
+#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+#else // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
+
+class final_action
+{
+public:
+    typedef void (*Action)();
+
+    gsl_api final_action( Action action )
+    : action_( action )
+    , invoke_( true )
+    {}
+
+    gsl_api final_action( final_action const & other )
+        : action_( other.action_ )
+        , invoke_( other.invoke_ )
+    {
+        other.invoke_ = false;
+    }
+
+    gsl_api virtual ~final_action()
+    {
+        if ( invoke_ )
+            action_();
+    }
+
+protected:
+    gsl_api void dismiss()
+    {
+        invoke_ = false;
+    }
+
+private:
+    gsl_api final_action & operator=( final_action const & );
+
+private:
+    Action action_;
+    mutable bool invoke_;
+};
+
+template< class F >
+gsl_api inline final_action finally( F const & f )
+{
+    return final_action(( f ));
+}
+
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+class final_action_return : public final_action
+{
+public:
+    gsl_api explicit final_action_return( Action action )
+        : final_action( action )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    gsl_api ~final_action_return()
+    {
+        if ( std11::uncaught_exceptions() != exception_count )
+            this->dismiss();
+    }
+
+private:
+    gsl_api final_action_return & operator=( final_action_return const & );
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+gsl_api inline final_action_return on_return( F const & action )
+{
+    return final_action_return( action );
+}
+
+class final_action_error : public final_action
+{
+public:
+    gsl_api explicit final_action_error( Action action )
+        : final_action( action )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    gsl_api ~final_action_error()
+    {
+        if ( std11::uncaught_exceptions() == exception_count )
+            this->dismiss();
+    }
+
+private:
+    gsl_api final_action_error & operator=( final_action_error const & );
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+gsl_api inline final_action_error on_error( F const & action )
+{
+    return final_action_error( action );
+}
+
+#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+#endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION == 110
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+
+template< class T, class U >
+gsl_api inline gsl_constexpr T narrow_cast( U && u ) gsl_noexcept
+{
+    return static_cast<T>( std::forward<U>( u ) );
+}
+
+#else
+
+template< class T, class U >
+gsl_api inline T narrow_cast( U u ) gsl_noexcept
+{
+    return static_cast<T>( u );
+}
+
+#endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+
+struct narrowing_error : public std::exception {};
+
+#if gsl_HAVE( TYPE_TRAITS )
+
+namespace detail
+{
+    template< class T, class U >
+    struct is_same_signedness : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
+    {};
+}
+#endif
+
+template< class T, class U >
+gsl_api inline T narrow( U u )
+{
+    T t = narrow_cast<T>( u );
+
+    if ( static_cast<U>( t ) != u )
+    {
+#if gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+        throw narrowing_error();
+#else
+        std::terminate();
+#endif
+    }
+
+#if gsl_HAVE( TYPE_TRAITS )
+# if gsl_COMPILER_MSVC_VERSION
+    // Suppress MSVC level 4 warning C4127 (conditional expression is constant)
+    if ( 0, ! detail::is_same_signedness<T, U>::value && ( ( t < T() ) != ( u < U() ) ) )
+# else
+    if (    ! detail::is_same_signedness<T, U>::value && ( ( t < T() ) != ( u < U() ) ) )
+# endif
+#else
+    // Don't assume T() works:
+    if ( ( t < 0 ) != ( u < 0 ) )
+#endif
+    {
+#if gsl_CONFIG( CONTRACT_VIOLATION_THROWS_V )
+        throw narrowing_error();
+#else
+        std::terminate();
+#endif
+    }
+    return t;
+}
+
+//
+// at() - Bounds-checked way of accessing static arrays, std::array, std::vector.
+//
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr14 T & at( T(&arr)[N], size_t index )
+{
+    Expects( index < N );
+    return arr[index];
+}
+
+#if gsl_HAVE( ARRAY )
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr14 T & at( std::array<T, N> & arr, size_t index )
+{
+    Expects( index < N );
+    return arr[index];
+}
+#endif
+
+template< class Container >
+gsl_api inline gsl_constexpr14 typename Container::value_type & at( Container & cont, size_t index )
+{
+    Expects( index < cont.size() );
+    return cont[index];
+}
+
+#if gsl_HAVE( INITIALIZER_LIST )
+
+template< class T >
+gsl_api inline const gsl_constexpr14 T & at( std::initializer_list<T> cont, size_t index )
+{
+    Expects( index < cont.size() );
+    return *( cont.begin() + index );
+}
+#endif
+
+template< class T >
+gsl_api inline gsl_constexpr T & at( span<T> s, size_t index )
+{
+    return s.at( index );
+}
+
+//
+// GSL.views: views
+//
+
+//
+// not_null<> - Wrap any indirection and enforce non-null.
+//
+template< class T >
+class not_null
+{
+#if gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+# define gsl_not_null_explicit   explicit
+#else
+# define gsl_not_null_explicit /*explicit*/
+#endif
+
+#if gsl_CONFIG( NOT_NULL_GET_BY_CONST_REF )
+    typedef T const & get_result_t;
+#else
+    typedef T get_result_t;
+#endif
+
+public:
+#if gsl_HAVE( TYPE_TRAITS )
+    static_assert( std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr." );
+#endif
+
+    template< class U
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_constructible<T, U>::value ))
+#endif
+    >
+    gsl_api gsl_constexpr14 gsl_not_null_explicit
+#if gsl_HAVE( RVALUE_REFERENCE )
+    not_null( U && u )
+    : ptr_( std::forward<U>( u ) )
+#else
+    not_null( U const & u )
+    : ptr_( u )
+#endif
+    {
+        Expects( ptr_ != gsl_nullptr );
+    }
+#undef gsl_not_null_explicit
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_api                ~not_null() = default;
+    gsl_api gsl_constexpr   not_null( not_null &&      other ) = default;
+    gsl_api gsl_constexpr   not_null( not_null const & other ) = default;
+    gsl_api                 not_null & operator=( not_null &&      other ) = default;
+    gsl_api                 not_null & operator=( not_null const & other ) = default;
+#else
+    gsl_api                ~not_null() {};
+    gsl_api gsl_constexpr   not_null( not_null const & other ) : ptr_ ( other.ptr_  ) {}
+    gsl_api                 not_null & operator=( not_null const & other ) { ptr_ = other.ptr_; return *this; }
+# if gsl_HAVE( RVALUE_REFERENCE )
+    gsl_api gsl_constexpr   not_null( not_null && other ) : ptr_( std::move( other.get() ) ) {}
+    gsl_api                 not_null & operator=( not_null && other ) { ptr_ = std::move( other.get() ); return *this; }
+# endif
+#endif
+
+    template< class U
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_convertible<U, T>::value ))
+#endif
+    >
+    gsl_api gsl_constexpr not_null( not_null<U> const & other )
+    : ptr_( other.get() )
+    {}
+
+    gsl_api gsl_constexpr14 get_result_t get() const
+    {
+        // Without cheating and changing ptr_ from the outside, this check is superfluous:
+        Ensures( ptr_ != gsl_nullptr );
+        return ptr_;
+    }
+
+    gsl_api gsl_constexpr operator get_result_t  () const { return get(); }
+    gsl_api gsl_constexpr get_result_t operator->() const { return get(); }
+
+#if gsl_HAVE( DECLTYPE_AUTO )
+    gsl_api gsl_constexpr decltype(auto) operator*() const { return *get(); }
+#endif
+
+gsl_is_delete_access:
+    // prevent compilation when initialized with a nullptr or literal 0:
+#if gsl_HAVE( NULLPTR )
+    gsl_api not_null(             std::nullptr_t ) gsl_is_delete;
+    gsl_api not_null & operator=( std::nullptr_t ) gsl_is_delete;
+#else
+    gsl_api not_null(             int ) gsl_is_delete;
+    gsl_api not_null & operator=( int ) gsl_is_delete;
+#endif
+
+    // unwanted operators...pointers only point to single objects!
+    gsl_api not_null & operator++() gsl_is_delete;
+    gsl_api not_null & operator--() gsl_is_delete;
+    gsl_api not_null   operator++( int ) gsl_is_delete;
+    gsl_api not_null   operator--( int ) gsl_is_delete;
+    gsl_api not_null & operator+ ( size_t ) gsl_is_delete;
+    gsl_api not_null & operator+=( size_t ) gsl_is_delete;
+    gsl_api not_null & operator- ( size_t ) gsl_is_delete;
+    gsl_api not_null & operator-=( size_t ) gsl_is_delete;
+    gsl_api not_null & operator+=( std::ptrdiff_t ) gsl_is_delete;
+    gsl_api not_null & operator-=( std::ptrdiff_t ) gsl_is_delete;
+    gsl_api void       operator[]( std::ptrdiff_t ) const gsl_is_delete;
+
+private:
+    T ptr_;
+};
+
+// not_null with implicit constructor, allowing copy-initialization:
+
+template< class T >
+class not_null_ic : public not_null<T>
+{
+public:
+    template< class U
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_constructible<T, U>::value )) 
+#endif
+    >
+    gsl_api gsl_constexpr14
+#if gsl_HAVE( RVALUE_REFERENCE )
+    not_null_ic( U && u )
+    : not_null<T>( std::forward<U>( u ) )
+#else
+    not_null_ic( U const & u )
+    : not_null<T>( u )
+#endif
+    {}
+};
+
+// more not_null unwanted operators
+
+template< class T, class U >
+std::ptrdiff_t operator-( not_null<T> const &, not_null<U> const & ) gsl_is_delete;
+
+template< class T >
+not_null<T> operator-( not_null<T> const &, std::ptrdiff_t ) gsl_is_delete;
+
+template< class T >
+not_null<T> operator+( not_null<T> const &, std::ptrdiff_t ) gsl_is_delete;
+
+template< class T >
+not_null<T> operator+( std::ptrdiff_t, not_null<T> const & ) gsl_is_delete;
+
+// not_null comparisons
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator==( not_null<T> const & l, not_null<U> const & r )
+{
+    return  l.get() == r.get();
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator< ( not_null<T> const & l, not_null<U> const & r )
+{
+    return l.get() < r.get();
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator!=( not_null<T> const & l, not_null<U> const & r )
+{
+    return !( l == r );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator<=( not_null<T> const & l, not_null<U> const & r )
+{
+    return !( r < l );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator> ( not_null<T> const & l, not_null<U> const & r )
+{
+    return ( r < l );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator>=( not_null<T> const & l, not_null<U> const & r )
+{
+    return !( l < r );
+}
+
+//
+// Byte-specific type.
+//
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+  enum class gsl_may_alias byte : unsigned char {};
+#else
+  struct gsl_may_alias byte { typedef unsigned char type; type v; };
+#endif
+
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+# define gsl_ENABLE_IF_INTEGRAL_T(T)  \
+    gsl_REQUIRES_T(( std::is_integral<T>::value ))
+#else
+# define gsl_ENABLE_IF_INTEGRAL_T(T)
+#endif
+
+template< class T >
+gsl_api inline gsl_constexpr byte to_byte( T v ) gsl_noexcept
+{
+#if    gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return static_cast<byte>( v );
+#elif  gsl_HAVE( CONSTEXPR_11 )
+    return { static_cast<typename byte::type>( v ) };
+#else
+    byte b = { static_cast<typename byte::type>( v ) }; return b;
+#endif
+}
+
+template< class IntegerType  gsl_ENABLE_IF_INTEGRAL_T( IntegerType ) >
+gsl_api inline gsl_constexpr IntegerType to_integer( byte b ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return static_cast<typename std::underlying_type<byte>::type>( b );
+#else
+    return b.v;
+#endif
+}
+
+gsl_api inline gsl_constexpr unsigned char to_uchar( byte b ) gsl_noexcept
+{
+    return to_integer<unsigned char>( b );
+}
+
+gsl_api inline gsl_constexpr unsigned char to_uchar( int i ) gsl_noexcept
+{
+    return static_cast<unsigned char>( i );
+}
+
+#if ! gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+
+gsl_api inline gsl_constexpr bool operator==( byte l, byte r ) gsl_noexcept
+{
+    return l.v == r.v;
+}
+
+gsl_api inline gsl_constexpr bool operator!=( byte l, byte r ) gsl_noexcept
+{
+    return !( l == r );
+}
+
+gsl_api inline gsl_constexpr bool operator< ( byte l, byte r ) gsl_noexcept
+{
+    return l.v < r.v;
+}
+
+gsl_api inline gsl_constexpr bool operator<=( byte l, byte r ) gsl_noexcept
+{
+    return !( r < l );
+}
+
+gsl_api inline gsl_constexpr bool operator> ( byte l, byte r ) gsl_noexcept
+{
+    return ( r < l );
+}
+
+gsl_api inline gsl_constexpr bool operator>=( byte l, byte r ) gsl_noexcept
+{
+    return !( l < r );
+}
+#endif
+
+template< class IntegerType  gsl_ENABLE_IF_INTEGRAL_T( IntegerType ) >
+gsl_api inline gsl_constexpr14 byte & operator<<=( byte & b, IntegerType shift ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return b = to_byte( to_uchar( b ) << shift );
+#else
+    b.v = to_uchar( b.v << shift ); return b;
+#endif
+}
+
+template< class IntegerType  gsl_ENABLE_IF_INTEGRAL_T( IntegerType ) >
+gsl_api inline gsl_constexpr byte operator<<( byte b, IntegerType shift ) gsl_noexcept
+{
+    return to_byte( to_uchar( b ) << shift );
+}
+
+template< class IntegerType  gsl_ENABLE_IF_INTEGRAL_T( IntegerType ) >
+gsl_api inline gsl_constexpr14 byte & operator>>=( byte & b, IntegerType shift ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return b = to_byte( to_uchar( b ) >> shift );
+#else
+    b.v = to_uchar( b.v >> shift ); return b;
+#endif
+}
+
+template< class IntegerType  gsl_ENABLE_IF_INTEGRAL_T( IntegerType ) >
+gsl_api inline gsl_constexpr byte operator>>( byte b, IntegerType shift ) gsl_noexcept
+{
+    return to_byte( to_uchar( b ) >> shift );
+}
+
+gsl_api inline gsl_constexpr14 byte & operator|=( byte & l, byte r ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return l = to_byte( to_uchar( l ) | to_uchar( r ) );
+#else
+    l.v = to_uchar( l ) | to_uchar( r ); return l;
+#endif
+}
+
+gsl_api inline gsl_constexpr byte operator|( byte l, byte r ) gsl_noexcept
+{
+    return to_byte( to_uchar( l ) | to_uchar( r ) );
+}
+
+gsl_api inline gsl_constexpr14 byte & operator&=( byte & l, byte r ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return l = to_byte( to_uchar( l ) & to_uchar( r ) );
+#else
+    l.v = to_uchar( l ) & to_uchar( r ); return l;
+#endif
+}
+
+gsl_api inline gsl_constexpr byte operator&( byte l, byte r ) gsl_noexcept
+{
+    return to_byte( to_uchar( l ) & to_uchar( r ) );
+}
+
+gsl_api inline gsl_constexpr14 byte & operator^=( byte & l, byte r ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return l = to_byte( to_uchar( l ) ^ to_uchar (r ) );
+#else
+    l.v = to_uchar( l ) ^ to_uchar (r ); return l;
+#endif
+}
+
+gsl_api inline gsl_constexpr byte operator^( byte l, byte r ) gsl_noexcept
+{
+    return to_byte( to_uchar( l ) ^ to_uchar( r ) );
+}
+
+gsl_api inline gsl_constexpr byte operator~( byte b ) gsl_noexcept
+{
+    return to_byte( ~to_uchar( b ) );
+}
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+// Tag to select span constructor taking a container (prevent ms-gsl warning C26426):
+
+struct with_container_t { gsl_constexpr with_container_t() gsl_noexcept {} };
+const  gsl_constexpr   with_container_t with_container;
+
+#endif
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+namespace detail {
+
+// Can construct from containers that:
+
+template< class Container, class ElementType
+    gsl_REQUIRES_T((
+        ! detail::is_span< Container >::value
+        && ! detail::is_array< Container >::value
+        && ! detail::is_std_array< Container >::value
+        && std::is_convertible<typename std::remove_pointer<decltype(std::declval<Container>().data())>::type(*)[], ElementType(*)[] >::value
+    ))
+#if gsl_HAVE( STD_DATA )
+      // data(cont) and size(cont) well-formed:
+    , class = decltype( std::data( std::declval<Container>() ) )
+    , class = decltype( std::size( std::declval<Container>() ) )
+#endif
+>
+struct can_construct_span_from : std11::true_type{};
+
+} // namespace detail
+
+#endif
+
+//
+// span<> - A 1D view of contiguous T's, replace (*,len).
+//
+template< class T >
+class span
+{
+    template< class U > friend class span;
+
+public:
+    typedef index index_type;
+
+    typedef T element_type;
+    typedef typename std11::remove_cv< T >::type value_type;
+
+    typedef T & reference;
+    typedef T * pointer;
+    typedef T const * const_pointer;
+    typedef T const & const_reference;
+
+    typedef pointer       iterator;
+    typedef const_pointer const_iterator;
+
+    typedef std::reverse_iterator< iterator >       reverse_iterator;
+    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+
+    typedef typename std::iterator_traits< iterator >::difference_type difference_type;
+
+    // 26.7.3.2 Constructors, copy, and assignment [span.cons]
+
+    gsl_api gsl_constexpr14 span() gsl_noexcept
+        : first_( gsl_nullptr )
+        , last_ ( gsl_nullptr )
+    {
+        Expects( size() == 0 );
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+
+#if gsl_HAVE( NULLPTR )
+    gsl_api gsl_constexpr14 span( std::nullptr_t, index_type gsl_EXPECTS_UNUSED_PARAM( size_in ) )
+        : first_( nullptr )
+        , last_ ( nullptr )
+    {
+        Expects( size_in == 0 );
+    }
+#endif
+
+#if gsl_HAVE( IS_DELETE )
+    gsl_api gsl_constexpr span( reference data_in )
+        : span( &data_in, 1 )
+    {}
+
+    gsl_api gsl_constexpr span( element_type && ) = delete;
+#endif
+
+#endif // deprecate
+
+    gsl_api gsl_constexpr14 span( pointer data_in, index_type size_in )
+        : first_( data_in )
+        , last_ ( data_in + size_in )
+    {
+        Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
+    }
+
+    gsl_api gsl_constexpr14 span( pointer first_in, pointer last_in )
+        : first_( first_in )
+        , last_ ( last_in )
+    {
+        Expects( first_in <= last_in );
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+
+    template< class U >
+    gsl_api gsl_constexpr14 span( U * & data_in, index_type size_in )
+        : first_( data_in )
+        , last_ ( data_in + size_in )
+    {
+        Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
+    }
+
+    template< class U >
+    gsl_api gsl_constexpr14 span( U * const & data_in, index_type size_in )
+        : first_( data_in )
+        , last_ ( data_in + size_in )
+    {
+        Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
+    }
+
+#endif // deprecate
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+    template< class U, size_t N >
+    gsl_api gsl_constexpr span( U (&arr)[N] ) gsl_noexcept
+        : first_( gsl_ADDRESSOF( arr[0] ) )
+        , last_ ( gsl_ADDRESSOF( arr[0] ) + N )
+    {}
+#else
+    template< size_t N
+# if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
+# endif
+    >
+    gsl_api gsl_constexpr span( element_type (&arr)[N] ) gsl_noexcept
+        : first_( gsl_ADDRESSOF( arr[0] ) )
+        , last_ ( gsl_ADDRESSOF( arr[0] ) + N )
+    {}
+#endif // deprecate
+
+#if gsl_HAVE( ARRAY )
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+
+    template< class U, size_t N >
+    gsl_api gsl_constexpr span( std::array< U, N > & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+    template< class U, size_t N >
+    gsl_api gsl_constexpr span( std::array< U, N > const & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+#else
+
+    template< size_t N
+# if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
+# endif
+    >
+    gsl_api gsl_constexpr span( std::array< value_type, N > & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+    template< size_t N
+# if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
+# endif
+    >
+    gsl_api gsl_constexpr span( std::array< value_type, N > const & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+#endif // deprecate
+#endif // gsl_HAVE( ARRAY )
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+    template< class Container
+        gsl_REQUIRES_T(( detail::can_construct_span_from< Container, element_type >::value ))
+    >
+    gsl_api gsl_constexpr span( Container & cont )
+        : first_( cont.data() )
+        , last_ ( cont.data() + cont.size() )
+    {}
+
+    template< class Container
+        gsl_REQUIRES_T(( 
+            std::is_const< element_type >::value 
+            && detail::can_construct_span_from< Container, element_type >::value
+        ))
+    >
+    gsl_api gsl_constexpr span( Container const & cont )
+        : first_( cont.data() )
+        , last_ ( cont.data() + cont.size() )
+    {}
+
+#elif gsl_HAVE( UNCONSTRAINED_SPAN_CONTAINER_CTOR )
+
+    template< class Container >
+    gsl_api gsl_constexpr span( Container & cont )
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+    template< class Container >
+    gsl_api gsl_constexpr span( Container const & cont )
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+#endif
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+    template< class Container >
+    gsl_api gsl_constexpr span( with_container_t, Container & cont )
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+    template< class Container >
+    gsl_api gsl_constexpr span( with_container_t, Container const & cont )
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+#endif
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 4 )
+    // constructor taking shared_ptr deprecated since 0.29.0
+
+#if gsl_HAVE( SHARED_PTR )
+    gsl_api gsl_constexpr span( shared_ptr<element_type> const & ptr )
+        : first_( ptr.get() )
+        , last_ ( ptr.get() ? ptr.get() + 1 : gsl_nullptr )
+    {}
+#endif
+
+    // constructors taking unique_ptr deprecated since 0.29.0
+
+#if gsl_HAVE( UNIQUE_PTR )
+# if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+    template< class ArrayElementType = typename std::add_pointer<element_type>::type >
+# else
+    template< class ArrayElementType >
+# endif
+    gsl_api gsl_constexpr span( unique_ptr<ArrayElementType> const & ptr, index_type count )
+        : first_( ptr.get() )
+        , last_ ( ptr.get() + count )
+    {}
+
+    gsl_api gsl_constexpr span( unique_ptr<element_type> const & ptr )
+        : first_( ptr.get() )
+        , last_ ( ptr.get() ? ptr.get() + 1 : gsl_nullptr )
+    {}
+#endif
+
+#endif // deprecate shared_ptr, unique_ptr
+
+#if gsl_HAVE( IS_DEFAULT ) && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 430, 600)
+    gsl_api gsl_constexpr span( span && ) gsl_noexcept = default;
+    gsl_api gsl_constexpr span( span const & ) = default;
+#else
+    gsl_api gsl_constexpr span( span const & other )
+        : first_( other.begin() )
+        , last_ ( other.end() )
+    {}
+#endif
+
+#if gsl_HAVE( IS_DEFAULT )
+    ~span() = default;
+#else
+    ~span() {}
+#endif
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_api gsl_constexpr14 span & operator=( span && ) gsl_noexcept = default;
+    gsl_api gsl_constexpr14 span & operator=( span const & ) gsl_noexcept = default;
+#else
+    gsl_api span & operator=( span other ) gsl_noexcept
+    {
+        other.swap( *this );
+        return *this;
+    }
+#endif
+
+    template< class U
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_convertible<U(*)[], element_type(*)[]>::value ))
+#endif
+    >
+    gsl_api gsl_constexpr span( span<U> const & other )
+        : first_( other.begin() )
+        , last_ ( other.end() )
+    {}
+
+#if 0
+    // Converting from other span ?
+    template< class U > operator=();
+#endif
+
+    // 26.7.3.3 Subviews [span.sub]
+
+    gsl_api gsl_constexpr14 span first( index_type count ) const gsl_noexcept
+    {
+        Expects( 0 <= count && count <= this->size() );
+        return span( this->data(), count );
+    }
+
+    gsl_api gsl_constexpr14 span last( index_type count ) const gsl_noexcept
+    {
+        Expects( 0 <= count && count <= this->size() );
+        return span( this->data() + this->size() - count, count );
+    }
+
+    gsl_api gsl_constexpr14 span subspan( index_type offset ) const gsl_noexcept
+    {
+        Expects( 0 <= offset && offset <= this->size() );
+        return span( this->data() + offset, this->size() - offset );
+    }
+
+    gsl_api gsl_constexpr14 span subspan( index_type offset, index_type count ) const gsl_noexcept
+    {
+        Expects(
+            0 <= offset && offset <= this->size() &&
+            0 <= count  && count <= this->size() - offset );
+        return span( this->data() + offset, count );
+    }
+
+    // 26.7.3.4 Observers [span.obs]
+
+    gsl_api gsl_constexpr index_type size() const gsl_noexcept
+    {
+        return narrow_cast<index_type>( last_ - first_ );
+    }
+
+    gsl_api gsl_constexpr std::ptrdiff_t ssize() const gsl_noexcept
+    {
+        return narrow_cast<std::ptrdiff_t>( last_ - first_ );
+    }
+
+    gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept
+    {
+        return size() * narrow_cast<index_type>( sizeof( element_type ) );
+    }
+
+    gsl_api gsl_constexpr bool empty() const gsl_noexcept
+    {
+        return size() == 0;
+    }
+
+    // 26.7.3.5 Element access [span.elem]
+
+    gsl_api gsl_constexpr reference operator[]( index_type index ) const
+    {
+       return at( index );
+    }
+
+    gsl_api gsl_constexpr reference operator()( index_type index ) const
+    {
+       return at( index );
+    }
+
+    gsl_api gsl_constexpr14 reference at( index_type index ) const
+    {
+       Expects( index < size() );
+       return first_[ index ];
+    }
+
+    gsl_api gsl_constexpr pointer data() const gsl_noexcept
+    {
+        return first_;
+    }
+
+    // 26.7.3.6 Iterator support [span.iterators]
+
+    gsl_api gsl_constexpr iterator begin() const gsl_noexcept
+    {
+        return iterator( first_ );
+    }
+
+    gsl_api gsl_constexpr iterator end() const gsl_noexcept
+    {
+        return iterator( last_ );
+    }
+
+    gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept
+    {
+#if gsl_CPP11_OR_GREATER
+        return { begin() };
+#else
+        return const_iterator( begin() );
+#endif
+    }
+
+    gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept
+    {
+#if gsl_CPP11_OR_GREATER
+        return { end() };
+#else
+        return const_iterator( end() );
+#endif
+    }
+
+    gsl_api gsl_constexpr reverse_iterator rbegin() const gsl_noexcept
+    {
+        return reverse_iterator( end() );
+    }
+
+    gsl_api gsl_constexpr reverse_iterator rend() const gsl_noexcept
+    {
+        return reverse_iterator( begin() );
+    }
+
+    gsl_api gsl_constexpr const_reverse_iterator crbegin() const gsl_noexcept
+    {
+        return const_reverse_iterator( cend() );
+    }
+
+    gsl_api gsl_constexpr const_reverse_iterator crend() const gsl_noexcept
+    {
+        return const_reverse_iterator( cbegin() );
+    }
+
+    gsl_api void swap( span & other ) gsl_noexcept
+    {
+        using std::swap;
+        swap( first_, other.first_ );
+        swap( last_ , other.last_  );
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 3 )
+    // member length() deprecated since 0.29.0
+
+    gsl_api gsl_constexpr index_type length() const gsl_noexcept
+    {
+        return size();
+    }
+
+    // member length_bytes() deprecated since 0.29.0
+
+    gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept
+    {
+        return size_bytes();
+    }
+#endif
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 2 )
+    // member as_bytes(), as_writeable_bytes deprecated since 0.17.0
+
+    gsl_api span< const byte > as_bytes() const gsl_noexcept
+    {
+        return span< const byte >( reinterpret_cast<const byte *>( data() ), size_bytes() ); // NOLINT
+    }
+
+    gsl_api span< byte > as_writeable_bytes() const gsl_noexcept
+    {
+        return span< byte >( reinterpret_cast<byte *>( data() ), size_bytes() ); // NOLINT
+    }
+
+#endif
+
+    template< class U >
+    gsl_api span< U > as_span() const gsl_noexcept
+    {
+        Expects( ( this->size_bytes() % sizeof(U) ) == 0 );
+        return span< U >( reinterpret_cast<U *>( this->data() ), this->size_bytes() / sizeof( U ) ); // NOLINT
+    }
+
+private:
+    pointer first_;
+    pointer last_;
+};
+
+// class template argument deduction guides:
+
+#if gsl_HAVE( DEDUCTION_GUIDES )   // gsl_CPP17_OR_GREATER
+
+template< class T, size_t N >
+span( T (&)[N] ) -> span<T /*, N*/>;
+
+template< class T, size_t N >
+span( std::array<T, N> & ) -> span<T /*, N*/>;
+
+template< class T, size_t N >
+span( std::array<T, N> const & ) -> span<const T /*, N*/>;
+
+template< class Container >
+span( Container& ) -> span<typename Container::value_type>;
+
+template< class Container >
+span( Container const & ) -> span<const typename Container::value_type>;
+
+#endif // gsl_HAVE( DEDUCTION_GUIDES )
+
+// 26.7.3.7 Comparison operators [span.comparison]
+
+#if gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator==( span<T> const & l, span<U> const & r )
+{
+    return  l.size()  == r.size()
+        && (l.begin() == r.begin() || std::equal( l.begin(), l.end(), r.begin() ) );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator< ( span<T> const & l, span<U> const & r )
+{
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+#else
+
+template< class T >
+gsl_api inline gsl_constexpr bool operator==( span<T> const & l, span<T> const & r )
+{
+    return  l.size()  == r.size()
+        && (l.begin() == r.begin() || std::equal( l.begin(), l.end(), r.begin() ) );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr bool operator< ( span<T> const & l, span<T> const & r )
+{
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+#endif
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator!=( span<T> const & l, span<U> const & r )
+{
+    return !( l == r );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator<=( span<T> const & l, span<U> const & r )
+{
+    return !( r < l );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator> ( span<T> const & l, span<U> const & r )
+{
+    return ( r < l );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr bool operator>=( span<T> const & l, span<U> const & r )
+{
+    return !( l < r );
+}
+
+// span algorithms
+
+template< class T >
+gsl_api inline gsl_constexpr std::size_t size( span<T> const & spn )
+{
+    return static_cast<std::size_t>( spn.size() );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr std::ptrdiff_t ssize( span<T> const & spn )
+{
+    return spn.ssize();
+}
+
+namespace detail {
+
+template< class II, class N, class OI >
+gsl_api inline OI copy_n( II first, N count, OI result )
+{
+    if ( count > 0 )
+    {
+        *result++ = *first;
+        for ( N i = 1; i < count; ++i )
+        {
+            *result++ = *++first;
+        }
+    }
+    return result;
+}
+}
+
+template< class T, class U >
+gsl_api inline void copy( span<T> src, span<U> dest )
+{
+#if gsl_CPP14_OR_GREATER // gsl_HAVE( TYPE_TRAITS ) (circumvent Travis clang 3.4)
+    static_assert( std::is_assignable<U &, T const &>::value, "Cannot assign elements of source span to elements of destination span" );
+#endif
+    Expects( dest.size() >= src.size() );
+    detail::copy_n( src.data(), src.size(), dest.data() );
+}
+
+// span creator functions (see ctors)
+
+template< class T >
+gsl_api inline span< const byte > as_bytes( span<T> spn ) gsl_noexcept
+{
+    return span< const byte >( reinterpret_cast<const byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+
+template< class T>
+gsl_api inline span< byte > as_writeable_bytes( span<T> spn ) gsl_noexcept
+{
+    return span< byte >( reinterpret_cast<byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+
+#if gsl_FEATURE_TO_STD( MAKE_SPAN )
+
+template< class T >
+gsl_api inline gsl_constexpr span<T>
+make_span( T * ptr, typename span<T>::index_type count )
+{
+    return span<T>( ptr, count );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr span<T>
+make_span( T * first, T * last )
+{
+    return span<T>( first, last );
+}
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr span<T>
+make_span( T (&arr)[N] )
+{
+    return span<T>( gsl_ADDRESSOF( arr[0] ), N );
+}
+
+#if gsl_HAVE( ARRAY )
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr span<T>
+make_span( std::array<T,N> & arr )
+{
+    return span<T>( arr );
+}
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr span<const T>
+make_span( std::array<T,N> const & arr )
+{
+    return span<const T>( arr );
+}
+#endif
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) && gsl_HAVE( AUTO )
+
+template< class Container, class = decltype(std::declval<Container>().data()) >
+gsl_api inline gsl_constexpr auto
+make_span( Container & cont ) -> span< typename Container::value_type >
+{
+    return span< typename Container::value_type >( cont );
+}
+
+template< class Container, class = decltype(std::declval<Container>().data()) >
+gsl_api inline gsl_constexpr auto
+make_span( Container const & cont ) -> span< const typename Container::value_type >
+{
+    return span< const typename Container::value_type >( cont );
+}
+
+#else
+
+template< class T >
+gsl_api inline span<T>
+make_span( std::vector<T> & cont )
+{
+    return span<T>( with_container, cont );
+}
+
+template< class T >
+gsl_api inline span<const T>
+make_span( std::vector<T> const & cont )
+{
+    return span<const T>( with_container, cont );
+}
+#endif
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+template< class Container >
+gsl_api inline gsl_constexpr span<typename Container::value_type>
+make_span( with_container_t, Container & cont ) gsl_noexcept
+{
+    return span< typename Container::value_type >( with_container, cont );
+}
+
+template< class Container >
+gsl_api inline gsl_constexpr span<const typename Container::value_type>
+make_span( with_container_t, Container const & cont ) gsl_noexcept
+{
+    return span< const typename Container::value_type >( with_container, cont );
+}
+
+#endif // gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+template< class Ptr >
+gsl_api inline span<typename Ptr::element_type>
+make_span( Ptr & ptr )
+{
+    return span<typename Ptr::element_type>( ptr );
+}
+
+template< class Ptr >
+gsl_api inline span<typename Ptr::element_type>
+make_span( Ptr & ptr, typename span<typename Ptr::element_type>::index_type count )
+{
+    return span<typename Ptr::element_type>( ptr, count);
+}
+
+#endif // gsl_FEATURE_TO_STD( MAKE_SPAN )
+
+#if gsl_FEATURE_TO_STD( BYTE_SPAN )
+
+template< class T >
+gsl_api inline gsl_constexpr span<byte>
+byte_span( T & t ) gsl_noexcept
+{
+    return span<byte>( reinterpret_cast<byte *>( &t ), sizeof(T) );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr span<const byte>
+byte_span( T const & t ) gsl_noexcept
+{
+    return span<const byte>( reinterpret_cast<byte const *>( &t ), sizeof(T) );
+}
+
+#endif // gsl_FEATURE_TO_STD( BYTE_SPAN )
+
+//
+// basic_string_span:
+//
+
+template< class T >
+class basic_string_span;
+
+namespace detail {
+
+template< class T >
+struct is_basic_string_span_oracle : std11::false_type {};
+
+template< class T >
+struct is_basic_string_span_oracle< basic_string_span<T> > : std11::true_type {};
+
+template< class T >
+struct is_basic_string_span : is_basic_string_span_oracle< typename std11::remove_cv<T>::type > {};
+
+template< class T >
+gsl_api inline gsl_constexpr14 std::size_t string_length( T * ptr, std::size_t max )
+{
+    if ( ptr == gsl_nullptr || max <= 0 )
+        return 0;
+
+    std::size_t len = 0;
+    while ( len < max && ptr[len] ) // NOLINT
+        ++len;
+
+    return len;
+}
+
+} // namespace detail
+
+//
+// basic_string_span<> - A view of contiguous characters, replace (*,len).
+//
+template< class T >
+class basic_string_span
+{
+public:
+    typedef T element_type;
+    typedef span<T> span_type;
+
+    typedef typename span_type::index_type index_type;
+    typedef typename span_type::difference_type difference_type;
+
+    typedef typename span_type::pointer pointer ;
+    typedef typename span_type::reference reference ;
+
+    typedef typename span_type::iterator iterator ;
+    typedef typename span_type::const_iterator const_iterator ;
+    typedef typename span_type::reverse_iterator reverse_iterator;
+    typedef typename span_type::const_reverse_iterator const_reverse_iterator;
+
+    // construction:
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_api gsl_constexpr basic_string_span() gsl_noexcept = default;
+#else
+    gsl_api gsl_constexpr basic_string_span() gsl_noexcept {}
+#endif
+
+#if gsl_HAVE( NULLPTR )
+    gsl_api gsl_constexpr basic_string_span( std::nullptr_t ptr ) gsl_noexcept
+    : span_( ptr, index_type( 0 ) )
+    {}
+#endif
+
+    gsl_api gsl_constexpr basic_string_span( pointer ptr )
+    : span_( remove_z( ptr, (std::numeric_limits<index_type>::max)() ) )
+    {}
+
+    gsl_api gsl_constexpr basic_string_span( pointer ptr, index_type count )
+    : span_( ptr, count )
+    {}
+
+    gsl_api gsl_constexpr basic_string_span( pointer firstElem, pointer lastElem )
+    : span_( firstElem, lastElem )
+    {}
+
+    template< std::size_t N >
+    gsl_api gsl_constexpr basic_string_span( element_type (&arr)[N] )
+    : span_( remove_z( gsl_ADDRESSOF( arr[0] ), N ) )
+    {}
+
+#if gsl_HAVE( ARRAY )
+
+    template< std::size_t N >
+    gsl_api gsl_constexpr basic_string_span( std::array< typename std11::remove_const<element_type>::type, N> & arr )
+    : span_( remove_z( arr ) )
+    {}
+
+    template< std::size_t N >
+    gsl_api gsl_constexpr basic_string_span( std::array< typename std11::remove_const<element_type>::type, N> const & arr )
+    : span_( remove_z( arr ) )
+    {}
+
+#endif
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+    // Exclude: array, [basic_string,] basic_string_span
+
+    template< class Container
+        gsl_REQUIRES_T((
+            ! detail::is_std_array< Container >::value
+            && ! detail::is_basic_string_span< Container >::value
+            && std::is_convertible< typename Container::pointer, pointer >::value
+            && std::is_convertible< typename Container::pointer, decltype(std::declval<Container>().data()) >::value
+        ))
+    >
+    gsl_api gsl_constexpr basic_string_span( Container & cont )
+    : span_( ( cont ) )
+    {}
+
+    // Exclude: array, [basic_string,] basic_string_span
+
+    template< class Container
+        gsl_REQUIRES_T((
+            ! detail::is_std_array< Container >::value
+            && ! detail::is_basic_string_span< Container >::value
+            && std::is_convertible< typename Container::pointer, pointer >::value
+            && std::is_convertible< typename Container::pointer, decltype(std::declval<Container const &>().data()) >::value
+        ))
+    >
+    gsl_api gsl_constexpr basic_string_span( Container const & cont )
+    : span_( ( cont ) )
+    {}
+
+#elif gsl_HAVE( UNCONSTRAINED_SPAN_CONTAINER_CTOR )
+
+    template< class Container >
+    gsl_api gsl_constexpr basic_string_span( Container & cont )
+    : span_( cont )
+    {}
+
+    template< class Container >
+    gsl_api gsl_constexpr basic_string_span( Container const & cont )
+    : span_( cont )
+    {}
+
+#else
+
+    template< class U >
+    gsl_api gsl_constexpr basic_string_span( span<U> const & rhs )
+    : span_( rhs )
+    {}
+
+#endif
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+    template< class Container >
+    gsl_api gsl_constexpr basic_string_span( with_container_t, Container & cont )
+    : span_( with_container, cont )
+    {}
+#endif
+
+#if gsl_HAVE( IS_DEFAULT )
+# if gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 440, 600 )
+    gsl_api gsl_constexpr basic_string_span( basic_string_span const & rhs ) = default;
+
+    gsl_api gsl_constexpr basic_string_span( basic_string_span && rhs ) = default;
+# else
+    gsl_api gsl_constexpr basic_string_span( basic_string_span const & rhs ) gsl_noexcept = default;
+
+    gsl_api gsl_constexpr basic_string_span( basic_string_span && rhs ) gsl_noexcept = default;
+# endif
+#endif
+
+    template< class U
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+        gsl_REQUIRES_T(( std::is_convertible<typename basic_string_span<U>::pointer, pointer>::value ))
+#endif
+    >
+    gsl_api gsl_constexpr basic_string_span( basic_string_span<U> const & rhs )
+    : span_( reinterpret_cast<pointer>( rhs.data() ), rhs.length() ) // NOLINT
+    {}
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+    template< class U
+        gsl_REQUIRES_T(( std::is_convertible<typename basic_string_span<U>::pointer, pointer>::value ))
+    >
+    gsl_api gsl_constexpr basic_string_span( basic_string_span<U> && rhs )
+    : span_( reinterpret_cast<pointer>( rhs.data() ), rhs.length() ) // NOLINT
+    {}
+#endif
+
+    template< class CharTraits, class Allocator >
+    gsl_api gsl_constexpr basic_string_span(
+        std::basic_string< typename std11::remove_const<element_type>::type, CharTraits, Allocator > & str )
+    : span_( gsl_ADDRESSOF( str[0] ), str.length() )
+    {}
+
+    template< class CharTraits, class Allocator >
+    gsl_api gsl_constexpr basic_string_span(
+        std::basic_string< typename std11::remove_const<element_type>::type, CharTraits, Allocator > const & str )
+    : span_( gsl_ADDRESSOF( str[0] ), str.length() )
+    {}
+
+    // destruction, assignment:
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_api ~basic_string_span() gsl_noexcept = default;
+
+    gsl_api basic_string_span & operator=( basic_string_span const & rhs ) gsl_noexcept = default;
+
+    gsl_api basic_string_span & operator=( basic_string_span && rhs ) gsl_noexcept = default;
+#endif
+
+    // sub span:
+
+    gsl_api gsl_constexpr basic_string_span first( index_type count ) const
+    {
+        return span_.first( count );
+    }
+
+    gsl_api gsl_constexpr basic_string_span last( index_type count ) const
+    {
+        return span_.last( count );
+    }
+
+    gsl_api gsl_constexpr basic_string_span subspan( index_type offset ) const
+    {
+        return span_.subspan( offset );
+    }
+
+    gsl_api gsl_constexpr basic_string_span subspan( index_type offset, index_type count ) const
+    {
+        return span_.subspan( offset, count );
+    }
+
+    // observers:
+
+    gsl_api gsl_constexpr index_type length() const gsl_noexcept
+    {
+        return span_.size();
+    }
+
+    gsl_api gsl_constexpr index_type size() const gsl_noexcept
+    {
+        return span_.size();
+    }
+
+    gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept
+    {
+        return span_.size_bytes();
+    }
+
+    gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept
+    {
+        return span_.size_bytes();
+    }
+
+    gsl_api gsl_constexpr bool empty() const gsl_noexcept
+    {
+        return size() == 0;
+    }
+
+    gsl_api gsl_constexpr reference operator[]( index_type idx ) const
+    {
+        return span_[idx];
+    }
+
+    gsl_api gsl_constexpr reference operator()( index_type idx ) const
+    {
+        return span_[idx];
+    }
+
+    gsl_api gsl_constexpr pointer data() const gsl_noexcept
+    {
+        return span_.data();
+    }
+
+    gsl_api iterator begin() const gsl_noexcept
+    {
+        return span_.begin();
+    }
+
+    gsl_api iterator end() const gsl_noexcept
+    {
+        return span_.end();
+    }
+
+    gsl_api reverse_iterator rbegin() const gsl_noexcept
+    {
+        return span_.rbegin();
+    }
+
+    gsl_api reverse_iterator rend() const gsl_noexcept
+    {
+        return span_.rend();
+    }
+
+    // const version not in p0123r2:
+
+    gsl_api const_iterator cbegin() const gsl_noexcept
+    {
+        return span_.cbegin();
+    }
+
+    gsl_api const_iterator cend() const gsl_noexcept
+    {
+        return span_.cend();
+    }
+
+    gsl_api const_reverse_iterator crbegin() const gsl_noexcept
+    {
+        return span_.crbegin();
+    }
+
+    gsl_api const_reverse_iterator crend() const gsl_noexcept
+    {
+        return span_.crend();
+    }
+
+private:
+    gsl_api static gsl_constexpr14 span_type remove_z( pointer const & sz, std::size_t max )
+    {
+        return span_type( sz, detail::string_length( sz, max ) );
+    }
+
+#if gsl_HAVE( ARRAY )
+    template< size_t N >
+    gsl_api static gsl_constexpr14 span_type remove_z( std::array<typename std11::remove_const<element_type>::type, N> & arr )
+    {
+        return remove_z( gsl_ADDRESSOF( arr[0] ), narrow_cast< std::size_t >( N ) );
+    }
+
+    template< size_t N >
+    gsl_api static gsl_constexpr14 span_type remove_z( std::array<typename std11::remove_const<element_type>::type, N> const & arr )
+    {
+        return remove_z( gsl_ADDRESSOF( arr[0] ), narrow_cast< std::size_t >( N ) );
+    }
+#endif
+
+private:
+    span_type span_;
+};
+
+// basic_string_span comparison functions:
+
+#if gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+gsl_api inline gsl_constexpr14 bool operator==( basic_string_span<T> const & l, U const & u ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > r( u );
+
+    return l.size() == r.size()
+        && std::equal( l.begin(), l.end(), r.begin() );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr14 bool operator<( basic_string_span<T> const & l, U const & u ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > r( u );
+
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+template< class T, class U
+    gsl_REQUIRES_T(( !detail::is_basic_string_span<U>::value )) 
+>
+gsl_api inline gsl_constexpr14 bool operator==( U const & u, basic_string_span<T> const & r ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > l( u );
+
+    return l.size() == r.size()
+        && std::equal( l.begin(), l.end(), r.begin() );
+}
+
+template< class T, class U
+    gsl_REQUIRES_T(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_api inline gsl_constexpr14 bool operator<( U const & u, basic_string_span<T> const & r ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > l( u );
+
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+#endif
+
+#else //gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T >
+gsl_api inline gsl_constexpr14 bool operator==( basic_string_span<T> const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return l.size() == r.size()
+        && std::equal( l.begin(), l.end(), r.begin() );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr14 bool operator<( basic_string_span<T> const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+#endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+gsl_api inline gsl_constexpr14 bool operator!=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+    return !( l == r );
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr14 bool operator<=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) || ! gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+    return !( r < l );
+#else
+    basic_string_span< typename std11::add_const<T>::type > rr( r );
+    return !( rr < l );
+#endif
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr14 bool operator>( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) || ! gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+    return ( r < l );
+#else
+    basic_string_span< typename std11::add_const<T>::type > rr( r );
+    return ( rr < l );
+#endif
+}
+
+template< class T, class U >
+gsl_api inline gsl_constexpr14 bool operator>=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+    return !( l < r );
+}
+
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+template< class T, class U
+    gsl_REQUIRES_T(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_api inline gsl_constexpr14 bool operator!=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return !( l == r );
+}
+
+template< class T, class U
+    gsl_REQUIRES_T(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_api inline gsl_constexpr14 bool operator<=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return !( r < l );
+}
+
+template< class T, class U
+    gsl_REQUIRES_T(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_api inline gsl_constexpr14 bool operator>( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return ( r < l );
+}
+
+template< class T, class U
+    gsl_REQUIRES_T(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_api inline gsl_constexpr14 bool operator>=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return !( l < r );
+}
+
+#endif // gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+// convert basic_string_span to byte span:
+
+template< class T >
+gsl_api inline span< const byte > as_bytes( basic_string_span<T> spn ) gsl_noexcept
+{
+    return span< const byte >( reinterpret_cast<const byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+
+//
+// String types:
+//
+
+typedef char * zstring;
+typedef const char * czstring;
+
+#if gsl_HAVE( WCHAR )
+typedef wchar_t * zwstring;
+typedef const wchar_t * cwzstring;
+#endif
+
+typedef basic_string_span< char > string_span;
+typedef basic_string_span< char const > cstring_span;
+
+#if gsl_HAVE( WCHAR )
+typedef basic_string_span< wchar_t > wstring_span;
+typedef basic_string_span< wchar_t const > cwstring_span;
+#endif
+
+// to_string() allow (explicit) conversions from string_span to string
+
+#if 0
+
+template< class T >
+gsl_api inline std::basic_string< typename std::remove_const<T>::type > to_string( basic_string_span<T> spn )
+{
+     std::string( spn.data(), spn.length() );
+}
+
+#else
+
+gsl_api inline std::string to_string( string_span const & spn )
+{
+    return std::string( spn.data(), spn.length() );
+}
+
+gsl_api inline std::string to_string( cstring_span const & spn )
+{
+    return std::string( spn.data(), spn.length() );
+}
+
+#if gsl_HAVE( WCHAR )
+
+gsl_api inline std::wstring to_string( wstring_span const & spn )
+{
+    return std::wstring( spn.data(), spn.length() );
+}
+
+gsl_api inline std::wstring to_string( cwstring_span const & spn )
+{
+    return std::wstring( spn.data(), spn.length() );
+}
+
+#endif // gsl_HAVE( WCHAR )
+#endif // to_string()
+
+//
+// Stream output for string_span types
+//
+
+namespace detail {
+
+template< class Stream >
+gsl_api void write_padding( Stream & os, std::streamsize n )
+{
+    for ( std::streamsize i = 0; i < n; ++i )
+        os.rdbuf()->sputc( os.fill() );
+}
+
+template< class Stream, class Span >
+gsl_api Stream & write_to_stream( Stream & os, Span const & spn )
+{
+    typename Stream::sentry sentry( os );
+
+    if ( !os )
+        return os;
+
+    const std::streamsize length = narrow<std::streamsize>( spn.length() );
+
+    // Whether, and how, to pad
+    const bool pad = ( length < os.width() );
+    const bool left_pad = pad && ( os.flags() & std::ios_base::adjustfield ) == std::ios_base::right;
+
+    if ( left_pad )
+        write_padding( os, os.width() - length );
+
+    // Write span characters
+    os.rdbuf()->sputn( spn.begin(), length );
+
+    if ( pad && !left_pad )
+        write_padding( os, os.width() - length );
+
+    // Reset output stream width
+    os.width(0);
+
+    return os;
+}
+
+} // namespace detail
+
+template< typename Traits >
+gsl_api std::basic_ostream< char, Traits > & operator<<( std::basic_ostream< char, Traits > & os, string_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+template< typename Traits >
+gsl_api std::basic_ostream< char, Traits > & operator<<( std::basic_ostream< char, Traits > & os, cstring_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+#if gsl_HAVE( WCHAR )
+
+template< typename Traits >
+gsl_api std::basic_ostream< wchar_t, Traits > & operator<<( std::basic_ostream< wchar_t, Traits > & os, wstring_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+template< typename Traits >
+gsl_api std::basic_ostream< wchar_t, Traits > & operator<<( std::basic_ostream< wchar_t, Traits > & os, cwstring_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+#endif // gsl_HAVE( WCHAR )
+
+//
+// ensure_sentinel()
+//
+// Provides a way to obtain a span from a contiguous sequence
+// that ends with a (non-inclusive) sentinel value.
+//
+// Will fail-fast if sentinel cannot be found before max elements are examined.
+//
+namespace detail {
+
+template< class T, class SizeType, const T Sentinel >
+gsl_api static span<T> ensure_sentinel( T * seq, SizeType max = (std::numeric_limits<SizeType>::max)() )
+{
+    typedef T * pointer;
+
+    gsl_SUPPRESS_MSVC_WARNING( 26429, "f.23: symbol 'cur' is never tested for nullness, it can be marked as not_null" )
+
+    pointer cur = seq;
+
+    while ( static_cast<SizeType>( cur - seq ) < max && *cur != Sentinel )
+        ++cur;
+
+    Expects( *cur == Sentinel );
+
+    return span<T>( seq, narrow_cast< typename span<T>::index_type >( cur - seq ) );
+}
+} // namespace detail
+
+//
+// ensure_z - creates a string_span for a czstring or cwzstring.
+// Will fail fast if a null-terminator cannot be found before
+// the limit of size_type.
+//
+
+template< class T >
+gsl_api inline span<T> ensure_z( T * const & sz, size_t max = (std::numeric_limits<size_t>::max)() )
+{
+    return detail::ensure_sentinel<T, size_t, 0>( sz, max );
+}
+
+template< class T, size_t N >
+gsl_api inline span<T> ensure_z( T (&sz)[N] )
+{
+    return ensure_z( gsl_ADDRESSOF( sz[0] ), N );
+}
+
+# if gsl_HAVE( TYPE_TRAITS )
+
+template< class Container >
+gsl_api inline span< typename std::remove_pointer<typename Container::pointer>::type >
+ensure_z( Container & cont )
+{
+    return ensure_z( cont.data(), cont.length() );
+}
+# endif
+
+} // namespace gsl
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+
+namespace std {
+
+template<>
+struct hash< gsl::byte >
+{
+public:
+    std::size_t operator()( gsl::byte v ) const gsl_noexcept
+    {
+        return gsl::to_integer<std::size_t>( v );
+    }
+};
+
+} // namespace std
+
+#endif
+
+gsl_RESTORE_MSVC_WARNINGS()
+
+#endif // GSL_GSL_LITE_HPP_INCLUDED
+
+// end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..74550b971c696bf3c35aae6742f0f600ff5346db
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/CMakeLists.txt
@@ -0,0 +1,1219 @@
+# ---------------------------------------------------------------
+# Programmer: Radu Serban, David J. Gardner, Cody J. Balos,
+#             and Slaven Peles @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Top level CMakeLists.txt for SUNDIALS (for cmake build system)
+# ---------------------------------------------------------------
+
+# ---------------------------------------------------------------
+# Initial commands
+# ---------------------------------------------------------------
+
+# Require a fairly recent cmake version
+cmake_minimum_required(VERSION 3.1.3)
+
+# Libraries linked via full path no longer produce linker search paths
+# Allows examples to build
+if(COMMAND cmake_policy)
+  cmake_policy(SET CMP0003 NEW)
+endif(COMMAND cmake_policy)
+
+# MACOSX_RPATH is enabled by default
+# Fixes dynamic loading on OSX
+if(POLICY CMP0042)
+  cmake_policy(SET CMP0042 NEW) # Added in CMake 3.0
+else()
+  if(APPLE)
+    set(CMAKE_MACOSX_RPATH 1)
+  endif()
+endif()
+
+# Project SUNDIALS (initially only C supported)
+# sets PROJECT_SOURCE_DIR and PROJECT_BINARY_DIR variables
+PROJECT(sundials C)
+
+# Set some variables with info on the SUNDIALS project
+SET(PACKAGE_BUGREPORT "woodward6@llnl.gov")
+SET(PACKAGE_NAME "SUNDIALS")
+SET(PACKAGE_STRING "SUNDIALS 4.0.2")
+SET(PACKAGE_TARNAME "sundials")
+
+# set SUNDIALS version numbers
+# (use "" for the version label if none is needed)
+SET(PACKAGE_VERSION_MAJOR "4")
+SET(PACKAGE_VERSION_MINOR "0")
+SET(PACKAGE_VERSION_PATCH "2")
+SET(PACKAGE_VERSION_LABEL "")
+
+IF(PACKAGE_VERSION_LABEL)
+  SET(PACKAGE_VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_PATCH}-${PACKAGE_VERSION_LABEL}")
+ELSE()
+  SET(PACKAGE_VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_PATCH}")
+ENDIF()
+
+SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# Prohibit in-source build
+IF("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+  MESSAGE(FATAL_ERROR "In-source build prohibited.")
+ENDIF("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+
+# Hide some cache variables
+MARK_AS_ADVANCED(EXECUTABLE_OUTPUT_PATH LIBRARY_OUTPUT_PATH)
+
+# Always show the C compiler and flags
+MARK_AS_ADVANCED(CLEAR
+  CMAKE_C_COMPILER
+  CMAKE_C_FLAGS)
+
+# Specify the VERSION and SOVERSION for shared libraries
+
+SET(arkodelib_VERSION "3.0.2")
+SET(arkodelib_SOVERSION "3")
+
+SET(cvodelib_VERSION "4.0.2")
+SET(cvodelib_SOVERSION "4")
+
+SET(cvodeslib_VERSION "4.0.2")
+SET(cvodeslib_SOVERSION "4")
+
+SET(idalib_VERSION "4.0.2")
+SET(idalib_SOVERSION "4")
+
+SET(idaslib_VERSION "3.0.2")
+SET(idaslib_SOVERSION "3")
+
+SET(kinsollib_VERSION "4.0.2")
+SET(kinsollib_SOVERSION "4")
+
+SET(cpodeslib_VERSION "0.0.0")
+SET(cpodeslib_SOVERSION "0")
+
+SET(nveclib_VERSION "4.0.2")
+SET(nveclib_SOVERSION "4")
+
+SET(sunmatrixlib_VERSION "2.0.2")
+SET(sunmatrixlib_SOVERSION "2")
+
+SET(sunlinsollib_VERSION "2.0.2")
+SET(sunlinsollib_SOVERSION "2")
+
+SET(sunnonlinsollib_VERSION "1.0.2")
+SET(sunnonlinsollib_SOVERSION "1")
+
+# Specify the location of additional CMAKE modules
+SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/config)
+
+# Get correct build paths automatically, but expose CMAKE_INSTALL_LIBDIR
+# as a regular cache variable so that a user can more easily see what
+# the library dir was set to be by GNUInstallDirs.
+INCLUDE(GNUInstallDirs)
+MARK_AS_ADVANCED(CLEAR CMAKE_INSTALL_LIBDIR)
+
+# ---------------------------------------------------------------
+# MACRO definitions
+# ---------------------------------------------------------------
+INCLUDE(SundialsCMakeMacros)
+INCLUDE(SundialsAddF2003InterfaceLibrary)
+
+# ---------------------------------------------------------------
+# Check for deprecated SUNDIALS CMake options/variables
+# ---------------------------------------------------------------
+INCLUDE(SundialsDeprecated)
+
+# ---------------------------------------------------------------
+# Which modules to build?
+# ---------------------------------------------------------------
+
+# For each SUNDIALS solver available (i.e. for which we have the
+# sources), give the user the option of enabling/disabling it.
+
+IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/arkode")
+  OPTION(BUILD_ARKODE "Build the ARKODE library" ON)
+ELSE()
+  SET(BUILD_ARKODE OFF)
+ENDIF()
+
+IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/cvode")
+  OPTION(BUILD_CVODE "Build the CVODE library" ON)
+ELSE()
+  SET(BUILD_CVODE OFF)
+ENDIF()
+
+IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/cvodes")
+  OPTION(BUILD_CVODES "Build the CVODES library" ON)
+ELSE()
+  SET(BUILD_CVODES OFF)
+ENDIF()
+
+IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/ida")
+  OPTION(BUILD_IDA "Build the IDA library" ON)
+ELSE()
+  SET(BUILD_IDA OFF)
+ENDIF()
+
+IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/idas")
+  OPTION(BUILD_IDAS "Build the IDAS library" ON)
+ELSE()
+  SET(BUILD_IDAS OFF)
+ENDIF()
+
+IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/kinsol")
+  OPTION(BUILD_KINSOL "Build the KINSOL library" ON)
+ELSE()
+  SET(BUILD_KINSOL OFF)
+ENDIF()
+
+# CPODES is always OFF for now.  (commented out for Release); ToDo: better way to do this?
+#IF(IS_DIRECTORY "${sundials_SOURCE_DIR}/src/cpodes")
+#  OPTION(BUILD_CPODES  "Build the CPODES library"  OFF)
+#ELSE()
+#  SET(BUILD_CPODES OFF)
+#ENDIF()
+
+# ---------------------------------------------------------------
+# xSDK specific options
+# ---------------------------------------------------------------
+INCLUDE(SundialsXSDK)
+
+# ---------------------------------------------------------------
+# Build specific C flags
+# ---------------------------------------------------------------
+
+# Hide all build type specific flags
+MARK_AS_ADVANCED(FORCE
+  CMAKE_C_FLAGS_DEBUG
+  CMAKE_C_FLAGS_MINSIZEREL
+  CMAKE_C_FLAGS_RELEASE
+  CMAKE_C_FLAGS_RELWITHDEBINFO)
+
+# Only show flags for the current build type if it is set
+# NOTE: Build specific flags are appended those in CMAKE_C_FLAGS
+IF(CMAKE_BUILD_TYPE)
+  IF(CMAKE_BUILD_TYPE MATCHES "Debug")
+    MESSAGE("Appending C debug flags")
+    MARK_AS_ADVANCED(CLEAR CMAKE_C_FLAGS_DEBUG)
+  ELSEIF(CMAKE_BUILD_TYPE MATCHES "MinSizeRel")
+    MESSAGE("Appending C min size release flags")
+    MARK_AS_ADVANCED(CLEAR CMAKE_C_FLAGS_MINSIZEREL)
+  ELSEIF(CMAKE_BUILD_TYPE MATCHES "Release")
+    MESSAGE("Appending C release flags")
+    MARK_AS_ADVANCED(CLEAR CMAKE_C_FLAGS_RELEASE)
+  ELSEIF(CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
+    MESSAGE("Appending C release with debug info flags")
+    MARK_AS_ADVANCED(CLEAR CMAKE_C_FLAGS_RELWITHDEBINFO)
+  ENDIF()
+ENDIF()
+
+# ---------------------------------------------------------------
+# Option to specify precision (realtype)
+# ---------------------------------------------------------------
+
+SET(DOCSTR "single, double, or extended")
+SHOW_VARIABLE(SUNDIALS_PRECISION STRING "${DOCSTR}" "double")
+
+# prepare substitution variable PRECISION_LEVEL for sundials_config.h
+STRING(TOUPPER ${SUNDIALS_PRECISION} SUNDIALS_PRECISION)
+SET(PRECISION_LEVEL "#define SUNDIALS_${SUNDIALS_PRECISION}_PRECISION 1")
+
+# prepare substitution variable FPRECISION_LEVEL for sundials_fconfig.h
+IF(SUNDIALS_PRECISION MATCHES "SINGLE")
+  SET(FPRECISION_LEVEL "4")
+ENDIF(SUNDIALS_PRECISION MATCHES "SINGLE")
+IF(SUNDIALS_PRECISION MATCHES "DOUBLE")
+  SET(FPRECISION_LEVEL "8")
+ENDIF(SUNDIALS_PRECISION MATCHES "DOUBLE")
+IF(SUNDIALS_PRECISION MATCHES "EXTENDED")
+  SET(FPRECISION_LEVEL "16")
+ENDIF(SUNDIALS_PRECISION MATCHES "EXTENDED")
+
+# ---------------------------------------------------------------
+# Option to specify index type
+# ---------------------------------------------------------------
+
+SET(DOCSTR "Signed 64-bit (64) or signed 32-bit (32) integer")
+SHOW_VARIABLE(SUNDIALS_INDEX_SIZE STRING "${DOCSTR}" "64")
+SET(DOCSTR "Integer type to use for indices in SUNDIALS")
+SHOW_VARIABLE(SUNDIALS_INDEX_TYPE STRING "${DOCSTR}" "")
+MARK_AS_ADVANCED(SUNDIALS_INDEX_TYPE)
+include(SundialsIndexSize)
+
+# ---------------------------------------------------------------
+# Enable Fortran interface?
+# ---------------------------------------------------------------
+
+# Fortran interface is disabled by default
+SET(DOCSTR "Enable Fortran 77 interfaces")
+OPTION(F77_INTERFACE_ENABLE "${DOCSTR}" OFF)
+
+# Check that at least one solver with a Fortran 77 interface is built
+IF(NOT BUILD_ARKODE AND NOT BUILD_CVODE AND NOT BUILD_IDA AND NOT BUILD_KINSOL)
+  IF(F77_INTERFACE_ENABLE)
+    PRINT_WARNING("Enabled packages do not support Fortran 77 interface" "Disabling F77 interface")
+    FORCE_VARIABLE(F77_INTERFACE_ENABLE BOOL "${DOCSTR}" OFF)
+  ENDIF()
+  HIDE_VARIABLE(F77_INTERFACE_ENABLE)
+ENDIF()
+
+# Fortran 2003 interface is disabled by default
+SET(DOCSTR "Enable Fortran 2003 interfaces")
+OPTION(F2003_INTERFACE_ENABLE "${DOCSTR}" OFF)
+
+# Check that at least one solver with a Fortran 2003 interface is built
+IF(NOT BUILD_CVODE)
+  IF(F2003_INTERFACE_ENABLE)
+    PRINT_WARNING("Enabled packages do not support Fortran 2003 interface" "Disabling F2003 interface")
+    FORCE_VARIABLE(F2003_INTERFACE_ENABLE BOOL "${DOCSTR}" OFF)
+  ENDIF()
+  HIDE_VARIABLE(F2003_INTERFACE_ENABLE)
+ENDIF()
+
+IF(F2003_INTERFACE_ENABLE)
+  # F2003 interface only supports double precision
+  IF(NOT (SUNDIALS_PRECISION MATCHES "DOUBLE"))
+    PRINT_WARNING("F2003 interface is not compatible with ${SUNDIALS_PRECISION} precision"
+                  "Disabling F2003 interface")
+    FORCE_VARIABLE(F2003_INTERFACE_ENABLE BOOL "${DOCSTR}" OFF)
+  ENDIF()
+
+  # F2003 interface only supports 64-bit indices
+  IF(NOT (SUNDIALS_INDEX_SIZE MATCHES "64"))
+    PRINT_WARNING("F2003 interface is not compatible with ${SUNDIALS_INDEX_SIZE}-bit indicies"
+                  "Disabling F2003 interface")
+    FORCE_VARIABLE(F2003_INTERFACE_ENABLE BOOL "${DOCSTR}" OFF)
+  ENDIF()
+
+  # Put all F2003 modules into one build directory
+  SET(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/fortran")
+
+  # Allow a user to set where the Fortran modules will be installed
+  SET(DOCSTR "Directory where Fortran module files are installed")
+  SHOW_VARIABLE(Fortran_INSTALL_MODDIR DIRECTORY "${DOCSTR}" "fortran")
+ENDIF()
+
+# ---------------------------------------------------------------
+# Options to build static and/or shared libraries
+# ---------------------------------------------------------------
+
+OPTION(BUILD_STATIC_LIBS "Build static libraries" ON)
+OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
+
+# Prepare substitution variable SUNDIALS_EXPORT for sundials_config.h
+# When building shared SUNDIALS libraries under Windows, use
+#      #define SUNDIALS_EXPORT __declspec(dllexport)
+# When linking to shared SUNDIALS libraries under Windows, use
+#      #define SUNDIALS_EXPORT __declspec(dllimport)
+# In all other cases (other platforms or static libraries
+# under Windows), the SUNDIALS_EXPORT macro is empty
+
+IF(BUILD_SHARED_LIBS AND WIN32)
+  SET(SUNDIALS_EXPORT
+    "#ifdef BUILD_SUNDIALS_LIBRARY
+#define SUNDIALS_EXPORT __declspec(dllexport)
+#else
+#define SUNDIALS_EXPORT __declspec(dllimport)
+#endif")
+ELSE(BUILD_SHARED_LIBS AND WIN32)
+  SET(SUNDIALS_EXPORT "#define SUNDIALS_EXPORT")
+ENDIF(BUILD_SHARED_LIBS AND WIN32)
+
+# Make sure we build at least one type of libraries
+IF(NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
+  PRINT_WARNING("Both static and shared library generation were disabled"
+                "Building static libraries was re-enabled")
+  FORCE_VARIABLE(BUILD_STATIC_LIBS BOOL "Build static libraries" ON)
+ENDIF(NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
+
+# ---------------------------------------------------------------
+# Option to use the generic math libraries (UNIX only)
+# ---------------------------------------------------------------
+
+IF(UNIX)
+  OPTION(USE_GENERIC_MATH "Use generic (std-c) math libraries" ON)
+  IF(USE_GENERIC_MATH)
+    # executables will be linked against -lm
+    SET(EXTRA_LINK_LIBS -lm)
+    # prepare substitution variable for sundials_config.h
+    SET(SUNDIALS_USE_GENERIC_MATH TRUE)
+  ENDIF(USE_GENERIC_MATH)
+ENDIF(UNIX)
+
+# ---------------------------------------------------------------
+# Check for POSIX timers
+# ---------------------------------------------------------------
+INCLUDE(SundialsPOSIXTimers)
+
+# ===============================================================
+# Options for Parallelism
+# ===============================================================
+
+# ---------------------------------------------------------------
+# Enable MPI support?
+# ---------------------------------------------------------------
+OPTION(MPI_ENABLE "Enable MPI support" OFF)
+
+# ---------------------------------------------------------------
+# Enable OpenMP support?
+# ---------------------------------------------------------------
+OPTION(OPENMP_ENABLE "Enable OpenMP support" OFF)
+
+# provide OPENMP_DEVICE_ENABLE option
+OPTION(OPENMP_DEVICE_ENABLE "Enable OpenMP device offloading support" OFF)
+
+# Advanced option to skip OpenMP device offloading support check.
+# This is needed for a specific compiler that doesn't correctly
+# report its OpenMP spec date (with CMake >= 3.9).
+OPTION(SKIP_OPENMP_DEVICE_CHECK "Skip the OpenMP device offloading support check" OFF)
+MARK_AS_ADVANCED(FORCE SKIP_OPENMP_DEVICE_CHECK)
+
+# ---------------------------------------------------------------
+# Enable Pthread support?
+# ---------------------------------------------------------------
+OPTION(PTHREAD_ENABLE "Enable Pthreads support" OFF)
+
+# -------------------------------------------------------------
+# Enable CUDA support?
+# -------------------------------------------------------------
+OPTION(CUDA_ENABLE "Enable CUDA support" OFF)
+
+# -------------------------------------------------------------
+# Enable RAJA support?
+# -------------------------------------------------------------
+OPTION(RAJA_ENABLE "Enable RAJA support" OFF)
+
+
+# ===============================================================
+# Options for external packages
+# ===============================================================
+
+# ---------------------------------------------------------------
+# Enable BLAS support?
+# ---------------------------------------------------------------
+OPTION(BLAS_ENABLE "Enable BLAS support" OFF)
+
+# ---------------------------------------------------------------
+# Enable LAPACK/BLAS support?
+# ---------------------------------------------------------------
+OPTION(LAPACK_ENABLE "Enable Lapack support" OFF)
+
+# LAPACK does not support extended precision
+IF(LAPACK_ENABLE AND SUNDIALS_PRECISION MATCHES "EXTENDED")
+  PRINT_WARNING("LAPACK is not compatible with ${SUNDIALS_PRECISION} precision"
+                "Disabling LAPACK")
+  FORCE_VARIABLE(LAPACK_ENABLE BOOL "LAPACK is disabled" OFF)
+ENDIF()
+
+# LAPACK does not support 64-bit integer index types
+IF(LAPACK_ENABLE AND SUNDIALS_INDEX_SIZE MATCHES "64")
+  PRINT_WARNING("LAPACK is not compatible with ${SUNDIALS_INDEX_SIZE} integers"
+                "Disabling LAPACK")
+  SET(LAPACK_ENABLE OFF CACHE BOOL "LAPACK is disabled" FORCE)
+ENDIF()
+
+# ---------------------------------------------------------------
+# Enable SuperLU_MT support?
+# ---------------------------------------------------------------
+OPTION(SUPERLUMT_ENABLE "Enable SUPERLUMT support" OFF)
+
+# SuperLU_MT does not support extended precision
+IF(SUPERLUMT_ENABLE AND SUNDIALS_PRECISION MATCHES "EXTENDED")
+  PRINT_WARNING("SuperLU_MT is not compatible with ${SUNDIALS_PRECISION} precision"
+                "Disabling SuperLU_MT")
+  FORCE_VARIABLE(SUPERLUMT_ENABLE BOOL "SuperLU_MT is disabled" OFF)
+ENDIF()
+
+# ---------------------------------------------------------------
+# Enable KLU support?
+# ---------------------------------------------------------------
+OPTION(KLU_ENABLE "Enable KLU support" OFF)
+
+# KLU does not support single or extended precision
+IF(KLU_ENABLE AND
+  (SUNDIALS_PRECISION MATCHES "SINGLE" OR SUNDIALS_PRECISION MATCHES "EXTENDED"))
+  PRINT_WARNING("KLU is not compatible with ${SUNDIALS_PRECISION} precision"
+                "Disabling KLU")
+  FORCE_VARIABLE(KLU_ENABLE BOOL "KLU is disabled" OFF)
+ENDIF()
+
+# ---------------------------------------------------------------
+# Enable hypre Vector support?
+# ---------------------------------------------------------------
+OPTION(HYPRE_ENABLE "Enable hypre support" OFF)
+
+# Using hypre requres building with MPI enabled
+IF(HYPRE_ENABLE AND NOT MPI_ENABLE)
+  PRINT_WARNING("MPI not enabled - Disabling hypre"
+                "Set MPI_ENABLE to ON to use parhyp")
+  FORCE_VARIABLE(HYPRE_ENABLE BOOL "Enable hypre support" OFF)
+ENDIF()
+
+# ---------------------------------------------------------------
+# Enable PETSc support?
+# ---------------------------------------------------------------
+OPTION(PETSC_ENABLE "Enable PETSc support" OFF)
+
+# Using PETSc requires building with MPI enabled
+IF(PETSC_ENABLE AND NOT MPI_ENABLE)
+  PRINT_WARNING("MPI not enabled - Disabling PETSc"
+                "Set MPI_ENABLE to ON to use PETSc")
+  FORCE_VARIABLE(PETSC_ENABLE BOOL "Enable PETSc support" OFF)
+ENDIF()
+
+
+# ===============================================================
+# Options for examples
+# ===============================================================
+
+# ---------------------------------------------------------------
+# Enable examples?
+# ---------------------------------------------------------------
+
+# Enable C examples (on by default)
+OPTION(EXAMPLES_ENABLE_C "Build SUNDIALS C examples" ON)
+
+# C++ examples (off by default) are an option only if ARKode is enabled
+SET(DOCSTR "Build ARKode C++ examples")
+IF(BUILD_ARKODE)
+  OPTION(EXAMPLES_ENABLE_CXX "${DOCSTR}" OFF)
+ELSE()
+  # set back to OFF (in case was ON)
+  IF(EXAMPLES_ENABLE_CXX)
+    PRINT_WARNING("EXAMPLES_ENABLE_CXX is ON but BUILD_ARKODE is OFF"
+                  "Disabling EXAMPLES_ENABLE_CXX")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_CXX BOOL "${DOCSTR}" OFF)
+  ENDIF()
+ENDIF()
+
+# F77 examples (on by default) are an option only if the Fortran
+# interface is enabled
+SET(DOCSTR "Build SUNDIALS Fortran examples")
+IF(F77_INTERFACE_ENABLE)
+  SHOW_VARIABLE(EXAMPLES_ENABLE_F77 BOOL "${DOCSTR}" ON)
+  # Fortran 77 examples do not support single or extended precision
+  IF(EXAMPLES_ENABLE_F77 AND (SUNDIALS_PRECISION MATCHES "EXTENDED" OR SUNDIALS_PRECISION MATCHES "SINGLE"))
+    PRINT_WARNING("F77 examples are not compatible with ${SUNDIALS_PRECISION} precision"
+                  "EXAMPLES_ENABLE_F77")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_F77 BOOL "${DOCSTR}" OFF)
+  ENDIF()
+ELSE()
+  # set back to OFF (in case was ON)
+  IF(EXAMPLES_ENABLE_F77)
+    PRINT_WARNING("EXAMPLES_ENABLE_F77 is ON but F77_INTERFACE_ENABLE is OFF"
+                  "Disabling EXAMPLES_ENABLE_F77")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_F77 BOOL "${DOCSTR}" OFF)
+  ENDIF()
+  HIDE_VARIABLE(EXAMPLES_ENABLE_F77)
+ENDIF()
+
+# F90 examples (on by default) are an option only if a Fortran interface is enabled.
+SET(DOCSTR "Build SUNDIALS F90 examples")
+IF(F77_INTERFACE_ENABLE OR F2003_INTERFACE_ENABLE)
+  SHOW_VARIABLE(EXAMPLES_ENABLE_F90 BOOL "${DOCSTR}" ON)
+  # Fortran 90 examples do not support extended precision
+  IF(EXAMPLES_ENABLE_F90 AND (SUNDIALS_PRECISION MATCHES "EXTENDED"))
+    PRINT_WARNING("F90 examples are not compatible with ${SUNDIALS_PRECISION} precision"
+                  "Disabling EXAMPLES_ENABLE_F90")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_F90 BOOL "${DOCSTR}" OFF)
+  ENDIF()
+ELSE()
+  # set back to OFF (in case was ON)
+  IF(EXAMPLES_ENABLE_F90)
+    PRINT_WARNING("EXAMPLES_ENABLE_F90 is ON but both F77 and F2003 interfaces are OFF"
+                  "Disabling EXAMPLES_ENABLE_F90")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_F90 BOOL "${DOCSTR}" OFF)
+  ENDIF()
+  HIDE_VARIABLE(EXAMPLES_ENABLE_F90)
+ENDIF()
+
+# CUDA examples (off by default)
+SET(DOCSTR "Build SUNDIALS CUDA examples")
+IF(CUDA_ENABLE)
+  OPTION(EXAMPLES_ENABLE_CUDA "${DOCSTR}" OFF)
+ELSE()
+  IF(EXAMPLES_ENABLE_CUDA)
+    PRINT_WARNING("EXAMPLES_ENABLE_CUDA is ON but CUDA_ENABLE is OFF"
+                  "Disabling EXAMPLES_ENABLE_CUDA")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_CUDA BOOL "${DOCSTR}" OFF)
+  ENDIF()
+ENDIF()
+
+# RAJA examples (off by default)
+SET(DOCSTR "Build SUNDIALS RAJA examples")
+IF(RAJA_ENABLE)
+  OPTION(EXAMPLES_ENABLE_RAJA "${DOCSTR}" OFF)
+ELSE()
+  IF(EXAMPLES_ENABLE_RAJA)
+    PRINT_WARNING("EXAMPLES_ENABLE_RAJA is ON but RAJA_ENABLE is OFF"
+                  "Disabling EXAMPLES_ENABLE_RAJA")
+    FORCE_VARIABLE(EXAMPLES_ENABLE_RAJA BOOL "${DOCSTR}" OFF)
+  ENDIF()
+ENDIF()
+
+# If any of the above examples are enabled set EXAMPLES_ENABLED to TRUE
+IF(EXAMPLES_ENABLE_C OR
+    EXAMPLES_ENABLE_F77 OR
+    EXAMPLES_ENABLE_CXX OR
+    EXAMPLES_ENABLE_F90 OR
+    EXAMPLES_ENABLE_CUDA OR
+    EXAMPLES_ENABLE_RAJA)
+  SET(EXAMPLES_ENABLED TRUE)
+ELSE()
+  SET(EXAMPLES_ENABLED FALSE)
+ENDIF()
+
+# ---------------------------------------------------------------
+# Install examples?
+# ---------------------------------------------------------------
+
+IF(EXAMPLES_ENABLED)
+
+  # If examples are enabled, set different options
+
+  # The examples will be linked with the library corresponding to the build type.
+  # Whenever building shared libraries, use them to link the examples.
+  IF(BUILD_SHARED_LIBS)
+    SET(LINK_LIBRARY_TYPE "shared")
+  ELSE(BUILD_SHARED_LIBS)
+    SET(LINK_LIBRARY_TYPE "static")
+  ENDIF(BUILD_SHARED_LIBS)
+
+  # Enable installing examples by default
+  OPTION(EXAMPLES_INSTALL "Install example files" ON)
+
+  # If examples are to be exported, check where we should install them.
+  IF(EXAMPLES_INSTALL)
+
+    SHOW_VARIABLE(EXAMPLES_INSTALL_PATH PATH
+      "Output directory for installing example files" "${CMAKE_INSTALL_PREFIX}/examples")
+
+    IF(NOT EXAMPLES_INSTALL_PATH)
+      PRINT_WARNING("The example installation path is empty"
+                    "Example installation path was reset to its default value")
+      SET(EXAMPLES_INSTALL_PATH "${CMAKE_INSTALL_PREFIX}/examples" CACHE STRING
+        "Output directory for installing example files" FORCE)
+    ENDIF(NOT EXAMPLES_INSTALL_PATH)
+
+    # create test_install target and directory for running smoke tests after
+    # installation
+    ADD_CUSTOM_TARGET(test_install)
+
+    SET(TEST_INSTALL_DIR ${PROJECT_BINARY_DIR}/Testing_Install)
+
+    IF(NOT EXISTS ${TEST_INSTALL_DIR})
+      FILE(MAKE_DIRECTORY ${TEST_INSTALL_DIR})
+    ENDIF()
+
+  ELSE(EXAMPLES_INSTALL)
+
+    HIDE_VARIABLE(EXAMPLES_INSTALL_PATH)
+
+  ENDIF(EXAMPLES_INSTALL)
+
+ELSE(EXAMPLES_ENABLED)
+
+  # If examples are disabled, hide all options related to
+  # building and installing the SUNDIALS examples
+
+  HIDE_VARIABLE(EXAMPLES_INSTALL)
+  HIDE_VARIABLE(EXAMPLES_INSTALL_PATH)
+
+ENDIF(EXAMPLES_ENABLED)
+
+# ==============================================================================
+# Advanced (hidden) options
+# ==============================================================================
+
+# ------------------------------------------------------------------------------
+# Manually specify the Fortran name-mangling scheme
+#
+# The build system tries to infer the Fortran name-mangling scheme using a
+# Fortran compiler and defaults to using lower case and one underscore if the
+# scheme can not be determined. If a working Fortran compiler is not available
+# or the user needs to override the inferred or default scheme, the following
+# options specify the case and number of appended underscores corresponding to
+# the Fortran name-mangling scheme of symbol names that do not themselves
+# contain underscores. This is all we really need for the FCMIX and LAPACK
+# interfaces. A working Fortran compiler is only necessary for building Fortran
+# example programs.
+# ------------------------------------------------------------------------------
+
+# The case to use in the name-mangling scheme
+show_variable(SUNDIALS_F77_FUNC_CASE STRING
+  "case of Fortran function names (lower/upper)"
+  "")
+
+# The number of underscores of appended in the name-mangling scheme
+show_variable(SUNDIALS_F77_FUNC_UNDERSCORES STRING
+  "number of underscores appended to Fortran function names (none/one/two)"
+  "")
+
+# Hide the name-mangling varibales as advanced options
+mark_as_advanced(FORCE SUNDIALS_F77_FUNC_CASE)
+mark_as_advanced(FORCE SUNDIALS_F77_FUNC_UNDERSCORES)
+
+# If used, both case and underscores must be set
+if((NOT SUNDIALS_F77_FUNC_CASE) AND SUNDIALS_F77_FUNC_UNDERSCORES)
+  message(FATAL_ERROR
+    "If SUNDIALS_F77_FUNC_UNDERSCORES is set, SUNDIALS_F77_FUNC_CASE must also be set.")
+endif()
+
+if(SUNDIALS_F77_FUNC_CASE AND (NOT SUNDIALS_F77_FUNC_UNDERSCORES))
+  message(FATAL_ERROR
+    "If SUNDIALS_F77_FUNC_CASE is set, SUNDIALS_F77_FUNC_UNDERSCORES must also be set.")
+endif()
+
+# ------------------------------------------------------------------------------
+# Include development examples in regression tests?
+#
+# NOTE: Development examples are currently used for internal testing and may
+# produce erroneous failures when run on different systems as the pass/fail
+# status is determined by comparing the output against a saved output file.
+# ------------------------------------------------------------------------------
+OPTION(SUNDIALS_DEVTESTS "Include development tests in make test" OFF)
+MARK_AS_ADVANCED(FORCE SUNDIALS_DEVTESTS)
+
+# ===============================================================
+# Add any platform specifc settings
+# ===============================================================
+
+# Under Windows, add compiler directive to inhibit warnings
+# about use of unsecure functions
+
+IF(WIN32)
+  ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
+ENDIF(WIN32)
+
+IF(APPLE)
+  SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS} -undefined dynamic_lookup")
+ENDIF(APPLE)
+
+# ===============================================================
+# Fortran and C++ settings
+# ===============================================================
+
+# ---------------------------------------------------------------
+# A Fortran compiler is needed to:
+# (a) Determine the name-mangling scheme if FCMIX, BLAS, or
+#     LAPACK are enabled
+# (b) Compile example programs if F77 or F90 examples are enabled
+# ---------------------------------------------------------------
+
+# Do we need a Fortran name-mangling scheme?
+if(F77_INTERFACE_ENABLE OR BLAS_ENABLE OR LAPACK_ENABLE)
+  set(NEED_FORTRAN_NAME_MANGLING TRUE)
+endif()
+
+# Did the user provide a name-mangling scheme?
+if(SUNDIALS_F77_FUNC_CASE AND SUNDIALS_F77_FUNC_UNDERSCORES)
+
+  STRING(TOUPPER ${SUNDIALS_F77_FUNC_CASE} SUNDIALS_F77_FUNC_CASE)
+  STRING(TOUPPER ${SUNDIALS_F77_FUNC_UNDERSCORES} SUNDIALS_F77_FUNC_UNDERSCORES)
+
+  # Based on the given case and number of underscores, set the C preprocessor
+  # macro definitions. Since SUNDIALS never uses symbols names containing
+  # underscores we set the name-mangling schemes to be the same. In general,
+  # names of symbols with and without underscore may be mangled differently
+  # (e.g. g77 mangles mysub to mysub_ and my_sub to my_sub__)
+  if(SUNDIALS_F77_FUNC_CASE MATCHES "LOWER")
+    if(SUNDIALS_F77_FUNC_UNDERSCORES MATCHES "NONE")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) name")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) name")
+    elseif(SUNDIALS_F77_FUNC_UNDERSCORES MATCHES "ONE")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) name ## _")
+      SET(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) name ## _")
+    elseif(SUNDIALS_F77_FUNC_UNDERSCORES MATCHES "TWO")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) name ## __")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) name ## __")
+    else()
+      message(FATAL_ERROR "Invalid SUNDIALS_F77_FUNC_UNDERSCORES option.")
+    endif()
+  elseif(SUNDIALS_F77_FUNC_CASE MATCHES "UPPER")
+    if(SUNDIALS_F77_FUNC_UNDERSCORES MATCHES "NONE")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) NAME")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) NAME")
+    elseif(SUNDIALS_F77_FUNC_UNDERSCORES MATCHES "ONE")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) NAME ## _")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) NAME ## _")
+    elseif(SUNDIALS_F77_FUNC_UNDERSCORES MATCHES "TWO")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) NAME ## __")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) NAME ## __")
+    else()
+      message(FATAL_ERROR "Invalid SUNDIALS_F77_FUNC_UNDERSCORES option.")
+    endif()
+  else()
+    message(FATAL_ERROR "Invalid SUNDIALS_F77_FUNC_CASE option.")
+  endif()
+
+  # name-mangling scheme has been manually set
+  set(NEED_FORTRAN_NAME_MANGLING FALSE)
+
+endif()
+
+# Do we need a Fortran compiler?
+if(F2003_INTERFACE_ENABLE OR EXAMPLES_ENABLE_F77 OR EXAMPLES_ENABLE_F90 OR NEED_FORTRAN_NAME_MANGLING)
+  include(SundialsFortran)
+endif()
+
+# Ensure that F90 compiler is found if F90 examples are enabled
+if (EXAMPLES_ENABLE_F90 AND (NOT F90_FOUND))
+  PRINT_WARNING("Compiler with F90 support not found" "Disabling F90 Examples")
+  SET(DOCSTR "Build F90 examples")
+  FORCE_VARIABLE(EXAMPLES_ENABLE_F90 "${DOCSTR}" OFF)
+endif()
+
+# Ensure that F90 compiler found if F2003 interface is enabled
+if (F2003_INTERFACE_ENABLE AND (NOT F90_FOUND))
+  PRINT_WARNING("Compiler with F90 support not found" "Disabling F2003 Interface")
+  SET(DOCSTR "Enable Fortran 2003 interfaces")
+  FORCE_VARIABLE(F2003_INTERFACE_ENABLE BOOL "${DOCSTR}" OFF)
+endif()
+
+# F2003 interface requires ISO_C_BINDING
+IF(F2003_INTERFACE_ENABLE AND (NOT Fortran_COMPILER_SUPPORTS_ISOCBINDING))
+  PRINT_WARNING("Fortran compiler does not provide ISO_C_BINDING support"
+                "Disabling F2003 interface")
+  SET(DOCSTR "Enable Fortran 2003 interfaces")
+  FORCE_VARIABLE(F2003_INTERFACE_ENABLE BOOL "${DOCSTR}" OFF)
+ENDIF()
+
+
+# ---------------------------------------------------------------
+# A C++ compiler is needed if:
+# (a) C++ examples are enabled
+# (b) CUDA is enabled
+# (c) RAJA is enabled
+# ---------------------------------------------------------------
+
+if(EXAMPLES_ENABLE_CXX OR CUDA_ENABLE OR RAJA_ENABLE)
+  include(SundialsCXX)
+endif()
+
+# ---------------------------------------------------------------
+# Setup CUDA. Since CUDA is its own language we do this
+# separate from the TPLs.
+# ---------------------------------------------------------------
+
+if(CUDA_ENABLE)
+  find_package(CUDA)
+  if (CUDA_FOUND)
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -lineinfo")
+  else()
+    message(STATUS "Disabling CUDA support, could not find CUDA.")
+    set(CUDA_ENABLE OFF)
+  endif()
+endif(CUDA_ENABLE)
+
+# ---------------------------------------------------------------
+# Now that all languages are setup, we can configure them more.
+# ---------------------------------------------------------------
+
+# C++11 is needed if:
+#   (a) CUDA is enabled
+# C++11 should not be enabled if
+#   (a) RAJA is enabled (they provide a std flag)
+if (CXX_FOUND AND CUDA_ENABLE AND CUDA_FOUND AND (NOT RAJA_ENABLE))
+  USE_CXX_STD(11)
+endif()
+
+# ---------------------------------------------------------------
+# Decide how to compile MPI codes.
+# ---------------------------------------------------------------
+
+if(MPI_ENABLE)
+
+  include(SundialsMPI)
+
+  if(NOT MPI_C_FOUND)
+    print_warning("MPI not functional"
+      "Parallel support will not be provided")
+  else()
+    set(IS_MPI_ENABLED "#ifndef SUNDIALS_MPI_ENABLED\n#define SUNDIALS_MPI_ENABLED 1\n#endif")
+  endif()
+
+endif()
+
+# always define FMPI_COMM_F2C in sundials_fconfig.h file
+if(MPIC_MPI2)
+  set(F77_MPI_COMM_F2C "#define SUNDIALS_MPI_COMM_F2C 1")
+  set(FMPI_COMM_F2C ".true.")
+else()
+  set(F77_MPI_COMM_F2C "#define SUNDIALS_MPI_COMM_F2C 0")
+  set(FMPI_COMM_F2C ".false.")
+endif()
+
+# -------------------------------------------------------------
+# Find OpenMP
+# -------------------------------------------------------------
+
+if(OPENMP_ENABLE OR OPENMP_DEVICE_ENABLE)
+
+  include(SundialsOpenMP)
+
+  # turn off OPENMP_ENABLE and OPENMP_DEVICE_ENABLE if OpenMP is not found
+  if(NOT OPENMP_FOUND)
+    print_warning("Could not determine OpenMP compiler flags" "Disabling OpenMP support")
+    force_variable(OPENMP_ENABLE BOOL "Enable OpenMP support" OFF)
+    force_variable(OPENMP_DEVICE_ENABLE BOOL "Enable OpenMP device offloading support" OFF)
+  endif()
+
+  # turn off OPENMP_DEVICE_ENABLE if offloading is not supported
+  if(OPENMP_DEVICE_ENABLE AND (NOT OPENMP_SUPPORTS_DEVICE_OFFLOADING))
+    print_warning("OpenMP found does not support device offloading"
+                  "Disabling OpenMP device offloading support")
+    force_variable(OPENMP_DEVICE_ENABLE BOOL "Enable OpenMP device offloading support" OFF)
+  endif()
+
+endif()
+
+# -------------------------------------------------------------
+# Find PThreads
+# -------------------------------------------------------------
+
+IF(PTHREAD_ENABLE)
+  FIND_PACKAGE(Threads)
+  IF(CMAKE_USE_PTHREADS_INIT)
+    message(STATUS "Using Pthreads")
+    SET(PTHREADS_FOUND TRUE)
+    # SGS
+  ELSE()
+    message(STATUS "Disabling Pthreads support, could not determine compiler flags")
+  endif()
+ENDIF(PTHREAD_ENABLE)
+
+# -------------------------------------------------------------
+# Find RAJA
+# -------------------------------------------------------------
+
+# disable RAJA if CUDA is not enabled/working
+if(RAJA_ENABLE AND (NOT CUDA_FOUND))
+  PRINT_WARNING("CUDA is required for RAJA support" "Please enable CUDA and RAJA")
+  FORCE_VARIABLE(RAJA_ENABLE BOOL "RAJA disabled" OFF)
+endif()
+
+if(RAJA_ENABLE)
+  # Look for CMake configuration file in RAJA installation
+  find_package(RAJA)
+  if (RAJA_FOUND)
+    include_directories(${RAJA_INCLUDE_DIR})
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} ${RAJA_NVCC_FLAGS})
+  else()
+    PRINT_WARNING("RAJA configuration not found"
+                  "Please set RAJA_DIR to provide path to RAJA CMake configuration file.")
+  endif()
+endif(RAJA_ENABLE)
+
+# ===============================================================
+# Find (and test) external packages
+# ===============================================================
+
+# ---------------------------------------------------------------
+# Find (and test) the BLAS libraries
+# ---------------------------------------------------------------
+
+# If BLAS is needed, first try to find the appropriate
+# libraries and linker flags needed to link against them.
+
+IF(BLAS_ENABLE)
+
+  # find BLAS
+  INCLUDE(SundialsBlas)
+
+  # show after include so FindBlas can locate BLAS_LIBRARIES if necessary
+  SHOW_VARIABLE(BLAS_LIBRARIES STRING "Blas libraries" "${BLAS_LIBRARIES}")
+
+  IF(BLAS_LIBRARIES AND NOT BLAS_FOUND)
+    PRINT_WARNING("BLAS not functional"
+                  "BLAS support will not be provided")
+  ELSE()
+    #set sundials_config.h symbol via sundials_config.in
+    SET(SUNDIALS_BLAS TRUE)
+  ENDIF()
+
+ELSE()
+
+  HIDE_VARIABLE(BLAS_LIBRARIES)
+
+ENDIF()
+
+# ---------------------------------------------------------------
+# Find (and test) the Lapack libraries
+# ---------------------------------------------------------------
+
+# If LAPACK is needed, first try to find the appropriate
+# libraries and linker flags needed to link against them.
+
+IF(LAPACK_ENABLE)
+
+  # find LAPACK and BLAS Libraries
+  INCLUDE(SundialsLapack)
+
+  # show after include so FindLapack can locate LAPCK_LIBRARIES if necessary
+  SHOW_VARIABLE(LAPACK_LIBRARIES STRING "Lapack and Blas libraries" "${LAPACK_LIBRARIES}")
+
+  IF(LAPACK_LIBRARIES AND NOT LAPACK_FOUND)
+    PRINT_WARNING("LAPACK not functional"
+                  "Blas/Lapack support will not be provided")
+  ELSE()
+    #set sundials_config.h symbol via sundials_config.in
+    SET(SUNDIALS_BLAS_LAPACK TRUE)
+  ENDIF()
+
+ELSE()
+
+  HIDE_VARIABLE(LAPACK_LIBRARIES)
+
+ENDIF()
+
+# ---------------------------------------------------------------
+# Find (and test) the SUPERLUMT libraries
+# ---------------------------------------------------------------
+
+# >>>>>>> NOTE: Need to add check for SuperLU_MT integer type
+
+# If SUPERLUMT is needed, first try to find the appropriate
+# libraries to link against them.
+
+IF(SUPERLUMT_ENABLE)
+
+  # Show SuperLU_MT options and set default thread type (Pthreads)
+  SHOW_VARIABLE(SUPERLUMT_THREAD_TYPE STRING "SUPERLUMT threading type: OpenMP or Pthread" "Pthread")
+  SHOW_VARIABLE(SUPERLUMT_INCLUDE_DIR PATH "SUPERLUMT include directory" "${SUPERLUMT_INCLUDE_DIR}")
+  SHOW_VARIABLE(SUPERLUMT_LIBRARY_DIR PATH "SUPERLUMT library directory" "${SUPERLUMT_LIBRARY_DIR}")
+
+  INCLUDE(SundialsSuperLUMT)
+
+  IF(SUPERLUMT_FOUND)
+    # sundials_config.h symbols
+    SET(SUNDIALS_SUPERLUMT TRUE)
+    SET(SUNDIALS_SUPERLUMT_THREAD_TYPE ${SUPERLUMT_THREAD_TYPE})
+    INCLUDE_DIRECTORIES(${SUPERLUMT_INCLUDE_DIR})
+  ENDIF()
+
+  IF(SUPERLUMT_LIBRARIES AND NOT SUPERLUMT_FOUND)
+    PRINT_WARNING("SUPERLUMT not functional - support will not be provided"
+                  "Double check spelling specified libraries (search is case sensitive)")
+  ENDIF(SUPERLUMT_LIBRARIES AND NOT SUPERLUMT_FOUND)
+
+ELSE()
+
+  HIDE_VARIABLE(SUPERLUMT_THREAD_TYPE)
+  HIDE_VARIABLE(SUPERLUMT_LIBRARY_DIR)
+  HIDE_VARIABLE(SUPERLUMT_INCLUDE_DIR)
+  SET (SUPERLUMT_DISABLED TRUE CACHE INTERNAL "GUI - return when first set")
+
+ENDIF()
+
+# ---------------------------------------------------------------
+# Find (and test) the KLU libraries
+# ---------------------------------------------------------------
+
+# If KLU is requested, first try to find the appropriate libraries to
+# link against them.
+
+IF(KLU_ENABLE)
+
+  SHOW_VARIABLE(KLU_INCLUDE_DIR PATH "KLU include directory"
+    "${KLU_INCLUDE_DIR}")
+  SHOW_VARIABLE(KLU_LIBRARY_DIR PATH
+    "Klu library directory" "${KLU_LIBRARY_DIR}")
+
+  INCLUDE(SundialsKLU)
+
+  IF(KLU_FOUND)
+    # sundials_config.h symbol
+    SET(SUNDIALS_KLU TRUE)
+    INCLUDE_DIRECTORIES(${KLU_INCLUDE_DIR})
+  ENDIF(KLU_FOUND)
+
+  IF(KLU_LIBRARIES AND NOT KLU_FOUND)
+    PRINT_WARNING("KLU not functional - support will not be provided"
+                  "Double check spelling of include path and specified libraries (search is case sensitive)")
+  ENDIF(KLU_LIBRARIES AND NOT KLU_FOUND)
+
+ELSE()
+
+  HIDE_VARIABLE(KLU_LIBRARY_DIR)
+  HIDE_VARIABLE(KLU_INCLUDE_DIR)
+  SET (KLU_DISABLED TRUE CACHE INTERNAL "GUI - return when first set")
+
+ENDIF(KLU_ENABLE)
+
+# ---------------------------------------------------------------
+# Find (and test) the hypre libraries
+# ---------------------------------------------------------------
+
+# >>>>>>> NOTE: Need to add check for hypre precision and integer type
+
+IF(HYPRE_ENABLE)
+  SHOW_VARIABLE(HYPRE_INCLUDE_DIR PATH "HYPRE include directory"
+    "${HYPRE_INCLUDE_DIR}")
+  SHOW_VARIABLE(HYPRE_LIBRARY_DIR PATH
+    "HYPRE library directory" "${HYPRE_LIBRARY_DIR}")
+
+  INCLUDE(SundialsHypre)
+
+  IF(HYPRE_FOUND)
+    # sundials_config.h symbol
+    SET(SUNDIALS_HYPRE TRUE)
+    INCLUDE_DIRECTORIES(${HYPRE_INCLUDE_DIR})
+  ENDIF(HYPRE_FOUND)
+
+  IF(HYPRE_LIBRARIES AND NOT HYPRE_FOUND)
+    PRINT_WARNING("HYPRE not functional - support will not be provided"
+                  "Found hypre library, test code does not work")
+  ENDIF(HYPRE_LIBRARIES AND NOT HYPRE_FOUND)
+
+ELSE()
+
+  HIDE_VARIABLE(HYPRE_INCLUDE_DIR)
+  HIDE_VARIABLE(HYPRE_LIBRARY_DIR)
+  SET (HYPRE_DISABLED TRUE CACHE INTERNAL "GUI - return when first set")
+
+ENDIF()
+
+# ---------------------------------------------------------------
+# Find (and test) the PETSc libraries
+# ---------------------------------------------------------------
+
+# >>>>>>> NOTE: Need to add check for PETSc precision and integer type
+
+IF(PETSC_ENABLE)
+  SHOW_VARIABLE(PETSC_INCLUDE_DIR PATH "PETSc include directory"
+    "${PETSC_INCLUDE_DIR}")
+  SHOW_VARIABLE(PETSC_LIBRARY_DIR PATH
+    "PETSc library directory" "${PETSC_LIBRARY_DIR}")
+
+  INCLUDE(SundialsPETSc)
+
+  IF(PETSC_FOUND)
+    # sundials_config.h symbol
+    SET(SUNDIALS_PETSC TRUE)
+    INCLUDE_DIRECTORIES(${PETSC_INCLUDE_DIR})
+  ENDIF(PETSC_FOUND)
+
+  IF(PETSC_LIBRARIES AND NOT PETSC_FOUND)
+    PRINT_WARNING("PETSC not functional - support will not be provided"
+                  "Double check spelling specified libraries (search is case sensitive)")
+  ENDIF(PETSC_LIBRARIES AND NOT PETSC_FOUND)
+
+ELSE()
+
+  HIDE_VARIABLE(PETSC_LIBRARY_DIR)
+  HIDE_VARIABLE(PETSC_INCLUDE_DIR)
+  SET (PETSC_DISABLED TRUE CACHE INTERNAL "GUI - return when first set")
+
+ENDIF()
+
+# ===============================================================
+# Add source and configuration files
+# ===============================================================
+
+# ---------------------------------------------------------------
+# Configure the header file sundials_config.h
+# ---------------------------------------------------------------
+
+# All required substitution variables should be available at this point.
+# Generate the header file and place it in the binary dir.
+CONFIGURE_FILE(
+  ${PROJECT_SOURCE_DIR}/include/sundials/sundials_config.in
+  ${PROJECT_BINARY_DIR}/include/sundials/sundials_config.h
+  )
+CONFIGURE_FILE(
+  ${PROJECT_SOURCE_DIR}/include/sundials/sundials_fconfig.in
+  ${PROJECT_BINARY_DIR}/include/sundials/sundials_fconfig.h
+  )
+
+# Add the include directory in the source tree and the one in
+# the binary tree (for the header file sundials_config.h)
+INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include)
+
+# ---------------------------------------------------------------
+# Add selected modules to the build system
+# ---------------------------------------------------------------
+
+ADD_SUBDIRECTORY(src)
+
+# ---------------------------------------------------------------
+# Include the subdirectories corresponding to various examples
+# ---------------------------------------------------------------
+
+# If building and installing the examples is enabled, include
+# the subdirectories for those examples that will be built.
+# Also, if we will generate exported example Makefiles, set
+# variables needed in generating them from templates.
+
+# For now, TestRunner is not being distributed.
+# So:
+#  - Don't show TESTRUNNER variable
+#  - Don't enable testing if TestRunner if not found.
+#  - There will be no 'make test' target
+
+INCLUDE(SundialsAddTest)
+HIDE_VARIABLE(TESTRUNNER)
+
+IF(EXAMPLES_ENABLED)
+
+  # enable regression testing with 'make test'
+  IF(TESTRUNNER)
+    INCLUDE(CTest)
+  ENDIF()
+
+  # Add SUNDIALS examples
+  ADD_SUBDIRECTORY(examples)
+
+ENDIF(EXAMPLES_ENABLED)
+
+# ---------------------------------------------------------------
+# Install configuration header files and license file
+# ---------------------------------------------------------------
+
+# install configured header file
+INSTALL(
+  FILES ${PROJECT_BINARY_DIR}/include/sundials/sundials_config.h
+  DESTINATION include/sundials
+  )
+
+# install configured header file for Fortran 90
+INSTALL(
+  FILES ${PROJECT_BINARY_DIR}/include/sundials/sundials_fconfig.h
+  DESTINATION include/sundials
+  )
+
+# install shared Fortran 2003 modules
+IF(F2003_INTERFACE_ENABLE)
+  # While the .mod files get generated for static and shared
+  # libraries, they are identical. So only install one set
+  # of the .mod files.
+  IF(BUILD_STATIC_LIBS)
+    INSTALL(
+      DIRECTORY ${CMAKE_Fortran_MODULE_DIRECTORY}_STATIC/
+      DESTINATION ${Fortran_INSTALL_MODDIR}
+      )
+  ELSE()
+    INSTALL(
+      DIRECTORY ${CMAKE_Fortran_MODULE_DIRECTORY}_SHARED/
+      DESTINATION ${Fortran_INSTALL_MODDIR}
+      )
+  ENDIF()
+ENDIF()
+
+# install license and notice files
+INSTALL(
+  FILES ${PROJECT_SOURCE_DIR}/LICENSE
+  DESTINATION include/sundials
+  )
+INSTALL(
+  FILES ${PROJECT_SOURCE_DIR}/NOTICE
+  DESTINATION include/sundials
+  )
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/CONTRIBUTING.md b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ea2f6f9c64d20da6a096c4b137d3336d3c6a45c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/CONTRIBUTING.md
@@ -0,0 +1,91 @@
+# Contributing to SUNDIALS
+
+At this time, the SUNDIALS team does not have the resources to review and take
+in large additions to the code or significant new features. Contributions
+addressing bug fixes or minor changes are preferred via a pull request to the
+[SUNDIALS GitHub repository](https://github.com/LLNL/sundials).
+
+All new contributions to SUNDIALS must be made under the BSD 3-clause license.
+See the [LICENSE](./LICENSE) and [NOTICE](./NOTICE) files for details. The
+SUNDIALS team will not accept any file previously released under any other open
+source license. By submitting code, the contributor gives irreversible consent
+to the redistribution and/or modification of the contributed source code.
+
+Please ensure that any pull request includes user guide additions or changes as
+appropriate, has been tested, and includes a test for any added features.
+
+Any added files submitted with a pull request must contain a header section at
+the top including the originating author's name and file origin date as well as
+a pointer to the SUNDIALS LICENSE and NOTICE files.
+
+The act of submitting a pull request (with or without an explicit Signed-off-by
+tag) will be understood as an affirmation of the following [Developer's
+Certificate of Origin (DCO)](http://developercertificate.org/).
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+1 Letterman Drive
+Suite D4700
+San Francisco, CA, 94129
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+As discussed in the [Docker software project blog](https://blog.docker.com/2014/01/docker-code-contributions-require-developer-certificate-of-origin/)
+this DCO "lets us know that you are entitled to contribute this code to
+[SUNDIALS] and that you are willing to have it used in distributions and
+derivative works."
+
+"By including the DCO signature, you are stating that one or
+more of the following is true of your contribution:
+
+1.  You created this contribution/change and have the right to submit it
+    to SUNDIALS; or
+2.  You created this contribution/change based on a previous work with a
+    compatible open source license; or
+3.  This contribution/change has been provided to you by someone who did
+    1 or 2 and you are submitting the contribution unchanged.
+4.  You understand this contribution is public and may be redistributed as
+    open source software" under the BSD license.
+
+All commits submitted to the SUNDIALS project need to have the following sign
+off line in the commit message:
+```
+Signed-off-by: Jane Doe <jdoe@address.com>
+```
+Replacing Jane Doe’s details with your name and email address.
+
+If you've set `user.name` and `user.email` in your Git configuration, you can
+automatically add a sign off line at the end of the commit message by using the
+`-s` option (e.g., `git commit -s`).
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/README.md b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b501b21b9ba744f0ca99767ef7974f207e4381df
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/README.md
@@ -0,0 +1,139 @@
+# SUNDIALS: SUite of Nonlinear and DIfferential/ALgebraic equation Solvers #
+
+#### Cody Balos, David Gardner, Alan Hindmarsh, Slaven Peles, Daniel Reynolds, Radu Serban, and Carol Woodward ####
+Center for Applied Scientific Computing, Lawrence Livermore National Laboratory
+
+SUNDIALS is a family of software packages implemented with the goal of
+providing robust time integrators and nonlinear solvers that can easily be
+incorporated into existing simulation codes. The primary design goals are to
+require minimal information from the user, allow users to easily supply their
+own data structures underneath the packages, and allow for easy incorporation
+of user-supplied linear solvers and preconditioners. The various packages share
+many subordinate modules and are organized as a family with a directory
+structure that exploits sharing common functionality.
+
+The SUNDIALS suite consists of the following packages:
+
+* ARKODE - for integration of stiff, nonstiff, and multirate ordinary
+differential equation systems (ODEs) of the form
+
+  ``` M y' = f1(t,y) + f2(t,y), y(t0) = y0 ```
+
+* CVODE - for integration of stiff and nonstiff ordinary differential equation
+systems (ODEs) of the form
+
+  ``` y' = f(t,y), y(t0) = y0 ```
+
+* CVODES - for integration and sensitivity analysis (forward and adjoint) of
+ordinary differential equation systems (ODEs) of the form
+
+  ``` y' = f(t,y,p), y(t0) = y0(p) ```
+
+* IDA - for integration of differential-algebraic equation systems (DAEs) of
+the form
+
+  ``` F(t,y,y') = 0, y(t0) = y0, y'(t0) = y0' ```
+
+* IDAS - for integration and sensitivity analysis (forward and adjoint) of
+differential-algebraic equation systems (DAEs) of the form
+
+  ``` F(t,y,y',p) = 0, y(t0) = y0(p), y'(t0) = y0'(p) ```
+
+* KINSOL - for solution of nonlinear algebraic systems of the form
+
+  ``` F(u) = 0 ```
+
+## Installation ##
+For installation directions see the [INSTALL_GUIDE](./INSTALL_GUIDE.pdf) or
+the installation chapter in any of the package user guides.
+
+Warning to users who receive more than one of the individual packages at
+different times: Mixing old and new versions of SUNDIALS may fail. To avoid
+such failures, obtain all desired package at the same time.
+
+## Support ##
+Full user guides for SUNDIALS packages are provided in the [doc](./doc)
+directory along with documentation for example programs.
+
+A list of Frequently Asked Questions on build and installation procedures as
+well as common usage issues is available on the SUNDIALS [FAQ](https://computation.llnl.gov/projects/sundials/faq).
+
+For dealing with systems with unphysical solutions or discontinuities see the
+SUNDIALS [usage notes](https://computation.llnl.gov/projects/sundials/usage-notes).
+
+If you have a question not covered in the FAQ or usage notes, please submit
+your question to the SUNDIALS [mailing list](https://computation.llnl.gov/projects/sundials/mailing-list).
+
+## Contributing ##
+Bug fixes or minor changes are preferred via a pull request to the
+[SUNDIALS GitHub repository](https://github.com/LLNL/sundials). For more
+information on contributing see the [CONTRIBUTING](./CONTRIBUTING.md) file.
+
+## Release History ##
+Date     | SUNDIALS    | ARKODE      | CVODE       | CVODES      | IDA         | IDAS        | KINSOL
+---------|-------------|-------------|-------------|-------------|-------------|-------------|-------------
+Jan 2019 | 4.0.2       | 3.0.2       | 4.0.2       | 4.0.2       | 4.0.2       | 3.0.2       | 4.0.2
+Dec 2018 | 4.0.1       | 3.0.1       | 4.0.1       | 4.0.1       | 4.0.1       | 3.0.1       | 4.0.1
+Dec 2018 | 4.0.0       | 3.0.0       | 4.0.0       | 4.0.0       | 4.0.0       | 3.0.0       | 4.0.0
+Oct 2018 | 3.2.1       | 2.2.1       | 3.2.1       | 3.2.1       | 3.2.1       | 2.2.1       | 3.2.1
+Sep 2018 | 3.2.0       | 2.2.0       | 3.2.0       | 3.2.0       | 3.2.0       | 2.2.0       | 3.2.0
+Jul 2018 | 3.1.2       | 2.1.2       | 3.1.2       | 3.1.2       | 3.1.2       | 2.1.2       | 3.1.2
+May 2018 | 3.1.1       | 2.1.1       | 3.1.1       | 3.1.1       | 3.1.1       | 2.1.1       | 3.1.1
+Nov 2017 | 3.1.0       | 2.1.0       | 3.1.0       | 3.1.0       | 3.1.0       | 2.1.0       | 3.1.0
+Sep 2017 | 3.0.0       | 2.0.0       | 3.0.0       | 3.0.0       | 3.0.0       | 2.0.0       | 3.0.0
+Sep 2016 | 2.7.0       | 1.1.0       | 2.9.0       | 2.9.0       | 2.9.0       | 1.3.0       | 2.9.0
+Aug 2015 | 2.6.2       | 1.0.2       | 2.8.2       | 2.8.2       | 2.8.2       | 1.2.2       | 2.8.2
+Mar 2015 | 2.6.1       | 1.0.1       | 2.8.1       | 2.8.1       | 2.8.1       | 1.2.1       | 2.8.1
+Mar 2015 | 2.6.0       | 1.0.0       | 2.8.0       | 2.8.0       | 2.8.0       | 1.2.0       | 2.8.0
+Mar 2012 | 2.5.0       |             | 2.7.0       | 2.7.0       | 2.7.0       | 1.1.0       | 2.7.0
+May 2009 | 2.4.0       |             | 2.6.0       | 2.6.0       | 2.6.0       | 1.0.0       | 2.6.0
+Nov 2006 | 2.3.0       |             | 2.5.0       | 2.5.0       | 2.5.0       |             | 2.5.0
+Mar 2006 | 2.2.0       |             | 2.4.0       | 2.4.0       | 2.4.0       |             | 2.4.0
+May 2005 | 2.1.1       |             | 2.3.0       | 2.3.0       | 2.3.0       |             | 2.3.0
+Apr 2005 | 2.1.0       |             | 2.3.0       | 2.2.0       | 2.3.0       |             | 2.3.0
+Mar 2005 | 2.0.2       |             | 2.2.2       | 2.1.2       | 2.2.2       |             | 2.2.2
+Jan 2005 | 2.0.1       |             | 2.2.1       | 2.1.1       | 2.2.1       |             | 2.2.1
+Dec 2004 | 2.0         |             | 2.2.0       | 2.1.0       | 2.2.0       |             | 2.2.0
+Jul 2002 | 1.0         |             | 2.0         | 1.0         | 2.0         |             | 2.0
+
+## Authors ##
+The SUNDIALS Team: Carol S. Woodward, Daniel R. Reynolds, Alan C. Hindmarsh,
+David J. Gardner, Slaven Peles, and Cody J. Balos. We thank Radu Serban for
+significant and critical past contributions.
+
+We also acknowledge past contributions of Scott D. Cohen, Peter N. Brown,
+George Byrne, Allan G. Taylor, Steven L. Lee, Keith E. Grant, Aaron Collier,
+Lawrence E. Banks, Steve Smith, Cosmin Petra, John Loffeld, Dan Shumaker,
+Ulrike Yang, James Almgren-Bell, Shelby L. Lockhart, Hilari C. Tiedeman, Ting Yan,
+Jean M. Sexton, and Chris White.
+
+### Citing SUNDIALS ###
+We ask users of SUNDIALS to cite the following paper in any publications
+reporting work done with SUNDIALS:
+
+* Alan C. Hindmarsh, Peter N. Brown, Keith E. Grant, Steven L. Lee, Radu
+Serban, Dan E. Shumaker, and Carol S. Woodward. 2005. SUNDIALS: Suite of
+nonlinear and differential/algebraic equation solvers. ACM Trans. Math. Softw.
+31, 3 (September 2005), 363-396. DOI=http://dx.doi.org/10.1145/1089014.1089020
+
+## License ##
+SUNDIALS is released under the BSD 3-clause license. See the [LICENSE](./LICENSE)
+and [NOTICE](./NOTICE) files for details.
+
+All new contributions must be made under the BSD 3-clause license.
+
+**Please Note** If you are using SUNDIALS with any third party libraries linked
+in (e.g., LAPACK, KLU, SuperLU_MT, PETSc, or *hypre*), be sure to review the
+respective license of the package as that license may have more restrictive
+terms than the SUNDIALS license.
+
+```
+SPDX-License-Identifier: BSD-3-Clause
+
+LLNL-CODE-667205  (ARKODE)
+UCRL-CODE-155951  (CVODE)
+UCRL-CODE-155950  (CVODES)
+UCRL-CODE-155952  (IDA)
+UCRL-CODE-237203  (IDAS)
+LLNL-CODE-665877  (KINSOL)
+```
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindHypre.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindHypre.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..35ce31f47ab1313a4dabd0a275c513e168b651f6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindHypre.cmake
@@ -0,0 +1,44 @@
+# ---------------------------------------------------------------
+# Programmer:  Slaven Peles @ LLNL, Jean Sexton @ SMU,
+#              Eddy Banks @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# - Find hypre
+
+#  HYPRE_INCLUDE_DIR = cached location of HYPRE.h
+#  HYPRE_LIBRARY     = cached list of HYPRE library to link in
+
+### Find include dir
+find_path(temp_HYPRE_INCLUDE_DIR hypre.h ${HYPRE_INCLUDE_DIR})
+if (temp_HYPRE_INCLUDE_DIR)
+    set(HYPRE_INCLUDE_DIR ${temp_HYPRE_INCLUDE_DIR})
+endif()
+unset(temp_HYPRE_INCLUDE_DIR CACHE)
+    
+if (HYPRE_LIBRARY)
+    # We have (or were given) HYPRE_LIBRARY - get path to use for any related libs
+    get_filename_component(HYPRE_LIBRARY_DIR ${HYPRE_LIBRARY} PATH)
+
+    # force CACHE update to show user DIR that will be used
+    set(HYPRE_LIBRARY_DIR ${HYPRE_LIBRARY_DIR} CACHE PATH "" FORCE)
+    
+else ()
+    # find library with user provided directory path
+    set(HYPRE_LIBRARY_NAMES hypre HYPRE)
+    find_library(HYPRE_LIBRARY 
+      NAMES ${HYPRE_LIBRARY_NAMES}
+      PATHS ${HYPRE_LIBRARY_DIR} NO_DEFAULT_PATH
+      )
+endif ()
+mark_as_advanced(HYPRE_LIBRARY)
+
+set(HYPRE_LIBRARIES ${HYPRE_LIBRARY})
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindKLU.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindKLU.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..138cf1d76a3082228abea07187bf8d5e6849effb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindKLU.cmake
@@ -0,0 +1,71 @@
+# ---------------------------------------------------------------
+# Programmer:  Steven Smith @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Find KLU library.
+# 
+
+# Set library prefixes for Windows
+if(WIN32)
+  set(CMAKE_FIND_LIBRARY_PREFIXES lib ${CMAKE_FIND_LIBRARY_PREFIXES})
+endif()
+
+### Find include dir
+find_path(temp_KLU_INCLUDE_DIR klu.h ${KLU_INCLUDE_DIR})
+if (temp_KLU_INCLUDE_DIR)
+    set(KLU_INCLUDE_DIR ${temp_KLU_INCLUDE_DIR})
+endif()
+unset(temp_KLU_INCLUDE_DIR CACHE)
+    
+if (KLU_LIBRARY)
+    # We have (or were given) KLU_LIBRARY - get path to use for other Suitesparse libs
+    get_filename_component(KLU_LIBRARY_DIR ${KLU_LIBRARY} PATH)
+
+    # force CACHE update to show user DIR that will be used
+    set(KLU_LIBRARY_DIR ${KLU_LIBRARY_DIR} CACHE PATH "" FORCE)
+    
+else ()
+    # find library with user provided directory path
+    set(KLU_LIBRARY_NAME klu)
+    find_library(KLU_LIBRARY ${KLU_LIBRARY_NAME} ${KLU_LIBRARY_DIR} NO_DEFAULT_PATH)
+endif ()
+mark_as_advanced(KLU_LIBRARY)
+
+if (NOT AMD_LIBRARY)
+    set(AMD_LIBRARY_NAME amd)
+    FIND_LIBRARY(AMD_LIBRARY ${AMD_LIBRARY_NAME} ${KLU_LIBRARY_DIR} NO_DEFAULT_PATH)
+    mark_as_advanced(AMD_LIBRARY)
+endif ()
+
+if (NOT COLAMD_LIBRARY)
+    set(COLAMD_LIBRARY_NAME colamd)
+    FIND_LIBRARY(COLAMD_LIBRARY ${COLAMD_LIBRARY_NAME} ${KLU_LIBRARY_DIR} NO_DEFAULT_PATH)
+    mark_as_advanced(COLAMD_LIBRARY)
+endif ()
+
+if (NOT BTF_LIBRARY)
+    set(BTF_LIBRARY_NAME btf)
+    FIND_LIBRARY( BTF_LIBRARY ${BTF_LIBRARY_NAME} ${KLU_LIBRARY_DIR} NO_DEFAULT_PATH)
+    mark_as_advanced(BTF_LIBRARY)
+endif ()
+
+if (NOT SUITESPARSECONFIG_LIBRARY)
+    set(SUITESPARSECONFIG_LIBRARY_NAME suitesparseconfig)
+    # NOTE: no prefix for this library on windows
+    if(WIN32 AND NOT MSYS)
+        set(CMAKE_FIND_LIBRARY_PREFIXES "")
+    endif()
+    FIND_LIBRARY( SUITESPARSECONFIG_LIBRARY ${SUITESPARSECONFIG_LIBRARY_NAME} ${KLU_LIBRARY_DIR} NO_DEFAULT_PATH)
+    mark_as_advanced(SUITESPARSECONFIG_LIBRARY)
+endif ()
+
+set(KLU_LIBRARIES ${KLU_LIBRARY} ${AMD_LIBRARY} ${COLAMD_LIBRARY} ${BTF_LIBRARY} ${SUITESPARSECONFIG_LIBRARY})
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindPETSc.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindPETSc.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..46757ed0b2c21cc67e442e7bbae3176c9f307927
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindPETSc.cmake
@@ -0,0 +1,45 @@
+# ---------------------------------------------------------------
+# Programmer:  Steven Smith @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Find PETSC library.
+# 
+
+IF(WIN32)
+  set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
+endif(WIN32)
+
+### Find include dir
+find_path(temp_PETSC_INCLUDE_DIR petsc.h ${PETSC_INCLUDE_DIR})
+if (temp_PETSC_INCLUDE_DIR)
+    set(PETSC_INCLUDE_DIR ${temp_PETSC_INCLUDE_DIR})
+endif()
+unset(temp_PETSC_INCLUDE_DIR CACHE)
+
+if (PETSC_LIBRARY)
+    # We have (or were given) PETSC_LIBRARY - get path to use for any related libs
+    get_filename_component(PETSC_LIBRARY_DIR ${PETSC_LIBRARY} PATH)
+    
+    # force CACHE update to show user DIR that will be used
+    set(PETSC_LIBRARY_DIR ${PETSC_LIBRARY_DIR} CACHE PATH "" FORCE)
+    
+else ()
+    # find library with user provided directory path
+    set(PETSC_LIBRARY_NAMES petsc PETSC)
+    find_library(PETSC_LIBRARY 
+      NAMES ${PETSC_LIBRARY_NAMES}
+      PATHS ${PETSC_LIBRARY_DIR} NO_DEFAULT_PATH
+      )
+endif ()
+mark_as_advanced(PETSC_LIBRARY)
+
+set(PETSC_LIBRARIES ${PETSC_LIBRARY})
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindSUPERLUMT.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindSUPERLUMT.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7617e8fc26aad73a24a640a9935813b2ea3cd421
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindSUPERLUMT.cmake
@@ -0,0 +1,91 @@
+# ---------------------------------------------------------------
+# Programmer:  Eddy Banks @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# SUPERLUMT tests for SUNDIALS CMake-based configuration.
+# 
+
+# make sure valid thread type - if not, then warn and return
+STRING(TOUPPER "${SUPERLUMT_THREAD_TYPE}" SUPERLUMT_THREAD_TYPE_UPPER)
+If(SUPERLUMT_THREAD_TYPE AND
+    NOT SUPERLUMT_THREAD_TYPE_UPPER STREQUAL "OPENMP" AND
+    NOT SUPERLUMT_THREAD_TYPE_UPPER STREQUAL "PTHREAD")
+    PRINT_WARNING("Unknown thread type: ${SUPERLUMT_THREAD_TYPE}" "Please enter Pthread or OpenMP")
+ENDIF()
+
+# find the SUPERLUMT include directory path
+IF(SUPERLUMT_THREAD_TYPE)
+  # if have user input for thread type - set postfix of library name
+  set(POST ${SUPERLUMT_THREAD_TYPE_UPPER})
+
+  ### Find include dir
+  find_path(temp_SUPERLUMT_INCLUDE_DIR slu_mt_ddefs.h ${SUPERLUMT_INCLUDE_DIR})
+  if (temp_SUPERLUMT_INCLUDE_DIR)
+    set(SUPERLUMT_INCLUDE_DIR ${temp_SUPERLUMT_INCLUDE_DIR})
+  endif()
+  unset(temp_SUPERLUMT_INCLUDE_DIR CACHE)
+ENDIF()
+
+IF(MSVC)
+  SET(CMAKE_FIND_LIBRARY_PREFIXES lib ${CMAKE_FIND_LIBRARY_PREFIXES})
+ENDIF()
+
+if(SUPERLUMT_LIBRARY)
+  get_filename_component(SUPERLUMT_LIBRARY_DIR ${SUPERLUMT_LIBRARY} PATH)
+  set(SUPERLUMT_LIBRARY_DIR ${SUPERLUMT_LIBRARY_DIR} CACHE PATH "" FORCE)
+else()
+  # find library with user provided directory path
+  set(SUPERLUMT_LIBRARY_NAME superlu_mt_${POST})
+  find_library(SUPERLUMT_LIBRARY ${SUPERLUMT_LIBRARY_NAME} ${SUPERLUMT_LIBRARY_DIR} NO_DEFAULT_PATH)
+endif()
+mark_as_advanced(SUPERLUMT_LIBRARY)
+
+# add threading library (pthread or openmp)
+If(SUPERLUMT_THREAD_TYPE_UPPER STREQUAL "PTHREAD")
+  # add pthread to libraries
+  find_library(SUPERLUMT_THREAD_LIBRARY
+      NAMES pthread
+      PATHS /usr/lib /usr/local/lib
+      "$ENV{ProgramFiles}/SUPERLUMT/Lib"
+      )
+ELSE(SUPERLUMT_THREAD_TYPE_UPPER STREQUAL "OPENMP")
+  # add openmp to libraries
+  if(NOT OPENMP_FOUND)
+    find_package( OpenMP REQUIRED)
+  endif()
+  if(OPENMP_FOUND)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+    #set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
+  endif()  
+ENDIF()
+mark_as_advanced(SUPERLUMT_THREAD_LIBRARY)
+
+# add to SUPERLUMT_LIBRARIES (Note: will be 'not found' if either are not found 
+set(SUPERLUMT_LIBRARIES ${SUPERLUMT_LIBRARY} ${SUPERLUMT_THREAD_LIBRARY})
+
+# If LAPACK/BLAS not enabled - find BLAS with SUPERLUMT
+if(NOT BLAS_ENABLE AND NOT LAPACK_ENABLE)
+  set(SUPERLUMT_BLAS_LIBRARY_NAME blas_${POST})
+
+  #unset(SUPERLUMT_BLAS_LIBRARIES CACHE)
+  FIND_LIBRARY(SUPERLUMT_BLAS_LIBRARIES ${SUPERLUMT_BLAS_LIBRARY_NAME} ${SUPERLUMT_LIBRARY_DIR} NO_DEFAULT_PATH)
+
+  if (NOT SUPERLUMT_BLAS_LIBRARIES)
+    PRINT_WARNING("Can't find SUPERLUMT_BLAS_LIBRARY, support will not be provided."
+                  "Try setting BLAS_ENABLE or LAPACK_ENABLE to ON")
+    SET(SUPERLUMT_FOUND FALSE)
+  else ()
+    set(SUPERLUMT_LIBRARIES ${SUPERLUMT_LIBRARIES} ${SUPERLUMT_BLAS_LIBRARIES})
+  endif ()
+  mark_as_advanced(SUPERLUMT_BLAS_LIBRARIES)
+endif(NOT BLAS_ENABLE AND NOT LAPACK_ENABLE)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindTrilinos.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindTrilinos.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c0288f5af8511bc0feb275420cacc789921c1a39
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/FindTrilinos.cmake
@@ -0,0 +1,61 @@
+# -----------------------------------------------------------------------------
+# Programmer: Cody J. Balos and Slaven Peles @ LLNL
+# -----------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# -----------------------------------------------------------------------------
+# - Find Trilinos
+#   This will create a Trilinos::Trilinos target which can be used in
+#   target_link_libraries to get all the necessary libraries and includes
+#   without using the Trilinos_LIBRARIES or Trilinos_INCLUDE_DIRS variables.
+#   However, the Trilinos_CXX_COMPILER_FLAGS sill has to be used. Also creates
+#   the variable Trilinos_MPI which indicates if Trilinos was built with MPI.
+# -----------------------------------------------------------------------------
+
+set(Trilinos_FOUND FALSE)
+
+# First try and find Trilinos using Trilinos_DIR only.
+find_package(Trilinos
+  NAMES Trilinos TRILINOS
+  PATHS
+    ${Trilinos_DIR}/lib/cmake/Trilinos
+    ${Trilinos_DIR}
+  NO_DEFAULT_PATH)
+
+# If Trilinos_DIR was not provided, try and find Trilinos
+# somewhere else unless using in the xSDK mode.
+if (NOT (Trilinos_FOUND OR USE_XSDK_DEFAULTS))
+  find_package(Trilinos
+    NAMES Trilinos TRILINOS
+    PATHS
+      ${Trilinos_DIR}/lib/cmake/Trilinos
+      ${Trilinos_DIR})
+endif()
+
+if(Trilinos_FOUND)
+  message(STATUS "Looking for Trilinos... success")
+
+  # check if Trilinos was built with MPI
+  if(";${Trilinos_TPL_LIST};" MATCHES ";MPI;")
+    set(Trilinos_MPI TRUE)
+  else()
+    set(Trilinos_MPI FALSE)
+  endif()
+else()
+  message(STATUS "Looking for Trilinos... failed")
+endif()
+
+if(Trilinos_FOUND AND NOT TARGET Trilinos::Trilinos)
+  add_library(Trilinos::Trilinos IMPORTED INTERFACE)
+  set_target_properties(Trilinos::Trilinos PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${Trilinos_INCLUDE_DIRS}"
+    INTERFACE_LINK_LIBRARIES "${Trilinos_LIBRARIES}")
+endif()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddF2003InterfaceLibrary.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddF2003InterfaceLibrary.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..dd2879d4550d2587c9c7beb09986cecdf2aa9a98
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddF2003InterfaceLibrary.cmake
@@ -0,0 +1,60 @@
+# ---------------------------------------------------------------
+# Programmer: Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMake macro for adding F2003 interface libraries.
+# ---------------------------------------------------------------
+
+# Wraps the add_library command for adding Fortran 2003 interfaces.
+#
+# It appends the library type to the Fortran_MODULE_DIRECTORY so
+# that the .mod file generated during compilation of shared and
+# static libraries do not collide.
+# It also adds the .mod file directory to the target's includes.
+# It also adds the C library as a library to link to.
+#
+# REQUIRES following the F2003 interface library naming convention.
+# I.e. if the C library/target is sundials_cvode_static then the
+# F2003 target must be sundials_fcvode_mod_static.
+MACRO(sundials_add_f2003_interface_library target libtype)
+  # extract the variable number of source arguments
+  set(sources ${ARGN})
+  
+  # create the target
+  add_library(${target} ${libtype} ${sources})
+  
+  # set target properties and target dependencies so that includes
+  # and links get passed on when this target is used
+  if (CMAKE_Fortran_MODULE_DIRECTORY)
+    target_include_directories(${target}
+      PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_Fortran_MODULE_DIRECTORY}_${libtype}>
+        $<INSTALL_INTERFACE:${Fortran_INSTALL_MODDIR}>
+      )
+    set_target_properties(${target} PROPERTIES Fortran_MODULE_DIRECTORY "${CMAKE_Fortran_MODULE_DIRECTORY}_${libtype}")
+  else()
+    target_include_directories(${target}
+      PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${target}.dir>
+        $<INSTALL_INTERFACE:${Fortran_INSTALL_MODDIR}>
+      )
+    set_target_properties(${target} PROPERTIES Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${target}.dir")
+  endif()
+
+  # get the name of the C library which the fortran library interfaces too
+  string(REPLACE "sundials_f" "sundials_" c_lib_name "${target}")
+  string(REPLACE "_mod_" "_" c_lib_name "${c_lib_name}")
+
+  # depend on the C library
+  target_link_libraries(${target} PUBLIC ${c_lib_name})
+ENDMACRO(sundials_add_f2003_interface_library)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddTest.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddTest.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e965fed76da9e0bfcb08269b4e8184b431668615
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddTest.cmake
@@ -0,0 +1,148 @@
+# ---------------------------------------------------------------
+# Author: Steven Smith and David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+#
+# SUNDIALS_ADD_TEST(<test name> <executable>)
+#
+# CMake macro to add a Sundials regression test. Keyword input
+# arguments can be added after <executable> to set regression
+# test options (see oneValueArgs and multiValueArgs below).
+#
+# When SUNDIALS_DEVTEST is OFF (default) the executable is run
+# and pass/fail is determined by the executable return value.
+#
+# When SUNDIALS_DEVTESTS is ON the executable is run and its
+# output compared with the corresponding .out file. If the output
+# differs significantly then the test fails. The default level of
+# signicance is 4 decimal points for floating values and 10% for
+# integer values.
+#
+# The level of precision can be adjusted for all tests using:
+#  -D SUNDIALS_DEVTESTS_FLOAT_PRECISION=<number of digits>
+#  -D SUNDIALS_DEVTESTS_INTEGER_PRECISION=<% difference>
+# ---------------------------------------------------------------
+
+MACRO(SUNDIALS_ADD_TEST NAME EXECUTABLE)
+
+  # macro options
+  # NODIFF = do not diff the test output against an answer file
+  SET(options "NODIFF")
+
+  # macro keyword inputs followed by a single value
+  # MPI_NPROCS         = number of mpi tasks to use in parallel tests
+  # FLOAT_PRECISION    = precision for floating point failure comparision (num digits)
+  # INTEGER_PRECENTAGE = integer percentage difference for failure comparison
+  # ANSWER_DIR         = path to the directory containing the test answer file
+  # ANSWER_FILE        = name of test answer file
+  # EXAMPLE_TYPE       = release or develop examples
+  SET(oneValueArgs "MPI_NPROCS" "FLOAT_PRECISION" "INTEGER_PERCENTAGE"
+    "ANSWER_DIR" "ANSWER_FILE" "EXAMPLE_TYPE")
+
+  # macro keyword inputs followed by multiple values
+  # TEST_ARGS = command line arguments to pass to the test executable
+  SET(multiValueArgs "TEST_ARGS")
+
+  # parse inputs and create variables SUNDIALS_ADD_TEST_<keyword>
+  CMAKE_PARSE_ARGUMENTS(SUNDIALS_ADD_TEST
+    "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  # SGS add check to make sure parallel is integer
+  # SGS add check for float and integer precision
+
+  # check that the test is not excluded
+  if(NOT ("${SUNDIALS_ADD_TEST_EXAMPLE_TYPE}" STREQUAL "exclude"))
+
+    # add test using the dev test runner
+    IF(SUNDIALS_DEVTESTS)
+
+      # command line arguments for the test runner script
+      SET(TEST_ARGS
+        "--verbose"
+        "--testname=${NAME}"
+        "--executablename=$<TARGET_FILE:${EXECUTABLE}>"
+        "--outputdir=${CMAKE_BINARY_DIR}/Testing/output"
+        )
+
+      # do not diff the output and answer files
+      IF(SUNDIALS_ADD_TEST_NODIFF)
+        LIST(APPEND TEST_ARGS "--nodiff")
+      ENDIF()
+
+      # check if this test is run with MPI and set the MPI run command
+      IF(NOT ("${SUNDIALS_ADD_TEST_MPI_NPROCS}" STREQUAL "") AND
+          NOT ("${MPIEXEC_EXECUTABLE}" STREQUAL ""))
+
+        IF(MPIEXEC_EXECUTABLE MATCHES "srun")
+          SET(RUN_COMMAND "srun -N1 -n${SUNDIALS_ADD_TEST_MPI_NPROCS} -ppdebug")
+        ELSE()
+          SET(RUN_COMMAND "${MPIEXEC_EXECUTABLE} -n ${SUNDIALS_ADD_TEST_MPI_NPROCS}")
+        ENDIF()
+
+        LIST(APPEND TEST_ARGS "--runcommand=\"${RUN_COMMAND}\"")
+
+      ENDIF()
+
+      # set the test input args
+      IF(NOT ("${SUNDIALS_ADD_TEST_TEST_ARGS}" STREQUAL ""))
+        STRING (REPLACE ";" " " USER_ARGS "${SUNDIALS_ADD_TEST_TEST_ARGS}")
+        LIST(APPEND TEST_ARGS "--runargs=\"${USER_ARGS}\"")
+      ENDIF()
+
+      # set the test answer directory name (default is test/answers)
+      IF(NOT ("${SUNDIALS_ADD_TEST_ANSWER_DIR}" STREQUAL ""))
+        LIST(APPEND TEST_ARGS "--answerdir=${SUNDIALS_ADD_TEST_ANSWER_DIR}")
+      ENDIF()
+
+      # set the test answer file name (default is test_name_test_agrs)
+      IF(NOT ("${SUNDIALS_ADD_TEST_ANSWER_FILE}" STREQUAL ""))
+        LIST(APPEND TEST_ARGS "--answerfile=${SUNDIALS_ADD_TEST_ANSWER_FILE}")
+      ENDIF()
+
+      # set the precision for floating point failure comparison (number of digits, default 4)
+      IF(SUNDIALS_DEVTESTS_FLOAT_PRECISION)
+        LIST(APPEND TEST_ARGS "--floatprecision=${SUNDIALS_DEVTESTS_FLOAT_PRECISION}")
+      ELSEIF(NOT ("${SUNDIALS_ADD_TEST_FLOAT_PRECISION}" STREQUAL ""))
+        LIST(APPEND TEST_ARGS "--floatprecision=${SUNDIALS_ADD_TEST_FLOAT_PRECISION}")
+      ENDIF()
+
+      # set the integer percentage difference for failure comparison (default 10%)
+      IF(SUNDIALS_DEVTESTS_INTEGER_PRECISION)
+        LIST(APPEND TEST_ARGS "--integerpercentage=${SUNDIALS_DEVTESTS_INTEGER_PRECISION}")
+      ELSEIF(NOT ("${SUNDIALS_ADD_TEST_INTEGER_PERCENTAGE}" STREQUAL ""))
+        LIST(APPEND TEST_ARGS "--integerpercentage=${SUNDIALS_ADD_TEST_INTEGER_PERCENTAGE}")
+      ENDIF()
+
+      # create test case with the corresponding test runner command and arguments
+      # all tests are added during development and only unlabeled tests when released
+      ADD_TEST(NAME ${NAME} COMMAND ${PYTHON_EXECUTABLE} ${TESTRUNNER} ${TEST_ARGS})
+
+    elseif("${SUNDIALS_ADD_TEST_EXAMPLE_TYPE}" STREQUAL "")
+
+      # convert string to list
+      IF(NOT ("${SUNDIALS_ADD_TEST_TEST_ARGS}" STREQUAL ""))
+        STRING(REPLACE " " ";" TEST_ARGS "${SUNDIALS_ADD_TEST_TEST_ARGS}")
+      ENDIF()
+
+      # check if this test is run with MPI and add the test run command
+      if(NOT ("${SUNDIALS_ADD_TEST_MPI_NPROCS}" STREQUAL "") AND
+          NOT ("${MPIEXEC_EXECUTABLE}" STREQUAL ""))
+        ADD_TEST(NAME ${NAME} COMMAND ${MPIEXEC_EXECUTABLE} -n ${SUNDIALS_ADD_TEST_MPI_NPROCS} $<TARGET_FILE:${EXECUTABLE}> ${TEST_ARGS})
+      else()
+        ADD_TEST(NAME ${NAME} COMMAND $<TARGET_FILE:${EXECUTABLE}> ${TEST_ARGS})
+      endif()
+
+    endif()
+
+  endif()
+
+ENDMACRO()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddTestInstall.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddTestInstall.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0625f8fa41269248326c18007f50333a876b0c7f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsAddTestInstall.cmake
@@ -0,0 +1,51 @@
+# ---------------------------------------------------------------
+# Author: David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+#
+# SUNDIALS_ADD_TEST_INSTALL(<package name> <executable>)
+#
+# CMake macro to add a Sundials installation smoke test. Keyword
+# input arguments can be added after <executable> to set test
+# options (see oneValueArgs and multiValueArgs below).
+# ---------------------------------------------------------------
+
+MACRO(SUNDIALS_ADD_TEST_INSTALL PACKAGE EXECUTABLE)
+
+  # macro options
+  SET(options )
+
+  # macro keyword inputs followed by a single value
+  # EXAMPLE_DIR = path to the directory containing the installed example
+  SET(oneValueArgs "EXAMPLE_DIR")
+
+  # macro keyword inputs followed by multiple values
+  SET(multiValueArgs )
+
+  # parse inputs and create variables SUNDIALS_ADD_TEST_<keyword>
+  CMAKE_PARSE_ARGUMENTS(SUNDIALS_ADD_TEST_INSTALL
+    "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  # create testing directory for this solver
+  FILE(MAKE_DIRECTORY ${TEST_INSTALL_DIR}/${PACKAGE})
+
+  ADD_CUSTOM_TARGET(${PACKAGE}_test_install
+    COMMAND ${CMAKE_COMMAND} ${SUNDIALS_ADD_TEST_INSTALL_EXAMPLE_DIR} > cmake.out
+    COMMAND make ${EXECUTABLE} > make.out
+    COMMAND ctest
+    COMMENT "Running ${PACKAGE} installation tests"
+    WORKING_DIRECTORY ${TEST_INSTALL_DIR}/${PACKAGE})
+
+  # make test_install depend on solver_test_install
+  ADD_DEPENDENCIES(test_install ${PACKAGE}_test_install)
+
+ENDMACRO()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsBlas.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsBlas.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8eabb6198a4f83ce656e9a4c92a4221a903f2ea7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsBlas.cmake
@@ -0,0 +1,101 @@
+# ---------------------------------------------------------------
+# Programmer:  David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# BLAS tests for SUNDIALS CMake-based configuration. Based on 
+# SundialsLapack.cmake
+#
+
+SET(BLAS_FOUND FALSE)
+
+# If BLAS libraries are undefined, try to find them (if we have
+# a working Fortran compiler) or look for them in the most
+# obvious place...
+if(NOT BLAS_LIBRARIES)
+  if(F77_FOUND)
+    include(FindBLAS)
+  else(F77_FOUND)
+    find_library(BLAS_LIBRARIES
+      NAMES blas
+      PATHS /usr/lib /usr/local/lib
+      "$ENV{ProgramFiles}/BLAS/Lib"
+      )
+  endif(F77_FOUND)
+
+  # If the xSDK flag is used, set it to what was found
+  if(BLAS_LIBRARIES AND TPL_ENABLE_BLAS)
+    SET(DOCSTR "Blas library")
+    FORCE_VARIABLE(TPL_BLAS_LIBRARIES STRING "${DOCSTR}" "${BLAS_LIBRARIES}")
+  endif()
+endif()
+
+# If we have the BLAS libraries, test them
+if(BLAS_LIBRARIES)
+  message(STATUS "Looking for BLAS libraries... OK")
+
+  # Create the BlasTest directory
+  set(BlasTest_DIR ${PROJECT_BINARY_DIR}/BlasTest)
+  file(MAKE_DIRECTORY ${BlasTest_DIR})
+
+  # Create a CMakeLists.txt file 
+  file(WRITE ${BlasTest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 2.4)\n"
+    "PROJECT(ltest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "ADD_EXECUTABLE(ltest ltest.c)\n"
+    "TARGET_LINK_LIBRARIES(ltest ${BLAS_LIBRARIES})\n")
+
+  # Create a C source file which calls a Blas function (dcopy)
+  file(WRITE ${BlasTest_DIR}/ltest.c
+    "${F77_MANGLE_MACRO1}\n"
+    "#define dcopy_f77 SUNDIALS_F77_FUNC(dcopy, DCOPY)\n"
+    "extern void dcopy_f77(int *n, const double *x, const int *inc_x, double *y, const int *inc_y);\n"
+    "int main(){\n"
+    "int n=1;\n"
+    "double x, y;\n"
+    "dcopy_f77(&n, &x, &n, &y, &n);\n"
+    "return(0);\n"
+    "}\n")
+
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${BlasTest_DIR} ${BlasTest_DIR}
+    ltest OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${BlasTest_DIR}/CMakeFiles)
+
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Checking if BLAS works... OK")
+    set(BLAS_FOUND TRUE)
+
+    # get path to BLAS library to use in generated makefiles for examples
+    # check length to protect against BLAS_LIBRARIES having multiple entries
+    list(LENGTH BLAS_LIBRARIES len)
+    if(len EQUAL 1)
+      get_filename_component(BLAS_LIBRARY_DIR ${BLAS_LIBRARIES} PATH)
+    endif()
+
+  else(LTEST_OK)
+    message(STATUS "Checking if BLAS works... FAILED")
+  endif(LTEST_OK)
+
+else(BLAS_LIBRARIES)
+  message(STATUS "Looking for BLAS libraries... FAILED")
+endif(BLAS_LIBRARIES)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsCMakeMacros.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsCMakeMacros.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d6032e389ea2f936c16f73d27473e6f238a79e2c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsCMakeMacros.cmake
@@ -0,0 +1,118 @@
+# ---------------------------------------------------------------
+# Programmer: David J. Gardner @ LLNL
+#             Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMake macros used throughout the SUNDIALS build system
+# ---------------------------------------------------------------
+
+# Print variable and value
+IF (NOT COMMAND PRINT_VARIABLE)
+  FUNCTION(PRINT_VARIABLE var)
+    MESSAGE("${var} = '${${var}}'")
+  ENDFUNCTION()
+ENDIF()
+
+# Macros to hide/show cached variables.
+# These two macros can be used to "hide" or "show" in the
+# list of cached variables various variables and/or options
+# that depend on other options.
+# Note that once a variable is modified, it will preserve its
+# value (hidding it merely makes it internal)
+
+# hide variable (set as internal), retain its value, and
+# leave the documentation string empty
+MACRO(HIDE_VARIABLE var)
+  IF(DEFINED ${var})
+    SET(${var} "${${var}}" CACHE INTERNAL "")
+  ENDIF(DEFINED ${var})
+ENDMACRO(HIDE_VARIABLE)
+
+# show variable (set as cache)
+MACRO(SHOW_VARIABLE var type doc default)
+  IF(DEFINED ${var})
+    # ignores <default> and forces <var> to its current value
+    SET(${var} "${${var}}" CACHE "${type}" "${doc}" FORCE)
+  ELSE(DEFINED ${var})
+    # set to <var> to the <default> value
+    SET(${var} "${default}" CACHE "${type}" "${doc}")
+  ENDIF(DEFINED ${var})
+ENDMACRO(SHOW_VARIABLE)
+
+# show variable (set as cache) and overwrite (force) its value
+MACRO(FORCE_VARIABLE var type doc val)
+  SET(${var} "${val}" CACHE "${type}" "${doc}" FORCE)
+ENDMACRO(FORCE_VARIABLE)
+
+# Macros to append a common suffix or prefix to the elements of a list
+
+MACRO(ADD_SUFFIX rootlist suffix)
+  SET(outlist )
+  FOREACH(root ${${rootlist}})
+    LIST(APPEND outlist ${root}${suffix})
+  ENDFOREACH(root)
+  SET(${rootlist} ${outlist})
+ENDMACRO(ADD_SUFFIX)
+
+MACRO(ADD_PREFIX prefix rootlist)
+  SET(outlist )
+  FOREACH(root ${${rootlist}})
+    LIST(APPEND outlist ${prefix}${root})
+  ENDFOREACH(root)
+  SET(${rootlist} ${outlist})
+ENDMACRO(ADD_PREFIX)
+
+# Macro to print warning that some features will be disabled
+# due to some failure.
+
+MACRO(PRINT_WARNING message action)
+  SET(MSG
+  "------------------------------------------------------------------------\n"
+  "WARNING: ${message}\n"
+  "${action}\n"
+  "------------------------------------------------------------------------")
+  MESSAGE(WARNING ${MSG})
+ENDMACRO()
+
+# Macro to print fatal error messages. Fatal errors will NOT allow
+# a makefile to be generated
+
+MACRO(PRINT_ERROR message)
+  SET(MSG
+  "************************************************************************\n"
+  "ERROR: ${message}\n"
+  "************************************************************************")
+  MESSAGE(FATAL_ERROR ${MSG})
+ENDMACRO()
+
+# Returns an unquoted string. Note that CMake will readily turn such
+# strings back into lists, due to the duality of lists and
+# semicolon-separated strings. So be careful how you use it.
+
+MACRO(LIST2STRING alist astring)
+  FOREACH(elem ${${alist}})
+   SET(${astring} "${${astring}} ${elem}")
+  ENDFOREACH(elem)
+ENDMACRO(LIST2STRING)
+
+# Returns a string of unique example names from a list of example tuples
+
+MACRO(EXAMPLES2STRING example_list example_string)
+  SET(tmp_list "")
+  FOREACH(example_tuple ${${example_list}})
+    LIST(GET example_tuple 0 example)
+    LIST(APPEND tmp_list ${example})
+  ENDFOREACH()
+  LIST(REMOVE_DUPLICATES tmp_list)
+  LIST2STRING(tmp_list ${example_string})
+ENDMACRO(EXAMPLES2STRING)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsCXX.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsCXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0ac63e183a92d55910777896dd6125ef6fdb3d0a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsCXX.cmake
@@ -0,0 +1,82 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU, Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# C++-related tests for SUNDIALS CMake-based configuration.
+# ---------------------------------------------------------------
+
+# Enable the C++
+enable_language(CXX)
+set(CXX_FOUND TRUE)
+
+# show some cache variables
+mark_as_advanced(CLEAR
+  CMAKE_CXX_COMPILER
+  CMAKE_CXX_FLAGS)
+
+# hide all build type specific flags
+mark_as_advanced(FORCE
+  CMAKE_CXX_FLAGS_DEBUG
+  CMAKE_CXX_FLAGS_MINSIZEREL
+  CMAKE_CXX_FLAGS_RELEASE
+  CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+
+# only show flags for the current build type
+# these flags are appended to CMAKE_CXX_FLAGS
+if(CMAKE_BUILD_TYPE)
+  if(CMAKE_BUILD_TYPE MATCHES "Debug")
+    message("Appending CXX debug flags")
+    mark_as_advanced(CLEAR CMAKE_CXX_FLAGS_DEBUG)
+  elseif(CMAKE_BUILD_TYPE MATCHES "MinSizeRel")
+    message("Appending CXX min size release flags")
+    mark_as_advanced(CLEAR CMAKE_CXX_FLAGS_MINSIZEREL)
+  elseif(CMAKE_BUILD_TYPE MATCHES "Release")
+    message("Appending CXX release flags")
+    mark_as_advanced(CLEAR CMAKE_CXX_FLAGS_RELEASE)
+  elseif(CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
+    message("Appending CXX release with debug info flags")
+    mark_as_advanced(CLEAR CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+  endif()
+endif()
+
+# Converts a CXX standard number to the flag needed to set it.
+macro(CXX_STD2FLAG std flag_var)
+  set(flag_var "-std=c++${std}")
+endmacro()
+
+# Sets the CMAKE_CXX_STANDARD variable to the ${std} if the compiler
+# supports the flag. E.g. USE_CXX_STD(11) sets CMAKE_CXX_STANDARD=11.
+# If CUDA is enabled, it adds the correct flag to CUDA_NVCC_FLAGS.
+#
+# Requires:
+#   CMake > 3.1.3.
+# Notes: 
+#   If the compiler is not supprted by the CMake version in use, then
+#   the flag will have to be added manually.
+macro(USE_CXX_STD std)
+  if(NOT (CMAKE_CXX_STANDARD EQUAL ${std}))
+    include(CheckCXXCompilerFlag)
+    CXX_STD2FLAG(${std} flag_var)
+    CHECK_CXX_COMPILER_FLAG(${flag_var} COMPILER_SUPPORTS_STDFLAG)
+    if(COMPILER_SUPPORTS_STDFLAG)
+      set(CMAKE_CXX_STANDARD ${std})
+      message(STATUS "Set CMAKE_CXX_STANDARD to ${std}")
+      if(CUDA_ENABLE)
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -std c++${std}")
+        message(STATUS "Add -std c++${std} to CUDA_NVCC_FLAGS")
+      endif()
+    else()
+      PRINT_WARNING("Could not set CMAKE_CXX_STANDARD to ${std}.")
+    endif()
+  endif()
+endmacro()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsDeprecated.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsDeprecated.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..689f1ad140e23939419e22b772d5996a3000ed89
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsDeprecated.cmake
@@ -0,0 +1,121 @@
+# ---------------------------------------------------------------
+# Programmer:  David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Print warning is the user sets a deprecated CMake variable and
+# copy the value into the correct CMake variable
+# ---------------------------------------------------------------
+
+# macro to print warning for deprecated CMake variable
+MACRO(PRINT_DEPRECATED old_variable new_variable)
+  PRINT_WARNING("${old_variable} is deprecated and will be removed in the future."
+                "Copying value to ${new_variable}.")
+ENDMACRO()
+
+IF(DEFINED EXAMPLES_ENABLE)
+  PRINT_DEPRECATED(EXAMPLES_ENABLE EXAMPLES_ENABLE_C)
+  FORCE_VARIABLE(EXAMPLES_ENABLE_C BOOL "Build SUNDIALS C examples" ${EXAMPLES_ENABLE})
+  UNSET(EXAMPLES_ENABLE CACHE)
+ENDIF()
+
+IF(DEFINED CXX_ENABLE)
+  PRINT_DEPRECATED(CXX_ENABLE EXAMPLES_ENABLE_CXX)
+  FORCE_VARIABLE(EXAMPLES_ENABLE_CXX BOOL "Build ARKode C++ examples" ${CXX_ENABLE})
+  UNSET(CXX_ENABLE CACHE)
+ENDIF()
+
+IF(DEFINED F90_ENABLE)
+  PRINT_DEPRECATED(F90_ENABLE EXAMPLES_ENABLE_F90)
+  FORCE_VARIABLE(EXAMPLES_ENABLE_F90 BOOL "Build ARKode Fortran90 examples" ${F90_ENABLE})
+  UNSET(F90_ENABLE CACHE)
+ENDIF()
+
+IF(DEFINED FCMIX_ENABLE)
+  PRINT_DEPRECATED(FCMIX_ENABLE F77_INTERFACE_ENABLE)
+  FORCE_VARIABLE(F77_INTERFACE_ENABLE BOOL "Build Fortran 77 interfaces" ${FCMIX_ENABLE})
+  UNSET(FCMIX_ENABLE CACHE)
+ENDIF()
+
+# SUNDIALS_INDEX_TYPE got new behavior
+if(SUNDIALS_INDEX_TYPE)
+  string(TOUPPER ${SUNDIALS_INDEX_TYPE} tmp)
+
+  if(tmp STREQUAL "INT32_T")
+    PRINT_WARNING("SUNDIALS_INDEX_TYPE overrides the standard types SUNDIALS looks for."
+    "Setting SUNDIALS_INDEX_SIZE to 32 and clearing SUNDIALS_INDEX_TYPE.")
+    FORCE_VARIABLE(SUNDIALS_INDEX_SIZE STRING "SUNDIALS index size" 32)
+    FORCE_VARIABLE(SUNDIALS_INDEX_TYPE STRING "SUNDIALS index type" "")
+  elseif(tmp STREQUAL "INT64_T")
+    PRINT_WARNING("SUNDIALS_INDEX_TYPE overrides the standard types SUNDIALS looks for."
+    "Setting SUNDIALS_INDEX_SIZE to 64 and clearing SUNDIALS_INDEX_TYPE.")
+    FORCE_VARIABLE(SUNDIALS_INDEX_SIZE STRING "SUNDIALS index size" 64)
+    FORCE_VARIABLE(SUNDIALS_INDEX_TYPE STRING "SUNDIALS index type" "")
+  else()
+    PRINT_WARNING("SUNDIALS_INDEX_TYPE overrides the standard types SUNDIALS looks for." "")
+  endif()
+endif()
+
+if(DEFINED MPI_MPICC)
+  print_deprecated(MPI_MPICC MPI_C_COMPILER)
+  force_variable(MPI_C_COMPILER FILEPATH "MPI C compiler" ${MPI_MPICC})
+  unset(MPI_MPICC CACHE)
+endif()
+
+if(DEFINED MPI_MPICXX)
+  print_deprecated(MPI_MPICXX MPI_CXX_COMPILER)
+  force_variable(MPI_CXX_COMPILER FILPATH "MPI C++ compiler" ${MPI_MPICXX})
+  unset(MPI_MPICXX CACHE)
+endif()
+
+if((DEFINED MPI_MPIF77) OR (DEFINED MPI_MPIF90))
+  if(DEFINED MPI_MPIF90)
+    print_warning("MPI_MPIF77 and MPI_MPIF90 are deprecated and will be removed in the future." "Copying MPI_MPIF90 value to MPI_Fortran_COMPILER")
+    force_variable(MPI_Fortran_COMPILER FILEPATH "MPI Fortran compiler" ${MPI_MPIF90})
+  else()
+    print_warning("MPI_MPIF77 and MPI_MPIF90 are deprecated and will be removed in the future." "Copying MPI_MPIF77 value to MPI_Fortran_COMPILER")
+    force_variable(MPI_Fortran_COMPILER FILEPATH "MPI Fortran compiler" ${MPI_MPIF77})
+  endif()
+  unset(MPI_MPIF77 CACHE)
+  unset(MPI_MPIF90 CACHE)
+endif()
+
+if(DEFINED MPI_RUN_COMMAND)
+  print_deprecated(MPI_RUN_COMMAND MPIEXEC_EXECUTABLE)
+  force_variable(MPIEXEC_EXECUTABLE FILEPATH "MPI run command" ${MPI_RUN_COMMAND})
+  unset(MPI_RUN_COMMAND CACHE)
+endif()
+
+
+###############################################################################
+# Secret option to install impl header files.                                 #
+# TODO: remove after Sept. 2019                                               #
+###############################################################################
+if(DEFINED _INSTALL_IMPL_FILES)
+  if(BUILD_ARKODE)
+    install(FILES ${PROJECT_SOURCE_DIR}/src/arkode/arkode_impl.h DESTINATION include/arkode)
+  endif()
+  if(BUILD_CVODE)
+    install(FILES ${PROJECT_SOURCE_DIR}/src/cvode/cvode_impl.h   DESTINATION include/cvode)
+  endif()
+  if(BUILD_CVODES)
+    install(FILES ${PROJECT_SOURCE_DIR}/src/cvodes/cvodes_impl.h DESTINATION include/cvodes)
+  endif()
+  if(BUILD_IDA)
+    install(FILES ${PROJECT_SOURCE_DIR}/src/ida/ida_impl.h       DESTINATION include/ida)
+  endif()
+  if(BUILD_IDAS)
+    install(FILES ${PROJECT_SOURCE_DIR}/src/idas/idas_impl.h     DESTINATION include/idas)
+  endif()
+  if(BUILD_KINSOL)
+    install(FILES ${PROJECT_SOURCE_DIR}/src/kinsol/kinsol_impl.h DESTINATION include/kinsol)
+  endif()
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsFortran.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsFortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1cc0b32747b1a8ab428fbda6feadc95baa215c44
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsFortran.cmake
@@ -0,0 +1,339 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban and David Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Fortran-related tests for SUNDIALS CMake-based configuration.
+# ---------------------------------------------------------------
+
+# If the Fortran compiler flags are set using environemnt variables (i.e.,
+# CMAKE_Fortran_FLAGS is not set), then check if both FFLAGS and FCFLAGS are
+# set. If both are set and not the same then a fatal error occurs.
+#
+# NOTE: This check must occur before 'enable_language(Fortran)' as it will use
+# the value of FFLAGS to set CMAKE_Fortran_FLAGS
+set(ENV_FFLAGS "$ENV{FFLAGS}")
+set(ENV_FCFLAGS "$ENV{FCFLAGS}")
+
+# check if environment variables are used and CMAKE_Fortran_FLAGS is not
+if ((NOT "${ENV_FFLAGS}" STREQUAL "") AND (NOT "${ENV_FCFLAGS}" STREQUAL "")
+    AND ("${CMAKE_Fortran_FLAGS}" STREQUAL ""))
+
+  # check if environment variables are equal
+  if (NOT "${ENV_FFLAGS}" STREQUAL "${ENV_FCFLAGS}")
+    print_error("FFLAGS='${ENV_FFLAGS}' and FCFLAGS='${ENV_FCFLAGS}' are both set but are not equal.")
+  endif()
+
+endif()
+
+# Enable Fortran
+enable_language(Fortran)
+set(F77_FOUND TRUE)
+
+# -----------------------------------------------------------------------------
+# Check if Fortran90 is supported
+# -----------------------------------------------------------------------------
+if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
+  set(F90_FOUND TRUE)
+else()
+  set(F90_FOUND FALSE)
+  print_warning("Fortran compiler does not support F90"
+    "F90 support will not be provided")
+endif()
+
+# -----------------------------------------------------------------------------
+# Check if ISO_C_BINDING is supported
+# -----------------------------------------------------------------------------
+if(F2003_INTERFACE_ENABLE)
+  message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports ISO_C_BINDING")
+
+  set(F2003Test_DIR ${PROJECT_BINARY_DIR}/F2003Test_DIR)
+  file(MAKE_DIRECTORY ${F2003Test_DIR})
+
+  # Create a CMakeLists.txt file
+  file(WRITE ${F2003Test_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 3.1.3)\n"
+    "PROJECT(ftest Fortran)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_Fortran_FLAGS \"${CMAKE_Fortran_FLAGS}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_RELEASE \"${CMAKE_Fortran_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_DEBUG \"${CMAKE_Fortran_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_RELWITHDEBUGINFO \"${CMAKE_Fortran_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_MINSIZE \"${CMAKE_Fortran_FLAGS_MINSIZE}\")\n"
+    "ADD_EXECUTABLE(ftest ftest.f90)\n")
+
+  # Create a Fortran source file which tries to use iso_c_binding
+  file(WRITE ${F2003Test_DIR}/ftest.f90
+    "program main\n"
+    "use, intrinsic :: iso_c_binding\n"
+    "end program main\n")
+
+  # Attempt compile the executable
+  try_compile(FTEST_OK ${F2003Test_DIR} ${F2003Test_DIR}
+    ftest OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${F2003Test_DIR}/CMakeFiles)
+
+  if(FTEST_OK)
+    message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports ISO_C_BINDING -- yes")
+    set(Fortran_COMPILER_SUPPORTS_ISOCBINDING TRUE)
+  else()
+    set(Fortran_COMPILER_SUPPORTS_ISOCBINDING FALSE)
+  endif()
+endif()
+
+# -----------------------------------------------------------------------------
+# Setup options and cache variables
+# -----------------------------------------------------------------------------
+
+# show some cache variables
+mark_as_advanced(CLEAR
+  CMAKE_Fortran_COMPILER
+  CMAKE_Fortran_FLAGS)
+
+# hide all build type specific flags
+mark_as_advanced(FORCE
+  CMAKE_Fortran_FLAGS_DEBUG
+  CMAKE_Fortran_FLAGS_MINSIZEREL
+  CMAKE_Fortran_FLAGS_RELEASE
+  CMAKE_Fortran_FLAGS_RELWITHDEBINFO)
+
+# only show flags for the current build type
+# these flags are appended to CMAKE_Fortran_FLAGS
+if(CMAKE_BUILD_TYPE)
+  if(CMAKE_BUILD_TYPE MATCHES "Debug")
+    message("Appending Fortran debug flags")
+    mark_as_advanced(CLEAR CMAKE_Fortran_FLAGS_DEBUG)
+  elseif(CMAKE_BUILD_TYPE MATCHES "MinSizeRel")
+    message("Appending Fortran min size release flags")
+    mark_as_advanced(CLEAR CMAKE_Fortran_FLAGS_MINSIZEREL)
+  elseif(CMAKE_BUILD_TYPE MATCHES "Release")
+    message("Appending Fortran release flags")
+    mark_as_advanced(CLEAR CMAKE_Fortran_FLAGS_RELEASE)
+  elseif(CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
+    message("Appending Fortran release with debug info flags")
+    mark_as_advanced(CLEAR CMAKE_Fortran_FLAGS_RELWITHDEBINFO)
+  endif()
+endif()
+
+
+# ---------------------------------------------------------------
+# Determining the name-mangling scheme if needed
+# ---------------------------------------------------------------
+# In general, names of symbols with and without underscore may be mangled
+# differently (e.g. g77 mangles mysub to mysub_ and my_sub to my_sub__),
+# we have to consider both cases.
+#
+# Method:
+#  1) create a library from a Fortran source file which defines a function "mysub"
+#  2) attempt to link with this library a C source file which calls the "mysub"
+#     function using various possible schemes (6 different schemes, corresponding
+#     to all combinations lower/upper case and none/one/two underscores).
+#  3) define the name-mangling scheme based on the test that was successful.
+#
+# On exit, if we were able to infer the scheme, the variables
+# CMAKE_Fortran_SCHEME_NO_UNDERSCORES and CMAKE_Fortran_SCHEME_WITH_UNDERSCORES
+# contain the mangled names for "mysub" and "my_sub", respectively.
+# ---------------------------------------------------------------
+if(NEED_FORTRAN_NAME_MANGLING)
+
+  set(CMAKE_Fortran_SCHEME_NO_UNDERSCORES "")
+  set(CMAKE_Fortran_SCHEME_WITH_UNDERSCORES "")
+
+  # Create the FortranTest directory
+  set(FortranTest_DIR ${PROJECT_BINARY_DIR}/FortranTest)
+  file(MAKE_DIRECTORY ${FortranTest_DIR})
+
+  # Create a CMakeLists.txt file which will generate the "flib" library
+  # and an executable "ftest"
+  file(WRITE ${FortranTest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+    "PROJECT(ftest Fortran)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_Fortran_FLAGS \"${CMAKE_Fortran_FLAGS}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_RELEASE \"${CMAKE_Fortran_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_DEBUG \"${CMAKE_Fortran_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_RELWITHDEBUGINFO \"${CMAKE_Fortran_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_Fortran_FLAGS_MINSIZE \"${CMAKE_Fortran_FLAGS_MINSIZE}\")\n"
+    "ADD_LIBRARY(flib flib.f)\n"
+    "ADD_EXECUTABLE(ftest ftest.f)\n"
+    "TARGET_LINK_LIBRARIES(ftest flib)\n")
+
+  # Create the Fortran source flib.f which defines two subroutines, "mysub" and "my_sub"
+  file(WRITE ${FortranTest_DIR}/flib.f
+    "        SUBROUTINE mysub\n"
+    "        RETURN\n"
+    "        END\n"
+    "        SUBROUTINE my_sub\n"
+    "        RETURN\n"
+    "        END\n")
+
+  # Create the Fortran source ftest.f which calls "mysub" and "my_sub"
+  file(WRITE ${FortranTest_DIR}/ftest.f
+    "        PROGRAM ftest\n"
+    "        CALL mysub()\n"
+    "        CALL my_sub()\n"
+    "        END\n")
+
+  # Use TRY_COMPILE to make the targets "flib" and "ftest"
+  try_compile(FTEST_OK ${FortranTest_DIR} ${FortranTest_DIR}
+    ftest OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts,
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${FortranTest_DIR}/CMakeFiles)
+
+  # Proceed based on test results
+  if(FTEST_OK)
+
+    # Infer Fortran name-mangling scheme for symbols WITHOUT underscores.
+    # Overwrite CMakeLists.txt with one which will generate the "ctest1" executable
+    file(WRITE ${FortranTest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(ctest1 C)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+      "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+      "ADD_EXECUTABLE(ctest1 ctest1.c)\n"
+      "FIND_LIBRARY(FLIB flib ${FortranTest_DIR})\n"
+      "TARGET_LINK_LIBRARIES(ctest1 \${FLIB})\n")
+
+    # Define the list "options" of all possible schemes that we want to consider
+    # Get its length and initialize the counter "iopt" to zero
+    set(options mysub mysub_ mysub__ MYSUB MYSUB_ MYSUB__)
+    list(LENGTH options imax)
+    set(iopt 0)
+
+    # We will attempt to sucessfully generate the "ctest1" executable as long as
+    # there still are entries in the "options" list
+    while(${iopt} LESS ${imax})
+      # Get the current list entry (current scheme)
+      list(GET options ${iopt} opt)
+      # Generate C source which calls the "mysub" function using the current scheme
+      file(WRITE ${FortranTest_DIR}/ctest1.c "int main(){${opt}();return(0);}\n")
+      # Use TRY_COMPILE to make the "ctest1" executable from the current C source
+      # and linking to the previously created "flib" library.
+      try_compile(CTEST_OK ${FortranTest_DIR} ${FortranTest_DIR}
+        ctest1 OUTPUT_VARIABLE MY_OUTPUT)
+      # To ensure we do not use stuff from the previous attempts,
+      # we must remove the CMakeFiles directory.
+      file(REMOVE_RECURSE ${FortranTest_DIR}/CMakeFiles)
+      # Test if we successfully created the "ctest" executable.
+      # If yes, save the current scheme, and set the counter "iopt" to "imax"
+      # so that we exit the while loop.
+      # Otherwise, increment the counter "iopt" and go back in the while loop.
+      if(CTEST_OK)
+        set(CMAKE_Fortran_SCHEME_NO_UNDERSCORES ${opt})
+        set(iopt ${imax})
+      else(CTEST_OK)
+        math(EXPR iopt ${iopt}+1)
+      endif(CTEST_OK)
+    endwhile(${iopt} LESS ${imax})
+
+    # Infer Fortran name-mangling scheme for symbols WITH underscores.
+    # Practically a duplicate of the previous steps.
+    file(WRITE ${FortranTest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(ctest2 C)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+      "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+      "ADD_EXECUTABLE(ctest2 ctest2.c)\n"
+      "FIND_LIBRARY(FLIB flib ${FortranTest_DIR})\n"
+      "TARGET_LINK_LIBRARIES(ctest2 \${FLIB})\n")
+
+    set(options my_sub my_sub_ my_sub__ MY_SUB MY_SUB_ MY_SUB__)
+    list(LENGTH options imax)
+    set(iopt 0)
+    while(${iopt} LESS ${imax})
+      list(GET options ${iopt} opt)
+      file(WRITE ${FortranTest_DIR}/ctest2.c "int main(){${opt}();return(0);}\n")
+      try_compile(CTEST_OK ${FortranTest_DIR} ${FortranTest_DIR}
+        ctest2 OUTPUT_VARIABLE MY_OUTPUT)
+      file(REMOVE_RECURSE ${FortranTest_DIR}/CMakeFiles)
+      if(CTEST_OK)
+        set(CMAKE_Fortran_SCHEME_WITH_UNDERSCORES ${opt})
+        set(iopt ${imax})
+      else(CTEST_OK)
+        math(EXPR iopt ${iopt}+1)
+      endif(CTEST_OK)
+    endwhile(${iopt} LESS ${imax})
+
+    # If a name-mangling scheme was found set the C preprocessor macros to use
+    # that scheme. Otherwise default to lower case with one underscore.
+    if(CMAKE_Fortran_SCHEME_NO_UNDERSCORES AND CMAKE_Fortran_SCHEME_WITH_UNDERSCORES)
+      message(STATUS "Determining Fortran name-mangling scheme... OK")
+    else()
+      message(STATUS "Determining Fortran name-mangling scheme... DEFAULT")
+      set(CMAKE_Fortran_SCHEME_NO_UNDERSCORES "mysub_")
+      set(CMAKE_Fortran_SCHEME_WITH_UNDERSCORES "my_sub_")
+    endif()
+
+    # Symbols NO underscores
+    if(${CMAKE_Fortran_SCHEME_NO_UNDERSCORES} MATCHES "mysub")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) name")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_NO_UNDERSCORES} MATCHES "mysub_")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) name ## _")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_NO_UNDERSCORES} MATCHES "mysub__")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) name ## __")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_NO_UNDERSCORES} MATCHES "MYSUB")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) NAME")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_NO_UNDERSCORES} MATCHES "MYSUB_")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) NAME ## _")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_NO_UNDERSCORES} MATCHES "MYSUB__")
+      set(F77_MANGLE_MACRO1 "#define SUNDIALS_F77_FUNC(name,NAME) NAME ## __")
+    endif()
+
+    # Symbols WITH underscores
+    if(${CMAKE_Fortran_SCHEME_WITH_UNDERSCORES} MATCHES "my_sub")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) name")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_WITH_UNDERSCORES} MATCHES "my_sub_")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) name ## _")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_WITH_UNDERSCORES} MATCHES "my_sub__")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) name ## __")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_WITH_UNDERSCORES} MATCHES "MY_SUB")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) NAME")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_WITH_UNDERSCORES} MATCHES "MY_SUB_")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) NAME ## _")
+    endif()
+    if(${CMAKE_Fortran_SCHEME_WITH_UNDERSCORES} MATCHES "MY_SUB__")
+      set(F77_MANGLE_MACRO2 "#define SUNDIALS_F77_FUNC_(name,NAME) NAME ## __")
+    endif()
+
+    # name-mangling scheme has been set
+    set(NEED_FORTRAN_NAME_MANGLING FALSE)
+  else(FTEST_OK)
+    message(STATUS "Determining Fortran name-mangling scheme... FAILED")
+  endif(FTEST_OK)
+
+endif()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsHypre.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsHypre.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e52430a835cde719a80059b30aa24c88affa8c8c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsHypre.cmake
@@ -0,0 +1,77 @@
+# ---------------------------------------------------------------
+# Programmer:  Slaven Peles @ LLNL, Jean Sexton @ SMU
+#              Eddy Banks @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Hypre tests for SUNDIALS CMake-based configuration.
+# 
+
+### This is only set if running GUI - simply return first time enabled
+IF(HYPRE_DISABLED)
+  SET(HYPRE_DISABLED FALSE CACHE INTERNAL "GUI - now enabled" FORCE)
+  RETURN()
+ENDIF()
+
+set(HYPRE_FOUND FALSE)
+
+include(FindHypre)
+
+if(UNIX)
+  set(LINK_MATH_LIB "-lm")
+endif()
+
+if(HYPRE_LIBRARIES)
+  message(STATUS "Looking for HYPRE LIBRARIES...")
+  # Create the HYPRETest directory
+  set(HYPRETest_DIR ${PROJECT_BINARY_DIR}/HYPRETest)
+  file(MAKE_DIRECTORY ${HYPRETest_DIR})
+  # Create a CMakeLists.txt file 
+  file(WRITE ${HYPRETest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+    "PROJECT(ltest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_COMPILER ${MPI_C_COMPILER})\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "SET(CMAKE_EXE_LINKER_FLAGS \"${LINK_MATH_LIB}\")\n"
+    "INCLUDE_DIRECTORIES(${HYPRE_INCLUDE_DIR})\n"
+    "ADD_EXECUTABLE(ltest ltest.c)\n"
+    "TARGET_LINK_LIBRARIES(ltest ${HYPRE_LIBRARIES})\n")    
+  # Create a C source file which calls a hypre function
+  file(WRITE ${HYPRETest_DIR}/ltest.c
+    "\#include \"HYPRE_parcsr_ls.h\"\n"
+    "int main(){\n"
+    "HYPRE_ParVector par_b;\n"
+    "HYPRE_IJVector b;\n"
+    "return(0);\n"
+    "}\n")
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${HYPRETest_DIR} ${HYPRETest_DIR} ltest OUTPUT_VARIABLE MY_OUTPUT)
+      
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${HYPRETest_DIR}/CMakeFiles)
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Checking if HYPRE works... OK")
+    set(HYPRE_FOUND TRUE)
+  else(LTEST_OK)
+    message(STATUS "Checking if HYPRE works... FAILED")
+  endif(LTEST_OK)
+else(HYPRE_LIBRARIES)
+  PRINT_WARNING("HYPRE LIBRARIES NOT Found. Please check library path" "${HYPRE_LIBRARY_DIR} ")
+  message(STATUS "Looking for HYPRE LIBRARY... FAILED")
+endif(HYPRE_LIBRARIES)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsIndexSize.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsIndexSize.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..79199f1601692787a1b14ba7c70d447df9cecd3f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsIndexSize.cmake
@@ -0,0 +1,86 @@
+# -----------------------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# -----------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# -----------------------------------------------------------------------------
+# This module handles setting the index sizes in SUNDIALS. 
+# The SUNDIALS_INDEX_SIZE build option can be set to 64 or 32 
+# for 64-bit or 32-bit signed integer indices. The module will try
+# various types for each size until it finds one that matches the
+# desired size. If no match is found, a user can provide a type via 
+# the advanced options SUNDIALS_CINDEX_TYPE and SUNDIALS_FINDEX_TYPE.
+# -----------------------------------------------------------------------------
+
+INCLUDE(CheckTypeSize)
+
+IF(SUNDIALS_INDEX_SIZE MATCHES "64")
+  SET(SUNDIALS_CINDEX_TYPE "")
+  
+  # if the user specified an index type use it, otherwise try the standard options
+  IF (SUNDIALS_INDEX_TYPE)
+    SET(POSSIBLE_INT64 ${SUNDIALS_INDEX_TYPE})
+  ELSE()
+    SET(POSSIBLE_INT64 int64_t;__int64;long long;long)
+  ENDIF()
+  
+  FOREACH(INT64_TYPE ${POSSIBLE_INT64})
+    string(REPLACE " " "_" INT64_TYPE_NOSPACE ${INT64_TYPE})
+    CHECK_TYPE_SIZE("${INT64_TYPE}" HAS_${INT64_TYPE_NOSPACE})
+    IF(HAS_${INT64_TYPE_NOSPACE} EQUAL "8")
+      SET(SUNDIALS_CINDEX_TYPE ${INT64_TYPE})
+      MESSAGE(STATUS "Using ${INT64_TYPE} for indices")
+      BREAK()
+    ENDIF()
+  ENDFOREACH()
+  
+  IF(NOT SUNDIALS_CINDEX_TYPE)
+    PRINT_ERROR("No integer type of size 8 was found.\n\
+                 Tried ${POSSIBLE_INT64}.\n\
+                 Try setting the advanced option SUNDIALS_INDEX_TYPE.")
+  ENDIF()
+
+  # set Fortran integer size too
+  SET(SUNDIALS_FINDEX_TYPE "8")
+  # prepare substitution variable INDEX_TYPE for sundials_config.h
+  SET(INDEX_TYPE "#define SUNDIALS_INT${SUNDIALS_INDEX_SIZE}_T 1")
+ELSEIF(SUNDIALS_INDEX_SIZE MATCHES "32")
+  SET(SUNDIALS_CINDEX_TYPE "")
+  
+  # if the user specified an index type use it, otherwise try the standard options
+  IF (SUNDIALS_INDEX_TYPE)
+    SET(POSSIBLE_INT32 ${SUNDIALS_INDEX_TYPE})
+  ELSE()
+    SET(POSSIBLE_INT32 int32_t;int;long)
+  ENDIF()
+  
+  FOREACH(INT32_TYPE ${POSSIBLE_INT32})
+    string(REPLACE " " "_" INT32_TYPE_NOSPACE ${INT32_TYPE})
+    CHECK_TYPE_SIZE("${INT32_TYPE}" HAS_${INT32_TYPE_NOSPACE})
+    IF(HAS_${INT32_TYPE_NOSPACE} EQUAL "4")
+      SET(SUNDIALS_CINDEX_TYPE ${INT32_TYPE})
+      MESSAGE(STATUS "Using ${INT32_TYPE} for indices")
+      BREAK()
+    ENDIF()
+  ENDFOREACH()
+  
+  IF(NOT SUNDIALS_CINDEX_TYPE)
+    PRINT_ERROR("No integer type of size 4 was found.\n\
+                 Tried ${POSSIBLE_INT32}\n\
+                 Try setting the advanced option SUNDIALS_INDEX_TYPE.")
+  ENDIF()
+  
+  # set Fortran integer size too
+  SET(SUNDIALS_FINDEX_TYPE "4")
+  # prepare substitution variable INDEX_TYPE for sundials_config.h
+  SET(INDEX_TYPE "#define SUNDIALS_INT${SUNDIALS_INDEX_SIZE}_T 1")
+ELSE()
+  PRINT_ERROR("Invalid index size.")
+ENDIF()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsKLU.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsKLU.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..49919138b3473b98eef96f13c873e04cbfdc198d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsKLU.cmake
@@ -0,0 +1,75 @@
+# ---------------------------------------------------------------
+# Programmer:  Steven Smith @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# KLU tests for SUNDIALS CMake-based configuration.
+#    - loosely based on SundialsLapack.cmake
+#
+
+### This is only set if running GUI - simply return first time enabled
+IF(KLU_DISABLED)
+  SET(KLU_DISABLED FALSE CACHE INTERNAL "GUI - KLU now enabled" FORCE)
+  RETURN()
+ENDIF()
+
+SET(KLU_FOUND FALSE)
+
+# set KLU_LIBRARIES
+include(FindKLU)
+# If we have the KLU libraries, test them
+if(KLU_LIBRARIES)
+  message(STATUS "Looking for KLU libraries...")
+  # Create the KLUTest directory
+  set(KLUTest_DIR ${PROJECT_BINARY_DIR}/KLUTest)
+  file(MAKE_DIRECTORY ${KLUTest_DIR})
+  # Create a CMakeLists.txt file 
+  file(WRITE ${KLUTest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 2.4)\n"
+    "PROJECT(ltest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "INCLUDE_DIRECTORIES(${KLU_INCLUDE_DIR})\n"
+    "ADD_EXECUTABLE(ltest ltest.c)\n"
+    "TARGET_LINK_LIBRARIES(ltest ${KLU_LIBRARIES})\n")    
+# Create a C source file which calls a KLU function
+# SGS TODO what is a simple KLU method to invoke?
+  file(WRITE ${KLUTest_DIR}/ltest.c
+    "\#include \"klu.h\"\n"
+    "int main(){\n"
+    "klu_common Common;\n"
+    "klu_defaults (&Common);\n" 
+    "return(0);\n"
+    "}\n")
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${KLUTest_DIR} ${KLUTest_DIR} ltest OUTPUT_VARIABLE MY_OUTPUT)
+      
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${KLUTest_DIR}/CMakeFiles)
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Checking if KLU works... OK")
+    set(KLU_FOUND TRUE)
+  else(LTEST_OK)
+    message(STATUS "Checking if KLU works... FAILED")
+  endif(LTEST_OK)
+else(KLU_LIBRARIES)
+  PRINT_WARNING("KLU LIBRARIES NOT Found. Please check library path" "${KLU_LIBRARY_DIR} ")
+  message(STATUS "Looking for KLU libraries... FAILED")
+endif(KLU_LIBRARIES)
+ 
+  
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsLapack.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsLapack.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e1bc5ad3f8f9b871740c7c9fbe0feab3c3732894
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsLapack.cmake
@@ -0,0 +1,105 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# BLAS/LAPACK tests for SUNDIALS CMake-based configuration.
+
+SET(LAPACK_FOUND FALSE)
+
+# If LAPACK libraries are undefined, try to find them (if we have
+# a working Fortran compiler) or look for them in the most
+# obvious place...
+if(NOT LAPACK_LIBRARIES)
+  if(F77_FOUND)
+    include(FindLAPACK)
+  else(F77_FOUND)
+    find_library(LAPACK_LIBRARIES
+      NAMES lapack
+      PATHS /usr/lib /usr/local/lib
+      "$ENV{ProgramFiles}/LAPACK/Lib"
+      )
+  endif(F77_FOUND)
+
+  # If the xSDK flag is used, set it to what was found
+  if(LAPACK_LIBRARIES AND TPL_ENABLE_LAPACK)
+    SET(DOCSTR "Lapack library")
+    FORCE_VARIABLE(TPL_LAPACK_LIBRARIES STRING "${DOCSTR}" "${LAPACK_LIBRARIES}")
+  endif()
+endif()
+
+# If we have the LAPACK libraries, test them
+if(LAPACK_LIBRARIES)
+  message(STATUS "Looking for LAPACK libraries... OK")
+
+  # Create the LapackTest directory
+  set(LapackTest_DIR ${PROJECT_BINARY_DIR}/LapackTest)
+  file(MAKE_DIRECTORY ${LapackTest_DIR})
+
+  # Create a CMakeLists.txt file 
+  file(WRITE ${LapackTest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 2.4)\n"
+    "PROJECT(ltest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "ADD_EXECUTABLE(ltest ltest.c)\n"
+    "TARGET_LINK_LIBRARIES(ltest ${LAPACK_LIBRARIES})\n")
+
+  # Create a C source file which calls a Blas function (dcopy) and an Lapack function (dgetrf)
+  file(WRITE ${LapackTest_DIR}/ltest.c
+    "${F77_MANGLE_MACRO1}\n"
+    "#define dcopy_f77 SUNDIALS_F77_FUNC(dcopy, DCOPY)\n"
+    "#define dgetrf_f77 SUNDIALS_F77_FUNC(dgetrf, DGETRF)\n"
+    "extern void dcopy_f77(int *n, const double *x, const int *inc_x, double *y, const int *inc_y);\n"
+    "extern void dgetrf_f77(const int *m, const int *n, double *a, int *lda, int *ipiv, int *info);\n"
+    "int main(){\n"
+    "int n=1;\n"
+    "double x, y;\n"
+    "dcopy_f77(&n, &x, &n, &y, &n);\n"
+    "dgetrf_f77(&n, &n, &x, &n, &n, &n);\n"
+    "return(0);\n"
+    "}\n")
+
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${LapackTest_DIR} ${LapackTest_DIR}
+    ltest OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${LapackTest_DIR}/CMakeFiles)
+
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Checking if LAPACK works... OK")
+    set(LAPACK_FOUND TRUE)
+
+    # get path to LAPACK library to use in generated makefiles for examples, if
+    # LAPACK_LIBRARIES contains multiple items only use the path of the first entry
+    list(LENGTH LAPACK_LIBRARIES len)
+    if(len EQUAL 1)
+      get_filename_component(LAPACK_LIBRARY_DIR ${LAPACK_LIBRARIES} PATH)
+    else()
+      list(GET LAPACK_LIBRARIES 0 TMP_LAPACK_LIBRARIES)
+      get_filename_component(LAPACK_LIBRARY_DIR ${TMP_LAPACK_LIBRARIES} PATH)
+    endif()
+
+  else(LTEST_OK)
+    message(STATUS "Checking if LAPACK works... FAILED")
+  endif(LTEST_OK)
+
+else(LAPACK_LIBRARIES)
+  message(STATUS "Looking for LAPACK libraries... FAILED")
+endif(LAPACK_LIBRARIES)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsMPI.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsMPI.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4dd3b659a501a0fc3d905bbddaa1bd73debc97a4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsMPI.cmake
@@ -0,0 +1,349 @@
+# ---------------------------------------------------------------------------
+# Programmer: David J. Gardner @ LLNL
+# ---------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------------------
+# MPI tests for SUNDIALS CMake-based configuration.
+# ---------------------------------------------------------------------------
+
+# ---------------------------------------------------------------------------
+# Prior to CMake 3.10 the CMake FindMPI module considers:
+#   1. Inspect MPI wrappers (MPI_<lang>_COMPILER)
+#   2. Try guesses
+#   3. Try the compiler (CMAKE_<lang>_COMPILER)
+#
+# Starting with CMake 3.10 the CMake FindMPI module considers:
+#   1. Try the compiler (CMAKE_<lang>_COMPILER)
+#   2. Inspect MPI wrappers (MPI_<lang>_COMPILER)
+#   3. Try guesses
+# ---------------------------------------------------------------------------
+
+# ---------------------------------------------------------------------------
+# If MPI_<lang>_COMPILER is not defined check if CMAKE_<lang>_COMPILER
+# can compile a simple MPI program and set MPI_<lang>_COMPILER
+# ---------------------------------------------------------------------------
+
+# check C compiler
+if(NOT MPI_C_COMPILER)
+
+  message(STATUS "Check for working MPI C compiler: ${CMAKE_C_COMPILER}")
+
+  # Create the MPITest directory
+  set(MPITest_DIR ${PROJECT_BINARY_DIR}/MPICCTest)
+  file(MAKE_DIRECTORY ${MPITest_DIR})
+
+  # Create a CMakeLists.txt file which will generate the "mpictest" executable
+  file(WRITE ${MPITest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+    "PROJECT(mpictest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "ADD_EXECUTABLE(mpictest mpictest.c)\n")
+
+  # Create a simple C source which only calls MPI_Init and MPI_Finalize
+  file(WRITE ${MPITest_DIR}/mpictest.c
+    "#include <mpi.h>\n"
+    "int main(){\n"
+    "int c;\n"
+    "char **v;\n"
+    "MPI_Init(&c, &v);\n"
+    "MPI_Finalize();\n"
+    "return(0);\n"
+    "}\n")
+
+  # Use TRY_COMPILE to make the target "mpictest"
+  try_compile(MPI_TEST_OK ${MPITest_DIR} ${MPITest_DIR}
+    mpictest OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts,
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${MPITest_DIR}/CMakeFiles)
+
+  # Process test result
+  if(MPI_TEST_OK)
+    message(STATUS "Check for working MPI C compiler: ${CMAKE_C_COMPILER} -- works")
+    show_variable(MPI_C_COMPILER STRING "MPI C compiler" ${CMAKE_C_COMPILER})
+    set(MPI_C_FOUND TRUE)
+  else()
+    message(STATUS "Check for working MPI C compiler: ${CMAKE_C_COMPILER} -- broken")
+  endif()
+
+endif()
+
+# only check C++ and Fortran compilers if MPI C compiler was found and works
+if(MPI_C_FOUND)
+
+  # check CXX compiler
+  if(CXX_FOUND AND (NOT MPI_CXX_COMPILER))
+
+    message(STATUS "Check for working MPI C++ compiler: ${CMAKE_CXX_COMPILER}")
+
+    # Create the MPITest directory
+    set(MPITest_DIR ${PROJECT_BINARY_DIR}/MPICXXTest)
+    file(MAKE_DIRECTORY ${MPITest_DIR})
+
+    # Create a CMakeLists.txt file which will generate the "mpicxxtest" executable
+    file(WRITE ${MPITest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(mpicxxtest CXX)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_CXX_COMPILER \"${CMAKE_CXX_COMPILER}\")\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS}\")\n"
+      "SET(CMAKE_CXX_FLAGS_RELEASE \"${CMAKE_CXX_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_CXX_FLAGS_DEBUG \"${CMAKE_CXX_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_CXX_FLAGS_RELWITHDEBUGINFO \"${CMAKE_CXX_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_CXX_FLAGS_MINSIZE \"${CMAKE_CXX_FLAGS_MINSIZE}\")\n"
+      "ADD_EXECUTABLE(mpicxxtest mpicxxtest.cpp)\n")
+
+    # Create a simple C++ source which only calls MPI_Init and MPI_Finalize
+    file(WRITE ${MPITest_DIR}/mpicxxtest.cpp
+      "#include <mpi.h>\n"
+      "int main(){\n"
+      "int c;\n"
+      "char **v;\n"
+      "MPI_Init(&c, &v);\n"
+      "MPI_Finalize();\n"
+      "return(0);\n"
+      "}\n")
+
+    # Use TRY_COMPILE to make the target "mpicxxtest"
+    try_compile(MPI_TEST_OK ${MPITest_DIR} ${MPITest_DIR}
+      mpicxxtest OUTPUT_VARIABLE MY_OUTPUT)
+
+    # To ensure we do not use stuff from the previous attempts,
+    # we must remove the CMakeFiles directory.
+    file(REMOVE_RECURSE ${MPITest_DIR}/CMakeFiles)
+
+    # Process test result
+    if(MPI_TEST_OK)
+      message(STATUS "Check for working MPI C++ compiler: ${CMAKE_CXX_COMPILER} -- works")
+      show_variable(MPI_CXX_COMPILER STRING "MPI C++ compiler" ${CMAKE_CXX_COMPILER})
+      set(MPI_CXX_FOUND TRUE)
+    else()
+      message(STATUS "Check for working MPI C++ compiler: ${CMAKE_CXX_COMPILER} -- broken")
+    endif()
+
+  endif()
+
+  # check Fortran compiler
+  if((F77_FOUND OR F90_FOUND) AND (NOT MPI_Fortran_COMPILER))
+
+    message(STATUS "Check for working MPI Fortran compiler: ${CMAKE_Fortran_COMPILER}")
+
+    # Create the MPI Test directory
+    set(MPITest_DIR ${PROJECT_BINARY_DIR}/MPIFTest)
+    file(MAKE_DIRECTORY ${MPITest_DIR})
+
+    # Create a CMakeLists.txt file which will generate the "mpiftest" executable
+    file(WRITE ${MPITest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(mpiftest Fortran)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_Fortran_COMPILER \"${CMAKE_Fortran_COMPILER}\")\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_Fortran_FLAGS \"${CMAKE_Fortran_FLAGS}\")\n"
+      "SET(CMAKE_Fortran_FLAGS_RELEASE \"${CMAKE_Fortran_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_Fortran_FLAGS_DEBUG \"${CMAKE_Fortran_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_Fortran_FLAGS_RELWITHDEBUGINFO \"${CMAKE_Fortran_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_Fortran_FLAGS_MINSIZE \"${CMAKE_Fortran_FLAGS_MINSIZE}\")\n"
+      "ADD_EXECUTABLE(mpif9test mpiftest.f)\n")
+
+    # Create a simple Fortran source which only calls MPI_Init and MPI_Finalize
+    file(WRITE ${MPITest_DIR}/mpiftest.f
+      "       INCLUDE \"mpif.h\"\n"
+      "       INTEGER IER\n"
+      "       CALL MPI_INIT(IER)\n"
+      "       CALL MPI_FINALIZE(IER)\n"
+      "       STOP\n"
+      "       END\n")
+
+    # Use TRY_COMPILE to make the target "mpiftest"
+    try_compile(MPI_TEST_OK ${MPITest_DIR} ${MPITest_DIR}
+      mpiftest OUTPUT_VARIABLE MY_OUTPUT)
+
+    # To ensure we do not use stuff from the previous attempts,
+    # we must remove the CMakeFiles directory.
+    file(REMOVE_RECURSE ${MPITest_DIR}/CMakeFiles)
+
+    # Process test result
+    if(MPI_TEST_OK)
+      message(STATUS "Check for working MPI Fortran compiler: ${CMAKE_Fortran_COMPILER} -- works")
+      show_variable(MPI_Fortran_COMPILER STRING "MPI Fortran compiler" ${CMAKE_Fortran_COMPILER})
+      set(MPI_Fortran_FOUND TRUE)
+    else()
+      message(STATUS "Check for working MPI Fortran compiler: ${CMAKE_Fortran_COMPILER} -- broken")
+    endif()
+
+  endif()
+
+endif()
+
+# ---------------------------------------------------------------------------
+# If MPI_<lang>_COMPILER is set, FindMPI will try to set the below variables
+# for the given compiler wrapper. If MPI_<lang>_COMPILER is unset FindMPI
+# will attempt to locate an installed MPI library and set the below
+# variables.
+#
+#   MPI_<lang>_FOUND           TRUE if FindMPI found MPI flags for <lang>
+#   MPI_<lang>_COMPILER        MPI Compiler wrapper for <lang>
+#   MPI_<lang>_COMPILE_FLAGS   Compilation flags for MPI programs
+#   MPI_<lang>_INCLUDE_PATH    Include path(s) for MPI header
+#   MPI_<lang>_LINK_FLAGS      Linking flags for MPI programs
+#   MPI_<lang>_LIBRARIES       All libraries to link MPI programs against
+#
+#   MPIEXEC_EXECUTABLE         Executable for running MPI programs
+#   MPIEXEC_NUMPROC_FLAG       Flag to pass to MPIEXEC_EXECUTABLE before
+#                              giving it the number of processors to run on
+#   MPIEXEC_PREFLAGS           Flags to pass to MPIEXEC_EXECUTABLE directly
+#                              before the executable to run.
+#   MPIEXEC_POSTFLAGS          Flags to pass to MPIEXEC_EXECUTABLE after
+#                              other flags
+# ---------------------------------------------------------------------------
+
+# Copy value of MPIEXEC_EXECUTABLE to MPIEXEC for older versions of CMake
+if((CMAKE_VERSION VERSION_LESS 3.10) AND (MPIEXEC_EXECUTABLE))
+  force_variable(MPIEXEC FILEPATH "MPI run command" ${MPIEXEC_EXECUTABLE})
+endif()
+
+find_package(MPI)
+
+# Copy value of MPIEXEC to MPIEXEC_EXECUTABLE for older versions of CMake
+if(CMAKE_VERSION VERSION_LESS 3.10)
+  force_variable(MPIEXEC_EXECUTABLE FILEPATH "MPI run command" ${MPIEXEC})
+  mark_as_advanced(MPIEXEC)
+endif()
+
+# MPI not functioning
+if(NOT MPI_C_FOUND)
+  set(MPI_C_FOUND FALSE)
+  set(MPI_CXX_FOUND FALSE)
+  set(MPI_Fortran_FOUND FALSE)
+endif()
+
+# show some advaned MPI C variables
+mark_as_advanced(CLEAR MPI_C_COMPILER)
+mark_as_advanced(CLEAR MPIEXEC_EXECUTABLE)
+
+# hide some MPI C variables
+mark_as_advanced(MPI_C_LIBRARIES)
+mark_as_advanced(MPI_C_COMPILE_FLAGS)
+mark_as_advanced(MPI_C_INCLUDE_PATH)
+mark_as_advanced(MPI_C_LIBRARIES)
+mark_as_advanced(MPI_C_LINK_FLAGS)
+
+# hide some MPI variables
+mark_as_advanced(MPI_EXTRA_LIBRARY)
+mark_as_advanced(MPI_LIBRARY)
+
+if(CXX_FOUND)
+  # show some advaned MPI C variables
+  mark_as_advanced(CLEAR MPI_CXX_COMPILER)
+  # hide some MPI CXX variables
+  mark_as_advanced(MPI_CXX_LIBRARIES)
+  mark_as_advanced(MPI_CXX_COMPILE_FLAGS)
+  mark_as_advanced(MPI_CXX_INCLUDE_PATH)
+  mark_as_advanced(MPI_CXX_LIBRARIES)
+  mark_as_advanced(MPI_CXX_LINK_FLAGS)
+endif()
+
+if(F77_FOUND OR F90_FOUND)
+  # show some advaned MPI Fortran variables
+  mark_as_advanced(CLEAR MPI_Fortran_COMPILER)
+  # hide some MPI Fortran variables
+  mark_as_advanced(MPI_Fortran_COMPILE_FLAGS)
+  mark_as_advanced(MPI_Fortran_INCLUDE_PATH)
+  mark_as_advanced(MPI_Fortran_LIBRARIES)
+  mark_as_advanced(MPI_Fortran_LINK_FLAGS)
+endif()
+
+# determine if MPI-2 is supported
+if(MPI_C_FOUND)
+
+  # MPI_VERSION is set by FindMPI in CMake 3.10 and later, update to:
+  # if(NOT MPI_VERSION) test else() check version number endif()
+
+  # Create the MPITest directory
+  set(MPITest_DIR ${PROJECT_BINARY_DIR}/MPI2Test)
+  file(MAKE_DIRECTORY ${MPITest_DIR})
+
+  # Create CMakeLists.txt file for "mpi2test" executable
+  if(MPI_C_COMPILER)
+    
+    file(WRITE ${MPITest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(mpi2test C)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_C_COMPILER ${MPI_C_COMPILER})\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+      "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+      "ADD_EXECUTABLE(mpi2test mpi2test.c)\n")
+
+  else()
+
+    file(WRITE ${MPITest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(mpi2test C)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_C_COMPILER ${CMAKE_C_COMPILER})\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+      "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+      "INCLUDE_DIRECTORIES(${MPI_INCLUDE_PATH})\n"
+      "ADD_EXECUTABLE(mpi2test mpi2test.c)\n"
+      "TARGET_LINK_LIBRARIES(mpi2test ${MPI_LIBRARIES})\n")
+
+  endif()
+
+  # Create a simple C source which calls the MPI_Comm_f2c function
+  file(WRITE ${MPITest_DIR}/mpi2test.c
+    "#include <mpi.h>\n"
+    "int main(){\n"
+    "int c;\n"
+    "char **v;\n"
+    "MPI_Comm C_comm;\n"
+    "MPI_Init(&c, &v);\n"
+    "C_comm = MPI_Comm_f2c((MPI_Fint) 1);\n"
+    "MPI_Finalize();\n"
+    "return(0);\n"
+    "}\n")
+
+  # Use TRY_COMPILE to make the target "mpi2test"
+  try_compile(MPITEST_OK ${MPITest_DIR} ${MPITest_DIR}
+    mpi2test OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts,
+  # we must remove the CMakeFiles directory.
+  FILE(REMOVE_RECURSE ${MPITest_DIR}/CMakeFiles)
+
+  # Interpret test results
+  if(MPITEST_OK)
+    message(STATUS "Checking for MPI-2 support... OK")
+    set(MPIC_MPI2 TRUE)
+  else()
+    message(STATUS "Checking for MPI-2 support... FAILED")
+    set(MPIC_MPI2 FALSE)
+  endif()
+
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsOpenMP.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsOpenMP.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..200c723fbcd3499a058fbdec1689deb4b1c9ec17
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsOpenMP.cmake
@@ -0,0 +1,54 @@
+# ---------------------------------------------------------------------------
+# Programmer: David J. Gardner, and Cody J. Balos @ LLNL
+# ---------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------------------
+# Locate OpenMP and test for OpenMP device offloading support
+# ---------------------------------------------------------------------------
+
+find_package(OpenMP)
+
+# Check for OpenMP offloading support
+if(OPENMP_FOUND AND OPENMP_DEVICE_ENABLE)
+
+  if(SKIP_OPENMP_DEVICE_CHECK)
+
+    # The user has asked for checks to be skipped, assume offloading is supported
+    set(OPENMP_SUPPORTS_DEVICE_OFFLOADING TRUE)
+
+  else()
+
+    # If CMake version is 3.9 or newer, the FindOpenMP module checks the
+    # OpenMP version.
+    if((CMAKE_VERSION VERSION_EQUAL 3.9) OR (CMAKE_VERSION VERSION_GREATER 3.9))
+
+      message(STATUS "Checking whether OpenMP supports device offloading")
+
+      if((OpenMP_C_VERSION VERSION_EQUAL 4.5) OR (OpenMP_C_VERSION VERSION_GREATER 4.5))
+        message(STATUS "Checking whether OpenMP supports device offloading -- yes")
+        set(OPENMP_SUPPORTS_DEVICE_OFFLOADING TRUE)
+      else()
+        message(STATUS "Checking whether OpenMP supports device offloading -- no")
+        set(OPENMP_SUPPORTS_DEVICE_OFFLOADING FALSE)
+      endif()
+
+    else()
+
+      # CMake OpenMP version check not available, assume offloading is supported
+      set(OPENMP_SUPPORTS_DEVICE_OFFLOADING TRUE)
+      print_warning("Unable to determine OpenMP offloading support."
+        "OPENMP_DEVICE_ENABLE is ON but device offloading may not function.")
+
+    endif()
+
+  endif()
+
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsPETSc.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsPETSc.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..89aedbf3bb74218c0f2e441dd78d276b2ad82fbf
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsPETSc.cmake
@@ -0,0 +1,73 @@
+# ---------------------------------------------------------------
+# Programmer:  Eddy Banks @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# PETSc tests for SUNDIALS CMake-based configuration.
+# 
+
+### This is only set if running GUI - simply return first time enabled
+IF(PETSC_DISABLED)
+  SET(PETSC_DISABLED FALSE CACHE INTERNAL "GUI - now enabled" FORCE)
+  RETURN()
+ENDIF()
+
+SET(PETSC_FOUND FALSE)
+
+# set PETSC_LIBRARIES
+include(FindPETSc)
+
+# If we have the PETSC libraries, test them
+if(PETSC_LIBRARIES)
+  message(STATUS "Looking for PETSc libraries...")
+  # Create the PETSCTest directory
+  set(PETSCTest_DIR ${PROJECT_BINARY_DIR}/PETSCTest)
+  file(MAKE_DIRECTORY ${PETSCTest_DIR})
+  # Create a CMakeLists.txt file 
+  file(WRITE ${PETSCTest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+    "PROJECT(ltest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_COMPILER ${MPI_C_COMPILER})\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "INCLUDE_DIRECTORIES(${PETSC_INCLUDE_DIR})\n"
+    "ADD_EXECUTABLE(ltest ltest.c)\n"
+    "TARGET_LINK_LIBRARIES(ltest ${PETSC_LIBRARIES})\n")    
+  # Create a C source file which calls a PETSC function
+  file(WRITE ${PETSCTest_DIR}/ltest.c
+    "\#include \"petscvec.h\"\n"
+    "int main(){\n"
+    "Vec x;\n"
+    "VecCreate(PETSC_COMM_WORLD, &x);\n" 
+    "return(0);\n"
+    "}\n")
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${PETSCTest_DIR} ${PETSCTest_DIR} ltest OUTPUT_VARIABLE MY_OUTPUT)
+      
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${PETSCTest_DIR}/CMakeFiles)
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Checking if PETSc works... OK")
+    set(PETSC_FOUND TRUE)
+  else(LTEST_OK)
+    message(STATUS "Checking if PETSc works... FAILED")
+  endif(LTEST_OK)
+else(PETSC_LIBRARIES)
+  PRINT_WARNING("PETSC LIBRARIES NOT Found. Please check library path" "${PETSC_LIBRARY_DIR} ")
+  message(STATUS "Looking for PETSc libraries... FAILED")
+endif(PETSC_LIBRARIES)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsPOSIXTimers.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsPOSIXTimers.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a59856d92b514657b1821eadc82e916a1d246e79
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsPOSIXTimers.cmake
@@ -0,0 +1,89 @@
+# ---------------------------------------------------------------------------
+# Programmer: David J. Gardner @ LLNL
+# ---------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------------------
+# Check if POSIX timers are available and test if they can be used as some
+# compiler flags will preclude using POSIX timers even if they are present
+# (e.g., -ansi).
+# ---------------------------------------------------------------------------
+
+# clock-monotonic, see if we need to link with rt
+include(CheckSymbolExists)
+
+# save and overwrite required libraries to check for timers
+set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
+set(CMAKE_REQUIRED_LIBRARIES rt)
+
+# check if _POSIX_TIMERS macro is defined in required libraries
+check_symbol_exists(_POSIX_TIMERS "unistd.h;time.h" SUNDIALS_POSIX_TIMERS)
+
+# restore required libraries
+set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
+
+if(SUNDIALS_POSIX_TIMERS)
+
+  # locate rt library and hide cache variable
+  find_library(SUNDIALS_RT_LIBRARY NAMES rt)
+  mark_as_advanced(SUNDIALS_RT_LIBRARY)
+
+  if(SUNDIALS_RT_LIBRARY)
+
+    # Test timers with a simple program
+    set(POSIXTest_DIR ${PROJECT_BINARY_DIR}/PosixTimersTest)
+    file(MAKE_DIRECTORY ${POSIXTest_DIR})
+
+    # Create a CMakeLists.txt file which will generate the test executable
+    file(WRITE ${POSIXTest_DIR}/CMakeLists.txt
+      "CMAKE_MINIMUM_REQUIRED(VERSION 3.0.2)\n"
+      "PROJECT(posixtimerstest C)\n"
+      "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+      "SET(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")\n"
+      "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+      "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+      "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+      "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+      "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+      "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+      "ADD_EXECUTABLE(posixtimerstest posixtimerstest.c)\n"
+      "TARGET_LINK_LIBRARIES(posixtimerstest ${SUNDIALS_RT_LIBRARY})\n")
+
+    # Create a simple C source for testing
+    file(WRITE ${POSIXTest_DIR}/posixtimerstest.c
+      "#include <time.h>\n"
+      "#include <unistd.h>\n"
+      "int main(){\n"
+      "time_t base_time_tv_sec = 0;\n"
+      "struct timespec spec;\n"
+      "clock_gettime(CLOCK_MONOTONIC_RAW, &spec);\n"
+      "base_time_tv_sec = spec.tv_sec;\n"
+      "clock_getres(CLOCK_MONOTONIC_RAW, &spec);\n"
+      "return(0);\n"
+      "}\n")
+
+    # Use TRY_COMPILE to make the target
+    try_compile(POSIX_TIMERS_TEST_OK ${POSIXTest_DIR} ${POSIXTest_DIR}
+      posixtimerstest OUTPUT_VARIABLE MY_OUTPUT)
+
+    # To ensure we do not use stuff from the previous attempts,
+    # we must remove the CMakeFiles directory.
+    file(REMOVE_RECURSE ${POSIXTest_DIR}/CMakeFiles)
+
+    # Process test result
+    if(POSIX_TIMERS_TEST_OK)
+      # set sundials_config.h symbol
+      set(SUNDIALS_HAVE_POSIX_TIMERS TRUE)
+      # add rt library to list of extra libraries linked against
+      set(EXTRA_LINK_LIBS ${EXTRA_LINK_LIBS} ${SUNDIALS_RT_LIBRARY})
+    endif()
+
+  endif()
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsSuperLUMT.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsSuperLUMT.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8244f931372667d4bdcbf888539592525b0743a5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsSuperLUMT.cmake
@@ -0,0 +1,81 @@
+# ---------------------------------------------------------------
+# Programmer:  Eddy Banks @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# SUPERLUMT tests for SUNDIALS CMake-based configuration.
+#    - loosely based on SundialsLapack.cmake
+#
+
+
+### This is only set if running GUI - simply return first time enabled
+IF(SUPERLUMT_DISABLED)
+  SET(SUPERLUMT_DISABLED FALSE CACHE INTERNAL "GUI - SUPERLUMT now enabled" FORCE)
+  RETURN()
+ENDIF()
+
+SET(SUPERLUMT_FOUND FALSE)
+
+# set SUPERLUMT_LIBRARIES
+include(FindSUPERLUMT)
+
+# If we have the SUPERLUMT libraries, test them
+if(SUPERLUMT_LIBRARY AND SUPERLUMT_LIBRARIES)
+  message(STATUS "Looking for SUPERLUMT libraries... OK")
+
+  # Create the SUPERLUMT_TEST directory
+  set(SUPERLUMT_TEST_DIR ${PROJECT_BINARY_DIR}/SUPERLUMT_TEST)
+  file(MAKE_DIRECTORY ${SUPERLUMT_TEST_DIR})
+
+  # Create a CMakeLists.txt file 
+  file(WRITE ${SUPERLUMT_TEST_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 2.4)\n"
+    "PROJECT(ltest C)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\")\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}\")\n"
+    "SET(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE}\")\n"
+    "SET(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG}\")\n"
+    "SET(CMAKE_C_FLAGS_RELWITHDEBUGINFO \"${CMAKE_C_FLAGS_RELWITHDEBUGINFO}\")\n"
+    "SET(CMAKE_C_FLAGS_MINSIZE \"${CMAKE_C_FLAGS_MINSIZE}\")\n"
+    "INCLUDE_DIRECTORIES(${SUPERLUMT_INCLUDE_DIR})\n"
+    "ADD_EXECUTABLE(ltest ltest.c)\n"
+    "TARGET_LINK_LIBRARIES(ltest ${SUPERLUMT_LIBRARIES})\n")    
+
+  # Create a C source file which calls a SUPERLUMT function
+  file(WRITE ${SUPERLUMT_TEST_DIR}/ltest.c
+    "\#include \"slu_mt_ddefs.h\"\n"
+#    "\#include \"pdsp_defs.h\"\n"
+    "int main(){\n"
+    "SuperMatrix A;\n"
+    "NCformat *Astore;\n" 
+    "return(0);\n"
+    "}\n")
+
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${SUPERLUMT_TEST_DIR} ${SUPERLUMT_TEST_DIR} ltest OUTPUT_VARIABLE MY_OUTPUT)
+      
+  # To ensure we do not use stuff from the previous attempts, 
+  # we must remove the CMakeFiles directory.
+  file(REMOVE_RECURSE ${SUPERLUMT_TEST_DIR}/CMakeFiles)
+
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Checking if SUPERLUMT works... OK")
+    set(SUPERLUMT_FOUND TRUE)
+  else(LTEST_OK)
+    message(STATUS "Checking if SUPERLUMT works... FAILED")
+  endif(LTEST_OK)
+
+else()
+  PRINT_WARNING("SUPERLUMT LIBRARIES NOT Found. Please check library path" "${SUPERLUMT_LIBRARY_DIR}")
+  message(STATUS "Looking for SUPERLUMT libraries... FAILED")
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsTesting.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsTesting.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..815576a2916b5bed8a1729b15bf5c5e04a77b874
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsTesting.cmake
@@ -0,0 +1,55 @@
+# ---------------------------------------------------------------
+# Author: David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# Enable SUNDIALS Testing
+# ---------------------------------------------------------------
+
+# Enable testing with 'make test'
+INCLUDE(CTest)
+
+
+# If development tests are enabled, Python is needed to use the test runner
+IF(SUNDIALS_DEVTESTS)
+
+  find_package(PythonInterp)
+  IF(${PYTHON_VERSION_MAJOR} LESS 3)
+    IF(${PYTHON_VERSION_MINOR} LESS 7)
+      PRINT_WARNING("Python version must be 2.7.x or greater to run development tests"
+        "Examples will build but 'make test' will fail.")
+    ENDIF()
+  ENDIF()
+
+  # look for the testRunner script in the test directory
+  FIND_PROGRAM(TESTRUNNER testRunner PATHS test)
+  HIDE_VARIABLE(TESTRUNNER)
+
+ENDIF()
+
+
+# If examples are installed, create post install smoke tests
+IF(EXAMPLES_INSTALL)
+
+  # Directory for installation testing
+  SET(TEST_INSTALL_DIR ${PROJECT_BINARY_DIR}/Testing_Install)
+
+  # Create installation testing directory
+  IF(NOT EXISTS ${TEST_INSTALL_DIR})
+    FILE(MAKE_DIRECTORY ${TEST_INSTALL_DIR})
+  ENDIF()
+
+  # Create test_install target for installation smoke test
+  ADD_CUSTOM_TARGET(test_install
+    ${CMAKE_COMMAND} -E cmake_echo_color --cyan
+    "All installation tests complete.")
+
+ENDIF()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsTrilinos.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsTrilinos.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c452166ec002529d01fee1f45e0c05e06f782ad1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsTrilinos.cmake
@@ -0,0 +1,129 @@
+# -----------------------------------------------------------------------------
+# Programmer: Cody J. Balos and Slaven Peles @ LLNL
+# -----------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# -----------------------------------------------------------------------------
+# Trilinos configuration and tests for SUNDIALS CMake-based configuration.
+# 
+# This also creates the variables:
+#     Trilinos_INTERFACE_C_COMPILER
+#     Trilinos_INTERFACE_CXX_COMPILER
+#     Trilinos_INTERFACE_MPIEXEC
+# The variables should be used to set the compiler when building targets
+# that use Trilinos, and to set the MPIEXEC_EXECUTABLE for MPI+Trilinos
+# examples.
+#
+# Additionally the variables:
+#     Trilinos_INTERFACE_C_COMPILER_FLAGS
+#     Trilinos_INTERFACE_CXX_COMPILER_FLAGS
+# are created. The variables should be used to set the compiler flags
+# when building targets that use Trilinos.
+#
+# The variable
+#     Trilinos_FUNCTIONAL
+# is created and indicates if the Trilinos installation found was usable
+# under the current configuration of SUNDIALS.
+#-----------------------------------------------------------------------------
+
+set(Trilinos_FUNCTIONAL FALSE)
+
+# Find Trilinos
+include(FindTrilinos)
+
+# Test Trilinos
+if(Trilinos_FOUND AND TARGET Trilinos::Trilinos)
+
+  # For XSDK compatibility, only use the user/spack provided compiler and flags to build
+  # SUNDIALS modules that use Trilinos. If we are not in XSDK mode, we can use the imported
+  # Trilinos compiler and flags by default, but allow the user to change it through CMake
+  # the Trilinos_INTERFACE_* options.
+
+  if(USE_XSDK_DEFAULTS)
+    if(Trilinos_MPI AND MPI_CXX_FOUND)
+      SHOW_VARIABLE(Trilinos_INTERFACE_CXX_COMPILER     STRING "C++ compiler for Trilinos interface" "${MPI_CXX_COMPILER}")
+      set(Trilinos_INTERFACE_MPI_CXX_FOUND ${Trilinos_MPI} CACHE INTERNAL "Is Trilinos interface C++ compiler MPI")
+    else()
+      SHOW_VARIABLE(Trilinos_INTERFACE_CXX_COMPILER     STRING "C compiler for Trilinos interface" "${CMAKE_CXX_COMPILER}")
+      set(Trilinos_INTERFACE_MPI_CXX_FOUND FALSE CACHE INTERNAL "Is Trilinos interface C++ compiler MPI")
+    endif()
+    if(Trilinos_MPI AND MPI_C_FOUND)
+      SHOW_VARIABLE(Trilinos_INTERFACE_C_COMPILER       STRING "C compiler for Trilinos interface" "${MPI_C_COMPILER}")
+      set(Trilinos_INTERFACE_MPI_C_FOUND ${Trilinos_MPI} CACHE INTERNAL "Is Trilinos interface C compiler MPI")
+    else()
+      SHOW_VARIABLE(Trilinos_INTERFACE_C_COMPILER       STRING "C compiler for Trilinos interface" "${CMAKE_C_COMPILER}")
+      set(Trilinos_INTERFACE_MPI_C_FOUND FALSE CACHE INTERNAL "Is Trilinos interface C compiler MPI")
+    endif()
+    SHOW_VARIABLE(Trilinos_INTERFACE_CXX_COMPILER_FLAGS STRING "C++ compiler flags specific to Trilinos interface" "")
+    SHOW_VARIABLE(Trilinos_INTERFACE_C_COMPILER_FLAGS   STRING "C compiler flags specific to Trilinos interface" "")
+    SHOW_VARIABLE(Trilinos_INTERFACE_MPIEXEC            STRING "MPI executable for Trilinos interface" "${MPIEXEC_EXECUTABLE}")
+  else()
+    SHOW_VARIABLE(Trilinos_INTERFACE_CXX_COMPILER       STRING "C++ compiler for Trilinos interface" "${Trilinos_CXX_COMPILER}")
+    SHOW_VARIABLE(Trilinos_INTERFACE_C_COMPILER         STRING "C compiler for Trilinos interface" "${Trilinos_C_COMPILER}")
+    SHOW_VARIABLE(Trilinos_INTERFACE_CXX_COMPILER_FLAGS STRING "C++ compiler flags for Trilinos interface" "${Trilinos_CXX_COMPILER_FLAGS}")
+    SHOW_VARIABLE(Trilinos_INTERFACE_C_COMPILER_FLAGS   STRING "C compiler flags for Trilinos interface" "${Trilinos_C_COMPILER_FLAGS}")
+    SHOW_VARIABLE(Trilinos_INTERFACE_MPIEXEC            STRING "MPI executable for Trilinos interface" "${Trilinos_MPI_EXEC}")
+    set(Trilinos_INTERFACE_MPI_CXX_FOUND ${Trilinos_MPI} CACHE INTERNAL "Is Trilinos interface C++ compiler MPI")
+    set(Trilinos_INTERFACE_MPI_C_FOUND ${Trilinos_MPI} CACHE INTERNAL "Is Trilinos interface C compiler MPI")
+  endif()
+  mark_as_advanced(FORCE Trilinos_INTERFACE_CXX_COMPILER
+                         Trilinos_INTERFACE_C_COMPILER
+                         Trilinos_INTERFACE_CXX_COMPILER_FLAGS 
+                         Trilinos_INTERFACE_C_COMPILER_FLAGS
+                         Trilinos_INTERFACE_MPIEXEC)
+  
+  # Begin testing the Trilinos libraries with the compiler settings
+  # that will be used when building Trilinos modules.
+  message(STATUS "Testing Trilinos libraries...")
+
+  # Create the TrilinosTest directory
+  set(TrilinosTest_DIR ${PROJECT_BINARY_DIR}/TrilinosTest)
+  file(MAKE_DIRECTORY ${TrilinosTest_DIR})
+
+  # Create a CMakeLists.txt file
+  file(WRITE ${TrilinosTest_DIR}/CMakeLists.txt
+    "CMAKE_MINIMUM_REQUIRED(VERSION 3.1.3)\n"
+    "PROJECT(ltest CXX)\n"
+    "SET(Trilinos_DIR ${Trilinos_DIR})\n"
+    "INCLUDE(${CMAKE_SOURCE_DIR}/config/FindTrilinos.cmake)\n"
+    "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
+    "SET(CMAKE_C_COMPILER ${Trilinos_INTERFACE_C_COMPILER})\n"
+    "SET(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} ${Trilinos_INTERFACE_C_COMPILER_FLAGS}\")\n"
+    "SET(CMAKE_CXX_COMPILER ${Trilinos_INTERFACE_CXX_COMPILER})\n"
+    "SET(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${Trilinos_INTERFACE_CXX_COMPILER_FLAGS}\")\n"
+    "ADD_EXECUTABLE(ltest ltest)\n"
+    "TARGET_LINK_LIBRARIES(ltest Trilinos::Trilinos)\n")
+
+  # Create a C++ source file which calls a Trilinos function
+  file(WRITE ${TrilinosTest_DIR}/ltest.cpp
+    "#include <Tpetra_Version.hpp>\n"
+    "int main(){\n"
+    "std::cout << Tpetra::version() << std::endl;\n"
+    "return(0);\n"
+    "}\n")
+
+  # Attempt to link the "ltest" executable
+  try_compile(LTEST_OK ${TrilinosTest_DIR} ${TrilinosTest_DIR} ltest OUTPUT_VARIABLE MY_OUTPUT)
+
+  # To ensure we do not use stuff from the previous attempts,
+  # we must remove the CMakeFiles directory and the ltest binary.
+  file(REMOVE_RECURSE ${TrilinosTest_DIR}/CMakeFiles)
+  file(REMOVE_RECURSE ${TrilinosTest_DIR}/ltest)
+
+  # Process test result
+  if(LTEST_OK)
+    message(STATUS "Testing Trilinos libraries... OK")
+    set(Trilinos_FUNCTIONAL TRUE)
+  else(LTEST_OK)
+    message(STATUS "Testing Trilinos libraries... FAILED")
+  endif(LTEST_OK)
+  
+endif()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsXSDK.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsXSDK.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..01fc61b2ceec7b531ee07a16ddd80e0a7e6903ea
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/config/SundialsXSDK.cmake
@@ -0,0 +1,364 @@
+# ---------------------------------------------------------------
+# Programmer:  David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# xSDK specific CMake variables. If set, these variables will 
+# overwrite the value in equivalent SUNDIALS CMake variable.
+#
+# Only USE_XSDK_DEFAULTS is created in CACHE by default (set to 
+# OFF). The other xSDK variables are left undefined. They can be
+# be set by passing -D<variable_name>=<value> to cmake or can be 
+# enabled in the cmake-gui setting USE_XSDK_DEFAULTS to ON.
+#
+# When USE_XSDK_DEFAULTS is ON the default values are overwritten
+# by values passed to cmake or manually set in the cmake-gui.
+# ---------------------------------------------------------------
+
+# always show the option to turn on xSDK defaults
+OPTION(USE_XSDK_DEFAULTS "Enable default xSDK settings" OFF)
+
+# ---------------------------------------------------------------
+# Set default values for some xSDK variables
+# ---------------------------------------------------------------
+
+IF(USE_XSDK_DEFAULTS)
+
+  MESSAGE("Enabeling xSDK defaults")
+  
+  # set the CMake build type, SUNDIALS does not set a build type by default
+  IF(NOT CMAKE_BUILD_TYPE)
+    MESSAGE("Setting build type to Debug")
+    SET(DOCSTR "Choose the type of build: None Debug Release RelWithDebInfo MinSizeRel")
+    FORCE_VARIABLE(CMAKE_BUILD_TYPE STRING "${DOCSTR}" "Debug")
+  ENDIF()
+
+  # set build precision, SUNDIALS_PRECISION defaults to double
+  SHOW_VARIABLE(XSDK_PRECISION STRING "single, double, or quad" "double")
+
+  # set build index size, SUNDIALS_INDEX_SIZE defaults to int64_t
+  SHOW_VARIABLE(XSDK_INDEX_SIZE STRING "32 or 64" "32")
+
+  # disable Fortran-C interface, defaults to OFF
+  SHOW_VARIABLE(XSDK_ENABLE_FORTRAN BOOL "Enable Fortran-C support" OFF)
+
+  # disable CUDA by default
+  SHOW_VARIABLE(XSDK_ENABLE_CUDA BOOL "Enable CUDA support" OFF)
+
+  # disable BLAS by default
+  SHOW_VARIABLE(TPL_ENABLE_BLAS BOOL "Enable BLAS support" OFF)
+
+  # disable LAPACK by default
+  SHOW_VARIABLE(TPL_ENABLE_LAPACK BOOL "Enable LAPACK support" OFF)
+
+  # disable SuperLU_MT by default
+  SHOW_VARIABLE(TPL_ENABLE_SUPERLUMT BOOL "Enable SuperLU_MT support" OFF)
+
+  # disable KLU by default
+  SHOW_VARIABLE(TPL_ENABLE_KLU BOOL "Enable KLU support" OFF)
+
+  # disable PETSc by default
+  SHOW_VARIABLE(TPL_ENABLE_PETSC BOOL "Enable PETSc support" OFF)
+
+  # disable hypre by default
+  SHOW_VARIABLE(TPL_ENABLE_HYPRE BOOL "Enable hypre support" OFF)
+
+  # disable Trilinos by default
+  SHOW_VARIABLE(TPL_ENABLE_TRILINOS BOOL "Enable Trilinos support" OFF)
+
+  # disable RAJA by default
+  # SHOW_VARIABLE(TPL_ENABLE_RAJA BOOL "Enable RAJA support" OFF)
+
+ENDIF()
+
+# ---------------------------------------------------------------
+# hide (make advanced) and overwrite equivalent SUNDIALS variables
+# ---------------------------------------------------------------
+
+# ---------------------------------------------------------------
+# SUNDIALS precision, indextype, and Fortran interface
+# ---------------------------------------------------------------
+
+# XSDK_PRECISION => SUNDIALS_PRECISION
+IF(XSDK_PRECISION)
+  MESSAGE("Replacing SUNDIALS_PRECISION with XSDK_PRECISION")
+  SET(DOCSTR "single, double, or extended")
+
+  IF(XSDK_PRECISION MATCHES "quad")
+    FORCE_VARIABLE(SUNDIALS_PRECISION STRING "${DOCSTR}" "extended")
+  ELSE()
+    FORCE_VARIABLE(SUNDIALS_PRECISION STRING "${DOCSTR}" "${XSDK_PRECISION}")
+  ENDIF()
+
+  MARK_AS_ADVANCED(FORCE SUNDIALS_PRECISION)
+ENDIF()
+
+# XSDK_INDEX_SIZE => SUNDIALS_INDEX_SIZE
+IF(XSDK_INDEX_SIZE)
+  MESSAGE("Replacing SUNDIALS_INDEX_SIZE with XSDK_INDEX_SIZE")
+  SET(DOCSTR "Signed 64-bit (64) or signed 32-bit (32) integer")
+  FORCE_VARIABLE(SUNDIALS_INDEX_SIZE STRING "${DOCSTR}" ${XSDK_INDEX_SIZE})
+  MARK_AS_ADVANCED(FORCE SUNDIALS_INDEX_SIZE)
+ENDIF()
+
+# XSDK_FORTRAN_ENABLE => F77_INTERFACE_ENABLE/F2003_INTERFACE_ENABLE
+IF(DEFINED XSDK_ENABLE_FORTRAN)
+  MESSAGE("Replacing F77_INTERFACE_ENABLE and F2003_INTERFACE_ENABLE with XSDK_ENABLE_FORTRAN")
+  SET(DOCSTR "Enable Fortran-C support")
+  
+  # check that at least one solver with a Fortran interface is built
+  IF(NOT BUILD_ARKODE AND NOT BUILD_CVODE AND NOT BUILD_IDA AND NOT BUILD_KINSOL)
+    IF(XSDK_ENABLE_FORTRAN)
+      PRINT_WARNING("Enabled packages do not support Fortran" 
+                    "Disabeling XSDK_ENABLE_FORTRAN")
+      FORCE_VARIABLE(XSDK_ENABLE_FORTRAN BOOL "${DOCSTR}" OFF)
+    ENDIF()
+    HIDE_VARIABLE(F77_INTERFACE_ENABLE)
+    HIDE_VARIABLE(F2003_INTERFACE_ENABLE)
+    HIDE_VARIABLE(XSDK_ENABLE_FORTRAN)
+  ENDIF()
+
+  FORCE_VARIABLE(F77_INTERFACE_ENABLE BOOL "${DOCSTR}" "${XSDK_ENABLE_FORTRAN}")
+  MARK_AS_ADVANCED(FORCE F77_INTERFACE_ENABLE)
+  
+  FORCE_VARIABLE(F2003_INTERFACE_ENABLE BOOL "${DOCSTR}" "${XSDK_ENABLE_FORTRAN}")
+  MARK_AS_ADVANCED(FORCE F2003_INTERFACE_ENABLE)
+ENDIF()
+
+# XSDK_ENABLE_CUDA => CUDA_ENABLE
+IF(DEFINED XSDK_ENABLE_CUDA)
+  MESSAGE("Replacing CUDA_ENABLE with XSDK_ENABLE_CUDA")
+  SET(DOCSTR "Enable CUDA support")
+
+  FORCE_VARIABLE(CUDA_ENABLE BOOL "${DOCSTR}" "${XSDK_ENABLE_CUDA}")
+  MARK_AS_ADVANCED(FORCE CUDA_ENABLE)
+ENDIF()
+
+# ---------------------------------------------------------------
+# BLAS
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_BLAS => BLAS_ENABLE
+IF(DEFINED TPL_ENABLE_BLAS)
+  MESSAGE("Replacing BLAS_ENABLE with TPL_ENABLE_BLAS")
+  SET(DOCSTR "Enable Blas support")
+
+  FORCE_VARIABLE(BLAS_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_BLAS}")
+  MARK_AS_ADVANCED(FORCE BLAS_ENABLE)
+ENDIF()
+
+# TPL_BLAS_LIBRARIES => BLAS_LIBRARIES
+IF(TPL_ENABLE_BLAS)
+  MESSAGE("Replacing BLAS_LIBRARIES with TPL_BLAS_LIBRARIES")
+  SET(DOCSTR "Blas library")
+
+  SHOW_VARIABLE(TPL_BLAS_LIBRARIES STRING "${DOCSTR}" "${TPL_BLAS_LIBRARIES}")
+  FORCE_VARIABLE(BLAS_LIBRARIES STRING "${DOCSTR}" "${TPL_BLAS_LIBRARIES}")
+  MARK_AS_ADVANCED(FORCE BLAS_LIBRARIES)
+ENDIF()
+
+
+# ---------------------------------------------------------------
+# LAPACK
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_LAPACK => LAPACK_ENABLE
+IF(DEFINED TPL_ENABLE_LAPACK)
+  MESSAGE("Replacing LAPACK_ENABLE with TPL_ENABLE_LAPACK")
+  SET(DOCSTR "Enable Lapack support")
+
+  FORCE_VARIABLE(LAPACK_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_LAPACK}")
+  MARK_AS_ADVANCED(FORCE LAPACK_ENABLE)
+ENDIF()
+
+# TPL_LAPACK_LIBRARIES => LAPACK_LIBRARIES
+IF(TPL_ENABLE_LAPACK)
+  MESSAGE("Replacing LAPACK_LIBRARIES with TPL_LAPACK_LIBRARIES")
+  SET(DOCSTR "Lapack library")
+
+  SHOW_VARIABLE(TPL_LAPACK_LIBRARIES STRING "${DOCSTR}" "${TPL_LAPACK_LIBRARIES}")
+  FORCE_VARIABLE(LAPACK_LIBRARIES STRING "${DOCSTR}" "${TPL_LAPACK_LIBRARIES}")
+  MARK_AS_ADVANCED(FORCE LAPACK_LIBRARIES)
+ENDIF()
+
+
+# ---------------------------------------------------------------
+# SuperLU_MT
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_SUPERLUMT => SUPERLUMT_ENABLE
+IF(DEFINED TPL_ENABLE_SUPERLUMT)
+  MESSAGE("Replacing SUPERLUMT_ENABLE with TPL_ENABLE_SUPERLUMT")
+  SET(DOCSTR "Enable SuperLU_MT support")
+
+  FORCE_VARIABLE(SUPERLUMT_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_SUPERLUMT}")
+  MARK_AS_ADVANCED(FORCE SUPERLUMT_ENABLE)
+ENDIF()
+
+# TPL_SUPERLUMT_INCLUDE_DIRS => SUPERLUMT_INCLUDE_DIR
+# TPL_SUPERLUMT_LIBRARIES    => SUPERLUMT_LIBRARY     => SUPERLUMT_LIBRARIES
+IF(TPL_ENABLE_SUPERLUMT)
+  MESSAGE("Replacing SUPERLUMT_INCLUDE_DIR with TPL_SUPERLUMT_INCLUDE_DIRS")
+  SET(DOCSTR "SuperLU_MT include directory")
+
+  SHOW_VARIABLE(TPL_SUPERLUMT_INCLUDE_DIRS STRING "${DOCSTR}" "${TPL_SUPERLUMT_INCLUDE_DIRS}")
+  FORCE_VARIABLE(SUPERLUMT_INCLUDE_DIR STRING "${DOCSTR}" "${TPL_SUPERLUMT_INCLUDE_DIRS}")
+  MARK_AS_ADVANCED(FORCE SUPERLUMT_INCLUDE_DIR)
+
+  MESSAGE("Replacing SUPERLUMT_LIBRARY with TPL_SUPERLUMT_LIBRARIES")
+  SET(DOCSTR "SuperLU_MT library")
+
+  SHOW_VARIABLE(TPL_SUPERLUMT_LIBRARIES STRING "${DOCSTR}" "${TPL_SUPERLUMT_LIBRARIES}")
+  FORCE_VARIABLE(SUPERLUMT_LIBRARY STRING "${DOCSTR}" "${TPL_SUPERLUMT_LIBRARIES}")
+  MARK_AS_ADVANCED(FORCE SUPERLUMT_LIBRARY)
+  MARK_AS_ADVANCED(FORCE SUPERLUMT_LIBRARY_DIR)
+
+  MESSAGE("Replacing SUPERLUMT_THREAD_TYPE with TPL_SUPERLUMT_THREAD_TYPE")
+  SET(DOCSTR "SuperLU_MT thread type (OpenMP or Pthread)")
+  
+  SHOW_VARIABLE(TPL_SUPERLUMT_THREAD_TYPE STRING "${DOCSTR}" "PThread")
+  FORCE_VARIABLE(SUPERLUMT_THREAD_TYPE STRING "${DOCSTR}" "${TPL_SUPERLUMT_THREAD_TYPE}")
+  MARK_AS_ADVANCED(FORCE SUPERLUMT_THREAD_TYPE)
+ENDIF()
+
+
+# ---------------------------------------------------------------
+# KLU
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_KLU => KLU_ENABLE
+IF(DEFINED TPL_ENABLE_KLU)
+  MESSAGE("Replacing KLU_ENABLE with TPL_ENABLE_KLU")
+  SET(DOCSTR "Enable KLU support")
+
+  FORCE_VARIABLE(KLU_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_KLU}")
+  MARK_AS_ADVANCED(FORCE KLU_ENABLE)
+ENDIF()
+
+# TPL_KLU_INCLUDE_DIRS => KLU_INCLUDE_DIR
+# TPL_KLU_LIBRARIES    => KLU_LIBRARY     => KLU_LIBRARIES
+IF(TPL_ENABLE_KLU)
+  MESSAGE("Replacing KLU_INCLUDE_DIR with TPL_KLU_INCLUDE_DIRS")
+  SET(DOCSTR "KLU include directory")
+
+  SHOW_VARIABLE(TPL_KLU_INCLUDE_DIRS STRING "${DOCSTR}" "${TPL_KLU_INCLUDE_DIRS}")
+  FORCE_VARIABLE(KLU_INCLUDE_DIR STRING "${DOCSTR}" "${TPL_KLU_INCLUDE_DIRS}")
+  MARK_AS_ADVANCED(FORCE KLU_INCLUDE_DIR)
+
+  MESSAGE("Replacing KLU_LIBRARY with TPL_KLU_LIBRARIES")
+  SET(DOCSTR "KLU library")
+
+  SHOW_VARIABLE(TPL_KLU_LIBRARIES STRING "${DOCSTR}" "${TPL_KLU_LIBRARIES}")
+  FORCE_VARIABLE(KLU_LIBRARY STRING "${DOCSTR}" "${TPL_KLU_LIBRARIES}")
+  MARK_AS_ADVANCED(FORCE KLU_LIBRARY)
+  MARK_AS_ADVANCED(FORCE KLU_LIBRARY_DIR)
+ENDIF()
+
+
+# ---------------------------------------------------------------
+# HYPRE
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_HYPRE => HYPRE_ENABLE
+IF(DEFINED TPL_ENABLE_HYPRE)
+  MESSAGE("Replacing HYPRE_ENABLE with TPL_ENABLE_HYPRE")
+  SET(DOCSTR "Enable hypre support")
+
+  FORCE_VARIABLE(HYPRE_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_HYPRE}")
+  MARK_AS_ADVANCED(FORCE HYPRE_ENABLE)
+ENDIF()
+
+# TPL_HYPRE_INCLUDE_DIRS => HYPRE_INCLUDE_DIR
+# TPL_HYPRE_LIBRARIES    => HYPRE_LIBRARY     => HYPRE_LIBRARIES
+IF(TPL_ENABLE_HYPRE)
+  MESSAGE("Replacing HYPRE_INCLUDE_DIR with TPL_HYPRE_INCLUDE_DIRS")
+  SET(DOCSTR "hypre include directory")
+
+  SHOW_VARIABLE(TPL_HYPRE_INCLUDE_DIRS STRING "${DOCSTR}" "${TPL_HYPRE_INCLUDE_DIRS}")
+  FORCE_VARIABLE(HYPRE_INCLUDE_DIR STRING "${DOCSTR}" "${TPL_HYPRE_INCLUDE_DIRS}")
+  MARK_AS_ADVANCED(FORCE HYPRE_INCLUDE_DIR)
+
+  MESSAGE("Replacing HYPRE_LIBRARY with TPL_HYPRE_LIBRARIES")
+  SET(DOCSTR "hypre library")
+
+  SHOW_VARIABLE(TPL_HYPRE_LIBRARIES STRING "${DOCSTR}" "${TPL_HYPRE_LIBRARIES}")
+  FORCE_VARIABLE(HYPRE_LIBRARY STRING "${DOCSTR}" "${TPL_HYPRE_LIBRARIES}")
+  MARK_AS_ADVANCED(FORCE HYPRE_LIBRARY)
+  MARK_AS_ADVANCED(FORCE HYPRE_LIBRARY_DIR)
+ENDIF()
+
+
+# ---------------------------------------------------------------
+# PETSC
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_PETSC => PETSC_ENABLE
+IF(DEFINED TPL_ENABLE_PETSC)
+  MESSAGE("Replacing PETSC_ENABLE with TPL_ENABLE_PETSC")
+  SET(DOCSTR "Enable petsc support")
+
+  FORCE_VARIABLE(PETSC_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_PETSC}")
+  MARK_AS_ADVANCED(FORCE PETSC_ENABLE)
+ENDIF()
+
+# TPL_PETSC_INCLUDE_DIRS => PETSC_INCLUDE_DIR
+# TPL_PETSC_LIBRARIES    => PETSC_LIBRARY     => PETSC_LIBRARIES
+IF(TPL_ENABLE_PETSC)
+  MESSAGE("Replacing PETSC_INCLUDE_DIR with TPL_PETSC_INCLUDE_DIRS")
+  SET(DOCSTR "PETSc include directory")
+
+  SHOW_VARIABLE(TPL_PETSC_INCLUDE_DIRS STRING "${DOCSTR}" "${TPL_PETSC_INCLUDE_DIRS}")
+  FORCE_VARIABLE(PETSC_INCLUDE_DIR STRING "${DOCSTR}" "${TPL_PETSC_INCLUDE_DIRS}")
+  MARK_AS_ADVANCED(FORCE PETSC_INCLUDE_DIR)
+
+  MESSAGE("Replacing PETSC_LIBRARY with TPL_PETSC_LIBRARIES")
+  SET(DOCSTR "PETSc library")
+
+  SHOW_VARIABLE(TPL_PETSC_LIBRARIES STRING "${DOCSTR}" "${TPL_PETSC_LIBRARIES}")
+  FORCE_VARIABLE(PETSC_LIBRARY STRING "${DOCSTR}" "${TPL_PETSC_LIBRARIES}")
+  MARK_AS_ADVANCED(FORCE PETSC_LIBRARY)
+  MARK_AS_ADVANCED(FORCE PETSC_LIBRARY_DIR)
+ENDIF()
+
+# ---------------------------------------------------------------
+# Trilinos
+# ---------------------------------------------------------------
+
+# TPL_ENABLE_TRILINOS => Trilinos_ENABLE
+IF(DEFINED TPL_ENABLE_TRILINOS)
+  MESSAGE("Replacing Trilinos_ENABLE with TPL_ENABLE_TRILINOS")
+  SET(DOCSTR "Enable Trilinos support")
+
+  FORCE_VARIABLE(Trilinos_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_TRILINOS}")
+  MARK_AS_ADVANCED(FORCE Trilinos_ENABLE)
+ENDIF()
+
+# RAJA
+# ---------------------------------------------------------------
+
+# # TPL_ENABLE_RAJA => RAJA_ENABLE
+# IF(DEFINED TPL_ENABLE_RAJA)
+#   MESSAGE("Replacing RAJA_ENABLE with TPL_ENABLE_RAJA")
+#   SET(DOCSTR "Enable RAJA support")
+
+#   FORCE_VARIABLE(RAJA_ENABLE BOOL "${DOCSTR}" "${TPL_ENABLE_RAJA}")
+#   MARK_AS_ADVANCED(FORCE RAJA_ENABLE)
+# ENDIF()
+
+# # TPL_RAJA_DIR => RAJA_DIR
+# IF(TPL_ENABLE_RAJA)
+#   MESSAGE("Replacing RAJA_DIR with TPL_RAJA_DIR")
+#   SET(DOCSTR "RAJA include directory")
+
+#   SHOW_VARIABLE(TPL_RAJA_DIR STRING "${DOCSTR}" "${TPL_RAJA_DIR}")
+#   FORCE_VARIABLE(RAJA_DIR STRING "${DOCSTR}" "${TPL_RAJA_DIR}")
+#   MARK_AS_ADVANCED(FORCE RAJA_DIR)
+# ENDIF()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/ThreadPartitioning.hpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/ThreadPartitioning.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..10a8c72fd345c6ba9152ba716a589e0a46f71ff9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/ThreadPartitioning.hpp
@@ -0,0 +1,351 @@
+/*
+ * -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ */
+
+
+
+#ifndef _THREAD_PARTITIONING_HPP_
+#define _THREAD_PARTITIONING_HPP_
+
+#include <iostream>
+#include <cuda_runtime.h>
+
+namespace suncudavec
+{
+
+template<class T, class I>
+class ThreadPartitioning
+{
+public:
+  ThreadPartitioning()
+  : block_(1),
+    grid_(1),
+    shMemSize_(0),
+    stream_(0),
+    bufferSize_(0),
+    d_buffer_(nullptr),
+    h_buffer_(nullptr)
+  {}
+
+  ThreadPartitioning(unsigned block)
+  : block_(block),
+    grid_(1),
+    shMemSize_(0),
+    stream_(0),
+    bufferSize_(0),
+    d_buffer_(nullptr),
+    h_buffer_(nullptr)
+  {}
+
+  explicit ThreadPartitioning(ThreadPartitioning<T, I>& p)
+  : block_(p.block_),
+    grid_(p.grid_),
+    shMemSize_(p.shMemSize_),
+    stream_(p.stream_)
+  {}
+
+  virtual ~ThreadPartitioning(){}
+
+  unsigned grid() const
+  {
+    return grid_;
+  }
+
+  unsigned block() const
+  {
+    return block_;
+  }
+
+  unsigned shmem() const
+  {
+    return shMemSize_;
+  }
+
+  cudaStream_t stream() const
+  {
+    return stream_;
+  }
+
+  unsigned int buffSize()
+  {
+    return bufferSize_;
+  }
+
+  T* devBuffer()
+  {
+    return d_buffer_;
+  }
+
+  const T* devBuffer() const
+  {
+    return d_buffer_;
+  }
+
+  T* hostBuffer()
+  {
+    return h_buffer_;
+  }
+
+  const T* hostBuffer() const
+  {
+    return h_buffer_;
+  }
+
+  void setStream(const cudaStream_t& stream)
+  {
+    stream_ = stream;
+  }
+
+  virtual void copyFromDevBuffer(unsigned int n) const
+  {
+    std::cerr << "Trying to copy buffer from base class!\n";
+  }
+
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, unsigned& shMemSize,
+                              cudaStream_t& stream)
+  {
+    block = 1;
+    grid  = 1;
+    shMemSize = 0;
+    stream = 0;
+    std::cerr << "Trying to set partitioning from base class!\n";
+
+    return 0;
+  }
+
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, unsigned& shMemSize)
+  {
+    block = 1;
+    grid  = 1;
+    shMemSize = 0;
+    std::cerr << "Trying to set partitioning from base class!\n";
+
+    return 0;
+  }
+  
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, cudaStream_t& stream)
+  {
+    block = 1;
+    grid  = 1;
+    stream = 0;
+    std::cerr << "Trying to set partitioning from base class!\n";
+
+    return 0;
+  }
+  
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block)
+  {
+    block = 1;
+    grid  = 1;
+    std::cerr << "Trying to set partitioning from base class!\n";
+
+    return 0;
+  }
+
+
+protected:
+  unsigned block_;
+  unsigned grid_;
+  unsigned shMemSize_;
+  unsigned bufferSize_;
+  cudaStream_t stream_;
+  T* d_buffer_;
+  T* h_buffer_;
+
+}; // class ThreadPartitioning
+
+
+
+template<class T, class I>
+class StreamPartitioning : public ThreadPartitioning<T, I>
+{
+  using ThreadPartitioning<T, I>::block_;
+  using ThreadPartitioning<T, I>::grid_;
+  using ThreadPartitioning<T, I>::stream_;
+
+public:
+  StreamPartitioning(I N, unsigned block, cudaStream_t stream)
+  : ThreadPartitioning<T, I>(block)
+  {
+    grid_ = (N + block_ - 1) / block_;
+    stream_ = stream;
+  }
+  
+  StreamPartitioning(I N, unsigned block)
+  : ThreadPartitioning<T, I>(block)
+  {
+    grid_ = (N + block_ - 1) / block_;
+  }
+
+  explicit StreamPartitioning(StreamPartitioning<T, I>& p)
+  : ThreadPartitioning<T, I>(p)
+  {
+  }
+
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, unsigned& shMemSize,
+                              cudaStream_t& stream)
+  {
+    block = block_;
+    grid  = (N + block_ - 1) / block_;
+    shMemSize = 0;
+    stream = stream_;
+
+    return 0;
+  }
+  
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, unsigned& shMemSize)
+  {
+    block = block_;
+    grid  = (N + block_ - 1) / block_;
+    shMemSize = 0;
+
+    return 0;
+  }
+
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, cudaStream_t& stream)
+  {
+    block = block_;
+    grid  = (N + block_ - 1) / block_;
+    stream = stream_;
+
+    return 0;
+  }
+  
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block)
+  {
+    block = block_;
+    grid  = (N + block_ - 1) / block_;
+
+    return 0;
+  }
+
+}; // class StreamPartitioning
+
+
+template<class T, class I=int>
+class ReducePartitioning : public ThreadPartitioning<T, I>
+{
+  using ThreadPartitioning<T, I>::block_;
+  using ThreadPartitioning<T, I>::grid_;
+  using ThreadPartitioning<T, I>::shMemSize_;
+  using ThreadPartitioning<T, I>::stream_;
+  using ThreadPartitioning<T, I>::bufferSize_;
+  using ThreadPartitioning<T, I>::d_buffer_;
+  using ThreadPartitioning<T, I>::h_buffer_;
+
+public:
+  ReducePartitioning(I N, unsigned block, cudaStream_t stream)
+  : ThreadPartitioning<T, I>(block)
+  {
+    grid_ = (N + (block_ * 2 - 1)) / (block_ * 2);
+    shMemSize_ = block_*sizeof(T);
+    stream_ = stream;
+    allocateBuffer();
+  }
+  
+  ReducePartitioning(I N, unsigned block)
+  : ThreadPartitioning<T, I>(block)
+  {
+    grid_ = (N + (block_ * 2 - 1)) / (block_ * 2);
+    shMemSize_ = block_*sizeof(T);
+    allocateBuffer();
+  }
+
+  explicit ReducePartitioning(ReducePartitioning<T, I>& p)
+  : ThreadPartitioning<T, I>(p)
+  {
+    shMemSize_ = p.shMemSize_;
+    allocateBuffer();
+  }
+
+  ~ReducePartitioning()
+  {
+    cudaError_t err;
+    if (bufferSize_ > 0)
+      free(h_buffer_);
+    if (bufferSize_ > 0)
+    {
+      err = cudaFree(d_buffer_);
+      if(err != cudaSuccess)
+        std::cerr << "Failed to free device vector (error code " << err << ")!\n";
+    }
+  }
+
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, unsigned& shMemSize,
+                              cudaStream_t& stream)
+  {
+    block = block_;
+    grid  = (N + (block_ * 2 - 1)) / (block_ * 2);
+    shMemSize = block_ * sizeof(T);
+    stream = stream_;
+
+    return 0;
+  }
+  
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, unsigned& shMemSize)
+  {
+    block = block_;
+    grid  = (N + (block_ * 2 - 1)) / (block_ * 2);
+    shMemSize = block_ * sizeof(T);
+
+    return 0;
+  }
+
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block, cudaStream_t& stream)
+  {
+    block = block_;
+    grid  = (N + (block_ * 2 - 1)) / (block_ * 2);
+    stream = stream_;
+
+    return 0;
+  }
+  
+  virtual int setPartitioning(I N, unsigned& grid, unsigned& block)
+  {
+    block = block_;
+    grid  = (N + (block_ * 2 - 1)) / (block_ * 2);
+
+    return 0;
+  }
+
+  virtual void copyFromDevBuffer(unsigned int n) const
+  {
+    cudaError_t err = cudaMemcpy(h_buffer_, d_buffer_, n*sizeof(T), cudaMemcpyDeviceToHost);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to copy vector from device to host (error code " << err << ")!\n";
+  }
+
+private:
+  int allocateBuffer()
+  {
+    bufferSize_ = grid_ * sizeof(T);
+    h_buffer_ = static_cast<T*>(malloc(bufferSize_));
+    if(h_buffer_ == NULL)
+      std::cerr << "Failed to allocate host vector!\n";
+
+    cudaError_t err;
+    err = cudaMalloc((void**) &d_buffer_, bufferSize_);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to allocate device vector (error code " << err << ")!\n";
+
+    return 0;
+  }
+
+}; // class ReducePartitioning
+
+
+} // namespace suncudavec
+
+#endif // _THREAD_PARTITIONING_HPP_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/Vector.hpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/Vector.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e46973ea630ccf1f1e28e22b68b7b6e6df41b222
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/Vector.hpp
@@ -0,0 +1,289 @@
+/*
+ * -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles, and Cody J. Balos @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ */
+
+
+/*
+ * Vector class
+ *
+ * Manages vector data layout for CUDA implementation of N_Vector.
+ *
+ */
+
+#ifndef _NVECTOR_CUDA_HPP_
+#define _NVECTOR_CUDA_HPP_
+
+#include <cstdlib>
+#include <iostream>
+
+#include <cuda_runtime.h>
+#include "ThreadPartitioning.hpp"
+
+#include <sundials/sundials_config.h>
+#include <sundials/sundials_mpi.h>
+
+#if SUNDIALS_MPI_ENABLED
+#include <nvector/nvector_mpicuda.h>
+#else
+#include <nvector/nvector_cuda.h>
+#endif
+
+namespace suncudavec
+{
+
+template <typename T, typename I>
+class Vector : public _N_VectorContent_Cuda
+{
+public:
+  Vector(I N, bool use_managed_memory = false, bool allocate_data = true, T* const h_vec = nullptr, T* const d_vec = nullptr)
+  : size_(N),
+    mem_size_(N*sizeof(T)),
+    global_size_(N),
+    ownPartitioning_(true),
+    ownData_(allocate_data),
+    managed_mem_(use_managed_memory),
+    h_vec_(h_vec),
+    d_vec_(d_vec),
+    comm_(0)
+  {
+    // Set partitioning
+    partStream_ = new StreamPartitioning<T, I>(N, 256);
+    partReduce_ = new ReducePartitioning<T, I>(N, 256);
+
+    // Allocate data arrays
+    if (allocate_data)
+      allocate();
+  }
+
+  Vector(I N, cudaStream_t stream,
+         bool use_managed_memory = false, bool allocate_data = true, T* const h_vec = nullptr, T* const d_vec = nullptr)
+  : size_(N),
+    mem_size_(N*sizeof(T)),
+    global_size_(N),
+    ownPartitioning_(true),
+    ownData_(allocate_data),
+    managed_mem_(use_managed_memory),
+    h_vec_(h_vec),
+    d_vec_(d_vec),
+    comm_(0)
+  {
+    // Set partitioning
+    partStream_ = new StreamPartitioning<T, I>(N, 256, stream);
+    partReduce_ = new ReducePartitioning<T, I>(N, 256, stream);
+
+    // Allocate data arrays
+    if (allocate_data)
+      allocate();
+  }
+  
+  Vector(SUNMPI_Comm comm, I N, I Nglobal,
+         bool use_managed_memory = false, bool allocate_data = true, T* const h_vec = nullptr, T* const d_vec = nullptr)
+  : size_(N),
+    mem_size_(N*sizeof(T)),
+    global_size_(Nglobal),
+    ownPartitioning_(true),
+    ownData_(allocate_data),
+    managed_mem_(use_managed_memory),
+    h_vec_(h_vec),
+    d_vec_(d_vec),
+    comm_(comm)
+  {
+    // Set partitioning
+    partStream_ = new StreamPartitioning<T, I>(N, 256);
+    partReduce_ = new ReducePartitioning<T, I>(N, 256);
+
+    // Allocate data arrays
+    if (allocate_data)
+      allocate();
+  }
+
+  Vector(SUNMPI_Comm comm, I N, I Nglobal, cudaStream_t stream,
+         bool use_managed_memory = false, bool allocate_data = true, T* const h_vec = nullptr, T* const d_vec = nullptr) 
+  : size_(N),
+    mem_size_(N*sizeof(T)),
+    global_size_(Nglobal),
+    ownPartitioning_(true),
+    ownData_(allocate_data),
+    managed_mem_(use_managed_memory),
+    h_vec_(h_vec),
+    d_vec_(d_vec),
+    comm_(comm)
+  {
+    // Set partitioning
+    partStream_ = new StreamPartitioning<T, I>(N, 256, stream);
+    partReduce_ = new ReducePartitioning<T, I>(N, 256, stream);
+
+    // Allocate data arrays
+    if (allocate_data)
+      allocate();
+  }
+  
+  // Copy constructor does not copy data array values
+  explicit Vector(const Vector& v)
+  : size_(v.size()),
+    mem_size_(size_*sizeof(T)),
+    global_size_(v.global_size_),
+    partStream_(v.partStream_),
+    partReduce_(v.partReduce_),
+    ownPartitioning_(false),
+    ownData_(true),
+    managed_mem_(v.managed_mem_),
+    h_vec_(nullptr),
+    d_vec_(nullptr),
+    comm_(v.comm_)
+  {
+    allocate();
+  }
+
+  ~Vector()
+  {
+    cudaError_t err;
+    
+    if (ownPartitioning_) {
+      delete partReduce_;
+      delete partStream_;
+    }
+    
+    if (ownData_) {
+      if (!managed_mem_)
+        free(h_vec_);
+      
+      err = cudaFree(d_vec_);
+      if(err != cudaSuccess)
+        std::cerr << "Failed to free device vector (error code " << err << ")!\n";
+    
+      d_vec_ = nullptr;
+      h_vec_ = nullptr;
+    }
+  }
+
+  void allocate()
+  {
+    if (managed_mem_) {
+      allocateManaged();
+    } else {
+      allocateUnmanaged();
+    }
+  }
+
+  void allocateManaged()
+  {
+    cudaError_t err;
+    err = cudaMallocManaged((void**) &d_vec_, mem_size_);
+    if (err != cudaSuccess)
+      std::cerr << "Failed to allocate managed vector (error code " << err << ")!\n";
+    h_vec_ = d_vec_;
+  }
+
+  void allocateUnmanaged()
+  {
+    cudaError_t err;
+    
+    h_vec_ = static_cast<T*>(malloc(mem_size_));
+    if(h_vec_ == nullptr)
+      std::cerr << "Failed to allocate host vector!\n";
+    
+    err = cudaMalloc((void**) &d_vec_, mem_size_);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to allocate device vector (error code " << err << ")!\n";
+  }
+  
+  int size() const
+  {
+    return size_;
+  }
+
+  int sizeGlobal() const
+  {
+    return global_size_;
+  }
+
+  SUNMPI_Comm comm() const
+  {
+    return comm_;
+  }
+
+  T* host()
+  {
+    return h_vec_;
+  }
+
+  const T* host() const
+  {
+    return h_vec_;
+  }
+
+  T* device()
+  {
+    return d_vec_;
+  }
+
+  const T* device() const
+  {
+    return d_vec_;
+  }
+
+  bool isManaged() const
+  {
+    return managed_mem_;
+  }
+
+  void copyToDev()
+  {
+    cudaError_t err = cudaMemcpy(d_vec_, h_vec_, mem_size_, cudaMemcpyHostToDevice);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to copy vector from host to device (error code " << err << ")!\n";
+  }
+
+  void copyFromDev()
+  {
+    cudaError_t err = cudaMemcpy(h_vec_, d_vec_, mem_size_, cudaMemcpyDeviceToHost);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to copy vector from device to host (error code " << err << ")!\n";
+  }
+
+  ThreadPartitioning<T, I>& partStream() const
+  {
+    return *partStream_;
+  }
+
+  ThreadPartitioning<T, I>& partReduce() const
+  {
+    return *partReduce_;
+  }
+
+
+private:
+  I size_;
+  I mem_size_;
+  I global_size_;
+  T* h_vec_;
+  T* d_vec_;
+  ThreadPartitioning<T, I>* partStream_;
+  ThreadPartitioning<T, I>* partReduce_;
+  bool ownPartitioning_;
+  bool ownData_;
+  bool managed_mem_;
+  SUNMPI_Comm comm_;
+  
+};
+
+
+} // namespace suncudavec
+
+
+
+
+#endif // _NVECTOR_CUDA_HPP_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/VectorArrayKernels.cuh b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/VectorArrayKernels.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..8311cd86319bfc60bc2281b70cc5e8f7092c06d9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/VectorArrayKernels.cuh
@@ -0,0 +1,1069 @@
+/*
+ * -----------------------------------------------------------------
+ * Programmer(s): David Gardner @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ */
+
+
+#ifndef _VECTOR_ARRAY_KERNELS_CUH_
+#define _VECTOR_ARRAY_KERNELS_CUH_
+
+#include <limits>
+#include <cuda_runtime.h>
+
+
+namespace suncudavec
+{
+
+
+/* -----------------------------------------------------------------
+ * The namespace for CUDA kernels
+ *
+ * Reduction CUDA kernels in nvector are based in part on "reduction"
+ * example in NVIDIA Corporation CUDA Samples, and parallel reduction
+ * examples in textbook by J. Cheng at al. "CUDA C Programming".
+ * -----------------------------------------------------------------
+ */
+namespace math_kernels
+{
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * fused vector operation kernels
+ * -----------------------------------------------------------------------------
+ */
+
+/*
+ * Computes the linear combination of nv vectors
+ */
+template <typename T, typename I>
+__global__ void
+linearCombinationKernel(int nv, T* c, T** xd, T* zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n) {
+    zd[i] = c[0]*xd[0][i];
+    for (int j=1; j<nv; j++)
+      zd[i] += c[j]*xd[j][i];
+  }
+}
+
+/*
+ * Computes the scaled sum of one vector with nv other vectors
+ */
+template <typename T, typename I>
+__global__ void
+scaleAddMultiKernel(int nv, T* c, T* xd, T** yd, T** zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+    for (int j=0; j<nv; j++)
+      zd[j][i] = c[j] * xd[i] + yd[j][i];
+}
+
+
+/*
+ * Dot product of one vector with nv other vectors.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+dotProdMultiKernel(int nv, T* xd, T** yd, T* out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  // Initialize shared memory to zero
+  for (int k=0; k<nv; k++)
+    shmem[tid + k*blockDim.x] = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] = xd[i] * yd[k][i];
+  if (i + blockDim.x < n)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] += (xd[i + blockDim.x] * yd[k][i + blockDim.x]);
+
+  __syncthreads();
+
+  // Perform blockwise reduction in shared memory
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j)
+      for (int k=0; k<nv; k++)
+        shmem[tid + k*blockDim.x] += shmem[tid + j + k*blockDim.x];
+
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    for (int k=0; k<nv; k++)
+      out[blockIdx.x + k*gridDim.x] = shmem[k*blockDim.x];
+}
+
+
+/*
+ * Sums all elements of the vector.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+sumReduceVectorKernel(int nv, T* x, T* out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] = x[i];
+  if (i + blockDim.x < n)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] += x[i+blockDim.x];
+
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j)
+      for (int k=0; k<nv; k++)
+        shmem[tid + k*blockDim.x] += shmem[tid + j + k*blockDim.x];
+
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    for (int k=0; k<nv; k++)
+      out[blockIdx.x + k*gridDim.x] = shmem[k*blockDim.x];
+}
+
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * vector array operation kernels
+ * -----------------------------------------------------------------------------
+ */
+
+/*
+ * Computes the linear sum of multiple vectors
+ */
+template <typename T, typename I>
+__global__ void
+linearSumVectorArrayKernel(int nv, T a, T** xd, T b, T** yd, T** zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+    for (int j=0; j<nv; j++)
+      zd[j][i] = a * xd[j][i] + b * yd[j][i];
+}
+
+
+/*
+ * Scales multiple vectors
+ */
+template <typename T, typename I>
+__global__ void
+scaleVectorArrayKernel(int nv, T* c, T** xd, T** zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+    for (int j=0; j<nv; j++)
+      zd[j][i] = c[j] * xd[j][i];
+}
+
+
+/*
+ * Sets multiple vectors equal to a constant
+ */
+template <typename T, typename I>
+__global__ void
+constVectorArrayKernel(int nv, T c, T** zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+    for (int j=0; j<nv; j++)
+      zd[j][i] = c;
+}
+
+
+/*
+ * WRMS norm of nv vectors.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+wL2NormSquareVectorArrayKernel(int nv, T** xd, T** wd, T* out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  // Initialize shared memory to zero
+  for (int k=0; k<nv; k++)
+    shmem[tid + k*blockDim.x] = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] = xd[k][i] * wd[k][i] * xd[k][i] * wd[k][i];
+  if (i + blockDim.x < n)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] += (xd[k][i + blockDim.x] * wd[k][i + blockDim.x]
+                                    * xd[k][i + blockDim.x] * wd[k][i + blockDim.x]);
+
+  __syncthreads();
+
+  // Perform blockwise reduction in shared memory
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j)
+      for (int k=0; k<nv; k++)
+        shmem[tid + k*blockDim.x] += shmem[tid + j + k*blockDim.x];
+
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    for (int k=0; k<nv; k++)
+      out[blockIdx.x + k*gridDim.x] = shmem[k*blockDim.x];
+}
+
+
+/*
+ * Masked WRMS norm of nv vectors.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+wL2NormSquareMaskVectorArrayKernel(int nv, T** xd, T** wd, T* id, T* out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  // Initialize shared memory to zero
+  for (int k=0; k<nv; k++)
+    shmem[tid + k*blockDim.x] = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n && id[i] > 0.0)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] = xd[k][i] * wd[k][i] * xd[k][i] * wd[k][i];
+  if (i + blockDim.x < n && id[i + blockDim.x] > 0.0)
+    for (int k=0; k<nv; k++)
+      shmem[tid + k*blockDim.x] += (xd[k][i + blockDim.x] * wd[k][i + blockDim.x]
+                                    * xd[k][i + blockDim.x] * wd[k][i + blockDim.x]);
+
+  __syncthreads();
+
+  // Perform blockwise reduction in shared memory
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j)
+      for (int k=0; k<nv; k++)
+        shmem[tid + k*blockDim.x] += shmem[tid + j + k*blockDim.x];
+
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    for (int k=0; k<nv; k++)
+      out[blockIdx.x + k*gridDim.x] = shmem[k*blockDim.x];
+}
+
+
+/*
+ * Computes the scaled sum of a vector array with multiple other vector arrays
+ */
+template <typename T, typename I>
+__global__ void
+scaleAddMultiVectorArrayKernel(int nv, int ns, T* c, T** xd, T** yd, T** zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+    for (int k=0; k<nv; k++)
+      for (int j=0; j<ns; j++)
+        zd[k*ns+j][i] = c[j] * xd[k][i] + yd[k*ns+j][i];
+}
+
+
+/*
+ * Computes the scaled sum of a vector array with multiple other vector arrays
+ */
+template <typename T, typename I>
+__global__ void
+linearCombinationVectorArrayKernel(int nv, int ns, T* c, T** xd, T** zd, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n) {
+    for (int k=0; k<nv; k++) {
+      zd[k][i] = c[0]*xd[k*ns][i];
+      for (int j=1; j<ns; j++) {
+        zd[k][i] += c[j]*xd[k*ns+j][i];
+      }
+    }
+  }
+}
+
+} // namespace math_kernels
+
+
+
+
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * fused vector operations
+ * -----------------------------------------------------------------------------
+ */
+
+template <typename T, typename I>
+inline cudaError_t linearCombination(int nvec, T* c, Vector<T,I>** X, Vector<T,I>* Z)
+{
+  cudaError_t err;
+
+  // Copy c array to device
+  T* d_c;
+  err = cudaMalloc((void**) &d_c, nvec*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nvec*sizeof(T), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::linearCombinationKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      d_c,
+      d_Xd,
+      Z->device(),
+      Z->size()
+  );
+
+  // Free host array
+  delete[] h_Xd;
+
+  // Free device arrays
+  err = cudaFree(d_c);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t scaleAddMulti(int nvec, T* c, Vector<T,I>* X,
+                                 Vector<T,I>** Y, Vector<T,I>** Z)
+{
+  cudaError_t err;
+
+  // Copy c array to device
+  T* d_c;
+  err = cudaMalloc((void**) &d_c, nvec*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nvec*sizeof(T), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  T** h_Yd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Yd[i] = Y[i]->device();
+
+  T** h_Zd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Zd[i] = Z[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = Z[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::scaleAddMultiKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      d_c,
+      X->device(),
+      d_Yd,
+      d_Zd,
+      X->size()
+  );
+
+  // Free host array
+  delete[] h_Yd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_c);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t dotProdMulti(int nvec, Vector<T,I>* x, Vector<T,I>** Y,
+                                T* dots)
+{
+  cudaError_t err;
+
+  // Create array of device pointers on host
+  T** h_Yd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Yd[i] = Y[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x->partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = nvec*block*sizeof(T);
+  const cudaStream_t stream   = p.stream();
+
+  // Allocate reduction buffer on device
+  T* d_buff;
+  err = cudaMalloc((void**) &d_buff, nvec*grid*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  math_kernels::dotProdMultiKernel<T,I><<<grid, block, shMemSize, stream>>>(
+      nvec,
+      x->device(),
+      d_Yd,
+      d_buff,
+      x->size()
+  );
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax) {
+
+    // Recompute partitioning
+    grid = (n + block - 1)/block;
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceVectorKernel<T,I><<<grid, block, shMemSize, stream>>>(
+        nvec,
+        d_buff,
+        d_buff,
+        n
+    );
+
+    // update buffer array working length
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  T* h_buff = new T[nvec*n*sizeof(T)];
+  err = cudaMemcpy(h_buff, d_buff, nvec*n*sizeof(T), cudaMemcpyDeviceToHost);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  for (int k=0; k<nvec; k++) {
+    dots[k] = h_buff[k*n];
+    for (int i=1; i<n; i++){
+      dots[k] += h_buff[i + k*n];
+    }
+  }
+
+  // Free host array
+  delete[] h_Yd;
+  delete[] h_buff;
+
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_buff);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * vector array operations
+ * -----------------------------------------------------------------------------
+ */
+
+template <typename T, typename I>
+inline cudaError_t linearSumVectorArray(int nvec, T a, Vector<T,I>** X, T b,
+                                        Vector<T,I>** Y, Vector<T,I>** Z)
+{
+  cudaError_t err;
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  T** h_Yd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Yd[i] = Y[i]->device();
+
+  T** h_Zd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Zd[i] = Z[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = Z[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::linearSumVectorArrayKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      a,
+      d_Xd,
+      b,
+      d_Yd,
+      d_Zd,
+      Z[0]->size()
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Yd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t scaleVectorArray(int nvec, T* c, Vector<T,I>** X,
+                                    Vector<T,I>** Z)
+{
+  cudaError_t err;
+
+  // Copy c array to device
+  T* d_c;
+  err = cudaMalloc((void**) &d_c, nvec*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nvec*sizeof(T), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  T** h_Zd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Zd[i] = Z[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = Z[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::scaleVectorArrayKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      d_c,
+      d_Xd,
+      d_Zd,
+      Z[0]->size()
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t constVectorArray(int nvec, T c, Vector<T,I>** Z)
+{
+  cudaError_t err;
+
+  // Create array of device pointers on host
+  T** h_Zd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Zd[i] = Z[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = Z[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::constVectorArrayKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      c,
+      d_Zd,
+      Z[0]->size()
+  );
+
+  // Free host array
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t wL2NormSquareVectorArray(int nvec, Vector<T,I>** X,
+                                            Vector<T,I>** W, T* nrm)
+{
+  cudaError_t err;
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  T** h_Wd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Wd[i] = W[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Wd;
+  err = cudaMalloc((void**) &d_Wd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Wd, h_Wd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X[0]->partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = nvec*block*sizeof(T);
+  const cudaStream_t stream   = p.stream();
+
+  // Allocate reduction buffer on device
+  T* d_buff;
+  err = cudaMalloc((void**) &d_buff, nvec*grid*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  math_kernels::wL2NormSquareVectorArrayKernel<<<grid, block, shMemSize, stream>>>(
+      nvec,
+      d_Xd,
+      d_Wd,
+      d_buff,
+      X[0]->size()
+  );
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax) {
+
+    // Recompute partitioning
+    grid = (n + block - 1)/block;
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceVectorKernel<T,I><<<grid, block, shMemSize, stream>>>(
+        nvec,
+        d_buff,
+        d_buff,
+        n
+    );
+
+    // update buffer array working length
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  T* h_buff = new T[nvec*n*sizeof(T)];
+  err = cudaMemcpy(h_buff, d_buff, nvec*n*sizeof(T), cudaMemcpyDeviceToHost);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  for (int k=0; k<nvec; k++) {
+    nrm[k] = h_buff[k*n];
+    for (int i=1; i<n; i++){
+      nrm[k] += h_buff[i + k*n];
+    }
+  }
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Wd;
+  delete[] h_buff;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Wd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_buff);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t wL2NormSquareMaskVectorArray(int nvec, Vector<T,I>** X,
+                                           Vector<T,I>** W, Vector<T,I>* ID,
+                                           T* nrm)
+{
+  cudaError_t err;
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  T** h_Wd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Wd[i] = W[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Wd;
+  err = cudaMalloc((void**) &d_Wd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Wd, h_Wd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X[0]->partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = nvec*block*sizeof(T);
+  const cudaStream_t stream   = p.stream();
+
+  // Allocate reduction buffer on device
+  T* d_buff;
+  err = cudaMalloc((void**) &d_buff, nvec*grid*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  math_kernels::wL2NormSquareMaskVectorArrayKernel<<<grid, block, shMemSize, stream>>>(
+      nvec,
+      d_Xd,
+      d_Wd,
+      ID->device(),
+      d_buff,
+      X[0]->size()
+  );
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax) {
+
+    // Recompute partitioning
+    grid = (n + block - 1)/block;
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceVectorKernel<T,I><<<grid, block, shMemSize, stream>>>(
+        nvec,
+        d_buff,
+        d_buff,
+        n
+    );
+
+    // update buffer array working length
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  T* h_buff = new T[nvec*n*sizeof(T)];
+  err = cudaMemcpy(h_buff, d_buff, nvec*n*sizeof(T), cudaMemcpyDeviceToHost);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  for (int k=0; k<nvec; k++) {
+    nrm[k] = h_buff[k*n];
+    for (int i=1; i<n; i++){
+      nrm[k] += h_buff[i + k*n];
+    }
+  }
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Wd;
+  delete[] h_buff;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Wd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_buff);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t scaleAddMultiVectorArray(int nvec, int nsum, T* c,
+                                            Vector<T,I>** X, Vector<T,I>** Y,
+                                            Vector<T,I>** Z)
+{
+  cudaError_t err;
+
+  // Copy c array to device
+  T* d_c;
+  err = cudaMalloc((void**) &d_c, nsum*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nsum*sizeof(T), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  T** h_Yd = new T*[nsum*nvec];
+  for (int i=0; i<nsum*nvec; i++)
+    h_Yd[i] = Y[i]->device();
+
+  T** h_Zd = new T*[nsum*nvec];
+  for (int i=0; i<nsum*nvec; i++)
+    h_Zd[i] = Z[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nsum*nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nsum*nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nsum*nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nsum*nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = Z[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::scaleAddMultiVectorArrayKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      nsum,
+      d_c,
+      d_Xd,
+      d_Yd,
+      d_Zd,
+      Z[0]->size()
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Yd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t linearCombinationVectorArray(int nvec, int nsum, T* c,
+                                                Vector<T,I>** X, Vector<T,I>** Z)
+{
+  cudaError_t err;
+
+  // Copy c array to device
+  T* d_c;
+  err = cudaMalloc((void**) &d_c, nsum*sizeof(T));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nsum*sizeof(T), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  T** h_Xd = new T*[nsum*nvec];
+  for (int i=0; i<nsum*nvec; i++)
+    h_Xd[i] = X[i]->device();
+
+  T** h_Zd = new T*[nvec];
+  for (int i=0; i<nvec; i++)
+    h_Zd[i] = Z[i]->device();
+
+  // Copy array of device pointers to device from host
+  T** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nsum*nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nsum*nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  T** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(T*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(T*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = Z[0]->partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::linearCombinationVectorArrayKernel<<<grid, block, 0, stream>>>(
+      nvec,
+      nsum,
+      d_c,
+      d_Xd,
+      d_Zd,
+      Z[0]->size()
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return cudaGetLastError();
+}
+
+
+} // namespace nvec
+
+
+
+#endif // _VECTOR_ARRAY_KERNELS_CUH_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/VectorKernels.cuh b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/VectorKernels.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..8b304b75db05319a2f2e0ea717c6418476d2a72f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/cuda/VectorKernels.cuh
@@ -0,0 +1,1072 @@
+/*
+ * -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ */
+
+
+#ifndef _VECTOR_KERNELS_CUH_
+#define _VECTOR_KERNELS_CUH_
+
+#include <limits>
+#include <cuda_runtime.h>
+
+
+namespace suncudavec
+{
+
+/* -----------------------------------------------------------------
+ * The namespace for CUDA kernels
+ *
+ * Reduction CUDA kernels in nvector are based in part on "reduction"
+ * example in NVIDIA Corporation CUDA Samples, and parallel reduction
+ * examples in textbook by J. Cheng at al. "CUDA C Programming".
+ * -----------------------------------------------------------------
+ */
+namespace math_kernels
+{
+
+
+/*
+ * Sets all elements of the vector X to constant value a.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+setConstKernel(T a, T *X, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    X[i] = a;
+  }
+}
+
+
+/*
+ * Computes linear sum (combination) of two vectors.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+linearSumKernel(T a, const T *X, T b, const T *Y, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = a*X[i] + b*Y[i];
+  }
+}
+
+
+/*
+ * Elementwise product of two vectors.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+prodKernel(const T *X, const T *Y, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = X[i]*Y[i];
+  }
+}
+
+
+/*
+ * Elementwise division of two vectors.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+divKernel(const T *X, const T *Y, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = X[i]/Y[i];
+  }
+}
+
+
+/*
+ * Scale vector with scalar value 'a'.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+scaleKernel(T a, const T *X, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = a*X[i];
+  }
+}
+
+
+/*
+ * Stores absolute values of vector X elements into vector Z.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+absKernel(const T *X, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = abs(X[i]);
+  }
+}
+
+
+/*
+ * Elementwise inversion.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+invKernel(const T *X, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = 1.0/(X[i]);
+  }
+}
+
+
+/*
+ * Add constant 'c' to each vector element.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+addConstKernel(T a, const T *X, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = a + X[i];
+  }
+}
+
+
+/*
+ * Compare absolute values of vector 'X' with constant 'c'.
+ *
+ */
+
+template <typename T, typename I>
+__global__ void
+compareKernel(T c, const T *X, T *Z, I n)
+{
+  I i = blockDim.x * blockIdx.x + threadIdx.x;
+
+  if (i < n)
+  {
+    Z[i] = (abs(X[i]) >= c) ? 1.0 : 0.0;
+  }
+}
+
+
+/*
+ * Sums all elements of the vector.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+sumReduceKernel(const T *x, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T sum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    sum = x[i];
+  if (i + blockDim.x < n)
+    sum += x[i+blockDim.x];
+  shmem[tid] = sum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      sum += shmem[tid + j];
+      shmem[tid] = sum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = sum;
+}
+
+
+/*
+ * Dot product of two vectors.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+dotProdKernel(const T *x, const T *y, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T sum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    sum = x[i] * y[i];
+  if (i + blockDim.x < n)
+    sum += ( x[i+blockDim.x] * y[i+blockDim.x]);
+  shmem[tid] = sum;
+  __syncthreads();
+
+  // Perform blockwise reduction in shared memory
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      sum += shmem[tid + j];
+      shmem[tid] = sum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = sum;
+}
+
+
+/*
+ * Finds max norm the vector.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+maxNormKernel(const T *x, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T maximum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    maximum = abs(x[i]);
+  if (i + blockDim.x < n)
+    maximum = max(abs(x[i+blockDim.x]), maximum);
+  shmem[tid] = maximum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      maximum = max(shmem[tid + j], maximum);
+      shmem[tid] = maximum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = maximum;
+}
+
+
+/*
+ * Weighted L2 norm squared.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+wL2NormSquareKernel(const T *x, const T *w, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T sum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    sum = x[i] * w[i] * x[i] * w[i];
+  if (i + blockDim.x < n)
+    sum += ( x[i+blockDim.x] * w[i+blockDim.x] * x[i+blockDim.x] * w[i+blockDim.x] );
+
+  shmem[tid] = sum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1)
+  {
+    if (tid < j) {
+      sum += shmem[tid + j];
+      shmem[tid] = sum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = sum;
+}
+
+/*
+ * Weighted L2 norm squared with mask. Vector id specifies the mask.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+wL2NormSquareMaskKernel(const T *x, const T *w, const T *id, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T sum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n && id[i] > 0.0)
+    sum = x[i] * w[i] * x[i] * w[i];
+  if ((i + blockDim.x < n) && (id[i+blockDim.x] > 0.0))
+    sum += ( x[i+blockDim.x] * w[i+blockDim.x] * x[i+blockDim.x] * w[i+blockDim.x]);
+  shmem[tid] = sum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      sum += shmem[tid + j];
+      shmem[tid] = sum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = sum;
+}
+
+/*
+ * Finds min value in the vector.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+findMinKernel(T MAX_VAL, const T *x, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T minimum = MAX_VAL;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    minimum = x[i];
+  if (i + blockDim.x < n)
+    minimum = min((x[i+blockDim.x]), minimum);
+  shmem[tid] = minimum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      minimum = min(shmem[tid + j], minimum);
+      shmem[tid] = minimum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = minimum;
+}
+
+
+/*
+ * Computes L1 norm of vector
+ *
+ */
+template <typename T, typename I>
+__global__ void
+L1NormKernel(const T *x, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T sum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n)
+    sum = abs(x[i]);
+  if (i + blockDim.x < n)
+    sum += abs(x[i+blockDim.x]);
+  shmem[tid] = sum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      sum += shmem[tid + j];
+      shmem[tid] = sum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = sum;
+}
+
+/*
+ * Vector inverse  z[i] = 1/x[i] with check for zeros. Reduction is performed
+ * to flag the result if any x[i] = 0.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+invTestKernel(const T *x, T *z, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T flag = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n) {
+    if (x[i] == 0.0) {
+      flag = 1.0;
+    } else {
+      flag = 0.0;
+      z[i] = 1.0/x[i];
+    }
+  }
+
+  if (i + blockDim.x < n) {
+    if (x[i + blockDim.x] == 0.0) {
+      flag += 1.0;
+    } else {
+      z[i + blockDim.x] = 1.0/x[i + blockDim.x];
+    }
+  }
+
+  shmem[tid] = flag;
+  __syncthreads();
+
+  // Inverse calculation is done. Perform reduction block-wise in shared
+  // to find if any x[i] = 0.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      flag += shmem[tid + j];
+      shmem[tid] = flag;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = flag;
+}
+
+/*
+ * Checks if inequality constraints are satisfied. Constraint check
+ * results are stored in vector 'm'. A sum reduction over all elements
+ * of 'm' is performed to find if any of the constraints is violated.
+ * If all constraints are satisfied sum == 0.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+constrMaskKernel(const T *c, const T *x, T *m, T *out, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  T sum = 0.0;
+
+  // First reduction step before storing data in shared memory.
+  if (i < n){
+    // test1 = true if constraints violated
+    bool test1 = (std::abs(c[i]) > 1.5 && c[i]*x[i] <= 0.0) ||
+                 (std::abs(c[i]) > 0.5 && c[i]*x[i] <  0.0);
+    m[i] = test1 ? 1.0 : 0.0;
+    sum = m[i];
+  }
+
+  if (i + blockDim.x < n) {
+    // test2 = true if constraints violated
+    bool test2 = (std::abs(c[i + blockDim.x]) > 1.5 && c[i + blockDim.x]*x[i + blockDim.x] <= 0.0) ||
+                 (std::abs(c[i + blockDim.x]) > 0.5 && c[i + blockDim.x]*x[i + blockDim.x] <  0.0);
+    m[i+blockDim.x] = test2 ? 1.0 : 0.0;
+    sum += m[i+blockDim.x];
+  }
+
+  shmem[tid] = sum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      sum += shmem[tid + j];
+      shmem[tid] = sum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    out[blockIdx.x] = sum;
+}
+
+/*
+ * Finds minimum component-wise quotient.
+ *
+ */
+template <typename T, typename I>
+__global__ void
+minQuotientKernel(const T MAX_VAL, const T *num, const T *den, T *min_quotient, I n)
+{
+  extern __shared__ T shmem[];
+
+  I tid = threadIdx.x;
+  I i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
+
+  // Initialize "minimum" to maximum floating point value.
+  T minimum = MAX_VAL;
+  const T zero = static_cast<T>(0.0);
+
+  // Load vector quotient in the shared memory. Skip if the denominator
+  // value is zero.
+  if (i < n && den[i] != zero)
+    minimum = num[i]/den[i];
+
+  // First level of reduction is upon storing values to shared memory.
+  if (i + blockDim.x < n && den[i + blockDim.x] != zero)
+    minimum = min(num[i+blockDim.x]/den[i+blockDim.x], minimum);
+
+  shmem[tid] = minimum;
+  __syncthreads();
+
+  // Perform reduction block-wise in shared memory.
+  for (I j = blockDim.x/2; j > 0; j >>= 1) {
+    if (tid < j) {
+      minimum = min(shmem[tid + j], minimum);
+      shmem[tid] = minimum;
+    }
+    __syncthreads();
+  }
+
+  // Copy reduction result for each block to global memory
+  if (tid == 0)
+    min_quotient[blockIdx.x] = minimum;
+}
+
+
+} // namespace math_kernels
+
+
+
+
+template <typename T, typename I>
+inline cudaError_t setConst(T a, Vector<T,I>& X)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::setConstKernel<<<grid, block, 0, stream>>>(a, X.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t linearSum(T a, const Vector<T,I>& X, T b, const Vector<T,I>& Y, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::linearSumKernel<<<grid, block, 0, stream>>>(a, X.device(), b, Y.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t prod(const Vector<T,I>& X, const Vector<T,I>& Y, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::prodKernel<<<grid, block, 0, stream>>>(X.device(), Y.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t div(const Vector<T,I>& X, const Vector<T,I>& Y, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::divKernel<<<grid, block, 0, stream>>>(X.device(), Y.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t scale(T const a, const Vector<T,I>& X, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::scaleKernel<<<grid, block, 0, stream>>>(a, X.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t absVal(const Vector<T,I>& X, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::absKernel<<<grid, block, 0, stream>>>(X.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t inv(const Vector<T,I>& X, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::invKernel<<<grid, block, 0, stream>>>(X.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+template <typename T, typename I>
+inline cudaError_t addConst(T const a, const Vector<T,I>& X, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::addConstKernel<<<grid, block, 0, stream>>>(a, X.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline cudaError_t compare(T const c, const Vector<T,I>& X, Vector<T,I>& Z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = X.partStream();
+  const I grid                = p.grid();
+  const unsigned block        = p.block();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::compareKernel<<<grid, block, 0, stream>>>(c, X.device(), Z.device(), X.size());
+  return cudaGetLastError();
+}
+
+
+template <typename T, typename I>
+inline T dotProd(const Vector<T,I>& x, const Vector<T,I>& y)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::dotProdKernel<T,I><<<grid, block, shMemSize, stream>>>(x.device(), y.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    gpu_result += p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+template <typename T, typename I>
+inline T maxNorm(const Vector<T,I>& x)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::maxNormKernel<T,I><<<grid, block, shMemSize, stream>>>(x.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // (Re)run reduction kernel
+    math_kernels::maxNormKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    if (p.hostBuffer()[i] > gpu_result)
+      gpu_result = p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+template <typename T, typename I>
+inline T wL2NormSquareMask(const Vector<T,I>& x, const Vector<T,I>& w, const Vector<T,I>& id)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::wL2NormSquareMaskKernel<T,I><<<grid, block, shMemSize, stream>>>(x.device(), w.device(), id.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // (Re)run reduction kernel
+    math_kernels::sumReduceKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    gpu_result += p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+template <typename T, typename I>
+inline T findMin(const Vector<T,I>& x)
+{
+  T maxVal = std::numeric_limits<T>::max();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::findMinKernel<T,I><<<grid, block, shMemSize, stream>>>(maxVal, x.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::findMinKernel<T,I><<<grid, block, shMemSize, stream>>>(maxVal, p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    if (p.hostBuffer()[i] < gpu_result)
+      gpu_result = p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+
+template <typename T, typename I>
+inline T wL2NormSquare(const Vector<T,I>& x, const Vector<T,I>& y)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::wL2NormSquareKernel<T,I><<<grid, block, shMemSize, stream>>>(x.device(), y.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    gpu_result += p.hostBuffer()[i];
+  }
+  return (gpu_result);
+}
+
+
+template <typename T, typename I>
+inline T L1Norm(const Vector<T,I>& x)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::L1NormKernel<T,I><<<grid, block, shMemSize, stream>>>(x.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    gpu_result += p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+
+template <typename T, typename I>
+inline T invTest(const Vector<T,I>& x, Vector<T,I>& z)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::invTestKernel<T,I><<<grid, block, shMemSize, stream>>>(x.device(), z.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    gpu_result += p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+
+template <typename T, typename I>
+inline T constrMask(const Vector<T,I>& c, const Vector<T,I>& x, Vector<T,I>& m)
+{
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = x.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::constrMaskKernel<T,I><<<grid, block, shMemSize, stream>>>(c.device(), x.device(), m.device(), p.devBuffer(), x.size());
+
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::sumReduceKernel<T,I><<<grid, block, shMemSize, stream>>>(p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    gpu_result += p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+
+template <typename T, typename I>
+inline T minQuotient(const Vector<T,I>& num, const Vector<T,I>& den)
+{
+  // Starting value for min reduction
+  const T maxVal = std::numeric_limits<T>::max();
+
+  // Set partitioning
+  ThreadPartitioning<T, I>& p = num.partReduce();
+  unsigned grid               = p.grid();
+  unsigned block              = p.block();
+  unsigned shMemSize          = p.shmem();
+  const cudaStream_t stream   = p.stream();
+
+  math_kernels::minQuotientKernel<T,I><<<grid, block, shMemSize, stream>>>(maxVal, num.device(), den.device(), p.devBuffer(), num.size());
+
+  // All quotients are computed by now. Find the minimum.
+  unsigned n = grid;
+  unsigned nmax = 2*block;
+  while (n > nmax)
+  {
+    // Recompute partitioning
+    p.setPartitioning(n, grid, block, shMemSize);
+
+    // Rerun reduction kernel
+    math_kernels::findMinKernel<T,I><<<grid, block, shMemSize, stream>>>(maxVal, p.devBuffer(), p.devBuffer(), n);
+    n = grid;
+  }
+
+  // Finish reduction on CPU if there are less than two blocks of data left.
+  p.copyFromDevBuffer(n);
+
+  T gpu_result = p.hostBuffer()[0];
+  for (unsigned int i=1; i<n; i++)
+  {
+    if (p.hostBuffer()[i] < gpu_result)
+      gpu_result = p.hostBuffer()[i];
+  }
+  return gpu_result;
+}
+
+
+} // namespace nvec
+
+
+#endif // _VECTOR_KERNELS_CUH_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/raja/Vector.hpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/raja/Vector.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b032d93f25221202c5b3d18a41e72d66952800c9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/raja/Vector.hpp
@@ -0,0 +1,159 @@
+/*
+ * -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ */
+
+
+/*
+ * Vector class
+ *
+ * Manages vector data layout for RAJA implementation of N_Vector.
+ *
+ */
+
+#ifndef _NVECTOR_RAJA_HPP_
+#define _NVECTOR_RAJA_HPP_
+
+#include <cstdlib>
+#include <iostream>
+
+#include <sundials/sundials_config.h>
+#include <sundials/sundials_mpi.h>
+
+#if SUNDIALS_MPI_ENABLED
+#include <nvector/nvector_mpiraja.h>
+#else
+#include <nvector/nvector_raja.h>
+#endif
+
+namespace sunrajavec
+{
+
+template <typename T, typename I>
+class Vector : public _N_VectorContent_Raja
+{
+public:
+  Vector(I N)
+  : size_(N),
+    mem_size_(N*sizeof(T)),
+    global_size_(N),
+    comm_(0)
+  {
+    allocate();
+  }
+
+  Vector(SUNMPI_Comm comm, I N, I Nglobal)
+  : size_(N),
+    mem_size_(N*sizeof(T)),
+    global_size_(Nglobal),
+    comm_(comm)
+  {
+    allocate();
+  }
+
+  // Copy constructor does not copy values
+  explicit Vector(const Vector& v)
+  : size_(v.size()),
+    mem_size_(size_*sizeof(T)),
+    global_size_(v.global_size_),
+    comm_(v.comm_)
+  {
+    allocate();
+  }
+
+  ~Vector()
+  {
+    cudaError_t err;
+    free(h_vec_);
+    err = cudaFree(d_vec_);
+    if(err != cudaSuccess)
+      std::cout << "Failed to free device vector (error code " << err << ")!\n";
+  }
+
+
+  void allocate()
+  {
+    cudaError_t err;
+    h_vec_ = static_cast<T*>(malloc(mem_size_));
+    if(h_vec_ == NULL)
+      std::cout << "Failed to allocate host vector!\n";
+    err = cudaMalloc((void**) &d_vec_, mem_size_);
+    if(err != cudaSuccess)
+      std::cout << "Failed to allocate device vector (error code " << err << ")!\n";
+  }
+
+  int size() const
+  {
+    return size_;
+  }
+
+  int sizeGlobal() const
+  {
+    return global_size_;
+  }
+
+  SUNMPI_Comm comm()
+  {
+    return comm_;
+  }
+
+  T* host()
+  {
+    return h_vec_;
+  }
+
+  const T* host() const
+  {
+    return h_vec_;
+  }
+
+  T* device()
+  {
+    return d_vec_;
+  }
+
+  const T* device() const
+  {
+    return d_vec_;
+  }
+
+  void copyToDev()
+  {
+    cudaError_t err = cudaMemcpy(d_vec_, h_vec_, mem_size_, cudaMemcpyHostToDevice);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to copy vector from host to device (error code " << err << ")!\n";
+  }
+
+  void copyFromDev()
+  {
+    cudaError_t err = cudaMemcpy(h_vec_, d_vec_, mem_size_, cudaMemcpyDeviceToHost);
+    if(err != cudaSuccess)
+      std::cerr << "Failed to copy vector from device to host (error code " << err << ")!\n";
+  }
+
+private:
+  I size_;
+  I mem_size_;
+  I global_size_;
+  T* h_vec_;
+  T* d_vec_;
+  SUNMPI_Comm comm_;
+};
+
+
+} // namespace sunrajavec
+
+
+
+#endif // _NVECTOR_RAJA_HPP_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/trilinos/SundialsTpetraVectorInterface.hpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/trilinos/SundialsTpetraVectorInterface.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cef0e6cfe045097601ff6d925a849df9b2da853
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/trilinos/SundialsTpetraVectorInterface.hpp
@@ -0,0 +1,63 @@
+/* -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------*/
+
+#ifndef _TPETRA_SUNDIALS_INTERFACE_HPP_
+#define _TPETRA_SUNDIALS_INTERFACE_HPP_
+
+#include <Tpetra_Vector.hpp>
+#include <nvector/nvector_trilinos.h>
+
+namespace Sundials
+{
+
+  struct TpetraVectorInterface : public _N_VectorContent_Trilinos
+  {
+    // Typedef of Tpetra vector class to be used with SUNDIALS
+    typedef Tpetra::Vector<realtype, sunindextype, sunindextype> vector_type;
+
+    TpetraVectorInterface(Teuchos::RCP<vector_type> rcpvec)
+    {
+      rcpvec_ = rcpvec;
+    }
+
+    ~TpetraVectorInterface() = default;
+
+    Teuchos::RCP<vector_type> rcpvec_;
+  };
+
+
+} // namespace Sundials
+
+inline Teuchos::RCP<Sundials::TpetraVectorInterface::vector_type> N_VGetVector_Trilinos(N_Vector v)
+{
+  Sundials::TpetraVectorInterface* iface =
+  reinterpret_cast<Sundials::TpetraVectorInterface*>(v->content);
+
+  return iface->rcpvec_;
+}
+
+/*
+ * -----------------------------------------------------------------
+ * Function : N_VMake_Trilinos
+ * -----------------------------------------------------------------
+ * This function attaches N_Vector functions to a Tpetra vector.
+ * -----------------------------------------------------------------
+ */
+
+SUNDIALS_EXPORT N_Vector
+N_VMake_Trilinos(Teuchos::RCP<Sundials::TpetraVectorInterface::vector_type> v);
+
+
+
+#endif // _TPETRA_SUNDIALS_INTERFACE_HPP_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/trilinos/SundialsTpetraVectorKernels.hpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/trilinos/SundialsTpetraVectorKernels.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b435e7144dcab9ad11532b3d28a33e9a93626a8f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/nvector/trilinos/SundialsTpetraVectorKernels.hpp
@@ -0,0 +1,393 @@
+/* -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------*/
+
+#ifndef _TPETRA_SUNDIALS_VECTOR_KERNELS_HPP_
+#define _TPETRA_SUNDIALS_VECTOR_KERNELS_HPP_
+
+#include <Tpetra_Vector.hpp>
+#include <Kokkos_Core.hpp>
+#include <nvector/trilinos/SundialsTpetraVectorInterface.hpp>
+
+namespace Sundials
+{
+
+  /**
+   * The namespace contains custom Kokkos-based kernels needed by SUNDIALS
+   *
+   * Kernels are inlined in case this file is included in more than one
+   * translation unit.
+   */
+  namespace TpetraVector
+  {
+    using Teuchos::outArg;
+    using Teuchos::REDUCE_SUM;
+    using Teuchos::REDUCE_MIN;
+    using Teuchos::REDUCE_MAX;
+    using Teuchos::reduceAll;
+
+    typedef Sundials::TpetraVectorInterface::vector_type vector_type;
+    typedef vector_type::scalar_type scalar_type;
+    typedef vector_type::mag_type mag_type;
+    typedef vector_type::global_ordinal_type global_ordinal_type;
+    typedef vector_type::local_ordinal_type local_ordinal_type;
+    typedef vector_type::node_type::memory_space memory_space;
+    typedef vector_type::execution_space execution_space;
+
+    static constexpr scalar_type zero   = 0;
+    static constexpr scalar_type half   = 0.5;
+    static constexpr scalar_type one    = 1.0;
+    static constexpr scalar_type onept5 = 1.5;
+
+    /*----------------------------------------------------------------
+     *  Streaming vector kernels
+     *---------------------------------------------------------------*/
+
+    /// Divide: z(i) = x(i)/y(i) forall i
+    inline void elementWiseDivide(const vector_type& x,
+                                  const vector_type& y,
+                                  vector_type& z)
+    {
+      const local_ordinal_type N = x.getLocalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+      if (y.need_sync<memory_space>())
+        const_cast<vector_type&>(y).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto y_2d = y.getLocalView<memory_space>();
+      auto y_1d = Kokkos::subview (y_2d, Kokkos::ALL(), 0);
+      auto z_2d = z.getLocalView<memory_space>();
+      auto z_1d = Kokkos::subview (z_2d, Kokkos::ALL(), 0);
+
+      z.modify<memory_space>();
+
+      Kokkos::parallel_for ("elementWiseDivide", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i)
+        {
+          z_1d(i) = x_1d(i)/y_1d(i);
+        }
+      );
+    }
+
+
+    /// Add constant to all vector elements: z(i) = x(i) + b
+    inline void addConst(const vector_type& x,
+                         scalar_type b,
+                         vector_type& z)
+    {
+      const local_ordinal_type N = x.getLocalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+      if (z.need_sync<memory_space>())
+        const_cast<vector_type&>(z).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto z_2d = z.getLocalView<memory_space>();
+      auto z_1d = Kokkos::subview (z_2d, Kokkos::ALL(), 0);
+
+      z.modify<memory_space>();
+
+      Kokkos::parallel_for ("addConst", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i)
+        {
+          z_1d(i) = x_1d(i) + b;
+        }
+      );
+    }
+
+
+    /// Compare vector elements to c: z(i) = |x(i)| >= c ? 1 : 0
+    inline void compare(scalar_type c,
+                        const vector_type& x,
+                        vector_type& z)
+    {
+      const local_ordinal_type N = x.getLocalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+      if (z.need_sync<memory_space>())
+        const_cast<vector_type&>(z).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto z_2d = z.getLocalView<memory_space>();
+      auto z_1d = Kokkos::subview (z_2d, Kokkos::ALL(), 0);
+
+      z.modify<memory_space>();
+
+      Kokkos::parallel_for ("compare", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i)
+        {
+          z_1d(i) = std::abs(x_1d(i)) >= c ? one : zero;
+        }
+      );
+    }
+
+
+    /*----------------------------------------------------------------
+     *  Reduction vector kernels
+     *---------------------------------------------------------------*/
+
+    /// Weighted root-mean-square norm
+    inline mag_type normWrms(const vector_type& x,
+                             const vector_type& w)
+    {
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = x.getMap()->getComm();
+      const local_ordinal_type  N = x.getLocalLength();
+      const global_ordinal_type Nglob = x.getGlobalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+      if (w.need_sync<memory_space>())
+        const_cast<vector_type&>(w).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto w_2d = w.getLocalView<memory_space>();
+      auto w_1d = Kokkos::subview (w_2d, Kokkos::ALL(), 0);
+
+      mag_type sum = zero;
+      Kokkos::parallel_reduce ("normWrms", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, mag_type &local_sum)
+        {
+          local_sum += x_1d(i)*w_1d(i)*(x_1d(i)*w_1d(i));
+        }, sum);
+
+      mag_type globalSum = zero;
+      reduceAll<int, mag_type>(*comm, REDUCE_SUM, sum, outArg(globalSum));
+      return std::sqrt(globalSum/static_cast<mag_type>(Nglob));
+    }
+
+
+    /// Weighted root-mean-square norm with mask
+    inline mag_type normWrmsMask(const vector_type& x,
+                                 const vector_type& w,
+                                 const vector_type& id)
+    {
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = x.getMap()->getComm();
+      const local_ordinal_type  N = x.getLocalLength();
+      const global_ordinal_type Nglob = x.getGlobalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+      if (w.need_sync<memory_space>())
+        const_cast<vector_type&>(w).sync<memory_space>();
+      if (id.need_sync<memory_space>())
+        const_cast<vector_type&>(id).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto w_2d = w.getLocalView<memory_space>();
+      auto w_1d = Kokkos::subview (w_2d, Kokkos::ALL(), 0);
+      auto id_2d = id.getLocalView<memory_space>();
+      auto id_1d = Kokkos::subview (id_2d, Kokkos::ALL(), 0);
+
+      mag_type sum = zero;
+      Kokkos::parallel_reduce ("normWrmsMask", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, mag_type &local_sum)
+        {
+          if (id_1d(i) > zero)
+            local_sum += x_1d(i)*w_1d(i)*(x_1d(i)*w_1d(i));
+        }, sum);
+
+      mag_type globalSum = zero;
+      reduceAll<int, mag_type>(*comm, REDUCE_SUM, sum, outArg(globalSum));
+      return std::sqrt(globalSum/static_cast<mag_type>(Nglob));
+    }
+
+
+    /// Find minimum element value in the vector
+    inline scalar_type minElement(const vector_type& x)
+    {
+      using namespace Kokkos;
+
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = x.getMap()->getComm();
+      const local_ordinal_type  N = x.getLocalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+
+      scalar_type minimum;
+      Min<scalar_type> min_reducer(minimum);
+
+      Kokkos::parallel_reduce ("minElement", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, scalar_type &local_min)
+        {
+          min_reducer.join(local_min, x_1d(i));
+        }, min_reducer);
+
+      scalar_type globalMin;
+      reduceAll<int, scalar_type>(*comm, REDUCE_MIN, minimum, outArg(globalMin));
+      return globalMin;
+    }
+
+
+    /// Weighted L2 norm
+    inline mag_type normWL2(const vector_type& x,
+                            const vector_type& w)
+    {
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = x.getMap()->getComm();
+      const local_ordinal_type  N = x.getLocalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+      if (w.need_sync<memory_space>())
+        const_cast<vector_type&>(w).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto w_2d = w.getLocalView<memory_space>();
+      auto w_1d = Kokkos::subview (w_2d, Kokkos::ALL(), 0);
+
+      mag_type sum = zero;
+      Kokkos::parallel_reduce ("normWL2", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, mag_type &local_sum)
+        {
+          local_sum += x_1d(i)*w_1d(i)*(x_1d(i)*w_1d(i));
+        }, sum);
+
+      mag_type globalSum = zero;
+      reduceAll<int, mag_type>(*comm, REDUCE_SUM, sum, outArg(globalSum));
+      return std::sqrt(globalSum);
+    }
+
+
+    /// Elementwise inverse, return false if any denominator is zero.
+    inline bool invTest(const vector_type& x,
+                        vector_type& z)
+    {
+      using namespace Kokkos;
+
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = x.getMap()->getComm();
+      const local_ordinal_type  N = x.getLocalLength();
+
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto z_2d = z.getLocalView<memory_space>();
+      auto z_1d = Kokkos::subview (z_2d, Kokkos::ALL(), 0);
+
+      scalar_type minimum;
+      Min<scalar_type> min_reducer(minimum);
+
+      z.modify<memory_space>();
+
+      Kokkos::parallel_reduce ("invTest", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, scalar_type &local_min)
+        {
+          static constexpr scalar_type zero   = 0;
+          static constexpr scalar_type one    = 1.0;
+          if (x_1d(i) == zero)
+          {
+            min_reducer.join(local_min, zero);
+          }
+          else
+          {
+            z_1d(i) = one/x_1d(i);
+          }
+        }, min_reducer);
+
+      scalar_type globalMin;
+      reduceAll<int, scalar_type>(*comm, REDUCE_MIN, minimum, outArg(globalMin));
+      return (globalMin > half);
+    }
+
+
+    /// Find constraint violations
+    inline bool constraintMask(const vector_type& c,
+                               const vector_type& x,
+                               vector_type& m)
+    {
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = x.getMap()->getComm();
+      const local_ordinal_type  N = x.getLocalLength();
+
+      if (c.need_sync<memory_space>())
+        const_cast<vector_type&>(c).sync<memory_space>();
+      if (x.need_sync<memory_space>())
+        const_cast<vector_type&>(x).sync<memory_space>();
+
+      auto c_2d = c.getLocalView<memory_space>();
+      auto c_1d = Kokkos::subview (c_2d, Kokkos::ALL(), 0);
+      auto x_2d = x.getLocalView<memory_space>();
+      auto x_1d = Kokkos::subview (x_2d, Kokkos::ALL(), 0);
+      auto m_2d = m.getLocalView<memory_space>();
+      auto m_1d = Kokkos::subview (m_2d, Kokkos::ALL(), 0);
+
+      m.modify<memory_space>();
+
+      scalar_type sum = zero;
+      Kokkos::parallel_reduce ("constraintMask", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, scalar_type &local_sum)
+        {
+          const bool test = (abs(c_1d(i)) > onept5 && c_1d(i)*x_1d(i) <= zero) ||
+                            (abs(c_1d(i)) > half   && c_1d(i)*x_1d(i) <  zero);
+          m_1d(i) = test ? one : zero;
+          local_sum += m_1d(i);
+        }, sum);
+
+      scalar_type globalSum = zero;
+      reduceAll<int, scalar_type>(*comm, REDUCE_SUM, sum, outArg(globalSum));
+      return (globalSum < half);
+    }
+
+
+    /// Minimum quotient: min_i(num(i)/den(i))
+    inline scalar_type minQuotient(const vector_type& num,
+                                   const vector_type& den)
+    {
+      using namespace Kokkos;
+
+      const Teuchos::RCP<const Teuchos::Comm<int> >& comm = num.getMap()->getComm();
+      const local_ordinal_type  N = num.getLocalLength();
+
+      if (num.need_sync<memory_space>())
+        const_cast<vector_type&>(num).sync<memory_space>();
+      if (den.need_sync<memory_space>())
+        const_cast<vector_type&>(den).sync<memory_space>();
+
+      auto num_2d = num.getLocalView<memory_space>();
+      auto num_1d = Kokkos::subview (num_2d, Kokkos::ALL(), 0);
+      auto den_2d = den.getLocalView<memory_space>();
+      auto den_1d = Kokkos::subview (den_2d, Kokkos::ALL(), 0);
+
+      scalar_type minimum;
+      Min<scalar_type> min_reducer(minimum);
+
+      Kokkos::parallel_reduce ("minQuotient", Kokkos::RangePolicy<execution_space>(0, N),
+        KOKKOS_LAMBDA (const local_ordinal_type &i, scalar_type &local_min)
+        {
+          if (den_1d(i) != zero)
+            min_reducer.join(local_min, num_1d(i)/den_1d(i));
+        }, min_reducer);
+
+      scalar_type globalMin;
+      reduceAll<int, scalar_type>(*comm, REDUCE_MIN, minimum, outArg(globalMin));
+      return globalMin;
+    }
+
+
+  } // namespace TpetraVector
+
+} // namespace Sundials
+
+#endif // _TPETRA_SUNDIALS_VECTOR_KERNELS_HPP_
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/sundials/sundials_config.in b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/sundials/sundials_config.in
new file mode 100644
index 0000000000000000000000000000000000000000..8c7c7a2cf73a7b90d6117cc40d827f542cf42d89
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/sundials/sundials_config.in
@@ -0,0 +1,118 @@
+/* ----------------------------------------------------------------- 
+ * Programmer(s): Aaron Collier and Radu Serban @ LLNL
+ * -----------------------------------------------------------------
+ * LLNS/SMU Copyright Start
+ * Copyright (c) 2002-2018, Southern Methodist University and
+ * Lawrence Livermore National Security
+ *
+ * This work was performed under the auspices of the U.S. Department
+ * of Energy by Southern Methodist University and Lawrence Livermore
+ * National Laboratory under Contract DE-AC52-07NA27344.
+ * Produced at Southern Methodist University and the Lawrence
+ * Livermore National Laboratory.
+ *
+ * All rights reserved.
+ * For details, see the LICENSE file.
+ * LLNS/SMU Copyright End
+ * -----------------------------------------------------------------
+ * SUNDIALS configuration header file
+ * -----------------------------------------------------------------*/
+
+/* Define SUNDIALS version numbers */
+#define SUNDIALS_VERSION "@PACKAGE_VERSION@"
+#define SUNDIALS_VERSION_MAJOR @PACKAGE_VERSION_MAJOR@
+#define SUNDIALS_VERSION_MINOR @PACKAGE_VERSION_MINOR@
+#define SUNDIALS_VERSION_PATCH @PACKAGE_VERSION_PATCH@
+#define SUNDIALS_VERSION_LABEL "@PACKAGE_VERSION_LABEL@"
+
+/* FCMIX: Define Fortran name-mangling macro for C identifiers.
+ * Depending on the inferred scheme, one of the following six
+ * macros will be defined:
+ *     #define SUNDIALS_F77_FUNC(name,NAME) name
+ *     #define SUNDIALS_F77_FUNC(name,NAME) name ## _
+ *     #define SUNDIALS_F77_FUNC(name,NAME) name ## __
+ *     #define SUNDIALS_F77_FUNC(name,NAME) NAME
+ *     #define SUNDIALS_F77_FUNC(name,NAME) NAME ## _
+ *     #define SUNDIALS_F77_FUNC(name,NAME) NAME ## __
+ */
+@F77_MANGLE_MACRO1@
+
+/* FCMIX: Define Fortran name-mangling macro for C identifiers
+ *        which contain underscores.
+ */
+@F77_MANGLE_MACRO2@
+
+/* Define precision of SUNDIALS data type 'realtype' 
+ * Depending on the precision level, one of the following 
+ * three macros will be defined:
+ *     #define SUNDIALS_SINGLE_PRECISION 1
+ *     #define SUNDIALS_DOUBLE_PRECISION 1
+ *     #define SUNDIALS_EXTENDED_PRECISION 1
+ */
+@PRECISION_LEVEL@
+
+/* Define type of vector indices in SUNDIALS 'sunindextype'. 
+ * Depending on user choice of index type, one of the following 
+ * two macros will be defined:
+ *     #define SUNDIALS_INT64_T 1
+ *     #define SUNDIALS_INT32_T 1
+ */
+@INDEX_TYPE@
+
+/* Define the type of vector indices in SUNDIALS 'sunindextype'.
+ * The macro will be defined with a type of the appropriate size.
+ */
+#define SUNDIALS_INDEX_TYPE @SUNDIALS_CINDEX_TYPE@
+
+/* Use generic math functions 
+ * If it was decided that generic math functions can be used, then
+ *     #define SUNDIALS_USE_GENERIC_MATH
+ */
+#cmakedefine SUNDIALS_USE_GENERIC_MATH
+
+/* Use POSIX timers if available.
+ *     #define SUNDIALS_HAVE_POSIX_TIMERS
+ */
+#cmakedefine SUNDIALS_HAVE_POSIX_TIMERS
+
+/* Blas/Lapack available
+ * If working libraries for Blas/lapack support were found, then
+ *     #define SUNDIALS_BLAS_LAPACK
+ */
+#cmakedefine SUNDIALS_BLAS_LAPACK
+
+/* SUPERLUMT available
+ * If working libraries for SUPERLUMT support were found, then
+ *     #define SUNDIALS_SUPERLUMT 
+ */
+#cmakedefine SUNDIALS_SUPERLUMT
+#cmakedefine SUNDIALS_SUPERLUMT_THREAD_TYPE "@SUPERLUMT_THREAD_TYPE@"
+
+/* KLU available
+ * If working libraries for KLU support were found, then
+ *     #define SUNDIALS_KLU 
+ */
+#cmakedefine SUNDIALS_KLU
+
+/* Set if SUNDIALS is built with MPI support.
+ * 
+ */
+@IS_MPI_ENABLED@
+
+/* FNVECTOR: Allow user to specify different MPI communicator
+ * If it was found that the MPI implementation supports MPI_Comm_f2c, then
+ *      #define SUNDIALS_MPI_COMM_F2C 1
+ * otherwise
+ *      #define SUNDIALS_MPI_COMM_F2C 0
+ */
+@F77_MPI_COMM_F2C@
+
+/* Mark SUNDIALS API functions for export/import
+ * When building shared SUNDIALS libraries under Windows, use
+ *      #define SUNDIALS_EXPORT __declspec(dllexport)
+ * When linking to shared SUNDIALS libraries under Windows, use
+ *      #define SUNDIALS_EXPORT __declspec(dllimport)
+ * In all other cases (other platforms or static libraries under
+ * Windows), the SUNDIALS_EXPORT macro is empty
+ */
+@SUNDIALS_EXPORT@
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/sundials/sundials_fconfig.in b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/sundials/sundials_fconfig.in
new file mode 100644
index 0000000000000000000000000000000000000000..1a247233d2bde161043e160d3c2916a0d3851f8d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/include/sundials/sundials_fconfig.in
@@ -0,0 +1,51 @@
+!
+! ----------------------------------------------------------------- 
+! Programmer(s): Daniel R. Reynolds @ SMU
+!-----------------------------------------------------------------
+! LLNS/SMU Copyright Start
+! Copyright (c) 2002-2018, Southern Methodist University and
+! Lawrence Livermore National Security
+!
+! This work was performed under the auspices of the U.S. Department
+! of Energy by Southern Methodist University and Lawrence Livermore
+! National Laboratory under Contract DE-AC52-07NA27344.
+! Produced at Southern Methodist University and the Lawrence
+! Livermore National Laboratory.
+!
+! All rights reserved.
+! For details, see the LICENSE file.
+! LLNS/SMU Copyright End
+! ------------------------------------------------------------------
+! SUNDIALS fortran configuration input
+! ------------------------------------------------------------------
+
+!     Define precision of SUNDIALS data type 'realtype' as Fortran 
+!     parameter "REALTYPE"
+!
+!     Depending on the precision level, this value will be one of
+!          4  (SUNDIALS_SINGLE_PRECISION)
+!          8  (SUNDIALS_DOUBLE_PRECISION)
+!         16  (SUNDIALS_EXTENDED_PRECISION)
+!
+integer REALTYPE
+parameter (REALTYPE=@FPRECISION_LEVEL@)
+
+!     Define type of vector indices in SUNDIALS 'sunindextype' as 
+!     the Fortran parameter "SUNINDEXTYPE"
+!
+!     Depending on the user choice of indextype, this will be one of
+!          4  (32BIT)
+!          8  (64BIT)
+!
+integer SUNINDEXTYPE
+parameter (SUNINDEXTYPE=@SUNDIALS_FINDEX_TYPE@)
+
+!     If building with MPI enabled, define the logical flag 
+!     "SUNDIALS_MPI_COMM_F2C" indicating whether the user can specify
+!     a different MPI communicator than MPI_COMM_WORLD to FNVInitP
+!
+!          .true.   (communicator can differ from MPI_COMM_WORLD)
+!          .false.  (communicator must be MPI_COMM_WORLD)
+!
+logical SUNDIALS_MPI_COMM_F2C
+parameter (SUNDIALS_MPI_COMM_F2C=@FMPI_COMM_F2C@)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..934c7a9d5311991b2d90614254b36aef708d31b8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/CMakeLists.txt
@@ -0,0 +1,70 @@
+# ---------------------------------------------------------------
+# Programmer:  David Gardner, Slaven Peles, and Cody Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# src level CMakeLists.txt for SUNDIALS (for cmake build system)
+# ---------------------------------------------------------------
+
+# Add all of the shared SUNDIALS components
+ADD_SUBDIRECTORY(sundials)
+ADD_SUBDIRECTORY(nvector)
+ADD_SUBDIRECTORY(sunmatrix)
+ADD_SUBDIRECTORY(sunlinsol)
+ADD_SUBDIRECTORY(sunnonlinsol)
+
+# ARKODE library
+IF(BUILD_ARKODE)
+  ADD_SUBDIRECTORY(arkode)
+  IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+    ADD_SUBDIRECTORY(arkode/fcmix)
+  ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+ENDIF(BUILD_ARKODE)
+
+# CVODE library
+IF(BUILD_CVODE)
+  ADD_SUBDIRECTORY(cvode)
+  IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+    ADD_SUBDIRECTORY(cvode/fcmix)
+  ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+ENDIF(BUILD_CVODE)
+
+# CVODES library
+IF(BUILD_CVODES)
+  ADD_SUBDIRECTORY(cvodes)
+ENDIF(BUILD_CVODES)
+
+# IDA library
+IF(BUILD_IDA)
+  ADD_SUBDIRECTORY(ida)
+  IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+    ADD_SUBDIRECTORY(ida/fcmix)
+  ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+ENDIF(BUILD_IDA)
+
+# IDAS library
+IF(BUILD_IDAS)
+  ADD_SUBDIRECTORY(idas)
+ENDIF(BUILD_IDAS)
+
+# KINSOL library
+IF(BUILD_KINSOL)
+  ADD_SUBDIRECTORY(kinsol)
+  IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+    ADD_SUBDIRECTORY(kinsol/fcmix)
+  ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+ENDIF(BUILD_KINSOL)
+
+# CPODES library
+IF(BUILD_CPODES)
+  ADD_SUBDIRECTORY(cpodes)
+ENDIF(BUILD_CPODES)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50a8d0c3e3c68c8c86b160d052d75aa7fd52a9ba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/CMakeLists.txt
@@ -0,0 +1,153 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the ARKODE library
+
+INSTALL(CODE "MESSAGE(\"\nInstall ARKODE\n\")")
+
+# Add variable arkode_SOURCES with the sources for the ARKODE library
+SET(arkode_SOURCES
+  arkode.c
+  arkode_adapt.c
+  arkode_arkstep.c
+  arkode_arkstep_io.c
+  arkode_arkstep_nls.c
+  arkode_bandpre.c
+  arkode_bbdpre.c
+  arkode_butcher.c
+  arkode_butcher_dirk.c
+  arkode_butcher_erk.c
+  arkode_erkstep.c
+  arkode_erkstep_io.c
+  arkode_interp.c
+  arkode_io.c
+  arkode_ls.c
+  arkode_mristep.c
+  arkode_mristep_io.c
+  arkode_root.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the ARKODE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_direct.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_version.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/nvector/serial/nvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the ARKODE library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/sunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/sunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/sunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the ARKODE library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/sunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/sunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/sunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/sunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/sunlinsol_pcg.c
+  )
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources which will
+# also be included in the ARKODE library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/sunnonlinsol_newton.c
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/fixedpoint/sunnonlinsol_fixedpoint.c
+  )
+
+# Add variable arkode_HEADERS with the exported ARKODE header files
+SET(arkode_HEADERS
+  arkode.h
+  arkode_arkstep.h
+  arkode_bandpre.h
+  arkode_bbdpre.h
+  arkode_butcher.h
+  arkode_butcher_erk.h
+  arkode_butcher_dirk.h
+  arkode_erkstep.h
+  arkode_ls.h
+  arkode_mristep.h
+  )
+
+# Add prefix with complete path to the ARKODE header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/arkode/ arkode_HEADERS)
+
+# Add source directories to include directories for access to
+# implementation only header files.
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(../sundials)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Build the static library
+IF(BUILD_STATIC_LIBS)
+
+  # Add the build target for the static ARKODE library
+  ADD_LIBRARY(sundials_arkode_static STATIC
+    ${arkode_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES} ${sunnonlinsol_SOURCES})
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_arkode_static
+    PROPERTIES OUTPUT_NAME sundials_arkode CLEAN_DIRECT_OUTPUT 1)
+
+  # Install the ARKODE library
+  INSTALL(TARGETS sundials_arkode_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_STATIC_LIBS)
+
+# Build the shared library
+IF(BUILD_SHARED_LIBS)
+
+  # Add the build target for the ARKODE library
+  ADD_LIBRARY(sundials_arkode_shared SHARED
+    ${arkode_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES} ${sunnonlinsol_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_arkode_shared m)
+  ENDIF()
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_arkode_shared
+    PROPERTIES OUTPUT_NAME sundials_arkode CLEAN_DIRECT_OUTPUT 1)
+
+  # Set VERSION and SOVERSION for shared libraries
+  SET_TARGET_PROPERTIES(sundials_arkode_shared
+    PROPERTIES VERSION ${arkodelib_VERSION} SOVERSION ${arkodelib_SOVERSION})
+
+  # Install the ARKODE library
+  INSTALL(TARGETS sundials_arkode_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the ARKODE header files
+INSTALL(FILES ${arkode_HEADERS} DESTINATION include/arkode)
+
+#
+MESSAGE(STATUS "Added ARKODE module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/README b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/README
new file mode 100644
index 0000000000000000000000000000000000000000..6f476557ae34dc0d71a487371b49746b99e6f185
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/README
@@ -0,0 +1,73 @@
+                             ARKODE
+                    Release 3.1.0, Feb 2019
+                       Daniel R. Reynolds
+                  Department of Mathematics, SMU
+
+ARKODE is a solver for multi-rate ODE systems (initial value problems) 
+given in explicit form M*dy/dt = f(t,y). It is written in ANSI standard C.
+
+ARKODE can be used both on serial and parallel (MPI) computers.  The main
+difference is in the NVECTOR module of vector kernels.  The desired
+version is obtained when compiling the example files by linking the
+appropriate library of NVECTOR kernels.  In the parallel version,
+communication between processors is done with the MPI (Message Passage
+Interface) system, with OpenMP, or with Pthreads.
+
+When used with the serial NVECTOR module, ARKODE provides both direct (dense 
+and band) and preconditioned Krylov (iterative) linear solvers. Many different
+iterative solvers are available: scaled preconditioned GMRES (SPGMR), 
+scaled preconditioned Flexible GMRES (SPFGMR), scaled preconditioned 
+conjugate gradient, scaled preconditioned BiCGStab (SPBCG), 
+and scaled preconditioned TFQMR (SPTFQMR). When ARKODE is used with 
+the parallel NVECTOR module, only the Krylov linear solvers are available. 
+For the serial version, there is a banded preconditioner module called 
+ARKBANDPRE available for use with the Krylov solvers, while for the 
+parallel version there is a preconditioner module called ARKBBDPRE 
+which provides a band-block-diagonal preconditioner.
+
+ARKODE is part of a software family called SUNDIALS: SUite of Nonlinear
+and DIfferential/ALgebraic equation Solvers.  This suite consists of
+ARKODE, CVODE, CVODES, KINSOL, IDAS, and IDA.  The directory structure 
+of the package supplied reflects this family relationship. 
+
+For use with Fortran applications, a set of Fortran/C interface routines,
+called FARKODE, is also supplied.  These are written in C, but assume that
+the user calling program and all user-supplied routines are in Fortran.
+
+The notes below provide the location of documentation, directions for the 
+installation of the ARKode package, and relevant references. Following that 
+is a brief history of revisions to the package.
+
+
+A. Documentation
+----------------
+
+/sundials/doc/arkode/ contains PDF files for the ARKODE User Guide [1]
+(ark_guide.pdf) and the ARKODE Examples [2] (ark_examples.pdf) documents.
+
+
+B. Installation
+---------------
+
+For basic installation instructions see the file /sundials/INSTALL_GUIDE.pdf. 
+For complete installation instructions see the "Installation Procedure"
+chapter in the ARKODE User Guide.
+
+
+C. Releases
+-----------
+
+v. 3.1.0       - Feb. 2019
+v. 3.0.2       - Jan. 2019
+v. 3.0.1       - Dec. 2018
+v. 3.0.0       - Dec. 2018
+v. 2.2.1       - Oct. 2018
+v. 2.2.0       - Sep. 2018
+v. 2.1.2       - Jul. 2018
+v. 2.1.1       - May  2018
+v. 2.1.0       - Nov. 2017
+v. 2.0.0       - Sep. 2017
+v. 1.1.0       - Sep. 2016
+v. 1.0.2       - Aug. 2015
+v. 1.0.1       - Mar. 2015
+v. 1.0.0       - Mar. 2015
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/fcmix/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/fcmix/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12b6b542c51eab10f5050cd1b8add2d0d5417312
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/arkode/fcmix/CMakeLists.txt
@@ -0,0 +1,117 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the FARKODE library
+
+# Add variable farkode_SOURCES with the sources for the FARKODE library
+SET(farkode_SOURCES
+  farkadapt.c
+  farkband.c
+  farkbandmass.c
+  farkbbd.c
+  farkbp.c
+  farkdense.c
+  farkdensemass.c
+  farkewt.c
+  farkexpstab.c
+  farkjtimes.c
+  farkmtimes.c
+  farknullnonlinsol.c
+  farknulllinsol.c
+  farknullmatrix.c
+  farkode.c
+  farkpreco.c
+  farkmasspreco.c
+  farkroot.c
+  farksparse.c
+  farksparsemass.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the ARKODE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/nvector/serial/fnvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the ARKODE library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/fsunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/fsunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/fsunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the ARKODE library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/fsunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/fsunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/fsunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/fsunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/fsunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/fsunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/fsunlinsol_pcg.c
+  )
+
+IF(KLU_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/klu/fsunlinsol_klu.c
+    )
+ENDIF()
+
+IF(SUPERLUMT_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/superlumt/fsunlinsol_superlumt.c
+    )
+ENDIF()
+
+IF(LAPACK_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackband/fsunlinsol_lapackband.c
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackdense/fsunlinsol_lapackdense.c
+    )
+ENDIF()
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the ARKODE library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol_newton/fsunnonlinsol_newton.c
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol_fixedpoint/fsunnonlinsol_fixedpoint.c
+  )
+
+
+# Add source directories to include directories for access to
+# implementation only header files (both for farkode and arkode)
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(..)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Only build STATIC libraries (we cannot build shared libraries
+# for the FCMIX interfaces due to unresolved symbol errors
+# coming from inexistent user-provided functions)
+
+# Add the build target for the FARKODE library
+ADD_LIBRARY(sundials_farkode_static STATIC
+  ${farkode_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES})
+
+# Set the library name and make sure it is not deleted
+SET_TARGET_PROPERTIES(sundials_farkode_static
+  PROPERTIES OUTPUT_NAME sundials_farkode CLEAN_DIRECT_OUTPUT 1)
+
+# Install the FARKODE library
+INSTALL(TARGETS sundials_farkode_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+#
+MESSAGE(STATUS "Added ARKODE FCMIX module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a97073005cea8bafbf241b1aa3bf41e41c7a5ecc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/CMakeLists.txt
@@ -0,0 +1,147 @@
+# ---------------------------------------------------------------
+# Programmer(s):  Daniel R. Reynolds @ SMU
+#                 Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the CVODE library
+
+INSTALL(CODE "MESSAGE(\"\nInstall CVODE\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable cvode_SOURCES with the sources for the CVODE library
+SET(cvode_SOURCES
+  cvode.c
+  cvode_bandpre.c
+  cvode_bbdpre.c
+  cvode_diag.c
+  cvode_direct.c
+  cvode_io.c
+  cvode_ls.c
+  cvode_nls.c
+  cvode_spils.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the CVODE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_direct.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_version.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/nvector/serial/nvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the CVODE library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/sunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/sunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/sunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the CVODE library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/sunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/sunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/sunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/sunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/sunlinsol_pcg.c
+  )
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the CVODE library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/sunnonlinsol_newton.c
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/fixedpoint/sunnonlinsol_fixedpoint.c
+  )
+
+# Add variable cvode_HEADERS with the exported CVODE header files
+SET(cvode_HEADERS
+  cvode.h
+  cvode_bandpre.h
+  cvode_bbdpre.h
+  cvode_diag.h
+  cvode_direct.h
+  cvode_ls.h
+  cvode_spils.h
+  )
+
+# Add prefix with complete path to the CVODE header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/cvode/ cvode_HEADERS)
+
+# Add source directories to include directories for access to
+# implementation only header files.
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(../sundials)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Build the static library
+IF(BUILD_STATIC_LIBS)
+  # Add the build target for the static CVODE library
+  ADD_LIBRARY(sundials_cvode_static STATIC
+    ${cvode_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES} ${sunnonlinsol_SOURCES}
+  )
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_cvode_static
+    PROPERTIES OUTPUT_NAME sundials_cvode CLEAN_DIRECT_OUTPUT 1)
+
+  # Install the CVODE library
+  INSTALL(TARGETS sundials_cvode_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_STATIC_LIBS)
+
+# Build the shared library
+IF(BUILD_SHARED_LIBS)
+  # Add the build target for the shared CVODE library
+  ADD_LIBRARY(sundials_cvode_shared SHARED
+    ${cvode_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES} ${sunnonlinsol_SOURCES}
+  )
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_cvode_shared m)
+  ENDIF()
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_cvode_shared
+    PROPERTIES OUTPUT_NAME sundials_cvode CLEAN_DIRECT_OUTPUT 1)
+
+  # Set VERSION and SOVERSION for shared libraries
+  SET_TARGET_PROPERTIES(sundials_cvode_shared
+    PROPERTIES VERSION ${cvodelib_VERSION} SOVERSION ${cvodelib_SOVERSION})
+
+  # Install the CVODE library
+  INSTALL(TARGETS sundials_cvode_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the CVODE header files
+INSTALL(FILES ${cvode_HEADERS} DESTINATION include/cvode)
+
+#
+MESSAGE(STATUS "Added CVODE module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1c5ae29460ebb42bcd7adea2a9f6201a59a34030
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/F90/CMakeLists.txt
@@ -0,0 +1,116 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 CVODE object library
+
+set(cvode_SOURCES fcvode.f90)
+
+# Add variable nvec_SOURCES with the common NVECTOR sources which will
+# also be included in the CVODE library
+set(nvec_SOURCES
+  ${sundials_SOURCE_DIR}/src/nvector/serial/F90/fnvector_serial.f90
+)
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the CVODE library
+set(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/F90/fsunmatrix_band.f90
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/F90/fsunmatrix_dense.f90
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/F90/fsunmatrix_sparse.f90
+)
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the CVODE library
+set(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/F90/fsunlinsol_band.f90
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/F90/fsunlinsol_dense.f90
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/F90/fsunlinsol_spbcgs.f90
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/F90/fsunlinsol_spfgmr.f90
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/F90/fsunlinsol_spgmr.f90
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/F90/fsunlinsol_sptfqmr.f90
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/F90/fsunlinsol_pcg.f90
+)
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the CVODE library
+set(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/F90/fsunnonlinsol_newton.f90
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/fixedpoint/F90/fsunnonlinsol_fixedpoint.f90
+)
+
+# Set the Fortran module directory to a temporary location.
+# We do this to avoid naming collisions in parallel builds (make -j).
+# The .mod files generated when building the fcvode_mod library are
+# duplicates of the .mod files generated by the SUNDIALS modules themselves.
+# As such, we do not need to keep them around.
+set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/tmp)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fcvode_mod_static STATIC
+    ${cvode_SOURCES}
+    ${nvec_SOURCES}
+    ${sunmatrix_SOURCES}
+    ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES}
+  )
+
+  # include the directoy where the .mod files reside
+  target_include_directories(sundials_fcvode_mod_static
+    PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_Fortran_MODULE_DIRECTORY}_STATIC>
+      $<INSTALL_INTERFACE:${Fortran_INSTALL_MODDIR}>
+  )
+
+  # Set the library name and make sure it is not deleted
+  set_target_properties(sundials_fcvode_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fcvode_mod CLEAN_DIRECT_OUTPUT 1)
+
+  # install the library
+  install(TARGETS sundials_fcvode_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  # install the cvode mod file from here since it won't go into the
+  # top level fortran mod file directory
+  install(FILES ${CMAKE_Fortran_MODULE_DIRECTORY}_STATIC/fcvode_mod.mod
+          DESTINATION ${Fortran_INSTALL_MODDIR})
+endif()
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fcvode_mod_shared SHARED
+    ${cvode_SOURCES}
+    ${nvec_SOURCES}
+    ${sunmatrix_SOURCES}
+    ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES}
+  )
+
+  # include the directoy where the .mod files reside
+  target_include_directories(sundials_fcvode_mod_shared
+    PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_Fortran_MODULE_DIRECTORY}_SHARED>
+      $<INSTALL_INTERFACE:${Fortran_INSTALL_MODDIR}>
+  )
+
+  # Set the library name and make sure it is not deleted
+  set_target_properties(sundials_fcvode_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fcvode_mod CLEAN_DIRECT_OUTPUT 1)
+
+  # install the library
+  install(TARGETS sundials_fcvode_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  # install the cvode mod file from here since it won't go into the
+  # top level fortran mod file directory
+  install(FILES ${CMAKE_Fortran_MODULE_DIRECTORY}_SHARED/fcvode_mod.mod
+          DESTINATION ${Fortran_INSTALL_MODDIR})
+endif()
+
+message(STATUS "Added CVODE F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/F90/fcvode.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/F90/fcvode.f90
new file mode 100644
index 0000000000000000000000000000000000000000..148235146b944292b1022f0ef3b42d0da2551dc1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/F90/fcvode.f90
@@ -0,0 +1,887 @@
+! ------------------------------------------------------------------
+! Programmer(s): David J. Gardner @ LLNL
+!                Daniel R. Reynolds @ SMU
+! ------------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! ------------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! CVODE using the ISO_C_BINDING module.
+! ------------------------------------------------------------------
+
+module fcvode_mod
+
+  use, intrinsic :: iso_c_binding, only : c_int
+
+  ! =================================================================
+  !              C V O D E     C O N S T A N T S
+  ! =================================================================
+
+  ! -----------------------------------------------------------------
+  ! Enumerations for inputs to CVodeCreate and CVode.
+  ! -----------------------------------------------------------------
+
+  ! lmm
+  integer(c_int), parameter :: CV_ADAMS = 1
+  integer(c_int), parameter :: CV_BDF   = 2
+
+  ! itask
+  integer(c_int), parameter :: CV_NORMAL   = 1
+  integer(c_int), parameter :: CV_ONE_STEP = 2
+
+  ! -----------------------------------------------------------------
+  ! CVODE return flags
+  ! -----------------------------------------------------------------
+
+  integer(c_int), parameter :: CV_SUCCESS           =   0
+  integer(c_int), parameter :: CV_TSTOP_RETURN      =   1
+  integer(c_int), parameter :: CV_ROOT_RETURN       =   2
+
+  integer(c_int), parameter :: CV_WARNING           =  99
+
+  integer(c_int), parameter :: CV_TOO_MUCH_WORK     =  -1
+  integer(c_int), parameter :: CV_TOO_MUCH_ACC      =  -2
+  integer(c_int), parameter :: CV_ERR_FAILURE       =  -3
+  integer(c_int), parameter :: CV_CONV_FAILURE      =  -4
+
+  integer(c_int), parameter :: CV_LINIT_FAIL        =  -5
+  integer(c_int), parameter :: CV_LSETUP_FAIL       =  -6
+  integer(c_int), parameter :: CV_LSOLVE_FAIL       =  -7
+  integer(c_int), parameter :: CV_RHSFUNC_FAIL      =  -8
+  integer(c_int), parameter :: CV_FIRST_RHSFUNC_ERR =  -9
+  integer(c_int), parameter :: CV_REPTD_RHSFUNC_ERR =  -10
+  integer(c_int), parameter :: CV_UNREC_RHSFUNC_ERR =  -11
+  integer(c_int), parameter :: CV_RTFUNC_FAIL       =  -12
+  integer(c_int), parameter :: CV_NLS_INIT_FAIL     =  -13
+  integer(c_int), parameter :: CV_NLS_SETUP_FAIL    =  -14
+  integer(c_int), parameter :: CV_CONSTR_FAIL       =  -15
+
+  integer(c_int), parameter :: CV_MEM_FAIL          =  -20
+  integer(c_int), parameter :: CV_MEM_NULL          =  -21
+  integer(c_int), parameter :: CV_ILL_INPUT         =  -22
+  integer(c_int), parameter :: CV_NO_MALLOC         =  -23
+  integer(c_int), parameter :: CV_BAD_K             =  -24
+  integer(c_int), parameter :: CV_BAD_T             =  -25
+  integer(c_int), parameter :: CV_BAD_DKY           =  -26
+  integer(c_int), parameter :: CV_TOO_CLOSE         =  -27
+  integer(c_int), parameter :: CV_VECTOROP_ERR      =  -28
+
+  ! -----------------------------------------------------------------
+  ! CVLS return values
+  ! -----------------------------------------------------------------
+
+  integer(c_int), parameter :: CVLS_SUCCESS         =  0
+  integer(c_int), parameter :: CVLS_MEM_NULL        = -1
+  integer(c_int), parameter :: CVLS_LMEM_NULL       = -2
+  integer(c_int), parameter :: CVLS_ILL_INPUT       = -3
+  integer(c_int), parameter :: CVLS_MEM_FAIL        = -4
+  integer(c_int), parameter :: CVLS_PMEM_NULL       = -5
+  integer(c_int), parameter :: CVLS_JACFUN_UNRECVR  = -6
+  integer(c_int), parameter :: CVLS_JACFUNC_RECVR   = -7
+  integer(c_int), parameter :: CVLS_SUNMAT_FAIL     = -8
+  integer(c_int), parameter :: CVLS_SUNLS_FAIL      = -9
+
+  ! -----------------------------------------------------------------
+  ! CVDIAG return values
+  ! -----------------------------------------------------------------
+
+  integer(c_int), parameter :: CVDIAG_SUCCESS         =  0
+  integer(c_int), parameter :: CVDIAG_MEM_NULL        = -1
+  integer(c_int), parameter :: CVDIAG_LMEM_NULL       = -2
+  integer(c_int), parameter :: CVDIAG_ILL_INPUT       = -3
+  integer(c_int), parameter :: CVDIAG_MEM_FAIL        = -4
+
+  ! Additional last_flag values
+  integer(c_int), parameter :: CVDIAG_INV_FAIL        = -5
+  integer(c_int), parameter :: CVDIAG_RHSFUNC_UNRECVR = -6
+  integer(c_int), parameter :: CVDIAG_RHSFUNC_RECVR   = -7
+
+  ! =================================================================
+  !          U S E R - C A L L A B L E   R O U T I N E S
+  ! =================================================================
+
+  interface
+
+     ! =================================================================
+     ! Interfaces for cvode.h
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! CVodeCreate
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FCVodeCreate(lmm) &
+          bind(C,name='CVodeCreate')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_int), value :: lmm
+     end function FCVodeCreate
+
+     ! -----------------------------------------------------------------
+     ! Integrator optional input specification functions
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeSetErrHandlerFn(cvode_mem, ehfun, eh_data) &
+          bind(C,name='CVodeSetErrHandlerFn')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       type(c_funptr), value :: ehfun
+       type(c_ptr),    value :: eh_data
+     end function FCVodeSetErrHandlerFn
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: CVodeSetErrFile
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeSetUserData(cvode_mem, user_data) &
+          bind(C,name='CVodeSetUserData')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       type(c_ptr), value :: user_data
+     end function FCVodeSetUserData
+
+     integer(c_int) function FCVodeSetMaxOrd(cvode_mem, maxord) &
+          bind(C,name='CVodeSetMaxOrd')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: maxord
+     end function FCVodeSetMaxOrd
+
+     integer(c_int) function FCVodeSetMaxNumSteps(cvode_mem, mxsteps) &
+          bind(C,name='CVodeSetMaxNumSteps')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),     value :: cvode_mem
+       integer(c_long), value :: mxsteps
+     end function FCVodeSetMaxNumSteps
+
+     integer(c_int) function FCVodeSetMaxHnilWarns(cvode_mem, mxhnil) &
+          bind(C,name='CVodeSetMaxHnilWarns')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: mxhnil
+     end function FCVodeSetMaxHnilWarns
+
+     integer(c_int) function FCVodeSetStabLimDet(cvode_mem, stldet) &
+          bind(C,name='CVodeSetStabLimDet')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: stldet
+     end function FCVodeSetStabLimDet
+
+     integer(c_int) function FCVodeSetInitStep(cvode_mem, hin) &
+          bind(C,name='CVodeSetInitStep')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: hin
+     end function FCVodeSetInitStep
+
+     integer(c_int) function FCVodeSetMinStep(cvode_mem, hmin) &
+          bind(C,name='CVodeSetMinStep')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: hmin
+     end function FCVodeSetMinStep
+
+     integer(c_int) function FCVodeSetMaxStep(cvode_mem, hmax) &
+          bind(C,name='CVodeSetMaxStep')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: hmax
+     end function FCVodeSetMaxStep
+
+     integer(c_int) function FCVodeSetStopTime(cvode_mem, tstop) &
+          bind(C,name='CVodeSetStopTime')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: tstop
+     end function FCVodeSetStopTime
+
+     integer(c_int) function FCVodeSetMaxErrTestFails(cvode_mem, maxnef) &
+          bind(C,name='CVodeSetMaxErrTestFails')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: maxnef
+     end function FCVodeSetMaxErrTestFails
+
+     integer(c_int) function FCVodeSetMaxNonlinIters(cvode_mem, maxcor) &
+          bind(C,name='CVodeSetMaxNonlinIters')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: maxcor
+     end function FCVodeSetMaxNonlinIters
+
+     integer(c_int) function FCVodeSetMaxConvFails(cvode_mem, maxncf) &
+          bind(C,name='CVodeSetMaxConvFails')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: maxncf
+     end function FCVodeSetMaxConvFails
+
+     integer(c_int) function FCVodeSetNonlinConvCoef(cvode_mem, nlscoef) &
+          bind(C,name='CVodeSetNonlinConvCoef')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: nlscoef
+     end function FCVodeSetNonlinConvCoef
+
+     integer(c_int) function FCVodeSetConstraints(cvode_mem, constraints) &
+         bind(C,name='CVodeSetConstraints')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       type(c_ptr), value :: constraints
+     end function FCVodeSetConstraints
+
+     integer(c_int) function FCVodeSetIterType(cvode_mem, iter) &
+          bind(C,name='CVodeSetIterType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: iter
+     end function FCVodeSetIterType
+
+     integer(c_int) function FCVodeSetRootDirection(cvode_mem, rootdir) &
+          bind(C,name='CVodeSetRootDirection')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       real(c_double)     :: rootdir
+     end function FCVodeSetRootDirection
+
+     integer(c_int) function FCVodeSetNoInactiveRootWarn(cvode_mem) &
+         bind(C,name='CVodeSetNoInactiveRootWarn')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+     end function FCVodeSetNoInactiveRootWarn
+
+     integer(c_int) function FCVodeSetNonlinearSolver(cvode_mem, NLS) &
+        bind(C,name='CVodeSetNonlinearSolver')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       type(c_ptr), value :: NLS
+     end function FCVodeSetNonlinearSolver
+
+     ! -----------------------------------------------------------------
+     ! CVodeInit
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeInit(cvode_mem, f, t0, y0) &
+          bind(C,name='CVodeInit')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       type(c_funptr), value :: f
+       real(c_double), value :: t0
+       type(c_ptr),    value :: y0
+     end function FCVodeInit
+
+     ! -----------------------------------------------------------------
+     ! CVodeReInit
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeReInit(cvode_mem, t0, y0) &
+          bind(C,name='CVodeReInit')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: t0
+       type(c_ptr),    value :: y0
+     end function FCVodeReInit
+
+     ! -----------------------------------------------------------------
+     ! CVodeSStolerances
+     ! CVodeSVtolerances
+     ! CVodeWFtolerances
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeSStolerances(cvode_mem, reltol, abstol) &
+          bind(C,name='CVodeSStolerances')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: reltol
+       real(c_double), value :: abstol
+     end function FCVodeSStolerances
+
+     integer(c_int) function FCVodeSVtolerances(cvode_mem, reltol, abstol) &
+          bind(C,name='CVodeSVtolerances')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: reltol
+       type(c_ptr),    value :: abstol
+     end function FCVodeSVtolerances
+
+     integer(c_int) function FCVodeWFtolerances(cvode_mem, efun) &
+          bind(C,name='CVodeWFtolerances')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       type(c_funptr), value :: efun
+     end function FCVodeWFtolerances
+
+     ! -----------------------------------------------------------------
+     ! CVodeRootInit
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeRootInit(cvode_mem, nrtfn, g) &
+          bind(C,name='CVodeRootInit')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       integer(c_int), value :: nrtfn
+       type(c_funptr), value :: g
+     end function FCVodeRootInit
+
+     ! -----------------------------------------------------------------
+     ! CVode
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVode(cvode_mem, tout, yout, tret, itask) &
+          bind(C,name='CVode')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: tout
+       type(c_ptr),    value :: yout
+       real(c_double)        :: tret
+       integer(c_int), value :: itask
+     end function FCVode
+
+     ! -----------------------------------------------------------------
+     ! CVodeGetDky
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeGetDky(cvode_mem, t, k, dky) &
+          bind(C,name='CVodeGetDky')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: t
+       integer(c_int), value :: k
+       type(c_ptr),    value :: dky
+     end function FCVodeGetDky
+
+     ! -----------------------------------------------------------------
+     ! Integrator optional output extraction functions
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeGetWorkSpace(cvode_mem, lenrw, leniw) &
+          bind(C,name='CVodeGetWorkSpace')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: lenrw
+       integer(c_long)    :: leniw
+     end function FCVodeGetWorkSpace
+
+     integer(c_int) function FCVodeGetNumSteps(cvode_mem, nsteps) &
+          bind(C,name='CVodeGetNumSteps')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nsteps
+     end function FCVodeGetNumSteps
+
+     integer(c_int) function FCVodeGetNumRhsEvals(cvode_mem, nfevals) &
+          bind(C,name='CVodeGetNumRhsEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nfevals
+     end function FCVodeGetNumRhsEvals
+
+     integer(c_int) function FCVodeGetNumLinSolvSetups(cvode_mem, nlinsetups) &
+          bind(C,name='CVodeGetNumLinSolvSetups')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nlinsetups
+     end function FCVodeGetNumLinSolvSetups
+
+     integer(c_int) function FCVodeGetNumErrTestFails(cvode_mem, netfails) &
+          bind(C,name='CVodeGetNumErrTestFails')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: netfails
+     end function FCVodeGetNumErrTestFails
+
+     integer(c_int) function FCVodeGetLastOrder(cvode_mem, qlast) &
+          bind(C,name='CVodeGetLastOrder')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_int)    :: qlast
+     end function FCVodeGetLastOrder
+
+     integer(c_int) function FCVodeGetCurrentOrder(cvode_mem, qcur) &
+          bind(C,name='CVodeGetCurrentOrder')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_int)     :: qcur
+     end function FCVodeGetCurrentOrder
+
+     integer(c_int) function FCVodeGetNumStabLimOrderReds(cvode_mem, nslred) &
+          bind(C,name='CVodeGetNumStabLimOrderReds')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nslred
+     end function FCVodeGetNumStabLimOrderReds
+
+     integer(c_int) function FCVodeGetActualInitStep(cvode_mem, hinused) &
+          bind(C,name='CVodeGetActualInitStep')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       real(c_double)     :: hinused
+     end function FCVodeGetActualInitStep
+
+     integer(c_int) function FCVodeGetLastStep(cvode_mem, hlast) &
+          bind(C,name='CVodeGetLastStep')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       real(c_double)     :: hlast
+     end function FCVodeGetLastStep
+
+     integer(c_int) function FCVodeGetCurrentStep(cvode_mem, hcur) &
+         bind(C,name='CVodeGetCurrentStep')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       real(c_double)     :: hcur
+     end function FCVodeGetCurrentStep
+
+     integer(c_int) function FCVodeGetCurrentTime(cvode_mem, tcur) &
+          bind(C,name='CVodeGetCurrentTime')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       real(c_double)     :: tcur
+     end function FCVodeGetCurrentTime
+
+     integer(c_int) function FCVodeGetTolScaleFactor(cvode_mem, tolsfac) &
+          bind(C,name='CVodeGetTolScaleFactor')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       real(c_double)     :: tolsfac
+     end function FCVodeGetTolScaleFactor
+
+     integer(c_int) function FCVodeGetErrWeights(cvode_mem, eweight) &
+          bind(C,name='CVodeGetEffWeights')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       type(c_ptr), value :: eweight
+     end function FCVodeGetErrWeights
+
+     integer(c_int) function FCVodeGetEstLocalErrors(cvode_mem, ele) &
+          bind(C,name='CVodeGetEstLocalErrors')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       type(c_ptr), value :: ele
+     end function FCVodeGetEstLocalErrors
+
+     integer(c_int) function FCVodeGetNumGEvals(cvode_mem, ngevals) &
+          bind(C,name='CVodeGetNumGEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: ngevals
+     end function FCVodeGetNumGEvals
+
+     integer(c_int) function FCVodeGetRootInfo(cvode_mem, rootsfound) &
+          bind(C,name='CVodeGetRootInfo')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_int)     :: rootsfound
+     end function FCVodeGetRootInfo
+
+     integer(c_int) function FCVodeGetIntegratorStats(cvode_mem, nsteps, nfevals, &
+          nlinsetups, netfails, qlast, qcur, hinused, hlast, hcur, tcur) &
+          bind(C,name='CVodeGetIntegratorStats')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nsteps
+       integer(c_long)    :: nfevals
+       integer(c_long)    :: nlinsetups
+       integer(c_long)    :: netfails
+       integer(c_int)     :: qlast
+       integer(c_int)     :: qcur
+       real(c_double)     :: hinused
+       real(c_double)     :: hlast
+       real(c_double)     :: hcur
+       real(c_double)     :: tcur
+     end function FCVodeGetIntegratorStats
+
+     ! -----------------------------------------------------------------
+     ! Nonlinear solver optional output extraction functions
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeGetNumNonlinSolvIters(cvode_mem, nniters) &
+          bind(C,name='CVodeGetNumNonlinSolvIters')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nniters
+     end function FCVodeGetNumNonlinSolvIters
+
+     integer(c_int) function FCVodeGetNumNonlinSolvConvFails(cvode_mem, nncfails) &
+          bind(C,name='CVodeGetNumNonlinSolvConvFails')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nncfails
+     end function FCVodeGetNumNonlinSolvConvFails
+
+     integer(c_int) function FCVodeGetNonlinSolvStats(cvode_mem, nniters, nncfails) &
+          bind(C,name='CVodeGetNonlinSolvStats')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nniters
+       integer(c_long)    :: nncfails
+     end function FCVodeGetNonlinSolvStats
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: CVodeGetReturnFlagName
+     ! -----------------------------------------------------------------
+
+     ! -----------------------------------------------------------------
+     ! CVodeFree
+     ! -----------------------------------------------------------------
+
+     subroutine FCVodeFree(cvode_mem) &
+          bind(C,name='CVodeFree')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr) :: cvode_mem ! DO NOT use value attribute input is void**
+     end subroutine FCVodeFree
+
+     ! =================================================================
+     ! Interfaces from cvode_ls.h
+     ! =================================================================
+
+     integer(c_int) function FCVodeSetLinearSolver(cvode_mem, LS, A) &
+          bind(C,name='CVodeSetLinearSolver')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FCVodeSetLinearSolver
+
+     ! -----------------------------------------------------------------
+     ! Optional inputs to the CVLS linear solver
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeSetJacFn(cvode_mem, jac) &
+          bind(C,name='CVodeSetJacFn')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       type(c_funptr), value :: jac
+     end function FCVodeSetJacFn
+
+     integer(c_int) function FCVodeSetMaxStepsBetweenJac(cvode_mem, msbj) &
+          bind(C,name='CVodeSetMaxStepsBetweenJac')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),     value :: cvode_mem
+       integer(c_long), value :: msbj
+     end function FCVodeSetMaxStepsBetweenJac
+     
+     integer(c_int) function FCVodeSetEpsLin(cvode_mem, eplifac) &
+          bind(C,name='CVodeSetEpsLin')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       real(c_double), value :: eplifac
+     end function FCVodeSetEpsLin
+
+     integer(c_int) function FCVodeSetPreconditioner(cvode_mem, pset, psolve) &
+          bind(C,name='CVodeSetPreconditioner')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       type(c_funptr), value :: pset
+       type(c_funptr), value :: psolve
+     end function FCVodeSetPreconditioner
+
+     integer(c_int) function FCVodeSetJacTimes(cvode_mem, jtsetup, jtimes) &
+          bind(C,name='CVodeSetJacTimes')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: cvode_mem
+       type(c_funptr), value :: jtsetup
+       type(c_funptr), value :: jtimes
+     end function FCVodeSetJacTimes
+
+     ! -----------------------------------------------------------------
+     ! Optional outputs from the CVLS linear solver
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVodeGetLinWorkSpace(cvode_mem, lenrwLS, leniwLS) &
+          bind(C,name='CVodeGetLinWorkSpace')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FCVodeGetLinWorkSpace
+     
+     integer(c_int) function FCVodeGetNumJacEvals(cvode_mem, njevals) &
+          bind(C,name='CVodeGetNumJacEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: njevals
+     end function FCVodeGetNumJacEvals
+
+     integer(c_int) function FCVodeGetNumPrecEvals(cvode_mem, npevals) &
+         bind(C,name='CVodeGetNumPrecEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: npevals
+     end function FCVodeGetNumPrecEvals
+
+     integer(c_int) function FCVodeGetNumPrecSolves(cvode_mem, npsolves) &
+         bind(C,name='CVodeGetNumPrecSolves')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: npsolves
+     end function FCVodeGetNumPrecSolves
+
+     integer(c_int) function FCVodeGetNumLinIters(cvode_mem, nliters) &
+         bind(C,name='CVodeGetNumLinIters')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nliters
+     end function FCVodeGetNumLinIters
+
+     integer(c_int) function FCVodeGetNumLinConvFails(cvode_mem, nlcfails) &
+         bind(C,name='CVodeGetNumLinConvFails')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nlcfails
+     end function FCVodeGetNumLinConvFails
+
+     integer(c_int) function FCVodeGetNumJTSetupEvals(cvode_mem, njtsetups) &
+         bind(C,name='CVodeGetNumJTSetupEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: njtsetups
+     end function FCVodeGetNumJTSetupEvals
+
+     integer(c_int) function FCVodeGetNumJtimesEvals(cvode_mem, njvevals) &
+         bind(C,name='CVodeGetNumJtimesEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: njvevals
+     end function FCVodeGetNumJtimesEvals
+
+     integer(c_int) function FCVodeGetNumLinRhsEvals(cvode_mem, nfevalsLS) &
+          bind(C,name='CVodeGetNumLinRhsEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nfevalsLS
+     end function FCVodeGetNumLinRhsEvals
+
+     integer(c_int) function FCVodeGetLastLinFlag(cvode_mem, flag) &
+          bind(C,name='CVodeGetLastLinFlag')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: flag
+     end function FCVodeGetLastLinFlag
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: CVodeGetLinReturnFlagName
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Interfaces for cvode_diag.h
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! CVDiag
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVDiag(cvode_mem) &
+          bind(C,name='CVDiag')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+     end function FCVDiag
+
+     ! -----------------------------------------------------------------
+     ! Optional outputs from the CVDIAG linear solver
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVDiagGetWorkSpace(cvode_mem, lenrwLS, leniwLS) &
+          bind(C,name='CVDiagGetWorkSpace')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FCVDiagGetWorkSpace
+
+     integer(c_int) function FCVDiagGetNumRhsEvals(cvode_mem, nfevalsLS) &
+          bind(C,name='CVDiagGetNumRhsEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nfevalsLS
+     end function FCVDiagGetNumRhsEvals
+
+     integer(c_int) function FCVDiagGetLastFlag(cvode_mem, flag) &
+          bind(C,name='CVDiagGetLastFlag')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: flag
+     end function FCVDiagGetLastFlag
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: CVDiagGetReturnFlagName
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Interfaces from cvode_bandpre.h
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! CVBandPrecInit
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVBandPrecInit(cvode_mem, N, mu, ml) &
+          bind(C,name='CVBandPrecInit')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),     value :: cvode_mem
+       integer(c_long), value :: N
+       integer(c_long), value :: mu
+       integer(c_long), value :: ml
+     end function FCVBandPrecInit
+
+     ! -----------------------------------------------------------------
+     ! Optional output functions : CVBandPrecGet*
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVBandPrecGetWorkSpace(cvode_mem, lenrwLS, leniwLS) &
+          bind(C,name='CVBandPrecGetWorkSpace')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FCVBandPrecGetWorkSpace
+
+     integer(c_int) function FCVBandPrecGetNumRhsEvals(cvode_mem, nfevalsBP) &
+          bind(C,name='CVBandPrecGetNumRhsEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: nfevalsBP
+     end function FCVBandPrecGetNumRhsEvals
+
+     ! =================================================================
+     ! Interfaces for cvode_bbdpre.h
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! CVBBDPrecInit
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVBBDPrecInit(cvode_mem, Nlocal, mudq, mldq, &
+          mukeep, mlkeep, dqrely, gloc, cfn) &
+          bind(C,name='CVBBDPrecInit')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),     value :: cvode_mem
+       integer(c_long), value :: Nlocal
+       integer(c_long), value :: mudq
+       integer(c_long), value :: mldq
+       integer(c_long), value :: mukeep
+       integer(c_long), value :: mlkeep
+       real(c_double),  value :: dqrely
+       type(c_funptr),  value :: gloc
+       type(c_funptr),  value :: cfn
+     end function FCVBBDPrecInit
+
+     ! -----------------------------------------------------------------
+     ! CVBBDPrecReInit
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVBBDPrecReInit(cvode_mem, mudq, mldq, dqrely) &
+          bind(C,name='CVBBNPrecReInit')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),     value :: cvode_mem
+       integer(c_long), value :: mudq
+       integer(c_long), value :: mldq
+       real(c_double),  value :: dqrely
+     end function FCVBBDPrecReInit
+
+     ! -----------------------------------------------------------------
+     ! BBDPRE optional output extraction routines
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FCVBBDPrecGetWorkSpace(cvode_mem, lenrwLS, leniwLS) &
+          bind(C,name='CVBBDPrecGetWorkSpace')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FCVBBDPrecGetWorkSpace
+
+     integer(c_int) function FCVBBDPrecGetNumGfnEvals(cvode_mem, ngevalsBBDP) &
+          bind(C,name='CVBBDPrecGetNumGfnEvals')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: cvode_mem
+       integer(c_long)    :: ngevalsBBDP
+     end function FCVBBDPrecGetNumGfnEvals
+
+  end interface
+
+end module fcvode_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/README b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/README
new file mode 100644
index 0000000000000000000000000000000000000000..b6344ba135a94c6d52ed08f6d1a8e0dd47f96c32
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/README
@@ -0,0 +1,102 @@
+                               CVODE
+                      Release 4.1.0, Feb 2019
+                 Alan C. Hindmarsh and Radu Serban
+            Center for Applied Scientific Computing, LLNL
+
+CVODE is a solver for stiff and nonstiff ODE systems (initial value problem) 
+given in explicit form dy/dt = f(t,y). It is written in ANSI standard C.
+
+CVODE can be used both on serial and parallel computers.  The main
+difference is in the NVECTOR module of vector kernels.  The desired
+version is obtained when compiling the example files by linking the
+appropriate library of NVECTOR kernels.  In the parallel versions,
+communication between processors is done with MPI, with OpenMP, or with Pthreads.
+
+When used with the serial NVECTOR module, CVODE provides both direct (dense 
+and band) and preconditioned Krylov (iterative) linear solvers. Three different
+iterative solvers are available: scaled preconditioned GMRES (SPGMR), scaled 
+preconditioned BiCGStab (SPBCG), and scaled preconditioned TFQMR (SPTFQMR). 
+When CVODE is used with the parallel NVECTOR module, only the Krylov linear solvers 
+are available. (An approximate diagonal Jacobian option is available with both 
+versions.)  For the serial version, there is a banded preconditioner module 
+called CVBANDPRE available for use with the Krylov solvers, while for the parallel 
+version there is a preconditioner module called CVBBDPRE which provides a
+band-block-diagonal preconditioner.
+
+CVODE is part of a software family called SUNDIALS: SUite of Nonlinear
+and DIfferential/ALgebraic equation Solvers.  This suite consists of
+CVODE, CVODES, ARKode, KINSOL, IDAS, and IDA, and variants of these.  
+The directory structure of the package supplied reflects this family 
+relationship.
+
+For use with Fortran applications, a set of Fortran/C interface routines,
+called FCVODE, is also supplied.  These are written in C, but assume that
+the user calling program and all user-supplied routines are in Fortran.
+
+The notes below provide the location of documentation, directions for the 
+installation of the CVODE package, and relevant references. Following that 
+is a brief history of revisions to the package.
+
+
+A. Documentation
+----------------
+
+/sundials/doc/cvode/ contains PDF files for the CVODE User Guide [1] (cv_guide.pdf)
+and the CVODE Examples [2] (cv_examples.pdf) documents.
+
+
+B. Installation
+---------------
+
+For basic installation instructions see the file /sundials/INSTALL_GUIDE.pdf. 
+For complete installation instructions see the "Installation Procedure"
+chapter in the CVODE User Guide.
+
+
+C. References
+-------------
+
+[1] A. C. Hindmarsh and R. Serban, "User Documentation for CVODE v2.9.0," 
+    LLNL technical report UCRL-SM-208108, March 2016.
+
+[2] A. C. Hindmarsh and R. Serban, "Example Programs for CVODE v2.9.0," 
+    LLNL technical report UCRL-SM-208110, March 2016.
+
+[3] S.D. Cohen and A.C. Hindmarsh, "CVODE, a Stiff/nonstiff ODE Solver in C,"
+    Computers in Physics, 10(2), pp. 138-143, 1996.
+
+[4] A. C. Hindmarsh, P. N. Brown, K. E. Grant, S. L. Lee, R. Serban, 
+    D. E. Shumaker, and C. S. Woodward, "SUNDIALS, Suite of Nonlinear and 
+    Differential/Algebraic Equation Solvers," ACM Trans. Math. Softw., 
+    31(3), pp. 363-396, 2005.
+
+
+D. Releases
+-----------
+
+v. 4.1.0       - Feb. 2019
+v. 4.0.2       - Jan. 2019
+v. 4.0.1       - Dec. 2018
+v. 4.0.0       - Dec. 2018
+v. 3.2.1       - Oct. 2018
+v. 3.2.0       - Sep. 2018
+v. 3.1.2       - Jul. 2018
+v. 3.1.1       - May  2018
+v. 3.1.0       - Nov. 2017
+v. 3.0.0       - Sep. 2017
+v. 2.9.0       - Sep. 2016
+v. 2.8.2       - Aug. 2015
+v. 2.8.1       - Mar. 2015
+v. 2.8.0       - Mar. 2015
+v. 2.7.0       - Mar. 2012
+v. 2.6.0       - May  2009
+v. 2.5.0       - Nov. 2006
+v. 2.4.0       - Mar. 2006
+v. 2.3.0       - Apr. 2005
+v. 2.2.2       - Mar. 2005
+v. 2.2.1       - Jan. 2005
+v. 2.2.0       - Dec. 2004
+v. 2.0         - Jul. 2002 (first SUNDIALS release)
+v. 1.0         - Mar. 2002 (CVODE and PVODE combined)
+v. 1.0 (PVODE) - Jul. 1997 (date written)
+v. 1.0 (CVODE) - Sep. 1994 (date written)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/fcmix/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/fcmix/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..482a314719bb81fb27e998daa1586086d3d4a3e7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvode/fcmix/CMakeLists.txt
@@ -0,0 +1,97 @@
+# CMakeLists.txt file for the FCVODE library
+
+# Add variable fcvode_SOURCES with the sources for the FCVODE library
+SET(fcvode_SOURCES
+  fcvband.c
+  fcvbbd.c
+  fcvbp.c
+  fcvdense.c
+  fcvewt.c
+  fcvjtimes.c
+  fcvnulllinsol.c
+  fcvnullmatrix.c
+  fcvnullnonlinsol.c
+  fcvode.c
+  fcvpreco.c
+  fcvroot.c
+  fcvsparse.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the CVODE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/nvector/serial/fnvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the CVODE library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/fsunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/fsunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/fsunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the CVODE library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/fsunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/fsunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/fsunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/fsunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/fsunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/fsunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/fsunlinsol_pcg.c
+  )
+
+IF(KLU_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/klu/fsunlinsol_klu.c
+    )
+ENDIF()
+
+IF(SUPERLUMT_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/superlumt/fsunlinsol_superlumt.c
+    )
+ENDIF()
+
+IF(LAPACK_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackband/fsunlinsol_lapackband.c
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackdense/fsunlinsol_lapackdense.c
+    )
+ENDIF()
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the CVODE library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/fsunnonlinsol_newton.c
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/fixedpoint/fsunnonlinsol_fixedpoint.c
+  )
+
+# Add source directories to include directories for access to
+# implementation only header files (both for fcvode and cvode)
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(..)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY 
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Only build STATIC libraries (we cannot build shared libraries 
+# for the FCMIX interfaces due to unresolved symbol errors 
+# coming from inexistent user-provided functions)
+
+# Add the build target for the FCVODE library
+ADD_LIBRARY(sundials_fcvode_static STATIC
+  ${fcvode_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+  ${sunnonlinsol_SOURCES})
+
+# Set the library name and make sure it is not deleted
+SET_TARGET_PROPERTIES(sundials_fcvode_static
+  PROPERTIES OUTPUT_NAME sundials_fcvode CLEAN_DIRECT_OUTPUT 1)
+
+# Install the FCVODE library
+INSTALL(TARGETS sundials_fcvode_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+#
+MESSAGE(STATUS "Added CVODE FCMIX module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..692572a5a4753c3913ec85c1b6bcd347d90d56c2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/CMakeLists.txt
@@ -0,0 +1,149 @@
+# ---------------------------------------------------------------
+# Programmer(s):  Daniel R. Reynolds @ SMU
+#                 Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the CVODES library
+
+INSTALL(CODE "MESSAGE(\"\nInstall CVODES\n\")")
+
+# Add variable cvodes_SOURCES with the sources for the CVODES library
+SET(cvodes_SOURCES
+  cvodea.c
+  cvodea_io.c
+  cvodes.c
+  cvodes_bandpre.c
+  cvodes_bbdpre.c
+  cvodes_diag.c
+  cvodes_direct.c
+  cvodes_io.c
+  cvodes_ls.c
+  cvodes_nls.c
+  cvodes_nls_sim.c
+  cvodes_nls_stg.c
+  cvodes_nls_stg1.c
+  cvodes_spils.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the CVODES library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_direct.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_version.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/nvector/serial/nvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the CVODES library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/sunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/sunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/sunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the CVODES library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/sunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/sunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/sunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/sunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/sunlinsol_pcg.c
+  )
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the CVODES library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/sunnonlinsol_newton.c
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/fixedpoint/sunnonlinsol_fixedpoint.c
+  )
+
+# Add variable cvodes_HEADERS with the exported CVODES header files
+SET(cvodes_HEADERS
+  cvodes.h
+  cvodes_bandpre.h
+  cvodes_bbdpre.h
+  cvodes_diag.h
+  cvodes_direct.h
+  cvodes_ls.h
+  cvodes_spils.h
+  )
+
+# Add prefix with complete path to the CVODES header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/cvodes/ cvodes_HEADERS)
+
+# Add source directories to include directories for access to
+# implementation only header files.
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(../sundials)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Build the static library
+IF(BUILD_STATIC_LIBS)
+
+  # Add the build target for the static CVODES library
+  ADD_LIBRARY(sundials_cvodes_static STATIC
+    ${cvodes_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES})
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_cvodes_static
+    PROPERTIES OUTPUT_NAME sundials_cvodes CLEAN_DIRECT_OUTPUT 1)
+
+  # Install the CVODES library
+  INSTALL(TARGETS sundials_cvodes_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_STATIC_LIBS)
+
+# Build the shared library
+IF(BUILD_SHARED_LIBS)
+
+  # Add the build target for the CVODES library
+  ADD_LIBRARY(sundials_cvodes_shared SHARED
+    ${cvodes_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_cvodes_shared m)
+  ENDIF()
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_cvodes_shared
+    PROPERTIES OUTPUT_NAME sundials_cvodes CLEAN_DIRECT_OUTPUT 1)
+
+  # Set VERSION and SOVERSION for shared libraries
+  SET_TARGET_PROPERTIES(sundials_cvodes_shared
+    PROPERTIES VERSION ${cvodeslib_VERSION} SOVERSION ${cvodeslib_SOVERSION})
+
+  # Install the CVODES library
+  INSTALL(TARGETS sundials_cvodes_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the CVODES header files
+INSTALL(FILES ${cvodes_HEADERS} DESTINATION include/cvodes)
+
+#
+MESSAGE(STATUS "Added CVODES module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/README b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/README
new file mode 100644
index 0000000000000000000000000000000000000000..3b2679113f63b54cbce0c5ce15c926b5b1663138
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/cvodes/README
@@ -0,0 +1,98 @@
+                           CVODES 
+                   Release 4.1.0, Feb 2019
+              Alan C. Hindmarsh and Radu Serban
+         Center for Applied Scientific Computing, LLNL
+
+CVODES is a solver for stiff and nonstiff ODE systems (initial value 
+problem) given in explicit form y' = f(t,y,p) with sensitivity analysis 
+capabilities (both forward and adjoint modes). 
+It is written in ANSI standard C.
+
+CVODES can be used both on serial and parallel computers.  The 
+main difference is in the NVECTOR module of vector kernels.  The desired 
+version is obtained when compiling the example files by linking the 
+appropriate library of NVECTOR kernels.  In the parallel versions,
+communication between processors is done with MPI, with OpenMP, or with Pthreads.
+
+When used with the serial NVECTOR module, CVODES provides both direct (dense 
+and band) and preconditioned Krylov (iterative) linear solvers. Three different
+iterative solvers are available: scaled preconditioned GMRES (SPGMR), scaled 
+preconditioned BiCGStab (SPBCG), and scaled preconditioned TFQMR (SPTFQMR). 
+When CVODES is used with the parallel NVECTOR module, only the Krylov linear solvers 
+are available. (An approximate diagonal Jacobian option is available with both 
+versions.)  For the serial version, there is a banded preconditioner module 
+called CVBANDPRE available for use with the Krylov solvers, while for the parallel 
+version there is a preconditioner module called CVBBDPRE which provides a
+band-block-diagonal preconditioner.
+
+CVODES is part of a software family called SUNDIALS: SUite of Nonlinear and 
+DIfferential/ALgebraic equation Solvers [4].  This suite consists of CVODE, 
+CVODES, ARKode, IDA, IDAS, and KINSOL.  The directory structure of the 
+package supplied reflects this family relationship.
+
+The notes below provide the location of documentation, directions for the 
+installation of the CVODES package, and relevant references. Following that 
+is a brief history of revisions to the package.
+
+
+A. Documentation
+----------------
+
+/sundials/doc/cvodes/ contains PDF files for the CVODES User Guide [1] (cvs_guide.pdf)
+and the CVODES Examples [2] (cvs_examples.pdf) documents.
+
+
+B. Installation
+---------------
+
+For basic installation instructions see the file /sundials/INSTALL_GUIDE.pdf. 
+For complete installation instructions see the "Installation Procedure"
+chapter in the CVODES User Guide.
+
+
+C. References
+-------------
+
+[1] A. C. Hindmarsh and R. Serban, "User Documentation for CVODES v2.9.0," 
+    LLNL technical report UCRL-SM-208111, March 2016.
+
+[2] A. C. Hindmarsh and R. Serban, "Example Programs for CVODES v2.9.0," 
+    LLNL technical report UCRL-SM-208115, March 2016.
+
+[3] R. Serban and A. C. Hindmarsh, "CVODES: the Sensitivity-Enabled ODE 
+    solver in SUNDIALS," Proceedings of IDETC/CIE 2005, Sept. 2005, 
+    Long Beach, CA.
+
+[4] A. C. Hindmarsh, P. N. Brown, K. E. Grant, S. L. Lee, R. Serban, 
+    D. E. Shumaker, and C. S. Woodward, "SUNDIALS, Suite of Nonlinear and 
+    Differential/Algebraic Equation Solvers," ACM Trans. Math. Softw., 
+    31(3), pp. 363-396, 2005.
+
+
+D. Releases
+-----------
+
+v. 4.1.0       - Feb. 2019
+v. 4.0.2       - Jan. 2019
+v. 4.0.1       - Dec. 2018
+v. 4.0.0       - Dec. 2018
+v. 3.2.1       - Oct. 2018
+v. 3.2.0       - Sep. 2018
+v. 3.1.2       - Jul. 2018
+v. 3.1.1       - May  2018
+v. 3.1.0       - Nov. 2017
+v. 3.0.0       - Sep. 2017
+v. 2.9.0       - Sep. 2016
+v. 2.8.2       - Aug. 2015
+v. 2.8.1       - Mar. 2015
+v. 2.8.0       - Mar. 2015
+v. 2.7.0       - Mar. 2012
+v. 2.6.0       - May  2009
+v. 2.5.0       - Nov. 2006
+v. 2.4.0       - Mar. 2006
+v. 2.3.0       - May. 2005
+v. 2.2.0       - Apr. 2005
+v. 2.1.2       - Mar. 2005
+v. 2.1.1       - Jan. 2005
+v. 2.1.0       - Dec. 2004
+v. 1.0         - Jul. 2002 (first SUNDIALS release)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c14ba480376259109c2a39c7fc7e33dd49250d53
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/CMakeLists.txt
@@ -0,0 +1,139 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+#              Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the IDA library
+
+INSTALL(CODE "MESSAGE(\"\nInstall IDA\n\")")
+
+# Add variable ida_SOURCES with the sources for the IDA library
+SET(ida_SOURCES
+  ida.c
+  ida_bbdpre.c
+  ida_direct.c
+  ida_ic.c
+  ida_io.c
+  ida_ls.c
+  ida_nls.c
+  ida_spils.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the IDA library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_direct.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_version.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/nvector/serial/nvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the IDA library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/sunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/sunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/sunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the IDA library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/sunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/sunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/sunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/sunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/sunlinsol_pcg.c
+  )
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the IDA library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/sunnonlinsol_newton.c
+  )
+
+# Add variable ida_HEADERS with the exported IDA header files
+SET(ida_HEADERS
+  ida.h
+  ida_bbdpre.h
+  ida_direct.h
+  ida_ls.h
+  ida_spils.h
+  )
+
+# Add prefix with complete path to the IDA header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/ida/ ida_HEADERS)
+
+# Add source directories to include directories for access to
+# implementation only header files.
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Build the static library
+IF(BUILD_STATIC_LIBS)
+
+  # Add the build target for the static IDA library
+  ADD_LIBRARY(sundials_ida_static STATIC
+    ${ida_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES})
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_ida_static
+    PROPERTIES OUTPUT_NAME sundials_ida CLEAN_DIRECT_OUTPUT 1)
+
+  # Install the IDA library
+  INSTALL(TARGETS sundials_ida_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_STATIC_LIBS)
+
+# Build the shared library
+IF(BUILD_SHARED_LIBS)
+
+  # Add the build target for the IDA library
+  ADD_LIBRARY(sundials_ida_shared SHARED
+    ${ida_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_ida_shared m)
+  ENDIF()
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_ida_shared
+    PROPERTIES OUTPUT_NAME sundials_ida CLEAN_DIRECT_OUTPUT 1)
+
+  # Set VERSION and SOVERSION for shared libraries
+  SET_TARGET_PROPERTIES(sundials_ida_shared
+    PROPERTIES VERSION ${idalib_VERSION} SOVERSION ${idalib_SOVERSION})
+
+  # Install the IDA library
+  INSTALL(TARGETS sundials_ida_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the IDA header files
+INSTALL(FILES ${ida_HEADERS} DESTINATION include/ida)
+
+#
+MESSAGE(STATUS "Added IDA module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/README b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/README
new file mode 100644
index 0000000000000000000000000000000000000000..cb49f0b94f85aace2aec9bf0fccab2c32f25c07e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/README
@@ -0,0 +1,110 @@
+                               IDA
+                     Release 4.1.0, Feb 2019
+                Alan C. Hindmarsh and Radu Serban 
+           Center for Applied Scientific Computing, LLNL
+
+
+IDA is a package for the solution of differential-algebraic equation
+(DAE) systems.  It is written in C, but derived from the package DASPK
+[4,5], which is written in FORTRAN. 
+
+IDA can be used both on serial and parallel computers.  The main
+difference is in the NVECTOR module of vector kernels.  The desired
+version is obtained when compiling the example files by linking the
+appropriate library of NVECTOR kernels.  In the parallel versions,
+communication between processors is done with MPI, with OpenMP, 
+or with Pthreads.
+
+When used with the serial NVECTOR module, IDA provides both direct 
+(dense and band) linear solvers and preconditioned Krylov (iterative) 
+linear solvers. Three different iterative solvers are available: scaled 
+preconditioned GMRES (SPGMR), scaled preconditioned BiCGStab (SPBCG), and 
+scaled preconditioned TFQMR (SPTFQMR). When IDA is used with the parallel 
+NVECTOR module, only the Krylov linear solvers are available.  For the 
+latter case, in addition to the basic solver, the IDA package also contains 
+a preconditioner module called IDABBDPRE, which provides a band-block-diagonal 
+preconditioner.
+
+IDA is part of a software family called SUNDIALS: SUite of Nonlinear and 
+DIfferential/ALgebraic equation Solvers [3].  This suite consists of CVODE, 
+CVODES, ARKode, IDA, IDAS, and KINSOL.  The directory structure of the 
+package supplied reflects this family relationship.
+
+For use with Fortran applications, a set of Fortran/C interface routines,
+called FIDA, is also supplied.  These are written in C, but assume that
+the user calling program and all user-supplied routines are in Fortran.
+
+Several examples problem programs are included, covering both serial
+and parallel cases, both small and large problem sizes, and both
+linear and nonlinear problems.
+
+The notes below provide the location of documentation, directions for the 
+installation of the IDA package, and relevant references. Following that 
+is a brief history of revisions to the package.
+
+
+A. Documentation
+----------------
+
+/sundials/doc/ida/ contains PDF files for the IDA User Guide [1] (ida_guide.pdf)
+and the IDA Examples [2] (ida_examples.pdf) documents.
+
+
+B. Installation
+---------------
+
+For basic installation instructions see the file /sundials/INSTALL_GUIDE.pdf. 
+For complete installation instructions see the "Installation Procedure"
+chapter in the IDA User Guide.
+
+
+C. References
+-------------
+
+[1] A. C. Hindmarsh, R. Serban, and A. Collier, "User Documentation for IDA v2.9.0," 
+    LLNL technical report UCRL-SM-208112, March 2016.
+
+[2] A. C. Hindmarsh, R. Serban, and A. Collier, "Example Programs for IDA v2.9.0," 
+    LLNL technical report UCRL-SM-208113, March 2016.
+
+[3] A. C. Hindmarsh, P. N. Brown, K. E. Grant, S. L. Lee, R. Serban, 
+    D. E. Shumaker, and C. S. Woodward, "SUNDIALS, Suite of Nonlinear and 
+    Differential/Algebraic Equation Solvers," ACM Trans. Math. Softw., 
+    31(3), pp. 363-396, 2005.
+
+[4] P. N. Brown, A. C. Hindmarsh, and L. R. Petzold, Using Krylov Methods 
+    in the Solution of Large-Scale Differential-Algebraic Systems, 
+    SIAM J. Sci. Comp., 15 (1994), pp. 1467-1488.
+
+[5] P. N. Brown, A. C. Hindmarsh, and L. R. Petzold, Consistent Initial 
+    Condition Calculation for Differential-Algebraic Systems, 
+    SIAM J. Sci. Comp., 19 (1998), pp. 1495-1512.
+
+
+D. Releases
+-----------
+
+v. 4.1.0       - Feb. 2019
+v. 4.0.2       - Jan. 2019
+v. 4.0.1       - Dec. 2018
+v. 4.0.0       - Dec. 2018
+v. 3.2.1       - Oct. 2018
+v. 3.2.0       - Sep. 2018
+v. 3.1.2       - Jul. 2018
+v. 3.1.1       - May  2018
+v. 3.1.0       - Nov. 2017
+v. 3.0.0       - Sep. 2017
+v. 2.9.0       - Sep. 2016
+v. 2.8.2       - Aug. 2015
+v. 2.8.1       - Mar. 2015
+v. 2.8.0       - Mar. 2015
+v. 2.7.0       - Mar. 2012
+v. 2.6.0       - May  2009
+v. 2.5.0       - Nov. 2006
+v. 2.4.0       - Mar. 2006
+v. 2.3.0       - Apr. 2005
+v. 2.2.2       - Mar. 2005
+v. 2.2.1       - Jan. 2005
+v. 2.2.0       - Dec. 2004
+v. 2.0         - Jul. 2002 (first SUNDIALS release)
+v. 1.0         - Feb. 1999 (date written)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/fcmix/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/fcmix/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31bfe8cdbc0a53ea19f00b4f8fb33c6d2fa715b1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/ida/fcmix/CMakeLists.txt
@@ -0,0 +1,106 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the FIDA library
+
+# Add variable fida_SOURCES with the sources for the FIDA library
+SET(fida_SOURCES
+  fidaband.c
+  fidabbd.c
+  fida.c
+  fidadense.c
+  fidaewt.c
+  fidajtimes.c
+  fidanullmatrix.c
+  fidanullnonlinsol.c
+  fidapreco.c
+  fidaroot.c
+  fidasparse.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the IDA library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/nvector/serial/fnvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the IDA library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/fsunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/fsunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/fsunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the IDA library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/fsunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/fsunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/fsunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/fsunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/fsunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/fsunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/fsunlinsol_pcg.c
+  )
+
+IF(KLU_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/klu/fsunlinsol_klu.c
+    )
+ENDIF()
+
+IF(SUPERLUMT_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/superlumt/fsunlinsol_superlumt.c
+    )
+ENDIF()
+
+IF(LAPACK_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackband/fsunlinsol_lapackband.c
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackdense/fsunlinsol_lapackdense.c
+    )
+ENDIF()
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the IDA library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/fsunnonlinsol_newton.c
+  )
+
+# Add source directories to include directories for access to
+# implementation only header files (both for fida and ida)
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(..)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY 
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Only build STATIC libraries (we cannot build shared libraries 
+# for the FCMIX interfaces due to unresolved symbol errors 
+# coming from inexistent user-provided functions)
+
+# Add the build target for the FIDA library
+ADD_LIBRARY(sundials_fida_static STATIC
+  ${fida_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+  ${sunnonlinsol_SOURCES})
+
+# Set the library name and make sure it is not deleted
+SET_TARGET_PROPERTIES(sundials_fida_static
+  PROPERTIES OUTPUT_NAME sundials_fida CLEAN_DIRECT_OUTPUT 1)
+
+# Install the FIDA library
+INSTALL(TARGETS sundials_fida_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+#
+MESSAGE(STATUS "Added IDA FCMIX module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d8397037971bf4b63fcebde8d9310ef6cbd669a2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/CMakeLists.txt
@@ -0,0 +1,143 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+#              Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the IDAS library
+
+INSTALL(CODE "MESSAGE(\"\nInstall IDAS\n\")")
+
+# Add variable idas_SOURCES with the sources for the IDAS library
+SET(idas_SOURCES
+  idas.c
+  idaa.c
+  idas_direct.c
+  idas_io.c
+  idas_ic.c
+  idaa_io.c
+  idas_ls.c
+  idas_bbdpre.c
+  idas_nls.c
+  idas_nls_sim.c
+  idas_nls_stg.c
+  idas_spils.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the IDAS library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_direct.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_version.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/nvector/serial/nvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the IDAS library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/sunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/sunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/sunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the IDAS library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/sunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/sunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/sunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/sunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/sunlinsol_pcg.c
+  )
+
+# Add variable sunnonlinsol_SOURCES with the common SUNNonlinearSolver sources
+# which will also be included in the IDAS library
+SET(sunnonlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunnonlinsol/newton/sunnonlinsol_newton.c
+  )
+
+# Add variable idas_HEADERS with the exported IDAS header files
+SET(idas_HEADERS
+  idas.h
+  idas_bbdpre.h
+  idas_direct.h
+  idas_ls.h
+  idas_spils.h
+  )
+
+# Add prefix with complete path to the IDAS header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/idas/ idas_HEADERS)
+
+# Add source directories to include directories for access to
+# implementation only header files.
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Build the static library
+IF(BUILD_STATIC_LIBS)
+
+  # Add the build target for the static IDAS library
+  ADD_LIBRARY(sundials_idas_static STATIC
+    ${idas_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES})
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_idas_static
+    PROPERTIES OUTPUT_NAME sundials_idas CLEAN_DIRECT_OUTPUT 1)
+
+  # Install the IDA library
+  INSTALL(TARGETS sundials_idas_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_STATIC_LIBS)
+
+# Build the shared library
+IF(BUILD_SHARED_LIBS)
+
+  # Add the build target for the IDAS library
+  ADD_LIBRARY(sundials_idas_shared SHARED
+    ${idas_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES}
+    ${sunnonlinsol_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_idas_shared m)
+  ENDIF()
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_idas_shared
+    PROPERTIES OUTPUT_NAME sundials_idas CLEAN_DIRECT_OUTPUT 1)
+
+  # Set VERSION and SOVERSION for shared libraries
+  SET_TARGET_PROPERTIES(sundials_idas_shared
+    PROPERTIES VERSION ${idaslib_VERSION} SOVERSION ${idaslib_SOVERSION})
+
+  # Install the IDAS library
+  INSTALL(TARGETS sundials_idas_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the IDAS header files
+INSTALL(FILES ${idas_HEADERS} DESTINATION include/idas)
+
+#
+MESSAGE(STATUS "Added IDAS module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/README b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/README
new file mode 100644
index 0000000000000000000000000000000000000000..ca1b3b2931891b3ca5c2d05385dc13e77de863c4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/idas/README
@@ -0,0 +1,90 @@
+                              IDAS
+                     Release 3.1.0, Feb 2019
+                           Radu Serban 
+           Center for Applied Scientific Computing, LLNL
+
+
+IDAS is a package for the solution of differential-algebraic equation (DAE) 
+systems with sensitivity analysis capabilities (both forward and adjoint modes). 
+It is written in ANSI standard C.
+
+IDAS can be used both on serial and parallel computers.  The main
+difference is in the NVECTOR module of vector kernels.  The desired
+version is obtained when compiling the example files by linking the
+appropriate library of NVECTOR kernels.  In the parallel versions,
+communication between processors is done with MPI, with OpenMP, 
+or with Pthreads.
+
+When used with the serial NVECTOR module, IDAS provides both direct 
+(dense and band) linear solvers and preconditioned Krylov (iterative) 
+linear solvers. Three different iterative solvers are available: scaled 
+preconditioned GMRES (SPGMR), scaled preconditioned BiCGStab (SPBCG), and 
+scaled preconditioned TFQMR (SPTFQMR). When IDAS is used with the parallel 
+NVECTOR module, only the Krylov linear solvers are available.  For the 
+latter case, in addition to the basic solver, the IDA package also contains 
+a preconditioner module called IDABBDPRE, which provides a band-block-diagonal 
+preconditioner.
+
+IDAS is part of a software family called SUNDIALS: SUite of Nonlinear and 
+DIfferential/ALgebraic equation Solvers [3].  This suite consists of CVODE, 
+CVODES, ARkode, IDA, IDAS, and KINSOL.  The directory structure of the 
+package supplied reflects this family relationship.
+
+Several examples problem programs are included, covering both serial
+and parallel cases, both small and large problem sizes, and both
+linear and nonlinear problems.
+
+The notes below provide the location of documentation, directions for the 
+installation of the IDAS package, and relevant references. Following that 
+is a brief history of revisions to the package.
+
+
+A. Documentation
+----------------
+
+/sundials/doc/idas/ contains PDF files for the IDAS User Guide [1] (idas_guide.pdf)
+and the IDAS Examples [2] (idas_examples.pdf) documents.
+
+
+B. Installation
+---------------
+
+For basic installation instructions see the file /sundials/INSTALL_GUIDE.pdf. 
+For complete installation instructions see the "Installation Procedure"
+chapter in the IDAS User Guide.
+
+
+C. References
+-------------
+
+[1] R. Serban, C. Petra,and A. C. Hindmarsh,  "User Documentation for IDAS v1.3.0," 
+    LLNL technical report UCRL-SM-234051, March 2016.
+
+[2] R. Serban and A.C. Hindmarsh, "Example Programs for IDAS v1.3.0," 
+    LLNL technical report LLNL-TR-437091, March 2016.
+
+[3] A. C. Hindmarsh, P. N. Brown, K. E. Grant, S. L. Lee, R. Serban, 
+    D. E. Shumaker, and C. S. Woodward, "SUNDIALS, Suite of Nonlinear and 
+    Differential/Algebraic Equation Solvers," ACM Trans. Math. Softw., 
+    31(3), pp. 363-396, 2005.
+
+
+D. Releases
+-----------
+
+v. 3.1.0       - Feb. 2019
+v. 3.0.2       - Jan. 2019
+v. 3.0.1       - Dec. 2018
+v. 3.0.0       - Dec. 2018
+v. 2.2.1       - Oct. 2018
+v. 2.2.0       - Sep. 2018
+v. 2.1.2       - Jul. 2018
+v. 2.1.1       - May  2018
+v. 2.1.0       - Nov. 2017
+v. 2.0.0       - Sep. 2017
+v. 1.3.0       - Sep. 2016
+v. 1.2.2       - Aug. 2015
+v. 1.2.1       - Mar. 2015
+v. 1.2.0       - Mar. 2015
+v. 1.1.0       - Mar. 2012
+v. 1.0.0       - May  2009
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2853c72a4cba94b56d55dbede4efc88dc0f0b7cf
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/CMakeLists.txt
@@ -0,0 +1,128 @@
+# ---------------------------------------------------------------
+# Programmer(s):  Daniel R. Reynolds @ SMU
+#                 Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the KINSOL library
+
+INSTALL(CODE "MESSAGE(\"\nInstall KINSOL\n\")")
+
+# Add variable kinsol_SOURCES with the sources for the KINSOL library
+SET(kinsol_SOURCES
+  kinsol.c
+  kinsol_bbdpre.c
+  kinsol_direct.c
+  kinsol_io.c
+  kinsol_ls.c
+  kinsol_spils.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the KINSOL library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_direct.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_version.c
+  ${sundials_SOURCE_DIR}/src/nvector/serial/nvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the KINSOL library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/sunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/sunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/sunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the KINSOL library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/sunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/sunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/sunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/sunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/sunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/sunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/sunlinsol_pcg.c
+  )
+
+# Add variable kinsol_HEADERS with the exported KINSOL header files
+SET(kinsol_HEADERS
+  kinsol.h
+  kinsol_bbdpre.h
+  kinsol_direct.h
+  kinsol_ls.h
+  kinsol_spils.h
+  )
+
+# Add prefix with complete path to the KINSOL header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/kinsol/ kinsol_HEADERS)
+
+# Add source directories to include directories for access to
+# implementation only header files.
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(../sundials)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Build the static library
+IF(BUILD_STATIC_LIBS)
+
+  # Add the build target for the static KINSOL library
+  ADD_LIBRARY(sundials_kinsol_static STATIC
+    ${kinsol_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES})
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_kinsol_static
+    PROPERTIES OUTPUT_NAME sundials_kinsol CLEAN_DIRECT_OUTPUT 1)
+
+  # Install the KINSOL library
+  INSTALL(TARGETS sundials_kinsol_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_STATIC_LIBS)
+
+# Build the shared library
+IF(BUILD_SHARED_LIBS)
+
+  # Add the build target for the KINSOL library
+  ADD_LIBRARY(sundials_kinsol_shared SHARED
+    ${kinsol_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_kinsol_shared m)
+  ENDIF()
+
+  # Set the library name and make sure it is not deleted
+  SET_TARGET_PROPERTIES(sundials_kinsol_shared
+    PROPERTIES OUTPUT_NAME sundials_kinsol CLEAN_DIRECT_OUTPUT 1)
+
+  # Set VERSION and SOVERSION for shared libraries
+  SET_TARGET_PROPERTIES(sundials_kinsol_shared
+    PROPERTIES VERSION ${kinsollib_VERSION} SOVERSION ${kinsollib_SOVERSION})
+
+  # Install the KINSOL library
+  INSTALL(TARGETS sundials_kinsol_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the KINSOL header files
+INSTALL(FILES ${kinsol_HEADERS} DESTINATION include/kinsol)
+
+#
+MESSAGE(STATUS "Added KINSOL module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2966cbb27c421385f26642f5f5c4b110c8cf8fba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2002-2019, Lawrence Livermore National Security and Southern Methodist University.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/NOTICE b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..329b142ee63dfeffb0917546de18f397b7fe6a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/README b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/README
new file mode 100644
index 0000000000000000000000000000000000000000..834076de9d83df74d7a8225dca4ebdf598fcafdd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/README
@@ -0,0 +1,111 @@
+                                 KINSOL
+                         Release 4.1.0, Feb 2019
+  Aaron Collier, Alan C. Hindmarsh, Radu Serban, and Carol S. Woodward
+             Center for Applied Scientific Computing, LLNL
+
+KINSOL is a solver for nonlinear algebraic systems which can be
+described as F(u) = 0.  It is written in the C language and based
+on the previous Fortran package NKSOL [4], written by Peter Brown and
+Youcef Saad.  Nonlinear solver methods available include Newton-Krylov,
+Picard, and fixed point.  Both Picard and fixed point can be accelerated
+with Anderson acceleration.
+
+KINSOL can be used both on serial and parallel computers.
+The difference is only in the NVECTOR module of vector functions.
+The desired version is obtained when compiling the example files
+by linking with the appropriate library of NVECTOR functions.  In the
+parallel versions, communication between processes is done  
+with MPI, with OpenMP, or with Pthreads.
+
+When used with the serial NVECTOR module, KINSOL provides both direct (dense 
+and band) and preconditioned Krylov (iterative) linear solvers. Four different
+iterative solvers are available: scaled preconditioned GMRES (SPGMR), scaled 
+preconditioned BiCGStab (SPBCG), scaled preconditioned TFQMR (SPTFQMR), and
+scaled preconditioned Flexible GMRES (SPFGMR). 
+When used with the parallel NVECTOR module, KINSOL provides a
+preconditioner module called KINBBDPRE, which provides a
+band-block-diagonal preconditioner for use with the Krylov linear
+solvers. However, within KINSOL any NVECTOR module may be combined
+with an appropriate user-supplied preconditioning module for
+acceleration of the Krylov solvers.
+
+KINSOL is part of a software family called SUNDIALS: SUite of Nonlinear
+and DIfferential/ALgebraic equation Solvers.  This suite consists of
+CVODE, CVODES, ARKode, KINSOL, IDA, and IDAS.  The directory
+structure of the package supplied reflects this family relationship.
+
+For use with Fortran applications, a set of Fortran/C interface routines,
+called FKINSOL, is also supplied.  These are written in C, but assume that
+the user calling program and all user-supplied routines are in Fortran.
+
+The notes below provide the location of documentation, directions for the 
+installation of the KINSOL package, and relevant references. Following that 
+is a brief history of revisions to the package.
+
+
+A. Documentation
+----------------
+
+/sundials/doc/kinsol/ contains PDF files for the KINSOL User Guide [1] (kin_guide.pdf)
+and the KINSOL Examples [2] (kin_examples.pdf) documents.
+
+
+B. Installation
+---------------
+
+For basic installation instructions see the file /sundials/INSTALL_GUIDE.pdf. 
+For complete installation instructions see the "Installation Procedure"
+chapter in the KINSOL User Guide [1].
+
+
+C. References
+-------------
+
+[1] A. M. Collier, A. C. Hindmarsh, R. Serban, and C. S. Woodward,
+    "User Documentation for KINSOL v2.9.0," LLNL technical report
+    UCRL-SM-208116, March 2016.
+
+[2] A. M. Collier and R. Serban, "Example Programs for KINSOL v2.9.0,"
+    LLNL technical report UCRL-SM-208114, March 2016.
+
+[3] A. C. Hindmarsh, P. N. Brown, K. E. Grant, S. L. Lee, R. Serban, 
+    D. E. Shumaker, and C. S. Woodward, "SUNDIALS, Suite of Nonlinear and 
+    Differential/Algebraic Equation Solvers," ACM Trans. Math. Softw., 
+    31(3), pp. 363-396, 2005.
+
+[4] Peter N. Brown and Youcef Saad, "Hybrid Krylov Methods for
+    Nonlinear Systems of Equations," SIAM J. Sci. Stat. Comput., 
+    Vol 11, no 3, pp. 450-481, May 1990.  
+
+[5] A. G. Taylor and A. C. Hindmarsh, "User Documentation for KINSOL,
+    A Nonlinear Solver for Sequential and Parallel Computers," LLNL
+    technical report UCRL-ID-131185, July 1998.
+
+
+D. Releases
+-----------
+
+v. 4.1.0       - Feb. 2019
+v. 4.0.2       - Jan. 2019
+v. 4.0.1       - Dec. 2018
+v. 4.0.0       - Dec. 2018
+v. 3.2.1       - Oct. 2018
+v. 3.2.0       - Sep. 2018
+v. 3.1.2       - Jul. 2018
+v. 3.1.1       - May  2018
+v. 3.1.0       - Nov. 2017
+v. 3.0.0       - Sep. 2017
+v. 2.9.0       - Sep. 2016
+v. 2.8.2       - Aug. 2015
+v. 2.8.1       - Mar. 2015
+v. 2.8.0       - Mar. 2015
+v. 2.7.0       - Mar. 2012
+v. 2.6.0       - May  2009
+v. 2.5.0       - Nov. 2006
+v. 2.4.0       - Mar. 2006
+v. 2.3.0       - Apr. 2005
+v. 2.2.2       - Mar. 2005
+v. 2.2.1       - Jan. 2005
+v. 2.2.0       - Dec. 2004
+v. 2.0         - Jul. 2002 (first SUNDIALS release)
+v. 1.0         - Aug. 1998 (date written)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/fcmix/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/fcmix/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0c76ac56b5a3e611361dbee670a731935a5cbf24
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/kinsol/fcmix/CMakeLists.txt
@@ -0,0 +1,99 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the FKINSOL library
+
+# Add variable fcvode_SOURCES with the sources for the FCVODE library
+SET(fkinsol_SOURCES
+  fkinband.c
+  fkinbbd.c
+  fkindense.c
+  fkinjtimes.c
+  fkinnullmatrix.c
+  fkinnulllinsol.c
+  fkinpreco.c
+  fkinsol.c
+  fkinsparse.c
+  )
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the ARKODE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/nvector/serial/fnvector_serial.c
+  )
+
+# Add variable sunmatrix_SOURCES with the common SUNMatrix sources which will
+# also be included in the ARKODE library
+SET(sunmatrix_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunmatrix/band/fsunmatrix_band.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/dense/fsunmatrix_dense.c
+  ${sundials_SOURCE_DIR}/src/sunmatrix/sparse/fsunmatrix_sparse.c
+  )
+
+# Add variable sunlinsol_SOURCES with the common SUNLinearSolver sources which will
+# also be included in the ARKODE library
+SET(sunlinsol_SOURCES
+  ${sundials_SOURCE_DIR}/src/sunlinsol/band/fsunlinsol_band.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/dense/fsunlinsol_dense.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spbcgs/fsunlinsol_spbcgs.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spfgmr/fsunlinsol_spfgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/spgmr/fsunlinsol_spgmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/sptfqmr/fsunlinsol_sptfqmr.c
+  ${sundials_SOURCE_DIR}/src/sunlinsol/pcg/fsunlinsol_pcg.c
+  )
+
+IF(KLU_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/klu/fsunlinsol_klu.c
+    )
+ENDIF()
+
+IF(SUPERLUMT_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/superlumt/fsunlinsol_superlumt.c
+    )
+ENDIF()
+
+IF(LAPACK_FOUND)
+  LIST(APPEND sunlinsol_SOURCES
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackband/fsunlinsol_lapackband.c
+    ${sundials_SOURCE_DIR}/src/sunlinsol/lapackdense/fsunlinsol_lapackdense.c
+    )
+ENDIF()
+
+
+# Add source directories to include directories for access to
+# implementation only header files (both for fkinsol and kinsol)
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(..)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY 
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Only build STATIC libraries (we cannot build shared libraries 
+# for the FCMIX interfaces due to unresolved symbol errors 
+# coming from inexistent user-provided functions)
+
+# Add the build target for the FKINSOL library
+ADD_LIBRARY(sundials_fkinsol_static STATIC
+  ${fkinsol_SOURCES} ${shared_SOURCES} ${sunmatrix_SOURCES} ${sunlinsol_SOURCES} )
+
+# Set the library name and make sure it is not deleted
+SET_TARGET_PROPERTIES(sundials_fkinsol_static
+  PROPERTIES OUTPUT_NAME sundials_fkinsol CLEAN_DIRECT_OUTPUT 1)
+
+# Install the FKINSOL library
+INSTALL(TARGETS sundials_fkinsol_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+#
+MESSAGE(STATUS "Added KINSOL FCMIX module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1dc3a7f9af724629121e5c5c555a9285906bed06
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/CMakeLists.txt
@@ -0,0 +1,56 @@
+# ------------------------------------------------------------------------------
+# Programmer(s): Cody J. Balos @ LLNL
+# ------------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------------
+# vector level CMakeLists.txt for SUNDIALS
+# ------------------------------------------------------------------------------
+
+# Always add SUNDIALS serial vector
+add_subdirectory(serial)
+
+# Add NVECTOR modules with depedencies
+if(MPI_ENABLE AND MPI_C_FOUND)
+  add_subdirectory(parallel)
+endif(MPI_ENABLE AND MPI_C_FOUND)
+
+if(HYPRE_ENABLE AND HYPRE_FOUND)
+  add_subdirectory(parhyp)
+endif(HYPRE_ENABLE AND HYPRE_FOUND)
+
+if(OPENMP_ENABLE AND OPENMP_FOUND)
+  add_subdirectory(openmp)
+endif(OPENMP_ENABLE AND OPENMP_FOUND)
+
+if(OPENMP_DEVICE_ENABLE AND OPENMP_FOUND AND OPENMP_SUPPORTS_DEVICE_OFFLOADING)
+  add_subdirectory(openmpdev)
+endif(OPENMP_DEVICE_ENABLE AND OPENMP_FOUND AND OPENMP_SUPPORTS_DEVICE_OFFLOADING)
+
+if(PTHREADS_ENABLE AND PTHREADS_FOUND)
+  add_subdirectory(pthreads)
+endif(PTHREADS_ENABLE AND PTHREADS_FOUND)
+
+if(PETSC_ENABLE AND PETSC_FOUND)
+  add_subdirectory(petsc)
+endif(PETSC_ENABLE AND PETSC_FOUND)
+
+if(CUDA_ENABLE AND CUDA_FOUND)
+  add_subdirectory(cuda)
+endif(CUDA_ENABLE AND CUDA_FOUND)
+
+if(RAJA_ENABLE AND RAJA_FOUND)
+  add_subdirectory(raja)
+endif(RAJA_ENABLE AND RAJA_FOUND)
+
+IF(Trilinos_ENABLE AND Trilinos_FUNCTIONAL)
+  ADD_SUBDIRECTORY(trilinos)
+ENDIF(Trilinos_ENABLE AND Trilinos_FUNCTIONAL)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/cuda/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/cuda/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4a90c498b50dd11fea6118c789ecff5c99159dff
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/cuda/CMakeLists.txt
@@ -0,0 +1,100 @@
+# ---------------------------------------------------------------
+# Programmer:  Slaven Peles, and Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the cuda NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_CUDA\n\")")
+
+# Add variable nveccuda_SOURCES with the sources for the NVECSERIAL lib
+SET(nveccuda_SOURCES nvector_cuda.cu)
+
+# Tell compiler it is a CUDA source
+set_source_files_properties(${nveccuda_SOURCES} PROPERTIES CUDA_SOURCE_PROPERTY_FORMAT OBJ)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECCUDA library
+SET(shared_SOURCES
+  sundials_math.c
+  sundials_mpi.c
+)
+ADD_PREFIX(${sundials_SOURCE_DIR}/src/sundials/ shared_SOURCES)
+
+# Add variable nveccuda_HEADERS with the exported NVECSERIAL header files
+SET(nveccuda_HEADERS nvector_cuda.h)
+IF (MPI_ENABLE)
+  LIST(APPEND nveccuda_HEADERS nvector_mpicuda.h)
+ENDIF()
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/nvector/ nveccuda_HEADERS)
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(. ${MPI_CXX_INCLUDE_PATH})
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECCUDA library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECSERIAL library
+IF(BUILD_STATIC_LIBS)
+  # ----------------------- CUDA only
+  # The FindCUDA module does not properly forward compile options using target_* commands.
+  # So as long as we use it (required in CMake < 3.8), we have to manually add compile
+  # options in the CUDA_ADD_* commands.
+  CUDA_ADD_LIBRARY(sundials_nveccuda_static STATIC ${nveccuda_SOURCES} ${shared_SOURCES}
+                   OPTIONS -DSUNDIALS_MPI_ENABLED=0)
+  TARGET_COMPILE_DEFINITIONS(sundials_nveccuda_static PUBLIC -DSUNDIALS_MPI_ENABLED=0)
+
+  SET_TARGET_PROPERTIES(sundials_nveccuda_static
+    PROPERTIES OUTPUT_NAME sundials_nveccuda CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nveccuda_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  # ----------------------- MPI+CUDA
+  IF(MPI_ENABLE)
+    CUDA_ADD_LIBRARY(sundials_nvecmpicuda_static STATIC ${nveccuda_SOURCES} ${shared_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_nvecmpicuda_static
+      PROPERTIES OUTPUT_NAME sundials_nvecmpicuda CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_nvecmpicuda_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF()
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECSERIAL library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECSERIAL library
+IF(BUILD_SHARED_LIBS)
+  # ----------------------- CUDA only
+  CUDA_ADD_LIBRARY(sundials_nveccuda_shared SHARED ${nveccuda_SOURCES} ${shared_SOURCES}
+                   OPTIONS -DSUNDIALS_MPI_ENABLED=0)
+  TARGET_COMPILE_DEFINITIONS(sundials_nveccuda_shared PUBLIC -DSUNDIALS_MPI_ENABLED=0)
+  SET_TARGET_PROPERTIES(sundials_nveccuda_shared
+    PROPERTIES OUTPUT_NAME sundials_nveccuda CLEAN_DIRECT_OUTPUT 1
+               VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nveccuda_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  # ----------------------- MPI+CUDA
+  IF(MPI_ENABLE)
+    CUDA_ADD_LIBRARY(sundials_nvecmpicuda_shared SHARED ${nveccuda_SOURCES} ${shared_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_nvecmpicuda_shared
+      PROPERTIES OUTPUT_NAME sundials_nvecmpicuda CLEAN_DIRECT_OUTPUT 1
+                 VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+    INSTALL(TARGETS sundials_nvecmpicuda_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF()
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the CUDA NVector header files
+INSTALL(FILES ${nveccuda_HEADERS} DESTINATION include/nvector)
+INSTALL(DIRECTORY ${sundials_SOURCE_DIR}/include/nvector/cuda DESTINATION include/nvector)
+
+MESSAGE(STATUS "Added NVECTOR_CUDA module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/cuda/nvector_cuda.cu b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/cuda/nvector_cuda.cu
new file mode 100644
index 0000000000000000000000000000000000000000..58b5737fc5ab9498d137eea2bf115f456f1a51cd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/cuda/nvector_cuda.cu
@@ -0,0 +1,1177 @@
+/* -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles, and Cody J. Balos @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ * This is the implementation file for a MPI+CUDA implementation
+ * of the NVECTOR package.
+ * -----------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <cmath>
+
+#include <nvector/cuda/Vector.hpp>
+#include <nvector/cuda/VectorKernels.cuh>
+#include <nvector/cuda/VectorArrayKernels.cuh>
+#include <sundials/sundials_mpi.h>
+
+#define ZERO   RCONST(0.0)
+#define HALF   RCONST(0.5)
+#define ONE    RCONST(1.0)
+#define ONEPT5 RCONST(1.5)
+
+extern "C" {
+
+using namespace suncudavec;
+
+/*
+ * Type definitions
+ */
+
+typedef suncudavec::Vector<realtype, sunindextype> vector_type;
+
+/* ----------------------------------------------------------------
+ * Returns vector type ID. Used to identify vector implementation
+ * from abstract N_Vector interface.
+ */
+N_Vector_ID N_VGetVectorID_Cuda(N_Vector v)
+{
+  return SUNDIALS_NVEC_CUDA;
+}
+
+N_Vector N_VNewEmpty_Cuda()
+{
+  N_Vector v;
+  N_Vector_Ops ops;
+
+  /* Create vector */
+  v = NULL;
+  v = (N_Vector) malloc(sizeof *v);
+  if (v == NULL) return(NULL);
+
+  /* Create vector operation structure */
+  ops = NULL;
+  ops = (N_Vector_Ops) malloc(sizeof(struct _generic_N_Vector_Ops));
+  if (ops == NULL) { free(v); return(NULL); }
+
+  ops->nvgetvectorid     = N_VGetVectorID_Cuda;
+  ops->nvclone           = N_VClone_Cuda;
+  ops->nvcloneempty      = N_VCloneEmpty_Cuda;
+  ops->nvdestroy         = N_VDestroy_Cuda;
+  ops->nvspace           = N_VSpace_Cuda;
+  ops->nvgetarraypointer = NULL;
+  ops->nvsetarraypointer = NULL;
+
+  /* standard vector operations */
+  ops->nvlinearsum    = N_VLinearSum_Cuda;
+  ops->nvconst        = N_VConst_Cuda;
+  ops->nvprod         = N_VProd_Cuda;
+  ops->nvdiv          = N_VDiv_Cuda;
+  ops->nvscale        = N_VScale_Cuda;
+  ops->nvabs          = N_VAbs_Cuda;
+  ops->nvinv          = N_VInv_Cuda;
+  ops->nvaddconst     = N_VAddConst_Cuda;
+  ops->nvdotprod      = N_VDotProd_Cuda;
+  ops->nvmaxnorm      = N_VMaxNorm_Cuda;
+  ops->nvwrmsnormmask = N_VWrmsNormMask_Cuda;
+  ops->nvwrmsnorm     = N_VWrmsNorm_Cuda;
+  ops->nvmin          = N_VMin_Cuda;
+  ops->nvwl2norm      = N_VWL2Norm_Cuda;
+  ops->nvl1norm       = N_VL1Norm_Cuda;
+  ops->nvcompare      = N_VCompare_Cuda;
+  ops->nvinvtest      = N_VInvTest_Cuda;
+  ops->nvconstrmask   = N_VConstrMask_Cuda;
+  ops->nvminquotient  = N_VMinQuotient_Cuda;
+
+  /* fused vector operations (optional, NULL means disabled by default) */
+  ops->nvlinearcombination = NULL;
+  ops->nvscaleaddmulti     = NULL;
+  ops->nvdotprodmulti      = NULL;
+
+  /* vector array operations (optional, NULL means disabled by default) */
+  ops->nvlinearsumvectorarray         = NULL;
+  ops->nvscalevectorarray             = NULL;
+  ops->nvconstvectorarray             = NULL;
+  ops->nvwrmsnormvectorarray          = NULL;
+  ops->nvwrmsnormmaskvectorarray      = NULL;
+  ops->nvscaleaddmultivectorarray     = NULL;
+  ops->nvlinearcombinationvectorarray = NULL;
+
+  /* Attach ops and set content to NULL */
+  v->content = NULL;
+  v->ops     = ops;
+
+  return(v);
+}
+
+#if SUNDIALS_MPI_ENABLED
+N_Vector N_VNew_Cuda(MPI_Comm comm,
+                     sunindextype local_length,
+                     sunindextype global_length)
+{
+  N_Vector v;
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  v->content = new vector_type(comm, local_length, global_length);
+
+  return(v);
+}
+
+N_Vector N_VNewManaged_Cuda(MPI_Comm comm,
+                            sunindextype local_length,
+                            sunindextype global_length)
+{
+  N_Vector v;
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  /* create suncudavec::Vector with managed memory */
+  v->content = new vector_type(comm, local_length, global_length, true);
+
+  return(v);
+}
+
+N_Vector N_VMake_Cuda(MPI_Comm comm,
+                      sunindextype local_length, sunindextype global_length,
+                      realtype *h_vdata, realtype *d_vdata)
+{
+  N_Vector v;
+
+  if (h_vdata == NULL || d_vdata == NULL) return(NULL);
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  /* create suncudavec::Vector using the user-provided data arrays */
+  v->content = new vector_type(comm, local_length, global_length, false, false, h_vdata, d_vdata);
+
+  return(v);
+}
+
+N_Vector N_VMakeManaged_Cuda(MPI_Comm comm,
+                             sunindextype local_length, sunindextype global_length,
+                             realtype *vdata)
+{
+  N_Vector v;
+
+  if (vdata == NULL) return(NULL);
+  
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  /* create suncudavec::Vector with managed memory using the user-provided data arrays */
+  v->content = new vector_type(comm, local_length, global_length, true, false, vdata, vdata);
+
+  return(v);
+}
+#else
+N_Vector N_VNew_Cuda(sunindextype length)
+{
+  N_Vector v;
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  v->content = new vector_type(length);
+
+  return(v);
+}
+
+N_Vector N_VNewManaged_Cuda(sunindextype length)
+{
+  N_Vector v;
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  /* create suncudavec::Vector with managed memory */
+  v->content = new vector_type(length, true);
+
+  return(v);
+}
+
+N_Vector N_VMake_Cuda(sunindextype length, realtype *h_vdata, realtype *d_vdata)
+{
+  N_Vector v;
+
+  if (h_vdata == NULL || d_vdata == NULL) return(NULL);
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  /* create suncudavec::Vector using the user-provided data arrays */
+  v->content = new vector_type(length, false, false, h_vdata, d_vdata);
+
+  return(v);
+}
+
+N_Vector N_VMakeManaged_Cuda(sunindextype length, realtype *vdata)
+{
+  N_Vector v;
+
+  if (vdata == NULL) return(NULL);
+
+  v = NULL;
+  v = N_VNewEmpty_Cuda();
+  if (v == NULL) return(NULL);
+
+  /* create suncudavec::Vector with managed memory using the user-provided data arrays */
+  v->content = new vector_type(length, true, false, vdata, vdata);
+
+  return(v);
+}
+#endif
+
+/* -----------------------------------------------------------------
+ * Function to return the global length of the vector.
+ */
+sunindextype N_VGetLength_Cuda(N_Vector v)
+{
+  vector_type* xd = static_cast<vector_type*>(v->content);
+  return (xd->sizeGlobal());
+}
+
+
+#if SUNDIALS_MPI_ENABLED
+/* -----------------------------------------------------------------
+ * Function to return the local length of the vector.
+ */
+sunindextype N_VGetLocalLength_Cuda(N_Vector v)
+{
+  vector_type* xd = static_cast<vector_type*>(v->content);
+  return (xd->size());
+}
+
+/* -----------------------------------------------------------------
+ * Function to return the MPI communicator for the vector.
+ */
+MPI_Comm N_VGetMPIComm_Cuda(N_Vector v)
+{
+  vector_type* xd = static_cast<vector_type*>(v->content);
+  return (xd->comm());
+}
+#endif
+
+/* ----------------------------------------------------------------------------
+ * Return pointer to the raw host data
+ */
+
+realtype *N_VGetHostArrayPointer_Cuda(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  return (xv->host());
+}
+
+/* ----------------------------------------------------------------------------
+ * Return pointer to the raw device data
+ */
+
+realtype *N_VGetDeviceArrayPointer_Cuda(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  return (xv->device());
+}
+
+/* ----------------------------------------------------------------------------
+ * Return a flag indicating if the memory for the vector data is managed
+ */
+booleantype N_VIsManagedMemory_Cuda(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  return (xv->isManaged());
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * Sets the cudaStream_t to use for execution of the CUDA kernels.
+ */
+void N_VSetCudaStream_Cuda(N_Vector x, cudaStream_t *stream)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  xv->partStream().setStream(*stream);
+  xv->partReduce().setStream(*stream);
+}
+
+/* ----------------------------------------------------------------------------
+ * Copy vector data to the device
+ */
+
+void N_VCopyToDevice_Cuda(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  xv->copyToDev();
+}
+
+/* ----------------------------------------------------------------------------
+ * Copy vector data from the device to the host
+ */
+
+void N_VCopyFromDevice_Cuda(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  xv->copyFromDev();
+}
+
+/* ----------------------------------------------------------------------------
+ * Function to print the a CUDA-based vector to stdout
+ */
+
+void N_VPrint_Cuda(N_Vector x)
+{
+  N_VPrintFile_Cuda(x, stdout);
+}
+
+/* ----------------------------------------------------------------------------
+ * Function to print the a CUDA-based vector to outfile
+ */
+
+void N_VPrintFile_Cuda(N_Vector x, FILE *outfile)
+{
+  sunindextype i;
+  vector_type* xd = static_cast<vector_type*>(x->content);
+
+  for (i = 0; i < xd->size(); i++) {
+#if defined(SUNDIALS_EXTENDED_PRECISION)
+    fprintf(outfile, "%35.32Lg\n", xd->host()[i]);
+#elif defined(SUNDIALS_DOUBLE_PRECISION)
+    fprintf(outfile, "%19.16g\n", xd->host()[i]);
+#else
+    fprintf(outfile, "%11.8g\n", xd->host()[i]);
+#endif
+  }
+  fprintf(outfile, "\n");
+
+  return;
+}
+
+
+/*
+ * -----------------------------------------------------------------
+ * implementation of vector operations
+ * -----------------------------------------------------------------
+ */
+
+N_Vector N_VCloneEmpty_Cuda(N_Vector w)
+{
+  N_Vector v;
+  N_Vector_Ops ops;
+
+  if (w == NULL) return(NULL);
+
+  /* Create vector */
+  v = NULL;
+  v = (N_Vector) malloc(sizeof *v);
+  if (v == NULL) return(NULL);
+
+  /* Create vector operation structure */
+  ops = NULL;
+  ops = (N_Vector_Ops) malloc(sizeof(struct _generic_N_Vector_Ops));
+  if (ops == NULL) { free(v); return(NULL); }
+
+  ops->nvgetvectorid     = w->ops->nvgetvectorid;
+  ops->nvclone           = w->ops->nvclone;
+  ops->nvcloneempty      = w->ops->nvcloneempty;
+  ops->nvdestroy         = w->ops->nvdestroy;
+  ops->nvspace           = w->ops->nvspace;
+  ops->nvgetarraypointer = w->ops->nvgetarraypointer;
+  ops->nvsetarraypointer = w->ops->nvsetarraypointer;
+
+  /* standard vector operations */
+  ops->nvlinearsum    = w->ops->nvlinearsum;
+  ops->nvconst        = w->ops->nvconst;
+  ops->nvprod         = w->ops->nvprod;
+  ops->nvdiv          = w->ops->nvdiv;
+  ops->nvscale        = w->ops->nvscale;
+  ops->nvabs          = w->ops->nvabs;
+  ops->nvinv          = w->ops->nvinv;
+  ops->nvaddconst     = w->ops->nvaddconst;
+  ops->nvdotprod      = w->ops->nvdotprod;
+  ops->nvmaxnorm      = w->ops->nvmaxnorm;
+  ops->nvwrmsnormmask = w->ops->nvwrmsnormmask;
+  ops->nvwrmsnorm     = w->ops->nvwrmsnorm;
+  ops->nvmin          = w->ops->nvmin;
+  ops->nvwl2norm      = w->ops->nvwl2norm;
+  ops->nvl1norm       = w->ops->nvl1norm;
+  ops->nvcompare      = w->ops->nvcompare;
+  ops->nvinvtest      = w->ops->nvinvtest;
+  ops->nvconstrmask   = w->ops->nvconstrmask;
+  ops->nvminquotient  = w->ops->nvminquotient;
+
+  /* fused vector operations */
+  ops->nvlinearcombination = w->ops->nvlinearcombination;
+  ops->nvscaleaddmulti     = w->ops->nvscaleaddmulti;
+  ops->nvdotprodmulti      = w->ops->nvdotprodmulti;
+
+  /* vector array operations */
+  ops->nvlinearsumvectorarray         = w->ops->nvlinearsumvectorarray;
+  ops->nvscalevectorarray             = w->ops->nvscalevectorarray;
+  ops->nvconstvectorarray             = w->ops->nvconstvectorarray;
+  ops->nvwrmsnormvectorarray          = w->ops->nvwrmsnormvectorarray;
+  ops->nvwrmsnormmaskvectorarray      = w->ops->nvwrmsnormmaskvectorarray;
+  ops->nvscaleaddmultivectorarray     = w->ops->nvscaleaddmultivectorarray;
+  ops->nvlinearcombinationvectorarray = w->ops->nvlinearcombinationvectorarray;
+
+  /* Create content */
+  v->content = NULL;
+  v->ops  = ops;
+
+  return(v);
+}
+
+N_Vector N_VClone_Cuda(N_Vector w)
+{
+  N_Vector v;
+  vector_type* wdat = static_cast<vector_type*>(w->content);
+  vector_type* vdat = new vector_type(*wdat);
+  v = NULL;
+  v = N_VCloneEmpty_Cuda(w);
+  if (v == NULL) return(NULL);
+
+  v->content = vdat;
+
+  return(v);
+}
+
+
+void N_VDestroy_Cuda(N_Vector v)
+{
+  vector_type* x = static_cast<vector_type*>(v->content);
+  if (x != NULL) {
+    delete x;
+    v->content = NULL;
+  }
+
+  free(v->ops); v->ops = NULL;
+  free(v); v = NULL;
+
+  return;
+}
+
+void N_VSpace_Cuda(N_Vector X, sunindextype *lrw, sunindextype *liw)
+{
+  int npes;
+  vector_type* x = static_cast<vector_type*>(X->content);
+
+  SUNMPI_Comm_size(x->comm(), &npes);
+
+  *lrw = x->sizeGlobal();
+  *liw = 2*npes;
+}
+
+void N_VConst_Cuda(realtype a, N_Vector X)
+{
+  vector_type *xvec = static_cast<vector_type*>(X->content);
+  setConst(a, *xvec);
+}
+
+void N_VLinearSum_Cuda(realtype a, N_Vector X, realtype b, N_Vector Y, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *yvec = static_cast<vector_type*>(Y->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  linearSum(a, *xvec, b, *yvec, *zvec);
+}
+
+void N_VProd_Cuda(N_Vector X, N_Vector Y, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *yvec = static_cast<vector_type*>(Y->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  prod(*xvec, *yvec, *zvec);
+}
+
+void N_VDiv_Cuda(N_Vector X, N_Vector Y, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *yvec = static_cast<vector_type*>(Y->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  div(*xvec, *yvec, *zvec);
+}
+
+void N_VScale_Cuda(realtype a, N_Vector X, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  scale(a, *xvec, *zvec);
+}
+
+void N_VAbs_Cuda(N_Vector X, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  absVal(*xvec, *zvec);
+}
+
+void N_VInv_Cuda(N_Vector X, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  inv(*xvec, *zvec);
+}
+
+void N_VAddConst_Cuda(N_Vector X, realtype b, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  addConst(b, *xvec, *zvec);
+}
+
+realtype N_VDotProd_Cuda(N_Vector X, N_Vector Y)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *yvec = static_cast<vector_type*>(Y->content);
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype sum = dotProd(*xvec, *yvec);
+
+  realtype gsum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+  return gsum;
+}
+
+realtype N_VMaxNorm_Cuda(N_Vector X)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype locmax = maxNorm(*xvec);
+
+  realtype globmax = SUNMPI_Allreduce_scalar(locmax, 2, comm);
+  return globmax;
+}
+
+realtype N_VWrmsNorm_Cuda(N_Vector X, N_Vector W)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *wvec = static_cast<vector_type*>(W->content);
+  const sunindextype Nglob = xvec->sizeGlobal();
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype sum = wL2NormSquare(*xvec, *wvec);
+
+  realtype gsum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+  return std::sqrt(gsum/Nglob);
+}
+
+realtype N_VWrmsNormMask_Cuda(N_Vector X, N_Vector W, N_Vector Id)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *wvec = static_cast<vector_type*>(W->content);
+  const vector_type *ivec = static_cast<vector_type*>(Id->content);
+  const sunindextype Nglob = xvec->sizeGlobal();
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype sum = wL2NormSquareMask(*xvec, *wvec, *ivec);
+
+  realtype gsum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+  return std::sqrt(gsum/Nglob);
+}
+
+realtype N_VMin_Cuda(N_Vector X)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype locmin = findMin(*xvec);
+
+  realtype globmin = SUNMPI_Allreduce_scalar(locmin, 3, comm);
+  return globmin;
+}
+
+realtype N_VWL2Norm_Cuda(N_Vector X, N_Vector W)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  const vector_type *wvec = static_cast<vector_type*>(W->content);
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype sum = wL2NormSquare(*xvec, *wvec);
+
+  realtype gsum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+  return std::sqrt(gsum);
+}
+
+realtype N_VL1Norm_Cuda(N_Vector X)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype sum = L1Norm(*xvec);
+
+  realtype gsum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+  return gsum;
+}
+
+void N_VCompare_Cuda(realtype c, N_Vector X, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  compare(c, *xvec, *zvec);
+}
+
+booleantype N_VInvTest_Cuda(N_Vector X, N_Vector Z)
+{
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *zvec = static_cast<vector_type*>(Z->content);
+  SUNMPI_Comm comm = xvec->comm();
+  
+  realtype locmin = invTest(*xvec, *zvec);
+
+  realtype globmin = SUNMPI_Allreduce_scalar(locmin, 3, comm);
+  return (globmin < HALF);
+}
+
+/*
+ * Creates mask for variables violating constraints
+ */
+booleantype N_VConstrMask_Cuda(N_Vector C, N_Vector X, N_Vector M)
+{
+  const vector_type *cvec = static_cast<vector_type*>(C->content);
+  const vector_type *xvec = static_cast<vector_type*>(X->content);
+  vector_type *mvec = static_cast<vector_type*>(M->content);
+  SUNMPI_Comm comm = xvec->comm();
+
+  realtype locsum = constrMask(*cvec, *xvec, *mvec);
+
+  realtype globsum = SUNMPI_Allreduce_scalar(locsum, 1, comm);
+  return (globsum < HALF);
+}
+
+realtype N_VMinQuotient_Cuda(N_Vector num, N_Vector denom)
+{
+  const vector_type *numvec = static_cast<vector_type*>(num->content);
+  const vector_type *denvec = static_cast<vector_type*>(denom->content);
+  SUNMPI_Comm comm = numvec->comm();
+
+  realtype locmin = minQuotient(*numvec, *denvec);
+
+  realtype globmin = SUNMPI_Allreduce_scalar(locmin, 3, comm);
+  return globmin;
+}
+
+/*
+ * -----------------------------------------------------------------
+ * fused vector operations
+ * -----------------------------------------------------------------
+ */
+
+int N_VLinearCombination_Cuda(int nvec, realtype* c, N_Vector* X, N_Vector Z)
+{
+  cudaError_t err;
+  vector_type** Xv;
+  vector_type*  Zv;
+
+  Zv = static_cast<vector_type*>(Z->content);
+
+  Xv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Xv[i] = static_cast<vector_type*>(X[i]->content);
+
+  err = linearCombination(nvec, c, Xv, Zv);
+
+  delete[] Xv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+int N_VScaleAddMulti_Cuda(int nvec, realtype* c, N_Vector X, N_Vector* Y,
+                           N_Vector* Z)
+{
+  cudaError_t err;
+  vector_type*  Xv;
+  vector_type** Yv;
+  vector_type** Zv;
+
+  Xv = static_cast<vector_type*>(X->content);
+
+  Yv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Yv[i] = static_cast<vector_type*>(Y[i]->content);
+
+  Zv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Zv[i] = static_cast<vector_type*>(Z[i]->content);
+
+  err = scaleAddMulti(nvec, c, Xv, Yv, Zv);
+
+  delete[] Yv;
+  delete[] Zv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VDotProdMulti_Cuda(int nvec, N_Vector x, N_Vector* Y, realtype* dotprods)
+{
+  cudaError_t err;
+  SUNMPI_Comm comm;
+  vector_type*  Xv;
+  vector_type** Yv;
+
+  Xv = static_cast<vector_type*>(x->content);
+  comm = Xv->comm();
+
+  Yv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Yv[i] = static_cast<vector_type*>(Y[i]->content);
+
+  err = dotProdMulti(nvec, Xv, Yv, dotprods);
+
+  delete[] Yv;
+
+  SUNMPI_Allreduce(dotprods, nvec, 1, comm);
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * vector array operations
+ * -----------------------------------------------------------------------------
+ */
+
+int N_VLinearSumVectorArray_Cuda(int nvec, realtype a, N_Vector* X, realtype b,
+                                 N_Vector* Y, N_Vector* Z)
+{
+  cudaError_t err;
+  vector_type** Xv;
+  vector_type** Yv;
+  vector_type** Zv;
+
+  Xv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Xv[i] = static_cast<vector_type*>(X[i]->content);
+
+  Yv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Yv[i] = static_cast<vector_type*>(Y[i]->content);
+
+  Zv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Zv[i] = static_cast<vector_type*>(Z[i]->content);
+
+  err = linearSumVectorArray(nvec, a, Xv, b, Yv, Zv);
+
+  delete[] Xv;
+  delete[] Yv;
+  delete[] Zv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VScaleVectorArray_Cuda(int nvec, realtype* c, N_Vector* X, N_Vector* Z)
+{
+  cudaError_t err;
+  vector_type** Xv;
+  vector_type** Zv;
+
+  Xv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Xv[i] = static_cast<vector_type*>(X[i]->content);
+
+  Zv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Zv[i] = static_cast<vector_type*>(Z[i]->content);
+
+  err = scaleVectorArray(nvec, c, Xv, Zv);
+
+  delete[] Xv;
+  delete[] Zv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VConstVectorArray_Cuda(int nvec, realtype c, N_Vector* Z)
+{
+  cudaError_t err;
+  vector_type** Zv;
+
+  Zv = new vector_type*[nvec];
+  for (int i=0; i<nvec; i++)
+    Zv[i] = static_cast<vector_type*>(Z[i]->content);
+
+  err = constVectorArray(nvec, c, Zv);
+
+  delete[] Zv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VWrmsNormVectorArray_Cuda(int nvec, N_Vector* X, N_Vector* W,
+                                realtype* norms)
+{
+  cudaError_t err;
+  const vector_type* xvec = static_cast<vector_type*>(X[0]->content);
+  vector_type** Xv;
+  vector_type** Wv;
+  
+  SUNMPI_Comm comm = xvec->comm();
+  sunindextype N = xvec->sizeGlobal();
+
+  Xv = new vector_type*[nvec];
+  for (int k=0; k<nvec; k++)
+    Xv[k] = static_cast<vector_type*>(X[k]->content);
+
+  Wv = new vector_type*[nvec];
+  for (int k=0; k<nvec; k++)
+    Wv[k] = static_cast<vector_type*>(W[k]->content);
+
+  err = wL2NormSquareVectorArray(nvec, Xv, Wv, norms);
+
+  delete[] Xv;
+  delete[] Wv;
+
+  SUNMPI_Allreduce(norms, nvec, 1, comm);
+
+  for (int k=0; k<nvec; ++k) {
+    norms[k] = std::sqrt(norms[k]/N);
+  }
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VWrmsNormMaskVectorArray_Cuda(int nvec, N_Vector* X, N_Vector* W,
+                                    N_Vector id, realtype* norms)
+{
+  cudaError_t err;
+  const vector_type* xvec = static_cast<vector_type*>(X[0]->content);
+  vector_type** Xv;
+  vector_type** Wv;
+  vector_type*  IDv;
+  
+  SUNMPI_Comm comm = xvec->comm();
+  sunindextype N = xvec->sizeGlobal();
+
+  Xv = new vector_type*[nvec];
+  for (int k=0; k<nvec; k++)
+    Xv[k] = static_cast<vector_type*>(X[k]->content);
+
+  Wv = new vector_type*[nvec];
+  for (int k=0; k<nvec; k++)
+    Wv[k] = static_cast<vector_type*>(W[k]->content);
+
+  IDv = static_cast<vector_type*>(id->content);
+
+  err = wL2NormSquareMaskVectorArray(nvec, Xv, Wv, IDv, norms);
+
+  delete[] Xv;
+  delete[] Wv;
+
+  SUNMPI_Allreduce(norms, nvec, 1, comm);
+
+  for (int k=0; k<nvec; ++k) {
+    norms[k] = std::sqrt(norms[k]/N);
+  }
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VScaleAddMultiVectorArray_Cuda(int nvec, int nsum, realtype* c,
+                                      N_Vector* X, N_Vector** Y, N_Vector** Z)
+{
+  cudaError_t err;
+  vector_type** Xv;
+  vector_type** Yv;
+  vector_type** Zv;
+
+  Xv = new vector_type*[nvec];
+  for (int k=0; k<nvec; k++)
+    Xv[k] = static_cast<vector_type*>(X[k]->content);
+
+  Yv = new vector_type*[nsum*nvec];
+  for (int k=0; k<nvec; k++)
+    for (int j=0; j<nsum; j++)
+      Yv[k*nsum+j] = static_cast<vector_type*>(Y[j][k]->content);
+
+  Zv = new vector_type*[nsum*nvec];
+  for (int k=0; k<nvec; k++)
+    for (int j=0; j<nsum; j++)
+      Zv[k*nsum+j] = static_cast<vector_type*>(Z[j][k]->content);
+
+  err = scaleAddMultiVectorArray(nvec, nsum, c, Xv, Yv, Zv);
+
+  delete[] Xv;
+  delete[] Yv;
+  delete[] Zv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+int N_VLinearCombinationVectorArray_Cuda(int nvec, int nsum, realtype* c,
+                                         N_Vector** X, N_Vector* Z)
+{
+  cudaError_t err;
+  vector_type** Xv;
+  vector_type** Zv;
+
+  Xv = new vector_type*[nsum*nvec];
+  for (int k=0; k<nvec; k++)
+    for (int j=0; j<nsum; j++)
+      Xv[k*nsum+j] = static_cast<vector_type*>(X[j][k]->content);
+
+  Zv = new vector_type*[nvec];
+  for (int k=0; k<nvec; k++)
+    Zv[k] = static_cast<vector_type*>(Z[k]->content);
+
+  err = linearCombinationVectorArray(nvec, nsum, c, Xv, Zv);
+
+  delete[] Xv;
+  delete[] Zv;
+
+  return err == cudaSuccess ? 0 : -1;
+}
+
+
+/*
+ * -----------------------------------------------------------------
+ * Enable / Disable fused and vector array operations
+ * -----------------------------------------------------------------
+ */
+
+int N_VEnableFusedOps_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  if (tf) {
+    /* enable all fused vector operations */
+    v->ops->nvlinearcombination = N_VLinearCombination_Cuda;
+    v->ops->nvscaleaddmulti     = N_VScaleAddMulti_Cuda;
+    v->ops->nvdotprodmulti      = N_VDotProdMulti_Cuda;
+    /* enable all vector array operations */
+    v->ops->nvlinearsumvectorarray         = N_VLinearSumVectorArray_Cuda;
+    v->ops->nvscalevectorarray             = N_VScaleVectorArray_Cuda;
+    v->ops->nvconstvectorarray             = N_VConstVectorArray_Cuda;
+    v->ops->nvwrmsnormvectorarray          = N_VWrmsNormVectorArray_Cuda;
+    v->ops->nvwrmsnormmaskvectorarray      = N_VWrmsNormMaskVectorArray_Cuda;
+    v->ops->nvscaleaddmultivectorarray     = N_VScaleAddMultiVectorArray_Cuda;
+    v->ops->nvlinearcombinationvectorarray = N_VLinearCombinationVectorArray_Cuda;
+  } else {
+    /* disable all fused vector operations */
+    v->ops->nvlinearcombination = NULL;
+    v->ops->nvscaleaddmulti     = NULL;
+    v->ops->nvdotprodmulti      = NULL;
+    /* disable all vector array operations */
+    v->ops->nvlinearsumvectorarray         = NULL;
+    v->ops->nvscalevectorarray             = NULL;
+    v->ops->nvconstvectorarray             = NULL;
+    v->ops->nvwrmsnormvectorarray          = NULL;
+    v->ops->nvwrmsnormmaskvectorarray      = NULL;
+    v->ops->nvscaleaddmultivectorarray     = NULL;
+    v->ops->nvlinearcombinationvectorarray = NULL;
+  }
+
+  /* return success */
+  return(0);
+}
+
+
+int N_VEnableLinearCombination_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvlinearcombination = N_VLinearCombination_Cuda;
+  else
+    v->ops->nvlinearcombination = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableScaleAddMulti_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvscaleaddmulti = N_VScaleAddMulti_Cuda;
+  else
+    v->ops->nvscaleaddmulti = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableDotProdMulti_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvdotprodmulti = N_VDotProdMulti_Cuda;
+  else
+    v->ops->nvdotprodmulti = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableLinearSumVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvlinearsumvectorarray = N_VLinearSumVectorArray_Cuda;
+  else
+    v->ops->nvlinearsumvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableScaleVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvscalevectorarray = N_VScaleVectorArray_Cuda;
+  else
+    v->ops->nvscalevectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableConstVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvconstvectorarray = N_VConstVectorArray_Cuda;
+  else
+    v->ops->nvconstvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableWrmsNormVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvwrmsnormvectorarray = N_VWrmsNormVectorArray_Cuda;
+  else
+    v->ops->nvwrmsnormvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableWrmsNormMaskVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvwrmsnormmaskvectorarray = N_VWrmsNormMaskVectorArray_Cuda;
+  else
+    v->ops->nvwrmsnormmaskvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableScaleAddMultiVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvscaleaddmultivectorarray = N_VScaleAddMultiVectorArray_Cuda;
+  else
+    v->ops->nvscaleaddmultivectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableLinearCombinationVectorArray_Cuda(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvlinearcombinationvectorarray = N_VLinearCombinationVectorArray_Cuda;
+  else
+    v->ops->nvlinearcombinationvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+} // extern "C"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b98e840415bbb2f8aa00cda2933c3012c0720683
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/CMakeLists.txt
@@ -0,0 +1,109 @@
+# ---------------------------------------------------------------
+# Programmer:  Steve Smith, and Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the openmp NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_OPENMP\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable nvecopenmp_SOURCES with the sources for the NVECOPENMP lib
+SET(nvecopenmp_SOURCES nvector_openmp.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECOPENMP library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable nvecopenmp_HEADERS with the exported NVECOPENMP header files
+SET(nvecopenmp_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_openmp.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+# Use C flags for linker as well.
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_C_FLAGS}")
+
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECOPENMP library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECOPENMP library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvecopenmp_static STATIC ${nvecopenmp_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_nvecopenmp_static
+    PROPERTIES OUTPUT_NAME sundials_nvecopenmp CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nvecopenmp_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECOPENMP library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECOPENMP library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvecopenmp_shared SHARED ${nvecopenmp_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecopenmp_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_nvecopenmp_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecopenmp CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_nvecopenmp_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nvecopenmp_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECOPENMP header files
+INSTALL(FILES ${nvecopenmp_HEADERS} DESTINATION include/nvector)
+
+# If FCMIX is enabled, build and install the FNVECOPENMP library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fnvecopenmp_SOURCES fnvector_openmp.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fnvecopenmp_static STATIC ${fnvecopenmp_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fnvecopenmp_static
+      PROPERTIES OUTPUT_NAME sundials_fnvecopenmp CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fnvecopenmp_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fnvecopenmp_shared ${fnvecopenmp_SOURCES})
+
+    # fnvecopenmp depends on nvecopenmp
+    TARGET_LINK_LIBRARIES(sundials_fnvecopenmp_shared sundials_nvecopenmp_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fnvecopenmp_shared
+      PROPERTIES OUTPUT_NAME sundials_fnvecopenmp CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fnvecopenmp_shared
+      PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+    INSTALL(TARGETS sundials_fnvecopenmp_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added NVECTOR_OPENMP module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b27dc60a30e144a7daace1f9173bdadf05c3755
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 openmp NVECTOR object library
+
+set(nvecopenmp_SOURCES fnvector_openmp.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fnvecopenmp_mod_static STATIC
+    ${nvecopenmp_SOURCES}
+  )
+  set_target_properties(sundials_fnvecopenmp_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fnvecopenmp_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fnvecopenmp_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fnvecopenmp_mod_shared SHARED
+    ${nvecopenmp_SOURCES}
+  )
+  set_target_properties(sundials_fnvecopenmp_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fnvecopenmp_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fnvecopenmp_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fnvecopenmp_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added NVECTOR_OPENMP F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/F90/fnvector_openmp.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/F90/fnvector_openmp.f90
new file mode 100644
index 0000000000000000000000000000000000000000..87d2b30318093d8e60bc82f4d176a0c8409ebbdb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmp/F90/fnvector_openmp.f90
@@ -0,0 +1,480 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS OpenMP NVector using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fnvector_openmp_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VNew_OpenMP
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VNew_OpenMP(vec_length, num_threads) &
+          bind(C,name='N_VNew_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: vec_length
+       integer(c_int),  value :: num_threads
+     end function FN_VNew_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VNewEmpty_OpenMP
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VNewEmpty_OpenMP(vec_length, num_threads) &
+          bind(C,name='N_VNewEmpty_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: vec_length
+       integer(c_int),  value :: num_threads
+     end function FN_VNewEmpty_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VMake_OpenMP
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VMake_OpenMP(length, v_data, num_threads) &
+          bind(C,name='N_VMake_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: length
+       real(c_double)         :: v_data(length)
+       integer(c_int),  value :: num_threads
+     end function FN_VMake_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneVectorArray_OpenMP: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneVectorArrayEmpty_OpenMP: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VDestroy_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VDestroy_OpenMP(v) &
+          bind(C,name='N_VDestroy_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end subroutine FN_VDestroy_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VDestroyVectorArray_OpenMP: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Other routines
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VGetLength_OpenMP
+     ! -----------------------------------------------------------------
+
+     integer(c_long) function FN_VGetLength_OpenMP(v) &
+          bind(C,name='N_VGetLength_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end function FN_VGetLength_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VPrint_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VPrint_OpenMP(v) &
+          bind(C,name='N_VPrint_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end subroutine FN_VPrint_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: N_VPrintFile_OpenMP
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VGetVectorID_OpenMP
+     ! -----------------------------------------------------------------
+     
+     integer(c_int) function FN_VGetVectorID_OpenMP(v) &
+          bind(C,name='N_VGetVectorID_OpenMP')
+        use, intrinsic :: iso_c_binding
+        implicit none
+        type(c_ptr), value :: v
+     end function FN_VGetVectorID_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneEmpty_OpenMP
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VCloneEmpty_OpenMP(w) &
+          bind(C,name='N_VCloneEmpty_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: w
+     end function FN_VCloneEmpty_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VClone_OpenMP
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VClone_OpenMP(w) &
+          bind(C,name='N_VClone_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: w
+     end function FN_VClone_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VSpace_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VSpace_OpenMP(v, lrw, liw) &
+          bind(C,name='N_VSpace_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+       integer(c_long)    :: lrw
+       integer(c_long)    :: liw
+     end subroutine FN_VSpace_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VGetArrayPointer_OpenMP
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VGetArrayPointer_OpenMP(vec) &
+          bind(C,name='N_VGetArrayPointer_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: vec
+     end function FN_VGetArrayPointer_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VSetArrayPointer_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VSetArrayPointer_OpenMP(v_data, v) &
+          bind(C,name='N_VSetArrayPointer_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v_data
+       type(c_ptr), value :: v
+     end subroutine FN_VSetArrayPointer_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VLinearSum_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VLinearSum_OpenMP(a, x, b, y, z) &
+          bind(C,name='N_VLinearSum_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: a
+       type(c_ptr),    value :: x
+       real(c_double), value :: b
+       type(c_ptr),    value :: y
+       type(c_ptr),    value :: z
+     end subroutine FN_VLinearSum_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VConst_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VConst_OpenMP(c, z) &
+          bind(C,name='N_VConst_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: z
+     end subroutine FN_VConst_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VProd_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VProd_OpenMP(x, y, z) &
+          bind(C,name='N_VProd_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+       type(c_ptr), value :: z
+     end subroutine FN_VProd_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VDiv_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VDiv_OpenMP(x, y, z) &
+          bind(C,name='N_VDiv_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+       type(c_ptr), value :: z
+     end subroutine FN_VDiv_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VScale_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VScale_OpenMP(c, x, z) &
+          bind(C,name='N_VScale_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: z
+     end subroutine FN_VScale_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VAbs_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VAbs_OpenMP(x, z) &
+          bind(C,name='N_VAbs_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end subroutine FN_VAbs_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VInv_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VInv_OpenMP(x, z) &
+          bind(C,name='N_VInv_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end subroutine FN_VInv_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VAddConst
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VAddConst_OpenMP(x, b, z) &
+          bind(C,name='N_VAddConst_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: x
+       real(c_double), value :: b
+       type(c_ptr),    value :: z
+     end subroutine FN_VAddConst_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VDotProd_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VDotProd_OpenMP(x, y) &
+          bind(C,name='N_VDotProd_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+     end function FN_VDotProd_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VMaxNorm_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMaxNorm_OpenMP(x) &
+          bind(C,name='N_VMaxNorm_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VMaxNorm_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VWrmsNorm_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWrmsNorm_OpenMP(x, w) &
+          bind(C,name='N_VWrmsNorm_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+     end function FN_VWrmsNorm_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VWrmsNormMask_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWrmsNormMask_OpenMP(x, w, id) &
+          bind(C,name='N_VWrmsNormMask_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+       type(c_ptr), value :: id
+     end function FN_VWrmsNormMask_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VMin_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMin_OpenMP(x) &
+          bind(C,name='N_VMin_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VMin_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VWL2Norm_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWL2Norm_OpenMP(x, w) &
+          bind(C,name='N_VWL2Norm_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+     end function FN_VWL2Norm_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VL1Norm_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VL1Norm_OpenMP(x) &
+          bind(C,name='N_VL1Norm_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VL1Norm_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VCompare_OpenMP
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VCompare_OpenMP(c, x, z) &
+          bind(C,name='N_VCompare_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: z
+     end subroutine FN_VCompare_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VInvTest_OpenMP
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FN_VInvTest_OpenMP(x, z) &
+          bind(C,name='N_VInvTest_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end function FN_VInvTest_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VConstrMask_OpenMP
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FN_VConstrMask_OpenMP(c, x, m) &
+          bind(C,name='N_VConstrMask_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: c
+       type(c_ptr), value :: x
+       type(c_ptr), value :: m
+     end function FN_VConstrMask_OpenMP
+
+     ! -----------------------------------------------------------------
+     ! N_VMinQuotient_OpenMP
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMinQuotient_OpenMP(num, denom) &
+          bind(C,name='N_VMinQuotient_OpenMP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: num
+       type(c_ptr), value :: denom
+     end function FN_VMinQuotient_OpenMP
+
+     ! ================================================================
+     ! Fused vector operations: NOT INTERFACED
+     ! ================================================================
+
+     ! ================================================================
+     ! Vector array operations: NOT INTERFACED
+     ! ================================================================
+     
+   end interface
+
+contains
+
+  ! ================================================================
+  ! Helpful routines
+  ! ================================================================
+
+  ! ----------------------------------------------------------------
+  ! FN_VGetData_OpenMP 
+  ! 
+  ! Extracts data array from a OpenMP SUNDIALS N_Vector
+  ! ----------------------------------------------------------------
+
+  subroutine FN_VGetData_OpenMP(vec, f_array)
+
+    !======= Inclusions ===========
+    use, intrinsic :: iso_c_binding
+
+    !======= Declarations =========
+    implicit none
+
+    ! calling variables
+    type(c_ptr)             :: vec
+    integer(c_long)         :: length
+    real(c_double), pointer :: f_array(:)
+
+    ! C pointer for N_Vector interal data array
+    type(c_ptr) :: c_array
+
+    !======= Internals ============
+
+    ! get data pointer from N_Vector
+    c_array = FN_VGetArrayPointer_OpenMP(vec)
+
+    ! get vector length
+    length = FN_VGetLength_OpenMP(vec)
+    
+    ! convert c pointer to f pointer
+    call c_f_pointer(c_array, f_array, (/length/))
+
+  end subroutine FN_VGetData_OpenMP
+
+end module fnvector_openmp_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmpdev/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmpdev/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b34da7a0df3ccc534269ffb6442df78379ac6720
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/openmpdev/CMakeLists.txt
@@ -0,0 +1,79 @@
+# ---------------------------------------------------------------
+# Programmer: David J. Gardner @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the openmpdev NVECTOR library
+# ---------------------------------------------------------------
+
+install(CODE "MESSAGE(\"\nInstall NVECTOR_OPENMPDEV\n\")")
+
+# Add variable nvecopenmpdev_SOURCES with the sources for the NVECOPENMPDEV lib
+set(nvecopenmpdev_SOURCES nvector_openmpdev.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECOPENMPDEV library
+set(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable nvecopenmpdev_HEADERS with the exported NVECOPENMPDEV header files
+set(nvecopenmpdev_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_openmpdev.h
+  )
+
+# Add source directory to include directories
+include_directories(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+add_definitions(-DBUILD_SUNDIALS_LIBRARY)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+# Use C flags for linker as well.
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_C_FLAGS}")
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECOPENMPDEV library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECOPENMPDEV library
+if(BUILD_STATIC_LIBS)
+  add_library(sundials_nvecopenmpdev_static STATIC ${nvecopenmpdev_SOURCES} ${shared_SOURCES})
+  set_target_properties(sundials_nvecopenmpdev_static
+    PROPERTIES OUTPUT_NAME sundials_nvecopenmpdev CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_nvecopenmpdev_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECOPENMPDEV library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECOPENMPDEV library
+if(BUILD_SHARED_LIBS)
+  add_library(sundials_nvecopenmpdev_shared SHARED ${nvecopenmpdev_SOURCES} ${shared_SOURCES})
+
+  if(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecopenmpdev_shared m)
+  endif()
+
+  set_target_properties(sundials_nvecopenmpdev_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecopenmpdev CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_nvecopenmpdev_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_nvecopenmpdev_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+endif()
+
+# Install the NVECOPENMPDEV header files
+INSTALL(FILES ${nvecopenmpdev_HEADERS} DESTINATION include/nvector)
+
+#
+MESSAGE(STATUS "Added NVECTOR_OPENMPDEV module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/parallel/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/parallel/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f2617c8b4904035cdadb2a104c463ed616e67328
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/parallel/CMakeLists.txt
@@ -0,0 +1,106 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the parallel NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_PARALLEL\n\")")
+
+IF(MPI_C_COMPILER)
+  # use MPI wrapper as the compiler
+  SET(CMAKE_C_COMPILER ${MPI_C_COMPILER})
+ELSE()
+  # add MPI_INCLUDE_PATH to include directories
+  INCLUDE_DIRECTORIES(${MPI_INCLUDE_PATH})
+ENDIF()
+
+# Add variable nvecparallel_SOURCES with the sources for the NVECPARALLEL lib
+SET(nvecparallel_SOURCES nvector_parallel.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECPARALLEL library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_mpi.c
+  )
+
+# Add variable nvecparallel_HEADERS with the exported NVECPARALLEL header files
+SET(nvecparallel_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_parallel.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECPARALLEL library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECPARALLEL library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvecparallel_static STATIC ${nvecparallel_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_nvecparallel_static
+    PROPERTIES OUTPUT_NAME sundials_nvecparallel CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nvecparallel_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECPARALLEL library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECPARALLEL library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvecparallel_shared SHARED ${nvecparallel_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecparallel_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_nvecparallel_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecparallel CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_nvecparallel_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nvecparallel_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECPARALLEL header files
+INSTALL(FILES ${nvecparallel_HEADERS} DESTINATION include/nvector)
+
+# If FCMIX is enabled and MPI works, build and install the FNVECPARALLEL library
+IF(F77_INTERFACE_ENABLE AND MPI_Fortran_FOUND)
+  SET(fnvecparallel_SOURCES fnvector_parallel.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fnvecparallel_static STATIC ${fnvecparallel_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fnvecparallel_static
+      PROPERTIES OUTPUT_NAME sundials_fnvecparallel CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fnvecparallel_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fnvecparallel_shared SHARED ${fnvecparallel_SOURCES})
+
+    # fnvecparallel depends on nvecparallel
+    TARGET_LINK_LIBRARIES(sundials_fnvecparallel_shared sundials_nvecparallel_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fnvecparallel_shared
+      PROPERTIES OUTPUT_NAME sundials_fnvecparallel CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fnvecparallel_shared
+      PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+    INSTALL(TARGETS sundials_fnvecparallel_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF()
+#
+MESSAGE(STATUS "Added NVECTOR_PARALLEL module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/parhyp/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/parhyp/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..da894befdf466a3ec618aef4e0591ec4d41f51b6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/parhyp/CMakeLists.txt
@@ -0,0 +1,86 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the parhyp NVECTOR library
+# ---------------------------------------------------------------
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_PARHYP\n\")")
+
+IF(MPI_C_COMPILER)
+  # use MPI wrapper as the compiler
+  SET(CMAKE_C_COMPILER ${MPI_C_COMPILER})
+ELSE()
+  # add MPI_INCLUDE_PATH to include directories
+  INCLUDE_DIRECTORIES(${MPI_INCLUDE_PATH})
+ENDIF()
+
+# Add variable nvecparhyp_SOURCES with the sources for the NVECPARHYP lib
+SET(nvecparhyp_SOURCES nvector_parhyp.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECPARHYP library
+SET(shared_SOURCES
+  sundials_math.c
+  sundials_mpi.c
+  )
+ADD_PREFIX(${sundials_SOURCE_DIR}/src/sundials/ shared_SOURCES)
+
+# Add variable nvecparhyp_HEADERS with the exported NVECPARHYP header files
+SET(nvecparhyp_HEADERS nvector_parhyp.h)
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/nvector/ nvecparhyp_HEADERS)
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(${HYPRE_INCLUDE_DIR})
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECPARHYP library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECPARHYP library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvecparhyp_static STATIC ${nvecparhyp_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_nvecparhyp_static
+    PROPERTIES OUTPUT_NAME sundials_nvecparhyp CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nvecparhyp_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECPARHYP library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECPARHYP library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvecparhyp_shared SHARED ${nvecparhyp_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecparhyp_shared m)
+  ENDIF()
+
+  # nvecparhyp depends on hypre
+  TARGET_LINK_LIBRARIES(sundials_nvecparhyp_shared ${HYPRE_LIBRARIES})
+
+  SET_TARGET_PROPERTIES(sundials_nvecparhyp_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecparhyp CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_nvecparhyp_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nvecparhyp_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECPARHYP header files
+INSTALL(FILES ${nvecparhyp_HEADERS} DESTINATION include/nvector)
+
+#
+MESSAGE(STATUS "Added NVECTOR_PARHYP module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/petsc/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/petsc/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8258ccf131da6fbffd8b1eb13659524fb3cdf699
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/petsc/CMakeLists.txt
@@ -0,0 +1,85 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the petsc NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_PETSC\n\")")
+
+IF(MPI_C_COMPILER)
+  # use MPI wrapper as the compiler
+  SET(CMAKE_C_COMPILER ${MPI_C_COMPILER})
+ELSE()
+  # add MPI_INCLUDE_PATH to include directories
+  INCLUDE_DIRECTORIES(${MPI_INCLUDE_PATH})
+ENDIF()
+
+# Add variable nvecpetsc_SOURCES with the sources for the NVECPARHYP lib
+SET(nvecpetsc_SOURCES nvector_petsc.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECPARHYP library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_mpi.c
+  )
+
+# Add variable nvecpetsc_HEADERS with the exported NVECPARHYP header files
+SET(nvecpetsc_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_petsc.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(${PETSC_INCLUDE_DIR})
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECPARHYP library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECPARHYP library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvecpetsc_static STATIC ${nvecpetsc_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_nvecpetsc_static
+    PROPERTIES OUTPUT_NAME sundials_nvecpetsc CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nvecpetsc_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECPARHYP library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECPARHYP library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvecpetsc_shared SHARED ${nvecpetsc_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecpetsc_shared m)
+  ENDIF()
+
+  # nvecpetsc depends on PETSc
+  TARGET_LINK_LIBRARIES(sundials_nvecpetsc_shared ${PETSC_LIBRARIES})
+
+  SET_TARGET_PROPERTIES(sundials_nvecpetsc_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecpetsc CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_nvecpetsc_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nvecpetsc_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECPARHYP header files
+INSTALL(FILES ${nvecpetsc_HEADERS} DESTINATION include/nvector)
+
+#
+MESSAGE(STATUS "Added NVECTOR_PETSC module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e2f15aa5c8575e7d7c3dd1e88f4cf698cd660a02
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/CMakeLists.txt
@@ -0,0 +1,104 @@
+# ---------------------------------------------------------------
+# Programmer:  Steve Smith, and Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the pthreads NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_PTHREADS\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable nvecpthreads_SOURCES with the sources for the NVECPTHREADS lib
+SET(nvecpthreads_SOURCES nvector_pthreads.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECPTHREADS library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable nvecpthreads_HEADERS with the exported NVECPTHREADS header files
+SET(nvecpthreads_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_pthreads.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECPTHREADS library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECPTHREADS library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvecpthreads_static STATIC ${nvecpthreads_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_nvecpthreads_static
+    PROPERTIES OUTPUT_NAME sundials_nvecpthreads CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nvecpthreads_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECPTHREADS library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECPTHREADS library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvecpthreads_shared SHARED ${nvecpthreads_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecpthreads_shared m)
+  ENDIF()
+
+  TARGET_LINK_LIBRARIES(sundials_nvecpthreads_shared pthread)
+
+  SET_TARGET_PROPERTIES(sundials_nvecpthreads_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecpthreads CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_nvecpthreads_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nvecpthreads_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECPTHREADS header files
+INSTALL(FILES ${nvecpthreads_HEADERS} DESTINATION include/nvector)
+
+# If FCMIX is enabled, build and install the FNVECPTHREADS library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fnvecpthreads_SOURCES fnvector_pthreads.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fnvecpthreads_static STATIC ${fnvecpthreads_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fnvecpthreads_static
+      PROPERTIES OUTPUT_NAME sundials_fnvecpthreads CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fnvecpthreads_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fnvecpthreads_shared ${fnvecpthreads_SOURCES})
+
+    # fnvecpthreads depends on nvecpthreads
+    TARGET_LINK_LIBRARIES(sundials_fnvecpthreads_shared sundials_nvecpthreads_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fnvecpthreads_shared
+      PROPERTIES OUTPUT_NAME sundials_fnvecpthreads CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fnvecpthreads_shared
+      PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+    INSTALL(TARGETS sundials_fnvecpthreads_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added NVECTOR_PTHREADS module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..19ec4ebd399c99dc42cdb8f8f931c2809c5b0efc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 Pthreads NVECTOR object library
+
+set(nvecpthreads_SOURCES fnvector_pthreads.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fnvecpthreads_mod_static STATIC
+    ${nvecpthreads_SOURCES}
+  )
+  set_target_properties(sundials_fnvecpthreads_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fnvecpthreads_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fnvecpthreads_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fnvecpthreads_mod_shared SHARED
+    ${nvecpthreads_SOURCES}
+  )
+  set_target_properties(sundials_fnvecpthreads_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fnvecpthreads_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fnvecpthreads_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fnvecpthreads_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added NVECTOR_PTHREADS F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/F90/fnvector_pthreads.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/F90/fnvector_pthreads.f90
new file mode 100644
index 0000000000000000000000000000000000000000..4f4b97e87b5cc4ceebcaddd1ea1cbc9c048cd647
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/pthreads/F90/fnvector_pthreads.f90
@@ -0,0 +1,480 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS Pthreads NVector using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fnvector_pthreads_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VNew_Pthreads
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VNew_Pthreads(vec_length, num_threads) &
+          bind(C,name='N_VNew_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: vec_length
+       integer(c_int),  value :: num_threads
+     end function FN_VNew_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VNewEmpty_Pthreads
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VNewEmpty_Pthreads(vec_length, num_threads) &
+          bind(C,name='N_VNewEmpty_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: vec_length
+       integer(c_int),  value :: num_threads
+     end function FN_VNewEmpty_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VMake_Pthreads
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VMake_Pthreads(length, v_data, num_threads) &
+          bind(C,name='N_VMake_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: length
+       real(c_double)         :: v_data(length)
+       integer(c_int),  value :: num_threads
+     end function FN_VMake_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneVectorArray_Pthreads: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneVectorArrayEmpty_Pthreads: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VDestroy_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VDestroy_Pthreads(v) &
+          bind(C,name='N_VDestroy_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end subroutine FN_VDestroy_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VDestroyVectorArray_Pthreads: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Other routines
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VGetLength_Pthreads
+     ! -----------------------------------------------------------------
+
+     integer(c_long) function FN_VGetLength_Pthreads(v) &
+          bind(C,name='N_VGetLength_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end function FN_VGetLength_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VPrint_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VPrint_Pthreads(v) &
+          bind(C,name='N_VPrint_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end subroutine FN_VPrint_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: N_VPrintFile_Pthreads
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VGetVectorID_Pthreads
+     ! -----------------------------------------------------------------
+     
+     integer(c_int) function FN_VGetVectorID_Pthreads(v) &
+          bind(C,name='N_VGetVectorID_Pthreads')
+        use, intrinsic :: iso_c_binding
+        implicit none
+        type(c_ptr), value :: v
+     end function FN_VGetVectorID_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneEmpty_Pthreads
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VCloneEmpty_Pthreads(w) &
+          bind(C,name='N_VCloneEmpty_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: w
+     end function FN_VCloneEmpty_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VClone_Pthreads
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VClone_Pthreads(w) &
+          bind(C,name='N_VClone_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: w
+     end function FN_VClone_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VSpace_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VSpace_Pthreads(v, lrw, liw) &
+          bind(C,name='N_VSpace_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+       integer(c_long)    :: lrw
+       integer(c_long)    :: liw
+     end subroutine FN_VSpace_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VGetArrayPointer_Pthreads
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VGetArrayPointer_Pthreads(vec) &
+          bind(C,name='N_VGetArrayPointer_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: vec
+     end function FN_VGetArrayPointer_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VSetArrayPointer_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VSetArrayPointer_Pthreads(v_data, v) &
+          bind(C,name='N_VSetArrayPointer_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v_data
+       type(c_ptr), value :: v
+     end subroutine FN_VSetArrayPointer_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VLinearSum_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VLinearSum_Pthreads(a, x, b, y, z) &
+          bind(C,name='N_VLinearSum_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: a
+       type(c_ptr),    value :: x
+       real(c_double), value :: b
+       type(c_ptr),    value :: y
+       type(c_ptr),    value :: z
+     end subroutine FN_VLinearSum_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VConst_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VConst_Pthreads(c, z) &
+          bind(C,name='N_VConst_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: z
+     end subroutine FN_VConst_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VProd_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VProd_Pthreads(x, y, z) &
+          bind(C,name='N_VProd_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+       type(c_ptr), value :: z
+     end subroutine FN_VProd_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VDiv_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VDiv_Pthreads(x, y, z) &
+          bind(C,name='N_VDiv_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+       type(c_ptr), value :: z
+     end subroutine FN_VDiv_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VScale_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VScale_Pthreads(c, x, z) &
+          bind(C,name='N_VScale_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: z
+     end subroutine FN_VScale_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VAbs_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VAbs_Pthreads(x, z) &
+          bind(C,name='N_VAbs_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end subroutine FN_VAbs_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VInv_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VInv_Pthreads(x, z) &
+          bind(C,name='N_VInv_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end subroutine FN_VInv_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VAddConst
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VAddConst_Pthreads(x, b, z) &
+          bind(C,name='N_VAddConst_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: x
+       real(c_double), value :: b
+       type(c_ptr),    value :: z
+     end subroutine FN_VAddConst_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VDotProd_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VDotProd_Pthreads(x, y) &
+          bind(C,name='N_VDotProd_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+     end function FN_VDotProd_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VMaxNorm_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMaxNorm_Pthreads(x) &
+          bind(C,name='N_VMaxNorm_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VMaxNorm_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VWrmsNorm_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWrmsNorm_Pthreads(x, w) &
+          bind(C,name='N_VWrmsNorm_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+     end function FN_VWrmsNorm_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VWrmsNormMask_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWrmsNormMask_Pthreads(x, w, id) &
+          bind(C,name='N_VWrmsNormMask_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+       type(c_ptr), value :: id
+     end function FN_VWrmsNormMask_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VMin_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMin_Pthreads(x) &
+          bind(C,name='N_VMin_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VMin_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VWL2Norm_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWL2Norm_Pthreads(x, w) &
+          bind(C,name='N_VWL2Norm_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+     end function FN_VWL2Norm_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VL1Norm_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VL1Norm_Pthreads(x) &
+          bind(C,name='N_VL1Norm_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VL1Norm_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VCompare_Pthreads
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VCompare_Pthreads(c, x, z) &
+          bind(C,name='N_VCompare_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: z
+     end subroutine FN_VCompare_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VInvTest_Pthreads
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FN_VInvTest_Pthreads(x, z) &
+          bind(C,name='N_VInvTest_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end function FN_VInvTest_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VConstrMask_Pthreads
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FN_VConstrMask_Pthreads(c, x, m) &
+          bind(C,name='N_VConstrMask_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: c
+       type(c_ptr), value :: x
+       type(c_ptr), value :: m
+     end function FN_VConstrMask_Pthreads
+
+     ! -----------------------------------------------------------------
+     ! N_VMinQuotient_Pthreads
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMinQuotient_Pthreads(num, denom) &
+          bind(C,name='N_VMinQuotient_Pthreads')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: num
+       type(c_ptr), value :: denom
+     end function FN_VMinQuotient_Pthreads
+
+     ! ================================================================
+     ! Fused vector operations: NOT INTERFACED
+     ! ================================================================
+
+     ! ================================================================
+     ! Vector array operations: NOT INTERFACED
+     ! ================================================================
+     
+   end interface
+
+contains
+
+  ! ================================================================
+  ! Helpful routines
+  ! ================================================================
+
+  ! ----------------------------------------------------------------
+  ! FN_VGetData_Pthreads 
+  ! 
+  ! Extracts data array from a Pthreads SUNDIALS N_Vector
+  ! ----------------------------------------------------------------
+
+  subroutine FN_VGetData_Pthreads(vec, f_array)
+
+    !======= Inclusions ===========
+    use, intrinsic :: iso_c_binding
+
+    !======= Declarations =========
+    implicit none
+
+    ! calling variables
+    type(c_ptr)             :: vec
+    integer(c_long)         :: length
+    real(c_double), pointer :: f_array(:)
+
+    ! C pointer for N_Vector interal data array
+    type(c_ptr) :: c_array
+
+    !======= Internals ============
+
+    ! get data pointer from N_Vector
+    c_array = FN_VGetArrayPointer_Pthreads(vec)
+
+    ! get vector length
+    length = FN_VGetLength_Pthreads(vec)
+    
+    ! convert c pointer to f pointer
+    call c_f_pointer(c_array, f_array, (/length/))
+
+  end subroutine FN_VGetData_Pthreads
+
+end module fnvector_pthreads_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/raja/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/raja/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f0394ae7b963b70804c0dfa47894074ab760f45
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/raja/CMakeLists.txt
@@ -0,0 +1,112 @@
+# ---------------------------------------------------------------
+# Programmer:  Slaven Peles @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the RAJA NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_RAJA\n\")")
+
+# Add variable nvecraja_SOURCES with the sources for the NVECRAJA lib
+SET(nvecraja_SOURCES
+  nvector_raja.cu
+)
+
+# Tell compiler it is a CUDA source
+set_source_files_properties(${nvecraja_SOURCES} PROPERTIES CUDA_SOURCE_PROPERTY_FORMAT OBJ)
+
+# Set C++ compiler flags to include RAJA flags
+set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} ${RAJA_COMPILE_FLAGS})
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECRAJA library
+SET(shared_SOURCES
+  sundials_math.c
+  sundials_mpi.c
+)
+ADD_PREFIX(${sundials_SOURCE_DIR}/src/sundials/ shared_SOURCES)
+
+# Add variable nveccuda_HEADERS with the exported NVECRAJA header files
+SET(nvecraja_HEADERS nvector_raja.h)
+IF (MPI_ENABLE)
+  LIST(APPEND nvecraja_HEADERS nvector_mpiraja.h)
+ENDIF()
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/nvector/ nvecraja_HEADERS)
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(. ${MPI_CXX_INCLUDE_PATH})
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECRAJA library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECRAJA library
+IF(BUILD_STATIC_LIBS)
+  # ----------------------- CUDA only
+  # The FindCUDA module does not properly forward compile options using target_* commands.
+  # So as long as we use it (required in CMake < 3.8), we have to manually add compile
+  # options in the CUDA_ADD_* commands.
+  CUDA_ADD_LIBRARY(sundials_nveccudaraja_static STATIC
+    ${nvecraja_SOURCES} ${shared_SOURCES}
+    OPTIONS -DSUNDIALS_MPI_ENABLED=0
+  )
+  TARGET_COMPILE_DEFINITIONS(sundials_nveccudaraja_static PUBLIC -DSUNDIALS_MPI_ENABLED=0)
+  SET_TARGET_PROPERTIES(sundials_nveccudaraja_static
+    PROPERTIES OUTPUT_NAME sundials_nveccudaraja CLEAN_DIRECT_OUTPUT 1
+  )
+  INSTALL(TARGETS sundials_nveccudaraja_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  # MPI+CUDA
+  IF(MPI_ENABLE)
+    CUDA_ADD_LIBRARY(sundials_nvecmpicudaraja_static STATIC ${nvecraja_SOURCES} ${shared_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_nvecmpicudaraja_static
+      PROPERTIES OUTPUT_NAME sundials_nvecmpicudaraja CLEAN_DIRECT_OUTPUT 1
+    )
+    INSTALL(TARGETS sundials_nvecmpicudaraja_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF()
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECRAJA library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECRAJA library
+IF(BUILD_SHARED_LIBS)
+  # ----------------------- CUDA only
+  CUDA_ADD_LIBRARY(sundials_nveccudaraja_shared SHARED
+    ${nvecraja_SOURCES} ${shared_SOURCES}
+    OPTIONS -DSUNDIALS_MPI_ENABLED=0
+  )
+  TARGET_COMPILE_DEFINITIONS(sundials_nveccudaraja_shared PUBLIC -DSUNDIALS_MPI_ENABLED=0)
+  SET_TARGET_PROPERTIES(sundials_nveccudaraja_shared
+    PROPERTIES OUTPUT_NAME sundials_nveccudaraja CLEAN_DIRECT_OUTPUT 1
+               VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION}
+  )
+  INSTALL(TARGETS sundials_nveccudaraja_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  # ----------------------- MPI+CUDA
+  IF(MPI_ENABLE)
+    CUDA_ADD_LIBRARY(sundials_nvecmpicudaraja_shared SHARED ${nvecraja_SOURCES} ${shared_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_nvecmpicudaraja_shared
+      PROPERTIES OUTPUT_NAME sundials_nvecmpicudaraja CLEAN_DIRECT_OUTPUT 1
+                 VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION}
+    )
+    INSTALL(TARGETS sundials_nvecmpicudaraja_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF()
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECRAJA header files
+INSTALL(FILES ${nvecraja_HEADERS} DESTINATION include/nvector)
+INSTALL(DIRECTORY ${sundials_SOURCE_DIR}/include/nvector/raja DESTINATION include/nvector)
+
+
+MESSAGE(STATUS "Added NVECTOR_RAJA module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/raja/nvector_raja.cu b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/raja/nvector_raja.cu
new file mode 100644
index 0000000000000000000000000000000000000000..82e25aeb5a81031194d0236074e8a2371fc4a0cf
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/raja/nvector_raja.cu
@@ -0,0 +1,1308 @@
+/* -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ * This is the implementation file for a MPI+RAJA implementation
+ * of the NVECTOR package.
+ * -----------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <nvector/raja/Vector.hpp>
+#include <sundials/sundials_mpi.h>
+#include <RAJA/RAJA.hpp>
+
+
+#define ZERO   RCONST(0.0)
+#define HALF   RCONST(0.5)
+#define ONE    RCONST(1.0)
+#define ONEPT5 RCONST(1.5)
+
+// RAJA defines
+#define CUDA_BLOCK_SIZE 256
+#define RAJA_NODE_TYPE RAJA::cuda_exec< CUDA_BLOCK_SIZE >
+#define RAJA_REDUCE_TYPE RAJA::cuda_reduce< CUDA_BLOCK_SIZE >
+#define RAJA_LAMBDA [=] __device__
+
+extern "C" {
+
+using namespace sunrajavec;
+
+// Type defines
+typedef sunrajavec::Vector<realtype, sunindextype> vector_type;
+
+// Static constants
+static constexpr sunindextype zeroIdx = 0;
+
+/*
+ * ----------------------------------------------------------------
+ * private accessor/helper functions
+ * ----------------------------------------------------------------
+ */
+
+static inline sunindextype getLocalLength(N_Vector v)
+{
+  vector_type* vp = static_cast<vector_type*>(v->content);
+  return vp->size();
+}
+
+static inline SUNMPI_Comm getMPIComm(N_Vector v)
+{
+  vector_type* vp = static_cast<vector_type*>(v->content);
+  return vp->comm();
+}
+
+/* ----------------------------------------------------------------
+ * Returns vector type ID. Used to identify vector implementation
+ * from abstract N_Vector interface.
+ */
+N_Vector_ID N_VGetVectorID_Raja(N_Vector v)
+{
+  return SUNDIALS_NVEC_RAJA;
+}
+
+N_Vector N_VNewEmpty_Raja()
+{
+  N_Vector v;
+  N_Vector_Ops ops;
+
+  /* Create vector */
+  v = NULL;
+  v = (N_Vector) malloc(sizeof *v);
+  if (v == NULL) return(NULL);
+
+  /* Create vector operation structure */
+  ops = NULL;
+  ops = (N_Vector_Ops) malloc(sizeof(struct _generic_N_Vector_Ops));
+  if (ops == NULL) { free(v); return(NULL); }
+
+  ops->nvgetvectorid     = N_VGetVectorID_Raja;
+  ops->nvclone           = N_VClone_Raja;
+  ops->nvcloneempty      = N_VCloneEmpty_Raja;
+  ops->nvdestroy         = N_VDestroy_Raja;
+  ops->nvspace           = N_VSpace_Raja;
+  ops->nvgetarraypointer = NULL; //N_VGetArrayPointer_Raja;
+  ops->nvsetarraypointer = NULL; //N_VSetArrayPointer_Raja;
+
+  /* standard vector operations */
+  ops->nvlinearsum    = N_VLinearSum_Raja;
+  ops->nvconst        = N_VConst_Raja;
+  ops->nvprod         = N_VProd_Raja;
+  ops->nvdiv          = N_VDiv_Raja;
+  ops->nvscale        = N_VScale_Raja;
+  ops->nvabs          = N_VAbs_Raja;
+  ops->nvinv          = N_VInv_Raja;
+  ops->nvaddconst     = N_VAddConst_Raja;
+  ops->nvdotprod      = N_VDotProd_Raja;
+  ops->nvmaxnorm      = N_VMaxNorm_Raja;
+  ops->nvwrmsnormmask = N_VWrmsNormMask_Raja;
+  ops->nvwrmsnorm     = N_VWrmsNorm_Raja;
+  ops->nvmin          = N_VMin_Raja;
+  ops->nvwl2norm      = N_VWL2Norm_Raja;
+  ops->nvl1norm       = N_VL1Norm_Raja;
+  ops->nvcompare      = N_VCompare_Raja;
+  ops->nvinvtest      = N_VInvTest_Raja;
+  ops->nvconstrmask   = N_VConstrMask_Raja;
+  ops->nvminquotient  = N_VMinQuotient_Raja;
+
+  /* fused vector operations (optional, NULL means disabled by default) */
+  ops->nvlinearcombination = NULL;
+  ops->nvscaleaddmulti     = NULL;
+  ops->nvdotprodmulti      = NULL;
+
+  /* vector array operations (optional, NULL means disabled by default) */
+  ops->nvlinearsumvectorarray         = NULL;
+  ops->nvscalevectorarray             = NULL;
+  ops->nvconstvectorarray             = NULL;
+  ops->nvwrmsnormvectorarray          = NULL;
+  ops->nvwrmsnormmaskvectorarray      = NULL;
+  ops->nvscaleaddmultivectorarray     = NULL;
+  ops->nvlinearcombinationvectorarray = NULL;
+
+  /* Attach ops and set content to NULL */
+  v->content = NULL;
+  v->ops     = ops;
+
+  return(v);
+}
+
+
+#if SUNDIALS_MPI_ENABLED
+N_Vector N_VNew_Raja(MPI_Comm comm,
+                     sunindextype local_length,
+                     sunindextype global_length)
+{
+  N_Vector v;
+
+  v = NULL;
+  v = N_VNewEmpty_Raja();
+  if (v == NULL) return(NULL);
+
+  v->content = new vector_type(comm, local_length, global_length);
+
+  return(v);
+}
+#else
+N_Vector N_VNew_Raja(sunindextype length)
+{
+  N_Vector v;
+
+  v = NULL;
+  v = N_VNewEmpty_Raja();
+  if (v == NULL) return(NULL);
+
+  v->content = new vector_type(length);
+
+  return(v);
+}
+#endif
+
+
+N_Vector N_VMake_Raja(N_VectorContent_Raja c)
+{
+  N_Vector v;
+  vector_type* x = static_cast<vector_type*>(c);
+  sunindextype length = x->size();
+
+  v = NULL;
+  v = N_VNewEmpty_Raja();
+  if (v == NULL) return(NULL);
+
+  v->content = c;
+
+  return(v);
+}
+
+
+/* -----------------------------------------------------------------
+ * Function to return the global length of the vector.
+ */
+sunindextype N_VGetLength_Raja(N_Vector v)
+{
+  vector_type* xd = static_cast<vector_type*>(v->content);
+  return xd->sizeGlobal();
+}
+
+#if SUNDIALS_MPI_ENABLED
+/* -----------------------------------------------------------------
+ * Function to return the local length of the vector.
+ */
+sunindextype N_VGetLocalLength_Raja(N_Vector v)
+{
+  vector_type* xd = static_cast<vector_type*>(v->content);
+  return xd->size();
+}
+
+/* -----------------------------------------------------------------
+ * Function to return the MPI communicator for the vector.
+ */
+MPI_Comm N_VGetMPIComm_Raja(N_Vector v)
+{
+  vector_type* xd = static_cast<vector_type*>(v->content);
+  return (xd->comm());
+}
+#endif
+
+/* ----------------------------------------------------------------------------
+ * Return pointer to the raw host data
+ */
+
+realtype *N_VGetHostArrayPointer_Raja(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  return (xv->host());
+}
+
+/* ----------------------------------------------------------------------------
+ * Return pointer to the raw device data
+ */
+
+realtype *N_VGetDeviceArrayPointer_Raja(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  return (xv->device());
+}
+
+/* ----------------------------------------------------------------------------
+ * Copy vector data to the device
+ */
+
+void N_VCopyToDevice_Raja(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  xv->copyToDev();
+}
+
+/* ----------------------------------------------------------------------------
+ * Copy vector data from the device to the host
+ */
+
+void N_VCopyFromDevice_Raja(N_Vector x)
+{
+  vector_type* xv = static_cast<vector_type*>(x->content);
+  xv->copyFromDev();
+}
+
+/* ----------------------------------------------------------------------------
+ * Function to print the a serial vector to stdout
+ */
+
+void N_VPrint_Raja(N_Vector X)
+{
+  N_VPrintFile_Raja(X, stdout);
+}
+
+/* ----------------------------------------------------------------------------
+ * Function to print the a serial vector to outfile
+ */
+
+void N_VPrintFile_Raja(N_Vector X, FILE *outfile)
+{
+  const realtype *xd = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+  sunindextype i;
+
+  for (i = 0; i < N; ++i) {
+#if defined(SUNDIALS_EXTENDED_PRECISION)
+    fprintf(outfile, "%35.32Lg\n", xd[i]);
+#elif defined(SUNDIALS_DOUBLE_PRECISION)
+    fprintf(outfile, "%19.16g\n", xd[i]);
+#else
+    fprintf(outfile, "%11.8g\n", xd[i]);
+#endif
+  }
+  fprintf(outfile, "\n");
+
+  return;
+}
+
+/*
+ * -----------------------------------------------------------------
+ * implementation of vector operations
+ * -----------------------------------------------------------------
+ */
+
+N_Vector N_VCloneEmpty_Raja(N_Vector w)
+{
+  N_Vector v;
+  N_Vector_Ops ops;
+
+  if (w == NULL) return(NULL);
+
+  /* Create vector */
+  v = NULL;
+  v = (N_Vector) malloc(sizeof *v);
+  if (v == NULL) return(NULL);
+
+  /* Create vector operation structure */
+  ops = NULL;
+  ops = (N_Vector_Ops) malloc(sizeof(struct _generic_N_Vector_Ops));
+  if (ops == NULL) { free(v); return(NULL); }
+
+  ops->nvgetvectorid     = w->ops->nvgetvectorid;
+  ops->nvclone           = w->ops->nvclone;
+  ops->nvcloneempty      = w->ops->nvcloneempty;
+  ops->nvdestroy         = w->ops->nvdestroy;
+  ops->nvspace           = w->ops->nvspace;
+  ops->nvgetarraypointer = w->ops->nvgetarraypointer;
+  ops->nvsetarraypointer = w->ops->nvsetarraypointer;
+
+  /* standard vector operations */
+  ops->nvlinearsum    = w->ops->nvlinearsum;
+  ops->nvconst        = w->ops->nvconst;
+  ops->nvprod         = w->ops->nvprod;
+  ops->nvdiv          = w->ops->nvdiv;
+  ops->nvscale        = w->ops->nvscale;
+  ops->nvabs          = w->ops->nvabs;
+  ops->nvinv          = w->ops->nvinv;
+  ops->nvaddconst     = w->ops->nvaddconst;
+  ops->nvdotprod      = w->ops->nvdotprod;
+  ops->nvmaxnorm      = w->ops->nvmaxnorm;
+  ops->nvwrmsnormmask = w->ops->nvwrmsnormmask;
+  ops->nvwrmsnorm     = w->ops->nvwrmsnorm;
+  ops->nvmin          = w->ops->nvmin;
+  ops->nvwl2norm      = w->ops->nvwl2norm;
+  ops->nvl1norm       = w->ops->nvl1norm;
+  ops->nvcompare      = w->ops->nvcompare;
+  ops->nvinvtest      = w->ops->nvinvtest;
+  ops->nvconstrmask   = w->ops->nvconstrmask;
+  ops->nvminquotient  = w->ops->nvminquotient;
+
+  /* fused vector operations */
+  ops->nvlinearcombination = w->ops->nvlinearcombination;
+  ops->nvscaleaddmulti     = w->ops->nvscaleaddmulti;
+  ops->nvdotprodmulti      = w->ops->nvdotprodmulti;
+
+  /* vector array operations */
+  ops->nvlinearsumvectorarray         = w->ops->nvlinearsumvectorarray;
+  ops->nvscalevectorarray             = w->ops->nvscalevectorarray;
+  ops->nvconstvectorarray             = w->ops->nvconstvectorarray;
+  ops->nvwrmsnormvectorarray          = w->ops->nvwrmsnormvectorarray;
+  ops->nvwrmsnormmaskvectorarray      = w->ops->nvwrmsnormmaskvectorarray;
+  ops->nvscaleaddmultivectorarray     = w->ops->nvscaleaddmultivectorarray;
+  ops->nvlinearcombinationvectorarray = w->ops->nvlinearcombinationvectorarray;
+
+  /* Create content */
+  v->content = NULL;
+  v->ops  = ops;
+
+  return(v);
+}
+
+N_Vector N_VClone_Raja(N_Vector w)
+{
+  N_Vector v;
+  vector_type* wdat = static_cast<vector_type*>(w->content);
+  vector_type* vdat = new vector_type(*wdat);
+  v = NULL;
+  v = N_VCloneEmpty_Raja(w);
+  if (v == NULL) return(NULL);
+
+  v->content = vdat;
+
+  return(v);
+}
+
+
+void N_VDestroy_Raja(N_Vector v)
+{
+  vector_type* x = static_cast<vector_type*>(v->content);
+  if (x != NULL) {
+    delete x;
+    v->content = NULL;
+  }
+
+  free(v->ops); v->ops = NULL;
+  free(v); v = NULL;
+
+  return;
+}
+
+void N_VSpace_Raja(N_Vector X, sunindextype *lrw, sunindextype *liw)
+{
+  SUNMPI_Comm comm = getMPIComm(X);
+  int npes;
+
+  SUNMPI_Comm_size(comm, &npes);
+
+  *lrw = N_VGetLength_Raja(X);
+  *liw = 2*npes;
+}
+
+void N_VConst_Raja(realtype c, N_Vector Z)
+{
+  const sunindextype N = getLocalLength(Z);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N), RAJA_LAMBDA(sunindextype i) {
+     zdata[i] = c;
+  });
+}
+
+void N_VLinearSum_Raja(realtype a, N_Vector X, realtype b, N_Vector Y, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *ydata = N_VGetDeviceArrayPointer_Raja(Y);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = a*xdata[i] + b*ydata[i];
+    }
+  );
+}
+
+void N_VProd_Raja(N_Vector X, N_Vector Y, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *ydata = N_VGetDeviceArrayPointer_Raja(Y);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = xdata[i] * ydata[i];
+    }
+  );
+}
+
+void N_VDiv_Raja(N_Vector X, N_Vector Y, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *ydata = N_VGetDeviceArrayPointer_Raja(Y);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = xdata[i] / ydata[i];
+    }
+  );
+}
+
+void N_VScale_Raja(realtype c, N_Vector X, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall<RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = c * xdata[i];
+    }
+  );
+}
+
+void N_VAbs_Raja(N_Vector X, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall<RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = abs(xdata[i]);
+    }
+  );
+}
+
+void N_VInv_Raja(N_Vector X, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall<RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = ONE / xdata[i];
+    }
+  );
+}
+
+void N_VAddConst_Raja(N_Vector X, realtype b, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = xdata[i] + b;
+    }
+  );
+}
+
+realtype N_VDotProd_Raja(N_Vector X, N_Vector Y)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *ydata = N_VGetDeviceArrayPointer_Raja(Y);
+  const sunindextype N = getLocalLength(X);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(0.0);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      gpu_result += xdata[i] * ydata[i] ;
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype sum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  realtype gsum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+  return gsum;
+}
+
+realtype N_VMaxNorm_Raja(N_Vector X)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+
+  RAJA::ReduceMax< RAJA_REDUCE_TYPE, realtype> gpu_result(0.0);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      gpu_result.max(abs(xdata[i]));
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype maximum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  return SUNMPI_Allreduce_scalar(maximum, 2, comm);
+}
+
+realtype N_VWrmsNorm_Raja(N_Vector X, N_Vector W)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *wdata = N_VGetDeviceArrayPointer_Raja(W);
+  const sunindextype N = getLocalLength(X);
+  const sunindextype Nglobal = N_VGetLength_Raja(X);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(0.0);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      gpu_result += (xdata[i] * wdata[i] * xdata[i] * wdata[i]);
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype sum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  return std::sqrt(SUNMPI_Allreduce_scalar(sum, 1, comm)/Nglobal);
+}
+
+realtype N_VWrmsNormMask_Raja(N_Vector X, N_Vector W, N_Vector ID)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *wdata = N_VGetDeviceArrayPointer_Raja(W);
+  const realtype *iddata = N_VGetDeviceArrayPointer_Raja(ID);
+  const sunindextype N = getLocalLength(X);
+  const sunindextype Nglobal = N_VGetLength_Raja(X);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(0.0);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      if (iddata[i] > ZERO)
+        gpu_result += (xdata[i] * wdata[i] * xdata[i] * wdata[i]);
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype sum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  return std::sqrt(SUNMPI_Allreduce_scalar(sum, 1, comm)/Nglobal);
+}
+
+realtype N_VMin_Raja(N_Vector X)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+
+  RAJA::ReduceMin< RAJA_REDUCE_TYPE, realtype> gpu_result(std::numeric_limits<realtype>::max());
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      gpu_result.min(xdata[i]);
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype minumum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  return SUNMPI_Allreduce_scalar(minumum, 3, comm);
+}
+
+realtype N_VWL2Norm_Raja(N_Vector X, N_Vector W)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const realtype *wdata = N_VGetDeviceArrayPointer_Raja(W);
+  const sunindextype N = getLocalLength(X);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(0.0);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      gpu_result += (xdata[i] * wdata[i] * xdata[i] * wdata[i]);
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype sum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  return std::sqrt(SUNMPI_Allreduce_scalar(sum, 1, comm));
+}
+
+realtype N_VL1Norm_Raja(N_Vector X)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(0.0);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      gpu_result += (abs(xdata[i]));
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype sum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(X);
+  return SUNMPI_Allreduce_scalar(sum, 1, comm);
+}
+
+void N_VCompare_Raja(realtype c, N_Vector X, N_Vector Z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(X);
+  const sunindextype N = getLocalLength(X);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(Z);
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      zdata[i] = abs(xdata[i]) >= c ? ONE : ZERO;
+    }
+  );
+}
+
+booleantype N_VInvTest_Raja(N_Vector x, N_Vector z)
+{
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(x);
+  const sunindextype N = getLocalLength(x);
+  realtype *zdata = N_VGetDeviceArrayPointer_Raja(z);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(ZERO);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      if (xdata[i] == ZERO) {
+        gpu_result += ONE;
+      } else {
+        zdata[i] = ONE/xdata[i];
+      }
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype minimum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(x);
+  realtype global_minimum = SUNMPI_Allreduce_scalar(minimum, 3, comm);
+
+  return (global_minimum < HALF);
+}
+
+booleantype N_VConstrMask_Raja(N_Vector c, N_Vector x, N_Vector m)
+{
+  const realtype *cdata = N_VGetDeviceArrayPointer_Raja(c);
+  const realtype *xdata = N_VGetDeviceArrayPointer_Raja(x);
+  const sunindextype N = getLocalLength(x);
+  realtype *mdata = N_VGetDeviceArrayPointer_Raja(m);
+
+  RAJA::ReduceSum< RAJA_REDUCE_TYPE, realtype> gpu_result(ZERO);
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      bool test = (abs(cdata[i]) > ONEPT5 && cdata[i]*xdata[i] <= ZERO) ||
+                  (abs(cdata[i]) > HALF   && cdata[i]*xdata[i] <  ZERO);
+      mdata[i] = test ? ONE : ZERO;
+      gpu_result += mdata[i];
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype sum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(x);
+  realtype global_sum = SUNMPI_Allreduce_scalar(sum, 1, comm);
+
+  return (global_sum < HALF);
+}
+
+realtype N_VMinQuotient_Raja(N_Vector num, N_Vector denom)
+{
+  const realtype *ndata = N_VGetDeviceArrayPointer_Raja(num);
+  const realtype *ddata = N_VGetDeviceArrayPointer_Raja(denom);
+  const sunindextype N = getLocalLength(num);
+
+  RAJA::ReduceMin< RAJA_REDUCE_TYPE, realtype> gpu_result(std::numeric_limits<realtype>::max());
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      if (ddata[i] != ZERO)
+        gpu_result.min(ndata[i]/ddata[i]);
+    }
+  );
+
+  /* Reduce across MPI processes */
+  realtype minimum = static_cast<realtype>(gpu_result);
+  SUNMPI_Comm comm = getMPIComm(num);
+  return SUNMPI_Allreduce_scalar(minimum, 3, comm);
+}
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * fused vector operations
+ * -----------------------------------------------------------------------------
+ */
+
+int N_VLinearCombination_Raja(int nvec, realtype* c, N_Vector* X, N_Vector z)
+{
+  cudaError_t  err;
+
+  sunindextype N = getLocalLength(z);
+  realtype* d_zd = N_VGetDeviceArrayPointer_Raja(z);
+
+  // Copy c array to device
+  realtype* d_c;
+  err = cudaMalloc((void**) &d_c, nvec*sizeof(realtype));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nvec*sizeof(realtype), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  realtype** h_Xd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Xd[j] = N_VGetDeviceArrayPointer_Raja(X[j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      d_zd[i] = d_c[0] * d_Xd[0][i];
+      for (int j=1; j<nvec; j++)
+        d_zd[i] += d_c[j] * d_Xd[j][i];
+    }
+  );
+
+  // Free host array
+  delete[] h_Xd;
+
+  // Free device arrays
+  err = cudaFree(d_c);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+int N_VScaleAddMulti_Raja(int nvec, realtype* c, N_Vector x, N_Vector* Y, N_Vector* Z)
+{
+  cudaError_t err;
+
+  sunindextype N = getLocalLength(x);
+  realtype* d_xd = N_VGetDeviceArrayPointer_Raja(x);
+
+  // Copy c array to device
+  realtype* d_c;
+  err = cudaMalloc((void**) &d_c, nvec*sizeof(realtype));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nvec*sizeof(realtype), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  realtype** h_Yd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Yd[j] = N_VGetDeviceArrayPointer_Raja(Y[j]);
+
+  realtype** h_Zd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Zd[j] = N_VGetDeviceArrayPointer_Raja(Z[j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      for (int j=0; j<nvec; j++)
+        d_Zd[j][i] = d_c[j] * d_xd[i] + d_Yd[j][i];
+    }
+  );
+
+  // Free host array
+  delete[] h_Yd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_c);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * vector array operations
+ * -----------------------------------------------------------------------------
+ */
+
+int N_VLinearSumVectorArray_Raja(int nvec,
+                                 realtype a, N_Vector* X,
+                                 realtype b, N_Vector* Y,
+                                 N_Vector* Z)
+{
+  cudaError_t err;
+
+  sunindextype N = getLocalLength(Z[0]);
+
+  // Create array of device pointers on host
+  realtype** h_Xd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Xd[j] = N_VGetDeviceArrayPointer_Raja(X[j]);
+
+  realtype** h_Yd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Yd[j] = N_VGetDeviceArrayPointer_Raja(Y[j]);
+
+  realtype** h_Zd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Zd[j] = N_VGetDeviceArrayPointer_Raja(Z[j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      for (int j=0; j<nvec; j++)
+        d_Zd[j][i] = a * d_Xd[j][i] + b * d_Yd[j][i];
+    }
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Yd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+int N_VScaleVectorArray_Raja(int nvec, realtype* c, N_Vector* X, N_Vector* Z)
+{
+  cudaError_t err;
+
+  sunindextype N = getLocalLength(Z[0]);
+
+  // Copy c array to device
+  realtype* d_c;
+  err = cudaMalloc((void**) &d_c, nvec*sizeof(realtype));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nvec*sizeof(realtype), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  realtype** h_Xd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Xd[j] = N_VGetDeviceArrayPointer_Raja(X[j]);
+
+  realtype** h_Zd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Zd[j] = N_VGetDeviceArrayPointer_Raja(Z[j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      for (int j=0; j<nvec; j++)
+        d_Zd[j][i] = d_c[j] * d_Xd[j][i];
+    }
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+int N_VConstVectorArray_Raja(int nvec, realtype c, N_Vector* Z)
+{
+  cudaError_t err;
+
+  sunindextype N = getLocalLength(Z[0]);
+
+  // Create array of device pointers on host
+  realtype** h_Zd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Zd[j] = N_VGetDeviceArrayPointer_Raja(Z[j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      for (int j=0; j<nvec; j++)
+        d_Zd[j][i] = c;
+    }
+  );
+
+  // Free host array
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+int N_VScaleAddMultiVectorArray_Raja(int nvec, int nsum, realtype* c,
+                                     N_Vector* X, N_Vector** Y, N_Vector** Z)
+{
+  cudaError_t err;
+
+  sunindextype N = getLocalLength(X[0]);
+
+  // Copy c array to device
+  realtype* d_c;
+  err = cudaMalloc((void**) &d_c, nsum*sizeof(realtype));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nsum*sizeof(realtype), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  realtype** h_Xd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Xd[j] = N_VGetDeviceArrayPointer_Raja(X[j]);
+
+  realtype** h_Yd = new realtype*[nsum*nvec];
+  for (int j=0; j<nvec; j++)
+    for (int k=0; k<nsum; k++)
+      h_Yd[j*nsum+k] = N_VGetDeviceArrayPointer_Raja(Y[k][j]);
+
+  realtype** h_Zd = new realtype*[nsum*nvec];
+  for (int j=0; j<nvec; j++)
+    for (int k=0; k<nsum; k++)
+      h_Zd[j*nsum+k] = N_VGetDeviceArrayPointer_Raja(Z[k][j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Yd;
+  err = cudaMalloc((void**) &d_Yd, nsum*nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Yd, h_Yd, nsum*nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nsum*nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nsum*nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      for (int j=0; j<nvec; j++)
+        for (int k=0; k<nsum; k++)
+          d_Zd[j*nsum+k][i] = d_c[k] * d_Xd[j][i] + d_Yd[j*nsum+k][i];
+    }
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Yd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Yd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+int N_VLinearCombinationVectorArray_Raja(int nvec, int nsum, realtype* c,
+                                         N_Vector** X, N_Vector* Z)
+{
+  cudaError_t err;
+
+  sunindextype N = getLocalLength(Z[0]);
+
+  // Copy c array to device
+  realtype* d_c;
+  err = cudaMalloc((void**) &d_c, nsum*sizeof(realtype));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_c, c, nsum*sizeof(realtype), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  // Create array of device pointers on host
+  realtype** h_Xd = new realtype*[nsum*nvec];
+  for (int j=0; j<nvec; j++)
+    for (int k=0; k<nsum; k++)
+      h_Xd[j*nsum+k] = N_VGetDeviceArrayPointer_Raja(X[k][j]);
+
+  realtype** h_Zd = new realtype*[nvec];
+  for (int j=0; j<nvec; j++)
+    h_Zd[j] = N_VGetDeviceArrayPointer_Raja(Z[j]);
+
+  // Copy array of device pointers to device from host
+  realtype** d_Xd;
+  err = cudaMalloc((void**) &d_Xd, nsum*nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Xd, h_Xd, nsum*nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  realtype** d_Zd;
+  err = cudaMalloc((void**) &d_Zd, nvec*sizeof(realtype*));
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaMemcpy(d_Zd, h_Zd, nvec*sizeof(realtype*), cudaMemcpyHostToDevice);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  RAJA::forall< RAJA_NODE_TYPE >(RAJA::RangeSegment(zeroIdx, N),
+    RAJA_LAMBDA(sunindextype i) {
+      for (int j=0; j<nvec; j++) {
+        d_Zd[j][i] = d_c[0] * d_Xd[j*nsum][i];
+        for (int k=1; k<nsum; k++) {
+          d_Zd[j][i] += d_c[k] * d_Xd[j*nsum+k][i];
+        }
+      }
+    }
+  );
+
+  // Free host array
+  delete[] h_Xd;
+  delete[] h_Zd;
+
+  // Free device arrays
+  err = cudaFree(d_Xd);
+  if (err != cudaSuccess) return cudaGetLastError();
+  err = cudaFree(d_Zd);
+  if (err != cudaSuccess) return cudaGetLastError();
+
+  return(0);
+}
+
+
+/*
+ * -----------------------------------------------------------------
+ * Enable / Disable fused and vector array operations
+ * -----------------------------------------------------------------
+ */
+
+int N_VEnableFusedOps_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  if (tf) {
+    /* enable all fused vector operations */
+    v->ops->nvlinearcombination = N_VLinearCombination_Raja;
+    v->ops->nvscaleaddmulti     = N_VScaleAddMulti_Raja;
+    v->ops->nvdotprodmulti      = NULL;
+    /* enable all vector array operations */
+    v->ops->nvlinearsumvectorarray         = N_VLinearSumVectorArray_Raja;
+    v->ops->nvscalevectorarray             = N_VScaleVectorArray_Raja;
+    v->ops->nvconstvectorarray             = N_VConstVectorArray_Raja;
+    v->ops->nvwrmsnormvectorarray          = NULL;
+    v->ops->nvwrmsnormmaskvectorarray      = NULL;
+    v->ops->nvscaleaddmultivectorarray     = N_VScaleAddMultiVectorArray_Raja;
+    v->ops->nvlinearcombinationvectorarray = N_VLinearCombinationVectorArray_Raja;
+  } else {
+    /* disable all fused vector operations */
+    v->ops->nvlinearcombination = NULL;
+    v->ops->nvscaleaddmulti     = NULL;
+    v->ops->nvdotprodmulti      = NULL;
+    /* disable all vector array operations */
+    v->ops->nvlinearsumvectorarray         = NULL;
+    v->ops->nvscalevectorarray             = NULL;
+    v->ops->nvconstvectorarray             = NULL;
+    v->ops->nvwrmsnormvectorarray          = NULL;
+    v->ops->nvwrmsnormmaskvectorarray      = NULL;
+    v->ops->nvscaleaddmultivectorarray     = NULL;
+    v->ops->nvlinearcombinationvectorarray = NULL;
+  }
+
+  /* return success */
+  return(0);
+}
+
+
+int N_VEnableLinearCombination_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvlinearcombination = N_VLinearCombination_Raja;
+  else
+    v->ops->nvlinearcombination = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableScaleAddMulti_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvscaleaddmulti = N_VScaleAddMulti_Raja;
+  else
+    v->ops->nvscaleaddmulti = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableLinearSumVectorArray_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvlinearsumvectorarray = N_VLinearSumVectorArray_Raja;
+  else
+    v->ops->nvlinearsumvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableScaleVectorArray_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvscalevectorarray = N_VScaleVectorArray_Raja;
+  else
+    v->ops->nvscalevectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableConstVectorArray_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvconstvectorarray = N_VConstVectorArray_Raja;
+  else
+    v->ops->nvconstvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableScaleAddMultiVectorArray_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvscaleaddmultivectorarray = N_VScaleAddMultiVectorArray_Raja;
+  else
+    v->ops->nvscaleaddmultivectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+int N_VEnableLinearCombinationVectorArray_Raja(N_Vector v, booleantype tf)
+{
+  /* check that vector is non-NULL */
+  if (v == NULL) return(-1);
+
+  /* check that ops structure is non-NULL */
+  if (v->ops == NULL) return(-1);
+
+  /* enable/disable operation */
+  if (tf)
+    v->ops->nvlinearcombinationvectorarray = N_VLinearCombinationVectorArray_Raja;
+  else
+    v->ops->nvlinearcombinationvectorarray = NULL;
+
+  /* return success */
+  return(0);
+}
+
+} // extern "C"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8e99388aa778ef184795350512fcc8cbb1f75e22
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/CMakeLists.txt
@@ -0,0 +1,103 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the serial NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_SERIAL\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable nvecserial_SOURCES with the sources for the NVECSERIAL lib
+SET(nvecserial_SOURCES nvector_serial.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECSERIAL library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable nvecserial_HEADERS with the exported NVECSERIAL header files
+SET(nvecserial_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_serial.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECSERIAL library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECSERIAL library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvecserial_static STATIC ${nvecserial_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_nvecserial_static
+    PROPERTIES OUTPUT_NAME sundials_nvecserial CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_nvecserial_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECSERIAL library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECSERIAL library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvecserial_shared SHARED ${nvecserial_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvecserial_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_nvecserial_shared
+    PROPERTIES OUTPUT_NAME sundials_nvecserial CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_nvecserial_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  INSTALL(TARGETS sundials_nvecserial_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECSERIAL header files
+INSTALL(FILES ${nvecserial_HEADERS} DESTINATION include/nvector)
+
+# If FCMIX is enabled, build and install the FNVECSERIAL library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fnvecserial_SOURCES fnvector_serial.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fnvecserial_static STATIC ${fnvecserial_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fnvecserial_static
+      PROPERTIES OUTPUT_NAME sundials_fnvecserial CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fnvecserial_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fnvecserial_shared ${fnvecserial_SOURCES})
+
+    # fnvecserial depends on nvecserial
+    TARGET_LINK_LIBRARIES(sundials_fnvecserial_shared sundials_nvecserial_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fnvecserial_shared
+      PROPERTIES OUTPUT_NAME sundials_fnvecserial CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fnvecserial_shared
+      PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+    INSTALL(TARGETS sundials_fnvecserial_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added NVECTOR_SERIAL module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..30d9dafe5950d5f6f4398286cd48b3f76077aae0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 serial NVECTOR object library
+
+set(nvecserial_SOURCES fnvector_serial.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fnvecserial_mod_static STATIC
+    ${nvecserial_SOURCES}
+  )
+  set_target_properties(sundials_fnvecserial_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fnvecserial_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fnvecserial_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fnvecserial_mod_shared SHARED
+    ${nvecserial_SOURCES}
+  )
+  set_target_properties(sundials_fnvecserial_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fnvecserial_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fnvecserial_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fnvecserial_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added NVECTOR_SERIAL F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/F90/fnvector_serial.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/F90/fnvector_serial.f90
new file mode 100644
index 0000000000000000000000000000000000000000..460c499a6816454032d2a8ec705536c6ba82597e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/serial/F90/fnvector_serial.f90
@@ -0,0 +1,478 @@
+! -----------------------------------------------------------------
+! Programmer(s): David J. Gardner @ LLNL
+!                Daniel R. Reynolds @ SMU
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS serial NVector using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fnvector_serial_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VNew_Serial
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VNew_Serial(vec_length) &
+          bind(C,name='N_VNew_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: vec_length
+     end function FN_VNew_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VNewEmpty_Serial
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VNewEmpty_Serial(vec_length) &
+          bind(C,name='N_VNewEmpty_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: vec_length
+     end function FN_VNewEmpty_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VMake_Serial
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VMake_Serial(length, v_data) &
+          bind(C,name='N_VMake_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: length
+       real(c_double)         :: v_data(length)
+     end function FN_VMake_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VCloneVectorArray_Serial: NOT INTERFACED
+     ! -----------------------------------------------------------------
+     
+     ! -----------------------------------------------------------------
+     ! N_VCloneVectorArrayEmpty_Serial: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VDestroy_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VDestroy_Serial(v) &
+          bind(C,name='N_VDestroy_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end subroutine FN_VDestroy_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VDestroyVectorArray_Serial: NOT INTERFACED
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Other routines
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VGetLength_Serial
+     ! -----------------------------------------------------------------
+
+     integer(c_long) function FN_VGetLength_Serial(v) &
+          bind(C,name='N_VGetLength_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end function FN_VGetLength_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VPrint_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VPrint_Serial(v) &
+          bind(C,name='N_VPrint_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+     end subroutine FN_VPrint_Serial
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED: N_VPrintFile_Serial
+     ! -----------------------------------------------------------------
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! N_VGetVectorID_Serial
+     ! -----------------------------------------------------------------
+     
+     integer(c_int) function FN_VGetVectorID_Serial(v) &
+          bind(C,name='N_VGetVectorID_Serial')
+        use, intrinsic :: iso_c_binding
+        implicit none
+        type(c_ptr), value :: v
+     end function FN_VGetVectorID_Serial
+     
+     ! -----------------------------------------------------------------
+     ! N_VCloneEmpty_Serial
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VCloneEmpty_Serial(w) &
+          bind(C,name='N_VCloneEmpty_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: w
+     end function FN_VCloneEmpty_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VClone_Serial
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VClone_Serial(w) &
+          bind(C,name='N_VClone_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: w
+     end function FN_VClone_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VSpace_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VSpace_Serial(v, lrw, liw) &
+          bind(C,name='N_VSpace_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v
+       integer(c_long)    :: lrw
+       integer(c_long)    :: liw
+     end subroutine FN_VSpace_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VGetArrayPointer_Serial
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FN_VGetArrayPointer_Serial(vec) &
+          bind(C,name='N_VGetArrayPointer_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: vec
+     end function FN_VGetArrayPointer_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VSetArrayPointer_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VSetArrayPointer_Serial(v_data, v) &
+          bind(C,name='N_VSetArrayPointer_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: v_data
+       type(c_ptr), value :: v
+     end subroutine FN_VSetArrayPointer_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VLinearSum_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VLinearSum_Serial(a, x, b, y, z) &
+          bind(C,name='N_VLinearSum_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: a
+       type(c_ptr),    value :: x
+       real(c_double), value :: b
+       type(c_ptr),    value :: y
+       type(c_ptr),    value :: z
+     end subroutine FN_VLinearSum_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VConst_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VConst_Serial(c, z) &
+          bind(C,name='N_VConst_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: z
+     end subroutine FN_VConst_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VProd_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VProd_Serial(x, y, z) &
+          bind(C,name='N_VProd_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+       type(c_ptr), value :: z
+     end subroutine FN_VProd_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VDiv_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VDiv_Serial(x, y, z) &
+          bind(C,name='N_VDiv_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+       type(c_ptr), value :: z
+     end subroutine FN_VDiv_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VScale_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VScale_Serial(c, x, z) &
+          bind(C,name='N_VScale_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: z
+     end subroutine FN_VScale_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VAbs_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VAbs_Serial(x, z) &
+          bind(C,name='N_VAbs_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end subroutine FN_VAbs_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VInv_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VInv_Serial(x, z) &
+          bind(C,name='N_VInv_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end subroutine FN_VInv_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VAddConst
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VAddConst_Serial(x, b, z) &
+          bind(C,name='N_VAddConst_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: x
+       real(c_double), value :: b
+       type(c_ptr),    value :: z
+     end subroutine FN_VAddConst_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VDotProd_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VDotProd_Serial(x, y) &
+          bind(C,name='N_VDotProd_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+     end function FN_VDotProd_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VMaxNorm_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMaxNorm_Serial(x) &
+          bind(C,name='N_VMaxNorm_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VMaxNorm_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VWrmsNorm_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWrmsNorm_Serial(x, w) &
+          bind(C,name='N_VWrmsNorm_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+     end function FN_VWrmsNorm_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VWrmsNormMask_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWrmsNormMask_Serial(x, w, id) &
+          bind(C,name='N_VWrmsNormMask_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+       type(c_ptr), value :: id
+     end function FN_VWrmsNormMask_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VMin_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMin_Serial(x) &
+          bind(C,name='N_VMin_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VMin_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VWL2Norm_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VWL2Norm_Serial(x, w) &
+          bind(C,name='N_VWL2Norm_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: w
+     end function FN_VWL2Norm_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VL1Norm_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VL1Norm_Serial(x) &
+          bind(C,name='N_VL1Norm_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+     end function FN_VL1Norm_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VCompare_Serial
+     ! -----------------------------------------------------------------
+
+     subroutine FN_VCompare_Serial(c, x, z) &
+          bind(C,name='N_VCompare_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       real(c_double), value :: c
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: z
+     end subroutine FN_VCompare_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VInvTest_Serial
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FN_VInvTest_Serial(x, z) &
+          bind(C,name='N_VInvTest_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: x
+       type(c_ptr), value :: z
+     end function FN_VInvTest_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VConstrMask_Serial
+     ! -----------------------------------------------------------------
+
+     integer(c_int) function FN_VConstrMask_Serial(c, x, m) &
+          bind(C,name='N_VConstrMask_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: c
+       type(c_ptr), value :: x
+       type(c_ptr), value :: m
+     end function FN_VConstrMask_Serial
+
+     ! -----------------------------------------------------------------
+     ! N_VMinQuotient_Serial
+     ! -----------------------------------------------------------------
+
+     real(c_double) function FN_VMinQuotient_Serial(num, denom) &
+          bind(C,name='N_VMinQuotient_Serial')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: num
+       type(c_ptr), value :: denom
+     end function FN_VMinQuotient_Serial
+
+     ! ================================================================
+     ! Fused vector operations: NOT INTERFACED
+     ! ================================================================
+
+     ! ================================================================
+     ! Vector array operations: NOT INTERFACED
+     ! ================================================================
+     
+   end interface
+
+contains
+
+  ! ================================================================
+  ! Helpful routines
+  ! ================================================================
+
+  ! ----------------------------------------------------------------
+  ! FN_VGetData_Serial 
+  ! 
+  ! Extracts data array from a serial SUNDIALS N_Vector
+  ! ----------------------------------------------------------------
+
+  subroutine FN_VGetData_Serial(vec, f_array)
+
+    !======= Inclusions ===========
+    use, intrinsic :: iso_c_binding
+
+    !======= Declarations =========
+    implicit none
+
+    ! calling variables
+    type(c_ptr)             :: vec
+    integer(c_long)         :: length
+    real(c_double), pointer :: f_array(:)
+
+    ! C pointer for N_Vector interal data array
+    type(c_ptr) :: c_array
+
+    !======= Internals ============
+
+    ! get data pointer from N_Vector
+    c_array = FN_VGetArrayPointer_Serial(vec)
+
+    ! get vector length
+    length = FN_VGetLength_Serial(vec)
+    
+    ! convert c pointer to f pointer
+    call c_f_pointer(c_array, f_array, (/length/))
+
+  end subroutine FN_VGetData_Serial
+
+end module fnvector_serial_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/trilinos/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/trilinos/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bb584b8c8b9a55d6f0e5fd757337f099474679ff
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/trilinos/CMakeLists.txt
@@ -0,0 +1,92 @@
+# ---------------------------------------------------------------
+# Programmer:  Slaven Peles @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the Trilinos NVECTOR library
+
+INSTALL(CODE "MESSAGE(\"\nInstall NVECTOR_Trilinos\n\")")
+
+# Set Trilinos compilers/flags
+SET(CMAKE_CXX_COMPILER ${Trilinos_INTERFACE_CXX_COMPILER})
+SET(CMAKE_C_COMPILER   ${Trilinos_INTERFACE_C_COMPILER})
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Trilinos_INTERFACE_CXX_COMPILER_FLAGS}")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${Trilinos_INTERFACE_C_COMPILER_FLAGS}")
+
+# Add variable nvectrilinos_SOURCES with the sources for the NVECTRILINOS lib
+SET(nvectrilinos_SOURCES nvector_trilinos.cpp)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the NVECTRILINOS library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable nvectrilinos_HEADERS with the exported NVECTRILINOS header files
+SET(nvectrilinos_HEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/nvector_trilinos.h
+  )
+
+SET(nvectrilinos_CXXHEADERS
+  ${sundials_SOURCE_DIR}/include/nvector/trilinos/SundialsTpetraVectorInterface.hpp
+  ${sundials_SOURCE_DIR}/include/nvector/trilinos/SundialsTpetraVectorKernels.hpp
+  )
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the NVECTRILINOS library
+#  - Set the library name and make sure it is not deleted
+#  - Install the NVECTRILINOS library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_nvectrilinos_static STATIC ${nvectrilinos_SOURCES} ${shared_SOURCES})
+
+  TARGET_LINK_LIBRARIES(sundials_nvectrilinos_static
+    PUBLIC Trilinos::Trilinos)
+
+  SET_TARGET_PROPERTIES(sundials_nvectrilinos_static
+    PROPERTIES OUTPUT_NAME sundials_nvectrilinos CLEAN_DIRECT_OUTPUT 1)
+
+  INSTALL(TARGETS sundials_nvectrilinos_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the NVECTRILINOS library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the NVECTRILINOS library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_nvectrilinos_shared SHARED ${nvectrilinos_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_nvectrilinos_shared
+      PUBLIC m)
+  ENDIF()
+
+  TARGET_LINK_LIBRARIES(sundials_nvectrilinos_shared
+    PUBLIC Trilinos::Trilinos)
+
+  SET_TARGET_PROPERTIES(sundials_nvectrilinos_shared
+    PROPERTIES OUTPUT_NAME sundials_nvectrilinos CLEAN_DIRECT_OUTPUT 1)
+
+  SET_TARGET_PROPERTIES(sundials_nvectrilinos_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+
+  INSTALL(TARGETS sundials_nvectrilinos_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the NVECTRILINOS header files
+INSTALL(FILES ${nvectrilinos_HEADERS} DESTINATION include/nvector)
+INSTALL(FILES ${nvectrilinos_CXXHEADERS} DESTINATION include/nvector/trilinos)
+
+#
+MESSAGE(STATUS "Added NVECTOR_Trilinos module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/trilinos/nvector_trilinos.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/trilinos/nvector_trilinos.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a500ef53ab9b3dea35ff4e98331d729f4b2c42d1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/nvector/trilinos/nvector_trilinos.cpp
@@ -0,0 +1,544 @@
+/* -----------------------------------------------------------------
+ * Programmer(s): Slaven Peles @ LLNL
+ *
+ * Based on N_Vector_Parallel by Scott D. Cohen, Alan C. Hindmarsh,
+ * Radu Serban, and Aaron Collier @ LLNL
+ * -----------------------------------------------------------------
+ * SUNDIALS Copyright Start
+ * Copyright (c) 2002-2019, Lawrence Livermore National Security
+ * and Southern Methodist University.
+ * All rights reserved.
+ *
+ * See the top-level LICENSE and NOTICE files for details.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ * SUNDIALS Copyright End
+ * -----------------------------------------------------------------
+ * This is the implementation file for a Trilinos implementation
+ * of the NVECTOR package.
+ * -----------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <nvector/nvector_trilinos.h>
+#include <nvector/trilinos/SundialsTpetraVectorInterface.hpp>
+#include <nvector/trilinos/SundialsTpetraVectorKernels.hpp>
+
+#define ZERO   RCONST(0.0)
+#define HALF   RCONST(0.5)
+#define ONE    RCONST(1.0)
+#define ONEPT5 RCONST(1.5)
+
+
+
+/*
+ * -----------------------------------------------------------------
+ * using statements
+ * -----------------------------------------------------------------
+ */
+
+using Teuchos::Comm;
+using Teuchos::RCP;
+using Teuchos::rcp;
+using Teuchos::outArg;
+using Teuchos::REDUCE_SUM;
+using Teuchos::reduceAll;
+
+/*
+ * -----------------------------------------------------------------
+ * type definitions
+ * -----------------------------------------------------------------
+ */
+
+typedef Sundials::TpetraVectorInterface::vector_type vector_type;
+
+/* ----------------------------------------------------------------
+ * Returns vector type ID. Used to identify vector implementation
+ * from abstract N_Vector interface.
+ */
+N_Vector_ID N_VGetVectorID_Trilinos(N_Vector v)
+{
+  return SUNDIALS_NVEC_TRILINOS;
+}
+
+
+/* ----------------------------------------------------------------
+ * Function to create a new Trilinos vector with empty data array
+ */
+
+N_Vector N_VNewEmpty_Trilinos()
+{
+  N_Vector v;
+  N_Vector_Ops ops;
+
+  /* Create vector */
+  v = NULL;
+  v = (N_Vector) malloc(sizeof *v);
+  if (v == NULL) return(NULL);
+
+  /* Create vector operation structure */
+  ops = NULL;
+  ops = (N_Vector_Ops) malloc(sizeof(struct _generic_N_Vector_Ops));
+  if (ops == NULL) { free(v); return(NULL); }
+
+  ops->nvgetvectorid     = N_VGetVectorID_Trilinos;
+  ops->nvclone           = N_VClone_Trilinos;
+  ops->nvcloneempty      = N_VCloneEmpty_Trilinos;
+  ops->nvdestroy         = N_VDestroy_Trilinos;
+  ops->nvspace           = N_VSpace_Trilinos;
+  ops->nvgetarraypointer = NULL;
+  ops->nvsetarraypointer = NULL;
+  ops->nvlinearsum       = N_VLinearSum_Trilinos;
+  ops->nvconst           = N_VConst_Trilinos;
+  ops->nvprod            = N_VProd_Trilinos;
+  ops->nvdiv             = N_VDiv_Trilinos;
+  ops->nvscale           = N_VScale_Trilinos;
+  ops->nvabs             = N_VAbs_Trilinos;
+  ops->nvinv             = N_VInv_Trilinos;
+  ops->nvaddconst        = N_VAddConst_Trilinos;
+  ops->nvdotprod         = N_VDotProd_Trilinos;
+  ops->nvmaxnorm         = N_VMaxNorm_Trilinos;
+  ops->nvwrmsnorm        = N_VWrmsNorm_Trilinos;
+  ops->nvwrmsnormmask    = N_VWrmsNormMask_Trilinos;
+  ops->nvmin             = N_VMin_Trilinos;
+  ops->nvwl2norm         = N_VWL2Norm_Trilinos;
+  ops->nvl1norm          = N_VL1Norm_Trilinos;
+  ops->nvcompare         = N_VCompare_Trilinos;
+  ops->nvinvtest         = N_VInvTest_Trilinos;
+  ops->nvconstrmask      = N_VConstrMask_Trilinos;
+  ops->nvminquotient     = N_VMinQuotient_Trilinos;
+
+  /* fused vector operations */
+  ops->nvlinearcombination = NULL;
+  ops->nvscaleaddmulti     = NULL;
+  ops->nvdotprodmulti      = NULL;
+
+  /* vector array operations */
+  ops->nvlinearsumvectorarray         = NULL;
+  ops->nvscalevectorarray             = NULL;
+  ops->nvconstvectorarray             = NULL;
+  ops->nvwrmsnormvectorarray          = NULL;
+  ops->nvwrmsnormmaskvectorarray      = NULL;
+  ops->nvscaleaddmultivectorarray     = NULL;
+  ops->nvlinearcombinationvectorarray = NULL;
+
+  /* Attach ops and set content to NULL */
+  v->content = NULL;
+  v->ops     = ops;
+
+  return(v);
+}
+
+
+
+/* ----------------------------------------------------------------
+ * Function to create an N_Vector attachment to Tpetra vector.
+ * void* argument is to allow for calling this method from C code.
+ *
+ */
+
+N_Vector N_VMake_Trilinos(Teuchos::RCP<vector_type> vec)
+{
+  N_Vector v = NULL;
+
+  // Create an N_Vector with operators attached and empty content
+  v = N_VNewEmpty_Trilinos();
+  if (v == NULL)
+     return(NULL);
+
+  // Create vector content using a pointer to Tpetra vector
+  v->content = new Sundials::TpetraVectorInterface(vec);
+  if (v->content == NULL) {
+    free(v->ops);
+    free(v);
+    return NULL;
+  }
+
+  return(v);
+}
+
+
+/*
+ * -----------------------------------------------------------------
+ * implementation of vector operations
+ * -----------------------------------------------------------------
+ */
+
+N_Vector N_VCloneEmpty_Trilinos(N_Vector w)
+{
+  N_Vector v;
+  N_Vector_Ops ops;
+
+  if (w == NULL) return(NULL);
+
+  /* Create vector */
+  v = NULL;
+  v = (N_Vector) malloc(sizeof *v);
+  if (v == NULL) return(NULL);
+
+  /* Create vector operation structure */
+  ops = NULL;
+  ops = (N_Vector_Ops) malloc(sizeof(struct _generic_N_Vector_Ops));
+  if (ops == NULL) {
+    free(v);
+    return(NULL);
+  }
+
+  ops->nvgetvectorid     = w->ops->nvgetvectorid;
+  ops->nvclone           = w->ops->nvclone;
+  ops->nvcloneempty      = w->ops->nvcloneempty;
+  ops->nvdestroy         = w->ops->nvdestroy;
+  ops->nvspace           = w->ops->nvspace;
+  ops->nvgetarraypointer = w->ops->nvgetarraypointer;
+  ops->nvsetarraypointer = w->ops->nvsetarraypointer;
+  ops->nvlinearsum       = w->ops->nvlinearsum;
+  ops->nvconst           = w->ops->nvconst;
+  ops->nvprod            = w->ops->nvprod;
+  ops->nvdiv             = w->ops->nvdiv;
+  ops->nvscale           = w->ops->nvscale;
+  ops->nvabs             = w->ops->nvabs;
+  ops->nvinv             = w->ops->nvinv;
+  ops->nvaddconst        = w->ops->nvaddconst;
+  ops->nvdotprod         = w->ops->nvdotprod;
+  ops->nvmaxnorm         = w->ops->nvmaxnorm;
+  ops->nvwrmsnorm        = w->ops->nvwrmsnorm;
+  ops->nvwrmsnormmask    = w->ops->nvwrmsnormmask;
+  ops->nvmin             = w->ops->nvmin;
+  ops->nvwl2norm         = w->ops->nvwl2norm;
+  ops->nvl1norm          = w->ops->nvl1norm;
+  ops->nvcompare         = w->ops->nvcompare;
+  ops->nvinvtest         = w->ops->nvinvtest;
+  ops->nvconstrmask      = w->ops->nvconstrmask;
+  ops->nvminquotient     = w->ops->nvminquotient;
+
+  /* fused vector operations */
+  ops->nvlinearcombination = w->ops->nvlinearcombination;
+  ops->nvscaleaddmulti     = w->ops->nvscaleaddmulti;
+  ops->nvdotprodmulti      = w->ops->nvdotprodmulti;
+
+  /* vector array operations */
+  ops->nvlinearsumvectorarray         = w->ops->nvlinearsumvectorarray;
+  ops->nvscalevectorarray             = w->ops->nvscalevectorarray;
+  ops->nvconstvectorarray             = w->ops->nvconstvectorarray;
+  ops->nvwrmsnormvectorarray          = w->ops->nvwrmsnormvectorarray;
+  ops->nvwrmsnormmaskvectorarray      = w->ops->nvwrmsnormmaskvectorarray;
+  ops->nvscaleaddmultivectorarray     = w->ops->nvscaleaddmultivectorarray;
+  ops->nvlinearcombinationvectorarray = w->ops->nvlinearcombinationvectorarray;
+
+  /* Attach ops and set content to NULL */
+  v->content = NULL;
+  v->ops     = ops;
+
+  return(v);
+}
+
+N_Vector N_VClone_Trilinos(N_Vector w)
+{
+  N_Vector v = N_VCloneEmpty_Trilinos(w);
+  if (v == NULL)
+    return(NULL);
+
+  // Get raw pointer to Tpetra vector
+  Teuchos::RCP<vector_type> wvec = N_VGetVector_Trilinos(w);
+
+  // Clone wvec and get raw pointer to the clone
+  Teuchos::RCP<vector_type> tvec =
+    Teuchos::rcp(new vector_type(*wvec, Teuchos::Copy));
+
+  // Create vector content using the raw pointer to the cloned Tpetra vector
+  v->content = new Sundials::TpetraVectorInterface(tvec);
+  if (v->content == NULL) {
+    free(v->ops);
+    free(v);
+    return NULL;
+  }
+
+  return(v);
+}
+
+void N_VDestroy_Trilinos(N_Vector v)
+{
+  if(v->content != NULL) {
+    Sundials::TpetraVectorInterface* iface =
+      reinterpret_cast<Sundials::TpetraVectorInterface*>(v->content);
+
+      // iface was created with 'new', so use 'delete' to destroy it.
+      delete iface;
+      v->content = NULL;
+  }
+
+  free(v->ops);
+  v->ops = NULL;
+
+  free(v);
+  v = NULL;
+}
+
+void N_VSpace_Trilinos(N_Vector x, sunindextype *lrw, sunindextype *liw)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  const Teuchos::RCP<const Teuchos::Comm<int> >& comm = xv->getMap()->getComm();
+  int npes = comm->getSize();
+
+  *lrw = xv->getGlobalLength();
+  *liw = 2*npes;
+}
+
+/*
+ * Linear combination of two vectors: z = a*x + b*y
+ */
+void N_VLinearSum_Trilinos(realtype a, N_Vector x, realtype b, N_Vector y, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> yv = N_VGetVector_Trilinos(y);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  if (x == z) {
+    zv->update(b, *yv, a);
+  } else if (y == z) {
+    zv->update(a, *xv, b);
+  } else {
+    zv->update(a, *xv, b, *yv, ZERO);
+  }
+
+}
+
+/*
+ * Set all vector elements to a constant: z[i] = c
+ */
+void N_VConst_Trilinos(realtype c, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<vector_type> zv = N_VGetVector_Trilinos(z);
+
+  zv->putScalar(c);
+}
+
+/*
+ * Elementwise multiply vectors: z[i] = x[i]*y[i]
+ */
+void N_VProd_Trilinos(N_Vector x, N_Vector y, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> yv = N_VGetVector_Trilinos(y);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  zv->elementWiseMultiply(ONE, *xv, *yv, ZERO);
+}
+
+/*
+ * Elementwise divide vectors: z[i] = x[i]/y[i]
+ */
+void N_VDiv_Trilinos(N_Vector x, N_Vector y, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> yv = N_VGetVector_Trilinos(y);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  TpetraVector::elementWiseDivide(*xv, *yv, *zv);
+}
+
+/*
+ * Scale vector: z = c*x
+ */
+void N_VScale_Trilinos(realtype c, N_Vector x, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  zv->scale(c, *xv);
+}
+
+/*
+ * Elementwise absolute value: z[i] = |x[i]|
+ */
+void N_VAbs_Trilinos(N_Vector x, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  zv->abs(*xv);
+}
+
+/*
+ * Elementwise inverse: z[i] = 1/x[i]
+ */
+void N_VInv_Trilinos(N_Vector x, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  zv->reciprocal(*xv);
+}
+
+/*
+ * Add constant: z = x + b
+ */
+void N_VAddConst_Trilinos(N_Vector x, realtype b, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  TpetraVector::addConst(*xv, b, *zv);
+}
+
+/*
+ * Scalar product of vectors x and y
+ */
+realtype N_VDotProd_Trilinos(N_Vector x, N_Vector y)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> yv = N_VGetVector_Trilinos(y);
+
+  return xv->dot(*yv);
+}
+
+/*
+ * Max norm (L infinity) of vector x
+ */
+realtype N_VMaxNorm_Trilinos(N_Vector x)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+
+  return xv->normInf();
+}
+
+/*
+ * Weighted RMS norm
+ */
+realtype N_VWrmsNorm_Trilinos(N_Vector x, N_Vector w)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> wv = N_VGetVector_Trilinos(w);
+
+  return TpetraVector::normWrms(*xv, *wv);
+}
+
+/*
+ * Masked weighted RMS norm
+ */
+realtype N_VWrmsNormMask_Trilinos(N_Vector x, N_Vector w, N_Vector id)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv  = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> wv  = N_VGetVector_Trilinos(w);
+  Teuchos::RCP<const vector_type> idv = N_VGetVector_Trilinos(id);
+
+  return TpetraVector::normWrmsMask(*xv, *wv, *idv);
+}
+
+/*
+ * Returns minimum vector element
+ */
+realtype N_VMin_Trilinos(N_Vector x)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv  = N_VGetVector_Trilinos(x);
+
+  return TpetraVector::minElement(*xv);
+}
+
+/*
+ * Weighted L2 norm
+ */
+realtype N_VWL2Norm_Trilinos(N_Vector x, N_Vector w)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<const vector_type> wv = N_VGetVector_Trilinos(w);
+
+  return TpetraVector::normWL2(*xv, *wv);
+}
+
+/*
+ * L1 norm
+ */
+realtype N_VL1Norm_Trilinos(N_Vector x)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+
+  return xv->norm1();
+}
+
+/*
+ * Elementwise z[i] = |x[i]| >= c ? 1 : 0
+ */
+void N_VCompare_Trilinos(realtype c, N_Vector x, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  TpetraVector::compare(c, *xv, *zv);
+}
+
+/*
+ * Elementwise inverse with zero checking: z[i] = 1/x[i], x[i] != 0
+ */
+booleantype N_VInvTest_Trilinos(N_Vector x, N_Vector z)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> zv       = N_VGetVector_Trilinos(z);
+
+  return TpetraVector::invTest(*xv, *zv) ? SUNTRUE : SUNFALSE;
+}
+
+/*
+ * Checks constraint violations for vector x. Constraints are defined in
+ * vector c, and constrain violation flags are stored in vector m.
+ */
+booleantype N_VConstrMask_Trilinos(N_Vector c, N_Vector x, N_Vector m)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> cv = N_VGetVector_Trilinos(c);
+  Teuchos::RCP<const vector_type> xv = N_VGetVector_Trilinos(x);
+  Teuchos::RCP<vector_type> mv       = N_VGetVector_Trilinos(m);
+
+  return TpetraVector::constraintMask(*cv, *xv, *mv) ? SUNTRUE : SUNFALSE;
+}
+
+/*
+ * Find minimum quotient: minq  = min ( num[i]/denom[i]), denom[i] != 0.
+ */
+realtype N_VMinQuotient_Trilinos(N_Vector num, N_Vector denom)
+{
+  using namespace Sundials;
+
+  Teuchos::RCP<const vector_type> numv = N_VGetVector_Trilinos(num);
+  Teuchos::RCP<const vector_type> denv = N_VGetVector_Trilinos(denom);
+
+  return TpetraVector::minQuotient(*numv, *denv);
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sundials/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sundials/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e5680d0ba21049348dc0268bf1e4fcc030bc4aa5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sundials/CMakeLists.txt
@@ -0,0 +1,58 @@
+# ---------------------------------------------------------------
+# Programmer:  Radu Serban @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the generic SUNDIALS modules
+
+# From here we only install the generic SUNDIALS headers.
+# The implementations themselves are incorporated in the individual SUNDIALS solver libraries.
+
+INSTALL(CODE "MESSAGE(\"\nInstall shared components\n\")")
+
+# Add variable sundials_HEADERS with the exported SUNDIALS header files
+SET(sundials_HEADERS
+  sundials_band.h
+  sundials_dense.h
+  sundials_direct.h
+  sundials_fnvector.h
+  sundials_iterative.h
+  sundials_linearsolver.h
+  sundials_math.h
+  sundials_matrix.h
+  sundials_mpi.h
+  sundials_mpi_types.h
+  sundials_nonlinearsolver.h
+  sundials_mpi.h
+  sundials_mpi_types.h
+  sundials_nvector.h
+  sundials_pcg.h
+  sundials_sparse.h
+  sundials_spbcgs.h
+  sundials_spfgmr.h
+  sundials_spgmr.h
+  sundials_sptfqmr.h
+  sundials_types.h
+  sundials_version.h
+  )
+
+# Add prefix with complete path to the SUNDIALS header files
+ADD_PREFIX(${sundials_SOURCE_DIR}/include/sundials/ sundials_HEADERS)
+
+# Install the SUNDIALS header files
+INSTALL(FILES ${sundials_HEADERS} DESTINATION include/sundials)
+
+# If Blas/Lapack support was enabled, install the Lapack interface headers
+IF(LAPACK_FOUND)
+  SET(sundials_BL_HEADERS sundials_lapack.h)
+  ADD_PREFIX(${sundials_SOURCE_DIR}/include/sundials/ sundials_BL_HEADERS)
+  INSTALL(FILES ${sundials_BL_HEADERS} DESTINATION include/sundials)
+ENDIF(LAPACK_FOUND)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..965189e32665d332528e22ce6b289deebe91fe0b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/CMakeLists.txt
@@ -0,0 +1,39 @@
+# ------------------------------------------------------------------------------
+# Programmer(s): Cody J. Balos @ LLNL
+# ------------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------------
+# linear solver level CMakeLists.txt for SUNDIALS
+# ------------------------------------------------------------------------------
+
+# Always add SUNDIALS provided linear solver modules
+add_subdirectory(band)
+add_subdirectory(dense)
+add_subdirectory(pcg)
+
+add_subdirectory(spbcgs)
+add_subdirectory(spfgmr)
+add_subdirectory(spgmr)
+add_subdirectory(sptfqmr)
+
+# Add linear solver modules with TPL dependencies
+if(KLU_ENABLE AND KLU_FOUND)
+  add_subdirectory(klu)
+endif(KLU_ENABLE AND KLU_FOUND)
+
+if(SUPERLUMT_ENABLE AND SUPERLUMT_FOUND)
+  add_subdirectory(superlumt)
+endif(SUPERLUMT_ENABLE AND SUPERLUMT_FOUND)
+
+if(LAPACK_ENABLE AND LAPACK_FOUND)
+  add_subdirectory(lapackband)
+  add_subdirectory(lapackdense)
+endif(LAPACK_ENABLE AND LAPACK_FOUND)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..75a8f14152dc4cb212af26fc083e9563f97b0185
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/CMakeLists.txt
@@ -0,0 +1,106 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the band SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_BAND\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsolband_SOURCES with the sources for the SUNLINSOLBAND lib
+SET(sunlinsolband_SOURCES sunlinsol_band.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLBAND library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_band.c
+  )
+
+# Add variable sunlinsolband_HEADERS with the exported SUNLINSOLBAND header files
+SET(sunlinsolband_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_band.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLBAND library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLBAND library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolband_static STATIC ${sunlinsolband_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolband_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolband CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolband_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLBAND library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLBAND library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolband_shared SHARED ${sunlinsolband_SOURCES} ${shared_SOURCES})
+
+  # sunlinsolband depends on sunmatrixband
+  TARGET_LINK_LIBRARIES(sundials_sunlinsolband_shared sundials_sunmatrixband_shared)
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolband_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolband CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolband_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolband_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLBAND header files
+INSTALL(FILES ${sunlinsolband_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLBAND library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolband_SOURCES fsunlinsol_band.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolband_static STATIC ${fsunlinsolband_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolband_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolband CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolband_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolband_shared ${fsunlinsolband_SOURCES})
+
+    # fsunlinsolband depends on fnvecserial, fsunmatrixband, sunlinsolband
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolband_shared
+      sundials_fnvecserial_shared
+      sundials_fsunmatrixband_shared
+      sundials_sunlinsolband_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolband_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolband CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolband_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolband_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_BAND module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35ba5bbd956821496004ee8af99b91d7525889b7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ----------------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ----------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ----------------------------------------------------------------------
+# CMakeLists.txt file for the F2003 band SUNLinearSolver object library
+
+set(sunlinsolband_SOURCES fsunlinsol_band.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolband_mod_static STATIC
+    ${sunlinsolband_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolband_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolband_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolband_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolband_mod_shared SHARED
+    ${sunlinsolband_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolband_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolband_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolband_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolband_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_BAND F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/F90/fsunlinsol_band.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/F90/fsunlinsol_band.f90
new file mode 100644
index 0000000000000000000000000000000000000000..e5f5c8ca2a90315c3050fd7e918ca2f606a9eed4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/band/F90/fsunlinsol_band.f90
@@ -0,0 +1,101 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS banded matrix using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_band_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_Band(y, A) &
+          bind(C,name='SUNLinSol_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: y
+       type(c_ptr), value :: A
+     end function FSUNLinSol_Band
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_Band(LS) &
+          bind(C,name='SUNLinSolFree_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_Band
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_Band(LS) &
+          bind(C,name='SUNLinSolGetType_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_Band
+
+     integer(c_int) function FSUNLinSolInitialize_Band(LS) &
+          bind(C,name='SUNLinSolInitialize_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_Band
+
+     integer(c_int) function FSUNLinSolSetup_Band(LS, A) &
+          bind(C,name='SUNLinSolSetup_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FSUNLinSolSetup_Band
+
+     integer(c_int) function FSUNLinSolSolve_Band(LS, A, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_Band
+
+     integer(c_long) function FSUNLinSolLastFlag_Band(LS) &
+          bind(C,name='SUNLinSolLastFlag_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_Band
+
+     integer(c_int) function FSUNLinSolSpace_Band(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_Band
+
+  end interface
+
+end module fsunlinsol_band_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2f5374b358229f0a7ffd9c0d9348b18382d82766
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/CMakeLists.txt
@@ -0,0 +1,105 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds, Ashley Crawford @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the dense SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_DENSE\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsoldense_SOURCES with the sources for the SUNLINSOLDENSE lib
+SET(sunlinsoldense_SOURCES sunlinsol_dense.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLDENSE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_dense.c
+  )
+
+# Add variable sunlinsoldense_HEADERS with the exported SUNLINSOLDENSE header files
+SET(sunlinsoldense_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_dense.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLDENSE library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLDENSE library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsoldense_static STATIC ${sunlinsoldense_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsoldense_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsoldense CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsoldense_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLDENSE library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLDENSE library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsoldense_shared SHARED ${sunlinsoldense_SOURCES} ${shared_SOURCES})
+
+  TARGET_LINK_LIBRARIES(sundials_sunlinsoldense_shared sundials_sunmatrixdense_shared)
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsoldense_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsoldense CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsoldense_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsoldense_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLDENSE header files
+INSTALL(FILES ${sunlinsoldense_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLDENSE library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsoldense_SOURCES fsunlinsol_dense.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsoldense_static STATIC ${fsunlinsoldense_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsoldense_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsoldense CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsoldense_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsoldense_shared ${fsunlinsoldense_SOURCES})
+
+    # fsunlinsoldense depends on fnvecserial, fsunmatrixdense, sunlinsoldense
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsoldense_shared
+      sundials_fnvecserial_shared
+      sundials_fsunmatrixdense_shared
+      sundials_sunlinsoldense_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsoldense_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsoldense CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsoldense_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsoldense_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_DENSE module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5fcdceb46fc6b85116307da1edc03290e8cf4a0d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ----------------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ----------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ----------------------------------------------------------------------
+# CMakeLists.txt file for the F2003 dense SUNLinearSolver object library
+
+set(sunlinsoldense_SOURCES fsunlinsol_dense.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsoldense_mod_static STATIC
+    ${sunlinsoldense_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsoldense_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsoldense_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsoldense_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsoldense_mod_shared SHARED
+    ${sunlinsoldense_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsoldense_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsoldense_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsoldense_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsoldense_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_DENSE F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/F90/fsunlinsol_dense.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/F90/fsunlinsol_dense.f90
new file mode 100644
index 0000000000000000000000000000000000000000..1374259db0da77de0cf8be5975119460dc8dd3ad
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/dense/F90/fsunlinsol_dense.f90
@@ -0,0 +1,110 @@
+! -----------------------------------------------------------------
+! Programmer(s): David J. Gardner @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS dense linear solver using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_dense_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_Dense(y, A) &
+          bind(C,name='SUNLinSol_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: y
+       type(c_ptr), value :: A
+     end function FSUNLinSol_Dense
+     
+     ! Deprecated
+     type(c_ptr) function FSUNDenseLinearSolver(y, A) &
+          bind(C,name='SUNDenseLinearSolver')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: y
+       type(c_ptr), value :: A
+     end function FSUNDenseLinearSolver
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_Dense(LS) &
+          bind(C,name='SUNLinSolFree_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_Dense
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_Dense(LS) &
+          bind(C,name='SUNLinSolGetType_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_Dense
+
+     integer(c_int) function FSUNLinSolInitialize_Dense(LS) &
+          bind(C,name='SUNLinSolInitialize_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_Dense
+
+     integer(c_int) function FSUNLinSolSetup_Dense(LS, A) &
+          bind(C,name='SUNLinSolSetup_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FSUNLinSolSetup_Dense
+
+     integer(c_int) function FSUNLinSolSolve_Dense(LS, A, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_Dense
+
+     integer(c_long) function FSUNLinSolLastFlag_Dense(LS) &
+          bind(C,name='SUNLinSolLastFlag_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_Dense
+
+     integer(c_int) function FSUNLinSolSpace_Dense(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_Dense
+
+  end interface
+
+end module fsunlinsol_dense_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..775c4c1fd185fba94d04a0dce309e05d23af8cef
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/CMakeLists.txt
@@ -0,0 +1,107 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the klu SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_KLU\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsolklu_SOURCES with the sources for the SUNLINSOLKLU lib
+SET(sunlinsolklu_SOURCES sunlinsol_klu.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLKLU library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  )
+
+# Add variable sunlinsolklu_HEADERS with the exported SUNLINSOLKLU header files
+SET(sunlinsolklu_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_klu.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLKLU library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLKLU library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolklu_static STATIC ${sunlinsolklu_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolklu_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolklu CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolklu_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLKLU library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLKLU library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolklu_shared SHARED ${sunlinsolklu_SOURCES} ${shared_SOURCES})
+
+  # sunlinsolklu depends on sunmatrixsparse and KLU
+  TARGET_LINK_LIBRARIES(sundials_sunlinsolklu_shared
+    sundials_sunmatrixsparse_shared
+    ${KLU_LIBRARIES})
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolklu_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolklu CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolklu_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolklu_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLKLU header files
+INSTALL(FILES ${sunlinsolklu_HEADERS} DESTINATION include/sunlinsol)
+
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolklu_SOURCES fsunlinsol_klu.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolklu_static STATIC ${fsunlinsolklu_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolklu_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolklu CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolklu_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolklu_shared ${fsunlinsolklu_SOURCES})
+
+    # fsunlinsolklu depends on fnvecserial, fsunmatrixsparse, sunlinsolklu
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolklu_shared
+      sundials_fnvecserial_shared
+      sundials_fsunmatrixsparse_shared
+      sundials_sunlinsolklu_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolklu_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolklu CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolklu_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolklu_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_KLU module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8023a096c6df969f71924117e4ed7f2750599990
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 KLU SUNLinearSolver object library
+
+set(sunlinsolklu_SOURCES fsunlinsol_klu.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolklu_mod_static STATIC
+    ${sunlinsolklu_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolklu_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolklu_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolklu_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolklu_mod_shared SHARED
+    ${sunlinsolklu_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolklu_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolklu_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolklu_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolklu_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_KLU F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/F90/fsunlinsol_klu.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/F90/fsunlinsol_klu.f90
new file mode 100644
index 0000000000000000000000000000000000000000..f49adbdfd60b2638e129747a4074360f5b3ac654
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/klu/F90/fsunlinsol_klu.f90
@@ -0,0 +1,129 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS sparse matrix using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_klu_mod
+
+  use, intrinsic :: iso_c_binding, only : c_int
+  
+  integer(c_int), parameter :: SUNKLU_ORDERING_DEFAULT = 1 ! COLAMD
+  integer(c_int), parameter :: SUNKLU_REINIT_FULL      = 1
+  integer(c_int), parameter :: SUNKLU_REINIT_PARTIAL   = 2
+
+  !======= Interfaces ========
+  interface
+
+    ! =================================================================
+    ! Constructors
+    ! =================================================================
+
+    type(c_ptr) function FSUNKLU(y, A) &
+        bind(C,name='SUNKLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: y
+      type(c_ptr), value :: A
+    end function FSUNKLU
+
+    ! =================================================================
+    ! Destructors
+    ! =================================================================
+
+    subroutine FSUNLinSolFree_KLU(LS) &
+        bind(C,name='SUNLinSolFree_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: LS
+    end subroutine FSUNLinSolFree_KLU
+
+    ! =================================================================
+    ! Setter/init routines
+    ! =================================================================
+
+    integer(c_int) function FSUNKLUReInit(LS, A, nnz, reinit_type) &
+      bind(C,name='SUNKLUReInit')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value     :: LS
+      type(c_ptr), value     :: A
+      integer(c_long), value :: nnz
+      integer(c_int), value  :: reinit_type
+    end function FSUNKLUReInit
+
+    integer(c_int) function FSUNKLUSetOrdering(LS, ordering_choice) &
+        bind(C,name='SUNKLUSetOrdering')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value    :: LS
+      integer(c_int), value :: ordering_choice
+    end function FSUNKLUSetOrdering
+
+    ! =================================================================
+    ! Operations
+    ! =================================================================
+
+    integer(c_int) function FSUNLinSolGetType_KLU(LS) &
+        bind(C,name='SUNLinSolGetType_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: LS
+    end function FSUNLinSolGetType_KLU
+
+    integer(c_int) function FSUNLinSolInitialize_KLU(LS) &
+        bind(C,name='SUNLinSolInitialize_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: LS
+    end function FSUNLinSolInitialize_KLU
+
+    integer(c_int) function FSUNLinSolSetup_KLU(LS, A) &
+        bind(C,name='SUNLinSolSetup_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: LS
+      type(c_ptr), value :: A
+    end function FSUNLinSolSetup_KLU
+
+    integer(c_int) function FSUNLinSolSolve_KLU(LS, A, x, b, tol) &
+        bind(C,name='SUNLinSolSolve_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value    :: LS
+      type(c_ptr), value    :: A
+      type(c_ptr), value    :: x
+      type(c_ptr), value    :: b
+      real(c_double), value :: tol
+    end function FSUNLinSolSolve_KLU
+
+    integer(c_long) function FSUNLinSolLastFlag_KLU(LS) &
+        bind(C,name='SUNLinSolLastFlag_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: LS
+    end function FSUNLinSolLastFlag_KLU
+
+    integer(c_int) function FSUNLinSolSpace_KLU(LS, lenrwLS, leniwLS) &
+        bind(C,name='SUNLinSolSpace_KLU')
+      use, intrinsic :: iso_c_binding
+      implicit none
+      type(c_ptr), value :: LS
+      integer(c_long), value :: lenrwLS
+      integer(c_long), value :: leniwLS
+    end function FSUNLinSolSpace_KLU
+
+  end interface
+
+end module fsunlinsol_klu_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/lapackband/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/lapackband/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1ef5cff24557c022f43f68c951c89fda64d8cb54
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/lapackband/CMakeLists.txt
@@ -0,0 +1,103 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the LapackBand SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_LAPACKBAND\n\")")
+
+# Add variable sunlinsollapackband_SOURCES with the sources for the SUNLINSOLLAPACKBAND lib
+SET(sunlinsollapackband_SOURCES sunlinsol_lapackband.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLLAPACKBAND library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  )
+
+# Add variable sunlinsollapackband_HEADERS with the
+# exported SUNLINSOLLAPACKBAND header files
+SET(sunlinsollapackband_HEADERS 
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_lapackband.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY 
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLLAPACKBAND library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLLAPACKBAND library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsollapackband_static STATIC ${sunlinsollapackband_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsollapackband_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsollapackband CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsollapackband_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLLAPACKBAND library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLLAPACKBAND library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsollapackband_shared SHARED ${sunlinsollapackband_SOURCES} ${shared_SOURCES})
+
+  # sunlinsollapackband depends on sunmatrixband and LAPACK
+  TARGET_LINK_LIBRARIES(sundials_sunlinsollapackband_shared
+    sundials_sunmatrixband_shared
+    ${LAPACK_LIBRARIES})
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsollapackband_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsollapackband CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsollapackband_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsollapackband_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLLAPACKBAND header files
+INSTALL(FILES ${sunlinsollapackband_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLLAPACKBAND library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsollapackband_SOURCES fsunlinsol_lapackband.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsollapackband_static STATIC ${fsunlinsollapackband_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsollapackband_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsollapackband CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsollapackband_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsollapackband_shared ${fsunlinsollapackband_SOURCES})
+
+    # fsunlinsollapackband depends on fnvecserial, fsunmatrixband, sunlinsollapackband
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsollapackband_shared
+      sundials_fnvecserial_shared
+      sundials_fsunmatrixband_shared
+      sundials_sunlinsollapackband_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsollapackband_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsollapackband CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsollapackband_shared 
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsollapackband_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_LAPACKBAND module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/lapackdense/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/lapackdense/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35605825c20b3495d426e38d985f9bcfe0378acc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/lapackdense/CMakeLists.txt
@@ -0,0 +1,109 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the LapackDense SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_LAPACKDENSE\n\")")
+
+# Add variable sunlinsollapackdense_SOURCES with the sources for
+# the SUNLINSOLLAPACKDENSE lib
+SET(sunlinsollapackdense_SOURCES sunlinsol_lapackdense.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLLAPACKDENSE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  )
+
+# Add variable sunlinsollapackdense_HEADERS with the
+# exported SUNLINSOLLAPACKDENSE header files
+SET(sunlinsollapackdense_HEADERS 
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_lapackdense.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY 
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLLAPACKDENSE library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLLAPACKDENSE library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsollapackdense_static STATIC ${sunlinsollapackdense_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsollapackdense_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsollapackdense CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsollapackdense_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLLAPACKDENSE library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLLAPACKDENSE library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsollapackdense_shared SHARED ${sunlinsollapackdense_SOURCES} ${shared_SOURCES})
+
+  # sunlinsollapackdense depends on sunmatrixdense and LAPACK
+  TARGET_LINK_LIBRARIES(sundials_sunlinsollapackdense_shared
+    sundials_sunmatrixdense_shared
+    ${LAPACK_LIBRARIES})
+  
+  #	if a blas library was provided, assume LAPACK depends on it
+  IF(BLAS_FOUND)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsollapackdense_shared ${BLAS_LIBRARIES})
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsollapackdense_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsollapackdense CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsollapackdense_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsollapackdense_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLLAPACKDENSE header files
+INSTALL(FILES ${sunlinsollapackdense_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLLAPACKDENSE library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsollapackdense_SOURCES fsunlinsol_lapackdense.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsollapackdense_static STATIC ${fsunlinsollapackdense_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsollapackdense_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsollapackdense CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsollapackdense_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsollapackdense_shared ${fsunlinsollapackdense_SOURCES})
+
+    # fsunlinsollapack depends on fnvecserial, fsunmatrixdense, sunlinsollapackdense
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsollapackdense_shared
+      sundials_fnvecserial_shared
+      sundials_fsunmatrixdense_shared
+      sundials_sunlinsollapackdense_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsollapackdense_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsollapackdense CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsollapackdense_shared 
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsollapackdense_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_LAPACKDENSE module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..969a0ca594d26fdd55e22dfe84173eb4499d0ed0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/CMakeLists.txt
@@ -0,0 +1,108 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the PCG SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_PCG\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsolpcg_SOURCES with the sources for the SUNLINSOLPCG lib
+SET(sunlinsolpcg_SOURCES sunlinsol_pcg.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLPCG library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  )
+
+# Add variable sunlinsolpcg_HEADERS with the exported SUNLINSOLPCG header files
+SET(sunlinsolpcg_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_pcg.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLPCG library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLPCG library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolpcg_static STATIC ${sunlinsolpcg_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolpcg_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolpcg CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolpcg_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLPCG library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLPCG library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolpcg_shared SHARED ${sunlinsolpcg_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolpcg_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolpcg_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolpcg CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolpcg_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolpcg_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLPCG header files
+INSTALL(FILES ${sunlinsolpcg_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLPCG library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolpcg_SOURCES fsunlinsol_pcg.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolpcg_static STATIC ${fsunlinsolpcg_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolpcg_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolpcg CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolpcg_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolpcg_shared ${fsunlinsolpcg_SOURCES})
+
+    # fsunlinsolpcg dependes on fnvecserial and sunlinsolpcg_shared
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolpcg_shared
+      sundials_fnvecserial_shared
+      sundials_sunlinsolpcg_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolpcg_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolpcg CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolpcg_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolpcg_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_PCG module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d923bdabc58403100ae2e3ff4ee69813e919b390
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 PCG SUNLinearSolver object library
+
+set(sunlinsolpcg_SOURCES fsunlinsol_pcg.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolpcg_mod_static STATIC
+    ${sunlinsolpcg_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolpcg_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolpcg_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolpcg_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolpcg_mod_shared SHARED
+    ${sunlinsolpcg_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolpcg_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolpcg_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolpcg_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolpcg_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_PCG F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/F90/fsunlinsol_pcg.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/F90/fsunlinsol_pcg.f90
new file mode 100644
index 0000000000000000000000000000000000000000..fc5c6ca8eef523f573132b97e3c870ad89d2c6d0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/pcg/F90/fsunlinsol_pcg.f90
@@ -0,0 +1,174 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS PCG linear solver using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_pcg_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_PCG(y, pretype, maxl) &
+          bind(C,name='SUNLinSol_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+       integer(c_int), value :: pretype
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_PCG
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_PCG(LS) &
+          bind(C,name='SUNLinSolFree_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_PCG
+
+     ! =================================================================
+     ! Setters
+     ! =================================================================
+     
+     integer(c_int) function FSUNLinSol_PCGSetPrecType(LS, pretype) &
+          bind(C,name='SUNLinSol_PCGSetPrecType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: pretype
+     end function FSUNLinSol_PCGSetPrecType
+    
+     integer(c_int) function FSUNLinSol_SPTFQMRSetMaxl(LS, maxl) &
+          bind(C,name='SUNLinSol_SPTFQMRSetMaxl')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPTFQMRSetMaxl
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_PCG(LS) &
+          bind(C,name='SUNLinSolGetType_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_PCG
+
+     integer(c_int) function FSUNLinSolInitialize_PCG(LS) &
+          bind(C,name='SUNLinSolInitialize_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_PCG
+     
+     integer(c_int) function FSUNLinSolSetATimes_PCG(LS, A_data, ATimes) &
+          bind(C,name='SUNLinSolSetATimes_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A_data
+       type(c_funptr), value :: ATimes
+     end function FSUNLinSolSetATimes_PCG
+
+     integer(c_int) function FSUNLinSolSetPreconditioner_PCG(LS,     &
+                                                             P_data, &
+                                                             Pset,   &
+                                                             Psol)   &
+          bind(C,name='SUNLinSolSetPreconditioner_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: P_data
+       type(c_funptr), value :: Pset
+       type(c_funptr), value :: Psol
+     end function FSUNLinSolSetPreconditioner_PCG
+
+     integer(c_int) function FSUNLinSolSetScalingVectors_PCG(LS, s1, nul) &
+          bind(C,name='SUNLinSolSetScalingVectors_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: s1
+       type(c_ptr),    value :: nul
+     end function FSUNLinSolSetScalingVectors_PCG
+
+     integer(c_int) function FSUNLinSolSetup_PCG(LS, nul) &
+          bind(C,name='SUNLinSolSetup_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: nul
+     end function FSUNLinSolSetup_PCG
+
+     integer(c_int) function FSUNLinSolSolve_PCG(LS, nul, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: nul
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_PCG
+
+     integer(c_int) function FSUNLinSolNumIters_PCG(LS) &
+          bind(C,name='SUNLinSolNumIters_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolNumIters_PCG
+
+     real(c_double) function FSUNLinSolResNorm_PCG(LS) &
+          bind(C,name='SUNLinSolResNorm_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResNorm_PCG
+     
+     type(c_ptr) function FSUNLinSolResid_PCG(LS) &
+          bind(C,name='SUNLinSolResid_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResid_PCG
+     
+     integer(c_long) function FSUNLinSolLastFlag_PCG(LS) &
+          bind(C,name='SUNLinSolLastFlag_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_PCG
+
+     integer(c_int) function FSUNLinSolSpace_PCG(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_PCG')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_PCG
+
+  end interface
+
+end module fsunlinsol_pcg_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1690d9cdb893e605c7f4cb28da73d0b04712bf1f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/CMakeLists.txt
@@ -0,0 +1,108 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the SPBCGS SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_SPBCGS\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsolspbcgs_SOURCES with the sources for the SUNLINSOLSPBCGS lib
+SET(sunlinsolspbcgs_SOURCES sunlinsol_spbcgs.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLSPBCGS library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  )
+
+# Add variable sunlinsolspbcgs_HEADERS with the exported SUNLINSOLSPBCGS header files
+SET(sunlinsolspbcgs_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_spbcgs.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLSPBCGS library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLSPBCGS library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolspbcgs_static STATIC ${sunlinsolspbcgs_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspbcgs_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolspbcgs CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolspbcgs_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLSPBCGS library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLSPBCGS library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolspbcgs_shared SHARED ${sunlinsolspbcgs_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolspbcgs_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspbcgs_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolspbcgs CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspbcgs_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolspbcgs_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLSPBCGS header files
+INSTALL(FILES ${sunlinsolspbcgs_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLSPBCGS library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolspbcgs_SOURCES fsunlinsol_spbcgs.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolspbcgs_static STATIC ${fsunlinsolspbcgs_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspbcgs_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolspbcgs CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolspbcgs_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolspbcgs_shared ${fsunlinsolspbcgs_SOURCES})
+
+    # fsunlinsolspbcgs depdens on fnvecserial and sunlinsolspbcgs
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolspbcgs_shared
+      sundials_fnvecserial_shared
+      sundials_sunlinsolspbcgs_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspbcgs_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolspbcgs CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspbcgs_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolspbcgs_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_SPBCGS module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35292f1e57b0c23e83b25a45ac29dae7df722bdc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 SPBCGS SUNLinearSolver object library
+
+set(sunlinsolspbcgs_SOURCES fsunlinsol_spbcgs.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolspbcgs_mod_static STATIC
+    ${sunlinsolspbcgs_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolspbcgs_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolspbcgs_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolspbcgs_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolspbcgs_mod_shared SHARED
+    ${sunlinsolspbcgs_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolspbcgs_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolspbcgs_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolspbcgs_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolspbcgs_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_SPBCGS F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/F90/fsunlinsol_spbcgs.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/F90/fsunlinsol_spbcgs.f90
new file mode 100644
index 0000000000000000000000000000000000000000..13d26183f567374f8c29623fc34c2ebca6429335
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spbcgs/F90/fsunlinsol_spbcgs.f90
@@ -0,0 +1,174 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS SPBCGS linear solver using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_spbcgs_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_SPBCGS(y, pretype, maxl) &
+          bind(C,name='SUNLinSol_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+       integer(c_int), value :: pretype
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPBCGS
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_SPBCGS(LS) &
+          bind(C,name='SUNLinSolFree_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_SPBCGS
+
+     ! =================================================================
+     ! Setters
+     ! =================================================================
+     
+     integer(c_int) function FSUNLinSol_SPBCGSSetPrecType(LS, pretype) &
+          bind(C,name='SUNLinSol_SPBCGSSetPrecType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: pretype
+     end function FSUNLinSol_SPBCGSSetPrecType
+    
+     integer(c_int) function FSUNLinSol_SPTFQMRSetMaxl(LS, maxl) &
+          bind(C,name='SUNLinSol_SPTFQMRSetMaxl')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPTFQMRSetMaxl
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_SPBCGS(LS) &
+          bind(C,name='SUNLinSolGetType_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_SPBCGS
+
+     integer(c_int) function FSUNLinSolInitialize_SPBCGS(LS) &
+          bind(C,name='SUNLinSolInitialize_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_SPBCGS
+     
+     integer(c_int) function FSUNLinSolSetATimes_SPBCGS(LS, A_data, ATimes) &
+          bind(C,name='SUNLinSolSetATimes_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A_data
+       type(c_funptr), value :: ATimes
+     end function FSUNLinSolSetATimes_SPBCGS
+
+     integer(c_int) function FSUNLinSolSetPreconditioner_SPBCGS(LS,     &
+                                                             P_data, &
+                                                             Pset,   &
+                                                             Psol)   &
+          bind(C,name='SUNLinSolSetPreconditioner_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: P_data
+       type(c_funptr), value :: Pset
+       type(c_funptr), value :: Psol
+     end function FSUNLinSolSetPreconditioner_SPBCGS
+
+     integer(c_int) function FSUNLinSolSetScalingVectors_SPBCGS(LS, s1, s2) &
+          bind(C,name='SUNLinSolSetScalingVectors_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: s1
+       type(c_ptr),    value :: s2
+     end function FSUNLinSolSetScalingVectors_SPBCGS
+
+     integer(c_int) function FSUNLinSolSetup_SPBCGS(LS, A) &
+          bind(C,name='SUNLinSolSetup_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FSUNLinSolSetup_SPBCGS
+
+     integer(c_int) function FSUNLinSolSolve_SPBCGS(LS, A, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_SPBCGS
+
+     integer(c_int) function FSUNLinSolNumIters_SPBCGS(LS) &
+          bind(C,name='SUNLinSolNumIters_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolNumIters_SPBCGS
+
+     real(c_double) function FSUNLinSolResNorm_SPBCGS(LS) &
+          bind(C,name='SUNLinSolResNorm_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResNorm_SPBCGS
+     
+     type(c_ptr) function FSUNLinSolResid_SPBCGS(LS) &
+          bind(C,name='SUNLinSolResid_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResid_SPBCGS
+     
+     integer(c_long) function FSUNLinSolLastFlag_SPBCGS(LS) &
+          bind(C,name='SUNLinSolLastFlag_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_SPBCGS
+
+     integer(c_int) function FSUNLinSolSpace_SPBCGS(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_SPBCGS')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_SPBCGS
+
+  end interface
+
+end module fsunlinsol_spbcgs_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7192ff4b0829bac5cbf093dce9a865bf567c6a1c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/CMakeLists.txt
@@ -0,0 +1,108 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the SPFGMR SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_SPFGMR\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsolspfgmr_SOURCES with the sources for the SUNLINSOLSPFGMR lib
+SET(sunlinsolspfgmr_SOURCES sunlinsol_spfgmr.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLSPFGMR library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  )
+
+# Add variable sunlinsolspfgmr_HEADERS with the exported SUNLINSOLSPFGMR header files
+SET(sunlinsolspfgmr_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_spfgmr.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLSPFGMR library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLSPFGMR library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolspfgmr_static STATIC ${sunlinsolspfgmr_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspfgmr_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolspfgmr CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolspfgmr_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLSPFGMR library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLSPFGMR library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolspfgmr_shared SHARED ${sunlinsolspfgmr_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolspfgmr_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspfgmr_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolspfgmr CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspfgmr_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolspfgmr_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLSPFGMR header files
+INSTALL(FILES ${sunlinsolspfgmr_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLSPFGMR library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolspfgmr_SOURCES fsunlinsol_spfgmr.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolspfgmr_static STATIC ${fsunlinsolspfgmr_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspfgmr_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolspfgmr CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolspfgmr_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolspfgmr_shared ${fsunlinsolspfgmr_SOURCES})
+
+    # fsunlinsolspfgmr depends on fnvecserial and sunlinsolspfgmr
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolspfgmr_shared
+      sundials_fnvecserial_shared
+      sundials_sunlinsolspfgmr_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspfgmr_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolspfgmr CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspfgmr_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolspfgmr_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_SPFGMR module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..398086c83c5e2289d2a37d82d1ad7128356bfb9c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ------------------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------
+# CMakeLists.txt file for the F2003 SPFGMR SUNLinearSolbver object library
+
+set(sunlinsolspfgmr_SOURCES fsunlinsol_spfgmr.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolspfgmr_mod_static STATIC
+    ${sunlinsolspfgmr_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolspfgmr_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolspfgmr_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolspfgmr_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolspfgmr_mod_shared SHARED
+    ${sunlinsolspfgmr_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolspfgmr_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolspfgmr_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolspfgmr_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolspfgmr_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_SPFGMR F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/F90/fsunlinsol_spfgmr.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/F90/fsunlinsol_spfgmr.f90
new file mode 100644
index 0000000000000000000000000000000000000000..80a9faaf19ec1f174016937393ff0479164e4489
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spfgmr/F90/fsunlinsol_spfgmr.f90
@@ -0,0 +1,182 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS SPGMR linear solver using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_spfgmr_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_SPFGMR(y, pretype, maxl) &
+          bind(C,name='SUNLinSol_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+       integer(c_int), value :: pretype
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPFGMR
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_SPFGMR(LS) &
+          bind(C,name='SUNLinSolFree_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_SPFGMR
+
+     ! =================================================================
+     ! Setters
+     ! =================================================================
+     
+     integer(c_int) function FSUNLinSol_SPFGMRSetPrecType(LS, pretype) &
+          bind(C,name='SUNLinSol_SPFGMRSetPrecType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: pretype
+     end function FSUNLinSol_SPFGMRSetPrecType
+    
+     integer(c_int) function FSUNLinSol_SPFGMRSetGSType(LS, gstype) &
+          bind(C,name='SUNLinSol_SPFGMRSetGSType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: gstype
+     end function FSUNLinSol_SPFGMRSetGSType
+
+     integer(c_int) function FSUNLinSol_SPFGMRSetMaxRestarts(LS, maxrs) &
+          bind(C,name='SUNLinSol_SPFGMRSetMaxRestarts')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: maxrs
+     end function FSUNLinSol_SPFGMRSetMaxRestarts
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_SPFGMR(LS) &
+          bind(C,name='SUNLinSolGetType_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_SPFGMR
+
+     integer(c_int) function FSUNLinSolInitialize_SPFGMR(LS) &
+          bind(C,name='SUNLinSolInitialize_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_SPFGMR
+     
+     integer(c_int) function FSUNLinSolSetATimes_SPFGMR(LS, A_data, ATimes) &
+          bind(C,name='SUNLinSolSetATimes_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A_data
+       type(c_funptr), value :: ATimes
+     end function FSUNLinSolSetATimes_SPFGMR
+
+     integer(c_int) function FSUNLinSolSetPreconditioner_SPFGMR(LS,     &
+                                                               P_data, &
+                                                               Pset,   &
+                                                               Psol)   &
+          bind(C,name='SUNLinSolSetPreconditioner_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: P_data
+       type(c_funptr), value :: Pset
+       type(c_funptr), value :: Psol
+     end function FSUNLinSolSetPreconditioner_SPFGMR
+
+     integer(c_int) function FSUNLinSolSetScalingVectors_SPFGMR(LS, s1, s2) &
+          bind(C,name='SUNLinSolSetScalingVectors_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: s1
+       type(c_ptr),    value :: s2
+     end function FSUNLinSolSetScalingVectors_SPFGMR
+
+     integer(c_int) function FSUNLinSolSetup_SPFGMR(LS, A) &
+          bind(C,name='SUNLinSolSetup_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FSUNLinSolSetup_SPFGMR
+
+     integer(c_int) function FSUNLinSolSolve_SPFGMR(LS, A, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_SPFGMR
+
+     integer(c_int) function FSUNLinSolNumIters_SPFGMR(LS) &
+          bind(C,name='SUNLinSolNumIters_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolNumIters_SPFGMR
+
+     real(c_double) function FSUNLinSolResNorm_SPFGMR(LS) &
+          bind(C,name='SUNLinSolResNorm_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResNorm_SPFGMR
+     
+     type(c_ptr) function FSUNLinSolResid_SPFGMR(LS) &
+          bind(C,name='SUNLinSolResid_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResid_SPFGMR
+     
+     integer(c_long) function FSUNLinSolLastFlag_SPFGMR(LS) &
+          bind(C,name='SUNLinSolLastFlag_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_SPFGMR
+
+     integer(c_int) function FSUNLinSolSpace_SPFGMR(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_SPFGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_SPFGMR
+
+  end interface
+
+end module fsunlinsol_spfgmr_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0693a503e63e1b85251acc0399de9d2053164f1c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/CMakeLists.txt
@@ -0,0 +1,108 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the SPGMR SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_SPGMR\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF()
+
+# Add variable sunlinsolspgmr_SOURCES with the sources for the SUNLINSOLSPGMR lib
+SET(sunlinsolspgmr_SOURCES sunlinsol_spgmr.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLSPGMR library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  )
+
+# Add variable sunlinsolspgmr_HEADERS with the exported SUNLINSOLSPGMR header files
+SET(sunlinsolspgmr_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_spgmr.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLSPGMR library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLSPGMR library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolspgmr_static STATIC ${sunlinsolspgmr_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspgmr_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolspgmr CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolspgmr_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLSPGMR library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLSPGMR library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolspgmr_shared SHARED ${sunlinsolspgmr_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolspgmr_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspgmr_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolspgmr CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolspgmr_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolspgmr_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLSPGMR header files
+INSTALL(FILES ${sunlinsolspgmr_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLSPGMR library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolspgmr_SOURCES fsunlinsol_spgmr.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolspgmr_static STATIC ${fsunlinsolspgmr_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspgmr_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolspgmr CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolspgmr_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolspgmr_shared ${fsunlinsolspgmr_SOURCES})
+
+    # fsunlinsolspgmr depends on fnvecserial and sunlinsolspgmr
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolspgmr_shared
+      sundials_fnvecserial_shared
+      sundials_sunlinsolspgmr_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspgmr_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolspgmr CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolspgmr_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolspgmr_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_SPGMR module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ba4d01c7b976e88a35473dc7edfc6ee32fa95898
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ------------------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------
+# CMakeLists.txt file for the F2003 SPGMR SUNLinearSolver object library
+
+set(sunlinsolspgmr_SOURCES fsunlinsol_spgmr.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolspgmr_mod_static STATIC
+    ${sunlinsolspgmr_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolspgmr_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolspgmr_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolspgmr_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolspgmr_mod_shared SHARED
+    ${sunlinsolspgmr_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolspgmr_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolspgmr_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolspgmr_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolspgmr_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_SPGMR F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/F90/fsunlinsol_spgmr.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/F90/fsunlinsol_spgmr.f90
new file mode 100644
index 0000000000000000000000000000000000000000..5859dd775d4bd1230c98fdba0b557cd43f0d4703
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/spgmr/F90/fsunlinsol_spgmr.f90
@@ -0,0 +1,182 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS SPGMR linear solver using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_spgmr_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_SPGMR(y, pretype, maxl) &
+          bind(C,name='SUNLinSol_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+       integer(c_int), value :: pretype
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPGMR
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_SPGMR(LS) &
+          bind(C,name='SUNLinSolFree_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_SPGMR
+
+     ! =================================================================
+     ! Setters
+     ! =================================================================
+     
+     integer(c_int) function FSUNLinSol_SPGMRSetPrecType(LS, pretype) &
+          bind(C,name='SUNLinSol_SPGMRSetPrecType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: pretype
+     end function FSUNLinSol_SPGMRSetPrecType
+    
+     integer(c_int) function FSUNLinSol_SPGMRSetGSType(LS, gstype) &
+          bind(C,name='SUNLinSol_SPGMRSetGSType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: gstype
+     end function FSUNLinSol_SPGMRSetGSType
+
+     integer(c_int) function FSUNLinSol_SPGMRSetMaxRestarts(LS, maxrs) &
+          bind(C,name='SUNLinSol_SPGMRSetMaxRestarts')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: maxrs
+     end function FSUNLinSol_SPGMRSetMaxRestarts
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_SPGMR(LS) &
+          bind(C,name='SUNLinSolGetType_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_SPGMR
+
+     integer(c_int) function FSUNLinSolInitialize_SPGMR(LS) &
+          bind(C,name='SUNLinSolInitialize_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_SPGMR
+     
+     integer(c_int) function FSUNLinSolSetATimes_SPGMR(LS, A_data, ATimes) &
+          bind(C,name='SUNLinSolSetATimes_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A_data
+       type(c_funptr), value :: ATimes
+     end function FSUNLinSolSetATimes_SPGMR
+
+     integer(c_int) function FSUNLinSolSetPreconditioner_SPGMR(LS,     &
+                                                               P_data, &
+                                                               Pset,   &
+                                                               Psol)   &
+          bind(C,name='SUNLinSolSetPreconditioner_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: P_data
+       type(c_funptr), value :: Pset
+       type(c_funptr), value :: Psol
+     end function FSUNLinSolSetPreconditioner_SPGMR
+
+     integer(c_int) function FSUNLinSolSetScalingVectors_SPGMR(LS, s1, s2) &
+          bind(C,name='SUNLinSolSetScalingVectors_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: s1
+       type(c_ptr),    value :: s2
+     end function FSUNLinSolSetScalingVectors_SPGMR
+
+     integer(c_int) function FSUNLinSolSetup_SPGMR(LS, A) &
+          bind(C,name='SUNLinSolSetup_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FSUNLinSolSetup_SPGMR
+
+     integer(c_int) function FSUNLinSolSolve_SPGMR(LS, A, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_SPGMR
+
+     integer(c_int) function FSUNLinSolNumIters_SPGMR(LS) &
+          bind(C,name='SUNLinSolNumIters_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolNumIters_SPGMR
+
+     real(c_double) function FSUNLinSolResNorm_SPGMR(LS) &
+          bind(C,name='SUNLinSolResNorm_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResNorm_SPGMR
+     
+     type(c_ptr) function FSUNLinSolResid_SPGMR(LS) &
+          bind(C,name='SUNLinSolResid_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResid_SPGMR
+     
+     integer(c_long) function FSUNLinSolLastFlag_SPGMR(LS) &
+          bind(C,name='SUNLinSolLastFlag_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_SPGMR
+
+     integer(c_int) function FSUNLinSolSpace_SPGMR(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_SPGMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_SPGMR
+
+  end interface
+
+end module fsunlinsol_spgmr_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c74a2f4bead658221597efd760e7c38647d27d0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/CMakeLists.txt
@@ -0,0 +1,107 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the SPTFQMR SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_SPTFQMR\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunlinsolsptfqmr_SOURCES with the sources for the SUNLINSOLSPTFQMR lib
+SET(sunlinsolsptfqmr_SOURCES sunlinsol_sptfqmr.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLSPTFQMR library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_iterative.c
+  )
+
+# Add variable sunlinsolsptfqmr_HEADERS with the exported SUNLINSOLSPTFQMR header files
+SET(sunlinsolsptfqmr_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_sptfqmr.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLSPTFQMR library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLSPTFQMR library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolsptfqmr_static STATIC ${sunlinsolsptfqmr_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolsptfqmr_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolsptfqmr CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolsptfqmr_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLSPTFQMR library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLSPTFQMR library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolsptfqmr_shared SHARED ${sunlinsolsptfqmr_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolsptfqmr_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolsptfqmr_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolsptfqmr CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolsptfqmr_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolsptfqmr_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLSPTFQMR header files
+INSTALL(FILES ${sunlinsolsptfqmr_HEADERS} DESTINATION include/sunlinsol)
+
+# If FCMIX is enabled, build and install the FSUNLINSOLSPTFQMR library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolsptfqmr_SOURCES fsunlinsol_sptfqmr.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolsptfqmr_static STATIC ${fsunlinsolsptfqmr_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolsptfqmr_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolsptfqmr CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolsptfqmr_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolsptfqmr_shared ${fsunlinsolsptfqmr_SOURCES})
+
+    # fsunlinsolsptfqmr depends on fnvecserial and sunlinsolsptfqmr
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolsptfqmr_shared
+      sundials_fnvecserial_shared
+      sundials_sunlinsolsptfqmr_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolsptfqmr_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolsptfqmr CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolsptfqmr_shared
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolsptfqmr_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_SPTFQMR module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b4326cd6f9a9c2eb0efe225997765803174883e4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ------------------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------
+# CMakeLists.txt file for the F2003 SPTFQMR SUNLinearSolver object library
+
+set(sunlinsolsptfqmr_SOURCES fsunlinsol_sptfqmr.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolsptfqmr_mod_static STATIC
+    ${sunlinsolsptfqmr_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolsptfqmr_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolsptfqmr_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunlinsolsptfqmr_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunlinsolsptfqmr_mod_shared SHARED
+    ${sunlinsolsptfqmr_SOURCES}
+  )
+  set_target_properties(sundials_fsunlinsolsptfqmr_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunlinsolsptfqmr_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunlinsolsptfqmr_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunlinsolsptfqmr_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNLINSOL_SPTFQMR F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/F90/fsunlinsol_sptfqmr.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/F90/fsunlinsol_sptfqmr.f90
new file mode 100644
index 0000000000000000000000000000000000000000..12fdf1dfe6714c426ee053fbf849c36b5b3c032d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/sptfqmr/F90/fsunlinsol_sptfqmr.f90
@@ -0,0 +1,174 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS SPTFQMR linear solver using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunlinsol_sptfqmr_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNLinSol_SPTFQMR(y, pretype, maxl) &
+          bind(C,name='SUNLinSol_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+       integer(c_int), value :: pretype
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPTFQMR
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNLinSolFree_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolFree_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end subroutine FSUNLinSolFree_SPTFQMR
+
+     ! =================================================================
+     ! Setters
+     ! =================================================================
+     
+     integer(c_int) function FSUNLinSol_SPTFQMRSetPrecType(LS, pretype) &
+          bind(C,name='SUNLinSol_SPTFQMRSetPrecType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: pretype
+     end function FSUNLinSol_SPTFQMRSetPrecType
+
+     integer(c_int) function FSUNLinSol_SPTFQMRSetMaxl(LS, maxl) &
+          bind(C,name='SUNLinSol_SPTFQMRSetMaxl')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       integer(c_int), value :: maxl
+     end function FSUNLinSol_SPTFQMRSetMaxl
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNLinSolGetType_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolGetType_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolGetType_SPTFQMR
+
+     integer(c_int) function FSUNLinSolInitialize_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolInitialize_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolInitialize_SPTFQMR
+     
+     integer(c_int) function FSUNLinSolSetATimes_SPTFQMR(LS, A_data, ATimes) &
+          bind(C,name='SUNLinSolSetATimes_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A_data
+       type(c_funptr), value :: ATimes
+     end function FSUNLinSolSetATimes_SPTFQMR
+
+     integer(c_int) function FSUNLinSolSetPreconditioner_SPTFQMR(LS,     &
+                                                               P_data, &
+                                                               Pset,   &
+                                                               Psol)   &
+          bind(C,name='SUNLinSolSetPreconditioner_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: P_data
+       type(c_funptr), value :: Pset
+       type(c_funptr), value :: Psol
+     end function FSUNLinSolSetPreconditioner_SPTFQMR
+
+     integer(c_int) function FSUNLinSolSetScalingVectors_SPTFQMR(LS, s1, s2) &
+          bind(C,name='SUNLinSolSetScalingVectors_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: s1
+       type(c_ptr),    value :: s2
+     end function FSUNLinSolSetScalingVectors_SPTFQMR
+
+     integer(c_int) function FSUNLinSolSetup_SPTFQMR(LS, A) &
+          bind(C,name='SUNLinSolSetup_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       type(c_ptr), value :: A
+     end function FSUNLinSolSetup_SPTFQMR
+
+     integer(c_int) function FSUNLinSolSolve_SPTFQMR(LS, A, x, b, tol) &
+          bind(C,name='SUNLinSolSolve_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: LS
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: x
+       type(c_ptr),    value :: b
+       real(c_double), value :: tol
+     end function FSUNLinSolSolve_SPTFQMR
+
+     integer(c_int) function FSUNLinSolNumIters_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolNumIters_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolNumIters_SPTFQMR
+
+     real(c_double) function FSUNLinSolResNorm_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolResNorm_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResNorm_SPTFQMR
+     
+     type(c_ptr) function FSUNLinSolResid_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolResid_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolResid_SPTFQMR
+     
+     integer(c_long) function FSUNLinSolLastFlag_SPTFQMR(LS) &
+          bind(C,name='SUNLinSolLastFlag_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+     end function FSUNLinSolLastFlag_SPTFQMR
+
+     integer(c_int) function FSUNLinSolSpace_SPTFQMR(LS, lenrwLS, leniwLS) &
+          bind(C,name='SUNLinSolSpace_SPTFQMR')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: LS
+       integer(c_long)    :: lenrwLS
+       integer(c_long)    :: leniwLS
+     end function FSUNLinSolSpace_SPTFQMR
+
+  end interface
+
+end module fsunlinsol_sptfqmr_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/superlumt/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/superlumt/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8c1cf2cb56d8899139cf976ebebd625330b2e2f9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunlinsol/superlumt/CMakeLists.txt
@@ -0,0 +1,112 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the superlumt SUNLinearSolver library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNLINSOL_SUPERLUMT\n\")")
+
+# Add variable sunlinsolsuperlumt_SOURCES with the sources for the SUNLINSOLSUPERLUMT lib
+SET(sunlinsolsuperlumt_SOURCES sunlinsol_superlumt.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNLINSOLSUPERLUMT library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_linearsolver.c
+  )
+
+# Add variable sunlinsolsuperlumt_HEADERS with the exported SUNLINSOLSUPERLUMT header files
+SET(sunlinsolsuperlumt_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunlinsol/sunlinsol_superlumt.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY 
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNLINSOLSUPERLUMT library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNLINSOLSUPERLUMT library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolsuperlumt_static STATIC ${sunlinsolsuperlumt_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunlinsolsuperlumt_static
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolsuperlumt CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunlinsolsuperlumt_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNLINSOLSUPERLUMT library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNLINSOLSUPERLUMT library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunlinsolsuperlumt_shared SHARED ${sunlinsolsuperlumt_SOURCES} ${shared_SOURCES})
+
+  # sunlinsolsuperlumt depends on sunmatrixsparse and SuperLU_MT
+  TARGET_LINK_LIBRARIES(sundials_sunlinsolsuperlumt_shared
+    sundials_sunmatrixsparse_shared
+    ${SUPERLUMT_LIBRARIES})
+  
+  # if a blas library is provided, assume SuperLU_MT depends on it
+  IF(BLAS_FOUND)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolsuperlumt_shared ${BLAS_LIBRARIES})
+  ENDIF()
+
+  # if a blas library was not provided but a lapack library was set, assume 
+  # SuperLU_MT depends depends on a blas library provided in LAPACK_LIBRARIES
+  IF((NOT BLAS_FOUND) AND LAPACK_FOUND)
+    TARGET_LINK_LIBRARIES(sundials_sunlinsolsuperlumt_shared ${LAPACK_LIBRARIES})
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunlinsolsuperlumt_shared
+    PROPERTIES OUTPUT_NAME sundials_sunlinsolsuperlumt CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunlinsolsuperlumt_shared
+    PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+  INSTALL(TARGETS sundials_sunlinsolsuperlumt_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNLINSOLSUPERLUMT header files
+INSTALL(FILES ${sunlinsolsuperlumt_HEADERS} DESTINATION include/sunlinsol)
+
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunlinsolsuperlumt_SOURCES fsunlinsol_superlumt.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolsuperlumt_static STATIC ${fsunlinsolsuperlumt_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolsuperlumt_static
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolsuperlumt CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunlinsolsuperlumt_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunlinsolsuperlumt_shared ${fsunlinsolsuperlumt_SOURCES})
+
+    # fsunlinsolsuperlumt dependes on fnvecserial, fsunmatrixsparse, sunlinsolsuperlumt
+    TARGET_LINK_LIBRARIES(sundials_fsunlinsolsuperlumt_shared
+      sundials_fnvecserial_shared
+      sundials_fsunmatrixsparse_shared
+      sundials_sunlinsolsuperlumt_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolsuperlumt_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunlinsolsuperlumt CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunlinsolsuperlumt_shared 
+      PROPERTIES VERSION ${sunlinsollib_VERSION} SOVERSION ${sunlinsollib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunlinsolsuperlumt_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNLINSOL_SUPERLUMT module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31c51213a795ec4f3e2c76c09677f1850fc3264b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/CMakeLists.txt
@@ -0,0 +1,21 @@
+# ------------------------------------------------------------------------------
+# Programmer(s): Cody J. Balos @ LLNL
+# ------------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------------
+# matrix level CMakeLists.txt for SUNDIALS
+# ------------------------------------------------------------------------------
+
+# Always add SUNDIALS provided matrix modules
+add_subdirectory(band)
+add_subdirectory(dense)
+add_subdirectory(sparse)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cc77429a4e31afcbe1924bb1fb5912d0d85a1db1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/CMakeLists.txt
@@ -0,0 +1,105 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the band SUNMatrix library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNMATRIX_BAND\n\")")
+
+# Add variable sunmatrixband_SOURCES with the sources for the SUNMATRIXBAND lib
+SET(sunmatrixband_SOURCES sunmatrix_band.c)
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNMATRIXBAND library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable sunmatrixband_HEADERS with the exported SUNMATRIXBAND header files
+SET(sunmatrixband_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunmatrix/sunmatrix_band.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNMATRIXBAND library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNMATRIXBAND library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunmatrixband_static STATIC ${sunmatrixband_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunmatrixband_static
+    PROPERTIES OUTPUT_NAME sundials_sunmatrixband CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunmatrixband_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNMATRIXBAND library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNMATRIXBAND library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunmatrixband_shared SHARED ${sunmatrixband_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunmatrixband_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunmatrixband_shared
+    PROPERTIES OUTPUT_NAME sundials_sunmatrixband CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunmatrixband_shared
+    PROPERTIES VERSION ${sunmatrixlib_VERSION} SOVERSION ${sunmatrixlib_SOVERSION})
+  INSTALL(TARGETS sundials_sunmatrixband_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNMATRIXBAND header files
+INSTALL(FILES ${sunmatrixband_HEADERS} DESTINATION include/sunmatrix)
+
+# If FCMIX is enabled, build and install the FSUNMATRIXBAND library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunmatrixband_SOURCES fsunmatrix_band.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunmatrixband_static STATIC ${fsunmatrixband_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixband_static
+      PROPERTIES OUTPUT_NAME sundials_fsunmatrixband CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunmatrixband_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunmatrixband_shared ${fsunmatrixband_SOURCES})
+
+    # fsunmatrixband depends on sunmatrixband
+    TARGET_LINK_LIBRARIES(sundials_fsunmatrixband_shared sundials_sunmatrixband_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixband_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunmatrixband CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixband_shared
+      PROPERTIES VERSION ${sunmatrixlib_VERSION} SOVERSION ${sunmatrixlib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunmatrixband_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNMATRIX_BAND module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..81c5ac603480ab4474a9ee5e413cf1b97b0a4d42
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 band SUNMatrix object library
+
+set(sunmatrixband_SOURCES fsunmatrix_band.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunmatrixband_mod_static STATIC
+    ${sunmatrixband_SOURCES}
+  )
+  set_target_properties(sundials_fsunmatrixband_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunmatrixband_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunmatrixband_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunmatrixband_mod_shared SHARED
+    ${sunmatrixband_SOURCES}
+  )
+  set_target_properties(sundials_fsunmatrixband_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunmatrixband_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunmatrixband_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunmatrixband_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNMATRIX_BAND F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/F90/fsunmatrix_band.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/F90/fsunmatrix_band.f90
new file mode 100644
index 0000000000000000000000000000000000000000..b96a71bb576a9b7169dc0bb3a26789ecb48e0d9b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/band/F90/fsunmatrix_band.f90
@@ -0,0 +1,222 @@
+! -----------------------------------------------------------------
+! Programmer(s): David J. Gardner @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS band matrix using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunmatrix_band_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNBandMatrix(N, mu, ml, smu) &
+          bind(C,name='SUNBandMatrix')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: N
+       integer(c_long), value :: mu
+       integer(c_long), value :: ml
+       integer(c_long), value :: smu
+     end function FSUNBandMatrix
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNMatDestroy_Band(A) &
+          bind(C,name='SUNMatDestroy_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end subroutine FSUNMatDestroy_Band
+
+     ! =================================================================
+     ! Other routines
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED SUNBandMatrix_Print
+     ! -----------------------------------------------------------------
+
+     integer(c_long) function FSUNBandMatrix_Rows(A) &
+          bind(C,name='SUNBandMatrix_Rows')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_Rows
+
+     integer(c_long) function FSUNBandMatrix_Columns(A) &
+          bind(C,name='SUNBandMatrix_Columns')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_Columns
+
+     integer(c_long) function FSUNBandMatrix_LowerBandwidth(A) &
+          bind(C,name='SUNBandMatrix_LowerBandwidth')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_LowerBandwidth
+
+     integer(c_long) function FSUNBandMatrix_UpperBandwidth(A) &
+          bind(C,name='SUNBandMatrix_UpperBandwidth')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_UpperBandwidth
+
+     integer(c_long) function FSUNBandMatrix_StoredUpperBandwidth(A) &
+          bind(C,name='SUNBandMatrix_StoredUpperBandwidth')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_StoredUpperBandwidth
+
+     integer(c_long) function FSUNBandMatrix_LDim(A) &
+          bind(C,name='SUNBandMatrix_LDim')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_LDim
+
+     type(c_ptr) function FSUNBandMatrix_Data(A) &
+          bind(C,name='SUNBandMatrix_Data')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNBandMatrix_Data
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED SUNBandMatrix_Cols
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FSUNBandMatrix_Column(A, j) &
+          bind(C,name='SUNBandMatrix_Column')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value     :: A
+       integer(c_long), value :: j
+     end function FSUNBandMatrix_Column
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNMatGetID_Band(A) &
+          bind(C,name='SUNMatGetID_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNMatGetID_Band
+
+     type(c_ptr) function FSUNMatClone_Band(A) &
+          bind(C,name='SUNMatClone_Band')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNMatClone_Band
+
+     integer(c_int) function FSUNMatZero_Band(A) &
+          bind(C,name='SUNMatZero_Band')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+     end function FSUNMatZero_Band
+
+     integer(c_int) function FSUNMatCopy_Band(A, B) &
+          bind(C,name='SUNMatCopy_Band')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       type(c_ptr), value :: B
+     end function FSUNMatCopy_Band
+
+     integer(c_int) function FSUNMatScaleAdd_Band(c, A, B) &
+          bind(C,name='SUNMatScaleAdd_Band')
+       use, intrinsic :: iso_c_binding
+       real(c_double), value :: c
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: B
+     end function FSUNMatScaleAdd_Band
+
+     integer(c_int) function FSUNMatScaleAddI_Band(c, A) &
+          bind(C,name='SUNMatScaleAddI_Band')
+       use, intrinsic :: iso_c_binding
+       real(c_double), value :: c
+       type(c_ptr),    value :: A
+     end function FSUNMatScaleAddI_Band
+
+     integer(c_int) function FSUNMatMatvec_Band(A, x, y) &
+          bind(C,name='SUNMatMatvec_Band')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+     end function FSUNMatMatvec_Band
+
+     integer(c_int) function FSUNMatSpace_Band(A, lenrw, leniw) &
+          bind(C,name='SUNMatSpace_Band')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       integer(c_long)    :: lenrw
+       integer(c_long)    :: leniw
+     end function FSUNMatSpace_Band
+
+  end interface
+
+contains
+
+  ! ================================================================
+  ! Helpful routines
+  ! ================================================================
+
+  ! ----------------------------------------------------------------
+  ! FSUNMatGetData_Band
+  !
+  ! Extracts data array from a SUNDIALS Band Matrix
+  ! ----------------------------------------------------------------
+
+  subroutine FSUNMatGetData_Band(A, f_array)
+
+    !======= Inclusions ===========
+    use, intrinsic :: iso_c_binding
+
+    !======= Declarations =========
+    implicit none
+
+    ! calling variables
+    type(c_ptr)             :: A
+    real(c_double), pointer :: f_array(:)
+
+    ! internal variables
+    type(c_ptr)     :: c_array
+    integer(c_long) :: ldim
+
+    !======= Internals ============
+    
+    ! get data pointer from N_Vector
+    c_array = FSUNBandMatrix_Data(A)
+
+    ! get length of the data array
+    ldim = FSUNBandMatrix_LDim(A)
+
+    ! convert 1D data array
+    call c_f_pointer(c_array, f_array, (/ldim/))
+
+  end subroutine FSUNMatGetData_Band
+
+end module fsunmatrix_band_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aecf7d92859a1b977b451a9ec028769570b5b968
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/CMakeLists.txt
@@ -0,0 +1,106 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+#              Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the dense SUNMatrix library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNMATRIX_DENSE\n\")")
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable sunmatrixdense_SOURCES with the sources for the SUNMATRIXDENSE lib
+SET(sunmatrixdense_SOURCES sunmatrix_dense.c)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNMATRIXDENSE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable sunmatrixdense_HEADERS with the exported SUNMATRIXDENSE header files
+SET(sunmatrixdense_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunmatrix/sunmatrix_dense.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNMATRIXDENSE library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNMATRIXDENSE library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunmatrixdense_static STATIC ${sunmatrixdense_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunmatrixdense_static
+    PROPERTIES OUTPUT_NAME sundials_sunmatrixdense CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunmatrixdense_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNMATRIXDENSE library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNMATRIXDENSE library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunmatrixdense_shared SHARED ${sunmatrixdense_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunmatrixdense_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunmatrixdense_shared
+    PROPERTIES OUTPUT_NAME sundials_sunmatrixdense CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunmatrixdense_shared
+    PROPERTIES VERSION ${sunmatrixlib_VERSION} SOVERSION ${sunmatrixlib_SOVERSION})
+  INSTALL(TARGETS sundials_sunmatrixdense_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNMATRIXDENSE header files
+INSTALL(FILES ${sunmatrixdense_HEADERS} DESTINATION include/sunmatrix)
+
+# If FCMIX is enabled, build and install the FSUNMATRIXDENSE library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunmatrixdense_SOURCES fsunmatrix_dense.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunmatrixdense_static STATIC ${fsunmatrixdense_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixdense_static
+      PROPERTIES OUTPUT_NAME sundials_fsunmatrixdense CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunmatrixdense_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunmatrixdense_shared ${fsunmatrixdense_SOURCES})
+
+    # fsunmatrixdense depends on sunmatrixdense
+    TARGET_LINK_LIBRARIES(sundials_fsunmatrixdense_shared sundials_sunmatrixdense_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixdense_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunmatrixdense CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixdense_shared
+      PROPERTIES VERSION ${sunmatrixlib_VERSION} SOVERSION ${sunmatrixlib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunmatrixdense_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNMATRIX_DENSE module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d405e77a68754264e3381391c2a869ec3fbb5c70
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 dense SUNMatrix object library
+
+set(sunmatrixdense_SOURCES fsunmatrix_dense.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunmatrixdense_mod_static STATIC
+    ${sunmatrixdense_SOURCES}
+  )
+  set_target_properties(sundials_fsunmatrixdense_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunmatrixdense_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunmatrixdense_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunmatrixdense_mod_shared SHARED
+    ${sunmatrixdense_SOURCES}
+  )
+  set_target_properties(sundials_fsunmatrixdense_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunmatrixdense_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunmatrixdense_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunmatrixdense_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNMATRIX_DENSE F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/F90/fsunmatrix_dense.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/F90/fsunmatrix_dense.f90
new file mode 100644
index 0000000000000000000000000000000000000000..eb9b593827028ae267fa8a495032f50ddd270835
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/dense/F90/fsunmatrix_dense.f90
@@ -0,0 +1,200 @@
+! -----------------------------------------------------------------
+! Programmer(s): David J. Gardner @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS dense matrix using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunmatrix_dense_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNDenseMatrix(M, N) &
+          bind(C,name='SUNDenseMatrix')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: M
+       integer(c_long), value :: N
+     end function FSUNDenseMatrix
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNMatDestroy_Dense(A) &
+          bind(C,name='SUNMatDestroy_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end subroutine FSUNMatDestroy_Dense
+
+     ! =================================================================
+     ! Other routines
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED SUNDenseMatrix_Print
+     ! -----------------------------------------------------------------
+
+     integer(c_long) function FSUNDenseMatrix_Rows(A) &
+          bind(C,name='SUNDenseMatrix_Rows')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNDenseMatrix_Rows
+
+     integer(c_long) function FSUNDenseMatrix_Columns(A) &
+          bind(C,name='SUNDenseMatrix_Columns')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNDenseMatrix_Columns
+
+     integer(c_long) function FSUNDenseMatrix_LData(A) &
+          bind(C,name='SUNDenseMatrix_LData')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNDenseMatrix_LData
+
+     type(c_ptr) function FSUNDenseMatrix_Data(A) &
+          bind(C,name='SUNDenseMatrix_Data')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNDenseMatrix_Data
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED SUNDenseMatrix_Cols
+     ! -----------------------------------------------------------------
+
+     type(c_ptr) function FSUNDenseMatrix_Column(A, j) &
+          bind(C,name='SUNDenseMatrix_Column')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value     :: A
+       integer(c_long), value :: j
+     end function FSUNDenseMatrix_Column
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNMatGetID_Dense(A) &
+          bind(C,name='SUNMatGetID_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNMatGetID_Dense
+
+     type(c_ptr) function FSUNMatClone_Dense(A) &
+          bind(C,name='SUNMatClone_Dense')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNMatClone_Dense
+
+     integer(c_int) function FSUNMatZero_Dense(A) &
+          bind(C,name='SUNMatZero_Dense')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+     end function FSUNMatZero_Dense
+
+     integer(c_int) function FSUNMatCopy_Dense(A, B) &
+          bind(C,name='SUNMatCopy_Dense')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       type(c_ptr), value :: B
+     end function FSUNMatCopy_Dense
+
+     integer(c_int) function FSUNMatScaleAdd_Dense(c, A, B) &
+          bind(C,name='SUNMatScaleAdd_Dense')
+       use, intrinsic :: iso_c_binding
+       real(c_double), value :: c
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: B
+     end function FSUNMatScaleAdd_Dense
+
+     integer(c_int) function FSUNMatScaleAddI_Dense(c, A) &
+          bind(C,name='SUNMatScaleAddI_Dense')
+       use, intrinsic :: iso_c_binding
+       real(c_double), value :: c
+       type(c_ptr),    value :: A
+     end function FSUNMatScaleAddI_Dense
+
+     integer(c_int) function FSUNMatMatvec_Dense(A, x, y) &
+          bind(C,name='SUNMatMatvec_Dense')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+     end function FSUNMatMatvec_Dense
+
+     integer(c_int) function FSUNMatSpace_Dense(A, lenrw, leniw) &
+          bind(C,name='SUNMatSpace_Dense')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       integer(c_long)    :: lenrw
+       integer(c_long)    :: leniw
+     end function FSUNMatSpace_Dense
+
+  end interface
+
+contains
+
+  ! ================================================================
+  ! Helpful routines
+  ! ================================================================
+
+  ! ----------------------------------------------------------------
+  ! FSUNMatGetData_Dense
+  !
+  ! Extracts data array from a SUNDIALS Dense Matrix
+  ! ----------------------------------------------------------------
+
+  subroutine FSUNMatGetData_Dense(A, f_array)
+
+    !======= Inclusions ===========
+    use, intrinsic :: iso_c_binding
+
+    !======= Declarations =========
+    implicit none
+
+    ! calling variables
+    type(c_ptr)             :: A
+    real(c_double), pointer :: f_array(:,:)
+
+    ! internal variables
+    type(c_ptr)     :: c_array
+    integer(c_long) :: M, N
+
+    !======= Internals ============
+
+    ! get data pointer from N_Vector
+    c_array = FSUNDenseMatrix_Data(A)
+
+    ! get matrix size
+    M = FSUNDenseMatrix_Rows(A)
+    N = FSUNDenseMatrix_Columns(A)
+    
+    ! convert and reshape 1D data array
+    call c_f_pointer(c_array, f_array, (/M,N/))
+
+  end subroutine FSUNMatGetData_Dense
+
+end module fsunmatrix_dense_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..292cae79c8effa37c870974b3501d68d630996fc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/CMakeLists.txt
@@ -0,0 +1,105 @@
+# ---------------------------------------------------------------
+# Programmer:  Daniel R. Reynolds @ SMU
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the sparse SUNMatrix library
+
+INSTALL(CODE "MESSAGE(\"\nInstall SUNMATRIX_SPARSE\n\")")
+
+# Add variable sunmatrixsparse_SOURCES with the sources for the SUNMATRIXSPARSE lib
+SET(sunmatrixsparse_SOURCES sunmatrix_sparse.c)
+
+# Add F90 module if F2003 interface is enabled
+IF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  ADD_SUBDIRECTORY(F90)
+ENDIF(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable shared_SOURCES with the common SUNDIALS sources which will
+# also be included in the SUNMATRIXSPARSE library
+SET(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_matrix.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  )
+
+# Add variable sunmatrixsparse_HEADERS with the exported SUNMATRIXSPARSE header files
+SET(sunmatrixsparse_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunmatrix/sunmatrix_sparse.h
+  )
+
+# Add source directory to include directories
+INCLUDE_DIRECTORIES(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+ADD_DEFINITIONS(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the SUNMATRIXSPARSE library
+#  - Set the library name and make sure it is not deleted
+#  - Install the SUNMATRIXSPARSE library
+IF(BUILD_STATIC_LIBS)
+  ADD_LIBRARY(sundials_sunmatrixsparse_static STATIC ${sunmatrixsparse_SOURCES} ${shared_SOURCES})
+  SET_TARGET_PROPERTIES(sundials_sunmatrixsparse_static
+    PROPERTIES OUTPUT_NAME sundials_sunmatrixsparse CLEAN_DIRECT_OUTPUT 1)
+  INSTALL(TARGETS sundials_sunmatrixsparse_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_STATIC_LIBS)
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the SUNMATRIXSPARSE library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the SUNMATRIXSPARSE library
+IF(BUILD_SHARED_LIBS)
+  ADD_LIBRARY(sundials_sunmatrixsparse_shared SHARED ${sunmatrixsparse_SOURCES} ${shared_SOURCES})
+
+  IF(UNIX)
+    TARGET_LINK_LIBRARIES(sundials_sunmatrixsparse_shared m)
+  ENDIF()
+
+  SET_TARGET_PROPERTIES(sundials_sunmatrixsparse_shared
+    PROPERTIES OUTPUT_NAME sundials_sunmatrixsparse CLEAN_DIRECT_OUTPUT 1)
+  SET_TARGET_PROPERTIES(sundials_sunmatrixsparse_shared
+    PROPERTIES VERSION ${sunmatrixlib_VERSION} SOVERSION ${sunmatrixlib_SOVERSION})
+  INSTALL(TARGETS sundials_sunmatrixsparse_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ENDIF(BUILD_SHARED_LIBS)
+
+# Install the SUNMATRIXSPARSE header files
+INSTALL(FILES ${sunmatrixsparse_HEADERS} DESTINATION include/sunmatrix)
+
+# If FCMIX is enabled, build and install the FSUNMATRIXSPARSE library
+IF(F77_INTERFACE_ENABLE AND F77_FOUND)
+  SET(fsunmatrixsparse_SOURCES fsunmatrix_sparse.c)
+
+  IF(BUILD_STATIC_LIBS)
+    ADD_LIBRARY(sundials_fsunmatrixsparse_static STATIC ${fsunmatrixsparse_SOURCES})
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixsparse_static
+      PROPERTIES OUTPUT_NAME sundials_fsunmatrixsparse CLEAN_DIRECT_OUTPUT 1)
+    INSTALL(TARGETS sundials_fsunmatrixsparse_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_STATIC_LIBS)
+
+  IF(BUILD_SHARED_LIBS)
+    ADD_LIBRARY(sundials_fsunmatrixsparse_shared ${fsunmatrixsparse_SOURCES})
+
+    # fsunmatrixsparse depends on sunmatrixsparse
+    TARGET_LINK_LIBRARIES(sundials_fsunmatrixsparse_shared sundials_sunmatrixsparse_shared)
+
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixsparse_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunmatrixsparse CLEAN_DIRECT_OUTPUT 1)
+    SET_TARGET_PROPERTIES(sundials_fsunmatrixsparse_shared
+      PROPERTIES VERSION ${sunmatrixlib_VERSION} SOVERSION ${sunmatrixlib_SOVERSION})
+    INSTALL(TARGETS sundials_fsunmatrixsparse_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  ENDIF(BUILD_SHARED_LIBS)
+
+ENDIF(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+#
+MESSAGE(STATUS "Added SUNMATRIX_SPARSE module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f7c2301769861f64603324ec96f10f80c92483e8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/F90/CMakeLists.txt
@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 sparse SUNMatrix object library
+
+set(sunmatrixsparse_SOURCES fsunmatrix_sparse.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunmatrixsparse_mod_static STATIC
+    ${sunmatrixsparse_SOURCES}
+  )
+  set_target_properties(sundials_fsunmatrixsparse_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunmatrixsparse_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunmatrixsparse_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunmatrixsparse_mod_shared SHARED
+    ${sunmatrixsparse_SOURCES}
+  )
+  set_target_properties(sundials_fsunmatrixsparse_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunmatrixsparse_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunmatrixsparse_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunmatrixsparse_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNMATRIX_SPARSE F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/F90/fsunmatrix_sparse.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/F90/fsunmatrix_sparse.f90
new file mode 100644
index 0000000000000000000000000000000000000000..cb162716542e9642b48d8e5864cc18d0cfdc6e2f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunmatrix/sparse/F90/fsunmatrix_sparse.f90
@@ -0,0 +1,266 @@
+! -----------------------------------------------------------------
+! Programmer(s): David J. Gardner @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS sparse matrix using the ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunmatrix_sparse_mod
+
+  use, intrinsic :: iso_c_binding, only : c_int
+
+  integer(c_int), parameter :: CSC_MAT = 0
+  integer(c_int), parameter :: CSR_MAT = 1
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNSparseMatrix(M, N, NNZ, sparsetype) &
+          bind(C,name='SUNSparseMatrix')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_long), value :: M
+       integer(c_long), value :: N
+       integer(c_long), value :: NNZ
+       integer(c_int),  value :: sparsetype
+     end function FSUNSparseMatrix
+
+     type(c_ptr) function FSUNSparseFromDenseMatrix(A, droptol, sparsetype) &
+          bind(C,name='SUNSparseFromDenseMatrix')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value    :: A
+       real(c_double), value :: droptol
+       integer(c_int), value :: sparsetype
+     end function FSUNSparseFromDenseMatrix
+
+     type(c_ptr) function FSUNSparseFromBandMatrix(A, droptol, sparsetype) &
+          bind(C,name='SUNSparseFromBandMatrix')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value    :: A
+       real(c_double), value :: droptol
+       integer(c_int), value :: sparsetype
+     end function FSUNSparseFromBandMatrix
+
+     integer(c_int) function FSUNSparseMatrix_Realloc(A) &
+          bind(C,name='SUNSparseMatrix_Realloc')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_Realloc
+
+     integer(c_int) function FSUNSparseMatrix_Reallocate(A, NNZ) &
+          bind(C,name='SUNSparseMatrix_Reallocate')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value     :: A
+       integer(c_long), value :: NNZ
+     end function FSUNSparseMatrix_Reallocate
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     subroutine FSUNMatDestroy_Sparse(A) &
+          bind(C,name='SUNMatDestroy_Sparse')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end subroutine FSUNMatDestroy_Sparse
+
+     ! =================================================================
+     ! Other routines
+     ! =================================================================
+
+     ! -----------------------------------------------------------------
+     ! NOT INTERFACED SUNSparseMatrix_Print
+     ! -----------------------------------------------------------------
+
+     integer(c_long) function FSUNSparseMatrix_Rows(A) &
+          bind(C,name='SUNSparseMatrix_Rows')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_Rows
+
+     integer(c_long) function FSUNSparseMatrix_Columns(A) &
+          bind(C,name='SUNSparseMatrix_Columns')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_Columns
+
+     integer(c_long) function FSUNSparseMatrix_NNZ(A) &
+          bind(C,name='SUNSparseMatrix_NNZ')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_NNZ
+
+     integer(c_long) function FSUNSparseMatrix_NP(A) &
+          bind(C,name='SUNSparseMatrix_NP')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_NP
+
+     integer(c_int) function FSUNSparseMatrix_SparseType(A) &
+          bind(C,name='SUNSparseMatrix_SparseType')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_SparseType
+
+     type(c_ptr) function FSUNSparseMatrix_Data(A) &
+          bind(C,name='SUNSparseMatrix_Data')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_Data
+
+     type(c_ptr) function FSUNSparseMatrix_IndexValues(A) &
+          bind(C,name='SUNSparseMatrix_IndexValues')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_IndexValues
+
+     type(c_ptr) function FSUNSparseMatrix_IndexPointers(A) &
+          bind(C,name='SUNSparseMatrix_IndexPointers')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNSparseMatrix_IndexPointers
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNMatGetID_Sparse(A) &
+          bind(C,name='SUNMatGetID_Sparse')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNMatGetID_Sparse
+
+     type(c_ptr) function FSUNMatClone_Sparse(A) &
+          bind(C,name='SUNMatClone_Sparse')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: A
+     end function FSUNMatClone_Sparse
+
+     integer(c_int) function FSUNMatZero_Sparse(A) &
+          bind(C,name='SUNMatZero_Sparse')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+     end function FSUNMatZero_Sparse
+
+     integer(c_int) function FSUNMatCopy_Sparse(A, B) &
+          bind(C,name='SUNMatCopy_Sparse')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       type(c_ptr), value :: B
+     end function FSUNMatCopy_Sparse
+
+     integer(c_int) function FSUNMatScaleAdd_Sparse(c, A, B) &
+          bind(C,name='SUNMatScaleAdd_Sparse')
+       use, intrinsic :: iso_c_binding
+       real(c_double), value :: c
+       type(c_ptr),    value :: A
+       type(c_ptr),    value :: B
+     end function FSUNMatScaleAdd_Sparse
+
+     integer(c_int) function FSUNMatScaleAddI_Sparse(c, A) &
+          bind(C,name='SUNMatScaleAddI_Sparse')
+       use, intrinsic :: iso_c_binding
+       real(c_double), value :: c
+       type(c_ptr),    value :: A
+     end function FSUNMatScaleAddI_Sparse
+
+     integer(c_int) function FSUNMatMatvec_Sparse(A, x, y) &
+          bind(C,name='SUNMatMatvec_Sparse')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       type(c_ptr), value :: x
+       type(c_ptr), value :: y
+     end function FSUNMatMatvec_Sparse
+
+     integer(c_int) function FSUNMatSpace_Sparse(A, lenrw, leniw) &
+          bind(C,name='SUNMatSpace_Sparse')
+       use, intrinsic :: iso_c_binding
+       type(c_ptr), value :: A
+       integer(c_long)    :: lenrw
+       integer(c_long)    :: leniw
+     end function FSUNMatSpace_Sparse
+
+  end interface
+
+contains
+
+  ! ================================================================
+  ! Helpful routines
+  ! ================================================================
+
+  ! ----------------------------------------------------------------
+  ! FSUNMatGetData_Sparse
+  !
+  ! Extracts data array from a SUNDIALS Sparse Matrix
+  ! ----------------------------------------------------------------
+
+  subroutine FSUNMatGetData_Sparse(A, f_data, f_idxval, f_idxptr)
+
+    !======= Inclusions ===========
+    use, intrinsic :: iso_c_binding
+
+    !======= Declarations =========
+    implicit none
+
+    ! calling variables
+    type(c_ptr)              :: A
+    real(c_double),  pointer :: f_data(:)
+    integer(c_long), pointer :: f_idxval(:)
+    integer(c_long), pointer :: f_idxptr(:)
+
+    ! internal variables
+    type(c_ptr) :: c_data
+    type(c_ptr) :: c_idxval
+    type(c_ptr) :: c_idxptr
+
+    integer(c_long) :: NNZ
+    integer(c_long) :: NP
+
+    !======= Internals ============
+
+    ! get data pointer from N_Vector
+    c_data   = FSUNSparseMatrix_Data(A)
+    c_idxval = FSUNSparseMatrix_IndexValues(A)
+    c_idxptr = FSUNSparseMatrix_IndexPointers(A)
+
+    ! get matrix size
+    NNZ = FSUNSparseMatrix_NNZ(A)
+    NP  = FSUNSparseMatrix_NP(A)
+
+    ! convert and reshape 1D data array
+    call c_f_pointer(c_data,   f_data,   (/NNZ/))
+    call c_f_pointer(c_idxval, f_idxval, (/NNZ/))
+    call c_f_pointer(c_idxptr, f_idxptr, (/NP+1/))
+
+  end subroutine FSUNMatGetData_Sparse
+
+end module fsunmatrix_sparse_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..556665a76fbdc9a9619309b6c42cfa2608dbe106
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/CMakeLists.txt
@@ -0,0 +1,19 @@
+# ------------------------------------------------------------------------------
+# Programmer(s): David J. Gardner @ LLNL
+# ------------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------------
+# nonlinear solver level CMakeLists.txt for SUNDIALS
+# ------------------------------------------------------------------------------
+
+# Always add SUNDIALS provided nonlinear solver modules
+add_subdirectory(newton)
+add_subdirectory(fixedpoint)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..df8022e83c8af12649765a7f17b05619def19e48
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/CMakeLists.txt
@@ -0,0 +1,108 @@
+# ------------------------------------------------------------------------------
+# Programmer(s): Daniel R. Reynolds @ SMU
+# ------------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------------
+# CMakeLists.txt file for the fixed-point SUNNonlinearSolver library
+# ------------------------------------------------------------------------------
+
+install(CODE "MESSAGE(\"\nInstall SUNNONLINSOL_FIXEDPOINT\n\")")
+
+# Add F90 module if F2003 interface is enabled
+if(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  add_subdirectory(F90)
+endif(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable with the sources for the library
+set(lib_SOURCES sunnonlinsol_fixedpoint.c)
+
+# Add variable with the common SUNDIALS sources to be included in the library
+set(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  )
+
+# Add variable with the exported header files
+set(lib_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunnonlinsol/sunnonlinsol_fixedpoint.h
+  )
+
+# Add source directory to include directories
+include_directories(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+add_definitions(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the library
+#  - Set the library name and make sure it is not deleted
+#  - Install the library
+if(BUILD_STATIC_LIBS)
+  add_library(sundials_sunnonlinsolfixedpoint_static STATIC ${lib_SOURCES} ${shared_SOURCES})
+  set_target_properties(sundials_sunnonlinsolfixedpoint_static
+    PROPERTIES OUTPUT_NAME sundials_sunnonlinsolfixedpoint CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_sunnonlinsolfixedpoint_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the library
+if(BUILD_SHARED_LIBS)
+  add_library(sundials_sunnonlinsolfixedpoint_shared SHARED ${lib_SOURCES} ${shared_SOURCES})
+
+  if(UNIX)
+    target_link_libraries(sundials_sunnonlinsolfixedpoint_shared m)
+  endif()
+
+  set_target_properties(sundials_sunnonlinsolfixedpoint_shared
+    PROPERTIES OUTPUT_NAME sundials_sunnonlinsolfixedpoint CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_sunnonlinsolfixedpoint_shared
+    PROPERTIES VERSION ${sunnonlinsollib_VERSION} SOVERSION ${sunnonlinsollib_SOVERSION})
+  install(TARGETS sundials_sunnonlinsolfixedpoint_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+# Install the header files
+INSTALL(FILES ${lib_HEADERS} DESTINATION include/sunnonlinsol)
+
+# If FCMIX is enabled, build and install the F library
+if(F77_INTERFACE_ENABLE AND F77_FOUND)
+  set(flib_SOURCES fsunnonlinsol_fixedpoint.c)
+
+  if(BUILD_STATIC_LIBS)
+    add_library(sundials_fsunnonlinsolfixedpoint_static STATIC ${flib_SOURCES})
+    set_target_properties(sundials_fsunnonlinsolfixedpoint_static
+      PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolfixedpoint CLEAN_DIRECT_OUTPUT 1)
+    install(TARGETS sundials_fsunnonlinsolfixedpoint_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  endif()
+
+  if(BUILD_SHARED_LIBS)
+    add_library(sundials_fsunnonlinsolfixedpoint_shared ${flib_SOURCES})
+
+    # depends on fnvecserial and sunnonlinsolfixedpoint
+    target_link_libraries(sundials_fsunnonlinsolfixedpoint_shared
+      sundials_fnvecserial_shared
+      sundials_sunnonlinsolfixedpoint_shared)
+
+    set_target_properties(sundials_fsunnonlinsolfixedpoint_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolfixedpoint CLEAN_DIRECT_OUTPUT 1)
+    set_target_properties(sundials_fsunnonlinsolfixedpoint_shared
+      PROPERTIES VERSION ${sunnonlinsollib_VERSION} SOVERSION ${sunnonlinsollib_SOVERSION})
+    install(TARGETS sundials_fsunnonlinsolfixedpoint_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  endif()
+
+endif()
+
+#
+message(STATUS "Added SUNNONLINSOL_FIXEDPOINT module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a8416ffd81514177f5d15ba940a1e94b242d237
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/F90/CMakeLists.txt
@@ -0,0 +1,40 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 fixed-point SUNNonlinearSolver
+# object library
+# ---------------------------------------------------------------
+
+set(sunnonlinsolfixedpoint_SOURCES fsunnonlinsol_fixedpoint.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunnonlinsolfixedpoint_mod_static STATIC
+    ${sunnonlinsolfixedpoint_SOURCES}
+  )
+  set_target_properties(sundials_fsunnonlinsolfixedpoint_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolfixedpoint_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunnonlinsolfixedpoint_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunnonlinsolfixedpoint_mod_shared SHARED
+    ${sunnonlinsolfixedpoint_SOURCES}
+  )
+  set_target_properties(sundials_fsunnonlinsolfixedpoint_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolfixedpoint_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunnonlinsolfixedpoint_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunnonlinsolfixedpoint_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNNONLINSOL_FIXEDPOINT F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/F90/fsunnonlinsol_fixedpoint.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/F90/fsunnonlinsol_fixedpoint.f90
new file mode 100644
index 0000000000000000000000000000000000000000..4eae2a857c09daf7b9efe32568fad44c834e9893
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/fixedpoint/F90/fsunnonlinsol_fixedpoint.f90
@@ -0,0 +1,146 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS fixed-point nonlinear solver using the ISO_C_BINDING
+! module.
+! -----------------------------------------------------------------
+
+module fsunnonlinsol_fixedpoint_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNNonlinSol_FixedPoint(y, m) &
+         bind(C,name='SUNNonlinSol_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+       integer(c_int), value :: m
+     end function FSUNNonlinSol_FixedPoint
+
+     type(c_ptr) function FSUNNonlinSol_FixedPointSens(cnt, y, m) &
+         bind(C,name='SUNNonlinSol_FixedPointSens')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_int), value :: cnt
+       type(c_ptr),    value :: y
+       integer(c_int), value :: m
+     end function FSUNNonlinSol_FixedPointSens
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolFree_FixedPoint(NLS) &
+         bind(C,name='SUNNonlinSolFree_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: NLS
+     end function FSUNNonlinSolFree_FixedPoint
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolGetType_FixedPoint(NLS) &
+         bind(C,name='SUNNonlinSolGetType_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: NLS
+     end function FSUNNonlinSolGetType_FixedPoint
+
+     integer(c_int) function FSUNNonlinSolInitialize_FixedPoint(NLS) &
+         bind(C,name='SUNNonlinSolInitialize_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: NLS
+     end function FSUNNonlinSolInitialize_FixedPoint
+
+     integer(c_int) function FSUNNonlinSolSolve_FixedPoint(NLS, y0, y, w, tol, &
+                                                           callSetup, mem) &
+         bind(C,name='SUNNonlinSolSolve_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_ptr),    value :: y0
+       type(c_ptr),    value :: y
+       type(c_ptr),    value :: w
+       real(c_double), value :: tol
+       integer(c_int), value :: callSetup
+       type(c_ptr),    value :: mem
+     end function FSUNNonlinSolSolve_FixedPoint
+    
+    ! =================================================================
+    ! Set functions
+    ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolSetSysFn_FixedPoint(NLS, SysFn) &
+         bind(C,name='SUNNonlinSolSetSysFn_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_funptr), value :: SysFn
+     end function FSUNNonlinSolSetSysFn_FixedPoint
+
+     integer(c_int) function FSUNNonlinSolSetConvTestFn_FixedPoint(NLS, CTestFN) &
+         bind(C,name='SUNNonlinSolSetConvTestFn_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_funptr), value :: CTestFN
+     end function FSUNNonlinSolSetConvTestFn_FixedPoint
+
+     integer(c_int) function FSUNNonlinSolSetMaxIters_FixedPoint(NLS, maxiters) &
+         bind(C,name='SUNNonlinSolSetMaxIters_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       integer(c_int), value :: maxiters
+     end function FSUNNonlinSolSetMaxIters_FixedPoint
+ 
+    ! =================================================================
+    ! Get functions
+    ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolGetNumIters_FixedPoint(NLS, niters) &
+         bind(C,name='SUNNonlinSolGetNumIters_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       integer(c_long)       :: niters
+     end function FSUNNonlinSolGetNumIters_FixedPoint
+
+     integer(c_int) function FSUNNonlinSolGetCurIter_FixedPoint(NLS, iter) &
+         bind(C,name='SUNNonlinSolGetCurIter_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),   value :: NLS
+       integer(c_int)       :: iter
+     end function FSUNNonlinSolGetCurIter_FixedPoint
+     
+     integer(c_int) function FSUNNonlinSolGetSysFn_FixedPoint(NLS, SysFn) &
+         bind(C,name='SUNNonlinSolGetSysFn_FixedPoint')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),   value :: NLS
+       type(c_funptr)       :: SysFn
+     end function FSUNNonlinSolGetSysFn_FixedPoint
+
+   end interface
+
+end module fsunnonlinsol_fixedpoint_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7f942b91d92a4b56c513bf0f68cd658accb5fae9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/CMakeLists.txt
@@ -0,0 +1,109 @@
+# ------------------------------------------------------------------------------
+# Programmer(s): David J. Gardner @ LLNL
+# ------------------------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ------------------------------------------------------------------------------
+# CMakeLists.txt file for the Newton SUNNonlinearSolver library
+# ------------------------------------------------------------------------------
+
+install(CODE "MESSAGE(\"\nInstall SUNNONLINSOL_NEWTON\n\")")
+
+# Add F90 module if F2003 interface is enabled
+if(F90_FOUND AND F2003_INTERFACE_ENABLE)
+  add_subdirectory(F90)
+endif(F90_FOUND AND F2003_INTERFACE_ENABLE)
+
+# Add variable with the sources for the library
+set(lib_SOURCES sunnonlinsol_newton.c)
+
+# Add variable with the common SUNDIALS sources to be included in the library
+set(shared_SOURCES
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_math.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nvector_senswrapper.c
+  ${sundials_SOURCE_DIR}/src/sundials/sundials_nonlinearsolver.c
+  )
+
+# Add variable with the exported header files
+set(lib_HEADERS
+  ${sundials_SOURCE_DIR}/include/sunnonlinsol/sunnonlinsol_newton.h
+  )
+
+# Add source directory to include directories
+include_directories(.)
+
+# Define C preprocessor flag -DBUILD_SUNDIALS_LIBRARY
+add_definitions(-DBUILD_SUNDIALS_LIBRARY)
+
+# Rules for building and installing the static library:
+#  - Add the build target for the library
+#  - Set the library name and make sure it is not deleted
+#  - Install the library
+if(BUILD_STATIC_LIBS)
+  add_library(sundials_sunnonlinsolnewton_static STATIC ${lib_SOURCES} ${shared_SOURCES})
+  set_target_properties(sundials_sunnonlinsolnewton_static
+    PROPERTIES OUTPUT_NAME sundials_sunnonlinsolnewton CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_sunnonlinsolnewton_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+# Rules for building and installing the shared library:
+#  - Add the build target for the library
+#  - Set the library name and make sure it is not deleted
+#  - Set VERSION and SOVERSION for shared libraries
+#  - Install the library
+if(BUILD_SHARED_LIBS)
+  add_library(sundials_sunnonlinsolnewton_shared SHARED ${lib_SOURCES} ${shared_SOURCES})
+
+  if(UNIX)
+    target_link_libraries(sundials_sunnonlinsolnewton_shared m)
+  endif()
+
+  set_target_properties(sundials_sunnonlinsolnewton_shared
+    PROPERTIES OUTPUT_NAME sundials_sunnonlinsolnewton CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_sunnonlinsolnewton_shared
+    PROPERTIES VERSION ${sunnonlinsollib_VERSION} SOVERSION ${sunnonlinsollib_SOVERSION})
+  install(TARGETS sundials_sunnonlinsolnewton_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+# Install the header files
+INSTALL(FILES ${lib_HEADERS} DESTINATION include/sunnonlinsol)
+
+# If FCMIX is enabled, build and install the F library
+if(F77_INTERFACE_ENABLE AND F77_FOUND)
+
+  set(flib_SOURCES fsunnonlinsol_newton.c)
+
+  if(BUILD_STATIC_LIBS)
+    add_library(sundials_fsunnonlinsolnewton_static STATIC ${flib_SOURCES})
+    set_target_properties(sundials_fsunnonlinsolnewton_static
+      PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolnewton CLEAN_DIRECT_OUTPUT 1)
+    install(TARGETS sundials_fsunnonlinsolnewton_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  endif()
+
+  if(BUILD_SHARED_LIBS)
+    add_library(sundials_fsunnonlinsolnewton_shared ${flib_SOURCES})
+
+    # depends on fnvecserial and sunnonlinsolnewton
+    target_link_libraries(sundials_fsunnonlinsolnewton_shared
+      sundials_fnvecserial_shared
+      sundials_sunnonlinsolnewton_shared)
+
+    set_target_properties(sundials_fsunnonlinsolnewton_shared
+      PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolnewton CLEAN_DIRECT_OUTPUT 1)
+    set_target_properties(sundials_fsunnonlinsolnewton_shared
+      PROPERTIES VERSION ${sunnonlinsollib_VERSION} SOVERSION ${sunnonlinsollib_SOVERSION})
+    install(TARGETS sundials_fsunnonlinsolnewton_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  endif()
+
+endif()
+
+#
+message(STATUS "Added SUNNONLINSOL_NEWTON module")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/F90/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/F90/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e7471f3ae78f5b73d668844f71aeb72d2b49b292
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/F90/CMakeLists.txt
@@ -0,0 +1,40 @@
+# ---------------------------------------------------------------
+# Programmer:  Cody J. Balos @ LLNL
+# ---------------------------------------------------------------
+# SUNDIALS Copyright Start
+# Copyright (c) 2002-2019, Lawrence Livermore National Security
+# and Southern Methodist University.
+# All rights reserved.
+#
+# See the top-level LICENSE and NOTICE files for details.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# SUNDIALS Copyright End
+# ---------------------------------------------------------------
+# CMakeLists.txt file for the F2003 Newton SUNNonlinearSolver
+# object library
+# ---------------------------------------------------------------
+
+set(sunnonlinsolnewton_SOURCES fsunnonlinsol_newton.f90)
+
+if(BUILD_STATIC_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunnonlinsolnewton_mod_static STATIC
+    ${sunnonlinsolnewton_SOURCES}
+  )
+  set_target_properties(sundials_fsunnonlinsolnewton_mod_static
+    PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolnewton_mod CLEAN_DIRECT_OUTPUT 1)
+  install(TARGETS sundials_fsunnonlinsolnewton_mod_static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_STATIC_LIBS)
+
+if(BUILD_SHARED_LIBS)
+  sundials_add_f2003_interface_library(sundials_fsunnonlinsolnewton_mod_shared SHARED
+    ${sunnonlinsolnewton_SOURCES}
+  )
+  set_target_properties(sundials_fsunnonlinsolnewton_mod_shared
+    PROPERTIES OUTPUT_NAME sundials_fsunnonlinsolnewton_mod CLEAN_DIRECT_OUTPUT 1)
+  set_target_properties(sundials_fsunnonlinsolnewton_mod_shared
+    PROPERTIES VERSION ${nveclib_VERSION} SOVERSION ${nveclib_SOVERSION})
+  install(TARGETS sundials_fsunnonlinsolnewton_mod_shared DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif(BUILD_SHARED_LIBS)
+
+message(STATUS "Added SUNNONLINSOL_NEWTON F2003 interface")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/F90/fsunnonlinsol_newton.f90 b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/F90/fsunnonlinsol_newton.f90
new file mode 100644
index 0000000000000000000000000000000000000000..4c32e3cfabfaaa718b23ab0b4514190fa36e9755
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/ThirdParty/sundials/src/sunnonlinsol/newton/F90/fsunnonlinsol_newton.f90
@@ -0,0 +1,160 @@
+! -----------------------------------------------------------------
+! Programmer(s): Cody J. Balos @ LLNL
+! -----------------------------------------------------------------
+! SUNDIALS Copyright Start
+! Copyright (c) 2002-2019, Lawrence Livermore National Security
+! and Southern Methodist University.
+! All rights reserved.
+!
+! See the top-level LICENSE and NOTICE files for details.
+!
+! SPDX-License-Identifier: BSD-3-Clause
+! SUNDIALS Copyright End
+! -----------------------------------------------------------------
+! This file contains a Fortran module for interfacing directly with
+! the SUNDIALS Newton iteration nonlinear solver using the
+! ISO_C_BINDING module.
+! -----------------------------------------------------------------
+
+module fsunnonlinsol_newton_mod
+
+  !======= Interfaces =========
+  interface
+
+     ! =================================================================
+     ! Constructors
+     ! =================================================================
+
+     type(c_ptr) function FSUNNonlinSol_Newton(y) &
+         bind(C,name='SUNNonlinSol_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: y
+     end function FSUNNonlinSol_Newton
+
+     type(c_ptr) function FSUNNonlinSol_NewtonSens(cnt, y) &
+         bind(C,name='SUNNonlinSol_NewtonSens')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       integer(c_int), value :: cnt
+       type(c_ptr),    value :: y
+     end function FSUNNonlinSol_NewtonSens
+
+     ! =================================================================
+     ! Destructors
+     ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolFree_Newton(NLS) &
+         bind(C,name='SUNNonlinSolFree_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: NLS
+     end function FSUNNonlinSolFree_Newton
+
+     ! =================================================================
+     ! Operations
+     ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolGetType_Newton(NLS) &
+         bind(C,name='SUNNonlinSolGetType_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: NLS
+     end function FSUNNonlinSolGetType_Newton
+
+     integer(c_int) function FSUNNonlinSolInitialize_Newton(NLS) &
+         bind(C,name='SUNNonlinSolInitialize_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr), value :: NLS
+     end function FSUNNonlinSolInitialize_Newton
+
+     integer(c_int) function FSUNNonlinSolSolve_Newton(NLS, y0, y, w, tol, &
+                                                           callSetup, mem) &
+         bind(C,name='SUNNonlinSolSolve_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_ptr),    value :: y0
+       type(c_ptr),    value :: y
+       type(c_ptr),    value :: w
+       real(c_double), value :: tol
+       integer(c_int), value :: callSetup
+       type(c_ptr),    value :: mem
+     end function FSUNNonlinSolSolve_Newton
+
+    ! =================================================================
+    ! Set functions
+    ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolSetSysFn_Newton(NLS, SysFn) &
+         bind(C,name='SUNNonlinSolSetSysFn_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_funptr), value :: SysFn
+     end function FSUNNonlinSolSetSysFn_Newton
+
+     integer(c_int) function FSUNNonlinSolSetLSetupFn_Newton(NLS, LSetupFn) &
+         bind(C,name='SUNNonlinSolSetLSetupFn_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_funptr), value :: LSetupFn
+     end function FSUNNonlinSolSetLSetupFn_Newton
+
+     integer(c_int) function FSUNNonlinSolSetLSolveFn_Newton(NLS, LSolveFn) &
+         bind(C,name='SUNNonlinSolSetLSolveFn_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_funptr), value :: LSolveFn
+     end function FSUNNonlinSolSetLSolveFn_Newton
+
+     integer(c_int) function FSUNNonlinSolSetConvTestFn_Newton(NLS, CTestFN) &
+         bind(C,name='SUNNonlinSolSetConvTestFn_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       type(c_funptr), value :: CTestFN
+     end function FSUNNonlinSolSetConvTestFn_Newton
+
+     integer(c_int) function FSUNNonlinSolSetMaxIters_Newton(NLS, maxiters) &
+         bind(C,name='SUNNonlinSolSetMaxIters_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       integer(c_int), value :: maxiters
+     end function FSUNNonlinSolSetMaxIters_Newton
+
+    ! =================================================================
+    ! Get functions
+    ! =================================================================
+
+     integer(c_int) function FSUNNonlinSolGetNumIters_Newton(NLS, niters) &
+         bind(C,name='SUNNonlinSolGetNumIters_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),    value :: NLS
+       integer(c_long)       :: niters
+     end function FSUNNonlinSolGetNumIters_Newton
+
+     integer(c_int) function FSUNNonlinSolGetCurIter_Newton(NLS, iter) &
+         bind(C,name='SUNNonlinSolGetCurIter_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),   value :: NLS
+       integer(c_int)       :: iter
+     end function FSUNNonlinSolGetCurIter_Newton
+
+     integer(c_int) function FSUNNonlinSolGetSysFn_Newton(NLS, SysFn) &
+         bind(C,name='SUNNonlinSolGetSysFn_Newton')
+       use, intrinsic :: iso_c_binding
+       implicit none
+       type(c_ptr),   value :: NLS
+       type(c_funptr)       :: SysFn
+     end function FSUNNonlinSolGetSysFn_Newton
+
+   end interface
+
+end module fsunnonlinsol_newton_mod
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/bu_.appveyor.yml b/Requirements/AMICI-0.10.11_SS_eventFix/bu_.appveyor.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e9eac5615aed7b88b480c7416f33e5c33e91307b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/bu_.appveyor.yml
@@ -0,0 +1,41 @@
+version: '{build}'
+
+os: Visual Studio 2015
+
+cache:
+  - x86_64-4.9.2-release-win32-seh-rt_v4-rev4.7z
+  - hdf5-1.8.17-win64-vs2015-shared.zip
+
+platform:
+  - x64
+  
+branches:
+  only:
+    - master
+    - staging
+  
+environment:
+  matrix:
+  - compiler: mingw
+    MINGW_DIR: mingw64
+    MINGW_URL: https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/4.9.2/threads-win32/seh/x86_64-4.9.2-release-win32-seh-rt_v4-rev4.7z/download
+    MINGW_ARCHIVE: x86_64-4.9.2-release-win32-seh-rt_v4-rev4.7z
+    HDF5_URL: https://support.hdfgroup.org/ftp/HDF5/current/bin/windows/extra/hdf5-1.8.17-win64-vs2015-shared.zip
+    HDF5_ARCHIVE: hdf5-1.8.17-win64-vs2015-shared.zip
+  
+install:
+  - if not exist "%MINGW_ARCHIVE%" appveyor DownloadFile "%MINGW_URL%" -FileName "%MINGW_ARCHIVE%"
+  - if not exist "%HDF5_ARCHIVE%" appveyor DownloadFile "%HDF5_URL%" -FileName "%HDF5_ARCHIVE%"
+  - 7z x -y "%MINGW_ARCHIVE%" > nul
+  - 7z x -y "%HDF5_ARCHIVE%" > nul
+  - cd hdf5
+  - msiexec /i HDF5-1.8.17-win64.msi /quiet 
+  - cd "C:\Program Files\HDF_Group\HDF5\1.8.17\lib"
+  - C:\MinGW\msys\1.0\bin\sh C:\projects\amici\scripts\patch-hdf5.sh
+  - cd "C:\projects\amici"
+
+before_build:
+  - set "Path=%CD%\%MINGW_DIR%\bin;C:\Program Files\HDF_Group\HDF5\1.8.17;%Path%"
+
+build_script:
+  - ps: .\scripts\build-mingw.ps1
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/cmake/AmiciConfig.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/AmiciConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2fd685ead9721c9addf4870d156e6b7a076646a3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/AmiciConfig.cmake
@@ -0,0 +1 @@
+include("${CMAKE_CURRENT_LIST_DIR}/AmiciTargets.cmake")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/cmake/clang-tools.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/clang-tools.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..126fcbba3bf45193326eb393196db6f663e8e1f6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/clang-tools.cmake
@@ -0,0 +1,34 @@
+######### Add targets for clang-format and clang-tidy ############
+
+# Find all source files
+execute_process(COMMAND sh -c "git ls-tree -r HEAD --name-only src/*.cpp include/*.h | tr '\n' ' '"
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    OUTPUT_VARIABLE ALL_CXX_SOURCE_FILES
+    )
+############ clang-tidy ############
+
+# Try to find clang-format and add target if successful
+find_program(CLANG_FORMAT "clang-format")
+if(CLANG_FORMAT)
+    add_custom_target(
+        clang-format
+        COMMAND bash -c "/usr/bin/clang-format -i ${ALL_CXX_SOURCE_FILES}"
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        )
+else()
+    message(STATUS "clang-format was not found")
+endif()
+
+############ clang-tidy ############
+# Try to find clang-tidy and add target if successful
+find_program(CLANG_TIDY "clang-tidy")
+
+if(CLANG_TIDY)
+    add_custom_target(
+        clang-tidy
+        COMMAND sh -c "/usr/bin/clang-tidy ${ALL_CXX_SOURCE_FILES} -- -std=c++11 -I${CMAKE_SOURCE_DIR}"
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        )
+else()
+    message(STATUS "clang-tidy was not found")
+endif()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/cmake/configureVersion.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/configureVersion.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ef8e0df555ba9ba55e91f478324770edb078acb6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/configureVersion.cmake
@@ -0,0 +1,5 @@
+include(${CMAKE_CURRENT_LIST_DIR}/version.cmake)
+set(AMICI_VERSION ${PROJECT_VERSION})
+get_filename_component(directory ${DST} DIRECTORY)
+file(MAKE_DIRECTORY ${directory})
+configure_file(${SRC} ${DST} @ONLY)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/cmake/version.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ebc391e5764553dfe0971404a8f588695f2671f8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/cmake/version.cmake
@@ -0,0 +1,16 @@
+find_package(Git)
+if(Git_FOUND)
+    execute_process(COMMAND sh -c "${GIT_EXECUTABLE} describe --abbrev=4 --dirty=-dirty --always --tags  | cut -c 2- | tr -d '\n' | sed -E s/-/./"
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE PROJECT_VERSION_GIT
+        )
+endif()
+
+# get project root directory
+get_filename_component(CMAKE_PARENT_LIST_DIR ${CMAKE_PARENT_LIST_FILE} DIRECTORY)
+get_filename_component(CMAKE_PARENT_LIST_DIR ${CMAKE_PARENT_LIST_DIR} DIRECTORY)
+
+execute_process(COMMAND sh -c "cat version.txt | tr -d '\n'"
+    WORKING_DIRECTORY "${CMAKE_PARENT_LIST_DIR}"
+    OUTPUT_VARIABLE PROJECT_VERSION
+    )
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/codecov.yml b/Requirements/AMICI-0.10.11_SS_eventFix/codecov.yml
new file mode 100644
index 0000000000000000000000000000000000000000..2f1478f3e51f70327ec1b53ecf42e13e696b645c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/codecov.yml
@@ -0,0 +1,2 @@
+fixes:
+  - "build/venv/lib/python3.6/site-packages/::python/"
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/CI.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/CI.md
new file mode 100644
index 0000000000000000000000000000000000000000..091bcdaba9fff8f7934ac7ae930ab7cf96c5eaaa
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/CI.md
@@ -0,0 +1,79 @@
+# Continuous integration (CI) and tests
+
+AMICI uses a continuous integration pipeline running on https://travis-ci.org/.
+This includes the following steps:
+
+- Checking existence and format of documentation
+- Static code analysis (http://cppcheck.sourceforge.net/)
+- Unit and integration tests
+- Memory leak detection
+
+More details are provided in the sections below.
+
+The CI scripts and tests can be found in `tests/` and `scripts/`. Some of the
+tests are integrated with CMake, see `make help` in the build directory. 
+
+
+## C++ unit and integration tests
+
+To run C++ tests, build AMICI with `make` or `scripts/buildAll.sh`,
+then run `scripts/run-cpputest.sh`.
+
+
+## Python unit and integration tests
+
+To run Python tests, run `../scripts/run-python-tests.sh` from anywhere
+(assumes build directory is `build/`) or run `make python-tests` in your build
+directory.
+
+
+## Matlab tests (not included in CI pipeline)
+
+To execute the Matlab test suite, run `tests/testModels.m`.
+
+
+## Model simulation integration tests
+
+Many of our integration tests are model simulations. The simulation results
+obtained from the Python and C++ are compared to results saved in an HDF5 file
+(`tests/cpputest/expectedResults.h5`).
+Settings and data for the test simulations are also specified in this file.
+
+**Note:** The C++ code for the models is included in the repository under 
+`models/`.
+This code is to be updated whenever `amici::Model` changes.
+
+
+### Regenerating C++ code of the test models
+
+Regeneration of the model code must done whenever `amici::Model` or
+the Matlab model import routines change.
+
+This is done with
+  
+    tests/cpputest/wrapTestModels.m
+
+**Note:** This is currently only possible from Matlab < R2018a. This should
+change as soon as 1) all second-order sensitivity code is ported to C++/Python,
+2) a non-SBML import exists for Python and 3) support for events has been added
+for Python.
+    
+    
+### Regenerating expected results
+
+To update test results, run `make test` in the build directory,
+replace `tests/cpputest/expectedResults.h5` by 
+`tests/cpputest/writeResults.h5.bak` 
+[ONLY DO THIS AFTER TRIPLE CHECKING CORRECTNESS OF RESULTS]
+Before replacing the test results, confirm that only expected datasets have
+changed, e.g. using 
+
+    h5diff -v -r 1e-8 tests/cpputest/expectedResults.h5 tests/cpputest/writeResults.h5.bak | less
+
+
+## Adding/Updating tests
+
+To add new tests add a new corresponding python script (see, e.g.,
+`./tests/generateTestConfig/example_dirac.py`) and add it to and run 
+`tests/generateTestConfigurationForExamples.sh`.
+Then regenerate the expected test results (see above).
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/CPP.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/CPP.md
new file mode 100644
index 0000000000000000000000000000000000000000..360d030855cdd311db5719dbe7fac1c01525485f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/CPP.md
@@ -0,0 +1,113 @@
+# C++ Interface
+
+The @ref python_interface and @ref matlab_interface can translate the model
+definition into C++ code, which is then compiled into a `.mex` file or a Python
+module. Advanced users can also use this code within stand-alone C/C++
+application for use in other environments (e.g. on high performance computing
+systems). This section will give a short overview over the generated files and
+provide a brief introduction of how this code can be included in other
+applications. For more details see the function level documentation, e.g. in
+http://icb-dcm.github.io/AMICI/amici_8cpp.html. 
+
+
+## Generation of C++ model files
+
+`amiwrap.m` (Matlab) and `amici.SbmlImporter.sbml2amici` (Python) import a
+model and create C++ code for various model functions. The model
+source files are written to `${AMICI_ROOT_DIR}/models/${MODEL_NAME}` by
+default.
+
+The content of a model source directory might look something like this (given
+`MODEL_NAME=model_steadystate`): 
+
+```
+CMakeLists.txt
+hashes.mat 
+main.cpp 
+model_steadystate_deltaqB.cpp 
+model_steadystate_deltaqB.h 
+[... many more files model_steadystate_*.(cpp|h|md5|o) ]
+wrapfunctions.cpp 
+wrapfunctions.h 
+model_steadystate.h 
+```
+
+These files provide the implementation of a model-specific subclass of
+`amici::Model`. The `CMakeLists.txt` file can be used to build the library.
+`main.cpp` contains a simple scaffold for running a model simulation from C++.
+See next section for more details on these files.
+
+
+## Compiling and linking
+
+In your application, you need to compile and link every model 
+`${AMICI_ROOT_DIR}/models/${MODEL_NAME}/*.cpp`,
+`${AMICI_ROOT_DIR}/src/*.cpp`, the SUNDIALS and the SuiteSparse library.
+The simplest and recommended way is using the CMake package configuration
+from the build directory (`AmiciConfig.cmake` for use with 
+[`find_package`](https://cmake.org/cmake/help/latest/command/find_package.html)
+which tells CMake about all AMICI dependencies.
+
+During model import a [CMake](https://cmake.org/) file (`CMakeLists.txt`)
+will be generated automatically. The CMake file shows the above-mentioned
+library dependencies. `CMakeLists.txt`, together with `main.cpp`, provides a
+scaffold for a standalone simulation program.
+The required numerical libraries are shipped with AMICI.
+To compile them, run `${AMICI_ROOT_DIR}/scripts/buildAll.sh` once. HDF5
+libraries and header files need to be installed separately (see AMICI
+installation instructions). 
+
+More information on how to run the compiled sample program is provided in
+`main.cpp`.
+
+The file `wrapfunctions.h` exports some functions with generic names e.g. to
+create a model instance. These functions are meant to be used by applications
+which may be linked to single, potentially changing model to avoid hard-coding
+the model name. Including multiple `wrapfunctions.h` files from different
+models at once is not possible.
+ 
+
+## Running a simulation
+
+The complete AMICI API is available through `amici/amici.h`; this is the only
+header file that needs to be included for basic usage.
+Additionally, `amici/hdf5.h` may be helpful. This file provides some
+functions for reading and writing [HDF5](https://support.hdfgroup.org/) files). 
+All functions are declared within the `amici` namespace.
+
+The entry function for running an AMICI simulation is
+`amici::runAmiciSimulation(...)`, declared in `amici/amici.h`. 
+
+This function requires 
+    
+* a `amici::Model` instance. For the example `model_steadystate` the respective
+  class is provided as `Model_model_steadystate` in `model_steadystate.h`.
+  For convenience, the header `wrapfunctions.h` defines a function
+  `getModel()`, that returns an instance of that class.
+
+* a `amici::Solver` instance. This solver instance needs to match the
+  requirements of the model and can be generated using `model->getSolver()`.
+
+* optionally an `amici::ExpData` instance, which contains any experimental data
+  (e.g. measurements, noise model parameters or model inputs) to
+  compute residuals or an objective function.
+
+A scaffold for a standalone simulation program is generated in `main.cpp` in
+the model source directory. This program shows how to use the
+above-mentioned classes and how to obtain the simulation results.
+
+For running simulations for multiple experimental conditions
+(multiple `amici::ExpData` instances), `amici::runAmiciSimulations(...)`
+provides an alternative entry point. If AMICI (and your application)
+have been compiled with OpenMP support (see installation guide), this allows
+for running those simulations in parallel.
+
+
+## Parameter estimation for AMICI models in high-performance computing environments
+
+To perform parameter estimation for large or otherwise computationally
+demanding AMICI models from C++ in a high-performance computing environment,
+you may find the [parPE](https://github.com/ICB-DCM/parPE/) library helpful.
+parPE allows for the private or shared memory parallel evaluation of a cost
+function requiring multiple simulations of the same model with different
+inputs. It provides interfaces to different optimizers, such as Ipopt.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/FAQ.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/FAQ.md
new file mode 100644
index 0000000000000000000000000000000000000000..cbdaf3035327365b1ee5e6396ee16a2f297f077b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/FAQ.md
@@ -0,0 +1,44 @@
+# FAQ
+
+__Q__: My model fails to build.
+
+__A__: Remove the corresponding model directory located in AMICI/models/*yourmodelname* and compile again.
+
+---
+
+__Q__: It still does not compile.
+
+__A__: Remove the directory AMICI/models/`mexext` and compile again.
+
+---
+
+__Q__: It still does not compile.
+
+__A__: Make an [issue](https://github.com/ICB-DCM/AMICI/issues) and we will have a look.
+
+---
+
+__Q__: My Python-generated model does not compile from MATLAB.
+
+__A__: Try building any of the available examples before. If this succeeds, 
+retry building the original model. Some dependencies might not be built 
+correctly when using only the `compileMexFile.m` script. 
+
+---
+
+__Q__: I get an out of memory error while compiling my model on a Windows machine.
+
+__A__: This may be due to an old compiler version. See [issue #161](https://github.com/ICB-DCM/AMICI/issues/161) for instructions on how to install a new compiler.
+
+---
+
+__Q__: How are events interpreted in a DAE context?
+
+__A__: Currently we only support impulse free events. Also sensitivities have never been tested. Proceed with care and create an [issue](https://github.com/ICB-DCM/AMICI/issues) if any problems arise!
+
+---
+
+__Q__: The simulation/sensitivities I get are incorrect.
+
+__A__: There are some known issues, especially with adjoint sensitivities, events and DAEs. If your particular problem is not featured in the [issues](https://github.com/ICB-DCM/AMICI/issues) list, please add it!
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/MATLAB.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/MATLAB.md
new file mode 100644
index 0000000000000000000000000000000000000000..40ecc87c31459543b0a0e7ed03e58d71f8be1201
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/MATLAB.md
@@ -0,0 +1,304 @@
+# MATLAB Interface {#matlab_interface}
+
+In the following we will give a detailed overview how to specify models in MATLAB and how to call the generated simulation files.
+
+## Model Definition 
+
+This guide will guide the user on how to specify models in MATLAB. For example implementations see the examples in the matlab/examples directory.
+
+### Header
+
+The model definition needs to be defined as a function which returns a struct with all symbolic definitions and options.
+
+    function [model] = example_model_syms()
+
+### Options
+
+Set the options by specifying the respective field of the modelstruct
+
+    model.(fieldname) = value
+
+The options specify default options for simulation, parametrisation and compilation. All of these options are optional.
+
+| field        | description                                   | default
+|--------------|-----------------------------------------------|---------
+| .param       | default parametrisation 'log'/'log10'/'lin'   | 'lin'
+| .debug       | flag to compile with debug symbols            | false
+| .forward     | flag to activate forward sensitivities        | true
+| .adjoint     | flag to activate adjoint sensitivities        | true
+
+When set to false, the fields 'forward' and 'adjoint' will speed up the time required to compile the model but also disable the respective sensitivity computation.
+
+### States
+
+Create the respective symbolic variables. The name of the symbolic variable can be chosen arbitrarily.
+
+    syms state1 state2 state3
+
+Create the state vector containing all states:
+
+    model.sym.x = [ state1 state2 state3 ];
+
+### Parameters
+
+Create the respective symbolic variables. The name of the symbolic variable can be chosen arbitrarily.
+Sensitivities __will be derived__ for all paramaters.
+
+    syms param1 param2 param3 param4 param5 param6
+
+Create the parameters vector
+
+    model.sym.p = [ param1 param2 param3 param4 param5 param6 ];
+
+### Constants
+
+Create the respective symbolic variables. The name of the symbolic variable can be chosen arbitrarily.
+Sensitivities with respect to constants __will not be derived__.
+
+    syms const1 const2
+
+Create the parameters vector
+
+    model.sym.k = [ const1 const2 ];
+
+### Differential Equation
+
+For time-dependent differential equations you can specify a symbolic variable for time. This __needs__ to be denoted by `t`.
+
+    syms t
+
+Specify the right hand side of the differential equation `f` or `xdot`
+
+    model.sym.xdot(1) = [ const1 - param1*state1 ];
+    model.sym.xdot(2) = [ +param2*state1 + dirac(t-param3) - const2*state2 ];
+    model.sym.xdot(3) = [ param4*state2 ];
+
+or
+
+    model.sym.f(1) = [ const1 - param1*state1 ];
+    model.sym.f(2) = [ +param2*state1 + dirac(t-param3) - const2*state2 ];
+    model.sym.f(3) = [ param4*state2 ];
+
+The specification of `f` or `xdot` may depend on states, parameters and constants.
+
+For DAEs also specify the mass matrix.
+
+    model.sym.M = [1, 0, 0;...
+                    0, 1, 0;...
+                    0, 0, 0];
+
+The specification of M may depend on parameters and constants.
+
+For ODEs the integrator will solve the equation \f$ \dot{x} = f \f$ and for DAEs the equations \f$ M \cdot \dot{x} = f \f$.
+AMICI will decide whether to use CVODES (for ODEs) or IDAS (for DAEs) based on whether the mass matrix is defined or not.
+
+In the definition of the differential equation you can use certain symbolic functions. For a full list of available functions see `src/symbolic_functions.cpp`.
+
+Dirac functions can be used to cause a jump in the respective states at the specified time-point. This is typically used to model injections, or other external stimuli. Spline functions can be used to model time/state dependent response with unkown time/state dependence.
+
+### Initial Conditions
+
+Specify the initial conditions. These may depend on parameters on constants and must have the same size as `x`.
+
+    model.sym.x0 = [ param4, 0, 0 ];
+
+### Observables
+
+Specify the observables. These may depend on parameters and constants.
+
+    model.sym.y(1) = state1 + state2;
+    model.sym.y(2) = state3 - state2;
+
+In the definition of the observable you can use certain symbolic functions. For a full list of available functions see `src/symbolic_functions.cpp`.
+Dirac functions in observables will have no effect.
+
+### Events
+
+Specifying events is optional. Events are specified in terms of a trigger function, a bolus fuction and an output function. The roots of the trigger function defines the occurences of the event. The bolus function defines the change in the state on event occurences. The output function defines the expression which is evaluated and reported by the simulation routine on every event occurence. The user can create events by constructing a vector of objects of the class @ref amievent.
+
+    model.sym.event(1) = amievent(state1 - state2,0,[]);
+
+Events may depend on states, parameters and constants but __not__ on observables.
+
+For more details about event support see https://doi.org/10.1093/bioinformatics/btw764 
+
+### Standard Deviation
+
+Specifying standard deviations is optional. It only has an effect when computing adjoint sensitivities. It allows the user to specify standard deviations of experimental data for observables and events.
+
+Standard deviaton for observable data is denoted by sigma_y
+
+    model.sym.sigma_y(1) = param5;
+
+Standard deviaton for event data is denoted by sigma_t
+
+    model.sym.sigma_t(1) = param6;
+
+Both `sigma_y` and `sigma_t` can either be a scalar or of the same dimension as the observables / events function.
+They can depend on time and parameters but must not depend on the states or observables. The values provided in `sigma_y` and `sigma_t` will only be used if the value in `D.Sigma_Y` or `D.Sigma_T` in the user-provided data struct is `NaN`. See simulation for details.
+
+### Objective Function
+
+By default, AMICI assumes a normal noise model and uses the corresponding negative log-likelihood 
+
+    J = 1/2*sum(((y_i(t)-my_ti)/sigma_y_i)^2 + log(2*pi*sigma_y^2)
+
+as objective function. A user provided objective function can be specified in
+
+    model.sym.Jy
+
+As reference see the default specification of `this.sym.Jy` in `amimodel.makeSyms`.
+
+### SBML
+
+AMICI can also import SBML models using the command `SBML2AMICI`. This will generate a model specification as described above, which may be edited by the user to apply further changes.
+
+## Model Compilation
+
+The model can then be compiled by calling `amiwrap.m`:
+
+    amiwrap(modelname,'example_model_syms',dir,o2flag)
+
+Here `modelname` should be a string defining the name of the model, `dir` should be a string containing the path to the directory in which simulation files should be placed and `o2flag` is a flag indicating whether second order sensitivities should also be compiled.
+The user should make sure that the previously defined function `'example_model_syms'` is in the user path. Alternatively, the user can also call the function `'example_model_syms'`
+
+    [model] = example_model_syms()
+
+and subsequently provide the generated struct to `amiwrap(...)`, instead of providing the symbolic function:
+
+    amiwrap(modelname,model,dir,o2flag)
+
+In a similar fashion, the user could also generate multiple models and pass them directly to `amiwrap(...)` without generating respective model definition scripts.
+
+
+### Compiling a Python-generated model
+
+Due to better performance or to avoid the Symbolic Toolbox requirement,
+it might be desirable to import a model in Python and compile the
+resulting code into a mex file. For Python model import, consult the
+respective section of the Python documentation. Once the imported
+succeeded, there will be a `compileMexFile.m` script inside the newly
+created model directory which can be invoked to compile the mex file.
+This mex file and `simulate_*.m` can be used as if fully created by
+matlab.
+
+
+#### Using Python-AMICI model import from Matlab
+
+With recent matlab versions it is possible to use the AMICI python package
+from within Matlab. This not quite comfortable yet, but it is possible.
+
+Here for proof of concept:
+
+* Install the python package as described in the documentation
+* Ensure `pyversion` shows the correct python version (3.6 or 3.7)
+* Then, from within the AMICI `matlab/` directory:
+    
+    ```
+    sbml_importer = py.amici.SbmlImporter('../python/examples/example_steadystate/model_steadystate_scaled.xml')
+    sbml_importer.sbml2amici('steadystate', 'steadystate_example_from_python')
+    model = py.steadystate.getModel()
+    solver = model.getSolver()
+    model.setTimepoints(linspace(0, 50, 51))
+    rdata = py.amici.runAmiciSimulation(model, solver)
+    result = struct(py.dict(rdata.items()))
+    t = double(py.array.array('d', result.ts))
+    x = double(py.array.array('d', result.x.flatten()))
+    x = reshape(x, flip(double(py.array.array('d', result.x.shape))))
+    plot(t, x)
+    ```
+
+
+## Model Simulation
+
+After the call to `amiwrap(...)` two files will be placed in the specified directory. One is a _modelname_.mex and the other is simulate_ _modelname_.m. The mex file should never be called directly. Instead the MATLAB script, which acts as a wrapper around the .mex simulation file should be used.
+
+The simulate_ _modelname_.m itself carries extensive documentation on how to call the function, what it returns and what additional options can be specified. In the following we will give a short overview of possible function calls.
+
+### Integration
+
+Define a time vector:
+
+    t = linspace(0,10,100)
+
+
+Generate a parameter vector:
+
+    theta = ones(6,1);
+
+
+Generate a constants vector:
+
+    kappa = ones(2,1);
+
+
+Integrate:
+
+    sol = simulate_modelname(t,theta,kappa,[],options)
+
+
+The integration status will be indicated by the `sol.status` flag. Negative values indicated failed integration. The states will then be available as sol.x. The observables will then be available as `sol.y`. The event outputs will then be available as `sol.z`. If no event occured there will be an event at the end of the considered interval with the final value of the root function is stored in `sol.rz`.
+
+Alternatively the integration can also be called via
+
+    [status,t,x,y] = simulate_modelname(t,theta,kappa,[],options)
+
+The integration status will be indicated by the flag `status` . Negative values indicated failed integration. The states will then be available as `x`. The observables will then be available as `y`. No event output will be given.
+
+### Forward Sensitivities
+
+Set the sensitivity computation to forward sensitivities and integrate:
+
+    options.sensi = 1;
+    options.sensi_meth = 'forward;
+    sol = simulate_modelname(t,theta,kappa,[],options)
+
+The integration status will be indicated by the `sol.status` flag. Negative values indicate failed integration. The states will be available as `sol.x`, with the derivative with respect to the parameters in `sol.sx`. The observables will be available as `sol.y`, with the derivative with respect to the parameters in `sol.sy`. The event outputs will be available as `sol.z`, with the derivative with respect to the parameters in `sol.sz`. If no event occured there will be an event at the end of the considered interval with the final value of the root function stored in `sol.rz`, with the derivative with respect to the parameters in `sol.srz`.
+
+Alternatively the integration can also be called via
+
+    [status,t,x,y,sx,sy] = simulate_modelname(t,theta,kappa,[],options)
+
+The integration status will be indicated by the status flag. Negative values indicate failed integration. The states will then be available as `x`, with derivative with respect to the parameters in `sx`. The observables will then be available as `y`, with derivative with respect to the parameters in `sy`. No event output will be given.
+
+### Adjoint Sensitivities
+
+Set the sensitivity computation to adjoint sensitivities:
+
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+
+Define Experimental Data:
+
+    D.Y = [NaN(1,2)],ones(length(t)-1,2)];
+    D.Sigma_Y = [0.1*ones(length(t)-1,2),NaN(1,2)];
+    D.T = ones(1,1);
+    D.Sigma_T = NaN;
+
+The `NaN` values in `Sigma_Y` and `Sigma_T` will be replaced by the specification in `model.sym.sigma_y` and `model.sym.sigma_t`. Data points with `NaN` value will be completely ignored.
+
+Integrate:
+
+    sol = simulate_modelname(t,theta,kappa,D,options)
+
+The integration status will be indicated by the sol.status flag. Negative values indicate failed integration. The log-likelihood will then be available as `sol.llh` and the derivative with respect to the parameters in `sol.sllh`. Notice that for adjoint sensitivities no state, observable and event sensitivities will be available. Yet this approach can be expected to be significantly faster for systems with a large number of parameters.
+
+### Steady State Sensitivities
+
+This will compute state sensitivities according to the formula \f$ s_k^x = -\left(\frac{\partial f}{\partial x} \right)^{-1}\frac{\partial f}{\partial \theta_k} \f$
+
+In the current implementation this formulation does not allow for conservation laws as this would result in a singular Jacobian.
+
+Set the final timepoint as infinity, this will indicate the solver to compute the steadystate:
+
+    t = Inf;
+
+Set the sensitivity computation to steady state sensitivities:
+
+    options.sensi = 1;
+
+Integrate:
+
+    sol = simulate_modelname(t,theta,kappa,D,options)
+
+The states will be available as `sol.x`, with the derivative with respect to the parameters in `sol.sx`. The observables will be available as `sol.y`, with the derivative with respect to the parameters in `sol.sy`. Notice that for steady state sensitivities no event sensitivities will be available. For the accuracy of the computed derivatives it is essential that the system is sufficiently close to a steady state. This can be checked by examining the right hand side of the system at the final time-point via `sol.diagnosis.xdot`.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/PYTHON.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/PYTHON.md
new file mode 100644
index 0000000000000000000000000000000000000000..4935aada464fbd08ffad6828810fc3d5171ad11e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/PYTHON.md
@@ -0,0 +1,87 @@
+# Python Interface {#python_interface}
+
+In the following we will give a detailed overview how to specify models in  Python and how to call the generated simulation files.
+
+## Model Definition
+
+This guide will guide the user on how to specify models in Python using SBML. For example implementations see the examples in the python/examples directory.
+
+### SBML input
+
+First, import an sbml file using the `amici.sbml_import.SbmlImporter` class:
+
+    import amici
+    sbmlImporter = amici.SbmlImporter('model_steadystate_scaled.sbml')
+    
+the sbml document as imported by [libSBML](http://sbml.org/Software/libSBML) is available as 
+
+    sbml = sbmlImporter.sbml
+
+### Constants 
+
+parameters that should be considered constants can be specified in a list of strings specifying the respective SbmlId of a parameter.
+
+    constantParameters=['k4']
+
+### Observables
+
+Assignment rules that should be considered as observables can extracted using the `amici.assignmentRules2observables` function.
+
+    observables = amici.assignmentRules2observables(sbml, filter_function=lambda variable: 
+                                                    variable.getId().startswith('observable_') and not variable.getId().endswith('_sigma'))
+
+### Standard Deviations
+
+standard deviations can be specified as dictionaries ...
+
+    sigmas = {'observable_x1withsigma': 'observable_x1withsigma_sigma'}
+
+
+## Model Compilation
+
+to compile the sbml as python module, the user has to call the method `amici.sbml_import.SbmlImporter.sbml2amici`, passing all the previously defined model specifications
+
+    sbmlImporter.sbml2amici('test', 'test', 
+                            observables=observables,
+                            constantParameters=constantParameters,
+                            sigmas=sigmas)
+
+Note: To build AMICI with OpenMP support, which allows to parallelize model simulations of multiple
+experimental conditions, set the environment variables `AMICI_CXXFLAGS` and `AMICI_LDFLAGS` to the
+correct OpenMP flags of your compiler and linker, respectively. This has to be done for both AMICI
+package installation *and* model compilation. When using `gcc` on Linux, use:
+
+    # on your shell:
+    AMICI_CXXFLAGS=-fopenmp AMICI_LDFLAGS=-fopenmp pip3 install amici
+
+    # in python, before model compilation:
+    import os
+    os.environ['AMICI_CXXFLAGS'] = '-fopenmp'
+    os.environ['AMICI_LDFLAGS'] = '-fopenmp'
+
+## Model Simulation 
+
+currently the model folder has to be manually added to the python path
+    
+    import sys
+    sys.path.insert(0, 'test')
+    
+the compiled model can now be imported as python module
+    
+    import test as modelModule
+
+to obtain a model instance call the `getModel()` method. This model instance will be instantiated using the defautl parameter values specified in the sbml.
+
+    model = modelModule.getModel()
+
+then pass the simulation timepoints to `amici.Model.setTimepoints`
+
+    model.setTimepoints(np.linspace(0, 60, 60)) 
+    
+for simulation we need to generate a solver instance 
+
+    solver = model.getSolver()
+    
+the model simulation can now be carried out using `amici.runAmiciSimulation`
+    
+    rdata = amici.runAmiciSimulation(model, solver)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/README.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8108891f5e58ac206d67b248c609d1e8cac8afa6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/README.md
@@ -0,0 +1,80 @@
+# AMICI documentation
+
+This file describes how the AMICI documentation is organized and compiled.
+
+The AMICI documentation is created using [doxygen](http://www.doxygen.nl/).
+It combines Markdown files from the root directory, from `documentation/`
+and in-source documentation from the C++, Python and Matlab source files.
+
+The documentation is generated by running
+
+    scripts/run-doxygen.sh
+
+The resulting HTML and PDF documentation will be created in `doc/`. Upon
+merges to the `master` branch, the documentation will be deployed to
+github-pages at http://icb-dcm.github.io/AMICI/.
+
+`scripts/run-doxygen.sh` also checks for any missing in-source documentation.
+
+
+## Doxygen configuration
+
+The main doxygen configuration file is located in
+`matlab/mtoc/config/Doxyfile.template`. Edit this file for inclusion or
+exclusion of additional files.
+
+
+## Matlab documentation
+
+Matlab documentation is processed by
+[mtoc++](https://www.morepas.org/software/mtocpp/docs/tools.html).
+This is configured in `matlab/mtoc/config`.
+
+
+## Python documentation
+
+Python documentation is processed by doxygen using the script and filters
+in `scripts/`.
+
+**NOTE:** Unfortunately, the current doxygen Python filter is unable to deal
+with Python type hints (https://github.com/ICB-DCM/AMICI/issues/613).
+
+
+## Out-of-source documentation
+
+Out-of-source documentation files should be written in Markdown and
+created within `documentation/`.
+Graphics for documentation are kept in `documentation/gfx/`.
+
+Some guidelines:
+
+* Note that there are some incompatibilities of Github Markdown and Doxygen
+  Markdown. Ideally documentation should be written in a format compatible with
+  both.
+  This affects for example images links which currently cause trouble in
+  Doxygen.
+
+* Where possible, relative links are preferred over absolute links. However,
+  they should work with both Github and Doxygen and ideally with local files
+  for offline use.
+
+* Please stick to the limit of 80 characters per line for readability of raw
+  Markdown files where possible. 
+  
+  However, note that some Markdown interpreters can handle line breaks within
+  links and headings, whereas others cannot. Here, compatibility is preferred
+  over linebreaks. 
+  
+* Avoid trailing whitespace
+
+
+## Maintaining the list of publications
+
+We want to maintain a list of publications / projects using AMICI. This is
+located at `documentation/references.md`. This file is created by
+`documentation/recreate_reference_list.py` based on
+the bibtex file `documentation/amici_refs.bib`.
+
+After any changes to `documentation/amici_refs.bib`, please run
+
+    documentation/recreate_reference_list.py
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/amici_refs.bib b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/amici_refs.bib
new file mode 100644
index 0000000000000000000000000000000000000000..8366aecbe14e65637fb05740a4e408eff4375ee5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/amici_refs.bib
@@ -0,0 +1,481 @@
+% Encoding: UTF-8
+
+
+
+
+@article{VillaverdeRai2019,
+	Author = {Villaverde, Alejandro F. and Raim\'undez, Elba and Hasenauer, Jan and Banga, Julio R.},
+	Date-Added = {2019-07-26 10:02:28 +0200},
+	Date-Modified = {2019-07-26 10:04:48 +0200},
+	Journal = {accepted for publication in Proc. of the Foundations of Syst. Biol. in Engin. (FOSBE)},
+	Keywords = {ODE, large-scale, Parameter identification, prediction uncertainty, FIM, profile likelihood},
+	Title = {A Comparison of Methods for Quantifying Prediction Uncertainty in Systems Biology},
+	Year = {2019}}
+
+@article{WangSta2019,
+	Author = {Wang, Dantong and Stapor, Paul and Hasenauer, Jan},
+	Date-Added = {2019-07-26 09:11:43 +0200},
+	Date-Modified = {2019-07-26 09:13:12 +0200},
+	Journal = {accepted for publication in Proc. of the Foundations of Syst. Biol. in Engin. (FOSBE)},
+	Keywords = {mixed-effect models, dirac mixture model, dmd, sigma points},
+	Title = {Dirac mixture distributions for the approximation of mixed effects models},
+	Year = {2019}}
+
+@article{LinesPas2019,
+	Author = {Lines, Glenn Terje and Paszkowski, Lukasz and Schmiester, Leonard and Weindl, Daniel and Stapor, Paul and Hasenauer, Jan},
+	Date-Added = {2019-07-26 09:08:46 +0200},
+	Date-Modified = {2019-07-26 09:13:34 +0200},
+	Journal = {accepted for publication in Proc. of the Foundations of Syst. Biol. in Engin. (FOSBE)},
+	Keywords = {ODE, large-scale, Simulation, steady state, Newton solver},
+	Title = {Efficient computation of steady states in large-scale ODE models of biochemical reaction networks},
+	Year = {2019}}
+
+@article{KapferSta2019,
+	Author = {Kapfer, Eva-Maria and Stapor, Paul and Hasenauer, Jan},
+	Date-Added = {2019-07-26 08:59:38 +0200},
+	Date-Modified = {2019-07-26 09:13:24 +0200},
+	Journal = {accepted for publication in Proc. of the Foundations of Syst. Biol. in Engin. (FOSBE)},
+	Keywords = {Optimization, large-scale, parameter estimation, Parameter identification, standards, PEtab, SBML, SED-ML, ODE, Simulation, steady state},
+	Title = {Challenges in the calibration of large-scale ordinary differential equation models},
+	Year = {2019}}
+
+@article{BallnusHug2017,
+	Author = {Ballnus, B. and Hug, S. and Hatz, K. and G{\"o}rlitz, L. and Hasenauer, J. and Theis, F. J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1186/s12918-017-0433-1},
+	Journal = {{BMC} Syst. Biol.},
+	Keywords = {parameter estimation, MCMC sampling, Bayesian parameter estimation, AMICI},
+	Month = {June},
+	Number = {63},
+	Title = {Comprehensive benchmarking of {Markov} chain {Monte} {Carlo} methods for dynamical systems},
+	Volume = {11},
+	Year = {2017},
+	Bdsk-Url-1 = {https://doi.org/10.1186/s12918-017-0433-1}}
+
+@article{BallnusSch2018,
+	Abstract = {Motivation: Mathematical models have become standard tools for the investigation of cellular processes and the unraveling of signal processing mechanisms. The parameters of these models are usually derived from the available data using optimization and sampling methods. However, the efficiency of these methods is limited by the properties of the mathematical model, e.g. non-identifiabilities, and the resulting posterior distribution. In particular, multi-modal distributions with long valleys or pronounced tails are difficult to optimize and sample. Thus, the developement or improvement of optimization and sampling methods is subject to ongoing research.
+Results: We suggest a region-based adaptive parallel tempering algorithm which adapts to the problem-specific posterior distributions, i.e. modes and valleys. The algorithm combines several established algorithms to overcome their individual shortcomings and to improve sampling efficiency. We assessed its properties for established benchmark problems and two ordinary differential equation models of biochemical reaction networks. The proposed algorithm outperformed state-of-the-art methods in terms of calculation efficiency and mixing. Since the algorithm does not rely on a specific problem structure, but adapts to the posterior distribution, it is suitable for a variety of model classes.
+Availability and implementation: The code is available both as Supplementary Material and in a Git repository written in MATLAB.
+Supplementary information: Supplementary data are available at Bioinformatics online.},
+	Author = {Ballnus, Benjamin and Schaper, Steffen and Theis, Fabian J and Hasenauer, Jan},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1093/bioinformatics/bty229},
+	Journal = {Bioinformatics},
+	Journal-Full = {Bioinformatics (Oxford, England)},
+	Month = {July},
+	Number = {13},
+	Pages = {i494--i501},
+	Pmc = {PMC6022572},
+	Pmid = {29949983},
+	Pst = {ppublish},
+	Title = {Bayesian parameter estimation for biochemical reaction networks using region-based adaptive parallel tempering},
+	Volume = {34},
+	Year = {2018},
+	Bdsk-Url-1 = {https://doi.org/10.1093/bioinformatics/bty229}}
+
+@article{BastCal2018,
+	Author = {Bast, Lisa and Calzolari, Filippo and Strasser, Michael and Hasenauer, Jan and Theis, Fabian J. and Ninkovic, Jovica and Marr, Carsten},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Journal = {Cell Reports},
+	Keywords = {stem cells, differentiation, stochastic modeling, parameter estimation, tree structure},
+	Title = {Subtle Changes in Clonal Dynamics Underlie the Age-Related Decline in Neurogenesis},
+	Year = {2018}}
+
+@article{BoigerHas2016,
+	Author = {Boiger, R. and Hasenauer, J. and Hross, S. and Kaltenbacher, B.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1088/0266-5611/32/12/125009},
+	Journal = {Inverse Prob.},
+	Keywords = {parameter estimation, profile likelihood, PDE, AMICI},
+	Month = {Dec.},
+	Number = {12},
+	Pages = {125009},
+	Title = {Integration based profile likelihood calculation for {PDE} constrained parameter estimation problems},
+	Volume = {32},
+	Year = {2016},
+	Bdsk-Url-1 = {https://doi.org/10.1088/0266-5611/32/12/125009}}
+
+@article{FiedlerRae2016,
+	Author = {Fiedler, A. and Raeth, S. and Theis, F. J. and Hausser, A. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1186/s12918-016-0319-7},
+	Journal = {{BMC} Syst. Biol.},
+	Keywords = {parameter estimation, steady state},
+	Month = {Aug.},
+	Number = {80},
+	Title = {Tailored parameter optimization methods for ordinary differential equation models with steady-state constraints},
+	Volume = {10},
+	Year = {2016},
+	Bdsk-Url-1 = {https://doi.org/10.1186/s12918-016-0319-7}}
+
+@Article{FischerFie2017,
+  author        = {Fischer, David S. and Fiedler, Anna K. and Kernfeld, Eric and Genga, Ryan M. J. and Bastidas-Ponce, Aim\'ee and Bakhti, Mostafa and Lickert, Heiko and Hasenauer, Jan and Maehr, Rene and Theis, Fabian J.},
+  title         = {Inferring population dynamics from single-cell RNA-sequencing time series data},
+  journal       = {Nature Biotechnology},
+  year          = {2019},
+  volume        = {37},
+  pages         = {461--468},
+  abstract      = {Cellular development has traditionally been described as a series of transitions between discrete cell states, such as the sequence of double negative, double positive and single positive stages in T-cell development. Recent advances in single cell transcriptomics suggest an alternative description of development, in which cells follow continuous transcriptomic trajectories. A cell{\textquoteright}s state along such a trajectory can be captured with pseudotemporal ordering, which however is not able to predict development of the system in real time. We present pseudodynamics, a mathematical framework that integrates time-series and genetic knock-out information with such transcriptome-based descriptions in order to describe and analyze the real-time evolution of the system. Pseudodynamics models the distribution of a cell population across a continuous cell state coordinate over time based on a stochastic differential equation along developmental trajectories and random switching between trajectories in branching regions. To illustrate feasibility, we use pseudodynamics to estimate cell-state-dependent growth and differentiation of thymic T-cell development. The model approximates a developmental potential function (Waddington{\textquoteright}s landscape) and suggests that thymic T-cell development is biphasic and not strictly deterministic before beta-selection. Pseudodynamics generalizes classical discrete population models to continuous states and thus opens possibilities such as probabilistic model selection to single cell genomics.},
+  bdsk-url-1    = {https://www.biorxiv.org/content/early/2017/11/14/219188},
+  bdsk-url-2    = {https://doi.org/10.1101/219188},
+  date-added    = {2019-03-19 23:04:09 +0100},
+  date-modified = {2019-07-26 12:14:33 +0200},
+  doi           = {10.1038/s41587-019-0088-0},
+  keywords      = {pseudo time; single-cell RNA-seq; PDE},
+  url           = {https://www.nature.com/articles/s41587-019-0088-0},
+}
+
+@article{FroehlichKal2017,
+	Author = {Fr\"ohlich, F. and Kaltenbacher, B. and Theis, F. J. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1371/journal.pcbi.1005331},
+	Journal = {{PLoS} Comput. Biol.},
+	Keywords = {parameter estimation; adjoint sensitivity},
+	Month = {Jan.},
+	Number = {1},
+	Pages = {e1005331},
+	Title = {Scalable Parameter Estimation for Genome-Scale Biochemical Reaction Networks},
+	Volume = {13},
+	Year = {2017},
+	Bdsk-Url-1 = {https://doi.org/10.1371/journal.pcbi.1005331}}
+
+@article{FroehlichKes2017,
+	Author = {Fr\"ohlich, Fabian and Kessler, Thomas and Weindl, Daniel and Shadrin, Alexey and Schmiester, Leonard and Hache, Hendrik and Muradyan, Artur and Schuette, Moritz and Lim, Ji-Hyun and Heinig, Matthias and Theis, Fabian and Lehrach, Hans and Wierling, Christoph and Lange, Bodo and Hasenauer, Jan},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1101/174094},
+	Eprint = {http://www.biorxiv.org/content/early/2017/08/09/174094.full.pdf},
+	Journal = {bioRxiv},
+	Keywords = {drug response; cancer; adjoint sensitivity; ccle},
+	Publisher = {Cold Spring Harbor Labs Journals},
+	Title = {Efficient parameterization of large-scale mechanistic models enables drug response prediction for cancer cell lines},
+	Url = {http://www.biorxiv.org/content/early/2017/08/09/174094},
+	Year = {2017},
+	Bdsk-Url-1 = {http://www.biorxiv.org/content/early/2017/08/09/174094},
+	Bdsk-Url-2 = {https://doi.org/10.1101/174094}}
+
+@article{FroehlichRei2018,
+	Abstract = {Single-cell time-lapse studies have advanced the quantitative understanding of cellular pathways and their inherent cell-to-cell variability. However, parameters retrieved from individual experiments are model dependent and their estimation is limited, if based on solely one kind of experiment. Hence, methods to integrate data collected under different conditions are expected to improve model validation and information content. Here we present a multi-experiment nonlinear mixed effect modeling approach for mechanistic pathway models, which allows the integration of multiple single-cell perturbation experiments. We apply this approach to the translation of green fluorescent protein after transfection using a massively parallel read-out of micropatterned single-cell arrays. We demonstrate that the integration of data from perturbation experiments allows the robust reconstruction of cell-to-cell variability, i.e., parameter densities, while each individual experiment provides insufficient information. Indeed, we show that the integration of the datasets on the population level also improves the estimates for individual cells by breaking symmetries, although each of them is only measured in one experiment. Moreover, we confirmed that the suggested approach is robust with respect to batch effects across experimental replicates and can provide mechanistic insights into the nature of batch effects. We anticipate that the proposed multi-experiment nonlinear mixed effect modeling approach will serve as a basis for the analysis of cellular heterogeneity in single-cell dynamics.},
+	Author = {Fr{\"o}hlich, Fabian and Reiser, Anita and Fink, Laura and Wosch{\'e}e, Daniel and Ligon, Thomas and Theis, Fabian Joachim and R{\"a}dler, Joachim Oskar and Hasenauer, Jan},
+	Da = {2018/12/10},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1038/s41540-018-0079-7},
+	Isbn = {2056-7189},
+	Journal = {npj Systems Biology and Applications},
+	Keywords = {mixed-effect models},
+	Number = {1},
+	Pages = {1},
+	Title = {Multi-experiment nonlinear mixed effect modeling of single-cell translation kinetics after transfection},
+	Ty = {JOUR},
+	Url = {https://doi.org/10.1038/s41540-018-0079-7},
+	Volume = {5},
+	Year = {2018},
+	Bdsk-Url-1 = {https://doi.org/10.1038/s41540-018-0079-7}}
+
+@article{FroehlichThe2016,
+	Author = {Fr\"ohlich, F. and Theis, F. J. and R\"{a}dler, J. O. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1093/bioinformatics/btw764},
+	Journal = {Bioinformatics},
+	Keywords = {events, logical model},
+	Month = {Apr.},
+	Number = {7},
+	Pages = {1049--1056},
+	Title = {Parameter estimation for dynamical systems with discrete events and logical operations},
+	Volume = {33},
+	Year = {2017},
+	Bdsk-Url-1 = {https://doi.org/10.1093/bioinformatics/btw764}}
+
+@article{FroehlichTho2016,
+	Author = {Fr\"ohlich, F. and Thomas, P. and Kazeroonian, A. and Theis, F. J. and Grima, R. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1371/journal.pcbi.1005030},
+	Journal = {{PLoS} Comput. Biol.},
+	Keywords = {SSE, moment equation, parameter estimation, stochastic modeling},
+	Month = {July},
+	Number = {7},
+	Pages = {e1005030},
+	Title = {Inference for Stochastic Chemical Kinetics Using Moment Equations and System Size Expansion},
+	Volume = {12},
+	Year = {2016},
+	Bdsk-Url-1 = {https://doi.org/10.1371/journal.pcbi.1005030}}
+
+@inproceedings{HrossFie2016,
+	Author = {Hross, S. and Fiedler, A. and Theis, F. J. and Hasenauer, J.},
+	Booktitle = {Proc. 6th {IFAC} Conf. Found. Syst. Biol. Eng.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1016/j.ifacol.2016.12.136},
+	Editor = {Findeisen, R. and Bullinger, E. and Balsa-Canto, E. and Bernaerts, K.},
+	Keywords = {PDE, parameter estimation, Pom1, cell division},
+	Number = {26},
+	Pages = {264--269},
+	Publisher = {IFAC-PapersOnLine},
+	Title = {Quantitative comparison of competing {PDE} models for {Pom1p} dynamics in fission yeast},
+	Volume = {49},
+	Year = {2016},
+	Bdsk-Url-1 = {https://doi.org/10.1016/j.ifacol.2016.12.136}}
+
+@article{KazeroonianFro2016,
+	Author = {Kazeroonian, A. and Fr{\"o}hlich, F. and Raue, A. and Theis, F. J. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1371/journal.pone.0146732},
+	Journal = {{PLoS} {ONE}},
+	Keywords = {CME, moment equation, moment closure, SSE, SSA, toolbox},
+	Month = {January},
+	Number = {1},
+	Pages = {e0146732},
+	Title = {{CERENA:} {Chemical} {REaction} Network {Analyzer -- A} Toolbox for the Simulation and Analysis of Stochastic Chemical Kinetics},
+	Volume = {11},
+	Year = {2016},
+	Bdsk-Url-1 = {https://doi.org/10.1371/journal.pone.0146732}}
+
+@article{KazeroonianThe2017,
+	Author = {Kazeroonian, A. and Theis, F. J. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1093/bioinformatics/btx249},
+	Journal = {Bioinformatics},
+	Keywords = {moment equation, scale-free networks, scaling, approximation},
+	Month = {July},
+	Number = {14},
+	Pages = {i293--i300},
+	Title = {A scalable moment-closure approximation for large-scale biochemical reaction networks},
+	Volume = {33},
+	Year = {2017},
+	Bdsk-Url-1 = {https://doi.org/10.1093/bioinformatics/btx249}}
+
+@inproceedings{LoosFie2016,
+	Author = {Loos, C. and Fiedler, A. and Hasenauer, J.},
+	Booktitle = {Proc. 13th Int. Conf. Comp. Meth. Syst. Biol.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1007/978-3-319-45177-0},
+	Editor = {Bartocci, E. and Lio, P. and Paoletti, N.},
+	Keywords = {parameter estimation, ODE, cell-to-cell variability},
+	Month = {Sept.},
+	Pages = {186--200},
+	Publisher = {Springer International Publishing},
+	Series = {Lecture Notes in Bioinformatics},
+	Title = {Parameter estimation for reaction rate equation constrained mixture models},
+	Year = {2016},
+	Bdsk-Url-1 = {https://doi.org/10.1007/978-3-319-45177-0}}
+
+@article{LoosKra2018,
+	Abstract = {Mathematical models are nowadays important tools for analyzing dynamics of cellular processes. The unknown model parameters are usually estimated from experimental data. These data often only provide information about the relative changes between conditions, hence, the observables contain scaling parameters. The unknown scaling parameters and corresponding noise parameters have to be inferred along with the dynamic parameters. The nuisance parameters often increase the dimensionality of the estimation problem substantially and cause convergence problems. In this manuscript, we propose a hierarchical optimization approach for estimating the parameters for ordinary differential equation (ODE) models from relative data. Our approach restructures the optimization problem into an inner and outer subproblem. These subproblems possess lower dimensions than the original optimization problem, and the inner problem can be solved analytically. We evaluated accuracy, robustness, and computational efficiency of the hierarchical approach by studying three signaling pathways. The proposed approach achieved better convergence than the standard approach and required a lower computation time. As the hierarchical optimization approach is widely applicable, it provides a powerful alternative to established approaches.},
+	Author = {Loos, Carolin and Krause, Sabrina and Hasenauer, Jan},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1093/bioinformatics/bty514},
+	Journal = {Bioinformatics},
+	Keywords = {Parameter estimation; ODE},
+	Month = {July},
+	Number = {24},
+	Pages = {4266--4273},
+	Title = {Hierarchical optimization for the efficient parametrization of {ODE} models},
+	Volume = {34},
+	Year = {2018},
+	Bdsk-Url-1 = {https://doi.org/10.1093/bioinformatics/bty514}}
+
+@inbook{LoosMar2015,
+	Author = {Loos, C. and Marr, C. and Theis, F. J. and Hasenauer, J.},
+	Chapter = {Approximate {B}ayesian {C}omputation for stochastic single-cell time-lapse data using multivariate test statistics},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Editor = {Roux, O. and Bourdon, J.},
+	Keywords = {ABC, single-cell time lapse, parameter estimation},
+	Month = {Sept.},
+	Pages = {52--63},
+	Publisher = {Springer International Publishing},
+	Series = {Lecture Notes in Computer Science},
+	Title = {Computational Methods in Systems Biology},
+	Volume = {9308},
+	Year = {2015}}
+
+@article{LoosMoe2018,
+	Author = {Loos, Carolin and Moeller, Katharina and Fr{\"o}hlich, Fabian and Hucho, Tim and Hasenauer, Jan},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1016/j.cels.2018.04.008},
+	Journal = {Cell Systems},
+	Keywords = {heterogeneity; single-cell; extrinsic noise; subpopulation},
+	Number = {5},
+	Pages = {593--603},
+	Publisher = {Elsevier},
+	Title = {A Hierarchical, Data-Driven Approach to Modeling Single-Cell Populations Predicts Latent Causes of Cell-To-Cell Variability},
+	Volume = {6},
+	Year = {2018},
+	Bdsk-Url-1 = {http://dx.doi.org/10.1016/j.cels.2018.04.008}}
+
+@article{MaierLoo2017,
+	Author = {Maier, C. and Loos, C. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-03-19 23:04:09 +0100},
+	Doi = {10.1093/bioinformatics/btw703},
+	Journal = {Bioinformatics},
+	Keywords = {Robust estimation, parameter estimation, outlier},
+	Month = {Mar.},
+	Number = {5},
+	Pages = {718--725},
+	Title = {Robust parameter estimation for dynamical systems from outlier-corrupted data},
+	Volume = {33},
+	Year = {2017},
+	Bdsk-Url-1 = {https://doi.org/10.1093/bioinformatics/btw703}}
+
+@article{SchaelteSta2018,
+	Author = {Sch{\"a}lte, Y. and Stapor, P. and Hasenauer, J.},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-07-26 09:04:30 +0200},
+	Journal = {FAC-PapersOnLine},
+	Keywords = {Optimization, Parameter estimation, derivative-free, derivatives, gradients},
+	Number = {19},
+	Pages = {98--101},
+	Title = {Evaluation of Derivative-Free Optimizers for Parameter Estimation in Systems Biology},
+	Volume = {51},
+	Year = {2018}}
+
+@article{StaporFro2018,
+	Author = {Stapor, Paul and Fr{\"o}hlich, Fabian and Hasenauer, Jan},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-07-26 09:06:44 +0200},
+	Journal = {Bioinformatics},
+	Keywords = {adjoint sensitivity, second order methods, hessian, optimization, profile likelihood, hybrid methods, profile integration},
+	Number = {13},
+	Pages = {i151--i159},
+	Publisher = {Oxford University Press},
+	Title = {Optimization and profile calculation of {ODE} models using second order adjoint sensitivity analysis},
+	Volume = {34},
+	Year = {2018}}
+
+@article{VillaverdeFro2018,
+	Abstract = {Motivation: Mechanistic kinetic models usually contain unknown parameters, which need to be estimated by optimizing the fit of the model to experimental data. This task can be computationally challenging due to the presence of local optima and ill-conditioning. While a variety of optimization methods have been suggested to surmount these issues, it is not obvious how to choose the best one for a given problem a priori, since many factors can influence their performance. A systematic comparison of methods that are suited to parameter estimation problems of sizes ranging from tens to hundreds of optimization variables is currently missing, and smaller studies indeed provided contradictory findings. Results: Here, we use a collection of benchmark problems to evaluate the performance of two families of optimization methods: (i) a multi-start of deterministic local searches; and (ii) a hybrid metaheuristic combining stochastic global search with deterministic local searches. A fair comparison is ensured through a collaborative evaluation, involving researchers applying each method on a daily basis, and a consideration of multiple performance metrics capturing the trade-off between computational efficiency and robustness. Our results show that, thanks to recent advances in the calculation of parametric sensitivities, a multi-start of gradient-based local methods is often a successful strategy, but a better performance can be obtained with a hybrid metaheuristic. The best performer is a combination of a global scatter search metaheuristic with an interior point local method, provided with gradients estimated with adjoint-based sensitivities. We provide an implementation of this novel method in an open-source software toolbox to render it available to the scientific community. Availability and Implementation: The code to reproduce the results is available at Zenodo https://doi.org/10.5281/zenodo.1160343},
+	Author = {Villaverde, Alejandro F. and Froehlich, Fabian and Weindl, Daniel and Hasenauer, Jan and Banga, Julio R},
+	Date-Added = {2019-03-19 23:04:09 +0100},
+	Date-Modified = {2019-07-26 09:07:31 +0200},
+	Journal = {Bioinformatics},
+	Keywords = {large-scale, benchmarking, optimization, MEIGO, scatter-search, multi-start},
+	Pages = {bty736},
+	Title = {Benchmarking optimization methods for parameter estimation in large kinetic models},
+	Year = {2018}}
+
+@article{DharmarajanKal2019,
+	Author = {Dharmarajan, Lekshmi and Kaltenbach, Hans-Michael and Rudolf, Fabian and Stelling, Joerg},
+	Comment = {doi: 10.1016/j.cels.2018.12.007},
+	Doi = {10.1016/j.cels.2018.12.007},
+	Issn = {2405-4712},
+	Journal = {Cell Systems},
+	Month = mar,
+	Number = {1},
+	Pages = {15--26.e11},
+	Publisher = {Elsevier},
+	Title = {A Simple and Flexible Computational Framework for Inferring Sources of Heterogeneity from Single-Cell Dynamics},
+	Url = {https://doi.org/10.1016/j.cels.2018.12.007},
+	Volume = {8},
+	Year = {2019},
+	Bdsk-Url-1 = {https://doi.org/10.1016/j.cels.2018.12.007}}
+
+@article{GreggSar2019,
+	__Markedentry = {[dweindl:]},
+	Abstract = {Cyclic GMP-AMP synthase (cGAS) has recently been identified as the primary protein that detects cytosolic double stranded DNA to invoke a type I interferon response. The cGAS pathway is vital in the recognition of DNA encoded viruses as well as self-DNA leaked from the nucleus of damaged cells. Currently, the dynamics regulating the cGAS pathway are poorly understood; limiting our knowledge of how DNA-induced immune responses are regulated. Using systems biology approaches, we formulated a mathematical model to describe the dynamics of this pathway and examine the resulting system-level emergent properties. Unknown model parameters were fit to data compiled from literature using a Parallel Tempering Markov Chain Monte Carlo (PT-MCMC) approach, resulting in an ensemble of parameterized models. A local sensitivity analysis demonstrated that parameter sensitivity trends across model ensembles were independent of the select parameterization. An in-silico knock-down of TREX1 found that the interferon response is highly robust, showing that complete inhibition is necessary to induce chemical conditions consistent with chronic inflammation. Lastly, we demonstrate that the model recapitulates interferon expression data resulting from small molecule inhibition of cGAS. Overall, the importance of this model is exhibited in its capacity to identify sensitive components of the cGAS pathway, generate testable hypotheses, and confirm experimental observations.},
+	Author = {Gregg, Robert W and Sarkar, Saumendra N and Shoemaker, Jason E},
+	Country = {England},
+	Doi = {10.1016/j.jtbi.2018.11.001},
+	Issn = {1095-8541},
+	Issn-Linking = {0022-5193},
+	Journal = {Journal of theoretical biology},
+	Keywords = {Interferon signaling; ODE modeling; Systems biology},
+	Month = feb,
+	Nlm-Id = {0376342},
+	Owner = {NLM},
+	Pages = {148--157},
+	Pii = {S0022-5193(18)30548-4},
+	Pmid = {30395807},
+	Pubmodel = {Print-Electronic},
+	Pubstatus = {ppublish},
+	Revised = {2018-12-23},
+	Title = {Mathematical modeling of the cGAS pathway reveals robustness of DNA sensing to TREX1 feedback.},
+	Volume = {462},
+	Year = {2019},
+	Bdsk-Url-1 = {https://doi.org/10.1016/j.jtbi.2018.11.001}}
+
+@article{PittBan2019,
+	__Markedentry = {[dweindl:6]},
+	Abstract = {Dynamic modelling is a core element in the systems biology approach to understanding complex biosystems. Here, we consider the problem of parameter estimation in models of biological oscillators described by deterministic nonlinear differential equations. These problems can be extremely challenging due to several common pitfalls: (i) a lack of prior knowledge about parameters (i.e. massive search spaces), (ii) convergence to local optima (due to multimodality of the cost function), (iii) overfitting (fitting the noise instead of the signal) and (iv) a lack of identifiability. As a consequence, the use of standard estimation methods (such as gradient-based local ones) will often result in wrong solutions. Overfitting can be particularly problematic, since it produces very good calibrations, giving the impression of an excellent result. However, overfitted models exhibit poor predictive power. Here, we present a novel automated approach to overcome these pitfalls. Its workflow makes use of two sequential optimisation steps incorporating three key algorithms: (1) sampling strategies to systematically tighten the parameter bounds reducing the search space, (2) efficient global optimisation to avoid convergence to local solutions, (3) an advanced regularisation technique to fight overfitting. In addition, this workflow incorporates tests for structural and practical identifiability. We successfully evaluate this novel approach considering four difficult case studies regarding the calibration of well-known biological oscillators (Goodwin, FitzHugh-Nagumo, Repressilator and a metabolic oscillator). In contrast, we show how local gradient-based approaches, even if used in multi-start fashion, are unable to avoid the above-mentioned pitfalls. Our approach results in more efficient estimations (thanks to the bounding strategy) which are able to escape convergence to local optima (thanks to the global optimisation approach). Further, the use of regularisation allows us to avoid overfitting, resulting in more generalisable calibrated models (i.e. models with greater predictive power).},
+	Author = {Pitt, Jake Alan and Banga, Julio R},
+	Citation-Subset = {IM},
+	Completed = {2019-03-13},
+	Country = {England},
+	Doi = {10.1186/s12859-019-2630-y},
+	Issn = {1471-2105},
+	Issn-Linking = {1471-2105},
+	Issue = {1},
+	Journal = {BMC bioinformatics},
+	Keywords = {Algorithms; Biological Clocks; Calibration; Humans; Metabolic Networks and Pathways; Models, Biological; Signal Transduction; Systems Biology, methods; Dynamic modelling; Global optimisation; Parameter bounding; Parameter estimation; Regularisation},
+	Month = feb,
+	Nlm-Id = {100965194},
+	Owner = {NLM},
+	Pages = {82},
+	Pii = {10.1186/s12859-019-2630-y},
+	Pmc = {PMC6377730},
+	Pmid = {30770736},
+	Pubmodel = {Electronic},
+	Pubstatus = {epublish},
+	Revised = {2019-03-13},
+	Title = {Parameter estimation in models of biological oscillators: an automated regularised estimation approach.},
+	Volume = {20},
+	Year = {2019},
+	Bdsk-Url-1 = {https://doi.org/10.1186/s12859-019-2630-y}}
+
+@article{KaltenbacherPed2018,
+	Abstract = {In this paper we consider the problem of identifying parameters in stochastic differential equations. For this purpose, we transform the originally stochastic and nonlinear state equation to a deterministic linear partial differential equation for the transition probability density. We provide an appropriate likelihood cost function for parameter fitting, and derive an adjoint based approach for the computation of its gradient.},
+	Author = {Barbara Kaltenbacher and Barbara Pedretscher},
+	Doi = {https://doi.org/10.1016/j.jmaa.2018.05.048},
+	Issn = {0022-247X},
+	Journal = {Journal of Mathematical Analysis and Applications},
+	Keywords = {Parameter identification, Stochastic differential equation, State space model, Likelihood function, Adjoint method},
+	Number = {2},
+	Pages = {872 - 884},
+	Title = {Parameter estimation in SDEs via the Fokker--Planck equation: Likelihood function and adjoint based gradient computation},
+	Url = {http://www.sciencedirect.com/science/article/pii/S0022247X18304414},
+	Volume = {465},
+	Year = {2018},
+	Bdsk-Url-1 = {http://www.sciencedirect.com/science/article/pii/S0022247X18304414},
+	Bdsk-Url-2 = {https://doi.org/10.1016/j.jmaa.2018.05.048}}
+
+@InProceedings{NousiainenInt2019,
+  author    = {Nousiainen, Kari and Intosalmi, Jukka and L{\"a}hdesm{\"a}ki, Harri},
+  title     = {A Mathematical Model for Enhancer Activation Kinetics During Cell Differentiation},
+  booktitle = {Algorithms for Computational Biology},
+  year      = {2019},
+  editor    = {Holmes, Ian and Mart{\'\i}n-Vide, Carlos and Vega-Rodr{\'\i}guez, Miguel A.},
+  pages     = {191--202},
+  address   = {Cham},
+  publisher = {Springer International Publishing},
+  abstract  = {Cell differentiation and development are for a great part steered by cell type specific enhancers. Transcription factor (TF) binding to an enhancer together with DNA looping result in transcription initiation. In addition to binding motifs for TFs, enhancer regions typically contain specific histone modifications. This information has been used to detect enhancer regions and classify them into different subgroups. However, it is poorly understood how TF binding and histone modifications are causally connected and what kind of molecular dynamics steer the activation process.},
+  isbn      = {978-3-030-18174-1},
+}
+
+@Article{SchmiesterSch2019,
+  author   = {Schmiester, Leonard and Schälte, Yannik and Fröhlich, Fabian and Hasenauer, Jan and Weindl, Daniel},
+  title    = {{Efficient parameterization of large-scale dynamic models based on relative measurements}},
+  journal  = {Bioinformatics},
+  year     = {2019},
+  month    = {07},
+  issn     = {1367-4803},
+  abstract = {{Mechanistic models of biochemical reaction networks facilitate the quantitative understanding of biological processes and the integration of heterogeneous datasets. However, some biological processes require the consideration of comprehensive reaction networks and therefore large-scale models. Parameter estimation for such models poses great challenges, in particular when the data are on a relative scale.Here, we propose a novel hierarchical approach combining (i) the efficient analytic evaluation of optimal scaling, offset, and error model parameters with (ii) the scalable evaluation of objective function gradients using adjoint sensitivity analysis. We evaluate the properties of the methods by parameterizing a pan-cancer ordinary differential equation model (\\&gt;1000 state variables, \\&gt;4000 parameters) using relative protein, phospho-protein and viability measurements. The hierarchical formulation improves optimizer performance considerably. Furthermore, we show that this approach allows estimating error model parameters with negligible computational overhead when no experimental estimates are available, providing an unbiased way to weight heterogeneous data. Overall, our hierarchical formulation is applicable to a wide range of models, and allows for the efficient parameterization of large-scale models based on heterogeneous relative measurements.Supplementary information are available at Bioinformatics online. Supplementary code and data are available online at http://doi.org/10.5281/zenodo.3254429 and http://doi.org/10.5281/zenodo.3254441.}},
+  doi      = {10.1093/bioinformatics/btz581},
+  eprint   = {http://oup.prod.sis.lan/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btz581/29004243/btz581.pdf},
+  url      = {https://doi.org/10.1093/bioinformatics/btz581},
+}
+
+@Comment{jabref-meta: databaseType:bibtex;}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/code_review_guide.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/code_review_guide.md
new file mode 100644
index 0000000000000000000000000000000000000000..a842502c5831de04bf13ecf5c9431c7f45a5efab
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/code_review_guide.md
@@ -0,0 +1,59 @@
+# Code review
+
+A guide for reviewing code and having your code reviewed by others.
+
+## Everyone
+
+* Don't be too protective of your code
+* Accept that, to a large extent, coding decisions are a matter of personal 
+  preference
+* Don't get personal
+* Ask for clarification
+* Avoid strong language
+* Try to understand your counterpart's perspective
+* Clarify how strong you feel about each discussion point
+
+## Reviewing code 
+
+* If there are no objective advantages, don't force your style on others
+* Ask questions instead of making demands
+* Assume the author gave his best
+* Mind the scope (many things are nice to have, but might be out of scope 
+  of the current change - open a new issue) 
+* The goal is "good enough", not "perfect" 
+* Be constructive
+* You do not always have to request changes 
+
+## Having your code reviewed 
+
+* Don't take it personal - the review is on the code, not on you
+* Code reviews take time, appreciate the reviewer's comments
+* Assume the reviewer did his best (but might still be wrong)
+* Keep code changes small (e.g. separate wide reformatting from actual code 
+  changes to facility review)
+* If the reviewer does not understand your code, probably many others won't 
+  either
+
+## Checklist
+
+* [ ] Adherence to project-specific style guide
+* [ ] The code is self-explanatory
+* [ ] The code is concise / expressive
+* [ ] Meaningful identifiers are used
+* [ ] Corner-cases are covered, cases not covered fail loudly
+* [ ] The code can be expected to scale well (enough)
+* [ ] The code is well documented (e.g., input, operation, output), but 
+      without trivial comments
+* [ ] The code is [SOLID](https://en.wikipedia.org/wiki/SOLID)
+* [ ] New code is added in the most meaningful place (i.e. matches the 
+      current architecture)
+* [ ] No magic numbers
+* [ ] No hard-coded values that should be user inputs
+* [ ] No dead code left
+* [ ] The changes make sense
+* [ ] The changes are not obviously degrading performance
+* [ ] There is no duplicated code
+* [ ] The API is convenient
+* [ ] Code block length and complexity is adequate
+* [ ] Spelling okay
+* [ ] The code is tested
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/development.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/development.md
new file mode 100644
index 0000000000000000000000000000000000000000..eedfeb5d882466980f36d472e0c31a411cf4b326
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/development.md
@@ -0,0 +1,135 @@
+# AMICI developer's guide
+
+This document contains information for AMICI developers, not too relevant to
+regular users.
+
+
+## Branches / releases
+
+AMICI roughly follows the
+[GitFlow](https://nvie.com/posts/a-successful-git-branching-model/). All new
+contributions are merged into `develop`. These changes are regularly merged
+into `master` as new releases. For release versioning we are trying to follow
+[semantic versioning](https://semver.org/). New releases are created on Github
+and are automatically deployed to
+[Zenodo](https://zenodo.org/record/3362453#.XVwJ9vyxVMA) for archiving and to
+obtain a digital object identifier (DOI) to make them citable.
+Furthermore, our [CI pipeline](documentation/CI.md) will automatically create
+and deploy a new release on [PyPI](https://pypi.org/project/amici/).
+
+We try to keep a clean git history. Therefore, feature pull requests are
+squash-merged to `develop`. Merging of release branches to master is done via
+merge commits.   
+
+
+## When starting to work on some issue
+
+When starting to work on some Github issue, please assign yourself to let other
+developers know that you are working on it to avoid duplicate work. If the
+respective issue is not completely clear, it is generally a good idea to ask
+for clarification before starting to work on it.
+
+If you want to work on something new, please create a Github issue first.
+
+
+## Code contributions
+
+When making code contributions, please follow our style guide and the process
+described below:
+
+* Check if you agree to release your contribution under the conditions provided
+  in `LICENSE`. By opening a pull requests you confirm us that you do agree.
+  
+* Start a new branch from `develop` (on your fork, or at the main
+  repository if you have access)
+
+* Implement your changes
+
+* Submit a pull request to the `develop` branch
+
+* Make sure your code is documented appropriately
+
+  * Run `scripts/run-doxygen.sh` to check completeness of your documentation
+
+* Make sure your code is compatible with C++11, `gcc` and `clang`
+  (our CI pipeline will do this for you)
+
+* When adding new functionality, please also provide test cases
+  (see `tests/cpputest/` and [documentation/CI.md](documentation/CI.md))
+
+* Write meaningful commit messages
+
+* Run all tests to ensure nothing was broken
+
+  * Run `scripts/buildAll.sh && scripts/run-cpputest.sh`.
+  
+  * If you made changes to the Matlab or C++ code and have a Matlab license,
+    please also run `tests/cpputest/wrapTestModels.m` and `tests/testModels.m`
+
+  * If you made changes to the Python or C++ code,
+    run `make python-tests` in `build`
+
+* When all tests are passing and you think your code is ready to merge,
+  request a code review 
+  (see also our [code review guideline](documentation/code_review_guide.md))
+
+* Wait for feedback. If you do not receive feedback to your pull request within
+  a week, please give us a friendly reminder.
+
+
+### Style guide
+
+
+#### General
+
+* All files and functions should come with file-level and function-level
+  documentation.
+  
+* All new functionality should be covered by unit or integration tests. Runtime
+  of those tests should be kept as short as possible. 
+
+
+#### Python
+
+* We want to be compatible with Python 3.6
+
+* For the Python code we want to follow 
+  [PEP8](https://www.python.org/dev/peps/pep-0008/). Although this is not the
+  case for all existing code, any new contributions should do so. 
+
+* We use Python [type hints](https://docs.python.org/3/library/typing.html)
+  for all functions. In Python code type hints should be used instead of
+  doxygen `@type`. (All legacy `@type` attributes are to be removed.)
+    
+  For function docstrings, follow this format:
+  
+  ```
+  """One-line description.
+  
+  Possible a more detailed description
+
+  Arguments:
+      Argument1: This needs to start on the same line, otherwise the current
+          doxygen filter will fail.    
+
+      Returns:
+          Return value
+
+      Raises:
+          SomeError in case of some error.
+  """
+  ```
+
+
+#### C++
+
+* We follow C++11
+
+* We want to maintain compatibility with g++, clang and the Intel C++ compiler 
+
+* *Details to be defined*
+
+
+#### Matlab
+
+*To be defined*
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/gfx/amici_workflow.svg b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/gfx/amici_workflow.svg
new file mode 100644
index 0000000000000000000000000000000000000000..cddc2e8ab7380743c4ee6a77f5b1d451415368f0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/gfx/amici_workflow.svg
@@ -0,0 +1,2168 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:i="http://ns.adobe.com/AdobeIllustrator/10.0/"
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="294.54358mm"
+   height="107.54767mm"
+   viewBox="0 0 294.54358 107.54766"
+   version="1.1"
+   id="svg11110"
+   inkscape:version="0.92.4 (5da689c313, 2019-01-14)"
+   sodipodi:docname="amici_workflow.svg"
+   inkscape:export-filename="/home/dweindl/src/AMICI-devel/documentation/gfx/amici_workflow.png"
+   inkscape:export-xdpi="90"
+   inkscape:export-ydpi="90">
+  <defs
+     id="defs11104">
+    <marker
+       inkscape:isstock="true"
+       style="overflow:visible"
+       id="marker33673"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Arrow2Lend">
+      <path
+         inkscape:connector-curvature="0"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         id="path33671" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker23227"
+       style="overflow:visible"
+       inkscape:isstock="true">
+      <path
+         id="path23225"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker22567"
+       style="overflow:visible"
+       inkscape:isstock="true">
+      <path
+         id="path22565"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:isstock="true"
+       style="overflow:visible"
+       id="marker22465"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Arrow2Lend"
+       inkscape:collect="always">
+      <path
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         id="path22463"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker22255"
+       style="overflow:visible"
+       inkscape:isstock="true"
+       inkscape:collect="always">
+      <path
+         id="path22253"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker21832"
+       style="overflow:visible"
+       inkscape:isstock="true">
+      <path
+         id="path21830"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker21706"
+       style="overflow:visible"
+       inkscape:isstock="true">
+      <path
+         id="path21704"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker21324"
+       style="overflow:visible"
+       inkscape:isstock="true"
+       inkscape:collect="always">
+      <path
+         id="path21322"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:isstock="true"
+       style="overflow:visible"
+       id="marker21180"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Arrow2Lend"
+       inkscape:collect="always">
+      <path
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         id="path21178"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:isstock="true"
+       style="overflow:visible"
+       id="marker20369"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Arrow2Lend">
+      <path
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         id="path20367"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend"
+       style="overflow:visible"
+       inkscape:isstock="true"
+       inkscape:collect="always">
+      <path
+         id="path12310"
+         style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.625;stroke-linejoin:round;stroke-opacity:1"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <linearGradient
+       id="XMLID_5_"
+       gradientUnits="userSpaceOnUse"
+       x1="33.799301"
+       y1="-6.6968002"
+       x2="34.244301"
+       y2="34.067001">
+      <stop
+         offset="0"
+         style="stop-color:#FFFFFF"
+         id="stop5544" />
+      <stop
+         offset="0.2236"
+         style="stop-color:#FAFAFB"
+         id="stop5546" />
+      <stop
+         offset="0.4981"
+         style="stop-color:#EBEDEF"
+         id="stop5548" />
+      <stop
+         offset="0.798"
+         style="stop-color:#D2D7DC"
+         id="stop5550" />
+      <stop
+         offset="1"
+         style="stop-color:#BDC5CC"
+         id="stop5552" />
+    </linearGradient>
+    <radialGradient
+       id="XMLID_6_"
+       cx="-104.4189"
+       cy="-41.148899"
+       r="20.6565"
+       gradientTransform="matrix(1.0223,0,0,0.9987,120.8042,52.6105)"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         offset="0"
+         style="stop-color:#BCE6FB"
+         id="stop5561" />
+      <stop
+         offset="0.042"
+         style="stop-color:#B7E4FB"
+         id="stop5563" />
+      <stop
+         offset="0.0935"
+         style="stop-color:#A8E0FA"
+         id="stop5565" />
+      <stop
+         offset="0.1501"
+         style="stop-color:#8FD9F8"
+         id="stop5567" />
+      <stop
+         offset="0.2099"
+         style="stop-color:#6CCFF6"
+         id="stop5569" />
+      <stop
+         offset="0.2135"
+         style="stop-color:#6ACEF6"
+         id="stop5571" />
+      <stop
+         offset="0.3103"
+         style="stop-color:#65C9F3"
+         id="stop5573" />
+      <stop
+         offset="0.4293"
+         style="stop-color:#56BCEB"
+         id="stop5575" />
+      <stop
+         offset="0.5598"
+         style="stop-color:#3DA6DD"
+         id="stop5577" />
+      <stop
+         offset="0.6976"
+         style="stop-color:#1A88CA"
+         id="stop5579" />
+      <stop
+         offset="0.7865"
+         style="stop-color:#0071BC"
+         id="stop5581" />
+      <stop
+         offset="1"
+         style="stop-color:#0054A6"
+         id="stop5583" />
+    </radialGradient>
+    <radialGradient
+       id="XMLID_7_"
+       cx="-39.161598"
+       cy="-123.4775"
+       r="7.8785"
+       gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         offset="0"
+         style="stop-color:#BCE6FB"
+         id="stop5590" />
+      <stop
+         offset="0.042"
+         style="stop-color:#B7E4FB"
+         id="stop5592" />
+      <stop
+         offset="0.0935"
+         style="stop-color:#A8E0FA"
+         id="stop5594" />
+      <stop
+         offset="0.1501"
+         style="stop-color:#8FD9F8"
+         id="stop5596" />
+      <stop
+         offset="0.2099"
+         style="stop-color:#6CCFF6"
+         id="stop5598" />
+      <stop
+         offset="0.2135"
+         style="stop-color:#6ACEF6"
+         id="stop5600" />
+      <stop
+         offset="0.3103"
+         style="stop-color:#65C9F3"
+         id="stop5602" />
+      <stop
+         offset="0.4293"
+         style="stop-color:#56BCEB"
+         id="stop5604" />
+      <stop
+         offset="0.5598"
+         style="stop-color:#3DA6DD"
+         id="stop5606" />
+      <stop
+         offset="0.6976"
+         style="stop-color:#1A88CA"
+         id="stop5608" />
+      <stop
+         offset="0.7865"
+         style="stop-color:#0071BC"
+         id="stop5610" />
+      <stop
+         offset="1"
+         style="stop-color:#0054A6"
+         id="stop5612" />
+    </radialGradient>
+    <radialGradient
+       id="XMLID_8_"
+       cx="-38.2202"
+       cy="-135.5493"
+       r="8.8347998"
+       gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         offset="0"
+         style="stop-color:#BCE6FB"
+         id="stop5617" />
+      <stop
+         offset="0.042"
+         style="stop-color:#B7E4FB"
+         id="stop5619" />
+      <stop
+         offset="0.0935"
+         style="stop-color:#A8E0FA"
+         id="stop5621" />
+      <stop
+         offset="0.1501"
+         style="stop-color:#8FD9F8"
+         id="stop5623" />
+      <stop
+         offset="0.2099"
+         style="stop-color:#6CCFF6"
+         id="stop5625" />
+      <stop
+         offset="0.2135"
+         style="stop-color:#6ACEF6"
+         id="stop5627" />
+      <stop
+         offset="0.3103"
+         style="stop-color:#65C9F3"
+         id="stop5629" />
+      <stop
+         offset="0.4293"
+         style="stop-color:#56BCEB"
+         id="stop5631" />
+      <stop
+         offset="0.5598"
+         style="stop-color:#3DA6DD"
+         id="stop5633" />
+      <stop
+         offset="0.6976"
+         style="stop-color:#1A88CA"
+         id="stop5635" />
+      <stop
+         offset="0.7865"
+         style="stop-color:#0071BC"
+         id="stop5637" />
+      <stop
+         offset="1"
+         style="stop-color:#0054A6"
+         id="stop5639" />
+    </radialGradient>
+    <linearGradient
+       id="linearGradient2795">
+      <stop
+         id="stop2797"
+         offset="0"
+         style="stop-color:#b8b8b8;stop-opacity:0.49803922;" />
+      <stop
+         id="stop2799"
+         offset="1"
+         style="stop-color:#7f7f7f;stop-opacity:0;" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4671">
+      <stop
+         id="stop4673"
+         offset="0"
+         style="stop-color:#ffd43b;stop-opacity:1;" />
+      <stop
+         id="stop4675"
+         offset="1"
+         style="stop-color:#ffe873;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient4689">
+      <stop
+         id="stop4691"
+         offset="0"
+         style="stop-color:#5a9fd4;stop-opacity:1;" />
+      <stop
+         id="stop4693"
+         offset="1"
+         style="stop-color:#306998;stop-opacity:1;" />
+    </linearGradient>
+    <linearGradient
+       y2="137.27299"
+       x2="112.03144"
+       y1="192.35176"
+       x1="150.96111"
+       gradientTransform="matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)"
+       gradientUnits="userSpaceOnUse"
+       id="linearGradient1475"
+       xlink:href="#linearGradient4671"
+       inkscape:collect="always" />
+    <linearGradient
+       y2="114.39767"
+       x2="135.66525"
+       y1="20.603781"
+       x1="26.648937"
+       gradientTransform="matrix(0.562541,0,0,0.567972,-9.399749,-5.305317)"
+       gradientUnits="userSpaceOnUse"
+       id="linearGradient1478"
+       xlink:href="#linearGradient4689"
+       inkscape:collect="always" />
+    <radialGradient
+       r="29.036913"
+       fy="132.28575"
+       fx="61.518883"
+       cy="132.28575"
+       cx="61.518883"
+       gradientTransform="matrix(2.382716e-8,-0.296405,1.43676,4.683673e-7,-128.544,150.5202)"
+       gradientUnits="userSpaceOnUse"
+       id="radialGradient1480"
+       xlink:href="#linearGradient2795"
+       inkscape:collect="always" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_5_"
+       id="linearGradient20555"
+       gradientUnits="userSpaceOnUse"
+       x1="33.799301"
+       y1="-6.6968002"
+       x2="34.244301"
+       y2="34.067001" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_6_"
+       id="radialGradient20557"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0223,0,0,0.9987,120.8042,52.6105)"
+       cx="-104.4189"
+       cy="-41.148899"
+       r="20.6565" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_7_"
+       id="radialGradient20559"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+       cx="-39.161598"
+       cy="-123.4775"
+       r="7.8785" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_8_"
+       id="radialGradient20561"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+       cx="-38.2202"
+       cy="-135.5493"
+       r="8.8347998" />
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_5_"
+       id="linearGradient20631"
+       gradientUnits="userSpaceOnUse"
+       x1="33.799301"
+       y1="-6.6968002"
+       x2="34.244301"
+       y2="34.067001" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_6_"
+       id="radialGradient20633"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0223,0,0,0.9987,120.8042,52.6105)"
+       cx="-104.4189"
+       cy="-41.148899"
+       r="20.6565" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_7_"
+       id="radialGradient20635"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+       cx="-39.161598"
+       cy="-123.4775"
+       r="7.8785" />
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#XMLID_8_"
+       id="radialGradient20637"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+       cx="-38.2202"
+       cy="-135.5493"
+       r="8.8347998" />
+    <linearGradient
+       id="linearGradient51087">
+      <stop
+         offset="0"
+         style="stop-color:#ffffff;stop-opacity:1"
+         id="stop51089" />
+      <stop
+         offset="1"
+         style="stop-color:#ffffff;stop-opacity:0"
+         id="stop51091" />
+    </linearGradient>
+    <linearGradient
+       gradientUnits="userSpaceOnUse"
+       xlink:href="#linearGradient51087"
+       id="linearGradient56927"
+       y2="182.21277"
+       x2="43.330002"
+       y1="182.21277"
+       x1="123.53376" />
+    <mask
+       id="Mask-5">
+      <rect
+         style="fill:url(#linearGradient56927)"
+         id="rect3259-4"
+         y="182.21277"
+         x="43.331245"
+         height="185.81773"
+         width="81.202515" />
+      <rect
+         style="fill:#ffffff"
+         id="rect3261-2"
+         y="0"
+         x="123.53376"
+         height="800"
+         width="800" />
+    </mask>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.98994949"
+     inkscape:cx="597.91329"
+     inkscape:cy="-28.709503"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="2560"
+     inkscape:window-height="1340"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0" />
+  <metadata
+     id="metadata11107">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(31.865322,-26.168742)">
+    <g
+       id="g27950"
+       transform="translate(0,3.0849579)">
+      <rect
+         style="opacity:0.79018399;fill:#f2f2f2;fill-opacity:1;stroke:#f9f9f9;stroke-width:0.19996412;stroke-linecap:round;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:0.59989232, 0.59989232;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect25369"
+         width="253.77472"
+         height="25.000847"
+         x="8.8035564"
+         y="50.711193"
+         ry="4.95432" />
+      <g
+         transform="matrix(0.06434095,0,0,0.06434095,-22.513419,52.538507)"
+         id="g12153">
+        <path
+           style="fill:#00599c"
+           inkscape:connector-curvature="0"
+           d="M 302.107,258.262 C 304.508,254.103 306,249.417 306,245.209 V 99.14 c 0,-4.208 -1.49,-8.893 -3.892,-13.052 L 153,172.175 Z"
+           id="path12119" />
+        <path
+           style="fill:#004482"
+           inkscape:connector-curvature="0"
+           d="m 166.25,341.193 126.5,-73.034 c 3.644,-2.104 6.956,-5.737 9.357,-9.897 L 153,172.175 3.893,258.263 c 2.401,4.159 5.714,7.793 9.357,9.896 l 126.5,73.034 c 7.287,4.208 19.213,4.208 26.5,0 z"
+           id="path12121" />
+        <path
+           style="fill:#659ad2"
+           inkscape:connector-curvature="0"
+           d="m 302.108,86.087 c -2.402,-4.16 -5.715,-7.793 -9.358,-9.897 L 166.25,3.156 c -7.287,-4.208 -19.213,-4.208 -26.5,0 L 13.25,76.19 C 5.962,80.397 0,90.725 0,99.14 v 146.069 c 0,4.208 1.491,8.894 3.893,13.053 L 153,172.175 Z"
+           id="path12123" />
+        <g
+           id="g12127">
+          <path
+             style="fill:#ffffff"
+             inkscape:connector-curvature="0"
+             d="m 153,274.175 c -56.243,0 -102,-45.757 -102,-102 0,-56.243 45.757,-102 102,-102 36.292,0 70.139,19.53 88.331,50.968 l -44.143,25.544 C 188.083,130.951 171.15,121.175 153,121.175 c -28.122,0 -51,22.878 -51,51 0,28.121 22.878,51 51,51 18.152,0 35.085,-9.776 44.191,-25.515 l 44.143,25.543 c -18.192,31.441 -52.04,50.972 -88.334,50.972 z"
+             id="path12125" />
+        </g>
+        <g
+           id="g12131">
+          <polygon
+             style="fill:#ffffff"
+             points="221,177.841 232.334,177.841 232.334,189.175 243.666,189.175 243.666,177.841 255,177.841 255,166.508 243.666,166.508 243.666,155.175 232.334,155.175 232.334,166.508 221,166.508 "
+             id="polygon12129" />
+        </g>
+        <g
+           id="g12135">
+          <polygon
+             style="fill:#ffffff"
+             points="263.5,177.841 274.834,177.841 274.834,189.175 286.166,189.175 286.166,177.841 297.5,177.841 297.5,166.508 286.166,166.508 286.166,155.175 274.834,155.175 274.834,166.508 263.5,166.508 "
+             id="polygon12133" />
+        </g>
+      </g>
+      <image
+         width="22.966059"
+         height="7.523427"
+         preserveAspectRatio="none"
+         xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAGLUAAAgYCAYAAACbC9dwAAAABGdBTUEAALGOfPtRkwAAACBjSFJN AAB6JQAAgIMAAPn/AACA6AAAdTAAAOpgAAA6lwAAF2+XqZnUAA8Ug0lEQVR4nOzBMQEAAAjAIO0f er6GALYaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+E4AAdi7YxoAAACGQZl/0/2nAYwwqQUAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAvAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAA AAAAQJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHY uwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJ JLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA mARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/ 9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0AAAAAAAAA AAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMBAAAA AEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg7w4E AAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/9QArlEhS CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0AAAAAAAAAAAAAAAAA AAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBJA APbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMBAAAAAEH+1gOs UCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg7w4EAAAAAAT5 Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/9QArlEhSCwAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBJAAPbuQAAA AABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMBAAAAAEH+1gOsUCJJLQAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAdi7 AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg7w4EAAAAAAT5Ww+wQokk tQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/9QArlEhSCwAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACY BGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1 ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAA Qf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQA AAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFIL AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA 9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQ IkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ACYB2LsDAQAAAABB/tYDrFAiSS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlb D7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAA AECQv/UAK5RIUgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAGASQAD27kAAAAAAQJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsD AQAAAABB/tYDrFAiSS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAJgHYuwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgE YO8OBAAAAAAE+VsPsEKJJLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UA K5RIUgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AGASQAD27kAAAAAAQJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB /tYDrFAiSS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAJgHYuwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAA AAAE+VsPsEKJJLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD2 7kAAAAAAQJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAi SS0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA JgHYuwMBAAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsP sEKJJLUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAmARg7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAA QJC/9QArlEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LsDAQAAAABB/tYDrFAiSS0AAAAA AAAAAAAAAAAAAAAAAAAAAAAAAACYBGDvDgQAAAAABPlbD7BCiSS1AAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAYBJAAPbuQAAAAABAkL/1ACuUSFILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgHYuwMB AAAAAEH+1gOsUCJJLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgEYO8OBAAAAAAE+VsPsEKJJLUA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgEkAA9u5AAAAAAECQv/UAK5RIUgsAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAmAdi7AwEAAAAAQf7WA6xQIkktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmARg 7w4EAAAAAAT5Ww+wQokktQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGASQAD27kAAAAAAQJC/9QAr lEhSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYB2LtDGwAAGARg4f+n98AcZslaT/AYnFoAAADA A0mqeFlvfDjOPgQAAAAAAAAAAAAAAAAAAAAAAAAAbEYAAdi7YyIAABgEYkv9a66HMpQhEcDh4Of7 AAAAAFAjjVdcdtUUAAAAAAAAAAAAAAAAAAAAAAAAAABKrQDs3TENAAAMwzD+rPf32zFpUm0EYRBT CwAAAOh0NbDYyg6TCwAAAAAAAAAAAAAAAAAAAAAAAACAJ0YAAdi7YxoAAAAEQP1bG8HXTSiC1AIA AAA+rCQWjeQCAAAAAAAAAAAAAAAAAAAAAAAAAGBEBGDvDkoAAGAYiFH/pvedgo1CoqDUwIlaAAAA 8C5p6S1Uaj937xe4AAAAAAAAAAAAAAAAAAAAAAAAAAA4NAKwdwc1AAAwCMT8u95rBhbCY2kFEByc qAUAAAD8lI5ZXPeSIYr9IG4BAAAAAAAAAAAAAAAAAAAAAAAAAFAwArB3xyYAACEQBPn+mzZ/BBWM ZCY+roUVtQAAAIBbNmIW3Y9s9wcnOpupt/ABAAAAAAAAAAAAAAAAAAAAAAAAAEAhBGDvjk0AAGEg AIKt+0/qAJrGUjGCjdzBd8mv8EYtAAAA4B+ZQYsaKZF28JfpXd32zc3NQMXsMG4BAAAAAAAAAAAA AAAAAAAAAAAAAPDIEIC9OzYBEIaiKEpWSqtrZEnn0N6RfIKt+LWUc+A2H5IVnlELAAAA+IfK8MRI U5pTv2572tKaloe/3oxbnKpDFu3mXtE+vAEAAAAAAAAAAAAAAAAAAAAAAAAAoOAQgL07tgEQhoEA KC/DIKzDPtmHLdgmuI6CQkJBcyd9F7lw+YUTtbr7CAAAwL8iZv9KoDFa4JYpmX3w7swcmevl3BW9 IuKpnJgpLRQcH+iHAAAAAAAAAAAAAAAAAAAAAAAAAICeWwD27tAIgBCIAaCknu+/CiS1vOHwiAwI zO5M7J2PiVELAAAAnjNqcSUZtOiVFt77K19lXPxcksIhHbhIywslxyH9EAAAAAAAAAAAAAAAAAAA AAAAAACwMwVg745NAABhIACK4P6VuK7aCoqIaHMH3yRFssHH3w8AAAAAx3bKJUrYL7ToUksebtzI 7P9xv5oBAAAAAAAAAAAAAAAAAAAAAAAAAPBQFYC9OzgBGIQBKCpdTByiJ/ffo3pXDNaL8B7kEkHI BF/UAgAAAO60ijz097dN2fg7t6lpHKd4Jvu/kYtIzCJyMwAAAAAAAAAAAAAAAAAAAAAAAAAAh3wC sHcvKQBAUABFja3J0iyeiTLwK0Y6p95A8rKDK2oBAAAA/2lxh3SxI9eJYR+jWP1hFbQ4CVz059nd 6C0AAAAAAAAAAAAAAAAAAAAAAAAAAA8UAdi7YxMAQBgAguAiNu7m/htoHSQExEK4g3QJGeFFLQAA AOA/lahD3zMvfozDfYxTtDBZAKMSuIiyHfEKAAAAAAAAAAAAAAAAAAAAAAAAAIDHlgDs3TEKwCAM QFG7uHj/nrd1UkKTod3KexBwiIIn+KIWAAAA8B97AOK8p398b0YtRlsBixizyCIXx8OdGKSoJvtX dc72AQAAAAAAAAAAAAAAAAAAAAAAAAB46RKAvXs3ASAEAihoLVZzif23o4eJiJ9EBGEGxGURLOGJ WgAAAMBbdiGH/07lfAf+iqGGLWZxijDZ96GL0Tx6u4pbtDvRCgAAAAAAAAAAAAAAAAAAAAAAAACA C7IA7N2xCQAgDABBW5dyG/dfQRubKCJoI9xBCIhkhRe1AAAAgP/F2EN5eLv2yWkOVYxZvccwxS5c cRK4SOHPakfCFwAAAAAAAAAAAAAAAAAAAAAAAAAAl5oA7N1BCgAQFARQR+F03P8ELKVPFjbqvZoU U44wRi0AAADgH9FQw3qXR9rDP8tITfvRiihzb+6npXMat4jO23cAAAAAAAAAAAAAAAAAAAAAAAAA AB7oArB3BycAgzAARXstnbMbOXBzKQRJeiie5D0IgoqO8EUtAAAAYA9v2GHEnIvfvmOu9M8cr8jT RS6+AhdV3KLbP9J5tVZ3AAAAAAAAAAAAAAAAAAAAAAAAAAD44RGAvTs4ARiEASiaUTpOTx3D/Ucw F6GIKb14EN6D4CGiI3xRCwAAADjDV7RhnE/OveHvK6fF/4DFKmJRBS6ieCdeu/nOvAMAAAAAAAAA AAAAAAAAAAAAAAAAYIMuAHt3bAIgDEQBNIITpHQZKzdxjZBFrBzRyi5aBjGIWNi8B78IOfJvg/R/ LwAAAAB8Un/6MD4N57yGGKewbSWkNLzpmc8sZ/ab7lpp7Fcad6VK673ucr7qqrlWBwAAAAAAAAAA AAAAAAAAAAAAAAAALx0CsHcHKQCCQBRAR89hnaFLBZ2+A7TKZZgk0aLNe/BRBpXRC5j/bgAAAAAY 6n32kJr5VLONDipliX2POI7XPcw1a02+JHWSH9bkZoxmT1tLcb9nrxbRfyMAAAAAAAAAAAAAAAAA AAAAAAAAAD44BWDvjk0AhIEAih42FmrrgI7iDE7glBZCtBQ5IimF9+AghISQCb6oBQAAAPxPFnLY 7ulrl9Z1j/Oco5SI4ygxDFPru8s9Y+TxinfIokvOZfGL51+y4EVL2OK9ru0BAAAAAAAAAAAAAAAA AAAAAAAAAPDhEoC9O7ZBGAiiKPgboANLVODAFVhyCBktUBPFUJU78NkistCdLiAhmJE22A22hSdq AQAAAP+tFWQ4hx/ux9x6j4ZhzLompZRsW8k8Pz7397LkNU0ZL93IxfWYZ+rBinO0ondvxS2+J5W9 dUtlBwAAAAAAAAAAAAAAAAAAAAAAAADgB7sA7N07CoNAFAXQJ5YB7dNLOjvXkzJ7cStZn63jrxGV iW3gHLjw5jHDLOEqtQAAAID/cix3WHx+Per7b6T0XOeUtjRNt56HcYxXXUdbVXf+f895zCnjXF5R 7vZFnMsvrkov7hRZ5Eos9nfiYs7tAAAAAAAAAAAAAAAAAAAAAAAAAADImARg7w5xGASCAIpOCA7c ClxdHRfgCE16id5flAvAQlqzSZdiKireS8bMJiP2Al/UAgAAAP7XUYih3N/3uZ0dGoZrzHPEur4n 5xx9n15vz2WJpm1jSinGrjs7ddnnEZ9xijJSUduX4YtazOJb/OIofFH7F/EKAAAAAAAAAAAAAAAA AAAAAAAAAIAf2QRg725OEIbBAAx/wV4KxV566gKCU7hdB3FCB2jSqpciqT9H4XkgJOQjkA1eUQsA AAD4H6lyvnx6NE3XSGmMUp4xi5zLuudo2+Exv81zpKaJU9/Hueu++cc9anGM90GLw859LVhRm23j FbX1Otvai1sIXgAAAAAAAAAAAAAAAAAAAAAAAAAA/GARgL27R2EQCAIwOqy2KeyD3iB9bpPSy9tY WikuQn4UFVJYvAfTDLvL3uATtQAAAIBr2gowvO+badq9h+r6EX2fr+WwRY5bpHSbd90wRCrLeZ5V deRv92le8Ru1KOIzZrEWuPgOWBSxHrNYzkWcC1sIVwAAAAAAAAAAAAAAAAAAAAAAAAAA/MkoAHt3 jMIgEARQdEQhRcDOxgN4pxQ5k1VukculFRWNQQJhV2wD78HALMvC3uCLWgAAAMB/KBL7Y53L0aO+ f0ZZttv+jlnM8z5TDMPn6Wsco6iqbbq6jlvTnPnPfZ1rfEMWqXBFLmjxG7fI7fs54jhkkZK7F70A AAAAAAAAAAAAAAAAAAAAAAAAADhpEYC9O8RBGAgCKDoVbeqqewEMljvguAL3T3A1FQ3TgiArCotA IN5Lxuxs5gpf1AIAAAD+z7vwQvl+2eZcOzSOh5imJjKzCFrktrnHsuTzz22eX1GLrm3jNAxx7Pva 6Ucp4xqfAxa1oMVe3KLZmTJs8U3kQrgCAAAAAAAAAAAAAAAAAAAAAAAAAOAHVgHYu4MThGEoAMPP pj0U7AJuoEM4iRt1jQ7Zi0QpBUuNrXjy8H3wIIQEQhb4RS0AAADg/x0K6+vepb4fomlOkXPMkxdx i3uM4ytqUdV1VClNYYtL18W5bb951+05x3gPVKT4PWix3PsUtij9RylksT67vgMAAAAAAAAAAAAA AAAAAAAAAAAAwIaHAOzdwQmDMBiA0TiAC3gRF+i5I3VtVxBPQoomeggSbaGXHt6DH6OSkA0+UQsA AAD4L1fBhfJ7v83r00HD8AjzvG9LUYsUs4gxrd95liXmf+M0heYIWuTnNs+2/eauXdjDFmXEoha0 uAtcNJX3c+TiKmxRTqisAQAAAAAAAAAAAAAAAAAAAAAAAAD4wSoAe3dwgjAQBFB0lhz2sJAGPFuR J4vKzRLsyh7SQdDVENGwhhw9vAcDw4RASANf1AIAAAD+W2rslzp566VhuEbOh9f+DFosUYt7Xeao xfSOWtzGcQ5aLNN1cSwlTn2/5/vOdUrsC1qsn6XVLTX2iO+wRStk0fpXn7dfdwAAAAAAAAAAAAAA AAAAAAAAAAAANjwEYO8OUhAEwjAM/5mz8gbt3LZp3wnadILufwM3QlkD1WSiCK1aPA98jIgoeIFX 1AIAAAD+x1JoYXz/nHdae1HbHqLrNq+gxb0ELZ7nkM9b9P21PD9UVVR1XZbyjk0T+5TWPrXLu8Qn aDG3pbjFNr5DFtOgxThs8f4H08BFrFwDAAAAAAAAAAAAAAAAAAAAAAAAAPCjhwDs3b0NwjAQgNHL T+OGBaiRIqVjBYZgrSzBmJaSIAgBJXFL8Z50snWSGy/wiVoAAADA/6o27rfSo2F4RErnVdDiPRE5 z7u8hC267vp8k+s6qrb9TNPEJaXoy1GL2X2aU3yHK37jFVtxi6OQxd65/otS4CIOdrGzAwAAAAAA AAAAAAAAAAAAAAAAAADgZRSAvTtGQRiGAjD8Gjv0Ci5OWRx18EzefygOtlhSChKixc3h++ARCEkO kOUXtQAAAID/8Cmw8L5/Wua+91DO1xjH9doatogStZimLW4xLfMscYucL+XcY54j9X2ZLWrRpRS3 YYhz2v0+OMYatjg0po5c1HGLVuziW9iii3bgog5XdNUKAAAAAAAAAAAAAAAAAAAAAAAAAMCPXgKw d+8oCMRQAEVfsJgpXIDTCwNux50NrsE92oiZjx9iYm1xDoTwHoEs4YpaAAAAwH+qBRouscYfmqbp Gn1/eM3vqEVsQYv7ErWYgxZz2GIYxuXdLT9Kn0GL7T52XZx2P798Ouezj3rYoha4KE9qzCm+Yxbl rgxYlIGL1i4aOwAAAAAAAAAAAAAAAAAAAAAAAAAAsocA7N0xCoMwFIDhR0D3jl09QLceotC19z+G HZQ0WFokVSouLt8Hj0g0Qk7wi1oAAADA8dbCCvP9e5nbvx913SX6/n0s51wFLeIbtBjHYZq2PU3f PsvLT8wizcIWkVJcm2bLHc5lHvEbsaifl9YtoYs6aBEr61IMRLgCAAAAAAAAAAAAAAAAAAAAAAAA AGCHlwDs3cEJwjAUgOGn0pvdwIMr6RLu1CGczHsvbbVNUWsw6FHw++BB8iCQDX5RCwAAAPg978IM p0+PmuYcdb1L5ylmMc81zRS06PvpPKSwxTB0KW7RdXOw4tK2j6DFuqqeYYtx9uP98N2/j+Nsoxy2 yPfL2cRrxGIZs7jvI7uvsokoBy5KuyjsAAAAAAAAAAAAAAAAAAAAAAAAAAD+3k0A9u4YB0EgCKDo ungISwo7Km9hY+X9Oy9ARUPUFTCSAUJp814ymQ3JbsIJvqgFAAAA/NdWUGH+/VbmuvdQXTep6w6z oEWaYha//QlZjEGL57D7/jXcfbTtGLL4xiymncscc06XMuf9fzmVuadlyCKnZcyiCnstbLF2jiGL GLuI4YoYu4hnAAAAAAAAAAAAAAAAAAAAAAAAAAA2vAVg7+5OEIahAIxeC33KAL4LruEMLtcVHMwN +lxqrBGLhkB9FDwHLk36A6ELfKIWAAAA8Fta8YXT1kfDcImU9us+51zFLXLMc16u8xq2eMw03cr7 13EsIYsStuj7Z9TiFbjoujguc/ju/OdlUnxGLepwRSt4UYctdtW6i3bIIt6e1f+tDlxEY791HwAA AAAAAAAAAAAAAAAAAAAAAADgb90FYO+OURiEoQAMp2epe6eOvYSn8ObuToIENGogtga7uXwfPJDw CDhm+kUtAAAA4D7/BBaey3RXFzXNK4zj9sxPEYskhSxyzCLGHLqIh7DFNMV1tx+GLWCxhy3ylHGL 97L3uf6nVNZow2+84ixwUZu88yjOyu8QjpGLs/BFLXLxfQYAAAAAAAAAAAAAAAAAAAAAAAAAQMUs AHt3cMIgEEVR1I3EhWADaSDV2FoasIYU5d4SxPkJoyJxcBnIOfAYB3RhBVfUAgAAAH7Ht+jCM60p fTQMr6rr7u/nCFrE5nk7YxG2iJhFhCxy0CLuOWoxTtMnapHDFnW9xizyHum927X/6NPaqhy2OAtc 7AMVx3spXlE6jwGLKzERAAAAAAAAAAAAAAAAAAAAAAAAAIC/twjA3t2cMAiDARgODtEBvHaArtBL ofsP4N2jNDRNUrEiAXPr5Xngw59EQRd4RS0AAADgP3rCCo8897MXjeM1LMtQIxZFyifHoEWZlN5b 2OIbt4ghxld9ZprnX9BijVnU4zpDWcv7bn3fdsnzDO2AxT5kcba+v26FLnrm+F9b9wAAAAAAAAAA AAAAAAAAAAAAAAAAaPgIwN7dpCAIBGAYHgJX4r5th2nnMTqUN+iAgbgoyBl/k5FcBj0PfMiAgnqB V9QCAAAAfkMutnD79lDT3ENVnefzEraIQYshZjGELcIYspiiFq+0tn2m+x9d9xmyKIq0U9wYuYgv del3PfY9db8y7Icr9iIW25BFLmaRO6//W+66DVgciYoAAAAAAAAAAAAAAAAAAAAAAAAAAPy1twDs 3UEKwjAQQNGp4AWK4Bm6E7yF3v8wRUqbpCIxUMzK1XswFEpS0mVWX9QCAAAA/q8nqPBM8/j1oWm6 xzx/X+9zxCIHLfZnlLDFHrdYPrOuOWzxKoGLcbyWfUs+wDtqcaqmBC3SxDDEOa259f3jJfawRRu1 qIMWbcSiJ25RByraoMXRRLUmDt4BAAAAAAAAAAAAAAAAAAAAAAAAANDYBGDv3nEQBKIAig4klNKb UOpK3IxLYgdu0A4QGT6KKJHOwnOSlweTTDEruKIWAAAA8HufIgvnb5fK8hLyfP/4b9shZjHsZ9Ci rmPQ4jaGLKZpxrMmFMWxv3+tqj5ekU5hiywLSTf9HgMX0aGb07Z3xTDHLqyHLeaBi/l3sthpeA1a zM9DeI9brO1lwGJLXAQAAAAAAAAAAAAAAAAAAAAAAAAA4G/dBWDv7lEQhsEADEcv0MlTdHDxECJ4 /2M4FmoFzZ8NQWgnp+eBjyRDAjnBK2oBAAAA/7UnpHD/zHXroXG8hHnO12LIoq4xbLFODFuEErF4 paBFjls8yyxhGE7p7mOaUtTiG7QoIYtDnRi8CLk8cd731/jwLazRijZeUc/HH/v2vBW4aOMWffii naqPXfR7AAAAAAAAAAAAAAAAAAAAAAAAAACKtwDs3TEKwjAUgOFQKBSE4ujuSRy9iIfqBTyeW7eq TUMk1kq7Ofh98AgJvCEn+EUtAAAA4LeW4gqXtaWuu4a2Pby9xYhFjFqksEWKWQzDY5oUsohBixy3 uL8iF02zn/ZvfZ+iFnliyKKup8BFlUMXIZUjjuOctv3vPM4uLIcsyvs8bvEtcFHGLMpgRRU+gxVL 5zxgsSUyAgAAAAAAAAAAAAAAAAAAAAAAAADwl54CsHfHOAjCABhGSx08gMcgcfIQLt7/Ii4EEKlt DSGiTE7vJX8gkBAYmT5RCwAAAPifPQGF27zrrwe17SX0ff6tn6apLMcs6lLMYhjyasBiHPv5mJcD F48Q4/H1nHvXhSbGd9AiljU1aJGul5dNpYnzvm8+hRy2OHxZ3NgyYLF1bxm4CB/uLVetYxfrcwAA AAAAAAAAAAAAAAAAAAAAAAAAZk8B2LtjHARhKADDbZxld/Qkjl7EU3EBD+jCVnltagySgJOD35e8 PBggZWX5RS0AAADgd9aiCreth8bxnobhVK8jZNF3mwhYlBq0aGGLVO8jYNEnQhY9clFKhC4O9R2P aXpFLSJi8T4Rtsixcztm/FA4z3PZ953XeY7pM2Txbdwip/XYxTJokTb2MmCxJzYCAAAAAAAAAAAA AAAAAAAAAAAAAPB3ngKwdzcpCEJhGEY/JFxBy3BWq6j9r6OhAxW8PwoiN2zU6Bx4ScTk1gYeUQsA AAD4j1/CCe+019WLhuEZ89w1ghZRQhb7ctiixi2W9DmViEXddAhcLOWZ7DOOEVvUoiyHLNJK2KLv o8vXeds5bvksaY/r336PGrZoRSzO91rrDs+eYxf7f9iKW7QWh+/El3sAAAAAAAAAAAAAAAAAAAAA AAAAACSrAOzdsQ2CQACGUaSg0IQBrF3FXdyJAZzMlgW4iBwIykGUzsL3kj8cBAom+EQtAAAA4DfW YgqXbx9V1TUry+N0Pw9atLOgRQjDYriibe/99bUwrWmGqMWtrrN8DFo8oxYxaLGLi+ei6M/vRYlT t/22/z13O2TLmEX+YWOIIr1Pn6fvpsGKtWsasNgSHQEAAAAAAAAAAAAAAAAAAAAAAAAA+CsPAdi7 nxOEYTAOwx/ZwD2K4MEVxIv74wJdosTYP9aWKNqLJ58HfhAIzaELvKIWAAAA8HtbggmXfudvDzXN MXJePltHLeawxRC0mMIW00oZ4hXdM2JRyhy1uI3nnLvxrWvbRqQ0Bi3SKmiRHpsjF3VFYt/v8P0f 7PqdYglarMMW7wIXdbTiU/SiXmy4j3iNXdRnAAAAAAAAAAAAAAAAAAAAAAAAAIC/dheAvTu2QRAI wzB8WFBoQW3nLq7iWAzgkIjyH1wghAiVjc+TfDlCAoEJXlELAAAA+L2tiMJj76G2faamuebrdxQs JiVmESGLsghblPX9a9octIhzXJ+6bnxXRC2qqspRi7Ict4jV9Ry3SHNxIs7bsPOx/74Pu6TtiMVp de9b7GL5CcsAxvrT0s65DlgciY8AAAAAAAAAAAAAAAAAAAAAAAAAAPyNjwDs3UEKgkAUgOGneINu ES67Q1D3v0gbVxM5Y4oNkm5a9X3wmMcgs/ACv6gFAAAA/NaRUMJ9nNveQ31/iZSamHsW+VzvU9hi ClnkUEWedcxiDlpMd89lTymVNx7DENG20eTJUYuuK7MELd5nuY/PKsT52L84jXON79GK+m4rWLEV uKgndr6Z1bGLegcAAAAAAAAAAAAAAAAAAAAAAAAA+FsvAdi7YxwEYSgAww9HJ1YXD8LobbwXB/CA hkhDW2NTIpOL35e8vBAgaU/wi1oAAADAb/XiCfdvP83zI8bxUp9LzCJJIYstahGR+hQparHtyAGL ErN45sBFmSXHLpb3gYahRi1OKWiRIxY1alEmPisT13WmY/e/rXOOfsiiDVy03+y924tftMGK3m4D FkciJAAAAAAAAAAAAAAAAAAAAAAAAAAAf+ElAHt3jIMgDIBhtIMH8ACMMuk1jJv3P0xrKQhJ24Uu Tr6X/AFCYGBj+kQtAAAA4HdGAgnvstfZi+b5EVJqf+Nzzk3Q4rtchS3yHq2IVdRiDVx8tuMRtIgx hWm6be+M5d4atQh72GKLW6xBi36hLUhcyu5j3+Ra9gxtyKIOWvTxiuO6j1aMLJw8c+hjF/05AAAA AAAAAAAAAAAAAAAAAAAAAMBfWgRg7w5SEASiAAyP+wShVV2kdXfpWB6gE7ZRqRllLHRAVy7i++Ax D0URL/CLWgAAAMBxStGEx9ZDbfsMTXMZ9xSwyNL+DVq856BFOvt+miliMYxBixy4mGaY76WwRV2f x3e+ui5+WbUKWlSL87c6kQsR1zi3ff/hHucU1kGLUsxi7/VS+CLvYeNcBiz2xEgAAAAAAAAAAAAA AAAAAAAAAAAAAP7eRwD27hgHQRgKwHBB0sHNWzizubqZeP+TOJAYQALWxjLA4uT3JS95NKRDL/CL WgAAAMBv7Akj3Ke5bV3UtpfQ9/UnaJFCFilqMY7j/J2DFnkfhucctMhxi+ErZrFMH2I8znc/ui5U db3MO2xRNU0OWsS47NNZqkakckQzzXnf25ymuYZ1oOIQ1uGKqjgrwxVbEzb+T8rYRbkDAAAAAAAA AAAAAAAAAAAAAAAAAPydlwDs3TEOgjAYgNHKwMTo6jUcvQ+HYvd2Lowk2BYbtUpgcjDvJX9KGtoQ LvCJWgAAAMBvfIsl9FuHhuEauu74tlfHLZaZX4IWc55nyGKK7045cJHWFLEoQYt4MkcxmqbNd97G cfnAErZI8YpH1KIELfKaJnxWJk5xzvv+xyVOKmnUIYu10MVhZb+eOnpRnsPGWgcs9kRJAAAAAAAA AAAAAAAAAAAAAAAAAAD+2l0A9u4YB0EYAMNopTfwFCaGzRM4uHr/0ZkzALbURiBRGNx8L/kDC4Vw gU/UAgAAAH5vTxDhnnbbOqhtL6Hvm0XIol7fMYscsqjLYYuyHLMoQYsatxhmkYv+tRK/GMc4nfvo uvSVhxK0iHFaU6MWs6BFzAvLkkQtSJzSztv/6Jh2Dd9DFZ/CFfNX7lnYeKZaxy7W9wAAAAAAAAAA AAAAAAAAAAAAAAAAf+UpAHt3jIMgDAVguCQsJg7Mxrt4Gq/E7OGcuYCg0kKNggEWF/N9yctrSMrQ C/yiFgAAAPB73yIJ57VLdX0JVXWYfY8hihi1yHsIWzxS0CLHLdo2vKIWXXcbQxY5cHEfQxbD7v+U 7kbXpklRizQ5bFGWad6jFkU8h3llIu5jP7tt73LqZx+GeMVa0GLa0FiKXhThM2KRz2FlTwMWW+Ik AAAAAAAAAAAAAAAAAAAAAAAAAAB/6ykAe3eIgzAMgGG0uwGXQOAmsSgc9z8FapKltJQuZQQ6geO9 5M+aZanYBT5RCwAAAPitLSGES9q5d9E4HsM8v14XY33WsEWOV4QmZhGX5YBFDlfUeEXZbXlfwxbl XO69TlMYnlGLIUctmrDFI2rRhi1y7CK8VySyfdqh/692aaewLWjRBio+xSu+LXS+rdaxi/UZAAAA AAAAAAAAAAAAAAAAAAAAAOBv3AVg7+5tEITCMIwS7bSmdBPHcTQGcCo7JjAXvJ/8BG6M0NiYc5I3 EAiEsMAjagEAAAC/9SmOcNt6qGnuVV1fVtf6sWgxxSxiKfXvmEXX9eP5ELSIeEVKseccshiiFt0c tchvyOvmsEV4tO3woRG1iEXQIu8QAYtF0OI4Hat1YWKqTMSXn/b9n2veudoOWpT3ysBFuTJ4sWxu fDuWAYs9kRIAAAAAAAAAAAAAAAAAAAAAAAAAgL/0EoC9O0ZBGAbAMBpLL+AFOujiMVwF738D156g rSZpIlrBKrj5HvxUwUro1ukTtQAAAIDf+SSAcI47rf1R1+3COM6v7aVl8RSzSJumep3DFjVwMQwh RyrmiEVdClsMJWhxvYcsaigj3ZNc+r6cOB65acImLYUt2jaHLfJK3CKHLcJrSaLaxx3Wn9k27hi+ C1o8fl/GK94trPy2WsYulp8BAAAAAAAAAAAAAAAAAAAAAAAAAP7CTQD27uAGQRgMwGg9mrgA8ege zuNwDOA8XhlBUqS0JEiqcuFi3gt/SkhoCgt8ohYAAACwn1oU4fbrpba9h6a5vD1bhy1S0CLFLPKa gxYpTNH3w3Qf47OELHLQIoctYolazBNL4GKY9koeXVdOexivErZIUYs5bJFCFssJoTrpY8/jHLf9 p+s4p1CPVtQCFsswxacj1IIXy+7Gt3UdsNgSKwEAAAAAAAAAAAAAAAAAAAAAAAAA+DsvAdi7YxQG YQAMo4kgjt2dOvQg3br1/ufo4tLQGqNWxKJDp/Ie/CSIiDf4RC0AAADgN46ED+79bnsfattzSKma QxaTErR4LVbCFjlikdLnnsMWOWIxBS3KmeawRYlblKBF/8XFQnh0XXjmSsbw5zHEMWpR5aBFXYfY L59D0KJphnOrLDE9u4zbcep3DdsRi637t9hFPLCw8+5kHbtY3wEAAAAAAAAAAAAAAAAAAAAAAAAA /t5bAPbuGIVBGArAcJxLHQpCl16lp+nRPEBP10EcatRX0iDo0qV8HzySCMngBX5RCwAAAPiNrRjC Y+9S3z9T192+vkXcolxzd6KciFmMY1qjFUvQImIW+bxMBC3SJ2yRJ99v28v8/msYUhNBiyJsUcYt 5qjFOrksUdYmojCRXac5H/tf92lO1VNb+7Kh0VTnramDF7FPO2sdsDgSLQEAAAAAAAAAAAAAAAAA AAAAAAAA+CtvAdi7gxQEgQAMoyMt3AkdISHoFq2D7n+RwFViU2NmYzRCu3gPfnQhyixdfaIWAAAA 8Ls1wYNz3Kn0orY9hL5f/q4PY9EixSieYYsUo0gL44YsZHGd4hYpYvEKW8S3vK1pto9vXLpudoIq 7R62mActxuumrhdBi7wesYvblw4eQhN3DN8DFXno4lPsolqxUHh2On12ze8BAAAAAAAAAAAAAAAA AAAAAAAAAP7aTQD27iYFQSgKwKiiSETTaNRSWlB7cwHtq4ETs/zNl7zKQaM4By5X5IniBj5RCwAA APi9WATh/O2hsrwk+/2xvx4bFi97jlkMQYtuhzGLuh4mDFk0TRPELG7PmMVwL9z3pCh2/buuVTV/ fBezyLJ58jxJp7DFOGmaRgsT0xza2az7b6d2tkk8XvFuwobGpzPLs8tgRWwvAxZr4iUAAAAAAAAA AAAAAAAAAAAAAAAAAH/jIQB7946DIBAFUHQgobemkpXY2br/xRBlfjpBzJjYmXOSx1CQRyiprqgF AAAA/Oab0MFtm2tv0Tyfw7q+/6q3YYsYsogBihy0uKe4RTzzhBS1iDGLGraIZ41ZtCGLbVPcWN+Q rtOU0xPPqMUwlGNIQYuxhC3Gg7DFUYUihFc9Yul9fHba5lJW9UIV7bQtjX1T49OEzrPVPnaxvwcA AAAAAAAAAAAAAAAAAAAAAAAA+FsPAdi7YxuEYSiAggaS0NBCxwpswDhsxwDMRR1hYgdDCEFQUKE7 6csuHEvxAk/UAgAAAH5rKn5w+PTR8XgK6/U274cRi+d9vAct+rhFyCGLFLRo2xK0iDlmkcIWj2lv oYvLPXDR39nfV8RY5/Vcohb5D2Z5SthiVlVhXtdh0TR5UtBisVy+BC2GYYv0CJtudt+9376bVQiT nYx3U0IUn86Mz46DFVPrOGDxTcQEAAAAAAAAAAAAAAAAAAAAAAAAAOAvXAVg745ZEATCAAwfgrg2 O0V/pq3//zsanDLL++5KJFIa43ng41RE9DanV9QCAAAAfrcncHB5znnrQX1/TOP4+Tc94hPvyEVE LaYcs4g1whZxXiMWtxKwqBGLe4laTGXuJWhRoxbztXjt6zAsviSCFqlp8tSwRZ62zVGLput21STm ZMdpayNSOqQIWyyDFnviFvWedbzi26SNe1+7sFrXxwAAAAAAAAAAAAAAAAAAAAAAAAAAf+khAHv3 coMgEAVQdDCsdE1c2Yn1WBkF2JJrWkCR34OIJuPCjck5yQvD8EmggStqAQAAAL/zKXpwyT1U19dU Vadx3XXv12MvghZDjGIKW6SXoEXbdkvEYpgpbnGf57HsT4GL9Z3dfBJ7t6ZZ9qYvKVIRQYt5dhG0 iCnLsSoRs41aDHPsZ5//h4NzP4e0xioiVJFrZ+Tu2wYvYp0yx23A4puYCQAAAAAAAAAAAAAAAAAA AAAAAADA33sKwN4d4yAIgwEYLcoBPICLTJ7C1c3zewFugSBQC9IYMI7mveQPkDQldGP6RC0AAADg N9+EDW79XLc2qqpzeDyWv+gxNjGHJmLMYg5btG03xSyGsEXTxMBFDFnEWUYs8qBF95r3d8bne13P H1MUY9QihS12Q9SiLMdJYYt9CluE9YrE4NjPaetAQjj0c8m2ylsZnyatyeMVaxM21k5HkV3zewAA AAAAAAAAAAAAAAAAAAAAAACAv/MUgL07uEEQBgMwinDg4BlvjuI8LscALuOZKWgFC4hIAiZeTN5L /tAESJsu8IlaAAAAwG+sxQ6uWz/V9S2rqvNzHePn+z40kWIWcZoUtUgRixS0eAUuQmiHgEU7TQhj zCJOQYu4slkI6dj3pnk7TB+2GOMWh6LI8jFoMUQt8rJMYYtsvTQxL0Scuim3LiW5dHPM9gct5lt9 ++0yWLH2XAYs9kRNAAAAAAAAAAAAAAAAAAAAAAAAAAD+2kMA9u4dB0EgCqDoExdgT6MrsbR1/6U9 SxCR4SMyaMDWnJO8DBA+gY7qiloAAADA77YEDa7tXNZuVJanqOv573kfsVjOFLNohqDFFLNIYYs+ aJEiFvcuZJH2p8jFYwhZNNm6dKuq5YsVRRe0iGHt4hZj1GIMW0S85r0ckVckUsLjuPZhIg7tnLPL t8Qt9jF/9C6b+HLs07l5zCKPXeTbAAAAAAAAAAAAAAAAAAAAAAAAAAB/5SkAe3dzgjAMBmA4gV70 3quTOI2zdQAHFDRpMaQxWsVT4Xngo6U/Ce0Cr6gFAAAA/K8XObhsvTRN1zCOp/n8TV+i3KvDFsvx 3gQuQhWxuM1xixyySFdL1KIOWvTk9V42rT8sxhK0iMMwzypskSesyxJtKSIb0xy2fs7inObYWfLT PLf69dk2WNE7tgGLb+ImAAAAAAAAAAAAAAAAAAAAAAAAAAC79RCAvXtHYRCIAig6UdA2fSCFVXaR PmT/q/ETjaOojGjacA48GAZ5ohu4ohYAAADwmzMhg3c/r6NFVfUITbNetw5YdPHczUGL4W6KWAxB i7qewhZdDFkMYYt2Po8RizbuGMMWe4ZHi6JMfNllnm/YIstCNgUtYtQiL8txwn49YlmRuPVzP/pB IVz7eW7WnIlb5CH92mWYInWXenYbs9jGLrZnAAAAAAAAAAAAAAAAAAAAAAAAAIC/8RGAvbu5QRAG ADCK4M2b4eAwTuRsDOBwjdiChFrrXzyZvJc0JVAKneATtQAAAIDf1OIGp3cvDcO56fs56zA+70wU gYsxC1vMcYvlOoT0LAUtQha2uEz31pjFeItb3H8whSqWX9/vD9Mc0uYPJ41r2rbZdN08irDFFLeI y7bNWpXICxR5YaKPo5LPqDnGsats92osB/p2bRmsqM1lwOKTyAkAAAAAAAAAAAAAAAAAAAAAAAAA wF+6CsDeHaQgCIQBGB3NhdCmtRF0lDbtu/8t2rgyS80xHQRdx3vw4zAMI3qBT9QCAAAA9tsTMHh0 c9+6qKquoW2X18WAxS9iEcaIRZit39NejFk0TTzfjvMap49ZtFPI4huziLOuLI/D81nXyRdmQ/wi y/MpbJEXxS9sMUYt+jOxFpEWKLKwrEKcu7ls/agQTt3ckmv2xC0Os/Pp69NIxXxv7Wwas0hjF+ka AAAAAAAAAAAAAAAAAAAAAAAAAOAvfARg7w5SEAQCMIyOiBht8zpdprN5gE7VtgsUNjoOmIxY7YL3 4GdcKKIX+EQtAAAA4HelqMFl76G+v4auSzmHYdGXGFatiRS4eI9b5JhFWpg3hi6ecY/5TGGL8Xo7 ZlEOW9R1O523+33xbP7CKsUt5qjFFLZomlDlqEXbhjquFLQohS1OcYe9n5Wc446h3MrYWn7Nt/eu gxWlcx2w+CR2AgAAAAAAAAAAAAAAAAAAAAAAAADwd14CsHfvKAwCUQBFB02bOk0qq6wifSD7X0Qq FyAaR42fh6Bt4Bx4jOgwoJ3VFbUAAACAc86EC979vI4OqqpHatvtL/mvHTEGLJaQxRK26Ib7S9yi m+MWTZOft9M0Q9AiX+dwxbi28xldLGcERXEZ1k9db18yxyymiWGLMgct1mGLlObZq1CsqxC3fu5H Hyylaz/PcMSZuEW52h+bGjFSsb63tzfGLGLsIl4DAAAAAAAAAAAAAAAAAAAAAAAAAPy9rwDs3b0N gkAYgOFLJFLYXusoLuRsDOBUVpSCgofkIBDQzuR5ki9A+DtY4BW1AAAAgN8sxQyuWzdV1S3EeH7v 532JFK+Yxi1ShCJkIYswhiyaJmTb/txjmHaMWqR5Ds9rs1WshS36z0hRi3tdTxc0XpKCFuETtSiK NEPU4lCWu6sS/XHs5rj105JLN6ew3MlYm/xV31w7D1YsbecBiz3REwAAAAAAAAAAAAAAAAAAAAAA AACAv/ISgL07xkEQhgIwjJ7AmTh4FQZ3738WLLYBS3lRYTX5vuQlQJqmHZl+UQsAAADYdyRY8Mhz 39uo729dStvf8W3cYqoBixi0SGnaxC3GcY1czAGLZw1ZrFGLFIIWXy5yel9lPluNWsQDlnVL2KJE Lc5L1KIELerk91KdaMsTsULR1iH6PNfdE3aXPEPY4kjc4ldXI0Yq2m+f1saYRYxdxGcAAAAAAAAA AAAAAAAAAAAAAAAAgL/2EoC9e0lBEAoDMGqFGjQKnLaTttPuXEBraujYMPVq2s2whsE58OM1fDZ0 8olaAAAAwO+WIgaXtZPK8poUxalfv4Ysppl+a4aoRTObsB9CFmFd181w7D0KW4S4xXit4apvjx1a FuN609+jc6uq6eHil++CFu0ks7DFNk3DZFmyy/NnTWKpOjGWIcaPEsd29mt/XnBu55AsdzI+zfx2 vxwbByuWtnHA4pv4CQAAAAAAAAAAAAAAAAAAAAAAAADA33gIwN7d4yAIgwEYLjGBydnEOHgSR1fv fwFHTqAopVaxqLCaPE/yJYS0/G1Mr6gFAAAA/LYkVHDq5zh3oe12H7ru/Ve8DFmkcEV4BC1esYt8 /nIJQ9Aihy1S3OI6zCtmkYMWcbp89ekLVNM2x+2Wnu/ctsVzjvbHfY+wRYxaVDFqEaeu0zTNszix Ct/jFvmucTb97OY+YAjrfg7hPUKxJG6xGq0fxyvGYYpP5z6tLWMWZeyiPAYAAAAAAAAAAAAAAAAA AAAAAAAA+Ft3Adi7lxsEgSiAorjAlRsT1nZiN5ZGAbbknh6QxzCZMEGRpck5yQv/bwNX1AIAAACO 2YoXPPYu6vtn03W3eX0dsihT9o1LyKJELmIiZBHHYpniFuOyLwUtUtgibUfEIq3nuMXnT4i4RQ5c 5Pd4DcP2xy/nzddE0GKaCFqc2rZELWKaZhW2qCsTdV3iOs157ycm92kuX269NfkxR8+tgxVbyzpg 8UsEBQAAAAAAAAAAAAAAAAAAAAAAAADgL7wFYO+OcRCEoQAMN5jI6OrkwOQtXF28/+QBvIOClKKW F42uJt+XvEAItMAFflELAAAA+OyXQMFpnOO3hbpun/p+uVwMWTziFSVokaqwRZnbLS1iFtdriVuU mEUOWfRz4GKYIhd1zGKIXYv5M0qk4vVeed/sfLnMQYz4yPzM49g0z7DFNOt1WrVtavKkZXUiFijq nfNxO87u249MaTPOISzzS9xiVd1fbx9fI157d2+MWcTYRTwHAAAAAAAAAAAAAAAAAAAAAAAAAPhL dwHYu3scBGEwAMMwgImjYfUo3sfDcQCPZhhEKD+FigE3h+dJvgBNgaQXeEUtAAAA4LitaMF976W6 fmRVdQ3365BFnLjWLmIWQ2Sij1kM9+28PoQtprXXPFPMYhm2+GxTpE2GuN7vLctTeHo2zfid8QN5 Hq+LoEWYPmhRFCFqEcIW/WTZatLKRFqHuHRT7h3m4NbNOdtuZXyb6Ve/7k2DFVvX9DCPxFAAAAAA AAAAAAAAAAAAAAAAAAAAAP7eWwD27mAFQRgAwLCW4MWgWyAdepNuXXv/FwkE0zQdzRXZNfg+GNM5 hh49/aIWAAAA8Nm3MEF4dh3GZe2guj5lXbf8BU9DFiFgMQUtsihsMUUpxohFCFy07StsEeIVfX+f 5xCheCtZvH9Int5PC1W1f863plluiOIW4958jFrMYYtNUSzDFmW5GrWICxLBYRjH1TfPdsM4J0f8 ErfYRvvTrkYaqYjXPu1NYxZp7CK9BgAAAAAAAAAAAAAAAAAAAAAAAAD4Ow8B2LubFASBAACjYyAE uQlad5Ju09U8QMcLJC11Jh2RrGXwHgwOg38j7j9RCwAAAPjOWqDgunVRXd/C6XQe5nnIYhrTWjeL WYT3SEGLFLlIa33gom0fMWjRzaIWbQxb5PdPWyhilCKtjfNpe1V1HI73pslfOLtVMcYtYtRiCFuU 5Ri2iFGLXb8W8qLEsjxRzOa9/sn7rY86urzGIeSxiq2RNvrructgxdpx+X98iqIAAAAAAAAAAAAA AAAAAAAAAAAAAPyFpwDs3TEOgjAUgOEmhMHNycmJyWO4mnj/qxgGQWoBS1FxNfm+5KVG8QW4wC9q AQAAAGvfggTTb9dhLluLmuYUum65rgxZTPGKFLQIWdiiX4QtYsQiTT+fKWBxH88ubpz39mWIIoQs ZpEeZxm0SGdd757nrW3X5Y3XovTfOHnYIgYt6jpUY9hiCll8qk4s7yY5DHPcerEh7Ic5F6t+iVtU 2fV5vKJ8EeV3764tYxZl7KL8DAAAAAAAAAAAAAAAAAAAAAAAAADwVx4CsHf3OAjCYACGGwIMjobV o3gg78YBvJcLm5aSyo/E4ubwPMmXlgBNSNhfUQsAAAAo2wsT3Eov9f09dN0l7dchi8/oxHQdViGL OWbxfO/H+8uwxRS0yHGLeT3yScvAxXJfVW1aH8NQOCKeMQYtctSirkM1TtOkuEUKW4RQDFvkyc5x 2gNfEF3jnMI6VlGaHKL49dltsGJv3f4n3+IoAAAAAAAAAAAAAAAAAAAAAAAAAAB/7yUAe3ePgyAM BmC4RBk9gMTBq7i4ev9LODGDBUJpDT+uJs+TfKYiJdrN6RW1AAAAgNJeiGD+7BXnefSgprmHriv/ en/HLaZ4RZ/WS9iiz8IWS8QiX0/7ujRxdwpbDOvjn7H2fnAeX99tOxc4yi+etlYpbBGysEVV1+OM YYuwFCL24hYhlOWIa5zb1sEuLnEeoYxQ/BK3OGX35/GK/DDWrq3du3agYeMaAAAAAAAAAAAAAAAA AAAAAAAAAMBf+QjA3h3cIAiDARgFQzx5MeHqJs7jdAzgPN6ZQQu0wTZQ4s3De8mfNlASYIFP1AIA AADqtoIEj6OHhuHZ9P1t3pchiyU8UV5rspDFErN4zzNdTxGLPGixRizSfj9mUfuc/H56t9c47p9q 23WNYYtT1y0TgxbzhP1UkJgyGXtBi1SW+HYNcz540+ge5tLksYqjSSGKX8+WwYqttfzBtUgKAAAA AAAAAAAAAAAAAAAAAAAAAMBf+wjA3r3jIAhEARQdQkFnbYiFO7Gzdf+JG2ATIB8HnkSQ1uSc5GUS RZihs7qiFgAAALDYCxDk7x793H/dqK6vqW0//3avQxZTvKKbgxZL2KILYYs8OWaR5sjFFLOYZohZ 5HX9rPEARTzCeo3XLL99Ns3uGWPQoijLlN5rEcMWVXW4GhFncO7nsruD0amf2+p2R+IWZbj+2zbS xmdbW44v89sLFrEAAAAAAAAAAAAAAAAAAAAAAAAAAP7OSwD27uYGQRgMwHCJRi6eDFdHcR4XYwBX 8s4KpgKl4Sc26M3D8yRfUgiQlgVeUQsAAAAo+xQiuO+91LaP0DTXcb0NWcQYP9ybYxU5aJEiFnEK WMRFzCLHLeL0rVdIQYscs4ghhy2KhxpCFNXcXUjLalrPR3523d5Rx6jFMmwxBi0WUYtDXYdjSAWJ PPm6FLbILv2c9ncwuPVzDutYxbctjV+fLZVBtiGM1V8q7FvoAgAAAAAAAAAAAAAAAAAAAAAAAAD4 a28B2LtjHARhMACjJM4ewMSJyWOwuHv/0YMUC6Wh/NHq6PBe0tBA0xQ2pk/UAgAAAIpeeKA+e+Rx /7bRON6GlI6/3DFkUSMVZT439/a4RQxblJhFCVeUa9rCFsvmafgUs6ihihiz2CMWxw5DPfszRC3m 9iVqzGILWrRhizVosUUtlrGsaaMWvXrEfrLikse1+7VX5zym4Rih+CVucWrWx7ZGjFS0996tjTGL GLuIcwAAAAAAAAAAAAAAAAAAAAAAAACAv/cSgL27x0EQBgMw3MREZhNWb+J9vBwH8EyOHEAEsdDW CnFzeJ7kSxvCT5qwv6IWAAAAUFcLEFz3Huq6W2jb82tfhizmAEV5LQ9ZTPspXhEDFjFsMc9jiVtM 6zCMm7CGLbLoRPU4eXdhDVyEJG6xuvf952vKb8S4xTtosUwStjg0TVaR+Ba4SMsS0Wmc48apEpcw xy3SWMXexEP/em8ZrKit5f+zFU0BAAAAAAAAAAAAAAAAAAAAAAAAAPhLTwHYu2McBGEoAMONegp0 8CROXsD7X4WAkPpieaA4OnxfQiylgcLm9ItaAAAAwPfgQFx7TMd970Zddy3DsPy7nUMWEbGo47GZ e8ctImQRkYu4XufGFMlYxyyiVxHhijZg8fkV63nf771leshrnMMWhzZsMS05lbKKW+RixFYV4jwd l/3dzEGLW7rlL3GLY7M+byVvp53bWrv+mMvfPAYAAAAAAAAAAAAAAAAAAAAAAAAA+GtPAdi7gxsE YQAMo+VmgtELZzdxGldjAAdUsRCqpVaINw/vJX9qDCK6wCdqAQAAAJ9q4YHL1of6/hq67jS9LkMW 7wBF/t4yZJECFilikcIW+dK1w/CIu8/neOO0bz+nmcIW+da07WE6b+PDhDB/R+3Wc8wiLg9bjDGL Zg5aTAv1mEW5vCyRHON2q0/7co7bh2WsYmspRPHrtWWwonaWf/JaWQQAAAAAAAAAAAAAAAAAAAAA AAAA4O88BWDv7nEQhMEADIuwOji5ODN5CDc3738NJyZUflLa1IqOJj5P8oUKDVYv8IpaAAAA8O/W QgPh2XWYy6cXte1p0/fVS7wiXYeIxbx+JPdi3CIGLGLkInwOEyMT4/W++tNiwCLvLaTPx9BF3LPb 7afrreveBy2Wr6nmoEVdL7NtmmmWsMWwDkGLNGxRilyUqhCHYY7rp5iOPcw5e9U3cYs62Z/GK9Ij lO6V9uYxi/zPz9cAAAAAAAAAAAAAAAAAAAAAAAAAAD/rKQB7d4+DIBAEYHRDQWJsqL2L9/FwHMBb 2dCjo+IOYEQ7i/eSiexG/hL6T9QCAAAA5t4FB05bJ/X9uXTd4bWODkSdcRW3yIGLx9SAxeN4Clvk wMWYohgRshifU57r/ArrNESNW9T95V6sY6ttd/edyzBsvXq9dpzbNDVuEUGLKWoRU8oqbJGLE7kI keMWIRIb7VdPUo632Zd5rGJr8m1/+e+7Wsjyd/k9fYqoAAAAAAAAAAAAAAAAAAAAAAAAAAD8lasA 7N0xDoIwGIDRKmHzAjoweRITd+9/DzYINkID1gKOJr6X/ElTSKEn+EQtAAAA+GdbgYH07BHnvndQ 01xD35ePyyMW43pY7M1xizlmMQYuui4Ughbp3OE1KWyxdcU5XlGKXORxixDqeopatO37RVY/c5jD FilqEec4hS2qKWqxV5oo1SLS+hznEnad4tyyI7+JW1Th8xeWE1b2Su/mMYs8dpGvAQAAAAAAAAAA AAAAAAAAAAAAAAB+0lMA9u7uBkEYCsAoNPiiL7iP4zgeAziVM9hSavn31YdzkpubFAiEBT5RCwAA AKj2QgPPXw8Nw6vp+5pbqNGJZopO1LDFOnCRJwcs0pSARY5YLCMX86kxi+PQxDJUsQ5Z1PN8tgxb hHAZ93setTh4R4lZjEGLEPKkoEXXNW2ckIIWcVI1opQj0u6mvS5OlK+dxy2Se5zr6dd8PeLcmm1D 41dPoz25fnTvOlixt7c/fZ/QBQAAAAAAAAAAAAAAAAAAAAAAAADwVz4CsHf3OAjCYACGSZDN3cUw eRA3N+9/Cy8AQcqPlFJhNfF5ki80QFo4wStqAQAAwL/aCwvMz579PI42qutb0bb57dYxiy6KWcSR im3AIgQummYduQgzBjHGmMUSzNiGLeZAxdKpWH7rE6L4Kjw7DatXErXInbU6M8wUtRiCFlU1Tghb hGuRD1nkahO5KsSln+vOl0/O/dyTrcriOFpRRu/H8Yr4E3L3cu+mMYs0dpGuAQAAAAAAAAAAAAAA AAAAAAAAAAB+zlsA9u7mBkEYAMBoiYlc8eosDuRwDOBcXjiiCC2lVrh6eC9pCknL7wCfqAUAAADM aoGB+9Gmvn+Errum89h8iBGL9XgdecgiBiymkQcsapGLNWjxuWrIwxabF2maypyvK3sL359hHOf5 OQzbF/u1awlaNFPQIo4lbJHiFm2bqhGnUI9bxJpECNuyRHR5j/PukyS3MMctymZGrZ+R3/4ofFFb WwYranP5wfd/AAAAAAAAAAAAAAAAAAAAAAAAAADAH3gJwN4d3CAIgwEYbaNnFzDh5CQm3t1/AK8s AIktpME2Ra4mvpf8AQtUmOATtQAAAOAffQsKlGvPNI+jjYbhFua5v10ds1jjFNuxjli0AYtp6kcu yrO9mMXyAbHXTojL+notVveWtfWxLYJRvuk1jodBi1D+8yNsEUrUIk0OWsQctUiTixLnUEct8u9e 2KKtRZTza5otI7LrkubebHUKx9GKU6hfIzYTdtZ697YxizZ20Z4DAAAAAAAAAAAAAAAAAAAAAAAA APyUtwDs3dsNgjAYgNFiCA/GRF4dxn0czgFcxgGYQrlYoeQXXn04J2lKGy4NC3yiFgAAABCHBW57 D93vj9S2l+86tx+W0YkybDGFKoZAxRSpyOs4YLGMXMwxi/yd7dDEHKuogv1XmrfLvsJ8/zQ/u277 JyyDFnn+hC3GoEVdp6ofQ9Di0DTj+9cViV+ViZTKskR27sdx+1TZtR+nVMYq1tfRcfbCF9G962BF NEfFkYjQBQAAAAAAAAAAAAAAAAAAAAAAAADwF94CsHfvNgzCUABFjcgUKEU2SZENMntGYAwQiQWP YMSnjZRzpNdgy7LcUV1RCwAAAP7NUUgg1p6feZwd1DS31Pfbv9ZlzGKYohTDHKeIuEXEKyJg0XXj LCMX3/0Ry4hgRhm2iCBFGbKo5sDFel+slevl87zaNqXqpLEQIYuIWUxBi2XYIgct5kljVSLmMs1e 6GKrCpFTItfjW2W5fXFfHVWn82hFncprVKtJO9+29q5jFlsPLWIBAAAAAAAAAAAAAAAAAAAAAAAA APyktwDs3cENgjAYgFFE4KgXzm7iNo7GAI5ngglSSQFpE7x58L3kDzUpoeAAn6gFAAAA/y4XFLjt 3dR196JtL/Pv2JeIEYtlvUwMWUwxiyVUEQMWz+cwhy7COuyZZpjv23QspheYwxTr1zkk8Yp8HqLI 7J/OFDz6fu9TrA+yXMOZQtgiTFW9p6zr4tg0H0GLWI8oN+s48bTruEVwHqf57lTXcU6ZR+Qet45f 7IUvcnvTPyG9ph8+T+gCAAAAAAAAAAAAAAAAAAAAAAAAAPi5lwDs3U0KgkAYgGEzEAk6QNDaVYdo 07773yXMvw91nHIb9Dzw4eDPODd4RS0AAAD4J98CAvHs2c1jb6OmuRWvV367dcyiHQIR83WOW/Sx ipgxbDFPPI/78W3s2W7qFrloxWEVvIj1cjKnH77r/1fXp+HOELbIvpseYdqzv5blOFPUopyiFmVV rYoQadgiyhDLa1qLiPWlm+v+qc7d3JOtjsV+tOJYbI+znOLDvdy7acwijV2kawAAAAAAAAAAAAAA AAAAAAAAAACAn/AWgL07OEEYBgMwGoWCB5HqzV0cyOE6gJN5kEItbWNCDBVPHnwPfkxSS7ULfKIW AAAA/LNaSOD66aauu4W2Pb/2sS8RgxNpnSaGLOZYRdyHJVoxhL4fitBFujbfl8IWa39jDlXkwYq1 z7TOwxfz+RAOh9N0dn88qu+hGsXIgxbLbJewxaZpptmOZ3nMolyXQYuQ7fMnHsfZVX/Zm8s4++IR 5bqc+CLWwhe1737z4kNxrSR0AQAAAAAAAAAAAAAAAAAAAAAAAAD81FMA9u4eB0EYDMBwQcKgizNx 8CYO3sD7H0WC1FB+Csro4PMkX2yAlOrm9IpaAAAA8C++hQPSvUc/972NmuYa2nb7L/UyZtENIYpu DFKkuMUUr+iGeMU06f48fJGCGGm/8fDFXtCiWD23/Cm2+wrx+ePx/F4/46G2axpr6T3xM0YtYtCi n7KqQhmDFnHqehWzmBcm5teKbL38ViHEtMhl/1Snfm7ZVoewH63IGxtFNuHDta1n85hFHrvI1wAA AAAAAAAAAAAAAAAAAAAAAAAAP/cSgL27x0EQBgMwjMSBSRdmb+JhvBsH8G4OLiTKj9j6ATI6+DxJ U4qtED3AK2oBAADAv1oKCFy2DjXNtajr03s9tR6miEW6TiOPUozRijT6eEXbPkLoIn3W34+hjPTc 70GLz7jFuGfal5+LZ6d5v6+G+Xa/r/8gu/jdr3v9uiw/whZD3CKLWuRhixi4iEGLIlvnf9yxG9X6 2+XO3TgU825GfGx8ha3wxdLeGKxYmpdrInNCFwAAAAAAAAAAAAAAAAAAAAAAAADAzzwFYO/edRCE wQCMQmR1dnFm8iEcXXz/x3BiJIpcbCmtjA6ek/yhAVIuL/CJWgAAAPAPvgUDlmv3YW57G7Xtper7 /HZpfOIdpgjHELcI8YrnHK8IE18P8YtpXXrm8hnboEV8Lv0N+XV8f1034/HRdXu/ZeUTuJjDFmPQ ommmoMUy1TZoERchSnGLXBXiNMx5/7WOw1yTreLHluZQrV+jTqYqnMvdm8Ys0thFugYAAAAAAAAA AAAAAAAAAAAAAAAA+KmXAOzdOwrCQBRA0adCEGxi61pckWtzAW7I1hUE1ETHyYzBT2PjOfDIBPIn /RW1AAAA4B9NhQN2707a7w/RtpvH/i0okSMWeZ0nRynO92hFnj5c0XXnKnQRRcxiHMkYr8tYRb7f OGjxeNlZ2VRI0YkyYDHVW1gMq+Pp9O7TlNdJQYt71CJGYYshbtE0Me+38VyPSDMVtIgoyxLJ+jrL zx5ve51VlLGKel1P+jDfHlsHK6a29X/4Kr4CAAAAAAAAAAAAAAAAAAAAAAAAAPBzFwHYu5sbBGEw DMBFwgxeDCcnMS7g/jfvjEAQhFqpVI4m5nmSLzQt/V3gFWoBAADAv/sWFBDHbmNd9xZq23Po++3l 1mEWwzOUIn1TSEUKrxiWYItUcfw9+GIdbFG+RgqoqMb/5vZnaMXWc5TzEuJ+967be5q4ybq9hFq8 qq7DoWlCNdb03QqzKCVGVFk73Xx2HOu0f8Ip0OKSLV1ny29VPFZVqFDo25sTsvl5HwAAAAAAAAAA AAAAAAAAAAAAAADATz0EYO9ObhAEwgCMDsrBk8GrvdiN5VGA7XinBBJlwjayaTx48b3kDwxLMtDA J2oBAADAv1kKBlzfvVSWt1AU52HdBx/6iMV4Pk4fpWhjFeElVhHjFXX9mIQuxntpzCI9n35KG6tY yjykYYu1kMU8fpE+G/cS3atq899kXcCiWwzXYshiCFvs9+3kedjF6aIW05hFFuZhi7Q4EZJ1uutT M4fNXQ4uzRzDerhiramRffHsNFixdPy0MiJ0AQAAAAAAAAAAAAAAAAAAAAAAAAD83FMA9u4YB0EY DMBoO3sAF8PkPdxcvf/qzhEIIlBbqpXRxLyX/AELVPQCn6gFAAAA/+xbICBdu01z3duo685hGD5v t41ZjHMMIh9z3CLHK8Y1XpEnXS/DF2XMIu39KWyRjjHWkYq43h9f19Ok+8qgRb0+jsvne9/v/T3b N0qRizTPqEURtpiDFtOUMYs6btGqRZTn+ZctjtOc9l/vMM0lvActYmh/dRmyiI0JjbW9Z0L1fL0G AAAAAAAAAAAAAAAAAAAAAAAAAPAzDwHYu3scBGEAAKPFECYHXD2LB/JgHMBzOTKTKGgqpRR1cvG9 pCnlJym9wCdqAQAAwD8phQLOnz7qukto2+NrHcMSMTQxX88jRimesYqwiFVM8YphuGWhi/lZGrNI r1c/s4hYLDsJ5XDF+nkavCg3GkK49v36u6pwlGnIIt6aYhbTHmLQoq5DNY5d0zzmtCSRRy62ghYh Wae7OIyjWe+q5DSOfdgOV2w1NfLtfvNufvilOT/MdzEWAAAAAAAAAAAAAAAAAAAAAAAAAICfuQvA 3h3dMAgCABTErtFO4F9HaNIFuv8sxgqVgGD1s0lzlxCJREQXeKIWAAAA/KujMEBeey3jebbRON7D NO1vt41ZzClMUa4lblHiFfMarygjr9fhizpmUccz0gdUAYo8LxGLPlixnfdr/X4f8RxRilrsRSxq 7XoVuIhhi7CMyxq2GKqwRRuzOBtDM2+/8rqM2/FJoxi0eIQ+aDGE49fnY7YFkG8/Ot87eyY0z7f3 AAAAAAAAAAAAAAAAAAAAAAAAAAB+4i0Ae3dzgyAMBmAYTEg8ED05jvO4HAM4HIn8KPCBpcaLF58n aYBAKXSBV9QCAACAf5EKBNw+TWqae1HXl/l6akvE0MQ6PrFEKZ6ximIVqxjiFW372IQulnsxZhHP 49pvP1am2wjpWMW6vVDuxirKcf2svblzYOP1/hC2GKIWhyFoUVXjiEGLGLZIRS5icaII1/Erzv04 5r96cu3HKbFMrq8xbei3z6Y2f3vcbmYuygIAAAAAAAAAAAAAAAAAAAAAAAAA8BOdAOzdPQ6CMBiA 4RJGBxYXE8PkOVy8gfe/hQMTURBq+atsDuZ5ki+QkhbxAq+oBQAAAP/oWxAgPrt3c9s7qK4voW3n xy0jFjFw0Ycp0jXFLVK84jnGK9JMn6f4xXN19upDimm0Iq3NYxXrgMXQm0h7tkIZ071VdXxfH02T /5M24hYxZhGDFp8py2H6sEU/YV2UKMe354oRxeI+feHg1M05/2ujQzfXjdcXIR+qmIYsisyEzNre nrDYv1wDAAAAAAAAAAAAAAAAAAAAAAAAAPi5lwDs3c0JgzAAgNF4EIrQn3Nn6TrdzAG6Wy8eBCtK JKapbQ899T0IxqAk6ACfqAUAAAD/oBQGuL57qW1v4XQ6L/frAMSwrKUjRinmWEVIQhVhClf0/ZCF LkIxZpHOn/fO4xWhGLGI61W1biXEtXUYI+8rzJpmP13vXffuc63FPfO4RRK0qOp6mseAxauIxaug RUju05Mfx7H77JSXcRwK22wdJX6ob5/NgxWla/4DtuIsAAAAAAAAAAAAAAAAAAAAAAAAAAA/9xCA vTvGQRAGAzBaTAiDB3BxZvIOLl7A+9/BzZEgStDyU2RzMO8lTQqNpeABPlELAAAA/s23EMC0dh3G ZWujtj2lrptvFwMWU4BinPfZvRTiFWPAIh/5eilsMY5+5XTZi1XliMUydBE/w/zz5IGLaZ+m2b9W b/f75jk+z3xfjNdZ0CKFsMWurmdBi1iIWCtGVGEe3+wwjOP2cZ/FjnPhkVVaD1Xkx4pFkFJZJL+3 9ZuUln9YnAMAAAAAAAAAAAAAAAAAAAAAAAAA/MxDAPbuJQVBKAzAqIUDR2HT9tJ62pwLaF8NGpra rftIE4QmcQ78eBXFB84/UQsAAAD+3VwQ4LJ2Udddq7Y9vffztkSfHU8jF8/ARR+iFXFivCKPXMzF LNJ1eu/lvsVnxOK1joGL8nPk/YUsRhGOj/er62Za3+73tU9WxDSqGLQI23H2Y9AizBi0mKZarkas BS2qZD99g+MwzeoTT87DHDY8wm7DuXOFkXJb/q/fIi0AAAAAAAAAAAAAAAAAAAAAAAAAAD/1EIC9 e8lBEIaiAFoUR67AxDByISbuwP3vwgkTo3wClieIIwfmnOTxeQ2l7QauUAsAAAD+yacAgGHs2tRl baKqOqX7fTpdDLDIAyj6MIshwCKF8IrH2B8qH58LtuhrMcUixTyEGGLx6sXt5+/v/Wm4RWvXXW91 vXZkM0ssxns7b7HZpNRUe++CLcpyEmqxzeqbdIkiPMedHpo6rq9y39R55pdFWg6qyJcVD3OaFvLe W/smhe9jDwAAAAAAAAAAAAAAAAAAAAAAAADgZ54CsHcHNwjCYABG6dGLDOAqbuNqDOBmXjiSIKCQ v1gRD17Me0kDJTQUGOATtQAAAOCflUIAl0+LmuZa1fVpmedtiT67nocu+ilEsQ5YjOGKrssjF4+w xWvMIp7HZ8c9zOGJlFIWrihHLFJoS5SiFe/NoYzRrW33LloiFnEery9Ri2fYYhpVHq94F7IoBS2q MI9vVw/jsG/X52EcC4/Z2sb8cb69dx2sKB3XP2kr1gIAAAAAAAAAAAAAAAAAAAAAAAAA8DN3Adi7 exwEYTAAw2DC5O7kzOQd3Fy9/wVcuQEK1AZaCkwu5nmSL/KnVNx9RS0AAAD4F3t//B/PPYd5HH1Q 296m2MRSGq9IAxTjawxUhFjFOmARIxb5+VLYIsy7vLj4peo0XJFGLOb90JZIuwlzFGMZuig/vr4P x19dt72Og1BGvGaMWVTfWUYtTk2zClosaxF7xYg6286fxmWY6+7qJudh7oVb5svYil7UG1NtHDt6 T1XlP9p6GwAAAAAAAAAAAAAAAAAAAAAAAADg5z4CsHc3NwjCAABGW714Mnh1FgdyOAZwFDdwCZMK GqAlBeLBi3kvafgrKQHun6gFAAAA/6oWALhu3dS2t9A05/G4bEuk4nwZukjvEMUUrhgiFik8n2nc fvZDNWaR7+drL/UthhhFjFP/YCl2UcYrynvmAYx8Xkqfa/fHY+vVlXGLOK0b4rRezIMW3dj1UYt+ hLISsQ/LIYta0CJkx/mHP3XjsP3kvUs3jpVl1h5jeFHfzp0HK2rb+f+7Fm0BAAAAAAAAAAAAAAAA AAAAAAAAAPiJlwDs3c0JwjAYgOEUenQBLz05ibiA++MC3aFgQ6nxC4n14kWeBz6ssT/pAr6iFgAA APyDT3/4v/92X+d2dKNpuqRlibeL8YoYoMifJWCxfc8BizKpCl2UwEUrbLFNp2LResEQtogRi/qc uN4OXsQoRnpFLR7z/MU+0haz6B3noEWe/Lz3uMU4hjJEb3rFiKE6jm+X0nmdkinpOq1zbTzyaGv7 tobOpM7a0TWpur5eAwAAAAAAAAAAAAAAAAAAAAAAAAD4uacA7N3NDYIwGIDhQsLJgw7kPi7HAE7k lRFQ5Ke0gEjiyTxPYkBa4icD8IpaAAAA8I/WXvx/27upru/hcon5g7Qt0SbX09BF+w5RpPGKkMUt +pBFtx5DF+0ikjH+Zn7c/6vFFJaIHYnYScjP+97EViuhyNZCeDRNXJ2HKjbHKhahi2m+MW4xBC3K qgpldx6+D1msBS3C7Pt8svPrc9qedO46bD8yxvhgj+7NgxVrx/wBf4q3AAAAAAAAAAAAAAAAAAAA AAAAAAD83FMA9u7ghkEQCgMweOsCPXrqHL10g+6/imlFgwWqeOqhyfclL6LyABfwF2oBAADAv+v9 6D+/e871OFtoHG9hmurl6vCKOoAiXT8BFut9HWQRmqCL1zYn95VrrPucplh8fXqMbQhFGXARq3ll XxteUc7N99VxeiEWnffb+VINw1ZLqEWuFG4R+gEWvcSI2IzzV+bxda6xf/rkMtd9Z8u9vI29Y8WD CgfPznpC098+AwAAAAAAAAAAAAAAAAAAAAAAAAD4qbcA7N3LDYJAFEDR0YU7DG5txX6sjgIsbhIU iGZ+YEhcmXMS5Cf6oACuqAUAAAD/pvXC//u3i4bhEfr++tnP2xJjdjwPXYxziCKPV4QibjGGGJfI RRq4yH8jDVu0ZihuMgtZrIUp6u3lutA4Xv3D/DnN1nWXeTtOw9eD5OvyXHL+kC5F1OK4EbVYC1m0 ghYh2U8nmu7gVE/Ycnst551jvB/03u/WlZF6XT7YrYgLAAAAAAAAAAAAAAAAAAAAAAAAAMBPPQVg 7951EITBMICWgVEWJ1c2n8LBN/D938OExCCVQKFyWxxMzkn+UAq9ADufUAsAAAD+2dYP/odrj67u exPV9TW8XvPp5uEVeQBFOwmw6M/nQRYhC7pox3uGccMcaZ12XPfwC5iEW+SBFmv9qW8pHGMacNE3 qur8OT6b5vjGJvubBV/EioEWQ8VQixhoUZabwRVH0iWKrJ2eqHfpKsWWrDp1dVtYsgjHtlWsVFjp 2xsTQv7xvtsAAAAAAAAAAAAAAAAAAAAAAAAAAD/xFoC9O0hBEAgDMPq3Eipo1W26UHfzAN2sRYKl pc4MWgmt4j0QHRl19AB+ohYAAAD8k7kf/Z8/XVTXl9jvj+M4j0q02fk8dNH2IYo8XhFF3KKNpnlG LtLARRqyGI7TZw+xi+XXXG4fTBGLMnCRz51iFhHlvabYxSaqatefu95uSwvKV7dZ7i30IYtX2KIL XIxhi27rxrEuZDEXtIhknK7k8Ni2X71BnF7T1yxj+IBr55bBirl9+UHfxVwAAAAAAAAAAAAAAAAA AAAAAAAAAH7mLgB7d6+DIAyFAbQQ4uQLmBgmn8P4Er7/7shOlIBIuSI4uJickzQtPy2XsvMJtQAA AOBfrf3Yf7x27dpla6G6PqW2nS83D6/IQyyGfgqwGI7nQRYpBF3cX/eM88Y18nCLJXngxepmFPNA i/x4GudbFLcqBmJMynLX97em2S4k1JPyPhv3dY1hFs9WVtVqcMU36RJFGMe3PHTtuF3+vmvnhUd+ ytyIZcXUkbjR8dzWnJTih3ofAwAAAAAAAAAAAAAAAAAAAAAAAAD83EMA9u7gBkEYDMBowYsn5ewq TuN+DOBEHpmABBHEtLVCTDyZ95KmQiT5LXc/UQsAAAD+RekP/i9bD7XtNTTN6XWdBiSG5H4auhim EEUarwhZ3GIIfT9HLuLARRyyiKMV+Z5MUoxbpJ2EUtBivYWQHln6fBXd3037reveB8snqgqvYYlY PMMWVV3PK/78CFtsRC0+hSxKQYsQXccTHce13/wVk/O4Dl+OsRzct9/NX0hpzw92LeoCAAAAAAAA AAAAAAAAAAAAAAAAAPATdwHYu2McBGEoDMDlAM4uhsl7OLl7/yu4sRPEkEL7FMHExeT7kpdC4ZWy MvALtQAAAOAfffqhf752G+u6tVDbnlPf18vV4RVliMU0LgEW03kdZJFC0MUw35P78hpluMVeuacM rliCJOrjOuBiuf4adrGeg/C8dximzwf3rtu9z9w7j2XlDcVAixBqUaZDfBNy0YTj+JbHsU7b2z+M dXnzyL3balYqrcxt9aTQH+cAAAAAAAAAAAAAAAAAAAAAAAAAAH7uIQB793KDIBAFUHSWriSubcWK rI0CbMg1DZAgSkbfjKAQd+achPAPDwrgiloAAADwD+Z+7H/+dlPbXlLTHJ/7ZVtiKI6XoYvhEaIo 4xWpilsMqe+nyEUMXMSQRd6Oz17bt5iuW2obfApXhNBEyp2JGMNYdu26dcPFeMXbqVfc4h60SDlq kddh2i0hi7mgRQr7cZrDuOzWvclpXPYbx6jHX3ttHayYW9cf9VPcBQAAAAAAAAAAAAAAAAAAAAAA AADgZzcB2Lt3JARhKAqgpHcDWlC5EN2D+9+CHS2GT0hAEB1tnDln5k0gPwIL4Aq1AAAA4N+8+pF/ GrvFuu5tVNfnPmyiNA+vKEMshjYHWAz38yCLPJbG05y0Lu1Rhlt8o21Dv08OsXgOtEj5Ejm8opxX TfPy3HIsxPMO1/emWT1D2AqxKAIspvuu6QIsUrDFGG7RB1qMtRVS8UnIRVhc5zccHGOd1j9p6RDr svLId48VNqra6NtbUy3WL/sAAAAAAAAAAAAAAAAAAAAAAAAAAH7qIQB7d3ODIAwGYLjhaqIO5DSu xwKu450ZRBAqn7X4E08mz5MQBGra6s2Dr6gFAAAA/672h/7Hd29q21Pa76esQQ5MLJaLGLlYAhd9 CFvkkEUZuOhD3GIJY+SQRZyzPH+1+TlSMcYt5jspfyQxTPF4TtX7tcjF6HKZfj44d937tRQBi/Dw 6Xwb3zTT6xC1yDOvhS3WQha18SlcxxXthmPzcjd3h+HYVqZ5tYxyC5+OXfvCal2OVDwrCV0AAAAA AAAAAAAAAAAAAAAAAAAAAD+7CsDe3eMgCAMAGKWJZ3ByY/IUTu7e/wCunIAoPymlRejCYvJe0hCK bQkH8BO1AAAA4J8c/YF/fPYaxrO2Udvem77Pt8vjFeuIxXxNAYv5vgxY5KGLz/KbuC7usY5bnCGP V4Rp79SOSMGKGMBIc3FNimPkz8PyXUbvrtueWcYr1nMhbM6P4YswxiyGMV6nkEW8Xi5Z4eEoXlEr RpRhjPSFZtdh3A6/7GRsXzx+HFl7vfhaYWc0O3O1NU2xvpwDAAAAAAAAAAAAAAAAAAAAAAAAADjN VwD27h43YSAIA+gSpaNKk9PkQpyNC6TmNkkTiRoxscGG8WIrYIJS5D1p5F3/jt2vv+e/bgAAAADu MPYj/9VPF63X72W5fD0FTJzFKXDiMIs66CIOQRTD8IpShVtE2e2OIRc54OIclHH5jLyd9wkWKZTi mCkRMZadUEaCLRYpFGMYblH73G77m9/YYgrA6Csfa6sLtXhqqwyTHNr5vlwmRtT7cvXHohvn+/Td vzT1cd0bvDW1aerrhjbyY6M7N6oqaZxbLN08JrYlXZ/PrU3tBwAAAAAAAAAAAAAAAACAfyOvp+bh 5nzsX10THfMX7wMAAAAAE74FYO+OcRCEwTCAEgdcvICJG5O3MF7B+5/CgVEppqFtWjEao8N7yR9p oaXgWvJtfr0AAAAAeFFr80qawHCZ6rw20TAc54CJVBk0EYIoljCKWxJg8WjnQRbLuXg+XhPHxbmW +nwjTL55Kg2nyI/z6hr99dcb5glr7/vt3L6OY+2i+nHaLoMzQphGCLKIv1PFYIuY7pCGW7TCK9J0 iVp/OVf65MF+qkP1yTO7qU6VW64tLS6r9rKf/UFrY7pifNkHAAAAAAAAAAAAAAAAAADwDa3voNsf rb8/JwAAAADwJ+4CsHc3KQhCUQBGddYgDIJ2035aXBtoZw0cWFqPntenFQURnAPiT0+9NQ4+UQsA AAD+VelPKIdnNx2Pp2q93g3H465ENwpbpM/7+MQjcNFlYYsUsoiBiy6LW1RZGOP2rBjPmM7xniEK UdejwEUMWpTOxx2K/Fp9v/ZY32ua7bA/t+3SMLMzTtakmWfCFr0YpogFibmQRSloUYXnJJvrtpr/ Rrn9dWsKr1kaIzY5Xl0bgxWlffyxl6IvAAAAAAAAAAAAAAAAAAAA7/o0NPHN+wEAAACAH7oIwN4d oyAMgwEYjTjp4iy4OXkJwTt4/0s4OBUshl/TGNuKgwjvQSBo0kZd1U/UAgAAgH8w9of98dy5H6ep C+33h9R1w8vVoYkcsUiPiEXEKXKo4jVgEaGLeD7WlHvjHhHK+F67b1AGLPJ8uC7ff/FYOwhOVO2E 8lqr1eY+u1yv807XClzUQYsibJEibLFc3kcrRDEWsBgrRiyq+fPdyLb92E2/pHU/jo1bTh0tjtX6 wlV9nPKxqT0p1R/Y6xwAAAAAAAAAAAAAAAAAAGCOTwIU734HPWf/p+vrfQAAAADAD9wEYO9+VhCE AQAOSwcpvHTqEXs5X6A36+DB8M9wbiOVIgi+D2ShLaddBz9RCwAAAP5RabPJfWtS2z6qprmNn9dd iX4VtgjXQ+BiGqsoVtHPIYs0cNFHcYs0ZtFn8Yx8HUetX8MSsciDFiEyMYUsprDFFLdIX+V6bphX 15dxfHbd/tVFEYsQsAgxi+z8HLMYwxbDUS27ik6FcStkUQpaVMnvBEOu47zvkYaoxbVwm3fLiB/j yHfTYEVpzP+8MpuzAAAAAAAAAAAAAAAAAACA2KcBim8epfttrRsAAAAA+KGXAOzdPQ6CMBiA4crg 4gFc3Jw8hnfw/pdwYPOnIvpRkRqjxuF5kgbSpKXsTV5RCwAAAP5d7QJMtjuPbW2j9XpziU1EZWii D1bkCEUXpkghYhHH4Rq4SCFkcQzhi+HaGLf4nvK+zljoIoX5ct0wfhH3a5r55blv2/opZhN3gELQ 4ha4aJp74CIHLXLcIj2GKcqgxdh4Vowo9+v/un9fnseq+mdpkbqwRfnJ2tH6Y01dshqbq61Jxfpy DgAAAAAAAAAAAAAAAAAAIHsnYjE2NzX/yZjFK3ELAAAAAOBHTgKwdwcpCAJhAEaFNi0iaNFxuk93 6wLdqlU7ydT4UadpzBZB8R7IDOrYFLQTPlELAAAAfk3u5ZLj3KLT6VxtNvt+Pu1KNJOwRVyPwMVj HIIVEa2IkEVdN+1xm5yL+8chizSe8byP5cbhiVyMIubPMYvx+VInYVjTNKt+frleP9hjNQQscvNu 7GIWEbToxmQ3pbjFq5BFLmiRPi/s2mP93lc6tMc28zGlbcQPvPTeNFiRG9P/Q+kFMgAAAAAAAAAA AAAAAAAA4P+VAhJz930rbJGuz+2pylxP9w8AAAAAfMFdAPbuYAVBIAgD8HbtDYLw1HPUW/T+547e hdzMXCfFioSI74Mhd2h0BY/KL9QCAACAX7b0ckx2buu0dKKqOqSmGZ8uBk10oRVdCEUXTDH0+sCK LrSiD7YoAy6GdZwtwy2+LYdCjMMryhCL8XE5E3vT62eXun51Y4/girl99//JIRa3Xv7N63uwRZnw MBdoMVVziRGbcJzS+EHatbVfvrNtW8eJSy5trd/WOy9zpRdmUpiPPQAAAAAAAAAAAAAAAAAA4L+t HWARP/suP9v+tMr5eN245xT68b4AAAAAgJVdBWDvfm4bhKE4APuYWzhnimSA7tL9skBXyQRsQUKK Xgvm8UdtLpG+T3qyZQwYcbX1E2oBAADAO8k2lHxu3XS9fpWmOX33p7kS90mwRVyPgIuhjXCK+yjM YhxyUQdcPKv7ufcZZFGHZ8zX8V/rIRbDeIwtBVlM22F9v3O7bujf2jZfwVKIRYyN27ofwRbRRpWS 7krKwi2WgiyyQItSPScc+zqkXzfz0VeTvGZtGfUmrb1z8x+U53KU6lrNhiwAAAAAAAAAAAAAAAAA AHh/fwmx2DtWH/G+9HUu0/PPW2EXS+en96ynlPk3rZ2tzuYDAAAAAC/2EIC9O0ZtGAagACqTtXuW bpl6iXbKWnKi3CgX6S26lhyiqoUiRciRCaG08B58sIVtybvEV2oBAADAXzXaPPPjELMffWi3e7mU MmRt0UQqrUglFKnIoozVJRal2KIUXJTnc5FFmIstcjFGykNbLK6kIovrvTv1WCm0CNVYXYARuvf1 89nn+bxmQf37qZq3mm9qyi3mbDbd3Um9Qotelhojpua6/cNtzPP4D59iXjtTjpaWl7W0USssjI3e Cc377RgAAAAAAAAAAAAAAAAAAPA/3TpjPHrunhKLt5hjzCnmK+Yj5j30zzyPiivaY+JrE5rrcOMa AAAAAPgF3wKwd8c4DcNQGIBNxdYFBs7BCeBAXK0XYOQOXThBJTZOEJM2cfNsJaSVQF2+T7KcvjjJ a7vG+u9v3QAAAABcaO7Fkre1i3a797TdPp3DJia5CrY4VfIUcDHMJdgihzCLGHLRBlzkEI4x3LN8 LveP81+KIRRToMX57HlNHVYxV5uujyEXXTfkYn4eDtUzT2Edx3Xjl6pqbbhF3fDUdwm72GyqYIup y/ptpa6ZY2JEW4ujnMvjcbxf+Use+/G13HX00o+Pfnxf0UZ8bB7X5makcBxbLD9DXphTuD6ubS3V AQAAAAAAAAAAAAAAAACA27sksGFuzbW14/zQj9c0BFk8p2EP9Zx9Wg7UWOu37G2+m6mtiXuqU/p9 r7R91AAAAADwj34EYO9echqGoQCKmik7YMKkI0ZsoeyBlbIl9oCQKtV1lRi/uk4TIfEZnCM9tYma jzq2dUUtAAAA+I+WFq7EhS6vZV7WbrTbPaXj8fJ2MWZRIxZTiCLPIYt2LkYsWtiiBS7a79NXzKJe W+MYeX7Y1HrYsoboO/r8Q+1KhHjEVchidM1y2OLs83C4iFisv9Z0jzzfO8fYRQhZpBC0SHPUog9Z xOPcfY5mVJfI4VxK1yugzscPZT7KtHzH0H2ZfZm3lUeOXit2NfpJC+fi35C6z34R1taFWQAAAAAA AAAAAAAAAAAAwN/6yYjFXff9eZ4asnjc8oLFe2pbtNeeU422cvfXjPZBx/3St/ZP20cNAAAAAL/o JAB7d3CbMAwFYNjckbgwTtfpdCzAlR3YoyO4JOgpzyYRblUVIX2fFCWYJE44G/2iFgAAALyDtUUs n88uOp3OZb8/zvGJtsFQm7DFPFKXIMV9H3GKmmIWOXLRBy5qilm094zjyXTO/EJ/GrfoYxXRjVgP VbTjy3Xbz7QbblikyR/H0viu+zyPRdgixy7SxH3kIu9HqxLxXa5KxHjMdCj3YsWAj9t2uW1fP3iM PG0tS+QibyUd50eMn2FrIVYp7cKrrYVYFmgBAAAAAAAAAAAAAAAAAMD/G/2T+Ug04tl503HEKyJk cRicv3ctS9TiN+/Q/x96LUxRy/a9hS0AAAAA4MW+BWDvjnEahqEwAJuIjQV16daJa7BwBY7KVThC F5bODFTBgT5iG5MGIRDD90mWFcdxnMzP+oVaAAAA8N8sFdTEvfvc7s4ttNvdpONxqMbaoIkIohjH OZAixsoQiznYYg64mOen0xplKEYEZ/RrYGL8p+EWdSBFXWM0r90GVnwOtlh4w9uc6Xs2m206HJ7S S/74y2Fopp0CKJogio97nesItqjCOKZ1I9wi9xf5XWWqQxlsMTZ9r/XSJcZiLKW6cimut7k957Zf /jlX6b146+HMK3vbKnM12hbbie3GWPkbUtMvFWApxgIAAAAAAAAAAAAAAAAAgL+35jB5b853x6b+ OtUhFrdrNrjCY6rPQS/tpXemeU2gRft8O68d+4pz1QAAAADwS14FYO+OcRqGoTAAu2s7UBgZuAK3 4nK9ACtn4BRsiKkTJknr5tkkagpUYvg+yYplJ85r5xf9Qi0AAAD476YaWp7OPbTbPaft9v4UNjHK VbDFsJLbQIoSbJFDmEUMuWgDLvIpCKMf8cwyj9eqml+FW8QeoxAMsaoDLeJ99fr0GSUgoy1ps7kZ Qi0+9vt0t15fVml3WD5MykLcrMbqGGgxzNP3dIYYchGvS1Mlyl5MlSjr5T233Xhb9tP6Zq6Xbrxf UEZ8bU5jyEUcKY2NVbHE8jdMNWzFhqzU3NvSkAUAAAAAAAAAAAAAAAAAAH/rmiEWbajE43GUIIuH JQX+wGs6fA89V1c6s5ebeRtO0c8/24fS/HfUc99aAwAAAABX9CUAe3eM0zAMhQHYQR2QGJiZO3EL xBW4KVdC6spSMTYkpY+8WKa16ADD90lPSRwnjjPb+oVaAAAA8J/8tIAlJzO8TPV86UXb7WM5HNav q4MmIohiDpaIQIpoyyEWS7DFEnARfeK5dShGBGf0r335fbjFun8EUsS9HGKxhFVEYMVQ8q9dhh7S e5babG6Pd9/3+65Qi+EUUjFWbdH+PWiEWZyCLMp8nOp4nWaZ0yByIkQ+tqqVLjGmtlLWK57i+mGq j6l256d5N9XTVK8Xhmx9Vs7VqCtPOy+0yr+hVMexOm+1AQAAAAAAAAAAAAAAAAAA1+vdGH4unKK3 33we4RURZHHfOf613srXHufeeczqfc2tMIsx1U3jmdJ4xp5pAAAAAPgjnwKwd/c4DcRAGECNIqo0 NOQCXAMuxO1yAiQa7kJBkQuY7ArHs47DOkiRKN6TrFnZ+2NtPdYn1AIAAID/rNfI8rr20H7/lrbb x1PYRJUXwRbzTG4DKUqwRQ5hFjHkooZblPUShDGN+M5yHeuav4dbFOchFnW+/85T0MTi+bpWbDb3 c/08HNLTbvf7Lpowi9QGWfzUuzDiXkrwxaXEhhhyEetoqkRZi6kSZb58Z+riWo/umD0fx/txfF2x jfjZnGrIRRwp1UaruMX4S3o1pWUz1qXmLE1bAAAAAAAAAAAAAAAAAAAwZuQAeO+ea+em+pCWIRYv Ixu8kY90Hmox8i9y57o9Sz2id4a6PWMNAAAAANzYtwDs3TFuwjAUgGEnay9Ah/YKHKf37JnapRsb UwooffWzlYagiqrD90lWhEUSg5iQo1/UAgAAgP/ip40rucbwUubNN6t2u6cyTe3l+tBEhCguEYkI UsRcjljUsEUNXMR74rw2ihHhjN/tfbktblGDEPU4NPN9NKK9dhu86M+v8/PfCB+Hw02fpQlc5Hvn yEU/xrEM4/i9ujg/1yByESIfl8ZSXeIzzZXS7mCK14/ncTyPt/WP+FDm3+XrlVsuLSt3NfoRy4nl xlz+Gkp3XNuIZVMWAAAAAAAAAAAAAAAAAABsc8+IRR+I2H+NCFk8b1ngH3kv83PRF1vCFmsxi6G0 YYsY05U1LD0KnnmmGgAAAADu7CQAe3eMFCEMhQE4dna7tdfzeHsBL+BltNyeiOiTRwCJFuqM3zeT CZsQyFK/zC/UAgAAgL9qq4jl/mjR5fJQzue7j7CJWV0EW0wjtQ2kiGCLmsIscsjFHG4R8xGEMQzL Z8Z17r/jKNxiHWQx/dodTysX963n1++p9a3W6Ol67dt8Dq6IZ7R7T20KsXjv89zN+A0isCKqkXKo xdD0vakSMZdTJWI89nka223fv30tEHsc2/MXtpFfW8sccpFbKXOBVt5ifIa605eyLLbaK75SlAUA AAAAAAAAAAAAAAAAwH/XE2Cxdd/euqMQiwiviCCLU+f7f8NeqEVJY1vnldtAi3zdBlrkY9+f2To/ 7bw0AAAAAPyAFwHYu2OchmEwAKNmZGPjAJ04BEPvgMTNOBMHYWfpwNTgFIx/u24apApV4j3JcupG iZM50idqAQAAwDVY+lin/PeUx/bchTabh7Tft5frQxMlRDEHI0qQoqzFiEUNW9TART0//YQzahSj hDMu/83LUtwihivm43pOG674mmLsov6O5x9fv32H77vdcI99tOKkGLvonucQtvheP8Qt8pjyi49f EsUaRCxCxHk0RnWJ+JVTCveIVYj7PD7yeFt+qts8nvN4OXPL0bZiV6MfZTtlu2UtvobUzVN3PFoD AAAAAAAAAAAAAAAAAID/ak3E4lTA4Tdr83yX2ojF45oNXonX1AYt1sY/psG8FLQoMYt4PLrezWAN AAAAAPgDnwKwdwepCQNRAIYna1eFrnuBQr1Wr+cJeoWueoe69ABJI+aZl2lCUlCQ8n0wZIgaJ7rN 8ItaAAAA8IjmHmZ5X/vQ4fBRdrvna2winIMQEWXIcYtpkCLCFl2KWeTIRR246K4hjLadXjPm+Xgr S3GLMWwxPt+UYxe/GwlNCmDUQYxm5ppNf5+X9MPxdFpfaF5fRCxyzGI4PwY30nyIWTTp/VFiyE8h 5ahFWx23ViXitVyViPPx1z3143v9js9e+/HWj88/LCN/bVfGyEUepYxxirzE/NPMHUuZPoy1FLQQ ugAAAAAAAAAAAAAAAAAA4D+7Z8Siqeb7YUTI4mXLAh/UV7nsf84b1beo90kvjZKOef90qV6b2zsd 57uZOQAAAABwYz8CsHfHOg1CUQCGr0/g7NBF38kH9xEcdOrqKJaS03s4UspCE833JTcQSuktaTtB f1ELAABgd/XP96G49gHJFYbXNl2ws+pweL6EF8I8bjFFISJgMcYqesyizSIWPWzRAxexT4Qs5lGM 4XL8e+hxi74tRyhq0CL2+x26mAcl6vPz93cYpvX343F1buNzzvOrEYv0eD7uQ41e9MlO+7Z5rWGU axC5CJGXS2OpLjGkba0tX9n0dBpfp/Gx+s7PXk7j7cZLLk0rdzXqiOnEdGNbPg2tLOvFV6sXZPmd /t/u9bsEAAAAAAAAAAAAAAAAAGzn/s7dbD2xa3GKrfuN6xGviJDF48bX/ws+2/WoRT0vNVJxLWrx ndZb6/dLx73TsWxlPY61FL0AAAAAAHb2IwB7d4/TMAyGAdjtmoWF0yAuw/V6AWbOwMABuvUOCQnN F9utq6QDokjPI31y4ji/s51XqAUAAACPpjXZ523tpMPhPXXd8xI2EaafuZ/DJnJ/3i/DLIY53CKH WOTK4RZxPIIw+r6+ZmyX7W+qf1ZfB1P8bO2uj0WoRCvg4nxOPZco9uNWn8djNXYJsLj1wvO9hhjf CrGYawm42O/TbqxWKEY586gMtegv2q2pEnGsTJWI/nijaeZY1367Sy9jfYx1uuMxytsOKYdclJVS nmRVPmJ8huFGm1I9Gesq0GKlHwAAAAAAAAAAAAAAAAAAHtmWEIvWmHv7pvYp1SEWr1se8B/7Su1Q i9Z3WguziJrO7VNeex3K5eLlOulyHbS10gAAAADwR74FYO+OcRqGoTAApxVLb8DE0omJQ3ADFm7G 4bgIS5XiiD752ThqF1pUfZ/0lMS1Ejfzc36hFgAAANzSWoNQTlt4K/V67kb7/fM0z+3t2nCLGmKR Ayny+eHwE2JRgy1qwEWEX8Tc5X7LvHw8XiPFYiCCOxY1rCLyIPL1JgVW1LFqHGbx+7fyrspLeNhu p1WDMIp+bJODLNKcZp0RclH+YJ/QkDuSciJEPo5qlC5xnNqup9zVFNePpb5K1UiPoV2p91IfZx45 WlbO1egrlhPLjbG+MSsf++asSxq2AAAAAAAAAAAAAAAAAADgP/vLEIt+g/XLqSLI4umSBd6Rz1Lx rbr1zeftvuW1UIs5nYfYg533T8f+6n6sfw4AAAAAcEXfArB3B6kJA1EYgF9dCaF11VP0Yr2eJ+gR eoseQBDBRVMlffoyGkwXLVK+D4YXJslkJusZfqEWAAAA3JNrG4Feb720Xr9F1z2fwiZShj1kG/ra gIs4hVdkmEWGWwytv7hfgzDqmHld61/IEIgabvF9ZxRocbmPZxx28dAGTJRxjo7r7rqn2G43sdvv 43G5bCcyLDxre6/WMvc6h6htsZiYzznJoa4m+2qdmypRdzt9NuPlSlaH1qx4yksMm9PefzCN+tk+ ziEXtUWcN1/VKeZv6CdqxHiD1lSghaALAAAAAAAAAAAAAAAAAADuyZwAi2vPTb13K8QiwysyyGI1 8/v/0ceh7WI499yGS1zTN7WGWOS553p8O8pzi3I9Pgx/eU46+9pz1QAAAADAL/oSgL07yGkQiMIA PFygMXFn0k3v4cI7eHFP4QlctQFBOvIYhxYTrTb9vuRlhmGAoekOyC/UAgAAgL9y6kWgvO+5r6dz J9pud6lt56ebh1vEEIspkCL3h/1liMXhMNYwNgZfpM/jhvnDsbHtLplisSCGW+Tt4540BVw0xXjZ zkMwpiyK5uM+N5v7MdRiv/8aarFifd3YmSpuxxCLEHLRHEMyagkNMQ0iJkLEtla1dIkuzd94yteI 13zo662v1/O3u+vr5cwla8uKuRpl5eXk5eax+DOkou2Kfm0MAAAAAIArtRQOzU25xj+B5xM/4D88 nwQAAAAAAAAA+AVr3oepzfnu2NDepXmIxeOaBd6Q4ZPqWqBF+buWYRYxxCL328q8FOYtVdwfj/Wd NAAAAABc2LsA7N09TsMwGAZgZ+oQxMbKFbgA9+FwvQA7MxfhBEgdQmj4EttNmiIRRMXzSJYb58/2 WjuvUAsAAAD+irlFQU9rN+33z6lt78awifD5EZchbGJqn46nYIsIsRgCLros3KIMuBjOdUUoRv7M +J3Xv2Mp96AZ5yACKo5nToItUnHvkCORP6t8x27XHlveD4fh4pXBRjBFfVXx/irgoolwi7x9RiQ5 5D2Mtry+NFUizuWpEtEe/b/ty83ZEY8e+/LSl7dvdCN/bZemkIu8pFQuvqqnoVuoUyoXZi0t1LKA CwAAAAAAtneNQRQ/aavx+48DAAAAAAAAAOD6bBliUW+YfvgqEWRxf0kH/7HXvsR36ubmtl6vU4da 5IEWTZr2RMdx7JWOe9aCLfL6XD8AAAAAgA18CMDeHaM2DENhANaQoZ26ds/UW+QS7dF6xELXQsgW 16oQehZ2YkJxQ/k+eFhRFEvxaolfqAUAAAB/YWlzUUxTeB3rcO1G+/1LOp+nt5uGW8QQixZIUdv5 +z7EogVdpC7koozPv43XYdsUi0U1KKLlQJTwirK8uI8nhXEt7KIFTUwDMKLd7vHn+nU6rQq0GKYd JbSi9ofPcf2pD7Togi36hIaYBhETIeJ1rubSJYbQF+eIcz6PdRzr4+K/Tw9jvY31fmXKuWXFzVlL qSV1ubUvPobUXYeuPdcHAAAAAADcbquQiv8chvEb7ytufT7elQAAAAAAAAAAbGPt/o5L4RRrx+V2 Da+oQRZPK+en+Ezl7HPWn2Guhq49V1k8wh3HL52njpyHBgAAAIA78C0Ae3dw0zAMhQHYudILF6Zg BsZhui7AFkzAFNwbZFnGz1YCTlWhCn2fFDlxEtfJsXnWL9QCAACAe7BVXPL6203n81s6nZ6+wymq HDJRwiZafztuwRYtvKJsfYDF2p1vbTkfx6z7sf17fRBFC6no64Py8y8hJGIMsuj721hN+SvhM4da HJldDLiIYRYx0GI4XoZrttQkh/oES+iL7WyqRD0XUyVqf51/rlZ7mHvs51SK3N4PTCP+7JpayMVY uBWLtMbXsO60KfUFW3sFXAq7AAAAAACguHWIxLXj/ecwi2rrW8a1jo5x5P36hgIAAAAAAAAAMG+m LmMvxOBIX24fUx9i8TIzQX70kcpa5zEspBoDLbJLOL4M18Sl3MuwPy6Mj5uaHQAAAAC4A18CsHcH SQ3CUBiAI7dw48KuXHkG7+DFvYTb7lyWEjHTR0gFa2tn7PfNvCFAgMCWZH6hFgAAAPy1Y5OP4kST 16Felm602Tyl3W56u2m4RQyxOIRZlHY+3wqxGAMsDufKdbl/vrZsx2PXnwMzDZ2Yt2NARTYOuRVa cZe+mxs29us+2+/b7clj7av9FGq233WTt+lDO4X9mAYRZzDFbata6RJ9OBafEZ95P9RH/g7Lr/w4 1NvCI1vDirkadZXhxIla9WdI1bav2q1jAAAAAABwa84RFrH2HucMpvhvIRd1KPdvnfLvY23/NePz 3wUAAAAAAAAAuFWXDLGoF1E/f1UJsnhYM0B+ZG2oRZ/m65bLeuq4bDulebDFsUCLWgy4sDYaAAAA AK5gLwB795LbIAxFAdSMGWTU3XRF3V1WkL10HHUJpbHoqx2HAPlIqdA5koWl2NjAkBeuUAsAAABe baqo5GNp0n5/SH3/9hc2EXLIxBhmMdVKsEUJrxhbCbdITbhFPW6cO65TjrnlDIZX5lvUwRYlxKL0 4/eua0Ms6mP0Lx9JXF+EeHwej3ObOe93U484TY9pgy1+9zzM3OCoZqp3X1c4tQkSS6kSdSXUd3O+ 2MHu1Pr5qwrvp3Y4ta8btlEvO6QSclG3lM6LtdrbMFw5ppQuPgw1dWMVcwEAAAAAsBWPhCQszb3n 3I+GNmwt0OLZ2rzytW55N7I0bmlt72AAAAAAAAAAgC1YW58xF06xdlzuR3hFBFnsVq7PfXKgRXyj bk09TNvynPjvcxtsMRVocS3cQr0UAAAAAPwTPwKwd/c4DcNgGIDNxsjK0IV7cA/uyXXYQZ2Za1JF Jrb1pUl/gqj0PJLl1I3tNO1mp69QCwAAAP7SqU1G5b23obwuDbTbvaTDoR2uDbeYAi7qQIpyfGyP QizGAIvpvdKvjNPX7XzL+Q3bmvboTMEWbaBFe87MKEEoRumT83j8sd/P9s1R+EQXVNGHVpS6BFo8 BOEW5RP2/0RUXtdpEHUiRF1HJUqXyKndHRXN+TyU76F8hnfi12Maf8/vC1NGl1XnasxtxiqXW9rq 25C6OnfHURsAAAAAANyjS1doTvU7Z8xbnrvlatNWY1+7xrDmurZcx7g0CGPNmBGhFwAAAAAAAADA PVqztyI659y2Y/2U2hCLxWfPubmvND7vXPTfWe6O+9IHWcw9M92Hl0RzeQ4aAAAAAP6BHwHYu3uc hmEwDMDei9hYuQJ34nq9ADfgFgyMSD1DWpoa/xAnaZsQhueRPlmNm9iputnWK9QCAACALQ1tOHqd umm/fwu73dNP2EQUQyyGKwVbpPCKvlK4RajCLfLv9ff24+RjDrdbhFvEAIpWiMXvvuLuRls+p+v6 vUOfh0PRXwdZnK/lARZlZxlaEccYqwkxySG9abqWt3NTJWJfnioRr8c3fTzVw+TMzr43zL2f6uuK aeTDdiGFXOQVQgqnyKcYf4au0YZQbtxqbeSywQsAAAAAgP/mlhWYsdD1JcZbIhjjnpWlTSPXL66Z w61rD2OH4ufMZak1j3y95d7ntKz9DgAAAAAAAAAAc6wZYlEHGbxcKgZZPM+ZIKv6CP3Z5bH/QX7e eSjQog62qM9F559bgRa1+uw0AAAAAPBHjgKwd/c4DcNgGIDDyMTGDbpxCe6AOBon4wowdmNtSNp+ 6hfX+SEVLUjPI1lJbcd2ssbpK9QCAACAa5n6w6Boe+nK89xAm81Ts9sNhyuDJiLgIgdSxHlfXwux OARYnNriuhinPE7p+9wu2GJ/lmsrARfD/sP2Xjuoi37xnD+228MN5gdf/o6643EfdHEcq422HHxx LHfFNWf32Jx2GJUJDTkNIu9mysdaqaVL5B1TeY4852NXvrryebbKgfuuvHblbWbK2rJyrkZZYjl5 01b5GJri2BbntToAAAAAALi1n75lWRtcsbb90nGX9lnTd03/3zIWqr3murlx5q6pBX+PjbV0DWMu Db5YFNhRvEfzjoc/oS3fFwMAAAAAAADwXyzd6zAVTrG0X38e4RURZPGwcH6u5705fOvcm9pfUwZa RH0Othj7Tjor62v9fAsNAAAAADf0LQB7d5CTMBCFAXjKjp16Dc/ghbwdJ/AI3kMvQMICNfXR19KW KQGJ4fuSSZOZafuAJa/9hVoAAABwK2PNJq+nTtps3sp6/XQImwgRYjE+umCLLryiHV24RRmEW+R9 7bntffI9j+eymP+7cIuujycCKZrmONCiqyfvLWlv/1r5p4rPtN3tziyx6R2bYZDF71qzWh3WYt+p F6BEV1OuPubysTZVItZyqkTMRyWP3+Oj7pM/l7ax7n1BGXl+X7qQi2FTV7wYKZcYX8N+4lhKv2lr qolLcxcAAAAAANd2iXCHuWssXbvktWrWrxlucWtL6x1mjNfuHzunJhhi7j+QqRCMpWEaY84Nvaip d8k5AAAAAAAAAMD9quldqO2tmZv7OT6UfojFS02B3NxnaZ9bngq0yP01ecTz0aVMB1qcCrn4b31S AAAAAHAXvgRg705uGoihMAB7hBRq4JAc0gDt0DZN0AEHIkUh2xPOk2fJCkjfJ1me2LPYvsYzv1AL AAAAHmHoIz3R91YmbEKaz5dlve5OgiLqcIkIsdjVdSBFHO/aWyEWhwCLn764Lu6T63P8XrhFKfXS 12EWOeii75qDzXEO3X7us9lzWa2+eh7d9U84BVrk9pNQjareB1o0Zpi/ahS/I9WhTnnYpLpVWukS eedU65kv2/K5LR+N5UiW2/I+8shcYsh9m7ZiOHFutNXXlFRv0nGrDQAAAAAA7uHaAIdLQiXOuc8t 2q8JvrjF9deaGvpwD2PPGwuYqM8bW6vWOX0B4H190T80rnPXcGjsQ//jTAnxuHRMAAAAAAAAAMD/ d88Qiy4dvx5LBFkspgyQP2cXavE00B8hFln9jnP9/nPr5fZSLt8TZQ8MAAAAADzYtwDs3VFqwkAQ xvHRR4MVhF6jJ/AwvZ8X6LtHaE/Ql0LBgoLP6W6TaSbDrq5bVCz/HwyG3c1mk9ds/Ai1AAAAAADc QmpzyfOpk9brF2max5/QCQ2w6DIU2kSwxRBwoQEVQ3hFV0O4hbhwCzuuO1fnVvZ6pS4ZbqGBEDYY oju21zShEaNgi0lyHrsXSOeK9zCfL2W7/ZCvw0GWs1luQcmH8xtQEfvNOsVXNJ2O+wroLicxd6Zt 9rc0VUL7NNzCzqd39xCqKVqdrEJtQn2esQzb3vZjW1ci4w1d/jG0mV+R8Yat3B8hEXQBAAAAAAAA AKhR+kbkUgETfw2zODbfItSTa/fh7ZN+zCJzzVWm/dr2oV5PjNlk2uN5O9f23tc5fK54ydiaMf69 iO8rDcnIhViUhmLUhl6UhHX48SkEXQAAAAAAAAAAAAAA8P/VhFjU7MuJxxpeoUEWuf0yuB9vcjzQ IvLfO2vpJ9n2m2Zfyodc+H4/DgAAAAAAAMANfQvA3t3jJgwEYRheqBANKdOlokPKAVCq3ICCo+VE 4R5UtDSkJM4ueOTxeH+McZQgvY80WnuWXQP1wkeoBQAAAADgt+UOMMncxtd7aaPlcuXO5/Z2sRCL MOpACrkO/ViIxTXAopmTdbKPHe81friFPa+je02/G2jhTABG9wxQ02rm5vPFJdTieDqlQy30ThJk Eem3Ujfqmkyn17GdyNFd77r/cCT3kuqgUx4qM8Yqli5RqZ5+hn7ms68vX4f8VzHztfX1UXikLXnL +iPZg1n6Y0pPr3FmrMx1rAcAAAAAAAAAwC2Ghljk1t0aNjGkF35E/1rfv9TlTD/4LyEUYwv53evC a0rzJTtz/6mubahGKkAj6BPqUAqnyK1L3dsQilQoRCn4ok+4+JDAizHCLgi6AAAAAAAAAAAAAADg sY0VYpHrhfHJtUMs3vq+QTyUvUsHTNizLt9m3v68O7ZPam/7mtgzAQAAAAAAAPyRHwHYu5vchGEg DMMDEqoQux4Ase+i9+rtOAFHYEFvwQqxYWfIz8hmMk7stsqCvo9kJR6cH6HsYucj1AIAAAAAMDdv gsnX1EH7/UHW6/c2dKKhwRBpyIQXcKEBFTG8omsx3EJMuEU6rjs2vV66H345/eVvwy1sSIXWNBxi GGjh/27PNRy/Wr21vevtVn53GmyhwRVO345vLZdaKL6WJjnEO461dFuaKqG/BYkzp7Suj0DzVatN 2e19SDdJ71hxG2k99GODaSLPE7vs3xAyW5Hh5LGSDyoBAAAAAAAAAP63nwZY1NRsvTbgQkMpmpou nt892rbfZ0H9fGwoRmlIxvejXZx9DcVo+id7UM97r5F71zEWVDFVs3noufONhV5472y0XjLOQ9AF AAAAAAAAAAAAAACvryYUIDd+KsTis28aZLF1xuP1nKVbq5ybP5KuV07XNIvEtc420GJh+iLjz3DN /B8AAAAAAAAAM7gLwN4d6zQMA2Ecv2ZghZUpEhIb4nF4FN4TIR4AkFiZOlYhh3vNcZzjKmpAoP9P suwktpNmrZ2PUAsAAAAAwJrmPkBk1+6kLGKa1ffXstvl030PsZgCKayt17MQixJgMV2zcdpfx8Z6 DacNtzDZeh4fYBHDKr72rYZMiOZMnH3W79tt+yksvCK/WObdTPc8HGu766Zz+/4xScR/ySd+xcdW QPmUhyHUWcnSJQY3Vyf5PS/Hom/krflW5GosD41bxuIXdW2SYo9jfe2cHyOhHkI7OwcAAAAAAAAA gDrmX4ylYRXZudaGej2+HcuFq3XzvAZZ9MLm+f/ixrV9EMZ90vdJSsiFD7p43B+/juXF9Z0Lt/Dt VjBFba44j4RxrblbgeQ/EXZRm+uY3w8AAAAAAAAAAAAAANY199//kiALv/fUwissyOJ8yQPiz3uW ske5Jq5f8cEWtT3Qp8J6FQAAAAAAAOCXfAjA3t3cNAyDARj2tUJCggUYAIkJWIBF2K8TwBCdAM5c OPQaGhrjr8Zp0pb2gJ5HsuL80RRxQm5fUQsAAAAuqbXg5HnqpuXyJS0Wt9/RiV7uGsTIRAlblCBF DlSUeMV2lLhFquIW8brtvfH14rw7w3KXU+IWJVZRAhQxCBFjFuGu3WjEr/3dn5uvSWn774TP9frg Z+zytn6TMWYR5j/nDtRa+ZSPxe3cqkQ+16XyTT/5eP5TuN6Mq3mP97gZr5vxccBjxOPdcG1XjRQe Lz5i/jV0I9uUpr8cad9xAAAAAAD+n2MiFucIWPQfjM/BirswRCuo3Yf508g178PoQxerVAIYeX8q UNE6Vp+fE77YF72o7z82dtG6ZyxocUroQuQCAAAAAAAAAC5nbsxial1P3r9JJWLxMMyh95baUYv4 GeVaa+1Ka/4XgYt6TYw1KwAAAABwAV8CsHfvOg3DYBhADRMbMwN0YudpeE9eCSQGJkQFWwkNiRXj OqEJSUH0HMmycmni1pUsVX/zCbUAAABgKUMPLorHbkNT6DRotboOm035cl2QRRNE0fV5sMVuiEUT YNEdi+fG1+b9oUwNt8jDKfK6nt2Ai+JVsr50rKlBelqve8dRpakfaUDF0LjzYIt2Xwza6JuBoafz xFSHNOWhyvpSK6VLVMm1TkP5nhfb9rptj73v9tNZaAr77r65Zd7ikNO3lE90Orx0wt7D7uTmH11e SCbEAgAAAADgeMwVYjElwCIGVaQBFvWf5M/3GBOMcdm2Win44iU04RZ18MV92x7afc/JefuEX+SB 5GFgu+86Q+fuG3YxJehizpCLvvMAFnEyttCCv8pELuto1uYv9UvAbKy3TOSLs6xfXfSsuQAAAHAQ U8IsSnU6dV3OTeiCLK5mGR3/zVvbxvyuF+tNYku3x/hpQEWV9QAAAADAjD4EYO+OUxOGoTiOP/1P BhvsBDvHmLDT7HJewL+F7QI7wf4d7B8PYG3UR1/fkibVWrB+PxBak7SGIgRs2h+hFgAAAACAscQW nXzkDlqt1rJYPB9CJwJ97smGTDTBFrEwi+r0WYMs4gEX2m6Ptd9n98d69uq8cAsfbNEOsdB9H3ox s0ESrb7/6bX53W47hhE51oZX6NbX2b5hTPN5NhQjRZMcDqeTJu1h57alqRLapquh7Pn0J/FYl4ey 4b3VZVOXvx7DsPXVqW/likh7oZe/DFViKyKdLzzK1QMAAAAAAAAAbssYIRa+7UWawIqwDQEWy4Jx AGMJt3peO9q/5Bh88S1N8MWnafdhEVLQVhpiYT/7+zup0IxUkHku6CKmJOiiK6M+1wcAcJ+u+XLr Kb84+9L5NHVtmKcBAENgfu9viDmY+R0AAAAAgOm6NMziXY4BFhpk8TTYyDBlP3JeoIVfj+LF6nNr avqEVPB/GAAAAAAAAHBlewHYu2OchmEojOOGsRsjE1O3ngFWTsA5OQxwAISYunTo1srEdYyfH6+x myqglP9Pspw4seOolSK1ST5CLQAAAAAAUxi62SRte+rKQ22g5XLl9nt7uBxkEYMocq2DLXKIxW4n gyzytrRv6qvrv3RKuEUZWnFo+bEuwy7ymPKjKZfL/a+6+cT19/W6OhdvBVn09XeQhliW4RqHQIvG Ex96805KdZApD17VVrHSJbwY69rZx7ztyrYrn8NTXrj4/X+uHFKXNGV5SmVCSTm91Cb7OFXrFxpZ bQAAAAAAAACA+av94D4mxMJ6ID6EVYTgivAwfAivuHOEV+AypMCLR9X+4WLAxWtfv/Rl49rDLFqW jwVQ1MIupgi6GBtyofvwPxQA/C+nvoh66v3nqjWUyjLUh+s0AGAMru/nOycMsrY/13cAAAAAAOat JRhALt+4+NxqKOGenfuJ5oXL9+bK55ate1X0fSle9PGqv+xnjdfa5o+0AQAAAAAAAPglXwKwd8e4 CcNQGMfdESF16FyVI9C56oV6PE5QdeAI3IARlh6gIYa8+vGwsY2om5b/T7JCnNg4WSwFk49QCwAA AABAC7GFU2+5RovFu5tMHvahE56EO+iQiRBsEQuz6IZ9CbLQIRch4EKO67b6+/Tn7heXtpSGW5wG WMTDKk7PD/WHqlhegvsOtVit10d9+FCRfUN7k/IDDlsfZOGDLVSghQRfXEKSHPTVSNqDBFTkgix0 +TLt71S9XPV9X6Zlw3vty0dfthXD0PXdcG5ninPHC77sbbALxFIvQUoFWhB0AQAAAAAAAAB/Q4sQ Cx9YMTflqWKMwH/wOJQXU//pDkEXEnLhAy+W6vi5cIrYOanjsd95ckEXsf5yQReEXAAALlWy6KPk pUw/PYaxSs2PtdeUmq9L+meOBgBoY5jbr91XSzUhU7l+auZ23T9zOwAAAAAA45d7vuK3fp3OswtB FrMG48Jt2Lh0eIqwa0pK/3ts17fEgirOtdH7POcCAAAAAAAAGtsJwN4d6yYMA2EcP7F1QmxMbF3Z uyBeg6fsU/RJkBi7MaLUlnPK+WScRAko0P9POgWS2AlZLMDJR6gFAAAAAGButYlSuu0k6YH+Vbvd p9xu5e66IIsURNEtxYRUaICFtKEWtiQr29Yvl6Y/3EKDKfIQizzswu6bttnK2+ThGHpNfq/XcojF 3dNK/TTtuTU2rMIeV9fbcAttUzmWf6qOmPea6uBjOjQZ4l6IRSldojF9raR8zG2ocHXkUr8iH6GO ob57DulLT7n0keyERN1X19k24pa1yWOEWAAAAAAAAADA65gaZFF7vwl1kHRDfLwRfh9qPfYEgX8k ZqF/tWXFoIuzpKCLn/Z1rLFhFkO219aVws+HBlv0PQRzjpAL/p8CgNc3R8ja0L7mbrckU+dt+PHb bxsy/vIAbABAtISxfWrbJZg6rjK2AwAAAADw/krf++O6OF/nKF2QBfN28Cg+1EKN/T2pNq/Eh1k0 herrAwAAAAAAAMCT/QnA3v3jJgxDcRw3EgvqgsTOBTr0GlyDO3ArLtC9Emfo3LFj54oQN3n1i/te saNC+fP9SFZKeAkmi6vg+EeoBQAAAADg1KxJK+tjB223z2E2W3yFTUSSZaBDJlKwRQqkiPWpNd8B FxJcoQMuUvjFsEZ/nv67NLvhXOxwC51TkMItUjiFVffbNjcZXIfP9qJNVfDEz3LjPDrMou+fvNah GpMs8GLs5Zckh673Ke1hn21LUyXkPZkRpc8nfYwzAR/KuhfDXV7a9l7RDb2/6Wu9iVr5V5bXjbMN YTiRy1sYgaALAAAAAAAAALgMf7GYoFcTH35/Uttlde8AWB77tmrbpt/3Ebqwi13owi5ie1PHjA2u qKm3fisqDUM/RchFXs9vUwBwPWoWsC5d/Lp2/60p+Z7WWOmNwdZi2N7/A1Y/GJcB4L7U3H8qufc0 pvYWjQmDPFbrje3e+RjbAQAAAAC4XPPQBVjEeTsSYgGcy2vw7y1Z8zlqnjnO6/Lnoq15LdZxAAAA AAAAAP7BQQD27linYRgI4/iFiYkuDGxdOiLEyoLgHRCPxivxHgxMLBnYkIKj5mL3cnXcNKKl/f+k U3DiJi4MLqnij1ALAAAAAMCccg+e6bGXUM9jJ1qtbvuACSsGWaxDLOJWkqAKDbCIIRax4jHttxmK 0fTt/yCGW1QbARa6zz4vWA0CJNJKelbDdrurvd5icS11/SU/4Rc2CLXQTrq1x5x2H2zhVNWe3wRh bGNX1JGkbVMdNBEi3XrlpUs0ybkuxL/mTajvUJ/5IV+Geg31NnJJWzrk9C3ZP2Q6PJt24qWY2MWI ShYoAgAAAAAAwBGw9/IAnLx9gyy89lLiA/CPoe4mjw7AFFehHrpSbdDFu6wDLjTsopayoIo5gy7s AtelIRe575a8hTVLF9rcdhwAcBxKFq3e5fPquYdZ7MKbf3OhVWKO2fnevm7sWgCA01Q6FzO/z2+f /7m1X7ovN78ztwMAAAAAcHj3XT11tTzkYHDWPsS/tzQ1vKIxZffZ/t7PY6/j3hYAAAAAAADwR34F YO+OcRqGwTAMOxJDVVSBegAuwMARGDlLZ07WEzB1ZmJnYGRm6EBwYrv588uJ7aZFUfQ+kpU2dhJX rWQ1tfsRagEAAAAAuKbYArNd6qD9/s2s19s2bKIRchFkyEQXbKEDKUJQRX0KuJDhFSHYogu/qHvH 6nPL681b5fvs8gr6wRbmtO3+3E4HX5jBsAu3u/9WbjbbNtTi53g0q5uy2wvNuWvdsa6DLshCBlrI NmcK6Q/tqUw/7SEEVKSCLGT5VcdXYn/4qNzZcpvXvUdbnmx5L+iG3F/7tkMTu+RLliEYsYlksUWL 5y6MBAAAAAAAAABcTkmQRaytrm/uSz+L7cOk3gG4hibo4sWXV7/vy7iAiw9bDn5bElqRs9W/F6Xq hkIucgPU9R9rx+o1Ai4AYH6mhllUGW1S10rVLclY2MRYfWgzNr7nhlswbwQAlq90fC99nLpObv0S lI7tueNwyXd0xnYAAAAAwKJUE9ek/qN7Wz6NW5IKzMG3ep5z3ygWPGFM/LjYfJShuS4l96tS1wUA AAAAAABwAX8CsHc/KQrDUBzHn7MQ9AYDgyvdewKPMR7ZtUeYjTcQBkE0tROTPl/+jBax+P1AqE1t GkUo2CQ/Qi0AAAAAAH3JTV7zx9aurEoNzWYLOR7t5kLgRBtEEbYSBVXchliEItfi3+PP1Vt/veGM XWs76r+jbhjFqPP6Nrgi3obzuvWhjMeTy/Hfw0FkOi337C+k4qTqfL1xQuiLDr0oJIzomXcS7etU Bx1wkQqxsNIlTlFbH2Jf89OVvSu7bI8v5q5s1SVzXYq7bH0k6+PpH4NeEMKatFi72BAAAAAAAAAA oH//Way3tL+UNryiKc2zGibCA8P05cq3qttIG3ThtzWT/h/Zxm2/QsiFfi/PswDg+UoLXpfCLGoX vS4tiF3Tp6HTw1NyxzvDdMS+R1r1qXALFr8GgPdSE5qae839vc699/batlNhVY+GZQAAAAAAgP40 Y3oYx4NX8pOozz1XSu3HdVbohD6WG/NihVzwXxYAAAAAAADwZGcB2Lt/nIZhKI7jTpdKlUBVRy5R ViQGDsMFe4KqA1fgAIwdGJC6Ypw0jzxbL7ar/hPl+5Gegp3EcSdLNPWPUAsAAAAAwLlYP7B6Ld20 Wq3dbLbowiZakl8gIRPSp6s9J0EW+6AK/xtwocMrJNhiCL/w0b36efGz+w/0R34OJ2EQ3schFmlQ hb42GcE8p9uTybQ7fu527mE+L87Hxx1xUEV/bBodtqGu031HkPSHbmgXpz1IQEUpyELXd3J/o/rl 896Huqub3nOoTaitekRTmIbu924IwtClAy30FKXtR47OxS9zsTkBAAAAAAAAAFzGqYIslqFeHCEW wH/w1Jd4d0PIxVuoL3dY0EVNuEX6HVFtyIXlkIALq22NlzsPADi/2g2vazfALm12Xdt3C3JrZsva rFq3S2ujtZ7n3ifR5wEAtyO3ttaGWbC218tt9Hfs2m5dWwqdZG0HAAAAAOCyHq89ASDxcYIxxt5P 0X+PBVVYY1lt/ocFAAAAAAAAXMGPAOzdQU7CQBTG8RdMXLtzQYJu3BgP4Q1c4Qk8gLfwBl5IE2/C ksS4JnVKW2Z8vHntYE0J/n/JQKct0xZJJkJnPkItAAAAAABjyA0WSwegL6WZPMm1WNzIZmM3F4Ms miCK+CxJUMV+iEUssivdPt1r9XPu+NuLOuKhcV34QwyBaP4EacBFsrf44wfTNvX6s+3jar2Wu/m8 6PyqWIntp29qHWIxm+227W0fchzJj+jTqQ464CIXYmGlS1RJW11dH/MylK9QVv4pn4fyGMqrOqR3 SukpW5dkXd7PD4b9AbAmJfAGMAIAAAAAAAAAfmeMIIsraX6HeRBCLID/7rYtT229Drn4kBhy8dmu Lw2y8F7jhVzoSbD7JtHM/R6lJ/C0tmsEXADA37gI5TmzzbuHaGi9ZCLrI76LZzQvyXLuevsm87Hu ARGx+2u9XpxlAMDpuJf8Pb5D+ubSvv2Q9afiLZT3pG5db2nf3tc/6//N9TJ9OwAAAAAA07me+gQA pQ61sL4zOiRcouop3j5e23yfBQAAAAAAAEzkWwD27t64QSAIw/CRyjMKXIAbcGB14BbcgxN34VxV uAVlzhw6VA3OpRaMAbG6Zb133Axi8M/7zOwIEAcHCSNx8BFqAQAAAACYg/eA1dNYo93uLaxW113Y REtCJHTIRAy2iIEUEmRxqvoccKHDKyTYIoZf1IO2en96unaGtfzUcIsuMCImRqjP7zkGOqjiHByh tlNlDy62/TgeSzs3OGGDcIuggi1UdcEWMt3X1FFG9gl7nfYgNRZkoevTtNehGbKfdVNXZd27bequ qb3aRZXphl1ehxiEYQ9JuuflengPNuoHFr3TFwqWAwAAAAAAAADSpgZZtC8Svu+rDbK4uVzXAPwx EnLx2M9LyMVr/5kKtSgNtPCWVYl17PKx+0y573MhF7mAC+5rAcB0D009L92Jf2Rr5r0XBnmBFHpd b2zI2LU498Jr246xIwDw+72EU2gq5tdeN9/V/KWu7anf3CXBVVzbAQAAAABYzmbpDgDGoWAd7z+t kkCK1FgUvQ1vH3bbqTYAAAAAAAAAZvYlAHt3j9MwDIYB2HALli6IYwDHYO052WFnQOIEDIyVGCsI KlbMJztOW7VF8DySlSZOHKcdoubHr1ALAAAA9tUaKKRMU7gbyk2vocXiKq3X9ebGIItNEMU4TUVQ RQ6wGEMsxjLW5fXytnE61+8Mt6iHVYwhFmff32MZXFGuU7ZRO7DNsnzsb6tVvRdzAyjKsIsQfPEj 5GIH8a27VMzHVIeytAIsWiEXH0Vb56m+z4uhvA/ltd/ty6E8hV3GrI1apsbUIcX8jtYPXU6nXlj0 siIAAAAAwG72DbL4CkbOIRbd+y4ADTHk4j5tBtN8HMpzOkzIRa2uNiDn1P2o2uCcqTGfQl1sp1UH wDzLU3fgn7keykNYVhuwJ37uDXY99/mP1vYA/B3LJNDimPLznKWpc3ue7/2X7tn2nO68DwAAAMdx e+oOQOGlU7/Ntag8bYVdtK5xxXV7185q2wAAAAAAB/IpAHt3jNMwDIVx/GXsAAIOUPUEnKETIwfh FL1SN7ZK3AWGCqnqBQhxHdf2i+24akUi8f9JVhPHTp66ZHH8EWoBAAAAALi11GYhb2OTttudLBZP p8AJs17EhiY0UciED7bwgRRmvGs22MKHWPiQiza6Zuf5ue7e4XN0X8ncwi18mEUcaBEHXMj5P/Z1 66CLZjDXzTehGMbX4VBTUHycCaoI6xscXxFuobn0h9P9JU57cAEVY0EWuWSJNrjfj/iVT/ddu6sr z2xE8NG1ffCIplCG7m/FB2GELQy0CEt057mNDETiBVy5jxT5eBEAAAAAAAAA0q4JsngU++H6a9fW XVveriwAOHvpm/EpNuDivf899v2pDQZqQy5K48IxqdCK3ObbBFwAwHRWwuZKf+1BhhtfO7kNr/X1 8F3eqHH6XK8ZKa0rqVlTAgCYv83UBfwzz3L5u70mGLLm3S6qj/AqAAAAAACmtZq6AED5rhiTC6DQ 56VAilQAxVj4BQAAAAAAAIAZ+BWAvTvGaRiGwjj+nKErIwNS24VLMHEDFtSFhVNxFzgB52glLsDe 4Moxdh7PSdqoCVL+P+nJSu04bjt0SOOPUAsAAAAAwBilzUBc1vfi66FvovX6Xo7H9nR1kxaRgixC EEVqJQuq+BtikUp+K46J5+p2jP8VbpEHW+hAC9cKvojhFvG8FIaRH6fzwncRnqfrC7UI42s7lMK5 dmhFXJ9Rrqou+mD1DjeSHetUh5j0ENMfSiEWVrpEnc1ViX3NW1/fvr66l7zytfP1pi5ZWlKeqWG9 JV15uIWoPlFt1+ZAPLwIAAAAAAAAAGVjgiy2vp4khVkAwJTufD03dfLp672pg3QHV5wTblHaNLPU Z92b6gu4sG7ZdYVYEHABAMO8zr2ABTptfP1hvF7a7Ee3OsjCOrbmZvNrAFiGR1+buRexMDcS/heq XfO3PZ9vSHgVAAAAAACYxnbuBQDK/oyxfeEWuq8UVjE0/KI0BgAAAAAAAMCEfgRg7w5uGoahMI4/ jhVSDwzAAkjQI0c2AXUR2KcLsAHHztADt85Q45K++sX1k90WGlD+P8lSEju2k0sOcfIRagEAAAAA OFXph0ylY/NaR4vFu0wmN9+BE9s1JCnEoqvXQAt7fBtAoUEWXVBF2Adc2PAKDbZI4Rehd672r+yY p/pL4RYp2EIkD7jo6tPxftiFmHPkYF+vcbVe98baB1h4N3DXf9D2ToiF2LCLX7iRmv6gV2TTHmxS hBdkke/bZIlg+ttIWhU1jeW6bXp3sTzEsjRDXBWG9aYTJAVh2GIDLewUdd/7QFGkv7jL+2iRjxkB AAAAAAAAjF1rmEXebhbLs3RBFvc/PSkAOMPjrrzG8ikp4OJD6sEWLdstbUvvrVoCLqxSoEXpPZjt z6sDgLF7GXoCI3Qrhz++rv302nvetvzsOmeDomrrR1g7AgD/z9vQExghXQ9qHRNoYbftsY34SmEW +Xg82wEAAAAAuLynoScAZFZHtvfWaOR1tXdXIm3vsEp9AwAAAAAAALigLwHYu7+UhoEgjuOznkIo omAfewbpCcQ33z2leAuv4EMvUASh0LrtdpvNOLNJJU0Qvx8YmmySbfoHtoRmf4RaAAAAAACGVqYo PMd66DpgPl/IdmvP87QPntgHJeQQirycgy1SUMXPEIum5FR5n3ysfhzadOEWQdofQ2qzAi4OS6F5 zKEh7eALHYYRTu/X12ZTD7FIHXS2hTLIotgnFOEWeXl3ZuJIeUedviNPpzpYARd9a1f0ldf1c17H +oy16j7t+1jv0g6u8E6pzNTwXpL18vSXoVy33jo9ERA3KwIAAAAAAADA74MsniSFWDzGuh36pADg AmaxXo61jvUmKeDi9bi9T8hFbZICqw+rLTjbsnMDLvQ23Ze3DQD+o6Xw23UKN9JMfK3Ho1qoRS3Q wqs8GXaQ5v8nuv8+4RYAgL9hKen6FMZ3ibH9ymjzxvbaWM7YDgAAAADAeO6mPgFA+TDarGtY3vWj 2r5ekIU+ztvHew4AAAAAAAAAI/oWgL37x2kYhuI4/sLUqipIXIOFC3AGBi7AzCm4UmcGOBALoJIt ISYxfXae45Z/UeXvR7JaOU7sZInkJP4RagEAAAAA+A5rkQ+r7i53oM3mUZbL88/ACfceiQ9ViHML +ro2EWbRftXp8AofbLFr74sM/YX9+P8HZiZk/We4RVWF4RPjMIt4LGGb8f42d06r1alst6/yVtey XizigaQvpD9+4oLoIItR+UVxOoNOe9Bf+OlUiUbSoRZNtL8OzfD9nHVlvd/wrrry1JVn1UU1MYy4 vpVdEIb10aI+ZR2C0SZ+RcIXvVIfLfIxIwAAAAAAAIAS/CTIwoVYXEs/ZQwAx8o98roZivMgfcCF Ky9DXWoxgqkQC6udFWJhBVdMLZqwT8BF6rmYPkZqGwCU4nbuARTqQvILX+fup76uMer1gtf6VZcT CRfC1n3mQqQAAMfhfu4BFMq/C+pwbwcAAAAAoGyXcw8AUOquvCe2Tc0ZxXNWVvupIAtr3sva55Bw DQAAAAAAAAB/5EMA9u4eN2EgCMPwWJGoKEhFR0edPg1pcgoKLpS70Oc2aXKBNFQ4u1rWngyzNoQf R/H7SKP1+nddrWRZ+xFqAQAAAAC4Jp2esA713HfBYrGU/d5f+ykGT8Qgi9RKE2iR+21Qxc8Qi7ak qXxOvodt72G4cAubI+EFWDRnqrZS54q6Jr3LdPqYQi12u+NQC/1gJ9wi3qfOxw9lgywqNejqwmAL G2Ahchw8od9Yh1SUykuXqNW9ct8+cx7qK9Rn95AnoVahtuaRNmvDy9TwXsmWDrcQc0xMW5ttbx8A AAAAAAAAjMFvwiwIsgAwBq+HepMUcPEubcBF3wKc5/RPCbjoW4zTnidm2/KuLx0DgP9sFmoz9CBG KoZJPai+tyDQKQtf67lRL4Cd/znxFr8uzZWl+dVuAwD+rhdJ/yji/nSoRTTU3C5OX4+RuR0AAAAA gNt7GnoAgPKhtr3vQX3BFXZ/V9iFbb3ru+5dGhffsQAAAAAAAIAb+xaAvTu4TRiGwjju5oJQpV66 SK8cOkM7QkfpnVF6YoIeeusEzNAZEGlCsPz4+l4JoDQq+f8kK9gmccTFEon9EWoBAAAAADiVt5mH 1/Zy7EKr1Xuaz+93gRPteyI5uEIzELq2HEDRhVDYoIo2wGKz2f5oy6EXJfyi3p9frmvH0LahDBdu obkFh+EW3dEGWdi6ZhvYc2/M71KuP5vd7lraUIted5eDLJx2UzkMtqiqEmgxAF11Z9Me7DEKstC6 TZbQ0Iw8zl3qdhvo4bEpH035MkPkxYxe5oa216kEYdhiAy28XA9vox9v4WK0UJEFjAAAAAAAAACu yTlBFk+mEGQBYGpywMUylYCLt32fF2qxdfqi7x77/FuwhT7Dip5pRRt4R8/Foj4AuDbPY9/AxC2a 8mnquvmPNz/aOdZudF1Le5Xiza+taLNr3hMBgP/pdewbmDANtWj1ndv18yVzu47L3A4AAAAAwN96 GPsGALE+45w+73R4fXr0/uvSPh0XAAAAAAAAwAi+BWDv7nEaBoIwDE8TQUtDGdFwDnIJRMkVOAG3 4DC5DyUdQuli1jiDx1/GToxAC+F9pNF613+bypIj70eoBQAAAADgu8RkhNtSq0MnLJfXnwETqh1v gyy61naBFn3fQyr68IphuEUsD7rw87St5efCLSQoohuxGGgRwy76432fnmcSfNFZLM4/2tfNZta8 Gr/Jbg7aH8w/BlzEwIsvpI9ogIXZfvBEjASJX/XNqSZcy/t6z8tSb6Wep6d8Vuqu1JMNgys0ayPL 1Mh+klYMtzDZZ9I2sp2NAQAAAAAAAMApmRtmcVPq3giyAIDIAy4erQ+4WNtw0YH4N1pWNrKt18j2 H7sgp4ZhmGyrbFHvbBwATslD7Qn8cxel/PsfXQDIW130Ogt72ob+NrR+zjGLX+u9AQB/z8q6d1mo o33+xu96Dz3bp4Ic9dker8GzHQAAAACA3+2q9gQA8TLj2KmQibEwi7hP2+xaY++reI8FAAAAAAAA VPQuAHt3jNMwEERheFxQRBENF4CWNHAWrsElOBAUuQDiBlScIiVtlLDGnuxkNBtvJBwT+D9p5Hht rbdzIKt5hFoAAAAAAI4RNe2Ixh6HJlouX2U2u+pDLba74AqfVdCNaQCF9EEWOagij2mJrNdduIUG XWgARndvns8+wx5PbaxwixxE0bhQivhzDrnwgRcSzNGOX3wfa0ItduEV8cUcWKHrcOf2+k/z6Qw2 7cEebarE5sC5TZbwoRn6nLab2bxueYtUd6nezSOa4LGl5WwlB2HYsoEWUa5H1OQnasZTagBE0AUA AAAAAACAc3RskEX7/1sNsrgea1EA8Adcpnro6zPVS6rnVB+y32xTZDjYojbgwt8TBV/437RKv3GV wi5K4RbRNQA4ZzfSfffFdG5TvbmxUqCF3Rdim137BtgieY+JuPOo+XX0zjy0pwQA8Hs9Tb2Af05D LYYa/dl3+8aN61gj+9tT/Vz+3T70d6vfUsu7HQAAAACA8dxPvQDAWVXeVxtIUbv/o3RPaW4AAAAA AAAAE/oSgL07xmkYCKIwPBKXoEARBYJDUJBzUHECxJE4R26RjhoJSrq0gQ3rDc+TsdeGRA7wf9LI 3izBmzQWxp5HqAUAAAAAYB807eA21XXtDbPZpa3XcW+oEjyRt9YEWnyNS0iFBlnk2g23KPvlfRqe sRkfk32EW2wDIPJIZ7ZbDafQ4Is8pz9f69118rn3tlqNXuN72bbCMyTMQoMsdPxD/mk7s93gCf1G NKRiTOnTgmXsj3lquWPPa33ZF6mW1g6u8FkbUaZG9JF8abiFuTlzW/+gIg8vAgAAAAAAAPgrxoRZ nFsOsbg3giwA4Ds2ARd3Tb2keky1SPXczA9tXuBfi0IxrGe/9v8tDceIAi1UVyPQrjkA+G0epl4A 7Mxy8+vCN/TpO3dqkEVpfF34sVm7+bW/p0SP33cu5T4SADhe81Q3Uy/in7uydqhFLdBCA6t8WFV0 ftf7RvU+UrPhf99yLgcAAAAA4PDmUy8AcJ6C1/RalVl8zagviCL6XV3XxWr7Q44BAAAAAAAA4MA+ BGDvXlIiBqIwCt8MGxTEoU5ciLgGd+DEXThxQw56LoLbaRz1AozVJkX9qb6VlI+mfJwPijyMnYiD QFPJIWoBAAAAAKjlPbzk7btd+qD1+slWq9P3SMVu/oiGJtSwrx8DFDaGLIb1tPTjFjF6kQIYKZah 54nr+blb+nrcIgtFuAELm6zvhzC6LJCx//kxSrLZbisvq1v+o/QYPX+XrvMQ/6q8zqC1B11qVeJ1 ZlvLEnk0I57neBwVLsN4DmMjp4hVEa+5ke/vLYUwdGjQwut69IWl2XTiV+nhRR5qBAAAAAAAAPDT lb60zkMWJzaELG7CuDr0RQHAP3Iext04HsN4sCFwsRS28GIWnfOz0ku9820r7DNn2+T4msAFcQsA f8F16wuAndn05ddm5fudjjgPRF98bZbmhmgUSqfI6PwRs/n7HvNDAOB3uW99AbAjG+Z07nhBC11f ilV5gSqV39O9uEUN7vcAAAAAAHy/i9YXAIiXT/7eR0Lsc8frPm+/F9fg+yoAAAAAAACggTcB2Lt7 nIaBIAzDkyDRUtKFjgPQIyg4A+JktNyA+9ACUg6AqGEtZ72fx7N2kGXFSO8jjXbt+GdTOXGc/Qi1 AAAAAADMpX92ekp1O7XDbnfdBSJ4OXiibe0QaFGWS0hFDq0oQRY+3ELDL/QY+ThrNy/cIgqnKCER w7ALG6wvx9H9y3Z5fG/7fTyCWgBFDq7QwIpNfyzdmJt2u+36M5I+eu9IAyzMhsETGv+hIRV/Kf3X YF7257xM9Z3qc3zI56keUz1bP7jCZ21EmRrRW/Kl4RbmXjPX/rh+tA4AAAAAAAAA1mzsRrO/QX5n bZBFE2hxseSgAAD2cKivVK+pXlJ92HSwhf5GpRNz1yZHqK3buPVjfBh8ra8ItwDwXzWBFlenHgTs xoaTXx8zOVA08bWf/FqfL4meMzHrf1eqhT9xrQOA9bu39n4XTu9M+sde2/M1Wtsp+fOAfw5U22h7 rucAAAAAACyP31+wJu/Sj+4NRaESNVP710IqovNMqYViAAAAAAAAAFjIrwDs3TFOwzAUgGEXpgww cAJ2Bq7AETgBMyP3qtg5AwsnYGHszG6cOi99eXm2A1JJEf8nWaVpSDwRqTj5iVoAAAAAAJbwHvDk bXtsHWi7fQldd7UPTPTrQyQyEc1SkbwtDgGKMIQspqEKL2SRQxdxfJVAho1lyDn066n6SdxCohDz YEWYBS4OcYvpfl70Qt7nOZ3t37/vds25RB2wmH44CViM56uNI7F32evagxe2OHe2lcoSNpoh57lM o1s2vZs0btN4U6fYVKZht8dwCGHooYMWXtfD3rxYehBP6SZGbm4EAAAAAAAAcCpKXzDbkMV1Gg8h xyy4eRwAft9FyH+D+/GaxvMwWnELG6aoxSxqD0vYOJ+V/m9G3ALAf3C/9gQw6kN7n8PPS4IWcj1q PfjaXpNK60i8ayUA4G95WnsCGH03alEKWngBKjmGXMuFXhuqf6e2FpTrPgAAAAAAx3G39gQA46O9 y4y39kJ/VtrH7lc7hhe54PsqAAAAAAAAYEVfArB3xzgNw1AYx1/FBVjZkKjUhYWFhTvAzlm4S2/Q s8ABurH0BEykOHVcv74+N46gqoX+P+mJmDqJg5BctXE+Qi0AAAAAAL+hFze9hnoa22E+v5eu858b ZYMnYqBFbsftHGSRAi68cAsdfhHDLQ6P2eu3bWBDy6aHW+h1Z4fbOuAiHy/3Of67zPZhGKlfNyyJ W282udcu8GIbB2nTQlSwxa5f6p9e08EXQ83MPn/FrrQXOQ6e0FerkyFKIRZeuoReSZja9pw3ob5C fY4P+y7UhzllaUg6U0Nfknd5enj2n8YuXvQeUsCDCwAAAAAAAAC0rDbM4kXiA9Sfzz4iAECtx6He Qq1CLSV+rVYTcDFWUvH73qnvv7zXCLcA8J9cS3yPjDYsQr0P2zWhFvr+kFKghT2WvofEu8dE9xPT Zk4DgLbdSvz8C224Mu00j3aqbed0G1il5/hvyQEWaR7XQVW2ts5Pi/kdAAAAAIDzebj0AABjSqhF KWSiFGxh+3h9p5wDAAAAAAAAwAX9CMDeHdwmDENhHH/KDVX0wLEX1DVQh+ga3aIbcO4QHFig6j4V M1CjxOHZec9OW6EQ+P+kp2AnJFY4RAGTr6lvAgAAAAC4c9bDnqy+t9qO9vtPWSxWXSsNmtDavmMX QCFdkEUaVGEFWbRBF8d+GQMyYliGPk58HbebE+ucDZ3/e6bDKM6vRdKP0cowGOYb6GCJ5Lz9JXBC h1hIFzCSh1ec2k3Tr+u3uxDrjDRqaQVZlNq68v1Fj6Eexg3vJdTK2K132NJw9Pv18Ky2OMth8olt PskxAAAAAAAAAG5F/h2nte7kOdQ21CHUTgi0AIBrtZT2oepfoT5CbaT9Lew/Vfv9zGp7DwO1Sgr9 mtcPANfgdeoBIPEkv7vO6eud1+/NH9HTW7w5JOK0a/0AgGm8Tz0AJErX7/y+tTZVNb9v9eaGevet YvQDAAAAAIDLWk89ACDzPXK7MeESpVD2WpX2Pa+HAQAAAAAAAAA36kcA9u4Yp2EYCsDwC6D2CIil YmJmZOrCORBX4C5chJ3bMLAjJirVqS3H6vPDdhiSpkj/J1mxTe24LFYdO+9q6QEAAAAAAP4tfXjp yaeHsQabzZ04Vz7vlAJPxKsMAS2O5Zg/BrJIAS5KwS108IsYtCLvsyQFaJgzYMLUUkyJ9pDrZ8pj uzxYhb7GOBLtc+er1Vp2u5/xwdp+TEALW9/p4BbqGuqm2nUUeu1VXoZyOsnn5HekByfjUSJ0cqav i8o9r3369umzPeS1T1uf3iQ/nNg3bt9Vyvbr6eGNvZTA/uv6Sh0AAAAAAAAAnFprxVyvcT4PaTv7 iAAAU3scUni09urTu09fUn7ZgavUl16K4FS+9tKEUvkv9DM4Xad1lXoAWNLL0gNA5kbiPpGgNC/p ea8bymLywV7iHhFRn017RvTekVS/V/3ofSKpvcZ8BgDn6VbiWhjOx6XK1357pnnXST4H63ldJJ93 dduxQBWl/Z/2bwAAAAAAYB73Sw8AMD4KdXZfhF0vKgWiKK0ptT7Tuod9HlZrAwAAAAAAAOCEDgKw dz8pDQNRHMdf4qpIXagrF6Lg3hN4Ge8huvMUHqIX0Gu48R5CF3HayZQ3L28yQaht8PuB106SoRna wtDmz6+tdwEAAAAA/GPehUzeusfaC61W77JYXPRLedCEFtd1fQCF9EEWeVCFF2QRgy663XMKyEhh GXo/qW33Hdd1u4CLubDvYwqE0MEQKaQitrePkj7K2Kcxz7qP/cjj8ua9XS7Pt+3v9Xo4sFJwhRqn 7dvEJI28Nto237ZHjWmnK/R1OoSuk8pyY9r69ZKzUKfThvcQ6tLZhd1taThe6SHZIZZCLUTGvhxD 80mLAQAAAAAAADBHpZuz6f85b0M9h/oK9SYEWgDA3F2Feg31Eeop1LXEY2O/qda0S8fTvMN+teNt IsNjbmM3Fh274SgA/KWbUPeHHgQyd5LPVXbu8uYyb25L62pzWVKax+w2AMDxejn0ADBQ+j1qf6vW zgMtnaJaOyd0SjgwAAAAAADYH0ItcEw+K9trF917oRVeQLvXR5zlUpDFlH0DAAAAAAAA2LMfAdi7 Y5yGYSgMwG7FgCpQV6bSiTsgMXAKJBa4AifgAFyGG3ASjsDE0hWrIYrbOrFbiZZW3yc9JanqyJky xH6/UAsAAAB2kW5oeox1Vxowm90sQxBy2uCJ5hh+Ay266+a8C7JoAy5y4RZp+EUTbrF6z1rHGm6R 2zOehkesB1e0192Y1bHtf9Kgi/R+k8l0efxeLKrmOMoFUqyHXyThFaPxuDkWAjJ2NbQDP7eDb33H 3zZV6l5zFZrOOwXnsR7Wbl3asDiUq5F7tKGmOn3NC0LPbwAAAAAAf6mmIfh9rPdYn7FeY13vZWYA 7MtlrKdYH7HeYt2GrgHoWagLtKj93Ff6BCjcAjglL4eeABsuwuZakb5m2KX1JDVLW7Ztfu29BfA/ zWM9H3oSbMi902vCqYYCLXJhFjXrQUPwHgcAAIB9mseaHnoSkPhKzkvhEe35LoEUuQCKvvCLGsfV BAAAAAAATsSPAOzdwU3DMBgGUFOph4oLYgIunBBiE9QRuLIFsyAW6AAwChNwY4DiNk3SuE7ioqpR pfekX3VSJ7F6sSLV/oRaAAAA0Kdv44zU69iNVquvsFjcbttVWEQbNLGvOrfeBVCEXZBFN6giF2RR BV2sm886IKMOy9h/Tt0uzau4tHCL6jfsC7PYtrKBFm1wxWGgRfe6bv/5fLE9/i0Mtejc8yp5dh1k kQRXNMezWXvdicMtDsaYtMeCLI5dOZjuXrOx+RfiddnwHmI9ZR7RN4ySTQqGNtjJLVzMbbwTku9S Fj0CAAAAAKcytgH4TayXWN+xPmM9n21kAExpGes91kdowy2Ggi1mhedLguaHNg8VbgFcouXUA+DA Y8jPSf8Jrxibt8YqBPMTwKV4m3oAZN2Hsrn82DDGvnfRvvdOczsAAACc393UA4DEz3iXxlC4Rdov F1ZREn6Ruz7XBwAAAACYwJ8A7N1NSgMxGAbgdHAp7nVRC4I3cO8hXAoeyRO48CJewzu46wWKsem0 Y8xMOlr6I88DXzMD7UyghbTQL69QCwAAAMbqNjA9hrQZyKDp9DYsFuVepzZ4Io1hFWixOU/HmyCL NuCiFG7RDb9I4Rbfr/kXpxlu0Z6V+s3S29gNrVg+roMm8kCLkL02aZqz5fgxn1fnlIdVrG+0Gied sIofQRdN0wne2K1SgEV7XNt1ZmwXYW3HmstYV9tN+2bLW+a3LU1jqIkx9Dwnb27s+5ABAAAAAOxS bcPvWaznkMIsXmJd721mAByTu1ivsd5iPYT+UIuh+k2IvHAL4L/4CrTwXfo4XYTh9akWxjTJxqE1 LYTy+mPza4DTMYv1dOhJUHQetv+tWVvLx/wHtHQegrUdAAAA9un+0BOAzPvI55ea7UshFH1BFnnY RS24Ir8OAAAAAHBAnwKwdwc5CQNRGIBHXbEwLvQAxnOYeAXP4AE4gxvPY7iAN3HjwjU3wAItKfW9 lhJDJfm+5FFo2s5jNSFh5hdqAQAAQCTbJKPrZehBi8VHmc1uN++bUIh22MT+51UdQFHqIIv9oIoo yGIbdLHaHZuAjCYso51D0R7vWOcQbrEf/nBRf9/mXDu8Il6ftr01XrP2O1TiavP6vVyO7nF3zMIu OsEWreZOIgq7GBNkcWjKRHuc9c4D14e191jVXfDYbNgxix+zxY3dRYtDGxhELHgEAAAAAI4xtMH3 U1XvVX1WNa/q5nStAfCPrfPk30ocbnFZ8iCLvoCLQ0q4BXDunqdugNRDOT60ItoUu6+iuSrb/Dr6 m00p5iyAqb1O3QCpsb8zhwIt+ub4UvJ5O5LN6wAAAMDfuJ+6Aej4Cs5FwRLZ4vq+a7Mgi+592TXZ GAAAAADARH4EYO/ucRqGwTAAWxUSKxNiqpiYuQBXYERswEG5Cgdg7ABjcYlCjLHzU0VpkJ5HstQ4 TeoutarY3yvUAgAAgCnSzUmPsd0NXbDd3nwHTJSkQRZtmEUTTtEed4EVbX8bZJGHW6ThF024RUju O/9alfWHW3T7z9oAi/2+XBPld1DFlL1n3X3ed7uRl1RCLH5OJyEWabDFwWaTBXbMp29nfWmHX233 /5TEiFqVmsvQVNcZcB7bQ/YRY3M0SsOofcVa8ZyhYgV5HwAAAADAMYYKej/H9haaYuX3yw0LgH+m Dbd4je0ltovYzsLf8Iq0L38ONzbgovYYcWzB8JC9Fm4BLO3wG/l06kFQdRXGL1spLVXpO64VwK71 AbBu18Gcvmb5XDz1f+bY+bwWNnXMvG7+BwAAgHncnnoAkPiM7aNyrm8TfR5CUXp/X5BF6fr8PqXz feEaAAAAAMACvgRg7+5xGobBMACHsWJAMLByAIZeiZGFmbFchEP0AtyFC3CFkmCZusZ2EimQIj2P ZOWnafJJrfQtsV+hFgAAAORqC2LkHsdutN+/dZvNzdd+DIBIwyZOjw8nIRR5UEUpyCIEXRy+t8M9 QqjF8X5R+rwlnXe4RTnEIu7HsIsYbHEMiyidP/4FwmXhOAZl1EItLmohFvFcus3PpdfGOkZCMZZW CrtozSAsrW5Tm1lYWqVmcNWPy2nl3fdjW3hEbTGdOYvs1AIu8smNrYmNtR/KxEYAAAAAYExrAe/r fuz68dGP137c/WFdAPxvQ7jFcxfCLZ660FPywIo86GLq50uFW9QWDW/1RoAlPaxdAE233bR+M/aq SunVlbFgi6772XdKr9YAcB5e1i6AprwvT+3jc/v3lGCLVn0AAADA8rZrFwCJ92S/FjAxZRJ9K6yi FmxRekYr5GLOdwAAAACAX/IpAHt3j9MwDIYB2CqMXIClAiExs3MTFpg5BFfhIpyFgYG1J2jBKErl GNt1y086PI9k1Wla1+0SpcnnV6gFAAAAvdICpbvYbne9Ybm8DptNuabpe5DFEGYxhlJMQyw+tgEX pXCLNPxiCLcIk4CM/3CM4RZjIMUYVpGGWIy/zzTIYsyMKNebp+EW47jr9fDXwvtq1TOh8nY6z6Q/ mftiUR7jF9Wq7GvVfz0rA7QqDfNAi/Qzz8Owok6Hq2zok0r/kMUJWkWPpWLHEKZfJ38OAAAAAGCX 1oLdl7E9x/Ya21MYMoIB4BBnsT3G9hKGcItSSMVpaAdalALm82t1rUVK97kO11pMPN8P8FMPc0+A pq/zovy2ldq9Hr2LYvfcIxJ29AE4Lhex3c89CZpKx+rW8Xmf88mewIvanAAAAIC/dTP3BCDztufr 89CKWr+0L38sjVV6DJVtAAAAAGAGnwKwd8c4DcNgGEDdsQMMCHZugDgAl+AArKxcrTMSN2Fl7gEq hYTIxHETJxWNGon3JCtOm7i/2sGKmvgTagEAAEBqbAGM3OvUQLvdR9hub376MewhDZvo71e9EIou 2KILuDgc+kEWbdBF9bttxojnxfGi9POWtr5wi/6z5GnARdPaUo/zB9JAibjfnd+9XlVt/2u/z47N qkgCLIrBFPlxTR1JoMVm6vwF5N/OVKBFvoLN0Io2pXCLxnXdruaV91S324Fh4yI5U+WNlTV3sYJ8 m/84Hn4EAAAAAOYohVk8hjbM4rNuL0GYBQDnE8Mt3uv2HI6DLMbaUIhFHm6xSfbPHW5Rmjf9Dwf8 RbOQ0sOli6DoLozftpLPN6eEVsy9R6TUB2A93i5dAJOG5upzzeshDM/RQ9eXeR8AAABY1v2lC4DM KaEWpZCJsTCL9L2xsIo5x6zpwX0AAAAA+Ne+BWDvjnEahqEwAD86MLMhIVQ2ZmYm7sDIwmG4Fyfg CByg4g6FVKE0cRw7oFYJ0vdJT0qatHGyWJVj/0ItAAAAmKI7YempqfvaF9br29hu83OchkEWaZjF 5/d+P8hiF2yRhlt0wy/acIvoBWTMZTnhFsOQikMwxVkSQDFtfZRusMX+Ht83m8yly+EVvfZ0wyq6 4RW5cIufezi+3NPYb+dmAZbCLaYmRqxi+JR3Lpu6rjf5PNpgi7HginQhnbGJjmOTHH+7kE73MVrE AAAAAACoKS3K/dDUa1Nv0YZZAMCpXDX1Em24xWMcgilqIRerkc9q4Ra5ocbS+FyMbJf6UeNzwF88 z90Aqm6i/hrLKSqi3L/oewCW4yL06f9Bre+d0q+X/j/mrhHJ8XQ7tw8AAAAc193cDYDEx8TzpgZS 5Kp0LD1n7LcBAAAAgIX4EoC9u0mJGAbDABxmNwi6UAa8iQvxDB7BjXvvMLeZE7jyHB7FxYAWS0la kzQunAjzPBD6A02+XRZtv1eoBQAAAJNSs4ul57WJDofXsN1ef59PoQdp2MT8+nMWQhGDLWLARRwx 3GK6NwZZxOem+Sbpej30Dbco9zdJQyHi+fw4D8GozT/6OB5XysnMk4ZZTGsl6/6oYbP5s0CLmuUf fLkuM6VUidx1KWUiXedyGBdt5d0P4yYzbdokp7WcUvZGrWHB8tj6k6OfHwEAAADgfNWacD+GMczi bRgPpywKgLN3O4x9GMMt7kI90GItzKIUbrF8H1cKt8g1Kg1hvn+uNRn3Pg74rafeBdBkF9qbW9eC k2p7z1Lu05naPmMPAujnZRhXvYugSeu3mq3BFcvr2p5urwYAAIA+hFrw37xn7qVBEyGsB1nU1IIr Ws5b1gAAAAAATuhLAPbuGKdhGAoDsAcGtjKAkJhYunED7sHAxMWQOAFH4gRMLB3BaQlJzKuTVmoJ 6vdJT3Wcpo26ZKj9fqEWAAAAjOlvbHrMdT92wXJ5tw6YiPwOsijDLD6/j4dBFlG4xSbgovuMfnBG czwnxw63aAMh+sEQcZhFea6r5na7t8c5Bc1vv1hcrscfq1V0I8PX6Fxx/BNsEdTg3IFEu/DbcbRz sBZuMTUxouxC046vc92M3/J5rofiK8pGOdtyNKaEWOyyYbL8GaM5AAAAAOB01ZqpPeV6y/WahFkA 8LeacIvnXC+pC7c4S7sFXIyFXdT+p9vWZLycS8G4NNZ0HKDVhMtpgP0/XKVpazhq60CipSq1hti1 58nYvOcQwPFcpE2oBfN3m/YLrqit2ZxybY1nNgAAAByeUAvm5H3P68qAiii4IgqyKM/356L5KFxj Xs0DAAAAAOAEfQnA3h3jNAwDUAB1W5aqgoUZwc7AwIVYuQjH4Aw9AYfhFEgdSkoJcVw7cZZQxHuS FSeObG9RVdtfqAUAAAAHpcMtUs9jHW23b2G9vv6qtyEOcdhE/37fC6Hogi26gIvTIIsu9OIYZLH/ eb/trxWPdy7mCbc43ZO2GAyB6NrTa7yPrf+ss9kczzT42O2mzzQNvYivSZDFYrnsvzOz3O6/oUCL 9ESaXLJELmUiHueqKZd107tvykNmiFVhiquQn0pt0EVp82NI2kLSlrIJEgAAAAD+h5owi9em3M44 JwAY8xiO4RYvTbkJXTDFRSgHXaQBFrXhFqWQ+ppDy0PhWcz/csCYp9+eANXuQv03Ib2fckh2bqFQ rt9QaAdgfodACyFVf8Pm+1r6Jse/B0OhXrOWc4h1nQAAADA/a6M4J+9RPbfxPRcqUVITUjE0zhSl UAwAAAAAYAafArB3xzgNw2AYQJ2tAwMbEkuHSpyBkQsgTsANOnA77tNLIHXCLYqa2E7iSFSu4D3p H2I7sZWhVof4E2oBAADAnOHHTu+xnpdu2G6fzgETJXmQRRpmcQmrSIMs8nCLS/jF8Bn99a27frhF /k3aOLDip7o+NCKM28ZBGOW+vjabu/Oor+OxbmVdHrLRDcIrCjeUwy+uGG4x9zV+6eSYuWSIpSoF WgznfIj1WLfsXfLo9HCcqWlrQixqD8xJX12YaAMAAAAA/gdhFgD8Ba+xPmPtY92HPMiiVL8VbrEm hD4kbQ4aB2qdftveWi+CasNDsGv2iDV9IczvK1OHZNtfANo77ecfrRfBKkv7awj5/7ip6zXBFvZx AAAAaOOl9QIgcVgekkkDJUqhF6Uxc21Tfem8AAAAAMAN+BaAvbvHaRgGwwBsWiTUARgQB2DkDlyC GyAxcL2OTFyKoStxRYjj2PkR0FbV80hWXMv54i2qkvgVagEAAMCcD5ai16lC2+1H2Gzu9v02sKEN sGjzG7rfabhFGmzRBVwMgyy60IvYYo04N62XXqPtn7L/DrfoB1O0x1JgRTqnV6FXp1tqGpZxtT9+ 7nYL1vMz0A+q+D6moRnpvIvValjjgEpfAo4FWuS70IztSlMKt4humnY9b3lPTbsvlF1XlrgOww1x frtRztQmOSU+iAQAAACA8yPMAoBz9Na096Y9h2GIxWVhrBZuMfcRYu2R4lg4fSj0c8ItgNzLsRfA Io+h/n5GLbAiVMbnBGBMvf8xds8B4HBioMXtsRfBIrX/cFP36Pz8Ur3S+JJzAAAAgL/3cOwFQGZJ qEUtZKIWbJHPKc1dcg0AAAAA4ER8CcDe/eskEAMAHG7UyTg4OZmwuTo6+B4OTr6Kz+OjmTixawEv V3r9cxoEJN+X1MClcBeWDqb9iVoAAABQk25+eo7jsfeBxeJuHZkomYYs8pjFGKvIQxbTuMUYvxi+ Iw1kjPfbzQ+xD38RtxjiD2nAIg1FpHGIrYBEY4/aZk4euDhf//1YLn/1fN9vxmuFkMXW/D1FLUo7 +ofXpRNjWmWI1qkztaBFes+bOG77j7yqizyF+iE4+YE46W3nRCx6cYvWpsnWpkgAAAAA4HSIWQBw 6q7ieI3jLY6HMA1WXIRy5OIslCMXtbBF7f90rcBF6eDTENrrM8DKy6EfgB+5DP1YRXo9dObn80rz Q+W9tQTgOFyHTdSC/6cXoKittXOut76rt4Zb4wEAAGD37g/9AJB5nzlvTlziszBKn+3Nq90bAAAA ADgSXwKwd8e4DcIAAEUtZcoUqQfo2KFTbtWT9BS9RE7Qw3TonBuk0IoajA1GaYUQ70mWEkSwlYUh xF/UAgAAYN9qN654mbvQ5fIejseH79ddnKELS3Txg/j+NohQxLBFDFyMQxYxetGO9hoxZnEbBCzG 8y35Stb1V3GLQTAi9CMWw/+ex2PxnHLsIjvT72c/r9faxQ3CFOn1i2GL7vXsmv5X7l9+U0GLdAea XFkiV5noz3NqxrFuec/NOGemOBSWeAj5pdSGLu7d4GDuOAAAAACwHWIWAOzJUzPemvEafjaQ7SIW /WjF1JgL1PfPWxKzmPrNrnSv9lsd7Fv7jIFNlLblMXlfE6yoeZYjd7+YezYk5Z4CsI42aHFaexEs ck94ML2vu/8CAADANpzXXgAkPjLH+qGJEMZRialgRe68UsCiNEd6bmkdAAAAAMBKvgRg7w5yEojB AIzWO7hxS+LCK3gGb2BMOIKn8z7uOQNxjDaU9p9O0ciovJc0oTBAA4tZTDqfqAUAAACRcpPT4zTu l96w2dyl/T7eF9WGLOqYxSFWUYcs2rjFIX6RP6MMZMy5zLjFcayi3Md2PC/DElfBPN7zlo/J//vr bhevoopYzC+3jVk0r505ZhHt0s+PozvG9MoQSyMKWpTfefM5Btym9oY3vaZGveRexGL0Rjn1T5dm ngMAAAAA/r65G6dtk5gFAP/fwzRepvGUPq7F1XGLPO+FLaLIxeilx5Freik4pub6HVyu7doL4Euu Tzh2LnjUi1VE4YuloEX0vc4vAD/vPbL3vPYi+Jalc+bIOXgpWgUAAACsT9SC3yQKWpwiCltE8Yro mBTMR0IWvYgGAAAAAHAmbwKwdwc3DcMAFECNqt4QcGEJdmAHRuDABkzVWydgE8S5U5QEiBw7dmJR oFR9T7LitE5iqVIjJba/UAsAAIDz1bpQxdPSibbbl7Be33zUhyCGIURiyGWI+/skhCIGW8SAi2mQ RQy96Et/jhhmsU/CKsbXKznFcItDjQMsYj0PuAgh/fnj5/12KGn79JjX3a6lM2m9FFZxMb12Uj9C uEWuFHYxt6pMvvpMvr8UbtG7+ioN7sPn4gX5aVeVLq6ydrVuLQVahMq2NlkyZ/IkAAAAAJyW2mJr D115C8IsADgfl1157sqmK3ehHG5RC7NoadPyanG8Hwr1kNVr4wW8s4Pz83jsDvAtt2H6v90SRDE3 Xmwu/GLumFI/WseKAHC4PtDi+tid4Ee1jO8+5N7qvgwAAAB/r5+A7RkO/8k41KI0kb0UQFFqU2qb f5cfXwu/aLHUJwAAAADgl70LwN4d2zQMRGEAPsIQNIgiBRIdA1CwBWILKkaiZAU2YYCIITjLCj7O 7+yEAsfK90lPsZy7+OTGShy/X6gFAAAAtfLB4udcD3MTttu7MFhiv/07yKIOsxjCKuogi3G4xRB+ sf+MMiDjGGsKt+jP398WOw6iiAIjxmOG13bQxfBe//PC525XHTdaS2qGUpQBFj/jg7rYbP411KL1 1H0r5WEqGWKq20wUaFE/+X+V63p+yV1jm6fqEJeN7ajZzVyIxVy4RathQXQ6AQAAAID1aTU1fcz1 kes9CbMA4Dzd5nrL9Zr6piRluEVZ0b4yyCK6p3dImMUh9/ZSMKbmPh6cjy6QTgOldbpp7J8Kr6jH TV0XWvP97wPgtHTfO16WXgQnxzUaAAAATs/90guAytcRY+vwiijEon6/npfSdPhFND8aAwAAAAAs 7FsA9u5Yp0EgAMDwmaaDi3HwIRoXH0ETn8LNzUdz7RP0NfoWbp0VbJByHMe10RbD9yWXAIXLJQwM NPyiFgAAAPNU+mGKt7GJ1utNWC5vv7ebeMV+O/S2u3GLw7BFG7johyza6EU96jnamMVnMqZxTP9h LnGLvVSUonvbm7BEHJhorwk/1zT79f2ofex2/dhELj5xFa0nMzq/T0QqdpELWsRfnSn5Ck18h26q cV22vPtqPCSmXQwscRGdV9LeGIpYjNVRQmJ/7DgAAAAAMA25mMWmGo9nXQ0ATNNLNd6r8RzS8YpU yCIXtsi9Wix95ZiL0AtbwHy9XnoBnOzuhGtKngW5/4QcE7wA4DwEqv6v1R/M6VkMAAAA0/V06QVA ZPsLc4wFLobOKQlXxEEMAAAAAGAivgRg7+5tIobBAAxHwAC00ABXIDEDQ9AzDQOcbgYGZAicIopj PjuBExiO55EsRc5vlRR3yStqAQAAQC5/Afk5jce1HXa7h2oUIg9PTAGLZcxijlWUIYuPcYs5fjEd Iw9kHOt04xbze+XLKMUyKFEGK5bhiuW77PncuPyp0EYUpYjiGWVUIw9tVKIb3ykKWEzL0RdhWmWI 1ldlzoJjlF8GuErjettl3xenOK8sl6fdErFYi1tETY7WxxEAAAAAgN8titfepfE6iFkAQGT8WW+f xiGNyzQuhjhqMc3ncYu1sEUZrN86yu2HYJtcNAecjvHe9NT7Iviym8a66H5eW279h6P1DKht67kB 8LNeel8AR+nx3PSsBgAAgD5ue18AFN6CuSgsUYtL1LaNRrk+2ifyR976BwAAAID/5V0A9u4gpWEg CgPwgBSKoAh6AC/ixoNIt72VRyi49yaew42gmYokmbxMYyum1u+DRyZJmQ7NItBJ5hdqAQAA8P9E LyRFx9a7OtpsntNicbVtf4VXfLbToN0Pt+gGW7QBF8Mgizb0Ilfuow2zeO+FUHS/7xCnFG7RDX5o gyhqYRDluXItk1i+Jsvl+bb9li/ccCD97YRzg8CNqI5A9GvVAi3KJIlyP0qZKFcQuGzqYtrw7pq6 Dro9GxliufjNlOyNsRCLaDt18YPjuLgAAAAAQBb9t5cnBh6bemnq4bcHBAB/TA5+emrqPsWhFmO1 K9hiypRjbV4vpf49vjYxbP4OTtNq7gFwkJvgWC2cqBZgsc/nuvvfCcMA4OesUj3kiNO0z33Ws5oA AAAwv9u5BwAdrykOtchqb9iPBVOM9RFtx0IsoiCM8hwAAAAAcAQ+BGDvDlIaBsIAjKbBpdCV4MJV d97AXU/iHTxC94JXFE8hdGVqCJlOZyZJi04p78GQtjbt7CKU/J+oBQAAAIPwJuPXbr1MnbDZPGcD EHHIoj+GMYsxVhGHLE7jFmP8YviMIT5xeP4Xbi1ukbv3LB27OH4+xjFSkYzeev3we/ze7xfvfxWG LcJgxfC4bY/es6oUtijdzZ+aBlMqQ5QmyrSJz4inADx262l6y4cBNtsmP9QmHnATfu2ciMVU3CI1 vKA0IAcAAAAAuB65mMWuW5+NmAUALHHfrfdufTT99XQIV9w154cuzglZlH7raxLHkN/04Pa81d4A F4mjFkvCEnMGW0/FLACob1d7A1y9OdfsOf9DuPYDAADA5ba1NwCBr+BxKUoxJRWrKAUt4nNzfyu9 VjoHAAAAAPgHPwKwdzc5CQNhGICnMWlijNGNW70CBzAuPAkLz+GZiAfwCt7BC7hjiwMGaYdpGfCn /DxP8qUfdCiTsGhC23mFWgAAAJyW0oeNnjYdaDJ5DXV9veiX4RVffVjr2+EWs++Aiv4gi1Xoxbzm n1uFWcxagRPN7/tthxtu0Q6oWHRVLpRi/XXVCItIgy6amvvq+nzRfUynRXOtOgIpWu8nARfVMtwi HTOw3FP8fYEW6SozfavOdCVDXMa6KJvefaybzGHPOqZ4lowryd7oCrHIbUsXURj+hwUAAACA05X7 f24c6y3Wc6yrf50NAByPh1gvsR5Df2hFLsSiZMw2YRch04fQfYkyHQ8ctlGsu6EnwY/dFozZdA9H 370cuTCLbQOQnDsA/sY4OJcfu13Pn+7JBAAAgP0zGnoCkHgvGDNL+jRQItfn9qXbXcIvAAAAAIA9 8ikAe3eP0zAMBmDYRVQMsLMwoG5cgYlTdOESHIEZiStwQsTUA5CSthj3cxKkQBR4Hsmq6vTH6tAM rfOKWgAAALCVbyC+b8Zt3xNWq5uPyETkOGSRdnGKtBttqCIKWRzPpUMEY/8a+9DE9v5vmWfcIg9W 5L7GK6Ljn5GLbHYR7Wdvb5fLNmrxttkMXuciC1akLLhR3i/nD8cmCFp07dSPKg+1MkRfyOIkeI3y k79sxlX/ks+ase54+3Ip+dsOiVj0xS2iCyBEFziwYRIAAAAAphddbPQutTGLl+RCeQAwhotmPDXj ObWhqDxQcZri2EUtbNH1c2MUshgarU+VufIYMF8PUy+AUZyn+n8yUjA35Lu9dk7oe86QEJLzB8B4 HqdeAH+O8zQAAAD8nOupFwCF1288tisyUYtZ5MdqsYohj5nJrn4AAAAA+F/eBWDvXnISBgIADA9i WBqP4NK40Y1bz8AR3Hq7egHu4tYlF8BWUuhjph2TakG+L5lAoJRJINDwmF/UAgAA4HLkLjbxNraj otiE1eo2VL8HqeMVlWb4oT7fjlvsDoGK42k8blGHL6pR3e4Ys9i14hLN+/sL5xm3CK1IxaIXjGhG LsZ7A+24RX3Z9ffp53Y7Oq9+RONwRS9YsWiELFpznyFoMST2T/5U0CI2xiIXsTLETdivTpDhoRyP kd0uE1NchvSiNzmhi9gTaWwhg5jTepABAAAA4P+KfW53V46iHJuw/3wRAJjWSzney/Ec0iGLbuSi G7a4Cv3IRc5Xj6nv+UJoHxMMLX4OnLf13BNgEveJy3Nfv38SO4rdLraN9wyA3/caxGcvyZTvrTnH BgAAAMD0nuaeAHR8ZG6XG6SIjaHrutuk9g0AAAAAnKAvAdi7e5yGYTAAw+6KkBAbYqzEwAm4BUdA 3KEX4AhMnI2JK7B07IBLm9ZNHTtEkLTieaRP6p9lT1SiSl5RCwAAANILjZ/iPNQWzOf337GJnOOQ RdjGKcJ2NqGKJmTRBC7acYvVKuwiF/t1+6hE1/5jOYe4RROAOAyBtK8rnyWRidluTe610j6b+6mE 8Llc9j1csvY4dHEQs0hDFunzieQCFs3j3N1fusoQtbvJ1O4qs3YT57bfse8K27ePkm7bJ2JRi1vk mhz1egoAAAAAMIb2/+XWRevXOB9xHsc/DgD8K5dx3uIs4lyHctAiF7aohSxyPzv+JGAfQv53vdxz 4Hw8x7ma+hD8iosBa3J/69P32p8pfUd0rQfgb71MfQBOSi42VfvOHroPAAAAMIyoBafmPfNaGpoI oRyWqF1dXwpX9HncZw8AAAAAYCJfArB3NykNA2EYgEcL3QluXOvSQ3gId27rBbyOd+gJvI0XEHfd FWIQ28zESSaWxgTyPPDRpO38QEsCaSevUAsAAIBl6FuIHHsudbTdvoX1+vp7Ow52yG2n4RbVMaCi eazCft8EWcThFofgizTMokqCJOLxpjL/cIuudWSHYIiL1n7TJt3Pr3Frt/nc7fKjHQIp0icLU4/a tIMtkrHnIRd20RVokatSyEXuU7j6qQEe6rrJdLvqmOIq/L6pTekmOF03MhiyYLL7iwoAAAAAjCF3 nW5T13tdL/8+GwBYtqe6Xuu6D/kgi1JdZraH/vQo2AKW53HqCXA2tz2v/eV/GX3H/FNCLJwfAMaz Cf3Hf5ZrjPOvczoAAACcx93UE4DIx4ntckEVuSCMdpBF+/2h0KavTwAAAABgBr4EYO+OcRqGoTAA J0jMLEgsDAwM3XoFbsCGBKfhFIxciVuw9ghgNWpjnOc0QaUB8X3SUxNHjZ9aqR2s+BdqAQAA8L/l DyY/Nt3G96NWq/U2aCLShU7kQRbNPpSiqz6sogus6MMt+mr29fV6HyBRm39Jvzncogyn+Ng3Wg+0 GI7n9yrH2/SddOfvm83c5gbhFWVoRZsFWrRBuMUSogCL3XG0E0wtGeLQbjJnwT3KXWSuUl0fbvk8 1cPI9GUr+bRTQizmbIBTfozRGAAAAADwM6Iwi7tUb6leU12cuiEAYOs21Uuqp2YYVDE1zGLqEuTY 2t5ObW0P+NtuUt0v3QRHcxmMRb/lbXFeHkfXytdD7xN8BHAaz0s3wNGsjnCPKf+3U0KovhNiBQAA AEy3XroByOShFtFT8VGoRE0UWFGOj80zRy0UAwAAAAA4sU8B2LuDlIaBMAygA4VuFPEGunblETyC R3DtxoN4mZyg5/AErnuA0jgY0iTjJI2lmKm8Bz+ZZCbJQCGFQOYTagEAAPD/5T4oyh17PXahqtqE 9fr2u90PcfjZrg/VhFvUh5CKbluH3S4NsmjDLvrVXbNtt/fpb0tRZrhFLwwidMEUbbhFu9+1h+e2 x/vj0v79vnnF8LndTs8kDbAYdg5DK/rjx6owua/2xwItcnVshZncSgA3sa7mTe8h1mPmsquRKa5C foGbuUEXcxc8CElfqrwfGgAAAAAuU/qu7T5WFWsTfDwNACW4jvUW6z00QVNTYRZjoRdp3znCLcIv 9oGyPS89Ac4qDbU45Zk89txPt1NtAP7GS6y7pSdBEfwPAwAAwOV4WnoCkPg44Zw0UGIs9CI3Lrc/ 1ZfeFwAAAAAozJcA7N3BTcMwGIDRwBSIAxKVkGADLqzABuzABrALA3FhAtQ9wCWYOtFfJ5aABPGe ZCVt0san9hDFn6gFAADA/1U+lHyXxvXUBzabq4/QRKSPWPRBhxyf2G1zmCJHKvbhiv74PmxRxi26 r+PDsEX/ep3hiKH1zXEYtCj3+3m+ddGz51HIIr9XhjKyl+12dF4XxyeKY8PYRjcMVhQBi6PgM0uK AhZ5P1r95VAZYipkcRx8R7m/c5LG6bxpX1QuP55Keak5EYupuEVtERwLHwAAAADAz4kisw9pPKdx +/vTAQAm3KTxlMZldzhsUYtWRO+Pb1m23NerLXAO/C33S0+Ab3f2ua39Nke/47WIUS1gNP5/mBM7 iv5TAGj3uPQEAAAAAGh2vvQEYOS14dxaZKI1ZtF6jVU9oQ8AAAAA7L0LwN4d4zQMA1AATVupG+rE zBU4AEOvwcrJmHsCbsMBGBk6loTEjZPGToIqCPCeZMWNLctVB0up4y/UAgAA4G9LvSjc9zQ20OHw Umy3u896HNhwWT+dryGMog6xaMMsqmsIs6g/F1HYRVy6YwahHtqXbBnhFt1zR9qgijgcor5Wcw1h Fd2wiW69H3Zxar7k+/E4HGIxOsVuAMaqH2TRtK3W63NbO59lGXqTPxVoMfWEmaGUifhXvWnKBA9l uR0YdpOY4qa4POhmLHtjzmE3Uw43yN0HAAAAAPL6z9b2ZXkt6lCL3bfPBgCYqsq1fy7LYzEebDE3 6CIXcBEM3UvxXx78DvdlufvpSXB11R6QqcESqba4Ty7oIrenI7UHxBoBcB37wjr+H31lHbX2AgAA wLJ4psPSvE3slwuXGAqw6AdZzOmXGh8AAAAAWKAPAdi7u5SGgSgMoINIXYLgg/jeR1/dhtsQl+CS XIGLcRVCQUwa0gzTmUwilk7xHLi0M+TnlkIDbTOfUAsAAID/Kb5puF8E46m2w3b7uA+RyJmCLKag if5xDKYYawiv+D7Mj8EWQ4VDTfvEwRbDOH/+FoIj5rXQYxpOcRxaMYVVDL2WsgiOj9u/T5vNzX78 tdvVGsmPC/Nxr/G2LQRalO7eL6U8rAm3yK4o073mvnKrAdx2dVdv+bqr51BewCZd5CZufUmIRS3c orQgTijMAQAAAAC/k34P99DVe1cfwc3SAHBJXsLyYIurzGMpwL72295oLsAeuCyv526Ak7gvzK8J sUg//9Pn6XFqwUeuEQB/7+3cDdCcNdfbJf/ZPMV5AQAAgCGsFFrymZmLgyZCOA6VmAusmNsuN86d oxZyAQAAAAA05EcA9u4gJ2EgCgNwtVtxYeIpXOgN9ATGc3gJr8TSlVfwNLogJDhF206HaQuiFsz3 JS9tmTJ9CQsSaOcXagEAAPB/5R4cyr32ODbRfP5SlOVZE8xQhzNs7q+abR1GUQVWVGEUcXjFctmG W3zur5rz2urOWYuvlzqE4Igxf91jHQgRB1rknkNvAyLq4/w88bndOYtiNrtYb98Xi1wj3W2mz2Y8 nj+qk9OvnzHCtjN2gHJP8g8FWqQryqTH66oCLer5kmCLqs5DzbZr7yrUdbG5aE3Z02JZ9C92s+2i N0OL3aQfokUPAAAAAGA/6W9pT6FeQ91P0AsAsJ+3UM9F+79dX5hFLtAiDbvIBVv0LWQ+tqA5cHwe pm6AX3E5MDZ0/8XYvRljYRe7XhOA77sLdTt1Exydbb63h94LAAAA/IybqRuASC7QYhe5YIu+8Iqh MIvcWC7YIjcOAAAAAEzsQwD27lgnYSAO4PA5M6iJg3Fk8w0cHHwREx/F2Wd118nY0hwc9c9dtQlU /b7kApZWLzGBwNH+RC0AAAD+n/JEpcdu3LUOWK9vN9GJyC5kkbYhiv42hyny6GMWZbRiiFn02z62 sYvh5/3jd797+vdNxC2yr+eU7+IUw/YyTDE8Fh1bznX/XLWzIiqxWl1ubt+jqEU0u1rgYhy5KOMW jUDGsUUBi3w/uhLMoTJEGLLIowhaHLq6TO+6GzfTpn1f+fPjqZRTnxKxaMUtoqlHF8JZxj8YAAAA AH6P8eduD2mIWfRRi/NTTAgAmO2lG2+pvp5XC12MgxbR2l60/pfV1vZSYxuwHE/Je4K/6mrifq2Q RS1mVHuOb8UxAJjv+dQTYDHmvu7OCV0AAAAA33eRrM+wLK/F/egM9yhAEe0z9bEoUPGTSEVrTgAA AADAEX0KwN4d5CQMRGEAHgghbkw8gQdwozfQI3gMb+UVOAFb7+EV3LCytrSF0s6UwcSUmu9LXsiU tgx0QVKG9wu1AAAA+J9ym0i8nTvRZrMN6/XdYdyGG7SBE+22Y7jFMYyiCquowijq0Io6uKIOs2iD LbphFt9NdcMsipPgh+7r5RBuUTkGVnTHZ49apHqTFCH+X/ZFWK1u9qOv3S5/dr3wiuS4v/9yebLf NYp1ekkFWsRq322mCrNoAi0GnWSqzyecXo3bpjI8lPUYhkEV3YY2qdCL1FvICbQIicf+RdT0AAAA AAAu0713Vt3Ufy9rG+r7gADAPH001Q+uiAVZjP2+N1a5IfUtIfUwT69TT4A/cx/ZFluyEhuPrddI re1IrQO5ZO0HAPleynqeehLMmu9jAAAAmM7T1BOAns9fHFOEYSDF2HOxx9hxsXOk9gEAAAAArsiP AOzdMU7DMBQGYDdIDFwAiQlVYmBk4RocAY7CCbgeIzdgqViB0DSN5dpJoIIk4vukJzdWEr+plRrF v1ALAACA/yV+gfi+rtuhC9br620IRU4cQBGP7XxbTWjFx76aYItwEHjRXfseBVs0c8eYe7DFl7/p cRXizIj97CoOseiCI+KxHIrRHVfV6XZ83WyGO+kLomjXS9dvgy6qKulpen1v/+d2giklQ8Q7y5zs wizS3WZK92yd13Uxru2rvuUzy6Yt94VYjNkAJ7dxQijMAQAAAAB56f9sD3W9hOYZAACwXG91PYXD 0Io02CKdLz3zKz3/G9qgPP0cojlgGS7rupu6CX7NWXI89vt5KPgiN/5kHQCO8zh1AyyG32YAAACY n5upG4DE8zfOLb31XgqhiK/JnTMmuCINxAAAAAAAZuhTAPbuJidhIAwDcBMSdv5s3LvUlScwehQX HsgTeAZOoPcxrti4rFNLS2lnpmDENuR5ki+lP5QPSGhC23mFWgAAAJyefW8kfh7b0Wr1ViyXl+18 E7xQBU50VaETTfhEE0ZRBVX0QyvqMIsm2KJetht4UXTCLMqf6r/2b8MfmoCMOTtGj93wh20GRH0v +nZdbDySbrDFMH9gu7xs58uyXv+xXh/cYzuNBVU0YRadYIveG5qt2AgAqUCLnXSJRKDFIEmi+lyK 3W/oPNTZfu3dh7qK7H6RaHFRDNvItpeoIjHddyCc+X/xAAAAAPA/uv+VXYd6D/Ua6mKSbgCAv/QS 6qsYD6nvB1mMnWaMPU6fMBZID6fgaeoGOLrbzTT3Oz28+Cc/n7uGI7ePVB+5fQMQ9xjqYeomOKqb A7Y95PjpWAsAAADzcDd1A9DzGVk2Fk6R27bMVH997DkxMx8JAAAAAAD4FoC9O8ZpGAYAKGpVnbgA CwPq1htwEjYkbgLng4E7dO8ZSkoIMa5duygohb4nWariJPUWqWnyRS0AAAAuR/xw8EM37moHrFbr jwhFzhiyGGMMcdhiGEO0Yohb9GGLcBC86PffRWGMMZQx5X9QLjVu0RtjFrln1g63n/Jc2+5r/812 27icQsQiXk8yhgBGWCy+BTvOwbGn/HOVh1wZYh+zWH4GLY6N0jkH1924qS952Y37dAmFz/HXtUYs anGL0gsTQmEbAAAAANBLf1d76sZb8JI7APgvXrrxGuqhilMD9bX7evF8COX7dO7fwd/yOPcC+HVX oS0s0TIXz7dEMNK53DpcNwB+5nnuBXA2Wq+lU1xzXbcBAABgOrdzLwASuajFXhqdSOdyYYrSOXJB jNKLAnIhjNoxAAAAAMDM3gVg745yEobhOADXkPBiop5A333yCBzH+3gRTuA5PIHPPPlEwE0y+VM6 1gSQRb4vaZp2W9fAA8lG+xNqAQAA8L+UFhOV+l6HBprP39N0+vDb7kIW2sCJKIZPbIMs1lnZDbJY Lnf74rUxIGP33uufe53KdYVbxPCHfA+SGHJxE4Ii9s/Z5Ersr0/vxl6tNvXnYlGeRV+IRdcX67wv ntvNcSAUYyxKK/j7Ai2Gdp8pJkm0n0cYuy13Tbmtm95zU14Kw08KU6zdDKcm0CL11LWbLIz/iwcA AACA84jPxtpne22YRRtqcX+Z6QAAJ/bVlLfUHzZfUyZp/71daYyunUKdUn1gfcra3uHB+Mya8nTp SXB2jz39QyFF3bFD/+nIz6kd228CwHFmSYDtNTsmnAoAAAAYD893GJOPgeO1q9ljaEUeSFGq+8It DgVj5H2HrgEAAAAA/ti3AOzdQUrDQBiA0UnvIIgr6UJw5c7r6FG8gSt3PYCn8QZu3PUEbrowpkkz DZNksNgJ9D0YLKatPwqWaiafqAUAAMBliDcWP9XrcerOm817WK/vmwBFrA9bdCGL4wjFMFCxD1f0 cYvdLrTHjoMX3ee6x/ahjOarDqYbnsNymsuJW8TBipCIV4QofNEfr6rUHvUQ0nvX9z6324xxErGK 9mMVRSuqwWruslqln2MBpr5bqcrD4UoxbZhiKmSRW47oXNfrJm/su5C+yE1qlHj0nIjFXNwi98IH y/thAwAAAMB5xX9H+y1Sv9bro14PxSYCAP7DW72+w99iFjmPmYvSjwXqU/wPD5bvufQAnMXVxLGp 6MRckGLsnI653/9eHwBO91J6AIrJeR3NPbfS+zoAAAAo57b0ADDwFd0e27GeClCkAhWpjf5zYYu5 +MXYHAAAAADAwvwIwN7d5TQIRGEAxfCsvjSuwwWY2CW4BxfgQmviLnwy6Qaa4CAgf1MGG5XSnJPc 0NIBJmlSEij3E2oBAABwOWIPFsXWPad2tNncZXl++/2+CVQYBiu04RNtkEUVZtEPrSjDLA6HJtii qMMuxiEY3YCM1LGFW5yiDbQY9iNpwyvGfUpiYRftNu1nRVFdZnjf73vj6xfxdVPBFN1xZZBFeexO oMVVavszEnu6/6trTJh/HirVdaZJluh2n+klRtShGN26DnUzb3oPWdXgYNjMJh8cMhZ0cawhzpxA i+zIcvilppooAAAAAMCl614L24Z6C/WyzFQAgD/0GmqXjUPkf6Omgulj9/WA9SvD8J6WngT/YjNj TOp3fs7/OWLbTI1xPgE4zTbU49KT4Gw4nwIAAMA63S89ARj4+MHYqZCJVPBFbBnbl0ALAAAAAFip TwHYu5ucBoEwDMDCBVy6MZp05xE8iRsX3shlb+NdvIC7uq1godDh4y9aoeZ5kgkwDMyQNiHpFF6h FgAAAP9f+4Hj56I8jh2w2Tx06uowhTKE4hBkcRpCkQZUxOEW+2O4RV13aNsc2wRlfPc64fKEW0zX DbE4DbjIOttx1kDWypto6vfVoD52u3lhE1kynqpk7WXV7rgvz1uHr+uZvSjAol5vvw0mr4IooiSI NDmiry49Z9r/TVFux4dcnvZpoKuo276hR1+gsXCL6KUJ0eWs64MGAAAAgPNr/25WvpD2tShvRblf bEQAwLl8FmV7NR4oPxRa0bdM5/eGJoTjCWJzdXCJykCL66UHwZ+4S7b7/oORtonapvuitnPCL9w/ AOZ7WXoAXLTfuve6hwMAAMDPCLVgbd4ntpsaSJGuR9tRGesXAAAAAFi5LwHYu4PbhGEwDKAOiEur Sh2hI3SEbtLeemSdLsIGvXeHzpFDE6FA4tgOqVQSqvckCyXE5hcgLBHZn1ALAACA/6G0+LjvfWqg w+Ez7HaPp+MuPCEOUTiHT5SDLI5tGGJR1+dzXb9+QMbUa6cJtyjL7z1SVXGYxTgoIh0cMVz/3q+l bj/sYjnV+LhrieuqOPiitdmsLtCi5PSuNzX3Ay1KO8+UAi1GO9G044Yw2D3goWn3l5XXJtk8J4bf ZkrchnEZxfIyLWQeL93k4Ha+AAAAAAAwT/+/r5emfTVtv0wpAMAVfIRjsEUpRL50760UaJELs0iF z4eQv2+XuscHrNfb0gVwNXe/7JcLNoqfCyH9uz93LjB3AEx7atrr0kVwM0pz69S8a14GAACAvyXU grX5TpyLF+bPDZ2I+8bhFrlxctesfFU/AAAAAND6EYC9u0lpGAjDABzdd+FO3JideAPBhSfxLr2B 13HlDbyJa4VudJISOomTmRCwCfF54CPNz3S+UugiofMKtQAAANi2+A/Hz6EeSgPq+q4Nqoh1YQXN 8WOQRT+E4hhsUQq3+O5VfF039hSU0c468yMLtxjqAiHiYIh+mMVpv7v+uJ8Kk7hIBl401Xxvu91V e+zrcEg10t/mxHOOVO/cyoyt7HKZCJ7IhVqkgixKyRHD+a9D3Uxr+zEz/bCVVOu5hXRKi+RMWSBh +BoAAAAAtii+T9YkUL+Eegt1u1hHAMBfew31XqUXF8+FWKSe3eWC5uecq6rfz+g8s4P1q0M9Ld0E Z3VfpYOKYlN/48cCLcbG5QKSUj3kzgP8d/ulG2CzhFwAAADAedVLNwCRj1CfM8YNgyqqwn5qW3qP KXMAAAAAACvyIwB7d4/TMAyGAdhJ1yAxcABmll6Bm8DGyM1QT8AVuAgbS0dC0xLHcf4k1CjoeSTL cZQfq6oUqam/V6gFAADA9uUWEuX2vUxd6HB4D2VZ/Y4vQQlpYEIbPjEVZBE64+aY5rw42OLS4vsM 3Xs+4RaN/vryNqiiv048vz+tZdJeJ/2qVdXtqf86HhfPv0hDL+I+CbIoyrJ7zAacPvd4HLqVZdJk iLGQi9zxxfkeaaWam3Ob4aFu+9AvgLMbmNYuTE97TqBFGOiXFjwAAAAAgK2Lf+t6rNtH3V7XmQoA cCU/xSPezttDQRPpeEmgfK54+dj7OuB/eF57AlzdXWbfVMDFmLn/5xh6xqTX8pwBmHZft6e1JwEA AADAn9ivPQGIfEbbuZXyuVCJnFwYRXpO2qfnL5ELzAAAAAAAVvYtAHt3jNMwDIUBmKkLF2BAYurA wMzCwEkQR+EG3TkM5+AUbGXqQNyQxnJf0qSgJKq+T7KaOnH91CVS3fgXagEAAHC58geCX6r2eGrA ev2wD5zINSEJqb8OsmjDE9pgi1PhFvXxbleGWbRjU1BGE3rxv/8tEW7R/Zx5fVyGU7RZEsd7mTTB E825QxDF7zWr1fX+3dd2O6jWNmAj6IsCK/Lry9CLhTl8MyloIgu06NplJkqCKJMjuvq6PrNxU7Xb YWU/9UwVTdtVerQZzpjNdY6+xqAPAAAAAC5F/rtYSg7eVO2janezVQQATOW9at9X/ZuFl+ts+bly zNB1uNxf19+s38HyvM5dAJOLQi2SvvCivntHNGZsMJL7A8A4b3MXwOTuZ5o3usdH/QAAAMB5nucu AAqfZ4wZEmARXVe+Rq08V84LAAAAACzYjwDs3T1OwzAYBuC0kZCQ4A6dWbhCb8LEzNW6snAFRi7B xtAV8xPquLEdUCEpfR7pU36UxF/VTnWSV6gFAADAcSs9cBy7rV1os3lo2vbia7sLRUgDHN7CJ3Zh FqUgi2ZvuwuxiIMt4oCMTrz/cA57H8sxhlvsgii67aGz+uEV8bn9AIv0uh/a9ux9+bLdVvtLx+iF U0TLRVTxcYvlcv8aMzPUX/qWmfgtNGl4xVC1A8f33mTzGaAR12Wo83EtX4W6zgw71GIcdJH7CGMC LZrMMvfwZGrePwQAAAAAyIv/21qHegx1N00rAMAfuw/11OTnyUoBFrUQiyY5d8x82k/n3GY+cw4n Z90IyDtFpe+8dO9Fbb0WjDR2TADKVqFupm6Cf2nollUAAADgd62mbgASz984thQyUQqzyIVXjBmj th8AAAAAmJFXAdi7Y5yGYTAMoKYSCzdAYmDpyM7CUZA4CjfoBXoANm7AXTgBU+eSpjJJXDtxJVBa +p4UWXH/xN6iNLI/oRYAAAD/U3/h0XNzPI4Vr9dvYbl8aMMm+mIgwi6IYh9kEZJ2WxFucRh2sa/t ru2CMtpRB+P/frDFZYZbdGEVsTcGXHT9w9CKNNzicH17DMnoWyyu2/ZrszlqjoPwh6ve2Jkgi0H9 CYdaxHCJn/MwXPGfS3nIJUGkyRGlvtI9o9vmuKub+lNmuLFhS1PPbZ4zFW4xtUFP2gcAAAAA56z/ P9eqOT6CzWcB4FLsNo14D+MB8LEdC70obUpa+u429Z3Ndzg4fy9zT4BZ3FTU5J4pITkvPXdy19TU eK4A1HmdewLM7tjAibF3vdr7eD8EAACAv3E/9wQg8VlZt03a0m+58IpcO1aX3vvEV+oDAAAAANG3 AOzdTUrEMBgGYItLRdzOzqXuPIJH8AaeQDyQh/IOXsDN4HZM6VTTTNJGXaSF54GPtkOn+QoDA/3J K9QCAABgu+ZeFI49Lx1ot+unur/43h5DGtKwhjF8ol/+hFjkgytOgyyG7TgEYwyEiMfJjS3c4n/G AIihxzisIl1PgyqmwRdL78z1ux0Ow6WGj/2+trlJMEWXhFQUgy3G9a47+U5rNT3l3iZMgyzm6jyz /yQx4hioEddVqMu6U7gLdV8YNtdiHHRROoWaQIuzwrJ2woN1/RAAAAAAoCy+7tVfi3sL9dKuHQCg gddQn8f1mvtfcxOK/2afJSu96w1Uug712LoJmrhNtmsmt/5LWEXtsx65YwGQdxPqqXUTbJb/WQAA AFifh9YNQOI981n6ov1SkEVJTbBFbgzPJgAAAADARn0JwN7940QIRHEAZlsbSxMrGmNpvJP30Lvs Bbb1EraewHqPoBAzy+zwWIhsMsR8X/LCnwHmQblh+Qm1AAAA+H/yPw2/dPV86eD9/tC07eNpuwyV 6EMo+vUUQjEsv7NKARdluMX5djouPy8FZfTrc++gCLdYY5eFW+xO4RZRcMV5iMWw/A1rGAdPpLF0 7d7X8Rh3UYRYTLc7DrMYjW0szKIXPptiPX+qUcpDlARRJkdM7SuvWc5/19X9slt5CKa7NO1U61F4 xVy4Rfnxg/w25j64AAAAAABbl/+u9drVR1dPlXoBAOp47+oz2H+NUIo5cx+bWHsNoK4+0OK2dhNU c/OHc9aEVUztWzIfAIO32g0AAAAAcFVt7QYgEwVaLDEVUFFWE4w3wVh5XHROOQ4AAAAAbNCPAOzd UWrCMBwH4Ojr6Njj3uZBdpd5wx1hZ/Fd77BuWWmWJm0QpBW/D6JRYhNLQWj/9SfUAgAA4D613iR8 XNpQ1z33j0+//TTQIg9m+AmfGEIoxhCLPMwiZGEWw5j4Og3AGOZI58kDNWqEW1wvhi6U7kcPIT2E YoDF2JbvYY9tCLU4XS4ti/nfL4VV7MaQjV2pv99vJtyiFGgxOz7rp2kPtTSJuWSJSZJEv548PaL7 aw3e+/Zamba0xHQ5ta/QEmgRKs/5zq3t7G0cDAAAAAAwlZ7nOvTtK8RQCwDgsZz79nnjOUp/IjF3 UXyDV7aBKx3XXgCregvTGotSvcXSmPS9uRqOUulLbY65bQM8skPfPtZeBHeh5feztc4SAAAAuJ2X EM/Xw1ack36pNqAUKlEz9/lSbUJrzUJtrlJABgAAAACwsm8B2Ltj3IRhMAygqdQjVOrSoWLrxtax l+hc9Sjco4fqCbp04wQdqSOUYhsbE4RIVN6TfhESOzEoEgISf0ItAAAA/pf4huC3UM+tDovFU3Vb H0LRBzPEIRTbUIpNVHGIRRxmkT4fwizifn1AxrDPU64pEW4x1vb02IUv7E6XPowiDbBI73+LAxvi dmngRfcXavG1Xift90YyrMtDLPaOEbUv1E2l/yXlYy22yZbjd7eU8jAmyKKVHJEf/z7UQ/tl3YZ6 HTGU0tAPhVi0wi0OTaLQmlgBAAAAAOYm/h3rPdRnqJdphgIATOwj1M+Z99mayOGYf6zziSRqk1aY NALm67HzPePa3VXWt8IlasoXER2/XNoXAKnV1APgKvgMBgAAgMtZTj0AyHyf0GdTqNq2rvJY6lPa R35cAAAAAGDmfgVg7+5xGobBMABn6YQEHIEjwIlg5lBcgalLZ+4AM3vvgEPl1nHs/KhIDtLzSFaT yIm/IVP6Ja9QCwAAgP+n9HJR6djr3IX2+49ut7v/3Y7BCzGEYbg/DqGIQRWXEIsuC7OIc077Mcgi DchIwx7S9dYSbrHeMIjhEk7R1zgMtqi9U54fi+EYp73v47G06FRB53pqARajIIvGYRbnWq85P9tO 0x7yZIilIReDxIhQX54ecRvGzbLy+sSbx8qypbLScmplLwm06Cq/5ZturP2NAQAAAAAX8XlV/zD+ PYy3MO7alQMANHQI42vBvNI/y6WPP9Q+ElEKqJgbpXVrawHb9NK6AJqrhVpEUw1Ac81Cc/P0cACs 9xDGc+si2Kzljbt/d30AAADgek+tC4DM54q5tZ6AWghFes7UnKk1av0KAAAAAMBG/QjA3h3dNAxD UQBttkD80L8OwAJswAoVC7NIdwiBKOjFerYpQriqzpGsJrFTv3xVqhxfoRYAAAD3I74o/La0594N x+PpK2wiswVYxLaGUsyhHb4DK/ZhFvvzLcwihlvEgIy/Wmsi3KJnKgIrygCLdcw8x779/fE9trV7 H46xe7Ze4EPWX1ybYpBFGDOFcIup7P8Hv5kzC7DYjrOUhywJohZk0UuOKOd/WNrjz8o+NaYpS2mV nm1q0Au3yDZKyB7Hy5UAAAAA3KL439bL0t6X9jqsGgBgtMthDbj61NoIojyvhU5kx1lQRfZd2Zja 8bX1AuOcRxfAcE+NvtYm2K0lLdnntXNY1wGQO48ugLvk9xcAAADGav1XDyNckmu9cIrW2Nrag9q6 hdqah149AAAAAMCN+hCAvbu5aRgGwwBsyg1RBAd24MgADMEMTMAGDMIcvXJiJk5IkFaE2I7j+BA1 RTyPZDm/zlepl1aOX6EWAAAAf0vpJaPSsae5gXa797DZXB62+yCCOMBi2P+KwizCT2hFHFIxHEuD LcJv2EXf5yEZvfh5SxBuMRaHMKRBFmkoRRpQcZbcO4xRf9dtu7059J/7L8G4kLRvOBfX3QdZjNoR LR2gUVoZIA+yqLXzwvVJYkRXb54ese3aVVt5D127nXhsqcQ46GLqI7QEWoSJvrbIQstxAAAAADiG +P+pl669BS8sA8B/99q1j4lztQUj8v3aAhF5MEXL8dLiEvk2cPoeg98chHDRcE0+L6MWbjHVz83d MGcDYN51157XLoLV3a1dAAAAALC4+7ULgEwp1GIvn0eQnyvNNZgaoxRaUbu/NH7pHgAAAADgBH0L wN7dpDQMhGEAjl0XdOXKRXYewaVXcOfOg7rxGr2JUIo1aTt0Mnz5ETEp9nlg6OSnMx+0UGgmeYVa AAAA/A/5DcNvTXsae0NdPx7CJiJtkEUZQHEOuMiDK/bVbrcvwiy628dAjKoTjJHGb/t/ub5EuEXk /FXJAyryoIs8ACPVWN6bns7PX9vWfqbr9d3hzM/t9ufV5cEWeWBF6q9WnXNuZg62+G2gRRRgkfpR ykOUBFEmR/Tt6xszuW/aw3jJ7RCvwXRD0/aVHoVXjIVbRKWXD0wo+wAAAACwpPRfVd20j+oYagEA XLf3pm1O/b6rw9FDHqJjU8Mt8vZ1akNBFuW+cu6p28AyXpYugItQPhh7KLSiFB3rC7bIxx4Kvxgb H+CatYEWt0sXwUWY6zfSeksAAACYx/PSBUBmM3J86vX+KesLonUN5XZfkEU039AaCgAAAABgQd8C sHfHOA3DYBhA3Q5dihADB2Bl40bsTNyMqTdg5yLdWDoVkiKrjmunAaWEiPckK07qxH+kSpHaJJ9Q CwAAgPnoe3g49XTuQJvNa1gurw79GKiQhlcc1z86YRQxpKL97BhiEbIwizjuaz0u84CMKJ3vUoRb nGYDdMMZ0oCKZOuiNO5csMMirFbrQ+99txtWXeV4ne1ZwMUihlvkYy4kD/oY/fhZP017qKVJ9CVL nCRJtPWH7rfgumnrYed037SHyrSlEtNyaqcwJNAiVJZDX3zgwUsAAAAAflP621X7Qtm34CFlACCE bdNeej7ve0FDqbX2PePy8Ip9oV+bJ2TL0ospajUD07lp2uPURfBn3P5gn/yejO+EVdS2DZkP4L9q r93PUxfBrI15LXVdBgAAgPHcTV0AZLZJv/Y/f+0egtDTz/ct3UswJPwCAAAAAJihTwHYu4OcBoEw DKA1aeLSlYlxxc4DuPQSnsELeQDv4KE8gLu6bAVKYRxnCpgKRd9LJgPDMP3bTRtC+YRaAAAALF/4 R+Knst33nVAUd3XYREoVZBEHUHQBF11wRRxa8TXYYtcGYHRt1wRi7Nff1o/ZmPaek9OHRiwt3CIM ZzgEVPRlQYTzL9oaw/Eu7GHfr9eXdf++2YyqKywotx+Pt8d+OdDipOtF2+Gnl0p5GBNkMTQ5onlj q5uyux1W9sOIUlKlHwux6Au3+FZ69LHFYwAAAAAwtcO1qeqBdM9ley3b1XzlAABn5KVsH81230Mi xgRLxOEVcZDF9sic+Fi8vgALWJbHuQvgrFyv8vdYhPt9c8KxVJ+7byMVkJE7nntdgL+uCrRw7ZCp DPmuTf1W+Mk6AAAA8N8VcxcAkbcRc3OBFantvrCKMeEXuXMAAAAAgDP1KQB7d4zTMAyGATRVxQYc gQOwwBG4DSNcrgsLC4dgZWbqHgFJS0hi7MRFpEml9yQrrhPFf7tEamx9Qi0AAABOQ+4GofuxG202 L8V6fb7rN+EJ3fCK9vNnL4yiCamoz7UhFsVPmEVZ7sfKsg23aIMsfs8Rzn8s04RGTBNuMaU2p6G/ f7wfejGWGxALtqjvcbY7vm+3GXWsov1YYMWqE2TRq/WEAi0G5wr63bSHMBkiN+SilxhR/15B/6Jq l3nf8bpqN4lpY2V1yxkqeyzQokgcczZRDo0DAAAAwH9p/oO6rdpz1R5mrAUAWJanqr1+92NvgIfG UmETYSDFR2I8p6WuT9WXew44rse5C2BRrhLjuesqUkEU44uIxucCYB+K69lNrr8+U62nBAAAgHnc zV0ABN4OvD5nDUNsbGhdwqHzAQAAAAAL9yUAe3eM2yAMhQHYXbt0rNQpW8dWnXuYSj1aDpCeKUPX HIFCUAI8DAQJlaJ+n2TFYOI8lCmR8S/UAgAAYNvaDw1/lu1t7OL9/ivtds/nwImcKsgiBlA0ARfF Nczi0q9eL2EWTb8feNGEW9TzV/2115psIdxiyRqbsIrz0fX1LgZEpP5xO+SiO0+/vmqoKOrx79Np ToGdWmPtqdWyxwuL97n4/KHf/mZyKQ9zgiwmgy1a4RaVx7I93Vb2+4xScqXH20vhurFwi7hJQgpz xHMAAAAA8Bsu/0d9pDrQ4mW9UgCAP+ZYtsPI+JxNHqZCKWLIxS1tbEOJXH9sowpgPbvkdwhd9xPj uXUVQ+svcus74thQ4MXUZwL8V1WgxcPaRcCAuEYTAAAAmOd17QIgOGbOxQfhxx6Mj+eH1hLk1hPE 9wxdY90BAAAAAGzMjwDs3d1KwzAYBuB4LBUvwVO9L8+9H0GvzlvQM1k1dk1C1mQ/2oLPA9naZmu+ sUFhpHmFWgAAAGzf0s3EqcfWiYbhZny8/t6ewgjS8Ip5P4ZQTGEUMbQi9pWhFWmwxbQ/t7BvZUBD Ot6a/le4RX7veR5yUb/HPA29yPvyn2CsL+97OxBqsQ+lmA90lJ68pwy2yOo732+GWTTHLrbTtIcy GaI35KJ8b/lND1+t7zM/hLgYRm3YWllpOVcHjtdKW1r4oLZYQij6Sm6yBAAAAODSpv+nbsf2OraX YDE6ACD3PLb3n+3WAhA9/a1Ai3OCLD4r4yzVBWzH09oFsDn3C31L8yxqU1ZarztmDHM3AOJ/ia7d nOKU66j5lAAAAPD37tYuABIfYZ6zcIxy3kBo7NeeW+foGQMAAAAA2KidAOzdQU7CQBQGYNh6ATZu WRpJXHsHb2DiCb0BZ9GFa05Qba2Nw/BmKFFsDd+XTBheZ8oLGxIo/YVaAAAA/F/pH4if2nF3bMN6 fVM8NgRZpCEX3RgCKvowi/35EGbxHWyRhlv09Twgo/m8Hcb8riu5lHCLwyCLvrYfXhFlCkRhD/m+ vtY0/fxttzu1uYPwijy0YpkEWiyDcIufSN+Hv1C6G0AaZJGOU4IsouOl83ZW7bge1/Z95WXzWtR6 KbCi1F4t6GKRnSOvAQAAAMA5DN8/bdqxbcfjhL0AAPP03I7Xr3n0C2+pVgutOBZsUVv3HqzL10fB FrWbTQDz8DB1A8zO1Yg10TUb6bFonj7P90T7ojUAl64LtBCMyznkn+2LYP5brwMAAACU3U7dACRe knntGoXamrxe2pM/lvaPEQVmAAAAAAAz8iEAe3dw0zAMhQE4LdcKMQGcuTESR7bj1A0Yggm4dgQg RJbsh+0EKtoA3ydZceMkfaoqVaps/0ItAAAA1q22AKh27mHuQfv907Dd7j76KRghD69IaiEUKewi BVbkoRUp2GJqr0UIRn5vGZQxFHWsyd8Pt9iE8IbP69TLsfyaGIJRfhXTfam2l8OhX0kMsCgHy9CK /PpWO8Ipwyzm1Fb556EUsb8k5KIXaDEeL9/bbtlncDtMm/XFEi4aZeXlbBrnW4EXtVLjsbdJwpLz AAAAAPAV6X+m+2EKtLAQGQCIxjCLx854bVOHVoBEK5QihlPEfq3VwjBaoRl5fbXae33gdMZAi5tz F8HqXIfXvdCKqDdPrbVRdmsT7aXPB/gvroYp1AJ+0jG/tb25l37DAQAAYN7duQuA4Pkb99TmK8R+ bSwel8yBiO8LAAAAAPwSbwKwdwcpDQMBAEUDHsCNILjqRnTrTTyEt7LUpedyb88QY+PY6XRmmpRg or4HQ0MyzUQQhNbki1oAAAD8TvFNQk/deKhNXq9fm9XqbhebyAkhi+P4xD5QEYIVYTvELPZhi/4c IXjRn6NNXnerfa25zKhF8LfjFlEkIrqvPI5dHIcv0m7E4fviX8m27V/fttv97FK8It6XrP99LN2O r+3gOs8zZ9Aid6d/2M5VHnKhilIh4iIzrxa3uO7GzbDLvh2wbBqqqMUrmmReLW6Rvq9JzpHuAwAA AIApxJ9JvXRj043L+S4HAFiw52i79G1u6eEO8fFczCINUYwJWuTiFmPGqZ8J+HmPc18Ai3U1Ym4u WlGKVZTiFec87NoDsoH/5jNo4fNEUvcTnGPI39NasAIAAACYhqgFS/M+Ym4tMlGKWcTHSv/7UFvj 1H4AAAAAYKE+BGDvDnISBsIAjA6wNBoXuOcg3sWNB/Bo3sQ7uHXpgq2tMNgOM0MbNa31vWRiA6X9 gwsjFD5RCwAAgPnKfVgod9vjpQNtt+3X1V99bscIQjdeEcW4xSFmEU6r3aeNVcQV94lhixi36EYw 0sd3z5ubY66WF7foRyj64Yrz7Ri36McmkvBE6Icl2t95632/z0csLo7YD2Cs0pDF8b7Ven26rz/P 0NN8P4jxW3KxizRQUVqb8FWW6BYmakGL9ud1s26GPR/34dDASMfZFEbMjVGKYlyKWJS+TKHLBzAB AAAA+EnxdaVds16a9TDdKADAzD036/W4nXsHt3ZbLliRi0uMDVqU4hZp5CIk56nNPuN3+OHfuA3+ N6HsLpxfTzEkRFG7Vq0WvygdN7fPmOs8AJbkaeoBWBx/PwEAAGBedlMPAIm3gfvVghS5awnGrtqx XXsAAAAAAH/QhwDs3TFOwzAUBuCgsLMxoW4dEQMX4Ahd2FEvyHU4ClIHSBtFNcYvDkVtUun7JCuO kzhv6FTF/oVaAAAAXJ90ce+2a8+1B9brx/DaEGSRhlzsWxpQ0YdUHPtDmEU6lgZe9HN8Zce+H9ch 3OLfs/2hxjyc4ndAxfja8zgM4ubwG2jb9nD2uduVXl7up+fB+I9ak+MpgRZLEa3cj0IopoRZlJIi poRb3HftoV7ybddemziYos36pdKjwIqovLGgiyabIx8DAAAAgFMN/zFtmj7Q4mnGWgCAZduHWbyP XM83a6ht6JAHWUwNqajdE7137NqUTSyAy9rMXQCLtgrGS99WROelYIro+dI8vtkAOHrr2t3cRQAA AABwVi9zFwCZj8JYvqi9FmQRKX1HEM1bex8AAAAAcGW+BWDv7m0aiMEwAJuUgFIxAC0dW9GyAeyR HeiyAZMwAk2aFFwCJo75fI4iRA54HsnyyXe2vqQ56f5eoRYAAADTFL3YG43d9RZaLp/TbHax3c6B B2XYRJbDLd7DLNJn2xyTAytyaEUZbLFe7wIwcshFPb8OWhgLXhBu8Q2rNWrcBUJE0Qnpy74y+CIe 338XvTx+Pr/a9q+rVbvQRrDEXmhFEWaRinY2+7ikMfR7+w4wpUCLMVHYRSugYtuG39VKlTgk0GLT z4d2edj/czO027qEtAuxiLajsqNQjF6IRdT3PrjQGwcAAACAWr6W9DC0p+TDcwDAuEWx3br52/uo QyvMog6e6AVZ1HPqeWNBFlG9rbEJ39mHP+/+1AUwaedHzIkCK8aez+g909FaH+A/ejx1Afxqx5xD nXcBAADg512fugAovBw5L3qmIWq941NwXLRmtB8AAAAAmLg3Adi7Y5WIYTiAwzncbnITXLxNnARX X0bwBX0DX8jNXe1dCc2Ff2oKylXv+yBYWntJJ+GI/YlaAAAA/C3lPwE/D+Phuxt2u9tDXKI0xS0+ j8ITeZSBijFSMR3vYxY5fpHPlcGLMpgx/TzMtuhBxS1+4NOO1hjHKabAw3h+U0Yk8pVN9Pu5IxH1 BFLabsf3u73voxYdkYRWaGJTxiqqsEUq19M5x1qDFlHAIh9HlYejisTwTBc5aFGELaJSRBS3qOe8 GsZ137IfUztMEcUt6qW3Xm7Qeuy50EWqPqM+BwAAAAC98vdOl8N4TWPUAgBgzkuaXgrRG4JovQQi Ck1EQYveuMVH4/56nmgt0TqB09sN4/7Ui2DV7mau1fsoWnssWnsyomu9c9jDAZyjp2HcnHoR/FtL /rb27Lf8jXkBAADgHOz3mfkOiDV5K45bexiifQyRuft7YhdL9hm0ohgAAAAAwIp8CcDe3d0kDIUB GIZekKjRQbxiA5dxAEdwI5nAFdzBFbzhgkT5SaH9/FpO1VjQ50kq/TvlwI2JqX1FLQAAAE5P9s8+ 2b77YxdaLJ4nVXW1XT+ELLY/Q8jifR+y2AUrDoGKOlhRRyvqsMVme7WaNMbVAYz2+Fr7/cuJW/zA 1fZzjMGKdqAis9s/TeIVh2s0j9XhiNnsYrv9tlwWf0HTEK/o3I7nV1XrvN5rn5nsiQDNKMUmZhFL Ec2qRLYeixExbnG9Xm7Kvq/bye5BGZ86G80phvWssZFFMY5FLLLXvgcvlOwHAAAAgPpvR/P18rJe 7kacCwBwHjYxi6ee49kDF7oe8JCFLPoiFUOWrmBG37H4GbLPBfy+h7EnwMm7LDgn3oNRErAYErqI 93lkYwD+g8exJ8Cf852QxZDxfmcDAABAufnYE4Dg9QtjhkYqstd4vOs+ifi+AAAAAMAZ+RCAvbvJ aRAIAzBMWXgEV0ZXXbowcesdPEI9l4fxWCbdKJQgwxdmgNhIG58nmXTozzDrlvKKWgAAAFyP9M9F b814nvvAfv94ikuk0rjEELSokjEEKrpIxTBvYxbjsMXXKHiRrtc+tsf9/Lf+b9zijKsle+ziE/18 /L7dKCBRagfE0MQwr+ub0+Pn8Ti7r2Jwot/LbhzN+Ald1HXY78r1L0jpjgBTlYc2aDEZsQjPx1JE Lm6RnvO2GXfLtv0ST1+V4xYxgJELVuS2VwpdVGGN+BwAAAAAlPTfIx2a8dGMh+22AgBckfdknvuB N3dTh34eb+qQhihieGJJvCKukVtv7qYRc2ELYBuvW2+Ai3cfjksxiij32pqYBQCdQ+U7Rv7O2tgF AAAAcD5PW28AgjVRi9J1DrlrBnIhi6XnmLomAQAAAAC4Et8CsHdHNwkDcQCHL8Q3jc7hm2M5hhu4 gTN0AndhAp94t0WOtse/7ZmgUP2+5GzTIrkSEhM4+xO1AAAAuC7RPwpFx56Xnqhp3tNmc7vfH4Ys ujUefdAiH88BihyxSId4RRpFK8Zhi/7xOXyRwxhTgYdzRB/+X9yiZj1PnRx/GM9x3AX4CkCU0Ypx a+A0IhFFJW72Pz92u2/P8bg9rW30MYvB/vHcxPWu3cmdALpoRXdtKY5VhKGLYn8uaNFt79txV/fa PbbjKZhCFLSYmsZUFGMpYjFXXEnFudL63xgAAAAAnFP+vOi1HW/teLjgXACA9WhSfzOI6EvdqZs6 5O1wRKGJKGhRG7eYe2x5Y4kocFGem7ou4Hd1QQs3x6ZGGbaILK2/mFuHEcUsyueJfq88Zv0G8Je9 XHoCcODvLQAAAPws391wbbbBsbk1DXNrAKJ1DEtrDqK1BzXzAQAAAABW4FMA9u4mpWEgAMDoWHe6 cefGbZeCuPUyBQ/g0TyCp3En9Armh5LpdGaSYDRE3oOBMkmTaTeFkuQTtQAAANiG+Cbe12Y8j71h v3/sAhOxOG7RjyFEcYpRnGIVbaQiHkPMon/dzw/Bi/h4QySjO9uCX8P5ZxG3+Ik2bjFEKrqZSqhi bhyiP3YIn8fjxOVkIhZnm6/O94uDFbvdRcBiqzGL2t3+XemhDVqEcsjiOrNfrhQxJW5x34yHact+ SU+fLCmNW6RLLwUrSsurhS5Ccox0DgAAAABS7X9Hd834aMbbymsBALajjVm8V7bnHtAw9rCHOcGK OWGLsVhG7sES6dprc8DfOay9ADbjNpSvpwiZuSlBitL1GGPvyYUxSrEMgP/iEDzMkGluFjyW31MA AABYx9PaC4DEV2G+dj3A1CBFui13TUTpfLkb5Ze+eR4AAAAA+GXfArB3B0cNAmEARgke1RY8O14s wRLswjrswzrSgXevVmAbCiY7rOu/QA4K6HszTAhZycbxFBc+UQsAAID1GLvAN/cwdaL9/rlp2/PP /Txk0a/rGIIW6XgKULwftxS5+B61GMIWh7hF+pnDfh63KN/35wIU4hanKiMWu+P8hjZAOv71eZOF I+LrzvPXUtTirRK12NUiFnm8Ij2Wx/KxaU7Z/laDFmPa7HNF1Yda5KIsTZwF42tFictuu5j3u7zp tttgClHQojaNWhRjKmIRPc698cHf+0MBAAAA4BTpu6T+ouKXbrtbdjoAwMY8Zfu1f+DOvZlDGZqI whPlfi1eEY2tnT+6WUQ0T2Ad+hjf/dKTYDOuK8fH4hXluDnrNWrnj8ZYpwH8J49LT4DNuJo5rhaS GhsPAAAA/A5RC9bkdeL1uWsAyvUMUeyiHNMEz8fWJpTHxmIaAAAAAMBKfAjA3v3kJAxEcQAGlm5c mrjBle49EYlXYu8VvIHncOuGjTcgGoc/LcNzphZjqOD3JS+UYVpe2DQp7fyEWgAAAPx9+YNID6nu uybP54+j6fRuHTCRy8MlNpUHWGzGVmEVuzCLXXhFHmyxXH60IRab+fvHa0IymhCNYxFucYgY/LB7 7rzpsfZ5OzKO4Rhfx1deFose7RTCKrav4yy0YhxqPWUy2Zt7DuIvP8nCLGIKRCnIok2GSPuVQi5q xyitQHCV6rpf27fx60NLMdwitl5bAKHWXtfCCaNwjDgGAAAAAM21olmq51TT4VoBAE7QU6rX7XZt sYW4XVvwoRQ0cWigxaree8wtLTTRtfhEn4UlgOOZDd0AJ+XiB/t0BVbEezkODbxwzwbwn8xGrjcy nN845zpvAwAAQH83qS6HbgIyb9l27T/+WgBFfN9130ApgOK78AsAAAAA4Ax8CsDeHeUkDAMAGB76 aPQEJHoQD+OL9/AG3sAreCJffOQMZMgopLVZu+IDk+X7ksalVCjExIRs+0UtAAAA/ofWi3lfp55o vX7sVqu7w3EashjO+YhBi9N8mBtCFmHE4xCuCHGL7TaNWwzH/WHE30njFvnrXjY2IW7RKlxLHgMR MVCx24W4RTpfbgTE50kf6/tw/LXZxNVJrGJ0rhalSNcNIYth30nQ4uY4tzS/giHpfPJzKnKRlyZu R9aX7jBwvx8PbZ/rcxcaGPkWxoIWpW2UohitN0PIP5ZU6U0s748GAAAAgCmn74Te9+Ojc1ExAHCe IWbxeTyuBS1KN24ojVqwomWMPcdULGMsajH1voD5vMy9Aa5K7WbqtXMqxk4Myh+rxStKrzE1D7Ak b3NvgEX4y/9ZAAAA4PKe5t4AZL7PWFuLW+TrarGK1vhFaQ0AAAAAcEV+BGDvjm0aBsIAjFoJA1BQ UadFILEAS9CjLMAy6SiYjRkoXAYb49j5fec4onAM70knEee4XKBAQhd/ohYAAACXrf/h4G01Hscm 73bvxWZzN7jej0s0YxijqGMVbcSiG/sQs9iHOfvvuEW7XhvJaCMacxK3GNfFEmIboAtd1HGL/uNm FIMIxvGax5+V+yzL82ITh8jGz3r92EXvufZ6HbZYrdeJ97Vsq/7PoTj+DcUKRCpkcShD1MGPxPO5 NVLFiLpUcXt6y1fVeI4vH7YU4xZx67lgRW57Y6GLIqwRrwEAAADwP9X/H7oumhtRv868FwBgecpq vE2Yl7uRQ/t1vGlDDEzESMWp6EVqboxl5AIWY/sELsdDNe7n3gSLcpO4lgpW5A8QDefGNaZ+31hE A+CveSnGw0IwxZS/lVPPRf4mRgUAAACc9jT3BiD4OHN+6mxA6mxBLlKROgMx5fWcSQAAAACAhfoS gL27x2kYBsMA7JYRwRnowMBpuAIjIzfsXXqODjQNVRzrc1xYTNPnkaJYzo++VpEiJY5foRYAAAD9 RR8DRX2frRPtdq9ps3k8t/Mgi2FsxxRocekf+4aQinGZ2nl4xfGYwmCL/LhL3/z883Uvwi0i0zdq eYDEPJRi2jaEW8xrbF2ym/N1cbUoiCIPs0hZwEVWa96XttvVBFos/Y5aYkMr5KJMmngI9q8lSjyd lufr/tu3NE6kUZYQBVrUyqiFYrRCLKL1tZMirOPCAQAAAKBleA40PL/an5b3zrUAALdpCMY6/LRr EzuU7dqEDlHQRBRe0Qq0aO27NJFE2ZdS/ML5H79xh7vx0bsAbk4ZavGXsRFL4y5+sw3gnnz1LoBV 6nVvdU8HAACAtpfeBUDhEPRFYwBq4wCW9m2NNSiPqQVYGIMAAAAAADfsWwD27ignYRiOA/DCBXg0 vsibPqo34Cg+eCsO4Bm8iSdREx5ws4yV0haMidvi9yX/sK1dVwIJySj8hFoAAABMV/yn7M9tPdY6 bzYvzWp1970dBxDE4RKh+gCLUN2xLqyiD7EYapcNs+jbh/N30bihprieRLhFEIdXDOEJuXyANECi OelzHIIxjN/p3hvLZfh9/Od2ezq9/tqlQIvM/iHEopvPYhEe+/2obc7iQIv01/7xq5OmQOSCLA7J EO2YuZCL0hi5xIirtq4vewq36eWberhFOvVSYEVperWgiyYZIz0GAAAAwP/R3RNaNyHQ4n7cqQAA M/XW1ut+uxZoUfqjhlJdGk7xmyCLXdI3137ueQHjehp7AszSzf6xtk4iXVdRXkR0un+urXSt9Fjt HIA5WTfuPTINPlMBAADg7zyMPQGIfLT1Xmirffefrh3I9a8FWeTOz53zk3ANAAAAAGCivgRg725u GobBMACn4Vih3DhUYhOGYAQODMIe3YVdWIJDVVFSUNTE+ZwfLk3o80hWrcRx3ShS1cr2K9QCAADg uqYu4H0d62i3eyw2m23n2G9IwqkVaJEGW5x6pR1ecTwWYbDFpXTDMZpQhvO5JuxiaW473CJeh34J uig69XjdeBx8EbXdbquf18/DYfaoN2noRTO+suwHWpRlt+0Kde/7SNugnqZDRCEXadLEXdA+lyhx X5dq2vie6vIQDCEKtMgNIxeKMRZikX9I+7cstd6HBwAAAIAhzX9EL3V5r0t11dEAAGt13vhhP6Fd bgOHpp5u1vCV1NOQirFwi6ht1N/QBhK5zwAsx3Phtwx/c55INmXexJRQiaF+ovkZab/R9eZqAP/N 27UHwE2a8/099zwAAAAwTsgpS/LRqufmAwwFV6THh8IuonkR0Xvk+s5dY84CAAAAACzctwDs3TFO wzAYBtCwdOACLEgdYUTiAHALVsSZOtMjcCdmJJbuJWnrxhjbiRBSmvKe9MuO08aO2qly8wm1AAAA OE3xH3df2rqvvXi1WjfL5c2uHwcihH4cZtG1cQhFF1bRHe9DK5pDmMU2G2YRzvdBFttv1w0hGv38 +3CLU/R/wy1Kz/8P/RB0kWZEjM0Q6AMaFovL3fHnZjNqhblgh4sovOJHaEU8FrczC7eohVmUngAQ h1DUgiyOyRDtHLmQi9I1cp/2VVvXw7fTTfmUTt/Uwy3SpZe+bKXl1YIumuQa6RgAAAAA5yv8BrRu 63XKhQAAs/fW1sehPxQEkXuAQ1y5oIk0iGJMoMVQ5cIsSmNNMpa7L2A6z1MvgNm6LYyPCbEI52t7 Muqbj/Jz2K8BnKvHth6mXgQMEHIBAAAAf+tu6gVA4v0X78ntKUj7uXNpW9uLELdN4RgAAAAAmIkv Adi7g5yEgTAAo6UmLkQTjyALD+BJPAI7z+G1vIm3cMWOBKm1dJzOTIGYlOp7SQN2QH6XmnE+UQsA AIDppP75J3XvZewbrVaP1WKx/HGvC0z0QYs+bNFGKXaDq4tXNOvbbTUIW/Tru0PYIgxk9J8bxzXE Lc71+7O1e4K6WETYU0iHLIbRhTA+ET+G6vr66/FjsxmdavD+KFgRxi0WwdrhXl0X4xCX6tyZc8WG schFXJq4Srw+dwrB3f66PW7e5lCEp8QIqaBFboxcFOPUAxPiwEWV+HrsPgAAAADz0/yt575qD6Be TzwLADBv7/vr7ft5KWiROsyhdOVCFKdEK+Lnuc8prY/9XMC0mt9rnqcegtm6KayV9k6k9lqE78nt 13BQNvCfvU49ALO1HH8JAAAAcKEeph4AIqdELUqRiVzMIlw7Zr+BoAUAAAAA/EGfArB3BzsJwwAY gIH4DsaL7uzJxJsXfRTja/kwPo0nE65eCHNjAltpt4HGbfh9SdOuK13JOAHrL9QCAABgfOoP+b4U 5b7rBVl2u6nDAItmXxVwUQ+hKMMqyuMqtKIqq1VeC7PYB1nUx1Zz5I15t+02Yw+3GKvfDt6oghTy 4Dh8tvwwrGLfjmUEHM4xn19s6vfl8oT1fbe3YRWxkIvFYnfcqCegHgzSOTZo1+9CmAIRC7LYJUMU 14uFXKTmiN3Vy6Jc9XuLD+HlZ+3hFuHS2zZA6BNwEf9Ax/sAAAAAOC/l9z5ZUd5mNn8FAH7msyiv LedTGzF0BVysg3YqpOKUQIv1LB5gEVt3qm/Ev57Dv/M89AKYtJsjxvYNuUjVx84JcE6eivI49CKY rOs/vl7bH4Fj/QAAAEDa3dALgMBHz3F9Aylipe1cOCY1NwAAAAAwYV8CsHcHqQkDURiAE7rpptCb 9Ao9Sne9Rm/UlTfovlsPUXDnykUdTEwcZzIjTUmE74PB8CLJEwQhvuQXagEAALCM1E0/qdp76UCb zVfTto9X9RAeMQ6w6EMnQi2EVMSrD68I+w+Hpgu06MMuhv3DMYaAjOtzT/e81nCLucMj5jZHf7lg inH9MnChPdeG16E+7XTZYbff1zZ3EUxxDq0Y7W/HARZdsMU49KI2KGJJc/WYS2wohVzESRMPiffn EiWejuu5rv+QtPOSaCEVaJFrIxeKEX/cmgco5G7AjK3/CwQAAADAlHB9J9ws/N2crk8BAPzF53H9 dNulf2pTwRallQqwKAValFbNAyVSfQLr9LZ0A9y11EOy43GTeN6iZtYiN5eRm+G4ZW4D4B59LN0A FPgdBgAAgP/xunQDENkmavFMQCnIYspUcEXNds05AAAAAICV+xWAvbvHaRgGwwCcriyMDAxlY2dH cBQkrtS952DiPoilB0AlVv8c90sakiFteR7JSmM7ydepUuX4FWoBAABwXvKXeN/r9tQ1ebFYVvP5 YyO4IsmDD3ZhFumYh1yksIp0fgiuSGEW632ARR5kkc89hGI07ztkHYlwi2HG1zermrkE6WS97Wu+ V34cgrE5boIv8v7yfqnGzfFrtYqrKEIssoFm8EMQZpGPHfWdqdmI0I1oR4Hd5zIFIgqy2CdD1M+P Qi7a7hHtOHBXt/t+ZT+Xj6+6wy3K0rs2O2ib07ZJQlXco+wDAAAA4PKl/3re6vZZt9tpSwEArkDa 7OFj+7nvpg59QiyiAIt87CeY1xZ6kV/fFZgRjZ/6XsD0UmCfsD7GuCnO+66RaFumko9FazD++hyA a/Bat5epi+BqREFQp+a3XTvkd3/IOAAAAPxnD1MXAJnvgdeV6we61jx0zc/7ov4oXMP6BAAAAAC4 QL8CsHfHOA3DABRA0zIiuALqwNBbsbFyBO5RicMxMHdja0hIojrGdgJIJCrvSZbtpnHtqlKl1skX agEAAPD35l7M+zg10G53X202118eH8ImwjIEUXQhFXXfr6N+GGwxDrpoj7fjhsEYcXhGWH/HGoMt WpcebjEOWeiuZ+u6dRUHWnTtcz0+Jzz3fOx06tpvx+OcyZzrvsShF6N+1P5cy3a72nCLn4ZZTI6b aKdSH1IhFleZdirQIuzfNOV23nr2VXeTjXgKqUCL3DRyoRjxclPhF6m3JZRbxDo/RAAAAADkDL/9 PDXlpRJoAQD83ntTDoXjpZs1hM+ZE3ARt1PhF3MCLeIxUjeAmAqxWPG/4/AvPSw9AS7Cvq9LeyHi PRfVRL+0/6I0Rm4epbEB1u556QlA5fsTAAAAlnK39AQg8Bq0c3sD5u4PmDo/F1KRep0puVAMAAAA AGClPgRg795xGgaiKICalGyAgiY1HT0SWQoF62EDKSgpWRENZcQegoWxM3kZf5As/NE50pOdzGT8 lCZSMs4VagEAADAf6Q26z2Xdd03e79+K7fbu5zwNN4hBEzHgogq2qKoOrkjDK6rHx6bSuXUoRhVs cWzWG2OfSLXePPebrC/c4vJe8DSs4jyA4RRuEY/tc87X/jgcurupX7vZ5MMfMuEWV0noRTzOzViB Fl3/FBBTIHJBFk0yRNlPLuSia434LwM3Zd0Oa/shXj60FMMtYuttgRW59roqfeuKlucAAAAAWJ76 u53Xsl6mbAQAWJX3sr5+z/t+ic0FW/w1zGKM6rtuW5/AfD1N3QCrcF0MC5YYMhbH+0Iw4liuD3s2 gCXblfU4dRMQ+GwFAACA/7GbugEIPvunXMgFVaRjbXPivK41cnsT7FUAAAAAgAX7FoC9u8lpEAgD MIxx48afdRPdu9ObeIOuvYXX8iZu3fcMVgjSDMM3CkSl4vMkNCOlZTAkTSr4iloAAAD8ruhmoWjd 41dvtNlc149ng/V5xKINT+yTIMW+F61I4xX9sEWVPNcGJ9qYxTCiEAU15hK3mG9e3CIKUZyE4Yro XvIoYtG9tjmHGq+7XbZ9NYhP9O5kT+MUaawiGw9+zvexsEN446f3E4yj6kMUsTgtjA+hjC4gUvXP gPN6uRh3bLf1chdMIQpalKZRimLkhxvFL6JfS6p0EMdxEgEAAADwmeY7nKuq/afT24XnAgCsx0u9 PH+Mo7++5nGIbjwmZPGWrZsStoiCGKV9jQ1bRMcFHIeHerlcehKswk1hfX5NRWmb0vUYpWszxry3 azKAtXhaegL8O2M+v0uvAQAAAL7X/dITgMyUqEUpMlEKW+TbRNtO2QcAAAAA8Ie9C8DeHeM0DENh AE4PgRgY6MzABRjgBlyBjQt1Y+AoHIgDsFQCh9LGfXWdFFGlKd8nWXVtJ3lDpA5N/Au1AAAAOA35 y77Pqd3WFi8Wr818fvPdz4MMYtBEDLhYBVus+l1wRQyz2A66aFs73oVidOdt+8d6fkS4xe8Nq2+W BVJ0YRR5SMVuKMNn4fhsJBy7tkw30HJ1sxSq2BxcmJztfg8BFjHc4pQCLY5y3tDP31CMKRClIItN MkSqrxRysTmunf9ZU9qdoHWZ2tWwsu/i5Zt6uEUsvbZBwr41+zZWaMI54hgAAAAA07AOtHhL7XHk WgCA8/GR2ktlvrRJQ/657g8JuIj9oQEXMbginqO0cURfiMUJ//sN/9bT2AVwNi4qc7XQib5Air6w i0OvCTA1D6ndj10EHMBvMAAAAPyt67ELgOB94Loh4RJ9zz3EYIvSeO3aAAAAAMCEfQnA3h2kNAxE YQCe4qYIuvIAduHaHknwgB5JcO1eaBeaGCuTyYtJazApfh9MM52k6bQEAuElv1ALAACAvxPdEBSN PQ7taLO5q17XnfEyxKIJnnjPAinywIqmNYEWKe33ebBFam1X7/cQhpF/R/Od7eXUhFucrm9+Tf5D FGQR32dehlt0PxOrj5n1+vKz/7bbBfPoBmAMrju8zwIuVnnYxQJCLeYI1uhLbBgKuSiTJur+RRZm 8Z0WUf/PqX2UXFXtetxvrRN47oMpRIEW5ZRWKZ5qvj7/udGBHP0tuaEHMQAAAACwLPV1m23VnlNz 3QkAYCpPVXv96g89ZCFaHhtmMUU75mESqRgDluk2Ce9jOjcjthkqAhpTixF9pm/dT+MA5+Jh7gnw L4ypO//NOdX5GAAAAE63nXsCUHgJxsr6gLJWoK+mINpPueyrQSj7UY2CugUAAAAAOGMfArB3xzgN w2AARk1Hlo4MSKgzGwfgDtyAhSN15xxMXKP3YOlCRUqbJv2xnQpU0lbvSRbBthIj1rSfqAUAAMD4 +h/6fWnGQ23zfP6aZrP77+tcXKKbb2MW/bDFZq0LV6RduGJ9vQ5cbCIX3f52X3uPfjDjP98ZEbf4 vfL58uGKUuhifz5l98bYxXS6+Wz8x3KZeeqAXsAid76ryaQLSMS4xQhi/ONozwnX/W8BiBWIXMhi V4bYxiv2RpjbC1ukn/+7m2bcHnbsx/j4VI9bxKPXyiulPaXQRQr3iHMAAAAAnK42aPHejOnIZwEA LsuiGW/b69qXNMS5Q0IWqzAX1z7TcLRiFX7mnnVo2GLo7wLG9TT2Abgod+H30vsTufXcKz61sEUt flG7F8C5mTXjeexDcDGuj3DPobgUAAAA8HeiFpySxcD60HsBpWhFLXqRi1mU1mpn8M4CAAAAAJyZ LwHYu5uUhoEwAMNTdNGN4hHswoW3cunSI3gP7+RJ3LsRauIQm0y+/BAkreF5YNow0XbaCoKMeUUt AAAA1hH9Y1A09zz1QIfDQ3W7783n6EMqxmkuhyuOvxGLeuSARY5ZNGGLftziGD5efs7u/RrELZbL 6xtrA6TeuW7EYt71/0+diV3a729/jr/qIsocQ1GI9nw7XFHfN3GL9tzK1ohZTK4hOI6qD72QRTWu q/VfBZGLTtSijnak7k/ITTXu5r32x5Q3apZLiIIWZfxiV3x9tMz2yx27SEIqzpVvWen8HywAAAAA jfpvNU/VeE+CFgDA3/qsxtvI+amLNMwZ7UhFGawoIxdDcYsychGFLKJ1R2svj4HL8XLuBbApSy+U PRakGNqPEX0/wBa9nnsBbEoZoFqL39UAAACw3H2yf43L8tE6nhOPWBqkGNp3EMUv5rB/AQAAAAD+ oW8B2LtjnIZhKAzAQR04AmIiKyywcxg2jsXG7ZhYupKEukmf7CRFCJfo+yTLkfsSP6lDhqb5hVoA AADUNf3T72s3HpdOaNuHYc6FS4zrfRhFcxjjcf9ZCq74HmOYxTTEItWnurQ2Dcyo/XyIcIufS/0N IQUhtGJci0ENp1kBpxkT0+ucnrvbXQ/z536/vsHp/iGsIhdeMa27qhBsUSPQIvfNpOOYApELsjgm QxTCLIrBFmG/3k03bte1/Ry3b+bDLWLrc4kspZpS0EUTrhHXAAAAALgsKdDirXIfAMA2vTfjSx6W XvBQehHDOWEWvzHWBGnEPi/4V2zg4Kkbd7WbYHPuD/PcMxFzz1XEmmZmzh3nrlPaf6lPgNrabrzU boLN+at7X2kf914AAAA4T1u7AQg+lkuO5sItYl3u2YM14Re583M1AAAAAMA/9CUAe3dw0zAMBmDU ERwQXNiEFdiFBRiBTZiiE5QzV8bg0iuChqSq8+PEDVJJi96TrJLUAicXpNbRJ2oBAABwfGMP4kYP tV+0Wr2kprn6cb4LPKQw9ue6cEUerfjsIxZdzGIXttiFLoZz93GMUkhj6XiDuMXvdevLQhDFVsB4 6CJGL/aH+ZzL79f3zWbe4sLfiYGLphC4GBz/gfy+nIqxYkMpcnGRhnWJeFyMWrTXnNJg3GzH7WH3 oS3y3IXljAUtYvyiCfNLy8wvtxS/KN2WnAc2AQAAAE5T+/nMcxK0AACO43U71v3PpW93x85NjVJ8 ohS2+Ej1aEUtZFELXMy5LmB5j0svgH/pOh2+R6L2Xv5+bS9GKW4xFcoAOAdPSy8Aev5/AgAAwHLu l14ABG8z59f2QcR5MWQR9yPUwhVTexcAAAAAgDPzJQB7d4/bIAyGAdg9RYdKFXPH7L1Db9CD9XYd umbMGhBybYwdSIcC0fNIFuTjJ1+SAQmZvEItAAAAtpM/lDsEWpyWDui6t0lwxSAPTYhhFnkQRVwf tqXgivAbWhGDLVKYRciOT+cbwzFSbW+EW6xXhjGMvU1DKab7pHCL8fhUW34ubrz18HM+/7XZ2es8 4OKpWP5XqMUewixqT/7H9TIFYpYi0fdfS4ZojUmwRZj/8s/9eFnX9ntoB1PUwi3K1luBFeXHXRr5 VxcaNQAAAAC2FwMtPrduBAB4SJd+fN3YXvuDhrhcO/JAilo4RSvUohVk0arX+lyqAfvzsXUDPKTX Rr02Z6K2rTVXo9x/aT5G7fwAR9IF9yk5pjXX3TUBWK7fAAAAMOq2bgAK35VaLViiNVfg1r73zE24 5z0AAAAAgIO6CsDe3eM0DINhAHbEwgKIgZ2VjSOxcgsu1ZmFM8GEQqI0res6joUUJYXnkT7lp67r VJUita5foRYAAADLqv1Tz+tcR7vdR2ia67PzQ5hDSOp4bgiuaA8hFn0NIRZDmMUYbDEGXcTtxjCL uL9+3kgarLElwi1qnQdS5Mc2/RE+Db3It2nbYVsdalETTBG3yQRaLBk4kQaCbNHUCgGHtIj+GkI+ vOIq5NMmTkIt9s+P66ar27r35amr56jLUqBFGn7RJO1zw4wvd2pBhbRdzGIKAAAAANvQfx9z39V7 sFAcALCcPtDic78/t7BCblGG8TgNnZgKsxjrO3OutkoBGlPj3Myv1EDRS1d3aw+CP+mh8Fhp3sTc fjovI2SOa14T4FK8rT0A/qXf3jfNhQQAAIDlPK49AIh8heO8h1RprkAuhGIu3CLdToVY5OYy5PoE AAAAAC7QjwDs3TFOhEAAQFHwBBY2xobaxgNYeAVP4Ym290R6AhvbPYSRCQsMIwNsjIL4XjLZEQZ3 rEzMuF/UAgAAYB3xP/A+1eNuavHh8FxU1W0XHUhf23mIOYQQRTP6ebjXhiuaoEUfs2i/bq4168P1 5rk4bPE1yrCtSMOQuMW8vguRhhrKbn/5xsQwIJE+32qjFm/HY34TY29wul6m8YrhxgejjAMXP2CL MYvcpwLEEYqu+lDv/yIOWtTzsTJEbgzCFsn7Bdf1uFm27fsiH6YYi1ukAYxcsKKcWJMLXRTJ90iv AQAAAPD7wt9mLosmaPGw8l4AgP16rcfLaZ77kIWxa1PjI3kdi1wsjVbMhSzOCVzM/VzANjyuvQF2 62rBmvQMRnovtyb3zJI1zmYAf0lViO+yH1O/g5cEqgAAAOC/c6aNLXmP5t85IzAVq8iFLeL7555T mHsGAAAAANioTwHYu4PUBoEwDKATuikUeoZkUShd9Sa9RA/Se/R22WfdpbVY6zjOjEJTos17MKjj RP+EgCCjn1ALAACAv1N7WDf2Onegw+EhNM1tJlSimQRO9H19sMUQWDEEWYzDLPrAi/G4Icyiic7b ROcOo/U1hDTkCLco6Z4764Iaps+eD/3Ddt83DsEYf74UjnE8nWbK2RUCMsIkuCKuZxf3x+3M1hho UTMJu4jDLMI4pCJNlrjJ9E1CLb6PF7e7tt0v+52eQhfkk5aUC7RIS9wl43Nl/nztpIXCculLE7b1 JwAAAADYpq97MPvQBVpUw6ABAH7ho23vlf2lFzLMhVqkoROlwIolIRel49XCK2ovlUjXgXXZt+3l 0kXwbz0m2+lciSWBFLV9pbkatbG1cwOs0dulC+DqzV0zS3Mhz32tde0GAADg2j1fugBIHBeMSecN pPMNcuu5felybu5CLvwCAAAAANi4TwHYu3ukhIEAAKOb1gtY2KS2s/cQ3sCDcQCP4xnsqa2QyBpx dpcNLgwQhnlvJpOQ3y2oYOETtQAAALi89EdCMWjxtO/kxeIt9P3j3+ttJGA3KjH8hizGmEXcF2MV 2/VqlYYshixkMcYsxmvj/jFokYYt2gIM4hbHmT9uMa7TcEX6Nh2GMnYRsuN5jCKPXqzX4/pjuUwe 2eXrdDTpvZLzujJYUQldZNsn0p3hnqe2E7BItn9KD5vx18IU5bGWJQtbFM+L7jfLQ9uwn8N0mKIW t6g1OWp/hNDtOWcqdBGKe5T7AAAAALiM+HlM/NHvexC0AADOKwYtPn+3p76pbfmzhVpwotxO932F /2MWrZGLQ8IWwPV7mXsA3Ly7I66pxSpqx0Koz7E4dN6FeRrAteo3y+vcg4ADCFkAAADA+fRzDwAK LVGLrX2RiamYRXpsav5EyznmLwAAAADAjfgWgL07yEkYCAMwOrJyY3RNYjyCXsudR/BmnEAv4hWM WIITOj/DtCVqEd9LGso4lCk2YVP9RC0AAAB+xtg/1H0cOtByeZvW68tiLEcsYnAij+WwxWbbBivy fgoxi/g8zy1DGdvgwrp4/xZxi+P8/udWj1iUIYfd/i5usf+zPL47Xum9u9COikPE1/QDF/05i0Ux /h0hilOPWQxZ9H6Pe6GLFOIWab8qUatNFFGLzfFTefVcddvNuM9tU+q5ryyhFrSI8YuLML+2zHy6 h+IX8TEu+tBJ/O2LAgAAAOB05aDFqtuuZ14LAHDeXrvt5Wu/9Y8W4tiY7aOyPzVaMRSymBK4GDov 4HQ8zb0Azt5dqt8f0deKV8Q56cBjLXIRx1vraEUyAObyPPcCOGvHhKdapt772PreH/N6AAAA+G8e 5l4ABG8j540NUrTuQ3CvAgAAAACQPgVg745xGoYBAIpa5ApIDEiQmYEbIHETRi7UjYFrcROWDsSI IMdxnKhVk1LekyyI60KomMD1F7UAAABYV/qm3NduPNYW73bvoW0ffq/z4EEfsOjjE33MIs7HWEW8 jh/3+2G4YhyyCIMxjFkcHlsQtzjM2q9bHrGYagIM14TJgEX6dePvV9M039cxbFFak1wUHxvFJfrr PGLxM/5j0CJ/V+FVErPIKxCjuW5tqQwxNQZhixBGJw3cdON22W0/hekwRSluUWpylIIV+Y87N9KX LkzMAQAAAHA68W8wz0HQAgA4vc9uvFUezw9aWBqzyKMTS6MVtXX5+tqBEOl/l2tzwHmKhx/db30T XLzrwtwxB1eX9muUnrtkD8ZcbANgS203Xra+CS7a3RHPFYMCAACA9YlacG4+CnPpvoIQ6nsG5vYT 1MIVSz5f8j0AAAAAgD/kSwD27lgnYSAO4HDLZOLSyZ3BwbdicvYJfSJnTUhMpZZK75+7FggEGr8v uVBoLQdx0mt/ohYAAACXl7s4KPfa69yJ1uvnqm0fktf64EGbRA+GEMUQuejCFnH0IYsqhC1i3OIQ s0jDFm3y/qcStzjPNb+3vv+QXhOePq8LsYvDGOZWZ0MSh3M1zdPv49d2OzGfwjV1o4BFHbb/xmqV HjOKXZwq/1mWZTz/UrEhF6nIVSWmYhf1/r3ib8bjbjTHfYcvVb+IM04hF7SI8Ys6HJ+b3vBxS/GL 3P6xqZspAAAAAHAZ3d9aNrvxXglaAADX1wUtPvfbpf/E5m7EEPfnghNxOwYsvqv5oMVcDOPUsAWw DG+3ngD/Qi5q0Zm6Gfbc2otjj7P+Aliyza0nAAAAAMBdEbXgnnyc+XO5dQdzz+Njaa1C6RxxPwAA AACwUD8CsHf/OAlDAQCHGwcGJjfjJLODF/AS3sJDkbB6Gr2MCwODjVro+0tLGijh+5IXChT6Spig 7U/UAgAA4Hz6J+u+t+OltvJ6/dGsVs/7+3HcoAtYpDGLv1hFd7vbheGKNGTRBCOMWUwbVhC3OM30 n1v5XPJD1OHwdU3jFs1+3W5+4XuEW1sslr+339vtwOmVAxf9sEU8pghaXLO73ucTXxkgrkAkj7Wv qwUskphFtBxfseChHY/Dpv3alMMUubhFrsmRuxhCvLu10Ze7oMJ1fzEAAAAA5qsLWmwuPA8A4DZ8 tePzfzn372vpsSEjF5/IxSlq4YpcyGLMGLNfwLy8XXoC3ISnynOlYyeGLB8LVwzZBsBc3TfiUwAA AACEar+3w7n1oxa1Yx5q68TP1SIVte2Mcew4BwAAAABgxn4EYO8OUhoGwgCMBrqo6EJwWfAMXsGj uPJSXswzuOzGZUwI2Mz0n2RSimnwPRikcdoMaSGbaT9RCwAAgOuKvnAbHXufe6HD4blp27vk2BA3 aJPAQRy2aIOQRTPxuP0NYozPMZynTc5/DeIWl7nudTsFK05/Tx/VNGKRxi3SyEU0N5233w9Ri6/j ccHyRusahyrG8YpgfpNHL6pPt+3vyk+tv/SLAnkZIipL7IJjZ0WJ/j1pmmQ8dOOp7pr25Z6XYEm7 phy3yJddimKU6y3nl2MucpHb9gcGAAAAYH2CFgDAX/ruxsfE/6MfYVg6poIVtUGLUgyjJmIxdQy4 XW/deFx7EfwL9xVz8j0VpS0npaBFzb4LcQtgS/qghfs0t+CS++WSvY/uxwAAAFDnde0FQObzgufk ew5KewyiuMXcnopobvR6AAAAAMCG/QjA3r3rJAwFABiuHZxdnFxwMw4+gs/i5nv7AG64mdgiyrn2 Ikq1fl/ScIDegCYkXPqLWgAAAJxG+Kfdx266G1tgs7n9HKchg4+ARR6zaKIpDVfkIYt4/n59h7DF z8cnxC2+5ruftzhokUcs6v9Fj2+LwwqHcdue7y6ft9vj9zOIVYTXd+O2zYIbU9b5l4MWWWAkvK+J X7G0ApHd1q2nFq8oxiyScXpmgstuupr2MO6bcpjirMmDFuGm090pHci1eaaELMoHNAAAAADH6j9r 6U8IJ2gBAJxKH7R42Y9r37SWohDp/WmgojROwxSv+6kWtSgtn26rdNIHEQtYh4eld4B/4ya5XotW lAyd/Lr2G4ux+MXY+gGWdtG8f4YJv93Y++jQ+/2cZeduFwAAANboeukdgMTTjHmHIhOlgEU4rkUw pm7DbxkAAAAAYEXeBGDvDnISBqIwALfBhTFRr+ANjCfwNF7HK3gKbuBWL2LiiiUJtmKl076hBTQV +b5kwmQ67bySJiTQ8gu1AAAA+DnbHuBtexg60Hz+XJTleTK2DjJYJWEGcbDFqhdc0YRZLJd164dd NIEY7TXW66yS9X+LcIv9HFrWJgwhF2JRFOnz5OnlHM/f7NPUV5Znn6/vi8WuBX6/doMnylaYRbuf 7Dd4+ON+pm6n8I6gHyVDRMkSs2CslyhRv/9FkbTLql2Nq7H+44S7oKRZpx+VWGbmt7c3p5sLv4i2 t+VO4rgvIAAAAIBp1N+pPFXtcepCAICT8Vq1l69+9AtrbmxMywVbdMMqovFofi7YYlvb5byAv+Wm avdTF8FJudhjn233VQyFVeTGxqwHMLU60OJ66iIg49DP1+g+SQAAAGDY7dQFQMfbyHlj7i0Yuh9h 7Lzc8QEAAACAf+JDAPbuGKdhGAoDsNsTsCIGOnfiRjBxom4M3I2RsQsjNFQtzovthkolRP0+yVIa u8lzFalS5OQXagEAAHB5+cM/z+nEwqXN5jWtVuvvkIlODC44BFgMwyxSr8Xgin2Yxecx3KLrz8d3 x/sJtpgmaEK4xe+d+5vFQIvCiGPfohcqcc6zcPvbD+/bba2YfhBF/Fwan4/L61suiyEY/a+3++eg Ob+wHUMs8hSIwb7dcWvhFcUwi7Adn3S83bW7cVNap3IwxSINAy3yU8dy4pTjdFstV7rg533RAAAA AEzvEGjxOHUhAMDV+Ni1l0b/mJcvlEIsWsEWrdCKWqsFY4x5GURrH/C/PU1dAFfnPg3XSNRecn1q vUQr2KK25qIUkFHrr50X4C/cpH2oBcyN/04AAAC4rIepC4DgrbAvX1uQ0nD9QCuwojSutmahdo44 tlYHAAAAADBTXwKwd8c6EcIAAIYht5g46GDifIMv4dO4+eaut7l5eAQIBdrCERXU70saKTRaXI/j F7UAAAD4Grkv74Ze537R8fhUVNXN4FwTLqgG8YJ42KIahCymcYvhvIlbhDGLKogkVIO//5PELa63 7n9WBn2IPvSQa0qE68PvmPfzcG0zP5+bn2+n05Xb66Ma3Tw8nqxtr5eZG/gLMYu19xB728C4DNGN cVniEDk3KUrUeyuKwbi9jPtl+32+jMfIlg6j4zJyvkysD693t5uKX8Suh3L1FwAAAADmCVoAAFuo gxbv7XHq09TcSxq687mIRS5c8dGOXMgiFcuIvRgitd/9fYANLPGy9Qb4dx4S59c+E5F6/mLpMcBe 1UGLu603ASt51hEAAAC+j6gFexILWlwjFraIxStia4rIfEnIYu75DAAAAADgF/gUgL27x2kYBgMw nHZkYmFioDMDZ+AS3Kw7l2HlLj0CSYsr2/nyU6AkiOeRLKXBTZ2CVAkSXlELAACA68pv3O2CFk9j k/f712a3ezw/riMFKWDRj1k0xShDFl28ounFLlLIIh2je04KI6wlKrGWdUTWGLboXPae5UGKcl9+ /1oeu4gCFvnjMnZxmn+OWhwOE8vJwxpVvCKFKrJoxSbbd5yy3ZbP6R3+b9+Td8n6o+9o2q4rEPm+ 43b7OkPxijBmUW0XPx3tse7acT9v7S9NHKbYNP2gRf7S9XLqU65Pd2xEb6N/rgAAAADwPYIWAMAS 3trx/rkd/QV1aF806uhEFLao4xb1/ChoEQUu5o5LzgtYn+d2PCy9CP6doahFEl0TUV9/MXSdxdi8 oWOP7QdYym1zilrAb7q50nF9zgIAAMDP6X5vJITKmuRRi7HrH6bmzP1aFLP4SqRiak0AAAAAwMp9 CMDeHeQkDERhAMawcaNHMGHhgh1HcuXNPJYHIOEOtQ2pTh9vCgWFEr8vmWTSmbavQMJmOr9QCwAA gMuNvdBbej92odXqddE0j4Nj+5CCZhBUkAdbNAfBFcNwi8Owi35ef48+7KJcBzKH7Ia5hlvsv4MZ FrY4L9yiD6wogyV+ghSy98yH47XQi6bZ9z+32+KWIbSirKYMtsjCEIpzuyCLvn0fC+cNn+M+/Vb9 td0EYjJEliyxTI4dJEp0n3XoP7Xt+bTy1m3bJCUtQz8r8aEyvxzvH3ds84RTQi6i+/5xAQAAAPwt gRYAwC3s2vYxMp5tvjC1ZeEUU1sMxsgCMbIwi+wZYh+Yt7dbF8C/tB4ZG1sjEfu1ucfWT5x7HsA1 dYEWNifk2l5OnJf9DwMAAADXsbl1ARDsJsytrY2Ic2phFfH87NrxGrU5AAAAAMCd+xKAvTvWSRgI ADB8MjLpaFyYHXwBFx/Bt3D1YdgceCzfwZHBCRNLQvF6vWtPUlPU70su0NLQa0PSgcIvagEAAPBz 4h8PPTXjbmjj9XoTVqvb43IaJGgDFv2YReiMNFyx24VexCIebcyijSB87WfakzEFcYvvqzln5XBF LnbRf4zeqRukSH4797bdnh5niGMVmXDFcf1iEa36GzGLU4+h9I8Cbf0hrkD01jX7LMUrsjGLkIQt orjF3nWzfFN3HPchH6a4CP2gRbzrdDq5D3Npm5qQRenPGgAAAAAouwqCFgDAPF6a8X54Xvq2NBeF SF8filiMBS0+DmMsaDEWzyjNe2juwHm7bMbj3JPgX1pWbJO73yJ+LX2eexwKZOSWAc7F/hr9PPck oNLQ9XSKa63rNQAAAHQ9zD0BSLxO8B419ybktqkJV4zdkwEAAAAA/FKfArB3LzkNw1AUQPuZIDFg B6gTxmyLNTJhGyyiS0AKRCGq8/qcRKKkv3OkKIlt2W4bKRO7V6gFAADA32SbdrKyt6mOdruXVdM8 DMq6QIJmEEqQB1s0R8EVw3CL47CLPhCjHKMbpwljzfsilnSJc2pdZ7jFYU95GW4xDFM47DcfhlYM 64777NqV4361D2JsHcMpYl0W7NDfl+EW/XmzuZlAi3/pN7mOyRD9EZMltklZLeSi7Ptx1e34naFN 9nlNprQN1+ukfF1pX9b3U6qFX2T1pdqPct0PGwAAAMDptYEWHyuBFgDA8t5/js/f66lQiLIsO2Lo RBZsEcMtsj5q7ecGW8Q/iZj7uYDL1AZaPJ17Etyl53A/FloRja2Ri+ey77Hwi6n+AZbWBlp4R3NJ pt6Pc9/jpxgLAAAA7t3u3BOAYJ+UZcEStXUGtbZj6xRq4Ra19QrWMQAAAADADfoWgL07WE0YBgAw nD6BF2GHXeZ1DPYCe5hdd9v7+AAe93iCOFhbKUtjkulw1M7vg7Awa0xB8NL2F7UAAAD4G/FNuW/t eKodvF5vwmr12M9z8YEhYHEcswijkYYr9vs0ZDE+vlvvO2xRDh+UgwjTucY9DeYStzj0IHKxivE9 5ccBi/Exh4BECOk9bcP7uu/qYrHs59vdrhhrOCXi0EQBiyYaIf7bRS3akQYy5uRSQYvc0wKGeVqB iP/Xz9s91OIVaS0it0b8mXftevennddLyIcpmnActGjC+DRKH58el/sy/xSyuOQNoAAAAAD/2RC0 eJ56IwDAzeke2vBReT19WMM5MYlS2CIdn5XX0phFKZJRekhE7hzSOXD9XqfeADdtecaxuRDFb2IV 515j4ZoMYCrvU28AIpf8PSz9TgMAAACne5h6AxDZhnzUolO7fqB2DUJujdo1FrW1a3ENAAAAAGDm vgRg725yGgTCAAxTuzF1UTcuujDxBh7Bq7jwVp7OS7hxgVREZ4ZhoI0NEJ8nIaX0h2/RpItOeUUt AAAAzpf7c0/u2MvYGx0O91VdX0fHujBC2EbIhy3qKFxxDFvEMYt+7KILYrSBgzoIHdTB+ftzLjEk scSZOuuIW/Sv5x9GLPqxiypzGx+Lgwzt/m63/7r9OH7wThWELH5nqboqRxS0uNpu49eszE+k49Ln yeynZYhuS8sS2+RYen/oCgY3zXY7bbxj4ecxM1J62k3m+Gbg+eHj3UhjF1sYi1yk1vmhAwAAAPhb ghYAwJxem+39e3/oh9pcFCJ9PI1YDAUpzglbhGGMKRGLdO7S7MDyPTTb09xD8K/dVf21EFNCFKV1 cqU1F0Pvm3vO2OIkgEt6brb93ENAwVzfib6LAQAAoOX3HZbkLdgfW19QkotVlIIW6WtL6y9K4YtT ZgQAAAAAFuZTAPbuGKdBKADAMO3SxN3JxKSrg/EC3sXNa3iI7t7Dkzh7BoduSKnI4/XxoFYD2u9L SF/ogwLpCPyiFgAAAD8vfMD2sVpuc5M3m+divb6px2H/oIkO7AMWZSJmUXSWJlzRhC66YYvD+bv9 tWGL4+IQcwxJzPGYGvOMW+z/pm3YohuuaMfd2EUYXUiP09uvVhf1+vftdty1aIIVX/sK1qWiD7vf Xy7T8/+I34pZ5J7+jysQ4bp6vAuFFOnYRV2NCL6P95eqQlxW86/Gned9kQ5TLIrDoMWi6J5Grq0R n25uSV3G3EsdAAAAAM6doAUAMKWXann9HB/7woQwYJGLTuTiFkNzy8S2Q2GLvpdGDJ0XMF8PUx8A Z++6Z33fPRBjwxRDEQr3WwBz9zT1AcAJcvEpAAAA4HR3Ux8ARN5GzCmjcXzvQWqc+i7+/E78AgAA AAD4Rz4EYO8OVhqG4TgAr8yDCIJv4C4efKtdfTpfbHjaVerqVpuENI1D106/DwJpUpb/oGOXND+h FgAAAOepeQGou36Z+qDN5mnVtrfRWHjo/xBsscoEW7RRcEUXbBGHWQxhF0O4RRhm0QZhEPGaNZYY JLHEmnrLDLfohAEXw3UcshC/e16ay/081uvjM/62359ZYrxucwqsaE5hFp+tH+v7VyIMB7noupl+ mgzxFV6Rub4pBF6MnVpwf2gPdeU9r46bPdOS1km/yYw3I/eH831JpQMWakIuUtfz4AEAAAD8LIEW AMCcdof2WpifOmghd2DDWNBFLtCia++nlo6PBWGk/VJNue+Q9oHrsJ27AP69u4n50p64qc1Ctfsx atYEuKTtoT3OXQT8kqn/Wf/DAAAAMG0zdwGQ2H3j3lLIxFiYRTg3FlZRc489DQAAAADwB30IwN4d 4zQMA1AATdUzMDF1BBZ2Fo7GPXIAzsXK2IEV2jShtuMYR6CkwHuSG8e2LKcd6/gLtQAAAPhZ4Yu4 x0CLu9Lgtn1udrvbrh5mHQzBDHHwxHsUZnGqn8oQXDH0xcEW8dghHOMcbPH9IIhLzGkQblHnHKaQ f588DlwYv5uehjGEY+O+bff5ut/PXeB47j684rMtuB9dL9xSYRbpL5eGWIQpEGFbV0/DK473fds2 6U/ny51QcHUYf1333A9NPphi04wDLTZN/BilbI30cUsl9zXmDmkAAAAA+M8EWgAAa2sP5a2vT/0R WzpoYWhPwyy+CrKYU8J5akIs0nWX1g78Do+NA7NZ302hb2qfRK5e6iup2YsBsLSntRcACxJyAQAA APPdr70ASLxUjqsNpJjauzB3f0M6NwAAAADwB30IwN4d5DQMA1EYdgML1AqJDYsukDhaF5ySS7CD XqArkHqDGJvG8niYxAGkJg3/J1kNk1APpBUomLzrqRsAAAAAgAtk/cOOVXuqPdF2++C8vylqMuxA h06UYRa+CK6IwRZlmEUOu8jhFjLMwovgh3LO30ifN7csgbn2FaVzfa5gAy3Oe2phZX5/vP8ecGHd 6z/Xh+Y57T8cj2ObK0+aEZ7x9bypo7i/aYqQi7R/rqY670UPLr/7ddBF4/LKspQc4UPPrSuTI/Tw 4lG+YtLHt2HchXGotxcTf+KNEF/UFFeqrdaop5oXdb2QLn25enj1KMmX1MrZi+v66gAAAAAAAEtE oAWA/+BNbH+E8e7K68Bpv3Vt+FVs/+TacTz2MYx15bhNd5y2Nur33QCW5jmMfbddC4WQNR1gMRQ6 YYVTtD3HW/v6AjJqN4AYc4MJAJdjN3UDgKv/fhnp9RNjAyzk0pNaQIacQ9b5+Qbg3HaO0ClMbzN1 AwAAAAAAYBChFpibvVHTQRN/CZ0YWrOgt/vWNfA3HwAAAAAAAGChPgVg7/5tGoihOI4/wwI0UKGI tEGswAyMwRgZIj0jMAcSDROgSJRpoUoUbN05PN7Zd1b44wt8P5Jln218TlCg8eVHqAUAAAAAfB/9 QO6tL1d9kxeLO5lOZypYovE5yGK7q2MYhQ2zWK91YMXWBFvoEAxp19DBFtK5/1eNNURirPsK6oZb OJMd4VS7qcP2Uv0ffa5dp7t/HZwRLFerzDYKX7sOszDBFzrQYsyqhZhIN8AifvuAToGI/bEvjB+3 73m41ikSu1QJP37kf9F6HZ0q4cw9T/38c1+/DP/xufblKXFbJ91Ai7hdna8R+/QWnJqn34bUvDgu qk+HXohpAwAAAAAA/CcEWgA4ZDGc4s2XZdsX6te2HYIqSh+2LnnQe5/x58I1HgbWzwkBF2fq+jLT nu25PvAbwmf5vmfcfnnCUHDEUJCF7Q9lo4odSwVhlAZa5F6DbQM4DCe+3NTeBOBNzLU9G9F3BiJ1 4MWesciFV+R+HgBqm9feACDN/+fHH75HKpgqFUJlz0cCAAAAAACRi9obAJTMQ9qD+s5I2DmSqXPn F0rXBAAAAAAAAPAHvAvA3t2kNAyEARie6EYQcdOuzUZw4cYbufROPZM7z+DCTQ9Q2phpZsiXr/MX sGQi7wNDkzQmA7EgmPQlagEAAAAA86QezpXrH7kDte2z6bq7ybZOfMG7jk4M0Qoj4hbjsPGKw2EM XByPxg0Zt+gmYYsxZjE951+pNSJR67ys5eMWjTj/+Ey5XfW/L8MuTWCfcV2/Z19Pp2H5e7/Pz+Qc whAXyocspvUNWdeYLDdu1HiRlwpapIRiF7IM4clyxE1mdOYyaCGfdnxwo8BLP9768alOcStOo+MW ssnhp+G3h26g00EL/WCmvmihyIXGQ50AAAAAAOC/I2gBYA1smMJHK3zEwg+pJF4xN2hRGsSYu08J fZzYPyd+3PC+Mse1AYytW351r20/7t32beBngGvbmeFzbuU+j6n3QzGLWOCiJFwRe78kYqHnnZo7 gPWwQYvHpScBOBtz+TdxTChaEYtVpL4gOxW2CN1joWMbAHAN7/14WnoSwELqu5kVAAAAAIB6cY8c aiKjFrF7DUrvNwg9b6u3p84zRyyKAQAAAAAAAGBlfgVg745xGobBMAw7ZUPMSGyd4QZMHIWVW3CI 7tyDS7B2LRISQyfmKsEmcfznj50ooSUWfR/JiuO4sdsIioSTj1ALAAAAADgOefPtky13Q503mxez Xt/+1GWQRDfIomq3Icii6gRVyBALd8zvHw5lG2whwy9kmIUsp5RriESu83L+Ntwifo95GDsEVfiw inp68XvNu1MOO1VV13f7fbezT8qQF8TWfSiFTg8I8wjnaAMsZH21yu7i5hBoEQuw8KkNMgXCt180 16Cw10QnSpR63/ZdNf1K00+VKNSYN7b/l91+jP8SurflLTJsYfqBFqV4O35o2VaKt+/b5MeQevBC LMhCf5wspAMAAAAAAOeCQAsAOfGhFe+mfjDvrimufc5D4ue0/TbwYqx9zNTXzf2HxWdTnFQAxpUJ QRdue90UV7+cOS6Q8mrLtqlP+dnVYRVymwq4GAqtSAVf6PNOCbg45oMhAOThcekJAIILI/MLeFLr HgrTXR9hTPzvyKFgC7n+IvWa2Lgm0sb3H4BTeF56AkDE1GCnQtX1/tRzpI7zXQwAAAAAOFcPS08A ULbjXXr0OoTUuqdYv9j+0DE9LgAAAAAAAIB/5lsA9u4YKWEgCuP4MjaWnkBDYaV38Cp2Hs9r2FlY WOuM1lR2MeZJNry87GY3A7oR/7+ZByQLZAcYCti8j1ALAAAAAMg3dZKt3r5LPVFVXbaXp4N9jWrs bkMnJLBCQikkpGK7vatduMX4dl1/9oEXOtjCh2To9SCEW5SdR8jvh1v461V/XB9kocd04MUwZGIV vI/wr/P7ZvM91mR+4AbhFoHwCnvd14IsIcwixaYzyJx92oNPhmhcONAiVo0bB1robgfSzeqsrbf0 9CQBSBokPppDnESmpffrXA09JeeGi+RsoIUNrrBvYk7zBE7kBAAAAAAAx4hACwAlSXDFi6mPbuwQ ARZT2zknXeeemJ367finf1ve5/lTjRUlz/qpu/0QGL92278I1m4bdiENla/2mA/+L2nEfT8xbkMh cpsrxIIrpqruKhZoMSfIIvS9k/ouA7B8VVs3pScBKOdtPQf227USMePFRON9scfZYwFAKbdtXZSe BHBAy1+oCgAAAADA37QuPQHAeJ1x39y1UDlhFnOPwf9AAAAAAAAAwJH6EoC9O8ZpGIbCOG7fAcHa nTNwIDaOwCG6MXAmpl6AjYkdpcQ4L319tZ0YSOpW/58UNbWd5DWNVKlN/RFqAQAAAAB/p/+U++ji BOxZ2+2r22ziED2v/3GQxX58lACKGEyxH8IqJLziOMxCQi5Sz/X+9fHW1mqIRKt1BcuHW/hsgEUq 7EKvx+tI97lxP1JvDLGIfV/hgp0sx59cnF6CLdQYbwIsdMCFXuYGaCyhxUALG2Dh3GFGgp/EB1Xz mAwRzmV/Hm2iRGefhzCMYZz06VQJb45514//7B/fp9+jh355SxzWu9NAi069HDm0buvUy5c2fRpy ky2kgizs6eRGOwAAAAAAcM0ItACwJgmw2LlDgIVWG2LxH321Y3Ntc7fNWeK76NofNEoTFefqC32p wIvQfjss92YdyHlx5VAb3V7qT4VZ1IZcTI2bG2Jh6y7VDuCyPJ27AMC4+cU2qcAK22bvuagNvOBz D8Cans9dALCg9m5cBQAAAADgchGMitZ8zBxXumciFWBhgyxqxuX2DwAAAAAAAOAKfQvA3h3jNAxD YRy3BBJRGbhCGRiQGDgCR+gRGDkjh2BgQMyIgROgSB1C3MT45WE/p1Rt2uj/k17bGLd2pQJS4/gj 1AIAAAAAxkld4KPb/GbqT6UXWi5v2ttq0CY33R+GW4QwC7cJr+iOY+nwii7oIvy8EeV+gy1CSIZc E0K4RXSs8/L2EW7R5UDE68ZlGET4iMfj2Ef3L10D5z+HVbVwdf3t6vXaXZwPv5II4RPJEIownn7f sl0EWsjjKR1joIVlM9s+PETuJCCTIULIhU6WyFXj/gZayDSIy7au2vosT++2rfu2XtQQZ5lpyXaZ qyGn5NxwAV1qQ4VG3UupkAuNTRcAAAAAAMBc+O85CLQAsC9+Y/p3F0Ms3jL9ckEQ/wmiGBtWsUuI xS4hF1bfQ7JOdpROhFgbFuvjr75eVZ/rvnzIxV3/eFEYF/P37Lq/Gd7Y351UUIW8t4IsrNCKVLt+ 3W0CLlLnsKz3BeA0rKaeAKBYG3DpdQ6pEIvwuBRwYY2RGpM1FgAO5dGxGSFO15j/tbnnAAAAAACA 7T1MPQFA+Ui06TUGqfUGucAKq5+1jqG0RgoAAAAAAADATP0IwN795CQMRAEYf3XfjdHEJXGpGw/g hdx5GPYcwat4AZfuXBg3rCx2Oi19nb7pFAppMd8vaaB/gEERE6nzEbUAAAAAgGn0P+i+iJ94PWq9 3shq9VBd1/P2d0MWu/1lE6Bo4hQuTNHGK3zAIgxbdNebiMVufz/+vrNZQhaWpUYkljou5xxxi+5L 2bqeReIW7Rja9fY4H6nw1/P8uopa/Gy3cpvnA0MxnpcRsGjWM2PbnGGLS4hZ6FkAqu9YHbNwdAVC RJUh3Ne6fO2FRYkiXC+Pu6qPK6RflQhnNbgrj/8uLz/Tb0rP5fJuPGwm/aBFIf0mh95W6KcfPN0w bCHq0gpZhF/Ohby7AgAAAAAAnIz7m8dGCFoAOJ0v8fGKZnHrYyamPzRIEbtNKnIxNYqRur9jtw8Z e5spH2IcG7EI91nHxbZ91Ive7wIX99JGLh4T48L/4iZneBvYb03CkApHDEUrUsuv9KMVYezCimnE xiRi/zzz+RNwuVzQgkmzsTQ3xjYrZqHPixgTt7BiFdZxet16XH7vATi317kHAMxk+Se3AgAAAACw PE9zDwBQrKDFIVLnVITbROxzGqx9sfMfhiIaAAAAAAAAAC7QnwDs3TFOwzAUgGGrLFRIwMLehZE7 cARuwMSpOBAbIzdAYkBsZSTENU9+edixk4qmRv8nhSZxCIYiilDIT9QCAAAAAMpqbqzib4j+UDrR ZnPdvz0d7OvUjdyHcQuJWYQ4RdiOi41ZhNCFjHdqiWELiWR03dfuMQQHpn9B/sKxRiSOdV7e/nEL G6iQfTFIMQxZuMFY6jyyHr+v4th6fb5b+9hu01ELOaf+vFRsIR5mQhp6nqtVYs6H00LQwtJBC1tn kEddhpDIhS1L5JbO/Q5aSFXC7zvrl8t+eS1P1UeD/EWgz+ZDnGSmpffrroaeknPDC+Ns0MKGK+wT XHNjBW64AAAAAAAAWiZBi/ulJwKgaZ8u/G33xcWIhTc3DDE3UFE7PvdYu57arj2mZuwQ5oQscu9T c+xY/EK2336WJzV240LgwocufPDiKjMHtO/RhZ8pXikMMzaeillMjVyUjivFNHLzHps7gPbcLT0B IMFGLaaEJWp+1yvFLABgSbeOeC/aknpdTr1273N+AAAAAACQ5v/t8WLpSQDKu1rPXXdQuvZg7JqK VPRiyrlzuB4CAAAAAAAA+Ee+BWDvDnIaBKIwjg828Qi6M10bF+49kbfwEN17Bb2JunFtE/cuTLoD B5hHH48pjFLTqf5/yWTgdcoghhRT5CPUAgAAAAB+Tv/T7a1vl2ODV6t7t1y2Q3SQRD/Ioup6CaCQ cIo6uGIbXtEGWNhgi/76NsxCtq/na5erLtwiF7mGSOS6X7V54Rb9YIthuMUwsMI+819P276/6Ho9 x2Jx2vSfm01kN4reiVHYMAsVXFHJPNLk/abeG/PL6S05nUOpmj2W4xZqktqgUyCk3tTq4+qPpU2U KO26H3cSxpV6e02QTjUI0Tjz9Q/fv0//nm58e4pMW7hhoEWpfhwJsdA1WdZZG/owxE4CeV0fRh16 4cwyAAAAAADAMSPQAsAcdYjFa2hvqp4aZDE3eCLlte/Mt+9wi9yDLVK++BgLpJiqp4RXTK3r+rNv L749hvVz1wZdXIWekIu/4cG3dVhOCYyRmg2q0P1YkEVquEW5Y7tTARepgRd87wQcr/pBR/w9hVxd uP51eoy97rL3UtjAithYF1nfdX0Ye2C3i9QBYI67Q+8AEGEDp/Zh7HMXAAAAAACkuT70DgDGenrI QOzehLHXYv1UuAX3OgAAAAAAAAD/yJcA7N0/TsMwFMfxRF0QiJW5CzNiY4MjcAuOxwG4AogRLoDE wMTUBaW23Efdx7MTk4Qk6PuRHqn/lDhUFQil/hFqAQAAAAB5bZuseH7z9Lu2b7Ren7uvR9/tsHd7 c9COK4RZhHCK0N4HVegwixB0EcYkBEOeL8EWEpKhzxmOfUIRxjHXEIm5rsvr/zruPz+uAy7qOg69 iAIkZEatP4deqWAL3w6hFp+bjTptPnTiIOBCh1aoPmnXcXtkc3rfdCVrtn7qOp1BjnEyhIRc6GSJ VPn5Kzln9HrLDj6nVdjN46196T4Z6MLVszrFKrGsuF/64ktoVJ9crq5GHWNWyIVG0AUAAAAAAFga Ai0AlPpw9eTq1dWjGhsqyKIkxGKoOW3zuoxb7b59YysJqMiNDRVokZtnPX7f1cOu76wK4Ra+rlwd G+vCvPmNGe4z46lNFXLBEaWhFbq+jL6msoMscmEa+hqs6wKwTLdTLwDIOKl+hkakgiWseyX0HOso j3N/E8b3ZeixLvdjAECJG1fXUy8CMPhQiyl+1y3v5lcAAAAAAP7W5dQLAJSXgrmp/zWlQiji56Tu afjNPWAAAAAAAAAA/pmtAOzdPU7DMBjGcaeHYK6YACFxA+7DxhG4QHckrsLGCTgCAxtCDJ0LdlIn r9/4K0VVUvj/JCuO48Ru+jG5eQi1AAAAAIDDyD/c3tlymeu82Tya9fqqrfvQClnvyne/9QEUPpzC BVeEZRxsEe4PYRax8VIIt6i31Hk5U97HMLxiaBN7Jvy4N8E53abp2zMj2eOrtva53fbjZFcm6WAK fX0RbtGo/dG5R7Kk70qtIIzEjAMs/JMIZAqEb2/b3D22nzGdKLHT+7bfat/PBVnsTPxJBX4OZ7bP l92+536kOre2vEaGbcw40MIPK/M1ZJuclm+Tt2H8BRiO65egbycL7wAAAAAAwKki0AJALfeQ+RfT /WH6TR37TZDFlECKUhhFqX3KtUrHdD3VP9U3d/4cpgZbTA2wiLWVwipS9dqQi+f9/rkZAi6uI/PC 8jyJeu7BC6XjsTCLWPBErqSukbpezbxKrw3AabqfewJAxoWJP/gotgYiRq+pSK2vSJ0nx9JjA8Cx PMw9AWABDgkyBQAAAADgv7qZewKA8hFpK4VT5PrqdRQ6zCIXblGzBgIAAAAAAADAH/QjAHt3cJsw DIVx3MeqVaWOwAIcKk490WW6XxdpJ+gJqaeyQqG2nCecV7/YhqAk6P+TDImdxAYUCYHlj1ALAAAA ALDVLKwSFkB/K11ovd74xztVG+dl9IMt0jCLGE4R909Fh1mEbQmxkBAMOV+CLSQkI50LQrjFOOY6 rqD+c5RQikxLLxvCviVOfdjHHA4xL2C332fHVAy5yF05GWC6ndZdYwbUnO6NWi1jzoVd6GQICbnQ yRK9sIvu/T+q80LIhdw8sprPoy9PvnyXhxcWVnj25UN3ZwwrrZc6Pay0Tl6uLkf1nKpZZIHFFwAA AAAAwFIQaAFgyKeLv8+GBXB/VFtrkMU5wRLnhFyU+rlWwIV1TM1+TdulvznX/IHU2tYabGHtjxVo YbV9deXdlwdfXlwMuQjP9w5zEz6nXbfdEhCjwyd00ESp3Qq1+HX/Qy5y5w0t/mAtBFF6XQCWY+VY 6AjzNvSdZ2jeg/6OlbbpY6zAi5Y+AWAsr75spx4EMLKWiazLm/QKAAAAAMD0VlMPAFByoRZBae6S NT8qd43SnC3r2la/AAAAAAAAAG7MnwDs3T1OwzAYxnEnh0BIHViYGJgRt2Fk4wg9RHeOwA6HYOUC LExIlRgBO8XkzRt/tpQk0v8nWY3tfDiJSivq9iHUAgAAAADqyS/Z3tpykVp5s7k3q9X5ILTCGS5/ /YZZ6IAKF1zRh1fs+nWwxbDeh1nEjleKcItycx2XU3If+yyIRq3XDPojW6t1+5Xlsr9Gb9ttybAH g+vCKWRghQqv8G3d8dq2P48j3JA5PR9KJe+9GQdY+NQGmQLh27s2d33tDdWJEp8mnDDRin2FfqXA j+HU7vfdPr7m/1hd2/IcOGxjxoEW/rAyk0O2yWH5NnkZ9I8ryMukT0FfTibdAQAAAACApbkxBFoA GPNBFq58mLIQB13fJ8iiJpAi1xbry21TOg7dV7ocqte0/bWasIrS9tIgC7l8SJBF6tEvy7r74OrR lqef+qXZhVtc2XJiMDUXZvGQ6I89z1PBEbnQin1KLMwiFaahzyF0XgCW627qAQAZZxXrpt7zlbwX q90nr4MAjmE99QCAA/zX62NsaucUYwEAAAAAYA4IScWcvGT6S/9nE5tDofuMCc9vCM2XSo0htw0A AAAAAACAhfkWgL37SYkYhsMwnFm5cOPCAwjCrASv4MIDeAyPJAieSQ/gRnAxl7AmkwnJfP21SctI q74PhKZJ/6SUQgcy/Qi1AAAAAACb9cdZbQu/qR5rB9pub1zXnUlrnHdRBl2kEsMsXBFukesaZhGD LnIIRmhL+6dgi7jM50znnYJwi3ZrHVcQ7qN9D/vf7Y/bbY760765byMhGMf1MhBjH0rRxfX33W50 nL0AC+nrBVaU61I/9Y1Y0zPQau6YrbALTYZIoRW9QAt/zi8JvdD99vf48MCkr/ic+3Lhy2d9eCFM 6NbFYAvN1rCGVbantvISOmlLl6ulk2XJCrlQ/KETAAAAAACsWQi0eFl6EABWYw1BFj8RYjFn+6nX UtvO2sZan9veas5Hhsf6WsIqauu1sIpUn9rXskz1V1/efHny5dqXexdDLgi4WMZzUa89C0PP4lCY hRU8UQuusI4xdDwrwMIa99i1Afi9HpYeAFBxabTpVBGdK2G9O+n62HvW0H46l4K5FQBO7c7xAUL8 T1NDSgEAAAAAQHa19AAA8VHUW+ch6FyoobAKJ326tI5lLWvjAwAAAAAAAPAHfAvA3h3jNAyDYRh2 JM7A0AUJFkZOwMZhuAWH6MLEFbgD1+jK1oELQIjrmvz+7dhOGjUB3keyYlnGMW5apJL4I9QCAAAA AMaRD9c+duU213m7fTGbzc2h7kMr4nobhFn09fYnqKIvcbBFHG7Rj5k63ykIt6i33nnlXsM4xKIP rYjDLsIxwmfSw59rjud2x50ItXBhF61bKH2RymALHXLRqJCNRNDFnIu/pmu+1pg5pwIs/I4EMgXC tx/a7Jqr4IoL+3qKPqnyZeJdCuQcLrsxPrrje/lD6964TaV0pkZj4kALf1qZrSHb5LR8m1yG8GIO l0n/Cno5uQEPAAAAAAD8BgRaALDsw89vxgVZ7M24EIapARb+WGqbs2/tOKccp9SH2pb4njn3j6RS +5QwC1mfGlhR6pMbf2gj5t2xPHfluisPhoCLc3o1/aYMpfdKaVOFVNCEDrTQgRW6fJo45CIViDG0 McTQRg9reM8DmJcNtLhaehJAgQ61mHJ/Q22gWK4OAOfwtPQEgJnMeT9i7u9xKnQKAAAAAID/5m7p CQDKfkTfmnu8fH1MWEVNH75TAgAAAAAAAP64bwHYu5+chIEojuMjbEyMiSdwycqNWzd6BC/hnbyF a4/DwjuYQBynTl/6+tr5A0Wo8v0kz6nTQqehBKLT/gi1AAAAAIChmpu0NDdJfyk90Wp1F35emt44 H0PCKyRwQgdbSG23sSS4QodZ9IMsvKou2EJCMvQcEMItjmu+45LXsOsbC6Jo16jWhlt01QuZMH1x n7H93GzGQywKLtrAhEFwhdrHz/4WC3UsKjhjT3M6z2tNHXMqnUFanQwhARbL9vVZqN+/TOiFfZxX 54Hc4ec61E2oj/Iwm1ChexdvrqaffqmH5frhFtIvffoQvOmTw7XlTavpEy11UScXewIAAAAAgLkh 0AI4b80Fz83fWd9dd/FzLnQhdxP5sb7aUImasIma/inLub5d2lKfXS6tS213aKV/LpQCKkrb1IRd TA22yLVTt5WAi9dQDy6GWzR15fAbmjCLt8z61HusplKhFfuUd8MgC19YZ49h7LgA/G3Ppx4AUOk2 1Nrl5zGkvivt+j1PP9Yu6/V2HLKNncYCALWeQj2eehDAkaQ+Xw89CZbPZAAAAADAOSDUAnOzrtyu NpCiNP8qVaX9AgAAAAAAAPjnvgVg7/5xGobhMAz/2jAysLDQlYWBY3AOZm7BASoxMnAcYIU7ILGz Fwg2xsRx/C9OpaTS+0hWXCdN3MaKKtXJR6gFAAAAAJRzb+y5UeUitfF2ey+bzXkvtEJz6/a1DaPo 6u1f4IVZ6vAKU1rZ7bpgi2G4hQkrSB1vnwi3KKf7tbQ+aWa89J/N353PfojFMMhCeuvT972ZdU3T qPH6JZ+qHK3X3iar+Al0gyx6zV7Ahdf2H4RRaUlju1Rtn/27DN3UBjcFQsRJhtDfsTpnvwEWMkyR iJVvST+d4Ezt70Mt3/MXL/3QqNfAYVcyDLSwh3WzNdw2t1u2zX7c+OCPf22t1wYAAAAAALBEOjT0 bu5OAJjFiyqPYgItrNowi9TD5f31pfWxN1GHjlO6Xa5es8y11b5OyW1b8wdCSZBFrD0XXBGrTwm0 iK0fG2CRateeVHlW5VjMfxVXqlwK9unBqcfG9phrkBtmEQqeKAmv8PcR21/sYQ4l1wQAh+9Eleu5 OwEUOhUTJBWa9yCBttzEoNLfcaH3haatSKAvADDW7dwdAGZCkAUAAAAAANMQaoGleQu0+XMTxoZO hOZZhOY2xI45ZZ4TAAAAAAAAgAP1IwB795PSMBDFcfwpiIhQN124EpdFEI+gR9BbeDyXuvI0LgSh 4KKrQJw4vmbyOv+q1VT9fuCRdiZJpzY2Uqf5EWoBAAAAAEM1F1zZc3Vb2tFsdi5tu29a/XwMDa8I Ay802EKraXxpeIWvPtii6/PrtkH1wRYakhHOASHcYlzbOKaOZkn48eVCLFb7+tuDPZr9+3W6Y3Qy mcp8/iyNO0BXQi3sgGLtujS3d7RN27t927Y1bNOxXOu7xmzTGXSpSRH6842FV7yHXbjXMta3nOEW vN56pZ8D8Vf6eCoP78zVhfhgi8FDS5+9YcMtlpkcZii7Zhk+bVutWVqlQAu+4AkAAAAAALZBF2jx 6Opo7IEA+DEvrh7Eh1ksPtpyXy6uDWgohUF8NqCi5r7tqw2qyI01daH83HOL9afaSvdLnx9v+vPl 2n8w1ARc5Npy29eGW6wbTlGzbk1/qu/V1b3436tjVzfiAy4OBV9xJ/3FGGouqmCXYcWCJsL2WEhF TcBFbJvc+1bp/SP1XAH8PtdjDwBYw4kMQ+6UnRcRE59UlP+7zG6X2i/nRACbcuXqcuxBABWmG9hH 6nOW1Dq5bXPnf87TAAAAAID/4nTsAQCBbs7XorjWKjtnQQr3S3MwUtuUHgMAAAAAAADAH/ImAHt3 j9MwDIZx3NmQqg4MSKxlYWDgAsycg5WNw1QwcgQuwQWYOAFMDIilSwXYOFbeWH79UT7aiP9PspLY pna/EEKOH0ItAAAAAKCOvJn20pbjXOfl8tYsFiej0ApHnofrEEYxnH/0gRf+6IMsfJjFeu37hpAL d+3aZJhFbrzfRrhFnd2a03D/uHvfxuEWcYiFEUEX8n2O67pRP2k22/8KtXhbrczefF6enZuT3jiM 2c+x68MsOhl60WiXPr+1fmrOqQCLsEuBTIHoB/U79dgPjGuPkyPCuVbeTXqXgjCHQ/v4r/b4VP4l dmbLQ2JYbVqdGWdryDo5rVAnX4bUZgyhPRa/nCzCAwAAAAAAu4RAC+B/uTc+yOJR1OVCFEobxsfH Ul0uNKJmA/hSXWmsUp+WcxOdp27KTvVJtaeuc/V/8X/m1k0PtbbaAAutbdNgi/jYEmjREmqR6vts y7UtN7acGx9wcWTQyoVZ3GXate9VqdQGVmwSbBGPo7XFzyH1vABM39W2JwA0OMi0aescSoEUso/2 d1PrmACwqYttTwCo9J1Qi+kteAUAAAAAYBpOtz0BQHgR59qag9K6hLif9jOpdRmlx9Vo664AAAAA AAAATNinAOzdMU7DQBCF4SUEUdBAQ50CpUAUXIILcAE6LsVBgFPQcgFaqogqwqy1TDweduwlEdix /k8ardnYyQaTgIQzj1ALAAAAAGiUNFw5inXfd0fL5VWoqmMzm663kPAKHXghwRZS63UqCa9IFX4E WejbdbCFhGToazwIt0jjiJY0ojW1+/nIeavPY/scej178v2EmmCLpubz9Lp4X63CeUGohawn5Wwc bAI2NkEbUu0D0jCbNV/X1fMiGNPP62/8x7p114DZ9/mwyRBVyIdXHMb96+CL3G2bLj7q/EiHn5NY p7He+pd3GdJFoi/2odWybLiFzMucfgqVmZNvga3KjJY+1mv0wIV4AAAAAABgCGchNYsm0AKYtvrD zHWQxXOsDzVfGrBQ8sHlrnAKO9+1b18ARd987XPLx/TW6z3Xknlvu/TD3kM3vP+LYIuuIAtv310D LWQs2dZzJQEWuf8b6PnHWE+xLmLdxroJKPWgtruaLORG2bavURswoYMn7HYuvMLb17t/77216/0X wDQsAg2OsF9KG2j3BVl4f1vp0TvWm+d3JYBdLWLdDb0IAAAAAAAA7KXroRcAGK9bHJO7fkLf5u1n x5Lrt+zjAgAAAAAAAJiwLwHYu2OchmEwDMOWVy6AVAkWJE7BzFnYOAIrUndmbsANGDgBKyMSGxIs HaE4sZ38MXZsF0VJ0PtIv+I4buNWVZY6+Qi1AAAAAIA8eePtlanzscHb7Z3abM4GoRUN2fb7Psyi b+9d4IXd2iCLPswiFWRhq9+PnW8OhFuUWdKc+iAKFybR/Y5EkIQ9Ksb73Ihhn3jXrqW1DbX42O2K 5pL8Cbugiu5cIuCi7dM6mG/+XGsz1ZzlkwH8GXxqQxtQoWzig+/XLrSiPa6GyRG+napvFX/ygZ/D sXnvT7N9y1/MLkw9R06bmlaYySH75LR8n/waUg9kiE0y/DpZkAcAAAAAAObWBFo8mjqdeyIAJtPc xPzkSjokfGEs3KEmMCLXV3O89qbp2nmOfc7YNhwfHku9Jraf668dU6r0D4dDH0icGpM6lmtPFWxR ekxHxoR9vl5M3Zq6N3WpbMDFkULKg6lX1479xnPXK1mxoAnZXxJo0dRXwdjSa5BSv68Xqc8KYJ2u 554AUOkk0heuc4jth2352tQ2FwoWrqlgjQWAv7qZewLAAqxvYSwAAAAAAMtAqAWW5r1i7NiahNR6 p7F1WCXnyPUDAAAAAAAA+Ed+BGDv/nEahqE4jgeQQGJiY2VlKQv3gY1rcQHEygGYuQMDDGzdK1y7 jsnT6/OfoJQU+H4kq4ntpjaUUrVOfoRaAAAAAEBknbij6459uasdaLG47pw7UbVxHUYKr5CBFzKM IpTVKhYZXiGDLcK2DLdIx4vhGENIhhMXgSfcYlsY0h4NZ2POcAsdVpHOF0/14Xc4jM8Ki7D3db+0 /7Fcjh6fixvmD+hAhFpshV00HPu3mWPMh32gxebxxa1MhnCdHV5x1AdfWG1fK9zCnPonWbr6T7iq 05kvb/XhXXZxseiLfmgxLB1ukepTnZyCU3Vpuro4davJ+1qvxFyEAQAAAAAA/KQUaHE190AA7MSz L0/dcEH4pHRist4u3Y4Jg2gJmrD6fDb2bT221ZabgzWXXFuuXbe17E9xkvfYz5m/8yVD7T61L45a +ugvq3LbpX764sqloApZVwuzkHU6s9sKzNbt777c+/LQDeEW5x2k8Nr12G9bz+nc31qtlAIrWop1 jNzjuEy7noM1LwB/w+3cAwBGOlX7rWsYcu+3ZJv1ns26PwDswoUvN3MPApjYlGsNS/+7AQAAAABA /HwJ2Cevjf2stRVWW2491Zh++tisfwAAAAAAAAD+ibUA7N09TgMxEIZhJxegRWmRkDgDDSUlJ6Dn FhwgPQUFB4ALUHMBKg6ABBVSUkG5zG7W2snIHjuRyEbhfSQrjvdvWOVPYeOPUAsAAAAA8Okf3t5I O/VWns/vwmx20vVjaIXtx/sxzGLox4CK1e0qyGIIs1iFXjQqzCKo1iSPsW/2LdxizBAJz67r6gIj umNOVGbE8NDXIRb6cRbHhjpTYRdrR5Jtp13vc7GoLc4/ETrIItakAy362lNPh315HG5iVzXrXz9O +/PXhCHEIqZAhH582odWtMttckTs55qd+cnWcCz7XsrtR/lF7Vzaa+KwubImYT3gQo/Zyaf0n5ub xCout/TpJMQCAAAAAACMpf1e4iEQaAEcmm9pz9JepH2p8doQhZqghlIYhB3bJJgirp/q12zv/Xi6 tvZSPyTG7Tnyxra5X7vsr9X8U6J2kmJvzAu7KE2ymJs0ORde4Y2Vgi5qQi5Ky9vU90dpT9IupV0H wi1aP9LuK9bLTaQQ+/Z5bAMmbEiF7pcCLez+cgEXXr22D+CwXEk7GrsIYAtn0t6Cfz2D/YwTCvc3 +XyXu1wktX2TWQ4A1u3YBQA7VvoOx3ufrtm39xmB92UAAAAAwCG6GLsAwHhPjOWuZbLr5Jal9pO7 dix1DL4XAgAAAAAAAP6pXwHYu5echmEoCsNuERKCGStgjNQZ+2AJMGFdLIEZLINVdN4RowqT1LnY ufW1rRT1xf9JVh5OExvSiIfrQ6gFAAAAALRNrHLZlZfaiRaLB+f9ldobxmVIeIWEAqTBFlLW61Ak uCKUGGzR1/XHxWALP5zHDWEYcu44FiSdB/5Y5vAn3KLNfts1G10nDarIBVz038N4b8W6/OfN4zHe h+Vytcq3wgigGAVVyHKWXnd8jk2YxXw+DrnQx5yYQ7R562vrxukMspT0CBmhlguvuBiCL3J1vzP9 9NcbbiyZBeimK7ddWdabe+/CpIyf+tJJs3S4hUw6JN1Iu+DVPumuLl4ttfS1udubD3YCAAAAAIB9 eO3K46EbAeDP9AEWEmbxlewvfXC4NPm7Xlr7SsERpZCJb2O7VFc6j6zX2qHrc/1r6b+ut+qs+ty2 tW/XuqlaJj+cWl/7X2zLpMe1oAtZt46vhV1M2baCLOaNx7535cOFcIsn97/DLd5cnICh9l6pPZ+s Z0gpsKJWrNfXnou5dlr9AnD6ng/dAGCia7c9bqE2eXWJ/rnJFbZ1Xa4drtAWAMi5c+F3LODc7Tqg 1BrsCwAAAAAAwt+YgGORC7RoURtfoccxWOMdcuvWuCxdDwAAAAAAAOAM/QjA3h3jNAxDYRw3OQED GxUsSByDmaNwCw7QgY0DMTOwcQEmmHqBEJM88uS+ZzutaJry/0lWXTtNnKiKKsX1R6gFAAAAAPj0 H3YeunKb23i9fg6r1c1PsEQkC/5LgIXQYRZjXQIq+tc+yGIMs9BBFn2YRVClNY9hObbwBsIt6hxm XNtr7ox5EGloxRhuYa3lk/b174fAiuFcPjebiiFth1W06ti/gRVpids0jbmP8TyWZY4xNypgRK8S IOkPkgwh7c0QWhH70+QIqXtFUiWsVavivi+6fV92rx/ezW1015U347DesM6CH3ChhyVt+jJYC1lJ fyrNA2FSHgAAAAAAOKSnwEJuwKmIYRZx8feXpN37E7HV54Uz1ARBWCETXr+1oHxQ9ZrP1JbcWLzz mXI9glEvXefavlL7rtvtYurDiClBFqVgC6ttSj0XfuGFWuwTcJELuUifL9SGW9yH/xlu8R76kJ7I +n57iyXU3HP+OsiiTbb17k+58wJwGs4DIYJYrquuvBrtMrehFHCRmz+RbhOSfu/3JPMqAOzjce4B ADNb3gRZAAAAAACOS3zucz33IADlS9W9+Qc1c5NKn8/NIbOOU1KaNwEAAAAAAABgob4FYO8OUhoG ojCOj7hwIS7de4GCiFdxX8G9B/Ic3sIjuCq46AnclMSM02leHjPzpkklJf5/8EhI0mSSNqWkw3yE WgAAAAD472oGUPGDnb9YO1qtHl3TXKmlfeCEDJ+QwRaxdrtQMrxCBlv4eRluEfcXwjH6kIxWDPpO uMU453Z9onnCLXJj+9hjBA3DLYK2DbkAn9ttv/Vv2MXww3pYJoIqkq29UMfyJQMtZNDFub2hFeZo s3VMnc4QpzE9IvY0S4VXXO6DL1LrDj3f/PH3n4c4+s+NC71Bv+zm+/Chh64+9KFFs3S4RRxoKJ6G PIVWLYunq6tVU02+NvXNzIAMAAAAAADgrzx39Tp3IwBMtnFh0PcxYRY1UysA4hQ1JshCB2HUtKf2 nFLXoHSdauZz70FpmfVseM5nx8f8SVEbWlGzbSkQwxoMOfcHVmlaO18KsjhFvbsQcPHU1bqra7d8 3129VWxn3Zf6Xm7UvA6pkPNWoEVpf/q7RbfXWgZgOdZzNwCY4LawrtTHwfqtlwuzsH5j0n8CwBR3 jnBfwDvmmQwAAAAAABi6n7sBgLIZ8Zpcn6rUOpeZ5vpm6H3o4wIAAAAAAABYuB8B2LtjnIZhKIzj Ts7AwNCRhZGR27ByCw7QnY2diZuwwgVgAancoMRNn+w8+Tl2o5BQ/X+S5cRxE1NKQMHJR6gFAAAA AKTFN9Hed+U613m7fXSbzdUhWMKT5/PHtQ6zCMsSUNHXfZDFMMwiDrqIgzDioAxhBVmkrC28gXCL MnOOqxkEQMiyzpYI9533baGWeUjx9zDel/yMfO52/Q7jD6xeHw4sDEAPKFqPwy0aCbdwPueidXs5 +D+xhkCLVIDF3oX0B0mGkPb2GFrht+vkCFm2iqRKpJ5U5fd92e37p6s/xk9yt115TRzWGlbj7ICL eFjSFr8NqQdZyXZNv51M0AMAAAAAAHPzgRZPSw8CwCTvXXnpylti21iQQkltBT9IW2moRGlgRUm/ mvALazyuYrmkHmtLrdfctF1yvfgvrynnrnVb/XN9Sx6kWBN0UbNcG25R0q7bWmObLq3aT2v0e3Yh 3MKXcw638Oe37+PyWBBE7hw2du6wAitOKSXnodQ4ra8LwHm4W3oAwAQXBX1SfwNZ212m1q/J9WFe BYBTPCw9AGAC/zv5a4b9rmwGNAAAAAAAq3ez9AAAJTVvzGL9b0XPaUi9JtcndwxrDhsAAAAAAACA M/UrAHv3k9MgEMVxfIwmLtx4AjXpwsSNHqO3cOmpPIfxFF7EjXvScQiMfTzf/KFFW+j3k0yAActg DEUY5keoBQAAAIBTVhocpdX+3/RS+qDV6t5tNpeq1oswC9+HWLhBsEUsTdMVGV4xDLPottsGW8jP 24ZkeDHYO+EW0zm23080dbusQAv93rnOkvi9/zPRNv0u+7ChTfjDvhDBE0aDzDZ6WR9DLBKNa9e1 gRbzirM4jkCL7LZumM4QpzE9IvZcs8IrzvvgC2vdT683EXASRwe6CnXXrirU4iGUx1A+9K5Fs3S4 RRzAKB6GPASv6uLh6uLVVJM/ax0EAzIAAAAAAIAptS/XEmgBzFdNmEVqvmYq73fmwirGlNSA8qWB 5vfdr9X23PGOnabmS4PU514CL9VZ/vP+8S4PKXLPXWvvie8abCGXc8EWcb4UbGHV5ZZ1QHaq6O3k cwm97Vcor6G8uS6kau2Wpz3PvffzpUETZF3NucgKohgTWqHnc+ev1PrScQFYjifXPZ8G5upGLetr uNx1mxVyUbrWSl1zyT4XTtUDQI27UJ4P3QhgD7WhFrK/4l/juxgAAAAAcIpuD90AQPk06mr7WaSW x/TDKvWDyNUDAAAAAAAAWKBvAdi7Y5yGYTAMw066VEgZ2DgAlRh7As7CysAdWDgFM0NvwMYZuAIS M0gdKlUVwm5ikpjff+JAlSh6H8lyYrvELVBQk/gj1AIAAAAAfmvePHtry5U2eLN5NqvV+idgQKrr 7TqAwodTuLps90EWZd/hEAZbtIMwfLBFc333lCALydTCG9zrMpVgC2dqr4/3H/MqMwTa94xnVWBE /T1oh1tI6/G0AzGOs2uFrbif26I4N9vth9nt96ZYLqWJ1HXYJ+1XYRaZD7Xw885zky0W7bCLiZti mIUUYOFXEnCrLPlkCN+eV6EVrj9MjvDbsdJczanp+DVtfWHrT1t6BFtc2/IqHDY2rczEAy7CRaaa T1dbdKFrkS5u+AQAAAAAAKfiAi1exp4EgEHebHkyw8Is/LYW0pByI7K2YPwp28MxXXOUnrfW16fu agu3++zH2lL6+44ZSvt8OzbWiz1GOwkRWwA5ZYwWZiH1x/pSAy60tlzYlvabi1BKIRhu7LstD6YM t7iz5dLMw86WR6W/7++o9r6ihVQMCbT4MvL7ljTvWBvnhYB5uhl7AsAfnQ18nPT/kNRngr5wTMrx +FsKQHM/9gSAEaR87gIAAAAAAPpZjz0BICCFWjhd1zGF1zVo1zRo12XEjhe7boLzOQAAAAAAAMDM fQvA3v3kJAxEcRx/YMICY9QbuPUUHsOlxoXX8xBude893LAgqR3h0enwZt5QIUX4fpKm/6ZlSqRE GN6PUAsAAAAA56rmx7Lhf6ZX70Sz2UyaJinML13gRCjoH+YaZhGK+sfhFCG4YrmUdYiFTtJbXrVr NkEY3fm6kIw4OOCUwi30ugi38O2nX1YdHonCKnL1+/vHxO37x4rM51e/oRbfi8V2qIXbvYk5nyTB FiHQQqbTftsjd4yBFuYx0lVXaqJtOtf0CB19ZoVXXKyDL6x9m9FsUcCJpkpcttNNXahFCCMKxRs/ 04eOupWGW2hBIr2M+BKaZJtebq7wlM5T8bHWRVCEAQAAAAAA/NVtO7210/XYHQGwk/Dj4/DafTf2 1YQqeMENpSAIL1Ri6HarTek4MdpIss+7jtrnovT8Wfu8ZWt913a7tjkE73Hjz71r26btSufwvr9N P0O31tPlUtiFV3g5V6jZC7SIw7LT4Ox4fVrYptt1/UNWRdMf2+lFVl+Z/GfhfqdFF7y/pZp7Wu5e kwusGDLV3EetfgI4fc9jdwDYg3vpgvVy71+l8Iq0jRTm1rJ1ntKYCsZWAEjdtdPT2J0ADsR73yu9 Nw95LAAAAAAAzt3D2B0AIl/O/trvS2rHOYhsj3fIjcsq9SE3RgsAAAAAAADACfgRgL37x2kYhuI4 /tqlE1IHBsQCQ3cOAIfgCKzcgQOxdWJggSNwEYRYOqIQN7H68vCzXRX6j+9HsurEbuIEqKok+Eeo BQAAAAAM6X+UvZduYnTXfP4is9lVvxTCJrq3xvnWY7BFV29UkEWzXI4hFd3rKtyiC7jQwRbDIIwY bKHndd80yCJln8IbCLeot/64bACF/Kjr5dFIB1WIWbcKwND719uaTE6WtY/FQs6n0/Lo+qCKxqzT +9RHMg4hCIOxSHcyYkjCHtr27/W6+/NmiYqzK8VZlaRfP+5DK0K7TY6Ida8MUiXCz1iGM1+dtes+ 64ItrtvyltitN6yR+AEXdtIpfbipSau8ybr06bN1AAAAAACATYWLba9tudj1QABU23aYhddmgyNK gRQ1gRWl5Zo2SYzNO46a82H7SEXday+93+vjOYRrxXaMuZsNXt/cJMn2VoTtnwu9qAm4sP1TbblJ mHMhF3a89t5BqujQCm+dvlcRXh/b8tSWh7bcyGEKEy489/Xc31Tqsy73GZIKsNBtX4l+XuhF7nOp 1F46LgDH5VYIFMRxOE2syz3PUHropOY7ld2O/k5U+l4IANbdrgcA/JHffL4wdS0EAAAAAAAMXe56 AIDxruo1zyWVnqWy2/Cer/K25fUFAAAAAAAA8I98C8DeHeM0DENhHHdKi0AsjIysTCBOxMjIxGGY uAE34RDcgAWhLsEmeenTw7GdEjWB/H+SlcZ2E6fQVGpSf4RaAAAAAFii1IQn4tiX+9yGNpvQ7VTV NPdgSOBECGIIyxBE0Sx36024hfsRXiHrEmwhIRgSgLHbXt1tt1aTuxNucXhzen20/cZVRQMq5C2S CrPonxNIntuMab0++V7/3G7zozFhFq7dX60PrA2sqFarrq6Ssfq6Of2vWFOMbYx96lALPTuTLCU9 Qu5Yi4VXHLXBF7G2Wm2/Mvs78+W8LNTiypcbX17trtWwbLiFTELU5WqovrWpk8O1pTZLSz83dhAE XQAAAAAAgH09+3Kd6wRgFj5cM6n7S6StNHAhF9qQC4EombQ9Vdc3sXtpmEUq5CI1ZlsXez1Kfkyd +6F1yd8hVZeqL20f2m9suQsKely/7Wvb+74/t4/tZYpU377HJcvSkIvU9YMhwRY6yEKuTUjbuy+P vty6Jtziwv0d4dz35PLvmdJJE/rOLbGQCr0+JNDCbkOfY+y4++q47gP8X3dTDwAYSSzUIojdHqLb ZGmLbncD+9l9A0BOCPp9mHoQwIFM9fnI5zIAAAAAYCkupx4AYLwN6Dvk3qeSe89i20rdZ8X3RwAA AAAAAMBCfAnA3v3jNAxDcRx3ewFWNjoxcAUWbsDGyMTCrVh7Aw7BwBWYkBBC6sJUEWzS17gvz45T Afmj70ey6tgucTukJU38I9QCAAAAABrxDbP3vpznBq/Xj261utgFB1T7AIHmsTqoN0EW1c+2hFTU j85tt014hdRDsEUo8ty6VPvQDPEXQRaWMYU3EG5RrnReh+EUTWm3O6O9HXjRjNHt9emIt82m1+s4 CLiIAi32wRpSQriFGjNGUwu00HclxisXhHdcVl1yu/blLrQi9OvkCKm3in/OMhw7ozGyj3h1qlM/ 7sOX1+6D36Uvz8ZuU9NauHTAhdQXUZtMKbfwQmrhrcqoAwAAAAAAHOvBl+uhJwGgSAiyCIEWn0Zf V8BCyQ3FqRCIL1VPLQZv1Uv7SgItpM1l5iF9+nVZ70Hpe+OMcbov9RxrO9V2THvOVM4fp+bZFf6c +1u6P3deXYdV6J80dF2fp7fGHRNyIdtLoz0XbBH/9hAHZFghF/LbxpMvt77c+XLjpiEc/947xvQ9 xsXHFh1Q8Rula78lizsAmKewgDb/g2EuzjJ9Jd+tUnXroqESXEcBoI8QaHEy9CSAEbA+b0s/g8d5 kS0AAAAAAP/vaugJAMpLz/G565us66VKrsnouz8AAAAAAAAAM/ctAHt3j9MwEIRheCMaRKioOAMN 3AgKDgAH4AochTsg0dNSU1KhXMBs4gyeTGZ2bZHg/LyPNLKztrNrpESRbfYj1AIAAADAsYn+acfO uH9fe6Pp9Dw1zelauwROSEkIRbeUcAupRlX3WodgzIMt2jCMtk1CMto+mpW+/8MuhTcQbtFfaVyL wIjF9onZ3gVWrIZWeHPueMEWaz0lmcfnazbrN3AJq9Cv1bgn8xCLiRnnsk3CLlYCMUa2b2EW4Xum bjYlb9YnSY+QJ9e8EIuTZfDFb6CFOsYGWuj+prku+oVaXOW6zvVuu1bd2HALmexITkNOQR+jH8jz PgyNWVqlibdK7QAAAAAA4I926TriBj3muh17EACq3nK9JH9C9yhkoTa5u16Pwh/spO+1di+gos96 bVutPSU/yMI7n9LforSM1qPtQ9r6XNPdxHXfbV47jkIktsW+v9d/31CM6Lp7FDIdTboctdWCLex6 6R5CqfStkSjMQu/3nes512uup1yXaXd9pDbQJxJ9zkrlhU8MDbZonPUh313ed1DtvAAchruxBwBs 0FmPfezvFbtN72Pb9DI6ztuHZycA1MxDph7GHgSwBw7yxggAAAAAAFtwM/YAAOPTadPPKXiv7b7R sUOeeyjtw70cAAAAAAAA4Mj8CMDe/eM0DENxHHd6ATbWMsIlehMkGLkSN+jUlTswMXECBjYmWCoF R+lr7Ief7bSoSavvR7ISO/9cVa2qxPWPUAsAAAAAGMifdp58uc3tuF6/uOXybldr92EBwzJu6wIt JKCi29aHVgzhFdvtEGYh6xJkIeEWcryEWYhTBVmkzCm8gXCLena/wrCIsB4HV/TBF/H/yeO6DsaI z9+2/fLTCLWoDaDowixauVDTRO99EwRazMm5B1pYM0HJjEoym5LbtS92oRXddp0cIev7cAupB0EX 0hbO4CTnvvb7ffnyUf4SXPnylris1a3GpQMuUiV8uX9TXuIua9ZEWgAAAAAAAGM8un4yawDz1U3k vvHlPbGtNmzBCnCoCYSwJmO3AilqAy5ygRY1E8O7oG71u/Saa5elNqte2r907DH7HXvMIfQjgGPk 7o+PketTakJl3Wbdh28S7TrUwsr1Drfn2mR9odpqQy1Sba1aymOUV1/uXR9ssXLz8+3Lc2Z77Wc4 V6yQirBeE26ROp/+7tH9ttp49gNctoepOwD8Iz1OTv+WS41pOCSsIjeuQv/WcaodAFK6QIurqTsB nKHSfZ95DbwFAAAAAOB0bqbuABD4cf14i7FSYxxydWt8WumY0jUAAAAAAAAAXKhfAdi7g5yEgSiM 4xMXJgombDyHehDv4ZbEe3go9x7BxC1h4catOEM79Pl4bzpII7X+f8mz7bSlAwk1act8hFoAAAAA +E+8H9HK9vNYD30vNJvN49+LvfY0trqsFFzRTHOwRQ6zCG1tRHXLMsQiB2Dk12lCMUIbTLD5duxT GVN4A+EW9ax+dfNNMEWXC9GFV+TPNs83y/qrFHZt3fo2sKI97utq1d9J1bnt/mmaAi1U+257NT+W cIu/HmhRPE6wR3XK6RH5abQzVdvUiDbERK/bhP1ACzmCwVWsRV2oRRp84S7Wi3X4sJ+zocMs5FuQ +8iH7EoDT1mDagW1r/UmGJgBAAAAAAD0Sdc8nk7dCQCudWjCLJ6Ndd6g5zU/HvZCH7xB3muXjwm1 qA20qCn9nkqfhbfO2q40X7PstQ25fkyO7at3bdzz02vi+vaEd2zdJq/hyz7IvuiQi76pNVizPnZf wIW8N1EKtcj3ND7Ftu+xHmPdx1rGmofxSOfCtdFe+s7WnOPy+UaHWQxRh5yvgmoDMH23sW5O3Qlg YJexPg7cpzasQk6t/Q85Hv9vAWSL0IRaAFNxHexQXAAAAAAA8Hu4/4MxeRPz3nNMpWehrHZvH+s5 q77X9XjPcgEAAAAAAACYiC8B2Lt7nYZhKAzDh4idhYmFMsDAxMzVsHIv3EhXpjJxA0isDOyoCyNT 2uI0OdQ9PXaSCkjVvo9kJbGdn7YoSK3jj1ALAAAAAKjpQ7L3oVzlOo7HExmNrn9CJXQ+9dVyva4O stBACpGylCbYoq6vtjW8QtfLcj3cQkMxNCxDVfXLix9+vv6lXQpvINyiu9XflPeMuYj/DLrI5rPl GlxRr9v3XgMt5vO6/n06NW0Lp/9iI6jiqAlBEBtWEadwxIEWRTHom75vYRZegIXOoBTPnqT1RbiW efgcq/Y4OeK4+XzjhAlt033i48UzNumxz0K/z1A+2oMtbkN5tadpDmcDLeIJo2zAhVfil5ubqMG7 SPt2MkgPAAAAAAB0dRHKcygnQ18IAFc1gftTKF9OW1vIQm6y9D6TvOfquoRV9AmyyAVc9JkYvm27 zzK3nurvtXetb2vra9e+L97mh4fffA19v0OP+3rhErlt+zNIqi61TE3mbMMy4oCLQjbPFwddFJl1 u3wM5SWUh1AuZXjVhJyTlj65e17qHmfDJ7xgi5nZbtuv6/00dX/yXhOA/XQ39AUAf+BcVhNpp8Yx 5AYViVPXFgRmj2vPkRtnwRgLAFWgBd+NYp+c/sM5UgODbR/+1wIAAAAADtHN0BcAGG9b7OONvbLr Xptddh3fJWZfAAAAAAAAAAfgWwD27uCmYRgK43hahAQqB8QYXBiEDTj1yJERmIOpGAJxQuoIxiZ9 ivv6nu22ahPa/0+ymjip40YoSInjj1ALAAAAAJfCe4E2r7+O5bXW0GJx14Vws1UvgRNSJIRCAiny IiEWQxmCLSTEYlgf2kkTwEs4Rh4AMMVwi+n0pT9PhFvUDaEp2++S51kRepvep1/ebCOthrC5//dq td2Jfkezf7P5vAvZH/tMQitUiMUsD7QY+SSfW6BF8bidPaOTpEfISLW/pIh1MIkZaKG+owMt8jcm b2N5aAu1eIzlKZZPdQgJrdDd0GEW+U+4WrepB+BZgRdBfWreRBBdpR4AAAAAAFy2+66fMJ9J24Dp SS8Tf8TyY2yrhS14Lwjnyy0TvZfqvOCKffexjtkSamH9Jl1XOhfW5z7Lpbpd96357/d6D+l/y4OL WvvefXZp3/u+3qYfZeh2g7FN38u3Jne0QitKQRc6uMJ7FGKt58EWVn/S9q9YXmJ5j+XZOTenkIJ9 0jVRn3fhXQt3KXlIhQ6syOtK4Rb6mmZdx1r6bW0HcJ6WY3cAOAJvIu3SeIYSL+yrtlw6Fv9jAYh0 f/Rt7E4AR3TIuEErpKJl34mNaAYAAAAA4OQItcDUWOPPPC3jGmS5ZdxayzFq9QAAAAAAAADO1K8A 7N0/TsMwFMdx05kDsJWBhVtwFFZmdi6DGLoxcggYOAQLLBwgarGbvMZ5fS9xokhU6fcjWU3sNHHT f1HT+EeoBQAAAAC0F+I8xHLTt+Bm8xbW69tmbncYe7+97dbVIRbhEERRVRJYUbdVlYRabPdtaVrq 5H4SitEGDnS3mTulsIRT6ktCuEWZev9IEIU1Rr/0t73mXM9323T70QbtF3Pe3vRrp+o6fZYQC1WX B13s1zEcfjCbJQdaWAEWMlpSGkVJRlOS+lXs1zbu+3TbSZGQ+mCEW2RtUpeP2CTrvorL/cbyNfzc 3sXyqTfTrM4KtLgIdsCFNQhV/nCP3zT9AyxYA2IBAAAAAAD0eQ11gCeA05EuIn6J5cNpLwlg8AIc xgzs7s0PBVVMCbvwtmv1y3ssul7vK+/C6ZL9aU1b82OX8/Dbrq903wyd5Oh77qz7lv7m7p3y8Kb1 8kNhFrotP3+wMur7QrTlnMRO1cttfkolTT/F8h7LYyyXBftibs+xfIfhgait931QddZniw6zmKOU fN7qx8L7Hzgv94GAQSyTF2ohrGMr6xgnP9YpXc47DuQ/FAA8KdCC72Ms3ZjvwTFBFlPxvQwAAAAA WLrr/+4AoPwULmf9j8Fqm1r61s3vRQAAAAAAAMAZ+hOAvfvJSRiI4jj+IKIxbNi6cucFPIAewVt4 Gu/gDVy79BZ6ERODWmak005f3+uAAav4/SQvDNN/U0RibJkfoRYAAAAA/gNvEpO8/zjUbWlH83mc 6+O005fCJvJKIRQpkCKvdYhF9RVs0W1/NiEYqT/fT5yMP4Vj5BPzE26xHcItNhUDINpAifb1SoEX TWZEvU67XRuGYe83vq9nsxNZLt/kPbz5j6ZTtUoddBGPWz82swPV7U7Ihd5WBVp0BvoDDjnMosSb ySkFWIi0SRK6dNJEqkr6gRb57EzzUIvNQi0uQl3KevImfehKusOYSD/MIg2jqpeJ9G/OG5poyptU K9/WOgm+DAoAAAAAAHL3oa7GHgSAjodQj6FejWWloIWhMId8mQ6GsCZe32WIRSnMYttgC32e3hef S326X/fptvV803U8/L92f0qv7dDFEO/n/N2wi3zbUltfI7CuC3gBF/ryhw68sEItrHZ6zAMtUjuG Yb2Eugt1VjjvXYrXY56k/xpp3u+/91mjwyesYIsP9dzbbijIovS5lo/dOh8Ah+tm7AEAe3I+sEz/ /TQZaFtBX3o97xjWMblnAoC2kHWoBYC+33EjKQAAAAAAf9P12AMAlGejz7uPSq/jLbP2s829WFyz AQAAAAAAACArAdi7e5yGYTCM4+7ahQqJhaVdOQKnYGVDXIDrMLCy9AZcgpUDILYuiKlD1ODIfan7 5vUHUiFR+/9JVj6cJiYtbZU6fgi1AAAAAHDq5AaeBxcGPE9aLl/cfH61XWr3wiQkaEIHW4RQi7Dc NG4bWBHqmmYXbCHzYdruPVaCLfTxaowpLGFMbekQbtEXsiQktGJ3T3kcbtG//9waYyfeR/+x3et6 Nrtwq9WH+1qv3fl0arfHJXo4xUkaVniFTtv4x2CLUwq0sEYgikdMktGSwgaTEMzjjDALX7fxdWa4 RVQXj740Uce89Nt91gVbXPvyqg/jdiEWsk4CLSZqWQIurH8C+XOtAaj0adL06aRzHwAAAAAAsNz7 cjd0IwD86G4cfvbl3agr3dibC3HQARY1g6yXwigOGW5R045U+3OD15fOS+lcWtuk1tVeg+Va7bjk no/UjyW1z2Hp2rxc+6+dz02tcIqa+ji0IhVq0artZPnNl1tfnlzhN/ED6UJ+Hl1/8OvUObbeE+Ll VJCP9T6n60vhFtb+rDbE09I6AMdr4cvN0I0A/ojdeWef9T0lrtPzqe9Cep+5ZQDQukCLs6EbAYxE 7nOTz1gAAAAAAH5nMXQDgIjVH61Gqg+W1Rcit70ztkv169D1AAAAAAAAAI7ctwDs3UFOg0AUxnGs iY3BhTdw69IreAATV57BpXfwDi49gntP4UVcuDGaJg3OQIc+XucxQxoLJf9f8godpFBsSEOH+Qi1 AAAAADB3sZtw9A2yZ64eUy9Ulhfu8bzTJsMmYmEWzfw2qMJPmxCLop0PwRZhvdAewiyaUIyqDceo xKDthFvsj3CLYHv/uAy0CO0+2MKXXNb9O93Wba8fxbLlsqynv6tVUahQi+jbtg6GbN+EW7S1WGwD Lw7g0J+hKX1mJTkikQ+lkCMZhBGUdLBFNNBCVFXsjtIkR0nwZ+bLvFALn0x04+ojsumq6O7GSbEb ZiEHgTrdvKbuhBdLe9GDSWly3dibIOgCAAAAAADcunodeycA1H5cvbl6N5bnDHreF+6QKiu4wmrL DbUYGmRhBVvoa6Y6pCM2b7VZ86lB5HVbzvVVrsEeN+v/13dNvs+QkIu+5dY0NrBz7PcF6/cGHXCR M/1y9eDq2dVd6gDs6cXVd89yfXxzzoPW+UrWOtKWW6lzWe75B8C83Y+9A8A/ulbPZXBXeD7kO5cV bBHm9fcguQ29LfpMAJCext4BYAKm2XkUAAAAAIDjdjX2DgDCp5i3+kbl9l/oWz/WP0Kuo9tTrP5f AAAAAAAAAGbkTwD27l2nYRgMw7CLOrDRgQExdWVkZ+BSWNkZuRLuoBMr1wASYmWFjW4ZmCoF1+Zv 7L+2kxSJRs37SFYOzsEJaSu1xh+hFgAAAADGTP6p59a0dDhaLJ7MfH7xGzZQR2ESEjQRB1yEwRbG BVc00zjMYrXy834a7yfBFj54YbI5366GFCgxpLasEW7hzhRNJ0EghMz7Nm2HWzTbxgEWfhKu93XT 6bFb/qoqcz6bbbUg3bzm2LU/ULM+DK+Q7aQdUiflLy+iZLP+/5kZynMajhoQjmbg0iBsGyWgwq13 z0+dDK1w29q6ZLhFUCfr9IhP6+Uzu11ly2f73/fKljd9Gml2sE4CLSZqWQIuUoNMbS5XrdcDMaQa qW8nnfYAAAAAAIC4tOVx340A4Lza8mDLd6KuaxBDKtxBh0CUBnTPzfcNs2gLuijN9yn6Okv3onTP TKK+63IK38GOQ+77+C7b6X1y2+jv9vVPJrlpaX7tKDiuLvrnkrZz1cH8vS3vtty1XPOuXmx5Nun7 LHKv2dL7Xum9r09oRVuQRZ+Ai9I1AThMDKKNQ3dqy7LnPrmALl0XTlP79zkfn7vAeN3YcrLvRgAD 1fUzdRidTwEAAAAAGJbrfTcAUD522CfXx8GYuL9Drl9Wrr9X6vj6vAAAAAAAAABG5EcA9u4npWEg iuP4s6UFEdy5du1Ob+UxxCt4AMH7iPcQN3XjSsZMkiEvL/PyBxIizfcDQ9L867RKWprJ+xFqAQAA AOCceTfC6uWxsv7j0IEOh6OEcNla1g6xqFoModCBFKk14RVxKnWoRRNskfZLy/VxquNKHZzR1EEh 3GIZhFskNqCifQ96CFXAhQ63aO/bPobdZr8/ltPP0ymzdmQPdZiGCbhwH89sy4EWnvJvIlXFn/Kx muoqS16whU2a2Jl9dIUmXY3pqmjX40JL7op2X7QP2wX1NKkbF9INs0jdCPU6ke6AvFyBKVtAyrJF rywKMwAAAAAAsE0xEfZVKNYGrO1HqjCLd2d9XzBDmvduDvbalGLudlnfuqEwi6EgC6/gu0jz07D3 GnPrvPdw6AZo77328PsqEvu/MEfIhX6cuw5grxHoyx16e31d4Vfy1xv0PjvnuLmpzg5/K9p30Z4H XudUMfDnRboB4VYuBHzsOXBKaEXfdnb73DltzLnKzgM4X/Ea8+3anQAWdlO0r3reG8NggytE8p/5 fcEW3mCj3HeiYLbNfc8BsB1Pa3cAWEnuM2/Oz8H/PSgVAAAAAIDlPazdAcCYEmrh/UYUxB/b4I3r Gvsc3vguAAAAAAAAABvwJwB794/UIBDFcXxNbWllYWXqnMC7WFt5FT0I4wk8gmNnbZHWsTC2uAjL Lm/fLn8iysj3M/MmLBBYcIZkIuyPUAsAAAAAa+UewLmxdZlbsSgezXa7a1plZ7z0OsyiFAEXYbCF +Q6ucMEUMsyiDrowbeBF+D6/3bKzv/hZ3emWFCixpL5UlhpuMWd32oCIuhW8+ul4nTrgIl7uOyrb fowdY94Oh7Gd7L6G+2gqnO60fxBhFl74ZOTG9tHdweb+ym6EpEpZLa+ukSYOrYhCLoL3bprAi3B7 4WhPpmmf2/Xebe37gy2ubD3L3RgfYuHmuUCLE9EOB2OS1R6ussyYbpdzp5PBFwAAAAAAQOXB1q53 LQBzejJ1oMWnsmzog7/avL5KhUuMCbI4NtRCa+dKHl/uHORe5bQ2b+zD1EBK6vf6vnWGbrsv4MLt T4ZdaO0p4RYb0XZV2NrburN1OvH4pHtbH+KY5TmQASDhelOvecfUkGua1lcA63P71x0AfsGFrRdl fur+Bfk9R7tBKBdikZrmsxaA5toQMIX/7WyGbWqfwQAAAAAAIMbvTliaV2Ve7l6q3P9Wxt7vlbpv Ykh/AAAAAAAAAKzAlwDs3U1OwzAQhmGXRRCsOAZLOAFX4ArsOAY3gdsACy6CWHXDMjhKTSbT8U9E U1f4fSTT/CitG5VQYWc+Qi0AAAAA/FfWDTj6xtlz3x5zT9R1nf95Mds2D7Fwu9AKGUrR/7YpvGJ4 nMIswnI4LgReyOcJYRjHCLc4lXr5hFukrX9+xl+TKRPCut9cB2A4Z30OU33s+7Hu/+d2G+nGZn89 96ZFn2ZBFmLbIWZJEWhh033U6QzhMVRWClWUsoEWounKS7pi03ClvioLtbj27daNxej0S/du3o2N 2w+zCN1ITdZLFZeyilg5dWysIAST/QAAAAAAaMeLb3e1OwE07NuNYRYfkf1WgXOrQLtc1ttiBdWt QIvSgIpDhFksCbKIvU/rHKTOkT6XetlaL90HLCU/T6n/54f9qXV5TGrAR48h6OEVue3M2eMPMtxC jmVYYxvD+ptvD749u78HW7z79mr0V4Z96zES6/qQuhZZwT2loRW5IIslARcS1x6gHfe1OwAcwWVm v/U9JxZYYX2f0ftigRe51wTQpqfaHQBWNoRa1Pi7d/qTUwEAAAAAWN9N7Q4Ayldke25e1ZJ5DiVz uax9sdcFAAAAAAAA0IgfAdi7f5yGYTAOw5Z7AFYkhoqxV+AyZGXkIBykN+AiSJyAtQuMEJwS118+ bMetAo6S95GsJrHbmPxpBxz/bO0OAAAAAEAF/gGcB1ducw33+2ez3e76tdbIedJ90MQw4EIGW3RB FeYUTOEDK3yYhQ+58IEX8n3hc9vB/uKmGe8h/445mF9/2sH5qO0vj0/IJog9by6XfQBG2N62uWfO w/afdsa8HQ7nd04GaojwCr3tGLxhbWg/QTAEgRa/df2zoo/67Fvxeixde72tL5u+TiZMyPfpz4vN cnDt2t2UHbM7EwIr5G79Nr+bjRnuVq6nii1ok5uQIbYMAAAAAADWpZtg+r52J4AV6wJxH0080KIk tGFscvTcZOuyfGZepy5faln3Q/dhbBL53OTx8hiZTBtdlzoX8/kHDpYodl3m6nPXsL7+S0NrYvdX 6b06du+/uNK48n7pAXI+XHky4/d96jsw9b1YGl5R0q6kD2MTN6S2AVi+xpWr2p0A/sEuU6fHL6TG NujxEOeMgUjtg7ETABpXtrU7AczUJb+TJWMXAQAAAABYE0ItMCevI/WlYxVS41Z0nVF1ej0VZBHb X2xsBQAAAAAAAICF+RaAvbvHaRgIwjC8kSiApOIE1DSIm3ADSq7BOSiQuBFXoKBLR0EVll2shfF4 xt6YH1vO+0iL7bVjJlYEkX/2O5q6AAAAAAD4A9ZDNfqB2ePUbod2tF5v0s+TVl87xKKEVshQivjV muCK7wCLEmaRwy5KyEWez9vkJvdTwjD2C7fw3n69sv+5jKM/v3qaguYSNPD7x6c75n7Jg1i1wiPs gIvuvpqpfG1uu12z/LzdDpTTbJ+P++dUrWs1q08GWvzgIBFmYfNqzL1RTEtfmZbUhxi6wRYy0OLd 6I9iKj95ZXmd2lmq62U49eUitcvUnoxfHUO7jJXoL8uljL6Bqqwgi6immnyt9Sa8fgAAAAAAsBxX qT1MXQRwoN5Suw92mEVWM8B530D2mTfg+9hB7r111rw11fNWTdaDzV6fdWxqBoOvHSie86OYmvwM 9p3n17zz+971Ar1OXxrJbRfsLHB9LUJfYolqmxxscZPaY2obp5Y+OdDiVdQRjFqDmpfvUf8d2TfQ oyZsxwu5GBNsAeDwXE9dAPBPTiu20d83agMs+r4PWKEY3BsBQLqbugBgIcYGYPA/GQAAAACwZOeB cHPMi3zo2jsv492vppf1uhCG74sYuncCAAAAAAAAwIH7EIC9O8ZpGIbCOO7CIdhIBhZuwQ24AWLn Vmy9ARsDEiMSF2CArRMTI6lD8pqXJ9tJoDRR/f9JVpL6NTUSShB1/BFqAQAAACA38kDOnW8XqcL1 +sEVxWV7VPXCJCRooh9woYMt3E9YhQRTSICFDrao9yXwQr+nrhsfZBFil5D/neWFSTTb5YynGdBS ggf+J9xCtjrgIvz8eT/wQvd3re7qfpeburfNRpW3Bf3C3Xkr2eoAC/lM9dpKB1lIHYEWe2fHaJ9c tCslSUBFrWqDSkKhFae+79v3BcMtVJ+8ZldJqI/PfN2nbx/DF88r317tx7guxEJek0CLlTmWgItQ 2/24gT7n+kO2bB4Ik/4AAAAAAMhH6dvj3IMAMvXimkCLr0h/aoHz2MO8qRZaVP0vgRZTQy1Ci7nH wi1CDzuPDbMgyALHbB8BF7Jvgyjs1u7r7xxS4RYn5lw62ELv18EWN77du2nBFs++Pbnue5FYqEUs 8Dt2zRwKpAiFU6Tqhq5vQ9c9i+sSkI/St+u5BwEcyLk5tvMaUvMXQn8L2fkRsUlFsffbc3H/BfJ0 61sx9yCABTjUvXDM5FXuywAAAACAY1LOPQDAeJ9Qa+dexf5nE5sHEZvjNbUGAAAAAAAAQEa2ArB3 NzcNw2AYx90ckFCEyoEZWIAFGIEFuDMGNxZhAAZhCc7ckFBOKDiYl9hvXycOoCZt/j/JykeT2KnS VMqHH0ItAAAAAByb3Auy8fwTX+7GNlTXXV8dp8m8NMTCfYdWxGEW7U8JwRV9gIWEWXTBFRJyIeMy 3W2jD8KQetqk/nLx+8S/t7wwiTBcTntCg5YSQvBf308cUmHtW8iJ2CSfW+uk6/c/xe5477w1TQiq mHZwJ4EWrdSt2vpVd1Ul86fWRaDFrtL26d6WZJ4MpWcl6THJCrbQSROVWkf33CTbrn3ZloVaXPpy 5cuzbkJUjTRj43bDLOLOnnIdHQ112mR13uTUutZO8FIoAAAAAADH6dyXJ1+2czcEWJnGl0cXOmW3 5IIXcqEO1nVCqzP1kiALq0P2v4Za6HFrOrcPeh/192ANS8c1roHi0MTHbOm1/ynX+/W9hdJwizaa dtF0a4x3wRa3LgRbnBW06d2XB5eeH+Jwi9w9EmvfrHOkdZ7T5WPk89w2hs53uXO9ngdgHW7mbgCw Zxe+vBYua4VW5MIqcuEV+rm+KfXynwysw/3cDQAOXO5/dtkPqgIAAAAAsD/XczcAUF4mLj/2HIZe LvecmzPWGaqP+zQAAAAAAADASn0KwN4d4zQMg2EYttIzMCAGsjOwchrEARjYmdm5Rm/AeXoEWJAq CC6JFcfxb/+hKY6a95GsNqnjOFGTDnX8VfkqAAAAAHA23AM4j7bUqYrb7Zup65tuqRmESbRhFk0Q cOEHW7SBFH04RRtY4QdbHN4fAi+GgRh9O27SfdfGcTRjSBSteMe7BMvrTzM9mOGEjjk/w5CK8H34 7Hm0hUE70ufO534v9qFbSPTPjOt1ARfhuilhEVKYxymV2OdUuf7FZh5wr5X3+ltsW6N1QtkE24Xt xWZDuLT1rnTn8870gRX+bt06t5uNGe7WX5ZKpaijuVCW/cUAAAAAAABzebXltnQngJXZ2fJs8oEW UnBFLgwiFiaRmoT9y3udq8Ta/RaWtZPC544599Bz6s+ref7YAsqKTQ4Q+0y6TjT3GOk6TYVAaO4J h2CLe1s+FMf5Ysu70I7mvqIJnvhrsEW4be7cOoRYAAg9le4A8M8uzHgsgyaIIjauIRVsIbWRqqPd L4Dz8WDLdelOAAsz529fbiAwv7MAAAAAgDWoS3cACOwi68JxC7mxV1JdaaxKuJ1UR9oHAAAAAAAA gBX5EYC9O8ZpGIbCOG6yIChSJcTMAZh6IcTKys7AkTgC4gwcg7lIFVKwSU2cl/fstEJKmvx/0lMT O0rdqPLk+CPUAgAAAMCcWC/Hpu0Xvh5LN1qtrlxdn3fauiEWMXAiDaWo/6oJrmgDLGKYRQi7iCEX 8TieN2EWrnNMuEXZ9MYzocG4w59PkwEg3wtvjtMwiW64QdvftsvP7rXh/7xe3/y2bHe7zHiMd+KU 0IuzGGaRVmivql5bzhjBElMPswiOGaP2L5C7D5hBFvvQC5k00atw3f7aKrn/pa/rYWO+c81mkbks jRhukYZflH5COhwryKLULx+fG9AOAAAAAABO05Ovh7EHASzMq69nX59Kn/VSbi6gobQ5u7bpugyf kJvMlwIrvo127d7HhFnI3zYkuCP3IvSQTf6BuRny3y8dHxpuYc011twg68PXvcsHW7z7enP9uUSb c2SfNXbZnrtXbs61zq1nmAsZkZingGXZODbSxvLcGu25hUDy3FoLoV2v3Yf1EACil7EHAJygUnDU f34PAAAAAABzsBl7AEDiy9fW6MutV9DWppTCLeSntrbFWsui9QMAAAAAAABYiB8B2Lt/pISBKADj iyVDZWNhwVhaeQW9iS2dp9COo+QI3sU7WNhhliSzbx+7bzf+C+N+v5kMIQmwMJCKzUfUAgAAAEAr pskzu365sQ7sule33d6O9w5REGAKTcSBCxm2cMdYRVgfghUybOHXffAiDmKE55F0jOBnAg7ELX7b 8B05k8GM6j6fMH88BCriueVhW2rdJfeFIEY8h22zuTzefhhRi3h4iTlwOlaxCmP3MYuV2ld+ib+d Z3caCDk/c8eYu3rBVH+IKhBjjKJUhjiJW/gxidvca171+6/rxn7v4mCFjFJMQQs5jNT93HJRcQwX bQAAAAAAoG0P/bJfehBAQ3zE4qVfusx+K2JRu1gXbU9FLkrxilLEIndx+lTAoiZmoS8Kr9+XvpWf kbWuP2cmNqM1Nb8HKwxjBRpqftel85Dc58MWz5n38e6Gi8vmzkVzIhvW9kPlc+aO0ecxfU6zIhbW NgDteFp6AMAC1l94TCpYobdZsYs5wQsA7Xh0xKWA7yJkAQAAAABA2d3SAwCEN7Fu/b/EOkZut2IX qf9FpF4j99y5x/DfCgAAAAAAAOCf+xSAvTvGaRiGwjgeghqEmJA4ABMSGxIX4QgdOQIDnIiBm7Cy cwLE0g1wFdzYr8/JM1R1W/9/0iNO3KYOUjI5/gi1AAAAAHAotBdl5ELhJ67up07UdZ37exodi0Ms +opDKb5X5cMrfIDFsD+EXPi23+9DLZqoHYYiEG5ht0vj2c9wi/hWigMN1t8v18MvZJhF2B5CL2az /j77XCzsF3AUhGbIwAotfMF/vm2jz62fdvvhErseZrG0iTFOrVwwFmhx/Bt6IZMmwj4ZkNEG5z9z dW67hitXt9rPiLYfsgyzGMvjsC7KMBZ0wcINAAAAAAAcrktXL6UHAVTk1dWjq7dEfyqUITyWE2Ax tWi7Ncwip76UbU6ghbyW1AL6lgX4LS9XAzWy3COW+ysVbpEKuch5Ji33n109KGN8cvWhnNMStJMT TJF6hsnj2vXmPLuaJv4/y2MA6nVXegBAAdcjfXKOQmpew9icB9ln/Q3mRwD1mZceALBlFxs4x3/m HFq+O9UHAAAAAMC+uSk9AEB4/8N3tLklsq31ya02T0XbNol9AAAAAAAAAJX4EYC9u8dpGAbDOO5Q xMACK1uYOQETvQkcgLNVsLHADTgGK0zdqgY7zUvfGH8kitQY+v9JVj7sJE5BQcipn9O5OwAAAAAA ByBfoHm05TrVcLV6M3V900363/Qm/5egiX7AhQ62MG1YxX59F1ihgy3c+mbTeIEY+/NoOkQjxtVN n3NeLjDtRNLPUubpL6k/EmxRUohB/vPpz6svoQ/xgAt1ZJWr21ksztrl53o9/ga8c1aBgIs25MJ0 gRaJ0Io5fi4l/S6ETO2fO7oJbEv6w7ZbOo29VvsMNOlkCEmV0G/GyblCMx7INa/s+b9s+cgHzNza 8t5dRnen8vZJNypvW3fFLz+3G6gzahnqpP44/Y8WAAAAAAD8bZe2PNlyMXdHgCPg0pVdgMxLpD42 iXnoi7v+dmqi+VRIRGri+dj+1PG5a48NpfDvP7RMrZsB+wHEB2tDYwOxcQIZfxBbb1uGVXSd7KsC bfSzwAVbuMmt77u6Z1teVduTxPEyRhIbF9H3mQvmSIX06PXQMzL3/Is9+zSeY8DxeTD8r4bjdD6g jfxd1+9A6Dq/nb+eaqe3Y6+fAPj/lrbczd0J4MCmhFqU/UIqAAAAAADlqufuAOAZE2qRCpmIhVno uiHvSBBoAQAAAAAAAOCXbwHYu2OchmEojOOGIUwMXIArtCPHYeQYCImdmUv1IAwsnTF2g9vnFz/H FQK3zf8nWXFCFV6gNUht3keoBQAAAIBLULoZR9/sGm+4fZo70TAMzvub7FgeYjGOPJTC70cKr0gB Fof9Q8hFmqf9MdTCZXM/33w9q293wYRbFJ1SPecSbpEHV6St1WdGB13or8uQi/y492Nfm8/t9rii RXhFPPfk1SJCLZwOu5jU9b9O6Xdv+YsaZScDvdLI1IfU7SgLsgj1fIUn6i45Is7j8bAvH7PvNBRr /3lSpw5FcfG/awu1iA2Z1mFsdAmitBRuceWmYRZZKYUhL1c3YJBbTR4vXQRNGwAAAAAAOF9vYax6 FwEsQLzZ993ZN/3WghqsgIdS83WrIbsVQvHbUAurcbuuZ66hu74m6/qtn5Geu4bjAKasN2vl8dK8 dj75fkQpnNupbXrN63CKlzBuw3gI49WNIRK1deVabUvft1SvXLfkmmYFWLSsrXpeWwudmLescQAu 22PvAoBO7tW+/rxC7f8Q6+/8MWEWABA99y4AAAAAAAAAi7DuXQCgfDQ+rjWQouWzYrXHWOcGAAAA AAAAsGDfArB3xzgNw1AYx5+5BQNqV+6ARG/CzMidWHoDDsABGFkZmMPEVBGcNk5f3GfHUCSH9v+T nkgcJ7gFBUSMP0ItAAAAAJy68M+u976WuY7r9ZMsFtf9Xit6/fMQNDEOuNDBFrINq9hv7wIrdLBF t73ZtFEgxv46mg7RKEW4Rd6cxjPvcAvXbzuVBTFe18a5ccXtej8tZAKIvDdN2SB1QIV52A1BF8NY +v76WCt13vs5fb1T/nKM8SoGOrWhW8HoS9SKSNvvu3ZoM8v30akS+phehckaw6U/tykLtrjx9WJ8 Ghe1hUALF+1bC0Lp3A5R56UWjZoaJCEWAAAAAACchgdfd7UHAZyBZ1+Pvj4Tx38SaDFVVqhELqSi JLji2ECLXKhF/LpSrz31/sTbUtAOYNox4RbhGYR1Teu5RXiuEQIoXHTOhdrvgi2ufH3IYdC3yOE9 RgdahGtbi1anzk/dH3NVGmAxtfAC9zAAS1+3tQcBVNQFW7xN9LECssLHVJhV3EeMfet3GWueROkc CwD/z0r4OQyk/Gbu4PwnrgIAAAAAUM+q9gCAyKvRlpvHFbdN/e0oF1xROj+MZzMAAAAAAADAmfsW gL27OWoYBsIwLMIJwyUdUAIlcaIOKqACqqEBasidHKhAWJOsvdqsIoXxYAe/z4yIf2KyjmcMEyn6 CLUAAAAAcO1KX2TV27u+vdR+Udc99D/vsm15iMWh5aEUcWgSXiEBFuP6GHIhy7J+CLUI2XK8JMnC QbjFeUuqZ6nhFjHqQAu915uDX4VGDNtsEEZOgjPkWuz2e7+Y0vuigiqirPsFj+EWm00WbHFRYswE lnSNPX9Rnw61sHcXPXuSzHKk2+3xWg8pEyngor+G+jnDaDp1fWXGovRHYNsWapGSjZ769mlLUKVJ uMVNOA2zsJM4eRMkeYEX0Txaert3EgRdAAAAAABwXdLnD29zFwGswHvfPgr7al/CrU3W7gVG1EIn WsIsWkMwvNc7txyO6965eOfd+j5ZfE4JTKfUWesFWti+Btuv4PU92KDuYI7RgRZpPaXUf4e8L0Sz z9eBFrJcmqza3oNa75Wl+6e9B7Y0XYdXG4B1eZ67AGBm9+F0jEIpWEL/r1Eax+c9ynLtGPu63tgJ xkwA/8vr3AUAK+EFTy57oCsAAAAAANN7nLsAQPn65XGl8V+1sRHeeDE7Pqw0ls7uBwAAAAAAALAi PwKwd/84DcNQHMed9AKMbFRMcAgER2HlOByjN2DsEdiYgZWFvSg4TRy/Ws92IhTyp9+PZCVpSWJU yakS9/0ItQAAAACwZu7HNU+2Xaf+cLd7MdvtbbtVndS7d0ETpwEXMtjCHMMq/HoTWCGDLer1w6EK AjH8cSQZovEXhFukzak/cw638CEVrqV+Yx7WvfHhFj7kwu/fhVp85edaNUEYlXzBL0Urgu2jsqmh U7TBFv85S2pOn2nMmH3UKgvICkYupKJWtZ9xF1xhRJhFEGCxEfuW4lhatQN3zkt7rG/bPvOD651t r8ppZIiFDLoogu2wCJRs3b+rvGfEMtdJCjIAAAAAALBcF7btp+4EsHL1Tedn294j78dCLNxSW5eB EGGh9FjIRN+wijECLYYWcO8TZpG6J8n9SmA8fcMttJAL7Vix5xfu+YY8lxsbShOnjS+F2C/2TCR1 nHBs+zHDx85w3EyNhcboYx1jG3C+HqfuADCxG9velNe17x2a2JyJXMHscDISwRXA+Xmw7X7qTgAL lZsI2udanNo3dh3mGg0AAAAAWLKrqTsACB9iPTbno++chtz+uXkTQ+73xEIxAAAAAAAAAKzUrwDs 3eFNwzAQhuGo/whIsEo36DiMwRxMwSQM0SH4SbAJ11yPO8ctqG6a95FM0roEJ6VBIs59hFoAAAAA WDLvphpbCOM+tee5DfX9Q/p6972uQyXs+nEoxXBoEl4hARbTY39dtqO3KeEZ/41wi7JrGs/1hFtM QRQ52GIKt5CACxtSMT2vl3pbsr2xa+wfhrH+zV6HWuQX5OMgS/WcDqxwPyle0MVPoMUmLT910MUF tH8f57Uao62qJEupmpT7JNAiDLNI/RsTdnGYSad+f6RSUf5j8FQXapGLM2xTe3d+vBRnkKHooAt5 fDQUp+nd1W0wS0s/7+0EN4cCAAAAALAMb6k9th4EcMPy//VeU/sI+ktFy6Mbd6MWhVjYwuq1YRa1 hdlLwRZzLdpPeyyiY9U5/QAuI7pYaz+L51wv0IHdOoxCh1nUnmf09Y6h86+J6P2Izrulc2cUclF7 HtRqCz4AWI9dRwEjoD/je0pFsu3UkFMDL5gPAazHS+sBAAvz1wmgpfBJAAAAAABu3a71AABjP/+S X2rmgUVz4mq34c234LoNAAAAAAAAsGJfArB377gNAkEAholPkZI2ZeoUyVHS5jY5CUfIFXyKNClS +ACWF+Ixw2gY2ASFNf4/aSVsY1g/ROEHP1ELAAAAAFslf7J5S6OOVmyaj6quH7plHZWQkEV73TBw ocMWVRer6Jd/ghU6bCHLwyBGvx1NRzSWtmzc4u//YSopJtGSjkIJyopb9Mve+1ICFzZooeduH4dc lvf/1+FwDmhkvPFVwELvX1+W0cYPjrudumvmvn5h/dcu9p/z8wIWchRpXxWJVHTXn+clv3K7FCWc gMUgcKG25f3LUuZwn7bzncbn9Ov/lMZ+ZDcSsbChC31ZT8WOy8N1brNPU4STNgAAAAAAcH3e03he exLAhrXRmCa4fU7QIopa2BOmT8UsckIWc6IWUchi6mTulbM85znx8LkksK7cuIUNTOj1x77DkO9G jmpdHbjw5qSHDoDbbXsnrLbHqej4aoMW0bF2buRiKnYB4La8rj0BoABR2MX+VuEuWPZui+IV3nai fQPYlpeKz06BpZT9A1YAAAAAAMrwuPYEACMnajEWmRgLW9h1vHVz9gEAAAAAAADghp0EYO+OchIG gjCOF3hSfIDEg3gUvYVvXMF7eCVu4gF8McHdwLTTcXa7GGHX8v8lE8i2LEPSUqN2P0ItAAAAAPxX 3g039mbYu1CvUxOt1w+nXQc6XEJqHEpx6EvCK3SAxbH85zKPnlPCM67hb8IkUmul/GKmhsItWuol qhluocMpxkEVw2k21ZYfbDHMpY/5r3CSrJaZtXDi6+05cuqtPxrjPjrcIs6nxhZm/0toPcwiqt2j XUFJxiJZ4Ug/2gCLUcqEE3bRr0KkjhlZteg+1LYs1CImHT11x2CLpVML1Yo812EWo1acko9t62Ae LT3ufQgWcAAAAAAAoF0voXa1mwBm6jPUe6h9YvvUzbnyqH9/pxdy1wuje6ESlwiyyAVa5MItvBCL klCL1FjnbAfQhly4RerPMVPnsc0Pzy06bUMs7LjuwfaRCuTQc57znVoSXuF9T9r3tmMAbs8m1HPt JoAGPDpj3vXcXu+77ue13vvZIrXNe50XosG1Gpint9oNADOTC4kCAAAAAAD5gGegho/C/UrCJUr/ byI3nntvAAAAAAAAADfsWwD27uCmYRgK47irXishbqhICIkF2AD26R6swbkbME+H4FCJiDip65fH s5u0oQ7k/5Ms2w1N3NCEA46/zGqRAAAAAPBnhQduNu7ExKLt9sOt109NWy6wH4Is/PyKdLCFa8Iq YrsNrJDBFqGt3+ePVVXdscggjWuIn/Givbix5qCMM55xTGksnv++XCv0xGszD/Qz491Ai9Sz5DEE I/ZT/DWwWt027c/93hjHolNb29Sgj8EWIdDi2Pe1CrkYW+mwiD5KjdFalSDUIZxiefg9ydQImSKx FNtk2IWVNmGthhT6d/V+7vudhxcXAytyhw7thdFPFWu4qYstZ/pfOgAAAAAA4D3W5b30IIB/aleX N3d+oIVV9ELquQXWvw5F9y8tcn+6lttzn6HPQu/OaFvncEL/NQGgWNfoqYUIrPuDfi0VINH3vmdt G3KfrNRxhgYFpUIs5Dmy2gDmzQda3JQeBDABOtTinLkJqWkbQ7cBmIdX187VAubu4Zf2y99XAAAA AAB+ei49AEDZGa/pOQ+p+SHOqPXP6dpq6/en5l0wnwwAAAAAAACYsW8B2LuDpARiIArDw9KgVZaH 8AJeyKXHcOd1OAlrt97CKhYanIr2NOlOg+gE+L+qOJgAEzIULIz9CLUAAAAAcIpq/1yjC4Cn3J5a T5TSdf55NemT4RIyzGI8ypCKj+/wChlgMbb67RJuIQMyxnPMt3eDcAtbT3PZ+u9wCxlK8RNWMfb7 tfdlGIUOuJg+JqWbr+P7ZnPA9BbVYwmyGHSghbzvEU3Xpk+9zXHyTirXTTWdImGGWVTCLmpj5ZzL 3O5ia3Gf24MzjRJ4sRC3ZVCF9xIiqTGtcetF9HOhAQAAAADA1m1uq4HCqMBfWOf2ktubMe6FNliF 3q2C7q0C678NsIgWcvcKzXvF3HW/tQZ6/Tr6KwmAhkhRAt3nhfZYQT6R362QnsjnoPVc+37uRUN9 IusI4HI8zj0BoCOlqLa3B8Hb4zAMu3sb9hmzzqX7vMcAOB3Pc08A6EQK3s/bP3hsfMcCAAAAAM4V oRboyWtjvLWXwdob54Ve1MIsWnvJDpkbAAAAAAAAgDPzKQB796+UMBDEcfxQZygcRhtn7KS1srby kXwVX4PG2pfwMewcKloDd8iSZdk7AsRJkO9nJpMLF8LyLzjmkt9V1wUAAAAAQAvsCa7Ja5weSnea TD7CePy4bOuggDrIYL4VbFEHUoRVWMVm0IUOtpC23E+m9Fhprukgja7IYx933Xt5Asefw9ROPe3o Uy2JfF7/JqSgPtdbB1rsPv/cO9d8czu2L90+HF4v29PZLNyNRg3KG2y/ERJekYIrbL9aXtcht7Xw hetTUEROX2pMVczNsrw3KeWhWs3nKYgiBbio29ZhFrGvin024MKuV4V83Era7n3czjROX7s/A89x +sw8zOVqc7o9MMu6FC+3I6j75YItdhVpX1oAAAAAANAvb3F66roI4B9KYTHvhf6mF3K3yzYAoirM SxdX/1Fzr8/bjrecq8c+BznyVDq5uPSaWPzPEThN3sFa+32W4woDs773vZdjI7qt9zcXal1Z9ua5 A4pe/bl9X9PgDW+fbfeZIey3TwRwHsZxeum6CKBH0oAeb6hH6W+LHH/gUN0uhVhI/9aQE6cWAKcp XTyQ32DgcPv8BgMAAAAAgF+3cbrpughA+VbtJuO5Dg2kyI2V8MIvmmDMBQAAAAAAAHCGFgKwdwc5 DcNAFIYTdQFErDgFS24E7FhyKS7CBVhyCcSuYmlsEqeT0UxiEChO+D/JxKRuPW2lFNHEj1ALAAAA AFvjXWAj91/E9rD0QF13GX+eN/I8CRkuIcMscpBFH1ARxuCKPshCh1mcbu+DL8Ik3EIHZIQ1kywM hFv4aqol+btwCz/AIs11mm86b9ofQjuOsx5P13o4nH1t34/H71eZ5hOBFWHYNq2qM/Xz9hdfq1rC Ijw119cO70lOfJBHDJ36kFc80m2SMjEEYcjbxzPpRIBJXrmoi+2qLNQiJR+lC6dfnDJaUUruyzCL SSlGs562XkzKeiPlfutJEHQBAAAAAEAd7mO7XbsIYGc+YnuK7XlmjHcRrhdqYS16bgVYlCymLsMs vFALLwjDWpDdW5Td+3+jdYHx0iLu1msHYNus7xf0dw/62GCNl1nist+I34MYWxJoURpq4YVTzB07 vQALPYfVB4C7tQsAKnMd26ux3/t7whrntcbY6vvIufTcAPblce0CgA0o+dy1+j+dCwAAAACAvbtZ uwBAeVseMpoLt9Dj5s4lmwu/sO5vjQEAAAAAAADwD30KwN4d3DQMQ2Ecd4K4sAASJ3pmB8QoXFmk VzbpCMzACiwAl16hxElebF6f7YBAMen/J1mtm8QxkbAq2fVHqAUAAACA/876Ic5DV65yF+12T26z uZmCK0SoH46CLUIgxVCGwAo3hVz4YAsfaOGPSciFXCfFhxD411gcpFETwi3SauqL93fhFn2rRnFT aESjAiS+Bl6E/gyfHwdetO15//q233+zW024yxho4cZAi/icpm3D+fr4D9UcFiFq7aOEi8R12elA dj7qdzgaQyoO0WdTmEV37EMFWJwZ58muSvpJyD0vu3Ze5wVb3HblOXEbCbGI3zeqHnfFyu1w0XWp TRxKnWTjBgAAAAAA6uN/+Pq4dCeAlfGBFtuuvCSO58IbrOCHXJBFKmTCCqSYW96NNqx6aiP3UpiF 9Xemnkfu2QFYB2uiVv+vlzallnkReR9P6cj8iNTj9nKBFnp+3xqr9NhnjcVzx8jcmBljHARwv3QH gMpcZI6lvjvkQqz0giK9NqK00IV1EcA6XTtCgYGS3wx5skKlAAAAAAA4RXdLdwBQrKDxnNS6Bx1C kVpbZq2ly7VfWnsGAAAAAAAA4IR8CsDe3eQ0DANhGE4W7QYJEBeAHXtOwH24BDuuwYW4RA/Armvj KnU8GWbsBFWKSd9HGrV1/6apmkhN4o9QCwAAAAD/iXcSjRy/jfVWe6Hdbt+FsJ+M5XCJMAmzyEEW YQywSIEVKcwijQ23hxpCL8Ik3EIHZITWkiwMhFv4Wurl5FLhFjmkolcZEdb55fr2knPO85z+38fj 3OZ+BVfo+3sZYJGCLcT4GILxB62GRUgt96iXvTVTkpX6IGdFcsMszkEY8v7x6LrTMjn/PtLsRjex HuaFWjzHeon15bTRi1bSdRlmMWnFKOtj60Vjfaly3Jssov2NDAAAAAAA23Qf6zPW3cp9AFtyiPUR y/szuRbkUAq0sCZPt8ItLl2l4Ayvx67Lk8d7Jxdby0BfL40B2BZrP4PeB1ELtpC7bXSuuA6xkLt2 5ONSOIY1gaZeV3nrwFL4Ty3gQr9Xbf0I4Lq8xnpcuwmgMUt+E6Vj+vSBRNbl0tdk2w1sx/vaDQCY jW0wAAAAAGBLntZuAFAOxpgVLOH9P1N6rBdkoZ9nHWNReg8AAAAAAAAAV+pHAPbuH6dhGIrjuKNe ggm1M0MPwGFg5jRcgrVH6MTcO7BXjDCR4qR18vz67EQUETd8P5LV/HUeUChSHP8ItQAAAABwzSpj +cm329xJm83WrVZ3XXBFIEMmwrIOoTiGW7hTYIUTIRdOBFnIkIv+nKa/uo5r6YM0LvtG/IUSwy1K mbt/nuEW/bnHLIiq67MPvQjHxc+ay31hWb/H23CD9vds0a6/7feJMuyvQT8dF9VkBF9UetsPlBwW 0Si5Plnb2c/OxbMchZCKwymk4iC2dWEWfl+tAiwWxnF6VqXomr6PG9/efT8jgi3ufdslLhNCLORy pdZlKVZuhxPnpSZ1GCqSh0YBAAAAACjHs2/rqYsAZuTVtxd3WaBF6iHdoQnSc0EUTftKHDc2zCJ3 /aHJ2XMPGhNmAUCybtIOBVpY22Sgd1i3bsnIfmWYt3Pn9z90jfJvmxU6NHZZI8QCQM7j1AUABbLG 3+nPdPk5r/8XsIZqpF6tZl3DqgPA9Vr69jB1EcDMWINIxw4sLXcAKgAAAAAAv285dQGA8OnbR2Jf 7n6IFUIxFG6hX1MhFtZYNatPAAAAAAAAAP/QtwDs3U1OwzAQhmFnw6IFCXEKtpyAK3AElhyDG8GV 2LDtBSqMUeJkMplxwo+I27yPZNVxlGpiVa3UJP4ItQAAAABwKryHZeT4VWpPc2+031+GGC9GYzJc IgdayCCKNtgi9mEVuX88jgMs2rHhGLlPB2TEU0iyMNQUblFfmET7Wk89vwu3GA4rPWc+DbCwnk1v 902fPc9BL++Hw4J6mn6SYxdUEa1zUwEc/dgPwy1qDovIaq5xrjZrtSQr9SGnRug2SpnogjDk/v7O OfH5+ehq2qV2k/oLQi1uU7sLbbCFVUYjSsl9GWYxKsVo1mnrqbEmUo5bJ8FCDgAAAAAA/L/HwGJs wF96Te0l+P9zLQ208BZIL4VZeMEWVpsLt7CCLHTfqyvXLc/J6pfmxJozANujrzeUgiy8axNf5PUP HewdwvR6hx6bq9Frpe9Ka6EGPe4ttgBg265Te1i7CKBCO7W99P6DRvX1tvXqHQ/gvD2vXQCwMfzG AgAAAAAwuF+7AEB4E30vYGKJUliFF2wh95fuOSsFX3ynRgAAAAAAAABn4FMA9u4ft0EYiuO4wwU6 dmDp0qFb9p6ot+kBeoEsmXudds8R+gdwCY+n5z8kSHbJ9yNZNiEhTyhypAT8a0oXAAAAAAAXsm54 felaG3vR4fDu2vZxGMs1zGXIxBRs4c7hFD7cwgdS+PAKGVrhhiALGWwxjv3r/bHHYAv5nrqO/2Q8 R1cexa1xrco6taynvnp+LghRsdaacU7eVy5DI3Qfv0dd7vc/TXycTolydvM22zU9NqtDBVkMfdMs CrWoOSxiVHONodpiMSmN7PuQCvXYOcxC7JMBF1baxGzFpP6zILbvu+027xw+uymwIvbW43hnbIea Va7VUur9MAAAAAAAcBv2XXstXQSwIW9dO7r8QIulC5+nwiu+FrZvo7eOlROCIWtNBV7EQjz0+aro 3wsAhcQWH0jNK9ZcFJo79djaH5tzcwKCrPkxNBdes/ADgG3rAy3uShcBVOrpr49dixC6uCi0Hbpk xBrHnptzbAD1enAEAwOlpb43+V4FAAAAAGzVvnQBgPKZ8Rx9/YMOlLDG1j7dW8eyeqsOAAAAAAAA ADfqVwD27iCnYRiIwrC7YRFYcQF6BI7FkiOw4xqchXtwgJ6ATaWQAJOMp2NnooLiVv8nRbFsK51U bbNo4keoBQAAAIBLUHowRvePD5g/LR2o6+5S399kfTpcQsItJIhCQinmMIt+CrM4HnWAhfT1UxCG zP05VpraMn4tCLcoa6+e9eEWeUhFIaBgd/p8uM6eyAMv8nnj92H0cTjMr2X3WR1pHtPznBALt2/F ebccFjFquca1tdWiUGzqg7dlKRNO2IUes5/C26HvPlbruFjDY6UMCbzYqbYOqqidgv2inWRxBMYj 10oAAAAAAPC/3hKLoQJ/4XPYXoftvTJn6WFb3S4twi5tvXh6bTH1WtCFF2gRWaDdC7CILNbunave 2/eqoX8rADTA+11YE2xhAya839dIuM85gT+RTZ+HbQOAeN66AKBhXYoFS0TG7PhSCIYd8+rgfgjg cr1sXQDQqIetC/jFNRYAAAAAcM32WxcAGJFQC1ELmSiFWeixpXvManO45wIAAAAAAADAty8B2LuD 24RhKADDEdxYoIeqKNee2gm6Ss9dhDNrsAGbdIgyA8JN5Prlye/ZB2hM+D/JIkBIfECgCjc/UQsA AAAA9yj3T6xfYbx4Lzocjl3fvw7b8rr+MWSRtmOEYoxPjHGLFLNIYYvzELr4DVmMwQsZuUgxjBjH kOQ5loK4ha29+dTFLWKEIgYK9BB7OrfT7bEtkV5bmsckRpEJD5ixC/m4iluUgguthiKkludYOzfr qgex/vB3KyIVugyxzgQs1p1djZCFCfnufArHea6b90c3DVZYp5ZBC33fGquKfWom2e6bAwAAAACA ZduH8Tb3JIAFOIWxC+PbeN4LOZSCFjpmYd0vxSu8572QhRW/8C7Wri8Wb4UtrB9YGvp1AkCDrhG2 8OIWtxi5z8NS0MKLeAB4bH3H33GAZ2s8rhcIWfvk1jvobX2c0rFZEwHcvz6Mz7knATRq8w/n4HsX AAAAAPDo3ueeAKD8VO5XG6Tw1lDUrrPIHRsAAAAAAAAABhcB2LuTnIZhMAzDTtWqqMAGiTOw5yQc gx0cgR2nY88aiSMggSI12Ap/4zq/h1CkuPR9JBM7g+OGMqgZvuXcAwAAAACAjJIbZS5tuc91tNlc 2K9nu/Y42GIIoJCpFAmt6OudF2Sx3QVZuHkShCHBF31fZq8ePsRfmhU/o36Sv3k9cowOOyi1Hdv6 xtMPKB9CoN9bPgREBGs3w3YSjBHr1/1crFZr07Zf5rNtzXrpfVQhHblxunoYgJEIu9gf3xBoMQq8 ULapXa1jPHRcbuvOm8q8MPWhM3pohUuN2ErbhV3Y98viJ/TCvdcXXv9NsL9zu96VLe/5sJcbW25t eYkMQwIvtl6989oyjNSFf9qDHbpgGvLnj15E039zfn3xYEkIDgAAAAAAJ+7Oloe5BwH8A2+2PNvy EVmu3Tyr3XQbtmPhELlgCwme6IweUKHNzwVnaA9jT4VVaPXYMdCOFQDkhOcewnMS4embXD/a+Q3j zTNeW+tDpiXBGiWhFfyOBJDyOPcAgMpdJ5bF/j9IXyi0v04s7GLqPgEcl6e5BwAciej1gBO2jbVj y/hbDAAAAAA4BYRaoDavyrzwOojUZzIl13PEgitK6iX7AAAAAAAAAHBCvgVg7w5uE4ahMI6bTMCB QyUucO4GTNENeu9UvbJBh+oEPRQCbuIX8/xsUCS74f+TLBybkBcEXIjzdbULAAAAAIA7aYtnPvq2 tXY6Hr/cfv967Q8BFqF/moz7EAofROHDLU5jUIUPq3AiyCL0Q8BFCMMYwjEkeex4fEn3DZ/nfLT7 j9SqZT7t1XNbjM8n8OvFQ1jBtK8HXOhrzsOcu9ler/0a+J/LF2paQN5KOX4cYCHDLxLBFtP62tRy jY/WlVo5OaQ/jI9/4RRybAyzEHMy4EKOD/vL140/qS9d57Zl53FwIbBCO3TcXynbqdYVPKekyDY/ KAAAAAAALNOub5+VawCW4LI4d85Ai1zIhBZSobXU3G/U18IwtPFUAEYugMO6wXv8PjX0DwSAfyIX CGEF7qTCerRAH6vFv5tWCFEu3MIKAgIA6a12AUDjNgXPyV3LoF1IpD3G+6TmrHEA7dv17b12EcBC 3RNkAQAAAADAMyPUAi35fnC/kuslrOsnrJCL1GvE8wAAAAAAAACe1FkA9u5vx4AYiuN4l2Ql62IS 2et17c32MTyKh/FILtyV7hjqOOe0RCj7/STN0PnXESqh0x+hFgAAAABaVnNjarcvv6UDdd0sxPh5 US9DLPIgiqGkkIohqKIPsoiHupiFW8TjMfrgi+FY4eyxFh5gteldEG5ha6k96b15en9ehljIUAot uMLaV9afL0OYTKZ/y812WxXcYK7P60WAxcdodAq7ENu3GhSRa7mN92ybNiuBlfqgFS1lQhYtHSIt v/blu+5aFqEfvOqdYpydQoZZlJqnXbb2AbLWM6kDAAAAAACPtQr979QAbrcO9wm0KE2u7oVcaJOr yxALq97btnRuL7ii9mZi+ZoAwC2skByvv9X6X6uPrVkvgyzkPrLP1NpVc10AkKRAi/mzGwE07kc8 l2MStMmzvfELXrBFzfgI7VgAXsvy2Q0A/gG+IwEAAAAA8PH/EFqSh1pYYx60MXOampAK7zzXKI1j AwAAAAAAAPDGdgKwdwdJDcJgGIZjh42u7MKNuPMgegRv4NpbeA9P0Bt4DJdewK27bokJIRAyf0La wQHxfWYYQiDwo06dKW2+aukCAAAAAOAE0pdiX8xylxt0OLyrur5v22GIgFvrUajAEGahu3AL3QdV uLAKFQRZ+PY44MKP8WEZofG18/wxK57L/iTz3E8curBkLfNZUz1SsMWwzgVcuLbrH9b+eC/s92Oq 6rJtfR+P6na/L6rTnke7hmv7a/ja4sAK25/bv1Jrrm+u2uxZtLDt0x+abm1/xzsbvhL09WEWZl9j 9u3M2iZItG3l0iT8sU03vj+fGv/12u0bc0xtlq/pF+kHs3xElwizNXTUvoi2m+DyUm6HUuMSpYkb poqMf7QAAAAAAGB+r8q9TwDgfDbQ4k2l38sq+bJtbnL1konWp8It4m0draXzShOzSwEWqXuR7jnu cx0lieoANukXniP5ZxNxn1Llzyek88TbucJTr32pSRZSEzgQ/gNgytPSBQB/wNWZ43KBFKlgC2k8 gG25Nsvz0kUAG5T7v0koFAAAAAAAY49LFwBEPs8YI33eLNyXapd85k46VjofAAAAAAAAgH/sRwD2 7mA3QRiO4ziDmCxup72BFxNvS/ZSO/oGe5E93R5gJ45qhEHnn/L/t2W6UPX7SRpqLdAaAxfor4x3 AQAAAIBZWC/OyPbnprzHDrRctt0eR+0u4KILn+gCK7ogi6IPrzgVF2ax241DLNo2uY+rd8c69HUZ FjCNDOK4BZeZi/Y8zB+Oktlvm9N42v/rMOBi/C65C7d48AIixiEWepiFU5aLn+13XUfHZS7O44Iq /MAKGcAhvh8Gc+Qp5/H959i0VQu01Ae/VH2ghatrfVyxkiKemv1e0ua2bspb5BSVOEVVDE8dG542 bStpRvs+5R4KAAAAAADO89qUj7kHAVy5z2JaoEUowMIPswgFTcQCLPaiWJ/9wIu98lkLxUgZvzZn 2ab9RgBwKda1JnSNSr0ea+1Wm7aftZCCVrfmAgAtFtUG0m36bWzBbPvBoGGfIrDV6imLcesPNgHI zXbuAQA35px7HvdLAAAAAMC9Ws09AMDzNaFvKGRCC7CQdSsEI/UcPH8BAAAAAAAA4NdRAPbuHjdh IAig8Cp0OUEkKuoUqXMLLpKD0VHScxvScYAE7GXNeLwzazCR7fA+ybKz/ltLVCj4EbUAAAAAMBe5 H69+nZeld9Jmswur1Xu9LYMBcf3bCgik+EQMXMRFxitS2CKGLNJ2UMfEJcUxLndr3eveaMGUggdD Pe5ZiFv8lRR9iHGLZtRYZLTi+hvx7pgcD+K8Rb19OB5vnuNlQ+9oghYyYtHELF6m/3XIswUtrDcQ pPpDsxaxClmGkEGLTuxCbKfz5XX1p/Tt/PlY9nvGz9AOVli31ft14CK3WP2N3JQ90/0gAQAAAAAw b9ULULdjTwKYuSposQ+3BS3S2nuZuvVC9FKMIhewKI3rYEUuoKFf1m4FLvTf1jMHZwwAHsWL6Nwb HLLCFdZYKfzzE7pzyc3PeyYAz2s99gSAGXkN/cISffbJ/bl1KW7hhTIATFv1fSpRC2AYK+xUOmbI 9QEAAAAA+G8+xp4AoHz3PM6LS3j/v5E7t3ScdX0AAAAAAAAAqJ0EYO+OcRuEwTCAIlXqipQDtHO3 HKvH6RkzZ++QSDQU0RDzG9xUDbR5T7LiGGPMxGL7W/8pjgAAwD3KbYwZtreb3F7nBqrrTdU0j6P2 PjTgHGJRfQVRpKUPrjgcxiEWx2Nz0a+vX47bjf1fAxh+QrjFtOXn0+39HodQpPWpfeXzmqbrv9vv 41kEoRWjIIvxTec+g3ofaLHW0Ig+TGSNbjm39OSCvj5KfWjDLAZBF8PEiLQ9LVE6RPvbnsawKXvP l1PZzjziIZ1y8D93b/TauUMdousl31IAAADgOm+n8rz0JOCPeq9uF2gRlTSkIhdukWuLxkvvmQuw KNlAXLIRGeA3lQZbXBtu8Z326BnRPAVaAKUcqg3lnjLt0dKO6NrUmocq6Vcy9lQ7sF7tt7deehIA AAAA3L3t0hOAxC5om1oXkV6fW2M2t/4iekbuQARrLwAAAACATx8CsHf3uAnDYACGHbhAlwqpZejS uSfgDtygcy/Su3CDnqkjMxIkmA9s9/NPgDZx8z6SlT+iJBJsJi9RCwAAAAA10P60+tGOp9RJm82X WS5fj+tuHMAu914swA9R2CHhCrtuj3URi91OwhZ+4ELOkziGK7z2fwww3IK4RdqQ9+O/2785BVq0 oIX//3N73I9ihEEM2ZZn+95uS2/kvK9xgxVudCHY18UsZvP5j3PGZKwxi85f3Jv2xgJZztzlKVYh 0QovcGH0QoS7vwnO096esGg/81z2zCtziVekLhsel23tBxSLYMRGzni/WAAAAAAA1GndjvehbwKo VBe0+DT3D1q44YhYfKJPlKJ0aLGMWMii5EXtsec1iX0A8JtyYYvUeknQ59oQRu76uWcAMG0v7Xgb +iaAijwmjsWmepSsa/MeSuZBMAcCqM+DISgFlIrFpG6Ri0UBAAAAADAlRC0wJlrQoo/YfLM+c9JS oQuT2GYuBgAAAAAAADBhBwHYu7scBWEoDMM1JnPBmExiXICX3rqpWZdLcwGuYZQOVo+Hc2glE36G 90kaoAItaiQxLR+hFgAAAACmxps0I+vjJLfv3ImqahOu149WfQoIeIZYhEcQhS4puEKGWTTrTZH7 pfXX84ZHCEDb3wUw/BeEW3Qbvj86pOJZJ7/bKx0gsbLmmOs56fJczfb5cunujQyjUIEDOtxC1sVA i5DW07ETC5BYeqCF2a5apvXftIf7Z2kFWMjEiBR84RUrHSIuP+vjtmXXfajLMdPEWnZdNZ3rnrxs q6u510vuqQAAAAAAoNy+LqeR+wDMVQq0iJNx+wZaWEEWP06dFVrhBVOUhFZ459aBGl5fcg9rt67b em8AYGi53yTvYQdyu2/AhRdk0dU+AOTwUG3gPbuCfayxDEFte+MdrGNK9mHcAzAf8d77NXYngJmo wjj3OO6rAAAAAIAliPPS+Z8KUyJDLbyxGbkxESXjzax9vHFrJRinAQAAAAAAACzcTQD27uC2QRgM w7CdLFGpueQWqZcO0CG6RrfKNRtknp67A8U4gP3ntzFELaZ9H8kKYMBOhECKjD9CLQAAAADUTs5n 7ny05ZA76HK5muPxpVsOgwD8ZxMFA8RBFL648ApX/LIJtpnhMw638KUPxwjFbWseD2CoLXzhUYRb 5P12X8aQiL7E74u76z4OPhjrxwwKe1u/n2e/afzfE59BqIVNhFdE27SQizDcYrcbAi2sdkwFbNi3 yqzRt9zMBl3SQ9ufvRJoEdUbPSEi3G5vYRfWpMMtntpr57ns+7+ZMbwi16ys79e1UIpUCEaqTKnz IgMAAAAAYHvOhhdbgSWmAi1ywQ7aC7RycvSp8AkZQJELvJB1SwMv5oZYaBO1y98GANZScu9OTX6Q uteV3Du1tkraz/UbAN7X7gCwMSexLscplARS5Opk6MWc8AvGQgD1cxMFEigF/Lwlz8TUMTxfAQAA AAB/1evaHQCEr+ldBnPGmZWMxdPOLc+R2gcAAAAAAADAP/ctAHt3cNsgDIVxHITUg9VLskBn6ATt Nl2jW2aL3DgTEHXtPt6z3QbVpv3/JEvIOMZAolxsf4RaAAAAAGhJyQKZ01zech0599hN08Om3ocT hBCL7jOIQhYfYLEGV4TjEHgh28p+177LEW4h7RtusUMvDT3f3x2LXD8eAg98CeORgRZyrXkfBWP4 UIz17HUc7wuciIIrehleEdWFkI66a+9qXz+llbF9+eb49yaKFmARJ0YMHwEWVrF2RXBzOZc9h2UD h2fl0vElBmXIuVvwbbTbzm3usP3RbrXxkgEAAAAAOI73ubzUHgRwQMvi21yghTy2FuFagRbx5ui5 kItcSEVpaEVuM3Ztc3ZZp92z9WwAoLZUcIQVRCTbWOdL21pBGVY/ACAtgRZPtQcBHJD7wWe0+Qza ua7T5y98d04DcyCANi2BFoQEA20p+c8kSAoAAAAA8Be91h4AIFx26CM1DyM1l6MkuCI1rw0AAAAA AADAP3YTgL07uGkYhgIwbDIBR6Re6JkLd5ZgDYZAzNMNGIoBkHoocVLXz8bvOYCLE+n/pCgkTVMT FfWAm5+oBQAAAIA1K32Z9WVcdtaTDod3t98/TD/LG//P61MSAkgDF/MSoxWnKVQR97nLWsYtwrE+ YBHCFvL8cr0McYtcm9/n79f1cqYVXd9rjyXGDUr3xpcBi/SxuGl9/3ze7/+Ggs/jsTagb9t5wEIG EJx8bBjS53TU+/U1N2u4Ntn2EOIpLlYeBrEt6w/D+bFa6GI6/nycPG9+J4W78T2zW3Y9nlwar9Be Ng9ehO1SlEKLYGhLzTrfdAAAAAAAbMPjuLz1HgSwQT5k8eraBC08GYWwohVWyKIUrigFLrTohRaz sAIXWsRC++Jvu39oAEB7VkRCC1xYMQzruFrc4qdjBIDn3gMANsrHYGpzE6x4RX6MU9alSUb5fmsc tUlKAP7XrZujFgDa+e1n3DU+G/m8BQAAAABszX3vAQCZj8I+ax7ZkgiFNRfDmn9hzQUBAAAAAAAA gMSXAOzdQWrDMBCFYa2y6MYklK677amy6ll6jZwyJRBIPTaqlZFmJChFSvt/ICTbRJYdkhCQ9Qi1 AAAAADCK2sOmYprLe62jaTqE222X7Y+L/28hFmEJopBalxhgIeEV1+vW3kIs8tfEftd6bf8M4RYa 4Ra23xjLupa/fh7c2o5BDfk6+zEkIQ++2AIU9vuXpT5fLtZA8kALdXzpLwmuuDtH3JbjcbtDeMMI oRGWEccVwyyWdrpfFSu84rt2gi6sQAupn+ZyaLsvb2Fd3NIKr0gDL0pBFbXhlS7bWuDB/pDmxnvT AQAAAAAYjyy+duo9COABSZDFx1zOwQ+08AIf0qIDLXSdhknUwitKoRX6mBeWUTq391Bw6fr0tev7 AgAjq31X1RZHaC1ef955AaBE/tsdew8CeFDPhX21gAuPNe+htV3qC8B4JNBi6j0IAK6W32wAAAAA AP6K194DABKfoRxqIVrmReg5FVYf3rw8r28vXAMAAAAAAADAP/clAHt3jJswDAVgODCxdK5UWJl7 A3qFXqMbR+A4HIHrcAcGtpCkMX4x79kEEHHg/yQrhZhghUhdAj9RCwAAAAC50r6U+leNRexF2+2u mM+XnYBF7X9bdn703wcpyvPw0YqyCVv454rzVsYt3FwXx/DvJQMa954K4hYh4ha2x62l+71xF2Ow owyXEYt0+MKbzT6a7eF4vG21MlIhIxrtqGMW2pxnyjEa4eS2tuYKEWuSV5KrPEzb4EVYf5i2+8Kq hFabmLSxC3nc8Ar9rOZ8XXd+VkU3XmG9bbg091iLUlgRDGuk5PVBAwAAAAAwDptqfA+9CGBk+gQt tOesEYtKhPGJVMzCil5YUQtrpNabClto5wUAxuCayIQ2t88PJPQ9PgDE/A69AGDEtKhFTYtSaPti 9zak5sViFgDyVcek1kMvAnhhj/w/SNgCAAAAAPAufoZeACDsxd/33Edm3XMX7tOOqc1NrSH1GgAA AAAAAABv4CQAe3evoyAQBVAYY0JhTDTGXjt7n8C3sfSdfQA7Ow2COs54vRfGX4Z4voTs7OLAQEPj cohaAAAAAEhBzD+fjspt3XSg8XiSFUV+97cwcHGJTLgARRGELfzmAhZVvOJw8GMfsXic447rz1Oo a3gPcQsplft6O1JC9/cza9EiFVrkwrUjeiJaob9n/zFs0cvyfHAe7fb7uJUFcY0qWJHJ6EYYsPCT /Ofd7z+IOdghkPaluDZtTdqbCqzqgxWx6F8DFtZmvRlhWM6bxt2jRbktlVOHp3DBCy1U0bQ87bKt goy2nxc9AAAAAADwvFW5bdpeBNAx3wxayHFdbOKY1Ucr5FgGLeTcupiFFbjQrk1eu9wHAF30TIDC mvfOXACIwYu1gdfNavZZkYqYcVO4IuYcANJUPXdHbS8C+GNWSOrTz1CeyQAAAACArpi3vQBA2EZ8 Rn6/Tn7/TBtr++TPV+IXAAAAAAAAAHBzEoC9u8dVEIgCKIzaWdmZqK211q7G3k3pDlyYsXEByu9w Ge8ARuJc4vmSCUHnwTx8nTwOUQsAAAAAFmn/xHpKx6bthy6Xa7Jeb92+fKB/FpmQ+3WQ4ulGHa14 5mGL+rXEbWXcopqbHbuIZNTn9LdyTRYiDJbiC0Owcl3dkQxd3+HiFtrz8bufl99sAUzcmuR+ZjYr YjT3x6N7NdVBtSBDGaqQc+SQAYxfsBaMkCyuTa4p9ESCqv6Qb7PPMnmvP0zL9/yqhFabmJSxC3lc /y98mc5Z9bteh6QZrwid1l9ata9FKUIRjNDoYu+DBwAAAADApkU6zrEXAYzMr4IWMj4RClpocQst ZtEWxtDOo8U0tDVrv6/2RYSRbxMAYDDfhCpiHBfAf9inYxd7EcCIzXvMabuRSHtd23bFK4hbAONx jL0AADlCFgAAAAAAFPaxFwB4bh/MbbvfLBSzkO+FYhV95nB/BgAAAAAAAIA3LwHYu3udhmEoDMOu qFiYUaUuXeGuOnI53BnXwNKxW7eCsZUecuL4T2khDryPFDWJEvskalqpGH/ruQsAAAAA8O+l/rlF 7/eTh72UGtpstsba+8E+PaG/f5XACgmiCBcJsPDhFedzv96HWIzPkXalL1uRICCHXDenvPQzvZHb 1NGOVu7rd0sN3d+ptfQhA7lAi8EZxe2uTb/oZ6X7ieJ4OtUWNnj1bdrIxa0uARYrHW6hz/9BLYZG iBZrK9Uk7xj9zkmlPlgzTozwM8vduT4+3cMQhlxY9SrtGNPPRvfgznt0y6H8+f5sukGub0HXOpBC 9umS9XZu8r7YZYe3JnYj9f7YRYQPJAAAAAAAMObVLbu5iwAW5DcDLXS4xMdlPRZQEYZblNZjoRWx GnIhFrlAi9Q9AYBJav4u3YBFFAngz9vPXQCwcE/Bdjj+IDfmIDaGIRVsIeup8Itw2EipbwDz2Bt+ VwWmusWzUzM4tGbsfun7ne9fAAAAAMCSEGqB1rxXHlcbSFEaz5Y7JtcvAAAAAAAAAIx8CcDe/dwm DENxHDfhBANUquDaOViBDdorW3QcRugonYEj90p1SG2/PGwnIQib6vuRrPyzk0ckhAQOv2a4CwAA AAA8lH4gpnWw7TU36Hj8MpvNm9+W/9/R/plHCJxwIRRdEIVrIbSiC70I+4xfynAL19eFY8hr6mWO DN243dDckUfVUY9a7qs/U0X3d0otMtBiIcIj+kEXuhnRz1yNT1zJ1tR9RXE6n0fXlj2nDLH4a/41 NE1v+94GayuoxtpyNaUiUlz6w2XZjjf9kAq/bY8t1TEZdOH7237yfLFrvtj923H3bmdCeIUubZlY l9uxN5bO7cj1mfNQKgAAAAAA6Oxtey9dBPBESgRa/JgQSKFDKqa0XBBGLOhiTK1DgRb3+wECAAAA Y3yULgD4B9Y3jElNMNLH5DI2fur1AJT1WboA4ImtZozlcxAAAAAAgDRCLVCb78g+PadsTuhEah5b bD03xw0AAAAAAAAArvwKwN4d5CQMRGEAHmPixkQJF9CVF/BCrjwXp3NlwgVIsGQoHegbqARs1e9L Jp3MTNtHF7AZ+gu1AAAAxlT7A005/tC091MXms3mab2+2xsrX96f+zmAog25yMEWaRtikXYBFpvw itWq63chFqnX8nXK0Izz9mhcJvBAuMWhKYZbTMXwZ9OFU+Tggf1wizKMoAy+aM8tz4uDC2529Wx8 LJdxFe39gvFtpzv26tgtzmPF8dKmFhhRmmJt360pepNBLfWhFmJxuw2wCNe0c8Wa9l73zdh8WL0v TXsNbl1esg28iIIqauWV5dSCLIbMD/ntBQAAgP9s1rTF2EXAL3LtQIvDgIla8EQUbnGqf6pFYRa1 cItjnyt6HgAA/IxNaOHj2EXAH/CU+nsOett4Bqwpx2p7HQ7Pi/Y9HJuv3Re4vreUvy8AAAAAYEqe xy4ACp9nnhftVYuCMKK9bLW5aPzYNQEAAAAA0pcA7N1NTsJAAIDRyhlcGHHr2rW3ce8lPIrcwCu5 9wqmYurQ6TDTFkLoxL6XTPoD0gnBsJnyiVoAAAA1yd3Q+rofD2N/tNt9NNvt4+E4/qH+ELCIRxek aAejj1d0j4X9sI3jFl3goj1EMuJrpttTXC4oIW6RqiluUdt7e958hveHx3GLPnxx/Jz4XPf0/rG2 7fY/v2asx8rEKsL2Jo1bxOPXZpN/jQuoMRoR1Di3uXPK/QJC2IbKw+YveJLWH0KgIq1KHIUuotfI VR/C8d3+83M/b97PzTBekbtsLngRjnP/SKUIRmlMqe9DAQAAAHV4b/zgKcx1jaBFKWyRxiy+k/3S SOMW6fmxsEUuZjF2E3Dp/QAA4Hpelp4A/BO3hfOltQdTaxLS9Q2lEMZUIAOoy9vSE4AVOOf70Hco AAAAa/e09AQgEt9EXVpjlltvl5MLVqTnx65zilIUAwAAAABYmR8B2Lt/3IRhKI7jjwwMnRgqIbEw d+sRuAE9AmOPDCfgEkiuK9eJ7b5nwr86VN+PZGEwsV8GhEBOfoRaAAAAAGhlzAWtC98+z020XK7E uXn2Wnqj/tAPARQx5CIEW8hPcEXsh3CL02noDyEW8quFedLQjPvswSDc4nEIt7DZ9cQQithiRsQs G7euNR/CLKSfp585CaFwLvxFcTge83GRPPygDK3QKi5CNmZd1z/2lVWOv1S63tRMsbZba7LuZqCl PpghFn79TulnLXk9rvXi2+u42t98e1eWTqeMgRdaUIV1Cmk59Q9fffzam0oAAAAAAPDfffi2bV0E 8CSmEGihhVmkgRVaX3ufto4TO8hClL51zuW5AwAA4O987zviNx5wH1aoRaTtN6jtX9DCKs7tgxiz JoB2dr6tWxcB4CLW9/Et8wAAAAAAMDWb1gUAhf0Vx1j71kTpa3v0yue1sXJdAAAAAAAAAMh8CcDe 3eQmCAQAGCWcomnqoqvGQ/Qu3fYWPUqXHsHz9AhuXFotRWYmwwCaCjbvJRP/UMaEhA3MJ2oBAAAs Re7GmPfjeCx9abPZVqvVy/l1uCh/G7AIRxOkOESjDVc0gYs4bHF6L4xbNIGLwzmSEe4zfbyWuMXf EbfoN24+QTAiChR095R376f3quXW3e/2udvvp8UmkoBFFKvIPP/Zpq6Dr193L93SghGhJc7t0jmV jqK28lD/RlDS+kMbqEirElHQIglYlI7ch+Px8zTuf7xWcbwi19fIBS/a132LOuQiGEMLQPRZ3kEC AAAA8zktdvo59yTgTtwiaDE0SuGKUvBi6LfSuYwZff+5SrYBAOC23uaeAPwj68JnfZdY5J4PXUg0 dR+ue4Dl+Jh7AsCo8+ml51DnXAAAAO7V89wTgMTXhG1LkYmpMYup+3DNGwAAAACQ9S0Ae3eTkzAQ AGC0EFZsJFzArVtvxMpzeT/PQLRN2zBMZ4Yxiq3lvWRCLf0ZFqSJaflELQAAgDnkHmwJ13c/IPZ2 60CHw7E5n3dX68If5e+X+wDFGLnowxbNELEYl1Nhi88haHHZZxz9ccJoxv3uzRC3uB9xi7xwPpc4 Rf7Z8k0cl4jeC/dLBS+671OtZBghDFgMf29ycYvuZbtdbdDiOjSyDL89p9RTlbnqwyRk0fQxi10Q ssiOKHbR2bfjWPdZXtrx2uTjFWHwIhWqKE1tWpJJP3Baer/mWgwAAACP5L0dT3NPAv6BvwpalOIW pYjFd2IW8bni89fGLOJ18ecGAGAep7knACuyr9imdF9Cajl3j0N8zNw5gOU4teN57knAg/rpddG1 FQAAgLXzfyuW5qNyu1JconQ/XmrfW9vljg8AAAAAMPElAHt3k9MgEIYBmHUT1y7auHOtB3DhDfQa 3sLj9Aiex7UHMGlMpcWpdPgYWLQFzfMkX2BgCkN/0s3AK9QCAACYg+im1Ze6VqUXrddv1XJ5e2i3 AwFSgEW7mkCK7VFFYRZNiMXvtnbIRRNk0YRktM+ZL89BuMX5CLco227HPx8/CrBI+0uhBrtrXiyu 9uufm023QxZKEe7r6XsIVPip9np4vAFzDI1I5jiuU42p76kFKf1hv9x9NlU3/SEFVKRAizzkIgqw KD0p4bruuxp3XQ/VcXhFeOqqG3iR2tGPri8Eo6+GzO9LAwAAAJf3XNfT1IOAP+CjGhdoEW07RaBF HlLx1bMsBV8MBVrkYxp70++Y9wIAgMu5r+tu6kHAP3KTtUuhFbloX1+wRfvYpT5Dxwcu63XqAQAd /h8BAACg8Tj1ACDzHmzLb1DP556V5q6V+kXt6BzmugEAAAAAo30LwN4d6yYIBAAYPhi6MNSa7l27 9o0c+zp9gz5jF0eKnLRwgkATgZrvSy4inHqu5vAXtQAAAJY25ebSp2q8j73RbrcPZfnQOdcOAsTj GKBoIhcxbBHOwYrm+DJsEeMW5c+c9uuaOMZvMGPZvRriFrcjbjEshi2SSETH5f3k7cBFd36WXI/X iuKxfvw6HmevL0ujF62gRTtmUT/P8+7cv3zOBm1xbbdc09i/GvQVJJqgRV2MOEcu8rGRxC5Oiurc ftp3e63GWxiOV2ShG7BIQxXXljalNjN23R8+AAAAQAi7anyuvQj4B04/3H6EaUGLvhtopwYthkYa qRgKWswJX/QFLgQtAADuw2HtBcAdep4xd2zvwtCc9D3m7l+w3wGWd6jGy9qLAHrZHwgAAAAxhA5b 0Re0mGNsX156LiTH6fNrr+u7DgAAAAAQvgVg7w6SGoTBMAwHdNFNRzc6jp1x11N4GbfewpXncNkj eAvP4MYVZxCTwi8h/VM6UiDC+8xkmlJIAmMZlcB3OfUAAAAAACxe+Dxy59mW+2Mb7XbvZrPZtgIs hARY+EWCKPyihVlUoRXNMr9UQRYSklG16fc9dgCB9Nf/mfGuoX6NnG8saTjP/sgPxH8+tmFARVWv Ai6acIvsN0DCeHXtq30YhtG8zcxqtd7XXKjF7Xp9wvCygwMTjim2fisEw5WOL3CKgREixbENNSbX aqm8l/QHd1p2IRTuXJ3Xn+1f3TJXt8svZD3TTpqQbfN622+jPx1B+rzLc1PYdb+6T/6Ptnz43QRd yy5IPfzMH4qW22G8NmIPgOgaZHhoAQAAAABYkjdbrqYeBJA4F2jxaqqbarv+j9Q30EILuNBCKroC K2LhFVp/sSALo9S113DfAQAAML2nqQcAzNCNLUVd9ydGhVM5tGWhY8EWseka2jrhBK3SW85cCGAc L1MPAJiZB1s+B2g3vYmmAIDkpXifQiIGPzBlOfYdagAAzNa1YW4g0lJ4de13Pi1UQlvn1M9iARWx 7WP+uh0AAAAAwFNfe+l7nWGRf5dx6QQA0vIjAHt3jNMwDIZhOGkrJLpHYmNm603gCB25MTtnYOhE sOM4+fNjO1FLYgPvI1mkduI6ZYha2f4ItQAAAACwpdgParLeThB6neuoaR6qtr2b1PkAi/HYB1C0 Itii6gMr/PH3YAsXbtEO58ji+pGhGe4451xtAhjWw2fbvaP4O64Pt8EWLtxiDLQYrqine+tPx1yr dne+vb/D4b57/XG5XDFMEXChAytUW/f+u93iRRYlL8YocWxbjim0C4FOdtj3gRYyLWIIsjBte/us UG2+DLvXieATv7Pd0ZTG1C8ItXgy5VS5YItJhkZfZKBFLeo/xevUxn+h29YfTeifIutDN8HmDgAA AACA/+DFlOfcgwAKtyTQIhX6sGagxVzYxVyoRSzMIjT+2L3qegAAAORnv+uxQRHw8+wm22+B+tj8 gqXBFDrYItUPcxmAspxNecw9COCPOS48LxQktRaevwCA36C8hRU3qLddKFL8c56NqgAANzjlHgCg vF9xTWheW6otNodPXxPqQ/cNAAAAAJsocP+k4gYkbDE2vhMCAJK+BGDvDm4QhKEwjisu4InExMQZ nMBVHMChPDqCYziEJ29MoNVaLY/SgiH2Kf9f0kAQ4WkwptryEWoBAAAAICc54fRuZ9oi9qTD4Tgp y1UtxMJxIRN+s4EU11oLhVnYEIv3Nr/ZIAsbkmHPU1+67YRbDFmLHsMEl/z+ezt1gRDeuv2cyTnm ySM1gi3sMWeP5aWq+hbWXA/UOi2Kxj7pQ+u9iDXW9o2a5OxIP7XBJUEUog5/e2EuWpkqUUuaeO7j p0qE7rJwP2dp9l2adk5PktiYdpo0Ay3cqd1LcOvyMb8U2Z4X9usYbTd9SBXJxFMAAAAAwNjMTdvn LgJQTmOghVz2CbSQQRZtgRZdJ/TK9wAAAAA6bHMXAPyp1E22Q+MOQoEVclss7KJL4AV9MiCfbe4C gBGJfefFBm7qG2gKAECchu8uDTWkDNkX/vT10h8HAPyCde4CACEUHt4mNl4vNY4ttE+X4Ao5BhAA AAAA/sW3f/vP+V/DEH26vvXTjwSAkbkJwN4d3DQMg2EYNkXiwoGqQyBx4sAAsAFrMA53hmARJkGc egdjN/lT23UcBxLshPeRrCaOcZygKkqb+iPUAgAAAMBfSf2wVNhJxJ6GOtpud0rrC6+umVhfe8s2 aEJCLppgC9UGVsjyabBFE26huzZuafpxQzNOP0urIcyBcIt5THcsyzq3XSDE2fF34uGyrDdjCrcd 69KBBzKfv1Lv+3322OwOtLOu/QZ+gIUEW8iYJZijr+9K1Ti2kmNyQy3kf7k5BK5oL/Vho/y0iC7I wrQ9t9eMYJv7N4dij7F948lMd5embpcXanFtyp0pbyrI0GiLG2jhDvnLWU9NAiinIiw6eA259dG3 Qk89AAAAAABr8GzKVelBAJV7UfMHWuhg/aeBFrEwi89I3+E4hkItYq+xcwAAAIA62GePHksPAlip G1Nee7aFzxfEQixkOXdbbB+xffJsA1DGgyn3pQcB/BM517q+62uq3W/aAAAwxlzXlin7Xdr1zx3v VPfEY/sZc864bwcAlHJbegBA4CNSNxROkWqb8/xbX7jF0DOBAAAAALAUtXxfUMt3Dal5hMbK7SP3 2LnnBICV+BaAvTu4aRiGwjjuuDcmqNQLly7BiU1gBEZgEAboCCzBGHBCXSGYOm5f3GfiQhK75P+T rAQnaR4SUkjj+CPUAgAAAEAp2sszT66tfzpot3s1m832GCwRhPCKEDYR1n0gRdtrWpiFD7E49cnm gyx8SIY/l76UaghzINxiGssMt0i9P970fpbBBqf1fhCGHn7g+9rWHpbv+32ijCbvLXQRZtHIYIvw GXHf2eH1/qHWWFuJmrSZEMIsBStXzyEtogu2kGEWod+6/jhVopc00e0jUyVSMyOsrTWfbt+P4WCL O9fezHmgRTj18VcQJcttspS42e4crbLNiGXOi608AAIAAAAALMG9aw+liwAq92L891lTBVqkwixy Ay2Gwizi8AwCLQAAAJbhsXQBwD92k7FPGKsgxy/Ibdr6pdvkOWQ/92jAvJ5LFwAs2BjXvfoGowIA rlHJSaLmuJbVeL3U/gcYq87fTHI15mRW3NcDAKZwW7oAIKKFWnyLQyfibVowReoztPFuqRALbdzc 0DEAAAAAMLe/fg+ee/zYzwXmfs4Q38ONcf5Lxifk7DdUE/ehAHAlvgRg7/5xE4bBOAwnIHWOKmbm rj0BPUrHHou7sHfuBTpzA4IT4uTzFycxKH9MeB/JwjEYTFUEOMY/Qi0AAAAAzKFrMkm2Z6b8DN1R lr0nef7mtLnhFm6YRVNPqsAKW28HW9zCLfL6NrLc7scNzggRQ5gD4RbTeM1wC0uHWsh6U5qXie+3 5u3QC/u6+j+fA4aQ1k+67GuDKlSARX3sqaebTesPFmNohBXj2GIZUzmKKvTkItp06oMMuHCCLEzf bRFepK6Tfcoi/u/srnfFjg070x4QavFhyqcpv4nK0KiKDLSQQ76I46GN9nyBF7m61GR7149cOOkD AAAAAFiTYi76uPQggMgVgRanZNpAC1+YxbMEWjBfBgAAEK/vpQcArNheHeu1Bn3rC3zrFdKOS1tv LzACEIsvUw5LDwLA7FhLCACv5xk2iZrq+2Ks30Onej/WwZGhxtzMqu9x+QwCAHgUc1iIyd/A9fd+ rgpd99YVbtEXjKHb+voAAAAAwBgenZcf6rdkqPbc5xrGPodw76ZoIY/PuQIAWImrAOzd203DMBiG YacrgMRFkeCGa5iAfdii43QExBLsUHGHOgIqdhw3f1LbcaOkdtr3kawmIYc/BXJo0nyEWgAAAAA3 pJSHj6vTL6AaH7rdxSbabj/Vev1yDJZwzIPwZdiEfHXhFSaQwjRfmIUNsWiHyWaDLA51sIVdlv91 iBkv99tfWrhF7vdjKrcQbmG3HZXorrs63aGgCjnc9bvp2oyJqvm/XdX9u/1+qKD2j8izomZ+ne1d 01+J4AsXgqCq/nqVp8TaSqhJXslw9cg0iDotoglLkWEWbvhKD++nSrh+OY5MlfDFs5j5PuhxH3X7 Gd4pvOv2rU4DLdzi3Sq47v7PZCm+3A75NoQe8JBygaczTgm/b5QrNegLAAAAgMU5VhE2uj3lLgIo 2JeygRYhJQZa/DXzlcMOnm5Zj6/m2PrZHj4MAQAABeDcMuhNt9fcRQBX7l6338RxfaEVoXsZQuEV Q8EWvi/CHu+PYHsJzGaTuwAAQbEgqTHTpk0Y2efykSpwORz/YoS5wyQu8aCocwMYrsE565G6Ix77 oCv33YUpBJdfxTdwHGwAAEKecxcA9OxEd+gYxhdA4Quo6IdVKBW//+2se+Qi9S3OEs6V+fwMAIDb s4RjFGBGU18LmPp6+BzXPy4ptba5ArRTQkZiyx5zrYCTKiwC5/+4Nv8CsHfHOA3DUBjHTQcWlqoS OxMX4ABwHSa4FDdh5BAMbPQMFEeO02f32SGJrRjl/5OstiZ1XkqrKo2Tj1ALAAAAALWlfgyS/V2Y xfPYQPv9we6YXwd9YbiFa10AhWuXYRZdvxZs4cItfMBF2NyYYXDGHDXCBtarY3kAQyuvRynbCbcI syR8WEQ67CIMxYgzbVyghevz4TGf3+Lc9z7A4qoPJ0gU5v7er+vkgyui24twi95utzMnv/LGtHgw srWahvelOR/dkJ+iOPVBBlwEYRYixEJrw6w9H6pizlfBu7F9B/s++uq+RPLubXuw7cOEORp+NTLQ Qpb8Ix7nLg6obXb80mj/QNmvfdDmnqQCAAAAAEBrugucvqxdBNCwd9ve+vva70FLAi3k49KBFtp4 WpiGvB/Xndu+ePsBAADQpte1CwA24Na2Y39fzlOQ+0vxXAVj9LkKuWALOdko9RxtvUbpY18OKOvJ tse1iwAwixYeNWV5AMD/VSMsokZoUomLUi19Tgtjl9yPjevMjZ06z6CEpReymlr32HMAANtwt3YB QOQ4vsggN29tLPhCu9XGYo4cAAAAgNpKHCMoFTKxZPwpy/3V3PFK7bPJ9afGrHHcYElY9pQ6c8sD AAr4FYC9u7lpGAYDMGwqhoBDzzADJ0ZgEmZgDy4cOwJLcObMApyRigR2yCf/xLVrN3EMvI8UpU1D 66JyKEn8ErUAAAAA0NpZ5Pa9Xi5TP7TbPavt9mqITvghCz824a7dMMVPwMJGLOxajdELN3YhAYyv 4blkrnt53XBdqpeYA3GLZcwbtzj9lzLXeGyYInbduI1X+EELP2Yh8QqJWfixCxu1+Njv1ae+c77Z JMcziVyEbzISsFBB4MIELXrMWfQWjjB6G9PwGVLxmQik/jDUIsbPihuzkO0mYhFWJeS+u49blYhd 1WlCFxd6/W7CFvlAyo1eXtQ0aCEvL29BboePuUOJdTuU8xzTP0T7eAqTOgAAAAAA/qqntQcAdMwE LR7H27VBCxVsC2MSBC0AAACwpLu1BwD8A9d6eY1sd0/ZyE00GTu5KBW/CLcfOl0EQBsPaw8AAAAA UXNHH37jJFGnXPDQ08USpWMp+U5cErkI94/tW/p8h+QuTqsJXjCJFQDgdu0BAIG3I/c7NkiROg8u teReFwAAAABKtYhXlB7TmCPeXfr/+hbHGpY4hlATyM4dM6j5jlk72VrLKAcAYPQtAHt3mJMwDIZx vJIQCR+UcAGPoJ5Aj+JHj+FlvI6HIJ7BRAhgJ26+Le+6uq206v+XvNnc2FYJhLCWPoRaAAAAAEgp 5ibi0tZj14kWi6XZbt2vMG64hfGCLPZHJQMrZLBFvX4IuHDrcE43OGMspYQ5EG6RRinPa3Om0Z5f d1p/PcTi+zFyvwyx0N5K1bbp9NxsNu/mbb02F7OZd+mz9jSZ+jpKsEWzlIEWk8lnlfiCKy08olJa m9rao82QoKU+yIALJ8xChFho1Yzcq1+LdllHWMzt+tLWa3fzqwkebm29GDdHo76MDLSQTd6Jv7sG FWpvyL239MntbZ1HdM4AAAAAAH6zJ1vXuRsBFGpl6/lrPSbQQm73fxC7M8f3rEKBFlq4RcpAi64w jrb/EwAAAGV7sHWZuxHAPzDvcYwWWOFv08Y5xAZeADide1t3uRsB/HFXRg+QSs3/nGW8IACUa8zw iqETOuWcJGpoIEeKY09tyA+OQsfGTP7U9Rh/f46JrJjECgBwk7sBgGelbGsbv6YJjeuT5wqFYvjX ZJwcAAAAgD6GBFf3vb+v9WkPPUfs/hLDLULkd7vYtoSO6RNgMXZ/wU/7CegjAIDEPgRg7+5xGobB MI67PUAHJpaKblyCQ3ANNo7AxlV6BG7BJZBYKBNCnQj5cuM4rz/S5sOQ/0+yUuI3talaRdA4D6EW AAAAAKYkLUx9UFWwhdN+/6K229sydKIdZNEOmzC3ZjBFcZwOrKgCLJQRZvFjhFo0rQqyyMpjqrHk 7RBSCXNIJYQhlddjKKm8rqdnOns+1RrxboiFmRXRBFnoZq8tN8dtPkdNzWZzpQ6Hd/V1PHZDLU7l crhFMV7WnlCrrwyyMOcm1M0ttfCIQkpzkuZir5w0Uxt0EsS6eG/UYRWZtb8IsbBTJfTPZo2ZKrGq 57Kyxr/O933m77M3ffJwu8vbq+oGWujh9a+gH9t9ralYbV2PkQl9ytiGzmQsSgUAAAAA/Ce7vD3O PQkgUcVi2ee8fav4QAtXIIQUIiEFTviCLEIBF2MGWoQW/gIAACBd93NPAFiIG0+fdAmH63Eo4MI3 hjQm1zgA03iaewLAApwTINWX6xztquUcCwDzGeImSZeETIx5s6mYviECMvrWprN4Iiz2HB262ZRd 53sNpJo+N6ty9U11E6vQnEJ1AIC/ZTf3BADDh6quz+sr5jo3KaRCuk7Od0zstXQAAAAAlmeMAIvY /X2OH6I21BfTH1szttDfdL6wCbvO12cf63pe1//mL/2uoM/3BARdAMCAfgVg7+5xGoiBMAw7XUQB EaSHkoYgDoDgBlyD63AD7kJPATdASDQ0NCBFCsErWDI7GXud/dE68D6SIfubSRQJNvb6I9QCAAAA QF9Svuib+nZdd6LJZN8tFtXLl2q4hVNBFsu1th5asQq4KJbLYAsZhvF9zmpwRp9yCXPIJYQhl/ej K7m8r79nSq5HBlLEQitW26x7zathBPr4lfF41/98ce/zedoLCbyAkQq0cGXNRbCFb24kasrgQ5ZT cEQpt5pS67FmK7BSH2TARSXMQoRYWE2O0NNpETv+2APfnuvLPPbtzLd7V83RKJ9GBlrIkj/Fsh5Q qAcPWoEXS/Vbk+tTOoQAAAAAANgWt77tDV0EkKEP325cONDCor+HsoIjQoEWdcEV5eM2gRayjpRA Cyu0w0XWAQAAID9Hvl0NXQTwT0yNddbNpXJsQkq4ReyGZOsc8jlCdQDo1qVvF0MXAfwzsbF8sf31 Y2s59ThrX/7eAkA/2gY0dBUo0SRgou3kU3Jb0a8/M7YfunjQ4sx1Pyag6Q0Vd5Ftb749Guufflqd 0OROmxy36X6x56ybzKrJRFax0Is+JrEKnZdJrABg+50OXQAgvIrHof+5dKiExRoHp4/pcjycNc4O AAAAwN/WNLShTYBF6vlS1pXL52rdxLcTY99Qv0QXrHqLfoKHwP5WX0Fq/0Fh0z6ElOu82LVlap9B rL8g1lfQtJ+gj6ALrokBQPkSgL2zx2kYhgKwqdSBBXUDqazs7Eg9AFPvwSWYOEuPwC1YGFgRnAAx MBHqpK91Xp/jNE1b036fZDmxHduN+qPG8vuQWgAAAAAAwL6wHiQ+zNNV00Wz2bMbj2+WYgnBCyZC 2USYh2KKSlrhahILn/vkhRWh2CKUW0g/1Vh2vitykTnkImHI5X70RS73ddlTq/msSyrsY31NlbTQ IqwPRRlFceaGw/Py/Pvnp/2LCOUUC1lF4VYyi7LMaLcmttj1hztCbvIIT25zSs0nFqVA7A+lLaJ8 jxU1mYWUe4mFtkrIedhG+pB2YfQFGf9y3uZ6MHCf8iMSZzJPL25daCHDS/dyrOtEcGGlwWIM7d7Q H+bUm54NqAAAAAAAAHAMTB3B1gAsvNDiyVUbZps2waZynX5VHpZbQgtdhtACAAAAADZleugJAJwQ WmqxiVhi0w3KTUIMANg/j4eeAAC0JiaNAgCAfGj7Hb1NAKimuj76jQWJCuUSI1cPBKXFFL6dDiB1 DNz11M+rq4JbCTpwldQXRl1Im+BNqU1KqfVk61wHqEoFskoFrLLKmqQZFtsGskJ0AQDwf7g99AQA FG8drmkjsLDa6dxKuk6PCwAAAAAAp0HX9Yqu6wldRRVeXDlaHE+CchFX+PZ+PeIiMq/cuN/i2i9X l2f7Y1lL+HCrtQKfvyf6Sv3/a3q236Y/a+3B6jO2VhAr6yK76Ht9gP/OAHDy/AnA3tnjNAxDAdgU wcBUlZ2RiY0Vieswch8WDsPIMZgQCweAYDd68OzYsfNT4sD3SVYS0zgvEVXVPvt9SC0AAAAAAOAQ lPzwuLPtLjfQdrszTXPq9flyCxOILJpOE2GFNC240H1+a891RfZFmPHb1CJzqEXCUMvzmItanuv3 SMXxaElFbB25P4Ae78cf4YsuWqFFu7/ZnOy3r+967n0B4YWUtOJICyyURKNz3gLUJo9w1BTT2Fi0 1EK/S0LrgxZceDILkVjoftu3r4Bnt8dOohQZ03Fm/35u20s+zEvbrm17Nr5HQy6phRY65E91nJpU mLrt8NEMXRgiY5JcAQAAAAAAgLXgJqw+Lh0EQKU8mHaS8hxCi5RMIiWxiO1/mK60YqzQIownjDd2 P7F7BwAAAIB1cL90AAD/jAuTX/AaTi6KzV9ILXaOySz6inOnilyaSD8AjMMVAbxdOggAAACAlTJF YFEqqUj1jS0OpftcEahUoSh5zU0iRpjGVXBcKsvQBa30vhZfPCXOTeVOc+sOSsaIHevv71OKWEl/ bNwcpYWsSiWe/BYBAFAHSC2gNt4GvLZPMtEns0itMS25Rq4fDkhNa7qhCviHgDXA5wUAwHqZU2Ix h8DCHUvuQbZOYOGk2C438RfF2FNx4g6dLyjJHYgkW+cMRIYhIowh3yFLcwm5fMGQXMEQ2cXcogsk FwAAEb4EYO/ccRqGwQDslJEViYUKNjZ2jsBhuAMHYekNuAQjEydAMDF2RyFO6ub3X9txH6Ru+D7J bR62Y0VRU/nxf0gtAAAAAABgDEIdjo9NukgVWixezHx+28onfJFFvZZZ9Nu1kluYlbTCeBIL+22T FVZosUUnt6jbumyZrr7+Wt21D3pfsihF5lCKhKGU+3EoSrmv65oi7amUDKKSwgixL/P7nonQevTQ +vSz9vN7ucxqrxNV1GJfblezWS+5EPm9dARKnGRUWpu2bU9oBELaIFpbRCtQqT2ZhTtuJRbaKtEa JVZlatNbJ6QYQ8ot3PUvmzJXzbP3ZV8mae6b9GY2hRbryxtfbqHPyeaEvB1GNTEU6GHozYbEAgAA AAAAAE6ZJ9NNZAUAn2fT9UvFyBFZhFJINJE69mPCwgotuBhLaEE/GAAAAMDpYYMSXR+7EQD/jHOz OecgJpYYWvgZkl/Ic6nFzXq6hjwXW7AKALuBQAqgbLYJeF7WRFEAgOnxFwKLnOO7BJOy4+gu2LMT VNwZAkVNAR3Q6iGR93OVbOAqF8jKCS9eVd6cwMdDcopYXakgVrH8OX0AOf0GIQhkBQBw+twcuwEA io/MfLF5bfpcSF6RM9cvVTf/WwAOB/2wMHX2ecZ53wAAjE/O7/a+EotUeSupsOMOUl7BOMS4SIl2 bMzABvpy8ot30wsw5PiBJldaIfeH+v71dqxfPya7GEN0wdgAAEDDrwDsnTtOw0AQQJeWCokiEhIo JVT0VNyElo6Ow9FyACpEj6jocoAkeGIvmWxmPwlOsibvSav4s7bHlqLE+5mH1AIAAAAAAPqmZMC0 yCwecycajS7cdLr62rIqt3CByGK+VrSwopVWuDWZhRZheJmFJc5I397uqUXmUIuEoZbn0Re1PNff M6l4FqKIeSimWM4bX5dZ5OZHxJDrtHn4vyeTSJWTopnmWm7hdEx+ORBy7LMluDZ5hFBbTH3EozMj 6G9GaH3QggttjJg1MVimiUV92deJLixbxGmz/7wpX/kwb1w7GehNX1pdSgstdMgztZ5KImjddvho rIcdm+ThIeEDAAAAAAAADIH7pjwdOgiACnlpymu3nJv8Gn7mhBah3MISWMSEFjHBRayUCi28eRah BQAAAMD/hCTbAPvnuikfxnZrqIaFNY5BD7tIjT/UdRBXAOyHcVMeDh0EAJj8ZaBlXYNGAQCGy7YS i00EFrljY8eIoOJMfUrSKBFWiBz0KhUsHBWXXRF8IqvnoM67a5NW+WRWIruYu6X0Ipe0ytqW66uN rVvJp8IEWCUiTk1YfxMxR0mSqlSCLgAA2B33hw4AIODT2BaKJErG8lmUiC2sa/DfBKAf+mhrpb0W hsymvyexvAYAANAfu5JYpJJJjV3b/+CFFbeO/oihIcLsu27ZEl9ICiV5t9V9BbIu4uxt2/+32ZeS VJT0EaREF6V9ASH0DQDAUfIjAHt3jNMwDIVx3Go3BlaGVqIDG2dA4ggchJWdI3AJpN6AC3AApF6A gbETB6DEcV7rOs+Ok5QmLf+fFCWNE+chFRXi1B+hFgAAAAD+mnZD8tG4YIuo5fLNzGY322AJoYVN yNoPpnChFWYvxMKu7WLDLsJgCxdusSn72gVbyDX9tXsx5ATwYwlzcCEHvXup1oRbiDGGW7haYmMN qe+Z+6EXbtkPxjBBH+531vpcr1vVWQZTeGEVsr27vpGEjnqwxZHePGMLjrDGVlPfemIjCZL+UKZF lCEtm70wC9k/KfZLqsTUa58WbT/VOdLuB2P44RZy/avinPlkYr7kTR13Xywfph5oIZeT7v2S/Da/ HC23wwQlahNBNA2AMPkDAAAAAOAUvQxdADBC78XyWm0fKtCiKcwiDKrQQivaBlvkBFo0fVlX+7kB AABweh6GLgD4hy4SbbHnC7QHhvy28JhY4EWbawI4jOehCwCwpX3maY9N9ukfAJDWZSKorvua2v2g Cpkc6rravsyoE8h1W61lMqsnr+3buAms7KRVMpmVrK0uE1mlgipSfYaTVWnnpCa7MhltsZpS+7S+ Y+0AgMNZDF0A4NECLXLkPsNnlHajtIXHaeeE7QDq2txH7XofATg3OfMY5B4LAKg7ZoiFHYdYGBde sahe32VcH6dvXi3aWIENx7bjBCuzGzNYBeen/kfVjovd/4+dHxsjyAm6MN7+WJ+pWpr+lmFsAMBZ +hWAvTtGSiCGwjgesHDGCocDSGPljJWVJ/AWWlp6SSpvoZZSeAGXxGzk7SPJhmEXg/x/MxlDdlmC Myiw2fcRagEAAABgSKkvOeX4pW3PfQeazeamac47YzJcIgRPbIIsmq0mAyt8aIXZCrOQQRibMItu cEZMGD/1cIvh5kC4hVZTuIWfS+z68FRARdubyBALfR/9+vHj4Xm/rVb5SYUwCpGu0vnGWARYyNsT Oa73GVFt4RFObXMaYz4y1EK+GmQQxVTc/unbefymRYiQi6lqLjjlzP2/MPEqChd2+9y2j/5pXtt2 Z9urMZ3cjPBQMtBCTvnbdJ9OblFirNhDo35qsRMzEkUhAAAAAAA1ezG+WAeADXdx7FiBFqnAiZLw ir4gCz3eqH6j+qmLc2MLm1O/CwAAAByHJ+MLNwI4rKsd9s2tJ4wtONI/dz0mn/GAYS1se/zrSQAY TF2LRgHgOAxVCCo1nvsMFMZcYagQYBGCKygQhVq4AJX7xDZ3KYU7R700voDVe9svKVClb6cKSPUV wdIFqmKFplJFrPS22Bz1sXJjFLICgMNx7512+R4bGNun6KfW7eUKeup9U/fX6/1y/RKxNXjAqRoy 5HLfxwFqoD8/73sMiYALACjT9/d3nxALeX5iYfz5CdduDes1EXfTtgc17sIuQsjFsu1/tdtKwyxi 23OBFaX7lpwf6Au5SNVrMmofjfc7AP6FtQDsnT1OwzAUgN1wAgQLEkVssMHIMTgMB+jGOXoDTsHE xsKMUDcWBkZKXmI3zqvtJLRVXPp9knHq/yEShZe8D6kFAAAAAADsktCLp5JM7CQ1aT5/MtPpVSWf 8J0STjZhP1mpxVLJLYyVVpiWxEJqKTJeiy1qucWyWr8RW7g927VG5oydGD4HmQNyi92Ro9yillU4 H4Qfk4hdN/OqK0900YgvHEX1822xaJqsvELGrYlmlLTCXa/WVW1mos6B0CILtnmeVKRgZYKQ+6C8 l3yZhbQfyT1mwhIL6fuxc5x1YuKt68st3P5n5ZzPojAf8sslzV1ZXsy60MJt55Z317rPP44uhd1j GegzXt0V6CD5AwAAAAAAAOwLl2WZjXwGgNyQF2Mfy/Jt+gkt/PbQS7NaaBGrU8UXWsQkFjGhRUis gdACAAAA4PC4H/sAAAfKaaBNv+TpP0IRe6hIfw7VoeccQnuEzgEAmzMb+wAAB8j1DtbM64FRAIC8 2ZbEoqtN9x+bOhmUJIWSJMySKEoSMV/0OA9ArpzboqUXTnbxbJpkVq9ef0pOkeofksTKDBiTSjg1 RHIRGhNbN7U2AAB0czv2AQAU73+YE3seLtRnInVoTmgNvS8ANGwjWXSfdYaOA9gHUuKL2N/uGuL/ AABtNv1ukpJYSFzixrQFFgCb4mQXwoOtv0wtu3CSCxcnEFL/r+8TJ+jbFosPxL53xCQXmq7YAHEB APhX/ArA3tnjNAxDAdhJFyYYEKrE1JUNRiaOwBFYOQ5cCkZGLsAB2JhK6xCbvLzY+aFJY5Tvk56s NJb7lihpn/M+pBYAAAAAADAWfYqsFzYeuxZary/Ndlv/uSLlElJg4cUWOqSwopRWmIbMQq5TySx2 v1KLRvP8CH7e3E3iU5A5ILeYjnTkFpm7PppiCh3y/fH6cV1sIYUXtevOySwGZeekBPJYiiz8ulme NwQXfa/5IbmkRmo5HSMfWRkIdU/w1oeVyyV34gopsgiZJn5EFvb8qrhvBNYsOLHnz218dKd5ZcoN s2/G1LwZ/quk0CITn3+L49BGRVk0CTV72KlR01VUYTMIAAAAAAAApMiTjbO5kwBIiC8bzyYutAgR exm2SyzRJqaQo5ZV6DkxkUVsRGgBAAAAsDw2Nu7nTgJgoWipRd+9AzGZhTynx7Y1AGBaNjYe5k4C YKHMsS+PeywALJWpJBZtAos7UworZGMo6tuwJGKyi1dTNbDyUdC3UdUhMgwtsdCCjKklFzSyAgAY l5u5EwBQvA+Y2/Y8EWuwqUUWXc8OsX10PHMAVLQ9v48hu+z6DoDUCUkq9HHbnJCYMrSOn8s9CgCW yhiCrVC9oqhNXLuxkFkgsIBjcmrj1oXHiy5eTCXE/hTn/1ob6FM3iP3/3+e38iG1AeoCAPDv2QvA 3rkcNQwDAVQwVMCFQ5jkQh9QAnVwpQH6oIF0QBtc4A7DkRJgghVLyXpZS7KDsSd+b0ZxYsnSHuwk tj4PqQUAAAAAAAyF9VDzrkrnqYPW6ye3WFztxBKRKJsIn7avXl6hJRe1tMI1JBZ+65Mvr8UWtdxi s61/L7aIbTa3OZBbDBEDcgvNmHKL/bl9EiQQ8vqQc8qb88vlcUatov762o18VRfrmZdPNIPYNerF FBt/Qcs8ubX26zJBbPHXT3LH/h6wmFpMQ8ajewrkzIJogjgNIpMos4gr4FlGCS25kGWkGEPKLWL7 F9Uxl9W5+iFPbhs/Qem5pXkptIjvdZ4Mx/J2ONcM8ffFmu/UYOAHAAAAAAAATJ0bx6KmAJrHKr0n 8nMSCC2u0DILK7XlWdKKNqHFt2r3EJEFQgsAAACA4+N27AAAZs6ySm8uPY7AGjDUJrPQ71PH6Tri Ph1H2wKUAFDGw9gBAEAn+gzIRCIFAHPkPyUWq5D8GPEosFgWtA8wV/QiVp4ounhxe9FFibAil2fN n7D6mHW5LpKL1CJWsUwqX9eXygcAgCarsQMAUHwa+3JyilRZa+ycHkOXG19XEg/AXCl5bpp7dpAq m2qjbzmAIenzG2EtCm3d2+r77j732QAAx8ahIgvr83VIXmDh+yoQbcPUkKKL+7Dv1dV9AlFy4fsJ SuaMtfURlPYByDxdpst/Fuv/Txf5Nf0CADB5fgRg785xGgaiMI4/Q4EEFCFAT0VBgZA4ALegpaXk SFScBjqOwAFYIqUKxhPPJC+TWZwNO8r/J428xp5IiRJr7PcRagEAAABgHZoMzp5V7TF3oF7vVMry YGadDpfQARb1cjlpOqiiDq9woRUyF2ahjzMNsygnRfrLpkkWAYRbbKIPuXt2/7Mv3dBOuEX9TLj7 bBeFmy9sf4q54Au3fTbgIn7/hfk+Hh/3ZDD4lO/hUPpHR+GemECLUEhAIMCicPO2P4UNyhhP1bZ1 afu7H9KlPrXRFz1SoD/1JqRiJNPUh3EwRbVuzwZX6CALlzShgy3c/vvm90PCaRGH1fZ+1T7y3bys 2m3VXiWcraEDLXSXf9Vy7obEUOBFaDBFiz204XAjCAAAAACgS57b7gDQMS9Ve7PzTR6EDU39lgqt iAVVjDLrmgRj6HP782KXU+/Ff88AAADYbk9tdwDYcedSByjqa6xYsETugcxc0EXq3kR974P/eq7/ gOVdVO2h7U4A2JhlC7rHfucBoOtWLQCV28fMm8LJLrjCFIa6FopCAevgB118S124yhWxMtMvuy1W vCo1dfOp4lW5fWIhF03CL/QxYihkBQCLu2m7A4AnFGphhP636OVYIc7QMRYp5Bk7fug1wC5ZNcyi aLBP0/MAXeJ/NpepNRAr8OwXO/Gvsxc5BwBss0XGMXJjGCdSh1fcyXS8AthGV7bd2+UfqccEXHtX ++pr2dgYQWp9KtxCZP4/SmpsQBLr9PlTgReMCwDYCn8CsHfHOA3DUBjHXzsXBBtLERt3YGHkMhyi x+kNEDsSN0DMcABWpEqEOM5T3NfnpCltE5X/TzJOkzT2UjWugz9CLQAAAAAcgvdj6KPEYIus5fJJ 5vPbKnwizZTQsIn6VfU3hFjYkItQYnCFhlfEMItQwvk22CKGWxTV9ZtgC21zvd4F4RaH6IOdlxyy L+NwnHAL+xzF5tL92n7oTxNm4b+3yZ2YmJCLWM9ml1WoxfdqtdmT8vwQIpB+OKt9breTsApty5RJ es4fDf1Z94ytT8fsj7digf6Kr2EUIZwiTYNIa5so4RU9Z5JeN3mt7V+VbX1Np/LpBbGsu5O4yKDX fBpoodv2WNodW6Z1G4VzTJK665uPhz4AAAAAAGO1kLhYCIDopSzP9Xaff2gttig/zuuugIu2fW3h FgRaAAAAwAqLETH+A4Z1LU2IYip9PCM3BvOeaRBnO63t+3LXZdwH7Mdi6A4AyNr1+46F0gD8J33D e/qGWNwIARbAUM5lM+jiTeLiVa8SF7L6qPe3LVLVt7b3YG0LXbGQFQAM737oDgCJ947j236H557t s8dE/Pug3LFcH3ILggKnquu3ga7tPufm2mvbD4yFHafqPpF+4127z14jt+YBzwQAOCX7CrK4kCbA QucsgFN0VpaHugQacqFzAxpy4Y1/vfFt17g6V3fNDeTmCHL3MW3zAt75zAsAGI1fAdi7Y5yGYTAM w25Rl04RCAamjoiNC3AFNlZWRu7DSbgEl4CRiaVTW2xiN3/c/E5MKQ7wPpKVuI5cgyhK6sQfoRYA AAAA9jVk0vTMlvu+jqrqxKxW7csUGS4hwyvq+mZbZEiF29YBFjLYwohjdvsKwRlh/zsRbnGIMXTN W5YayzgcPtwihFdoz5E39fpz1H72fDfoYrLTZzhmNpt/1t+XS3NeVWII7TCL1uhCsIXvYyPCLEzr vZvjt+3iuK8m2ZT+fHcZ25hKjyd8uz91YRZ+341p6v7/myb1Ye2Pca9vEyN8AEZImgj10O7+3o5E P/EqCnPbfmzLS/8wL2y5suXZdGdryECLiXh9LeqpxQbDryIu8QRJbMikB5MdAAAAAICSFrY8lB4E MCJuoY5Hv6/d9KptUyUOlkiFWGhhFn0BFrmBFn3b+GcGAADA78f1H1DeaaJNu4egL5BCHqOFXeS+ J4B8C1vuSg8CwGiM60ZUANDlLP6UU3cPM4TwCre9NgRYAGNz6cutr7+aZhErV9xjHLkLUpnE69qC VT+5kJV8j4CFrACgtig9ACDyJvZTC33L/fjcQztXMUY/r9H60o4F/rPUItHa9wXadmjb0DowJtp1 6aSjPb4OHtJH33UyAPwF+wRZyPqNIcQC0EIunkx6bmDI/EDunEJXMFfqfGbovEDc1tWP1gYAB/ch AHv3j9MwDMZh2KQDM4IFiQo2LoEQR2DhENyAkY2VG7D2BuUWDNwAwQgSUvdiJzZ1vvpP0gaStu8j faSN28RIraIkrn+EWgAAAADoWugC6a2uw9SbJpOpGo/PyxAKf055FzZhn5V/TXCFDLkwZd5bVRVc sQi2cEEX9XXVduZesIXbZ33ZFcItuu6DvM/ZZ1+G43/CLeTXvB4akfqMLzIk6mMxyiAKu9vRaL9c fs1my29c2t5e9Mrqb5CGDK5wQRdFke1vE31/p0OG1Kc++yKv4hf28xKa+cClQfhLmSgRKvcauR0/ LcI41vv+1J+5d3PQSbvQ9RLZvR9o4R7LNr87sgq7j3mgTXnL3BGQASEAAAAAgKF5VEweAjjmh7AP 9nFskGuoLRRiEQqSSAVPpIIuZJhFk3CLVD9kn3P/GwAAALaDmUzyuu9OAFBHDV+XC7IIjVmITRKT a3PrOQcE1nPfdwcANNLlMY/wKACbap3Jn0LrzPNTXVeqCq8wIRZMBgVsnhNdN7YMF3Jhaqrr265v OylVaF0osCLVnpukc5WAi9REVrF2ANhmZ313ABDeWrw2NeatbVhFbFu5sYPArjnQ9aSqcQhSkx/H tw3ZbGI4EwRgl73qurOPQxOPxM5TVznPDZ0nx863U9sEgCFLHd+bBFmY+xUuyOKyw34B20SGXHzo elbVvQGzjF3z7+regL+U67u4LyDb5DZibQDwZ34EYO+McRqGoTD8QhfGSrAhmFk5AZyAKzCwcgIO gcQpuAMLN2BkRyDWbjC1wa7j+MU4bkJDU5Xvk56S91wnL1Urt3H8fkQtAAAAAABgHXKLQz3Hxm5W HWg6PZD5vPkXRYtLaPEK55e1aZEKJ17hY17EIohZaPGLIGZR1qIW5dBKFgkQtxg6h9Q86Fi5bA/2 eta/luZ76z+zXixCm467/dAv5NNMyPk/164XxWS5/ZjN6j5dvpu1wEWVR9lsrOOFErZQyfZm7O9w im3LaVvy0XloNYeyatuz44AE1YelkkQVrxUjjL8wvlea8L5vL40/UceJP937pv3Q2PvqdE+NnRl7 lrS2hha0KFR8ofxcAUJJpJhaLBHTZeEDkxsAAAAAAAAwBhfiHs4FAJEvY/fGPnv0Sd0/0vGuohUp PyVmEb8+1V62nD/18HCXBbcAAAAAsDtYQQtEDQHG5yQRi4tMpPx4X/dt2+bEL+LzxHkAQD9s0aar sZMAgEHIjZ1Dn4dxFwA2Rd9CkV18WwjqXEIhKO45AOweWuTiztiLhCJWdpsrTBXHcm25glW5rUj6 N9UQhaz8cdraAAB2kYuxEwCIeO35+rbxP25r+z3Stp60z/kA/gtW0OJJ3L0BAAg8GLsVV6/AE49B bYIUOTGKuH/8/zbu1+VYAADbzDpCFvbZjUtxcxd2vRxzFwD9OTJ2XZnlUcK8wFsVy93v/83cQKot NV8g8nfzAghcAMDG+BaAvTvGaRiGwjhuOnIAlkpMTAyIG8DEyhU4AeIwHIAFKTfgGgxI7L0AA+pc 4sSPOE/PjiVcEuj/J5m0SZq8ilZVa8cfoRYAAAAAarJ+NH10/Y+lSU3z4tbrs+9gCSFhE+Fe99cH V+iQizioQoIrhmCLIeAiDr4YQjHc6Lx6uU+EW9SuIe6fnLuWZaj3XHbdMYZgCuv6NmuOfDn/Uff4 /v02dU2czNfv3Md2W1ZeHFBhbh6Hcki4RXdztbJDMCZPubwXyNJqWko9K/W/jUcw6FevpEHES50o YTXZRx9Hp0WctLWctq+5jX8z5PmLol4Tp48DLeS23haXo5sMItkZ21y0nHpLMAgEAAAAALAUT3MX ACzIc9s24XbJBa7WxaupIAmrWWEVcaDFVPhF6jx6vSzjGnODf/XzBQAAwP9xN3cBADrH6n7pGAI9 vtAab6iXqccDqO9h7gIAVLePz07GDgL4TbWDLK5dP077KiwBHJ7z0PxEVp9uHHDhJ7JKTUY1NTFV ybp4m57IKjdZJxNZAUC5y7kLAJSNsc4ar5eb+Dv1WD2Wz9pf75c6JnBoCLQAbE3b7t040MJLfXbk vteW9CVY+9EHAeAvKw2y0PclhPs2tIvKdQFw7iY07931/QI+6OItrMtdp1bSD6B/+9d9ANY6kesX iPsB9OR61jZ9jNQ2APixLwHYO3uchmEoAL/AwICQKjgAnRBdOQEzSIibII6FOAEzKyvcgK7dYKLB IXHzMP6jtI1Fv096Sp6dOi5CShM7/pBaAAAAAADAsoQepOrySxMXqYZGoyOp671vZVouoeUVbd5L Kay0wu73MgsrtugFF1Z+8bOtNh/q+Qtyi1X3wX3+NmRfymA93yUktND1+v9a5yGxRdX1tx3nns5m /jOHBBRKWrHYumX62C6qhBTDPXdplNankvrj64srtai743YakZL01ocvk0RXvjBGmHxucmuasLmt r02+q9qpnPb2Tf2hCd9MRIcTE2cmnsTv1tBCi0qVz1UeW2zQ/inccAdIXHIGNBjMAAAAAAAAgE3S LLJ2PHQnAAqhmUz72O2HXk71bXW9FkjUTllKUBGTWHwE6l2xRUx0IeJ/zsXLtgAAAADbw1jaRScB oAwmJl4kPlcgNKkolMfEFrE2bFlowcbcRTMAtpmRILUAKIHTFbSRM4kz5z2A1DWe6yoArIvfiCxS MrxzQWIBAGEOxL+Q1YOJZ0kvTiWBre/4nIWschYAzRFcsJAVAGwz46E7AKB4N/G2xOfc3xOSyGO/ R2KfSZ0D4L+C0ALAz52JG+mFFrF52alrkL53bfbnnrZy7mFD98eMUQBAaeTKLNzjrk1cSTuGwbtx AJtj0sWtiVdpxwTuxT8ukDM2kCr/i+AC6TUAFMunAOzdP07DMBTHcTcjCzPqyilg4QKIKyAOgjgI Swc2Bm7BxsxaiTFnINgkbl6c5zhpImKV70eykv5J8iq1ahs7/hFqAQAAAGAp2knU69RGu92b2W4v fyfdr8QpDxf00N6uV1wARRhy4YMq6lYHVLTBFm3AhQy+qPdTHY7pj/MddoX9McItlq5B9nOuXUse lnst7Yd104RCdMMrtACL/v1VpV+T7j+L+7JMlxK8mE7ghRZcURSHbTZFoe4jfqj83gS51ZRLPWEd sTP24TtQpkHIZZgooTX/nHA/4WiJC1tbad97X+kvnSvbPiKHl4EWfj18TJYTNjmgpP8hHX+RAoM+ AAAAAABrcpOsPa1dBJCJT9temvXYYNXYUruIVd5OBVEMhVmMDb8g0AIAAABj3K9dAICOMzNt8oix E9NqYRWpcAutDjNQC4A+F2hxvnYRAGbJYwAnABxnTpCFvO0mpLwx9QRQt/PLAvDPaBNZvTdLre9a ri89kdWYgAsjttUmA9WeJzGRFYBTxATlyMlerMfG9GkThGvPS20TG0c3tN8Y7TcMcCoItAB0z7Y9 mnb+AWnM9074nzb8/iiU+2L/ZVP/gQEgF8cEWbjr4O5M3YfhlozRANa3te2hab5f4NW0ARdD5/yn 9BsMrccCLrxUP8HQ7yptX7HHAGCSHwHYu3ujhmEwjOMyFDAAZfgoKTMCE2QGOlqOSWANWICjYQJa jgGgTkFvIcWW/epF/sAx2Bf+vzudLdlORM65BFvRQ6gFAAAAgCGaLqzK9mNXrroeaLE4M9YeVPU4 2CIOryjqtiohtCKs12EWIdiiDrgI4Rf6sepgC/utD1PNzT6ncIup56efW7jF1K/HWIa+rvKcLFbj 11YGXNSBFvF22VbsZ8Q+Wdm/YvmxXkfPLd+nUVsIrGjueLWs+icDLbqON9O/H1Pm1qe59KdPP3So hS2P2/OBR6ZOfdgkSZTtVWKEq+euHpImQj1st66+X56XmzO2PG/DLHyHrv3IlffuP+XclaUpgi1S 2Roy0CIT7bmo64n+9I2PVOCF/uGD1ucGBjcvAAAAAAB/4dYwgBfwfDrwXbne9qPUtskyZJHBEjpc oiucoi3MQodWpNpt4jmbrm01Ddjl2hQAAMDuupy6AwAiJ668JNrbfkQpBxPpIrfrfVLHpzBmARjG T5xwPXUnAADAvzNGkMWpKSZ/unBlZbh/DGA8ciKrT1eeTDGZ1WO5fZsJqn46kVXT9Q4msgKA2HLq DgDK24Bj+nxXSG3Ty7Yxd/qxTKIO7Br/fdd/Tjwbrh0A2o0r96Y90EJ/BoVl0+dLlmhL0funMAYA wJxsE2Thy+o3OgVgNDrgwt8XeHDl1fT7HztX7al9+t4X0Nu1TB1j1LrWNI6T71kABvsSgL27SUoY BsM4/nIA3TmycvQCHkG9gwdwvINHce2ajWuv4RXULWtdCSaksS8hHy12bID/b+adtE2ByNThoyUP oRYAAAAAhhD7YvXR1HHuRrPZi0ynF6uwCR8uYdlJ6tt1t9EHUOiQCx9U4coFV7TBFm3AhQ6+cPej wyz8Y663evmQwy3Gfg6GHYc+pznmOOrx13CL9tjUz+3mb883Qy5E7bPZ+nG9zeducPofM1xfH1g8 wKLZPlF9vn7DLSQdnFGb2sZU03hyYwmvWAiDLUQt+zQI3YaJErHy+6yOO4kf8fb+Tk3/mTn23hcL Kbgy9Zp4eB1o4ZfDPh9wESt/8C8jfaLa0gkILgYBAAAAAIzB/rDobuxBABX4Ehdo8dnzdqkfrsYq FkDRNcziu9C/TZhF+Hfk1gEAALA/bsRNVAmgHieZvtKkE7ntqTCLLhPe8rkQ2I4NtGASJ2B3bPOa V8+FngAO3RBBFtfiJn+y7eVA4wKAnCNTt03pgAtbpck8SxNUMZEVAAznfOwBAIF5j31z18GFy7G+ sO3yGKXtwL4g0AJIezD1LG5eAi33OuTbLp+Duwonggk/B0tkHQD+U98wC4IsgN1nAy7um/IBF0+m PiT9PmgS2ZZ6vyQdlsPv+/u8R0qdI+CcAIDB/AjA3h3jNAxDYRx3gYmpAnY2DsAJmEHcgSMwcQ5u wMSGxEVYETsrGzNtcJq85uE+23EJJKr+P+mpjZMYd6hK49QfoRYAAAAASuV+VFq78nWZ62g+P3aL xebXEh04IcEVzfNqXRJaIc+7MAsJtugCLqQPCcKQvrq/k76mMnaQAeEWQ48jnNMcaxzTUfJ6unCK 1O/GZ0bwxSw4/+ex3fHN+1R8+TfvgQqeMAZkjrEK28NACzW2OthidY75WqdlamOayni2GUcYalG1 /ezVwUeuS31YJUm07evECL+99NuSNCHb9XH77RtqPZOgglhkVb5D33bk6z0/zDNf575enJ2toQMt Zqp9qbZziwBagRfhhEYoNWEhfTJhAQAAAAD4S/djDwCYiEdfcpkpFfoQ+xGRC9qX6tEq2WeFVcRC LlL9VJG22LWs1CIdXI8CAADYbTdjDwDAhpMex4T3I6T2u8RjeE7qGO5ZAMrUiyncjj0IAIMpuZnS uhm4tA99Lp+/AGJ+G2Rx6pqFny58XQ83LADYShhw8dTWqytbpKp0Wz+3Ai5YyAoAmgXLgSn56Hlc eG9cbN+2leqbz3rsOgItgLg7X88uHWiht3PfVa1Sq4ZE5dYsiGFeAsB/6LPGGkEWwO7TARdvvh5c E3r96eLfw+X/oNw8gdVmhVlY8wChXOh1nzkBax8AmL4FYO/udRqGoTAMu13bAbExlBWxwM4Cl8Ad wMSdsHAlnRAbEis7MzuwMSBUqRslVnqwcziOE1pIad9HOkobt8SIlv7E9keoBQAAAIBFWV+0XuTu NB7futFo7yuwQhbVlwAHCZuQrQ6mkOtlle0h2CIEXMTBF2WQxawSmiHHircpvr3L9dsJt1h2P+QP TriFaPb7hECIUNXHZciPqM53iwMx6h7H/vk8HG65yeTNvU+nbnswUF3ohSekfuImwix6EmYhARqp qvR1taxSn/5rX1Kj9PXqCHEaRLzViRKV8sEXrpooYa3IIMfcKW7/2u+754/seIyjoh4Sh48DLeSy btPdiUsSY2ZGm4u2uRMODPwAAAAAAPyl86KOu+4EsALuirqfX85NaLVuE08Yyk0o0mEVer+0WWEW et/M2LaZWGtNpuW7KQAAgPXmJ3yedt0JAN/squt6jIE1lkAPz0i1WbdNhV9YEzYZxwA05wMtWMgJ 2BypoKmm9+X1FUAbdf9vckEWh0WdufK88MGS+wUAy+IDLmQhqxcXAi6e5u2LLGRVd11fZiErACid dN0BQHk09umxb03G/VlS4+qsn5s7HrCuCLQAbD6g8bKoGxfWGdBSry2pz6zW2HPnwjIN1mIKqc+0 +rOqNR4AAH5T23MbPsTCn88gyALYDPtFXc3r2pVz+3zp90Pxe5rcXLk25wp+Gnod90nv1wi9BtDI pwDsnTtSwzAQQNehYUgVZlIwNJSchXQcAI4AR+AylFyEgkNkuAAFHYmxYslWxDqS8xkr5L2ZHVuy 7Gw625L3IbUAAAAAAIA+pBiEZ1XcxS40nV7JYvH3kcQXTpgwtb7rbdmEk1a4/VZm4cQWreAilGG4 a7W/0e/dSQ4SA+QW+87Dn+8cMo98iP8fTQHQii6070r8/qIRTfjn12PKsj42Hk9WUoufeMF/Jb2i c1sEYotiNFobk5OswZFbTjnls2suodSitNccGQGStNaHlUnC9jfGiKq9rNrNNhjnjBKr8AQsrkrf edV3WcVnPM1bqRdOfYju1vCFFoXXv/TasUkOTXgRLvYI2fThgrsmExQAAAAAAACwb0wh05ehkwDI gHkVr3Y/5cPW1A+I3FaTUPj7vqhCE1nEBBh9BBda/gAAAABwWhihBUUmAPLjwsZ3z/M0WYV2TERf r9B3sQjrFwC6Me9bn4dOAgB2JmV9f+z8fBaGAsCxs63IYiK1wMIUfTIFoHgPAADHxnUVTzbepZZb mEJWX3KYQlZFR1s6+kRpi6znFPaHUMgKAHLnZugEADzmW56Xut4vNl6UcV3FMcPjAP8BhBYAOkZo 8SC1eOnM69eeFcNtylp0tx7c1TlwhO2uZ1EtFx/m/gHgkKTMubp9M5/xKMxnAJw69zaM9PrNhpFe +/dOS0m7j9p0vOgYJ7Ld/VHqvABzAgCwkV8B2Lt/nIZhMA7DVhckpK6oTMAlWBBX4AyIA/QGHIIT sPYGSMAhWBALEzMDQkgdg93kk7+4duyqpQnt+0hWQmK3btXS/HHyI9QCAAAAwDpiB14vco1mswcz mZwtwiYkXMKRsAYJm5CpBFJIce18qdf7YAsfcKGDL+ogi6oVmCHPpaelhhBiQLjFpvuhj9X12Y/h aL8ef624/8zFritPrdN1TCL8wtc5ODhczH3P5+ZoPM72VUIqqvZCX5YbqHCNZjoa1d+rVf8h/KEh BUg4Q+nPOv1IjcqPfXolDUJPW4kSLsDC+IALSZPQiRLxmJf68Y5tuy/7ufvIh7dc2vISPr3qkrwE mQ/Xhd3RpUl2ab0N4dsh67swEAQAAAAAsA3uBmsnfXcC6NnclruCeqUXuIYXEsk0Fj6RC7BI1el6 zJJBuXqaep0AAADYXdd9dwBAkjtO89bMp/bPusIrwjqmYxqbj9VN3XSx6lgP7Ct3vJUbLAD7aRiD QQHsitIgi/BvF2QhIRZXm+4UAPTovCm3tjzZcm/Lq1m+kZUx+XP4sTrSnhtZAUAb4woxJJ9qPvab WQXLu35Xu9rHthN0m3B5TmzcHvDfEGgBxP3YcmPLu2kHWojU71LJ+HMZE+7IbRZGwXK9L5nbr2S/ E8C2rBLUfWrL1NTnNNj/BKC50OtpU55NHW7x2KzT2zWl5wVy5xFSodcl4yPDbbGSbTS2zQBE/QrA 3h2rNAzEcRz/t11EEIq6Ct3cBJ9ABx9AfAEXnX0VX8zdWcRVHDqWepfLNZd/LncpRhLS7wf+JKZN cpWWpM3lfoRaAAAAAOiqS6Lwhann3IaWyzPZbJpfR8LACVt2jG83rUIpwqAKG2Thy4ZY1KfbXQCG D8Pw26r28fffScYQYkC4Rd/tCPvvDtmO8ag+KnrI//rf1eutv/DwvVn/n7hgiXrAhZsuFkfF9Hu9 zrZvFgmz8Mt2+/b7aan5fF6MtDYmYwmQsKbcFh1q4d83cxuEJFXqQ9F7olweBlmECRML9TyfKFGU bXf5YfIj9R2bZaemPvLNvDR1bepN76qsMNBiJs1sDd/xI3UxIxZ4sVVTLddxhMEgAAAAAAB9Woob ZA04dK9S3fTadsNqbFnuRiI93xZaES7LhVnoEIsu+5cO09RrBQAAwLSsTN0M3QgArc4jy1J9BXKd PlLBFqlwi9gNmdxMCaTxeytwGMbT+RPAFO0z2JO3Ejfg06Opq39oEwCMyYmph7LexYVb2JCLH6n/ brFP+XX0oFWpgaxErR/Sg11JZl6vG1sOAEO4HboBgNLhltEGfbzfqsdiz4k9ltpG7JyAYzmmxJ6j 3os79ybQAqjYQIsniQdatB0XYseUVB/wWTAvwWP+u2MYdqGDLiTYRqxNANC3rtc3bDi3vabxIlzT ANDNXVlf4sItbH1K81ynS8BF7DqASDr0Wq8XGzuKawIAevErAHt3jNMwDIVx/MEtQOoMKwdAXKUX 4AYMrOzMzJ2AjSuwMSIxMjIg9QIJdpNHHq+O07RFNfT/k6wYJ21cqaiR4/gj1AIAAADAulKTzG+l edCt12z2JJPJySJsQsMlIg1m0LAJ3WoghZb4Og2qiMEVGmLRhVvU7TFd+IUGYtjADD2X3W6ihBAD wi223Q/9YhBuoez/TxdG4evd37Y9n4vjgy2iZsjiYz4f1UcbcPEj2MKFW2i/YphFZfcXoKQAiaiU /myzH6lVDHRU3a+GoGkQul2EWZi270CLNuTCtlXmfXzv9ZxH4XWf4Xv4XlUy4DyUF1kOtNCQC/0I Wvf7fHdsOWzPUSf2idkO/WISYgEAAAAA+E1xIX8eMMK+e5RmsYsoNQ4z9KCquHYfZrFKGQqvWKXU iW3uYdvU52UcCgAAYD9Md90BAFmpUIuoL2hC9+k2N0dBRh7nzw0gLwZaMN4KlOk0lNcVjx3zu1fG ZFAAfx1BFgCwnniNdxPKVSj30iyyqwtZbaPIQFuUWshKevbJQN1iISsAJTjbdQcAZ0yoRd+8OD/v L1Xvmx845hzAfxGvS6eh3O24H0Bp3kK5lnygRe43xtZT88/9sTa44kCWQyxSiyqL9N/vyM09AICx cnONbP1Cmnsa8d4G8yoArOM4lMu2PEhzX+BZ0uPw/tqq6qn78f060yaSv37ingCAjX0JwN4d5CQM RGEcH2DjxoUmLFzpyrXxGLryBuxNvIwn8ADGexhv4MozuIY6Y/vs9PE6PCNNQf6/5AUKtB2MWJlO 5yPUAgAAAICHp1P2NtbNpg3N52dhuVz/KpIHTqRKc3vXt20oRR5U0QZYtMEW7W31E4AhYRiyrXYf w/SJ7EKIAeEW225H3k83ZjvGJ2EQVTXphFusX2se1HIeJNE3xX93PzLHvjvUQgdTqB+2BFtM8nCL 2axdT96bb2+D2ZUACbEr7Rm6HTrUomr2OU2BSCELt/j+/c+CK+LyLAUwhW6CxKp5Lq0viRJVs758 eOSswVF87DSWY5TiZazrWG96V03lgRaTsJ6tIbkcpYsYrIkg9OAQrXQiQrY59kcLAAAAALD/rkI9 IBg4ZCnM4qW5b/W36AuLrAtR9WBX6wIjHTzhCblYZvd/E2jR10bPewEAAMBhWIzdAABF54XnrMkR vfc3DzDy7RNAv8XYDQDwZ97j3jYGYHKMBeCd6ElcBIIsAMByHOq/jaleYz2G7kRW+hx+6FnWz/WV nsgqX7YwkRWAfVXqqwbG8GE85hnzZ9l0vC+9prRtjtn4Twi0AGzvse5jfcZKk/yUxmNbY7c9x55E vqNOs+U80MKcyiG71W0BgG3znOM4CXWf3UPgOyaA7bprKl0X+BTrOXTngCr141sBFtb/Zque13JO AMBgvgRg745xEgiiMI4/sPME2GlnaWVibDyJ8QB6Dls9gw2VrbfwBJZqZaKVNgacdfLcx/PNsqLI Av9fMlmYXZjBoIvLzHyEWgAAAACYRTTw/HDag4bDGxkMdj7DJjRcoqIhDBo2oVsNpNBSPU6DKibD LOry/l7XVVsNxLCBGdqW3f61LoQYEG7x1/3QN8u6h1vUc8dzuEVpLnn9Iuv3YG/ifl0/njg2/5zy vofn57gXbQMobNiFaben7dugiwXqQh+sLvVnXn2JVk6woyHE3O7njnxdhdc0CZ8qsZGOGdnQC6mv +kcrLWibW+lxT/2+3I9GMsVBKrdB0xpyoS9Bb/t9vju26ECRcbBPzHbarx6TVwEAAAAA83Cx6A4A C/aWymXD/mgikW5LpRRiYet8eEUUZNGmRO22mexkt/61AgAAYPUdCRNEga7bbHGMX5iiKcTC14l8 H27R5hjGLgDNToRzLLCMms5v3Rn0CWCVNP1tiT7XbwtBFgDwE/upXKXyKDncolrIyn5vbhe18gtS /WYhK3F1kd8uZMV1GQD/bW/RHQCcp0L9uHBb75fG0EXPER3jz+/RvlK7wLIi0AKI3aVymsqr5HUG VNN5Qrf+XOTHftt6G2RRsesT+DUL/P+kUZ0U7gPALNqEWRxJ/l7jeO69AbDudlM5T+UslWvJARcv 0u56v5+XJ66u9Bz+OP8ZTEV1P/lOIKoHsOI+BGDv/pESBqI4jj+oLLXAGS201cobqEexsvQAVt7I o9jaOmNpY6MV4D6SJ7vLJrtBIVG+n5mdBBKWRWcIsH9+hFoAAAAAyCn5gfbEldtcRZPJkUynq19D /MAJLbqmd7VdhlJoSIXuW1jFMsjCQizk+xwLwAhDMfxgi+39/jGEEAPCLcJ2/LwNfr/o+u1Y1PBn p5B54RBeCEUcXmHnpB67+vebB3XZ2v4vb01jt/wqR8H+op74eS28wi/WPj02Hvf2DxlSgIQaSnu2 3Y54ZMS8boON0rAZATN339gPrtBzNIhJwgSJWX1Mz7VEiUXR11W/GVkvwZ4rh+72a76Z565cuPIU P1Vd/ECLkaxma/iTGpo6I1KBF/NoG2vrfLA66XwAAAAAAKzr2pWrvhsB9EyDXT7q/dLfWUoHstq2 qcRhFusGWZSEWbRNuO3y2gEAAPA/3PTdAABZZ9HteOxA18W324It/BIfS022ZKwC0Oyh7wYA6Kzk upZaYL7tvNLF6gHsnpI5RLa/L8sgi8tNNgoA/rFjqRayupdqESst71K2IFWudFnIKqU03IJFrAD0 jVALDMlz5niX8X+2zY2vi6/nqWt+rg2p+oGhI9ACSNNAiztXPkWCpRJibdeTtu+QytY38NcwsP1U kIU03AcAv62kD/RAqn4Nfa883XiLACCkfQIaPqbvQ49S9QnoklNN8+7i+7v2F0jiMbnga19b/4CP z3nAjvkSgL37x2kYhsMw/GtHJMSE1KmCm3ASOAPHAImNFcHYCbExwcYtuEClHqFSsWuc2K7tOFGb hPI+kpU0Shr3j9q6tvNNm3cBAAAAAE9sIPqjKme5gxaLd5nNLrfrNlzCrG+cbZtq6QdSyG9ohV13 wyzqsl6bbTb8og7FqO/Hnstd9sF9zEMxz++wlRjH87CvOpT+L9dHXfoTCxow2/xwC3+/ut95UoVJ +MeG88zt8/K9XBacW7ygimAH92S7wRaRoIs+jSVAwhpLffqqRy5yZTt6Qr9n3NviB1e4y2q7DrII tu2kRDj3a52rbfNp0V91V86pU9WaSKRqqepEHmJun5IXZxxvJAAAAADAsXgZugLAwN6knujaZkJR 7mIUscGtpWEVXUIuSgfJxh5X6jYAAACOm74o5s3QlQBQ5KTDMaVhFe4ydnzb8wEwF3fiogzA38d3 G4BDSI0TDn+v66Lb7K+qrFR5EgItAGAfTsVcyOpTlXtV5uJPXWkq4VSWXIlNk8lNg7HbROLfCyXf IQBwKBfSML8d6NnKWU+NeUsFUIS3c4EUsQCKpvAL4JgQaAHEfalyK3WgRa4NGbtcQlP7Mmwnhu2+ VHsx1TakzQhgX5o+a3TRgYjPYn6zPwhjJwAMS/cJXKvyocqdmM+kkr6ALv0DYX9A2+tMpfoHQvQJ AP/IjwDs3c9NwzAUx/HXwgRIPXDjwgQMwBkJiY7QURiCPYArKzAAd0CckFigSohJnLy8OK5BpY7a 70ey4ob8catWJbHr33HuBgAAAACYtJSOoeuqXG060GJxKuv18BLET+rviwueqJc+kKILqKiDK3SQ hQ+2EBVi0YVfdMcs1Tnqeq552/1E/TnnjXevQe6J66fxOmyrDTqQNndbdqd7Dw3vO5blrPmcjd2H 7K8bBlt0f/v4+gqdfDwNJBBi8VPm8zbQog3dUI/189pF+Evuz6A1pfbkbIs7s4+EdoEWha9LN5LP 1QsXXFG9T3SQReECmaQ/YqNojuO2PWrOoSOr23d9tY2b4eGkWr5ubuZ5VS6q8mxPJf1Ai/ap+GYH nk4sYduW0iytWJq2PyaDHwEAAAAAv7USBgnjsLkwi/umnhpoEdrmrwEWY+EVY2EWoXPodbF7Uik/ xAUAAMDhWOZuAIBk7t7NS1PX4w70tVxsMgsJrAstxwYhhSbFsOe2Yx64zsQhu83dAABZbGtgJt+j wH5K+d2Qq19KHWZxI0waDAD/yU1ktWzKQ1XuqvIu8b53/3uR0HrdBx/a3+4nZp02M/uJqYtaZ/cL rQeAbTjL3QDA+Ny8SSsWbmG3i4VVpIZfMC4P+4JACyDsSeqQREdPbWCFvhv0daO/9iuadXNVt/MO xOYjSBH77gOAFCl9HCup+zcI6AYwVb5P4FHqPoE3MVNdSf/egH0c6h/Q/8/F+hFExvsEPPoEAAx8 C8De/eM0DENxHH+NOAADUsXYYyAWbsANEDeAiyDBCVA5ATsSOwMzF2BkZ6labFKTl4cdmz+tKf1+ pKemiaNY0Cht/vhHqAUAAACAr4g9VHqYW2k6vZXxePIeNuGFAePDuPE6bMK/+kAKXW1oRZjWYRZd zWbtvBB+0YViyEfpbc6Xp1u2Ndwi/A9qD2Rf++/wu33Q5+hq92W14iEU0oVFtO96y03WhFrWthuZ cImwj3oz92anaYY6FO3jwrbRndD9VeEW6zgTWnu/s/5Kf2r1w94V0ajPQQicGPkwIOknRPg2Nk3C hlzoeYtlSIYPuNBXBPT2912bF/dZf9Y7QNyBq8dEF3SgRZi2y8KFhliFnS12M4mo19zuwsOrAAAA AICf2nV1WbsTQEWvrq4K2qUePi0tGz6RC67IVW4gjdjNrzw4CwAAAOu8dgcAFNtLzE/dN5C7QSR1 n0JuOrUtflcCnVMhRBjYBkPH2pLjMIDtUTLQ08TVibSDPfE9AgDWb2ggq6EBq+aJ+SOzXKQ/MGnp QFY23MK2Tz13wrkaAKtwVLsDgPGUb9KTGmzcHoNz9wlKZJ2h7XFMxqby3ymvpT1XAaBz5+pCysMs 7GuoRs0P02FcApHPARbrwnELgJW7xuGfSTsTrm8A2CzHy7p3dePqQbrvaPqZvKEQi9S1g9Q637km IGZa1Dy7Xmw+gH/gTQD27hinYRgK47jVLJ1gY0AdMrLBCRg4CRt3YIETsHEbjoA4BOIMHSqlwVby GufFdhyhyhT+P+nJKDWJi0ChieOPUAsAAAAAMTkT1C9tPcztaLOpTdOMP374YRNSbg3vrpVAiiGg oguu8IMsJNjCeCEWQ/jFsE8/2GJ6baN0iED547f98Qm3INxiuViIxbB9qO49TYMsYvt1f8tVVdm2 Mdvdzpyt17pT94OSVr/mmtVqGmwhrapDuMWRlf5b8zGWKRmHXDX3Z9PLrIvDlX7bd+UFV0iQhZ8w IYkTVR+UoWdujFZhsH3cb/mFbb/mh3pl68bWhzqUHNoPtPCzOPZm+nZSNxp0tarVUg8fyD650QAA AAAAyOUWMD0vPQigIBfqsu2/Tj1YpLfNVSyEYq4aszzoog20qQeiAAAAAKe2dV16EACyxUItRGiu QGjBCz/IIrdfao4jnzOBqefSAwDw6xByAfxPOc8K3Ztuoafbo48GAJBDFrJy4RavZhxuIc+JxBaq yl3IKrSfuesr+hpMbEGrVn2P3gYAP1GXHgCgfAa26fNe6jyb6hs6T4fm38X6xI4BnAoCLYCwN1sv pls/ICQ1dzu2wPHe66PXGVh6/94/5tLXOWcB0ObucdS2nkwX2A0Ap+qur3dbj7bcUlT+/2w65CJ0 jV+/nltG7ceXCrdIrTnFfQHgD/oWgL37x2kYhuI4/hKxorJAtyJu0IEZrsLKSWBkR+y9ARIL12Dh CoyA1Erg4Lpx3PecVGqbln4/0lP+uBDzryWN4591AgoAAAAAqUJZv3V1nPugyeRZhsOLxXYcLBGH TYRlFUgRlw+tCOtxmEVds5nfF8Iv6lCM+hjhePEyFj+uD/0f/0cN/dh+P/r9Pqy3D13G7m6rL+vW DKTwIRZ12/K15zTkQhbbaZhB/TiRweDsb/k9na7Wu6o/ZRk2/Hb8+UN7EfdF6pCLDWgGgPSPvjSV yc9naUaE+e9QqFKawRWlUlWQRah4fxFtazMynLr2UdnpLburqAtWtwpZ7mLcZpXWxbaJJDT9/3AB AAAAAPvqRHyoBXCoXly9zdet8Ip0qd2Img5O1Qas5oItciEWaZs24DUNssj1X/tad/IdcgAAAGwc 54PAfjnPtFkhFdp6OtFFl4kvcsdgzALQdCP5v1cAAHAYcpM9jcVPDPnh6kkItACAXVQFW1TjCe5d jcTfH3I0X1pVGvuWboOR+j4SrV27x0SUfel+Ef31p+t9KQDQZtx3B4DIl6tPoy03Fk4LlGoLt0iX 1ji99DFWO7DrCLQAdI+uHsQ+17PO8VaZT6Dr3AJtwRTWax2vRQC6sJ6Hwv5rV6+u3oVACwD/x6X4 awJ34sd9xe/z564NdL0u0HYtwPp/MewTsa8JWM/ZAP6JXwHYu5uUhoEwjONTEIrd+AFduHAruBI8 icdw4x28godw68aVG2+gRxD0CG66KjrjWPJOfOcjSWGG+v/BS9M0TaaB0DQzzUOoBQAAAABNLpXY ObV1nVvRcnli1uu9YF4YNOHDJ3wQhRGBFF1AhQ+ukEEWm2ALI0IsuvCLzfrDYIuyfqzaIQL1t0+4 xfbbMH0lLewPLzXeWL++2AUFhK93nyfehz2f7/88fq5WZa2LBUfIeWKZmQy3kMEWW9ZCaIPUSnta CfrQ2hC7Wt4fpTHrBVa4cAx5ZT8VeqEeRfb9C1vHZfvlzNalWGV/UzLQQusoyHUuyF2gHei510vO JQAAAAAAiHF/rDio3Qigkg9b97/TpYEW2jJasMQ2wiu0IIyvyLxcpT5HE1fFAQAAUMVV7QYAGGRR sExqTIE2nfrDo/Y+7TmA0G3tBgAodl5puwRFAbtPO56PjA+/erX1YvyNnuinBYD2uXCLB1s3tg5N Ptiif9Oq1I2shoRb5IIuTGSexPkmgKkuajcAEN7FdGpcX04qrKJk3F0uQCPVLsbtoUUEWgC6O1uP 5u9vvdRvvDFhFmPEApeMGf+9w3cU8D/lwizc+cGbrWdDWDeA3eX6BJ5MGHgdC7GI9QFMCbcYct6o 9Q9IU84xATTkWwD27h6nYSAIw/AkQmmgd8dPR5maQ3AGWiQkem4BokbkBvQU3IULUKVLgY218XjY P0PAdvw+0sh2vEpWSsCSvbsfoRYAAAAAcvgmjj5KPegxaLV6kaI42x7rsIQmbEJawRM6oMJVfazD LJrabOrXXPhFE4phwzPa25S+AwT6DjEg3GLXfcgdZ/Qfffmt72OKdShAkw3RDo9w9xPbAQIz07Zd i8Xh1/mP9TrdKxdMocMpdGiC27fhFardzJ7bgSGENjhDCZGoDLEfsdmYLnBC/0J9ozm22yrsQgVc zE34hQ7D8I3oKMrzx/Os23YX6qND3dLhFr5zocp9wJAyjC8bAAAAADAmp8KkI0xXlfB7n9HONzE1 p0JhFDbEIhZyEQq26BJmQaAFAAAAQqpAi5O+OwGgk3NzHAutsGILGfomNvomQIbapj4bmJIr4foK oM13fQWw3+zf+bKsZ6kXenoSFgIGgDE6Kuu6rNeybiQv1KLLQlZ23omeYxKbb+JeF7NlESsAf2HZ dwcA471je994Ot++75zdpsbmMUYPY0WgBeD3UNab5C1CHFucOBRWmMt37YqFMaXeJxaGYdsD2G+x MIsqsPtWmmccjIcAMBWXUodb3Em99qO7v38Q2E+FX3Stn4RbxP6f81wAGLFPAdi7Y5yGYSiM425V MbCwdOzQI3AJFljYkRAX4Az0BExcgUswcQK4CBtStyJsQuRnK352okhO0/9PeiJyaGJFoLZ24o9Q CwAAAACx1Bd92X5j6zp3oM1maw6HVdAWBk004RNtkIUvGVrxEwVZtMEWRoRY+PCL9vhhsMWw+agp BAjU7gPhFmP3YU7hFk4YXOG3m33x/cY+QGARbKeeY18uz/5+fu/3mV7EDYtwOxF4YUTfg/0jmFKA hDOVvkzlupT0I3XnfHwXvgyocGEWKxlmYfxofvFIvX39ua112XVyC0NcKqeSgRZdDw7kJhLkJdAW htAmF7rU/yMAAAAAAEzZrnYHgIpebX39b3eNAqfaSsIsZAhFVxiFFlahhVyUhlikBsh5WBYAAADS be0OABhkPeA12sOLubCKVFvJ+YBTtKvdAQCD9X2IXwurKD1O7vd4TwWOT/t/6xY2ebD1aevD1r2t i0p9AgCMR4ZbXJn8olV9F7Jq21MLnpYuZmUSbRKfNQH0ta3dASDSJ9RCu28uFWYh92mLhBNogbkg 0ALo9mLr3QwLsch9VzOiLSf33qWFMMXtpecBMH/auJELs3gyTZjFsyHMAsDpurP1ZuvR+HCLvvMC uXALbV2q1HxBarmuuE1iXgA4Ur8CsHf/Ng0DURzHn8IMyEKigJYGeiiYgQkomYIVYAJEBkBiA5AY hIqKIh0dMnexjZ/Nuz8xoNjy9yOdfE5MfAiIie17P0ItAAAAAKRYF55OU1+0XD5KURx+r+tghDZs QjrBE91wi7IOrZA63KLshVv49Srgot227IVZtPvTy02NIUBg22Mg3OKvxzDtcAsdZFE/Iva5xKrf DRBo+tZ5xna92nxn3X9brbLHpYMKfoQWNM+rpRl68UtjCG3QxjKeKYwj9BupAyesO++bQIt1X4Vc LHTAhX5cumEY1l9E4Z7fX2SdujtrhmANS+0ilLURuxFlk8kFMeP44QMAAAAApuBcmHiE+fLFg17q fu5EU2vC6tAwi89ePxZkkQrD0MvUxCTrewQAAMA8+YlVfCYEpmlX0kUucgthxIIt7JuT0sU2Qq8J zMGlUMgBmCOOdQAa/v3gwLUb115du3PteJsDAgD8mz3Xbl27d+1I2gJWqUJW/UALq5DV0OJVQ4pY 5c5TAQDvZNsDAHreM7fLDaSwWuw56z4967WBKfBFq5+EewgA7UOqYu7PEi86HKoZkFsrIPWZzDom hfo5x7LYfgDMR6zYuS9g5q9z+DCLayGwGwA8H3h95dqDaxfSPe9vXRcIXQuIBV5bIde5/3eK2NcC Qu/1XBcAJuZLAPbuGKdhGArj+ENi4ASMVSfEzsAIR+AITIywMlZcg4GdC8HCBRi7MFSh2IpCHPc9 24RKTuD/kywSR03e0KKmdvwRagEAAAAgZN3Yh/0L125yJ1ouT6RpDgd9w6CJNnxiGGTRh1k0jQTh FX2QxWbz+X2se63f93+78w+DLfY3TvV3AhV+c33CLfZbw/zCLYaBFtYcYwm2c8+h27bbNtTifb3W awnqKRaEVxwE+7tBHT8Xh2rUNqV65lqH9cv4zuyOKLBC+7XeiqZWZ3648x25dlxW76m0E3CtS4WB FtrAgPVgQTxIkPrAlzx0EJvGmwIAAAAAMDWr2gUAlXy49pg4rgVCxMfjMAttvySQYkyAhXVdq24e mAUAAIDmqnYBAEZbGP2lcwasIAprQlJuG0DvunYBAACgGn+f7Rd/9Is83QmLPAHAf3Hm2rNr99IG CecWsioJt7AWtdIWUN3nIlYAkHNZuwAg8qr0xQ+S54IsUlLBFSXbJdcApqALtLioXQgwIT7QYuXa i+j3XqWhg1aQRUhbBGVswFJJ8BLBTABSYRZPrr25diuMcwCAxgdeP0j7//Jc7NCK3LhAKtwiXrcq /h5a8v1TjL4Q4wLAjHwJwN4d4zQMg2EY/gsba8WEVHEDboB6BVYGzsAVGNgZWJk7MsJxYGBDXKCB YNO4+eM6dtJWJE3eR7JM7ECMhGjrxP4ItQAAAAAQE1r0+SiJSd7F4kWm07P1sQ5BKMMmpBI8UQ23 yIvQClkHWGSZ/IVb2LYs+5HlMi+OcxVwkVd+rruervdhOIEKu1yfcIv9juHQwi3KecFqcMKq3bWV +RHV8/V5/lyibnO/y8fX18bVi5PDo3MXdv16jLqelGMVVW+jL6ENTl/G05dgjTbjCO2a4GoXOLGe VTdfH9tAC1uLmpHXIRe6zwu/mKjj0Iz7qemfHTWavruU8kaAH1ShbwzEsjbqbgq0uXkQ0/0fAgAA AACg7+bC4iOM14OsFhtZTRamurpJ8QMr6sIrvovit6UCLXSbv6jIH2+oBgAAAJzbrgcAYGsnif7Y AsRUmEXdgsbYpoexdmBM5sKcKzB0qdfDUB+vkcCw2c3L7efrN1OehfcCADBm16a8mnIl8Q2q6jax Cq07SYVb+OtZmm5iJRJem9J0vQqA8TrvegCA8rnl94Weq0ttEB46X7eF2kPP9fEMH/rIBVpcdD0Q oEfsM+Z3przL5vr/1B4Bu3yuahNS0aTEfoa+ZuwYwLDU/Y/SYRY3/zoiADhcNvD6yZR7U2bSPsgi Fm7hv/9scx+g7jlRv033cV8AOAC/ArB3xzgNw1AYx41gQkwMlZhgQoKRWyCBxD24RMUFuAFi5gic hBX2HqEtjlwrtvv8nKgCu+n/J1lKk8ZxEVLaxHkfoRYAAAAAvCEPdz7Ydl/qaDa7MMvlSbQuDppw 4RNxkEUfZtEHWbjmQyvS135dt6/vPw62+Nv7U9MJVNjl+O2EW9R2SOEWUjjAURgQ0a9NlqUQi367 39cHW6zX7vX3YiH2GHWShlYE26LQCt+/1kZqIbQh1Mp4pjKOXJWE400ghZT+kJupn5u5L16Rt/2f 2nY+bPzXtt0phwoDLXJBFdrNA2PkYUp/Iq3ARKqNfxIAAAAAQCvmtQcAVPJp29dmWbqyqz1wWgqz kAIockEVWniFFogx9kEk6XM2cJUfAAAAlV0ZilIA++xG2aYV0pYmF5XeN+YYzEvAoZvXHgCApnGe BKbnybgwi1fbLusOBQDQiDPjCp++2XZrW/fAZynUohRyoT0WM7SAlRZokStiBQASvveiJT/Bcm4e YDoHMKe0f64QeKnf3LFy8/qA/0agBbCtC7R4Me48U/rNldYFCMnFPmKleenacjqnfBX0mfZvzPY5 TRqLNk4A+00Ls3g3hFkAwC4ebfuw7dm4a/u5+wJauEVaOqsUeF0qo5WuN8J7UtwXABr3KwB7d6/T MAyFYfg0bCyMFRIL18CAkJDopbAhMSBuqRsbbFwPnXsLoDokaRzn+If+YLd9H8kisdP0CFWKmtr5 CLUAAAAA4KMtCr2PvWg+/5Dp9Hq9bwce9GETMgieGIZbdKEVzX4TbiHr8Ap7vw+3+Pndts/bvZ/9 d19yB0uUUEMJ4Ra5/we7rWN34Rb71IcFhJ5hP1GP1187vMfYhVoslkv7TZ1zyWgsGGBhjU+svskG gRbjEI+8Sqrn0OsIPemgqsMsqmrwiT1r+wd339vQi8ods/vbGrW78p1LM35VJd3Cu5P+hwAtY8MN t9ACMEKTWFIWF8SU8cEAAAAAAJTo0bSH3EUAGdQLjN4D474wCC0UQguzcPvcYAot4OJb2fadNzXM IlY7AAAA8Jq7AABbOU84xje5SALb9r42N0ELxQgdA5ySmXDPFThGKQv5t7n2cd0EDt9F7gIAAEW6 Me3NtGfZPNDCXnuS+vCq1LUoWsiFK3XdCoDTMctdAOBYxA8Z0YIq7DHfMdoDwrV5e77wC+bsoUQE WgBjX6a9SHONiX2XCm3Hvkv9dW54LNAiddx3PdPqA3AcCLMAgP9RB14/mfZp2q0Mwy3ckAst3MIX ep0SgB37bUCUbbdPAn0ACrESgL37x2kYhuI4/pAYGJmQWKAsSFyAc3CKimN04AKscA/OhRjoFMAm TbFf8myHFtmo34/0lLb598rSkDj5EWoBAAAAwLP+cQ8/v3R1n9vQYnEtXXccfRYHTfThE3GQxU+Y RdfJZvoZBVf41+F7vw2/7LC+327XfWzn1QhYaCFUoXYPhFvsu4/dwy3+9u+RGiPc19E2QCJYQq0W hzGEoRb99G29nh04YexoFF7xvW8fGKADLrKbbut8Zyv9tBKsse8+hi35QIoo4ELGZ9B1WkQqQSI7 Qt/t78TVWdl3uZF+sJa1qzDQoqR9va7IdJtSOL/kWAMAAAAAcLhWtRsAKnl29b55bZ3JTQVbpG74 0WEVpTVn3dwNR/p7cXMsAAAALHe1GwCwkwv1PhVaoaUezj31IENrzAKA2Kp2AwCawu8mcBheazcA AGje0tWLq1sZP7jqt2EXuQdZhferlAZapB68yjEtgMFV7QYAZU6ohTWOzgq20MtMLTtnH0BrCLQA xvzvyoOrtcwLtAin2tT47lwokh4rbo0j1/NzoUu6H92nGPMA/E+EWQBAHeeunlw9ujqV+Dy/FW6R mlrXA0quA+hlRNLHtCGuCwAN+hKAvbvJaRgGwjA8tEuWhRUSa25Bj8IpOAkH6BG64VRcIQhixdPG ZuJMQiEOvI9kKWmT1IuqUv0zH6EWAAAAACzWhtKXtl2XbjocjrLb3Z3O++EGWlg/bR9ZuIWGVsgp 3KJpJIZZSAy2kCTcQu+3nquf+9tqCFVYug+EW1y6H/WFW/RDKPLjqyQcIh0vtO+T5Bo97ve3CT8C Xzth9Cd7r/R6duwNQqghtEHVEiIR/LV+5E/Z6PdaWwy40LaN1yQj7+15/3hrvR6fZSVMqNv2/fuN axhvL+cJACtjIw+3sCYMSpMCnsmDMXV8UQAAAAAANXmSLlQZ+G+Oct7IWtqQk782pXmCKt5j659b 9w09f2yzkYg9yF3BCD4AAAAqEQIt+F8IrN/NhGs9xQrHCm941yl89x5gjfZte1y6EwBme1i6AwBW i1ALAICHFrF6lq6IlTfcYmohK2svimdPiqcYK+M7AAIKn6M2b87rPIW6PUXAPdcNfTZQk1DMmkAL IDUUaCFi/38SsefTVSmworQ23AqvsNaXjwVZlAIu8j7lWH8OrB9hFgCwvLCO7FW639y5AdelcOux Nmde4BLrRQH8oE8B2Lt/nIZhMA7DH4gJsRQJRqQOMIOQOAMLEiPn4ARduAU7IzcBztBDMFSqhN0Q 2XU+/ykpdQLvI1mpnMYxEmraxPaPUAsAAAAAsR/qfv2dKbe5hqbTC1kuD1av28Xo/YX0m6ADCYIs XJhFG2TRhFm44IowxMK2Yd/bHt+GWPihFu589Z5JDSFUof75CbfYbj+GFG6xHlLRhCuE9ev3CV2d 9sy827Y1mZyutp+LRaIr+sfYnhda0Xndlu+gAH9/qr2hBDdY9KXbh9/oR9uudtc7lvQQpkWkEiSy d+DNuQ/N/+lxWajFuSnXiVP5gRYl3Q+PFdG7KYX7S75zAAAAAAD+n1ntDgAV2MlGr4n9JZNPtQlG YWBFKswi9r7wmFi7qYlF2lb7+wAAAADrvnYHAGzFiZQtnJFaTCOsS41JiLUbW8Cj5LzAXzGr3QEA ve3qOpW6bgMYn4/aHQAAjMqDKS+m3Egzz8QPt9hX6nILWm2ycFVqESuJbFnACkDosnYHgMBcqYuN rdP258bb5cYOaueILRLef7I60J/9LndlyrsQaAH47PXkSVygha/0uXfJGO9csEVsfHks2EI7tuT6 FQut4DoFjJ/2mTWRZjzDmxBmAQC7dmTKoynPppyJu8+/afB1WJd7TvCT5wJhnY/nAsBAfAnA3v3j JBBEcRwfpKEw0YTCmPjnDnYWRm+irQewM8ZjmHgAehtKGw9h5SksKCD4ht1ll+HNHyI6k/D9JC/s guAzQVZ3Z+ZHqAUAAAAAlzY55Sr2pNFobIbD08V2tWD+fLmt19wJt2iCK8wy3GI6NXWgRXXb7rcB F1WohRue4d7udrhF7u9f9UC4xXb7KCHcwg2p8K1dHx5T3IYQ9DrBGNVC/vb3ezDYX+x/TyaJbXnO O3ZCCZpgi54bcBEJtChJKf2UEvTxVz3sOa+7tvpB/b5qql8/Z+VMu+x3t/va/fVr+cItrCN5/CQt 2OLStCf8tYwNN9xCu0DguwiQmoAdk/9NAwAAAAAoxZ3Uee4mgH9mJxm9dvZ9Z2pjk3K6k39SJxTZ mpn1kIqZsq1NLHInI6VMOAr9DAAAAMCh1G3uJgBsxZnnft8Ew9RgitAERfd+xiMAxtxIXeduAkAW 2zwOckwFAADYDcdSL1IPZnUhqmYRK22RqlCwhW8RK21OCgtYAfgtQi1Qks/I47Hxc9p4u9hYPG2h ct9joR4Y24cc7N9w9nP8Xeogcy9AST6kHk011rwRmruf8v9QSniFW6Fx6L6v08ach8abaz1qvYf2 AZRJ+9yyYwSfpb6kngzHfwDI6ULqTererAZabBpusUmYRcp1gVj4dRfXBYAC/AjA3r0jNQxDURiW mxShpUpDCzuiTMMMy8g6WACUrIUVMEPNUKU1YGEUXyt6XIcQ2fH/zWgcO37cVElsSYdQCwAAAGDe NA+vbFLFfe5Eq9WVqev+XwwZLtEFWMggiy7Moguy+NoFV7h1GWJhz2X3dce7cAwZlhFTOlihdKhC 6eu3NRBucdw6SoRbhO/99UMFqt22XniEe7faD7PYP1fbFouLn60f2+2AEqtuKa8lQyx6u1e9pR9u MYbQBmcsIRLWudcROm+sR3wo6cFPi0glSOTuyNu2bOq51IVaXJu2M1fsUjLQQlO+f6zx9k0NGgi9 /5eOMwAAAACA87MpXQBQwHPT3n5fawbguG25FhswpB1ApD1WE2YhPwcDigAAAJCyLl0AgKNZHnBM aOChpg/CIYEXwFxsShcAYBI035G5QCrteQCc1kvpAgAAk3TbtMem3RjdxFV+2IV2EqvY8Bn/fo+/ zQSWEr9LgfmxE6IyCSrG5F281oRHpPoNpgIpQn3yYuEXGrmagP9AoAUQZgMtHsS6PyY/9L8nF24U Wo/1B4/1Ha+95dD+5p+Z66YCnABMS2wukXXTXg1hFgAwNndNezLtc4HcM4ChARexuatSzwU081dJ qTmsAJzAtwDs3TFOwzAUxnE3DIi5AxMwMbBxAuAI7CyMHINDMDChLuys3IRDMCCWjsWp29R5fX5x URun6v8nWXXitLEQUiTH9keoBQAAAICY9lLrxZcT60uTyYcbj8/m9bA5/qypy83y4yAKGWyxPA5h Fq4JuwhBF24t4CL8Vvs+8lNTOlihdKhC6fuHPhBusd1+lAi3qLXH9lYBFvKa+FotCCM9r7iqjuef v9Pppp0TXR21wyri47rPdViAGb5R3lD6MpS/y676sRbCItujz9Hy+uh4PsLuz7Vm4fvjuH6knV/8 VrUo2j1P/fnzvGCLG7ca8NcyNmS4hRaAkRr872rPHfQv/08EAAAAACjt2ZeL0p0Aevbly6fRri3K yQ20SC0AkouItEVF8bmZUs9dXBT3Xda1YwAAAOCxdAcAbM2V0WZtii3r1sYc1lwDa4oHcCjufLkt 3QkAO/ffZxshUMBh+CndAQDA3rr05dWXB5e3WVXOJlbWWhW5uZW2aVVq4RnBFgCuS3cAEL67L2mk 5gZq11kbfVvhF9r3tWuAvhFoAehkoIXGCk2K26x537LeFWShHcu6NrdcC7fYNNCC5xewX7RxmXsX wizeHM99ABiq+r3Auy9Prj3Onwq/liEWqWCLuC33vUAq2MIlzsk2AD37E4C9+8dpGIbiOG6JDTEg xI66VGJC4gSd4RzsHIEDcAN2Rg7ARbgDWw8QBadpyIv7nu1AFUfp9yMZKbWTuEtL4z8/Qi0AAACA 05WzMOXRl4fUhVartauq4c8LGS7RB1jU++NhmEUTXNEGWdSD4IowxKI5t2nbnd+FY/TBFuPGoUoH K5QOVSh9/7YPhFsctx/ThVt0m/73AQDD54Jt9eHzQHleeL3+HFl3tvv7vd2OeyPyPsq9wlCL3zb7 wIA5hDZIc+nP0vuRc11rdryW9BDOwI/Nyj84FoEX3fXO/WtXeaEWa1/uI7eSgRY53Q/PdUFba7GA Vc/iWAAAAADApS/PpTsBTKxJ7n0Tx7HFRal6udAotcAorNPaxtpYi4tSfWcxEQAAAFKazSruSncC wNFcK69pQRPW/AEr3CK3nTweE4YBLMlL6Q4AWKTYnD8A80OoBQDgPy5cO5/n1bVze+TGVdYmVuHG VdamVbFibVyVs1ZF4n9X4HRsSncACHyNbJ8TYiHbxYIwcubqpeYkAlMg0ALQfbrh/PIU6/Nf+27I nW8eC62IhV3Urg+2qIx7xYIstPfklHoA86U9i9m49vv+w5ebqTsEAPiTJ1/efbl16bGA2JiAtsdV alxAGyOwgrCdY2wAmI0fAdi7e5yGgSAMw4uvkIoClAaJOyDBQWioOBUlKCV0dJyBM1BQIeUC4Wf9 l9iTmfU6Ct7Efh9pFeMs9hpZCbI9+xFqAQAAAKCmFX7ed/3SYvHqZrOzYrmcCP93vSwnxm8GUdTB FGWoRfvn1cpVgRauCrpwWwEX5bba+5GvsaYeqpB6/+UYCLfY7zj+N9yiHUxhTfHf/kjZDr/Q+sn9 5GMo3/9cLqPGvdlPYKPVa9G3se4ky4p1WVxowCA6j2dAYx9HaLvWTAfrM7o6l+pWXF3366yQitZ7 9fpqG82r6to+T32/87hz9MptLvZrGRsy3EILwLAKAvoUDoQcxkkFAAAAAEghL4CnIAlT8+zbV7Vs FaVq62RRkVbk82P0sQqPZFFRKMAiVFBkFcnGHBsAAABwl3oAAPZKhlr0CZaw3usTZgFMXT4R1E3q QQAY1C7ffzHfuQCO23vqAQAARuHat0ffLl3chFUywMJatmpWukIuuiawkvj/Fhi/eeoBAMKHsk6b sNt6ji7UN/SMnjaZeew+gCERaAHoHnx7ct2f3VbIUXPZeqZ8l0CLb9FC/WICLeSz6HLc2jFqfwcA h0ObT2Tu24tvb45nFwDgGF248r7ArYsLtQjdO5AtdF/ACrboCrTg3gCQ2J8A7N0xTsMwFMZxV2Jg ZGBAFQI2Zq4BEgdg6lG4Biu3YOYSTGxcAaaqtZuGOC/v2QHSxKX/n2SFJE6wYAi82vnKeUsjAAAA gDH1WZBy59tt7kbz+aVbLtv/WsThEk2AxWq777736zCLKshi1QqukCEW4doQclFfX4djNMEWf32B P6EKU3//agz8HoYdxy7DLdo1viYQYNbZb7IC4jCM+LpUjbDaflihFkbowywKr+j0E/03x8P5EBSw /boEJYVIlDCWXY3jN/e1Kt3a7HlZYZfV9008dRx4EbfoeH2/Y3/stF+oxbVvN04v8MtAiz7Dl9c6 0Tf1YYB2nsWxAAAAAHC4TlwVagEckjffXhLnrcVG1oJUrVnBFLnwCrnQSOv700CLAqrsAAAA2AOL qQcAYHAXPfpYLx7U5hdo11jhFn0XKabmLAD7jJorAMl6Tg79HOS5CgAA8D+d+fbs24OzQyz6vsAq 9TIray1Lah0KwRYArqYeABD58u3TOJeaR6eFUOTCLeTWWkSuze3T7gmMIfxdtnAEWgBSCLR4dcME WuTCK7RjMrBChldoIRba+VSghTYX3Rn78Vb7OQAoh6y5hDVij769+3Y/+mgAAEMLc9CefDt33Xr/ kcvX/3MhF9ox67MBQq+Bgq0FYO/+cRqG4TAMG8rG2IEJxBWYOyBxAm7AEbgB3AR1gJ2rcALEwjXA juvGtn6OnaSp0/Z9JCv/EyNaIRzbH6EWAAAAAAxpoMoqd9F6/amWy+tm3U56/7ddjyfB94MoXDCF Ca1ogy3UJtjCLs0+f9sPuLD3Cp8TL4ciVKH+820d+D349djBXdR04RZt+IILBwi3t2cJxV3fnhMG DJzp77td/02FWoQVkbfdPeOlC7HQzheL4GepjXqEpqpHn/vmZktoPrvedtOCrvcFLembkAp37MJs R/vi1nTpmVf6vJuyYIuVSjfo+4EW8XEp4Vpq9O86XjoJxDw+ZAAAAACAfTId2xiUhFPz4a2XDj6S jschFiUBFlKJQyxSA4ekZ3UNeJXqP4OWdgAAAMzQo+J/Q+AYXSo5eCLWZ3BhajLu3DVSt4tUVwzg 0N3q8lS7EgBma8zfu9S1hEQB8/VVuwIAgKPzrMursu25Q4Is4smsuoIt+oxTYfIq4LTd164A4Pnx 1sdMxt0VVpGb9FuaGDxXh9w1wC64QIs3Rf8AwDc20ELq492nf3mfwIrUuSUhGlKfcwItgMMlvR80 48O+dXnZf3UAABO60+VdlweVDrTIvR8oeS8gzWE1JPSafqFABf8CsHfHOA3DUBjHH8rCwMDAiJC6 oI49Aiu3YOMarCysXIMDMXXrxsYUioMT4rw+J47kylLy/0kWTWInpgwtie2PUAsAAABgfcYml3Tu XHmeOtFmcy91Pfy3IgyX6AMsju22/G/3YRbHQWiFD7IY7mvaNqEXXfsuHKMPtsj/LIpQhfLX933g 75C3D/nCLewwAOteoA6wiI0VHs471/U+D4fgsHHtIMDCPG7U+wshqCq56MIBwnMUMgz1KGvJ/cjx Psfuelsj6HVaRKXCLkZH5behF+E5L92+m7RQi60ru6C5vlS4L6X7uq2ourGHALHjKd9JAAAAAADL ci1+0DKwJh+u7NvXcyeMToVKTE08siYPxUpsUtFYgEXYf6sOk4kAAAAQ81S6AwDOYhvZP7a4oK6X slhhrJ1VhzEIWIOX0h0AkFXs83SOlM8/xu8By/RVugMAgEV6dOXdlVuZF2xhhVvo49ZCVSkhFyKn 81NYvApYh13pDgDKfrrKSUCFtbi3fm0d0z+nFgZnPB9KCgMtAHjfkifQotu2xpXHAixqGQ+psAIt flTbOWPRpwI4rN/Reh8AlGfdb3kQH2bxJgRXAcBSXbnyKj70upkTrO/3pwZdxEKwc4Vej40b5fkA cEa/ArB3/zgNw2Achp2VgaViBDIwcAB2dpYegdtwAi7A1BE2Ng6EmHqBYjdO4n7x5zpA6qC8j2TF IU3jov6RHNs/Qi0AAAAAVJH6sy3nqZM2m3ezWl3u681i+7uuLhffD4Mo2mAKF1jRB1sYH2RhfLCF 8aEWpgu4aM7d+ec6vI7c/iVCFcpfv2lD+XuO8/g/zDncQn6V9P16bYBAmCHQZE/05zb1YV+g+8w7 n9vtoA3JUIIgtKBqgy58OdgPjldBSECJQIc5hUjMoS1TteM3z6mNbO/eva7Nwf6+J10GWPiQim5r +uCKti5H48eueWEfd5UXbHFv+g5+2ZEfBlrI4+G+1tE/5oZASvk3HAAAAADgVFygBQOWsSRuwupr 4vixiaaxCata0IUWSJEzaUibQKRNKtImw8ZeGwAAACC5yU3r0o0AMImzH5yTCqzQFibMHZfAeAQs QW3LY+lGAJgNfvuAZXPfAYRaAACmcmPLiy13Rl+MauyCVakFrOTclZy+IUJPgWWoSzcAEL5GPDYV MqGFWYTHcsbrEWiBOSDQAhhygRZPZppAC22MeCy8IhV2oQVaHAuzkGPac8acMwYd+B9kn0pty5st H7Zcn7w1AIASHkwTen1rxoVex/a1da/GhF7Lv5nINsT9AWAi3wKwdzc5DcNAGIbdLmHLqhtW7JE4 BRJwBo7ADeAOSGy4FCdAgkuwqKrgKHEzmdrO9C8u4X0ki8Rpk0EgRBPbH6EWAAAAwP+S+oAt++98 ux060WJx6Var/kcKGS7RBVhU7b5b73dhFlUbXlG1YRZdgIUOvQgthGN0wRbjPI8i3OIUrl/+Z9DU QbhFUC/gX1VNE70qjCAXaNsPGNgMtpj1vs+f5XKwnkinc7p/1tW4fk8IuJjPRw90OJUQidrU6zj0 eVO/5akR9L0gC2cfiR9CL+Q5z3zfhS3U4sq3G/F2fSnZlys/NUnAqdembvqnjlv+NwEAAAAATEO9 aOlT6SKAkb2LbesEpNhxHTQxFGghJxmljlkmF20TaFH+Bj4AAAD+isfSBQA4mtyE9dxigno7txjh LiEWjEHAlL2ULgAAAJyUj9IFAAAm7dy3V9fMP7UuXiXnsKT69dQaPY9lKPDUsngV94eA6bguXQCg fBlfZw2kyI3Ts47li50bGAuBFsCmEGjx7dJ/qy2BFnIsud7OjSmPjS+3hFgMjTePXX+fQIv9Fj8B cEh67E49H+zZt0/fHopUBAAoqQ69fvPt3u3+XCC1v23otYtsx75KPB8AjuBXAPbuL6VhGA7gePRp iCAMwRcFr+GTV/AGeg5Fz7Ib6E189S4+zGZZ2jT95c+0WSL9fqCs6+xacW7QNf0StQAAAACWTRr8 eZ9aabN5V+v1zW7eXHB+28/7F9rXUQoborBhCz9YYWIWah+2UPvQxRC9MOtunTDGOKDh3pbWQlih dlSh/vbr/w3MfhC3sG8bbozCNAOG5VLcYhyviF3T3vy/r1Znu/lv/cYw2YVxlEJ8rL97YrZmQxfO JC07hlYiEloL+1Iq8DHn84bOau9fzfZ1poZahI5Z2KCFG6g4dSMXwrx7VF3a5lX3c9d5YYs7la5W S8ELqWjtT7mDBFLqvwABAAAAAKXpoMVF7Z0AjuhDmcFHWu5g0dCgo9BAH2lgkB+lCMUqcp47NrAo 9rvUP4gPAACAlj3V3gEAxVwKy6RgRWhwYShuIZ06kVqPCxdiCW676bH2TgCo4jefa3wWAgAAYC7P 3fSqDgtbhC5S5T4WilmExqwoYV66VYH7AP4nohZozZewzD/PLnY+Xepcu1i4Imc+ZxvAXAhaAFM2 aKEjSKlzsEsGLVIRCz92kQpaSGGLvwYtALTBP37y0E2fykQtAADLdd5NL930pswYYXtcP+d7gVDs Iha2OOR6VpPLfym+HwCK+xGAvTPGaRiGwvBrxdCpYkCs0AHBxhFY4SYcgwFWJE7AObgEEiMrYuwG Q6YYu46JY+w0qVqctt8nPSWxif2iOkqI3/N/kNsBAAAAANgNhrAQNiwl9SP55Sfabpc1NJudS1k2 F9H2xSVqAQpVHcvvcS1moSrxClWJWdQCFr7oRVPIQjXazCls4PrOOfbd5edyIX//+X8D64dUfuyC D+6e6t5QLVBhz1NqVPkT/wbYFLSwf9cUxaiFMcy+aWs6PZKi+JDvopDpZNLrihZt2J2GWEVU2MKJ A+yZoMWu+7Hp6zOtK6lHtdsfV/tmPJlIjLEezGHUvYvWCMvGQfkiYsNcR3Wzl1UfE112rMftp3ko tnMhNmD3VWrxCr8L173vvnPDTwJoCyaJ3fQq2Ib45bGH+ihRDgAAAAAAANvHoVhRC4B9Ya7tpaW+ S9JRqq5LglCYcNQliSgUvegiYhGr53sOAAAAALRh5i0vczsBABsjFLVYZd6/LZmwTx3APnCX2wEA GCR9nokxcai+bfjn8n0YYBi8Cf97AwDA5rkWu4jVg7YvWb6wVMr8hBj/2I9LcPkvYexESJjD4m/9 PnhvBdhuELWAITFf8by2GMHUcbhNiVyk2gjrAdaNec8yseKPuR0BGBDmOfEkVtAiRptgUZtIRErY oktMeShsEauLnR/2EfMFQQuA7SacHzzV9qzt6v9dAQCAAXOj7UzbvbZ3aS67lbLY2lSl/J0n8OcD XFmXuQGH309qfkCE90+AtfAjAHt3j9MwDIZx3G2kLkiAVDEhFQaOgQQ3gYsgLgETS2/AjRg4AWKg UyTs5uvVi53EbYOb9v+TLIc4rd0PiSqJ/Uy7DwEAAABwoHwTUF5saV0xfrl8N/P55Xrbra3tggWK ullYvyKDKKpgChlYkeemDLMwZbCFKYMu5HHN43U/1Xb3Wt7DKV5/2nMUvvf+uPpP/xkU40j7Pux2 DF1PosNpi+1JHRih22SwgH+fDh6QbbPZyXrre7XqN3wRXlHvcoEVk7/91H1V+2U9YMjCoQdJxBpb oEVohYT6zLn7jG09rWpd7P46SaLczsT+TB2jZ43KPi/scYtpr1N8d6YJr2hLp9btmWr3lZh06zb7 8YUEAAAAAAzBTVI6Sz0I4B+92fJTbodOuIYm5sh2X5hFaGLSJsEWvslFbYEaocmw+jUBAAAAIY+p BwBgcIuybrsHQN9IpO8t8C2wvUlbaBz6McAYXdvykHoQAPbGNkEWMY/n/yYwDl+pBwAAOBq3ppiP emqa+SfblNBcF9+cldAcFtNSG/E3v22B8bpKPQBAkKEWofvpfAuV+/QJqWjrJ0bXfYBALPfbyi16 TaAF0Pi05cmkC7TIRYkNtMjVcxBoARw2fZ7k3JZnWz4MgRYAAL8bW15tuTf9z/3L2ndNQB8Xe22g 6zqBxPUBYAd+BWDv/nEahqE4jjsoEhJszF0QAwfgAowsSByBI3AENm4Ha0+BhFTGEJImbsKLn+OU pk7S70eyCvlTO3QpiZ9/hFoAAAAAp0H7J7q9/bFoD31vtFpdmyxLO9ubgAkbYJHvAifs702YRV6H V+R1mEXV7DHt0At7vg3HaIItcmf/sUwhWGE5gQr79h//M6jGsZTPQs6Vkv7WgjeBFnrdeLMv8RzX vTeYpufb18/NZvBVbMMF6gX/ExFYsQuXaL/W4RdjmVKIxBTGMtY4jn19rhUWZKBF0gqpcKVFaAkS WhiG7eei2HYVFmpRplzftU73da8FVfgKA+SfQLvRr+0P+a4CAAAAAJivl9gDAI7ovWjr+ufQAlJf UIVWkPRj/MVIIce6+vD1La8htOAWAAAAsJ5jDwDA6C5NeLCEtk87TwuzcJ2nLdjNPAQsxWvsAQCY haFhFwCW4Sv2AAAAJ+XGVAsY35qwYAutnOZMnO+qW5F1Lv8JttC2AZi2+9gDAIR1/yEdcqFvbQ6e K9yib7Fz17Gu9wMOyQZaEMQNNMpAi7eifSv7DxVoIcMotG2Z6YZchARa9M1PJ9ACmD95b+SpaB+m CrUAAMCnnCdafuct64aHhF7LZwHaMwHtOcI+gRY8HwBG8CsAe/eP0zAMxXHcJTuMtAu0G2fgHt0Z OBFSJ5aegF6FMzCyMTEWmySK++rnOKLE+fP9SE9KQ9K4aqWK1H4/Qi0AAACAeZKLO53ntpP2+4NZ Lje/236wRN08vwmcOA2iqIMp6sAKF1bhqgyzMFWwhamCLowXbNGc7z+3vKYvd6BA7mCF3K9/CGPI /R4045jKe9EWbiGDLMJhFcejDLcwwe3y4elzLBZlkM7nV7f1NcHr+GEHVZCF8R+L8y5pCCESztTH 0dfr07omXNWBKeZ8prwWUFFU24W3vxDHaJ0WnJU97i4t2OLRxG/ca4EXMmsjVF1u/scM4wMKAAAA ALikJ1s3uQcB9OTb1mvk76HFOSmLS7Xgilj5C49CC4q07dTFRPlvxAMAAGBs3KJX/j8Epu9B2Z8a YtF1waE8L3ZtYCrWhuZQAP6O70dgut5zDwAAMDu3tl5ME2whwykKZV+soVUozEILt6BxFTAfm9wD AISPDsfGGnmHAiz8bS0EI/UazPXDfyHQAjjXZ6CFPw9cC6uIhVjIuebavPPY/HMCLYBxknNs1rYO tt5s3ecYEABgtLa2drauTXqwRaivVdtvBFoLL9n0jt8HgJ78CMDe/eM0DENxHHcqFmDkBJ0YgWvA 0CtwBI7QKyBxBa4DB2HrwFYVV05q13+ek6jk0fD9SBZVaievdKjk2PkRagEAAADMX5+Nmk+2PdZO tFzemu32IjnuAyd2baCF+7sPqHCBFl1IRRhssWvDLFzr+vh+5hCG0YVjhNep0Q4U0A5W0P78f6EG 7e/A1zGX7+J4rVMThkP4oyae5/N5Een64ONjeW58G2qx2fSqNKktrjMXarFYuDFtO2UwQv5/pWPu dWh+via4fjzbfZgFD0IqpFjoOEGiFIbRnf/SHrvpF2qx3yDwEAyXLl9a6C+FYZiob2myv/Q+D5cA AAAAgHlaaxcATOjdtu/2dWlWtrZRtBRmMTTkotZP2vhU21TExiIAAACM8axdAIBJXAnvSesCamsG hq41qF0TOGdr7QIA/Drp93QofgsBAAAwhWvbXo3btxLuVSkFW+QeYNV3i02TeU2wBfA/3GkXAES+ evaT1gxKDzLPja31K50fODUCLYDUhxkXaCEFRNQCLWrBFbkQi3hMHG6RC7LI1UGgBXCe4nmQF9s+ bVsp1AIAmId7296Mvz8wtEn3BUpBF8ljvYx8f6D0oDvuDwAj/QjA3h3cNAyDYRj+owwA6o0D5cIA DABiAJZgIi4cuXQDhoABOHJmkAqHOKnj+redUuqQvI9kNWndxFEDVZ3YH6EWAAAAwPJUgeXb1Js2 m1dZrS5/lt1giW6i/F3ghPTBFm1QhdgyDKxowyzEBlu068N6XRlu199nSulAgdLBCqWPfwptKP0Z 7Noxl8/CvZ7sB1PYCf1tiEM/wX8V+rdT2bak7wnebttHNdRC3Ze35S60IlCvC7So8oIBsk0pRGIK bfmrdpQ6vv7s7c55cf4a7Hos6tkNqKjtcu08X3t1Yj3jF6beOu/8vRO9097dVSjVWuvIT3X0xzr3 Q8qfrAAAAACAY3k05ap0I4AT+TTlLfK6NiA1NOhIG+gzJrQiNqhI21ZuwEXquAAAAADfuTDwFViK MX1BqZCLMZMP5mwTmIPmO5UJooD5W2fWy70nz60PYP4+SjcAALBYTbDFiykPMn6yKi30Ijbu5ZjB FgD+h5vSDQA8X4Hn3PvtRPbvr4tN+h2rF1oP7cOvq7UD+A0CLYB979IG/R0SaBELLnLvAfeLFkSR CrFIvT830EI7Bu14Q+sATse/rtj8vmrCLJ5MOSvSIgDAnFyb8mzKvcQDrg8JuXCvIeTOb+W/LoFH UdYBZPgWgL07xmkYhsI47pGRoRfIAiNSj4E4BCsbE3MXZk7BdbgFc7lBsBWMHfc921FRnJr/T7KS NJC+UqFK7os/Qi0AAACAvtXcoDnY8VS60DDc/iwsP/+OKAROjL9hFtPWjxBuMQVZhNAKfzydn4de +N931/XXjMM0lmodKNA6WKH1699CDa3fg1BHL++F/255HmQRSHN42nyeEEQRXWscp/3P4zFfUhRa cXKsPD6r2z/mggHODEjYSoiE03sdrV9f/Pzaf8BsNjwKqchFQqcJEmIYRhSmcWW3u7pQixs79tGl c0+vTeTnbgowyc9qk/vaeRaXAAAAAIC+HFoXAKzoPdrXZmBzNx1p52pDK2puVBqT/dowi7R2AAAA YKnH1gUAWI20CHfaUqH1Ckh9A7nFB0v9B9x8iB49ty4AwEX6i89APkeBy/HVugAAwL/3Yse9KS9K VbtYVW6Ugi3ic0bYGuUYwDYRaoEtkQItlpAW/c71Ehoj9/Rp50zmmB5AnINAC+CUC7RwAX81/eN+ uzTQotRTroVXaCEWtYEWad+51oOuvU7p7wBgffG8x7Udb3Z82HHXphwAQKdc8PWrHQ9mebCFFn6t Lb9VCrcwwr60NcoxgIJvAdi7Y5yGYSiM488tEwuiEwtwEiSOwjE4AQfgEl3ZYOMazAzsXCAhlv2a V8tO3CLqiv5/UpTEMa1xK6VyEn9nrRsAAAAA4KBy820/SxgMKFqvX2W1uo4hE2OwhE6KPwZOyCbY IiwSQypssIWGW0gMtpAYdCEm2GL8e/u66Xvuw/9dy/nPte9aTcKu/da2D9q2ofVnMLaj7eegbfD2 bUfowz7Jiyg/Hx6yJMYy58ZyW9+Xh/5xm0AL7+Prq9iOXtfasbl/Kil3uh8XZ4//4sNp/d2yjqEt pxBmYU9JLq0zfCcXMkbA6PZWQEWssxy2u2Hbj6h3sVy3+1in09eIYRbOvP/VUHazWMinP4FOu5Nw kXmZNke2B+zT47qvN52UbvjXbpkKtpg7k7uKOgAAAACA4/YwLLetGwEcyIuMD6nmxjRy4RC5Orkw i11DLkqvURtmsUvbGb8BAABALSbgBk7HebJfe/0/F3yRHis9UFgqA/4bP7kE51TgtE2dVzkXAlDf rRsAAICEYAvvTcpjO12yL2a/tNgHZvS38eZRm+S41nGZfbu278t9EMDx8mNjF60bARg21KJ0393c fYNTIRNTE4OXJhGvUXMvI1ByOSzvwgTYgLVPoIWuS4EWaYjEXKjFXHBFLuCiNtCi1K603ZKUlfoB wGGlYy73EsKpeNYLAPCXHiWE0z7F/Zrgaa9L1pa9PtAn9UrXB6zctYHcNQIRfrsCVX4EYO/+cRqG oTiOv7YLB2DqwsTAhsQlYOBO3IGLsLJwBk7BVKkHqCjETdy8OH6O+0d1on4/kpX+cVy3CIqSPP/m w10AAAAATJRVmKIff63a89BAy+WdbLf94XzARd3qkIp665sOs/jbh1a45u5vNv55H2Yhu75+fzeu H1OHaZxKh2SU4j+3cq8/hs+g7BxK/wzqOZT/OZx/Ht3Qija4InZssb3dBgSE69/L/u/Pz3qtdmv2 mycObQQhFTPVJGyqT7v74fV9pYMWvFnwXkrOY0rjnuP1rRUVfNrDvNk/TJBYSD9VIhYXvVBhFvvW PHZTbW9TvxOt+6o9STe8wnr5ztQjbycWhiFBX+vkgvV8zv8wAAAAAIDxeys9AeBCVlX7TDw/VFSa 02KhFTlFRbqwKDXWUMgFxUUAAAA4hStMohAWuC4PzTZ1nr9/kVD6fmxxQ+t2qm/O2MBYuUALFu4D rlfO95X1/Wj1y+kDYHq+S08AAICGC7Z4kW6Nit4ONatuxaplmUm/9sUqWMs55gRgXB5LTwAIrA7o ay1aHvaxrtuLLYAejh2OYfUBjkWgBdD3IZcJtEi1VKDFr6QDLYZCLmLBGgRaANOhj3G4kEAXZvEl XMcHALgMt67lu9TXuum1rI5tuecHUutfSWKrcZ4AyPAvAHt3jNMwDIVx/EnZGDsxwCEYWRBH4AZc gYWLMDN0Yu1xGLkFa0nipH5xnmMHojo0/59kJXVo60atIhzbH6EWAAAAwHZYk1QeUk/a7w+y2922 +3rhe7314RY+yKIPpnBhFS7YwpUm0EK6IAtpgy384+Pg+f61x++5hDUECpQOVljHOSDcovQ5+Hs7 fB+dW+v/OAixGAZajHIkxO4DjPTt6TABK1ggp04HW5yqhiEXc0MT1hIi0bj0dpT+fNb7WyPYw8CJ WA94W1TIRdXtV6q+6uuDMAzr13Jd/81NXrDFvfgO/6lO+/B4mLVhldTxqeAKbR1fZgAAAADAbzwK A52xHR91+e72505K6vdTgRbhNndyUhhsEQZZWKEX1gQjq80AAABArpfSDQBwdlcyb0HA1PiA3AAL 61hsWAfw3zSLTHBNBaCVup5xHQUAAMAcr+KCLVILUeXWhXNeYnUEWwCX5650A4DA5wKvEQuhEBmO 28tZNDz2mLF+WAKBFsDYe10OslyghTXme6pOB1bo8eNhmMXcsAtrzLoVupQKuAjPA4Dz0n0bT3X5 qstzobYAALar+R/yTVywhe7rzwm/tu4JWPcQYktxxda+komtxn0CIOFHAPbuGKdhGArjuKssbDAx IiqGMnIMRo7BMbgOC5dgZmHiEOxIVVVwElJe7fdst6JxCv+fZEV1QuJGqIjm2R+hFgAAAMDfZP1D LPsvfbvPnWg+X7j1Oj6dDLJot30IhQy0+AmzWK0+N6EVQ4v7XBduMYRhDOeSoRmHMoVAgdrBCtO4 B4Rb1L4H+4xjWOC/D3XY7uufMVvr2Fv1wNEVus+Epmm6Vx/LZRwgsZ2QEQ4wGFPcP2sDAETQRRh4 kVM7ZEGawlgOFfBROzhkl+trqyVE33gHARVWuoQMt9hU138HZWjhGSd+e14WanHt2404rXn5cOjK 29EmAbjg2NwHgDZRQFP/lxwAAAAAUOKh9gCAkbz59pLYXzrZ1AqaKA2y0MIqrAlFqQCLcHyp9wEA AACUuqs9AACjuzD6U5MA5TG5WgKt4Ch3buoNcOzaQIvT2oMAcNT4Wwj8L6+1BwAAgNAGW9w6ferM rgEXqWCLmdFXslgVwRbA9LGQOqbmXenTavGscAnrWK2F+7Wf0VD3h99AoAUQawMtnt3+gRZWzXdp HbkWUhEGW1jHlgRmpOrNtddyq90HAOOR34GcuT5858lRawAAqOfKt0ffFi4dYpF6TlDyfEDbZzWX 2Eo8JwASvgRg735SGgaiOI6PuClIV0EoCOIZvIC9QT2CR/AogksP0CN4HK/gQpCu6iRpmpfJmzeJ VCeh3w8MTWL+vNaupjPzI9QCAAAAOA/a5M1X3xbWRdvtuyuKm2pbLnIvX2VrAinaQIs22KJu+yq4 og2x2B+Pt+fWx+R9w2f+lSkECuQOVpjGZ5D7+YRbjKsjXOhf67s77B1DAS461zXH+oEB9fGyhuWy qI587Xbj34gMvZCBFXJf1hKeZ956Gn2PuQMfZB1zuu8pn69/e7uBE7LHu9cbLoIrLg/bnUALJQRD G11fWvlzb4cFW6xd25FvddJrkwZSnfhDOvmH/GPzf7EBAAAAAGOtfXvIXQTwT97Ediocwpp0qk1E 0kIoYiEWqQlFseu0urSatfcFAAAADPHkmBQLnKNr429W6EQqkCIWZpEaW8DYA8xdudjEc+4iAMxK KkDqt9cCmI/P3AUAABAogy3uXXwxKmvhKm0+S/iqBVuE2wRbAPN2l7sAQPh2eqhFyRpfFwumiN3D GoNo3dsK1wDGINAC6DtFoEWzH47r1gItxgZWyFdt2wq00Maua/URaAFMk+zHePTtw7dNploAAJCu fHtx6WALK8xCWxsrXP/K+m0gFXARG4fK7wRAxI8A7N09TsMwGMZxI5ZKXUDq1IUFbsDOiiohcaRu jNwEuBJXYOlSFGyCE/ft6w8KxVb4/yQrrZ0PFzE5th9CLQAAAIDpyS3sdO5suc3daLm8MNvt6V59 v9F9NxxdkEV/7IJgCx9i0Q2hFb7Iuv7c8Tp3L1/vn/GXWggUqB2sUPtvUPv5fR8It0j3QxuTi4VY yHwIee1YP4Ze7JrPzz+Pb5tNUZ+jIQRB/YkMs3AhAFroReT+tYMWvKn3o/bvO/T5WprUXtqDElQx jKS7tjDcwohR9K+gDC08Y2aPi7JQi0tbroPbpgbwZVBFSWJ1+LNTiwBSA/6aNv7pAQAAAAAxbK6G /+LFjAtTcyO5JQuXciEVsryLop0TW1iUamOBEQAAAH7Tfe0OAKhiUXBOaiGg1p7bZDDXlqoHWufG XAmJAnAshFwA00SoBQCgRWtbrkx806ncJlaxYAttPUvJhlUmcTSR7wDquandASDwGnz+yTy72PxB 2abd85C5frlrgBCBFsAut8nFgzluoIU2V1wLttDCK2SIhRZ8kSoyTCM3v5z55kA7wnGOM1uebXky zDEAALTFBVs82rIy5e8ItHcCWrv2juC7wRZG+R7WAxA+BGDv/nEahqE4jr+gDkhsnVioMrEzMnMA OA1HYOIQvQEzt2BkQ+IKrBXCaYjy4j47TiTihHw/kpU/Do5BqALH8Y9QCwAAAOD/s9bVvuv7ov3+ Rbbbq+O+XtBeb3VpwyzqcIs2rKIJr/iWw6E5lt9gC1HBFm0ohtW2vvdU5hAokDtYIffPIPf96z4Q bhHuR3e+bjfEouic1x9FdVaEf65tq2mnba+Qzeb8WPuVEGrR7YMKr4gdq/M67CLWfm5zCdb4q37k /v7G3N+aue4HTvgj353ShFiosAu9f1achmD4o+eNS3ftLi3Y4lZOB/mtW6QM5vulrz62OIWW/xcd AAAAAJCqdOU+dyeACVQDla+ReutFnSHBEn5d30tE/jXWi0XWfaw+950DAAAAUpXC/4jAWu28Y+vl v1C9NZcgtshgbCHCWFvAUlSLThAkDKzPRe4OAFi8t9wdAADAUP2d++zKtdihFbFFqqxwi1gpjC3B FsBylbk7AHg+E64JzR2UyL5V52/HhF8AQ90IgRaAVs0bf3LlXdJDg1IDLULzv0OhFFZ4RSjEYmig RSjMYkzgEoBp6DGLB1c+hPl6AID5qp4RPEodbBF6RhArKc8GrOcE1jMCMY5D58Q4BlbvRwD27h+n YRiMw/BHKyTEAAwcgE5duQYbx+AY7JyDFS6GmCq2qtgkaZwv/pcqxCG8j2QlTWrHqdRSXCc/Qi0A AACAZQn94+tuvzPlKdXQZrOV/b7bXBs0cTguqxCKNpCiKTaoohtcIXWwxcEJumiCL9p6TVvusdxj lzCHQIHSwQqlX4PSx6/6QLhFvB86xEJv9+3zhV/oNiur1fnP8nO3G9RXt80zJ7AiFHghan+svZKW 3o/S5zfW8XvvhDrYojPirYIq1k6whW82fmfU3GlPh2dcmOVtXqjFVqoJZrHwirX4B+v1Nt/g/vH0 VZHM/TnfbQAAAAAA8/FcugPARF5N+arXQ6O2uReU6jCLVKBFqE7owiJfvVh/RG3T5wMAAADkeizd AQDFXJ5YL3WxoG/pqz/0eMCc2UCL69KdADA5HRD121I37+VvJgAAAMZib1r1YsqV+K9DCYVYnBJu QbAFsBz3pTsAKB8DnhubhxcKs3D3hW4cnvMc5vxhKPudh0ALoKsJtLCBRrHPYnc9NFfbN8c7Nmc8 FmbhC7bwrecEWYwVaAFgOu6Yxo0p76a8CXMLAAB/gw22eJB0eEXo8ZDQi96tvqT/20Dq9wIJPAb+ tW8B2Lt/mwZiKI7jb4ZUNCBapoANGIEFKNiFBbIBQzAAoqOlpUsfIc5Yxj77+dkBBR/H9yNZ9182 JLoEc/aPUAsAAABg3bRBnffi/wCv2m4fZLM5/dpOJ6+PYROxxDALH0gRwypieEUacLHfv8/2h+t8 qMV8wnxtSbgF4RYjjX4NfBvG/x5CO8pAinJMeXks7J8v4zkiZR+ev2297XZ9jUuDKspKihCLWZhF fq0kgRgLsPZ2jP75flq/1hud91prPd6fIRYh0EKyJ/LT4IssBKPWY+6cTOee9QVbXIqoVedVtI5r pXXcCq5ILeONDwAAAACwnE/lZnQjgF/wMpVH43hrwFLYroVZaIOTrBALa4CRdq01+Ki3/QAAAECP u9ENADDUhbSfCbDCK/JzxFhq670DCpmsG0vmJp/g8xTAsTD4Hli359ENAADAkAZb9ExWle/X1o8R bAFgOQi1wNK8dp7XG0hhPcvXmmTcqhc4hPsO5O63LtCCCbEBLwRauPv+6EALa70VZlELuCDQAvib 0n6Lq6k8TeV6TFMAAPg2F2xxK3b49aEBFq3/FWjzYImyri2lsg38Wx8CsHf/OA3DUBzHH7AgJiQO gIqQuACHYGHhBD0GAwM34CjcgHMwM7CWC0SpQxvFcd6zHaLWKf1+pKfmT0mcAbVybf8ItQAAAAD+ j9Sky8ajq4fUhRaLO6mq/uW6RfTr7XYbQtEFUrQVhlh0YRZ1b98Ps/Cv1QVb2L9dEW5x3KEKpe+/ aQPhFn5YRV1b69N3oRf++/XggNjDbN7/vVrZbRkZRtD7mzDYQmTwWtpcgjV21Y7Sz7ez51K2w17u UyO04jfoQvo97oOR9U27pf/fd7I9du5er/JCLW5d3XuX1Trvz7zz1uB+q1Pff+zYoH/rfM53HAAA AABAecvSDQD25N3btjo1cyeVxiYshROGcit3glHsGbRJVgAAAMAYzWIX16UbAaCoC+VYKuAiJjZp MBVuEQvKAOZsKSwcBWD851Ys6Cn3OrmfywDm66d0AwAASLhx9Srxxaq0xav+GmyRUyJ2n5Mo+wD2 h1ALzM2nciwcmzcldMJaTDx2TxYYxxQEWgBDX65exA4yCseKa8esceJTAy2qoKzgivZ8eA8tZINA C+AwtH0Tl67eXH0IY/QAAIfrydWzpIMrco9pgddW6LX124FEXsXYB47SWgD27ugmgRiO4/g/uAGP JhIXYAAXcBRf9cHEEVyDDVyCUXzTGdQ7a2mv9/+3FdAe3PeTNByU0hIwF4+2P0ItAAAAgPOlLUC5 KzXabF5kubza3Y83zA9hE6GEMAsXSOHCKnyYxeco4CIOtuiPXbuPJMxi2Hdu0/45h1sQqtC+fzeG uX8O4XqcG8MwxCJkBJSu27kyzhTwr+1uX41QC3t4P0EVyf3d8WCsIdjiu81iMYkQid65j6P1+zt2 /9ZOCHHgRBxKMQi1EH1W/YURfGHNsvcuu+/xqi7Y4sboOu2iVK+V2oUAJdP4QwAAAAAAaPoJ0Q+t BwH8g63oC1K90qLUvwi0yC10Sp+jjUGUOgAAAOBQ/I8IYGU8bi30S+tyiwUleV7Na+ceB6aK8ymA Q3DeA+Yn/o2HUAsAwClYd+VR7DUqWnjFvsEW1sZVpXUtbFYFTMN16wEAkfc922lz9rQgjNwm4jVt cvWAhkALYKwPtHjuyptRrwU81AZapHO+rSCLNLAiF2JhBV/k5pQTaAGclvi6hT9v37cbDgAAR3Pb lScxttuS3wVcWL8hWPtj+WMRe64qwRaA4UsA9u4gJ0IYCuP4QxdewL2zm6XxDi7cmJg5wRzDnafx OiYewb1b44pBCFQKvL7CGCyB/y9pnGlJ6cQYtbT9CLUAAAAA1mHMJszHsjzEOtrt9pLn3e7aA/Nd 8ETRCbJwwRbd4Ar5Da/oh1nUwReFF4jh+iyagACZHBJAuMWWQxXS378ewza/D1kvGKKpleEcXfu6 vq57TVsng/bq/elUt3182uu9MiW0wmvsFv96F2TRfL3w+0ksdeCDG8Mc45ir36XdXzs9oR9m4Sc/ +PVVmIW10t4FYwxW0jd1V2W5HhdqsS/LndetNjl/KcPhZkqdNpnvPr516ITVzoETAAAAALBsR2Ej E9bvuyyv3vvQxhxtQ+iYMItzAi20gItQ2IW1AUn7PKE6AAAAYIyn1AMAkNyN0WZt8Iu91g4ZtNYV hO4JLN1R7J8jAJiC34PAtlTPd95TDwIAgJHuy3IQ/dAp6zAq7dCqUIBFLNhCJL7Xxcff18D/u009 AMDjb3IOrbnTDjnX9A9A1+qt+0wRWyuIbSLQAhhygRZfgfa5Ai1CYRVWiEVu1GuBF+esKyfQAkjP n4d4Kcub8D8SAGBdqmCLZxnO/4eK9vwgFmjRf2ZAsAXwRz8CsHf/OA3DUBzHXbGxdmEBcREkGLgH EzMbIxylN2DmJswcghUSGacvL89/YhXcpN+PZJE0TuKqtEXG9o9QCwAAAGCdrMmcd7mTdrs3t91e DvtycfywWL4uMtxChlaEIgMuZLBFvy1DMUKQxT4843vShhKEW5xeqMIx3d+34ZRfh/H4Xd+G/cfR NPgiHmbh6/aPhs8CX+dThFoM17JCCeQxsb0RZXRcXGPTBwCsOEiiph1Luu6x3N/qhR56s7vfsUkP twiyiI2oP5N1jPrWqPreRVf3qizY4iZya32LkjTq0VPOHLeaHdP+TQEAAAAAsDy1bgDwD9678vW7 HeuBtSbwWJN8rDCLkglLuRCLOaEVuYmuTDYCAABArQfHghcAnDsvqGNNAHRqf84kwZI6jDvAUry2 bgCAxUh9L+bOAbBe/J8HALAkj84vxphadCoXeGEdsxapSgVbOOOxmr+3ARzWbesGAMpHxTnW+EF5 LFZP/0yNDdTX1dcGNAItgKnaQItciY0PD/u5MAodYqHDLnS4hXWPmjHnBFoA7YX+iGvnv7Nf2jUF AIA/dd+VZxdfemtOuEVqTSyCLYAD+RGAvbvHaRgGwzj+Vlk4AAsThQGYuQBX6BEycgnOxCWYQeIc TCxdWoFN5OSNYzsftHGg/59k5atJHCQgdRw/hFoAAAAAf1/sS61ef23KY9+B1utb2e/bh2sGx/+q gyd0kEU1Lz9BFTrYwoZW7HbdMAs71ftVgRY62EJUIMD0Z1mEW5xqqMIyzl/VIf+z2Hl/Dk0whQsL aIdUiOg2u+ZzfnBDu03PbbN/P6zP7XZa4IS/TyTMYlUU1Tlb1zC/3IEPDoEWBzynNL8f9by0Ex9a 6Q8qtMKGWcR62df7qeOt9PnM9MxMz4eFWtyYcq8OG2qwL6RbXb/RPhZ0ISLdaqr1fduH3PMAAAAA AOZXmnKZuxLAkdm03efE9r6ACLcce0Ep9MLQoQIt+l5mFW8dAAAA8Fub3BUAsAh33nJogEDflLCK vj4IoePRzwBLVwptrgDmwf9E4H97z10BAABGeDLlQrrvr+jBqIYMVhWbDwVZ+ANWpUJXfdxLA/O5 yl0BwPMx4rOpQcBTYRax/n5jzkF/QKTYe5nSlFch0AJwXqT6XnKsQItQP/BYGEUs0CIVfDEk0MKv k38Noesk0ALIQ7dT2L54b6Y85KsOAACzcMEWQ58LxJ4hjAm26Ht+IImpRJaBk/AtAHv3j9MwDMVx /ImIBYSE1IUFxEU4A1dhYu4dGJFg7IbYOA83YEPqElKlLs/u85+2ahw1349ktSUOeSqFoMT2j1AL AAAA4PRYEz9funae2mmx+JLZ7HbzWi+E/x824TcdbqFDK1xzwRb9ox94oUMxXJCFO6b/eNg6SoRb EG4x9Z9BX8dx3wc7IMC/Nte21p+mkrXqZWvb73JpFWE/V6/DOnX4xtl6wX8XaKHDOYZWO/DB1XCM Omq+rzWO733qg9AJt92LbVZBFrEAi0b3MfqHV8jXB5eb7jN+1zQlZT9EDh0eIrfdGuSf2r5VdkL9 XxIAAAAAgPZUuwBgAJ/qeexqa25S6T4TlqzJRW3Q15poZPWPTXItCeQAAAAASt137bF2EQBG42KP faywCmubiD1+YNcxBYxBwBjNaxcAYNRKzn+HnN84NwKn46d2AQAA7OBS+gVkr8Sep5IKsojNgQnn ssQWrkrNbUlNfuN/Z2AYhL9ibL4L+6XCJVJjDa19c/1i3x+wuECLt8p1AGOyCrR4lbIx4vpruVAi K1giF0ihwyt0I9ACmA53veG6a+9d+xBCqAAA07EKtniW+H2CkpBrKwgjFoYdhlyI5O8VWLhfgMn5 E4C9O8ZpGIbCOP6AhakLLJ0QAzNIXKATMzeAjYNyAFZmrsDSpSpOUyev9rPjFrVO4P+TrAQnJFaR QDgv/gi1AAAAAKat5B/c5kXxp6ELzec3slrtXq5fCH/dBU/oIIt2XzZBFTrYog2wkC7Yot3qMAvp mr9mH5aRe85HuMVh968frFD/M6h9//o/g3Ycx/ocwtCIeE7OPhb3x4EDPhRjLbPZ1Wb/e7nMDCXx a9H3b0Mr9P5ZE2jht/ocfe4J1A580OOY0nWncP8uQEX3qa2ukt+pmFehFU2YRWomvfu+IDjjXPow jUu3vS77DO5ce1SXzU3QW0NPFf2HE/Ulxf7WcSb3AQAAAGBcFq7d1x4EcGSfrr1njg8FROj+1AtL ufCK3LmpvtTLRiXjrj+ZDQAAgCl7rj0AAKPSLDaWe9YvEtcGiMTn514OtI5Z/SU1B9QeYAxehYX6 ABwWDDWEv3fA/0OoBQBgam5de5N0EEUq2CLc5oIurPdchoItNIItgNNb1B4AEPgy+sIaPWsR8KGF wq3zrK+te1Dzh1IEWgCxfQMtUiFD+wRaWEEWpSEWKykPtAhry3M16gRaAOPg5xkeXPtw7aXiWAAA qMUHW1yIHVAR9lstfE5grZX1m2CLkucHwJ/2IwB794/TMAzFcdyErWsZGPhzBXZGLsTCzlF6g94E cRukLkAUjF9enh27RLyo/X6kKE6T1FYRRTi2f4RaAAAAAKfFmtj5NHfTbrcP2+3t77Fc9D6FTYw3 GW4RwyyG/acIsxgHW6TAixRuEYMsYp16P/X3cAsvBCus4TPwrt//ZzC0Y9nPIYUxpP62lBuhgyuC KstADHnvtD9vsxnC4z8Oh+p2ZU4MIRaxbWq7cAq0WAMCLZavt1N1j3qsfwInRj3cIsgiN4r+Ul5j XB/fT9bXu+66cNNVdQc+ZqrWVcyd11vL4P856/ilAQAAAAA8ezcA+Ad7UZ6bsBTLpUlJOqDCOi5N NNLXlQIwaiYe+XdaAwAA4JTwfyIA6cp4bS7goiQ3SbC2bL0XsDav3g0AsAp3TvXytxE4Le/eDQAA 4Aj9XNh+waqaYAtrQSq9YFVprktruAVBcYCPB+8GAIIVaNGidWH0EKZj/HLn9H3WeZw3Ai2AqWMC LeI+913eOh7cCq6wQiysMIuacAtrXLludyi8FoxjAMuT/Q/9+Lu37+3erzkAALjrnxO8hOnzgFxo RU25NdgihPJzAp4V4Kx9CcDe+eM0DENx2K1QhcQARygL7JyApTNXYELchSsgcRhWNhYOwMDAxtCp MXZrN/aLnToVqRF8n/Tk1H/i1zaVG+fZv6PaDgAAAAAAwN70Lbb0nBu733Wi+fxSrVbx6dpN7/VW eCIUstgcq7VQRShskROzCIUswnatsIUauNm/rzv8vt53U2uP9fr9a9d/vTmR+p9B7f7rfwcbP5Tz Y98zdOfbQhELKXThj+P+ukIY8lzWtJ6o2exknf+1XJZ7aNv6NBCqmEyn69ed7yDyXbXiFiOJkdS+ BjyIWRyub5sbjWD2OjTXl5/R9lEhkWiFKfdiFo0dj1U7Ux7WbVz9bbSIu25Xrq9jU2aFLd7t4NvP hbErYy+qFa+I3HJ5WuQ1Ik1tlign50PTIpWE+akf5SSTDwAAAAAAAOMwN3ZT2wmAkbGLAd56yuVC Hpn2LVjKiU8MEbRICWP0CVmk/M29HwAAAACAoVwrFtMCQExK1MIiYwRkmU9TmweW1uuLr+T+F34r t4qxFABaDjVmlaxJAAAAAAA4JHfGXo19DGxXsml3WGZjLMLNqppEndRal9R8FvNNAONwZuy0thMA AZ/BcS7+rjRGr6QsJ1CRa59j33bwd0DQAqDLo7Fn9fOCFql48Fx8eE7EYpfYhU6ksq9cbLn0W4m8 3OcAAOPhn8nZ+58nxTotAAAAz8KlD5nyknjRXDv7PzoUr/DPB+T+WXIPLPn8IJXHf2j4F3wLwN4d 3DQMQ2Ecd1Jx4VqJG8zABIgjYzAIhy7BCKgjMAcTIDEAp15RaVrSvLz42U6U4ET9/yQrTpwSU4oQ ceyvjJ8CAAAAYCEKT/3VRf7Z3m7f3Xp9e96X67Y3YRPtIsMtZGhFXexgi3a4xelrnery2v3WjrfG xhJeuZ9snfqFXH/fM0hkij5kvTw/g3M/xngfdEBEN1y2afffC6z6UOhQCaEsr47b790u3ptAmEFR B1XIc2TARVl22yeQO/ChRqDF9Nf2raqg74q3YpurIAvXTZBo7ctz/ur1Mb2Sg9y/OXy+71arlG/j wbi0Tpq22mRXZIm1W4tR+MzjlwgAAAAALtcmdweAf/Am6vouqjVxVG99gRV6olBKkIVvopO1nzLx NVQHAAAAhnjO3QEAsxNanN8KqUipp05EDF0DmKNN7g4AWDz+1gGQPnJ3AACAga4P5cWF56t0ptl4 jvWZA1N4tta9qFAAK4Bx3efuAKB8DXiNfoYw1hZaPD20bz3fCBBoAXSNGWgRC6/wHftxwwMt9NYK tAg9Wx4LuNDvA4Dp1PcTHg/l0xFoAQCAVgVbPLlmDEAWPV7ga7fGDqpj1jpYeqzAufCaWIwX4CL9 CsDe/eM0DENxHHcQA2KBgaUTQuICSNyBlZ2FM3AB7sXANTgDEgM9QBUc0qivznu2mz9yWn0/kpXU TbEThqRu4h+hFgAAAMBxsr60yvpnt0uaNK1Wt26z6U8s305wX2/X670gi3a9DamQwRZ2mEXd+2z3 N3dBGfXISfUJtxjeftlghdL7v4Q+lP4f7Pox9DhYY2/9QAs52X+3Kuva9vUxvKo6/19+r9eH9U60 3Qs62NZ1QRdym+psvmGT0oEPHQItpm83p21rtgU50r036i0CLJrgCnVUvWnbBSPo4nNdGxe+7ibv +Nz78ii6Yw3Qp27kt4Iu5G5rOR+p93OuhQAAAAAA87l27Rg0cMo+fPlJbJMKsYgV7UEl6wGnWHiF 9Tqs1x5AAgAAAKbC90QAmsuMbWL3A2j1QyYR5KFBHINXFw+CAYCp5ZwPc86hnFeB5fot3QEAAEa4 8+XFxUMqUuEW2nva8y25JcS1MDC/h9IdAAJfB2wbmyg9NXm4tk1OcEV4PyPQXK+8OwItAGlsoEXu PdyxQAst3EJbWuEWOSEasfvHrX3UjgOAecixhuZc/enLVbnuAACwaG++PLn47wPabwOpcIspgi3C pTNeAyfnTwD2zh2pYRgIw5rAAZhJQwE9HT0N16CD4QicgJtQMSkpGW5AwRXoqBiqNHQxWtsbK7Ie eRE58H0zGlvxRlon8USWV/sflnYAAAAAAAC2Qmgh523uTZPJsxmPT2vhCUGT2Wti+1BxxS1c0Qot KWGLTtzCzMUy3D4FOVafxNq35PpsbPUG1IdSudjL91+1/ZdxoPT5D8GH0t9B54dp/cjbiq9i3/jc F49otCJSOeznLWXOW/ppUvN/Tqcphxb3O+WMoO8Ldo69ClrU55fwalVKf7cKYha771uOVl594b32 Qhq1NvWMdn1tVb2Z8JlbtzYza3Pg2FYiZCHCUX4f7VbaP7a/7xNbPvRPN86FLW9t15XpT+7HxCsq Z6uuuEWPqUupSfvcJeh/tAAAAAAAALAbbgwB0/C3+bblyannFoOmbJYRtMiJVqQWIMUWHcV8Y+ER AAAAAPwGImjBfSIA+Jx5dT8WIPXMP5UoMLQQMLVYsDLh0A3uh2FI3Jd2AAD2inX/x2KBjsMIbgWA baBjXwFRCwAA2HeubHm15T1yfJlE3v7+KLCvuEtxUmPk0FyTibwGAJtxXtoBAI+vwGs5cYqUbSi2 MJV8PNV2yh/4n8jY5MGW69KOAAwEiQ1/NJsLWmg9J2jhxnmHBClCghX+NiZmEYopj4lZ5IQsiCsH 2D0653BkmjUrlwV9AQAA2Bfu2u1L4Fg/kd1qyJjbfV6gCbm0nZHpxtp+++7zAmJU4V/xIwB7d4zT MAyFcfxBFoTEitSpDIgDcAJWJA7BEdjZuR8nYGPtxlaVuGlk9/Fsx22CA/3/JKshqWOnHZAav3z6 JhsAAACA+RtSTPLUtsfciRaLpazX+6fzIRObIMDCB1l027INqgiDLVJhFmG/LtAiDLbwD/LX8zB2 F9BrNAp6Hj32ceqPvzG/k98bv+71z2EOtb8DP4+hn4MVWqHDLLpjPuzCqh/X77fGEflcreyjkeCK PqBCgrHPYmEXOuBixJCE2oEPPQIt5jG29Ut4mPjwIy3ChVWID7No+tfddiz+OezXj3HR7rs+H/Sz 4F3b7oPp6MRpnVqtp24FXoSp1OFlpx4uETtOgS0AAAAA1PNSewLAxNwCx6/d9pDCpVhLFQdZYRa5 NqTgKFeElLomAAAA4FDPtScAYLYuD+gTWzOgj4WvVv/S8YBaXDjUsvYkAJy83AJe/l8Cf4u7F/Re exIAAIzgtW1XYtem6HqWxthvbVulO3qfVegWq3cR4z0AxnFTewKAYoVaOKm1ealgCuscsfV+sWAL 6/xWH5wWAi2AfS7Q4k2mCbTIrf1OBVqsVSsJtChdX566RutzADCN/neDh7Z9CIEWAACUcMEWtxJ/ 3pW+H9BI/r5B7JFd4b0DvS2SX9cqkb+Bf+NbAPbu4KZhGArjuNsOwKFC4kLFpWOwAmuwC1N0A85c mKNHxLU7VCQiTl6d92wXarlJ/z/JStMkjYHSgGP7I9QCAAAAmD6tY9xr6qDd7t2t14/9+hBmMZ7E 3gdQyHALGVrhSyzYQoZb+CALeU65lAi3qHl+wi1q16H2z2CoR9734SQsIjL//BB2sRgFX8ht4fHH 4+/jr8MhWQ/n6xKEVyyCwIp+3+VyCNzoJvu/ZItg7cAHX4cS9Sj1ulM4/7nn1lqd+9K+lgtas0Ug xaiHfbetbyWX+3aPtd7zfv2heZ9vVqucaj87uzFfzd8wtocltV0bAGCp/wsGAAAAALeFCdYwd+3A pY/I9pxwiHAAkDZo6ZwwC23/nOCMWLBF6msAAAAAcj05BtgCsLXtSNYEgHI9tY98LjaBoNVVwjpH TkgGUBohwgD+KnXdsibZvfT1jusncJ24BwQAmIP7prw4e7yKFWwRGwcTPh8O59HWY21I/D0MlMP9 J1yTfWJ77v9gsUAKayJ1p6zn9gVMHYP5IdACOOUDLb5d/uek9VmtBVqEy1TARW6IRSrQQjv/fwIt CEMCyvPtB23/gM+m3FWsCwAAU/XWlK3TgyusewQlgy1iS2esA7PwIwB7d4zTMAyFcdwjEgtDF7aI hQNwAUYWdkauw8ItOvcu3KDMndkqcNQ+8pzYfkkTcNP8f9KTXDd13CIqcBt/hFoAAAAA85L651T3 P/t6sgaqqnu334fDNeES3yrAQm5LQMWhdLBFLsxCxpCSsWWT/L4b9i893KKk0sEKpV//c5hD6Z9B M494f7ipf7O2pgMuDtkRqT3qw/W4bkhAeHu723XPHQsWUPdFgwfaQRd1sMUx0KJu/4ZfjFA68EHP Y07jzuH8U5w7/psTrnAHq90SZBEJsNCr552ECXW8nOPK9636PYd6If9BTcdKqo4tzOeCLvTTzn3Z P3V/n7+NAAAAAADTYoM1XLq1r69jOxdaodupi5Vy1Q6nyIVfxI5PPd6ac59QDgAAAGCI19ITAHDW Von+IZ/3x4IorA0E2VgQc/Ho2JwPwP8gyAJYpo/SEwAAYAIvvu5c/PoU6UsFWFgBF6lrXawS1loW gNNVpScAtHyq9tDvFbpMu/1Ya0P13LHW/HD5CLQAQhJosXV2GFCf999TAy2sEIt22IUVaBELthgb aAHg78hawo2vja/3stMBAGDWrn29+bp1+cDrVKDF2GALKwibYAssxo8A7N3PTcMwFMdxt70hceqF S1FH4M4QrMCNIxugjtINGIIB2ANxQJ2AROlLHOfZzylBDuH7kawozR9brdpIru0foRYAAADA36YN gHuyLjoeX912u2v3uzCL4aL1EkDRhVz0QyukpIIt/HALCbLw6/S3lv8ablE6VKFpA+EWpdtQ+jNo 2pDzHnRBDl2ow2pwfHiOc9Jn179mda672X6cTtGwCbP3ToIqpM4wuMI/1r50WZ9g6cAHQaDF9PX+ pG6tx7kt9b1dENHsBVLUYRZ+oMWgt1wJu9BGy8v+zXrtbjebnGbfh1UpJRZekRrYP2bgv2UeXzgA AAAAWL69Y4E1LFudqPuWOG4FQsQmMmmTmKwQi1R4hbUfC7lg0hEAAAB+w2PpBgCYtViohUgt/BcO IIotGmhNGMypEyjlULoBAGbpauL7jX0m5oZD8UwF5u+rdAMAAJjIs8ubuxIuWDU2yGLMHBetDwvA dPalGwAEPkecm1os3Aq+0LbavViYHCECLYC++ndbAi00sdAh/zVtrLYWKGEFWlghFuF5sevDMeUE WgDzJ/0Fd1V5r8pDwbYAALAUdbDFS1WuXfq/gUuCLbT/DFL7OQEXwCJ9C8De3eQ0DANhGHbKhgOw 5keqkBA7TpAdO87ARZBYcxpuwF04Rypw61pxpjOOS2iTtO8jWUld6vwsCgoef4RaAAAAAPNRUjTy 4ttz30DL5aNbrbrDteESP0mARXwdAipCfxtc0TQuG2YRx4gtjh0XxR+yOD/hFuMZO1hhGveAcAt5 D9IQChlQ0V9LHl53gwKqbb5EO+b6+yNq1l80GTuhA1qARezfbqtkf7NZLGYdaDE0fOHY487h+Ae5 n8q+NhNehllcKAEW6ZPznVn6yc/HY1z6vquya7r37Sk9HTm80VeJrfUQP73svkn+2vssQgEAAAAA x/M+9gkAB/aZ7FsPYa2iUquASSseyhUvaU1+Jld0ZJ1n7joAAACAv6p9uxn7JABM2kPmPfl/fWsB bW0CUmnhn3UM5hRgCmpHiDAA3fWAz/K7DkCKUAsAwKm4daF2VtaqaItPVaLPWqBK1rqUBFlE2t/d peFwAMrUY58AIFiLokv7BFLEfTkPMLc4ed9xcZ4ItAC6vn17c2WBFlpfbl546ZzwNLBCBlpYYRda 8IU1h5xAC2D64rOBV9++HHPsAAD4T3e+fTg7+HqfYIvc+llDwrA7qsCdY8Np+hWAvfvHaRiGwzDs NlskFJiAhTOwcwlGxkocgQuwcQvUG3AIDgBnYGZCqjqh1qH54zq/2G6S4jR6H8lK3BTbrShIbuyP UAsAAADgdEk3uT36fmi5fFNZdl3V6zCL5ib9ZQBFHXKxKcIqVBFesTHCLORgCzPcogyyMPs0j10Q bhFP7GCFcbwHhFvU74Ev0GJ3XgdVmM+fWcf2vtL07O/8Z73euzbbNVZU5DbMts2wjCrQwpwIs0ug sUykHWsMsV9b7DCNwdoS6lXJf4eUMaut68l8LoZTiDPlQtiFa2eHK932TZKEDPvO7koobeEVrsn5 rgsAJPE/fAAAAAAwbee63MceBHBE37q8O663LVwqj77FTF0CLUIXHvkWI7nOAQAAgD4WsQcAYPTS gOc0bzLavyadm3XXxoJSH8BYPMceAAAAmLzP2AMAAGBAD7pcqmawhb2mxbXu5dASus5FmndiLgro 5zb2AADLl/CYvUmB6748aSNxX7hFW39sTg7ThS4fikALoJT/vX7RZdVyfahACzuMwhVm8Ws9HhJo 0ee+cul18j8D+F/lnEAeOvWqSxZxLAAATFUebPGk+gdb2N8p+IItXN8dKHXYfa3AydoKwN4d4zQM Q2Ecf20X1JkZZeuIOEGR2MoVGJA4FofhQsxMlGIreqrjPjsOpHUa/X+SRZMmdlqJSHVe8hFqAQAA AFyH1A/RcP2za7u+jppmI/t9t7tjuMQhCLDQ5Tagol0vJyEW/q9f1qbrtQ9t2rc+AH/sB/ETblFP 7WCFaXwHtcefRrhFPI92zJhIpabawRdxTa8GXvjzynrdXqv79ieUYK8hFnH4hRFisVguu9sM6bcy Ai3GH/fcY1tV7BpokUqL8LPfKyPAIpwtP0mYCLbXMW7cutuyz7dx7SE4HKvI31pn3ShgFfiLdE8C ucn61MnDMo1/TAAAAACYh1ehkBrz9h68Tt24UxJsURJoURpM8RPtOzTkQqLXAAAAwJgIPwRQ4i5a LnngX+49q5Yg7ju3TV//wKU8uratfRAAAAAAAFwRH576Jun7U3IPnloZ7+ceSlXaRMrnugAM09Q+ ACDw6drXH/aLa/mkZ7mvJjG1T98YmC8faPHh2n3tAwEm4pKBFmF9dyqsIhdiYYVfWEEW8VhWXTmB FsB06HyBr6sjdAoAgPN7cu1F/h9skbpeEF83GBKGrQi2wCz9CsDe/eM0DENxHDft0IGxHVjgBqys MHEIjtCJI3CbHoFbILGxcQHE1LFSSUidpM7zv5Dwmur7kSzaYstuEY0UPftHqAUAAAAwTVKh2zo2 aLN5Ncvldf28CbPoHspvAyiakIv9IazChlns64CL8rV2sMVu1/RpAjLswfvduYdEuIUe7WAF7c9A e/5qDRp/g+oryAZPVJ9DO9jCf/b8cVBANwxDqu1dLC5/f35vt4nLu+gGU7QDLEL93dAL7xTjhx6k GGsd2u9Pc/4x5w1FvJTz2gCK+o62EGDhu2su9ZVOhLDPr2YzczOfpyz73p1KaL7NAaHi/tjvQzfu Xfr/jAAAAABwvp61FwCM6OPQUqRsXsrZ0BRrbihGaPORb62x1wAAAIA+ykALwg8BpFhl9JUCKWJh Fb4yjBx9xgB/8aK9AACT1+e6lRP0xHUROA/v2gsAAGBgd0W7NfK+FGl/Supel9gY374WaXMcIRfA MDigHafkq/XYV5MnHZAe6ucbE6oJzK39S6kxxHQRaAEcezP9Ai1CARGxQItYcIUUYuGOccMtUmrI CbQATpO9B/BQtE/DNRoAgP/yVLRHkx9s4QvFjp2rlRNuEapxBSbtRwD27hinYRgMw7CpOnRj6tCp CwdgYKc34AqIgZmrcBJuwMQhOAVC6lyB08iN4/7+7YakDs37SBZNcBxHDFGN7Y9QCwAAAGD8chaP PJj6S7VqtVqb3a7dXBMu8eMFWLjjKpjCBVuYQ4hFda4OrWjCLFzgRROAYQ7Xurbdpv/n2HSfcIty CLeY4t+gGTtrAgiuvHALKdDCtK4J25PCMKpz8/lif/S13XbopnAv/1z4eTZTwyzqauMYHxyqH6Wf r3SYxlnv59135t1bm0G/HxEXAiz8EfSjWfdefdf+wp5b5j3vjS13XnekQXgtgTq2CCAcjE8N0sd+ f8qCWwAAAADAaTa2rEt3AhjQm/c5tnhHW3SqBV2EC4u6BlrEFiJpC5OkvgIAAAB9eSzdAQD/xtIc /18/J4hC22Bbm08Qa1eqk3tfoE8bW+5LdwLARUu9y1Lv5K5t8w4Fxue7dAcAABjAk8kLsEhtQhWe k9pIbUoVW/sC4G9uS3cACHx2uCYnwEKqF/7UNi2XNkNgvuA0EGgBtH3Y8mq6BVqk5oDH5n/HgihS IRap63MDLWLPEHte6RhAf9x4wIst77ZcF+wLAABT9GzqfbFioRVSsIVWLzcgW5uzSrAFLtqvAOzd P07DMBTHcWOJBQkJqQtLUc/Byk04AUdg7NQLMNAbcB0OgcTEDDbBieO8FztSS1L3+5GsqG6KjfhT cPL8I9QCAAAAOD1SEclj7kX7/ZtZrdbt4y7MYrgBfwig6IdUfLfBFqH5MAvfF4ItmtadEwIyQrBF PGZ8PCbCLeZDuMW5fg2GdeDNFLrAiy6wop8Z0d9TP9rUP3rC2svf4+eXdk+BNi1hIH+8CPP4m1eY o7WDsYcfchnrggRaHH7c/xo7HcUHTrSr0lH4ROizQoCFGgUtnKvtyuDbrfueX9uipcL7dCihaeEV 6acUt9zz2uYTkmX8cAIAAABAXZ7mngBwRO8mX3RaUiwqhUukRURaAEVahKS9fqzQ1SSPpcVhipEA AABwKBvDZtwAyt0p/dr1/dJgitxmgWMbdgNzep57AgCqNPW9riRgCsBp4noQAKB2G9ceTL52JVfn ItWzTAm0SGlrUfydDUxHqAWW5mPCuaX39Gn3AmphFWNj5PpRFwItgD4faPFi8r8btXvApT4pUGIs gCIOsUiDLaQQCwItgLr4//tvXHt1bTfzXAAAOFdXrm1duzbNe3NJYEUcbDHYusvI1wxyRy24gmBs VOdHAPbuH6dhGIrjuNkQYmbOBDsnYIaBjRVuyBk4ChJ7T1AFh8jtw3nPz6UkpuT7kaw6f+uCRJBr +0eoBQAAAPC31Uy2fIjl3rtR192E7Xa8bBou0YsAi7Q9BFOEXShFCrEY9o2hFfswixR4kQIw0jXy njLcogXCLdoh3OL//w5kSIXYK46P231vLae/v4cME5iGCwz3GLsyPjab6rad2ckZuyCLSUnnKgEH S4YelMzVjtafr+X7N//ccjurW6Pov3rHlQAL2VM+GWGvBGacx31XdaEW17HcisutTnuvg96aDBBE 3VqEonS8dsELAAAAAEC9LpbH1o0AZvQq6jUTeLxJp3mAhRZUoU0+ssIvvLALa1JSqQ4AAAAc66V1 AwCclAvneGkRQG04hTZOwBtrUPOewBLuAsFQAJbFMw9Yt7fWDQAAYCZPsVwGvU9Im4LjLVhVCsE4 NOSC/8GB43WtGwBk3ivPsxYSz495C6p752n3ZnzgOhBoAXz3k0CL9Gr9vc3HgB8aZqEFW2h1L9BC G0+uPRtKwRb5zwHA70uBFsPz+blxWwAAWLsUbGGtiWUFV3hrZ8nlu0rfF2j7g/Iq8X0CTtanAOzd wU3DMBTG8dd2hAqJC0IcucEEsAA79MyRCRilG8AmXLkhcWANSGpCHes92xSilzT/n2SRhjR5Ra1Q HdsfoRYAAADAtGiD2+5LT9pun2S9Ptttx+vaa4vth+AJ6YVUdKEVIczi8yfgot3XBVuEtj+mfV53 /rCgfv/8niEPfzyDEG5xaA2+BXj/DbyvH2oYMtxiEYVbLKJggv643BBsEQdZiNT0v+2zBkJXxocV alEZiNALTkiP78IslAX+xxBm0RqqDu/X5x0q4WGZvGd7PdNK+MRSCbAwe86VY+NzpwEip817/ny1 qin7Jr2U0qzwivQlaRMHfjPY3zKODysAAAAAHIeNdwHAgF6/W05ukmjtRCErqCIXcKGFWZQms2qT rQAAAIAhbLwLADApl5nfpff3rQUAc4sDlsYSWNdgbAE8PHoXAGCWCHkC5on7RQCAY3bStDvR56No c1qsY6y5LNp2aa6LSL7/CkC9W+8CgMS7si/9zlUKsrDkFiPPXYPve/Nz3bQXIdAC6DzLMIEWNWO9 40ALa7sUZlETbqGNJ0/rlsw+UR4D+B9dX8BV096E/88AAIzFRdMexL4vkC7PFf+sCbuw7kUceu9A ewxMwpcA7N0xTsMwFMbxx4YQEgs7kRg4ATMSEiwMcIQejDtwBG7AHRhYe4NKOA0mzuM5eQkpbsr/ J1lq4iZ5ytI2tf0RagEAAADsL8/kkcfQ7odOVFVXstl0T9esa98scN8GWMjXdh1MEYMt5DvEot7X hFa0YRYx8CIGYMRjuudswy3S6y874IFwi2nX32WogreG0vfgkMMt0rCKZJH+o3Z/GnTRLaEv2EKH Yoh8rNeOclQNMawiDS+I27ovqbnzujAdQrDv513C9Utf+8e+nte5kfTbp+JGgEX61NyTGHEcjjv3 3YvL0K6TUw0lTlsP4vuCLkTsEsXZzwRcAAAAAJjXqnQBwA69JK+nTOKxJgjpiUS5cItcaMXYMAsP JiQBAABgTk+hXZQuAsCinDje0/ffv3dC31CfNaaAsQT4S1VoN6WLALAYns/PKfjsA/6f99IFAACw Iw+hnYo9TaYvzGJs8yxCpbf53g38TlW6ACBhBVp45BZRt8YC6n4x+vT7rGN0Pw5D/b2iDrR4Ff6n B6JnacaAzxVoYY3v7tunQyp0eMWYsAvrWrlx6LpuUfty9wHAvOJv/lVob6GdlSsFAAAYbkO7k+Fn /7n1sobCLMaEYefGwjKOFYv3KQB793PTMAzGYdhtFkDqhQtwYQCu7MCBEZAYgBXYgA1QN2AIlmAC TkjdoJBgEjvO99lJFclxeB/JSkhS2/SPoJHtH6EWAAAAQDmkL6aPqQft929mt7v43fcXkHdBE+0C 9zaEwm5dSEUbWmHDLL67gIvmWBtsYYu7pq3Hr9tvX+pHDoRb5Gnbtk+4Re72bR/mex02veCH4fxy t3i/2/oBF+Hx/jlX1/Fob2V8Hg6pDrmttEi/cHzjBVv0gi6228UEWpRUbwntL6Vt6S5zV7ywim5k vRBgocVBh9dWQn1+X87r9/tVVY35FW7DpoSSGvwv3YRPndcWmZDk/+ACAAAAQPkeDBOgsF4ffyUm NqE0FTyhTWQKQyu0c7FJSXOFXQAAAACnuM/dAQDFuQx+joVWhKRzw4FIw7q1yX9ATs+5OwCgKOHf T83Y8XQA/i9CLQAAa9UEwd0ZeT7KmBJbnCq1KFVqzosx0+6BAXDODGMWsSxf3r62YLgWQCFdqz0+ tuC61E6KFpCBsjT/P9wYG2jBgtmA1QRavJvTAy20MAtp7LcWaCGFW0hBFdr+2BCNVKCFFHARPg8A 5tV+t3+py2vOjgAAgKinulybcWEWWrjFlGCLKeEWjG3FKvwIwN4dIzUIRGEcf6WF6bS3yKSxcbyF 4yH0Bt7C63ghK7scgkF2CLB5vMcuEdww8//NMISFLGuaRHjLR6gFAAAAcJ28fzbj9lBw95LqaL9/ lKo67659hn19FmwRQirCegimkD7MIoRWVFW3bwizGI6rT4tES9332YVbTNl+wAPhFpedn3CL0udv x7DGAOJwinZ7HGghYtfmegEZg+/jMXqbDs6whhOdMwqskCjIwm1P9f0PCLRY/rzXfG6vYl1fxR5V 0hthF33IxWm7C8XwrnzfNPvu8z6bQ7M8R8PJvUBvXZS3gixE7CFK5v6c31IAAAAAgLT30gMAVvQV vdYXSVMXTb0JTnoCUU6AhRV0kRNcYY2VSUkAAABYW3iQ0FvpQQDYpLsZx6bqA7xjdB9Tk/+8NuoK sJYH4TsUwPrmBkUt2T8AAABQwmuz3Ir/wChrPov3gKm/PJQKwHKeSg8AUH4ueI9X9ycyrj3UbXrf 1PbcukdsC4EWwNgSgRbdtlXzrWu/5wZWxGvr9VSghVeLbrVbf6P1OQBYVvhuDrVzYR7KR+GxAACA tM9m2cl0sEW81m3WcdbztPR9Buu+QU6gBfcasCm/ArB3BzcNw1AYx01749ITghuswB2JEWAKpuDQ G2t0A1ZgDDbhUgJJ06SvzvOz0yZYRv+fZDU0ie0AUiTH8UeoBQAAAFAGbX3rl9hJm827W61udtty zXoZZtGGCrSffijFdlv1wRZdacIsmu+6YIu2yDCMn0Hdsv3Y2vnlBzycXkH5135O+4Rb5G9/qr/B xT4PIry+vB900R2rnXOoq9UE64iK7J5o+73vjsIs5DFNAMBiMdz3x+YKX8gZ6pC7/dzXHdyn/NwX EVbRj2ArARbBUXNvvzoqLvp2Xf/v3y6XKZf04PTBdmvSf7AL8vIi+8dM/GfAHgAAAABOd1eXx9yd AGbyuS+WUHCF9rJp7IWi1NCKSvmsvH749ci+WtsAAADAFJ5zdwBAsa7c8Fl/ShCF9fKeFX5hnWO1 G+obcK517g4A+Ddi9yjrXjt1WwDK8JG7AwAAzOjStcEW2jspWihF6vstWh0p4Rb++FRsPAzA0H3u DgCeMaEW1iLrsTl+oaCKWBvWouYoF4EWwLGvury5eQMt/PLt9GALbdsPsdCOs0rKXHPrGrXfA4Bp yXvzU+a+AACANM3zg1c3bj0saw2tlLW0/OcS1pxY5q2iaL8CsHcHKQ0DURjHpy1FF25d66KI0IXg LQRP4MYreAqv43XcegqhUOqkMc3M+N7MJLGdJvx/MMQmTTJYMGl8Mx+hFgAAAMD50b5UuuufbXtK HWi1Wpvt1r/tr+es33nBFlVIRb3cHVodUGH2wRZVcEUdWtGGWTTb2338QIzmmE24RVfjDnjIqRk5 5vn7m06wwpA+lP4dlD5//89AnrC/fXbmBxnIz9v8YAv5+MvlxX75vdlIb/KXGdtmzvrZfF633zCL KYYvlAx1KH3+kp9l13NrFetSZbz7VHwRhF2Erw/7VX0yctX8pd12ndffO9sene5ID+aldamBAVIB v1TYn9qec08FAAAAANC9le4AcEQfzs/aIE9NKuwiHFzUpUnBFtKgJKmvDEICAADAKfBdEUBf98r6 WHhF+D6tViC2fypEAziFW9teS3cCwCT857Ur9xoMAAAAnLsq1OLK/H1mpE0glRtwoQVb5I5h4V4b 6OemdAeAwJewLjaJeKyOT6s5DCcsT01mntMfjBeBFoCvCrR4t+3T6H9/+wZaaMESWihFGF6xNfGw i66140MCLYZNcgMgxr02PxTuCwAA6GZt24uJz4elzZe1ULaHr3NCsGP1rvxvAaP0IwB7d4zTMAyF cdxRmZCqSiywwRFYkRg4BmNHjsFRegNuwszMzA0qFeImTh7m5Tmx0oZE/59kEZwUG1CTNrX9EWoB AAAA/H/am8+X1IN2uze32dwct+X69DLMolq8vvr6O5TC1SEWVZCFD6nwQRb7/aEOuvgWpT3WHxf/ bNl+zjr58w54INwiv33CLaZvP+d/EIdSFE1dW9+e0mT93wX/i7ofVQnH+fPMen113KeGWqR6WEQB GzLQIoRayH2ynBGBFuO3O4dwEu1Z0BQRTtGMrlcCK0K58IEWrg26sGKgZRvBdflcuF2t+nT70aWT plOD/rUb8ENu3qdwsx4AAAAA8myn7gBwIh91saQmiGohFn0CKbRJUH0mJVkBF13BFkxMAgAAwNju HBNzAeS7zHiMNYGvK+BiSOAFcC6vU3cAwGJNdY3j2grMi7YAKwAAS+LvO/lgCy18QpvTcopgC+1e lYvq5PcAut1P3QEg8tVRb43V6xtIYS1QHi9SoO1jQfPl8a8TnhyBFkAQAi0+nX0eldvWGHBrzLcV PKGFWRyMulSgxZAx512/W9ffAcB4wvv5bVneHddmAADm6rksD87+3MAKt4i3tc8OhoZcBIxxxWz9 CMDeHeM0DINhGLYEQwZWJDYYKhY2LsCIxMAV4AZwE27AFbgB52CEM7B0qVKHyOkfY/t3aVIn9H0k q5GtNk4RauvY/gi1AAAAAKYl9sNS1t/bcqu90GJxZVar/lf+dn/6uhds0YRUtI91V9qAijaswg+u aIItXPvmOTIQo+5e04VbDGHeAQ+7h1uUMs9ghaH7UPo9KH3+nL/BJihCjp31syC0oNjwuFsojKCq Tn4ev5fLvIuIhQqIehdm0dUHQi/2EWwxVvhCyVCH0ucvfd07Pd87lv8tsZHtZvT72AVceEEXss6F YsRGvivbdprX/0tbrkV3tAH60IT+VNCFvPzYphPaYoAQBvMBAAAAIO3RMOEa/9ebON52UY+/0Eke 5wRXyMVIOQulUotaUwtYAQAAgDE8l+4AgFk7T7T59/Bjm/xpC/pScwFi52D+AMZ2YctD6U4AOEih zzg+94DD9Fm6AwAA7MGdLc2CM7kpVWpzqW2CLXICLbR1LwDy3ZTuACB8KO25c/Zicw39NmN+zwUM zVXU+qCFaWCa3KbZ74Y53EDDBVp8mfKBFqljLcwiFnBBoAUwbe73/IstryU7AgAABvFky5nR7w8c mc0+WaH9srRwC7/ur/cRuLeAyVsLwN794zQMQ3EcN1RdWMqABAsS9+AILBwBiQtwAAZuQm/AdZgZ EUvnKoK4VpJn8/wn0MiN+v1IVpMmTVJQG8n1849QCwAAAOCwaQWYj7kXrddvZrW62i3LuehlmIWb qN49+qEUQ4BF05g+5MKGW9h1F3Lhwi222+9+X7tfeGx5/n1Nyn+s4Rb1gw1qn59wi/rnz/0P/H6w IeAi3HbiBRy4rIgwyEIe83dbLs92Wz83m/I3IMIpwrAKG2jhhVcMF+bvO7GpwhdqhjrUPn/NII2/ nlubQaH/hIiQin5UvHhuYZe7Zvwecrst1lPu9YKL675sPxvXp0Xdh7cm3Rk/ZqC/bGNSqHPorAcA AACAcR5qXwAwkXdTXmiaKhLKFTjFCo9KQi5yBUolBacUKAEAAGAK97UvAMCsXSjPxYZJhMvhvqmC vtwxtHEGjCnAlF5qXwAAKHL3Pu6NwPzxWxEA4NjYYrM7k647GRNmodW8pOpbjEn3OaX6ugAMbmpf ABD4EsslY/W08X0lgRTaeMCxk5pj3rpACybNBpyPtj0bF2ihiX3Pyudi477/G2jRBC0WXNFtD89R Ol48fE/yMfw7ANgve18+b9urcRNgAwCA+bO/ITyZdJhFbH2hbNdeowVky3VNbKyrUdaBg/IjAHv3 j9MwDMZh2ERC4gaMZKjE0IkTsCMuwMRxeqcuiKuwIrF1a1VsghvH8ec/osFJ9T6SlbYmsSUECsSf f4RaAAAAAPOR+qPTeNbtKXWh1WqtDofh7X63F/1xEGxhAiy64/HUuoAKdQqy2O/7kAvz3vZ1ARhu qIW9zjA4YyqEW9RRf/x5hFvUHn/e34MrIdDChljIa3XdDIBxIED/vmmuf45fu13BzEcD9ONEAi/U H8IJyqZGoMW5x6059lmv5712f3oG/9H+DbMYRT07oReN95k9T1qtf6P7bvNCLe51e3CmkxtukSoK CG00IS36j/Xn3GMBAAAAAHqtbo+1JwFMZOu8Li3siRWapgqM/CIkKcgidH5o7FixKwVKAAAAmIIJ tLirPQkAi+aHWpQU4OU8909tGgjU0Or2WnsSAJCBkAvgsr3XngAAAP/E1N3GQi38Ghb3s1Ati98f 2oQq1ZTifhoo0daeAOD5KPja2HrE0rCKkvAL6RwsB4EWwJD53bvR7VPol4KA7DEWaOGv5ZaCLPzA iliIhRR8EQrNINACmD8baPGmeNYPAMClWev2otLB1rGWu6eWtLdW6hkCwRZYjG8B2LtjnIZhKIzj L8oGQ1cWuAGCG9AjMDIy9xQcpTfgJIgzsDMh0S0qSYMbJ3123CrhJeX/k6yQxE0cIYTi2v4ItQAA AACmS3vRXPV9aL1+lcXiavezv+68H2ZRL0pfb+swiqa4kIqiaEIrqjCLar8OuWhKE2jRFHdt//5j LsBPuIUN+/vbhltYP/8U2qD/DvQ15jM/QMI7FwuuaNdvH99u8932a7NJautBwMHvfhYIs8j88622 D2+s8AXLUAfr+1s/9yDXUfb3fwleSIU7lnthFt3gCj/kQq0ncnA9/zmqUIvrtGCLBzmt8z028L/b 4Z8y2D+GjnoAAAAASPNs3QBgJJ9leeupkzKpKTS5KTTRKTYh6ZgJSlqPMBOSAAAA8FcerRsA4Czc JNTRByDFxwh064qyr40ZCB1jfAGG8mLdAACzdmndAABngYVNAQD/yUVZlpIeStEXYqGdj31WJNxv JaL3XQFoW1o3AOj4OLJ+bIxfaPF1t9UWM+97n+N9b/4ItADaXKDFd+D8WIEWobCKWIhFETmuBV4Q aAFMX/V/+b4s72W5M24LAAAYx1NZbiUtxCKX09bRSg3FDn1nwHcHmIUfAdi7Y5yGYSiM45ZYWJDY GOmQjZUrcARmOAen4gbcpXOP0CrEGDeO+17yksp1G/1/klUak8YVEg3Gfh+hFgAAAMB10P6ITI/7 zeFvUy/UNC/ucBje6oe68+0g2MIHWITHPpAiBFS4Y5DFft+HXPjnsS8EYOSBGP3xGJhxSYRb1FH/ +oRb1B5D/BlIwRVpsEF4kAItYvCFOzlf4vvbNvRvd7tlg5aCB7KQC+eL+CehFiWUDMqoaQ2hEkuu W/La2gr2v+CK/3ZcHZ8EVxxnxZMgjDz0Ip6jzXrfd31PtlCLpmuvrp9ct07KS4v6pYn69O1ri/7H +i33WgAAAACA4LP2AIBCvpOv527umbvhSTouBVtI4RbWJo2dTUoAAAAo4bFrH7UHAWAVfHFuS/E+ y+Y8ac1A2jf1ulKBwbGig8BcG8fnJ4DzWMKgzmXZHM+meWAd5hZiBQDgVr07vTCUtI/FUrjKWoxK 63eO+2nAalN7AEBmKxyT1u9p6/akdYpTQRb5edr3aNfA7SDQAhhaGmgx1bRAi/h8KowiD7HIwy7y cAvpGvl6cW3tuPQ++b0PXEYMtPjp2nPlsQAAgLK+uvbghvP6aZ2sO3daCysPuNDqakn/c5gTbjG2 7hW4Kr8CsHf3OA3DcByGjdgYysLSgR2JhZlTcAVOwAmQepTegEPAzCnYu8FUQUxwYjt/fyTCcZS+ j2Tly02coYpk2f4RagEAAAAskzRB5DH1o/3+RW022999e6F7O8yiXYC+3bqhFH2AxfGoupALHWah j9uQi76Yun2IhX/v7+7ZcyLcoo76zyfconYbzP9fnvvtzvl2gyuG21Swhbn2cTgELssBAyZ4wAmv sPeFc2fm+B8DC0oFIJQOVljy82s/u8h9hePun6GDK6ygCtObPejt/qtjh1ycW6EX0dH11nvpUIvr vGCL+1BTRpTYxIGcjvoUOuoBAAAAIE6HKzMAG2ukE3JfE3VygivGTHaSJiaNDbKw2xVqLwAAAFDa Q+0GAFiNm8D53MX9pkzoU4k6jCNAKbvaDQCACfguAutFqAUA4FRcNeVWxYMm/IWlYsEWqfAKe9+I 9T+l6gKn7q52AwDLV1M+J/zOH/+n1HCsX2rx8tA9pDrSdSwfgRaA660pz6pcoIU0pjsURhEKtIgF X+QEWvht8t9Bek8CLYB5mO/ye1Mu6zYFAADM4KIpT2oYgp1cyitx3r/H2PWx5MX63GvAYvwIwN79 4zQMQ3EcN8qCmNi4QMXCgMTABdhQD8ERuAkH4BJcqXuPUDXEWE5eUvs9A6kcNd+PZJHGqe0OJP0T +0eoBQAAAFCf9QHT23bl1Wpos3lwx+O4uXHYRCg+wCL8bfsSAipcH2RxOAwhF/5xrAsBGNNAjLZv M/YX+q4XNEC4RR31+yfcouYYwiL4rdj+2XJDUMVpoMUQRpAKwbgaBVHE4+J5brffWwM6Da0QdbmQ i36feDxXqMXZAhAqhlnU7n8tfcuefFjF9L8l7ovbMshCBlykQi+mz5+W667urmlKhnnflSeXTqG2 giy0iQDpE0R60QmtvuQ9FwAAAACs3VvtAQBn8iW2fzvBpyTsQguomCPcQpuoWvo6AAAAgL96rz0A ABfjRqmzAilS9dq9AtYEQK1P4L9uHaFQAOZlXdNSx+eeW9qOdRzXUQAAACxVnIerfV9UusCUNQcm 127p91MAxh5rDwAQdmI7dW+eFVwx3a/d/5dbvFxrNye1ODqWxb83+HAEWgCRD7T4dGXnUbkvF/aT CrSY3s+dC6SQ4RWyEGgBXC5/Xfb3xnFdBgBgXZ678uLKQisapa4k7CK3vpb1OwK/LWDRvgVg746N GoahMI7rQh86SBdGoKBmBYagS8MmrJBskBW4YwkaBsgEVL7DihF+fn62ZMdBDvf/3elsYzkSFJgz 1vsItQAAAADmx1o0soldtNvt3XK5Ou7LovZyW4db6FCKOsCiKNxvyIUPs/DHVchF3UJf308GWVhj VlvCLUZ+grvkcIucCLfIP4cwvgyNaAYAtGvRy8CLZtCFfr5WHX8eDuJL1hjNc62QCx1WocIsWtec iECL6cf972PrEY4hFCLQwnpq3Xq6/RNcIUMurkToRV+ChAx8WS0Wbp0WbPHYNZUBLbYQYGwxioCH 9gAAAABg84XWnnJPAjiDr7K9R/qkBFfEwiz6FiaNCbKQ8+rbBwAAAM7pzlFACMB01gP6xkIudD+9 HfqZwJR80Yvr3JMAAMc9DkDtLfcEAAD4Qw9lu3HxQFQdbJG61kWva5HHgbUYrus8f7cDlfvcEwCU jxHXWAXW9b51Tm/7Cp1bxQd4n/By+Pv+tmwvuScCzMTQQIuu35FDAi2sIIvUEIvCpQda6PfFY++O W9+v/jkAmFa4L7/mnggAAMjiuWy37rT/G1j1tVICtWN1swi5wOx9C8DeHeM0DENhHH+wILEhwc6Q jXOwMHEDegLE9bgTO1IVFRIljl33vReTUjnQ/0+yEjtNYpamMo4/Qi0AAACAukpeknzuyuPchZrm QXa7w5/4MchiKDHI4msqQ0CFTEEWbRtDLvp6OBbPy68je+EWFsItFl9B/mK4Re1QhaEPhFvU6UMM mIjfC/vjZjEUYChhPw0KsEIw+u+c3ud2K22oWD3xQi6S+kFIQdo2lqUhBqcKQKgZ6lD7/rX/7lr3 vTDq06j42Bb20yCLNOBCC73Iz59G2ce2q257d1k0lNjI8AJAuGxpuMXcwH4+8O4NyHvHWaACAAAA AGyb2h0ATuT9iHNLwi68l4y8kIvScAtCLgAAAFDTW+0OAPhXbpU2bYKQ9n9+beE/K9DCmjeg3UPr B3CMPjyY5yeANeJZBwAAgHPyJH6QhVa33mPJj1vXstpz/DYHdPe1OwBkPn7wWW/xcSvMIj1mLWI+ d8xrx/qEhbNfancEWIklgRZha83vtoIlvEALb18Lu9A+780Xz+ea5/0Wp02UOoDfcSM8lwEAOHfX XXkVP5BiLsCiZC2tufWzJKnnW+a5YrW+BWDv/nEahqE4jj+avYyIiQOwMLNwAiSOwMCx2HsERs7C zA5SpargtiGO857t0D+v0O9Hito0sf3aJWri5EeoBQAAAHBctD+YT6VGs9mLTKeXq/fxA+zj1y7c YpmEW3QBFouF/IRchDCLsL4OueiWdt+wXxxkoY1p8Q638EK4hR/CLQ5ZQxta0f/MHlsLh7WCLYZ9 fcznSpdRCEXSvu1v0G+7HrfZMsxCr383PEMdvMd3DZVwGPtM+t85ndWunckenAHfBFfEIRdNFHph nRWXZKyLyUSumqam7FurlBGLNbG/Nom6hJP0AAAAADD06F0AsAef0g+10G70qQmuKIVZ1NyQNCbM Iq2VAAsAAAB4efAuAMC/koZa1F67t8Is4m3aJKTfjAVsKwRanHsXAeDklI6DuTYATsObdwEAABzY 3eY1d29KLohCe9hUevuO1b5lBbCm2wGs3XgXACTeK/erDaTIzRMcM5cw7Rt/A4EWQN+z7CfQojSv uxRooYVYWPstZRhsYdVRG2hh/Q4Adicck0OgxatwXAYAACLX38u95K8JaEsj/edqlR7jVQrHzs2D 5VoCjtKXAOzdMU7DMBTGcScTQh1YGAtDJVYkTtCNjUNwAu7IJRg5BVNUsNu4cV6eEweFPqD/n2Ql dRLH6tBKjp2PUAsAAADATsniySdfHqcaWq83brcbNtcFWTgRZPF5LDHMIgZZNE0XchE+x9CLeN0h +CJtx/XCLeawChqwDhgg3MIO4Ran6MNwfGwYBqAdG25zP5Pht2e1utrvN+FHSfYgDaVQu5gPsIgh FlVd9+q1gIwpBFosf1/Le1vdV967kseT+v2IdVsX99MgizTgQgu9iNccS3s8tn/h667rouHEO18e XDeAXhpuUYltSdr02OB87jgvsAAAAACAobAg9N66E8APePXl45vXzl0AlQuvyAVd5PYJuQAAAMBv EQItbq07AeDfuWm3Y8/ocwvzcgv1ZFu567Q5A1o/tHkIQIkwqe3FuhMAMBP/dcB5eLfuAAAAJ3bp y9ZNvySqdB1LSTtjRSoZowLOzda6A4DwptRpLyHXzskdk+3MnR8o22Tu4N9AoAXQFwItwvzuJQIt tECJqbo0sEIGVeRCLHLnyeAKec+xICPts/Y9AFhO+E8Oz/RDoAXrpwAAQPTsy8aVPTOYemfWnPNL nimUPF8ATHwJwN4d4zQMQ2Ecf0rGSmVCiAGJIzCwchcGVu7UGzBzCu7AFVi6AaGt/OK859iB4Cr5 /yQrLk1qBwlVOLY/Qi0AAACA82H9I/k0dtFu9yLb7fVPXW9Wr48h3OIzCrc4BVYMwyy6feIPIReh nM7tig6ysNosQbjF5E8Qwi2m9oFwiznbD6EU/bq/3tvbiz58ni6dzeYQavGx3+uG3eAJL5SgFxqg wyt0e4WBFnOFL9QMdajdfu37rt2uNVNd/5VYI9yDFIljSIUOuWhV6EVzfB0nR0j0+qpp5KZtc27h wetKQfEm/5cO0HsYpAcAAACAgI3WsFSvqp5a0JkKlBgLoRgLr8gJwhCjnuonAAAA8B8ea3cAwCJd Sn6whPeePicVdOFd680tyJ1vAHi6cdaL2p0AsApzb4rL9yGwDDxTAgCs3b2qW+NGjVP31rBYa1lS a1skOuaMdwFrdlu7A4DyPvE6bwN2a75g6nwxzkttgM68wvNFoAXQ99tAi9R8bCtQwgq0sMItrKMX bpETopGaJ+7do/V7APB3uu/ku+/yJgRaAACAoWfJD7SI99JqjZ9ZYRfW84fS5wsSvQdU8yUAe3fQ 0jAMhnH8XQ9D8KIgelMP8+TRTyEIevXTiuDHEU8Db5vp2to0fdO821oD9v+DQJemSSaIM0v7EGoB AAAA5DF0s2TjyZXHVEer1b1sNv3u2iALCYIs2mCKKsRCfgMryuMm1KIsbeiF1O3DfqQTbnEswi0O 7kEItzh0DvMOtxh3/Grtqx9ooZ1v66rxt5021bX+dRKcX8hyebqr+VqvJbggPsO6zaJur4ZZ+Iqi +z4M4RZTBSDkDHXIPX7OUIkcY1vG7fxWlO29+t2KdV3XHPtBFn7ARWd1vL5GC8IovP5PXN1VYVpS vHPlQdoFdGu4RWqBP1x8tyzKa+ctn8UAAAAAYE5eck8AmMCHK5+JNpabolI3mMZulBoKuogda68t 8wQAAADGdubKc+5JAPiXriP1+4RYDO0D0PqJhViEYwPHKP92Eh4MYEwXE/TJQ3SB+XrPPQEAADIo Qy0uxf6QKEuIRdhmqK/YOpV/HDsHzNFN7gkAHn/fYexh41o4hWboekvYxT57BC17DvF3zoVAC6Dx LeMEWjSvU4EWWkBFLKQiFmyhhVsM7Q8P94rH9oZr71H7OQAYTxNo8Sb83wEAAHS3rrxKP4RCewZW 6rUl3EL7fsGX+n4ByO5HAPbuJydhIArA+OgYl7gyuvMSLl14CtduvYhX4QjG63gNFugUxk7bN+9N /5Cp+P2ShgJCiwkhDJ1+RC0AAACAdZC+OL5ZD9puP9xmc9+spyenTy/buMW+F7eIwYpuzGK3a0MX YT0GLuLfhiUNWUjbnIu4xeRncMQtpu4DcYtlt9+NW8Trv1GJi9wxt/tOM6I9sf9w3M376+ayiVrM CU3EUEU/XBGvh5P3F8QszO3M8F+DFrWiEnHba9uuNPKcvjOkUexBReIYqUgjFyFmcZXeflyX3qXx eohaPHhf8pKecrsyYrEmCZRMANAwYA8AAAAAh6DFTe2dAE7gM1nvj4BqE0ClCaFShMKanGRNSsoF M7T9LJ0ICwAAAMz1WnsHAJytW+U+LTphBSms2MXYbQJjhaAF46wAlhSiFjU+p/hsBM7P9IkmAAD8 fY/JujSOdJlZ10IX0v3W3BYtdAHAuefaOwD0fE14TO7YQ5e5veSk7dLxg9oxhliPELQIJ84maAEc ghbv7jRBCys2IQUppNhFLmhhPX96THnu2HHtteX+DwCWkwYt+D0fAABoXn6WOzcc+9fiFd7Z59Wy ghYloQvpNwV+Z0BV3wKwd/84DcNQHMdfKgZGBhg7IWaEuAMDC1fICTgqMysrYw9QETd18+r4z0ur 1C39fqQo1UuwXSFBmsb+EWoBAAAAnF5pcqXz0W1vpYaWy0dZr8eX9UOQhQRBFkMwhQup8OEV/rWv 9zXZ1Yfjuh3ZC7eYA+EWB7cghFscOgbCLY7vf/x8b79O/3iueJ8VoYMu9Hmi6uP7bE1zs9n/rlYT hxeEV4R9NUMAxziII9XkPOELNUMdavdf+31fQr97d53d70rVN3eptzX/WgdZ7AIuXH0bYqHDLGJB GAvV/m1Xe1iYbis+ddurDDfNreEWsRv7sQkA+i2nHvDPHbdckwEAAADANWhrDwCYwbeUJ5bmAiJy E4ssWy7kIhaQYZnEBAAAAJxSW3sAAP6te+N5pe/1U88I6H34M6ljuTpgcSd9qAUAXCr+PwLX4af2 AAAAqOBdpgVOWEMscsdTi055YY3rbkDkpfYAgMCUUItUyEQq2CI8J9bGlD5wfnygxXPtgQBnwAda uL+rqRAHS6BF7hlsvS8FXFhDLEqBFrH+jwm0OHyBGAA57vN2221fQqAFAACw+ZT0elc6yCIXdJGq h7XceljWtbL4fgHV/AnA3t3kNAwDYRi2SNddw4LCmhUH4AqIO3Aw1Buw52qVCDVpmsl0xklMIhfl faSozg+xu0ha3NgfoRYAAABAeVYa4vvQH+33n2G7vfsty4no5WsXblGrcIsmqKIJsQjnIIvDob/e hFn0FxlkYdW5BMItss8QCLfIbQPhFjn19wMgrFvbmD60brvXhnj+um66NEaHWhghFhf7xXvoHX+a vN8KHVgqAKFkqEPp+kuGSpSoe0q9Vq+yvHKsXuyLFIlTSMVGBF3I4ypxjHUlt+u3x+vivqrGNPvF a8qEZWiQwNQBABod9AAAAADWLE629la6EcACvkTZG9Apy6mBRN/GMXpQlB4Q5YVceAOVrA593c5U CAcAAAAwp+fABBsAlrMztnmPJ+j11KA86zUVfsEAP8wpBlowCQaAazHl84zPPmBdCLUAAKxRDFh9 DOn+oRunPDXEQu/T9Yzpj+I7OtbqoXQDAMX6/8mbjN3bJ4/JXVLn5hnC60SgBdBpAy3iPTV1D5Vl 77nuKDfQYijEQoddDAVaWMEWfw20ADC/NtDio3A7AADA//J0XF5Deq4rWbbm06qc7fo3hFS4hWZN 5gcU9SMAe3e3kzAMhnG8EBIT47lXQDgl8QI8N557yiV4o96D53ANaMc+Wl7efmxk63T/X9KMdaOt JIKWdQ+hFgAAAMC0cv5hfLflLdXQbrc35/Ntcy7Iwoggi5+u1AEVxguuMF19XWe6enfchWFU+364 xVSWHG5xZwuGcIuhYyg7gNKvwbD+3fvS7c36V2rwhTvn+lgdXhEaWz2l8X086qMIhVjEwiu0bfsz iPbGCkAoFawwh/5L9/0X+7367apeP6/+MnPd1LWPLzPedrtpQiu6mfB23wuz0IIw1l77D7bueZ01 tbi15cW4SfTccIuV2OYuAkjdjCJ1swvjHQMAAACAJTiUHgAwgpMtX4lzYgER2kIibfGRDKrQFkZp 4Rba474LUgEAAIAxHUoPAMC/9ij2c7+fTwVfaNsh/QB9VcHBn6UHAWCRpvpsy7nJLp+zAAAAmLPX Zptah5JbQsEXsQALbW6Lv6MBZ196AIBwCtT3ve4wJwhDthnqQ15bGHoOyiHQAnCq99E20EIjwyu0 Ou36ay1QIhVokQqxkOeFnh+6bpxAC2B+CLQAAAD3+LDlyej3vJJ1oXNS58W+e4gFXXDNDmbjVwD2 7hinYRgK4/iLstGBgQMwcwg4S3aExAU4T1c2Vo7BzMjYtUOJSdI64b3nJmrrqPn/JCuKW/IsBGrr xv4ItQAAAADy0j4sPqd+aL3+kNXqrhdeEcTHQ7jFbhBu0QRTNCEWsg+y2G775014xW7/3NDiIItw Ha32JSwx3OI0tQm3mFY/z99bfwy5fwdj6//fR74JLGh7C+2+20Lp1/qa/i7U52ez8UeSCK0ooiaD 9tfXbtofX+dcAQg5wyxy119i7al1tdWh8X+JNpvdpUiUSphFnDBRxsco4MLaFSKEWtyX5THDfhyU sJKmUyEXYybjrcl5CxP0AAAAAJaqyj0A4Azence0BZ/egqIxTQuysMIttNreOL3FsAAAAMCpVbkH AODqPbRH77t6a0Gede4FW3jXsMahXRvQVHW7zT0IABjBel3j9Q64fp+5BwAAQCZPYs/1WKEUqbUt qTUvovR578V5P46lI9QCc/KVeDx1/15qc3bvOaKcp+4v9Grjcgi0AA6+6/YmxwVaaH3efdpWyIUW RmEFWlhhF1rwxbAGgRbA/IXP169CoAUAAJjupm4vYu91ZYVZdPtpdW3qnlri9InwnQJm4lcA9u4Y p2EYDMPwr7JwA9YMDCzdyg04ANyEW3TjCpyoR+AAlVgRUyTspol/Gzu2TGja9H0kq8FJ7Igl4Nr+ CLUAAAAATqdkAciLKU+5hprmQdrW/3PeD7KQIMjCBVN0QRWigitkqO/qZKh353U74oVbzBt2QLhF ZStCuEVN/4RblPTfh1foMAo/mMIfK/u9sX96LfgQPnF4lu7zY7/XF/if/s3ucyxMoA+5sGEW/XXq mECL6fu9tr6n7tebSW/bVvWH0e9j3UoHWgRhFl7ghQqz8EbA1f19+7em7m5VNLx4b8pG3ED6TayL SAmDK0qCLvSXAPpXlFoMkFsYAAAAAABL1giLp7A836bs1M+xEc2xgIjYwtBUUEVYasMtUgEXLFYC AADAHJ6FjbkB/D+76K8kWKLknD4fazMXbpG7B8h5nfsBAFy9Kd9bufcx70gAAABcIjsWtTkeh+tO xtalpNaq1FwX9v2XsTBgaRrhuymcl091nAuP6I9rAilSm7rXziFkvuF8CLQAHBtosTXlK3F+qkCL MIxiLMyiDepLAi1y88QJtADOk/1/+t2Ut7kfBAAAXLxHU9ZStj9WbK+s0v20wqCMsXmtodTcWOAk fgRg7/5xGoahOI67zVixIbbCGZg5DGXnUL1BD8FBEDtiqlgqURIFpy/O83MSVXFovx/JSuL8ee7S QpP6R6gFAAAAkI/2D+FL6qTtdudWq9tmW04w3w2bOAbhFnVQRR1i4Zogi8OhvV2HWRybY6sWXlvW lkEaORBuMfoqjnCLMfUJtxhWv/tWt2gFRPh1J5btc04hGad9vv7Xfj8+IMAHXPy1TtiA6Fto+88g Z6hD7vq5X/d/rhubTcH3h2EUMrBCC7OQfYVcioALbVaHyt1y6dZF0WfYT0GJcH1MsnQYejH2gX/5 0gAAAADgmjDZGi7RW9m+I/usbzWtHxf1bX3CLVI/XtLWrRAOAAAA4Nw2uQcA4CrcR/pj4RThPu15 gFRghXVtqx+wbMr2kHsQAJAwVYgTn6XA/H3kHgAAABlVE1BZ4ad+OSSwwgq40K6n1eXvaKAOtQDm 5DN9SMN61i88LjXZuRV+EZ6v1cf0qs/xx7K9OwItgMqUgRY/YjsWVmGFWGjhF1qQRVhLrhNoAcyL D7R4zj0QAABwMV7LduPi9wmGBFmEx1n3GFL7ndPvLXC/AZP6FYC9+8dpGIbiOO6EgREWxAlQ10q9 ACtSJTgS12LiBqysXKQSjtIkzsuznaQKryHfj2QROantdkHyn/wItQAAAAD+xpiDkEdfXnIN7XZ7 dzr1m2vCJiphgEVdumCKOqjCBcEVrq2v61xb390P2+kHZ2i2GDaw/oCH+Q2s/7tf0j/hFvH+6/mv LoyiCOqGgRbaHtz+u/+H58wn/faFbLsLsVCfa4IugueLshy0cynLUAfr/i1DJdYeaKG2Lfppwy3O 13K2OhVw0dxTZ8yb+0G/t77usRw1xfjkyyEYyo3WhVLU4Yv7qYMC4U+UOyigYcIeAAAAwH/2Zj0A YAEfwbU2iZg66Jk7GCUPIGkHllLPjQ3HiI0dAAAAWNq9L6/WgwCwCQ+Je6l1+tzafizMIrf2z94A zPVuPQAAmIggC2DbfqwHAACAocP5b+xcSXg+RV5rZ1hyL5vKhV1IBFxgy56tBwAI3xOfj+1TlCEU uX2KTvlMqj/2GNqq/m/vffn05c54LMA1+HLzAi1SARG5QItccIUWYiE/I8MttCALbRwEWgDXhUAL AACwhGqfa/Ve0NR6gayTr/OaUlLvxIqtMbCuADO/ArB3xzgNw1AYxw1ZKrpWgq1cghGJS7B35Tjc oDfgEpyEmYmlQ4eSNCS8vPjZrpXIiPx/UhTHceIUhIAk9keoBQAAAFCG75/Cl9hB+/2bW683/bac 0/13cvku3OJ03pbBFE1QRRti4fogi+NxuN2GWZz6tt15uiCLrk+9lspPtE+4RcYZHOEWuf0TbhEO t/gpjcIExkEXw+1Q+EBbv1rdnNdfh4OnydVwbe3XbWXghQyzEHVTWGqgxX8NlYj1O0ff+oz67nMl AiiuVdkXZiHrKrkWARfWjA939c/JtqpSLvvRjW/AX3ozPvTSv96vvzQp3whu1gMAAABYiqd62Za+ CGBizYCoz4zjfINCQ4OjrJAKPYgpJcjCibWvbO0DAAAA5rArfQEAFmMTbxJ93m8N1ItNDhhqwzsD uMTOcY8VwLxSfl/GpAxkT6nPCZ0CAAAA/pJmENqDqouNP0kJrdATV1lBFrJP58b9avydjSW5L30B gPLhqfNNSm69zxdqmzIBum5nnRPlEGgBDL3Xy6vLC7QIvb+t38mWixVEEQuxiB2fGmhhfQbr8/q2 AUyDQAsAADCn53q5dfbzglAwtrVfl/UxKc8YdDlUB8ziWwD27uemYRiK4/jDXFAH4MilXBBXZuDK Ch2AIdiDSTiyFKBKFSRK3djue7GTKnUVvh/JUsgf20XQVontH6EWAAAAwPxKJnq8NOU5V9F6/Si7 XVydD5to+fCKtnSBFj7EwgdWSBBcIUfH/P7+uC+/hzrD9nLqL7RPuMWEGoRwi6ntE27Rt98HU3Ss bQnO00Mv4kCA/tr2PWm16sb6/Gy30zu9r/sqCLbwbTrnuv3OReeeomaoQ+32a7/upbd7+C/xf7vB fmukvBVwEQZhHN0lDwIyfP03zb5bV3Sb8b4pT0FXrrUmlKJ2X+yb8enLjn5FSpFkO8UNewAAAABL tKndAWAGH8H20EQga2JoLsxibMjF0HWlIRcAAADAOW1qdwDAv3GX/Jw+s88FUgwtBqidOyb8gjEC KPVWuwMAFu+UUAs+zwB44XOnz2q9AADgMjzIuCALa76KtjiVVUfahkj8fZ3v7kC3MDxwKb6b8mUc GxrXl44B1M7PLXyuTfDXxjhax3EeBFoAsTbQ4l3yQT+5cJ+hQAsr2CINs0jDK6wQCwItgOUg0AIA AJzDq9iB19qaWOlyXmOCLUqeUZSulwXM6k8A9u4Yp2EYCuP4o5nKQFcYEDtCYunEKTgCE1frEbgK Kzti69QhJAUnzuM5tkuIkfL/SVacNG3cqh3q2P4ItQAAAADmZw06e449abd7kc3mqtv3F67vF5J3 4Rb1cd8PuXABFi60og2yOByG+1+P110YhnsdF2Thrqm3MeUX2ifc4oRXkN+GW5Sy1O/bsA2lPoO+ r6uu+7AIHUpxNgiSUKESwTnq+jyR9friuP3Y79NaZwQ6dMe8rXgBF4O6PpapZKhD6euXDJUoce25 rquv0AZO+L+gUBhFKMzCP1b5Wy/gQv863f7laiXXVZXS7Af52QEf64xPCbEIddSLca7/Fix01gMA AABYgsfSDQAm9t6U18g5KROmYsEWenJUKOAiJcxCt0nXxya4AgAAAFNrF964L90IAItx/l1yhRYC 1I+J2Pf+c8cDMH4AIU9NuSndCAAAgAzcawIAQGQr4f6kWLiFNZ8ltqBUavHbQ38Uloj7U/hP3ry6 9T8qdfL9WFhFysLnsQCNsXbx/+/vEGgBDJ0SaOG2obHb1ljtnDALK9jCqscCLfRY8Ni4cOt96s8B wLQItAAAAHO5bcqd2GEUum7t55bYvQQntIYW9xkwi08B2LuXnIZhKArDN6USLIAFdIQYIhbBlC0w ZxMsiS3BFhh00krEtEb2zfWjpa1R/H+SFcdxYqsMkPLwIdQCAAAAOK/cYsn+2PNYnkoXWq3uZbuN L+fDJpwwwMI1hcEUOsxis5Hf8IpdmIVEfdw2DMPw1wzHO0avYQO9hlu0/3u3Hr/XcIs4sMKHW/gw izjQIjwnDLyYfmM+PXeQ5fLmZ/9rvS7PSodZ7Br9wahfFG6x3x8Wi6PDLKzxL6lVsMN/GLu3cYfE fir5IRdwEQZhTO6Uu/Z98WNcj3UXbFHhbiyPwVSurCGMYk5fyjfkfX//U4Q/Sa6uccMeAAAAwJy4 QAs+psLcvGeOpT4IrSmp8AoryMI6t3YcPigFAABAay+tJwCgOy4QoLRQXy68QveRzNaq14Rg1BxH n95aTwAA/oD/aUC/3HOoj2IvAADm61bie1KnKoeGW2g1C1IBc/XQegKA8nlgf+v9P6tuHdPb0uLo LJLeFoEWQMy9t32OQAvr/excoEWqXgqzqAm3sN4j1/OWTJsY+wBOg0ALAABwaa+Sfi5QE3SRWkdL r6ml22ueNfAsAU18C8De/eM0DEMBGHcSiaVrmcshWLkDGysS12LoDXoSjsLWvdRN3T69PDtOZGpo vp9UJSl/YhWkqGnij6gFAAAAcFvWm7+PsR/abndutVpftuUk9ddJ60Pc4nDalpELGbYI6yFu0S8P l8iFjGHIkEXYp17OsdTYAHGLOurv/2/ELeppxN9gOMV+342QsQqn1uP3rrftw2n5vd9PHFIzWPfR ikZGLmTc4jxR/5yzdzWjDmH/7Pu+99uq/zF95nkQoxDrVsxCPtfJpQpcWGe5fdRi03U5w35Ru9Dr c6vSsSHql8aanELjhD0AAACAe/ZaewBAYb56+yW2rTOiVthCf31K8CIWspgbsIjdvBobLwAAAFDa e+0BAFictfHcWOAiJRW2SMUtrN8dv2AJ6I+Zm9qDAICzksernGMkgP+PqAUAYOme1XbqnpPYfSt6 cqkpMYtU3AJYoqfaAwCUKVGL1MTlOdcDxmIVOd/DNYW35Y/b/tprghZA7/P42LlyQQt5TbYVl7Bi FlbQQscscmIX1r6syEZO0CL2OgAoi6AFAACo4fH4eHP25wWxWEXu3FmpKb1yPnNwI+vAr/gRgL07 xmkYhsI4/qADCwMTF6iYWJA4BYJDcBRO1EtwFxaGbmyViBWFvDjv2U8lxKj9/6SINE5tNxKKlNj+ CLUAAAAA/k5pkeSh7KXbnmoVbbf3cjhMqxvCJhIdYJEO6WCKIczCCrLowyzk5/gYfDGGYQx16vaW cq5hA4RbtNG+/bbhFmv9/n5x/ekzrz7YYeiDF/aqgy703/yc8XNfl8jHfh/tnB1okYVZ6EALM+gi qGWoQ+v2W4ZKtGi7ZbuzY1m5Nep99gTcCbjQQRgX6vjkP1a1cdXt316GHjfedduj6som75Kzmd2X +cN6b+LA7BJllyffz/HAHgAAAMApuBEGb+P0pECLL6fMmwzqBU14k5GsSVL6HK88MqmpNDkVAAAA WENagIPFNwCszQq1SEqLaJcWGbS+Ez0vrx8oeWvdAQAIqt3XIvfGY+rmfgoAAID/LIVaRBZ9qi0W tcTiUqVJdsC5eGjdASDzGTwvGkjhjVP0ymrjCRljuL50X37ttp3wTh1IUqDFuxwfaOGFWVhjsr1A Cyvcwgqq8PajIRq1QAsr4CK/DgCWle7LBFoAAIBWnrvtWvz3A78JuKgFW4jM3x1Y7za8cmBx3wKw dwc5DUJBGMeJ7Nx0ZeLKnsQ7eIS690xuewTjzmN4BJe9gRbN2GE67zFEZEj5/xLSBxTmlTQ1trz3 EWoBAAAAzMf7B+9p6KD9/qXZbG5/1/Wk9KdJ6iXc4vN7XYdc6GCLU/snrEKCLmSbtOU8EmQhNe3j VJYQNpBTl3CLDPn11xBucR5QIR+BOvSiH4BROJMbFND/nu3jcCgfWwkaOAuz8OrJBP7dRP3B0IKs gIMl1M+uvZa69jrXZmTo9L7BlrCKphxmobe1ers+1tSRWl2oxbZtIy/j3pSw7TGJ097AALvfXhom qwAAAACwVg/ZHQD+watqDw0MsvvHhF54g6m80Iro4rH7GNQEAACAOeyyOwBglbaVfdHBd0MTDo7B PQKI2DX19y4AZPvr3zMm0AUu31t2BwAASHZ3XG7UemmMSWS5Mu3SOJZSHa22HbhkhFpgad6dbZF7 +mpBFN65vOdH2pEamI4EWjwn9wNYiikCLWTd3nvtBUqMDazQj167Fmhh+1G6Z7z0Gr3rAGBaBFoA AIBs18flsfGDLLx5r6LBFqXnR+bT8n7bAGbxJQB7d4zTMAyFcdwNExyAqQMSTMzsDBygEifiDByx c3eGNhKOIjevL88vbkXk0vx/kpUocWMrQ0B2nI9QCwAAAGAe3seR07nPWD6mLrReP4e2Pf3XPYVN dGSARXcohVLIMIsUWHE4DPv7/XBObvuwi3AMvpDhFnOrG/JQL2iAcIs66rd/6+EWU2Ndq9i+DrgY 6o/DL/R1u+dV/2zc7nYF3Vmd7jfN+Noy2EIGYujjbjN1x/Vqh2ksre1agRaTdVR96w340ah3JuBC bo+/TWEvqYg27uP+Y1M05PgSy5voyp3uUqaY3Q/2gLy1YGB0i9Tt0fsag/cAAAAA/jtCLXBrukWk 2wt+l1toVBJkoRcwlQZeyLZ1H1jABAAAgFqeYtnU7gSARXooqOPN5efm+62tvqZXh/cC4Pmq3QEA uBB/3wAAAIDBa/CDJc4p3joW65zVDrBkhFrgmhQsVDZ5H2+33hHM1ZfHrOPWe4i8dzgfAi2AwU8s 32HeQAtd2mAHW1j7OsTCqucVHaZxzvM7dx8A/C0CLQAAwLV4D31wtjUfUBJU4X1PS88reHMMmv2B PuYgMKNfAdi7n6QGYSiO42nZd1w6brrt3qWn0cN4lR7BC7j1EO09nCrQDI9HXkJoayh+PzMMBCwv dsZ/MeFHqAUAAADwN0J/2L2mXrTff7jN5qk51g+g79o+3OLUtGXIhQy28Md1oIUMumivn3phGP7e bburJ/e3RLjFPdYm3GJ6/eWFWzQPuF+5QTCFDqeQQRZtH/phFtZYWnev9twhEWqxkuEUg3505wdt a0vVKaRksMN/q12yrnkt0JZfQb2R7HNIRSzMopLHvh342NDI9+N67bZVNeZTevFlZHnd3cQWm/iv r+u3JjVgHzsPAAAAAPfowfGgUizPpzjWI52hBZypBaCphVKpRVRWndC9NSv8AgAAALglwg8BlLJT bSu0IiQnrCI2R4BgC+Sof2ZuS3cCAC7AHDkAtUPpDgAAMAPP5/2YwIkpm7XWxbn+79+hBXShNrBk jLdhTo7i+NL5fanXp+YR5rDmRGI6Ai2ATh1o8f67fblx39v0PhZoYQVLWKEUOrzi28XDLnICLaYE ElnvA4DrItACAADMzZuL/y9gTIhF7DlaOtgiVidn3i1wVT8CsHcHOQ0CURjHkY2Ja+O6myaauPQA Lt30Lt7Ra3Rh3PUOhAgprzyG92awlUwp/19CIMMUplWpGZj5CLUAAAAA/l9swIfs2zXLR+pAm83z KVRC6AnwdYBFW6SDKSTMQsIrqqro1sNgC73WYRhyTAm3yDHnPuEWSzz3ssMtcrrFcAvRB1D0z9rq QAs9UX/fhuGlVEIydJhFXR/X+8OhqNqLmFTU66Add2GwRbet953CL9rdZdmXD96PcdxMcodK5LKm 93zOz3jQ29z9Pku5lfwwCrjQYRbFuIe7lL8RWdQ57pvtp3JSt+O2OA4G0IEWUzrmzeYbzfQ6/Ucf UfDxhNshOvABAAAALBUTleLWtAOlvhJ1vF5Pa8CUV2Yt3gAmr3zKeQEAAIAcPnM3AMCqPZzxmkvC KryyKecD+M4EkMPjTMfl+w1Yr+/cDQAA4Aq8GGXexE9Tgiu87djrvX4r/lfHmrznbgAQ+ElXGbGe O9T7vDphvdgk6tYzhjxzOB8CLYCeBFq018dUCE8s0MJ6xjoMlIgFT1hhFnWkLBVoYZ3/0kALAPMg 0AIAAFyjt2Z5LeL3DMJ5sf4SeJEKzPDuN3jhFtx3wCx+BWDvjm4bhIEwjp+UxwyRdoNskC7R97x3 sIzQeTJJgkUcm+POmAcgwP8nRYBxsBWpoXWxP0ItAAAAgOlZf9D9Db3pdvuX47Gdh5IvNB8Xnm/L YrjF4xU+0Q2mSGEVcb8bdJHKUhhGun4KsojbGHQxN8It1tj2OsMtlg7WaPuwpXALe534tDZ/Ko9h Ffm6/f163Wdzw3dXqlseO7PO98p0cIAKvhAVblHT7tT2Giqxt0CL6rrGcf5T0xnBbq5rhlk0LyvM 4l1WCLrI2wqhFqfDoabbF901kV4TNYPx3gQBfV5/NN7gvP4oAQAAAGALCLXA1pQCLWqCJMaGVugJ TaV6+b7Vdqm/1jEAAAAwhXPzOi3dCQC7Fr6DvAUD8+OhOnmZtfUm7VnPEdRcE/vzI+0zLgAwt9pQ izkXv+V+CAAAgLULQatfYo85Dc09ifNYvPPee6XivIffwbFV30t3AFDGhFp4z/t5wRa6jlV3TBuY RrjnXoVACyCIgRZ3WT7QorQ/FGbhBVwQaAF8vnBfJtACAAB8qt/X1gur0GtfldbJGrumlkj//waE WGB2TwHYu4OUiGEojOO1wyDuPMLgSkRwIXgBDyB4Eg/gwmu59DzuXQxTtJ02Y/qal75KMS35/yCY tjGJA85AO8lHqAUAAAAwr9hmyO7ac10exzra7a6Lqup35za6bwMsvk8BFs2xH0whwysOh6L76cIs il6bNvjiNwzD9enCLaRUG//nHG6RCuEW6aw/3MKFVfTPufCK4bG2nlx/W23mt92eH4++9vtAk8j9 NS+wInS+F2LRlbOy7AUM5BpokVuohBt36YEWwd8XfYX+u/y738fgii60YuNCLyIhFmXX56l4Y1zU 9SbYwuCqLg9e9xtvStZUaetNef/PHrxE4uWRdYkb+AAAAADW5rIuT6knAczs3atbF0z5dUuwhbZw SV7TFjbJceT8tDkCAAAA/+El9QQAZE/bqPuvz+pjC/cs9SljIS9vqScAABPEPsP4fAPy5D+D+kg2 CwAAluXeq48FWWjnx9atWDab0tavWMIugLW7Sz0BQPg0trOES0zZHD3WThsb83MbZxNoAbQhP69F G2gREgrnsXw3O/S97KmBFpUoWnCFuy7HCIVsEGgBLA+BFgAAYOlu6nJb6M8DLHtjhfbIGmzvpbSZ 8vxB1oFZ/AjA3t0jNQwDYRgW4zKThoqOmo6WCo7AHehyEa6RG3Cd1NR0NCkRPxqtN7uSAsHC+H1m NDEeJVJB4sT6+Qi1AAAAAH6X9UPuofak7fYprFaf6zXlpvJyk/l0nIIscihFGAVb5ONx0EU+l8Mw ZJCFbEf3w+rPlJYYbtE7ZIFwi37mG24xDrDIoQAy0MKuf7iRv//3en3+8fi63zu9CH64hQy2SCXk QIszUWRdHW4xtSWGSvRsu1eYxXfbtd4t8p03uqudgitiGeL/9cE5VT8FXpSCLmRbF/E1L4ehpds3 umtG8y0hF7Ub/K0LDSzcnAcAAAAwd/e9OwCc2C6Wl4Z6XrCEFzphLVLSi5i8hUytC5wIswAAAMBf wW9FAL15oRaJNVZfG/dvrcf8ALS6i+W2dycAQKldr065MJ1rI/B/MCYFAEB29fVYCpgo3X/Sa1X0 cetrW/gOjqW47t0BQHk2ztXm+pU2P7fqleYUWm1Y8w2t5+Bn2DgbyN4/Cx+DH/Rjfda1Blroudhe kIUOrCiFWHjBF1ZoBoEWwHxwXQYAAHOwCeVxhWOCLWrhFfI4BHuMgRALTOpNAPbuGKdhGAzDsNUO dEBigpWhYmLkBCysXAFuwuE4BCtnQKhLI+G2MbVd+/dPSeu6eR/JSoiLY3VJZcf+CLUAAAAAhiO9 RObqnm15KjU0n9+brgubc5vauyCL8LgNt4jDK5ZL0x9dmIUJPrMJvvDbMEG4hQbhFse8L+EWNdT+ 3jd9aCXcwguGMH5IRRxokRof2z2GYRi7Y2mz2eX6+LVYJHqR6p4QcBGHXPjnXtBFUH9kYw2VaC1Y 4r/3HbS9qO3USPi0v+6nSEz76y7oIhdiMen/97d497iw5zcT1fDjnS0P0e01g/GlgXtpIYFmkUB8 HmMAHwAAAEBL2KgU5+bdOy8tFJL+1iyk0gZeaBc4meh6rk8AAADAIb3YclW7EwBG71ao0y64k18+ kklBGIDzVrsDABAZ8jnFsw8Yn9U81GftTgAAcAJWoRbS4jZfaj1Kac1KbuOp1HoVzUZT/GbHOSLU Aqfko1Bfeqcvtfm5ZoP03DuFuSCLffoGGYEWwJYLtPjO1B8q0CIXViGFWHTC9VTgBYEWQDteDc9l AADQhmtbHo0+yCKeY/jLvlq5+YbcXIWjmX8A9vIjAHt3cJswDIVx3BRx4YB6pKeeO0TVLtERuhZH VugAXaczVE2IjF9en50XUOKA/j8pIgEnNgiEMLY/Qi0AAACA6Vg/4D6HTjoev8Ju93TalwvIywXl U+hECrPoh1rEsIr+cQy6SPel82SQhaxHt6OEcIs56yXcoobar3vXhlsItyjPKe8HWoRecIUVgJFu 0xbLbTbb06My1GKw90wEVsS2rHKBFqLcyrc4/yRqBSwsoW7qveA6xrH8VJ2TI9qwiuZ9fe7NFiEW Ml3iQZ8TykEXsq59c/3n9drT7Nfwv3NdVzEmbTrX2Z+bADA0CaF0PwAAAAAs3WPoApeBe9F2Bn4P lLF6MT3hE6XJU7rMr1Heu5XaCQAAAMyB8EMAS7B1lLH+55eP6f3coCN9zdIxEL0321vtRgDAgFrf Y3x/AreLUAsAADov6tgz18QzL8UTYKH7taw+LF0OuCftmEbC17EkP2LfEx6RG58Yb3MLoOcWhLcW U/dgLOJ1CLQAkksDLa4Zk+0Jo9AhFjrsQodbWHVY476tsd/W8yTQAphXG2hxqN0IAACAET6Cf60r a32sMcEWpQBtC/8vYFJ/ArB3/joNw0AcNgWJgRXYkJBgQJ0YeAEmNp6Jl+E5WJh4gM4wIlg6wNSm 2K1NLuZsh1LVqP0+6WQn/nNOk1KSi/3bqz0AAAAAAIANIXdTF8purd2UOjo5OTNN0+0uLGAfRCy6 aWtSuGIyaXzaWiiXadt+Nk+luMWyhKbrXhO8lt+F75n3vV7nNY95Nf7Ddfb7Duqe73q+2zHUueZa /8b7T9eRYhV+T2LbmPgaiOt1y6T/xWL5r+Px764iOXAhbNERufC2E9m6qXWOt9X3Jp5j1/v3X1v/ BZpfz6b7hNu9gbPr06Ao0dh6U1t/LmJh01AW6s/b2rLG9Rn6c307AR6b37f548HAvLh/OvKcW7uy 9iTdm/LD9yZKtZeeUhMDXP1p/BGJNkbJ5z5eAAAAAACA/woLlcKmkRO0yE2WMlGqTZjSRCv67C8J WOQmjzKxFAAAAADWzalB/BAA/gcX0XYcn8/F5HOL/PVZHFCmM/PTF+8DgOOu9gAAAP7IXxbFZXI7 AMB24cROPsW2yz8r9T6MLowi759SbTVK912nJi2IeODLJUfe+rQHAHCiFiOTnlOSE6kIdTvTaxJ5 7XmUtNQzKZ5PwSZzWXsAABHv5SrfaO8gpkQuSgull94lLNWB5UHQAqDl0dq9WV7QIt6O38/WxCRS QhQpQYuc8EUfQYt4TKljSB2vtg0AqwVBCwAIuPuzN5938QYZk9BiFOE3eqT01ef3e5iop8UghiLv yog/AMChtWtrD0aPAQz8vnDvoa2NlYtHDKJ2pfiDRIs1EHeAlfElAHtnj9MwDAZQK907VmKiMxwB CXoJDsGZ2HsFVlYkRiQ2EEhMSD1CS1w7zeevduJUtIHkPcly5TixVRVa/30PqQUAAAAAwHGIDfDu 2m5aLh/MdHq2k0tUVKIJ+boSW8hkRRVObuGEFaHQos6rVN9rdiIL2Y7MD8HeOzbhAHKLg5/gc+QW 3fvQz2eubt/49vWVcL7LCSH2y1P1Y5KLKoX/l9zUxtdqldXfSlaxqQt0hUBmURTFNqi/LD8lYxI7 9N320NqN7WoXjYYz3tu/q42bvbbXvMSi8GXaLjHxEou1F13oGXO9s342mZjz8sdGhtjiqkzPJpRW 5MgtZBfkpHvTBL2WV8i3KBasQr6VTM4DAAAAAMB/A6kFDA0ptUgdBo3RdJg0R06RI7NYq+fG2m3q IwAAAADAKWCcCAB/CXuo77u1VkgqAKC+JvPY/V3aYyw/PhZluum7EwAARwRpBcB4eSzTdd+dgKMh gz1VooqNL5OBet9NKLHQ5IyBuoyTcuvqem8t9Z869MHKLmb+9dy4gFQyKJXNCUAFMC6s1EKfLUmd J0mdU4mdYUnNXWkphn6+PmDJfBQMmUXfHQBQvHasn9q32LR3UNeJ7StMPZ99h78LQguAGiu0uDd5 e69lWdse7JTQoinlSiwQWgAMD4QWAOPh0zgxRZV/+FzLK3K/i7uWx66/NFzPXYOYm/01h0ufX0Tq A8CwuDVuDb5tbUDHv8pNOl5WTJydWldg7yscjR8B2Dt7nIaBIIwO6ehAQtShQIIScQV6xE04Ajfg SByAnhaJEhAVLQEv3okny9heBycLyXvSaP9szwYRg9ez8yFqAQAAAADwe7oCyXTsqrKLvgtNpycy my1eThPWq4jFYtlYyBPtCVcs2mx+XCj13OCjEbZofI7BtgoOIG6x9BViibjF8DmU+Z1r/Ev0L0Z4 wovDresqUGH7ta2foRlvI/ipU/O/vb+3HLKTt7Jmfm7fc5tM5n2hrmIYOr7qlbptFJUo6buE33X7 rDVljE+9ZxhTGWarIvFdr877iEIXQcTCKkxo9P0kCl3Mrxe+R1HdaldqYYsMUYvjys4ru5d8QYuJ OUZLb4G+a8H/Q35uAPA2JYj4txMW8AEAAAAA4C+zV9ll6UkAjMhTtD66NkrlCFLYvpn4m5q8c7t8 e3P0NrACAAAAAKya69ITAAAwhKSimlg1fW8vpp0GEnWJVXilJ3LRlmQwDWL7lMVYAp7ht4Ob0hMA AFgzfUGNiGAAAJRFEzxZ0YqHWL7IT7HAMRI55Y4NeUYa63lq6HXC37HnaAEvSZUylTrx1JHUIhdH sU3iKYDN49Tps2tAXUIVkrT7klX1jeesO7EuBZvEtPQEABK8mEQviWru/8Rdyd7FKdPjcnzAcuxL LWhBbDXAcEGL9L5m615MdY6gRY5whSdy0SdokcZ623Y677bPm/YDwGo4q+y29CQAYFTC81V4ZxFE Kl5NXUW4U/r2VY3dlzM2lEdTbxPCCCIXKnpxGC3UEdsG+P8cSC3iexfbqYiF1kWa55BlhS263l/Y /Fji9LXF5wIsxZcA7J2xThwxEIaHoyRSGoRSBR4AKXkAJHgEGl4gT8YbpE+VMk2qSNChS0GHREkB 3GbN2ruzc971Hrt3Dtz3SZbt9fpmCu6WtT3zI2oBAAAAADA9sYCNb6lJl5ffZW9vvxaXCAShCd0O wha6OKGKStyiEqxw4hZPT6Eu5PGxqNuuNHOlFrLQdnQ9BdsqOLDN4hbjbNu44NVsv8zcsr+1xoci qyhB87uxLFZRj7T6O8rf5bpb2GLH26vq2/v7tHPus9R3slBCFfW4NN9XLWQhQYTDzlkDiEq8f9ub stnKsmBshtXq0C5exGiKagW7bM+8iMXMX7PqErtexGLhhS6iq9/eput/ms3kcJiwxUlZfktbtGKI uIV2IWhtWPEKfY89+C/S/rHpCwhgcR4AAAAAAN4S57kdAJiYHz1jQ0QihgRS2WCqrkCr2HhXsFPs HgAAAACAHHwty2FuJwAAFJ/Lch253rdnb/upRIKxubbN+zpozspymtsJAACpxJ9iz0kAgDH8ze0A RLk29ZXpr5KMaez11PvRmPGx715TvLulDvPf+PpPZE5IOOWELg587foknQJ4u7j18rksC53axFAi y3EqsbiVRaSdEsawNsX4ovsA74Wj3A4AKB6kSq4aI/W/berMoj1DaOuu84R95w05g/h6nKCFSzD5 JbcjAP8B6xC0WJh2StRiqIhFTMziueOzY+e/hwparLL2AgDT4AQt3LP5Y25HAOBV3Pni9jHmvq33 oFLP1iF7E333jN032fRzPuw5/DLXP0i1TnIsjdDF0aacAoDJuCjLT2nvLTh0ei+d/yrW78uXZe/v 2nsItgDWzj8B2DtjnIZhKIA6XbgAsHegEkJISBwARhbuwhE4CLdhROwsSDBWjIixhbiJmx/n206b pgHynvQVE7uxaatEaez/kFoAAAAAAHQjNJFV3ujd5nGTOtBsdmGWSy/hdJl83Uks6tsqbH5oK7Ow sopCalGPot33up2TYNhwx6qEGf3ej45VODBGucVu+vbnX+67/+0YWm4x1PetTlNokWWZN6ZMCCSM 114TW9Tn7q7EFOV7/TqfJ4aTBT8YKbjIJpPiWycFFiJsfZ8fLFIJ+u2zz4bkwp0rRLhZ89IisSrn 7Rel6MJKLKRhYj3jvhRdTMSxF2XdQb7vuJ3U4iSPyzyeTHuhxUS0cVstoWRs4YAbqrYIwSjlxtsc 2A8AAAAAADA0SC3gv/Esym3vxbUFnqEFVbGFVTHJRSpCY9r0fwEAAAAA6Mrd0AMAAPBIJf7UnseH hBWh5IDaXAH/9ak+YVzcDz0AAICSwz30oUmfYgl2uUYC/H3ehh7ASLFJcm0yJ5vU6aMsf5mmvKhN EqfQ/k0TPu2ynzZ127Trehztvm/TvuX179MUiad84YWVXUzzOCu3No427AcAhuHUFOdkbf2IPF+k fmuKySva1LNOBcbG1dADABC8i3KXRKepZOnaVtaH6mL7Yq+BOggtACoe8ng06d8CQnOuZbnNvOu2 QgtNYhETWvhiC20c2vxx7Rzd5fwPANuB0ALgb2GfcbyY4v7JSSx8OWDsepp6VhH7u0vb1P5UXd/Y 3/+05w6Wc1NJtqcG0QXAb8fO77k2hdjCpeIyJp7rys+HlcqXFRJa+HN6/OejWs4snj9AZ34EYO9s khKGwQD6UZdsXDhudVyqC0/gAdx4Ee/EEdh6AE/gxq3jmhvAUAlNIA1f2vSPwvDeTCYhpE3KCDFN mofUAgAAAACgX7TFrh91B81mc5lOb3ZyCYcTTfhpJ7bwgxNXFKIK2cotVisX57Jc+sKLQoLh6nLn yPPJrh4/HopLFQ4gt2h9Fhs3P8n5X3uX+sf5eyu3Qba/LzExxWHa5kzKeftLKOfneSGj/V0spFR4 U3EhvQh+zPb2jOJ9L12SW3j5/jFDcYlSiTHrHlMscew6tVX0DpPv65xz+53JbDqzgorM5oV2iSsr sVhb0YVh7b5XQX0m7zbL5C5NbPEqxQaVvrQiRW6Re3GVfTq8Se/ffA8/Ih4OAAAAAACAc+Z6E97H bgRAj3zJ4aJnh/ZwUeyhzdjDSn0HrY3cTwAAAACAsUF+CACnhtk4cB55r2rZgya0qCsXq0Ork3UB l8u9sKkeAJwmXfomrb9LKTveAlMAgPPFSSt+5FBgEVK30VKbvLbnabrRU5sNoJr2Y8cak6X2d1o5 1z+bTae+bXD5TnTxbINJ14kdAeD4PG7CZ5Dn3x9qIqyoypdIufAYNpSCS+Bl7AYABPwllImtT5SK tPZeGMfWOWrrHrXXkAZCC4A9fQstNIlEldAilFSkCi00uYVWV2x9eNhu7Rq1zwEAhsH0zTNBaAFw yphxkpnncBILM9/RZK6haizT9Zi6cVLqHEVqf9/l/4K28w/mtT/nYDBzDg+yn3N46tAuABiGNymk Ftr9f3+LL3/fq5jIwo1tNAFGTG4hXsyYBgbnXwD2zh6nYRgMoFY2bsAESAydkFiQmLkCF+AoXI2R BYmBWzB3oi1xkq/9YmzHdgsJyXuSyY+d2LSiKf75HlILAAAAAIByQp1G+h+8xzo9DN1otbo1260O 0t783O+30gm9PaRWUqGlFf3Ultvty7lCDC23aIO/L0u2sDTZwNiv9/F163mZY9RfxpLlFlKnFVuI PMe+f60rQh8fxBd+h8RP6YUW/3zZD7lOZpHdPh2E31N507aqMkYEFyLAOJH9B6nE/OueUp29Ge7q b8Y1P9hebW2RaPbr8ptOdGElFtowYSUYzXF9ftcdy7033X3P6nPnaVKL6zrd1enVpAstKlVGtr4O +9Cigko11V0EoDvsY533LBoAAAAAAICpQaBSmBtvaj9nAdHQItDQpD/fwiZ3MVROCrWT/gQAAAAA +CueDIuBAWB6pAT01EH9cgQWviCBoevcwIHGcwzL4HnsBgAARMh5NuWILErhWQnwf9BzYF/GbMiM WJt+MCcRWViGxjJzAj+d4vrUsdWSdqXmxfKn+CwJCSxyymvRheSL5OKm2yK5ABifC7Ufk0rEpBWx ZJF1Lu71vjqHvmPzHRzmwNXYDQBw+MwomxNk1ZcXCtaaUobP/zIQWgAcOFZooY9986v1PGt3znWK sMIntkgRWvjEGrH54r7f0fc6AMDvwLMZYJqIxELSujtfOnYxtJ+yxip1HVbJeEhu2VOSM/6gz9sx h3fTF13IWMO9ob8FYApcmlY482HCYwoSD8sVVbj5buys0PXu3Fc3VpbgG/tgvAGO4lsA9s4mJ2Eg CsADhoVhS1yqR3BnjOdwbeLF2LklnsPo0p0LT2ECJMjQDn19vGlnSENBvi+ZMJ12OoVAgfl5H1IL AAAAAIDusDqHXtoqTaczNx5PtnKJECM95HXSUoogrigkFm4jt1guw+PKLRZSeFFIMGRbPii7bNP/ xyxkD+chWzhX2cDpCx6sfpNDtr8f5/d+G5Tt6bL63Fspt6g/qrMNKvlF8VQGm/tg4Hc+d5ejka60 feF3RBRCUrFTx1XCCymy2Aot2p98EkglaPcQ7cVm0jtX9VKH/Kr8nARRxbCUWAzLMm2XuChlFiu1 34oY4c9/NRy6mzSxxeM6vbu6tCJFbiE73sOlNHXu64556yWKdcLTOQ8AAAAAAMcOUgv4T/iFox8J x1mLj9pSTFChFznliCzktei8tQ0AAAAAcAj4nwgAx8i12pbTDMJ27H900yJfaw6AFTQQQHK7Ts99 XwQAQMfwfQcAkv0XYpw3PpiTF1gEcYXPxwI66bKUccKUgE1t2znHptRPLcsJBrXPMV3UkeS+/3NF FtY0esl3md7K/V5yEYJO3WdeGwB0w8QVghl/X7fWjzStObHWq+h1LLpM19dtyPLYNsCpc9f3BQAo fhKPi/1O1/ua5hPmzDnU54Z8CJoNUHFIoYWcc20JKVKFFlZdS2rRNBfcusdyzwXol5njuxngGPB9 YZ+uGPP4cnXZX+p4Q2yMwcqn7k8Z90gdG8n5ru/jN0CKyMIqk/kguXhdp/E6PbhKcoFUG6Afnlyz 1ELGvpJ5mWLlcr8+jzUGoe9txMmCTvkTgL3z12kYBuKwYUFCYu3KHyEhYGFghwGx8kpMPAePwAxv gIAV3oGxUplasElML4djOyUkVfN90ilxcs1ZBTnNxb4fohYAAAAAAIsRSwr5c1fWLlMXOjg4MbPZ b1FDLTrhCrcX27kVIhVStKJqhd/nj58WxNDiFpUeDExsYXhiAz6uKeN2Gral2HpeZtfxF2c4/2/V PFcRr7C5iE81/+Z99LYON45tbm6ZyWQcFrX46cpc3EJG/fTfwdpcXEOLWZiAz1//eEMUlegzdh9x lzlmZaa7FH4R5mfNSxWJ733rPy2FLlxicVaKWXiblQIY31lwce1ped0Ne2yUJ2qxb+3U2qPJF7RY Fz5acTqUnA8l/X1X5U1GLj7Q+7GvFwAAAAAAoG/O++4AQIu8RM7lFE5JLQ6NLWzKEbPQcXWsun4B AAAAAHTFjinmMgEALCOueOB7pm+qeGCdj77GooVMeb5fba777gAAQAs0Kb5NYXuAYeJ+07qirdt9 d2RJ8QIW3l7V+VgRpFSBpNziSjmFmtq4Xo5vk2NNfZv6dEXq/pgSrkjdb2Xbi1zclcddoSkncuEE LkbJngJAWxxZexJtmVPSCxhDeai6dm7+KjYGskYFVhFELWDZeAsck/P+jImPxalxOmeeYWw/Jwb8 ZtdQNBvA8WHtxhT5jtSzfGirxy85p1rPu64ToAgJWqRELGKCFqG4uXO8c3M4APA/3Fo767sTAAPG /R54Lk2L++W+R0g9w6TWV6XOLRIr1t/cdup4m+SKWTRtj63dW3so23vWLgzvGwC65tDasSmELWI1 rqQoRUzAQgtpy8/pfVkjy28l8n1HaB+gEV8CsHfGum3DQBi+uKOHIkEKZGufJAjQF+gbJHOfJmuz 5BEyd+rWKejYLB36AN4CBAYSWBFNCqHPR1KyZcmIvw8gSEsnHREEkn1H3o+oBQAAAABAP1jBou+l i25v72Q6PV0Rl3DEfdy0KEUjXOFFLGQpbvHy0vSVPD/HghdeBEMLWVg+Yw5NbOFwxAa0Xwl+B3Xb k2+9NnRo/5tzGP9v1hpc77PxW1XWPvG3a2IxjPU1vFI/R4+XohaP87mcTKflGdX3MyNpYU6VrApb JEUuNgRRCfyO4VNHkGPrJrrdjJ0YRRXEKqogUjFpevHqEo3Nh7p3whYLdX6hfMSVHc4mE/ncTtji XPzGgFi0oo24RRywzwXnU4F560+UCsITnAcAAAAAgH3lW90+jj0JgB75GY27FFLJbUqyNjHpzVa5 jU7aNuXTmlNu3gAAAAAAu+Bq7AkAAGT4VLdZGKc2yx0ljmlywhapRUqWjV6Upv3ym/798aVul2NP AgBgCxCoAIAuIGrheRJfxOkhtP/hWEyu0FGXokipoomb2rQdt72v9bl039SxrrZtzw9B7n1aKhhV smkz/h3ajfiCU07g4qv4grwAsDvcO/HeOK5jRfYmuXV7fW1qU1zqHMWk4L2DqAXsE7OyiYm1LrH0 WffW9/TcPfR5sHHvT/ec+SWsowYoCVrkYhLWeuhtBC26iFgMLWjBcxVgGK6FfDzAGPwRn/9wQhbu 988mOY5SHiO1Tyr3Dm5r0yUn0jUH0iW/0Qfb5B/SRblsGzf+F9oPeRO4cMLaCFwA7J6Luv2V9VyA JUaha1+lamTp1ib/ILL+TCPvAL3xKgB755MTNwzFYc8sYNELsIIlYtcVyy56gSJxATgBV+A+LLhG N70D3fYClZCYNB7HGueNn/2SzozV5vskK4nzeM8MQ/7Yz/4hagEAAAAAMB2tgyh9obvvy9eao+vr z26zke66PdGJIGLhBgELNwhYBDGLnWjFuAT7KGbR7QliSHGLGksTW1iG2EAurhvinjTsgWKn+Zrz 4rf7e4ft//N9C5fDnRjF2PdYpCL+3lperkt8yRjB19lZELL4/f5eadZqb38rYpGIWWjCFav1euwj 2hiun7uQ7eYLLjH2UuLOjTfKck++y7JX22fzpCoS230vZJEcf7ixokQUuNj2gie+Pwa/533dhU3U wg+M3fblu7MLWqwTm7id0jm/TpoqJwKkHfZa5738eAEAAAAAAFpx17oBAAfET6bSJo9qicilhOZN xlYWTfBCm/wkfcmY9BUAAAAAQGseWjcAAKDApQsTqCXpeH0n6qWdthhgzj7nh7F+eG7dAACAI2BN MGyXZAoAcFr8mGMUsPBjkG8Zm9KiRtZzlgWUSos4HcLWGr9mV7PV6kr1U/2cktw90fJOWTuu7efq 4oJTr325cGGxqW+OBacAjsHNsC0t8mQRo5DTcSy2krReuy7SjwX/OletGwCQkOYlas+otedheU5b hFV7T6j51WKV/C0Vf49E0AIgEAUtfirnS/0OuRzpuYIWNeGKnNhFrZRyvXO53blt7nMAgOPx2Jen 1o0AWBBeyOLHULyQ95wxAEvdnHcgy3269pxibbfleErd32Idf7COPVjHHfxWClz4ead+zOFTuckA MJMvfXnpyy+3y39N/yeloIW2Npac17oSP9+J43i+E9uUeH3LrasFMIk/ArB3xjgNw1AYfhTEACsS YgKJhSvAxAALGydA4jwsXICKE3AFJJi4ANwAMXZgqlCJm4Q67rPjpKaB5vskK7Zr+zlV28DLy/sR tQAAAAAAWBzNOXRdN2k4fJDt7Z2KuITBPlbLvDBFKViRi1xMpkIX+XEi47EteJELYbhCFprNOvom trB6YgOxdqWwu1SziWzbvpJl216M7u2n/7ytrWniFqFnxt2xbn/1dbPljY3NaftjNJKjvT3vPsz5 /YhX6IOqghbl3i0BjNn5NKOPohJd2u7C7n+wGcrwUHq4y/qk+M4MiroRqVgvvj/TqB/zd4nVb7dt 9QntzpdZY3cwkP04YYuTrLxIVbQiRtzCdtrbjnnXQe9zzGtvkc8Jj3MeAAAAAAD+IohawCrxXPN6 TFCy9pCSL8Avtt+3jjh18fThTwAAAACAZXEqJAgCgL/NVos5oQd0YxMMuvPd9fnfvT8cZOWq600A ADREu1alvH4hdAGw2jxKnkxj1THCFa9W+VTGhJIVxSR28o1vmwQqhR3f2DZjtHbIbqiv7fgQdfPa XM9SJJby1e12TOKpsv0uubiFKYdZOSsKCacA0mAEV90ETiL6cySuXynkc6oTr3CPmi1tTwD/mdOu NwDg8NZiTihOMFSPiV/UxmrrwTwIWgDMMII9t1IvaBETc+2Lp24raKGJWPgELb4UG3Xx3u7vqe98 tTYA/A6XWbnrehMAPcDcD3mSXMiiFO8L+fGb3q8IHevmxfQ1XdM3N1SPafv6UrGIiEWTeiiezohb 3BTt86wcSy5wAQBpucjKvcxEsEt/v912BSlssQo3V5YrfNEkNvY3Y4ugx3wLwN7Z4zQMQ3Hc6sIF kDojIVVsILHDxApH4ChsnIGJC3ABWLkGEyNMSIitDTGJifv6/JGPNlL6+0lWEj/Hz5QSE3+8P6IW AAAAAADtiG1gdLbrMl2lKlosTs1qJasrNkQnKgGLSpDCCVM0YhbFv4hFI2DhyjeiF1IMQ4pbdGHf xBamKDaQ59fUfnfqdiDfcs3mLn33Y3z/Q3/fqkdkU19z3BS8WLf7vz9fVMIWbT6nStTi4+sr4N4r LPPregv5swpBizXBi7ZCAnsk7DC2733yO4TPtdXt3t+JHNG2o9xO0MKJVkiFiaXIcwIXfyPhXt3L ut6DMm+eJ2pxXKZz0whb5AhazLwy7qgtSgoNzM+8pvqdibvHKOexjxcAAAAAAGDXXBo2ZMG0ePXO U+/buZs/YxuatI1WqU1asUXVjBEAAAAAwNjcjt0AAIAEJ6YKzKmhBfMLnecEDQ350Hwy978/3I3d AACAAIdbqFMLoA0AMBWkiMWPyQtIlBPcMCeAUp+8Ieroao+VT123CfiUM9fbxdaF2P7ANveE3j1T gaVy7drxrU4Ppgo2ZYNOEXAKoB9WcNX+7/0p8nPGpUKBolJ50hZ7zjFGBVPiaOwGAAjeW5Rt876g rV+UtjY+6Afi2L4SQQuACvtcuze6sKclNb6Qs+Z6W4IWTsRiGfCRWv+treXOHesAgO1wVqbHsRsB MGGseIUVsXg2upCFvNZsOXMKWr8a63OHKB87xtoeKp9zncpP2SypOfjcuYm+cw+h8jLffndeyjQ3 1VzDjUFMG2AoLsr0VKZvo88J+GIWsWvt3UzatfsLcfRxzzLmHqAXvwKwd+46DcNQGHbL2IUBpG4F ngOJV4AnYOSxKsEDsPEEsAEjYmVhZOpWiWLn6jrHjpNeXNrvk44SX4IdpNSxfXJ+RC0AAAAAAFZD Wii6a7toOn1Uo9HJkriEwT4uW1OYoha2qI+luMV8botc1GIYrmCG22YfDk1sYRfEBlIET0fcom/b q5G+/f7PdyYUscjXuJavr4UkmoIWdn3XZ9fbUlX+M5u5nchXzsx92H1oEaaoxCwKq/uqqusGRYD/ EIcoKpGy7f8qLLHtNkMe9SZ/aJ0vsud4kQlamB+kUh0iU5XQeb8mrxCvOHLStvpE9TQXZaW30Hg4 VJM4YYtLba+qqaXRJm6xsI6uAvVAqOMuzEv/It+CPAv1AAAAAACwS1yn7gDAGnlXebAZiZBDsp0X +tjK/tCpi3iF5DgttSH1VUoDAAAAAGyKY8U8EQB2Hylgt+TiYO/phz7S9Tke+erZaald5vH7zZm2 29SdAADwYMbIFGNROidUANgWX6k7sCZMkKZPbR8qF7GICdrkpruc+/YHu5bFBF5aZ/sx5V3r+PLa ymPKUszBpLGva3CpUNCpmOBS5Xlb8Cn7+KztRdtYEXAKYFVOVS1qYb+Du2tG7ncpKuJcMtVSh6BS sK9MUncAwMEVNPIhvStLZSH/wth6vr8PMmasRNACIGdbghau77UkUBErYuG7Vmorxtdbuk98uAHS cK4YnwE2hVkXfiusJHZdP3a/wTePCeX1revLC9Vtu6/Y/FDeOt8ZQvsHMXW67jd0ORr71nav7UHl ew032i6EPgJAPEZM+0rbU5Eu41zFxL9y52NSXWm/wrd/oVTzNw0/WViZPwHYO3ukhmEgjCppaKng AsxkKBgoOAANFNwBzsKNqFPTUXAGQk1NlxgptiayWEnrOIkZ572ZncgrWetkSIz1sx+iFgAAAAAA enKLUX2dW/x5X+poNrsxq1XcXfVHdKIWsKgFKbwwxUbEYiNc4cUs6uO22EUshhGLW+wKxC0OGXuY z7qObZrYBw+NuMWg8bf9m9u0bwtY+LrUel0TtJXW67b7r6o6Df/i+zuomrTL0u9dJFThBSxao21h 3XTaFrzIgKjE+GOPJWZrpXvwXVmPYjffh/UItxerCEQrYoWJZeTz56z7cKIXTYxJ4zux5XOdqMWF tVtr70YvaBEO2K+MPHCfG6CfNm9J2gwQDtinBu/jjxcAAAAAAOCQkKwUxsRHUNYsGva+KqorbbqS Nlxp25Zi5q4VAAAAAGDfuGdENgcDwH8nFrXosmEut64zVU7VwXHyMvQFAADsgW3ub5p7KgCMh8+h L6AHTsTCJWpyIhaLwF+am8slOUqVSwmUcm21yZe69FFK0JSbr+zz/qU2ufO7+vrWbUPX+14pwVSf 5FKxT5tkKiz7hFPOHqw9WTsTrhkA0lyaWiQpNQ6VSgYljTuFyamkc6W+pFisM4Excjf0BQBEfAk+ zTrA3P/qqXbSsRRDWouYinHsuPslghYANUMJWiybchfhipT4RWyV8Jpau60ZS5GOAWA/nFp7Ndyf AXaJS6g0t/Zm7Sfwa/cwaeY2uvg0fk1ZW9/lNeXTHG/r9+Tm1rXzD6ljzXxDqq1mnsGX541dW3u2 dpW4bgAo82jaohZVUPbzCJVQjuca4mc0qV6ae6ii1xCejaA3vwKwd+5IDcNAGN4JZVqKVMAJGBo6 Ws5BOo7DcInUdHAHYOAI3IIyWLGFlfXqYZNETOb7ZjTWy17bieN4Je+PqAUAAAAAwHQsR9F9bqXV 6lnm89MtcQlHuNxOQ2EKLVyhhS761IthaMEMbXNXIG5xSNt1znVrWzrbBzeNuEVV+1O+c9s+7FDc wteH2/OCF1Y/y0++EaFYt/kvL2oRE7HoDZjLX0GLLv8rXjGb9fnOZupDQFQCu//dpp7ZHm7Z1c8C e+ugLlSS2OSdUIX7n9KJV5yosu+33lyn64EH3JUXzfV1XiZscdOkNxlqaaTELcI2yzEfOue1kz50 yOtTlHpJAac9AAAAAADUxr2cdV57JwB2xLe0E65zlE6YnppSIhfahrVPAAAAAAA1WdbeAQCAQs5k OyCtRS6gpxUIMBdkUGS4jq/Tz/W+H8/7x8NFk+5q7wQAQGWmTE5krhwAHBL3koAXsnDBxn2wJut3 KBaMyBrHs9pj/ceskxq7LG0vCcA0NWjT2HOi87lyyedSut0cpf2nvACTWndMQKlYfsqyNP8ifcAp J25xaRwDAAxx8610UCmR+DskMb+UdV1aPqvYtqx63l+BY+Kq9g4ABFiCFmPIzVXUdaLyuqzbJFHm HtDeC5dNehACZgM4v8mjjBe0yM21TglaxIQoUiIWMbGLsYIWqd/Y2PFaZQDYH0/S+qYA4O+4+7zz 976r+pyPP8yXjkWk7q2lzzklbSX9LPupY/rLmIdVt4//DWPHH0rHHkrHFVJtVvmjSZ9NWkgrbnFr 7C8ApDlt0nWTXruyj3Nlxb/ScbD0s1mqPbatMH5WbJxBgjbGHWAUPwKwd/Y4EcNAGDU0FDQUNHRb UHAAeii4ACeAo9ByBiQEF+AOSFRIcAcabgHBJgkaZj32BMImwHvSKP6LbVbsJrEn8yFqAQAAAADg w3Iakwsyx9GOah0tFnvh9VV31yyJTrQCFq0gRS9MocUr8iIWTde2F8BoPtJa3OInQdxilWNP81m3 Y4du7JUPjbjFpOP7/ufW3sUh3lPBWheX4hXL/Vnln+t7UYunJGohxSrSPIXAxVoXWF+KU2R/Cfv6 Lv1JxKIXuDD+3qn4j2P/dmGJOY0pV5TXkzBFECvW6TvQCVR8iFUI0QqtMPEiy7rv2NJqetdnqtuI 6R2fqMVutP1o98EnaCHFLKTARc6xqrTQ/6I+IrlgHzLp0scLAAAAAACwCg6nngDAiGina4nHYdh6 yapkWrwiJ2Zh9R1UWs+jNFcAAAAAgJ9gEe1g6kkAADjZDL6X5PS+fekFX+vl3to5etycXwD+AH+D s6knAADwTVZ1PfI4MnJtBJg/8j76dsqJOEjBZR86e1J1pX3CoUGLSm3GCJ401jne8tLRW2fVe9pb +aHtvPVj4Qk0n2tn5UsBpmoBp74SdMrK9wGnUvBwxC0A6mwb5dY6kUzrd1G8ZbquCcvj6bmEQj3A 3NkKBJ6HeSFFLUr+h7U23rrc80jpfAt8Edtr4mm0y4nnATAH7qJdhPqzeO03yPKnlseaadEKS8QC QQuAv81VwF8N4Lskce/HaDehFf6WfGVPxLtnYd0f1PK1NkP6q6U9x1pZLu/d1xjKGPsPpb0Hz3Ho 3oLOP0c7j3Yd7SQgbgEwlHRfJEUtGpHuY1s1mbSOf6Wf13L1tT2IntpeBICLNwHYO2PktmEgiq6V 0q1HpdOmiwtXySVyBLlx44v4Fj5Cat/BkzK5gzo16TQMYRLWcrMAQUoWEum9mR0QwIoLaaQRuST3 I2oBAAAAADAPL2F0P/aip6fvcnl5NRCXCOh2aFGMYmc7YQvbDkUuohBGjNVtN27M9wRxi2PGrvNZ d7Glj3300GcvblFRy2Dyd84KWOwEL2J7YfxF+Q9m3iwsYbvtJtebzeT3oNfWRPEKbXrtZvxNJEPq /O4GazujuLVin1pM7676KPQSRSxEhhltqyTxuh1EMMLxSi908aHvN0ocIwpcSC9kobPeob9cLORj mbDF19Ze5G8tjZy4hZ7zEvM6OW+T9HFbVCtq3DuKImkPAAAAAAC1WdVeAMAB+aG2vfPt1FjJw1ae 2QefPEGLlNn1NEKOAAAAAADqs6q9AACACXxq7ZczXlLQL/qVPpTnvU7HsrHhNAlF9L7VXgQAQCVy /4sAcPro+2P/JYKAxc++tUWaLFMKE00tduS1c+f29TnE2mXPuZTvmJ/Xz41POfeae55W+r3PFY8q 8ZlbYKp0zuvn5sJ19yBw8Vm6glOIWwD4XJu+V1xK56lKfqup+TF/HUvvgzwV/O/c1F4AgGHsvEOT uhfR+qTuKfSO8+2+7T5SPudO+F9cCYIWAIGpghapnEPqfupSQQtPsAJBC4Dz5E66/BMAzCOIWTz3 9tvMleTpS69F5I4JrN+c8RLfOespfY+6tdtj/fc+bhi7/jDl2kMu1zg2VnLNYWHGgrjFo3TiRQ+t fREAKOG2tWVr674f61x59a9sHSx9PpSbb8y43V+jWnG2JTEHkOWPAOydO27cMBCGqXVhIE3KwFUq w0jlBDmAG18gJ4iPkC5NbuTCFzHgM6TIGVztKuRSWlOj4UPyaglb3wcMRGr40mIlUqLEH1ELAAAA AIA8JR8z/rB2myvo6uqr2e1kce1AxMILULQHQYpenCIUr/CiFS8CFt6836ftBTBCQQxzELdol1ay UEDc4pR11/mtfd2mq/vkVa9W3KK2sIZvQ+o/1wgBiyYQt2gGacbhcVnj5+HDa9rWXuTONptRzpci GhENxCyUdE3ga/pyNcGLCqxNVGJN9dY4zk0nQrGv3wyviPtzuBO6kOIVUkEiFLpw4bZLP3qa3pXp 6jm34YsyUYtLa9+NV6AuEbQIxSxCgQttAjT1oH+r/Cx9HqOEJTywBwAAAACAU+EWYbuu3QiAI/Fs /II1OVIvKWv+mE0RsCipR+6PxQEAAAAAluSudgMAACbwYUYe7SNdzZeyVNncx79vfln7WLsRAABH 4pj9Vq5/pI8EeB+48/ivtc+V2+HeCX7szC3QpC2w0xObmyvxa9u5aWrtm5Mm3Mp8mi+2T4Zj6WNp c2WkWLrPyb24ry0YVeJPLTTVh6csMBULl8R7e+rMLSj+29on5XgA1s4X4wWWYmPe3LlnEn7tXDZK uE3EAd4632o3AECgCW1PRb5TKH2xNFqeKWPuteL6xjuDoAWAYwlBCykikRO1yAlXTBGzkHXF2iXb HTteuR8Alsetu0UfDTAPJ7j3YPw3VHPFLFLfN8XGA7ExgWMX8ZX6S/PI9ud8JdvcPi2eGzPMGVO8 Zv6hZI5B85fMMZT4Ugvu/7P2x/i5hp+Gb1kBSrixdt+FR8t6mbgYhfSH90ixNKn3ZMNrB/dK8Gr+ C8De+SslEANxeKWEsXCGsfVNHFs7S0tbx8Y3sqOysPMBrCz0HeytdAYqxYsQyIXd5A6BCHzfTOYu f7hEhsudm83+ELUAAAAAAGiPZjC6zn1oMHiUXq8/E5fwMdjnghZxCgUpvEiFF7aIj3WRCy+EEfbl BTN8n/64ebGH8V6JLeyzuEWpePuIW2y+7/kYUr85yz9XaiIXobjFPG/vIfftu91DGQ4/5WM0kqNe b6HN2P8oNVEfRaBiJmYRJlfe6UxFOqq8E7koIBIUjnOf+i7R7673eTDpsJ6flnkRC0do1Y6VJEIR i/FUGCMUvfBW7980vQdjC7jLH1f300kzYQtnqH8RRUtDbFGLsC5nnI+N9P689hUF5dokwMYBAAAA AAAoxUXpAQCskJSgheVwHZ5rjtFaijc/aZuhrKT1Y40XAAAAAGDTnEn5wJQAAG1IzVlaQD/rPLWp N+WUYdXhA7CbOIHg29KDAADYIJojru2c+7d+eG4CbA9vUsZ28CwTMQuXXHAm57urzVHafNImQJF2 bFuXKs+dW/XLjGGZv6fJ0Tq36tvUraN8neQ2waTKrXyT/09zAaa0MitvlYVBqByvVbqs0nmVbqpU 34ADsN/0ZTGglIi+f0SzSS2T4muF10ztWwHYRghyCP+Nd6VMe8fV3pNTbZv4Gmqf0eAZMMc9E6+E YNkAjgeZBL7OzR1N7RTefzr2pU6JWjQVtNDELL6M62rjaDOXWt8DAKwfJ2B3V3oQAFuIF7N4Uupy dnx/3va5H+etMq1NSsiizTVzY7DG3OQYX0eM+ph1vkssu/6QW3uwfOZWscZgCVqE9lK378+tN5zK ZK0BIW0AG7cmdx/kfZyrnDhFrs231AUvUuuG8ZwW3s9itAFI8iMAe+evG0UMxGErKZBIQZCgoDtR 8QCInmcA+vBevAYdDVQIyjwKBWlyhx2v2fHc+M+S01pkv08anXfstb2n3F3WM+sfohYAAAAAAHVq C0Cp7r23t62OdrtXbr/Pu8uFJg6TEMXhryBFEqeQ4hVRtGIWsIgW62PbJIAhBTFcJm6Rz2G6oFM/ klJhtNhCHHsb48axx7zfo0UWELdYf+x5DnJ9P1/nmkUq3CwOkVqa4hazX7ZP5TBU+I67uHh6J2rx 6+bmSNTC4u7cY2dWZwpbqDYj2JKoxNbGXXtM/XesM++zT7EQugjiFUG44iy9et/5JGhxHv6fmQQt pOhFapetlE99hnEe+fKLPlGLl97eePvu+gQtpJiFFLiwgp+loFpof1t4i/RDCs7Zi/Qs3gMAAAAA wBogagEPCZmU3bqn7kl8LvlPYbW56DoAAAAAgLW4Gj0BAICFPDN8R+kLLo/XWw/f6mPrAd/WeTrG T8z/4REELZ6MngQAwCBOnajI7yQA9HDt7Yu3H95+uzk/t5S+LPNynfDJV+1r+WvlJW1r597Hb7Xp nav2lfpxhTY99a3j0m/Bqfxr8K8bS+njVrl3YymrrnfjKV1vbXrz2ds3bx+9vTOvEmB7PC/4rbWi 9Fpbk6p9zkt9LVmb4n9x+N/YjZ4AgCDcl1iiFoHad6uVH1jLFWzdC5T6LuUlbpXwm3flELQACHxy Mce6dV/ds+4RzBKRqAlaaJGKmoiFLh+UzxrLmlftO5ScbYDxXLq4KT/xd4B+RohZlHxW/RLxih6r 9aXrStdQulbrvdHlVqyjt8196I0/1NYOrTZL4w5LYwyp7kyVZbzhq4sCFx8cecsAJR57e+3t53Rs 5cVKMQt5bO2RtS+co31yvywdn6jFIIg9QBd/BGDv3HHiiME4bna1BaKlSEfBAegpYO/CBVLnEEgc INojJFUipUpFxQFoKHKEpKEjsXdwxmM+259hGO/j95M++Tlje6R5+fVH1AIAAAAAoA6pM+iqdNBq 9cUcHR0PxCU8vdhEF+6FLYbWC1vE7lDkwgthePNCFr14xtAN67Fu4NjLVDIgbjF12W2ud2uRBcQt pi/7uWRbh6f//q4uB4K/Zq5uf2zXvj5tsThcu38eHyuqGJzPu4KAhc+zNuefz/vjncUP1HeilbhD y7L3pdyWAhqpmfUmELEw5mXPtleS8GIWa3EuM1SXmAfiFr6XfPZ8z8Q94i78YTYzJzphi3PTLWoL RStK4hZhWthBL3XMx5323j+4REG89BCggx4AAAAAAFqwbF0BgJFwE7TvE2mlhUiaic/hAqg4fozJ 1rn6AQAAAABMgVssjPAhAGwbsajFa8bdUwt7a9Ngt3HvyY+tKwEAoEQSfapF887TxOfezcyXA9hO flq7eMfzP1j7Ye3WdON/4bzecH6uZoOM1CZEuQ2MSnG5PGPkq0nT1lnTbo2r8UtjnzXhVJwm7S15 a9D8C9a8O2s3l5LiSgtrtJtMzaI80tx5Z7+t3Vj7Zu2TtVOhXQD7xEkmLV4Ck7o347D2/tXi8/L9 DdvIZesKAAT8Cvy137JSPmkeYe573CTylupQOmYXce8+16d/3boiABvAWwUtwnA8Z7pW0ELyl9Kf EuePy089U3PPWOk6AMA0fDX5/2kA6JlCzKL0j7IJVqqv1K5UmyU3FSeFS/Ha9Jgxxx80Yw+acQdN P6UUF48xxOMNLuzGGj5b+266sYazRNsA9pmltbsg7Pe5yu1/lRoLTB2Xuqf/Jvwe/qHgVfwTgL3z 120bBuIwZcBAgAyZMnQJMgTwWiAv0CFTtk4dm+xBXil5jPYlunfJEKBLhkxGtsolLdGmzvxzVh2p rr8POFDkUSQtIJFEUvdD1AIAAAAAIE1u4sf7Plu7KjU0m300dd1tris0sViJWbgyd+zFKULxika0 Yi1g4UUsXFlT1wtgLNq2Fh0hjYUi8DriFv93v03f41zvsUUWELcYvu/Nuav0/tz1+KqV4EUlRCW6 51Wd+tPp0TL3Op+XR9WKWIjCdRperFbMYplOJitxi6EvKIIW9DlUf7mZ6CoQunACMK28y1K4orb5 ifO58jbvBS2WahPeb8SseNum62dqjz/oRC0uTKNA7YUtSoIWoZhFKHARWwDNTeh79Wl5icKPAnIf CFSJcgAAAAAAgF3wydrJ2IMA2BE/Cv7cJuLUJuSY1Ypj7ebp1BgAAAAAAMbACVrwjggA+8iZaQJJ 5dbXt/nwVua38fkyOQ65R4B5gP3DBb/iPgkA+8LfiFqMt/EUAA4Zt5nfBcf/Zu3JNHt8ncX27Rqj f57OBSgqBTbK1dkmeFKfgEt9+879Ho0vTLW+VN1SPYm2Xsm3y3Mk2ntkrl4qeFQprwkuJdNSoCmZ jwWVKtlPazfWvli7tXYsfzDAgRA+f+e+DQn9qb/DUll4bqzcm/ygkbko2FfOxx4AgOBZUSe2L7D0 fB/zyTT3DiD7jeUPCXf/e7D2deyBAPwDDC1o8TuSagQtpIBFSdCitH/btOW53xi7DgAwDI8G8ToA DW+mEbP4HvGl5uv7vGPIfOq+mnsu0FgdaS/WfngPT70L9V0vkeUxn1H6UmXvSWr9Qbv2oF1nKPl8 Xgpl9zHXxi9rd9aurd0b1hoAQi6tnVp7afMbYb1MXMzCl9VBPhc3S54fW6MwZvP/nixnbywU+SMA e2ePEzEMhNFZChoaCkQJV6ChQ5yBI0DHHeAmFHQrDoBAVAhRcxOokKADHJKwk2H8s9HuZlnek0Zx 7CSOF4XYM7E/RC0AAAAAAMrxnEGnuZPG41vZ2NjqiEu0TMQm6v1W2EJbLWghke1vgYv6GqLq0+IZ 3W0KxC1Wu9667mF+b8Qthvp7D1d3U/Mk1bmJiYhFtyz3Db65+mj9e/vy+jrlbY2S6R9Bi1bIYm3N acP8QMxitetdFkEL60X+OUqJWIgYD3YjUqGVJFpliU6eErf4bPMrYZlGyMJ+ab8dnrHdMmGLQ6kV qLVoRU7cQpdph73nzLeO/jbd+YlUvte7wkEPAAAAAACL5GjoGwCYIY8qnRtb5z5s7mt2opStw95f 6mPoknYAAAAAAMyS46FvAACgJ9VEVu8zBm8CnY7je+Qm9qYmB9tFA/X5jPH/NptSi1oAAAAAQC0o Nyvug11LHeer1i5oxSxS8TgRP6YW63vHFjEqyS/d73vMLOpOtbEkTyJ5qTKbTpV5Y6HY+KhPrHSZ xlp9x5peXmphKS9duuiUN9EmtQiVTccWs7kK9hDsLNie0zaAVWen2drFpKyPKDXHxB7nPcci6Wc6 5xsD+IvwXoFl43mKY6fpM5f2zUuP+c/vgOodeCkIWgC8B7sI9iT5cXiJj8QTtIgJTXiCFFbQIid2 4ZlXb6kPqeR/KgAshhPhPQ2QoxKzuGvszSnPjQNy8YFUzKKvxd7LfcQv7D16IhexdqXanfudbLm3 n+o3zLNPURp/yMUicv7G2DYWc/gwZSmRi1i8QV+jihlWsYbzYAe2oQD/mP1gN2o/Fm+wa2Dp9KdM 1tCKxfu883U9uj6dBzAVXwKwd/66UQNBHN4TRQoKKkR7ooGWhhaJDlHmDaCk5xHyGEHKAyDxDhS8 QVoSJQ2pkh6H2fOtzh5mdtfmLj7O3yeNvP+8t2fJ9t3M7v4QtQAAAAAAsCktWIwci70tdbRcvghN 059T3RWyiJs6JzGLWNYVpUjiFV3hir619W3bjQhG29d9T0jjvkbJwmCO4hZzExxA3GJ0D+vj8A7m Im6xWG1c/7cfPD2XFou+oMWm3eacTb3XJuVbn/evu7vawfUuwmqsauxJzGIRhSy67VN6xxcRQQs+ c6rP9Gbfr+40uR+SIIUWrmjWQhdRtOLROp8ELVar0lJ9UJ7xtXhG7PNI0s/qRC2ei70W+xHqBC26 YhYl1emcs/63c4m0sz4E22GPIx8AAAAAAHYFohZwKMTFopdOnZ5A7C1IKk3YHjO5utRHabwAAAAA AA/FUuzN1IMAABjJS7Fzo1wvqLMoLdALxlGf5/XLf/zDIQpaPJl6EAAAW2bMu2q6CaoAsE/8/Mfz r8XOxL6FdoPFOJc37lswdAMjbzONhBcj9OJ4pfyQsm314Y2pplyX5Y76PKtOp/U7JJcfGhctvZ9q 3l+7/j9Wu4FUTV1uk6lSunazKS9tlTUVaS1wEeuuxD6JfRT7YHxPgEPnqdiNKsv5prz7MXevev4o K1/yiQH8LyBqAfvGRWU773ezrhsz5zD3bJ/7cz+++74ENsoGiP6Wk9DOq849h7rpnL+hO19aC0p4 AhSWoIU+DhG0sD639JzM+UGsPADsnldip1MPAmDP+S72NdiCerV++6HxkCE2VLyiZt2VJVoxNmZS ug6la2e1sfKl8lJdjm3FH7x8Lu7gxSFKcYaUz22Wr+MNlpB2vGa3Yp/F3od2vtZj9xsDzId3wRa1 qIklWHtgNSEvcGH1qWMOOv5APAKq+SMAe2eP1DAMhFEFyjQUMEMHBafgNBRcBq5AkQvApOAADC0M tFDS0HIEgoyt8VrsSnISYojfm9mxtbIsOxP/SGvpQ9QCAAAAAKAMrSPoPFdoNpu76fSgEZdYOKkr 0YpN1OkgbCFNCla0AhfuW9Ci9rUCF1V+EMOQQhateEZ32ZcxiVuMRXDgZ93j+73XU7/sn9l03cuz ubrr/ixNnKJ7X5x0/nt9/4eLRS1q8f7xYRyGsT8pVNEsg8BFJWbR6XELQhZB5OIXGZOoxJB1j6HO 0vq0HuZmB9+CEztiXyHSt9OIVEgliaAs0fE14hYT4avKukbIIu75PvTX2FGZsMWptwfXFa3IiVvI vBAY1TruFy49SE7+sHGHvYTOegAAAAAA2ATH3o6GPgiANfGcydfa2doHztrAq9yH1Z+ZbbV6tOMA AAAAABiSs6EPAABgBQ4Seam4vPVxhDUwL1cuVyf8T/ZcPUgaAABsrMktAAAk195uvD26Vshit8nr M2FSIHzLG8pr7+HWZEZW2vLl/KkJl1L5JT4rbZ1XnF+yLM2ztrW2K/Xl2k992lebbIuVPutybU9r m9TEUjnfMpNN9bFw/cWTTlW//5W3e28X3g6V8wLYVjRRiwpz2I2yHl+X8TK+V1jl4/rop4L/DKIW 8Nd4VXxxWyV13y1599Xe7VN19n2/3laqZ97MIWgBsC5Bi9R31SWCFjnhij5iFghaAGwHVdz9buiD APjDVG2NubcXJc9qb8TrqWd7nC6xUqGKXDrnTz3Pl42XpJap9Vye5VtmmxSrxB9SsYfSuEOfmMM6 4wxS7OLW25O3S28nynkCjIl9V48FfxM+GQ+Q81zFc15J32eUjoUttLJx7CGeN8uJPGekATp8CcDe 2eu0EQRxfOxYoqShSUeJaElLR0VF+kRCQrwGj0FBkyZdXiKId0gfCVEhUaVC2OzaN9zceHZn7/wZ 3/8njW6/d+/8sfbu3fwhagEAAAAAAMA8uZtMOe9rsDOvoePjExqPm83VQhYzZ+4zAQuqwrXVIhZN 8Qq219eZuAWLXtQiGJNGmyxusSwgbtGHvvt3vbn/xfqWazPt+57W3Nn3Wr1uze+rWuSCjHhznZvz BoN54YupAMWkPo+nl5eC4QzsuBbVENYcN32kLXvVrW+iEn3rd1sFLcy6pL7VWOylapeFLlhBgoUr xpXQRRSt+FTFx6LshPNJqUlUbcY+9oZD+jwalYhaxA2rL1QLW3iCFlLMQgpcWJujqYX5WP7NuERy wV6Hc5cXAAAAAAAAAJbBxaYHAMASeRDh1P/n3M3KufxFzepH5+t+c+cBAAAAAADAKrjc9AAAAGAB DgrLWc7/dJ73cG6qbiod/+//f6Kgxf6mBwEAAGvGu4nQmjPbtJ2aHzF3ArC9yHtc71vUewx2F+xX sH80u5+WfRR02Xfje3itseUcC7V1hFSaJ8vkhC3a9uON2Tq3VJpOt46pcG7vMhfPvRYWbct3KbcO SubEnAMpr4znbIrDnpMpmZZyNsVpQxW2nE5ZDqeiA7bvwW6CnRrnCMAuchTsj4jrZ0e00yfrMyrr Wkfdls7z0M+ubNN3KAApDjc9AAAEzx3reb/tycjXx5I63v2Iu0yc134QBC0AYEGLv4l8b63AW5PR x0UFLVJiFm9GH3oc3vqKdbSuAwBgffwm7LsDYBHn75/UfCZKUrKen5vXdbzE2ohWWHNzaZpn1tit 80yledevzb6HFdes8jdGyf59l7i379BlzyG332Dlp/YZYjjuM34Ldh3sigDoN+fBblWate+gfV1N RP6c2y6a95+V+gzLvmT/RKv9/gM7yLsA7J07ktQwEIY1E21AANlG7BEICEk4DMUFiPcQZBANN9gU DkDGCSgioq3ahIhkH0ZeWUy7p1uSx8MOs/N9VV2WWw/LU2WP3ZL8I2oBAAAAAFDHCga9qVVarS7C ycmzQVyiC1JXYi02kfaTkEU3siRQkQQrssDFeru26+vkz2IYUsgit6+3uwBxi2M4Nr/3lq0M2+mN HP65b5KEJ+5Tm8IQIt6V711W+XWdxajN1OfkvxuWjvy4vJQH37jxJRGMLvwVrND9XS7v/Z0Sr9AC Fwun/hwQtOCY+z6eFXFeDNdDFqYIQY04DiIVUkkiK0uMfEMbC+FbDteojIT3vr7eabwWz3phi5ub WrdfRfsWxqIVNXELmZcHTr2AvlafzukgtkH4ractFgkAAAAAAMC/5vW+OwCwI/rFoj+dvJZJxC0T n+VEar0wa5vJ1KX+AAAAAAA8NL3o4dm+OwEAMIPnhs/6cKDe12lZ19uWFt96C/d4/z9cnoYkagEA cAzMnbBo/acCwOOj9dn2a7QP0T6HND83z9PNbbRYnqd7J9q1PrQR1Nb7MFHreKAs0yJUMaeuzi/t W+mSr7St+VrT1n6tfK3ulPy55XdF6wdbSnPGSz7vnVWmrXnq1nuv9Q6r96VPXm8yrT8wJX15zv2v aO+ivQ0N6ykBHhm1eFAt5mT59PO2F9+yYlSt9ymA/5EX++4AgECKWpTmIZbK6DyvjvW83tKud6xS e4dO/z+3CghaAPTzqN9Hu3Lya7GBUnxGp6cKWlgiFpagxa1zDKsvpTiLd77WPgA8DJ8Cz/YAFl+i XUT7beTVYvQt4wZTrPSf2ypqsSsxi9oYSencvd9I53n5VrkW/9QyrbTE9bYZe2idK+fl1cYaepbK 540xWOMMXRjHOD9G+x7tPNoT47wAjoGXoTwO6H3/yvPne3Stbp++VfkhbN53GIeAZv4IwN6540gN BGG4dkckJIiQAxCwKSKGiHQ5AlyBS5BwAq5BzAVAIiZdCUhXQiJbjXGP3ePuosrd9npl7fj7pFY/ avoxM/Krq90/ohYAAAAAADneCxjpQ9hlG16XGrq4eC77fd7cIGTRCU50AhZy2GA9F7ToxCtubppj nIYxkYuhTTmKW9wliFtsoW9+75mt9PH0Ru7/d7ew57FzsYpBnCevN9it8m7c3Rz4r+tro+sz3Whi Ohv+qV6oIgpaZOIVId0LXsj5eV5/gfPslkQl1ux7C30u2V8UmDi0K/lZ7XB89EIXWrgiCl2E+rs+ H0UxwltsTbRL7pFq+uMx5B+06Se7XY2oxVPpJuy/SZ2gRSpmkQpcWM7RsQn/OFGf/iyxjhhpTenl BgAAAAAAgClcrj0AgIX4XrB7C4y9Bc1zF27XtGmNa8oCaAAAAACAu+DN2gMAALglD1W+1rfubQSY 2ryXeb0yOC3etuHR2oMAAFgZrncAYHEl/wtk/mnD5zZ8aMNPGcQsbuuLq9lYY2xzobn+QJHBFxjr 7p30lDZLZV5eRso8my63bDrt+TRL9a18qXxunSU+vyRTrpXWRlHemvGavPUcG9Pec61n8zai8o45 XRaP19Qe8mGzqd9teC9sNgWnzbM+tt4XkSSv3yHx5pxqjmFd3+qP9Sdwn3m19gAAFD9m1LHu81Ob 9zkd1zxf6H63wGPpNgF+ufZAAFYmCFqE+Zi/jt2bL4jx2LxMmvZELbRARUnEQqcbQdAC4JR5J4hP AWjCtftTH1uMXbtj2vMNTA01AhW1ghdTrt2loL+P9V11PMX/UXOfMOdeYun7jVr/Q43vwZo7tNrw /A+1Pgftu7N8DJ7ARZPYtZD2F+meyz9Kt18QwNYIa2RftOFrn/f8ddZeV+m5Wds8/7s+trXfQ++T VTrnABz5JwB7Z6/TMAzE8Wvp0BEWVngDGJh5Ad6DhYWB92DgGeiIxISYeADUFYkRiZGdhS9HiZOL e3d22lD34/+TTrF9buxWTVr7HP8hagEAAAAAAICNNCF0EXvRZPJA4/FeLVjB9ztvxCbKfFEnNC9O 0RauaAQsuNhF8xqqhDJKsQx//vD4X0DcYnlt59qDfls/78Xb5vM4Odqfj77bbs4zqL9D5cGnB0p6 5kyCte9x3+5GuMOEJ4zOsKJGzKKuw/JNnweif162TVRim9pdVwGNesbZf+ebk9ciFkTtqOGwEqng ShJeWaJVVolbDFjZsGrnqyrnM9377jo+GI1ShC1OnU2pLVoRE7fgPmnCnk/oh6rVfFKef+jaBD0Z 5QAAAAAAAACwKNiwFGwSU5bWxtHWImbJ38fi6ZQHqHj7mAMAAAAAAAA52CU8OAwA2AyKjQNfyI6z hw/bUSSvPbwrpVMfDiay1wmA1eIydwcAAGBF0BYZ5lvMCgDIzRs1ohbFpks3zm6pFLbg62y1TYW0 TYn4utywnGh2ra70X9zTZ/yva6zQEryQ/GFdySe9J83Hj6k+ra5WL7UsNu5JHRf1Xa8P+BgvVsej jROt14XjRykfprscw3GwlueWuuGUP947e6VS4ALCFmBTKTaUsjZusuaKrI2iYsbPI7ULwDpzmLsD AAR8dKhr/S8O07GxS9c2tuX+XwhaPDk7yt0RADKzTEELSXQiVbjCEr/Qzi/1RbtPWnMfUh4AsByO nV3n7gQAK8Snsztnj4rfGjf4oxYvCGMQ3K/9lv4IfqtM86fkeTkJaS1G0ld8JExr9SV/V1+KP0bX +MO8sQee/jXqxGIMUlnKXGcY75PELPj86ruzc2dXzs6U9wjAJnPi7Jnlu8QS/DXHY3j8OoyJW4Sx QH7PwHgLdOJPAPbOWEdqGAjDs9mC4gqgpDmthBBPgQTvQHMdL3KvcAUlHeIFeA1aKl6AHtFctRvs S3LxeWfG3lW4ZPe+TxrFsR1PNrrkEo/tH1ELAAAAAIARrxNnKPsY7EOpoc3mrWy3D5sbhSzaXnyi vRe96NKpkEUqXLG7S4+2L3KRHt+1KfdtPzaIW5yv39H/07re0/ke+nHm8n8c0/ge+80eikOskjxt Hsqq9++Nze3aSp93f29v5eXFhV4n+kqfjXGh/qaRNj5Uk7y9bZJe9cfsCWEcCIIW+Fyiv7wtq/d5 1dcdhC5y4YpdL3QRRSvW/X7M3yvv22z6e3OIPMb2n4W8V+t1jajFa+lUqH9InaBFOsku7ajXgqle B//WuERpYNELMtKhDwAAAAAAU/B+7hMAmIg4qPuXUeZNSPIGcFtltROk8gHg2jZtHwAAAABgThA9 BIBzQVs40IuvlwZNaJNvrf28TDsPcc4FlsknGRdqBgA4RS6lW3R+auYbxAoAS+NnsM/Bvsm4qEyj 1KuJweXv0rusjXxhjVzkwvOpmUh5QcSpbPAlWZ4Wo/RillZenq9trbQXTz1m38orlR36rbSUbyvv PGoXnMrLteO0v/H0m1WrW7volJce9hsl/5AFp4ZtFKK8CnYT7I3ymwBOnUunzLpXtbR1X+Z1NR81 vgFOic3cJwCQUdvPYr1v52WlsYs19az2zx0ELQA6jhW0KPWblAQtNDEKT8TCErvQrFW2aV9R7bNT uw4A8Li8CPY92PO5TwRgIcR5T1/EFsvz+vWteEHp//pUYhZenuajNN/KOl/vd5WuR+ka5ulj9jX+ 13vGFPGH0jFWHa/vctgeEnfw4g2tUk8Ts0jjDX+CXQf7LZ3ABcBT4l2wrzJ+A1r3kWf5ullpfh63 F6ONNinXnit8g4HLPwHYO3/dqIEgDs9dOiKliaBDdLwBDVWegVfgBXgE3oIGKRUt1JRItLwEkego SJMGCF72NhnPzezaucs5d/4+aWV7d22vfbf+M7OeH6IWAAAAAAAx3gCw162Vzs8/yfHxY8nx0a9v YqcXUYtbcYssPGFTWi+LW6yLV+iUBC7665Rt9/dZpnMQXpib2ALiFjvd7Zb2Xew0d9vA/h579E34 us27CFz0p7k8X8v6DchiFfkaeHJyKpeXP+W3FqiotSqte7sQThdlWYtbbMicRCXmtt9DELQIR9kr EQuRvhdxuRKp0EoSRVnCU5dIZUkU5n+d1Ta1Rbxs/8lyKU+PjuSi3a9fSlahtrupiVvosuI4rRnx tQNAG+b1j3At66dQn0oM9gAAAAAAsG3Opm4AwJb41ij33qlbA7q9QdRjgtp4247267UROwAAAAAA 7JI3UzcAAGBLpMCBnp1A++qjd27vwzsRGThwiaCBh8rbqRsAALAhjwbW02Pb7hvujQCHw6su/ZI4 cEUrCFHJ+6vWtwGNFmq+LKdxuX/Efz63eG3YVMhCi9tbofsxgZgiX2ItX5z82rSV11qu+Vlb+a1r /Zh7wb7eN2y7vf+qVycaS27no4+MakGnvHdcW+4FqdH9e0jAKW/sfJleSP7G8n2XnjvHCrDvpGfw KKBwwusnuszWk2Bas2V5z/c8h8O+cjZ1AwAM3528IWMBa8/sUb1oLKJdf47XdwQtADJfu/RB7iZo UbNVeIGqy3wkSLELQYsh9hN7vN4yAOyOJGjxbOpGADwArrr0sUufg/LWs370bjDWr9G6zw4RrvDq ROVj05Bjteelds5snrc81Ocxtvy+sXa/Wp0owPyiUifyL9hya5Os5UU+Bc/HoGP01PwN77r0Qxjf BfPjRZe+rOZ1vxBp+xFaqfQ/r2/a7XrXjNq1BuCGfwKwd8Y6DcNAGHahElKFYOrEwsLChAQ7Cy/A G/AovAE7iGfgTRgRL8DGgFiYaLBpjlyP851TlaYk/ydZdmzHdirZTXyX/BC1AAAAAAAAYI71MiKV XcZw4TV0fHwaPj8Xm2vEJUiIoqpFKKo6XdVCFo1gBcUySKELOpfaboQzKnUMQxBeGJrYAsQt1trt ivrW9nLW2f/ytOt7VNddjPnSOs/i5Xlf/FQ+mzVpErQgJpP9b1GL94+PMN3bs0eVzs2IVFDbPwPk AhdS3ILSVdm+W1fiDl32PZR+/7OAhteO3IHm6RETuiAFie00V9N9SS10kQQvtuvjlP9dnuoxEYzU 5lY9l/iu+E7MOxiPS0QtjmI4DY2whSdowcUsuMCFZji1NvHphTr5E3GDX85AKH9SAAAAAAAAAGjL YcDLXKA/PLK051CsOTJr5W2dvNs6WVtjBAAAAAAAYJ0cBjwfAgD6w9Qoy9nYNacjXsbryBd2PecL 2PX/N1cBH9gAAAwT6/+tO0dWAMAm8hZ+rwvcf5aOeT5Pa2IWMp98dLnIBfnv8n60cWj9U5sldr1V fXiJ50nRCy1t5bWJrXSuvlc3d+zll5YvW3eZ+n+F9V9Z8jJQro7mki/7lPNOPsPKuFLq5J6D5Qdq KJ/PRa0OT/M4rR9J2OI+QNgC9I+0l/BUp7V56e1PaXtQWizPb4N8Z2VT1lAANE66HgAADE3Qog3W c4rnvxiUY+s8rbwvQNACgDlJ0OIu+M/o2rqQW4f4fogUtLBCqYgFBC0AGBbXMZx3PQgANoDnGG5j eM2UW3v73r0/tz14do4SwQrtHsCrJ9PasRfkdVnXbsWlae3Yy/fK2tRZltweYOXUyZXn9iytzwTJ dqy4xN6QC9zGQLbCnL3hIYaXGG5i2FWuH4A+chYaUQs5t9K84PY7zZZH9ndePgv6fJTny7Zy6x5s D8DkSwD2zhipYRiIogqkCFAAMwwth+ACuQotFTeAm6SjpeUKFByCM8AMKTwRdmwnq/WutE5MnMT/ zWgkry2tnIwTW5L3Q9QCAAAAAAAAGWlw5zFVaTZ7c5PJtSvjLnsiZuGCeOdFuRS3CFNRrxS3cA3x CpqybBHUoUIW1CfNqe/9D4TflU9f+dztCUPcYhifdze+pTHfdv77+77LPO2/OWYdilzw8mhVXrcd 1g3FLNZ1xuOzpeV7Pm9/QnW7RLCiIW5BjguELcwu+nsPcCjCEkPx2aU/rS1pxqqqsBKxcI7NSlYi FlRJolaWqG2ny+vXr1Yt1bZF1SYdHa/bvz05cXfjsfvKstTpFIsiPl0oWpESt6D7tAF6Kn4hDdIH HxGxSwPzGLAHAAAAAAAAdMm07w4A0BG/rnyml4gtOtYWdGuJL7i2LLLm7Ut9kJ718fwPAAAAAAB2 yVPfHQAAgA65MRzDX5RN7W8TODDWJp73D4+XvjsAAAD/SOq/SQpIsY0vAMDxor3UUM+DjZx9Po6u xV2w9vhSYW0drtQHWpbm/iz2TRL3G9uWym1ySzk2dxqrH7NZ9m1b18KhPW9p68T5MbHgU1rgKdqe V8pazq8rS8Apz7Ylu1fyQtjiIU8zB2ELcFycV3kqmBMfn4ptS7n0Pxi7Vumxh/a7CYbLVZ4u++4E AAQahFa7Z7beV1v2xdYatvkt37TePgJBCwBK2gpaxMYhpHERi6CFRbhCErlICVrEgmJL5yDl/HMA AOyeaZ6e++4EAHvAa57elX2WMX3rf7g2x2EVrdDsqVzyqdk2nUOJ5SkbL3dhS9H3/Qf3b5l70MYO tdBB1jmH1HyDZuOxeei2ln+4tZA2hC3AELjP00WefojNMn9XX0/eNeff+XYseeazRvv9AKDBnwDs nUFu2zAQRUcQ0JyhmwbtJkBWBVrkHN10H/RYXfQKzRWy6wl6gO66ywWclHSkiB7PDFlbsVrlPYCQ hpY4lGBbIofkR9QCAAAAAKA+sTHzWRoWCLu8/CCbzW5xk7jEwyBEUW6nNAlWTNspyVN+mXbLkh1x i4j/WwTgEJ8Pg8/TXjDiFi/jfs/jW/fzntL3cbT6n4Qquh3bnjPXmedan5X0/avt9vfdncj5+X4d xOkpKyq/FbYY85SQRefZFRCzWLffNQpamMeK3evcDeWMQhdPShKDUMUodLG1ZXgfSvt9uZVCNSLX KYt0ydS7fpbyXvd9i6jFu5SuUvohbYIWpZhFKXBhBVS9Tvp8/Ma5RWXAL5o4QEc+AAAAAAAcyqel KwAwE56gxUg0sLhlYHRLikQuIr9RHQEAAAAATgXtQwBYE2+U3TLZ1ppAq8/3Jt56iwvqyXuWb/i3 uU5pfxAZAMA6mPMZVR+gCwDwSC0ONy6QIWL/p4zjdaP38NJP6WvcP0bI4l6VE12LF3f0bOv+RNdi neflRXYUR32u/GOPXbJMD/19ndO3LksvCmP5jtrBeqGnssyW9q+2vbxyganaYlNZ2OJaHoUtLgRg HeT+qTyWpfWdu/Yu7T37avv0Q8EaeL90BQAUvw44pzae8G/aCJFdawesgbcpfRcELQCeQ9BCL0xd E7VoFbGwxCw2TtlWH40naBH9L+r7AACnJ4vT3SxdCYCFyW2Hr+K3IVr6+KNndxTLaHm+e9sozzrH en7rfJE4rmJda3QfWu6hZ9eOj449hDneR6zF4o9F91uW+S22F3PYW05I+ajFFjpVlmVb/sY4xM+U vqT0TRC2gJfBx5RuC1v/dqL4nc6/N/Zrv2MrDuGtj0XMAvb4IwB7Z6zbNgyE4ZNgIECWoFu3PEPX THmVIC+SB+nQofArFOhSoN2yB8krZM1uOGIlwdT5jqQUxYrj7wMISuRRRxmRGfFo/ohaAAAAAADs Yy0iu801Wq9/ydnZl//iEuHdaydmIRJrTOyEJ6QTpBDZbNrUiltIJ1oheyIWoSyIW8TtwubQbZKB zzj3OG4RgCk+t53Pw94w4han8XnP4zue1z2077eR9u+tua26NrvyUgGL4ZxZ67+q2mmO55eXPUvr 67DqhCu2uwJtMEx1vV+WAUELfH5En8WCLOJEsiIRC5FhtLHuRCxiJYlV95xtIuGLoDbRr2SKRTD0 DHh//a/N83e5WpUIW1w16V6GohU5cYu4rg+uehP7eoI/DuKlgnkxTNQDAAAAAMBcXC/dAYCZeIqO vXfm3GJmUfXeom4v6fbetbS91UcAAAAAgEMSBC0ul+4EAMCMnE9s5/14VteJqtM2Y/wxF/CxuVu6 AwAAJwDjIcBxYm1KI+o8ttk65zoeV6lcY/2YwFuDGx/H8Tkr7peKBaZE7Us3YEqdS6IslefKUjY5 25xdynaszRxt3uMab/E5ZcG+t7nLGN+lm05Z9nrTGf1+rNe7j9lwyls7r/Ne2OKHIGwBnxv996/r +txK4hynxkTLN8Cx8W3pDgAoHkfYpv7H9tYReu8PYpxbPlLvAMdMGMeCyM2fJl0s3BeApfnepH9S tl5a5976ZmvD65SoRamIRUrQQgtbWP3Iza3o+7I+BwBYhiBowZgNp8zvJv1M1Ofm/EvGb28c18dj hStyY3OurCTp+7HutSRPHefqcuVT7abal1xrytq0KX3R/nIxBy++YMUWvHhDX1arulq18+IM/Z4/ 4fihSTfSCmkjbAGfnSBq8VeGz2D8vJTE9CyhCy1s4YlhaB/W9w2xCXB5FYC9s0lyGgbCaJsUh2A3 C6qoOQULLkBxAeYo3GMOMRfgCHAMdtRsWRFj4Qi3m25JDmFsT96rUklpK2o5P2WnW9GHqAUAAAAA XDulRV752IehvKsNdHPzRo7H+XCTuEQWotB1fxKxmOokWPF3GYUsrMCFHiONaYUtlrBvEYBzfPYn n097wtcsbrHG5u/7/lyfG4/ewvs995/e+9HWqc/BNLlJxKITLWiR2/k5tfMZ/Yydvj0+TvZ5p+VR sq6bfX47LWxRmdg1iUqs6fsafF7S37+MZTNRut0poYusIPFbqELG68Af+2A7pPsiW8sUAe/THNN9 jUwR8ZeD7dXh0CJq8VrGoH0WtqgJWuQ+vcwFLrzkainA/zN4ibxEH0F8AAAAAAC4BOnPXSwSh+fC 18DesiC5ZaF0orbQu3XhtZ1PZAcAAAAAeCrerz0BAID/wK1MG0tFv7PtH+rEtMUcj2qv7Y1TyvWT 898ed4LoEwBAxls02LqQcL0FqQCwJnYzmWyrFStoodt5na5djyuqr/av2yV/S+ylfGLNLo49slm7 V7e2Wx639llyfGm/pX23zDnnob8rEUs3n7J/KrI+onXq3oZQ2d664ZQ3lt3wxquTsMXHoXwWNpqC /ZNiUw/BMRsHao0x1eJP1ofnkxgU7BFidLA1vju20j12y/156++N2til+eyZdP1C0AJg5NKCFtGm 1JGghRWpaBW08MQtPF9RXMbO2ztH73UAgHX4NJS3a08CYCV+DOV+KF+C47W4fi33UMtplIQs7LW9 dv3vC4+9dn4sxi7KHl3fvbZXn9Mu2VqPb+XeYuk8WnMPLeOWcg5eW/ev5RuinIKXY4jyC3qPn2RL whZ3Mgppk2+A58ztqa59B184Nm/vq6Nj09+tKDfhrQ3QdgCXXwKwdy65UQNBGK6MshoJiQ1suQIL tkicBJYcA47AFdjkChwCiUMgsc6O3eC4p7uTck31wxNiz0y+Tyr1w3a3PYln3F3l/hG1AAAAAACY 4g24PrcOurn5Idvtq724RBiDPYhZyERkIpeDRXGLaLudJLEKSeIWnpBFrNPHRDELuRe0iH0MKZ3/ Dsl5iwAc0+eQ+lz2gp+juMVan3XsW1Lfi3eNuMV9/9M56Aehitr7KIdp+f9Hx8+L/Lm9ndS2uEoi FYMWqrCiFVfmvJPtxTS89lbiuQlpIGjx9G0Vo+2ViIWI8VQGoYqUtwIWu3RMVpLIkUz7chDBSNv1 LHlu//VmI2+ur3uELd5LdBRb4YqSuEXuLpcHOZyo15P19qU664DLWGeBhol7AAAAAAB4LCxaCpfC r9H+VrbXgpG9gO5SfckCNkhbb6v1K4UyAAAAAMBSvJS4UBwAwKWxdepqfvaeF3hLaWtxwVLoBHMB p83XtU8AAOBMWC/gFQBOHR0DaxewsGZFLPJxIUx4o7bldnSdTnXfNrX99dT1+Alb9V6+VFc699I+ tbxX7t2nVj9nnyXGPKc+rprzO9nzedZeiJnzN/Pa0ffsUyw4tXHyNg0WhC0+jvZ9tBcd1wRwzpTu JXHyc+aibNmbmzr1708Azdu1TwDA4IlaBFrP5l7MYKmN0jigNHYoxSxeQlxi+N1C0AIg8lhBC132 FqDOaY+ghZf3hC16BC1qC2PXrkGn3ucAAOvwYbQva58EwEr8Hu2btMcMted6r86zmshESzyqp750 fO05ose8a235Rf6Xf+SY+rks+RzS63849px65hC136AnX/M36HzJ9Dyq51+wPo4gbPFJor8BYQu4 VEKc7LvRfqZy636z611562L969zXuz8H1ZfI4fcI/gmYcCcAe+eP1DgMxWGFhnY7OihSUm8NwxW4 wF5j78EJmD0A9d5gZ6CnpaHkBgHkOFq/vDw9yUzGcsL3zWhk/VcMsmO/F/0QtQAAAACA74znDJrK bmO4KXW0XF6G9/ft7qTIRC9EIeM+dGIVKe7FLLaFLGxxi6F96nsQy7De143/rUlrEYDpxR76D4y4 xRRjtznX/dhhM/bkQ397cYthXQ+X1+F/QKfT8SLsil7ovKFeN8Zq1dd7fXvzz1QSpbAuOEKsYiHy pJDF//KTk532CFow5hzH22tfYfuKJI8XSehivSY/TPWItbKEELnYioOwPG3WqLQ+nca8s7juXsrT XMbwM4Z/oSxoIaeWjF5yKjp4L/ZXmVOUM955pxcAAAAAAKDEdesJAOyJ54o6nsOzruc5e3/F0TpX DgAAAAAwBxA8BIBj5TyGJyPf+gGdLEuxDrI8qHpWewts+ofDrxguWk8CAOBAKTkbtnOSBYApkH6u Mm3ZyZIdLog6aYOMlJ98cpN/rtwUI7UL6liPoe13OdtfrU0wiPnlbIS5sS07pVXu1bHKv5Iu5deU 7+v55pifk8Z+ttJ90vs7Wm1Lz6G5Hxrl/NdzG+B4z9O6jdwAx4q70G009TuGO2fuAHPnXKX1fcpb n967pdxxrgzgGLhqPQEAQclXsfb7X87HUJcFVabTOR9IK89rM1e6exqCFgA9UwpayA2sLUGKWkEL q21pQ+2SX7YVW+cBANrwI4aH1pMAaMTfGP445bX2gRo7hb5/l2Lv/usJXFj91dy3SzYUz6ZSc770 sZUek1dirt8vxszLe184tp+SzaE0Vo29Qb7vlEL32lao7Q2W0EVnb+iEtO8DwhZwvHSiFo9hd33q dWbtcyWv3Z6dL2SOLVugdZ3AdxZMPgVg7/yV4oaBOLwHzDCTGQq6dKTNM6TIk6Slpqai4iXS8wqZ PEmaNKTjCVIwF0BnGa/3VtJyOPi4+74Zjf/ItmTdSLK0e/ohagEAAAAAMOBNqpy3brq5+SHHx6cr cYk07hrELES0xsQgPCFZ3KILy6VksQoZCVmMg8j9/cPonkHMYpym3uajyuvV2TfRBcQt3jLtecq6 S1ty2m+e9N6KW6TfuWuzPFEKGZ0bxC/EiZd8zTgMbV83l/377k4nvnr5RV5k32Rs2BpRjQclXiGl 4LznHJDu7qW5bYIWdmb5+Ym9iIU67kl16CALXFgBi6USvEhKEr1n0+o4tRc5Xs+YS87Dx8NDOTs6 ktv0cVTni3RK1GuaGuKLWmil6X7i3pu0t4awkrHtuSicItRFyaQ9AAAAAABsyte5MwAwEXqByqiT csThW19XcsD+J+vPrT3P5mcqJ2kAAAAAgE25mDsDAAD/ibNKXNGNIbBv/6gnznEkTdhurubOAADA xKR+8dfcmRD6Q4Bdx/q7Lpzz/X7vi2sXOFrI+mJHBzL2s/W+yUv50c8pLaxUi28tuOSd89K252yc OPsRW2ckrnV+03ta0N5vRqvcplh4qtYfa392ve/FRxacqi1o4/nU67r08ylcP4XL4HsBbBsfgtfZ /5CU6lPpntIclddeePVf13mAbeTT3BkAMPxR+5Hv6NLYwe7be0vjh9YYo5SP90jqoxC0ABD5K93Y KLU/rXan1nb0x54PdEnUwgtREYuSoEVtsezWfIy39coBAOYjCVrQb8O+kfrq79ItJu5RswP025oN omTTiApRTCVq4fXZ0T48Oiby+vmXjHdeMyba9e+I2vuV7A6RMmnZG/Q1L7E36LB04q3tUNscF2ab QhK2+CadsMVJ4L0A3huf87bl7xq159klu3Q9a9kurK1RnwdY41EA9s5Yt20YCMMXZegLdOnUAOnW oWPHAu0LFMgLZetj9H36Ft07t0AGu6JlRqfrHUk5iWnX3wcQpCiKpGVQpHgUf0QtAAAAAOBSiSZk 9MvW3eg+1zK6vX0vm80yu3mD9SxEof3JJQGL7E9iFnNYi1zkcyltTpPCOe9ZLKP23qffEddxaaIL iFscs+w+93oqW/ZlH73oixW3mMu/evzPZxGL5brbLGSx9GWRZg5fqbxF/jw8SBazWMNOzGIZoeoy p7FCF8MwyHazkR5ckrBEj3LPXUDjpepvv1jb7svyZrk9t1OWcMQudr6oL1z27Vhbn16NcW+ur1tE Ld7JpEb9Q+qCFrpqW5kn6LXxS7vSxH42qkVGOm8CP7q9AAAAAAAAEV97VwDgmUgfaf0qnC8tVG5Z NF1zCb1g28srKleCYwAAAACAY3Ezug+9KwEA8EK0bBxoP3i153QaG6f96DovDTb90yfNnb7tXQkA gGemdUPdpxB9HB+lpT8E+L+INqMR8TePEfFtb3pB/aCOo802anWKylmz6VKUj40TJ3yIb8OlcyVb qEd07pBnMs/xPpTuu9cmWv6n2qZTazac0vG2zQ4mzuY9qOvzevzvo/s4ui8NvwPgFEnj8N/7sO0X NbadrZ1z8jaPsmltud43KYzT4RS56V0BAENpraJlzbi+5V3CyytKc+7P89QnIWgBUBe0iNYoZ99b 72znQ1oFLdaIWJQELbxyW+ZkPN+7DwDQj/vRfepdCYAjk/roJGjxMzjf0ldHYa+fjPrRp4hY1EQt SvVYY1vxwp5fi5NCXMuYgHHDv0T35BCbgzcHqf/PyN4gJt7aGaJjLW5hhbTtXj9J2CKNrb9VfgPA OfJapvWOqT+ytohofytrP8htZqOOrbBF6Xpr+xNZtmkNtgh45K8A7J2xUtwwEIaXG24YSioKiqTM A6Sj4VGY4QVoqHmT3AtkJkVeI5M2KcNDUMJhny283uzKOoec7/D3zWhsaSVW48GWTyvrR9QCAAAA AKDBmyy5GWq0Wn2Tk5MzafYyXysxC+ntpd4JT0grbtGkTrhCWvEK2QhX6KTr6HaNoEXfpz7G2N+M 5cxNdAFxi136nuZaN76l9b1z1zMTtzh6FbBIz8MkWJH63+X77eLzfn697r6DqYUtTpfLuDe1gIV+ YKYLYS+IKj+y5+1xqlm2uQhLzMXnvotZRCvgN8Iu0kWCFu29tVGHqG3V+cIRsHiqy6VTkkirnDb5 yv7c2vUMeeJ8sZCPx8fyZ1jY4rJKP8TR1BBf1EJPztsJe51sIMxO0PcukSr3HhdM1gMAAAAAwBiu pu4AwBvxe4u63gJoz+4tBt8meb6sHQAAAABgH7idugMAAP+RTyZvP5CLNhDUx5zN+yjPs3nxfuL8 +w3jIwC8d6KPxrdpG+Uj29CCRMZGgMMm2nxG26NjWmcbtbPrbKP37lJfXtKbL4nqz1AcMIoLen51 mS33bDLC9i/lETybD4tonXlJPV0/9/9TsuFUtEnOk/Q3mbL38+vnBNK/z+6q9L1KF5l+A+wrH6r0 yymP5oy8ekObRUXtrC+AQ+Vq6g4AGB4K6w2tU7S2bdYulvg9ZOqx67pKXybuB8DUJEGL6LnjzRfk 1i2PFbQYEq7wxC4QtACYH7UY1f3UnQDYMT+lEbR4DOzRe386lrz758ZuPYbb8dwb34fKcn5Kxu2S sTw3rufKSvMevCuMpyTmMPb62jiDF3+wc6FezDDFFOx8q7alv1+nr20eYQt4j3yW5vejXhPkCUzk 4g5vkXKxD+IV8BcvArB3xjgNw1AYdtMBiaFCYuECLJ2QYIeFnSMwch3OwQB34CbMSFwANSSkIe7r e7bTlLppv096smPHsTFO4tqO/yJ+CgAAAADAwRFa8NXGPVR2H7vQfH7tFosmybq4RLkUofDdxmqR itZtxCw6vy9y0ZpM0127E7foT8r6ByNl6RLEM7ZPvnzz/JY+tnpu8i6z1ncuhtf5GO7n7tHbileU ZffY9QUtWr/lWtTPw9ns/Ndfi1qsF2Gy6obihU388CVFUfyJW+ySiS+wcST5Hnqe+y5ooebjujYR GvmuFSQ09Yjf8FrkQnH9r12KpWiGf/efVGEX02lKMS8ruxbZTpxepJWi+UVQLDRA3463yg8J/CqS fsnuGz0AAAAAAIyNu9wFANgS757fGqW0Bj9TFkyHFmIv3Op1Y4uxU8sEAAAAALArHnMXAADgnznd II31YayMc06fm+87X8/8/n5xV9lt7kIAAOwZ8l3FuwsAWmJzc33n4bQNlbSNFKV9e6bFx0zbqDEW bx1rYdoGUykbQcnzQvXaZwMpSd/zYVxsow1Y7VM7jm2QpoXH7sOvyp6GVQPAqEgZd9K+K5FjWXxr AofCVe4CAAg+lDDZ1wr1pWWcllb7HaWlsc4Zc18eQQuAhk+XJmgRG3cJrX0eKmjhj5tYghZWeGg8 xPqbfFfWAwDk5ayyt9yFANgxdZt/dsMELWIWez9b72bLQnMo1jUWwt/nXW+NEWt9AKtfEKsvrd6Z 5/hf+vwPQsetP9YnDAmwpJjWrl8qex1QBwD7yo04tuYN5P5Wm4pXOMUvXW3tLcAKPwKwdy65bcNA GJ7EXjgBimbRbPs4QY7QK/Qe3XYbIAfpIisvs80duu1RArTeBIhoSzBFzwwpv2hH3wcQFPUaipYt mUPOj6gFAAAAAID+h+ln7qD5/Flms5vlchyEPw0Q35VDioUo1sIV0gpbyFLcIk5hW5f3RSykDf6/ srFet83lb9+PNybRhdpiC2Np57XtOu1d85r3Y//Uv8+xKEJfIKETuNCFK9JjNuedd+e6uvqwzF8W i8Iq6X1mPWGAVOAiiFk0SdJ9jkANgYcx2a0h3LEve8eoe6+3uRWzuIiWUyGKSbvtUjaFKybdeukr SXTnmUTnlPa4uA63zXfw23RaUu3v4gtXWIIVORGLyyRnYgEAAAAAAByL0Cl9V7sSAHvgv+iTRAOl g5S1dblBsfGxVjAZkb59bQCuV08AAAAAgEPzo0kfa1cCAODAfJHNyXEpnnhFuo8YuebTt8YAWHXQ 7MLxeahdAQCAE4bnFACUYPm9cn44KxBNToBi10BNQ4QutLIXlMkTtsi1geefLPVjep8DAZ3Gy5CA U9791y179/PQwFJeQLa/sgoSB3BufHK2eeJxVh+Tt98QG7zbwznxtXYFACJCkPl/WxynvX95ZS3P naPExqmDoAXAijAu+l7KBC20dVay+iiGCFpofSeW4OerYqN0nLZ2nenv2Tn9vgG8dx5lNTYDYAyE OUy/m/Qkvj9EJP+sTsvWs9kT197Vf2KJWFjvA6ndnI8k924y1A9itfe5/fd5T5T6G9JyyT2hCaRo 95clvGIJsIXyryb92UcDAJwQn5t0LbZgthW/yhO6KBG9SM8V5yKbPg5R9oER8yYAe2ev0zAMxPFE VQfEA7DTkYEJVvoGTOzdeBMYeSd2Zp6ADTGVsSoOqak53fmjjZK0/f2kk93E8blpq7j+uD+iFgAA AABwasQ2FvpzD87mqYpms6tqtfrfpd4KWKw3AhRh2lojYOHTVsximw9FLrzJa3zdoS/pfzd2H+M7 JdEFxC369o24xY41VOP5PetiFaG4RXve+w/Ly3oq9VxY13R6/pv7Wi4Lmlj/pbUXr6i2IgGhv3oj aiGFLvrgVIQlvM9DFZco8deloEWf1EJgIsxrI9iWgkQociFTKZIRpg1nLn8xmeQ099LZrXArRSti ohdW2digve8gxm6RzEsYwAcAAAAAAIv50A0A6Ii3grLaRqdKHItt8kwtitbKatdJ/wAAAAAAQ7EY ugEAAD2gBQ7cZ57d2oyXm89tBwzD3Nnd0I0AABgRKVGo3LIAcDrkzMGFx0oCKcaCMKUCNOUEcEoF icoVstBSKzhTKqiTvH8lQZysawEkJQHBSgNOad/3EoELmX9x9t7R+wboC2tsSr629ofExphie0ro r8MxcT10AwACPoO81n/S/vtoWGsNK3E85qeEQ1i7iKAFQEsjaPHs7Ns4n7sOOvZ/LUeMwhpPyQl0 vQr8IWgBcPwsnN0P3QiAnmgELZ6cvRrnrWdZzjyB9bwMU01Yah+znv2Wr7XIx5712jxJrB8g71Vs 3Jp5j/GS+7lVRt76nuSKW1gCLNrxxh6dfXTwvgHGxM0mTa1xTQlV7GvSL4DJjwDsnTFygzAQRRfb M26TMp3bdKlT5SgpcoKcIEfIDXyENJlJnVu4zAmSInVMEKBhWe9KYDMWmP9mNBISSCtsIYQEf5Xa AAAAAAAAABKjDZ6eYgdtt2+0Xl/X4hLNsxgfbAQnGleJW1SuEa6gWtiCSnEL7lya9/mxXsiCl8V9 Hj7uG9c+o/4Hn1bu8aQo1//uKT72Pqfz3JSd5nynrPMw5Y+rPTfCFlLQ4vB5VlV+I3bR/u292EQV 7/d1LJfr0v/+/T3V2JZghROyKB0TvKABRQnCpsxHzCJVuVMW0Din7VktKsFnobImkbKiMS7q9EXZ NvNSHSIvwguX5gQrnDgX8//qY7yShJ9FKrddHi5vd9/DylrU+9wUbXKzWtGXu5EKc0+V0roUrtiT Llixp7aYRc7ipHhFznwfz83lP1DO0g9OrxEPAAAAAAAAAJKH1AYAMBA7FrbGxH0WMnddENvXWXZ1 iQMAAAAAABdKqrnUmivCC8UAgHmgfTiQo82zh17c67NfSMwCzwDGyUtqAwAAYCScMljBS+kAzBe+ 7pWvdZVrYCV+He6e2vfSfm1tV2E5LX9t7s+XKeOtj+do+VhxMl6zywrH6hADYwwwBOoSfyU9i4St awCxOM3xdk9sm7fJ58J99K4ZAONBe53GuoZr7VD2h7Jf1PpM3h67lg3AWLhLbQAAgl18lwO0sQZP s/aTftfxi5b32HF90iNB0AKAcwpayA9k5xQWq5DhkBhoTATUhzW7tXpO+foGwKWzKdxraiMAOBNd +2ketuYW+vTZsi+1+tquTsvP6q8t26x6WHW3zk8oLEH/Pz1C8w2h56Gx/4Gci7ScnHvU5ht+qBK2 eI/WBoDpcFu4T7Yt17jG2k5fRyLMy5VtlpRtAOhfAPbOIKlBGArDlI5rV864c+Oq27rX8QTOeAEv 4Tm8ihdx5zEcV24tQpES4nuPhNKGyvfNZBKSkDzoUCAv5M9TGwAAAAAAcESsDw2bsscy3Pc1tFqt s82m21wrYFHs4lqIotiGWsSim65FK9yQdcqauk3ctOn2ZdHUG4Y0DyJwz736HU6KfuvfO8179pzO c9t3mvOd8pjH6X9K13NXxMIXtPCFL4rC+nbl73fni8VyG39+fUWatdjFnQVIqu08b/OdsNs+IHMT lkghLnGqghbHtl3rS7pCpZHs6sqU1CO2+ZXIhR9XQhi/ddw2c8eOszJ9uVyGmH9dhhuv20Umm9Qx LWs/rpHq9DnK+k6Rn/ZJ8wcAAAAAAABT5yG1AQAj8abk901iDZ0U3hfcSdx+u5I9fvnwQVcAAAAA gP14Sm0AAMCRuDLKpElEoWlp4cDYPmBa3JXhNrURAACJsBbLters0z4AzIMYn5uW/nbCRklbeVK5 3462CKO0GJSWpy32pC0AFeqrDD2vAGPT5/+O9auH+tz7Fl17L8PLyMcKcEguBu6nfVrjl7mxtD/A qYOoBUyNj4i6/nOUP2/QTUvzC0Oe9613hlMBQQuAmko0Z4igReyYi/sOJo2XWCIW1hhMrKCFNU6i Ha+0DQBpeS3DeWojAI5AzH1aupdZ/gDpHtrcWwsvT7r3Wj4Rrb7ka9FEqtx6mr1DxoVD/Bz4QP4P Ib+zlo55xtX8fZYwW+VzeB7rQAEmwDrT16CyBCmk9a6kdIi4heS7sNbFgpnzIwB754/TMAzF4ddQ qRIbEhIj5QTcgLOwcgp6Aa7RgQswsHIRkBhYOzAVlZgmjWue/zRK4ga+T7LixH59diTLiZ2+H6IW AAAAAPCf0V6U7mJGy+WTzGZnP3k7uH6dbQQnmmTEKrYCFyLrtewJWJhzI2Bhp0bcorFrxCw2e77s ow/ELYbwmVfcIpdfxC3G5j/PeLaFKuzA+E3WLZvsbBrbuH6EqbvZbJc6Plar5LaFhAEmtWNL9GIv n9KwFuQQW7B947Mff10KWgyJ688rL2P6KJYKRCVMcVKVFfJbwMIWryiq852ahGNjr3LXi5oXRSFX 02lKN24kLFzhE6yIiVgUzjG2AaDdQolcBwAAAAAAqJlLOJgfwFh4K9NnoDz0xy23TuqHr6HfSbEP wYfWAAAAADAkt7kbAAAwEKcJdbQ9ertMq+Mrc+1SzyE/i9wNAAAAABgpvuCC2vVYABotKJIbtEnL +8QuNBvNLkW0IhakKSU4Y9v9xEP2HAH6oOuAU+6Y18ZYaAw/lOm9w/4B9Ml5dfStOYlTHqpjX2sj 1nroNYBjYJ67AQAOr4n1fO9FblnsfSFWT/vtMb0zmPnnXhC0AHiRfgUtYkF+Q8F/U4Qv2ghauH3Q +ulbcwKA42BRpuvcjQAYgLbzdH1Mmau1edO3p3GomEVIEDwW7P/L095UMQv7HoTy2j1l3v+7dL3X kPIc7D4Tu2PgsUzP3XURICvme9nLKq/FqhLxfxPbNvnsbV8+2JsA+RaAvTNIShiGAmgozngEdy5k o+PGlVt6Cs+h53HhPTyEh3DGNTcA6ZSWNPyf/AyVgnlvJhPahCQUmEKa/ofUAgAAAABKIRY8uCt7 2aZlqqHF4tGt18Pm9gKLTZ+3IorNILWiCl9e4Sc3KO/qd3nXpt9XLsgtTtFnebIF5Ban5zLlFpqA VRNaOHc4xxUTt85242vzn9VKqSaLBXrhwGy2366qg+f2o2jKdvXHFgxMKbMoQS4xRZ9j9nfKsVs/ E7HZbz9pBolOcnHVSTAC0UUVtFl5Y7rePr6Zzy0v526bnsNuE8mvEwouYqILX3iROkTh4xAm8QEA AAAAwKeeegAAI/FlqGNZ5Jy6ycsagEZbNBvrGwAAAABgCp4cNxUDQDncB9uW4ICxMm1Bkt92bNFS qn2YhtoZ1v0CAFw4t3/QpvUmdAAoB8u1MUugGUuQRSm4oiUoviXwYq7IAokFlMQxAae074r2XYsF YH0d92UBnBU5QZ60G+2k+pqYld/1cM7UUw8AIOBb2Cf955HqaGVSO1Ku9XGp/xma886Ha6UWACXT BMp+d/E5gjC3zDtIgbFjSQt6rckuEFoAlE2z9oxzOJTAp8s7T4f7LPOgKclUrsAiJbSIXTvR5mgt 87fa/K92LKRjyTWRstDe85xrbdpnNdxOXWts8jeHTBv+Dw/CPouE4tgk9emE8lh8LCiQXwHYO5uk hGEwgAZlhhlXunTHOVx5Ex2P4Ak8iFtZu/MKbryBB2DpDbQBQtPw5ael5oPpezOZhLYhKUMbkpQ8 pBYAAAAAMFWkjtFTLtNq9WEWi5tN2l9I3yVb4UQbrKzCyii20gqzk1SYnbzC7AUXrejC7CUXWzGG 8WQWv52y/LgPyC1qlDk92QJyi/ocX3bt6zkUV7QCie5+/xjTObY9Th4bc1KL7/W6oDqzbuxv94Or gxNdeNs76RHQFFpolKkhlzhFKUTt9yotL7lfeD3b5XM2ByegcHaImZNVNPGlF1uJhRNZHAgtgjz+ Fe8GNm+b63I5n5ec1p05FFKk5Ba+nCIlsbgI4txkgPQRmsx2AAAAAAAAy712BQBG4stLp/6kGe6L PTBeIqwoDVL5Utk8cA0AAAAAGjxqVwAAoDJXA/LE5uvDfX4s5e9bHujwol0BAIAK2PZQo72hjQOY JtJChLmFZ2ILO/VdeKZEZJFaiGmIyKLvOUqfFws2wbmR+z7H0tJCU6l7gHRN27Rd+PVz5HMC+A9S 41KlMonY+FSf/5X0+V3Ob3g4JZbaFQDwkIQWJaT6R1I/QOpbhO9lhGPO6flEJ7R40K4IgDJDhBYu jt1TcmMfJTKLsC8mpXNCi9ii16l7oHTfk14DgC7XTXjXrgRABV6b8GbK22mXTs17xMZAU230mEEa by1p34e26yVzH6fcb4F69Jk/y80xxuYgUkILG/804Xn0MwPQwUotUqKJUsFFuGbWsZILk9gOE+ZP APbOJ6lBGIrDkY53cGUXdeO4dW9nvIEn8ASewRt4KMdjeIDOuHdlK4i0Ibz3EloKpXzfTCYhAfJg SKH5836IWgAAAADAFLD+JFVlT3l4jJ1osbhz63X9dDsBi802LoUoNo1QClns4l1wtfxq3yquzunX 1QWIW/RR5/TEFhC3GGPdx2/PpUP+v1TNWX5d0OJCELiox7IARjP/c7XyCyWDmvG/aEDNmb9XXglb bIUusmy0ggWnUO+519llfWMQ4pBmzEu91qGChC9okXnlDXGL4JyZZ+Nlnr6azVLMvMnDvV+90wUt pH1CgQtL6MLv3I/dojAdQsc+AAAAAABULIc2AKADvp29SFRa0BSbLN42v+3xFkzCBgAAAIA+eR7a AACAnpm75nh6OIYuLaazxCqkWJqQpC3+08q1euF4LPPwMLQRAAAnzD7vJeawAUwba9wrxeli6Gjm 0PDjbIc1Ur7m/CbmqMkaR9TuBeOEMHa0Z1lq707I034HYm20iF86vxqA7rne8zirnyi2riR2vJUP cEoUznLnQxsB4PHlpS1nm9Y+Kcdr31BSOoU28xj7AEELgJLCIfwxBC3a9KmE4oGauKDk7DpF3EKy K7TbGXlO2AaA4Xl1fKfD+VMIWry7du/p1JAqNhVzwB8Tr0h5x1tjJ4eKWYTp8P4xPgIS1jMTlmvf m2Fb09LS9kce3jq+JoAhuPXSmtCE5bOqjWCF5vMqdT6ulQ8T4VcA9s4dqWEYCMOLk5nM0DBUtDkC B6DgCJyCFi5CwyFS0FByClp6OAJNGjLBjm0iK6uHY2I58ffNaKRYtlfWxK+VvD+iFgAAAAAwRrQX ofvQRovFm8xml5uyGTS/Lm4FJ7ZptZKNGEWRl+V1Vd7mtrhFXVcKY4ghZrFu2DLzrnTbz/6+RsQt +rCbpo/T26a/99yLHP58ds+5bYpdNNcv6zRhi6YfrBYe+l4u5ae4mJoWPIH6z5pGmwIXhpDFX+Ms UYwuogMpBB7GZDeFcMexip20teWMElG0WwwViEqgYlLVZdWyqbF8Yq5nC1oY20xEGleP2rl5lWUy n05jmn0ju4IUPnELU5zCJ2KRWXnI+a91oQSWAwAAAADAuJkLE8jhNHiPWEf7EFP72KnNRPLQena9 Zp+J1wAAAACQkrs8XaRuBABAz7iCB7YZb9c+xHOJWITKMCweUzcAAOCEiLnfaVMGAeD4CQWYsXO7 rAU7tIUk2gRi9AWkce1fC3bjq5eI33Z/EKgJTh3t/62NnceMzWvXB/t8/8zTy2EOBaA3fM/HId9S SGA11ibAULlO3QAAi689tnG9S4jsPhvZy+w632/tGWyIIGgBUFIEyn4V97naxqei+TlCQoF2wGtX gOwYsQvNltYun+/E50sBgGFxm6eH1I0AOCDLPD1Le0GLOvf5P13jHr57teveHBKg8m0TI6LRxn/r O36t77i/QwwxYw2x4w7a86lL9KVIT3n6+O8DAuiZc9G/IY+JYxUraOGKmyWij1mE5uTCiPkVgL0z yGkYBqJo2i6QWLFmhVQ2iBUSB0DiAEicgCNwChacggux5y4sSqzixkxnxm7axCl9T7LixK7tWHWs jJ35iFoAAAAAwH/H+3gxpj234TFX0HJ5u3GWHukELFab41qIYrUVooCFFLLoRC7+psdrscy0riHY 3yF+f/sj4hZj1Funj2PdtTjV/p6uuMXsVwNi1nQiFmm8S+vya/a0ztm/dPofnreR7/DwdJAO/FUB izRfkjabz7eu9eFUhCVinccqLrFLfYcUtBiTQ9Sn7brXrNhBtGKRCFVEIYuoLLE5SnELUeY8afNZ G79cLEqaed2G+6RIT9BCyyMFLjyhi1TwItdFMi7BoA8AAAAAAA+1GwBwIL6SuGeE9D4CzW1ctTaw lmzCtupsnLwAAAAAAGPwUrsBAAAVOM+k55wCatsXrHzeB3q5OmF8rtrwVLsRAAAToe/cNMScxjwJ cPx4Tp3isWTNzhKWsMQrrLScoIVWfm5N0DqX/cC6IJwiufFQulYvx7UctyG8D3UTACNTak+SeXK/ yZUHMGXuajcAQLCLqIX1DqDtI5Tx0vcIb6/iFEHQAmBNELTYx1G29a6kvS9pdhLNca8lVOEJWuTs LNK2Iu9BO9f6AQCmw0UbPmo3AmBAgqDFWxs+m/7zdBrPfZPkCXZbglMlc7clXqWdl9hjvWDdu9Zv zO3QB+2/I/9z6TVrja9E+C1eC2PkdZC7ARiXm8YXk7D2uZaIWpT4v9Lq1vIDND8CsHcuOQ3DQAB1 oVLWSLCGLay4APfhGL1MF5yAU7DiBD0FUheIhtR0Mow/DW4dkvckK0mTZpyqcX7OPKQWAAAAADA3 rAui59SX1utX1zRXrr2HIRPk+3zpB+HEobSyinZ+J61we7GFF1g4U27hl+nEGId1eGmGjyWHpUFu ca6Y85It1JQ8dPHn9XuXiz18Ban4UmKhhRZ9kYX7GZcSjMBav9vMpuneZ//Ybq3A/WGwXv1lvfBC SgtascVCzDuGGoKH2nGnHrNkvHPW/a//Cesu9MKv1wkLxF5QsVSiCi2ykJKLnjVCSDAuXb8l8Dc4 b3b75N1ymVPtJ/dbSBGTW8ib8zGJxYUahhJkkAQDAAAAAACG8Fi7AgCFeAt8nnq5KacjdWi5nI7Y oXkAAAAAAGOgfbmYxN0AMEfuI/NyX5yzOiLlJA2MxeCZfn1WtSsAADBhjj0+AsD0SSV7shI6WQme cksoQVQqUVMqCZU1rbeTBE0A+c/u5XgqeZqVYGqzKy8n2QKAclyr6ZA0VS8Tmp/7/kju9wDGym3t CgAoNsZnqfOdEKfqkzjW6xCEFgAdJYQWfjok6JTXTEOFFalk2KlEwFa79ensdizWjgLAuFg5ztFh unihRSuyG3qcluPW/c2QWMKSV8RkFTnFOp4Peb6izzOsbdXj+jfjuA4lSD2PSz17jP2nrf3y3XXn 7gD/mQcxHurrauWy0tNDiibWDxfAfQnA3hnjNAyDYTS0AxLqAhISI1IXJBYGDgA3YOAA3IBzIDYu xiUYmdkQJLRujPv5twVOXMh7khU3dmInUpQ0dv6H1AIAAAAA/jPWJC9Xdtum69SOlsvzjcCiww/W 7oQT3XIlo/jYSk5goUQWK8lFX94lt02/z15uMRZl5Ba12v477U5NtoDcYnxqimq22/elFU2QD3/3 cgtfcvFdbKHn6C4WR19LKbVwNRMiik0/hNiimc1Wyx+KAGoIHqbUbg1xR6n2xu77EG1Zb8Bna9HF nieoCEUWoeRiS24h9unYb/Mn83lON5dtuvR2aQktVJ1QcGGJLnzhReoUhfkQXu4DAAAAAEybq9od AChAN1H8LbNu6kPO2ORUtW3uh6Th/lVfYnUAAAAAAIbkrnYHAAAqcZBRxxpzzwkiGJ+EpNuA+pw2 BNACAFCUvFchtgCYFrFxsnC8zC1zkgrIGKsXCw4VC6holaWCUaljJzgTgEZdG7EgU35ZzjXu8g8D 9R2gFMe/2NZ6Zo4FoVIBqmKSVZ7JYZe5qN0BgIDXyHr1n8f/nZpj2Igya96hKrOet2pz2Kbnhvfx MG26QNlPzbBCizC9r8tyhBapANo5ga+tdzf+vGy1VOcBAHaLmzbd1+4EwECUEFpY7zJjYx3WvVVJ KnLkFpY0Q/UpNU7i1qtjDvPh+eKeDqVJfZOnrsucsUV1jXbpsU0vAxwHwFiciXUq4J4ls1DrUnVT ZTEYq5gwnwKwd8Y4DcNQAHVLpRYmGFmAG3AALsPANZC4SRnZOAInYGflAoilO0mpVdv933ZUJ26b 9yQrTZzGTqU0sWP/h9QCAAAAAMaE1Ph5Sn1puXw3i8XV+rMvszCO0MJPrayilVD8SyvMRlJhBRZG lFvYfXyJxbaMlu22Uj9Jmv3K26+vckzihbHJFpBbDE9ducVkU7Y2b9zKK7bbd4Ptx75rvLz5/Hy9 /FmtlOpMglVHUOEuwyQdYzr1908wFrGELfNY5RJdyisptBiSkuVpV+tkI7FYiylsMr4dQhJZuJIL zxrhSDDOjP+vYDs5r5tr8m42y6n2g9kVUsTkFq6cIiaxmAbL3A5/CTruAQAAAADActmk+9qVACjA V8Y+qcHR2iRR+1kaQC4loyxTk0oZoA0AAAAANXisXQEAgErcBOsxaUWIlBcLBpgKHJhzfBiGl9oV AAA4UjSRU+l7GvdIgNNAex8XC8wYS7Hgidq7PS1wVOzdn5YXnhvv/QDy6RpsKvY/EAac+m7SW18V B6iINIckzAM4ZZBawCGRGrOY2y7QnnvCPGN22xtSuyVVB22c5FC0gTU+DGOXYdzYQNmfJv86jfWb SMGoteDYkpDClVfEAmDnyCxS/Sypc9N+BwA4LNp5SK+1KwHQE6WEFnY9RzzVVU4h5YX3865Cqq7z pVJtFZPYDlASrT0ce/6UrsvUM/Vvk577OgmAAbho0q3Rx/NIsauk9xCxmFgpSYZ7HCmvj7FGcIT8 CcDeGSQlDEMBFATXbly5kY3D0oUXYMYbeAGv5Ck8glfwMu44gKZC29/fn/wWSlrgvZk/7dA0CQwF SpL/kFoAAAAAwKWSWkhYHnsL8epVtF4//8skNFJuUQgpdiKK31aUAgtLZLGTXNTHiyjPKRLuS4mF TMA/jnThmDaP++/yfCUAh7R5XbIF5Bb5GU9u0V7vXSfVb+5bZWT+/WbZert7fD5bLvdSi+1WdaEt IDAT+wuxxbzZcPVYJcLoIbO4FrFE2e6ltzmoFCJj33O8J2TtN+U1rGMvqKgsEUJkoSUXLbmFaGcu 2wjb2xAPi0WXbj6FeBFVpoQWVhktuIiJLrQQQ79E9ocfSTEAAAAAAKDJZuwOAAyEXCCqF23GiE2s PiZi9eo2AQAAAACmQJH4h2QhAHDN3Pcoa00q8mQVQyT3ZpFePlYh3sfuBADAmYPIAgAsYkmMym1s bC+VOMlLjBhLQpOqR/cnNR6onwtjgACH0yfZlHe96+v+88R9BxgC7zd0TKBqlUmdEysLcE6sQtyN 3QkAwY/Yj90PWHMHU/cf1rmpeYixMlO9P0FoAeAnyrb+J0ndF6XEnamk1X0SYndJhm217821trbW 6wAA0+Njxm9zuExyCC2872hPPOV9f3cRWXn96LtuKjV2ApATb0xSb71xRev6+ArxfYK+A+TiUexb c19nxvEu4ZXXxy0Yv4CKPwHYO3ekhmEggIpMqvSpScstchPouQIFl8kZuAAtHReAki4ngCRGg7Je reT4s2T83ozHsixLG088HsuWHlILAAAAAJgL2oPQY+mg3e4lrFbNmMh0IvhGNvEt8qKQotkfpRUx r5FWBFVukR4XlyiySOUZ6VrGNBVecovrlgBc0ua8ZAvILabHT25xbDfXV5bKKYJS5uasjC66OKaX p/XXfp8W6BbkWX1CchHlFotFq229Kp++uLlINKZuc8j2PGIfrW5l+yibaJkdorwiJKYIRWSRSi7O rBFx+/eYVJIRY1gfrs3NclkT9ja0hRSW3CL9OTmJRfpzpX8jZMprpzAY+XTwAwAAAADMj613AAAD 8Wbs0wY6yU5Ia6ColWfl5/bLOErxAgAAAACMxYN3AAAAzqxDe5BcjYjCet9uyS9y9WplatuF4Xj2 DgAAwIHbcpEiNfenmm/YaibyBYDrpXaSxpjWtru8n8stcjIaWY9s3xrYwIRMAMPSd7KpeI2n1/rr YXkfKV6Avqwy+ZeO87Akq6V037YBpmLjHQCA4LNDWe0bxlxaPpPIda4uuZZ1eoPQAuBvouyPUN9X Yj0H9RFaWOmSzCInuJAxWX062lo7DwDw/9gelnvvIABGYAqhhXbftMRTmtDCElTJe3SNlKr0TqX0 bkY7R9zLwZPa52brv50Tt8XlaaTYAabgTsmrmbeqq+AiZOqQ9ckYAE78CMDeuSM1DANh2EkKho6S isek5AB0TG5By7EoabkOFS0lbXoCNopiWdmV1hM7yuP7ZjSRI0W78Ywty5L2R9QCAAAAAE6R1IYK X/Zcp6dcQ/P5Q7Va6eOoJiC8F7Nw+fbYC1U44YptIQsncvG7KW8FMFxw/VbYosoG20fcYj8gbnG6 dlv753W+h7Ftu55dMP3u2ltnd9IRsdjOh59yu91A/c3x7D/3vVza/oIXquj42i2fhHWCfChykfdt f5QStDh1m0PaO2bfLbamoRiM/76KVCDWAhUblYhAyCIWudgSt1i3OQ3a8LYv6nQ9m1lcva/TY9Bk StBCqhMLXGhCF7Eghj8dVZTXXvQDAAAAAAAsSjsAMACfhjqWDZva5lBtQba0ENu6WFvaeAYAAAAA sG9eSjsAAFCYG+V7SxBAf6xt3JPqS+0wf38Y3FUE3gCA8+Ryh9/ShwHAEEhza3FZKpiMJSiUJeBS bg5Q8wkAhsUabCqsq83r+/vA64j+AuyC9l4qRe4ZPCVgkRNpRWQOjoFFaQcAIr561tfGGHFZn2Cb fe2VAkELABcguwl+q907pOs7N/6xBNy1CFpIwbA1MYsfwYZlnXVqbCedBwA4TK7q9FbaCYARGErQ QuoTNSGLnJhUTsgi1b+nBKi0ZwVL363133E5wCEgPWdqY2vtGtCesz/q9D6u+wCjcRvkU+tYLYIW UnnDVCmXbPaZ94Az4k8A9u4YN2EYCuN4hBhQl6pjN87R03ToLbqw9RgcgaE3qtSpA1IvkCZFLs+P 92xDIYbk/5OshJBgU5GGxMQfoRYAAACYAuuE5yW30Xq9aRaLh995Oeh7CJmQyw7DLGRpoqkOtwjh F7vXaESYRRvVKacewi2GQbjFeOvd11+n8tv+XJfsz3FIhQy3aNs40OI/16radne543O7dZphh1BE oRWhBWrZ36ph2Wy2D72IXqpemMUUwiVq1HmrgRZDfiZCUEX0WJSZWEenQ1hBFjLkIgq2UFNdV++x 2zeX83lJs5+aw0CKVLiFfDteiIV8u7qJ1p/mmIEyUssAAAAAjBc3iGEMSkItetaNn/pxyc1UpcWr P/UcAAAAMJTnrtzXbgQAVHZ3wjbezXV6es5+fFzeqnYDAAAAJiDVH6b78XR/W6ofrmT9Y/r8rLYx GBMwrFR/vp7myntXvi/ZWOBEJSESJYM5pa5LldSdukbFdSpcm2XtBgDKh7HMOzexeOc2ct4aODZ1 /uR9j6qJQAtg9//irStfzvPe/h2mXskNTu0NgJ0LsfCCL6zQDKstqesx3vu1HgO4PqsmHggZGINz Blr0rOOjFzzlHYe9IAuvWIFUXrBF7pidO4anzmOAa1Nyb1/ue7fej8P8a0PfA25TH7jd/27W64dI /cY1FXAhx8TSryO3z9XpbYuJ+RGAvbPJaRgGwqhpxR1YVmLVHQix7xHYsOYIXIUtB+EYXIQNdAGr quA0dTNxPLaJmrg/70mj2LHjGSKsKLUzH6IWAAAAAHBq5GzQerS2SA00n99tBCZ8pMCEE7Goy21z ohar1bojZNG0NeIXTgyjSqbfCFuYXsn1EbcYB8QtTtdv7bvMva59H/P/dWo+N79bSRGLquzELTZn POGLriCGHMu0+q7X9fFjuUyH6yf7lyIW0lxMsj6ZBMcoKWhRwmcJcYljFYUoEfuYvjriLk1ja9a2 VCC2whQ7lQghYNERuZD1bfuFuGbnw9YvrV1NpzmhX1u794dPmOzjC1xoQhe+IEbrFsnwlTIAAAAA AJwvi9IBAOyJd1EOfdDlE9twapRyn03bOZu6tdgAAAAAAIbmoXQAAAAHwDzSpn1QFyrntuX6YD1/ XGbWnkoHAQBwwPR5LvEsAwCN2AcB/nqads4/r63HxfrGxs6JFQCGJzaXjQnP5VCSqS9rb0MHCzAi McFVre++fQOU4qZ0AACCKvHtT4/rtPeeUB+jHGPvTjEfJd5vbg2CFgBO0OJbaQ/tK87Zi/wfQYtQ kmxNuCImaKElxEbQAuA8WFh7Lh0EwAC8mDKCFrnPbV+8Ivf6X6WcErdI/Y2hewNwyGhrh9oxtebg yp/WXgeLGmBYZl7dT8ZnTDc/Vageslgff9wQrEPAhj8B2Dt7nIZhKABbqEPFBCMbjFwCcQOOwTW4 BQsDS2+AxFUYgbVMLIw0beL05dV/Teu4bb5PsuwmTvxSKcr/+5BaAAAAAMCp47r4eYwtNJu9m+n0 ctWWCd6tZEJOqyUW/21ZyyqsvMI0QotNuUXdvyvDkGPYMWW9DcgthqGM7AG5xXBjI7fouQaj9+c6 6f2qpYQWdW37LNv12GuJhUyWvym26K7LijE+5/NghO06hajC07HTb7VcI7RoE/k39VjEEnbcUx9z n+OVFkzkHq9t63mqtBYIK68wwhThElkIyYWtrQjjrJFlaP2zjeGq2k9vJpOUTbgzm0KKkNxCbo5P YtHZXBWi66/pc0Ofm/wAAAAAAOPgvnQAAHtg+XHod2B+6MNNV1/fB1++F7VT58diAwAAAAAYkuuq PJQOAkDwUzoAGC3nCX18LxOZSDuUWNDVN9QH8vJUOgAYPX+lAwAYEN8H8LusBwCOk9hzslAS1m2L b9nUcQGgHKHn+saE93FZ3vKGCZCFXc6TU+5nkTAKjhGS4sMh8SXasXMWXx853XcN5Kpdy6cSe4dy XyyPJwgtAPoLLWLFJ7Swv13Jr0MSCy27SEmcrZP6pibG1tvr+g0Ah8dFVV5LBwGQgZeqfJi083Vd 6+NdX6GF71icIrnYRnjR57mKrPX/wvEbjg3fOWjq8wbXOfBzVX7zhQyQjVvPdJ+cQrd1f+PoF1uH 671Znk9Ay0IA9u4ep2EYDOO4S8XMyMaHOrKwMcIRmFi5AsfhFgwcgAHuACti7cANikPrxnmb13Ga D6fJ/ydZTeskditVieLED6EWAAAAGJPQTVqu7sGW26odLRZX/wETkh8w4UIs1suy+OEWbjkPt5B1 bv1s4vw82MK0NpE+4RbdS9cu4Rb9tU24xZ57MLv/55jrW3n7ZfV5sMXuta/Van2543tZMp9CYKL/ mRdu4QdVbLfzAiwKxUwrWCJFuyl+37baSxkwMYT2trWbAAr3WaFsQipc+oMfYOGHXMj3M+/1yNuH 69exLafzeczXuLTlxnj5GkYPtChbRwZcaEEXMhCj8BP53VeWAQAAAEzTXeoOAC34jFhHGxgI3Xgd Wi/m4avQza5lD58BAAAAfbpP3QFA+DBM6I00zsT7Og/JldXVCa9gvH4YLmx5TN0JTN5L6g4ADVQd z5oc+zhWAuMXO05WZ6Kl0ARMMfsHMDza+HvVRFP+BFOvtvx03lOgWzFBq1XbcI6NQ3adugOA8LXH Nto9hqF7CqvOebQ62W6fsuNN9p99s+Wk57aBIcnGwLsMtCibqFqb1FoLtNDqqoIs5H3UBFoA4/dk y3nqTgAtywIt3o1+LKpzTt4k0EKGVoSW65aYZ6Bivp8RdcChCj3rJ19D5+Ju+deW5w77C3TFnddp 4wbaxH1tFGMYu0CEPwHYu3echoEgjOMblCItEg0dXIOG09BzA45BQR1OgMR56KnoIcRZlownM2s7 fmwe/59k+ZXY60jRQtaej1ALAAAAnDLrn6CHpjctl+9hsbjcLMti7jFsYrWzLYVbpGCKOIX/eQyy kPvS+s9mLsMwUpCFDM+Q874Itxgf4Ranfd54bsIt9jxCSN/nbQ38erH/7fKstlxNq1XaVg+20FNs 67ah31ZCkWQV5BdhFfI8O/tSoMXFRTYsYyylQjQOLTRhjPMNGWgxpanDM7zzWdUfrGSHFEQh0yFS oIXcvtmWtv8FW8zEuk6IkL+EX6+/n7fzeZtLugu7gRS5cAt5OV6IRe1yVROtj6bpweA2xTYAAAAA nJ770g0ABiAfDtUPdnmsm6+7TtZxgrPPexDLahcAAAAwhcfSDQCU6gHhj9KNwNm66vBaPfaeG5f3 xumbxvBzDwliePSJKK0qakUfiGPTt0+iXwOgecWRpjgf43PA8cgVUGtTcOpt7AYCHemw1T7ahlx0 OQ5waG5KNwBQPju8NlfAXS979yJax2nal9s+FgItgKj67f8l7B9oodd1EV2rSLZX7FoXxNZFsocK tPCuwbteax3AYar69qfSjQAG9hri/WqeNr87Jl0DLXR/bPXXVpiF1Zc39dtewEXuGSk5tz4T4Nh5 f5O2GWewvuvP6+lrxPYCY6jGJ7xgiab7XfuEV1hz6zzee3BGfgVg74x1GoahKOqkYmFigIGJoSML Czs/wc5nMfIHDEx8CTsrCxNDB0Tcxo3r2s9O6uA2OUd6suW49lOlNnXt3IupBQAAAABMBUn811x7 bOIhNtByeaskDXStlW5MLDb13dg1rjB129xCOcYXv+vQIuydsYUaVTQfc4vxwdxi2vNu5i5rblGK PO+5HqDymFhUTt32j6jaeeOa7/Z3+M9qtd/DMaXwXusatmXVGloYMf+6rteGFusIjDcGJYwlzLxT nzPnfMdiMDHWfL36dy8M/wPemlQY9wdjbqHLRWtksW1TnelFZZW1NYbJ86yJ68UiJc1lE/dK7Xlq SGH3cQ0uQkYXriHGzltkpx+oAwAAAADAvLgrnQBAJj6EayFRC8mEwu2XchjVfUArdoB7+MYEAAAA AMDh6PXgTekkACy0WaEW/vksnQjMliu1v3eeYkQhGVJI5hfSa/o8qAeHc9HEU+kkYPa8lk4AICPc owAgB5KYUo5x2KMDOG1CZwCUp7Sv63gbNzWA3pwH2lMEo3x9h4g98RseTgnOO8Kx8ZXYL0UUNiYq myo86xv7P8HQAmCDMbQIfQ5jYrm+Nlc415ShcEWvJROLIcLYobPT0hrNt54DgNPgpXQCAJnR9+r3 th77ne6W7r1uiKFFyv3aZ0oljeWbt89aQtpHYW8FpkjsecOUNbn5nH038TxyvgC5uVT+PQrprKrP BCMk9SW1+Uof7F/MnD8B2Lt/pAaBMA7DhEmRMjZaamnnCZzJXbyAp/EGuYKFpeMhPIcWKTEr2bB8 +fYPAtkI7zPDQICwCyODwGZ/hFoAAABgqrSbnafYl7bb12K1unKCJer5NmTCnV+HWFTHoQmyaEIr miCLSg27aIIw2kEZtkx3PAbCLcaXM9wih7kd57rseQWJ9C/ffYZVFachFrHg10IZt7dv6rVeX/9+ +t7tutdwsWiN3bCKY7BFWTZjsc6YcgRL5Cg3R3DHUOVdesDEucrztdCXyQ6lCKrQAi1OkiIOIRc2 CKM8hGWUSlnGzf48vVsuU6r9WJwGUoTCLdzd8YVYtHZXVFE7NLGH+qHOMwAAAABMzyZ3BYABmAd0 qZ2epjQ2t9O+hqahhtpye6EG3bIsAAAA4Jyec1cAED4OY0ItkMu9Z37KD+fsct8Q+n5Kp4MYl7km 0rEWcnor6mAnYEq6tE0DgC5inS/F3uMBmI4u7+rd4X0/fJ2jgkAPfZ8Rpa6f8rwLuDSb3BUAhE9l nrwfSW2z6NuO1qFm6nSsjKERaAHU/hJoYce++xpfsEQo0CI0rXWera3vC7fQ2lZr9ZbztOMA4PKZ d+oPuSsBDMheq42U/9d91zR5LQwFWoTCpfqETsWu19rvoOQ8bV+14wFMke9vPnT+a+eR+fxS8P4B /8+tM50SWCGX+ZanbkNbTy7HjP0IwN7Z4zQMgwHUqGLpxMiEKoZKbJ2YkbgA4kTcghPAysA5mJm5 AWIuKgl2ki+u/xoSm7bvSZ+Sxk78NVLrprL9kFoAAAAAwCEQmljRlN1XcRu70HK5+hVM2EjBhBZP bITYQsa2uGK9lnKLTnihpRab9nr1+XqrIyfILaanzD0uI1vQbR/Pfe7aRm4Rpi+K0JuwiLVfVy6m 7/sPrGM+12OqvhKlFo2swjrYhUjkRJb1E5xUblFCaLHPcold2htTaJGT3PKMv7TXnmkEFM2xXghJ hS20mBmRRSu8aI6rzjwhJRltG9Xr0yrOZ7OUNC+ruFbCr6H8QgtXHVtw4RNd2EKM3i2S6Xv2AQAA AADgeFiVTgBgBN4T6vgmisYGmYYmVsXCl0NsIioAAAAAQA7uSicAIKgHXryZ/Y+SicBRMx9wTkhY 4R26YIXvfMjDmUL0BGWp+8CX0kkAGC4mui79HAAAAExFbAyAb5Gp11wJAmQgPHEuvW5KOcB/YFE6 AQDBUFF76pjFWH3lqBdaQH74wglp1P3IjUJoAfCsphFayP0hQguXxMK1SPa3accu8+Ux9LuH8dIA +8OiiofCOQCMSf07/snsh/oou8zVx+0itLD71yHSKV+Zq892yahczxK+5wvXewY4VEJzAJXa/rz4 PvefVTxOminA+FyZbWyN1RQBRWh8bEh0YbcH0PIjAHv3j9MwDMVx3IrSgYENiRFxDwaO0pmLsPYA rL0CEgsLl+AQbEioI01T49cXP8cJTdKm348UNX9rtxJ1SZP3I9QCAAAAcxT7x+ep7aD1+tUtFtd/ yzLIwodY+MkHWPgpBFmE0IoQZCEDLsK8D8Ko9pXPXbcZgjPGRLjF8Ai3mHe7dduEW9ia56tkkfww 64vnN8+TNYMtDpf9cWV5tVv7vdm09r1RqN8IrNgV9S+Kw+AKHXwxgCmCJXy7c2/zmO2dU8BEn/Z6 HRdZjiU7FCKoQgZZpNYV+5ALGYShEyLkJ8Tt9m/3vixzuv3gmoEUqXAL+XKsEIuDl6u6GHtr2gpj pApuAAAAAJiXx6k7ABzBp5iP3cyppW4Gda75w0Dbfl23pfoGAAAAjGHpKCSC01IFWvzs5/sWAAL+ 6y6xLXXjXOzmPL0tJ7zCaoPf6odVBVowJmJKby6MgcDUcgOe9Hg3JMZBAADQhVXcWe/zMU53gJNh FZdyicfYscApSJ3HBcb2JebbCmBa++Qc33YNYtdCCKmitX1V48VyO707zrnjsr24+rx/zvXL+jF2 /bFVnNpap4tc6/CKVCFtHXYRa1+vs/odW469DwDOw8oxvmM+quvSnl39G33u93NrjMsNtPDruozD 1rbUZI3T1v1O+jF2HhW4JF2/w8vt8rNg7YDzcuPsa2Ctsl5yPmfSx8rniy13uc4WM/crAHtnjNMw DAXQRJVgZWBhpSszK70BnTgH90Fi5QysXIKZK7B0qQRxwIn7+7/jRG3cNO9JVpo4zf+tVLlt7P+Q WgAAAADA1OkyCDqeqvbQdaHl8q4WTIRoIgsvm/BSirbtiyu221Bu0Qov/qQWP8313PNDcUYbfz7F 8ZFbjBETucW4sefz+e0b34snQkFFK7HwfogyOHfn2UJssdvnY5flRb393mx6v4Yg0SaHWmYRHPf7 5ZGlFrnEEjnkElOVQkxFMHEK8VpvTbn3r3YttgjEFI3oIhBaLP5FFqEEw2/LYOv7mxjV/mXVbhaL lDRvq3ZfCIdGRwvPkYILTXShCTF23qIwfeMxAAAAAACcP1cFizzhPPiM9GmTyeVx2R9bJCbP6zPR O5YbAAAAAMCYrHMnACB4F/uILSAH18qxroJ/KXKLlIV9Vgzt2nA43P+jz7mTgFnjit7JMRDgFBm6 WJzxCwAAAMYgVmzNusf/MUJeAEPou55DKx4l+wDOiVXuBAAEQ+5nWXMSC+O4VWw2do2xC9J6ocXr EWMATAEntHACvb7FcLU5yLIgtVaoWhNaaHILbWsV1U6RaFjzpVPnTzN3GmBarKr2mDsJgAPhCgO9 FHGhRaxYvdzXxm9tDLXEUpqwomuMtmQW1jg9dL0T4zXMFeu3dMp3eN++qvZ23DQBDoq1vjw2hzVV pN1HdtEVj3seM+VXAPbuHqdhGAzjuPshdQSxsKFegZmFy3AfjsBAdyYuwgVYGXuC0CiYOG9ef6Ry 4yb5/6SoSerEBqkKDc77EGoBAACAudG+3LzEDjocPs1ud/e/bYuiN8XZq85+G2BhlzbIog2taIMs 3ICLdt0GYdRt3eCMpo+qMwa7bynF8Qm3GKNPwi3G7Xs5n9+0/vv3uNxAi/a16myHC+v3723Z9j/H Y9qARTCFPd4tim/brJTXlTg+h1KBFnPvM2tIw4THntJXjv581R866Q5uoIUTYuEmRmzEfhtusfkb qz2PTIhw+79fr81+u00Z9pPpB1KEwi1kWIUMsXDf9xXACN3g12j7uckPAAAAzMtz6QEAGdQTy2MP h4YmnIcmZocmmocmd8vzaOeVYwAAAADGsjc8bIzrUhf0lt/rCLVACTLU4twCgr5zDHkP46gDLW5K DwKL9mGaghnANUu5RqVe04aeCwAAIJWv2Jy77i7fp+VrrMEBGcWeAdHeSzkGmIrH0gMAhCH/zwoV xtTmHco22jmG9HEpBFoAjRyBFnZbzlPWCmQPLYYtX7VwC1+gRWX6RbN986q1n1H7PQCYhtvT8lZ6 EEBGryb8N3zsWhZ6xuicQAvfNX1IAJXWf+x5J98zUMazD1ia2Hfr0GfMLu+XHyaQzYPYjgVWaOta e1+7lHNobbFQvwKwd8dIDQJRGMc3yXgJG4u0Fjbew8Z7eAEvZqlXcEZbG8u0NnGUTVhYNu+xG2Gz Qv6/GSYECLsyBhDhfYRaAAAAYMr6ivy6efcmofjXen29C6jw+cEW3SAL0wmlcPPC4Irttg23aKeb OtRiP9hC9/bz+6L38QL051Qcn3CLU7RZNtyiVLuEW5Rrvy2QHxbL96e7926ZH3N4PSyWH7Go2txf 8vjcbJRF4iEUYVDFQXDFcpm0nmONFSbwl3bn3uZUAy1O/TuRs61mzXUAxcK9mm4aRBN2YbqBFqs6 yKKZZ9qQi4X36uY3e4/q/UX1nb1crVK6ua6GWxNkaEQGf5kw4EIKupACMTqbyBuPXfQHAAAAME83 pTsAjOAtcTntwU9pmWNv4tZCKrQbWVP6CAAAAORyV7oDQOBJmEaoBUoJH9CThIUAhzyEF87T2gqn UYxwOFuA46F0J3DWbKjTizAN+O/GOPZw/AIAADnECqaG4895uwOMIuV60ZDza87NMTVXpTsABD6E aX3nJH33B6YUxYzd06itNxcCLQBjvqrh0eQNtJAGO08qcK0VxtYKaseGY4pjS6/SdgAwHfb/6ZyD Yy5sANV7PZ5yzh57tkg6Tg4JtNCOz99GP+6HoVPaMbvv55O2AQD9ecC+fYO/X7B/H7zm7yYwGnfO F6u3Kt0zqwVZGOUzJlhGWz+w8ysAe3dwEyEQhXF8XDbZgwdjonftwAqM9diEN0uwg7UEK/DqxasV bCxClwXk8XgzwGZgZPn/EqMMMDMXhYXxfYRaAAAA4JRYH3Yeu07abt/cZnP5ty3DLGQB+qowexFE IcMr6rCK/HszxKIZZlEEWtSBGHWf1Rg/jTn4pCyOn2JMwi3GHnN5YQuEW0yvHrv5jKoddNF+vlUd Io+tAzCaqmOqUIuv3a57crKjMqTiTIdZNCfS/jlS6ECqYIkU4RJzDYU4pYAJa6wxxrNW5R9CJ8pA i5Vok4EUOjEiU+1VuEVWzn0l+xBjye3rLHO363Wfad+7diBFKNxCh1XoEAu53/dgv+uFgNa3aAYA AACAeXpIPQEgAlno1FeQwhntocXafffpfvVx+hzrWAAAAGBqFPDGf/NhtFlFgIApnLvwP8/pttD7 81CBQT2G1a91Pu/r48mvhxepJ4FFe1Xb+fPC7xQTAWaCayAAAOjDt2bAen//OdWkgASOeXYFzMFd 6gkAii+kNrSOMVRY1urDOsZaj6j3hcaNgUALoAi0eHbFOmbf7/GQAtm+othWkWxd2HpIiMXUgRas mQbm6Wb/9ZR6EkAk764oMJ8bcu8dugbqAvYxAy2sa7ocx3ffcOy12tcGLJ11X6vbQ38vXkadHRDX leteM+vbFwq46Bt+YfXPOwwc/ArA3tkjRQhDATi7FLZ2lo6zjYW9jTOeY89m4x08gRewdVt7K+ud UbIQeYT8gZEIft/MG9mEJbHAIPDeh9QCAAAAAJZKzBqo2ddxFzvQbndzkkxIpNiikVB8tqEGYcQW UmZxPKpBmxFbmGM1cgxT4H5asfkSxfGXKXuY/jx1mb/v1DH/n2wBuUXJsfu53LbQwhZYmO2h2KIf BvN3/e3d9+6ZNY4QU2y6zqbfIbHojaubt9u+HGMkJcQSZty1j5lzvDUIJkLjzcVWnE/2mS5tEEZS cRJYCKFF1YosvvtUJ7nYiJ9GnCEFF2f154uqSpnmVR23ynJoRELuYwsuXKILlxDDTFVZ2z4RBgAA AAAArJf70hMAyMBroM+XyBlKHssR9vFS5gQAAAAAMAe62M9l6UkACF7UsOCP/j8JqQWU4trTnpoo NzUJL7QPz+7zc66QPEFZDqovdeIeIayFULL5lO8CAAAA/JRQwefnmecC4EPfj5pyPTzmO7F7W6nX 8ly3Q2mQWsBf4hDpj93zixXMDe2jHJ9j7yqGxh4LQguATmihn2vHCkOnnO92YeqUQtmy6HWocLZL eJEissgltACAZfJYegIAmdDX7Q/tdmjNjq3XMnwiqhS5RYrQwrc++9pCuUwpazXrNYCfWE6gq83E Ux0fvzc1gKy4cgvs91qVGtakCtWrGiuvcNW5GvNMA1bKlwDsnT1uwjAUgF2BhNSl6tipHKRSr9BD 9D5VD8HcpeoxegZ2hm5dGCgRvPAw9nPi0Px+n2RhwGAHKTjxz/uQWgAAAADAWAjdyLymPrRafbnF 4r58rgO962DzEoj9IKIQScXuKKlwpbSiEFhst1pkcZJZSNlDef2d5/Uht/jPevPHa4d5vLl1Tl22 0Hbd0/q9RV6x2/mCirKEElycyuiyl8KL+HjZerMJNSLetoDAQqebwGtNZBbnx9YuXcglhiq0GLNg oq36yjNTzmkvlRaIo+hCZBS+MWLmvS5yCy25kO8QuYXUKQOhD7OZW87nVZr95C6FFJbcwpdV+BIL /3CrTABca4MCAAAAAAAMCzZ4wljI3RxqLdS2ylXZoBVbtGqNlrIQHAAAAADagADe0De+vedyb/Tr LmUXAG1wa7xnzamHNtTpz6RkF3XrhGYU/eFd142ASfOh8owLwlSoK22iDwQAAIBcrHl/nV87AkrB MMi9Nq4b7IlrcOg7S8eYHvQLPY+VkkdIPkdIkQqSadWfalMORX/x5hBawLTRQosQoXPbCpDdRGgR y8dkF1aA7ZDYIrVeOvTo/w4AMDxe9um560YAXIHimv39mK+zl8fqA0N9dKrPtmRUKaFFVZlFrL/2 j8c6bgAIE/uP0PlQ+tmnz5baCNCUx8T7qfhVsXL+YyzOVZX5iSrrbWGE/AnA3t3jNAwEYRjeyKKn oKAEpaWn4wx0HAOJk9BQcxhOwBU4BBUoeHGWTCazP443NonfR7LkP7ybSLGF7Z2PUAsAAAAco9wA RO+hne5yB1oub35DJiQZNtGFUKzWk9uZfFBFCLDYBFl067twC7e1LhyrC8cIxezrFZafW7jFgL92 hFuUtDmvsIXp257r970wAitkkEVunLg9li6c27/aE/C3PtHvHMIILLCWdYBFLPSihykCLY45XKJP ezUDLcY0dnjGWO3pthabDTt3uENYxV86xDqsQgZaNCrIIuzfiO36mGH5rN122TQl3b5up1unMjQy k9xHB1xYQRdWIMbWVyTmUw8PAAAAAJwWQi1wCnKBFkFqcKhenwqq6Ltu34GjAAAAwKHcT90BQPDF Pt7Esv6/6WPEvgBBbnCeVBpy0WcAHkUFD+/cEfKEaflAp9L7mgAAAAD2o98RkPNy+X2c7gBV1Lw/ lLs/xb0o/EdXU3cAUPqEs5e8vyi3pQrGxwrRxgrY6vaH8NeH13Z6rHQ84Bj5Z9hPrizQwlqXKpA9 NNBCh1nEimOHfayC3CuXL5JtfU6KZAOnwz9Pf566E0AF/r00H2jxmdgnVqg+tj52jbSu3VZ4hb4u 7xtokbpOx8Y35T47gLTc7yj2W3w5fNeAKi7EvBVUYSkNq7AK++VCMmL7YoZ+BGDvfnISBqI4jpdA wtLEmLjTeA433ERWrr2FJ+kV3HsA1+71DK6MQcZ2YHi8eUNh2hH4fhJCmRbeaCKN/fN+hFoAAADg FGj/1Dym3lTXL9V0erl6HYZZhI3lwzEXSNGEVCzakIp1aIULtQgfPujCP9ZBGJu1mhqLVa0cziXc 4vCa1vUlfdfeD+EWw9Uu5Vx+302/+abJ/Wa4xfZXum+Ev9EQ32jE79aFORbf7os38plhQ30xuWiN URBg4ZfVzzGUCJbwdU+9Zs56pxow4esNXUuLoJHpDn/P7fY+sEImRozFuA+3WIVc+PXt2EiZw/V4 XN1NJrtM/77aDqSwwi1kWIUMsZA/bupAvnZiQNLGOegPAAAAHLdZ6QkAGYTN32JNKSpjmy7BFNqN obFtdqkLAAAADG2+fFyUngQQeEusjzUCAfp0pYxpN8hZ5+G196Zu1rNqaPPA/lzAE/tDlFQHyxwn xH9zW6gu+zwAADAE7bz9a6G5AH2wGkbl+GxtGRjSrPQEAOG94/axBpjyekKtUbx1DWOqXq5jkD7Q 4iHT5wHHyAVaPC8fX5H12t/dLtcmy0AJK8gibIj9ExmLNcoOt5O1Us265XdQ7OfVXgM4Lk9VufNF QE7uvPxHu2w1o7eeY/vGVPiEFV6hBVxYgRYL5fmQ/XRsDEA3qXsY/ZgL1v7sfzrAwW6UsVQLL22b 1HZWYAbXDkH1KwB7Z4zTMAwFUIsMSKgDCwNbRVcGJkauwcpN4DBcAlY4BDMzO1KXkjRx4zjfjkPS fDV5T/qqm1j2b6U2Sev8h9QCAAAAAE6NWDFfu+8xj4eugTab272kQqIosF5KKHZVmFZYaYX7WNRN r5+bxjYbpRzDFq4/bhF55BbJIyjOfTrzLkW2oD1vPf+c329XGlFGLbcwh+d1X/lecbkmf5l88T27 Wl3u27/bbSSLUIq19KIhsPD3GdOSW3ShIZbQmFdD3DHWfHMWTEw9X1RAU3dq/cJtZRUHO0QlqnCF FpkrsjBt2cWZMKZtn+d9r7Ms5SXc5HFvPIdGR7h9fMGFJLqQhBiNt8hpdxXdAAAAAACAeXCnnQDA CHxH9oVEEl0L0mOLu/1F4CljpOQEAAAAADAFT9oJAHi8OW3p+uhL2AZwbHypRer/5ZKUwt8Xu5Gv z1wwjBftBGDRfObxo50EQISLCeboUwyXYyMAAAAMIVRUyv2vHqkqzIWU8+yU7bFzcM7PQZu1dgIA HtLaRWm9YGiNYKxvSnFav19ozDFAaAGgJ7QIySpiEouUQtnutp3QRmgBsEzWeTxrJwEwAu95fFTt IUIL6ZjdJbQIySukY/fUQgvuYQIYRp/rePdz+zpVggADuTJhsURIXmEf/xspY8PC+ROAvbPHTRgG A6gJSEiMlaqOpWOnXqBSr9Kl9+klmLv1Ku3YvWOllg0wibFjPv9AQ0LIe5IVO47jDwYMxvFDagEA AAAAfUf6YfOSarRYvKvp9GqbdzdwL/N2jsLUlSKKVU1OYcQWWlqhJRZuqosuVo4Iw0oxbJ+rXV+n ArlFVmv1n/ndIYkXLlu2cD792v4v9f22H99WbmHOa8GFlV3UWnmyi9IjMaolc6/ZrJRa/CyXmSHJ c2VuDEZesZNYFEW2zMK/V1v0WS5xSH9NCi3apG3BRFv9hfqSZsh9u8P2WLUtBFGFNkb4couJI7Zw RRdFVR4p+16bCdGb8VjdTSY5L+dR7QspYnIL383hSywkz4YK5HMm/EPn+QMAAAAAAKC/PHQdAEAD fCTqYw+Eph7ojF2XWgQuxRCbCWVhOAAAAACcmvkmPXUdBICD3tA7JirUfLcRCIDAfXXM2cQvR2Yh 3SvUzr9HKI6c//hhn+dNuu06CBgsf5v05pSZE4RzRxqTUtdLeamc2y52LQAAAMAx+BvMfnUUB0BT 8B0ZhsS86wAAHPRc32+gLrVO0N9oILUppn+UNiqQ1jeG6g8FoQWAUp/qOKFFKoWEFqYcE1dIEgt/ 42xfbpGzSTZCC4Bh89p1AAANoMftRZXPeb4n9ZyQNHZLgoscWUVKcJEas3OeZWKcBjgtsc8VqV6X kVpAX7gOnE+tfXXzUl3O2thD18/CgFgLwN7dIyUMhGEcfwGZcbyBjYW01tbcwM7ao3gFj6Ol4w28 gJaWXEDNEpe8bPYrBpOw/n8zO+Rjk3ehAIVkH0ItAAAAcExik/jafbeScaP3anW1DanQdLBFHTzx 9dOk1XRoRRNeobfL3jZ7rjocQ3aPpg2JcIuso4Vwi9yapYYtTKtuU7+E17t+q/aFWNjles75Zr2u PWsHS7SOdWuILJen2+WPzabDEGfNow6r8K3rY9zWOu3wwRK2buk1D1mv1IAJW2+KtXY9zeuhtulE CLtsgyp0oMXJfL4XbjHX/aUJsNDntOvLqv/5YpEzzMuqXct+rkYo0MLto0uHwi9mnm16qO7LlZo0 AwAAAMBxW489AOAAzOSnoRtDNd9NYr4+sYu7Uy3nHO5YAAAAgCHdjT0AwPGU0ceEWuT83wcc2pnk B0uE9uk+uTfx+Y7zjYPf73/vfuwB4F97lDrUyQh9T8j3hygBoUsAAGBKYpNJGc9DDQQYAX+TozTJ e/qBAb2r5dj1iCmxsIqcSWljNfqMyyLQAhB5kb8NtPBNXh0Ko3ADLdwQi9gk2l0CLdzn4HueTJQN lGddtZuxBwH0ZMLnHjL6dQ208H1ehj5nYwFUqQCLT6cWgRbANIV+dwi9p7xV7XWQkQH9XET2udez xuakcvdJYH+sT2ocuf1RgG8B2Lt7nIZhMIzjDqlUiY2JEXEDdi7Dwn3YkQoDOzOH4BBwAKaKNdRt 0rhv/dpOceN+/H9SlDQftlMpSjGJH0ItAAAAcMx8f7g8xg6azd7NdHq1XHaDLFZT411nAylWIRVN G1LRh1bYEAt32gy6aJwgDLfMro5mHaIxJsItko42/+n7LRV+QLjF6dbb13/s3/dmsEU/9n21EXax PSh+Zbb7vbT1q3ldT5fzn/lcKTOhtZ4gi0qEV8jP3jJGViJEo0RIQ676Tj1gYqz6UuuKXd3rYIq2 rAsnxGIdZrFYN+lCLtp9uhSJulvujms/V6b/7rtO0eu6NreTScrp3ZvtQIpQuIXM5pAhFvJ0Q/8c 0Dr9pdBAHQAAAACOx13pBgAZfCvrUwaEGxpMkbpfSnt4IBwAAAAlPJRuACB8OsvaoDrWl2cbsG/a y3lDQixiL/HJcrQQC1k3dvewmG5KNwJnyw6e8RHZh35DAAAAYD9CAzrbSXv2ADgkOfuGfAGsu5RP fxXGxPOOODRDfz9ozx/KZd82Oc81gG2sP9IOkvFiCLTAebOBFs8mfh3FrlFtYOzYoNi+kAsZZkGg BYBcXks3AMjgaTH9tsuh59HkOu3eLe+V2n1V3n9D9+Zd79Whd5t889A5A8gr5X3DtzJNAwa5dJZD z7K6tLGr5DZfmaFgDBPYF2fmTwD27h+nYRgOw7Az9AhMLEhMdIUD9BLcgyNwJCQOwA1YYWRGTD0A Imnq5Ifjv8GpG/w+UtTEcWMrghJSxx+hFgAAAFgL3wOBet+96hOmvbbbW2eIhJ60vQux6Bc1WWRo xRheIcvVrzJ9rD4cQw1BFubk8LWEEdQUblEy/KCWn6e+3TLnmXCLHMwQC3PdnCB/vNc1LZ8+P940 m8Pr534fN9G+DKlw7T8ujVjktuuYp1RDmznbW3Pf/0tbwzu73yNRJhMh9PohoEKEVegQC50kodeH +moMsJDH1Nubtv5lXKjFdbvciUP6Ai3MOrJpV/hFYymTXTVPV+gLAAAAAADrtSvdASCDd7HuG3ht G7Btqxsa6G2WxRwjpk8AAADA0naKSbxxXl7b5cuzX/6P9bZ8d4CJC8++mDGmrveEwi5S20Sax9Id QNW6QIuYyTO4Z4g1CoU9xdYFAAA4Bdt39R8F+gHkFHNvaW54BdfwOBdXpTsAGFJCLULjCOW6bV/s 2MdQWym6QIsXRaAF6jYn0EK/xgZazAmz+PaUxU6SLbfnTphtngcA6/agGFuG9XtS4zNGKdfOtmty 199sczslzCJm/18CLULPMAHIy/c5Yyt/XrAvQC43x1fb/FNy2xVeYdbz1Xe1MZ3cD9X7EYC9s0lq GAQDKNZFZ1zp6AG8gd7Aq3TpMTxJr9C9a2/gBXTtuOs+FhMSQuEDyV+x780woQkFMtMOSSDfQ2oB AAAAAKXiu7F5jn1pu92p9frmN28HZa+DtFeW1KLbVwsqumTEFlpaoSUWduqLLipLhNEFgjftmmD0 yC1KaTM/jhVyi7naRW4xb7t55+0XVqSIXC964ouq8kskrJZUHU9eqe/9PtSZozpigflbsUXz/V7e 2oYkF1NzDm2WKrSY+zdx6m3Fnoy3Yoqmbldgobf6H26sEZdNmfazyVsCDCPHMP01D0ZvVyt1nya2 eFLHQgpJbuG6OVyJhXu6krAiZeIgtJ8JAQAAAACAsnhcugMAI/AZOS4tBg0t5k4pF1sYHqrjr/0E AAAAABiLzdIdAHB4s/Kxl2kl+QXAVNwllIm9PBeaf099kS9UJ+SxUQThgOXQY9lOOI7QAkplyLjE mAYAAABzI83nx9YeAJwiQ58fERQKSoP1jnBqfCWWSxVSSEFqUwPZ+urOwQgtHgbUAVA6r2p8oUUo GLYktJDykswiRW7hBuyWgmITKBvgf3N9SC9LdwJgIFpmYebkY9feoW2KSEIay90xOrTPJ7Dw1R+7 F/Bdf/jOGQCmw71mtvNu+jik99l6BpDHlcpb12qOhZJbx9D4VnBm/AjA3v3jNAyDcRh2WyRGdgYk 1q4MbJyBjWtwBK7AzsrOGdjZGRESa1cmGmIqt1+++l9aiGvyPpJVNzWOW0BpU8c/Qi0AAABQg9TF hdZNW65SHc3nFz8hE9ImZMKsgyxscWEULpjChVlsh1fI7aazbblcFdefDM5IGUsYAeEWwxjL39Nq v2Ve50MItyiz312edzeEdbMefje4Qtb1z9rHbLCF7xDhFqxvmtVpj4/FoufwJt0AAlVf37oyna7r JcMsSoRL1BoK8d8DJoba36/+Tjadbp3ttv/JRzacwgVUyKLCLmR9otrqPt3947b96WyWM8zztlyK LmOBFrqN3HUo/GLi2SaHql+uUBAGAAAAgHrZSecs4IbafbblPaNdaIKobrPrRaGpSaehsQAAAABD sZ8Br0sPAhDs57mXjHbuMxSLCqKEM3Vff1fum2gU+149FmyRc/Gery/0c1d6ABi1J1HnHCFqFrtw PdZmn/4BAAD+gv4+/63QOICh8Z4bNSPUAofm1bPNN5/Q1yb0mK8vX/uces4+fAi0AIx5aMujic85 Dt365h7HwixSi2L7wiu+THrR7MZsL56tF8jWARd63EZtC70OAOp325aT0oMA9mDnot1ntAsdu2PX EOUEUfUJp0q9F8gNtJDPieM0cDhi5wVs/XnY4QC96XmzUmxObGhurW9ubCoYI7QPjNi3AOzdSU7D MBiGYaepVIkdK7a9B5dhxzE4CEvUK3ABLsIB2LBhW+omTmzn95AOGd9Hikia4XcqSmjr+CPUAgAA AHMkvZF5Te10OHyq3e7xPG8PwN4GWShvakMppNAKvWxPbtDF0QrCcI9b1Tx22hGyljACwi2GsZbf p6ru+sItxnquq9p9z7sbXOHOp7dxj+UHShTNc5EMtTDhFG1hZ11hB1hY2xeFW7PYbM7T0MYK0Zhr vaUGTJh6c6oVGknCTnPQP8u6VhNqYQVZ6MQIkxpR1uuaZTNv7Vea45tj1rWfylLtt9ucZj+rbiBF LNzCPh0/4EI63VhgRWjADF/OTcoAAAAApokbPLEEfQc1TXU8D62TbgxNdQyX6oaWAQAAgHvTgRbc eIwp+Yqskwbm+b5fU4Cghwv3iwVShIItpP1xWy+KkF+MRwfz9rn28fkhlozrHAAAmKrfsRsA3Bj/ e2OJ6POIKfm5cL/cfoi5A+arwOO5A93632EQaAFUgRb6M/1Un+DU61MKjfAHrpYGyvYDK/zwitAA 2dJ2Ui2pXaG/H7H+0XyXASzH/jS9jd0I4Ervp+mvns+9bqVCI6TrZW6YhXTdToVbEGgBzFfOewcz fQzSIuA6qb6zsZCK2OOp8a1ifW+VsIwV+ReAvTvGaRiGwjjuUomZHVVIsMAF2JA4BiNH4Qhcgktw BySYYGBi68paiZKSvObVtZ/Tljht8v9JVt3EJBYdWjm2P0ItAAAAsO+szXrl3F1RblIXmkwu/kIm tDpkwnlBFmUYhQRTlKUOsJjN5stwi1DgRRlqUZbymrLZ/Pab3Q8ljIBwizy6CXsg3CLfvfc73KLe 6D8c0rp+LjyW5YdK+Peez8thj8/p1Lu2Ww+v0MdCIRfq2ErIhWyMvwi0GEi4xKEGWvQ5YCL3/dq6 1/Kqi8+qqh5Vn5skQkj6w0pRIRdyTOp+e7nPyHt/XLQ/HY+bdPO8KNfqklaghd9G3zoWfjEKHNNd 9f9d1kMFAAAAAIfntusOAP/gQ9WtidmxhZz++dTi0B8XH6iPLTINtQn1EQAAAGjTfdcdADx6Y+/U wlqpv7fXHSDqqnq1no9b4RV+G2e8hupNFuVZE59Qe+i6Axi0J1WPjRla45dAbpctXJPvKAAAsC9i v7lfs/YCyIvf4+iLs647AChfqm7NSbTaNP37tjeVl+cMJ45AC2DXQAt/0+vQe71p9S6BFbG2VmBG bKNs59bnSKfmXQPoj8euOwDs6LkoL1U9tdZHXmPrfWLf4ZsEWTQJrSDQAuif1LpG8VaU7yw9Aran x2FTc2Nd4FxsHqw1z3XT5xjMmx2YXwHYu4OchIEojONPYGXC2sQVR/AEyg28gjvv4x24gAvP4la3 Jq5IXCFSSunr9M10CrRT5P9LGmin7QwkMlDwfYRaAAAA4NxYH1Semw5aLN5kOr3d3q8WPK+GTdTD LdaV0Ip8vQyyyMIt8rbyNg+0kH0whj5v3ue6No42CLcYap+H17q6tNAFwi367HvY4Rb6GlRZJL/6 P+VlwIWobWJsKwIuym1F/9/LpR1iEcsNttDnyvocjeqhFx0753CJNv2dMtCiT30HTPTVXxd9+SpG bIMqnGAKkTLAQgdZZIkRRWrEeNe2Xy/uq+OKcIwr52/2ZjyW2WQSM+x7qQdShMItdDiFG3Dhhln4 Qiqs/a2nUALbueAPAAAADN9d6gEAJ3BoQVNfaEXsfr4fhjedIzQeAAAAoCuzzfKQehCA8inVQj9a qND3V2cjAvyuJS5YIqZNt4dCL9x2KzTDOgZ+T0LBO6TzLtVwXot1ffCjg7EAbaSYY5jXAABA32K+ zweGqM/rQrxPx1DMUw8AcPi+6wqxfoeo23z7WIUxm37b6PZr3dcItMCl+9ksL3J8oEWxHlMMe7Vr iwm0WAX2a1tA23oN+W14jNbzAOB/mG+Wx9SDAI6QvS9fBNqb5jY9F7q3oTnVmpetuT40x7tzc1Og hTVu3+MFMBzW54bXdMMBTsYKqvDVrvLt755LH2edw23HBfkTgL37x2kYhuI47qriECwI1IWBAzBw ETaO0olLcAjugFgRV+gpQOpEQuP25TXPdtLU+dPvR7JkucF+6kCUNPGPUAsAAACMWWiTXv/Zc9Ge YhOtVg//IRPSIWRCB1m4KsBCtl1oRb0dwi183wde+ECM3Zx+Y/l+N7Yn3GKsaxJukb4u4Rb51h5n uIUPoJDBFfW+q40fb6Yfvh8m/+//brfBOo/mrkIqGsdFPQsZcpExWCC3KYdCzDVgwq83t7X2YRPl d6nGfCKET3+oNRFy4cdkXzYn56jWKdtV0b9eLlPKvC3ao5gyFGihj5EBFlb4xaJhTJbuVN8KwgAA AAAwPYRaYA5iL4ZaL342HSePD4VYpI7FXg4FAAAAcnkZugBA+Uw8Tr9MvOm/FCDqxhi3win0Z7rp v7FeurPmDo3Dth66AFy0d9GP3S+U576fs1UEnE+XcxTnOwAAMISm3+43uYsAenJKACswJXdDFwAo bUItQvcBrecbrU3zu6wRUz5P/O0ItMDlKgMtXov25foPtLCCJUIbW8sNsHVoRWxT7NDm27FNslM3 /QYwL+uhCwBO9Cb6bc7jXZo8/1rBF6mBU23CLFKuDThPA+Ogr+uta/6PPOUAnd07+7lW1zAW+y0i FGwRCrcA9v4EYO/+kRoEojiOb2IytFpYO+MxbPQoaXK0eARbCy9hqbVWNikxQBaWze5jV4Ib4PuZ YcI/eZsigwHyfoRaAAAAYExcX2i2XX+0272oLLsp583G6jrIQjdcr8InlBFukdehFVXIRRNa0YRZ 6O3NvA7CKPZtAjN0zfxkHH3NJYyAcIvhEW4x7bpV7bThFi7tEIulZ/3pb8i7G+wvyprrdVYu/ez3 ruLtV992Y17XXSyXdfCFudwKuTiz/w5MSFnzXMeZYuhDinpD12pdvTZCJsw0BzPVQQdYmEEWRWKE To24Om6rkyas/ctt+rOr6x+Xi1CL+9UqZNgP6jSQQgq3MN+OHXDhertSYIXUXMMk3XwAAAAAcHmu D9Nd6kEAPX2ruMZu0gPoyjMvPfztO46vrm8ZAAAAGNom9QAAy5sx7/qO5Fv3MchoANmtsM2+Jx7y 4zrXPXllrZNwHz7ek+JaKNIpgpzeO/aJbU4HTEXIOU0618YcBwAAIMRn6gEAAv7vBWi2j8vzFbhf SLhETIN5aT9fbUkRaPGquI6O+dKBFkVQje8+dcxn0tWgWmp8bTfAtoMs/hpo4aof2iTbfFWeZQDT sDlMj6kHAfTwrJqwuZhn0LqmkHOsfV6ODbLIHccMPVdzngbGx/4ME2qBsZJ6T4X2qzpnXyvMyK8A 7N0xTsMwFMbxdGCrhIQ4QMXEyMSGxDE4Tm/EzCUYGJgRp0DqQtzEtWP5PTtpkzjN/ydZWK6bBITS No3fR6gFAAAASqV9iLGPvdXtJbWh3e7xGDLhcyETLsiiCbOo2gALv3UDLJrmwi3MfBt84cbc9vzg jLGsKYyAcIvxzfn/NIe1/Z2bfZcQJKKtAY9d12qaHHbha+aZc/B2e3cc+Tsc8g4yVrxfCbQw/U6Q xYiBFlNbcoDGtQdMTLW/ufa1cYPds4ANsahc+kOneSEXdszvn8bs89vH/DPOTT1mgi0yPNTtOdis FGgRzvEDLKTwi01kzF7L1YprhH0AAAAAy/E09wEAFyAVg9NuRk/dlB7OSS3iim0/Naeq5P0BAAAA l/ZaUYAEZfms5IDC8HOT/Wn732MdFKC4z5iTu6BOW5wXm6/N4Xv6fPu5DwCr9u71cwpLcN0QSzH0 dYiF5wAAoGS8B8eSSQGr524LKAn3PKI0v5Gx8L7B2DXBVOF4f55UzFbaR98iAzbQ4rbHc4BrYgMt TMBdqhC2VFA6LEwd9nMDLbS+FHiRCrhIFciWzkcUygbWYz/3AQBnMOuJPtp+zhoi7XVOazlBFUNb at/S+4/Y7wmgHDmf03/q9jXJ0QDDaGsPtHtZtQJ/sZ9998H3Fyv2LwB7Z4/TMAwGUPdnaQc2xMbA PRAcpQO3Yu4VGBgRh+AOMCN1Kk0c1477+SclrdPmPSmKXZt8TqQoabG/h9QCAAAAAC4F6YvLS+qP 1us3tVze1mU3f7sVWeiylk+oRkSht0pMYWQVum6lFa7gwhVZtGUY9rg65vZgHH2D3GLIMbvOO+kr 7vGUucZlZAs69nius41d4npPmvNt/8ZlE+dPGi9EWyRh2uzefm7lFq74QrNY3NT7382mwxAnB3uT cH8vsRD617ILU+9RBDAWocUQj5UT69zxrjWW9Mu1b3dwrQ5GSOGKLCpjhLFGzJq2fb0qN9u0iTf1 Ypn79m42Uw/zec7QH9WhkCImt3BPxxdcSKcbE1ZI9h+JWKINAAAAAAAYFizwhGvAXRSaEkj4bcdO SM+ZKC6Ng4niAAAAAFCKVekBAHh8OuWcxCD+otzvE40LIMS9V29PJEoLKVKL60L/n4/1jcWGNs+7 7an0IGC0vO+2n0QfKfmV+zkAaHjmAQAAwCk5fhEewHno832Yd2u4ZJjzCEPiK9GeerdIJceP9VFC PdYWAqEFjJ1qDrIRWkhI91fonpUSX2+9fRehhSSwkMQVpt2PsfXi5ybJdvf+dQCA62Ol4smKAYZM JaZ6zeiXerfu8swOPcdDcipJNPVf+RTPZYDLxr+/PwqOBSDFMqNPKFeVCpRDc2b9Y/rHZ94s1PwJ wN65IzUMAwF0PR6GGSpautBxA65BxXnoaLkJJ+EOnIAqB8CKI3stVrLiGFuJ35vRxJEUS0ljRZ99 SC0AAAAAoERSQXl92atkHGzb7Z4OYgmPDh7vr31Qd1evFVjoNBRYtEmUyEI68UUrtdBJuvvqPizB mnKL5dtEbvHfILe47nbbtpf+vft5LNfsX4mFfe3f62D7/rqTTlTDubK6vj28/uz3E7uqhBU6yL9v y0ozsbQwYY0252zv2gUTS7VXSltVX2k48+0lFtLbHwZJSS58XiezOJZX+vPHfD1rftPkPdR1zld4 bNKzaj4ltAjraIFFTH5RGXnaxRH+XKnFBQAAAAAAKB8OeMI1EDtI5hmbIM85XBbWC+uP3Utk6iQ9 AAAAAMD53DfpZe1OACjcgeKvjHpWoAyf9z1nhwAyuJO8A3ohlqzCKhOx19tPXYNnzd7mbe0OwGZx z7xP9T4VBIoAUXDJLBlcl2cdAAAAzA1jb9gyjK/h0nBrXgTeh5LQMtvYmCI1B6jzrH2OqSDzU/Yn hnUQWsDWcUKLd8kTWlh5KaFFKLdIBcCOCS1isgurHKEFAEzBja8/1u4EwBm4tXg/Jk+NtcO8U1JM SBETV6TEVWPPZatcjNec7wkAZWD9jw/LkVpAyYR7ZlPSipDUflhrz2y4x5b1CzD5FYC9s8dpGAYD 6EfSqXtXkLgGAxyHkUv1CkgsLOxIbIwcAIkJtqo0TVI7ru18CSlJ6vckKz924ySq47RxvofUAgAA AACmhvZlwPu2Da3Xj7JcrvbzTZnFtkrlulI+UQsoylQIKmpZRblsRBa24MLILbYNGYYRZth1piG3 GEtGgNzi9KT0fSrrTuc8m7rHON+F2OKiOmZXVhETs+rEsFm22E+/OkotfOKMasHUUEks9oH5s6yR /1f+W2YxRp1D1jfnfacua51n2bU72FaHzBJVHOQVYqwRuTSFFrXIIhcjt8icuuo2vMpzuV4sNIdy I8dCipjcwj4cV3DhO9zYRU/7EGCIYBsAAAAAAHB6kFrAOfDesbxvgHfbi6GhF7ncMuLJc9f1/6Me AAAAAKAfhdCCQCQwJV4iebHfZPa6j4H3CUDDlfgHFtnE5BVuGYlMffMaCYYmPzXudul27J2AZHna pZ9qXhNgok8gOoA5EOrHhu6r6PsAAABgKAgiBWOiHQfD/S+kCOMdYWp8thc5EAqE7yvXFmw+FnA+ tm2boj09C8+RIV1qocV3IN/3P32oHYeCUXcJcL2RY8nFxskLCS3cFAuMrbnG+M4DAJwnD8K9AMyX VymfxxfE3uHR9N92vq9f1cgrQgKq2Oe3nmlbH01fDXAe2O39bcwdAWjhsmP50Ngg7ZhZkX7jiXhe khC/ArB39joNw0AAdsjAysDCVjGxsbEh8QasjDwK78FrIbEixNyVERLydzHns9PSmDTfJ7lK3Ut8 zVCrju0PqQUAAAAALAX55+ahKrexEzabK1UiMQgnvvpSxzUCC1nGAoumOCGycL34opFayDKILPz9 4ZcnX9i1TeQWiWc75BYpbSK3mLftOe53K4coxuNeteBCjxmPh+nSC20crPx5/dhu07Iqij4neewF jYQWzo/fUwyA0CLftVLayi1+WFNbfVQroOjqCk9S8cscISQXJ63ooquXQov+/DZe/qqcVnUXZZmS 5mVVbkTzltDCj5ECi5D8olDqpIvDv10hEQYAAAAAAPx/rnMnALAn7xPjY4s55XHKwtDYhPaUxaMA AAAAAIfmMXcCAB5SamEtKtbqu/Ly10kBJHCu1MUEFxbWIj1LbqFdm2f1YZ5yJwCr5dMNm2hohMYm ZR3jh3BsHKKvov8DAAAAAABYD3e5EwDweJ0YnyKxkHGWCCM2P9Hi3iG0gHWzq9AiVkJCi+69JqPQ JBa+5MKSYVgbb1tiC+17skk2wLo4c43UAmCJ1M/inxPiQn2c/NzqL2Nii1i/bPXXoXa1vOmrAZZN bG3hm5u+PhJgbqw5rdrnWoysi82Z1a4b2/gvNLcWjoxvAdg7e5yGYSgAWzRTd8SakUMg0ZOwcLaO XTkA4iIwos6sJSG18nj42W5I4jb9PsmK81M/p1Lk1Hb9IbUAAAAAgHMi9sNH8pwqaLt9cev17U9e LgzvF2nvxRa9wMKnVlDhZRXdfi+ykIKLXm5x+CXDkGXrmJLLky8MjVlOblEiJnKLqWOWlVuUirs0 uYUWWXSSCr/fbb3copdX6M/mxum6Pt73e+siW1yht/qYvFaLLgYwtzChRMwx4y1dMDFXvHOLZfWU S5uDtDp4IYUUWbTGiKrd+nPH49ImIeUWNyqWf8bvVitXV1XOrT24v0KKmNxC3o4WXIRuNyas0B39 1hec+54NAAAAAABl2JSuAMAIyEmbMWFEaIK3dW5I0uWF9mOdnkwmBwAAAICpqJv0WLoSAIIPZ/8B z1qsJ5Q+p6ogQISQ1KIlNnaeO94+5rg89Gwc7SCUY9ukr2M+tkiGzKf6HgHm5n6EMnLaqpx27j8i KQAAAAAAAFgGdekKAChCY16x+YmnXJuzuK2+LlV+y1OTdg6hBVwvb25+oUVMXKHzIZmFJbgIyStS C2WzSDYAeFqhBe8DcKmkxuKtY6m2PCaLsuQWloDqoD5nvTdY/32irQZYJtaz/Dp3RQBOIDVvNnXc ElGE5sbm5OHK+RaAvTtIahCGwjhO2/EIrlzI2K1rb+I9vIHew/E0egF3XsCFM0637qogpDzT95KU QVLo/zeTaUta8uqigEA+Qi0AAAAwBfKg57ZImOBrvb7+DZjwdYET322gRTNhuwukcAEW9XIZYNG0 /XAL+f6udetPmQuecIv/HDNPGADhFmOMmS8shXCLoXQ/7TK4wg+xaMIt/Inw5bJwcOt22/zr432z SShJCatwNSlN1rRYLvV1JBo7zCLHmEOON9eACTceY4nPdSv4O2uECKlw6Q+7UIu6T4ZYtEEXMvzC BVrsPt8ul78oZ9Wyi9Uqpcyrqt3IMoznS2W5DLCwwi8WyjKZxeH/uawgDAAAAADHq8xdADAAayLU GOvib+s91g1d2g2k1roAAACAHO5yFwB4XiL9oeM06aPobk4GxnIZ6NNuxEt9HguuSB0T+x5yF4CT 9Vm150C/tr2LTVYBTA3bKQAAMCXWfjkA4LiUuQsAhK/CPlcV2p845NrFwngM7bOEJvCtAy2eArUB c1efq34s+gda+K/9iam1ybCtIAotxCIWfNEn0ML6Dtb31V4DmJ+yave5iwB6eivSzsWHtt0pzdp+ p26bQ/1WsAWBFsB8Wcfq7vF1xFqAQ51H+rXrg6zACm3CPr/PCryIjYkT8SMAe3dz0zAMhnE8VSpV 4saJOxOwQAUjMAhDsAfn3jkxBxtA790BGoyTN679vm5I80H+PylqyIftRILQxPFDqAUAAACmQvsy JD1ZBe12b8Vmc/0zLweBrwIn5DIXauEnF0jhQyua6TTIoppcAMbXb6BFU44s29XV1Gkh3OKSdc4x 7KF739t5Hm/XOgm3GLbu/s53ExSQDqSQYRauWhl8EZbT3tctWtXn6vNwaO0TaVA7vEJpd12BD7cQ gRYrY3+1zIEMHdLg6+yrnDkEMcyhvinXlYp5lmkOMtWhDrA4/i7KtIjqs/QhFmLeB1n4wIswIcL9 +XCtuCnL4na9zmn2tjgNpAgzN2KBFWHwRepwtcCKvzwI4OEAAAAAMA13YzcA6MHeWG+9/Blup70w ag0ul5pPbQsAAAAM4XHsBgAB+VKx9f1Ie2m4+vy4RAMBxVXGNqln7UVieU6whbUNz+DjHo7T/diN wGK9ivmcweXCeTmABQAAAAAAABzu92FKZN9FbXBKi9XfMPYp12t9F+U+BFpg6XyghXXPPjUAdmyZ vJ+fM4h1GGBhhVicO2i2NUh26jhj5wHA//Y8dgOAjqpguRfxc+51PbZeXje163jsepsbYqX9z6BN 2jFwrQbmL9Yf6H2MhgA90Pqypgb3C9ef2/+V/rIL9y0Ae2eP0zAMBlCnFTdgYgHUhYEdiaswcBUO wh24AxyBhRmJDXVkLE2ITRz3+xwnSvPX9yQrju3ETqU2SmN/D6kFAAAAAEwd/wHoIU/3TQdsNrd/ ggmJMhj8rxValMHZnZCiEFiUYgvjCSx2dnsot3DCCyfEKFN1/q5x35FbHLPPOcoeuq+Fm+f1du0T ucWwffcrt7C5A1mF18rIa8Lrx1apOnK3K3e+tlupc6U/U5dTOHlFVkk1Mr8slFsI59OufcnSBNdf n0KLIRla+jBUf3Ps6/8MVkDhyjJPUuHEFiub98vWfllQXzNP2Pa+IeIsL7tIk1pc5+nOVHKKtZJf CeWhxEKSX2RCme/iCD+uWHAOAAAAAACYHkgtYAl8tGgbW1RmInXaxPC2C73CsTCZHAAAAACOTSG0 uBx7EAAeRaCQH6VOejYL68NnsPdeRwfQzE2wr0krJNrIKrIgxdqm9H2qPI09ADhZiv8s3yL1WlC6 WNA6gCnT5R7EfQsAAAAAAADawnxHmBqfCW20uYkmkpfqwq02d1GjEFo8J4wXYKl0EVq4rfbdawqA HQt2LeU14UWK0EIKmN30m6G9kweA5XOVp8exBwHQkZc8fdu8dN9KeRevySUkQZQkrEi5TzcJLmJr lrTr0a4ZAOaD9j0v0uvAYwFow3lCm1i8KS0+lbQNz6nVxcph4ewFYO+OkRKGgjCOx1AwY2djzUGc 0SN4ATsP4mWwtXPGS1hYWXkC74BA8sJm2X15CYEn5P+byRASyL7ooBCS/Qi1AAAAwH8Q+xAjPXdt aLl8L+bzm+28bPgemq+HZSHIoppWdZjFqgmpCAEX7XCLKuCiCsAIj91tJ2zbqjkE4RbHrJknDOCw msP7ahFucYq6eX7G+WuPHW5x1ZrfD7yopnZJ65jXblutkCOrub4Or4ittx6vn5vYwP/UAQ05ao5Z 71IDJkI9ahnPN+7rdIdtIEX9+2pCLWSQRX07E4EXcj4EWoRwi1LVCq/n27IsFmnBFnfFfiBFk5lh THJ3ZsZyvbuxwAqviYaW+r4bAAAAwGlxkSfOnXdRaOxk7tgJoN4J7OFWX+gV277XfDV1vAAAAMAY HnMPAFA+xXzKhbjWcvn56meMQQE9XQ94ziFhFd6ylHpT9rCe7nMPApP1Jua9JhPWsUh5Xx6PBM5Z n/9J3kXthGYAAAAAADYWuQcAKL/dD2nEmtF634PJdV3nP3p1Np6Kqpk/MFWvxXECLXS4xdBAC9kY 22qQHVtnjaMrvCK1aTaAy/WSewDAQN/r6SOy3vsu3gqO8EIlvPCovgEWXpiFF6gRex+i9w/A5dB/ r75yDQTooEMtYqEVWkpYRez8Wl3TWo6J+ROAvfvHaRgG4zDsBEWMsDNQ1JWBjbMgIXEFDsTKcRjY WBk5AVIrAUkTN1+dz45L2rpp3key0jp/bEVq06SJf4RaAAAA4JjJE5cHUw8UHDSf324OYN5oAyd+ xbQNpbAhFtW0DbLovq/KcvmzqrcBGG2R29/dTiDcYp9tjnHfEm4R1+Y0wy1SGb6/u4EW8hpXmxeR bUz7r2XV84vifDX9Xiy6rQbCKDqD8jthFpkNtZD1ed7Waz06cGBCyjZ3tZ0xBTEcc3tjb2u9xSaA opLbQAujJEeU9TawYp0YYetMHW4hAy3W6zfLy2+iovxcX8WFWtyU5V5048zzOlfq3RALLfwiU+pk Foe7u3xBGAAAAACOy6wsF6k7AQwkQy1iH/p060LhE9vcvB5qh5vHAQAAkMJlWZ5SdwIQqoF93iKW 6zv/kg/5fu2+m0Cva9P/UJ72AN1/Hs5z19P+jw/N97U7Bc+pO4DJ+mhKiG9AitD1SOBUDbm/bKrH OAAAAMDifBFTc5e6A4DjM3K5mECKmGuEvvm+bVUeDYEWmLYXUw9+7fvdpF2vt1PtMxga3Fqrk4EV bkCFb54v7EJr363z9Vt7r+0HAKdvZrifDOP1Kl5ve2yX87Vj+9AAC3c93++H0P//MecNAE6H9rl+ P3gvgP3y3dsq58UN5AcIfwKwd/84DcNwGIatRFWHTkiwV5yDO8AtuAbnYO/OxAXYuQELR2DpUlFo HDeO8/OfRFHcNO8jRY3iyDZFitvU8UeoBQAAAHILPSBoe45VtNu9q/X6ptq3F5Y3C62bYybIQm/H OszieA6pMAEXTbCF3g4HZe3/1uerOszC3+ZY5hnAMKRNwi0Sa8jY9nzaXVq4Rc5QDd1+3/db3+Nq h1S073l1y3xhrVLd+hq92eh1IX/2e6c0oYcmSKM5YBeewy2qrSi65wh1TWnOARrXHjAxVXtzbsu3 0kQVPGGFT5gbnOZYK8iifi1NmbNvAi1MuEXhtGX+nruyVPerVUq3H1Q3kKKTuaHkcIpSOG6X+0Iq fBdI3z8j9fM3AAAAgGlsc3cAGMF3pLzPRPXYQ6G+86U6Yw+NAgAAAFN4yt0BwPEZKPN9x5LOs8// GqFfQF+3nuN9fit3y0MhFrF9dG3/t8fcncBi2QvEpdwfjC08xz1FzNHQMdE+j7EOAAAAAOAi1AKX Rgq3Tf3NK1Zm15WyuK1U9lpvwFKdAi0+1PBAi9Bi1FKghBRoIYVbuK+h/ZQQDd+859A8aOl9ALAM L7k7AAz0pprnh1LHM3dcDI2foXFdGptjY3bo80OfZ5cAXB/f9eq0EWqBSxebz+ObA5sy93WMNamY a7QQfwKwd/84DcNgHIYTOtCBgZmpdENiZ2DhHDBwBY7ANThKd27ACWBGTJ0pToIT9+Pzn4YqSev3 kawkrhO7lWjakvhHqAUAAACmyv0CdG/KbWyH5fK6nrxc6gInNs6yC6SwIRbV0gZZNGEWcrur7wIw vuvSBFtsBplQ/jADGPr0SbhFwt4F4RapfRJuMWz/aa/39uT3djL80nns79ztbciEGoRRqm3n87N6 +bVeJ42//A2rEJVtgEW7LR7bGpc4Ri6BFlM8VkpfQ/dHXz37KLq/z1LU2USIreQIU28DK9rECFtX NOEWbqBFu78IzajKqdm+mM1Shnlpyo0zjJln/USplyEWWvhFqdS5WRyFWPcFYQAAAACYjruxBwDs wXtCG3mDqHbTllzX2oeCKna52YuLzAEAADCUp7EHAAgrZz3lO1HoJl63vO13mECUL9TCCt1cV3pK SjvfsUP1uXoeewDI1qspn5E2oUmxfJNZcK5DDjiXAQCAqTkfewDI2ke8yb9x/QoO0WLsAQCO2O+A PikTz4cmtdWuY9Tey19Meeg5RuAY7CPQwm7L3+xDk12nBla4S209FGihTZLt+x+D9hy11wFAHham PI49CKCH6rP3KvB46Hwe+rwtz+vynCsDKVJCp3YJnop99pfPD8Dxkd/vCbXAVF156mPXyvrINr65 qgqlPtR3rF8ciR8B2DtjnIZhKIAaRZEqNhZWKg4A7Jynx0DiGJyApQMn4CicgQ0mVNomTn4df8dN 0zhN3pOsuHZju5Uq14nzH1ILAAAAAEhJrJFv1dbQev1pFoubfV4Gc9+JJ2SZFVkUyYopNkJSUZRL kUUhszBVvnhv3Y4VZdR91X2ek8sTMHTtE7lFxNnmlGvfcxIvILcYun/t+25etyri4WvCiitRL8v8 Mgv3dZ5f74/fEVKLRmB+j7CikiC4kguZRHsp5BKXKoWYumBiqP6m1NfBle1SPuHaHaTVwcooDkQW 5TGzdU7eCi2szMLKLarffNn2bZaZ+zyPGfazaQopGs4N45dTZJ5y9+OGhBWnBNLghgAAAAAAQBqe Ug8AoAeOeYg/tLHbzcc+FNq2yTy2PwAAAACAvllu02PqQQAIdus3LbhPaE0m67W12FevIwVo5y5Q F3pwLvYhu7Z76F3PmwtLQyAOSMeHyB8baKItUBbAVGC+AgAAgDEj/3s/JBsFgDE/SvnQ60PWozA2 uPcFY0Le99ICxcfuE/QFr40NbuurezMILWC+/G7Tizmv0EILXh0SWvw5KSS+CCUtSHbM3mftewCA +fCaegAAHXk39bWS2PndV++b0zfO0U2adCo0P2t1mugiNH7ma4B5gdQCLpGu+4DcOFUxbWrnHCO9 gAnwLwB7d4/TMAzHYdhJBCdgQepQISFxAiYGrgELV+AITByBczBzB5iZmZioGLoi3KaWnT/+SkPr tH0fyUrqfNggwDRN/CPUAgAAAGPkvjG50eUqdcBkcr4MmHDZYAszsbqdYN0EUpgQi8XSBFm0YRby ta03ARi2tOdoQzMIYNhcm3xvM45WQ8MtSjiUn6e2XcItpHbSePtnX762dZ2sCLNFBFvYZdUJljhe Lr/m834ddxuU4RVufV13t1V/+7AtJQI0xniusbVHW8PbkQETahVwYeoqJ8SikxyxCqnohFyYOtWG W7jba/ecqpsicaT3OW2anC6f6XLpdKMJrNeeehli4Qu/qDx1bteVWA8FYQAAAAAYh2npDgADLR4K 9T3EH3vwKrUtJ6hC1sXaTt0YDwAAAGzKfekOAMJLYnvOA8eh92ifg3sH9HOSsU/s8/LQ5+tymXrI js/g/R5KdwAH61mFA5yM1LVIX/lRXF9EeRc99u0zPjGWAQCAseJ/cOyy3AnUgV1zXboDgPC+xjGx +w9j66l7Gd19n3S5XaNvwD5YBFo86vKhwvcL5wRayOvzocmp5YTXoQmwUyEW2w60GDYxCIBdNdXl rnQngDW86fIa2R4b8+WYHhpHY+O8b59YCIYvECtnvPZ9LYzXwP4K/X7PdPneZkeAfxQLp6g8Jef4 WD0O2K8A7N3BTcMwFMZxJ1Elrpy4IWABFmAIhmAQlukKSIzBABxgAC4doCikDq+v7zluaGPa/H9S FCdKE4MQbuzEH6EWAAAAKCX3ZuZp6ETL5Uu4uLj8KW9P3L7uy13ghFzWmzCLdR9SEQMuZJBFF2YR +nJ37O955Pm7dVdozzO10wtgGHtNwi0yPh3G9omXDD+Yy99Td90yv+f/F26hwx+8gItg7A9BNxtx 4ns90X5VdZPQf61WeRVVwRXmxP1xQv14zbreun5VT9/lcsqhEFMHMZxj8MO5XqsS4RX9PrXUYt3q AypkkMVm3YjwClmu1ediOIYO07hqmnC3WORU/SHsBlLsZG4EO5yiMfZbORvBKevBg30GDBhEAAAA AKZ3X7oCwB+lJogberB76IUteVzOg+PWMd71AQAAgCk8lq4AoMiXi737pNSEId7Svvj7foT6AinX ajsVWqENvbinj/HG4b1x+bmPvd8EJuJAGe1EWa9iO9VH6PVFxrU3CRVwCnLboUO0V3Nv8wAAOAbr mfBjLgDGSd0ncg+Jc3ZbugKA8rnHsbn9hfo5RGvbOnfcT6AF5iwGWnyEdD+8LHt98y09ibVee4sO s7CCLaxyTpDFoQItAMzTc+kKACO07ftSbHvtWs54u/XMmdfeem27FWil22gr2EJ/l/fqbf1sAOZB /h94K1kRYKR9n5mV+w89fxVm4FsA9u5YJ0IYjuP4KfENXJw0zA5Ojr6GuclX8SV8I3dXX8HodIMr 0oNK2/xbCiLl2u8naY4rPeiR3BEg7Y9QCwAAAGyNeQHz2JaHsQ/U9e0xYMKkJ27vwiwaK8hCB1Lo EAv1qoMsujAL9/1QrwMw7G014kTxJU2WX0oYwekd2/nj6Ai3WGu/aY7zFsItBmZYxc5YdoMt5OAL 9RqaXF+ta5ou1OLjcPA1skIsAhsb2rmf6d+vHZjQ7Xr9kIal9pd7wMSqwQ+Z7kusHxrY/wxGiIWV HNGHVFghF32dCrY4hls4ARe/29zZKRIXbburqorpft2We2OTlWf5XKh3Qyyk8Iszoc7sunu4fEEY AAAAANK6S90BYAHvxvLYADRJzKC02LpdoI20HgAAAPhPKtDiOnUnAMNrW74962IG5IauyVR5W6CP wFSXE9pKQRRTwyp8dTH7Lclz6g6gWCrQQp/rfPcApXuFviJNcgFs0ZxB6QAAYL7cQiZOqa9ADpa4 tuT6FCnx7Atb8xnZzjexvLsudnJ63/3Cl7bsI/sE5MYMtJBIE0aHfn9/CbTwLceEWfgCLnzPDWL+ M6TjAKA8N215St0JYAb1HP6rX44dHyTVu+d597waOr+PBU9J9WNjkKTzd8x3AZAn9zdPqAW2aOq9 2VAIxVIBFTwvLNiPAOzdQU6DQBTG8RG6qCvjovt6DxcewaVHcO0JPItJr2DiJbyBG+PaeINaLNPC 483wQNpp4f9LEEoHZlrTkhR4H6EWAAAASMF6o99j245Wq1c3n1//LdeLtK9rBdtlyEURTuEnH2xR zKtBFtswCyfaut3k97+fr2uP931Pp1j+VMIIzu+97X8vHeEWx+o3zfucPtyi+Nussd4MsqiGXNQf +3Z68fuLsp/t/Ov7u31Qcj+hwIta6Ea5Kstq4RbHkCJA4xT3ZelrzOEZY+tL+3/JnuXdMFllXtiF VFSDLMp57teJeSa28+EYu++fct+LPHfL2czyUm5dM5Cikbnh9HCKXFmv5Wy4wHKo8IY0RAEOAAAA AP0tUw8AGMCnoU2oUJyLLMtt29p3/SGcInQAAAA4tPvUAwCE98qy9UbcLjf4FtPHUIMFjBaueYNd 6BIDuU6KBVto595D5+pDz4f6HZuloxAH0iiKaLxFnpe/Ucp56DgnC18Ap8ZybIkdJ7V2ljYAAJy7 Uwhy+M8YDjkN/Rr68Nvd9NweSIHrUDAVd6kHAAja9YvyO1m7JrGt6Ly1nX98tZleNtNDy3iBsSo+ i0/OFmihrQtNWqBE10ALGWYRCq7wbbRzA2unF8gOFcRu+84AME3PqQcA9GA9Dx+6Z0ge12PHe0tI Rayt1kcsmCr2GgBMR+iz/3PUUQA2l8Z2sXpT2jVEXa5z7VK/CiP3KwB7Z5DTMAxEUYcisULiAAhQ 1yxYcQeOwIm4CVu4AgfgCKxRBVvYVRA3OJ1YntimTZ0270mjOPbUY0VtrCb2fEQtAAAAAGBMyD9C 96ZJBNzLfH69EpiQ+AIWjQjFT1tuBCxMK2bhhCwaMQv/fF3vBDBkX/aYmhS+ZLL8EjGnIEaAuMVu mMr3qYk7nd+siL6K3U1gr+017z4v84UttDzubp54Wyx6R1KtFTOML2RRuTrZJs47ghauPCC7Fmlw MbfVzyEKMZSId4ixUuO0Xvb7JOoqIWJhz6VYxcysRSuOfWEL0eas7dN0VSROar/zNFGLeW23osuZ Uj4K1MubmSZ+UQXq5ND9y+W/dOCFAAAAAABAeW5KDwBgC3xk+PZtztIWsRvlGPLXPq/Fj9UDAAAA APyXM0NCbxgXdoPxa4KfltzbePXapuP3bQwWIIMLpT5141xokZK2oS+lDCTigHI81/b9V055Dqg9 c4wZwNhhXgIAgCkzlHBDbt8xC60JH5Pljm2TaxfjMsEHYEg+B+yb/5iwr7DmEcZESNAih9gzQhMo +36W09qearvbcDwA+4r9LT7U9qW0a++d3TEl8XVMyEKKViyVOk34QvqFkmP3JeGOrXUOXQcAmCZX hrVksJ88mvT38LH5PdSWKl7lC1Rp4hZ+OXWuZt4GAIm9B7yUHgRAIqE1sCGf3Lbcc5ggvwKwdwc3 DcNQGMcNRULiAOLCuXdWYAimYA72qcQGnDjDGakLVOLCBtA0uH04zy9ucW0U/3+S1SQOiSmiaVPb H6EWAAAAKM36UCM9jB1osXh25+fXm2UZZNFPRr/bbxhyIcMqdoEVMsiiX3fb5T7Qwm2LP/7u8evX uqWV8IVa523l+W013KL8OQm3OKZ+8vo+4MC/fssJ7WW9vH8mwyzsMAy53bnlaiVPnta+IMDiRBQf YLEpPxPrD9ufX42QhpyBFiWVDn0oGfww1XOZ9cq6NnrG3/DchlSI4IouxOJMbPcJEj7c4lT5Ofm/ 7dtwM5u5eVqwxZ0bBlIMMjecHk4xU7Zrg4VcZDkc8BN7glPfnwMAAADIjwGemAJtYKh2lzE2SCus S+28HptILrZOp3IAAACUdF+7AUDgzagLP1sdOplI97jM1F4g1cVIfeogPO379Zzfwbdi7piIA3V0 k4y+GPX7XttS7kMCU5HrutXy9Q8AcHy5whX2OVas33aOkqNNxyiHtmns+bH85W8JlPCR+Xhjkz8C /10X6n5VuxGAIPsuxvolWhPVym0p/Rq1/S7X5Wldbs2WAtNVK9AiFlZhhViEk2FrE2PLbdoE2VYf 59jvq60DaM9j7QYAB3hfl1ej3noPLdfDa3ps2SrW+4Kx8KmxazbXbQCefE34rNkQoCKrX224T2w7 GvEtAHt3lNMgDMdxvO7Bd5/dgzHxwQt4F5+8gkfYPbyCF/AUxjcP4QFMZqKwUSj1339bNmCs309C KAxoR7IRoPAj1AIAAACnwj1xeTT7FwCr1uu74MvXuwCLLsiiLtcBFt080wZZ7If+dBd8YZpQi9/e turxIS+ALyV8Ya56S9m/pYVbzFcv4RZT6MItjBdoYZxyrB+/acd2Xftdfqo/9O/tdkjD/k83gRb+ vHYYyZJDIc41YMLWR12H1TOkrnaNJlTGzrtwQizsUzK76eo325aFQIvdtBtuYUzv6vrK2fZlNb5O C7W4rYYHtxmB8kqY71evNc0PxOjtIqfs/1lyQwAAAACYF6EWWLpP5TPtYVCtU7i0XOihUOnBtlB9 AAAAwJSe524A4HlzyrFzJOkcK3V4P16TgST3ymfaA3PSg3ex5XLqKPVe/GbuBqBYL045dG0wdr3S jqUXZ7kvwgCWTDs+5R7zAAA4ltywhaHbSAlfiNU/ZN2x2nQqbUnZN9p2NfXnV5FlgCXhnBLngP6O ODVfGcuGrgH6y6T0V7TqQItXQ6AFylX3IR4SaBEbQi+uttNacIUUYuGHXfjhFlIdUjtyXo4t7QcA 5bqphqe5GwEMkHMfPqd/WegYq4VUaMfs2LqxY7j0vQCURfrtf0zeCmBcbt9Wrc9syjaAnT8B2Dub nAhhKACXISYTE2PcuNW4dGO8gOfxGF5mEk/gCVx5AXXjHVwbBunAG0ptaWEQRL4veaH0h/cgQPlp 34vyvAYAAAAAMBCuFxJX3n1oQ5vNk1qvz3bBJcQBeil5wxG7WSYBKepgFRLoos4T0T7PJV/qicj2 62XeWO+KtB/TSbXYOrJv9En0LuX4HqZTTt7ujZd0LpV6xz+fSr2q0juq2hH1Nr916eOr77eNGona l5nLn2mRpLI/adyfv7JMrY+OrG0nddASa2d3ZVZ+YjjQ3+u3ZN9uIMY+54bUOedAHH9N33/U1VWP rp1b62Z6VZXrpb6NrKrrO62uSR0tYqsDWhR5WVUuaV0nK9KrKn+l01X7XNXXvug/T1N1VdxPPsLB cu4KeVHN4BOpmOiQrbE7qWr+TLcn+OTGYZB8O0/I1c9DaB4+O99XFwAAAAAAhuNiagMADsScFNpn QHdoIHsoz9bha+cqBwAAAAD4LbRDn5upjQAw0M5EfE59Qu9MoXc0e3Lw+zAmA0RzHFHH/pfum4xn D2Cw/8W7ysxy15CGJX2HuFQ44oBpeFPtwXc1fR1quBxeACyFGCfTAAAAMRzaZ8S076qjr01d2s21 r/TZ3fdZuP+EtbIN31lhjhz67sj7J/xlbqc2AMDidYBttH37841X1HJSyGMh1wPYADBHnlXp6Nr3 3NI2xrftW70rsERI7IAWoWAXPnHpN9O+ffDtr2sdAJbJw9QGAPRA9/WxQeRingdcfX6of/cFo3I9 K7Q9T/jmFrXZDgCg+SzkdGojADzIvzdfX+byO+WrE9Nmrv8+4Rf5FoC988dpGIbisNMOLBViZUGo MwdATByBnYUjcCkGJi7BBTgLSJXaDsQtbpzXZ8cmUVw13yc9+dlx7Nf0n5o++zcrHQAAAAAAgGkv +nuu7aHrhOXy7mjDc0cjYNEIWezFK8xBxMKWvojFdmtawhbW32ya9macZlwnljEUe0GOce91Dv0Y cuYdf85pXN9+c/4/57Hka2kqr6f9vOd4nX2RiupItMIJUzR9tTXhceEN+/m/WFzt/NV6HQlFH+QQ k/M94YqWmIUbQ7b1pIRIA4IWaXONKfxwbnMNNc9hBE9sxr1Xd4oQtvyzytWNaY4J3ypIzLx2p0Dh 2tzYtryoy+v5PCXM29ruvSHnAX+mtEsRCxmaPObXW5fI86uADwAAAAAA4/JYOgCAAUhJUk9ZkCZ9 eW5X/9yb29qCMgAAAACAoXgpHQCA4NPzYxvyaO2hxbwh+67tp0+wAJnciHpMtEISW3inLc7z/6Pv GnuKvJYOACbLh+enbBYVuwcpN9DQ6gAAAABwTBWxPufKfOnYHCn9Uk3L7e6KJadvnxiGttx4hnzc Xc+b8UqAc6VP/gq/UaEEiA3BqaHlL2r3/1I3m9c2vNVyFC9rezcIWsB0yRW0CL23+gpa+Jtca5te I2gBAKeA3eTkqXQQAJmsanvz6l3rfJyfKiyR850v/7MPHQ99T0u0XLhQHQCmjf1M+CodBICCzJl1 xPJhU/rk5toCmF8B2DuDlQZiIAwvbaEUUREET4JXn8GX6c2rT+Whb+DBR9Cr4oOIUHDdrI1N05ls km6NXb8PQnbbZGe6haabTOZH1AIAAAAAfouYBx7DbdeFFovHajo9a49tovXvUm8kXXffs4IURqDC Fitw4YtZWCELK2ZhkqFbQQx7/XVdb5z3AeIL+7bL/Y3oXeXOtQ9TdCFkt8yaxLDvs5xrva6394iv E+Lbc7fPZiz7bHbS1h/LZZwXUrJ9X6jCEbZok9yPRr0LAhyyKMRQBSasPWyVsyPNmEu7l8Yr8Ymf c6c2IhVj79gXumhfdwQxXFuWi/G4upxMYty+qbY37FiXQhuEfOEL7eNKLqZu7on9vw4AAAAAAP1w VdoBgB54SWgbCvjWgtkrpZbaa/01+wAAAAAA+2Je2gEAB7PJ+CmiXWpCES2Zh6nfevIdIJbzhLb+ unloTV1bY89JrumHGwwNk4hjXtoJ+Jc8N+W1o03XeKYl0tDeAyjJdSG72ib3IY9tAAAgExIfSO3j x0GHrpsilCDZiBFeSBVm2FUcIldsom8Bi1z7sd/prkIfJE+H0kjJ0lNIfY6UYmlynkV5foV9cVXa AQAHswam/U6HfgeluT6pvRbDeNyU+6rcPA1AaXIELWwdmq+PFbLQxCw+A6/FClpIybNDawvS5/Tv AwDAXVNOSzsBkMhDU95XxyljflfMmSYmFRKpCAlRaWN4zPjN2A0AGsQHwV/nKKNPSnxPTG4qLY4o 1yYcKF8CsHfGOA3DUAD9pSpiZGGsBANnQExcgQNwCC7FzM4ER4GdDTECDZEbx/22f9IQk+Y9KbIT 27FrVUmb2H5ILQAAAACgNP4flLvNdp0rsF5ftgQTPo3AohFZ1PIK2UosqtBJLOpNFLGFk1l8B0KM +rxjLOyOfOGv66V/DaWl7zO2w5YuhHWO/11q6p5yP9eX/raMYHfuQXvx+8VOX8fLSmt/tTr5Dd8/ Pjo0cbENnbBie9wTXKjHgzxdKSFpGKq+QxdMjCl+ONS6Bj9nc/L6SuCJKJycwg99cYUWd6ILd45l UN7VUYXHm9AotbjYbFfSTMpZRuJHynHrBChNiNHqIi++iMQBAAAAAGA8zks3AGAA3oz5UhPtc4vK aWki+gPs2D6DSQEAAABgLG6Ficjwv6iEFp+RNMvkXMv/tHDCsEWiATAkZ6INOmrTdSKdFsberafy WOudOizEAaV48OJ9Fp3Q7m0xadPXXi0FmA65+xgAAMyDmGCga/7ctk/ZnITBIlKwChdS0oe+Yokh xRR9+yxVR5d0a9/nxr5r34tTASiLRWrRZ0wK41hgqtyUbgCAx6sXT41LzJEaoximVyKLZ0FoAfPl SYYXWsTEEimhRSqekllY5Bbau4Kw3ZI4Jso+AMyX6rnGfelGAHSkehbymEi3/PZO3e+19/Ba3pSI KlU2vI/Hft/nPhMAzA/tWvAyeisA9qPvGJ9YOes74qHbAxPhRwD2zh6nYRgKwJZSqWJAiIkNdWTk AByGgWMxMPQATFwAFk6A2BA7Uwe2hjipG+fxXNv9SQj9PsmyYzt5r6Ehafx+kiKuAQAAAADsyCZH Pp+72IHm8ycznZ7XiSksLrB6E1S+ndf2G5GUolwntnDtbjIL480p18kw/CQaru0Cq/eR3MLSZ9Bu 95l6FDmIzEZu2eu5bWQ29XjOr/uS5+883N+1f7lDXKutbLOSPTa5XXtzd+6aupvsos0bofl+++2u Lbudb/UsipN6+2uxiGtl99EH6tJJACATV+yYzMLJ75N9yhuz7sgalxx7tFJsrwStt+vkFtU/APvY aL1dbF34dTVeVON+21ql2SQW9Uq1fb5cydE8ZJz8i6Iws8nEfNgHyc3cVOXVdB1wnEqaw8/StA47 hekuqEuHHqemVNHvc5Tm9yk03jzZH5oLAAAAAAC7cT20AgA78m30wKg5Rt+x35ta0FS5X2jOJvkA AAAAAIfidmgFAATPXjvVKVdz6g0F8NDK+z4UB8jgsipvSr+/bq6aGHjbcr1d9mlIo6VjfQdBIA4Y ihcTDy4aCpKl3c9iAS+W5nivc/ibuPtQ6vdSM7bVxlKPERrnOgEAGBe5Bt4pv49yx1N9Dvchaxt5 OXMOdby+ib1DkrqH5mvPK6G+0PFnQS0BAKBvZkMrACD4TJgTszPU2nK+a19V5aEqp1voCvAfuDfN 2nPo/V/IzjdlzVkLTp2a0ELWWrtUai04trZWIPU2oi90HgAALHYd/WxoJQAyefTaKff93JJ634+V TTJCusY+FwAAwH8hZr+j2cfGElSkysi1Z4IR8yMAe+eu0zAMBVBXAiHxCQw81BUQGwP8AzsTP8bI lyDEjFhYQYKxAjEXiBu7uXF946Qvt/QcyXLi13WrFhQ38UFqAQAAAAA5kRcx10W6SHXo94/HQouQ SmBRiSxKeYUZSyxs7iUWZTIRsUUps/BiCzmWzaUwY5kgt1hkzOW/t2Vc4+KuS0z/oUdu0Rwzz+ep jG1c7PWLW3+/6utelchicj2sjF319cIJn6q5bY/yj8Ggy6QqwUX44rzYIkh1MUd31lkK8R9FDDni /cdYy4jTKwON/yBNGB+c4MLnVlwxLPKRLUIcb7nv/I+XYdjvtWv/6/obJ7voueOdIt9rJ7U4KtJ5 kR5NXVThj2NyC99Giiy8xEImWWdEmT0fmvqPAaHwQntoCAAAAAAAFsth7gkAzMjrlP20B9a0m8lT 7U1QHraJ1QMAAAAALAK7qfdV7kkACOxG3y8t2mkbimj12gPHPr3PNGuA7uxO0ScmrNAe0tNS2D8c f1PWIdiIA3Jghbt34lzbmCJWJ8uaNtCI5d+zThxgBVjlDbQBAGBxLENe0aVumnHmNb6st9cyp5E6 K088UPraNcCTxPiSyw5tm3iIlD0X6dMdf7lzy5tpt8lzSOqhsdQmdrEx5H3qJiiT/bTr6H0lJsA6 EFtrTbVtWw6Qg7PcEwAISAlvJW3XD7X7Dq3Q4tYgtIDNZZ5CiybBtLaxdZOwok19uAF2TGgR2xzb KOcyj70PAACem9wTAOiIvc/svqE+9Tu8LNfuL0v9328SWITHYX0sbmxO2msCAAh5yj0BgDnSdM+s 1rZtOWwofwKwd+46DcNQADWtqi4sbGwgFsTEByD+pQs7H9WdDYmdhZ2FBQmJHbGwVCjUTW7iuH61 SZqmnCNFcZzE12lRoxD7HqQWAAAAANA1rocQV91drKH5/FFNpyel1KKSS2Rl0vJcbFHtEyGFFlTI IoKLdZmFMo7JShmGtCft5+ustr26qB09biG36DLm7j/bPK4q4g4lZmyccldxt+c//T3lsVURe7/j 5tKJuqS1EliUNeV23m5dclHF8gcVwYXm0ye1MJLhrzZHIyWJ6wMN1yQWa0KLDb6AIUsahtx3Yg07 VmlmKEQUIrbQv7/lr0QhsRBbhF6PzfVy/1hLK3Rby/LquEJwMRIBhsRRqvYfenPmzOl4rC4mE/W+ WMS6rScmvahKWnGk/EIL6bLIKaQrmVFviy5cXXS9WHBNBrI/2lgdAAAAAAA047rvDgA0xEyC4Zuc lTJoPXa+a1B57NwQrsHpAAAAAABtMOu7AwAWz4F9oWe20OTiWNIRvaSINADa5Gq5PHj2uZJk+sqh yXqbJk8NvZM/JHQy1/u+OwH/kqfl8lOUY8kypBxaXPczV2KNtzYvAgAAAKAjNhm83aa8IvU5qmm9 uX1rlM9VXYBwptbFFG0JJvrgJrHORmQYWnihxRevqhJgfAfOcyV3c31Hdn0oKZw9Gc3eZ7ePQBEO Ed/Yl9Rz224TYBOQWsC+8ZF4XGisYGwcoa6/VHlC/+P0rgEcFE2FFuZ2itDi17FOEVrYAouY0MKX INv1Ttx3ja7PAQBAmCm/NBVgXzHH3mzzHt4niwrJpVKEFr5yLG5s7hD3bwCI8dV3BwB2RBvvl2Pn cN89QP4EYO9cVhoGogA6JeAXiEtFBFeCG8GFX+LOT/E79HME3ejedcWd4NKV1aSZW2/HO49YmrTx HBhmMplk0tCmZF4HqQUAAAAADIWeBHjpCgaGHh2dLIQWISKwEMmFSClETCEyC5FYtMEZYgs57msh xGiDPn/8GuYfDLnFCOrs/9629W6+hCA42sfILdJ1DvN9auvu/x5LvQ1ldYfrr8uxIq1ISV61UKLd /v2cbsvMZtU8fn1PtBc353FBC5jIKmTR/CYOpRV+/zw0MgyfloX2c2yzFGIscoSh6xtjXX3Xo3+7 4VNlYXzwkgqJqzr+9AKLSgktRHYx8zKM+TPGl//yx4v0ZuLTO3W8V1UlUovDOpzX4cEtiyokbckt pIwWWYjEQge9z6m8ZvvTuE168k+YBgAAAACA9cIETxgDb384JjZA3Kl0agJYbGG52ASy8NwAAAAA AOvkaugLAAi4U+nce1Hq/apksZFw4vBjHc5W/gQAZewaeZbMQveTl8gtSsvpbaveMbdLNEILFhmF vvlwrdQihtXmaO2P/e/lFtMA2BaswbexMrFtAADYfFZdYGRVeUUXQUWu7IH7Wegvlt53y+IKyHMR xCH37kdy8VKHqWtFGCWL1ll5qb762L7YOPbTyDUA9EUXeW9p+2sub1XG3A4Fw8OYR9g0pkZebEyi Rey5rMNxHW4cQgv4nzRt8bd1eHL594PUWF/ZLulj1mKLcEHrUGiRk12ULopdMi7Ziq37AACguR76 AgA68uzSbSGxuT9WntX/bqX/IrTI/Wd3vV4AAI30V/CMgG0m9R3O9S1b42cn7vd42a71wkj5FoC9 s8dpGAYD6Be1UlcY2cIFOAASEisH4SpcgQuUmY2dkb0SK0iwMnaDUDd24rj+SSCkJXlPipwak8+t aGn88z2kFgAAAADwl7RdhHqdutBy+SCLxXEltTBJy7eJhYu6rpRPSCW5KOUW9WEEF7syC7HaFJUM w1zLXL8si8ZjF+QWY4o5jdf293HNmwG5RTzm8H9PZVzRcQcN2yl2lZQ+a45r2UKLpuQivg9CNWlK kLKqL+8fH+F+qD4bOYXPCGLLKyyhRebWu20Sz3tI+oo5ZsHE0PHGGGvoOG42CNHyiWpUXEssjC1C lcYeMdfyme1stm7zpdtvjRKb85kWWLiZLdxsFCezmeTzubyoL5Zx1KagJ6mlFZmEhRamy0ZOYQQX hVXvii58XfRtUo5NqPnqmUAAAAAAAOiP0313AKAHXju0jW1oCy0kD21uaxsjtoEMAAAAAKBvVCIf kqzBIaE2GYdkhO69Vyxpj/vYt8nYV/csSC1gOFypRRexRNckremFS9PhSEqpBcDQ3G+OtT5PJdIy 57HDl0QjlCSDsUaYClP+/wYAcOi0/Yz+iVQiVt/2er66XEophRLimfGzM6kFeReB+DAM57q8curf pBZcrPT5ymnTJmFcqJ29vj2UTC4PdRpgBKTW0cR+j3tT2Bf5vjsAYKHmwNbJVrv41iKGPleV0OJW EFrANFFCixsp7wNS4/C+0p1rDo3D22PwseMzUHYRWvjixuYOYs/R9zoAANhcSi1pBfgv3Fnnbcf3 TBmah0/Nxce+C/jm7VNz/232JwEAdOFx3x0A6IGuc8SpnwFUfAvA3rnrNAxDAdQpAxvsCCFEV8TI wMB3MPIjSPwWO0LsiB9A6twvqEqc2OTG9SttSNr0HMly6jzsliam7c09SC0AAAAAYAzkjX1PKiMA dT6/dRKUN1iBRSO5aEsprMzCSizqojxii3o/K7Zoijx+/pNEbjGlPo/jtd29X3uCILeI9zn8+6nu V5l+B+022XdRJZ9vC1n94opiY79NCYY9XuOlaMYwq+rFcikPouzGhXuBF9KK1rKvzRQp50j9fQ9Z 0nDIY6evafQV6kNmoXCtDn/GByOs0HVlh9DyCiOu0BFrM7O+MkyUyysjtyjMdeLECDPW5vqxtuMp l0/L+iJPanFTlvuyfKq2qMIu++QWdhspsrASC1nkOiXa9OOV52Vybwjy3RwEAAAAAAD9Q6JTmAI/ njZf8HqXRBapgPKcYPNYHwAAAAAA/8Xz2AMAcHgXy12Sa4QS+eTcfCzbF9sOHGBLrlRawFlE6nbw kn+fUDBTKJGre55N7fd4LbQ4T24F0C86Wd1bZH1oDrN16rtGNxmGL0kGwL4SmnvWzuNdjg8AAMMy lMAi9DkoZx8rqtDSuzvT9mhq3X4WGAfsP5emPDjtH2X5VrXgQpcvsa5Lsruc9df5wwUYjT4+J+Yc IxVz09dYAGIQ8wj7hBS7h66JOQlsQ/GHOu/Fi0JoAcdJSmiR8z28PAe3FVrkiCvGFFrwvxcAxHgd ewAAHdFxZr77gyQ5837qN/iYsMKdn0NCC3d+z53Tfc8FAADg2HFjYgE68SsAe2eM0zAMhWGrHTow MbH2AnAAFli5BSMjM0fqAhdgREhIzLCzM1WMhJrYzavj57hpaEj6fZLl5GH7ORZJXMf2j6gFAAAA APwVuZNib5oKWiwezWx2vBa1KIUrzIbIRClsUQYvcmGDFaioQihs4cUszDpNmWezLF++9y3Pc0Dc Ykw+D6Ntd/frbxDELdI+9///VPo1zu9e3Tb6loIQwmq8WIU8r45DAQx9rbn3/blcOuGLlg0R1lPm t5vee5tIVwQvjSGLQoxNHKEvf2P01aef6Mpbd++tnwROrMJ2J3+FKWxsz5194uzfLo23e3GLqROw KEz9SST9n0ynZp4nbGEnt76YSrTCFqMJWkxMJWYhBS4KYQ+FLmJVjG2oUZh6E8qmbFroDAAAAAAA 7Zj3XQGADvhS7KnfjeEEcS19ajGYlj82AV3LAwAAAADQNdd9VwBAYDcaec1I12aRsbbwOFxE/NbB dQBsw5Gpi0akvnk3CVLEYn/clEfbQDy0DXmswm5Ye9t3JeAgeRDH2j2kjR36uGkjjdhGGPIcYGyk 3okAALBfcp7FXQpY5JRl+/52A+tQvMLGp8mawlg5N3Whi2dTiVw8rcKH+FtT/zyV7swA/A/ajOF0 mWfIY0gwHi77rgBAwHuLPLHvYCZiu1qFu51qBzBcvKCFJiTfdvxdjsF3IWgRxrH8sbH+8FtALGjX prUDAEDIfBUu+q4EwJbci+Oc9562XienDxDrB6TsWlpt/VCqv6JdDwAAwBiJzWXV0nXhi3fsAfIj AHvnktMwDAVAkyJxB6RCWSD1Bggh7sCak7DkHhwHhFgjcQHWrFhTlbi2y6vjJLabJiWdkaw6v76X VnKbxPYgtQAAAACAvpGD+u7LctN2wHR6uRZa+OjJip18wsguNqUURlShKhKLqtjCHOfEFn/FCDKk QCMX5BZjinkYn62Lmx9Tjg9Oj7s6ErnFDuMqG7fXsA2xqyIKI7So1s1LaFr5uvdRqzbe8VMuHE8m NheRjPguNkQUUlAhMxYnsK4XRejkKvv3RVcxxyyY6DveGGPtUxx5lzvUKkzsexRCaCHFFbqpKLz1 Cyu90PGP9HrbRixtu7F0uZX1k/L1NE5qcVGWK2UG8UhRhauH5BZuHymycBILWeQ2Jdbp5UXgY5IT dvh1AAAAAADYDbOhEwDYEjkoNKaTeh11g9n8bcrb5i/H5tB2DAAAAABADnfKTOwHsC9ooUWsiLDp 2im1yIHDb1udAUA6cxWWqchn4k33AvwOR9VOTM3HyVh+7DGihRb89kHffJbluWF73eQUqb9l/kQY /jqAIZkPnQAAAHRKjsSiK4GFXHbiinNbnLTiNiI/AM21LY5vZfrIa8HFR1leVdrkcu71rPNMAdLI mTA9hphrS64/Yd+YDZ0AgMdXwr6xz8Y0WmjxkJURwP9H34N/Uu1Ci9R78SGhRKrQIiSxCAktFjUx QrmESug8Y9oQAADJ49AJACTyotr/X+c+f0/5D1AntEiNJfP16wAAObwrJNzwP2jqr7o5EV/zc+q2 PrNt2+CA+BWAvfNZaRiGA3AmKwMHgl687ir4CIJHfQs9evTkK/gkXnbxCbwKvsUeQQRhUnQ2NFmz LEmzbmu27vsgNOva/n6VuXbNnw+pBQAAAABsg7rOsJqHugONx29iMDidSy1KcYVYkEzIpRZQVPVS VmELK0yJRVnEfLtyn0qIYR5fxzZfNwW5RZdi8reNPIJaIrcIx2z/81TGFSpuq2EXYmvKc68EEstC i97CNsvbhsdoZNlA5PmP+JpOxdlw6Nm05/6i17nIWEJ9qnVcs0ik2EK9NzOEGG2yyXj7nDuxDieO a2YIoeQTc8ND8b+pX5uWCC20kLebUljxp+ou6YVuzXapdPT3wnm/L0ZZJiZ5Xpf2VVE+jHR6wi+0 OBKVzMIUXMyM9bbowpWiq/EgNIGHa32XJ94AAAAAAGiL69QJAKxJzKBQuyO43UncVbf3dS0ZQAYA AAAAu8Z96gQALMwJv0MT89jrfL/dmg5EloKBi/VOBSCa4wb7hAbf2e3tIeGF79hdfSYhJ7d9TJ0E HCQvRr3ueWLdNq5rlz2xlW+yK4DUtHWNiR3MDgAA8WxKYtFUYKHFFabAAnEFbIOTotyoopGSi3dR yS40dn8Bs365rQQBNkTMs9fQvXvdfT2/QWGXGKVOAMDCN+m+ja9PoV5nrr8tytM6SQHsMVJo8VyU b8/7oWfwMe3G9nP4kMhiVaHFrzomQgsA2AVkW/pd6iQAVuTVqDe59sW2w/ukFXVCi1Wu56H+ArHn AwBg85k6AYAIXNNupbjudbnfLDj4F4C9s8dpGAYDqEsHlkigTgxUiIGVFXUBbgAH4BAs3JCBI3Rm YezA0KGqSpzY7ZfUcZySOm36nmTFTZx8TqTG+bMfUgsAAAAAiInsyPeWpkndCuPx3VpoUUYPSmzl E3mycopcSmHzRZmF2hJbLBYb6YUVYlhJhp5KgUabILfoU0yObeAW1K79mpBbxIirTNyoYc05thi0 uO8u0evAOCSKw8q7xBaZWGKVD2yfJCM1m/2o3/lcjZKk/uRedTCkwEKILQZnZ0UZB0KLg40VO14f Yx1yHPmEeyC2YU0R2RtpI6yw08waYcQVS5OXQoulKZP9x/V8I8xYGRHOyqyjY5yn06vhMERqcZum B5V3zpGiirVvQ22LLWwZKbJY75ZIcpkS8/TvpeMwyUa6nAcAAAAAgHa57LoCAC0QIrWw+D5sL+eb dA4LKcN9LQAAAADsG32P99J1JQAE+n5tWrHMN8hI3fLQJDsPI7WAmNx4lrk67FXlXct88gvXdnyx +8Brmi66rgScHFNV3b5ZXM8Kfe1UeRAN12/X4FcAx0ibH/shuAAACCeGxMK1/qPaSCueVH79fh9Q F4B9MlHFfqRfKpdc2KSR19vXkeoF0Ca+71vKZULnAxwKz11XAKDEt2NeyCC2LnQ5LeP6+G+lAI6U mEIL1wDWZaGFT2JRVbZq+6EDYLv2k++RAWAX3ruuAEBDPlV936Cm7X6T9/Cu6wTftUNV++2qry8P AODDjrfDeQP6Suj76NB14YT5E4C9c8dpGAgC6AKJUAoKJCoacgMoOQHnoOECiANwmFDTIcQFED03 4AY0qeLgjXeSzXrsXefjyOY9ybJ3/ZlJRByH/TykFgAAAACwa1J/sDzELjSZvJnT0/Ol1GIxcfDc rEkm7FokFMV2UZ7NMk9mEYot1uuL46VslqIMub7E9su7BLlFn2Ly3iac7dbILeIx2/97KuIaF7eN aCvpQyGekDpNVmFK9eW6lehC5BL+fXs0OltILX6n0/Qbui+okGt65dIbJSILEVzk6/m+7EilVLsp s2g7HrG6EWtbmYWU7Wcwyz9/yzuLk1KI3cE+Zoq4QuQWVlhhz8m8ejnmxAkspBVKsjx24gvJ4XIw MOPhMEVsYQeOfZmVtOLIVAstJGVJXwQXc68+FF2EN8uwTqhrWNPqaYQDAAAAANicm0MnALADtEGh GimdxcNO5VXlqoFkdXEBAAAAAPbN/aETAAj4iOyPDdyN/Q7TBg9XDST+2eJ1ADTlQqnz27X99vSw yV+TWdRNEBs7T+u+0Kf/VTwfOgH4l7x42ykTSdUdUzWhVux7TuoB+s6mE7DTvwwAYH8Siyox35Up +h9YYcW1KyOvgK5w65ZHV7aSi/d8+cyXb1MvrwRoi9ikjqnQvwX6wPjQCQB4pPZdDKma/PYuX562 ygigu2wqtIi1LccmpZ65bU1coW1r8gqtLgvih3loOWuvM6UdAgBAA6kFdI1Xb7vp91/qc0BKO3y4 P9ZnTbu29owCAAAAzUhpy26yH3rOnwDsnT1PwzAQQC0iITYY2bsiIVYk+A3sLN0Y+ZOIDYn/wQYz glyTS66OUztOSNrynmTlw03sVFVdub57SC0AAAAAYC5sAN9jWW5jF6xWV43QwkcShKt8QosKKipJ hWtkFa3MwnXEFlZu4QsurERjDqSdY0+Yf3gChtw2eW8Trq63yC3ibc7/earadXW7f91SV1Ihgoum 1ggtWr9EO6Rs929bkqFDj7xGjovibFO/kVqM6nIrzbDHTYdqocWcHxSEFrRFO949qhsFrQ5qe/ip hRW6teIKWdF24p1X0YWKMYrNd011vRoo1CxxWp67LIoUqYUE3EhAzqvbFlXofkhuoa+xIovmsUyx dc6ck+Nv103gYd8ufx8AAAAAAKbjZukOAEzAR+Ccv/B7aFB+KOitL0As1CZBZAAAAACwBOulOwDg 8Wb2c4OL+wJ9hxZJQvg89oEAEvGlFjmJtFMTx8bqjpm1I7EozM+LiyeqSxmzUpJfxKRNzDnCvpMr kugby/7TGAcAkMOcEot7VyWTvq7LXULbAIeESi6Er7J8LtgXAMVfGzM0IWJoHUyoLvUeOfUAU3Dh mBOE/cJKh/rWIaauXXwoy9MUnQI4QGTuXYTSOUKLXXPyu4QWfSKKkNDC3+4SWaQILUJ9Dj0na5EB IJd1Wc6X7gTAAOS3QEzombp2TAgJKmL/w/cJLvxrY/FFsTkXxnMAGMO7q/6nAwAAj18B2DtjnIZh KIC6VUsnBkYWBg6AujNyGjbECbgHN+jCCdiZ2FiRuABiYQ5145+4rn/tpKVpmvcky4mrxm4FSRp/ /4fUAgAAAAD2SU5wreU+daDF4tXMZheVuMI+H/QFFquWwlQSi3K7LCKosBKLentdZiEiC5FYyHt9 iUYtzSiq/v6boSTM75+AoW2ffLcZ73Z1e7nFocUW0q/l1P+eyn6N6/cQva2vv6jlFiKN2BRg1HVs Ozj66GxVf/9qMTbKqFxifKOJKqTdldF4XLcfgL4KLZBn9KuvvvQjMgtL4e3bc2ilunFSCrE72Ns/ EVdYicXKGuFJLPz2sZNeVLPrIraQsbvj2v3LycRcT6fmMy22uF2WN1NLK0ZGF1r47gxfcFF47aHo IjxBFsFxhMJ7PfbVhu1tF0EDAAAAAAwdAtXhFEglkYsRBpKbxH6sTh0jpw8AAAAAgH0xN2USQYBj 4d3oi41zfiflJCCJLRbWkpR8tP8oAK24WpYvs30uWws60gKP2r4mbbF5dmO2z88fM09dDwAGyYu3 3TSZVM71Sru2hUmwkFoAbOLHowEADIVUoPMuEgtfYGGfOdlnTzeuAAyJc1cAhkLs2a32+5d7b+iC edcDAAhoGruonTsfl+Vux7EA9BWbxPrZ6P8fsXuPWDJp7dl7kyTWuRILhBYAcOw8dD0AgIbkzsNr MWZSp+4FUvFn2tz9tvi02NoibcxczwFgV366HgDAkaDFxxI3NGD+BGDvjnEahsEwDDvtwMDORIUY OAATa0+COCcXYGPlAsxIqBJjik3yB+fHdpzQ1k37PpJlt01it6IKTeJ8hFoAAADgEPwJe4+2PAyt sFrd9QImhARZ+AEXrkhARRNSYbqwin6YRW3bdRds4YdbhNbXIRqHVOqG+ad9s/ySfW7bPgm3SKzd 1uNXLvFeS/Z9muEWVbttv26CLH7DjeJzwMNjCi3XPP7YbCLDqHpHyao2pCK6G6iaMcpyLsxiYUvt vbbPP465hlkcuj/6mkdfu+qj8r6zve+zV/tpD9s2sEJqCbdwwRXuKreFel6CLtzzP3X72N+uPL6w y1wtlzmhFrem+f/4xfSDKqQdCreQZXT3+iS8/5rxnus+MvUx+a/rNgAAAIDdWJceAPBPsRukCj25 fmjSW2qd1KT8sb9VYxesAwAAAFMxGRnH5tVr5/6OSk3yzZkUHAq6kPanLe+2XE99Q8BIl+bvBLlY sIQ+d66FAixir4XWC43DBMYyJ0+23JQeBM7Os8k7Hin10I0s9I0vQjfICO3XarUd4NhNmTCe2rcB wDnbd4iFC6+QEAtXCLAAgOPxteftj71pMr9JUcp96QEAytuIZfWxQ+HO8xJogXM1NtAi9D2KnTfW 9VCQxZR2KtAidQ4g9B5Ctf4cACDH2jTH9oC5cP8P5J6Hl/bQ9WM515bF9tWpoIvcYlQbAABMF7t2 Fuj5FoC9M8ZpGIbCsAOtusLKUkZGLgBInIAjIHEArsB5unACJiZuUcHYA7BUDXGal7iuHTtpm5D2 +yTLseP6vUZy3DrO+xG1AAAAAIB9EbPxVvMS6mg2+1CTyaURyDwtxCyqNiJuIeIT+pxOIlCxXMqx soQtpH5VCl/IZ+3+13m6Uc6/1GBEAtrYSwt7xxQs/z/Z7P76Du/aymBD3CJs8zjGax6APu+zErKQ erPN+h6dlHZF+CJ+DUzbWcd0ny8WTZ2sfJW8cmTTsghdnJ2Vx4d46jVUQQvEM4Zla2h2EmM8bkWG yO81aRU9Qo/PoixCFCJcoYUqctUIQ8RC6s8LMYuVtCnO6b7l/qCKfnX5ajRS1+OxmoeFLe6y9KUq 0YpE+QUtTO0MU+AiNeptoQtb1yO1+hFStX0JzUvpC/YBAAAAAADxXPTtAMCOmJvXY/8T1r0U5trs rjx5aPM5L5UBAAAAQJc89e0AgMFvlj4j2tUF7DDrY14ODgUG1/mPQtQCuuNGuYNZmSIWvrWCxJGU 49jM7c/5+j2W9Ym3vh2Ak0PPbe9GuW7tzzXOfOuKTQJrueY2gGPANb/Zx/uyw7gBgCGyq5CFrzzN 0m2WHtRavOK+lXcAANAV35Ht6n7z1v1f3aVfgC6Z9u0AgEUo+G6I1yw97sMRgAFyCEELn0h0W0EL O49Zw28iaOHbs+y6DgAAsTz37QBAQ9o+hw+9F9TkOXzdvB6a010wpwMAwCmyy76c0DNu3zlELqDk TwD2zh+nYRiKwy5FrExILEVdmGEEFg7CQC/AtbgDF2BjZ2VnZiTYxG6dh+3YaWn+9PukJ9vPduxG atIm9vshagEAAAAA/42/6eFB211bh8XisiEw4eNELHyrhSkqK1Kh1mIVTTGLZt6VjbiF6+P3d8cO MT6RgC7jVXa8cQfLH+6Y+z+/4zu37guIuEX7mFP4vs7E/OW+8E25qsL7xH8D1M98f/P49Zzr9OMz Y92aDUy/KVpxCuP3TApYrPv66Y7ZtQDAvpjyeFMca0zjpI7hP32XVxan9lBZwQqXOqGKuc6blW9H 1n9sRS6MsIXxm3ondvEtjuvKJ7r+fD7PEbVYarvR9qqaQhVr7Qz1V9jCtZHDy4WBfp3yfLHT5NfL PAAAAAAAbM9V3xMA2JL3gra5C9xDG8VCac4YbX4AAAAAgF2w0nba9yQAPN4Sdan/Zr5PBvKQvhyT QUvM+8/b4k8D0I2zRF1s816bIIXfJiZ2UTrmGFkpgtfB/nnR9mXzOc8AS+9RoYAYsX4yUAbAVNhm 8V7q3qoidQAAQ6ZEyCK+YaFZNmsD7q2Z/EXn2QEAwJDI+X+YCgAZase6GBgy131PAEAQ2hwcujaH rrFPCkELOFyeVf3cve23RSiNvT8OCVqkAlmnBC1idb6v8tJY8Gv53F/OWwlf7DwAAOSy1PbY9yQA CjAiV20Bd2Lv4WU59R4+dn+OiVnE2qlIfez+DgAAcGiUrFMtEbLoypTWzUILPwKwd/Y4DcNgGDZV q85ILKxM3AGJihtwBEaOwUEYu7MhdWbhAAxISAxMPQFjTR3bxHVtxwlpfujzSFbsOP4+J2rSOP55 EbUAAACAbLpeiBhGRc6AXMV9laHl8lnM56eFqIVeS1wLTLgiFzpthSx0nhKjKIUrhBGsEJ6Yhd0v TRlbXtty7eut3En7jE8koIk/afx1v1h+14+cYxEjGN/v1t6AiFtU++zvftV+m9soBCNkeO53eT6h eeE2v9zv6knooG2r7WajMz/Wa8+33BWxsHFrJFbvyUT/Ql2hi8nEr0DTy7Lvb6C2huYPX+PwdWhx Fv8Lt9a80ff77xNEidGYtBWicAUtirQRstiYsjbtqkzYMipf2joZuyp9Pp2Ki9lMfFYLW1xtw6so RStORFzQwtXOcAUupLPfF7rwH6LSs2ORYv8Sxi6tOl86FAaMjDVmAAAAAKB1Mts5TPCE/8B39SEF qYn3sQHtqcHusWNitiET2o4AAOOFcTwAvXLbdwUAPFZOPLetlNMWC00GDk0ojk0afvvDOQHU5Szz uCohC3+QUmgbKxvbP/bG90PfFYCjQy2isUrkpxamqPONMbZoRmgRDbX9anpCAC1x2YKNnI8JVYJP 9Rzy/QIAhkkdEYvc9MKEaxMAAOB4qBrLIjLy6vgC6JJF3xUAcHjPPC70rFSCFjct1gVgTDxuw4uI v0f47zH+N3Y3Hlpw2u8zTolZuGl/m4qH7Pv+q/q/Q+cYug5QE8YhwyEZQR/DXd8VAKjJkxMP9bWn 8nL64WNjylLjy1LiFv5/eU5dY/sAAHKxa+4AAECCHwHYu5uUBmIwjOOxFNzqzpVWuhVc6tIbeAKh B/BwHkLwHCJuC+6Fmswknbdvk/lsG6f9/yDMV2eSKW2Hkpk8hFoAAABgn+TDfS+2PDbtMJ/fbQRY SC54wvVnyVKFW5QhFlWAxSo5H5argItq/7KOs2SQRcz4QgL61Lfy9R13+EKuek/l/T3VcIvDf4YP /3kq6zW+3v7HCAEVoe3yHFLrymuGDraIhWQYv86Y7+XS/NodpyGAorlh1Yn5+aIOtRymRRHHXgdn DDDWQAvCM8ZV15jq6XIMOTqETnUIaQ8re7yJC6Xw0yI1woVbGN8L7oMtXNiFuxPOhVsUU79+4kMw 5HHD8rndfjWdtgm1uLXlwZYPsxlUsc7OMNvBFuE1unrdSS+3GbPdiabfJrldzwMAAADo7zJ3A4Ad +Iysq7tBvOm1se2ph/3bzLepAwAAABhiZstz7kYAghv4OzXItv7v1OY/V91AH20fSg6FUAsc0nVk ne4Ljy3reblvahorepv8fo052GJhy03uRuDkvJkqXDf13Uld4/Ry6nqVCq+o2/Y1+MyAfBhwAQB2 G2RxYaoQi3tDiAUAHJu2g6a3pQdfbBp4EfgvZrkbACiyP6zL7+erLU+7bQowGkMDLeSy7g/uGmgR m+8baNE08HXqHOQ09j4AQFeL3A0AOng35X1mdYb2w6f62+tK1/vRujxrBABDuN+Tn9yNAPaAe4iw E38CsHf3OA3DcByGXVVVJZjY2OjMwAmQ4AjcgStwAA7TnY2BlYmJK3CPCpk4tlv3Hztx6IfT9H2k qPm2G9GEpo5/hFoAAABgV7EvJ7F5z107Wi7f1Xx+VXdQbvv+1i64YrPOdpCFXebDLGxwhR9XarUK wyxUEGKh1q9+CPdvy7V99xJuIcvTrrxxhy+UKvdcju+5hVuUK/f4f0+2XOXK/c/WsefEZcjFJHhP 28+Gb87Z8WfOw3P6qrpQtIVapIIofHiFthONsIv1uNrfsR/afihvnGWdUjm5+4j1EKHcZ3t95jAh NG7aB1HU6RHVfHPjVLvQiroVnAu7MIEWJuQiTJnw25j1ta+j26+Zvp5O1WI2Uz/dwRb31fClmsEV sUCLMDsjDLjQwXwZdCFPjlrsx9OqeQhThzY1DwAAAEDTQ+kKAHuQasTe9r1QNh6Prd/24Fhbw/PU w2dyOQAAALAvT6UrAAgfHctzOijJGVIdfrdtkwrbAA7hQkzn/o49EeNyOvaa2n6MXktXAGfH3H/8 bFkeu8eYey3r6vgi1jGW7HQDAACclj5BFl3/7z8qG15hwk7vdqsWAGCk+nSgGGvTQjsXDM2idAUA oU8HvMZlNbxUw+1hqgMM3jEDLcJ76r/Ba06gRVeYRSrQouu36rb3GDsOANCXaUN2U7oSQA9vwXjs noQcTz3Pk9u2LLU8JygrdT2PLeNaDuCQvktXABBol43B+BOAvbPHaRgGA6hpVCQ2roA6ISExIsEA 52DiCJyAkaNwEgQTKzuXoFIlfuw6Js6H7ThuIW36nmTl33YLSZrY/h5SCwAAAAD4K/zBfdc6XXQd MJudtAQTPkZiYWKL+6mRW1iJhZ02IgszNWILK7VoktvHii3ax7u8LW6m35jD7ZMElJT3VZc3bvmC K3cXZATb939bdn6uXm45yC1yCQkpwrILm39bftH2ULTHmJh7TFVV+pr/oeaLhTqYTkXRe81JL4UW vrTC+2BOcmHST13cusnE1qnwu1/n3wzBBGWNpZzSfPxIFfKK4mwP5lyd1NeAZWu3kVjU63xxRaWX Tc84I7dYTmvxhdnvU+Trlvf1diO2yJBaHOl0ptOz+i2wiMktnMxCFi8b5v1tylsX+5r87XIeAAAA AADKOBy6AgBrIDUwNPeZMTbwTW6L5dn32TTUoR0AAAAAoJTboSsAIHjx5nMDpeUE9+gahJy77Umn 8xU+H0AfjnV6VWmhheyQpDqWZUeFWNBbmYdbJ+sh2+E3+V3FjSIIB/w/D958LJBG6H1iaJ9UEI1Q UKxQEI1Q0AyATabk3jJ2QRMA7B6riCz85VNlBRaXysosAAAAJCXPibF+MKm+M+soF6CEq6ErACB4 y9jHXSON0OJO8Y4bdpO5TvfKBrrs+j2RChbtlkOBp2OiiZCUIldiERNaxGTUOW3eoWnoewAAKIE+ ZLBNPKp+krjUb4RUO3yqLb7rmJw+bV1wbwcAgLHzPnQFABzfArB3/jgNw1Acfi2tKiFVCDGx9Qjc gCtwDk7BYXoGLsDEwsLSmZGpO4Opa1uxjZ04aUib9vukyH9i+zmRGjfxs3+IWgAAAADAIaQcfVN5 z00Nrdevsljc7jccN/uIKytcUZUJhSzMOS1GUQlZuLgEAhY636VNnap+3L4JVZCuvlcibvHXnrL2 EF/4H7vc34LaNkTcotmuGlzYwNg1YbPpUKQiDuO1I2F+TgTD2Z5Y0SIly+WdbLff8qMHixY48Qrl XczEpicuzxe4mE5dxVZ2Ans9cY5CDMewd462xmSnDzELl97/lvUz0aZ12xObvrK/60DIQoyYxd4r zuXr9C7uq0w40Qv9wFGuz7Zdnb6fzWQ1n5cIW+iFb+9SJmjha2f4AhfKy4+FLuKHporacdRtoJHb eIOJfgAAAACAeh6O3QGAA/Gd2EsWzqcWiKXicd0mB/jcuVw/AAAAAAD6Qr/XsfEJnBIfkl9wnHo/ S5WpW3ycW1jcdPjlPwVRCxiOa0m7CuS+E5RudlsighGfS7os1PTlFHk5dgfg4thIKNaUos3mGbmx KTe21QlbuANgzLRxwsuNdV0c+fArA4Ah6EPIQn/zedwdT2J8eW/66RoAAIyQzYH143fXIeG/N/QJ /o5wanwVltNzBQhawKXSJGgRzyHHYTx/nNpsulQ8OiVY0UXQImW3bj4gd225+wAA0IWVmG+JAGPh zYvXjYtd5+PbzMOXzN03HRLFAQAAAGBgfgVg7+xxGoahOG5apCwMzAwIqSs7jFyAK3AGTsINOAM3 YWFhgEsw0AmVuG6IY2w/56O20v5+khXnOfZz0kr5sP3+i9IdAAAAAICDxF7E8FCnG6nCanXdEZiw 0SIWJhh5m1pxCyNiYbaNiEW7tfOuza3ftB1m2LdMud3pye1TB4beZD7JY7iurV+ub0JtNXSsodzv WuIa5/8vtb7j52sHrDf5rnBFV+SiuzZOErgwfo29qs6226/1Oqnf22D3bjB9n81T9ndMI3Yx1N9A pmwr1V9OXzkFGQ7VVw4fJQUt/rXj5F21By1UYStILJp9j31p19ntn+yOU067Tb6qyy9OkzSG9YTZ W+UXsFgKdve07OQrc9WAQguRQ4E6AAAAAACgH+elOwAwklCgVB+pC8D6LiSTymJ2AAAAAICxPJbu AIDDq5WXgpLYtti7mLRQ2Be4JLSv09ugMwMYxmXAnhKI251KEBpH7xvke65j7HeKgF+Qnxcrn/J9 MXRM6N7lu2/FBJx8doC5MUbIok/9ud7vAGD+xOa1+p7x3fmwWsDiqU6fdfqo03Od7hWCFgAAkI70 rigFXUyZ+yLNuQHYF1elOwBgoecuficch6AFHDNTCVrExoVTBC1+VFfEwhW0CJUjaAEAc4I5ZDAn 3pUs4Ck9JzTblDF1aRw+VC92X4/1N2YDAAAAgD3xKwB7Z4/TMAyGYVdVVFYGVDExIGZOgLgBcAQm TsHAebpwAiYWLsHCiFg6V0qIkxjbSfwTmiZt+jySlfj3+3BLS7D9vVFR1AAAAAAAWmjb9NtW9hQa aLV6E4vFaSFqUQYezyrhCt3GFrIo66QYhRayEJZohRaxEH/3qr3ua49fXjMr346q7Hb2Qo05YMzv wW2q+RsysPkxzKu2y/xG9K6u3TuP97oOb3eM95K2LSrbqkSfDbH9aYpcuPJmX11nt1fCFklyUpR9 r9fiarn0+lr0swt0WU2wYmYKV6j7DmIW5s/QB0O/tlMWz5iarUOz04sohrBXoGflwMVnYaHuUP2u FnkpTJFf0+oqRStSmc/bybJil1yeV4IWsk6qSchypSwh28kPnUz5X9mRnM/n4jJJxOdmE3L7Jk8f oilckYp2UYtUGPocwl7Qr4tZZEI0DuVltXEUmWhOoWtqXWUAAAAAAKC5HtsBgC356mEMXwA432b3 mIP4PJMCAAAAwK55GNsBAAMZlOQ9ol0oUFo9EIlZ5gtc4jtkbI7Rx7MkQCxnnjrf2ndIkMIlZhHa 1HDIa+gvYzsAR0eXQBq+/x+GBJfq31uhQFn1MQCmQlexCwCAfSIkVudqJ/MXebrP022e7nr2CwAA poMKmu57DvzvM6IvGGPI3i78AfDBfkfYJ34i2khBi2eBoAUcJyFBC5NQgGrJNoIWrntXXb1/3YZv rdoV+NoVCJu/mQCgLx7HdgCgA6/Gve+7sa0uZo3etX+s61p8bIrxHQAAAAB2zK8A7J09TsMwGECd RIKRBcYiFlbEBiMngd6GQ3AfNg7ByNiFDbVxEtPPTuw4/w28J1l2arufFanNn+OH1AIAAAAAxka+ qPecp4e2DpvNbU1gYdASC70t01FuUYoqytwWV9hiC1m/r8QWdn/z3d0wHZBb1OPtq3jIF6aJu599 wfr17d9+v8/hcfuD3KLYUvZhxN62ZRZJTYJh5BVScHEUWph450X+tduFB1gtRG9t/xaF2EKILIp4 aWq3j9y3axVaIM9YV6w1xZlqrHK1iKSKI20Q5kl2zSBRSS50Wd9Q1eKKLN/WM+S03KLIhQxDmiTS qr3+zz3L86ssi5Fa6Mmzj3l6V3WBhU9uYWQWbnj3Qb2sU+Iz326S9W4ZAAAAAADiuVl6AAAj8N3e pMD3MlhTu5iXy3x9mtpwvQoAAAAAU7HN08XSgwAQfATqYl5A9l2Hxaaml4qbviNGvAEwFpcRbRIn hepVIHf7+OrM52u6Z/GkykV+AebkTZT73PNrOhaFFsOIWSyjqR7gP4DEAgBOkSEiC70Y84sqz3Hv Rh4XAAD8TT4H9O1y7Rh7vdvWh+tVmIL7pQcA4NAmxDVCi+sZxgJwamiRxasq5/j6zgvcObehZ8Zj Ci3c3Ce0+PHECN3D980nZn4xAEzNVjGHDNaDlsO1nUu788pi55K1iSxCx/Aux/ZQGQAAAAAW4iAA e2eO1DAMBdCfbVJTU6XnClwBOAIVPTfgMDkAFTP0FByAnhlKetoYK7KSH1mLk4g4Ie/NeLzrKw62 iGTpIbUAAAAAgF1IdcrTPOQSms9fZDq9WEotrFjC1hu6dcOmyMLuc/IKK63YFFmsZRaihBbSyCxk Nen0XQx/DPNuuBOQW7TjVU085BblYx7+2tq40sQ9lZi73Z/7x92dc/p7srHdZ9biirXAYp2nUF/x eJ6tzKLd93wwGC3n3zGpxXAog7qQqPQXoWMM/PTa+5dii2Z7a38gn6VAMEGsvmOVivEXefVHh1g+ Hep7dWFEUW7d3LONOGqoBBXaIrFoJBir7Wa9XtaWiVFznHm4VS5dsWIMc+zleCyzyUQ+82KL63p6 l25Ci6GsZRZacFGp7b7own/AVl46jkralzB2aWPbAAAAAABAZNZ3BgAK8BXYpl8aF2n/Jkx1GPOP i839GKFzUnEBAAAAAEpw13cGADxe1XKXgcy26XCc64Sc63Ds7/+op6tdPyjAFviDVbm2b/0SWaiN 281DA+DG5in5hW6H12mdSl3FU98ZgLPjTexgGim6lGG5si012FZqf6qOEuDQmAEafwqlhbwCAI6d riILf90s39bTTTNngDkAAChNl/rY1HmhutvcMsChQWoBx0as/tA8K43w+lEQWsB5Ukpo4SgltIhJ LFJyCz9Grm069X5y6v8tAIB9ue87AwBb8KyWu9ZHuPWubfShsjvXDu+X8SE5Rqy8z+UdAADgv5J7 vw7goPwKwN7Z5DQMA2HUSSsWrNiyolK37GEHJ4HTcBsEh+AGHIEd4gAsECo2TivHtSd2EtVp8540 am0n9U+rRI1n5qtLDwAAAAAATgo3QO9B203XCev19b/ARAiTUNwVoGiLW1ihCvvaFq5oC1u47ZtG 2MIVyNg4CdVV630+/eKVhvXZj0P3ab7LzYEnOYd1tX0efm1tv8e2vv3jCUvMtVS/pX5PVoBC7YlQ uInttyIX+2U/nrwrdsU+CvkMiFrszkxJqO+IVQSFLaqqMzH/sQpapMxt7P7oa1g/cxe08KmdNfGv JL5KxKI5vnZftS2b8mJ7nGlrylVzXNXU1ap9ZTrTdZfLJK3hK223gWHthibUS9MKtcWSbSivTkrm AQAAAAAAMgR5wikwJFGWFAyXE1QWa5PqpHMAAAAAAFJYKZsEEWAqfKiw8KDBD9r1nWak/04plpI0 xP/M9+SZAQzjvOd5IUGKUJtS4b3y3P3zKe+332u7Kz0ImBXf2l6dcm6iqdT7lSTa1CVk4SbVAChN anLGXP+uKd+bAGB+SNewkC+rsQttj9petP1oe1Y2rg1BCwAA6ENuYqiu5IqhslSPfwtMgVXpAQB4 fEXqTfzdk0LQAuaJK2gRQ/LP9f1r+whauAIWvyouaCEJXYTq/ATZsT1qaY7+GgAAjMFKsZ8Ox4N5 vvHWcYzkZ9blPxbaV88RpkrxP4uNEQAAYI6MJWrBvRRG4U8A9s4dN2EgCKDjIESdMnWqHCJSThDl FKmpU+UiuQA3SJEuh0ibk5CAvTBeZtYfwIvNe5K1tndhFglpDfbMQ2oBAAAAAF1pm5D32vRGq9WX LBa32/2ymHn5OydILAKl3GIvuAjyilJaITuhRV1mIUpoIZXMQmqSjBA3xKgfy+DF88cnCegTD7nF +WLmk1vkiInc4twxc3yfip3coi6wqOeKH/bpIvh+7ngYs14fSi3crJdIVKFFFgfnq/3CeI1VpP+U AoApihhyxJtirDHFGeK7XEgky1HHhToO7Y1qgy1iuylZxU5oUfUV6txeo6MMElW8u9lM7ufzNtN+ FFtcYckqtJwiFl9Y/g5PUmGNF9XGnKJgBwAAAADANUCxDJgCP4k+q3hpaqx3zkv0txLQAAAAAACG 4iX3BAAivhv6mwqkNSUF9002FmfMb+tPBnA8D9JcyDslr4jHSKK19q338eaQ6s/Fe+4JwNXxKfuE 22PWL70OeWtXSlxhFeGwWoCpcYp16NLWMgAYJ9Y1utXniSw21xMf/9vzEJMFAIDJExeG6pqQaP2O 9cYAXCpPuScAEGE9u7gRWbxJf+E1wJiJhRZtnsvV571ndL3/yT2hhSWviIUXKelF/J+9JbFAaAEA l8Qy9wQAOpB6vqxpjWx7j966P29Jqrw1P+ynYqXmy1oPAAAAkIk/Adi7n6QGYSiO49A63sBlx27c u9OdHsETeAVP4OncewhnXHfprkgbUkJ8eaThr+X7mclAUwvBUamUvB+hFgAAAOiLe/Pwa9ke2l6w 2dwdAyYkJsgi81pRhVOYoAr72IRY1Et33T5vmwnHKE7baysW362me1rx/CWEMBBuMeQ+l/G97b7f tN/P7vtNt5Sfp8OppCjy6ljNqaUZWlGv1wEX/tf83aZd7vdm/Xu3c57Om0uvTyy07/XnbuiF21ar xnb7LNx/6QETYwYyXOq+xthHX4EWY/ADLdx1P+3BT5A4hVg4YRZX1WObHHEIsrCtEWxhAzKcfV6X fTfrdcywb8v2KAzLD62Q+rXDkp7TQizkP8RMSAYAAADOcT/1AIAexV40lAqiStsITSKTLuSGJtKl jA8AAACIxYRkzM2Hsx4zyTimCHioSElbsZC2bfnjBYYmFa9qC7jQaMEWbeEWWlDGHD2X7WnqQWBR fjITahGiXUN0+1ILbmktdO4D5qrLuQ4ApqS9R5buWd2W7a1snxlBFgCA/0m7dyamWKP0WmAI26kH ADi+hD4CLbBkhwLV71kdaBFLutdWu7Yee31dC7SQAjBSAi388WbKMnS8ANCHl6kHAETyP4tP+bxd e68g3VcWCqWKvecsdv4QAAConXNuHOP/Zs7VC/IrAHvnjtQwDAXAB/nUUDNAQc8FOAwV9+ACnIA2 NSW3oKCjoKEOdwALR/GzkGTJTuIk2p3RWLYVS85kRpYVvUVqAQAAAAA5xCKFax66LrRYvMp8fv6X rwO11+MQI5vQ8dNtQHVzrBZZiBJZSEtk0cgsRAktZCWzaOQY9vrN9qe17zI8kHy/d6IlSBhKETCU IiM4TNlD/zmLw7zfvnVu//fUCCpkvW3EFu0y/gD4vjXg/69thBmGr+WyLbHoat/6OtIILZx04uTd dm4ycP+xCiZsfdQ1rJ5dCS02cY1dyze80SLUObtvt6dqO1kJLCarvBZcrGUW6pi1RJzquqSWXBgu plO5mc1SbuFO/OIKn6xCyylc8YXP3xGSVPjK+75CiRxnMTQAAAAAQJuzsRsAMJCPjLJdfyTX+dB+ 7uL81M8BAAAAAORiJIXXYzcCQGECd4YClKQs5HXHXikLj3MWLfvGeu8Z9wcwlKvA8di8tztv3jVX HhJa5Myp7yOPYzcAisME0bB9Wui9nq9vS+mHYmIKX78XC7IRCqABsC+k9DMhEVOoHJIMANgmIQmc e84ms/jsvkovVfqs0lOVbnfSUgAAKBFf4PQ+hN7N+s7FxpuMSWEMzH8dmRuDfeLb2b8UhBZQLkZo 8ZxQzn3uiM0Pp7w77xJZILQAgBIwQguek+FQeJN8AZYl9bmhS24Ry+vysbp0e0LtBAAAKJUhfWHu PMUm6oQj41cA9s4Yp2EYCsOmVFyBmaUrbLDBCeAESByBlVNxCSSuwMIhYOlQKSGu49S17Fc7oU7b fJ9k1bGdvOeoTVLbef98bAcAAAAA4CRwFxM/N+lu1w6LxbUgIrEtQmFS3SUjblF3ghZWuGJb2KLu xC9s2hzD7J8bGN627R972RrLO8Bwu/mUtmmD5ZcMLj6F82psTuPcDrfb7/c53G5/TvX71AWXd4LQ GyGKsEDExpezwL7m0xXHsOftd7lMcWZ3mSts4frmCl00zGYzVVeVGkrJ3/Kp2yspMlGKY+rTIfiq a/yrv6v2YGe6rTJE1ebXwhXNxUTn9eBq1YpdVE1Z165tc76+BtVGyEILBDk2L5qyy/lcfa9Wu7px 1aTbJn2qsLhFFSm3E/mhbtnk1imnLHaa3Ho/DwAAAAAAMvdjOwBQmNSX80Mv30uL4GPHlsoBAAAA AIbwOrYDAB4fTl767+WXSYE+pIDfqUG+pf9yP8oEg4uJDQD8J1IQCXcO3G6n5kOBd2OBeCWbh8qD YgwTyqID0b0L9bHxQvuZEkjDD5ARC5aVc98DOAbGuvccyz0PAMYjVTBH53Ug5ac2Pe7TKQAAAA8p 4GNsfYvfRqqX2qfux3M37JubsR0A8HAFh/Rc05tC0AKmSUzQIvXZILZe1x9PD42NhwQtQtt9BS1C 9mJzAX6//f7zrAQA++JlbAcAMnDn4qV7pTTfLs3Bx54Tco8XWnsm+QkAADBlvgrZyZ3ngInyJwB7 95PUIAzGYfgDplv3rj2BF3A8gqfwEK68iK56AFdewLUuvE471qEQkma+hNBSQsv7zDDQmCa0/sFC yK/srwIAAADsaYOHtbLnvobW60+pqpv9dhMs0Xxmqef6dkMm6vJmkTbIQrqAiu3W3d7JZmPLbaCF tGEWNhzDtG/Xu4PHKYaGYSgtHPesk/udf5/mez6lJbyvTZ/LeG9Nvyc8Wy7pdzRXv+f9ebKBFP5j G04Rule8OJjA3raj3/+iBVt0LcUCLUKT5LvhFibUoiz3yxiuPWBiypCDOQQqjN3PFH2N1U/uffVL C2efCudxqayrNsCiMttmEem+XrZ1zeImRnQJEm1/t1Uld6tVykt6ED24olDKTbeFU88vd7+u/WGV QH3tLZRI+cSRTwAAAACAM0od9BY6cagNMA8Nhvfrp2wDAAAA51BPoPiUeycARz3Q4Tuhnj+5h1vm lv8pdVNuTD7mRuTfIS8UOEHKRFaxa+Da9fPQOvS8WLtz9Zp7B7A4H852yjlF/3iWOpFGbIKslJAL vz3gGs39GAXgssUG9PtjVOulPg/zLk0A1psQaAEAmF4s1EITOger1dPWfW0DOdzn3gHAY0It6kCL FyHQAsv1lVgv5f+OIdeEQ+fWtXCLIYEWoXPzqYEWfZNfA8CYTAgvcAl+pDnHHtN3jT50LE4ZWxY7 1vvH/Vhfsf0EgKk85t4BYCZCn785Vi/YvwDsnU1OwzAQRgNUSF0gliy7q9jBEhYVcBAQJ+ImHIBj IE4A+66Ruil2Q4g1mnGcpK1D8540qn/jcdXKbWLPh6gFAAAAAPQl3Fz86OymqcN8fmUGYPdB0kMR itLWf1aKW9RiFj5fiVh4YQufrkUtaquvUfbfRhD4ftfofrZpDEHzxyLAcHhiBNaY//G97fcdHcP3 tBxzu5+nOgC9Hj89FKlYry3xClvEwrfz68B0erbJf69W3X2sRCuqwPlBvhK22IhZiLKuHKrARDUe Y41jnH2KbyS3FWlN8UFVkPgVsziWghZFoCARCGEcBflwzFNXdjGZpLg6c3Zb6AIWJw3l1pSsupiI hRW8g4PNAAAAAABxHnI7ALAjtENisXqtTVhmBaaT/VIPq2nXBAAAAABogw+keJ7bCYCAWKCS2P8v 65CxVmYdIm7TplDS72lTBOjNpcjLZ9opghSxOm2DU6r4xVCfrd87u8vtBIwKH4QudU3rEigjDJZh rV1NwbLCunD8j04zBhgOsbWoaZ0a6joGAMMktrdU/oa+dvbibOns1dnTzr0DAACw+WpuomLtS4kd Umy7l4W9L7AvZrkdABB8OlsUpaDFNLMvADlZ9Ohr3UsP67T75TEBC+21jaCFHFPes5d+y7locwQA 2BXPuR0AaMFbpK7pWXyhpGWbPmZdS/qmoe3BiQcZAgBojxVrBwAABD8CsHf+OA3DUBy2EnXpUEbE hsTExoy4A1fogBgRhyozG1fgCizcgAUQdGjV4qfWiXHtxEnb/FG+T7JiJy9+bkrs4DrvFxUxDQAA AAAGT9GLejb3ZRXNZi8qTSdZ8HUTDF2CjNtx0U2gdNm3EbJQmUDFcmnnbSGLXODC2NjiGHnduQ+7 XBdzfr0YzcZ5tZP381mfpv2a76jJIORtXNt2fHJtI2tQdecXh3Kfbnwe7+/JFbrINSWK4q373hff JBE2Go9P1Hz+rb7mc3U6mcQ0Iti2f724EbZIEpWkqVr3TMyiaX/46oevQ/nomviGWK2dstyv0p9l PYaIUIjgmrNNt/f+SvJqu8JOxC10WVbayXHZiq2tEpFsbTMFCRHa0TZnur+4GI3U+2JR1uxrnV7V rnDFSvlFLYw7Y2cv7nPFLOwBz+xfO/UY1mr3EoYubWgfAAAAAAAA9I+6L+0LZQvaQzaheqr6BQAA AACoy7TtBgA42AHAY/5vKnshOBSgpCiwd+wLx24bELWAJhnr9FPxHJ9Yhe+Yco65NlX8dWXu4rHt BsDgeLLyvrHL3V9k4xu7fEGwfMGyis4JjXmfFT8rQJ9B5AIA6lAkZGHnz3W61elBETQZAAD6SdG8 TuhYKDhkaG61ql+AQ3HVdgMAHC51umu7EQAd4EanZ50+ImzLgkOH5sN9ohNlYhX7Clr45uRVoBz6 TDwjAcCxmbbdAIBI5DnhzSqXjZuh3+JNPjaVrS2LnfdwMWtr3G3IFgDgUNCnQBf5PXL9Rc8FMfYw MP4EYO/+cRqGwTgMu1BRCQ7ASFm6doSNGyBxAMTBuARnYYEVrsDQrcVunOaz689x2oRU6H0kKyH/ 7FaoTZrYP0ItAAAAcAzZce/Zlvu2HRaLpRoi4QYRliEUVdnsShVu0YRZhCEWm2BeTuP960CNvhFu MWR9G18fAQz918l7W7C3nxJu0V7nof9PTX/vet8wtCIVYtHMV9VOonrDPuTbAAr/nsxml9vpz2rV oYm7NI3qWLIuEV4xEdttt5XrXenwBUSgBXX9l3pOPXxD3rlOjVBRJz646dQHWpzVgRYu6MJOXaCF u8t+7oMqdkkTMgjDhVz4zwF5x/3CLrueTktCLW5tuTP7wRa5cIs6zCLI0zD7N//lOiOWaW+TXB/P AwAAANj3MHYDgB7kBoJMDVia21Zbpg1YV9opra1uAAAAoIu54XoOp+Xb6IGDueuoeH1qu0NLfZx1 Ylm83Xv7SwR6c2PLh5/PdWbXwivibYwyTYVcpB5y0jrVl3S6H9rcVIMJA3/l04SDaKSkfgtMDYqR W5YLr9ACLkoH2gDGdDV2AwBAURpm4c49X2x5HLxFAAAcRvsNtlTbcy1djzP0PkAKoRY4Ja4TMIEW QOPJllfxd8mAk7n7vNp6+Zt7acBFSZhFSch03Ka4ranXBwBDcufHy7EbARR6O2Lf+HtYm8+dW2j3 1duebSsRj3EBAEOLny0ExvbVwzGOua7m+huBXwHYO3uchmEwDFtNO3RALCwsiN4Diat0Y+MMnKcL J2BjQYIzwAFYGBBSpbYksU0c139to/yQ55Gsfv6pPxeh2Imd70XUAgAAAABiuG6qXWV3sY5Wqycx nZ6VYhVFUF8d11vmq3ayTtZLIQpRilNIoQrTNsUsKoGLwpZiFkLZVf/V566Wb5KxiVsMI2D+KT6F 8tmay4GJEZziUyifrblE3KI1n8f8P+2/y62FLPYFLUStrdaL2G4tYQn1XVPQorCzbF7aP+t1fFQq gL2nsi5oMZmUYhe2sMUxf/z/KMTQhb//6GtIfvo+VjsihBahKa5hf1ciJUpRiFdodYgiX6pF5GUb Q8BiU7TJ8xtdZ7SdiEoxoqYuoUQwLrNMLGYz8R4XtrjN04tIE7Qw3ZkCFztRH4YpdGFfjHdWP5pQ UA1XeZcBOAAAAAAAAKAZDn1p33eQXQRsMx87yO5rAwAAAADQFMuuBwBg8Ryp990fpbxY7Ar2HQok YteF/Oiyjzx95ek88jsAmuDCUab3vH373CFsAQyfEIZth3z15ZnGQ9cDgNHxaNipwbZ8eXv+cs1b rrnNN//FgnAA9IGrPL226M819+l86AwZAIyD0DrarFvk6V5IMQvuCQEAoO98q8+UdW6sTSjAY+j7 oXM1dt8ATXMtWLNBv5h3PQCAnnEj5HP2z4S2sXVEyjPzVJGKQ1JsD9q1/+z7PayHAKANll0PACCR QhDuLbGt65yXcNihNrE99VDfIVwxLWwbAKANuObAUEg5g9cG3KOPjF8B2LubnAhhOA7DjRLv4I6l NzAx0XgFL6BzL49jvIArr+ByNrMcpELhT6G0dMpXfJ+kGRg+2pk4ME6hP0ItAAAAEEveoPdalnvf Bnl+1ww4bsiQCR1C0S1FU6pwizbMQoZYtMEWhQi2KAa31/tdyn8Jt9jPgPmX1qnqOherkvd2s3XG fT5l3UsHW5h6tT38PfXXl2EVdthFu9xMV9V2wyy6+69+Dvk5Hie1q3nzTFCGaK8OtDABGp0gCxly EVQFARPUtW5dqerYeqBFbz+qf3SXwRN/iQ8mzKIs5zrsIjPT+nn9fVZVgRZnEXZxVa97XQdm6Hl9 cJK97jflc7dZFhJqoW9KfijLp9m98odbmDCLTp6G6l8oIJcp1e/Yt98m10UAdDIAAAAAfc9rNwBI 4FQ/htyQ75ofGnDOt96UOvifFAAAACkd1m4AYPkQ01MHS/MV1zahg4n4bmw2vsry6HuhQAJDoRbS 0ADc9uUCdpBF6HquCxm2OOh3rqqBhYGl6ICmb886voEwQs5PMQNohex3a59hYC6ucx8AGGPfeeX0 W12eZm8RAADpXDpAdOx2Y9uGLAdSydduAADA66Us7yPLh67VDekbtn8njw23cK0/tQ966NH1OgFg Toe1GwAE0oEWp5HlY/f62PNj5+aY69JC2GNVuMItAGApHHewJ1P6J0L6G+iTgNevAOydPU7DMBTH X6m6whEQ4hgw9Ahcg4UzcJ4uPQErIxIbCyNrT9CqJHHcuq4dv4QmJu3vJ0X+iO3nRG0+HPv9EbUA AAAAgCZCL9WhvOdUQ4vFm0yn15Vz8dKZrwlll7aYfWa/EaKQnUjFeu3GXTELccQspBa02Nfft23C UtxiSBC36NPmdnAH8Jd0bo1NxC0aatdh+8o5jjWnbc3vyQhQhNbB+WtbDtNW4MLE7XFNaruxNqZV 7Ge10h2AK1IR6rdfxolP3LykmfMSR8hl7xxtjc3OqMQ35HCk3FxCjPiEFbSohCrK59M63wpaXIkj WCFmJt2mSJdlN2LELcpwV1b2ihGuukTVh1rU4n42k++0sMVDsb2LTtDCNecKXGzluBtW6MJ3wLH1 2rFs5fgUxk5tLA8AAAAAAADGgWbBfgrNwrLUgrlY/aZ8AAAAAIAuzIvtNncnABw+JL7oOLSgOFSm 6d3LdyTyl00awk9B1AKGoekaHpwqoIynhCtCdUM2/wuvuTsAF8fSiaccZvjE7jtaR1ghZ1qael0d bgAMge/YRVvexmP3PW0bsf38VwDOF42YxV2xvYgRs7jpvUcAAACnJzVHpuvzbmrsNBTXvDvz/A2n Zp67AwAAkORRzHh7l7m9oe+6mrH3ULovYemm56VQGgCgT56EcU4YD0svfYpxBO1anrbf010/Fprv lHyDBIAc+PMqAHLz1aKs5h6e2tfGFlwgvwKwd/+4zcJgHMdNhDp0787YA3To1I5de4T0cL1Jpc49 QuccwsUBwxPXDg9YQEDfj4ReCH/sRG8hAds/Qi0AAAAwhfyx/VFPT0M7VNWjsYmfHe51Fz7hwiaa Sc7bNpyiD7OQIRZ9sIUVwRY2ur8P0ZDlnt/MQrcNCLeYqzzblke4xTxlLv/5bu+znfb3mV9untv8 /yQDKi5DIfrwCmOMos94rIwmOKPf5vd0SlQjUT8fViHqZBPhFW65OBy67bvwi+hh9xswsXR5eyxr S+Vsqa7R45rLM3rRBloUwdQlSLSBFqWfN034xTkEw+0rwi668Is2GMMt+xOxP4/c1f8+lKUm1MIN vvFcT9/+8GY43MKHWci35EMs5CTXGfO/IUD4Mcn14TwAAACA3uvaFQAyaTu+aRq6+fWaDmmp42vK AAAAAHIc164AEPgS89oOx7HfW1MG/pbbjg2+COv2o3u7QLZ7xTZhB/lUg6RUoEWs06pm+VbuaVSm GWgYWIq7lmkHBtVcX8JrUhhYoRk0Kwy6GLpGAnvBoAsAxtKEWRxN8/3yZfbaAACwrDFtYFL7aNrB aMsD5latXQEAgMpbPX0Grw21sQ2f38aeEafut8fuv2vuyV+7F3/t2XKqPTHflQAs7X3tCgBKbpDr KYFXXvj9QL4WW596jj70bF221fHLJrIMAGvz5yP6BWPP6KuLLH8CsHf3OA3DYBjHX/VjRewMwMbI BTgLAxfhPF04ARsDCzsSA3MPACytQkxi/Nb4K6Vt2vT/k6KmqVO7kWhJYvsh1AIAAAAxoYt8oW13 uTeazR5lPD5pQyVcuIR9brhgCxdgYdZtSMViodd1mIWoMAtR+zXvZdnJ23V9/muEW2wW4RZDq3P3 x/fwju3690gIt3DcNn9M+Gq4xWrIhahyzWcxVag5439ec78FTbm3+TzdUD/AQrWx0gEX+nPYMAu7 v34MVkHABHX1W9em6jjkQAt/xohR+zduQil+wyzq5yawompDKWygxUhUYIU0PeqWbdn639Em3MJs t2VFpUmY74u2DmnbcDaZyOV0Ku/5YAsz6O9ZygItRuLCLHTARaW2+0EX/hdw5b2PVcnfQxg7tLFt AAAAwNDRoRZD8FlQJnW+1+Vc0O8MlxtYV9IJnnNRAAAAdHEqDEjGfjEDjl8KynUdXKzXU0tugpFY Pf66QagFduXKex4aBB+7XpDqO+s/2vVY+EXonvq+3De/77sBOCpfsjq5Vur6Xcn1wNwEW6mJtGKT bnWZRAsYEu5jAUjJhVlcSBNkYZbzXTQIAIAte41sX6ffS2hyR84vcQiu+24AAKDITb081MtHplzq eneXJRVoEbpOnwudLrkWT19gAH0zfchu+24EUOjpH/uW9v+Kje8p5YdZ6HsQdh6L3P5+2wBgG+hH gWOwqbHAOGLfArB39zoNw1AYhi1UIcHCzEIZ2RiRWBhZuQLEFbIzI1YuAom1KxMUh8TNqXvOcVqR pD/vI1lJ7SROERA1dfwRagEAAIB1yZuCj7HclHaYTq+WQiSkFGZRh13Ml8ItUoBFCrnIQyzaYIu5 CLaot0+lDrdogzQ8hFv045DCLYYOJNi2MIL++gxNn4N1SbjFYH0u/z79hUXMV5/zbtvt18shF9rz 4+3xf37q+s/ZTDYGJQmjbUtHa8ItVkIu0vvIgy6qgAvjh7pv4Qhj9bePfe1SP7t0rl0cyb9tsczL IkGiCbSYpPWqvgq9CE2ghQizWIRfpP8ZVaBFU/fdHPc4vj6fTLqEWlzEchvLW1gNsrDCLVKYhQyy SCEWssi2IOqSfMCAbM/XAQAAAPCQJ/bDh1JXGpDuPZyvHaM0kZ33YL9Vx2dTAAAAbKIKtDgb+yQA 4d1p8z53WROSaHX5ZCSlCUu8Y2rrCaEWGNJpKE/kk7OGCuRtcqntv05/Y9y/uAxMvoFhvYQ2ONf6 ndfuB3a5FmnBFN61LG/L90sTZWjXOe/8gW3kXbNK+wA4bKUwi7tYnkL9TBkAANiM9Tk4OEttX+C/ XY99AgCATk5iuY/lOasvjdm1lvm6FxSdf69cCpAuff/snZv1XgBgCA9jnwDQ0Vcsr4VtvDFl1nba a6tOyuel0MbiaPNTpHkvgrGNdnwA6Msm4y2APlmh3CXefQJtW++eQdd+cCB+BWDv7HEahsEA+lG1 K+IGDOyIE3CWjhyD8/QEdGDlACxMLByAqVtBoW5s5cvX2HH4cVrynhTVdpzYrdq4iX8eUgsAAAAA 6CJ3st1d34lWq0eZz8+9VKKRS4S4Q4ss2kKKWkqx3VYHIgsruHDhWmghXmTR1CGsTa7LS4Hc4m+Y gtxiLCHBMcgIypQpvsxiRU5WblH+O9x+dqUlFz7FvIZwLN2+tueY1+IMkffNRj52DcZ8NpMs7Afj ZRqVFVmEvGdauBGkGtW/FkyULu+/CRVKloXQwpRRF3QQ3/9mfdzVwwkrKp8ehBYtYYXUI+w+fV4n q9jLLVy6y+vT9ex3fTVzcSe1uFos5LVfbOGkFk+SJ7SYSSOz0IKLStqSC93hby+klTlPoFL7uz5a mz7WohwAAAAAAGNxMXYFAI4EO5AtNihehPtGAAAAABiX5dgVADCsVTh3YlDXPdjQxUP6BBdd57d1 1Gmhn/B5t11nvA+An3K521582E56FxXX3fZiwjYtNjDJHpealK/z6t9Gyb70+0LlADjcAhrrxP7U xNncNs22Xakt1sb1tYs8s4SpwcIMANOkT2axlFqOdlukNgAAAOV5S+yLjXWJ5Y2lDV0skvtRKMnN 2BUAAIBBOKnFgzRS6SF0jdvNeU7e9bzdHtsnuYj1L+f+XwIAKAVSCzgV+oQWXaTa29ScnyHYsTN6 zExYs0KkLbPQebvG2QAAlIRrD5wi32mzY8ek5v/+xvnhxPkSgL1zyWkYBgKoCxUSO3bsaJZcAIld j8AVuAGnYs2aE7DmHpyBkhAPmbhjx6bgVOl7klUndhzXapuPm3lILQAAAACgBH2z8LFNd1MbbDa3 UYmEyCx62cVuJLcYJBUirRCZxedIbiF5qTOWYvSSDJFolILc4n9AbrGs/Z7K+J6a3GK+/e78Z0pE ECs3FltY+WFZtgnriVhC3pcWH02ixRV+eU9gIeud/y5IXmQZeh2CCfa1kP1UEU1UHhMrgkVMj6PN ECK3WEu+W+/FFd9CCy++OA9kGN3ryotuzrwAo2v3ol2+Xq9zpBZNm+7b9Ob2RRYxuYXILLTIQib6 ddJlTq37GTZjyMKgG3pYAQAAAABOGR70hCVQ86H9WJC6WNlU+wAAAAAAJTRt2s7dCQBFdz32ESkr fZg4FXQkN6hIKqjJVD9kHvHdIbWAOty4QWqhickjUjILyackFrH8sd2vaFwfiBigFs9uCKiV+wBs 7NhiHcdSQbTCslQ9q93YfUiAY8U67lhCp0PaB4BlkpJZXLXpyfXnkJtqPQIAAJiH0oDQ1vWrLrPy ern0PzZT2wAcSjN3BwAAoIhL14stXjLqWucssXng3GSJLXLmnsP+WK9hvwEAatPdF32YuxMAmbxm 1vvL42qsrVSAIEtmEUb/seJWAADMRfdbxPwoHAu/EVpqcuYlAIr4EoC9+01pGIbDOJ5Ci8MX87Uv BL2BB9CjCPMmnmdHEHzlG28heAcVN6Q2Lumf7Jek1a5h2/cDZesam1icWZs1D6EWAAAAcMVuzLPu YztaLp9Uns9NqEQTLmHXtXaQRTeQYhNKsQmsUHWIhV7W626oRROAoUyQhaonLm8ey876EIRb7Abh FrutN0UYgXbox5dwi6nqbcItTAvqv61u2IUbeqHqAIvQvTV610VxUvUnX+pjtVLz2cwpYUa59H50 W7Z2kW0/b4ddZK126WAL+1r1vNQd1QQIz9ivuvapnn1q69B6xLt3TRBFPVJerevAitIJqPhNjDDP bZrEtymr3/U23CJzyijVjKq3R9bP81xdFYV6jQdb3FTLi+oXaGEH9tuZHO0vELpfCOj+I24OUXs/ Vqm2D6Hv0PpeAwAAAA7VWeoGACN4H1h+Fzftx744x3kmAAAAxrBI3QDA8RjZHjpHGjIJiTT5d6ys W790/ied9+lQi7vI7wWM4TSy3TeWbR+lm+t95UKBF7E6p/aQuH4cFx3M9BzYLl0rHDqJlttnSZNn hcpJ29y2SetAKrH+7S9i/ReAwxX63HqpmjALxrwBAMfCFzAcE7tOK5Ubep7JeSmmcJ26AQCAwXSo hZ7IWprcMnTdu8/1+f8uUhvc+qRHqY0AMLVF6gYAPX1Wy61nW6hvlfrhPos0zh4ae499RpDa4ms/ AKRwkboBgPE24r6kvtnd7vu5PmXow4/EjwDs3T9OwzAchmGDKiSkThyAZoSZBTFxBHYk1BvCLZgY OAUDQweGDi0ttmKTXxI7cUtSh/R9JKsO+WNToYY0sT9CLQAAABBLDrh71OWubYfZ7CoYIuHCLNzE 5TLcogipcKEVRVmvlX01ZaNWq01p+6LkIRkuRKMLhFv0g3CL8bSZt8v7G7G3fSXcwqccUrFVvjHg RY6EXK4HWdT/DvOwCXN+mE4v1GLxob6Wy1qohWxdHMzb161c58IrTN2GWbiQjVO9XI2I78sYQx9o axhtjCnQoq0N+RnQNBPFb4KEDauYuLr5uQ2/mCgxUt4G5bjtzeuJCLv4tsc908sm2CIi1CLT5VaX V1UPsgiFW7gwCxlk4UIsZJHrlCp/KPveJrm+WgcAAACOWZa6A0AHfIPdfGIeend1Bu0DAABgiOap OwBUvIl62yChtklC9i1NIRfVNkL9Mtz9w/fG3xjozrUuz4F11UeDfIEVrh5abnu4of7gUnEvPdX3 GZnKJyUGDuVF1PcZ7Bp7ftpElNA5LWZSjdAkGkAKl4naJfACGJemMAszkbEJs3g6XHcAABiMz8jt mq4PY7/HlfXY60+uS9G3+9QdAADszITg3qhywHTM/yp93Ffe9TjV/vj6CQCpzFN3AIh0rstD6k4A AIBB2eea2vcceNuxQvv8pR/4R34EYO+OchqEwQCOlxGyxBivIIkH8AQmu4Ln8MVz7Q7GFw/go88+ G5/2vAkbpZ9dC10HdMr/lzSUUmiHMyjQfov+KgAAAJgR14vJrrKnvgOt1y+qKG72eR20wqRdU24C WciAFIcAFmofuEIvXcnU27b5Q6AM1R5fty/XzzVkoIzx2+v7n2+MNuNMf1537Xdjujb//3k17XJ+ A/ZWsfdd0v1cx2zXjPfWwSrqdNyea1y4XZaJgBdy+nljubzeL783G0dXPON0mvJMrovAFfYk+ZnY LuuPxdWHMdHW+e1cQvCGqY/T10bqc+KaUSITv/t6vY4KsWiCV2TNciHK6u25LpfbRf1cmQgTdrCM Wh3U4q4oQj7SgzLBJ2TgCrus7YLYljvK5XZ7Qg6dd9V3nULVUc5AZwAAAMxFmboDwAA+m2Xs3cGu QfcM2gcAAMClWFXpNnUnAOFN+YMMhkzqMcREIqccwy63+6Xz757PBAztKqCO75m46sjL9eOXkjyv HgT0ZQrPqTuAWflQvyfRsrmuEaHXoq2V9wWmsINa2Pu79rP74+ovkNpU15VT3gUD8Df4/jaty1ZV elWH4IoEtAAAzNVXsxzy/ZiYiaCAVMrUHQAARHkMqNN1v7trwoPYZ8m+4/qeDfjqAEAKZZXuU3cC AAAAEELG98aOvfXdM2AsLzr9CMDe3eM0DINhHHerFImNAYmNrFwAiQXO0CPkhtyAI3APJAY6sLWF fJk4b+3YqXCSJv+fZOWDJHY70CqN34dQCwAAAIQwH1zO8vboOyFNH8qQCVvxcx1moYvem+EWxTlF QEUTbtG0/V7Vy5/WUodZHA7H+twqJCN20XfCLeIg3GI+fVb98v4GnK3OvU8zv3CL0znduph8uz85 L3xl5EWcBlzYaq5vNtfl2sduJ7oMnGsngyrEdlmcf72ueowcZlF1MewcwTmGTAzZ1yX1M4WgibH6 kdUpXO0vGaIOq0iK0AuzqSbkwtzW4Rbl/wxzu77uVb59lyQhQ03z9qTaARVmuIUt2ELvly/FFn6x cuyzvU3K8ncmMQMAAGDpbsYeADAQ1+Qy23Guoqdd51NADgAAALFlYw8AEN6N9dCiZ76gCVfRb1kU XBYBt13bVZzENTa9/0s1k6uAmO7FdldoheQq9GtbmtfuOsZ3/diK+5TZCP1iuV6NdVdBKl8RLb0M CaQ4Wprrc873mei6dwlcMp7hApatK8xiq6owi7e8vQw5KAAAJujTf0jv52Pktu9eb+h9Voo/I4Z0 7AEAAM5ym7fnf76m6/tGyL18eWyf35X5TgNgCrZjDwAAAAAQvgfur8/vFqH7MDO/ArB39zgNw2AY x6PQrLCwMHICToDEFbhBp86cqwM3YOAADGxMHIGpgpW4rhPLff2RLyeN/j/JgiRu35ChSUrsh1AL AAAAGKFBeLZd7I32+7eiqq5PS224hG76PsMOslABFKaZkAodWKF/Ss30swMw7KAMtU7XaetNhXCL aRBusZ6aum7+opd3fPuPfVxjuIUbUKEnoldNn1fMxPTnE9T75lp3cyX0RPE/h0P7PgmT3Tf1PP2b MIu6HbeXpVR8VLlDH3KGD6y1Vo4aYwVa5LC0YyJ+qpjPHGvZDrIwgRQmuKI0201zlpv+RZswIUXw 3G02xX1Vpez2Y3EeTHElrHPDKdzgCymzwxdSIfWXDmERWM9gaQAAAKyduuZ9mHsngIFSBuyHpAzi 9/0eem1swFzqJAIAAACAoib6ZkAylkTdi30k9PNNCuLbPlaL1XG3uz4T/jZgDLcd+kqBFLGwitCD S13q5vjf+UvdbjLUAZSvUwuRvsdzmxRM4S6nhFu4YRYpgRbuec/s43v6YQAuVsp5SToH9nkfANMK hVls6/Zdt9eCMAsAAJS/ga/v8nxKbAIoe710f9q3LhDyNPcOAAAGee75Oum53dCzuVK/0LVNl2sY rmsALMV27h0AAAAAHL+R7bF7eamPva7LGGDg6F8A9u4uJ0IYCsNwySTuwGu89M54YeKNe3EJ7sfE JU1mC7qOiUr5kVIO7QHKn3mfhAww0DIkiozlfIRaAAAAIMYdxPxaTE+xHfL8vgyckDRhFk2AgBtu 4YdUuNP1aurXn86r3acNxmjnq3b/d0AB4RZL9Ue4xXJ9rn9uq36Pdn6n/XzO73e6tP32n/3uFqKv ltv+utv3a9ZnYjH7LDuVrzbUQlPoXlUQv9nGD7xw1ye0ZhBD0x99zetnrfCGPbUT62Pv5yTz5qXp L0GiDrPohFXUIRfS8sm04Rbl7wl3uW77pli2wRYKeTE9m25AhRtuIQVbNOuljyOFXEjrpNNkhPd5 QBkAAAAAjksKtYgNaJs76G3oAbex7QIAAABaNtCCQt/Yk3PgPaloiD8fCqGQCoZ/O/OaouKhfmLH a10Cnw9I6db0/2etCaIIFeYOhV8MtStto+03BRve9LZQ24Dk3Zmf8n2edK3xgymka1noeqYJswgd n/YBXmBrU68lQ/sx7gs4Jk2YxYepxp4CAIDKp7BOOz4mVMjZXRcbHzP23pN7VKT0uPUBAABmsUHv Lwu0O6aopf+9fqwt/pYBsEd3xfSw9UEAAAAAni9vWVukUPvcrrvM/TpUfgVg736SEoahOI6Hf1uP 4MZ7OB7B8RLejRu4cOcFPIZLNi5RQxsawnvta6Fpg9/PTAda0iY4MqFtyI9QCwAAAHhtP8CLvXYd aLt9d+v1Xb32c5zovFqa9TiAIiwhpKIKrKgepSWUiwMwQlDGodb6dChMoE+4Revebsj5Y3khAUPq I9xivDoJtzDu7YZe3yk13KKZeF6eC716/XR7878Ul3Ou7Xd0/jj7fXVJ5Gu30wrJE+Ev4rbUtdRl F8vledmw/cqT9+cMfchd3y3WVVI9JQRN5KhHnGki+tyH9UMqxN9nfFWHUaQBFydpEsl6CLA4Bl7E x47a4EMtHjYbS7Mf3XkwxUrYloZTpMEXUm6HFlIhlZf+hK5lOz98BgAAwC17mroBwIj6DHqzTqqq HZeBcAAAABgbE31jbt6i59bzL+3cqyucok8Z6fhdbUnfh3/8NLwn4Brule3avW1rMEWfe+NzuCfu +znCm5DLh5ODcmOWPsvSX2mL9nraz1n6Ra5NAu19mTZxPoDpEGYBAMAw38r2PueFl46PAabEd0QA KN9LpnouGeerleO7EYC5eJ66AQAAAMAI0vHc0vhuy37WOvAP/ArA3h3jNAyDYRh2RCUkJgYmljLS CYZOnKackKswMiMx9wJVS9zEze/od+K0iU3o+0hW4oBjqxIKSR1/hFoAAACgi3zJ4L0s674Gy+Xz MWBCUwVPNAvay3CLdkiFLLudqbcHb2vbNMEYzb62qHqugILU/RFuMUV/hFtM12e+cIscfRJuEatZ UL/OhDgdr45pwRV2e/DqVduutdOr7c92GzGkQq/LgAtRCjHwU9DFTAMtUgUc/Pe+UvQxVqBFCnP6 TI7nau17xfYj9l14hRdWYcMsRKCFrN+Idsady9Xr896W9cfFImaodjGON+MHVMhwCy3Ywh1vh1ho 4RdF4Jj2MRnl57y8DAAAAADz9J2wL21yXOzL/Ux6AwAAwLmeyvKSexCAYO/DQouBd903mY66tgj4 kMW8hyz+HeMz8veAS92d0abve3C3DYVdDAm8SOHeEN6EtD7E/tBneDHXn73Rr0d9IReha5b2DDJm rMBf13e90eZzTTHHizljQDqhv+GNIcwCAIAYzI/BtXvNPQAAwMUeyrIy4z6TG+tc/A8DYC42uQcA AAAAtHwl7EubPxf6noJ7/Sv3KwB7d6/TMAyFYfhUalYYWZGYmNi5DC6Cy6uYWbkMBsTWlYW1NLiu T5xjx2lCSpP3kaL8OLEDiwVJzkeoBQAAAHIVv7Xnro42mzepqqvDXgiX8EEWv0dVkIULo9ABFtII rrAWf54OwHBhGaF/t27ue1MX0T9XOMGAq4Vwi9R4hFv83ZjL+N0OH3cZ4RauCH37G+9wXBptoXB9 aHNj6vALafWz27mG9+2264bC2iiQ3wqtiMMtMtf2NWUQgx+PsYaNM1V4wxh9XFrQRNc4o/Rj7B+D dSQKr1ChFce0iLo9Pu6DLw7LahUFYPhx1FK7Wa/lrqpKbvvR3540gyussAodThEHX+SCLCTajs8/ pUAHHy8DAABgrvjQE3PwnWmziqVa51jnxm3W8dJ9AAAAYAgKfeO/eVXbub+zrOOpAt2nFghPFf+2 1qlt69rP/fKV+DmAMd1n2qzXAlLbpW2lY0z5jLye564nHA/L9iLpYCava37S80Y8P1lzV8kcZoU5 xdfE+9a9AnNFkAVw2XJhFh9CmAUAAKV4PwZLx7uOADAPT2o79XxLMueUBN/y/z8Ac3W7Xx7OfRMA AABAD32eK3Q92+jTL88vID8CsHf/OA3DUBzHH1AxMDEidUFs7AyMPQJX4JgcgoGNtXMPwNKBuIkT 4z47zw1K0+T7kaIkzh+HhUiO+36EWgAAACAl/OD4Xi0vfRes10+HwAlNHTzRFa/34Rbu/HodBlxI G3Sx30sbchGu/XV1MEa3bS2gPvdwi+H9EW6R7m8ZAQyEW0y536WGW2h11EWOf+sdFs1P3aOz3e2i PiUfQBEEVBwCLaLAiisfaOF2muNt8EXYR6ExQx/G7m9uIRO+r0vp55Ke9Zz9hHe9bsIq4pALvx+G V7RhFS7cogm4uFH2/XX+/0fYh3NbbT+sVpZHfayWV5GjjI04tEJr14IstMAKrV2idd82AAAAsBQU i8MSaUXfUufl1rlrrO0AAACAxdu5HwAI/FTLp+G8VEFwre2UJVcgPO5fEsdy286X4e8EhroznGOZ mKRt5woBWQoAjfH9/F4Ib8J43DvsI9jP/ZDVUvwzF0xRuqSCLeL3W9+zMg6JKbC820pYitml2kuC nQD8v9SczI0QZgEAwCm2hedb5sf0janm7l3SDgzlxhGZ6wgA8/Asf0PftbEDS1vpOCBBGADmgDlk AAAAmKLvnuPa3LdUEHduLhzfL1DkVwD27icnQhiMw3B1hq1xb2LiDbyAl/AEbjzcHEK9i4fQBcmM 1qHDx5f+Y0Aow/skBCjQNrNpAp3+CLUAAABYt9yPkK+pina7N1NVN81ZGy7hgiz+Sg+mE0DhNhdS YQMr7FbXh9Ox3GTghXvuGJbR1n/cd89jCLdI1mAItwi1t44ABsIt/r/dAU+byw63kCEVzZFbPL6z vzJtkIVv7ot/Hs1+35Z/13W8J2qRfF84QqdMBl/I/QICLaYOflh60IGvnSnaGqudJfV1rnZ0jdei HZnwsGmu6dSITRNO0SkX5zLQQgZgnOoXwRZ32615qKqcbj+JrsngCl2mwyl08EUsyMKoY981309o IuVMTAQAAMAlup27A8AIPs98LjbZbazJa0x2AwAAwFD2z8gs8IiS2ECLr8C12ILbsqxv0IVe3Nu3 2Heq7lA/Quw1Qi0whXt1ngqj0PemymLhFSV8A7eBFixGh6nYQAs3huW8/4uNTXo8SgVSyPt0mEXu WJczvgEl0GNbHyWNUQCGCYVZfPxu74Z3HQAAnCP0XlaLvaeNLQYly5gfg9I8zt0BAMContW579tY zjet0H9JhwS6824SQMle5u4AAAAAMIE+QRc5dWGlfgRg7+5xGobBMI5bbo7AyBA2mJiQ2OAIPQJH 4I5cgDN0ZkVInciXldfm9QdtlETJ/ydFjowTe2pJ7fgh1AIAAAAaOYn41hxPuQvq+r4LnND0wRPj RvUu3KJt35d+uEVbunALdy5Ld10fijGeX7NJO+EW2Tss1O/6+9xLAAPhFmvuc7vhFv4m9dp73/56 GX9D+/Q74+13h/NzPmud+6UYk1rn2roxi7I7rPXCLkrMGfrg+qOvffQzZ9DEHObqx4p+5KeKDLmw ZgypsEpYxUEGWojACxducRhCLNy18pOraupuq6pkqO3LiM/G/MnYCEMrtHotyCKs10IutDCL3DkA AACwB7zsiS34Lmx3SVBFuDGqPC/dRI6FbwAAALjGcekBAIEPcZ7a9CysSwVQpDbuDjf8zm3ynXpW K13A4tp8FrQFpnDzj7axue/YvLgsTXCN9rdU3dRz6W3g7vvE9wRivkwfahGjvfha+tugFmwRO2Ih F9r3Xth3bqz8DgkAWAPt/8Y7M4ZZvMw+IgAAtuM0lJc+/6XWt6SeNVkfgzV4XXoAAIBJPQxHKDVv Fc6J5YIwYveNBV7E+geAtaib43HpQQAAAACKU75JpzSUW2ujzVOwZg5JvwKwd+84DQNRFIZHEJeB AiHaSGyDRSBlAXSsizYdG2ARdDQsAyjBE2eS66t5XMuWjZ3/kyxnxp5H0oRgew6hFgAAAOfLeiHw udTRbvfmqurqUDqFS4Qgi33tr2sFUIQthFT4wAq9+XofbCHDLGQARhOWceq/2bfLXRFukW3t+iyc PzbCLZY0Jp+tsQe3lHCLdpBFs2/qdDlkRKSeH0/d39J8l6zXN/tSNNQiotWbDr2Qi+rHAi1a78sw 1sihD2OGDyx1rDHGGCrQYgxz+kxKLtQ4OsgiJDwcgymcSosQ4RXH+hB8IcqXqk6OFUa/W63cfVVZ pv0gpiaDK3SdDqfQwRe5IAsn6l3imNxr3JgIAAAAAPPSZWHS1LHcQqu59pYb6LrOBwAAAPCLfT9N PQlA8AuCfxjOK/2esiwMrhf2Lv1ms4yj63Nz994z5wFDunXpxXdk2XKtOxdsUVqgJ3Y8VTcEH2hx PVBfQMlrvX0fXnf5H1+XMItYoEWsLhdyYfkeTM0VAIApxf5u3NTbS719OsIsAADo68d4Xun+Fnke 98dgTjZTTwAAMLitKueuR+UC2VMP7+dCMHQfKTxLCuA/eZx6AgAAAEDCV8/21msbsTaW9lyjOFN/ ArB37zoNw2AYhgONkDqwIsaqE0gMXZC4GsQlcAncG+ysrOzMzNhNQhz79ynnVu8jRSl2HFuVIC1x /BFqAQAAAJt5c/BFbY+xBvv9wzFwQlIFT7SL0jfhFvr4at8Nt6j2bsBFG25hBmO0r8dekJ1wi2Dr os93yLUtmj9dfwQwTNcn723iGRbse+x+3WfEu4EX7nwWd4H76phq8fvuebfb6+P+NxZqIQVX2PWe cAunjVRmjX/uQAv6GtbPXOENazpPrI9Tek9y+7Fn6v1vRsjFZf2zGV7RpERs6vCKTV2mX5d16IUZ cHFhtDX/0l2pstuyTBn6Tm1PReFkbNihFVK5FGRhl5t15ttRWPvYawAAAOCc6c+9h6UHAYzgJ+GY vhPSQu1SAjJ8ZUyEAwAAQAoeRsbafATqQsERsQXBpTppgfCUxb6lc/nGG0OoBeZy5ykPhVfYx4UW 5/G1j4VoTEkHN71O3AfQ0P8/fA/U51yzcgMoYtczu94XXiFd1/pNlgbWoc91JuV6NuT8APqzf+f0 Z703tX2q7Xn20QAAcJ6+B7bPmR+T8t1TCsKQ2vC9FWPZLT0AAMDo7tV2I5THnvnMqS8C9dKjuPY4 Qj8DwNyYRwYAAIC1+qr3KfcEUu5X+OaFh9r77nNI584ZD07YnwDs3c1twjAch2EbglRx6bnH7lGp Q3SBXliji3QChuili3SIShzbEhKD8/dn0nwR3keyShwSG6QKYmL/CLUAAAC4TbmTC3apE+33H2q1 2tZbl3AJE2Rxqv1VjQAKU0yQhQywMOEVZZCFCbmQgRdVWMbl/NXf5nYfCLeIHq26XC/Ob9H8odoj gGG4NnlvM45W/xnPme7/VJ+KCaGoaCfI4rx4vDbbZp9y9rsZEvp8XFHcnWq+D4dgn5ptNXZUdTLQ QoRb6Hpxeu12JNjWWJYYMjFmW9fUztKDJoZqw27Hd4ecHWRhEh7Wdb1MjVjXwRWN+jrgolFvh1uI tkwfHopCPW42OS/jyeqaHVwh62RohQy+8AVZyBsSTXd9+3xvoYrUcwMiAAAAluR+6g4APUiFWnQd SfQtHCfPl5rIH5vYDwAAAKSw2Dfmxl4QvM2kIrkt62MLfHctsb74+hrymXidQB+26ac4Yr91xxbn yQ28GFq54AZjkxjLu/U4NH4Xm9Qa+yyzgyp+EsV3jG8753MthLFHLEFOmFPouW2ObdsuAJdvwcfX Y/k6ljfF9z0AAPrkm1gmrxlzxkVj97HErj9zz5GqA7p6nroDAIBBvKjweF9uMEXoN7DQPFPfuXzt AMCclEHCfCcGAADANetyD7fcn5rLK4/jPrsb9ycAe/eP0zAMxmH4axLBCVhYyMgGE2JB4gjcgKtw Es7VEbEx9gTgNAlxXf/5ELGjRO8jWQlxHLuVaFTF9Y9QCwAAANjsB4OvpjykGrTt7TFgwqcPnpgW oB/DLbqAin57Gm4xBlZMwRan+2O7vs14ne8ii68TbhFtLWsLtyjbHwEM+frkvVW0lnWGW/QBF/6w Ct/cFvHUSWJfpK4vj9uvw+FsDH3XgXkxO7dfmUIurHN2VTWdnwi1KB36UDJ8YKt9lehjrkCLEtb0 nmj6idY7+7/FCrmohr/toIoxJaILsmjM50NthVnU4gRaDCEW4zH7E+7CHLtuGs1LaU15FDnL2HBD K3zHfUEW7nG7zn47xNmm9gEAAAAA66KdkKZZqM7XVnMMAAAA+K/WlLulBwFY9hIOFdQE/qUCLkIL eucKuHDHHvq+9xF4zcCcbiJ1scW6fdMD3DrN4juhPnI+M3/LeG3Ath9KjHsv0N5fNMEUoWCLWJvU fVOcfWAL/nrP8d27mOsFlOP7n3uWPsziXQizAAAgh88ZrpH6nunb+toDpd0vPQAAQDZPplyJLngi FWDh/qY0dr7mGVuqDgBKell6AAAAAEBAam5eR/PMIXZO7FzNHHbNeLBBPwKwd+84DQNRFIYHErdU NHSRWAcSe2ADtHRsKxUrABo2wCKo09GkgDjO4OurOw/b8SPh/yRL1jw8gyUUHMZzCLUAAAD4f6x/ 5lllT6kLrdevriiu9uc+tKI+fg7lPoiiDrGQQRYyxEIGWWy3vk0deOH7VWEZ1fVlcIYfb0iEW0R7 uy7PkqcXEtB1TAIYhhuTe5vR2/X5rmeKYItq3HodS3OTeTvMom5jtddrYsr21abwX5tNY9zoqhcV XKHrLmSAhTr+6hpdxgti8OMxVr9x5hCqMPZ1UmOc0j3pM475pq4IsvCr8RaHcp0aUYZYlCEVCyPk 4lK2l+EWaiw/h5vl0t0WRc6PdCemJoMrdJkOrdDBF1aQhV5o6Kdr1Vm30EXKWYAIAACAc3A/9QSA mbBe2rfqAAAAgDE9Tz0BQPkQ521e8Ik9Z+VsEJ4bWhHahC02txB5nc+WfYEuro2y0MIip85DbXW5 VRcbw7r2sTy6eJAHcEwv4rzLC6vW54wMowgFVaRCLtp8tqXmCJwz1mgB86N/L1e74313vDn+xgMA YEihwOFSm+fEnLbWBlC54Rc8s2IIq6knAAAY1IM4D4VZxOpyAixSoRj2S/4AMB+EWgAAAGCuvo2y 1GaCbcMqYn1CZYD7FYC9+8dpGAbjMOyoETMLC1NHRiQWJjgCd+Ai7QVhZkKINQdgBPePifPls52g YBf8PpKl1InjNEOjJo5/hFoAAADA8R8CPtpyk2qwXl/tAyd8btJ1P2zCD7zYbe8CLmRoRR9sIT9/ frc7hGL0y8MgjcXPSRDhFtHWhnCLWJ/5/5/XdG4Jt0i2Nj+9R5Tru/YhFf1l6dB3M1jvB1jo75Gn xrY0dp+r/dJb141aBw4uXS8n+PeDLUbN8o69+Y8hEzn7+kv91BQ0sWQfc/oJzTwhQy4aF1BxDLNo vfAKGWaxMiLQ4hhi4er8X7UzW3fZtlMOdfcS460xo4wNGVqh1WtBFtogxFH+hjhNoYk7GIQIAAAA AKfvJWNfvLQPAACAnHgZGafkw5anCduFAiu0urklNkF4agJyo2yj1WnbEGqBHGSoxZzn1LEAi9D+ Yuty2BboE3V6Nun7h1OuU6kQCnl9ksEWWtDF1HCL0PWO+42oSehaxbguIC85nvLclo0tr7bcFzki AADq0iXWa2NaYp+1tqn7pYyFQSnXpQ8AAPCr7my5SGwzN6hiSuBFLMQiNDGAXAaAXB5KHwAAAAAQ 8L7APuY804i1Awa+BGDv7nEahsEwjjtSujAgNjYQB+EODBygYy/G0EMwcBJmJAa6sHSB1DJx377+ iEucNv3/JNR8vyYSRIkbP4RaAAAAXJZQp5+0Sh1ovX41bXu9m3aDyPcDnvfzLoCiC6awgRR6kIUL r+g+t9vDwAu3nw3L6I+v1Sfc4lTqEW4Rrlc/fMHWnf+5tTUJt8jY25x2uEXoXe9mV1sPtPBDL/x1 sUuf/fzYbCJNUfZXgir+6jZeO7xpN980sp3jqxVwMPdaNWr8V6BFDed0TnLqZG+rzMsgCz+gYi/A wpi9gAs/PcIPuDgItxC1XBtu29Y8LBY5zX70muYHV8hlMrRCBl9oQRbyH7FrrrZOO4UmspwvIAIA AODc3UzdAGBkQ16mjw1uykv7AAAAqK0LtLifuhGApwu0+A6sy7knKg2xyBnYO2fgb9mOId4Gbg+U usvYRuvf1gbwMcp8al2ollyW6ltPWRqucajnxZsueYanXW9keEUo3CIWWpG6xsXaF3uO6Xxl/G7A 2K5GOi7f1wKmIf/2lr8/78aGWgAAgDo+C/aJPQ8N3Yem7ku1dTn7AMcg1AIA5u/ZHB9Uob1jWhJw ERpAAACm8jR1AwAAAICIWP9FaUCFXKZ9xt791fpH6MO4QD8CsHcvOQ3DUBSG3apiwoA5ow6ZISQm 7IeFsBK2wgAWwBZg2j1UxFiOnZvrR5vmofT/pKjG5GEq2kDj3EOoBQAAAKz4AuBrszyVNtjvH/4D JmK+yLkLnjBtiEUItggBFzK0IoRbdL/267h9hH3Zdq6w+tpDCgi3GMfaf2/Ccdf/3LpjEm5RsbVZ arhFHE7hmmG+ijv2ps2UCIXvtcCIsF1cIN8+Ho+u/XM4lAbTLr3i93Ff/Biv75ftdtIgBjcUjjX0 OEsLVcjt41qDJuY6jv5Oo4RcNK/9NkkiDq4w3TCLNmlCBGBsTAi5iP9ov2n67ne7mqHaghUvphtQ EYdbaMEWvl+beKhNMOzlb4inKVXMQ5uICAAAAKzF49wDACaQmpQm23Ldc27AP6XQHAAAAJDDzchY ms+oXVNM2/edEkCRKvadKwqeKgSujWOI34HbAzVujR48IdWESuSK7aSugeeukV/yuvnbhfYDlHyZ csHP3PmpdO6R4RVykecx+b1cOEbpHKe1477vws8NTKEmrMlibhawbPI1aosJfzTLe7PczTIiAACu l/8ft/RZ55B5LbnPdIE5EWoBAOv3bEJQrrxmpd3reU7oRSq8QguzSPVpbQAYG/PIAAAAsGSFwng9 Y9zfW7r3l+scV+pPAPbuHqdhGAzjeCrajoidAbFxCCSYuQRIHIhzdOIEXIGZAzB3hBHsgskb9/UX cZo2/f8kq3E+bINaIdLYD6EWAAAAxyM2UU56TDW0Wr008/npZtstGN8ubt6td8MtXFCFH2TxpQRZ tOfZ635eu/35/WumHlJAuMUwpv6+afvdeZeEW+xtn/9/BnaIn9UFVGwHVcigi9km2MLVvRbENaGQ i+bv+vf1WnbefQ2MrxNkIYvYN/OO6+MZDiET/fs6lH4Oaaz70k+f95K6uoQfZGHK3IZViMAKF0zh tk9+66GAi875Xl9uDOeLRXO5XOYM+1oMTQZX+Pv80Ao/+EILsvAfMnTD1Y5pv8Imsp8HEAEAAABg XB+V2yt5EC6nLQAAAKDUmSn3Yw8CEOxiaW+BY6FFtbXJQbnBFiUBFqF+UguAa/UQex6Lg2MXrgL7 c0Is3PHUgjyxa7Rzan8f/mDKReU2Ac2nKc+iHvsbkJrk6odTaIEWsQCLUNBFnwALYKpKAptqtw9g m/zM2HsVT6a8mnIzznAAADhqpaG7uf/rpibrhe7v5vYJ1MI9RQCYPhtocSfqWoBESVhFaj6q3G6U 633cWwQwptuxBwAAAABElH6H4cS+b2B+L6r4FoC9+8dpGAbjMGyiTnADpoyMDCxsrGwcoZyAK3At di7ACbgFSF3AruXguv6cL/+apLyPFCUkTmxVlUJjxz9CLQAAABB3/j3b5a5U2AVa1PXNPmAiFiY0 98ETcZCFaZY0zOI43CI97sv48+Nr/XSeRP3cQwoIt5jGuX9vfJ2EW0xb59q+t8sKt8i90/03CX0u qOK4nByQ4e4nfv292xVDLMTWJeeESfIP9od9VeX3L3yy/qXXdap6lh6qkF5namv7TDT1jHatZLsZ bVdVTV1VtA7hFS4lQgqz2K+TAIyLaF9Tj/3bBWdcbzaaprpB5vfmMKAiDrfIDSQM+6UBh9JgxPjj MMm6bRsAAAA4J/XcDQBGoB301nXiurRs+nJ+/weVAAAAQNl27gYAifeW420vDmnDKaSJwTXBF2k9 mra2lYmv9aE4DxjqsnBM6q/WTK7TFnbRtc4hXie4JpDzZnwok6OZbFNzj+pyD9NeJ5xXakOurblt YC263H+G3osY7wX0k/6v+GSXT7u8zNMcAABgfSnL9Q2c6PM7VAq5yD2j5fcrhniYuwEAgJN5tMuV yfdnSeETpfAKzWJM/pmk1Kc25vNLANC4NYS8AQAAYNlCH4amL0La39a/IY0Xl/o2NPXiH/gVgL27 yWkYBsIwbNqqS1izK+IanIAVR+iaw3EFhLgEN2FRCUjimjiTiX9CG5P0faQoNEntUQVEENsfoRYA AACXITWx/jmlsdXqutm7xeHbhcy7r7vhFm1Ihd3b4IrD4bsXZOECL+q9e58Ny2jbl/2nWnpIAeEW 57H07xvb5/Sfa6l+L+XzXUa4hRZG0S5675+zfYbWSO+Pb6nvMU4TbCF7F+EU4mSkdBtg0YRZ+IEW Z16wf6rgh6X2Nad+5hgAsaR+ZCsuZKL2G0JhbCrElfFSI0RYxfr4eijgonO96MvVcLvZmPvtNqXs B9MfTLhWjskBhjL4QhuYKH8Bu3K1c9pHaALHGYAIAACAudqVLgD4B8YsdpoyST+lfQAAAECzL10A ILx7X49Z/Gxo4tBftlDbQ7XIczneMq8HxshZiCI15CL1OXiszVPYGxbbwDQ+jQ21GBILhYhNhP3y 9rmbfH/KvSxUKzA3pxxjlXJvA5DP/5naVdtrtb1U202RagAAgPOhHIsFR6SGS8hxL0N/F2vtMmYG U7grXQAAYDJ1APyjOKZNyvfnjWpBFf580pyQC3mtxP8iAZTwVLoAAAAAIEB7fqGJPU9w52JhFTnz fQHzIwB794/TMAzFcdyhElKF2BBzRzZmJmYOwjngRhyFK3AA5k4VkDRx9PrilzhtEpPk+5Gsum4a WxX0n13/CLUAAABYNznp9+rKFOlWu91Do81vXl4GT8ggC1cXGWbhwy18iEURbHE4OFH/rQIt/P1P 60NsmL70kALCLcax9L+bss904RbT97mOx3f+4RZy435rfYzrOMa23d4eL0OhFvUIrE3wfbsPFxAl 84EW4pj6XCNs3j9VwMHS+5qij6ECLaYwp8ckZT/1M04VSFE/O4n/+ytx6cMripQIK8zieKkCMDLf VrX7vq/z6/ebTcxQiw0sntxpQIUMtwgFW/j20MLD0KLDRv6Gfpgi6gAAAMAS8P4Wa5R60VvMZgEA AABYt2Jd1GPqQQBC8WOjb+M2ayMz3dYWQiE3+Q5tGH5JCY3lXF8X3BeIdRdoy1S9z3x2W7CFLlYf oXGc632AcwAxPvKyr+qx3+e1lZ9AXb9+6detrkCL2Ne90FhDdWCuUs1VMUcGNOn3gG95+czLc5rh AAAAZW+0x3w2DAVQtH2Pap237+dQPrdiKMybAcC6vOTlxvUPoNBhFvIY/XtU6zyeNaemb9d1ABgD oRYAAAD4z6z5i1hdcwnWvEXXuvDYteTMZSzcnwDs3TtOwzAcx3HT15CBHoCBcgP2XqachPP0CAxs XKTsDEidEXnb+ePYTpoX1vcjRU3jxLYiaJTU9Y9QCwAAgPiFJtW/+Co6n9/VZnOfr1cTwetJy5vv m+EWOsiiCrWogivkkpUVIRj6uCIsQ9cv279F7CEFhFuMI/a/m6LN+M+rbpfzG3C06vuMqG+7zZAK 87VYL4p9Y1eUKDfzJO7yfiXJPn/3db2Gdsy7vQ6zqJbV6u+xA06uP1XAQaxtTRmqsKR6fG38p3My VzuNT6UqzKIKslB61N26XK9TI0RYxbp83xZwUe9fbrN94j1st+pptwvp9tHomhlcYRtAaDYngy9c AxKVsV21lMlTaAq9fwEAAACW7jB3B4AB+Qah3VJn1x/r+wa4MdgNAAAAbU5zdwAQPoz10Hsj14Tc XSYMd03ybatP9mfIe69LunwPWB9gI0MtQr+DtoVSyLI+34EP6ZQujyO3AWSyIKY3R7ntOiGvKeZ6 yDVLBl2EBFf8iPZk32x97TJRKRADxmcB0zH/t7KwzSzM4jVd9vN0BwAAWFwcZUPcC7bdn7qev47V F0B6nrsDAIBJJUqHbLoC231hFrbQC18ohm2ReEYJYEoHRcgbAAAAlu3Tsi1kXJxvH3Nb26tt3TUG z7UfIvUrAHt3jNMwDIZh2K2qDEzMTKgbEisSIzOn6BG4CZfoAZi4ADsS90BiZOhCmtTJb8d2/rQk Bed9JCtJE9tRhAhNjD9CLQAAAOZLvuzblOUudfB2+2rW69sqYEKyE5XXwRMyyMI0RYZZ2HALG2BR h1nU27tdG27R1nfXx5oIPveQAsItxpH7z03dZ/7Xte2X66uobcYPt2jHwchgi2ai+IU7XkVOvu8G YXTHrnSDMowpiotq+aUNtXAbbMMr7PZyKXYvnHUn6OKX5BgyMWVf/6kfgiaO62OyfuS2LOL3k91u EiMOIRWxMItqKQItlnVDTju2v6LcvlqtNKd7XZZ74wZUyBALue2HWYQGI4YGGNrP5eUw3rJvHQAA AMgBE8khB6GBb1pDHiRqJkbVDnoDAAAAYjbnPgFA+C7Lm+K42GTgxvs8FVCROiY1QfiQ8/CPG2Jf 5+OIesBQN4dl6r10KKAiFmYRaitWL/Q+PDZZT19Ihu9JeRxwqhexrnmGFwu20IZZxEItQvtj97rU PU77HBKYm777D+O7AB35d91lWZ7L8m6YJA0AgL/os2d/atIm/3tm6rlqrM1YH3w/xRQItQCA+Xk0 usCJUDhFKNwiVFJtGNN9f5Z6FwcAY3k49wkAAAAAPU75314rNnbP3yeXofpAx48A7N1NTsMwEIZh Q3/42bBhw5p7QI/Qa7DijBwAcRB2SKhb0qQmU8eeTEziiPZ9JEOCm45bCVDjxB+hFgAAAKfNmlD/ 0vdEq9VV9fWm3vaLvrcLlLdhE7614RZtkIUPtZDhFT7cQgZeyP0mLKOtF9YfW/nF5Qm3UI52hFuk 6hG+MG1d3l/D0W7acAv9upR0eMWFWMS+e393U/c4HGOxuK73v3a73rGnFsf3YRVhwIXT9v+o1GL9 p16rRI2xAi1K+E/viaVOiRqXQZ2jIAvXTYX4TY0Q4RZ1kMVhvxNwIYIu5GNiV+s9LJfucb22DP1J DC0VaCF/HnspqZCL8A+wP/8c65PfQ9bPMQAAAACAaX339OdeqGa5ad8SdAEAAABYbat2N/cgAOFd 6bOG+sVuLsptllAMbRxDxBZ5exv4HECOW2cPlkj1ycdoQRfaXHgq4CJnTnzjWBgZZexvkNXCmGLn 8nL+F6UCmGR/Krgidqw2Hhdsh68DQIOQC2A4+XuxqdpH1V7nGQoAADDoC7WI0c6L5iwK5Xr6+LyK KezD15g7A4Dzc1+158N2KlwiFWARu480p8naIctcHgCMYTv3AAAAAIAen0qf5VpzrU+buxg6z8Ec xpn6EYC9u8dpGAbDOO5WhYULMBXUmQExMnEIDoDERbgBp+AQLJwFdWfqDk3ipHlrXn8lpSbw/0lW nDT+UCVE06R+CLUAAAD4n+QNv8eq3MQarFZXba2/dugWJa+DJ+y2C7Gwx+rihlTIfRtqYZptHXQh z7Ftv3b91P0ea9H3MovLE24RaG2GXLNOLyRgyHiEL/zsuMcfdHrv77C/z5xxbQ6E/vtxe1iGVPT7 +3V3Ef2+Pp+fNNuPzSZt4jKkQmxnct8pM/fYSMcKOPirY00tVIGgid85jjaGtkLFXshF/T63211i RBdYYZwwC/e1tu3cdrTXTzfeabV/vlikTH9ZlVvzPchi5jkmwyy0IAvtIcTuuHw7jLON1QEAAIAp uyw9AaAQ30Ns2jm+tinnAgAAALkeSk8AcLyKeur1UGgx7lA4hbsAuLYguAn06ZvHIb0fuD9As/Qc zwmx0Bbc0e6Ha+1CYw/1NLI9kOpF1H3f96V8J5gSZvHpKbE2Wt+h/2fAlJ2VngAAlfzcVy8Q/FyV t6pcFJsRAACIWYt67NpxTBhFStBi7pjAWNelJwAAKObehAMtfOEWvt+War8xzQ2+MGb8fTMAyHFX egIAAABAxDryuvaMnu8eRM6zfbExgMZWAPbuHKdhIArj+GRRChoaKOiQOAUVvgGXoOdkuQQXQHQc AlFF1DgejzN+fh6Pd9n5/6RRHG9viESseJmPUAsAAID10kcAr3pr2tHx+GG225ts2g1Cbpv9/VGe Z+dfAi7KQRbn8AobZmGbFnjhtpVhFpea6w63mLYe4RZjINxiTTWn/2xt3aV9vsOGW9gB4KvPe5eD K0JjoG+KQfr9gef9/dqam/R1l73/PZ3iO13Zp9J/N4i9v7587WCNIRNT1lpSHYImutUYu45WQ1Ys BVmYaipEkRrhhVtkQRb5exlosctDLNy0W0e7a+9hvzdPh0PMn/Lsda3I2DD6zYR+ObmediOi/IJ2 56C1ZdpHaALzuTERAAAAS/E4dweAkbQ9Eag9nF+3DgAAADCW80CSr3N3AvD8mPoHjbSHhrTgCW15 aMDwtoN+yzra77ohH1T66rEtEOs+sCx03brpmnZT2EXbmrGStL303AcQ4ztvIfL4EXMMigldagq4 0LaJaUZMG9PvOAZMrS6oaUgypEnOC80HrpH/f5Ck7TNt7/N0BQAAtPAXuZ523lRbFnOuNWaetn9g aMncHQAAzObO2GtM2rWtULhFKMRCrtM2xEJO1y0DgCEkabuduxMAAABAQJ9Q7rp74kL3y3WtwTWM K/YvAHt3c9MwEIRheGNFVMCBQyRAtIBEGxxSAHRCB1RBExzohhtSWsC/Ybze2ZlYxg7mfSTLzsbr XSwiCzL2R6gFAADA/yO/xHsul3urw253V4dLSN0DyKvgiX6IRWjDKEIvzCIOt2hCLUK9roIu5D5N 358wiy7gQoZbzImAgnMbb9zD8/nd+a0x139emzEJt3D2DmP/zzQcN3+v9/GB8Zu4NmVIDZ6ox23W n4dD7gDJNhleEeJt2VbtWxTJoA2vuQIO1j7WHGNMFWgxh790TjzjnMMYqcq5XshFG0rRreuEiCjA oguuqEMvRIhF0YZbFM2BjsctxHgX5eur7dbz49yWy0MYBllslDYZZuEtNOza5ekI0draBgAAAACs l1Uc5y1so/ANAAAAlqelJwBE3o33rRuGvA/sTj34O7ev3I7HSc0n9XosQi0wh0vHPnHBkvW+to77 aO/l2i0vI/sBp3oT257rgHWTbOq6owVZaNcvT5iFNr9cOwAd9VyArvt8VKGar+XyUS7Xy00HAACc wApxtHhrWlJ/K3vrZrQ+nvGBnJulJwAAWNQ+6Pd7pu4T9QRdaP08IRfW92kAMKXHpScAAAAAGL4m OEauhi6uSZfb1ODB5VsA9u4Yp2EYCuO4K6KOiJUFwUnoUdgYOVcPwYJYEQdgY+kNGCltU7fPr7af EzU1af8/yVKaOLapRKsmjj9CLQAAAM5T7sE46dlqaD5/dU1zvdmWC463C7y73X4fZBEGXIRBFuvw ijbMoi2xwAt/btveUi1wvgzGMa6F3vv0Vyeg4NT9EW4xRH+EWwzXZ71wixp91g632C8gPxE5EXrJ +H2whayfn8dyuP21WNiD84vSrwMqgt2TXciFXLhe7pcBF12dKuDgXPsaU6jCKcc6lvfkv/Rj9aGP BkEWLkyFCFIjdLiFD7XYBl34c662IRZ+W7alP+1um8Y9TKclf9ajGNpuGO5wMqHuTteLTUTUH8D+ OnTsWOwtdJn9TEwEAADAGNzUHgBwJD8Dt9/lYfvUQ/sAAACA5an2AADlQ2yXLHpmldJ6pW3o9vRY SxYw7+PtCG0AOXfqtQ6viN76T9R1Ln3fOzdxKRWa0fU++My19/yBob2vyrdRp+S7yAqg+M2U2PHS dlPfeS6zDYxNLowpVT91bmk7Vj3md+FSyP+h2ap8rspLtdEAAIA+YvNicr8f5XHrd6W+nhq7vqq3 S+bRMHcGx3JfewAAgKrWYfD++dLSUhJikTve9eH/PtcuAaDErPYAAAAAAIM1Z8+zgidkPWsOea79 kj5wYf4EYO8OchoEwjAMD5a4cOXajUnXJpq468a7eBJv4FG8gUdw7VI3XXmG6lCY9meYYQaGApX3 SQgUCjMhVdLyMx+hFgAAAMsib9496+kxtMN6fbcPl5DqYRa/jTCLMtBCOUMriqkMtVD7eRF04XqP GdT8eHz34OpLGEh/7EH0pzqnCXurPt91+eycqs3/f17LNpdxbtPbTamTzXS72SGwwqyTlzLXtnqw hVLN2pb68m5Xvv7cbkXTjtoWEWhxeH1M2ohf13HwfUIm0ts6l3bOqa9zaWeMz1KfNlyVc7WQiyqU wsyLAItc/29ZWUEWJujCBF+sqvceEiKqZXMc096lfn2T5zFdLQbs2KhmkEXmWSe75is29BUiytOh rHloGQAAADhH91N3ABiIr/gt5iH6tm2xPxpS6AYAAIBUD4rvaJiXDz39eLaFBjCz14cGBe8ymHjo QSXfwG2pZBtfAxwPaHPVc7+2QApfsIVr/yG9nOCYgMubWO7ym6DZ7rtW2det0PWsa5iF3T8ergWa qM0C0si/oVc9vevpdqK+AACA/r4HOIbv91p7m5y79gfG9jR1BwAAk5PXAtf9sAvPcpcQi5hwi7ag CwAY2rWilgwAAADz53qu167dbrvnEHNfwldnF9onpqacex8L8CcAe3dw0zAMhmH4b6m6AzckTogR uDACI3DlxGRdgCMDgJiDG5dIVdWCcVwc89txkrZJk/eRogYnsd0IFJE4/gi1AAAAGJ/cl+Ke6ipa rV5lPrfv8fmTmtvJ3KWyuOAJ82nCKTabbSXUwoRX2DALu7hwCz/MwgVY2GUXhGns9v3QTGEi/bGH W3Rvr9270vzuHKvN8Z9X2+Y0zm33dtvPZWCCLaxYwEX5078wC1H2nXkT1M8q9X8VhRTrdbXxnIns YyEW/rFemT+pfbra0wY/jCnowLVzTqEK59TXIbUztDbCvStBFlJNhXCpEb9BFi7cQv6CLFyYxYXb ryyfK+vaqL3LxUKul8ucbt95Xdt3IbEefhVtwGFYJl65RLZpp1AS5QxMBAAAAID+pW745QyQC7fl 7NOkDwAAAIDx2HcHgMCbt547gVndZGh1S+4k4GF9YX/aD/7Qv1O4/nGguoGUm/Iz9cw5FV4R7iOJ T21dqyfWfmz7vTDhHE7jReJBTE7u9chIBS5tJS+YKQy6yLm+xa5p2jowVYzFAppxfzMmSPP9Z3nu sS8AAKCb1P+9bca+aGWpe62xfZj8Ccd21XcHAACDYJ6b3Uqz0Ant/dFYyEVdKEbTZ2vcxwRwCA99 dwAAAADI8NnimNQzh/C5hHZMbMx40/HumIhvAdi7f6QGgSiO4yuTsfAEVrG0tLbzEB7AJr1H8EYe wos4XsLCIsLAso/l7T9BUPh+ZpiAC+yaUTHJ8n6EWgAAAOyH/NDuZNoJ1FHH460XLOEKmrfFzc9d mMW5D6FoFhlUMQyvsKEWZhBu4QdbaGEZuYXU91BIn3CL5BnMT17X8rPzW31u/3lt+9zHc2v7nXC0 Kf/9dOETtm9ZaF4LumiL6o/b3LY7Xn4/X81FJzKKUYF7P9BC+Xpf0L6qXFtGoMVSttjXf+pnSwEQ W+tnah/azLlByEUXWiFn49kwC5sU0SdGdPtWYrtPiOjWL7p2299lvX19OOQM9aZe7s0woKIfkhlP MpRDC004DE1GlE+H8R5T6wAAAACAvy/3zb/YZLaSvgAAAIAcT2sPABA+6+UtYz/tBiHtRqFUAe/Q PlrB8NIblbT9piLUAku4MnnBEjltsj0WeuG3a6EZ2jEhLxn7AFM116xXsR37258q3Kldl+Rj6aKd J3ZNmzvA4n2GcwBLigUlpY4BMCT/X3s2bWjh3XrDAQAAM0iFOfr892xTrz9DhaP8c5ZsA3NI1hcA AOzGo1jXPs/S7iMNhVjEQjBKQjP8sQDAnB7WHgAAAACQ4SPSlprX7e9bcnzJubFz3wKwd/84DcNg HIZN/yGxwMzAwoQ4A6JH4AwciHv0CAwIcQB2Rk4BUisBSYmTL+4X20nTJG3fR7Ji4tSOKkFo4vpH qAUAAMBh0R7OafseQx0tFi9mNDpb1+XC6f8Lt5tSscET6VaGU9jgitUq3f5kWzfoohxmkfZhwzEK v/l5xDqGhfQJtwj20NO4wx/zWAIYCLcY8ph1wy3kwv8n64CLckBFsUi8PSZ/pSc0IN2dXm+m09P1 z9/L5eYxMoyiqhOnno8pi9uX0l9XAQeHPlYXY7QVaNGFfXpPhjDOtmOoK07YvwGmCK+YZCEUY2dr iw24GGUhF3mxxzt1bebe5WRirmezmNO+M5uTCMeeupxMKNu0IAt3IqG9H621aW+h8exnYiIAAACG Kv1flS99Apt8NwWZ3AYAAIBdeEjKed8nAQjvnraYhcq0xbpDoRa+gIuYUIwuP8e97aBPwHVVsd/3 zFq2hRbV0QIrmjwPrzJPyn2N44GmnpPyldVjrgV1rkExgRTyWDeMqe71TDtXrR7rs8FrgH3F/Cyg YH8fLpLympSnHs8FAAC040PUQ58PffdvfYs9yfZtxgDaxvxGAIB1k5RbExdCEQqncL9TGgq78D1v k/WqNgBoYt73CQAAAAABdZ5fyOPcueVaH7EBFlqb7xkIjtCfAOydMU7DMBRArVIxdUBIDExInRmZ OEcPADfhMD0DEtfgAkgcApgKTRwnP5b9nTQhaZL3pKiuY/ytKG1I7fyH1AIAAABgGcjJuufj9qA1 3u9fzXZ774klqgTmNpn5byGzsAIKJ6aQoorstZJYGCG5OAiphW1nhRh1YYaTZXRJnD7NZO9t4yG3 UP7anHrPO/R542LO+dyxMef/mbQxObYNezDaZ9Qml89LrsY4wUUVN/ZceH1dip+k3vWb9bPZXOd1 P1JqERFPRMfqj0aILXKZhegrlDB/KMHBXGMNKVU4p35SMaZ0TM4hTt8xQt9OmaSi/L4oynI1n5NZ OFNEaYwoBBcr8b40RLh+iv2u/8vj+9v1uslQs6Qdj6YuqCiHJIa4EuULExdZhBYaunp5OIz3mioD AAAAAEyJq7EHADAibZLCxRaysZgNAAAAAPrgaewBAHi8iXLovidWF0rMnUrmnUoA7idSC+0LjeO/ eR8gBiybG2WfPzetJc/xyzGZRWq+u+18+EvL9gCn8G3q1ywf7fc/7XqVklaENu16d4jEazpWgLmi CZq0Nl36B5g77rzP5JkfBskYAADAXPhKN6mh/aabSuyk3SvH+tbqAbqC1AIAACQ7UQ4+FmvCz4qG tpjMoqngIia6AADog+z/4LuxBwEAAAAAkOCzRdum6+XaCCyaxmAOY+H8CcDeveQ0DAMBGB4VqVUF EhsOgMSKM7DpDTgHp+EUbDkTB2DNFuqmjqeuPZ0mpSbl/yQTJ3ViUyGFPDxDUgsAAIDL4ZmAELwc OtByeRN+buo6YHkXpF12ik48EZNZhOQWMYFFSmqRll09JbYI7bsifT357scxxjSDvR/bH8ktjL1l yPVvi7+bFv2SgOE3++S7dR4hWy/N984D9Hfbun7TOyqpTe20uL99sbjeLL+2SS0OBrZXyQL6tjEJ Ri0ZRmw/m+229/R3QpfY15T6IdHEsD6m9p2VZgDH30Mnn+gTV8R1nbRCUoKL2TbJRV/U/rqu+4k3 fUNSi4f53DPsJ9l/ofDKqOuXCfVnVpILUdslay+FZc57vQMAAAAAOK8hdwY9AVLHTNznhTgAAACE ZIPPrQcBKJ9Sn2RUC3hWC4iWtyvtZwUBt4o1jnwspfUxwrE+Tng8oOTO0cYTLMd61m092661sZ59 x89WQgBlnMebpMCenntzQ85JVgILK8FF7ZxW214aa6kOTI3nfHYsAsUB+/T/fK/r8r4ut+2GAwAA TswbFMr73op1jzVvz7UqWrtvPQAAwJ/yKN25wZtwwir5PFMrmYVkdc1KJM89TABDrVoPAAAAAHA4 9vlFba5uXFrv1Vntase2tuMf+RGAvfvJiRCGwzBccWK8xER3ujMu3bn2FLNw7/3cegDjEVy6myNI Bwql/PpnSKGC75MQGKC0TpwQoPQj1AIAAGD77Id0r/X0GCuw39+N1vXBFs0g7U2YRRNAYYIp9NwE W/RzHWKhgiEXZj9fWEZO6xzs/dz6CLcIlFZTroUJt5izzu3/Jps6+W4TSqvh71McFr5bHoZKjLf1 68fHGpa5ULvd9Wn9z/E4bWB7uy12edMOO9DCCbNYMnxgq3UtUUeuQIslrOk7SalniTrmrKcLmlBK 7nHXBlCY3nl6bsIsutCLdl61AReV9bkrZ22z/5qrep0OtkhwU09PahhQ0TXJaqLd3EsVD7Jwwywq 67M0aEdsGQAAAACwHnRMAwAAQEmH0g0AHO+R7bGXflJDKaSBwWMDi/teSvK1Ldf1nvRS1FemYwM+ 987nlEFwQs+uQ8EW0qA80jxUt73tENgO5KJDmD4C26XzQ+o5KnZucsMr3P1C5ze3bVJbuV+JLdGh FiX6U9GHC/+J+X+/rafPenor1xQAADATaVColHujKfdL3WtV3wBR0nF992h9xwSmeCjdAADAn/Ni LUvPt9zXYKV3SVPCLNx9QgEZAJDbc+kGAAAAAAm+hXXn9OWOPT8I9btLWQZOfgVg735yEgaiOI6/ 2oQFB3Bt4jlUjuAN3HAAT2XCIVx4GbesjDuVAkNfn/M601Ko1O8nmbSVzh+NhJRO50eoBQAAwDSk 0ueDZaqh1epVynK+3deLk+8WZJdG0cETIcSiCrdoC7CoQyzq8+tAjK/tfu37MI6hXd5i7336I9yi pbb0uUYeM9zivP0RwHC6PvnbZtSW5vuz2OdAeCEWeuH74tB/fZx+Drwodgu+v6/XnUbaGJMJs7Cl cc4ZQx/0OKfU16WFKkwhnEH3cw6X/rvo0IqwbaxcsQ+gCGkRZTjWoRVSB1xc7UMuDkXV13UK036l CrW4nc1yhn0nvycTli37evKgfq0t5ELUz0Xi4Rd6a+Ve9wAAAABjexh7AMAAPgdqJ2fxOO/bxNyJ b0yKAwAAgPU89gAAQy8Q3uVhIa/Ezmtb/DvVhm3PjrXLtdwx3k7QJmDNe9SJhVXEXhMZ5r627eNm U546tgH08aL2vQdhU4t7hm3sc8qGVnglVif388174DY2TgBpXeZxAVMR/r8fZRdowYK/AABM08cR dWMBE9416ZDfsXI9iyEsxh4AAOBPut+Ua4kHS4RnQb1wCn3shVl4IRa2Xc27J2f3ASDXYuwBAAAA ABliodyV1PO1sTng3rF3n8P2kzPPnHsX/9SPAOzdP07DMByGYTdIrNwAlJ0BiY1zcAIu0iNwE24C EltXJOaOLB2Ko8T1L67/xGmTtMn7SFbS1IktqFo1dv0RagEAADBvcqDuTZfn1All+egES9ThFZV6 kfJ9E2YhwyjaQRV2u1e7XTjkQta3QRn1c2Mtwn59i733aY9wi8jZqs/34SW8buo2x79XsKS/LeEW ybPFfnteil2H3p1/YutV7boL1ttF/925KnWoxe9226lnRyEWxxXs1ixkb44VhVrpEj3/jOYaaHEt 7RA00a+NodsZ+//ie6dqvWM1ARRyVp4JszBJEYfEiCbgopCPm+3KuZZxq49VwRYd3OvyotoBFYcu iS7K7t6odJCFG2bhTmJUzja1DwAAAAAYx09G3a4LsqaO9RFbRA8AAADL9KTLw9SdAIQvXf4Cz3X5 YU8syCK04PcpJdSXMX549D3w9YFK9RmRGoOOhVe4dVRk69tPBWT4+rWO9BU4l40un4k6qUU7QyUV VCGPx4IsYp93vv4oZ185+8DS5My/Yq4Wlsq89t91+dDlbsK+AACAYW0iz+V8lwzd0/Vt5bVjdVLX B05RTt0BAMDFehX7vlCKnFJ4ii/cwheY0WWcDgByVfPJuN8LAACASyfHLlJzykN13OOhc2LjE7lj E75xD8zcvwDs3U9OwkAUx/GxNSxcG7eSeA1jvAl7N3ox4h2Me+9hXMgFrB3bCa/jmz9taEvh+0km LbUwE6Lg0OH9CLUAAABYPu0CnHbsKfVA2+2bKcurv31XiLwpRl51bjfhE/utbTaIwgZS+AEWLrhC O9bcpwmycM0VP6+qn7bo++DnpZflFXsf0h/hFpF7myHzYH5vxuz39J/bpk/CLUK0gvPdQAoZUNEt UN/sXrR9porX79e8fO524bFojyHDK9zWFbH3z7cF54vCFDbUwgVdjGiqov1z9DVFH4cKtJjCkp6T nH5OpQ/t71wekwEULi2idLdlaIXZB1wUbchF2R67FMfl+f7jWzbU4m61yhn+vfm/aLCM7MvFg/Jn sZALY0xnwaEWfiG3vtz5DwAAAABgfEM/aYwtlksVAmBRGwAAAFJe5h4A4HkX+7lf/AkV5XbbWFFv vxh4n8ALfzxTz8O+66Yv3gAO51o5llpcFBMLtoiFW+Ra123T43xgqFex77/257x/hYIlQoEUsRCL Pu9nxoTfr/gsEedqqrVUWuBT6hzgWLn/3dZ1+6jb86yjAQAAY/sS+7lzx9g8NFZAKjZ31W4zl8XY buceAADgaD3U7cbowRJaKIUWXKF9v9T/rmkqEEM61PU2AHicewAAAABAhlggd0jo+oV2LSMUaJFa V55zjQNn5lcA9u5ep2EYCsOwFSouAqmsjOxMXAID18BtcIUMbMywoq4MlQgJqZOT0+PYKflpwvtI VlPHiU2EiMiPP0ItAAAA1kveoHsqym1sg+325jdYQvKTkFchFrn4zOsgCx9UUYVWNIEV+/1xyIUM tqiCLNphGe0wjfUHMczR59qPKeEWY/VHuMW4fRJuYWlPpC83tOY7b9c125XhFtZzLE2bPK8uj3zs dimDCo7V+YnsxbKT9VnWuY+hTBWmMGVfSwpVmHKsSzkm59LPnH3ov1b6CTsfQCGfyvNhFj4pov70 dSrMIjuEZmRiX95lUXe12aT8CNdFuXPtgIp6SGKIcrgXLh5kocMsWvkb6jDputCEHwAAAACAdUi5 YnjKJHoAAAD4vx7mHgAgfBXlJaFd6GUip+q/jbYpJTRhuNWPHoduY30fSrnf15H2DXhWqEXJeiDJ Wmfe9u/ZLrR/q/45sA4Y0puLvxCbcv6xgitiQRVdpescFit63HoZwLG+5ylgLfzveHk9oQy0iL57 BQAAFu8z3qTWdW00NBlUV7s+ffB/LMZwP/cAAABn7VF9t97vTCmxsAu9HNq/HgsAnIrnyQAAALAE 7z3a/vX+Rcq9iNA67l/A/QjA3v3cNAzDYRh2SdUDHLhyA4kFGAABm8CBPRiEGcoOwBBMwBpNQxM7 jmP/bKKkbtr3kawa549NVbVq4voj1AIAAGDepB/P2V5jJ1qvv1RRnO/q3WCJ0gm2UE0gRVvscAs7 wEIHXbhtev/6+NKUdqHz0ozDtBx5EEOOPo/9OSXcYqr+CLeYtk/CLXzqReIXnjZ3AfnuPBV7n/Yc /bLZ1Pv9WqEW3oXpdZsOqwgP2DzqMItOoEXs+IH2FXKQo6+59DOnsR5KP/t4LeXsozdrrgme0Nt0 mIVOiyj0305ghQm4qN5Lzpq6Pm5Xd/ZfOOf/c7VcqtvVKuXfuVf9iYOFULcnD9rbpJALZbUr5Q+/ 8D2FSmhnUiIAAAAOxVPuAQAjG3L1cMxjmOAGAACA/3ipymXuQQCWb2Fbyo+JQiEUKQuJpywuLvUT G+8YfCEanxP0A9iuhW3S4jixeuw+d6wPX/tNVZ4j5wPG8G7VhwQZ+T5T3PCKWLhF6meb7zMsNCbg 1I05n0o6l2+BOWAu9Gv3rSofimsKAACciliwo8v3HdN3bTN03dXdxvda5HSXewAAgIP2UJULFQ6q CNWlAItYUc5jeOGA7r5uHQAkj7kHAAAAACT4SdxPuscQm28ubYvdv+DeBYytAOzdvU7DMBSG4RAq BibWDmVlZmViZuKOuLQu3AC3wMzMUgmI0/ycnPrYLoS4Td5HstL82kKINNjxR6gFAADAPMmOORdo cR87YbO5q4MlpGGYxXczCfl+wvU2xEKGV7SBFa7sdn2QhV72wRb9xOa6WOYexJCjzrn/TAm3+K/6 8oVb5KiTcItcdfZjTYYhFsPxJocBFxcH++xxLq4NItRCT0ofC6/QQRc60EJud6UsxenjjZWZKuRg yrqmCs4Yq55zausp1bOkOqyRdN1fqSaAQo7o68Is2lL0qRH1UoVZtOvyWu21r6qyXq1SmnpblYdi GFDRNUk0UTb3sogHWegwi1KshwYfWp8BAAAAAOcp9lJ+bB8AAAAQ8py7AYAiQy1SXu5JfWEoZfLv 0ETgvuv72pbj+ewtQ51YluuEY0L91FZftrVPn2et+7a9JLQV+KvXqnxEjkl9mTV0b/oKFGv/Mfc2 3z3N+gxgz7pfjT0+i/FeOFXud/OmKtuC710AACzNZ+JxxwRO6GdQa+InnluRk/v+S5AbACDmqVmG 3u/0hVv49o0ReCHxv0YAv/GYuwEAAABAgvfC338RGhOnt8Xe2R2j/4L+DNR+BGDvfnIaBKI4jg8h 6cZLNHHjsgcw0a0rb+C+R+vKE3gGr6Bewp0IhVce48zwasCx8P0kExj+zbRpihWYH6EWAAAAl8t6 EW4/dqDD4cWVZfuc3jBYovKCLdwxkKKZl9IHW7ShFTq4QuqyTLZvAjHa/atT6VWnfqQw2Psc7RFu kdjbEW4Ra28d4Qu52l3L+2sLt5Bpf6obDiTfh18Mgy9Cz5QP6805ySo4eL0Os+jqhYRX6HAAHb5B oMVi2llSAMTS2vkvbfz45mk+M2qdBFBIWkQpdTXVYRbH4Iou5EL2K7tlfihGodorulCL683G8tJu 1aGklIl5faOhXpcKuXBquXPh8IvQW+gSy7kpEQAAAAD+jnUw1imPDwAAAKRs6/KYuxOA8tGVkNQA Z/760HbWAcRjDyB9uXCblr7M/XvtbebjAzdePRZaEZK6Th27WWks/CLWzrYuT4m+AFP4rMuzqp/7 nW89D4XOS2MhF5bgCgYCBaZDkAXWRP4+29XltS53ebsDAAAyeA8ss/xf9DcDR+lp7Pesv01qfaxd wGKXuwMAgIvwUJcrNx44kXp+1BJcEXocVsRCNPz1/jwAhNzn7gAAAABgoO85P+c6QOx6xNh94VNe v8AKfQvA3v3jNAyDcRiOooqBmYkB1B0hsTIxM3EENm7BvZhYuAAbh2Bi6VCpkLT5UufDduwkjdPm fSSrzh/HVlSpSpP4R6gFAADA6TFvyL0U5batwXJ5o4IlMhVm8VtNOL6bXL3cV8IpyvAKCbGQYIv1 eh9mUdabgRdZHXBRtpeJzCU0I2YidSZ7P1R/hFt4WmddrqH53hyqz/HPa6p+53J+/X3qMAsdcLE9 Qr3uf+DFvq5DCMxz+7NaWbpuhlJYt8linu96k+AKo9QT2ZvrexgrTCFFX2P0MVSgxRiO6ZxMoZ8p 9+GauaJ+ws4IpjCDKqSuAy62n9U+dZFjGO3FWbF8uViEDPWqKPdZM6CiHlrWfMhQh1n4gix0mEVu LNsm72irAwAAAACmo8+/iTy8BgAAgCE8pR4AoHy0bHddC7W9VKTDKfQE4L7JwDeqve7HNbYxr9s+ R+wL83XeoY1v8pyQsIrQ+9yy32vsAIEO3oryXdX7/C7JPr7fpJjgio2jfeY4tuulWlsdOAUXAxwj ZNK3kPWxYVBAavK9fC7Ke1Gu0w0FAAAk5AojjuG6XtbbzE9b+9j+gD7uUg8AAHAUyvtoj1XddX/M 9g6pb73tvdPQsAyN/x0BxHpIPQAAAAAgwFfL9pBQCVtQhd7fdV/D1zZ0XNzLmJE/Adi7n5yEgSiO 409K2LDQpUsTD6AX8ABcwp17b+INvAEHcIuH8CAmbrFDaTt9nX9F7ED5fpIJbacwkwYlpeX9CLUA AAA4T6kX315iL7Reb6Qoqt/n1cXEq9reWxVsIbtAiiqMompVmEU3tEKHWbRNmiAMO9CiG6axbeYx RK5i72ObekgB4Rb/Y+rvm2rMfH+T4495GcfXHrMtGn/lXG4DLkS6H4XD6p8vlze7x29XqEVMZy7t ei/YwpjNuvseaKwwhTHHGjNU4ZReJzbGOR2TUxjnVMfQz2hCbvZ9dZhFnRZRlP8r6vXC6msSJqyQ i85+dcDFPvxCJ0aYcW7nc7lfLFKm/ST9YIoisGzfNGj3hUIuxNou4g6/cB1CCWznpkQAAADkdpd7 AkBmoW8TcxZFBQAAwPS95p4AoHxay7Hzn1ih8NQWKxIunmVX4e9jFFo7hBljM8I4uGymeLG+oah3 aT9hH3ub6zH1pib9umZ+z/7pA0dhbpT7CPTHQiF8xTtdwRRDm+v5rs+01LkCU/OXUAvurcIlq9// b2V7L9t1xrkAAIB8zPnwT6Df932p3ie1z1VgKjX8gnNcHNtD7gkAAM7GqmxLCYdZ+MIp9O9KZ2q7 7zm+63J6X92vlwFAe8w9AQAAACDB14B9U649hPp8ARa+da5foOdXAPbuICdCGAzDcGWIybgwbl0Q 3XkIb+BB3HoDbzJX0JuYeARdu/ICSmcotn/604oIDLxP0kzLwLQhxhlC6UeoBQAAwLL4N+LuTWKC yW73ZKrqRgRLmCDMwoVPuIXUbVsGVbhXG2bhB1zYYAtXD4MtwgANv/0XSw9hmKrfpZ9Xwi3+q7/1 hS+M2++6zu9h/fhYiIXbfijhQvNfXvDFz77yeNu230Pb7fm+/ZkbaiHCBoLwgciC9yd+sIUMvfil pQZaHEs/BE3062Mp52yQvyFRl7PpiqJoEyKKJvxinxLRhFaUTWCFS43YNPu1M/qaY9xY3XvOad2+ LMucoVZ1uTVhQIWbHNgO0YSTCjcmHWQhwyxk9oYRr6k6AAAAMCf2d+rV1IMAZoYJagAAABiDffiY 6zHMyYvRF0brevgntj1W1xb47lu0sfSbHNWP38/rSH1ivbTFwLX70Kn70/LWf86COrEQDecx0R8w BBto4b6rtP/12gOqXSEWMpAidYwMs+g6TtseG2usDgBYL/tb66Iuz3V5mHgsAABgWm9ePfeaUbv+ NGJ77qJQ2j6x94EhXU89AADA0Tiry11T18IlcsIsYgEWqVCMWJF4thRALjunjIBjAAAAzN17XT4y 99XuK8j3ZF1ry/3lZ+X0ixX6FoC9O8ZpGIbCOO60VSSYOrCxIHEMBliZuAEbOzfjCCwcghFxBXZK Hfoa4768ODR1lOT/k6xacRRbEaJKHfsj1AIAAGB8UifdntoutF5fuKI4q+phyIR/XpCNy+WYD6T4 Dbmowy4k3EKCK+riojZXfUpAhv+UUm+Qvtn3d6yphzAM1e/U7yvhFqfqb17hC7lN+/7W77hsNvp+ 5n8DKvTQizrYojjIjwjbyvK8qn+lhloE19ACK+T4QZs/tlj8O8wiZ9ABoQr6dXIY0z1J6SdHH6fu p48+Dnaj2IVPSFsVZrELrJBAC0mJWAb1MLzCl2V0nna+9CFhF5erlbsuy5Rh38hwgrI06uHLhGGb FXLhguPO6eEX2i10xnFeSgQAAACA/nX9Idx6qa3LpgDHtAMAAGA+noceABB5C+rWoqH4WLxQ6Dto szYGT90MPHUj8JzPW9rz4kfG/jFPTaEWwpqHbttMxzov5dpX2/LYMj7gWH4B7IvRrv1vblvw2hRA EQdXaCEWKd9n2ti0seb4DiN8CVPFO1eYKv+37Tcue92Wh4HHAgAAhvfZ4dy2Z1CrnropVFufQJ9u hx4AAGBU7l1a4IS1hjReTxoXK+DCueZ5Nxe1A0CTu6EHAAAAACR4D+pd1+VaYRPatVLmMZrmKpjD wN6PAOzdP07DMByGYZdkQBwBqcDGCDMTR+CCvQLiIuwcggGWsiHqJk6cX/0vkMSteR+pSho7ttuh EbLxR6gFAABAOewJOB1ocR+qvNk8q/X69mBjcvPeBFc0m5c3m6bbQRY65EIGWrgCLkx93Z6+Rwdc 2AEawzCNaZUewmD3u2x/ZX+vhFvM1V/J4Qt5+2z6LfX7Ha450eEWus9mX/n+sSc3m3eFXfjPm2NV ne+Pn9vtyCGuDs5X4podbNGVjdwcf6kwhSX7OrVQhVLCGUw/Syjls8zRh/w1OmsDLrpfJhFu0aVE tEEWtQmvENfN0Q6wUKoPyDD0/Zd1nTLUq93rQYk8jbb5bohquMCwUvEgCxlmIbM3lDjGzgEAAAAA 5WBhGwAAAH7jKfcAAMvX7vWaUM+3Obgs/3bUHbOJeEqIhRyHrON6Pyc2C8fcrgNlch46tPjIVzc2 lx0qJ9ACS3ixzlP+AdUXbBF6DrkCLcaGXPjaDT3XfJ9hSh8ztQtMacp1Vf7Ft8DxswMt7jKPBQAA HIf3xHopm0Cl/J3q2xTK13boOvAXN7kHAAA4OReqD0SKhb/7Ai5c4RWue2LtuoTm9ADAeMw9AAAA ACDBW6Q8Np+Qsq4vpb7yXHetKWcu45/7EYC9O8ZpGIbCOO60VSUmMnTgAuxcAIlDcIBuTBwSsbMy cwGm7pA0duIE+/m1KLGS/H9SILWtPlMhRWocf4RaAAAAzEvoRlqo7SX1RmV5qH7enM/rwIluc/Im gOJ8ZtuaAAsXdGG8YItQuIXpBVy4/ibYoh+M0flp641h6SEM+Wou+3Ml3GKseksNX8hfs6k7fdHp /taiDauowy3iz8hpwiyKQfBFrdnc/ft00s3GC6qIDOgO+7rYbPrtyo3ylxpoMZc6BE1cV2PsOnOt 8WeVnA2hcH2FDZ/wAy3c66133iZE2CALd7j20Pi2hq1zt9uZ+/1eM+1HNx3v2Arn/mJCv08KuTBe uzHh8IvQR2iEdhYhAgAAAMA8aB7aTz3MDwAAgHU7Vsdt7kkAnnehTwqKkB4QunSD79SYWJ3UfKfy lqku1uOgGDO8Zy0tRor9TgVkDMeU1fGqmBvwH/XmndprleZh19i1J3T9CQVbSP3SQ7Wx6xqANE34 0rXhFdJ41nNhavX/3LE6PgzfGwAAgM5XoC0WOjEcE+sLvU9sA6hQDTaFwhQeck8AADBLz+ayQItU 2EUo9EJ6D6mu8foBIOYp9wQAAAAAhU/FGOm+QmodXWydn1RD08d9jBX7FYC9u7lpGAbDOG4ixBZQ rpwYgAMrMAUndmEAVEZgGCZAXHvnUolSk6/Xlv3aCeSjyf8nWc2HW5uCCMWxH0ItAAAAlkEOvD0e y61Webt9M5vNze+2XIi8XpjcFhs+UW4fmtKGU7hBFvv9wdlvAy3KxzYIw22jDsoYaw32pYcwTNfm sgMKCLcYqj3CLYZrc/z3tmz3/7/WNngifH9JG25xJuqX593QitAccaclU6+j/rHbxftSFW2Reyfs wq/XI8xizKADQhXCrzOGU3pPctqhjTyF+J6EftvZczLcokmJqIIwzqtSVPUK77wMsKjbk/8MvqiC LTJcHsud8fI0qpdvuiiOyTALLcjCD7PwszeM95jaBgAAAObieuoOAAAAAMDKPEzdAcAjFwrPmfCT E14RC6dILQAem7SkTUbqOklpKO8TtIn1uPL2uyx+EzoXC7aQr51aHNwefzIsuIzhvYjt0DXJP67V SYVZfEdK6jna9TD3msRkWcD113usuE8Lp8b+vD4fy+vUHQEAALPz2eM5/udlbbEoY+KfpUPbWl2t D0BXhFoAAPqwQfH3Ji9kIhZgEQq7iB2PhVdo42vaPoB1s38DM/4OAACAubPjFl8d6ncdgwiNcfjn U/eca+2njmOhfgRg715yGoahKAy7RCrTDrqASuyCTTBhCwxRl8SOGDNEbIJZQ636JjeWXylN3aT/ J1lJ87oWE5om9iHUAgAAYD5SA+G0t9yFNputORweB9v6AIthsIUNnpDwiT6cou1CKmT9FGhhumCL U6iFXKPtridNVXb7xv0x/oNwiynq1QkouHY9wi2mqEe4xXQ1lxFu4U8srz/r4Io+4MJ0y+G5sfF0 dlvrzo+HWgyu5/chFFahAwQC6ys34Xy21hUsLTjjUmEWBE3cZp0l1NBBE1Jv5e2TVAgJtJDPjVu3 YRaN2i5hFrLNP16O6Wq4OjbU4mm9Lun2s3RHtSaxrl8u1PtSIRdGbTcmHH6hl77S+yUAAABgarva HQBmKverIi+1AQAAIGR3bC+1OwEoPyY+KVpqoJC/3z8mFmKRm/RbDyzyjw/V8GvXYmt/V6yP+7Ad cWzouXVsMp3Us+1U6IWdTON9RJ+Ac3y5ljJm8Gro/1MoqMLfXhJuUTJYtnTyUABxvF+FpZHvVh/H tq/cFwAAcHt+TXpiqDH3l7GQidjkUKk6Odzn4hIItQAAnOvV5J+VPXjLXNBF7PzSpvsCADF8BwYA AMAcfKr13LvcuWcP+rxz370LXT9VF3fqTwD27hinYRgK47gVKlZYWJAq2DgDExyBG3BEdu6AEDsL W+/QAeISJ/brc+yUkMTt/ydFSZo0NqgCpXbeR6gFAABA+fyBNxtokfxSfb2+2639ouNuW4Zb2AAK u+/CK1ywhQuu2G6/g30/9MLud0EYXaFzF2IhC58fezH9Uyikz+80+W5zyD15eT/nIe0RbvF/bc4X bjGWrvi7nGsSFoX/bTN85nuvcHwbIhBey4VafG42qc60a7XwvRJu4S9tCEZVheeJPk5h6rZKaaek vi6lnSk+S8fahlalIvjrZIMqjAi3aF6rmhCLXXCFe810ARdVE5bhh2i4azjn9f71apXT9Zt6uTdh QIWbKNh20YSTD89MOshChlnI7A0j1ul/CAAAAACAUjCBDQAAAGN4mrsDgPCaOB67F9IeFpL7QwuH y3Nl+0sqAK49GPUxU19wOq7M/nizHHvWxqNzwir6wi9i17aBFhfJXgN/8+Jtpx5E7TsnFkYRC6rI CbnIDbNI9RHAcLG5V8zJQmnsZ/ayXt7r5XnmvgAAgGX68rZz7yf77k1j37dqa+1eVx6T7QJjup27 AwCAYtmg+AczLHQiJ8Si73gqxEJ7NFc7BuC0Pc7dAQAAACDDW+Z52jiCNsdOe1/svL7xCsYt0OtH APbuGKdhGArj+KtSdWBmYEJIHIAbIFZuwsDAxXoGBOIQbEisPQBLJWgUXnh1bT+HNk3T/n+SRUhM nlshAsTxR6gFAADAOOQegrMevBPN569SVWdr+8IgCw2zqIMnmlAKMeEU321IhW7XwRbLpbTBFk24 RXMODcJoztc0U7mtvzke75XsDkEMfdQ7jfd0i68Wwi1S9Qi36K/mWN/bZi6JXQg+3I7NSdGQCv38 bw359cun7tf+H4uFLOuLmNZpa6SGZxaoj4RXTILtMPQiDN3Yl2MLzthVnTGN9ZDqUKN7jY2VKn5/ 3uixiQZYiAm0iIRYaGpE+1GPm/2VOVcsMeJiOpXr2azkJdzqcEyrMtt2gqE9lgu5ELNfJB5+EXsL JbOfSYgAAAAAME5McgMAAECJp6EHAATsg0VdAixKm7fot9cvrCuR7dR49+1loLo4HZeJ/aX3o8N7 2bmFdbzz12EWj4n+wK68rdq706fkGuVdi8KQC691vcalFgCNbQPH7Lyn8zLXCmNVf+9erdrzqt0M OxQAAHDAPjv0zS3WFFvkKTyW+5+rV4O/bdEHfk8GAGzjXvxwd/vM6H9CLErCLUrvxwFA7W7oAQAA AACOL/HvXeTmysX6eXPHS+bipeacx8aDE/UjAHt3jNMwDIVxPKCIgQExI6HMMKDuLNyGg/UATBwD IS7DQlWRR+rIebUdm6px4vx/kkWI09hEFVEV932EWgAAACyb/cDttW1PoYO32/eqaR7+giZspuC4 DreQAAr53YRTSI1vO7hCwixMsMVutx+EXki/CcKQn8PAjLhC56UX019DIf3Sr+np4/3vsznvnXON Wf517cZc6rW98G4fB1x0292YrsL+/hAMCbT4kRtV6uz0GCq8YrBvJNzi3KYMtFjKOCUFQJQ2zhrG 0P/djlbVta+tTVCFCqxwBV30/Yd9/fkOczDnMOe+attdXcf8Gfdte66GARVmoWCfv2Hts8MsQkEW OszClb2hFzqGtgEAAAAA8zGnYqgAAAAoz0vbmtyTACxSLPzb0xcqgGbv8wVNpLR95Dli5pHTV+4J oHjXI/2uZ9CuAjkxz7XHCuxIoMXNyHyAU71Z2zH3Jc11XwmFUug+HXThe13s/Sp23kCpYkMtplxX xfot5CLvvU3bPisK9QIAgLCUUAsRWvcSKuoUUxiKz7qY0ib3BAAAiydrMx6rtNAJ/X3TUMjFpeqL ecbm+mquqw/AOt1WrCsDAADA/H0kHj+2Ltx3jN5fOY5JXT8+l/XmyORXAPbuYKdBGI7jeAnZTJYY r949+Q4e9hA+wG4efEjfwLPvoAfvJuBqKf1Tun8hbmOw7ychKy2sSIxEKP0RagEAAHD5tBfjpJfc F202t6aqbv7KIcii7gRZ+DALO5+3C6UwnbAKF1jhwi1s2QZbuHUZeGHaIAz3PXW7BHXnODRLn0z/ GibSX/o5JdzilP3NNYBhDn3O7dy68SQhuKLohFiEbcJnmES+/06ey5QIdTLw6cde/HrdF+myWE8G WzSfRRNiUYgJ5tv1MwYQLC3s4FiBFucwp3NyCf1cQx+9uJ3m74NvK5rwibKp9wEVMrDCJkb41IhS tJVR+IVf99u0fTT93K9W5mG9HvIjPZn+oMFSKcuBhLJNC7kwot6YdPhF6hQapZ5BiAAAAACwPAx4 AwAAwG7qAwAi76KsTXYW18UvAg2d6HvspODapGmX+GLRtxk/yRwwxqPS1nukr5S1No3f106m8ZrZ FvgvG7z0ldlGe+FVC6yQ69WBJbVfHHQx9noWH3dcBtCnXZsYX4W5sr+72/3ytl/upj0UAAAwA5+J uvh/Se1eae6+b+4ebK4MnAqhFgCAY3gW5dTzstR7o0NCLA7tM2SJjwUAvO3UBwAAAAAM8CHKuXHd qWcP8fbxGMC4LdWe+v7UOL1DfWv1WLBfAdi7m5yEgTCM45MmuJDEuDZpws6F8QRewiO4NF6LeAS3 3sC9S29BwkLt0E47DPPx2kIr0/8vmdAvOiMBCUx5H0ItAAAAzpc90fZctfvYwev1myrL292yXVC8 C7cwBc5VG2yh103Aha7v3YVWdK0Otfhuwi7s8AvVhFr8NOcy5+1f1Dz3YvpzKKSf+2N6nHCLfv2O LffnTt1n/q/Jus9zemzda0wOl/eDLtz94frn+v1pubzerW222/AIQgXwPQEW7XbdiuJgW2FvO7Hc gjOO1UcuARCmnzHk8rf8tz68V/A1wRVmvU2EcAIriibEwg66aPc75zBjMucw/V5U6zeLhWSoZdUe 1H5AhTmVCbGwt9lhFrEgCzfMws3eUM5tahkAAACY0mrqAQAAAADADOjJ3cepBwFYdKHwD8FxoR8L pfanmq8ouKSAWqwwuG99TLrvrwn7R/4uBcfE5qRjARax+7jbXqp2JRgL0Nemaq/Weux/faw4Z+q9 xw2pSLW/hFhIxwpAFqokPXZoX8Cp6efgU9XeFYEWAABA5jOwPfYZM/X5VDn7fbeh72h9n7l9+4Gh VlMPAACQBR0Yf6dkIRSScAr3d6iS+ygV/o4zNpcHYH4IdgMAAMA5kFx7rg2Zlwhd95e61tztmzkL 7PkVgL27yUkYCMM4PlBCUhIv4EIXXsMFh/AIrjyU93DpBTyEa1cuJIGN1PK20/LOB1Ccfvx/CfZj oDMUg0Gm70OoBQAAQL9pX5Rp+55DB1qtbvY/88Y+O8RC1iXEQoIs6pCKMpxC9kmgRbG92xmz3UrQ hamCLOQ4clyr50P/8SeiOe5xF9OfQiH9sZ/Ty/o7b75hit+bFP0OK4BhaH3299yWoQB1MfZy0ZxX UhePn50YbFE/Ns/L68O/N5u4JxBTsN4KuKjCLornM58ftV/LmMIOuuqHoInz+rh2P2N6XWL7OHpH kgAKaylBFjN7aUwjxEJSIzKrLWuFX8h2lTBhHatY3i4W5mG5jBn2ozkOpsg86/YkQ7vNF3JhrP3G 6OEX2ik0nv1MQgQAAMB/uU89AKAjMYUdAQAAgFSKQAsKVqJPPjxtMQW5XRcGuS4mChUA19pd/Wjj TUG7mOo90VgwDXet7VMK3fi+k3YV1NHai5Cml+BIgcu87W8/h/WY9/5QwIT2NyY2pKJ9P23bNwZt rNo6MFVdzo8Kzc8CUpNAi9fE4wAAAMPxFWiP/Vyp/a9Va3Md89TPr6FiUkCMdeoBAABG48la174L 81032r6FHhMKuHAFXQBAYZ16AAAAAEDAp6nn9bn45qDb26G55777acfyzdkD/vwKwN794zQMg3EY tiIiMTExIaGyIgbYuQwT4hacpFdgZ+cCHIOxE0tFm7T5Usf9/CcVrZP0fSQrbhwcE6FGUYx/hFoA AACMk/2C7bUqj6GD5/MPM5vdb+r24uFSt4MttkEUEmCxasMttoEVuyLBFsvlXxt6sWszbQhGXaR/ Cbj4rzXTp76Y/jkspD/1a0q4xTHPN9wAhvGfc0jX1g2k2K/rARamE3KhzYtZrfYDLsrycrP9WSz6 /xISViHnber2582mKLaBFicKsyBUQe/nFMZ0TVLOM5VzDDmYo/3WkkALpbSJEE5gRdGEWNhBF217 s09m8RXNGCXYQlxU9ZuyTBnqbVWeTTegQrqXEAt7XydLwyraBETjtBmlTdvn+9IHAAAAABzOXdjR hwlpAAAAyOEl9wAAx6dVT3lOCgVNxBYOd9tDx2j9h8bi7s/tO/cAMHnXPY71vbf2vdO2t24f4q0q Vz3GAPT1a7r3KFfsH17de4ld94VUhIrv3uW7l6WOFYAu1zwq5m/h2Oq/sXdDoAUAAOjHDrXwPVe6 z56xZ2PtZ2MLSIWOjY0PONRd7gEAACajXrTmwaSFTcSCKbRwi5QwC5cWrqG1ATgvT7kHAAAAAER8 WfXUueeyDc0XN8rn2Ly8UHiFr0+cubUA7N1PToNAFMfxUZp0KQtN3OnGW5h4Hk/lyvu407Un6MpN k0YIPHgznT80tGU6/X4SAh0oMzYmhDC8H6EWAAAA+Uo9UBPvqRPV9b3Z7dZWW1e0fAyzGEMnxjAK CbYYQyzM8Hm7HdvabQmzkO902xJmsf8e0THrpZdeTP8aCumX/psSbnHK/nIKYCitz1x+2+l1zN0g i664/P65xqLzN9axVdWHWmw2ybFaRevdbaeovfQnbcP2CYvrnzO44ZICD0oJTpB+zqGUvyXnPqww C1nUPgmguO3bh7UxVoiFpEZUal+lwi+kbQi0UIt8flytzMvavm8IeFVftfI1Atu6K70vFnJhVLsx /vALvXZNvZ8CAAAAAAAAAACX5blZ3pYeBKD8GrsgmhYrgubud4/xBVekQi7cF4vc4319uH3n5Gvp AaB4DyZd3Gbqc+pYsIWvj3ZJzv8FZvpslr9+e07BzlCIhS+kYkrQReyaFgu4CF1Dc7t+AZdgztwq 5mBhSe3/34fpQi0AAAAO8XPAsbGQidR9tG/tO1foGO5xcWx1szwtPQgAQFH0fA3fS/++YAr33dEp YRZTAi58z/EAoA20uFt6EAAAAEDCd6A9FDxhPO36eHf+uHuu0JzA2JxB3xhCY8SV+ReAvbtHahgG wjDskIGSks60NBT0zHAOOrhbzkBDy0ngAjSpA5aTtTdCXimZCDvy+8wI/C9NChwjWR+hFgAAAOdH d6y5F9rurYNXq7eqru/aZT1ZuP4twRYuhEKKC6XYhlO4sumWXXiFX/rjfrrzJNyiD7bIPyl76ZPp z2Ei/dI/07mFW/xvfVMJYCixzml9tn0whN7W/qzi74bL+fuBE1LnYnHZLn+v12kNjQVTyH4dYuGX DEoKOzhVPQRNHFdH7npKqUPqOcX5oRks/NIlQqjAiuVuvQuy2AVd6DALP+CiC7dQbb9qll2wRYK6 KY/VfkCFDBKUEAt/kOGyigdZ+GEWF2p9+I/78DIAAAAAAAAAACjP69gNADzvkf3WJOKxl4GsicSt gIuNdz3/urG2TcXn2A1A8W4HtqdOfhPqq45NniPbnptyndZM4CgucOnD2B+6HxxyX7LuTan3KX85 ZUJPXogF8mPsFaZKAi1exm4IAAA4S18HHp8SSBHaZj1HW8+zPOsil4exGwAAKM5TU26q4b6xWDiF fufUCsCIXV+z1vl/JzA/fAcGAADA1Lmxfan9FqGxdKG+idC+oTF61jjBUN30b+CPXwHYu4OcBoEo jOOv2DSxiTtXbj2Be4/hAYyH8Fyewb2ewp1JT9CgrQPMYzozzCCFlv5/CYVMp7wJG0KB+Qi1AAAA OE2xF9m0l64drdc3u8/rVpuZoNyGWdjQCRNGYRepQivqdblbl02QxXYrKtjChmDocIx6P2Zy8p+q fvbxyEIQw/nXnPsxvZRwi6kCGMZ2Scd2inCL2DzmdiJ2u20msG/3NfkR7sT2vmdWzN8kX5tNeFCZ E9cvisLWdcMteuwvWmukyfvrWmPUGCrQYgzndExS6lAjvcYQgRYHT8yptoXYAIqiam/WIk2IhU6N uJJ2mEXTRwVZ+J4E3LtbLuV+tUoZ+qP6aStfI7CtS+nvYiEXIu3h+cIv9NqVel0FAAAAAAAAAADO x/PUAwAcH2o7FmBRr3MmC09dYpOHu/Ul8J1vvFPbj+N96kFg1m57/MZ3n9r/cJN/qb9/7VEbyPGm trvOT74+qeedMnPJeVm263wVawcwnJSQJ+DYCLQAAAD/9e1pi00EldM39zo21IdrXBzDw9QDAADM 0pPajoVPFHL47mgo3CL0vqn7CmzsHpwI/1cCINQCAAAAp+8zoY97z6IrcCI1tMJtd/fdVRf48ysA e3dw0zAMhXH8gegIcECKODIEEuoWTMBknYEBECzArWfu3Cquxa1x8mI92yk0SZP+f5JVp6ljN4dW rZ18hFoAAABMi55Qe5bCH+mr1YtU1f2+rm+Arh9DsIUOotABFbr4AIsmyCKEW7TDLJpQjHYfosIt hkEQw/T7nPs5Jdyir/6GD1/w/c7/3Po+xzi/7TUl/gbyqevD/7buZHfI7db/TfK12XRrUFfbQRVh +0I9J/o1av+xVsYMGdwwlTCCIcc6lXNyKv3QR9PeOob1qRaXOhEihF24cvW7rUMs6ro0SRJ6uw63 CJ9fu+O4+u1i0eUtVK48SDugIiwSDCEWl0ZdLza0giziMIt4saFEj6U6AAAAAAAAAACYj6Urd2MP AlDeXflO7OtyQ7JDLhw65AbgpWOnxnEq9Hg+xhwIZi/3nRLPOacWJaUWLFmLm8L2k/g5d6Ava1fe Mvuti067hEvE30O5UKVSkIXVLjceierx+xjS60j9Atr12AMABkSgBQAAOIbPxPO535alGzuJpH/T xu1TN4Qq7Qf+i3k1AEAfHl25ETtYIg6myIVbWEEWVptSkIUYzxF0AZyv5dgDAAAAAArWqt5lPVyX teGpeYfUXEWqnbXP2saZ+xGAvbvJaRgGwjA8hEoVlVggseACrOEAHIMDsOUAnIuTgLgGy67YURql SSbTie2WNr/vI4Ua28RuVCkCHH+EWgAAAAyP9w8xr+41dqLV6nr79crUbhphFnXYxKYRSJHXFaEV UoVX6CCLovy7F2yR9y/DK/Lz1PueF4U5bPo+9SCGPsac+jUl3OJc4xFucd4xu76+F7v32VxTogMu 6rLeKN7b49x/rrw4t8j3eh2Zih3ftGWZG2ihwy5sEMaxugpUKMcayzhjmutQxunis8QYzXPs1Xnj qLYygCLb1VevInWIhdTBFZfqe92nWs1XBlqoo/xj8d1iIffLZcpbeVI/qrMzdNmGW9j+3jR0vUhz el74hXcJJVDPIkQAAAAAAAAAAMbppe8JAManKreFRXh1oQeGQqEV3kbiKSEXdjM1MfVD4c3nq/NZ YE5unbrQBjixzXBCQRa6/e3gmQKHeVdl70FUWx/q492HvKAKe3jtKfe6tvvT0O5ZQN+8e9iphUKb YvXAqdwIgRYAAOD/2gItSqm/c8aCKLzXY8bR/UPnA1I89j0BAMBkPatyLHwidtjnTW0Ihn0ENiXg AsB8PfQ9AQAAACDgZ3t8BNrb1nqnrEkPrcvz+ofaU+aEGfsTgL27x2kYBsM47iDEzMQE6szACZCA I7BxBe7VMzBzDQYWtg6cAXDafLx9eW3ng8Yk/f8kq6kTxVaRiJLYfgi1AAAAmA/5Mu3Zl5vYwev1 i1utrrfbcrHzNtDCNcETZQhFGUbRFh1UUYdYuCbYog2z+GqO2YVYfDdhFjo8QzqGRd+XHsSQo82l /6aEWxyqPcItDtvmFL9vG1RRll1zepxJaMxJeP7c/qLyxfZ6WHrfbES1DMzQp2pDKwpx3K/ACvld 140wZaDCnEIV5tTX/9QObUzTRte/qbXqhS5NckQdduFEoIX/PK1CLE6qgAsrcWIv3KL+P+bLmd8u gy06uPLl1jqtswMtZBcK9akHGzq1zxn7rLrYhQEAAAAA8Pe49wIAAMBUzn15zN0JQPh08UlFNT3R R9ZZ+4cWfY5UO7o+9D23j9wdwKLpBcH7LHgT2hcKuqg9+XKZ7how2FtVYqyFNlMTXFNBFbIuFHDR J4zJmiAbu34Bx2zMc/qh1z7eDWAKZaDFqyPQAgAAjCdDLUL3k9aCTKFnu6Fnqqn77dixqf4BQ93n 7gAAYLHufLlw9nzOWChFLMCia9HtOWO/i2wDWK6H3B0AAAAAEvqMPbfqY2PFQ8dZ4//6vvvo008c gR8B2LuDnAaBKIzjY21q0sS4d2FMPIAewIVbz+ENvJMHMXHtSYyrrosiDDyGxzCDyLTj/5c0kCkw TxbUwnQ+Qi0AAAAOi/YgTGt7GjvQdntu9vszp7UNl7BBE23oRFEHXBQ/wRZVaIVpwitkkEU32MI0 gRbV0tSvoje5ujbneapJ35ftL+8ghhR95n5OCbf4q/7ShVuk6DPPa11/bEnZpZwgvlp3gyj6Y1Dk dq3qNsnnbjcpcOJk1b3NYsMtevXJY08MLVgy0OJY+skpAGKpfnI6Z8fQR2yYhd2ncyWz4RR1e7M0 dZjF93Xo1IZZGBF0IbZZifebQAvxsleyy/Xa3Gw2IX/avdhVy87Qwi20AYhuGbLdmG55WviFdgqN p51BiAAAAJhb+T/mQ+oigJldpS4AAAAAEMpAi4vURQDCm+e9kEm4Q8Mp3EnAh35UpLVrxxqq91C9 pi4A2Qu5/zH0bFqbQMfdx93ueVqZQLAXsR4yMaa2jfsZ4gZTaJ9Rvs+pkDCLofp87QBaMWOhYoIs pmJsFn7LBlrcpi4EAABk4SNiW993aXc9JqwiZBu+/2Ju16kLAABk77Feaj/od5+j+cIrhsIu3H2M 5zgu7lEC/9Nd6gIAAACAEe9iPTQwYmxseOj4cd+YvZjxfID5EoC9+8dpGIbiOO5KdIEbICKxcQgG TsHO0pP1DJyAG7CwcwSWbg1N3TTO48V2rMT5w/cjWbXi0GdVRVUbxz9CLQAAAJbBvZC2M4Ef0ff7 d1MUT+e+u7F5E2Jhmw2xMJdgChtGUQdX1OEVTYhFNXZshVu4zYZYVI/2nqOmbhm1sfqyQgNSa+Yt SEjBGPWW9D713Yc+Vs00a3/f2Jr5X9ep6o77+rphFc1akrLsWuPSbNrvbt7f3le+OX7+CLv4ORyU 8hu9f52Tctwdd85JDRPIFUJQ18pRY6hAixyW9JrE1MlRY+w6S6mR9P8u+lqrAyuuYRamHWRx44RY yPHWqj4n5KKuV/3t/XYbM9Xi1J61pzV6oIU7hY14lAsNjRgzyph2TOsDAAAAAPq7nXoCHnzfAwAA +H/epp4AIHw4/dBCiZibierj2mbhMQEWoZuTuuYix+boc+oJYNXuzN9ry76Nb+Rjn3NeT+0hYY5A rCpw6TtwTuyNrb529DRtXPv8iv0sk/OWfQDp+J0dc0WgBQAAGNpXz/N9v51q30/7bCIVWw8YwuPU EwAArN6LaV9r6wqxkH1fcIXvudx7TI3od4VchK4BAlgXQi0AAAAwd13XLHxrvuUx2Q9dmwitYQ+t KU/b0BKr9isAe3ew0yAMx3G84rJEEu8eTbz4EB4871G8+WS+ifHoQ3j2MhNko5W2/ls6lgJl309S g1BpR5YQsO2PUAsAAIDlSE1/fxk6UV3ftj9vvL19uES34LhZ7LzR4RaNFXLR6KCLRu33XemCLNRf qIX5vQu06EMxTDGLmtuBGinKCg0Y095lLKa/9uta1vd03LsAvje52pz+us7Vbr7r665V7gZcXFmf M2UeuXteu78/hxtbqGYg3MIJtvC3zaL4wn4/CCOp3YxKC1VYSziDaWcKa/ksJbQx5rvj1z6ewzpm Aigqvb+qqn5kng6vuDZhFsoNuThuW0EXTqCFVcxL47vNRj1styndfrL+VMrOkMItpAGIfjfs/Uq5 3ZPCL6RLqCL7GYQIAAAAANPjWQwAAABj3KtuMQRgKT7b8hU4NjSJJzRRSFos/JwFx1MmHZUwyejQ v4+5O4FVewzsTx90FC7+8dezegoMe7O2Y5NZJaH7hh9EEQpbGgq5SJksK/V16fcpoCSxe9q/YWs5 OwJEEGgBAABykN7lnvKuNFY39LwbOk+oDs+/yOF57g4AAFavbstOb/v/G7O3pXALaS6pVCcWeuEf 8/GeE7g8hFoAAABgyd7b8p1YVxpDd2pIhTR2T2pjaKy58uoB6lcA9u4ep2EYDOO4EZQB1ImxQp2R uAEnYOYCrJyKK3AIZu7AFVg6VELky8qbV69jKwn5/P8kKwansVVarKaJH0ItAAAA5k9+gfaWlcfY A47Hh2IrFzGvQyzKUgdY1EEUZVBFWerginzr3Pn8K8ItmiU/lg/HKPvyYRahzydxywoN6NLfNIvp j23tz+uyXqfLeC9O0efWwi3G73OY57dcGL6oVT/7euwaF9fYNkMwXKM9nwv3+7ui/nM6JY0pFEhh BlhUddmWutj9msIOhuqHoIluffx3P2v6uwwRaNF7DKreuNquCqaQYRU6RSIvVyLE4lIFXTRSI0TI he/vOqsfdruUod5n5ck6rLMDLeQQLtRWB1w41eaMNut3Vh0AAAAAMK4+n8f4LAcAAADpdeoBAMqn qFsXRaQsWib367OQeNsi4bGFwufIuuHqe6KxYBtuOjwmZXEc/TX/S1YOXQYIJPpw4cAlLzbvyP+9 et6x5qSUuckKttCPsW6cDc1dc5/HgDnifDuWIn+tvjsCLQAAwPBSAoqtttD5XL2PC2xDxwidx9Xt QF8s6AsAGMNzVm5dexB8KJxC30/adp+pdRwv9P2cbtd1AOvD+WUAAADM2Zeod7nWXG9TrttL2dca Q9sYY23YgD8B2Ltj3AZhMAzDv2ikSFm6d2mnHqPq3KVXyNaxJ8sBOrZ7994kUpYUAg628Y9NG2Eg 7yO5BIOxFalBEOKPUAsAAIBpSEl9r9bfYgfa7b7Kv2uv9nieyNwETtTl2IRbmHAKaYIqpBNsUdWZ UIu6Tqw2bjiGHZ5R91mPYQ4T6i99Mv2cE+nzvk6lv3n8L+bo81rCLfJ9Dvz1/XXnLG9DKdqJ892w C22ecxH3GRT3GKZ+s7k9LfeHQ9Ko2j6lDa/Q1tsG9bIo3P1C/YwUEGD6GqOPSwVajGFO70lKP0vp Yw7BHP9uHziek+5Qfn6cnshr+ima7Sbs4sYEWHghFnYARmFtPwdaWMUc8261kse1f30R9GSaWsXP 2fDDLfz9O8Pw6sWqF+k+gOgvfSnXXQAAAACAcXA9BgAAgCG2uQcAWPZl+U7Yr2/ystiPg1JK30Ti feOQwD5a3VR85h4AFu2+Z1voOV5tP23iHON94LiAIapz04e1rp0LQtvsutgPXP0wi5Tit089b2lj BXAZqffouZePsZhAi9fcAwEAAIvzY73WrolTrj9jQRShZah9qtj9XCDFQ+4BAACuQhUg/9K81sIl tDCLWF0sFCNUfNzjBK7Hc+4BAAAAABHa8+fa9wB9z/WJhL+vGFJixwZUvwKwdz85DQJRHMcfxYWJ W3VjunXjQg/gwq1bL+Dac/UMXsPEK3gFk26aWEvJwPCYN0xNAaHfTzKB8m9G04bAwPwItQAAAPjf /I6zt125i228Wr3LcnnbCJYo+CETRSmDLJpBFGVwxbYVZlFMN5ufxme/lMEW9UDlLjTDXYu0xy+f xoD6cx9Mn3CLvuqb0vd0Gr/FMeok3KLvev/y/7WCLdyyTJphF/VyK9iiGWZR75/n5/ul3+v1gW3U TS6DKnTgReami0U1bx9iuOCGKQUezCU4wdUzhLn8LVOoo4/vjh71wgVc+E/iucCKfZiFSCvI4swL schV0EUjNcKtq0KDsv2+13me0tSbXXkMHVbCgRZ+EzI11Q8gilongXWhZaF5AAAAAEC6qwHr6rpu 47oOAADgdD1JfMBxYGjFC0XWQwWxgbn9ZakvBenBxK3PKcew2jEFn2M3ALN2GVjW6qqXtL5oqx/7 Rco+daAvRaCFOzd1veDq5lPPO12BFHo/HbqUcg6LvRBrzQOw9T1wG/frcWwu0OJ17IYAAIBZ+jpw e+ueq54PrdNT63rXum/LdS+O7X7sBgAATsbzrlzIccIsFkaJBVyItPvvQv14AObtYewGAAAAABEf Yj9/Xujqf9Dbhp7dC+3bVSQy1ccDKr8CsHcHOQ0CURjHn5CyaOIFXHsFV17GjefyMN17kpq46Noq LUNfH29mKDrFkv8vIUWEecSFLXR4H6EWAAAA8xv70MBrbqD1+l6OQfbavm9a3jYRPwVe7LtwixBM IV1ohZhgC+mCLfYq+ELUMefBGDo8I23aNcpthQZMqbfsEAZd97r1lv13JdyiVD3CLcrWnVJ0+PZ4 HnBx2mfYVP5u8Duv8XxdN4fXj90uUit2avEx+yb3dmlV/q2ZJYUd/FUdgiam1ShdZyk1Qp05jx+M Z36ufv5fVDrQwgmg6GfkdeEVdQizkPOQi8O6CroIgRa1Hk+dw8NqJY9NM+a0n8MpqMXmbNhwC2+i oTcpMWwXtV3M/uK8WqUf2gYAAACAJfGaOgIAAADX9jL3CQDGRq3HHhTytsWaoeUafNvG4GOaiscm BN3qg0WfcnnzOWAse/9jyvfHsaY44ZUGzShpK8dQixgvFCLVmDO1fGUWb1/v/czWTp0rAF+J+/e5 eVdAKW/C5yUAAFDO9oJ9x16n2mvaVLOn2D652sBv0dAXAHBNbZObp249Fi6RC7jwni31jsmNO+b5 Ue6BAsvEZ2AAAAD8Z+9qPfVdwSXz0O14sfl6qfnlqWALwi0Q9S0Ae3eM0zAMhXHcQMXMBaCMHZg5 CafgVEi9AAvHYGcsc3dGRNLG8evj+cWVkiZN/z/JpGrc2O1AlTh9H6EWAAAA0yUXzF6r9uR1Xq8/ wnK52j2WBcplyEQKs/gfRiFbDLTYh1n8tiEWKegiBmHIJsc95pzjPArqz72Y/qUU0p/750q4xVDj EW4x3JjHfLaH97CkMIt030gqKG/9RlyOW7f0+sNC9Ivd3812Kw4hQij0rJx97WtV33a8GGih+hCq YB/nFM7pMykZhzHKx5haoIV2Lf9PiK28E0+GVegUibotRIjFjQ66aF4T30cMuojv7bZqdbBFgfuw D7aQU4g3ClqBFnLqV2qrb0IMal8w9lnPWY8BAAAAANPhFXzseh4AAADzdxcobIlpqQugfRX0yxUL z+33ioeXBljkxrF+hOQVZ5uien6bsSeBWXtott61h9zatL62ofs9V23VwxyBnPeq/TSPSwpj5n58 6n0P5QIsSgMuSr/fcnP13htwqepQizGumXOdHn17C5z3AwCAYX0X9vNCJ7rOob19uXNefWygbxT0 BQCc2ksoC5ywwimscAsr9MI7Rgj2Op5fdADAnDyOPQEAAADA8Zl53lsn6FqL0PfhWX261jSsOXSt XbC2gfAnAHt3lNMgDMdx/I8umZnx3UefvIXZFTyGiZfwakafPYSH8BGVlcK/TVsKE1jd95OYQcto XXRkrO2PUAsAAIB15aS8N56GTrTb3UhdXzllZrFwu3i3Dp7owyhMOIUNrRAvuELaYAsdeiHqOeZ8 JhzjW23b9se8FGUsqP/fF9M/p4X0l22vpL/TMv4X12iTcIs520y/tnaR9T7I4rAXKHfHnPQL1eet Z25OZ+q7UAtvofpoiIUtU4+VX6f3VcBF17sFgxtKCSNYsq+lvCan0g5t9M+fs5+VuH207xmVqjuM zFNhFN2IvDa84tKGWYgbcmEDMC7UOXTChIj7rnm72cj9dpvT7QfbBXGzNfR2LNAiNNgwFHIhqly8 4yXw6Mv9HAYAAAAA+BuxkIqhY/msBgAAgMe1OwB43hN1qeCI3IlCepJRndgfO9ko1t9T5f8ejdeV +oLzcC159y9ygzf1993Px3UNSGrClt4S9cdci2ITX0PloeuUXx+bCBu6Zk0byAogx5T77mPGYAFj vAiBFgAAYH6fgbLUvdzQsSmphZ9ytnPaAKa4W7sDAICz0wTx7tvtWLhELMDC3w7NLc0Jy9Bt+8aM ZQZQpv3wIQAAAMAqPn5/vhL1obFzse8yYmPtUuPJY+cdGnvOOD5E/QjA3rncNAwEAXRjISrgiJRr uHGAGweKoAGO3OiAQkgNlIJEBRQSKbCOWe94vb9Yjjc270mjTIKdGUURluP1PKQWAAAAAOeJvGj2 ouMmtvF2+6HW680hd4eRm7wRWlgZhZFPWFmFDSO22O32rcSiK7uwUgwjs7C1frx95DPs/GVe0oAh 9ZBbjF+vjKBg6nrILU5RD7nF6WqGP9uunEL1cim4sAPgpfTCeCT6Youm5Oovbx6/a6lFalC9T1Zh 6vmiquw2VdXuM5VQoe1tJnXm1Ou51Jniu0SN7nucErdH339Ad2WeEVYcZBZK9UQWF0ZiIYQXRmzR rgYUgoxWbqHzSx212CKDax0PqiuyMIsGXaHFSrwuFx/6RBauzMLn3nA/mlgOAAAAAAAAaa5Efuw5 1RQ3f3GOBwAAALB8Xks3AOAgB4cPGWYWuyFo7Ij14v5tDnyVbgAWzSbweo7EIjY0517H3RgNAgR4 F3loIGbO0EzfcUSKKvaJ8O3je55zvPIxl2MVwNIYU4AB4PKs4610EwAAALB4ahlkbEhUiNhvuO42 KvAYOi9nOBRMxWPpBgAA4F/ypML3esbkFj6JRUxykSO4yBFdAMByuC3dAAAAAABAhE+RH7tGLnXN wV3z58tT+6XW8nHtAnr8CsDeHeM0DENhHH8RqGKtVPYO7Ows3AZxKm6ExNgLsPYIFQ2OG/vh+LlV iJP2/5OiGqfpM5UoSuL6I9QCAACgntSNr1Tfm/VC6/VGDoeHqM8tDO4XJXdtF2TRh1G4cAofWiEq uEK6YIsw8EKCYyR6zb6Wr98/Em4xZj3CLcavx3tqHC1L+FusUZNwi/+sWRpuoeeUiPydX+L2RwvD nxaK1/uaY113qeR7v88P0h/jAysKn/cbZtEFWrTtxjp+JFMFZ4xVZ0ljnVMdakxTY6rQjVM7VV+C T8AufMIHU4T7w/AKH1Lh0yTu1c930gdZ+IQJUXXaUIun1arkV3jxQ5A4WyNsN6rfmnCo+yXoF0mH X6TeQsn0MzkRAAAAAGIb+ykmzrUAAABwqe1xe649CCCwE7cIWoq18FhuETRr4W9rMfCSLTWWpfmq PQBctcfMvtw9Zyvs4v3iEQG2XbflDC2qaW0lwRRDwRa5Y6z/h6Laotq1zWksgGWqa/MldbhPAK0N tPioPQgAAHATwuu5qXO6c85BrfNW/Zg6tpQ+TwYusa09AADATWrnHb/KeaET+julue+VlgRaiMTX JHV7aB+AZSPUAgAAAHP2OdBvBUkM3Y8YY2557n7GGPc6cOV+BGDvfm4ahsE4DPtAmQIRjhy4MQE7 MAUnBuoMsARndmADTlyKAvlTB9uxPzvCiZv0faSorpPUH5FQlLrJj1ALAACA02NOhD01y5208X7/ oqrqtmu7Dx7X7TZ4wg62UENAhbvoYIvDoR62scMufqxgDDvEIny9QbhF7vEIYsg/3nkc03/srdbw v1hiTMIt5hzTPLZ/p0czhGLcHgdVuPv73/fquu9rQy2+2xNhP6D96mOu0w+8d1+H1YG+mSwREpBr nC0FQCw1zpaO2RrGKF1jKMLHXHRARRdmodQouOJCh1zofh14YfTpGnSfdtm8v9rtUv6Ma9UHW5gl 6B8MuoEWZulmuIUvyMINs3CzN3yHRmoDAAAAAPKJhQv61nF9BgAAAMlz6QIAx5vRnnKzjnRTUcqD xFNvKvK9j9W2Jh+lC8CmpQZ7SvPN7vT9/XEB5vJqtKWbW2PbhM5DoaCKWMjFlHNWrMZT9Vm6AGBG 0nkOyOFBEWgBAACWEwuD9JGuX0MPk5K+q419j+v7bCCHqnQBAICz9ajC93r6Ai1iQRfSfikhFym/ bwawfjelCwAAAAAC3pvlS1jvmy/wzUekzEWE+qduJ2E+A51fAdi7Y5yGYSiM469VpLJWYmBiZGDj AEg9AqdAnJMdxEHY2SpqmrT2y3PshAQn9P+TIlIn7XMr0SiNnY9QCwAAgDKsC17WjXxeUi+03V7L fn8VtDUBFsfFD7M4h1EcwymkDqwQFVwhdbCFH3ghp+e4df81z7Wa+vH+Em4xdr3LCGLgM51TvWX8 L5aoSbjFlDV1uIVE1sOxLWGwhT3WRIdfuGNbe5vN3F4HVgRN/v6rMJhjtV53h2X80pJCFQiaGFbn L2pMXWcpNUr2sXWi4PYVb1RdE0jhfcecRufVIRY/y+E7xw+xqPxwi/pvE2TRPBZV56aq5G6zyXlL jxIOHgzKSDvcwgqy0AMPdZt47SJ2+IX1EUpHO4MTAQAAAGC4oaEVnJ8BAADA8lS6A4Dn67C8ZewX m+ij23Ju+t11M/HUBCLrpmtLvnm44/r6WroT+LdujbbYwCT9ODYw6XmcrgEmN9E1dWPOnMmn1rHG OvZYxyJrsZ6Tu+h+6/U5+SjdAaCHMX9rT4Va87s+Uh4kDGUCAACY2mePfWO/sVrr1jm33tanxlzP f7Fcu9IdAABcNBcmfy95YRPWvFEdVNE13zQ3xCJ13Q/A8u1KdwAAAACIePfWY9cDrOsFXdcgcsfj 9dlu9YnrF4j6FoC9+8dpGIbiOJ6gTizsSChiKxt/Ns7BJbhTV1auwAkYOAKXYIlEiVteaz9sx0FJ 3bjfj2TJjZP6lSUqdfwj1AIAAOC42D+APXftJnbyavVaNc1y09ebjEvfbM7tBltsQykk2MI0CbOQ IIu2/d6FWLhhF2snGMMNsVg78/Yh3GLs+coOYsgxZ+l/U8ItppyPcIvp53QDK7b92L53/mfI93vH 78ftz9Sam+Gft6z1xdZQHT73t+02rfe1Ec0tVKGUcAaZ5xBK+SxzmONQoRvJ53r6eoWeJERsgixU 325n1pgEXch7SE0SciFMEMblYpFS6lXXHtVUsmBQB1rU1nE73EIvPNSLCuV45RnzHevbVAQAAAAA 4FpGxv77vaovgBAAAAAwTKBFk7sIwGICLb4CY7HNzuxjQx4UGrIBeMoG4bqOObFr/shZCIp2rl4P DerUG+U8dO1+nNIArxern3If0nz3ER1esVavU0Ir+sIsYvXN7f4ElMK3jmqKtVX8JoDrrr117SJ3 IQAA4KR8Jp4X+84a+z+s71q+D+MY3OUuAABw8p6sfugxWF8/JeQidt2QoAsAZbnNXQAAAAAQ8B44 Hlv3FxrrW1ceWwPoWzMYm6OKnAtUPwKwdwc5CQNRGMcflQQ3JBKNW3cmxit4CO9g4vVcu3dtPINr 44q4JFDbodPH45ViO0j5/5JJy7RlJihpWqbzEWoBAACQnjfrdvz6uemNZrMrWSzOa3UhwKIIsYjD LKowiiKcQsqwinp4RRVsUQVZhH2KpdTeM7S178TmhFt03d6wgxgO0ebQP9Nuwi32aze1of/vFG0O +Ts5Wuc+hDaL1/WxJHHYxebU73rsiW06vfxdfs/n7XupQy+ipQ60GGVZ/ZiOHFOoAkET+7WRImBh KH+XLgIt+tTms964YCgDKNalDJ/IojCKdVJEHmhRlixa5mUcjpMo7KKsCwkTotq5Ho/ldjLZpdsP sjmA8Eyt6ywOa9ChFXAR6iSqF7HDL6yPUJx6BicCAAAAQHpWjqNeBwAAwOl4PHQHAOU1WvcmNtN1 bQIovIeKmiYJ1+1Y/Tg2Vp8/kvcCp+SuXHr3IqzBR9b+T111CjC8rcpXwz7eeafpnKLDK3TR5ye9 bZcHY7edu7wHcwH0jyAL9OViVV6EQAsAAJDep1HnXYvq7Xrp7edNBsX1LlK7OXQHAAAnL//d7V7a hU54JX6e1Au68EIsrEkHrG0Ajk9+D5r7zwAAAPiP3lflx9ne9BvFX8aitz3e6g+w1VIA9u5ep2EY CsOwCxWqkNiYUFlZ+Rm5DnZmrqvXwM4VIHEZjJ1YiRsOOT21HadxlTR9Hylqmjo5ViVI8+ePUAsA AIDx0Be+3lx9kS5qtXp3y+XdZt4OKC7z9fIm2ELCKSTYQsIsbKiFbxcKt9DBGLpGiWMQwi1K15t2 EMMQNaf+nfardxx/h0PVJdyiLD0AvK6nAy7qz2eqfTMwvazftNlex+8vF4urTdvv9Tq3U7uD0qsA Cx9esfW5bq9fC4VEHFqpwAOCJvarM5UaYwqLSG3jkPpsP3S3nL1DzydEzP9CK84DwRX/ARayXAVd yDakjxJyIS6q9zfzeU5Xb6vp2ZSSGwZtoMVMLdc3GIZuPLRhFjZ7I/TVpOYBAAAAAHH7HDt1WSen 7U7WY8+aAAAAGDf/oPHr0J0AFD9weGjwMy80GFns4Z7ch4m6BFjE6rQNFB56fwy+hu4AJu3S5Z2D iH0m16CfqumxYL8A7cfVg4KL1P/22ICb8qr3OzaQwu6LYgEXoaCLnP1WTl8BpF0X2EbOoG05y7vs L3GaPqrpfuhOAACAkxM7p5vLnnttG/jJufCxb+y8cVtboI+HoTsAAEDlRc2HAiVsMMVZYmpbJzcc w/YFwDTw+xcAAABj9anmY+f+U/ec6/clp1gNWy/WV8D9CsDe/eM0DENxHH8RqYoisTMxMYC4Aofg Ckxci2vAynVg6sBKQ/oU232OnT9Nm+j7kaIaJ40NA21a5/0ItQAAAJhXTpGd+j3aW+pEVXUjRVF5 fRpg0YRYtGEWbRBFE1hR92l4RRho0QZb6CaHvuZ57jl1LD/gYhzCLaYeb91BDOcYc+1/U8ItTjke 4RbDWetE/Frk9Zhugfi26fZ11TFv95Xl9X/rZ7cbMFUnnOJQGN7rd8IuNPBiqjCLJQUerCU4QceZ w1p+lyWMMVfoxqDnGefxVtVpeIUTTqHHaHCFhle4IRalEXqhQRaaMCHi//e83WzkfrvNmfazHC8i vAraRdAfW4RoLVAMAy4kOFaMxxDFUAEAAAAg7qFj39Brp77FscaOBwAAgGV5OfcEgMBnYn+qQHfu DUJWYfBYcfDwuHAcaz7Wz0tDqAVO6S7S3/V9s/Wd9OuUkwICH9KELdVSN7lqO/Xak3pdygmqiIVg dM3BmqvVBmAbE2rBZ+2Y07sQaAEAAM7j22nHCi/lXot2FW6KXeMOvc7l+hhToKgvAOASPO63JzkO obDCJlLBFLH7S/uGWMQLFfC5KbBkvP8FAADAJfrdb1+RfalACX0M19r1WZOes27PKhrJ9xTI8icA e/eO0zAMx3HcTdWZiQ2qjoiJmXOwM7NxBA7SM7BziC4cgQMwdUbENE6df/xKmmBqvh/Jwnn4QZco rZMfoRYAAAB/g/2D11NdbkMnb7evar2+6YVKaHbAhAm50CEUJsBCh1GYwAoTXtENs1DOcAu7XTfE Yp77DcItph6v7CCGHGOW/pkSbjHneIRbnOZwyZQBFXr7+LnK8IpQKIbsS6nl8vCS9s/9fuDUFv1t EXLRCbeoKne7gc4pVIGgiXFj/EbAQgljmHFytk/pf7JwGEe9DbZogix+QixUE1ThCK5oAyzUMfTC BF20q/qa+Zp95v/QQRhXq1XKVK/rci+GMgsGZaDFwtpvh1v4FhsqsV85jrn2ueoAAAAAgPFSwih6 WY2edqcEW3CPBwAAUIbn3BMAhJ1Vj62ESHlQKPW81D5kf3KuoReunaP33BNAsS4Dx1zfa7jqd4oX ZmA++iHXt8Dx2MOksevHl/V3aJHtfdeu1LkCAMrwUpfH3JMAAAD/1seINqH72dhLn1SgjasPOS4w lU1dLnJPAgCAxoNVdz3kL4MpKk8JhVnEAi6UZxtAOTa5JwAAAAA47CLHU9b4hdaO+87z9SHbp/x+ 4ZsnoL4FYO+OcROGoTCOOzQSXZEQM1OlTu0FmHuObr1Fj9SboG69RDshdYQmJA7O49lx0pQ04f+T LJxg4tcOICLjj1ALAACAy4nZmCfN2kvThRaLpdnvb50zhyrAogixOIVZ5P3iuAisyM/Z8AoZaCGD LOwY+7pTQMahOq4HXPSPcIu+55t2EMMQc079f3pt4RaXnY9wi9/xbudeznseVqH1izH1/fOSJD0+ fu12cZW4wRX58WxW37S+7FfjfEEXHYwpVIGgiW7zMEf8HGMItOjlOsp1q9V3biCFfe9xxtjgChte 4YZYpCL0wl7DPTamnh6xSlNzN5/HlL0x5wsJb0Q/Eed9ixC1BYoy4MKIsUZ5lLpspAoAAAAAaKdt kIXvxl7MNQEAADBO66w9DF0E4Nhm7dPzXGhzMu289qMhuSG43Fi8bfPV0m0Rz/+T/w3vQxeByVpG jNE2v3H7T39QF2C9Ze277Pve02N+sKp91shAi9BrQoEWoTm0zytf3QD60eXeOffb0ZfnrL0OXQQA ALhqHy3Ghr5nN23iFBoTmkP7fgz0YT10AQAAOO6ztjL+wInY1jbMwijHxjlvxBjtOQDj8Th0AQAA AIBi6/Sb1vv51tW5z2nr+LqsNfetbZfz+WoFjn4EYO+MdRqGgTDsFsTAjsRQISbEyswAD8FLsPEm bLxAn4GBmZmBlY0HYCtCHZpgN7nGdc9J2kKstN8nWXYuce8apU0b+/wfpg4AAAAAAJYGuu5tuaw7 eDx+NqPRxWJbFkQPBSZE5KIQoRAhikqwQsQrlsUsjCpuIcIYIpYR+uhijWrxu74v+Q+0XsfN/W1G 9/7y0l83Drt+fyl87vo53c5fPz6H6XzmnV03lc+i7tO5defICVWENl+4omhWAhLuHihtPZ88Fmux HvrXZBKPpS5WU1z189oTtPD7LAlcbECfBCL6FOu++cHH3/RP6UO+bxxOgCIzirrD/PszL0YM3DG2 LcoRmVdnphK9kPawPDYrRTHcsTNT3rtsfWTtTtjiYzptCnVky7Utr54rmTB44NmkLfbc2yf2oakG QDQxi5kxKxMJ5dhB0C9sAwAAAAAAwCouoWydRH+hSVwQAAAAAEDjIXUAAAFNCUUxW2zh7jZJQtoi 422TidokFfWJxfSLctu139OFAzvOWbAdjiX716LGqUHUAv4PJ7D0UrNfE4WIJby2vf/EBCza3re0 2LRY+36vAtgXtIXdeP4PMa5seUwdBABAwKepROKE79IeQ/Zv+5vV9XeLuJ54tnNbjpU2APwdmlhx 3TPeuv+vst32WW3dc9umeAC25TZ1AAAAAAF3tjyVbS3HU/JFh57dzyH180t9u58zOlD6Z8F+H36H AewWN6kDAAAAAAAI+LHlLbKvaT6d1HVjEJqtbv557LWbxkYAovwKwN7Z4zQMgwHULaoqFSE4AEMH JrgDZ+AELFyPgRswII7AxgISC0PHriFO/DXOJ/8kVZso5T0pamP5r1FVp85nP6QWAAAAAMMQCtgP Gd2fchWtVhdGxyk2oomi2sC7FlAYT0RRCytsmsgrtNBCiywkj5QTQYaILXyJhk0fcmP9/TfV719w WuKAfdorXHunKWIYo81Tv6bILY7V3rDfm6Zd49qdRpsisWgkFVpUEVonN3PXV+QSWnLRrr8e386q 85/Npkundh9qNp9Xg2Ih6X69TmCxk1k0nanK5Va9634OAUKL4dsYqh3aOGwdY9Tf2rXF/baIaMIy d79NIrGYST4RWjhxhbU/iKjCptvJYi29sHVV0XxOjOFH+Nly14uFuVkuzWdebGGlFu+mEVpIM4Vp Cy10ug5KlIcnfqChMe0bDemeH3xYBF5TlzaVBgAAAAAAAA37/G+KPTfrsylWql3+ywEAAABMl4ex OwDgYRcUvXXIF9s03Kj0lKAilSe1kXiuH7ovofOpgdQCjkXfDUR14NLjYbsD0OLFe99lI8zcQtTU YlYtsYgJLvTYlDuPjZOxzwAAxyUX2BYLyu1aN/P3/5er8ngtj8uxOwIAJ8m3qUUTli/v/dY0corC 5GUVXcaivuNVLv9Hh7LnphZcWO7U623P/gBAWGphyc2d5uZX/bTUfHAob2pul/tkOBTrsTsAAACg uC+P5/L4dee+2ELWgcbkFP65vGpZRahMaAMC/34rJbdnDhNgWqzH7gAAAAAAQIBc/Hnu2UMs5q5L PGCqbOq5Bs8uoBd/ArB3xjgNw1AATaoeAQkJiQIbbMzs3IBbcB8u0DOwM7CyVYKBAbYeoHND3NrJ j/l2nJY2pH1Psvob23w3ompa23lILQAAAAD6RU6IPWb1QkOV6fQ5m0yuVxIJg7sJupRM1KKJtdDC ySnWcVHJLHyphWmnyS3c33EyC5fPfc9oHtvPjdE3zyXnEbvnHMpN3zfLV9h8hyli6CPnoZ9T5Ba7 yrff/5s6b2bzDiFnLafQ47wRN89lXuV19UWRi7h+NHzO5y1DyasPiFU/rd5/gVJsIceXcCKGJlUY itTg2PKQ42/6/7cc/mo5ueJutG5YSSmc6EJaJNxjZZSw0gtnlljavksjuLCyDCfRGJfx2XicIrU4 L8tdWV5FqpEdpi+0kNKKkajzZRbqy83qhYzuuDw1/mnyYwAAAAAAAGhy0rG9JqaItfXbaMcAAAAA 4DgwQouLvgcBIHiL1Gkbd7Q2sU1BXUuKFCM033VI82BILWCX3JTl3cah940273xalvvdDg2OGHPj 3tgm15QbZaZ8xoTESrI+JK7Q+sbGk3kxAOyHbX975/d7aMMILV4yhBYA0A0ppPi2z6WU4ssec8Su ITeti9V3vWbd5hp3UZaZjWeBNmbvqZNfXNkY4QXAbz5a6lPfq23fa7U2mfI89PuxdizWByCF274H AAAAoPBQlicbx8QTKUXuLZXFl1towgyJvy0XAIbJZd8DAAAAAABQkOv92uYhY3MDsbV+ofqU9ed+ 39SxAlT8CMDe2eQ0DANhdAKqiiqxBLFiyQYkLoAQR+AAHIDjcAl2XIALIPbsYNclZcEJWuLWbiYj u0lQ26Tpe5JlZ+x4plWVpPHPh6gFAAAAwOaJTdy3Nvdc9ljV0Wh0LNPpUclWiEosRCeCeIUrO6GK cOyEMIJ4hRW0sEIWoc3ifPH9ylLYQotnWPosbrFbm77/19/M++unEEMbPvv+nSJusSl/2/3dFH7F ++2qTzvvRCJl/b3F8+IeZutDTIvjLy1qoQQs9E0w8xu7L9tkSiQjiF0oEYtSG/vpdF+Rum2wDj+7 FGtX/PBZtutjF2Ksw4ER08n89SlT9eIFKKbePhf7CYIWXrjCzco79Lmzuz8mrn2oD+2XghZSnv3n zjsbDORiOJTPamGLmzy9SSFWEUQsZlIWtLD2A1XWgyZ6oqFI+eEiNulwFsktMTsTEwEAAAAAYJ9p KmqRwi4IayJ+AQAAAAD7wX3bAQAYXlW56aZjqUU/qcVBdqPw2MbhsqLPVBx95FcWG7yftx0I9JLY e5Cq8WJX/7CZcADmPKtybNGqta9qU/f+Y1PVOVULY+vQ1/sWwC7AO3pYF095um47CADoHD95mqh8 Yo4dqWdYy382Uanbd936pv7WzYfP343diS2e5OkqT6e+fLnhWAC6zFiV61w7Uu90bdmem/pfnnqn uyoegHXBMzkAAHSR2zy95OlbirWdYQzOClHYdaSxsY0mIhhi/ImyibJliTIAdJu7tgMAAAAAADC4 cdBxom7V2GVsnp891rbUHD4reJHqu85cRIAkfwKwd/46DcNAHD5VAjF2YUGigglGZmYegZ2ZkZdh 6jPwFH0AJAZY2RiYEVIFxWlyxL3YiRvahLbfJ53ixH/OsZo0Tmz/ELUAAAAA6A//I9its7O6xOPx g4xG53NxiQxd9NoXmSgFLnIBiqqgxWxhW4pZSFDcQstQMQstO6W/gbjFatF11Lvzl5/ktgox9OFz 29sUcYt1+ev2d1P67bZd1WdGuriFtosNV4UqtP3yjSc64bVvHlTRizLv53QqB3t7wRrMYpUNHffE LBb2jdBFuLjNWYAfcYb/6Qcfqy2jz/JjPkKj5fy74SDPmAvhifwKXfgqErqdh4t4Pabp518uVNyi KC8rf9+Fj9y9MkHU4tjZpbOJlOIVg6KaVtDCF60YeHFWzCJ4ulIKWuhxv2lsM9kwAAAAAAAALE+o vxVL16Zsu0//DQAAAGC7GDq76bsSAB6pE4piE4Vs2qYJRnYRjrr4poXSQv5j+5tIdg6PgqgFrIeY uKf/zsNeR9nCoVfrrBTsNC+F1dE08TT035IiptQkcBHKk2JiwiLV6woAuif27h7BC0jlTujXA+wy KlDx7OzD2auU4hWWpufA2LNhStplymuTPiW+bdq26H/1W2FPJj7rs546Oym2mR12UC+AvnlfIm3d vST2DlYi21hZoXe6sTwAf+Gi7woAAADUcO3sXuLzPFOtTvBiJlWRjC+TX/GfwxiXDLC5DPuuAAAA AACAYdIQX/etIGW8XcoYve9Ieus/NPbc+gMI8iMAe+eu0zAMhWGnqlQkWCohVjow8ABsTLwAD8DE wuvwKuysSDCzs3RnhaGVEmJiJ45rx25pLiXfJ1k58e24CMWxfOIfUQsAAACAdnEF8bsO3nkIdTSf n4o0ParlVUITWSlkIcUopC2FKqSYhc6rRCtSsV7XRS1MIQvZTl9l+6JfUQpb2OIZIRC32B/9HOCf dXqYPiIFbfgTyl8n7hC3aM1ft/83hU+hfHbmMtJvPW7E/JtUdlKz9X0h1lHZuswUtCjGUE1w36vV pqiF7Fs9HzN7MtR+rR+QmPlqDBu2/UsPTFThUEQNxuYHH/tpP1QfdqRcop9P6n6i7rUoRaLqJFrQ QuaLIiqvFLVQdfXJA7+KE6p+KWgh6hGAst7ZdCouZjPxERa2uM7Tq6jEKrSIRSbqghZ2/sSwzU0U MxBRiPoLhSvoMHNcbVz5BCYCAAAAAMBYuXTk2cKAvnWUy/b1tavYBWs1AAAAgP/Bfd8DALB4DpSH DliM+WBI73fZB4SHPjDStu3HN7ZDXzfZ+3rSfs/TbW8jgv/MeUPZxha9SnetjgjGzpNhxzzfm+r4 5hPXvJR6yl1zV9OHtC4OfV4CGBJS5GvZQr8IWcC23OTpse9BAEAnSAFQKVSxVOlTXbd9N3Xdx+Tt 0mabdjFlf23bJq5vVrXYxZuRfyIqgQudFh2MD6BLYt+Tm9awvsOd7GvT2jjkF2DfLPoeAAAAQANX eTrO05eoxw6b34f6bHufIlYAQ/twxTu7BC58dQFguCDsBgAAAABD48WwY+LNfXWb4s595U2x53Zs Xyj+PJQPI+dHAPbOWKdhGAjD10gBiQdgQhViAokXYGbjKVh5p74BEk8BIwMMiJmZiQEJCQp2k2tc Y8cuammSfp90qhOfz27U1mmc3I+oBQAAAMBmcBfBroydtDlPJjcyHh/PxCUsmkDbFZlwhSasAIWK Wdg2lUBFI1phRSxU2EK3fXELjaFiFhr7r/8tELdYHSTTH0afiFu0tq5fu/1d3ESf2/J9zOvXv5/E z32nwhahnHgjiX++RrO5syx3zVz5IZ92ovRaJmfCUSO48e0IVqigRkjQYu47D9EfUYU+jbUr/Qyl j//qp+uCFl051qG75dxfwKIKUgni2fpavGKuHKECF2af3f6SRYUJ9Z+tWKi4hSPus2PKB2WZI2ph H6Y+M3YnjXhFUQ/TF7RwRSsKp84Xswi+XWkELXS/e2j8w+SXAQAAAAAAYDWE/tDGhCyW3QYAAACA 4XC56QEAeNw75ZwEZCkL+YUSiefG8OP5Y102WWPfeNj0AGCw7GX4uOvN+8bO1zoi2GZujT0nfHKS aKbml2mLhepz48bmMmkpA8By5MxbFnfuWjckets+DmVRhAkAhsG7VAIWT7IoXqH4v/Wp87s2/1T7 VLzcayB/GVdu3ap9UsQfhsnb/2bssTa3/lQqgYsjQegC+s9LYF9ucqZQXdt13lislA/nzbAOSOgL AABdxl7PvDB2LfHnPF0rEvunXrmtjdapn8jv8zGubQL0E86BAQAAAKBL2PWJ10hdzhpp6t7z0L17 flkCMUKxcsYIEOVHAPbOH6dhGIrDTlVUJCpBEXACBjZOgMTKEbgCp2Ni4AJsiCOwMXaCSh0CMamT F2PHbpo2Cf0+yUr8J34mahtiv+cfohYAAAAA26Nukx7DQZYeQh3NZmcqTQ8rZaXQxHchZKHFKPR5 LmJRlknRCilekYtbpNkxLQQvzFFfn/erCmELWzyjCYhbtMe+bKbfv43027a32/s6rM/pML6LXdjc N3GL0may0oJIxN/uOk8q7as+J2Vf7j3xclGL6fRUzecfarFcFjW1+G6MLLfOpbhFUa/LQ7ZaoK3P Tl828x+KjV3ZwUa7fXTZf4wN21Put33242muGq3yRoAiWbVJjKCFLs+OUuBCi1YYRQnj2WfaF4IW 6q8338V4rC4nkxhhi5ssvahSrKLQ1lBVQQu7fCTO5YKKdDhUqvpPhC434ha2k6M8hm6trwwAAAAA AGAf0AKFroD/tnBN3NnCF773ON7VAAAAAIaPDi6+7noQAIJXFRdQ5AvqCQUT2ZuCb5p8Y6kLOho6 b10PAP4tV1be3tTGnoe43/qIYJ+RG4Svu/FlbDCr73nkErVw9VH3XHKN9b88l967HgDABtQ5oyEs DU14zNJx14MAgI3QcyB6LViLVhgRiy9R75v78NXH5pu2W9dmzPWx/cbWNWnXhNCzuy621RVMYwtd HKlc4EKKXZw3GinAblmo6u9YLK6NnOryrmOojxgbAJtw2/UAAAAAAtxl6SlLn6r6fhIjaGHHlMo2 sk7mZRt7vc9+L3KtB+KjDNBvThTz0wAAAADQL54D9XW+3rE+4iG/8tRxrc+vj3ULaMyPAOydu07D MBSGTVCpBGJmgYoNJBZmRkaegpW3QurIzBuwgsQEI0zMwNCpFDuJG8f1JSlpooTvk05zGh/HblXl 4trnR9QCAAAAoH3MRDw30k5CwdPpvZhMTtME2wqdyNwUmTCFJpQAhRazUHUygYrFUqzCJXBRiFvo eoWVRSyae8ZA3KI5hp5Mv8tE+m22O/TvFXGLTbXX7u8ma1PkbbbWZN6ma46IW9ii2GZ+uWw1P95W mui9/IHG4335+iG+ZrPqvzxLnEK/T49vi1fYcabIxbrKUZW72R9BiyEJTbTVDm00U7+vbYRm1ukz 4HYubpHGJUnq6xl8arBY+XO5TylJzEVZYUKdy37yuktxi/x4ih3pH45GVUQtjqRdSHsQxQTCRHdR lAUtTNGKxCizxSzsj5vk/lysfg0Lhy8cPgAAAAAAAGTsGX6dBVquBWd2GQAAAADAddcdALB4Mvyq iQ99i4j0NpYAvE6y8CoLjIaOSrD5KUhOAJthV2SJdEKocY0DaZeb7w78U9TiVp/Akia0mNW+VtjX Fpe4hWmhuLrXLbOvIb9PvHXdAYAIsXH8JsfqGev/39wKRCoB+sirtBdRiFjYid9DYyF2Weh91XvA KsdetywW69tXd3+d+9q/3gPXFbIICVuE4tX2W9qzKIQuFOpZWAtdqO1ZpD8AXfBu+KGx3FCMHeer 4zuHhY7rw/ccDVCH4647AAAAEEH9D3cl7U6srvP0mb1+1NxnrzWtciwdK8TqfRciFgD94rzrDgAA AAAAWDwafuz/Rtf879CcQHtuX8xcsa62Qn0F8PIrAHvnrtMwDIVh9yJAldiZqFh4CsTOwsoISPB8 bLwAUkdmxMjExFIJtpY4iZsT147dkCYl/T7Janzi+JxGbS6+/YhaAAAAAGyH0IA/jV6g9TFU0WRy rBaLo5KtEJpYroQstBiF3s5ELAqbS8BC2jOxi0zwwtiNmIWpxyWe0RSIWzRH3xfTR9xiW/5U7q8V d4hbbM1fu7+bzKfKfbbmUtyLpFhFEYD5/mV7YXOdn0LQohC30MVGo4N0/9d8HowrPa7IyB1rAhcl AYs8n8amF5YPevo7TfxG+iQA0ZYffLTrZ9tx7uK5tkfKDXKBHFPLMM8bAYp09F1y3dECFUYpwgha rJQkkrJGUcLYB3n5laCFWh/NdzIeq/PDQ/UeFra4SNJMFWIVxvVSlQUtbPtQbMuOFDkYUanyg4O2 G3ELW8xCfoZOrc8GAAAAAADQd05VtrBJ7EJYVS+2VYtihMoCAAAAQD+56zoAAMFPkl4iyrkWM3NN Llo4ysZMGvJNPHL5seOwy7jy/x39ffSiipddBwK9ZKqydhCN7He2/0c3rUUE+4a+Fz2JfNU1vWrR TN/9Rn5umlz1uFJsrADQPGtDyVT9/19Mmz/sL/dJuu06CAAIooXSPlT2jmOELKqeIe38Js+iVe0W deqsWz42HzreZ6tbPrYOHzH345CgRWxfvU/0Qm9/5mkm9l0n6SEiPoC2eKtxjN3+WnWtsa9PofZf e5/tF6BJpl0HAAAAEMFVkp5VJjIv30s2FbOQeVnWd4xsK5XzSiWuvkHmkwLsLmddBwAAAAAAIHhN 0rdnX91+11BaeLZDfRgxMfpsACm/ArB3xjgNw1AYNqUTCwsMqEJsiJGZBbgB1+A0XKBnYGfvHVjZ y9i1FLtJmlfLdpw2sdv0+yQrL46T9xq1ThX7+UfUAgAAACAtcpXtd10eQo2n0081mdyv7WIR79XG dglNGAGKSszCCFIUAhe1aIVL4EKKW0gxjGrf5bsPELfojqEvpp9T3CLt4v3Dvq+IW/TlL+33pvCp Sp/JXJbPP1u4Ytuu47Hn2ddtyzXeBfWHGI2KVyY/8/luQdo3xBK1kOIWRtCi7xvY1XfiWEQNDsVH Kj/46PYaOa/fhY/QzLqqBzw3/U4pSmGELqRwRSVusdTHjZLEUm0rTKzbl+duxC1KsQzDWNs343GM qMWtLk+6zIT7URWiqKvsM9HmT2xdExSVqFeqFrSQt2HlsJXDBgAAAAAAAKUuPPUxYoAhsYo2i2PE QOIYAAAAwPHxpstl7iAABCFBi5iEoqYFy9okF7n2900uOnbkUCiiFtAXV556ObZ8rctrsojg1PhS dXJrTB+/S+JqSJBCtrVFlmKeU77E2JANAMOD9/XD5lGXj9xBAIATI2LxLYrZj1l8JOY/m+89yD7H d71WqH3sOTHX8dWF6tu0iX1WNo2Xh8bkfXWxdlM7s100xAeQmt8Wbdv0h6G+KfR7PqX3t5CXl9wB AAAARGLmJD+rQtjCzvP0FTt/1Ba3CJ3jOqbEtmkeNAAcLne5AwAAAAAAEMyEHTMuuW8Jzd2zfTT5 t+sBGvkXgL3z12kYBuKwU6nqSiVYmHkBHgCJmadg4b14C1YmJpAYGRjZUGe2tnGdaxw3ji9pQ9L2 +yQr9tnxuVGVv2f/ELUAAAAAODyaQED7Aewp1dF8fmmyrLpOUClmsdoKWVgBCpt3IhalLSZe4edF 8ELsvliG7cdtux+MtiBucThOfTH9cxAocD5P+7gibtGXv//93zifpvDZt6fSgfNZjR1x/uvELlw5 y8rkC1rsCly4VyY/i4VyWOkfLn6lvRWzqAha9HTwjkEoAD/42FvI4QjG2LePnRVDixOb9Dix5x1X sbEvizZZnhelCBG02CpJ5PWiKCF2ab8VtCh8Z175ejo1N7OZ+U4LW9zl6c2UYhXiemWqghahfeLl /Y8tfrChMdWbBWsXcYtQzMLfpg5tzAYAAAAAYHkdegAAPdFlwkebh1yNgEX40q/NcxwAAAAAjJfH oQcAEOCLWmgXfayb/KOZOJRaKLxpclFsbKf6PCTf83w+hxgInAUxUQuLvHdA0AL64s84UYsYdQto +mXNNSm8DsVS03VsGfGnHSsAjAPtAtjafeE8uMjTs0GgEmAsWDG0L+MELN5NuZC79p1GaE/lm+q1 ++7jQ9s21kZTTvWbsmvqu94fp76lp+zhwq2afGwfv3wV8Q8wFL/KdrHzRFjXNTX1zXMy9MHt0AMA AABowUOeXop8XXxwkzjFZnprUBdLsT7CeaU+cq9GPDLA+LkfegAAAAAAAAU27u9D0U4TA942DjAW G5iKRfd9A7RmLQB754/TMAzF4bTQBTFwACpWhIQ4AAMHYOAc3IalR+g9kJgZ2FhBzL1BKDHxS9yH 7bghNCH9PsmK43/vVdC4SZ79Q9QCAAAAYHe4AXv3RbqINV4sltl8fl4JTMhvfld0QjbfFgEKEbMw IhRGoELOjWiFT+BCi1vU/deVkIXYrjf6Ht/G+ohbdG1vbe2N73+lX5vrkQoUdGHvf3wX+7A5NnEL EaKoxSHqtClwUebrz72tM2a8ss/HahVyJlMqGJWP8uGriBYlWjERQQtnrIndbL7LJ3xd/d0RgBim HWx0O0af4/+FDfd6InkjapFbkYuJPT+wIhTmOuUKV4i4hWlvlCTybFNh4ru97SviFobcXhsPi+N8 NksRtTgt0nVWbg4k5qfWRS1o4QYaTp06XwCiOwFMbT5X5W7QoQ5A1HkAAAAAAIB95yhS1yQW6Lbz bXTRtGmWzvtscA8HAAAA8D8xG2He9e0EgMO7TT704p2UBT2/XTzkLiDSm4f7xg/5MtZ7pZe+HYDR ctZQf1yk2104AnvJMis3JjaErt+xOSllrokJWMQELkJzVdMcFvIbAIYNohUQ4qFIV307AbDnmGcX zza9OeWhZxNt8rHfc23abNs/dYzUfKhvm/NQWUpdm3ZCytwcErHQ56lCFr4y3/EywTeAXfLqKUt9 nhuq843jO3IfDH3S9FwTAABgSBiR+ZsiPWY/13mGBC3c9aOS/wz0S0mx2GddjsAFwDA56dsBAAAA AADLU6ROvz+I1aXEAeqYPR0DGHp/4fMj9m6E+2CI8iUAe+eO1DAMBFARMhNOAFU6CkoOwAmo6UnJ NZmBO3ABOlramKztjWVFKznEiWPnvRljZSVbmgzxV9JDagEAAADQL7mJdwS5BnvL7Wi5vHdFcdOK +YILkU6ohEJiIq7QWCWq2BVZSNlQZCHldC3bax2yn5g8Q+8xpigsQG7Rd33T/V8Zqs6hBAXj+U7H 8Vscos4pyS0qsYXKIcq/2/h6XeU1wgvXStv9TmLtvy7X35bUomlQS1ZRxPJqaUXZu0VkFrNZK/8q 2E8fjEloMSXRxKnqoY5+tp9iHTs95fQYU8dntXSiKI+lRdVjT8ps0mqKUKHF1iQh8gvnWtILLb8V WtSSC41JHbfzuXtYLNxXXmzxtFk+XSOr0KoL1xZahPGZl/ZftPgdFJ1rXyBIXOUWsc6HXTshWjEA AAAAAICp8t9Bz9akF13epx0K920AAAAA589q6AYABHxk8lMDinRtLX5+bALx3KAjqx6rbZdwP4TU Ao5FTO7pP2d4NsoAHMqPyw9uDdO5waupwaxhPHVuSuWFbYu19RLOSwBTJ/cMHwnGZbDaLK9DNwLg AhHpmUzQriKLXy8vN7lI7HotlU5ta61PtW2X9D5lw3Tsc658Lt41/z9Y596U2KKrzMLKs+J3yZYC nBZLWpwj9QzWeh5r3Rdbx7jUfgD64HHoBgAAAOzJy2Z5d824TufsiQB8uUUsHr7TyG0XTj6gaFmu 0QDGAQJmAAAAADgX/H5/Xd4dWn3Mj7GEbYq9r3BGDMDkTwD2zh6nYRgMoKYSSIiVASQkysbEBRi4 Ciu34QDMjJyBM7BwCa4AwW7s5suH/6qWuk3fk4ztOrGdliZNHOchtQAAAADYDnJQ68mG29zCLy9v 5uLiZiSxWPztzB/JRC+06JaCCyemkPmY3EKLLsLyQxjqT51fTFlYgNxi0+1N93+lVZu8p8W1fbzb 38UWbU5DbhGTUUiBRWhzKB+LLXQ9WpTRp8OxcCS18A9qP/IPgx9XdzTEUnIRhBYiXvZJrrNBNvH5 TkkAsa122JbttrEPfWzdRhDmuP2VNDaEssUdeU5Y4SQXrtyJKcxgjwhyi29b7kwS32ZsmOi8yCLE Mx8HTmz+8vi4RmpxZcO96QdoQvMz30UttJDSipko0zILvbneJrQUWsi3oYukTSQNAAAAAABwyJwW ynMTuEoP09ATw0oTxmrbBQAAAIDd57F1BwAU60woyk0C0g/QyOVzdej6dF9jfZ76OdOHDXetOwGT Q9/fK68/nJleagHwH7yKdGr/nXpIpszHjidSWvFTEfQ6tcet1ETY1DYAwHpc2/DZuhOGa/WHwtyG 59adADggnPBMiixyvwP1a6kHk6TKdzXeRJlOp5Yv5Vf9bbvKcbFm2ZobznMyC5nPiS1qRBexGKkF 7BJfIp3aX9Z8v0vrx67dmszrJWrOpwFKILUAAIB949yGBxvefV7O8yzJLfTYRW6ZXH2diE0kbRJl ANCeeesOAAAAAAB43NhESrqtxxBKYw+pe8bXDbq+WP8AVuJXAPbOX6dhGIjD11KpiAUqMTAhIbEj 8RjMvAEvyMzGwIp4AF6BrTA25BS7tV3/aUpK2vT7pCiOHfuuVRvHyuV+iFoAAAAAdEcsQDAWAPhU Gmg2u5SqOvXqXIELTbRtBSi0rhGyaMQsGqGKdSEL2+YKWdg+utcxrA07biigEWPIyfURt+ja3nB/ K33ZPJbvdHt7h/Ff7MPmkMQtVoIV8Rh7V6zC7WfrVoIWfgx+VTX5z7/m8y3dGwWHRtDCrVf74/G6 EEZq0i2a7ObLRZxhP+1go9sx+hx/1zaWkXR6PbG2jLCFMjbHlbneLMw5IxWmEF/QYqkkoeIXIp7o hW3TMU7MmDb6z4oAXU0mcjudymdZ2EJFLd6coZfDiy9oEdaPnXIYhGjrRPybAq234hax4MNUcGGs nkBEAAAAAAA4Jq4lHVwXkhOhyCXJaANrMgAAAIDDRhPr3PXtBIDDe739JNravFDklsNEGpsmAm/7 clHKj6HiPtP7EEQtYDec1dt3UKe/uwfTBtA1NmFxilyCzNK2CMqx+SgmahH2z81jMX8kKIefAwD+ zn/MSbnk1rFz+Z8Pl+d6O+/bCYCBo8lO9J5QRTf1uWxszZ86DuNlc+2l+jb7Lvps6l9sHyvn7j9L /UvHqXkuN/9t2+aSe5Zeep+1VE4JW5Tq7f4+4xtAH2wa1+KSWueK5K9fsfVweG6sPRwboAsuhPt1 AAA4TB7r7VX8Z8AlQYuS0EVK5CLVX8RfA7m+AMD+ctO3AwAAAAAAhpdCe2x9WYq/y8XqhfGAbWP6 Qr9S/gFk+RWAvbNHahgGwqiSSSpaWg8FDTM01DTU3IKa01DkCtRcgSItBRWXIQmSbZG1IusnTuLE fm9GeCWvtSITW5Et+UPUAgAAAOD4yIdZrzrdh5wXi3dVFHcNEYvy70btiEyYZEQprMBFJW4hBSx2 xS1coYvm8VUdtv6cMcWQX66PuMWh4w33u9JXzKF/pt3jXca52EfMyxa32FYgBSuaIheTMs56XQlX VCIWUsxCKdlNbwUuKoEny6/uHGfTaaApE3/exvGUu/bEFbzI5JIELYYkNHGqOMQ4zPFjiSHrlzPn 5Iw+my9n5BnBCiNyYfZrWwpXWHGLlRGuUJUSRKkqYfyECEY9hPgXzFjV+ZnOF/N5iqhFodOjTkvV 1M0wTXQFLaRoxVTsc8Us3H/XXshXavdj2Hhs5bEBAAAAAADGzFWCj2+cJff5bJnPfRmHLWfMBgAA AHB5vPTdAACHpbBTF+e0Lf6x29iCotRFRaE4yikfMr7neN/9NQcGzo1OP7Vtzy/z4vDnfpoDI+BD 2CmLR0M+vgWsPqGKNhGLnH5KqfZ+aAx9E8A50WWOU9s9+5hvbCIc9++Hw5tCmBLgWLhCFoaU333S Tinz3beIbVPLuvrHjklpb6jOWF0+n5BfW1mu7yGI9eEpIhb7bm26zWgvwCnIEbUIncsp15CU+7I5 1xaALjz03QAAAIA9udbpSafPOu8bd+wrYiFTqL6N2CqPrVr2AUC/8BsYAAAAAM6FL2HHniOmPA8N pZT55qrF163fbR/jXcjiTwD2zl+nYRiIwweiKmKAEaZOCPEQSPAojGy8JSMzYmOHDYEQEqFu7NY+ 2Y7ThgbM90lW7bPjc9u0+Xf2D1ELAAAAgGGIBeRrmzn3uunqaDY7labZD2y+wIURnXACFMbWClms xCzCfFrIYtWu7cP5cP1qAY1Sal5cH3GLof3Vu6+M5bP2z3QYcYv+G7Pv/JRPsT7X2VrHpGhb2M69 LyNYkT6meYvAW8GLyWQqn58f8vL6KseHh6p5u3B72zbSaUzYQgtZWKGMpaDFmsIWQ3xvNQlAbMtP LT625ee3C1rU8lm7/nVk3I77z7JlJz7R2P+wL9tmxxOqcIIWSyWJeb2zLbaxAhiL9kb0wva5VJiw 5ZO9PTmbTuWxW9jiYp7uZCVW4Vw3EgpaaPuul9eBiM4mEp6UG7sTt4gFH6aCC2N2AhEBAAAAAOC/ cC6rxRwNfSZq5Z6j9V1ow7+OAwAAAIC/y/XYAwDweJdwQlGKkglF/iQg31YywSi1sHjMjx6HbhMr 1wiiFvBTzCS8D2IwghYHI4wF6ufBphwlx5WYcIUua6GKXModm0omxkomDwDj00fIAv43V/N0O/Yg ACrjbZ7upb0X4e5HdF3Tp+4L5OpS7VJ169iG9rfJa986bc/lY+WUbdO6LkrmsGpbH3GLUkELlz/u GC/AtnmK2HK/367fate1b1ddql+AobkaewAAAAAbcCmhqEUjcZEKnS8VuUht5yeR8DrJteXcDeD3 cjT2AAAAAAAApH3u+5yoK33mm3q+kIsPzMX16Th2Uf2lxgfQi28B2DtjnIZhKAw7gS4sMFZCSDAw IG7AxMrGNTgTPQPiCgiuwCUYkLqwVFDixqaOaztOk9bU/T7pNY6d+L2GFCuO7R9RCwAAAIDNYr7E ehD1gj9eJpMnMR5fNEQsFp9zsSIyIU2KUmiBi1rcwhSyEA0xi9msNlvcYnl+XYeuv++zRs6L6yNu MbS/fO+VVD5zv6b9/K33O9R+t3nfaJ+SXO+d2qdQPmPPKJT2Q2HEqdNLEQuzrJlXqHbUHmsiGsfL NvHo6FhMpx/i0yVq4QzNEsYw8wsrDoc1zom5EgP9nXJZzH9bPrblBx/D1pGy/tQ+zJFz5og+vb8Y kVedeyBFLmS5EqvQ6hFayELbn7KEIYBRqjyh6voxxH4Oq/3T0ShG1OKsspvK3gz3pQrRFrQwRStK o8wWs7C/bqnS32L1MswdaeFIAwAAAAAA7CubWLQxtJCGb6KYrx6e2QAAAAB2h3vBxGL4X7wGyvpM KApNFApZSNjCzmuLN3deUgcA2WL3g8j9uxSBwF7waKRD7Y4PV1thT2C125lQeWybFYpv39ojgF0G MQsIcVLZc+ogADJCCpnJPggpZPGl8kKLhvj6IEJlvoVOfHW4+hzajumSHiJvnW1bme/YmDJfXtdj h6BNpMq33yZs4dvaaWmXHeIF2AYxC0e5fvMxz7tt/3N8Pnx9uqF+XoCunKcOAAAAoAdXlV1X9q72 Xc8eLtNzSG0RC1vkQltI3GJubIUjLTxlAJCO29QBAAAAAACIeo0kTey7Qt+48C5j92LG9fneBdsx xMQMsMKvAOydMU7DMBSGrbRSGBioxMAEDIhTIHEJDsDCvbgBh0BiY2dgYuQCSB0a4iZuXp5sxyUt rtLvk9w4fq/2S9U6aWL7R9QCAAAAYDy+gfy6zD7cehqqaLE4N1V10iuTAhd2gW0nQGHLGiGLTtzC 5fviFn0hCyd40fg0dbg2XL1aQGMMU15cH3GLXbc33e9Krjan/pnmELfI8b3J0e7hi1toMYt+WTjf HZPdNMIWXT1y31KWp/Xrt/lZLpOPw9VfOZEKF5/ed/5FsbFvtk1wSe2MZSqL+U+tHdrYzfuPpY0U MYuNX923OO+i3a/W/V/VjNyzfZUQq3CCFrNWqMKtamAVIdbKEq0Axtq/ts/aOt0oQNefXczn5qYs zeewsMVdnd6M6ellzNpDkYIWurwQefmARg40NKZ/AVCYTtzCN/gwNLjQV85ARAAAAACQ2MUU73MH AbAHrkQ+5X9Q6MadvGkX8vXZAAAAAGA6POYOAEAhRS1SJueEJvqkTihaiW1s0pGvfl9sxz6h6KtO l7mDgMlhF895EftW0GIfgp8AdlJraMFNR8o5Z+hctIqkkF2fy1Inyuq4dR4A8hK75z60EDYcH88G UUqAsdhrvdc2yeu+2LWStsUWF9H3EGJl0hZbzCTmN7a+beMMlYXeYwI+KfYhW6gsVp5q/yuhc3Xs nD4kaDEkdKEn6dymBgvwD3wM2FN/i7F7syl9U8gWisFXP8C2XOcOAAAAYCQPpi9qUYm8T4xC7msR Cy1yEarDN65Z/idyvlyjARwmZ7kDAAAAAICj56dO7wl+sWeg2m+fSceg2wXYil8B2DuDnIZhIIqO Ct0gboAisURiwZ4NW3ZwDe7UM3AJ9ogzcAQW7FBJart1JuPEadoGkvckt56M43Gqqm4SZz6iFgAA AADHI7559SLuIbckq9WrFMVNTcRi87qWhshEVYKQhSvSEK3QghaWuIXuI/R/jHOLKSfXR9zi0PGm +10ZK+bUP1PELY4Z77TfHRdTfEzLa+cR3wlV1NfKO7u5rt4JWEitrbN34hbVrsulexb96/u7c9yW YEXkdH5lbw9ysajbGbGGMiUBiFPFIcZp44wlBDHVGHoVX1hNF+zNiryyr7NK5KLye7GKtd8WBC0q BYiaskQkgLHw20R2ghk/3j4v7WK5zBG1KMpyLy5pw1Yvww9RC1rEohWLyKfFLPThejWhraBF/DGs jboYdQAAAAAAgDkSEoQ2dBQN29qmSQlZWEky4n512+YFQwfnbwAAAAB/k+uyPI09CICIT18srGRk OckNdclNAq4fGtL7Wf3ruHOjOuYPQdQCDs+Fqj+ONRCYPLF4Sk6iS+3PmXeseahL5CJ3rrLGOsf5 COA/MGQxG+IW8+RZOH8HGMK7OCGLOIlJ2/89q556D3Ur8Uifel/7UPvqY+ryp3ypdilfW30fO7Wt jz+nXdc83HYv3rJzBC66BC9C/aoslx3jAzglKfEgSWxvu8ZqXW/N+V1uawNwTB7GHgAAAMBAqlw8 t1IXtoifFe0jThH8qedMU2UdvYtRl4QPAMbhbuwBAAAAAMDseWvxWfcgdD1nfV681q9tPWDb/l33 mwH24lcA9s4mp2EYCKPTtKKIVSshxAE4ABfgAGwQC27BpTgCW/aIPcdg2QO0IW4carue2IG0KdF7 khVn4p9pVcVtx5kPUQsAAACAv5Gz8W9elefUQMvlpZTluWdzBS6M6EQjQGFs5ny9rsUt6uLW40IW brt6vLrU45VRAY2+GXNyfcQt+p5vvJ+VoeYc+3uKuMUh5zvuZ6eeU+ycWovYXvmJ4mO4134//10j dOGufUVxtj1+rVYdPHecDsUsmmu2TNxjPWFi2H7e/1NKtM88zHGoMYYc/5Tm2MsgasUmmp6N+ES5 vQfWwhWmzaSqT42whTmK/AhaNHXv3ApgbJUlbD+xYxX2ujm/ms3kZj7PEba4q8qHiKeXMbUvxdPU COyFU3cDMe7GQxF/0S9kJ24R23yobS7UkqYSsAEAAAAAgDFzYUtaAXZHlwQbKQGLsJ8mnBHa+K0G AAAAcFo8Du0AQMB74noq+VnqoaDYA0WppOEb2Y9tuXOlfBszsUQin1V5GMwjGCuuUMq9+CIXAH3x Kn7CzRi5642h7eHVLsIVG6W/KGNra1asDgDHI2d/E0IXoLGoysvQTgD8Q0wc1SQueRM9sXp4b45d aztqtpQ9/D73mzYxu+ZD6lwbI/f1t7XTbDl2zZb6f0jjGN+FtTVZE7bIFbhoOzb163w3AY6CJl4c I/d/17Z7WKxv1zYAfXA7tAMAAAA98SS+qIUbE46JWbjPkcZiHTExi5TAhYj/WymMTwPAabAY2gEA AAAAAPFFLXLihl3isKm9fSlbW+wiN34N0Mq3AOydu07DMBSGrZaysjBSwYIEIxIb7DwLGy/AW/QV mJkZkViZWSmPwNIJQVzbrXuwHbfQuEm+TzqqrzknVZUm8eVH1AIAAABgO/iDVreVnaYaTyYPajw+ 80QlzD19SGRCmxGlcKaEkIX6JWgRFrdYHkMLXfgCGk2gz3G3NkffBV/+uGoT/jaj65vpI26xDX/K +mvEXe/ELZr9rTb72zE+lfXpl4bELJblJj4/LftJQQvfjy9uMZyXfc5myRgXO5/rvqnvxhO7WDGN E7SI9G+DUAB+8PFXH22IcRd8bHp8OYvPzaZz+fmMvOrYQ0/kYmgFK3xBC53WV6w9m9dCFr76hFvR NrCiGI79Kj8ejXJELY4qu1Jm8Gahl2FDlIIWvmjFwKuTYhbydJ2K0Jf6/TV8B9IqkAYAAAAAAOgj x5W9BcrrxAFdm9jir/CLu9W+0hcAAAAAtJO70gEACDZdUJRj6/RJLSiK5WMx9+2Z6bmy+9JBQCc5 VGYj2pvSgUAn0RPSnrx8anFo6lpf978ixSxyLNQ/Z8FrLNauMlXmfSkAQBfRwksHpYMAaBH6ueGx sldlhC0cuZuBxDYOyX0vEGsXEqmQZal3GOscI3XMnHNIlcm6UH1dWSqdk0+V59wDb+s+OXd8Pacu JmLh0qH6y7wwARpjumb7uuftWFnqGprjr0/PztAMJ6UDAIB/4cV+XheNAqAs58r8r73bfGiuca65 daWxdaaxuczyXk0uy1Uiz70dQBkuSgcAAAAAAL3nQ8XFtlNjwX5Zag6gnM+XMukn1aYuXoBsfgRg 79xxGoiBMGyWIBAVEiAhIaVC1JwAes7BmTgMPWcAUVHQ0tKGmLUT72T8yIN4s/k+aWV7Zm1PVsq+ vPaPqAUAAADA6mgf/knb0XR7yjU0Ht+YyeRkwe4FLqxwhRegsLZWyGIubuHzXXELTcjC12nb8It2 h+36BdInW3jE6M/i6H3rS45r/nd/q4EQw+73OfRjui/iFnX63K4wUdtnm3rRCZvOY1j8Rj70+X1D 4YtunUXaflr/1/e3vk/TzP5HovJiqtl8BM7/F6PpvuXb1HFGAKKf/dDHZtuo2X6f+1DPK/Y87sqN K3tRHrvvTKTCCVaEghY+31GWcOIXvs6ha3OmMOHKV6ORuT0+Nh95YYv76fYahuK6mpiuoIW0N0E+ HKgJPzw0pnuhb8xc3EKKWYRp7tDGbAAAAAAAAEPiIuFLPT+l6vg0NfEs1Q7PYgAAAAC7w51h4V/o F3ZxmJ+ILzehSNq1fOlkIm2ByGUmFJUsmDZkPmsHAIPl0rSL55zWDgQGiRW08NegksmiJdcSmc9d gzQxi1S9nABTLO6h8mm4t4X6jP+hzdw7eRg+VozyoXYQADvCu2nFLN6EPXU/JO+fUmnMFnt3ELPF hCzW9ZfYYuXcb5Q2o/g1X8wm8zlfzLbsvjHWuU/OXaNTIhayHBOw0PyaqMV1JhaAbaMtHqX990v/ 3yXnO1kv9z53yM/JUI+72gEAwNpYcUn7bHFuELUAeJxuzy4v53pa5PxRKVgxm9Kq+DTRiwOxv7b4 APdwAP3jrHYAAAAAALD3vAT5ZccaY2Ocua3kG7/S7/s2MeYJe86vAOydO1LcQBCG21sQOwUiE1GO fAJIOYszH4FDbOiUzAcgpYjtEzghoygSIkd40Wh22NbQO9vah8RK31fVpdeMule1NaPH9PyIWgAA AABsH/2h6ntlZ6XC0+m1HB2dvglMpMmx07ZeD5aELKLJm2hFFLCQd4IWubhFFMRoniP5SM8TyddQ J9aPPrudWH/9SfXbV9wv4YB1/HX7fxmDSMHQryniFrvy133bHf3WXsUaHx9jWTbPXVPsYiF08akg 5BTL/n14yHZH8YlGxVwRSolX1D60cEUS5NCW6qjruU+CFkMSmujKDz62U38sPrbWHkizZ2uM5qvb w1m9TGIWtWLEXLBCC1q8SKYsocqnEXzpnP9VB3VQ2fHhoUfU4qSy88puZTGQcDIPNxe00AMMJ7J6 4KGo/SILQYu0X1+a/DLl6wAAAAAAFs99BwCwQ0qiFjmliS9WTYrhOWfanknzkRcAAAAAPi4/+g4A IOOPWvcm51iJPt4kIe+k4ZskFI2Re4nvYz73HQgMjjBR+GXfQcAgeZI4QdkyliWtpqUnkVULWyyz Nv2UFZsVK30TQLcE4aU+3o8jeDFcvlR21XMMAPtAEMm8kfeTp3vumzxL634v3y7dEwZKQhWblPUe 8/6WttdGLz3rpfvXUv1SHe+xdcq1pdQnW8c83+kt8QqrTLCvjhgBuuKf+ASMrWOeZ99V7bZ1DqvN s44DbAqiFgD7zc/K7iT2C+HdcXjeQNgCxsxFZb8qe5xv6xzPkA/6ovbl4hR6Oy1zsQqrTp5bmr9z zfNJrTRdAOiWb30HAAAAAACj57ejTNvvvCXzjPezvmdYceT7AdbiVQD2ziCpQRgKw8FOrVeoM864 8hAewnHhHbyOK2/g1vEMnkBXrl30GiJpSHmkSQiUQqHfN/MmLyHwEqaFFpL8iFoAAAAAdCM0sE+W Xxb23HSg9fpG5fnVXrkVuNCiEya1ghTWTJn1rfmELIxV9cwxjeljSNEMG1umc10gfcj+dY8l32e2 j8mC+n3GU2W8QcKNEnPu5xRxi2PFG/ZzU8XVlol+1kUrdF76rvhFXRwj29WvdCmynfDTz2ZTBfb1 0wpaOKIU+9Uy80kSwho136l7KHMSgBgqDn0ZNsYU2ngKMXq5HihnFF153bJHXlxcbMUncitsoYwg xTYt81LQwvq1fCl+YfdZlDH+VCWYof3r5VLdrVYpwhb3ygzKlXoZC1UNKnTFLXJRTw48lIMPbZlS 9Zu7b0Bj7kmbTm2oDAAAAADOi6/CHsZuBMCR0ItSxBbc0/gEA+U2ny/z7j6xugAAAAAwLR7HbgCA QC8K02VCkSyLbU+dXBQStkiJ49bx5c8B3edvZRY4AegTLWjRRuATIJUP4Yeu26F7gE1TJq/6RCza iFw0TYr13a9CfQCA06LLM/bQPjyvnxcvCrE4gBh6cdl3ZZ4pSFL+p6ekoWcLbj70m6wP0xwichFr u6+/sXOhAtubymK+L39oWZvtxyblfp3yzl76vtT6iFrAKfEr/ND3N3ZtcMvda5m7LRYnRFO7xr6G wHRB1AJgmmhBprfCPp1y/Z8DUQs4d54Key39mPBEisk5ptJccQvf/FKJ/a3G3FGA0+B27AYAAAAA wFmj3xunCm3H3g30ZTFhC9/7jqb2ASTxLwB755LTMAyE4WnUngIKrFAljsAhuAJbLsIJegV2XAKx Z80ZkNixpCpxY7fTwXHdKq+23ydFscduZhpVcR0/fkQtAAAAAJonDFA9lcdtquJ8/iLT6UyJSlT/ 7a3AhBagqIQsKmGKIFpRCVjIP0ELK25RiWIs19cJm3VXvur7Fae+Qfopi1uwoX4b/sT768RdLz5P /Z4ibtGWvy5/N5v5IE7Ywtr0uYqnbj69bNXbFrpw1y5W5++fH/ldLGQ89q9RgoDFsqbttOIWIR3s psyKW4yKQtaN9IEgzjBMP/ho9hp9Xv8YfcTUGQovRKHrjLw9iFmsFCN8PS1osfBlY5/X9QvZrGgL PoLPcZm/mExyRC0uy+NeKmGLtV6GD9EKWmjRikKVWTGLcAtE2UU2Ew71bVhG0hJJAwAAAAAAnBNX Jm/7R6nFWrFOburFXWwhmvZhfbFQDAAAAGDYPAobY8Kw+EiUpTY4Sy30SS0WOmSz8Do/sXjPCdsn dOk3QdQCmgdBC2gDtwHye6I8p83JWaQaa1dighex8lhZKh4xaQA4LXImsMU2xOaZcHw4IcqHvoMA GChtiVmk0tqWKzLR9rFPfLHvmroHOfdsl82md+VjbVWq/Wryvcyh7WTuxPKUWEXMtisdG8e/y4wF oCs+D/jMrmdxXT17zn3+iSkHaIrrvgMAgL1xghbPsi3KFHD9DteuzTqNCGBYuHHf1/L48nm9xtMK UWhb3ZhJSuzC2q0/UTZRNjtezX88gG656TsAAAAAADhr9Py/3DHHnLHXVN9Wp/ed2xeLIydmgCR/ ArB39jgNw2AYNimVKiSkjgyoEwOXQOIIDByCM3ALFhYWrsEBuAMjl0BUqkSIm7h1XP98iWgSkueR LP/E9vclquzETfwiagEAAADQnNCLfHb5vAgPqY5WqyuV54uDciNwofezLmMjSFHucW2ELYyQhU7v xS3qQhZlULt02afaiWTYohnGdohxb5De7flNRdyiW3vj/b30ZXPs1xRxi2PZ6/J34xe0cIUsSldC ++O5ghZql7fnxO/NRp2fhpdRyja5W3h44V2BC01W7ql+Mpup/B+IBXRlY2x2sPE37adio4tzyIqx R49bxlJWifXk1XiWVWXbuMrbghYmXVOWqAQsTH47Kuo+q3PS/ejjF/O5ul4s1Md6nXLzpgjvStX0 MkzXtktuue+FRFfgQqn6hJ6pvbiFK2Zhxy6+cl5EBAAAAACAsXJWha+G7dyFvJBYhR372jexx3MZ AAAAwLC469sBAIc3Ky15fpB+RCQRr4jV8fUf88UtnyqffTsAACDkxUqHNrXMhXVSc8xPJMTapD6S lTDlOQlgSLRdKz/Gy2us2w+bZRFe+3YCYICExCw0vns3X3lsE5FUPnY/JrlvO2bw+So5T+k1UoJj obqpepL6qbZt6kjRfYXmYqmdUPuY2IVU2MLEl0JfALrCN1aHaDKWNBmTUsdi5QBtue3bAQBojJ6z npRf0MKgn0Meu3EHYLDcF+HZyrvfe0pDTPDCFbfwfV9qsO/jWOsE6J9l3w4AAAAAwGQxgqQpYv+T +o6HQtP/hX123OOuXwCt+BWAvbPHbRuG4jgjeO/YAB3aABkKZMgFil4h5+hJeoEcoAXaS2TsAQp0 SuasmTsZiUKWpEI8P1KUalOG8vsBD+KX+WhClizx44+oBQAAAMB+iQNTX6ydlwpeX/80p6dniaiE /28vBSZSAYooZuGEKZxoRSpusd3uilqk4hZeFKMf6nHx6GPqc8W6N0hv+/3WLm6xzAb+fbNzxfvz R0QK9unPBH9N3CFucTB/hz5vpHiFT0vFKdI5I1pZPf7yWScKFdmmkeEjfgP44Shqc+nDGRLDQtQi 9s9J1/lwSJvzxm9NAhCt/KzFRys/xy5osZa+blF/OmsunckX4/9m4AURikFJIghWpIIWj0YoS0Tx C1c2hJ3QxUkQz4g+Nzbt7WZTM0rzztona7/Mi3hFF5ooBS1S0YouyZNiFvLrdiH8aHa7oVfCRgkD AAAAAAC8Jt5buw1h+Xhpkrj2Ak5SErbQRC5kevrMptXdF/IBAAAAoB0frF0t3QiAhHuT3+Qst5BH y5dl0gVET0l4yiIiWV7zIX2DMX+WbgAAQAV3ZnxBq7ZBZo2VhCpkupY/JrpUuieN3SsBYD2MTWxr OCsa9sw3a2+WbgTAEfHb2g9TFrPIhUvH2v9Vc6zm/cOT8FMraFabl4tr/aD131jfavXJ8FheLq2U /j95U9DqmXtvzY3NSx81Ihe5tIuZbQM4FA+V5bTriJY39ZqYu77JugH2zdnSDQCASbgxyq/W/hbK uHuGm5/p3iV/bNEogCPls7Xvxv9edpa+Gv9byYW15+EaAYzooze785M1gQttmS4AtOFy6QYAAAAA wKvlppBXM+Y5Zfy3Zk6gHPeVY8JjY6cAs3kWgL3zx2kYhuLwSyUoEgusDJ0Qh2BiZuIWHIIjIcQl WLkAE0dgqQRdQk1i6rz6b2mbJnyfZNlxXL8nFOzWjt8PUQsAAACAMkIv9bn1x8t0n+poNruUuj5Z q7cCF0Z0osmtIIX85FbIwlxr8QojbGHFLZo2TTtbbvqUX5EMVzTD2i5hfAHStT1p7R2yLd8+6C7t bcbYn5XGprQ292Zy9H/XYT2nw/hf7MPmbp6bytGT6L4zYq4b4aZQvDxf3Ds/pp/T0zOZzz/kc7H4 g7tVJ6+smIXJjZhFmzpti02MI5j/vmzsyw42tttHn/2PxcZEieZU7WBaOffNdW3aWUELI24hjmCF yJq4Ree6/awp160wht3lqNpr0/7i6EiuplN5+/pKuX29TC+yEquwbtSiNDVU/cQp6xcQbZ1IdxKf yErcQotZuLkmdNCLDR0AAACA/8l73w4A7JiZrEQtcsgNchULiuErx4J68HsMAAAA4LC469sBAEXs QJEhFtywJJBZ7mEit622z4GiPBC1AIAh8OyU9XieE/DSN+/EhJRiIhb6fuyArMj6fBTzGwAOj22+ x5Sz5s/YMCxuBCFKAIsJGmu+s/n2QlPBR2xZ/7ZPrSH46mLrC6VtcsU2c1LK/1Q5lufeC7UNtcut S81dpXPbtubCkn58AVZD9311eg5PHci5LvANYB/4RCRz1lZD40mor9QYlTN2AWwTgvkCDIeUoIWe Q56W6WHXTgEcOLfL9Ch+oQktSDEJ1MfELurIZ0SV9Xc51kEB+uO8bwcAAAAA4F/z6pQ32VvYZL+4 ZB/XZ1fUPZ+fAMV8C8DeueM0DARheCNBQYFEiYQA0VBzAnquQsVh6GhocgUOwAE4AwegpiPBiz1k Mpp9JHJiJ/k+aeX1PjwbE9ZrezI/ohYAAAAA/SEvpB6bdJtr+Pw8DefnN0pUol3PW4EJLUAhYhYx wHYUrciJW+gkfdrtQiRDbPRxL7EfAdJz9kJnb8y25O847oD6+/5daW1uV6BAbEb29bzu1vd0N/4X h7C5KXEL31fe9x8RMQkZQ6srEYOvL4tixP12G8LJyemfqMV3Oeh6kINOTND4ztCiTolbzKUuooUt RLWjyuTuB9rfRzvY6Kf/odgY4jNorzntySf7f956nQjFv5JEFA4Ky4IWP13dUZzTmhsNiXYQyyZd 3yh0MenEM8RmbH9xfFwjanEZFsIWcmgtbjEz+Ymqn6mtdUDUH7ebgP8FLfRp8Bweg5MHAAAAABA+ hx4AwIa5TpTnBAHzD+78ba5dyjYAAAAAjJOnoQcAYKj5QVHqh0Je2TopF0Tc2ghOPjXeQ+a9SfdD DwIAIEH0efACbGpqrjOloMRW5KKUao+bul6FTB4AdgfrjJsq68MO88S4OGvS69CDABgBX02ahuXn BULNuse7Zy89S5CymcnXPlNYZZ1YK4rhjbP2c5TOgy3zzp1XZ8tSbVapz5Wv2yfHJq99JSEL3W5u 9m0fby2Qy1/VDBBgS3yt2S83d5fmu5Co88q9uY51MfTF3dADAIAq4vPhl1Bea+r6KLYXhTBYd8Eh 89Ckt9CKweT8i62ghRWxmCX62fb6OHNlT8o0tt7mAWBzsAYGAAAAgKH4CIt3EqV3mF597r2r3L96 /uXr+PZ57zJy4wNYmV8B2DubpIRhKI4HgUE9gRtx43gMD+BJXHsxlx7Aiziu3LLRDYoEGny8Nh9N pS3l95vJNN/vpYA1kOR/Fq8CAAAAAAVVi/L1Yv3ZOjzGOprPb81qdV7KdwIXVnRie3WCFGZzTRGy sOV/abPL0yIZMu1sN0X21wb2Hq1aNNjm+PJt5c0V23/teK8Mwe7Q72sze8fxWezCZvP3Tfn8OilU sRWm0Ie3j4ox7rcp91lOTyYXm+vHYpHhqvBLHyZvBSyE0MVePLn7evVzGZrQRBviBEOw4ex02T6l /6HYOHT/0kbpL54tN0rIQl5dXKTHRdjF12Vj3cbVEXmjwp6LX02n5m42SxnGvdkXs9Bh7NwXrvmC XGwo84zIN6Ke74BVjW++CAAAAAAAMDRCmyTrHnQh47F5V8wGczAAAACAfmI3Et907QSAwB4a8+kp C20wknmhTT+5Ida3z49TR96jtw79AACI8SziKc8bTdXzIiRKoct8G1tjG15D/vEcAhgehxKygP5i RSiZs8Mp82W2/6c9mTxBi9QDRKoOH/kugoxrAbLvhLAsgi9/GcjzpUO2tK8pPv54rnrMut8UkbY6 Im46P6dN6utcp12TkGorNvaUOrr82gD0h3cRT/kuNTSfjbXXc2ZTUZZKytwbIAYH+gL0nxxBC/eM eDmgXwDHwOU6PBTxkKiF3i8aytflVfV9ZRq++wQAAAAAADgtXk31bwFVvxOE1uOF1v2F1veF6mqb 0i8dB/gXfgVg7+x124aBAMwEztwOGQJkaNG+RtHMmfsU3foGfYmMHdtX6N7uDZA1Y4FsQbYMGSqV rHQqfTmSUmyLjv19AEHy+HOUbEuiKd4tag8AAAAAYEeQBaePPrzNVby4+OZOTt70Rr0PBsPe2sFE 7IBCnFkExxbBSUXJuUVXttxG2oW86NjUHEOOYyYb2MM5nMvo9pzH93Rd8tlOazj/Zze3vt39rtTU u+vndTV9z+O3WEPner43lr1xK9/p6e6tqfdHDvo6yzbwFovO2PrN3d3EoS070Ggl7o3LSzzUPTx8 1C7f/fY7NNhHPehYT3t0bL7/IG2jWMskPzi58BfQwXuEz8tusUW4nvkJRhMc8klZSPd1/r2117cN spCOdYb2p0dH7vrhoXQopz688+Gnc0PXsUOLRqXjlw2bKBa5LMJYziz+GKehNdLOSAMAAAAAAOwD OacWgjWfisuckltxzkGG1gEAAAAA28un2gMAUFxG6ZSBMkuW2/gzxmigZRzQ6ru0oYg5UIe1ZndV bzgAAFmC0bLbQp3cfSHnsCLOTzXK2xj9jTW6q8et0wAwD6/W0MeYF9hSdfR//6nrAP/lbyevffhc exAAFQnPaF+d7fiy9LxjxaV5vpSNdY4w9VlwbH7ss15TODarLHdOSudQp1N1rHypn1LbKeWr1l+1 bem+HfeZqtsa5Vqm+2lV+n1hHABz87tc5RGp65lLyFNz4lwfWuaMPMAqvPThRe1BAECWL+6/sUOL 0jPzDx8++HC8kdEBPA/Offjuw73LO7aQPaOWTO8rjfeXptrktt4KulynAWAznNUeAAAAAADsJeH9 v1+GvLTuOXWttrTWm3N2nxpXat01JQMYxV8B2Dt7nIZhMAw7gVLgBEydEBIDEjNHYOIWiDOxsDBx DO4AMyNjJyYUnNqpHcuOHZq/ps8jffJPnHxOKKld/7yIWgAAAACkEVJOt/NPpT3GLrRaXYqiONEp 05ZXG20r0QkVqngpXFGGMSGLSszCpMVW2MIIZKg848/47oP93CC9jT+h/U3Zl2+uaZ/+/geflf78 DiuKMO/nirhFX/66+NxUwhX2dbJa3Ba3qASe7L9HWdTce2bFF5vwe71Oq4kWrKhd2Hc8M/Wxj8Ue /JwEIObmBx/dnH8oPqZ2D5l+CVZn5DpdZEqEL9d5m1Cnj/WxXxmWShKlEsSRTtdEMKQVOm87y0+n y9fxxWIhrpbLFGGLO6EWEeYBc8UtCuuYO9nQnYgoRP3LOhdG3MLdiNWdlFh7lJ58JiICAAAAHB5f Y1cAYACupX3ouLuxRWzjqlCeG1bxkPhFar8MAAAAAMblYewKAFiEFhS5xBby+DYy68Jiftz8UPpQ QdQCAKbIj7RXK930Dm9aNBpasOoKWriLV1OELlK+n1LqCgDDc7bDuQPPaocJ8jJ2BQBGovxt4Fna Z+B4U/+8irtlfO0nVxQiJogZa+/5yqYKWLQVtgjdU1O8TRiKx37vSG07p+anlumj7TtEe9r14dt8 tWlDVl9eFb/ZuXYA3dJG1CL0bknpA4fKtvEB0CW3Y1cAABppK2gR6ne8SXvqvHYA+8O5tHuh/hfs tZ1NZq8j9YlbpIpi+OYv+/patPMAAAAAAADmz7sOY2MAsbFY33hvaN5f6rhxbOzXrS/9WOiEPwHY O2OchmEoDLuVmJmQkBBISFyAEzCzcwCOxNArsCExswEH4AwMbEiMbG2JiU2s1+dXp6R1W32fZOXF dvxeomKSOPaPqAUAAADA/4kDUH5A+MKqOJncu+Pj8z9BibhgdhSy8KRlrbBFK0zh63iximXiFlHI Ih7T2fO/RbxTf5tgNxdI7+PPBX/b7Ev7rnSd/laD38q++Nzv64q4xbr8lf9uWtEJWS+3tl1a1glJ tMdLfapFP+13KM59fH3lY7GDbTfjcSd2Ic+x2R/FfOP8EYDYTj/4GLaNmu3vi4/S9jV1hjQv7v/2 hFKoIvR90ybP2zO/de2IR9yf+W2oPwrH+rxREM+IPr04xsnBQYmoxanrhC1i0zlBi1S0YpyUSTEL ebrjYE/d4mWYK7ZTbAAAAACA99oBAGyAM9eJWizDellnvdCTbeTKYl5uUQ75+AsAAAAAm+O2SYe1 gwBIeDPKShctkxN9cmXahCJrYpJs05pQJOODlpfaAQAAKDw16TvYJX16n0mtuYmuJRNWtUmucuFl 6/+eZQMAwPbjBSivagcBUIHHkDRK3wloebnn+ZJ7MOu+Ttp9BC36ClnEc9DuCa3roN3L5q6hbMcq l3bfvFXrl7ZRi6FjSduTQhaWCMbZwHEA/JfPwnpaH6TVWTVZbW9TXwL7w2XtAABAxQsd37nlQnqp bT13PDfppklHw4UIsHNcN+kh2LlvkbU5o1LQIi3XUk7gYi62KfFvle+UATYH4m4AAAAAUINXtzg+ GikdL142lpwb87XGfjW/Wnw8s8Lg/AjA3hnjNAxDYdgtqoqYOjKVBbFyBK7AwhU4CofgJt06sbGz 0g2JpQcAkxCHJK9+tknTpk2/T3pKbNd5TtQ2cWy/H1ELAAAAgDhacJx6/nlmj7EDzefXxtppI6+I 4W2diEUlZFEIUlR5ISGLUsyiSldiFlIkQwpq5NvjCATfxp91/oYXWB9xi679Dfe70q9Pu7drWvgr tsfxPT2O32IfPlN/j3l5aTKmXZUnj6PHz9O0nqwt4pt/rNfxxue+6hfMtc/W21AXrpD7Zcs85z6E QPtD9IOPbuqfio9DP4eR+w8rjzB2afsrBGQrMQuX/q4JWnxl21xJIleCOHPphghGZtbl/c3wc+l8 5ORyMjE302mKsMVdZi+mKWgRErewtTJrmhMPpcCFMc0b9NhU4hbaBETf3UMLpMoADwAAAAAADIkr synwJ/s+IyVPEhK2kONxvjqaD/phAAAAAP1z33cDAASL2n5KnyG04Me3aEhLb7ugKLbQCCpWhsCK AHA45MHLFoFyq+zLPO1+4ROzSLWURa//aSsAHC5t5i3tcZYy9MDMFME1AU6Jt8yeM/tUyuUcUt9+ 7Nms7XuDtkIWbYQ0YybPSV4bLT92DUPXVeb50lpeat3UY+2qXhfH3fbe3OZ5IDTOf7tdcwA6Z+XJ k31b7Z2r8Wzl57TPhHzE3vUCdAH/xwCHR/5O+Cmzd6U89Dwc6ncsM3vorJUAx8eFKdaVLk1zbWfI pMBFXdwiVsdXZozet/LNY+aZD2B3zPpuAAAAAACcHK9mU2A7Np4cG9PVylKELLRxYdmelLESgNb8 CMDe2Rs1DINhWA5khxw0OY6aDZiAgoYl6FiFu6xACw0LwASULEBLSReMhCyiKJ9+khA7dp7nTmd9 tpxP8jm2fiy9iFoAAAAAbIcbgLrV4TyVcDZ7UJPJmSgqsQh2pxW0qP/ELIxtxCpy4hZOyMKds4hb 2/kL2xH9Wgh+E3914294ggWIW/y3v+HeK135bPuaWp99uqb9+C924bPs3nHCFSnxiqrJc/g7y/av +EQdrpFX6fentT8+P9MZdoIWnlDF0lcnTuDC8+cLX6jAXkrXAkPyQ1na9dGHPO6Dj30tg6TO4O9z tglHo5EVt/DFKrTPuSdu4RQlnP1ttk3aqjnP7Ksa8Qzn81jvOx2PS0QtTnS41OFFLcQrYoIWvmjF yDsWilmExR018blavQy1EFdCHAAAAAAOE79eCDB0YguExoQApc65WFDCNjzH9xX6BgAAAID9YKrD ddeZAPAwC5vlFq908dTkntD2JwVtsmBkycSjMK+0fWTMdXlTiFoAwP7wpMNXE489u1OTSVPvC3/y amqh45ygRek7ScqrFAeAYRP7UHeT3+HZ0R13yoqXAxwCZkHZRxUXGsvVb6S60Dbt/VKBinXELWJp SoNUplzZw33SNhaX+jlSdmmakmNtpd0Fu/Zf+m6um7QXu80OwFq8Z47n7u3ccz6VRgl2rE+3xDfA uky7zgAALGHGIu/V6gKHjlSdOVVHNzzrcKXswv4Ah8qNsnNKXbtEqc3EKfw5pa4tLZ0T2n48xP1X 6fcEaIdp1xkAAAAAgIPjVcX7/mNjCKkxXWl8OPZtX3gsN44hjVNI+QbYmh8B2Dt7pNZhII6LMLyB ioYZOqB4BXeg4Cp0HIKCkgPRcQUq3gXoaV8LE6wYJetl9WHjjzj8fjMaW7Ki3QQb2ZK1/0W+CgAA AMCvxppU0pNNR1W6zTV0dvbXLZd/GmVBYCKIWgQhinp/2RC2iAlZBDGLTX4jZiEFM3w7lqCG9keX Dcn49pbrIOnj2Bvv+3W3lXv+7NteNzhX5m+T3zT7aTeHa3EKm/FzJxbrLghdNNfL1Xk7Lt7mmG7f 26+HTl7f3sShvebW8myx2IhbyPpCxGItZvFVd/UZYWPXxBm2Nah/FxtjCCDMwcYcfNwWG0O335eN VVtOvHlX5VcKEdX/J6ke4cv3wzG/L8tEXitOyLK9L3uh7PTgwF0eHpa4eeWaYhY67Qf3g9lEki8Z yjInyp2olwqu2vgpC8sAAAAAYHf5N7UDAAPTJUCofrbSx3Sd74N+6bblFgAAAACm52ZqBwAUT2K/ JECiLM8Fl7EWHemFR6mk29P+sIDIxgoU9zKRLwAAGi+kFAue7CnpW6yykj4n1//EAiJbvlm+0i/V 0OfALlAy9t51/J3x+u3kokr3UzsBMBI+yPmdywtalN57WfdZViCSWPoQW70fS+9qa+2/t2xT1tP+ aF91vdT3s+5Hc8JqJfm2Qh2Bkr9ll3a70sbWED791I7M+3cFjlvaBxgSKWQcuzZSz7XWuW59Vm9l fetYDp6toQ+up3YAANZ4QYsH17+gRbh3/V+lxx79BZgjJ67u+6z3i1PiFrH1pLpOrq2260kZHwUY Bn9tnU/tBAAAAAD8Kvw8xLOz5z9j88mp9/r0fGWsXctOTtgiNWeqYZ4CfsynAOydz03DMBSHDa2Y oYgDIE7swBgMwJVFWKIXJkCICWAAmIUL9AKUlMSNY/xe7SaNleb7JKvOix2/VG1sx39+iFoAAAAA bI8dSLotwoWWcD5/MLPZ+V/cF5Wow3JtK8UsapGLUrjiRxW3sEIWNm8dL4/ttWP6EQgWdF1ef/eH uEXX5e3vbyVXmWP5TlvkNkP4L+YoUxe3KD+bQhb+cRVbC0008zav8X+fvK+iAv5eVcIK4qbyrt1L U/sTEL7YMfskNNFXOZRR5x+6EEQfZQzlewrNprPxw+oeGiIXvliFJ24xcewTe74KdpbfgRO3HBW2 4+k0xuWTIlyZsGCFL2gRmlwYErPwJxZau3HOSRuqpm60CgAAAADj4D23AwA9cCnY/S6mtoBLExAM 5U1JAwAAAAB5ucntAIDDogivEemkzWJCtm2CtpBJ88ME0ki2sfOS2wEAgIpHJy49r0MbmLnHMfVJ zMbC0mLa1EWvm+5hbDAOAEOl7Tt05kcNm/vcDgD0xKotdmeaG51bpDZOSv8/1B5LEYbQBCxiQ2p6 zY8Y0Qqp7bkMnI9pa24jChr7niZWYDSGLt4H7arN3KUPKdc47fImADog9KyX8J/7Wl83VF+E3ttq 19bSALTlLLcDALDmzZSCFh/C+dT+h9SefSrCZ5eOAwyQayPPI3bXi/prSDWhCyl/bHB9AQAAAAAA gP3j2egiFtJ4pyRSERp/3ZQvZSzUeHGj2ABa8SsAe2eT4zQMBeDXVKNuZoWQRog9YskN6AnmFNyK myAWSHABNoDYMTdALEajGWrsxlFcx/ZLaJM0M98nPTmJf95L1Ca247zXy0sYAAAAwBMl9fIoXoS/ sfJOa+jq6qUYszk41gSYaJyCN4Eo6u02IIXzn90Es7i/N1Z2nWAW7X4bzCIMmOHaCfdb/WWaMhP5 op5Bn/H6plE45fn9v67mhzGsIr+VU+sTr28SdbPofOzX9Hh9y/gvzqGz/u2016cNQiFyeL26fu1c WWNWPm0dztfnkFpHIhLGsfh9eyvPLi8PDXL668a6xmpBLnwAi1Cq9VpMVe23x5wFJNDE+emYSs8p AlqMyRKuwTnoGLP9lb+vVf4+1ER2MPv7pWlX7PmgFTt7zAWucOlff8zdOtd+vwrqrH07lb9vPvi8 ndf54uJCXm028vPuTjPTBbX4It1FhKGqXag2yDNB2rywWQXHRA4fxJU/pfAhYRJp51ImjufKAgAA AAAALJHXVr4F++GYZ5XZj7fDuqk0LJ8qo42xYhsYkwEAAABMw1ZwbgbnhQtokXPy0sexmPbRTx+H M6mPiLS2c3ZAnq9zGwAAYPlh5XMhv6/zMu35UvpAVQtkUXoupeyRaDs+DwBYPjhee/xsrbyd2wiA kbmx8t7Kr0x+rh8WHiuN2R2aw5JUn6uUDqk3pD+oSe5847R0zXJ9w9JcS26+I0cu75i+6FPtx2rn nesLxPV4lsC58X1g+dK8q3bP08bJqfZL870Ax/BmbgMAYI/7ts2NQbR+65BxR07+WPlo5fp05gMs judSj0k++f1cYIs4SEU8fi/lG6U9I/m1yY09qTwAOA3buQ0A6MEHqdeqDaXvHINWr1RWywMAAIAu 7t1z6XlbmuMZ8p44J6ny2jvg2EaAUfgnAHtnkBMhDIXhMpG4dDvJLDQmXsO9t3DvdeYALnStV9BT uDSeQHc6kxmkgQ616WsLgSHC9yUN9BVohzC0FN77EbUAAAAA6IZ5oXRXpqvQhuv1o1ouL72iEk0q DrZKzKIRuTDpr4DFvk6N3SR7Py1mofPm2F2fL/5fMPi29RV1fdMLro+4Rd/1TfdaGavOqZ/TfsQt 2u88n2vHvn4a4Yrmesrq9khx75Rjd6kEL/L8VG23P+p7sxG2UpUIhU8xKrMENYyIhrHXKTPLxaIp G5ApBPQ/Zj3U0e8xxjz+VOoYVNBC1T1PXcdhvby/Hb7S06IUemmLVZS2nSVuYRQlTF6LVhiFiUUt mLG3loaTMr/K8xRRi5WqhC1eVSNeIQla2KIVC6vMFbOwO11j1+wcu/3xYebs564DAAAAwDzRY8H3 Ml2P3A6AoTm31lMdryQHMrdMOWVuXhLGKDx5nMIAAAAAjs/t2A0AcLADi6c68oaClNmORSEnpDaO RCGHIp5p0vks01eZzsZuCADMmidrXQo0EXIelRxdpaDGkjOr1BelOrj62gQA00b+mBamwP3YDQAY GB1M9kHFRS194zDfM3lsvBQSo/DZQkFH3LLYMduM68zv2Xt+l++8xMrcc5e6HrK13TYE49buSOcu c7a5GL4pAK348Nh8z9mp9x9pPjh2T5Tmd315gD5A1AJgfJ5VNRcc62NiY+7U546irhNRC5g7N2V6 UdV/wvXzlAQt2ohcSPuFAhXYbQEAANCCFm8ee6ifCM2rSnPaKdvH6qbvAgAA6I70nkCa35HeH0vf mUvfAYbeCYfe+UptB+jMrwDsnTFP3DAUx98VUSEkJJYOdOjAdPA92PkIHflQrP0UbG2/QIdKjK2E xIKQmI7lcO3DSRzzbCfhuPTC7yc9nfOc5DnRXez4bP8RtQAAAADQ0Qbexwvk7Fu7KJ3o+PhEjPnY 8lUCE5WoRSVE8ZxuBCmWy0qgQmoBi7Y9BelGzCIUzHDn0QQ1hrB9i8H3jWd8vOktro+4xbrjTfe7 MlbMqd/T18Ub9jus4m7ye1PFdLx93Fkdr6nXtHXtGlEJzf/yOKn3N2a2qqMPDj7J/f2NPCwW8rlT 0Wb6DQj9UdoJWsy0/KGVtlqs6QhNbCoOMdZz/HuJsc3XEItZrPBCFo5K3cF4AZ9aQcJur1QjAkGL pfc5JYgdv10LYASCGDv+GVcrTPjto91dme/tyfXjY6nYTtTip7wUskiJW5ggz0h7AGIscCHSroA/ SCNuEYtZ5AYdan4GKAIAAAC8D/6MXQCADTD3n+F7jiYskZvIJZFP20frzNPOH8fl3QsAAABgHA6t nY9dCICAO9EnCseUJvIMXVwmNWmoa5zYn9qGZ9x9+SWIjQLAeFxLud5JTSLN1ScloQptomtuseQ+ Fpc7TgPAuHyx9vcNzouQxbT4Km2xcoApsbD2zdr3zD5d379TbaHUIiJxOiVg0denfab6HDRf6lpS 7VDtHnVtCw7pu9D8fdqXtEU3SzgWwEF9Av8Trg4oiRml8rr0v5aekbnnmZafOgZgCIhaAIzLpbUf Um7zltrgffuFb61dWTtb03UAbCPuneTU2m+/rS0ekBO4iEUsYpGLynLiFkba45TjtCTyAOD1HI5d AICBlPoptH1S/dmpvFy6VAYAAADoRqp+zf23HP8n3NW047uaVm7aArB2/gnA3hnjNAxDYditqg5d WGBACAlOwAEYuASX4Dbs3ZBYuQMSJ2FlZGAqENPYeXnYjhOldSjfJ1lObNd2qyqu33Pfj6gFAAAA QH+cI+muSpephuv1kzk+Pg+KSjTpy5dtxSwakQuXrGiFzrWwhWzvRDFsP67vMfcT+w6STnD9KYyl /ai7Hm8YfFf+/piH/pmWELco8b3Z/bjyzEeoblZrQjSCFlagoqlv2vlXWWEJ367d73K5+snfPz6C s2iV2T7aBT75uvraj6va/upjBBCa+J9jjDEOQhDTGGMf72FeP3tCp+lmteCEP6knxCm8goQVtTCm EbkwW6+IE7v4rAUxpMfEjfspBHwW1f3pYpETWeisStdmewi4S9BCilbMRZ0Ws5CLiyu3bFS5XIj0 oqSvAQAAAAAADhVrNDup0psq7xIAdG2GJiPyUJ/sxQAAAADKYgUtjkpPAkDwkqhLBS5LBZSJ1eX8 iSg32GRsvtAm5OJ8NohaAEA5HsV1TpCIUBu9NqQCGes/ssbWnlzRpRCsPwDTZpXZbp82dGz108IG +bovPQmAHfFapbWJi/vE9vk677IB6N9iQwUtutrmCFn0CVii31PsPpXnXofu+5SFYC2ZFs4Gc1N6 IgAC+fwf43kTss+mno/yNX3mkLMXB+jiovQEAP4pQ0T1cvceqX2GTA8GUQuAW9MWtZC+4pAYhbwP iVhooYuUoEXsLLNry+87gN1yVXoCABlkhEjw5Npju+y3uXZb1ikAAIDhpHwA2r8Qs/O4tDFhH3JM 2CLlQ47NT9cDjM63AOydv07DMBCHr1Wh4gWQEDsSYuEB2HkNFnaegndiRqxIrIwMzDBQiSEJSRM3 9tV/QluapnyfZNU+O76jQnXi2P4hagEAAACwTOwgHMO0TLepjo6PTyXPD50DvY3AhBG1MAIWdb4V pMgyI2whSsSiTaa+FrrIF/20fbvl1v/6cLj+X/iTxt8u+7Lf6W7D32rwvzJ8n/v+nSJusUnctR/z A9OLQtktAYmRazOx1XEaQYxa3KL+FJlMjubtPmczx2M6tFE0P+/fiF4Yu13eAEMRTtglP/jYzPX4 GH7/tpBFhVF3KBpxioWCRFk2QhZGQSJrbFlTzsfjWthCLGWJSvii8bFQmGjKJwcHcjadyuv3dyr8 qzI9ybKQRUjcorDqCnEXIeaqLOIOumNpxS20mEVs0aHPzgJFAAAAgP3no+8AALbEuSyLWlTo557l yTrXrtv42vp8hOw8cwEAAAD0x03fAQAoHq186llBbyryHShj7OscKhlKsVh0HYR56TsAAPi3VEJK b4k2sTGma/JtYI1tcE1tbO0yNsU2wALAbpISno5dB/vFnSA+CfvJs9SCFl+Ber0OVNt8+dyydTkk 5LfiFauIWYTu2/RBJXbsofkNXz71XYXqfeWubXxwjzkMLvsOAECRegav0L9nXX4ffXX609eX79MX B8Am4DBfgO1TCVrcy+qienrcCAkUx+Zyq/x7mR7KdL3uHwQwYKq1yxfiClvMt6fK78Up7DZ6f2ns mkLcOVidl0AdAAD8P0JjQJd52dTcRKiv2Pt9xiQAAID1CI23oaTfB2fKHhOz8IlbdHnXwb0AbIUf Adg7f5yGYSgOvxZ6ByQYKjgGAxyCS3AcpF6BGSYOwAkYGTkAE0uHCkLS1M2rZb+4Iqlp8n2SFcd+ iR0rcvwn9g9RCwAAAID9cBNI96W7sgwXi0c5O7sMiko0rtiG1WIWjciFc068Qh+dW618gQvnr+/j 7t1nHyLX5vqHTa9+yCFuro+4RdfpDfddyZXm0Mt0bOIW/QpbNEIRld99a3ffHW3jRC4mEcEnLXpx sj5+LZdppe0/qHc+mU6lKJ1LXzb+bd46KqghCU0cKh3S6Ob6saQxxGew/qbTIhfrP/XKcydOsVWQ KMOqbogTuTjdCGC4WRWtLOFmTmRzrx9VGVfXnc9mKaIWF6W7lnozojZBix1NDRWnw/XPhqLCRRpB C1E2RcAvAT8AAAAAjI+33BkAOBDVwrBXIz7Uf9Jx2ibkrHg/Tve/9hEeBAAAAIDumJfuJncmABTv pfuMxMUWAfthsY3KrMVCfQlcQBofuTMAAKPlSfn3XQxqLWpN+e60iVykLGgN5ZXvD8BxkjIWHhOg tuz+YgN5mEstagEwNJ6lbnvF6jqrjdPW14+1x2Ltspi4WIpdqI3XtoltynhC7BlDZdNWVhIIt8JS 2o+0MY+Xee4MAHikiFo4rPrKGiu26stUG+o96Jrb3BkAGCHVfOOD9CdoYQnnhfoHL4KoBcCd7Ipa FMofWiuqxSpCff+2a6z/mB3OjvYfQH8guAn/ndSxipRx2ZR2pUTC2u4dyw8AAACkY32rQ2M+el74 2wuz5plDY0N+ejofvj90DtAJvwKwd+46DcNQGDZCpRILrAwdkBACMfAEvAuPwsZD8DqwIQSPwMwM bARbjlP74FvbqKHJ90lWfUl93KiK49v5EbUAAAAACIltqJdOdg6VFbXIslicqaY5CPKckIVztO0E LGy8aYUtrCiFFalQgYiFH5wIhhOzcIIYzoapx6aXzrrjTrv7Ybccwa9rs9ma425rz34ibrE5CDHs vs2x39OpiFv0b9MJQfjpveB/suz7wu7cilnILt7WFfaX5jrrz/z942PzFhu7rdXGvxGesEUfjMHZ /jbtYKPfOoasfyw2/stv8IUsDE7doWnFKjoFCZ12QhadgoR+rpm0L2bhVk06ZQldvt/a6BQm2vTJ bKbO5/MaYYsbHZ7UXyGLlLhF45U1Ktxc+CPSSoUdrSlz4hbSMWtu02Esnw2KAAAAAAAwBi68uBT3 y42RpCiFrCN22Cv23VjdsfGXiuQDAAAAQP/cDt0AAMGjF69xvOjnpw725g4dxZzQpIKsT7aHMcz6 vA3dAACYJMaxckpIyVHqT/w+IeXUTB5yLfU7NU6RZdpvay4OALtDH/uUEK7YTe50OBq6EQA98q3D gw7PmWty7zO5cXnpXalWnKIkchHLr31vW3W+Ifbba+6RiuTXpmPwDjkeroduAICg9pBX6hkny2rm cXPXpOoG6JvToRsAMDGMY+J7HT4T5bVjkNLcb27sIMcHLzq8Khx7w7S51OFKhcIWcm9ySuAiVS7F LXLfKZ0Xrd1TDQCrcTx0AwAKfIl0aS4ilZea1y2lc5+5OAAAANQTWy+VfXJqHXidkFrTlrZZt4Ct 8ysAe2eT0zAMhFFXQj0Bi0oIgXoOBEeBNQfhBqx6B/Zs2bNHYsWqh6jaELdxO3FnHNOGBpL3pJF/ 4saTqHKcOJkPUQsAAACAfMLC0WNp01TD2ezFTSbTPTEJmYYA7T6RohRBpMJbEK+QabDFoi5wEQQx 6uIW3lbrlEDwbfVXVP31V9yiz0H1+/5/6YdIQVN//T6niFvksxGl2IlTbP4TUrTCOf1c5NbtCKIW n/O55czuoCIfXWVF8DkctEhHsk7aAfRJaOJU/dBHO78fSh9DOAZNnWFbJ0Qu1m/nleUgTrFVkKjG vCBoIcUspMCFXHFx1b5WYiw9K8uX43GOqMVFaTelvblmQYuapobYFr9wGL/EGPQ8llH9KGpfiO1x HgAAAACGxVfXDgCciPPKUoEC5AdccZ1W1tKU+IX1gRj3ZAAAAACn56FrBwAEPtDle0a7VFCZpmBl Tdb0UVHKD6e0seqgjj9Hfu3wtmtHAGAw+GvOqyhbY7y2TdZp15FjP2zV9pNzPbJ8BQD4CQRq65br 0u67dgKgRfyc68nZa/HaPEZL5RxIBvvIEZjIEbPIEbmw5npx/9b8MPZde57hEnXWeYrzOWUNxv7+ QtBk+Gt8KHXxvW5qTGoar6zxNTef0wfAIVx17QDAgGhT0CLn+a+2vmgJW3jBv+cjjw/gv3Pn9kUt CpHXxCykYIX1ban1G0vcQhLaMQ8EaJ8TRkMBOJhY1CKHpue6VjnVJt6PS+QBAAAgD+v5f+pZUO77 f0ulTWotOrV+EfvIdR9+jW8B2DuXnIZhIAy7hVKJG6BuWLFgyR6px+EYHIhjsENC4gYVS+AKJcRN 3EynfjUtSdp+n2TVE8ceJ6A8HHt+RC0AAAAAGkJRruX26zI9pRqazW5NUVxtbHNCFvZXClhU+UaU Yrl0whZmQ8RCJil8IQUxGh+FELWo/Nu2VwdEIPgD+ev2fFY+uxO2sLQPqr97Rf5fDu3P1P46cdeL z1M/p4hb5OEELaRd51ZJ26r2VnJCGa5PjRhVFct88R2LzWc2xChGdVD3ddF4XAla1CIWhdxfpZHc ZwcQmhimn2Pw0beIwrH4OYa/5X+0L4UsLE7doVhdMxsxCytKcVlv0yoSS2VvKEuU+1/UPtazAGv7 ZjIxd9NpjrDFY5lezbaQRUjcohBlhfFPRvR9wHHdduIWerJjbNKhbzsTFAEAAABOl0XfHQDokHtT BQuV706hd530IN22wEWszNc+71oAAAAA/TA3BNGBYWEFLUILhXMCi6UCzcQWH8VSqu1QPyCNnLj2 YRC1AIDusIIW7p4TWyAq87n3k5Qgha6nF6/qeql2fH315QHgdAiNtbetC8Phue8OAByQ3ECyMq/f wWV+1+ewUOAQbefuF3rOyxG2CB1PyI6dF9/5y7E1PCeeD4hawJD4aVmv7bU0dF/R7fra0OUA+zLv uwMAZ4Jdp2aFI1Jjvjn3g0O9d8g6b2V6L9PDXkcJcNzY78EvZfqqbZ+wRUycQq8t/Q3sr9szypbX gZjN/GaA/WFsAobOZ6I8Nt7gfnPGs2PlOX50fwAAACCf0DdYlw/N15PjO0vxK8u13fZbMfd46IQ/ Adg7e52GYSCOX4s6M3QDIWbehx1WHoeFpTMrOyPiJdjgPSpamiYmV+v8VVIM6e8nRXacxOdErfNx 9v0RtQAAAADIwzmX7iQxAXuxeJL5/EIFwrbSXnTCCVk4kQu3OPEKnbpluexFL3phC1/corXjQyD4 oe2N93rub0v7Vctt/qeA+uX2xvt7qWVz7NcUcYsU/hgQqyy0fbeeXtBi99j2t9U28F2LWrgg710A 993qJn06ncr2pp0QtJjodA/GEGz/N+1gY9g6atY/Fht/7RwsdYbvMiVysR2Zt1k/6fpCLXLRfHh2 HhMtZqEFLrTXRbq6VqpPbfY7n81yRC3OpBW2eBFb0GItu+IWE7V9pVJrcKKocpFe0ELUPmsjL0Ye AAAAAABgjFxJK2qhiQn/xcQpQmIWPv6xlliGGLYBAAAA4HDc1m4AgMerylvvBqGy3AnAqQA0OcHH QxOHmFBUhuWf+6jWGgA4Npogms+R7dYkVr1ecr+xAiZbQhbWpNZVwF5uWwHgOAl9e8/dH+rRBPa6 qd0IgIF42yz3kha0sJ5lcp63YoJiJUIWpUFo9xWzsM7HOtdY6udT23x4VjxeLms3AEChRS1yvrHG +q5QPxnrR3PqDdmK1QeQA4F8AQ5PqaBF7jtIStAi9t5hvas8CqIWANeb5aHLx4IO6DmjvoiFnmPq /29Dx39KeJyz6wcQsQAYntPaDQA4IKXjB0q+HVupBNYBAAAgjeVPcGWWvzfla/bFLEJ+5di9P9ZG ax3gx3wJwN4Z3DQMQ2HYBVGBxIFTpYo74sQCSIgRGINxGIARODAAS8AJsQASA5QKCYxLkubFfS9O SmggfJ/0FNtx7Neoip3EeT+iFgAAAAAZVkAcWb4f7DLV0GRy6LwfV8oykQmfi1gU5sW2EKcohCpc RcRCmhS+yMQspJCFX/ZTCluU26pPWSGB4Lvqb7jnc9PiFn8roP66/Q33/9JXn0M/p4hbpCjXfYy+ hCHEnmXGin+nt+F9Wdf7LI7569vbl+2Nx3oTZtOj1XxhWpk0bRCvNDUcoYlN9UMf3Rz/X/rgN4g2 ciGLBYW6g8/bXopZLAQuXPlWRKpIvEf5irJEOH4772OpMJHnpzs77mh31z3N5yk3T10WnEh2UwhX jKIyKXSxJdLyhZDMO1cdULWFh17ZrpxKpZzFiQAAAADD5SHYSd9OAGyAY6M8FgG0PhZzRp1Y+MIS w0jdi8m6qXoAAAAAsB4HwS76dgJAsAho9mjs0wKZWYHEmn4o3EbAwuon3h/X0fJgc9+3AwDwb7gN NsvT1nW67iPWJuNLnYBFKpBym3FL81VLAwDA7+eqbwcAOqJtINm4rG7e1VbMomtRC8uHNs8VtHmc NveMz42WT833mA/Ced8OAERYz3/r0K6jcp+VbnIfr9XV2gP4Lot3cgTyBfhZrl32fVrT+xDrfWPq HmTdewzZ5l2w52DT9X8uwJ/nLNhNsJc8L7/1lEIUdeIWsu6HW12zrLUTr2+W1wy5ZtlF+1nDDAAw bGYibT0fsOaRTdYQNH2W7JS0ttX8BAAAgDRN3iPUiZvK9LurfybUdNyP/dLyAJ3yKQB755LTMAyE YYNQJfYsKiFE4QQcAAkOwSk4B1eATe/AHXjcgTVs2bCvaHGamEzSseOWNA7p90kjO492JlFrK3Y8 P6IWAAAAAM24SaNba5PQidPpoxmPz1fEJKplKTqRi1mUIhe5SEUpXiFLZ7OZFL8oP1MVt8j9xEAi +Lb9Dfd+7oq4Rbf+hvt7SeVz6PcUcQsdXbhCE7rw58XLfWqfN8t+1zGzne1hOJhcFKOIaVk3gezm QsBC1mMuHqGJ/vnoyk/fBS3+wz3og4++X4OWEfR3XyE4sb8UAcpLJ07hVCIyywaf3QyKFLOQAhdy piUj+6656AgOrJ2MRjGiFsfWLq09m6qgRV3EwoWyJ47PRam9aGjEfmNKQQsjzlkodaPUAQAAAGB3 +EodAEBHHBX2acILsSSxQhfGczw8ILg6GMrzGAAAAMB2yQQtSKADfeK14bhvYW7s4uB6whnfdmhB cd1PTKwQz1PqAABgJ8hElF4Cx//SxzQlpGhKZhZKkKzFFtqGKvI9EIA+cGrtLYHf+v+AZGz94dra VeogAFqgbUGLpuf1UEJZbV8KQQvftYXK2LoG7TpIzlIHAFDjY41z6+1ZvU01yrav/d3EB0CbXKQO AGDgbFvQIub5wy29Wyh1bRz43trdxlcMMAxurD0UdZ/oRKxJoQtpmiDGt+LPmGobwrgpQHtMUgcA EMH7muf7xiaa3h3YZEzZBEoAAACIJzQ/7epaXx0z9xwSuAi9h16PBaATfgRg7/xyo4aBODyr/lV7 ACT60kf6AuoB6Fl4RJyCI/QUfQLBWXjiDL0AQqgEd7PZTKYzjncb6m36fZJlx3E9k3QTO3HsH6IW AAAAAP7EEjtwdJrCx7GKzs7OpWkOB3mtyESzErHoBSz6uBOnkJVwhazFK3SsRSx6MQstZNGs7fTC Fn08BgvBT21vvudz7uIWdRbwb57st9Laa+NdFil4vL35XoOPt/c8rsVSm0vRiGW54bp27f8+WtvO iwe1DtL39R8cHKU2+bf80QoXvRNLZ7tF3m3T2wlbaLGKhRK/WKh8LW6x/rvguP83iEDM08ZLF2rY FRvP8Ri6e9xC1d2JUzSiFCTSPi1goVUk7sz2QFki1b23svFX1XuffrW/L2+Oj+XnuLDFe2knMmoz nWsLk6eFLvRh6AEhvS0ybES9Dw8bJ35wKp18Pk4EAAAAmCeIWsBL4kJaUYuInHiFLSMmzolb6DST wAAAAADq8aG2AwAGvcD42LNBNMGnJH+TkKs78sXug834kcLb2k4AwKy5UWnvnm7zc2W2mcRaIq5U sphF5N9YPgDsBidPYCP3bt8ry32jLp9rOwAwAd9T+Cbj/ZPcgiG6rxMtGuL1u0r6X9uIWnhxaX/N HptNR9veOfP2ReUANO9qOwBgyH2jovHaDK9MdN+1ca5cZBtgSi5rOwAwU36lcC2xcGj07NHFUVvh 9f2neN7QNr6m8CmF11scN8BcuErhSwq30l4Xeq6nFaKwae+63UQEw9oT8QUu7H76igCbc17bAYAJ iN4l5N4NR33Kku8CxElb+7RJAAAA45SMW9s2N2qvo3HlO6dcyTiytS3BNsDk/BOAvfPHaRiG4rBb 0aUMDJ0YKnEEBnZYWbgHl2BEzKywcAHOAAcAMTICI2KpGJhasElMnNdnJy1pqrbfJz3FvDi2G1on /vtD1AIAAAAgjR8wOrU2TEW8uro1g8FwSkyifCxEJzIxi0LkIhOpKItWeDELJ2zhzYtfFMIWUtwi y2de2Ai+6fzW934ibtF0fu1+V7I8TZ5na1mu/X1dre/pavwW03kWjuJ/LPe2K+J5IYnMpH/62e0F M9wztt/fMaPRu/n8+jKD7e3pQoYJ6IUt/IGAhbdfT7dbFrhQL18foYm28iGPZq7flDz4DCItU8yq 8zWcE62Y5Pl0ckEfd3R+L07xJ3BhzXVA+9GTUMwiFLgIR1o6eTq/oyt5vbplfbu9Xh1RCzcB1wlb 3JuyoIUUsfBF6QTnJ8FRTlIMHzLdPDwWfm0Soj8vwwAAAACwGTxZO1l2IQBa4sBkm8bKTkfZrAzP +XDMwjaaZkaEwzS1fAEAAABgMexZO1x2IQACHq19RM6lFuyEPm2RUbioKLUZ5n9MKwvMh7t3LwZR CwBYHM/WHiriaBtD1LEqoQq5oDW1ADb1zEn55GeAae6snS27EACCWecnVQlRz3OdFpe6pD2ODG10 WH2uTXncUSLfsXy47jtXSmjiPxvLjiNppd7R6gqQaX+n7kVVWEI9DXXYX3YBAARviq+qTZuqS7V4 s7abU329AE2ByBBA8zhBi3Nrr5HzWr2felev6q+tal+MI/5Uf/GltYvZPzrAWnFs7cbE13jK+cma PyV28S2uMUFcI/zy/Y8+UgAAqOp/0HyxOQJ15gRMIukZ5RgrHwAAAMSJ9RfNOk6tjTnXedZrYxGy XAAL50cA9s4ep2EYiuNuB8oAW9WFhQlxBhauwsQlWLgC90Bi5hJIbIgbAFMHxiokTd28vPo5DvSD ur+f5MZxIr+XKonjzz+iFgAAAHDohAbR6wVwqpWrb7symkzOXFEctdJqkYliuSC2F7Botl6cwi0E LNxSxMILWvggRS5qMQspZFEs7TTCFq61tnZfWAh+3fby/T8Rt1i3ve3eK7XN7QoUeJsVuf6v+3Wf 7sezaNtsxop4wQotYtGc51pxSwij1qcYtMrR0eik/P10H9OpOx+PW37V4herhe483We48KXw6ZZ4 hTzXn7Pl+zeHRf1zsrEOO/skopCzjRyuYTgczt93etSd3M5D6YcUsJAqEjO1LxUk5qoTVb3GNSP8 /AqmlajFxfGxe+8Wtrhy9YRGaca7NlBpUuhCX04hzgsN1vDueXELPdBRbjWhdAYnAgAAAOSB/w4E ODQujXRL0EL3xVlCFTotZV/b0w2gsfoaAAAAAPTnZtcOACheRDx1wk7XBN7Y5KJY3Mo3ZMfyDdLQ db0q/uoQHAWAzfEk4vr9nVL+WOWMNSE1JmJRBNKt8sipeJffAHAYhAbawn5yv2sHAP7IXwQtUuvx scVCqv1ZIH0mjnUtLmstOLtJMYvYt6YF337QF0Qt4D8RErToQ1cbcOwcF9gP1bN/824GSOF81w4A ZEZVpjyU4cs4HuvPC5UdMUGLmKhFqK6h6yFW+3HFcxnuynDa6+oB8uK6DI9l+HarY4uliEUorp/b kNiFzkvOK5V91D5viT6u4wAAkA9vkWOxtgGrXTj2PRkbX+DTdH6x71sAAACwSem/Tu2vjrUVWfsp feKWr5T1sDF+BGDvbHIahoEw6qCqQmxg2QUIwTXYsOYU3AAuwJpDVJwAiTtwBG7AlhXdsSLCbmJl OrUdt6RNm74njez8jhNVHTuJ50PUAgAAAGCR5YzXxjxYu0odNJ2+mcnkeklMYrFsRCcqMYtG5KIS qfACF4sCFt6c0IU7Rm5rBDKMELPodvxAIviu/Q33fiJu0bW/4f5W+vQ79Pt6WOIWsXzgsp7Kc1ev LQpxvkIsN+IWjtHoeF5+zWbKZSM6kY0WtJDLvi6274twwi75wUc3xx+KD66h5dyVg/DXdW69E7mo SydmMVeHcHXTKEW4h9D+a1opZiEFLpyQT1kfV4rz+tg9svWL8ThH1OLc2o2pJjZKQQstYuGbUojt pSj1R4oyoBzV9V+1vlD7y48QdR0AAAAAhs9H3w0A2CIn1i6tfUa2h8ZMRtX1cmqfUKn96QeejMUA AAAANsN93w0AEPyY6h1RG7FJREatz0kymZNYPDRpKKcdej9YjXdrT303AgAGiRNQSiWjcLRNUg3F kJiQhV6OWVsMSplut64DAMDuc2uq5H0A+8qmBC1CYhJtghQxk0llfdl2zpx+X+o69LXn9N1S/Tj6 eLAOZ9ZO+24EgECKWsSep7b9L+Y8j82NPbkw5oYuoM8P0B0unjybKgF+iFgc8KWOCbGxR2wsEhK0 iAnp6fGG9OP4tvZi7XGVGwAwMNx3zHfWXk18jmdInCK2Xs8zTR1TqH2NWe7vIWIB8H/oC8OQWOVd fk7S67bn0NqnCZQAAACQh46doXgr66k4vY6AVWnC8Zt3ELB1/gRg7+xxGoahOO6WClVCzEidOjEj sbOzcQcWjsE9mLkCN2DkJiAhdUYlH3Xz+vBznDY0rfv7SVacF8d20g/H8bP/iFoAAADAKWOt/Crt F0V4astoNpu75fK8ikshi3IB1lrEohGwaLZewMKtRCrcWrxCC1posYsmv1rkwpfTCFu4zutrt8FC 8H2Xl+/9RNyi7/Ly/a4MWW7u9/WUxC2kIIWn/lwbW60REVsbb7Q+r8lvk/G4bue/FguRjX2xVV6b hqCQxWgVfHxdfxnvu1E36rsPchAPOJYyjqGOh1AG15CW/1Ltl/9LvlTviSe3VSjSSQELqSLxo/ar UZMiz7NVWaUohh9NkR59V5OJu55OU4Qt7orwrorxVRspmxS60JcjHRBDjhq+el7cQjs6yu2fWxuw 45wIAAAAkA/lc913ayqAvLh1taiFnpCl+zqWaEXopV2KLXQs1h8DAAAAgP54cLW4GcCh8BE5FppE FEoTmsC7bUhdVNyqB+wGgqMA8F+8inhK+6IJtTOhiadyP0W0oq3didWPdgfgtIg5nOlje/Yohx14 HroCADswlKCFfs5KWUA2VWgstI09s1nX5JQtdB9CcZdgB0jlZugKACg+O6S12gmdJvYf7CLnhfKw 0gDsynzoCgBkRClc/OL6EbSw+iHWwsNaJK+LuIXVpygp+1WPRbjsdCcA8uK+CG+u/m1b/sWWOIU1 n1TarXOkv7L0YZbo4zoOAAB5sc073Lbx/y7vpGPPjZb/AG0SAABAN0JjBDKubSnCFla7HhqDiI1t AOyFXwHYO3+chmEoDrtAFxa2SsDSiyA6M3EORq7TIyAQKyMSd2BlZUK9QMFum/rJfc+O2tCA+32S ieP6z0uKUtux3w9RCwAAAIBI6u06cOfDea7QdPrkRqPxQpxCE5VYHqPoxFLMIopcBFGKKHARhStk CEIXoYzM0whkSNGMfYwncATfdXv13k/ELbpur97/lbTd/Yoi1H1fD0PcYiA0H+JakPidaj7u0rhL 0gcrgQuZ53jx93M200ulIhbLxILl/n41eVLRC6vOjkHMos42/ruIQi1t1HQNmjfQdVoQ5QkiF6tj ELNYqEOEuItKEWEiullVuxaz8Hml6MXRSixjIWIh6m1+r098/HI4bCNqceHDlQ+vsnq3KWLRmDIQ n8/FUVuk6ES6c1HQwok830rcKXEAAAAAqJuPvg0A2DNB1OJRnGtiFuk4SZuwk2Oy3KYyrY607dyG LzaDAQAAAOzObd8GACS8iLjW37fSrM27uU2+qVNxzcm4y9Rp2QHdEQRHwyKPs74NAYCqeHNl55nW sz+32VTbrGo5pLA+b+OkorTRVYsDQD3sstgMcYu/zcSH676NANiSZ7cUtLCwnGvlxvFav0gTCrOC 5WS2jZhFW2cjc8P29JpL/bVcv40+HXTFpG8DABLeO6ijNFdr5dHKWOc8h6Frxn0bAFAJYY43CFpY z+muxiBtxh4lMQt5ro0zpJ1fq+u6b30nAOrj1IcbHx7c5h5PK0jRijRtXihTWtecPmdYtwwAcLhY fcs2fcxt5qdzc9NOiQMAAEA7Suu/rfcLpffGuffLpTWAORv5nYdf5UcA9s4mp2EYCKNpq0qV2HRL JRArLoGE2HIKOAV34RTsuAc7log7IHaUuOm0w9R/bdMazHvSyNgx8SRQ107s+RC1AAAAgP9KLJK1 cNbaQ+pEs5kTtBhtlLvAqyI2IQIW61TEKZqlcEWzEq+wghbOtNiFnE8EMlw7IpgxP+L0gUDwfbdX 7/1E3KLv9ur9XynbZt33tVZxiy7QuaQibjFQxyU/WNXv/sa+9SExR9exy0OiFhEnfwhWLHy1N0X8 culw2JmvXs8gaFFfG3/Bx9/QBtew//kXx5cCFA5ZhafThbX1RDVClCJ0/ksJX0j5aCno4wQu9GpA iWh6Oh43l5NJjrDFVdNtdNSnl+YGpkwLXdjLmat6vpdJ4p6IW9ggrTrduJWechYnAgAAANTDW2kH AI7MeWsnrX2osti8KLaRy4oKWpGLxlPPzsmsD7o+8y4AAACA/Zm2dlfaCQCFCzD+Hjjm26AT2pwb 21AUspyg4b52fJuK7HyF+cvuuHv30tp1aUcAoBo+W3tS+W37bN93ik8UyZdPBajINZ+vfNcA1EvO 2iSELurgvrQDADvigsnK+CoWcCM0n7Z5O54KiU3kiljkilqE2sp9ZmCvM2fsFhrDMbaDQ3BR2gEA g09s0jdHD/WZobqx/tnXN9uyWBsAfXBT2gGACnCiem4Okuq/Y2P01LvCXEG90PwjNQ+JPfd9bBC1 ALht7bnp1jKH1hjnilnoOtZCAhdzk2rk88r+UYDtcZ+baWknABK87vh7qWcR264dSAku5zyHBgAA gDx87w30z7nPk3LyofcSqffHAAfjWwD2zicnQhiKw2+MceHGjTuj8Qgmxnu482Luxgu4ca8r9URe QJFO6VDevJaSMIPg9yUNpfx5hWHa8mj7Q9QCAAAAwLMy4o/S49Rer1/k/PxyR1SiG29FJ7yYRSty EcQq4mCLWkhnnyCQ0bVbbW1vL+QgggVVY4uJ4Mext9z7ibjF2PaW+6xMa7M62D319vxyHs/p3/wv BkGLOO7rRt//o/t7hv3aY8N6fJ7d87t62wtY9YpaBAELr7Zhb2tELKpY8CIStQh2V83E7vtgCZP6 H9LOHGxMLXIwFztz+C3/6vmtWUi3aa7MaupQt3RiFht1iEi0wgXnjHZlX+hhG9Ji0YujRixjM2Np dN7Q9jmu41cnJyWiFhfSClvEghZaxCKIW6yi7T/SnTRVdy6UKF2kFbSQaB+rM6IYcQAAAABYNs6R cDZ1JgAOyG0dPlWafkfSQhaS2KbfwXKDyywQswAAAADYL/dTZwBA8dazPTUIt28wcGpwcMmgIb2f tmPlx1qHMqzPmR+CqAUAjMertBNnpsrqIfVKbiDqENGK1ETKuXzoa8jVSwDwf0G0Yh5cC6KTME+c oMW6iVvtj1SbRbdnSttGQ0JO3KKK1rWfYMikYfoadNy69tS9yqUDjMH11BkAiHCCk5aohSNXFpb4 ZeM0a6mPt85t+Xopo2EsbqbOAMDMeRI/xqzEt6uXJe8gll+3732jJG69c6Tqnq86PNfhoeyWACyS 0zrc1eFd8v2XcwIXWtwid0yu37PIbpmjBS0QuAAoh/YwLBHLj2C1+VJtzG8jrcRHLUYcAAAAhpH7 lpvyJTlK+52XfGNO2dVxgL3wKwB7Z4zTMAyFYVdUqDdA6tQNDsCK2GHlIByBlYNwCEYGRoaOTAhG rlBBiNs+4r48x2mbNk36fZIV14mfX9KkjlPn/YhaAAAAwDFSFdxGuM3TTcrQeDxxWXZaKhchCxGe EBEKEaRYiFO4f8EKv5zNYoIWhdjFQgyjsBkKZmTG8GG/ggXZsq1+BthHsOAQ2pKT/LAC6rffXn/P lbba3PcxXbTZpWN6qNdiYXjx3RUCF1bMOxGxENEKa11YR86Lj+9vo+lBuSMulDNW81bdQNBibsUL W+zoQPVFmIA2mrfRpv2+tNH1fVjX9mD52ye1ZBZeuJynfDtRjfCCFj9e6CJPJTELV6hLnCxFffx2 K7MBvSBGXnY2HLrz0ci9p4UtrvL0qsxLcwNVFgpd6N3Jgu2sP3ZkIqKIW2gxi3BZOpRGOZMRAQAA APrD1BE4EY6LS1eIWli6iJo6QhbrllljMgAAAABonvu2HQBQvAX51Dgg9cJPVWCadV4echX2tK+W z4xntmfatgMA0Bt80MznivWpF0JT/cI2QZd1/VifVNdXAOgWFzuwiZhFt3ho2wGADfhyuxe0qHt/ ZQWLtcpS92I6kK32K+aztb91nxtUlQM0yXXbDgAEfAb5bZ6pxvoTvc6yaW2b8iFVB6AOk7YdAOgo /tnukyvmNVpU9QGxPsMaA+hxggQZTo07UoIWMWGL0Ffh0SFqAXCXp5dlPjXXWItT+M+/al14rcfq hJ8ztQyRa5b5zQAAx0ds/lhsPlnsWbfObyJs4Yw8AAAArEdsDl7s/4YmkrYf8wdgL/wJwN7Z5DQM A2F0WlBPgLpBSL0B7OEg7LgNXKBXQGLHFTgBZ0BI7FCX7JoSt3HruDOxU6VKG70nWbZixzONWv/V 8YeoBQAAAED9jyCfvk/dNJ+/ynQ6W4tShKIS9fROdGInbCFbkQovWBEKV+yLWkitjK+nLmax2trW QNzinO0N93kibtG1veF+V/qyyTNN3l3Fff8W4/PrNnG9fu2sOy1Pavk7cQvn93gd/ywWsiw74ovx +EB3K9GMUMwiCBLEvrzZwbc2jaDF0Gycg4+nYIPP0F392omg22uu/XIiF1XsBCjW6hAuLRuhCidI 4ZQjLl1aduoRewIXlVjGegdgUN+ysunuv5lMckQtrsvwIJuNx6HJWMTCi1uMgvxC9E2IcafhO4Rl dH0UlQ83IcZpAAAAAACAoeAPz8oVsZAgzinXJICh1RFPY60yAAAAANCOWRlu+3YCIOCzDL9GnvWi UFym6cWh+KXfY71UZPkHh/PVtwMAMBjey/BXpa22WutzrJA68CzVH1mHmFk2tH7I8hsAzo8+1roR vjgNZmV46tsJgJY4QYuXKp3bdlnzZ23sc6igRRtxC22tIDU2a1oXaBqj5Yw9AY7JXd8OAER8Z5Sx 5ufSkNby4tiaW1ttNm01dA3/zQG0xwlaPEtdFCmkaQyutfvaeL+LOUjOfMSyH+M+61sZHs2nAjB8 rmQjzvch++94WoIWoYCFTxdGeau+MKzEXreNr7OXGQBguKTWClLrD6k9A5qImrb3oAhshCLMsU/0 RwAAAPnk9Os+TvX1Pq9oKKfVpflhXQPonH8B2DtjnIZhKIC6okOFBCsrHbuzwik4AEfgGKwchw0k RoTExE0YClWJ21hxf/xtJ2qTNnlPspqkqe0EGteJ/R9SCwAAABgb2uB5f/ulyXhQO58vzGp1Vtvu RBZOPFHJLJyQwhdVGPP7u94kJ7Fwy1J2YfPw8/SFGbmxrpFbnHJ5wz2fyC32Xd5w/1f6KnMs57R9 ecfyXZSx7dzfTIosQnHwqvcqkcVuPDy/rf1ZLs3FbKbXZJPHenfdBmU34o6fFFzYTU6W4Yst9sAQ gvp3VUZX5Ry70OIUzsExlDH2Y5iU4h2XgxuV579amYUcKWFHRlhxRU1mYSq7hPuc63H9lXIMU8ox rqZTsyiuxd9pscVtkd5F9q64idjmiy7k4cQe+hhTDUx0covQAMTcgYjaNgAAAAA4PV6LdNd3JQA6 5LxIN0X6KNel3C/U94klt48vHUzd7PP7Y/5+8kYmfS4AAACA9jz2XQEAwae3nDs5J/bcRwsKIycJ h5Zjk4i0ycD0Tw7HV98VAIBBYMVJL5H3Q0EemkxKDbUrWvDk3PYoVLdQXWmDAMZLm0FjOXNxoFse +q4AQENsQNlns5WFab9DtCAcOb+lYuIJLTBsal0GB8uVWch1k1jWjl87PwBdcd13BQAEmtw4RKpP 7C+n+vZa3to+XK9h3yAZAmiObTNs/+NQQoumYr0coYXWH9H6HfI4LPY+zZNBagFwX6Q3U5/bmZJb aBIL9x3M+Vw9SMEWbSw1AAAMm9R1v814Av9Vk6HliJhz6gcAAAAVqWcBqXHiWlsca6djz5dpz6FX /gVg73ySGgahOPwy43TtoiudnsIDuHflNbyIXqBXcO/KtX8u4ngHx5VWsNAQAg+aVtum3zfDhADh kWiBMOT9ELUAAACAYyd2fGO5MWGmXTSf38t0OuuJSnihiTDeFbaQnliFP/rgz624RVze19O1u3D2 6m8acYtDtjfe54m4xbbtjfd/ZVc2x/5MN7e3u99i48QhWhEL344m+HvpYhZRjZ0yS5GKNvczJWrh HLuvjok2LsKyshSw8GIXYbqY9MaJWnSuGwAiEOO0sc8iB8dk49DvYWjdKXWGVZrtt6zIhTt6YYpf hQgnSuGVI06sOIW06hE9gQtb3glYWMK4uOvPJ5MaUYszWQpbPIfVS1/EwotbNEH+t/Qdp+acq1q+ ovR4w+MiyI/jAAAAAAAAY+FCWlELj/ZBWFim9GFXTsAiVV9oV4R3MAAAAIBtcr3rBgAEWIeYrxXl tI96wvTvRFntQ+EwLfcRcKkdcVtS5zAM+xxfBNFRANiMhyCe659TffoQ5xM1jphTY07pvMYpBWMP AOSo2Wimrc9raTCcU0F0Eg6PW9GdkWtOOErzqdI8ShOvqHUim7Olzb9SczFt7hjHtTSA/wAn6rBv 5ByTx2jvwKXxRctLrfmm6gbYNvTHAOvxbsKdCR+ZfG0enurzhwpa5N5DSu8gJVE9bb3Xrr+8mfBo wlXm/gGOgakJlyY8ufOa/cexiIX/3Wn5Wn0L6e9jDuOSyQOANMyJYUyk1olLoXYfQWquGs9j4zYw BgEAAKxPPH7WrDel0rQ1qdL1WjsA/pwfAdg7g6SEYSgMP5BxYEbHpUtl5XAGr+EB3HkjV17GA7hw p+dwwY5KTR+kJXlpKxKo3zfTaSZt8l4QU5Im70fUAgAAAP4TscX0fv7F+nhKVTSfL6QoznfyfRGL upiFClL4QhWyEa/Qs6ZV3EIFLso6VMzC1V00hC36cWhxi0MF1nb23Pl0gsF3tVdU9oYXXB9xi33b G+53JZfNoX+m+xG36F64v9163DtXvh6/bpvXvLZdG+JEMeLP1fI5PJtdynL59SNq0c61QGN8QYvK ejEa1b9Pmv7lHx1Bi+HZOAUfj8EGbThs/aOq89Qaxy5zc70mZlEJWejq2vLajpiFVOoS63u17Fll Y+XVXwpcXE8mcjedymda2OJeXDAjX7xCzY0aeb7QxdhLpzatiGwXJ6q4RWgBYmyBIRu5AQAAAIbJ a24HADKw8NKxzVjSuCclZBHL8+sI1WeNw0I+AgAAAECaUtDiJrcTAB5vxjVro05qE1Dbo20Q8ZCd lL/QH38s+i6IWgBAf8rgZ5Z4UptnS5fgE6FnSkrIIlTW8kcaaQAYNn3nwNvsvYG8PK6Pq9xOAHTg Rdxvq5JQv2QF4UiNyfsKWliBZDWIbCqYrCVsIYl0rO2hzwUgFwSMhGPjI5DXHONafWeqX42NrUPp WP9N3w1/wW1uBwBOiH0KWlhjEGss0kdULyawFxt/NNvgt6Wcv3kWRC0AHsSt5df/Cz1bghaW0MXK uB4rL1KfU/V9AYBuMB8Ox44l6KyE5jBiv+narC+wRC5SawpScx8AAADQjtg7Aut9cOgdcuqekC2A rHwLwN754yYMQ3H4BSEWlg4VS4XE3FP0CL1Ipd6HuWv3dqzavUsP0EtUYmmaQB5xjP8FUqKE75Os vJDEzwSwY2O/H6IWAAAAcMm4gt08FGkZumi9fpbFYrUVpTBFJVRoYmfX+7WwheyFKlSswrQ1qbiF fb7m0xSzyPf+TqG8/lzCFiWIW3Tp77z3FHGL7uC7MnyfY7+np/k77neofo/zWc/vyBoiEbVoxeH5 9TbP7Th4zTzLz3s+v9qKWvxsNumlKvzmO2ObsmqrQha5LWah+5NJ87WWjf0YgvqPyUcXfoYkcjBm H7yHKg85nD2n9qQU7akE7TIVtCgFKsQSuCjStBK50NemYsyoKPtTKoJR1YGTSsxCKa9fzmYpohY3 UgtbmC5tEQsVt8iM47/GNhRktaq494IWYpyTO2xx2AAAAAAAAGPgWnZBjr/F3deJLdhS29UX8/XP xLLNvHx9LxaFAQAAABzHfd8FALB4MezU4I+xRUG+xbx2QPFjgojb5aBf0i1mH1D57KMgADAangy7 zQJU1zkp7Yov2ESbtijW/rigPQKArkD04nw89l0AgBa8Si0UFuun21tfsoN1+Z6pYgFjU4LIhoKA xZ7HxGH73rfvvgD0yarvAgAYpASHdOGrl+06OdYeSeSaUJ4Ap3LXdwEABsJ7kdYSf8ZOqc99/xuG Agen9EdCghexfkjK+K+OzbwV6UN26+kALpVyPvNtkb6qfXu+cUjcwvzN+45pCuWXS3O+sm2L5xgA AAyP0LhFaFxc7dj4cmiM3Ddm3kbUgjYIAACgPXb76dtv8/+D65jreIp/gH/lTwD2ziWnYRgIw25p pW5A7JC6YsuKG3AK9rDkJFyEM3AATgFbuAJrVOrGbqbu+BFI66b9PsmK4ySeSQR+pBP/iFoAAADA qRALjpflF8v0lKtoPreCFmdb5V5owopPNNsm3wpSSKEKsxawkIIWPnmhC3u8qUfWvQiELfphv2IF C2drv+IWLK7fpz3j7B2yrfD33F3b+xv8rQzf5rE/0xriFuU2wzXpQlvb69ptil2E10hhjLbv8P5M p+er7Xd+8XTdU29bileIfS94MXJla0GMLnYGItCAjf1dfyo2uIe69Y9cYzl27ZaPzlttraCFFLPw QhWmibq1xyZu3577Y1o1iVFwnbXhFSaME7i4mkzMzWxm3vNt851pgnGleMXaVFAmhS42bieSjNns 9MamFbfQAhBjAYZaOcGIAAAAAMNDvqx4q+kIQEXsHOzF5UNhP23ekxIRzJWljqc+2mSuBQAAANCd y2V6qO0EgODLJY3Uh7/a8fA87Trtw+CSlPIj9EXbh//xWdsBABgsHy6liH1MmusztIWXw+MpgQvt mtI+KdcPAcBx0mcMUi4QjXin3fNoGoFxgCFgx1NeKExrG7TxlN/m5uQ5gbA+BS1iIhqhX9J3LR8+ h9QzATgEbms7ACCQi0PG2s/S+W5ujqy12SX1xmyl6gMo4bq2AwADoKugRWzMnnuXm3p/20XQomQO UrIIsXafPn7yeZleI+cBnAr3ZlPUQv6PSKGKMF8icqHVkYpt9vhzGRsCABwnufFoqiw3Ns29K9fe ZZcKMwMAAEB3cv17ye8PpdtUPuYLwE75FYC9s8dpGAYD6EdLr1AJFlgRYmJG4ggcgZnbIHVkZeYM /NyAazAgdWBrSNK4ddzPjtOmcpq+J1n5sR27pTi16/ghtQAAAIBjRVvJ+ikP56FMs9mrTKeXpZTC lkoY0cRyf31siy2WYbESVphzutRCrDxGiiGOzCJbldclQ5ZbsLj+PsqTqrw+l2X+SZBb1Msb7mcl VZlDf0/7Lbcw19YEFuvMpSQi24yr/83c66zPjceT8uhnPm/1OjYEFlq8LbYYjfxpg8UgtBhaGYdQ xz6UwWtIc317Bp/dXmVVeYWQwmxLM0QhtxCpCy7ycFpJLkqjRB43rmQVq1kSRoJR3RRGVbyhyH82 mcRILYq+3p0sFxW2hRauxMLILU6s+IW1DU0srBrwldBCrDSZsi/KPgAAAAAAwBC4lbXUwqA9DKbJ KCQQ5x+8C1/DHqDU+l48HAYAAAAQx0PqCgA4fDXExyxaE/sAsLZgTdPCNlo5vrrRJ9kf76krAAAH y5u1H9Nuh9Jo95SQyCL2ntR20QnuN93xm7oCAB2jLbDmjsd3VQ5t0e48pq4AQCR/eXjeIp/bh7bP xcrAQkKL0EKy9rH2Ha1pfEA8x+Lsx3yfBEjNfeoKADg0iSc1tPbZjgulaxpH1tJq1wbYlUI6f5G6 EgA95yUPnxL326C7DbX3PpGery/i61809UEyaxvTB3HrbnDHcT7y8J2HG8/7AnAMXOXhWupiC7Pd JhiBxULqwotQnkz8c5nd50oZPwUAOA60MQnfOd+cgbZCiyZRGvcfAACA9sTO0Yv53TiUxhcPkJR/ Adg7f5yGYSgOW8DQgYGBC3RCLKgzA1yCQzByFBYk7sMFEBtbxdgDsFRtieuYOsZ/XkqCm/B9khU3 cvxeoyq20+f3Q9QCAAAA/gOxQHr3/GlV7nMdTaeXarU6/nHeCk1o8QlfzMLUrUiFqoUs1mq5DIlZ NMUuzHW7623/rqBGXyBu0b3Nv7U33nuKuEXX9sb7Wyllc+z3dBjiFvYYji3R/Zjn8q7DneBFs970 1cwB5ouFyO9tP76NZoNwsVaFNxkxi3HaGKLIwRht8B1k/W+sHS1kUZ+3EXnboxa0cMUsrFBFXU6c uhasWFkBDN2vd52qBS+OjPFtey1qcTGZqPe8sMW1MkHKrnjFtynvnCt00fg6kaJUc6DTba24RSgA sU0iVYIRAQAAAIaJncPpTWE3JR0BKMC5Mpup5yotKrHv5jBNbDOYb8c9z9oKAAAA4Hc8lHYAwOPF qefm+6nNvqmENaFkmdI+/P58X0M+s27ph7eqXJV2AgAGhRZOyiXLjI0dbcaNWBLmWJH2K01Gwbiz P6+lHQDoiT6CzYh96pZZVW5LOwEg5LEqn3U9tQaOraFTc5/UnCmUMDaXTNZPLBtKACaZi6lAPXSM 3QuAQ2Ja2gEAj48Wbf3nampdnBuH2trgmQ5dMyvtAMCB07egRS5JcGgtIVl3SNcgqeTDkjHnqSrP gnYAY+ZONUUtNk7dFarwP8eeDblrYnHP7rtX2465I4CMs9IOAPRA7J156L1FLh4hN3fNzStj/gAA AICc1P8S/udQXRLfx3/NcFB8CcDe2eM0DIMB1KlQj9AFKjqCGBAzZ+IEXKNHgBlOwsoKcxc2JlqS OG6+uP4c94emCe9JVv5jN4jEdpzvIbUAAACA/0gWmH/I03nsoPn82Uwms1IyIaUSRfDyer5elmIL X1Zh55el3EJKLQrRhRNf1BILK7eoxRlmHTD9r8UWMg/kFv3Lz+a5Otr1tPnZKXKL/UHE0P88h35N T0VuYQUUmbdeiiTc38B//DvBhRNYaPvI5TKEuvlYLILlk9IKe95Vc70rYJZtrmsWOM9qtPljlTyP wRAC+/cljz6U8RTy4Dd0f/6CkRNamOadfVXln1V10bWYwskqqmUntyhG4RYGiR+5vpJXlCMknASj uq+Oqu2Os3x5Oh6nSC0u8nRv7GBlKbTwJRZObpGJ7UsxjQ0srG7ga6GFEfusAvMmMA8AAAAAw+Kr 6wIAdEQhc/k04Q+vQm0juV6mUFvMrTPesaFz+Pn6nZO0wwAAAADSmOXptutCAAjeTB0Y00cLSubv 0xaoZpeA4VrSyqKVDw5HcX2LwONILQBgG17EfNsHpz5tASViASNCASa2kVn45SMIBcDwuTrAOVIG mmn7+H382r2GAG2HA+Ek9IVXU0vCtHZ5aCq3a/UpLeBrLJBsm+wiJhXT+gjc+8rUOlnsOgCcIpdd FwDAI/wx1yYp9922NnXqftr5AQ7JXdcFADhRvo0V6b0r22N18th7wlB/bKqUOLXNsa/Qou15JHnK 02Oepgn7AgyV6zzdmKbYQvtO1JdVaNt9uUXsGDle2v3fxsYz05cKsAmiNxgSWj011heROs4gVp+N 9W2HygYAAAC7kfJOOHV8X8pzmuc3dMavAOydP07DMBSH3dKhE2JjqhgYOAAX4ARM7KxcBM7Azi2Y 4SAgRtQbVCFO4jixnv8EtXGTfp9kxXZtPzdqncSx3w9RCwAAAJg7KYvnz8vwFGtos7lWu91ZL88I TdRiE0UjZGHFLEy6FqlQraiFFq+wYhZW3KIrfFHXs+0ZsYy+oMZUnJcPtVU0tnAEvx97457P2qZq bI5jK7dT/UMy998L4haHsKcae6OYOwpxi4URiSgWbdwiiVOoAWmbVxS1n/Kf7TbcQelkLIzwhhW+ MOIWbZ9NmUbQIvabmYNT/zHtTMHGHEQOxrAz9fbHsJGr/SpfC1k0abMirzpqQQsjbqGscIV+wqoE LZQVudD5OyOAodt16qlG8GJZG63KX65W6ma9ThG20E5VP1VfvKI15eR1hS56X8cTlOpf3JbKiltI CxB9CwylfBYjAgAAAEwX7TTxPncnADJwW4a3Ttq3KcscfeIWbjq0Scyt163r2/zl9g8AAAAAZHCa CcfGRyeesgHI5IWclKU6GI+VjTmVcTcEw36Rnj2/8nUHACbIexl+I2VSHEqYMpKDiO61RXJcJjmb CDmhGHINkuIAcJqMuHob9sRFGR5zdwIgAS1mYUTCQs/s0jEWpHsryTms60w2lHbr++6/fPdeSohL R+kcABwzd7k7AODwLeS5c63u+Boan0PlfGO8W5/xHMbgKncHAI4QLWjxovzvf6SxOjTOh+ZwQ3O5 ITGLUHyIqJ7bN9/3C61/fC7Dq+czgFPhQfVFLbr/HWkdsm8PaUjMIiZwYfIN7nttAACYP6lzxbH5 jSEhdX4bAAAA/k/sWhp7jzGkfKpNgIPzJwB7Z5DTMAxEUVMhToBYVIIlEjsuwB04AntugMQhkLpj C2vOwAHYsmUPZ6DFDjadTMd2AlVD0/ck08SZeEwEieOO5yNqAQAAALuGldX62pdp6aTZ7NFNp6eN yIQUlQhj+rbQhBSjWIpUSLEKud0u85ZtErII7Wkfzc/Yh+1KXt7X1yL6IhH8evxt9np++9ycsEXg 90n1+5/I38u6/bnobyPuBvE59ms6pLjF6rmrufCWYhc6p522z7eVRC3e3t+zfWqiR2LC9SRasTID qAUuoqCFFLaQdfr8sQgT4GP9bQzZ/lh8bPvvMET/cxlJF9E2CFKkz0YlYjKJgn2LnyjbJGzRROgm uyhW8ROJKwQvApN4PLHv948PDrqIWoR3vwtfnl1b0EKLWKQu7Ynjc/FpBRY6YR/4VPXyculARL0N AAAAAOOBpImwqxz6cubLq6grvSPJ+pqgha53qk77cGobAAAAAPpzOXQHAAQhUc1LBzsr6Zhe6CMX 7cq6rot+rQW/lh/dD21j7cP6CN8N3g7dCQDYCsIz5knsl+7VpQWltUQRteRlpYRmpYQTuf7xjAEA GAdXQ3cAoANhPHXfwS6XlKuWeEuPpWpJYrsKWnw6e6xm+bfmAPR8QCkZGGMz2BbOh+4AgMAStOiD dX/O3c9L87m5e3/NFuAvcD8GaBOeCXe+fGSOd/muTu7XRIlz87ml94quYhZ9RfWcsa2x4iQffLnx 5cSwB9gVQjzzkS8pQUAtTjlXknDF3KhbGPa6ffn/qWOcndpnHAkAMF5y88bW3EJtLsKay67Nb88z PgEAAKAfpedo32N9Ysp5fsO/4EsA9s4Yp2EYCsNuERILgo2pYmDgEEhwCQ7ByC0QB4C7MHMCJlYW NsQGCyrBTu3iOn6xU6q4Cd8nWbFc28+OKsdO7PcjagEAAABjRvLo6qfv63CVqmg2O1Hz+c5Kmi80 4cQnFqIXlRW0UDZUy6sRr/j6agpa+HmNuIUrb+p04harwhZNhuW8vKutytrCEfxm7I33fq5vK/ze 280mQgybtKesvV7MFbE59ntaRtxiUodQxCLtz65ZphaRsHUt4mp5dX17fX9vtGGRR3hIB2IVdd5A vGIpYjGd/l798j3/b4bu2H9INobQxm2wQR/K159rY2LHLJfT7cirRzUraGHivlKEE7UwO3F3PPGK uY67PE4UwwleKCt4MV0YrfMf7e6q0729HGGLMx0e1ap4xdJUkOYLXfjdiR1ODDcFu246cYvQaat/ bdzKSDqbEQEAAACGyUvpBgAU5FyHZxuPrXGkkMojCQ765cLylZcuHQIDAAAAgDhG0OK4dCMAPB5b fms71JPrsCzmuKYtLeVUpu0AMOuRfngq3QAAGAwPOnzaeM7YLT0/Ys+IHEGKro4m2uqItTUWB4Dx s86eox53ckMHrks3ACADI2jxZuO5zjhia2dpPiUJf6UcyUoCF1WQVqn0PCx33pXTf4Bt5VCHg9KN APB48+LS+Jpa9+aMz9K4vu6amrU4bIKL0g0A2CKMoMWNDh/C76n5eTiPb3t/mytokROX0nLfBce+ P0p9N4Tvgkz8TofbSDmA/8SlDvc2HttbHJ4dDQUr3HnTb9U8XxoTvpD2O/swRwQAGC9d3ie07UFQ wTUUpJDmu9K88jtSJtU+AAAAWI/U8zX27fwv9QH0yo8A7J1NTsMwEEZdKnXJAVoJsWKNxJ6zsOUM XKNHgB1XgUOwZMWOBWpK0titmU6mTlvy+540xA52x41KzbST+RC1AAAAgDGhFbN5zG1uTVouX9x8 fuMFK1wkKiGFJsp+KUax3lopahHEK3bt2H5+su3vwvwglCF9bH4aYUW/ipfX9bX2vigEfx5/w72e TYtbtCXE0Ky/4b5e2vI59GvanrhFmDeJfO8LV+wzUY5/c0SybDdvlW/SUy88oa5S8xGLW8i+bCvj u1Kwvg8+mvLTdUGLPlyDLvjgOZz++Jo6w/acF6ZwXvxnowyRt4NSRMi6DcIWmwxdP27qxSq2mbmR 4IXzj5N5AY3CT/Fh92I2SxG1WLidsEUsaCFFLMKSYg2OOPmwqvBqGF+wEufjy6UVVaWgKgAAAMDw oGgijJm7qC1jHxn3pApXWHbh9kNTp/SrYq9jCnsBAAAAjIGHthcAIIhFLQ4VbQl96wbeQwViqopa WoVkrIIyxB3N8+XKQkdXbS8EADrNtytFLaqwCk6k7jXx3mKZtT9lFf5S1woAEFMn8cwSmD7GL+9P 9UBwEvrAe25vvm3F61aRLBmHVx2risJKQQtL4GKtnNf8hbZz+//X1XleAH3itu0FAAg+jphjfVab +n4u42utb8XkAKdy3fYCADpEEW8UInrnELSwvguUMUeIG7T4QROxsMZYIn2Hvq9MiTu0HMkw9jm3 p9wulXkAY+E+t9fcPn0/vr+zyD9eOT0nWfbDUctxlnO0ogXx36/MZ9Zu0QUYOw1WnAFolNQcMis/ TRujzUnJNWDPAQAA+D+q9tnU/Zd9GjrJrwDsnT1OAzEQRh2iSBEVlHSkQpScgCPQcABqjsA5EA01 B0GCM9AiTkBFg6Kwk7XDxPFfIImTzXvSKF5je7wriNfGng9RCwAAAOgqsUVpnX/c2G2uodHo3IzH /bk8LTThxCda0QsnZGGsiWiFUeIVi4IWrdiFmYlduPrSphO3aP30kmIWPrsVvHxZXxPri0Dwq/HX 3efZdXGLOsIP3f19qeWz6890k+IWTrBCxCdk3NR5fjsuX9vvOOuu58/f6XH4uxmsRdRi2ra+SQmu bgO3e50LX1vhip7K77k8Ec2QYPDN50J7a6ALgf13yUdtEQJ8bKb9dfvY1v6778Zee2EOZE5j7I48 ey1prRShRS36SrxibEUxpuWdKIYtIz6kPZcvdU4GA3M2HJYIW1w29mrmxStmrrw8LXThbz7MbRJ2 t+lvapwEPhceZSCfzYgAAAAAu8dn7Q4AVOTQtIfAnlWeL/YXO7hlImVSlqqTmn8BAAAAQJyjxq5q dwJA8WHiAcxyAcVC84FcEJsSc+34QWZC7ft+U32D1SHP990gagEAaZ4a+7LpkoOkpYEh9BiRErDI BTbLBZ2I7VtIpQEAcvhCFsvW5TtnddzU7gBABhEIeywo57+rlM69Y0FmXToUKDYlbDEJ1An50Wm/ v7H7id0zwC5xUbsDAB5vS5RNzen9dVm/TslabshHahwA+A+ntTsAsCW8mHa+kVu3XXb9NvTenxMk LhGzSAlZpNZ+U4IWJWON/Cy2HiN7me8bu0vUB9gHrht7sOnS/ccxi50v9cUtQmdLNe5vlvVUAID9 JPe//Niauk7n3h9L3y8ZhwAAANbDX8ZYxmXYen4EYO9cchqGgTDspKhIrFElhJB6AxZcgKOw5zq9 AnuuwOM4XXXVFaWJ49Yx40cDiZPyfdLIz9Rjo8ZNSOYvczsAAAAAMBCFkH/e223ooNXqRS0Wyzpv RCw0u0NZ1+myFqPYHawSqnBNFrUwdhSyqEQt2mN8HcY5hbbf/TPkeFrwY7jJnfNa6vHOdz27j+V7 TrGv8box9Hh6zGEHzDNHvoPjGS/+XbSDrpusFoQqrDpfjDul5OdAWiPUe/Pl5VVd2my33YPJ24IW Vl3hlOukHObWzVgD45/jGIX7t+6BKaxDyudPfZ36nsPY/P8pH6RU2Yj2FE5aNm0zy0o3VUfxCiN4 MWvK0ucaLvb5u/k8xeUbpQOrzlRbX8OIWNj5wulTWGkoiKrprwJ9YnkAAAAAOA/eczsAkJGHJpX+ V+eWU14Ai/VVSr6u8rVxDQYAAAAQ5im3AwAOn5H2lGA2MfMFGg/1DwXLifkGf4/0IvdbJl8AYBqs 9/YRaJfO5yl7irRf+PYdX79Qm+ub5Cv7DwC4+O6Jp94r57768CwVgpMwfqoAsyGBMF/dKdfosWCy dp0UWDZ03E5IQ7/hVCB15wcwRe5zOwDgsBbqQvtN6FrZlH3mtkvHSHDOhz54zO0AwAh4VacJWsTO 6777rqliFl0ELaQ69xokJnBsz9E3J986mHIlarHxrCPAf6F6n3Sh5GeK7fdF7XdIfXaqCIZP1EJ6 rlnKAwDAuLn+5fGh37OpfULl2DMPMYE1DMMwDMO6WwpdjgHIyrcA7J27TsMwFIYdUIcIqSsrHbux 8xIMPAAjD8XIDi/CwMZLIIE6oqrETVwc9/iS3pxa3ycd4Tqxz0lF48Syz4+oBQAAAJRIyiL7aWNP sY5ms7laLi97dbbQhBGf0GIUbbkVpmhNC1aojZDF768kaGGf+99e92nELfrCFusI1C7vG+eVvHyo LxLBH9Zfud8n4haH9nfa/5XW52mvMYfPkn+D+/vz/Ra31460Cc6rzmcrbtFPzi4JW3Sftp4kqnWd Hpvrerqu+Vos0kLWDYWk8JVVX0nn60TtRtDC08chOJVwQAk+jJ+c7VP6L8XHsfsv4RrG3L9uf9Hc w6QVfUbQwlWHMOoRRk1iI3hhzrfELDZCGEpeKXg9mah5XaeEeqdkIQvTlS144R5PMVfgwpSlQWjI ZnEWIwIAAACMH3cC4ztLFADjQItaXHXl0EYsqewTrEjZDOb24/r3Jd3inQsAAACgz2PuAAAc7ITj sdUHu2wakupjm3ZVoA/pmBQnHJ+P3AEAwKh5s8q++/IqcE5sHHGTk4XMbZM6HsXGm1A9AEAM5s7z cp87AIAIn429B467zyi+ZByx55yhCWZ9SWR9ghah5zEpPuna3GsGOFducgcA4CCJWmhi7+rueBOa n5Xu6b6NbNKYEGsDsAu3uQMAyMxzY68qPt/pe+ewy7651qFiFkvBfIIXxlbOMekdJDQH7Ls25Sn7 xqafxl4UADx0f4esX5Ystq/U3frq69+GeVgAgPNlX1GLEClzG6Hn35S1bgAAAHBcVhFUyQZl8icA e+euEzsMBFAvD1FcSiQkEBJ/QEN74Q/4D6j4GKio+QZqoEfbcX/idjwqEuwkszhevwARb5ZzpNnY zmMm0SbxeL0za6UNAAAAABgAXybyUy3bsZ0uLq7V1taeN6lEv62tt8ko6pmYRBWyFJlPalHNyrK/ JMpwdTSfvX65VD73u5QcY4C4z4PrE8dliKDWrT7V6RtEXQF9y3s9v66L+86vb9jvSqtzuPOzdRqW 9bqO63tq34uTrj4/X+Tj2rX1VqevWxCeA2KOYb9/NzY2m+X/p6eklc2+bl1skoQW0mYnuVhZaQK3 v3WB939qWG4MSSCWRccYbFwEHZxD+eN/V8ekPUBTdp/UTbIe/UCddEtJbrGq+jNxJbFFM3u3284k sKiMn2Tam+dyPZvJV1nHlXfnmi7vrq+rx9fXlMk7Wv5que1U2hMHxTQpV6o/2bCylqlAq4Y3p91+ gbkvM7cMAAAAAONF+nNTLSclDQEozJGWm65s+0au+/jVP4blSq36egEAAAAgjgmUc1DaCACLBy0v gXWfCTQWKvsCiH9HXLtS9sHPMi1tAAAsLCYI831kfSgoWI74gqP5tvEFMLP39+0Xs0c5Zfc8AABC EDRtMTkvbQBABDNR88qqh/ocIT851O9JJf8KJazwtecmtPD14Xz9rdj5xK4BwJg4Lm0AgMW/xPrc 527Kh/Ztozz13Gd/ah+AHPZLGwBQCONnXGu5i2yT8wxPjde6/oD4DLXy+xkh3yLmc4R8j9BYsGt3 7FzdaxGbIyltl1rOFMDv5lDLHy3Pan7OsvkvaB0pu/dt7vxl0eHer0r1x2RD6+lPwm+HZG8wZkJ9 t5xt7bbQ2HrO+ENojCN2fAAAAACAKO8CsHcuOQ3DQBh2HyoVG9YsKhYs4BAsWCJOwY6bcB3W7DkI sEbiABUqeZU6kxk7aaPm0e+TRpnYju1GbVxbzvzTeBEAAACAQWFtovfT02jUz7GKVqtrt9ksSmm+ 0MRWfCIVo8j9XJgit1Sowv0LVqzXmqCFy6wseuGyOrfiFlVBDQ25VliPeL3tcsz2jq3MN+Z7mbc3 3vu5f1v87vT2xvtd6bLdsd/Xw9qzfotlUYpqni96Uc73hTDK1+bn8/lZdvZTQ9RCVFz1Zd+S8+ls Fi7TEn0PjD+mNobQxz60wWfoR/1tf9+zOt3uSTt1nipE+syTaW4napFZKnpRCF/4/lboQtYx8fzL xcLdLJd1un0nmveFLSZF2sTIr2OawIW2IdE/SrR0XiAHAAAAGBafXXcAoGMelDQ5N/LTpyK/qTln 163laWUBAAAAwLmnrjsAIHj3/KaBw/wNBqFAlTIIhRXcxrrGelF4v81G0CaszwCAxavnWwEltKAO WhktCJkWnMwSsQiNP7FxR+sTAJwGtw3KNlkLZ928H9wndtV1JwACvCX2Xfj7ztVjpgWEDZkVRFYL IFvnv5ef5pRj7PMCDA0CRULf+PJ86zmrrcXK+br05bXa0VrztcYCxgFoG8Tn4RRJBS1enC1oEXsu h+YToTnGr7OF8ZpY3XmL1bemY4+8N6G81D5cLhgCcMqcJ/ZY+Nq+Yrkn2drTrL0eG7tGy5OwLgtQ 5aLrDgAcSGy9ILQfoW49obWRUJk6/QMAAAAAqPAnAHtnjNMwDIVhq0gsrExFSJ24BQfgFpyAY3CC XoGZk7AzcgCYuiPipi845tl+Ka7Sut8nWXFi189YKGlc+/8xtQAAAIDWiQVpPE9dus19aL1+ccvl 3TY/FtuOjSb6c29k4Y0oJHmDCjn+GlbE6Tsys+hFy/u2xjGkH3n22/d6WuLlU2MhBF83XrvjiblF 7Xjt/q/MGbf1ca1hbiEmFaExhXYexhTGYu4powuf700tvjYbW9cUgfc/5T72YrFNkpfrtU0taojW E2NaG4fkVMbBEuPQ7bfwNxxz++EYa3fSYYWdmFzsjmJucRGkRXx0blQ2JBes4AvaFfz1m8uxSWGC ZZfu3di8QjO5kHJtwWFJRFXqu0ydUh4AAAAATpuPuTsAMDPXXVq59OYrbXNWaSOXxfgibsc5PYbW JwAAAADA1AKOCy9g82aolxIqK5VbBDRT4pbWOHEd7RwOhx/rlAASAJwv77uUwyqMVjoviaalBM0s zylNlMIqfAEA54N17rvGHDnz7PV4nLsDABm8mcVrptzyPUp7Py99N9LMK1ICsvG13Dv+f4Rk99tc BHCcrObuAEDEZ7nKQG7+Nc5Puc9b6vAcgNpgMgTniL/ne0OLlFF56rc4Ocb39pLh8BTDPEt+qplF 7r0o95zKYWnr2dAOQOs8dOnKldcha2uVw/2n2tpmba1zeE3Q1jlr5XEeAADaYp/5hNxnUmXMWwAA AABAVX4EYO/8cRqGoThsqXQoA7CyMVVi4QbsiIljcAlOwsxBECfgBoiNsTOKIMF1eXn1v1RN46Tf Jz3V2CTPSRGOXff3w9QCAAAApkTogxhZf1bHY+pEy+WNqapZq06aWTSi4o3xRGNAYcvWjMKGNalw 5hXf3z5DC/MXztTCHd+c05lb2LLZQeB7t32w4xIv75oLIfj95pvu/cTcYt/5pvu3ovMeNt+07+vu +Zrh/kd4QLT3b2ybVrQ17GxOaV7h2//RYJdSvlarQDcy94VIAXhnYiHP0YMIf9+i+ORoH1+6CUEJ OaZwn/q+hjHco9TxG8OJ9c9yF54zp2jVGese4dwkTur/kc7IYqbaNkYXxr/T73I+N9eLRc5l3Bq/ kYU7lTS80O05oQ0uXNknqpozr43VAQAAAECZvA7dAYACuFu/xgwmfO37Dp1XwjwLAAAA4J+HOs6H 7gSA4C3SliNUliMKowVtYmKbXYRmUv2FfpHvxfuQHQGAInkW5Rwxyph4sW+MyDG3yB1nQkJmqT4C wPESW/NmPXwcXBg7PwcoldizlK6Ptaeei6Twa65gbGW2BWNDYrKx/L5ryHluBBgziKhDaYSEzTWx MUfP3WU5tV6c+uIo4wD0xdXQHQA4MJ91PJm0oUXoWT21xhozzNNzCWmaVyVCz0F8hntd5h563ImN RV0/j3S//1HHS+A4gGPhtI77dTl3z7L+Gquu8xlg5JplaFi/BQCABtYcAAAAAKBYfgVg7+xxGoah OJ4CnZgqsaAegxmJlVuwcxAuUI7AIdiZESMzM0wVI4SklRPn9fnFFfnO7ydZ9cernx1FcWw5/iNq AQAAAFNGOwjnPguX1p82m6dktVrv4tWDtdOKsIVL78Uo0iKUIhVlOBS1+PXKqkIWmo88/3jq9koF /lXpc/sgbjFmf9O9nohbNO1vuvdKvz67dTjk+7QqVuHypL7EosjX95c4f/Y3fGm6F7362m5jGlZt 42GjynzZaBn/B10ciu/84GP8Igq+n7HXP4U+tF1/W/d76GTShfPr/Tpxi1Mv5OlczGInaJGUQhaF iIUnZlHs4PPqdZxl8fVyGdOVfI54nVTFKzSRC1d+zIbDRNgnhk1dHAAAAADGTewH1gBT5SrZfwTm sOZGTYpX6IuBh/MtOfdiLgYAAABz567vBgAInr24dSiZn445jCxGvMKy0erX2hbTZmgW7fq+dd4K ABgyL1n4rLGJPdjSGmOsw5ZD5XKMqhuvtIPOtDgAzIeYNW5rjVyzi7GBZkFwEobMaxbejXJrfhzz HhV6X5Lp0EGyoXTofcua82u/Vj8Bxs5N3w0AEHwoedY8WLO18kLPfssn4wF0ASJDMCfyZ/1DFr4D 5drz11q7lWurlhCeNbf4UWw1G2mn+a2bg/hlsl/a9bDGwdA459f9qNQLMDdus3CexAlQWGIW/vel JyKEhCwcof3TslzGAQBgeFz03YAArFkAAAAAQCv8CcDe2SQlDENxPAWHYenWhQtWjgdw54zewCt4 Bvcex7Vnce0FOIEbhkHSNpA+8onYkvL7zWQIaZr3KB/NC5n3R9QCAAAAxoLvDxi7/XZb3mIDLRb3 ar2edtpsoQkjPqHFLJr6pq43pRGpMOIVq5VL0ELVxYhamPP1mEbcoits0fUhH9//1ZGzjrZ3HIhb lGxvvNeT792p7Y33szKUzb6vaWPzPD+nTRLz0D6N/b6OwyTsVTvGvu+hzar1p3n8Xi5jDgnfur7u kslbwhWVOc86Vk0mf0o635f4QQnJ9/uwUbrIgbFR+usoXfSjhPcg18ed4ET7vLNDrxWnsNumbZuO yq4soYta/ELtRS52fcUY9g6/m9lM3c3nKW4+KreQhRnKFryQx1OKFLgwdZlQ1X48uJSJbQAAAABw niBqAZeOFrR4UP7YJlXgwhX+hfop1bXpWkgktgIAAADocr0tL0M7AWChE9n4ko6Hko/J47KPTGaT ktBSJnyR/V02pG0YDtZnAMDm06rnJqNMSTzmu6/ERC5C951Q8rYUv+G0cF+BkmAdvExeh3YAIMCH VffNQeTcJRZru+ZEscSzMdGwjaNdztNc8zCf/67XBzA2SKIO54ReF/454ryU9dnYb35sDNaA4b95 HtoBgJ7Q4sPvKl/QIie+8AlNSFEKl5iFLC4BjFDcEoo7cmMQX1tOX2PvSzXXHuCS0fuan9p6bO9y SMwitJc5ttfZJWRhYE0XAKAsckQtWDsAAAAAgOL5FYC9c9dpGIbCsFVQV7YOSEh5EXbEU/AyjN26 Id6BmY2XYGboY3Brmjh2To9PXJQ2F75PsuLWsX0KyLGN+/+YWgAAAMBc0VStN6760nWS9frZrVbF Pt8W0ZZGE9Xryozip0nBpCKkQ1OL76gsGFmUphayDx9HDCL7ffY1b4H9uYvrY27RH/ytTL/Pocwt zt2f3ad+dqMSXt+30CqLjSXa4uz6WRBvmuFjeN9u3Wc5Eagaa9o8DCuYVjT5xSK89v3X98TGFrEx hjtCPD7+7KeGPkL9sZsQjKGPOfycTv0ZpvB7zq1vqYY2Jhf11ZtblAYVl7sx8qLOx4YVjZlFZHDh y5qTfVG7nvL9m+UyJ+TrXbp1bfMKzeTCl8tDh9bhQifud8Y9XXkAAAAAmC5vQwcAMALu6qtc8ziR 19ZExyZfV67XZJsxrL8AAAAAKh6GDgBA8NpRniOemRIbk+I2lpCmdq/sXxMxg/HA/gwAeF5c2jDJ 0/XciMd8S6As17hCiqulxM5ShkoybpmH/vkYOgCAE9LXXjl77n+ncEFUD2BslOt0ay6lzUfkvKRr jmUZVViisV9KHW0OlZpbyXit+AHmSLFLV0MHARARP2+0sTd3P1bbH5Z1UmO+1W6K1Jod4BiKoQMA OAOlqcKTy/tfn7/mJG1/tWtNIc0o5Bojx8yiy1zP2mPu43lk7RNrz7/HjvYA/gP3Lv9csjyPrJlb aMlqwzn9bLN2thoAAOYDYzsAAAAATJ5fAdg7Y52GYSAMnwQdusMKS5eKhQfgDVj6CDwY78DMys7C xMhbVGoVlabRKY5rO5eQ4Db9PukUx6l9p6hKYse5H1ELAAAAmAKxiTq3/lmqF0pJFosHKYqrRp0r NKHiE2UO66q8O5Qrq0QqVLxiuw0JWsjBVNRC25d9qrhFU9giTv9k4v47Z2MrQ0xDgrjFOfub7vlE 3GJof9P9r+TyyTktieWl0+1OjtdzSKOuTlpfm/rU7XqzkW15A+/IUTJ4V/TCjVRj8MUtjD7OPbG/ 6+fUfUzhXCM2Yfdx7v3/xccg7aW++rpKECpooSIVvprEtXu8LEstcnH4jdfWX+F3O5vJcj63hPkk YSEL7coVvPCPW8xPqqrl2CLE4Kk01gEAAABAfvwZjJ8cQQCcGHd7Wzr7KcE/68dhoY++2vp0SY3D GG8BAADApfKSOwAAj0+nbElqM4alEs74fiVQjsUL/89X7gAAIDvrvb07+/41uS0ZZts9p0uStD7J zrrECgBgITUX3jZPzjz6eKxyBwAQoXyWenP2Y88nsQSqbePurolmuwhfhJ63LElkU89gAFPjMXcA AB7fPdrE5mklUE5d+61zwaG+AYbgPncAACPzKt0FLXSbul6HBIdTQhSFNMUqikRdSvCibcyRmu+1 jEH63mdifZX2IZWwCMAlcyO1sGxqHXNIwMKyhtlirm+f2JpnAAAAK9w7AAAAAGAUfgVg71xyE4aB MBwiod4BVV122wNUlXqIHqQXYcmyp+kFeoQeoGsWSH1ggomZju0hPJyE75MsTPyYCVRJXJn/x9QC AAAAxojmOv6YGzSfv1Wz2f2mvi+YLY0mmveNGcXvrrQmFW35b2rxE7S1RhZOE1vG8HmkOE5MvNvA MYvsj10MHnH9PsTqtm+Ev5VTx7vs+ZWIeS2fqUYruL6/l6PxhogZWWh6dnL8ZBu37bNcrdJJiniT uhY5Kv1DE4sOphZDMIGwxui7wL+f45yM6fsc+vznjDEEQ46jx4v6pApMLrbnv3OJ2BpYhKUO2jcl MLjwbbudgcG8npt1/XY6taQ6W5enat+8QjO58O3aJsTc5kLfv0r0ydUBAAAAYFj4fwp+Fs4DoC+4 H3/FDCSsBheWH4BpfVJxZC4AAAAA14oTLXsonQRAgBNSWUbaLKJhMQEzi6BmqsTmsOQB5XDfwUfp JACgOM7Qwt9bcoJpvp4qUphMHouNkUJnlnG5+06sDgBwKjC5uByvpRMAiBA+S8Wwro9jz0AWkwop HvutjEvNLdfpMufYOfCMBWMHUwvoG18H9E1ds7V1fljX1tuWGLnjAF15Lp0AwJlxhhbvVf66qr2m ruGxtYQ8Jk0rpHGFZmAR65MyzJB5ybxT5yo/CyuW+194bHHg/ABj5KXK71vO7V+ulXLovmer0QUA APSXu9IJAAAAAABcij8B2DuXnIZhIAw7hS7Khg2IJduy7AEQXASJ23AcJG4AB0DiCHAJFm0FcRIL 1xk/KKFOrO+TRnX8yLhRZcepMz+iFgAAADB1fH/E2Pmntd3FTrRcrtR2e7STZwtNGPEJLWbRpr+a dGutSIURr1ivJUEL1ZgRtTDt9TmNuMWusEU6hw6wb3weEsQtpuyv3OuJuMXQ/sr9reTyWfo1df2Z AOZtgHS75s8ejqqaecQt5KDtu3lVM28bNnoi7zfot5PSnVhFZQtXBEQtUgLKlyBOMBUfUxAhGIOP Eq5TCefPKWjRG22N4ER33OzO08IV3efMKnfVJI5tgYuujbGmjiVwYe/wm3X9v5jP1dVikdLtayUL WZjT2oIXbnmKuQIXJi1tOExZ74byAAAAAGBcPOfuAMBI0Ouuc+V/8cp9gcvO+4tJfpRT7taRjgEA AABK5z53BwAcXq20LximlOcGhEkNGC4FmfEFmpH8xILDwGGRghy9ZeoLAIwDHQzzMVAeC2ycMh+k BGFOmX8kf6G+MucAAJSDDih+mbsTAAKfqhW1MKQEW43dM4Xupdx7pVBQ2pR6vnW8b22f8v0ASuM2 dwcAHN4T6/nGbrcsZdxPefarnLoAQ7PK3QGAf0KvKR5qe1HxcfU3z2clYTufiIUkkLf11POJW4TW HDFhvdh3dK/HEEjPko091fYxkB+AqXJW243q7zeOiVuERCzcOvvucVYqvs8ZAADGw8kebULjOmM+ AAAAAIyWbwHYO4OkhkEoDDPpdN1dR93o1p0n6Ck8QLdepCfoFdx7Edfew0WXalOkIfQ9IFNLGvy+ GaY0EB4wFQKS9yNqAQAAALUh/TPmZR9uYjdtt69muXw4xPsOskOhCfvdilF8H0MnUtGFU1GLLy+t E7JonWOHNlw9hlK7g/3SNks6grf2yvYnzvWvwdY0/vb4rUzfZu19au2dPgJYR+zSGRIbd+nW37ku bOGX2c7ji8XyEP/c7ZJ1O4pWyIn9uC9i0TSJ+vRtTMEx/jXYcHbGvD+n/FpsXLr8GtpwzeX/VR9r J+pCEYsWpxIx+xWw8IMTrJh5eRo/uHJd3U2/D1pRjLv5PKfKt/uwMn3xCknkwqX7eXynq7HDhS6/ ieRJxQEAAABgmuS+aA1QOysvHnsxK7XOaoy8Nst5qcy3YwxrLgAAAADHeuwKAHi0jsffM/Jpzmy0 9NwQE7/IsRNe175DWRC1APjfvHlxbTzWxnb3mTNvpJwup0Quhjo9i7UBAOrncSS7mkg0e+3nsx67 AgAKraBF6gB96vlJuhZ7TtKC5lBWE6rMCVL9w3YB1M7T2BUACJCcbKf2X/1rsfE7Nv7HbDAnQAnu x64AwAVoBS02+/ChpA/dlx2y/6qtKUIxi3CtoQlhpPZ6pfWJ1A6prVJ/DCU2h0l2NmfYAqiFZyOf YU6dXY4JXWj35YhcsNcKAFAXJcdz5g4AAAAAKMKPAOydPU7DMBhAPwStVAmJARYm1JE7ILEycgRm zsBtOAUzO9dBalWVOq7bxHz+KVVSx7wnWXUd13+iCbHS7yG1AAAAgDETjzptud6k11RD8/m9rFbn nbK2aMLJJ4zMwubXTd4mK6lw8orlUhNaSJOc1MJ93rTp5BZdscVx1B5g3/U5TD/DBoK3fQ67ngTX L6GvcXz3+FsZf5+1r+lebuGLK0T8mHR+oHb7dt2pt6/SrTudXjav34tFdDydiHiusTNFntEKHN+u 54QYOzGGElx+DBKIkvo4pp8aJApD9FHDOvU9hzGsUd/zdzILcTIKI66Q36IL3yZx0RZcbD/jUlPH lW/Tro3tfG4nE7mfzXKG+SC6yMI9MNgWXvjHc5IfnNXlQwFc1aXMLAMAAACAskBqAWB5kvB9TUzy l/PjMO3HXqE2RNLjCNUBAAAAqJGXTbo69SAAWnxFjuUEFUsFhtEC38SCh2vloX608UIZILUA+L8Y WdJn5HjOtSSVQoGTU8GV/WBnudcv8fIAAH2BJHpYnk89AAAFE4D2o/U+J+CqVid1n50TjDZUzy87 5P84UV5jcwOoESO0YH8YSkITWuSQupfW9pa164GW19rUjgMcC5IhqA1zTn+T8DO02l5n6Jyr3Uvk ii00SUVIbBESWYTKY/vD2jz8OWrr0Rf+WN7l79ddgFq42aRHyZNNHCKxiB1PPdMc25NlfxYAoEzu lLKcc3buOR7pEQAAAAAUw48A7J1bTsMwEEVNaCXUBVRC4oOVwILYR9lA//hmIawHkJAq8cejeRgm 07HjQMBpco5k4RDb40Yljh1zL6YWAAAAMCWsBbqbfTqPVdpu7916fVnl2+Lb2miiPq7NKD6+kjeq kOnQ1OJdnPs2sihNLXQM348hQGB/yFh5zC3+Ox7i+rlj8bdnx5vudyVXzOld0/a7N21uUYuzW3s3 TpRxhaVvJ2o17SwWZ9Xx824X6E7aO0BtVnFgXqF/WvX/GGIMU38uMfgM42h/jN9332IhTXyMVJVx jVGFMKfwqWhMME5FmUKmJkYh4klKU4yL5TKly+Uc8sq1zSsskwt/XpYJCajqgcaXty6HS8wDAAAA wPHxkLsDACNh5ep5V6r5RN8U+wcwHcMZeQAAAIC5gmgmjI2YWKZFSBgmVTQztYzVfqwv+veQlxeH MA/AXLkT+ZBIWEi4Upexxo2YwHJMhLnP+JQCYw3AvOm7t2gIYbSucqy796MUr7VEjwByU87RXzvK pMzJQ/PvFNOKkIisfraKCdyGnq+s50HrGGDKIKAOY+NJ5FPWYGP37Fh9PX7F8inougA/gXsyTIny ncztPj0GzsfWZrve4XWZS4TmEW9GCplZ6HJW+13ru/Kc9bms6/Fb9PUMjZk+vxkoLsAxcy3y1n7j IpDXe5dje5hTzC2sPc4AAHAcrBLK5LqvM54AAAAAwKB8CsDe2es0DANx3LR06ISYWLt0qJB4AyTe gIEXYOS9eB8EGyM7TEiIoaogbuLWPc6Om+ar4feTTnHixHdxP5JYzv0RtQAAAIBjJTRQ5m8/z+yh rKH5/MqsVuOdbb7QhBOfsGIWeflnXc4tF6lwQhbLpSZoYTb7WHPH2zaduMWusEX9kGC/Tl9DSwSv +2zX33D7lN9e3f6G+13pyucQ+3QrYHHiiVv4Sdq1d+7+zuvw95f53UejPCH627uYR5eaTN4XrnC+ PJPrMoA6ktaXh4gPv40mOZZ+SPHRdPtDOIc+t990H/tt78yqK0QobP1aLaIQqNBm8dn6U1/gojjG mRO0sMeOvbITu7BcTCZmMZ2mhHxttgIWvpDFxoXXvKxPMf/io4lbGGUp0bYzqQQAAACg37x0HQBA j7gT6ykCFLGXw2Ivesl9Zbt+DDImAAAAgP/CLLPbroMA8LAJbj4CdVoSlljyslDymJQkM2WJZ8qS z1SbBARNYj+P566DAIDWeS0shkyeVuW6IBMxh5Krha5JIdPiMaJsRBkAYB8YD+8P910HAKDwbeLC kyn3ILF7LPl8HhMIiwmHhcqh+ygZe5XzAhgSN10HACCoIkwb+t/X6kxgGRvf1do1yjrAIcwyO+s6 CICaeDK5oMVXoD52X54yFqs9R6yUpRS00PYNiV6kChinjO+Gzlmee5OE+vcxs88W/AP0mUVml2Y/ 0YnYHObQO6UxcQtjwvOay+Y8AwBA96SIWsQ4JG8A1wUAAAAAaJVfAdg7l5yGYSAMm4peoAIJgYRY cwjEEVhwCY6D1CuwZs+aO3AA1t2y45EHid3J2HEgqVP3+ySLSWJnRlZR6tb9f0wtAAAAIBe0L18e inYaGrReP5nV6qKKXaHtrtFEfVybUXy3zZpU2NY1tfhyrlkji9LUQuZo6pgKBPbHzJWfEHzKfHXO fOeU/72x8+X7WkmVM7c5bYTZa/3yo8rYosxnDS/annJk59g1ybD3P67+vm82btJgPaHr7fimjyMs LwXmpxbFJ8f2+LmbEMwhRw7ztAszh7nP0U7muInrE22s7bprXSJ+DSzc1hhXtGYW5fnFom6ijzHW zKKhNMU4Xy5jyj4r2o3ZNq9w/TXcWNuAGBJTNaK/Nh0mMgYAAACA/QLBRADLSdGuxTntA7vQj79C a6++NZkvR6gWAAAAgJy5S10AgODFiYeIusQKgfvEb2IMLoznvn21QRo0QTqMRwEOj2cnjhGe9PWR zxCfQVLIxOIvz5xUAmcAALB7WJ/DHCkNLT56+vStv/uEXmMMLULvxXyCsm6s1WqU60Y5BjgEblMX ACB4G9A35vNi35hQn1AO+TwBGIur1AUAjMRr0R7NcEOLmLVDnzGeNLaQxhWfpmtcEWtksU+GFtrc +q6VrCeoAWDfuHdiba+x3LcsjSo0AwttH/R/9j0DAMB8uZzw3kN/38KzAwAAAAAm5UcA9s5fp2EY iMNWiyqVCYmRAXWsWJiZeAdegpH34SVYeQiYGVnYUAfWqipJHbeOOf9JaeMk/T7pFNdOfReripPU uR+iFgAAANBHfA/N7PrLwh5jHc1mc7VajWt1Jql3udHiFVrMQgtRrDdlbVqkwohXLJeSoIXamBG1 MN/XghZrQTyjHUiwf0hfw0oEn9uf9tmuQ8QtDgdCDP332ecxlcQndqIUulyKW9htvnUdodzuZX+m n6/Fwh+L1Impt8QramV3n9Fol/i9KA9BAKEvPvouomD76Xv/QziGY/ff5d97KL7a2bcSoSj3NWIW o0oIw13JV7afWeIV4+q7UkZT07btp4rlajJR8+k05RDulCxksXVhde+2p5grcPFnaIStNJQpdQAA AACQB/fl5898oQB0kgflF/hr8iJX7fYv0keqyIUS2gAAAACGzFPuAAAc3hL28SXMlOr2sVDCcde/ 8rRJ8UJ+ELUAOC3eC/uI7JMyf8SSk0mJlWNJz1LFLaR5SAXKAAA+UpKgIfqcj9vCrnMHASDwapXd a47Y9Yjvfj10bRQTBoslsU19RhCKGeDUuFDMQdA9voW60Hk7NEeZz7E5ocl8EaoH+A/3uQMAOAAv hT2r+Pmz6X99klh9zFyhCp/ghU8YI3YPEnp27DtW33i0hW+MS1GLn5ZjAega88JuVLO1y6E1z5Lo xT7rmu0ya5wBALrLeQs+pHnA998e8wQAAAAAHI1fAdg7g5yGYSCKuhW9QiUQQl1zByQOwQHYc50u 2XbNHRAH4BBcoBt2EBJcF3c6juOSxnH7njSqEyeeSWjrZkjmI2oBAAAAp4CWbHuq7bJtp+VyZebz xW/bL6r9JzJRbZZtgW8rRlFtzQlV+LYvavHt9dn9rTiGE7Zwfqut7yGhwH6fvsotBD9Of8OeT+tz yPfLwXsaPnuav9P+/OXwWeo53S2cPlHWy7p4cp3bNlY33KZTPgKiFp7jfdEKv8/587aZePu5uIcQ tBhKPKAEH6WLHDgfpR9H6aIfJfwNjh2jNvbON677jlOsYasSsRGu8G0q2heBbVzyeypiadZfz2Zd DuOqtjuzK16hiVy4fnlzYdtNhkZsr50O07ENAAAAAGXxmjsAgBHRPPx16y3Lax7tOqjLQ2Gh67HQ OMbo11mxZQAAAIBTgaKZMDbeavsM9MUKk7l1KUXJtGIzWvGZ2NihOGB8vOcOAAAGZeW1u8wjEm0e kMXTYoXVusw9FM0EgLFDjvz4POYOAECh7RrdUYn2Iab9bkoRCgv91kopLgtwztznDgBAQRO1aJDz juyTedlQ7lZ79ccI+dPyvuSCoU8WuQMA+CfPtb2YeG5Te237f1yqoIUvZvGlWEjwwlkl+qTfWJ63 7Vj9c3Hs+SNljlsbK2wBcO48eG1NUELeozxtsZCYRVeBi5DQBcC5sc4dAEBHbnoaJ+U5lhSxI+YS AAAAAOiNHwHYO3ukhmEgjC6EFFDRUadMxw3gCByDkptxB7gAdLQUlKkpMgngsZXIm9WPSSaynfdm NFEkx7sREzsSyvdhagEAAABDI6UyXXH9Vx5TJ5rN5rJaTVptWyMLaYwnnImFeEYWsjGpcEYWy6Vl aCGbY6pSv96ZWfw0RYqIo2swtzhkrGEKwfc3Xhlzi2PF2c/c4tgxhxBv3J+/EjGHOaa27nfb2KL9 f7la2N0yxdgWv2+9rutfi4UR3viq4ptWaJMLz9TCiby3xN4nk94L448lxhBMCPoQYwzjVMLMoW8x +vI3bO2qa0woqtc6M4vz5pq44ybRGFdcuGPF3ul31hzb2v3X5HYzncr88jInTWdqoY0sNiG801vp pIo2uNgZGuPRGsqcNgAAAADoB++lEwDoGXcS/tGVq+v5U465hZ57pQwuJNIGAAAAMHaeSicAoHj1 6jHBMd1mCcWkBGVCIji5ops6H8TLhsGnIHoAcCpUIswhEUxHrlBa7HlMZDnUb92Dcu89EqkDAPjk 7CvaZz2ctfTD8lA6AQCDZ69uCbCG+vy21Dxc93Uxs0h9n9J5WLmF3hPAKXFfOgEAxUeiP/d6HboX 6T5Rffq5te4bW6fukiOA5rZ0AgD/5FtqQ4sXCV8Dc67B1vwhtA7r2izzirXqS9VX6tyrSEw9B9F5 x96rHotShMYbUwsAkbnUJlO5hhOxovcx5+5r1lj7nK0+gLHyVjoBgA5cNY9df5OSqykAAAAAANAL fgVg74xyEwiBMIymHqEmTZo0PUFv0PS5Z/EcPYFX8Hh987lWXHEHMsNS7bKi35eQZYVlWGrBXWB+ RC0AAACgdbTJltU+POYuWq83brl8PcSlA+1eZGIXnUtBCx/3ohX9Z7uTuEUcfkRad50vtxPIkHZ7 W1ODuMV/2mrREfw127vd9qz9fxds1oTvS/s222nTnA86zZH9LLEXz+/FPtlnIn93/N5udRGL4uom YheirENd5/NI9OIiW6r58cUJgp1rt9G6iEJNG2OXfwv3MHb5l9ioIegxVH7U0wpRH20FXlCJCCIW ByGLfd8YiVkcxS8eRJ4Q5kdBC+d6MYuAz/+8WJTc1tM+vLtYvOKkr5HEtcWF1iJD2RQhv9YcrjAO AAAAAO3AgnqAGC8mGOb1rMfDkKY9Y5Vu9tLyWjYlbP4CAACAewCnmXBNeMfjQw7LPJaTGyvdCkMO xNMyhuykn1vnMC3+74HwKMDt452obcR5rm+2HFGGozZ25JwpDzlgLhmDrPoxpgBADXCYUx/vuPZl 6koAJPjn81KBsBDP/a75q0BY6W+pIYFKpxzTuHYOcE98TF0BgAQ5/lj9szUGuUw8vdYaH3JjCOMF jM3b1BUAOAP/LvbLdYIWGkP9qvYOtuS9qxSj0EQqSsM54nrWM4h1j2l71EQb56x8XhR+Y6QD3BOf Ip7u5/Roe0flvtPS9c1pHmv9M+9pAQDaoXSup2QuLk3LXcNYAQAAAABV+RWAvTNIShiGwnAYhwVu dKUrF+xk594ZT+EBvIG38E669iJ6CDcI2NLGpuG9JGWAtOX7Zt40JO3Lo0DTlvT9iFoAAADAkNBu nrn1d4W9xhzN5wuzWrVPhVwhi0p4YlNb+3UpWFEKVSyX68I2W9sVtDBbs6IWlQCGFbPY1GayJEJP AXGLQ/Y1lETwQ+lvvPtz7L872+dp+xvv9yVXn0PZp01CdWmeSLOs1pNz0jVtrt9quV439b/lAJ8U S+MkmPTdilm4HXqCF4fgVEITfU/wb30ckyGIevShjyF8V3L6t33k3P5Y/ltH4lqEYmJFK2phirLt X6jCNGIWF1bMwrRn/Pmz/ux2E2fbktvp1Cxms5QwHx3XfncT0xa8kMKJmS9wsbNrhKW0K1PqAAAA ACA/JEwE2OVZqJNE/fwHuTRBwdiDX/qNQflaDAAAAGDMvBR2lTsIAIfPQFtKgu9YAkspeaZf1tYJ +dLihX7hfl7cowEYP++F/dTlrgkwU8eELsmUNT92u1AMUqxSGQDOk/vcAcBBQHAS+shHoC12PhK7 Fu8qaCGdc0nnX6nilaH3A3BuXBsSqEP/+O6wrn8MD10/S+OBP2ZJvrQxZL8HOwF0HnIHALAHpRBR KWjxpbRr/+fZpX9s1u6fppovbhErdxWzSP3fMDR29AUt7rdsEQH0h6fCbow851h6/lObx6yJWWjz mn2/Ltq8Z78MAAB5uVTqU/IAhNbpIn4BAAAAAHB0/gRg7/xuGoaBOOxK7QqVkBDqIkgMwTps0RU6 RJ95RmIEGIGnvlFwU9eOc/Yl9E8c832SFSd2c9e0NLE53w9RCwAAAJgy0j9Z1qYJpEuyXm/Mcrk6 1MNk2V5kYt/abwQpvChFI1JhDvu2bkUsusIW3ydBCytuYc9hz+sEMrxdb6tEak+yj7jFlO3Vez35 u7uGzXq/L2PZLPmaOjGKboJ5H6sRtjV6Ed1YD2+vm6g+9OVrt5OcaG9T7XFfJ2jR8m/m2y6UkL4G AYRL2JiCCEEJNmq4TjWcvzZBi1b0hPu9E4rFTmDPj6IUTtiiI2ZxFL+YB+0nEYzja43xYhYO2/9+ sejj8p1pAhFD8QpJ5MK1a8lVpUBD11+6HKZnHQAAAACmwfvYDgAUyKORF3/lxlDaAi9JUDC38Etb 7MXiLwAAAKgVkmZCabwGdS1SQEsYoyXASSXW7FtyvsRtMC7SZ8AcDUDd2KCubaY9leAyPpa6z0iJ lYcmQMvde4b4CuOBQBKUxK3mrZkrvx6Mz6E0bGLat2BfG+9qY+hzx+Gp56ncmF16vtpH29R7A/hP PI3tAIDA58D+2tg+dazv/G8fewCXYDW2AwADsSJEL0YXtIif08NjuTGCJCiRErJwJd6XSixuER8f Mo+bGndoc723po8vzueP37K5tkMAE+A5qGvxzVqJY5rjeOewnrMX+gMAAGXy8IfXDPldn0VbqT1u k/pyLwEAAACAs/gRgL3zx2kYhuKwq9IhAyOwdunAApwAMcPAwJ3gONwBcQhmToCEYKkK5C91nGc7 SZvaib5PeqpjN/aLpbrOU/J+iFoAAADAWHAF0iruUrv1dbRaXajNZl6r04UsCuGJ39Lqx5lgRSZU sV7/NMQssnJxrHKrRC0KUYxtP0UicBUk6XlfSLK/z7HiTQQ/zvGmO5/87oYY87ADIm4xxHhdrm+7 RagnhJef35CELWz9ZtecJMf50ackaiGeJvSnCVfMNEGL3PSy7fyOHEqcYAxCDlOYh6mITUzhGmLu f+g53lf/tVW5FKGYlaIV83Q9rMZpPLknCVwoWU1iXvWrnZv1ebZYqPMkaeNmlmD1SDWFLP6H0LqX 3PGZmZy1MTXCpzSV9YoCFcoAAAAAIEd6QfolhCMAkfOglV2iE64XvlyCFy4BDFfwkJsbAAAAmDLL 1O5DOwGg8aaKpJkSUiIYs92WQMZMgNk2YWYXk3yBuCEROcC0eU7tuyzb1mRbkjFfMjUpkZr0HZ+g hS9hm/m/ZvMbwvER2gGAHdln/JtY+m4sU7sM7QSAwaujzbcHMe/N9XLbfVOf/ZQ0ruQzeyiAOjeh HQAQeBfqzPXdFYd1xWx9993mObbv8H8CQ3AV2gGADmRr9VNqX5Z2V2yzTQzWJl4hiVlIx5J4hU0A wyaY4bv/0NvM67LNRwy4YuNV3eOhnQKIkOvUTpX8bLEkSuF7d7TNs8wuIQsl1CF0AQAQHyeOtr5r dRcBi67tAAAAAAC9+BOAvXM3aiAGwrCwceCEwENA4E5IXAKB26EEl0AXJMQ0QgNEDsh4yD5ZOp1W Kz+4l79vRoPkW90KDZwePu2PqAUAAAAMldSXK49apc3mxSwWy10+DIztRSZ+auW9IIUXpXBCFbbs 8k7UwotbWMGL7+qaF7Kw9etiFt7XUCDI/iV99TkQ/BD9jbc/+b+7tL92/1b2Plt1d/A55n6Vf7+m KEVarCIvcGHzvt5N5cuX7Zg+n9/tLD+32+J2H4J7B2IWxgX9DgUsIvud2IWrd2KA8CEITZT6OMfP GEQU2vAxhn4aipiD5qPL+v99/1pkUPe8C5IVnZhUn0+NV4mYVkIWDTGLyv42uO7SpBK0MJVdiLVf zmYlTX4w+xcRQ/EKl6aJfGijvWBoIvu4O5oDnJwHAAAAgH7jdjQImgjQJDz8ZUx9nXPM4S3NrmR9 ZoQ8h78AAABgbDx13QCAiDBg5jHBXlLBzMLPS4LiSLa5QDQExBw27M8AjBcrkPSWuS6NGe6nNo7k xhJtXJFEMFJtS7WV8QYAuqJkTzwVYO2U+1wjq64bAJDgPcjn1ujaelqaA8VzplMEwlJzL00oLDff ArhW2CeGvvFlvFDlMcTPfaOUpT0BrY7mA+AcVl03AKAQ+53es7mcoEVqTi8JTcSiFCkxizilBDBy ghna+kIbT6T+6BtSW236+EuvrbYGoJ+so3IuSIH2XnNO7CLOS/eP2wIAAP3jvsBGe4anzrdIZ16k ++ZsGFMAAAAA4Gx+BWDvbJIShsEwnOLADOMBXMoSl17AS3gAr+BlXHkJL6LjeAOv4IYFg0ospWn4 8tNCSVqfZ6aTNDT9vnagJSW8L6YWAAAAMARiHqRpl9qH0I6Wy1u12TS/AplGFlqkWptQlEtzXRtW mCYW6/WhoUVtelGtf+8NMSpzi6axxTBBZP+UsXIRgh9LvPGeTz53p4433vdKyrhpz6tP666slyL0 ynrdXj/8Ta8Wbq+3n80u/8qv1apr+vW+TbMKc91oP9bIoW+GEGMIOeYQg2PIY/85v9/7MvRozK6b TMpZeJVpRVHs4x7M3JMMLpTsJnFR9d+VxS7G1XSqbubzmDS1keLeX0MIVRleFMLrMYttcGGfGiWU 0qmMaQMAAACAtLynTgAgU+53pc9sIvRHL6m9zR/HQkYXAAAAAGPiMXUCAAb6x/fXiO18AmMxQpoh kRyfGLkvDyVs42qDfPhInQAA9MKLUXddh11ialUZElSTxNSkNte9pa34cugYAAB8dH3G3WZ+EhwH YuKQG2+qNArrgmu8HDMODwnIxojLSrnYdV8bwH9jsV2uUycBYPFp1H1i275t7HZXn1M+240ZywOE WKROACACbWjxrMLXX9d1NzQ++FFxz1slM4qNo81nZuGL68tXOtbcxx2u+6fr2J7OlBdAztxtFy0o 4DKqcNV9BhZt5i3bwuOSwUWMgDkAAJyPZcd+LsGcmD6u/gAAAAAAvfErAHvnj9s2DMXh59q5QV0E mXKCogfo0DlLztH7eMzaqblDgHYvkKk5Q9YA3WKHzzQhmiafJUGRaPf7AEKKKPI9OTb/SNT7LaZ2 AAAAAKAHuRtq3136ZBVarX7Icnm9FZiIg2A3IhObvb9VhMILVHhRikawQvaEK+IUhC5CfhDE0DL7 YhaNrVMm+N89pm248G4F+9vrx5j2wvdvjEDS3p7s7I1ibgJ75/t58rsb2t75flemtDvV5xrwdstr OJp8OTjv0OdcHTOZz33w85eeohYasF1cil2fRUHbg6DF9jyf2d3GGYgTDGXj1EUOzsUG1/D+9dfu 30F94kco263W7Rp0FZxYR/nB4lyalbHz3Tma9Ab32pXT1cVBrGIhhVXF7ry1tq1uO9vZU1QQ4+ri Qv4eb9MvxS9EfNhVGS8qDC7G+/EixHW0tTqqIGbxKmnn09QZ70tmHwAAAADq53FqBwAqRedc9y49 R8dycyIr5eZeH2T/pUur/CbaSmZfCnkAAFUx1jOa/5guHzB9BdTKFyFYGdSFClr8K+RZQSnjY6WA K1ZwHCu/TR0lP6B+9P+kwqOfp3YEAAblyaXfRn7XQGrHgqvl+pVjQha5spY/kuyn1wEAUBvx/XZo x+3UDgAk/DHyuoynFGvclI6tLNEwaz7fViCM8RTAId+mdgAgw1OPMqU5dG4+nZuHx3nH7hGndgGG hGd3UDt34u+/lto/axze9pldGxHhVKSiJGaRnrOJtpagRepX6n/uWk+1j1A/0zUwwfdf4kVMvo7q EUB93Lj0U8rvd+bWK5fWN1ttofXOaendUe7DAgDUyUcpC0dbbXdpbXKuT8gds6DPAAAAAIBBeROA vbPJaRgGwqibUgmJNQsOULHjDN2yY8Ed2HIJzsMVuBIbWFHAJGknzvgnURK35j3JiusYz8RqMZ6a +ap4FwAAAICsxIJtFhvIe4oNtN3emf1+3WmTQhZWuKIVoajrx9etUIUrXuGWvvCFHGf/d5WCGqUw /pm0c1xz2hvHkvbse/J7wYcreS5re+XOJ5+7qe2V+17JaTf3vHYTNnW/k6vFI47tsuux7opcrESf Wif0/cOXU6PLQajCeP64cZJLdfpXw8M3JYgHTGHjIBIyI+cwDynjn/s8zf0M5zBHp+5fyvhWlOJw cqIRqLDtdhdXCeEfqSRRNfes0MVF29cpdrx1M75sa692zJvNxtxeXqa4ag/itmZcc6umbSXqPXcj RRO40A4iymtvOhPbAAAAACAfiFoA+Hk06eIVVeRe6H6KDW0vBgAA/4vQ2rDkGABz8JzbAQAHmYBc O2jgawslFwuJVviS46QUnx9w2miJ7IjRAJTHq6j7kohpCdW0Ptraoa0fWvLl0M+MWWcAAKZgTDxi yPkkGMdDbgcAHD7NsD16bL8uX4f24rF9ekggzBcX0PaBANBll9sBAAVf0kcN375eq2v3tFhBzEas HWAsu9wOAERoBS18hOKvoXhoSszVJ2jxZeKCFlofV/BCi++WKmgRWyvdtpclnAI4ce5/y5VJO9fs O8uccm6592+vwgc3cbnvvlsHKIW33A4ADOR6QN/Qd3FT/a5nbQAAAACAyfkRgL0zxmkYhsKwq6IO bF0QEhKIjVMgZs7CPbhAr8BF2JlYegEmpB6BUpNYcV+eXxyUtk76fZJVN3bynKjgxLH/H1MLAAAA GBvaANvLLl1ZO61Wb265vPnLx4LXIR+bW1QGF9s9U4q2WYVuahEbW1QGFpVBRhPHp59a5HvgK1MA iOwPGWvaAvvnJqxfZiz+7vR40/2tyLjHjXec61oJrs/q84vNKuRcjf19wn7hs/1Orm1usd1W3782 m3RbpAC8jxUMKkKZVk8eI04ZTMFkYYgYYzdRiOOM/fhTOIdDH7/k3/vBDUNCjCpYs00kz9xFbhK1 kUXLzKI2r7iIyufBIKOuE+LNoni+/u1ikdPk6116dI15RTyxcK7kpdCqNQHRifra5XCZeQAAAAAo Gz968X7qRgAUin/muqvzqUVY2kKu1MIv+UyWszAsjq3lWfwFADBtUi+MxhoHIAWimVASXqRsnVFP E6PsK4zTJYBpiWLGcVLCLlp7oVwwtQCYFmvX3Z9oYmNd/UTKzEKrYwmg9e1/LHExAIBDkDNGPlQc aHg6dQMABB9GWZ9ncKtMu/fKuYdK3U85175/0tpsbQM4VxgnhhL5zqynjd1qZf9N1rHpS+AQ3J+6 AQAJvPHdq2sMLbr+72rbct7ZyWcCaWQRm1NIgwotb5lXyOeNlKme1Tek+oox9hHaOYTk5zp/Hr1F AGVxuUvPdT5nXnNqrrK1xtSa2yzLJIy3AgCUx0NGHUsfwHpPp73LyymztgMAAAAA9OZXAPbOJqdh GAijLqiLigUbJJasumADHIALcApYchJuwBE4CIJTcIEeoqJqQ2vFmY7Hrtr8OLwnjZy4wTNuaZy4 znyIWgAAAMCQyZkgu9rYa6qh+fzOrVbnjbpQyKISnqhEKLbW3PdCFV60Yrm0xSxq4Yu6HS9i0RTU 6DZxepeQZP+UvsadYB/BgiH44nun+xvv/0q/Ptt3WAtTuD/hicqkIEVdyt/kmqWWw71uazul8rNY 5ARl7/t2FfGKPREM00034gEl+Chd5MD7KL0fpYt+lPAZtC440cP3vbG6zotReNGK3fGTXX3DFIGL hqhFUMrVfz6W6+nU3c5mOaE/ukBfw+0nTvWCFxPl9RyTAhd7b41SSligCAAAADAstEQanz3FAlAC z06//9HujawHv85EXc5DYzELYwEAgPFxqMBE7vhxaHsAXfGyscu+gwAI+DZey0nqnZuE7JgE49KP FS+UA6IWAOPiI9jOSSRmHRNLqqaNK7HEZ7ljTSw+qx4AoE2OmaOw1jIx96FDMnEYGl/Bduoa6tDr KXkNpV1HxQTEcu/9tXt3K2aA/8yDY54YhokmWGmd22Vdav5WHpczZjB+QBfc9x0AgEIlaPHm6nNz 7vkw5ze8lKDFryiluEVMzEITwEiZFkOsD7J/Wr+HjjXeaX16bz0igOHztLELl14nlhKzCI/R1jpr 7Xis9dTO2AYAgO65EfvWOVti5QeIPWOj/V1sHTNjBAAAAACchLUA7J1NTsMwEEZHrbphV7FBAiGW wIoTcABO0TVn4Bi9AeJU7Fiz4ASFuG1aZzKxHTc0P3pPsurGTsZKGzuZ2PMhagEAAABjwnLOvRbp MrTTev0hy+X1Nl8VlSjTb+W7E6HwRSnqYhW2qIUvbFEKWbj9q2IWR1sliFuYe0rOe/spB9mfeoB9 BAuGYIvrzrY33f9KXzbPc06r7+B25vRtRNP6uFCs8GPeiWU4PmOiFmXAdvdpFu/K/Ppa2EK8IO7N Zv7/3eEYbIxBhGAINqZwnsYu5tCFjSn8hrVtu4JD3ppdNxcxRSt8MYutgMVsZqpJHGb07ftlvx3u GDeLRUrzr4r0LEfxCt/E3MjryYehoKmi6lunQxLzAAAAADBsCJoI0MxDkR6lXcDw0AIxvRgsRcxC YzkYrTIAABgXKf600DiRMo7Expi27QHoglXfDQBQxAJmiioPBZJJCZJzSgq1RZfB8Pkp0lffjQCA TnACSbHruW0gtaby1MBnIUGMNmNOUx4AoOS+g2Ok+COa6uDLyOdO6oGNAPrkW+xA4jG6eN6OCVE2 3U+JcO8EkMuq7wYAGOT66vSYkPqsreuLUc86plUOcCpPfTcAQOH65Ddp53fVnyl+WO1P1QIVm8z8 JmG79eyR0veL1Pv/sY8H1vhWpnfhfRrARZFe9nm9jrPL+csp85tjc5wBAKB/bjP3y12zwtoWAAAA ADg7fwKwdzY5DcNAGHWLKvUASGzZVOy4AAvYsmPBOTgGHIczcAHEEdiXGxRV1EQhk9H4J6WJk+g9 yUoaJ/akFDux7O/D1AIAAADGSs6Edz+A95QqaLO5dvv9WeuYNLLwxhPehKJK7c+1UUVtWrHbxc0s GuOLppxKvNslRcPnamzhQWT/lHXNW2B/nuL6sr4hfyv83522vvn+VkrV2d932szJaOul18e0EL6l EV6LnNta4T6rNrX43G7dt+/4W1UtmpK0aLs0rNAGFtK8wqflstmqspuP/ZsT1PWMvY6pmygMWUff 5c/hHvou/z91DGHoMfR3HFN48+1ebULx6xAh2ko5k+/PzEIYXEjTC5+WYms6TByOX6xW7mq9zrmN Gyf8NVQoC9c2tLD8NVJJdkKWuYUzthomKAIAAACMm7fSAQCMnEexbw3o6YVbQV9DlR9bMJZaHKZj kfC+BQAwPVILvKwFYakFwjnn5l4P0BeXh3RbOggAgRfL/ArkpcTBYsIyIRHMlBhml2TFAtPC/80+ SgcBACfhVex3FRPrIqwW6meONbPQ8YX2AQD6gjGIsjyUDgBA8R7JiwmcOrVNPVtZz1Gx87q+q/N8 BZDHXekAAAzkWLHVbutx2FjbHrs+NNar+7NcQv0QQBcwtYAx4dvjF5fXLoe2VhsbGneVhhYpUwpp eKHTPpAXegeJvW/IPH1PXcegx0isP7Xu57nHWACmwr3LM5xIzVdOrSnNmcMcm5cGAADlOXeVIZIn Z66wNcdYnxO7Rl+X2x/QbwAAAADA0fwIwN7Z5DQMA2HU/Khb6BIWwJYVNwCOwqF6A8Ql2MIFuAIn YMWGRUnUmDjT8cREbVxb70lWndTOTKrUTqLxfIhaAAAAQCloL9tWTTmzOq1WL265vOzEK9Z/ybp7 kYn1YLttE4pSbItV6KIWobCFF7Jo+w/FLHpbMeZOmj43009t2prfmpPs155gv57k+jF7c14rU23x v9Pt1Xut5LK5r9+0T5g+jMnYnF//3bCd1jfUnOjbtPO85yfc0J3R94X7FXELs73wZ1+UIuRQushB LTZKuFZyHt/byNn/EI4fszEYeQNxIC267iQsgWjFqRe08MIVXgjDRbKadsIYR4G9tv/VYpFyOhdN ue/ckMGEmqCFFnwYC1x0or32c7jEOgAAAAAcLl9N+cztBMABc+s2STRSFoDFFoWlLA6zinPD5ytr sQAAAJSDNYZr79m09qnzUaxPqi8A++AptwMAgvegbiXD0fZbycasxDOpCTHl8aQ/9Qb61YuWlO4j ky8AsDteXVwgyTM2T4TjgpVIOZZ8WZt3tMRoiFwAAEDIY24HAARvQf2/z+j+03q2tu6j5P1Tyj2U 9EnWuX8CiHPTlLvcTgAoTImlis0Rzm3PRXKf7C/bat/LYwPsgnM3ki8BYGZaUfrvxLba+CjH0THB YO3d65iIhSZ2IcUtdiVIrD1/xM6/dGLPd8+OmGeANjn5Q1ePxZdpsczHxrYV/5wak+bRYtUAaoLY DiiNa5c2NmvrVsbaaPOQ1ceKXU6xDwAAAACwxa8A7J3LUcMwFEWlQBapgG2WZEcBLFIAyxSQpqiD GiiAXljBTDLJEMc2lsV7kux85JhzZjS25c978WQky597MbUAAACAIZLyEOXFlE7mQebzhdnt7p2a Rji7NLEojSzK0l6ujSpq04rtNmxm0RhfNMcphbpNZ4HwMZtbnCaW3m/HMYvsj11gfyzi+nq8a/5X +sbq9y4//5Vzx7vu78sR8/zntBIot7Jxhf+crdzGVjrqtrW/9Bxvv2+WvzYbIbz9E9Ff1860iuUU 604nk2b+N6/LcgsxbsGEYAgxxnCexnB8DC26Hb/V+hYGFdUxjg4R1fm0Vf3RRcIxs7irtvNNL9z1 E2ff+k2/Os+H6dQsZrOUNJ9NY1rh+2dYI5tbdCluByaZWxhhKp3KlDoAAAAAyMN77gQABs7KmZfG QpJxoPbBlz/e6voBmBQ/NA8AAMOkaKvXh/Im1PsfcEnrtQ+7UtZr8bSYRqkDOJV17gQAHL4P5SNh O008xa9LMauQhMpDwuShPIywjVYHwwXhA4DbpuhL3Ov7kMBkqM3W+ouYoFpMHE0ytogJbWq5AgCc Qp97DNyXuDzL3AkAOBTXVSkCpdr1U2gcrl0LxcbkqaaUsXF6qB7gv7LMnQCAQhex7FCbHxtva/eA YzFi/Q1AX55yJwDg4bfHKc/D/Day6/M6yYzCN6/wTSykeQwt0vH7yFj/+XrxjACGT/FesyQSLpXQ u8nSd6TSPv5yKK5x1gOMkc/cCQB05FGpj+kCuNtpbX9of/oEAAAAALgKPwKwdzY5CQNRHB+MIWFh 3BjixuDWM5hob6Ab9x6KtRvjIbyFV/AKLnSlOAUqr8Obj5ZKP/j9koFh+jGPAjPt4/X9EbUAAACA PqA5y65jG83nL2Y6nS3rMkn2SsyiLG5RtElRim2xCl3UQgpbFPvNty+LWWz6qgLiFuqWpu5//ENO CD/0BPv9T64f62+f35X9/vb4rjTd37DHslV/ux9TTcRipQ+xHaOxWIyU7YzZjuEo9bCc8yeTk+Wr r7WoRaWE7cW62rNW1sv2JU7QByGHIRyHoYhNDOE9dHn//32Mu/QZlkZvIQ6kRVq4ohV/4hai/agQ sTB6lF8hlDESNuaPx7Z+MR6nmHxuy826SzeYUBO0kOvEAhONs752OExiHQAAAAC6Se4AeWvbCICO c2bLg9Gvh7RrJU3cIiZmERO0MKZ8fUWQPwBAf8nH7Udbnmy5s+XShH1qoRuCY3NI7IZitw/5WrMb oCkyW2ZtGwEgyAUtPj3LfIlw3DYtwUzd8pO4H58d0E/wzwD0m1ezmUtSEhinzgWyniqaFEuMViVR WqgOANA0VXwPPl9GHf/Fofs8MltO2zYCQBASnaxyjS7rqeddoXOquudOnEsBhLlv2wAAD+9Km2/e 8S2T66TMJSnzTMwegF3J2jYAwEEbjyXuWKk9h/yo7vm/1pYiaPFt4oIWrq835vcNvS/tGAwR3+f4 bMtHW0YBdIQ8rvnW+GPCfHFkTcQz++KaJW77oftgAQDa5KrGNqH7V0K5BOrOEwAAAAAAtfkVgL2z 12kYBuL4tepSISEmxqpr34GBlZ0H6MIb8TKMvADvAHMXJlRVSDSEtM5xjp2PJm76+0lWYzvxXdMm zod9f0QtAAAAIDViHoot9ukp1NByuZLv71mpzA3MnQlPZAGp81TOF0IVhWjFblctZnEUvji2kwfl lk6CgSNuYW4pTd73DxUQvj9b/X45BAu6ttff9xv7scd/5fxtNt+noXdxogK45+WZuEUucBEar1Gs LzKfX/+WfG23cQHbXYEKVW5u75QffPa10RF9iVm0sZNSAP6UbYxhP12SmMOptk+h/VbHu5PkT7hi UohUZPnpNBetUOlQJmXhC10/dcQwipF/hd+3s5ms5vMYN+/kKFqh9TMmYotb1Eluh2UFbBXj09qV MWUAAAAAcFr0JK+M14F8ATgnHvbpysnXmQgWmhjWZDJY1UQBvQwAAOmQnZ/XkgtaFKydOn0u131N SKSiTvLZtJYBumY9tAMAihdnOTYYTJ3AY74gOVY+JoiZ5QecP+/79Dm0EwDQiI2U+xJNVSDjpv1I VWA0d11fXtuO8RXSg98IxkCd5w8xg2u7sHNp3A/tAIDizVlue49u1fmun2KvqULJ5yMA/OdGcvFv gBTZeMpj7vFDfYLVV+k2fPZ89/L0PdAVy6EdAFB8NNimzvW79YzVJ1phiVhYYhaW+IXvnqONoMXY zv91+sPsfdpzH04BJM6j+AOM67FmvrHJMSIXTcajAQBAOiwq6qreu/nGM4fqYm3QXwAAAABAJ/wI wN75YyUQA3F44AmFjY3vYWGhF1GP4A30UFzB3otY0Nla2FJYaInEZSHEmfwBdOP6fe8FsiTLDMuS sNlkfohaAAAAQO1oA2vuZudJbKfp9EEmk8uvvB8QuwnIvQieGxEKX5Tiu1iFLmrhC1u0QhZu/20x i8Xa9r4gbqHuKbvc++9zgP0uzpM+H8/GXn8FC/jtHdpef8+VrmyWHdPUHBAxg6tvXt7s29QdBPkN o1ET7Px1Pk97FtgdtEZ9kQp/O3jtLwTf/w0bf8HHGmzwGep4/5rP95rblK2WvBX20VIrbqEkX8xi 2IpYKPXWs/vc8fB8do9Hw6Gcj8c5Lp8t09XKZDihUBO08OukJhhKUF87HJKZBwAAAIA6mQlBEwFS HC/TndiLurQFYCnxwHBRWOliLysPAAB14trqe9kWtHC0/Ytfz77JVLZQOCdZNkW2/dK2AXbBBSq7 7doJAA8XnMwKiKMFS7ECklnBMlOBckqDYWrlYR1tG+rHfWezrp0AgJ14XKb3Vd5qf2NBKHP6ipiA RUzgwuprcoKlxfIAAD9NyRgE4xX7cdO1AwABTxl1cq7Rc6+7S+qV/nfivxRAHMaJoVaeE+W5bbp1 3R+Wiej9hlVm+WD1TwAlXHTtAIDHh2zGXR1WW2g9+/XCsdbU2GsoShETuAhFLtpt7b216xCRvH5C ++z/Aas/dXFe3rpyCqASTpfpWsrmieWIWMTKS+c1M88Z+shL1w4AFOLWwcSELRyxmACxtjw19zks Y04yAAAAABycTwHYO3udhmEojLqtKsTEyMjUoQw8ARIzEhKvwMPxFEz87DwDbAwMZW5UEbe4dZzr 2Alp4kTnSFFcO7FvotY3qZLvw9QCAAAAUsL3h5ddf5cvt6GOFosrlWXFSx1bhNsYT2gjCtvEQn/O sk3BxGK9tsubkpnFwfhi168xtygaW7QL5hbinqrJswBjFtjvy9yi6/HSFddvY7wuvy/89todb7zf lb7GbH5O/VpAk4JZRNHEYjdmWaPI3mY2O9m2fq1W9SKyhN73ZcvIYh/TdLpdT/N1weiiZboSt09Z 4N/0P5Yxjt3/kI9hCPEfO8ahmZ4UZmZtTvE3LxoHCXO+Zs4yNWV1MLiQ2remF0p2mDifz9Xy9DQm zGt1MK1w/TMmSja3kMwvqgRXzemQzC2UsJZOZUwdAAAAAHTPa98BAAwAbSZ4qaoFwJu8GCbV1+3P wAtgAABpoufkB1U2tNBc5Mu9KueVmHzQJGdIucuO0y2TT6BttFDZWd9BAFg8BdpDwt6xQpeSAHmM mOZGGEeKR/oMaSOJ0r30FAsANEebI71VtP8nd4Ryhmte4RNFk/pwY5NiJa8Mh+e+AwDoGP6raJeb vgMAsHivaKu6J/ZdZ0l1sddaoe2qxgOAODC1gFT5tsq+eb3qHlrKFdK+Uu7w5RXyC3QF9weQEp81 tpXmzZjr+5CxhW1Y4TO8cNt8fbp1Uly+Y5GOdYyE8qtd/smXxy6CAkgcrXkkvdcZ+5xZjIlF3efT 7FgAxshH3wEANGBplaueG3bxaQJIzyK7+7j1IcgdAAAAANCIXwHYO3+lhIEgDm8YpbByqCx0rLWy t/ElrOWh8BH0bZyxtHTsLHkCBJKDy7r3Jw4hMfm+GeYW2NytEe+4uNkfohYAAADQZ6wLZ/epgxaL F5nNLre2X/y6LL69Uu1e2GLTOqGKumjFyhOykJ3t+zghCyeWsS/0vdqN3QaIW5hHyl/yAoZcYH8s xfWPO95wzyl/e4ceb7ifla7GzD2ndcGK7StGG8rRiP0vcP+8KE637fdymYynOkB8YYpfRd9VIftJ JWzRtqBF2/S9wL8bo20Qm8jrf+xiDvwOq3781gn+SDkv1jLtPNEKSyXCiVlMnIiF4bfL7qt8Cm+8 k7V9NZ3mhHwhZYFVp7VhCVYUys4tlirKXyI+KRsAAAAA+sl71wEA/BMeJX3TlrZj4oHaL3UTmEh4 j5X7GgAAHJfNXDwXW9DC8eT5aoFZa72x1o3QOhO7/qfHEKmvHawt0AbzrgMAULx5dioJIKfIZa5f bh+6Px2rFfMwE/nGwWfXAQBAY149O1WkMuVjFVbLKaqmxSti4hY5648FawsA5HJ2wL64BtE+D10H AKD4aOifs48OPULfo0IFZkP9+rFYcen3AKDkXErBb4A+8tXANzb/az9r/22tY7rvHB+AQ3DXdQAA ipz9gTUPx77LW9dO/WuwMfEKS+DCErSIiVnk7DPEaK2fd0yEztVzZxEB9Ifr9eNW0veGWjloOSIX TfKaJWCnctEAAKB9btIuwUI41rwvgechO5SvbL2vjwcAAAAAiPIjAHtndNMwDIRhS0WVugDiCeWR DoFgAsQDA/DAagzCACCxAbyzQStE3Dapc/WdHSnBTfR9kolJjH1J09g45/sRtQAAAIBzQZvUCvdf 1uklVVFVrd122x3mhAG3G+GJRsziKEzhDgIWrhWy2Gx+dykUsugKXrh22whjhIIZcxUt+E8IsD9k W/MOrl8mmP98rynfvaHbm++9UqpN+5p235ntNSFiAheyvPV7LF7dYvdTFbXIFaOIlOsEhR9J1IIA //K+GLedqdc/h3MYu/5zvt+n/hnuPO8Oghb+ediIUDQKEo0gxUKkdp87ClzEjrdb0ZZPV8ulW69W OWbe1unCdYUsQgfCmLhFTPzCCrjaXo4g38dphEB4AAAAAOeHn9x4K20EwETwDv137tSxPsynFnDJ gOQxgQvr77X2pD0AAFAe/0x+dragheehTpWzF4PF+gdr8XAs30fgVp4HwBBUbj+WAjgXPur0oxzL CUaWCmypBcPMDS5uBbbR7IBp81naAADohQ+q9p4oowWgTKWUUIXsZ7S+xupzYvY4kXciDwCQ4jqz XN+5bOYmxuG+tAEAghzhSTl2kWX7jrv6/p+utWPZDACnPJY2AMDgu2d5a+5Y6ztkGWv+V2uPfgeG piptAIAgfIcXezemHQv3x8b7OQIUMbGKlOCFVV/O/Ky02zrnOZN73n7/V51eR7UGYBo8BflYkHDN R1n6MWtCF7k+Zyn/MwAAKMeNO303Z631t57h2noWeUzWQ78AAAAAAKPwJwB7Z4zTMAyFYTdDB8TA VBYkZsTCEbhJO3ISTtArMHMFuACHYEMwcIOSkrix3N+OG4U4Cd8nWXGfnfilJTZJ7PcjagEAAABj RT0ceyjTRWyn7fbJrFbXv3k30HUVaHvnbRthi/22EarYHUQtbFLiFo0YRhVU24plNEG9d4e2hwJx C7mn6TJfYM4B9uceXD+XuMWw7Q3598K11297877+crTpf6dauCL0Pi783q4KAB9ruYkp/vH93e6o EqkQQhaLoqjOwS23wejLsj7ELYYKbj/mAP9DHN+2MfXzmLroxxR+g7/2cQrXuzxuvS3qvtHajlIt WqFm8bliFoUVr1B1a0EL257rw95+tVymuHxpqoBgMcGKhZePTThUE0psffV1mMQ8AAAAAORFLYR+ zeQLwBRZl+ncxBdtKeGKImIP3Z+1fQ4tAGMBAABAfvb978a0C1pY1kb3+f5YoWyxMUaNHa7NeFtl c7d+HuAUNrkdAPB4c/KhwGPKpgLOqLK2QJmnBBr3/ek2IQbGDqIWANPi2cmnBNoK1QmNFW3B1tR+ KeOMMeFxhLEFAMZGH88geI4R5j63AwAOXyZNeDJUlnJPfsr/TMqu2lH++PfvAHAMohYwZt6FTd3T h/r4WN2258v+PqpMfQbog7vcDgB4fLaUh/rN1Hd4SsQiJGaRImChhCxi7wLdMt/H2Ln+J2K/sbU9 Du0UwAi5KdOtSZtrnLKGtG1ec5c5zMw7gznxktsBgA6cGS1Mr/pwVRbr91Pr+cdmPAAAAACAXvgR gL3zV0ogBuLwwkBBZ6clLbWVlY9gY+3wcr6IvoSlhTWlNsjIeRcIuewm/JFw5/fNZBJyuUsIc7eX kOwPUQsAAAC4BLTJLj//RmpRC5PpdCbf36OdPN+5thOecGIWW2EKaYQspCVoEYpbLJer5jzZxE4Y wxfMKKktgbhF9Ew5ZO1Anx3s9925fmnH+uepswt1ce/F6+v3/VeiTr9Pa+fqcR9AtVbEQCkXxvYr ympVT6t8LBZ243xxiujhgeyIVXiiFoMgfelCEaeoowsiBJdQRx/6qetiDqeoow+/4bmuv7OSohGh cIIWgyb9K1oRhE2ebAUuXBi5Ms01/PSweWZX4Xo8ltlkktPkO2mLVwwjebHjQyUvvIbrjpi4hUTi Vrdm5gEAAADAeXkp3QCAjlAt6n8S3QH4IRu9LPGKmOPxcAyV2vDFmAsA4LxUz9255AtaVDjbkrIH KWELS2Qpd4Nx7jwfwL7MSzcAwONrHV4zysWcf8ccqFhOaawymmNyzUlZyjlmPxfr/S+YnwHoBpUw 0luijOUwTbMNmpBF+DnlMC3HLml2x7IzAACHYs0tMO9QjvvSDQDwyH238j9b71tafmqcvs97U1gH AORxtQ4PpRsBoFDNG38qx6xnfWp8LdK2UWFs2ZkwHTsOcCyIWsCloY0Rcp57uWOB2LyqJWaRK26R M94QI973+/aNnP8/XT++r8PzXzcIoAM8eulwPbG2RtnaO2qdk1p/Flt7BgAA5blV8nP3peTsmdGu rdkF7AQAAAAAHM2PAOyd0U3DMBCG3T50AyrxAH1G7IAYgRGYgGUqRmAQBmAHQLx2htI0dWNdzvYl tHEavk865RonthNVucRx7kfUAgAAAMaINsj2srOr1E7r9ZtbLld7P0wUXifV3oplI2xRLb24hbeY qEVldXktbuGFLLxYRpPAe3tsuySIW6h7uj7zCKacYH/qyfURKxhLW/125P9y6vaGj01lzmnlae/g mt8yEbsXuAhFL/z2TVm4bI7rZ7MR9eydeCdDEQtFvELaTNbXM4k8Cf7dYEIQUxASmMIxnLv+v7Qx hKDHJM6x9+sVR79lB9EKbSZfKGYx9yIX8rf3D+3NhZhGJX5xs1hYun29sweXFqyYCb9rUju/vXY6 nNEHAAAAgPHxXroDABdElejp3rWfiSyJxKUf+ygsJXRh+QCM5y8AgDJU199n103QouLW1fFFixsx 8QqraXWF65xrx5PUB2bSB7DwuLNV6U4ABHwkyrokSumSLDOVONOaSNPSX7g8wv/QZ8F+AICdMEmW JW5ItPghxStknEiVW+NJqn/EEwA4F5YxBOuYQyzpTdf2oH5OBxgTYcLa3P3KVlknt0vdS53StHZz xwHw33kq3QGABF+Bn4oxqW3C9VrMkPEsF09idcf2If5AXxC1gDHxnSnPvZvTyixCwdaymLhFn3Ha 1PWba3o7hmrn8XXoTgGMkDunz2nWLDcX2TLfLDaHOUSO+TLvDACgLDFRC09qDnHsmq4tY9+3xN7x 5eoGAAAAAEjyKwB7Z4zTMAyF4dfSDuUAjLBVYuEKnASpI+KGjKBegIlLMLF0aQuNEre2ebbjAHUS fZ9k2XUS2w2ldh37/zG1AAAAgNKEJrLs/MrM4jFV0HJ5J7vdzMmzhbSN8YQxszAGFia93UpLQ4sq Fiv9dTS3cI0t+gPmFuqV0mVNwZgF9scuro9ZQR/q6vZ/Z+o8J3xehl+nuZ+1LnlY79sWfvfNLNw8 sY7V7Pf1tMrnZiPbakARQxN/90TnHWML+zo/ZDIUI4ehC/CPpY4hfFZKlm/qKHl9H8ov9Td0vs0b EwpjaDFp0sakwg7HPGkMLqbTU1rc1X0XplypzS1MfVfzudwuFm3eQmVqMTPFyU8BO83cQjO/iIng mduhmVuIEmu3sk0eAAAAAJyP19INABgYT6Iv3A9t/uoiQB4yuNA2gqU2fPGbCwDg/6m+a1eSb2hh eBC934j1IylzW83cQuujcjeSAeSyKt0AAI9nK91WJKatIE5KPFM7RyJlhtoBw0cTs3sr0RAAyGJ9 CB+Jc1KiarGQElKLHff7mVzTpFAaAOAvKTXHwNyGC4K10DfeA/n+mEQbr7Qd54TGSbExk1++1gbG TQB5YGoBfSYloq6h9Rl+Wjvmx7H5YjuWwGuA33JTugEAFqn51xhtnt3F5l93gXRsHjY0vxv7jaHF /nuAE7FnptWztfV5mwPQS+6ttLamWVuHHFqzPBF9vVlqPXNMzBxgLLyUbgBAR64P4bJJx/ahiJef 2rui7afxX4f22mjnAgAAAABk8S0Ae2eP0zAMhmEXoW5IUCFYOnAHdtQbMDGxcACuwQl6BmauwIGY QZ2CTZPgms+fnQCJEz2P9ClxGv+0au3Gcd4XUwsAAAAoDWkS7dHGiZZpu302q9X6a98XBd8LaFfB 9tvYwm0bc4smUqYWvhnGYXlVLdZdtXWXBuYWYk7TZ33BnA0Z5i6uj1lBCXVN43fX1DlsffP9voxT 56Kt69CwItym1mqk78O973ZC9Yt47looPWpSERhZLPxjHZiCycIUTAhKqGMOn9McysfQYvjyD3pl r1/9EbVpRUxZzsWxM7NozC1qs4sm2nRd35FvOuTy2vR6ucx5G5dmvxAxJWgnidvlLiZszpc+DpO5 DwAAAADl4GYvXsduBMDEOLdxZ/Ie2NKEw6XQHhLr8iAY118AAMPh+twH09/QwnFv48x0N0LqYngR G2O0G1WxG1aMM5DLqUGoDMrCCeHExMkkkTFNuDI8T8qXI5yTI5ApiaDF2g7TBVMLgLL5sPHipbv2 xbnjg5ROmVz0GV9y2w0AMCbMP/wPm7EbAODxZnTRWk3gVfvf0yW0/1VSW7hGB+jHlY3bsRsBoNDF 1ELr+6X53fA16Vo99xzGGfhrNmM3ACDA749Tc5ra9UCzr5naSfOsqflYyXi4ErbaHC19vE5qXA2P PQ3RKIDCubFxYfT1xNpa59QzprHjYfk+Wpp5XwCA4blOvC7151JfLq0xjj3DkioLAAAAAOBXfArA 3rkjNQwDYXgzTIpUlFQUaTKThp6OQ6TkBFTcjQo6GA7BHaigSpGCZJwNkrx62CS2Y75vRmOj164d sBwh7Y+oBQAAAPRJbILLzb/epodcR4vFjWw2/quNGzRbBShUzMIVpqiELKRI0KI6uu2rowpmqLjF 0EHcwmwpbdYbjFmQYezB9RG3GIIt/u7iNsf7+9KVTT8w+uRwP6v8VGw5J4j5JDz3f3b9/16vy33T /jQ4eyhgEaR9Ja88a6MDAQS102f7kv7HYuPU/Y/hGobc/6nv8bl/hk3891Zl7EUoVNBCn68qUlFL 4otZHPLEX9l3of1KJW6h9q6mU1nOZiVu3rrdST1gnSVuURrwTtvp7bDELcQ4WreyJA8AAAAAjk8s 2MZTD74AnDOrbZrvz2MbvqyNXrkg5LFNYyVJxP9uxSYwAIDTs3u+PsrfBC2Ue6mPG+Fc3YWUz+Hl xpqSjczudQK0YSdocdm3EwAOL5ny2CqCpoExrQA4qbrueWgn5ts4F9/9b177dgAAkjzLb8DlY4wX qbGiiWiFFSwtHE/CfsJrSI03AABdkZp7yM1LMG/RjLu+HQBw+Ciok3t/cfOs9y2rLJVy9VM+AkAc xI9h6HwW1rPGJauszRhT0jfAsZnnqwB0SkpkKPd/s/D7QCy/TYq1teZoQ7uSOMauB3xSn/fbNr13 7hHA8Fg556k1YeE6ZWvdcmqtWVjfsse6MxgzX307ANCSpdSfzbE4AFa9NsnqWzJlAAAAAADF/AjA 3rnkNAwDYdgtqJtu6AYJJAR3YM9ZWLPiImUFS8SJWHAELgHqqiRN0rqTGdsJbZJG3ydZdVw/Rqka x6/5EbUAAACAIaEtjLxm4SJUaLl8d4vF9SbuOwAvnGWvxedO2KISpPBDTNTCF8Oo6vNDtSab130K ohGIW6glXZu9B2N2sj925/qIWwyhLf53dpvdNjgecQvtlWKybW93bfkHmpR6E3Lfxj75O8F8Xrym /KxWaaZN9amYPWfuQshikpfRBC4MuhKz+E87p+6Av6s2xnCfEHPo5h4fu/5j/4bJeYsC23gtlCIV NYWIUsBCClls8gqRi2kpaOHK7/y2z7Prm9ksxdSrLDy4sGDFRMRjDu1kx1Xl126HS4wDAAAAwLDA cSJAc55cfTxkHeCKiVnEnJGnbPKPHQJjPAYAcFjy5+pHFl4OVF/er/h9gC9g4c/1yfSzQJ4mwkly EUnrb+hLoCmPfRsAIPj04rGdAm0dXUrH4TGH5C5Qn7QVZ2bjJ+SsCQD649cVohYWIWdqfpr1vA85 RUt1prYWaVp/kmIrAMApEJufYP7C5s4hPgnDwh8Dhd5NrDFyaKxd5QkJiTWtz4m8ITsBYJ/nvg0A iKAJLVnztDKP9Z1Wl5Y/JZ7SBkAbbvs2AEDw3aKMNv+akypAr83NWvOu1jpg6nqg/ynthx2hvlG7 f29Htwhg+ORnSS+dvtdY2ytmiVuEzpimnj2tkGnsQYMx8NW3AQAtuTfSrfMo2jPcco7TJr/Wfuic DAAAAABAjT8B2DtjnIZhKAy7VTsEdjYktooNDoDoDCti5WjcgRtwAcTGJdiQ6FBVIiYxddz37CRq cVJ9n2TFdVz7UcBuLPv/MbUAAACAXGiLV375fZnuUg0tFtdms5k1ynyBbGdA4cwsfGOKysjCiIYW 63XT0KK6+u+vrr5hRijKPRbTiLHE2QdE9vfZ1/GaMeTp73g/T/7v9t3f/4/ROaaEw5lbtNHwbpZv BdZ393NU97ZtFUVlavG1WqWj8U0p3NU3qNCE4706KfH3MRg5jCHGIfTBzzCM9of89z4GQ499ta/t pptUjVS78Wqzikmdt4YUs+n0NzlTiz9lucDIIlSbm7g6dd7Wc/2dzefmsijahG03Is5cc2ZXvE4y t5DML2Liqu7jkMwtjHANQWAVAAAAYFi85g4AYITYg92PJn14SzK6iBlWSOUxswztYFhq4z8AAPTD ja/PZXraY7vnZbox+tqcv5QYW7/TDC3CfGzukNb2mFOgKxdlus0dBIDHW5k+lXspMZSwPCZ2ExOs 6ZK0WPptboExYH+v77mDAAARa2jxXee1MViaS2ICaZLoWWwekUTVYmJpWrkUq5QHAOjKae4AoBXL 3AEABHwo5bFn8/B+7HldKuv7nSm8H4sTAJpcGUTTYdho68YpwjmjzXqvVN8vk8qZf+CQLHMHABCQ GpO18bHNM0BXI2HptbaWG8Yojd1GqQvtiD2jvRiM4wEsD15e2lfcJWnnSaX90Vp/PuwzAwDIy4nR jS0s2hmUcEzXNATavDfsT2oTAAAAAKA1PwKwdwY3DcNQGH4F2gMD0BNIbMAdiUGYgim4dQTECCzB Atw4sgIceqVNG6vO4/nFLWnjRN8nWbiOY79G1G6c+v8xtQAAAIBSsDbi37edtFi8yHx+K9Xzzljw eyuM/av+7owtgiFFnLSpRVwW1wsmGTqFZ7GWIPdQTCOGEuchILLfZV/jNWPop7/xXk8+d133N97/ lW77tZ+x2UYVu/pbcXi7nb+i67tj0+nlJvezXEqSWgxdlzXysbmFUTax6jSaO424fckC/6H9sfRx 7PaH/B6GEP+xYxy66ckh16cxaoex0UrBpKIeextKcoaRxUZdTplcnNWGFlIfi2O4WL++ns1yQp7L VizMM6yYqHxKTDUlbhfqW5dDMvMAAAAAUAbVakglmvjddyAAA6TaBFY9LExt6rI2ebVt/rLKU+eL 2PdY1rNPAAD4P2FMfZVuDS0Cj9Ic8731vXOVcs1q24yRUmt9APvy1HcAAIr3KO8JY+oyT3gsR3y8 TSizTeBMVDmMB0to6aOnWAAgTSWi9uYc94TJcoTU9BzhCanlzjNWbFaszC0A0CU3J+4vtWbBWobP Xd8BAChyRUe9++X4eM53r5z78VS7un8AyIO1YiideD7y1om9OrnnW3NLTrupvqz5EWAfuEeAkvhM lHvrnPq19f3eMwa21l/bDCwOub+wxn7Gbp/U3Ju6ls9HjwigfB7W6UrsPZyeKYVnYJGbdH9iHBcn D1Ay8bzz1VcQAB0QTC28sVmMcm/M37eM3yUDAAAAQGesBGDvjHHbBoIoOlKiwpWTKpVrFa4Md76B u3S5QYpcKxcIfIEgB8gdfABXbixAkmExFKnRanZ2oFAgKb8HLJZcLmdHlL0jLan5iFoAAABAH5QW 0yquNuV7ydB8fiOr1e60fZEJaQUoGjELLUxRi1aIKWixXB6KW6zX+vy61oIZkQTcYxGNGIufx0CS /S7HOu8E+wgWDGEs/u/s8c73b6XrcWsNiF3i9Lq277PV13Vi9JF2f3dsd+50OvtXPy8WeSf2dif7 bWlSdyVe0SZ8DwhanJqhJ/hvxjg1iE3E7L93MQfew7L9TuyoIlsRisr2x60oRdX+oRGw0EWkFb3Q QhY661yrNtHYFWltVuXLbCbXFxcRN++2ZidymMxOt1nHownwmsthiVuIUVuXMtIGAAAAAKchXQB7 6MsRgJHzQ/IP31uJw73vWpHE41FBQhG+dwEAdEk1f37alN9yGkGLim+b8ll88YpUxMLr5631eTFF Y/3Y2DoGkPK1bwcAFC+b8jfQL5fAUpL2V6NvpOQS31jjpH6kfax9GD9/+nYAAA74pbZz825uDm9q Ly5YCdTShGkRkYucXS/e5F4DAMBQ8dYsIAYJa2FI5BLWanI/6PA+53ift/S2Z6+UdNY7BgD7VPdV WCuGoRMVWdKkMai0vmvFFi/2lGIRQBdUc/Rl304AKJ7UdnT+i96vKwlVWGuvufXbyD3B1Lec33A8 6TX/KcfFdIBz435bW0IT6fNh3rPIpWebtd3I82eSaQMYG499OwDwH9wWjkeFJ3L9crHAiwlebCBu AAAAAIDLmwDsnUFSwjAUhoPMsNA948IZLuFab+F4Ii+AV/AkXsSFSzaeQAk2mD7ee02AQovfN9Np bEMSFYl5ffl/TC0AAABgCGgb7l9DRzLGcvkW5vPFppwLX/+Wv8X5z9giGVLkhzS1yK/l9ZJJhjzS s+tS8e2xmEaMZZz7gMj+Mfu6bIF9DAuG0Bd/d3p/l/teOW6/7edtbS313ZyQ9P+D22LWyGQy3Zw/ Vyu9nmNG4XTQNuJw2kHg/zRGEKmfsbd/Cd9D3+0P+f3O71BkSKTPyezYGk80RhW5KtxWOU4xspg2 r81NLq6a14fmXsjK0TjjbjYrGfLt+ngIvmGFNLewEgytRJJUV/44vMRHWQYAAACA02MFHxBOBNiP +MDwKdibvOSaq2vDV4mxRcmmMm8NxpoMAKCO+LmZDC0ee+7rOezG9KRJhTSqKDGolXE/a34JwZ5P AEqJImWLcw8CIOPdueeJ4lhCONo1TeDGuuYZW1hiZdZ44bL4OPcAAKBFFMAqnUNKxdM8MTVtrrDE 0jwBNm88QZQBAPqgNi9I7ufR9vfUtLHP/f9C33EtgBoOFRDXrpeu3yM1xpNevwDgE2PFCKbD0KmZ k6x4spwrrJiBVremD4BjgukdDI3dDbI6Xryz5pmdZSSs1bFis946JD/L8UMZ2tpMu5d46Xc4AKMg xv9ugp5PrOWNWfnMXl6yzDsLQY/pavlnVl2AsfB17gEAHMD1+rjPvu7KD+6aC1IdLQdZa1+rI/tG ewAAAAAAivkRgL1z12kYhsKw1aJKfQNWlkosIB4AxAwLA6/AzjshngPxBmwMTGxILIi1ikpCYsk5 Pb706rj6PslK4p7aJy3FTWr/P6YWAAAAsG98N67c+tu63MQams3OTFWNl+qtkUVjXuGaWbjGFK1p hVENLebzZXOLqnKf325dw4x1xbZLMY0oJc91QGR/m30dtsA+hgVD6IvPnd7f4f6tyH5TaUXT47+X 9c0p1ltPt1i09R9fX71INVr24R53Quy9XFwjCytm35V9idsPWeB/H+3bPko/j9JNP0p4D3adYwmf 9xzt92ZQjEbtrIvOrMLWj62BhVtMp0AnjCykKp19/v9xF2fP53gyMafTaUqal3U5ss2Z5cmFmrmF O6kwRQzPOPHypTHKVnspU+oAAAAAYPe85k4AoGDu63LS7ccWcGmLwWRsyNgitGBMwuIvAIDNaf5/ NoIeL3U530N/D6ZvZCHNK7QyUrax+3vaYrKURWPaMYDkLncCAAJXkDxFPCYmfhkSw9HEblYR19Ry O8yJc6DxaRBBABgSz85+iqBkTNhSjhUhATWfWFrqGLPK+ME4Uy4/uRMA2DLcb9gt17kTABC4AuIh oVKtLvUaO/S41nZKrAbfpwD8POZOACCB78Q47V6AFpMyBoXiQn0DbJOL3AkACN4jj/uuFeR+yjWC z/AiZCacUmQe2jnA5vje36e6/OZKCmAgNILlVitJCom7+3Jus1bvm18Wmm/mEza3cA8YSqYZa95y JwGwIVdKnW+M0MwmfDGhsSbUnu8YAAAAACDKnwDsnTtOAzEURa0p0kCB0lCAWAOihIKaVbAA1pKO lkVBRYegzCIixvNBb8x7tjP5zCfnSJYmtse2NMk4/t2LqQUAAAAMjSbk8pC6abV6c8vldXUtxbWl yUQdahOL1tiiNaSQITS1kHEyn7//f/lVrX9192UqhhGYW6h3uj57GOYssj93gX0MC8ZQF787vb75 flf61NkVT++us20nrh7f67zZ1OV8rdeycq1Bdrowq5AmFtLAQn4uisNP54xd4L+t49BM3UigrePQ 5Z+6mcMcnuGUyu+4MzTPr2iMgTqhMaoIFUcrFTnFyKJSlgtMLor2flG+E+XdLBY5Tb4sw6PTxes0 Q4uwuTkbTdq8LpIndQ0AAAAA48ALJ34M3QiACfNShnOXPqyljbussZh1MCxn3Katg2pxAABg49+V xzS08FyV4d5tb2QRxqcMa3P6kVifYn0GuCjD89CNABD8uK5QpsQSxNTStXypYIndOCXdKt9qyzw3 0YF/ru9DNwIAKj6bEEMTKcsVR9OE0sI4y+BiV0G1VF8H0wHhHJgzzDfsn9uhGwAQ8J2ZLzU2jv0X s8bgOf+XrHF4v8MkAKeJ73uOtbYCsAva/HHO/Kw2L2CVo/UjsTpi/RH9EOwL3tEwNqz1PAtrLOCM +F3X97R3v3XN+3t/aM/USvO8HrxFAOPnqQxnLr0XTNs7Fu4ryzlvKuNawvOjsf1nzAXDlKA/h6lz 52oDJE/OuzilLxCLC8sIr2P15qYDAAAAwAnzKwB7Z4/UMAyE0YWQIhUdBQ30pGQ4BFUKhjNQcjPO AMNB6NNRQJGEEI/jRJZXWplJ/Md7M54odiItnmBZ8ur7MLUAAACAJolNoBVcbrYnq6Lp9E6Wy2p1 uaC37MwsVqu87BpT5KYVohpaLBZVc4usjv3389d9O3IwQe8+GUb0Kda6ILJ/yLaGLbCPYUEX2uL/ Tm9vuL+V+m2mPSOzBdfLvzX3/K7X+dTKx3wuqplFtbFdmydOeXdMMbVw9/XF0OKYNGUE0Tehf63+ IfwNXa6/CUOPrp+DLtRfyq5wTChGzv5RYWDhbrJVlfOMLEqqc46xRVHvqdP2xXgsN5NJSqiZceNZ EY5Ukwg1cws34dASv3OTSTRzC1FeK6czcR8AAAAAHI9iAuKt7UAAeszVZnsUfYGXv3jLEhn3x2aa sUVdIXLGXgAA6RTXz5nkhhbnDbf/ILaZRR0Di2LKMrUfEan2Ef5iMoAQs7YDAPB4N46Hnv5bopi+ MKYmOG6J4YTaCcU2zIS5/40mYPfaUiwAUObFKadcj2Ofca//P6L3E1pfovUfdQXVrLgBANrAyiOK fQf+DqYW0DUswdrQYg3t3kcbT4fG4LF7qNA9Xcr9HwBUeW47AIAELENLi9g8r3ZMJNxvacdEeW/t B0jluu0AABy+N9uXsj82LvCPa+OA2HO62JxrHVNhNx6/rL2HwxDqezNTi8+2ggLoCJlY+f22HBIe 14wp/LyykImFnw+dkofmwlwv9BnyOWAI3Ep8rX8sl7goWyZHWj8Q0hvQPkdfAQAAAAAmvwKwd/44 DcNQHHYl1AUh0Yml52CEFVZOwAG4Tc/AisQZuAjsMKAOSB0qkqYG9/Ge7YRC4vT7pCe5dpLn8sdW HOf3w9QCAAAA+kRb+Lqr4iR20mJx72az+aYcilqHJhNNXWM84U0pvCGFN6zQTC3COn+MN8OQ1/c5 fO59UZJhRCn97AIi+/vMNW6BfQwLhpCL/zs933j/VrrltJ6ptc23u8/Nf3xbLt3HahXvgSLuLusm 0siiqdyYWUzC+j8Qit+HgH7pAvljyVG6YUYJZg5D71/O9Uv+HU58jibZd52MrVGFplbqDSt2DC7q tqD+67zt95E7QI6quvl0mtPlsyounC5spxlayO7miNv5Y7Ufh8ssAwAAAEA/yMWtx746AjAS6hfB zl18k74s/yaslwA8sZcJrM8AAIeOHxdvq3hw/29oUXNTxamLm1jEQlv/s4yVwjbn8tbvrPkGoAah MhgaT0E59YQ/V5wmFbmC45rYiuxrTKgHxslz3x0AgI0hUkrU0hLMajMfrFtGF0E1a36RZQCAUmAN ojuYWsCQSBlaaOTeV+e0W8dabal+AcBP6mccGCBDCbwGZWstNnUvrc09Wps8v+2co1237XkAIZd9 dwAg4CUox8Y1a9y0nrHlrt/mGAprY7p1D5LzXSAfbf602t5dY2wBcOhcV3Hs0oYTOWYWqf3L1h5m uf+M/WYAAMPgKihr47ZT2uWYr7VZx1tzg8yJ3gAAAAAAtOJTAPbOIKdhGIiiU0CVygEQG6ArJDaw YsNpWCJxGG7AFTgDF0CCc7BmU7WQKjFxnBnHTdOmid6TrDgTxx4CxI07mY+oBQAAAOwLa9HKt19k 5ampo+vrW1ku693lybvz7VqEYi1mkdfdvi9csZLFoipo4e+XbcUTtsi35Tiy0+TdQxG3GIqfbWn/ o2mxD2njjTXJ/tgT7CNYcAhj8X+njzfev5X0MePfndnX5/f/eN6mjG9z56w/Y1SHmgS7E9VesYXH fLtLDB/YuqaLBP9DT/K/jzHGcJ3G0D+CFsPvvyYI5BVxYhSFWIWzHzsBC6+cOEGLQsjiyDtWqYsX 6VfsO1/Op1O5mc1SXH+QMjgwFLfwbeFxF2CiCWKEfYjXvnZplG2IFfACAAAAALvBWpB4l/ylLgBo z3NWziT+8pdWjz1zaYnHrRfKrOcxMWwAAFDi7o8vWXnt0xHJhS1SBCxSxGy1NUHtpWJtThGlDmAx z8pd304AeHxk5cc4Fkt+otm1emqCm9Ri+dIuIAWGymffDgCAvHn1TZOQpSZIi7VbKfWm88KEappf AAB9kRITtM16A2sVafC8DofEt2FvejbX2mnP91qSWcsW+yyVsnYAADqP0o9oOMCmWHOSRmx+Cdtp 80vTGrB1vtYGYFvmfTsAENAkfBdb94x9l5eyXqvZU/qw/GjyGbrD+l0hagEgcpqV+6Kekmhci0du ik+2Ys2sWGafLteHAfbNV98OAGzJZVauAltsrhCp389T7v2p80PTHMAcAQAAAAAqfwKwd8Y4DcNQ GH4g1AGJoSMS4gycADFyAGauABsH6QGYeglGxB24BixIXYCE1sR9eY6dkNRJ+T7JipM4fi9pZdep /X5ELQAAACAXVvCW8g/Kk6aLFoulzOdnP3k/gLUvMrE+thaecKIUvrDFOlUiF6XAhS9k4fKVmEW9 fmfD2R6SqYhGTMXPLvwtQHu3C/c5yP6+B9hHsGAMtrqtV+C70re93d5fuk37+1E9my9z35rz5oSu HB+rVXunN4HZtXDFgZd+yxweypbQRU9MIcD/vtgYuv59uIcx1z/0M576Z7hr/7dmSrh20kqeMIUZ pdSJVxT5Iy9fU5Vw7bKyXZ4/n81S3D8t0qWkBbiz3E2ZNOLKWo9DEvMAAAAAMA6eczsAMHHKxWAP El/EFROzsMZllrBFmwViIvYYjHEZAEDVFj4W6S6nIxtupS5I0SRiYYlcxMRqrT5GJNxvsKAYYtzn dgBA8eLlQ8HFrGM6IM2ndy41EHmsrGXHClwG/w9ELQDy8iTxgJZtgprpvkALVuhk9SFa6KJtP6P9 1nkAgD44HqDO1GA2EOcqtwMACj9gbVPg16bfL3o8bY3RrWOa0KR9y461DwA2vCuGqfDaQx3WGNw/ FypjXRPap++BvrnI7QCAIiZqURIbH7htqL1Neaeqy3f9L492u3/aPPv3Ii0H9whg/NxIelBxPffY ErcIzTUL7YvU56LpdaS8+4Up8pbbAYAeuN5sU+YHp6xNiSWReh9g2ZCGsgAAAAAAW3wLwN656zQM Q2HYBTpUdEACMQJTFyQWJDbEDgtvAOJheB0k3gPBezAyUKlqRUJixXGPLy1N3ITvk47iOG7OaVrF udjnR9QCAAAA2sD1kMqsv8vsNrSjyeRCzefLu9NJpfNlIV6hy5WYhS1cMZstamW9XrVVhrBFsaz8 qASJurshGtGVONeh7QT72mebIG7RZX/9PZ6IW2zaX3//K6VHwefyf6F+HOTxbcvCFqq2Pbf8OmM8 Pvyt+ZpO40J0JH0PClsY2zbBXxPQdz0Bf1s++nCcEHNo5xg3vf+mf8OmCfmojazQIhalQIWu39Wi FaapIqvc3s5OlXku/3xpul1t1F+5ruM6Hg7V+WgU8zWuSxcDtZzMzqyzt+tBhaEEeObgEUncQglL 6VDG1AEAAABAM+iHE6+pAwHoAaeZPanwBDDfxK91RC9iBS18kwIAAP4j+TnwILP3zB4Sx6LJhWqv lCxY4RKxcIlfDIRy7CTl2EnF9COQc586AACD78zeItpJSSull/QLoa3P7KTlMYlv7DjsNtI69BME RwHSkPcdL8a67xwcm6jS7hPMvmEVi0m45oqPvgMA2uAkkV+eR8RxljoAAItQwlpfclJXslm7jb3d rIu9Tw9dR3GdBSDzqIr35QBdQBK2lJ4HSH2Fr63rnt3Xd/n6P4BNg6gFbBufK7R1vdsL3QeE6mLv EXz3IPZnoHlcv9tzsogAtoejzG7Ksi/xuDSO2S7b7dcZt2zD2DPoKh+pAwDYAJeZ7Tu2uc7hMX1I bL8gzWWxfdv1AAAAAAA1fgRg74xxGoahMOwBUYmtGwPiCowsiAMwMHEALtQjMHIINiROwMbIytaJ qaqIm5o4znux06aJ036fZCVyHD+nCjax7P/H1AIAAADGQNpkfxe7abF4MfP51ebcF6v2TSbKvFLM 2plS+MYWZTL/x9WqMraojC7WnplFs34Xw8UemqmYRkylnbtw7AL7LuZwsYZ9OAwL+o433PMd+98e 70ovUbaxqnG6aW7h9zvaWuZqn0z1O62L43qbV79+fl4Kmf8sl1VVMYF336BCMbOQytfy9zSk2Icc BOynEINnyKP+nN/3KRh65FC/FqO2IsP1k1LyjClChdKNaYUztHDlPLOL2ipA10cHsc+KvOvZLOVx Lot0b3SRO8ncIlUg1QTlpZ/DJJ4DAAAAwPCEE1jvI7UD4Nh4KNKt0TdyaRu/Uk0stI1k2kJ/bXOB VAYA4FRw/aUV7bCGFjfjNqfBo2kaWPjGFqGJhWZMG875Sce2uTwf5vJAwxpaIFQGOfHRcq1NeGwX cZsUkfE2wUxEy8DivxOfYzYE4IR5K9Lv9jylT+7S93cxppAMkcK6YvVIbZXOAQD6ZKj5glQRNKhA sBZyI0WwVvq/S7oefl9L535eSvkw3m4bQgBOl+exGwDQAcnUwtLW72tjhVZHbEzS6pbGPsYj6Au+ ESA3voS8lO+AMC82f6vlx+ZZU78R6KcPi/Y+hHk2fRfp9dANApgAT6a5dljbH6rtH5XWL6fcF9uH CjBVlvEiANlzYUq9AYvWP7dpAXTt81PuBwAAAADoxJ8A7J27TsMwFIYPpR26MCHYECsSMwsDHZFY eAwk3oPXQrwCTwDsbJWYSklw3bjucez0klu/TzpK4rj2SVripjj/j6kFAAAA7JuUCesXWTzFGrq+ vpHZbL05IzZtlsa8wq4XZha5YYVdFuYV87Vw61hzi7ydfFn0I42YWejH3YJEInQlz01AYH+XfdX/ Oenz+TT99dGwYNu++NvT++vLZ2W1UXNM8+W63XbNqdxnjG0dN/z9xetXGQ6NqcX3dKqnFhJ8V4wr jjyDCxv/5YNBUbYhbRf4t+33pY99t9/lY+hC/vvOseumJ218D1dmTlgTi4VBhS23xhV5DLPram5I MRRjTGGNL44X9QbW4MLZt5z5t9i2eZ6NRnI1HqekeSvFREFf4M4t8/fbCYYhUTy3njj1106NstRO ZUoZAAAAAGxP6FeSzyze60wEoMc8Z3Eu8Qe8UowsNBOMsofIyoTKRcL3Z9yDAcChYK93kyxepZ1i /A9ZnMi6QYVmbJE6fsQeNBYJG9dqY4Y2tsBh8th0AgAerqlFiqhMqphNSETcFSsvExrX2tdyQwjn cNCElz4ayAPg0PkRY2oRokyosqog2m8k/HqhccjvOyVXAIC2wW8J9YBgLbSNrwp1NeHYubcv9d47 VKYtQ7nw/QqgnEkWd00nAZCIJqDuknrN32ac0erGcoi9BiCFy6YTAHAIGQz5xL6ru+tV/8+Xco8h CdtQH2XvuS17qTspgBZyKuYerYoAeWx+WWzuWUjQXALrzD2DrvHWdAIAO+Le2y4zpNg0QuOE368o +xgjAAAAAKCUPwHYO3uchmEojj+CVCQEAkYkxBVYmLkBGzucgpkLsLEycgHEzB24AWJnqsQKTps0 rvOe4/TLLf39pCc79dcTLXHiOO+PqAUAAACsGm2x6snZQazR4+OznJycjfJ+MGxfZKIOUl2mpbBF LUhRC1uMTSZpKVoxFriYFrVo2krVPhSz+J2MvQ5simjEpvg5CwTYX+RYecQtVj0eggW5x+J/Tx9v k38rTUeNGEV7H9R4Tm/iWEwLWLTjWzR1pTr+9cqaMXd390bp93Bou+gFZp8SrqjKdoqiXd+3up3M /rRv3QP812MsG8Qm0vrfdjEHvsPu/pdJH/+ndtV558mWecIU5fFEpMITryikEb0oKjGMlqpE5Vu4 I6QsPx8MUlw+dXYlerA7TdAi3GiYssGwrqv9OSQxDwAAAAD5ec3tAMA/Yd/ZvbND6fcC2LyW8pKA KCkAwLZQn/funL07O8rnSifX0ghZxNb1rOOUuaII8iLdLxMzd4DPsbPb3E4AeHyJHSAzFgwzLA/r aEFvYsFvtOApYX1tjHBs2D4+cjsAsIW8OPup8ta5NzaHpARKSxGw0Mq7BJViwddieQCATSNlLcIK hNO3n/8GohawTlgBa7V7YO3aRiuLXRNp99tW/9aagOUvALR5yO0AQA/8OWmetYAwH7bVUus+PjYn ASySi9wOAHj4z/Ri1+3a59b1v3UsRp1Y/bCeBefqPFi/mdI+nb2t1BuA9eRG9D3DfYKPd+1PLjra x/YvAwBAHkrho0uxn6XF3jtJmTu65gBrTmB/MgAAAAAk8ScAe+eu0zAMhWH3NvACzF1BndkQjCAx MLHzUKzwHmyIp2HsXDUlaeLGdnyt0ubS75MsJ3Zqu03rk6TH50fUAgAAAE6J6wGVWv6Sp+dQQ6vV ndhum82VgajLvBSvkNu1mIUUq5DCFZtNpmzrgha1sMXuIIpR5pkmbtFHhiIaMZRxHgMB9tvsa8jB 9eP7PG9/4/1M+e213d+Qviv6OTQFLeQ1QpkypXynHFuuPy7q61SvOZZleruZ1u9kMt/nf+v1Ue+i sYJPBnK3CFs09mP7GECA/yEIHfSh/TG8h1O33+fvO+fw9O1rXhRSxKISqJDl8+n0IF4xq+qKmXyu CF/so9Mpghczpe7g/Vfty3FfLxbi5uoqZpj3VZcT0Qxwp5aZ9dK5JBQUT3UisYlbCEtu+yhjygAA AACgfeRDCEQtANpjmad34Q4cbooK2haBmfddvtelLgjjHgwALgl1HvzK02eHY4nlTejP5WaiKXIR K2RhE7NIsSEusBvw2vUAAAy+A/WhAGWhIJjqH/76n//hY83+TeeRcTq2QSo/XQ8A4MIoglj+eupt 87QrAGWMzTDLTXviszW+wGq2sWJXAKAvHPvsIMW3COwsRb8FXeHycIlamNiuc2zBaG2vS7lO87UB AGks8/TQ9SAAEoi1SQWh+29122ezXHbHdww2CdrmsesBABi4hOpVQnOtby6NuRfwtec7Fs5PjA1W z9/HmcYF0GeKoOW3Is3HOMbfLCR0EQpYrm676gD6CP4cMCaeqjw0X9vmdNt+6poWV79q/9gFAAAA ALDyLwB7Z4zTMAyFYVOGrnSCAaGurMwIcQE2dq7AEbhAj8AdOANiRSAWzsBW9rYiaeLEfXFsJwpx 0n6f9KiJnfg1hbh5enk/ohYAAADQJ7ag2bVvp8XiWc1m59u2Wfhat8ttWfHqVNhCC1JoYYvMVPG6 WpXCFqaoRblv9fiZbQohjaEyFtGIsfjZBgrsdznXmIrrD3++bM79Paf873U939D/VsrBuyIV8vdd 2xWvWAvBi42yi1ysc9uIsZrj7c+f5dLtshCjKIrb59vMdkW0Iu87mkyqfc4ph13gv4/j6znG/j7G Lvoxhs/gv30cg6BHzOPrOVrtZ77qa6rFUnGKVNCikr1niFdsq89pAYtc8KKiKpGfC5mpkR77YjoN cfkssRtlL3RnE7SQyYYhiSN6rO10qMA2AAAAAPSLDFJ9qrCHBQEgjNvE7lT1oS6ZwB9akLyN0IWJ TP53jQEA2Bf0de0ksY/EHiL60oTTxK6Ufx0IEaN1xfpcsT9Vs00p1g/IeIztAIDg3WjXZQKEFra0 mUu8ImScnFdZ2nX+wuHwFdsBgAPixWj71g3bGN9aUE0Oqze5T9O1J/Q9AADsA64YBDlIJfPYDgAI zALidfe/ru8t8juP757btc22va4fAPw8xXYAoCHfDce74ra2uEFoDLrJfABdMI/tAICgSZ6qLTYr 266Yaci1Wfa75vPFZKEfXPeWr4m99esOwCC5N9q2XDBbPrPs9z1f2rSQuekLwNCRa81vFC8Auucy N43ruf+21/uQ+gJ1fRLWDQAAAAAo+BOAvTPWaRwIwvAQnVLwBFQofSJxFQXVtVfzAlfei9wL8Qo8 AR0d1wMVEk1EwMaZeL0Zz5rgxHb8fdLIm/V6dxIrdjzZnR9RCwAAANgXdUGosP48s7+pjhaLS3l7 2+5OxSXybSFeoeVSzELFKlS4YrlcBeWqoEUpbPG+EcXIt+U4Eghq9F+QYQg+5gzFz10gwX6bY/U9 uf6wxivGPOyAiFu0B+IWn62C9tV5Z6XoRLmWOBSnKAUrVNAi3K622mpfsWhG1ecivPL88lJUpJKy W4nhVdAisJPAzLYJ+p7gX8fYN0MXEtAx9t3/2MUcjuEcDr3/NseozKBYC1VMJpNPoQqdraHCFRvL 6n7kpoIWUmSgU3GLSdC2Mvtv/VrHO5tOZX562sTNq/UQVrK7sC7ev3kLkk6QJ0H7rY/G2FofZZM6 AAAAAPgeXiTk5mBeAIyDP5ktxF7oZS36qjPrOS4uWwsHrAUEItVnLRKTA8Cxotezn5k9ZHbRoS+7 8Fv8uJzG+lLCR96i468uJD4R7hNQMJPhfafguMmTkrzW7PMSz4R1ccKasNzUVg37aOIHjI/83P/v 2gmAkXCf2a2zv0lSNO9eEJYtYQpL1CI+3jrO80eicvw+AAC6JBVLsOIN+4hBjCmm8atrBwAintJN Kni/c7wks6n2X33u5jkdwGcmwxETB1CsOLJ1X6m7/nttm8aBreO8MQDaYNa1AwARjw3bpf5X0633 f1wqjmr1n7qOw+Gpi33H51fr/h3CKYCekycsn8vuSci9+WbfmXsWlr25zAB9Qe8zd107AtAi12Jf g73ruDcH2bsnxO3ivmIf6l4DAAAAAMiHAOydP07DMBSHrQ5dkEAMDEgdEAdBLNyAA3AERkYu0I2V M3AEBGJGHAGxcoXyJ2li4rjPz1Ea4qT5PukpJnXs19L4Jan9fohaAAAAQF9ID67uMtvTDlou783h 4WJdrotK1M2YQngiF7awghRW2KIw87ddrSphC1fUojp2s33bh+3bMgZBhjH4mDMWP9tAgv0u+xpi cv0x99f/edf359nySMO5J/U3lPPvx6lTn7tmBS2KbSVQYdccF++hWn9cCVmsHKELK2jhimG4bXwZ //vxXabCeP9sOn+vJCROYfd5Ahe+2IXe9Ha/C44tgX3KPv67/V14D0Nuvw9Bj6F/BrvSfm02Rtnm ekaFHTed1624RS2TnCNe4YpezErBiw1VibLdmfM/tu0t5vMmLh9ndmbkJHiSoEUs8Z00McXWNUqd WBkAAAAA0vKU2gGAHeQms1PTfIFXKDl56LVQ3dh9nDH1+zIj7AcAGCt2HLvK7DGzg3SutOYis30j Cxz5ghZSWYsboQVj2rM/KVawsHi6XKd2AMDj1SlrSW38fX6SEz8ReSgJjp+EXKsbS2RGgszpIiVP IgkCQD88OOUmycq0On58kOKCJmLRNq74EEsAYFfo+vnCVJ9XnKR2AMAjJEQpoSWX1RKXSlvt/jt0 bRW6ruJ6C2CT29QOALTgI7BfG+elmCHFj1hM0mJT7HWAbTlP7QCAhzQex8Zad1/TcVu7T9B+v4v1 AcMgFI9ze87spXePAIbHpVOWBCWkeWSx+WahY5rMXQ7NWQYYA2+pHQDokFz46MiEx2Z/7nBXJvWj rXEJ/Q0AAAAAE+VXAPbOXqdhGIjj1wpVKuIBGLsiOjAxMSMhsfEA8AA8Eyw8AW/AA7AjNqYuDDC3 abGVOLm656+SKl//n3SKYye+K1RxbV38h6gFAAAAAA6Ba/GJ198quwl1NJ9fUpbtdpdvSp0fc/EK U67ELIxYhRGuWC7XrLwtaFEJW2xKUQx9rPyQd+PwLggydCFGTVfi3AeIW9Tpqy2b6/fFX3//nv/z td+N+L7U7Y9/vg2r385X40IWXNCiEqrQ9RmrWxXHjGxBC31cr7OyfVsQw7yrzMl/q3wuFrTSP0rs ViZSMRoLSzG8nYtYmDZt+j6XCIblqwuCFoemDz66LpjRBTGHtscX0//Q/4fevqkQnij8GOEKI2jB hStKU3VH2oygBeW70RlxizG71tw/tn0pO51M6Gw6jQnzqnA5ol1xC15nt5cfgcLJicSuN2Up4SRm Hu+rAwAAAAAA9WIWhV+V/TYcCwB941jZo7ITkudRoY3Hy+midS5tYm73l/JiAJL/AQB9gD/fnpU9 UTcFLQzXFC+CFKqzxwDfC8UknLvqwDB5aDoAABjfyt4jrnNtVhNqD5lrA/MUP/Y10jkYBm9NBwDA APgozEdo80npue8SsrDPXSbdE2t23HYZAAAOxXHN/aXkEtn1vrWKIa5jzJoOAACLr8jrfBvUhubq vrbQnNvnFwAgM1N233QQACTiErQwxI4D0rgjtbn6TB1vXGvNAKRw0XQAADBC67MuYtZtXW0klMlR Lz3b8fxtB771cGme93LwiABoP3rT8nPazRmT8sVCOcdSrnJqnrJUjl3nBaBpfpoOAICauWNlO2+Y l0MWylVOHSMwLgAAAAAAACd/ArB3xjgNw1AYttqhK90YUMVFgCswcAXuwMgBegPExA24ARcAcQR2 ZqQOBRoSt6+un+20IWmc75OsOI7j96iKnbj2+xG1AAAAgDbwTVDdxm6azx/NdHr2l5cBraXIRFlW Ck8UMaStIIUVtiiTWR+lsIUUtdjcu9u+tWFth+iDIEMffCzoi5/7gLhFk7byFWPoxl6+n2fb/3fW Zpvk/335Ec8C2+vSrNhEWS4FKKTAxdJJVuQilDbiGEXdjY1tvoXGxddi4fVfjSgkxSs0qms7QhfO PU0E+O9zAPu2bOTwOeXQPoIW/W//P2xsrcyoRIS0qKBjIUKxjionxCuk6MWoErwYu3Wr9kbib7Ht zSaTFJdPV+nSbdrsBkT1BUeNLSYxTn0TqBPLAwAAAEB7+DbgPXfkC0DOnK/SndE3edUJSp5yXmdD gPEcjXIOAHDM2D7rZJXeTB7BlK5NWPQoRSxJG3O0jWXGOcbm7RgrhkfxveyzWAzkx2vgWkqw7zpB MFOCjfuua3Z8/sKwee/aAYAB8CDyseDGWh23b3fFK0JjhzaOxMYXzb9QOeTLR9cOAFTMDrhXm5OG Zrjq2gGABELv7G5Z7Hkn5bkpVodnKoB63HftAMAefIp8yju2Nsfr5n3X3KM2DmlzxoxL0CTF7+f8 tgfHRKw/PvRdQetrQ/kUUuZqoX20sbtITyYuagUwBG5E3hc43F1HFlqXpgUtj61bNso5QJ946doB gIa5MOUeF4uvv9bKtDFEKwu1Y5y86492DgAAAAAD5FcA9s4lp2EYCMNTVHXRAyCW3aKqwIoNG9Zw BiROwDG4E3vuAdwA1n2Ao2QS2x3bSZTg2P0/aZTUSTzT9DF16swPUQsAAAAADI3ropPe/qjsIdTR ZnNL+73ZHRfQLgt3s3gFrzdiFixWwcIVLGZRtG23pqBFI2zxW4tiFMvGD3UuEp6CIEMKMRakEmcf IG4xpK98xRji+Mv3fOb+uWOf/+tv7PeLee4bf6WZghaNWEUpZsHiFLuAkMVOW5bH8X7cZyNucbAD NEQttsUPE0YQnhDR93EJV+iPrX5TKfCfi4+x+8/hOUy5/7HPceqvYerxc/+6j3omRSVCcVYJVfBM DBauqE21zQtjQQsqFSVqcQtl86p9xu3V+pkmlHGxWNB6uWwT8l3lckbH4hZ6m729fgrknpyoF75z iVuQsDw6rS3bAAAAAABAf3wXVyBqAcA4rJW9kH9CvzTOOtI9JHm85roBQG/XcY3RMP4CAKSG/h13 r+xD2XW0aIblXNkVuYWMXDcGdxWsDeUN6SYyInduAXnzHDsAACzetPU2EwmkYjV9iouHBC6k/n2x 2O3gNPlW9hM7CAAy5p3MgmkSbXJEKHccPObabueeUB7yFXZDHsmfz9gBAAAmzSp2AAAI9Cki2qbo t1RUNjQmd43bpe0AAJkV5SEsDk6PLvnIzgW+Mbi0zV5KfbnyDfIQGJqb2AEAYBG6RqvT5j831390 0vH2MVIfkn8wHXzXwqXX63XEWABIhUsq56C1nTvmm1PWRcyChMektZO1j7QNgCnxFTsAAEbgieR7 /4nM7/ou8477zF22fSIXAAAAAAAAkT8B2DtjpIZhIIqKMJMW0lGkoKbjAgwFPQ0FJ+AacIccAXpu wB2oaDkFFGESrNhK1mIl25kows57MxorkqVdTCLZibQfUQsAAABIjfaDxUNTo9nsxUwm01VeBgTf iEwsq7LyaONHO0EKJ2xRJrM+OmELmeQ5tp0UsdjYXa5td6UPggx98NHSFz+3YehB9hG36LO94V5P PncpbKZ4v9TXNEkbVmBisfAFLZaeWIUTqHACF/OizU8lXiHzmsBFXcii7Huh/o22aDQ6XuW/5/Oy sCkwvFZXldVunlw/rk6IWuxKzKLvAez3YWMI1wkxh/1c49T9p/4fpmYv18jlhT1tBYcUt6ityKjE K0ZO0MKJW4jjkciPRH9G2LDl0/G4jdtnRboyujiFJmjRZQGJdEdbfOiXxfIAAAAAkAf7RYQVtSCA IkAarot0b+JigZp4YKysjfigf/QfW7WNCCZSBgDwX5Bj1GOR3op0ksmXVNwYfWyPbQTrWtdmw1hs MzEcDqdFus3tBIDABiELBb5pCkTTFPBGBh3vGlxcO1+z4dsGsO+D99xOAAyYV5HvGpwsNO774702 XzSJXMTmEy3QZWw+AwAAOM/tAIDCV6Su6XndPzfWRrt3atNvk1/ccwHUecrtAMCWtA2i3mY+CX3v 67+OPfOH+gbYNZe5HQDw+NhBH9rvbbIudI7WJvSacblfhObhZ7Od0CLA0LgTeXXrq/m7piy2Djm0 zzS2ri0UwBygL3zmdgAgAVb46KLKx9YNt1lnHItBoNWFbEr8cuYPAAAAgAPnVwD2zl+nYRiIw6aq KlXqxIDYUEd4BSQEYoORgRHehKfgPZDY2OB12BhYqiLitm4u7jn/SLGbfp9kEtvkfI0grqPz/RC1 AAAAgC4JvWyS7bdZuakyNJ2emfm8aC5PYr0sVsAiF7LIxSycWIUTrnBiFrZtNisKWuTCFrkte3Si GV0lBd8FQYZd8NGyK362gST7XY7VXzGGOOP1937yf7eNMbsasBifJoWmnMiErVthC13AIheoKIpX +G3FdntcCmTMV8fc7rJs3lfry2RyuDj/+l7u89lI3C6TnbtzIVQhxSqM1784tT8GA91OS/qQwP4/ xuAzpGE/5b/3XRD0SMF+zM+wjqBYiVA4MQoXeeGEK9YlaxvaItqGq+L6C2oT0p4QyjgejczpeFzH /fOVyQOzmfxUtvn964/gXaMl1TOiXrgtoi6P2m2s0wYAAAAA3SFfjrxG8wKg/9xn5dqEg/VDAoSy rq3L6iYs19qNd/TXX6zHACBF3LPJJtm3yWmfIvqyTa6yMjHhDV51NghrG4ZD84Sp0S5h09h+8Rjb AQCPt4r+UDBBVfLwsoTlVUnIfzx7vt0q32C/0JLgvUfyBaDvvJjq5JVNkk/684E2V1TNGfK6kC2t Ln0tOwcASIE27wmIJfobJKyFlKn7XUVbq2s2Qmt6v17W18Y/gH3mMisPsZ0AaMmn0tZkLtD6tHlJ W7uXXVN3fIC2nMR2AMBDe0+rPQ9Dz9PQ7zb5/h9aE4TGgLQIrQu1Psvz1j0CSJ+LrBwZPR5M2/vp x5VpMcpNYpObxpzx3hdS5SO2AwBb4E5pq4onLhM4alu0saQ/2jkAAAAA7Bm/ArB3/jgNw1AcNkVq F9ZKbJ3ZuiBxCxYOwMTEIbhKxQkYGDgEQtwAcQQWhqJA0tTJq/vsJE2Dk/b7pKekdmK//rNjy34/ RC0AAACgS7RJqLuqmxaLZzOd5usyZNDoUmSiFJzIhCysEEUuSmGESIVZi1aYQthCmr3G3idFLMp6 f4u698EQBBmG4GPGUPzcBYLs77OuwxVjiFPf4X6e/O/2XV/b38rmWqWyT873BedlJyvBCXtMEitk IQUtpC3Ta5arc3uUeeV54pRjhS2SrfckP9fx+Gx1/EkfKryB1ZX00LWa+EV2PhqNtvKacigB7An0 X6+OLsvuu/9d+zh00ZMhfId1ynfr2FgtYdtQJ90eT4UIRbFqI2tr12ZFLawQhs0/cdLNOl36kKXP JpM6b+Pc5BvLtCComqBFk0Um0p3QohVfMDxtkSIAAAAAdIu2qespki8Ax8J9aldGD0oeEhEMXeOO 4dwNZHXHc8boYzPGagDQF2QbNU/tLbXreO78C5kYktaeh+bufGIWTTaWGeW1Lw2Og9vYDgA4vIrz qqAzVUFsdrVQwHK3fuPJ0/yF4+U9tgMAB8h3ai/idSgIWqhtDvUFsk9oYu79vv6krq8AAEOial4h FKCmyb1N6x06s9gOADhUCYtJ6j77VAUtDT0nEbQWoB0PsR0AaMGnJ72q3wj1O8bJ980Ha2Vo12j5 AG2Zx3YAQJDN1frGCP/VHofKDpUJ/cfX/z6m9hXLKYAecSPO2wYe961t1ta2heqT/gAMgY/YDgB0 wEVql6a67TdGX4tcZy9Mkz7ChT4CAAAAAAr+BGDvjHEahqEw7AId6IqExMqMxAUQMMMdOAJX4BKc hDMwc4YyssHC0qoQ0zh5cZ9jN22TNHyf9FTXMfarS23Zst+PqAUAAABsi9Cmk8y/z+wuVtHJyZlZ LA4reS6IdClm8fNnUtjC2nzui1csCgGL2awqaFEKWzhBjOWrFM3YVQDwfRBk2AcfLfviZxMIsr/N toYrxtBNe8PtT353226vyf9K9SybFLRw4hK+oIUVnijFLea5cMVSvKIUsqgKWzhblvEFMEoxC3dn edlG6HMaMx4f/6U/Pj9XC2gB3XOBCvm+IlThp11Q9oODatk1GUIA+zbaGEI/IebQTh/vuv59/g77 9jsqTlA4cYpclMKdtHDiFYVleUcifZiX8fMKtYm83lFet6v3dDw2F5NJiotXeZUjsypuIfP858VH MPrhElnOiPeyW2Q3GS/P78aUPAAAAABoRt0myktmX205AvBPeczs3OiH+EMH+uXy0F+bxdZrKRfN fNYNFAYAsGvkOPSU2Zv5H4H67NkX7TJY3QWx2IXiujLaRbTQXGFEGRg2NuDNZddOAAheM/sOPKsL ginztCA1oYDldcHGU+qI+QHgmHbtAMAAsYIWbs5ICWIcG+sXSjo2R2hiFtrfxerRfNXSAAB9Zd39 A22Pmj2IeghYC31jHVELS2jt7D8LBamVadblANvlNrObrp0A2IDQfrIldS7Q5hrtWajOJhfe6uoD SIGxG/rEu0hvMk5uMh6nrBG0PMbjfqHt6Yee2bPQz204BdBzrjM7NavnwSxawPHYvdGmJgndNfXT AF3hz/vTLpwAaIEHkdbODcfMF7ZInQ9C8Qa0eYM5AgAAAADMrwDsnTtSwzAQhhU3aSkgJZMDcAZO wQE4DKdIxQWoqKgYLsAMHTVDnYKSDI/ItmJlI8mKH1HsfN+MxvIj0joPb6RZ7Y+oBQAAAPSFa/Lp uu5Fi8WDms3med1OvF2JTFSCE0bMohClUGJrRCuUWq2k0EV1rhCzsNu3+/3b9N0XQxBkGIKNmqHY 2QSS7HfZ13jFGNL0N973k99d1/3Ffle245OkoIWsbwta/OSiFZWghRGo0KIV35agxWpTtwUu3MIW ZvsbYXshyPW5XO713viY2GIWZdk51qTNHjlEAnvTz9DbH8M99N3+MQta8Bmmbz+mj61oCSMMJI5r bHELE6GRi1Zk2Ua8wlyTGUGM8thEHDftlQbmRYtgXE6nMbekgxD1mNmV7NQlaBGb9M6+5Uzs113v qgMAAADAYbEnmx5TGgJwAmhFwju1K2xRtxjMV1zjN9cCs5gFA8qxVZ59AIBDYD+fztblWRWiFqfC xbpcqWYLgdsuJJaxOHWLxVz7MA5uUxsAIHi16vsmnPElugwlEpcJyGVS8lCR9pAwE0K8pTYAYGTo JMpPgfNtEiNLHyGFK0L+IiRuIfv22YovAYAxwVxCd8xTGwDQEN9/m7oEtKHxt68d/kcBNOM+tQEA LXi36rG+wjdOD43ZfXMLLl/l8134KeiSeWoDAAQfEdc0fR7XPWt5Hp8Gvs9ci1p8pTIK4Ii4Kbeh 9Zyx8WghwQsZD+1r34Y5YjhmjD95SW0IQE+cq8pHaFzxwbGxyL71KqHXy3MSfAQAAAAA5PwLwN75 4zQMQ3HYoWWBvUOXglgZGZHoyi0YGbkE90EcgZ0zIEYkFhYGqlLiJk4cJy9x+gcn6fdJT3EcY7+Y EMfIfj9ELQAAAGAXSP9ssvNnsd03VTSdnqvlsviJYoJg52IWq7XZwhZG3CIRq0iOWsxCmz5fLGwx i7KZn7dFM7oZ7DscffBR0xc/N4Eg+7tsa7hiDGHaG25/8ne36/akZ6W8Zi0pt0rTtqDFMhOzMJaL WJi0Ea74icf3PJ2LWfxk4hZGCKMobLG02vn1ErWIovH6+Pbx0VRQFQQp7ODn60NUzEuDpkdHR6Wy bYQthhLAvu/30YVA/9vW3fU+2rePfRD0CFm/aWPf9W/aRraCwohTpEezwsKIWRQikKbCFToS6Sg9 Hzt5mdpERb3aJsfH6vLkxMfF67TKSJXFLew893p2C6p5EaKyzu1usbtJOXluN/rkAQAAAMB2VG3w ew7kC8AhoSdvj7FdqOaNXiMnLc3JquZ37gYx3wDm0pyNeRkA/Cf2O2ce21tsN2FcCcpctds47B6r Noi1FbxQqvj7kDaQwTC5C+0AgIUOUP7qUU4KcCNd39TcOpracfOlczhM9HPwEtoJgAHxFNt3mm4T 4NhnjJAEjzYRuZDqrRtfpHsAAOgrbdYOgcwstAMAHvjMj33mzHXBaKU66spUfXfxnQWQ8KAYY6Df fDcXyagbg6rGjbrxSKpbKsO4A7vmLLQDAA6fLcq2fR+713gfDx+f58Ckv1QibAFw6FzFdqqaA4q7 6ao9o9usN7PT0l5TNw3QBd5DOwCwR25jm6jq97gkUCSND+7aZelaXbwBxggAAAAAKPEnAHvnj9Mw DMVhw9AJBEslBgZOAsxMnICDMHEDztCBAzCwsrAjcQNAzN0RQiUmduO4/pc0rZP0+6SnprZrv0ap nL7Y74eoBQAAAGwCV9BJPlgMZvGczZ7EdFqupzOTbFciE5XghBazKEUphPVaiVdIMQtT0KISthBK zMLs3xx3sRx7mwxBjGEoohFD8bMNJNnvcqzxijHkGW+855PfXdfjmddKfT1SvU4LSixU3a+q04IT pgBFJWahRSxKkQopbPGtxCx+/t/r49L056q+tECGtiZ8zedpDWVSdkfZShstcmEIXJjv48MMP4H9 NsYYw3lCzGE7PtJ/uP++fYfaagktHmSVS/aVSIUWo1gKWRjiFXYbLV6xZ5ZrISKjb6Han04mKS6f FHYu3IlQXYIWvkUkKQn0RKSd63SxqAQAAAAgL4+i3MgFAJtFPs+8LexQ+JOQu5KSh4QsQuWuTWcp m8ns/2j8ZwOATWPHh+4Ley7sKI872bko7ECE42opsTqXuEUsXheK4wlPGfPEuLgWu/vbg37yGqiL JSwx2/iShduJxc3k5KnJx119+fwFkJjXyVtORwBGhEyQ9hKobzJH+MwnUuESvHDVu+pC/gjrGAAg N8H9OmtAXKEdZ7kdAOgYX6JZ1/1QKBlt03sn7rUA6hwXdpfbCYA1+eygD/emtNXXkMX6Buiay9wO AFh8JLbz3d/bdanP+3xtfH3DsPFdBw/ZPALoDzKee6WOQ/s5Y+vKfOuaY2uT7Tob4sLQd94F+2tg vMg54sYqazpHtBE/WmeOYN4AAAAA2DH+BGDvjHEahqEw/FBQBxgREixIzDB0YERihYE7cAOuwMIp OAYTp0BsjByAiQ0EKU4bt455TpzQJmn6fdJTnJfYfriiqRPn/YhaAAAAwH8J3VBy/dfGLqsa2ts7 lDRNCj6b1HohZjGZmitsYcUtrJBFtrVCFjNhi9SU0/nWCl9Ys/Vd0YwutRDWRYxhHWLMWJfxbAJJ 9pfZ13DFGLrpb7jjyf/dsvtLC+IWrrDUTNBikvvTXGAie2dYE7SwohRWqOIrt8/pdiFykQlczIQt rPiFrbsQxPjO+44XtEiSLfMb42Na/v6pJ4KhCVnMBSwK7oVfrac2vdrnfm0lsO9bkvwm7Q/hb+hz +20IevR9DDah/WX1MV9BYcUpFEGLgnCFSEHcIsn3txVfISNpvm/7OxiN5HQn6r3xc2PbeTU/2anr 84/bRSKhxKnuIhJx/O6wuMMkns8fxhgfAAAAANSnKqnmY1uBAGw4+8buZZasPCRgkTjb0FwsNDer mrf5czQtebnI37kYczMAWBXu98vY2LOx245i6RMXEv/ycJ2Xv6qEbEXZD/lgmNx0HQCAx5NTrlpx EJPExvpDCcerfGXtl8XiH4PNRPvs39oOAmCgPDjlmKTHZedo1wNNuEKzsjpNk11qcQIAdMFR5Hnc P2iH464DAGiB0G+2uscAIJ47QfQY1p/3yPNCic5D93rdclWidK1eWR8Ay2DcdQAAHq+Kz78XWvZ9 2OS5oFY3dh4B/Sf288v8b4KwBUDGlbFdqb++TFtj5otZaOIWoXXKIn/b94/7ZYA+8NJ1AAAr5MzY iTS/RmjXi7J3WOpeI3jeCAAAALDh/ArA3rnkNAwDYXiaSq3EilXFCvUG3IADsOEc7DhFz1FxBw7A BViz4QJFbNnQBvKwk4nxxE7b4Dj5P8mym/gx6iNTW/b8ELUAAAAAwLmxLUzduhptt8+0Wq2LMg+o XYtM1IITWsyiFKUgI+diFrpMRd5MadEPF7Gox/2pxg5JDGIMMdioicnWriDI/jnHGq8YQ5jxxvt+ 4nd3llHYeGnh2/kZ4fK7kyohi5QJW5ipKWiRC1Y0hS2aKb+fC1scDrreXvXB+9wrcQs3i8WM5vNP 2u3ei9ffkqgFD8ZuE7Jg5Ubwdlau8iRxBniPPYD9WMaIKdB/iP71GCHbD6H/qX+Gffff2Bmhn6Ps eqKuaXGLKjKpFq1g4hWmAEZRL3smJ/q+qjNT/VSWq/rXy6WPyVdUzqFtAVFtghY+Qe6kzSjkqGe+ XdhgAgAAAAAQBr5K8xTMCgCmxzpLG6qFLXyEKkyBC3NuZxMvdB0KIJLnazwn4TUAAJyCuR70mKXX LN2EMWdw3FH7mtoxh8Z81/TMcSTgF8bHZZbuQxsBACMPdiMFIDMD0LhEJXyClHdJrnY2WwCwgSAI AJzOG9kDpHHMwGbHPO8lvyEJW/j6Gps9ZJTJKAMAQCz0va4w5bUJBKwFQ+Sr5Z7PfxtbMFrXPdf/ J2meDgD4S+5bIDoOxsCH5ZrLD9l8ho8/ss3r29pg7Rj0yTq0AQAwfAWGTNrWTc06JOS2uUOXPkEc SHM//jlv/tsoAAbIBZV70HJ8zntK+8wkcQvfc6bSHrQpr++COHgJbQAAPfNAtfgRUTcf0SXugM03 SG2Jmv5BKgMAAAAAgJHzKwB755LTMAyE4UECIbFhUyGxQV0jJA4AByjbigOw5CbsEJdgzRGQKg5S OAKLSlXbgJ3GzWQY20kbyIP/k0ZxnNiZRmomD3t+iFoAAAAAYBd8L5J4/Zmx+1hHg8EprVbFWxOX CD0Xs/hKjQtbOHELJ2Rhl7mYhS0nqYCFrbPrtl0ufpGYZZKWuWhG23QPuiDG0AUfHV3xcxuQZL/O Y/VXjKGZ4/X3fOJ/t3XPhbITlVqLW6wKQhZc0CIvLze2FqaQNleMC1ssmAjGotDf2jzCFILDwz2a z99pNLqiyWRC4/GYPmczWvqELSjwFU4IV6TrMhl9Vqe1y1e7n8D+L47Rh/PUh/4haNH9/rv6Gzaj Kpw4RbZ0IyykcEVB5IKyDKWmvG8FLVx7pc0e69faycEBXRwdlXHx2th+1kxLeKqJWxR+gmijDUok Vs9PCz9NJOrkaSxTBwAAAAAAtkeblGcH3X804w4A/5KhsQdaC1v4Bvr7nsFC4haxgf7aMxyJfUhZ yv0AAGAX+HVkaOzV2GMzrrSWgbHzrFx1wtc2E8Vk7HBoE8aIfsYCxIZ+cNe0AwAI3lg5lAxMq9eS j/mSiZdJWB5LQC796e8gMlA3SIIAwO68sHKZhMW+fWRsSOhnnODbYiIXVWJJzEcAAGgzsXcCdSab wfuHnOOmHQBAoeq3Zt8ztVwPJawN9V2lHgBA9NS0AwDURB1jn3zvlOU2viTRRtsWqisT3wAIcdm0 AwAwuKhF7Lrn20duC33/Cx2nCrget5+y3wCsTY09/7ZDAHSAG8oTllcdcybrZCJzX5vQXNLYODS8 AwZtYtq0AwD8Mnac8m1W9l2rteu7Fit8ps1f8cUDonhMQJwAAHSZ0P04AAAAwbcA7J1LTsMwEIZH WaAUCXVXNizKDbgBV6lYdlFxGNj3DEgcg+cKsesdKpAoVUgau3Gc8aNpm8Th/yTLJnHsSSLhemLP D1ELAAAAABwSzul0l6bYdtF8/kij0XhTVoNnFyITheCEFLPIhSlIy1UxC1mmTa4mKW7BiWXI76Jd 1D0IQTgiBBszQrGzLvVv7b8H2ef66q8YQzv99fd5Qtxip9ZK5WL8TYSIRSFuIcuFoMW6JEJRiFKs hGBFIWKRJD+amEVZ2EJem4tg/Ip21iK5b3YwSGi5/KTp9IZmsxnFcUzD4ZDeFgtaKaIWXgHZs8Dw WRZFlePb3CB6Ua5+XB94UwHsQw2Sr7bfh3vocvvHfsahv8PQ7ZftH7KP0ioN0Xak9CHPR0K4Qq66 2ApZKIIWkfa3LJcilIq2S18nRZ2LkxMfk8/TdE180FNO0EJfVLJL8Dty1CNLGQAAAAAAHAeXY+Kh ESsAAJIx5cIWZ1RduG8St3AJWrgECU0bA4j4OZuaq2D+BgCog+7/maTphXJ/FaiSPRffDb7chi9u Qxjn4+Pa5MYDouo7BP1i0rYBACh8p+nJo54ruNi+yRaY3GYHMXVMxwB4b9sAAALmOU0fjjo+44JL hEIXuXAl1xhiS7rdehkAALrEIX0ENn80qHLVtgEAMJzWvM70W8e2GaJOcFoAgJlbwrca0B++LOds c2+urukY5wPm/NOmuq6+AdgVzA9A13D5bDm4b3zqOVs9lw+Yq8u1DcLCNA6r7/y+aaMA6CCZv0bO 93z2e3JrzHz2lfruO9WBPxh0mde2DQCgATLxo0vy+x+uxxvwiT3A7VuxCSJxYwbGCgBAaPj+Ft73 GgAA6DV/ArB3/jgNw1AYfwXUSgWJDh1gQRwAiZ2BAyCu0YFLIKRKHIMFMXMJRpZeoUt3VCEGErCb uH11n2M3bZo//X7SUxw7sd20suP05X0QtQAAAABAXlyLKZ5/T8mDsUz6/XOKouXbEhNMWhKeMMIW RtzCCFXo7ULMQqdjlY5neUbIwohfJPvJ1m6j6tRBkKEOfdTUpZ952CwAfb4T6x1k39dWc8UYymmv udcT4haZZ5Ptg5T8Dv7SdMzSUSps8ZsKTkRCmotSJEIViZBFYlH0YwldLItZmHONQMY6ghbdbkyT yScNh480GAzUfpem0yl1Op1Z+dd3ln/1Ki0uUMGDrJt8ybQABjuu7gHsd9FGE64TxBx2c42Lrr/o 77BomvAdzLapHaRiE2ZrPCsOU+GLpWijav9Ijb/zMiZoccDyljw8WL3aztptuuoGvRd6Q0mA0xat BjrleXb5/COQ2+mEC1qYfH5ZiO2TlUdCuS8PAAAAAABsDn+w8lpmRwDYUy6VPSs7oVVHf3v95RO3 cK3XQoUtJOdXvEwGANgG9jjSU/au7EXZaSk9qge3yo4p/GUxEvKkcd71Qph0vp3PwYtjzUIHu7ku uxMAMLSghevP8ZBgMyEBa3wBzaVA5L66Xf0AwIX+fSAQAgD5eWPpPMHIpPE9dqSlMpdohU/MIqt/ mDcAAHWmrGcD+/hMold2BwAQuAg8Lut+x3ePFLI+z9MuAPuMnlOeyu4EAFtizNKh4740t9h1SOt5 1zlS25iDQNFA1AJUjbH/kDlZY6adltYCdtk6bWB8bgZZ/9GOlH3stjsAVJI7Cvc/ywo0HuKbLNVB tOqDBr8zUEXse4tRiX0BYJc80MJXmcg9N/jEK3xxB3y+zxJSOeYMAECVcI1rRdUPAAB7w78A7J1B TuMwFIYfYccaJFZ0kLgH3AAW5Qqz5hJzgTlBNz0CF4AbsGWBWDObUZFQxVBN0taNY54dE7VJHL5P esqrG9svRYqx47wfUQsAAADYFtrC0s+6SpPJrRwdjZa+nSjb+KvE51IRs1iJUohztMUsjC/Lo21G 3KJsv+zDrF2vxDP6/4w7BUGGFGIsSCXOJrSdYN/02SaIW6Tc33B/T8QtPtWo+NW//UIRtCj8lbBF IThRClr8c0QpqkIWpYiFLWhRCl7YYhZVQQsjarEIXkWW7cnBwbu8vj7KdDqV8Xic/2/xIfP5XGaz 2eaa/r69xf0soeT2lsjFxkydLNv4Wbb7pR2S5PejjyG032dBixQEPfrQfsrXkK3j37P60SaxRqjC 7MDYX39eCloUx3XZxrfOqWQmtfsrL3D53claBKmG49wuRE92qglauBtKvrKBUTzlvoR4PFAFAAAA aA/tRewiieJDN+EAfGtOc/ud25nom/h9c7dYIYtYYQsRfY7nltswhwOAOtz7xFVuT7lddhBLipw7 n7Wlx6YvHIfW+9x2tT5hWNx0HQCAw73l+xKRaGW+JDZ1CcZjk5THJCZvvjEKvgNagqXnjmIBSJ0i EdWfmnNCCY/rxIwWUh0XXHPHDfe7kDhGaEyRgA8AkDLaWgLrC80haS0MEd8cu2k7ABDHRBAgh+Hg E0rW8CU4j/G1ufxX+mCsgm3zo+sAABxeIs8L3RdDa7ta3ZhneFr7kB6hcVpba//VRlAAPedQyj1o of1mmoCF6zc1u28X9iVDn7nrOgCAFhjldi3x9/S691RCZdsaPxgrAKBLfO/XxdYJ3fN20TcAQJL8 F4C989lJGAjC+BBCSLjogZD4CsZH8CBHEw8efCcfxHjE+AomvoA3zz4CaYKgFruULct0dxiwtix8 v2TT7nb/TCV2yzI7H0QtAAAAALALmh8ibrJ0vamjfv+M0rS9VmYDQq/ELOZLoYmVsIUVt7BCFea4 ErMw52l2ni7KrJCFFb/I8/lxXdyCSnbEIHQQg50x2GiIxc5dOPQA+3bM+saq9+b2X7Dgr+NB3MLT kmL439ONt+5f5ApJ5YIW82V56ghLrAQt8rKfQtAiF6n4YkIWrpjFlJ1/lurm4hbfRb/5WLKgRbvd om43oZOTKY1GIxoOh1lf6ULUIkkSGo/HRZD0yWyWN+LB2Z18yxWqsNd8QhahOrYP3zgVUVcA+5iD 5Nv+Y76HGOz/bxtjFz2J4TPU9N/EZ1zyzliKTtj8QqjCEbVYO7f1PXnbT+G94fRr0qDToYteT2P6 ZZY6y2Y8AKpbxq8Xt0Cyw4n9w9hycsqI5bUOiVJdAAAAAABQHQ9NGwDAkTLI0j2VhS20ghb8e9om sQu+CS0kbEHCkQJ5AAAwcGf50yw9Z+mJEBxpG8yGYmnjgu+Zzpcn+UYyaaOZ75nPP0vMA4fJbdMG AOBgApS/K+r5xAE2BRjTBDXXBBwPBUiRAm8epuMYqIKXpg0AIEImWXp08tpAlLwsNCdwQYs5y2uE LjTzicZWcNy8NW0AADWxaW0Baw9lsL4G9hnNO40mCHgoSK3UXvNu5dtMgfcwcKyYdWGIkINDQrOu bJDmk22Do2vr8f4BqJKrpg0AgPHhKdP8jub7DiD143v2Smuvu22sBjEgzc8mGPlr7RYBsH/ckd8f TPIh85WHfJGldpLvG9Z+wb4Dfw5wLJg4fudU9hUO7TkJ+SVrrmvnD2JH+C4DAJrG9yyS6vn2YfDr Uruq7AEAgCj5FYC9s8lNGAai8IgWVl2WXVWKegAkLsANeoYeoZseoZdgVYl1N931ND1BpdIFCwpV Y5IJjhl7wk8SkrxPsuwE2xkREifGMw+iFgAAAAA4BZJj/ERrNJ2+Ub8/2JTtoNhbkYmt6ASLWcSi FOTktpgFl2mT24nFLbJCFtng2lJg7roIHdTBzjrYaKiLnYeAAPunPFb5v5Mmf5/x8SBuIbSkel97 2TVl2zE39guOzzcLSvyl4hJbIQtOLEJhxCxWG2GK9XqZbNsCFksr57ItgPGbtOH+VunxQnS7RtTi i8bjIc1mMxqNRhvbWdTCCFrM53NaJmIWP4uFvzMTuF3Yt1PHEa/IbHc61IlSUWIWfMyiqXuQfD5G 0f23XcwB51Dvv0iach2lZSvn/W7ZwEIVZptFLNJEccRRU750tlncIo1Imnx/mX8akzo3vV4e802w 1AnJQU4lQQt34WGehYW+gKhuewqUAQAAAADA6dEc/d5LtAUAkMWoFBphi3vafQ8LiVZcWHlI6CKv sIXmEGDn5NkGALQXaW7nKUqfUXoo35zacxulgbBfmk8LOYLtkzq0ex59ThIYD5rBIyEYJjgvQkFF 8gQCDwUPd/dJgcp97UN9hewFQAMBywHYn48o8SKqvAGNQ0m7/+cdI9w63C5kg2SrVAbt5LtqAwCo CG1+oe3zD8OqDQDgCA59vgk982nv5XhvB0DGiJG/Vm0EACXg3uuPGRfc93h3rljqxzePfJhTHwAy d1UbAICFJGixD757bOg/Ouk+7PuMlLqgHmjjrlv3pXCLADh/rin2JdXWnEnrz0I+pfv4mxL5151p a9IAqAqs5wBt4jlKVxT2K/GtUdb8Vdw+Q/0z2tgBAABlocU+8T33avc5Xz3pM80+AABoHP8CsHf2 OA3DUBx/FVIrlQugLqQrN4CZiYlKHAJxEibUI3AHJiYkuAAbKwsn6FBQSSFu6vQlPH8kJXGT/n/S UxwnsV+U1s6H/f4QtQAAAABAWUwPRzw/SuzaVdBoFFEcH+SCYOtg5hsxi5+VcWELLW7BBSs2YhYq vUzSy1WeFrLQ4hfperrMi1u4T7wtQgdt8LMNPira4mcV9jfAfh11hRG3aLo+iFuErquN/738OCMu aKHFKyRBi6TXXqe/mS2YKMVGsCKOPxP7yq2nQhZa6IKLXCyYOIa22CloMRgooawPmkzOaTqd0ng8 zglazGazv6IW87m5wIJYRU6YQlpn+UrMIjtGEsf4B5oIYK/raXv5XTiHusvfZUELXMPw5dddh+81 zkZWrMUm9FLlaRGL3OgMJnCR7S+sZ+WtrcfKVXbU79PJcOhzKqeUBjjtkb+4BQ90agqOygeUEMsn lkeFdZ/3AbY8AAAAAABQneKErvfEHsK4AgCgVNjiNrEzkp+1TM9urrymhC3wzAbAflNsA6LEnhK7 IwTM34YLck/65W2zbSKYNJnMZwIFUf76os3vFpehHQCgwAtL+wQRMwWxKeZLgcZdwcldZvOluA0A Eypg+bZBngDYJ9TgqUfLdpcohBTMTOoflhWseLxP32HzFQAAdonD0A6AjCi0AwDUQJl7IZ99bfdd VeoEoIvcE77dgO7xZsi3tfnSM7vp3S9ZllLapz8ylQWAL0qk6Di0EwAw+PcO0314mXe4rm1S21ul XcW72vZj+i0oeyZ8iwNAcUXyOGDJTGOJfUQubMe7xqQBsGu8hnYAgAZR81huyNxHmNr4MvNWJCEM n76CSO4v0IcAAOrGFgPFNgfDtK+rrZPKJsN+Pn4CAEBr+RWAvXPXaRiGwvDhMtA9qpgqeAMkmGFj YeA1GOnOgDrwArxAJR6Aiedg7Qg7Q9UBCSIodhM3jnPsuKS5/590FMdJ7KOkjVtfzg9RCwAAAAAU hetYehR24LpoOn2h4fB4vR8FL9eFJpK0ErOIRCkotZX5iZiFSlNK8EIdl+WkhSz0ANv+Qb/bInTQ Bj/b4KOkLX7+h34F2C+7ru4KMeh1Vltfd+9p9797S62+rKCFmU4LWvwwghahJmwRiVZE4hZfmrhF JGKRCFvoghbfsaCFKstP0GIwWNJiMaPx+IYmkwkFQZAStAjDcCVoMZ/PV1uZJ1mLWmg3PSNg4YMe kD0WtTCFLrZJVQHs2x6Ivy+B/ovWUfT6su9BmVThf9OfoU/5dT3j1IhjfF5mpFCKVIh37m7spy5k oYQuVibS+8a+ErdYRyaNy0iNQMZljqRyUj6Hws7JHex0h9LiFq5Jh64JjGTJ5wZrzTQAAAAAACgP W6/OU6VeAABM5IKAO2GXxAtV7DFbLs9X4CJvERq3eMy1mAz/5wDoH1xfzr2wV2EXlXvTPU4pahsU tsUProURXJ+ebd9Wtl63js/CMdBcjoRd1+0EABozYR+WYz4BwWwByvVA5VyQ8bIELgDwQX5W3up2 AoAW8SzsM07nBYNUaZf9MmmzveCEkVyCFr7tDOcrlwYAgCYwqqAOrn+BC+DA5QMAuovvb7688wEA CVLoGP3CAPBw/cvcMSK+zdm0HUK7BYpyUrcDABjYxvlc+Iy5cX2q5jvbvI4rw3YOaB+u/4Tcs34o 3SMAmk9A0Vw+nzWh5pwzl4jFJutNiezzzDAHDTSRd4IwEugXZ8KuKD9mgGteMrdGxSZssYkRZdsK YvYBAGBbqPfLrZHHrbcwjxc9xuWb9dv8BQCATvAnAHtnjNMwDIXh10iA1AUGBlY2BhYGZhhZkDgA EkfoDTgAQ68AEjdgY0RiZGCDGzAxVB1KpRCIm5i+OM+xQ9uEmP+TnuI4qf3aqnbs2u+HqAUAAAAA 6uAzUDpN7cRV0Pb2DsVx8VGEi01oIQtlXNhCi1tooQp1nItZqHSSppNZnhayyEQwvn5EMNSxKG7x uw+jK0IHXfCzCz4quuLnbwg/wH5z9YUsxNBGfVmd4X6m4f32in5lffp8PVlR0OIzF7OYC1kkSWZa 0EIJUHBBi0zIoihuUbQPli6KWdQVtOj3E3p7e6Lh8IoGgwFt5IHHtahFHMc0mUxmghaj0YjG4zFN p9PZPe9pmiM+QAkB17mABRev0MHQZ6dRVBTIWFJQ+K4LNejyEejfXf4qWYb/IXyHXS8/hPdQ+zW5 afGKKBemkCKSRuw+LWARMeELfm6W02N5qr6d9XXa7/fLDpVRohZr+cukQKdc0IJf75HlLVB5YQmx fKJy9+XabC7l409VAAAAAIDFsG2q1vl3qY2acwcAYEEtfD0nWWhQMnOMVkfYwneTAFUcORi3AfA/ kBbFH1MmZnGZ2mbTDgWKmug7JPfmXp9NXT4byGybH6TNEGjvu89Z2w4AYPDI0nUCglUFF/MNYO4y szzTnzAXfoFVIAVZemjJFwC6hgqIdl9x3RVo0tU/SH2EKXThI1yRGPWZvkm+oh8BAIAymHeQOWrb AQAs7Dmu+4zzq56J8LwEwHLYSu2mbScAWBGvFddc43SeVxX43DbfIM0bI4g6aIKDth0AwOClxr2u //182mrXPKurPQfhYvbRt4Sg5AAo+NyitDbMDEIurT1zrTerG6yc+wLAX0P1Ic9tOwFAw1yktpun be28bX+L73028Quzf+BI66Zt5wAAsAi8HbpObUjZentpLwU/t+W5np2l9q+qTMkHfg8AAATBtwDs nU1Kw0AUx1/bbAquuxLEpbjwHF4hpxC8gCvXrrsS3FbwBIIHEPEK7gQXpRTEQtEZp9NMhjcfSWs+ xv8PHpnkpZmXls7kY+b9IWoBAAAAgF3gHiQFB19Pp/c0mRxv13Wicp1kWwtbmGIWSpSCrKUSsygL W9B2mzYtblEWsvje1Feuuw59ETroQ5x9iFHSlzjrkF6C/fbqS1mIoY36VJ3NVghxizqxFGXzPyDF K6QQhI5XiUrIsha2KIQmODGLwgoBi/WaE7VQ+xW+QtgiVtBiOBzQePwlri3eaDabUZ7nxnkoQYu1 uOCQohZSzGKxWNByufwVuFitVpRlGb3P5/6vyky4botTWMnYXUIXJduBphLYdzGJfdXjp3AOXT5+ E4IeXf8O/sPxu/Ibl94Cbj5jlyVamEKLUYxMI5VtVJYza12LW2yzkRrHMOuWvsONaFKACal7bV+C 0wGVxS1CAw9dAxHJsd31AtX1MhUAAAAAAOwfbmLfXUuxAADK5MIuKSxkYS5HHn+MoIXvfs/0EeM3 wT0dAOnC/edlEqQbYY/CzhqPKH3OjTLX9oYmFMdOjOCe59l1kuVzrYN+cNF2AAAYfAp7jtgvlCys itmJyUMJy31xELOPaxsANq9tBwBAT3gwyr6EZ3Y5pp/gxCxcohac39e3uPqUmHMAAIAuUnVMjyvR gu2LPUYdPwCge+xyzYP7bwDqc0sQJQfpE9sn+J7/2n7yLLm6cc8PmuKo7QAAsPhgtlVpL7l1l9l+ 7jMcaIvTgfvdOZ/m+m/DAaAXnAg7pbg5oTHjzaokJ7fHHpOjXOf5MQD7ghsL9NRSLAC0yZWwA4rL HeCbo8IJW9h9RGy+Ag3Xl3DrAABQB92WyLkxL6SEfiRa1MJ17erLoRLTvoXaPd/1MwAAJMmPAOyd v27UQBDG9+5IpLsCKR1KgU7UKdxS8wBpeABKChqEeABaGgqKPAAtUl4BiRcACWqkiDoNkMaXO3Zi Tzzem7Xjxfba5vtJo9td75+Jc96199b73YvtAAAAAAD6J3AjUV8hmf7I2vO6io6P12azKWtrSbEJ FqAgMYtC0KIIS8EKErPg42m6tWnb2zSqh4/J8mVxi5BTocMbXne9Gey/MgY/x+AjMRY/Q+Bro/mf xhdVs4Lh7YXRZ3t9f0+mfC6z9vq/7qjJPs9nWFuxr73yOiIpHEXv/Gb/t10ubFFYJmjBYhYsbrG5 EaHIxC02t8IW+wIXnMbiFVRmX8SCxTGKdvyCFovFzBwc/DZHR8acnX00SZJ4BS1IwMIVtEjT1CyX S/Pz8vJup8134nOxCvqe70TcPVbKE0Af19EU2kD93bcx9nMw9vr7aGPo9c9ysQkanUh4ggayXf4p dxfdGrE6QwhZXFM+IWQh4zdm44u8vi37a8PU5oPDQ3OyWplvV1d1bj629omq19zJ02hImInwXOTj NM3mphi4+WH9Oq9LDjMcd9Pd4/Lc+vICMFmxSAAAAP8vXYxt4l6X78Nc3lt70XrDAIAQnpjst9LX 1n5V5LtLZ1H1oFtMvBbPc1slj1uHfJ4rPavNis4GN+kATANfH/LM2juDTZC65KG1tbUfTjq/pLAT YfelCLmZbpMXI+Zmv293X4qQ6dp8Hxg2icFGN2BYkKCF70eNug1tOK0Lq6vb5wcATfgS2wEARsCF tc8Vx7XNqpr2+T5hI03YwnfcN45o/hgnTHPBGEPAJNeOA5CDL3c7rGM7AEAFK2t/Gpapuv/BvREA 7fLS2mlsJwDoiIsGeUPGHu3Z3jhpoW32BqYd2mcAz/BJbAcAEJCAvSZqQWjztzKu9a2+OqrmXbUy vuP4TW+6aO+nUfiDtbfW7sdwCoAB8dTa9zysrQuTa8bcuFyLVrUeza3Dtz6N0a7bLFP8+y0AvsZ2 AIAI0Fz/G2uvTHU/737WmVZWq5vHFw05ZmDtMgCgTbjfofm2c1NeY3+q5OOw21/VxZsi79frwlp8 kGCuGgBQx18B2Dt7nIZhKI6/FignQGJAfEgMIIaKtQPMbByBAzBwA67AgBgRS4/AjDhKJdauhYCo iOu6eXGf7eB+JGn/P+kpzrNju6GysWv73wwnAQAAAAAQsQdtiofUtn0Pvby80s7O4eQ+OyiaJlfl 06IWNCVuoYQsjEAFF7bQfsoJXmRpTb75/M2Ybt7jJp1/9QdjdahnHeqoqEs9Y4gXf4lbJzJvsZkq lbfs78kqv0td3uq+z9nKintwts+WXzOU9bF6nYP+O2kBC3NV4hDDYSYyoe1nImihxCyUGIUWq0hG 9vubTMKZ/yuXxohbyIIWP15Bi60tJWrRp07nhLrdLrXb7SlBCyNqocQrjKDFYDCgJElGPhXXarXo o9+nz+/vwm+wYUQqWNiIVoydOSEL9mDhMqQyF80yDrGv+kH565A/BC3qn/8qfIao58bXJm+DHfEm zUjIghtppQgV3rTuN4zIxfi5Ji+PlaH8e9veYbRhN7WLcRFNhzVYfEOIC5lJRw6/vSBRCgMAAAAA gPni28Cn6JH/kDgAwHI5Su0ptWPKixDycOheCvusyPiPPFcOxnYA1BvXHM15am+pPRMELZbBFf1f lMI3Fxea3yOPj6x4UE/uyq4AABZ8DOo7qMb2uQ4HD9nQCksHkbvMVQ8AYumVXQEAakCXhaXDx2y/ L43UJ0j9gm2hZ2L6DwAAWFcwnxDPYdkVAMDD/oLzx/9PAMSjftO5L7sSACwQl2CyjTSHIMW55p5J SFMkb58fgFm4LLsCADD4bx2zzIe62mM7TsrT1W6H6hVqw0F1kfpnV5ziceE1AqD6nKZ2Rv51ZSG/ a/1Z0f2mRNNr0HjYFQdAGbyXXQEASuIgtVty9w3SPpMie1R8e1eKGglXAACIhbctN6T3xxxYadRe mWuS20MSfP/Zv8HvicJtH9o/AMBa8CcAe2es0zAMhOGDSgydQKoQI93ZGFlAYkQIJJ6qC28ASLwJ OyvqXDF2QqoqpWmF3cTp1fI5TqAkDv8nHU7OiXsxqaOk8f0QtQAAAABACNKNEfffUDY538tgcELL ZW/Lx8UmXEIWWqwiMyNssaLFYrUWszA+vZ75N0IWps6IYOhyW9yifoeEEIvQQQxxxhCjJpY46wBx i9/8rO6KMTTzed3tzzi+d9vvC3FBCy1ewYUsTJktL3Nxi3RtGzGLJBeiSJhYRWIJVxgxCy50kRT7 ZOWCCVqkebkSj0LnEk+SCd3fX9NoNKLhcJj3yUbMwghapGm6ttlsRvP5fC1oodd1nd5ei1p8fH7S Qvl8iEnYmb8QseA+/Wd/n4gnoq+Q0P2vEti3NYl9lfa7cAxtbn/XfRz7/zD2+E37be8je//iF8Vc hKIoScgmygQuiu25oIUar434hW7X+PdM/Pnyibp2nPX7ISFrUYsD05wdDm0LWvD6PRIOwao3HWL8 xHxkrYc8J/D5AAAAAABAPVwTu14bigUA4OZY2UjZBbknA4QIXUi3oj2hPXuSQcikALuOrDoAQDxI 39sjZS/K3glJMv6Sc2X8YV+ViQuhEyF8433ZJAj7fMGY337umg4AAMZU2Viok5KC+RKYlyUVryJg UZawTEqM4loHQEKfK29NBwFAixmTfJ0wuJKZlY3/kpiFaxtJ4KKqMFJIUi0AAIidOkkU8BwBAAAA 2B2Hyp4JAuWg20x/uH/ZPXlI8nS73vUcwLUPAHU5bToAACwmAdv4xklp2d637Fmwb1tXHKCbSOeH FrX4aiooAFrEA1u23/fyJd/1zR8NSdhb5500ANoA3ucA/5VLZVdU/n5xHXELuz3fdcPgmrtig2sJ AKAKfMx4VPZE8m8ptySPgb5x0ScCZLcRMo+Dxy2NhxgLAQDR8y0Ae2es0zAMhOErqoQq1tKJoYxM TIiZJ+ANEHsHkLpWPAOP0IUXQGJh4wkQGxPvQIdSlUKJcdxc3bOdFKVOyv9JJ5zEsU8tPTeufT9E LQAAAACwDtKD01nopuHwgTqdw8WxSUJuEmgbYQstakFL4hbKZrNM5EKVjbiFPk+/ghb6fFbXtMOF M7KE25tJTF4XoYM6+FkHHxV18XMd6pFkf30gblHn/rb39azu5255bZotaGGXlwUtvlKxCW1chIIL WGiBikzMIhOxsG26ZFrE4pP14Ra0aLXmNBq9Ur/fo8FgQO12O30d5gtRCy5moWwymdB4PF4RtFDs KoWMhI/plGyxCa8IRSpesXIlrbsQuOBlS/AiRNkJ7DfRBxL9x2/f9BHz/iq0X/Z7WDbb8B789f4G i7kN1qb0sGvEKhpMtGJhlGYfTcpNdtxkAhbm/h3WHu9bnT9Ix48A+6SFLVziFLaghesHVJ9xcQvf D7XkKQMAAAAAgHJwzdjcEzZvAVA19hK7SeyCZGEKl7BF0Wv2oljfAlnXcx3/y8EzHgD1wPX5vU7s jXQcAptFCVqckHsjrzT3FpqrszdGhASMfHN4oF5cEhKYgWrxGLgeSv6dN4F4kUTkdj27H8kf6RgA H/z/6SWmIwBUnDtWzhN3fXVccV4aL74d10NjiJQ8LeQjAAAADeYYwnRjOwCAh6PYDgAARG4TO47t BAAlI4la5JnLDdXh53wJ0qW5B6kNl3+YJwDr0I3tAAAWRQSGQnO4vCzFS1/8DNVBzN0+fOOwXX4n LWwBwH9HzeF0Kd86szzr0IokJXftFbXXwUnr4gCIgRo/nmI7AUBEeomdknvNsZRzIK8YknTNtc7Z tU9FGlcwbgAA8mBihRIGf07sKlD/nPJ9J5bEKnyx0/ddm2g13vniIQAAbA0/ArB3/jgNw1AYf1Si Q6tuDGwIDsAJGLrCxM6A2BiQehHEwND7IDGCxA0QLKyIgUqlBew6bm3Xf15b1Njl+0lPsWPHeYlc x01sfxC1AAAAAECK0J8gc/++sMtUQTs7uzQa2d0PU2zCFbLQAhbKVFyKVcyELFR8OPy29slydH4V V1tb3GL5G7IspQgdlOBnCT5KSvFzGfJdZP9vgLhFyefb3PuZz+9ufryQuuc/VdgUtBhXYhbzQhau oIW08XhYCVnY4hYhIQstgqGO0fGZpQQtWq0Rvb09UL9/S71ejzqdTnXtM0ELLWqhhS3kdjAYiP7H cBKX6Wad06IWX7IDw8UUq9BxI2yJWDQa1jHEXFwfi+TncY5NKD9nQYsSBD1yKL/ka1hHHZx+baxE KKZbml85VKdrgYtJuminLdELQ/xClqvzbenrqcK7zSYdttucSzgStq2Lc90hW9DCt9BpSBDD/KBK xn4y9pET57wviO0DAAAAAAA8UhOm30kJWwAA8uNM2DWpxag5whbuNiZqyBlMG5tkxhkYi/9yAORL aHJPl5SYxQ1hIfw6OTbCvvaY024vmk5k1wm3jmAyWJmc1u0AAA6PRjg1CCG2eLi7qM0qRpGw62ts wRwAfPjqx9PavQCgDO6FvSbycNr+lADFd8R86dxyQ88YioQBAKA0OO+AV3lfgHcNM+S92KvbCQAi tOp2AAAwx4Ww87qdAGANfP5BGaH3C26aufUdD8C66NbtAAAOL8x8nLZ0lW+AqfOC/0OozkhRi4+6 nAIgI06MsG8McGgccWyMsW882iLj2QDICbNvcVenIwBkwJWwA4qPN17GuM+ZlMCFG/bFAQBAY7Yj XWHPxBMGl3NoXGELnyAPR7gnlJfbZ8a8PQDAxvMrAHvnr9MwDITxA9FKnVigSAxVGRgZeAF4A4a+ EBLiBZjYEA9QiQGxIvECvAEDOwtShVSJFuwm19rW+Zq0ahLD95NOcRLHuf67NI59H0QtAAAAAFAW qaPoxlhbO+j+/om63aP5Oid/5hzQLGyRiVqQJ25hjQUrWOAiE7fIlguhi+l8ncUtfCGLn/x8/rmr JhWhgxT8TMFHSyp+rkJzkuxvBohbpHy+v/t+1vu78+fo+u/zVBC0sGUWtvjOyxNPzMIKUbAohbXJ ZDwzK1zBy1DMwhe88AUtFoIZE1XQotMZ02j0RsPhkAaDgfPfZCFowUIWbCxuwYIWtmzrcpJ1a61W a9bOl6lThGhy9UDYIjRPAMNdCu0jSX6x9lN+DSn4v2kfUxc9SeEzLNJ+kz/jmH/uE0DeL930zsQt 8jZcIQsWrLC2w2WuQ85TyXzbttOee267/bCt3lYz+8bOSU9sukW+uIX2ILVIIrzYA1tSygAAAAAA YHOESdSsXdfkCwBgOSfGbo0dUzlhi6LiFuE+adBskQGysQlnuNcDoDlov1M7GOM5NyTMq5+esb6w XepLi0160PrlpHiu9d2F3xtMCkuDPmWTagBoCq/GPiL7pPtUqY6WxEZKQL5qEnItKc5qAycAWPBe twMANJQHpyzFXo1Y/A5FKaRrgiZwUeQ6EvoXKwMAQCrsbaBNLcECACBNeisco8UA9DcCsB6nxu7q dgKAitD61sK+27IJz8P7fKnfOlanbF8GAGXo1+0AAAGSOPG6MVhqKxZjpXMiDv8ftOfKYfnT2GMV TgHQcM6MdUkeB8ZTVbVxZuG4Ym0uqTb2zEUbi4Z+IVAV0v+Fl8q9AKBZWEHrK2MHFB+fHLsmaEnb iyZ+18Y5E/nXFxK2AwAA48aFS8rmyOyWOP6C4rEvFg+XxTpNBM5dJ6GsvT4AAEiaXwHYO3/dtmEg jJ+cxgiCDu1kT+kLZMie2UOBDh38Lh2z5TXyEN6yBGj3vkGAvEOAZKhqV1eK8onmkZRjm5Lz/YCD KEoiz3JER/xzH0QtAAAAABBCe/mR+d8q+xoraDq9oLJs/+shxSZcIYu1gAXVaSlesWoJW9hzy9IK Xiyba2xZbXGL7W/ILhmK0MEQ/ByCj8xQ/NwGiFvssq7jFWPIU9/x3s/DP3crUV9bKMoIWqzq/KUQ lFgLWpi8v9Vvc/nfjJjFn0bcwghTuIIVPkELk7bnmjJKIZBh6jFrkjc5OSno7OyZJpMRLRYLms1m LUELK2YhzRW14DSfJ3FFLZ5fX8M3VAZWd8QrpGBFKIh7MQp36ww9yL8tH4H+4+Xvm12ICewTfIfx 8o/hOzjk9c3oYS1C0WzJHy2Uj3+o2mQrcmEFLVrCF3VeUec3I5O1uAXbdDymy/PzFBevKzu1xbnu UFvQQh4vSPkIznE5sVFObgxtfbcxJQ8AAAAAAHRD69R5quzXAf0AAHSDF5SxsMWcNt/fpGkiF+65 KWIX2iIEbRItebYS38I0AMBh0J4/zvtc2V1lj2SEUEF/4Hk0qYu1UhYLxxaB+cpxQVs+LL7ndgAA h98iHQoY5uaFgoXFLDUouVue6w+ELMAuQRAEADa5J134yJLa/jMhgSNNvML3G7JUro/VHwqiBQAA fYdFLXK8+6O/oc2n3A4AEOFLh3Pf8nxjDiEAcXic5yG3EwD0GF8fsDzmS8t9X99w130A3spVbgcA EHA/7ssW17l9qBTZj40LatfE6gDHi/a3cpvNIwD6xVykUwOIa9YlUG+oPukPAH3iZ24HAMgMByn4 UdlH2owbUDh5atiESH7qvGZtnrPckrIPAHifyPaCx9x5/ORmi3JY1EJrr1JEe2IWawfdz0Kkt38A ADBo/gnA3rnjNAwEYXhwg2hAooWCgj4F1MAFuAIlouQMcJAgIWoqDsAVqKiAC1BRIPGI8GCPPVlm Hwn4Ff5PGjl21utx4oc83pkfohYAAAAAmAXrIek4ttLFxQ2tr29U83XhaKqmUijbFbdgExELEbgQ MQue1kIXkykxCxG00MIZuvh2n3QFhiJ0MAQ/h+AjMxQ/5wHiFn+5rcUVY+hme4v7e7Zz3tXtRIxK 5/oWv+2kFLKYlEIWIm5RWy088f4tdFHM+0QsiuWfn2xvzvL3cl0tZiHCGR/kE7RgvYkse6bd3W0a j8c0Go1+CFqIqIUIWWgxC/6O5/XxJMXisyyrjHl+eYn+MUHBCve7UvCiMt6OfDbWHYLQQR/6X4R9 aLr/Pgta4D/svv+mt9HWMTj1ZrBsbz38ZqVgxZIIVygxCxG3qCqMKnGL6s1muSxT/elt8/LN5eWU 3eJiqAcUL146tXnyvxgNFc2jSDsKfAYAAAAAAH+HFWRwgzuXLfkCAJifk9zOclsle8C/K3JhiV6E EgRSBC5SEgSsxDNy2gEAmid0HnKRIx6g/5DbUZtOgWR2qEgOE1JibVaMLiZKlBrvc/ElSoD+cNq1 AwAoXilNSNEqFGYVnokVFPe1CRUwj/nh+mLNA5DKXdcOANAj+B5xreZD11pfjFOm1n1AT2c1q5/Q PSTmKwAuOE7Af8cXS0CMAUVrQf9ZoenYZQwUlwKgGfhc4oJMa107AkCL3Ce2S40v/ObZHvFi0Baj rh0AQKHFiVPGpPqujZYYhbuO9a4w1q8P37tHMExS78G8/Cm3q0a9AWAY7FGRT2qNB4sVKk8dT5w6 1lgIjT1D7Ah0yW3XDgDQA7ZyO6efwha/KeTuW8/qe5a8FQ3uHwD8b/Q14CC3x9z25+yLc/YOyX+9 cnPyQjl6vnotqde7UN6ete8AADAovgRg7+x124aBOH6B3QydPXhrvXfJ0KXImCVAJyPvkTfomDWj gS55ji4F8gAB+gzZMmYJUlswKlakdL4cP+QvUcr/BxxEkRJ1lm1Kosj7Q9QCAAAAAD5SBpl/L+0y VtFkMqWi2Lzt4GITUsiiEbCgWqCiEa+o1o2ohTG3bVFUghiuvBHEWAtxi+1PyKHpi8hBHwQZ+uCj oS9+bgPELfZ5rOGKMXRzvOGez8P97zbHlDmRKCcCwYUsuKBFeRW36YJZJUBRiVIsa+GKzfRfK2bx qohcVFYJYayEoEVhBS30z3J6SrRcPtJ8fkGLxYJms5k9b34xC2Or1eqNsMV63YhmuIDrLgj6eDz+ v3x6flb9eHOD5YKnu6DrmlCFDXpeH4eVy2Dtxwpg3/dA/Aj0n3aMXfc/9Dk4JMfwP/fvMKX+nL/j Xf2rR+MxwQr59tGJWYycwIVdckGLEcsb2bwTtm/dvtv0tLxgffmYNF/0vLQPrjoKvyDl5ScUfrnK B40QyyeWFxs4wk+hlg8AAAAAAHZHm6BtRC0eu3EHANCCb6X9LO2M/INgQ2kpcKFtJycExAbOyjxS lhzfMx8AYD+E+lWMXVMlZvGDEOgoZ0wn31fS21YSeW0tNhlC1k+eMpAvJvjlp66dAIDxEChLCTqi BQ+PiVq0FbyICV2E/AOgDeY39KdrJwDIiF+lvdh0Stvbpo1PEaTg20rxI7lfrB7NVy0NAABDpE1f AfoVABgGvr6nbf/jKUGoEJwFgE3uCIHOwftl2+fslADpsX7o0PHx/A/2DQTvQG6kigtxtHaVl/m2 k8tQm6y920Ob/D4IvT9weTfHdgqATLkS675guW3GnWlj0GTaV7/0BYAcMNeN+66dACATPlMjbKFd B3zpWMB3bT/fnBSfkbIkzzoAYPjI+8vb0n7T7vNkpKhFGyGLVJGflPZO+4wAADAY/gnA3hnzNA5D cfyRDiChbqgbErfxKZhYkO47wM7AIT5CWY+dmZmN5bbjE9zKCDtLVQkJThBiHKfOw352opLU4f+T rCZpYr8WEreu836QWgAAAAAgFtfk0f3QQZeX1zSZ/KjWTSJxk3TbiC201IJqcgstpbAlF0ZukVey Cy260MVsU/WYuhbijLxMsN1dcvE2pCQ5SCHWFGJUpBJnGyC3WGZbw5Ux9NPecN/P5Z539TlBRmih l9/Kx7yUPORMaPH6SWixEFFogUWeP1cyC70slRcmtrCFFv8/2vOxsZHTfH5HZ2fHNJ1OaTwel+/V In4jreBiCyOxWHyGySnLsqqoROSj0ai2rpg9PdWDsKQVjUQUtuyCH59ltedSFzWY+pHoP1z/V7KM +IfwN0y9/iG8hq6Pr83gM9dVx/MfsgrTD9gSC6JKflFlGDVyC0tgkZXbMqs+u221fXt9PSbkraLs kfyD6Rq5J4rETgyx5RYxE0iQFA8AAAAAoBukG6uvugwEANCaSVF+F+WI3NIKLrBwySx8232Ta13f 90Lf66Sb0MizDQDQHulcU+WQtMzigiCzSIUDa9l1TY29mStmTI+P5fE2iT3nWwerwa++AwCA8cda lpKF8W1SUhpfcnFXQnK+Hwl1+uIAoC2uRE0PPcUCwKrxSPU+giNJIUIJJn39g69I/cubp73YWAEI 8bfvAABoQFfjADHjDxiTAKBfdlsc0+S8jdkX1wrwnTkl/bsPAN+Jx8j9QuIJez/fGLR0PMYAQJfs 9B0AAIzYa7Eidgw1Zqy3aRu4Pg+fGImJ+f+5L8rNVwcEQAKo+0g3SZ435lqWBBahQuyRz0GT5qVh TAf0xW1RZn0HAcCKsFOUc5L7i9hE71K/IgmSDKE+hti+AIDhw68TSg77rygnS6r/J8UJe6R7+Jrk bpE+a/PXHVoGAIBkeBeAvbPHaRiG4vhDgkowIEYmihhASEhwAE7AxAmQ2JgqzsHAxoTEGbgBgplL wFQ2JgZoK+w6Thz3+cWhofno/yc95cOO/UjJhx37/SFqAQAAAACOUAPH3b+n7KqooH5/n0aj/CtH XmwiL2SRCVhQKlJhhCwmqcCFFrXQZrZJLY2IhU13y8rqyupsg3hAW/zUtMHPNvioadPvXhaIW1RZ V3fFGOqpr7vnc77rzs7lzfaZ85QXtDDr4+n2ZDKeWl7IwlgmZvHjCFP8pIIW2sbjkJCFFcH4ni5d cQyTNkqFqzjW1yc0HL7S7e0NDQYD6vV6yfnJC1q4QhbarMCFFbTw/1esmIU2G0De3ffx+UlO5uLT zohXzOxz8q7YdL3uiGn8F10Jkt+Fv6HJ5S9C0KPp52AZym/6b1ylf+noCSta4QhSzHzBTMQrVl2h C0/gIrWkXFfsYiURt9Db2+pZdbSxEePiqbI1WxznFs1+IJUGmvjpbnA927APDRYJTSjFRFMAAAAA gOqICc4JUQsA2sWFsntlBxQeGOu330KDY4uOkwbJSkHVyVtyA2rRzgNgPqQ+FG1WzOJBWX+BfoH5 2SE+UIl/j+XuyzGiRNz9WhIukiYSc9ugHraUndftBAAOOrjNeyCNC1gTChrGBbPhjpOCkoeC4BT5 4efhtgEow3PdDgDQEB6VfSXrsYEiyz4DJAELSeAi9AwJ7ed85dYBAGBZiZlfBABoF4dC2l+vbele IZVZ9P0J9xrQNS7JCJgDsGyUCaTOUdQ+jwm2HjqO6z9GnzKogpO6HQDA4y0ynyQuIfXvcsfG9Mdy 5YPlIeab892inQKgoZwlS25MrzQuWBqbNo/ghQv6b0Ad+O8blpcafAGgqeySCRDvB2APrRfNUSkK 5u7HKHBjFRDJ81SIyQcA6Cb+9X2t7EnZcYV1bFJY2KLMHD0/n/9OXeY9XJrHAQAAreRXAPbOXqdh GIjjVjpULUhIHVgQEmJi5QkKI+IJuiFeCDGydWDsysKG4AV4BXamTiBUEWMuPcz5I21a5+P/k6yQ 5GqfAti1c74/RC0AAAAAEIM0GbpVZpLlZDp9UKPRQXFOiaApH/RSZEL9E7fQhUQq+FGLWfwVujCF BDB0PVQXr5/Wn5dtN0M8AH5WRxN8JJrka1kgblFlW+0VY0jTXnufZ/m2+PvbhfVsFoKghf7ZCFsY gYmluAUXsyBhCi5k4S6fv/b2ORey+CoENSR0TvPB4CP/nvCmZrOZmkwm7JkYMQsStLBFLega2fFn 4BKz0CXLsp/rw+FQvc/nhb0TQayCH0m4ggtYFDaZWdLRghZRohlrsOkk+dtoA4n+49pI+fk61N/1 32HT669EEIMdqS5eY8aEJwqBCy5iwe6ReEWP2RQRGEwcg9dL/by+ftjvx7i8n5excr8otQUtfAnx fEGKruBGV3I8+9EBAAAAAIDNIG3k0psO79O4AwBYkeO83OXlWrmDY3sl7/k2BkgbCGLmd6E5HzYO AFCO0AZPXa4UxCzawIWK3+jrW58LbYDw1WODPrveaEGLvdROAMB4DNwPJZwJiVLYiclDScftewuh HZdv7QzGAil4Te0AADVAJ6J89tyX+uPYMSE0FtjiFbadbzyxfZN8xXgBAOgCVa4L+Orq6hrEOLUD AERwEmET+v9d5X2Sfb1MH9HF/gS0j9O83KR2AoAaEbOmG7Lh10Jzfle7vnqxTgDW4Sy1AwBYSEL2 sX2xEo4+O+lcagP9LCB8f1c6OfnLdt0BoJboOLQdFb8fNCZm2Pd5bkuE4tNWXfcBoEqeUjsAQM04 V0bYYlfJsciuBO4+0QvbTspf4BpPpJhnfuRgLAGgXdjfHY+UEbPQQuCbiJ2/VO7+K7RHzyeCUUYc jnC9Q0U/BwBoNN8CsHc2KQ0DURx/bbWlBXeFdulKENy5FUToQgSvID2Cl9BT6Epw70HEc7izC1dG dMbMa16H+WpNmyb9/+DRNJ0viyYymXk/SC0AAAAAYJOyaPRaxWWsoeFwTFm2+O+GlE3YIotcTEEm CnkFh36vpRYsttDlsiyXWPDnsq2iL38y77rIAzDO8qjDGJk6jXVZILcos6/myhiq6a+532daX4vr wfLyxR7g/Lv5MQILFkrYQovMCC2yudCCZRSFnCIktvDJLDIjx/gyfX9TkZ9ikU6nRb3eJ41G7T+h xWQyMd9BIbPQYYss+FWW4XqMFFhw2JKLfr9P77NZmtAiloBdlrOEFm15bk3UXSTAfaD9cPsQWtS/ /Sb8DFXWD7ZNixKKtunP9aSR5RZ7ttCCaP5+HqbtuQxDSC90jLtdOhkMUoZ4pmKfm3MNi4oHofLz FsUfnEqhBZ8ncS51wQgWkgAAAAAAlI9vlkeff9rkQAAApXGj4kHFEaVLLGSZlEWzvk0Gvs1sIeEF EqUDsBqxvx0dU8plFo8EmUUTOFUhJ/p819PYRmHXZuPQ+9jGCDkebIzYLqZVDwAAi1dxHFtxkJKg PKVcSGjhSn4TSmwWSnAGwKp8kDvxEwC7xLM49iWBjCVC41fXfcCWVvjCVSf1fuJKxmaDewYAYFdx zSOsY+4X8xAAVMvxCnWWTbbim39M2bsIQNPQQgudnAlSY7CrlDGf5ptPsD+Tr676AGyKw6oHAIDg v9dh13U29AzQrkeesqF6sflbUG9ivyf2ubtNDAqALUevQbsyxylr0ELrhF2JxmNr0FxriiWY1wHb wkvVAwBgC7lQca/igNw5BUKSi9BeFN/9xL53pIgtcH8BoLm4/r5vVbypOF9jv1oK59t/t8xx7JqZ speDCT1jxfUOAFA7fgVg7/x1GoaBMH4UVQwgJAZYKbCwdSnvgxDPw44Y2LrxEsDMzMjIAEMXkAoV xE0vdU4+26ncNkm/n3TCqe34kjYJ8Z/7IGoBAAAAgBCul6DrUKXb2wc6OjqZpu0A4RwTmoUtclEL KolbGGORCha4MNssZpGnTSDq3FgAw+yH92Xvn8csfYG8myIeAD/T0QQfmab4uQgQt0jZVnvFGNbT XnvPp95WeY7P/Bmar/G1BSzm2yxuYdtvIWJh0pPJj0fEoixgMZnYeT8OMYvfog1N0KLbNZoPnzQY nNJwOKR+vz877r/CjHAFmxS2YFGL+f8u5ZPFgha2sAUHU+d0N3PifTSi7/G4qDNL6F+MncdiFVLQ Yha4fmpG2KLTcddPQFuC5LfhGOq8/2Wf46Z/h033n/df93OU2r/S7Ae+51rt8HYhRMHCFTPrWHks XrFtlSlGJa26HW5jflDTcsc7OzEuH1I+WOsbFN2y8uWEkphAd7a4RWgwVaYBAAAAAEBatAXXdofp Y2ZPK/MIAJCSs8zuMrsiv0CFT7RCvh/6Fg/Id8QqAdG1CbYk8gEA8dfKJUHMoo2YxcQXpPebxfS7 hfrutPu3DfrvmkGPlrs4B4CqvGT2oeRpQWVkmZig5bFBx2ODkktfFptkBICO+T29rdsJANbIK5VF j1yEApxpFhKqkM8PTcjC92xx+UMiTSINAACbTOr+A/RHAFAfzj15vmtVy3P1dZL4zAfuD6DNHGR2 TxC0AJvNlyevyju4r6wr+Lnr/V8rW9UXAEJg3B/UCXvMLzSup5UJ1Zd/U/S9os92s9DGeY2ZudHP K/cIgPphAvPuUvx6UN88s5i1pjIIOZG7D8iVL9MArAKez5FCWBGAttGjXNhij9zPBt/aE9/6lJj1 KtqzSRtL0OZAAwCah7x+e5QLgN/Q8sdM9ikXhdOEelyCF7GCPjHCPhT4HAAAGs+/AOydO07DQBCG B4RSRKJDFEnDAZAo0iJBQQGiywXgCNyCNiegokfiBlwArkBDkwMgHjbBK3vt8WZfNknWXv5PGtm7 ttdjO/Fa6/H8ELUAAAAAAMcVWCq4pEq928h4fEBJUn/UqIQmFktCFpWABZUiFZV4RV4WohZS2EKs lyS5iIVcztuqhC2aJQnvi9AB/FwdffBR0Bc/29L+0Np9dx6zIEPMYgxh9hfv+azvqx7bxQUthHhF fg64sEVKlaDFTyE2Ie27NCFUsVjkwhVp+rUkbpGmH7Vyvu4X21a2I8UtkkLQQn+SBgPxXPBG0+kZ zWYzGo1GxbEuC1pwIQs5lWIW3FS4mAUXtdguBCakqMXrfE7vn5/NL0yR2Jzvj1gi9VLIQtYxUY1V 0fck+XIf626/64n+ffYRcvsutL/ua7huYrgGf91+Uz6WURNMtGKLC1gwk+IWO6qgBVFZ5laL/GNl YftZx3Y4HPq4epzZoNhM92KUC1rw5a4gE/4SlVg9sTrTtHYqLfUAAAAAAKA9tkSd95t3BwCwQq4y u8tsQm4xC7XeFlTr+sDA9jGbLqiWDHUcnyRFAMSK7ffP/1fXBDGL2Llg87r7qu89uO392vXxsK4M wnAd2gEAFJ7ZvC05jVpnSxLmErBQk5n7JkFX/WkXUASAHl3SpadAvgDQBR7YvE/iR9M6pj5AJ1Rh E0JS6039B5G5f0CfAQCIhb0VtOGTcMyn3jbWEPM4RMzHBuJj0mBdn7FuskybtglATAhBC5Gg6Si0 IwB0HNv4risZummZa9wC4wFgnZyGdgAAhTaJnU3jrLplZJj63N9xf/6/2Ppw3e8CsdEAEImPTWW+ J1uMmCvmzBZ35opL08WiSTCuA0Kh9h2PoRwBoOMcZHab2S4t5xJQ59XvU1ziFk2ELYjM/Yrp/QL6 GAD6he558Sazl8xONujHOZkFLHT1tvVcwhbqM7ROII48ygAA0Bt+BWDvfHYSBoIwPlESiBcvyE2D 8Ql8Aa/Gt/DIlbOcPRofgegzeDfxCTzJxafgQIJR7NIOHZbZ3bYQ+ofvl0zo0u3ulOi23e7MB1EL AAAAAPjQFpUPQgeNx2/U610ut2Uy6HWhiUUiakFr4hbGWKRCfrKYRSp0ERsLYJh2uC3ZPs85500Q XhcBAfi5O+rgo6EufhZhu2T+xQ5ssiBDk8UYyumvub9nes1cljYELWJY0IK/s4UsUkGLWIDixxKw MAIVLGQRmxSzkPXYWODCtJWKZfw6z6PTWdB0OqHhcECj0Yi63a44v8VSsIIFLaSohTGzzxa0cMFJ 1G1BC1lutVrLurP53P/j28nYXeWkTxawWAldWPt3QdWT2Fehjya0X2VBizoIelSh/TqfQ9X/Bg1H PO6KvtYejpN9KyEKFq4QQhW879gWt+A6sm5SXusn2Xfebmdx+SyyGwq/DJXiFtqikCwLESlQj5Rt AAAAAACwH+SExgsVC0IEAFSHq8ieI3uI7JS2WyQbCiLQAtVcSdPt50Mi9zOhxPU9AE0jFLDJZhIY mUX53wQxi0PgguJAMBtt/NQCin0BDlkDi7U+pB+2X6Ac7st2AADBLLKPDPW0pDRawpE/pa4rmbkv UXkoGXme5GYAbMNn2Q4AUBKTxHyExnuXcEVIqMJnvmtGyGy/7W0AAKgT24haYD4AgMPDzFueBOr4 3gG55hW170NrDTFHCZoKBC0ASPkqcIzv+dyVSD3rsVoZ8wFgl1yX7QAAFnnGYdd4mOddXWhMxVgM XLiET4y9EtZGA2C4o+zxoNq6My2+1JWE3LcOjUif7yHC3A7YH657h/d9OgFAzehH9khxvEroelBE yCKrsIXrnYH2SaKMawwA1Ub7P+1T/K7kieL4uH1yS5vxdlnELey6Whxe6P6ZKP99M8Y4AECt+BeA vbPHaRgIovAgEYpIkShSpEWipKOkgAtQc4tcASqoaBCi4Qh0nIOCE1CnoKJBCo7A6/U442X/YpzY G94njVhv7PXESWzjnZkHUQsAAAAAMK5/ZmT/OWnlQS/j8YSyrH6bURey0CIUWoziuxSmoNKW4hVs almJWrCwhVovy7SIBb/OghiqXRfPaH5AtN9pCAjAz/ZIwUdFKn42oflvNybOxb3PTQJxi5T3t03H s/6b0cIPyzzguqDFoljWfxe/hCzYtADFVyVIofvmlZiFW8hCbjMXY/H4GemcYzvDYUaz2Qs9PNzR dDql0WhUvScpaCGFLJSxwEWsoIWCRSxMcQt+TdlgMCiWPz4/bQMEx6+tZxRVZzGLoq/cb2jMGFIv ks/jp/weUvB/3T6mLnqSwmcYM36fP+Muj3E1gyhEK3akgIUwFq7YNQUt8jb3SeGL2qylWFY22duj o2Eob7TgJLdBuZmvWKn5+g79nkQ1J1DlxCn3k+gLBYnIQ2jrBwAAAAAAqxFbvPN+M+4AANaMmpt9 yu2C7AG0oUBaX+BtbHKBK9nNVXjIbEuQSAC2ldB3nk0VL7okLWZxSxCz+E/EJhOTo992PvaJW9jG McE5uV+cEc4JoF/4BC18xcFchcxtfX8pdh4qTO7zF4A2eO3aAQA64lG0VykWKdcxrwumeEVI3CLm uuG6Drl8AgAAANpkv2sHAFiBY9FepfhgTA5iWzGDtoJWAKQABC0AaEbM82fXNrZnxc0TTgH4G5j3 A33j3dIXikX1rRvzPBbPakEMvmu97TtxvUZfAEgFlWx6WrZ98WZmnJlZWNwXexaKTfPFnZn9eJ4D uuC5awcA6DkHud3kdkh+8QozF8WVfxKbj9KGsIWrDwDQLa77w6vc3mh5/7ppVAEyKWwRyseziVm4 zoG281oov4NBHgcAYCv4EYC989dpGAbC+BUGhBjYuiLegIEVxAJ7JR6AhZFX4FFQBWs3xBvwGgjB G4CQkGhpsZu4vbg+2ymtncD3k05JnTi+/nMU+3wfRC0AAAAAIOEKRL0MVer3H6jb3Z/u86TQPCl3 sZ3MkmcbIQu9b0Qq+NaIWRT7Y7UtbF6vELiYC1lMZm3M2/sdbREQgJ+row0+atri5zKkFrdILY5g 2kzXVto3B3GLVbe36vdXjfPh70eLV1TFLb7LY0bQwrbRVIDCCFIUIhVfC+IVk4lLzOKLiV2Y+lzQ YjRtQxK00HnHt7eH9PHxRIPBgHq9HvvMCjELI2hhi1pwQQsuahGDEbIwxsUttBlRi8/hMO7rKIUq XOXO5Or8fH58yUTvbU+Sb9pY9/WbnOg/RRv4DsPXXyd/5X+Us37dNirRfGV5xzp3Fr1XilZslGIW m1zsggtc6PsEzUUvKueW9SvtlMf2trZi3O8qOyZ/4EeHFidJYwIQ7WARCtQhxz4AAAAAAFgP0mCo LrtV9p7WHQDAmthRdqWsr+yQ/GIVMYG2vgUDLpHD2AVs0jOhtJAAz4ug7fgWZ9r/Ax1EcUNFkoBr ZbspHASNQieH4+q1dj8ZOz4XWvgQO9ZnY5ejj07PRW4HALDgoha+hDb8dYx4hSvpeEzCcvJc3+Xb 3wymAk3iRdlbbicASMwjuROfcWLuBaF7xNhj0nH7/lFXDCkmQSYAAPxnME5Qj4PcDgBQg6Ma57oS SfkSsZB1XqjcNUaJ/ge0Ef27haAFADLLPne7EqH7riU9+yOROkgFngtA05DGdkOCAr6xVLtM6qul /lia78NcH9BIv5U7Za+5nAKgQZxTfPyZL54slHRceu1rl9hxAHJyn9sBABqOjmnWwhan5L4nSKIV vgTwdYQtQutR7K1vHgIAkA9pPu9E2TMVa2dyc0b11tz51t/psg4t5mwJ9W9Ecr+FOVEAQGv5EYC9 M0htI4bC8JtgXMiqi9AECg2FLrLotusG6k0gi/YCPUMP0FMUeoIeoCU7b3qH7LroqlcIpIGOoXqR XywrT6M3iccamf+DhzWaGVlxxrKtkfRBagEAAAAApuvHjnDu4ixX0NHRC2rb9a8YoWiCF8lmAcVi QXcyCp+3LrKQ4G2WWojYgs9rW3+e7JfzOb0SWwyzuHktAgHUc3PUUEemlno+hF2XW2zz+UpcJyVE IZBbZEtZS4ciKC+x8O8dL3tY3EouvNBCBBcssRDhRLsUUPjQ5RU+VvIKEVqI7EIkGP+W5Up5i06h xWTS0HR6RYeHRPP5nGaz2fI1WsksOGKRhTyGMgs5z4IsLK8JLWSfSC2ub25M5UUZt9EsywvzSNnm 4x7D2Bext5S/C3/D0OWPWSaA/2H58od+jrFfg1K+5TnuRksE0oomFFgEIcKKiQgtOIJ8uVu5F5Sn bXM8m07p9f4+GeAJpk9o/UaoNmgk3t9Q+sZqfBOVonTuUXsJtXwAAAAAAPB44g5RXljxW6G6AACG 4ZWLLy4+u3hONnmFti/OT/0mbKJ0n8lu1JEOweBbUBva5Ettn8Spi58ufrv4uJ0qgpHCHXxvKD0x ITfZNxdd7XVIqo0GZXnq4n3pSgAQ8IfSC4Foi9BYFrLpu6C5ZX+q/FRddnNgFSgFX0+XpSsBwBb5 6+J7sN23jbW2+13yo5TMwiKugMACAABWbLIfINW3AQCohxMXB6S/n8PtPuMDU/eGLOlU2QDUAl+/ 3N8LoQUA9/llOCYnngiP61oU3SKu6DoGfctgE0BqAcZErg22tnOWtjc+hpTt1P1ELc/62QDqJnWt aPuYr4PXCIDxw/05b0nvi8mNL9MWGLeMQUuNE9ZAfw8oiXyWXJSuCAAVwGObP7n4QPc/B3Jyiy7h RU5uYZ2fQko6BHNRAChH6v330sUP8nNojrdaozTvqJ/QIiW5CNdp0drJ3Nw66/dptGsAgGr4LwB7 Z4/TMAzFcbcMnRDqwISQGFh6AFYmli5M7ExwAS7AIViYOrDCARiQGJi5ATeApUsRoIKN85oX46+k zYfp/yc91Un8lTTUxPF7f4haAAAAAMCGbXHoeajQ9fWdGA53ftM8MDQPwE2Bs3XA6VyoQn8WBS2U kZiFTqvA1NooPwlj5EIWxeDcdcUZT0VAAP1cHSn0UZFKP6sAcYtVtpWiEEO320znmhbX7+Rjpvb/ 1ecwz4Qs5pmQBYlbkOViFiRoodMfzEjI4n2xzcUuKE1ldZ2fC2EL3d6XcAlaKM2IXu9NHBzsi8lk IkajUXZdvhemBCuUeAUJWXBhCxK1KCtoQVDwc5ugBRe1mM5mpevNEnxnvm2KW5jlKpxDnaRef91t pPAd1N3HrggVdLV+aqPu+rv8Hbd9jQtvCbN8hYdl1T/BhCgyI+EKErfoM0GLPtu/YeSl8oV2smO7 g0HM6WxLOxT+RR89z/GYxYY2cYvQC1bz0gEAAAAAgOXxOU9zZ8GrxnoEAGiSsbRbaWfStkTc4tpY IYtYi3mGdD0fuhbdwqkAdBXf/Wm774fSTqW9SHsQer4GAMWYpUMOCyGHrX5kXltbtjVBrm3QDErQ YqvtTgDAeAocDwUEiwkszoOU+wKZm8dc7bj69j8XUYE24fccRC3AOnEv7TVLLzMOUB7fGFBGuGLu KC8cddsCoPnGEQAAWDdC8wLLrAXy5cd8BADtYpvDjvlbLxuYxZavSrsAdBV130LQAoB6KPO87guK beaxzTFXbRcAzp7Auz/QLbiYfcxvnuvdnpk2y/re5fnyAODCdS/dSJu21SkAOsSJ+DuX4vIFda0v ixG5iF0vjHkd0Dbm/ymPLfUDgBRRfikX0jZFWKjC5o9SVdjCNs4Izz7+ycHYA0Bz+PxqLqU9Sztu skMRqN+2IxH2vYvxtzMFLVbxXhQAAJLlRwD2zh6nYRiK46+oYmBmYKJ0YeIESAgkGJk4AWLgGByA qQMrbKxcggsgDoCAGQYkJL4awK7jxjHPH0nTpCn/n/Rk13Hs1yqKGzt+f4haAAAAAMD1YGOW71N+ cz1Lr7dOSZL/e2EKTUgRCylAIUUstBiFKsuELf6KWnyPhS1kneFQnSePKVGLTBwjE7aY38DwZYGf 1dEGHyVt8bMMELeosq+2CDFM1me9/c3yb5p/r8wUtFDiFWoPryloodIkFbYYjkx9/kpNiVjoNBO0 0OUy/z6yJPmgvPDFl1HPFLfQ9sN+NxnT+/PzkQ4O9mgwGFC/309/i0zQghOy0KkWszCtKKaYhRa0 MPPdbndU7/n1NbbBXFB1O8B6xxCy0AHUO6KvnMhFgaDvbQ+Sr/uYdvuzHOg/pv0qxASmCdoPtz8P 36HJ82PaLyUKlJoWp1hI2/qzGinHA3GvHqVkiFhY+fGKZdoG91nayuIibSwtxbi4KaybnsYtluoy +6XDDvkXWM2XEMnKh1LuJ+TKAQAAAABAOXwBO++FXdbnCgCgZo6EXQk7Jv7Zz0xDYhdlNhPEBlT3 BTHi8B0DoC5816nr2l4TdkFKzOJcWG/qXoK2sUrqOrEJ3TddG4djNkLYdbj+TD9sv0A9HDbtAAAW 10Y+tKAeClzuCjRiBxgPBS0nT3u2r74gZQCUhbuGbmr3AoBmeCMlauEiJArhGgs4YYqixp3PjSGx vgIAwH9k0ud/zOcC0H62HOWu+UJuXtE391i0Ptd/KOgLAE0jr0sIWgAwGdwzvO+53i6LnQOInQ/A vAGYhLWmHQDA4ilcZUyR+2lRsYpQnXJBAMC8wF1frmMvws7qcAqAGWdZ2DaF3x+z3yULiVj4jrvm fsiR972bBkBVuP4/PAi7rdMRAFrOrrBTYSvEjwmcuEUVe1FC4w5ZqW9NAWMNANPDt7dmR9idsBOa XaFXeY9ziVf4hC1c+SJiPTF76XAPAwC0kl8B2Dt/ncaBIA4PVBQ0SBHNFRxvAOIF0tLcI9y1SFfy BhGvQI94AhpaHgGJjoIG6VqaFFfEAuFlPWE9mhlvULDX8PukUWyv/2wSy0mcnfkgtQAAAACARPtT 4KRro4uLa9rZ+fE2nRaHTottc/Hs0M4iCpZZsNAiFVsEoUWYD4+LxUu9LAavz2KMd5FFWqC77yL0 4xAIoJ/rYwx9DIylnx8Bcot1HqtkEcP4jhePWdpr6gstIiyy4GUstHhuySaijKJqSSlYZhElFotG ZJFOp4KLtgijLbSo3o5nPbetrReaz+/p9PQvzWYzmkwmLTlFEFakMouqqpYRhBYsteCQcovc4ELo aTDp9L+np9XeSFlcPZVVSHGFlFlkFGb/KkXyv8JzKHn/fQg9Sn8NvsP+S3+PS3qNW6McWDCUtG82 sqGliCLIKhqZxaZcTlFowcKKpdyiiXTd1nGatr1gdupml+Ifv96Ajw2nPXfwInfP24aUaQAAAAAA 8LloyX5nQ3QEANAb2xTlFld1/CJ7QK2WRKANqvWSCbTkBEtuIR+t34s5g3LxexL0warnYzr/p46b Oh7q+E3lDsQHZXBMeffgVonce3RIgiiTnxQTzAEohds6/httXiERbblVuLxLYLFKWH1B0RvQB3dD dwCAnghCC/5ssK6tVjEzT2IhhRRd20iZhbedtVzrqzYNAAAA9woA+E6EAohHTrs3HlDmIMqxgrnb yuNp+wSgVMI5CqEFAD5aMfXce7haAXT5W99aV2sDoA+mQ3cAAMFj5no511HrXrCc967X1r4B0LDO ryC1mA/VKQAKgseiEdljxbwxZjm5pbk5p8gjBSVyOXQHABgZ+3Wc13FAes6Il3uSI7bYcKa1eWv8 s/d5g88gANaLl39wSDGPJsRen536AFPy8+20vLuu3Dr5fdr7/sxY/5tKcC0DAIyCVwHYO3ecBmIg DJsEJVJCjVKh0NJwAQSiglMgulyCC1AhipSIIyAQR6DNHRA0aSlRsgIPG2+8ztge8tjNJv8njeL1 Pjx5yLuxPfND1AIAAADYbiQLQCn5yUXsQp3OgUqS/KOFLTRBIhYkQEEiFkaMIq2bClsYMQtb3GI0 +mFFL1JRi6k4xlTYovjE5fn3XA0BAfi5PKrgI1EVP+cB4hbLbGvdhBiq3V7aZrENzr5H93duvuM0 djcvaJEon5DF1EaZCAUJUiTJaCJO8T3ZtoUrbGEL82qON2VbzGJs+TNLqzVWw+FA9fv3qtfrqWaz mROzMKIVZEbUwq5zRSzmxSRrr9VqOavX639GZdpP/n36RC18QhimXihukR1biw/vrDpBfBFtING/ rI0yz1+H62/7d1j161flM85mEy1Bix1LqCKbnbQEK3btbaeczVZOzuW2yfYbDXXcbktcPNHWnJzG TZ6aOm6i1LdQxJ1gVU459sp9hFw9AAAAAACQwwUHuvvJ3rW9FuQTAKA8OtputD2ruLhFbAFubCGu L5gtFEDg/ocMBc9xIGkRWAXS3x1nXW132mgi4EHb6Yp9BZsDJYdrWduh/tDXn3Ljdb5+N2YuvsAJ sDquy3YAAIc3qyxN/BVKGB5LVC5NTi5NTL6Zi6PAugJRC7ANUNLJp8B+ThTCTTBll0MCFK5wBSdi Ibl/cL5xvuKeAQAAcSTxRgCAzeDSKkvGB33jmty+0HG+MctYP4N+CKwLZs4IghYAhOFELZZJSMDS N54cuw4Ai9At2wEAHD6Yuth4qnts7NxYfxs7Bn0wIELj+G75S6XCFgBsO5Q8+EjJ1565a9BCa9Mk yXm5sRy3jLVooAzMfeSlbEcAqCCUyOBW25WSiVWEYlEkcSqh+5JkHoFbD43YEwAWJxRrcKjtUdtA 21mRTi3AnrZzJY+dC4lc/Pd5WfrsDAAAleNXAPbOHqdhGIrjD5ZWHUCVYIIDwNaFmSMgVWwMIDFz BMQFOAQDB0CVWDkCSMwMDMyIAfFR0YJdx+mL5a+UBDfl/5OeyIdjP0Rx28T2D1ILAAAAAHBsX3aO QxddXFxTt7sx2eaLRPOFtdVPvfC0FlWQVVihZBbjyb6UWsjQggt1fpxJLbjI4jtvY9peOpoiEECe 1dGEHCVNyXMWILeosi3ILapt7+//7/h7YnbEyGNsyC1GWZmRI76YzEKLLZS4QokslMxiKrj4YDIL LbQY5kILLceYyjJGTqGF9DV0Op/ic8ATDQYD6vf7BaEFl1pomQUPeVyXqepvoaUWpuBC78tot9v0 /PpK78OhryIqyCqMNkzBRb7PYsmsx5FvnTRlEfpFrx9Ci+bXvwi/Q8rrY+qftY3CqAYtFmLnJ/KJ TFKxzIILLvJjRNNyVBRf5OWz84V2smObrVZMyuukFlL0PShd8pyPHbio0/NdQ5ZtAAAAAABQL7Yb npi4BcD/QcotTklNwtmj8jILc3CuS5aoPY2uiWyh75O+74/mcY7vHAAhQq8vWxletiviUMSNiAcR JyJWa8wXLCZSaLFD4YkJsROzzP7V1w9zcO9ufjhKnQAAjHdSk8xCuBYrJ+P42FK2zKLmMRILMw+z jG0fgCq5T50AADVzxbZd/WmM2MLX79uEFmUlF656YxevxHsF+A0vqRMAwGCtpnpx3wCAxWZLxDbF 3zsnR1nb+MLYsYW8jtA5AFKjX589EXcEoQUAv6HM/VzXIukx9fgWXweganqpEwCAIZ//vc1wna2v 9O2H7g27rgm1AYDE9bq6TJYRAPPFPts2x6HZxu2aC+/GjP8ts9A4xqKBlJifJR4J4zoAmJUDEeci Vsj+nmETXYTmoFS9IHzMMwsAQDl8c7nkfJozEbekxDdNY5fi5tXF9l1l+6+YZ6TotwAAjeJHAPbO IKdtIArDD5kmi2yyqljBASqE2HYRsS3dVL0IN+AmsKjEKksOgAQcoDt2SO0dKiEhSj1MXvI8efNm XGzHhv+TRrYzznhizNgez/MHqQUAAADwfrEGmjJfy3ScKmhnZ5eenqqXFVI04SQWTkDhJBZu6hPL Lagis5ByCyexYOmFl1g8L2UWfv7vi+BiJbbYvMwiZCgCAdSzOYZQR8dQ6vk/QG7R5LYgt2h2e13u z2fx+6riJym0cCIJFkrIKRHLJnyqyixWogqWWDixhU8PS4GFJrOQQgtfHgszdKFFUWzRePyHptNH ms/nNJvN/K9ThBZSasHLLo8Tf68p3EvNi6J4SU5owZ9xcuKNm7s7q4DVRZd8cbmUXAixxZrQQqxD QTmyjn1/iX1O+W/hN/S5/Lb38dD/hkOvP5ff9300xH28fLrIgqPFdtZGWAhhxbZcDvKWozm4LLks Pvs4GtHBZJJTxc9l+rD4mjX4IxxIskX2A9Yw4DQMPrWm2i7UPgcAAAAAAPnkBmBfl+m2q0oBAHoB yy0uycstphSXWFhiizBfk1to95d1gtyIqveJ1sBdiZUHAJM6TnIGix+V6Zy8yOKMvEwUgNfwRcxb QQqpAIc6wRDatuT/hRYUAdrnqEx7m64EAIIbIy91/8lT7eXhdV44nlontp1UfQFoA3ec/dx0JQBo kd+Uf25ItftWW6+195rYwsrXzhVafSiYB6AJcC4AfSNXatFl3yr6GQAYBt/FfNivGJLzTCfVZxnr u9TQ8tC2gE3Bx963Ml0RBOgANIHW/xy7j4/Ny2Xrvh99yqALIDsCfeKXmNfaOqudja0X+47VDtdt Z7X+XvA+0MZBx9Zzx/dF6zUCoP84UeknyhtzltNXE8aR1n3BuDZvjVMDoAms64UfndUCgLfHPvn/ oUPS31EQE1uk4lCsmJNULEq4TKSflyjIAwDYpOK2Tsp0X6ZTGu5zERcHFGuzcgQWMZlF6nqZsWI4 rOexAADQW/4JwN7567QOQ2HcdIBKSEgsLCB0R9g68xzMqBtCvAa6y5W4r8ADVAxIbLwEGwsLK0+A ChV2ndOcnus/pyUhzuX7SUdxW9s5SqOkje3vg6kFAAAAAIjQH53zXKObm3uzu7s/L3OhaC4UXgtq 18YUZGZBBhbc2GI6nc1fO1MLF2RwQfXI2IL24cWq6zHJEnX6+2IggDybow85OvqS5zrA3KLJfcHc otn9tX08l+fs+HtmvZ7Xl2eVkQTfflSGFs4M4r2K2szCG1Fwg4o3YXDht97Y4m1heEH1uZmF67s2 tAgfi81NYwaDV3NycmQmk4kZjUZLx4/MLMjIQgaZWVD/TR5zZ2LhYi5eXpXJ3ILE3YfD4bzu1Obi WAiqSyMKDbwtf48ZXkjB9r6L5NM+2u6/dKF/zT66bF9C/21/h23zP3wHX21feo6LftiW+iRDiw0q m2UjCjKsGMj3jTe0ILMKaXDB64ZWeB5sbWlS3jN+YDU0IYQPjqbMKzQTFCk9rWAeP5wAAAAAAKBZ Ygu1qXz1jbkAAMrBmVu4ScPO3OLC/GtukYvYZN2QuYWclBubqJtbWJBaYJCbKI1FBz+bdc6V2Hn3 y8ZfG882Hmycmf5OvgflcWj8OSbJXQtjz+60i41z11ieh8wLtMO46wQAEHDhco3YTMpoImdOkRMk jwmQxyb1pN4HoClCYk2PHeUCwHfAhaA0IpGpOqF7wCzwWkauTer+o70H4F4BAADp//54LgDAz+G4 Ck7oWaF2LCf0uexH2x6AUqDzcWzj1mDsCAAtLy30qRFgX7UfAJpg1HUCAAie1mijMbAI1ZNbzbif 3C8AMWLn0u/OMgKgLE5ZOfQMJjRvVyPQG2qjWXeK5zqgJO66TgCAnrNt44+NSxs7Ri8IL8uyXkr/ YFVTJXnfSa0hAADUaNbdjI03s7g2/R8Tcdczrr8Su/akDHnkb+lVfi8TubUbAADQGz4FYO/cdaMG ojB8glBShBpFWiWkoYJX4AGQQCIpU6VJiXgIXmDbFMCrIERLQ0VBAampc1nFSWawj3d8dObixJcd 7/9JR86OvTOzltfOesbng9QCAAAAWE98P2Lc8jcmXscq2tnZo6Jo/ktRJge/rYQTZTJtK7GwyzJY bkENmYUrt7ASCxZYlBKLpcxi+f7bOhE5t7XqyflzEQign92RQx8tufTzPkBu0WVbkFt0214f+7M5 J4zFUqXcgiVQPqHFzX/JRCmxKGoJxVJi4caV+JvjspZfFIW7DQstriuRBYf++W2u7sXijI6O3tJ8 PqfZbFbvLxZaaFIL+9qGK7ToYz+7MgtOyM7BcguWWlwsFs33KnWJguZSK+ck8CK4rlwSxI/ZxhTq X2WhRU6igjHrz/kzrPoxyPX3vg+oGl1kyUVVLkckXWHFY/e1WFePVAqxxSPR3tPNTXq5vZ3STTuo ulW9jZOLygFV3+BpbBKIJrSghGVjNwbKAQAAAADAw9AeKPxm4vs43QEArABPTJyY+Grio4ldaie3 CD1EoMktQhN3Qw8WdCG4kNuC6dL2WIgdW/smPpj4YeK3ifdUygcA6AM7Hyd2fLY9V6aKZ0P35XDe HA4rmno3dicAcDgjf2IxLTlNLGFYLMl4SnA9Mmm5Vr9sF4ChgNQCTJVfFE92lpKkTBNPaDILTV7h E1zEZEiha0XKNQwAAKZK7Dd/l0kTcH8BgHw5VMp89xTb3It05xqGxoLcuklZp70GYAjcY++Lic8j 9gWAHDlP3C6U3LzNPWlZBsCQ7I/dAQAE/1ps2+Y8rK2Ty5Q2YuVgPUkRnvBx+Ieakm4A1hUrKn1B D5t75q6XcovUxOIuuKcDxoavFX9N/By5LwBMgQMTpyaek574PfTcSYrAwidYCkkufPkNMFcagDCx 74eNYyplFp9MPBusZ/3zivRzkRRdbIhlSGzhE1ykjqW64BwFAMiKOwHYO2OdhmEgDF/ZylBUCYmB gZkFIbGxsDDyDnRjYOzYlZWRveIFWGBEvAbvwESniopCXNfp9WrHF0jSpP0/yUriprZJg6GOfR+k FgAAAAAw+Ab/b2JvGg5fqNs9nO3zYNE8KLgLpm0DUDtJBaWyCi6ysDKL6ezYSC1McoILd54TWyxk FjxgN8+r97PrJrTRgHYWRxPaaGhKO/8C5BZF1gW5RbH1FXU9l+eBcaGFlVcYuOyBCy2+mWiCCy0m HpmFk1WMxf7XXGZh8+17J0JoMUnrCNFu/9Bo9E79/i0NBgPqdDrp9QnJLLjUokyZBYeLLZzcgksu jNzC8DkeL94jtiviCpnvhBWi3lZSz4r8gok1yqTpQehdHWWWXff2VxHov2y2/TPUlF/nz7jJ1zhd VclFQuy1HSmmYMKKHZlPVmjhpBVScJHKLFhK60nSkTFAxdknK7bImuzR8uRpJxrKCR/ah6v80gEA AAAAgP+jWYzt8u8qaREAoO5cJemZ7OTiS4oLLHzbrAUFmoUGIXmiZhIvBfI1E6vxfbS5aD7r0HlZ 9083SddJeiUrsrhP0kkpPwEAy5wlaZcda/o32UfG+tHYgghN3wnKwwgt9tbdCAAYMQliLMCMRlIh A5PHgpJPRfm8TgQkB3UBUguwqTyxfW3wqNCxT0aRJbKI/R3RyixibQQAgG2iyO/4mPsDwGZzPE/a 5y2+cU0ZcEozVinL4GUTYbwSrBd37xlR8RvZ50oAgGrJGxw9Fmw9T/kA5OV03Q0AQPChPC+rr8zz PDA2dusrG/0wyML3vEHeVw9VNwqAmnLB9n1jLqF5uqE5aLEA4to5aRjTAVXj+074uKa2ALBpHJAV W/SS1CH/+hEptJACDF+eRnCRd0405kkDsIz296FHmymzcJxTeF1caL8ltll9kXydAudx8H8zAKCx /ArA3tnsNg0EcXwCUQ/NHfVUHgEJiRNVr3ABpDwAXLnBE3BH6jPkCTgg3qD0wA3EjTMSisQJCVUV VWwzE3uS9WbWX038kf5/0sjrzXp347q79mQ9/3HXHQAAANAf2gg+CnpB6A/t5j9je1pW0dHRMUVR XiPLFZoQEQsRoBARC9mmpuIWlBOzcMUtRMRCBSxSEYu1mMX6+MQRtrCDj0s/+n5dD6GPggYF73tf h9DPIfRRGEo/m6DjRf2vpgNNvQObt9eMNttr+zrZ53OZttf0fG6+E7wWc4i9dEQqcpGKWkRL2xS2 WHhiFNeZUMViJWSRfvYvE664zsroMSqKoUIW0bKetK2YQhweLmg+/0az2Yym0+nqvKj5ohaydc0t 25aghaZFxEIDtYuNx6nL5e/VVdVKK7WbrHfWgeGzbaL17OC7D12oYB/q30YbQz8HqL/7Nvp+De66 Davu1a+L/FnE4688IScyN2RpmfWWv1pynkbYGMucpsIWWVry72af61aPXa6gkrktG+OlvXsHB/Rg MqHvl5dl3T5h+0zppK9V+4FGE/0ajsXe55bd8Y7VSX7k5Ftb/xRSIB8L0wEAAAAAbobl0LygNFDp SfvdAQD0kIeZzdk+sX1k+0X5hbJFz3exk7YCUlo2Ktgve34Mvdhc5AywjrHK4xm0X1R18IQW1Jfl iZDFc7YXlK6NAKALRNDiEds55e/b/Hu4qi8Auy9C5FyLRhkXd+wlqj8Og+a87boDAHhcOOmy//em QWq2EejG2g/1GeMWaIM/bD/ZjrvuCABbRPyHP0rKVBnfy/wEcU2r43+w5hEqSAMAwG2jq+d8+BcA GAav2d7Qpr/S8hmWBWS5iRHl/ZYUyMPYAnaF60+XAOUi/ne/o74AcJsoGtOLfMdlxzf1CWCOAXWB qAXoG5avt8hv6udVGZet8vDNgm1jrRPUa0lE6LE2GgCiU7YPbL+zfX8dsLXOLDH2dRsHyvv1kbfv +3FC+/DpgG1TtKZc1smftdgXAPadl2xP2N6zfQ2UGXlpa/2yH3xI83RbZW2KT2hNdFE8AysfgH0h NDf6/6Ov2N7R/v8OMmF7zPbFybPGDH0fQ3Hfz3Dviy0ruucmsu+dQ/fGuGcGAPSa/wKwd/a6VcNQ HD9NkdoJ6UpICFgqHgCegoEZHoAJVmZmWBmYi9T9Dp0qRp4ACbEzgHgBlopKhIvPdXzvycFfSfPN /ycdxXHs2Lpx4/rE9r9IJwEAAADAwtGDS+Z5KtPZ2QWtVve2YblptBSYsEe3CbUTqaCdWIUUsrBi Fn+25yxqweYELlw6J2yxF7LY7MrYl1en702tu2AOdXTMpa5zqOcc6sjMpZ5tCAniZOSkNr6e9uW1 Y8jyhm4nS/4tbXlNfs/6XK56XidosaG6oEVZhctKpKLcmhOgsCIVTpyChSp+7YQsbNgKXJTlPrzZ XAlhC3u0YhZWFMMKWvwOCloUBQtaXJk+/wet1+ugoIUTs9DG8U7wYqj2qIUtpDEscsH8vLxsctP9 UdiBPNfp+XrRr3tniE3yp74R/xTuf50y+v6N8QzHv3/fZXTxjKf+d5Jz/+3RnQfiWNzCfV3kMNth ZYWIP3SiFiLNjSquUOab4cfxd4+O6P7xcarqt8hOSJS31sUceOJ8xecsIo3lIU8YAAAAAAB0g3aG 6AWA0l4PVSkAwGy4Y+yFsQ/G3hl7RHac6LNCHfV4MzS+lOPM1DU9gde3kC5n7BlLo8lNB7rlus+o SRs4IbsJ1yeyizZPCYIWYHweV8ecthx792lfXpv3JIlrFDkH3XBi7OHYlQBAwAtLQx+2feNLXxrf BjX7CQt5G5DrNBRIp+uVqh8AfcJt7vPYlQCgY85FOOZ39JHzjo/1CbLPaCpmEasf+gcAAMjH5wvI 9Q/AjwDAMuA5h0+qcI5fsckcw6bzER0pXybeP6BrZJt6ZuwjLX8jJwD6xPmfY+PztmP3lM84ls/n 90j5GABIAVELMCW+t8yn34Uxn6y+Tp5rOp0vj74OQKod6bg3Q1QKgBnwVIRjfpzYXN3QXN9Yel95 qXlpAAyB6zO+Gfsycl0AWBq3jb019srYTaqvJ8lZb6LThLZYyNnzwNePEf3b/+mwJLaOAYC5Efre Rip+Zeylsa/G3tP/8x3kAYXXwMX+J06t00h9SyWqP5PUd1EAAJg8fwVg7+x1nAaCOD4JUZCugYo7 IXHiMZBOQjRBSHQ8CW/AC4AoroeaNuWV3JXXUFPRQ5UqKAF2sDcZj2Y/nHM+Nv7/pJF961174vOH vDs7f4haAAAAAP0i9KEiyzlxw6vUjs7Ozmm55Gbr8T4pNMEiFixAwSIWvKzMi1tQQ8xCiluwiIUX sKhELNZiFuv2f4WwRV6i8RIS85fgo6cUX0vwswQfmVL83ASIW3R5LIhbdHu81PlsxtxIoScpaMFC EpWQhV4uxHLxX8hiufRCFPOVkEUlVDGvhSzmK2GLdfnvhlXlUhyDBTQWwd8yGg1oPJ7R6emQptMp TSaTxu+XghZS1ML/LcUsfLtt4wUttLCFX2fzoha/ZrO2O7fLDMGLhpDGlhK5I9F/et+Hfo4O3b+c /ff9f5iz/12IOdyl/TGc4+j22oZ1vWHdRo9OenELKWixErzw9ZUQxsBvq7cPatEMtsfjMZ3U75sE F87u183uCZe0yEVoYDUmeJET6GEtrVNolQMAAAAAgPbEEs3x+rWzm925AwAojBfOPjq7omqCwRNq ThQYUVjwwppYEBLEiE00yJkEFytrayHa1gc2XZ77WIC3ZZwsgq/nW2ffnb2nKgAdgEPh3NlTozx1 vYcmZ+U8E0M6uta9qe9TPAO74+2+HQBAIb8RcxN/WUlrNklYnpOkPJUI5zgDmsChopMtMd/25AsA 24DfCT8TdVKJzELvBvnM/xMw692ghS7avj+033odAABAPugbAKA/vKFm4pqcPnlZT8cVhvou24zz SBBvCLaFvN4eOvvs7JOzB3vzCIDj4Mcd2rb5hs/59o/FVW1yTAA0fUn+B8pA9vXGxvtidXLaW2Mn FClPERoXBMB6j3v7SoiNBoB57uwR2f0qoXgzHbvbRX+OJBaThv4csEsu9+0AAEfKS2dfnL0mW8Ci zdwSXRbKbxATXsqJl9brEswZAaUSm6ej7w8Ws3hHlZjFB+pff9YzSj9frOdIjvhbahw1NfaJ5w8A oCj+CcDe2es2EQRxfIiIUlAFiQKlQEDlOnmAUNKlSJeCGomejo4XoMdKQ5sCiYKKB4h4CGijpIoE yHLCrtdzmVvPze1dzl6f7/+TRtn73PVH7GQ/5gepBQAAADBstM7+t3UXnZ5+o93dvVm5LJe4LZJ9 c2LtkIiaJRVUyCqkyCLILG5m215q4YMFF3weiy0W67oV9dXTh8T8fWgj06d2rntb+9BGT1/a2QbI LbqsC3KLbuvTns/y3K6778SwXjecfzMTWJR/TueSCS+DuJNZBJFF+DmdSknFv0hwwRKLvwv7vMxC 3qcszdCfsO1toq2tSzo4eEnj8ZhGo1HpMbPMgkUWk8mkKPvIIbRgYokFBx9jqcXV9XXy/aSYIk6g XhxnkYWvK9rXpdhiU5LQr3Oi/5T7Q2jR//tvwmPIeX3K/XNIT0qjhvPjcl8hqOCylFdE+x/OgyUX XLZGMmV9z3Z2Uh7KExevyJ7I8UDZ12QgtW6CozXpAwAAAAAALI+qBHMfs7UIANAXnro4cfHdxZmL NxSSr1sSi3jxgbXAwBJZ1Akv4snBVWUi+//SJovqJG2u2VTu8zymXt/ktXvs4sjFZxcXLs5dvCOI LMB685qa/S7IaLNwmCr2SYb6mbZKjnI3AACBT2bzM+E8LelMXVKalETjWpJyLQGOVU98jrYNwDKB 1AJsCn9cfBHb9oS1Rao+/+PP+lhSkRKpEovUtgIAAOiGlP6/IfIrdwMA6Ija9YVk909a8vKmSV7i ukg5DsB9iN9PXpz+g8IYKQBg+aSIJer6IqrORR8BWCWHuRsAQMTvFtek9Ltq43ha/3B8rnY8vjcA Eus7XXsPYW40AIFjUW47Ly3uw9HWmsblqvok6MsBq0L7G+RrprYAMAQeuXjv4pOLfVpcT1K1bcku tDwIqWtOrDnVZJQlGIMAfSBlPYCM5xRE3n7e8AcartDbS+BekD22WSV7qxPFpazrIGWbSH8drf0A AJCd/wKwd/66TQRBGB8Hy4pIRREUUYBwQ5kXQDQRFQUFVYqEV6DnKajcp01JhxAFokY8AEWUjiJS pEgoQbHJjvfGXq929+ZOZ2/W/n7S6Na3t7vjs+/s2z/zQdQCAAAA2Bw0Dyy8aPp1XUV7e09pPF6s zhW3YBELFqBgEQveWhNxC1oQs3DFLVjEQgQsrIjFXMxiXv6/J6TR7mSUEJi/BB+ZUvxkSvC1BB+Z UvxsA8QtumwL4hbdtifnMy5oweIVaUGLyUzIwgpbiKCFFaVwt+PxTUTc4npWZi5s8W9al63vdsFi 18X2Npnf/nM6PHxDo9GIhsPh7D2KoIUvasFpMVfQIsc9SUQsJOC5pGV/v9+fHndxdRWuoI0IhStm wS9dYYsOKT0IvbSxyfXnCvTfdRuoP13/ff+M1+EcNzq+si1H5KLniFjIiKOIW4iYxUwAI5CWY3uS V+VPP5+qzseDAe3v7GhcfGlsUBV74LjkBxYNTd7QBB71B1ZJsQ2dwtB+AAAAAACgo27Blpv33diP pXsEAFgXXpBdZPDF2Imxd8YekX1W7FP9YoKY0EVKACP1/KkVtmgj1qixFF3Vk4suz0VdfU2D7ofK s3FQIZ5Q/9XYH2Onxo5ocyfYg/LgxVsPndfaa8C/FmKB4jTXXOq6vs/3rFLhuVnPcjsBgMPPRJ4m QHhMhCImYFEXkDyUH2sn5C8AOfiV2wEAOoKFLf9Wac29tk5gYhJIh/Zpfg/8cpMaH0K+htIAALCO 7OZ2ANBZbgcA6AgWO39Pzfoq6/Zrg0ql8ogW+yxjaQC0+N+bD2QFLfYz+AIAsISe7WPHaMqgLwCs iue5HQDAo4moRapPuMl4YZM2NPd7AHxS4xQ8N7qNmAsA68YrsoF6/XloTGrebUrAosmcUn++WWhu GvpzwLJI/a+4NPZ5VY4AsKFwn+onYx+NPSG9mMVWYOvHP/Drio0haOdRU+Q4n1QeADlo8n2V9Ftj 34z9Nna8Ah9L4IDi69Via9Y04hap/8excc7Q54n7DgCgCO4EYO/sedqIwTj+RBkIQ1CR2NqhH6Kw dmXkK7RiY2DIGFY6dmdDYgWJjnyEsjMysHZBZQiRTklr38V3z1nnt0sud9b9f9IjO45jP7kkZ8Uv zx+iFgAAAEB/qZrk/+560dXVHe3vf0zz5WDeSmyiSLkQhRKzUAIWXNgiSZbpYylqIU0JXKh6Stii ELLgAbzXCygeQ2D+GHyUxOKnJAY/Y/BREtPnHgrELTbZF8QtNthbSdxCF7TIUEIW/1Ihi0LQYsHE JgpBi0KgoixgkQlVzFNxi0zgYp7XWSzmqzoJE7NQghZJ3oeJ3d0lvb4+0WRyRtPplMbjcUnMQglX SCGLJEnyVOW5qIUubLENS6/6KlWB37mwhbThcEij0YjeZjPjdahEBZJXwdRZfsDSAX9eq7cOXQsS X6f9rgf69+mjzdd3of2+f4axt9+Xa1xaQWRCFirNBSpUnolUDPlj8bwSuEh3U7C8bQdg3o+wTzs7 Pm9LBhuVGxL1zR96FzbxipDNh76BKfmlAwAAAAAAzWAK6HbZmkcAgJj5Qtn947ewX8K+URbUyHbA IETIIkTgok4g95DDCCH/hescVqjbfpMWwib68q3LP+fPlAXRuhX2R9ijsAvK5j0AiBEpaHFI5d9g VT70N+Yj8MPxnbfDXN76nLTtAAAaDyzvs/PBR7zCFaicByR3BSO3BcGxlQOwTV6E/W3bCQDW5J3K Y4KOTRTCd2zQxwCbmcYK09jh6ysAAPSBgy30YZq7qKqDuQQA4uaYsrUhiWmusqqsap7SVce1nkCO vK0MgCr0ufIPwu6F/SSIpwPQNKGHL21B0/HfH3QJCCKBrvFSUWZbW3OJCdnMVsfWNu7jwIVp3Det D/xo3CMA4uDrKjXtCfOdm3Ht5eXt+uxRI0MZAE3Cx4ybNh0BoEfItYVrYafC9sh9zkQXrjAJXvic O6mzJkGGujqmcgCaxud7qX+XZWyRc2HPwu4I5210jsh+X/C5j5jEL2xrnb7nOQAAIAr+C8De+bs4 EURx/AUkgVh7bdBCQSz8A/wHDtQ/QbGwsEntP2FncSDa2Qpef43YWthqIVx1hRbCIcdBDt84O9mX yZuZt8nGzSbfDzwy2R+zL3fJbrLz4wOpBQAAALAfpH6kyOUPOQ5LFU0mt2k2W6yulk34CDILV66l FLXYIsgspNzCSSzCtvX2XmYh5RjxsdqiDxPz9yFHB/Jsjz7kGOhTrk2B3KLNY0FusUbtFPe38TIH P3Z3UWghRRZXQmQhI8gsvNCiFltcCLHFxXyZF1xcVnKLy6V9g8jCyy1mIp9lxuMrOjv7QkdHr2k6 ndJwOPSvKJJaOHmFDCmyiAUTXRAkFi6cwCIILcKjYzQa0a/z81JFtCCmiI4xF1zE8gopunDBx11H arEvk9Bve/0QWvS//l14DV3ub6l/m6Un85ZGIbkYCLmFey7FFkFiMRdgKOWw7SCsq9b/y7Wq84Cv pXfHY0uKDziuhVRCurTcgSNePqBmHTxCmQyP2p9QWw4AAAAAAGzkJnCTy1x84vi88YwAALvMHY6X HCccx+Q7PN+j9IACbXCBVi4NNNAkjTnZRa6TcFOZIxm2aSqH7Pp3b9Ncm7zGpvVr/7ubHE843nJ8 5/jG8YbjEWFCIbA7hL46ls+RZRCxZdvc8Sgqa8/BarhJ0Z52nQQAglOOn4l12oQglgnNU+KKkuQi ntQm3l47RnxsALrCvf++dp0EAGvynuNPVbZMLmadrEye0zVpRUl0kbuG5AQXuUmuAABgn1jn93yT ewO5ewoAgP7zguNGVdY+76u0AaRk5qu0r2htLTgXgRzae8bJiH9wPP7/6QAAWqR070J71PYFYFXu d50AABHWdsB4nUVIkTuv5toVtbY+bR8ArMTvWTdZ+WmnGQGwHbj+aNep3P9T60+bElfk6grzWFru HcXr4zIAbaF9J/nI8bubdADYO9x16BnHB47nVB5fkhpPkhpTYo3SNYxo8RpVan+Qy3H9Apsi9f1J Wx8/d9LVd+RlFq84JptOtqe4ts9bVB6nUfpObNnHItMhsUwD5xsAwFbyVwD2zli3bRgIw5ciQ2B0 8dKlQIG+SeYCBQoD2YoU6FgEnYI8QpY+RIauHQoDXbpmTuZkCtAxb+DYVsKzSJtkSZ5oS5Zk/x9w EClK5EmQLftE3Q9RCwAAAGA/Cf2J+SbtdHX1h4bDt4uym7jbiE2sRCdWYhS0FKSYzQpHyKIUsygW dRa1YDMCF2Y7I2yxErJ41uM+L/2ok7YTZFehDz4y8LM++uCjoU++5gJxizrHgrhFZo9O2T1/hSdu MdfbzHV5viyX5gpauGIWEy1eERK2mFjtT1rM4snqa7YwollU0II1FwaDibrH/6PxeEyj0Wh5HLaY hTEWsphOp0lRizaxRS3ssl1nUYuHx0easrKX3GG5sMpGvMJOsn5grXeELbx+co+lSZDov/n+u57o v+oYTfbdZ/9N/10/R7twjrP3sZbO97RevtLCE4tZEyyCZAlcGOEKI25xqJaHltCFKadmThh4/fuj oyou88PVY3IncIQSgabEK6oaCftQoAwAAAAAAOpFSvDJ9YvtuQMA2HFY4OJM2W9lt8p+KDtRNqS4 oEVKvCIlcOG/CJcSX5QEGVP1TcQpcvdbd7xNbJMx1z3O1Nimzkkeviv7RaWIxT2VIhaflb0jAHYT vrbfBNZLcbXY5zjnheJQv6HPuu8XWI9PbTsAgMdfoT2V1DyW0EZKOl5QWuCi8Przx5R8A2Cb2Ncl RC1An+HEZteJ9tD3b859ICRA4QtdSNuF2nzfQr7ifgEAAHn/47cRA0BcAYD+MVB2ruy1rtvxw1gs cp3EUbHYZmxf8paIYwKJ0HXCQsT8fJMTq0FMHYBuk/qPnytQgXgBaAqIWoAucSe0V/0ulGLCoW0o UI/NYQ2NF4v/gv0l97nxZbPuANALOJ7zQZdD8ZOq8ZfYHFxpjlrsVVgD4jagTX627QAAewaLW3yl Mgb7kf4XrJAELqq01SFuIc2pTt3TYm0A5CBdS6n3AvhZxxcq3+W6UXZKeOZRhWNK/8at6x0vitQp 0uavBwCAzvIiAHvnr9tEEITxOSw7RURt0sAbQEcRIStNJGhAvAkSJRK09NTQUblJkypPQIGUKh2i SYNEhYTARRJ2WI9vbrP/7nz2ne3vJ41uvLe3N44vvmRvZz6IWgAAAADbT+yfVIGTpo9TAx0c3Ker q+pwpdiEiFnc/Df2RZSC6ziLz8IWLGShxS1YxKLse7MQwSiFMexrEctYR3HyPhTLTrEJMTKIsz02 IUZhU+JsAsQt2jwXxC0yRqn4WtjJiliUObtWWELEK66ViIVYKWZhzRWqmCn7q8QrZgtfxCysX45V nsv/hgeDgvb2ftN4fIem0ylNJpNbghYiaqHFLETgQvazyTFdIwXgRchC2hh5PRwO6eLykv7MZnJQ dZs+SdVXQhZuW5OC9Cj03/34co4uj+/D+Kv+DFfNNnwGyx7f9xhTY7c5/uIJpdwTyN4XRMRiIWSh BC0G83bdx9e/kH1zsYxi3o/98WhEj/b3c0J8Ymw0P2wg4VJ1EYivMGjh7I8VDNU+ZWx9P0JfOwAA AAAAaIYvmUuMCy5+7iIoAMBWc9fYS2PvyS6KPjX2ztgh5SUfxAQt9Os6CQg5CQoxoQW3T5sCFJq2 xuzyvLEEELeNRU9eGHtr7MzYD2NfyIqicNIKRCzALvGUlvu9q9Ou5+dC3wsUaQfNedV1AAA4fFV+ TMBCtnWKl+daTOTCPQd5/FC8AKwS33V2vvYoAGiPE+Wn7ge+Prnf89cZFro3xASRQoXUYu8BAABA HMwHAABcHhh7TbfnFrWfM1+Zek4Tel7jm8csPNvQ8w+w24SuA86n/W7s+XrDAWAnCRVWzyluHiO3 f6of5gxAG3DxQBQLBH3ip/Jz532bCFL45mVDc7b4vgVtE3puzcXKf3UVFAA94hnZQuJN1p6F8kZj a2h1m5BapxbyAViG0Hoiaf+wxlgAACX3jL0hu0aF52Tr5pXUySGJPZOomwtCiX2a2D4AXOpcT6Hr 8sjYJ2PfjH009nClEW8fjyn+N7GQI3SRykUjZxv67N2+AADQa/4JwN75+zgNQ3H83bXSnW5AOgmm DgcbYgAkthtgZ+EPYEBCTCzsiK0SfwEMt7IwIDZGNpBAbMfADGyMDAdSBA3PtV/z4trOj3JJ0/t+ pCc7ju04VWs7r46/474bAAAAAIDOCTn171cVOjp6Tfv7k7lARXmT7twd54v0QoyiEKXQIhYibpFl s3nciFoYE4ELySPCFoVoRvk/6y72s5ZrdrEZbluG0EYD2vn/GEIbDUNpZ1vM7bW7Nem8mhWWPq+r j7PL63X9XRnOZ1lex1UIWuTuuHhf14pY2Pd5rbDFjK9nhS6I/s5DLW5hhSgyFS4LVlgxCxHCyFQ5 Ecj448QsrMXWlO3sGHGrH3R4eIOm0ylNJpOkoIUOtZiFLrMOiKCFhKPRaCFwITYeW7fL7yyjc3t7 ybpK96WEKvJyxuW4Frpo8CXDRv+bUT/EIDa7/tO+xrp/B4dSv6khdyG5/lynjYzQkXleJidSwfHS qgcRtuD0Mcfno7kZHzk+lrjKL6O/xHNzD67Og91dOj45qWryBbabbG9dFbKAQ19my6XlVF6gIZdv slBjW5UhL8zVca7SAAAAAADAaoTmWaFzwlO2ux20CwBwdrns7J47/sT2ke0L2we2n9RsY8rUBsep 0C/vP5sShZ9PdZ9KFekhZ8MQnnXrOElWyWPSzeYN18j6Ja66OEQrACgwv40X6lj3UXVs4TKksgsx lq/Kr1enzwPNuEi27wNgXXjP9ityrs5GYlXztbZWVXesHQD0zXHfDQCgJWZTyXeJ8/4ztYR1bObF Y8IUvqiFXz5ULtUe8uL+fQAAAFgm5fuLbaIA4kDwDGwqV9gesj2nuI8x5H/UvsvQGkR9XpffdtfV +YmW+yH9307Kv4k54dkjNmZdIrvJ060O2wIAiJPqn1PP9zE/dlV9AJwW1/tuAAAe3xvkja2tip1L rdGq6p9TeQBIEXrmC62VlvgztsedtQ6A9cRsbHCb7RXVX4um/TR+Wuy90tR6NCL4a0D/+OPEN7bP hI2/AegLI27xhO0B2xu2l2TfJ6kao+S3rMejmZeuxzA9doXWlWwF8vuhT2jeqc9pUufA2aPNuzih MibtgO0O2yPC+zircp7s+v6vKk3/tmWuW3d/lVTe0JyZvGO/f/LB/BkAsHb8E4C9s9dxIgbi+CCU 6iSgSJ+OjpYK6XgAhCjT8QIUFOl5CBAND0GBdD0vQAOIlkM8AB2KQlZ4Ys/tZBh7s3vJfhz/nzRa x15/6JJb7856/IeoBQAAAHCzKW0aITyhqLBdZLG4T9vtfnO12AQlMYsoYMFpEaVgEQxJs1iFNRa2 YIGLWsSiFrOQ9viziGXsC2r0xxQ255/CGBmM83hMYYzMVMbZheuJI1j/dB99tgfiFkP1t7/WSwta RPEKRoQsJK9KAhOc3ob5Mwpa1GIWWtBiY4Qs+PM65a9T/p+r8n1BC20iaOHDghbr9Q9aLp/RarWi +XyehLBqY/EKMRGzEBMxC7ExocUsJC0m5bPZbJf+vdn8W5/St5w2I1cNxytDErTYCVukH81VWkQv Ul+k86wQRmbspwQb/Z++D3yHw7XdVx9jbx9/44a2KYpVcB/bJHJxSwQt+Ei1ioSIWNzmc7meOid3 vl4ZKEpr3MY8zDsPzs7oc7OwxaNgH4l2XVpBC+lOB4aKVabcMxtUKjcuuQUd3stTLFQEAAAAADgN 3v0Xp78He0txAxIAAOiDh8mEbxQFLljo4muwLynfe+5kKlVuz7P59mifOe0x90zq1RVy+W3Lx0iX xfPMIhlv0s8buHPgFxbMA1CGg4jPKfrtvIAEL3ChTXCEF3CsAyIE7bcj8u8h7djAYbwcegAAGD6p dC4A08vz7r3EcpuVS1ll0lWmnVw/dhwAjAmIWoCp8l6lvWdhm186x5sTPKEKa7n5omluyc0HmCPA EFxS9IUAMDXG7JucMr+GHgAAJ+Q8Hd+kY5Nv0vNJWpELve6QMnWsr1PeFZGqY32bki/Ap/n/UIqn fUVxo6e7/Q0HANCStv7f61zbMS+AY/J46AEAYLhseX7J1+r5iHO+YaLDruVe2wB0Ibc2mp9bXwS7 M8SgABgRvJfURTAOOC2tPztEzMLz6eTq6I15PZ8Nkb9GDoBjk/vtvQ72rv/hAAAULG7BwhZLisIW H4L9pPw7BytmoeeaSuXb+UmXe88vTfOQrmfXVlPhs22DCuXg5tElDserI3n3gj0N9pxijA44Hvzu k30o8n/p7Y8i6a7xHF69Uvv2/abNAwCA0fBXAPbOX7eJIAjjYxMZBdGkoKIILQ9AiXgCFCRaWmQe AaG01CmoUiOlS0eLBHQU1FAiahSJhsIWd+z4dnLj8dzd2vL57pzvJ4327+2to+h2tTu7H0QtAAAA gJvFyIm/anro/PySjo7uLwQqlkUl8pjOr/NLMYpSlILFK0TUQsL5fDk+n2cLkzoibFGKZizvTXd1 r/UQLucfQh8Z9HN7DKGPzFD6uQmbiyPodaX137nLPyXELXb1vtVzv+sJWpRGxKIUhZDFqqiFCFqI iIWIWsyccmmjiPP910Wdf7R6HqTk8DCjq6vvdHr6mqbTKU0mk/j7C4EKFqxg02IWEkpZXwUtmFG8 rFwELbz0bVb1CPydzZLb9H6pFrYQ4YrFynSMX4talA+4kyVcQt99+9t4x9D/Bmi/+3f0/X+w7Xe0 0faSV51qX/LGUXRiHONjiYuFPFaJuBXyD7guFUIXWYgfSFzVz2OdURTMELjsOIw9CaIW96jYsP5I 5YFQK24xolK8wopdaGePlA3WsXqGTOg5cfRv4AcAAAAAGB52nkW0Ou/S8bfBXhAObwEAuuFhtOcq 7ysVAhdsLHjBQhfeYYCqA9E2Tibfc+ytO4BddQDBq2PbosTyvrCOAz1f+COiFccxfNxSvwC4CfCa 3Wda9e3R62hi9gCwV2YPFG96QMIejOjzN6zPPOu6AwAofgf7llAvZW6ly7dlTe+x+VVpAHbNF8Kh UTAsfkSrw36Xve+2J0xh0yniFlbMIkXQwhtDqCYOQFv8JIhagP0h1blq/w4EAABSeRLDdzGsWp/M nXTTWkBOywIXGs8HUaP9D21I5jnMEfePunGJy06CnRHmbADsA3YNwJYB0BUPuu4AAIZfTp63t5b6 TfXm7t7enuen5ZV5aQCa8Pz+qnyj/1AhbPFmZ70DoJ/cCfYo2CfyfdDqfM/s2k7dmdIU/7Qqv1r4 poE28Py9dT5fns9jBYRPAeieu8FeRvsQ7IIKXxZvTNFjTWZCvSdQJW5RZXr88fLISadSNf411QHD YdP9de85ncdCFifRnm7QL5AGz5Xfq7TdZ1xn3ivlmRP37lmx3zdSZd53CAAAesd/Adg7ex0nYiCO m0O55iQqdCWhokOio6SkoYp4jHsBHoQKKe8Ab4CE6KClBUFxdFScxLEJntjOTmZnvJuQ/XD0/0mj 9Xq9s6Mo2g/b4z9ELQAAAIDTxfrY5fWkvvi8zdF8/shV1a67WmzCRTGLIGBB5SRKQSIYqUxiFdKk iEVot4qCFsGoLK81BUpYnL+EGAnEeTxKiJEoJc5DGFrcYmgxhnTN4cQf1oP+T8YXt2jOyarFHFai XMXjmqDFSghZ/I0iFLdRqOJPrKtFLEI5HK/FLG63Yha1jyr6bBe0uL7+5JbLpVssFtvYuaAFiVck S2IWpQhaJEi8wjL6785ms027m46iFhuYeEVjK8UrQhC77Uy3/f6xS1/kvgT/U49vCtco3X/f1ziG 79J/46H8r6PYxGak0ddVUcRinQQtaOtqFYkkYnGX2tI5rI3WnvwndYnk00XhjMvzc/f44qKLsAUt qPMhupSCFlzA4g6r4wOo2xAUOxPnppcGK2FUG1C1kkcx+AoAAAAA8H9o719U/uXttbdXYwQFAAAK T6NxvrggcvHd20dvP1xIwNaSprWytuXttARXra0sa0kFVidE24DQUN+8XTpJeBsSqqBJ8Um84oGD eAUAfUACP5fefor6XLJvLnFYJkJ0SaxYi2s4t3vvQhLxYZCgxXzsIABgfM4ck4vXaOW2hWq48UXJ rcXJtXrrOlq8AIwJ72v56iBqAcriDSs3J6410drIe7YUptCeCbnnQhcxCyu+XD0AAICANUfnWPfP 00sOAABYPHPh3kELhFp9kPuKW5yJsmPnyj5PPi+Rs8/8RLw7ngZt+bNPXBCzwPc6AOVh9VNbbXP9 FgAMwcOxAwCAcePtt3Esd2/UxuXa+oXl1vKhzefSjgNwCNq3X/pmvfJ2b4ygAJgQL729j2VrEV1r LpnMKZXjetY5bfPREta8NAD6gD8vKH+GFrC+GjUiAIDkRTSa3/jO21vXXPRd2+fPpZWoy41LWN8q 1nNJG3dI+87Yl1h+u7QD47LPWLjWtksd5ezQGBwJWdDaoBBf6p/7Lszx/ybqrfdmXtdF/C33rq1d o+t9CAAAJsE/Adg7f98mYiiOv6SVMjBUldgQgpWVGQVGFiR2ECM7Ejv/A0xdK9YuYYIJJP4BFmaE GFkqoUhRS8Av53f3zrF9drjcD/r9SE/22Y792lx9V//6QtQCAAAAuDpMPPHnTR86OTmj4+MbG4GK uqiEiE1UohPrtYhbVCIXIlqhw4uLelwLXWiBCxHJkDbkf6khnW09hsP5x+AjAz/bYww+MmPxcxf+ d3GLLtvr4z7pUrhD2uPvXotb6OdeJWjxx+b9LsNK1OLSilmI6ERdzELEKwqxipVKX1khCylTF7Qo wktlRf2h8U3WV5jNVrRcfqPFYkHz+bwmaCGCFSJqwWIWrqCFlJPPDBW+J2OCFhyKqMX5MrQGsKxs 85ngTyv5AYGLic0P3bhjPyR+322Mwf+xf4djr7+LNoZeP37HzUxtPz4pGiuFLcrdmFZ0YmrjU4mL mTRWiTgw6Ydclgqhi7WJH6r4gYpvZiZtO6Ufxm7NZimiFjzBypPaH6guZKHFLSZUiVe4Yhepk6vi nl7ASE6oF2iENpECAAAAAIB83Pcsou33Lh3nzVtPjd3sykEAAMjkjjXmhUr/SoXQhQhesH23YdNG al/oprmbDChy3VQmNECx2wTRvyPtiUAFi1Yc2ZAXxN/r2B8AANFDY6fqumkjsbvRwTduFxO38NXt O+CNPOkgncd9OwCAw3sVT/nb9m3e9FnKJtBYGV/9Pj9S3sEA2De+sZUv/bkDQDafjf1sKJPS96f0 +yEL5bvPi5xDBigSBwCAq8L1PdTprvcBcT717QAAHfHA2DVjr439Iv+hLO5hhzFhC/LERdxC0IIW qcIWbp6Acc/xEnseSd5tY6+MPdu7NwCAttilPw6NFYfm/nPbxTMC5HC/bwcAUOiDGHP6Sl85XT7W v+bO3zX5hT4YhMhZG31u7J2xJ515B8AwkX2kH6k+ZhI7ZNcVH5U5O1/5UH3uerTUg3mxtxS0jW+N Nqe9IYhaADBU7lp7SYW4xVtjP2j7WaQFLNwwV9xiErgmlabxnY/g4pun8BF6PqaUA+2TOyfuKx+q w03na963wwIWLGTxKLNt0A78rnzqpOk+IHaGSlN+yrXbDtH2+7GbBgAAg+CvAOydvW4UMRDH57LJ NaGhQemuo0BCRwFtWl6AioY34A2gQVCnTM8DINFTIJ4AiYoOqOgiQcXpdvHEnrUz54/N3tfu6f+T Ruvd27Unp4vttT3+Q9QCAAAAOEy6vNTyi+zTUkaz2X1aLm9mJyIWXszCC1B4UQqfDkUrxBaLekXE wgpZ+PzC86aZDErMQjOGzfnH4CMDPzfHGHxkxuJnHyBuscmydvs72e132QRl6jVXoaBF7YQr6iDN AhdLJzbhBS28GMW/Ns1iFnJu04tWxMJfl/OYoEWdFbQ4Pp7QyclfOjub0sXFR5rP506YypuIWaQE LUTUwn4fA274idq/iZHfpT5WVXV9/H11Fc0juapCi1fc+MiJWxwdrdyjhTGwCf1h5D8GH5H/sMsY uqDF2PPPldGuzjOfL52IRSOCFnwkryIhIhYV38vPqHsqU+9ft5XkRTFEXULyJCeccW86pfnpKX0t C1vwxpSfXfFa0CIUsJgE1+rgvHUhYnoRowSPphaHxJrF1AQrFiYCAAAAAKxHrP/FaR7AeGvsch9O AQDAGjxwFpv75uCFX4FxoOo3svUei2DI4K2uE3OB2+FAfmwzpL4BBNt41xWxChGqIPLCFWwPt1Am AGA9zmlV1KJL4K8OFq7Veeq+XF5E3cfsQBoONnqxbycACGDxr9Qm5rE+UamfpC21IXkXK92vfUVd BIYGRC3AmPgQpFPvvSm61OM1xev1kshFqv7X6ZivaBcAAMDCG5TtY23N4QUCAAC68MTYG2OvjP2h /JilXlt4m35fiBa2kH6mEJsL77NOEQyPLvGyd429NPZ6++4AAHYE6mcwBh7t2wEAFD97PJPrl6fm C2PHWB9ff6bLBWATpNZGvyOIWgDAPCMbR6rHSXJjOaUxnpTIRWlTXyE1VgPAtpHf3g9jX8ivtQYA DI87xp47+05W3OIT2ZgQaV/CNkkfm0g6fC+pqfw+o9ur0rrFXNsmeZVIPZ96Fm3p7eg7r91ljqJ0 Xa7NyIpY8B6g5z39AZvjsbH3kethPTNR1/rEdeg+sb4//F/OzW0CAMBg+C8Ae+ev2zYMhPGT0CBA liLo5rZppg5FtkwFAvQV+hYdOvQFOmX02skPkDFA0TFZ2nfIWqBjgU4ZG8N2dRYZni4nkjasWnK+ H8Do+McUDcikwiP5QdQCAAAAeBwUhv0h9aHJ5JIOD58vBSq8gEXNwsUX9+lBjCKIUnjRCnmdTpu2 FLqQwhZBNMPfY+7u3++17kM4nH8IbWTQzs0xhDYyQ2nnOkDcYpP3+r/PSfffrbk+xgtbFMXCxYNf pCloMXO2F7II11qMQgpT3C3FKmr7r0q7E8IXWsxiKuqeOQENe55zb4///qHT0zc0Ho9pNBrV30iI WWhBC3/1eUMStPCUZdkI/FzKa+mEJ35rUQvxQC1nj8WDpoUpHnxOCl1IW4pcUPe/ERz03339fW9f H+6B+ruvfwht7FP9DY8k9+dV/y7TSic6UVIQppAKEpy2FLCo0p9wWQpeSk6bSSEMHl953OC63X08 XObl/n6OqMUzqh3d19QUspDiFgUF8QotdqEXHsaCb9pcxOVVOnPhYAUAAAAA2Bx6wWvbAlifzgt8 PxIOOQcA7A4vXHibKMcCF7fOvhG2jMuNCLJMarN1avNBmzPozCjLB6PrPprjT0X+SeReAID+c1CF dxQ2ETMFPewrcjZBzI243FxszeF5cufsMI+X5v22GwCA4krY1u83tqEydpCNDjkHm8c2guqDbmJt A6Av/Nh2AwDI5Cu1Cxx5Uv283uSv+309BuSMBZYokv6Mjsu2xmwAAABp1lloterBHQCA3eS4CpMq fK7CT2rOSTJ+7aF8jyuMNDJsUnV4pLAFKVsi5zV132TNdVrpYLvExhSZ58UsPlHwmwEAdouc//lz 0mP9PMYAsC7H224AAIpVRC1i6560beVZ7+9tZVL3BiCXVdZG/6rCBUHYAgAWQ+Y1ad9dPGcNWq6I hZ7zaQt6/Zm1Js7KA2Bd2uYE5fP4hSBqAcBQeF2Fcxe+US1uwUGKVuirzFso24qnfBZ6LJP51hiX 43ew+qq2cbCtnhzf7GMYVzfho871SeTkFcrmMz28kMXR6k0DHcLvyq+oFryy/IfyN53as2Htz7De oWNlUu/EeFcGAPSGfwKwd/46TgNBGJ9g6a64NqJNR4OQqKGgo7zqJMp7gkh0vAElb0DDG9AgIVHR U/EGtOiqQ0IhFwePdseeTHbXG1/i2JfvJ43i/ePdjZN4nd3Z/SBqAQAAADw8chzD+c/t67aCZrMn tFptFteITZAXs3ACFnwsohQsgiHHWrRCbLksN0QstJiFlMdhW5er3x0MfdP7MbRzDG1k0M79MYY2 MmNpZxcgbrHPuvr9nhzmvW36cImgBRsLPLj6RMhiHRS0KMs7/yoCFHdKmGLpRSv4dVGHGyGLfyq9 EbVoyhETQYsw5+dEi8Uvur5+Q/P5nKbTqb9m24IWWsxCBC4kj+QfCxMvQCEiFkVRBAUuOP7m9laf mFN4Yzps6q9ftaCFbxcd8Fo+tE3oh1jH2K/B2Mvvo46hl49rvL/y69nFKv/Ki1isRdBCi1SIVfGF F7TgeO6BCy9gUYtZUCOKIeoSUiZ54YzHZ2f07OKCfrYLW7wkt8GOVKkFLbSAxUTFlSpcNyFgj8y5 smg05hwSmkCNOWxgshUAAAAAYHdSDrH6mexdZV96bBcAAAyBp+r4xdFaAQAADl60wmN2djFLaEFE aGGDTSsz8lIkHFsUgfG5fN4euwEAKP5W9iMjn110GVqceR9LbWyeagcF8sTiADgWvFEUFp2CIcN9 wVcVjt17Q2k6LnWP1/f6Xcyen9tPxNoKAADgcHRxzDqlsQR+n9/JjfEAcCqwWO+Hyj5W9pm2fQft sWCf81JjACtqF7aw5dl7j54z13GanE2mwOFo62PsuDkLvkPMAoDTIdRPhMYMupYNQFeeH7sBABh+ Z+bLmX+LjQWn0jC3B/okxzf6PUHUAgDmipxPml3PmfI7C8XpecGc80I+aUJsTSkA+0b7Qeo43hgf fh4AjI9Lb3+oEbf4RvF9C3S/lfJJSf3fmQTSbFxbn5Y7/xCay5DzY+e2ldl1440+++g+NhDbZQ5i l3Q7d8HMyH1PX5GbN8YcxrDhz+kThT/L1LqLUHrKbH4Jr00a0fbvD8/NAIDB8V8A9s5fN4oYCOND hO5S0EQCGorQBiFR5AmoQeIRKCjuFSjyBjRIPEBeIqnyEmkQlCloaBKJAokc2eA523g82F7vcXdZ n76fNFqvd892ojvPrv/MB1ELAAAAYPtJvSTN+j50fHxKe3tPFgIVUlSC32nseRCdCGIUQZTCi1bI 43wep6XQhRS2CEIWMsA3RbGZWwl630I7W2gjg3aujhbayLTSzmWAuMUq69rs92R1f1u8N0IKWljB CqZz4hZhn68XmAhCE78XwhZSjCIIVVxHaStk8csJWFyroxfBsOXYuueujo5y7O52dHX1hY6O3tNs NqPJZOL+T0HQwotXaDELNilm0ZKghUcKV/i0FraYTqf07fLSfyB+oIkLy+fra168wtRxS+H7z+eL vJu8CMn/MpYg8dtcfgttRPnjrmPsghatl99Xh1zlwH01+zeZt+NEJ3YoCFNIBQnOu8/3GB/Jg/ed E7Tw4hY3UgjDXVvMTLp6PHzPvvFBFaIWj4y9JBu4RApZSHGLexTEK7TYRWrxYWmSVYpikDrqhcSY WAUAAAAAWA+lQB0+yM6psVebbBQAAAAAAPjLgbHHxr6r/L6NDVrEQub3jePpDcW3qg6ieLK6FBgO BDiAzYu7bgQAAha0+Jm5pn/HuQAzQwPW6A2gqQ2hfWXn2gHA2ODv5Tkh2AEYNzwv7H1BzUb3Uh+v +/U+QQp5nxazqPUZJT+RSwMAAIjZ1Ht8zSIujCkAsH28M/bc2EdjPyiMO0oxi9xYgBa8SJETtvDP jyVS6xP1dUlqbBSshyFBonz6KVkxi7eEQFAAbBOr7G9LZfWNMaPfB0OBqAUYG18Tebrvy83B5a6l yhoyTlszFwnAEPR7Xek978LYibHX628WAKPmobFnxj6785ogvCUhC33NW2otml6TllqHpoP3YvwY rBPpNz4Z+3CHbQEALM8DY2+ceYELFrc4o9jnyHSn8muM6F9fp/NTcRJyPq3k/3Lo+zU1fnMZv9pK 0LfadtbOYddek+f7ZIUR2FjEAmsI2+KQrKiFJPXb9ce+Z+gukdb7P1JlpfqK2n4CAAA2zh8B2Dtj 3ShiIAxPbkWz6ZHSIHgCSiQkykiUFJQIUd0j8CQgIiFoeBTKiIIWKGgjhSpVWC7Cjnd2fROPbZy9 vfPxf9JovV6vPfHd7Soe2/8iXQQAAAAAFREbdGCeGTtOVXR0dI9Wq/XqRrEJ6sUsnICFTbMohd1D mdO+aAVb112tiVj4YhZcnz2XbWnUsgl2DX7W4KMFfk5HDT5aavGzhNQzLnInlYwzlbdXxpztzf09 me6zY79d7MMXtGBBCRawcOIVbCtPhKLrxSxGIQsnXmGFLC779OWQN1777R1HQYtRGCMuaNG2f+js 7AudnLyh5XK5JmgRErPouu76yMIWtQtaWFjIwhe0sGk2e962Lf26uKDuKrJOhjdHT2zEPohXcFlP 8GLRNMn7bwP/TZvkf69/031c+2dYu/9c/6730T708abrL2ljiD7yM7uvaxC2MNZ4dq0YIa/3eU2f Hq4RDed+nZa75t388PAwx8Unxu7QKFbBAVJfwGIh8v2gaiPKL0T5A5GmjGOoC0P5AAAAAAAgTWyR oLa48PUMfgEAAAAAAJ2ndHORAgXytIUQOeVSdUu0fKDzatsOACD47KVjG9XIvNgCzdiG43Kj8tTm 5KkNcOqcWAD2GfmbsHzdki8A5HBOTtRCIzSOGPqex57fvrCFZqF7NHEL2bbmK94RAACweXLWKoGR n9t2AIAt8sjYB2OPaX28MjS3kOcfanMQZX5ofmOofjnPMTR/MTbmKsHY6LTk9nfIrIjwR2M/yIla QNACgP2g9P967T6ME4C5gagF2CXOC+/TxoRTcTxtDJmU/JsLrPHcBrcnZ27027mdAmBHee6lD0Q6 Z95ZbOyldO6a9AWAKYnNj+LjJ3ICvQCAumGBCytUc2rsHbn3nhUW8GMRmmkxilCcIic2kRuziL1v /+VdShnlSuaX58RQSpjCj9K+Km1DtvPA2EtyMbHvxr4Ze2/sBUHQokasANx9iv+u5PmUFmqLRJoy 8gEAYFb+CsDe+axIDQRhvMdVNgjCehbxLL6CM4JP4COIbyHi2WfwtLBPIAOe9KIIiuDBg+BpWb3s 1csKOmti1aR7UqntJN2ZTDKZ/X5QpNPd6T+zu53ZTqW+q0MPAAAAAAAbxffPyZOmiw4PX5uDg1tL oYly0G4nNlGIThRiFIUohROtkMfFopyWQhdS2KIQsshsv3nnTbGuXTDsTQcxXZcxjHMMY2Qwzu4Y wxiZsYyzDW6Ni5+aWxzjLmzfXzv67K/v35O4uWkxC5mXCnGLzApKZFa8IrXl58t0XlYIXBTCFn9X 6Vy4wuWVxSsKMYuFFcooxCykaEaVLxjPNUn+0D381MznczOdTldlTqhCilo4EQtprk7+GY7X50yK V/jSTJIk5svxsTmneV9zwhM8Z3f0N3wxLUUsRPnE9pfJ/Lq2W85zk4y9/S76GPtnMPb2++hj29sf +2e8bePnmpk98prM9zqZx6ITKeWthCkozWIVOpIH5/EGPtdNKc135z1K/xNiFq5s+XTS9uPgOrf3 983Xs7OmId8ke0D21pSdKlJTfsi+Z6ch67igIjEPVK+Ia4w6ZuI8E3kAAAAAAKBb5PcumeeOP8he kD3tc1AAAAAAAGDFjOxInMe+DMF7cHLvTp/rek17enqPrioflHk89AAAEHAAm+8B9UICz8jypqDm TcFuQvvR+VXnAAzNO7LnQw8CgApekf226ZCgjzFBzHxCRlKsIkbkIuR+EjoHAAAA1XTpk1PnWOX2 Fy7b+nwy9AAAGJjrZM/IPpG9JDu1+c7/0IhzlxezTqSqDdlWerF6aR2aiLraV9GX1u1ILtva1oZQ 59umAD2PTC5iMVt7RACAXSVkTQ7ZX8baDtpwZ+gBACD4KdJV61zdszddt+56vWdrPGWhhOz9AtBE nW/0e7IPZPd7HREA28ddsntk3+y58x/zvR8a4lcmfdJcuuka/c6oTpuKMgDWRf+eubxfZHOTByEH AOwGN8geWmPYb/Iz2Ruyj8bvlzJR+TE+jz7/Gn3U9zTf/dCoOr5yXScG3/flNjS10VU/McT056tb db3MZ9HtmThCuGL34J/riU3r54a+9ytC46uExF/Rf+91zyrx/RgAsDX8F4C989eNIgbC+FwuOhGl SIdSBEE6mnAFDQ2CFomSOrwM9Gl4Ch6AhiqhoeYFIp4A0R7Zwz57NmPH4/2Tzd7u3veTRudd73nn Tom9Z4/ng6gFAAAAMB3q/DB+b+xdVUMnJ6dUFGFzUsjCiVk4AQtbZlGKm5vbshStYFutikDEQopZ cHv2WN6naT7mTbLQESS8H0Ny/jH4aIGf3TEGHy1j8bMNELfo8l79/p1Uf7ZwbUEXtCi8cEVRls3o 6sUt2Fh4gsUoWKzi30bMgo9deRUIWnA5FMMIxSzsq8b+/szYXzo+fkQXF19puVz6z78uLRa0kKIW to6FL/h9Y0aKWMzn87JsX7m8WCw2167M93Dgy0pjyXMbwQrlurJuz+3tmclzHTH0RPxTaH+XEv3v YvsPfY+h/w1Oof2u7lFG6VlxCi9osWZBC9OP2zGRVSS4fs7XsoiFF7AoxSxIiGKQj3rwx+SFMx6b sefs8JB+VQtb2KDcS+9CLGghBSxm4pxMiFe6kLC96L28aTQOQkwFJcqvkJTz436gAAAAAADohyZJ OLj+C7nA/Cd9OAgAAAAAAAJs0rc35BJj5zbwVm1yiDcd83FuE7FEPh8S5efvME8XYpOsHW3bCQAE PzJ1ueQ1qc2YuY2acqMnl1MJyVPnUm1p/gIwVK637QAAClbc6CpT36Tv10wToKgaF+L61NgQ+0PR OQAAAN2jzRN0Haw11TmFP9t2AICB8MrYGTmBNSviy4IWMq7wvsjnxXjuMzfH0Kb/0eIatfpdo+4Y kRpfUtc8NfbR2DkhWTgAu0qbfhXzyqBv3m7bAQAifldfcofUWp2s067R5mq1urgvRt8M7kud2Gh5 7rOxb/24BsCg+UChqIWMR+P4snXiWFsHrHpPLnEvo8WkAfCQyLHjE0HUAoAp89zbuT/+buwnOWFu OyY2jY/J/U6imq+pZ9fUeFgnZrvPtYo6bTdZT+5q7TnXTtU9UvXPjL2gWwGL1+3cAiPjJbn1zPgZ Wf7PttnDkRKRy7Wl9QF4XgYADI7/ArB39jpSw0AcnwWtTjqkrUBCKyREiSgpjxJKxAPQ0PIEPMA+ BMUV1yDegIoKhIRExSNASYloDk634Ens83hu7GyW7Obj/j9p5MR2bGeVtRN//SFqAQAAAEyXmXH8 sumik5N3tFjcrgQqpKhEFJmIohNRjCKKUgTRCumenaXHUuhCClvoPML30zbCFtVNj2DD+zGUdQxl ZFDO7hhDGZmxlHMbIG7RZV77fU7se0vHEGIb99efx/W4qaDF+YUrBSeCBVEKdon+VIIVtd9v7wa/ KGoR4kcxCz5nEYsomJFjPuf7+0FHRw9ptVrRcrn09xzFLLSgRXBD2JQELZggZhEELaSYRbA5/3CO X6entDg81AlkX3RyYhaVP6fNG6CzX3jYWNjCn3chbDGWTeL7SLurPLDRf39p7yuPoaeP33i36Sej k1wvswCj8LvmRSeu+7BEPYLDyKtLuGPuxF97QQt+O2Bxi/MgdCHCqlFKn0+A87lzcLCJqMUtqjfJ e0+pkIUUt5hRFK/QYhd6ILVkROngKynXmlQ8/hcHAAAAAIDhId+7pF9webOdV87e7rNQAAAAAADg Al4E84Euz/+RfWi5xcRWWG4RsbVAQueTWwyBvrs8L/ouAAAKuZF50/82t/jS8i9tTL6tlcqiwwAY Gt+d/SQIG4HhcSyOrbpW+5fiaJNCFesGs66xzjdpHyzQNgAAwG7oepLWVehP+Np3AQAYEDecPXf2 xNlrqvsopLiFxaZ1BNcna3WN9b46U365fk5r7mIOq4xW/KnVd23bBCt+k98zqsUsnrbMCwAwbPqo D6dWB4Nhcq/vAgCgaCNq0dQPbMXT/cm5cbxN8gBgF+hvOfmsfXT2ydmjvZYIgOFx39kDSoUtrI12 m+aZlealla6x+of1/DRS52g3wP+QWzcj50fyXI83BGELAK4Kj70FvlAtcMH2mS7PgyRKxyJK8yvJ 8Ndtm/7GyrWB4djyt/xk2BjGMLYZg25zTVPcEH6XUgELdhftiwYmwE2qBU2+kb1+Qq/hICq/87Y1 nV6pbiAVBwAAeuGfAOydz2rbQBDGxzkkh1xKMAUTiJ+g195CboXee84buHmEPkufoQ9SEkiTY06B 0l56CRTXVjXdHWs03ZHkWIol+/vBoNVq/ylI2s16dj+IWgAAAAC7gfcPtHXoe1dX0GRyRotFubhC yKIsYMFxIkrBIhgS1qIVYvP5siRiocUspDw+L4QtaG0xC8uQNrwfQluH0EYG7WyPIbSRGUo7nwPE Ldqs62Wfk+Leyr8VaEGLIF7BiJCFxHmCFkGAQsQoCoGKIFixXP7O88yNkIWEtZiFhP+osrm+hXs/ h4fclz/S5eUHms1mNB6P433+L2ihxSxE4ELSSPpdQZ4nK2TBJnEseMH8enqi05OTtcvP1HElWqEF LbRJmpbuqyuGXn4bdQz9b4Dyt19H35/BrusYavtXnnpRtIJ7CO59S4IWFLwaFlHogkUt/oVFxCIK WKzELGJ5ByyQQXGUEc9HsZ7J0RG9OT5uImxxTmGTPGmeFrTQAhYjFacdDldNSNiBySsDodSPuKlF o5KWnPjdGWAAAAAAAHSHtwGHN77i4xfCAi4AAAAAgG3BC4hf5/bdxNctYrCLhdex1EJkUkcif8Ew 5ukKXlHw0wKgL9zn9tO55i2QtHHexpDyvUltRN6VwAUAfYaf0WsKC1wB6Av30arwFtbXWRNhCk/Y oipPXf9DJkwmDAAA+8y4hTJGTthLU5XX+z5jHgGA/YPnOj/ldpPb59y+mutNvwl67nKp4jMVl6lr MucpebPEOTnntn11jqWpvE2cUfvyPdzUcTaVv2k/Ms3tisK86tmG7QAA7Ad2LgOAbTHddgMAMPxo mK7Jd3TT3/iqxtYAtEWdb7T1d+ENy+ETDQDReyqLWuh3JuVDpsUqZN7Fri3NKvJUbdwrSDr0E6BL vP6BgagFAPvL22gf4/ldbt8oCFzcRtN9VJ1vSyrsHVNr+7zrXt9p8xOlv3MpmqZLpX8p1qmzLu0F BQGLKRVCFhCwABr2+3yIYfv+tW2UCNtxOVH6/caYGQDQC/4KwN7Z87QRBGF4rCDLXSylTEVJDS1S yvT0EVIK5ycgxF+gp0ShRvyBNCg0FHRI9KRLQ5ECAeLMjXcnNzfs3gfYvlvrfaTR7tp3u2Ow7/b2 Y16IWgAAAACrSWgR+fe6k46OTmk8/jwTmtCiEjoVgQstRiEmohU6fXoq57XQhRa2KIQsdMDvou33 kFLA+6kPPNpnUvCRSeX/noKfKfjIpOLnW4C4xTzbWub3ZKo+WztBCy00IeITWoiiEKrQqYhYPHjx iseS6MVrQYtCMKO8n6PMaJTR3d0NHRzs0WQyoeFw6D6dErQQ8QorZsGmxSxWSdBCYPEKScVEyILz a2tu6OXf/X2zCkMCFV4og7gtFrhQ39/ZKLSUvS//z2359041SHxK9ffdvz60kXr9i25jHnWn/jdO qX6ZDRy4it2zlM8PvFBF5sUrrH3wghSZz/PdJPOCFnznZnGLZxG6UO/NVvvxPde3R76+9dGoiajF J3ITrb/otc6GlAdUiFdYsYs2QfLEtUyV7YSrnehdvY4EAAAAAED3xBa16vRHbtdL8wgAAAAAAGi+ 5vZTlfXYWZ3p8bdQuW5zxIDC43KxDRKgYLdrBwAwXKh86LdbFVAmtlkyZDaweZuANrEAN7jWgL5j 57E4f04QtQD94kzl7XW1yX0hdL3WYhQxoYo6kYs294g6HwEAABS8R9Ri9Rbhd8d51w4A0GM4SNAh OXGL49yuKo4N7Y8MHcMmfUyi4lkt1O+Uc2J9TT0GO69+Z109qVx/q/xs+x6/xkGjWMTiG7nvBQAA LAKMIYBF86VrBwAw3AZei835hd4PzdfZ82JzerE2bH88dg4A88LuSdOc5LZPENMDYIucAOlfX65a OxZblzZVqV2jJtf4urVp+jdaVcbeUrAIbDAeHtf/ndt2N+4AAHrEhrcd9dolOXGLPz5lwYs2ayGr 1keGYirY42xdROWx96pnuLrjhNBY/rLvv2+ZL7HnfCQnVsHG/X4RscAzAGjCJrm9G1V90ab9ZisC F9vHEaoL/WIAQBK8CMDe2es2EQRxfOxIKZImRXpT0SHR0fAIERWNOx6DFwBRUVp0PAUSTxEaCspQ oIgyFEjIyYUd7Q4Zz+3u7Vn23a35/6SR7fvYG1vnr5vd/UFqAQAAANRPrlOmcEHelJ1lsXhMTbPZ nEgm/KTVFIQWXmLhpRTUElnYWK+bDYmFllnoth7EFrQTmYWllgnva8izhhyFWnKtIc8acmRqyXMb ILfY5bH2eZ606wL8XeeP1yixQxOEEimhRbMhsvCxVqIKEVr8MctEbrF2bWjxxW0QW+j2ZIxwnJOT W7q+/kKr1YqWy6V/NkpQoYUWIrOQW1536EILhs8hllfMgnhCzimRXYjU4qZAasH7Jl8le66GY90H CcYstk0PMNH//o9R00T8h9j+EMeYevt4jcdvn5kHWQXf3gWhxX2QU1iLhKw/km1FYhEEFv9kFqE9 llkchefQBBnhPKw/Pz6mJ6enJWIL7nDFk1v9prbQQgssZmqZLqbK+ljMzb7yI8QOAs0NCk11xEAB FgAAAACgjNKOrvr31XcX71y83nt2AAAAAADAwhNiW6nFNgOIm8Rju11ugARR+fW6/51XYycAgIIL 1bnJIYXYoMrUsr6Rm9g8N/CyZNIcAKbI1dgJAKC4dPGtY5uSz/suCYX9nLdii5joolRukfreSN0H AAAApsIN+UlTAABxeBKh9y5+uvjo4lPhfvYaqO6HKPe7rmvY5XYffazYJDG61k6ZZX0Y8zdtad5d 25WMcX3k4gVBZAEAeKDk+i/+94Mp83TsBABQlF4L7lrfVTeMbUORx7laYN/cAMiR6hsde8y8dfFh gLwAmDovXazCfT15rrxnrLgi1RetoU2Rhe2DZve/o3afNCF2HQaAXZC7dqfPuzcuPg+SEQCgNp6F 0PwgL7lgwQXXBb+G+EXp/0Zdt7lluT7bsf23qWPE6iRjkTv2grykgsUVXI/lesOZi+cD5AUOm3Py tawratcJ7W/mPmM6SoIi7dn3c66WCQAAg/NXAPbOX8dpIAjjY1LcifIaigNegZaG3BvwAjwBBT3i PaivQBRINJEQBR2iufbegIICIaorTkghZ3bi3Xg8mT2vjRN7c99PGnnXsXdHUeJdz/75IGoBAAAA HB765YR52XbT+fknOjk5XYtUSFEJeQwCF1rcgvNS0CKkl8tmWgpdSGGLWsii9PWVjbqHJpcN73Pw MwcfA6Xf1HXq5PCd5uAjk4uffYC4xZB1Df07acb5ZbtWiVRUYw1FUQpBi5UQtaiEJqpzMTGL5UbM ojo2xSzCufpaS8zi76Z+C/46jo//uDb7Jy0WC5rP55vvKyZoEcQs7pKgRUCLWkhhi9lstk5fXV93 K9SXUbA4hrOtqLIQtFibF9Ho88fJfZP4HMrPwUeUP+06pi5okXv5u6wjjALe88/t9XsJiVl4LHLh xSu0zbwAxo1PczD/xgtacCvO4harIHThr+PyV9ScBRhm+z08OkoRteCBVm74vxBt6WyEfEG1eIUW u9Cb4bUNrEpRDFJHa1LxYXcqAAAAAADGIbbhBlHdB3vr7IWzR3v0CwAAAAAAEN13dubsK9mLdlMX Q8g4XGxBsXWfrrMtXocYXrVxzZOxnQBAwIIWscHqlE1krI0f2yxlg/K2smN+AJADl2M7AIDgvUin bh6mr9HPbS1eoduAFNGKtrbiNv/QHoApws/+s7GdAKADfd7fD29C/u7hZ8N8bCcAyIAHzl47e+Xs s7MPzn4Y17XFQGX8U85ljPU/i0ieqNkvbYuTtmGNx1t0KXMo+jzbb7tHfxbyHC997g1CFgCAXYKY Adg3vFkihOzAlPgt0inxVT3+ZsWDrXutGG5qfDfFJwCGwprbwul3zt5QtQkuAHcZjl1+dPbL52Vc xRKfsMQtStoWuojdo9eV6vlpRNvxESsuA8D/oudeyvM8T/Obs2d79QgAkCun3p4an11QLXRx5Y8h H3u3ir1r6bT1rhZbF9j1XJdxgz7tckr5QaSCCc/jIFrxmNCPB7uH+8nffVqvnRjayDhXqvNE9n8V fWMAwOj8E4C9M9ZxGgjC8IST7opI9OikK+gPRaIEiQ5KGuh5nTwAPACC5npqkECipOAFENRIJ6VC JD522R17PJr1Ojn7nM39nzTyZu3bXVk5J1l754PUAgAAACib1I90Wf/cxdNcQ6en92mzaTfHkomQ uJpaIosgpWhkFlJqEQQWVSxXLYmFlFnIthqxBY0ms9CUkvC+hHGWMEZPKeP0lDDWEsboKWWcuwC5 xZB9DfE+ad8L0EKL0Ee4J++FD7xuNwgtNlFkwSFlFuv/goqm/CeKLP7GMssuGqFFKLPMgv9u7fpZ 1+2n8G6E4+MVnZ3dpeXyghaLRX2OWGbRV2ghz+2hcifKJPxWh38/sdTi92rVr8EoxUieNfkeZaFF /XLWyC56dTX+P1fpie5vu0jgJvpA++O3X8IYD7l9q4/6iTwvp4hCi6sop9AWCd5/xMeyxCLKLWqZ BTUZQY5iPxWL/aJI497JCZ3P533EFo9cfBLNSaGFFFjMRF0lXvN+K/TDi5U4LVcdW30KKVF/2F88 AAAAAACGQSfZ6EqOwXWXFBKJvDeOAQAAAAAA4+IXRvjFknKiUS5a6LMQWO6rehxL6rWeq7MWFGNu LvBq6gEAoPgsytssVLQSz/QJnei8j+DCSopDHfUA7DuQWoB94Qu1k5hZdF3nc9dwfatah/480Pu6 5Bi5z4pUGYCpuJx6AABMiJ6v0HW3mR8EqQUA2zB38TLGNxcfXHykkORJz11a+H2VsZVzm/yaxDHW /MdM1aXmP/WcKSWO68Nui3yGYZs+rWN1nU8s9YSCxMJfB5FgCgCwDfidD0piMfUAAFDk5oMleo41 df217hnqrf5bq+2uYwAYAut56NSz0r782sXyxkYHwP7ywsWbWM4l182FFF3I0M+pWcIMSer5NADG wJqTe0eQWgAArg+LLp4l9n+N218ufsYyiy8830VZ/w7TZWuf9fmauhdw3fsaOaSkwo/hnBpJ6ANR frzjOAAYmocu3lJ+7QRvc9+RK6OcW7vRtVYD35MBAHvDPwHYO3+duIEgjA8SSFShQVFKcl1EmpNo 0iSpeQqaPEVS3YtQ0CJRJEqBFCmKkmeAMm1CR4PQKZfsxLv23NysvZx8ttd8P2lY24vHg3VnL7N/ PohaAAAAAOPCGhD+rumk09NPtLf37L9IhRSVkGUQuNDiFry/KmyxKIUtWNSi2K5MCltUQhbLi393 uf51Lgve5xBnDjEyucTJ5BBrDjEyucS5DhC3aPNa635OlvP71Tvtr9+v5kAUIhaFmAULTPglq70I hSznXrBibghX3CsBC1k3L8Us2FexH3wW/mN/3s4O/7yho6NDms1mNJlMyvuiBS20mMVjFLRggnCF FrOQoha8HRW1YCEKMu6VXgBdiFWsiF4EcQtpCXFvktz9t3GN3O9B7v67uMbQ/eMeD8t/2dPPz3Av MlGOwnPHFl68QhuLWZRiFW6bE/oLL2jBrYhtXyfPZ79/aHkUYOjlfL67myJqse/srbNLWtXZCPtb VIlXaLGLWGdqrINVdsCSKq2Bw+NvYAAAAAAAdE9scKpsg3109tnZcYdxAQAAAAAAohfOnjr7pY6n Tmhoy4iW24x1kzQecw7vpO8AABDwwjXXkTprgqO1II1VH7OHCFjErmMtbINFbkCOfCMsYAz65c7Z hdhvmsyusZ79liBFioBFTOgi5T2REisAAIB2aRpQFcsTpPqOPcvHmE/42XcAAGTM1NsHKsQtvjr7 Iuqt/GXo244JW8i+b72tj5FxTI5jlGVTftTKqQ6Nuud5at1rb28Ii/4BALpnqM9XMH6mfQcAgOLq gb8fyw3HcrSxPkMyzrH8W/2DAGwaay4ab585e+/sSR9BATAg+H/5c2e/qfq+hO+MFqLQ29aYkXXG osVyKVbuZYx5ZNAdes6MlfNjwjsCQq0AgE3ySpV13FIheCH54Uv9Xvze4KtujFAdUohCo8UoWPj6 ZYJPAIYKr7VyQEV/v26L6n7JtudvSHRb2Wq3EKGNDADokX8CsHf2ulEDURQ+CdKmibaiSEdLtz1P gISEKJAo8xArgUTPGyAkWt6CCmq6vEEU0VBGipAisIMvnouv7874J7vr3WHPJ115Zjwzvk6s8azn 51DUghBCCMmX1KRAm/4cabXOf5ydPUJRtKtTkYl6A2u0hCxqUYqYmEUTFyELMckn4hZiVszC1tUI W2BSMQtPLhve5+BnDj4Kufgp/N34ds/9zMFHIaf/+1gobrHJa415TtpzWaygRS1gIZQhfAcvaGGF LAARpfgd4l7Qoi1moUIWTfiXK6NiFlbQogj3h3B/jecnJ8Dt7RXOz19huVxiPp+3xClUzELNi1po HhXAOATk+bDmBS30OJvN8OP6ekiFjWCFhv0zmBKw8Mcev7cJ68/DR9a/39fYd0GL3Ouf4hp99esI oghaFEGQQtr8lqAFgvRVOP9A84Z8KmhxHNI0fxnKCqX20YOQxsPqnbQ4PcXFzU3fLcgEAtls5ydW BS2sgMWRSStNXM/HzE9i1A6THcCNHf2fEIn0w+iIEEIIIYSsh5+An+pf2TQ5vkHdV+QiLkIIIYSQ aXla2ScT94shYmYXEJcufewi4jHf6A6ZF0gv2iJkF4xZoJjamGaIpTY0T+VNbXLT1Z6wrSE5YMe1 LkFRC7JbPqMWNxJSbahv+/va+jHvgqH1aLkuH2K+xsKEEELuz7oTqWIbLBDgYtcOEPKf8CyY8LWy L5V9q+w72t8vy0hYj0P6tHDxI6z2R/28RkTCiMTRk27PxVi333ufNrqrjGxItUAjZEERC0JIH4+x mY3Wh5wjZEoWu3aAEMdVJM23mV1jcl15u77bpr41D7kGIZuk7/eZDcuC7/eVvZ3MO0L2l5eVfcDq fLTY3LTjRLqfqxYzv6a0cOUV+67gWlGyLex7wccl/K6yj1M7RQghCWQN3xOX5uPK6y37QsihIONf lyHsf1du2pBIv3N5YuOO7CsTQnbKHwHYO3/dtmEgjF+AwIaQzR2DBn2BZGkeoI/SqV6yZ/AD5BWy Z+4LZM0SIA9QoFODrgEytQHyRw0vFO3ziUdZRSxK9vcDDjyKEXkwHImWyPsgagEAAABsDjsR/1vT Sefn32ky2X8Tn5CiErIMAhda3ILrdWGLshKzCH45F7vwfvk2VuhL9h9+H+XOgz2UhPdDiHMIMTKI 8/0YQoyBIcXaFohbvOdYTd+T5fVWbQQtvMBEEJvw4hNejOLZHX+uxCqelGhFELKQ4haLsi5o8SLK kjThsyyKku7vf9BsdkrT6ZTG4/FcnCKIVQRRCy1mwSbFLLZF0CIQxCukkIWssxVFQb/v7ujh8ZGK 0cjqKP3lloIX4m+kqEZN6CIS67rJnSQ+d/99jy/3GEOPfwj94zPO3781xtIuRr6eVyIT81V47lhZ iVdoYzGLuViF83e5zvdmrrtzdkO7OJ/7faHllYBhtd9Hd59fQdTiA/mXrZdU19kI9R1aiFdosYs2 SfGIlhPpkSpjG0C3a8IBAAAAANANemG+Ps7lrbOzygAAAAAAQHfwszotapHaxGBtGi6NemrjsR6D qF0ytm3ia+4AAFBcCb/p/zOVxLHpeBtL9W3FotsA6Buxd1lIYAxy8kBe1MJCJxiz2q1rdynKtqbP X+WekIoVAADAetm8Rfbd8it3AABsIF8qY346uyEvcHFNPiFpLPGifA4am9cSxeek2rdK/XuQjDaJ lajRosvrcWysI1qIWHB52GE8AAAAQJ/5lDsAAAT8XPiv0Zaac8aezVrv7sgoU+/1mt4HAtAFsb1o 7LOoxQn5JMEAbDPHzvac/aH6WjEtRKF9/aylbeLef4YfsNpxDwH/S2zPjL5PsH/hbObsoLvQAAAA ANAjPpPfu5Gah666l0PmUZG+NUeWferxMCcGAPSKVwHYO3/dqIEgDk9y6IpLQxHRpksFT4CilEgU Qbo2b0LPKyBR3BNQ8AgRHRSpUKSgNCCaFLQp+HMbdrI79niya5/RnX2r/D5p5PX6vJ44kb3xrfeD 1AIAAAAok9xgRF1/4uNFV0MHB4e0XDabE8lEmMSaGiILllWwlOK+zKJeZ6lFEFtQVScRRBiuaqcW W9DoMgtLKRPel5BnCTkyyHN9lJCjUFKufYHcYp3Hsn8n98dQ1TIHZ8rLuN1V67XUwlUCCuf+RgGF yCmCzCKUfzWkFrXcQgQWvyshRi20kBCpRprZzNH19TktFguaz+fVz6uFFiKvEJmFLEV28VCFFoJI LCaTSUNmIZKL6XRKn66u6I8/b0mpBX+Wz18s3y183MrfmxVWxLiTXHB5dzd8LC6rfdTvo/RJ4kuY qL/0c1B6+0McY9vbL/0cl57//7RffQvp91tGIQVf1xtCCwrfSsr2R/5az/delluw0MLxvvxZ3s51 VM8GMonHYdnFTrwv8PGe+HvRs709+nJz05Xicx9nqjkttNACix1Vp79Qle2psIMYpbNiXya1S3sK KVP/MDslAAAAAAD9yE2w0TWR3Vsfpz6ebjQ7AAAAAACgmfk49vGR2l/m7fNShF63flwb9pi2H4ln dESPfbwaOwkAFJc+fma22ck6cpPI5CZ2lMkIUpOR5yYo7xOpXAAoDUgtwJh8oHrystw1NHUvyIVL lO19wF7/u4QWq94/UrmmygAAADbHKu8ugTToEwKwWQ5jnMb1rxQEF599XPj4QeFaZYUW0vfUdW3P QmiFZaou9V28JvfSzpD93FReIq7gCftYZnE0YD4AAABAaRyPnQAAiu+q3DYGtItcn9huS7WZe67b lVfbPgD0JTUeOjdWmuWILLZ4PVh2AGwnPC7tpY/31BwbZst6vFlbvTPltn3seDYijEMDw9H1fO6N j3fDpQMAAACALWKfgtD2G6XlEravrOvXEbemzdT/txr0mQEAo/BPAPbOmMdpGIrj78RV6oZ0IwOC iQnxDTqw8SGQbgSJ73QLX6ASQrrxJAZmhGAFdMvNDAzHJfhd7MR9tZNUNGmb/n7Sk53GsV+ryE4d +/0RtQAAAJgGJ4n8266LLi4+yNnZoxVxCSVOg8CFFbeoxCmssEXhxSxCvlgTvAjCFnFdZdn8H9rH WNiHEvD+EPw8BB8V/Nweh+BjoAzBficI4hbbbKtaIxWLW1Tth9+qqMtU5+7qtBG1CEITd0Z8Ihaz uPUiFWkxi1j0IiVmoQIZIn99G+nBVfUP5vM/bmy+keVyKYvFov6OOUGLIGaBoEVDELGI01jYQpnN ZvfprT50KUFwItxHbb+dubFrIYtMudBuaa4ZEuon0P/U6x+6jX2/B6dQ/xht9Kl/Jdqb9tVeZCJ8 pqIUhRevsKZiFvfjbRC0cJ898IIWKm5xqteKrFxvVwDW7Th7Op/3EbXQl60vnV3Kus5GOD6RRrzC il3EwfG6TGR9AWKc2oXDvFgFAAAAGIbUc1fIh1TtjbNP47oGAAAAcPToy7wrWV8jlNtAnLNNNg2L ObZzc6lNGsc6b3e+awcADPF/tk2DxuSCNqYsF9C8TdzC1mf9OdZ+BKbF1a4dgKNFBY0uW853BSDr 6vdT/b0VuugjXFGY9qxvKV8ZHwAA+qOByH8OUO80F9pvl/j9mvJFqqDwADA8z7y99se/nX139tnZ N2fXzr5KM4fZZZI5TqVt+dy5XLC8Mfrah1L1TS98XueeH3sDAACAfjzZtQMAhl89yqTmXNvmh21Z yaSbPDenjgHGILUXTfPvBVELAOWVs4/OdMNpW1De1DqzePtqYcqktraWpoxdh9Y2Z5Jbswbwv6Tm 5nSMeOfs+fjuAAAAwB6g789++Hwq/sk2LVdnacrYZ2CeiwFgp/wTgL3z12kjCML4OJbsCIREEUV0 1BRIlpCoko6KLnVeIk2kPEI63gGJBhpKSiQKnoCeiColUCD+2M6sd8c3u+yez2D7buPvJ3269d7e 3vgK33rvdj6YWgAAAAD5kXo5Uf/x+Mbam9TRxsYm9fsfvDoxsbCJrMkzn7CmFDEzi+KzMbWwxhbk GVmImYXuqzDLGGaRTD6X5Pw5xJlDjAbEOTtyiNGQS5xvRefQn/JIt53u4P/T3GLozqWfn8v10YYW A2ViIeW+M5kQaTOLl7FZhS0/KvOKR8/EQup8M4vnkZFF0aftP0W7TdTp3PNY4CMdHBxTr9cbfy8x s6hqaFFcj+UkNLTQxhZtvtBm2+12R20fnp78Y8mfGW65BOeqwt/G6hNqSXnOND3R/7zP0YQk+U0+ R+7x59A/rnH9/b/3HOM394xBhTOkMOZFnqGFmF0YiaEFl0fmFua+7cwt9H7JFDLOTif/uZ2RxqdO h7ZXV6sYW3xhnbvuQkMLbWDRUnU6GZ7sjyl8QXGgLsswsSUKbp+ROt0HAAAAAAAoJxxnheXYYkIj k4DnN+vXAmIEAAAAAACWLdZn1t+gftaLIqoumhBSi4WXbY7uR90BAKB4YF1UaJdKUkNBfZlBRVmb ssTm08QRtgMgF5DAGNTBqSqnfjdjCXVTCchSv/UDem1iEdalTC4mfZ50PyirBwAAYFmp2E4nQpg3 yzZPIM/argljQgDqYo2166QxRhd3rEvWLeuKdeMk7zDGxqWxsXNqG86fxuZTY7x1X8gmWYOKdSp+ g76SNbBAEj4AAABgNvTqDgCAgCqmFkLqWV2sPGk+OdV3qs0yzQ2A+oitQYst/jP7/rCOWN8XEBcA TcbMKe+zTuh18tyUQsMKXSdrUAcV+mkFbYmwVhTMl7L5u3Ds85N1tqC4AAAAANAsdliH5I9FY+sl ZFt1vFs2To71mVqfgTEyAKB2/gnA3rnrNhFEAfTykJUqRAgqS4QWiY6CIogaJMQ/8Csu4BfyE7Q0 aREdEgUfQA0lZYRhr2cme/d6ZrN27H3gc6TRzuzszo4dx9nszNyD1AIAAGD65AbQ3l130vn5Rzk5 mUeBhVwFArfbJLjwcgstr4stllFmkfLLNeFFElvU12yOR2vbqxc08mDyUwl6P4V+TqGPCv3cHVPo ozKVfm7DzcQPfnyu+zX7fCv3J7dojkGG64Q1tSFGdL3Gtim0+BPzSWRht5dRTpHEFEFcofu8zMLW peNrCcalabNdaKF+heXyp5ydPZPFYiHz+Ty+b+tCCy+zQGiRJ0ksUkpiC0Xzs9lslU9SC/vRvHpC HAONF7HSitjuX72GF1rEY1f1u32Zrjv7/aUeexD6XZxP++Nuv49r8Bk8zJ+hndEnUWZk991OAguJ RohYXtkkNC9BUHEnyS2i0ELlFndNfTrfzgC0MwS1fHp01EVqcb9KL6t0IU2RhZVb3JJaXuFlF10n HqY3009AtFs/wMpAKwAAAMB+8JPy/YT9tO9Dld5U6WmvvQMAAAA4bF5JWByR2GQRsX9Wt8nCYZty i4Yls/+Q0KA1p0N3AsDwtaWuS+CYUlDxbVMXKUZbPwCmiH52fwgBjKFfNGhZm9SoFHxs0+/0ksjI 1pfEFblz2/ojLu9fBwAA7I62iVD/34T6ftC/Wd+q9HbojgBAgydx+zxT91uC5EL5LkF6oXyR+r5U 5RcpYHDuftZuJVMuPQNRSt+3KqK4Vyjrc8lHMa//gx4X2gAAGJKHEqRCm8D9KYwdpBYwNn51PK50 z+rrSmN5Xcb72toGGJLcfBfd916QWgAor6v0qUq64LQtOO91MgtbtseWzimtG7X4ep8H2Jbcehk7 H1LH3z9X6UXP/QIAAIDheVClxxLmgebkEn4dh91/kySyft/ryyLl/3EBAHrjnwDsnbFu1EAQhieR LpGI6E6iQuno6NMgap6AMjXSFUg8A4/CMyBKeAM6ykjwEhwQ4zl7feNh7V1OvrMXvk9aeb27ntlc Intznp0fUQsAAICyGAq2sf+MaAKhFylD19dPpKr65oKIRZPQWnpCFo0oRUzMYn+uohaNsIU4IYvG nrVlxTJ8/uZSkskzz+koYY4K85yOEuaolDLPQzhc+CEVLz+1v8OZ1md/H0Fje7/nVp9p/T23Y4IW QYDiZydQ0RyDYMV3c751ohZ2/I+erb2gxa/Bn+LyspLt9qvc3r6UzWYj6/W6E7MYE7TQY+gLghaI WfSxIhZW2EKPq9Vq16eiFll/jlagwrcZ4Yquq/W7E7NofVZhzBF+T0tMEn9K+0uf3xJ8lG7/2D6m sF36Z1y6/al9dFF4KlDRClLUD5GdUEUQtNC7uT7hz7U/CFoEcQsd14pb2P6QKaSLCFQBjfbZoP4e XVzI06urHGGLZ3X51JrzghZWwOLMtNkAxNAfK+fu2nvzsVQDR5E/X/r6NmsDAAAAAMbx6yxfjyXc CGvCVzKeKA8AAAAApkUFaL2oRWoTRGyTsN9AHBO8qFyb9yES/04u1v6v83ruCQA4Pph6btKYnKQ0 Q0nM70fOY0kdfV9sHgClEUu28VlIYAyn5Z2px77T8+1jY3Lv976krhl6b8z9HwDgNKRiac4G6of6 ApGPc08AAP6Kh3W5aes3pv1N4rpvshe6iJG71lVxiseZYwEASmJ9ZPusPWEOELWApfEl0ua/dx1b l6bWrEPv/nLrOT4ApsTGQ8fOQ5tyJ807FoQt4H/nQV2eSyNs4RP0puLSKhmPRUvFpfn4NBH2isLp icV9aP1tXd7PNSkAAACYFd27cdfWveBErkhFbgm2/Xq5cmNYJwPAYvgtAHtnk9s0EAXgVwVFVZdl h5Bgyx04AStukG1vwAqxqITEKXoJduwQF6CrHqKqxKpqBQ4e2y95fn2TmPzYMfk+aTTjiT0eRZHt 2M/vQ2oBAAAwbqJgm4t1G11dfZXz8xeVfMJKJWytggsvt0jLT8UWRSOz0HbREl7oulZisUyEPW/t 2zKWZPLMc3eMYY4J5rk7xjDHxFjmuQnHIrfYbn/tOCovtKiXa4lF6js5mS+EFrVgQmUTVmShIorH lsCiFlZo+8HJLh6dzCKt+7sZX6UWhZ/8grOzP3J3dyOXl59kNpvJdDptvp+l0CIJLFRiYetUrMwC oUUbK7HQth4vUj2ZTKr2r/v7fx88EFxU0gqVWBiBxaJ/jxx6ov9972PsifjHPn4f+zj08fmOhx9/ F/to2RnSsbuRTGjfpDyXaJ+1RVQ2iXL9KvOHCi1SfyO0SHKLZ+ZztUvYjMM+QvDV6WkXqcVzqR+4 fpO2yMLKLex0vexiVRBi9LDVSjHE1T4gjIesAAAAAPvBvryVe7Er1ddl+VKWD73ODgAAAOB40ZeH U0JEf69M21r7Fxz8y8FFsOxvI/oxovtzIvl7dcdy/+790BMAMNxKPolilERmXfKZKEFNrnRNVu73 EyUzJ8kN/A+k8/XHoScBR8ONxEnLLP443OVY3kVetE5wEW3TpYhri3A+AADYBv8ffZv/7D6mB/L8 HHoCANALL5sCAADbwzUmjIXXQ08AwHC74XarngPmln296vlfNIb/HKAPfHyLRe+RfRakFgCJd7JM 3p+LO7PxZnOJ49FsDJp9ZhhtY5fn8jQuTYli5QA2JTo35H5z38vyoyxve5gXAAAAHBZvgj577arL tn/V9XMRtKN8K37MXKwH18YAMCh/BWDvjHEahqEwbNoJMbAgGJAY2BEnAEY2zsBUjsLCwCW4BIdg 4gCwdUJITNBSEddx8+LYsQlt05Dvk57s2K792qpx4zjvH7TtAAAAACQT2owjL0SuMruMdXR4eKym 00FJSMKKWJig1qokZKEFKbQARlXMojjWohZG2EItyoyQhelP9lUIWyivmIVLV4Jn4+fy6IKPGvxc Hl3wUdMVP5uQek72vFI1WdtqPl4zmo1X3Stlvv/iWduyoIURstBCE9oK4YpvIUJhBS0KIYvZ7FOk xoygxZdIvxapFLQoRDLighbj8ZO6v79To9GoImhhhSuskIW2yWSyELVA0CKMFbBwBS3ksU41bx8f v+28NE6wjRTS8IhgLAMp1LEK1hHkftPFBOg/3v9/eA9tvj6l/1X/zjf9M07pf1Vj2Av7YT5nzFUh 9BySjznMbV6W10lRC5tW6u285NTZ93GQ/Sc42dlJcfEss21ViFXYm6VSwGLglMsbrEOn/cBpv+Xk VSR1vwhfmQqUAQAAAECVUGC4ugB31m4ze16DjwAAAABgOM9Tn2iFzLtrbr5y39pciilVXnvzrdf1 hevMdtt2AkDwGKn/y/VfLMh5XVuZd8fx+eM7BugaBDCGdfIg8inn07o2ofO3bx6YBep9c4XPQv7V lQMAQLfp05qB5j2z17adAAAAAOgJffuvCe1y2rYDAAIpahFaD667J+e2ddv41nNT1p1jpKwTAyyT ut/HizIBywH6zl5mF3m+Ljivu+cs9Fxpyh622L40SZ/3qMF6CO1numnHHQAAAGiZo8z2VTy+Sd2z HE1MqfJ47vjEVgGAjeBHAPbOHqdhGArARmKoKnViYYKZmQtwBAaWHoGDcI5OHKAS12BnRDCxlbFF RNQkTp+NG5vGaer0+6QIx01eX39E3CR+H1ILAACAfPH9eAieBJ3NntRkcl6vm+Lcpj61EVuUUgtb bqHX/4otikpmYdqFJbww25pYMr45hxtbGzuXQtrkmY4cctSQZzpyyFGTS567gNyi3tJq2595UffZ Qgv997uWWEjpxEZ0YWQWy1pmUYorlk6/EV2shOjiq4q1ib2RZviFFrou9ni8XB+L39V8PlfT6bR+ HaXIqrBkFlpk4cosEFqEkRILV2YhpRYfi0V0vEahRbVuiquf6PjVPpbcIhFDKELfdn8K/Q8//qF/ xkN4j7uOn9trsK5ICvGE6fsVT1RtaYuoJRZSaCGEF7rvVPYpYZAwxwnx3Lr/cjSKSflMlcXyfCIL ebOh2yfT/89F1qZ9fG8jAAAAAKTFnSwYWu57yBEAAADgWLlS5eQIQ8oJEG0nTyin7VsfGrd9JwDg 8CzaoQv8Mb/3YreLjeHGc3NNUQAH4FDQN4l89p0EHAW6yNJbYJuY/+khAUXRsPgej4277dihGtoA ANAtbYofDP08wC4gOwMAAIBj56LhsZixZ5sxJuNT6IKbvhMAcHjZYZ9t1/FUoB1zDdG3rS8eQNfE fpdN38M+kgLIgDsVfz9ak8DCnXcas1/TfWmM7SE1oXGKPF68rpfHPeQEAAAAh8e1aPvGqKnnY/jG y/L5fTBWBoBe+BGAvfPLSRiGA3AFAsTwaCJPhCN4ADPfjG/exjt4Gs+gB/DBc+iLvBAV4krX0W1t t+Hc1uz7kmaVYvvjT2B07e9DagEAABAGvh8Suu0+LrdlHS2XK7HfZ7szZRNSXmGKLKSQYrezySyO f0uphRJbiPQ2JbJQMguzr+NYpycxDyWpNnE2RwgxSoizOUKIURJKnKcwbLlFdh2KKWKyCy12Iiu0 +EmPSkDxVZBWKEGFrG+T9q3RlpddfKf9KCmGLkpq4Xq+x2MhZrONWK3mB6FFFEUFoYWWWmihhTxq oYUuptQC7JjyClNqodsmk8mh/rHZ2DuoKKEwZRWFBO4NiyysYzRMCEno+x5flf6H/hqG3j/PcT/6 b+sxpCvy9HdIUtcyClNeodsycovkqNvPhCj+TzLeyBj3cjoVV4tFlVCv4zIXR1lFfoGhKbDILzi0 STBGufvnFyWKkqNtw9JfNtUDAAAADJ06kz/5jYdvcXlsPCIAAAAAcHEn3JsY6m4krrtJ2DcPN7S5 uLVQ67UA+sJrXN4dbbYkHbb7+JLQ2BKVn5qs3JUkxxcfQGjI9zEJjKENnox63QRhVQQXts9+2/dC XZlFPj4EFhAivFdhiAztt38TPHcdAAAAAEDHnP9j35yfQhesuw4AIEeZ9NjEN4fsup5Y5fpelTGY S4M+4EtY/iKUSBxg6FzE5UbUX5PmE1mUSS5c6+CEo14lsS9AHapcZ3+Iy2cLsQAAAEC/iCy3uc5J 6+zlcJ0X+/r0jQ0A0Dq/ArB3BkkNwlAAjcW2+y7c6DguO16hl3DhFTyK4wnctpdw5c4LuPIQznRj l1ZlBOGXkCY0VWgE3pvJEFJIfltGKJL/kFoAAAC0E9uPiJtdOy0WD2oyOd2sF4mtJTG7LrdQJblF ur4ttohzmYXU45LwQraVvvRx5P7tX/JjtyXBNnHWRxtiTCHO+mhDjCltifM39E9u4RJaFPNsM4FF nH/nmdCiEFmI1OLTEFB8JOfEdS6wWGsyi/e86PWiLRNa2GQWX7nQws5wmEotlmo2u1Tz+VxNp9PN MWrKLMxiyiyyz6mbx3cdSLJzEVlIPYqinyL10WikXlcrnw5LdV1kUWIwKLaX16Veg+CCJPTNxoio wK//LryHkPv79M9xHrj/fAxZSpssB/KaKtsiNhILXWihySvStmOtTdqPZGmOk5Sz8dgn5InKHki0 iSyq2vTw90mIV7WP/jEqow0AAAAA6sEnmam+fpeUl8OHCQAAANBLzMkR+9x7s00Qdk0YtrXZxjNx tXeNq9ABABg8a3WXtMLW5kow7iOm8E1ebvZnxoPIArqALZnTU6BYoD88KrfQSPD9u55SJS6KlZ/g yBRd+JwnXOcGWx0AAP4Xu37/9+H+wC4QnQEAAADUD9eZEJKL0AEAGCw9t6uSS1TdR7bt63OP19Y/ wKGp+r+DeVym67eNRwTQDq7V9rxNn8S8rmfUqp5L8513qscC0CSu6523pNyHCgoAAACCcZ6UE2Wf H+GSTewzt8N1nayUfTzb2K5tAAAa5VsA9s4mp20gCsBDFiiKWFaqFBZInACJ7rrprjsOwBFYcZNs uAdXQHARBCt2qJtWJG7qwZ54/PLG41Ab/+T7pCePfzAvxsROZvw+pBYAAAD9J/QBwf9AcZHGz9iO jo9PzWpVvvz7xbytvMK2kyRrWyGFbW/LLIp5K7XIxBZms8yFlVk4KYadL8QWzRYsH0oxefJsjiHk aCHP5hhCjpah5PkR9kNuUR6PIoUW2d/37yYKoUWSr3dCi2RLaJGJKQphRZL8eZ+u1yGZRSHAsO0s nNBiVSm0mE6NeXt7NJeXF2axWJj5fJ6/xnVJaOGkFsvlsiS0cNu483ms53STSJmFm98UKE+ns9nM vLy+xnakt71lB1aeIYUWUmxh1/9HIfbBF4lvQCTQdqH/tkFUEN9/n4/RWI5x2/sf62vY9DTm6yZ5 20kpfEmFW1eSW+TTyUFZcrE1AjD/eZfD18NDc3Z0VCf172lMTSGr0AYYTsRyvwNVS0cbgKh1toYG QmqHUELnKwAAAEA9YkVPtQe4/LhK41c7qQEAAACAx8xkAlr5YIKk7kMP2sPCVUIL+TtjDw+P9fu5 664TAPD4ncZDje20ovta8Y5Y4fHQNlqh81BBEJmHzEWbBxgaFDCGNrHv/bfefNV76C5FyqSQQsos 6oS2n6prAwILGDp3XScAIDjpOoGcsX4fEENey+66SAIAAACgR9j708+6Nwz1ne3rvSm0w4+uEwAQ PCnL6vTBhYQV2nYhgUVMGEDfH/SR0Llq497o/1MA+8aXNL6Z3YvvxiQWVevrjlMzYhu5DmAXqoRH Wvsmjee2kwIAAIDece61tXvWJqNqn8aE7325JwaAT+efAOydPU7DMBiGDUJqi9SJhYGBI3CCHoCj IMaKoQdA4hS9BAsrOwsTIxdAQq2EEIiUmNqN4zqu05+4Ds8jWbHz8+VLlCauf74XUQsAAID0cP1x uFp10Hh8L/r900VZB6jWQbwLsYlZSYjCTGVhi0yJWeh8tiR4oYUtTNtFgPDtBytPJeh2KgHCU/Az BR8l+Lk9UvBRkoqf69BecYvl72JZ0EKo5XyO7Vy4QgtZaDELnQrxiSz7NsQrvkrCFVn2aYhbVItZ SBtl+z+VV9HrZWIyeRHD4bUYjUb5t7+vrmu2ELVwiVloQQstatHmZ3hXSDELKWphC1vIslx2u13x Np2GGdNiGEZeC1poAYsDQ8zir+XZXGfZCWXfA/2HniPm8ftgH0GOtO2nfo9T+J2H2G/yGkq9iub7 Xy0P9XteFGoQOq8FLkp5JWRxpJIpfKGFMUybi/Pk6azTCXH/RMwnYZgDCF1CFfY60/06Ha6+Y1y3 EQAAAAA2Z9VAfF9A0+c83TXgIwAAAAAIMVDL0EkRVW1tLnHaupMmhCPvKreJC7E/QUIBJE+ebSHB YnyBaEKSHbA8RBSjalACgxWgTbzGdgBazUOePlQ+5J1a510eIkhh7muLGtX9Lrh8deUBACCM4wbO UWfsTpvbB3yY37nHmI4AAAAARKa35nF16pEh+4b0Y/3XuivU4zy2AwAGmwbft9tnfW239j7CUXb1 AVaVafuFpvD1P7iez9udewSQBpdG3jU2bdV4sxARi3Xmm1Jnhyaoqhu95+kmllMAAAAQjYFjnS/m Seicjqr6sG3ft00I6sgAEIlfAdg7e5yGYSgAPxCtEGJggk7siI2diRtwkIqjsPQEHIGJHUYGzsDU hRUJaERM8ojj2rGhDU3C90lP+XPd11KVqLbfh9QCAACg2zRN6tZrl3lcxDqaTI4ly+rd2YXCjcTC 7C8WxTkjo7DlFkZcUUQlrTBSi0JsITWRhcos7MdXYot2i5P3qQh3X3LtQ559yNFAnuujDzka+pLn bxiO3GJ5/pT+3QqBhSu0yEqphAotKtHEssyiklKozKI4Xt7a4otCZvH+FVlW9acijRB7ex8ynz/K bHYt0+lUxuNx+d7VZRYqtLBDpRamnUb1PhCx0ALodpFylVkYzHY0Gsnzy4u8vr1JebK+bSJUYN0V WFjtflqQnSL07eY4lEL/bfff59fQ9c+g9o/0ZPP9pzzH9whk2VbFFCqlsOUVtrRC5RY71jVt57NO bJVtNKej/N7hbH8/5aWc57ErlazCN8lw2zlvD6z60rHbu4OwEtn6FhixyAgAAABgvfgWdIUm6s/y ePi71AAAAAD+LSd5HFrHqQsh2g43n9Bx37nadAIADnfWfkha4TsXE1n4ipDHCpenFL/x5QEwRJ42 nQAMllepf/e7NEkhmr73Y9IKXzT938gCz5eaKwAArE5oHk3qY5uOQ9dizze03whS4L4QAAAAIMy6 7ldX7Q8ghQNBfA/dwpZapIzDNY0jplzzCQF+I6ngd2HoEu64yI2sLowBGAJmbtqp/HzuWEhiEVtz 2lTMVwL7FPKFdRATHrntbvO4bzUjAAAA6BrHUqzbCNUw8dU+WWU9hq/OiniOqasCABvlUwD2zh6n YRgMw6ZC6toDcABGJHZmRioxsnAKbsA1OnGASlwA7sENutCholSlxE2cfDW280OT1NHzSJ/sGMd5 01aNSePvxdQCAAAgLlz/KDyW7TSbvarJ5CLfNgnW0wTh0nBid2BEoc0qUkOLXV5qY4vN5iczsyi2 jdmFNLfQxhZy7PSwxbHbJKZE8jHpPHWtMWjUoPN4xKBRE4vOJsRtbuE2s0hJ19Ompk/S0EKXW2Fi sc22UwOKQzMLY1yxzutFfFlt36LcZGEMM4xphtvQYjTShhZrtVp9qPl8rqbTaX4e0qTCmFoYEwsT LhMLqIdJUq6NLIyZhb2tTS2Wq5X6TKJsrD9jpxV/fyvOZFlRf1vEYFQQe6L/LvSf+ntYZfxTfo+H 8hq3Pf4QzsH7N1Hm5kSibZRdC3QYNwhTNwYX+3pyzTl3GVyowvjCGGPIMfPjJHExHlc5Hb0Q40Yd GlK4jCrsNim/TgK80D6ulxEAAAAA/o9vwaAvMams63hIYtmmQAAAAADYc6v8i3mrLHQoa6t6D0/i ax8ad30LABAslD+phi+xjC/xjN3PtV+Z6YUvQjpsLa5tgBjRn+P3vkXAIHlJwjyEVJZUw9TrfreH DCxCBhe+a4Ov3aXVVQcAgG4IJUSA5rz1LQAAAACgZy4r9Dnm3DM0VtlvWcyBIcRV3wIALBY1+vru D9t9fPdvXc+N2mPbY/j6AHRNKGG567P53K4cgGi4F3VX8lz7eTPbqEJGlX2qPqvGnB26IPSb+lOP ugAAAKAfrrOyydqNJuszmsyHmScDQKf8CsDeGeO2DUMB9Cc2kgAZOnUKkKFbEXTIXLg36B2690A5 QG7RregJOnXvBTpkKOIWTvUtfYn+IUU5cCJRfQ8gJFEi/W0YsmSR/yG1AAAAmC59Nw2276PUE9R7 ubh4I5vNbndhUvA6YbdsJRa6VBnFrtzi4ZG0QkUW6/Vm2yYUWZjMImzfiS2eX2bhKSU5dylxKiXE WkKMCnEejhJiVEqJ8ymUJ7fwQouwbiMmuTCRhUolVPzQCS3+tkuTUKjIopNZ2HonsqjlFvftMX67 rvvjSi21SH1Gy6XI6emdXF6ebYUWq9Wq+XweWlGFySzComILrdfipRbwNExeocvFYtEKLUKphfJ7 vX7Utr1K8wnPbTtYHtm2L2EbX5dg6on+X+I15pwkv5T+5/Aexmw/pH+kJ/n+p/ge2hF5TVsTU5iU wmQWx420Yiu0ENkRWti+ZbMes04cNcdYjK9PTuTd+fmQEN9X5Uw6WUVsoOGxqw8HGsbCCY/3gxIl s4xNqE8l1AMAAACA/Rma8M7Kr6p8fvkwAQAAAP47PrjtfSY7pCYNDxVexF7Pk6ovnU9VeTV2EAAB XzL7c8nOh0opYgnNcwnRU/eTqdgYtABzIfwufx8tCpgrmqTsW8/+2Hl26Lk+d4738gp/XN/vhI8t Fiu/AwAA02GO9/Nj8nXsAAAAAABmQCxp16GeRc31mRYcnuuxAwBw/DhAHykJhcjuf7ux53y5Z32p /4YBpkLqOcptVX6OFRTAhHhblSvJjyPrq0+NS0uNU8sl7fXrqX0A+zB0/JLV6ziQm+cLBwAAACaI n7ehpK5Hh8zjyF1H+/779olwLQwAI/BPAPbOGKdhGAqgLjAgpG4IMcHAAbqwwxEYuBKHYGkXxAk4 ASdhhwGxFLWqSkzzW/fz45jQkLp6T/rCcRLnKxSRNPF/SC0AAADywbphqC0INBo9uX7/dLksxaoX xcBD4cRciSzcUmYR/pxOF0ILEVxMJrO15VBsEY4dFgvvol52LoW6c8nTk0OuOeToIc/NkUOOnlzy bEIecosqocVqLq0XWSyEFr5vVootvMBi9h0im9ASCpFbrEQW62KLhbziM2iHMgs9nggtbLwjodd7 dZeXF244HLrBYFCek/lSaiHiChFZ+PBtLbSQ/aAZUhBdZBYit9DrPB/jcfKYFStWTVmWKI/5Q3Lx m/E3xLYXoafQ/+6P3/YxNvE7zv0cb/vfeeox2h4/9RhrTw7LfcK+vVJs5ENsEL7thRUHXqjkVtIL EV6I3GK/FFfIOhFjhGMuj1PE+eFhSsrHRVy79cJ3lqhC94Xpp7x0KOnFtrVOIwAAAAD8ndgERaut 46mI+9ayAwAAAADPURFXqi8ml0iZGJHSr49TNXHCymMXuOk6AQBFWNi87sF/SiFza7tY0fK6MfR4 Ote6+0+AnLA+4y8d5AG7zWPQTikQFtsmRVpRFdY+qf8nYqKLqrwBAKBdYvfset2u3N//J+9FPHed BAAAAECHnDfcr66IrbVtrJ9rWfgrTT/LAG3xZvRZ3wmniIfDbVOeIVr7WPBdL2wL1ue2ap3nofWM APLgNmhbQgn9fpmeXxpGT7X1PrH5o7F31wA2SWyeTLj+roiPf8wLAAAAuuWsiBMXn6tR1W4Se676 2te6LrdyAgBolS8B2Dt3nYZhKIBeEC+h7khlQWxslWBkYweJlQ/hF5g68UN8AEgMSMz8AQtioIVc EreOsR2rj6Qu50hWgpO4Vwlq0ti+B6kFAADAahIbPGO2XRfloqmhw8NjGY/rzdkJwFVioesqsdCl 5rWuyy2+J8IKW3Chcguzvawb/xb3+KnYohuZhUsuieRziVPJIc4cYlRyue45xJlDjEoucc7C6sot 6n2IrtCivCZGaKFLI7QYVXUjS27hCi1UTmHLLD4raYUtt/h09pseWxZdN8KML/nbx1myu6v33je5 ubmU4XAo/X6/Og91oYUrszBCCyOzMPuv6/9hmxiZhV3sum21kBS8N0ktfEIKI62YVG/U60zyc7c+ +BHLe++cQxL6VY8vpf3/fg1T2l/2OZr3+HU4xzm338ZnLKL9SW9j1ZYRUxgpxa/MwhFWbInUhBab 1fYtI7wQz0jAah8T88HOjgx6vZQQz4uyJ1NZRWjQoW9gYcrgxFiHq2/p64ylAxYAAABgcYQSj8bK XVFeWowRAAAA4D9yJvFJvKmiitD7vBQ5rUj9vVts4kTuHBXlqusgACyeivIR2BZLyuGrb0puvogS imW2wSIAefDcdQCwVrwW5bFhHzeZRup3dJOowq6PiSxi9w1fPOKsi7MOAADLZZ7f7Ov0e3/Z6L3t oesgAAAAADpkv+sAZoDnXfAx6DoAAAudqOqTWiixd6whMUWojdg751jb9AdCLoT6L+6FZOUAyomU 46XmScjrG5/m+zs2Bs4mlsSX53hYFE3POiqzvm01IgAAAOia02rZ9OyaOq8jZX5GytwNG56HAaA1 fgRg7wx2EgaCMDwJJoQDBxMxnnwUvXvyGTx69AZPwgN4NT6Dic/g3ScwxMRoCCiFTpmuu9sCFVj8 vmTT2W07TIGwu7Q7P6IWAAAAaeCbJNxUnTQcPki3e1bUNWH1IvG3FZz4doQspBCvsNtMyGI8nhYC F5mdtS0FL2QubFEWs7AJw9dNcN48qSTwJs7mSCFGJZVYU4gzhRgzUolzHfZL3KL8jNVvQQsRXW+7 +EysoMWkEJpYlHEubjGe9XtWuELFK75y+9MRs9D9ZTEL9bcsk+B70ulMZTR6kcHgTvr9vvR6vfza l2IWWlTIwgpaqKjFIX/vto0VsMi2rVarsLVdRS3eP0L5RMr+TKVse4QrbIL8mLDFvif6r+MfQYv0 /R/CNezy/Dr+ET2p9r+v11C6s6i/66ZtLmaR20cqRCG5iIUKVqht2tS24hcqjGF9Fq8zK+ftdp2Q j2flQsqCFD7dDLdN63UT4ml4sWN9byMAAAAAbE5soaK1Qwu63mblVljUBQAAAPCXZIsjTk190wUQ TRU3nlA9Na53HQCAw7Oxq+Zwts2XTFy3sWTkbhLzVQQv3HhIXAP/haddBwAHxaOxfQnBXELHhAQt fEIVIRGLVfoFkfDvPn0BAMB28c3Lm5y7pz7vbwpf/8e4EAAAAP4zJxX7Y+PIquRcVUm+6vgAqMvl rgMAMLwae5P/XkP/G7v7fD5D9wGr4oqdA/CXxO5Xu/ZIFsIWACByZWzfONu3VtSuJw3tc8fu7jF1 nk0DaIpYnxAaI91L+dktAAAAOGwuPG2xfCexMW2dsa/rP7ZPhHEyAGyZHwHYO3udhmEgAB8IgUCs MCLUjY0XYGbjLSoxMvMaDDwPD9ClEzMbKwMoigjUrU3M1XbcqiU/fJ90Smgc9yhVm1LffUgtAAAA ukdqcYw7djOL66aJRqMLqarf0/nNvo3EwuwbGYXZVpUouUUtrPAFF0Zk4Y774c41YeQWbv71G5pv n7409CbPzdGHHB19yrPrufYhR0Nf8lyHduUWy+tKFo9zXVfrhBYLiYUTWVRWbFGLJn7LJ0pPTmHk FoUntyh+wskuvr4KT2DhyyxKqUUZC4FGjKOjT3l9ncjj44OMx2M5sA2nndDCSS2MwKIsy3n4Qgtf ZjHU51qbGJmFL7fwRRPmmOG9KJZPtA3F9W0pluQV3jbUsL2rDdz/an4a/f+P+bv+Nx7CY7zt+fkd AnPa2LXzzgUVRppk7yskrPgRWdjtrj2+58svVOw4SYad92R/Xy6Pj3NSvJrFodSyCr3gUC88jC1M jI3XX8RKwzZUZJ9TjA8AAAAAcVKL8/U2VNw4ncX9NhMEAAAAgHmBRKqIYZXIKQjOKRQeagHxXdsJ AHh8zGKSMS72uU3U7VVgbE7EGp2H7kfnoceEfgYYAtO2E4BB8GwjRc7reEhc0SSqSEXqvaApdN56 HwAAYEg8yaIZIgAAAMB/pElqoUnV2a96DsCmOG87AQDFS8aYWENmSeyHjult7DvBmKyC//tC14k9 v43U4q2tpAA6hFmbdirh9WKuh2Vq/VmsvrRpzZqe1yfVwJfPBrApQtcw+r3i9k8zAgAAgDY5k/q6 WJMjoli3rkMkfD0cuu/YGACAjfMtAHvnrtMwDAVQ07FSFyYGBPwDO/ALlfgo/oGhG2It8Af8CEgM DCxsoEJLTHMTx3Js95GH23MkK26c3FxKVUwe9yC1AAAA6D+ufwqCJzQnkyc1Gh0Vr6Vw9bLItymb WFgiC1XIK8ylFlnMZvNCcKH7el0pvFC52KIsIi6xdXFwOXZfSaW4N3lujxRy1KSSpyaFXFPIUZNK nuvQvtxiUZFbVN/bebFOhBbl8reQWJj9UmYhUgpTYLHsl3KL74rcotzeJbT48QotBoMDNRx+ZbHf 1HQ6VePxuBgTmYUttBCZhW4yjtCiOURiIUILu4nU4v3Teh7NU/w8WBjdLJ5uCi6s8b4X+o85Rpf7 9yH+vv8OU4/Pe9yP+Kn8DJUrkyJHyteJyEKuKIqc4r9vCisM2UVFcpHvK+MSbyAxjdg67nEuzwpw mLVLVRVSuLwZ9joz/VCRPPsmR9+4/TYCAAAAQDP4iuPNraVud1m7bz9NAAAAgL3hwnod+1CET0gb ejjCF9fFLpyvu8raaddJABg8e8Z8hWJCBWdiCqDHFEX3HSeUL8AuoT/fL10nATvBrdFfpyCY67vZ lleE5BaxfyPqCpq5cgIAgO1z0kBM7sfZDg9dJwAAAADQEbFSC9+1JnMbV39VmNvCqpx1nQCAxccK 28ZcO5R+3XVFV5yYbTgPDH0j5jMvff1A+GMbSQEkwLXR36Qwr3mvmtlc96a5hBm+50kBNiU0R3Jd A3/N2k3zqQEAAEBPOM+Xrrlp3Zx13Xmzb1+l6ufBzI8BoBX+BGDv7HEahqE4blALqOoMAxIDJ2Bh QWrFws4ROAcH4DC9BRIXQIIDMLJVYuMjIm76iGNsxykQ1+X3k57sOLHzorT5sv3+iFoAAACsF6EX BFl3WdpFW0OHh8eqKJrNmYHEK7EJtRCj0KkWo2iKW9SCFabAhRaykPWmSV2p3xS3yCdAO37+Ljn4 mYOPmlz81OTgaw4+anLxcxX6Ebeot6uElswyl6DFhyVo8f6VFsXb0l6XghWmOEVTxKIWs6hFL76L WYiQRZ2vfPrOYLCldndf1NHRSM1mMzWZTIxjqoQqRMzCNl2uzRa1gN9Fgo6LgIUtbiHLw+FQPc/n ZsVG3hkQXcQqXOIVdpm2cn+S39r+288+OQShRwwiffubcAwp68e0z+88bft97GMx+k7fVyQvy8vz I4IVUt4QslimUn9gil8YJvW/hC3K9GBnR52MxzEunpW2p2qxitDAQtcgQ5+5BiHaHayu1D4hvslN dMYCAAAAxBOapGjnZdkObHdd2uNfOQgAAADwz9GBgE6tMtfkXd8k4S7lockQvu90rm92OXKV2gEA C1PUIhRAxlxuE6+IDVoeCmDuat/lG4MXYFOx/wea+0S+wOZwp9oDlMVc49uu/UXAfOu73CNc94bQ d0YAAFiNkUrz7p3r+36f3KZ2AAAAACARPlGL0DNkqL/J1/fU1l5XHwBMzlM7AGDxFLldrCBFbL9f Wz+g3TZALvh+8zfJPAJYL6al7Sv3+DHXHNC2eaM/Ga8mdHlnAFiV0Lgn817x0KdTAAAAkIypo8z3 XNr2jOsTd3PN14iNr8JzMAD0xqcA7J0xTsMwFEA/QpQJCYmFiZ2pzCxcgYEzICTOVDExIyQOw4iY mKBiQWqAEpPacY3tuJA0dXlP+orjtvavW0VNE/shtQAAAFhtfCcH500vurq6k52dfbOvF6+u5RJ1 eV5kIUZeYW+VyKIoPo3gQpVVXS28EI/IYmr60H3X9at/DZo82yWHPHPIUZFLnooc8swhR0VOn/ui dCe3mJ/rWvUxnY2lFlpU82qrsa2EFrXIQkstKqFFJZ/Q8T4ns9Ciizrq/Y8PV2bhRtVX6L1sbW3I 5uazHB8fymg0kuFwOBu3qZFaaIFFURQymUy+tzpssYUtwSDaD73wuy20UOiy2g4GA3kaj6VQP5pi C6CHHrPlFT6hhVW3oeUWHbHqi9AvY6H/rkFU0Nz+Ko/Ruoxx1+3zHgLtWlsjR7LqjHhCxMgpvsu2 sMKSXcxJLhz5hZFj6Lbtvss42N5OSXmvjBNxPBny82bDHy4NEa+8oummw9hzfcMIAAAAAO0TklzE JjO+lHFZxuuScgQAAAD4b6gJEqEJDItMAm6aHCGR9l1C9TmyW8Zp30kAWDzOwod7zhZbPNz3vNSF z0PngZ/i7zMll/W8OQaAxYvhb7yVcWPtL3rsTD2e+47vTZKLlMXMEFgAAOTDb87hQ69Zl/8D2ua2 7wQAAAAAeuTA2fctSBsidB0qpZ1F+gGIcdR3AgAO9566lOuCKY/ZbcWkGG6fXPuDXEj9rqr6hzKu O80GIB/OnP3U+9R896fFZBduOdS+mwtAG8Sub8fmy1wsJTsAAADoG/U/t5a9ufh+H9vlpnVUYnM7 JLJ1+3NzAgDohC8B2Dt/nMaBKA4/toiFFolqqzRoT4BEi+hoOAF3oV9tl9NsQbuiRoITcAAKSoRC hJ/sZ09GM+MJiXFGfJ80mknmj39BxHaSN++HqQUAAMD+kArmtj7dHH05tNB8/ltWq/Xl3KThamKh bTWj0FrzKq+bW/SGFa7BhRpZWL9bbG6zpm9uEdZYSoJ2dO6WEnSWoFFB5+4oQaNRktZN2a25RdjQ wvbZ9uYOTekNLd7b/t7QwjehMMOKxtBC26+OwYWZWbzWj/txzTyba+1ld4xYrEtVHcjb25NcX1/J YrGor+/z7n9A9ZtZhRYztrCiz+kY38QCxsUMLNxiyc61rqpK/t3fy1JvwoYXkyzji3Zcl+R8ZEOL EpLQ77u+nPUx5Ch7/dL/xiW8z3PWL/01+Mew87zrANEZUjjmFa5hRWdk0dY/2v41swvH2ML6O9OM uv41m8np0VGO3PO6HEpvVhELLjyQcJBhKhAxFJAoA3UoKJEfYQEAAAC2I5b01G2HkuC5Ce4e63Iz rkwAAACAb8uZNBskjJTxRKwv13x2aBNFjJK/j9OYreOpRQA43A30p5JuWD2UgDyUuDyVxHzlzfeP E9NGMAN8Bx6mFgBFc1uX57a9zfndxqTO7ZsYV4S+/1t5Ovw1/NeAyQUAQLnkfMYnqdg6eq17qcv/ qYUAAAAATMTPkdcPJfDKSfYVegwQ4mRqAQAOz8NDgqQSMftjJFLnzEn1A+wbOQnL/3y1KIA95UKa +/pUst1QO2VgkRuXJpG2H68WawNsQ2wvjXut0L0yf79MEQAAAEzJWVuH7l1jz39mj8bQXJH4PS/3 wgAwOh8CsHfuOA0DQRgeQYEbUlBRcAA6bgA9p6Cho6TKQShoqOAAiBtwCUokToAoQJhXFjPOZNn1 xsGxs+j7pJHtfXkcRVHWuzM/ohYAAACrS2hCcJzqdHFxI5ub2/W1JrCukoV/1knDq4TYVshCavEK e3RCFmX5UQtcuHNXNhW8mApZuLH0nnoPvXeMXJJs42e35OBnDj468LM7cvBRycnXtvxd3CIlaCGi MbfV5/j+I/zgRAasmIU1K2bxasQr9PrFE7PQtlMxC1deCWPYcePCBkXxKU9Pd3J6eiLj8VhGo9GM oIWKWjgBi7Isa1NBCxW1+M/flVXDF7RwqKiFHoui+C4v39600+wxPHBdXydpN9e2rxOzsIIWfn0X z7hMukhCT6L/4cfP+RlW/Tuo4yN6Mvz4fXxOa/pbLtNnmllxVOEJqRQkdBdfLVYhRtzCF7nwRDBC merElO9sbMzj8tbEDmR2Y+G6/N5s6JdZ9+fdjCiJtkpqIRYAAAAA2tM24VwoSPFqYufduwYAAAAA UgUOpwJ6/xL4EGoTuo//rs5vkyNHQzsA4HFrzlObAlIJzue1VHJziZyH5o+xYG+A/4pLXvw4tBOQ Jc9SiVrESL2jiyUaCwlTtLVQ/1hCs3l8BQCA/lh0jr6MuX3u7wuaCM2THNcD+AIAAACwCuwu2C+0 fuXXAfTB3tAOABisqEUqyXKsjV+XWtfrYn0vJJgBMBRN6xi2zNn9xC6X7RBAJhz+HGN7yKw1xYDG RC5SfWJ70yRSBrAITXEzTXY2sYeefAQAAIDh2A+UxcQm2v7HbRO7EaoT4X8xAPTElwDsnT9OwzAU h61WIlJhBQYkhDhBZw6AxMQ5GHoAbsHSG3ABLsEGEhtn6MSERIsiYhInjvHLnxKSuHyf9GQ3jp3X tEqbPPv9ELUAAAAYB9INgH2jcJ3YZd1AJyfnKo7Lw9kJwrXwhK5rMQpdGjGKQtyiEKywTQtZmHbb TN90TCNuURy3KaEk3cbPbgnBzxB81OBnd4TgoyEUP7ehvbjFz5hfen6KNbPpa12mlopYxJmwxee3 GRGLsqDFJhelSMUqPjKhio9c3MIIVxRCF66YxcYaOxXQkJjNPtVq9aSWyzu1WCxUFEX599KIWriC FraYhTZ7f+gHk+TciFhMp9OS0IWuR1lS8Pf1um6w8stsfEmg4vu4mZBGSdCiI0IQKgg90X8f/o/9 M2wy/pg/4105x389/i68h7+m6jyZ3wNbAUILV0yyPrZQRS5ooVSpnDj75XXbjB9Zeby3p+YHB03c v0gsUoVYhW9y4cTZLk1C9O3vBmZVTelLmsdkRQAAAIBukZKVViXJ03ab2GPfzgIAAAD8A+wFEk0W DrdZAOFrk47jawuZM5WK+gKMhefE3oU230Jq3z5VIhRSYvJtTfJF8g9gF9Hf9ZehnYAg0YIW5pov XTPbJNGIPfW6a75PzKKqn7Td56uvDhAib0M7ADAwdff9oT8X6JqHoR0AAAAAGIjDrJTmdCurXTXc p0kf/o9CF8yHdgDA4XWLPlWxOynGKMX8quKBvpggwNipirWYbfd9OwUwUq4S21f1887c5LySiIXb 7va3txmkeW1uu1sH+A118Xpd6pjhTT/uAAAAwICcJnak5OfRvufVbf8/V63t8JXusV2fAAA650sA 9s4fN2EYisOWgIWBpUjdeomqB+jajQNU6tyT9CDsZe/UPweoeoBK3Zk6IEEpNCZxeAlObGggMXyf 9BTHdpyXgBQntt8PUQsAAIBmYnsBuHcdNBw+qV7vPN03gazjwODLNEB4HBBbClmoVMxCbrWQxXy+ EMIWiyTP1JFCFsvcOdfn3oZQAnDjZ7WE4GcIPmrwszpC8FETip+74ndp2bki8T3Jrrk1AhdxvhG2 +E3sR8UCF2txCy1IYSwWqZil4hVrIYupELmYinIjZpEXtJiXClrooNHd7kxNJp9qNBqpwWCQ3INN MQub6TJdR9ux/y+ayCqYeKu1MiNiYbamvNPprNL6t7I0kN0WlSvRURRCGplys19BAPlDBXCv83ja /3/7x3ANdR7v0z6iJ+72Q78G2zkyM+vM8ySXZ0YVtYKEmbVnhCpWeULEoh09l9pCuEKKW9hGOZXI v0iEmRycRXatspMLW2pzwmE+z+z7DrYa98rq2m4jAAAAAFRDUUBUmfax28i+9+opAAAAwOnRj+xK 7Jct4C0qsy0O9l0ckT+vrcyV30Tu6nYAIMebSLve0WRePvDGQpSVBTT3DWLuG8CcyQxwCtiCQj3X 5AuEyziyx5JyW8Ax23/PJVhhE66wiVj4PBdsvtl85VkAx8Z73Q4A7EiV7+autkL6DrBvviL7qNsJ AAAAgBroF+T7BNkqq+MK4iXT27QLIEHUAprGeIu6ru+1Mu0Ss9j2HHwLhtAoG2t/UdmxeoBTpRvZ TZIumn/mE6BXilj4riktWgYroT8PVeHqMxXZa2QPB/IRAAAA6uMy2ZbFOZH9V1vdKkyp4j4wfWMA 2Ct/ArB3/jgNw1AcdqlUgejAAgsLE4KNA6AObEwMXIDLIO7BCdh6CgYkLsANQEhFomqETfMax3Uc t0mbpv0+6cmO/74UtQ6R/X6IWgAAADRP6J8BqbvXdlM20MnJqZpM8su7CFkYjPCEyZs4yiYVMYpM 3CITrLDNCFlIvW3SdzqmiFtk81ahLcG48bNe2uBnG3w04Gd9tMFHQ1v8XAZ7LfPU5vLTdnb8hST9 XJJU0GJipZOZ0MQ0nQpQzItZ/M6EK+bT35yghYhZJMnYEsjIRC2ymBB5ut2O2t//VufnR2o4HKrB YJDeeyZoYYtajMfjfxMxC1vQQvrBepGA6mJG0MK1Xq/33/ZrNKoykcoJVtim58hd232WvKdVUjUI PYH+t3/8Vc9Rx9+47Z/xpn/PY+dY9fibNEcnbW/v1ttLhSo6aSpCFTNBC53vmrVIylRe0GKWt038 StNjvYZd9fsxLl5rO1CZWIW9wbDI3I2IRW18wfRUSeo7eMRmRQAAAIB6CQWrkzKffWq7W7l3AAAA ALvHpSoXlfAdZPBdu3m3f0zbbeChaQcALH60vUa0Kwpq7tYnnraLBD+PEbFw/XDb+K4BtpG3ph2A 1vFi5Yt+J2OELUK/5z5Bi0VFLorGDa0PRfcAAACbxSJ7b6rOsyvI2vjctCMAAAAADXARqFs26FbM +fzYel8QsF16VoUwZ007AODwEdku9H429C7Z15d3v7CNxAQst8se1+EUQAu41Xao4gQoXBEK35lS 39lSt48vSLBS83O69W4eoAplzz2ydjxpe1+LRwAAANAUA0+Z77lUyouE3FSgruyMh5vyDAwAa+VP APbOGKdhGArDD5VKCKkDC2JAMDB17wE6cww2Fm7TmYEbIE4AHABxBFbYGDq0aolJnLjGdhKaNnH7 fdKTXcexXyI1de34/YhaAAAAdA/XH4GbspPu759kMDjLP+tg1mkg8GUeEDwNjG0KWUguZmGmSshi Pl8YwhaLrEzXMYUsllafRd/rEkuQdvxslhj8jMFHBX42Rww+KmLx8z/8FbfwCVoU+2P/ClmoVAtZ aDGLeSZCMcsEKGZZ2apgRZG3P89yMYtUFEO3kZoW0PCtUfb7SgDhU0ajK5lMJjIcDrPrLQQtXGIW 2hC06A62oIVCpTpQea/X+02/p9M6jRapEfD8wBSw8NX/JzEEoe+6f1Xa77pYQ5U+Nt3+pu/Ruufv wj2Ouf1t9NGFa1hZQczq2mV6dVH9yug39rRQhRa0OEzy2nIBC1kVt3CthOp+VP3zo6Mql3Qi6QKs +QJhT8KCFWad0IJs3QVa120EAAAAgGaou8HRFdxO2Xtid5t2FgAAAGCPeEnsIcu75slCGxvser68 q00RdzsuYpunGyd22bYTAAYvgWMhoQjffzZXWVlg8rI6vn7K/AXYdd7adgCi4kuqP/PrzMu55uh8 z3afkEVI4Cjkj1h5AACIB9f8QRNt7hvmb+Bja14AAAAAtMtFyfHQOLFOIK9Qu/s4FoX1GbftAIDF h6PMFYDfdzwkSOFb8yvrg7lf2BV83x1lz4m9bt0jgO5xnNh1lveJS9jmErMo20daZ5+pCWN+aIrQ uCdkitttOAgAAACtoea6T8U/Hg3tvbDHvCLVx78SSEUYIwPAFvkRgL3zx2kYhuKwi1TEwIoYOoA4 ARIjAxsbYu/EOThEd2BFXICJa3CCsjMylFJV2DSvcV07diBt6vJ90lMc/3l9UaU6dZz3Q9QCAACg Xao2yEjbtbbLmKNe70RNp4vu7OTfRnjClI0YhTmKGEUpblEKVthmhCyk3TYZK+Nn/srPbZpckrQT Z7PkEGcOMRqIszlyiNGQS5y/QUSarJolQYvZ9U+LsghaGGGJyc+5LWhhC1DMzBWzGOm57lPX22IW o3m/sv7r51j6mcwttB9rd1ep8Xio+v0rNRgM9HzeWxKzELOFLFwxCxmzrd95DthiFiJkISIWttiF 4f3jI8lfqH5J0ELKci7tO/WXfXIQKsg9if02+N+Ga2hzfIp/RE/i/nO/hr98RqcYaytA7BRCFZ3i OBe10HOBiFssCFmoRUGLedljIpxx2O2q0/39lBDPte2pUqzC3mQYMnczYqiP2zf24DWWlM+tBwAA AIB0Qonz7LqUhKdP2u5XHSwAAADAP+BF252nPrYelpoAKOWF4JBvtz4nbtoOAMDhxSqHksy45ynJ zkMCFlWJy+sKWVTVA/wH3toOALLiwSr7ftvd+qo+MTGLacBiY1ISdcRgDgAAWA1HDfhI+Q//14TB Oa4T1CWUJHSo7Xm9oQAAAABsBAe/GFP3mVQs0Vcd/wDCcdsBAFj4BC3q4BO2qHrup9Tyum+ozbdG 7LYDbBqxhOVu38eVRwSQBxcqTXDCJ15R531S35jQO6TbsFcNNp/YvCH2qu12jXEBAADA+jkrjlX3 o768KE2bUuF7X+6JAWBlfAvA3hnjNAxDYfghGNoBCQkqMcFNOAN3YWvvwdqBGyBOgAQXYOEIDAyd aamoaV/quLbjQELq8H2SFcl27Ze2aty8+P8xtQAAANgvfIv/Sufd6fRBjo/PRe91qqC1in6rucVa INs2spDCzMI+GiOLxWJpGVssN3XaRwojC9XO3s65nbsNchHsJs5mySHOHGI0EGdz5BCjIZc467F7 nSsbWojoPtr1uX+WjC18phNlM4uPHcMKczTGFlszC22ff5tZ6Ot3zSw+g2cxHC5lNnuRyeRGxuOx jEajkqGFmloYA4v5fF4U19Sin59xnqhxReioJhdvs1ndgYvxxRFAt+tU5P3A7l8z/jZpwkgAof/+ j7/vn3Ef3uO2x+ccmp+jlJ3U33inTrON3+YVsjWpUNMKY05xtCklAwspm1sUxRpT5zF1F4NBSsin sn4o0R7yUOIPGNp9fA8ZxhKssb6+txEAAAAA2iEmoqd17sZFFb+brMpzq9EBAAAA9Bsjemxvmk8V jIxtXvCJAFWNmdI3J05W5brrIAAsjEDNe6AttEna1+72CZlYVImV2//x3P6+Ody5Af4b5nv/2HUQ kAWvmxKjSnSs6nfeZ1Th1qeYW8SuDSmiZwAA0A7DX7y2T//r9537rgMAAAAA6ICLSJu7Fg3ltGL5 qNScVmp/AIPJGV52HQSAhZ0vrHpWM9YntS2W56tzn5f7w5ATMZHyO/m9uQxAHziT9R5SQ6pAr21W ETKv+KmIrwtrf2iKmImFHkN5+dtVefqDGAEAAKAbrjx1oXVqHQ2VKvMKVzsltJeDNTAAtMqXAOyd sU7CQBiALxoYiImTDoxubryAk29g3EwceRR3FxOewt3V3cTBh2CUgcQQif1pr70ed9dDgfbk+5I/ pfS4+2nEFtr7P6QWAAAA7REzMfwmi+umjobDi5VgQqhLLPLnRGIhj0VGIUtpW5dbVMIKM0Rkobeb oV+rX5/3p8f/yy6JJ5UC3uS5XVLIM4UcBfLcHinkKKSSZ5j1+530+8qlFVpisVytVyKL5UpmsVza Eot65PKKRSG2+CrFFToq6YXetigFGHVRxmI1XkhoMRh8q+n0TU0mT2o8Hqt+v18TWmiZRZPQQke1 H4g2QzDFEjpMsYUwm8/dfxh2gXNd9LwoLO5tb7SrCTBcfTq76X4R+q7nF9N/12UNMWMccv/s4270 n/p72OYYWmZRu4NP5BTZsUaON0cOacVx0aZ8TtWFFqXowhBclGMUx6KzXk+NTk5iUrzKYqAqWYV9 o6Er7JsTfW3stqGLrspou7YLPbsWAAAAAOJpmtAYW0hP4j6Ljx3nCwAAAPDfkItOj1m8RrR1TWBw bY8tEOSaINE0fmqI0OK07SQADF4atvtuCnF9T7PXNy14bre1x6dwOUCF+Xl4bzMRSIZn47H9/zP0 e5y97pNR+EQVMZKLWJlFU44AAACHjhwbRWrx2XYiAAAAAHvmMqKNr0CX8jz2Le0+N1kHMBm1nQCA xW+K6bt+zw1tcy2brgX6+gZIgdC1bdf6w27TAUiGW7V+7h4SWoS2+SQXrrmkru8MroK/ALsi5rih z43uspjtIykAAADYOyJxPlfNczN8czBiznlDcgvXUin/OTHnyQCwVX4EYO8MdhKGwQDcBEkIBxMT D554B+Ndn4E38ODN+EwcfAESfQSvJt70ATx45CohIKUr6366roPBKH5f0nR0XfdLgM11+z+kFgAA AMeD72T/oWqj0ehVnZ9frZZdkYVZdgUXCyGyUGuZhVtrkcVsNnfEFvOszfZRa5FFvq+FqHd/M2JJ JUF7KsnkibM5UohRQ5zNkUKMmlTi3MQvszCY52WNxMkVXBiZhSkzZQQXZtkUI6SQ0oq8/i3Uucxi 6mwrhRYzFRJa6ITQ/f50eSz9VuPxWA2Hw8Jx1EoqrNRCCi2szEKKFOA48Eks7LIu3W539fpnMgmO UdrmSizylbLzZqmIeZ80kYQeGUT745/C39Dm9jHj8zlvd/wU9lG4w84KjERbJzs+WIOElFZoWcVZ VtbtUnxhx8nWyVlN3Tbo9WJCvliWW1W8mbCjqsUWtk/shKsNL9TX9zYCAAAAQHP4bsgve1jRTZon k+DpCyZPihv2AQAAAGLRQgv9kPy7aN/m+lcocY9vXcw+QmOkwn3bAQAI3O97HYFFHengLv3kfpVn uSxegFPE9/n+OHgUkBpvy/JV0Sfmt77qN11KLqpK3WOFL4FZKLEHAAAcniauH8B22OOgnht7aTMQ AAAAgBYYiNdl93v7CCXh8tV1knxV7Rv+N9dtBwAg+KzRNzSn6JNQuNuUXeeNSfgf2jdASpR9H57V doIZgFPjclnuVJxkwk3SG5JYyD51EvpK6vy/ARCiat47NF+u5wIeDxAjAAAAtMNNVodynPjOX5su SpWf73IeDAB74U8A9s4ep2EYDKAuUiuC1JGlQ0EcgRUpGzsDOxdh5g6MnIDDcAJ2FhgqJFBE3MSJ sT4nTps0P31PshRsx/maSklJ7O8htQAAAOiHkAfid2m5rRtotbraCiZcjNCiFFmo/G/lyC1KYYVd tMjCtNvF7Gv2z8Yzx9zlVOzPmJJ6jyVW4myPMcSoIc72GEOMmrHEmeEKLey6RBnJhS2ySLY3JyOx sEUWmYAik1P8FIKKUlrxbW3bIotSfGFkFnp/PWaS/BbbmTxDuDGnnJzM1GLxqdbr063QIo7j4jsI kVkYoYUttYDhYAst7GJLLjRRFKmvzSZkwP/JzwWxhX3s9CBy34oE6kNPQn+IRP9dg6igfvwhn6Op nOOux+cz9HeMWT62EVYUs/WMrEKSVph2U6cEoYVyZv3l/Wd52/l8rq6Xy5AQb9ISqVJW4Zt0KE0y rOvj9q1bbCQl2vMl3+OlLAAAAMB+hCSn8yXRe0vLQ6fRAQAAAEwDvTD+UckL5Ju+RAxZvHCMCxwu VbboGmAo6CTnvhfNdYljTJ1PNNFUfBEyRkgcAMfIe98BwOB5tbZDru8u0vW5Skrhtrmii1CZRVV8 XPcBAKaP9Axhl2cGU37OoJESgb70FAsAAABAX5ypLPFtU6RkX1KbUu3MD5/6b1NoxkXfAQA4fAh1 dXKKqr4hz36l/2l9x62qBxgyVQIXafup84gAxsG98q/ldNd/+iQVIZKLthL6ArSFdN/wzaXSguvn g0YHAAAAhyIW6kLkFvvKK0LzqvC7GAA6408A9s4Yt20YCsOvcJB4ypAhKDIU6OagSw5gIFfJlDVr LmPkDkUv0B6gU4ceIUAndwoS24ppkTJNkBRVyxBZfx9A6ImhyGfGhihSfD+iFgAAAHngG/Tft130 9PRNzs8/bmwV19rEtja2nXaFLKQRs7CPSshisVhZwhYrnWfKSCNksW2rco77d8a/UlKA71J8xc/+ KMFHBX72Rwk+KvL3MyRosd0rq4QsakELlbfU50poYqkFIBZafOKtSVuBi9cdYYuqqoUtqupF5xsx i23Z+no3LTfthfry9PSDjEZ/ZDr9IrPZTCaTSdP3tqCFEbVwky1osemBrP9nx4stYGGCl9vnyh6P x/I8n7fWo400UQpTTglbGHGLyLUlBKHP3b+U+hHkKLv+0vu4hN95Sv2lf4a+29hZRTT3Gd1PjcCF to2ChC1aYQQvTnRyxSxMmUbcwqrPblvlXZ2dyef1Pa2FC6kXYe0XCkcSF6ywy3R54VBayvq6EQAA AAD6o21DZMpmRzPhpwK1PhzSWQAAAIDC+S31xng7UMU+i4eHWHhMnX/LeZ7ubmgHABx+WnbsGczN c5/DUgOUdw1mHgts7gb8ADhmvg/tAGSNmhfzBSOzic25xQQr7PNVIPmuc4Uuut4XXL9dGwAA8qTt eX2fwGA5zwUciti974f4RUsBAAAA/meu9TE2Noy9B+6WkcjRZ/sC7YZ8aPMTjoOboR0AcAjNI8fm Ydvmbd28lDW/0Hy1r12Akgl917+u09+hnALICCVadyvdAvGmiFjE/h4K7CsBm6C+0Aep69+h/TKP 6/TrYN4BAADAUHxap0vxjzNjghS+MbDPThkDh8bEIZ8AAHrhXQD2zl23bRgKw0xsB8iUOR4y9gWy Zu3QrUPGDM2z5AG8dOtc9Gm6ZOoSoLO3LnFqp050LNGkaV4kRInI9PuAA8rkEXl8gUVJ1PkRtQAA AHh7YgtcdNvnyj6mOjo7+6Ca3NY71EmyVZMo+8kRtBBbb7e1YIVtImRhfI25fcnYevyccmvnn6Dd UFKcJcRaQpwlxCgQZ3+UEKOQZ5xxQYs6Zi1oIeW/nVKEJkRwYr1+3JgWt6hFKGqxilqk4q9lWuBi uRG3MEIXuq0WtzBiFqZfHa8tNCUcHSn18HCnrq8v1Ww2U9PptPEzohZazGK1Wm3NFbPQ/vl9T6Cx xStGo9HGdJ1sC5PJRP2ez9ViuXR33i33O9/dDvgf2AIXnn1LSEJPov/h+y/5PeT+G9T9I3oyfP/v 5XM6aEr3DuVhI0ixNWXEKkZNu2yP5Zjl8XFX/m3HaNpOqwnOyXjcJsyLyo6VEavwLSoMLTJM+fhu zKpEGXuYya0HAAAAgG6EHla060JJ9Nz6H5V9e+V4AQAAAEpEEh2LoMW9p61N8gnfPK0PXpLMMle+ DB0AgIUkpvnZws99INqui7WnLHT+1mUc18f3GuB/4XboACBLFpV9t17H/jNTicZi/+GuSEXKuohY tI0VAADy5KXn87FkwLCPffy8GTIQAAAAgAEQUQvfmu4QqXlm27XjbRLZMq8FH4haQE78SrS3vSYb E6TwlSFxi9j1arfutdYrAPRJ6Lfua/tT2de3CAqgAD6p8Hw8lqy3i4hFm8S+MaELgL5Jrb/y3WO/ UggiAQAAvEfOm9I3J1Vqf47s8+3D7LFcmBsDQO88C8De2bPEDkRh+KhcWIRFkFuKWvsj1J8j3HLB Rn+JjZ2FrTb+CbGy18pSLOSu3xk3R0/GmSSLicmszwPDTDIfeTchH2wm58XUAgAAoHtCD/o7VZ0O D09lcfHve9kGz9ayTc54QvOJKYUUTCycQYUzsnh6ejHGFi/5Om0jubmF3darl39/ZzRJKoG/U9Hp SEVrCjpT0OhAZ3OkoNHRH53FuR1fDS1E9NvZiV5raPFcMJtQI4uigcVjbl4x9vL/H20+zS0ejJGF 5nbs5/AvyGQNBq9yd3cp+/u7MhqNZDgc5nVxQwtXVkMLNbXoz3GBMtTQwiVrcDGfG0y4ZWdqcXN7 K/fjsXayA1RtoNTcQoOn2zxUbosmjARSDvT/E/r7fgzrjN/nYzwr+7jt8WfhN7RNm/tJR52313hT N5cbVLiyOki4XM0q1PDijzO0MMt+GzW6sOP5bzFXBoM6kpeztCXFSYULUm1soW2mmXAoFW393ciL VwAAAIB2iQU09dvYSfs2oN5elo5b1ggAAACQEkdZOgisr3qJWCeI/HeDEft9U2c7S2tdiwAwnJfU 1Tl3Y8FoYh9UVwUuD9XHthPSC/CbcefARdcioJecyadxWZ1raJXBROhaXdekwm8XWi7TENIaKgMA QBowv6Z5/HvjiUyCIAIAAAD8FlYj68vmeJcF+gr1JaAXNMV6lpa6FgFguDblaf9LlpKy3zeUx/4H LpsfCjArxM4FZ2pBcHKAyTyrDZk+6G7MxCL0vamtq/O875djdQDTEJt7Gav37xtXWfrXjjQAAADo kM3AutCzatPmFf5zbayO518AaIU3Adg7e5yGYSgAu/xUCHaQmBBHYGfiBogDsHTkMoiFgWMgwSEY OQBrhcTIf0Xc2Ilxn39ATVPD90lPTRzXeUUtrlLnfUgtAAAAFktswYs9dlzFUWqg3d39qZzCpy56 rUyh7DZqIUUdVmThCiza7e99bdhx9Lj1vmrOv+w1tkspBF5KnpqS8lz2XEvIUUOe86OEHDX95Tlb b6HOo70ntt6fTCUWrchiIsgs3p3HdyO2sHKLF09y8SoILl4diYX7/A8jxfgMCi00W1sfajy+U1dX l2o0GqnhcDht15IKSWbhhhVb2L6u2IJY3tDYQuZ+WNGFfR88v7017xXpKvGM4CKwPzBii4HbxxY6 N2GlGl0yD5lAlzB+evy/8Br6fH7O+EhP0uOX/hoWcQ7p7zQw7f7KvBUjpGhC1bKKNWF/1WtrBBhO NOcw887O+ro6MMKuBIdVbKhWVhFaWBhaZBjrIy1IVIlH6cfZ2M1PAAAAAJBPbJF+qnCqVDTvrIr7 DvMFAAAAKIHnKs6ruMnoK33nUmr2R1ipj9/ujxk7X6qtNE77TgDA49bZzvmMxUQTqYLn/vFYH2n8 WC5+O8B/QJqLH3rKBZYX/X3vNnI8pwhGaNv/fz/JiNAcEJoTcnMFAIByofDv/JDmxydViy0AAAAA /gtaarEZOBYqwpWznRJXpM7B91uQ2Os7AQCPxx/0zb1++1NZRU4frg9DyUifj9AxLSq9WERSAAVw 4mxLQglfRhG7hzQmwfhNsV+ArpDmiNT9MtdVXC4wRwAAAOgefc17W4VrluQKLnJkbrGxlPqeA3VU AKBTvgRg74x1GoaBMGxaJAYkxMiA2BEjDwBzN56AhZdgRuI1WGDvwAuwMDGzg8QrAAVBiZtc6lg+ O0DSNPB90slXn7FPQU1MEu5H1AIAAKBbQhv7k9QPXVxcm42NrZmfC1iYiu+aFZ6QNhemMKqwhYhb 5P489vFhSiGL+VpTr/39wWgbCsk3S1/ytPQh1z7kaCHP5uhDjpbF5ll9Zldd+7Psy1sRuBAxCxG0 8IUt3kqzIhbT6aT058IWr0WffHaFLcTeCyGLfN5cSCMsaDEYrJj19bfs2vlkxuOxGY1GZUzEKUKC FiJkYWO+kAX0BxGwcE2Kj9t2OBzO/JfJJO8LT6JNrrchM05x9ZaKrP+2CD2F/v/+/G2v0cTvuO/H GLGJevP/lTVmrXyO9A0K4QlRkLDtanZNEvEKEbNYFfEK22eqghYy1p3PXcf2ba+t1Ul9M7MDU32x cGjSwhYy5jsvHJrE2PJwei0AAAAANIf2Yr7blzK3iN5RZvftpgwAAACwtNiCFOeZ3Slxbb8VGiO+ VoxCK1bvz6UVqNfW7Bv2fuZx10kAODwavThN7Pvtx/0x/t9fsWLl2vnBHx9aw18bAIy56ToBWDqu MnsufO1cmdrT+ed23/dFKuoIXcSuDTGBi1hxJwAAWBw7Lc3LuzY/I3UdPFtIFgAAAADLw24iHirK 5cZCY0Kx2Byhgl7sd8HnsOsEADweao7TnvlrsdR95//wrgBACu37cdlZRgDLhd3j75l6IhSp/xX1 BS5SYhexIr6ur8UAvkNsfyV+6nn+aWa3LeYIAAAAi2e/aOvUNwndx27K3LUAAFrlSwD2zhinYRgK wy4oCBArS4cKMTGyo7KxMzByFY7DJVg5ARszJwAWhpSKOI4b1zwnDjRN3X6f9JTUduwXC8XGcd6P qAUAAMD6CE3y3X8Ebgu7aatoPD4vBSZ8TOBrczQCFsa0IIU1X8xiNps75/Vv9xq/LiOQYdv8S1cM SyoBwvFz9aTgZyr9iZ+rIwUfNf37ufyezjRl01xBi3klaPHtHK3AhBacsMITeSVKkS+EKbSghRWs qI+u1QIX+nojYuGbFcsQBuKCLBupg4MPNZkcloIW0+nU3FE5NhuhCi1aYUUtfLNl5tVAm8LfBtRY QQtX2MIXuciyrCz7ledRK8AjR6DiV5onYFFlllYGV9/rd9kHIQEEOWLq77uP/nv9NvRxyvWvo41t uIeYNkZVGXdnnhWrKAUr9DikatGKfZtn01QtYuGW81UmFm1UIhenxbh2eXIScwtXhR2pWqzC31wo mbQJUSrjl236OEk5ZX91oeA3L2wBAAAA/o8UuM7foB8Kkqd/vysjbPG5DmcBAAAANojXwh5UOCiF NLeyxy4BJ0KBJ9rKNAXBSJnboR0A8HhqyW8Kft7leSAFN28rqwL1tvkGsOu8DO0AbBRauOi5IT+0 ttZlvhd6xsc+76V1O983yVfGAQCAYTmOLBfaM9MH7MNZxh0v9fpP05wAAAAAYNu4cM67BJcN7fdu E7CQ0tsgCBhozoZ2AMDjTUjr8o5OWtdtC8Icai9mrRggVWLfeeh0va7z2LtHAGlw55xLghK+MEXs t6XSNQT1hSEJzb1Ccy3J7hXfyAAAAGwT10JaaO16leIVUtwUKW+de0MAYEf4EYC9M8ZpGIbCsKVW aicWJMTUuYgFiRugzgxcg4VDoN6i6hUYOAIrJ2FACFEBoYWYxo1jnh1HpE3Tfp/0ZLdJ7JcMrRXb /4+pBQAAQHNIg/vrsoum03t1cHD8W18aWKhC3Q6th23KpSmFEo0tkiQ3szD1JFnGfK5WRhZ5X99O +f+H0QQIydcLedZLG3LUtOl5bnuebchRs548i/N0uaFFvh92aSKxyPo2hhZfmaHFwjKbMIYW2pTC NrewjS0+0vI9K3ODi78mGJ+CmcXcyTen19Pi6E9qNDpXk8lEDYfDwjMzhhbavCJJklUYQwtjdoGh RXsxAvmuoYVdGlOLl9msevsqFzX/I25uGVysTC+0qcUahNbrMAJou4j9LrS/C/fQ5PUx7WN6Ut5+ 2+9hE334nlNhJtH8NzjfGUOLbmZAUTCqyOrdLIyhRcc5z9RNe+4Mp/5u0O/H3MphGhequLCwo8IL D+1zpAWIoQnY0LnSYwQAAACAegltfAxtZJRE83T5nMZVGq/rSBYAAABgC3lIY5zGm+e4b2xVZVOk K4AsCRr72nDz8PXdRm6aTgDA4dGqh4QyTFlF5Dw2QqLnbv/Kc0zKF2Bf0QaekugU7Cd3Vr3sd146 J/b3e1ExpPd0sWPLsnsA2FV8hoQA20ZVgeCYY1AN6f2Kjttm0gEAAABohPOIc9y13jFrw32CXj7x rlA7AJqzphMAsNAmydU3pfrn+n2ffXN/ZdeU9QGwC/jmRsaNZQSwXZykcarqEemVzC1i9pe6hMb6 jPuhTmLWatlz73rtyOXm0wQAAIA1MUjjSPnHpL7319I4WKqHxr/SZ7dvKScAgH/xIwB7Z4/TMAyG YVdMDN0QQyfExoTEjAQTO6o4BufoHRArB0EcgYUxB2BiqSrEj63YiWP5L2rSJunzSJ/sxsb+Ggq1 avd9MbUAAADYDaHFu73Yf5BxmxposTgXWuu6QSmYLbRodh3KkMKEa2ZhjCzssPuV8atNLf4qcwsz /1S0tg9bSL57yLM7xpCjYSy5jiHPMeSo6C7P5hkl19CinMcYWqjyp1GWphal6YQysajjuzKwsM0s zOM6bGOLsp8xt2gaZcQNLZSW82ZTiOXyTqxWK/l+vWjcp5ShhWpXYfqP4TUAfox5hWtoobBNLb7W 63YD24Lmpm7MK6xrM21kMdNzdm1q0YWRAEL/0x9/6L/jKdzjvsfnOQxnjlb99c9UDhCWgYVdGqOK I+eabW7RMLQQTZeJag7d91S+t13N5zkpXss4FrVZhTu0L9xDh6E+vs1ZkSjdG8yGLAAAAEC3xIRL cwRT3UP77zLuBcYWAAAAMH2eZTwF2toISeQK1eeIE4fGt9vc/MbImYzLfScBYKEMbkLCND5Rc1+f kKjGtv8XYtdDeQBAifp7KPadBAyCDxlvkfbYeqvNOi9mTpQysogZn/nyEU7dfR4AU6bYdwIAGeSc gckV9Go7FqR5FeV+GAAAAMAhcKIjtf70iXD5+oTOjPvqoTFZv4IP9g5hSHxa9Zw9udBnszmf56b2 /tqQ2ksEGCpt9uQLGS99JwQwEm6suk9oN/R90Nh3RX1ivjkCv7H1P8C2xNZQbt08dvfk1Z7AY18J AgAAwM650GXMYMLX3nW48wIA9MK/AOydP07DMBSHDUVCQqIjYuEOSDBzFrgBEmOF1IkLsHACxIDE GeAAjIhLMFQs0Io/dRO3L+bFcWlIY/p90pMdx3FeMqRO/fJ+iFoAAAAsB22yf1J10NXVrel2dyf1 TMDCFOrSrPCEKzOBC6MKW4xGM3ELWc/6mamghTWZZHtW1nND2kAqScTxs15S8DMFHx0p+dl2X1Pw 0bKYn8U1uZ+CFsa4b2azc0hBiw9FdGI0EaTIhCnec2GKoSdsYcs3RcximPd1ghijqUDGTNBCZ2vr 0wwGT6bXOzP9ft9s50mdfTELzew+a1LQAtLHilhoJgUuXl4j8y9K4Qq37e1fy0UsJma8JOj+8QuA kED7xRpizrHK46d+j1P3342f+jU0cY7Y+1RYpXTiRnnbuhNYykUpOqLsCJELJ2axIdu8flNxCzFe Ifpv3La3uRlzad2xHZlikGHHhAUrZJ95gg1NRV/tNgIAAADA31IWqB+TgM+ZDdo/bsZdAAAAgMax iujnY3so2a8llZg3uXFswmMtuXGVLyFSWQQ9XbYDAB6Poh6bMCaUXLwsOXnV8yDmWeL7E/t8AFgF tN/N+yX5Au3iTtRD862YPtrzXBOqKJvrfSlt8wiglfkIAADtpo54GWJu4gm9wzkuG/IFAAAAoA0c Km2h2O46knz5Y8WcF1aX/WU7AODx/ItjtDVDua+sn1+G1gdDMQUA/4VQ7LNru2jaKYCWYr8f3THl iXWrxCnkd6RlYhZauz++JLTNOwDUhTbPionjuh7bTUM+AgAAwN9y4G3HzokXFa8I/d/tz32Z/wJA bXwLwN4ZIzUOQ2H4sRtmZza09FBCxQW2pKfgCuloOAsFB+AqDB07Q0cJDA0zcAIvGazIioXyZMmb GOPk+2beyFYU6SWBIGzp/zG1AAAA6J7YBN6f3J+UcZzqaH//cGZOEWJFsKUSz67DGFK4CM0sfPMK Z2jht6vNLGTelzPGcOOtK0MRFSfP1TKEPIeQo2EoeRqGkOsQcjS0y3Nx7ZN9br031p5PZyYWtZHF VDGzKLzSmVEUnnmFM7Pw47PRhTWzKOZmFn6fIv+q8XXG43d5efkrl5cXMplM5Fcl6GxMKlw4U4ui KObhG1q4924InzOk0cws/PrRaDQ7f3570zvINaGoRMXt4dbCY+KMLlZgarEKEXqE/vvvfx1eQ5/P z+m/65/zrvnun+GmjLFs/z8qAyV/VZ4zq/BLZ1TxM6gbOTOL0NBCPIcJZ27hDC7Kcnd7W452dnJS /FPGb6nNKvyuYxEuOIy1CduGm4u0UrtB27QJCgAAAADa0bRRMbXxURPVM+V1Gecd5QsAAADQF09i 5ziPkcebRI1TQsPLCha3FbUP82yq+26c9J0AgMdrGbcZ7TQRmv/5rsj5/dbOm/II22jnAJvKXd8J QO/cS1qALEc4LHYNLWcuGDO4aDP/S80F+d4HAAAN1uFYwr+ZJq7EXicCAAAA2AQOIvW5grOaeFdY Ngl25QrepuphfdnrOwGAgNcWbXPWbrrj2P3G8NpvaoxUPcA6EFsPY+JB7BpnABA59Y6bhHdjhhaa uYVmZhG218bT/g8AWBWpdZKx+/vh/fizMm46zRQAAAC+AmNqMZa4XkmuwYU2L841twivk4sszolF aQMA0JoPAdg7f5yGYSgOG4WhAqkSC2LjCggxc4aegANwBlbOwYS4AEOPwcIhgKUTgkr8iSkv2Jb9 bJTQNOH7JMuO82K/pGrqxvH7IWoBAACwfmKD+PPcQVdXt2Y6PfgqrwQsjFd2kxWfkFyEKWLCFlbI whe3+Cm/vZlG3OKnr48mFwGNMTOUAOP42S1D8HMIPlqG4qdlCL4OwUdL3k9/Ds63f2/qVrkIXIiY hQhahMIWyyb5QhUibPHqCFxILmIXS2fbFbSQfuKCFlW1ZXZ3X+r80cznczObzZrzt0IWNk+JWYig hYheDOWzhTwS1F4ELGS7qiov4P1kMjEPi0VJg17bxk1hvdjHBC5anlPb4wn0r7e96QHyS9rf5Gs0 lmv81+1zDpvTx6+PcXIRUvJmHUWAwphGnEKEKkTkQsQstt26wK4pi5BF2Hddf1j/vhWwV6dT479I WBldsMK1KZ14Ffc029hlDOsAAAAAoD3ai/qpQKipwHuS3xiELQAAAGA82AXtF3V6TuwvGTOVBjgO x1batjYuywW2CH1MsUmTpHbC97BvJwActGAXJcHDtYDjJf+7cveUVFspfwHA565vB6B3rp2yFlxM swnvxZpoWWzsVzLeS937Y3C/BwAYF20CGvDeTR7t9/RynY4AAAAA9MhxnXYS+1IBucKyax/mpceG bcT8gP/JUd8OAAQ8Fdppz3K1ucSwPmcXa5vnxDA2tHn52PeC5zoAK+z60X1Tvt7TFawIyyWBfnPr R02kjrWk0BW5d7hS9uHc/lmd7jv3DgAAANbNyXeuCUzE9nedwn4BADrnUwD2zmCnjRgIwwbCSq24 9sqRMxLKsVL7BjwIT1T1xAnlMeAluLYnbiB66CElsK7XMJl41g5sCE6+Txp51/auZzdK1rG98yNq AQAAsFr6FrfEMq8w/T13osPDo//iFJoQCNs9i0xEi4IUKTGLeSGLIG4h63mLYhghKPdjJ5AR29Tt b/b8ci3XiJ/DUoOfNfjoqcVPTw1+1uCjJ/25z8/BheKYJwUtZp2YxINIgzn3TwhPTDvxiqkQp4hC FYtpLIvCFv64FyELaUHUIvi0yGi045rmT/ts/uwmk4kbj8dz1+yFKrxoRRS10BbFLGbdg7WWzxTK kKIWUtxCilw0TeNu7u7c1KuI9ZxH7KTLd3cX81LiF68Mwj6EoMUqqT2Afe2CHDWcv/Z7/FFFFJY9 f+3X8B5tDHGf5PE73b5clRfFKmQahSr2VN5ICFhoQYs5i7536Zf9fXd8cFDi7tfWPrkXsQq52NAy vUDRqqPrpl5Q0qn1UpOGSVsAAACA12MFWI1pic2UXTiELQAAAKBu/rb2s7UfRnkqIMQyfScreHEq mLEOYKz7XrnAxpa/qWv6qJyu2wEAxZXYzn13lgkukwpybv2GlFqfL7oMAAK/1u0ArBUvXPQ7U2fZ /l/JeFpf39ASxCh9Jmi/9TYAAGwWpWttSsu3Ceu/ksw/d/m+AgAAAMCmcNKlOfEIaw14X+AvKy+V nwt4C9vJt3U7AKC4TuT1jdHqvL4xW2t9Qq4NxoFhG+kb37l0YR4IAEIsrchbgvGWvG8qt632JPT1 YZXk1nBZc/u3rZ21dv/O/gIAAMCwnKj9knHrIcQrrD6vNTYOAPBmngRg73xyEgaiODwJJvxx48K4 1h1LF6414QTewIVn4RYkHMGNJ/AKLjiDCWsTwKAd2kenw8x0CsVa/L7kpY/yOn00CtOZ6fshagEA APC7uDryz2UHTaevajC43PipgIUq+KalQhQqE6FIxShcwhZayKIobpH7ur6yCFvk5/q2tsUc21S0 fl/a8hnJs17akGcbctSQZ320IUchz7W4TikXtMiffU0FLNZZvAhafGWCFuut2EQuaKHFLExxC1PY YpGJV+RiFqkvYhZLw4piFql4hvv6dru66PSHGo1u1WQyUcPhcPs5TTGL1Wq1seVyuTHti6iFxMgx co2w0zHBFLPQiN/r9dTbbKY+FwsJ3Mbv4BC3EPGKHRELibH32e2UUHdx9bo5hSL5bSiQH3OOY7b9 l/8GpX1ET5pvn+uU/dbI74PRXmGGMYvRfsfYdgyRCxGzODP3GXGFeGnXOo8+5qbfj0n7IrEHVVxE 2FFhwQozxl5sWDYJG4rdXkpra/sAAAAAUC+uhyT3KcqHsAUAAAC0lXliY5U+zO7CVRzCt8/VT3IV IPYVLw6JXtgFkWOKGdsTrWWv/wJ6zPKp6SQADHRBmrnnPdd9lP1+zPdEVeGKWHPlAgC7SFEb+J+8 GH7VvlJorKzsez5G5MLXv/ON58XmDQAAAG5893jjBnIBAAAAaII763VIXMK13tuOq1IYzNcGgHDd dAIABvuKH/rWG/jm+ELz/7572FA7AKdAzP+BuY9xHYCU+8SulLuYbkiUIiRgcUhh39AzpbYPUBVX v8fXx/LN82t7T+zxqJkCAADAsdGiFufq8HFsX585pg/sq53iywkAYC9+BGDv7HEahsEAatEOHbox ViobEhtiRmLhAgwcoCfgAuy9BysLh2BG4gZco0MFdd2vcVz/NSQkLu9JVto0sb8kSuLm53tILQAA ALoj1FG3O/YPm3Kfqmg+v9zKKVxM4mS1S4pdFS2kkOLKLOoiCyO3sKcTmYVIMcx3tW8/lUO9pETr TSllGYmzXUqIs4QYNcTZHiXEaLDj/N6dS6r7bGY5RGihh+va0EgtjHRCSyyqoscZgYUts5DvVbHF FmY6kVtIXTlCi8lEqdXqSy0Wj2q5XKrZbLbfBlpOIVILkVfYIguRWch05Ww7OBYtrhiNRtsiEgs9 tOUWWmrRCF8Cd1tw4Rnv/S3axO+Tq5ec6P8v4h96gvyc+oe8jU9lHXdd/yksQ9eUsJ588x/ILJSq 3ak8s6QVW0uECCuccWNHZmELMGpl1460dz4eq+vpNCf8202ZqHyhRc7DiT7hhXx2V8/B6gqsShdu ygIAAAA0J5agL/TipJtQz5dwT4stXrsJGQAAAKATPjblWYWTTsSSQ6SSyef0n0Lj14FpUi9SxhIf +5ZliPAiKAyNd+tz6qVnd/wxx46cBOjH7uND398B+sbedz77DAR6402FxUVCbt9P4x6/fcf2nGO8 T2wRkqTlnAM4HwAA9M9VT+2GnsHhmZtDYv/tXlTzhKUAAAAAJXGjTIIvm5S8QoY5ibtSdSjPdDG5 Bf3a/8VF3wEAWNjXlUP3D3Ov0cbmd69Pu/O441OU9NwAwDG4+4ddtNie6zoAhrvd0Nf3jiXt9f2W I7zw1UvyXuiDVL/M1++S+/pabPHUaXQAAADQNSJzjgkmfL+3Xdx2AQBa5UcA9s4fp2EYisMuRZXa oRISO4fgAqychBUpEkt3JgZu0I0TsHAIJCQOwkahVVTipm5d99lOQto07fdJVhzn2Xnun8S10/dD 1AIAAGB/SAP7u1il8fhVDQaXi3wuYKE28nbSwhNma4QpJGELLWSxKW6xzqepWglbrM81d7bxzp5C sO629BE/66UNfrbBRw1+1sdh+7j2SwtU6PuLva6Wu20ELfSOLWSRWmITJs0WghS5MMXvUthiuhKz MOIV8/mPIGYxXdoaQYyZ03bq7UW/P1dfX59qNEpUkiRqOBx6BS20mIWddLkRtDjs9wrqwARBt8Us jKCFKev1egvbSfb5iDS2ke9I5fa+trHOtZhhzvaLClvsIrh6ndB+vP1j6EOT9Yu0j+hJvP2292Ef 56jjdXLrd4RjWwIXy3tD19raYhVGzOLcEbxwBTBCT/tp26ti4k0XKn8o0W6uiLhFV8niFbHF1pCt +zJKZQAAAABQD6FgrL4/LsaC6OmtfmgfYQsAAABoAzqI8XOWvoVjUjCHWCDjooIVPvGKMnWlMZkU sKKNi6H3TTsAYDHJ0nsBO991QiqrkkIB0EN+KMHGVwZwSkjfgY+9ewFNo6/xb9Z+aBwVm0fzXbuL jAdjY72yYz6u8QAApwvP2NSHdL99aMIRAAAAgAa4FsokkQmfGEVM0OI/Ab1CQXDhuLlp2gEAhyoB 8kPzvKE1Pmku2rWVjrttAxwTvnUR33fgceceAbSDW5WL2MX+/3nm5EPCFaH6tq0h9FtBBfIAZamy xu9b93/J0tOO/QUAAIDd4c55l5m3rpKU2h7nqsAx5rwBoBb+BGDv3HUahqEwbKmqKipWVsTECkhs jGyMvEOfBYkdqTsbAwPPwMrAa3RkQKIgil3H7YkbX9Im9PZ90lFujn1cqYkbp/+PqQUAAEA7hAbr ciB/q+M6VdHx8enUnELiBLGtmcWkMLCwYQwpXPhmFmUjC2tuIcs5MwtnimG31az9ZTS490G8e1v6 SJ7Nsg15bkOOBvJsjs3KcfH9JJvbRBhW2Dk1a2Jh9VOcoYVSvpGFW9owphRz84qxMK/4KmI8W1oD jHFxzreox9Zp2/qt6IOl3/9Ro9GbGg4f1GAwUL1eT9yLJzMzC9/Qwmw7QwtZHnYfaWzhhMWlsUW3 253u+/is0iuaVVKqb2G/WUpR9GK7tJ4pmL6quDpC/7tff9tttCHw3zS7UD992Jw2Vj0/VUdpZrEw oSi90SeMLKRZRUfNzS26+r7lDC06atEAoxQur2J5pO9z54eHOd250nGgymYVqYi9nCjL+GWr/sS0 8HEFPkofJmgBAAAAmqOuaLMvrIqxBQAAAGwLRsD4Tsdz4HhKMCImWuyPk3INLXxzi5DZRUrcOHRM 9sFf3yROdJytOwkAgTG0CE0k5wjChMRpUr+zcr/ToQjlAQBh3tedAPw7xtDCXeND18iQIFjq+p0z ZqsaN9a5F+SO9bj+AwBsHnUFCWIiXrF66oh/7fP7N7HfdvJ++6Lj9b+SAgAAAFgjl2I9JawVE+ry 1/3yIeGuHHFb2D8u1p0AgEcdU4vY8+fUc93Y/F+sjarnxgD7hD+P8qiWM6MB2DX6Om6K9Rzx3pCB Reh/o7Fzqo75MOaHpgmNr+S+qnn5qvn5ex1PLecLAAAA7WBMLZy5m0/MkCI2ns0xe/PrUqqcA+Ni AGiUPwHYO3uchmEwDJukQ9UV9t6BE7Ay9hYMDHAHxEl6gI5IjBwCVmaYWAqIBuKmbhzLf23zQ9Ln kT7ZsR37S4oaU8ffi6gFAABAO9gm7Fehk+bzRzGZnK3zhYCFqORLYYtCeEKlSpjCJmwhhSyq4hZl frUSW3GLcqxfI93vBhxDEO++BCvHz3rpg5998FGCn/XRvY/VdbWqP5lWluXPqyI2ihKzKOxHS5V9 b60qVKGELb40gQuV6mIX6lgXtFDj2AUtkkQKWnyK0ehNLBYLMZvNiivaXE+WP2yVaIUuaKEELmS5 bCOt+88E2mIdPDz/49EtTdNtuR6M/GO5DPalHYQGLtvYhC4cfSAkgCBHTP9N36NDzx/CPe5z/22M MYRrqGOMWDELvW1l5XEjQiHzqZbqYhUjdawJXajjxGifqn6NcWTb6Xgcc0mnuV2I6kuFMeIWqXC/ hOhbgPW1NW8jG5IAAAAAmiNmM2Mo8J4ZfE8ZwhYAAADwH3nJ7Ta3Z0e9LyjwPnOizFHnEq2IEbOw iYrpGylNv0PXZea75KZrBwAMnrS8SyzCVmYLNB4TmNwMaB4TDN0VyCYmwA0AlCBqcVy8i0LUwoVv HuX6ft91jmj7nveJW5hj+3wFAIBhYnuPBurF9yyVdXdtOQIAAADQIeeiCHbrmnf6BClsbXaxmLFs bWD4TLt2AMDg1VLmW0sM/b8ZWgMM1bn6BRgytvecbXWK+2bdAegNl6IM6Osz295PfU/piZEmnnN8 e0Z9e0rNPMChxKyt+9b7r3N7aNJBAAAAaAwl5uwTmLDVH/Jbt68cAKB2/gRg74xxGoahAOpKbYSQ OrJV6sAFEMxFYmVi4BxciqkbAyfgCEhIzMywUImlgIibmDg/du22aZO070lWmtqxvyukunH4D6kF AABA/YQenNHcpuUq1NFodLqQU9jYcgkjsNASCnM0RcosyiKLTG5htzN9ZHIMc67+x68jD/ehJPTu yjyJs166EGcXYtQQZ300E2N5Xy0b3rxXCC2MyELnSNFii0IwoXOmfFviiXkur5hbcgojqqgeTZ0R W+jrCpFFVWqRxVSl3++pJPlU4/Gxmk6najKZZDMSQgtbZmELLYzM4jf/Im373wrUixRYyKT7SZIs jh+zWVRf4o1yMW18QgsptrD6RWjR/f73YQ5NXh/TP9KTcP9dn8Muxtj0c1rn+tKuYy6hKD3JZ4ks jKyir2VMlsyiJLhQVQGGkWSYPnq5KEMfTwYDdT4cxoSqF1lHqiyrCBXXQ4muNrKt3HR1HeUHvewe DwAAAACsT0wivNgkqjLhnk5KjNgCAAAA2sKDyv5J/ctR50r6EEoM4Us4LGUTP55jqN4luJDJjmMS 3ttzajs3TQcAYKETnr9GtPMlOffVh35HxRbXOLJetnGdA0DBc9MBwM7Q60KzJoxJ+BW7TnStBUOy M5/gIvZ7whfrsrkBAABAGNfvq6e0PDYTDgAAAMBOubReL0u2tUmCr5g+5Fiua+AwOGs6AADBu+f9 0B5dzD6+63607MM3nqx3XQOw7/j2cu7T8tZUUAAtQgvsrvPXsWt5l7DCJbBYpd63pmedD3UTWm+t Wu7S8rLdkAEAAGALXIjzWAlFHUWOqxx13PMGgI35E4C9M8ZtG4bC8EM8aOjQXiDo7DVXyNKOPUSu 0Cv0EgaydCwy9QbtAToVvUOHokuDBrVbsdYL6YdHUoIl23K+D3gQ9ShRTwLkMCT1fkQtAAAApsfr tN/UTrq9/ShN8+J/OeTB1lzYWk7FLVTgIopTiCtsEYQsdsUtYnm9jufHa/012z2fhMR2n0Jy77nc J3GOyxzinEOMAeIcj8PFuLseKQpaxG9ct0IWmy6edbcfBS1SwQkVoNhsUnGLVNjidydeEcUstmUV s3hILG33Tyee4T+TpgmCBN/l+vpKVquVLJfL7R0lYhY5QQutQ9Di6aKCFql5vsDPX17+osKIr5fQ PPE9ilt4whYmxn0g0X+97TnHr+2f+jM6h2c8dfvcw+lc45Dn78wiqvhRUqdCFKG86LZBzGIR/j51 PhWwSAUudP/xGC1ru+Y64djLpukT8nPZfoSULjTsI26xEF+8ojb5WjrWPkbPBwAAAADjUfqQMZe0 zyZSziXoC8IWH6YKHAAAAKAH9629a+0uU2/7OZ7PJhTOCUzkzBOqWDt+T8hiSLJjL1FFKenFKREE LV4eOwiAhM+FulrCmPSYmtl3e8i7bq9TihcAyoT35Muxg4CDEJKNfSrU7/ObbsfNSn7v9z4nmlbq o4rxAQDA+VBaH1NK8AvD8ebJ7L763k4fDgAAAMDReeX4aiITuu27jnxIvRhfLTY4PxC1gFPiW6W+ 7zhtbvzZ1omUx4O9sWEvBq99gLlTmifxyu8njwhgHrxu7ZnU++05MYsLU/bMnuP190X8/wVE6OPD uJTWUmq5NL+frt380dqb1r5OGzIAAACMTBC10D6wJTc+7dVdZMpDxroZ8waASfgnAHvnrxo3EMTh tc+GIxjSJNWBcRVIlyLuXKUPBNL5LULeIfcC7pxnCqRKm/QhBOPGwZisvJq71XhH2rOk0y3+Phh2 b7V/RsJ3WmtX80PUAgAAYFisSXk8if/o7V1XR8fHr1wdC3tFLC5RHbu7ExGLpgWxirR4hYhbxKIX 6z7CGCKMIeOPFYu7hEDwQ1DKeeLnsJTgZwk+VuDncIzrY3MNTQtahLFF0CLERonTSmQiCFHc3qfB buuyIGARi1ms7V8kZrH+vM5LP3mCFvO5czc3P935+Xu3XC7dYrFYXTcRqhBBCzERtBBRC6lXwt8E jIMESdfCFmKz2ey+3p/ra90wHbxcl+s6SsRiL06jcvGt77mNSekB7Mf2fxtj7Hr/JYgQdPVdsv/S f+nnsI0xdkG8pbHiWItQNHbyKXGKlVhFnR74soO4zDUFLfblfhcJXuzVQhlV+vLw0L05Ospx9czb 3DXFKrpMb0q06qQWafXleXC5jEupYWEWAAAAoD/Wi4ypND5uBeSLrRK2+DywvwAAAAA5fPP2ydsP 47j1kqKkucHoNzUtbmGV5QhdtAW4t4Ib7+LC6YepHQBQxAHPu74zud/DTYOi51qbL/oYAARSwZ6+ T+QLbJfLKG8F+rKCHuk61twwZ56YapP6nPO7n4LffACAcumzB4b9M/1pu9dW+V/evmzPHQAAKJRK UPHr1E4A9OCFt9eJ8k2EKdqC1A4R1AueDifenk/tBEDE7yif83zWWi/Ued3Wel6t27f5AfBUsdZy LrxdTeUUwA7xzNtpnc+d21vvkXa1yfmfQZP7PinAY7H2iuo6lv11QdiCewoAAEBZvK3TtmfR8fG+ ZvWlxwUAGIT/ArB3xrptw0AYPiuFgRgIEKCZ075D9ix5gyCDhwJd+wx9gQABOnToGyRDpkwZgkx5 gywBMmc3iiJDgTSxQ1o863wmKRmmJUv9P+AgiqTIk2FJB5Hi/6FpBwAAAICO4wviv5UddH5+S4PB nhOZoJmoBKeluAULXOTiFDQTqchFKwpxCytkERK6kMcVfU3UdvUfIwT3UcfCpU3SlvOEn2lpg59t 8NECP9OR1sfFsbJFQQsi/vY17/vNCT68uTTb63Q/F7JgYyEKFqt4cWkWu/gn9l9mx+UiFnw8t/3q hDT8DAZjGo0e6OzslIbDIfX7fa+ghTUtZMHG9SFm8f/iu76koIUUtRg9P5OoNJfuibaCqD4mcj/L pvvsBwtdrBLUQQyi2+3X0UfTC/x3vf06+ujCOdTRR9P/9ekzRLRlnyec13N5Wy7fPpFsdGS3NjLL bJ4pG1vBSxa8cAIXY7Odq2PzRBs90fd0BqCp82l7m+61iNMiH40dGbumYuIgNxsTrdiiYpGVTLkR G4iVdUltJyrtywMAAAAAAOtDxmBV4i8ZD3KascdfuvSPtG4CAAAAAAS5MHYTKIt9mBhbTEIuNqzT VRcwLhOu0GndZuyDybJFM3zlm/CebdfY16adAEDwSPML0kh8C8fo8tj9I7ZgeZVrfJl7QOy+AABY BKIW3efRWYxQTFhmVYQpYuJkVcUsYnn6HAAAALQD3xiMzltlAtPmTqLfLHg8zJen5yv9MvbF2H5t 3gEAAGgTf439bNoJABJwSIVovC9erbIIl29OuS+P1FbaRJWH9kF3+dy0AwAonpao6xu7C6X1O1+9 DbVVpQ4AXUa+0/HFCTL9h3Jhi++1eQfA5nJi7I7mr5PQN6CZqKdjei6TY56hY+S+TGv0+1gAUlA2 BhD6v8lYS34f89vYsbErYztJPQUAAADAujigPAZmdBwsY9TUJpF9EeGdNwAgEe8CsHfuuG0DQQDd MDFgIEgXF65yBR/AQXyFFKmVO6RIk2sE8C1yCddufAK7cxckTWBBQjjcXXu02h8tyqSk94ABV/ws h7I+K5qc14ydAAAAwB6RuvBaD/C/tHFR6uj09EMnqtBouYQsWy6thEKmOqzM4ilEZjGfr8ot/Dpe ZGG3tfuwj83j/l+yJvehFAHflWPclb8HeQ7HLuQokOdwbJ7j+vVGtr+ne17t42Unk7BCiYVre6GF l1ZYAcWq0ELkFCKu+NdNrcTiwc3T7YdumZdbrEsx5qYstFiY+/trc3n508xms05o4Z8jLbQQiYUX WoRiC4QWIGiJRNM0Xfi2nievsUepRa54eSC78MKLteV6Gmwj+8vuo+KYEFrk+556gfya/qf8HO3L c7zt/jmG6exjzO2T/bq+OxuE+y7x9ghtiHjthBeNm4rM4o3abmUd35dbv3HztMjp5OjInL2ruj7q vI1jlUpOZuFDX2CYWydcN3YjUjiN/aM2BjfhAwAAAGxO6cZH384V7ssV5ROxxbct5Q4AAADgkSIS P0xZaJEqClEqPhwb98SEFDmZxaLQ1kILLbYI8wkLKKeKH8eOf0p8HTsBgIAr1e7zPkoVFS/9jqp5 L8eKl6d+swHA80Bqsf/8Uu2a4l65c2Wp82K5cWRqnNnns7+UIwBY+EyHQyBXPBg2I/e9K/G7je8v mhEAAOwSIty+M/0KXgNMkY9tnLh2SV4RK3rbJJY9p8DXq8xjPR/2k4uxEwAIuO25fqk4cmpen/PE pb4BDpHUe0mkFn/GSgpgQrxv45NZH+vHxvbhOD9sx34L1I77a+8TZbwPQ9Bn7FUTN218buPvthMH AACAQRCpxVtTd47bmPQ4OVYvpWbcmxoHc84bAAbhvwDsnUtOwzAQhqekUoEFKw4AOw7AIdgWcQC4 A2fgGlwBCaQegDWsOQJiRVc8hICaZFrbsmO3BIrp90mjOM7EmUbKo7YzP6IWAAAAP0fo5fwktdP5 +ZVsbGx/lU1ObM2LrWVb3EIFLmpxCpmKVNiiFb64hS1wUfvM9psd68NbfvNMzMkqJAQv6TeWEitx dkcJMRqIszsWi9EdP3PbeJ/W1UsVuKjFLGpBCxWzsO11aipYMRO2eJk8q54bgQvjo8tXS+xC121B i7fmmGFBi6rqyebms/T7DzIajWQ4HDrPQV/MwjZTb8z4IGgBNipcoVZVlZPg2zAYDOR+PM4Xm/D8 pm15IhZOnfFRQYsFk6T/9eTvOe0jyFF2+6Wf4xJEFHLaL/03/MYxujhPXcbojDSq4FJT7lllFa/o WWIWX6oSjYDFmuXTD/loWdsUdxTUbN9dX88JeUvqSYn2JMIccYtKwuIVqUHYNt/QafTrAAAAAKBb 2hL6zTNpP5bE2QhbnP5Q7AAAAABGyOJMwsmiUgngF33H8YUsfJGKNstp40NcYYvcxPehDy9D5+Qv cLzsAAAsniZ2k+GXk1BGr9uce0vsXhO7tmNxSMAnVgcALiY5MQkn/y+3E7tL+OS8F4bu2aF7eKqP LCaWNo/5cftlgFXmcdkBAHjsLTsAWJjYs/dSXEFEAAAAw8XErq11+hmgdA689bZktyLh+d+5ltMu ib1Wk51lBwDgEZuL4K/H+mrbfHPH+2M+sWMA/HdC10ds21jqfh0AEDmSdMLeVLJe//vS3P1S/wsA foPY/KrQfAB/bF/NCFscCsIWAAAApbDfLNsEJuztqffk7/Z7AwB0xqcA7J0xbtswFEDppjbQAJna OenUNQEKeErRqXtP0dwke85gZM5Veo1saYcWSBChZCVK9PcnRceyZTrvAR+URYn6SmKbsJn/kFoA AAAMQ2yiHk7mv9v41jfQ6emnFYlEKJdwEouqqiUUrg0jlFh4kUUnsKha0YUXW3Rj1NeoH9fX8Ncb k9dQHLykeywlV/IcjhJydJDncOTnuLyeoj7F7wuFFlUjk3gO2ue27aQTT20syym82GK5raMTW1TV UzDGqtSizmkVJ7SYTn+Zs7Njs1gszHw+b+/fiSq80EKTWrjHCC0gxv8i4Y3QwhcSD+UWbns2m5n7 hwfz9/HRn5QasGvF9kTua9pJKLSQ46xxH9viEIrkl1AgP+ca2xx7nwr8x8YvWXpS+t+IH/9QhBab nr+rn/WkkVD4NrRBeENEK6vwMgu7760/vpFdhEKLN4EU46h575uY7ufyfjo1FycnOWle2nhnlmUV fRFbjCiPkcdqix9lK38pqc9+AAAAAGBz+v5xMtyXKu6XElv8MCzeBwAAgOFwRehvbNza+KP0x4q+ p4rOa8WIY3OcHEmFdkxsnzxXy6GvuLG8b6P07wMXNs7HTgIgwAkttNcRR05BmFixmU2jb5xYHgCQ j3vO/Bw7Cdgat8H2Swp8aa/Hcr4o55I50oo+mUUqP17nAQDKYldrWrSCC5BH3xxBvk9f2fi9g7wA AKAMnOzortn27xVILaB0vtg4Nuk5Zm5RL239eG6Rr9T1tD44LD6OnQBAgFuXkPs9ouyT393lrtGU 58sxtGO0foDXSOw5dD1aRgD7xQcbX816RXlzJBap/r5ivnKbz7thaHLmYNo5qUBsAQAAUA6fxeOc z6fXFbWl5r7hdY3Spx0LAJDFPwHYO3+chmEoDptCEYgNsXODDlyAgYkZxMzKyH0qToGEuAQSEuwg JiQOwJ8WqLHdvLp27KhNQ9rvk57i2o39UimJmzy/H6IWAAAA9RCaoF+kdrq6ulbb23t/ZZ0X2+XG dmUpbuEELrQQxXCoxoIVTthCClwYcYtia9rdvkbcohjrx9vO+EvMgVVIFN6mY2yTn23wtQ1+tsFH DX7Oj3IfJ+OLCkELbUO7r1kTa/pwghYDK2QhxSykfVlxikLMwghWvNvyuxWy+BBthfhFIWYx2W/s Pd7mphYWeFVHRweq3++rXq83Pm4naKGFK2JiFk7QQopaAEjGicOtuIU2jdt2u131+PKiPgcDf8ec zqc/i4ToY6ELT+Siqu910fYk+QgJ5PU/6/7L8Bu3uf9FjLGoY/jvx1HruWi3HXmPEG1rdnwnXuGE KTpWrGLdClh0bN2GtanviLrQm07dtr+1lePyrjJBiTKAMEfcYl2FxStSL2BTi5P8n8yvAwAAAIDF kFo0mUrC59p1YuabkZ0pgvcBAABgdu5GdqlMInqf2KJDfx4jy3LeEktGHBPvGkasqrjFd2LsVNLj UHKK1OemOG/aAQCPW1EOnSexurJzMed/kn+u51jMDwDIIzQfuG/IF6gXnVj0LfGdsut37jOv2BzR v86H5nq5Y/nX+lgZAACWg3nGxRBjU42c5yjPiiSIAABg0OIVTkxR3jOeG/AFYJ5oQYvjSFsoyZcs V7VQLLnfnxwbVofDph0AEMh7e867utTC8LJnvqE4h1S/MWJxEwDLRG5MjK5/UpNi6ACrzKmaXrNZ Zc6eI2JRNQmw9AWgDsrmV1XivaQ9jOxEsTYGAADgv6NFLXZUeL5ZNi8tm+NWEXPzn3X7Y4fqAQCy +BWAvbPHbRuGAvAr0DjokK1ZvGTL0ClDx0yduuUAWXobr116jh6mS8agh2gaFRXqZ4oxSfPnJXZj y/o+gKAo0RTlAA5FUe9DagEAALA9pQF4OGDXScBPrYYuLi43JBKhXEIlFn3vhBWap8kLK9YCi34o 95HoIsxVbuECd/dD+/J0vkNjCkHDx3KNY+mnMpa+jqGfY+ijQj93x2Yf4+1YaNEPZS+0cLFQwjwW Wvx5Sk5Q8bgSVjihxVpesc79vi6qtxZcaDuh0OJv8bpOT0W67l5ub29ksVjIfD6Prlf/L6q0Iie0 8FILhBZQI5VZpEILzWez2Wr7d9e1GouLhf2+/EbPkZNbGIOmH3rw9ym0fwzXsM/PW9pHetJuf+zX 8Brn2MX39JrfQ/TkcRBS+Dy0QXhDRCiq0PztsG9VZ5BdREKL8PNe7BSc//zkRK7Ozixdvl6mdxLL KlqptCAxrZN7UCuNPP0j1eaAAAAAAGB7Si941V6aTIP4pQv20/26eB+xBQAAALyUB3EvmX9dpl+Z 47lA1daXDmtBiXNCilKdkuSiJbKwCi18Obxm64v6h8KXfXcAIEADnv8sHCsFkyndG4XHW0HQrSl3 nlaA81wZAMogtTg+dMz4PSjXfiOtwStKc12WsWROdGH5/bf0FQAApo1lvYxl7Q3rbjap3eN9EyfQ AgCA6aLziQtxzynSe7XSXCPAmPgsTm7RCsK1bUrbE4nHprn6UijD8XC17w4AJNy94DO59Qrpdu5Y mpeeGebmkiVTBpgSrWfqmiMqBXC8X6YP8ryxe01k0XrftHYvIIVtxvvwv7GsybKsAfshiC0AAADG wMchb41HLfPXNWGFpS7jWwDYGf8EYO/sdaMGgji+XHLSpQCEeAEoqVNSUNNR0CFdiXgNpLwALXUo kHiAQKo0qVOAaHmDFBRIIWez49u5nQyzXh/4/JX/Txrtp73jO8fZs9fz3+/bAQAAAGCCWBP217mN jo9P3cHBwyogOBsRy+WNMolPsCgFC1lo0YoobhFTEq9YC1mUG4EMHmsdnDv6NNQY3fxZdBEAtC/G coxj8ZMgX8fiJzFkX8fgIwE/22MtTCF9zAlaUGEVBB9WIc92XZVJhCIKW1xvxC2iqMVvkb8K/a9C P7ktb79yUcyiSB7LYlG6y8uv7ujorVsul5WwAH8HLFTBghYsasFCFhCzANvAwc7ZSMhCBkCfz+dV +ssStaA+dH5xarVzKgQsSilo4fOl8IPzqbMWAeynv/9dj9HGvsf+GY99/12MMYVjaGOMrn0sRV31 uyjUbZ46BgGKvVBPKc2oZr4vCVQUPl0FIYt9Kvu04JT6+vaZELag/rOwDx6D9vN4sXAXP7Nrox54 e+btxMVFg3thqDrRCnaf+xXyEBPmVF+n0lLlrToAAAAAANA+PPfSZT0nY+6IfoScE6YgYYun3j56 e/Kf/gIAAADg9kDBIt67dQB6TS7wrxUoIvfCoU4tAa+UAEbp/havsMQsZL/UuJZf+jj0serPwSr3 xQtv9/t2AgDBl0x70+tLk+uKDmieCmqu++lxLH+sMgCgGRd9OwBa57OLc8bUtXGb4BR1IhSWaEXT /fB2dT5Yvlp5AAAA4+Nf176kFj4NdyH88JHPxuTaJKuNv7c33s693evIRwAAAMOBhBTfOVvQgvje rTsA7AQStHju7ZOo4/Xfer7UJPhtIfKlKOfMWj/uHO6JTJ1HfTsAgMJan5Ci7tmddU9at6We9efa 6uoBmDqpNc+6D/HD2wdvr3bvFgCD56W3byGv59xy7l43z9fPPVN96t4tTb2zAMAuqPufkTr/5Lsx qXdkSNiC/qboN/TdFv0FAAAAQHscejsTZX1/W85buT43n7VipjijLRc3RfqDuTAAYCv+CMDeGeu2 DQNhmDEaGE3RqVOmzkWXIHOnTH2Drh38LO1LFMjSvXMfInvXzh6KoJMRR67OMm3qTFLnWrLC9vuA AyWSOp4FWKZM6f7J2AEAAAAUTu6BbN8mirY3XY4uL1+71artLhSyEBELL0LhBSlC2xeyqLYiFjuh i6olfCHiFjJG47MZQxB/JSTq/h8SipfyGYmzf0qItYQYBeI8ll1MTYxetGL3XmuzX23amnwozbYX tFhuhSuk1KIUVbVYW1vEYtGy1WqxbvPtXuDiEEGLi4ulm8/v3O3tFzebzbaCFmKhmIUIWXjz4hZi CFqAFS1kIaW26XS67vuwXPYy3rpsdlwodtHa9vuJ44fiFP6HFmvgHHX7P/b4f+Ecl+6/9M9Qyhhj x3gW9JkEpVeP8OIUohAhQhRik03p66T9Wf1b1mrbbG9VJvxv4WYM8f3q/NxdvzQ9E/WutuduJ1aR E7MIwz8z9NF9Y2IWutQnlJfzAQAAAIYn9XKlNWlrLFGrtl+1fXAkdAAAAAAb32r75OyCFl3zFUtS 4pgYxWOw/6jqdFusPuU7NbYlUbL+3PqcxPbH5OPYAQAo7oLtru+K5Tpi7Wf1of3pWHNJbQDAxs/a 7scOAnpDkot+z7SnkojputR12Cp0lpvb6f/PYtd5S6wAAACHwHM1h5O7x5M55OeR4gIAgPGQe06/ VpG6T5P6HyeLCGA43tf2IlKvk3FZxS3+1vQ4sThcpB3K5WrsAAAUc2M/y9rdMeuLXb4BYH9dJfYd +nrqoACeKG9qe+v2RShSAhZd83b9/qjlGOfSc3rm+zAUsTX53Fwr7KPX+MNnAbywxe+e4wUAAIB+ EFEL+b87Nq/MzVdDYnlS/LZz8XluzidzXAA4mj8CsHf2uG3DYAAlWhewPTVA1wy5Q/bOnrrkCr1F r5HVNyjgIScIkjVAp+65QTI0SYHaFU19FkXzT45s/eA9gBBFSZ8oJ7EZif4eUgsAAIB28Q3Sv6cO Wi5v1Gz2ZVvXObIlT7bUJXG2lk6I4EKkFCKysGUVdblFtTTbVU2EUZ1r4yzVYJJ2D6Wf72Eo10g/ 22cI/RzK60k/D6E+f0L6Zsq/XZtZiuBiXUom9HaRWdhSi0pKYSQVbzWxxXr9akks3nbyCiOzqNbr cU0JCS10Xuf5/G9RntRqtVKLxcJckSO0CEktdDtCC2iKLbCQZPF2mUwm2/2eX17ygzqiCjvenrzC dKK2vz/ksJPYjyH+GK6hy+Nz4iM96Tb+WM7x3p/1KX5X5Dx7bdayJkKSNlXKLERK4UgqRGgh7Z+0 0ELWVSW6+GDF2ZstWB57Pp2qi9ksdRlnRfmq6hMIc+QWH5VfXpGafBjb1/cyum0AAAAAcBxyEiGn vkiZkltosYW+Wfiz/e4DAADASHgsyg9lpBYuseTvdlvTMUpKbOEKLVzhhSuxiMkvQvE3Tj2V7N63 VIH1LvlclG9ddwLA4kH5ZTkaX8IL3z6x95yQlCaUyDw3WU3sC9YA0Bz99/Or605Aa+hx45+yHks6 Ydeb3N+KjdNiY8zY+3+OvCxWBwCAYdPm/JdULObahMm9n2J/Rl8X5f5oPQIAgL4hQgv93CL1OfH7 JD0COC5zZeb0xCQTucWdK27PP8+JqzzbYbwgtYC+4ZNVuc/mQs8RQ9t8sZrcE+7znACAPhB7tn9b lLvTdgegt1xZdd+4OzaOd0vqmNz/Hdy+AByD1NgtZw6Bby4YYgsAAIB+c1kuU2PP0P1t37G597bd +O65AAAO4r8A7J0xTsMwFECNVFVsTIiRDQkxsnbjBkjsjOycgZ0bcICegEswcgBOAAxICKiIlbr8 mP9tt5A2hvckK4mT2j+RmliN+x9SCwAAgNVJDdjDvtOmnOQa2t8/cHF+bCmX8BKLIKLQyneRxWy+ PROii1lHfOHlFr4Pv9627xb9xdSSwLuWOH9CLedInL9LTXHWQE3Xc7NxducYtaGEuvYdVyt5+JgL LYLIorvsCi3eF4KKVlIR5Bav35Zhf5BdtMe+N+vh828duYU172k02nLj8WPzrN120+nUTSaT9owi oYUms5BCCyn0AMghZRNSbiElF0Fq8fTykmktnaB8IawQwovO8VJsocTYF7Un+q89/tD+0K/RX7jG fbfPOQynj01+vrSP0n4WbybnMoqtSEIRxBRBWBEEF6PmmTIKsgu/LfbJ46TgIvQR+t0bj93O/BmY wQ/atl1XVpErpRMUtYmKLrOML27JS1wAAAAA+DmpRKm5iftakj8rmd9lU276OgkAAACoFp+Q2Ast HpR9WnJ3bb1kjGIlHtbkFKsUTVoR11kJk3MJ7a1lfJ2GwvmmAwCIuBPrqT8sx3VWcpnSPzbnvuta e3E8cbIcAFge+T1CavE38KKi28R+LenXMmNJ7T5uCSxK7/9abFqs3PMBAP4vWkKFPhIbMOfmC+05 bJWLpjyvO0AAANgI165MaOGX92uJCKB//P/zd8W2JpmQ9SmZRSqZrbZPazfGigfqBqkFDAltrkIJ y7xDTB0v67R67XdmfkuG/4j1vsX6nlytIyiACjhsypGzx/Al9daYvlRmEZNK8Mt4H/pilflf1nwB L7Y4c4gtAAAAhshxtK2NPZf9DdzaZ7Ubz/2wYOwLAEV8CsDeGePEEUMB1ChBWugipWe5Qy4QaRsu EaXlAum5x5b0oacDDkAHLSUSBV2IEIExY2f+mP/H3sDOrsN7kmXvrGfmz0rseLHnP6QWAAAAb4c2 CN/P7XR4eOy2tj4/t32e7JgrO7Zj8mwvnYiCiyiliCILKavoyy26un3f9UQY3bkek1qPtZZk3rXE +RpquUbifFtqiLOGGCO1xLqaOPvrIzqhhS8PIabuGdhWNiGFFn+EzEKW+yCjkMIKX9+F9l0QWPzu iS3ifu3r+yCx6I5rrXPa3PRJmq/dbPbFzedzN51O2ysKMotSoYWUWgCUIoUWUnIhi+f69rb0gH/r jVRkIfo8b/EiC0V2IWNbJrUnsB8r+fx7Pn4NEoLcsWuOPx6/9msY4xw1yFtKz9GbkQz901nKKKuI K/akpMILLaKowispPgbphZRfSJlF3K83wxnuU7uTiduZTHIhf2rKV9dfQFgit/jgdHlFbvHhUF/t Y0y3AQAAAMC4LLpw3xJbyETOB035MU74AAAAsOb4xBBeZvFTeW8oeUOsh5LEaw8TpuKJVEChCSos eUXJ+9bYKB03Wckscgku0s9knfi+6gAABL+aclrQrzR5TO67x+qT+7sfiiONRXsNAC/R/k7OR48C lsGRaFvfh9YYMtYl3+G5cd2Q5CL32rrfWNcAAADvh9eskbH2tRKHQUvuXuzrK1fw3BoAAFTPvCmX ruze4LlYekQA4/FN2ZZL2FWawHaRop1LxqO1oU52Vh0AgOBGtLVxQG7eLu1r7W/NEVrzgzlK/s8M 8L+jzaPHctKUs9EjAlhP9kRbS76bjuvTZ0nTPtpvgUV/H6SxACyDkvVWuXVg2nMyvkZsAQAAsJ54 qcV2ss1aM7FI3hMrB8rQsdP+AAD/xJMA7J0/TsMwFIefWtQeAIHULqxIDDDAiNQbsNMD9SJISMxc g4EjgISYu5YSETd26jjPz24a2rj9fZIV50/tlw7EOO77ILUAAAAAmhGzqFpN8E1CDY1GFzWJhC2X UBILI6LgSl1kken9zBJdZBXxhZJbqD5UvWifyv5iSCWxdypxbkMq94g42yWFOFOI0ZBSnLuJtbrm qCq0yPR+puvZSmJhBBdKbJFlSy2uWGoBxY+WUixKYUUhtFiU8or1dlE5Z+rrc6Y908ev9y6GQ8qf ix80nT7QbDaj8Xhc3JEltDDyCk5qAaEF2BaTCN2ILdzS7/dX133P574GaknKS5mFp7+axMIkLe/1 vG22ySEkyU8hQX5MH11uP/XvuCuCgi63fyh9pCJvadpH+abRyCe0cKIipdDCCiW0UNIKu5jzJ9Z+ 5Zzuo2eeh1a/Z4MBnSr7WJh7Kl7M2rKKUPEtUAwtVnRfvnJb98uW5oYAAAAAAEB7SIlU3W0oYWtI bPGSl0fCAn4AAADgmFEiCyW0+GTOcQkbNvnhoJtUWEo87EoqfPUYeYV7vdsWl9Tel/heSmLBfVdd 4iYv1/sOAgCLN+Fckx8uc8c2KTFSjFDSPABAc973HQDYGjV+lGRFUiKwTf5WS+O0kMiC+6wUDzl1 AAAAaXHZQhsxa2CwfqY9uPGCqUvlNS/PO4oRAADA7lFCC/X/pjRHSFR/dkjzjwCkhEr0dUXxiWe5 BLbuVlp/btfJ048Nxr2HxWTfAQDgwK1bCCHN7/rWPBBzndQGN2+MeWRw7ITmddxrn/49IgDS4DYv 5xQvnHCLO86PlVkQs0/Wcd8+xv+gTbjng2+MFnr3764ZMGKLr3+KHQAAAADNuKOwxMI+Jl0njXHd z/jgRBgAABDNnwDsnU1u1DAUgJ8oi2mlEZtuUcVJuuwFOAASG9Z0w6h36abiBmy4QC9ABVwCqRIb NEhT4nFexvHYsSdNZuLh+yQrruOMXyLlp/l5H1ILAACAYQhdiL9PLXR7+0VOT8/XdZMr2ybMfqrr 0iTQNtIJFVyolEJFFq6soi232EztfGmJMDQ390ag8dTEkUspSb5LifM5lLKOxDksJcRZQoyGUuI0 jBfr9rtF3UILbbP5TqzEQsvftXTClraUQv9erf44YovNVPvqsq4Ywx3DxhFmNlvJ4+M3ubm5lsVi IfP5vNluKqow0gqVWSyXS2QWMDgqtHDFFpp8XNuM2OLX77wciZq0vEleHpBXOJ2bviq7WI//Yrzb QKUnsD8W2cSUt9GxbOOxf591mM4Yh1x+rDFaTyL1XOG2SS2hkNoiYaQV5hwm1ihxUssp1jKLavqy ll6o/KKZL44Yw/ltHddMX89mclGVBK+qcintFwhz5BYnsv0BUs6HTF19Q5vRbwMAAACA8Yh9AJl6 aT8neZ+f7PlerNji59ArAQAAAJPGnPs/ipVa+HQlhXLn5yQgTpWQtCImsOgSW+SKLrqSHu+a8Njf LlPj3aEDAPD46tRjCelCbbFk4137cEyq02cfl452AOgPUovy+ezUU/eyUn1yj+Opa7qUtCx1vA/B 8R8A4P+Ad2GmQ+zc6187fKrKw14iAgCAfZISWvh19/+77yPGBbBvPlTlrK6HEtDukuh21yS5Smxc f75fh7J4c+gAADx2kVqk7jmH+sWeEfYZAwC28fc3t9xJP3ENwDHy1qn7CXkNoev5mKAuJK/z+2hd An1yEgkDDEnXPZ/Yewah72NCxTwzuKrKj8GjBgAAgL7497lDhEQTKYFFSmYRutYFAHg2/wRg74xx nAaiADoCNoq2Q0JQbkfLBVY03ABpCzqKNFxkWy6AtNfgDCBRsA1XWIViRbESICLm40wy+f4zYxsn 8Wjfk74mHjvjHxfJKB7/h9QCAACgP6lJeTxhf+3jVWmgs7PnLYlEEFo0AoqtiMKKtshitd5eRaKL 1Y74QuQWUqBbXjfjb887lFqKfteS5/9Qy2ckz3GpIc8achRqyVMYN8/2WqIgWtISi63IQtqmBoq0 sdBC2kZQ0cgpGpnFz7WwIkgsfm369L6wP4gwmnH/bNqc0OL09LdbLr+4q6sPbrFYuNlstiO0iGUW IWQ7BEILGINYZJEKEVrM53N3c3vbZcDdNu63wkXFziOxRev9I1F7Afva8w/nmPL4Uy3w32fsqV/j LuPX/hkOcY4xrlNN12FzhzLIJ2KhxVpm8U9YsRZUPFQR+h4Zx8RCiwdB6BSd95mfoz0+OemS5rmP uduVVZRCL05MHWMtXHSFNnczt0s/AAAAAAyn9EBk6gFLq3ifLvanCz1f+3jj49PYHwIAAAAmx51r ChBf+vhu7LeKN5SKAVsPCup+Pf8YIqrQAgxr3NT5ckWRUwWOcw9L6us1Rd4eOwGACPm+SRWoyBW2 sPbr46z3WQ80l4qal/LQx1jbANCPr8dOAAbzzZUFqan/rnLf0V2kRCXBRW6O1+W3IPe9DwAAAOOT +u0t/XbLYuR3Pn4cJk0AADgAQ4QWoZX4vL/UAA7OE9cudKtfdxVWpAQXuaK31r4Ya904a8nr5MWx EwBQLI2+3Nwg9x9u3/+Ic/cOS/kA3Ff63EuX7cv9pgNQDS99PHX2nNuST6TkFimZRWpOX5rjp+QW zPVhn5TWFei+3PoBWTMq9w4uHGILAACAYyPPrLz38THq07VMnLEvRW6uqmUXJZBdAMBg/grA3hnr tg0DYZiJMyRZ2qEPEPQJ+godveU1gj5Cuvc5imYtuhlou2VvkTFrMhVdGmRp7ARFSctnn1iSoq3Q NpvvAw6iSYk8K5FFSaf7EbUAAADoT2gyftK10dnZV3Nw8GJaboQsmnuHTmRCypJQuxG5MHNRChGy 0GIVbXGLxbJpNy0hDMnRrccRP/pQSwLwWvzsQy3fET8flxr8rMFHx9Pysx0j0e7zz7xOnmEtBC20 0ETbGiGLh5koxdiee8ZKxMIt75SIxXguXtGIWSw+h/qOCVoMBjvm8PDO2q0ZjUZmOBy29pETqhDh ChGzmEwmUxNhCyd44cwXtsCwVcwhydF9kzYnavHj5sbcu8laCJ1cvSuBuS9isbvbLhfgf0iSX3v/ pceoIcE/oid5Y5Tuv/b/9cfof11/y95+quX8nKTqpsIU9rwh5amShCyt7c3Krm1v1jaQ7dS6so4W t9hR47r6l/Y8eLS/3+Xyc2uvTTuoMEfcYmDSLxLFAg9T64Z2o18HAAAAAGWJveQVCtDXn1cRtvhl GmGL9wW+BwAAAGwH3629tfY50JZK7K7bUxZLMBwTs1hW0MIXt4iJYsSSHOeIWITmW/4+8ffNNnJs 7dmmnQBQfOlo70oKk5tgJpTYPLWuLvvjxHzb5mMfoAb0cX2xSUegF59UOed3MrVO6n5WaJ4Z+33P EbOI+ZeqB4B/4XiBmlkl3oUYmfWTe43oRNLerMUjAAAoyW9r76ydm/Q1ZewevthPa1fl3ARYO+5F wSPjhcPPyqFEtzqprZ/c1k96G2rLiSf3k4PliF3AdvNq0w4AeFxH6rue3S3zfD8WFxEbI/T8MLQN ACyIxTh/MPHjHOCp4YvY9bHQu6ah+X7sOiIlaAFQgq53ZKScGyPmx4eKsMXHMu4DAABAB5fWTq19 W3K71P3oUHtq+2XaAACy+SsAe+eO0zAQhOHhEaRAhwQSVW6RCiGOwhWQkKhpqKGjjsQJuAAFJQ0V FTegQUg0iMAO9iaTZfbh2Im94f+k0e7aznrsxMnE3p0fohYAAABANXyBuAz2+Ubecayjg4MBfTu3 FWWbBSi4LQUppP0VshiX7fFkOdel8AX3xUmWuc4iGePx3/02gUzm3GVy8bMOuRwj/GyWHPzMwUdm 9f2cfY5VdGGXSUELK2TxNSmL+hdNhS1syWIUVpxiKlRRCFpMRSx8dSuKUYhffJIUt/CNaWJBi17v jQaDbRqNRjQcDmfOCwtUsFiFFLSwQhZWzMIVsQCgCX6TdnNi8DIJua2vlyIT/X6fHl9e5AtmS71T 73ZrYt1vcFoKWyT3XYEcEre32b/dx6L777KYw6qc45z7X8Y+lnUMXT+OnN/LySwaFqWwAkwkRCnK csMKVJT1DbGMy02nPdmepmIZVszCsre1Rbu9Xoqbh8Z2aFasImahQYhyG21QIkXK1AlHeJgLAAAA ALAYYoP2tcR8vkSAMWELbl8YOzf23vyhAAAAAKAlPoxdG7sy9uqs0+IIWU+ZGKglkU8Vt3AFLkJi FTGRCy3m0fxLMVJK7Zx1lZO2HQDAQU5Mil0/Va5R9zsp1A714fbn+hpKfAMASEO7tp7acATU5oGK iachUmLK2Pd0KJaMxaJV4j7ts+nWAQAA/A+qjHvxJU+AaMZ8hH6PY7/hd8ZuluAjAACAxcCCFpfG nj3rtftzof+c9827CECrnFExplwb160lsvUlt/VtExpf7msT6bEwyBOIWoAukXrfObbeFyuEtiGl rY0L8PkQeqYIwKrju4a0dczlwj0CIA+OjO2THuuHRClC80rnMUnVpMEA1CEUZ6WMN3DHB2jCFqcE YQsAAABgmfCclVsq/ve5c1bqkBKXaoIYbh0AAGrzIwB7Z6wbNRCE4VEcoqSCggegvZZXyAPQ0FFQ 8AZ0SHQ8xkl5AQokRENHQ0HDO9Ag0VIgcgiC9+y1x5cZr33n2Nno+6SR1+fd9XgLe887nh9RCwAA gMOwJucvUo0uLj7I2dnDbTnkzY7Js2O52so1EQstZKHFKrriFtW2PS6dPmKe7vac7bmnJpfE4Ln4 eQi5XCN+TksOfubgY+Bu+tldx2oFLdo1qqurf6r8d7sfBS1aEYtofzpWCVNE0YqNErX4vbVK6GJT i15sVJtNI2Qh0vbvxS+dnIgcHf2Q8/PHsl6vZbVaNWOhxSyi7YpahONR1CIKWwBMgRaxKIqiEbKI ydmD3asTef+6vOy2vd6ZdQL/zbInZpGRoEXu/d+Fa1iy/ZD+ET1J95/7NcxxjinGKcdx6Kw41n1H sYkmoi+KW9TCFEXclnasxC6O62NFvV+ouo0whqrfifIr9x+dnm4twQOpAhN1YOEQcYtC7I+LUoGH fXWtYdz9DQAAAABuHi9oP5V8dR9hi2BvS3tW2veJrwMAAADm52NpL6WbUD5iJWOwyn0JiIckGfZE KnYFLrw6XjtPLKMvuXFK4MIaA2vMbjPh/eKTpZ0AUHwV/+OkvgQX1u/ePWmfBOZD7wMp/wBgfxC1 yJN3qjx2rjRmfpm6548Vs9j1zysDwHA+Le0AwMx4Sb6GtoVxeM9n6zn/qrTPM/kFAADTEQUtvjnH +/7Lee/zvkzsI8DShI/yn0s6HjwlaGGVh8aci/jx48SX501YU7y/tBMACr2e2PefUJe9fW+tz9rq +l6cQB+8Xwaw8db435f2cymnAG4ZT+utlXB3yJw/JXbhidhZ/e/77hvgEPpis1IxrFZMqGVB2OLN jV0BAAAARIJY6Wupvl2Zi9ScdewclzkwACT5LwB7564bNRAF0BuxSoRo0lBtkY6aghKRIi2ioIwo +Al+Yb+AkjY/kU9IkQp6QkmHQESyVitmYl9rPMyLXe9jzDnSlcdez3i8kTfe9cw9SC0AAADKSRnp 9LW3Ji5yDZ2dPftLIqEiC5VZtEvpl63UQnq5hSuwWC5Xndhi5YguVgPxha1rE3Xbsm3Phh5329SS ILyWpPWbUMs50s9xqaGfNfTRMp1+DscX+UKLtv6qK6vIQtd9oYWKLFRc0XQyC7/sCi5cyYW7X+O0 t3yQXNhjxTg5EWmaO7m8fCOLxULm83kvs9BQqYWVWDRN08ssVGihIosa/q5QFyq1sEILt6yiCxuz 2exh31/3920dcW44fSnFsPHg+lHXtrjhbN80efsUkuRPof1DlzlM4T3edvucw+EcY9P6U3kfeqFF J584UqGFyEBI8agLt+yuzwKva9lvU3l6fCynneQpw0sTj2Uoq8jFugMR/QlFoWXpQ1se1gIAAABs j5JJlqHJlaGEfiVii88mXpu4Gf9UAAAAYAd8k3ZiwJWJ395rucS+qaTAqSTCIYlFSFzhb4uJLEKS Cr9eTKgRS3ycS3BckuTi0Hm/7w4AeNw65dB1FNuWuk5zicv/Jcl5KklN6LMAAMYDqUV9XEtcVKSU JJfQffzP6BJ5Wun9HpILAAAoYYzxL4yVGYfU/+WS737vTHzZSU8BAGAM7DOMdYQWqTEQdvndxNfx uwuwV16ZOJd4ctuUzCK1HtqeazsnvJDENjg8nu+7AwAeud+eXUqf5206LsCvH9oHANLXpF/+YeLj LjoFUAEvTDyR+H19rBy7p1/nHt4v+/NIY2WAbZK7d8vNj/Hjk4kPJn7uoO8AAAD/G3aeip2vYp/5 6G87oe+EsTF7AABV8UcA9s5fp3EgiMMjQoEpopPuBdA9CTVPgGiuu+Ya2ktHdW9BQUlDQ0NDwyNQ cPU9Qe4KEBIKeLNee7LZP04wISt9nzRK1l57x0E4483s/BC1AAAAWJ/QBPOP3EHn59dSVV/n762I hX2esAIWr+12I2zhzApRvLYiFVq4wglZLIpcuD6ycA5Xr7sbpxvvoympYHhJvq5LKdeIn8NSgp8l +Ggo18/l3IdlQQsR93uUPXbWCFpoIYuXut2JWlhRCi1usShmYdqdsMVzK2yxKGLRiVl0Y8yi11ZV M5lO7+Xs7JdMJhMZj8ft9VoRp07MwpkTszDmRC9K+VtCeWgRCSNkoTFtZ4Z/j4+rZy6oAuTzVzeG FsNwxdAHKIheeuH2Egrkl35+PuPtOH/p11DKGCX4mD2/dOIV7XeJ3idWfMK9zpUkmrZRlNhVYhe7 zb5R0x41bXeME7bYUeIWOpvvYG9PvlVVzuUvYhcg6eTCPuIWI9W/b1KiZPrqj1Ei2wAAAABgM+QW R8aK86UKPGthC78w9LS2k9ouBr4OAAAA+DjcwgAjaPHX2+fHCH0LDqcELGKmRSlC4hbvtdh4scLH oRgptfjRp6QfWE8/2wEAxVNtdz365RYt+YuS9bZUUdPYfSw1ju+H3yfUBoD1MPMOfrwC24u5p1+p dq7Ql0/s/u3PW/WJNVPCZikxi76+AgAApCBXZnP0eS5z3/MmtvxZ2/8N+AUAAO/DzAX8lvUELULP lv7z5O3A/gJsA99rO5C8sIWfD67z0GMFb3N9cvnoIss55xJow/Zx+NkOAHg8rNg/Ng8dmw+OzVFL 4JjQ+VP5BAAQJvZ/Z0QtmMMBENmv7ah5H4qtc/F+n5g+Fc/7+3yI6WET5GKuWCwXyw+I5RRc1nYs CFsAAAAMyR+xa1ZuAvtWzc8jvw8AiuBNAPbOHqeRGIrjj81HAYiWMlRbc4GtqGjpyQEoOQIFl0Ci 4yZbbIUQ2lMgml0JFCkowS+eFzuWn+1RkgkW/59k2fMRj8kkE+PxvB+kFgAAAEAZ2uCyPxh9YdJZ rqLR6CfN56vVOdmElVDYnJY5CylYUCFyCyuvcDILLsuyTbOlAENeawN8zxf1zWarx+2SmoKH19LO dajlfKCdm6WGdtbQRqaudoaCCGm7uxclEgsnsuDcxkHh3AknrHzCySw+GkGFk1n4ZRFb+IILkVjY 5alXz0dzTF1osb8/pZeXR7q/v6PxeEzD4XB5LlhUwUKLmNSCE6+H0AJ0BUsrJMh8r9dbLHMuDAaD Rf5/Mimqzw9wvixz/Sy08CUWsk+zvWmMX1Grv6P2IPkQCWy//trfY5zD73OMdc91F58VOU7Xx9jz 1v8gJ7wQcYXkIqeQcs9bx3nfW+6zwImUp3k8OdOx6csd9fslzf5l0iGtyipyKZyMqO0Tm5xImbz0 YSNMWAQAAAAA2C6xiftaMAd/8n6J2CIMQC3bbsgGAsIkfgAAAOBr89uka0o/GKAFZtAC/6aCwseE EjGBxaZkFpo0IyWy0ILbx/pLfh5772rg1KTRrhsBgEdKaJEKDFMSVKb0upW7JmjHybUXALA+/L16 2nUjQDHcx3xvyiXXyjbX6BIhhTaeVXq91/p/qTIAAIDvDea/dE/u9znXT3g26XL7zQQAALAGj2SF Fm/K9tiYfdvxwT8bbzUAu4eD3V6RnVdeEpC27bzy3OtLAt1CbFEfJ7tuAAABMQl27H5i6b283L1A baxYG0eOLQMAHLHvkrbtH1mxBQCA6NykA0qL5DQ5Re550Vh/318naBKNcHtYBmBTaH2uWF/O3yec Z6DNG5A5pn/JimTaytQAAAAAsArPIXww6dak12Bbbuwk/H0PX5P63zK1LwAAdMKnAOydv27UQBCH F52LJBUFPYiKt6C/gppnQEKioOQhqGlDfw8AL0BJl0egoKII0QkSPJzHu57bP/adc7bh+6TRbtZ7 9ti62Hve2fkhagEAAHAYsRfLr0ofurz85M7PH/2tSw5tTaS9E7C4a9tFuEJNhSxUpMILVXgBC23f CVvcNn1cZx9eOOPOlMdeisNYSiLxpfh5LEs5T/wclyX4uQQfhfn76e/9IlbR9Xc39xQKXHhBi19G zMJbV8zCi1bsxCxUwEJFLG6acmu2xwQtVNRiH8l9fHFx46rqu9tsNm69XnfELFTQQsUstttta/K3 tIvFhC0wbGzz39sHHRNU7EIFLn5cX0e/80UCMYuOUEXYFm47QMxiyYn4l+6/7n/u1+hfuMb3vX/O YT7HmPLzfY9xymvdia4zbW1UnopbNMIWKy1rqwKxi6rZtmrKKuwfiF5ovT1uc7ynZ2d93H9Y23PX DSLsI26xcvFAw5y5Qt/2kprS1gEAAABgGlJBejbALwzYt/VSkmhJXPiitqt7PA8AAAA4DEnuIEmg PjifaFgpBfznkv7Gxgk5swIWVtxiqIBFaj+5xYg5gYtUgopcQoo5T4rHeDO1AwCGUNQi9v80JLlM bNFx7J6V61NKXpPyBQDGIfb8/TqRLzCMny4unKbkFov2vbf3HYPmnge3ieP19RUAAJbPswF9h8S7 EBszHan3WVrasYCIvr4+mXcAADAEuUe/d8MELbTM/a60vxu/1fZlTMcBZsLj2t66/RjuUrLbkpCF TYKbErrIxZjn4soZS8+XJ1M7ABAg76BTC05z73Fjc32ld9S2zMVe2npsOwDkSY3lP07mEcC8EAG7 dVNPiUukxCxSbX3Xk8b6WhjPw6lIzeuX4rxsrICNLfht2iXW9mVtn0c/AwAAgP8DES9/5+KxhKXn d279RmouyEW2O7c/djgGxrwA0Js/ArB3/joNw0AYP6SiSqBObCzdGdkrZjYm3oCJR2GCmQkJ1Hdg 4imYgZUB2ECUksO91DHnP6FJG5fvJ1l26sQ+V2riOuf7IGoBAAAAxPFNsO1F6GMygRWD7O4OaepM /eWYcxagMDmVuRGwoFLcYi5ewfnUyr/KYzlHruXAyuZ606bd76pxAz93lVzsXJRcxgk7myUHO3Ow kemmndX1JzZPhC2qghYiZDEpc1Oe0FzYQnIWoTBiFkaUQsoibPFeyav1H7PrP63cTuZB5X6Xvd4G 9ftvNBxu0Xg8ptFoVNaLQIWIVoighQhZsIiFCFloogMAtAUHCGcBC06MXbZFLV7rilpYIhWV4Ofu 5wuIWuQewH5Zwef/c/s5iBDE2s7Zfmk/9zEso48cxFu60EdFyWEmZLEhghY0F7UQcQoRqOhZxz9i FsVzrmeJWIgIhrrjR8Qtinxnc5P2B4OUYYzIOCfaYhWxFNqE5HNQlDJF8tSNRnh5CwAAAADQLrGA qz4nPje4X0jYQgtC/URG2OKq0dEAAAAA4K/wC5drMhsD7p26kON/aHOAFhxYCww1ofDcoY6Yhe+6 UF++/jW7tbG6uW9TZG4crdoAACweZ0lD22gU22wU+32n3MdIqfe177Ml1/sDAF3lbtUGgCR4zinO Pr77YOjennLPDs3tQgIXoblrbD4YKgMAAFhvUv1amvB/gQ9NPWLP6dh6F88Bbop01qKNAAAA6nNJ RphbI2X93veuwvff8bZZ8wHoDHtFOiV/oFrNj1yr14QstPN912rCFkS/fc/dz0G3OFi1AQBYPFjl mG9kCJ/fpFun9RPrI2YX1pcB0N8V+c7j3/116xYBkAeHRdqmxcUstDl/6H+Bby4fmuu7ZQCaJMVH q67vgbaW9FKkkyJdND4CAAAAYH1h38FzMuLlz05d6D2PS6qPoda21kbdzwAAYCG+BWDvjHWkhoEw bLS61e01FPQUVFsiHoAr7kUQNRUNL4BAVDzAStfTX0MLR8k7IDoooUDipCz2OrPxGo+d6KJNDN8n jeLY3nhiaVfeZDw/ohYAAADDST1Qflr60OXllVmt7u3KPqG4X997AYvtvt4JV4iJkIU7iliFF6qQ 82ZfL21y9J9rdtYJZ2yj422nYjxqSTBei5+3pZb7xM9xqcHPGnx0zMfPw2dS3qXuHZQTkGgayW+y bUUrOkGLTsRC7ObAmuamFa/wYhVewCIUtDgUvvDnv4NrxIIWf8+Zqzs5ccmOv5mLi0dms9mY9Xq9 n2MRtHCiFSJoEZoIXUg/EbYAOAZOwEKSqTsBCylL/XK53PX70VfUohWoUKMbUiIWcbmQNP1fSJJf Q4L8PmPM+fq1z/HU4gG1XJ95Ot73fcq5vpPps4/YE3GLVqBi0Z4v2rIIVIiYRSh2If2lPizL+HLt +6en5sFqVboVp3zx2BwGEPYRt1iY/OahlJlC33gaCUYEAAAAmJa+myRTAX6asEUuSWCYPPqltWfW fo55QwAAADCIa2vPrb2P6lOB/Vo5lfBXWxOURCw0kYq+bfE48Xja+HGy4pywhckc4zmskSfW7k7t BEDAdaG9tGEptwk5bE8lryttXtbG0Xyr9XcBoAa+TO0AFHGbUD9m2rWkYEOsJKqm9cu1xb6lfOX3 HQDg/yEX10LMy/zJrTE0oas31t4d3VMAAIj5Ze21tQ9Ku/YOI6zTYh1S/x2l/Mna97FuAmBmnBsf syPkEt2mEtnm6lLtcWx5asy4LTwa5Rym5eHUDgBEfB3YX3tvGJdTbfFxaEwBz5UBhqN9115N5hHA vDgzneBYac2dE7Mo7SEdssc0hLU8HJPU2qu0htPeGZTsrbUXhj0xAAAAJdx+Fbdv5XOire97nty7 /VyMuNYe99F8AQAYlT8CsHf+Og3DQBh3pFJVQmJF6lIm3gIxsCGGComFre/BSh+CHQZeCFgQDIwM iIWmVYJN4vRi7LMjiBJH30862Ukc5xwp/xz7PohaAAAAADyuzmTa+Xwu7cRX0Wx2KPK8Xt1WbKIQ syhSUaWFgIWoRCqUYMV6nZVpTtKsWqbCFmrfYr+srKN+3D7Sn0DwPLH4+VdiaSf8/F9i8DMGHxXd +lnvc/otaJH/CFioZSVskWWbcpmKWphiFlq4Iq0JV2zzdF1K8l+lmAUVtFiTujfOVkwmiVitnsVi cSGWy6WYTqdFi8pzq8UsqKBFmqbVOrUdYhagC3RgcCVgoUUsqMiFyuvt75/Mv10jwDgNOJ4YAcFt 5fW6pDw2J2oRewD7oYhN9PkcDeUct13/ENrQNjGcp9jvifQYocepKTmUwhWJFrQQW1ELLU6hBSp2 5DNGC1qMtKCFWU7YRwZWowplmf3xWOyNRiGuHknbFXWxCp+ZAxJdZZwuMmnoJCMMWAQAAAAAaB9X B2DTYA9NhS2UqQGJc2lP/9YaAAAAAITwKO1K2o00U0WcC9Kg05CAwS7hCE54wsz7hCw4UQxzH07I ghO44CY50NR2DmNk3rUDABjQAOi+a8t37fomOLmWuTrM+kxfh3aPAKCvvEr76NoJwHJH8r6+KFsZ bqKp7x2Ueydtcv+3vQtybQAAADAsQsavJI68qxxEMtqFe7fgypvPfhXsGcIWAADQHSo49bW0B8d2 23ea7xvS9W/AZqYoOABD4ljameCD0nIiFaHCFrbgtzSv8Y0/N8uB7jno2gEADJqIWrj6oG157h8g 9y/QVQb9yAD4Cblu9PX5Iu22bYcAiIRTESY4YROn8M0l9e3jmj/qeu8HoG1szxJufgxnvv6je2mX 0t7aaQoAAAAQNaq/RgmXq+8227yVpv95XOt9Y8O5sYC249rW27YBAEBjvgVg7wxSGgaiMPy0UOyi 4MID9AjeQHQvXsELuCruuu7ehSfo1hvoFVQEvYOgFFwIoqU10+Ql08m8mYm0Sab+HwxN0phM0jZO Jm/eB6kFAAAAUA1bp/KF748mk1vq9Q6W0yqfNifVTgUWi3y5ElBwYZEFSyoKUQXPz/PlpsxC304h zkiTf88zs0Xb83ojYX27iOUYY/k8UM/1EUMdFfXWsxxbVBZaEHF/VSGymC/lEqncYpaJJgqpRSqn 0OUWuszia0ViwYKLdPrbEGP8UCHLmC3lGRK93oKm00cajS5pOBxSv99Pjyj7f6aEFSy1UCILllqw 0EKXWcTwPQHbhy6y0F91uUW326XXD38+gp1drQsnRE6hrZMnM29QaFGHrGGTxJCAf9Pbjz3B/7Z8 hrEfQx37WMd52obzUGUfK5F0mcSCyaP0WG6RCSo62TzLLHKBBa/DcgttfX09nub98T4He3shVd5P ygmtBhKGyC06JAceSoU865qnEYGJAAAAAADN4wvCswX98XwVsYUtobQKTjxLyvU6DwgAAAAAVt6T cpWUMZUTOrgGBVQN+peSQpkiC0lWEVJMYYUkuwhNbOwbrCANgpDOYYwMKG2XAdAWHqg8gIlxJZOx LXcNOA4doBx6rdi2awMAMaB+Y09NVwKIKKHaveP90AGpvnaodF13tf3Mvizf9d11zce1HgAA/heI b4kP3z2i1M5Qr2r820vN9QUAAJD2D9qeZzC+/nvfPaTtntF8pnGTlM81HhMAbeM8KcfkF1q4kttK YgtJbuGKL/cJLUC7OGy6AgAYvAWuZ4uLsL0X2l/sii+wbRsAUA1bbID5exvXXSkAWopK0HWUTUty CamN72u7VxlXKrXjzeVo74MmCO1P8o2LMctzUk6TclfHQQAAAAARoOK/lchiRGVxuRSDJz3TCXnu EzL/1z4d1/LQ9wEAIOdXAPbOWKdhGAjDJ2inzixdeAdmHoKBhRWpEhIbT4LgGejamRHBzMzIgFgQ QmJBalogruPGcc8+h6ZtXP5PspyS1HaQmqbO+T5ILQAAAAA/oclls+8kL4dSQ/3+/oJEopRN0Fw+ oSUXutYCC5pLKpSwIsu+i/rHqr9ZsYV6bynH0G2a/lJK7p3KWFMZ5zKkdI6pjBXjbI4UxqhY/Tjd tk1/5bMl/dpsT616Oqu12CIrhBQTS2YxKQQVpcyi3B7PJRZVmUU2F2Lo2rSTFX35hRa93oTe3h5p OLyhwWBA3W5Xn5EltFDiCiOysIvaB6EFaAOc0MIkW7elFi/v7/Q1HnvbqSQl5xKUc5ILq4/Kfue4 bUiSn3r7q+4jhQT/kJ7E9bHq9relj2Xfvy3/h7/2URFaGOGEEVpQKbWYSSuUqKkQWXQsoUXHCC2K 17uW3MKNBtyx+lT97OX3fAeFyExAzcX0qCqriFlcFLMIyTvEQB0biIgARQAAAACA9bA4Ueqv3WA9 X+Jq7rUv4fQV6cXyr82dEgAAAAAK1KKAUV4uaDGhcMyigJjFAL6ET6FkUK6YIkZwETrGbSNWYhGT xJir3f9j6hxtegAAODxY27GfO+kzHPq8u9eIOouZ3PH80HZcFwBoK9y9y92GxgJkRta2NP8kHeO7 D+Wu55LkQrreE/mv57jGAwAAqEtTsS+IoamH9D0uzYPZ9xtq3gRiCwAAWB/DvFwSL72V5u+lZxqh pISulPszL/fNnRYAreQ8L6ckiy04aUWM4IKLRY9JhGuD5LftBFIL0DaemL+5c7yh34nSvK/0bFDa jukDAOAnFB/wTNX4AgD+M8cUFlrEiCp8a0brCi5iRBcArBIpPqHOMwJfjKxdPvJylpfr5k8FAAAA SAr1+0ytW7ll9nFxedI29/3MxQpyx8TGgttjc/t2xw4AAEvxKwB756/TMAyE8StZKDDyABUPAks3 Jh4A8QaIl0DMrEjwCggJVcwsvAFiRMwMCAYgAkrc9pKre3bcNmlj+H7SKc7ljy8VJI5z9gdRCwAA ACAcrWP5oOygi4trarc3B+VCUIIFLPq53whQsLGQBYtUFEIVvF4IWUjj49gK4Yy+tSz8sUz0HUus scQ5DzFdYyyxIs7qiCFGQz1xjvcbjdfxk/u4j6rfZ2GLr1zMolgO7fs7FQIVhWjFUMSCBSxYxOJD 7JtaAhdS0ILr0QUtVlZatL7+SWtrr9Tr9ajb7ebXwWIWbCxqkabpYGnWeRsELUBTMEIWxpIkyctS 4MKIWtze31Oa/f3a8CTiwpEvW6LMNiZgwduzeiZEL0blJk+q3oTzcx11n7/JYg5/5TeO+fyLqOMv XEMVdcQQY511yKPs508+EmfkT8xzTQhVDJYjS4SYBQtcuPbjMtfHdXRWV2mr3S4LeSOzbRpPKAwR t0hIH1xkJxbaPl+Cov0zaj4AAAAAALB4QhL3y5L2taRA18TW9oTTdzScFOiq8isDAAAA/i9mMIAZ FHBp+WcdCOB71vtME7EIEaoIEbTwiWhInyvuaQYp+Ca5iJ2jZQcAgOCdJkV4NFz3LrL8P8q+Ie83 rvuEVo8dh72Ptg4AqI7HZQcAVB5In0hMMmu/k9Y2DW2r+u7xIW1D8pQBAAAAX95LWU4McmbqxfUe J30ue8lsjyBsAQAAdWP6BU8yu3Fs9/UHln3fmOa9UX5jOJ//sgBoPLuZHZKeK64JW7gmu/WJYEwz 6a02+S3ays2js+wAABA8z3icLz/Sta7tL32aX+tfRr8yAH5832S0/83jBcUFQNMxE3XtkH/cZ5mI RVm7f1oRC7uMcaRgkbhyt3ztQFcOWUifkulLOs1sP7O3yq8GAAAAaDZPNPzGc0aTouUh+ddluXza 89iVQzhvnqAdOwAAVMavAOydv24TQRCHR5btkyjSUbujTSpXFER5A8SL0IHEm6SzxCvkAQClQUKi gT4FLQLRIGPDLuvxzS0zu4t9/rPO75NGt7mz92Yvyd15vXsfpBYAAACAjtVZLDuVn7q4ylU0mTwi 63naLLNoJRdhGQQWtJZUeGHFfL5cLX+L5bIjtGjlFyTkGKFO3p+eRz0P/a4l11ry3Iaa2lhTnjXk WkOeNeTo6S/Pbv9WqJLXSaEFiywWnfDfJ4WyFE/MV4KKuZBZsNDi50py0S6DvKIVXrR1yTo5lmor RqMBNc13d+18QLPZjKbT6foYeUkFSy1KZRY1/A2A04aFACyw4LIP3t40zd/yr8WC3xQWgw26bGJ5 hVwfba/9Ifm1yyZ4H8dcf+3H+FR+h7W3YR/76OM4ncJx6HMfHaEFCydYaMEyCqKOqMKbIoZCaDFk ocXqZynBiEf8DcQ+/X4ejsd0NhyWpPqYgtxCyipykRqgmHqtNZkoHhBpHcqS9QAAAAAAoH+0gXfW pMp4EL/2AEFrIKAmt/DxzcULCpPlf/TaMgAAAOB+8YGCzOI1dScFaNdwrawN3Leu9dpDoGLZhCag KBVapF6j1ZV7gHHJJARrsqLklB40ceFicugkABC8TWxLTRZK/e/mJjmVTITK1VmSLwBgN3w8dAJA 5VqUN5nsafU/5e5Hc+f43Lk/lR/O6wAAAPoEkovdo127c58Trf6urxTEFp92mzIAANxbvBTxuYvP xnbt81rqnJ4SHObk3HL5xcXNto0DoAKeuHhJ7ThzbVx46RjzeF2J6EIjJbTAvfLhOT90AgAI7kTZ +hyo3UNoWPcc2n2H9d5SSvqkAQAtqf/vNy7e7TcdAI6WZ2TP49SEFiWiC+t9pQI7mQsA+8Yaq5Ab KxqPL/gfscWti0sX73tvDQAAAHB8+LkqfpzgK/r3Ox6tT0WWS76nTwkqSrZbYwtLQrYjbhcAAGzE HwHYO3vdJoIgjk+I5MgdElSuqKkRbRBdeAQeASGB5Ffg4xlo8gppQAgegYegoIGCAtFYMsTHju8m O57M3m5ibN86/5802o/b25uL5Mvc3u7+i3aGAgAAAIA7oPwsd9Lp6Xsaj+8oUYk2dm8FLJqujrrN uhslRBFFKqJQhZSjkIU2OU9M9vGO14nXSyFttrHZ5rrU4mstfq5DLfdYi59MLb7W4GcNPjLr+bk6 ZhQFLZquvDom1YpXRHGLKGhxboQn/lzYYiECF1qwQsqS/9sdmzsiFrHvFEdHB+H873Ry8pim0ylN JhNX0IJNhCysoIW01X9TAHaN/l3Lxuta6GI0Gi2PzeZzfZLXkV829dxnIykLY6h2LJTBG4s3bBv8 jdS+CT/6r8PHfe5/G9fYh3v4H9eowcdtXoN7kf8Oyz45FuvKh+oai1AvwhasJHEeynycI0sRuLho w+IWXObjXTuO1uRcacd1BzJuEcr3xmP6HeK8r7NZn8u3gx0H+0Bx0uCyW+oXqzik+LH2Vpd6Ewtt nW5LJm1M3qsDAAAAAAC7QeIzW0eqXsdrNn6TGNDGg0SX+7V9SflzsC/B3lI7oR8AAAAAZfCmT2fk Lwjw8rrsbZgg6cK0SS3cyy3k61s80CdEkVuUkEpT/pXcc9/mEfs2dvVy1w4AYNCiFiW/wdKFTrnN zXMLlrz+Pd9uwnMDgKEBUYvhwRsH/cy0KXl2557pV40jvXjxKuJn1JMHAAAAwDDR3730HCWvjhKp 2C9qhS14/O3+Rr0GAICbxVlnHt47WGqMv+QdMvfNwXtffBfsyRr3B0AtPAz2KtibYD+onffDNF1e p954SWo8Xc6xc4lyG9zacRfMLx8Oj3btAACGb/kml0jNG6BEfcmzL9eenDIAII03fiN5otX4gete B/u4HdcAGDR3gz2guJl+TthC4nT7Ht13vMn0Z8dcbZ4SxwDYFPr/iC57qYdeVy2pdw0NC2U/DfYi 2PPrOg4AAAAMHP6284laYQtNyVy71NhMyVzB3LzBkrUrJXMF+8Z6EMMCAK7FPwHYO3vcuGEgCo8t GzDgJl1KO00AHyGAD5Eq6d2mywm2c2vfJSfIAVy6dGEgPoGL9W5WiUYid0fjISl5f2Rq3wcMSK0o cSQBEpcc8h2miwAAAAB7R2g1SBlU8o2ahROjnJ19prJsDtGiEpx68YnFwm+TE7CgpUgFC1bM56VL /4m0bAlarMQvSIhjkBDU6H4D/CLiOZCLr7n4uQ65XGMufjI5+fnefc3BR6a/n+2+rbagRdkStGAh C1vQQotYzGglWPHihCpeXF6b38dlp+64ubK/yzTEyckBTacPdHX1nSaTSS1o4e+HFLRgAYvZbFaL WXhBCy9q4cvl8qzB/uAFLIqiWApZSPOiFvPSGO8NCFeY+73pbVFXq8wWWNaT6fl9Hft8ftzj93H+ 3K9hF3Vs4j6N4T5ssw551oK/X6KuWhnCiVrUChFOvIKVIo5cWotZOPPbhbOWwgQ/S5Vn+1h9Hz8c H3dx9bKyU1qJVcTELLzJAMQ+ZS0xC53qBxLrYwIAAAAAALvD6jCMTcrU210CBRfOZF4aLwz0g5pA /ueNXRkAAAAwTnjB4FtqFpkJCVp0XWAhNQkgZQsj7WtWm8FqO4TqsyYkdDV9zzRjHFj9OrQDAAge KbzwTOz/iN5vldPvtb7vBX2cdX5dLwBgd/we2gHQQi5Gqt+Hqfdjql0ae5+nJqn2aQvG8gAAAMbL xUD1huJnEC+zeazve6rPTLYnvLDF/dY9BQCA8cNjG9eUFrQI9d+H+ui6xizocY3QuMSfyn6tc6EA ZMR5ZTeVfaHXMeGhuPHU7zqvjeh1THko9pyMMmD3fBraAQAUfUQtQv3VsXHHWDukbx0AgPWI9eHw WOFbRG4AGCNSmNEStbDmgOr91nzR0Dm6mPQFgCFItdG69DPF4mn5Nyt2leN6eUzhadMXBAAAAAzI XWU/qRnfkYIW1tiNlQ/F8r1FqMIa6wnNJ9H5VNxg3z4d9P0AAJL8F4C989dpGAbC+FWAVCoVFnbY eQcmdiR4AQbeoBNSt0o8AgtSn4GBDQkWViYYGNlZyoKEBCoxzjWOe/6TNm3q6vtJpzhOYl8q1U2d 830QtQAAAADCSBPJF6GLhsM72t7e+y+bybW1kMU4r9f7bCxkwSIVhVAF7xdCFqbxdWyFcMbY2la7 8ZQSg6fiayp+zkMq9wg/6ycFX1PwURH2czqmaFrQgsgUtNB1ep5Ki1v8WFYIUWiRClPY4nsiXqGF Kwohi6Ku3Ea57V/nnXQ6YxqNXmgw6FOv16Nut1sSs1CmhCtYyMI0VQ8xC7DKsKAFi1lw2bStPGH3 55ct1Fy5M7HcyvdbuQ+T4zUnQU89Cf86CAmseoJ/iJ403/669JGCeAv3k2IfpdUzuViFeawkRMFi FrlQBYtbTAQsjHM2feflZRbO4B4P2u0Yl3cyO6JyUGGMuMUGlRcW+RYUmXW+AEX7Y5TqAAAAAABA c0iTh1KwXihZRNVE2HaiiPvMzjJ7rPPmAAAAgDVBJXy6Ib0o4Nk6JiXolepDyZ5ifq9D4hMx+7FC F9IiAylZccyig9CCROnzXDfOM9tt2gkADJ4Cx13fw9DCYtcYZ5d9/2ns/qXxFQCwXMzv5nuDfoAy t6SfU33EjtsK6TnP9cwaGvul68nRtmvsl8oAgNkYNe0AAA1hx8cgRmbxuN558bbqf0k1fp0ShC0A AGAeVMKjPk0LdSt88/dmucrcX+gdg+u9BJev575jANKhk9llZsc0ndRWSnLrSoAbm+zWF5dug2fn 1WC/aQcAsPiIPE+a85XOkeapQ7EFobYxnwzAbPje0UhxPVcL9wiANFDizYdUTXTCJ0bnE6wLideR o4x1pKAJpN8O1zYm5kCac5JiXl8zO8nsoe4bAgAAAJbMG2mxciWMbMcHSu9z7Hopvi8mNtAsS+95 7LqxVS+15fMnZq4ndAwAAET+BGDv/HXiBoIwvtxRIhoe4Lo8QHokeAMK2nsAJFAeKBJNyhSIkpou BUpegXSUiAPpLuewg732epidXcsmvr18P2m0Xv9Zj43Ou6zH80HUAgAAAGgTmhz2J5FPrR3HGprN PpmiaK9rxCZ8MQtXN5WAhalFKkiwYrUqqvKvVxZ13QleuGMbcQxTn79vju+cEoXn4msufvYhl2uE n8OTg5+53E/Zz/f1cp9mvqmsu+W1V7YFLYrCiU80JReuoLIUt3DrGpELXwCj3L5iba4jghZ/zMPD nbm8/Grm8/lbcn93zWRr27GRcIUTtVgul7WYBW0jg6AF2HS4sIWfTJ3K6XT6tvy4WHRptCkF4+IV JGjROmZgIFQQb3/T79E23OOPbh/XsDnnGPP41HNsy732BS0mlSCFO+/EW+cLVVCvtusJWuw6QYuq XotYeG04gYwdd47KDuzY8PP+foq7h9b2TFusImbSR0gp+/IgRKnkfxxtrgkAAAAAAPxbYkl+XBkK 5NMCCkMBhFLi6ntr59a+WHsa8PoAAACAXCHl7ytTilncsm1aAt4ufbXUv6f04ykCF11NEtCICVxo YxQtWbE2/tlGTsZ2AACG/0yL/fa055qWSCbFQv/f8DaMsCz5CQAYFumjx19jOALe8WLtxqtrgXyx eSft+ayJnGnjw5igURdfAQD9+Tm2AwBE6Co4MURSrth+iJ0Zhi7jEGl+jEonbPH9o50FAIAtg/5v JLFuSnj0LGzX5ty0Of/Q+4GU2AQeoyBt+23tut+lA5AVlCD+hwkntE2NKZ8Ix2jJbkPr/BKMz9HY DgDAuBfW8Tlfaf43NVYg9s5QOkfKvDMAoD/8t/nNyM8EAP5HTr1lae6aj82170dTjkkx7gsAYxAa n2llKGZBireV5pdomd4pnFm7MPgeBgAAQH6QgAW92yEhQS5WHoq/6xrjHRKkkL4Z0bZp+/P+mtdT fefXDwAAybwKwN7Z60YNBHF8ziHSpaKhRrSIhobuJMQTUPEKtDwFggegQBR5hWugIEpJR41ExSMA BVIggM3Oece7mZtdX3LGt778f9JoP7y2x1Zuvdmv/41dOwAAAAAUjtWB/LTvpOPjt3R0dMsLVoQ2 OgtOcDI2EbcQIQsRqQhCFZKuu3wtZhEEMppIOKNR4fYvQ641xkag2zIVX6fi5zZM5Rnh57BMyc/S fWTC+7yQ6+t2qeBrnxf6tpomCFu08TYUUYtgvyNhi3MvTCEiFb/8sVi44jw6R4tY/KEgnqHUnTxV NaP5/CcdHn6j5XJJi8Wie042FqoQ0QoRtBBxCxG0iMUsIGgBSkUELWTzcSvOIfP1R/94LZe3/tq7 fBG28PFV/eau34SCg4palL55fQn3KP36U3/HU/d/jOvvyz2GuP4+vIex7lFF35vV/bi9JWlqZ+fx 96R2+SJswUoSf12aBSt4FPTAC1l0ZVjcgtN83JfjluIBt/34flyO2hHU1bfSn3d7Pqfvri345ews 5/JNZw+dvaMweXB1e8ovKuIyTVSuJntioc6Ly5IKGxW38gAAAAAAwG6RdpqVZ4UppE0o7UMJ5XqV j1fROXrS36mzj86eO3t0pacBAAAApg1v8PTem97sKbdZQl+Y2nxBL8RL5VkT+/sW7Fl5ucUCuTC1 sCF+Fiuee2+5vH3hjrPHu3YCgIgPZG9kx1gLnawyqd+7rpP6FkalrmHVlzk/AADjAVGLMojbqam6 0KrTc3WyjvfV5ZcRO8vlW75acQAAAEBT/kT764ke70rNWZqp4xLXc6YY3oTqmY8/Gd5lAADYOz47 e0Pt5keaTcY4cn11qf8dhxJHZHtF6FMH14eX1PbxdFPhPfp3WJH9W5wZx6oopKicnl+u22bohymP +7t2AICIbTevt+YPpPqJrXaJTlvjhKk06jcANsPqr9HthhjeZPX1CH4BUDp3nd1z9smn4zn8lnBd Y+Tr4zWtt/VzIha6Ta/jlDgGwP/GGi+wxgpqWv/OEK2vrxbi8YMUJ9RuBv7C2YMr+A4AAACMCfcR L6mdE6jZZFxHh5uM86TGfDYd77FELvR5qXmDcVo/V+rZAQDgUvwTgL3z120iCML4BieukEgX0SCn pElLwbsAUsoIKXVqpDwGIHp4BXgB3gHRUFpQmnOyc3eTm4xmZ9fCvvOG7yeN9uz7s3OSfV7vzswH UQsAAABgIBVsLQNJSL05W1Tm9PR5K2gh4XrbLHQhhShYvKKJfx9YpIIEK1ardd/eiHZ991oKW9C5 gzhGuOt/F3W+aylWT9Tiay1+/gu13CP83C41+FmDjx2DcFFfWzgMc0JS0IK3WVSiE7UYxC3+ilaL UgyCFp1whRSx0IIW8vyVunYTUvNV8zkV8V+Gs7NFuL5+HxaLRXd3StBCiliwqAULXUDQAtQEC1ew iMVsNrsnbkGviV/LZekF74tb6GdXL2RxQGIZdBwLWWjbwn3tktqvP0Yf+y5oUfv1x+ij9uuP1c++ f9bH6mOsfnQfMnruEQtc9G0brUe/c/22FqqgthFiFixwcRh/o2g8x6ugbWRTv6+NfupFNKjvk/k8 HB8dheCLWhAvo32N9icMYhWeoIUMspJJRamgfZmQxDM+qaLHVjJ4KhARAYoAAAAAANNgJX6lxnbW eE0mpVuCZ14Av74eTQq9jfYi2rtoT4vuAAAAAKibXYtZ6NdeUoBOEChJGLASCHLvWdspP1IWjG2v lfwPc1BvpnYAAMV3sV36vbS+96XPidJi597zRfsBAJiOb1M7ANqipF+c/bmxasm4tCQ5dZPnveWb 5Sue8QAAAMDDILfe5Z2ni1TJ8cZltN/RzrfsLwAAPBQooPVzsIseEan5Nm699Y2S9Qv5v7ARbYmo BV+DoKLZH6O9Lr91AKrkQ7QfwS9OK2PIU8IWN86xXrFba2zmFcLFvM24HEd7MrUTAAikqIW3lpg7 xjpW79Pne2uHOXI+AQDyWOMG2v4U7SrasymcAmDPoHpfUtRCjqMtMQtvbL8OtphFTuBCz8mWzMcC MAbeZzOXG0PIXGuZB+MltfN35We0V6GL37yI9nhj7wEAAIDdsu3cFWt9h0jFbafWfVJ5KNaaT5PZ v0nMuLeOBQAAG3ErAHvnjtw2DIThpTIe2WVuoNZdihwghU+QE7h1m5QpcgIVPkEKJ32qNDmBZ+Le tUtPUrmSnIe5IiCukF0u9KBE0v83swMQWIIAPaZAEMA/8l0AAACAZ4s2sHbhnXR19Z3G45eLuNxo mwUn4iGHbJXABQlhi78L0YpaqKISrYhp0aSYhRTHqMv/l4Rb3IUG+rSZeF/q2pd6bkNf2oh67pY+ 1LPbdVwdA+Jnfj1G9CfUvR5f+l/QIgpORHtMrBKxqAQrZmU4C2kxPgv5s6V/bY9J2b/JGqcaj4sy /57Ozl7TdDpdEbRIxSxYyIJtPp8vRS3YFhsgB+vu3wuAmiheEYUtZFo05tfDg1VA1ibmcufEIpwn y9iVmEVVXHubqheZ7d32Gm2X3+V7NJR73Hb5Q2hD2/ThPg1F0GJf91peo0jyVnwpqELwOSFkY1GL KG4RjxcmfI6SPD5/mU/1rsBFyGMmx8c0OTnxmsCLSd5QLVixLNqxF8I/htLISNN8ZT4l56dpAAAA AADg8HgLOtOwaUJhOnkwnTQozUq7pmqxzZcdtQ8AAADoIrwIgDcGfhfCuCjAmyzvmbYhk/fbrMXT MNe83/ymxQObLiSwFhU09XGGzvmhKwCAgDdCv8nwsxY5efk5z0XtvWWd66Q+2jEAoF3ufBfQIl9F 3Hr+Wc/SGHrPaa3v6vVnc8tteu5bbQAAAPC80ea5WD7WMTgs1vte7tiatI+lvd9LrQEAoF/clvaB dEGLTcb4PPEJby6CtZFRzjcLtsvSjIUsAAwCFo79FuKWmMVIiaf5IyW/aS55zlx0IvSnu8CrQ1cA gISfa/haY9GaX9PcAu08673S8gEArIf2P2blMZ9brxEA/eC0tAnl9cM90/r3Vh+flGMS6ZT4aHkA 7AOrv7bJXAZvrqs2J/dTaW9L+7HbZgEAAAAbY61dYbRvNjKe+409ja/7Xcf6ppOmW4IW2jWtOku8 OYUAAJDFkwDsnT2P00AQhve4XCpIgUR3Aol/gKhB1PwBOmgiUYCupaKnQhSIH0BHSUkNNaKjQ0BF B0eRK0xiZm49zmQ0u3Euudi+vI802g/bu2MrsVf79Q7adgAAAADoCKnOYN1p/IDs7rKCDg9vnopV aGTP7ShisShEEcUrtLBFFLEoiihkURSlCmd1Wgtb6Ou5Dql/W3t9y6bi29jMc1364mtf/FyHvtwj /NwsffCzez4uzj+I7okAhxwTMQsRsvAELbSwRVGHUcjiXy1sMQ9FvKKo82PcE7GY15GC9yGeTL6F o6PHYTweh9FoVAuJsLGghRW1kLgcEyELiFmAPsG/VytiISIXHA4GgzAcDsOv4+PVCq5EKriMss6q 4vL+0kIWqu7yjO+3rm9e33b526hj1zf477v/2yj/otSxifIvwnPoSh3SMcLfGBaf4AZpWYU8U4/j l6o4C1VwS3Sf+z5YuILbefy9o7wZffu4PSfHphTuV98uvnbGZVTXc3llVe81+k5ePTgI309Olt3K nRAXH/0NUaxCis7ZLMwnHpYq9Cbul+pc6fnZU/k2DGGxMb9n0svyAQAAAADA+VN3q5i8VDsvqPNl wp9ezBLCYlvRlm3rtXl/yF6QvSd7Rna7+a0AAAAAnYYXAHyozC4G8OI63WRhnU3nFtt5i+9SYWpj 4VXSqYUKKb9yfVNNnov3DHeBe2Q32nYCAMXnzDG7OMiL594FuYVRTd+BuXo8fwEA24f/e1/Irrft yI7CG4d9zBxv8u5u0j713s/eYtNUO9Yey/kTTBwAAADYJF2ZdL+L6HlKNp0a65LwdJpWWGxnCHz+ uxDnYb0ku3IOvgMAQJ+QjY88MQvG66tf1sffZBwjNwYxreIpUe1pohxdx2+yV2TPGz8JAPrDD7K3 IS8uoef8lE66bHi+Z6WqE/0x3eVW2w4AYPi6gTJyY39eW8Re553vXQ8A2Dy2D0fyXpM9JRu14RQA HeM+2Zsqrtve0ua3a0Rt+176RO2aUtu+t9fPzHENvougS6TGDFLjBR72f2LL90z4SfaQ7BHZE7LL Z7wPAAAAYF0+hSgQODH53jiOF8+N69j0svl/dtxnVRGp1DhQSsgiNafQu68mzwYAAJL8F4C9c0lt IwjCcCkTsLbeZOlFLpAbJIcIZJ2Al1oZsjPkBLlAAobcIZBLeBMIPoWDMU4gUhBKl2ZKU+pUP8Yz o9FI/wdFP9TT0yOkeXVV/0/STQAAAICjxHKqPk9tdHX1lU5OTtd5veA2C05IkVO2UuDCF7Oo01LI oha3ENPttDhG3f/KS1t8Cw0Z0yLjY1kUfSzjbMNYjhHj7JYxjHP4Mf7vEySCFtpKsQotZFG+i9oW sdBiFn83QhW1iMV8bavVXAlYzKs2fwxBC+mHBS2k75igxYru7n7Q5eV7ms1mW4IWvLCxFrRgMYvF YrFORdgCghZgzLB4hQhYcFoUxaYsi4hPp1P6+fCQ7kyLVfj1rk9fxMIXtCBtDRnDAvZD9t/3PvTv pU0ffdLFGFP990nf45d99N3/oeyj7faH8j0Mfe6aRNqJNx6LUEyqlK1QJuWnUke0Keu2azEM6YPq lYAnVd9sZ+5a+ZxV0uJw8PQrqgUrJtJ1wgrVXlLfydCqs9r6jonWQsYI5AcAAAAA2D9SwZe5Doc5 ToVLlYbsxtk7Zx+c/ersKAEAAIDdI4s8XVSpBAVYDvLklXOvu00c+q3rcShdBspNLCeIIOd4Q0GA uUEFx8DboQcAgIde3C7n//iYQKec82Po3OHXhcbi1wMA+sO6N/o+0FgA0WeVT703SrVpcy8b2ybn fjEFzu0AAHDcWP4rfl0bHxf4x+yO2DNc6N4l9Swpdd+cvXGW4eQMAAAHCwvY8jyHJWgRemcfy8ee AXMWKLLmL6y5jFCd3xc/A980/lYA2G94TvKjs99V2RKlCIlV+J9ZvucxMQvf99zPg/3ixdADAMDj 1qiz3j+HfAVCbXPmDa1tLPBeGYBusP53oc/uqRS2AAAQvXT2jMKxnkTxe38dQxp7LkjFl2pC8aR+ HoBdkfJxaOqjluuTq98/fXH22tl1p0cGAAAApGExC57T+UTbghapuRvJW355Tfz9lkbemqeJxZ2k 5nYeE5uiifkSAABAI/4JwN656zQMQ2HYRbRDp0oMrHTkFZhgZGOAmaWvgXgDBI+AVPEevAATEsxM SF0qhMTQi7BJ3dqOLydtiO32/6SjRM3FJ5EoqWOfD1ILAAAAwN0JrHYcX/E4DZ2o3z/+k1WoyNrb hcRCF1EUMouy2MIMKbeYTMpiC/V40YZsP1bN79wKjueSby55bkIu14g86yWHPOPkWO4LKnJY9X3p IotCYjGfC8mELrTQRRTTpdBCFVeIZSG3kJ+tJBe6AGPCVKFFsZw5hRaixn63O2Wj0QsbDh/ZYDBg nU6nJLQIySwgtAA5o8osZIFyGVJ4IaQWn+Mxm8zcchjlhMtly1xXoiX3VbfZzkPIP3VZA6WN/z5/ yjKHbbnHOZ+/iTa24RrqaCOHHFNqo0o72ui7hXxCHi/lFtpsnYXEYl/8rzPkFnKbFFpIIYYpyNhT 2jzkz5C9dpuS6hmPA6bLKkLhm3Tk29cUVtiW1Mn+GKAIAAAAABAfygA936RO1wB+X+GJ0GBDUfz7 nMdTbVcJAAAANENqMgvX5IB1hBUh6YWtDVcuVSYTMGa/d7YXqLv2UrXH4yJ2EgAofDB7wRlBqCAM pdCMWeSO8v3JHPvb2jDbBgDE4zl2AjvK+yJ8VCn2ECr84Pqe9xWXpnznuz4zrwEAAACoijk+BqTH Js8qtnjlccLjrZn0AQAgGUQf3wOPe6YXPhK4fm/5+uKo7z9CRQEpQgtKgSR12+1adwiAdLljxd+w rwitWazWJbMICSxcxW4ZK48lt+1jroNmOYqdAAAKP4z2jtG2jdL/a3tecR1vO7frPSYAoF5c/TlC avEVKykAEuNSWa/6vG77TRCaPyrXfe2p+QCQArZnN9eyyvgG6hhdEWIM3TWPGx7fdV4cAAAAYEGV Wcj+Fcr4Orleh8wiNGeF8s7HN/eUMveEOr7cBH08AIC1+BWAvfPHaRiGwrhRkdqqA0zMHTkFDJU4 AnAF7sAFuANbWQGJoQOcgZEd1AsAA6IgAXkkbl5c289p0yZuv5/0ZNf545dQWtd5zx9ELQAAAIBZ bJPEZ9JBw+GDard3/+t60W0qSHBCr8FNZdqWb+NiFkVRCy1ikZfaUgGL3PLz/870XxexLT4ei7+x +LkIsVwj/KyWGPxcnY/F2KFivz+ZL/n8ERe2oPknErEgcQstaqGFLVJhislU0CIXqvgqiFikZb49 F8D4ZmV6Xi2gYYMELTqdT9XrvavRaKQGg0Hmu13Qghu1cVGLGN4fAPgwRSy06XYSe3kaj9XHZGIe GHJy+2vezttsAhcev5dJ7GITuo8mnz/2e7wuf8PYr2EVfVRxn9bhPjSxj0JEXXYcz6TRohRcjKKl RSwyQYvtTMRiKnSRtfF9pwoUhpjFVnZusn6no/rdruQy7XCiikGEIeIWLba/LQFJOdp8yUrmbUSA IgAAAABA85GC93VdCu4LCdqXFrvW9prYRWKniT1WdaEAAADAkqAEgDJiFvMs5mT7rvV9/5Zd3Gle 8yUO8HrIWEJKoDDvo/K0bQIkaLFTtxMAMO6F7a7/UylxKiRxWNrX7N/83NjEzxAAmsxz3Q5sKLes 7por8rXZPr99gkSSwJkkfuYaa0t+AwAA2Az263YArIzQcUvoXJxZ0vOq48Sul+A7AAA0EfpteK5m n9HP+7yjzKJ/rgWQpGcevoWSfIsd0TZa7OlyvlsFQOO4UqkYlxmrbYsBN9sXEbOwxZvzvk1fXCDG fLUc1u0AAIwXVl9kntc1PjG32c5p21fyQToGAOAm9Nk91d9UOs4BACh1kNieknM9ea6oy3xiFyHj f43vNwDG+KAufLEMZinNaZnPDHzzVeZc1E1iR4ndVXlxAAAAgEpzVXxiFmadv7bFYrtisqU80dDv RlcOii/PRRK2CIkht8UUlp3/AQAAK38CsHf2Ok4DQRyfOLkrrgAJieKkKxDNKULiDXgLHgCJAomW DlFyDT3wHHR3NS9AhSgRT0BFpITYeLI7ZLyZ3XVIYp/D/yeNdr3x7k4c2Z7sx8ykbwUAAACAnokN /uoBY3YS8yTX0MXFQypLuzkXxKIZiMIFs9gMbBET/fliIcEt1vW5j9L5Ou81mEWIOCHvwjHnPhiK vkPRcxeG8h2h534Zgp6H1bE5Bua6ao4NSRAL9/kyCGpR+rLf/lgCWyxUOl8FuZDAFRKoYjOv64is 23bt2y+cyWRUy0+6vDynq6uPNJ1O/147DlIhAS1YJIiFpFKug1kgoAUYMlYQC51nxuPxKp3N53T3 7CzemHrucN1KnItz3jrP91HpYBbeOTiTurOG7oQf7Q9Dx2Nuv4s+juE77KOPIeh4LH3IQAm/Pzj4 BBurlU95lR7nizrPQSrEYh2z/ScBLMgFtFj6+hP/2ZLr+2AWhbTv01UfPn//9JTunZzQ99ksp+qj Wh7X8oVcsAppMiUlrRccahVijmBGqp5cniqSEjVfuyOyX8OxcgAAAAAA0C3ajpNjTWjzWfULdSy2 JhmpnN9GvtbynJzT5he1nG/xnQAAAIBDI8EsPgflqc3WYT61US481uWxBfiW0+DU5jprA17uvFzb qc0OqbGn1HUJ86my/4VnfSsAQIB2dBe7N2PPNqvsXyS1QSnsg4x8TF8AQLewAyt2UIPgTd3Bm1y/ Zc5p87zO2X8x2zIm29iV1nOfEnkAAADHT1frUeCkq3/4d7bmuGLrmhi2L4pMKnBgi1fknES/Ocg3 AACA/uH/hNrxkSY3Xp8ab8v9d2wzH9EmKMY2/ytD/d+RC2B0J3JtABgCPFd5TZvruAUpGwV5a13P LsEswrKUPY714/3xoG8FAAj40eIcy/ZI2R/huRRJrbas1NIDALB/wvEbKXtfy8teNALg9vG0lg/q OGbn58TaQ1qpdoogv6RNu5+oeb/Cxge3CWveIDVnENaVfTF6ziBsr6A4cj/x/MLrWj7V8pawFwYA AMBucDCLGy+/VHlqfVxuzCO1zjonqfmeXeeAcntarLTN+JB1bQAAYGv+CMDe+etGDQRhfIJyuhRE uuIKyki8AE8AEk2kPAKhoucB7lFAKBJFahp6CipK8gCIkhIhQQTh7tixPZfxeP/5zpHt4/tJo117 7b2xpfOu17P7QdQCAAAAqOMLnn6ROuni4j1Np7ONeAXDCQtOyDrcnJb7bsu0mEVd1GJFNzfNVI4v hTHI5VdFvqzfph3cjQ4Zw0L1GvZ3DL6O7b5uw1iuEX52yxj87N7H+hhQU9BiXQlYSN4KWiw3YhOl 8IS2P8QCF34xi98NsQs5py6I8Zfqghl+ptMD1z59o7Ozp7RYLGg+nxf7RaRCBC1YwEKLWYhxmRwH MQuwL4iABYtXiKCFFraYTCbFcT+ur+nBbGZPLjt2VWoFLPT2ZtVsEbCQ83Vduizg610yhkXbx14/ 7vH+178vvzEG8Rb8RnUu3fZUD0TMQpXdKwtoxeIUrn1bVyIXImjBPcfDqnzJ7aFLi+1KyGIjgsGC GNScEV20l1W/8OToiL67/uOXtLDFQ2dXVVXspq46ZCKAYQOsUhOObDCWTtcm79sHAAAAAACGR2xi e04Av+1LhvqMoSD+2ERRXjD8g7NzZ8+c3c+/LAAAAKBzeHGnj1QXs4gtZhALig8F0PsC/5ldxSx8 kwVSIhc5kwFs3ueb+J+6bnvfMImgyYmzJ307AYCCF0P/FSiLPR/1vtD7wC6WqjvkBwCgX/h/+NnZ 474d+Y94p/I5z22L77kb6yfaslQ/MvWcD/kEAAAAtKXLYKbhTgbYT9p849LljE/IwscbKsXYXzk7 3tFfAAAYCixicUl1wVoh9p1DUvtuljNml/p2IdtLlbYVt4i9b9rr4cUFXzp7671DAAwfXgz+deKY 3EVuaYtjiOp9LBtTpGOFwDB41LcDABh8olohYuPXNh+LPYjFIISOwXMMgG7xjdP4xtN4/1cq31vO 794tAAYPf0Pn99ef1OyfWyEKm/e9n+cIYMhvrAN5IVSONhT0Rait8aUW+W4geT03hijcZvnGoZhP zk6pFGl6TpgLAwAAoB1txSxyxkRyY61z567kzlex29sIWfjmsVi/Qtdo7w8AAGzFPwHYO2PdKGIg DM9FpyjNFWnoU/ICNDRQgngIipNo0vMGPAI8BBVCiBoKStrUqemRkkg5PLc73OwwHnvR3t5u7v+k UbxeZ+xd3e157bF/iFoAAAA4ZnLB0XpAmdWZn5ccXVw8pvt7350IXTRCFBslZvGvsEWt7cQtqBW3 aI63mxpP/DVhDhvVC2jrtJjLNaKdwzKHdg7Txu4YWCRosROysIIWWnRC7O6v7QQrtLDFLq8rdHFH VhhD15Hj7GxBNzfXdHm5pvV6TavVant/xFiwQgQtRMxC/so5EbOAoAV4SIh4hTadv1w2wzO/b2+r /bnfECNgsS3XilgslIjGRsqKYIbyu0/m7n+MOqYuaDF3/2PU8RCuYYw6pv5ZH7OeudWhI5NOROCC f1+oUYQQwYutgoSIVrTiFlye85et0AUfL0X4goUwpHxbh0QJik+2R6endM5iUGVRi6fJvif7ZVxG poOqdBNyk9FeAFYuoIuo2+nPBXkhQBEAAAAAYDp4C8P6BPBrbDD/ifkrvsU8oQu9GIY3k/iQ7HOy N8le1VwQAAAAMCAsZsEb/l6pvNwCAO9caVGATvddEBAtCqgJ7K8Vr4gWApQ2HfauM3c/vHsY5R0b rw/dAAAMP1W69nsbPRtKz5ToueX5zi1MIpMPADgMdpyB098IohZjwcJEpU3DoudrqU9YWozq9Vdz fc4+/U0K0gAAAMAQ1AQm2TLe3ApiZvZD3zkt29+xAheLNu8HNf1UFrZ4MlRjAQDgAOQ2QGJK71XR HIcXBxC9J0ZjfTXiFTWbHkXvjQw/478k+5rsBQEwL1jQ4p2TH8X92PMlMYuSb0/YQvuzdaLve3gg agGmxnVlOW+ezztXilGonUO0vgEA+0P6KpLWSH+C+zwQtQCg4WWyj9Qd/7RpT+gid06/r9f8j5Qj wng3mD76N0YfR3MIcqzXwhB1P/vW54b8tTD6PNv7ZJ+SvU32rO/FAAAAODo4po/XrrAwuczl2L7W /87pROMlTK2YRWm+x879lOIESz6iOMI+ghbRfQQAgCJ/BGDvjHmjhqE4/pQKtXSo+AhMfAC+DGK5 GamqygArE/0SDN1gZKr4AsxI7caEkMpYqRNC5SCH3yW+vLz62U7u6CXp/yc9OXYc27kqqeNn+w9R CwAAAKAhNLHkReqi09Mz2t19tBKvYDhgwQq/RzCHVVpzTopZtEUtSprP22FbyMKLWSzERuFVPT4t b174dhnDRvWesbV1DO1ch7H8PdDOzTKGdvZr4+1xnXxBi7/LUAtOaDELjpfljRKu+FOHv2sBi5vV dY2gxZwaEQtfti1osb+/oKurczo5eUuz2Ywe8GbD9e/CQhVsLF6hBS28yIXPA0ELMEW0oEVRFCvj uH9eflmiFvVm4cFnw79zRLjMG0i/lVe18X8xtg3bx1r+GNo45fLvoo4p3MMm6hhDG6dYR2slzVJQ s/mftONFkmrhJD8rTwpacC+SxSxKFjpjMQuqRC9Wwhd8zGksbiHKKEWdRX3+8d4eXbt+5Le4sMVD Z8+omtzki9yhZgKVZV4AQ24wrBckhRYp6YmIMlyo41AaAAAAAAAYJiGnW2oCv9XHk31Lma8QcV9+ yHy+QuS7dPbG2Qdnr5w97Xh/AAAAQFd4o9+P1N7s11oAIOM5YWxBQMysSfk5m0H1ObbKji0MsBY9 hI6t344C5wBELcCw4Hfjl4x8XZ7/TVqqHp1uxQEAd8vFthtwT2DH43sRj70LY/0zq68a61emNh7N 6WNa7cM7HAAAQIq+81asSUnDneh/v9D+Le3T8mkh5JwpUseaa2fPnb10drRGewEAYFuEfB5MzjdW asw/15/RVdCiq7BF7JtS3pPsExw6O3d2oH8wAAYKb2L2jprNzGKCXrHNbikQ6mtjpq/P6RtjHvl2 gagFGBpfA2kpP57OGyPHbxg7zqkDANAPayxH52G+U+XTgrAFAJUg4ydnP8le9xkSp7BELELnZVyW o7+nrWcW60jBkEj5DqxvaSb0nMj11BQoOzUe9cPZMVXC2a+dPel3WwAAACYMj5V8rs2TO24RGlPJ 9eswKTELy9dj+XxC/p9UmjXfMOb7WUfQAgAAOvNPAPbOWDdqIAjDgw+lOJGCghpSUCAkutRQX0XF G/AE8AzUdNSn0PEEPAINElXaKGUqRJHiQi7snHfweL2zu75ccvbd/0kjr9f2eGzJd2vv7P4QtQAA ALCvpJKoZds7Z69zjo6OXtByGXcnQhe1EMWNErPoCluUWiNuQcrqd4NGVKNeDnnydwGxbp6xxHlb xnKdiHOzjCHO8hi738WayYGX3lfzHakRtrj26yIyIUIW2kScYuHFKRZqfeHFLWqRC6Irtf9Vy4eI ZMj5LKbTv3Rx8Yvm8znNZrPW/xELVbBwBZsWsxCBC66HoAXYZSwhC10/mUxW+/65vMx46zhvl7Wp 7Q/8JOOt/VR8d8nYJm0fo/+x3+Oxx38f/nflHGMQb8E5Cn1Tk5k0cf9jSxFX5CU1qhArBQkRrfDi FpWzVT2LV/j1hyJ8IXXKR6XOe+39Pzk4oMcsCJUWtWBeOntF9eA67TJlkkgVJhvGOm11YuJ//Q1V Hy6J2i8BVoIXEhQBAAAAAIaFHkii66zEfWtgim7ehgIXuu1ZBceV2Kmz986OnX1w9rzfJQIAAABJ uPPiuzfpyMgNAAjLqWVuUIBlfcQsSgYH5MrWIIDUgIDYNcWuO3ZvwnKqbl954+zptoMAQPEzsc16 5nXZ+r2LbSuZlC5WH/NlxQsAGAZn2w5gT0i1dSlS36etarVZS4Qqwn3kuFQMsVhjZQAAAGAb6LQj cLfwPbYmQ5Ryrt0j7Q+dPxVOUsV8dvbD2Rdnh7cNHAAA7gGeBOmrs/OgvuRdKvbuFXsvy32zW1fM IiZucaOWfUUtwmvk3/jfVAtbnBAAw4e/53yi7vO8DilBi1R9ajsmsB02z7YdAACKUGSrlNJchFj7 xdoWq0/5BABslvAbjkbaE/w+A1ELAIimzmbOvlFXtM6yUOBC12nB35yf2KT+1jMLwJCw+g6sfoOU yEWlyrKv+Kw6RzRUaj827l/gOf7eOvvo7FHuIgAAAOw8nI/N+Xynqi6VA7fud5B1+nesvp6Svp/U eq6cyie08gdz9yIEbVcAQG/+CcDe+es4DQRhfIiILuWVlEg8AC9AKioaehAFDYhn4QmQkK6jDc0J 6RqKAwmJDh6AVzhRXHEcyTETe5Lx3Oza8SWxzX0/abT/bO9GSpy1d2Y/iFoAAAAABZHDyKu6k46O jung4HAlXqGIyIQWJRUrjrkuZlEVtVjQ5WU1rQpZXK1ELHTjb9uPTYt8Uejz5u8Kxrp9hjLOmzKU z4lxbpchjDM/xuq7sOJQ+26LAkELTeel2MSiFJyYr8QoCmEKFaRYC1eshS00f8H5v8u0OP5PKGax Fs1YUMRoRDSZXNB4fEaz2Yym06n5f6oKWqiYhRW00HZ7DgD/IypeYcUtVNRCGMvG3Mzv8/P1OWUa /ir8fSUql7YUtPCCF6aNdvi7G8IG+V330XdBi6Fffx99DP36++qn79/1ffWxr3521Yf1PpL/suX8 TcvaVgopqVeeFbSQmeVdTkXQYi5iFlSIXqyELyRPpeCFXkOvVwpaLK/P+fuTCZ3xvPJXvbDFA7af 5VBUc0MdplKmAhgpR0RyZa3zjog29QFJCFICAAAAABgekQO/JefML/h5pXXiH7lUnQa9w36dfWd7 xvaU7TXbvTYfFAAAACiRzV8kGOCLqWsTDGDbIkd5m29ibcQsUgEAUX0qCCC1+VOTzYijIIAoIABB ApvxsusBAOA4Mfm632wueMjXN7nv5O5F0fVzY/FtAIBu+dH1AG4BsuB4kmnPzYFtXeq+G80zm1pu Hpq6p+fGCgAAAKRo4rviHZLuBHXRcdseB2iOX9uydbk1La2za1eKlOfBOd+oECB9y/a49YgBAGC3 yGbR76m6CZKQepZKrXtEz36+nFq7iNYncs+L0jbPtLd9nvSfT7D/D8ds79jeEAD95gNtR9CiKf0N ZAVteNj1AAAwWFGL1HNa0/e/0TtrX5/rZxNycwsAwM1IvdcRTtm+sj3a64gA6CdP2D6xyQYNqbhP K1xxFdQtXNkemzonFS9q8e0+D0BX+O+rXzfQujrsb8fGVft1Bb1enX1k+8z2gu05QdwCAABuGyJg LHEr4sen70ma+sal3nlssp6Tsk1iV9qKWuTOz40hZRTk68AcFQDQin8CsHf2uk0EQRwf20kKJCQk RB25RCISHR0PgECi4QGoqHgMFN4gDeIFqBAFEi09dVpeAAURIWFwzI5vJzfe26+zz7lb+/+TRrve u9ubi3JfezP7h6gFAACAfSQUOKKDql9QFVAbZTq9T1dXq93JvMAidFEJUSyUmEVT2CLXanELUraw +w2/E5Qw+bsAX7unFD83pZTjhJ/dUoKfTR9Xx8RqQYt6LEhELKrlc6pFLebXZS064YpZiM1s+x9b zlTbzFlX+vhLlYjFP7uPOYXGnA4ORsYu6OTkmE5P35t74tQraCECFiJmwaUIXfA6ELQA+4AWtBAx C902mUyW6/24vFyWWWITieve8suxrKPXtfWRnSR8G5Q8YXsp/eNv3H//N7GPXTiGLvZRgo/7tA+9 H7mPjK1Qhdy/RDliYctr0QorbsHiFct2Fq/gZSxwIcIX0iZ9cDvZaD+7nPu/d3REdw8Pc0QtHhn7 YuyXcismaKEDqGKBiKTqOvCKqJn4HQvoCgUiIkARAAAAAGCYhBJOQs+AMbTIBaltxkSNJIGx8ztl H419MvaMIG4BAACgPd+oSgaQSZ26TgbQ9TaJAZuKWfjqsTZfmZsUQFSPFeUkB6QSBjBO1OSOsed9 OwGA4pxWJ5vRuOe777qauia6CUptLLWdzxcAwHDgc5InpnnctyM7DE+M8NvWc57H1nluTSWapiYg zb22+3z11QEA2+O7seO+nQBgC4wCdVAW/DwQi2vS41o+cXbBNyEVc0HV5Ocvjb02drtb9wEAYG14 3I7f/b467bF3ptQ3Dt3W9v3Q974YErOQMlfEIkfUwj0exjcB51uqJsl9QAAMk3fUPK+3DcZXdoeH fTsAgMP5GtvE7u2h75M53yVD6/r6BgB0h34ed+uCbntj7PPNuAbAoLll7ImxD7T6bhszV+DCFbeI beNbRuQ/Z6Ud904wRNxxoLb/u7xMf0fQOdZ62SLwmwLlT2NnVOXCvDL2NOtoAAAAlAx/w+HcFR7r 9cXwxcYlYvcUKXPGQXLi8zbJWUkti/UbixVMjen4/iZu3fcbAACy+S8Ae2ev20QQxPFxUKIIIaB2 wUMg0UWiSc1jUNDRuUK0vAJF6KioAClNSlqQeANEGhq/AFF87ORu7ubG+3Xx2rkz/5802q/z3p7l W692d/YPUQsAAADAv6n6ZepDZ2df6OjocXMQd5fPIhOS5pCtFrhYF7Poi1qs6OqqH/aFLKpWxKI7 ALy7jw5DTOHwdwFtLc9U2rkpU3lOtLMsU2hn3caqJ26xLmhRNQIWEreCFtet2EQtPKGtE6pYrf62 6S6+LmjRF8Oo69GiFiEOD2eu/A+dnp7QYrGg+XzeE6cQwQotZCHiFmxcJgYxC7DvyDuvxSy0STkL W1wul+F+zJPfClNo8QorZCF5bHy/xqot9Zc45H/79U/9O5h6+3dR/77co0T9+/A97NM9mAMliiQi FpKWnXnUXCO7kLSgBY8wb0QteMzIYhZUi160whccp2519UDVO2sELW7qd/Enx8e0dOPMhLAFO0fz IT/n1B0OfM9U7zMRwNCO2b7NhjZPX0smrEzclwcAAAAAAMaP3cCv83xhqA4tVOETuLDX2Q39Oi9k n6ne0P/C2WtnD/IeEQAAwH8IOwCIM4Acyl7aGUDHhzgHbCJmEdvsHysf6hBgBSxu4xTgGzdgvigM C1o8uutGAKD4puJD3ueKwn1CTp+Y46hk67PtQV8DwDjR8w8/CaIW20KcYkPk9NG+vJy+O9WPh8ah vrb52or+HYC74RdB1AKMi/uF6xu6QcmKYfj+n0KHfYEy6HGlTsdCRgtb6LwcPji7cPbO2bPbNhwA AApQSsxCwtx1jdSaRs5hRmzXkTxfWUpYkai/nmGfW/4HpP9nsaJXzr46e0gAjIuPVAvBliS2ZhfL L1UOdgtELcDY+D3g2tTcsI7H1gpj/VJqjAQA2A2+eR2Bx0K8T+Fkpy0CYJw8d/apiYf8Pn1iFvoQ flvus5DAhZ1j1ch7C99RMEZCv9lcvxi9jiBp7RNT0brvi05LfGbSfN2lszfO3jt76+xpxvMAAACY Fj+oXr/53qSHzHekwtR8SO7ajl3fSYUxv5VcH5fQfWMWe35fqMEYFQCwEf8EYO98dpuIgTA+UNLm kgMSXBG98g6VeAkkkJDgEOCWB+A5ynvAsbe+ABceAHFEgkPFqVJKF0/iYSdee3byd7PN95NG63U2 tjdRHK/Hng+iFgAAAA6N0iJqPSn2ItjztoJOT58tiEiIgAUzF7EQIYpKiVk0hS28VotbkLIq1r3c c0Efgr8LaOvm6Us714Xvsw/32JfvA+3cBLrP1r6b2kTQohaySAUtbjKCFtNEpCIVsFgUs5iLXEyV 6bK4nptYb56Tk3t0ff2dJpMPNB6PaTQa/b8vEbRg02IWcpTXRMwCghbgUGDxChatEBELOer0cDik n1dXNA2/kcHRUbmwGEA8m69N58U018VBw2e9zxb6yT4EyO+yjj4E+Ef53ddxF+5hE3X0oY37Useu 6snVoVcisdjFrTyDRfEJUYWYKUiIaEUUt5gJW3B+OOf3sj2Ir91KPtUKE7K6if+//sbyHx8f08PB gMgWtWDOaO7U/qOaZQla5BYj5hYlkkrrRYz64yktTNR/5tamfQyYAQAAAAD2E73BROd5BC2EVDjt fpKvyy+NSZuTzPlrvgS7DPYq2EuCuAUAAIAaDowgYhaMtRkgPa8y5+nR2gTA6OBJlmDEOhsDPK+t Kmax6saA3OeVgnkhm7ddNwAABU9Sf229yu4Pl+ljSmYFR7faQZlrSnkAgO2T+pM4/aOz1tx9Pqu0 Z1yW61M9/XIaZLTNPONhawxq3QMAAIDD4ska7019FZ5rwX6ix5j6XB8FPRaVJVs6MJVX2IIDTr0O Ngn2huCbAgDsFhHyvohpoe35rnQs+T08QoWe4EbrPD96gx95nx/lvmQNw7dgH4OdG9cDsGs4eLNH pNSa9879tr2kfUnJ/+cpF3M23fG06wYAkPDLed0yfZy1hsFzXal8AMD2yPkJJU3UnN/5RBC1AIB5 RHNhi0tanPe0TK/L1+l0fb/XiJpzrVTIx55RsE+k/gOdZ/kSBGtPjN5vXVFT4KJK8nPjU/Y1vKO5 gPZ7grgFAAD0HfbZ8L4Vnt/9HfM8vhudXsWfY63xa1ujt+yelTa/TVt5ln/Hmsspze145pIAAGBl /gnA3rnrRhFDYfikGSUVlCnzCtRpEDUlDa/AUyClSE8XRUpFQYcEFLRpEYmEREGJ6KNQIeW2iz3O 2Tk+69vOXuay/ycdjcc7Y3sizSUeez5ILQAAAGw7ocHTb3I7nZ19pqp6OhNZ8HeF3Qe669Qs3wku 5mUWvtRiQnd3/tIXWUxnEgv+CHhTp79chH5//N0HbV09Q2nnMgzpGIfSVrSzDfP9Za55rv/INTEm tHiol1Y4MS+18MUUk8mNkFbcenlObHFLjcRC7ttIMri+GHt7U7q+/klHR29roUVzT/KFFlpmAaEF AA4WWXDaSiY4XVUVfbm4oPuE1MJuV587Wlwxv6FbmLAf/96x4gwTU/X7qhjDh+H7Xj7+xt2Xv4k6 xnAMq6hjCG3cpjpC9cjRRyyx4HUewWfvNTxSiS0RLLSwGrVaamGfH63Mgpz0YmIlUOZZsX4KZumF 2N91tzihBT3eEw92d+nKPHP+Tostnph4YeLTY1Hs3JDFh4IFGHIAVWiwoc6T25JaTlU6lAcAAAAA AIaDHsSvn+eWkVzI/aVsTdYVG9gvg8v4a+LExAcTL8nJLfYzbQIAADBO7GSASxNfyUktLOuaDCDz YoPoS2QWKenEolKLthMBcpMDQsefmxCAyQHtOCA3ERmAvmCFFv8iv6WuqTIvN8kod00KXaNyZcfa AQDoHz+6bsBI+UWN3C1E7FmuJEonmeZEFqnre6g9pNL6OAAAAACwvfA7I70ulxLOayu24PLemfho 4pjcR6cAAGCdbFJmIfNTfXWpdxW8/hDIX0RkUfq+Qx+XRt8r+Nr/3sShideR/QDYJFZocUrl79hK 3uelts/13+v9QsTqAN3yvOsGAKD4E8jL9fXG+oxT5SzSn5wqEwCwOeRzuj4f7Tw5e/1YRmwLwFh4 ZeKc/HMmJ7TIyS74/+rQfroMmdbgXgr6ju4Tknmxdwk5yUVsjjWfWymRRSi+mfhOjdziWZsDBQAA 0Bk8To/H6pW8t5HpVF6sryM2vk7HOueslJaRSpf0Ucf6vHP9RQAAsDT/BWDv3HHbBoIwPLZjgwFS xn3cBk7nNkitSxgu0uUEuUDOkFZN2twgiK+QK7gzUqWUITE75k44Hu5LFiOupP8DBuQuyeVS0C6X s48fohYAAAAOidhqj9oxzIOrsmrkFxdvByISEtYCFCJI0YlTDIUtSq0XtyBlrb/v5t8GdS3+ngZ5 HZ9dyecm7NIzcl53JZ9M7XmdPp9Dv1lfb3fjmFnkgeOPjrSwxZI6YYul3++FJ3pjAYsHL2AhwhUS 7kUsejGLhb9uYdJZZgUteN39pnmg+/tfNJ/PaTabPRGz4GdgEwELFrOwghZyDgQtwKHCAhbWJJ5p muZxu3Bl5uXZWSc84d8J0TKj6zYvmNGK4IW3f73E9phcv2F5xCL//z/92vM3dfrbuMc+PMM27jFG +vvwO+zTPUruo0ceHbMwhXzPePEJUYV4VJBgQSfqxS1OlHCF7L9g0Qt3/MSnpRUmVj4d8udw+ufu nXl+epoTtWDeO/vh7I/KlghXxMQt9ACqloaDEm1Hrx5spX+e0Jbo6cdCbBAXhC4AAAAAAOpnjEH8 dmC+bY/qAf26/dkmwrF4Frf4Rr24xUeCuAUAABwKPImZF3KSxddLJgDocMlkAL1fOhFgWxMDnjMh wIZJhVPPGvqNYnH2GMhzM3UGADDoBdFLy3fK1xyqi1L1ZG7yUug+Nh8AgLq5nToDe8p3tR9rG+fa yLIN1dOh+jq0CGmsTi+p3y2o0wEAAACQQvqNYmGJE+wYp3WFLeTaO2fX1Pl0Pjl7VXgtAACU8ps6 H12pmMXY/R05ocISMYrnCFmE+kVy35P2+XPIuZ+dvXN2uca1AIxNiaBF7n8e8o/bshM6Vuqjyfls 4LuphzdTZwAARUjQYh1i7ZmSdg0FwqF2Q+pcAMC4aH9NzpfD4S/Ovm4nawBUzWtnH5z99GEpLykL zRVdZc5JpdfScI6AYH2tmDMKakP/N3Vc7r8dQ5clCmwl/WMTzpmIW1wRxC0AAKB2uL9G+m64H8e+ R1LhmF8i57uw/o+VOhbrOynp47HnpUQrUnGp9GJ5Cz1byr8T2lrQDgUAjMZfAdg7l9woYiAMVxAa RURCOUG4ASeYDQdgx5IFAnEJLsAtIiT2s+AhsQWWCBassuIEILFCoEkGXHEXXXbssrvTMz09839S qdvuV00n4+4p2/VD1AIAAMA+k8rM+Lh00Onpa5rNji/z/4oxPkl3ux/nKOeyFrgQMYtQ1GJFy2W4 DIUsWpGMNoG4XDNcXpfxk7/XA1+HZyp+XoepfMap+MlMxddx/AxjPt6FMOYlIhZc9uIWUr5oxCZW SnBiebnuhSvOlVBFKFzh10XYgvf7c0XMgs/RCmWIcIYlaPGbjo5+0WKxoPl83vjeClqwaIUWtJAl 14tpEQwA9o2DRnCCTQQtZF2WMxaycJyzEpp9svDlT8QrWLQi3i8lYqG3DfC51gnOPw0fd/n8m7jG LnyGIa4xBR/36Ro11wmy8TbPJinLSD1qnk0yek8LWvDTTota3GzqLhqxi5WsU6g44V+pvaAFNcJP J4eH9MO9e36zhS1ukR+Y+LY5lWhu5AQt/rtMbaevTiYcD6iK6+LEw3oZDz60khsDAAAAAIBpEE8U 03WpQfyp/fW7ZmoQf+2A/niQYmrCjdgrZ2+c3Xf2hCBuAQAAuwhPBvji7B35RAibnAwQl3OWGoRv DdYfUsyidkKAZaV7krp3MYgHdePR2A4AoOCJVmcV+3VpJ7q2mVbbW7pOXJ8rAwDG56uzu2M7sUOc Ubn9tt51c+1ySahC1+UELroKFlltOtpzAAAANfQZq9JlANN2TzLYP/hvHfcxEdUnprKELazjeNsL 8sJiz53dq3MXAABMODbH7crHqL7mN1Ipvt8nXleb2KiPoEWXvhC9ThQmPYrvgyb1DJB2/6ezh84+ OLudOR6AdWIJWuTo2+dXirvUxmesWH3Jb7Bejp3dGdsJABTf1XqqDSj16+m6mm259ip3fA7EogHY LKm4DZdfOnvm7GQMpwDYMh44e0/h9yUnZHGjsF3/vk5tzwlbEF2Nv2K+KJgSqT6Eg6g+9/+c+06l 5lnr7+FfVdbnsuyTs8/kxS2eEsQtAABgm+C5K9xGc99N/MywyqX4hSxTsdy4XGOl+SRWn4/VX9N3 HkuXGHbqXuTuIyW2AQDAYPwTgL3z2W0iBsL4hCS9V4IDB6T0ilSJG0d4ASQuSDwErwF5BV6A90Aq Bw48RNVrb1wQqZTgSexmOpmxvdtk2U2+nzRa/4vXWWW9G3vsD6IWAAAATgXPEVoODH8I9rZU0cXF yx0RiRSXAhTSkjiFFLaota24BQlbxfMe5j/CUDapZ9DW/TOUdj6GoXzHobSTGUpbu2vnw7GeraDF djxoI2ixjPnrbXujiEUSmFjei04QaTGLZIuY/jceFyJtocqmOixBC/t5MpmMgv2my8sXNJ/PaTab xbZvxClYrIJFLbSYhRS04HwIWoBTh/uc8XhsClokm06n67J/7u6sCjYvnFrQQtSfUkfyM5yuBS9Y qYbTYrTNXXkMm7b3vX5c4+Ov/1jOMQTxFpzj8OeRXnVPWJCCRSfiMyspR6zikQUt2LOIJyaW4Zk0 Ce+KXH4tYBGOLGixFriIYc6TChP3q6JjGa7/2dkZnfNzNC9qwfBi6J/BbkWzknCFJ26RHKa0w6I3 0S0dreTlsY5EDx/FnoMiHBcBAAAAAIbBzvAM7S5Eqd0QSGIJXMi6VipsvbOOjDRZNolbvAn2Mdir yrYBAADoL7xBLy8E4AUBLGxhOapb8RrH9iaLAVLaUuXnhCxqFwY81vm/tAFxzYIAK1y6jlRIA3ne EzaZAf3iRybP6xtkuKaf8frGUl9a6p+t9gIA+gnfn9cEUYt98k2Ec+/HuTK6j80tOLU2IbX68Frx Igv04wAAAA5BU/GKkYqXynvPL/jKdI+cT2orbMFpcmGCVQdviv4p2Otgn4M9b99kAMAJY4lZ1Mx9 pLAXz42nlcbhSnMYbUUtcv8pm2yARMaxllTHdbB3tNkgFIAuKQlaWL9xayy87f2dG7fx6m4C3nu7 B35RoG/ctPhMbu6v5j0g10/qOrwyAIDDkcZnUphUXIe/BPvaWesA6C9PaeML/z3Gpc+9Z7UiFtJy 9enxVR0mJw+APiGfNSkuabImRs8nWGti0jn0fVb6/87G4ha/COIWAADwv+F5m6totyqvZv4ml+aN bzSZ0/HGf/cpZqGPNetXvDTv+3nXw7uWZOQDAMBe+ScAe2esIzUMhOGBYnVICKHbloJ3oIXuKGgQ HQ0lHQ+xPTWiu5fgKipaKiQouI6aDtFsc3dZPElm4wwe20l2N8nt/0kjx3YSO9Gtz7HH/iFqAQAA 4FgJOUi/S110fn5Bi8XDci9hMabaqLs5j4UnOM6hL2RxdaVFK4o6rQnbQhaNSEazIbiU2Q73wVw2 qWdQ190zl3oOYS7POJd6MhvZwHbi7Pedtsd7/he0EBEL/9gXtLjZik2w8EQjQHG9FaooChGs8ONh QYu2GMa1uueN+RSLxR137W86O3tKq9WKlstl9USbTSlUwcaiFVrQgkNf0EJELQA4ZqSt8UUsxFjc ghFRi7/rNT06Pe1fWC1aURfYHEu6nydhh9/oHDbIH7uMqQtazP3+hyjjNjzDIcqY+t/6Ics51jJa HnX1/xOJi7ce1cJK4sG3FbRwxiIWpcgFC1pwOgtVuLAUuGBBCzmmtuJEOTtbC1qU93fHj09O6I/r i/6KC1vcc/ba2cf6VqK5YQlaiIkAhpynnRNJxSXNP5dUqJ0PLWdFAAAAAAAwPywnfkvwzLpeL4hh Cu866dOSF1pO/CGnft3NZvtC1QYUT6jqOz/r/PQAAADGhBcDsIjF5/o45KSeisfCXS4GSDnlpxYI DBWxyNngST+fL8wReyfWO9Vg/Kcfr8auAACK2MZ5mpx2U9KHCO/E2jKrLjoPADAuobmj785ejlaj 2wVvhJjaJKxvH1e33bmbkg7pq1r9frTnAAAA+jJEyMJKA9NC+ps6HgotLGEL/76SH/r+/OrsOVUC F2+c3c+vPgDgiGFBbxazuPTSYt9BOs8a00+N2aXmN1LzGF1FLaxvxtj8SM53Y2regtHtv+9rwPyg qu3+ELkHALukj6CFzs/9zfSZP+wzZpMTB/sFm5yCqXGZPmVLrD1Mzf1Z7VNuG4W2CoDxCY3Z8PEn Z++dPRijUgBMjBdU+cLrsc6YoEUXkQvrutBaUyFnvBWAqaHnEfw0ay7B+ju31mPzuXe90C9Hx2PG 57K4BftPs7jFW8J3HwAAHIK1s29U+VH/VHldxxpywti4rKQVKt8a581dsxKb++kSxsagrbqHnjf0 bqw0nQcAAHvhnwDsnb2OEzEQxyfSfRQoEhKigQLpykPwAki8AS9AAxJCKfICCImnQbr2WmrqO4mG lieggeqKkGBnPXuzvhnbe9lsdpP/Txp57f2arM6+tT3rP0QtAAAAHAJWQLQc7Hrr7FXuQmdn53fW /OW8FKC4a1SLVFTiFstawEIai1/IfHUeCVuF+/bXVxjbgvoe+NodY/FzE8byG+Fn93Tva3O8JyVo cStsEQtaLGpBiyqtxCmIFkKkIhawaIpZ3IpesC2E/QvXWpLF6emEbm5+0Wz2nubzOU2n0/p5sZgF C1qwmIUmaMGCTAAAWotXSJOCFlzm+ZtejLtmEhYJD5kqcddYufrXEK9ontQ8t4WgxRAXU9/H64/B x32+fh/32Iff0MU9xuDjId2ji/vIaCMvUrFksbsgPsGqEEfhf9BaSSKIWByF49cCFi71ghZrgYuw 7ffxSruNFX3DMT7/+OSEHh0f50QtPM+dvXT2Q7jFwhWWuAUHTckAqdSE8EScJx+PlhI1OxFW4BYC FwEAAAAAxkVpEH8p2gcxFKVaUP+K7HdYTeiCy66oCup/6uyDs9fOHrTwFwAAQL/4xVyug2nB6WSU lQa25z4G8FhB9NYHALn8pmmuzMqnxny059X2o4BUOcjz0Nm7XTsBgMAvovfb2Be3C3HdT7U1so1K CQBtYpovAIBh4xfe+LJrJ/aES7GttYkpSt5zU+13TuQi9T4a+5d79wcAAAC6ZvgfBoA28LxQnNdS C03YIvd3Er/r+EXRvzr75OxNoe8AgMPDz4N8o6ZAYapPZM1/WOP8qTG6XP9P6wuWClhYfUXr3Nz9 79unjGNZZZ7bek592YWzF85mBMB2ua+gRdvx8pR4jFY/U2NAVLCt1UnQL8927QAAEdp8o9ZGWO2H NfdnzRFqc4ZaWc4fAMB2kWM32ru63P5D1RjL5968A2C4+He9c2c/Q17G2qeM+7xxzL4Wg7+K9sXX isdW420y9gEwNOJ5BFmmzSFYx8u6En+vvaRmvZDHy/pm9ef523A+hsUtnjj7SJXQDQAAgG7xQha+ rf0elafGMuR2as5CGz9NjWu0GQO28puIWWjjxCWCFiWWey7WsyRlPwAAbI3/ArB39rpRA0EcH+W4 KBES0NHR8AJIPAYUFAiu5AGoaagQHXkF0vEAkVJRwwMAz0BBcwoNkcghmx3bE89NdrzeS+7Dd/+f NNqPs3fXlrxn78f8IWoBAABgF4ktkn2VOun4+JT29+9Vfn/FmNphd3scC09wWoQsPKGK2awWt6it rEQuOGyFLFqRDHEK3tY5H66K3XZUvzyG0tahtPM6DOUa0c6bpxSnu4uXcCWdFrQQIYuiSVtBi39G lKIWqyAS0YqLKr8o/jbHXCgxC33ubK5MEdHwODwsaTr9RkdHH2gymdB4PFb/Q+WlaIWIWIigheRD 0AKAq3D/IiIWEuo4h6PRqDr219nZopVc1sXxUgtYNHnSDknntH/ZDF1IYNcd/A+9/asof1vqGIJ4 C+pYbT1zK+oaEQtJy8ohEVsqmvfDPRarCNkiYsHiFiyEwXm3GqGL6jc+R+JUz9SKCkU1c9sIWlT/ eyH+4OCApuG9tIewxcNgP6jVyegStBCTqvUGvZhDYZtnF1ZZp8M67i1WBAAAAAAAw8RuPtF5pH5L vQvazS7aOZAWs7DCFjZuF/PbdBE5/mew98FY9fhpsBfB7ufdBgAAAEuCHal/oXpDwB+Vn7sZIJa3 yGYApjC/ewvvUw6XcjcJ5JTT1Ra5Bu/6+m4KsPGuPJDHs3U3AADDVxXPee5LivcZ3sakPv2Z12/1 6bMAAMPg+7obsCWckC9IJKT65dg7sNdne04Pvb4+R5BNt7UrDgAAANwk3iKjzd8sAGLIfJBNx0IP 63xKQluPDu1vv4O9DfYp2Jtgj3MuAgCwtZxTPQ/ymdrvuK7vntS8hw275jxyxulSzo36pruc6ufO fcSuLXbP7P2yfb51tKnrZWe5d4NNnDIBuC7LFLSIPWveuE7s3D7PHpk0xmo2i0frbgAABm/MOvXu E+t3vDK8MWXvnFj5XecAAFZHbLyG4yxq8TrYnXU0CoAN4znNi1ro796YGIV1uG+/AbpEMDyRDCJ/ 7BWAIaGfH52n5xBsnkXvr9bPFEXiUtZeJC7pUuXH4my8D+ZdsI/BngR7Gex2+nIBAAA4sOg4z9mw kMW5yu8ai9Dx1BxOKs+b++gzn+ON/8bGi+0YcM6elVT5fcy79j73kxJ5AACwFP4LwN7Z60gNA3F8 tEI6aRtEcRL1FUiAaGlO4qPc1+AJaGh4m62AivpaaihoEM9wV0F10rEHmY1nM/HO2N4PJTH3/0mW 7ThxnEjrdWZs/yFqAQAA4H8nNWlaytgg/TpX0dnZky0RCclrAYrtQBuRCha1YBGLVuCii0XcwhK/ aOulTf3tfcf9Zjh88/fhqG1TfWbqba2lnYdQyzOincdl/3Zu23m6fvo25Dv7UydsIYIWq5DWYhZ9 UYtOrOImiFloEQuO47KbqJ5VkaDFfP6HLi+/03K5pMVisXkWDixUoQUttKgFxyJmAUELALbR/Yv0 MXGaxS2Y3/mNuClctLn2r8Rx/yXiFSJmoa6j2YxKqGGD/DHvUcMG/7XXP8Q9aq9/qPvcdfGWoe9T 4z30jKNZELFY/99xWRCy4HIRq1grSQQRi3vhfBG64HPWAhchzWWiLtHbyTecw/nTkxN6cH1NlP8v PafWaX5FnViFCFd44hZ6AbY1ySl2DuvF2vr1WDFR/6PCm7yFiYsAAAAAAHWix33xMW9xWWqwbi2O ISMtdXlj2JzIhT7/VxM+NOFTE15QK26BBd4AADA8shiAhSyu1PFjLQaQuDRdGnIb/eYm9u86+X8X MQtS+fjZUu/AendxmgqOg914O3YDAFCwIfpbwXle32kd26d/TW2glWoHGed4xwAA04A3+uXv8/tj N6RiuO++UHmvr7TK9DFvbJnalDQXvPFsrl/32goAAABo5tQXRT0W014YAEqJ/VLaZ5QTthB/EqMF LWJhC86vqL8JlTXG+dGEN0143oR3TXi0zwMBAKqHN3X+TK3tTTZGSn0DxWWeHd9Ke0LXKT+H55c4 VNTCy6d8IKlgPbf3Dks2H9TzCeTdsbDFsyY8Nc4H4BB4w8kvTlnKV7erfd2ytVtCF5YdvkTcwrPF w64zPi/HbgAAip+Z8tJ+wusL4zKKyuJ8qf8wdw0A4Dhou4381uLxu6TZj8jCFu8Hax0A0+Uxtd+q WthCrw/dRZxCz6e/jfLeNZZdNU6TUwbAVLF8CZqcP8HCErjQdYkPQo9vc2tg4utY3IJFMz824RW1 PoiHhe0DAIC7jqxd+Up9Qc6UvVPnc7bcOE75N1L219x6Ec8mvE9cWublPbtN6tlz75KMMgAAGIx/ ArB39rpRxEAcn2RJohMNLQ26N6C6Dp4ACRokHoCCgvehy0sQXU9Lg0RFhwQ1EkgpUIjugue8czs7 Gtu79725/08a+WPXXt8m3g/v2H+IWgAAADg2PMfp96VCl5dXdH7+aCFiIcbERbub/Vh4gtMiZMHm CVXc3orARXt7FLqYt0QyZGHw5pjtcF8MZZF6YUjtHUpbh9LOdRjKb0Q7N0u/drbHfGJRPeZFjqCF hLNabILjIjyhxShE0MITsuD8m1COQ973pi7zbxHGMiJiIXXPlm2yVNUJXVz8pbOzPzSdTmkymSzP BZsIVmgRCxG2EKELtuaehTEuACwiWiECFhJKvKqqxfZf19fpSsx16SSUvZv7/XopYiHlxGJj3Pps +W1z6Avwb7t+nOP917+LY9yH37CJYwyhjcd0jE0fp+VRx/Xy82CdriTN9z1qPPlOa5ELEbFgcQsW wuC8B7XQxWJbLYAxq7eJGMbySy6LXdT7cHo8GtHv8Iz6PS9sMQr2JtgHanQycoIWYnJoPfk6tZCw ztP7kgmt82HKWREAAAAAAAwb68Sv83LPhKl6Wlpv1H421U74Nq2d+q2Dv03PnXrYPlFcPOBxsLfB ngd72ONcAAAA6AdPAOCFm3hCwA+VX3JCX2cyQCpunf/1Np32nO9TDvrbELXITQDoskCV9/u9MJVH znawPuNgT/fdCAAUelE9i+37qWt2X+uzQFZuu9cOAMDhw331K0WxSbAaLGjhLYiqsc96Xa/LfRYX TS2Q2Oea77XViwMAAADMk2DfOuynvzOA44L/5qsKW8j3JIlb/yip75TS2GedzxR9u14Fe0fxmxQA 4P7zheJ7m9yzcu85uXF6L/TGzWy663uf9w6YEixcVcSi9M6Yykv9xtR5tPm5a78XsgDny2AfCcIW YHNsQ9Ai1S9T/bEkcNGlP2Jc53AZ77sBABh+qnjpXi1x795v47Zs6bqZ27fUPgDA7vHGajgOUQsA Gl5TW9RCv/t6YhbWj94+85fKeMIWROlxVwCGiPwPe3mpe5PXB3LzYe6omfNNKq3jun/m+q6eA8Pi T1fBphT9bl4Ee9b3BAAAwBGwayELCUvfObpYFxELO17shevmpdpAlJ7L4p2P0vm04BkTALAX/gvA 3vnrSA0DYXwO5a5BFBQ0CAlWVJx0vAI1D0CB6Kl5CHQ1T0BHT0t3p3sBnoKKAiFdA9IenngnOzs7 /pO77G4Svp80sp1kHSfa2Ik99gdRCwAAAHMmtUKj7gB+SxWdTIvF6ZaIhKS1AMW2RXELjkcRi6US r4hhFLZYbghfSDrmS13+8bzj+naYyiL1wpTKO5WyTqWcd2Eq14hyDku5nJv9PmtBi3XfkIhYxP0i ZLHsBCai2IQWn/irRCnERMTiTzIeRTE2f7staOG3H01zFOwXnZ09pfPzz6HNW3TXz0IWbCxYwUIW WsxC0iJ4AUELAMqwcAWbiFkwXMewNU3Thr+vr4v5tIIV8qxJHaVDu239w21L5L9L5rAo/P++wP/U y7+P/OdyjiHyn8N9mNM5dn2ezvtIBClCe9W2dRzSWhVCxCpaJYmViEWzOl6ELviYVuBiFW8FLGjt kdR6LK3aRPEwenRyQg+Pj4nyohYMT6B7Gey7KpYIV6TELawDoufwRCp+pH63cXuckGjzhT3loAjH RQAAAACA6SLvcdYxX7bVOPJbrNCaJ7gm+XjvsdpR36ZL8R/BPgZ7EOxVsDfBnhfuAQAAgDp2KWQh 8V1NBrjrpIC+EwVycXv+0nV496PPfSVnPxiOD4cuAACGKxUv1c96223r15qFs3L1m1cOAMC4sf0E HL8kiFrcFn7H/pbZ773r6XSfeju3CGJJvMJOZPXq7FxZAQAAgKHIjU0M4XgE/5fxIe+fNu2FgqS1 sAWptPaZ8s5X+ob9SnGhdBa3eE8QtwBgjvC32tXKOJ77/rHpVB9+qp+/tl+uZnyjJGpRErFI7fPC 3NhH7rpK98tS699qz8PCFlxPXwR7ksgbgBrY8fsTpcXYSv/r0jNdI2JR26/jPbu5ZxKMi2eHLgAA hp/lQzpq+4pTdVGubiodg/oMgMPhvZen+lp4we4vwd7toVwAjJ0XFOePamEL62Nfa+J7b+eW3jjH 6vxt+2nH/8mk0d6CKWDHEvQ222bV/K+9+TBkQv28cahFLm7MMbo/4J4TZ7ugKKj5mKLA9utg94tX DgAA88UTssj1Hdh037EbCWvGc2wfR2m8JDXGUzPW02esplbMglTau77cPaFCPLcNAAD2xj8B2Dt/ HSdiIIxPJHQXXYEoUlBT0PIACIF0HQXiCegQj5GOFvEA9xTAg0BFhQSiuI4TBdJJyS2e7E5udm78 Z++i7Dr6ftJox/bG9q6yjtex/UHUAgAAwKHi/RHjxb3NZXR29omOjx9sNisXa2lI79vNwhMcFiGL Vpyi6YlVsLUiFtdHm96KYPRFMpqmrbqUN8X9wmvZpF6oqb611LWWet6FWq4R9dwtfj374z03BS1E xEL7WtBivRWbaEUtVp0AxaoTrGD/sgtfbsUt2jTxRfBipY7XpkUtYhwdzUI+53R6+pSWyyUtFoue OIUIWoiIhRa04HgRtBBRCwCAjwhXWNMCFxyez+d0fnGRzcuJ7B/Fd8QrZiKmEaxx8qphg/wxy6hh g3/kP34Zh3ANuyijhjpOpYx9lbMPMQuGf9dEaGIT7tL4d0cEKTYqESxWEY4iYsHiFixSwXH3OqGL tYhjiE+0FcNguJx1d22zrsxHJyf0J/RZf+SFLXjD3W90rZORErQQEwEMvfg6NvFQx+lzyRzt5EMv DgAAAAAAHA67msjvLYTRi2Ckn0smzjvaCf124r4XL/7fYJ+DfQn2mFpxi2eEif0AADCUMYUsYn5s 0vyV8XMLAu4iaFGyKCBVjxLz7hkWBUyP12NXAAAFt9nfI2mx9jjXXqdsaBvnlWPT7TleGAAwPb6O XYGK4Q2R/3V+aqxF+yV9ZNtfjQlY5DZCHNL+e3X1fAAAACDHPuekTHuxABD4+zBU2ELQG7rpMDl5 NtQXwfDqoU3ELV4FexfsYekFAQAmC4+tiZgFUzpmFRvTFz82HmffqW77P0dMeHaokIXnx8pJvSfm rjt2/zxK2nqbrxgvgHlDbXt9P1EGADF4zJ0FLX5F0kuf+dSYTelYTqmlntWc2esC++XF2BUAwPAz f8oGry300ry20YZTbVMsbwDA9LDPp/Tj3xNELQAQntNNUYtG+XY+vRWssOtHY2IW9vPeelMh994N QA3I9ze2AZOk2e+7/e57zx9zpc61a2Lkc405x773e2thbPh3sA/BPgZ72dmTwnsAAAC1cxshi5xf csyNYQwZy0iN/Zb4Q0UtUvE6PVf31L2giB/rO6JPCQAYnf8CsHfuuk0FQRieIOIUkdykoqJIj2hp 0lPSIB7ASpfH4FHokBACpaEMNQ0FokGpeQAUgbHY8dmJ1+OZveCE4yX/J4326rN7jrznsrcfohYA AADuGmmn7wsaNlXJcnz8aENEQsQtBtGJdQGKlVEUqBARi0UUsFi5g7DFIiNsISIZi+tyd51eNqkX uL491ZXZ9fr2Us9t6OUcUc+bZVXPtdisoMVK2EILWsyvBS0G99eGrQtY/IzCFZtpgztXxuXMY/k2 BwdEV1ff6OzslGazGU2n0zVBCxGt0GIW7KaCFpIfAJBHxCtSE3ELYTKZuKIWnG+trSmxCpdYxlLA QgQtJKyOf9v0LiSADf77P/6/KON/OIebKKOHOt6lMsYoR55YLFKxiN/dLDohyhGcLmIVSyWJKGJx P+YXoQvOsxS4iP6FuPyb4L8X/XJstqP9fToKz9QKUYsnwT7QsAmvVEuEKzxxCz0JUU940gPI6WRE In+hdzqhilTejcvsxAMAAAAAgH5omcifpre82KeT+fWCGW8Sv07LxWs/H+drsJc0bFTBY7BPCRP7 AQAgR62QhRcuTVjXfRVWnDXpn6mZUO8tBmhZBNASVxOuMet8vWtCBT9VxIPtYUGLh2NXAoCEj4X0 msVFtfdXb6O80n1Xl2PVxwoDAHaby7Er0Cn83n2RSd/mXl16L/U2LC29N5fe760wAAAA0ELN3JM9 x+/l2+2FAKAW/l+0CFvo/1K6YVs614qS/OmxW/r03gZ7R4O4xSlB3AKA3pBvs4voL/VTed9qnpvr ///b77tWMYs0riRk4YVL35m58ytdtxL6GWDF6XKlL/JzsGfB3hCELUAbvHkab7z8w0lvbfde+80J VPyujPPauNWe07p655TLA26Px2NXAACFJehj9QV7WGlWP3LNvcnLg3sVAOPj9dfoPMxlsFcEYQsA mJNgr4N9j2FL2MITp7DWj2qxCus3e6os3X+aC2PNKOiNXF+SHkvw8qdjCFYbo+Q4uk2m62BqRCx0 OI1/H+w82INgz2lYB3PYcjEAAKADPtEgYvGF7HEaMuJyYw9Wek0/burP9fHWWG5cZZt1K9uM3Xhm XQPL9eLISAcAgNH5IwB7568jNQyE8eHESbfF1XSIV6AGdKKlooCCZkveBOlaKCiQrr0HAKF7CgqQ EA0dojytaEBaHXt41p7d2Yn/Jbu32SzfTxrFcZzYjhTHccb+IGoBAABgH4k5Q8fiXpYudHb2gQ4P j8OC3aRMFjH3sPCEF7mghSiFCFVosQovYrHcpsUsrtXC4j4Pne+uL/zODGWRemZIZWWGUt6hlHMd hlJHlHNT+PJJu8zFLAtaiJDFLOxbQYsrJWRxpQQrpo2wF7fQQhar51mhjKVvcJPR6Jomk690evqK xuNxqJd/77BQBRsLWFhBCzYIWgDQHRGxsKIWss+iFj8uL+nPdEojF5aG5haLUcwSz7SIVqh9EbtY Ea/Q6XQ7y/E3VN9lFsNfFH7XF/gf+vW3kcc+1GEbeWzi+vtwH5BHt3xWPOjCO0z2Fx5B/N6jpcfe AYtUuK2IWLC4BQtVcNztIHQxPyZCFu6dOBe2CGm5L7rw/AvCGRy+e3REE9eH/f47NcdpDjsVnTj7 GIojmhspQQsxEcCQdNZZisy+xNmJ2tapSofhkAgAAAAA8H9Q48hv41LXyJntt5K6nr52zMF/Rk1B DB1nj3P4F/l+9gV5x/7nzh46u9Pi3gAAwL4SE7JYd0KAjStNBtBx604EyE0AyDnyd50IsM6EgFS9 7T3K3dsYGLe5eZ72XQAADHph9FIb0KV96mKUCduy1rx3AAC7yee+CzBQzlW4TT87libWL61ZHLEk UlS7WGmsfKV4AMB24bb6pO9CAADAmnC/oiRsoUn9w5J/SBKWtHLNg8YZ6W9cfe578uIWj529cHY/ XRUAwA7AiyTxeBr/G0l9b8X2Y+P4+lhuTKzLmFubfxltRS1yaVPfhanvxFL9U/fRYtt6m76m3df5 cXm/EIQtQDtYQPpd4lipPSiN17Qdt0kJWcTiU890jcXql4sDm+de3wUAQMH+IzLhpU0bkOvz2DSU 2NackzsOAOgP3ZdP9dVZNAyiFgB4njl7G8J2rqeNq/HHj/XzrbgFh/8m8iNqfnsDMGRiY0x2TCk3 zqTPsc8Ro+fA6DQ5YQv7rKbmxsSEMH46e+3sjbMnzh45e9DifgAAwC7BYw6fgn0L+zXjkqV/Dbnx BtnWhu34w0wdrxl3Lc0/6Xq8dKyN1dwjKoRzcQAA0Cv/BGDv7HmbCIIwPEZJEdFAgZAQTVoaGkpE 45aKio4fxR8AhZKWtCAqCjoKKAGRBho3gCzZhh3vjT0ez+ytk/jjnPeRRre3Z+/uXXybvbnZfSFq AQAA4Cqhnb1PKTuOihwf3wsX62bhCRGgWDZqBCpExGLSCFjMt1nYYlIQtqBZ+Yxux+4v/D4HbV0f XWlvV9p5EbpyjmjnRVj2+Uj/3OtJPz33V82FLUTQYtyktZjFoqhFFrAQoYph2h9Nt4viFiMlbpGF LIhG0/152RIXuQxf0qOjEQ0Gn+nk5CX1+/3Z9RYxC0/QQkQtRMwCghYAnA8RsbBiFgKLWvw4O6M/ w2EWtchf8gry84xYxWzfphmut2kHrfFe7sIC/Osuvwtt3OfyN1HHPpzDZdTRhTZepTq2XY+OLmKR ChaiENEJUY7g4yJWMVWSaEQsDprPi9AFf+ZARC2SjVnIohHHmDTpaWRSUzbbrfR/9ObhYU3zeXLz h2S/VLNEuCISt5BAKAlaku95L5h1EJWenP0v2BItPnxEgVoIWgQAAAAA2B+iQH6NHf9535F8G8yv g/E9ITZdfjROjY7ptCduIYH9HNT/nPK7WQnsvx5fEgAA2Du+U16w6SPlRQmYtiDz2kkAkq4JdI98 F20TBKLgfC+/Npi/7fOrLvKrJzC0nVd0nbzravPIOQ7Wy41kz7bdCAAUvAgf9+VRPx71L/Yzpf7s vIudt1nUVgBAd+D79n2yR9tuSIf4QnlibonSuLl2bOz13bZfrx37rjJut+cAANg+g203AIBKap4J NvH/BfEvuwv/XUrCFpInlIQtrAA70WIslR7rXFPHyaR1vZx+m+xdsgfJHlNeYAoAsBvIexG23+aY 56ey6VJeyddfepaq8bVdhpiFV86qghZtPj5vv3QNyTmu01HsQbRQrsQG6BgBsU/JniR7kexu0AYA /iZ7RYsC0pq237b9/bf5ZDwfjRWqGDv5Y/P9sSmz5n6Nzs2mwea4v+0GAKAoxY9Ivu03orFUNFby jnv1rEI0DgEAbBbru5E85itlAbGHm2wQADsKv1t/newnze+bnkl7ohTeM0at+AXRor/U+k7t8zb8 5KDreD4m+/uO5qFo9DsE757T7xnkfYLeRvWskq+3b5KdJrtDeQ4Mi+TcXvHaAADApuH3MyJk8Y3q /ADRM37kpy35bWvSpbzIamKqa0Ur2ua3tNVT4xf29r3rYa+jTZfyAABgJ/gvAHtnrONEDIThIRF3 hw4knoCOhoomDS0NJR08A+/BK1AgpCuuQhRXIvEKVNBch0RBSQmBhGTxZO2NM8zMeve4Szb3f5Jl 72SxnXDr9Xo980PUAgAAwL6hbaLSbC/aKjo9/UCHh3dXMX43U7UR95eFJ/g4CVlwSkIVLFyRbLWI xTq3xSyqJlB4akfmid0M/K6Dvl4eQ+nvUPp5EYbyHdHPzj3ZKNfdSrZlvDcso7hF1YhK1PkiClpw +U8szxVBi3kUrZhH0YpZtP9ubOvz8rSIwhZJ0GJB1jrUeHyDDg5+0PHxLzo5OaPJZJLdb6qVUAWL VkhBi3QMQQsALoYUtNDELW7G4NvT+VyroJ4MaiIUcpzMjrn+KrZTpc/4mNuMtsu6mocuJIAA/6j/ urQxBPEWtLGb7bSJWSThpHTc7AyKghRpF9GIhStCnkQsWNyC71Fsa8Qswn1rzPPVKHKxEsKI5/K8 tNk1GIUzuHzv6Ii+z2b0ZTr1vsatkJ6F9IrWohWeoEV+TnoZ7W0+lDbpoO1tVPQ2LwIAAAAAgP0i n/dJuxYgyJsfapv583Jen+aAk9vkxn3pACCFLHJbyvN6OPAmByW4Q/XGfnaYe9Ty2wAAwFDhoOcs YsEOAT+pv0OAtenfyi1byXFJKtms32XDf6kIhjyHlHJfhwAyyta9Fms0V8vTbXcAAAGP69aY7o3B nmNT22elAe5km3lfZB8BAMMiXzf4RBC16MJZVrbm357Nmjd7YmyWiEWXcZ3IHrcxlgMAAOhL21qH 9Szh/Vuw3/D/uxaEimjzvZV2rkSKW1T0r1hFqsdKo+ycfC/WR6qf19+E9JxqcYvbbV8OAPDf4aDM fC3y++Cv4jPvvmKtY1m5V5bPVUtxTmmQI/ncVypS4YlalLRVsu6nlb3fUn6moY33cn+CVV/+HRKf Q3pM9TP5A6ddcD3hoGqvYy4pGRus67zt2rUELaS4hSd4odXVR+QCc+vt8XDbHQBAcE76PKlt7NOO S84tGae0cYuUYwDA1WPN0+X1mfbsvgzp/dV0DYCdhwPRs++oJmbh+YJawfS7plS3dj+VdviQgiGj rSMlW54T+X/r1nXK9hHp15b0hZHiNJpvjOYLo+XfQnob0ruQ7of0hGo/GAhcAAB2AfZT4Xcz5zGX QuOM94zfVu6Se+W+axX5mq9lK/VHaRO48Nrru66i/Sba7yfLVGAHAICd4K8A7J2/jtQwEMZ9u9E1 lCeqExUUKyFtj/j3DFQ0PARvsG9AxSPwCrzAQUlx5UFFQYUoAIni0JHDg+PbyeyM7eRus8ny/aSR ncRx7L1bx/aO/UHUAgAAwP8Cn5B64e1B7obj47sb+wVHSHgiClBsmmsEKqKYRd0IWKzDIGxRJ4Qt 3FX+RG7j8PFs/J4HZd0eVN4plHVqn2sfplJHlLPo6a34WtBiPVe0FrG4bMQtgqBFEJioFeGJIGrR FqiIohW/E/EL1xa0uBB524IWVXXg7adbLu+41WrlFouFKWgRxSw0QQt+DwCgO1G8IpoUt6iqME3z 6/y8/0NiW8lDET+Yz0NrsaV2dR82hR+7oMXU8x/iGftQhyGeMfb/9SGfg2fc/HO4VxGJVNTNmJVE J+haVIW4EqnwRiIV1KutmvRRzGLeiFnEtCRuMWvEMeom/s8rsMmb7PbhoTvylhG1IO57W3o7dZvC FZa4BV9ofcmqY/34zJ0X+cejhc61O/alTosAAAAAAGD6WI78nNJ+oOXMby3Akf1SzaFfClekxC1S 4Q9vb11YMEcCF+TUT879y4J6AQDAWImbNcUFAVpbva0FAda5kuPrLApILQAodfzvshCAbz4lN6K6 7oIAmUYD8zC74eWuCwAAgxZ/vRPnrPZZiu7weK59zbWrqU2yrLKl2jC0bwCMF22e4HQXBZkoJDR3 lknTp422hCzkcWqTwy4bHmrtvBUHAAAALKy5JG0+JPeeSY09wP6h9Un531rbjEreO2Pn+MZvMc3M iKdMbuJI4Rdvr1wQt3jq7bm3e6UVBQD0gubLaOxFv4t8ENes94U8Tr2LUu+t0nm3LmO8ElEKbfyn xa08rbnAeF6rj1bn3GfolHQpZHsf70n5J/BNAGUZv3t75iBsAdq89/bGhbZD0rUtsL7bmvgEHf9h oRSrkGHJvE6fOZ1UPxt96WGAqAUYG99YXHuvW2PyLu2jds3KP9dfAwCMD9mPj+eIExf6X48GLREA 4+SJC5vRf02kKRGn4H7zJb750kdfjruxNhTsI6l3U0QTmChdGM+/f3TfTMR5vjJ/HvL1L13Wwnz0 9snba2+PXXjPPvR2q7D8AABwE5A/XFyz8lm5nhrvd4mn5ipy13JzE12sVNSiVNwid80qg1UPed76 XJwRt/qD6CcCACbBXwHYO3vdKGIgjs9FuiSU6CoqIngAirQgiiAh6HkCnoUHoEYp8wSRCC08AgU9 FDSIGnFKtHjO9p1vMmN7T5vbD/4/yfJ61uePO63t89r+Q9QCAADAlNAmqDTb21JC5+eXdHR0Pxzc TYmLB5p7WHiCw1HIgl0UqmDhimjzIhYb3xazaJIDw30e0s8xlgPqGZT1bkBZh8VY6ohymjluXd8W tGiCoEV67cUf4lpGLzoRhSeugxDFdRCpiGIWHP67Dqf3vPBFFLRYrj+/cRtRC4vDQ+6jftLZ2bOV oMVisdgSs8gJWrAdghYAdEMUrkgFLaTAxXw+X8X9s1y2SreR4VTIIr3H+Ti39RTHuB0920M/gH8f 6Y+hjFNOfx95TKEOXeQxhjL+T3kMKZ90Nd0s9DExvD4NNwhSxNV8Byxa4fwbFq7g+K6/Wu0MYkGL IGbB99m/CQIXKyEMHtNy38fCFiHtKJzB1w+Pj+m361crhC0eO/eV6gQt0ji5hYhk2FJRDBJ+I641 GwAAAAAAmDbp+E/aS2PGUrraJpkDw1azKN8Styj5aV4scPHRuU/OPSC/sP+lc48q6gQAAH3DGwLi QU2/jDjWpoDaDQHWwnVrwXtNOLVLcYiSoIRl73ITQM3GAK1OVr1z36WMo4H5mP44ce5J34UAIEET Lcq1J7k22GoT5eFYjRJu015qbZhlBwCMg+99F2BEXCTXufbbQhtnlsa5NaIVpfY7Vz603wAAAHbh XvCtuRHL1mZ+BUwb/q1z762sd1bp+yR5+BvR9vujGD+mXRK3SO/PxD1+93RJXmD91LnXzr3aod4A AJsoZPFF2Ev/vaz5M2nLza+VwjX/w6z/druKWdT4bef0cv2w9b1J2vbVufZeS0+uA0jryJ/h9viF c++de9OyLGBasIjFB/LthsQaX9Y+79YzXHKWoEWNwIXMQ3u2rXp28ayC3TnpuwAACHi+v9T2ae0d Uf2YQq4JSX2ZlwbaKACGhRyfy7G6PDD/nXNX+ykaAIPnOXlhixS555Po9v/imv2iNQIXsk+15lIB mAJavxTtbfdNx7i1z5kmctEotplyTyuf5sfrz+TnRznNpwSBCwDA3fGDvIjFt+BL0WDZhlpzrta9 mnkDK541dyvD1vuPWkEJ7ToXrnk3k1vbR8q1VQfrO7J+h9xccc4OAACD5J8A7J2/jhMxEMbnArqr KWiRTqJC4gVo4DVoUtKd4A14Dx4BUdMjXUl3DwANFXQ0J+A27KztZHbWM+vd3CVx7vtJVvxns+tN srZjz/iDqAUAAID7gJyIek0FauLn588ym3avooDFRoBiGCgKVCQxiyYKWGxeg7BF4whb0Pr83VVn bDBcywb1DOp6N9RW1xrquQ21fB+oZ+8qvbgvaNHEOt10eSw0sRG0+CfifwehL2DxJwpXDMvCqyVo 0ZDF2RnR9fU3urh4Q8vlshO06O5ECFqweIUUtEhpDumYINQxr08CAAS0iIUUs0hhiqiFFrNYi1PI MpEmFrNIaQ4ifVvULiRw3zf4r73+uzj/sVyjBvEWXOMwrzPnGtKaaMFCFPH/H4tOcFlShViLVHC6 7aN4/PmQ84SYxYMoZpGOZXGLRRTHaGK884SL5+b8x6en9Ij713FRCzYWYgOinzQUrrDELZLjXTJk SrdjLUif0NAR2zJsIur/KbEMs2CwCAAAAABwvMixocwjmiZoIY3nZZ7cMKjEuD9nxG+JW0wx5pfx H2342IZPFAQueJzOG1m/GLlHAADYFb8obLaSnAK0QwBjGf5v4xDgGblPdQRgPOP60o13p24ANeca VvDubY5DgI57eWC3vNt3BQBQsBCb117k2inLQaq0/dtG6EfXEe0aAMfBl31XoBIuKYzfPbyx5Vj7 O7ZJ4sopLxkzW+09OXEAAADA4gkFUVav78uVSaw5GDLSGqscfVk98HdVsgFVydqVXJsi6q9HEfVt pxbifdZv98TJ498+b77PG6q/pLCp+tPx2wUAZOBniZ8pXidJ6yNjc+u5uJXnze+PrQ+UhDlCFrlj px5f+n+TaLh+Y3021udJmfJtkG1/rh/Q9Uj1l3ayzFsK62rvb6FOoD647fhA/kZrJe2CfE6sZ7xE 1OImE/cELcbELXLPNdGwfvrewH54te8KAKD4rtLeeEfn547T5yoZP+njvfMBAA4TPW6XsJ/cVRue 77RGABwmLHz7uQ2/jXJLtMI6Lmd7nzvPSuXn+lQIXIBjJTefpH/bem2hdD7K8oUh6j9v2g8mnTMn eNGQ7w+TynN+MNznXsZ0EreAwAUAYC5s88b+Kl/pbkQsUtxbc8i9evHSOQi5luCtmYzll6y/TLXP k8KgWiS0ZI5GfzZkxK1xHsZ/AIAq+S8Ae2evIzUMxPFhhXTalZCooIWGkjegh45uH4HHgStASJTX QUFDRcsbXEWF+Cg5hBAdkDs860wy6/PHJAvZTfL/SaM4E6/j5G4drzP2H6IWAAAApkJqMDjkUamg k5O3dHR0fbOAeWtecEKQfS9yQY0ohQhVaLEKL2LRbtNiFhebcr3Jeba3XRnLAvUM6vp/GEtdx1LP XRnLdc67npfH5sqCFiJkcV77W0GL1n47v6RZwKIVq9gWs/ilxCy0/VHbqtnmBC1Wq3M6Ozul4+Mn tF6vm/slghZVVW1MhCy0qIUc43zybAIA7I6IV+i0FrbgNPPtZyomwnSSpvxGtEIJXug89I/az0Nd SH3IsscgQrDP8oc4x9jLH+o8cxdvGfo8UzlHn/NsRdzxZ7lPWe830T61IIVEAC1cnqsiblFvF4GY hQhcVLVvk5f7t/zcY2GLutzm/M53e7mk766f+yEvbLF0tnb2jGyCFjqPvKhOBSTGfFoUg4LtRZCO +QAAAAAAwDzQ/cDQn+sn5gL4pV+a6sPqAP5YQP8VKotb5MQswgD+sDzxs8DFK/ICF9eoDeyHwAUA YEh4AsB7aicEfI3k6RL4n0qngtW7TAqwBs13CfrvG+BvmQBgXbg3vJaYIEfpHpExTQY/GJaH+64A AAqeJPYxcSzVPpcW17IssmVpH60LZhFdbt/Q3gEwTk6d3d13JQ4Yfin4Wu13bftibWmsXY7t56xr 3zesK9psAAAAu1AaJ8odyz1LU+MzeG5NE/675t5Z9Yl1CgUuOK9eZEp8utzQFhFfmPeHszfkF667 4+yBs3vObpqvHoB5souQRem3TekZkhvnir0rSP1Wi/lzAhR9xSxy6VR9UteXug+xexiy6zO41Nbn Pidbadv1dbGowRdnj8m//wfTh9uMF+TbjxBLO2Hpo+a+pxYxi76CFtbvueU7in7zsNzadwUAUHym dDtRMovAT6pNsrZXFPHn+iAAgOHQffYwTbTdn2ffU2fPh6kaAAfNivyY4Etj/lSMvcVin099RwGY OrH/ffGX3inotOQrzYWRfHpOSyhsUZrrInNiQpGL2OdjPha4eFenWWT7Pvl5MDfstw0AMDN4jOAT +fkq4ZyV0hhjbrwx916hy9aato5FhIIRXd7rxI73FcboWu/Ql7pPZEznfAAAMBr+CsDe2axGEQRx vMKaQPDkQfAScxTxFcT74hv4KD6Gdw+LD6E+hBAvEdQHkCAERARhndg13Z2prVR/zGazu737/0Ex 3T2T6Z4OO91T/fGHqAUAAIBdRzp9X5F38mQ5OXmSFJFg4YlBzOJKGQWBiihi0QUBi+HohS26jLAF XQtcMKvaRLyVDeoZlPVuaKWsrZTztrTynPtXzkUf0CBmwXQhr0UxC39dFLTgoyVoMYhZLApV/HXv +3l/XBS3kMIXXsiCBTE47u8/D3nbghZcDcfHc7q4+Eyz2Yym0+l1HbFIRTQWr5BiFlLQIl4DQQsA VksUrphMJr1JQQs2TmN+XF7W3pCkMEUvZKHyIxbKiAIXnI+Lx/ANsYsln+ku2fb778KG9a3ffx15 7MIzrCKPFsq4T3m0lI+cOcQiFZ3rX/ZtHx8pqEK4+D3XRvG5KFLxL4pcCDELKXDRrxZiIYsgjtGF 8FUQ0Iilfnh0RA8OD4nyohbMM/IbAJ3RTeGKlLhFnPwUJx9FkYvUIPWB+DtZPdaRaPEjJbUosLRY EAAAAAAAtI+cmG+l6T6k1Ue0rsmZ7L+mJt7XTuyXR0v4QqbJ9Gi/nH1w9jHEpcDF/VLlAQDASFjE gjdXOSe/OEAyZlHA2AUBMVxaEFCzEMBKK1ntpP3bxnP5l8qdqgernkil58JUkQ7WDwtanG66EAAI 3lO+Hci9f/VGWrXvYPk3uU3RZf5E+XehFQcAtAX/hnksC6IWadh/8DOES/2+ZfrK1oaJNf1ea+PT Uj9YP0NNnxYAAADQ1PiNlhEgzflodNgqE2iT+L/TY1bW5lPynI5Li+IVnbhWjmlpkYuYLu1gRJx9 wF+dvXH2gry4xXPCmBMADG9C/ynYlxDP+cR0vPT9YvmtrHM1bdfYbznruyz1rVZzzIWXaVtT9ZSq R4tVta/y3a3f8al8dNmsBW885s/jb2+dPV1JScG2wr4ZFhz9I9Jq/Bs174TS71f6aSxRijGCFvqe JV9/7e/aenawHk43XQAABLxBZa5PVerb1PZDdFiTytO6JhcGAGyWXH/9nbPXzh6vtUQAbCcvyQvf /g5xq93LIX2aqfOUuUb7TnPf2QDsGrKtkmmS0viCTi+thdFrVuJx7BoYLXJhXWetgWH75uw7eZGp R+THIngNDOb8ALDfsIgFj8Gc0zAWw+R879b5mu/31FhD6nzOP5sKp/yi2ldBKl7j/yj5PZa5X61f N5WWqieqDFNFOgAANMN/Adg7dx6ngSCOD0gnnSJBcQUfgKOnSYtEx9cA8Ulo+Ax0VxwFErQU0PHo 6Gho7xq6q65AcCRm57yTrIfZh3Nx/Mj/J41s7ya7a8cZW7OPP0QtAAAATIFYMFfzPFfQ6elHOji4 4xfxJm+14IRQH69NRClEqIKFK+S4FrFYb+NiFtVq4XBZO1xvt8FYFqhn0NZuGEtbx9LOmzKW89yP djbjQHFBCxGyqPfr7SIQtvjrRS2uAjGLtZBFLVQh4hZ/fNpvdXxFTfGLhRe2WKzKj8Wk+NQPD3/R 0dGSTk7e03w+D54v1UqwQotZsHGeWPgdAMB2qGQBbyVCIVsRvGAuLi/NMlaiFbn/ZihWoX3iSMQs dlHHvi/wP/b276L8qdSxjfKncB2mVMeu6tmmmMV1WV5sgpFRP5UIVPg8Fq3gNH7jFeGK20rMQgQu Fj5tKd9j4SZfzvUMZ18W13s8m9GFe+c9ywtbHDv7TmWCFuFnVtUaRpG0UBSD1LZS+1YaAAAAAADY PzYZzJ9LD8uNDeiXwfuxwfzWwH49eD8nZhG2ISdy8cXZV7//gNYCF/cj5wcAACl4ATOZEPBD5bWZ GJDbj6WVTgQI00oGy5fapmIWpZ8J0ynxmTbnlbteVLhPBemgP5723QAAFN/of1+R8u3aL8YW16rU cU7AIuZvdd1WuzTwfQCMA6uf6Ly/5gwe7gz8kMjPvRvG3sctf97WrOeB5c9L2woAGBbirwEYKjeJ HxHZz6lUXuoYTAPt9/TvbI15iqHHXIXf14IWcu/douZ9Wnq8pGa/1idnn33aI2/c7wSBC7BPsCig iFjwtiSOlIvB67SS2H7uOWXl5cRi28TqcnldiFlY16Dkemq6ftaGPj/0qaGPl23oZ+V6CPx5Xqzr ibMXzp512mrQB9zv+prq31lI3b+b+ALrv5qL12hxi5iIRU4Uo81/Xp8L6J/HfTcAAMUZpZ/7m75f 5N49Yn2QGvgwAIaN9Y5u5Qkvnb3aQbsAGDozqoUt3lA8dmERxi11mhXXJLUfjodPgTmjYOrI/W3N hwnjTTqtpNySed26nrbiFqm5MtYcmLB8tp/O3jp75+yus4dUz4Hh7b2C8wQAjBMWrOD+l3NqzleJ +beSeGoqL9avUBKDsNJKjnXcQfJLhSxi+V2LV6TiJ7lYb+yapvapIB0AAEbHPwHYO3sdp4Egjk8u OV2FQKJEkVIg0aVHQrwBNU+DRJWKN6CDB6CnPTreAJorETQHHbl84LG9yXg8s16HfNn3/0mr3R2v 7bXvst7vP0QtAAAA9BnZyfQ6cy+bThiPn7kbeBciFpTvIRx8KU6xWKw2Ihd3d6uNrRCyWJXCFquI sAVtBC6YQ24k3pUN6hnk9TB0Ja9dyef/0pXn7G8+q31BW0GLbf9RXdBiKYQtlobwhBSzWGRluxSy mJfCFX+pKngxr4lgbEUywrV9QYvRaJC5PzSdjmk2m9FkMtm8DxayYMeCFSxowW4+n+diFiEeBC8g aAHAYZACFsPhMBewkOHgrq6u6MftbcoFq2FLrEKJW2xEMUp7Ht+hTO/CRuqHvnYXRAj6fP1j3KMP z7CPe3Qhj+dyj2Pdp6vPImcPXZQiFrmgUxbncFCOGAZBC67DlsIVI04vxCykwMVmpRBfi69J9dk+ zOPLy9wliFrwomReqPyL6sIVnrhFWFgdbhtELrwB7IE4T74eyyeqNgC8iViYtAgAAAAAcH8I9b7Y ZH6ieh1xHTnHWtCmnazLepP5B044ZfJ+TMjCylNI+y1z3zP3IXMPaDux/zlhwyEAQB1eFCAXBDSJ WOyyKMBbCJDqp0yEj03+b+PaTOqPbdDUZN91AYD3Xrx3RolhSrCD0/OIik0FNdYCYW23FgrHFit6 8RTfyhPoH/zt+Cni3jehqbyNbazlnecdj5W5RPXy0bMBALoJfyPfnDoTZ8onKur9TEodsE2d2RMm ipXfsU0Pm8p0K69WGABwXtxQMedAYrUfdFvEC3ttFyts+ToM7ifcnpH9R8Fv26cj01HkemQcB/2E /76x8SrtkwqH9BdURc7FCmGZVvrrxPjAsGsb17OvSzuLW7wgCFyA/sIbzvP/O4+T3DhpYn1gVhqr rWWd5x2T9l3GPVJELHTbzrOlCFjsImZhPWvsXXk2Mo7vmzZlvM5HeB+MJXDB57zN3OfMvcvck/1m HZwAFsd5T/6GbG3LCm33+sj1b3Yp4lqQIiZiocNr43yvjLDyG/Ot9wCOgx57TB1zDH7KGCPa7qAN X8n/9ut6kS77PGGflDqTvo91T5kGANAtZF1d2j5m7lXmHlJaH3VT3Dtf27UNgHNgUvre93EX9G9F H1tH4k12APqI1+8kSflNhOsMlC2MOSypuu5Erk2Ra2Bi4hZ6rYtc86LTSJsO63z8pqJ/9ksZf0rF GpgpFetgAADdhcdfpIgF71eR0r/f1CZvGjfw2vxW+li/rBe24lafQ1shi1iafdmb8tj0vN57osQw JdgBAKCz/BOAvXPHjSIIwnCtX/JKZA4IOQFCxCRIzjgFISkn8C2IkXMkyDAHIIKAhAAkJDIyciw8 TO107dSWu6trbbyeXv+f1OrHPLp3drenX9U/RC0AAAC0TmlQ1/KidqPT0w+0v39vsZn56AbBCWGI a0dLIQsRsxDhikHEYvTLYhad2kBc8ln1b4pWNqhnUNaboZWytlLO69KljV2nTivfR6ycq+NBlwUt RMRCh7WghYhO8HyGhEWM4lyJWZwnMYs/2fB4jQhbaDeKWpQ4OJj19/tFx8dP6OTkhI6OjpbPQAQt RLxChCzYZ8diFhC0AGAziHDFLAlKWMfHDg8PF6IW5/3/cn93t37TTB03S6IVnT3HE70I0rqQADb4 b//+m8hjGz7D/8ijhTLepTxazWfFIpnvy23NFF685TiexC2WihApbSFukYQrdoyYxa469jelL0Qx aHXmeZbuxfk8mM/pd9/+/eELW8xpEEZ9RTFBC33OMtuMo0KaNb7WfmfCuTQAAAAAAHB30W3DXFqp PVkyArBtVbtYXxbS28X9nRO3i/pzC/1raXahf2mRP8d5cf/73p3RuLifF/az0MVD51kCALYX3kBF DALEOEDI9aujhgFRo4CIfxWDAG/x/JQW/cs5pOKl8tr0Ujznl8Le2AnGVabP0+SXDOOtkZ83bid+ xNlr7P1yRo65cT8yYbCd2LrH1lmemEVXCJeELGobqOfqSzLpAIDt4cttF2CicPv/zDlea7NH2tel DcQiQkW5cK5subKiLgegHV7TIMDLeP0Wjus+R65vsmfS9ijWb6n1XQT0We4etXddtN/h9UFsXjbf 0jmgXfh7LM07ad87P7feasekd3RZ0EI2ppLfo54L0/ELdU2ubLkNp1igSAQuWNziMQ3zTffXeDYA TAkW//tMw1zJJxrFADW1fokX9vzasUhfrOZqorAR0YqrilfU3p25z1Z7RrnnZdnEe1TX2V7dnrtO /AvnvI+9e9a7l717fp2CgluDx2JYYJTfmbW2Xmmsw6sbSv9rb+zdE7LwxCxKQhiR+iNSF3rPBmyG t717l8KlOT7bp87NN+o+vO23l+Ye5ZqZ8tF3B5Zafei1QUp11LpCFzZfWzYAwLSw7XWiy+13HWZb OW9dTWRtzU4m7I1N6/ccEd51YHOU+tfrjlFcFfs712mRfjUFzwGgZey7S6evawujrxPbE/0/zM1B 8PkR+5eI4EXEHqZkEyPuW+++9+5Nij+iUeQCdjAATBcWsPip3NfCeeuMnXpxbw6hdmydtEjcG2O4 CSGL6PFoGb202jOkYJgC6QAA0Dz/BGDvjHWcBoIwPCjcXZWCii4FDUhIvA99RHePQMMz8ByIHtEg HuCka65CUNNAdyc4B2/s8U0mM7MbEid28n/SatdjZ732+da769n9IWoBAADgWJGDS6+pcSINmc2e uyISLGCR9nMsxSlYrOJBvKJqBS44vejELmxhC+oELhL7Xkx8LAvUJ1DWfhhLWcdSzm0Y0zWOpax+ OVfHhGJBi6rNpxG0aEQs7jvBCRa1qCoWsJACFXfCfueIXfzptpt8taCF78d7cUF0e/uNLi/f0Hw+ p+l02l13Eqpg0QopZMHCFimw6EXVqjhB0AKAfmEBi8lksgwscpHiRBK1+Hx9TX+1qEW7ILfKrLG1 eS7a/BetWAXburSwd/u8vI1y983QhQqGXr5D57+PcxzDNezjHLvI/xjuA84xvPN0XjjpPVTHVSvq l4QneIbGUpiCBS1Sezal6/hxEq0QYhbLWSAsZMHCF/VxejUI6aH09PycnpydEcWiFomX1Dj7XNG6 o64nbsGOTZ02B8UftOXk65XbY8REq50XzykRzooAAAAAAKeJbDdKG5E9+aVkgQnpOJ/QC/1E4ha6 OZ5z6vcc+7XTvrWtJ715zv0f6MG5nwUungX3AAAwXtLEABavSPHP1m7Ve5HzeLStHdQt2yax5/xe 6jRfEvqYGLDNhICSa9rkPlLGbh0Dxs8uJrhHz2fJfis/6a+G5+000M+LTOcW1rJsJeIWubpUl4do /XnE8wnAuPlFTdt3duiCDIyPIh29r3W6pI0diVnk6vOoHe21q0uvAQAwTLhv4O3j/bpOKuknl/Tv E3oxeB2IUJ+cKlHfxXv/ReNAJQt5E62fExwXVr0n67pHhi2HrsNkvUYqT/39Sde10l4Zx0dxCmmh 7q91eE+NoDoLXLwquA4ADskNNUIWaRGlH2qf9X/ojSVF6VxdH/W79DbbKrGvUseVfrMoEagoFbjw zhv153S5vXvi3T9to4xtX3j1vXWcjuV9k74Iv+vwrg6f6vC2Di92WF7QH6l+Se/HL8qun4foGY+e k1zbMxpzvxdxqZjFrgQtovrPu0dgXFh/T6//I+s82Q71Yv4d+u6nTVQn6rrPSmtbLsjzWnarbACA 4cPvE68tZr2j9NiJN6ZMatsaB9f7rHeb3If6BfRJ1BfX70v9G+v3Gv3/QQXb2m79zwJwSkTjTaVz YWQeul8VBT72f8UtrG8K0XwY/Vv9DUTWKVdtYBsLXEDkAoDDIQUsvlMzV8Vi0zF+b7u0fRK1+73j o7FZvb3J+G0ubDOnpfQ4Iv8bTe56ddrbzqWpwA4AAEfDPwHYO3/dqIEgjE+CctKJ0NIHHoNXoL+e joIHIY+RmiegTUGDhKChQSg9RHQUB8Ls2p54bjIzu1biU3z+ftLI+8/22ne7Xq9394OoBQAAgDkT feSQvC4d6OLiPZ2cnLZr+Q7WCU4wnV9aJ0KhhS0GMYvOLf23xSya9rid8Xl2t/tkLgvUZ5DXaZhL XueSz7swp2ts+sVoHzrDPb0VI4Qchn6nXUELFrL414dLQQu2P2IrxSq2vUkxi61wy33+9iIWUizD F7RYrxu6vv5M5+dvabPZ0Gq1unmusFAFi1doQQsWu8hpeB8AwLRIMQsWlmBBC3bncpzZpnK67t01 x206h44YzAuvqL/nsAD/1MefQx4P+fj7OMchXMN9nGMOeVzSOQ7lPHKUUH7mtW1P9vdxWXjpWPiz oEXD4hYsWpGfo1ngIh2jbevmfZL/US98wemkmkQ7krY/Vu5oOVuv6VdqD38vC1s8T/aF6gQtZJqb 0xpGTpg36doabFUagAUAAACAAwN9dqCSvmsoVHZukxhhOr01oF+2VzNS0EKLW+jB9t4Afm/AfjSQ 3xrE7w3st+wTDYP7T2l3cP9ZcF8AAA+TnzRMDPjaW81g8NLkgDETA0pbdpcmA9ROCNBx0YD7KYQs rHSk9ony7cVH9ynaRm6qCAfzZOoO09L/PiMXl5H7ybYJWA5eHa/r0xrximgB9Nq6Wf5XvbwCAOZP Ls9XBFELSZ44fBnEe+35MebVx9ZCil681xa28kPKDQCYJ6V3BF3Oa+qiI7WVHIswvRBKI/xguXjP Hev9pfQci55hZPitfIDDgX/TIyOMRJzsQyHlJtqtq7xxVzlNtKhUY8TpMCve2mp3FlP/luxdsifU fWvK9iLZ04r7BMCU5PeijzR8M5FY9W5NX7v3LlW7jdxRWNQWKoVP4bbORSoN+/X1WNdvbb0wMuL3 iW7P6vrbqtutBdsZ7Wc+JHuZ7FWyN9TVseDhcdkb1zGluoX9pbpkbPm3RCc8i8QsPCELCFosG13v cZiXVvtr/9sZWU/Kdq+VB7AMov9PTb00VtBC19E6H5a71F4BAOwX+cyQbXUrzusf4fpD9jvLMD1e V48n1ug5cXoxb50GgKkpvYOUvuXq49SgywHmgwIQo59hOpxEvFV+onLFZTAyTlMjbuG57zIfxgrX fk/k4hl1IhePnesHAIznN3XzU/I3l6tkP8gWsKhpK5TSRN8JSvGl93Xr3d8LK/VpeeE1dp9CFmPN yrd3/d69o8AdtenQ3gMALIb/ArB3/jpSw0AYn4Xbk66iAYnqJERBxQPQUOxzUNDzQJQ0bE1LQYME JaLjXoLiQAKKOxY8XCaZ9c44k/3DxrvfTxrFcZzEm01sx574g6gFAACAQ0QPaDxL9qRvh/PzR66I hAhY8HZZanEKEavQwhVXVxxeNEte/92KW6wKW1ArcMGMYYKiWiaoZ2qb+J9BXrdHLfnchFp+Yy35 5D4fKWabeW2p6we68YvNxSxu9hFBC15aghZamCIXtBAxCy1u0aVbFcXgc1y3QhrWNeWos7Nrury8 oPn8Nc1msybvnaCFiFZoMQstaCGiFxC0AOD/Ic+zCFmIaXGL6XT6L82v9LzeKR+sE7No1peWRvp2 HyVokXsseXneFWM//iFMjI/jH8c5ahBvwTnGeZ59/Bapc1ikYtH0P7DwBKcQ5YjbImjBbdtGtOKE 0zeCFryd9z8RIQsRvkjptIeP9hpi7p2e0t1kAVEL7kt6l+wbrQpXeOIW4pjbanNQebB7QqsTSuRO Tjr7urpexwELAAAAAAAcPtIWtBz61/0gpuQ4/ydb1878Vnx+LL2uHfa9+IVxDi9/2mTSaR33PdmH ZB/V9RLn/seNAQDGg3wccKGWP5y0nvO4Fxdx8ve2e+kjjv9eOOr8L9u9yZM2dfrf9OMAyU/pd5au V76NgmEKxIN62EXnZX4PevHecyHtivzjfaLl9olm7E4UYDje/aPDpYlkhghZRCbVs/Ll3esAgDqx 3uvfJ3u6txyNj7kKe23+Uhuyrw3gTZzYV44PaV9HQLkOQJ3ocjwf/4/0AUg5kvfNegIX+YSYltAF qXVwHHjvC169N2SCbyqErfVS3kD96LIuj8vbtV56i1JfjIT5WFrY4pYRJ+kWZE9IJUtv3EqH2a+M J/bm8aaXye5TJ3LB400QuQC7RsQrZNzkZxNvlauR9yEv7MVZ7ZnStkgfbMSs9y9rPVqX9a1H68BI /Ri5rhb7riujZfsk287o8tYSs5hk8a+SvUn2PNmLDfMNtgNP3vY22ScaPj4bLSesZ6f0bEf73NcR sogKWujfWHrWresC6sT633U4v18nRliXhd6YozXeiHf3w8YqL/raQV6Z1Vc+Rto8eT4AAHWi2+k6 Tpa6TsrrLF03Wf0xfefV/rqWeFMe1qDOA9vAqr+sd5Gh/pHRcw0F34IC0CHPwtBvYUp9VxNj3TOd Ro8f5N/B5N+39IW9fa1zRYz5TMsiFyxu8ZA6oYsHBACIwH2fPMbCwhVfkn1twkK0j68vXV//qQ6v 09cqy6H9saVtXrqIRb9poYH7WPnKj1PKd+Q6WUvqibfSAADA0fBXAPauXkdqGAibW05aaZFoqZCg p9sH4A14B2qehv50jwDSVYhXoLmOAgoaaCigudMtkMVOMpvZuZmxs7csyeb7pJHtiWM7exf/ZcYf SC0AAACAsUL7IKHpXuYKOju7CKenD+qDzTtpCCcITZpLqENJbEHEFZ00xBZdvqoWup8OEqezxGX4 PzGeA+objKm9aOv+MZZ23gVjecZht3N7r67p54nEp+n0GxKLZp+L4k34hxFb/G5JLYiEYpvQoiGs uKn1VXXDyCtWgsziV5BkFinsSDOoTdu/aQrm8+uwWFyH8/M3YblcbvIlIcKKRF4hCS2I6CJJNwYN YNABgAmBk1jQe026hNlsVoc/r67Co4eC1oLYeDpWHnG5JbngpBVMJwktNqLgGA5SHzqhxdjLP0Qd x/AMh6hj6P/rh6wHdQy7njVPp3lom954DSeiCpZOhBbrltziPpFZxHgiuUhhTWiR7on5Zi3xBZFb cDaJ2vq1LSvV+3g+D99XqxyxxSLK8ygXoYzQgufZVKtIMHTcUDeIUBpbeQZYAAAAAAAAAJBgGeaH sPt8UjOU1/SWQb2mtwz/pbG+TEvDfl6GVrfME4x8ybD/kl1Phv3PWIjDhwDgMCBnADqIiRwFJPoY /2u6UmPzvs4AFFo6qZeG9DLvPqTUyJ8fwlJ6j/YMJY4AfZwASuKhQA8cD3bd2NTe95J3zzoY1prb ANNCSd/d54Ct3AGyub6W62UbrTQAAOPEZT7LZPCxFW8N0Ke/5mnZH1t5vD58V6db2aej/waAcYPW C2sR57qSvoqvUfjeKQ/pGj8gk3R8bxeYJrz/M+3w3tzhmNp45Y1l2M+ZBrQ9Et7nhXC7H/TKsfZh Tpy41d/KsArb36gozOnkt6mk/xrlW5R3rY5ILtIhUulb05PsLwcANjj5N0mCtw4qSWtxT+eF2hjj Xesj1rrK20Ozrmllees278BnT689Ow+9uKcbArT+NJef97eVkzeV9yPK6yhvo7yK8uKO7QX6I+2z JBKLD6Hfd9qS/sV6f0jnvaO5w9w9wopSMgutLtkOq/253wcYH7S/5a7jGEEjnrT8DYDpwZtj5PpC bf3uzWt4ndbcDQCAcYDm5RQPIi3j2vzrnohL/zY+LlljVbr/RMQp1PzpZHkA8C+RW5No839vD0Ar e1+ArygAbI9fXBfCbTtNOb5Z3yYs35ecLajmByO/FeTiFbvP8pXJ+cNo60buF/Mpyuco75mO/GCe BhBdAAARg3PflC/ttdK9+b46b87Q53uBto6Xei205jDeNY8gQpsf7WITZ+1TWGXLuNceS9fn9wqF cQnM3wAAmCz+CsDe2eM6DQRxfBJ4KeA1FNCix6NEuQHiGlTcgwPkClyDW1BRAAUNDaJENAiJIpKf 8cgeMp7M7K4fIYnt/09a2ftlbz68a8+O9w9RCwAAAFNDG19eNuF5rsL19ToUkRABC86XrQhUaDEL EbFohS12YhZa2ELydb1W3KI9D3OOC4uf9wL1+4ypvWjr4RlLO/+FsXzG82tn30bUNq/u9m/ahd73 BC0q2glbVEZ0wopZsIDFVolVbJW4hQhdbEmLX/TryzGr7vj74wGnrVYLWi5/0nr9mDabDV1dXfXE KXihXxas8AQtOE0ELyBoAcBp0aIWLGih00TU4lew0PbfhcFVP+teybr/1eIVnpiFxI/Ud4/h+GNo 45SPf4xzTOEzHOIcY2jjnM4xtfNE59CedUsWoahboTkWnuA8UY64I4IWKs77FY+XnYAF178rQhbd lkUutOeO9hBiHq5W9ODigigtasG8aMI7ap0TrHDFjUmToB2Maurra3gT4wvafzmlDrZE/QebyEkR zosAAAAAAICRe8KcQ7/eTzn06/qeU7yX7jn2R+IUtr511q9Nnj2Wt5BQ1A5SdSgox3yh1sFf4pfU Ljz0RG3vBd8TAKCMb7R7MeBzt//blEk59JeWGeJkbrepvCFO7iVx7Xjv5R3Cyb+kDqm4tx8F77tI 5ZVsyYlHdg/YQ4BHdE3buH1JXxMtLmNNj/r+6VwcJcD/Ixonor7VW2DGLqIVLapl+3Wvj0+1z4sD AMbPh1M34Ix4S+m+MNVPl9xPp4Qson65RMxCty1qOwBgWujnB4l7zypRv7Sg9HMHl9M2TzmftYN6 dcE8yI2NdvzzxCuicTEa68B8kf+A7fckrab+vA2ptFJ03yh9oN7X25RPlvyXrUjQ0pSzc1fe/JYO VuSC55meUjvHxItJ8TzT/QGfF8wLmT8RAfCvQbmcDajE1p5KS21zad7zz21DTogiJWiRK5tLL/0s pd9Tap8K0k+Fdy8b+SJ4dRmxs2tfW71YroWvg9dNeNOEV9SKW1wOajUo5Qe1/c172i3wJni/a8n/ uaS/0HE7L2mvTc/G7t23lghYVF3dKnHMqB1e+8mkg/Gi+zbvfjVVT/9XdP9m80idI7qPJFMOzINU X5nrD6Pnd++Z3ca9Ntg09G0AjBNvLKudPDtG2bFM21+s2EV0Xs8uY8c6jHngGERjXcouMMTvsvS8 AIDhyHWUsz9578REdqsh776k3oOxdetg3xOviIQtSuYcorIU5H9swieTL+/AcHjUhGcEwHRgG6eI VciW0747ZYeO47e1kep4qU01un/PbVO2V5ueSjvEeyyePcyzs6beXcndg6XSct8DOeW9PG+fCtIB AGBW/BGAvavZbSIGwrMVTRWJY8TPseJNOPbGiQNvwBPkDXiPPgZnOCMu9IZAXDggIVFxIW3COt7J zg4ztrNB7W72+6SR7bF37aTN+G/sD6QWAAAAwBhhbUpYute5F11evqXT04fb+3tbiWQTjJiWEkko NEHFarXekVtIMgtJgtESWWzEe7mebjg0DO+C+jTG1F609f9jLO08BGP5jMNoZ3edSBJasKzXt9vc qrIILW52pBZEHG9JKSKZBZNT/BHpbpzLRIKLVfOum877I2mGjbOzqn72O11cPKflckmLxaJDThEI KzxCC84DoQUA3C+YxCKIJLaQMpvNtmV/XF/3qYAssood8YXIq5r2bJR9HjuRwNQv+B97++/i/cdS xxjIW1DHMOu5z8/S8Q5qyJQ4zV6qoV86EWnewAgkFutActGQWYR4YIt40MRPGv0un7psEluv2VBf U+/5fE4/63Hy5zSxxbyWlxQPxJUQWsgyu2oNIUcnD+qRCrVjlaUDAAAAAAAAAAs5h/7UGNNy6JfP W2PanCO9le89p5365WEAy7G/MsposQ7YpYREPCzYvadIfsd5T6h17OcLiEB0AQD/gg8JXFF7SOCr KuM58O+rsxzOdTp1OMBzVM/pUw7w+xwGsA4EpBz0+5BXHColn6Xke9JlSMWt8hawLgLk4P3W5Rqe 9/9uXbJljVVIhDoOHB8sW6VtuGWrZWhdqrUx4jpcq7pytjrXdgAAxgs9np4q3lGcZzC8saW2kZbe ssO5C8K8/EPG67nPAgDA+MG/90qlvTmJnIPoy8UkPEI+b+6Cecu0YPWLMu5dHJybt1jPE6GPA1pI e6d12hZ6PlDSjuX2oPSlUhyWklvIkPehUhdNeW3jMiTSv2r5QJGgjss9ruUZtYTq5wSiiymCCSy+ UEtkoeGtnZeWycX7hNY6lLdG1Ue8+ZSlz83DSnW5uZq1X5P6fsjJ13Eq0A8B2qZzWy2fA/2cjGv7 epup91stbyj68r6o5VUtT/dsO9BFIK24EsLrTCV/v5K8lH3QcesSM+93XbpWw5Ijt/DW472xLim9 9/m87wgYDyx75/Vr1l6jvARcwjoz4PkpyRA4flg2NGUbLVtopTdKXzLeydk1AACGCavvsvoROW63 +jbdh+3rDxPeYREvV0oPPxvgLuCNz71xXaqPTc3/dV2H9J/evBoApgy5/mTpSeTrtarUO/XeROke hLUXsEmUSe0peOdj9D5DqVBGFxD2Jz4qfdifCHsVYX8inId51AgADBFhP+U3xfXMsMb5SaQlcjag VF+6NirTfdZQredTYenaa2rsY+msMt6ZFr1mmsvT6xx96k+1P/V9pMLSOBXoAQAAJom/ArB3xrpR xEAYHqIoUiR0FYgmTUSZHomGJ0A8ARJdinssRMtLUKSmoopECSWiSBTgcuxoPZe5yYztzV3uznv/ J1m2x3u73tWtd23P+oeoBQAAgDGhB1Hed+F16QcnJy9DEQkRnOByibU4hYhZiIhFL2xxJ2ahhS2k fFnYghYCF3K8XV+cntmNBerr4fq2VFemhfq2UtdW6rkKrZzj9uq5PFbkCVr04hX9GFjfJs+SfUa9 uMVsITzBQhQiStHb/qT4RtlvArGLvyovAhb/zP59jo+Jrq+/0/n5B5pOpzSZTBbCFCxUwYHFLKyg hdhkm9ukpARBCwC2h4hXaHELK3LB/L66Grzf+V1GFyynJS/plG99IfUWFvhvff+bOEbr+9/UcfZd vGXTxxnLMXbtONor6IBFKFLfnYUnuOwwPddYHUKEKvhtmWOe1JixqEWy8+8PRcgixSxyoT12tGcQ 8/zoiJ51oSBqwZxR/8HwV7ovXHFrbBK0M5GcRm6y/AndX1xiHsREy52cyMEKTowAAAAAAMCyikO/ fh/19qud6EnlV3Hwj+zWsX/dzvw1Dv46/yOFC2V/kYKIXLBT/2lw/QAYG1a8QtJMydG/ZB/i4O9t l3P692xDPwgY+iFArTP+tkNN3e02Xlkurk1bMPYBckT3bO6/7S0wEy0K670b6BjsB7Xtfe1CW7Ng u7mKc21yVEe0lwCME763v3ThzbYrsmU+U11fwWura9rYmoUPcwsh1rbdte/AAIC2kPs5N7aaC3Zh TN03sQtjyv60e4QeGyUnDfaTXN/Fe0ZGz7qafgqZfJT2tgXjQtola9NYXyfvN2LPiayTyXtt41yV 6dgusu6V2fmrqB7Wrs9HL+LIc0w/aXmeSQuqY55pfMji8SIAHon0rWqr7XeUxu2jcdYoLflokaGh IVpYvvQs8uw1CznX9OOi62KviXc9rY2c8l0natMjv1dG2lCdtuPw3gd19lr/6sLHLnzqwqsuvOvC 24efyl7Bc7jS5nyjWCw1+v+WykttSnQf1dz7OeGJdYToGLYutu7R+UXXC7RN7X9Z9+O9frv+FgD9 dmCp+Z9F7ZaeZ4z68A9517H1Q7sGQBvod/bcO0qurSHyfYKjcWkJB8pmfXd1vfQzjwjPPfD42P5L 6Z3O5qPnqt0HAODxkHssNy5FJh3tx/bNdHpo0L/z5i6sLffti312Dv0mhipsXv4yhQuzDX8L85T6 +YnTlD7LXFsA1oF8i6KDtjGlZ+7QMfghY6I6H9mj9NDx1FJcGkco5cW2rvmc3HjDUCGLkr3mvHVs t7dl0W8seN8DAACH/wKwdza5UQNBFC4ySFHChg17EFsOAafInvuwyRFyCzgAC4SEwoIlkA0LwgkS JsY105Wp1FRVt5MhGY/fJ7W6Xd1jt524/90PohYAAADGhjch4dne1k50cvKB9vefLjY4X7ml4ISw PNZuKT5hhS0uL6+uxS20mIUWsliJWXTXG5HLnuLii8DFtm9Oz4xlI31mTHllxpTfseR1LPm8C2O5 x/vL5/rYUU3QYhm+KuIS2v+r3KXytVjFRXFazOJChfVvVudbiWbEghaHhx2dn3+h4+NjOjo6Wt6N I2ihxSxE0GI+ny8cp5HfAAAeFitiYQUtZrPZIp2IWizEKrJ3VwtV1NIoAYtO2R71eejmcTl0V7DB //Y/g4c+/31cYxfuYRPXGEMep3SNXbvOUDGLRXpuo5ZjWZ0j9dVeiZuJwAW3f1ncoohZcJhrzccl vCfiFxJPN9UkFit4+Jzlus8PDuhP327+XheSetm7r9QmaKHTXF/WcRTYtCgGGd8urBqy2AoAAAAA AAAhW9Cv8dqbeuG+d17dtvUW9jN6o57MRRsSRXbPltmHOi/P1ibHsgHRqYljwTzeeIgFL14V/1nw PAHYZrgjfUarDwTOlN+ykD+z12xDF//rcMuHABJu/QDAs0WL47MF/7X4+3ReHrz81cJDfHKOh/zf AKDRbRY7hqZ9u6mMDtsNtSTO+zCQHB9MB6/+iFy0SVaLmMVtN9wDAOwmuq/O/c4pi1q8p9UHy5Za u711M0QvLirju+DcNpy1w23+bRgAME502a3feT3uSrRettg+C6nz2PNLn0X3XeQaUR8GTJOojozq rrsIW3h9JjL2Wj7B7qDLQmvXZZa1kQkztlyUsk/H2bkiWzZ64haZ4IUOa4ELb7OpTHTD3qsX/4vW BdXZscAFzy29KGFsILXd8MbxMo/yrYR/B2mHjIe3jqt74cyW+VndYY8j2xA3RJDiNnZKjrP+WvQs 7HOiIDzk7zwmonLTluVa2ELbhEjYIuJT7z737l3v3vTuNU17jEQjc7kioiNzuUJWjmT2IeXK0HLD e3e9sRvxNylm4flefrJ78xj7uz0ldNvMHnfquKX+kvZhhG0DdrTeFtTpwPRoaUt5c4iRoEVU7kXt nSg/rXYAwMOS1Wk2nfWz/lOtfrPntn2CbD2u9gH433j9Fz0uUJvvzfotROv1qh0rAABsBq9+k3ct m1fIzuOFvbpLfwezRzfrsk1846LnHrw4PQeh85TNN9i61zv2wsxp8T8aO89T8DcxPE/xRPmYrwA1 ZM6Exy9/FpsIf/8o9oxavXqbcc6WNK1x2ZipFx+lj9rrma11HNaz2XjbPqr9puZarlmzRcfZ8/H8 1rAFbToAAEj4JwB7Z68bRQzE8bkTiRSERAEFVQQVTSighgfIG/B4eQAqxBNQUEdKQYNQRIWEkE6K 6HJ3rHU72bm5mbGd+2B3+f8ky16v9zO58Xr88YeoBQAAgLEgnSPvm/Aud8Dp6Uvy1gdmAYu0n2Mp TsFiFixisRK26MQspLAF718XtqA7gYuEXqh4KIvTJ3Cv+2NI9zuUex3KfW7DUJ5xv/e56TPq7Oyi 3dZiFpy+bbdZbEKKT0hhik1Bi01xi67cpihGGie0upYnaDGdTujk5JZms690cXFB5+fnd8/CIhVJ sMIStOB8Fr2AoAUA/cESs9DpxO+bG99G1trO9txLPlaIWdzl74m+CxX0ZZH3Pp77UNcYwzMc4hq7 OP8Y3sOYrnGo6/T5WeSooGkSoWi+V6dtvTRRwhQsVJG+nFOcOjbmSdSizU/HPeDybZxELvRsYWoF LZIIxpPjY3p6dETf87f6tgmfaTVYQgtXLFQeBzlheUnr+hpWJ/qE1hfLiyb5Ea03erwBVrmBVwAA AAAA4P+GvxW9Qf0k9i9VWn6bWueNBtvPjbzSgfpRvjVQP8ovDUS+EIfO87Y5vnT2vaJucP+LNv3c eb8AHApLuOIPrRZektxn8HbtRIBou2aAeenAf13WG/hekh8N8i+ZEGCll2RPpiw5bx8nA3hlNPBx gAjLf2aViYKegK99ddF3CIlyVhqMi6i+yf2PcewFa8GZnO3W9+Hda1QOADAMrHru8l/cSE9IbZYP lLeB0bdytMiptTCY3m8t6p1bDFHbcgrSAIBhY9lt/o1bflYeHmHZJPZzkkqTyJNpr+2i/ZI6DcZN 5LOJ2i+5dkyuvtP1HgCRfWT0mCfP5yPtnSVmYfUvlYhbyLQWsLDS+tjavikqyEt8a8MXVYYXjZJ9 TY/a+KHx3sDu+EFd3wn3q1xTt/BSzv6V+nR0XuTzyfnkS3z5UV3h5XPefRc4itpnNfm1Zaxn8/Jy 74ucdM3feShou6ztqHy2iSjDtpNjojphC+vvMmvCxyZ8asJjWolbvGnC6yY8K3+kwZLsEPflXtOm gAUT/b9FNkVv19oTjqPfXLRIrOWfqRWtmBvHWeeMbAcZaSu23hPoN9qeWftK6ouStnsqp8UorXFJ MtZpME4821rynVPSVi8VtMjZPADAsJB1XK5NwjbCQtdplk9HhqmKS/zUqPfAPvG+1UvqXK++jepN 75qoTwHYLfybyvXF6rR3Lu3jJ7LrMTkPRu+3ykf14TZzXxZOuqYfwtumII/jn224Eu9RHnPWps/E dgJ9FuMl+SS5X4Tnmvyizk+p559ISurIbXybUX6u/s6VLfWbWnk5X2rJvqgdH/mxSvZ55Wv6gGqv Xfpcufdk5ZX8PTX4fgMAgEL+CsDe2ew2EQNxfNpNVapwBW6ckDggjnknXohrD30Arki8BVy4ofTe C0KklEBCHHuys9MZj520ZXc7P8nyrO31etPU3/HfRS0cx3GcISEtQkhh76yMLi4+wcnJ061YReui 4AQSr6mLIhRc2GK5XO3ELaiYBRWyaMUsYl7xcHF8TtenDOVw+oCX9f4YUnmHUtahlPMQhvKOd1/O 7rxRzL47N3Zb0AL9v0lgYrUTnogiFOgvIQpRoGDFzTbdanVDxCt+MzELFLFYkjz/QCuaIa/zN80R nJ4uYDr9BefnH2A2m+2EKVDUQhO0CGEhLjh6j+M4/QPFLAIoatE0DUwmE/h+fV2XGRGr6Fyjnfyt iEUStFjTe++Bvos5DEGEYMz5P8QzxvAOd/GMIZSxL894qOeM6V32eU5nR1ASmdi2UZB26YT+K0Sh i+NkN0nsokmCFChyEexwqsMk2ccofsFEMXar2JvwbZub8n15dgZXmz70t8XiVjkJTyAKqL6HMkEL mmYN+sYgUMKoKAYwn2+mqtlg5TiO4ziO4zgStD8phQOJ531P2ieVfG1TP7/m/WFQ4q0futHN+dIm fq1vLv1YXOqfl5RXs3Mb+z8r4eHgoXAAUdjAHw4kepvi3oDjHA4erhT8Obn+mfyANcbMxVsb/2uv cxvHeVzuPmuzek1Yzeb5Q38EYG345wIYVv5SfC6s5D1BSK/F5WyOz3U4EtgfyMVrDtt1tAHafgLP g/Y9pL4FQLccvEz93qzh7IPWBnG/5pB06yCtEoELqf7Wyuw4zri4tJOMlo8Qxy8cqR6U+rSSGIVW B2v1dunB3lYdzstd2ld2HKe/WGMWnhbTa+MXaexC0x2TMDrnCaDPX4JgO+NGG7/kxs/ct9q9mgMy ebmcxwX+3aW1KbqOxMOktNQucXyuh16vhXTcLhW5sNbEStfHeBgI/o+N+8LC6H24zoSiF9MUBuCH SFl8Tf4cuusp6OfYZ97bqiOtuSnNtubttbZBs7U2JFBzoNEhwhS1ghWWy70ft7Vrbpf+nYcK7/Py Opy/J62zA5awRcnnyD93KnAR8nkNUeDiFUSRixfGO/WVK2gPgQtuDq2QhUVtXaR97jV1i1SvlNQN Ur+yVNQCwyUBC2u+x6pXeLlrPitnONC/G63DaF1HvytHio33h+8i1nF4ryamRp/n4/bHh1aHaP0r aV5bq/dyc9ZWfec4znjgbRnvw3Of989K9sHw+0rmQ0Dwrec4Ti25MQ/a0vc/Nzbh6aRwEPx9kcbX juO08LGUFC7ZVp60vZLGb7XrETm3j/BFrQMlTBJY1Npqrf2WfFyv0NYtnicXbPxdDF23CHHPwPlf 4FwkQgUp5tCujVC7tq0q/V8sva8kvCQ/Lb1l14bl5lGtuJydm9PMpS2Nl+YpavIqCSt93xK/1OZ4 38txHKeSfwKwdzW7UQMx2EHdXviROPRIhUCICqSKO2/Cw/SxuPMGnBBCQsCN9sqJom6J2bjxej0e J01ps/t90mic8WRmsj+eP2c+kFoAAAAA2wC9+PGuDW9rNxwevvxHMuGduygEFnymosSanELILITE YkVs0ZNZaGIL0WtiCymX62FkDhqfy+H0DLT15jCn9s6lrXNp53Uwl2ecpp3r60c9oUW/NrVJaCHE EsuOZIJ9xnryiXVCij8docXvLs+5IrcQoovzq3z2vr7Mi65e3/7v7TW0WPyi4+MndHJyQkdHR2vk FEJYUSK0EMILEFoAwN0E2zkms2DyCpGF3IJjxv7+Pn07Pa2Wc6kOAjfKlT2VPF3alU4ILRTJxdTP eJPAAf/zL/9/1LENzzBFHXNo4y7VsW31TEIwtCpo5XXT9WtNJzeGmEKIKng0zTFvblwwqUWXziQY e5K/i5nkQrx17nVpjdTRhoO2z328WGSa+qoNx234SJvEFSVyC3EaEseiNX4N2txMb9R98vFcFmKi 9QlQyakKzosAAAAAAABAFjJuLDn1k9Jnx5h6/JpxjK8570e6khN/xoHfklYsA51ts6enihylad3P LliHfo7Fcf8B9YcRiSM/SC8AIahgyIsEP7r0M1p/0cBD7T+efSEg4/yv02r3X8fh38uTcWivOf5H uqFO/mPyDrnX02WfJ/pcotjKNV0tHQAi6N+fjBuyQdb39MFZUoY94NDr83UM7BZKNjL6rUmsX26/ UHFEYhEdquW1CwCA7ceH227ALYHnNu+pbgMz9rl20JcciFg7FMyz1Vom8u12ZnwMAMD8IfMJfW1j sRuCxqQ1Spa5ii5P6tBzGF2Hty4J7C6y61BDiC2GHpDprTEBuwdrHyVNY4xPlLeOE+052UOj7LUl rLgsyN7elHfoFJk8+rmjPafoOoq/qs/G9gMi8z7TMyU/VbrXSj6geR8mpfdPGJ8cmfdQzkaWX7Nn 0Xwgkyez9h6t02fX9yO51ocwlo7sXdf6n+vmGdIP1a69uCRHtmnb4I1za3ZdIyK2WCpZyrHfDRV0 Ej634Qv1NvdRG1604U0bHrbheRfuB228aXh2iO0UE3kKicUYRJ97xpbY6+i3XrIjni0p2Qf7347i DGFFhsgChBZACZ5t02ne75Zoczxo5/ASY98RiOCNQexhkZFtrNnDrJ0j2rR7sHEAMA/YPsvK9r/c GF1pXG7r0MGO2Ut9Hfo94K4gmsNEc5TsevjSKd+LAQCYDvK/Kq1LNQW5Vqa3D0BU79+GhFqfOWSv wbalRKYt+ug9GHLSsnsSXh+vZXlHhtM84gt9LQQYDP2+DFH/Do1g7vsXU4DXFS0h93darTUKhLi7 dJ3B0L5s7Jp59j4vXyattE46Zo3USyvNq0tjkSgtkktjGi9tKn1Jl2nHkOeL0sjRW52XtwSM0QAA AEbirwDsncFu1DAQhmcLFarUWyV6rQTHiofg1hfhGfo8fQkkXoCeEBfghuitnChCAmkrNmQaz3Yy OzOeZHerZplPsmxPvLaz7dqxM8mfohZJkiTJVNBuRmi2N7WKLi7ewf7+4VJgonvhdyc0QaCtE7do liIXGEthi9vbxVLcgotZcCELErOguqi9rp1+XGMqL6dHsq/bA/s7pb4ij72/U+nnOkzlHMf3s7+H tCpo0RTxCiQqaMFFKUjAggtXzIuYxXxFzILKdvVR+Lus2+LZs1n72Ws4O3sN5+fncHR0tBSmQLEK DChcIQUtyIZiFlgmBS2S5PFC4hUypjQGFLW4vrmBP/M5HLTpSoX9uLTRFFsvjaIZJGhB5VLQYqNM vf6HaGMXzuEh2tiIWMAOfA/Zxu62M+sq6TLsmhVTKD5xdy1b0nsl/aTMaShisUBxCxK9QGGL1v60 pPdI/KLES2/AInDRlP7PSr0vDg7gR3tN/fW39NVY4SV0TjIRQQtehroQdVQC6ItigIilA9UYp6ok SZIkSZIksag59YM4PuT603Lu92yI51C/aQf+aPD6JW1QSVs26zjyC+6d+N8bnyNH/WO4d9A/LfFz SKf9KfKFpemlJviQwVVJf4PVBxGIyG91qJP2GJvnJO7lrTosJ/TaQwCWfYzTv8yPdeJfp/yQ9rx8 9Hvhcc3mpSW5p5FEkPthxMwoowXtoXtex93WJKvD29fT4uT/wBoXvfE6+gIu72XpkTkBjHySJLsH /rYv2nAC9lpSxrV7VN58561bZXqbvIX+A9eIt5ag9ILFfGyuvezLG7NlHVq+UfLeOsU6pyRJHj+0 ftBs2hpGrl0A+uOGLE/HpaCFrEvzO8j1S0IMWcNo6xdtXvTmO63NJOHQ/0Vt/JRjqTfmzpS8F3g5 KWihleFpT8hC3otaiDqAlbN8y6L3mmr7Vd48gGl+3wm5hD7yu+b5U1iFv2jKY8j9qsiLlT4pts+K bVNY49rQfXBvHeDlh+zbW+O/Z/PmCss+NowRqZCfj/RJlrHykRgqdnl8V5HjsRy3tWthjiVsEble jf6dm9LGzzZ8aMNH6I/7GKN/8GFJvxJ9OC7Bgo89st9SmGLMS+Ki1MYXz26NQ+uMK5T2fp/W/om1 l87TEfGKsWIW1rloee27SqaBHL+0Y/L/gMYsTciCjpGQ+Z4R533HxMIbV7Xxytq/xrwm1CzH09rc yfuSJMm04XOeNsch/LpcW2t5dfNrbl5/bY9Di5Nk29TWM7V1S2RfXNan5Wv9s/JJkvjwfSnLrqVr dcq5DWB1rgOw5z5eRj7P0ijHamFhpL1yWj9A2LzzAcUubV5cs8nj9LdB8YvvrMyl+IxWD8+fQF/4 gux4XyJyDwNgveduxu4FXsGqXxSB380273vItjZRJlo2Og9G9+asfU4vX9sb1cp6e4feWj9ii9hr tlp5a//Wqiti9/paS3s2CNi8tCSvtZIkSTbAPwHYu5bcJoIgWraSRRZZAdtIrLgD3IStV6xyRo4A CDZ8JMQZsglyjDuejp+LV9XVYwc8Tj2p1dXVn+kZj6u/0y9JLRKJRCIxdeBEx9u1e9PKcHX1aofA AlEJLCrJRfGRnKKSWVQSiw2xxZbMAoktajwSW9Ryy3UKxh42PpXD6Quyro+DKdW1YCr1nUo998FU 7rGvnrtzSTahxWZdcFN2JbRYAtlEJbXYJbTYJbPQRBa3BvHFbyCwQKKMpXkXFxciNzff5Pr6nSwW C7m8vHx4FoWoohBWFIdkFkhoUUkv7oZGLgktEonjRCWuQBIL7Qqpxedfv+R2/d8upBaz4XDv+8O/ o/9tRXbxQG4x6ArBxT2hBbo97EYe8J/lH8M1TuEeDnGNKdTxKV0jr2OXsUIZ+/+FyHGQZ5W4Qjbs EJWoovSqi18WOJaF1GLQFxKMs5p+8Cu7xF0htRh0s3qNtXu2bmufn5/Lj3a1X6/de9l8YKaJKyxy C/xIeSVbkgtrMX4mf3/sojc+4UYlbLytjVTRDVaJRCKRSCQSiQTioctu6BGsz4n9VlY229AvIOtN 6Wwzfe0/63y9G/jnTpmWbG30Z3Wx7kv7EZ2Vl6X5PvifSF6UX8p2sz4ePITyC0kSjEOifKDwE8L6 MJMvRO4d10XTRzf1R/WR8qywV461wZ/lH+N7m+ctfWRzfisuEj+m/Fadrfv2nouQeCuOhXvfq0Si Fzh3psPM6Z1jRRc5VMZrzy0c9+aMRAstO9VqN/R7p/2eg9RXSj+mvolE4jSAY/aF7H7YPgcf17JQ ttyZCuu8NYzl6zYSx87o/wt4Yw1mj1HWh3wtlR8htLAOBGN9Zx32bHsikThNtOYp0E4VW4qHYmI6 3I/gzYGKkjVy3HK6YO1LdAzDxjKRw4S9eSyrbtkOJrCPy3QriNPzPmwtS9u81lxPdWhbmd5at2K6 O1JOa82KzUGxtTBpyFqn9czvkfE/+1HFszwszDC2PTpUOzbWFnn5vHFANE1rPl7bWa+fodO35rYK vAPpLb03J8vGZod2rF7s3qz793xPloD+qQBttbYbGozYgtn26kd+I7Y+MAdZ96O/ytZufpBdm6vt asSORuziYyD6PnrhiD2pcst+ROwCC1tz6ZF+KcvHyuyxJdYzYM8sMQ3U/74O19+Syey91iQX1daI yttaexTia+S4/bTQste9dtQbq3vz1trm7VP3RCJxPMB2jslaJ0rG/TRzFdbXYfPV3pyIOD5Dtn+J MYi0Va02t4CtKXt7eVprxXjtse1wIpGIAcdzlp7JmM5qg7C90+M8Nu4TJ00k/yEd1kWvI/eQXIjh 96xBRHUszOL0b1jT6GMDxs7Z7dMn+Z/9mUO2MYcYN3pl9OZh/VgvnzW3Z5XD0mvZS+/5LR3rn/SG e3VRYgsvHE0bfQ5C4q04Fh7zviUSiURiBP4IwN615DYRBNEiJpsIiRsgsYUD+QQchhyAA+QY3IIN OxDsUXYExSE207FrXH6u39gO8Tj1pFFXV9X09Dhx9df9itSiUCgUCmNAdkLgQ1TQ1dVnOj9/1ZNa tEMT1wQWi163JLdY9CQXLUVii7u7eU9uIcksJJEFk1lwWfy85XM2010wlsPpG6quj4Mx1bVhLPUd Sz33wVje0a/n9txSTGgxX6X3fbomnGACir9ATjHr5fn8dkO/JLeQvpIQg8uUpBk6GqHF9fUXurz8 SNPptGurzvv3b0QWjaiCySsakcVsNntIm63p2GfZztTcWaFw7GBCi5ZOJpMtkotGatHwp/uuv764 sAtCIgpJUCHdGoEF2wPfXXDsRAWncDB+lf88njEG8pZ6xnE+Z2zvwuXgzh9G052tiC5YPlvJkxUZ RiOxmDdyCya9aMQWnf6lkCdd+/dA+ib8W5n9r0JWpBlNftN1yH91/evvNzde1bteO0276xPlCC2k z4LsHyCToZOkGAQpbpqKNlIVCoVCoVAoFAq7Quu2o96Tub8q73sBem8zPuYjf2tjvXdhX906SGhI n97bwB/ZKEizm/g1m6b/JvIWAQbq3tKaCIPzF+DzXrm/4Z2hP2b87K7fir4NIn8o+q9JPwu7jOn2 2XSdvTfzo4Aon7F5m/8jv4WjR7snS92QTf2RfteDnzLPH5KP3pkUvZaiHNksv0LhUMB+CM/bsSyh HTCD/ZSofZcpyoXTRqatkXntR+vR4Vtoy7YXWD8tXygUxgscY0s90fZ4W9qjGMJxRxszy7LxoDb2 0w6ffKo1Ky82W3HYI6zIXt5n6/XzvXcoFArjhozJ2vdaxknsPzJafL2nzUMxDzGGqfHL80R2LGO1 m94YRjvgK+qDWHUqPG9Y/VmJIfukZIzEvHdpfmeOba74efrMRbS5f8xbmyIjzaw7UcJm+bLs/Y2s MjSb97f07v0f8WPX+W7Nlp1Xt/y8GOqlmXksLd/grW/gfY9JVpFpX6J38j4PtFFSpoT+lIGxG/up MrXAsY7jHh6eK+MigYypfB5eWr2sw+atPQcEqRcfyclbugyG/v9FsSjqm1nfCytmDPkuW4fDYhqR WmiyVb72fKy39rlEn2NhnMCYwDoCGf9PtAO+tVhoxRgy8lpZhdNH5n/Oi2FezPR8vWcQ2AqFwrhh tXPoI2Vu67BvznEBSeOwvePyMvPVKBcKj4UhbW6D1Z56+3qieZFsvQqFwv6QbZGl92TZfhLkLdkb 92VtQ9cQcN5saBktRZKLIesRmTUKy442S47m2aI1i0gfIfJ56vWLfZCt36H8PDvasnNxXjuasVk+ 3txgNH8YzTFGOm++0hvPaz64vqPdt++zo3fI6FCvpShHNsuvUCgUCgfEPwHYu3bkNmIYinUatynS etKlywnS+RQ5X3yglGlyCLdObGUpLSQshB/1i1d6b2aH4J+UViBBUnwgtQAAAACWDLl48X18vmUZ Hh6+bAktNDbkFnNCC0lOwWQWTGKxIbbYkVlIYguOl8QWTJ7Ryt3Udzo7ZymX0zegrefBktrasJT2 LqWdx2Apfdxv53xNaUdm0fA25dFkFiwzwcSc0IIJKPaJKiR5xctEbvEyyX9npBeyrB2hBZNo7OPu bqD7+z/0/PyLnp5+0OPj47av6wt4x6cRVrSnkVgwoQUTXHAcCC0AYDlg4opGYiHJLTh8Rmox/uaN AjYTS01oIcpfTenWsiCvYP+M5KL5p7yHaJD3fsn/e2/f/y7/EnVcQx8uUcd7f9cvWQ/quN56ojKG iXBim26Uh0kemLiCNuwQTGTRZtjNbZscr43IYgpvZBYfxvmxJL5YE2OM6d4mef2Pt4nQotXzaRx7 P07Ecgnapaxfx+cn7RNXeOQW8s92K9qRXHgb9gPR3mVAK8clmg/hvQduAAAAAAAAAKAKnk+e6lC/ Vf5A8/mud9i9cqBf1nfIAf3o4H+lLC+N159MPsT1ZC9ep9E2hAz7rfJGZBi9h/gbWcbnQrpToJds 4lTosc96bbksfXaQ/5C01UPi0u/liQ6lW2E9buVAfHYg/9iwLP2p/zRQ7Xvk6nzkxFuyBtYmgGPh rYlZ6aRskVusaD6us1/PRbyxXLrk+IHrRTa+efpfPtkf3a3Lt7wxwWoXdC4A3CZ4DKvoIalv5D6W DqfJ9QiiBiVbdvmlkellS9/q5zWI83R15YKSbG5PSgYAYLnQ9oulE63fvnWBb0TK512OmdkwsF9u E5Etk61HeZcNV20Xy4YBAA/8rlh7Ut5+lFeO1sWWP9oT6smT6WWLnILzkCF7eSgIoyDMi9PhVlwm V/3e95V9l16Zl0KlbV6aaP0m8lfW4D1bQuv0KM6zTXrsmnM/DRGphhVf6V/kVmUqhN8K9JxX6mzt WnklWaZcZ2BYY0L0eOsjcj9At02TD1n6nCjWqd5+e6YDe5C9a5V3NJOjMO+3dIie6Lkg1iOsyEgs KhfMen3wPhP92QDXB/5u5W9XupbtLtNLvRLpEm9uZvmB64bWJz36tcdet3SgJPeJ2gQAwLIg5+ee zH5L1mOdzC/3FCPy5WhNQ7rk+AHgHIjGXHbl2JuR42Xr4xTIAABcDtLG88Ij2Ro/BxXurSdJf0NG olrdt2BZjrfeHkRWd8VetfyWHIWREZ/FWfFWnDWPqIRlexNyDpRhaXOZQ8ejSr5eG7OSPvNHabw5 r5XGS6vHcG9s9+YWmSzDTu3XcZU0lbZnfcn6SU4eK40V78VpYO4FAABwZvwTgL2rzU0khqFmEaoq cYsegIPtrSr1Bvtrj9ET7AX2V38gQSm7A3Exru04w7DLDO9JURInJAEydjL5eCC1AAAAAG4d2ZcG 32sFPT//pMVi+Ulqcbz8mwrhxL7ISMioEFJ8JbbYbiWRxYnMQhJZMJkFE2RwfVyP9IfCWC6n74C2 XgdjamuHrr1jaOvYftc+GMt3PLZT9pssoQX7TGjxUYgndoWMgv1zd05mYZFbyPySyGIr6rPZlObz GT08rGm5XNPLyw9arVafxBSdY0KLjryCCS3YSUIL+RkAAG4fFqGFJrdYlEu1N+/v6TK1BjisoBXC iv0xE2c+uVMBJz+pS279gv+hykD5t13HFL7DEHWMoY33VMfU6hmqDq8cvcOH0cm+FaILDjMJxbzY PUlacSC9KAQXh1F4R24hiC8+RP6uzG73za60a1bKfXp8pN+bDf1ar2tf5+mve6UcoYXMsyd/YxA5 Mn04T/p6c5S3eQoAAAAAAAAAhkRtU7+ENy7VG/u1XG/g98JEufG1rO9SUopoTN9yyEDLqCLPbuy3 Nu1HaV7eWj4rjWVeX/Cg097oSJLROiG97QUuH33mbpdsuvbSM/K+m/+jcjIHACKfw9kN8FZa64b7 80XJWBYdBqjV0feAQC2c8WsyK47DAMA1UBszeHKvL8tD9/rwvR5naLtuhaVPThyYHjI2y9Prlutz 4ZZuj6XrAQC4X0g7GY0t5fxWx/Uc2N78drKZ+rOkwkTXtZHRvMTTyfqikYjQokZwoS8Li8b1tbYD ADBtRM88z1NkWOpfvVegRspHRlj6ulxg+sjOZWq2MzuXseyhVY9ujxUH7hfcF2aOzAp75cxUOKND dbqXP1qTquXXa0+1S6eyOt9be9KyyK/JMnFvLcmDlyb/v/8Fr+4WeZ/37Zn395HvybL635J5riVv pqwh1lyi3yHyyYi39oF7hNSBMm75Gno8LN85EJ3rgb3I6/UhTd7JbqbC0SW8kSPH76Mv+/ShvrpH x7O651Jdol10qXqLnxmTZonXMrpCAs/+NCD1lvxPLZm0T9Z6I+seS+9l5+xRGJguMro40rH/cr4O AMC4YY3Hpc2TY3Kic1vnjYGtcfUlts+KA8AQqI3p+9hdK3yJ3QUA4PrgZ07bGim3wi3laxvJZbHb kW8jM3LZvmg9wSqn5Wx7tPaQWZe4xnqElT5EvCbPpo1Vp2faPUSe6B1lTZ59vxmlZcOZtGgM0SqL wi1prfFMuRl5RqbTrPSazIpHfW6szyMAAMAo8UcA9q4lt20YiFIO4hygm67SpXfZdtOz5Ci+We/U dhGgbhDXkjXxaDw/MZZgOe8BBIecEUk5yvAjig+kFgAAAMBSwRcwng/he3TB4+PmndBC4khksR8E TmhBZBZEYnGSObnFSZbEFkSU0ZZ3rG/aec9SDqdvgbZOA7R1GiyprbW4/nvkfpTW8YdrYOeEFkQs 8daTV7Tr/ERo8dqHfyxuySr+9mmLzGI3sCf5WNcrq0f39/f3Tbm7+12enr6V7XZbNpvNgMyCE1rs drsBmQUILQDgdsB9LcltvF6vO/nPy0tNoUeSC0ZU0XlK6ddZfXtK3wihxZIOeZ+77LnquIV7mKOO JZC3oI7rrGdp95Itp+kJJ96vaUkQe7kh4opyZIcgIgsirejILFarbhy96nVdYMQXHTFGa9fL3Q4c quMQvhz6368PDxlSix+H8PMQfpVz4gqL3IJ/ZLcvJ5ILa0NAU84/yNsbcSnDiYe1YapmIxUAAAAA AAAAWLA29XMdh7bJXxvbFiVf2siN+d6mes1e5mU35ksbedj1W6DPtrEo+Zk8L87qtHTWzrOxnoli 6KyyPXx0Eltz/SXmWDVljN30H+kzm/9lXlTGmA3mYzalexvdrdjbfO/ZaOk5bbT2ZmQvz4ujPC3t PWtYgwAuDTleoDwO2efwtHbADB9LyEMGtTFDUeJipIHbR6Zf0wLpog/dpRz1KZm2AQBwm7Dm59pc Oxu0w2m0elcs9ua4c0KbQ2j+V/rbDLmFR2gx9rDEqB8BAGC50PyvtQaqXUvQyPi4z6XyMuucJZCB zwWvD/LmHdp4QcqZ/jDTFgCQ8NaFtPdPmXI02Xv/5L0r4nJUbs37p+z7LCtdRuRJvaXz5Ex6rF10 3VTI+CbPt2VtorV5qbfsNb0nZ9Jj+4ep7L12ZnTe7yV11jUS6Lt0RONhHhMorR2i6/mkvbCXz00j 0lS+1Hu+3/PJRZGLI2d8l2aTfdayvkZL1/qXsX5E/j14bOWPIYbOjEclYY53j/K3kL8XsDxwH2XJ lJawyCi1w749vyJtCsvTZODzIPLLGR9b+/4x6gc0GQCA64fX11EegXTWmFzr72g8Hq2jFEXmsWwD AEyNaA1gzNwmWie35lZe/QAATA/6f/P6Rg7t3YM2j2xEvjU35OlS7H7Ty4vyozWt7Hcul3oXkdHx 2JK9uXNW5+XV2n/Edk7U9DXeNZfUXWJtM2sXzb8jXTR2yOi8tcloTDKV3Zg2WveYzc/kaenaZw4A AACYEP8FYO8MktuGYSiKqpOJM9Ol1z1KF13mFj2F75MzdNUT5Q6urZoRaSMoAIKSLVv2fzMaUSBF Uo4DihSsD1ELAAAAt0x0gv+rVtHb2x96evp2FLUYXgBOWXCizzZiNsqiFHQUskiCFcm23XIhi5OY BReyKGIWRSCjtFfa4ftLcvsvpz+Bvl4G9PUypL4uoZ9TuM2/x+d1pqGLw3O9oZt9Fq8Y7DFBCy5m kcQrtsTFK3RBC57/l7gwxtBeaUfn+TmND+/0+vqTNpsNrdfrocf7/cfnXgQrknhFEbNIwhZc0KKU haAFAMuk6zpz+5JFKRKtohZHgYqT4bTx45J9aO9D7KLrKMqtizksQYTgmvXP0cbS65+rnUcXb5mz jbnauadrOVc7YTEL0qOAkq3LQhcl3eX01zzmJdGKPotZpPQuCVxkwYpdFrYowhf7XH6f6zz+ijiL ZqT099WK3l9easIWq8P247D9ppigBS9TghOjQUREevCv9tH1hg0AAAAAAIBLwu85rcD+Mfep0cB+ MtJTgvw1m5av3dvzc6XIRW0eELkWuY8G9ntB/VbQfktg/5TAf6ts5Hsip5FLp+UaIsH8kbxawH+k jBZMLo9bg9DH7Gu2lsD9KWXPVVekjshn4O1rNu0YPwYA14bfG2h5HO3H9nytrWzJtmNpIn1MJvLH VPBYRHyp5eu1zfpxe22z2gcA3D98ni2P+Zw6ssmxkVi6BONJ5PMqaxwlmm+stHxzze9GNkvgoubD Zb+s/gIA7hNt/iL9Ny9nzWm0F4dFYg5kO9fwzeD28OYykbUr7+XAXhkSdWn9AcBD85/SrqWturTn TfxY5lu+tnfK83FAil94z4682LIxgupa2rJJu5Yn07XxpSVfY8qY5Z071v+0rpFbPs9ah4+uOWn5 1vOCmn+XeRG7fCm8t3blldXs1jm1a/Ns2j6almDsqiPvg6Xf1e5/y7G2fq/Fz/Z08ok9O+6dY75W Il9Ib/l96cuJ/vefnn8lkWcdj8X6Plo+ppb2fFDUn/D/X/m/rN0nRsXSWkXVvLV26xqsa5d2cL+U v7Hmw3h+YsqcnZy9TIPHodUHJ/ZKOupzLT9o+UAAwPLh45x2T17yZKwNkT3e9czeet9Mhg2AOaiN u2VvrV3U5jTWeCvrAgBcF20OqOV5abkOptUjn0GU87105Niz9ZXytd+5aDavT5FrkmVJydfKtDyv kGntuFa+Zm8tc87zLM4xprTU4ZXV8sbYIue0rud5897a3DiyH2Or3Xdo506pc0pfW/L43kp7f+/a d8EqCwAA4Ar8E4C9c8dtGwjC8MoIXKpJ7zaXSJFrpFWXysfMJXKAAGncGQhiMaTEkYaj2XmQlEBK /wcsdvbB5cqQ9u39IWoBAABgjfDFiO+t++o98PLy5SRoITkKWTQDdxSlGNokaEFCFiRmwYUtOlsK W5BQRlfG8X23nwct83J6HdT1OqCu87OWek5lOZ9zuN50rNZ5ve0o7rDv72rf9/UmQYuz0MRZ1GIo aDEUsyDxir8s/E+IW/Dnjy4maLEp7++/yuvrj7Lb7cp2ux2IU5CYRU3Qorusl9zhLwBBCwBWS9eu kogFF7OgcMfvt7dUeU1FvILHnfJJsYtA+dcEF/yvv/xbvOMePsMc71hDHR/pHff2nrneMbacTS84 cSqjExTs7U544iRO0bqPNvypE7To4w+ujd/34henuF7Iost/EMbo8vT24eQNvaN1n5+fD84Rtej4 1rqfrftTLoUrauIW/BBvU84iF9pBgoblpRUteXCY+6UMJ03a4WIrHgAAAAAAgDmoHeyvjU21tOjB fvJrdmFxXlimzXFAP1NGtG6ePcav2ZGD/dkD/9m4SNqUvFOekYydZ2Wfyx7IruWPxkcPivOwd/hc yyvTvLxTDsxHD/hHwtG0Mfnm+sxauhenhfHPAGCJ8DEBsVHSNGEL6kP5hVbWWKIovmWD+yfb31nr wFkRC68PzrTfAIB1Epk383xem7Ivw36T+j9+YaSGNp/lfSrPI+25sdpGsq0LvCwRi49KvkbYVtlW W452G4DHgLfJ2p49tbvyorBSLi8IeyrDtla73LwovmWDx8GbT5Admc94fWCtXC0NgAz03antRW0q tldmdv8muk+krTk1gfy1sucQVLfiLF8+J9O8cGZ/KLuXdG2071Htu2Xlja7DW+v/nl+Li4StuKww RbY8r+xa3a3PXZR0mabl1UC/lYe3ezzsjY0lfJxsiVs0zC4svBFpNF55Kpd14QIXWrurtd9Fsblv 2Vo4QrRNio79aunR32BU5KY2bqzFRcUsamVZrii29bfRwuB+8Nql6Jy9lMv2AXN2ECXTNnvjr0h7 q42Pov0LAGBdyHE5j4v0fZRHjslr6x5yDSTT/2lhAK5BZF3AmgeN6XO1/jdSNwDAbeC/vSl7D7Lf lX0uPev1l5H9CS/srWNl4jJhzY7EyXjNr9nZscXYfYspaUvF6ncifVLm+alrmpbNw5H8tTVBzyfb m6tbcTxtCXkzdc74Xpy0vTQJxkwAALAg/gvA3tketw3DYJiNLz+c6xJdyh2i2/hHB8gYGaKL5DpA 09hqaBEuBAMgKEuOZb/PnY4U+ClfAn6Y1gtRCwAAANdKdNH/o1bR8/NLenz8ehS16F8cnorgRFds idlSEaVIRbCiOwhWZFsf3x/D/hoKWZCYBYliUHvUDg8vzfW8nL4O+joP6Ov0LKWf5/J5z3m6ByUF LXrb/hj24hZdEZfYM0ELEp94LyIVJGRBQhV/i5jFn4Htv5gFXe8sTvXmtnxBi6enLr2+/krb7TZt Npv+aYqYRRapyIIW+SIxC7pI0CKn5XxUBgCwXLJohRS04OFqtTrkc0Utij8eiFRU8vLwUK7vzDBN LT6v77/3F/wvvf+XqP9W2pii/lv4HG6pjUu1s7RnGVOPPCVDZNtDEbqgeBasyGNfFrTIdhKtIAGL XU4rghW7Ys+z9KMgRsmfyx5P2BbRjBz/tl6n329vNWGL9cf1/eP6mWKCFjwPHVTUDvImw8ZFMZII 5WGoyAEpAAAAAAAA5kSb3ss0ztiD/RS2HPa3DsOPPZQ/ZTnvvhb3bF5Ys0Xy1u6tRWKrfar0a2GK g9ZjfkhQO+zdcjg8etBfi0fyRw69txys9+LRQ/2RfF75lrK1Z47aI7bofTQNgLmQcwMtPZU8/Af2 8kUzXRqKyfIf4reMq5yljD9gGrwxNDoe8Rd9yZd+7Y18lt/3+gUAuB+0cZKvn/lF3znJ8Esa+iVr fJPr8od0OoZ64+ZceGsK7TOgkItT7IRNilx0Ir8lcCH7o/UPAHAfjF3HkH+VyBdm8vpb1jFYw9wn c6xlZFptX81r0+ojABrcf1p2LR6tW37XpN1ntBcVW98L8Tq89Fr5SHvWfTLyyHQtrNmsdO3+XFuN aJlWnxPdj4nuvVv+L+I3W2yePeLvPd/u2bQ6auXHxOWzaWE0LsG4dB5yLiz3E3iYRJwjxaqts7TU Bq+XC17weTbNZR5YqPl9rd2av9X6JePafSs1XyNtWn7r/6hljujZvKsmTKGJWUTvW/2MFsrPCtwm 0k9p6Smd+ifyLxzpI2T9WLMDD8/3ROZ4Yy6rrlp/AADLxpqTUxpB+9WUZv0GLrJvkdJwbLPGP8sG wNRExl1pm2rsTUpdtT4BAC4LXwdqdom2t+WtNbV1ord29OItaZH71jKRtrU8tTRp18pZNitPLd9Y +5i5y5zznXPGDqtsrc7WctpY65WzxkqrHm9Mp3gkf23vMLrPeE7+MfVM1RcrXdq9stJWux/7twYA AOCT+ScAe+ev2zYMhPHzkgyZC3TK2qFA176Cn6LP5kfK1pfoECBbUCsVLdE+Xe54R8pyLfv7AQRP 5PGPW4SkKEofRC0AAACsDb7p8KsPP70Cz8/fjoIWkkHI4mMSBlGKqZ3iLGYx2B+j4EV3FLfIeVzY IgtlpDqG9q7j3mhNH+FHX5cBfT0/a+nnXC77O6d7Tycxi0Q39uf0Xii3u24QmNhsOuKCFoOoxV4R qnhnaVzM4n0sx/3/inASz7B4etrT6+tv2u12tN1ux75PBS2ScIUmaJHFLiBoAcDtsBlFJbi4hSZs 8eftza1HVUvjIhZZ/ILELr0UwjDG9WsXc1iDCMEt13+JNm7hN5yjjTX08Z7aQDvL1ZHrmdx39PZm tJPwxFHMok/bp5iJVhxCb3ej+MUxbRSySP4HYYzkM9qHk7W5jT58eXigr4+PnqhF4nsffvThhT4L V1jiFvkgb34pLotcWAccNzT9wB4/pCRjoul0/2n6d9IBAAAAAAA4N3J9quXJ9Wn0YL+2Hi4d7Jdp PC96kD5fyw8UReuKvABQU1aWKeVFDvJ7B/ijh/pLflaaV2fEP8qlH3AtUbbmBTbPt+ZlgFq75sC/ 9Kl9AaDm4H3rCwBzykbzI7+1FFt26f/cu47mAbAUkXWAtq5IthS24HNqJ2wiex7VYs5tHxIBFqU5 1BvTtWsrkGN7fQEA3AelOZHnaaFj+fzjNET6HJwC/9CjFIeKzJ1LUhp7td+uiVtIIQsZtLI1Y7rs q7QBAOtn7n1MLut9KIwUuxSTcQ3ui/91L2O1DcBc+BhqpWs297PGRZ7HbT4W78kem0tpLf4yPVHz zMqzW2LLjsw93vOkSF6Ln0V0jLL8WvbhI/cJtc8QasZw77rVZ07b0d8UiaXt5Vl+YB5ynLXWxaXy /MPxUuSNx9mXx7wdTURO9ocLXFjPFK5pTV5a20Xs0t9N5O9X5km/TvhZeyjR9OgeTHRMsv49SMkD t4Mcl3iaHJtK45QcU65tfADrw1q3lMbo6HqtdlzUrgEA68Vak/Nrotj6XKvX27to3TcAYGla5l5u t869XvsAgOuAz4+lPG8elfebXj73a9nn954TaPekc54vROrTypbSSMnXfLznFFY5LS96Hc2b43su WuYVr0zN3lnEt/Xamk+j+34y7RxxNG3JvJY+WfmRNkr1kOFTKq+B9REAAKyAfwKwdy25bcQwlIkb OAG6ygG66d536tWCHKGrHqOnyC67Ltw4UwsjuTJDipTmE4/nPUAQRdKSxkior+eB1AIAAAC4RHg2 AQJ+WBU9Pf2iu7uvJ1KL/mXgFAknuqijTEeRlIIiaUVPYBF0vfyekVl0JyKLpAspkViElNpL7eT5 JSD0bykv4F8SYQD6Og2W0tel9HMopn/O8z0oH6FFnr9RT26RSCfeIrnF3w/pnMxCIrfI/f8TY/Tl 9yjL7EmbzQ1tt3/o8bGj5+eftNvtYt/7MSIRVgTyipD2+71IaJH8QWgBAMsHJ7RIBBZJn2zb7ZZe Xl89FX6ov0t6KR3rPiO9SJ8R6pkSeMH/8uufo41reIYx2lhCH9fUxrW1MyYRxeA6SL7pE3S3iegi thMIK8IMfBNJKRJpRSKwOBzzL9F2iPqD4B/qPP2aJJJmBPnb/T29PDx4iC2+H9Nv8hFa5D4d+X7k lutyUgxiOb/85LkQBQAAAAAAAABzQrvYn89Vay72a23wOXVJZ1361y7OdwW/uX8IINXFdR4bNepK sqdc62fZWvzmRO3arPaS9lg/CvDYrMvoki+3Wb5jXPy3dFP5tj4Dt2l2Unw8dk/ZawOAzwCfC5T2 woLMX84t1eUZL7kslYF1who3PeOLR1eqT+oHAADrgbRO5uNix+T8nCqXtfpT4i+E1F7aRoV8bGhx WIur/DtIeUvK65CS1k/EbABYH/I4bJ3pl873tTUMX7dgHQN4MMZaJpexlgE+G3kc1fQlubTnpJ0z lc6ivGdGQ32kl7t7ZWvu7s0tXWvZ0rf6afDGI8mvdT/e2ve3YqcUi1v13nLtZzS5dqywvitNV5I5 MCZNB0+MLX3//K7tLdN3JBNwanm645sTWHD5hmRyC09sLuWklFtRikkt8cf6v6uJFTXJIqtoIbOQ nsMbQ7gNuG6UYhQxmfvzfdVk0+aJxPxLcydgvdDitxWzh87dtPY1HQAAy4c1H5f2qvlYJ+lqxj+p DABzw1o7Wesl71jsaQ8AgMtD/j+qnT9w1J79WnmqRxpfh8panbV6y8f7DKXca9PsnrLXx2Nr8RsT teOLx987hnnXld7xsWa/M8m1tiG5ZivZx2yn5jOavVSPR67ZV7D+1jA3AgAAWBj+CcDeteS2DQPR kYME8L7oMvCm6AWyay7S0/huvU7RRZFVW1iuKJM2PRkOZ2RLseT3AIKfGWooORl+pQdSCwAAAGBO yBcivnfhtVbh+fnrkdCC40BksT8LgaCCp0OcyCwO6T0jtmgjEca+t5XyiSgjXONg7zbnS3P7AP+c 2ou2joO5tHUu7bwU45DjnK9FnQgtTuth7wktErFEG0ksdpHE4pzM4kRGEcgq/kR5iczib5TnhBb/ MlKLXbQl+/fHx4YeHn7Ty8sX2m63tNlsjs+sbds+BMKKRGKRk1mA0AIAlo1EXJFILAISwUUqW6/X 9OvtTawbcOYTEmFF2eAhCvXC9Ts7RxILoe6tExXcevs++vpT2FjCPUxh4yof+V/Ac4CNZdsZq61N IrGI6XQCpz+F05UfySm6sIv5RFrRhy4dSCtWUZbILkJZ0A8kGf0baTHdv40WCS2CrU9PT/S5CwZS i29d+NGFn/SeuKJEbpG/8LanE8lF6RBjk9Ujqh9Q4gelpImEdhgKAAAAAAAAAMbEpQf7uT4fD3NZ ql97WU47sF+Tawfxp3wJwFumxbUyi+6QfKnMIvPoePQ88MyzrLqanvVFAMsLBEMO+3vk3oPw3oP4 Y+lfw5ZHR4s9ZUPyVhkA3Ar4elg+Xiiled1GSBOd952kpKU8cD+w+tla36DlSSmT4lJbAABYLvh8 uJQv+Zt870lKS/b4hyAbIZAQ8/Q1YJm/7JUgkVrw/OFgok5oYfmwYql90n0AAHAf0OYxJV1pDiSt gRJhHgPo0PohLptiTlNqCwAMgeQHebmW5mNq6frcH6f6fK2JCmkp79lrGrKvZEnXYusekrUP8uwR efoubz/n8T2SrlZmnbNoMusak6av6VxLz2vXcn/WZ8TLpLz2O6P/mQbcv/LnnvvQ2m/CSS5Kfo2v X+Q+WirLiS0aZmeVXXuV2aj51LHG5drcQcpb/I/1/7DkA1JZW5B5wqUkFqW8dr8k6AD3hdxPcX80 dO+RsjrYewRqsI5lPONBy/hOsgk/CADLgzQe52vMtfG4pMv7P6Jh42H0f8BHwbOuUJs7afnSNQAA mBfyeaEm0+aPSVfaw5DWrKQ+29r/Dt0juNY1LGVcZi2XYp626njlHtklukMxpI+p1dHkWv9p0Rki 88yXL5FNEZfaUWuv11bNnqSrpWu/u+XvwiMHAAAAbhj/BWDvDJLbhmEoiia1ZzrTpdc5TJe5QM/Q E/gmPUCO0btkn2VW2SSOK0WEDcMACUqyIyn/zWhIgRApOROQoih9iFoAAACYGtEb+z+lih4e/tFq 9fMgatF9ELwTmuAPI7bJ0UZJnIKSaEUnYNHauvy7ErM4lnFeimJ0Gx3akekUmdsH+Od0vjjXyzCX c53LeQ5h3Gs8ncs6F7TYJ/GKFlvQ4ihq8XYiRHEUp2CxCileoQUtXoXt7aSuU0ELm/W6/V2e6P7+ F223W9psNgdhipygBYtatGWtDwQtAFg2LGAhxS04XTeB5On5mV6beLC6ve3spVggBSqsVMbptP8h cMGmJu8qwo3AlD+ejvqn08YSrmGMNuZwjl+pDbRzuTrO6qTzlT1tOyw+sU/CEzdJsOJD2IIFLpJo BQtY7Jr0eyrbJfvO8G/rvEk+h9U8je2uFZhqxuePLy+5U/7RbL+b7S/FBC2kz57sl+usBUBsk6IY pFK92CmyAAoAAAAAAIDPpHZhv96XeWvBPqkyPsa89SB7nG2V1S76v8aLAZGy0kL+3KJ9b6F+zcsA ueNz/n3tHnN7GaDmJQDLXvtigNyvWYxes7Cf830W2Q9Z7B+tZ6h/33PVx1llOl/zAgBeBgBLotTv kyj3jrXy8rhS3weAprbf9PqUXF9j1Yf4DcDXJHfvWxrf742tJGjBfhFBi9w95jUoxVh93Tqt3by6 9WadHwBg2ehYbd3HeLHbmvfUeTnPac135vIASGrnokrzY5E5MACugRUXtb1mHknu5+KxtEXyl/TT 6VjPj4Y8T4qUebacPVqew4tTufgVnZOPzhv1ec5QE6OlbYi9b/uReS/vt7BSnS+VeX7gepTmM7zx rf67ynkJFpiQa3HZ55vys/JayMKb73h38qT8KJPqfM7mEY1V0bjD+b7xw9v3bGNvuXa96/B+B10G lo2ORzoGaRvReTyy6rLq8Z5pftb8KZgPXqzKjQ059WIiOWWR9gAA82es/s/yZ1/MWYM5U7qPkvma +yivzPKz2gQATA/5P+o9g9BEn0NIWymlQtrHVvsMYUz/0vWQ4VsaZ9Q8myjte7Zo+TXHPqV+JNLP 5Hwi/VbEFul75X6kf46UR8pqfC6Vcr40Fqk9NlJWyvfZ12C8AwAAC+G/AOydv27bMBDGzwYMZMkU oGPWDgW69136Bh7yqp0LFB2zF0g2KxUtnXu+3JFHUU4t6/sBBMnjkWYy8J8ofRC1AAAAsBTkQcL3 PnwrVXh8/Ox+k3cQsjgXoJCCFJxOMYtZDOk3JWzRCTELOsUslJHaSKR4KR+0X9oH+JfUX/T1Miyl r0vpZwvtf+P5WZYvaJHS3fh7LGghhSZyghYsYpHEKaSgxSB0wWX/hC/ORS0ighZ3d0QvLz/p6WlP +/3++GF6LWiRhCssQYskZsGCFt04iUHQAoDbZLvdHsfLFOt0Crvdjn4/P9Of11d6uL+va1yPw5bY BQ3j9dvQmUHc4uCPba3gA/9ofy2/ca1CAfiN6/+dpf0tH9HfNB92o4gFizttxvSmT5/EKfpwGPMs WnEMfbobxS9OtlHI4jCKZBwVIpRgBt/q+dSv4x/6+fhXuatf+vC1Dz/ovXCFJ27BL7Xxy3EsciED ifRG1CPRTe8ykr4YZW0qPDsAAAAAAAAfTfRif+5lOZm31sikyoj89bT1ct2UC/y5smt5ESBqt8p0 OnrJv+XCf6291XcqtXstz7/mZQDPPvUieU16zsv7nJ5Sf646pb9n7hcNSmXRdLTc8wXgmrHmdF1m rRH0fO7V89YGJOya2734AWopjcWcL43/LfNHqT8AgHVjPU8aLt+dk8r0pRH23Yq0bMsKlIkvSWSc 1cETtZDpkpCFbqN2f4dxG4B1Ye1DvD2LV1fbiN7vaXSalB8ATPRsaco5WfRMMdcXAOZAj5XarrHG 0sjZFPt7z5xKaWmLPFdqffYUKbNiXa/ka9W10lbes9WUTyU3JkXPgnJ2TkeeF8zxrKOmziV8I2Uy jpZZ+ciaCvxfvHWtPrvIjcGdsEmBCRm4nhS30EIX2nej2ts6bVPBRpmYnPxUWtdzXlwqi+Q9mxda fK1+R/8PVLCB9aDHIG2rrW/FDPbsIEd0vemNc7XrSc8GAFgHpfnPWo/rulYeZ9ZgabTurTD/ArBe 5DznlWm8fWb03Izb0Hltj5z7T/WZ6l+qU+pLyafkZ/nk/Dxbzl7rU+OXmDJvROvk/Lyy3Hm9V8+b A728d6ZXc/4XnYtLc3ekfqS9OerOUabTnr+VL7WT8wUAAHBD/BWAvXPJbRsGwvA0dhYGuusFCvRQ PkHv0lwjx8gxcoKuu8iyAVzYrmlxrCnF4QwpVbHs/wMEPoYvBTHf9g9RCwAAANeEd2H/3Sro+fmF Hh8/X0Qtuh8Tpyg4cYxxJOIoilNQFK3oBCxCXOc/XMQsdrte5ILT9sIW3cP1cT0BFrhYyg/aL+0H +EN7l9TWwBLai7ZOz1LaOYb6dxzuY/VCDsfL86+gxSG6+4vbPUF4oheh6EUpdqd+mMUq/sRwJ2YR 0vdiFvLh/CySwYIZ+o++bzZHent7paenH7TdbgeCFkGwIidoEeLCw4IWnAcAcJuwgMVqtRoIWzDr dbdl83u3oy/DAvpJZk7AQgYp9rJR2OIsZMEiFzJuyhccNHfcmLcEEYKPLH+OOm7hHeao49r/1+eq Y656bqWOpdUzy9+9q6j3R8JYJcUnHqJgxVnYggUuomgFC1jsT+462vYxfi/Th3KDsFMs8/xttLi/ EOK+bjb06zQW/3x/t5r97fS8kk/QQqa5VJt5SImTohiUuOllX+sCMAAAAAAAANeGnLPmLuXnKH35 O/elO1JsubRjL/P/74v9Y9qp2UvleG1W2HsvwCrPU4bFFAvd1rWWJ5/nMrgW77lsXrKNudQ/xWV8 rQxvvilcqw2ecrw2K08ujSecgr0BcCvI8Trn9/ax2j6aJDfW4bMEJDV9c+14aOUv1QsAuA/S8avU P7DLZ1jc30gx9r1I+5D407GzdLYl25QyZh3mne8OLx/2YUuYIhWw0MLHiocSPwDgPvDsSabpPP2c ll/mza1r0AeBHFOuZ1r2FQGYC23fJ7Xl/Gna0nw2t9/Uch409qxp7PmWx62J09Lk0mlxpXjL5kHr m2riPfv6LWcJLecaVlxtem95NXVL17JpabWw1wY+Bs882eqPOY/cr0gfedc2t5+hiVx8EuWSUnau 363pN8mI0/D2SZ55mfX5q+kLvGGOOyg2y14qX3sP7R0pYwP3RWleJ21pv0SZsDYH1OagOHsEFtZc p2YOyf7SmJCrQ4sDACwbay5OBX+pTJm2ZgxEPwOuDe/eg3ftgfEXgPshXTNqdmt9KdNrY3bqL51J tLoeW02eFrfW5vGX5ial/KU8HtvY84sWvHO4FntpvPTEtax5Pf6p0nrztqzNp8hfW1bJr6XPhb1p auwAAABugL8CsHcuyW3DMBiGvEiybxfZNNveoUtfo8dLztGz5AKdbrLxtLZr2oIMwQQJ0XSsx//N cASCD9FphxQf0g9RCwAAAFNALlz8PIQfuQIvL987QQvNSchi3wtSkILtcGUxi5O9V/ZOiFlQd2Wh DBax0B8ln9oH7afU3im1NTCl9qKt9ZlKO6/B9xv7616nIuzbtfVoMQu2tz2hCRayOMXPwhR9wYpN K27BAhcxMYu/dBbF4HAWz4ixWhE9Pf2jzead3t5eab1ed3+DIFKRE7QIaRC0AGA5NK2QBAta6HgI LGrx++ODvn25kLXgiogS/QWLVXS7mdwft/c6XsOHvEXemkzh4+mo//73mMNvqHGPKbRxSfeY231q 3eMz/yZ7act5RRCcaO0gPiHFKbZtnEUrjuFg71rxi87XCl8cvzZzsPmtNPkWGo+dXx8e6Pnx0SNq Edaqfh3CH7oUrrDELeQHgvZ0FrmQgYTdiHIkmmkdOvIcbsIhYAAAAAAAMGasF9tkmiZ10N96bk69 TFf7EP+QMjXq8aZ7D/iXvBBg5YnFvT7PBHWsG3CeOZj3sPfQlwC8LwDUOvBf66C+Va9Vdqi/5Fqa x2PjhQAA4sjxO+azxvch9ZMo10TSiMY7voD74hmrrxk/ddz7DAAAWB6x8ZL9Ad6zYh/vOa2UvaW+ 6IUcHxtRj55v5uatt8QzT7DCTtkx8YqULxV0W2JtBgDMm9RcRs9DtJ2r0ypPdFkH5jLAosZ8pmQN zNMGAG5Bap3H+r8Y63Nz/XvuXFfjSCOHz5PmLZPzx665fNrOxa3x6rP2hUrW2j1rOZZ9zZ5Dzh+7 lqaV1OP1p3y5eOrfC2PL+NHPr+yL9bmpZ2Q+hyvr4LWPbZsmjwnLsDf8DfXFMKxACZuUX//WWHwo qT7pmme5kv5C+71xr8+K59qWslM+sFxi/Q9F7JK62NZ1YL4OLIY8e6Zsz/Mq+kcAlkVqTcOyh/QJ 1ngq04gwBoJxUrr24133sNIBAPMiNd7ptFRclkmNm7E1tdhc9B5Xz1rZLfckSvcqPPGcf2ie2gxd v/CmW/m980rPuKrj3n2CkjXRXHqNfLXvVZqeyh+Le/PkygAAAJg5/wVg74xyGweBMDzZqmq7yhH6 sJfI8x5nb9WHSnuBfdyLRbXaZGsbnMlogBnsZoPzf5IFDNjgpAXD4PwQtQAAAHAtaJNvzfardKHX 1790f7+dRC3GHwenIDhxDDZiNgriFDSIVvRHL1rR28b4IdgP1HUnkYtY9iRsMR6xvlgPDzmt/aB9 S+1tqa09LbUXbV2eVto5h/Q9nq+B2QQtePg+hVzU4iRK0bFwFK84CVyMtnOBC34uF8c4hLiulnR3 t6GHhz1tt3t6eflNu91uuu+UoEXXdWeCFrEcBC0AuA24iAUXtuACF1HUYv/25rrucYxEw3QMnkfW Dw9leTluW6AfuvUf+G+9/Ze4/lrqaEG8BXVcZz2t3culPxNtxwwF27cgdBHjvWDFIGwRBS6CaEUU sPjox9WQ9xHs8ddmorgFV5MY3kTrxTNCPc+Pj/Tj6akkbPH98/j5efwhm6AFLzNVqxyUsHFRDBKh tgFYezEGAAAAAACAVii9yJZ6xs1t9Le+mKeFvB1zNv2XNttf6oUBWZ83T8ZzG/g9LwaUypfOXaJs Ld55V658zWZxaavZ8G/Z/L/kBn7vtbyhp4zlXpd4KaDmO0qlJZj7g7ViHb9jnMi/HibHfA7W1kCJ OeO0dxwu1QEAWD9yXNTGwdR5PdGHFf1UMe/I7DLk/irNt0VKKONfQanf5M/wR+WQohaeUDtybUm1 GQCwbr56LpM7xzI2ANCD+Qy4RaRvJ5VX6ptz/bxca9oIOxnDGh/Qkv6i0nO+11+UOz93jjVvCSzz qpTN0i/O9aOU/CA1/pSaczxttthKae/3Aq4fbX2DSO9DLdeRaxZE50KeGxGXaRmXax+yf831u1Sw pdA+jxw1axG1fY3Fpq3BeNKWvFT9uXuRoM8APdpzHLdbnwm5TevXUnNz+B5BidTfh6XvnzNXBwCs n9RaBpFvDMxdM/c8jzEQXDM14y9Pe+Zk1roBAO3C/69TY2/My6XlOdLPkIqn/BSWMMZTa10WX4Jl vWyOT8Lis0iV19LWMjl7Ke9/YR1jPGvwnvHMOkctpS3X8c6HrWuonrJLXcebn0tbvj/rd+wtAwAA YMX8E4C9c8ltGwbC8NhGkhsU3aSAN93lAAVylF7H9+qRkk2AALVd0dLI4xEfQ0pVROv/AEKkhi8n AEd8SD9ELQAAACwduYjxuwm/UgWen3/2ghaaVsjifBOkIAXH3ZXFLNr4WcVPQsyC+isLZbg62vbS c67aPmhfU39r6qujpv6ir9NTSz/HcPsbb9fHroIW17OETqii5aSEJU6d7SjELFiAgkUppFiFFLP4 7NJX27DM365+rvdIoTW0hwcnavFOLy8/6HA40H6/74UppKAFi1nIwIIWLnAZCFoAsA7O3YeydXDw dbfbXa7vHx/J+noxC9897VdcW9ttK17BghecnoAaPvBfe/1ztFF7/XO1s3bxljnbmKude/otU7Wz hL6yuESfz/nRLu7EJ3oxiyYcu7R7gt+xsAW14hVO/OIibtH4vctzepNmUQz5dtq2bagXzvj2+Ejf n55SohaO1yb8acIbDYUrQuIW/PIcfwxI6mv4XsjaiHJEw0NFvsNIpPIO/sSB+wAAAAAAACyR2MF+ bZfEnntTB/p9B/l9z99sKzn0n/tSgPVlAUudKVsqn6W8tUwob869HPvclBzqXtJh//95oD6Wb+yB /9K6rf2z2GNxX9qaJ8cOwL2gfS/fI/L7YJ/NV0eqDVkXszQ/A+al9GWtUn+d80wAAFgfoXmttBMN 58YuLkXU9R6ULLMRYStsvrlqzsvgY7COs6F9Nxm0SEWOmMWJhu3q9gAA4KvmMqEzAmDdlM5n5H3M Z8A9Edt7yt13Co3FG5XmOkr3lEJ7OKm9oJz9pFg9JXZfOpU/VXaKvNaxyDKWlYyNY/ZRlnLleM7+ SMpPWPyI1Q6WT2zs9K15xP7nzuYT53ThKOLafvbEiYZrIKTK+WzyGrqnbbmMWXueajxJ3YvFQ2Wt 7Whb6ndpMG4ASWiu7Rt/OE6EvUcwPZirAwDmxuoDifLWQaxtaOAHwVdR6oPHrgmV9AMAUDfWvQjt d2Npqy/WPt26N5HKkyqfymO1pcpY81vT1jwW25i8ueT6kil8YEnenP0BmS71t1PHx+x/jK2vpP5Q Oudejh0AAMDK+CcAe2eU2zYMg2Ei64IWww6Ql91le+xN+pgr9QZ77XH6MOwGQ4PWWRRbCcOSEiXb TW3/HyDIEmXKCRDZkhj/ELUAAADwGfAG5DzkHD0+PtF6/b0TmIgvSadTORCyKD4R8lacgo6iFSEF 0YpQ1x43XX1zIWwR256FLdrE+5R5jqm90H5K1zulaw3EF11PgSl9t1O51qlcZx9aYYr4GTVBi33X hh9fClqcRS1emSCFFLN47cQsdqe6y7JMb8zHWTTDYr0OL7r9S/f3v2i73dJms3knaBGEK0La7Xaq oEVoA0ELAJZJGANXq9VpvA/HIUXbzU27ZPPv5aXU8fvjKF7RdtTuEnBBC3leJXjB//T9f0Qfc/gM Q/QxhWtcUh9z62eoPq79nWgRL9TVrZjoRBSmOApbRIGLUI6iFofjt0P+tROz+NKJWcS2DRPFiDOS hglnhH5+3N7Sn7s7ek4LW3w7pJ+H9Jt8gha8zZ7OLw2SKX4F/I92RJeiGCTyXJARJh8AAAAAAGAO pAL7pV2Sei7Wgvu1P6trQfry3D4B/EME/+eC9/v8McDjy3uOVbbqatuX+PFSO78qDQCvDf4fKtDf c05NkL3W1uuntK5P/x6751yr7G1TYgdgzmj36lhPpN+n5XOD/E3X3AvwOwQp+vwBLHcvbw0IMgFg sST28OTc9XSKUhfg4utSUJ3vS3F9eO5H28/iuex/THJzlr1ybKVGOdbELGI9KX5T14fxG4Dl8hFz GasPrT8ALEafz2RsAFyT1FqRFXtl7Tl595u4DyvWy9qXSuX8XKpok2rvbVtTtupK7ENROo6V7AuU 7qOU2nL5EOfmbN5jT1mC+8j8sMZMjjf2lcfVRr9yXUOL1eXjGB97tXpS6nmdtMs6jZSt5jfRZ+/T GitSuWctxmuvGbus9qTYAZCUzNc95dxzYOo6ALDAXB0AMAapdWZittS6dc6f5x6Y8gnAtRn9Hoz4 HwAWyfF338X/5NbEOKn1MTmH1fYitP0HrY73l7JpueXDsln+Su2pcs2+hPX88ln2L2rx3nNK5o6l a3ElewW5Nl5fpe1K24zhs7Rc811adTVtAAAALJT/ArB3/rptw0AYv8BAkMVbhy5Z+wid+i4dvHTK M+ZB+gpFhwBZgsgVbdE+nY/kHSmplv39AML8T9qASZFH8YOoBQAAgGuGb0r87N33UoHn528HsYpL 9oOQxX7kuCBF9IfPKGZx9O+FsEXHxCzo9BmFMkIdhxYr943XdqH9mvqLvs7Hmvq7lr6upZ9+zmNj FLc4xx/dWdCiG36HKGjxaRS0+BjEK6K4RRCziH4uevHBynJ3rHv8zumYpyei9/ff9PLyi3a7HW23 2+E7HQUtgmBFcFHEIopaRJGLKGjRDZMWbI0A3B9czGKz2RzCXOgixAX+vL1ZKyRV0CISBDOikEW4 oJvnj/6GOefeL/hfe/+XqP9W2pii/lv4HW6pjaXaWdt3ubbfJIpLnMox0YmH3n8Ss+jd5xAOq4bN IF4RDCGdDIc8g8BFEMXgt/HwW3rC55fHR/rau4KoReBH715795cuhStS4hb8wqA9jfU15MtZvIvy ciHtk2h8WCB1aMn6sh8AAAAAAADXinzuLaVbnpNjudyBfu6Xh/VTcaW0VH6eZj2gX3N5Rmte6S+F PQf+rXHW+ubGs87yHBCvOeCvxdUeavccrE/lr0mvqWvKNnN+T5onT6kMAPcMn4u1NCJ9zie6/C9p zwKpPTQAUrS+7OeZFzAfAAA0cuvUEtGGJUUu+MvpDyJMIo7IvkacA8uzv+bvFL90JUGLlF1PtgUA AIG51zKpfADkWHI942kPgP9Jzu5UY3Oy2JhytqZaG1CtDcmTnvNr4VL+UllPei2145jHTjCVHcVr I/GkTWnLqQlLMH/cPnIM5PFyjORx2jM238uQYW2vg495WtiSJvuuxWnhVkprgtr/bWlsSO25tOS1 1mP1kyEegEhqDNLSUmFi8Vivg1awVgcALMnc+9baGIN5EFwrmIMBAEuTs0fIdEnORlGyS3C/tu8m 8/L+afaMlH9KG4T1nRSvncJTLhdfm69UrnWu8JSvmbe8+3Ge/cxS/pa6LPms5a1lavJZ2rbGtT7n AAAAABf8E4C988ttHATCOFqtKmWlvUNv0lvkBHuf7Rl6hD72GD1BH6t9qPrcVZOa4HEoZZg/2Kmc fD/JAjMYcJUChrE/iFoAAAD4brQP/X+kgu7uHsLV1e9RYCKJWESiyESMUxqJT8QwiVOEUbQiCVjE tBTfFWIWRxvFc1GMvM4y9LC2D9qvqb1o63Ksqb1raeta2inzdZ3rKOSQ/A7Tt2lzQYvdGL5P4VFw IhehIGGKUrzibRS3eJvsx/j/Q95UTi5s8T7Vx7HZ7MPLy2O4vf0bttvtdB8kUhGPKFwhCVqkcQPr eABcIiRgEYUrSMSCwjL+/PraW1n6EPgYL9vxRdzCcS+9rEGE4JzLP0Ud53APc9SxhjZeUh2oZ7ky 5qyH82yJaT9GoQuKR2EKEq44hPF8GFMPAhbD/DsqRfyMQhZxDB7FLCjvLhPFoLeiDl/qieIZYz3X m034N8ztn9rCFr+G42Y47oNO0CLPM1VbOehPkOtthPD5o0KhCGuORJwzMQAAAAAAAOeE9BK4NBdu zZd7nftbzvtzpHmc+jnne6uTv+TE3yqDS5sz3UKrjLmepTwf0+hx+O9x7vc41lvz1OIaR3xveT33 ILVTm6b5LeHZHYA2tXG1Zqc83BxB87+G9TQgMceLf54XAgEAl0358nieVtqkPoQTtOD2rMrzPGzF l8Dy7LCvxLVHKYBRK6NWZ6utAIDL5JTPMgBosP6WvGMcfrNgrZT9cssm9eH5ddxcPo+XYwaXxtm4 fKXNYm/ll84t+0OSzZNPQttPadd2evccvPsee8FmyWdpTyvOpXn2xcD5w/WRIdj9YSlvbV9fs97R Wv+QbKESr5330NsfSWsoks0ScuV56m21vwR9CbBS64NyG4HndbA0eFYHAJwarFsDkMAYDAD4Tlr7 ETW7dk+CrtW8B1PWbdmD4NbrvHsRljU2bs/Ccq10ndbmybcEc4xpljza9X9Numd/wbMnY82bn5+i jpqNS9OUy4F5CQAAADcfArB3NrkJw0AU9qJiwbrqrtueobtK3KOnK1fpIXqGrliWClKbxMlgZuwZ kwCh75Os+GewTUWdxDPJg6gFAACAW4UG9bz79Fr6wPPzy0GsgiMKW4RjFKKgghS0LopZhPx2mwpb 7ImYheuPUSgj9BEY8yXlc3uh/Zzmi7lOx5zmO5e5zmWePKd7ZcM6ue+P7Roan/1s84PIxCBo0Ypa 7DoxilaQohWviOWfTtwiClwMbYPoxbEgxtB/XtBiufx1m82XW68/3Gq1OhG0CIIVkqBFaIOgBQCA EoUrqJgFFbRYLBaiqEUvVMGsJb1YhSNR+514RdMauBMBiysIWtzDi/Hn3v8lxriH7zDGGHOY438a 497GGWuMW/+bRHGJvo8gONHlg/hEL2bh086XH/w59XCd3olXBCGLXcz7dBC7CCIXncBFEMUIb+mJ G1JUPSIcH/15+cmngqhF4M2nT5++3alwhSRuQV8U1LhjfY30oS06xXjzkj6oR4/OHd+UScFJpaAl AAAAAAAA5sotBPdLgfma4H5u7mm+ZKcN6LfY1wT35/qV6qy2tXZTc05AuCX4n6vX9lkbSK/J13xG E/A/Rd4ypqUODyoCMB3cuVSyiWj2wmh/+P8EFsZe8/H7AwBoofeitM45vR+oJMAu5bmjE8pjk7se T6/lm0zemtLPcuNiDQcA5CjtW6Y20U6ztuB+BtQy9ost8PsD90Zu7bb4m2i5xteUxoil89H6oVJb rl2ysZYtPqCa+qmw+G1KtjW+CKuNxedybl+l+WnKKThvgIi07y+th5r+uD2NhpQ5G27PI7cPkvru ue9Q6/u2rD1cfa3vtbTHkrPVHrVtpTlLNgBYqblf14L7dVADfI8AgEuC8yAAx+A8DAC4FpyfONee UvscjNTGXSNIPoicjXStoclb2riy1iZXf07bLTDGHn3pd6W119rW+B3O8WPQOut8xp6rVGe1tdoA AAAAav4EYO98khMGoTD+qh2ti668QE/geXqDnqgXcMYbdNXjdNlx76KjaTCQIPLnQSAm+v1mMiEv L4BOG4QHfBC1AAAAcEu4E3A+Qhltt9+0WLxKgYmq3dtXiVkIlPCELm5xPJIUraha0YomfS1sIdLK txO2qGQZl+Xo51xMbUP7KdUXdS2HqO+U6ioYe32nUs+O67Ezm6BFYxPnk7Q34haN4MRJClB0ohZK jKITqOjEKzqBi8Z2KXChnv1r89MFM1xjb/P5Ey2XB1qvT7TbfdFms2mFKcShBCt8ghZK+AKCFgAA gS5eoafVIRCiFj/7PR3q98mqTjtRbYLRNrTiFj4BC3lfF8LgMPYN/qee/xBl3MNnGKKMsf+tD1kO yrjfcsZeV9+slpkUuqhkWghTiJ6EELSopNCFkK1TQhZCKeJZ2KTIxUzazz0QTRRDrbY679oj+7Ui v7fVin7rdjkgbPFSH+/18Uk8QQvdpy3WcqivQNfbILoUxSDjbE72SVnMBwAAAAAAwD0RWnBXanK/ a6K/7Tc7kb0bFJrYHzupn7MBUa5FANx5AbET/GM6mrcIrMX2uVI23OgzSb3khP6UTUZKPRP7uXMt DMCiAACGJ7SIz+fr8pnKxAwwHnK829E+AABisLVXep/TFxs6h9g0P99BlrTvTI7rUnAWGNvOZroy 7CfHfdNmq0NKHwEA8LiExi1tfgCUAH0aAPj43t2+/4OYWJPLbv7W1+sQih1xN40yn7HZOXnE2FL9 SxMbv4mN0fSNidjSnDz71sF2zfWJuQ8eG9e4B1G/+bD6WIhehsum3zNttjMlXnPIGb8MvQ9i7/v8 Y+9xyrWBdwrIDbe/bvoCkBP01QEAtyJ3O4h5OGBqoA0GAIyJULscet9wYhO+vH1rYfTnfOthTD/f Z+LGK2KeDdl89j73YjG/61L0HWNLHfvnxhBS4w+xPn1jOqXqleqb6gcAAAAk8S8Ae+eS0zAMhGFD egTEusuqUtlyG47S67Fl3UuwZpFCpvE0zjTjVxKrLv8nWcTj+FERObHH9g9RCwAAAPeIu8Dnowvv oQzb7f4iWDEFC1uwAEUfjBWmOF+ELFjkwhWtcMUsWPBiELMw178slkFlEGsfVF7bgfY1tRdtXYea 2krU0t462nk7J9e3+9eJtzadBS3aq7AFx3sbi1qwIIUrTiHFLH5sfEi7zTOIZLCohTYPt9k8mab5 NofD1hyPR7Pb7a7CFCxUQaIVLGbhBghaAAB8kJgFh6ZpRqIWZCNRi8/TKa4weh/Qodt0iDd/GLOg hSt6IUUspOiFLUevZv57595FCB69/BJ1PMJvWKKOGtr4n+pAPeuVUbIeFpewkV5wwtrpmsUs6F3W WlELEq84s6gF2fm6C+QgobTWClyQKAad3MMTU8+2HhbOeOneza9dCIhaEPsuvHXhy9wKV2jiFixM wYcHufoawyBqvJmO8xkz3kgn/xozHvBoC5BSN/YBAAAAAABQM/Lbd63F/fKAIS1NtkE7hEM7GCjm 0CH3Onfhf+oi/zmbAEKDydTBZkmnWs7YKmdhf+pmghIL+WMOQ0mNx9Y3p46p+Fxbzj0AgOXQ5r/m lgHAkuAZAwAsjeYr0saXrnD6VDny4EY53osdi5YiNF6Q4xNpk9dTfjrtWmuDZgMAAA2MZUBN4FkD oEeuy/KlS3y+JukbivE7ad/+U34mNz51gJTvd+X4glJ8RqE0Hyn5UvuxFL9Mqn8h16cR4yfJ9a0s 5VcK5QHAh9Z/hfo79z7f3Afnk2tupU2W45sX0Xztmi2X2D5pCX+uNsei3ZdjS2mDBP0KKAHG66AG 8IwBANZC61/wLgRgAM83AKAUsr9Zah+Ma/P5J3xxzc/g2zcj4yF/RSj/VFyzpd4bm750vhjmvodi 84d8WnPTUsrP9VmEbLl1xdafak/53+J7BAAAQFH+BGDvjG4ThoEwfIIKKc8s0IdO0lfG6BDswxgd o1NUHaASBJrGkCOOsZNzbJMY/k+K4jjns0EixjnbP0QtAAAATIV0MP8x5Gi3+6TlsmgEJqrrHrws ZqFg4QkWt7gIUlRXkYqyvIhbKBGLS/pW2EIXvODylzq69ejnlOSxoX1LTu1FW9OQU1sVubR3vu28 fVfXFbSoGtEKPa0LWrCYBQtaKPGJo0XM4tiIWfBRatel5ThpPto6XKxWqt3ftNm803a7pfV63RGn UIIVuqDF4XCwClqwPQQtAAAmLGKhUEIW+rUStVD87vdUqPSA4ITpt+pm0FXMwpZnils4fIbwCBvj w/9z1JGLUADqmF89uX2WnL6TvlW1Cxa64P5UiVjUZyVawedTcz4fdfpF5TUiF4sm/zwS4TLUjlz+ NOEMVc9rUdBP/b9fIGzxVh9fJBO00G0qajcQMg/+Clj4gvN0UQwyzuZivaEFfAAAAAAAADwrqSb3 28pLJve7/rf3bS7kSkvsfO6NtffJj70QYIpA2pjx1tiNflJMdve1SV0+ZV2++aGLNgAA0zH2dzm3 CRlgXuB5DwCYOz7xIbY1x636eFXf1JHIb2yZCul4QnKuBq7JkWfzBwAAsQh5rmA8A4ZAvwVAXFwx Gdt9G5JYU6w4k2lna4urTdJ1oT7xH2mfNdU4w9cmxgZILh+x4i36dYw2ukBfA2Lgel7Znne2tO0d h+nHnGdrm5Nr808OO7Lcc9F3PzQ2GRqT9bUZSofEhfvKATAFGK+DVOAZBwDIBczDAY8G+mAAQI5I 3t+HxiZ0H30xCvO+y7d0vYvEXlJmrK30vq+dT/lYfdNYPyExgLHv9kLWdNyjrNRfX75vG3x9AwAA AHfhXwD2zh65YRCIwqSxKncpUrrOEXKVdKnsY+YeuUEO4Jko8oS1tQpGLBIgEVDeN8PY4nftsUFo gQdRCwAAAKVhboZ61eFlqsDh8HwVrHDBwhYsQHELahCmsAUrWNjCFLNo21v8r5iFGl5ZLIPqJf7i sPJyD7R3U5O9sHUdarKVqMXesuwcrx2UBS0ufRoLWrCQBQtOfBuh7cUtWkO8gsUtvvQ1vzdFL9qh 3H3o+rqEAUTTNA/qfP5Qx+ObOp1Oar/fD8IUJFRBgYQrbEELijMFLS79IAVBCwCACfXXJGJBga85 cHzTNNe0tpPFd/rCY7EK89UFtbshQYva68/RxhY+Q442Sv+t52ojVztbaaO2dmqyVap3uLemcVMZ p8bo+EHMQoeuvybxiguLWpA4Hb/XgZwklNb1AhckikF18gOqO/UInf6426knPUbPELWgZ1rvOnyq sXCFJG7BwhTcrKmvYR+OY5rIExvXhjrXZmUz7+grFuIBAAAAAAD4b5S0uN91Ld3fTy3qDxGimLMh wJceUm9qWkreXITOtVIPAUpZKB+7aD/0wJHU/HPiQjcIpGwOwHwaZAc+6GzgiwYAAFAyvnmjPdec mkO45qbsk7LrkOaHJczHQg9StA9VtONc6b76JFsAABuiovlYNYYCmTL2BwAAIsjha4rxM7lscd3T S3ml8q7PK9meekDU2h1j7EFLvvQYf0aIHyXUt7OE70cC9x9gTaS+yeUv9/nR7bLSsw/fsxCfbz7k 0DxX+hL+ydD/+dx+ZW5fFNtnxfazAIgUOocv0igAAAAgExgHAQAAgPVYwjfB5UL3wnDclF/CXqMk tSnlcdlqX8f4J+b4HpbKk5M19kIs4SsI3bcx1/+yxP4RKT60jtgyKXkBAACAbPwIwN75JDcIQnGY 1Ewm3qGL3ijLXqG3aVY9QI7RW/Qi2XamTmL9AwaJCigkmnzfDINB5KELI/B4P0QtAADgHrgGt/iw NXQ4fIskSaXARC1gUaLELEqU8IQSt6gFKfKWsEWZsuzcCFiYwhaqzkXYIpc22nb0/NbMK6C9nSX1 l77GYUl9LVlKf+/bz+s5vovDV96ktqDFWeanJq+PdfEJXZhCF6rIpJjFnyxX59VxVgld1G3pwhan xl4faZqL4/FH7PefYrfbic1m0xK0KAUrbIIWqu5Mnd4AYAYoEYskSSoRCyVooViv62mb3+Id03Fx 9eG5KurnXQpvurCFLlqh/zb+K1rCGFrZVOYuQvDo7d/CxiPcQwgbS+jjM9l4NDuhbCz5mXTtCivt nKUYRfW9XhdWwhSVsIUSuChFK2RepeJ4XZZJkYsXWV6NTjRRDDWKUQoUZ2njdbsVb2lqE7ZIi/Re pC/hJmih11FmVx1JPYKW3oZoi2IIIzc35blu1AMAAAAAgAsxnfvNsikBiPqc+l0c+s0gGy7Bh1yD cUwN2uF7nW97IZkyxooRJKnvXGjn+5DBj8aUhdogEGPTBgAAAABAbPrGjeYm8KFxY19bQlyPLW1r TfdysvQZg4zJbYEZXTdJAwAAAMBzYgu6ZNbpYkwQqb5vfJe1JiGu14+6+umznmO7hyn+bL5jkbF2 fNdsxq7JxFxDmRr8ybcOQGjMd11Xuc1P1vZ+1I/75ll0bKIWsfx1fdZDfddvY5xzqT9UFwAAAAAA AAAA3Am1D0Zd6zNnPEbsYsiWi+iF2abJUOzLEGs0PnZDEmr+zLedWPtfus6PtTV1/nSqnZDPFAAA YFb8C8DeuSM1DANhWBThCNTUUNDS5iCcDu7DNWhpaCABb+x1NooetmIncvi+GY1lPVayZyInWXl/ RC0AAKAmbHC+lyY95zrc3z+4UAxfQYUtVICiTe5AzMIeNW+FLVqhi60Rs3D9UcUyxK5QS9BymUft QfctSxEKEJjrPCxprsJSPmPnv6/H+wj36+K2P7ZlrajFoaDFphebEOGJ9tyKUXx3IhUqaqHiFd/m XNvo+c+BDTtGWtBCgsd/uLe3V7der/trsYIWKmAhYhZW0ELqJKmYRS3PBgCoDxWwsGIWfn61Wu3a fn59hW0EbAZXHfss6IQ0+kgFnsDFrk4FM/55gP+lz/8c9q9ljCWItzBGneMs7Vqu8Z78al6eWybf i1k0adOdi3jFVkUtmvxG800SR4nUbTqBCxHF2PV1nXpEJ56hY9zd3u5SRtRCeGzSU5Pe3bFwRUzc QoUpVLTC6mvYYDn6OL8x/Zw7Fq4IvUjnvLZHtzhSDgAAAAAAe6ba3D/0e/kcAYhCNv02oXnF5pgr j9kcOl6O+h14e6bamD7HpvlQXWmwpaFtTrWXKh87h7G2AQAAAABqxfqJXCKf6q9t/d+NqSCNNfiZ xgZY9I+pupjtS18zAAAAACyLoQGWTvE1heykAkilylLjxIJIORdvn2Oozyc211LGBOMqbTOnH2Ws D6XUf8LvH6iJ0Ppmy33GCFzkxrnxjrG10B9/Skr9xbm1Y+xaVbK2neLrBgAAAAAAAACAMob+bz/0 v5kx+4SG+ipi5aXvx+f8Fn6bFJfyX5Qw1TsrU/SZ432Y0vrSd2xybc5xvwEAAKriTwD2zjAnYRgK wI34ZwmHMJ6BM3kgLmDCMbyF1+ACajKivG3PlrKuXVc2h9+XLC1b11cwIF3H+5BaAADA3KQmoniJ dXQ4vJnNpuoEE63AQlCZhaDiCZVbtEKKS4mFlVe4Mgtbl1KOS3k6WUmGG9Mvl2ZtkgBhTWNmrLeB sd6GecZ6fQ/ikNBCZRZat1KL2pFaWBlFK7LQx18XIgsruXDlFrXzWPutu3i1CV3Tk5eoqj7Ndvth 9vtXs9vtfp+LbCqsEHmFSCxUZqGbyiwQWgBACvq57Mos+jYhJLUIdGxLR1ZxUQ+1c8QWU1mDhGDJ /ueIsfb+54rz3+Utc8aYK849PZdScdY01miMNlD7wPm+LTURTzTfw7s2IqZoxBYquBBpRVc227n+ KPs6ycVDt7+ZqThSjDZU21fz/7mL8VRV5nieEySILZ7P27tJE1q4bb6NFVz4m74cKr7Qfa4Uw3il /+PisYmLAAAAAABgmLmTD/l9xWQX/phyExClPs++pKZ954fipfQ5hqUW9abMtabe4B9rk3Mzfmqi kaX6Dh0f83dgfgwAAAAAayWWkLavnjPvcNea/GPGLDf/chmTaDFW98vQ8ZQxAAAAAACEWCqJVGwN KdbWH1Ms7tC6VKjPGCXnICUTNuUmRcpNQJ8znpJrUQBLE/qM8o/57ULvjdD6e8r1lbGyn5KMea+n tk1Zx809L6UfAAAAAAAAAAC4LSV/C+P2kXtfkr8/ds0v1FfqOIba/JX1i7GUvM6W8/uNqW1zY5a6 BlnyfrCrc8hJBwAA98KPAOydO3LCMBRFRczABlKkhCZFWpoU2Uq2wuaymxRJQZdgHAv5gfyXbJnY 5pwZjX/64cLw/MS9mFoAAMBYsEX53tPy2tZgs3k5G1ZUIcYWYkBhiiqZWehin8ubWeSv6/bG2EL6 Nv1rxhokTkl4X5jSnJnrMDDXYdBzHWae5XXR5r4k1nGcXRdDi/hibHE9PloGFL8FYwoxq7hujZnF jyqaWejzpj/p42iZZsSq7t3gcrlQUfStdrtntd/v1Xa7vRhT2IYWtomFmFpokwsMLQDAF/2c0GYW gphY2AYXUWSktL8OB2VVlA5q+9Ztk/yJssFFYXtuI9sez7A5CNZPvf9bjDGHzxBijCnM8Z7GmNs4 ocaY0z2RcRJ7347JdMxj7V/MLNISZ8favOIkphb6d77sp0UnS/S1WAwulIkeTtnxQ7YvYzyuVupp vXYxtXhLy0daPlXZuKLO3EKMKcS0QqaTD7auf4hbWO2UKhtXNIkLuQrYAgAAAACAH33Eh6qESKW9 7wLqOoGNYt228y5xQ5MYh0vg2GaQ0SVG6dM2JH3G7yp65FPPV8golEBTn8/WR3ypa30AAAAAgLHT FvdV5YvaYs068cax55dc45YqYdgmsVgXIdmx3AMAAJgJrEsHuFuSwrq8viJSvr/XffJNxTauc+2a xxlaID6IKJFnnZB5lD45FL50YOq4CN0VaXsW+T73XHLtTfMo9uNLKME33/ceru1d+wMAAAAAAAAA gP/B9b8wdXWb6LK2qC5fYV9zmZ9v7qLqWhu3NLh1JeQ8hsqftNUL/a4xxFih2gEAAEyWPwHYO5vk BGEoAKfa6ejede/SrQfoEXoFb9IDeIyeyKXbbrRE8uBJA0kgoDDfN8OAkfzAAoQX34fUAgAApqQt 8UaTr1BDx+OPWa+3N7FEmTy8LBeZhUXEE3ZdiylqSUUtsrhUMgu9XUotLg2xxb0kQ/rR62dkTon3 hTmNmbGOA2PNT/5x/v9/5r3Q4uqkFXpbCy1q2UQtoPAJLbTM4tdTVkstpL4xPqGFn7c3e784mf3+ wxwOB7Pb7SoxhYgqrLgiJLTQEgwAgFisxEJEFiK5kOu0SC1O53NV3nmNaV7ffZ/dcmvL9qeFFsXn 64B7xJySvE/d9lR9LOEYpugjR/tLOA9L6mOqfuZ2LEs6J7ovPVulObNj5e6V17KCWdnf9MVmJbiw 0gq3Xjtxxastc5KLlSuXp5iLarMyTdh7puvjfbMxp+02JLbYFMtnsXybOKGF3keG8eJZ5BSI+ELK tBTDNNa+pEWxCYsAAAAAAGA4Y03uT/k9H5JQpEzyb7bVNYaYuQKp9VN4RBAv1zNW3wRTqe2M8f1Y fSKvAAAAAABopy3Roi82ZIw/VtSVrDHUh2aqZ7G+yWNj5RWhfVPGAQAAAADQl2eIM7W1n5pEKrad 2HqPIEf85hGxmaH7A8yFULK6UGw6Ju4aEv7EJMyLHVOOuqnXjNTvkFgAAAAAAAAAACyXtnc6uWQX 0lYuoUDXO8GxYhe+unNl6HEMjX8M2b/vu9Lc4wAAAFg8fwKwd8a4CQNBAFyKICqqKDV1UqTNZ9JQ peIRvCH/ygvyhFRIFFGwcgdeWAzGd/jOscmMtLIdlr1DSBjn8A5SCwAA6AO2Gd+ri5dLycvlu8xm j3uphFIVW1gBhYotdqKKQ1TFFtWcg8xC9luVZfi6Ol7fG9krQ2m8bxnSnJlrHphretLMM0ZoUZSP qdBCRRYqnPiRU6nFd424QuOnFFxUBRi+pq23kV0/1/NMJiLr9acsFm8yn89lOp0eCS28sMKHSixU aOFlFlZoUZQnJYQWABCDlVnYfbv1fK1W5z+z/d9iP3dUbKGHVmzR4rUMQUJwy/W7GOMWXkOKMYYw x/80BuPkqzGUcazwaVSeF0dmfy+zcLEpj728olCphdvf6L6LO5dXuHPj9lqgFFlsa5TCi60twoxx Px7Lg4sGqYXnycWziw85FVfUyS1UTKHSCpVc2BA53Ag3Ms8TORVX2K3I8UVd3Q99EF0AAAAAAOQn VwMirdPmx94h0ovYx21OyNxCc2NvLOgLuRp7pKzbpllr25xr3re+vtcAAAAAAF3SJJ2oXi82Hdc1 ZhzKtVhoo8VY8UXTcwEAAAAAcpNinenSd/uYNZ3QMZsEeiF5f0XqRki512na5APcEjGCi3Nr7KHr 7pfGCW2YF0OKxnDX1kBgAQAAAAAAAAAAni5kF7Zmiv83tVm7aModKl3ft5FTKpFbyAEAAAAlvwKw dwa5CcNAANxUESi/4NRP9BO8o48pb2ufUamcOCEgjYmXGDcEO3JSEmYky8YEr8kFjM0OUgsAABiL toV4W9/7vYFWq1fJsuLcrhOPS0tbLgKKRkxRF32sMguVV6jY4nA4WanFyRNbqCDjOo5BBRePnshe mUrifZcpzZm5DgNzTU+/efq/u5WOyOGW0OJk66OtD7avEU80UgpXaGFkFnv5K7jYt1zfiCzqcY9y T2hRFKVst1+y2XzIer2WxWJxEVqorMKIK1yZhbZNv8osTEFmAQCxZFYk4RaVW6jQIs9zWS6X8rPb xQ5+La6wdWnjlv41fjvyfQzN1GUN3KP5xJjCHJ8pxtzipIoxp3vSFcc9deJnWH2xogv9vHsxEguR RnBR1Udbn0vVzs1zVmbhSi/qFU0z5sU0YT67bYxVUch3tVYIEFu8VeVTwoQW7jU6jayl6C1Q8YX2 uVIM8Wo/WVFbHwAAAAAA/C9jHOzv+/3/3oH8kGQcMYf6Q+/FXNYyYx3sT5GINdV1iCsAAAAAAIah a312K1ljbMLaR/3TdmrBHjILAAAAAJgSsftMXa8JkdnF7jmFjNk1p6559CH1d/rUsgn2UQDSEiO4 6CLVfvuQpNg/RqADAAAAAAAAAAB9SLlXEUNfWXfo3kWfscc6TzX2b3NDCUaGjJdyHAAAgKfnVwD2 zl2nYRgKoLcC9bEzsHRlYWDhC/on/Br9IHa+gandSgPkNrFzm6jKA7uJq3OkK6epHTuVmoed+CC1 AACAsbGT8L3l8dpWYL1+aqyzcolCaGElFOIlFjas2EJlFvU8lcxCfOpkGU5iUZ/EPJWJ7B2ptVfR NqfS3pR+X9oah1Ta2r2dv43l6jj449NiXSG1KMQSLs28bKKQT2SliOLbpFZacTBxrAkubBzlXGqR eZHGJVarg+x2n7Ldvstms/H74iQVKrVwQgsrs9DQ75z0wkkwAACGUhdZ1CUXy+VSvvb79g3pMVyP R7Vj+UliUUorvNCizD8r1/vv8/p+e5yzUhcppDRJ/Vjbv5U6UpBZXKse6rjdelJqa+i6ZqVwwpfR fgOz7OQUGln52YordJBEhRZ3+fW9yivujfQiK0UWJyGGLuv5WfObOh7mc3lcLLpILZ7zeMnjQ5ri iktyCyemcNIKJ7mwIVI9LDMz5USa4gqbipzf5F16wQ7RBQAAAADAdLiG7MJuL7RgoUs7Q7wIMOWB uTEmRoo90UiMyZZClAUAAAAAgII2+WDbdXeIe8Rr898XnmPcawEAAAAAjM3QsZWQ174x7y/6TDhl y8QitEQ8VDkAqOgq6+zzf5tiP0qs8dwp7SMAAAAAAAAAAKRB1+eUhpR1efqMFdi8sfq7hoxfDKlj LKbUv0ifJQAAwBX5E4C9s0lOEIYCcNTWn0VXnqA9gJfqzZzxBN31Fj1DN12471hFlJIHTyYKTAIl 9vtmGCAJLw8XQCbCh9QCAAD6wDWgdpW91gVar9/NdPpkBRNpIbO43DaFgKIUU+SL7IvMQuQVIrY4 HI5WalGKLvTx1X70WhPLh+wF8u2WmPIl126IJdfbebYTWpRSiXy7lFoclNSiFFrkwgrZ3ylhxY+S XIjoQsss9pWYSSHScDEej8x8/m2Wy6PZbN7MarUqzkWEFpnMQoQWWmoh5dIOoQUA+CLiimtii4zZ bGY+t1uzTxLzOJlcjZNqoYW+jlthha7L5BVaZnFRL8fUXN+GLiG49/h99HEP5xCijxhy/E990E93 MWLsR5sWqv8YGdt7Y5oHNCMrofiVU9h1Nmp4ON8Tk/Oz/cTKLjKhxbEivRBln8QsTBM2blb/vFiY r92uidji5bx8mGZCC91G0hg5FvkJRHwhZVqKYSrrtLLtKgMAAAAAgHhoK7u4dYzU1Q3OuvoYRwhZ xV8LL0L+JiFidfmSgG9+jD8BAAAAAPqjTm6h2whN5o36eLnbh9BjmyGeIwAAAACALz5zK22fp0PM 1YQWvoeOM5Q8AKAdTSUXrra63Oc6F3oefijXMwAAAAAAAAAAgCb4SC+axnC1DfmeSd2H2/pmCILv WPoBAACAFpwEYO+OcROGoTCOP0pgYKm6dIa1EjND79LT5GY9Q0/A1qVbJQaXYuyXOA4RARKI4f+T rCSA81ykijgt/gi1AADcUrj43seurY51mM/f9oEVIV1v14VOSBFAoccaYhG2MNhCwyvi5905xO+X YRn2cVf3+Dw3lYXsFePtV0rjZaz9SGWs9XE2BVpsg2Pjn9dAC1MEW5THZfhENZQiDqxwWxdmEQda lAEYZSiGBllosMVhWTaS8fhHlsu55Hkui8WiCKawzRizbxpmEQda6PNhHwC4RBhgoS0Ot8iyTL7W a/ndbOR5Ngs7Hw2eOFCwutV9X2vb4vPpHhbG5/yPUSOVoABqDK9Oaj/LPb0nl9QqAp70HD7EQvc1 nMI2owEW4hIfiiALcWEXTz7cwvhj44Ms7ON/dt++xvYNarxMJvI6nbYJtXjftc9d+5Z6cEVTuIUG U2hohYZcVCdl5RfhRkE/kXpwRbgVqU74mhYmIugCAAAASFOfCxCdshhHXwEY5xjCGNq6ZmBIX7VT er8BAACAR9HFAo3xa4b6D5G3DAoEAAAA7kWba+JT5gR9XKd3MSe5xbU/8w1g2Jp+R7sM++myb0o1 AQAAAAAAgHO0vZd16t8NurxHFn9v/9qGfr9v6OMDAAAt/QvA3v3mJgjDYRwvdjHhtRfYcfbWNzvD XnKavfcanmjZBZYlTka1v1KbEoxQYsv3kzRCxbawTP5k60OoBQAgtdhNdazuY6yhw+GotK5dWIXM 4XudWFyWlQugMGEUfThF69YlzELCKyTY4nQ621CLPujC/3zYj/86JpeJ7AXjTSun8TLWNHIZqwRX hOEWt4EWrQ2t8Jf9QAsJm/jzAihigRZ+mMVvpK4PtZDPX0MtJCjj2s+Q7dacH77Ufv+mmqZRu93O BVOcuxNHGGhhwixMMWEWUsx2BFoAmFsYahHWa60v6z/dd5IJtfAn7Q4aur04jQRVVDbAopXtpcTW B8aaUu7tL9FHCfuwRB9T2y/hGCzZTyl95NZPTmNN2Y+ftOC3YOo29pwp573KhlC8bDbuPkCbVxtk oSXsQkIu7HsSiHG5w7FtuqQJ2655/7Wu1Xd3vh4Jtqi78t6VT3VfoIW/jQyjihQ5BBJ8IXV+KIYK XttgOVYHAAAAoFxzTEB0733DlAlOw9u9tZq67ymO3Zp/HgAAAEBJhgLPp7aRo1L2AwAAAFjaI9fS c/5x4rNcyz/LOACkNfa7/iz/MMp3EgAAAAAAANbq0Wdjcz/bK+0ZXWn7AwAAJvgXgL17V0oYiMI4 fhLk8gAWtrRaWPk+1tjwpvY+B6WgOckecsgFvGyALP/fzI5rkr0kzgCr436EWgAALsVvuvdalJdT DZbLxzJcwrN9ey3owgIo7HsLsfDFB1tYeIWFXNj5qg8J9Tosw8b/62bmY9nI3jDfYel8xzRXNYb5 MteYDkMs6o3UuwItduGcBVpsD8ImqvAJK31hFla38hkCLppttE/f31aqfVq7LRYim82HrNdvslqt ZDqd7u/LAi00tMIHWlhdj+t5vU5L/TwAIA4Lr8jz/KDYe4O9ZmmoRUfj6oNqM9DCnw9jiG7gbcdC ySzgojGfrmNDu/aQg0v3f44xUriHGGOMYY63NEZq48QaI6VnEnMcH/yUhffGzNUnIeypDKXQEgIr dDWxD7Io6pMQcnEXzpXXhCALre9C2zItwo1xP5vJw3x+KtRCPRXluSjv0g6u6Au38Me/pA658EWk 3ig2c+1E2sEV/qu49v7a1iPuOQ4AAAAgXTGCL37T17F21/rHtKGdex3Gug8AAACA+s/a4NLrN9Y1 AAAASEbi/7uS9M0BuGm8vgEAAAAAAOCoxH//P2b8YAAAAH7oWwD27uA2YRgK47jVcCBL9NCJMkTn KVuwRmeoukEPHJF64YAgaZz42a9WaCANEbb+Pyly8wi2yYE0Lfgj1AIAcE9DX0waqr2OdbTdvpui KH1YRdgav36vBE9ImEUIp2j8voRZSICFDrboa2FfPz8eR7dTPP5C9r8x3/tJaa5WSvNlrv8Rv8HJ +6CEW0hNB1rUrj279uRqIXgihFKcfJBFH2ZxVPtHVYuPD0EWfb9nMxZoUZa12e8/zWbzZqqq8ovD S0jFWKCFHGc3/iEAYG5xmIUEXOj6atX/6eb7cLi6z4urUkvIha3pcAsbeCH70ocsBp7QIu9L973U GDm8hiXGmKP/HM5DTmMsNU5qryWnczLXWPpap3uztScXYtE9bq+t7e/1PpyibbsgCxt254IsChd+ 4UMu3GOFu77Wqk9JjOiu3W6M5/Xa7MrSfI0HW7y024e5LtBCh1n4YQc2OQVyrNT0c0zUNtHPQzUA AAAA+Mut9w1TbwS5P7kd5wwAAADIUAKfYXv4CQIAAAAAAAAAAAAAAAAAAAAApvkRgL37yUkYiAIw /uoGDuDKsPUMLtz1IB5OjuJNXHoBk+pQZ5w3ndeSokBpGfL9kgl/CjOVGEhDykfUAgCwBPtjey9+ PP31hM3m8TcuYaUTs2J4QgYRCjGhijzGwhZ2e3++HMtI6095Qtj1/ZD9Yezv5ZS0r0FJ+8u+Hr0X e9fz+95Ob8fAQ1XFyEUMS6RL18UmYnzCaYjiy1zaaEVjxrcJXPTDFzZoked1MnYObHgJ1+tGmuZd tttXqevafG7koEUKWNigRYhZhBG2p5hFAScDAyiQjVjYmEW6HqSoxad/jzpi4hymMLGKtE2GnzP2 cWZbCRGCJeefY43S559rnXPnv4X/lbnWmGudW/pbplqnpH1dcp1KgxPdGiE+oZ+JrQYrujiFbgv3 hSOLLmQhMXpxp3ELp7edhizSHKk0sQvHRrre/WolD378I2rx7MebHx/SD1ccilvY+1t9bDsYIjlO UZnnieyHK+ylSP/gaixoQegCAAAAwLmmOqa4/i/+TnPS68P3WAAAAAAAAAAAAAAAAAAAAAAAAAAA ALi0HwHYu2PcBmEojOMmCCnM2XsEjtM79DhZumfuDXqg7h2iClol5cV+8AJWoFJIA/n/JMvUED8X VUFl8EeoBQBgKrFNJGJjL0MT7XbvLk3zJqxCm2h7v+G4XCNhFBpOoccaWlFV/TCL9vyhHjv/vK95 jNT7+w255D42sh+P9U5nTmsVc1ovax1VuXfcDbSQ3o/5YAjpJdzCB11oqMWPCbVoAy18YIX+XJrA isqEXGjQhQ2z+O7MeTnQYrVK3Hr95Tabg9tu31xRFM1zQpqEVQwFWmjwBYEWAKYmIRYaZBHrsyw7 Xfe534+es7fbdCy0IhwnYWNuG4SR6HUTfv/de8jBf89/ixpL+B2uUWMOa3ykGkurc60aS7onU9Wx z76z2eV56sJ7I+nlOWfCKU7/0UiQhbxTCkEWaQi/aEIuwjkbiKFzaGJEEuaV80957j7KcijYIq/b c91e3bhACxtm0ZSNNL0Feq2O2c+4Tn/sHMfGAAAAMAO8y8aD4Q8eAAAAAAAAAAAAAAAAAAAAAAAA AAAAuKFfAdi7g56EYTCM460VwgfwqglXPXjAL+QX21c0XkhmlLh33QPddNkOrFL8/5I3pdC1hQW4 9bn56w0AAP6d9JC916Zepi7Ybh/bcImUDmWJwRMuqVOYhcIrFFyhUphFGmyhMZovPo7n+GredN2l lHZ4OvtdTkl7NaXttZT95t3rWKCFjm11XahE7FuIRWy/mt/Iz7aGgRYWRnE4qBRUUXf10YVZ1G2p r7ALG2/X9cMtTmuMnVVkZ7+vVm9ut3twVVX1Ai0spMLCLCy0QkEWVnVd90ItbAyBFgByUrCFyujA 7xBC277v9/MmS0Mr0nYwxuu1QXlbv+AwBa9QjgXlmL/095BjjXN8TtfwOVzTGrnWyfEd0zqXNM/U Gtd2j9X67j/Pq+9imEXoAizapIikf9s9DoPnNEZpEcfrk9L8d+u1u99s5mz1qaln9zO4IvzynMrP HJsGXajvJtrhzRm7WZefFAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM7qWwD27hi3QRgK4/gL VJGY2bv0KF1zjx6BG+UaPUOv0A7tmC0ppaU87EcMJUFR5UaU/0+ybDlgOxmwyODv5toLAAD8S2OH 2431PUwNtN0+SppmbaiEnituRR1rO6y87gIoLNTC1S64oix/hlm4kAt3jdYWfGHhGDZvf77Lf5BL 2SHqf3Wo5G+x3nhYazxzWm/8tZ4LtHDFhViEbRdocaw1COIzCJ6wIIqPQSl9aMX7SJ+1q+5+kSoI ynDznLJeayjRq2w291IUheR53gunCAMtLNTC2hZmocWuJ9ACQGzhcyZ8xmuwRXcQt+9/2+3OjrXy oRTtmFP7hYVYDNo6Rswn39yDGuZ0CP61xp/LHHNY45LmYJ54YyxtHp2h9nMl0n/LSfwe2b7R6P7a tC2con270dAK/W/JAiyaduoDLcLPUr9X6j3tGNrXtKumvQrWcJtl8nI4yPN+P7Xsu6Y8ST+k4ktO h1rYV0tsGSPFfg671vrCe2RQ14P2WB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiobwHYu4Oc BoEoAMMPsGm3bk23nsCtp3FlWPQcvYNX8SxuXDdx1YVacIaZBw8sTU2gBvp/yYRAcWbsQsOGn6gF AOCS7Mv1ntx4OHXzdvsi6/V9FZaw9OW/TcRC6phFCFpIHafQuEWIWBR1zEKvadDCn+t8IWrRBDR0 /f94ufmUXrrvsd/xsNfxTGm/4+z1L0GLIn7WhCzsMcQndHzF65894Qod3yZwYSMYfl47Xwho9Fmt Stnv32SzeZY8z2WxWJjoUXFW0MLf54f9rgFgTDZcUb2AO01bQQs9z7JM3ne7vknC8cjfrSpScSRe 0T3qWkX38wFNPdYwh3jAHH6HIdaYwh6vaY25rTPUGnP6Ti65jl0r0dBTOKkCFEm8nsRghcYpUo1T uOGfOuqQhYToRRrjFod4fohBjBv3v7P0zxASahES5/Tz37rnkbvl8pyoxaMbr258SDtccSpuYa+X 8d6yM0SaOEVifk7kd7jCHkXaD4l9QQtCFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXJEfAdi7 l6QGgSiAog8pC1lCJlmLq2AHLoituBJXYTnIINN8qpGGfvDStsYBoh3vqaL40+ggJBMuUQsAwNJS bypMbXu6dqHNZitF8TAsa2BC30c4r+sLy7spbKEhi3GuEQtnQhZz2GI+bo5gaBzDT3Y8O1+b/xtz eOG+yikS4OV0v9zrz8npfpe51/gDrTMhhzho4S6Wx/kYsRjXzyZqEccpjuLjFM5pxMIGLo7muJM5 9xyurdf9OmhR1052uxdp21aappmeDamghY9Z2KCF32eDFsQsAKwtjlnYqIV+zldVJW/7vZz6z6v7 svxwvn1p9yeDXE5h23B9/0LueP+Cz0JCDb9//VsZI4eYxVrjMMbtjpPTvf61sew4+o0+HvkuPDOH XzohbjHUI3zEop8PIQv/GyKELMoQv5giF2Gfxiy6EMPQsoTTcEZY39a1vB4O18IWVT899tOzfC9o YWMWGqooEpP+C/RY3WbPkWjeRcupbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4B96F4C9O8hp EIgCMPywCe0BXHXXtVvXJhzFw3GHnsBt117BZZfqiAzDg8dQaWIKZuT/kgl1Kgx00YYNP1ELAMBS 7EP1nuvxeG2Hw+FhNKcP7NXgRAhZ9DEL56SLU2isIh4atghxixC40ChGiFr00Qw/b9f9Syk9cF+l ds4pnS/nOp+UIjK//2yr0ev+e+6r24Y5DVo4s3UmNuFMiCIOWoSAhcYrRN6b94eBi8tBixC1cN26 l/jL3u0+5Hx+lbIspSiKQcxiKmjh5/zQoIXuBwBLs1ELG7awcYs8z+V4OsmniVpkYedxdS0KV8Rr VVHUotKtnbvhtc0p9eMvscZ/uIZbrJHCOa5pDdaZ7xhrXGdqrTj8lGl0on29aX/zmnpEG6jwc/4O pAtZSIhe3GncQqR53//tj9XUJ/z9h4RahLTH9Me/r3+/99vttaiF91SPl3q8yTBcMRW3sPNV+79V NET6OEVm9hMZhyvsVmR4E/ZT0ILQBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK/EtAHt3mNMg DIZxvLQmhB1hH0y8lGfwZLsAB/BYyrIUbde3lIrCzMYs/n/JG9hS2rckG9949L0bAABsytRbBKe+ e5mb6HB4VcY0/lwCJuQ9hMNneXG5BFEMQRbnow1BFjaGWaTBFkPQhY0hGOe5+hiaIeulx3sr8cXr pfVcUr/0ehsl9epc1u9lgRZ9b0OwhI1BFuNAizyY4hjL2s7X8NnV+2jMd+EWc4EWWrtAize131eq bVsfaCF7kUCLNMyi6zpfEmrhikALAH+BBFeklQZauKrr2o89nk7xmgUTD8cwT77eaKz7Y/0hEOM3 +7qlLcxf+h7WWOMa92kL92FLa6y1zhq/sWuuU1KvS9day9RaVXaelgujkCSIKgRT+PSIEGhhsiAL OXeBFubzWfmQfGfCtTqM1fKsTXp42u3UY9PMbcMNeFZfAy0qNR1okVe+zbSFKhujFlyjsuunbi0A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhHPgRg7w5yEwSiMI4/tOi628akbLpqYpNeqVdh4R16 qN6hJ+jORWGQBzPwiqAxTRXo/5eMMAPOPDcqm/nubl0AAOBfsBvjvZXt9dTNu927bDZPVbCEFTYc D4ETGmRRt8KHUkgTThHCLbohFt0wCxtokefOh2OIn7+72fu4hLquuVnkb02t5inVS61/Y0q1qvP1 DgVaFKaf++t1oEUIs2j7eRU6UY9lTQhFe6zDK8K5Da5w7luOQywyM48Ny8gGP+dyGUkcf8l2+yhp mkqSJCboqA200KYhFjbIwoZZEGgBYAzsd7eGWWgL/dBWq1U1ljk3OI9/U29fXws71gm8ODnHhQhq uP38c1mDMIvrrjOXNaa2zpRqHdM6l6yl9zX/9/V3tTyP/LieaziF/rpW6RBlf+GDLfSpRAMsnAZa lOe5D7HIzfWFD8XQcafPIn4eXUdX1Pnv41ge1mv53O/PlfpctpeyfchxuIWT/jALO174e4tOE39s cj2kTTOMzLXuUeTnA2Qk/YmDQ+MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBGDgKwdwe5CcNA FIbtGqTCDdggtRfpEThF75ND9gyV3EVpJnhgYhwlG0Kc/p9k2SLYniQS7Pxenl0AAGA1SqcJlj77 HFvocDg671+7sQZM6PmDNnDicnj5uRdsIWEVl/7XBFeUgy1uYRauF2whze5n+yWq8UD22mquqV5q fYyaahXlescCLc4pUELGpUALDbHQAAoNqdCxhFnEFGghLab2c73WD7m4D7ewbch2K3V/udPpwzVN MxhoIeEVMcZrqIUGW0ighYZa1PZeAayTHKodQujCLDTEwo6Fhlp8t79lhQX6/dD1/LuFQAs/ttaE e3mkOdbnHpazxzPnL2mPNbxP3WcONb2XNT2TOfeZupfPxrZJGIUmQXgzDimwIqQAi65v/5Ol37T9 pnQ9ze3WTM3uKd72e3fc7abc2ru7D7Twrhxokbf8Nm0JPvuOmzDHZfNLjxYAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAPwTfwKwd8c4DcNQGMdfEVW2SmysnRlZOU3E2IP0DhyHk8DIAWhF1QS/xK9+ blMQoLY4+v8ky4nr2k4G3Agp3/WlFwAAGD3/Qrw6lPuvOi+XTzKf3+3OU6hEf9CHWLQx2CKFWfji gyx8iEVeUrCFjanjWWiGBlv4+Utg9+icL5L8q9LWXNJ6WetplLRWldabtbrPfKBFIynQwmoNsthm dR4+sRkoHzHIwp/7euO+a+NYYEYfoHFMVbWyXr/IYvEodV3LbDbLAi00rMICLSzUwo613cIstPj7 AwCXZHuKvSTdFwu30NAL9R7+rv1ykq7oWO1QW5jHB11k/X54Hacwhhfuj+EazjFHKUEBzPH/5int WsZ0T0qYq9vX7Le/7nPheBLb9VjDKfQJoUuHCOdXMbhC2/QfKFs913bJgy/06UX76li6Uzf6XBLH kbiX6vg306ncVpW8rlbfLfUhlOdQ3uQw3KKR4TAL397Gvu1ekVjvcj0kPXhN3Gf7tbjv+74Ht/hI OwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGIlPAdi7f5yGYSiO43bagVwiYuBOnIA9J2Ds9XoN pnZNE6DESV7fw7UISNDi9PuRLDtW/CfuEKlDfsW1NwAAWITUFwVTfU9zE1XVg/P+bmhroIXWWjSI QmoJqRiDLTS4ous02EJqDcFwp7YNzND1xr6cyAfec5LjfnPZM3v9G/nsVQIr9Dumuvc40GIsY/vN BE28TtdfhVm0JsxiLMfjwfQfEsEWXTSfhGakz7Us391ut3WbzbOr6/pToIUNs2jbdgizaJpmaIcS B1rk8/sBuAU2vCLUth1IX/Cy3/9o3lMtxfRHiUdn/d6MmVuHQIvrz885XeYclrKGrHOJNZbyLL+1 zhLP5D+v5aO2LSGMQpIgvGmHsIp1CK3o372hLQEXQ3/ftzbXq+n+1TS2mO4v5F1q9nBflq7qy4zw h9ijOw+08C4daBGX+DHtFnx0j/vGGBeNTx0tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4AR8C sHfHuAnDUBjHX5sKOECnSuxVly49QW7C3bhP5649AgsDwm6e7Ze8kEowBErS/0+ybDmJbVgcL/me /noBAIBZ8x/C2zTl49wD6/Vrqi28Irdzw4dOWJhFF05hYRahBFrENsRC+32whd2TnwltKIbNaSEW /oPn1r7VxxrHMLU1T229akprZq3Xcd9rjb22BTnktYbSH8pvCOWeo6uPbdBEP9TiIMNgCwuy8MEV udZ+DccIobu/P56NH7rVuv9Vl7taHWS3+5Ltdit1Xbf3WEiFBlZooIWFWlitYRY+0IIwCwD3ygdb +GJhFlVVpXq33180VsyN9CIe+xdzv93j+lLR+S4Ms7C5rmnq499ijjn8hjHmmMIa/9Mcc5tnrDnm 9J/ccp6x5kp7n50FdC/Us1Hp13ZV9sbY1Hp20J03aGBFc02DLI6lbcEXVvQ081j23PSMnlMkp0VI GVPHf14s5GW5lO/ze/lbU96b8inDcIsgv4dZ+P5Y7o0nRUrd5npIdzB8cNdOa5H+68Tg9eJMPwAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmIEfAdi7Y5yGYSgAwy8IUalzL4DYcy3OVaknYOsxuAQb UwdUEHnEiV/8aiw1ElTE5f+kyGlEbbdL6JKfqAUA4KdKTxYsXXs8N9F2u5emuctiEmlMh04hChtT pEJPwhUWs0jX8xCGDOMYy9CT9fyY9rPkB9iX1bbn2vYb1LRn9noZy9urfju3PY4RibBXCzx0MSjR Tec+ajGOFrLIYxYfMWbxLj5wMUYu/OsUwwiBizRXJ3nQwgvPVl+t3mSzUdntnqRt2+mzWMzCBy0s ZuGDFha+IGgBYMl8xMIOu6f489fDYd58/Xs0/KNr96U8ZBHXVB+08PewM/czQg1/P/+1rPFbD6q/ NNZY3jq1fZZr+k5qW8uXFvKZbmLowmIWQxUiBi5CnOLThSuGa/1x299jh98iFrYIv03i32uc08oS nYUz4uv79Vpejsc5YYuH/niWeUELH7OwUEVTOOwrsL+1a/49ko2anZeuAQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAACAf+BLAPbuXqdhGArDsEMTdUZiga0zUhfG3g0XlmukSyUjaMmxfRrHjZVKlBJH 7yMdObbqnyZDtnwP/30AAMBixR/Ne+/qbWrCZvMafXTdhNZf+PAKHzqhYRbDcIo+yEJLwiziYIs4 7ELn+A+jm8G68b45JX4cvbQzl3ZeUdKZOevfmMdZc4EWPsDC979D0IMGSuh1HGQxFmLxeW6PR+tK QyxOJ+tKQi76oIs47OIruZZ9NNjiUtNUXX2Y7fbZtG3rAi3SMAsJrdAgC2utK7mWMQItAJREQy3i 0nALUdc+k3R/OGTnTwVRJBP6VvYbWyuzXgkhB1Pr8x/ms8dv5y/lPixhj3vvcw+3Cl1Z2j0pea/B euH951Ie5J2rIRXyDg6lfUmUqHXMhJSJkd9X2td1jTmPS/+xaczLen3NUXddPZnL4IrVyJhWdeVv 46CLtG8ybfogcg9mLimPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgxn4EYO8OchMEogAMv0Bj yhFY9SzdeoDeoHtO073H8DTd1pVLY1KkPGYejDjYLhSE/l9CUEBmdCFhw/809QQAALMWe1hdbNv7 byfabLaSJJl/8LjbZmuLWbil8oELaddhpMLCFS5kcRm6OA9hSLMOgxnhuH95/rk9JH2shzrewtzm PLf5qjnNmbnex3RzvRa0cIuLSLjAhdun70u/z4IWpY9PuLiFiAtRuFjFZeBC113I4jsSs+iWLphR Dn6L1UrnvZP1+lWKopA8z9swhUUtLGhhUYswZmHRC/sMQQsAjyy8ZoRBi/C9Ri3SNJWv/X7wPHrF ufi389ehdt+1+EU/ZhE57tEjB1Off4wxlvAdbjHGHOb4n8ZY2ji3GmNJv8mY49xjrPAa2T9zqgEp vWfwx1jpQeMUp3p76UMVpW3T63L9mea+RF/rPr1P8cfrORIftmjutuptYRXiJctkdzzK5+FwbcrP 9fJWLx9yHqmoZDhqkQT7T3Ieq+hHK+zYfrgiFrSoeq9j2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAwML9CMDeHeM0DEMBGH4Fpe0BGJi7IsHChbpm6TV6Bw7FAbgCW9UJlOAX8+IXcKhAaqij/5Oi JiW1XYSIsuQnagEAOAf/ILxt2B5/Onm/f5LN5r5/oG+KSqRji05YzMJHLOLrMF5hx8OwRTMIW8SH o1ssI47r5/2Nkh62b0pbc2nrVSWtmbWex7Rr/XvQIsYrYtAi/syHKN4yWwxYNE0+cJFiFrZv47+7 /bz1WuR4fJHdrpa6rqWqqv67aKhCHx6r4QqLWOSCFnqObul3AACXy4csLGbx9X21Wq3k9XA4OVar n9f/fWNxChev6M+3OcNcbeYzhBr+f/y5zFFCzGKqeZhjvvOUtNZLm2uqv1m9R1jY9c+iE3pdlFSO 0LsJjVPosQYrrsN5XcDic9/CFz56ceXG0JhFN0actJtbj2+WS7kN1/QTUQt1F7aHsD1Lilb0w0s+ auHfb93X8ZtIilMs5HsEox15FRnedI4FLQhdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwQx8C sHc/uQkCUQDGJ4aNHoKF6Zk4RE/D0fQWLly4tSlQHo83PEaMjWltR79fQkf+yKAby4aPqAUA4F5L Txpc2vZ+60Rl+db/tYeWh9loMQtdumHdwhYyWqDCAhcSrpCQhY9Z6OtudmzT6Hv1PN3FvPc+Az2n h+2b3K45t+sV8YGZGcjp++Va49kv1qeQQxq0aGevdZyCFhqi0FEDFD5MMQUr2vYjhi3m+z/daO9t 4rrOeT1osdl04XjchbquQ1VVw+ewRSIVEqxYClrItjRoQcwCQE4sYJHGLWyUpSiKcDid/Juu/9N6 6/cmDV7IHC5oEWMX4f9HDv76/I+Y4xk+w0/MkcM1vtIczPN753jFeR4xly8tSHzC3zGtxtCF3T3F ckS/XeIUPlwho2wv+t/N4R5FXss+uWcZj7dzWlmitXDGuF6u1+FwPn8nbLHtl32YQhUWqVgKWviY RRqq8It9HXas35Yek351aewi3Q8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ7UlwDs3bFOg0AY wPGvmNC6Ozh0dfcFXHgX36Xv4MqD+BrujnXp0sTGw/uAD+6AVhNrk6P/X3KBUuAoA02X/olaAADO LfwDvGc/Hk/tvNm8yHr9UK9bvKJZr7ptFp2wmEUYsWiWcbwifu26ffS1Havn17CFzannDef9q5T+ bN+kds1c7/9K6Xqv+1qr0Xr/HHPdstlmQYuvYGmRiT48EQcpNETRRyuamEUYuPjsIhcawXDO9j0M zmlzOJmSZQtZrQ6y271JWZZSFMUoaGHhip+CFnYMAKQmDFrYsO068jyX9+1W9v7Zd+vXo3DFqbhF GLAIjwmiFZW9p6Odt35P1930s/scUo9BzCVOkMJ9msN9mNMcl5ontc8yp3tyDXNFv80sOqHfuRKX IzRiYYGLG79fHbBo1+39MHqRDc4RFSba4OWd/x6/Xy5/E7V48uPVjw/poxVdc0Omoxbh9mpwKTZE +jjFQsYRjOrIUiT+EXosaEHoAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmfkWgL072E0QCAIw POyatHr2bNqk79GH8Q15pZ69tqVeyggDA2wlTcWE7f8lGxQIi8Tobf8wfwoAABOp1QZT+45zFzoc XqQoHgf7bE1ei1lYdKIJWthr6QIVfeCiCVdYzMKHLvScPoghXdjC5vDz3nIt9DUurr62e+Z+l7Wm +/1/9/q7oIUGJaYhCx+eOLvx1Y6q/p3U8XnZ6vvhMQtd9NsmaOGvdz1oEaMGLT5kvz9LWZaToIXG KjRi4UMWVVV1cQuCFgByoAtcxxgvIQuLWFjkwkct3k4nea9/A+Xa4t+pY6mgRSp2YaGLdt6l2Gda 0tqvn8scf73+vb4rOTzre86Ry2e51Tw5PpNc5wpursINpcd8NcLKEaGNWoQ2XGFbHZv6/3Jjr9vz ojvfahFhNKd62u3kebudu+2HerzKMFoRJR2zSI1iZvhzxo9lPPyjkx/2AQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAACATH0LwN4d4zYIQwEYfkig7FWHRMralaVzL9PT5AQsPWTHSE3S1sY88uyA1SGJ gvt/kkVwESZQKRs/UQsAwDXZF929u/GaO3i3+5Dt9qX/rPGK8PlnnJsOW5xDFWm8It7/Ho/x+xrA CC9Jl+i8dt1bWOJL1pf2cniu97aWdL3/41rnghYhYBH2T1HQIsyfkqCFDVDkwhZfJmARxyw0ZHF5 juOw1nE2aNE0lRuf0rYb6brObdvxnvhIhQ9W+KFBCx+zIGgBoET6Qm8NWeiwYYu6rvtj9ofD1Ani rf1T7tg0dqHXMjF/LSUECkr5Do9+n0qJBJTyPHWde1jScynpntxznUdYy85VQ4CikvP/hgYsdGjI whclap2ToTJhjum3/nfczOsY13Hbp6aR9Wr1l8t/c+NZLmMVubhFJfkQRhq0mNqXmW16M+ceJKEL AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK8isAe3eU0jAQBGB4FkuxPURREHIOb9A3r+Bxckmv UBC0mGky3cm6TRpoIxv/D5Yuq2Q3eajgQ36iFgCAqXIvpcutvY9daLd7kRAee2v2PvJ8zMLm0syP 50hFG7howxUWs+iHLmIMQ69hYQvbw+97z/ehl/rC9dLOzXnvq7SzlnLeaWcdClq0o41J6Pw7CVoc u5jF14WIhX1+nj59yCKuxfnvqEWMWcQ98ve1Xut3+ofs969S17VUVdULWmisQqMVGrAgaAHgP7B4 hR+6pnzU4tB8F052KXrRxSssZBH0DG7PWyohonDN9Uu/hzn2uMVzWsJzWNIec+1TWpxjSc/E9prL X+4VkrmvNJziE9KvO1ic4qH7uQ9Y6Fg1fzdXydwHLXxdQpL9nrZbed5sxm5B/3H2JsORiqERRob/ nfSxpCN9jLk1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwQD8CsHfHOA3DUBjHHUrplIWJpTti Qb1ShMTUe/QOHIobwC0aCaiDX+JnHCuQSpRQR/+fZOXFcWx3aZQl3+V/bwAAMBvxB+4eXNv8NHi3 ezLr9W1ba3hFVzehbzjYQkMsTBte8RVkkYZZWD/WhmALDbOQe+N543WnoGtN+RHHU8ht3+z37+S0 V5HTfsf3ekyghfW19dc00OLgwy4OvdAJ92/aHiW8QuouxGIo6OItjNNarnX3v0fzf0T1MPlu637/ YrbbR1NVlSnLcjDQQsIrNNRCam1pmAWBFgDmIA200GeBhl1cSRqQUx8ZaiH3NAMhFhpg0aT9bp0w 3h/DHL/8n83pI/VznX+qdQizmG6NqdaZ02851To57fWc1jnHtdrnXPwO5urC13KU5Ah9o9JgCytH N07CKw6+llQIOQ/jfH3hri38M1cTJqS/kHVc//VyaW5WK/Na12NbvXPt3rVn0w+rWPgp0yCLtL+J fk7c9FoccGGj8+abozH9l9MiOR/rBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmfkUgL27yWkY BgIoPBLtpoeokOBKOQL3ydHgFmy6YFOpqtJgx54wdo3KT6li8z7JxEqr2GVBFRZ5RC0AAN9ReiJg 6dzTpQttt4/u5zo5Fx5Mbo82ZqFzcfMQrPgYNm5hwxZh2Gto2ELPhXUlOd5KTQ/at2rbN/v9OzXt 1atpv+d7zf9A2ZBDHrQ4JfNwtEELjU5ojEKPpZDF0UQsjoUxmLDFECMZpwtBi1F2u2fp+166rps/ rwYtfMzis6CFP69BC41aAEALbMhCIxb5fLUK/8J52+9/ssAcqhD7PRivrTGLeW7f/0tLjygsYY0W PsM11qhhj/9pjdbWudYaLf1ObrnO0taypQX7zqnyEEMXepc1lyNiwGKI0Qp/xzPFK9xYu+9rf39y FyMW0+txrhGLJGph9nC/2cjr4fCVsMWDGy+ShitsL8MODVqMcr5sadi4hWSvSXYcs3npHAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAaMy7AOzdP07DMBiGcSeiamcmlu7MzCw5C1fLSXoLrsCYFZrg j+R1PiegMpSiWM9PsvKnbex0qNQlD1ELAMA1+AfdvcTxdOkDx+Pj11bxCu1rq+hEHrYYIxUWp7B4 hUIW65hFP723T2ELO1bYQnPO8/3v8/a29KB9b2vrZr1/Z0trNVta77jWYRW3mH+3+rQdzylocXZb RSYUsvBDUQsfrRgjFmPM4iMd5zGL+bM+lDHua025uq7C4fAeuu41tG0bmqZJ96JIhQUrFLBYBi3s NQ1FMACgJIpYGB+z8IEL011+6PXywtkcw3SusutNEQsftkhBCwIFRdzDLea4xvVL+B5KmuNW82zt Xkr6Tpgrf3/2HzHuV9O+ghapHGHBijAHLu4sZhGPzxa0sABVPNa+ghb1FLfw9QmFLmyO+90uPOz3 v4laPMdxiuPNXSo1N8I6bLE8P7jb8cMHLRS4WLY3vtuGkAcsfgpaELoAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAKAAnwKwdze5CcNAGIYdXLWCI7BqT9UT9GocIBfgOl2yQ5aiqAy2k4lxE9SfIFvv I42CncS2vECIhb/NoxcAAChG7lTAXN/H0kCHw9E0zfOkzx9Qrq++JIwiBlL0vbT7oc/XNMxi/Oxr DMQwISRj7PPzmsn1kUo9pL20dbPe/1PSWkUZax1DLGJYxFyghTxzG2Shwyx0MEUMq3Dq6i7fjy4E Wuh7uuK7esz5QAtrJdDibPb7xrRtmw206LpuCLJwzl0rtuWeFIEWAGoWwyustdcAi1ywhfg8nb4b 4P62Dq1IwyyM+pH/w0PI1whRKCGoYWn8Wub47fu17EMNc6w9zxr+KnSltj1hrukfWo0qIeEVOjUi JkfYEGqxCQEWVvU/hXeG52JbriEgI45pkvledzvztt0uLfnlUu/mNrgiDbPQS0/bc6WfSbclrXQb c30AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAiXwKwdz89DcJgAMaLK9ndk5fFqzEhHrZP5Afj w3men6BO5aV9XSk0moCG4vNLGjYGa/cn4cZD1AIAMFd8Q7vnbhy/O+FweBjEK0S81ejENUDh4xYS rZA4hWwlXKFjGLN4/zpWwxYat5Bz42CGRjTWptQbtpe2btb7e1jrUj5GjyX+4MMRGri4DIIWfv8l CVq47rHGJ/JhCwlZjGMWunXJeIveV6MZ00GLuq6Mta/mdLo3bduapmnC2n3QQkIVzrl+pEEL2acx C//Z1/x7AcA8ciPuqZCFDmttf9zL+Tx3ony0QsMWM25AvvaIwhrm2MJnWGKOEtb4n+bY2jxLxRS2 9J385TylzRWfX4XrZGWu/yMNU2jMwoZ9/ZC4RXhtp7GL6HUNZMTvcaPX9zDHbV2bu/3+J0t97MaT GccqcnGLnRnHLdJj06DF1HOT2aZffO6HIHQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDhPgVg 745xGoahMI6/KJChcw7AwGUYewrG3KrX4AwcgQUmpg6VQLHxq+3YSY0KAkIT/X+SFcdNbGeJmuV9 V/+9AQDAIpSKz5XG7s9NtNs9SFVdS16TPAVcpKALbRpC4cMobAiqSGEVfmwcZpH6KcgihmKMQzLG BdEvtT56LNw+ZyHI37C0fbPfv8Nef+I00MLv0Tf/vjSh5rgZgi18kIUphFr0kgIt4tGHVRiTh1u8 j37zv79JCsXI50lrfKZp9P37ItvtnXRdJ23bDsEUMdBCQytiqIWGWcRwixhmoS3eQ6AFgLWbBlnk IReqcS/W1/3+KxOlP7khpELnsJOi3TpuwzVV6A/XubW/E26xhsL+a3iGOdZYQpjFXOuwxnrXWdJe L22tJT2T3m2zfqRjGjxx/AYJ58fkCDdmwrEPx9pdU4e+hl302Xkdz8N9levHJAkjKRVC57/ZbOTZ fQ89HQ7ntn3r2qOMQyqslEMtTDhaOV221OK10+CKUqCFnfRLYwAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAYCU+BGDvjnEahqEADD+pqtKZEfUAzMzcJhdg6QV6Bi7EObgAYurSJY0MeYlf/JoQCIJK uPk/yXJJqtgwELVDfqIWAIDf8A+2K5tx/9Wb9/sn2W7vzsIVys8WnUgBihS2sFkDFqdTkKoKg5hF 6M9b2MLiFhrI8OtaRCMH/+9h+/PovnPac25/55z2y15/vIvRax+06KIW4WzuhkUsfNCibkcXpaj7 QIXO44CFhS3sfDUKYaQ4Ri0W0Jiy2Ygcjy+y2z1KWZbtg9h90EKjFRa00IiFDotb2Dl9H0ELAEsx FbTwc1EU8no4fHud9n9mjFa0x8Q9ZXoQt4gHp8fMvV/SNTzU/xp+h79YI4c9LmkN1rncNZa4Tu5r 9fdPu7Z+pxFfW9BCjwX9bBJjFiGGK1bNPXql0T77WYeksEVblohxC1+fsNCFrnGzXsttc5+fEbV4 aMZzM97cpdotSopY+DE8/i4phOGHD1pY4GLY3vhsFjn/EDsVtCB0AQAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAABAxj4EYO8OchIGogAMvwYxgUvgxiM13sDzdOO9vIFbN4Qdm1pqH9PnvA4jhQWR1v9L Jq2D6QwsStj0J2oBABiTe0pgbu517EKbzbMUxXIwFx5U7o9haIQiRizyQ1/TuIUOC1vYucUxLIoR Ixltsv41H8Xfuo+H7V+HPd/elPbLXkdXPfk7hhzSoMVhcK7Hoji4oMWXi1rU7uhDFjFsESMWdWY0 fdAiXnMsaLFatbLdvktVVVKWZXgHfcxCR9Pd5DVaYTGLNGihr9v/ErMA8J9ouCIdyr6PjlGL3U7q 7j65XCxCdMICFr/cL33E4ufcvt8uiVmcubbf261M/fpzWWMqoQDWuL91pvZe5vSZsNaF1xIXfnLz x8qDX0d/z0gIVTTJUQMXFrF40Hmb66MWTX9uEYtB1MLt4Wm9ls/ut9HHfn9uy4/deOnGmwzDFb6X 4YcFLVo5XTY3fNxCktckObbJeW4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMwLcA7N0xbsIw FMZxg6UoYuzQnbVSValX6k04Q2+QU3Vg5QiVklKreYlfYoxDUUuhjv4/6clOSGwDEWz+lrdeAAAg W+GGdi9tPZ+6eLN5Nev1Y9fX4Arta6uhE2MAhQnCKTTgQgMsnA+xCIMt3FEIRn/fOOdY+e6r1weA 5LV+1vz3clova03OFPXDeZ0/56JAi09/rg+ycG7vwyu04nCK5qicq7tKvRbe1wda7L8NtJA9X1er D9M0W1NVVTLQQkIrJLyiruuhwmALCbTQUItcnhMAuAQJsJBNuqXCvrV2OC7L0rztdua9/e08x8Gm 3/EG4D68Irkx+NT5aOwcghRuOf5c5vjt+Nd6VubwWV9zjrm8l0vNM8fPhLl+Nn7Yl1CLIdHBH0tJ goS2Glxh2/9qq69LuIU/1uru9dcvg+sWOkfb3hWFuS+Kc5b60NaTOQyvkGGsSQdbWDMGVoTn4vu1 XUwcm4k2/lKmvqT/n3AJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSvgRg715yE4ahAIq+RBnB lDlqJVbRWVbTtWWBqETFRY7z8KfGtFKLsHWPFDkkURxCRx34ErUAAJTkFpvLHXu/d6P9/iBdFy/M 5xaLD0e32QiFj1jkN3vOhSz0mLnGLc5nE0UxfCTjK5n/N6/i+dQUBlA88/+r6Xl51uvdv+3HQQs3 umNGfMjCBy3sqNEJY2ysIg1ZnILxtMYsciGLMGgxJ4EMnSsftOh7u9j6UXa7T5mmScZxdE++xixs qKIUtLDnNGhR098GAPylNGihi2vr8WEYls8f81y+T5/8u0cX6b61EHgwT3TNjetbCBS08h2e/T21 Eglo5ffUeR6hpt+lpXfyyHlamqtL9peawzqfBiiickQQpdBxCVys5wYNWIiPXoRBi7AWod9N91+3 W3nZbH7y2G9SjlTkghXh59IWXiN3rk1fY+4YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACo3EUA 9u4Yp2EYCuP4a9OoOxNjNiQYYOmROEaWnoF7cQSOwFZUQWL8Gr/YcVoYgNK0/59kuXbc2OmQyB3y Lf57AQCASUpfXPfoy8NXg9frJ6mq291nC66wz1Zb6EQMoIh9MeCiC7HowitimEUMupAs+KLd9aWB GRaicU7seo75MsmfYs1/b0rrvey1Hgq0cEm7Ccct0EJrC5do+0CLri8NoehqkRhwMQ67SMMr3pPy 0ZcYmtFk643KciZF8Sqr1Y3Ude3v+VUfTJEHWmixIAsLs9Bi4RcEWgC4VHrvS0Ms8mALNQ9hFW/b 7fgEOk7vn1bvO251Gl4RXqTtkj6d04W53eAU03/h/jlcwzHmmEpQAHOc3jxTu5Zz+k2Y63fos7bV PYnNq89nCX+EhXAKPVboGA2s0D2PBVv47xa6/wnthW83vm3BFrqDm/vxRXi+WhJFG8418/VVWcr1 cikvm813S73z5d6XZxmGVexOKeNgi7zfhT6XFTuWBly0SdsdqEWGG8aZ7N9AHuoHAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAn7FMA9u4gt0EYiMLwgKVIzSVoK/UgvUEO0ctw0O66ywZ3QZsBOwxT IlK1SQv5P2kENgQ7jkR2fuVfTwAA8G9N7Rg41fcy96CqepKyvBv19ZuW22NfGkIxhFhM1zjgwgZb tKMQjP687cIt9Hw8/neWYhmWuBE8c768Jc339uY6F2jxYYIk9OgDLWyIhQ2zGAdXtG1Mpe2Y6l1s sIVeH9o+GCOHW0x/381G39uvsts9S13Xh3d+dQyz8IEWGmLRNI3EGLvSPr2m9xBoAeDW5QAL3Uw7 H+25HkMI3b1v+/3k5+XcTb/tfTbkQkuDM1zAhbhwjUtZQlDD3PNZp+usw1rGyONcY4y1fJffGmeN a8JYPxxLht+rMKVK/S9OgRbH5Ig0t5CudcEV0qdEdIEW6f7cDrmdn2VK3Hj32608HOoMj/I1uMKH Wdhp+3bhzosT/X5ZfNlllBN9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgwT4FYO/ulRoEojAM n0gySUFlZZsLsLH3Zkhhlbv0OrS2tEmKTMD9O3IgoBYYBd5nZgfO8rMbimRIsd/yrycAABgdu2Dd zrWH7y7Ybu/DVoMrdF+3GkQRF0H3re6rAy40xKIMQRaxlb3BF/G6eswYarGYxWLp+hmvtfDjEMY6 57HN1xvDnOcx158EWpRpvzT1OQRdxLALu3+S/mCLUwq0iH0iPujCHrcBFiexYRl1gEa3zUbkeHyR /f5JiqKQPM9Df1+ghTYNs/BNz7XPEwDmyAZZ+Gb7lfa/Hw7Na7++8ec5VbvfBmGYEIuqdSzM4Re/ o6ewsPwUPsMQY4xhjnMaY2rjDDXGlJ7JNceZw1iVqRvvev79X+rgi5t0buZD+Xxghf8/S4Mt3G91 5t+FUr109dnVGmzh33w0faL010kMzZB0r4Xb3q5Wcrdey2vr977Do2vPrr1JM6wi3F4ugy2yNHWt K1NXHbUNuChNXfVs7WMUc+zikff0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAf+pDAPbu56Zh GArAuJtGoCzBVBEzME4urNA1WIExuPTSS1UVEvpiv/jFNc2lIBx9P8nKP+GEXKr24I+oBQAgJ7dy YO7cy9JEu92bq6qH2Rq4sjCgj03o1g+JUGjEwocsrocNXPjRT1v9W41ixEiGv7kumr6w7O9qlBQG UKU9c2nPK0p65nU+a7pu52BCDmnQop/t26hFDFpIeMLGLD6nkEWMWehxPD+PWZzDXOcwl857O2jR NIPb799d13WubdvpPciQmIUGLWzMwgYt5LoGLYhZAMB12EcCFvK5Ykdd+59xDsfjuL31qTMuyB0P 7IW4NftTzMJc20hEY/O7YThiE//jHveYfw3vYU33+Kv7lPa/rOmdcK/738uWFuwTjJWH8Lk6fudx /tuaRCq+kq0ELrZhv5bz5lijFn2YpzKBjN6EM+T4qWncx+m0FLZ4vIzny3h1P4cr7NAwRe7YRits zMIGK+w1l2yHZD93DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFOpbAPbuGDdhGArA8ItSAQfo 0IG9Upf2CjkMJ8uBOvcYFRILNK6fE5NnE5RWgsHh/yQrNQXbmRBLfqIWAID/sA+u2/nxMfeB7fY1 CVcoe43RiTFAISZOkUYsjsfODxdGGrZIoxf95yTZN49qhJsp4EH5t1Di/ZZ25tLOq0o683LO6i7+ Hh8S3p2v/WsxaPFjrp0JWpySIRKDFjFkYSMWNmwxFbWIa8R14x7TQQu9tc3mJPv9l7RtK03TnO8l Rio0WKHxijxooTELghYAcJ1+f2jMIgYt8rBFXdfhfd+Hw98ybTZcEef5/6delyyKcQdLeLD8Eu7h FnuUcMZH2oN97rfGI+6z5L3m9qtM1Cm8z0QnKhOj0IiFG2IW3RCuqP33d62/i4b5k593wzykCnUt /Z/0MYsYyJBhrcpfn1creVmv56IW6s2Pdz8+ZYxV6DHD8nIZtsijF87M3cTcBi5s+MJduYqkP36v BS0IXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJBfAdi7g52EYTiO43+qkYQ7dxPPeysfjXD3 CXwGH8GLjyAYY9Gt7fqzFpFkMen4fpKlY5C148DCZV+iFgCAUu2JfrVj96dOtN0+mnM3P4ISITKR xrD1EYoUsQghi3qwIgcuNGzhxzhGimLkSMb3B8cTt2jreltbc2vr7bW05rbXem7QwseoRBpDZCLH J96H+ESOUmik4q0IV+Sohfc5bGFWi1p4+y1o4dzClstXW6/NNpsH67puvJYUs/hr0CLcB3iGKQAo DVikTcMWGrU4coIwnvP7quGLuL+I40HPOaE5xAPmcA1TzNHCGi9pjrnNM9Ucc/pO/nOeS51LSwv6 qaHyEO+Nw38ZszFG8VGMfeDiKu5fx5CFi/vpMz6ex0kgQ8MZ/evb1cpe9nt73u1OXdLd1/Zkx8MV uqUwRe21Ris0ZqHBCn3PivFQ7NeOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACABn0KwN4d5CYI RAEYfgomrrsk7t03cdfb9CacwRP1NE03riGF6TxgmAdoaxvTOOb/ksmIIoMbDBt+ohYAgGvZB9a9 +vH83c5leZTdbj8JVyg7h+hEDFDEsEWYY7iiD1lMYxbL0X9PJuv+9EzflB6Ufwsp/t7Uzjm181Up nXN65+oWcYvwftxuhs+XIYt+uzHhiU8TsAhzPcYq4uvaRCxqmQcwYtSiGdYP8/mL5mYjkmUnORz2 /hpfSlEUY5jCBi00YKFRi6qqxtc6wucELQDgMnttPBe40JHnubyfTr8/+CxeMT5t2sQrVuu1FozE 6Rz2v/H/LbGJ+1gjhZjFf63DGo+7Tkrnem9rPeJv+st63X+kvf800YmViVFoxMINMYtWZx3+vzTz 9z7tMHdxC7NP4/r7RK1PtPqe9OELGY618vOTvwkrtttrohYvfrz58SExVqGn2R1elmGLefTCmW13 ZtsGLmz4wl2YRaY3lpeCFoQuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIxJcA7N3BbYMwFMZx 21QgZYm0hy7RDTJBV8go7NlLL7mTCkEx2PAgplCpDTX9/6QnJyaxnUQit/eZrQ8AAPhTQp39QnPn pYWOx2eldTqa65qYy7ErG0LhQyy6IItQVX2YxTjYourDMXwoxhCSIZvHrwu3+E9N1mP8vLGdObbz WjGdOY6zDveh4V4ke4TWIkjCjtNACxli4UMoZH3cVFXZurZjXV8Dr5HvL0XARanm+ommqT33uzqd XlSe58FAi7Is+yCLoihGoRb2mi0CLQDga8aYtpIk6UMsrLZxdjNvxyzL1NvlsrzYXNNuv65Yv50W QRb++k+GWujJfr/hHuvvZY8t3792j7181wRabLNPTGddu8/ePtO99/rOfnryWKa82uAJ4wIt+uQI 9/sk7podH1wlooybM3JOrun/98V+j4eDempqQdbUq7oNrpiGWchj65nnOlBz86Gafo2hOQAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAEJlPAdi7Y9yEYSiM469KiWDu2Im1UtXeJ3PP0IU79gAdunRk RHRAIfgFv9qBkKhSSur0/5Msx0BiY4lEZvB3O/YAAIzn2hvHIWnxxnQvrjz3nbBcPn6HSLTVFjoR AihCsIXVIbjiGGTRDLNolhCMEcIyrPyUbbb+X34jKX7f1Mac2niVjjmV8f7d+T29AVnYTuX3B698 cIW+to/aZR10cQy7iI9DCMV5sMXOh1ichl2cBljsfHhFHJZR+v7bLRYim827rFavUhSF5HneCLSw wAoNr7Agi64wCwItAKCbbVxuIRYWdGHvzWYz+Vyv5cvdaxd53nexEErRFXLhrl9pLdHTa+BAi980 ldCAFOZpCvMwpT6u1U9q32VKc0Jf4/el5zbWnLpWFv9HmQ+l0HczXetoUIWuk9xzVddAmW9bgIUG WuztM3rs6lLb7nw91lVZ5vuon8uuvnPP/fv5XD62276hPrjy5MqbNMMq6svLebBF5odu7SpqVy3t SyEW1YVapLkovpHzRbLOYevrGAbrbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAUA4CsHd3KQ0D UQCFL2kR2kUIfXBr7iUb6TbcgoI76HM3IHZi5ucmN+OQFKSSCeeDYJLWmaQPKfowh6gFAECVVvgr nXtdGuh8fpOmeQqhiqgzkQm7LyZGoSGL0uaGmMU0bOGGOIbGMMZIRly0TRdvI26xrMb7re2aud7H Ws/1/n7gxFiFvqZhhzxm4SZRizFo4SMUNmbxPQlWxJiFHudhCxvAGMcYoxZO5oMWnVyv79K2bQha xHuJMQu/3fqHuI9X+M2HLDRqoUEL/7q+l8U0AWCZjVnYoIU976MWn5eLfPXP2RC1SItfL43b2f0U rAgxi3jSvnk4Hn7vjjnm5n6krSxev/bPaQufwX/Os5U5apunpmtd0zxbnusv89nSgh0hVB7S92P4 H5fIEKPwf8XtU9DCpZDFLkUrdL9JcYtbGmeXxmlMIMN/5zbx4kPs4vlwkNPxeE/Y4qXfPqQcrsjj Fi7dWulY9+02F7eQ7GeX7ZfOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAivwIwN794zQMQwEY f5UY2i5IrHRnZQ/X4SC9A5fIJbgLOzsqkAS/xI5fXFMQCiUJ30+ymqR/7HZolCUfUQsAwFfsDeru 3bg99eL9/kF2u5s+aDGMSjTt8RCdiAEKGYQpurhFiFjUbciiG3U2ehHDGDGWEcYYpnOj/POY4/ed 25pZ7+/62/WmfzyNiTnYkIX4cEUXtFitGr9fm6DF+2CIaMAiBCpsuCI8vmaesyEM+1lVP3+O/nSb zZscDk9SlqUUReHX3PQxi1zQIuwTtACAn0ljFjrs8RC1UC/uv/dyuz31Ycf7JlhxFK6w75nJzeWn HoJYyhxzWON/mmNp84w1x5J+k3POs+S5xpyvPVfa60y33VYeNDoh0gcoLvTaR2Lgoo9auNeHbQ1a 1P5Y7aMVlY9b6HYbyHDn/0rn0OGeu3Ln/uv1+jtRizs3Ht14lhir0KWmQYtc9CJEK5pk2+7nghZp uMI+igwvOj8LWhC6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg4j4EYO+OcROGoQAMv2YIiJWV pQNTpZyht+lxOAdLj0cVVYmLY7/41aRARYtw9H+Sm5AKO1CpMPknagEA8KZ2+Zu69nZpou325fiz /nYtBCZCvMIfNWaRYhSnoYoUrEiBizD68ahxDI1hpEiGhjRsUON2pW3sfysXN08sSWl/I+73f93/ fq8LWoRrvTn38YcuXnMmOvE5hCdSlMJGKtosXJGiFjZ8IZJHLTSY8XPQoqqeZLE4yHrtZLfbS9M0 5n93iFT4aIXGLOzIgxb6PADAdfT7lx0+bGE/y+o6fNf+aNuT54+bbscNt88Zd4+2sQsbvfBBDfv4 F4hNPMYafzH/HN6HOa1xr3VKey1zek9Y67HWsqUFO+NQeYifuRq0cDFc0WnAIkYrxrCFpMhFFeMW XZxnKEv4ucy5rqn3sFku5Xm1uhS28OWr1+N4l+lwRR636OMSNmrRZ7+z41zcQrKjy86nrgEAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAgEJ8CcDe3es2CENhGD6EktxAK3XI0K0TypSxt9Mb4wI7GyRU DDbYp4lAaSCFvo90BOHn2DAkmfztHj0BAMCfFi5M99nUaeyG4/G939ehEl24hbhwC+kDKMLSIRZV 1VUcbBGGXkgfkOH7+5rLf1qkfa3PurZ5M995LTPXa4EWYelAC7v1ARN1u63rsg+kGMIqfHhF6cIs TPC5bO4x7X2+husr1Ws80CLL7GLpX3I+v0lRFJLneRRoYcMqfJiFMSYqH2pBoAUA3E4HWuhwC1uZ /bJulPYP8A393U4UWJEExxIXZpHokIuJC4SvIahhrP8WFsj/bf8l3sNWxvDjLDHGVp7lXuNs8Z0w 1n3Gm7tv+0zSBVLs/O+0q/TCVodaPOljrleq+vhx7PZ5v5fXw2HKVD+aepEhqMKWbZNKHGARhl6E 1+nz4fFLYRbXQi1EnRN17scrnvJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgMb4FYO+OcROG oQAMm0TKwA0y9ia9ARtH6FlyEq7R27B1YgmSBZXtOHl+uE1bKRFO/0+yADeyQ9g6+CdqAQDIHRqX m3ubW+h0ejdV1SRzITBxH0IW8WD0KWARRy5YEUIWtzFuMYUtbska7lWuG/ZNgxpL+E8Htpf6XUu7 b+53Ocve61zQQkYs0vdTaML6YYz1EYrHQEU6wt+vwzXXzDU6aBHXtpn7DZrGRYLO5nB4NV3XmbZt /XyMWeigRd/3Y9DCzVtr/bUELQDg73TAQn6Oh2nXde1fPy6X3yychivkgd8yXCHnxOtPDghfK1BQ 8vpxj2f/HluJBGzl94z7rKGkZ7alZ7LmPlvfa4n9dur9OESAIilHDJ91yEKPaohb6BiGXEvu6bzs 937McP+YO5qvwxW1eQxW6JjFdxGLubiFDl3Ix5ibAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA BfgUgL27x20QBgMw/CE1ysLUKVLWTl3aA3GHLrlA7tBz9QIdegsWarv+gg02KUGR2gDt+0gIwp8h QxBL3ru5LwAAsFjpH9Bp0OLp0s7H46vs9w+neIUaRiXauIWEuIV0kQtj5BSqaMMWVprGdlELDVnk MYt80mPbsEV//jjdUrzXW/5Z41zWeq9ru26u9/f8/LVOBS1cWGclBi7OgxYmLH+GCIUZRCkav63p Yhf9+rGARRPiFX0soz2/Hb2L7Vakrt/lcHiRqqqkLMskRGS7oEUatYjLGrNIgxbp9wwAuF4MWMSw hU4qrrsmalGEYIX77rkXYxZJuCLbLwYw/JhTv+pLjzT8lzHWEgpgjOWNs7Z7+UvfCWOta6zTs9K/ 63Tj6bIkkQtp3/o0UGHD3EgStvD7x2UNWlid++061+OM356GLfSJr8cXYcz7zUZ2/uXto66nLvXR T89+epM8VKGntJIHLOJQLizH7S6Zu8HnsYiFG5mL5C/PhZy/TF9aDwAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAZvYlAHt3cNsgDAVg+KXqhUyRqupG7NBxWC1j9NAMECnFxdjPfoDVRqKJ6vB/kgWF yCY5JOXCT9QCALat9NS/0rH33yY6HN5kt2smx0JgwqWARdh3MUQRht3XkeMWfYpb5LBFP5nDb+28 Yd1pUONeanqw/1q1vtfarpvrvZ3117r8ggmxCj1ngxZfksMWOWihoQkNT4SoRY5S5HCF3Zb2LzKN WlxiCEOjFrpuWdM4OZ2O0nWdtG2bPh+NVGjQwgcs7NDIhT+vryVmAQDr6P/Mlv+t0uFp5OLziqjF bKI03yJyYeIWEtcqhjAWU9b/YPlHeA9/sUYN17ilNVjndnNscZ1HXute66U6gwlXSNw+xSDF+Bsu kmMWGrDw91YatfBxquG+aYxaDPv+jvDZ33OZ149FCR+3kHwXZ4sRL/u9fJzP14QtXodxlHK4Yh63 6OMS+rcz5/WcHT/FLWS2dbP90jEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDPfQvA3v0cNQhE ARh/cczk7slrCtACGBtLCZZCG3bi0YMFJLLgvmUXHis4UfEP+P1mdgghYSGHMFz4iFoAAMbYB9Fp 0OL2vQ8fDvey399063lUoo1bSIxbSBe5cE5CqKIPWTQhZpEiFjZskQ/9bhu26Pefxm9b0oP9v2qp 57q04+Z4v8/njjX/o7EPIE8xizrufxi06EMWunTSBy2ciVKcstftel2fYqwiBSzyqEU1GO0+3cjx SjxnDVq8yPH4KGVZSlEU3W+SIhVVVU0GLXQbQQsAmJ9GK+wID9COSxu3eD43avGBa1wXs7ABjIl9 rCEesIZzmGOOJRzjf5pjbfPMNceafpOfnIe55p8vXBvtfaR/3RUdTPQiBSpC4CIuNXChNYkQtPD3 UJe6LQUv4jVX4xYXcT+pPqHf3+g8/v2r7Vaud7tzohZ3fjz48SR9rGIjb4MWY9GLtL0xyyZbHwta 5OEKuxQZ3pxOBS0IXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8Ae9CsDeHSM3CANRGEaQiWd8 BHeetK5zlJwgh0/nKoUKx2YlliyyCBQGDPm/mbVAYC3gzgWvXPoCAACLyb39Lzf3ObTQ6fRef752 5mLAxLUNsIjb1yaIIpbdtiWhFTHgQkMuLk2YxU9nDRnturFvN1BjSXrf/8Fa73Vt1831Tmf8tY4L tIjraYCFvA/0kgRNdAMofoMsdJQQCx+CLGL5NuBC9+NoAy60hgMtytIVu913cTiU2UALCauwYRbe +7ZyoRZr+Z0BYC00vCIXbFFVVaiv8/nP72YO3I/pnD03raTHlHrv4cE9pvbsz2mO56x96DG+x9b6 PGKNrT2TOYMztthL+80p3J/dNyVCCIUJoggJEc1+CKxoRgmzqKTq/RcTZqHbTr9n1nJJT3Hc74u3 ugbIH3UfxX1wRW5bW7nMnD3mkvP6gi3Sso+u6JkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABP 7CYAe3ev1CAQBVD4EpKht7BgUjoWVjZ5JF+EB/QNrC1NlUIHcNfdS+5iEAsDwZxvhgl/2SU2CRac 9dwXAAC4OPaBc09ueRx7w3Z71633oxIhbiExbiFd5KKu5StUESIWjQlYhO2wtHE7HNN9/r0hbHEc X5dLpH+TqR+6OIelftalXTfXez4/X+tQ0MJGLTTw0MgxaNGYwEUat9AIRRqleD+xbaMX6flhrI84 Xi1jQYu1uwPI8zfZ7e6lqiopy9LEh0LQwgcrNGqhIQuNWfjjNmZB0AIA/pY+GNx+F+m6hi2KopDX /f43g6U/kvtBi/7ixtdzMrfe2nNlmu9yYhbTzLGEa7ymOZjnfGNc4zz/ea6p5xuay+9P7h3deldw iHEKDVo05tUvPmDRxNDFKgYtahO48KPWbjwbtvDn+ju8zM/j9t9sNnLrfgu8HA5jH+FBwv/1niUN VeTxclbyPXrRxnU93prXtrc9FLFoB15F0hvVTE7fuA7tBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAM/kUgL07uE0YhsI4bqeVpbIFB5boCEzSUbIGY3Sh3jhxSVVaGttxeHkxbQ40wfT/k55iHMd2 IgG3fNXSGwAALCL3Vr5c38tvE+12r6aqngZ9MWDi1AdYxPapC6KIJduyUpCFDrcYjvkK18t547rD QI1b859e/l7qvZa259Kec0n7He/1p0CLcYjFONDiswuj8IEWKZRCBlXk6l2UDrZI7WP7G/jRlpz7 mNlv5Jx/+eqb2W6fTV3X2UALGWbRNE04+vL9PuyCQAsA+HspvMIfZXm+3zln9ofD+QIRPHHushfP qYGDcVaOlyEXM4RNEGgxbX4CLe5rjbnWmeM7ds11Strr1LXmcs9rLX1vVrVlKmwIoRBBFCE5ovv8 2P6fPnTn+6OJARcpzCK1++vUXEatt16tQk2wMePgilw7LWUzffKcVeMuBVvo0o8x1wcAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAG7UtwDs3TtuwkAUQNEHwoI6bUSdLivITlhAdkDD5rKONGmTigoa NJ7M88wzY4NDEYE/ukey/MF4JhQgp/Bd9D0BAMCg5A+aew/L6603rNcvdUSiHZWIcQtJcQupIxfO SR2q0EBFjFiUFyGLuG/LOW6hEQvdjmGL8zhjYZ/TIx/G2Jcx/q3M+f7GNF8LVzTn2g5a+HSsFAtc XAYtXNq2oIVL62tLM2Ch0YrzcQ1WnFIg49S6rpMY1LhutRI5HD5lt9vKZrOpHohuYQoNVVjQIo9a 6NqO2Tn2HoIWAHAf9tBuC1vkD/G2Y8vlUr73ezmF7+Vikf61o9/Lel7X9/O1uEW+37Wd5uT/uvY/ TSVOMPQoxxQ+g0eOM5UxxjbOmOY6pHGmPNZQx6t+G/N727BdVR7Ctt6VzeMLor/Sel4Vr9CYYApY lClsMU/7Lgtc6FVdODcPW+i5esc38/H+9Kko5Dnc5H0dj7em+haWj7D8SDNUoZcspRmwsKF82rbX fbb2rf2uiIXvWIs0K4yz1v6t4wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAe/ArB3R7kJwnAc xzslJpidwWSX2g12kb14Do+xU+wQe9bHBTfQ8af9YylVlyVWYN9P0tAUy7+A4bG/2b0XAABILrYz X2zs5dqFNps3s1g8dsZswMSxDbCwfdskkEJDKbTvNw2yCMMtTvNMO1+vW1V2E/kwUGMM/tOm8GO8 V9Z8e8Nfr+7Vabwgh8OZQAsbKHEKmahc8ETpxjSEQgMpvkw/xGLvmgRZSNs3x27IxXdwHQ25uBxo kedHs9u9m/X6tRNocag/rBJUUZZlG2ZRFEXT/FALOS+/k99LG/Z7A4Bx84MsJMRCgyzkqOezLDMf 2635rL/TfyzSq9c7563hllIEQUylxj3nD6nGFN6n1klhTO9lSs8kZZ0p10pd7zf/5Yeg76fDSghF E2xRt7nrz10whQZWzPxjPZ55YRbab+d5oRZhYoRY5bl5Wi6v3ZbkajybfnBFrO+XCsdiy7g0Hmvh Y4yNAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAfoRgL071k0QigIwfKw10cmkaxdnl3bnffps PE1foWvnDg42QO/x3AuHG7FJYwXM/yVEUOFeHEQX/sexJwAAmAx/g7m3sLxcerMGLXa7/Sk0ofKo hMUtJMYtpI1cVJW0oQqNVljEopbjsR+ysLBFWrq4hYUsuuOrdOzuNOYlzf3WN4YcwxzPlTn/v2nO N482+ABHE+/3bV+AFpSw4IXFLGpJgQsft7D1PGqR1m3bIhY+dpFHLL7PHLM6M1+j89xsdJ9PKctS iqKIc+6CFrqkoEUKWRCzAIBxpZCFj1vkj+rrcJDtpZtZ64XAfXfr5ct/k7fb+r5sWYQxGv/cld1L NGDqMYtrHYMx5jfO3M7lnj4TxprfWH8dT/fp/Z8N66cghV5Dw7perfVVDVTU8XGp/8ViwKKOYYuH uF25wIXuV+kxXNgiZRUXOk54/mm1kuf1Wj7C74Ff7MPyGpZ36YcqdPha+gGLFLpo4np6vZH+NPz2 UMSiGXgUGfhJkn/EA88DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAb+xGAvbu5TRgGAzBskCJU rrkjdYAswERsww6diFk4VBzyA078OZ9dC0W0RE76PpKVkIAdVKlVL36JWgDA/5LaoS917TRpss1H 8HoITXQ+MjGcS4hCRqvOwzEELsK4hdyzc0rUQs8bry973eW1Of40eW7s/x5L/K488/vl87zPgxYS sOj6jUTta4k9SGBCBy0aFaOo/bmMMWIxhi1+Ri1qfxznqNU66T0+t9uN2e2+TVl25nz+MlVVqd/N Q9DCRiskaKGjFnHQQj4HAJiPBC3ia1ZRFP3xmtrEWkIWUdAiuJ849rtGu5iFD1q4eMZfRy2WEILI YZ3fzr+WSMBafp5zrbG0dZb0rDmts+a15l7vpZiFGf8LCz7tghSNClpIzMJek2BF465J5MIHLlTc Qt7fFyXcfK1aU/5uH/Z783m7TQlbHB/jYtLhijhu0boldE+jje7p8SxuYaJjF52nrgEAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAgMzcBWDv3nkahqEwDB/SVOrMykBnCGLpz81/RGJpqGhEjH3sE9OI INHmoveRjhrZqS/pkE7+iqkXAACYBXvQnAu0ePntC/v9U7zWg871zFwfbiEh3EJiyMX5LKF8cIUP sWjldOoHWfhgC60UbuHDMdL4jo6dW/IB7Ete+18tca+s+fqmXe9QoIUtDbHwoRJtmwIstE2DJ2wg Rdv6EAtfH9+Vwixs2XYNt7BhGJ9xjqHzPsvSHXj+JofDo9R1LVVVXQy00CALV03TxFALAi0AYDoa ZqFVuJCJ8Kn9ZekzSt+Px9Fj5sEUvbZwrQd79+408/5HuMXcgyDGzjH3fawloGEtv6fOcwtLemZr eia3nGftcy1tb/Hdmb1H70JbEWpjPl2CRAy1MH2lvUfbu3uLbJz4P6Hru99u5WG3G7PU565eJQVV FGGZG+kHWNjQC3tf3m/bL4VZDIVaSNYnWd+PRzxmcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 4Lq+BGDvDm4ThqEADL+m5QBDNOqhe3QElmCezMAYLMQIXCKZxnVe9GIc0gIKcfp/kqXEkBgZCW75 iVoAwP+Reghcam43dqP9/iBFse7NhdDEuYtMhGMNUehw5rg/QuCiH7fQ1/w9NWph7xuvn5Lzw9hz /dy3yPF7yvUz52T6PR4LWjgJ0Qp3ceycjVj42IRGKGyYYihgoSMOWdTR0JhFiGgMWa1emvccZbv9 kqqqpCzLn3kbs6jruhez0KCFnydoAQDP5wMW8UgFLk7Nb/efxTGLofn2Ydk2dnGPHEIQc1jjEfu0 hH1Y0hpTrZNbnGNJe6JrTYW15rGevbpo/zN1dBEKMeWI9txGLLp4RTP/Zs71uLsuupddz3vfbOSj Gb/wKcPhile5DFbEMYtrEYuxuEUcurDbmJoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz8i0A e3eM1CAQhXH8KWZoqKwsU1t4Am+SA6S0yQm9hoWtrQ0FDov7YF/YRUnUKAzm/5t5swshu0uaZFPw Xc29AADA7OIHym193R26WAMt1uvbfYiEPey8P+6qC7eQfchFXUsoDa9wIcTCSVWlQRZdsIVVH25h Y9j4/Vxfe9i6XTf1QxJPtdR1/9QS73dpa17aetU0az4WaNGEc04s4MICLSxkog+csFCL+pNgCqs0 wMK5+Ly+30Is3pJxu9aN3kWeN1KWT7LbPchms5GiKKKgIdcGVmhVVdWWBlloq2EWWhpmYYEW7adA oAUAzMYCLFT8YHZtsyxr+69l+b1BhyEW2mhAhu838XmrEJ4hJ34HE2YxzRxLWOM5zcE8fzfGOc7z n+eaer7fnCseK963at/CJ3Rnpd+m+moWjtvwCt2jDYItLkOgRR2d1/fV/to42EL/EGt3qPr7wPev Vyu5yXN5Pv674N7Xo68XSYMqdHonaYCFBV00oR/firXN4HgsxKIZaUXSzfiFfNycHzoPAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAm8i4Ae/eS0zAMRWH4FimDqKtgP5myBzZE9sUumHQDJTXkxj7B CQlECErd/p9k2XnI1+mgaSc+hFoAwG1Y2rFv6dzjpsl29dDHjdJtHCvAIo5j80CK2MI41nkFVniw RQyzCJMgi3ivjeN83ljTJv0WJW7o70pd90+V+Lylrbm09bq/WfPnL5AYVqFreaDFydYDLUIKo+hS GEWXHSusIu9f+++y4+T4o+WhFgqy6Maaa+o62OHwbG3bWtM06VlimIU3D6vw4Io8zEJNYRe6lzAL APg/w0bY2hDbN7BO4RZ5q6pquHdzqMXs3blLm2SrN4Vm+HHqx2src2xFoMV5apSwxluqcW11fqvG NX0m56xDrcusp7n0rsxnVqCFv8uV9qAwCw+oUGDFKZ27SyEXHmihoAuFW+h+zaH5LAVnKO3hfr+3 l/5/3jfBFv4D4qFvT7YcXDEPtwh6nKx0mF3L21fhFjbr32bjpXMAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAOBCvAvA3h3jNAxDARh+CFXtzMTYGTEw50bcLKfhEIi1FwA5xc/xix9WooiCaF3+T4pS K23sdmiVDvmJWgDA/+ZvLPcct8e1F+z3D9NjH7SwsW5j3EKmyEUIkjeNVwwpYGF7jVho8KKMbStx izGCUc5f5jr9/nYt3tBftbruU7X4fltbc2vrVb+35vo75Oi+VyxmMeQ5Qz6u4yAlbBHSsRKxCFOY okQsLFLx7mIWH1JHLvzrxvP4c4aZ9Ur+HER2O41TvErf99J13fQ5WcxiLWihxwlaAMBl0ZhFHbSw sdL92+Hw84mWfk8tbhHntNDF907bzo32zzlHCzGLv5qHOa53npbWeknzXPNcLc+3dB4LUvnHFrfw MYrbPE7hirgfcsAixSzy8y1oYfEL/R3Wa7VUnNDrvPx6/XNMj93E/d1mI/fb7VrUQukfe09xe5ES q9Cl1kGLueiFfyu2P1bjuaBFHa7we5GvF7tLQQtCFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA nNGnAOzd0W6CMBTG8dNqMNM38G7ZXm2P5gVPscfZpVdLmFnmLOzAWS2MuDks+f+SpqVAW4iKV3x+ 6gUAAK4u9ba9VN/TTwPtds+yWNzV7XSQxfHrJeoaRKHlo21rvwZXHA7HOsyi6euCLJpjpT0nvLdO x9V5bX0pXXNucl33pXK83tzWnNt6g9+teVygRTNHKsSiC53oig2qsOXt9NvVlfP934MtRN5NezjQ wnsnq9WrbLdeyrJMBlqE0AoNs6iqqq61hKALG2qR22cAAOYoDrDo2y6KQl72+75BevtdKqDC9sXt ofEGruGa9B7MYY4pzx87x1zuNYEW08yT01pvaZ45z/Xf8/3l9z81jovatoSAiroWkxwRnumm9ia8 IqRHLM328vTsD0WPa2vzf8Cm1T5uNnK/Xo+5lAc5D65ItXXZLtFn97nouL5gi7jEtzHVBwAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAbsCnAOzdPXLCMBCG4QXiGbocIBQuUiYnIAfKBTgQx0idg6Sl CxUFxCJa2WtkJSZ/EBDzPjMa2bItyRQ2avxdnXoCAICTiT8g9+jL/b6T5/MnmUxuQ9CE2n333EIm LHSiPqZhFNpWVdIUDa9wIcDCaguysP066KIbblGHYEjbr7IAjUOy/v77Q45/leu8fyvH+81tzrnN V/18zn2BFnGohQU8ONkFWrgo4OJNugEX3TCKOODCuXU4prW1iWyaIIx1FIgR92NhFlXvXRSFhlq8 ynR6J7PZTMqyjMKF6kALDa3QYqEWWmv5LMyCQAsAOE9xkEVcCv8iWCyXsvHP8mI06r12q+9HfcYn YRbtse4FdXvSll67b67Hdglj5BIUwBjnN05u93JJvwlj5TfWocf7Tl/hHRqtT3Xbwi10RalpD3p0 1OyH4ApfuyTYQs8vhsOwVrPQC2fnaa1rvqg/fZ8PfNu1/29wMx7Ly2r11VQffHn2ZSFJ5oZI23Ua erFttuOh2ykk+30hFtueWqS7UB/Ix4X7vnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBk7wKw d/83DcNAGIZtC4joEEiMwQgdgBlYJWsxRFdgBBSKMNiJr1xi00Qo/ZHofaSTI6eJnVRq/7vPXXoD AICTKnXcK829TLqZvW9HadAXh1j9wAkdRhHLp/G3JLhiv+8HWXTBFj5dbw73if3qusCMb6N7rp+i //pSG7svdd//tcTnXdqel7bfaNp+jwVa5CEWeaDFlwq0KIdY6JIgC+8/wij12c53c8PrpwdaeP9m ttsnU9d1FmgRAyt0mEXTNO0owRbxHIEWAHDdnHO9kmbaEmpRVZV53e3Me/htHyVhGOlY5oqlzmUN vI809F5L8/prD7Swpe9lZudYQ9ZZyxpreZa51lnjO2GtedY7pznDWcbuZQfHulz6/+0lR4Q5p0YJ rpBQi1s5H+omzcvnDqPal06tfdhszGOoEXehnk0eXFE6lm3bwpw+Zwef+yvYYljD11iaAwAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAF/YjAHv3j5swDMVx/KFSxNy1C3PVoffhBD0AC7fhGL1EL9Ch p4AhKEn9bL/UOPyRKASSfj9SZOeFxGYhMUN+41tPAABwE+mL497d9nrsw6vVh8xmL74fXn5uR+qm FkInpAmfKEtpAis02GK7rXy/KCy8woIsQl1raejFbzDGbmhGCNK4/svXbYyuX7r4V32d97n6+H37 NudhzfdUoEUda5VYwEU70MICJyzQoswCKYos4CIPu8gDLMJ17NrhuqWEQI39plOR9fpLlsuFzOdz mUwmTTCFBlVooIVuGl5hoRbWt2P6OTuHQAsAuD95mIVtabjFoyYcOdsyhiBpXX/TrRUrj9q/9fvu k2moRbqf1/e49yCIoYzRhzn+pzGGNs4lAwC6MLRxhjxW1+NdcqxzrpXed61v4Ra6ytO0Bz36EPd9 kIX+r+basbvP+9VgVfm633d9C73wq9MYfFHpOfF8ve/X+qzg2if3fPDsFo3fm82pqeoffW9u+5Qs c0OkmWoeelHHfvpVrK2z/UMhFvWBVmR30T6S9iL+WB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AFzRjwDs3cFtgzAUgOFH2gsZoj11I3boNszWjpABcs6BALVjP/QwLk2rKKnR/0kWxIlsyKFqLvxE LQBgu3JP3svNvV+1WFXPXoe4xDw4sQxbhKERCx+wCNEKG7YYp7CFnw8xC5miFv45dbpeuv89lPZA f1Xqdf9Vifdb2jWXfb3LPxghViGyDFr08n3QYrhEKEJ4wo40YrEWtrCfP5v1+ng+yFrQoq4HOR4/ pW1baZpmulf/0FM/fLCi67pFzMIGLfSzxCwA4P/TkIUNXOi5Ri3OGrW4ftH5MTNfufVHE7S4PJQ7 8z9ASQ/af+Qet1h/C9/Dlva41z6l3cuWvhP2Km+vW+/327XsL88qmd/FuIXWHjRG0bu5JxuscOPZ z/ughb4f54b42q+106PuGcMZeg0v+728nk5ycOMHb258SD5ckcYtBr0dkdmt2PfsWItbSHIck/Pc HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeKAvAdi7n5yEgSiO448iJeyIKzcmrPUGjQfyTlyg a0/gcXTpgo2hlHntTPvaghoTilO/n2Qy/TOdmYak0JDMj1ALAPh/7AJyz648ftV4u32Rzeah2tYF +No10Mvm2DDMQppAixBuoYEVIcCiDrE4mDCLNgAjbId+uqEZcrVF2GNb0D+Idd6/pfcb273G9hnF N986IKKdb2meIyHM4uDbFv687hfSBlsUTehEHTxRmFAKG1bRD7Cw+7bdvrm+7mvfCc7ozreWJCLL 5afbepM8zyXLMj/nOtCicA/M7wIttA2BFgAQj5kPkwglHAvSNK3qj91O7tbrwbXtz/bhM785b4Ir zMlhCcd7fVxSbIv5X6r/qYQETOXzHGuM2MaJaa5/aZwpjzX2eNcMszjXh313Ln3oROLDK0Law9yH RumfNNV7nT829yEWWt+4l8HCnUts+IVua63vg/4a/b7Xvmauvl0s5H61+kmoxZMrr668SxtWoVPt B1qcCr2wtxLqsrd/KtCiH1xha5FugMW5QAuCLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGNlR APbuJrdBGAjD8EArqmaddaUegOv0Dr1Mdr1AL9ZTNI0gmDLCE2wLEql/qdH7SBZgB2xYYKFI/gi1 AIB1mluBL63TBeaeL12oqu6kKO6jOl2XT0scOJEGW4ylbftTcMUYZNFH4RZTsIXzYRZyCrXQ9ens emn/15Lbgv4m13F/Ra73mtu48xjv9LIYx9snbWOgxdjmgv3Oh0y4IGzi6IMtWn/cSBxq0V7Yt2Ln dD7U4hgEZ7hovPZsNdCiqt5luy1kt3uVuq59yNByoIWFWmidtmmxMAsCLQAgD+UwAYShFnPH6qNp ovMWZ+alOXsu0EKC1aLDOr/49m/P/msJJiDQYl19rK2fn+pjTc/kL/uhr//Z37ff2zJ9dRZJfenD LSztQb/+NLDCBYEVN/qNp0EWQ+lsO9RpksStD7rQY/19aVvr0wdn2BgeNht5PBzkbb8/N2T9f+hp KC8yH1yRhls4ux2R6FbCtrCcC7eQZNsn+3N1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgSj4F YO+OcROGoTCOvyZB7J06slXqwgE4aiaO0Rt1qtgSKhogxM952CmgiqYx+v8ky2ns2i+tUCQGf9l/ FwAAGJU9OK4NtHi7NHm9fpfFopvSHYSuI3t/Lw6zEB9ooa0NrDgPtmhM2EXjAy30Z13nPDRDJnUQ e6oHw6da92+k+qyp1T3desOa9q7WxoVHDAVaaLiEBlpo6IQNtNiZsIov35pm63ptW3MdhlvszFrf 0gdbBBUfaysKObZPWa1epSzLKNAiDLOoqkrquo5CLQi0AIC06KHaNsQibHmen+Z8bDb9711fuO9N WEXUm/lP2pv2l1I6zP/S+gRaPNYeY+0zxmdM95nSOtf2eKT/MXtNd797127X8+916cItTu/xLOvD LFwrBu7p/ba3Y3qduXX9tXt3P89m8jKf31Jq+8XfUvqgCr+klhy0PJgXjtv7Q2EWP4VaSDAmwVj0 J77l4QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwH0cBGDvjnEahqEwjjsRqoS65Qbcgxsw9gys uSsnYEJiYOrQAdUxfrFf47iBIiBtTP8/ybJrt3nO0iiLv5tLbwAA8OemDnWbOhDu8VsXq25Hn+U8 dGnjwIk82MIlIRVpmEX+eZiTcQi0CNcZAjPcUf0l0QPiz31w42+Vuu+fKPVeS9v3svY7HWgR5p1J Ay7CdjXQooshEzbpvwq1CG0IrXhP1vbZWH+7j2EZNl7TfnoXq1Xl/0tfzGbzYNq2NU3THMIspFlr +9AKaRJioUEWGmYh6xJooWEWBFoAQFmmgizquj4Kl3jbbk+e6izfPTwHsmd1lQRcOF3PAy+knq89 55OkpIP856xRwh6vqQZ15rvGNdb5z7XOXW/RYRZmeCOtsvk61upjqeTdzoQwCuvHfUiF72WtkyAL mdc+zsu4S75fax9r9okQfk73cLdem1f/nvi8253a9r1vT2YcXOGScZesdXo7sblkXdfSNtpe1kzW u2w8NQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7gQwD27ianQSAMwPAXSJNu2LjtpmvdeBdO 4QHc9DY9hpfwAh7DpE2MgPMxPwwTqMTYCvg+CQGn2Bm7kNAFL1ELAPg/4gfGPZnt4dLJx+OL7Pf3 7bF9GLp/pXFhi2YgZiEhaNGFLerRkEV3Xp38jp/DzmgDGvN+bt28Hug/3VLX/RNL/VuXtu6/X+/3 QQs7Voe9jVs0vaCFPf50UYoqilikUYuPkX18fhy1qKQfzhi23YqcTm9yODxLWZZSFEUIU2iswgct fMQijlpoyEI3PUfjF+2nMPP/oQCAvvh6mkYs/HGet4/ElvfzefobX7o+u/cNYYssCzGL3vgVrCWA QNBiXXOsbZ7fmmNNn8kt52Guec537bXHUalwHXchitrt9VUNW7SZRY1YmOtuZe7jdCx3EYs8Gs/8 uDu/LU64QIavRzR6/TZjd5uN7MzN5YSohX4B+Gi2V+liFbrgNGgxFL2Ipw5LSH4eClqk4Yp4L9K/ uR8LWhC6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgRr4EYO9uchCEgTAMV+NGjuHC03APT8S9 9BC6M25d8CNDOzpUNMYEtOR9kqbQYgc2El30I9QCAOZlaDe+eEw2lNt9tNhi3TvXoIl+4EQcbPEI ptDmgyyGwy10XD7j1+kq3dexGwymsCe7bFaYSviA9fsggumk+qyp3ff09/v8BeGDK3TOBlpU4bgO 19Ttd48PmvDzpfMBFGUvlOJ1eEV8bK8vzXpVOK7fBlpkWePO54MrisLleR6epekCKqRJYIUGWtgw CxmTpqEXci1hFgCQLg2vWIZQibhpqMXpcnm1wNd19e0hgRayMfZYYRZab2xTbFr+y8//Ux1qzLdO Svf6T3XmXCvleqO/F9zjF6pWWtggC9PLL1IJqajC2LLtVyHMQvpK+3Zc3vw6Z6/veq0p/0uZupss c8fr9ZNgi23b9m44uCIOt6hDCT1vzLzO2fYu3MJFfRMdD40BAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAICJ3QRg745xE4ahAAxbbSPB1AOwMPcMHXKdHivHYOpZOrJ2QUJJXD/shx9uioqEIjn8nxSZ hNQODFCW/EQtAOAx2BvFfYTt7drJXbdz2208RW6wl++J7lPQwk/ELNw5RJHDFjlYIePxGEMWGreI IYt8vj6WeXVN2a8tFFFbfMCq+dpvVetrre2657ne8p6W3sQcNGYxpuvRcIXsDy4HJkYTnYiBixyl sLGKMmBh9+15/fnv41x9WmcwsY3f1us+fFZ+hc/hzrVtm645Bi00ViEBi2tBC41fELQAgHqVAQsN W8hoIxdN07jvw+HWyS/HqWNpfm8f3zlusZQwQQ1BC9Z43HVqCQAsdZ0lrzX3evdca+73Sb63JWbh 09o+RSeebOTCxbDFKbmYRjn+nLYxjS9hriH81tPn9PxTccIEMpQcew3/K2xWq/9ELd7D9hm2vcux CpmsDFpMRS/0eW9GX+xPBS3KcIUdnbv8sf9X0ILQBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA M/gRgL07yG0QBqIwbAOVIFfIqr1UT9Drca7ssquIQlHj2APGQCESoTX9P2kE2Mhj0q79kt/eAABg NWOn8oVj5vljbqEse1FaF70xG2bRlTEMtugCLKSu1+ZeEmLhP/vjdh0/MKN/Hp15ju2AdhsIEtee Rcx7f1Ss3xrbvp+332WBFra/hFfYQAsbYiFVuwAKG1zRNLa64ApTF+96CebCgIsw3OLLrT0eaJGm WhXFpzoetSrLshdoIWEWdV23QRZVVd3LD7WQ9wi0AIB9mAqzkDlTeZ6r0/m8ZLH+1esxmJM+rkc7 dxtfK9QipsP8f1qfQIt99diqzxr/O0v7/KV15nrs6W/8H3rF+m2b7tvrF6Y4mFAKubbJEe4+cSEV qRvLzLhc3XjmQi0Sb43Eved/o9y/HQ7q9VYzzNLvahhcMXYv29YjY/6cDt6bCrYIy/8Z1cQYAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LcA7N2xboMwEMbxQ4Aydu6Qlbbq0j1P1Pdhy1v0qTKy NlWbcsAVBy6krUhao/9POmEcyzYoQ5TBH6EWALB84YFwz3U9Tg3ebl9kvb5v2u0h8PbJoQu0ODhh FvIVaNEHW/SBFXrd7zXMor9vgyz68dY+Ds2Q0cHssR3kr2Lcs4l57z8V67PGtud53/OpQIuwLODh Q4aBFu39e3dvgRZvQRCFBlu8NhW2LfDiuB0GWvRztHNaoIX/3Hme1FXJZnMnZVlKURRNv4ZTWFCF BldMBVpo4IWOi/V7DADwhWEWVuF9lmWyq6rpSQahFcmwL6hE53b63fl+KabD/C81/zUOhI8tOOE/ rLGUZ5lrnSW+E9aaZ71rmjOc5S/37rVH4RZdUEVqIRb6GyDoS7s+rdQZP2zb3Fo3eS63q9V3tv1Q 15OMgypS27KcDr3wPj8XdBH+Z+ldvbBeD0EXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABc2KcA 7N0xTsMwFMbxR9VQKSXiEnAhxp6AIYflBgwIsXRh6UDapH6NH3UsoxYRUiX9/yTXiR3H7lIlHfzN L70AAEAvUpu3xW260dzzqRvl+Z37vO20WdBEN3CiDbaIwyk0sMJKVdWHkjq3uh1/DLCwoIx4/pht 2j70poR/McY1mzGv/bfG+F2vc83nBFo0PsTCwi0s2MICLba+rvzxLgqlsKCKr8R5JT+HWGyD+1mA RtpiceN+C99ltXqSsiylKIrvYAoNtdCwCi0aXhEGW1iYhYVe6LUEWgDAtIRBFhZmEQdcZFkmb+u1 fG42cp/n4eD0Q/SJ+RobG9zn0N7TBvn/bQxzjGGN1zTH1ObpMwBgCFObZ8pzDT1fn3NdNMxCjm+u 4SosyELf36zWt1UNo9j5tpmr566uNcxC2zWsQvuk/YPP+vR6HafjZ76/jtaj939YLuXDvUu+umeG Ex5deZFucEUTHNdBX21fx5cm6Le+sNg15wRbNNFxqg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAxkLwB7d3PTMAwGYPijSqP2xAD0yoEdmCQbsAGHLtMxuDEGK8C1UpHSxMZJ/CWOFVD4KZD0fSTL Lolw2guiB79ELQBg3sKD4e7cuPno5t3uQTab63rdHI6uV6wPWtg2ZqHxCQ1bhKMoumDF8Wglz7vX TeDC9EIYuu5HM2TU4ezneZj/35nys3/WFN/r+Tzzd4MWZTCHEQoNVxRRvKKZjcl9uGIoaBFGLcpo n2Hrtch+/yTb7b1kWSZpmrYxizhooTELDVroNb2XoAUAzJcGLOKfVZIkkZfDQV7d34Y6ajE2ZlHd 58eFn8OgRRuyiO77atxiSof5n/L3z+FzmNMev7XP1N7LnD4T9preXj+93396do1LhGuNWxiNW4i0 gQqjoYoqZuGH8XOyWEjp/g+sr7m1des2hiFdfaJi/D6Xy6VcrVZjoha3bjy68SxdrGIoaDEUvdDr Npht9HooaBGHK8JZpP8lwHtBC0IXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACc0JsA7N1BToNA FIDhB9WFXKKXIvECXoedF/MQLrs1JGSovDIPplNoMRoC4/8lE+jQdsCFbTf8RC0AYP+m7pgXz+nj t0Vvlr1cPbbQRDjCmEUYp9BgRdO0w1ZHOG/HbPSvHwMWFsqI11/i/9zMfxv2fO4/tcdrTfecb/8h 9LEKOxYGLZzMBy1aH6BwPkDR+KhFM8QrNE5hEYs4bjHGKyyAEUYxnN+39aYVxVlOpw+pqkrKshz+ BhqocM5dBS3quh7CFha00OfosKAFACBNeZ5fPht1Gw6l8xq1UF/dZ8SsmdBFZiELe064b+Pe3AKp 3Bz/t2vs4Ry3ssZa66R0LX+1zp7OdUvrpLzW2uslG7OQ8ZdsFs3nPm5x8Fv95ar7Fqg46DHpAxdP Om9b/5pnH8Sw2MWlKKGvlb4uEZ6fvv+xKOSz+335IGyhXy5eu/EutwGLqbhFa5cjY7iijY6F417c QqLtOdqfmgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACv4FoC9O8dpGIgCMPxsFCU1HVVqoKH2 jThWKp+BS3AOzuDxgseZh5+teFhEkD38nzTyFjIORZZmfqIWAJAuuyDccz8eYw8+nV7keHyQ82Lw dt1bPT4HJ8aoxRi2mA+NVjjXSVVNQxZ13U5CGLpv59TIxU+ku5j/Om353r9ri681rXuevyd05n1C YxZteI4mXPfHjYyBidZEJ5oQo3Bmq6P6wr5GMOrZ843hjEvyPJPDwUcz3qQsSymK4uN1a6TCRyuc c0PEQoePWfhzfujjCFoAQNr8Z+HS0NhFLGpxcaXn2HcCvRa2w9/bmIWe9wtjL4Qy5vd/bVuYYwv3 +J/mSG2e35ojpf/JX87DXOucb833rnEJu5+F/SyELPxVDVQMMYv+M7/pf/vdaLginBt+E4ZzjUxj GLY+4bVhntvdTu72+8+iFt59P5768SrxoIU938kYssjNsS1QxoIW83CF3YpMv9YsBS0IXQAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAcCXvArB3B7kJAlEAhp9kSJt4A9dNd1ysF/EcvZG36AWalGCF 8mSezExJi400Dvm/hIyOwqALDRt+ohYAkLepO+elc2W/vfx2IOdKKYrHaE5vrmexiSE0IVHMIoxT aMDieGwvo8YrxrhF/Fy3YX/xQYvuEsqwgMaw/h+/FVnbzfzvX87nfq0cP2v+5zwvaDHMtcHjUxSz GJ9bxOIURSrGaEWTBCzSqMWw/3CczyCU0fq56R8v5wopy3fZ7R5kv3+Vqqr872x3viGpxio0aKEB C93quj6PGrXQmIW+pu/RzfYDAKxf+P9tj220qMVH08w/oAYxNIzkAxldGLMI4hXhaIGLjb/Z9jXn vJSl17jF8dfwPaxpjf9aJ7fPsqbvhLXyW+vW693ruYdXtZtkvvBxCxv1qjIKVPSjs5iFjv3/uNPr R33Nz+l7LXBxLkrovmLZx/Fc9fhP26289deYM8IWz/12kO8Bi6m4RWsfR8ZwRZu8Fm4/xS0kGbvk 8dQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABY2JcA7N1BToNAFIDh11GS7jyAadiY6MoL1Au5 50I9hhvv4tboqjttQQbmwTACNsZKBv4vmTCYykxiUmwX/EQtAGCe/AfBPZbjduzFu92TbDZ31Vwj Fv5cH57eRi3qIIXGKcLARR2y6ItZ5J3XaNhCgxm65l+K/2H+cbF7j3HfvxHj3ynOPefBfjXm4Ect wqCFHsOgxcHFJw7N/Hu84iOYd0MWOu9eww9m9L+JJclKjHmX7fZesiyTNE2b91YNVWjQwkYsdNhz P2hh4xcELQBgOVYuJGGMqYbO9ahRi7f9/qRr2X+2e+8gPSGLocDFj2ucWQxrxLDHJa3BOue7xhLX mfNa/73eEmIWQ7/rfzavvkeROm6Ra9xCpAlU5O5ozy/Le//RBS0uNHLh5kcJYhjS1ies3K1zlSRy vV6fErV4KMdzOV5lPGjh/7yQNmRhvPPCG2NBizBc4R9Fuh+4h4IWhC4AAJMq7++fU+8BAAAAAAAA AAAAAAAAAAAAAAAAAAAAADBLL0VR3Ey9CSzblwDs3U9OwkAUgPGBQkhY9gheyYVhb9ITeULjAdwR Y4t9nXnMHweaEIg++H5JnTKGzuACSTT9iFoAgF21O+iVc3JDude5C61W6/HrOpvTiIWMGrHo+yGM h2PcQs41YFELWchcHrbwhwYy4vXjen79y34op9i8mb+9PQur+76UxddrZ8/6fqD71fP88BELjVuU QQsJUKRBiz6LU8RoxVflcTp+Z2O8Zhq0qNtsFuN74bvb7Z5d13WubdtpXgIVckiw4lzQQqMXBC0A 4PGUEQuNXOjv8Kbxt6r+nLsxdQhaZI91TD8PFPPTzbZPBS4qe701C2tY2OMjrXFv61xrDUt7Za37 W+va61nZe1paWBTzyxC30FEjFhqokD/iDCFoISGLPgQtZFzquTwvBC6mooQ81/m6RLp3uf7Tdus+ 9vu5sIV8yHgZjzf3O2BRi1sM+nJcDFcMxffS41zcwhXjoTivzQEA8F/w/xcAAAAAAAAAAAAAAAAA AAAAAAAAAAAAgFto/noDwI8A7N0xTsMwFIDhJ1CjbhwAdQcWzpMjcACW3qbH4BQcgAuwdesAwiWv 8WueTZNIqC11+D8pqhOi2ixEYfDPpgoAMD1+A7in5rgfunm1epHF4m43bqMSsh/7axa50IiFHhqm sLHFLez6obiFjvN7NZAR3O5659invZzN/DslrlmVuu7fKvH3vdw1//xjoLGKdrnbuJd2HrT4ckGL IBaaSKMWn/HcRyrSeEUIHzFaYeELH8Cwz+47u3kPm89FNps3WS6fpa5rqaoqxnzSoEUes9BP+5ne p1ELYhYA8L/457Q9q/vG7+t17/fYBtbxZHziPGAxErOwOU7t1HOUELM41zzMMd15SlrrJc0z5blK nu8v3mOPuXb/nNexxS2CxS2kDVtoXErfCa+b67uKRAxX+LDF/pqkMQxfn1AhznMzm8lt87I6ErVQ D83x2ByvMhy08Ne30oUsrty5r1MOBS3ycIX/FEn/YdAXtCB0AQAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAADAkX0LwN4d3CYMQwEYdpNyyRjdoxtkkA6UxRiiUi9IHFEj4uZhG784TkGoVDj8n2SFuMhO ODTiwk/UAgDKlPsVvXRuM46PSwu539DbJHP2HLKQCIWLT8Sji1K4SEUIWORCFjI3DVu4IWvLOnH9 uF+8pvt63B/zX1biNYtSr/tWJd7vY11z+g/AqpiDDlmIQZ2HkMVS0CIMHbLQQ8ctvs/vnQYwjn7O rX8paNE01ux2W9N1nWnb1t1BErTo+34StJAhczIkZCFD3kvQAgCeT4hWhFFV1eR1OK/r2nzt9/k1 lhefH1UsY/bU8XtZHbkw6wkTlBC0YI/n3ae0AMDa9lnzXv+931/uVernpEsLL8l85eMWtT/KM/d1 fP6eghb+GSznx/E8jVlUIXAh3zf93KkoIXEL474t63uR9d+axnweDteELd7HsTXzgEUubjGE2zEx XDEkf9Pjt7iFSY42eZ2bAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAd/IjAHt3kJMwEAVg+EFt AysP4IqVMXHBtkfyVux6Bi/hNXTHXoO1r53HPCa2Iaagrf+XTBhG6ZRuCCz6E7UAgHnxN357asb9 0D/vds+y2Ty28y4qIce5X7PIRReziKELjVho3EJDFbpuIYs0bqFze108hrQj3fPa/tbN/M8zxXNW Uz3vn5ri+/39c+4LWviohQUeLGQR511o4jNEKHSexiy+i1r0zePwYYwYzDjI6a1BI71+6/V7M3uT qqqkLMvu7EPQQkMVQ0EL/ZsOi18QtACA/ysNWviwhY2iKOR1v5eP5vMlzzJ7YTyIfY7omv9MSYIW i/BYuzVbT9fs3C7t0nuMcfw5XIc57XGtfab2XuZ0TdhrenuNvd+Uzz09rv8OrvNFmB9rECFy0aYb NVahz3U9hCsO4fHGBS70m2oWAhfLcCyrT0g4pu5zm+dyt1qdE7V4aMa2GS8yHLTw67XEkMXSPa/d GApapOEK/yhy+uNBX9CC0AUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP6EoC9u8ltEAbCMGwn oUI5RdpFj9YL9hq5TiXqAmocGBhPiJomlMrofSTLxsE/eJOdv81/bwAA8GtTt+nZvhha9PbTREVR OO+fkj4JsOguX5fwibGWUAoJqpDQihCaPsxiDLdIgy26EueO88j8er1u/TtP5UHdPvK66y7HPUe5 7vteOX7v8nvWwRVj3xhooYMrdLsdAibatu7bOtDCBlQEFVwR609TB/POl5qnTsq1QIvdzruy/HCH Q3kRaKHDLEIIrqqqocRAi9gnoRYEWgAAIh1eYYMt5PcYavF+PLq6aWTQ1ERDfcvl3F7GqBALPX4N F+Q/Ov8S57CWs15yjbV8y1zrrPFMWGue9ZY0ZzhLrntP5jRtXban//hNH05xTohQ7XMtz32QxVbV Q58ep0ItknX773rZ793zqdzg1V2GV+gQC/0sn2P79G/evHct2MIWe4xTfQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA4A98C8DeHeQ0CEQBGH7YENKVK1esTAyeoDsv5GU4Q6/hpdxrY5UZeJ1h8lBj cCjk/5JJCS0MpSlNuuAnagEA2xHf4O25G4/fvfh4fJG6fvDLfVRCLsvxOo1OaMxCAxcuUBGiFiFu cTqFuIWGLXS7sA/xw5pzaWu8gfwaownOWo/7r9b4fvMcs7X/NGjxOazrYxYatAjLH5egxfk8jlLY AQsrYvFmRDDGMYvuSjgEM+xzUpaF7HavcjjcS9u20jSNX+/iFC5o4cZU0MINghYAAItGLNLAhRtO VVX+8b37DUkDFJPiG4Prcjri17q5km3+S65YxJLbX9MchDmub565ztmWzknOebY8V+755vz+L3Ge cl+79He90Pmlj1P42IURrojXxXGLUfxi2MdNMQ5i6B+It2Up9X7/m0N96sad2EGLNGCRhi6s538K XcT/cVqP6Ycz9WERugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCZfArB3h6kJw2AAhquooJco u81u4A12G0+5W0w3Zkhjv4ZKN5iylueB0pBqUv2h/vIVtQCYl7E/Y6vnNtfjbWqh7XbbrNfDP64r AYt0LvGKeC5RihKq6EMWfcQiH2XuaxC9yGv1R9zvP5ljfCBx3/Mwx9f7uHuu18zhivtBizT+7MZ9 yCIHJ2KE4hziFjFyMRW2iI/9uK55ua2Zx5eRe852u9X1c/G9OR5fm9Pp1LRt232W5kBFilWkmMW9 oEW6nqIXghYARDFiEc/xWvpdn5zTj/Z84d5iv5q7hS66uUH44kHmEFhYSqBhKXs8a5+5xTmW9J6U vZ5lyXvN9bUtMfyxqsYxNBFDFiVKUcaDYEUIWWzqufi8sk69b/ed3u73zcvhMHXLacljMx6nqCMW MVTx04jFVNyiDl3Et3FsDgAAAAAAAAAAAAAAAAAAAAAA+GPfArB3/7gNwlAcx1+girJk6VYpe9ut V2Lt1CEHyjV6ic7deokoHSg4fuAHJn8VlaYQfT+SZWMT22QhZOB3998bAAD0In6x26svT6dOXq3e ZbF4rNp1qIQ07bjPQicszMICLuKgirZ0Qyws6ML6689LVQ6tOUT2Uvlrv0Dxt9j3OIzxevvd86FA CxeNaSnDukVzXAdalKGv6NQWaGEBFBZQYeEUbdBFHvrrvji8oq1/wrxWl0evZDYTWa8/Zbl8kyzL ZDqd7gVa5HleBVpYiIUWPdZ+HdfzNNQi/p4BANB7gr2IfLcordM0rdrf/t4i83l3Aj0vzHH2/hLf 36MAi0mSiNN2CNRwf/DbZQxhAWPY41DWuNY6t3Qtfa0zpr0OaZ1bXuva6xFmcfmaWsroWbu699uY bydhXAMqqnjHEFxR6DNnCK4oonCLpk/qEIwizBGnT+j8Oq7z3/vn1wf/UPu12Zzb7rMvL758yH6g RSmHgy5caNu4i2q3c3wsxMIdqUW6fyxMZP+PhlP9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg AlsB2Ltj3AZhAIzCJgodkjVrt56Fs/RMnKrKDTp0S6YsSCmmNfgHx4UStSiq0/dJCGIQJlQqysIj agEA6Rh7u1485v6vP8+dKM9zk2UPF2MKWHQvYleAYlgrbKFAhbYVrziftXSftV/bdR2GLZqL+br5 f3hXbiDF+IDDdadBL6tOye//RlNBizBqYf2Y9UvjwxIKWVgfnLBBiKLuYxXDWBiyULRCY+/B8dqn c4TBjOmgxWZjzfG4N2VZmqIo+vujSEUctKiqqt1W0MId4xZ3PDELAEBsKmjhlpWPTChqcTidzONu d81J5/cF0QwXsejfBh2HLxZ4dqUQP0jhGv/THPc2z1Jz3NM9ueU8zPU350v52q/lQhN6ioazZ9rn QxaNj1K4p32tuEUQrlj7qIXWq5HoRVuU8Odpf2UrnGG65/vTdmvePn+rvs6HLVwh98V8DViMxS2s vo4ZwhU22hcu38UtTLRuou2xMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsKAPAdi7m5yGYSAM w27TVmo3rNiVJeISXIhbdZU7cCZ2bMKPlJCJM87UuAkqFcTwPtIojh3Z7s8iK3/L394AAODb7AFv D23djj18ODy6/f6ua/tQCRfatk9DJzTAQgMuJKTic9UhwMIHXNgwiyaEWch8fp75B1mk+O8ks007 9p2DXD/refseC7QYQixsoIWESgwBE3odQizisIq69tU0r+Hej8n9iwm1eDPjwzy6jq90oIWcebrb vbvN5smVZXkUaJEKs6iqqitpS8mYPEOgBQBgzFighY6vVj6v9Hn6IGo7cbh2B3nbMIu+jg74jp7P 5RD+S+w1p1CD/7DGT61zyf/51Dpzmmdqjb/0G7PWfNfLee/nrmnvtb3o2xpyIdeiD6nQ4Ioi6iu0 P+rrEifad4dlP6/26fxX67W72W6/svX7tq5dOtBicaJf26lx258KszgVauGiMReNxfJKEgUAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAYIY+BGDvDnITBKIwjj+I1OgR3PQEnKcn6FU8gaterqsuuzJN SBCmPJhXHkosibaW+v8lE8YB540LJbiYb3HrBQAAJhnbfO14TDeKe/5uoizLJEkeBmMWYKFHC6/w Rwum0OAK37fwirK01odZWMhFH4jR962e9nUDvbnt5W6bz99i48NLsO6/b66fddq6T7/ofWBEGLRu vAu16PoWbjEMtRA5xCCKgwulsIAKC7k4HRMpB+/r57F5rc74j1OaJrJcfshms5Tt9kXyPP8K+NCA Cg2q0NAKbRpgURRFe9SACxu3MAsCLQAA5/h7rG82pizg4n2/v6yYzRvnC7FWsJCLZvxad6w5hAXM YY33VIM6PzfHPdb5z7V+ux5hFpfV1FfB9f142v5fFgZH/eOvavoaSlHHwAp9ctUgiyoGWlQu9EKv 1esWeg9vnj3TGGbR1mzOJW4Nj6uVvK3X8no+JEvf/tS0nYwHVOgSa/e6to8TW3Dn7Zxvds2UYItw 1B8bAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV/IpAHv3j9sgDAVg/IUokbJ2bSTGqluHXiDH 6cCJcoscJEep1LUiUAx+5uESkBoq1en3kyz+CGwyhoGPqAUApM1+2O2tGc9TFx+PJ9nvn9r9LmIh Yd+e0+iEBiw0cOEiFd9HFQIWXeCij1n099u54zW7tVL7iL9z3wGCvyfV5/6JVH/r9eeOvyVZm5CD xiwqP8clHGvQotsOgxbDqIUGK3T/M9rawIWLWNhrSzPnReaCFpvNSrLsXQ6HVymKQvI8DzGLuaCF G2VZhqCFhjAAAJgyFrOwQ6MWH9MfoR6buN+auWt7Lh72vht+z29KJRTAGv93naXWSOlZWev+1lp6 vZSffak1Vz5eYfc1blH5qEWlQYvmfIhY+HDF2gct1v68xiza/6p+nrY44a73x+6FXBuxarYP2608 7nZzUQvHvXt8acZZpoMW9nwtfcgiM8f6QkDM/ljQIg5X2K3I8A/8taAFoQsAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAG7wJQB7d5DTMAwEUNTBKFKj3IGDcAqWvUMOyyW6667LlpRM7MET46IqIBTD f1Lk4IbaYROxySdqAQDbV3rrXT7XuhC1+FLX9a5p2sWcRiXCS9lDgMKOGqaQcIU913jF+azH+HGN Ri5SECOd2/XC+mkf841V9hJ/Ueve5xckVrZnUevfe41a73W57+8GLWxoIowpTqFRCxuvsIeNW1wW n6XfvXz6/lvaVmI/B7ffv7hhGFzf9/O8Bi0kWCExC4lXSMhCD/lZ5glaAADWyAMWedTCez9fdzyd 7v3Cm+tcC9ctnuYxoLE2bLH1oAXhhP+5Rm3r1LTXLa3zl9eqeb0txiV+ez37nG2y+YcYt7CjPPXf NG6hMYtp7jFGLXT00zPbT/97+hi+8CaOoTWJMYYzdA9Pu507dN09YYvn6Xh15ZBFPjfq7bgUshiz z/SWG3NNKWzhsvGanZfmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAD3gXgL07yEkYiAIw/Igp ga1bWWvixvv0Iiy4DNfwFK49hBvCTjJ1Hp03vLSUglGTqf+XNG3H0indWDb9iVoAQLn8C900aPF4 6eDt9lVWq6fjdhuVkLztxyw6YQELC1xopKK/hBywsMCFxSxOn/fn7s/ZVepL/FWJ117iNZuSr/1W pX7XNkzhr9tCDj5qEdJYSEuTPmeBiZDCEyEFKQ4pbKFhCtu3cIXFK4YiFz6G8elCFoc815DFQmS/ f5fNZi11XUtVVTlMoaGKa4IWGrPQY9t7w7s1AQDjxoIWfvxjtxs6yfkHb/v/nM7T6L4b6627y43f 47eVELRgjv87T2kBgKnNM+W5/nq+n5xryvfpu3POUrzCb1vcwoIUwQIVcTxHLDRUa4ELHYvPBsff n2nMjrcohp5D9+/SM4I+A8zi+n4+l4fl8pqoxXNcXuLyJpeDFn68kVPIwsIVNt4tX54LWnTDFX4t 7hzi/ta7xQPjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgxJcA7N1BSsNAFIDhF6GG9hg9h0fI NbxRLqY3KC7cle4abBzNpHmZ18mUWGzF0f+DIWEMM0lBaDf5iVoAwO+WevtdPLfoxuPcQv4F7EVx fzKnAQt/1HiFPWqYwocr7Pnh4MaIxXG48RqNXIQgRji3+83J9SX+Xo73nuM9q5zv/VJ5PWv4P5+G LMI4Biw0bqFhC2eCExq3aE3AIo5T2IjFmzm2Mo1atGYtXVf3TVsunWy3z1LXtVRVNcYsNFJhgxZN 00yCFv4aP/z1xCwAAJfqX2idiFno8MqylNfdbn6xKHDRvzA7/nsctzgXuPiiW39vucb6OUUN/sMe P7VPbs/ylz4T9spvr2vvl/O932JPW1ooovm7IW5hj74E8a5xC41ZdHMLH7MQ6X97asxCx3j9sIZW JWQIZ+g9rFcrednvZTMftnjoxpOkQxbxnNPHkRC00Dkb7S3MdefiFhIdP6Lz1BwAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAPimTwHYu4OcBoEoAMNT0ISd+3ZrYuLGI3Aeb8U1PIXX6K57EfA9Og9m KCVt44Ih/5dMQKTM1MTSbvoTtQCANIVf5PYp423p5Kr6cvv9a79/jkq4YT88ZtEJC1hY4EIjFZej HQIWFriwmMX4+PDal3PeIq0v8Y+luPYU12xSXvu91v9cp//gXRC26Pz3YC8HLcaohUUomihoEYcs 4qCFc7W8/vz02ziE8Ttcc9xvZtZ7pussilq2R3kdrVxZlrNBC41XzAUt9Hc69FyCFgCAR2VZthi1 0KEBu+Pp5Gq5Nz3n+fyFLGihj5FrXr0vTeMVOr+e73wEY0NBiy1FArbyXLb09/qveVJa65rm2fJc Kc+39rjEGubb+XhFuG9xCwtStBaokOONbJ/8fn9cthay0ONNELZo/XVyf679rO8P9P6+k+2LvKc4 FMUtUYt3GR8yvt1y0CI83rkxcmHhCjs+LWHOBS2m4Ypw61z84f5a0ILQBQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAD/gTgL07zk0QhuI4Xm0WN2/BQXadHY3L7Aoew4SYqtse8NpnU6IziEK+n+SF UqDFGhP/6m/97BcAAAwq7YKX97391dctg3n/cXGuARbd5uxdAIU9ajCFBFfYdgjnGGLR1TneoyEX KRAjte1895jzZvC6Cf6czPGd1Zzf/b9e77PafSj7nh8Nc0jV9WmIhQ2wsIETNoxCAyukDibQwvYd 4nkKtLB1vGhfC7TwfuU2m72rqndX13UbaCFsmEUIoQ2wkDCLpmnao5QEWsg1Ai0AAGPR8AoJuCiF XEioxfdu546nU/7g8Jj2ugZYDD2r1/O+K+/7SARapDmmWOulrNdU84y1ZktakynnWfJcU8835u// Ges0p+9mlbVtSfCEHtf90fdt3/8/iEEWpp1XvF/H6svOKarttq0bfLoUWFEKsbDn8eMU+uz09r6h YIvScy4bo7S0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgTr8CsHfHOA0DQQBFx9IqUlpamojC CImCJofKYXyHXINb0VAS8BhPdhi8ERYQea3/pJGjjeN1SEHnT9QCAOrjH9h26Of+0snH47Psdo/D 6xyV+AxM5LUcubCAhQUuNFLxfU7ngIUFLixmkT/vr5338se5lvcA/3lqvP8a79nUfO9zLeO7xv3f x3CFvadzGtff3PiwhQ9a2FjAwk8OWJRGwxY6PmgRAxqloEVKTT8vst/fSdd10rbtsG6BCo1a+KCF j1po0EJHgxZ6HkELAMBvTcUsYtgipTSc+9r/bxo/VLzW5FqIVZzP8+/F44X7/U9/8ZDytQQa1rLH tfapLc6xpr+J7XUta96r1u9WU1xiCXv6a9nrGLfQowYsksUsfLhCJEcuYthiHDu3kRy6aMbr3mw2 crvdyg889PNktydfgxZxLYYumsJ6KXgxFb+Ix/gjlH4UQhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAMz0IQB7d5PbIAwEUNimlEVELlGpJ+ouF+iGw/YKVe4QFil2GZGBqeUobUWhRO+TEI6TYGeT n01eufYGAABZuT9XS+fkPfz11oXK8tEVRfVlTkMTQ7hiCFDYs4YpJFxhx+dzGCMWwxHGx2jkYgpi TGMNZsz1x+56nTX+pHAOW9z/Fvestrz3n1rvteaCFtHcZ4MWIRkPgQnv4yVoEUzQQmMUHyZokUYu ctGL9HlTyELH11SV79/Lju5weHFN07i6rsdoiEQqNGgh4QqNWshZbst8GrMgaAEAmIONWaRBCxu1 aCVqsd/nLuB87jMp/c5gwhVy3Zjep/PX4hh/jJjFcmsstc49vZa51tnSXv/TOve81tLrEbNYb025 UjRjOy8hCvl9qeeH/vuA3pYiRGfCFRK76PrfpDZmoUcnz+3P4fLcQtfsb3uzh6fdzh3b1r2fTre2 /dwfb24IU8iP/DRiEZKxjVlEM5cGK7x5zHfCFjEZ5+YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AMAvfQrA3h3kJAwFARiexDSBlRfArV7Cy3TpzgUH4hpuPYU38ALEhcHWN8+ZMq0tSgKE1/xf0vCo rVNcWHDhT9QCAMoS/3HbU9ruDx282bzIavWQ1zEq4WuPW/jaAxYeuNBIxe+t6QIWHrjwmMX+fAnf W7qZ8fEUSo8VlHj9JV6zK/naj3XZ1zoVtIhRi37QYh+2aCwy0aTfGxq08PhEjFp8ynjUYixmEaMW Oztv14ta/Mwdt1iIbLdvsl4/S13XUlVVfi0aqIhBC41Y+KZRixi00GN9AwDgXKaiFh8atRg5Nt+b 9X3BobCFPcaYRRew0DnpeTs4Ns44N4IW85oxtzmnmjGnn8kl5zDrOueVfO3XMLO7f4e1TssxC4so 5lKEBSpu7J795eEK+1qOXNh+f54rExbD0HMbO1bfJ7QWwrpNn4fvlsv/RC0e0/aatnf5O2jh69bW vq8N+4eFzLGgxTBcER9F+n+omApaELoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAI3wKwdzfJ CcJgAIZD+jODl+iJWPYMvRAn6wVcdeuyCymhfCVfEiIybUc6xr7PTEaMGNCNOs7wErUAgOuzdEW8 fO5hHC/fWczax9n9NDYxXaw9hiz63oUwhYQr0u2ucyFiMQ0X9tHIRQxixO0Yz9juOnGlxwpKPP8S z1mVfO4/tf1rXQtaxDFFLKa4xWnQYopNTBEKDVp0fjvGKyRQ4VwaspDYRfc1N49efGRr6bYed1ld O3M4vJq2bU3TNCFmoUELCVakQQuJWcitBi00eqHPAwDgkuSz3FobRh61kBCTeD8e5887v+BJmML4 tYalx9P71oZzGnzsYkuX+B5TUtTgPxzjr45T2mu5pffkVo9165EGghbXccy0tFBl8/IdQCIU1n9e h4KED1Sk4Yr7cd9+/G16l8zp6H0EQ9fSqoTx4Qw9h6e6Nm+7ndmvhy3kP6bncbRmHq9Yi1tUyeND MpfGfKtkv3NxC5PdDtn20hwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPiFTwHYu3+chmEwDsNG VFW7MnfohpAYmHOlHqkXyMxBeg9WRipSbMe/5EuUtqDKCIf3kaz8aRoHhibq0JeoBQCUw/5g286P x0sH7/evbrt9jus2KqF1G7cI2giFMyGLqdF0AQsFLhSz0AjnGJ97vMyl9FhBiddf4jVLydf+U3n+ 1luCFgpZKGqh8MQx7T92ow1WDGMWw9dtzKJ/v+bol9MfQOFfslp9+OWbq+vaVVWVPiNPXdAiRCum ghbaH4IX4ViCFgCAHBS0GIcstC9YLNqvd97Tj05fuuPHGIV9MLfBinOhCx2TXr+z2xkf8m99dplL JGAuczBPvnP8x3nmPNdvz0fM4u/Oae/ZClrEyoOCFC6VItL2fbpnfypckV6LkYu0X9uN62MY4b1N Ojbc12O0yi8flku3Wa+vRS2CJz9e/Di460ELravLoX0ns18PF1qfClqMwxV26dzwS4BzQQtCFwAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfNOXAOzd3U3DMBRA4RsHglqxQZ8YIBOwEKN0DiZihfad pwpVovlpItvJrWtSgUoVw/kkC2NCHEAlgoccohYAMC+xJ+Nlwfp9N14unWixeBRjipM1HZuwD1/3 IQodpdBRi0YOBzt8xMIOG7ewxzVD2KL/XH3OMZ5x2+fDpR4rSPH6U7xmr7/2FK/7J67zc4q9nqeC Fo2b127euABFP69chKJycx2n0ONTzuMWYfhiHGM0oxr2j8nzTIriQ1arB1mvX6UsyyFMoYMWYcxC By36Y/zxt/5dBwD4H2L373Du33/f7SaDFmeC87R+TUcu1MiMsU+L9sf+klRCAewxv31S+1r+0veE vdLb69r7pXztc9tTlxaMu+cOZQcXnPDrQ0HCBSp0uOKuu2/X3d+quVrzo3YRjMady1clJAhnPC2X st3vZXM5bPHcjTc5jVdMxS0y9fFWren/g2bquK/iFhK8bYN5bA0AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAHzTUQD27hynYSAKwPDDSop0tJYiGgokmvS5EWfwUXILLpKLcAKwHfw88+LnJQthnfB/ kjXe8BgkwFD4J2oBAOmwF7Q9Ncv9sRM3m2dZLh/adR+VsHUft1AhQiH7sEWIVNS9bQtZhNhFiFtY zKILYsjo2sPxJ6UcWlAp3n+K96xSve9LXf75jr+RQ5zCjtl7KCVGLMJ2OKdyYxVHi1BYkGIcrOhC Fq/xXH+sdFGLN3ddH7SYNmuegrPsRdbrlRRFIXmet4EK/droWJbl0aCFHregRfi5ynsxAQDfx8IV WZa1y9S60qjFBy56+ng8p/c2aA1b+PDFF/vs81hqUQPm+J/zpHSvf2mea54r5fmuOS7xW/MN5/V/ w98MohP7akTc1lF/T1cWrojH2shF3G/btXQxDP3YOp6rqjjP7Xwud4vFOVGLx2ZZNctWTgctbN26 HLZv5/bbo0ev6TGx7A6MIv1/YhwKWhC6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgDO8CsHcH OQ0CUQCGh2IwNHIGT+IV3PUODbf1Au7UZfcYQB6ZB48J0NRY6+D/JRPoiAxtYhu74CdqAQB/x9wd 8pJg/r4bx3MnyvMHt9tlkzkbm5Cb4TWNhihslGKMWGi4oqqaPmgxjnqIWWjkQn/XnnOMZ9z+vnCx BwtivP4Yr1nEet3fddnzDf+WbcjBBi1aH6+w+xqyaEx44tPHJ2yUYi1qMRe2CKMY9WStJVkmEZ93 dzg8u7IsXVEU3Xtd1QcqZEiwQh5rxMLGLGRozEKDFgAAXJuGK2zcQudlpGnaP/44nZZOsD5vt+Gc Hipryo2y/fYaUYsYghas8X/XiS0AsLV1trzWb6/3k2tt+XW65ZpCYhNDUMrM918U+riFHjMUJHyg woYr7rrP7br73zU1czpqH8Fo/Lm0KuF80KL/3O/2H/Pcve337vV82OKpGy9uGq9Yi1sk5uetmbPf hybmuKW4hQu2bbA/NwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7wJQB7d5OTMBAGYPhDmwa2 bmVrjDvv0xOYGC7ELTyIS8/gkoSk6YKCnfb7OsNobaMEM/I+yaQ/NJ1CCH8LXqIWAJAG+2O2p2bc fXfgev0iy+V9ux5GJWw9jFs4XYRC+rBFF6nY99tx5KILXdRt4CI8xp0jPne8/GupBwtSvP4Ur9lJ 9bp/avz+DgUtwqjFcdDChy324oMWLkBR9zEKC1P4qEUcsPAhi89hi50GMWqNY+zEBy2GX3Tmc5Ht 9k1Wq2cpikKyLJOyLNtAhYtVWLjCRS2qqmqXboQxi6GQxaU8XwAA52XvLxazsLhFGLlwI89zed9s ppxw2jFh3EIjGkPBi986xXtoSlGDS5jjXPOkdl/+02PCXOnNder5Ur721OacaVzC1mcanbiyIIVo KUK33fLgohUWrtDb2siF7rftvfgYhn3Lv9Z5a53npvmMcbtYTIlaPDTjsRmvMh60sHXrcti+Q7A/ Lml+FbSIwxXhUuT4B4KhoAWhCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARnwIwN7d5iQMwwEY b8dkgXgJ7+EldgnPyxXks4aEL2QwiuvWwn+lDONb1vn8kkaouA5ituiHPkQtAGAcYrvk6WB+3oyX ewdaLB5Vls17czI2YTfBM8aHKGSU4jpgsd+bNl5hR113Q4Ys/Lz9WXnMSzxjnPvBpR4sSPH8Uzxn K9Xz/qr4+x0KWlxGF7Ho4hbXQQsfnji4uUMQqrDz9UDUov/67ng+iOGDFn6t+HUny7TK83e12azb 52VZtqGKqqqa61h9Hj5iYedlzMIOeU3L3ObefnPx8HP7L78zAIC/IcMWck6OoijU23arDs0962E2 u3Wg7o8CGa2IvUY81vY+5zbH/o2oxXfvmVOKBEzlvUzp8/qpdVI61zGtM+W1Ul5vLKGHKa13a11Z WtDBvI9b2CCFr0K0wwUqZLgib+7lR2POz+U4ughGW5RwgQwj13RBjaflUq13O/V6P2zx3IyV6scr huIWWnz/JObk/0W1eJ1S8cCFCr6egsexOQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8EkfArB3 N7kJAmEAhocQSQybHsB01zQNm16GE7DqmbxF1z1Dm3gWV62gzDCf8zGU1pr+CH2fhDgO1UHTiG54 iVoAwOWTC7I9tNvNR3+4Xj+a1erWjXVUQsY6bmF1EQpzjFTYmEVd98MVOnIhoYturunFMLqYRXju +PYSTT1YMMXjn+IxW1M97nOF1zvY84WghYQsJGqx8/GJ3SBoEWIVb+1nyat5P3ARHtd/vrDGmDRN zHb70purqsqUZWmKojB5nrt4hQQtZGwjFzZm0TSNe936wuFpmh6DFnaTeRn/t/8ZAMDPk3NMfO6R c02WZeZpswkP0AGLkS/l7orOOlShxom/H+9P/MWze2uciaDFvNaY2zpTCwDMbZ05r/Xb633nWnN+ n/5yzVPWjX9n2qCFqzzYIIWPUbhShL+f+nN4LeEKv89FLvy8BC/27W/e2gcydH3Cqv06V4uFuV4u T4la3LXbfbs9m8+DFjKWLofM7dW8fNHQ4zhoEYcr9K1RjzNq3+AtHpkHAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAACtgwDs3U1Og0AYgOEPYjBtTNzYA3iGbj0BFzGewlW3XsoLeAYXLoyburCpWJAP 5pNhxNqm/k19n2QCjsgAMfFnwUvUAgB+39Bb65Jg/rAe55+daDQ6kjTNenN+yEJffudHKCxcYft+ wELjFUXRDg1YWMSiH8DQIe/OpZde/eWaRSD2l8/by/ZjEuszj/W6t9cFcVR7v+uCFqXbX7n90kUn dP/FxS0saFEEUYvnYNsFLvrRi+5rLWph67RrDsuyRObzNmhxcXUmD/mJHNw9SnZ9L7PLWTOf57lM p1OZTCZNwEKjFjosaGH8iIVFLcKtHm/HhPb/+wYA8F3CeFIYtdChUQv1tFzK8Xi89fmr8GM/ciFe AMOPXOxwP7uKKWrwH9b4qXViu5d9eiasFd9aX71ezNce85p+aSEJ5i1ukbqf428FCQ1W1FsLV1i8 YlX/veqHLUo3l7q5pijhAhmlrdFeZPP/gNP694vbxWKTsIUWd2+kH69YF7dIvM9XwfJ224l3nEgX rRg6bujRVR/MAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACADbwKwN79qzQMRQEYP6WUtIu4iEIh dNDVNYuTk4v4HC6+RB+jk+ATOLi7OepD6NriYimmMSe5tz29JSoVNSnfDy75Y8xNoZLWIR9RCwCo N/8gtst8HH124Gh0K/3+YbHuAxZ23cYtVBmgkCBSsR6u8JELH7oo980XAQsd4bnLsMVyuymaHCxo 6rVz3XUU/uFmi7BD+XL98yXFRSzK7TJgkZplKj4+sQxavAehiqqoxcz9zmrMYnme1MxRHbTodjMZ jx+L9avrM3k9P5B2NpXpXksmx5GcXuzI/tNEnm8eZDi8k8FgIEmSSBzHEkVREbWw0Rgfr7AhCz/0 WBu3sGEL/+Dx7X7fAAB+k41XVIUt/H3nbTZbi1osntqs96DwQ7qJVLRctCKz+5We2x6Xb2cb3s9+ eh/clkhA0+IM/z1H0+Zp0rXWaZ5tnuuv5yNmUf85N5k3/F6pQYui8qBBChejKEoRbrvtIlUat0h1 2/1MAxfFN3eNXOTLuR7vjtFz2bqEjtTNs9vpSNzrfSdqcZKP+3y8yNdBC7/uuxx+X2b2+w8vdj0M WoThCrsUWf1nR1XQgtAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVPgRg725yEgbCAAx/lRJT 4qIGF0ZXrrgB7vQSJt7AtYfwCF7CG7j2EG5c6QFIjAmgNK39Zjp2WopE4w9t3sc0lCl2CiESWcxL 1AIA/lfT6nVBbbyfbxfrThRFO9LrRZUxPzahi95pbMLFKFy4wu37AQuNVywWdtOAhYtYVAMYuknl nGU8o4xatHHx9jYvPN/Wa+e6N8Vy0CLLstp+WqyHnYpdazKrhSxSLzqxMPt6a2MUq2IWSS1qUW5l DCORMpLhYhargxZR9CaTyb3Zv7w9l/nxrgTZa/7H1f6YZ3S4LY8HscxP+nL6EMve3YvcXN2YY+Px WEajkQyHQxOqcIuFJ0myFLVo2vdvNQriRy583XnvAAB+mx+wcJ8f/v0wtF/xPE+nsh/HXz25XcW5 iFpUghb+mH/sG59hBC26NUfX5vmpObr0mvzlPMy1mfO1+dq7NKdfWghq4y5usVVEqT4KEvl9LUJo 0CIswhZh8f+pX5LQMY1bmMdr3EKPFYGM1M1hL9p8J3A0GMjTbLYubKG/fpZv11KNV3wWtwi845lU p3dPO/AeJ1JGK5oe1/TSZSvGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAGu8CsHf/OAlDcQDH f6UhARsTNxZwMDGEhZjexDO4OnkWboCbBzFh4AZOjhoGTSTRtLXvnzweFEyMaOH7IS8tT+irUdPI 0C9RCwD4v9wN2K7Lcb7phaPRnXS7fb0fRiUWoQkzFBOhkCBSsRqucJELF7owc/lXxMKELJaPvbqt 703/Offd47z/UlXQovC+biIW6m8/inIvbJHLImjhxydcyELNheGK92AbDveeD3tsdzwT0Nh038lW 61Vmswe9f3N/JfngWBrlOg31iBr6rX7cQo5ieRq25HEocnYZS3/yJs+3UxmPJ9LpdCRNU+n1epIk if4ZZ1mmt5viFmHYwh/+Dcj343cHAPDb1PWiKmbh5lw86WU+/95Bw3jFuvlgP7I3zBbvPApTu9qy 1M+vc3WKGhzCGrtap07fS53O9ZDX2vdIA0GL/V8z/D9SBS105UEFKWyMQpci7PPYXqtd0EI9j+28 C1qo6EVuR2YDGX5dQo3MrnPSbMppu70taqEMynFRjqlsD1q4fdflcHOFN+9/OOFHKcJRVGxFlj9I qApaELoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCNTwHYu3udhKEwAMPfqfgTXAhuDhoXBnZZ HCWu3oYX4+TNsHgFTm7uJg66EAdCsCL2Oz/2tBYkIaDg+5gTSws9xZgUlvMStQCA31O1ip0p7d/N xtVPJ2o0DiRJdgr74tiELnani9CHGEUIV4TtOGCh8Yo0dUMDFiFiUQxg6JDCOfN4RvW6b+u8cDvX vnpc96rNClrkwwUlXNxCt3UYM/HRibH9rREKdzyNohap3x9HK6oCF/lr8ojFexTKcPNMkyS62PaT 9Psvcn7RltPrrpjjfXnzQQu34KdxcQt9HP/YBblFRodbcne5LePunrQfRnJ0+yy9m549f6fTkVar Jc1m08YqdEFQXUBcIxdxwKIqbFGOW+h8Ybts/f5/AADLVhWxKG/rvUa9DgZznc/e60OoYkrgohyx +Ba8mPPaF7Ep4YRNmYN5lneO/zjPJs+16vmIWfz9ORedNy4tmNL+ELdI/H37qyChnw/0ddn3zlr2 /XWsj/2o+e+yelwfJ37YGIa+1gcyPsIc7g3Yzw8n9bo8DofzhC3OsnEvxXjFrLiFiY5PpDh9eNsm ep5IHq2oel7Vn24yZR8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjhUwD27iClYSAKwPBLaxc1 m+6E0oK4EdxEFDyCd/ACghs3HqcroSfwGN1058ZbSKGgydSZJK9Mx9FWKLXR/4MhY4yZtAhNN/mJ WgDAftIHr93ZcfLdgaPRkwwGp+Xcj0ro3I9bOFWEQoJIxedwhUYuNHRR7TPLiEUVslg9d7iNae5D /7n238B178LPgxYatXCBCWM0NGG8AEUuYdAiDFi4wIUxb/WxsahF4Z3PrA1atNuJzGbTcn77cC1H 91fS6rXtKu/LaEVrEYlZeEEL/dkpDhN5uRR5vhBJb0TO7annjxMZjycyHA4lyzLp9/uSpukyUJHn eTRkEYtc+IELjVzoaNb/DwBgV/RzIfzs8GNJzut8vtn5JPIEZy+SIbGghW6TZO0ToJsSCmCN/Vun aa/lL70nrNW8tba9XpOv/T+tGX5vdEGLsvLgghR1jMINF65YGFOVI7ygRTnsce735Td7e8yB+9t6 FHUgw69LuFHU6/Q6HTnudjeJWpzZkdkxlfVBC51rl0P3Lbz9euvhz8OgRRiu8Lciq7cvX93OELoA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDwIQB7d5OTMBAGYPibQpqUuHBBYlgYF+xcuCfRc5h4 AK/gMbyBp3DtzgPoFThBF6ywrZ3OjP1ayk9iQIrvQxpLBzpFFBMX8xK1AIC/0bWanWkdj8vtcduJ kuRMoihuHNOxCbvInQ1QhBhFCFeEfR2wsPGK5dJtNmARIhbNAIbd5Cds4eIWheigxi76vGg71354 XPc+rP6+ulBFGGsHLXK/n0kdtqiDEyFm4WIUdZxChyyaX+uYhQtb6KhFCGNk/nxhzm5xbCRNXdDi 6flezh9upEhMeYYvycrn2pDFoLxF/qb324ELy7Q+ohcTkfcLkeGtyPWnyORtLq8v82psNpvJdDqV 8Xhcvc95nleLimflB+WmoIU+phcnD/ttx/kzBAA4JB2w0BGLMDYcun/xpIvFrifcft/HK3TgolpI 24+tPEddz2/0LWrAHP9znj5d6zHNc8pz9Xm+Uwg9HNt8+5hXlxZM63iIW0T+b/bAhy8iH7CwsQob rsh02ELqkoS9H/nN7ldFCR/IyMMc7gVV571MErkajXYJW9yV24c04xWb4hZGjRfSnD68bKMeJ1JH K7oe1/WtK9YcAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa3wLwN7d4yQQhAEY/lBDQGJjDVaa aEKhxiN4Ce+gt/AU1MTWxEvQUVh4ChNMKIVdZ2bnY2cHdqVQXPB9yITJsuwQovwV+xK1AID60ROu 3ZtxVrXjYPAivd65aEtCT6CvgYkwbmFlMQuJIhXL4QqNXGjoItuWLGIYWchC3LHytYvX66r3Sf+r 8dg3zz7ubXvMVv2e7/gfNQ2iNBqzyCISedAi8fO55CELjU4sxyyKoYo4alGc5/vOgmPpcROpClq0 WolMJq9u/vj8IEe3p/JpLjNzX3sabpeuaOxJI20UIhZ22+KSLgcurDhuMWuLvN2YcS1yeCdyNRb5 eBrJcDgyr8U96ff70u12pdPpFCIVcdDCDnvi8bLbwsiFjvr9DQEANqnsfUDfL3RuvU+nqw/iAxUu SFH1oT1cIwxXxPPSu9c/aMEa/3edbQsA7No6u7zWptf70VDCDj9Pf7nmb68bf0+0QQtXefBRi9QH KVygwsYs/G374TD7HJjPD+6bfpK46EWi+/sgRliXsGPu1zluNuWk3V4nanFhxqUZY/k+aKHz1M91 Wxpsj3+8cE/BipGWXIsUfxQpC1oQugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPAlAHt3jNMw DAVg+IXC0MDSCUZYKk5QBjgAR+ECXIKLcASY2NhZmNjoijp0oBIhlDzHrp3IgQqqCtP/Q6HBNXFa iVZ0yE/UAgDWL3ZFu6w13q+2i+8OlOd71fcds98MWviwhQYoXIzChSvcfhiw0HhFUdSbBixcxKIZ wNBNGsf08YzfXect5Qu2c+7rleI5O3/j3JcNWrjx0u7XQQt/64IWhd33QYv69s0GK1zAwo81wxYa rngPjlPaueVi7S79fiGTyaPZv7q9lN2zQymr33MhC41VLCIW9quX9eqAxdyPt+e04xYxrwci9+ci 2ycix08i+3djubkemzjFaDSS4XAog8Ggeq0szRbGKnSOjrWDFnrbFbdwFyoPpfg3AAD4mfA1P3x/ cPe5TaNJL9Np/BjdB28GK9xYbE57fjBvFe9LKUUNNmGNda2T2mP5T88Ja6W31qrXS/ncN3XNsLSQ tcbN/436OZ34KoTZbMBCYxUarijDsIX4koT+vGU3E8PQ+2wc40OCDy9tUOMoz+V5NlsmbHFabQ/S jFd8FbfIgvvn0lzePewsmCfioxWxebGnbt4xBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIj4F YO/+dRIG4gCO/xAbwDgwOELQwZgYEhP1cXwBH8TRF3DjAVx8CRYTViedWUhchbbetXflerb4hygt fj/JpaVQrppoC0O/RC0AoFrsjdau1Tha9cK7uwfp9U6SdTcoYQMTbtxCSyMU4kUqPoYrbOTChi7S bVEWsUhDFvn39pfrqMZN/3+GY/9bdTxma3PHXha0cKMWftAiMiELuwxNiMLGJxbmsRur8Meb87wN XMxN9GLhvc8ymLFKq/Uqs9lLsn47uZH94wO1R5je1DteRilycQvzXBa4kGa2notbNHZy4Yu4Uf7P bdEVebpU40Jk70rk/DGU2f1YRqOx9Pt9GQ6HMhgMpN1uZzcgLwpa6KFvRO5HLooCF3bU+W8AAPB9 NnJkzwNF8aMgCOR5OpW5OtcEzaa7c/5i3TxOzif5SZbbvIhFst2PWzjHtu7P9tvqFk74D3PUbZ46 HWuV5tnmueo837aFHqow3ybmdT8X6muBSJ/bRbIIRVaN0IEK/VlUJAtWZEPto5e7av8wipLoRWRf r4MW+jpDlnWJ5JsCM09XXXccdjpfiVqcqnGmxkQ+D1rYddvlsNtiZ7tf5kx+HQUjLlmK5L8gKQta ELoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB4F4C9O9ZJGAgDOP5dY2wCJoaNwYSExQcwjA5O xvAIzr6P7+BDuLjpC8jkaMIDyCQDJbXX3kfvSkGNWFP8/8zFkxYOCUJwuD9RCwBoVt3OdqZyeZyN m89uqNM5EmMOg8v8oIUGKDRGoeEKnfsBCxuvWCyKYQMWGrEIAxh2SHCbZTxj9/u7tXmzdu57s9p4 n1Wz931b0KIcRbhC4xZ+0KIITdjvZXxi4eaJi1WsxyzCuR+/SFzUYunNy3U2iSKTvf68ymz2JpdX ZzK+vZbuybEss+uZylcQqqjEK/xjwXFTxiz0nDxq4b9SV7fIdN77Ik9jkYMLkdMXkf7jVO7vphLH sYxGIxkOh9Lr9VZhC92E3MYr7EiSZC1oocd07m9orhuY+8+fNv4dAAC+R6MWdXMbSHqYTCTRqIW+ L9QELfw4xaaQRe3crZXq3L4f2XreD36f38Ya/3edtgUA9m2dfV6r6fV2udY+P05/uWaT6/ofRY1b N/XmGrbQKkQ+XMDCxipsuGLphS3yoIWNL0oRwIjcyGMY9ro2biHFfwlWH43dmoNuVwbz+VfCFufZ eJYwXrEtbmG846mEy1c/nUfu57Ryjn9e3UOXbrgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABU fAjA3h3rJAyEARz/mlhC46IjAy44aIJRn8Jdn8LEzcF3YfQReAZWdfYd3JiU0np37VeOo4CJaDzz /yUXTlJylUQsHe5P1AIA/g7dYO3WjONNB45GY+n3T9zcD0pUgQkNWyyCE1WEQoJIxWq4QiMXGrqo niuaiEUVsliso2v6j7sWe7AgxvO2YnzfYzxn9fPn/p2gxTwIWtj5rJ7P6hhF3hKyCCMX+rOGLXIv jpF766zfFHvPXLlOpy9ufvdwI+f3V5Lud8wrqwhGUn+MaqjCn7uNPYNYxVLoIqmPK5OV+EWRFMtb Zc6lPWxRz/NM5PWyGofXImdP7/I2nsjkcSKDwUCGw6H0ej3pdrvmc7WoNg+twxVtQYswdBEO3dDc bWQa8d8BAGC78HM/HGmauuM+8lyyjhfA05DFJkG4opn78SQzShux0JiGmZcELf7NGr+1Tmy/y396 T1grvrV2vV7M586a7evaUXjfAxN7L0qkiVA01Qh7nI1ZiDTBimaY19iwhbsDYP6vu6qEHm+DFjZy IYu6hLtrUK9zYK49jrLsK1GLUzMuzHiW7UELnWuXQ58rvef1wsafh0GLMFzhP4os3yxZF7QgdAEA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPEpAHt3jJMwFAZw/GtBY4qJYXLRwYF4ABInZ8/gDYzX 8BJewdULOHgCRhfcnA0DEQKCfW0/+vVRICZYKfn/TH2l+HitCVGW/olaAEB1yu5wF3jHj+LtbtML RdFx/P2gcCyPWUgSsHBjMWYxS6IUfsDCxSsmk3RzAQuNWBQDGG6Txfw0bpFHM6pQ1xu11/W8VR3P v47nrLZ/7svvzzRUoc/5QYtZtq9xiTw0kUYsXHxiughS5FELP1yh+9OluEVxvo1a6Prl3H25B4Ne sv/weC/nt1fSOGzEM9I5NmKhow1ZqMB8JY+zmEU4Dwsxi0X0IgjFTF696a9Ub7eZPf48E3mNt+aN yOWbyOlLX56f+vH1HEq325VOpyPtdjuJW+iNym3Qoixy4R/TOTr66vheAAAss/GKsrCRjVp8jcdy EkXrXqwYuQj076f338OKwEXgYhZe8OK31/LX9mWNqtbZp2vZ1jp1OtddWmef16p6PWIWu7/mf67r QhO25CBmP/2cW6xChNkcF7D4jsemC1bYsIXkJQkXuHBxC41fJEUJF7eQrC6Rre0CGm68aLXkYzSS 9+Fw02lfx1tPivGKdXGLwDw/N8fsJ3GboBTJoxVlP6ejl6YsPQYAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAIwfAdi7g5yEgSgAw6+kC9jpzgVdYWJMINFTeAQv4QG8hBdg6QE08RLEjYlLT+CSPdjW TjuvMw4tEkMIrf9nJjQVmIpBOyz6E7UAgOOgF1a7K8b5tjvO5y8yHl+U235QogpMaNjCBSc0RKHD xCtM4CIMV2jkQkMX1b6sjlhUIQs3j87p3x5CV4MFXT1u1cXj7+Ixq/0ce/jGzL2/GRqzyOx8GpTI 7LYfskjFhSdSG6dwQQs/YlHFLVYN31vXj/OjFi6akTYcrzMc5rJcvpfbD0/3cnYzK2MWuX1MGLCI ZPN1C/dHW77qvEU0qJ8zH+Sbl8bUy2oGIYt6v/er+BqJfFxX4/RWZPa6ks/nhSweFzKZTGQ6nUqS JBLHcRm4MCNN0/qi5WHYIoxbhMO/wHmX3wsAAMcPWjRtGxq1WGcNoSgbsvD/N7RM5GIV/q0dkV5E +49Ri74EGvoyR9/m2dccfXpNDjkPcx3nfF0+dubcbe5w3WdiE+HStSxFmECFDVhkftDCxi5MzKL8 RKA4j4jtfc1ITdDCnHfY5xEbs9Al8klx/pGMRrtELS6LcVWMN/k9aKHb/qpbV9u6P/yQQ7wf2x95 y63Iz9V7W9CC0AUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4N/7FoC9O0hpIAYDKPzHith2UYqC G0ERituCS2/gSTyJB/AUbr2Ai3oBd7rpFepOKHY6TibJTJJOdShojb5PwkzT2owVqbrII2oBAD+j aac7Fc3vF+P6qycaDA5Eqb1gro5ZiOj9a/XRxCikilJkmVSRChOwWJbxCn3UQ9/n7vdjF+ZcqjiG iVvU0YxtSXWT9lSv20nx+lO8Zmfza28btHDzmT03QYv66IIW7/bcD1osooCFiVosly5uEcYs9LEO WmT23F9PGr/Wbncus9lzeX77eCOHF6fmcflm388gbOGFMNx9VdjCBi069mOhFmHIwr2c/taa8f7h 8baX9vz1WGRSjN0rkfMXkaOHqdzfTYuvtSvj8VhGo5EMh8Ngs3I/aNEUuYjn4s9deR0S/HkAANRh izho4W67qMXbfN72CdfPR0ELpd9PipFHcYvyaIMZba7/u7HG71ojtXVSutb/vNZfjzSkFmdhze2t 6//JqaL58vcDCasQ5bABCx2r0OGKzA9bSF2S0Ld37OjY93y/KuFCWcoGLk56PTnr99uELS6L8SRh vOKzuIXf5ci9Of//qn6/Q2Q1Sek/rumly9fMAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA60MA 9u5YJ2EgjuP4HwMBN9kgDsalCcbE+DQ+g2/jZsIbuPoSjZOuDk7uDDqwUPCu3L/99wCFRIXC99P8 c6XQ3pWENmW4H6EWALB9OqHarauz7z44HD5Kr3eer9tAiXnAhAZblIETGkShYRQ+pKJaGmjhQy7m 5YMu9D3dbx5kUfajfdp2W+oaWFDXcas6jr+OY1abjX1VoIUNtYgDLaYhWEJbGzyRhSCKiSyGVdha DLiwARhloMVEqoEZ1fHac223P2U0estf37/cSTfpuRHGyRELZyuzcK6V66RZlmksWY7CUnzvdppM O6OnyOpgC90vniLTtZNjkdfreXVvRC6fxvL+kEqappIkiQwGA+n3+9LpdNx1eJpXlmX5pOXLgi3i cIu47MTndf49AMChstdxLU+v8Z6/B3gf4/EmBy5be18I642wvZjlWYMt7L5rjP2v0Qf97MIxDrGf fe7rv/v7zb72+XvaZp+73G/8nOfDJmyiQ5Ea4d7zgRb+iVwDK4py+zTdfT6Pn3TPn83w2Znf5l7n KRP+/8ZwHAmBFv74J62WnLpn1zVCLS5cXbl6lp8DLXRdczlsroZujxM8xZy2rVnUWvaPglWBFgRd AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO2pcA7N0/T8JAGMfxp6CJgIlNHHUxzC4Mbo4mxtFX 4Obr8Y2Y+AKcfAVuhlnjYgIjibbYa3u9p0cFjP84/H6Ss9dr4TkbtMBwP0ItAODnNa06F3njW1m7 XPRE3e529nOzNubCLETStNgvwiikCqVIEqlCKkzTYRZFoEWxb48X59i+VOEYRbiFC81YJaEu0B7q vK0Q5x/inK3Fc58XaOFaEVxhUxl0oIUNmkgagijevOCK5jALG2ThAjB0kMVrrcZH2m2zGOejjMcv cnp2JOdXF7KztzsTSKH38/9Ner/smxCMaXUd3Lgdawq5aEUtiaaz4RZpK3XLX/phFlHZt9uP+Mtg lv3Rvshd1jZORA4fROLbodxcD6XT6chgMJB+vy9xHFcLl+uwimXCLUzfPs5u8+mo11KIfxMA8J+Y +1ZToIXhjz+PRl+ulz+XDrCoH8zbMqs7r0sQxLrU+K06of0u63RNqBVere+uF/Lcqfn5uvpeHHnj UXmv1qkQeSsDLExghQmuSHSwhbgkCXssyc7NwzCyrXmsTZUQ+96kDLc46PXkaTJZJtjiOGv3Ug+v mBduoXM5pmpMf7+q8ztE3Kf3pvPscf8y+pdztb78BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg D70LwN4d4yQMhQEc/xA6qImRleBkiDHpoItX8AgunoG4eReO4OgdOrgYE4/g7AKDIdDie9Cv/SjV oIO25f8zLy1N21dJhNShf6IWAPC/9EFqd26cfrfjaPQo/f7Zct0GJVaBCQ1b5MEJDVFojEIDFnZo zELHdBqnsYskO24Vssjn0TntskrqGiyo63WrOl5/Ha9Z6UOtzZayvX4QtIhlPWjh12fp+iyNVMxL QhbFoEUeslgdb4MW862CFkHQksnkZbk+vL+Ry+G1HHQPy367jfVFyY/droGLLHRR2EcjFp6GLHzg or1ou6uOJWkl+eMx9W3fkzxikT3ZM7VN3MI+JtMt50cir1du3Y3urUj49CFvD5FEUSSDwUDCMJRe ryedTieLU8RxvFXgwoYtdNiHoNf5bwIAdon9LLef4zZa9D4e//bkq2Ff69Kf274u7ltynX+hKTGC psxRt3nqdK1VmqfJc9V5vl0IPVQ1LFGVeYv3dT42YYsOWTXCByp8rELSwIUd7piO+85f/scgSbKw hT9rnEYvfNwiSc8jadDCn/84CORkf3+bqMW5GxduPMtm0GIh5XELeweud9+63dxVr0UpimNRWFpl kYuNt/iL7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANN6nAOzdP0/CQBjH8ecMgYggg7PRhNmF wcXdN+CbcPFd+CJ8F8zOvgE3ByZ3E0NIWGypba/XPncecVGgzfdDLhzXP3eWSCjD8yPUAgD+V6z6 nAnGj/N2/9uJJpMzMabvjTVhFkWhOfvahlFIHUqRplKHVBSt6NvgCj/gwm13+9hjpA7HsOEWTWjG oWtrcfa2rttp4/rbuOZCs+7YNpemEAu02FT9tOqndd+GWBQhFEkdSNGEWsTCK3T/S34GYOjzNXNs MxgYWS5toMXj04Nc3l1L/2TgBVjovz0MpdBjLrxCP6LBFpnt63M4Rj2KcAuTGclM5jba8pllFVDx Ayx06c3wbYgJy2JW/c9zkZe89W5Frt5ETp8XMp8vZDQayWw2k+l0KuPx2CtuniRJNMxCv9bP7lhd CN1bWsv+LwCg68IQi4IOt3Cf5R+r1bYT+Ml0Wz7nTVW8ut4nDLPQx0bO0ZWAhq7M0bV52hYA0LV5 ujzXruf7y7m6fJ32OWdb5tW3lCYYL78jiJ8KUbYqwCINQy3y7xK9zaYc14EXab5vGYaRPxfjdaZj FbppqnCLi+GwbO/r9W/Lvsnbq/h30EfS3G3rQIuN+LkcmRrTv7Pq/A6RJrwitp/bHl7G8HIe/o+g AIBDk+x7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAACATtpe0BXYkW8B2LtjnYSBMIDjnxFCWIyJAyQs OrBAoqNP4Fv4Aj6E7+DM7AvoI/AAGuPs7MjihL3Wa3vXfr0i0QTFw/+PXFpq6RWiKA79E7UAgO3x F1C7smO0bsfZ7F6Gw5NiXQclysCED1vUwQkfovAxijBgkY88bKHHctkMXTRjFvW1b8PlXxd/sCCu 8/ZiPP8Yz7mMU5Rr5Xln6j3CVxRcsKEKWqRuXYcsjJRxi8Qt3xtBCx2xKOMWq2MW/nE6ilFHM4yK bbT1+5ksFk/F+s3dtYwuTlvRinUBiypikZUBC2Pn9PeNmHqbul/FLrLmcbwqaOFu+/aW7CXNiIW+ vGaqXvZVQYt1YQuR9iU03b7JgcjzuV2x4+hSZPLwJi+3c5nP5zIej2U6ncpgMJBer1d8HxhjqsjF qsBF+DUdxdAXRi8uaB7lzwUA7KbwPVlHLHTUIh+vi8X3Du5jFf79X8cr9D5u2dgn2C+mqMF/mOO3 5ontuezSa8Jc8c216fliPnfm3Py84ee4PDahiw6+ClEEKvJghV1PXbiiY/+GMGla3O/kny39Pm7k RzX+MUUgsjyOuKBFfvzDbleOvxa1mNhxZsejOi0fscikGbQIt/ttmdoe/jNE1NPWIwuW2qrIResl /mQ7AAAF+3u4u+1zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+AkfArB3xzoJA2EAx78Sw9BUVkfi 4OpGnBx9Ft/EJ/BBeAATB5/ARCeeARY25Yq99r727iiRAYVr/j9SqaXSgwSwDPcnagEAf6dvFros 2p5Xy+Nvd5TnRfUznAeni1mIlGXzexOhkDZGYYzIZlO2gQu7bgMWceBCb28W3V924hh26NtUahaR VCdmT3XcKsXxpzPm8LVogxF27Bq36IIWGrowbr0JWnTXGpzwgxTfbZQiDFh8SRi3CGMW9roLWhi3 7h+vX54bWa0+6vXn1ye5urvZ84i3QYBCt2nIog1buItxFw1ZtBcXvLDr+jdx0EJl7i27zlvUE4La Sby3YdginlJTIxdxoKJvms19b6lZ//7La5G3arl4ELn9FLl8Wch8vpCiKGQ2m8l0OpXJZNKGLfTa D1v4QYs4chGHLXSy9HZYZ/+6AIDh8qNDcYTI3z4ej2W5Xh9yh0GpLnOTVQeBi+j3nZCF97kwpEjA UB7LkJ6vYx0npbGe03GGfKz/Pl7KMYtTHDPVsMQpjuuXFrJoe+Y+0/0qRL3YQEX1v4BxQYuyLNuY hYYsRl7gwlT71jGM6tpu11Ngcd9FZC5uMc3zejkgbHFfLe8SxitGbthx0ELPtHUf/+zb/77V73eI dGfmffvp7fHTGD+daX4ZCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAEf0IwN7Z4zQMQwH4Balq J0AUqUJiQEgFQRdW7sIRuAXiEp05ATvqDTowMrKwtQtT1SbEiV/z4qaFhdKE77Oe7DhO7URNfzK8 D6kFAMDfoInT7tM43zRwOHyW09PLrG2FErnUQsUWybIdiihCgYULJ7awMZuVRRfuOBfFHPmceZ/m dqsn9REWlKnrupU6rn+31xzmU9R7s6ijyG47wUTsxRJaW/HEYimxWJVVqMxiVXCRjy0kGIXQYi5l Ycb6/I/t9lQmk3c57h7I48uDHF2c6BmVxBW2LdlZ+JIYiYXKKpJCXjHXkq7J9bm27tNxKsaoEltE puz5sogWurNAU2pWiSxEymkwQ8nFpvSYYfpM357vi7zepo00unci1+NPeXsayWgk0u/3ZTAYSK/X S69vO3sPq9zCCi1CuYUVYLhjXO2SmtrE6aWl7eS9AQDQbKqEFrqt+zudjnxMp9+9UP4jXz/fVWhR Nc7UkR0XCi1+WX7XFAlE02QHdbpmTbom25ynyXNte746Cy3+g0CjSfNm39fmmYaTTVijg1ohnKAi 8TKLxG9rxEZmEZv+7AmDa6e1k1vE/jjxQgv3+oetlpz9TGpxlcZNGmOzLJVYJFIWWoT9Vi2p/eG/ bjGnbSMJakuV5GLlEq/pBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoLF8CsHf/ OglDUQDGTwkhoTEwODIQX8CBxcXB0Tj7Am6+jm/C5gP4As4ya4yJCUwkQMEe2kMPlxIcRCl+P9IU avW29Q/CcD+iFgCwH2Uz0UXB9jhd7nd9oTg+kShqrG0rYhYamsgeZxELWcUskkRkNpuvAhd6XwMW ZZEL2ydJbH9ZxTEsZGFjZuMf8mT/31PVc6jqcRs9/qod++Fd8+1BC7/opJRF3MIHLSxkMS8JUYTh Ch+18OssZFEEMHzIYupiFsnWs6jVdBLuNxmNPuT65kJuH+6k3Tm1MwrPMLstsrWGK8K1BSosWqER C4tZ2G2aHpt/vIpbSFJEMvJQhpdNAhqtBS4Wel1tGs3lThvfgs0lnDozjFrsilxEJfunPs9EntKl cSVy/pI+bzwOpN8fSLvdll6vJ91uV1qt1vJnwgcufNgiDFzoY93P7vsJ1PX+xqEdzO8HABw/H7QI 4xaqXq/L+3Ao48lEmo2G/8Ty8MSWv+HLCbHz4MXG/vmYC7feZ9SiSuGEvx7jt8ap2rkc0zVhrOqN 9dPjVfnYGXO/4/rSQhRsX/6/IEEtQoMV6etEXSfp87iFKyxmYY9rbpvtp0EL3W5VCcnf74nyuEU3 jqXTbMrreLzrsC/T5VnW4xW1/LDDoMVc1rscC7fNv+/q+x0ixSvxsv3s4+FlDC8nEQsAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAwL/2JQB7d4zSMBQGcPxLrXTQQXEoCN0c4ubg4uRNRNw8gQfwFt28 ghfoCRQRPIGLq6BDbWzMe8nXfHlNtYO0Jv5/JeSZNH2JoNDl/YlaAMDq6YJpl9k2+O6Nw+GtDAax H6dmkdg8MKFhizI4oSEKjVHUBSxc2CLc7Hl3XR6yKOfROe3e3lOTFzNv6jM09b6dpt77+u+7bv3E +qBFHrAoYxZui6JpJTaRjyfFeFJEKpJvQhbhOCmut0GLZKmgRbcbydvbgx9fXZ/L4cWpbO1uh082 22vQQiMWGrJw8YnP4OWiFZPspUELN3YxCx+0kPJndy681gUu0uClNGbRiTrlvWjYIlxGU8c/RSui BecWhS3sMpxhHCPzsSfyeJINjkX2z0QO7l7l6WYko5FIHMd+6/f70uv1/MLnbvFSt0+SpBKzsHEL e04XTA8jF34x87X/fQDA/2ADFuH/Yz3vohbPLy/yPh5XoxY1n5UGIYpZoKJ6sNybsZ83m3/u/b+o TSECnmU98zTpXv/SPG2ea9XzEbP4+3O2dd7we5qLTdiiw0ZxvmPiFdPi+OxnE7mYmuPuU330IttP /ffj/Dopghbu83c2N33YYomoxWG2HWXbvZSxCo1YpFINWoTH9VhqjoffssU8tt3C9KRVF7mY+xUv OA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCt9CcDe+SslDMMB+FdPGbjjGJxZ1NmNRVcfwkdw 8S18CB+Dzddw5DxnB0fuOEFIa9Lml4ZQYOHQ4vf1QtMkNGlK/4QhH1ILAID90zQjXZaku9nbH3bt qN8/t59nK2m1zEIkz6vtSmIhQWZhjMhymQfBhYun8goXNL8KWl6CHKOSW9TSjE0cw2Tm7hja2P42 931b2/477V6//ipxhealQovcx42Pm1Jg4NaV6MJJKJZBSFFLLZrkFXF8IesCDOO3Tahvm9Ci08lk MqmEFk/Pj3J5fyOnnfqVNJZJqLxCyr3mYVsFFLHIohRWFJHMolgEgcW3PYZysetUblEKMLzgIk8W bUNMFi1lfubzdRpNnVozPjXrp6kOTYKK+Ht6mkXqp0j6c0jlGPax8XFVhc6dyPWbSPdlLKPR2D5X +jIcDmUwGEiv1wsToRt781ephYotUsFFmhdPpO7iKW27tgEA2kAsFNoUnNTC8TWfi73ZN++neefb Kl4JQX4Riy72zLFIII5NdtCmPjumPjlkPdT1N+trc9up87B1x8PDLEkvx27uXaEo7Di4qG0RXlZh bJqKK5zIwkTrkyiu5XIvxdDhsPj/1jIvt7joduVzNpP36XRXs29teJVVecWJb3YqtFCNpJZJNZN6 2FlUTmRVE5mW0/y0G9PuRGIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+WHwHY u5uchKEogMJXEQJTSSTRmDhxIjE6dQFuwwW4CNfgmIlr0DEL0JHRjRBGBIzUvr5euL2Un4nGwvmS l5ZK+4oGpJMeohYA8Pv8PeSC+3Scrdqp13uRTic+xQYlYmBCwxbz4ISGKDRG4QMWYYSwhR2TSTF0 EfaLIYv5PDqnXS5T1UiBqvL5c+5/7+/O27/xEvOZoPWDPMAwC1pMZ+s2bKERixi3KAYtbMAixi3K YxZxFKMY86DFt4ltLGq1EhkMPrL1x+cHObm9tK9qYalhiRCw2CRo4SMW42RcCFpkUQv5KsQtdH9d hmNnSYskzpUUft9RdiPQZH8evtCwhQ9T7En5LTCXxS7EPV9v21kWwvC30/SP8/VJW+TzRuTgWuT4 TuT8dShvT33p90W63W422u221Ov1LGyhsYpVcYvw+n3oQsMW9qbqVX1vA8B/Zv8n+c9XHxoajkZy 6g9g9yn7cq8/L1vmIxx/amMWdrnugmFDVQon7MIcVZunSue6y3Nte6ShanEW5tzOef11WfiGEEIU tvaQjTxkkYUq0sc1+9hELqZmezhqCFzU8mPqfpIHLcLxDxsNOWo2N4laXKTjKh3v9rQkRiwSKQYt /HZ75azb/RW3yGLQwocr/B9m1RX3uu0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGydHwHYu4Oc BGIojONvkBhBWbomRtdsXHsFz+FZPICHcOkVPIGJuvAArkxMjCFBp4NMp298LUPUBJHB/480LUOn b4AogUU/Qi0AYLkW7Uxnj+/O2tlXC/X7e5Jl29GxzzALkaKo7lchFlKHWTgnkudFHXBRjssAi6aQ C53jnM6XOhyjCrf4DM34ibZvZN7m6+faV+93r/u7gRZ63IWxhlhor4ETeQitcHVARTW2ARZvdV+F W8RhFtU5Gmih4Ri2XrNe712en+/9+OL6XPaPD+yzmusLH8gR+gWBFhpMsSjQwjeZ1IEWdlze7Hka aOF7cVHdabipTDJ/P+oz817Z8Ap7TKR5e82m0ArdnjN9LF3DrmtrZ/H8vCfyeFS17qnI6FZk5+pO Li/vfKjFaDSS4XAog8Gg3hS9DK3I83wu2KJpbIMw0k3Vrbb9fQPAuklDhNL/v6Vut/qp52U8js+V BbsuNwRU+E2wTZBF2aKPHDtP+yUEWmxKCMSmhQK0qU6brnWd6mxyrVXXW2atTX6d/rLmf6ibZitq bR9oET7T59IiGkItyiALZ/qOGbvZWlthzU4IzPA1tUYItzjs9+VpMpGH19evLvtk1m4kDq/ohKeQ BloUEudyTM0xbWLG+uV0msyx8/Tx9GVsiqoEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODf+RCA vTvISRiIwjj+NKZh5QITEhcYVwZ3btx4GQ/gbdzJwkN4AXbGlTFewBMYEhcmaGntTPvkdZhCSIBQ 8v+RocPU8qY0GupiPkItAGCzDiL9u6L1Fx00HD5Jvz+QcnH62XgZMKHBFrPACQ2i0DCKWICFC7YI m93vjiuDLGZ1tKbdrqKtIQWqzfNn7tu3/nk3BVrYZIMw0CKrgiV0q8ETZbBFPZDCBlm48d9g/MeM 677UHJ9KPTCj+Y9Ep/Ml4/GH7z+83Uv34tSe1dx2WaCFC55Ic//sAyqaAi20v0qghXtfDbXwjzyL Bls4binQw+Jhx+fCLfRS2cCK2JKY9tLabJAwIMMu1bnofSXyuuqnxyLvN0XnWuTsVuT85VOeH0cy GokPtxgMBtLr9fw18AufZplfLH06ndZCLDTYwoZa2L4epwuv2wXP2/b7DQC7JAy2CJuGCn1PJv8/ 3/RlPhpGEQRc+K5IPeTCcXXs6zWc16btS41t1WnbuezTZ0Kt9tVad702z52au1PX8fdmVcCEhk3Y RAdNhTisgiw0rMI2Dbw4qvoabOH/E+H2FdvM38OXgRii9YrWTRI5SZKG2dVcFu2qaK92WhLJ34iM 61huxptiIcOWB1tr0R32snEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPbKnwDs3bFOwlAUgOFD RQeCIZHRgc3ETWZ9BhJ3H8Bn8VF4AJ/DkLi46W4khjBAi7a9Pe3pTSshELXwf6ZyU67c6oB0uT9R CwDYnbod6uz50/i4X/dCvd5Z/L14iy7CEi46sVq5cy5iIXnMIopEwnCVBy6SsY1X2LHOiSKdL3kc w8UtimjGtpq+iXmTr59r/327ue6fghbF4cIVWjmwQYskNBGasIXGLTROsfQOG7DQqEVYEbVYZq+/ LMUy6gRBslH2q0ynHzK6vZHRw530zvv2tyo95vGILGhhv2zQQkMUGrJI4hR+uCIZ53GLLGRRClpk UQuNY6SvHY81oFEVtLDxCt0EvFXz1p/HLfzghL8lpnjn7Vac/tab+vxRxfNVc/1wRsubfyzydumO k5HI1XP8+DiR8Xgi/X5fhsOhDAYD6XQ6pY3Sq8IWVWOdazde143W7d8RALC5uqBFcrTb7j7icz7f 7H3WxiyycfrzQeD+fZioRSvbyDo9Ldvv5LwvMYJ9WaNp6zTpWv/TOvu8VpPXO4TQw6GFJf5sXbd4 MTbn088MUlGL0IiFSB600ICFPmr8wgYwkqBFcl5vZSULJKafEeLxRbcr74uFvMxm6y77Oj6epByv CLLL9oMWmnvUOTYBqYeYsd6Mfnlz7Dx93v65/LtpIhYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA gIP0LQB796+TMBQFYPxgIAw6aIw4aXRgMSauTi6+homjcXf2QRh8CGc2Fzd5EJ1gIpbae+lpTy+F gH8grd+PNFwa21tAUBj6EbUAgL8TnjPOuU+Wo0Ub9XrPcnh46sfTqMR0/TQ0oWGLfKwhCo1RaLTC Li5moUELO9bFbZfv30Y0itc/VdVIgary8XPs6/e94y57sa0StIiC2ESUBSjyQEUYtRjLbNgiD1nk 23ymt8M5yjWbDRmNBn788Hgj53fXsr23Y+9VIWqRXYKghU9ZaNAiDVBojCKMVWjEwocs0vV2rAGM sqCFzuGDFvE0ZOHGInlsIzxu1Ugvbr1eZ/ezETynYcjCnk7Tnn5zXrRiK7it40nJdnZfdv44+NnE eF9kcJUMLkWOb0VOXj/k5akv/b74uEW325VOp5P8rZj43+koigrRinlxi0WBC12yQ6vYaxwANiFO TxLtzHs/1YDQ+3C4/I5L3oNtuMIGLWz0Yub2iuoSgahb7KBKj1mdHpN1zlPnudY932/OVefHaZNz /ud5Y3PbfkfR8IHGYu3BL0Gswi4TE7awY7dXd+0rE+77Sjd2/4vo95fJ+t1WSw7a7WWiFmfJcpEs b/awpKS/UbLeJiJtClKCcRi0CD8lh09a2SfqmYd8znoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AGrjSwD2zhinYRgKoD8VZOhSKSdAmZgqNiaOwMYhGLkFl+AE3ThJxcIBmJBYqm6Vmoi48U9+PmkL UikE3pMifzuufxK1brz4IbUAADgM23aps+1hN/fbfQNNJpkkyWmnrZVLqIBCosRCGplFUYis12Uj uAixl1fooX2KQvtLI8eo5RatNOM7GKqkQBny9XPtx8duPr2nZ89nS3POCy3KGBcxLjpii1pAYWUU VlZhZRbd2Isv6jFUilE0+XYJLdI0keWyFlrcP9zJ2c2lnKTta+c2oYWVSTRSiyrPRj2hQosopAil lVWsJMosTKx17aciCyu0CKXmU6GFSix2ySz65sfETPl9kotGcOGFE1ZK4aUX4s77rTglnrNbdm7b tlPk49fMbr0Zxqn+fl7O6yO9Frl4Fhk9zmU2m0uWZTKdTiXPcxmPx5vvtUoqVGRhYyu52CW30Hio v3EAgGOic6SfS7XN1l8Xi0Mk7Ja2vU9y8aWhhyNO+Okcx8oztHv5S8+EXMPLdeh8Q752cv6evD63 Xe558+7mnUFaC0Rji1CJRajHWAUWWh+ZWAUYZSxrUWU3T2jLqzXk22r1GbHFVXU8SVdeMYrDeaGF rpS1j19d621bf4dId1Xu++l5/xj940RiAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAD/incB2LtjnYShKADDh5hCWDUSGFyMAzo5OvpAvoSv4MjgQzg4M5i4GX0EXUlkR0vtKRw4vbSg iSDF/zNNbyncVhJIytCfqAUArEd4rzh1lS5Hy17U691Ju32cjSdRCZmOk9m2xSYsQmGLbhcFLDRs ES5+/ySSkZ/fju/X61D1G5hX+fw5981afc7hBy1x0QRfPbDQxWSxcT5sYRGLeBqmCAMVxTEL255H LT5dyMLmi2UezyjWbCYyHL5k45v7a+lcnvn/amFdFrTQmIX+aXhCxxai0ECFD1pk4QoZzSIWtu33 2fN17QMZFrTwMQsftMid4w++DC1uURS2yOasJeEL8sGKMHqhyqIVdjtPKdm3al47vs3j5hgdiDzr 7UQvRDqvIicP7/J425d+v5/FLbrdrrRardlNSuM4zm6oruuioEVZ3MLCLzpeeC8r9DkHgE2xcIVf LGhh6yiK5G0wkI/0Ozna2wsnKJ3XAhWJf05JtKKm3+FL5lt2/puwK8GDXXq/fus4VTrXbTrOLh9r 08ercsziL47538IS2xK0KNrnf5uo6XWYTC4DfTnCghUWq/DL2AUu/FhnjfVabzzOFSdU9ptmut6v 1+Ww0fhO1OI0Xc7T5cmflsyvin3QInzcX9n6q2gJxmHQIgxXhG9kUeRi4S0ueRwAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAgJ3wJQB7Z6+TMBQF4IN/BAZJHAwbiWFjdHDxFXwMEt/EF9CXIHF0dmU0 DL6CgwMzsVR7W057eimIEUpavq+53J9e7imXULgM90NqAQDwf1btGGfbz6N0/9tAnc5F9Ji/NVux RSKgkFREYcUWQRDmylZeYcuZCEP7SzpOIrdQwUV5+7BVUVJgqfL1c+3lUnzNmwottH2+KKvEQnPX HsR5JqNQWUVghBVFMossWalFMl6QSjMyeUYxrdaXTKfvcfnp9UEub/r2VS3lKo5w0gqtx4qJ73kq m3DiCRVauNzJKuJkxBXx4QQWrm7KKrLQ5+kYGsOJLVSgEZpD4lcZbuU+2DBfBb7cIp4HJ7jwt9Us klCI5Lfg1LfB36azYc6vEmEU9fVVTLb/qchHP0lndyLXk6jtZSKj0US63a4MBgPp9XrSbrfTDdVV cLFOblEkuPA3Z6/i5xwAYNcUSS00Kc1mU57HY3kcDpelFtlAxWXbZoUWtm7b/njtu6YuMeoWZ1sx 6jQnZcapc6yy41VZaHEIAo19xdx37LUyC1leAmo5/v0gmQUitUWoxMLVF2UVWGhd5Rcn0dotDEM5 dv9buvYoV7uEjePWdlfRmvFzNttEbHEbpTfJyyuOFsP5Qgtd0Wofq3i0K+qG6SeSX3H7/fS8P43+ dCKxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICD4UcA9s4mJ2EoCMADaUrcQkwg boghJu7kCB7HI+hJDKcw7l251jsYN6xkj6W1r2XKMLVEE0Rrvo+8zOubtvP4aaEs+iG1AADYP/4e cYGrvJ3s2mg2u5fh8LTol1IJWfezalllE6XYQioRRSmyKGUWKq9QmYUKLWxfm4ox7P61vo2Hou03 L2/z/Jn7YdnMuZZZ56xRwAst0rXIQqNKJ1ZGaKEyCi+vsGILK7dIzHbvToyxMrH5pBDHb7JYvMp4 PJTruxvpn43ss6pFlUYUsUFoEYQUQTxhxRQqqyhkFkFeYfq6bKUXdh/J+tEktLDzsvO1/Y5sv2l+ uQldT8UW1b41dDK/QV1EYaUXXZfzHxmftzkvzui69Wz9znZuORB5upTiFqOjF5HJ41webudFbjqd ymQykcFgIFEUVXIKL7BQscUuuYVKLUIspmMOljYd6wAAP4GVLnmZhS6H83BgmSRyFMdb+Zq0KWwT rjmMrKJYz51vqzHTOvl5OjP72XUB0SZxwm/XOFSdtj2X//SaUKt9tfZdr81zp+bfqfvd2l4cGL7/ 1fJgzREqrFjleZVYaEuN4CLNfwdEaVr2w5hIJcNQ40Sg+G8zj/38N8lxr/cVqcV53i7y9mynJRt1 oxVa+HEdy6SugfSaR98yFy2fXTHXXuKGcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AACA1vMhAHtnk9IwEAXg15ZAKYoLNwWhC3FdcN8zFNy79jBepVuvIfUAblyJK6FQ6G9qJpOXvgxJ qyja1O8r00yS13nTIUk7m/mQWgAAfI+qlePs8dOk3O1rqNM5Sd6Lj2UrtvACCslFFCqz0GJFFotF XNjX+jY+zraSt+PlFiq4+Nv111z+Oi9aXkfJglLnsa/fuG/ye9z32QottsWLK9RGYIUWbrnIlRFb qNxiWRBVFOUVy+x8KLvw8f7cKquHQotymk23KOaLTCbvMrwZyPD+Vs4uzu23LMghVB6hQgv7UqGF lVBUCS1cfS5GZpHtpyILE18QWiTfS9uPN16i4fqiW+2X7fNmx3qUKqjQ+mdpZK/0fjNt5GNWJbgI 5RYi4eXiCZft1Ng4OGcFFzauSnBhlwGNRF6vfImGItePIvOHsYxGY+l2u9Lv96XX60m73U5+X+L0 Gl8nPzpOXuG2ZZKLXYILh4ou6nevAwD8LKE0yO6r1CKKovBD5cKJQIqRx9pjWcxGymUX4p7TO57J xyIiqJsA4pjy1Kmvh5TnmHP9dj5kFoef8z/m/Urusmmf1tP/DrK1QOS2CJVYiORCC5VZtJzMIjm+ zoQWLT3u5vnuf0myVbtEw+Rxc7nLTkfeZjN5nk73dXuQlCcpyiuaWXOh0EJTaYyd8doZdMPEiRRn 2GGcng+HMRxOJBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8C/4EIC9M8hJGIgC 6EeBEDQxysIVxiUsSLyAcec5jDtP4AG8BfEULl27cmE8gkv2LEyAUjvT/vYzUCQRFch7zc9MO3T+ tE2blsU8pBYAAOslnBvOcZfE2bKd+v0nabc7vp5KJSSrx/m6yiZSsYXkIgoVWhSiiqmP8TjyoWIL K7dwoWIM27/mt+V/sQuTlm/rMWzruJXNH//8zVWIK7R9mdAilE1EmZQiMtIKFVqMsvpIrNyiEF9Y ocUk7yftU8UW09IjqdUqMhy++/r9w410b6/k4PjQHOmsHMKKI2ZkFm5RoUU8SUUUyeLqKrKwQotc ZBEILlRk4TUYmQzD9aFlpEuSy+Z3Y3KSCzvG8qv3/cNxJcFFXPxOxRYryy2y/Wem3wylE+G6Tvdp 1/dNvbKkz3BbkG/cEnm9FqleirQ/RM5fBvL8OPBtvV5POp2OtFotqVarXnChk66HIguNUHqhodId lVzMnJqNvd8BANaPiis09Llq21Rq8TkayVGzWdbR/Ev/IsGFllnkYoswSsb62+xKjl3Ls64cu3RO /jIPuTYz3zaPnZyblfsneUNRYMXLFiWXUKgVYk9lFUm7Si282CJ573DfdSq4iIzswgkt3D8KKsNQ u4SPOP3iPanX5bTRWEVq0U3iIok3OywpvmSt0CLcbtOH2sdQARlGHJSWRZKLuVNcsh0AAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYKv5EoC9s8dpGIYC8Cs/lehSialDB8TGkpWFUyAO wcgtuAQ36MBVEN1YGdmqCqlpaUliv+TFOKoAVUra75NcW4nt56aKG2fwh9QCAODvNO0gZ48Ps3S/ raPh8Dz7rE/JVmzhBBRSiihUZqFJRRXL5UbS1OVV2QktqvpalrIfJ7dQwUW79l1rv6BgO139Dl0d t9LO8cfuLyeNcON1ye0xvfbnNl40oUKLSmxRyShWvhzKKtJouS6+WNb6qcsymoUW/X5PZjMntHh8 epCLu2s56VfzWJPQQuURuVyilFpk8QqVhQotvJAiz0uhhRdXWIlFKbcw4ouY0EKFGVaeUcosCllI Tbnxi1/zZ10VVGi5oWG0nba1fZRNmgQXoXRCguPa7Dg4pl6IdeScHWPYZ2wM/vzqTOT9yqXTW5Hk NTv2PJXJZCqj0UiSJJHxeCyDwaC4L628IhRZWMmFCjC0rJKLHN3IvZ33OwDA7gjFFqHcIhcJ5Xym aby9z6P/elZkIWa6t3NsKLOIzL9dEiccQoyuxenSWA851r5LGromZyHm/sf9T2y7fAuNvMWzhFQW iNIW4UUWxbLRCC1UZqGiiy+b5+8x8+eSLFe7RM/Eyddul9ma8GOxkLf5fNuwb7L0InV5xZHvLhRa aCitYxWOdsXcM/VE6ivqsJ6eDy9jeDnb9TIVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAGAHfAvA3hkrJQwEAXSjjjO2SoGFOuPQaGVBYamf42f4C5Z0/oKFha21NrZ+AJ1jY6FAzF7Y sCwgFlEB33N2bpPjbpMo6FncQ2oBAFAfcU845aKIva8GdTo30mwepryUSsgwz6tjk02UYgupRBQm tDBRRa83SLlKLCzX1qI8PxJj+Pmtvm8XiVXYsHxZ72FZr9tYnOuPb6yRJcALLTR0k0jdezHL8kpu MS628AKKcUFFKaeYLrOw45HUojcc4+f0taaztTWQl5enlF/dXsru2bG7q3yi9UIL/2WCCRVZaG4i ChVUeKFFElfIeyWxsGPfZ6/X1sQYNm9qVWRR1J8ltBi4+/1KbDFLVDFPhlGNm/P5aq8zscW35RY2 t9+OM0oqbEvPdZevhX5xfdmcOX390PexI/JwLrJxKnLwLLJ/35W7627qa7fb0mq1pNFopJ91DduI 3aQWUWwRpRcW+v2zjdwnnuWfv+cBAH4OL7GIuf9cfH17iwPL3zTxD34vqIjnpgkrdAqTXugG1dZm M5VOtYJoYrXrLNO1LlKdVa712/XqrLXKz+kva/7HunXWjmLATNdVIpWEwqwQa05qoUKLfrF2M5FF klwMRRZ9l6vQQv+jYOPMLpEiL1e425ubslPENzgq4qSIR39ZMlrVeqFFPO/Le5WjhDwKLeIqNz70 aSviiUc84zwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNLyKQB7Z5DSMBAF0F9R kCIKglDoRjeupAjexSt4Fw/gGbyAJ3BbwZ3gzp0b68ZVbBrzk/nNz9hYqRUTea9MJ5OZzJ+k7cB0 MQ+pBQDAajTtIufP7+bpYllHe3v7+Xt9OvZii1JAIXMRhcksLKmkQtP7e5W0nCT1cim/yILgouqn lFuY4KL9+621R1CwOl29h66O2/jb8X9XaDEL5VQquUUa6tIgm5gWeSWjMFnF1AkrvMwicdKLJIgr KqlF2d809G0xmueCfj+RyeShOL66vZSDsyN3V5+FFiaLULmElQuVRRBaFFKLPL4JLTRXWUWRnLii eKnAQsvu2NqoxML3Yf3Oo2RpTagxy8pxmeAivofmT7KqX7Rtt9WblKJ2nDVLMRbRCy+91vc3j9Uk uIhFFCL+K1fl8bae1nYW1cXXLeozHkOon26LPJ2Uaetc5PROJLkZy/X1WAaDgYxGIxkOh/n3ql/8 NlVe8ZXcwsrWxo6trd/QvetzFgDAd4nnOZsjlefXV5HDQ6tYqe/MXxtLLiLxRTGWX15TILRoX4x1 xvlPz4RY3Yu17nhdHjsx2xN3nbH9ci028/aCmOqTLULXYLNyZb8ZpBVeZmGCi9Tn+n+mrtPy3OwS PRdH12rHOzvykiTy+Pa2bNgqtriXurxiI3QXCy0slLXJonNms+y5cyL1FbRfSfvVb/wY48fZ/j9V AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+wIcA7N2/TsJQFIDxA0owYTEYQ0yM A4MvwGhcfRdfxcEHYPcFHF2YnHwGFwfDhHFhgbb2tj3t6W0xNSGGwvcjDf0j3BYUUod+RC0AYDv8 a8E59/F0+duDptNnGY3SC8KnUQnJ5qN8WWMTadhC8hCFBi2CIMxjFW5+tQrz+TRgEZr4RVgJZBRj lu933T5crLytx9DW/Vb/v//1QYsiIqPXWNR1gaRxizBbH2bxiSCfL8coNF5RxCyKsIWNW6yzEIYG LmwYo1nQot//ksXiQwaDE3l8fZDh9YU5qvqgRfL5lYUj6oIWLkaxjm8apbBBiyRm4eIVZl6X/aCF Psdabxq0MDELt5zsR5Tuj978Y2j+zhbRik3bzIqKpoEL+3N/ilvouHq5Tadbs83/Vex62+02G87o eMv++N5lPldnIm93Ise3Ilfv8TSby8vTPLnw+mQykfF4LMPhMPnbdEEXDVW40IXGLGzkwq238Qs7 aeii8lq29HMLAHwa8LFBHz/u43wvl9sYrBq10M9YjVmI+z4iaLFLY7RtnDbt6y6Ns89jtXm8Qwg9 HFpYYh+CFnXPa/8/0omiUtEhqUS4czNJv+ODeLtb7pqQxZEXuNB5F7QIzOP1NDSZovSM9rTXk/N+ v0nU4iaeZvH0KUWsQiMWpf5GzXp/+LozYjGHbafIu7fqzoArL/GG9QAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAtNKPAOydO07DQBBAJxgKEpF0KAegpMkV6OgBCS7AUbgAh0jHPejoqWgRRRBCSsgH T7yDZzc/IiLA0XvWaL273h3biaw4xT6kFgAA67NoNTnf3srjetVEzaYu3r0XtXmxRSGeiCUUKqiw KEQVE/n4KEPrg0FcL+QXZdg8XmxRFZlFStUFC0pVr6Gq5238zvkvE1r4GIc2k1hYqctADiWWWRRt XlQRyytUVBHXyxiGvnKuWGgxnyyr5c+TR+n13uT88kROb67k4LDlriqWQ5jEwoQWfjOhhZdQpEKL fr75/S+ZRdJnYyKhxaSQWmgOlVdMy7BtUmgRf6rl2GWCCy+kSPe/gx1nY9cSXIxd3dKlX0Mlk9ml PSWMz+Ycnx7n+2250ESyMdwXeTouYv9C5PhhJO9399Lt3ku73ZZOpzMt6/V6tEi7F1iY2MKLLnyf jUsXeK/6cwsAwPDPNi+xMKGPlS+vr9+dsBRXWH3RMSFqeY7pY15zaehz9icXtfT0EE38xzxVEwBs W55tzvXb+TaZa5vv01/mJO8G55XZ1zjbn/6myMvdIKrS96csj1EQWIxD3ziRWZjgYuRL/T9A38vy 0uwSNZdH5z5qNOS5318lttAhZ3ncSiyv2Al9qdDCUtkxk6QtfTv2WsdUbOFv0zyRRXo7K/rvKgAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAaj4FYO/scRqGoQD8KkoXGKAMqANLmboh dUZi4hpIHICVA3CLHoADsPQAjEiIkSMwsIGEVEhC7OQlr24oVFCEy/dVll9+6udErVN38IfUAgDg +4RrwDnO8rI3702j0ZX0en0fW6lEltWSiaKo2EKmhBSFqCIt49THr69pFbu6iFVskVaCDNt+nb/Y H+tC36uwUHms1xBrv5Xl9L9pHcNFhBZWNuG234yIohZZFPGkPKYSi4kRW4RCC32vtv1mcjTTbrfk +fnOx+cXJzI4PZKN7U1zVbUcwsoiQqGFV1mo0KIUTzgphYu9pEImVa0SCy+yMNvVOaXQQmUYrg2t E31lyYxQw49zgdDiOzKLJhpFFdn0sXksKrjQeK7cwgomdNsu1xlKKsJtXR5UgmN2KVDbpgT57Dm2 TzkvuyI3x/nn7FBk/16kd/0g48uxF1MMh0Pp9/vS7Xb99zPNH2IqqkiSZEpm0SS4ULmF1iq6mLmX kY5dAPC/CYUWKvFx6BjoeHx6+qiBov6K2U7PDcdLFVsseRyNSc7wF/LEdi2rdE/IFV+un84Xc9/J +Xfy/mbuUPzXyuNWKbSorBBuTiXin/eJk1y43x1GZLEWCC40dkIL98+DyjB0iuhLVsxgt9bXZafT +UpXB3k5yMut1LIKlVhkMi20CPeH6Ztmx/4WNJQsqC3zZryf7QcAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAiI53Adg7m5yEgSgAP38CMSRoXJGwMjFxxcKdiccw3sG9t/AW7lh5EFa6 NfEGuoCwKpQ60/bR16EoJgQsfF/ymE7tzBu6mPhYzIfUAgDgbyw7Vc7eP3Xx8NtE7fa5+yxvw1Zs 4eUTKqHQ8IIKjUxUkchkUoTvR1G5n8kvitB5MrmFCi4SswYEBdumrt+hrutW1rf+qvMKZyZHEZlM YiaF3CI2rYotpmlbSCxUTFHILDKBhUotVHgxMc9aqcVUFqUZ1TSbIsNhJrR4en6Ui/ub4JtWCy1m bk7fermECiVUODEXWuRCCt+qrMJKLNK+GLmFEV9UCS1UmGHlGanIQpKNCS3Cd5NfVIoqrPxi2fUq 6HM6dkFwkQSCi+zhsrxCj+uU4L4OOwr6Oj4UXVTJLmTJWHu0p2unJyIf11mc3YlcvcUyfBlIvz+Q brcrvV5POp2OtFqtdIjKLTR+klvYa3vwu0bd9y4A2F90H6vq+72u0WjI52i0ykRFIaJ7o79n98Wg f5D350ILLw1a8z5aNznDtnPULU+d1vqf8uxyrk3nq7PMYhs5900ssetCC1uOaTab15d0JVuE+z8h zgUW/m/HubTCyixUcBHb1v++6Wsw16pdYm6MyGuxS1fjfUWRvI/Hvy371sWrlOUVh/l0odBCU+kz SXDPVq16T6RcIdtK2Va34WsMXycSCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY Sb4FYO+MdRIGwgD8iyaEVaKRmDDo5uLGrI/jY/gKjjyAD+Bg3J2cHFx8ARI3mCVt7bX81+OnBQwI Fr6PXO7vHb3/WpLCMdyH1AIAYDUOSuK7tJzOO6nff5JO5yKLc6mETOLEH6tsIhdbyJSQIhdVxJM4 zuLxOPaxq/OiYovYCzLC8TV/WCt13+S77vN31PUa6jpvZbX5270Li938q4UWcRCrZCIK5BOFyCIX VaisIpRYfM/0FVILPbcYKxRoVNFqxTIcfmTxw/O9dG6ugqtKZupQaBG+VDDhRBYuVhGFE1RUCS28 yML06ftdrWIMHTerncgizV8mtNBjew1/ivdaVIsqlpnHbwUXGifmwV4pt9C5htt3JiV94bFuByqm LyoZo2xMm1+KeHQu8paWo1uRy0+Rs9eBvDwOMjFFr9eTbrcr7XY7/U6LvaQiiqJKuYVt17ZQcDFz L2v6/AKA/UIlFlbWo88wJ7X4Go0WDeIXAqW7MFu5hWtK83mZRUn/OkA08T/zrCvHLt2TTebZ5Vyb zldnocU+CDS2lXPbubed1/oOQ9tDwwkq3HucrCL93eCkFY1AZHFoBBcaO6GFWyKqDEPtEllJ8tXw cfp75aTZXEZq4f6UuE7LuxSyCpVYJDIttLDtNr3GItMrVSu0sOIK+yHNW+EuagcAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqBU/ArB3xjgNw1AA/VCQWgaEkJg6wYLUDbFzCC7BXTgA V+AgDJ1hYGNGgqEzJGnJd/3jH9NCESBI9R76xHZsf6eDSxj8kFoAAKzOstPlfPteHRefTbS7u1// bm/BXmyh8gmTUFiowMLCZBVFkULrr6/tuh/jpRhzuYUJLj4+V03vd/lw764LFpSuPkNX1218ff2r Ci2msV5JkltUkkQTJp/Qci6myGUWRVNPUosiiivS2Pm40s1fLVhvYjAoZDK5D+Wrm0s5OD10T/Ve aDGNcgyVS1g9qCyi0CJILer8JrTQq8oqQjhxRfhRgYXWXdn6qMTCz2HzNllmVUuoMZ3N1/WXQot2 U2r8SHARhBRLyqsQ+s3SWD9Hk2uZ4CIXUUjWbsN6WV372jGh+RjJ+smCsf6Y0Hi/HIg8nMxj71zk +K6Sp+uxjMfjILYYjUYyHA6l3+83gguVW6i4oizLd4ILDZNfeMHFogPhu75/AcD6Y3vXsn1MQ/e5 x8lEinrv2+71PpswXWM57Ie+XZzQIkbYuv1e6SQZ33m232adZAdde5Z1+kzI1b1cP52vy2sn5//J +1e5m9cw/92t3+11eTNKKFq2iLq9igILvbcVpRVeZmGCi8pf9f+c+reKzivJj7gRc+u719HOjjy/ vKwitjir41ba8orNOF0utLBU1meWtbWWIu232VxsIe66SGTh32aRWAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAADAWvImAHv3r9IwFAVg/PinLXQRLIIFFesgrtIX8IV8AH0UH8BZnNyc HdxcXequToJUE3NvctKT25gGRWvq9yvX3oSamyyROuQjagEAX7dUMj9OxlbVL52dXUq/v+fnaVRC snmcb2tsIg1bSCFIkcYqomwe+fl4HOVz954OjV9EeSDDHl/Xt++fWYSHe3MN89PU81b1wi7lQYtJ NEafnaj7NGIRZfujLD6RBieKIQoNWkyHLKbDFhq9eDPHG8skZDE7aNFuP8rT04Ps7m7KycWprO/3 zVWVBy38/SoLR4RBizf3iv3PPEphgxY+ZuHiFWau22HQwh3Dze1xw5iF2/bnEafno6/wGn5UjSWq QhV1zrEycBFPf07DFrXjFnoc+zjPMFJht6uCFlFw7M+OGa5vruU5+ct6k4zVI5Gde5Ht65FcnY/8 A9uHw6EMBgPp9Xo+bqHhCg1c6LaGLXRu95c9GD7U1HsYgMUUBizKRqvVkrvRSF5eX2Wt27W/PPsL QHDP8/dADVrYz4Tjm9f005oWgFikdZp0rn9pnUVe67fXI2bx99f8j+vOc227biHsJ8WKQ16FcIEK SWNW78lnXbRi2YQsVoLAhc5d0ML9F0JjGFqX8LLgxXq7LRudTp2oxUEyDpNxK5NYhUYsYikGLcL9 dvnYzO0+e9l2xMG7VfWNdtZ+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa40MA9s4mpWEgCsDP IhQEUSko3bqRLjyBnqHoDVx6G2/hYboRVy4FN+5cpFCwv2Yy89o3Y9palJqU7wuvk8xk5iWFTjOb fEgtAAB+xrI3zNn64zzu1w3Uap3ln/H0a8UWTj6hEgoNJ7DQUFnFaLQIdzwcxse2j5VieLmFCi42 e59a3eUEDu7h/6jrdTtWX/sqoYWNaahTiYWW7vWO43Acyyh8WKmFCitUahHLLXz/USLF8DKLhdCi HP9+61fJsky6t9dy83Anh6dH5q5iIYJKLFRoYTcrtFAZhSsLOUWQWnzmm8ot3P5cZpG06fl2LJVk pEKLuVijRGixFZmFT7Th6YsOqwQXKqUo2/9p/r2wub52jHnXZYKLMhGFbZ8uaRNZL7tI+6VjJ23j A5G3Sx8nXZGL54m8P/ak1+sVYotOpyPtdluazWbxe1VxhY1UbmHry+QWGnWewwBgt9F5KS3dvObI BoNYavF9gFhyofOcGW+Wnm+imKp/KbVAaFHNPH+VY5e+k23mIVc189X52slZrdxVuOeyJVzx354/ FzSChCKyReT1kyCwcG37QVphZRYquJjYMsgrGm5c8c8N8yXmzK9Mz/NnlY/hUF76/XWXf5XHk8Ty ikYYLhVa6KpTz5kldXZVqnUi8Qo49Xxou5i6dPWKxAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAdo4vAdg7e5yGYSgAv0JbBpYKqawdmFgQ6gkYOAgjnIADcItegY2BlZUJcQHUIzBU LK2SYjtx+uykLa2EhMP3RU92/dMXR2oqZ8iH1AIAYD86DfU7E6ebJk0mTzIcjkqhRCiz0G2F3EJc aCFFIavIy3ru6otFXtVtWYSXX+SVIKOeMyx3oQ0v9m7LGlI8/5SvfXjuTT+eXYQWWSWcWJVeYKGl Fl5YUZdY6M8riYWWWnhRRlbmbqbX68hs9u7q9w83cnF7Lf3jI7WqUA5RHZHQwksmnNCiFE9YKYWV UTiphRSiCnt4iYUTWajP1ZhSaOHmmsN+ny8zf0RCi7y8zqkILerT14gq5GdraJq3bdxOcguR8BWd lm3SiqY+H7ovztXUJuH4z5HIq4nulcjZh/kDfpnK8+NU+v2+jMdjJ7kYDAaBoELLK3RpwwowbGnH rRNc1K5lgvcxAGgPXroT3698X7dbPPL5ms+bJruNwNo3LmuhhZZYRP2x4GLfdfw2bcmRWp6UzvU/ 52q7pCE1OQs525/3r+YORH4SWhwqK4TdK0khpcjMWCutOFAii8NIcOHrVmhhn0p4GUbu5RZl2Nwn Zh9n4wecm7g08SYrWYWXWCwlFFrE7b5N70qXUZteto5lVGo27WC3tQMAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAJMG3AOydy0rDQBRAb4u0i4IgXUiXgiBdunPhX4hf4l/4F278li51 K7h24a4UpOkjZpK5zc00aRUfdeo5cMm8MneSRcJs5iC1AADYTtNJc7a9L4XUYiP9/rGkabvSZsUW Tj6hEgoNJ7DQUFnFbFaGqydJtW7vsVKMQm6hgouvn6MWs5xAif0ZYl5/3GsvBBHVtS99X/Xk/mLs Ukq5xcJcF15AUYgt1uUUiS8nvi+UWljhxXwVpchibvLX0+m0ZDwuhBa3dzdycn1RfdYGocUym9dd nVxChRIqnFgJLbyQwgotrMQir4uRW3jhRZPQQoUZVp6RiywkjV5oUZ2qnGyT4MIKKfJymjbeU4eO 03k+JbhQR4s93jPsD6UVVoRhJRmhCMPOWXc0aMuMy+rzQ5Hn8yKOrkTOHhN5uR/JaDTKxRbD4VAG g4F0u93sP7jMwx367iQWehC8ii20rIIL7Q/lFhoxf8cAIH5C6Y6VXKigx/FWJ7Won7AsSrPsIv/+ 2fGh7MILMz6y/p9m36QAMeWJaa1/Kc8+5/rtfN+Za5/f0y5z/se8u8zdKLOQ9S1b/r934gkvoajY IrL2hRdYuL4DL62wMgsVXKzGuX43h9tbuf2YlFu7PNJiJ3ra68nrdCpPk8m2x7nM4kGq8oq2ny4U WujuUcekQZvdhWqbhEs0r6dl+sPXWLc7BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AADYC94FYO+McRIIogD6QSChWyONMcRWCxMTLmDjtTyDNbfAws7eysbKiiNQGkJc3Nnl7/wddheJ mjDkPTKZz8zu/JkNGoZiHlILAID96dTETmhx3nbTdPoko9E4jwuphGxilU1ou4otpCKkKGQV6SZO 83i1SsvY1UVR+UVaCjL82FLmt/VvOYZDvWNfQ8zzj2/u/g9HBRY69WahRWrir01shRYrI7VQWYWX WajgouhT0YW/zkotQlFG2xmKw2Eqi8V7Hj/OHuTi/sascr1VW6GFfalgwoksXKwiCieoaBJalCIL I7gIhRYqxtBx89qJLLL8dUILfR+uIWastKKtzwot2u5pIhRc7JRbOPQ4UD+ITqxdWtGt6dslwgjH DHNv4sWlyGtWenciVx8ipy9zeZ7Ns8/6UCaTiYzHY0mSZOvQdxVcWLGFjfW6OsHF1rOM5n8ZAMSM FeyE0h3t7/WKn3w+l8t9Bva1FtOuQouK2MKKLvaY/39zTLKD2NZyTM+EXPHl+ut8Mc+dnIeTN5bc FXGfVC0OpRXC7Y3E7RE72T59nUsrukZkcRIILjR29+j1ab5/99s6/W6R9PtyNhj8ZKrXWbnNypt4 WYVKLNZSFVqE7WHqblDb3WhY1kFtqZNcbD3ihnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAgIPnWwD2zh6nYRgKwA+WDkgI1AF1YSlSNzY2DsIJuA07J+AkHRgRC8xcABASiKZJsRO/ 5tkNbRn4cfm+yI3jJH4vkerKHfwhtQAAWM5nq77Z9j1Xzld11O8fuM942PULxalswssn0uIFFlpU VlEUbfHHk0l8bO+xUoxGbqHxvmf9tPzkBIvk/gw5559H7ul3R+UVTf5N6r6tCs9TSiu3KEN7KSqe aOqtkKKRWqQyi2J+3AovrNBCBRdlqE9NnGVCi4k8Pt7V9cvrC+kfH5qnWhRapOKIWmbhtyC0qKUW LrYKLfy+FlUEWYWKK95lhdBiVkRSC+3XbyrQiJQa9buV3xVa/ECopXKLNcb0rwouVG5hJRlRLnZ1 06bRrEYq8VKdW+Zcl7QiFV90yS60z2oh2XhZ0XD/dFfk/sTVXdk/ExndvsnD1VjGY5HhcCij0UgG g4H0ej33+1jNZRVdcgvdp+dSuYWWPMYyANgEPhNbWGmP5/n1dd0Om+HUjl9GbpGKLKTrujXz/m42 JUZucXLK9S/F2eRYOcf7D6KH/yaWyEEq8Vux0+lbuFG23NzGCyv8NCyyRbj2Mggs/DkvrqgSmYUK Lio/h5o1s0q93vepBom5MSJcc7SzI09FIXcvL6vSPnXlRmJ5xXboLhVaVGK8HKJ/3LRtWrf+DklT NK/HzoTT19g1GwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJ4PAdg7e9yEYSgA P34EC+qAhNROhaUSG0foeXqD9hycolMnph6gU7eOLJ0rIbEiksZOTF4eSUurQkn0fciyk9h+jiWi OIM/pBYAAD+jVVK+S9LVV43m80cZja53Aouw/7gWTBTlFlIQUqSyiigrR7682US7ssvTFOQXke8j FVnsx9T5MWjCht51v4c6j/98x14ltMh30k/lFeE4SCwiSfdHjDLhxNYLJ3IhhRZa7Iss0jwXXeTS iyCw2Kj+tDij+k/e769ktXqX8fhS7p8eZHiTP8J+I7TwyolMPBGkFFZooSUW+tgKLVwfrqz7DbGC yMId+3HE6XjCz97DSTjx9pT63vzW43H19SoOFVzoeqVyi1ZsGxTlFOGcmPNWWFFWr6xO2JLU9mPj i7qesBqLvCSpcysyfRO5eF7KYrGUwWAgs9lMJpOJL9uN4IO4QostgtzC5baebr83l2f3PAOAJlAm 1tHPG3fN8bFeH9SXf6exoopipYK8wrcx0gsJ4ouKGMemabKDOs1Zk+bklHGaHOvU8f4yVpPn6T9j ErcesQuiPilaHHZWCLcWklSEtU3qOllFW4ksXOom7yH+S0iyfupmAsGOqh/5bwz5Ei/OYg97PZ8O YJqkWZJeJZdVBIlFLEWhhT1vQ7dNrleqNsUmt3wntEB0AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAC15FMA9s4ep2EYCsCvVbcKuiFVHYtUroDY2DgAA2xs3ITDcI0ubGxIDAww0qWo Q/+LX5uXvpiUFgmhpHxfZNlxHD8nUq24gz+kFgAAm9m0+5uvb4R0u62jZlOFFtVMnW4QlxVZLBKR haQCC0smq5hM1knPx+Psub/HSzFWcguL93f7phVXTrA7ZX+GMo+/WGP/Tmjh09zVzVydlqeJ4GIq a7mFCSy81GLs6r+er+6fRFKMmZgsYxU3n2q1EuaDF+n3P+Ty6lwu7q7l4KjhniorhzCJhQkt/KGS CZVOqGDCZBSaL+UUidRiFA6TW2h5uBhmzq1s7a0PL8mIhRapWOMfCi2+hE83Gs3/jdi78EKKuLwL 1m55b4i5VXCRJ6jw23+KK8eyi03XYqGF5LSN63y8kM8ORZ5OQzmkxo3IycNAXu+70u12pd1uS6fT kVarJbVabbnhqskq8uQWeXme3MJSseYzANgH/De9l1lY2eYn5a3X29yRtv/J+iCaxyohTiq2+Pa2 8sgZihCnbM+yT++EWOWL9dvxyjx2YhYnbhljx8u1pKPld4IKK3RJlrFFhPpZIrDQazXNVWahuQot 5vO16ELbJ+Ira6/XbImXGiMWq5Xmcb0u76ORPA8G24Z9FtKjZOUV1aS7WGgxF+flEPvDZl1nZe/v kHiI7vX4le+214nEAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKz6cA7J0xTsMw FEB/aWGhakGwINEdWHoEJu6B2DgBB+AWHIOhnIEJFsbegAXEgqAJsRMnPx9DO7U1vGdZ/nWdfCdS orqDH1ILAIDF6UTiy6Ie/HbQzc2t7O+PfBwkFk2ct/r9xvFKcFEKLbJachHij4+sjl1b1iC/yLwY oxRZfM+p22XxFzbzTv0aUp7/aucee1jmCS2yKnZtKZrodDIlnggCi886boQVv0st2scEqUUQZcyq 3HF6vY68vT36+Or6XI4vTmV7t6+uqpFDaFmEFVoEyYQrQTzhpBRORuGlFlKKKlx5z9/rqj/XYyqh hT+2KO58oZ2FYoQWWXWfrdBiqTKLMuFqyXWoNjaPiCpi98aKKRYSXOTtcXPlFuWguHRCTL99nOy4 2Jgf5BVRwYW6BsfLoch9UbtnIkdPIv27qUwmUxkOhzIej2U0GslgMPAbsYbN4bXowm0UH5NbuLFa cqEFF5YU38cAsD5YiYWtAfcOen59jZ+k+C62MPAyniDlKTu+78asRRa6tdKLxOQMq86RWp6U5rpO ef5yrmXnS1lmsYqc/00skZpUYp3ytsR80rY41FaISlbhfjPMirHdILBwa6Ni7dRVggu3lupVbVeN z/z/DY1hIq9y72xuyt7W1iJTPSnquKgP0sgqgsQil7bQwvbb1Bum1StTW+2K1DJPaIHoAgAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACS40sA9s4ep2EYCsCvP5QBCYQ6oI5IqCdggIVb cAEGLsAtuAUDF+nOwAQDO2srtqZNsB07eTFJi4RoSfm+6jWOk/o5lmrJGfwhtQAAqKdpFzhdf2Ti dl1Dw+GJ+a5Ot25Ddi+b0BILK6PIZRbiJRZlWJFFkmQu7Pl8nlXOgwQjRNlmpvJtd7+0NosVAm1/ hjb3f/N9r/u/pKovZeRiiVRKucWyckxTK6QIdbGcYu7Lc38tllpo4cWiiFJksVD569nfF5nNcqHF /cOdnF5fRE9aL7RITbv2aOUSTmiRFaqJUmjhhRRaaOHkFeZTlJXUIggvmoQWOkcoO5GFZAgtvpE/ jEWTpGKd4KJRbvHFVdGp/DYWXGS5AUP/oGxHSyn0Vp6d6Lq+v7viWvxITSKNGgHG8lDk9dKUz0WO b0TGTzN5e5zIZGLK47GL0Wgk/X6/EFRowYUWWoSy26hViS1iuUWINs/HAPA30HOKnm90DAYDeZ9O JTFz016vt6qx6lHX64jr6s5V/36bXZMdtGnMdmlMNplnl3NtOl+bhRb/QaCxrZzbzt32Z46XZ75h 6Zi1i5VY2LcOFVuEqV96mYV7G6IFFmnq6rtBdmHv9/f1fFv2WljqFcaILF9Znh0cyDRJ5OXjY123 r0w8S1Ve0fXNxUKLVJSXQ8JLnLIulLW/Q+IuquGJVYyrhnPbbxIAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAH7EpwDs3T1OAkEYgOEP1MLEUJBQWGy0JIbGG9h4HA/hFSw5hiFyBgtp jA2XoEfYdWaXb/fbYfgpCLjkfchklr8dIHEDFvsStQCA/cROzf3iRrLtScPhu/R6d2XAQpsSNjBR 3ZcFgQs/pyZq4edU5vNlPhf36dD4RZqHMYqQxfqadj6lcziRd9PfQ5Nf/3Fee/iHUp0hf3PQohjF 9aWZF6v5t4xQFIEKjVRoxEKjFjZ0UT3ORi3q+11GXm/l+jqV2ew73377eJXbpwfzrrK12QYt7EUD Ez5k4bc1ROEDFRq0sNEKjVnsDFq4sdCL258GLfz6saCFXg/fw9Gc+hi65/r2c4mFKmzEIrZde96O Ne3+Y5GLrLVWxIhHJyS4XU8v2ja3xeIYYSgjEq+IBi7sbVcis3uRTzcunkX6PyI346mMRlPpdrsy GAwkSRLpdDpl0MLGLcKwhd0Ohw1crH2WDTwmAzidbTELG7UYTyb150lwaPfHHv/9Ruf4YvGIRSyG 0dqYSDqoc4odNO29nNNnwlrNW+vQ6zX5tbPm/1n3HNeuhfikXnEoqxCrWEXmvoukPmIhRbDC/5dC ty99wMLGLnwE0D/G7TuPW+S/8+sdQ792132H8WMPfTce3fiSKlahEYtM6kGL8PZw6XYw21+i4Qh/ gYZ2BS0IXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGuVPAPbOXbdtGAqg168pQNPABrp1yOAC HjJ1Sf6mW3+mez+h32GgQLeMDvILBZolCBBbj4oUr3RFWXEQwInlnCMQpEiRl/IgkR50kFoAALTp +hKcrT8t0vddA02nnyTPh40690E4lU00JRbi8zQtcxVVlOVSXrHZlAKL9TrzqRRd5KFfnawYo453 eN9J67NYQen7PfR5/vub+3OFFlk4t0KL1ORJEFskRlCRhPONEVhoWm+pi/uk1Xh1nKeEFmu5u1v5 8s8/P2R68dncVVtoEYsjvMzCHXlaySaceEKFFi73oopYZCGlwKJTaJFvKqmFl2SEcd2hAg2NrYIN 8Xf8zoUWL+QpwUXXb1hJKfLtUoyuPrZvLMnIy8FsB21oSimsdGIYtYvJBx1tsbAivlavG0p7zIL0 g8jNZVH4KnL2TeTL73+y+rWU5VJkPp/LYrGQ2Wwm4/G4+pC8E1gkSdKQWtg8LsdyC019fiYDwNtg 1/ix0MIxmUx8/vD4KB9PTrRT45mzC39tfdIWWLj2UD8onmt+Y7PHvUffBBDHFKdPcz2kOMcc67Xj IbM4/JjvMe5bxt6LzELaTkH/ji/e7U5i4XbnaoVwUoo8y8q6IKgYW4GFE124fY/bMwUBxiisK0Zh LNemW7PYGHFerF3+FmuY2/v7XdO+KtK1NOUVwzBULLTIxHg5pNYpap2Wrb9DtkzRej60fdfP2dN/ FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARP4LwN7Z5CQMRAH4idqVhERiXBnr TgyJN/Eerl14EU5hYsLSG3gBV2zdywX6Y6fMg9dhgJggoc33NZNOX9t57ZC0wOJ9SC0AAHYTK8H9 XLXrbSdNJm8yHN7UfZVYrPplI14XkS+aMoo8L5ZiC5VXqNRiFS9MrKjrxy5EFus57frY6EIR79IX B24rbf4M9jv3caHFquiz1jrUmOvnXl6hYovMx3LTVzlFKKywIovMbGs/M+fljbH1OjaRJD8yn3/L aHQrL++vMkivzF01hRYqi9gmtKiVE148oVKKmNCiIbfw25uEFnZczVX4xQotSrOE93AwjuH5uYdr 0HmLiSrsPiu02CbF2IQ9Lia5KE/0xSTrIguN29KhMWlFWGk13GdFGXYt5ngxY4QyjHOR+Z3IZ9VO n0Tuv0QuPmYync5kMBjIeDyWNE2l3+9X796ifg654q0xmYVrbl8otogJLtbmsoXPZQA4DDE5TtiS JKmPzYrir4M317G46de96lrKf35mdU12cIg8+8rRpTk5ZB5yHWe+Nl87OY8rd9fvuSHek6bFoef3 1cIK91+CyitkIaxw/1po/8wJLKzswv02csdU56kMQ60TpR/X5bisvscM/XeZHTxU7VEWYoueaerf sEKLML5MbWKhYtFOQejesOuQXUILRBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0Bp+BWDvjHEahqEA+lNlLCCkCiRGhFT1ACwMDGwcgAEkdm7CVbhIB0Y2YOAGDFSVKNCkxKl/+TZp I6QKSPteZdn5cfLtSnWbDn5ILQAAQubtCGfj20W5qrtRp7MnSRIus25TNpVNhBILKessm9YqrZi2 87KovEJFFtPjfNZnen0oxvjK14z90ZosVnA0ffyOps5hOeNeJLSwJTcxK7RQ2UTmZRSuPfbtDyOv mCe1+DD99JqxuUcW5JhHq5UUn/8nGQwGcnZ+IqfXF7Kxs2VmFcohYqGFfTnJhJNOOMGEk1Co0KKU U3ipxVvxUrnFaDIKjm1b+7ta5Rhax0KLmVijQmjx6zKL/8KSp10rt6jIZ6UUP5VbVIktylzJJL7g +/ahdrtQ2yeWXSw6Fx/HIo2qPGZo2abI/VHROBTZvRTZv32Rh5u+9Pt96fV60u12i+/9jqRpWm4w rwILtyapyCKu43Yst9DS1HUZAH4HXTfitUNxccfr+/uim1Tb7+y6UyO5SFZEaLFqQoVl5GnSWP9b rlWcU9PzrYvoYV1y/mXeVc8dP375pJJ4iUXuRRYzW4RKLLygIrUCizwv46XwwksvXHzi46VRwp33 ORMvtNBnoYN2W56L3zGPw2HdsI+LciehvKLlpxALLXIft4ILG9N2YmIi4ZNj7PnQ83Vv55r+qQEA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATedTAPbuJidhIAzA8OcPsCBsMCYkho2J CTFsPIIH8BK68gyewD2ncMXSS5i4MZzBpSExMdipnTLTfh1GUSNi8X2aSWtpGSCCwoKXqAUAfGwr sn2ZjYOPThqNbqTXO8y3fcSi3E4r+/MvkjfVGEWSmCJsMZulRczC71scPmphXMyiOqde10Hdv8C7 7rffqut9+P7t/mrQwrhtHbMwLkKRqBjFzAUp7M8+YvFaxCziUYvqufNt49aJmzuu0diS6fQ+3766 vpDj81NptlvqXlXjEH7x8YgiZuEiE3bx4Qkbo7BBizxqIfNQhV1e0pdi6J+LY1zIwp+ngxaJX4Kg hXGP858JWqz79XOF8+vHtAhVpIuXh0GL6HlL6ONikYs8cOG/IlSkGp0QtU+C/eHTNHZc+RRefj16 rnBfQ+TxaD52zkQGDyLt24mMxxPpdrsyHA6l3+9Lp9PJ/h6b/LXIfplrLGZhh49f6LBFLHBReRxr 9roMYLV0yCI2bGzHenp+lv7e3meucPllPrpj1zaaoYMWev1Db0A2LUBQp3nqdFv/0jybPNdvz/eT c23y47TOOf/jvOuce12/V/6zlm03f/HZi7hyhItcGB+vECmDFjKPXezagIUPAGbbr1JGMOz/EeFb t9TFLbrNpuy3Wp+JWgyycZKNOymDFjpaoYMW78UsUnVsmFv0dzkcabAOLQtaELoAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAANTCmwDsnbFOAkEQQOfU0FBoiYXRWPAFVMZ/sPUT7P0L/0I/hV4t9SMM BXQo4M3dze3sChwmGDx9j2xmnYOZlYQlR7EPqQUAQGDVyXA+f5SPm6ZCvd6pZFm8xRYHtFeyiVhi IZWQoowmqijn82KY0EKjjSCyCDW0tuW8NKOttFWsYLR9/Upb/4fN173s8zF3NcIoxRJzCXKLWRJV TmGCi49IUqHyijIXyyxsBKmFF2BYHYtzWSe06HQyGY9LocXd/a2cXA3koBP2oSahhcolCqHFolZN BKHF4j0SU6ioopBX5I967v424YVFraOvt+h72LwQWVRiDYQWu+nvpRWrrqWksotNsOd9EVuYhEkn y5RS/iPpjw8VN08lFf6aHV0qyfPW1cmSnGN2KPJ6kU8GIsfXImePI3l6GMpwKIXcot/vF6ILPVDe yy10blILL7vQaNdWyS1s1G9Ny/ZmAPhZ0v3B7xlv4/F3CoVow+Wz6uBpi+l1hBa767HNPn/pPaFX +3ptu1+b107P39P3v/VOb5Pq7//8O17FFfpLRWSLsFwlqthP5RYmvHD5RZ6f6X1PHgsDhYoxrJ/1 zHPn3a6MplN5mUyaln2Zj2eJ5RV7VblUaOFlFssEF9FSJL6bTMUW4mKTuAKJBQAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0kk8B2DtjnIZhKIB+JIpQJ4TUgaHMgEQlbsDKUTgGV0Cc goGRhTMwIPUOrIiBgbYx+U5/8uO2ASQENX2vsr79ndhOpEZNBz+kFgAAq1m2pfZlWQ66Trq5uZXB 4DDWTSzR1EMrr+224EJjUYstJpNQyywst1iK+lwt7bFtzrw3vc5VrGDkvn4l12voXne6h2Cza/1q oUVVqvbMxek8ehnFu7SlFo3EohFbTF3+3Y0zdfVZjF17Hu7uzuTlZRzr1/dXcnB+4q4qLMRiLsdQ oYV9olgiVFFFFiqbMBGFiilMaKHyCpNV1DILzSV9Gk2EoWVqn3I8E1rYfKnQwtrpNfw6f73N5F/M H9r3u0twkQotviu3aB0blkguNL1Vmy4WBRM+J+K/wu1jLJcKLdL+rnG6+nsiz8dV6V2InD6V8WEs d3fjKLUYjUYyHA6l3+/XG8yb4GKZ2EL7UrGFCS+83KJ1HzN7NgPAz2HPhGUSHEXbyuvb25fGWinE m8stapGFjpsIL2JfZpvQ5yaa+I15clrrOs3zn+fKeb5NED1smlhik6QS6zK3or8nCvt/RWTB5BDN ESqr0Pd5k1eIE1pIJbvYVuGF5sp3nlifH1f4c8W9qoUQx9/f2ZG9Xu8rSz0qy1lZHqURWnhphRda rJJZBHdsSHLpLfBvqT6mfCa0QHQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGvP hwDsnb1OwzAQgI/SpUOnDjCBWJC68ABILLwfOwMPwwZMDAxITDwAUKliSvNDzrHpxU3ToiKqlO+r rLPT1Ge7UhJl8IfUAgCgYtnucPb4SCqpRSuHh8dS7Yk2RzdhC7KJusRCXMyyKgZRRVXPXQlCC42h BJGF7UP7DnKLKqeVaHRTSBDT9Xl0ffxKV+ewOO51hRa5b1uhRWZi6sUWqRdRzLyMIpW6wGJWHktq 8oogvZifm5rfZiZmrXMbDBKZTJ5d/fr+SkZnR2ZWzUILK44IQguVWISPiieC0EKjE1XEIgupBBa2 XhNaFLNvqUUQWmiOEK1Mw42j8KINhBbby9+Qs01Usc5/s67gIpzXJLZwufaK+AfzMceCi3i70Dxq x2IMK6jIW/qJ84R+DbPySeHpsqxciBy8ipw8fMjdza3cJiLj8dgVFV30+/3yfp27ohvEpmnqxBVN koue3/TVSi7s5vULa9mx6zMAbIYVWDRFvY4ob9PpTzueR3tdWdY2OTe9he2a7KBLco5dWpO/zLPL uf4632/m2uV12mZO8v6f3ErP3Ne/R6LPHkXhvtO3FTVbRDimworynP1YbhGEFyrJ8G2VWWT+uDNQ uPcVxhjhpVunw6G8J4m8fH6uGvZ5WR6lLq/o+e5ioYWVWTQJLmpDkboqMRZb2GVaJa5AYgEAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAneNLAPbOJqVhIArAT6WtdCVSFxbElUIFkR7C y7gSvErvILjo0ptID+DKjcVNF9Z27Ezymjdj+oMUbfT7yiMzk8m8SaCBbN6H1AIAoJydkvbNLI6X XdTrPUirdRLaKrEo2i4aD0XlI8GFP07nYovx2M1lFjr2Nabza33YtW1upapCgpSq30fV9++p6j2o sCLedzbmXFrZXsd8e5LLK1Rs8ZGPTUxbhRaxzELlFf6YiSrepZBYxFKLbJ1i7VVCi3r9VYbDZ+l0 TuX2/k4Oz4tXVCq0UFmECi20b4UWQT3hMgFFEFPkUopUaBHJLfL+IqGFXVdzlQktnPml9/Dj/HZp yS0RWsSniwnLBBdWRpG2181t56ZyizBdBRepyCKVTni0XKnOtyIKW0ZUz2kZ07Ryayq/KJNo2G3W RF7Osti/Frl8mi39OJB+fxCkFt1uV9rttjSbzXlBehVXLBJb6FHD91WKoWtowdew9Yq9nwHge9j/ v8pu0r7nbTRatMB6Y5K/8lSikYez8zcgtvhLsoOq3ctfeibkql6uTeer8t7JuT15/3PusvzRt4YJ 7QdzRC6pmKq8QozQQjLZRc0LL/LY05idm9prxXziORfWP6jV5KjRWEdqcTGLK8nEFrsmIv+GxHKL VGbhzFyXjKWPwH4Z2mPKKqEFogsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Go+ BWDvjHEahqEA+hO6lQGkVggWJLr2CoxwB8TAykm4AqfhBiyIASFxBNShHYCqbYid/PbbSSkdaAm8 F1lObOfbblW3zeCH1AIAoH6jsbh8L0/XqwJ1OkeSJOHSqoIJl0KJhfh8Oi1yFVUU5zOfVGjhck0q srAxXGyVWxR9itmgv8pf2fC66fNo+vgdzZuDfkZ03EWZyi4WaWbKrNBiIZsopBTufDIXVBSSinqp RbVcy6bluRVaFH0tI02TfD14luHwTS6vzuXs5kLa+7tmlqEcok5oMRdLZKHMwh0qsnBiCpd/5IfP VWRRXts6297l83hlHgstdEx1QoutySyKzrfLLxRaVJsvF1V8570L7vuiubazYotAepJk8Q2LmPEW pNp0J6q3W47GcgyNNYvqlTS6TqJ7S94PRB7zJKcihy8ix/cDubu983X9fl96vZ50u11ptVpeUqGi islk4sUVy+QWrp1be9213cheN7APXprGrNEAsA762VbZTZ3cQuteh8O1Y2c2z2Nk8Vpir43oYpkU 47vz+UmaJprYRD9NGutv6ucv97Xp/poss9hGn/9NLPEfpRLb/u1ekVlI1fnnvuuTLPPiCvfkIrBF aJkTV+RtVFrRKv/DqMwitVKLvN20LPMGCv/swhgjSqHGSbstg/FYnkajVdPI/33Jg4TyirQMFwst rMyiTnARDEVCbWIstrAv0ypxBRILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgU nwKwd/Y4CQRRAH5EFw12hphAayy0wStYeBHtvYAnsOcUdjQew1jgGaysKIHFmWXf7NtlBIKG3+/b vOzM7sw8ZsmSDMV8SC0AAGapRcpPLi7mdep2X6XVuszKKrEoypPS9Wxj+ZLgwp/TILYYDidBZqHX ZiMNfX3YsW3ueeyekCDOrs9j1z+/Z/vnEHsZJvn7Mglyi7LQIs3LVmaRGvGEP6vMYpTXC4nFfKmF th2ZcQphxjR3nCSpyWDwkZWfXx7l5uFO6mcndlYlAYAeKo8IMotcMuEPFU94GYUXWmRSC5mKKvwR ZBYubD20yUUW2s8KLcZ6VIQWaf6cEVpsmD/M2X5X8wQXVkphy/4U6xfDtiuNoblqxZilIe02o1qP SSuKwWfvHVX62Ha2bWxrUtsnEfm6nsbpvcjVpxv6rS+9Xl+azaZ0Oh1pt9vSaDTCpvR+09fxeBw2 pY8JLqr3VYphN7ff/t9oAFgV+67HwpMkiXwv3vx5VkaR11VsEe4beUX03gpzWAf7lOe/cuzTM1ln nn3Ote58uyy0OASBxqZybjr3Ic552fyltYUJrWfmiFxSkaq4wl1L/DrFrVtUYnHsxRd+vWPFFq5d avuKWb75/23c+bxez2IJ3KpLbl28SyG0sNIKK7T4TWZRVSVWlYlVoYVVJlZXpsoioQWiCwAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYWn4EYO/scRIIogD8IJQ0UmEjjaGhtjLxDt7C E3gKj2DrMahtTeyMla1UhELEBWd25+2+HVmWKCGsfB+ZzOz8vVmSnbAU8yG1AIBjp+q0Nlt/4tJN 3UT9/kCyM9AKVDDhU1liIWmeJFmuooqsvEyTCi18rklFFnYOP7fKLbKYhWBgW/7LYddNv4+mr99z mPew7nnITrHP1rvK8+IMQ5VbJCZXkYXKJ74iecUi1KnU4jNqK4QWhdQiCW0qy1jKJqGFP7txOs2E FncPtzK4vojudLPQwsslUqHFKldNFEKL1aIkpvCiilRe4T552Vyr8EJzP4+O9/PZGFpORRZBrKFC i6W536MXWux7DTuMZ6UVVW1x7Fh2sQ3aT8dWyi2KAXm8kuDCHkVqpRX2CNJ1bXabaEV943mr6hwf fZFnl+RK5PRV5OxxIuP7cdo2Go1kOBxKr9eTTqeTCypUXBFLLbSs176v5nZsuhyzNx/WPg0Af8VK LOJn3e8lb5OJLNzLhz9UumKC7EVChRWy/lTlHxILv8+4tArl36x7HzRJNLGvOP/pOyFW82LtOl6T 107Mw4l7zLHr4sevPWGAtNxvBy+u8P+QlGwRWhd+Nyxdv1xeYVLbXrs+SahLDRRebiHGGBGEGufd rrzP5/Iym9Xd0qVLT1KWV7TDdLHQwsos1gkuSksJdSLlt8zY8aHtdV/nIfwbAQAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQy7cA7J0xTsMwFEAdQUXLAkNZKrGxAEOvwMxZuARXQJyC BbFwA2YWKnEDViYkVJLgn/o736YUKiRIy3vV17dN7J+qShQz5CG1AABIKea0z3zsLZp0eXnlhsP9 pq0Si7ZdJ+PSTwUXkqsotphO6yiz0LGPUcW5EnZtW3tZuikkWB75Hqv8Hdbhd+jOd8gvhPbt8qnI QiUWM6lEUdShXYb8ZsQW09C2QouZzCIdU7HFmxnXfmnkFmVce9G7DPv90j0/PzTti9tzNzo5TgQW eVZZhAgt9NOIJepZVvGEiChESKGCCumLvEJlFVFmIWOhb4UWcrxklWM0H99WoYXWi2dRh/MKgov2 l/nn73FcYaFFumy78KeCizlCi2XlFnqszrVrxFSYfi6zsK8btbcBQT0rhTk2F1psZHPytfJ2kY0r PeeeDmfRP3XuYOLHbibu+nrinyuGbjweu9Fo5AaDQSKoKMvyg9zC5vzvVVXF+RrduU8DwE+x13Z+ rUv0ej139/joXl5f3c72djJvngyvuWUZuUUUXdh+egLzj1mwIVk1AcQ61Vmlc+1SnXWu9dv1kFl0 v+Z/rPuXtf/6eXzZ+slewoT2G3OESLV8rsNeRKQVm7JPMXKLTRFf+Kis2MLPqYLgogpyi7gVk//1 +bzrn2v2tra+I7U48jH2ce9aoYWVVlihxWcyCy1v5+Q7vTzqLOd8JbRAdAEAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAneRdAPbOICdhIAqgX2BDwsLgQhKNLnDNAVx4Hi/j3qUXYa1b ExNj4hGMLNgQaIudaX+ZTlsKiUqB98j4h870/6EJQlnMQ2oBAMdM1a5t7vHTuN3XJRoMruO/ndy+ rSqYMC0vsRAbwzCJKqpI+pFtKrQwUZuKLNwcJrfKLZKaUrox7bYcwkbXvIZmsNvXsKnQIrJRhRZW txCFWT8RWmgMMolF8jwvsRCZ5+QVSVw4cwPn3FBcWcY6ut2ZTCYftv/48iBno6taoYUV6KTiCBVa GImFPox4QoUWKqYoiCwkEVi4/ZzQYrmw55qoQgtTQ6Mr07DraKrQYtfbRR6I0KJYpkRUscyPrWNT wYXOs2IL89nr5c7kFqsTVmspE160vHF/qe2Ssagkl0g+r6w5FjMbiLydx+lvRS4+RS6fv2T8NLZj o9FIhsOh9Pt96XQ62ab1Kq/wxRau3ML0zVyNrhyjcC33+PMG4FipElnoMYN5/xsWQaAnVQonCv8H XFGF/9w5bje4Lpu/SY0/4pDq/FaNQ7om/1mHWs2st89rp2Zz6h5z7W3r+7c5aQI5ib9TGImF+VVD b5U0hulYOxVVZPKKqhbPMaKLViq0aNnfNRxjRCrUuOn15Hs+l/fptG7Zd3F7lby8opWm84UWrszC F1yUNffO0R9zL1OduAKJBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsBT8CsHf2 OA3DUAB+RS2gDgghlUodEEslhi69CCdhgLv0CiwsiIswIHEEWBgYkVq1IXbynGeTtggQ/fu+ynL+ 7Oe0ShpneB9SCwCAikbN8nVeThc1Go3upNM5C3lhNYm/FUyo3MInmY8EF66eBbHFZJIFmYVu+1pm oa0rtu9qDH/zhSBVWA84hx9FrFnPjPSlkllUQotpJLYo5BNaT8v9KrSIZRYqr3B1IaoYSyWxiKUW RT9aLxZauK+r2XyT9/dXGQ77cnV7I0fnHXNWsdBCZREqtNB1K7Tw6omsEFB4MUUppfDyCiOxiOQW 5fo8oYXtV2PVCS0y80nPYWWsOnXkquP/A+E3zupFFVZ+MW/5u/hk7qXcwvYRYjWqsXyRWdj0o6n3 JgQwx1qhRSrC0GPTbel+u71keijyMijKwaVI/zkP8fAk9/dP0u12ZTAYSK/Xk3a7nT8HzELyehVc WLmFrVVwoRIM1zZNhL8N/zcAu4Zer6ncwqHXe6vV8usf4/GyzuKJRHIviDIuq7zCCC78fWSJ1GKT BBDbFGeTxrpusbbxnDY93q6IHnYl5irj7nLs38aP5g6mOPZK0ZU3Q+TL/g1LKa1ounmJkVs0nQwj FVvo8e69Rim3CNMzP88TOc6fbU72978z1Iu8DPPyKJXQwkorrNCiTmZhw9s26cwuLVlSpywTWiC6 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC141MA9s4gJ2EgCqCfwhJjiEQTEld4 AbZuXXgCV25cegwv4zFceQA3JsZ4AjZuiCEmQO20M+XP0AKJYkt5j0xmmLbzhwbITBf/IbUAgEOl LHOb7j9Jyv2mgfr9gcRx2+vTkomlvMLU2fv5PKudqCJrL9LihBamdsWJLPQYemwdcxc0Ick1n6Ee pAkIdz7/dUILP1P9sk8LLZayCS2hyNpOUlEstVjtd31z2w6FFgspI4paye//XabTqdzeXcvVw40c nR6rT+XLIYqEFrlYIvZlFublRBZGTKGlFbnIIhBcpEILe76r8/FsHQotcrFGrHUWvoijUqqeQhXx K3eIlIsqtvlObCu4yJO8W8FFqdxiObAvmHCpSF1q01BKoVOUhkILLbsI5Rk6VtFflRZhJHyfibwm pX0pMvgQOX8ey9PjOD02Go1kOBxKr9fLk9mbMpvN1sotXNtc42qXCN/U+v6FbQCoH+H6UItqHJ1O 9ujnq0Rq0couLN5LKGnFSl1U9DneMM0SEOxTnH2aa53iNDnWf8f7y1hNvk9VxjzEuFXGrnp9/SuZ haw6/FKxlRFVGHGeNe+m2yQrrzASi8gJK5TQorQk5xjRRWSFFlH6jEMZI+ya5aLblc9kbfM2mWya drKbkhfx5RWRHS4UWmiZRSi4KCp6Nxge07dpk7gCiQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAA1J4fAdg7g5yEgSiAfgyIwY0LE8LaGBOD8QSewr1b4yW8gTtOYdh4Etx4BU9AYhDa ym9n2s9QQBMQCu81P52ZTvvbhhaGxTykFgAAGbWS8pNkYouF9Hqv0ulciJ//1U8E6+Zwm6mrfMJH IbqIc7HFeJzkMgvfNh9xvq+GzVOcwxrvSsC+SBUUrmF7bO78yz78q4QWsStnMousrOuJE1EUIou/ Sy0mrm6FGIUwY5nQol6vyXD4npafXx7l6uFOjk+b5qpm5RB+iZNMbJHLLJxkQhcvnlAZhQotUqmF l1WIkVk4iUVYTveRYj8rtIj8gtBit/Nv85qTsFo0LBNcpFKKBeXfkk7u7uQW9hh5rkWCCzt1aZnU Ipx+1Pbz06JKSd+wLXwVWLmFq0cnIp83WTTvRS4/RL7fBtLvD6Tdbku3253+HulIq9XK5RRRFC2U W+g2XcdxnIsuNHzdTopf9e8cgEPAimns8+tDn3flazSa2zd9tsMBhBVUlLWF28veD77PvwjNfMrN 56natezTPSFX9XKtO1+Vz52cu5P3kHOvO78dK6iAwg5raq4tNUO4bbGTVtR1rGLkFnUVX4RiC99f hRbuOPkwLB3XiZw1GnLebIqsllpcT+N2Gvony5EJL62wQosymYVN763GZaPCMJJgHbJKaIHoAgAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2ih8B2DuDnISBKIB+CmHjioTEhEhCPEM3 bryCR3HhLbyFC4/hyhOYuDJegKWEEAzS2mnn09+hWBdGoLxHfmbamf7fkqZpN/OQWgDAKbJrBTe7 f5zFbVOi4XAkadqt7LOSiSSRQGJRhooqin6ShwotXKuhIosih+Sty605bc3/og0LXHMN++dvz7/u /k9MnVBokQT9UjZRCCiSQGixMtKKrx0SC7utIouVF1msTM5EfhJa9Psis1khtLh/uJPxTSy9fvnK 1iS0cHKJXGiRblQTpdAiEFM4oUUur8h+m77ZVuGFti6PHu/y2Rraz0UWXqyB0OKA6h+Q0GJ7eLeo ovF+SX//DNF5KrholFvo0qWVJLK9fKnd1vFQaGEFFjqvI9vijLCeXf7Uj32ei7xm0b0SGb2LXDxP 5elxmo/FcSyTyUQGg8FmgXsnqtB+neDCtrr4vV0c37W7/ksA2D91Egsbjl6veI/4WCzCgxuNePnj ycoswuOD6GTPjLQypT1ShWOqc0znekh12lzrmOudgujh1MQSpyqVaEtta1pw4orNp1D2ThGZOvln kZdXrP1Y14sqKgILH5Hdzuas/b7I57GfTirUuDw7k+lyKW/zedNpX2fxIlV5ReTT1QktOlIvuNAL tPIK+/UXii3EtE3iCiQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHDQfAvA3tnj NAxDAfghtaJ0YqRZGaBCDNyAO3AiroBYuAMDYuAUFWLgDDDCwlI1DXmJn+O6TcpvS8P3RVbs1PZL G6WNO7wPqQUAwKzMwuqXedltGnR1dSuDwb7PA2sJ+kvBxGxb5RMmoijL1IksMiexyLzMwo7Nl6kX Wdh8oUDDYq2STZcqKLyH9fP981+UBd7uvzqhxVRmhRa6n0Rii0kgqIgFFuNAZDF248LXJn6eql7O 3ZSjsNdL5fX1sahf3J1Lcno0J4OoE1rYVoglsnJv4gkVUaiQwgQV2lZ5hckqvMxCj7l2KLTQ/ro3 OUax5XUTWlg8fxZZKe0wwUV1Zf5AfsZ1nwJCi4auVecmwUUhpdB6VgkqiuOf+A4pkr27sX6+OFb8 dBCKK2IJRV07TEtqaVJFqrSodfKLWHARyi1cO90ReTouy/aZyMGDyNvNSK6vR5IkiQyHw/w5ZSD9 ft/LKdI0XSq3UAmG1q1YO0ySv+m/OwBto0lqYfev8vzyEg76arBmuYVrb1n7lxcobZIqbJoAoG1x 2hxr1fF+NHl+iz+ndcYk7v+J/ZvxbV6/NpD5JZRJKVRUUfwL46QVHV2bBHKLjoovtE8otrD+KrRw 8/hlU7GOE9ntdmWv1/uI1OIwLyd5uZdKaBFKK6xu8opYZhGGN7txvIqLhRbxqnDRhVgmtEB0AQAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/hncB2Dt7nYShKACfwkLCQIKJgzGG+ABO jMbRQZ/N3WfwHXR2M3ExJs4sxoSERQK09t72tIcrBWJEKXwfubm39+8UEkrLcD6kFgCwb1RlcrP9 12m5WrVRp9OVJGnO9VnJRBxnMgsVUdjaFRVVTCazvI4LsYUWFVlkazMphsox3F425n/ik8nVPLH1 LiTorvt7+Nn5ryu0iH09L7SYmVqlE1MjoiiFFqXUopRZzPdr266fmj1VaFFNq/Upw+Grb98+3sjB 2clSoYUXRiRJIY5QoYWTWOjLiSeckGKSnpsTUXhRRSiykExgEbbdHLfOF7OHijK0tjINFWyIILTY GmoitPi+tBRYLBxbtLfpW/c6ovNUcBHunURBoDClqIapklLYFKZVQgtNk7pKlCFmvY2bMj4Ueb4U aV6IHL2JHD8M5P5u4Mf6/b70ej3pdrv+WEUVmux+meBCk+G7tk2O7+qqzxIA/odQYqHFod/Zj9Fo 3c2WSy/02pnPS0yfF1q4eNq/QeokmvirOLv0mRCrfrF+O16dz52Y2xN3n2NvMn7D/M4XEdw9QPpM pWOFLSKXV8zysWYuqijkFVUlneNEFyrGaPj/P4wxIpdnnbbb8j4ey8vq+5zztDxJKa9QsUUU9Omp R8GxDS+mrfPErIsWzNXxEPuUicQCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALaW LwHYu5uchKEogMKXRMCJxgkDSIhGJyVx4thluBUTF8IuDCYuhBj3YKIzglNii/Tntrfl1RITKIXz mYZW4b12gpTBO0QtABy7lmP/vupF4/Gz9Ps3oi0JXYw/Dkzkj8P4hIYobNDC94N0PwxYLBZBErpw bUEastDxbEBD56pT04MK6hCuo+nXsPn5u4MWWeQli1lkQQvfhC00ZBHkIhRZ0MIdrrBhi/XwhQYt fPNYHbTodGYyn3/IaHQpjy9Pcn7VM1eVD1poLEKDFnpsgxZRemL5k4YsNEoRBSsK4Yo0bpEca/Qi ep0JWthxdS5X0GJpforXUKs9OIWdn0NDgxb5YbKBSgMXyd9y+/94H4wWgF/G49jx0rnKAhd22dK/ ohR2eVIbtLDLn+rz9NgVyhBz3Mo/+qcin7fxdvYgcv0u8v06lclkKsPhUDzPk8FgIN1uN1383vf9 yrhFGMEI93XTY7twftP/9wBN5opZ2E2jFl+zWdkA8WPZDYUJVtigxdqzbdBii+8FTQtN7GKeJp3r Ps1zyHPter4mxyzqmPPYwhLHGJWo+zPxtuZ3jZu7FzBbWoVIohRhqCL6NiaJVpyE9yImbnEShi+K YQt9fvj9RzJO+vkj+d1Fuy291f3NBlELb7XdrbY3yYIWNlqh+xqvKMYsdHptdois37UVgxaFOzZn bLkqaEHoAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwF34FYO+MdRIGwgD8IwkLLrKhMRLfgNXJ xNHVB3DR1/B9fAUHH8E4EkcG40aQRFKhZ1vub6+X0moCAuX7yOXo3fH/dwxtb7kPqQUA7BPLTnRz 20+jclcVqNs9E2OauTZXMhGGC5mFiijcWkUWKrOIy0JyYSQI5tH13LaF6fg4XlyrHCOO5ebcJupy qHUd1rHrayiff5nQwi2h01YktHDlE99WauHLKgJ7Hdg2X2qhYzMxRlbPbb5i4rXNZgMZj7/k9v5a Lh9upH106KwqL4coElqkYgmTl1nEHxVZ+LKKVGThCS6SMVaCoXUaz9a+0CIVaxhXZ5EXcYAgtFhJ WHtPMMvlFmVzqbwXGm+ckb/JLdxrjedLKULvNwdLxuqxqVWijKJ52L7PE5HXqDSvRI7foneX56E8 PQ4TSUW/35deryedTicZq6IKPfy+THDhyi3cQ/T10PzclHb0+QOwS/jyimWCi1arJe+j0W8CZnKL MomF9tn4yfco77ofP3WSKqwqR53+k//MU+dc/51vl4UW+yDQ2FTOTefexzWvO78f190GNbJB0X7N JCILJdn2WHnF3PY1ragiJ7AoKtGYWHShYow4jrHvJMl2ySx2a+fttnxMpzKYTKqWcRGVF8nkFSq2 aHhtKrRoeNfuTs0v7u7O73P/pipxBRILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ANhKfgRg7wxyEgaiAPorICRuWJCw4gJNjGfwFO71GJ7ANZ7CsPQQLlh4CuOOmLCiFOzQ/vI7DqAJ CsX3mkl/y3T+tGlL28U8pBYA8J+JAvFjVrrbNhoOn6TXG5TLOvB+LpioLjv5hIoorNAiTRcVucVs tpZbJElVdqFyC9eWtmcFGprr2Ki7UEE5hf2o+z5U+x862XcJLRZFnMss8ngtnljLKBIv9uUVM1kL LEJCi8QTZWie8LFvNiOZTl9X8f3DncS313J+0TZ7VZVD6LRY5mKLUmZRSCZUPOGWnYzCCS1WUgsj snCxCi1srMta37Wjc9uu5nKT7cPRCy0O3RWEFntt355bUcBXVcovjJBiFW+7Fwb6rfV02x8JLuww plZqIeZ3W9/W02FUxatnt7V1/XpezrQj8naZl/aNSPySysfzWEajsQwGA4njWPr9vnQ6nXLw+/l8 HhRZbJNbhAbRr/v/D0CdKe9hxfXYarXkfTKRJE2l1Whs2ih/sYiizaMp2+vZyCzK9UaEsW/qJJr4 qzyndEzIVb9c+85X576T83jy/ufcv5l/V7uVZ3/5+sFVpRROVLH6QlNIK5rZM0Rq5BZNJ77wxRZa v5gvnBhDzGtXtq6bPef0s/eZb0gt4qxcZcV9jDkzRaUVGqu8wpdZ2NShYg+BLUtv7rNLaIHoAgAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzqcA7J0xTsMwFEB/QSoDQ6eChNSFXqDi AIwMIMR5uAT3YGJmYWNGTHRnZEKdSklK7OQnP27SgITatH2vcu3Ysb9dqVG8+CG1AIBdoe70NVt/ laTLpoH6/ZPku/z4tJKJOE5lFiqisLkVWVhxhatPy5r03jjvp3IMN5aN2Xa25UDrbVjHpq8hlVKE 84+ztiqhRRyUowrpxCy7nklZYDGrqfsyUotQhPFtYhRCi2J+xdwPDkQ+P1Ohxd39rQyuz8prbRBa OKmEF1rMc9VELqDwMgtZFFq4T1421z5JkbtxtL8bz8bQshdZZFILhBYtj79KViC0WKwqpBV1bcvG 8f/JX8w7f+7M5W9yixB7BKpI+bGlffYq2hx6jKreF16Hx6iWJphm02ORlxuR/QuRwVjk6OldHh/e vaRiNBrJcDiUXq/n1xsnLzROVBFF0VKpRZXgwvXXvPa3BIB/ReUVVZIZR7fblefxuKpjvSHPCiq0 rNIaHdu0z0OhxbKx/7i2VbBJcTZprm2Ks82xVh0PmUX7Y+5i3HXGXvc77tpkFlKxBXHvCE48Yfr6 bU4mr4iyNi+sMEKL2pTcE2cyDJVjWIdgZ57uzk4PD+VjOpW3yaRpWedJepVCXqFii05Qp0KLTnBt d2Jhsru5sM3+TE3iCiQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANA6fgRg72xy EwSiAPwa0WjSRdONsRsX7YKkq6676S16nl6h3sJ9e4q2q96gFzBdqmAZ4MED8S/Rgvp9ZjKMML4Z BBQW70NqAQDnykXF8uOmTqPRWAaD2yw3qyaqTwQTxbaTT6iIwgotgiAsyC2m01xuMZslRWUWKrfQ PjZOPoZ97ZLDcuxCBeUU5nGcc8gPdBVYZDnmVwotQikKLVw9T2UTWs9SSYWKKqzMYmqkFrnMIn/P iiys0EJjVcwiGmuvF8pk8h23X99f5ObpfkkGYeswFXc4oYW+YrHEIqlVPOFEFE5IkQkqSrKKTGYR FW3bbVx/V6vUQkUZKrTQeNko0jmq4CL/php0Uap7KHXEr3vOh2LDvOxxt05wYYUU8XK42/VQt4v7 Rufz1oKL0CxbCYWsads0pppWVcy2q+QXZVGG/cx0fdAT+XlIyuWzyN1HIL9vnzIef8pwOBTf96Xf 70u3243lFpooXwUXVVKLKrlFObF+nAj/KH+DAJrNKpmFbXte8vhnHp3H7VZr1wBL7fh8Lq8vCzD2 wClJFfYV45T2yX/GIVYz4x3z2InZnLjnHPuQ8Xf93MJ/fVl+8KpCilYqqAhTaYXn7jOM3MJz4gsj tXDr3T2J9gmd5EKKvkAX+6rdlutOZ5uh+lGJ7oTkS3KhhZVW6LLKK8oyCxu6qthdYMuiVJfZJLRA dAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfInAHtnzJtGDAXg50RCQsoS1CWK qrB0yIDUuVO2/pP+ns79Faxd+g+qZIvYyp6BAUWiEFzbx4N3JseJNAg4vg9Z9vnOfj7EISyh9yG1 AIBToCoLm+3vhPKtbqKrqxvxvpwE1kom5vNCZhEFFHltRRZRYqEii9hftLWsrtWxVo6RCzSOjaYk s27CfaSE7Eex/vyzXuQJnC+T0WvfPNVliYWKLVQ2oUILFVJMS7KK4vhvSV6xLruYmTmmYmUWRbv6 2Wy3JzIaDVL7x+/vcnl7XSu08N4vxREqtIgSC32phGLqp8t6TWQhhcAib8dr0jgzdrZ4xRhaW5lG WgdCi8OMv8973mXsLee20oqqc2vzmva2gos4dqPcQlOW5ilINUydlCIXWFjBhaZV3STKsH2lBRZl fC3yEMr5V5GPjyIffg3lZ38orVZLer2edLtd6XQ6r8otXpNaVMktbHL9yvcSAN6EfYas1MIeny9E FqPnZ2nnCZ/jtUnUE7+7XNmalwsrtJ0LLFR0Edvhef9fqUXThArvEeeY1nposZp4T8ce71RED6cS c59xTzn2LuNvM6/d5ixHxd8F4ffEmZknbWsW8oqXxbkkrjBCC1uS7CKMeQn7EDtG5Rh2mxVjxeNP FxfyNJnIYDyuW/aXUO5lJa9QsYXL+lRo4bJjuxPLi9295efs21QnrkBiAQAAAAAAAAAAAAAAAADQ IJxzn0N1F0rfe/9nv6sBAAAAAAAAAAAAAAAAAAAA2A3OubtQxf9J8B8JAACAhvJPAPbOWCdhKAqg twPiYJRBQlzEwYHoYByd9DP8ADf9GBNmf8DBL5HEfzBx0gQXB0xb+9re9vaJoBGlwDnk5b1HX3v7 Glqgae5BagEAq0gwpn2VlK1JK/X7t9Ju7xY5XjVxvS+ZyOQWVRGFSirCMKrILUajUm7x/p4VJ7Yo x2eJ+3V7GsfJM7J4i5sEehmkEI5Fn0f993+80CLb72o7y8HsCy1UOBEZGUVohBZfiStGY95XiYWV YlhRRjhxJmtrzzIcPsnJyaFc3FzK5l7bzKoqtFBZhAottG+FFql6Is4EFE5SYYUWvriikFvkfZVe pOsZoYXbrtY2lsZWoUVsXv4casG8dwWhRS22bT+TkwQXVkiRtn94XSwSx+frVgQXWgXeRKx0YpqU wvYdVmhh06XqOO1PEmXo2KhcHq6LPB5nZeNcZP9+JC93AxkMBtLtdqXX60mn05Fms1nILbSeJrdw bTvWJt1Pk+DX/rsIoN6oqMw/h2xfpRavb2+y02r9LIBe53JZRWzfV4GFL7/4xfm8bKIDhBbzi7PM sf473ixjLfNxmmdM4q5O7L+M/9vtVn7by+cbsCqkcJKK9K6NFVgYuUUj6Ue5zCIdq3W+TpTeK5FC bhHnsVuNhmwn/1e+IbU4SMpRUh6kFFpYaYW2VV7hyyxs6HHFHgJbYq/2mSa0QHQBAAAAAAAAAAAA AAAAALAABEHgHtJTiYUrp7osjuPr+ewVAAAAAAAAAAAAAAAAAAAAwGzJn5E4k/I5CZ6RAAAAWAE+ BGDvbHISBqIA/AYMG9iwYKMxMXgAOYGJC+MVTNx4AY/hkVy48QyyM+7YuxKDQVOxQ/vax0gFgvwU v49MZjqdvjc0lDAJmQ+pBQDsOkW7sdn+w7jczArUau3Hi6PqRJ9KJhKRRSKzUBGFra3IwkssVGTh +5O2lnysXqtyDH9scybt0cY30luWXdnIuuzvYzvnP1tooXsKJs+h7i8YCi0iI6D4NEIKbX8YeUUu s5gutcjFGHmteaZTqbj4mX6Wfv9drq4v5Pz2UurNhnlXuRzCyiKs0EJfXjJhZRb+pSKLUFaRiSwC wcV4TCrB0DqLl9YqtAjzj+9zILTYKpmFZ9PTQWixlbGttCKMXfgZNt2LCi78tW7kfsQulFvYY80d Sim+gmsqBWN1m9XfRBlWkGHzp+23A5HHuFTPRNpPIs2Hntzf9aRWq0mn05F2uy2NRiPbRN+LKqIo +lVqoe2wTNuIf+JeAsBc2OfR1lpUavE6GMwbcLqYQmU0OiYYn52zMUbzf6Gv49kvm7hhl+4JucqX 66/zlXnu5NyevP859yrzLxPXLmuyKP53QfwboGLijpcxqbwiSs+NxRVGaFE1Qos9Py4t9hqVY1hH oBslq6/jel1ehsN5xBancelKLq9QsYUL+lRo4YJju/IKi12thefsbZolrkBiAQAAAAAAAAAAAAAA AABQApxzR5ILLPwmDScFQ3trmRAAAAAAAAAAAAAAAAAAAADACljgPxLdtUwIAAAANsK3AOydQU7C QBRAf00sJBo1bggrFprI1o07Ew5i3HoLb+DODZdw4TFI9AjGtTvDDmyx0+Hbz1AQogiV95JJp8PM /ClJS9uQ/5BaAMC2EZXU77NyNG9Qt/sozebJVz7WQioRSia82EJFFFZokSTphNxiMCjkFsOhL05s UfT3Igudzwo0NJZdy7qT6v0UjmMz2Iz1l+Xrmy+08LkER2O5hBda+K0XTxQyiqGpW4HFIGj7MG2h CMOKMtK5Qos4jqTf9+9Vbu9u5Oz6UuK9mjmqcqFFOkr91oksJJkSWrg2J6NwQotcamFEFq6uQgtb 133t7+bRrZ0XoUXFQGix5LQjL5yY4byy8ouJ+pLXxnz+qBhr5/uKNUtwYdOe2svdjqlrfwnaNO2q zOinaVdT02Zj2ZSp7l7mQOTlIqtnZf9K5PRpIG8PPen1etJqtaTdbkuj0ZBarZYnni2TW8wTXWji /TD5fp4UfyN+jwCqQXj+uHMqbNe290WlFsH8YmUVvrGs4+zPFonxB1QpTpXWuklx/nOsKsfbBtHD tokltlUq8R9j//a8E/fyMv0iVoUUTlKRK0nHwopdJ7PI9pPsuSIxQguVXWg/HZPmItDJxyQX+ziO pVGvLyK1aGflPCvPUggtrLRC6/oUFcosbOiyYr8CW0bBNuQ7oQWiCwAAAAAAAAAAAAAAAACANRNF UUd8YobOuBwuOPR1JQsCAAAAAAAAAAAAAAAAAAAAWAH8RwIAAADK+BSAvbPJSRiIAvCrGA1xAYkL F7LiBLg30bXex1N4DQ/BwoQb6Ma4xbU7NDH+dey0ffQxFIFYAev3kUlnhnbetKHQScj7kFoAQJ2Z lZXN9p8n5WzeQPv7B+JcY6LPSibiOJNZqIjCbq3IwkssVGTh+7O6lmJfPVblGL5tY5ZRl+TPnMdm sL75l32+s+zr5UKLOKircMKKJ7T+Pi6ZnOJ9Rt9bLrHwfaEI48OM/73QYnc3ktEoE1pcXl3I4fmR bO8Uj17zhBZWZqEvFVCkMguZFlr417hu2mmRYuuP03H81sbQeiqyyMUaCC0WZNVzqKvQ4jdRIZQ5 gTLBxczPt+me+f0Yuip0PyfLyS0smj7VpkcNU6Vq2lUp2demYbWZX0ORRln8vP7cEblNSuNUpHsn 0r5+kH7/QZrNpvR6Pel0OtJqtcYJ9FVu8Z3UQuth0TFC/upvKsAqKBNb2La/5zwvr6+Lj5kNXHwl WGmFvR9tW8U0S9yvdZIq/DUBQN3i1DnWquNVGavO12mdMYn7f2L/ZvxK73WZ9uqlzwXOpSILJV22 JH1eUPGZv9fwQos4TvtUZqESC22r4EKPUTmG9fRFLlttdff25DF55rl/epo37eOk3MjkSmlLpldP uiKLgrautMqKXZ2F79nLNE9cgcQCAAAAAAAAAAAAAAAAAGCNRFHUliwpgyZoOPnBcIOfzwgAAABg OfJkU4p/pmkveOjA1IfOuWFFUwIAAAAAAAAAAAAAgA2k4v9I3FYwJQAAANhQvgRg7+x1mwiCADyH lViRIhEhR3Q4UgqQm4QS0vAqPAlNHoEmr0BJS5POTRRRUNPQUjhpiBz7Fu/tjm9uuUusxLZ85Pus 0e7adzu7lv9lzYfUAgCeEllN/+S+k87Ovsr+/itRl4QW+w+CierYyydURGGFFtNpXpFbjMel3OL2 NoQXW5THB5GFzmcFGpqribbLFBT2sRmsd/3pA7usyF4VWgSRRZBYhCiFFnkUT+RRRuGvU0HFtEZo MTZSC5VZpFILFVqkwoy8cSc7O7mMRj+K/udvp/Ly5LXZlfunzaO4wwst9FKIJVxoVTzhRRZebDEX VCSyCi+yuHE3lbE9xp/vWz+H76soQ4UWmm++irhHFVykewADQovNn7/RU7GY4MIKKYp+3evjHWvX 4/TchQUX6u7R8qd1Mou0emwqtHiW9O1tTfPodclt0+ciP9/POu9Edj+KHF78kV9fhjIcivT7fRkM BtLr9aTb7c4L608mk0ahRSq80HPSgvxFkfyWv6cCrAr73Ji/1iTPE5Va/L6+XmzSOnFF0zENkVkh RmOa9ogm1pXnf7pPyNW+XMvO1+a1k3Nz8j7l3KvMv8p9FXNHwYS1OEjsq5CiE0VYLs8LiYUKLDqx teOOEV0UvwT51rnKVxwXc+9tbcmL7e1FlvpmFm9ncSml0MJKK7RvNYFWZmFT14VuOQ2XtCn3CS0Q XQAAAAAAAAAAAAAAAAAArIgsyw4kFGbw4Ys0HC1xego2AAAAwNKJn198fJAgrDiO4/4jp/6U5PHN lZSfac5nMYrj78650SPzAQAAAAAAAAAAAADAGuE/EgAAAPBQ/grA3vmsNhGEAfxbe0khUCEHD6IE oVfJGzQ+jI/j3RcRH8CLNxF60ZO9e6gQiiUm4367++18HXdML5tkN79fGObfznyzpYEZWuaH1AIA xkruZjbf/qJMb3dNNJs9kxDOHrR5ycR2W8ssTEThcy+yUImFiSy0vS5bis/aWJNjaN3HfCxjufiZ 9zgO+l9/t9Ai/s7nhBabtvxQOuFlFCaoWDtRRZRZRKmFr6djo8yiLue/i+fnv+X29ntVfv/5ncxe v3Rv1S20CCG04ggTWqjEwj4moViHdZt7cUWVpBZYpGV9phrnxv5pPhrDci/TqNYxJKHFoZd06Pj7 ZGRCi38fi9KKXJ/Hyy1y47pIBRdZuUUqs4iBYr+/LrVLeJETWojry81jcVLpRSPDWD0X+Vqmszci r65Fnn66kY8fbmQymchisZD5fC7T6bR63225YdJcL9bfbDatyMKXTWZh9S7BRe5nCXDqpBKYtE2/ R8qvu7tHzZXd66Sii//Vd8TYB0OKM6S1HlOcMcfad7whyywOEfPUxBKnKJU49D5zkDIL6Ti26F6k 3Fc8cXH1mcoOUe5P9JxQSS6cvMJkFtuk3govmvlMjuGPTUUj07gszyE/7+/l22q1a9kqPP4iUV5h YosiaTOhRZHUTXDRlfyJK+0Tl+8SVyCxAAAAAAAAAAAAAAAAAADoiaIollJfzLBs0kWP4X70ODcA AACcAOXeRaUVS4n7F8373L+kaKyrpnzlO8q1mfCiTSEELqwCAAAAAAAAAAAAADgS9vw/EvyNAAAA YMT8FYC9s8dtG4YC8FNjw5nSDC46FWgBe+hUZMiSJVfo2Dt06l265AABOucE7eYhQG5QGB26JENG I4niiqKe9UTTSlw4kn++zyAeaVt8ogDLoiDwQ2oBALtCEql/z8ph3UZnZxfS77+btXVxVy+YqLad fEJFFFZokaaPFbnF3V0pt7i/98WJLcrve5GF9mcFGpprGTZdpqAwjvXgZfa/TmgxX+aFFjY+mPgw E1Q4iUUos7ASi7KuEgsVWmh/KspIF47CHZNu91pub//K0dFQvp5/k9fv35hRVYUWKotQoYV9qdAi V09MvYDCSSqs0CIUV0ymE18vZBc2WqGF61ejlWdobhVaTM0rHMNa0fYutZG/rTFvudCiukm9qCIq uJgmpRRjiXNkvuB8IbfIo/atIQlyWcFEErTDz237lcyfUpMgPtWPK49BXxnpgcjvk6xyLHLwReTD 5UTGP0YyGo1kOBzKYDDIrqf60uv1/KK1hahChRZWaqHRfab1mNxCy6b/rwKsgpjEIia56HQ68ufm ZlEnftHpNI2+PyevCGNQz3+fC36X2yRVWFWObTomTebZ5lxN59tkocUuCDTaytl27l0c80vnb/y8 UggmrMXB4WQUOkVxkor8jk4gsNgrom3vGdFFfmfIxfyeSnWK4nIfdrvydn//OVKLj+IfvLmSUmhh pRVaV3lFKLOIzbRis6uwhDOykKeEFoguAAAAAAAAAAAAAAAAAACWJLII9Gnd91cNizoDAADA/5Bd w3yWcnGpT63uTD0qvJhdYxXPLf4Sv3DVT/Gii3EL+wYAAAAAAAAAAAAAsFOswTMS4ybzAQAAQLP8 E4C9M+ZtGogC8LtEXkilgDogZQH1F2RGYmSBof0VbIiVf1Yx8hMqIXXoUsRIJ7q0QXW4s+/Fz4ed RDSpneT7quvFl/O9c6Rceq37PqQWALCPtGVos+0ffHm/aqDj45f+e32ptJKJPC9lFiqisLUVWQSJ hYosQnv5WEvVV89VOUY4tjEfw74kfeY6+sHm5r+u0CI3banI4kFSoUUlprBSi0pikcos6lILFWJY kYXGaWYwcDKbXcrd3Uw+fjqTN19OZfTiyFxVJYewsog2oYWVWYQvFVmksoogsShKIrgo+kQJhtaL 8WKtQos0frG+JUKLXsosAl1P65CEFtumR0KLf4eI690SuUVNaCGu9pm97jq56Devj7eItY7cQqS+ dAbylnOa+rolz9m0rW1jZSK/X4lc+DJ8J3LyXeTZ1ys5P7+S0Wgk0+lUJpOJjMfjQm6hyfaDvEIF FyqyaHus/dNk/Y2vJcABYd8TbRKYLMvk582N/PHvt2w4XDZYa7uLSaitxKJYDhrEFm3z3Da7Jm7Y p9eEWLsXa9PxdnnuxOxP3EOOvc34T/b5KPVtmCuD+z3OvJBRWNnFILY9xFqFFVZukSfHC+GFPyfI MYoi9W2Ri+Of+D3Ir/t7uby9XTXtt1L+w6zKK1Rs4ZI2FVq45Fh3Sk1lEGPMG54TU68SVyCxAAAA gP/C//wVbjp+vmb3a24WBgAAAAAAAAAAgH3COfdaqgTQ4felXSaBvugwNgAAAOwQMcnUWSynHU9n E6jo4nM48Nf3Q0rBRVH4OzUAAAAAAAAAAAAAwOPp2T0S3zqMDQAAAE/AXwHYO2OdtoEwAP+BYAak FqGw0ilK1a1DFzqUPggCtY/RJ+jMS6BO7J2zIQRbp4pHoEJdQmLXZ98f/746MYWC4+T70Mm/L777 z4KTziG5D6kFAKwCnYr4fV2jk5Nvsru7J7ovtW5QnQsmyudOPqEiCiu0mEziktxiNCrkFnd3eXFi i+L6XGSh/VmBhuZ6LG2XKSjLdB9tvoeH/x6q/pjrhBaxj2MpxBZWPDE2UgoVVFhpxWgquPi7bjxt n9dbUUY8V2gRRR25vc2/Y/Ll62d58+mjRFub5q6qhRZxeh/u6OQSVUILV+9kFE5okUktjMjCxSq0 sLGe6/WuHz3aflVo4X6ysSC0aEf+Ju/5KXMvsNCi3N0MuUUye55YwcW95Rau/07RNjvOE1yEMgvd HjXcWjWUV9g2SdA+CdpoWavoJ9xa1ceTFyI/99PgncjOocje+W/5cTqU4VBkMBhIv9+XXq8n3W43 E1zoJvwqt7Aii1B6oUKMWRv3L8saAeBfCeeCzg99zc2371dXMp4ntfAbTU/FFHYe2TrtV3KhRUls EbZ5xvVum/K0aayLlGeZcz13PmQWi59zFfM2mbvptWPbZRYzc6vAwgkqXGX2jONtD15Ise5fi73E QgUW6/5oz638YtomE4aWH1dc7u2NDdmJovsM9XVa3qblQgqhhZVWaKxPWKHMwqauKiLVwovwCSyk TmiB6AIAAGDFSNc4Bz5UUcW2j5UP/yFHVfUvySVgyo05t/FlkiQ3jx0DAAAAAAAAAAAAwEPx76O6 900PfHnZ4HBCLusvAQAAgFUmXcscy/KILObxKi1HvljJxZnkkgv+7wwAAAAAAAAAAAAAUMOCf0bi uukBAAAAwNPyRwD2zia3aSAKwM+tqFqpCetKAbqAZTacgC0LrsGaLZfgHuxYlHOwzq4HqJAqFamp hI2fx8/zMgx1UNPGcb6vevLPeOaNm9gdR+l8SC0AYGz8a6Y2v/9lHR/7Gjo7eyVVtTrZq5dMlGWQ WZiIwi+9yEIlFiay0P1h3SIea3VNjqHbPuemGcuEz2M4j/07h9z7uXTtpEKLMlk34YQXT/xOhBY+ 7iQIK+5W9sfjosjC5Bax/fuFFsfHhVxfB6HFl6+f5cWHt8mZrie0MMGE/piAopFZSBRaNMIKlVrI spNbNNFuNyFxqfWsHV36HLbeiCxaqYUJLcr2tbA+D5JtdwuhxW60/Uj466Ko/r7n5a6bteUWSdXu 2Er65RYh0aqc4sC166dTTadWzZX5cr0tHN7TTm5KVit/JvLzdYjD9yLni/re+X0hFxcLmU6nMp/P ZTabyWQy6WQVGqnIIhVd+PWc4CJll//GAqyDl1jkQlGphfLr9lZOjo6iBMZEFv+XMNR311YntmjL O/HFiKQKm8oxpt/JU+Yh1zDz7XLfyTmcvPuc+zHzb+19JKuPNiqvaB4V6vHGQehY9ObV+xp5hZbp eMbJK0xmUSbbnfDC1TGrRGeMaGUab05P5Wq5lMXNTV+3Vcn3Q6K8wsQWRbLPnoyKZNsrBdPwT2Zp mbhln7gCiQUAAMAe0H6Z+LwNk1c8WFbxQJ5n+pCdRKUdg+qEI5eZQHoBAAAAAAAAAAAAG6MoCv38 9J3ECRq2/VlqH5fb7gAAAAAMj3pMo2OZTxJkFkOabOopSSUX+s+aKrj4VlUVYjAAAAAAAAAAAAAA 2Hv4jgQAAAAMjT8CsHf2OHEDUQB+FlohuihalI7QrFZKg2jS5CyRcpM0uQGcIGWq9GlotkpDkQPA DUgqxGbtzHjm2c+DzUIk8M9+n/U0Y8v2m1nhZdYazYfUAgCmTtZSP5ctE7zOzr7J4eFRtbarLkQd BBPNfS+fUBGFFVpsNnlDbnF3V8st1usQXmxRnx9EFno/K9DQXM/BFIQKnin0Yzf6kP4h16ujN4UW QWQRJBYhaqFFHuUTeZRS+GN/jayirndJLYLEwl7TlGPUeXLp4uAgl5ubX2X9/McXefNhaXpV3CtV FuGFFrqVYgm3X0onomxCRRZ+a5NV3Ba3leDCyi70HL3OyzF8XUUZKrTw+VRoUW6xjyq4SPswOPpu FkIL7m1y6HOSdTi1Wp8jc6jxXflAm/U8lWOkgosiWC/MBeZ+qXSiS2Zhl1FNw64Q2ya9sHKLNL/p 28aNvq7eu8qpyOuPIkc//8jl15WsViLL5VIWi4XM5/Ny4X0vuFBRhcotrMiiTXrRJrfQmML/WICH qL4nOqQWPmazWXnO2j07T3oWtp2rAgsruvB19yz+lzDjiYxJ3DCmtg4t1xT7NPZ8uyJ62JWcfebd 5dzPmb/vfmkbfOQ6Fo/HpPxNE20PUUjhJRXl258osVCBxV4s7f6eEV1U1xRFZZ2ofp6446/c+Ge+ v/8YqcU7FycuLqUWWlhphdZVXpHKLGzqtqg+giSKpEyxx7dJLwAAAGBExInEOonYl8cSxiNT4G2M e5OjXb9/Sxhz+biSILq4eMnGAQAAAAAAAAAAwDjJsuxYwjtVH/696tjeqV703QAAAAAYDm5s88kV Poa+6FQfnMT47D6nawnjKC+4+N5rqwAAAAAAAAAAAAAAXgjmSAAAAMDQ+ScAe2eQ2jYQBdCvtBQC DqmXoYYsQhf1IbosFLroDXqFHiFHyLrnCHTbCxQaCJTQTU8Q0mxaGtvT+Rp96Xsq4UWdyFLfE58Z jTz6I2HBKDjzkFoAwJjoWq3Nt7+J8XrTiY6OjiWER2ttXjKxWiWZhYkofOlFFiqxMJGFtqe6RfNZ 62tyDN33OR+CsSz2PIbrGO81tAstmu94I7NYF1os63oSWCydyGJRl42sYj1S2++szfex8yyz83c/ e/v7P+Xm5ltZ//D5TKYvnrmrahdahBBqcYQJLVRiYZtJKExooaUXV5QhSWCR1/UzZT/Xd1FtmsNK L9Mox4HQYvdBaLFb5+7I4Z+ZNsGFl1+sPV+hu08XueBCN3/eUIR2wYSXW4hrC9l+3qdrKda8X77f tkSrHY9vodcnKR6/Ejm5FHny8UrOz69kOp3KfD6X2Wwmk8mkXgjXZBVtcou8rUtw4e9fXgcYOqXw JpNYKL6uwhjl12Lx9wlMPtElobDnxQQWvu6jaq/lFvfMkIQKQxrrLuUZc66HzrfNXGO+T33mJO// k/s+8/d9XYbKKnJ/XjlHiPOMvapeO/RiWymv0GM6j3fyCpNZrLL9Wnjh+ngXXxkhvSU9PziQ67s7 +Xp7u2nYL2NcSCOvMLGFl1h40UWR7Zvgoi32qhyh5Zi/TZveaJFYAAAADJQR/JB4WxxKWpSlXpil msPqPExFF58kiS6+9DE4AAAAAAAAAAAA2C2Kongvzd9WD3sdzL/zve8BAAAAQL/Euc3TWLyNcRrj uN/RDAa9T+804v37EcvTEMJZz2MCAAAAAAAAAAAAANg6I/uNBP8bBgAAMHL+CMDeues2EUQB9K4i pwUZxQ0SSK4ipQBKi4Z/oUbiTyjyBxQUfEUaS1RRfgAJGhoKTIEUOV4PO7tzd69n10pA8b5yjjWa 3RnP3BnbifdhzUFqAQBjJmnYfn1bo/Pzz3Jy8qxcy1UX3C8EE7v7Xj6hIgortEjT7Y7cYr2u5BY3 N0XyYovq+YXIQvuzAg2N1RZjECp4xjCPcc2hViOV0KKe6kILm29MvmmQVViBxVpi0UXVJg11KsjY hjzdOx//XkwmP2W1+iGLxZm8/fhOHj19Yma1K7RQWYQKLexDhRa5esIVAgovqbBCi1hioXILlV3Y 3AotfL+aW3mGxlahhTOPeA69ow/DansMYxVaHJIOhBb16kpgsa9O6/P9qL9/+Z+fL1Yf5BZxf/l2 05FQk3SiSWYhDWUuar+vXSzSEKkvvRq2N1ORr37p2IXI9LvI8y+/5OrTUpZLyeUW8/lcZrNZdoy0 3RFVpGlak1tomS33bfx2vNh/vuD+CL5nASxNn3NbrlKLP9fXd+3w9vIGsUWS/e2VQgstv+cTmqGJ G9oY71DlCMQaXrwhj52Y/Yn7kGMfMn7X81Licewce2t9fg4TbA9BSOElFfnVoCCxUIHFUcjt/pER XZRt8msvUsotXFKclT2eTGR6fHyXoZ9m6VWWLqUSWsQSCxVeWNGF7peh96TyJYiSi/IYW950UIXo AgAAoIdEEgu/KMnQf0h8aF6E5BcjkbAYyYUmJBcAAAAAAAAAAAAPjyRJ3mTZh67HcU/8ds5963oQ AAAA0A1BZvE+JO4d/z/+tePeMQAAAAAAAICU1xtethz2yjm3ajkm9IBw3641ss/ZRZvxAAD6wAh/ I8ExAwAAwMj5KwB7Z4zbNgwF0C+lHYx68ehJQdHeI1mToUsP4Kk9Rq/QK/QGBZo9R+hSpOgdggzJ kMRopYoSv/TF0DEQGJZkvWcQEimKXzRsQQSE/5BaAMChsClrm21fluXztoGWy0yK4qjTZiUTeV7L LFREYbdWZOEkFiqycO31vpa2r56rcgxXtzH74lASPR/CPMY/h1bQUs9hk9AiN22hyOKfhEKLrqDi b1RgUfeJSy3acezY+cZZpGki6/VveXhYy+rTuZx8+ShvFnM7y47UovkEQotKLlHOy8os3EdFFqGs QkUWVnDR9PESDN024/mtCi1CoUZ1PwuEFoOVWQwFhBbDH38AQotu167AYtPxRkah+y+45zd983Y8 O26RNKaLpzILrYt0b8mx1Ku2/pzkIjw3FFxIpP9rkZt3dXl1JvL2V9nlx5VcXFzJYrGoBBdZlsls NusILmIiCyu4cPuuv/ZR0YVN+P/kewQYIaHAQov7zdt2x+39/UsC1AmpTbwi9h/y8cJju2RMQosx XeuQ4hxyrDHHm4LoYWpiiSlKJfp+3puczEK6ywnfSZJyzZP6fV0qpGVbJa9wx9wzjJFXqMwiD+qN 8MKco1aJapnjxRmu/n4+l+vHR/lzd7dtGk6I/FNaeUVMbhGKLmxdBRexkvoYReSY/Zq2rTyRWAAA AAyU8nnIyStOpJZYZP1ezehxyUg++GIlF99d4cVmAAAAAAAAAACASXDc9wXsEJIvAwAATJQkSVbl 5qsgs9gF30hoCAAAAAAAANCwkv0nvj6V+p1umBA+yfrlvsPuOR4AwBA47vsCdgjvSAAAAEyA/wKw d/66TcRgAPdRmk5IFaIZaZUBia0rA4gX4QU68QjlGZg6wcbeV6iywwsgFsQYoW5peoc/+z7uO+dC MyQxd/n9IsvOxfbnO8WJ80f+IbUAgKGSbpssXPj05F+Nrq6u3cnJ878b8OvG0lEw0b4v8gkVUVih xf192ZJbzOeN3OLuLiYRWzT1o8hC+7MCDY2Vk/4LFSJDOI/+ncPykzdKKrp2PVehRVmXS9eILUQ6 sTD5ohZQqMzCyivmHUKLuWnTSDBiuTR9rxZajEaFu739FsofPl64F+9eu8ejZhm1Smgh8grJg8hC pRY+loon5LjIKERoEaQWVmRhJBbhVrWlFlpf+tHc9qtCC7mFsfRZaJF7eLnj7xKEFlvBSiuSB1bP P3N4rdf9ymxqX8sxrNgiVCmSWKnMQrdTLZM6qdzCtlkltuhqV7rlFVq1XHfx1Lnvb3zhlV+4/XTu 9Gbmvn6Zuul0GuQWk8nEjcfjltzCCi665Bb2uLSRcrrpf+vS9Oa9FqAhFVqkSZ73wq/ZbK2+OgV7 OjckN/Ok8POosnWSxzfFLuZm3wQAQ4sz5Fi7jrfJWEO+TjljEnd/Ym8zfu7zUh4ah11bFFq/lk4E 20MtpBBJRfhGqJZYqMDioM7t/QMjutA2nR9TfJzjw0P37OhoHanFS5/OXRRbPOpIMlwVXmjZyizU q/GQMjBNVZKn2ONdHyIRXQAAAGTAr2mOXRRYvK1zNiHZHlZy8clfe/nR7rOLgosfGccFAAAAAAAA AAAA2+Ms9wA2CBs2AAAA7BlFUchvyCKzOM09loHw26fL3IMAAAAAAAAA+I94nyHmWYaYkJ/LXQcU kQZyUwDYQ85zD2CD8B8JAACAPeCPAOydQW4TMRRAvyNQFam7LtgElA1kWYkLwBoJcQW2HIFLANdg X3EOVl1zgLJoWRWUDPPH/jM/U09bJFrH6XvRlz2ejL8dZaaZJvJDagEA+8DUqmm+/VkbH27q6Ojo iTRNXOx1W2jRJJFFlFmYiMKXXmShEgsTWWh7rFsMz7VjTY6h2z7nLlGfUCHPPsyjjjnk3r9xlfQ4 /hhxCiaxaFx9LYPQYp0kFOteYjHIKSx+p7ac1OKPO8b68pKMjVwntDg4CHJxEYUWn75+lKdvX7pZ NlfKKaGFCSb0YQKKTmbRPlRWoWUvrvBCCye46EKGUo+3frT0OazeiSyS1MKEFhs3X4QWO5i/1JwR Wtx5Hn++hebqNdzLL7bOzVSdvO5n150P/T7rz/fbCy68zMIvxZqTV0jmOVP7xpILbZ9l2rcGPerr scivpcj3Nh69EXnRXorDt1M5OTntpBar1UoWi4XM5/MtQYUPL7jwpZddmOjCRx1/awEG/L1DL7iZ KH+en/9T3yEtEJ2VVOg5o0ILL7EIUeHTVLigfk1Ci1rlCOSqL1/NYyfn7uR9yLnvMn/peRnXjWPs vUsHdKKJWarbLcWsbevkFbpPP9s7eYXJLDaj7V54kY7dpH78LYuN4fnhoZxdXt5GbKGKPf2xjMkr vNTCJBa+Hkbb4/Q+zKjXZPb5l+mmO1AkFgAAAAVpP/+8lyixeFd4KA+Z4zY+ayC4AAAAAAAAAAAA 2Ftelx7Af+RH6QEAAADA/RBCWEr8/vJV0YHsH1/4PhgAAAAAAAAgEkLQRa9LiDSXBXJCQVQuIfyf CwDgvkBqAQAAAFXxVwD2zh6nYSAIoxMlCFERRBASBUJpUM4ADTfhCNwACg6ABAdIh8QVqFAqCkoa KmgRBTWQNTvxjjOZJAYJk3Xs70Urj+P9mbUsxU6UfZBaAACqSGNGfOXLel6jy8sb2tranZBYMBJr yQXLJ0REoYUWw6GbkFt8fIzlFp+faWGxxbh+KrKQ/qbHLvbEFEFVFnnmeVRhDkz55mEv3PGK51po QSJZSJyfgxVauCCfcEFKIQIKLajIl1qkQgvbxkoy8oUWa2tDen9/HMVXt+e0fbCvZjUttBBZBAst 5DUSS/j9kXRijtBCyypEYmEFF7qOtOO+OJZ+tdDC6VcS8gqCCzuH0hI7vToJLf4bCC2m+tMCi+nD anF6LbhQeWhpRR7ZYvaUihqsMCOTW0hfeolVK7yQqk2zL1Nw5pgWWMzqZ2bCpl2o+7VJ9HTkg0Oi jReincEr3V+/0mBA1Ov1qNvtUqfToVar5e+rXCa4YHkFiyxEYiFSCxtbuQXH884lAGXFylnmvfeW t5Czvc7zFqnmYyK0kLo6JiXE+APLJLRYplzLNE6Vx1r0eMsss4gxZt3EEnWUSsS+f6uzzGJu/SQZ Px6E/cz2wPfhfityChckFiKwaIat3m+K6ILvSZzL2olPL3ss8eO0V1aos7r6G6kFf/nDRtMHmhRa SOF0RXghsZZZ2OFtITkFptgnKIt+/ydNIAAAAAAKJvwZ45hSmUXub85g4WjBxZ3f9pMk6cdNCQAA AAAAAAAAAAAAUAB7sRMoECzYAAAAAFScRqPR9psTX05j51JBXny5iJ0EAAAAAAAAAABQIk4ijVul xbbB7ziLnQAAANSIKn3OPsdOAAAAAAD/z7cA7J2xbtNAGID/BpAaqRKgTBWR2oEikVdgKCsSEjwS j9CZiZeoWPsCrbplYWBjI1EHhqjkuDv7r/+cXdKIhHOc77NOts+++/9r4+jsVv6QWgDAtnPf29Ns /Xtf3i3r6PDwSJx7tFBnRRPzeSGzUBGFXVuRRZBYqMgi1BfbWqpzta3KMcJ+FbP97x9rr1Dh4XRh DIF2jaNZaFF9piuhRVFfSCWCbELlFpV4QkUWt3frSlaRllmtfrGN9vM76f/+a21//5dMp9/i9ufL M3n++oUZVbPQIn5XlOIIFVoEwYQuKqFQoUVYq6wiyixKoUWT3CIssZ1pe1suIYaurUwj5uGKfHRJ x9Bacqe3a0KLTcZGaPHX/lKBRf30Sn6xsB0nDKt991sRRiq3iKINFVw0SSh0X0ydNp9LsxBj2bEm +UUt6aTNE5HJy6I8/iDy6tp3/XUs5+djGQwGMhqNZDgcSr/fv5NbqNhCJRep1KJJbqHyKysCqP0c AVpEKq9IRS0B/az/mExW7bwurGi6Dux5ZVz3j9fL/7je1hWja6KJbRUx7Gqsdcfb5tyJ2a7Yuzjm TcfPPS5lpfsQWZzq7xUdRNFEr9zWKX/P10V5RTgW5jRGXqEyi7nZj+KLMKf3c/9wrKft4vOZujHi 5OBAfs5mMr65WZb2G1+upJJXWKmFSizs9l6yn4a3xd4dpcfErJfdjSKxAAAA2DB+znMshcgilKOM qcDDOQ3F/+7CC02++HLmnPueNSMAAAAAAAAAAABYmfKl0F16LovUAgAAoMP4uctbKf4+2aX5S5v4 5Jyb5k4CAAAAAAAAoEV8zBT3Waa4kIHymddp7jwAAHaB8n8knubOY1045y5y5wAAAACb548A7J1N btNAFICfSZotBJQVgl2kRmxgWSE2XIArILFG9Ai9RncIqRfoBWjVE7BCYtcdLFhk00VCYmY8nvh5 6vzQJoztfF/1NBN7PO/ZaS3np/6QWgBA20gq+q/XbXR6ei6DwfOFUKJwSqSB2MKFF1FoocVsNi/J LSaTQm4xnbqwYotifHm+MHcDvBYZ9RIq3I027IMl/n6sElrcDi+0cIIJLbdw0gm3fLpoy7KKyQZC i6kSYszy/nzxeBn2+HW7v2Q8/ilHRy/kw5eP8vDpE7VXZaGFl1h4oYX+8UKLTD2ROgGFFVRooYUW V/i+FlnoVgst7Ly+1fIMnxuhRcPyI7SoJzsWWtxeXUgrlq1bNeem538/TssxSueIJMgVyixC4UWV sCJRYzsV6yzzYJ61hZfH/nks8uOt6bwR6V+LPPv6W67OrrJ1o9FIhsOh9Pt9c07vZoILf4N/L7Lw sosq0YUOLQlYdiwB6oD/PQ0FF3p5r9eT8c3NJpOVW7U8sX8LobAiFF40QGaxzTxNkm+Qq325tp2v ybWTsz559zn3LvPH3q9t1JBtn6bFy4r88cL2YK9bTGulFdk7Rbm4wgstOnnbzWUWVn7Rycd38usT v52dp+TRM2MfHRzIwFwPfV9f6qGJV+LEFg8qwr/Smau+llmE6cMQfwiCSIM2RC9fpQUEAACAe5D/ 88WxiXeRS4G7Y7/I/cmGeT4vxd3k5CJuSQAAAAAAAAAAAPAPvIxdwBa55ibMAAAA7SS/ydSJuM8m YTd8M9dSn2MXAQAAAAAAAFAXkiR5L/Fueo3gYL84iV0AAMAe0arvSMQuAAAAAP4PfwVg74xV2wiC ADonWYVIXKRyE2ECLgWGfEG6tIY0+YJ0CSlT5lPyDa4N/oS4CJh06UIqFW4sUKRobndOo/WJw/ZF K53fE8vd3p1nZm0k7wlpH1ILANhnNq2i5o8fL9uHpkBHRy9lseivHVuXWUhsQULhhRZeZKESCxNZ 6PGwb211rcUwOYb2Vzn3c92x/EKFx9OFMSh5xnEfocU8Hk+FFrPYV+HErBJSeEFFncAiHJtJndQi xDOJhRdb1NPrFTKd/pDb27/y6ct7ef3xrTx78dyNaiWH8LKIVGhRyiWW4/IyC32YyCKVVZjIQh/W r66J15nQoooXtya0SIUapSQnEVrsvMxCyV0iQgti/68c94jnn6sbBReLKKVwIoyHvP5X1ybxqlwm uKiTWVhfZP1lXjF3UJ3wwv4FbDrn4zct06rbgcjkJLSDdyKvrkT6F9dyfn5dSi3G47GMRiMZDoeh JF38tkZo4aUWdXIL/f2mooCuzB2gO9QJLXwbDAbyezJpChJuTPzWxb/ztPQii1Ru8cAxbIM28uxT rbuUp8u5tp0PmcXu53yKeXPmzj0n67LMQnlMHenUvggBS9FEL+5XzjwVVai8Qs+pnCIKK/pObqFC i/58Lgc2t3fCi579XPlezV1jxMnhofyZTuXnzU1T2SpK/i4reYWXWpjEwu8XST9N75u/G0rPids2 3UkisQAAAGiJuNjImYQvXhznrQZaRr88dbn8G+uHor+y4AkAAAAAAAAAAMBe0KUFG37lLgAAAADa pygKna98W7bTzKV0nc+5CwAAAAAAAADYMc5yJtfP3SPz7j7xvS8kJgAA2+NN7gJa5Cp3AQAAALAd /gnA3tnkNg1EAfgZ0lRsGhUhIdRNpKx6BHaIC3AFJBbcAnEBxKabrlhxgHKCSDkBa1aIbSU2lZAS yDBvxmOPBzuphJPJz/dVoxl77HnPqd1M3NYfUgsAOCSKlvaVLWerdrq+/iLn588qoUTtlDANsUUt t0iFFktbLxtyi/m8llssFr747UwltwiCjGaMMvIeP4rsEB7ufAjHoGznONpO1nVCCy+xqNuxyKIp tPBCilhS4SUWTYFFWI73W0TtZTR2t9Di5KSQu7uvrv3uw1u5fPNCBsN6qtQltFB5hdZOZBGkFjZW EE/oeqejML40RBbiZRZuOW5HUotq30Ro8Sd8GV+7XBBa7B8ILXZr7E3F+I/xYmlFOl7ndR2tXvse YJrbBTlGp9yiGjiKkwovuoQVIRXtf7iiLx4n9LU9BTcWX5R9vx+LfHtpwz8XefJd5GL2U2afZ65P 5RaTyURGo5EMBgM7D1u641ZhhdZtQos2uUXYPuwbv35pGyAH1fXcci7quf/j9lZ+zefyaDis5SxB YLFiTNNc8a/IIu5L63t+wNnG9dNXjEMTTeyriOFYY/Udb59zJ+buxD3m2JuMn/u4An3/zKnuWYWx VSBXLjshha1VUuHuHmldCi1UZuHu7ti5fBBZuFJur8VE++k4DW+ejXNm50NPT0/vI7W4FP+gFBVb PGgpmm4QXoR2LLNIw6elegmSYpI6JV6/TgMIAAAAa7BzkbGtXot/EMYoZy6wcVRW8sl+z98LcgsA AAAAAAAAAIBdZ5w7gR6Z5k4AAAAA+qUoCv398sfceRwBN8aYae4kAAAAAAAAAHaF8m/fX2VOQ//f bpo5B9g8iEYBALbLOHcCPYLUAgAA4Ej4KwB7Z5DaNhAF0O8khhiyKHjRTQ2hm9a7XKDrdlMo9AC9 Qg/QRY/QI+QGbTY5RxaBbLMLpN0kUAihljpf0pe/FDkyxc5U0ntmmJEGzfwJMR4Z6z+kFgDQVVZl UvPn34fyrm2g6fS5pOlu5ZwXTeQiCyklFNo2KYVJLHJ5xVJkof1520paCi1MiqHj2zjLOfuTb6wP Yog+rEHZ3jqa/l8TN2eTzMJy+yWFZGLh6j9l7UUWS5mFnatLLXw7l1fkbS/LSOQxocX+vsjNTS60 +Pb9i7x4e1RJ6L6u0MIEE/oyAYUJKUxQ4SUWpdyiEFzocVZkWev1No7WJszw82Uii0JqYcnoE7de hBZr8tQx9FVosU0GJrSoDlOaLKqCi1p/JqXw7cc+A1bElgkbimv9eOVlqwQXllrVUreKVD8KrDQJ L+oyjDYxRj32mmQjmYj8eh3KK5G9jyKHZ+Hc6bmcnJyHvd9U5vO5zGYzmUwmYT+2yOQUmhhXaztW oYVve6mFHlsyXhNcWOnL/gG6iReu+NrKeDyWq+tr+X13l0ktWseT4q21jsCiSWax5vugS+KGLsX6 v83VxzV1fb6hiB6GMmfMeYc89zbnj72uTcfgt+zlqLpHCfvnnaJd3jKEcyqoWGif7mlUWKH78LBn V7nFwgkt9oo9vB1r345dp9/tykNjxMuDA/l5fy8Xt7dtYb+R/MczJq/wUguTWPj2qHZcn94Xf8dT 7/N/pra7SiQWAAAA/0DxQM/XUD5FDQRi4OUWn9M0/RE5HgAAAAAAAAAAAHjIUewANshl7AAAAABg M4xGo2ehOpb4ySOHAskTAQAAAAAAAKp8iB2A9CvpNjRQPGvBcxYAAE/LYewANghSCwAAgIHwVwD2 zp+nbSAK4M9FDCwIooLaBWVkixgrhopvxtAvgOhXYGEpe6dKGZhYujLwBZBQJ8Q/12ff8929JjRD jJ3j94uefLHP986OE8dOdD+kFgCQC8WM8uH/Vjo9PZednb1WKBGcEmUitghyi0ZIEeLFSy2C0OLh IZQfH5twy1VqoSILF2kOnzmzIchyGNg5h21wLHc77IEaRhxPhRaNyCJIJVRu8Syp2MIJLZ680MKV g6jCyixSiYWWYxGGlWS8LrTY2Cjl7u53Xf7+85t8OtxPBBZ2qrIIJ7TQRy2WqJ7X0ok5QotYVqES i1mCCxVZ6HquLVfWdlttRvksL/Gj9P3ygovwymT2odIVCC2G3/4qCi2WTeu1CNKKf6vM2Yhodn0e WGBb9XyhgouF5BY6ZGs8Lz4tiClrXbferGFfJXoetxOPSGtzFVE7FU/bItdHIh++iOxei3y+vJXp 2bReNplMZDwey2g0aqUWKgJQoYWVWsSyizhimcC8fQnQJVawYkPrOP7c38vHzU3bQHMx4qf2uC38 QNNtXZ0W/tPILdf5+j5Y4NhfJaHCKvV1SHlyzvXW+ZY6uHzG+6nPnOR9P7m7zN/3dild9iORwWmu WqrnbQ/ue3U1dZKK+s6Sl9BZoUUSvv6a/05S3w3y7SSXElWerfV1GS0g+KrYr+KgiitJhRYarrsq vNByfFVj09tod4GJ0kwt8fxZV3eILgAAAOaAzAIinNziR3VM/JJGbsGfpgEAAAAAAAAAAIbD1747 sES49wgAAJABRVE46daFNL8zQveclGV503cnAAAAAAAAAAbGEASQ4747AJ1z3HcHAADeITn9R+Km 7w4AAADA2/BXAPbOJqdtIArAjxCkREKq2GSRClbtIhKLHqE36BW65BgcAbbcghv0AgghsemmB0As gkLVACVmxp5nPw8hFmoTx873WaOZseN5z5AfO5j5kFoAQBN5a0Y1u97fHHZUNdD+/idJku3SOiua yEQWkksofFulFJnMIsllFZnAYpYKLLzYwtdZKR6jUgw/vo5TxGz3PGNtEEO04Rg8/34c84UWxXO4 kFmUhRbPUfs5rwshhcotnoLEwvcfS4ILK7MoRBh2//LYi+bw6/XuZTz+lbbPLk5kb/SxUmiRvjcE cYQKLbxgQheVUKiYwtexuCJuq9wiF1qYff/qokILI7Pw/TSPJMtHl+I305D3lbrTrDv+KkFosVr+ Z95zxrKv8UWCi1RKYduz938OpJPiB7mFHS+P5QUXdlpVK6GIBRTzpnLtmG1i2rNo2yIxRrxvp/z4 WU/k5jArO99EDq5F/pxfybkrg8FARqORDIdD6ff7r6QV2rdCCyu60L5OzhvLBNpyDgHrT5XYotvN vgb6PZ1WDfS2bc8KLSS8vLXtZRZWbmHraLymiRtWkW9T5QjEal68JudOzPWJu8mxlxm/7uNSlnZ8 8vo0PhVkufOETmjnlwhuXTfILFIHnhFaxHKLbjhn177f5vfvhNp68zSHz7u7cvvwID8nk6q0vTj5 Ugp5hZVaqMTCtreifhzeFnu1E2+zP6aqq0skFgAAABUgs4AF+Bu/L91z5NTVx0mSjOtOCAAAAAAA AAAAYJMJ3+e2BoS6AAAAzcedn3x31YkrH2pOZVO4EyZPBAAAAAAAACgRhJvrINv8UncCsDzC3+nW 4X8uvrryo+YcAABWQviMbw3cIwEAALA5vAjA3rnrtA4EAXTMQxRXQhCBBLqNW0SROiV/QkEN/AH5 B/gCCgqq+wt0tNSIlgJRQIV4KMbreOzxxom4EFgcnxONdmFtz2y0EXaE9iC1AIBZIKrpn6TxZ9JJ x8fnsrq6WQglyj1Wk4rYopRbDIUUZQxyscWgkFlo68aen0u5hUotVGThopojz9yCrcd0o+cmMysb U39uHpOEFqMxWWjxlgstrMhChRVvudSiFFio6MIeq+dWr2WFFvW4KS8s3Mvj4630etuyd7ovy387 ZlZVoYVKLFRoYV8qtFDxhHs5QYWTUmSiilxWoeIKlVhYkYVtR4QWKrMw8gzNjdCioflDzRmhxc/m +WahxeghpbRi3NjItUz/o38LiuOSqiyjaCKv2LqtVa3wok5SYbd+nffGtMxBzXV069eBVLeATbxj U17XRW52ROZ6IuvXIhuXd3JxdpeNdbtdieNYOp1OtoGuE1a4eVu5hS+1sLILGyoScP2x7yXAlNC1 5ossdP3Z/tPLS/01xPvIunVq16qKWnTMtvYch677hgstmlTrb8ozy7manK8Nooe2iSXaKJUIfQ+F zGK6uYrvpjR3JtEb/jyf3ku4cSepyL5RGiO0qIRI0U/Meeq7Kx4d0uuuLC7K2tLSR6QWWzL8Z1sn tpiriaxcKZ9EfJmFn96P4i3wIvFaH/v7uqdGRBcAAACCzAL+i4M0dt2GNOl96L/QxQAAAAAAAAAA ALSYOHQBU+QqdAEAAADwNaIo6qfNUeg6WkY/SZKH0EUAAAAAAAAA/DIOQxeQsxK6APhW+qELAABo IXHoAqbIRegCAAAA4Od4F4C9s9lVGogC8ClIIpHEuIHclXfjDhM3Lo0uTYzRhfvr3o3RF/ERfAPD m+gbXNe6ccFN7gWpM2UOnE4hFwxlgH4fmXSmP3NOmwamTZgPqQUAHBvrZlaz61+78vK2js7OHkqe t0vrrGhiLrKQhYTC11VKMZdZ5AtZxWSyXHdzM2+r/EJlFyrF8P1rP8uYzZpfrNlSiMNj8/PYRmgx C+ut0EJFE1ZqEQstrLBCJRaTILiYRpKLqenD9j0NcVfTbmdydTX/f8iHz+/k6adXcu9Bz5zVUg5h ZRGx0KKQS7jzsjIL//EyilWyChVZ+I+2VXZRHCNLocWiv7BUoUUs1CikOJHQ4mhkFp7UqTZJaFE3 CC3q62/Lvux3QEVwkZflF6X6lr9pul9x7CwvCy403DrBhRVQWKnFzNTtVLCx/MLv1zLteJv2LVK9 flHM2V2RX4/npfNG5Py7yHj0Q0au9Pt9GQ6HMhgMpNvtVqQV2rZCCyu60LZO1huLBk5lHAGHRXyf 6f2lsotOp1O0/4zHK4/d2LIXZBclwYWRXGRhIul1OdbNsQkATi3OKcfad7xdxjrl65QyJnGbE7vO +KnPS9nb75FUnXXF+MGNQwpDhBdjhZe0rSC1+OvrQVahQotYbnEnjNHbZr9WOK5VvNOpGiMe9Xry +/p6E7HFM1fc08JCXmGlFvrkYutZ1I7D22KfbuJt9jLdNlBDYgEAAGBwYxv/Z5mPodxPnA4cD/5e +ebun5FbvmeiFAAAAAAAAAAAgCS8SJ3ADrlMnQAAAAD8P1mWfXWLi9R5NIyfeZ5/SZ0EAAAAAAAA wAHyNnUCgeepE4B6yLLsXHgXBgCQgiepE9ghl6kTAAAAgP3xTwD2zh6ncSAKwM8BQosiWG21SglV xAUQFe1eYSWQ9hYrLrAVt4CGEyAkekRPQ00FQqKBzeyM7bGfJ47CT8LE9vdFTzO2Z+aNEytxLMsf UgsAaDpJTf1oVqeTk1PZ2vpRCCXKZ7eaitiilFuUkoosxrnEIhNW6NJtc3UfXnzht7nxqjnyzB18 5FhbHubc/v2oOzhnCS3Gkj2vz9e1yCIUWmipRSmzqC6H0ovXYAwty5gutOj3E3l6yoQWf/7+lp3D fVntl6dD04QWTl7hylRk4aUWNpcXT7j1qY7CvBSCikJkIZnMIl3W9Vxq4epF30Bo8c+/TFamc0Fo 0dz8Mfd5kbkRWixuvE+OpaUV4VhTvy/U6jf9rhnVzsj75BYhPZmUVPj2ftl9xa8E7bQsQ49RJ8+o y5/XX76J3B7YIfZENm9Fvl/dy8XZRbptNBrJcDiUwWBgz+XGhSBAyy1CqYWWXWjBhe9X9/42/VwC loPwOCskNPk6x+Pzc7XP7EHr635Zh27T66lmzRI3NEm+Qa725Zp3vibPnZzLk7fLuReZP/Z+eWIe z8X1KMlEXE5gUdge3PmLLZ2kIr3KNEVoUYm8/Uou2fL9Jv4q2Dwba2uyub7+FqnFto1dG9dSFVr4 8Fq+saprmUWYPgz/FoRhgjJEr5/4l5VkH2zsKzAfpmsiaAAAmB/2J9CJLI4FmQV8nJ827uyx5MQW 57EnAwAAAAAAAAAA0DHa9MCGm9gTAAAAgPeTJMmGLS5tjCJPpYv8ij0BAAAAAAAAgGXD3dMsS3Rv vLt2Yox5iD0PmDvHsScAANBR2nSPxF3sCQAAAMDX8V8A9s7gtm0YCqBfTgEHRe51YATxpfCh6AY9 tNf2kGzQFTpAhsgKmSDIBu4EbffIybfEiFQy5Le+GDlOW9WU7fcMQhQp8tMGBVEH8yG1AIBtYtXu arb8i0uf13V0fHwqVXXQKLOiiSCyCDKLkORRTuHzQVBRLWUVi0Vddn9fn6sAw+dViuH7D3KLsN+Y xtt3dl8KsV00v0fb/CzNdW0yC92zr0xkEw9RQvGwFFnUkoo2gUUttwjtFpIKLUK+jOelPCe0GA4L mc+D0OLy+kLefHr3V0ILFUx48YSKLVRI4QUVKqpQicVSbhEFF1q3vM59fHvtx/Zr4z2KLKLUQoUW pfm+CC16Hh+hRT/ps9CiQ+xao2hZTln5RSO/7rmWuip04/zY9sWCi9Lk7aMnfczYrWFT+UUqu0j7 0P4lObdbxMa68lDk9n1Ir89ETn6KzG9+yY1L4/FYptOpjEYj91wZNuQBq8QWts7KLaxwQNOurCUg D4173cyhVGzhsVKLxmzz9fb9ROfmqqBWYpGILbRdoWUbeO/p4t7ZNvlGX+LscqxNx0Nm0f+Y+xg3 Z+zc6yJkFv8prjxdphdufVy69cIgDKz21rkyL6jwsotBlFWo0CKVW7yK0rkDc90gtvNHNUzYV4+3 R0dye3f3ErHFB5d+SC2vsFILfRux+SI5T8PbpCawqqXO/kzrFlRbLbEAAAD4V9za5qM7XAobi0A3 +D9+Xbt5deWO3/jjFQAAAAAAAAAAwMaY5B5Ah8xyDwAAAAD+DIQWWfleVdUs9yAAAAAAAAAAesh5 7gEk+M23Z7kHAd1RFMXEHb5mHgYAwL4yyT2ADpnlHgAAAABsjt8CsHf2uFEDUQB+RIqidGiDlgJp RUFByVYUlByAK3AEjkDHCShyCiQOQG4QUdAgmkgoXYpUFGR3hpnZefb4sd6k2MR/32c9eeyx542z XmU2Wc+H1AIAhsyjLeU3t510evpV5vPnSVSRJoavpvnyDbFFLbeoBRWbcFli4eTmxjXWsS6WNVRq oUKMGHUOl9pPmZlqLDGWiZzHcx2bG7S+jnpm8KbQYiOyqKUSKrdYS1NsYWUUVmKxKiQWf029Hr8q 2lnnHCrNaH8jHR87ub7+kcqfzz7J/PWL+joLkYWuVRYRhRa6JLFE2E7SiSi18Kv/hRaFrEIlFnFt BRcqstDzYluxrO2udfFrceWSXxMVXNhrGARddxWhBW3fV46+t1c1W0sr2up29aX6nXBL/8rjdsot yilbbZu6z0oqtE63dTpZW1fKMqwcw+az27n855nIzxAHb0We/BI5ObuUb18uU91yuZTFYiGz2SyM 6VwlqYiT6Kq8oiyr1MLuK8UY28YOQx9PwMNihSlWnqLbv6+udrbRKt4rJRZ2X7mdI92/Iad37eKx fbCv98nYRBNDFTFMNde+8w257+TsV+4pXvN95+/6upS+9OMgyyyqoXqWYVW2hziGCesoqUh/dWoR WjQiHx/DF+fpx4bqo0HI8/jwUJ4eHd1FavEyxDLEuTSFFhqq4XNFuZRZ2PQ2RH8EJrxZW8r92wZx iC4AAGD05AcoosziXbc9gZESH855Fe6z99777113BgAAAAAAAAAAYAKMaQLpi647AAAAAHcHoUXn fOi6AwAAAAAAAAB9I39Xvm/fk0dqMT4+dt0BAIAJM6b/SfDcFQAAwIT4JwB7Z5PbNBAF4OckKBGq BKiKWAQhxI5ISByABUdA4gDsOAdHYM2OI8AJuADKCZDYISSkhgWLJq3NjD3PfpmkaRYJYyffF438 /DfvuXLdcavOh9QCALrCTbOs2e2PXXt3W0fn5w8lz1e7szKLSmQhtYTCxyqlqGQWldDCL5fLZtti 0ayrAMPHKsXw/Ws/Tc4mbstEcm3geKQQXb4OI0wIAotqTkE7q3guOu9eI7S4juJGOtGIK1RKsQwS C7++ECu4qI7dJrS4Mv3nsm1uvtHor8zn38v447cP8uDZxFzlZqFF+SwI4ggVWnjBhH5UQqFiCr+M xRVxrHKLWmhhzr3SjwotjMzCr5d1FFU9+omvoRN0qNS9gdCiXX0fKkeb+7vRU9Hs2Ca4sEKKMi4H MLv/bNPj9NwVwYUusqhIK6GIBRT5hv3x1LDad8/E8b5Ncgxdtzk07Ujk9/Oq3X0j8mgmMv8yk9nn mUwmE5lOpzIej2U4HJaCC5VbeHGFj63UQmOVW+g2K8awrdvjCfif1N9v0T1km2cwGMjPiwtZunvw Tr+/rcNV+150D2Zhkui1c8IyC2KLQz/WuyS0OFYZA7nal6/LtZOzPXlPOfch86e+rrbU4CmrqN8X dGNWiiZ6Idahe89t84KKa78vyCpUaBHLLQZhrN03x/XCeb3y9z3rxoinZ2fy6/JyF7HFS9fc20At r7BSC5VYxLFdj9PbZt9g4n32y3Tb8AqJBQAAnBRubOMntXjv2r3EpcBx88S1eeoiAAAAAAAAAAAA jp0sy16krmGfFEXxI3UNAAAAsBthHPJV+NtzKj65sROTXQEAAAAAAACs8zp1ARu4n7oA2B9BnPI2 cRkAACeJewa/Sl3DHvlTFAX/ewUAAHBC/BOAvbNXaRiKAvCpxTqKLeIgFEenij6BP4/h5uDsI/gI gi5uboKLD+AkOrsK7gVx6+JSacxN72lubpuqUHPb5PvC4eavOSclgaSU8yG1AIBFpTZh/kp++NPY 5eWdrK+3R0KJtEdrlBFbpHKLVFAxjMFIWtHvDxK5hY5mm5nXUKmFiixMZHPYzKORhsU+ZflOFu88 /L53wxaCQyFLZPsNph3CpwstvqzQwhVZqLDiy0otXIHFUHTh7jsusugnOVSYkYeps15/l17vQw4O 9+T4+lRWN1vOWWWFFiqxUKGFO6nQQsUTZjKCCiOlSEQVVlah4gqVWLgii8wYhznGSGihMgtHnqG5 EVrMkKJrKKvQ4j9BaFGI0GJ8t1Rakbdt2rH/KrhIpBhRbezYuXILF20F64sqdH+tzRdT6LaBd2xf njGQbMtYP0fM56bIWxxLRyIbryKt56483HcTMUWn05F2uy3NZjORVPiCC1dm4You/HUqIND53O8S wGOa0EKj0WjI7dOTXJyc5EstVGiRd61Nklks2T7M9rqNrNTiP5nFvVDU/VS2PGXOVXQ+ZBbzn7OK eUPmDv2cU2aZhWFe6jDUHPlVRuZmlyWR4lnbg3k2jkcjqUh+ecoRWmTC7l+3zyX6Od+JZyQaa8vL srGy8hupxXYcu3G8SFZooWHKVeFFzVnvLvtvNP7bzSThReSNPu76SS9xiC4AAKB02IYiN3HsBC4F qsE5zecAAAAAAAAAAAAKoUxSi8fQBQAAVAXbdM009zuLomgraDGwkCC0CE4vjrPQRQAAAAAAAADM KfP4zrwfugCYKeehCwAAqDBboQuYIYirAQAAKsa3AOydv27bMBCHL7IBo4mHdPAQoEACZPAYwHP2 oECHolPHvkA7d0seIQ+Sl8gTKEOQvWOBDEGmwP9YUuKJJ5aCY0AGRev3GYQoyuQdHQWhjIAfpBYA gBRo2m1Ntn/R5fOmgU5OTkmp+satUjRRiiyoklCYOkspjKCCJRXmuFi4tvncnbMAw9RZimHG53Fc zPA+YukJEHbPvnwmacwjLLQoc3f1cgpr2y6FFqtKNuGkFr7QQgorWGKxsIKLpSe58IUWSxt3SW5n 8v8ZDA7o7e1R/86t6Nfv7zT7eUVHH8diVk4OIWURvtBCSiZYZsEyipCsgkUW5lWd23rRh8qjefF4 5lwKLXyhRiHB8YQWScksugKEFt0fP0WhRdtEEFrUu7hOjYILVV6TIoxt/74VYx+4vnK8KlaT4CIk oPC3geVtZP2tYc37s2oy9Wuq4bqMTVT7XNcfiP7OynL4jejTw4qe73LK87wQW0ynU5pMJjQajWqC CyOu4CNLLXzhBbeZPlJywSWNNQWIgbxPQveOYTgc+p2caa95YCeoCB1FPSi0eE+MLWjr3t830USq Ioa+xmo7Xsq5I2Z34vY59i7jx54X08U8Qh66Yj2h1w2ZrfPSPNNtRlCxMtesrIKFFr7cYmjX1gPx vsz2y4rvftxjhWlb67bz8Zie53N6en3dNIVLXXJy8gopteAnEb8uz2V4v8gnEv+a/Jg2LawgsQAA ALDX6PXEjT5cx84D9IZ7pdRt7CQAAAAAAAAAAAAAAOgJZ7ETaBFs2AAAADtEiCx+6HJhm/9ESgck DIQWneBWKfUSOwkAAAAAAAAAAKBr2O8tTmPnEeA4dgKgHfQ9Zn6WX2PnAQAAPeYsdgItgv+RAAAA AHrGPwHYO5scp2EoAL8IUokNmrLohi5YITZdzBqBehEuwGqOAGfoBVhzgNkgJE6AxBax6MwNkAak 0QwJtuPXOE5SBqmN28z3VVZsJ7VfqqeRpz/+kFoAwDGSddRf/utJq9VHmc2eOVGF2yR+s61X2RBb 1HKLWlBRlcJLLAq5uSkaR3vO1rWo1EJFFrY05/Azb9lajM2K24zlNTnM++hKxrbQou4rXMmyai++ ptDitkNoEUotaplFsx1LL26jMUJZRr/QIs8zubr65urvV2/l+ZtX8nBSL3n6hBaFvSfzsHKJjdTC zOXUEyYG22/lFBupRSiykEpm4dq+rm29zqksIqGFjhvKM1wsYxNapA459fxDgtBiWBJLKPY5Viit iMft/TsUdN9ZcOGvU8HFf8st4r5YPqHXxMKK+Jz487E4Ixwznivg91zk+1MzxGuR2Q+Rx58v5dP5 pUwmE1ksFjKfz2U6nbr7VXFFKLAIxRZ9fbGkIHz94jrcXyr5WNbKhzBn8jx39V/X1/LI5GgvXSKK LllFmI8mR0vtt5i27Dg3d5HrY5NMjFX6MHZJw7HJWZhz/PPe57n3OX/q+zqUGJRtsWR+7bFZjvt2 KJ9wZggroTDHokdo0Sj++gdeuqXP06W/5Y9fP52YNdKTbWujmhemnJryVZpCCy2q2VN5hfaH7fab bW21XlzK6BgT9nf904boAgAAjh7/o5wPUm9KA7Bvfkq1ERIAAAAAAAAAAAAMwzJ1ADtknToAAICx EWywdibdnxmuBw0Ijh6fU18EoUVKLsqyfJc6CAAAAAAAAIAD5Sx1AD3wff7xYHPsEN8bW6YOAABg IJapA9gh69QBAAAAwLD8FYC9s8lpG4gC8EuoFISUZXYQsajClp6iS9ZcgFNUao7Qm7RH6AEa0W13 XdMVYkV+7HriefbLxCEsEmawvw9ZnrHH7z1HFoxRNB9SCwBInV0rndnjzih8ty/QxcVHybLNcFY0 UYospJJQuLZKKUqZRV7JKhaL+th8XvdVgOHaKsVw8TVOnfP164elKUCIS1s+k3Tuo+l5LFf43hZa qMBC2ysvt8iMdGLp91ZMEQotbH9uxi4kFFpovDJmJi8JLU5PRR4fS6HFt+9f5Pzz9ZYM4jVCCxVM OPGEii1USGFFFSqxqOQWXnCh56pxxY+7XuPYuOucRX7NrVILXdw9M/eL0OKd5I91zwgt3jZPYhKK o8QS83snDwQXwfm1lMK2d/2Ne6G+9UL8/lobr7q0V9eyJZ1oklDYvhVa2DEqu2haRlaXnLVLv4ax ZfOabCjy8Knczm6L+eevuTz8mMlsNpPxeCyTyURGo5EMBoMNUYXblstlJbHQvRVf6LFQbqFbOvMK iEn4XIQSFCu1WKxWTQF2m/fCZ0v7+gyafuP+ACC0iJenzbneOt8hc7X5c4qZk7zdyX3M/LHvS0ml DseuWkLTQq8cLL1iTtL37WpaXxxzggonouh7WYUKLUK5xQc/nz4x4/r+ui2fnZdpXA2H8u/5Wf48 Pe27HSdYvpdaXmGlFidSv4XYtu3bt41ws28v4Tkx+31vf0gsAACgVRRziWmx+xq7Dugc0zzP/8Yu AgAAAAAAAAAAoENcxi7ggPyOXQAAQBswIgu33ewZ/vPoBUFrQGiRDNPYBQAAAAAAAACkiPm/WJIU 9V3yPev3jX/GUhWnAAB0hevYBRwQviMBAADQMf4LwN4Z4zQMQ2H4lSIh1ArBhIABNoQ6cAAm7sYB kOAAzBwBEIITsDDAhjgBLB0gxOTFfsmL4yIKFCfN/0VWYid5zykupQnyB6kFAKBt9ALbp1lZ+eqk k5NzWlvbKIQS5TytpiK2KOUWpaDCltRJLFJ6f0/zNl5znffxthSRWojIgks1h8s85ZRimKi4zry8 JnGvwx+I5czcVaGFFVmUUglbrMgizca5lU7YomUUvsQiURKLN2+/HC/nJi5+onJNfuMsL6f08nKf b59eHtH6we6XQguRRbBQQhYRTIhsIjFJXWihZBUiseC1L7gQkYWcx7F4W+J+yGI+KNWLcf1ygovy J9PCeQhjd7lLQotZA6HF7OI1NVYgrpZW1A+ZkFw1h84LUUzA7wQXldhGyS3KwIFZcKkuqTDefi20 8GP5IozQft2WUu31H28RPWZl4ZBo8yH7Y/X6ma4unmkwGNBoNMolF8PhsCKuyCfd7feLNhFZ6H1S DwkuJr2WoHvImNBjRcYD15nX8Zg2Vlenjmvshq27WLnQIlTUsb+9nr/gP94TbZUjIFf78rW578jZ nLxdzj3L/LGvS2hjP3pOsFXYHFy9sD04IQVLKvI7UxOEFpXiju87CVd+Ht8DpqrfjnOtLC7S+tLS d6QWe2T/UeiOSlmFllv0VFtPteu6r9bzv8GEhBfGW/vo9tCXNIguAAAAtI7sM5o/c8+ysh+5K6B7 3BpjjmN3AgAAAAAAAAAAAACAruAmztmO3Y8/BBM2AADAD5lSZKF5mkmHwNyhhBZ4Dh0XfiZ7FrsT AAAAAAAAAABAQ+F7Y02Wce4Q7se1HRZaNHmMAQDAXOOeVczN72FjzE3sPgAAAADgf/kUgL1zx2kY CMLwGFJEgCioghAVKDUVHT0NR0DKEThCagruwg3S0ISeGhpoQAqRaBwS4/HuOMOyicMrG9v/Z628 j2h3HDnSWknmg9QCALDKzMp4pvvP0nJaNNH+/mH6wLP+qU+LJozIgnIJBddFSmFkFkkuqxiNRGiR UBybtozLa0SKwfPLPNM1f5c3rCoih7+kKu/J8q/DL7SY3qNTmYUrtBCZhamzdGJs+0Z520gpRlZi wX0xacGFkVzME1roeT3ZwhXN5pAGg3va3GzS1c0l7bR31VX5hRbZZ9+KI0RowYIJOVhIoYUWfHbF FW5d5BYitMhkFnaOdzlEaKFkFtzO4khMPHK411AqQodcN6HFf64NocX/zbeqcxXMO09u4Y7n9UTV v5nUVuQWeo58rVmCizwLrmq74740soykmaU5Y1FBnwprsk30eGzKxjnR3u0bPV33qd/vZ2KLdrtN rVaLGo1GJhuYpBtRLbKQupZd6D6f3EJKVfZIYHH0veC7J7jwfcO8cLJmmyi6YNIvYorIJoX2vpxo OqbPi6w145p+y7I+A1Vbp8prlXm9Ooge6iaWqKNUIvTeBDKL5bFoLF5PHe9d0r3Dmq3n2/i0jwUV Yx6zsgoRWrhyi4bI4Wx7YqUYIsfQjw2RlWkcbG3RcxzT3XBYFPYJmSQkrtBCJBeJp67b+knCLVqx 546ROhdtriCxAAAAUGrSvQT/SaJLFfqBLigNr2nphA4CAAAAAAAAAAAAAICacRQ6gD/kIUmSQegg AACgbERRJCKLnybsg1AILEqPILRYBbqhAwAAAAAAAAAAAFaYTugACuDvdXqhgwA/wyZSvwgdBwAA 1JxK/UYidAAAAAAAWD4fArB3BrlNA1EA/Y7SbhJBK9hU3bBEyoplJSQkLsAhWHMH7tALFJYcASHB Cdgisaq6QuyyKAuqevDY8+3vidtExDCO8176NZ6Z2v/bStrEauchtQCAXSLr2H6+bqfz8w9yfHxS LuqrIouKpl/NuVpsoYKKKvIgtsiDzKJp/Zzf1lCphYosfLRzhMw9LCXGIsWrjOWa/J/zuE9osRrd QgsVTty2RBSNrELHfkcCi0p00UgvbmRVZHFjct3eeRb+Ek2nP2W5/CFnZwt5/f6NPDx9ZM6qLbRQ iYUKLexDhRYqnvAPL6XwQotSVBFkFSquUImFFVm02lhoEWQWftvLK/y25kZoMYL8CC2GyZCFFn2S SDxifz51CS7q+a5fObrfxovcZlJ9VaKGjeUWtq+5Y1GFndelaG2dsQjDzsVyjDh/VNavU5HvRUxe ipx8E3nw+Uo+fbyS2Wwmi8WilFzM5/OWvEIlBDqmIguVXth+l8xg5Vru+Psk2IwumYWO++eHZ3l9 /bcHr4/ltK85guyill5MJvceat059MHYRBNjlUyMWZrQZ64xX6eUOcm7P7n/Zf7U56WMoY4siLBq m0Po17aHIKQoJRVFm98htLAxDd+Xm33y8t5Q++28z3V0cCCPDw83KfVpEc+K+CqNrMLKLTIzlplx 2+++Edf+NBKHi9oYO971qQ7RBQAADJ7wDxIXRbxKXArsL2+dc5epiwAAAAAAAAAAANgzxrRgw2Xq AgAAdoUeRBY1zjmkFrCW4jl3IQgthsC74jX7JXURAAAAAAAAAEMky7InRfMicRnrOEpdAGyFF1ps dT8WAAC2hr+RAAAAgJ3mjwDsnb9LI0EUx9+eQuBOBZtUpxeIdlYW19gI/hE2gnZ3pcXVh3+Cf4r+ B9oGQSytLQ7BRkTBxNt13mbe7ttxokY2zu7m+5Fhfmz2vbcSyARlPpBaAACqyqiTz/T6smm/3wq0 tLRCSVI8TFWLJoYiC8okFDwWKcVQZjEUWnA/GORr/X4+FwEGj0WKwfElTp6z/PPCmiJyKJOm/E4m 9xzjCC1iu66FFiKyyIUWRSnFwK4VZRbDvu+IL3xCiyeb68nm9TMzE9HDw0U6/vN3h9Z+bdG3xTn1 VPmh51oW4QotUpWFCC2szIJFFjz2ySpEZME/2dyOWWDBr+NeYnDP8Tmu5HKFGnJAu1tzLQldNoQW iD2pHFWPVzZj1jdScJEUr6dSCj3+wGddekC/vVfHy1KOElxkp+JS8eNllLTCd5ysvharuT5elpx7 3DW+dYHo30/T1om+bhN9P7unq+Me9Xo96nQ61O12qd1uU6vVSp9XSy5EbCGyC732mtxCWlP2ScCP /r6hxz7Bxc3d3Xi2PZFXcGx5/9g19zXZWPdjUCehRV3lCMhVv3x1rh05q5N3mnNPMn/o5xLqXofX S8d7D7Nf+WLH2bbdrLGs4j9fs+IKEVq4cotZsyeO4zibyz0ix9Db+cjKNFbn5+n68ZEueb/0Ohum ndNLoYVILhLPWM9FcOFr+tuJe41U/9aGDhILAAAAtcLsJfgfco9M+xG6FjC1nCZJchi6CAAAAAAA AAAAAAAAppBO6AJK5CR0AQAAUGXs3wT3bCvr4LSLkuKABmPeewem2w1dB6Bb0w5CFwEAAAAAAAAA AFSYvdAFvIPN0AWAjxFFEQtJ9kPXAQAAoFFSi5PQBQAAAADg83kWgL3zSW0biOLwUxAJpHZpFl0k YMiq4EN0nW0vUPC6lwg5QQPOKXKF0E0v0EBX3ekMhRhCFE31RnrSy2jkuInkUeTfF4b5I2tmNJ5Y g7Dng9QCAPBWiDzpqzwcrjtpubymo6NjJbEoyguZhalEE7XcohZUFCGrpBUPD5mVW0jMxzgtQaQW IrKo65c2pO3Ox6a6Jjs4A9nAbgiMZUy6uw7f5HtOaFHILOq0FlqkNi4EFalHVtGUWdSCi9QjtEiV KOOR1gkt4jiiu7vi+8YXy2/06etnivfrZU2b0CLLr4FjlktUUotSOMECCi5nOQXnraQi/2NphZVX 0H0jLXkRXliVhRJa6Hq1PMOKLMhAaDEGILQYVt19tTHk+voYz1fWWUkrTPO+5ft803ILm3fvdy39 qV5n6P/kFnrbWKlfyytcIYXvGLO35ljkHGsry29dq1OiP3nYOyM6+U307mdCP24Smk6nNJ/PaTab 0WQysRvxiqhCJBcSs9BCiy+eE1y0jiUYBfI+u++5xFzO/F2t2ioopqv8X6o6TJl3X9+QWYhERZ2/ 6UdLF/NxW3N6bO2Mua1ttweZxfDb3MV2Q7Ydeq0BmcX26FJMVT0Pk3qt1K60PZRCCpZU2KdWHqEF pzNeMyvxhQQ5J7Pi06dLe27rfRzTx4ODTaQWcyq+NPSLalmFlltEqixS5Trveyjn6vXcYJzYRZf7 lmEQXQAAABgk+X2YfxjxPXQ/wE7Dm6csQncCAAAAAAAAAAAAAIAdZUwbNiShOwAAAENDiSy+UD+C +6SHOsGIyOfgIo/OQ/cDWC6NMUnoTgAAAAAAAAAAAANmEboDG/AhdAfAi+HfbXQlGwYAAPByTkN3 oENuQ3cAAAAAANvnnwDsnUFq20AUQL+CA6EkWxOSRb2pt9l1EQjJrhRygOx6hR6gix7BN8mqZyj4 FIFCNoGAySqxalUj6UvfY8sKqWQp8nswzFiW5s/YBn8b+z+kFgDQRcqqn9nj13H7WjXR8fFHiaK9 pWNWMKHyiaJJLqVwggqVVLh+Pi+OvbwUt1WA4cYqxXDz6zxpTFkq1twkfRE51ElfHhO3j7fvwX/9 FbXxVoUWKrDQyt9/c6FFIZ0ITT/3hBZhJrEoE1yEplcZRpjFCo1IYz0HByKzWSq0mNz+kNMvZ97O Xie0UMGEE0+o2MIJKZygQvtEYOHEFWacNMlkFkZoodfpPHbeJGYcv0xosTD7RWjxH2x7DX0VWjQJ QovuCy3qIjJyi5LUrkpwkRaurQ6VF+zPrt0ouHCdpoZ51VpZFU4E3tieb9+i1okxNs2r1yxkObON 718cidyfx+2zyIcbkZPfT/Ln11Sm06mMRiMZj8cyHA5lMBgsCS5UbmFFFlZ2sUluoa0vuRKk+M+v L7ZQqcX94+NbA6yMV6oim3jblFnUOc+uxSFWN+O957UTs1uxd3HPTcdve19K39axLg1PBFlOTJGN Nb3ei485QYWVVqjQYj/Od5ywwtkkcsGFkVroNSrHsOl7EKWfJj4dHsrD8/NrxBYXkv7YxhdaqOQi WjO2t612z2/204t/n32YqlIuJBYAANBp4lzC/aFlErdvba8Fdp6fFE8BAAAAAAAAAABoDaQWAAA9 IwiCkaQF0poSWVgolgOlZFKVSdvrgISZ8FwAAAAAAAAAlBIEwZU0/11aHZxVnwJdI/vvxve21wEA AAmXbS+gRu7aXgAAAABsn38CsHcGu03DYAD+M63aRCvBhSEOFXBD6gnxGLzELtx5DnbnPPEEXNlp iDs3JLj1ERiHHugSYyf+EydN1m7q6qT7vshy7NT+nSjbnFTzh9QCAIZA0rL/fl2js7PPcnLywgsl pBRZqGAirFephQoqipR5iUUmy2VWy90xt69JpRYqsnCp6t/UYu8KFideZR+uyd3OYVOhRSGyqKQS RSpEFpqnNRlFkYeiin+l1KJdaLGstatEGddBjO4flOPjVK6ufub7n75/lKdvXwVnZVZylUU4oYRu ucrCCy1yqYW5LkUUbmvKKlRikcstXNkLLVR2EbZzfbl97beMYlLJws34cXnBRfMc4A4gtOh//0MU WmybIQgtttGvaRarijbBRafcIrv937zys0ZW5RYmkFtUgVYlFBLUmaCsHHQcS25oF/bbIrSoHbdP 6YuXIr9tOngn8vyXyKOvc7m4mMt4PJbZbCbT6VQmk0lNbqEii1Bm0VbXJbjovJYwKEJ5xU1pNBrJ 38VifX/2HjFpqp1XQovm/dFW7z+fiy3W3E9DElrsq4yBWP2LN+SxE7M/cR9y7PuMH/u8+jIG5V6v sxdMJEG5tD14IYWTVORvsLyw4tAJLew8+dDPh/M8EF9o0jZOfqEmivLRwNY/sfOlZ0dHm0gtXtv0 xqYfUskqQrlFIpXAIgnqs6DcpslraveayTTyJs0njZVL3FEPAACwU/ziIefCP7VAfL4ZY1g8BQAA AAAAAAAAIAJ+0fPHkYexNYwxl7HHAAAQC/873UksTmW33wFe7jAWDAi/UN8X2aO5xsD5YOdKf2IP AgAAAAAAAKDHnMYewKa4d4H2OX8eexxwK5zQgvdkAACR8d+n7Q12PoB8HgAA4AHyXwD2zpilYSCK 46+llCLFwU6CYCG0k4M4uIm7Ln4Bv4Ofxc3ND+D3ELqoi4uLm4tQWhAhtT1zSV7ycl5JxJpL0/8v HLlc0nsvTWiT0twPUgsAQNVYNgqabD8PylleR4PBQXCjk+1OCiakyGKxoERkkcosVCKrmM1U0ub7 6TILMHSd+9L9s9wiipmKCFxQB5HDqqnDe1J8H+xCi/ScTGUWptCCZRZRXUsnWEAxi8UVUmrhizov m0ILmwhjLvrlPOx0Op80mbyE9ZvHa9oZ7oq9sgstlFKJOMImtNBCCim00HNTXMFCC5ZYsNyChRah zCLu44snFloImYVeDvNQUT48mfuwlrhO3XX8MoHQolyqKqFY4+NUWHChMo3pawp+dycD+2uxRTjw bePH52xGcGHKLOQwscuGf5Xbm8PN2tbxelOKQWJ7Y8jZxTbR23FQjoi2Lon27j/o5W5Eo9GIPM+j 4XBIvV6PWq2WVXAhRRa6zRRbSMGFWepwvbSpSGHJsuPbbrfpbTzO7Se8mZEyi+wGVomFteTF+SNl nad1i1PnWGXHg8yi+jE3Ma7L2K6vH+oss9BUJQ/Nf+RimhYaUSBqaDFFXOfL6WbQpgUV83jOQouM wIIi8UVLCyxEO4suWI4hbwMasUzD63bp3ffpeTrNS/skKA/0U2jBkgvunuvmOhZc2EozjqEs60jM 8+7oILEAAABQOYJrCT2YzS3hoQjgngmt0QNgAAAAAAAAAAAAAADUkL7rBFbIk+sEAACgbByKLCSv juKC6qOFFvuukwAhT0qpW9dJAAAAAAAAAAAAVSWWc164zuMX9Am/y60N8fl15TqPgpy6TgAAAP6Z Q9cJrBD8RwIAAADYUL4FYO+MddoGwgD8pxFUSIkKHZAYInWrsrJ2oawd+gZ9gE59BHYG3oCBl2Cr +gKVKnXqgITUBSEWllYK1K5/+/7kfHYSkAJnO9+HTnfnO+4/O6fEMeI+pBYA0HR6NeV3y37p+PhM dnb2nFBCpiILE0z4x/NN75OZoKKQVCTTdHdXzlV6MZkUdU0mtTCRhSZ/bD92TNiYuEoXrsnic1gk tAhT4o6HQgsTTvzzhBT3gajCyoXMolwP2++DsYqxi1j16Kn1+1dye3st7w/35dPpZxnszvY3CoUW JrEwoYX/Y0ILX0JhQotcVOFkFSauKAktXFspD4UWTmahZZVXaNliI7ToUPxY54zQ4nnjNFVC0fTX 6RHj2HtfRW6RlttK75Gu+JjP7mJjfqkfTwK5RdFpvtzCl1GkNf0XtSVevRf0XXTdtC375v7njciv LL34ILL3U+Tl1ws5P7+Q4XAo4/FYRqORDAaDitxCRRZa19xkF6HwYp7gonIdoTXME1pYm77+v29u 5O9kIlubm8UNl/+FJazbMVsHXjmXoNRJLMI1E4y5qjXVNdFEW0UM6xpr1fHaPHdiNifuOsd+yvix z8tYt3mYZGt6a+7qU9uDE1KozCJNkvyWuyKwyPpru0ks+l7Kn4Jpnj9DKvvnNNb2xoa81nul5bzN 0n6WvstMVuHLLXyhRc87nnj1ugd2oT4vTGmQh9So88qXeM5xAACAJyf7rNV/hjiJPQ8Ax5c0TS9j TwIAAAAAAAAAAGCNOYg9gRVyGXsCAADPgbfBnqaPkacj/K0H6sjW6ZGwAV6TaMumiQAAAAAAAACx 0Gdtr5b2ag66Ife32JOAB9O29QUA0GW6JLX4EXsCAAAAEIf/ArB39joNw1AYvaXdKAjUjQWkqp2Y GJnYeAU22JhgZoNH6QOw8AawVoiJAcTCghgYu0DaYHyT3MRxU8JPwW76nciyYzv2DSnEgOQDqQUA wCcm7YZm1q/rdFg2UKezSUot5OpMwYTIJ2IRBaVCClNsMRyqVFzB0gpOQRDX5wUY2bU8vowVz5lJ B3yhCiKHaVOFr8n4PfxWaCEii0xoYUotMknF0JBWBEm/IOlntpnXh/RVoUW9XqPX11v9PRXS8cke bR3t0uJq07irTA5hyiJsoUWkshChhRrFIgp9cLlIViEiCz7S86TMAgvuJzIMHkPyUA4Vjgk1op9B ltBipmUWjOvw50lo8df4Lkr473l8lVD4/px+OE5ObqGK26Q9Pc/tvV/y/rZEGNE40Ua4ecFFVC7S qU0SXBDlt4C1+9uyivqEenOcote39Wp/XyZ63o7T0h7R2vWAHs771O/3qd1uU7fbpVarRY1GIxJc iMhCcpFZ2OefyS0guJgt7GcnSZ4rw8/97umJgtEollpkF5fb+IpkFabMwq6z22g6n6GqSSaqKn2o uqRh1uQsmLP6887z3H85v+v78iUG4T9isU0LtXhiqrGYIinL8lmW2SGvd3S7CCtYYCEyC+4zJrvQ SUQXIscwl/21RKbRaTbp5e2N7geDsrBZxHxD40ILkVzI8FK220RwUZTkD92qoI2MvOy3MkgsAAAA eIFeT/R0tu86DgASLpRSPddBAAAAAAAAAAAAAAAw52y4DmCKYMMGAEBl8U1kYXDlOgDgH/rzuqOz U9dxgBT+v+yl6yAAAAAAAAAAAADPOXAdwDdZcR0A+BZnrgMAAACQUiWpxaPrAAAAAADghg8B2Dtj 3LZhKAw/JnEDxHDbTEULAwnQDgU8BF27tHNP0LEXKNBD9AZeMmbOBTIFyBHasUPu0KJBADeOVD6S z36iJcODIsrM/wUERUrke5ITWUZgfpBaAAD6TN2ywlNbnq4bNJ2e0+HhyyCUWK7JKoIJ3e8Wvi9W JRXzeeH6vdiCZRZebnF/Xyy2fdsfLyILLnpuHbtv5CByaJscrklZekFE9RyKsG9VaOHFElpowfWc lnILL5/wcop5kFOIqKJeakH0L/SLxOIuzHWn5uQ464UWgwHRzc1Pt/399Cu9/vye9p4sH12ahBaF nZtrlksspBY2rlNZiNDC5sS1k1TYH5ZWOHkFzVa2pS3CC6eyiIQWIszQ8gwnsqASQouc4qc854eM 3XdRQtdx+iqh6Pvr1MI8WgRmalxnjffNSFqxSV6LY8ulLENLLkqjBspys7Hcgqj6tqrjaUlFodom GlPW7KNozjXn9PcN0S9bdj4Rvfph3zsvr+ni4ppGoxFNJhMaj8c0HA6d3EKkBiyzYKEBt7kWuUWT 4ELLEOqu8TY/N+VKk9RC72PpCXM7m9GzgwMZuHkMWvNnryUWNVILCC3Sxck5Vtfx2oyV83VKGRNx H0/sh4yf+ryEvuTBJLuHBMGEUW0WUWhzxG4QVhRUFVjshWdgEVzsKKnFbjjejXOC1OjR3/Y/Hwzo xf7+JlKLt7a8Iy+2EFmFTlELLYzqL1S7zkYba/XiEn+qiKlR5VUvcUM/AAAA0DphkZsrW04SpwKA 8Ie278tfAAAAAAAAAAAAAADkSE4LNkBqAQDIDmOMiCz6Kq7HvRdUCP+bPkudR0/hL2v+Vu0PHcX9 1lEcAAAAAAAAAABgKzHGHFN3n9Pb4mPqBMBm2N+vL7Y6Sp0HAACABcepE2iRq9QJAAAAACAN/wVg 73xWGoiBODzVgyCih55EBKH2KPgE3jwIPoRPIj6CvoEn7z6Ct94EBc978uRB6kHpv7izyaRJunWl VJPd/j4I2SZpZpaWGkuZD1ILAEAqzKuI5o6f5+2saqP9/UNSas0bcwUTIp/QIgqyQgpXbKFlFpNC bsEiC+5ZZsFNj00FGPJc3l/20jH94sypwjmmVBwvBeort5i+30RgYWt2zwgtRGAxMY/HVjShxRNj I6WQfhgILUZGYsGPB3bOn59e+/uJzGK+0GJjQ1G//1xcX99f0t7pUXCnvxNaiGCCBRZ8LSIKFlSw mEJEFYW4wlx/qS8rtXDnZL0IMaQXYUYRM48/T2gxce4XQosaxofQIk1SFloskxUQWoR7yOdkmdwi nLefqc4eutBtdVhb6J/3Ub7YothSqXLNWii4CMvMurHXyf8THK4J5yhYE8ovwjxyJttErye6bWZE u70PerrrUa9H1O12qdPpULvdLkQGIrbgfjQazYgsysQWZXILafU9NzUXTxBTIrZg+HVmPodDO26f ZwpF234eJcIKT2YR9K1w7YL8x3utrnIExKpfvDrnjpjpxF3l2H8ZP/Z9CaucR3isbulEqJWfT0RG IUftNTM25jOruebmCSzIl13IuIguikb+Mb9lZBqdrS16Gwzopd+vSjs/kdMjzQotRHIh29vUgzkR XJQ1+cJblcyR01f9JwSJBQAAgCjk5wkuSHZLEFqAtLhQSr1XLwMAAAAAAAAAAAAAAPwxTfruGIXV AQCNwBFZcNuJnE4VWewEQHLcEor0PZAuJMVnk0wp9eMZxYhAjk07MP2yCmne5PGzJe0FAAAAAAAA AAA0lYvYCSzAQewEwK+5ip0AAAAAjyb9RiKLnQAAAAAA4vAtAHtnj9MwDMXxlxaQuhUGBtSBATF0 ZWBgQVyAK3AUNg6AuAQTbDDBARiRkOASZUF8xtjOe8mra+iHKEma/y96MnEa22mj1knQ+0FqAQCo KrH0wXvjdjo9PafV1Q0WShQ5WEUwoevdeiizcJIKJ61w9ZnYwtD7e1afyS5EcPHlS6kXUYZuW/dd dZCMOE693pfwRMsyYMv5mB2C5MYzSmiRhYgmhoUWn6oUOcVHLrMopBUfkfViv0Jk8ZmLM37Lndfp pDQY3Pu/z25OaH13Sx2VGSlFFuGEErJ4lQULLbzUwo5HhBaudLIKH0pq4Rfz9qPQQvaTNqTdvBfz RaleDI+LBRfhMdSWsocPoQXanlcfVW/vr6mS0OLX5lVy/ojgIvad6sUU6XBS/0nIX2fikguTKHlG KLPQqWQLf1TxmlBQYabcRjTqgpLtet3yskn0aGPpgGjjgah1/URXV0/U7Xap3+9Tr9ezv7UdO3dN /TFL6SQHUo4TXIRyi+j7CEollFlIyGcnUouX19dJGxxfryQX/tRttfJ6L0CR7TNeIP3XubVo/Sxy X3Xurwmih6aJJZoolSj7Nx8yi/+jCmNJeA7hLRAstCA/X2fbAwsp2iysSGlYYLHEYjdfssSircLf HXOlu19MlMstDPfdXV6mtZWVSYa6bWPHxh0Vsgott9BCi0TVp2o9vDqIKfLCCK8iQnR9bDIG0QUA AIC5wkKLW6p+shvQLC6NMRdlDwIAAAAAAAAAAAAAgKbD95AXBiRsBgDUGfudvE9Z8rw6iCw0EAqB HBayHJY9jhJ4tuGef17M8hzU7jOg7Ln+ra7nuZqLfY5pZSFuXMfTjgcAAAAAAAAAAGggR2UPYAaa LhWtBUmSHBE+KwAAqAz8PG5ReMb/SAAAAADN5VsA9s4fp40gisO/WJaorEQYBaVAsuQ4OUMqchTK HAMJ5R50aTkADY1pyAEQDTRp0lhQRFheNjvz5pm343Vsgu3949+3Gu3s7O6bt4OxhkWaj1ILQkgV mLcymm13L8a+LQp0cPARaZoPZwUTKp8QEQWmQgorthCZhcgrkkQlFk+hTQQX7l4RWjz5e1x8jSV9 PgsR6kS9JA6bQ6QQVR6TYqGFr6UqtxCZhawBOCuzkLoTUaiAQsQUeanF2NT1OBZaqMhiYu5PTNzk n0+ys3OP0egWe3tv8f38BLufPpinKhZaeEFNEEcUCS2ckGKSbVZM4epWXKFCC5VYqNxCpRc2xkQ3 FVoYmYU79nmkko9u8TPUlpqn/19QaFGt2Ovqo8rx1jGeVRNaLBlnacGFiadyCl9/idwilX0stvDh 30QJxzILPdblaONr0+j6dM45K7EoEmmg4Dyez03eA7+ygkOgcwPsX45w9WOI4RAYDAbo9/vodrto t9tedODkFq2w2K8KLWx9kdyipQKDeCzJxpkntNCfh5Va/BmPl4qX+9tG5RT5i6Zt/vqwh/tcZOW1 XxdNE000VTLRZGnCKvtq8jiV2Sf73Z6+19l/2c+lMA+TA8x0OYgr/DzDiSmkcWqIaGVtTlCRuOtC faYgL7vQdhVdtGwfWoJM43Ong9+Pj7h+eFiU9pes/MSs0EIlFxp+mnp0TgUXRUUn3WnBOZj9oukX JRaEEEI2Rlgw5BT1WvSGNB+3cMpR2UkQQgghhBBCCCGEEEI8vbITWCEXZSdACCEvJSxYfwQRWdR1 YTNKLYgn+zy/g/x/epu4g0gjzoKYYqVkMd3vlyun7jgb4x7k++IrlpOHHK8jL0IIIYQQQgghpEmE xa1r+W7OvV8M7w9IdTkuOwFCCCE5emUnsEI4ByCEEEK2mL8CsHf2uFEDUQAeC0uRVogQUbAIihRp WBra3IBjrETNHThCpCg1ESUXSG6RggqlCR2iQkFpQmQzY8/beZ7Yq4Xseuzk+6LR/DiZ92x5be9G Ox9SCwAYIllL+8iWx8v+6PDwi9nZeeGFEmYhshDBhB6vFsGPZBa1sKKoxmuxRWmur0svrwiiiyC8 EDlGEFvoWBJ7jCC3uM1wj8kyoUWh+vWaeLV4pbD7USqhhQgnblQtcoo/UbuWWTT78XaRY9yoOSVW N3n+01xe/jD7+2/M+88fzPbLZ2qvmkILkViI0EL/iNBCSyi00EJkFSKuaAgtlMhiUdvSEFp4mYVr O3mFa0tshBYbpu8c7qvQYpMgtBi+0GJdJBZjyDX1ltyibG5rtNWD2dL7eWPt/mwxJvPpeReCi1g6 YaK2vh1nUd21TdpFNF/bvDr3LOrb8nvPmG+25O+MefXV/srJuTk9Pa+kFrPZzEynUzOZTKrnWpEf OKGFEx+IAEEkFl2CC5GAaXnCSscbNsIysYWWWvy6uvrnecvQqfux0EJLL6R9h3Ogj/NnrHIEYo0v 3phzJ+Zw4j7k2JuMn3q/BPJoJzyXl+FxuTa3BtuDF1I88sKKwrel5F7gVtVeYqG3V8pXV1efNQVH nci6nuS5eb61tYrU4rUt7sv+ZybIKrTcQgstMjVeqH78TqFNiReX+B1FTIsKr3mYO8YBAAD+G3sP ndvqU+o8AFqYs3AKAAAAAAAAAADAYHibOoE1cpE6AQCAVfAL/3804xZZCN/5vw8ojm3ZTp1ET1Qy C3v+H/cZ1Ma7sNWBL+564q4jUuJj716fB33mBwAAAAAAADBS5qkTuANPUycA3fjvdIz9M2AAgPvG buoE1ghSCwAAgAfMXwHYO2OeNmIojr+LslUZItSRJSpSBr5CUdQObG0/QAc2xjIwI75N1/INkBgQ HwDmDAwMVGqZ4Eji2me/9MV31yjqkecL/19k2bHP9lPuFF+UxD9ILQAA2tTtkCbrP9m0v2yg7e13 ZExnoU4KJtxm/iyymM0o5ItiCy+zYGmFz/OcRRZecOH6suhCjhWLLTaBdEUOeqT1mqwmtPCxF1v0 2evWiyaybDaXTng5BYsoXM6SiucgrciFxCIPx7HgYhL1l5KMfwst3J7Kj4/X9PQ0peOTr7R7+JHe 9P86bKQcQsoiYqFFobJgoYWZeBGFfbhylayCRRYstWDBBYssCg1GkGG4MTif8sNMS0KN4j0nElq0 XmaRChBapD9+G4UWTdMGoUUT4yoLLRaHEKIKk9W2SaTgorSe18TEx3FfKbYoumWiY90WslJiUVVP tLh0Mx3RVrWc1o1bIdeYvCW6/WALe0S9MdHW5U+6+n5BuV3Kh8MhDQYD6vf71O12C8GFS52w+S8L LWRZii7ca8TPWZzgyqVwk7iHeh3IcxEnPjd3v1b4D5c8d/F5jMQVmROdxHKLFVnXtbJp82zyXOue DzKL9Od8jfNqzq29hkNmsT5SiyU2LWS+wd7/G3+r7KQU4ZiOrXOCiqm73wnlUiIvu+gG+QXXs+iC 5RjSNZcFmcZOr0f3eU43Dw/LQn9P/oc4sdCCJRc8/Dz0qI0FF1VJfkKI20jkyz5xQWIBAADgRYHQ AiTMmTHmh3YQAAAAAAAAAAAAAACAOSPtABoEGzYAANrCgU3ftINoiLF2ACANglzhs3Yca+A3eZlF ErKI8N1r8f1rheDiSDE0AAAAAAAAAACgFQQB7RftOP6DkU3nyjGAek61AwAAAFBipB1Ag4y1AwAA AACAHn8EYO+McduGoTD8BCsGvBR1vRjJEAPpUHjrmqXdeoWOvkBukRN46pg5WxAgc04QIEAG36Bj CgRZYkMsSfFJzyztOI1sSvL/AQQpSiKfKCdkjIAfpBYAgLqRBMrfXrtpOr2kfv9QSCXyehZMyHq7 Eb4ns8iFFZmtz8UWil5eVCGvMOdMKoUXLLHI21pum8UH9dkA7r3US+RQD+KOSWi/uXKX67DQIiMW WuTlBZVyi4Wrl3IKU/alFnMnsTDXl4KLvJ4FFnMhtDD9rBdapGlCz8/3tnz+64xOfp5S2i2XJ6uE Fplu2+RGLlFILXS/VmXBQgsdn8lZUCHFFX6Zj1l4ERJasDBDyjOsyIJU+4UWsR8jdv+7BEKL3VJX CcU+vKctxMK/c5PAGkyeWyrL+XzDmIq5X5XtFe0qIbhYJ7fg80pc50soMu/Y0Flx3yoxRhJow+R6 qn36nKf0B9HRg57Br2d0czOjwWBA4/GYhsMh9Xq9f0QILLBgqYWUW4SSvF+OH9aV28MX7Mmx9sf/ 9+Pj6obe+I7sx8y9cyX6UKLPTX/02yaaaKqIYV/7qrq/JseOPuvV9z4+87b7j/1cDOIIE4rHrid4 Dc/XWOmcsz04IUXHCSsyV+aUOmGbzZ3EQp6335yZ3IpUqZBb8Nrmw8EBfep2Nwn/i05fdbqjUlYh 5RZSaJGI+kwcqzWpGAIv+X8l+Mj60NIMogsAAACVoOdNs3lGWzbBAe3CbPAyiR0EAAAAAAAAAAAA AABgiVHsACoEUgsAQFMYxQ6gQm5jBwDi4zZ/vIgdxw640mmilPoTO5AQnuDiuz6+jRsRAAAAAAAA AADQCFgO2VQ+xg4AhEmSZKKz49hx/C/4fgkA0GJGsQOoEPyPBAAAALDH/BWAvTPmbRqIAvCjytCl KBISEzQLTFm6IjGx8DNg5Ecw9CfwE9gY6X+oxIrEwAwDI0jpaCU1fr579t0lriM16TnO90mnO/vs e8/JYLup3ofUAgBy0lUpLdz/vGof+hY6P38hZRkvZzILRcUTJrJQ6YTrY7GFk1mYtML1ReFEFjqn ggs910QX6VouZltEdowiiDFe0315+M8krSvX1rJzucQyi7qMdy2Z0O1VJJpwQoqV75dBbwKLpZdY 6HbRyC7i+XbcrrXyMVdyVx2809NSFosf9fjT14/y7O1FJIHYVmhhggkVWOjYRBQqqFAxhYkqanGF FI3EwrbDOTvehBjWmzCjjlnF7xJa3IZykbHUAMx9GTni57pmhBYPG2eoEoqhf0+7WGcf11iGw365 xRqBf2nbe3ojBzA5RrJ0I7eITopzbbZToUWYgt3SuwQWm9xRqTgj3BeuW7F8KvLnjcjJK5HHv0We fPsr11+u67n5fC6z2Uym06lMJhMvcLutZRVaDFiFFtanMguTX6RyCx2vpcuz5U4JRSJdzb6jO6UW 7YLx2Fo6b99teIyPV6bn9OS/b8YqYyDW8OIdcu7EHE7cY469z/i5r2soORhDykVJ80kdcP4geaRi Cj82Q8RJtU8FFSt95vHjtSZOdjHx8gvbb6ILk2PY43fdSvc28fLsTP4Vhfy8uem7jNdV+y7rQguT XNjyTerJnL0FbGr2UF1umAs/pr63LyQWAACwc6r7+Oeqe5c7D4AOBlvgBQAAAAAAAAAA4Ig52GI6 G6BgAwAcChe5E9ghv3InAIPgUg67+GMfC3G/dV7lTmRbKDgIAAAAAAAAsDXvcydwT8b0t8axcZk7 AQAAiPGS7tH8jwS/BQAAABw3/wVg72xSGoihOP4GrSh0YSlicVVXdSseQA/gwiN4A+/hUsRDuBPB C7gXXFRc6hHqsurUvEzezJu01mI/Mk3/vyEkk5i8zAdMqJAfpBYAgCqRjChfm7QxrtPV1S01GntO KEG5yEIEE7o+24i3LLNgSQULLLg+E1sMqN8v6iUVwousn4ylx9axhRhFEDFe07Qs5p5MKrQQmUXq ylnKRBNpLpwYLbPQoorPoXL5XPfTQgsRZ4wTWnxRr/diyzePl7RztF8SWPi5yCJYKCGHVVk4oYWV Wpj4IrTgnGUVNilxhT1YYMHnqpwLLUxZjyHj5lEG35TqY+Dm5QQXxZOJZD/A0JexSkKLeVN1UcKi 41RVQlH157QEQotyddEwTnBhpRS6/I9vOvezG/ebQ4+RxxLBhS+sKAYo2uVTLrvoMmuqzRdb/Nam +/vt5I1h8nSL6OMgS+unRDuvRP37Lj08dKnZbFKn06FWq0X1et2KLfh6teBCiyxEduGLLjjxvfEF C1hbzp5REgt9ztRqtb+lFvy38j77z8cXV7i4JYGFtNMEOyov6PnHFifmWIuOB5lF9WOuYtyQsUN/ l2OWWTBVmQezbHMprR+lD68x3bkIKdacsCJ1ZUnrbv1qcyex0O32VzTO+bdfN16+lDZ122YNtbu5 OYnUwqys6dCkJypkFVpuoYUWiapP1blvsNUpvwVeGni5j64ftUSD6AIAAMC/gdACVJy7ZdrkBQAA AAAAAAAAAACAVSBJkpPQc5ghPUh1AQBLREwbzUEotOKY9QS/zxeh5zFHnk06M+uMt9ATAQAAAAAA AAAAwGxJkqRtsuPA05iWdugJgGHMu3VOEW2aDgAAERHT/+jeQ08AAAAAAGH5EYC9M9ZxGgYD8E8P pJNOB0KCCfUGxMLQjZUXgJfoI/AoN7Mx8xhItyFmBiRYgAWdqhMLpA12kr/313YuJ7XBSft9keXE duzfSXXnSpU/pBYAkIu2Hcps+WuXXnV1dHb2TMpyszsrmPDiCRVZrFbS5Jtii1pkodKKOq+v6zqf +3t9rvfYvuoxJdrAOIypmuCANorbln2c07b090xuI7RYrcvbhRYqnvDXKrSwkopYXhGXWQFGse7z ut/ljTM5Pv4ti8WX6vztx3N5+PyJmVVaaFFJZBpxREpo4YUUhTt8rkILf+7FFaHQohJZyJ8NoYW2 1z4KPVRoYWQW/rqKo6zj0SOcw+jJPY1DE1r0OfbQRQn/e5yhSiiG/p5GJrSIm11LK6K6tvWbKb7x /7pt1/SvgotWuYUltWWsFVKE29LqmKuWuqW5706in3AL3HAuLhWPRX64NHkhcv+byKMPv+Ti/UXV ZDabyXQ6rUQXKrVQaUJRFGuhhc9DoYVKL/TaCheix8L6cmtSMgubvNTi5+Wl/HXv697RUVdn9Ree lLBCRRZhe1vW8T73TTQxVhHDoY616/HGHDtjDmfcQx67z/Fzz0shjjRd8YRL2+amSjQxac7VEDFx ZV5QsfTroeY8SlLLLu428gstV9HFRPszwgyN4enJiXw/PZXPV1dd03rp0ieJhRYqudDV/Dr0oE5X /amki+gyUWcfU6db7BZtAAAAOkFoAQNn4dI8dxAAAAAAAAAAAAAQsU8bNrCpOgCMgmajvAeZw9gZ ZVny9xfOcwfQI+/cZ3yeOwgAAAAAAAAA6I157gB2AOKEYfImdwAAAJBkn34j8TV3AAAAAJCXfwKw d8Y8bQNRAH4GliC1FQMdyJIt3Yq6dKQj6tihM0ulrv0rDP0RXbox8wdaqUJd2TpWAqRWItC492y/ 5OXiBCpMzzjfh04+3/nuPV8QuUTIH1ILAGgLWU39/U2DDg8/ydbWTiWUkInIwgQTvr14KH4ks1BJ hQostN0EFqNRPpFXXF2Vggs72jiby8/tYy+jiyKILt7TXWl2TZYJLcbuvHzWXRk7Flp4kYUXWlzP SSzmz0fVeN9mcoxrN+efKmY9uhRraz/k/Pyn7L9+KW8/vpNHT6f/Bx0LLUxiYUIL/2NCCy+h8EIL k1WYuGJGaOH6/PUzQotKZqF1lVdo3WIjtOhofIQW7aTNQosmQWjx3+b0f6cLAUVe3699M/VF7+tL ctBxJrfwc0yGmuDCHkEb132bF1EY61GfXm+PyZVoTDxXPG/ddiW0j3siF8/Ksv5GZPu7yK/PJ3J0 dFJILYbDofT7fen1eoXgQu/XRBcqtjCRhUksTHbhxRZaigcFR8IF9pd3Y5HIwtbTpBZfT0/l9+Wl PNncnK67CSxuilFOVP5KedHFNIn64ubummSiq9KHrksamoq3KqKHVYmZMu4qx77P+Knvqy05GG3K RfnXfGb2izbeyScKKYWU0goVVoyrupWNam9aHCuJhe8vvm3TfarubSXaOofrH4d91E7YA99CajEM 5UUoX2Qqq/ByCy+0yFz72J3nS8pkCaKSR8eY+FPI3BIvaAcAAKgFoQU8AA7C/vEsdRIAAAAAAAAA AAAwxyB1Ag1ynDoBAIBbMkidQIN8S50ApCXLsoNw2Eudxz3xIc/zLgs7AAAAAAAAAKAbUgv9jmYX +Wx7CK/Hq3B4njoPAACoZZA6gQY5Tp0AAAAApOWvAOydsU7DMBCGj4itiBaxQwcmpEoIiRHEyMLM zAPAzMij8AAM8AZMHRnZkMrGgoRYQNDU+GIfde1EqUqC2/B/lWXXTs6XVGrdKs0HqQUAIAZFdylz +491OSoLtLGxRUpNhnMFEyyeEJHFaES2nhRbGJGFSCtMzc+NyMIILnhfEV34scycFNyouIwm3qi3 icf0W35/TmYXWoxFEymNxRYioRhaSUW+1MK0P53tvib2nZRjlAstkmSJ3t/NtcLnFye0e3ZErbUV 56jGcghXFuELLTKVhQgt1NCIKPSD2yKrcGsWV3yoj0BwISKLTINhZRgcQ+pUHioNhBrZe4wntGiM zIKJfSgQWiB2XXPMe7yqmSehRR1UkNf4JrjhZ3Th+7rTnbdfHrKdCC6mkluEQUIJhVszctvbojHl jRfF9fe326brRM8H+jN9j6j9SLTef6H+dT8b6/V61O12qdPp/EgtRFwhcgsRXLjPpc+VXIh4gdvB acAac2rKhBYMSy2Yr+FwpvjKez2WfMGF28557ZommmiqZGJRBRN/PVeTz1PMOTHv/5m7zvljH5cw L3kwi5yLv5S1QTLRRGLbYohIdB8LKlJeW9p2UMjILpat/CLr0+tQXtOOrOwiyX6bCo0R3VaLtldX 6eHtrSztfV3uKRRaiORCVt8/qXtj/vRucZV2/ph7msq+QUFiAQAAYGYgtPhznnQZ6MJ/+nm17YEM KqXupgnCfxzSVcfrPsxp83ZtWmxu9Xm5iZ0EAAAAAAAAAAAAAAAgl53YCVTIIHYCAAAwJYexE6iQ QewEQHQuYydQE6dKqavYSQAAAAAAAAAAAKA+rHhgM3YeFeFflw7ichk7AQAAAIXgGgkAAAAANIZv Adg7e9y2YSgAPzVxAy9BA8RD68WLM3XL0LG5Q3uAHKFH6NY9c0/QNUvHdM9QICdJkCJACtAlJT7r hZWsGPGPJH8f8ECKER8pJghoyOCH1AIA2kBWUf/Y1Oni4occHb2LQgmZiyxUMGHb84PxE5lFIaxw eXuoF3KLsr2QWpSl9tNcNrcde1n6KILo4zO9lOXXpOqPqZRGVAstnPwvtHCJfEIlFuHw4r9J/bFG cGEFGCq10FxOmoQWg0Em9/eF0OLb9y8y+fxB9l+XW5A6oYXzuUMZ5BJzqYV/hlxloUILP69QqqDC iivSul6r8KJKaKHCDCvPyEUWMkNo0VcQWrQr97rGaHO+daxn24QWbVz/ma2WF4sEF+FndfXnEu5V uUWeY76JjEXW8HD2qNlZUrfH4Kbyi1cVfezxts7ca+UaidgilG4ocvu+iL1PIm+vRf78vJHLyxsZ jUYynU5lPB7LcDjMDwO2wgoVWgSRhW1TsYW252vk1yYVMrDHXA4rCKkSXKg45O7hQY4PD9POxYcb LZO8teKKNAIqKDF9NvE77KocgbG6N16X586Y7Rl3l8de5/jbfi6FeVTz0vk82R9qvrCHjNe5kEIK aUUQVrhY19iPe9G8jAKLILTYC0IL08fFPE+22f7+N4OBHB8cPGeqJz5OfVxLKauwcgu7k89MuzPX swUxX4IkUh1eim2v+iCC6AIAABpBaLF2fvm4kiix8Huf36tKXJPrqu5+I8E48zGJ0fg+vwXc+jjf 9iQAAAAAAAAAAACgFg5sAADYPJNtT2CFrOz9GXSPLMu+Sn8OfrQgtAAAAAAAAADYDc63PYEVciYL vosOmyPKUrrwPX8AgF2lT/+jeU8HAACw4/wTgL3zV4kYCOLw3IHYnBiwFCSFloe9hdiIrY9gaekT iI/gg9j4BgeCnY2dnYWNXCOKIMIl7iQ7uckmMZGLSUh+Hyy7yWZ3JyF447/9ILUAADRN0W5l+rxv ynnZRDs7uxSG6em0YILFEyKyCAKydVpsEYssRFoR1/FxmBQey7WM0XPFay6FBavQx016+3hPq1Lt mbjv03KPunh8WmYRbbcdCSv4eJESTYiAIq61lGIprWCZRVpikRVa6PHL+WSd4vd/fT2k9/fHqH19 e0nbx1N1V2GmLhJaiGCCBRbcFhEFCypYTCGiikhcQd+JxEKOdZ9cL0IMqUWYEa1p1i8SWgRaLtKn vf26cCtNx9BXocV/AqFF94UWdTEQoUW2q1hUkfqar+fQe/tXFFzIdbIRr/t58qvcwt2eNig4T6o/ ry9Q7bFquyKLvC1xbd9ii+jlxAw/JNp4JvLu5nR/M4/6ptMp+b5PnudFcgsRK2i5hQgu5FgEF/pa LWQQCUPqcSDPLESem27nSS3ePj8rz5f7ZrqCizyxhW1H8fC6NXz/VBZrE/RV+tB3SUNd6w1B9DA0 scQQpRJtf45CZtEcXYqFWSUendIms3CewWIK2xZDxNicY4HFgnMf284UimUXayZH4bw1ud6OkVrS ap0e700m9Pr1RU8fH2VhH5jyQFmhhUguXE2d2+cur4tW2Ll9+jGVJWCQWAAAAPgTEFrUDssXZlLq FFjUgYpnps9b2QWXI1vvNxpYOWcm9re2gwAAAAAAAAAAAAAAAGQZjUa+qTZbDqM2wjCctR0DAABU pE9CoU79Tg00h8kjPFNdtB3HPwChBQAAAAAAAAAAMADszzZO246jRry2AwAJV20HAAAAIB/7NxK9 oWv/+wYAAACA5vkRgL2z12kjCALwnAQCN5EoIlmuSGEpLcoDhEfguShRlDp1KiKa9OlSREJI6fMI FhIFhHV273Z8c+uzccSixefvs0b7w+3s3oFgi2M/pBYAUJqqp/7Jx8G6QRcXX+XoaBKFEu2ZqCqY sP2hncosGmGFq/tDvZFbtP0PD65T6jjNZXPbuXMwRBHEEO/puax+JpsKLVRm4WK9iUZuoWVXZqGC ilZUcR/776Pswsotutc25aMpnbQCjf7v7eHhX5nNftf1zz/O5e2Hd+auloUWKosIQgn91CqLKLSo pRZ+XSq0CGWQVdRhxBX1JwgsQtvUF0ILX7c5NO9ilvmjOPuJ96iCi/QeIBMILV5//m0UWuRmG4QW Lyx9KJInZ74Nc9jf8UuiinlXfmH/pq+TYqxaT7hWx9p8i0vWCS70uFsrqkjRY3A1qmRcKrCQpM+O E3Od+bobidy+b2LvTGTy09e/38jV1Y2Mx2OZTqd1ORqN6oOCrbBChRYqs0jbVmwRnk0qZmCf2U+f xMJKLgIqtZjd3T2VrBkXnnUiqVhq94xd5JDw81whtGCuYvPlnGvIz6nknMy7O3O/5Pyl70thHf3k Xk9nP6j5w54xtmshhTTSChci1jX2osjCGaGFhjNjXMzT2Vb7ed7s78vE73E3kFr4nbKc+PglrazC yi2s0KIy/c60U9Nt324+jXlSptj+vk0aogsAAOgFoUU2/vi4DLGth53FF5BDfAlt8w9Wp7EseSDd N7++y4LzAwAAAAAAAAAAwHqOSy8gI9elFwAA8B+8Nkn5c+CwnN0lCC0GI8eKILQAAAAAAAAA2B1K v2edmyGJdLeWqqpOffGx9DoAAGAlx6UXkBHekQAAAAD5JwB755PSSBDF4ZcguAjEiTOzcGNkGGaX IwhhNi6EOYNXmBsI4j28ggcQRA/gbnYzhFnpQjDizpiyXnW9zutKNy3a6Uo6v68pqjpdf151B60o qQ9SCwBAnRTtWqZf/2XTQVlHu7vfyRjdbCaaYFg8ISKL6ZR8nhVbJCILkVYkeXJu0sRtOZc2ui83 qqG5jYerookb9DZxTh8le0/eIrSYpq8XCy1YVPGiJBR8PpNVzMrPvixSCz6XstQLpRhT1bcSPATP dnPzicbjf/Tl8xadXpzQ9o8dNat8oYWTxnhxRJ7QgoUUE3twHgotnMyC5RU5ZS290H1M5BChhZJZ 8LmLwyTxyBHOoTHEnk7s8esEQot6WVYJxTo8p2WKRXhnTBlRhcm/Ntd/SxcL1j1BX2m9VlaWkVYP 5RZ6+1lZRhQJLAIJRSq/aKm6RLNlRitoo+uFYwZ9TL4S/T8kav8k6v616eqWrs9v3bXBYED9fp96 vV5GbiE5iyy4HAot9LluI2UXjlpfYq2Z/Ywi9yPM5d7dl2/CXIrbUFrfdy25ECnJgp/LqsoRMNbq jbfKsWPM5Rl3ncde5Pix5yUgjnwq/VlM8142J9Gya6C2L8vSuG1fY0nFC68dfbkobfh6aX3fRnIx TOjl8rdOh+66Xfrz+FgW9r5NNzQvtBDJhayu09CDa+HwOrX9GCbnmr5NZZ+KILEAAABQiv2dzpuD QGjxfkRkceaFEI3CzumBEsEFJ36/8BeUjij54lW/xlDGflwAAAAAAAAAAAAAAMDyMowdQIWMYgcA AABvwf/vpjEYY0axYwD1Y9/HnyiRWjSJ3xBaAAAAAAAAAAAAa0XT/raxFzsA4DiOHUDFDG26jBwD AABUyTB2ABUyih0AAAAAAOLzKgB7Z6zTMAyE4Qtqi1hAFQwtDHTrgoTEwggSC2LmAeANeBOgb9CV mYERZsTEK7AjKjEgaIIvzjUXk5ZKpHFJ/w9ZduzYvriRagnwB6kFAMAnQU756LdOvd4NNZubI4mF HNgqZRZP6DZXZmGFFWFcz2Urt0jrPz/DTC79ZCw9tpwVOyOvRTJ29UQQVXymv2JlEXpNtNAiVNf2 DDu7hq7QQosstNDiy5FYuFILK7bI3qf76jFljnHPEdHS0gsNBq90fLJPp9fntLa1nrY7cgiRWIjQ Qv+I0EJLKMYJLbj8QR+p0EK16fszQotEZsFllldwWeaG0KLi8/t6Zggtyp1nXiUU8/45FTHOLJ7x r2MWEFNGEpAjqtDyC73XyUgxpkDuk75TCS5+DpKVVbjIMbqutEIfheueEqzrXMEFJX1Ve7hCNNix qXZK1H405btnur19plarRd1ul9rtNjUajfhZWXIxHA5j0QLnWmQh9a7sIl4jszYiuJCEvWZKnvxD S0SYt/f3/L405hWSddXiCt2m5Rk8b/wuky3PiLI+66pKH6osaYDMYv7nXMR5fc7t+7sRMovyWKRY Mvs/mY/3iMl1LKQwOYsqQk6mXDP7kljbqiQXWmghKVR9wmScjEPO9F+t12ljeXmaULsm7Zn0RKms QssttNAiUPWhuo4mpNESOMnV3bno+rztH0QXAAAARpjv2TOTXfqO45/SJyuyuPcdSJkk4g7+p6sL 8/6w2IJTGVKUs0SwAQAAAAAAAAAAAAAAmF86vgMokMpJjAEAlaXjO4ACefAdAPAG//5xzXcQBdKP oujKdxAAAAAAAAAAAAAohyAIOibb9RxG0Wz7DmDRMe/VockOfMcBAABgIlWSz+NvJAAAAABA3wKw d/4uDQNRHH8p1aUqTs5acLCTro5Ogv+Cg6OLm7P4n+ifUP8DxV3oKDgoLjqKKKKpZ+7HS1+urRFp cmn6/ZRw10vu7iUp7ZHC+0BqAQAoi3HZy2S7fkB5mDfQ2toGKZUdTkompMhCCy5smRVbWJEFSyts ad+rdNN9dcl95FhyzrKoY3LeOp7T/xDCBGXz0PElyRNasGhiIJvoCxlFLAQVw1ILW/8Ux325vl+u LRZjx678HnsWc3MNenvrmfrxyT5tHe3SfGuQ1E/KIaQswhdaGJUFCy1UbEUUyUvXWVYhpRWpyMIT XLDIwmgwnAxDj8Fln1+qPyTUMN8nntCidjILTehTmiWhRdFUXZRQ9jxVlVBU/T7VVWgxCZT/dryo IvN7IfuJQyP1t7VPOn6UlWXwuL/KLWTq2UzmXRqkzuX936KPPJ73cT85JtdlXz9lrjs2XiF63Eua d4iW7ogWr5/o6uLJSBU6nQ61221qtVrUbDaN3GKcyILb/HaWNPgCh8zlmMH1pi/7kJuGr9PL+3u2 n+2c1tPPHUtD8ie2x0npBd+TAu4DhBaYq4z5pjl2zFmtuWfxnIueP/R5MYhjNEXG4y9N3YRGNNFw dTZENJy8ou/a9BLWiCz0GlOILXy5hS6NFEOP6Uo2TMjl7/rCAj1/fNDt62te2NvJdkPDQguWXPBq Og3d2+dPLzepqPP3ycuUt5yDxAIAAMBInNDiLHQcU8ZDsunkI+cQLJhnTN2k6CafpdOkPKDiks1c uLkAAAAAAAAAAAAAAADVZjV0ABMECRsAANNCnZLl3IcOAJRPFEXLZP9nrAs9pdRB6CAAAAAAAAAA AABQKnV6tpESRdGmUgr/l4TjNHQAAAAAclkNHcAEuQwdAAAAAADC8yMAe2eM0zAMheEXiUZlqVgA tRJjBwbEwk5vUI6CxAWYGSuxw8rWkZETdOgFegAWok4UEuw4jl+CGxVIa5P8n2TZcZq8lxApliLe B6kFAMAVgWV8T6b4lpXJ5Il6vcNMKGEKrJpt06R8oiyzUMKKOJ2XYyW3MPOrVVzo9XFalMHj5jWF d1ziq4kiiCZe02bYHh5VGVo9Z3FW95cLLWL6LrTQ4w/Wc0GFHr/nQovvggsuwDBCi6LYYr3QIgwD Wi6V0OLu8YZOxhe0F5plxjqhRSzOKXspl8ilFuIaUpWFFlpkQgrZ50KLTFzBJRa53IKJL2xCCy3M 4PKMVGRBCYQWTY/v8pq3Gdt3UcKu4/gqofD979RkocVfz1FxPH8/VAkuuJAiHVdIMWzo36WigCTJ +0KsKsGFOkmxDC6Hl78tSyvW7SMyZXj5/qB0PBNrJPtE0Zlq4ZjoaPZJ0fOcptM5DQYDGg6H1O/3 xboiTK9RCi605EJu2wQXfE7/Tt8j3tq23rSJLLj4g8+9RpE57nfBjKyi1KePAdtfZ4XkpsoYEMu/ eP85d8T0J26bY28zvuvr8iUHjU+5SHb9njHr7Sy2XBNm26mQQvRSYpHINSZRQWRhE1roFusmjomz 8xSccSJOr9Oh4253E6nFKaniADMysgout+BCi4DNx2w7qWj5LSi1pNSX4fO25RpEFwAA0HLEu3VE EFr8hBdSIosH14n4iLgvC9HdiudKCj+uqV65xRspYQYAAAAAAAAAAAAAAMB/Ll0nUCML1wkAAMCG jFwnUCMokNdO6vy26Br5bXPkOgkAAAAAAAAAAADsnCvXCWyJA9cJtJXs/z2a9N0NAACayrnrBGpk 4ToBAAAAALjnSwD2zmelYSCIwxNtQdCDvSpVD3rpOwiCB2/io/gAHnwE30RPntVH8ORRRAqCB/Ek RbLuZDObyTb9A7bdNvl9sGQ32c5OKpix6n6QWgAAFsGoHcz0+XPbziYF2ts7JGPK4bRkQuQTLKKo Elrw0YksRFrhjm5sfEtT8vNdLPIx9ZoxqePGvHW8p9GME1oUe9G5vpNbOGEFj0UwIUILLaAQKUUh qnBtQGWJRdj/Lb2+iJfSJKHFxgbR9/dz1r+5vaLds+Kzk1AKMU5oIYIJFllwX0QULKjQQotMXEED L7GQsb4m8/koYgyJmx15Tbv+KKFFSunQPdSK2LcEocVqxF4Eyyy0mCUQWsSLOUehxfDU0aIK/ywJ 4yW6O0X9Y9S8pCzL8FMmyS1CCUW4va2SUJQEGHqb3JQK4UWVCCPcTtcMXxvsEL3blpwSbb8QbT71 6fG+T+12m3q9HnW7Xep0OpnUQuQLVSILOReeDyUO3A9pQs2pBRZV41arRW+fn9MEqrb5BUKLJB+X RBa8eXQ4958s6mtXV+lDnSUNkFks/5pNXDfm2rGfdXWWWTDLkgfT1Fx0+epX5ZrE1i1reX89Py0G CZZWrNnrXmTBNaUah3KLbH7+GjlKmazL3aOtLfr4+ZlGbHFM7p/qQ6GFpCjVs/TDa+HyuulqP7ym 36ZJP+lAYgEAAMBjn+0sZLqLnceKwDKLa2PMQ+xEVgH7Pn3R7OUWF3lcAAAAAAAAAAAAAADAEpN/ 9lwbjDHYWB0AsCocxE5ghuB7b8Ow9QNvjHgZO48Zgt9tAgAAAAAAAAAADSNJEhZa7MfOY06c2PYQ OYemch07AQAAAOOp4d9IvMbOAQAAAADx+ROAvfPHaSOI4vCzLFu4QUKRXGyBXLqK4AQcIZFygRQ5 QC5CgStKauocIHRUCDe5AhUitFjeybydeZ63w8Qmxs7Yu7/Pepqd2fnPIi0ymg9SCwBADjqJ62+r Gk0m13R0VHihRBAghHwIlk9wGsstZjMnsWBhhZNbiMiiXNyTVNqIKEOPK+e5ZvZa+Dk0TwTRxDXV iR+ccMKzFlrIidEslHDlc7snxsstSp/WZRYisghCixdf/pIQWtTrunSu0tVCi8FgTs/Pv6rry9tz +vDxWK3qtdBCZBEsl5B8pbLwQotKamHnJUILTllWUYUSV1QfFlhwXl1LHZZY6D6k38UoxsksFh+/ RhFcxGtoFLmXBKEF+t7WGLve36bZJaHFNtgzoUW9WWhYE1WY+n0tpOB3nmVSjNR8pJ60jQUXxhkw 6u3jrrVoInVsbVfd1/U7Uf1YfGGifPz2X4b25oDo94mL/hei4f2MHn9MaWqjKAoaj8c0HA6p3+9X a2XJBYcIK1KCC10m9XhvtNBBymQPm0i83lSw1OLh6Ylmdu963e7fOnJ/+KzYJ/csUl1u4WUiHV++ iV9tCC0w1v8Yb5/njjF3Z9w2j73N8XOvS8A80mR/5o0Jr6s+zyIKMUfwPRZVlL5MiyxSQguJUrXh VLvdqvHsOIe9HhWDwVukFmMbpzbuKMgqtNxCCy06qrxUebMkSLYgilhnF6PLU69tEF0AAEAL8YeC /KT3iwaaztTGd8gs1kPJLa5syoKLT2t2dYGfAQAAAAAAAAAAAAAAe8Mo9wQ2yE3uCQAAwD/QpAPz ILVoH1+pOd9d47tNAAAAAAAAAACgnXzOPYEtMso9gTbiD0k/yz0PAAAAK2mS1AL/IwEAAACAij8C sHcGq20DQRgeKRiMDS7kVopDCKUnv0Kh9FbooW/QV+gj9NxDnyHvUeghkEsupRB6CZQUSqBHB1qI EVJ31jvSeK3EKpVYefV/YtFKK+3OyjIem0QfpBYAgK6570lmev9rU17t6ujo6CkVxWZ3WjIh8glf ZMFFxBWV0CIvt1er3LWvS56TXcu5vC196jH7RowP5Y1xTs2EFnm5fy2UqAo/xJlFE1IqCQWLKypZ RVUXicVKSSykLsf5Uoxc9X3/vT4e/6bl8jtNp2P6eP6BDp89VrOqF1rY96kTR9QJLVhGkZlFpBRa aGFlFiyvUHXZ9oUW0kcmiwgtlMyCt20cxToeWfw5REWEU9pJrEKLLoHQot3+uriefRNa9PH6BxJa bHfjcpliO5fZ+JzR4yW6mjSKpzwuqWQZdq0/jx/Kyn0Jhf+4W93O6UHqHc/II3YTb3+dOCOlzTm5 +uoJ0U9TkpdEh5dEk7Mb+vzphkajES0WC5rP5zSbzUohAwsrsiyrFVnwti+9EMGFnCs5ps41Y8o7 /e8s/txEanFxdUV/7u7o0WRSCSwewgkrNvo117OoaSvraUr/C2QW+zPWPo83FNHDUMYMOe6Qx+5y /NDz6ksMQp9iYYK9z6kmneacz+Q0ByKvIPfbMa1FFiytSF27FVmwIE1vu2NEbmGPd+fIWqe/EsPJ dEq/TL767fZ2V9jPTflC20ILkVxI9ix1v80fXhedrfttpNa7vvVAYgEAAAMHQotG/DDlvckzTkMH EgPmOl6b1Rtz7/E/a53Sv9179rVoPyoAAAAAAAAAAAAAAEBHxPTAhuvQAQAAQBOSJHkROoYWWTpx OhgW70IH0BJfzf0by1wAAAAAAAAAAADQEPf3+W9Dx9Ehx6EDGCj4nQkAAPaD49ABtAjE8wAAAACw /BWAvfNXaSWI4vAZwaCFYmOEWGiXUhCsFbvb2Qj3Wtn4LLbiY1jZ+Biyr2AvCKYT3d27Z2bP7tlx NCLJ7mby+8JhZpb5H9FJkPkgtQAAtI0J5K+mNbq9vaOtrV2b11IJl28Gyyc49eUWtbjCySxYbKFD nnEqbUSUUfefV3e89tBrYYlRBBHPmr4TWmSq7O6mc+uuhRZOMiEyiw9bNiZVMgotsfClFk5s0ayn RRapSkVoEWZlhS/LfqLJZELn/07pz/UFbQzre2V8OYRILERooV8itNASiq+EFpx/IyWzKMtWZKHq N4QWpcyC8yyv4LyMDaFFB7Q9h5iFFvPqH0KL/gstZgWEFu2RN/+umIBdopJflEIKmzellCIPtwkh 9aSt7S9rbkhuphoyPksu1Fqqa3R9aYW+Olee6z78vnRbb8x8nejlyMXgL9F28k7PDwklSUKj0YjG 4zENh0MaDAZ2rSz94hBRBYss0jS1ZU59sQWHrq8jnnMnVfKOkMxD1sd7w1RSi687+/QBqJJZpGld R/bNz/vPfrGWNohVMrGogom2x4p5n7ocE+Muz9jzHL/rdQl9mQeDuYQxcmbhcw+5b9TICt/KsxGV R1o+Q4rwohRXTItMtclUX5W/rRhnc3WVdtbWfiK1GBdxWMQj1bIKLbfQQgujnmeq7J+0/VN3SHjh 6+t89PPQBweILgAAYLm4L+Kg60n0lNcibjhwWc7sKfb0vji77ZP7GTz+YbNLvBcAAAAAAAAAAAAA ACwUkFoAAED7xPS7F5flLBnGmLMi2et6HjMCFw0CAAAAAAAAAADLyVnXE5gzMX3/uBCU/3MfsygF AABi4qTrCcyQp64nAAAAAIB+8F8A9s4mpYEYiuOv0kKxtqJbQURc9gaCCO70Cu5d6sK1eAVv4BXc CxYP4MKVHsBeoNBF2+mYZPKmr5n0Q+g4X/9feSSZZJI3ddDYwvwgtQAApMmiJ5rJ41cqLldNdHh4 kjgmJRMsn3BFFjOZxdRGSONxaMt5mYWO6ZRMH5+r2zynXLMIlOmBvExxr8l3z/xFaBEI2YRus4wi UPdmJK2I+pJSi6g+shIMbk/ikudhUcZsDT/1eo2Gw09Tv3+4pu7NBbX2dsRVzeQQUhbhCi2MyoKF FuEkElGol66zyEIKLWKRhWjHY6zUgmUYeg4uA36FQUKoYX5/OEKLUsos8gKEFvmfv4hCi01TBKFF nqQPZRVapHwfSIHFor74XFcQseA8H2acfSStlGXE0y+TW7iPu+VtyZZznESfK7Egcbxm68sTTgo0 FKMDoh8VtTOi/S+i7fc+vb32qdlsUrfbNZKLTqdjJBUsbWChBcss3LYbPtnDXGqF23tGcN6uuENG o9EwY8ZTzw/II7KY6/O9LywH8QkuZKz5P1VR5QhYq3jrFTl3rJmfdau8dprrZ31dDPLwk5d85Fay JvYgWjSxZevGEGE+n4pEFoHeA6o2Syvqet8o23ZMYNtmvD2HS7nd5RyOWy3qt9v0PRisSvtUxQcl hRYsueCdN9fdPnd5GVI55/aRKFdtyiCxAACAiqL+nj7T+jKBqvGi4i7U9neQGlZQca7uRS0PuV0x /EmN76WfFQAAAAAAAAAAAAAAYIOU6cFGvawTAACANTnKOoEN0ss6AfDvlEUEge82AQAAAAAAAACA 6lKWzzcWsZt1AhXkMesEAAAArM1R1glsEMjnAQAAAGD4FYC989dtGwbi8CmwBWRo0Qz1ECBIN3cL CqRz/QaZMzVrtgB5gcx9A09F36BFH6Ne+gbNkLVAgaBwAEcsT9SZJ1ly7MAV9ef3AQdSMkUeHcFm EpsfpBYAgDqJSuqXT100nX6jg4PDTCjhxQb+2AfLJ7gsyi2c2MLLLZzMwgku8vXH9HG+RkQZelzZ e7UlXouU9oogquE5tWc+ZTeL3zQ4L7RwdXfOhcgsfH2hSi2nELmFF1qsCi4WqvRCi7zYonrH6Tje o/v7n2n905drOjo7pUHslxJVQovE9sklyyWWUgs7h1RlIUKLTEjBpZZVPFAmsFB1OZZ2ZUILEWZo eUYqsiDTT6FF6KmFHr9OILSol6ZKKPrwc2pSLkILhBb5h32DUsGFrOGUkCKVBayRYpSNL+3k2q0F F66TXJ8ryLa6WsIh2+4yertdOV43VlGcYdubF0S/37uIz4le/5jT3fcZzWaUii3G4zGNRiO7XonT ubLkgkNkFSy0ELlFleCiKLeQaPN6ep3QgmMwcGu5v/P5Vn0yxp/Il/q8jmfkXgddlT50XdKwq/H6 IHrom1iij1KJ0O9PkFnUR5NyYZqWD7PMyRhvc8iEWlIXTxuLKhKOrL5JJOqaRPUlwRKNl8MhHe7v byK1eGvjHTmxhcgqtNxCCy0idT5Rx2ZNkDwFhTCFsog+X/YbAEQXAADQcez75YUtPobOo4H8sXFh jPkaOpE+YZ/vK3tP8oedP1c0uSV8GQcAAAAAAAAAAAAAgDZyHDqBHYINGwAAbaFLQqFfoRMA9RFF 0RtbfAicxi7g/znfhE4CAAAAAAAAAAAA9ZP9feMkcBr/HTvPCYSe9ZDdU13/3sckdAIAALAL7Gv2 K8JnJAAAAADQQf4JwN7Z47YNQwH4uejgIojRjmmXIksWn6FAp2ztVXqADj1CjtAbFN0LBMgtOhYB MicZOiiIXT1KT3pm6VgBnFA/3xcIJCWKj7IN+EVK+CG1AICnYtuqZn7/p3I73TXQ0dGxrNebw3nJ hMknYpFFK7NY1VslrqhKE1usmj56rtar81bNGLrfxxwqQ16MN8Uwrif+vLRrylXz91sstDDBhAkt vIDCCy3uorpuReizKbQw+YU/38bz8dLM5yK3t5XQ4uzHV3l32j4riaUQsdDC/5hgQkUWWjcRhQoq vNAiiCukaCQW1vbHrL+WJsawcUOpIosyfkpoYe34GkZJ7kvLET/XNSO0eN44fZVQ9P196pv4YV9j 9vW6OofeLqrY+I7yc5z5ard8qOk3k8fJLUxQsXbtZuXeqFQspZglzrVleuNx0hNul+yVtl/xVuTy c7n7o8ib3yKvLq7k/NdVma/MZblcBsnFYrEIUgsTVZjgwjYTXKTkFinBxX9T63UO2vKQrMNkH8rf oug6oBoEN/c9JK7w+7z8ol5cehsILYYT67nj7TPWmF+nnDGJO53YTxk/93UZzCNN3+ajhNxGEumy 7i9zjhd1PRgiwn2hSmRxr3lS2TZpxUvNE3277nNft0P/+hwrvb/N5vD+4EBODg+7iC0+SPXHO7HQ wiQXlmlbPT4Wh/ebz7rjY+LKXb8JIbEAAJgQ+k8ksl0eMGV+SiW0uM49kSlSvu7f6xw09dnkfQEA AAAAAAAAABgY9b3osXDDPUoAGBBILWCofMk9gT1xRt4AAAAAAAAAMFnGcn9jF69zT2BCfMs9AQAA 6MyYntH94VkHAAAAGP8EYO/8cRqGoTj8OlDBUpCIYCpi6ogEEhfgBEgcAI7CBRjY4BblBowMHToy Ii6AOlRC/EnwS/zSl9ShEbSx2/4+ZPk5JH7PUIRFkT9ILQAATdFyxGezHrq/f6BOZy+NtVQii4uN 5RPcl+UWmbRiIrfIZBaZ4KIcyzMiysjmTPIcknuZ4fWEePjcXwlXblFXaKFlFjwWiYUILVg2wf2X 7UVO8WmvaWnFR0Fw4bp3Mo/0s4UWW1ufNBo9p/Hd0w3tHh2oVU0LLWJ7kjXLJWScqiys0CKVWpi6 RGjBPcsq0qbEFekHCyx4rGK5hyUWeg6ZN8+SfBeEGrFdI4QWK57f95oXReiihKbzhCqhCP37FKr4 IYSf20Beo7ncInHva7T8Qu+BpqQYM/LLffLsr4ILOQJ3epJqIYU+PtcluNA1ytyurYg+fleLM6S0 DtHbqWnHRO0Lomj4Tq/9AQ0GRN1ul3q9HkVRRO12uyC4cMktqgQXVUKIcPegE6Q2l8xCPsdrY0bj ca35Cq8Tl7BC4rLA4jfxhaPmJkCu5co173zLXDtyhpN3nXMvMr/vdQmow01o9TCVArIkmWwn7Vhi ca6xqCLmZuM6LVbPxGqu3Plm8uxsbND+5mYdqUXPtBPTzA42l1VouYUWWrTU9ViNy+bcsjrOJbwo 6+nK6OuuHT9EFwAAsIKY35GHput7LiM0RpRJE/B18UyF2OLWXH/0UxEAAAAAAAAAAAAAAOAfHPou YI4MfRcAAAB1sO8FbnsuY27gPaK148p3AXOAD3m69l0EAAAAAAAAAAAAvHHuu4CG4EO78b/3C8b+ vffScxkAAADqs0pSixffBQAAAAAgHH4EYO98UhqIoTj8Rop0IbWom64cBAu9gktP4BFceoyCeCmh oBcQ3LkTqSCuasFF0XZqMjOv8yZN/9o26fT3DSGTaTJ5wco8W8wHqQUAYB1M2t1MXj9X5WbWjWq1 s7FrLLfgmgUWUmSRySyitCTiiqRmsUU06mOOjaJMjsHCDF183LhtGbZhE95F8WtN8wgtotH1RCiR lUxoweKJQSqr6AtJxa8htJh0no3L1yyzGFjizSiXv6nbfaWT40O6a93SUb0mVmUXWsS/l6k4wia0 0DKKvjpYSiGFFrHMQssrxDm3TaEF36PPBwsthMxCt+M4hkk8fJhrKCSul7ZrQot1zu27KGHT8/gq ofD951RkocV/7+Hbe3SYfz4FltQ69/yS84mtZW3jbJiCi5y0YCjkFvbB2fy5nXzFdZZYSLmF2d+U XXCqNI9MQ9clop+Q6F2V4JKo+kK0f9+mVqutcpkyNRqNWHJRqVRGEgub4MKUWui22c8mhvAZGaMZ r1zDR6cz/R6m2W/C2pP3EY0LLKTkYo5Y10lRpQ9FljRAZuH/nLs4r8u5XT9/ILPYHIhlOlaZBY2n xzr/0KKJvfQ8NkTEn10lIouBzvdUm6UVJS0+k+20zyBtx/3TMVxz6spFUz84oM9ebx6xxYUqTzQu tGDJBWfYfG6+Zk4vi8yyzddI1LP+ioHEAgAACo56rlYp+eeRwmxkswIeVblSecOX60BAgiG2eFOl 6TQgAAAAAAAAAAAAAADAshRpwwZILQAA20LoOoAV8uw6ALA5giC4pmJ8j910HQAAAAAAAAAAAADc EASBFlqcuo5jQ4SuA9gRmq4DAAAAsBCh6wBWyIPrAAAAAADgD38CsHf2OE4DUQB+RtpIKdgtIiio Nqm2Q6KgouAEaDkBHAVOAO3eAk7iK2ShRqCtAIFNZscvfn75waBsZuJ8nzXy+NnjeeMmo9iaD6kF AOyDYk39vcSFtzZydfVRzs4eNPKKVlrQHrdF5RNebhGlFa3cIsosouDC17WNijJ03VYVaARC/HYQ GS7k9j/kJYLYDenHtE1oUUl39eaqydcKLaLEQkUW8djKKLy4IsR+uvgvV9f2XpTxe+Mo4iLHn+Xm 5qu8ePlMLt+9lvsP229AvRxCJRYqtLCbCi2shMILLX4sNltfyizcOW3TEVrUUWrhhRZLsQZCi+Po H6FFnuQmC7grEFqku+cAhRaroX6Ci3CuNnNVG+9LuFbbFnWx8lu5VXARb7Aqt9CYl1b460W6478n 25+ntnX3qE9Fvj1dlCci47nIpPwunz6UUpalzGYzmU6nMplMZDQaLeb2VUdwEYQXVmyhAgwrvNBr 7f42nYwlF17EYXMNYwh82bTY8t+EFn7MKrOwpemjE1uT4z44VBHDsfa16/4OOXf6zKvvYxzzXfef elwKeawnt3wCfXJSMddyWtoca12nm0FUUYXS1PuUyrSpzL101hTipycn8mg87iO1uJC4aEsQW6is wsotrNCiMPHKHHtlnC2ij8CV2u09Nr5uZo7oAgBgWIT3to9TJ5ERb+u6fpM6CVjFiC3mCEcAAAAA AAAAAAAOFqQWAAD753nqBHbIPHUCsFcuUyewA67De87USQAAAAAAAABAMobw/0ZfzlMnMHSKojhf 7F4lTgMAAP6NIX0jMU+dAAAAAOTDHwHYO5uVtoIoAJ8L2gYCaVcuAgXBbTZ9AZfWnT6Ar1DowrX0 UXyPIvQZumh3roTSjaAggpibzsydkzsZ700w3DiT5PtkmPszM+fcIORodD6kFgDQNW07ioXXT0w7 WrTQ3t4nmUxml1O5hfYqsAhFFrXMovStEldUvYotyumYeG5Z1nKMWKhR5zHJckO3ZUkvguiet3+m pj3cXiO0GAeyCXteiyhqYYVKLZ69sOJJZgUXseziOVpHxRYao5nd3UIeHn654/OLM/n89Vje9d8H T1XLIUJZRCy0UMmEE1p48YSVUthjJ6mQp2mvEgsnsgjOp2O80EJlGHYN7cf6FQktSv8ax0KLjZZZ WFI/HkIL1l5VjNzX65qchBarAKHFUvPniSpm6lV/uLTcQmvwwssy4lp4ntzCTnU7AsvLbXRFZsuh pnthidI0py1mLMfYEXk8ELkxrfgi8uGP6X9cy9XVtfR6PRmNRjIcDmUwGLjXyQoubN8ksggFF/aa Ci20tQkjciDMtSlPlVr8vb2dt0j7tbCPr+lQsd8zaWUWxFq/WF3HW+fciZlP3G2Ovcr4qZ8rlxyU nHKx5JaPZVFOsWmhqCaZGndSedasmEL875alElmMbV1kzlVasWPrv/Dcjxn7czfez9HeWShc/S0u lu0P+n35Z+rN3/f3ix7rUKrNTmKhhUouVDChx/E9FVw0tVAvF9+ToF/0EwkSCwCADcW8t34T/qlB uTPt1NQJP1MnAu2w4QsAAAAAAAAAAMDaw4YNAABvz37qBDoEodCW4DfoO0mcRhdcpk4AAAAAAAAA ANJQFMVH2a6/1d+kz4By5XvqBAAA4NVs0vsjn9MBAADAlP8CsHc2qW3EUAB+U2rjTROIF4FCoRiT A5SQa6Rn6BV6i25ScoNuS4/iRbvuJhfoIiSL0IaZSKN5nmdZTZ3UiWbG3wdCGtmSnsfG8/yDPqQW APDUFIn2h38NOj//KgcHr9ekEu1xW1Q+EcstgrSilVsEmUUQXMRtHaOiDN23VwUaurYFEUQ/eJ7H lNrPrd2ReVVoEdqhLxSVWbTtW1N7EYUVWgSZRdv/OyG9+GOEFvF8pazuFr3KeFzI9XUQWnz68lHe nB7Ly3GbLvxNaFG6eX3t5RJLqYVbs1ZZqNCiEVL4WmUVVmJRH4uRWxjxRUpoocIMK8+oRRZSIbTY JYYqtHhKEFpsd74uvw66KsZAaPHf49dEFXGeqh1ru/lq8568qFq/n8oxNhJc6Fa5dl0rpSiiPona LxK3xfOkYrbzqlhDb34lcnniyjuRyYXI9PuN/Py2kMVCZD6fy2w2k+l0WgsrvNxCBRBWZBHLLWy/ yiFsrectd16dElnEZTQaya+rKzso1PEHoPixpCQWcducCxVbLJ+mZzo3Q5U+DFnSgMyi+2vu4ro5 1+7CtaRP8z6UrsThIZb7eUxM9ZhGMFGYY21r6ulFFaUvTXuTUpoxZTOXrqW5zp7Lsw4nk02kFkeu uGxVXIa6lFVYuYUVWhSmvzTHsT4upZKLSxXVMbY/lYkjugAA6DnueuX/FHuWO46O8EOC0OIidyAA AAAAAAAAAAAAQ6XZvGk/dxzbAkkyAPSIt7kD2CJslrM7vM8dwBa4dOVz7iAAAAAAAAAAIBtD+H7j IQzmN6Au0khgd0mSAgDQe5r37sFcH6uq4nc6AAAAWHInAHtnkNtEDAXQP1EVVakascuCTSRYsInE lhVIiA1cgiP0BIgjcAVuULY9BBIrhMSGBbAs6gqpZIo945/8emYYIjn1JHmvsuyZsf2/q6j1tJIf UgsASEnXyWL2/itXXvZNNJ8/ci8vt6dTuYXWKrCwIou1zKIMpRZX1LWKLcpVn3hsWa7lGLFQowtE ELvB9tYUfz7WZ8XVMW2xQguVWNj2n6q9FlKouOI6atcyi6bI4no1rm4vzXzLXqHF8bHI1VUttHj3 4Y3cf7Ewq7pp1FZoYb9UMOFFFr6tIgovqOgSWqxEFtEz7e9rFWPovFXtRRYufpfQorRykX0/Y28I y7vrHPZZaLGt+RFa7IbQYgjSh9TzpJxvCD/vLBkFG9XvtjC+TVRh5Re39rRFx5h/5BILLlrlFl1H 4dqjbuNjde29Mhpjn3WNscfwxjHjuEcivx+KfHdl9Fzk3mcX8uKrXLgymUxksVjIbDaT6XRardML LqzcoktwYe9ZKUZccvA/UovxeCw/Ly91QFNmofS8FzWkF9KUWVR93PenevHqmy8BuypiONRYqePt cu7EHE7cQ469zfi516WQRztDy8ezaU7x9lD3IYXbf4xCuzJE+L8xSy2yWHoxhbtWacWR3+/Z69Bn Ga6r/kFmobV1rRVBcPHg5ER+nJ7KFysRa+eJKx+lKbRQyYVOr+34mQou2sooxLhpeSam7tugIbEA ANgjwsFh57nzGAjvXTlze4NfuRMBAAAAAAAAAAAA2HMe504gId9yJwAAsAFPcyeQEA7LORxe504g Aef8HxoAAAAAAADgoDnLncBdUxTFM6TgW+Nt7gQAAGBj5rkTSMin3AkAAADAsPgrAHvnjtMwEITh 2SISaXgoUgoKQpGGBjoKqhyBa3ALOAASSkVJTcUxiIREmzJHIA0FjyyetSeerPNwhK21nf+LVt5d r2fGlgsnivxBagEAKBOzpH+z6aDh8JkODroZqUQ6TpvIJ3y5RSytSOUWscwiFlz4fTlGRBnyblUR aEjuTUAEUQ+KPae8Qgsts+CxL7Rg4QRvRWShxRQ/c5FFLK74ygguskILiRHHTHOtFlq02980nY5d //H1njrnJ+qsskILkUWwXELGTmWRCC2c1CKqQ4QWvGVZhWtKXOE+LLDgserLGpZY6BgSd57F/i4I NWY2rksEF/45gBKB0KL68esotCgaCC3CxCkyXlViFBWrwOO1wCK7LF24ILhQS43N/2zEMURuMY+n azGb5AeUlVIw8iZgUvv89bRmntR+463x1s6OiD6uonZJtDch6rx90vhlRKMRUb/fp16vR91u1wkr RFSxSmTBczzmayLz3Pe3rpwAggvJKfXqWphWq5VKLfQXoHVfhvT+5UmTe4RS2YWeK5mmSh+aLmko Kt+uiB52JWfIvLucu6z8oc9JqEodTJVqYapWD/Pfmkwi7ZrbHJKxMz0oGQWLKmbckn6eJuvdNhFk SDyb5NqPnrWO2+08UouzqF1E7Z1SWYWWW2ihhVHzMzW2axrJJfCa9bY+en7ZoxxEFwAAUF+eotYL XUQFuLPW3oYuAgAAAAAAAAAAAAAAAHaEQegCCgQvVQcA1AJjTJOEQvy/9UnoGkD5RPftKcX/pao7 D6ELAAAAAAAAAAAAQBga9PvGthyGLqCJRPcTX9fr0HUAAADYmkHoAgpkEroAAAAAAFSLPwHYO7uV NoIoAB+DiDSIwfamASGgNG9R79q79hn6Br5D8T18BG+9yIWPIHgpiBR6L5Si0Ox0ZndPMhlnNepm J9l83zLMX3bOGVEcEeZDagEAdVF1u5g//s2Wr88ttL9/KCa4VFflFlqrwMIXWUxlFllZCnFFUavY Ipt8Jnw3y6ZyjFCo8RIQQawGb9/TPEKLbDI+lUoUpeg74YQKLcYRocVjcUVcbuELMHw5hsozxpF8 p2xv/5G7uxv58H5XTkY/Ze/TR29XcaFF/nNYiiNiQgsno/hnH5VS+EKLXGbh5BVeW/uh0MKt4dq5 zMI9KrTwZBaun+dhinz0CffQalJvMXX8JkFo0SzLJB9Y1FpNrPsalikXBaHFXO+HAouqeV9uoYKK qneq8D+brxGcnZ+UW/hX32bBuEj1FbzhXDieRcaq4rp6U+T+UOSXLZ0vIntX9gR1fi2j0bX0ej0Z DofS7/el2+3mcgsVRKjcQgUX2o9JL1SKoe/6ZdHEYvqiDRVxOKnF34cHebe1NSurKEyCZXPyR9L8 8gs/FxsTocVqxGo6Xp2x2vx1ShmTuOsTe5HxU+9LIY84y5aP480yC5k9Cm4Ui8qGPbN0yrab75Qy CiepGLtzku2rtGLTne+8fj6mMouyuPlcjuEJMibGiFKmcWDPkr93duYRW3y25VIeCy1UcqHLazuc U8FFrHTKGCYyJ1793JENiQUAQAuwv2ePbfU9dR5LwA9jzGnqJAAAAAAAAAAAAADWiEHqBGoEqQUA rAqD1AnUyEXqBKAx2nBB360xhvMCAAAAAAAAwPpynDqBRDjJ7lnqJFqI+37aTZ1EwxylTgAAoAYG qROoEf7nAQAAADP8F4C9M9ZtIggC6BzIRUgUYRcuUsVu0kJLgWjgHxAFVHwKLSifkQ/gA+hc0KdM QQsiVhQJydjc3t7Y42XPiaI775393ml1e+e9mVk33jjJPqQWANAUWaT/8a6Hzs8vZDA4+U8qEe6f 6vdW9fKJUG7hpRUruYWXWXjBRdjXZ1SUsdqPdXHfvVkrQQTRDR42p01Ci7m59nvJ+RxWaOHFE74f iihiQotZKbGwUouZGTMTK7LwYzTP38pZ+DlfyXQ6lXfv38jrT2/lsH9kZrUuh1CJhQot7KFCCxVZ 6LmQU5RSiz/5oXIL11/KLILXdLyN5WQW7giFFkuxBkKL/cqfas4ILbabp03ygaZiNRG3beKHumK2 dV4tZ5OoYu0zMiaVqHguEmg5TuUYVpixzFUVym6pa5dQ4T0J+rHXHI82xJHg2SDGfCDy62XeXoj0 fogcf/stl18nMpmIjMdjGY1GMhwOCwmEiiqqRBbunrtWaYRKJMKzvm9Nrq+rZBpWavHz9laub27k Sb9fvp/r8oqFE1uYews7JjK+GGPX2eWm0VL2m5zrtiBX+/J1uXZytifvPuduMn/qeSnUEadt9Tjq rqmIV65hMnOtfV1CPlZZRdkPWyG0iIguim/83LkUZNglqYt/3OvJycHBfaQWZ3l7nrfvspJVWLmF FVpk5v7cXId6uJgSLmyL4Bxi78d+skJ0AQDQIfLPJvdPIp9T15GY67y9YgMRAAAAAAAAAAAAgK1z mrqAGuE7ZgDoCs9SF1AjV6kLgK3xIXUBNfAldQEAAAAAAAAAkJRdkHY+hNPUBewaWZY9lf2VpAAA dJ1d+j0dfyMBAAAAa/wTgL3z10kYiOP47wrREGIgcZLFJi4yObqYOLoYZ5/CxcXH8RF8AXwFFmdC HNwdGIgWvF97v3I9iqBUrrbfT3O5K/fvVyjpBdJ+ILUAABTBqqeM2a/f6HS1bqAwPKX5PDucyC0k F4GFLbJYyCxmJiXiiiQXscUsbcN9uSx9+RmtMqYr1NgWiCD+B5sdU9458ROhRZSKJpK2rojiw0gu RGTxEcsssoILV3bhCi0+rXnsJ1RnaTQCmk5f9Dkf0d3DLZ3fX9Nee986qoUcwpZFuEILkUzEQgsj nmApBcsoYqkFJaIK3kRiEYssrP20jRFaxH31xuNJHsnmCC1m5j12hRa1kFkwvg+zTkKLv6bsooRd z1NWCUXZP6eyih/K8L0t2zm64/72dXFJVDHPyi8ya2C1os83qEWndLw4l2u0EulBdo60vEpgYb+W V+eKOdaN47a1+zf1iisketUpuCY6HOomzyMaDEbU7Xap3+9Tr9ejVqsVyy1EDiFyCxFcyL4ILqSO k0gxVgkniiRvDnsejoN5n0zoqNNZiCloWWZh7IJJsve3NQJuSVWlD1WXNBQ1Xx1ED3UTS9RRKuH7 9xXILHZHmWJhyhYPU6jwiJaXfizYUnrNEphybIgwMgoWVEQsubCkFU2RWPAaT7dp6rVP5IgtuBxw P0uQkRojjEzjpN2mt4ODTcQWFzoNaVloIZILGV7Kbp0ILvJSYOaY59SRla9b1EFiAQAA/xRzM8Oj 7zg8A6EFAAAAAAAAAAAAAAAA+OPSdwAFMvYdAAAAbEiVHpYz9h0A+HuUUqHOzjyHUQRPvgMAAAAA AAAAAACAH5RSLLQ49h2HJ0LfAVQQFlp0fAcBAADgV1Th/w4B9+IBAAAAIMOXAOydMU7cQBRA/wRY BQmtohQbiRTbrETNCVKQLk1OkzoHSMUdUtBxhHTbJEWatMABkKIIGkjseDz+68/ICyFaM97Z96Sv GY/smW+DVn+t1TykFgDQB/HWtJ63D110fHwi4/Ersx+qigK69lEN8olYbhGkFa3cIsgsguAi7ut1 Ksqw6/axJ+vmiiDWi+X31PXP0O5+fFdoEfphLITKLNr+b9N6EYUVWgSZRTt+0yG9uDVCi3i+Qu4T WoxGTq6uvtf9T58/yOt3h7I9akuCZUKLoprXt14uoUIJFU4shBaNkMIKLazEoj4WI7dohBfLhBYq zLDyjFpkISVCi9S3uWlCiz7XHroo4anXGaqEYuh/p5yFFqkFEqueL/H1VmARzxXLLxaCC1MW3RFc 3JOLnudrKj9vLMyo13qohNStcjVcNKY56Fa/8bnlI+Z5Fs3ZULwUuTyq4o3I8zORva8/5cfpXOZz kdlsJtPpVCaTSS2tUFGFiixUbtF1rOGfT9xqHbqKGnuZ0MKGz8nz6/p68YWr1C9e9fMw4oqqLVVq oX0jtyjNuYtH3LPoIlfJRM7ShJVuVp7xc0q5Jutuztp9rp/6vhTy6GZo+Xj6zqmevxFMOHOsfS0H vaSi8NH0VWzha70/jfRiqyPqt3G+bQQZtjz18493dmR/d/dfpBYHVRxW8U1aWYWVW1ihhTPjhTmO dXBdarg4yqiNseNdBR6iCwCA9eCj5PVj2MeC0AIAAAAAAAAAAAAgEc65nDZVF941A8AakdPn75fU CcCT8D51AivgoqoVzlMnAQAAAAAAAADJyOH9xv+S0/vI5DjnXkiQWgAAwJqR4W8kzlPnAAAAAMPi rwDsncFKw0AQhqfRg0WkUG/1YEEs+BCe+xhevfkCPoRvolcPHnwCwbNH8SzioVDTmNnspJNtSqsm TtP8nyzZbJvZiRScQJ0PUgsAwF9Z1m1Mr3MjrstVgYbDsyVCiyQ/iohCiyzmMouZH5m4IjuK2GKW vye8lnuuSkyRW9TZeLVdIojmUryn8PMw7wGXvU8PLbQQiYWef7n5XEgh4oppMM9kFosii2l+XTaP Vbx4pdBib4/o4+PZzW9ur+loPO9dFEohQqGF/hHBBIsseC4iChZULBNa5CILJbgIhRYixnCKDC/M cCKLdP8yoYWch/ew9VjfJoQWzYj9H2yaLKAuILSwi2ktkKg6nvX1OpSqdzslJb2WX+i6KF9P1q/7 8vgdH2/mJRdSc3TkIYDKny5069wkWONSKCpZl7IsbM8bxiFabL8bCi+YXaLJKdFrOqIx0eFTWpHd v9DDwwv1+30ajUY0GAyo2+0WhBEishB5hBZahOdaahGO37LOcw3vy3xOJkVJRdEqWBBWuPM45gcp N9xcZBfcHFqLMZL6KrSmihjaulfV+zU5d+y5Ofu2ee8697e+LwF5lLNp+TB15lRW6hHXWGmNEvm5 M0R4GcWOF1dE6XkutEjXY3/u1vg9LC5TazyP+DolyMiNEb4eOtnfp7eDg3XEFufpeKJFoYVILiS8 zMPXpBIuG5HfIyl5jdRxVQkHiQUAADSM9O8t/2PMlXUehrDtnYUW79aJAAAAAAAAAAAAAAAAQEsZ WidQIY/WCQAAwA84tk6gQiAUagfb0PTxzjoBAAAAAAAAAAAA2OAlBBfWeRjS498BvrdfGSy06Fkn AQAA4FcMrROoEHxHAgAAAAALfAvA3tnjRg1EAfiNokishMgKJAoKqhVlhDgAIE7CEbgIFKkoaXMA +ohqizR0lLkASIuUAsLaeP48b73jVYKcHeN8XzSan9hvnh0pmrWT+ZBaAMDQmEz7Q2d8i5OTUzk6 ehz2QFUb1Gf3U/Xiia7cwksrktzCyyy84KLbjudEUYbe6zWJNYa5IX1MXwQxDbwkQl9Tn9BCyyxs vyu0sMIJW0eRhRZT/GlFFl5c8XtLcLEttIgxfMw0V7/QYja7ktXqm2t/XL6XR8dP03VmhBZViGWl FbHvFBP1upVNWPFEFFrY2okqlKzCiSzkVyux0O1WaFFfbUgtYlz7FQUaG0qN8DNBaHGH5kdoMa7Y tzXH2OMNzZiEFrcBQovxnb8jlhZYbB+qF8qqVofmzsvhjquTHEMLM1xYk7nIXcKJuL2vqDGd54Ea 74otjKRlk97Ot092ocarhyLf3zTlpci9C5H7X37I189LWS5FFouFK/P53EkrqqpyxYoj1uv1hsyi 29dii5zkwqV0w3V2nyRDFzu/5eflZRJTuAv1gopaiS3aMW8GTEILWzdjJnyv1se7+9f5UJe51Te9 rn0x1bn2PR8yi/HPeRfnLTl36ecmyCz2B7nspsjv9CCYMKof21FGYSUVdbMWs+uaKLpoZRahHGSK ezJn6yDIiPHqEP/B4aE8mc2uI7V41pQXTTmXJKvQcgsttDBqvFL9ekcRkQ2ZhV4N67qLHs99QkF0 AQAwUsI/xnwqnUdBEFoAAAAAAAAAAAAAlOd56QQG5KJ0AgAA18EY87p0DgOy4n3f9Anvtl+VzmMA zkonAAAAAAAAAADFeFs6gRFg3wmdlU7ifyc8K3tXOg8AAPhn+BsJAAAAmDR/BWDvDFIaCaIA+s3M wiAojLOZgKAwSi4huHKrR5i7DN7DI7h04xUGV66Egdm5jLhwY8quqv7t70q3ESZJtZ33pEhVdfev X/QiJeJ/SC0A4H9oqzpm58+Kdjov0N7eoUyn9XCx3qmrRBYqorD9N5nFtGxRXBE/VWwxre5Jn421 WGNMlVu4ZdssEvopgujLnqxgJdZ80y29CS1UYuGMVCK2OPbCCRVavDQILWbFFc1yCyvAsHIMlWe8 yHs14zY3n2Qy+Svfd3fk4ua3fDv6YXbZLLQI0pdSHJEKLYJyohRPqJTCCi2CzMLLK0xfx6nQwsfw fRtX11KRhR+HPFzMR3/SPfSeNdlmjb4KLZYJQoulFv/vFF0VYyC06N7zH4xlv09bBRdOajIKFVS0 PdNGde9GPV61lgou2srpeqy0Qsx9Wso3nXfmmq0yrNfahBZ2bOe+ijz/FPlXtMG5yO5tcUK7uZfr 6/sgtRiPxzIajWQ4HAaxhUokvMzCiyRUKKFyiybBRSq2SCUXH+W9GH4Nz8RKLVRcYYUWOmeaM2KL DTNWyYWVYdTecfq+k1c1by+rgrW6t95nzp01u7X2Ou552evn3pdCHs10LR/PSr/7pEGo5c9DxZlk UPbD0bKUUXwpzkdBTObni7kgtPBSsrJfCS6SOd/3zwyMIKMyRpQyjYOtLXnY3pa7x8d5aR8X7Y/M Ci1UcqHhtZ9e05NvU7NquPSamM95v4kgsQAA+DxcFm0ndxKZQGgBAAAAAAAAAAAA0A0o2AAAsHr2 cyewQG5zJwAr4SR3AovAOXeVOwcAAAAAAAAAyMav3Al0gP3cCfQEL7RY1/8DAQDoAye5E1gg/J0O AAAAZngVgL0z1mkYBsLwWYihQyXUgYGpqkRXBibWbkywMMDIy7DzFqw8ARNCQgy8QR8AEHQCqUrI xT5ycZ3CEGqn/b/Ksp3G9rk1wgTJH6QWAIA2MYHy5W+Nrq9vaDDYc+ekaomAFlvYE2RFPuHLLay0 opJbWJmFFVz4ZWlTHlLmRBZ6TJ2vkvURQVR0e07+IhBxBZWyCjulSmxh56qFFlY8Ycu+iCIktJg7 iYWWWszVPbpdpnIry2jCfvZTms1mdHY+oeOrC+rvVs+rfTmESCxEaKFfWmghMgrOSzmFk1p8FS+R W3D5M/+s1aUs93MucgzJfaHFj1gjILTYGJkFk8JUVx3DOgst/qv/Lgot2qYLQosUpA9t99Nmf6mt sdhCikhrOiiqyOvvLfRpdDGw/wuML/eJHKNRblFvZLdcup6rpI/o1dIKRh8JnFP9GF6/H+Ndk7oc D6z6zQZErxOityOi3pSof/9OT7cP9FBs4cbjMY1Go1J0wdIK+3dIVsokRHAhAgsRXDTJLXzJhXx2 y2gSWkgSqcXLx4eVUiyTWfA1EVZIYqGFE1v8vCf96HYstpByAw3LqTaXVYGx0huvy7FjzHTG3eSx /3P82PNKJQYhpViY1OJhov8cOsGEUXUps5yC9yycZy7xFrIms3BpK5DKJ4OcO0GGbDtz1//O9jbt 9Xp/kVrsF+mwSI9UySq03EILLYy6nql6viQR0YLQwlB9lxz6ovT10MYOogsAAEiM4vfPaZGdxI4j EhBaAAAAAAAAAAAAAAAAQDoMYwfQInexAwAAgD+yTkIhHJazGZzGDqAFnmMHAAAAAAAAAAAAgDgY Y/h53EHsOBJgGDuArlOspR2yUgsAAADdZRg7gBbB/+kAAAAAsMC3AOydPW4TQRSAn0MEsqwIajdI pIhFQU0JLTQ5AoJjcAJuwTEiqlyABipSIVHQBkUKCthr9s3u23073tgRGM14832rpxmP5+dtnMiz trIfUgsA+Fuuu/OYb39ZxotNEx0ePpGi6E7Xyiz8vVLXiyxMXFGVJrYomj5+rA8TW9iaqdltEUQ/ u3VOfb8D7b3eVGgh0opWRiOrm9Bi0Ygmqr4mslh0ZBWtyOJ3kFl0BRex7GIelQu3TiHXsb8/ksvL T6H+9t0befz6udyd3HNn1ZVDNEcktDDJRBBa1OIJlVGo0CJILaQSVehxtbxqwj9u+tQiCxvnhRYL OyKhRVFLQ2610CIHEFrkP/+uCi1ylVDk/DohtPj/c2xrrtTjtzBX83677BdVePmF3/OtSDFusL72 tbF+vmYtE1x4qUR3gnatZdRmY6z0fa0tllysm6cPvZ4Yi/yciXwrY+9Y5MFnkV8fzuTk5CxILWaz mUynUxmPx0Fsoedrggsf6+QWsdgillz0/mw3iC10ne/n55WMIhZQODnF0oktOu0mtJiX+9UywuO6 7AgxpL7Ok+61V1/u/tXfG6j0YciSBmQW+a95G9dNuXbqz0OGLLNQcslDIZf1JP37lx6Blu6Fyj1J MESo6Kusz3VvpuIvqfYgGnfK9iC00H1aXW8EF1Gb1m2c96iFqPdBjyYTOTo4kC8XF5vSflrGR1kV Wpjkwqa3evyc3/3G4VVw8XPiyk07eSQWAAAZU/8jw/vUeSTiRxnHCC0AAAAAAAAAAAAAsmFIN3H6 mjoBAIAbgtQCdo1nqRPYAqepEwAAAAAAAACAZLxKnUAmDOlzyVSo0OJ+6iQAAOCfeJg6gS3C93QA AACwwh8B2DuDnTZiIAzPQhoVKYooRyQkcsy9tx7KG/QVuPdSibfgyBPQY8+8AOqJWx+gFyTOSKnE Kani7tie9awxbag2sTf5v8iyd2N7ZhckzAb8QWoBAOiKKtH+/K9BV1ffaDR65/c4DXtfacmEyAPc XqhBbMG1FlpI28ksnOAibovIQoQZElKOJXYJ9EsEsRrlX1Pqi++kEfJ9GIqTW/AmxNx2cgsnmyAr YeD6t6pZSKGFFk5mEc7PE9KLRSSy0PWS/ia0GA4renpyQovLrxd08uk9DYbhx/5LQotlPS/XLJew QgvTqCaC0MIsWmIKFlVYeUX9knZLaOGFF1powS+ej2sdQ9pWZEEGQgsh9+Xmjr9JILTYLAVs2L/2 uTYx7/9QUi4ChBbdju+SxmsRiSpaXcyz/r5zc5wal6LpV7VlGTJ3I7doD0rHlbIX1TrP/aivnkvP o7cE1n0pMY67HxHNPtblA9Hbn0Tj7zO6u7mz702nU5pMJjQejxtxBa+RpZZzq8gtYsmFTVutt2OB Rar/YDCgh8dHWszn9KZ+3yhhRSOz0MWLLYzILaQtQgs5TrTtfFaipm6xMWH35Oh3BSc6CX3XSV+l DyXF6jpen3NHzHLi7nLsdcbPfV0C8khTWj5MSTnZXLxgwtodvJjCtkVo4UUVS194ydiSWfiynyj2 qR3Xfs0jS1DjY4/qtdfxwcEqUospuY1dflCQVWi5hRZaVOr8Uh3HDzV1IUoLL0xUx8Qr4We3+IXz AAAANs817eY/MrDQ4swYc587EQAAAAAAAAAAAAAAAAD2c9Kz3Dl0yC88fwYA9Iht2jzuPncCYL3U 64VT2o4NnrCxEwAAAAAAAAAAsLuc506gEA5zJ9Bnqqri+/cldx4lwJ8xGmNuc+cBAACvZQv/RmKW OwkAAAAAlMcfAdg7g9XGYSAMj5cEGgptboWcAnvY9BkW2l56bi99o32EfZZcFvYVyhLY3Hvbqy+7 kNiux9ZEY0WpaeOslPj/gpAsR+ORE6jqFn2QWgAAPsKuHch0/2NZ7tsCTafXlOfNcFZmYfdMFYlF LaWoj1lgwbUIK6zAQtpWdmHHNgv3a4FGjMQvgng/cc7J/fzt3m67hBZWLJEpuUVuRBSZElKIuGLl tGuZxbbIYrUZV7czFS9rFVqcnRWUpouq/f3HN7r6+kXNqtiqtdBCv0QwwSILbouIggUVrtBCSyz0 sVdoUZa1vMp4IrTg6/uEFnLszqE3hJ5uiOuHmjOEFv/3OjHJBw4V6xBxYxM/dBUz1nmdCvvcG89Y /bP4LcFFJaTI7bqvbZyLvEfGJkWytQ7YCC52bbcrffmOPldgIbH0ucQca/mF+37y9EvfgOjfNdFL WT49EY2fif7+XNJ8vqTxeEyz2YwmkwmNRqNqTcnz5VrLK9rkFlpwIffMlVy8VYbDIc0Xi0pqMSjb G1GFR26RiORCBBVabLFe25oFF6tVVTcEGGZzZ48HxNyzukfm0jjl+Ri7AIKJ+K7XB9FD38QSfZVK hH7ucYjrh56TEEseTEy5MLHlw8SSk7v2YIFFYeQT1crDyLRYaLGRW3DNsgojuRgYAUZDcOH0ZTLe xJB1T1WMTOPz+Tn9ubig32nalvZNWX7RttBCJBcSXtruOa1mc4ssuArPOVJ1228UkFgAAECEmH9+ fQidRwBEaIGNQgAAAAAAAAAAAAAAACAepqET6BA8fwYAHAVm47PL0Hl0BTYu6wV3oRPoCKwVAAAA AAAAAACAHpIkCe+1djLP4/bkNnQCRw6+SwAAcPyckngef/cAAAAAgJdXAdg7e9wmgigAP0Mi2QWW kCXorLRukFKmQ5yAIyBOwgVoUlHS0nAGOtxwAMpcID8dWie7eH7e+nl2LSxiZybx961Gs7/z3owd aWLL8yG1AIBdMOjZ//ivh87Pv8l4/KojlLCSCZUJhDVUV2ILV6uwIggugsyiqu78ORVdhPNhX0UW KszQkHqssUulTBHE/SinT9sKLeq2DueD0CJIJoJ4oq5dfRuPrZjithVZBHFF1RFcdIUWKsXQNuu4 v/mNOhpVcnPz2+9/mX+WyZup6VVXaJGKI7zMwm3NXSubcOIJFVq42osqoqxCxRV/llsquFgTWjSL VmrhJRmxXbepQENjq2BDfI8RWhxc/Nx93helixIeOk6pEorSX6dSxQ8l/N2W9h7N/fy+2uptfiWw 6Fyzk2uzawUX28gt/H1NvG8QZRnJxL2VW2xsQFZL7WqxS/imYgorsNClg620wrazqQv2Wny2fily +U7k6kxkeCHy4ue1zL/P/bXZbCbT6VQmk0krt7CyirRsElzY5/xYp2O1PLayC8fRUfh4qFosZORk EqmswootVGahYgsVVuh5lVg4oYURXOh97dDFBZ0HIZG1YXsWF5duV1Pu+X+hzyHyPyC0KC/WUx6n nDGJezix9xk/d78U8uintHwcJeakuPmSnY/4XOP8oxVaRFFFHYubIq7JLGJ53lO8kjbOaex0somx xsfH8no43EZq4Wy1p8vyS1ayCiu3sEKLgTlfm+PU2GuL6BAkpUnqlJ7Z7hqILgAAMhIXqPmaO49M vEdoAQAAAAAAAAAAAFAcJ7kT2CF8Bg0Aj4WntFjORe4E4EF4mzuBXcD31QAAAAAAAAAHy4fcCZSE +01D0zTXufN4pHzKnQAAANybk9wJ7JAfuRMAAACAMvkrAHtnsOI0EMbxT1dYpOzupQVvBjxUTz6A B3MVBF9BH0TZl1LYW3wCXTws3gKCZ0sFy7JtnK+ZL/kyTZtkN92Ztv9fCZnMJJMJTSYzaTo/SC0A AF1ZNxKZjn9rpjdNGUXRC8qyanalzKIYM7WQWORSCrISi1xSUcorSoHF9bUs51O5bXXieC3Q2BXC EUH0h99jaiO0WKj4hZVYLFQ4l1jkwom5klHc2LRVcUW93EILMOYqjzm1EVocH09pMknNtfWEPn75 RKfRSB1VVWghsohNQoulcsKKJ0RK4QottMRCL7tCC86Dwzpf2dfCfrTQIlMf9xgOBt+He2hCi23u O3RRwn3vJ9TB+kP/nvZZaBGSAKKP/Hxv32deHbbX9+mlqCKrT9dCitZyCy3EoFLGwNu2Ely4w/Dq oXddUYUbZmSI4AWtDu9LTpqbLznr23n2mGj2nOiXmY5M7+nsB9Hfz1d0cXFFw+GQxuMxjUYjGgwG yyzq5BZz0znaJLeQbUpZIBWiCx3mSaQW/2YzOuWwyCpEXFF2ztbLLNy4m5uK2EJkGPNM2qDqa5Hv kI9x+d06bOgv6HW79iZ2VfoQ0r763t8ulx37DGe/h7zvbe7f93EJKEc9oZWHCbFMjCvUkuUHpr3x 0IaXki1eFrmFbaMcWcnFI26L2XAhuHDi5rK9zaOQZ/BkZRrPTFvv98kJ/ZxOm4r9ykzfaFVoIZIL yV7Cbpo0veomrXpz00jNm3oHkFgAAEBYnJvpqe9CeOBDlmWJ70IAAA4P0//hgcFYKCRzJnZW47Sz hqy+1sQlKsyDIPEf/FJT36Vdywn2Gyu1kkHqYpWkz0vhdYsseZC41Inj808PxpXYOc5JsFeY6ym2 wYjKP5XpsNCmbse1BIKhw7nNy019ygmtDuaMcxsAAO4R1QeIqKzLY7UKp79syOaS8vrbJVFh6YsS nr2BOxL7LkCPpL4LALaHetbHxCpJP3shJ76pvhXq2tGM25ZG3Qv6IvZdgB6BJOAwiH0XoAcufRcA gC6oZ4a6DRRRf88MmUSFpZ3zBwIYAMLA1AMR5de47vO4vzFzelMdUPecKaWyDy1hXP+gF9Q9TOYR Ve9fHL7NeftdxeG+FRDqmfhd6qu63+8TOy+ez+B5DADgNth66p3vcgQG19OJ70LsGuZcek+H+V8Q ADbivCcdUbX9X/eutMQ3veMprHt/QvcR9G96eCcONLFP8vnUdwEAAGGw4X9LsbNqm3dp8C46AHvA fwHYO3/ltIEgjC9VKuiSLoN7ZvwKIZMZP0KaFJ68QTq38RNkxnUKt6kzroP9AHYmL2BPUuGKIvyV hHIr3aLTRYCwBXeg78fs7HFIpwMOsTpJ+zX2KZE7AKBanphYzF7JTG4l5StlJ6saubj4RsfHbxJR C3M/lOZKzUQs2LNQBYtTsHjFbJaKWEwmEU2nkfJzGo8jZWHiuX44jBZlsbzYRZyYbIe3KUIa+4iv CeKew+7e0ypBC1PIIhO2yAtapCIWmZCFLWghAhZpOa2f/SdwkdYHxrqB0Za5nWL444rjezXG/9KH 0xN6d/6emq+y+TRbHMIWtDAfLDLBohMsMCFiFOwTcQotajFVDxG34PIknuSeS1mWZy/iGOJtQYuF sEaBoEXtxCwY128ZghZoe1vb8LU9CFq4a9MnAYgq2nO9fpVtPWd90SdYIzFgvt7IJRY21ivRj0XM EOdjh8SbwhN2e2ZdkRDF3Hq9aNlly9nLLg87FzRGRC9+E728IfrzPa3rdDrUbrep1Wol4hUibGEL XIgVCVwwQRDQaDRSx0rDnI3H48QGgwH1+336dXZGr5vNTKQiDFNBCVOsYpmwhVHOCVtwG9pzcmcx U2ukoRM+5zInN/IjyM6qvOqYYd3RBAQm/NteHYQe6iYsUUdRCdfzMxCz2B0+9YXxrT+Mj31ipF+5 kE2LbYnnOGWuLNQxS6jiHi4HyrPNVHmm/FTFOonnOm1SJxYY64W6XYmFZJt3Kg778fhYpvtfld1S OskYkUw2iqJuWmeXxaISNl9iMeUVf4ui3GVRr/1xbwTOXwIAwNPQyZbuXPfDAefqv+Oz604AAA4b vY+VhKFdKncD/DaRG61/isdN1YeNkVCkS9lN+vzclxsYzTHJF5P3CBePA0/RSU6OtMkNjWUEX3aB /JbEeoREKaAkOl45onRc+z62kxgGYxsAANZjHI+Kud63SzIHxP6gNGoc81gpmzDEd95iDmY/KRAE EttEmMIVdjydGMYiWIUa85fKnbruR0XgXOCBo+e/7x13owqu1Vjtuu4EAEJB/NMlv2IfSVgkx5iY MwRgS1jnmmW/4HJfIL//B8rOh/E1D0UJREGNKZgb3SQpbdXY4zb578K8aLXo/ZX5fbs63ynfN67L AgCUQu2/Pin3xXU/POOj2ndeuu7EvqHG0gP5c02oD+C8XE0whOe7ukq8y2OAslxr36NsngvXUNQc XCMBANhnrHstuOzLuaWi+yzwnwuAQ/4JwN4Z6zYNhHH8q6jSAXVASkVG1kiIZ8jAC/AGGRk6sPEA PAG8AGJnqLqwWuqOUDcYEAtZqIREpEptHMJ95/vs89XGODi5O/v/syw7iX13Thz7bN99P0gtABgw WwQXq1rBllnwlK3B75sSOj+/pOPjh3o+Dz67oVwywUKLbMwkFCyyEDHF7S0LLX6XxBU8f32dyS0y 0UUmueDl+HNej9MQoQWnXeRX5B8zoQaL+x92t0118dXqhRbFezq8nRFNyLzIKNZUFlS48gqRXLjz KZVlGJKWnU81h4cHat+/1PMvX83pyfOnNLp/ZG1VWQ6RD47QQiQTPIh4gmUULLTQUgvKRBU83Gxu 8tF+nS9jRBayni20WMvgCC201GJTKmFe5sERwibvuwwQWoSV9q7yCDm9UIUPIabTZXohCSC6SM/3 +l2m1YHQwuVvgotaucWmfV3QFlzY9zvyOkWd1MJ+r0loYS+7dl5XLdsktyC6U92794PowUeiow9E 378Sjcdjmk6nNJlMaDQa6WX+VW7By6RpquUVLLYQuYXM8/vL5ZIWiwVdnJ7S45OTTETBUgojr7gj q5B5/pyFFWY+X89ex7xXChBtbSv/yiK0OJCp9VnXcgsILcLLq8/fk888ke9w8t5l/r63S0A5qgmt PEyIZRLcsuVVNSPb0lVAU18RuYUILWyphSu2EKnFyggu6sQWqSW0kHoRj79WK7q4uqLPqj7WwBc1 vqFCXJFWjHVCiya5hQgsquQWm4ppndTC/mrdr7o1eH4JAADboc55CfkPardv3qnzxtx3IQAA/cM0 wpUxpmMrBxdNKOsQc4agD3FiOunPKIzADF3AHbaks3+CRuNgn5jjuf1fCqFDxbbwf+kbFQFSEq+l AV4xHXln1I99m+svcp7Avg0AGDzWMV7GmK4F7Lr/JwQiBYwJpPvTdzm6Qu3X4T4YBxorePOMik72 Md3fa4t02k8IATWBRc+eGz5T+/WZ70KA3aH217mavPVdjg54rfbVF74LAYaJUweSe4YxB8G07xkm uL4EoB3O/aWYjgd8fZMQ/vuDJeK2OnJfNCFcl7fC+c1jaBsj7bL0iHZZAABBHc/4PBBzu41dAFFt S3p0j6xLEEi9Z1jiukdUPMuL5Zp1G9Dmc4D0SOStQRsJAPpNj/paoM8SAB74IwB754/bNgzF4Zci cDdvHTq5uwGjPUG8Zc0JcoXOvURR5ABF10x10e4x0LVA0Bs0KLxkSgEHhd3IKp/EJz+plP+VDiX6 9wUEJdkiqVhRSFl8H6QWABwwHqQWOp6oLH8x6XRVIRcXlzQYnBCPU/Q1iOOhimSCpROcs8ji4SEX UsznudyCJRWzWWLlFUkhsODt9/dJSXYhQgtOXI5ILbRAIw94u+2vork0OXjcrvg9JteHnUcRzs/H sswiC4Gc6jhuSbGeCyhEZKGFFBw/bm63/SuzyNf1a1UphuQLWiW06HSOaDrNhRZvL9/Q89MBHXeO 1ZG6hRYLUy7nLJfIhBZpoZpYCi3SPyUxBYsqMnmF+SmW1boILyTncnh/yXUdspyJLCiF0ELThEOG 0KL55UNo0azg//ssF0KL/bbBZ3mh9/dZ1p73XyW3KL2eVgQXa/ZztUNEXvmqo3+xSmrhklBUQ/VW xRf6vQuV15VPjvdXth/9Jnp6Q/TsK9HPz/m2fr9PvV6Put1uJq8QsUWd4IJTwgGXZ7NMYFEVWnCa Tqc0mUzo4/k5nZiyq2KKQlwhkgqRXTiWq2KLVAVuTqzQYqEGYFm77Wf9hMqyCt+Ci7ZKH5pUl+/6 2tx21Nmceg+57n3WH/q4BLTDTdPawzSxTYKrbaUumhVZpEpoUci4lNzCJbWYW5mFSCzqpBYitlho sYWt8/rujq5ubzc5lPcmfaOlvELLLbTQok5usS5VhRYusUVdj7mup1v9dW8Mvr8EAIDtOdBJDDxB cIiJgQAAH9jJA2c2tWli/DpkMvUHBHxoLi0PWrsLv2g5yX+EB8aBT1oc6GRXdIAUBM2IGPu/gvsp Q2pHQJf/RQeEQfAfAED0mOu8jEeHFF/ABu6vjCnvq4zDNgWEwPbRr0K3wxM35jx+EboRYIkN3jyk cgDn2PvKm8D3XvRYcRy0NSAI5u8jpgcvXuH+dtyY8/WdyV6HbocHEKwRPBpKkC4ptrGkC4wvAajB jo3k3hLnsYyLRHIxguQsTiJ+Vqc4dwnf4Zaw9wrletXWIIka/k6TP+cRxq0AHC72eY7r0O1oIJ/M tfEsdCPahDmXftBhjO+3AVKLFqOejW57kGzfiMx1TAi6HSWRPSPx3ZyjL0M3AgDgjwOaa4E5SwA8 An8FYO/scduGoTj+ig6NhwwZDKNbuxhBT5ETtIAvUB+hN2h7ghaZC9QXCFBkyF7kBkGXdmkGt0s2 Bwga+EPlM/kshpGlKKAlivz/DIGUPyjKkmnqg+8HqQUACVMz0FjRm90Yo6/VdFJV0OnpBe3vD9b5 TZBZSzLBQgs9aQkFiyxYbqHlFByMdXVHXMH5mxstt9CiCy254PeJ1ELKYLEFly3LkyYwxqYw5EBy j8HP+rgbOo+zVi20WDr5hZWK0GJupbnEojiff07PL51yy4UWe3sZzWY/1vnjs4/0/OiVtVb3gzev TFkstJDHWiyR6ZRFFiybEBEFiylEaMHyCpFVbGQW/JzzGqciwuBpIQ9VnggtZHmu0ELm3XVIihBW GUKL8MvvotDCd5mhluW7XAgtdl+Gr7La/rzPshr+fJmo4okl6q4tt8jc2by/V9jfqJJOFIXrdYUW VPKaG+bXLdft8m2RbTz9S3Sgun/Pzoj+/CYaDAY0HA6p3+9Tr9fTEggzuVKLFQdYvr1Vx0f/NiIL W2rBoovpdEpfRiMaHR7mkgqRWRhRRaG4wn3O5DMTtHndq5UAzibPQZxlu4rQQg4ubZmFOy/vqyu3 uLsP7ZaYJQ2QWYS/zBSX2+ay2z7vAplFc6Au5YRYJ6GqbptuV5blXTOrD2MLLWyphSu2EKnF3Agu toktFpbQYmktZzaf0/nVFf28vq5apV9qOqZcXLEomLYJLarkFvmJz3KpRZHcggryRV91LXD9EgAA 6mEGJl9SPAOSHwLfWPYCAz4BiO6m90YDA5rBMmPSg6VTGAjGg+YnpAUXl+1WJW2sQEMyUD+l//Ai EIwEPBr8nu4hIoBvGNDbbawAVNi3NRvJBf4rAOgOqi17p5JPbdfDE99V+3Pks0BzTMrfUUyBBh8C ByGVYG4I8pUAaAuATxIN3uwLtL+BEFm7CPzTyn+N2i8/qOR908sFQYD+TUewZF6xChHrIsGIJIg0 7h3pMJHJuF42dS3etAtjik8GsA3+3fNv/nPoxzQB3sdzEFI7aYksxpROUFs5Jk8ugJ5zPf9Nm3Vp AL73hbfzJPR2CgDgl4hknb7BOYcaqP1orJKvbdcjQCC16BAJBcn2DaR4kRHZNRdIqkpQ23qikrdt 16NhIDrpGJZkKpXzyNvAmCUAdsB/Adg7Y922YSAMn6wEhRfDQIEOgVF46ugC3Yv6DfoI9dA9j9C8 QJEiU7dkzdito4EsHfoCHfoAAbIEyBTHZnUkTzqzFBwjdEiZ9xmESNk6nmRZuVDU/QexHRAEobP4 coh+3rTR2dklDAavtIgET0pl2jaBmBUXQIELI3RhRC5wiSIXJEzRCF6stAAGCV8Y8Qpl1zfbGtvU n2I+pJt47SnQ8U05sdw2PH1/Hito0eRnM+u5oAUJT5g8cI0AxQIagYp78AlZkOAFr5ttFms2Tb9L j78N/f493N7+0fXvv77Cy8lrtld+QQsuHEGCFihiQS8UniBBC1xqoQpXyAKMgAWvrwlaqEUtaqFF MqxdfOk+1RJW/KWs0IYIWqSBCFqkb18ELdK1FdquCFrs3kYoW7G3D2krwvb0N/8/oQrlxAPcdsGr nrjQ4wd9DuNILWvhJMdVhdNXm5wfDxl77PNu6t4S1oUqCvYet0P99Bw7bv/W1vII4KYqxfsqHvwL 8OLqGq5+Xuv3JpMJjEYjGA6Hej9RxALFLEjgAtsPD1V8hiIUSq3F1vh+WZa6fXN31whVLBa1oIXi ohZU56IWVLf2KUGzooTNYJJC14mi9fFS9e71oBGwwPVYJ7GLnm2Tv/pz1hYJXLhfn2Lb4P5xWk6n IHRVYOK5++uy79JnWn3nuM+77j/2fhHih5/U/EFS9InYxjeKQSiW4DGJjpfAxCQlxlm2YPSEbSwH VVnaUnqKVobApY2D6vAPY5tq3eDwEI76/ceIWrypyruq/LZmKPLsQRNSldCERbR+xdquIIUrTlF4 inKWLny97z+DomW9IAiCEJYTyCvxHTKVydqCUDON7UBAdv5Ab6YPxxOY3AYfkPhSHYcfYJI9zOO6 lA92MjglJ8/t3NsEnpv4QMen6jhRMhKZLC60kvm1fBNvbTm2Y2R4vZekXh2Bndu5Pzjkw3duzyHD 5D+C0DHGsR0IyDyEEZZsEJNZ55qA9IMteDwkyVce7NPD7PPYDuSGiFgERa6/6TCO7YCQNLF+k9NI /Qrxmcd2QGgnsyTQ24JzZD7acl4dKxTFvQAT38hYeIew91D3hucYr7bJbnO8LuDvnu4p428e5ztc xHWplWlsBxxmVfkW0wEm5o7jojne36X/yU/p/IU9vn+b8f18HLfCpPbHOXzPgiCsMYvtQKLIvJft OIntgCBsi4hYBKOeQ40NO8df5nx2m3FsBwIi95JbyFXQAtIb9xI82HH3GZjxGZlnY5BnlgRhB/wT gL2zyW0aiOL4C6B0VSSQUJQVLLLpDaqucgA23ACOgASCZXqDSBwAOABC6oYtFRcALhAEQiy6gkpN 7CQO8+x5ztg42G5iezL+/6rRfNSZj9SePtsz799JO3MEALSHEo69Nrl17Rjphyq8z6vo7OwrHR72 wrTMPxxF4hUUi1CwSMVatCISq/D9JXleQNPpkmazKHD66orjhcoHYcxlfBz/PhK5CBIiF+v21u2X /D72DhfHVm5MRQQtAqM80CIWgZEWAQsRthBRCo5NEYtI2MIUtEgKWYi4hfn5pQ75ghYHB7/p8vI7 HR3dp2fvXtDtB/eMUSUFLUQsQgQtJG8KWoSSE1p4IhSm0KIUaUGLhLiFzm8StDDrlbakfc6Hwhor 3Tf9kx5D62h62E2039SYIWhRbzs2Oeyvqq4q6rVN+GFXddo2rqbHY9P1ZtFYOqvNNp4pYmHagnF5 iX7EdtPKsEVMMY1V4uB1nBaxyEoHqc8F9G99WXVtaiMr1tz8SXT3M9GtD0S/fhD1+30aDAbU6/Wo 2+3G3xOPcz5XNp6vbDrPi8NsNgvDdDqlyWRCz09O6OXx8VrIIisWoQsd54lZBNpBtORjy5sdRWuR CpGduCF53e/Yk7KIWWTk5TjqJGVOzOOI/n//sO3dkusiDRC0QJu2tdvmtqtsv+lx2dIHwaa+MLb1 h7GxT0KZvsVmlrZZYhEuQ5hrwQJhHLNNpdISfJX3VewpW8jjvC73dJmvy8Jy/dmFtpMkSDt/lK32 6eKiiLAFK92+ouhh5VzH6RCp6CbLlql0VpAHomZawiojzrOQs77qwuD9JQAAFEdvAJw03I26eWLx pmQAasexxdCn6voeVVGx3jjDm+Pb5tghj3MVRhC3qAb9f5rPOywGvx6yWHwMB4sAjk52As/5bwib Ha3COLfb6IBqV4jDOghcAGAZao77SO44LtjqeZS+NxhRNN+3TZy2KOJgfYz53C0cmwseYTNz9Rib 64eE+786gMBFzTg2L4Ld81Rdi7U7HFbn5TfCM+y2gnfvloFn4TshdPyHc3s/UOc8n++5/in2hHN1 3g2rqNh47/yY8GzJhO9nRrZd7+rvxfdYNr3z+aK+o0YEZPBcNJe35Mh6iBYLWeTB6174Hm+Md/QA uIlj9mwV3MH8l48WrnvddD8spbJ15aA8qXVuQ4KNXwcQuNhDHHsXiDUSGTi2h6sooaAF5iJ7gZDF tcGeJQC24K8A7J2xjtMwGMe/dmJBnWDqwl7pxBNwCAmegImBPMK9AX0AlnsApGO8B2BgQmJHvECF EOMtJyGdUHPNFX+Jv9Zx3SRt0tp1/r/Ksps2iX2XOK4T+wepBQA9poXUwpw7VNJfVHhdtZHLy2s6 O3tBy+WgNCEVyyxEMsHSCY5ZZLFYFEKKNC2EFCypmM8zLa/IVgILXn53l5VkFyK04MDbYakFB9kP 7zOfqMxRBYY8IVtbYixbfZmqhBb2/GvF+7LQYj2vmwgo3EILTqdaWJHSptxiYUgvZH2ZSy7T+8y2 lmI45PPmtzoH/tK75A29mr6lx0/X/Xq2HMIltFiJJZaFdIIFEyyh4LSILFhMwfFcvfJYRBbG+5XQ wvg+xyLHkNgWWkieXEKL3sosGN9Fh9Ai/O1DaBHutg6x3dDED11tM8Ry+S5TKMd1oOUY1GgGNgQX y83lzXerXg/lNkmpbWLLKsxl9jS+8r0q8UWd1EJiW4bh+p5OD/4RPfpF9OQr0Z/v3HYc0mQyofF4 TKPRSP3+4d9Ei1xqIYGlFqbkYjab0Xu1zsfz87XA4v6+SEssQguRWXB6R5lFvlx/VhJUqHhoLDPT pNMiu5DPyFxf3nNQ5bcFF2Sts41dj6CYJQ2QWYS/zz7u1+e+ffepxCyzYELJB4O8VBNinoR98lZq VhltGhFaPGiZhSm3cEktUi2zEIlFldTCJbbgfPy8vaVvNzdNsv1JhR+0lleYcgtTaLFNblEXbKGF S2xR1bK1W8iuP3ctuH8JAADNiexh1yZ8VteJxHcmAAiJyOqBzh9614O9poSHcuvgQS8XmDi0PXrQ VkIYqN81PBCCB/pjYFbP0FKihPo3+OfQYFIvz+jBQyI+wgDf7oC8BYCAUHUdn4ex1HEv95EBGvU9 2jK7kdfnaKvEgToPYrrx9xwDmA+DnvhLQizXjlME/S9HILJ6EXTPXu3OtuC47DVo3wSCvqcJ8W23 8EREVwR5YtCoY3+qog++89ERnT/TpO+TTSmeZ0IOBcstEh/tKBfq/8bX1tCeFXh2zLoQx+7OnGx/ KNowjYHcAoBICVBmFRpe+rpODQhnK4HUwjOQlwUDJtw+ISK753LU/oRToKdCC5ZyXuD3bHgY12l+ PhHtyfZwPzP331zheAegGf8FYO+MeZsGojj+QhAMqEMmFKlTRiY+Qhno5yjwBWBm6coG/QLtB2Dq wggsrKAODAxhQEIMlZAyVGrTxNyz78V35pw4ss93sf+/yPIlce7ObuK8xnfvB6kFAD2mYpIv10bF nKH84+r7TRWdn1/Q3t7DtCznHl6JZIKFFtmSSShYZMFyi0xOwUKLpSWu4PLVVSa3yEQXmeSCtxOp BdchdXHdeXt5+zWPz07SxX37f5/K8qaVCy3yxzLBRCadkLItoshFFnNDYiGCixsSkYUtvTDFFguj DWnHzXA4UO/ti7T8+s0LevT8Cd17cN/YK1sOITeRR6xkFloywTcRT7CMgoUWqdRCZBVkyCy0xKJY Tl9D+etMocVCbgWhRSq1SBKC0MIg9K73SWjhu+3YRQlttxNLsn6fdfmoN0bxQ1N1xiROaKK+0K9v sq6QQoyKda0TVayeS+x4cCu5RSIriRNtWVhaLqblLZNRLArbuLZzCSvWpQEuSwss9RQY/iYafSO6 +4Hozy+i8XhMk8mERqNR+vx8Pk8XEVpIeTqd0tP9fTo9PMwkFnpZSSz4viG1SNQ/cUtDaMHrBeUy i6VO0px2Xf1tRGZhCi9EVGEJK+Q+2cKKO4bcYlB4zrxvbkeDgVe5xa4KJtpub5f7jjbjabfPbfts P/R+CeiHm9j6w8TYJ6FO31Zhl8QuRFacYwotbnX5xiG2uDYev3aILVIhhlGXKbXgdmYq3vpyeUnf Z7NNXf6hlhPKxRW3jqVMaLFJbiECC5fcInGsy6JX89AWD3UlcP0SAACqoSd/fgzdjxbhZEoHGBQG gE3HBr03kjhHSwV4UO4RYWDuNmDyVw2QeL81ZKL/GSbJdBd9HucJFseE87hvMNmxZXRiF45TMMnX PzyR7gwJEgAIg54w+TNwNxpDnUu2uhil95/jViSxqQcSfe04fT8XgPVAZBE1SADtia6dF0HzhPiu 6eE1Z2CA+CYs+ntBrmkiHvILfiuMFPU5+ETdSXr/Sr3H3jZRkb6WwEtXjk0bfFbH/yB0J5hIx/G8 U8fnpe9GILOoDSfOO45dboEYphb4zRuADqHHN/0N3Y/IeRb791podOx/GrofEYNxzQGAyCJ6dlaK 1wfU5+exWn0N3Y+mwDWEHB378Xjrvv3m0bjIF9RHj7c5IoxN9AXGzABQkX8CsHf+yk0DQRjfyE4m NBkqmKFyAx0NT0BDQ8UjuGEoYYYHCFUKGsgTBEoqaleYIjXJExAqhpnM0MVxiCO0d7u+k2I7cizl Tsr38+zorD93a/ksreTTfkloBwAAjWNWTtCXV220u/uFtrbumbKfjIqL1lKZbwUuVHiChSh4ysIU 5+dWmMIJXlwYAQwVvuCpL2Ch27Jpk7Yd1/YinE/to42fLf+ZZn02m2fNrufnXLM52ew8zdemohMX RozCCVL4whWcF25sBCxUyELNCVmceevqNF/fVYIWGxtO0OL957f0+NWzpQQtVGDCiE6okIUIUhgB C7ExWdGK0/SURunITNX0/VTYQtZXAQytryhooa+ioIUpQ9ACghZtajt2oYSbbiemZP111VVHvTEI R9RVZ0wCEFXUF3r7KutqgKCFXZzOjRlSje+mcd7luKhs22vyStYSY2uFV15BoWB6d6UjZX9+Upin 82etu6h+Xe4czm8jTB4QHT8n+rNDdGebaP3hb9rf36fBYGCEK0ajkUn6nCQJdbvdqW1ubtLxyYkT tDg7s2WeZsbTdDw204vJxCV1luTMfoJmTuT8T0QuTHSdvZ/oOmITXV6cJ+vm5km5mFx6WiYX3U9U OIPcNYKfoDqXiTlNad610TwtEbPrWSwDghal6mmq78u0B0ELtN3E9kP13Vj9YGLxQ4nNHyZGn5gq +5GKZJkyuc+swlnGpNyZYV2ZFpd3Oe7KrOMt903b3Vpfp/tZTFaCR5k9IRclduhy5OlHm8WINFlg uV1QMCq5fN4XEmcnAgCA5lPJg9ANgQeD9fEgHwB5ZNB7a1g1mTYPFM/sXVY8ymybkAh9GQ7x4Nfy SJ/rZ3ZENukXBC3qhxMi8O/7Z7bfP8nDc6AlFI7j/LAujuP1w78pPnb9yPb9gTwoDSpG+7acL7hv 42Hfm4H79jfe73K+vhvaIQBuGb3QDlTIYdkVOT7lOJVssmo8NLo6Gv//RfzfWNp076r0sQDMR46T HyU2/ko2ZkPyw/jg7+Q14f5LHfRCOwCi5legdtt0vgbLgfgmEJxsSBL587Ujn3MRD9WP3iscSsJ1 EA+90A5UyMri4dw/vf8SbluCvFUw48pCO8FEPI7nRZ2VS98dkh03gb57ffj/8T353/ZpaGeKyPfM CTwRw1wfved9IAkoAQDNph/agQbQC+1AA+iHdgAARcZXabz3gTDGLVb4mmtPx8SFdgZcohfagQr5 HtqBWJCxp0O6ffc8IGgRETIW/Y033gZjE+sDY2YAKMl/Adg7g9ymgSgMPxEp6SIVR8CISuxQl7Dr jh079rkCN+iCIyDW3IADsEG5QTZdW4g1qUpFhKI0+M3MS56nxnESOzO2/y+ykkmmM892Mxkn9vsg tQAAlFEl+dS7bHm7q6GLi1fkC/e2MgtyIgvaiCislIKcxMJKKlhawcIKLlt5hZVZ2LoPm3p5ocW2 TS3Q2IcuCiCELq4byyny6yRpa2XfP05nq4UWLLOw5ZWSUGiRhYgrtjILee7x4yVpyYUWWVhpRrnQ 4uxsTff3Vmjx6dtHev7+NQ2GA7dW+UTNvtCCb75gwigtsv6NgiKLh4UURlRBfzcCCy230GWpZ6QW TmTBUgu+l3blJv2JzGJltul6U97umW797+1F6FWH0KIdbZ+C2GQBTQGhRbg2YxJA1NFe6L+vs62W CC3yVQtEFeuC1z1RwX/lFiV9i9zCyB+oguCCvPKulMB+euFBwd8+8erq10i168swZPXGRItLoh8f suY/Ez2dLOnX7xuaTqc0m81oPp+beiy0GA6HNBqN6OfdHf1ZLHJCi9yiZRZOXLH0Hou4QkQUSxFd KEGFSClW67y4wi8/SFnVl8dabiEyC5lda/nFRmen5Bay+3NLybGRllt0WdJQd1LwU9IHgUaf++1j 3032H4uYIKY4YomFiS0eJsaYhNo+twrKIpoQiYUWWoi0wtxnz4m4whdcmOd8mYW0QVQ4pXwxHtPL 8/MqYb+h/ExSzyK10MIXXvhqtV1KtbJl300LAACgZtzJx306Sfz62GT3AHSUJHQANXLUSe9uXORx gi/8xUXT+zMJHUCbcAkYrwmJ90PDCYjkRHEkKm8xBVIijONh4OMLvtjx1gkY8L46Egi3osEkAMqW 1CVQTsKGA0BvuAodQI2kVSq5MZ+PSyG7awY9/08CxwKqE2six0PA99MHoqSgvA0l6SHmxu0B42+9 XIUOAERNGqjfJFC/IDxp6AD6hhKlc7KhviW/igXe7pBbxEWXjg0OPm70hABd2iangs8rS0MH4Yj1 u5BnTYx7LPGAzKIR+Hdb+bxKAscic5jvZPczEibWA4/1XzlpNH6XB6DVTEIH0AJinRtFgZufYQ4F guLm9Pwb0C3Z86sw32sPIsWD3CIuuvTZl4YOIAaU0KJP13AyEFpEgrt26QvZ9yRLp/D98WnBOTMA lPBPAPbOJ7dpIIrDL0AXkSokVghW2SDEGbgBK44AO25BWbBEanfsYMsObgA7NhGVwgEisUKpBFSV +idNpn72PPuNYwe7jT0T+/dZI0/j2DOO3WQ8Hr8PUgsAQB0GBflX/1vp4OAT7e7ei/M6SKiWTIhs IJFbZGILnrPAQoQVicxiGScWWYjYgueyzJVaJDILKTvL19/5LgoghO7smz6/RFZh0r9dmUWSXKFF Ms/kE5dWRjFX88tUWuGmc3JFF1pkMc9tU4QW5Z/5cHhBx8c/4/z77+/o/tPHai/NyjzWRZhEIJHK JKzQItVNROWnQgqeTJJEWsESi1Nzmgot4onFFlpoYbL15nYSoYUWaKRSC5NILDivg0lDaNEzILQI a9tNlRH69jZNSEKLJoDQIrz1N7mtLRRarK66TkCgJiW4cOQWFcsemEEquIglF0Vyi/iNBalMWKHD ChcJLvLvzYswyqQZ+e0pFg+Ijp4R/X4btTNfR+nREU0mExqPxzSbzaLrpmXU/hzSr5MTOj87y4QW 0Zys0GLB4gqbLgpkFlp2wa3e/OsL/Z68vIJWpRVOWi6d9bUAI27dF8kuKJNbSBnx1YF9TQQXru6O smVF59dg4AgumqTtAOKbLKsPcglfZfapXCnbF74D+DdVvu/9ElCPYkKrDxNinYQm/0+cJp4tR/Ja THG7IN3Rwos16VYuSbl3d3boYdQuq8ATSgbA5GUVuqWoBRZFrc2ytK6VSxWXlx2gcE8qAADYTvZ8 V6BFvkTX6vu+KwFAoPR+0LsN7sDBISAWuD5vIA6qhhoQzgEYEXg/HHig+NQGEQZbBGQWwcLHgY/H HzyAcT1wbgcLHwcOoIyHiwBoh5HvCmyQtddL9rp0SvjObwtu/x9CwrU19L7vqs/YfhTu259S0nfX tyAPXUMe1Mf3780Y+a4ACJqvnsrt0u81qAfuDbWA9BWqwIC4nxkGIrdAP6FHOiYW+WeM+Vt3JXvd 9JkgBLgJ3wIbVzbyXYE1vNjUhuzv28co+4Nw7jYJf7aHvsZCKCHXB8JxbgoOGs3jXZ77rggAoB4c BJ7Q512Fke8KBM6e7wqA/qKE9Nym53tAGOuwvYjcAhLXMOjSPZep7wr4psdCi5cQWvgn9+wSfqv9 I2Nm9jFmBoCMKwHYO3/ctmEoDj94yZKmQ5dOhYFm6hD0AgW6ZM7crUcoeoJeot0KdOraK/gERroE CIICAnoCI2iNNI5UP4qknxhakRHJpMjfZwiy/lGPiRRRCvU+SC0AANvoknSK/zFy+lBBx8cnVJbN 4jYyC9IiC7IiilpKQVpiUUsqWFrBwgqeruUVtcyiXre06zWFFpsypUDjsaQjgLjPuOvmxl2nm1VJ a0ubopZEulohsTBCCyOd8I1vhbzCfGd5hZFayHm3etoMuwktDg4WtFhc0nT6nL5efKFnJy9ErZpC CyOwUPUUHymYYOEEiyz4oyQWWlChRBZaXKHkFbSRW1iZhSu00DIMKcpQQovqzgo1eJ9KtFGVVrgB oYUmhqrvO4ZUhRZDAqFFNEnzBydWMQaEFvFt32dZsZwTPdVDCiz8q22WbRVcdIzRyC3qZMZacFE5 gou2wSehmGxZzwxEzRTFXcr1STBMlZ4QLV8T/f64LvIz0dN3/+j6zy+az+dUFIVa5/vVFf1dLpXQ orq5oXK1aogoXJkFSy5WYqxazvq7FFHY5S3DXXVffuGKLko936rpxHxXbmG2VesK4YWVWQi5Bcn5 znJfUv8h5RZjlUKEkB+E2F8uEo2Q+w2575ASjyH3H7pescXBxBKHIbZ4mBhjYgY7TzzTRjQhJRbm u53m8XqeElpMJnZsB0dwIaUYvuYd8/LwkF4dHXUJ+w01VWiyJSlbkK7woq116dOotQ27/mgBAAD0 BHcgp3wSHSyoxxdqAUiQbDu9ixfkOblDbp3E++RnVVWfQgcRO54O4SA+VBJ+TqiAl7LGARL+jwbz AgYSe3VE368VhGM7dnBsAzA8Kd2vehO9OveluTyriwUj4TpHsq/omYYOoEdmoQMYC5zMi5OmUP0c haViaBenBf7+Po6U2kigf0IJBnBc5sssdAApA/HtaLDixNCBZEpK16Cdr+P6uOPtznqPJh9i7Ff2 NnQALfRyH7c+dj9QfX1D34n9YPpCnOsE6oMjRM4Qcu0H/h3/0HJYAMB4eB86gJGAvr1b0H0cIY0C e8eRr+IcTQspcUWy7XCk9LxrFjqAkGQutPgWOoic0c9lZoR3l2KF+0EV+hkpANnzXwD2zpi1bSCK 408NgUBCCoVSOhQ85gt0z96hX8FQ6Nq5U7yVTiHfoGu3DPkAXvIBAtmrdu1SSCAlia36SXfS01m2 lFrWu5P+P3P4kE7Sky3E6SS9H6QWAICmRBX1D3ULnZ19p/39F2ldyhKkZCKbnhi5RSG24G8WWFhh RSazmKeFRRZWbMHfdl5ZapHJLOy2i3oLvwbJ2PtHePtWLbRIa0mWtpZlElk9K+U6p7rl9LszIZ94 ICuvkOKKon5Py3KLByoEF3b5RypkGeuFFpyPL4p+0s3NLxp/fEeTyy90OHop9qqcgNnKIlYJLXKZ hRBa2JKKK+hvSWJxl9wtCS5ymYURWvC65Hqt2GImPlJoUUok3SR5dJ/xYdchtPB//SEKLdrGp+T/ 21wvhBbdoS2B8OmY1l6+LVbEsYncYmm5NfsaiU8ut6A1cgsSdZlKuGraMzHNTSVMDdrJUR53vryi 21n0Sl8T/X6/KF+JDj4TvXmbzTq5uqLRxQWdXF/Tj9vbssyiQjrB5Z6FFYtlH502ufDCkVbMjFxC SixmTpuq+e68KiHGXBYqBBdWZ5fLL6Tgwkyzggtb5unvGJWOGRfZvg26TCDeZlLwIcglhiaWGKJU QjuB/7a2r71fFp/i8CUWxrd4GB9jsnQVl5VZpHWxXVuXYoodp1iRRWlaRbtccCGK3e7h7i692ttr EuoRZQ84ubIK2WOUAou6nqi7LIm2VT3cuvmr/jA/DzAAAAgI81DkkF5eGy+uyf9oBwGAxwzyoXe8 IN8qY+0AfEYkqcUD4eHACRX4paxzvJTlJ5z00iTAQBKvsIAAoAYnuQuO7XDAsQ3A9ujTC71LSQlN kpGYcJ2gDff/OdnXFOdxb+nTuSDWDiAgOEkmEjH1G3v+xfjL0+nTeRG0T9z1Bk0fCuMYwyXWDqCv iHuZGAcPA5ks/Fg7mIEx0g6gRaZNG5r7CTzehHPE5kySJIm1g3AYaQewhudGzv5fcN/RJNQ7JRy7 GvD15HST/7AOISqFyFmHT6Y/grEWAMJgrB1AKOAe3kom2gGAwYJr0f7Dz7HEENSr0adrKS0ZuzoQ WgANzNjbN8rGZfDMjd9wX+q0SwktAL7yTwD2zl/HaSCIw3MXOsJJlHR3ooKeAiRKJBqEKOl4C0QH QvQgKioeAVoqRHfdIfEAwNFeAYgmgnPYsWfsYWMn5rTxrr2/L7LiP+vdjeLYu+t4PkgtAABt9Ak2 dcdNtzdldHBwZUUi0cgsSEQWVIsoKikFicSiklSwtIKFFbxcySsqmUWVtqjTWaGF5qFiCy1zG4xP ANGf9D9bW/hYX2jBaLjaSmBRFKeyTiUW1bsVWjSTLvviCp4WRl6hIgsrxGhkFo3Qop3ZbIcWi09u +kkPnz6gW8/u0/mLc/Op/pVDqNCC5RG+0IIlEyqbKAUUVmjhXqWoQt59iYXOl++SzgotypfILFSe UfivDqEFiAyEFunnP9afSUoB+7eVV+h8IbTYfh6h8oq9f8i8Yu8fKq8e+66VWyy9Nopp79br+9Rv 2cgtSrHFTofggmkL82vDCCtdYYa75mct6clLS94+u2adfpQLRL+uEX175LJ8SXTpXrX+1fEx3Tg8 pOtuendyQgtPUPHHLeu8L5n4vVyVTZy2rOva3iarqJelLBVU6HybGEOFFrqPTV+Y/Wu5hTkmeJ6/ V5Vb+Ns7DoszH95DBxAPWVYOcolYZeZUrpYdi9gB/CG0GIZU6qGkVh8mxTopQ9TNL0ElFnVTSmUU Mr9r5BTnzORLLmYmbS2z0DyIVpqIzOX5nK7u7fWp9k1qWoe+qMIKLXzhhd22rrW6KU2fLybdAwsA AMYLBz/I5U/kL1w//G3sSgCQOFn96R0PyAfniTvPZvuwwTpEZvGYEKR2zNwlPJSVFOYc/oamdf3K DRUAPEcwjQo5trnfguAu4wZyCwACMrUH9WxgPOkrsHCWz/vol6YDP8j7UQLHgkSYWDDYHwkGyUwZ jDflA8Zf/oOptZFAeCKN1+9HKBMkAto34eEg0yK+xb3MccIByt5Lvx8Mw5TaR182JfDGlXILiLcN PrhrWVK/V7l3lvq9ojP132TcjdurCKgXF25fvJb7WcHu1Zrz0xHhO44NXx8QEBGAxJHxUPT5+rMf uwKpIffQcM0FsfgauwJgEPg6BUH9wEzwPxLfY1ciBtIf4zGQ3MbvILSIhJFZfCY8uzQ2+DxxJM+e AZAlfwVg7/x5m4aCAH4dAkVIGUGIJRsLSyU+QHeGfgKkbrB1YGJAzdgJ1E/Qrv0WqdQPQJG6VmFA zExu1cTGZ79zzo4dO+XFd7HvFz3F8b93dqzk5eX5fia1MAyjCTsl0x/rNjo9vYDh8EUyTRKLdJqL LdK0n6ncYiG2wGcUWJCwIpVZhElBkQWJLfCZlnGpRb6+fN2bQr8A4vHoPLayeNJ0s2m8C5EFL+n8 eSKeCMOZm/cAqXBitiS3ALh3AguSWdw7wcUDm0dCCy62mLFnSptbzmCwA0HwM5n+dvEF3n1+D0+e P2VHmpdD0IPkEXP3SCQWJLJwAopMZhEXLq4IoiATWvDXuDyRWbj1i0IL3D/Vh0ILepDQghJFk3SD Yu490qdAuv42MaFFu/VoSXK/yX21sd/HoCkWwoQWfrf3iaZj2bDQIr96XmBR3J4vz0QGYbS8XYM4 Mo0Fl1tETG6xKv0vTy1cJ62oWrdqnVXCi5IUxPPXAH8+xLPPAZ59BXg1Avh9dwefbm7g7dUVnNze wq8gyAknSGhRJq3AZdlryIsnihKKWcm+5oV6QiiXV4RMWFEmxAh5gYXgIvuVwLZPWu0uaTbNz4QW wAQXUVT5O4mv34S2ZRa+6pMQcUgINPoi0ZCsV7JuSYnHJuuXPi5tcSBa4kA0nRdCY0yEqOSHpmFx DSXNqYKYgsQVOZlFzeuc4IIVqnc4GMDL3d0mob6Jyx4syyp4a5ALLOpaj8VtAaCyJdtkedWbp/OC MwzD2ALcYOK+JGb7G5exdBCGoZm+DXrHJDBgN8j75Do+52PpIDTCrrVjsJtPtx26KctrQgdjfdxA fbzRwj7Du8MRNEjQ1HVYAp8D6VgMb+ANYT9MbGEY/81IOgCPXNKEu2l5Aun3oKEPbP9/R5Gatf/V MJIOwCMmaViPXia36DHU/6IqmaxSRtIBGKq5Fqp3X6heQ57L+lWMpuDvRSd1PgP9ycyNeo7i99OS SbdDl87xdNVC61fyDo4rO5QOooRtuKYP1uk7c7KDCZiwSRv4f5aXflA3RmYK9vmkCWxPTqwtYhiq OZQOYMuwz7NlxtIBbBH70gF0kKl0AEar4LhG6+dqj5F0AB7p5RgJ1ofXp35+7GfbM6FF+7h+tzGY zKILHNv/SkZf+ScAe2eM3DQQheE3pkmR8QEomGSooGEYWgo6qgS4gY/AEaClYYYTZIYLpKJ2Qxtf wVVo02QYIGHZ590nPa0lWySydr37fx5nImm9+9ZK5JW0fh+kFgCAkD5Jpk7t8/W2io6Pn5AxzepY XiGSCSeyoEpE4aQU5CUWTlLB0goWVvCyk1c4mYUr+7cqp4UWUoeTW9QCjbFIUwAxDOn0LYxB0svK vl5PO8syCye0EKlFLbdwIos/Sk7x24srapmFrGuKLkRuUUsutMjCmFvaJrQ4ODB0fe2EFl++faRH Jy9Ur5oJlUOhBT9CwcRKaWHbXykobDwspFiJKuhXJbDQcgu9LOVWUguqZRhcj9QrD2lPZBa8bIyp lnUfiif2WxCj/Vh9htBi3HZSSXK/y7p2UW9q4oeh6ky1X7kwoghi8NcPVdc94xDxVtfYRMQWVVnT HH/1RSQWE/toCC6oRXBB1J7+ty19sE4r3JaOmKiZwpg6XhfWGbYn78eU6Odzoh+fbJWfiR6euPVf Ly/p9OKC3i0W9P3qyo4V1yUVXXKJG3vy15BLqLJdMopKXkG0vt7WdxO+jpSggtoFGLdqu16nR+0i t5A9b5TcgiiQW9Dm86RNcosYUogU60qxvZhtlia0KLHPu24/dr+ElOJIJRYmpViEFGMSohyLW5ZF NCESCy20eDCZVOs6hRZeeqHL6DpC55jE8PjwkJ5Op33Cfkn1aDAUVWihRSi80Nu6nqEEY5Ou7X/e WgAAAHeHE6aW8uXQ2bYE9wCAMia9+4m65+SSwJRyDNw1PPH8bewgUgMJh7JGEpRjkvjI+P8rkcSA /Cg2YSkLD5DAJ2vO7fnoMnYQAOw5OY27lvzDJ/aa2+eziLGAfrBIbZmZDHRfOYodwIAUmbDhHuDa fplI8meIhbrJaYwEhifWZ81RpHZBfDC+GQB/H/PM/rogSJ1zg8//5/56ANgBftyYzfV1Y8y8a5sX ZPNxAteVhuNDotfx92XMP+tTyP7t8rySJeEzLlX4mHLneRDqfifmY6UJ7xOILQBIED+OfRM7jj0D 14wV/h4mxlcAgDERadosdiAFkNP4vbh7CEpoUdI5Mn+v6JUxprj9HRslGcV3LPJB7iu9jx0IAGPy TwD2zl7HaSAIwAPiikgo7QmERDokOt7Ab8JR8QA0lHkBdLruOkR5FfAEQMd1IFFcGSmIB7jm7qQQ 47F31rOLLzbCzozX80Urb7Kxdxzncuu/+UxqYRhGG3ca6i/bZjo5OYP5/LCsk8SC1+ukn7mTW9Ri C5yiwIKEFZXMYlsWFFmQ2AKn1MalFk39VfV+PpCu6BFA9I/sujUJLeoExKHMoipcZlHLJjZeZkFi iu2W5BQbL60Iyw2EogsusuBCi1pssSsD82x2A5eXP8r66dc38CB7Gggs4mmpi8grgYSXSTihhddN FP16IQUTU5C0AiUWV/mVF1qUDxRbcKEFk1nQwwst8lpo4aUWeZX+F+s86bMJLUA+QfuUhBZDo12U sO9+tCS5H3JZQyxXq/hBw9+ttu+o9PxDLUuyb0Xr0SiqyMM2klz4wl7r2p/XWLTJLbqmDuZph5va +GtxeuJYaHFbfzH3ihHtY4BfL4q3vQO4/xrg8BHAz+treHVxAdn5OZyu17Aunm+dCOI3m5JAgoQQ gUSC2mmeWGThptgeyyk2UR+N7ZHcIhZmBHINqCUVJLfg0o1YbkHrE2r0usktqHXMUogxx259Nvc7 RamEdBL/lIUWmiQSWuIgtMWDaIyJ0BAbySzKOtQxlcMtFFWg0AIgkFUEMouW54HgghXqd35wAA9n sy6hPinKM/hbVsFHiXyEGI8e7+4ou3Rs0LH9to0pv5ENwzBGhrsJZioXNX0s9rE/SAdhGCNgIR1A jzReBO0uDMc2uwmwX7QmeBDBJRzCxOyWcCht7KasPVN81kuwBD0pgzcyTVJq4X5HcHxi/zPSZSkd gGEkQCYdQI98c/sLlthrXOC2+mQ3iYqTSQfQIyvpAMaEJTyYNP+VUHMCZNIBGKpZCfW7EOrXkGcl HcDYYQmHnstGYgwI7lu+deISo39SGjN+b3rRnYfG65+O9xxP6nwp9ju1nqNaSAfQkaO2N7hjou/B jolqh66D+KffVCcssfOd+jGxhWHo5Eg6gBGSSQegjKV0AMbk+SwdgCECHefSuj+dCimN3Sd1zt+E Fsa+wO+aSUaTBrfpMZ5XcveCG0by/BGAvfPXjRoI4vAgpDQRaWiowEWaUISOEl1FC09A0lHmEXgD /pQUSFQ8x9U0oEhpoAlNJLqLRIOCfXhvd+y5vT3iC+ud9fn3WZbO9to7PvvitbOeD1ILAICkS3Ip kyjg6XUb2t8/XJFISNEESyyMlIJlFmVJTmJhJRVGWmGEFWbayiuszMKWrZpyUmjB27ByC2oEGppA bhG1xsC0L7SQKWlZaFESp6dl2QTLJ1q5hfl8VZ87v5284qqRWViRRSuzaEUYcpRCi1LEEGZnZ0aX l9/o4OABffj+nu4e3hd7tSy0YIHF4rcjBhZamMEIJ1hCwUKLRmThxBULeQW1cotGZuELLZwMQ4oy zODLNBaijXnVCDcgtPDQ/grGJrTos+7cRQmp68k1yX3ux2mbhRY5CSBibE97/Zjb+p/1R7AfQbnF muWLdm81v369wGyWWCzEFiy4mAu5hS307xTAfjrhdWmIb62Z768XKkuBablrd4h+PSb6+Zrodj3e e27nf7q4oBenp/Ty7Iw+z2Z1m7QVQcw9mQW3zJeUcwHRhCwrl/8JjEvLqyq43BdclN66LLFYkW4Q LS2TLXwWXDTTJO5ChBAlSH0epGoGxEwunzpRvUZifK1k/JBKpK1Xe7/7qF97v2QcuZBbLDnFY8gx JiaH2PzaWWjReMaMzMK066gVWvhiixWhhZFgeOXkNnxnGcdQ7O7Sw729LmE/oVZo4bf8pNDCF174 OrSuyrV1LdhNvloAAACbc0zj6KxmOkUeawcBwECYaAcQkZWO0C4RzJTsC9ggHjkneEhOfZ5NyJ5/ J8qhgDTgpawEuAQ90/rjK+1YQK+8ra8nM+0gUiKST+FFou3mHeRfAESh0A4gIkaKgPuF4fIGyUdV KbQDiAhe4gegOzdKqDkSCu0AQNZMlepFEtvxgvbNDamvcQUSDo2Oo/qYf0UCouhMtAOIyLk/w7WH zd/aZ8mj2W5y71c2lPugR+Z6Flog/teLZ6LDobP4wB3fjwRhyZCA2AKA/IBQfXNwL+Vw/VXxPA4A oMkJ+lD0yja128+1A0jFSIUWPwhCi6S4ZzLmHZYvhPbgGDgi+zynUI4DgN75KwB7Z7QaNRCF4bOL hUJFsd4I3vTG6wq+hogvICqCTyB4JeQV+gb1snd9AMG+QEGvC9IiBb0vrVvajZnMnOQkmbi77mxm dub/StjZzWzmJM3uns0m54PUAgDwL0aW9rtZT9rbO6CtrQdlWxfypEa7OUmpxbQSXbCwQssspuWk 5rPYQt3yPCm1sI2n2462yBJAbrH0KJb7XGS4llhIsYV+nNsssrg1UopaZiElFfp2YuQW19SVW9Ri i7q/FGSwQMO+PcZjVZjvjC4uftLb98/p45eM7j3eFmuVNwolsyyiT2hRySyk0CK/rsUV9KchsbjK rzqCi0pmYYQWallyuSy2uBV/ZRRGaNEo+DyjOHQy+N4EEFqsx7KHIDRZwKqA0MLfMkMSQLhYnu/n u1wWhBZzP1eLF/pzGM7Fqr55T94zx3ilxiIf1XILJbugcS24sAkt2qWEpeBCli2mVh8ptLCVK24L LGzj2coO3ymy3R2iX6+K2ftEdz8QbT8k+nF5SZ9OTujF8TF9Pj+n35NJJYRoCx8qSQRP1BRYqPsd YQX3a0kpbhaZ35Jb3Ji2TW7By+L+01bsNrmFnHh95T7TLtIt+68ClwXBfcglhsbXmCmNG8LYPlnV +L7XiwkpjlBiUYQUCxNiTEyIsbHMomyTOrY3rtqjtpiiJbKwyi0sfSrBhZh43PsbG/Roc3OeUJ8U 0zPqyipkBikzwj5Nmm3qyxjl47PmzyPUBgAAMJtULoLJUiuOC8ASRHvSu7lYAoVg3BN6gYfBEIXJ vxLEKSlSXpSF4kPuMRfenhIutoidsyJnz3wHMSQoPpUMKlfKfAcBQCTElGPHtC6pooqPHiH/Hxaz vWN6/eBC/sX57jsA4BUUXLQT0/sicM/p0APiNZo8yG/+g+J1o87bUNsOx8DTY5eQ37hmx3cADmm8 pxb7yRvShfCQ/7knC1xMvU6fD51zEcXvYeu0HkAz83u4KNL5eqiggDPU//cQx7gB8I95L0WOtzi7 vgMIiMx3AAAQjgsCfQ7Fvu8gYsPk69Fc+5Ln+ZHvGIYgUaGFOpfjKYQWw1HsZy9Jf/5CIpsW6nvQ N/yuBGLnrwDsnTFv00AUxx/JSFqJjTEVE/0G3Tp0QerAyI5Y+QIsXRgYqnZi5QtUaj9C+QCoAlXd u3VCImJoh8bcc+7ZzxfbcejZd7H/v8iKnXPuzlbiPJ/j94PUAgAgNEkqdWimN6sq2tl5bU5IitVp 0QTLJ0RkMZ9TJqTgZ5ZUsNCCpRUyv5BXLGQWIr8Q6YUWWjw+kpJb5NKM2IDcYu1aabXQgqkSWuQy CxFZLJ5ZSCGyilxcIcIKKSvKLURkoUUYucwiF1qUMx4/o/v7X/TwMKNPX97Twed39PzFRG1VUQ4h QguWR7hCC5ZMiGwiFVAooUX6sGILLbQQiYUsp6+x0IKKQov0YWUWIs/IRBb2oZM/6z4Dijfpf5tA aBFX3W21EXt9volJaNEGEFrE936fdUFo0fy9ibtYIrhIlssk7s1ioqSh2MuuIhKLVGyhBBcivbAr 1U9lcgs3LbGUlaUrrpJljCra0ad4sk+2iP7uEf3+apo/Jnp5uHj97O6OPlxf08ebG/oxm5nYMimV P2QRuyqT1xIllHDlFu6yOxXKzUlnWbm0JYILXfdcTbouWd+VX2h5hWwHqW1MnHWqPho+v36+koKH SA4for2hSDRCtjvktttqPxZ5Qyz9YGLphxBbf5gY+8TE9DkS3N6ksonRKA+fREah5x2xxZLQwrx/ 7KxTkGKQE4bZffJqMqHd7e0m3d6jovZMR3o6WnSFF3q5LvqsK68TV9TtWgAAAA2xNzsP4SaYn+bc +TR0JwDYBPr6p3crGuB53EDdDrEneOgElXQficmHDR9nkNjWIzZmZVFMb36fQCVHoTvQJUg+NShO IVkE4OnYeBuA2OBEfIj/u6VPN+TeIkb4L7DPAMQWCsRIYAV/Ao3dTwO0CeIA8c2amOP41F7DPCGM gQ8ZiC38Mg3dAY9kCeDM5+PIPH0jHCva4HvM/yvj34rQfViTt3oB18N6gZyHT90CmzzxkpBUfJPh 7+Zl6E4AAJalUKAZGxgrecfuA8jDQAxgXBAwEFv4p09jhrehO9AFdizkioY1jsdCi31cI+oGe3/c hZk9J4y5DRU+vlzZ4w0AveSfAOydPY/TQBCGJxyBk/i4DtGRkgbxF2iooaSEComG7lrS0NFcTXE0 FFTwE/gJEf1JkWhor0okkgOPd8eZ3azPObC9m/X7WBvvxRvv2Il1K3/MA6kFAKCOUaD+pulDJydf 6OjoXlk3CTvJqbtlI7PQhSUWRmZxUYotuLDIQsQWPDeiiwtHahHqz9Rb2iMtA7nFTmsKvGfSwpo+ XJGFK7QQiYWknZW6FlvwXIQWG5GFLua938VvTNposYVej/QTZjwe0WLxo6x/+HxMj14/pRu3bqot deUQMrHQgudrO5USCxFZWAFFJbNgkYUWV9DSEVgs/iy2RBbc3hda8PqlPwgtrkgKu6HvGHIVWnQJ hBZpJc3vklTFGBBapPf5NteVyjGxh0KL7cWXCQjUOEiNfYNSjIb+KplFmcjYyC1kzpOTHjhUr5NU kPd3qN2Bt76mNMV1Z5GuF6PhCdGvV0Wzj0R33hblNtHP5ZLen53Ri9msFF2cr1Zm9K6kIJUEoth+ XxihBRN1QguRYujlq4bla2/9ayXP8OUXfjzVZ1SssrySWXgCD942R3Cxg9ziXw+BNpOCD0EuMTSx RMx+h9h3l/2nkvw/pThSiYVJLR4mxZiEVOPSiMyCKYdFNmYRT2gxxUGgbMktatpdG7liDBmC3R2P 6f7h4S6hPiRz41NIVuELLepEFf7oUbch2h4h6vebltd92en/CAAAIA2msQPoCTzsA8DuZHfTu31g 6zvhoa2uSDrBQx/Ym8J5HyDpPhAk+RAS2/4n9uG209hxgF5gEd2n2EH0BZJPDQpO5jiNHQQAmTCJ HQAANWD83y85nbuaxw5gT0ESBMBAbLEB+wBcxqy5SSfgdzlc5rED2Cdsohk+TnENEzAY37RHTsfU nF/s9bJ3USPJl/OivIwdRAOT2AFckQci37P/63A9LA/4O/ymz4EWdb4n8yvh+82Bx0g8DEB0njc3 ATVMYgeQANPYAQBgwTU8IEBs0S5PYgfQIrGuW/WGOhcyJCC06BErGJ0X5VnkUEAanEJsAXLlrwDs nTFzlEAUx99dRidFJoWVXW7GVBamstSxsbLyE8TK1tbyijRWNpbOmLR+hTT4DSzSpEuZ/iaFo4Is 7IPHAkISjrcs/9/NTuCA3Qdcjl2OeT9ILQAAhj7JpEzn6HVXRYeHzyiOq9VJ0YSRT7DIIo6pEFI0 yyxKeYWRWeQCi3y5lGDk25OQW5TSjCkAuUXr1g3zcVFvNd0riy5YaJFLLapyCxZY8N9SZpHLK36J aRZa/Bbv8TSXP7aNv9QltNjdTejmJhdafDk/oYO3z2nn4Y7dq7ocIhNHWKGFebmCiUxpkbafKSjS WIyQohBZ2FKRW4j5rNhpFltw4Xr55QotzHz2f8xyCwgtqvhwGCC08L/+KQothsan5P/brBdCi/HQ lkD49JnW3n4ofPmu5HFMm6SCl7HwS4gaatv1aG+R5BKL5WKZCy4WpdiiVW7RJJ3gdWQa47YUxX3W a5JdyHn3mDwi2rxIy1eiB5+IHr/J3/9+fU3vLy7o4+Ul/dxsMglEeRxL0UXMIgqqCi6yHr8QSrhy Cld24ZZiebpt47I4rqzjijDipCrYKAQXbbGKY1KIO3hfnX3uElz0Zcik4HOQS2i1Oad2uW0ttBPl b6t97f1iEEczvsVj8DEmxufYDFJgIeeL7lKD0MIVW9SEFstlbT1ZB08vnPaf7O3R0/39PmG/pKq+ TPbsZK/PFV7I+f/1Nrs0aH1Oqt8nHgAAPMQ+xHagHccInKVj5Eg7CAAmREhJMq5s0g/z8PuRdjCB MoUED1vFfsaitHxQDgX4BxLb3gMri4nSyWPtWMBozEZEh+RTs2OtHQAAARHSeBWEB/r/47HSDmBA Iu0AJkrwiS5Abzjx80o5Dm1W2gEAr4HUAoxNpB3AFLD3v08JSb5BHYgt7kmAx84882Cu5/i9bHus kyS50g6ig1faAdyBd+JaB8LB3AM9NRP2/H7WDAYMzrF9phgAMDI2ASnGhncntDHArbD3xzFeAF6Q jq3wGx6QmP7lWjuIQFhpBzAgQX9PzFRo8YMgtBgF8dsSBKPA5RuuuSBE/gnA3hnzNg1Ecfw5SqVI RZVQFrpAJCRGBr4A/QasjAx8DzojIbVb2crIlo9QNgaWCgkxVWFjzlIJ6hg/3z37+XBSGpzc5e7/ k053Pp/P7y52/Ow47z/0bQAAIEiyjvLr2zY6Pf1I+/v3a0EJLWbRCE00ghMiZqGTEbYwZRGz0MIW WuhCi1p07c+U+5uUTSOBTEMP5rYOdx9bl6BFofpqi1lwbuqbkLIiNmHyGxJhCyNGcVMJU7RFLn61 6oyQhbTT2+Uqz5UN3YxGv2k+/16Vzz6/o/HTh2pUxV/5wo6lFrYQUYuilrZoCVqw+EQtTGHFLUS4 guvcMrfh7aqk+hARC8lrIQueQyuwQdVoGzELbTsIAAhahN//rp4uIQXs31RfffcbqqBFH4Q0P330 5Xv7PvvyvX1ffW1jHGu20X5PJrdJRfd6KbL/qwULsmXxe5391e0yU677kCxbMQheNaDGZZbQwloh IXPa6TrpY+Fs6/ZNzna6DTMsPevHRD/LxK/J3ftaLr8n+nF9TW+vrqomLw8P6Wg8poPhsGUuj7ea gXL+cjHDCkNUgaRlvTJToivz8sDOe71czZkJEM31vJ4FJQZq/YLaGh7ST6YEKer1tl4PV/YhtnKb 3OYyJrHf/biqmhX3TO50d9HXfWQK4hKpiTukKCrh+7kKxCy2R0i2MKHZw4RoExOqXRqxsdDLcj1X y+IbVGoP9trvCluIuEXuLC/UMpdFqnchfgs1ftHB3h49GI3o23x+m+lPyvSsTF+oEasQV0cLWshQ pF57f9qbdBOpdjoVTu6i67uc2WxJPQAAAEMKQWM52PqxbyMA2DFi+oMXvxh9QXhhd5PsQoCHjWH/ eHBCOMbAciSwLf6scQdsIOALgiBRSnxKQYjOHtvTMj33bQvYGpflsX3u2wgAIiKm+1UQJ/D/t0NM 3wUz3wYAEAH8XG6a+HdvTN+LoH9mnvaL4zJdZr4NCB0bcJ+fET7ybQsIFhG2OEIwyLWY+DagRy4J v5dtGv596sS3Ef/ALvpWCKwcLy/Ka9SM4MvEyjn7qym/CwaAJyAo83+kLjh/7NsAAABYwRsW6yz9 y6lvQ3aciW8DeiTa552JClp8KM/vV76NSAH+vYCM0Ciex4Bl8DV3gnMSxMQfAdg7f+WmgSAOr2VI l8xQUpEiFKGAnoKho4NHgJJXoKOkTEvBjOl4C3gFZtxkaNKlZBg3ARsJnbQrrS/6Z2P5zne/T3Pj WCef9pSLs3bi/RLXAQAAnNNaE1P1vczbi76Bzs4eU5ZZBTqVaMLIJ0RkkaZUCSlqmUVaNCOsMPKK cn8ttpA+LcEoxyQlt6ilGYdKKeU43Pi7GDa3IUILKfEmQguRWYjQYkWl0KIUUawLLZYsrFgWwoos +81Ciz9Uyy2ahBZLssUW5fna53N09LMQWpyfP6BPPz52Ci1EIiFCCy2VEKGFEU6IjMKWWNyYLSub kVjI18V9PqZ4hBJgmFsZ04gyRGhhNltoUQk3ILRoxvWlcH3+fQKhxX7P40uR+zHH2se42zBGLD5I D3xaB64fv0t8mkugQovbh3TntZlslYAvW9s/lAlvySQhs02srbGcsC5FrEsXy75py3ET69hpw2P7 7pM1tlyPe0SLZ0Q3n4nufiC6z68uv1xf09v5nN5dXtJ8seBrpDJ+vnZpkSNzxs/3//I+6Ze+xpb3 rfLbquUvInX/qqEVfXzcyhpf+lPV9HiZxMlzqGKl+jVRqmQZMt9Mzbltfelq0sXlNtKMAxVa7DL2 Tc7pghjPG9ucxz6/63kJPsXhSywG3+Ix+BiT4GtcGh2jHa0ILap0iCUW8vW0QWpxx76fJLeOS/J9 epy11I7jeXh8TI9OToZM4SmtZ346M9RZ3rSlT2d5bVlmVyY65Jvs/0IAAABP4EIJMRRSvcAH7ADY mFPXAeyQVwTZwJgcSoGHnWOKkudtRuUHD7DGQB9S2Db2D9AOAkKLaAleuKfWdgyvw0BN8GsbgD1z iMXbQHyYPBYFGcYlpHwq2IINI4PrBmzMc2+U71MyyJFAF66eM1FQJV6uXAfgM1zU6hvhZwT0I2IL /J7fnJCu2RPC38vG5Ffe3rgOYiCnrgMAwAK5TLiYHGTmOggAYsIUHaXy/1zB9jx3HYAreP1AJrY9 If3N0Se+uw4AeMcM73H9NyE9X125DmAMILQAY5Kvr/f5zVfC+zGgn9e8XgAIgn8CsHfGrG0DURx/ BhcCCYF0KnTs0m+RfoAOnbMFSqFLt44lmbpn6dy1X6Bd/RHyBQINFDJk6RDqEuy693T3pNP5JMuJ pDvf/X/m0FmSde+EkM+S9X6QWgAAXHzJpN5v+tDFxTfa3z8q6joBJ9Xq9VLJLOyixRW6zvIKW2bB dZ6n68tiWkkt1tvT9T52RzjylFu0CS0qiYUtttDzpS4ii2VNSKELv78300pmUYksqqle7956bwst RJTxr7F/OnHgNd3d/aLTd6/p449PdPj8qdWrVS2hscgimoQWpczCFlqstNCiEFfQ36quynw1L9+z 4KKUWlhCi0JkIUILeam+2UKLIgojtLDj3TYZc/KE3hUh2g/VZwgtxm0nliT3Q25riO3GJn7oa5ux 9isVYhdBjLGtWIQWW7bnjpPWV7PGUE1yi46xi9xiMjFTn+CCaUs/PDHttUkqXMlFm8yCrHlu2+TU makaWb8gunmrPvKF6OAD0RM173o+p89XV3RyeUnfb2/pz3JZ7po12QOJyq4ujHDlEgtrmQgoFs6y hbU+r9e6vEFuYbcjpdTteeKT/sgxIXILb9kgt1AHQ2+HdQ5yiVBt5tSutB2K0InyIbQYh1jiEGKL h4kxJiHm2JhN50+RWRR1qvpTDIccuYUrtvDKLXjKggsjuSgFFyYO2Y4MqQ6mU3q2t9elKy9JP/Dn k1W4QosmUYU7OvSNAn0iiy7Lm3Zy3AcIAACEI4fEmvzwcc5JjAB4KCn96R0Mxy4leOgV8yDgjPAw INgOTjjzNXQQsQOhRbbwg01JJ6XFsZ0tLACbhQ4CgFQw51II5cCucGxEiKBnzG/yZEh9HDwgv0MH AKKEH85/EzqIsTHnRYyRQBujf9eo4/LV2G2CeMC1kGYgSwcPQMQWkKZvB5Ikgq6cq++tn6GD6Aju LwEAxuTYJGQFAIxDdtc0ByDn30znoQMAwAPu4wEXiNMeQWpCkBT/IwGhBRgKvjegykxVz0LHAnaK M1zXAanwXwD2zpi5aRiK488J0CFdO3TLHeWuxwBzlx7csXOMrPAxWMrIxjegAx+gEzPlE7QMzHQo x9zjrr1rYiNZerIsO0kb25Fs/X+5nGVLlp6cOHlSovd/4NsAAIBXlgWP4rw34vlqVUV7e8/EQKRc nS00weITSoiCjCBFIWahBCukcMXtLR8vhC24XFkIIzVpW9xiaEIQ3J/Qg76tQ9G32lwqC1pIXEEL Ts9zQQuVnun0rCJEoYQrWKSi2FbT7rlz3caMilC19YzHRNfXP/P0h0/v6em7l/RosmX1qioOIR8s HmELSrCgBYtN5JIWWtwil6bQwhYybYQrrDTvc3lZD2/telk8I3UeKmhwVdACWPi+HDEJWnRN6EIJ m24nlCD3XdbVRb2hCj+EcN+G9h71fX5XdflsO/R+3NW+BnWxn2RCHWfVvGXnJ4uGZ9mCcolKm/EP b5IVnWABCi6WWPspFaPBjMptu8cWnefanNUfT3eI/oknHRA9vCDa+Ub05wfR18vL/Lm/vU1vd3fp yWRSiEDIqkR/jTYHB5IWx4yuhjwmr4nOy7i8DAitBSQSy2QTyVmW0yIRtfl8CXS5VLdl1z+ybDP2 6nZt3Q/b1kQZWSrvXjpuw5zjDKDcl+Q+QMwC7Q6hbd/zJRCz2BywZTkh2sSEbBuzVMyCqm4R2d/x 2oeQvkAuZiHSaY2AxdzeH43UrGaammNzFrLQ9bAPwAIacv+x8JH+3tzQr6urVV06JLXgPTeHysIU YypcDU67ea6X5wpekFXHImGLVd61e2kBAAA46AA3MQTilouP8ad4AO7B0AIDgk7pU4CH1tALQ74T Ag6B9Xgtg1ZhEUc9CPofNUe+DegSvLejJgYxSQA2yaAWaYMokMHVz4T/D9Hddpn6NqBFzn0b0GN+ +zYABMuxnOOO7LehqW8DQNBceLofph7aBGEA/6YGzA+ChrCwxYvIfJwmYA4J3IXTvszZDC14JQCg N3wWnz8n8D8A2Aj4X0FzohxvR7QeBPQP+A+gjufic0uuPTjybUgPmfo2oEVOfRvQNlrMOrbv44+4 l7tH/iYgNieEdUtgPb7o+CHHvg0BoAn/BWDvjHmjhqE4/i6lVaVKldjYQEJiRnyCG/kMXSgSC0NX 1pYdCXVkgg4d+AKsfISexILUJSwsnUCVWsr10jj2S17c5O56SWon/v8iyz7HcV7SqHXSnH/R4iYA gIComrnrzaKNDg+/0tbWw6ycTYIvZBZaMiFTIbOQSYstdFmJLVhmwWILVcfSi0JkQUJmwfIDKuVD Qp/PAR4YJRXHNhP1ZZFFIbTQMotCYlEntGBhxZUpX5lykXSdLbT4n/dR1M0XWmxsKKHFj6z84fgd Pd97eSehhRRMSPGEWpTAgtM/0sKKy+SSsiUp0kVykeUstOD22bZGcKEWW2jBiy20yMoQWlTj+nSE JrToct+uf5ZN8U0W0Ie+uuh3yEILnwQQbfTnevs2+2qyPY5jtb6WaJPwOLamcT4mTMpjfFsmtmh/ I7NEo6iU82Ia3Z5e2J6OWK5bE3WyTVTxuapO9mX3Q2Kd/PwgHXk/Jfq9l1Z/Itp+q6t/np/T/ukp 7Uwm9O3sjP5Op/kpye8QEj7X+s5gZuo4z9R0KjdpymVuJ+rs/Nr0M3c99yX2MxXrZP01xyj6nol2 uQjD1PFM0nbiNlXY7RYBoUV3+wxN7hDiMXe9f9fHxfgUhy+xKHyKhfExJsbn2Ji7xJhLqaiQTXA5 YimFKK+NbsstqnI7Rea65354CLW9vk6PNjeXCfVZml5QWVZhj+Tk6M8e4dkjP3tbstpWSS3mra87 6f5fMAAAcL/sug7gHvjVly8fA+AZ+DI8WIbeTPDQJum91G6anRBeDAfNeGWuJSDApF5B8z4ASZL6 m4lrOzyO0mt74joIAAbG2HUAAKzAR0w82Dpj1wG0SOw6gL4SwD0EWB313C6055Zj1wEAr4kd7Rfj n3CJXQfgG+Z+ICY8HwTNUNfPF9dB9IjHrgMA3vOH+vXu3BPXAQAAgkQ9YzlwHQQAQ8fcM2L82gJG 8BAaB64DAKAGvC8F6tgP9Pd1U4b0P5fYdQBtEqjQ4jWEFt2jJEBp9p3wvSXQjM94bxH0nRsB2Dt3 nIaBIAxvEBIUKBItDZGgoqCjo4CGNnADSjq4AQghTkBPCkRNT5NDpA2iyQVQhARBCbu2x5ld23nJ ydjr/7NWfrBej4ODJ8iZD1ILACoGFYGrZVfq4gWlmrqdTRtzf/9QjUb2cFxsQeIJElGEcy6zGAsr BgPaPhZbUD8uwbDH5C1bOOALfokt7HMxoopQSkHnyRuJLkhoEUotbLkFl1EMYlFF2Iy84scRWfyy fu62scwijInK1aazuTlS/X4otHh6f1C7F0fsLO0CxVwWYYQWZnIFEyS0CBQUOj4jpIhFFlGz5BZs PWjRMoktgjH0nIsyzETHI5mFWQ/et9HEzwEwpF8OCC0w9rKOIX1tZwGhhdyYRRJA5DGe9P55jlUm EcSy9p9135xkFYscLyGpYH14jkhyC1dwMevxYpVFLSm3sAQXNE+TW2SJK1RKH7fcMd/PFWNk9U0R Xoy2lfo61QuvSm3cK7UTpdQvvZ666nTUY7erPr6/45c5Vt8xuUUguCBRBIknUtqfI7egbVYbDhP7 8MalGfE2p/8wLQaK0RVkMMEFXQ9ccKF/wUmhxxTBRRoSxeGrJLSQoKpSCelC+T4LLYokkShKHETR 4jEUMSaiyLEZ5rnW3V4ktIjTJEdoQWIKV2ixvrY2UWjhjmOlTVGse1tb6qBenyXsYzXO0Nwsj2dt rvCCr2dlcNN+PklcMemlBQAAYHMpHcAKuJMOAICSggcWwTTKVuAhF/TnJlMM71k6DuANeEA8CYr+ VxNzT/G62GhFv7QGQu6kAwDAQxrSAQCwIO1I4gbywafPUijoAsByMELRE+kgVkhDOgBQaNpCx/Xp fg3mA/kNQ9+PzlX4PkTRIZAHzaiQFZhAxfJAsDg3JZMlIrcCAEhxjaLDACydG+kAPKIhHcAqif4+ 43kkAEAZaUkHUEJ8+r/Ap3QAeVHRZ4ON0KIlHYTPmOfLdHvTi7fSsQBvaON7S6DM/AvA3vnrNg1F cfiAqBSpiIEFNjIBM2sHeAOYmRhYERMbEukbtCNMXTsV3iB9gEodOnWCBXVE6RAQUcz945N7fOs4 obVzru3fF135xk7u/TmxFMtyzgepBQCAKSse9XbVm/b3D2l7+77r+4KaVOgXWxBRyObFFr5vxRYs s2CxhV3H0osgtSA3lqzfyX2/PtWq3PVQVby0PcT5Q9lVL6oolKl1TcosvNAiyCysmEIKKspFFVJo EZ5fFVn8pSDJ8HNUVTEeDKY0mZy5/peTPXqw80TsVXZl6YQWrmitkEnkQouFbsLMzUIKK6iwS9eE 3GKaTYPkgn4X+k5okQWhhX0UhBZZEFospBaZl1iwcCPeB5DTx48DQou0xm5qjtTHq5uUhBZNAKFF eu+vcywILVohtCiuFpKzUseFEKDxuX4kvlhnvpVyi2XliOPnYcBySUWVBKOszDFR+Vxym+QO0Z+n RD8/mE2fie6+M6tMjrPLS/p4fk6vT0/p6OKCJrPZ4mPIzD4HFR7l59tZQQIxj0QUBRmFeM1MbJNL Hm/Gy1x6wfIKFlbEcgspsZjL+YkW8/LYc/E6+fXGyr9CW0NuwVs1ZBZ9mJPn1aCPUglt4UJT82vv l8yRCqllSSmPJcVMTMrZmJvkY5mF64ux3OlOJKWQYgsrtJBLKbuI5RYsuLglRBd8+nRva4seDgbr RH1s2jMql1XEQotloorbS1qVMo3W3L7sS0j74AEAgA1hfgPemMUj7RwN8wM3SgJwbXCzIljFqGUF Hm5EfmP4gem+184COsdXFLb15NKYvv2xB3j2zG/KL+0QTWGObVt8AMd2P9nt0/kSABtkqB0AgGti C9geaIfoEEPtADUy1g7Qco61A4CkGWkH2CC4pg+q+K40L47L/gKpRU5+X8YRQWgB6uUTpA0rGWoH AMnzrYX3lL3QDgAA6DUj7QAAdJxX2gE6RN+uR420AwBQAa4Rgiqe4/rWfzPUDlAjY+0AdQChBWiC XFo2Nu2lahDQNdx9i/jfEmgr/wRg74x12oaiMHykSmwZWGFoBio1C0zdWqFuXVAfAcY+RsTIAlO3 Cva+RHkH1KlCFRNbW8RAFRXjY99jn1zZbhJsnxvf/4uuSGzH/q8VRxfbOR+kFgDESVOxKJl3kLYP /1vRzs4u+bUztdiCBRMismARRf5XyyxKYcVsJtNLsYUspyUY8+tMCrmFX8RzGOKHZta3j/VCi6x0 b9YvkVbkpWlzoUVR9rUQToiIopRb8POZElVw++vJK+S5L7CYqfWKzOJfY082Nn7R3d0Pmkxe0pfv n2lzsq16NS+0EIFFdmyohwgt+MHCCZFQiMQiE1uwyEKJK1h0ocUWPD8TWbjl9Xu1KIMfsi3Zdiba SB5L4QaEFvWEsDv6zjBUoUWXQGgRVtH8LglVjAGhRXjvb3NdoRwTMQktFmXB7TVJKgqFRTLf9LxF ticSCxFbNAouiKpLDFdJKqTksaCXaSqF7IsxfMEF1Uzjbm4S3b9LR+Xn6dj7mGjrTT796+0tfbq6 opPra7p5eCh2idbiifBBSyP0a7/5cgsRVOimxRZVrUqYIfKLQoyhM1WIL/Qyfl8kf+L1V8Qdjf8j OvFHX8QilrCUaMQolbAukt/V9q37JYSUI5QsTEhZhBAzCSFnE1bN6L9LhBbFEMgTWoiY4gVLLERo 4YkrqoQW/nrmjBAu+6vRiF6nbQHeUjmS8yUVepTmCy/06yoxRd3Ir05iscyuBQAAkHNkHaAHptYB AFhjxtYBQNBcJklyZh2iL9yNu98ovh8dgH5gydiFdQhrXGEvSGPihEV0U+sQXeF+eHlqnQOY8Cdt 0YyXAOiZfesAADyDj27sC57PnnWAFvlpHQCAARNTQZwhfS+C9um9eJg7r44i/vGCgnVUiJzPrXOA wQJpejOxFbIFy8Hn74+sQ6zA2DoAACBqDl1hTQBAy7jrRjiH0h5j6wB94b6XcU8rCJnf1gFA8Eyt A6wZQ7oWuPbXECIUWvD5tPcQWnSLu7eBj48hHe8gHPhzdWEdAoBVeBKAvTPmbRqI4vhLVAmpRZUY 2JBggp1PwEfoysaEEBISAxKM+QjtxsjKxoqEBN+gjB0YioRYOlFVDFXi4LP9fM9XXxIRX96d7/+L TnGuzvldfHXOkf1+kFoAAAx9SaNernvTyclHOji4Uy3XiTOps9wtVkQhSy22qJeN2IJlFiy2MHUs vbBSC2pFFozd9s040xU/bE5affQLLYy4ou5Hm5a1kksUxYI4NW0tu2DxhBVS1MW8vm6erczCiizs c73etXjNQos5WVFG4e2FSSBXFD/o6uoXPX91RG+/zOjwwV3Rq+6DZRE+oUUrs5BCC5ZZLCudhV1u ZBYssqgeLLUQQgvTlmyXxRZSaFFF0QgtZKLkVcmWgSIQWsTffopCi6GJKfl/yHYhtNgd2hKImMa0 9vuHIpZj5a7lGK4M0Jl/uet15mau3GK54VxtaQUXk8kaucWqwqmKifrTF089da6oYtrTVp9Qo0dw sbxVzuAfEf1+U1a9Jzp8Udd/v7ykd2dn9PT0lD5fXNDfxaL9GAu6Kbho5RbUlVf0ySikXGIuZBYL 0U5HiCEEFnNHWDF31pPblO3wmQ/XFyJOjpvHBMstuL+dIsaMmxxerheKXSc01xRLaKCZMD7XbYfa fizyhljiMMQSBxNbPIYYYzLENI58DBkjyyyqZbL7pZrGCCmFkVmw4KIjs2gkF6vkFiy4mAjRBU+P bu/t0b39/U1CfViWx9Qvq3CFFj5RxdRTfLM6Wb/u774dEvdgAgCAwDQ3MYw9AeBPXCwJwFbgIljg I9UED/+FEFrgfwKExCS2fa0dhBZl301iISR+z5eZdgChaM67PimHAfQ4Ls9JcXM2AAPTzBsASJ1j JB7djrEdC8o5w7l2DIlzrh0AiJ6ZdgChGdtxEQxP+V2jkRwI4zJjML9pE1pB5AxCYpLeftAOImLw PQRW8SzR3+/vawcAAMiemXYAAIyUI+0ARkZO5wLZXm8IkiHF8y6wW3KS02/FyD6nP4n+LlNhrvfJ VGjxpNxv37QDGTON7O4rQXgHwpL1fUsgXf4JwN75rLYNBHF4INCLSyDXnOxje+610EDuJaceW8hj 9KLSU6HQvkF96QPkDZJHqB8gpJAn6MUEh2y10o41Xq+UkGw8u9rfJ4SsP56dVYSyNvJ8kFoAUB5D RaJ430k9H98XaDZ7RcZshpNiCyueYJGFFVG0Symz6IQVqxVv78QWfJyUYGzGNGu5xUOEDnmJHx5H +n0cFlq0dEKLVmLBS5ZNNCVhhYCiE1S0YgoWV2zLK3yRRSfFWFEnyuA2+oUWe3tENzeL+vpc0udv p3T09QNNDl6KXm3LIRqxhfFkFvVkJRONxoIFFEJo0UxObCGFFiyx4PVmm5NbSKGFjMvyjLXIwk1c ENnPGQTQPi0QWqQfX/saeSwpFex/rlix46YqtIhBSucnRizt98ckpb48JdYu+pGB0GJ7txuLhSR9 crJjtztPcNEX3NvMEotGbNEnuGgPvF9uIde5BDKJbbzeVxpZvi8kxSARzy+JbLt2QPTvqH7xm+jF F6LDN+32+fU1nS4W9P3ykv4ul+vTIAUXGzILJ4UwUkDhzbeeaEJKL6zA4tZsyzD8OSTMYPnFWmwh cuBcWXxx13OMzJ0FF7K/IcFF6DKJeXvQKGhemlhCs90S237O9lMp/p9SHqnkYkktH0uKOTGp5iWJ JrMIrLPgohnOeEILX1AREliEhBYyjpRZSIHGbDKh1/v7D0n7LYWFFv6ozN8v14dGiEP7h8QVQ6cW AABKp4SHjyrtBADIlZE99A7iU5VSjMgVg7PFviC0ALugcgXwi8IV850TfoBRKhcjF9HNCdd2qVjJ YqWdBAAjZaqdAAARQOHRpzOmgkQX2gmMgCvtBEDylFAQZ6qdAEiaP0rtvlNqF+hT/PimwIJWQA8U H+pnTJ8bQVzOjDHZCckL+EwDAMiDjxA2AxAX96zYe+U0xsZUO4Fd4O7Hn7TzAGAIJdkyyI9KO4FM mGonEJFs7w3u/+85lfX9Pwstsv275UB9bf2sF7+08wDF8MP9Vg6AbPgvAHtnrxs1EMTxWSdXhOKU igKJcA0SNRSUeQIEjxBRUNPS5Qki8gYRXToe4WoQEqKgPhoamiRSusTGs96x54zvI+HsHZ//P2nl 9Z69M+uP7Nh3mf9ubAdAO/QhiRQwQ9PF8nbVTqen5zQePywFJbSYRdGmSyVEoUshbFHUWdiCxSx4 KcIWUudlJWpBpZCFUNleb8CSzHOb7xN7Y2w6OWn5WeFvPf1qJWhR1CWV7I2vOycCFCJsocUptGiF Xuptb0JbIZJRCFrcUpXutpnRyNH19Q9fPzn/QI9fPa+NdLGgBS9FVEIEJkTYwgtaKCEKFqZgoQov ahHEKkTcohSvUMIXImQh/XghC2VDC1p4f5SgRarGC0GLBcQ+LLHtdwkELbq1YyXJfZt9ddHvfWjD FwuiB5aug9j7b7I/S2OxPg6Lghbrks3HYq7hUW0uVtO2na66lX5pAQuu+3hcd+0aOuBdUmXLURXC SwpkHdaLsIVWTXCqLsuk1k99myab8tluHvk/I/qdl+QP0fgL0cUnom+Xl74w7w4O6OX+Pj3Y2Zkz I8tUPTvp9YzX8zonkZaH26yWUFq2SUnpc7jieMrhSkKf3C7rWbDn29V23MaHkUUrXOi7tENU9qs/ c8qnLAhbSBuxL/ocLnlO1KfovsR4/hyKzZh2h2y7TfuxxyXAj2as+cNY9Emw7JvQ6r0s869a9+IV SeLn5iSsi6BFqsUs8m143tfiFrfq81RK3ncaBC5EsIrtjUcjerS3Rz+vrla5+jQvL/LylarITUIQ LWghQ5F2icSkLVtQSG03Fy7VlnV0+z8BqCtOnKUneWAE28LeAFT85/zzZlN+GOVXXs76EEcAYJRJ bAeAWTgR0ceB/H3lH+lOCcnIQXf4xLYDTEhyTBCOGTLHWzynHOflMLYTIBrbfG0DEBv8Mx3YFl6H 2H+67g7Wv7voeO6bdGmsZb4jbgCgE97n99o0thMtghgJLGPWpTE1r026tAtMMRtwfCMJrfDOG3QJ v4vkBP2z2I4Ygu9FfMcLmuB/Ajvq6TyFmB8AYIWjkGyzxPq7axCfns69XbHtv+ePwZOBXHMscIjn ng1y1+9uAQAb4zAk1kbC/OVMYjuwQfr6G4khvv/3ghbU33PWF85oWEIpwAafw/x7cdcd8R4IxOCv AOydu3LTQBSG1w5DmqSjocIzpKCioqFzyTDD8ArM8ADwBkCVhoImDZXfhLxC8gCeTJ6AKhesC3s7 8tEiRcYj6ayk/9PsSHvJ2bPri3bt+Pzz5iYAgBFRt/Kcsbp3Or1pMnRy8lLfuMrmuLCFEZ4gIQsj ROHOXMxiK1ix2VC5uyahCzpvBS24zbwQt9j3BuoEOMZ9841jjGH/FJnWXTcLWpDYhBOfIDGKLNsU whXb9EfX3duzu6Yzr+dlSWFz20e9oMXhYVYIWpz9Oi0JWnABC8oXAhJ55oQsAoEJK2Wh+zZCFiRM YUQr7vI7m/j1bX7rytR9SdzCCl94YQsrhqHPZJcOLmhBghr2deoPPgZQgfS0SPQvNWYIWvTbTyxB 7ru01YXd2IQf2rIZ67jGQuxCEH3YikXQos3+2rRV0YavLavaldaebN1PwmW7MPPHXB8zG2x5XpTR 8U9I4jDxUMiUDoIy3iZsy+vr6vjWM6z385I9Uer3W120UurxN6WevnJVP6+v1cfLS/V9vVbrm5ti Gmn3QTsQuz7WKfWBqXMvVmHytFNIfX3q2yYsn/p8ojfASVhWkcK/I/sJs58xn4rk22VBu9T7Wxob jYWV5VRes1cMo1PvSt9fdFnhDghajLpvqce46/6lxxWbH4ZY/DDENC+cGH0yxDpfnM5eyxV5EpU6 8AIWcy9CQWIWlCj/KCgP81V2SssgP67nR0fqxfHxLm6/Vm5lRSs1nvjqLazn+arVYN2KsCr979QC AMBUMT+AeSbtRMespB0AYOAspB0AUWIDPEg70RMQtABSmAD4n6Wd6JGlTp+knQBiGKGkc2knOsLc R75IOwHEuFDYkwLQJQjeBsbEStqBAbOUdqBFrqQdGAHn0g6AQfBejftzb6yRwENIBYJaCPUL5Jlq 8LEpBrQCcWC+z/zR2GpaYG0E6vig9gjSFQkLaQcAAMAzpf9pAaAP8JrqhrHvCcxnEHjugKFwIe0A GAR4T2tmKe1Ai1xJO7AHU/z837x/Q3CmW8zzyswvBC2ABOa35V+lnQBgV/4KwN7Z48QNRHH87Ypi EWloUqSBAoncIGX2CGnpOECkNOnScAEKJApK2nTJDaJUaSKqFJwgHRKiCeziyY7H8+FZe21gve/Z 8/8hy9+eN157GXvt94PUAoC0qUoS9bFppbOzr7Szs5sPm0SYVBoud15EEXZGbGGGtdji4SFzsgs9 rKdZ6YWXWpATWVh82c/fCTLED93CV8cqoYVyw15okZU6I7QwqWONbMLLJ0x/RlZOoVQosZhFQgs/ viyymAXbtGXU76PJ5J7u7v7kwxe/Tun1u4OgVmqpnwst8uSygUyiEFo43cSibCukcP1YbkH/nMQi HyskF3a6XUcLLfRfSWihvNDCSS1UVhJuxHUAEdy7RcJpOxSkixI2XU6fE79zbleq+EHCeSvtGOVe v6ttcZadUj3alreubTUs49RpNe35UK6mMi8riKVrTeU7jUWV3EKN6tMX16UrrkpvvGp8XDEt3k48 vaJcNVlcCRwS/f28WPycaPfITP99e0tfrq/p6OqKft7c0H2WueqHVyNW+vBY9K3YwsklKJBbZFlZ TBHPD2QT8XLzYt15IZ6Yx/MjgcbStot4wzKcxMIKTmwdlD8KVNytuFZsI7fgSGiemlgiRakEd5L8 rsrnrpdFUhxSYtFIisUibR+FSI0rZFMxWpmFZhx8ZqNiPJRSxIKLXGYxHjfKLazgYhSILmzz59XW Fr3Z3m4T6lsyD6nUyStiuUWVqCJevmULrdX8ug9M/sEGAADr5wN3AB2jk67jhX0AXsaUOwAgkhPq 50sETwVCC8DNCZmXFIaOruMldxCAlWPuADrkkjsAwApesgWgW4aegASkhX45FP83nsc+dwBrBAkA ANgcx9wBdAjaSGAVP5jKfc9ULuAnxfZNigmtgCy0wGvozwI9hSl3AEAk3xfdN+4gXgDa/AAAKej7 2vhOAmA96HNpjzuIgTL0Z+/074t4vhX0hb6KBcFmwX2tZobUBu/bbwgp3v/XQosppfHuEBcpHldA Hp8Iv6eAnvBfAPbOIDdqGArDr0JlVXUDm25QJcoGoUq9AEK9AAsOwBxlOAMLWFSi3KQcoVuQ0PQA VUUXrappJ8xL4uTZ2OmgSeY59v+NoijJ2H5JM5HdJO+D1AKAfOhKCmW2fVhOx49VdHBwSEVhVyfF FiyeMCILzhNazaXMohVWzOdmfSu2cKUXpnxbZ9HILfoUNUBu0XtrnmVXaGGlji1lFpXE4qFeboUT fhnFXIgr7pbnxZ1HbuErU9XbCjMeOvdke/uSrq9/0tHRKzr59ZWeHb4Qe2ULLYzAovwtSJlFLbTg DwsnjIRCCi184gqe3xa35dzILVwBBs9NnUZoIWUW/ClFFrXQwk1uDKFFAO3DkpvQYsi2tf+W6xKb LGAMdQ1Rb8pCi5gEEH3Up12+z7rWKZ/bfmxIMKHdXqekorC3y75/sJxnlRFZlGILn+CCtsIpiLvk FSZFMgW2d6VNDq0z8ftSIy9ZPCe6er9c9Y3o6SeivTfV+i8XFzQ5P6fPsxn9vrlpDkUz1cmopRTC jFwayQTRPwKLRUBKwQILa1lM5YjEkWDcizL3oq6FmCxxRh1HYeITcRf1+oWoQ+6rFHmExovy+9a5 opDQXKvNnNo1bWuhnSgfQovNEEschtjiYWKMyRBzbMymrp+yhS0hnWi6K47QwhVU+AQWPqGFW4/V 7an38+XODr3e3V0l7Ldk98xCggp3+xPy98we67mFJBarHloAAMgRfujto3YQA3NKePgdgHVJ6aF3 0A8/KA9hEIQWIAb4/Mvh9zYlvJidM98p3ZedpoSXjHKG+0xn2kEAkDjoP4DUmFL6iXX6ho9XSteC sSVsiJGZdgBgNEy0AxiQlK6LoH9mCm3iPlPe5Na/QeIhEAt8bwnjy4p97QBAdPyh8Y8H0L8CAMTE RDsAABIB4vPheKcdwIDwuA/nDhgTeK8HrAI/Nz3RDiJi+Nqf0rsNZ9oB/Ac5/v/fCC1w/R6Ofcrv vALxckq4twRGwF8B2Dt7nYZhII4flZBASCBgg6UTD8AT9BFYuyEGNsQOC6+AxEuw8wQMrMxMwAJb mVj4aOnFvcQxTj9ozLnx/xdFDXFjX9KU2G16P0gtAEgXX3Koo0kbXV5e09raVrZsEl5Sabk8FyIK e7aFFSy2EJmFiC14nYgvCqkF5SILoWh73kNRBnKLWlrw/C3JdfuW0KIQW/D6QnLxbYknXKFFIawo xBXyaMqM3OIzX29m2VbqMo+mPT8mMdwjvb+/0PHJAZ3enNHG7ra1V+Upk1mMhB19axKhRS6zsIUW IrMYSSzy5dEsIotsEqmFJbTIRBYitJBpuG/cph2DT2gxNily6mgfFggtUHeoNrTP7SogtNCrMyYB RB31aW9fZ10QWkQvmKilrj+290tUNqguH1iygtJ2U8SYKSwGS7PJLXwSCnv0WSW78G3fonKKZPkU yyfCqIqBd3VlODLYI3o9HxZdEW12zdPv3t7o/OGBuvf3dNvr0UffjA0GPvmDJYUQiUQulyAqiS1c eYVPfmFGPZRLL1wRBpe7gowvpw5pW0ZWsmzXIYKLQnBiCS/y88WZx4wXs7UKsgVNsYQGKUolNCUe IdvX3q/Y4mBiiYOJ6bgIMcYkxByboCkhKnVHRnFk3RJHSuEKLjKZRas1UW4hggsRaNiCi/XlZdpZ XZ0m3GGPiPapWl7h9s7GKcZ8Mgxynuv2FieVV72AcZ94AABQLwfaAfwDKSSBBiAkTbvpHcxPExI8 TAOEFiAmWELW0Q4iIPx+O9UOAqjB15UL7SAC0Sb8cDx18PoDEJaOdgAABIDHoLh+zEaTkjhy3xiJ AObnSTsAsDCw+KFJ/0OEjnYAIHqeFNpsK7QJ4iC1/k2KCa1AvHBfB+NLQ1s7ABAdh7TY16c24T4G AEBcpHAfMgD/Ad5L4WhyUlYe96FvCBaJ1AS44O/gulhNk77ffNYOYAbktyUpff4PoUV4+Lzia2NK 5xWIG3y3BBaCHwHYO2OchmEoDD+gYqFCQiyMlWBCiAswsDHCwk5nzoCgnAEJRuAGcASOACdoT8CC VKqWhrjJa+xXtxSIsXH+r4qixsnzS0CNEyXvg9QCgGowqxgUtx2l08FXgba2dvPilkWBS11socQT LLJQ9UCzuS6zyGQVSlzR7/PyQmwhpRe8fREzGcstXIsnILf4cVTL90JokWETWnyMpyRR84E27xty Cl1Ykc25nWUWfbEuxyhEGUXJVzu12gL1ei/p/+YbXV6d0v75Ma2s1bW9mpRDjMQWiSay4E+6HyON BQsoNKHF6KOLLXiid/M7Cy6oZwgt9LjclxRaTBQwznMGU6jioYHQIqzYrvoIPV7ZhCS0cAGEFuFt X2YsCC3+lWDix/2VFOsrUZkxBuTxfzKn4CxvZonFSGzxHcGFTU5hE1Loy2jGOrb1ZLllEm2iPPJw nej1MF10S7R8RrSxky2/6XTo5PmZrtN5p9s1jpcUQLAUYqzkE7ILKbCYkFJQIZuQUoxp0yCXX7Ao g2NxPgO5DZnijaGWd6Jtx+sYAg9tP+U1Ixfp1td3jc8C5T6oolTCd5F8V/373i8mpDxCyUURUi5M iDkxIefG+MhxUfTJQovx8EQILaSgwiawsAktZBxjmJPnsFmv0/bq6jxp75Epr5gmqJDtS2QfndlG atPaZ4kr5KEEAICq0vSdgGMeCQWsAPgtMT30DsqhRfH/tkJoAUKk5TsBh0BCVm3U37/tOwlHtAjn kipzT3gRGwDXNHwnAIAj1IuhMRfXKZuY7l1h7ADA39P0nYADGr4TAEHz5KnfmM7X4HtUbXxzRyg8 BMIC15cZ+74TAEGhniV78J3EL2n4TgAAAASxikMB+EuahOdLXBLrb5S63kPBWQBArKjapLivZSem 81rbdwJzUkWhhXr+Ve03hBbuwDtLIFQuCPegQeB8CsDe2aS2DYRh+Esa3AYHQrZdeVdoVr2BcoPs Q6khm96glG56gkLoBbzNLUxOELrKEboKZBMIMVL0jTya0WhkCSz5G4/eBwaN9ftGGpORLc8DqQUA 48Q3KNT3to1ubm5pOj1T9UIqQet6Vr42xYgo7GILK1hswTILnmqxha5zMVILKkUWGnPsbU9FO5Bb dN4L1Yc0Tcv5hbjCiCzqQotUSSwK4URVaFFMef7rWmRRnbLMwsyryi+MzGJl7Ucf389kQvT8/E/V /9z+pM/XFzSZvrf+0mahBU+1VIIFE6tspYQTeqplFlpQYUssXLGFWicvpfjCI7Tg/dryjCahhapD aNFOCKdm1xliFVoMCYQWYQ2aPyShijFCEFr0jbSQIqQ2Hcq1GZvQoq99CWbvLLfIqv3/xu0adlVq LLTcImuQW7jDFrcNf2yv9478wgtdJ6qLLHwiDHK2s/JkH/I7h3Oi/7/yRX+JTr8W8+8eH+nHwwNd 3d+r+kta3DdkPvmDJYWoiSms16kz3xZU1MQVjrTCllOk621tMQbvp1zuEWro9cp5ZIQapg1Ywgvr 8lfKhvvFIeUWUkILCcYqlZAeKD9moUVIEolQcmhCy8OEmEkTcjZGoq37jqllFqpO5rypbogjpXAF F0pmcXjYKrfQgosDS3ShuzcnR0f08fi4S/xPeflCzfIKtze2STPmk2GQs66rPmtb3nQxw26IAADQ DzOK/4fbC+kAAERATA+9g+3hAa9iH3yefwCzIDwcDsKD+22JdIgBSCj+Pilo5oni/b+S5OWbdAgg ym/pAACMANyvgljh+9G5dIg9YiYdoEeW0gEiQmrQdrB/XEoHGAD0kcAmpAQDaJfjZSkdYIcsqBho DYCQ4PvLWD+D78pMOgAICv5eai4dogcS6QAAAOAhxs9YANgleA8Ny0w6wECw0ALPuYJ9Y2wSXLAd iXSAQInpO5eldIAOjFE8wEKLuXSIyBljuwL7xUI6AACbeBOAvbPZbRoI4vg4IFqpUiVEywmpQcqJ Axw5ISQEQhx5Ax6BR3BPfQI49wWQeAP6BogDcEJybhyhvRFqd2d3x55sHAcFu7venV+12q/seDZx 4nWanf9N3w4IgjA4XUGgqO+1Ss83GZrNHq6ISDSCFkbEgoQsMO6nybmYhRGrQOGKxYLaTZmELrjo BY1vbFa1uIUPkQk6ZuiB3P6H7efovh48rCkFS61Dv9a5EbQwoham/Ne2c2GLBRO0oJwELEj04o/u awQwuBDGpbVP5RK6Qq7u7JRwcfFVl999OoG7j2dsVtVKXlpxDBS0oD8tLKHqKGJBYhNagsIKUZCw RS1WYQUutICFbedlzGkcilhgGe26ghZczKKsrF9MzIL7LgSKCFqEb3+MghZ9E1Lw/yHtiqDF8Db6 suV7fJ+2fI/vi1A+KxMStFhuahqzltvBpfUgH88eikIVm9C2K3PvgDax7t6nVVm1eoys5bhUJ8GK yulz65OWNnc+wNqylsdSn0rlHYDfr1T3M4Bb3wFufwD4+aOC9/O5Ti8ODuDl4SHc291t5sgCVZPo AwWw1j2qrt3EOpZte2nbSzuNpTzLajt1ux1LdW17MqntcL2OOrfH5GPIt4m1D+xxNA/ImtdwKRi3 fo3tU8bGu/eNa06nrUhN3CFFUQnf363ELGaBhOIHIr50E6JPRMi+ESGIH7UtbYCu/7asly/2mo5q ESVe21W6ZAIWVG6r37D1ib2W8zUDXbOxfn9vDx7s78O38/NN03ii0mcw4hW0umoTqHD7qU5f8q6T KwNoVmHrhC02rXjdp1YQBCEFYt8AM1fpo28nBCECpr4dEIIhlgAPXaCgxZlKjzz7IQjryCG+TVqn vh0YAV9U+tXRjxtbxrqpJYfuuY2Z3LcDIyDmc/tYpcK3E4KQADFt0hYEFwxCk3rg0X8lps+CwrcD gpAgR2C+Ay/8utErMX0uCv1TeDqunJfpUvh24Jo4BRG4FcIFz80c0nk/usg1SOC8gTj+LzX17YAg CEIL+Hvk3LcTgjBSpiAiiUNz5NuBAcDfur717YQgbEEM92TC9YFrTNkTtsrUtwM9ErrQTYrCAyJo MTwpnlfC+HgKZt/SmV83BKGdKwHYO3vdqIEgjs8dik5REDooQZGoItEhGlo/ykmI97hHoIyoeYHU NKEH5QUo3EGRBqVABDjjWe/YY2cv+C6+28n6/zutdv21u7Z89vo+5gepBQDjIxTp6+3/Njo9PaOj oydKYlHNb4QWVM8XwYWIKSRpYQWLLa6vK8EFiy10mVMjtaBaZCHotmMAucWNtQPTIaHFqpVXEotK MlHJK0Q+wXlXTNEVWvz25UZs0V6/yRuhhbSzft9ms590dfXVld9/eUePXzxTexUWWrjz3YsjRGjB ggl5iYRChBaca3GFCC203ELKvI7bTm37x7+4Dcm1TMP1o6j6I6/uPoA1xD48EFrYrz/2ObItlgL2 76quoeu1KrQYAkvHZ4i6Ym8/JJb25S517WM/rAom9t1ej/VuCC6K8HItpHBlNb9P+7KeCC6Ccgu9 nQ5rXKh5Gh3GWJatAssLVZZ8Re2wyV0xRkhuwdmM6NdLou9levCN6OEF0Y8PRB8vL12aTaf05viY Xs/nrlzvjnq20FIILbTQgaf9wXJiipaMgqc5WHWni1pa4eoqH5RFNDHx9bQEGUqioQ9XfZj8sq6I Y6KmRdQx7cg7Wtzy3HgXwYWFAOWptzvmtnfZfuz9EtCPMNb6w1jsk2C5b8K++9inPbdOUTTDHT8t 0il3L/f316mXVay0zKIcX/wtl6+TW4gMw2mCfX1arvXo4ICeHh72kVqclOlVmT5TI6+QoURXYDFR 87TIom4+kEitp1N35NZFzw+NdiG6AACkziJ2B3YMgr4BMAwI8gCEJaUf7OScILQAtkntx+ELSvNP w5vC0iD+Y9Y5VdfZ3E9v+wdOvnfPfTlTOc+zdI1jCV2qY/aMqvcrIPpE7XNb0jY8p+YPmZnKrZ3b /J5O9dwGwBp4XgUpw+PkBUEC14eUrgV57A4kRE4Yk4P+ZJTW9Tal6yIYnljBgfAZ4HjJY3dgD3AA SQgtgHWWlP5vhNaBsREQziidQJg4rwEAFuHva/l7WwSqBmBzFrE7MBJ4DGU9cPYm8OcRCIQM7iMY K4BNyGJ3wCgpfQ+ex+7ALYxRPAChxe4Z43kF7i9Lwr0YGOWfAOydsW7UQBCGJ00ipQAFKRISjSno yRscHR3wBtBT0gOPwBOEltDQpOYaHoCKAiGCRIUiRYIoycVnHztrj3fs89k+5ewd2/OdRrO3tndn E9/detfef6u40KAyDPqw6JTSCWUnAl9ECkEFxI91BR0ff4Pd3T2bzotXJKITJGKRCFfE1pNwxWyG FsHVVQSXl+hjm764mBtz+cm2yO5LIhdhuMhELkjcAj3FIYExfN5Wt7GJoEXM8uNUzIKMRCwwPc/E LZYFLbiQRViSx4Uv6Lgo866e1W3b3j6D8/PfcHDwAF4evYJb9+6wVuUFLUjEggQt+IsELaz0xCIR oECRCi5oYaUrFrNcmt7bF/Nc0ALLJc/FM6huFbS4Ab7/PD7q99VmFbToth4pi9y3WVYb5UoTfthU mdLa5bs9kj5vktoivR1SBS2kllVyTJ1QBd/OrwNyxzUV1FjAkshF1i91lw3NfFzI45cePC8uHFfm Vx0LsNS2rX/mWuEHwO0PAH9+ufzH+/vW7u7suH2ZAARB4hK0jQQqMiGJQpr2X9fnyqvYLxdTehzF BGX75c4BVw/Py/mK6+O6K+exCUuMVVTC9xhKG/X7bhMhJQ5EUiyItHgQiTEhUuPiSBU/yroSqaiF 7Zbg2KEdPwQrVjGPY5ijNxaaNNo18zO0KLLp7H2avmb7hmk5URzbcqO0DqzrbxjCl9PTJsIW3429 g0QVOBlcdWmeFxXyohJfNDf469JkixJf7KFV9M68j+IpAtC5baUvrPmbFRj72U4kYsCJZr3pXVFu jv4QKgguSD3xHUTLvAdddKgpOHJ9Ak5YgTz+7lY9+MkX2qc0+gBkLUYunSF9HqcwrIer1uErJN87 U+j+gemHBfP1P3gBw1o0lIOLIj3xHYQn8Nz+lJqPcztI/QT8ndtvIXmQR1GUdsG+5JnvIBSlZSr7 /tLnLjqaYw1gWOPc8ifP+8MbY699B6H0Blzc9qnvIDaE9pGUOuz8aZf9CNMnmBj3ubMKFWkMvX/z 3Nih7yB6Aok7k6AzF3aeVhwXgBO6DQqG44C68FNz7oPsReLaYszj9YoDv4MCGM59ZLIHhRRFGTOP jE2lj10r/unDc2QdcwIqCNoF9jvKdxAbBPu2ek3cLnr/T3toZ0FZh7GOaa0iAL1HogvGKDww5Hu6 pYBz+Tg3on1/pU88gxqxaB0HUnzwXwD2zl3HaSAKw7+drJB2ISso0RZu6JFW9O5peYBIlHTwAvsI u2+wLQU9pakoqKhpUlGwBc1KCAQJPvYcz4kviTcbeyb2+aLReOzJ8XF8mUs8809dO6AoSq/UNRpe b/vS1dV7nJw8ySfkWlkxCRa2sCIXLHCBQuCCYit2kS+z2AULYLCARS6GsSy+Q3bYPiP37QtcgA+5 s77+GJsFLXLhCmJ9frJ6QQuOpRAFi1bYZRuTaMUfsVyO/67ZztexP1XCMEivu2+4vf2FN+9e4cXb lzh5/FAclRWHkGIRZUGLTFwi3Y8Us6APC1mUxSpYyII+nC7ymHwsaFHYMzELWpQFNfJJ81YVn5Ut uP6JVNDCf/sqaOGvrS7s+ib8sC+bvh7XUPBdCKIPW74IWuxzf/u05YmgRb5o6vbl5uGqul22A4r1 q3btHs6X2QmE4BpHQS56kbnBMUS67FtQ2haIbTJ/iKrdpt9M2irnZz8fAb+fAz/SMPkOzD4DPz8A H29usjCbTjE/O8P56SkehKF11whCLNnV9LcM5DaTLkQoMj+CbDJqTmdxmg5Tu3wuQpG/nK8Qtgjy c0fLS5OH7IY1ghRrPiFv+4XSd/YzuwZQ2C3yV37T5vZx+dRJxiYsMbb9ut53l/t3fVyM+lGPb/4Q PvrE+Owb46ugRSW/EbYIRJpFpqhcDk15S2FCZa6JKUzTcp9EKop0Gv6J7UsOqZ2lsSfL6NnREZ4e H7cRtXiWhvM0fDGuTmCrDhwmsDUkXsfVG15XFqWQtbOgJtTVACVyfV0tblPtTlEU5ZAZyuQ8TdAE REMZiKwoLolcOzBwePKWBPlgCxmaiEyQYgAUupy0mfycd2jfBy6gghaboIlUE9jJ93ctY+Xk5knN dp6EnMOYBoLcBbrfYxz+INsY4xO0oOfpdRou4XaQHU8cJolNoHZCHyIz9Fy57mE/Logwvgmy6Nqm ASt0bfctZCHha1sOnolF6OOZQ8JPFz3sR1GUvO6o7MYnE28SpYtQ7ROgtA6q7RcquyLoBA2biFw7 sEe+unZA6QQ6r/S8XcDey3K5Lt2WCPYe4L5CIjZpFRBtz5DqFUM6FmX/UJvVxf+nkYN9Kn4w9PoN PXNV0KIZOv8J7H9Lix3tLLZ8N0Je/6HzQf3b2m5tZo5x9l1Grh0YONTPxPe4FK1pQrZdpFB11yI1 cwznPTKt898f+l8rwbrYUrIhf12bu4/rVtkf/M7LwoRtzyoiNnEEW9+gWOsam4lx+O+yKErfxNBn S1/EGM4zag6thyjKfeF3+IlErE9K+crptsRimdoO1I6IoEKtuxBjuO+a7sKQ+gV8/Q+B+pmvMa77 VAUtuofKgQRa928Ll9MLVMfZ3WU8U2xi7s+T4/D0XLTjAltELRTFBf8FYO98UuOGoTD+TRpKFmno JlC6MhQKPUMpeFWyKRS6LnjdVW7Q6Q1Ce4GcoGfwBQqlqyxd6KqbLrNIMtN5sl78LNtJJrEs2X7f ICyPbOnJI//TSO+nUAuVarrq8ra1EGnvNuHotoyS5FWDvFSHWawNzKIEUdTjDKqgQOCKiwuGXFRg Cxd6wfvKOAUuK1bNB26xbqnjbUCLld33SqxL4IQLpeB1CbQoYRYcr0MuLp1lmWcJt+gGWuzuLnB+ /svEv3z7hJcf32D3cXVr7AJaELyClgZkwVCLTX0YPEHfGxzFugw1kAVKmIVZl3ELteDt24AWV/xZ l0tjiwItHqbQh2hOQAvfih2UMHQ5Y3b8HjLfWMEPMZy3sbXR0Pv7yitk2XOqx9CAiYiAFvWvq4QG 4EKkS7iFdDHctk9XmQv7Wdt3CbMU+RrAhdzPBVgATRfI7vYrZ1tOl9u05Se3k2CNFRr1uHoO/Puw SX4L7J0BT74Df39f4mtRmPSjw0MTnu3t1ZxLMzSCi5KgCNKOdHztVtUCKoyH6RtgFbwuvUszPIOr 0QBh2PSV850BW4jDwdtdH9qFAJ6IelzXT9QdTjpvI3+GMTgoH3u5cy7bZ/mh68VSO9oVmz2kGG1i xWwba2gbt4ZZoHmPg72HMryK0hloYQgSFlDB0AoXYOGuP7LrBohh87kGTqGCUL3Y38efgwOc3Q62 eL0JP1DBK3ZawqIlnde587cNXrFjy3Afc+QTF6dvc2hVKpVqqspCG+BZp6ENUKkmoiS0ARMUQXdy VBPkt1WBajCuOzBUAgH6dKa9xLQdaGab8Dm0EZGJnZNTyDGcgw92GnFi16lNZ1AnRG3KMP5Jtseh DRhQdE6d2BCrw5zchiXK+z+ddxn8OUFdeso3Bi1DGzCgxtS2STQZ6b0NvsAjS0/5qlSqpqY0SduX aPL3TxHyHvNOUAcu6oRPfzrGvJ6dt1Ua2oAeVYQ2YGLKMVx/DzlGZGeId3GG2ZcK1NtN2yRy6SQ2 xfzgkncV3bsSTOM8TEMboIpaRaByk0DlqsKrCG2ARyUYfx+9D/H/oPRcUgxUJpVzauP07pTAf//2 WEXHJ+a+XF/SdtCvGFjD/yNvK/m+5O6foA6q7quPia5NU3K6lYQ2YKSitstjILYdq3NTu2W4Bd17 UszL4WXMor4avk7dZ2wW0H2NS1Bdp+h319+8rjS0ASrVCJWFNmBGehragB61DG2ASvVA0fPaEP9Z Eei5QDUOWjrH9q28I86SsLzULnWsRbtS6PwwqSmNl7rv+5pPZZgfzFqBFv7FQAvtq+4WA0l53E3R U765iLf1Eaeoz8PTfp6mqN2m0P9FVZHpvwDsnTtu20AQhscO7C4wcgAHzAlcJH0EpA6QnCC6Rjrn AgF8gUAu3aROESDq0qRwThA1AVyq8UOWSYe/lqNdrimZkUjug/MZg+FD+5BMibtDcv4dnxPEC5sT QhIqoXXsg8BMFsXL33J7s66Sk5MzOjp6bQhYqO0sNJFltBSggGgFhCngIVgBf3OT0myW5j6j6+t0 adh+dXWXm1pmQzkWu1BiGPeltlhMIwTi/B6WP3z1HrPlPha90PnMlFfCEqaYhTItbGGKUswtQQsl ZmEus+hFuRzXpbxut5r9/V26vFSCFp/PPtLzty9LiX3rClqwwAT+WICCBSkgVgFvilgsxS0KgQus L4y0R3muB95sg5cXQhaFqAULWmRGJl8RtKiB64+ob4IWbbYdat1tteFrknsRtHBXp08CEE3U57p8 k3VtU75v7yNUgQlPBS1Wve4xoQpzvznfKZWr2SaPYXlZFTUKm4IU9rrtbQGK+4rXP7Zetb2qLYsn f4me/iSaftXbnu3t0fDwkF4dHCySTzOmgIM9QV8IUFjru8W2XRa/4O2Gp2L/TpU36+Vy1nKpzIrX ruuj/d7MI8jOWG3Pke3yXSGCFvG323b7rt8X40s/gPRlPT72ifG5b0xI4kelIUQhHMU+hc8N/g6W ZTTP/Ry+sNvcZuzTtLxe+Fvj9fOinkW9Rhvox+/plL5fXNTp9pfcfhGCsSrAqoKwD433m9vSGpat MDOAXGVUsb7q4xZ6hlzbFkLhP84nSW5/2uuJc5BYNaYHTwTBJcckyf6bAA/HI0EIboLtMknIO8M2 vbkWNwcPmuqQh+AG5DHJzccM/t8j8vPBBBzHSLYjyRc1LyjcpGAJxT0eNTkldeyGmiQqIfWQFqyp hyZjPrdgHjKhfpxXkAQKx/bEcT82JSF9bpFjWxDCZJTbB9ed8AwWpxtT9/NPmwHpBAwweSh3c5Bo I6na4fu1i46uuY4ont+CTyRJiJpkkNuPFurFmO/cstAYkI4ZSnIczXuKK9FtmwwpnmQuvZ3HdTmO yMcEY5K4bl+JdXwjyYfKYM7C10EnbrvyAMxHEf+ThNOaviUoG1A784K+ge/5qLBJh+3iOzyk7eYu iJclFO51uiqOSe7jqQuOXZyfcJ6adNTmkNoVVxdW4/rerFhilNuyiGf7HrsW3BPCc2Ud0ad7THwg lljgkOKJz/pOrLEtHxhT8zFjjEPOqZwQO7S5YEL6Op7MKTQY68ck5LAtmPPEcnz49js7pH6dYxE3 Q/x85LgffSCm721TcNxuU/HktmDxWphcB9SsnUtJHEhwwT8B2Dt35aaBKAz/qCCZDBUzCZRueAAq 2tCl5gn0BuQR1FFT0HvoeIDUuKGmIg0zTB4gFEmqYCfGR6vjXSsrK4ol7e18Ho3ki1Yr27L3ej6R WkSKNBomj+0LYMaeJD6slm9tCZ2dnePg4GW5rcUWWmbBQgtTQsFCC5JZ3N7eryUWSmRBUovFalHC C5ZcKPHF3Xrf+VylR2nTMei4tOZ8hEJc12L9jdfxxOg024UWd9U2CydYSKFipWmhhRZbmAIL4F/5 nJZb8FrHT9Pb24UW+/tL3Nz8Kre/fP+EV+/ebAgs6muWRZDQgm+lWGJ1v5RONAgtTFkFSyxYcEE3 lluwyIL3o7Rom9M1hRb35q06RxZc6E8moIvEFa7fIhFaSNpDHcPn9HwVPvSVjq/n55MAoo/0XO/f Z1oitEhDMDF23p+yT8PrtokqGuUWy0fWfzbcFbrcbbZRlY/bQhjbhBb1x21hkLc9b9u/o9zi2TXw /A/w4ivw14gffXJ4iJOjI7ze29Ov5bUhgaiLIzLzudpjNoHFVlmF+TqL8CKzCDQepF3LU1bPe13W YRFcmPezLEMTQ9WiRSqRzrGHPL7r82IkH3Z8yw/hY54Yn/PGhCS0YNZFhkouUbaQVrIJlluQiGJR yS1MoYUptmCpxfq+IbUwxRaLSpTBCx/nej7Hj8tLnF9dtWX592r5jE15xWOFFvV1k9DCJrdYWtZt JTfbWy0kiPRtC6HQ4T8lR9wDLel/5tR1JgQhEmTw7G5QIHOaMO06uB1NfqRBtQW6BXugwj0Nyr3o P0teIJNCFRz4tkAYn/UEKq8SEMC/yTxdKBB/sBW6tnLEFRAzhypn7zpJI2QhSxs54q5rETFOZOtL nPQefk2uEoTYmUEC4zIkGprC73IH1b+OoQMwSBD1bryFpW3B976Lkfpd6X2JZRKxBNTvlwl2lylS 2XdmLK7b+IagjyCxsRByO8vYFIinXSfZPsWRpRajHcsC/c79dJmBnvF/8F0aSP+pggLYFAijPYzq pKfVknq/YGpBAHPE32Y/JHSdc4B41zy1HT/GuvYM0i7ahg/f3QlkXMMY+DTeZQL1O/XRcT58QGLK Ca2EMLdsJHJIeXVMGkXygXEBac8fC+k3GI4pdi8rUxvHzFhCE1i0wWP/c0gdkJDCgyamMRI+jbfM kVa5jOrTx4hzDIRvTCHtQwyLLKYI47vH42loSb1vibCOXySkHUhwwX8B2Dt7HaeBKArfeFlpdyWQ AAlRuoCagoLWLR2PYCRKCniDVEh0bEsVSsrtKJcH2G63d7+ioNo/EpOT8bUnjpM4ib13PL6fNYrj vzlOJvZ4MnPP8ghyiqL4RNWD4Id1Ox0f/6Sjo6ezeTa0KOZTy+SCDS5oZkLBiY0ueB5mFWx8cXcH A4txvgyvvB+Ow8dn7Ly7hDmPjomuZLmhBV4nE9u8okhmGRtOFPHNCkMLNqsov95mhhYwtrjJ1xXL bEML+1gmn1WGFoeHt7mhxfezb/TszYu1hhbpLCjceM7QAu9tQ4vcyCIzsbCNK67Ta8LEJhaYv0qv ZsthdJFvnxbmFmyQMbPKgLFFlv/MTCMztMj1qaHFZvTxI1JDC7eO3VYeLh/PVcOHJo/TNGpo4d7+ TR5LDS1kDCbuO7/71r7NcVdsl2bTqnVsRJEna6qb5yCbAkyDwJghIKVm+YI9Y+6wQPPrBkvWYX6v Ypk9H6zJY9ky65zSh0Q3r4j+fJ1m94XoyVuz6tflJX26uKCP5+d0lgWVLge45kjOdsoDU1vbjUvp nxUUe2H5kjSebm9vkwfX5n0nk+r8Sprm9GUaq4J321GoOVo1XBFXPStXeZnsiqSphBpa+JO/9Hkx qqMa1/QAFzUxLmsDEtfPpvNcMK8qGUcFmRkVz++V0oMgmH+/YpvASpzvo/19en5wUEfqy2l6TUUt h2tOdrJrU0FpflCxvb1N/hGUEtVcv+xLcbsQK4qibMY7aQEtM5IWoCgeEUoL6Cgws0DA7pjc6GyL gTojMt8nOv//rrnfkOQHfbfJKfW7czEajzHoLiRTVhNBLZuQkNG7SVn2lVhawA7E0gJaBgMmI/Iv SM6IzACNXX5/uEcmDelxEd8DYfJAtpGsjMbBbzWi3co29jttSI+iKPXo+6B9rs/j2RNtfa7XO/Bc Co24V4ZkBjl+JjNYVVlPLC3AYXwJ1gBcaEPyiWTL/fA8h+srrlMcLMYF09q2wHnxtfk99butJZIW 0CEiaQENkkgLUFonlBbQIH2+RrvEkNTQgv8Hjag77WF4Jh2SuSb8EFUiD56h+mRqEUoL6Ci456C9 PCJ32py4HR/Xn7q/4xNyR3+ThNICHAZlw5Wym5Bp00OZ1Xpc87jY3yUh08aC7/xEVoo4kbQARekQ sbSAnuGDEURMfpyHoiRb7IM6IOr8+D/rMZn2DdS/UPf3zdACcN//iIpn4b+CeqSJpAU4hE99JBJp ARkxqaGF0g64T6mhhWkngflwSOYz6UrZ4/406DuE+kff+zn6PkZC6Rj/BWDvjHWcBoIAOic4ieYE iAaJAhdHAYgPSEUa/oGCIn/AJ5D+CqCDAimf4i84iRZ0kqVrT0hcxyXE3Hg98eyeY4eL7Vnvzous rOM7e7xx4rWzO0+lFooSHk1JnmgZduZ907ai4+NX4KaStGUWeSGzMCIKu0wyi+UyZ+IKUzbzlfTC FlrkVhkn2taYGbfcolloYfZrXZbXG6mEkViQ0GJVlisRhS2mWG6kFZXQgsrLzXMltLDFFrR+81xf z5jQ7fDwAi4vf8Bk8hK+/fwKD58/YXtlCy1IYFEc51xmUQotCplFKZ7gQgsusSBxRfHImcgi/1Mr wCikFvhAmUW+srZFj0JkUQot3ITBKrTYAR+qaOgYQhVa9IkKLfxKmt8nvooxfBBadI20kMKnY9qX 9yY2oUVX6/I19h7Xy2UV9auprnX439X+T8s2SW6BQgsSXBTP4AguOK7coi61MsDNFMwHzvK61Mzu eg6cddVdfd+9vjJ5CvDr3fXiLwD33gM8egxwcXUFJ2dn8Pb0FBbn58U8Vcl6U39U32DJIkgwwcsr RzaxYq9z6QSXVfB5Wr8rxPhbvsZft8QXZdmNyY13sx/sb1BmUQgtoBJccCmKS86mfVCpxLDbld7v PrYvvV++xYH4EgfiU70QPsZE+BwbIRFfpzKLmnkSTXCJBZW5pILmXYFFndDiDpdigN0cohieHR3B i/s75YSdgC2v2CaoaFteN7UtbxJXNFWtoihKSIScZAE7iI2lc5uijIGQOr0PAZdZZKKRbCeFKmlz U6daHFT/aYB4pMB9i/n4/gymU/gcxjuYKwVzLGMi3FgHauEA1THKyjDmkAfXktAi5DZpCmYf/3eA Bn5W592H4w0JhH1uiWEgWwq7tZPqmHUci6IozSTSAQiC3094DsbBknPw99qzDTyf4HVZAiZxfOwJ GNoYY7t/CEJLxJpJBxAgu36v4AB6ngBnDmG3e7exgKo9/F00EhkS6QBGRCIdQIfE+FmPjZDaC5l0 AEpxnvwgHYQglOR+BuM9HvE3sRnc7v5fSMSUeGgqHcDIwOsAEgKkopFsJ4NKFNCUNP43hHvfPuTf WW8LHgvUVycVjeQmGZjPFCbu0/uf+8NlFnPws79LBuZ+bszv+QPpABRlJCTX02vpICJkKh3Ansyl A1CUgcH7N9jfmWT0MzC/Z/nYDuyTDMy+J2DqI0YS6QA8YSodQIfg9VImHQSo0ELpD7w38FE6CEFI RoX37LAupAW0+7IAcy6KWW6Bgha956N4wz8B2Dt7HaeBII7/CWlOBxQpoXHJE1CnpecB3CEEEgW8 AA0dxb1BrkTiASjNG1BcT0qkE80VJ0CXhBuvx97s+WOJHM16d36Wdb5sYo+/4l1nPT+VWihK/LQl e3o19KGzs884PV2U0yyxaKZtsQUq+QRqGQWNLKzgaRZb8LQ9mveYcpoPz5+xlz11pie36BZaGHGF nY60TmNaiS1YaNGILWyBhfn7F20iC7useb8rtmhkFmZ607kWsxmdBj9wff0Tr9+9wMsv7/HoycJa q/2hlFlUyXm31sCSiVpmYQstdkZoUY74U0+XUotKZMFl9v8stChFFjTsblAPldjCjqFNaNGXZFgJ DBVahD//KQotxiak5P/HnK8KLY4/j7HmJf35Mecl/fmxCOW7UoUWh3Pg8vtEFbacoHXwbQftUEss SsEFGsHFntyCcCUTXRmd7+GuzOI+7gosfFIvuzKLHsHF7iHw+xnw69Pt4j4Ci+fm9a+Xl3hzcVGO 36+uynXjlhaLIXaWLGJjvc6SCS7fOONNJbBwZRU31sjiik0lutgrt16ry7bbPaGGK7hwx62zHuWe v13HWnjR7OpGboH+9vIhcgvJxO0pSiWkk+Qfa/nS68WEFEcosRAhxcKEGBMTcmzM1IUWbfO2qyO8 rLL64MgtXMEFiSzms1mr3MKVXMyckZf7YD7H45MTn1Cfwjw43ievcGtPfSqwLi1YV01tqLxrJ4V/ UCuKogwTewK0qXdyU5SQiCnRz7Hh5A45wuhc70MB06m2TQgQc4IHgq6Fb6WDEIISDlHHcEpWE8tD XZQId4k0ky0SU6zbTTFmX/hhn1jOryFWMPUF3wcl6XxdHyuYAEjh2E7lQbYCpp70wfP99ODV+kix KIrSTortVfoupociM5hrcEzQ9SVH00ZN9cHPPihZYYrH/RCZdAAj8k06gEjpq7/SNmeRBdXlV0in LTdEAfOdk5pIVBPD+kFJCmLaVqm0c1NmKR3AiOjxKkuGdPsiUBuNkjIvEV6i8EMpYOo758JxSBHz vWwXbUv7wfedaHsVsqF4s4Y5lrskNTnibOMtpQMIDBYu0bGwlg1lEKpH0DmWar+GMaDfpDOEK7Nw SXmf6/VXUfzIpQNIlCknYc0R171ZJW2KnjJqo7LIIoPp76z3Rg1UD6btQf3AU/t9OZMOIBAy6QBG JITzmvo0pyS0oHtoS4Sx7WOH2sUr6SAE4Xs4OcK/Z/e/rGD2r2//8tjIpQNQFOafAOydsY7TQBBA B0iBFKTADyAjXYXEH5yQxS9cQUGTmua+ACl0lEgUtOmuvj/gB66ivSLNVSAkJKQjTs7Bk/U4443t 5ILjWe/Oi6w4WWd37NibXcfep1ILRfGLpsGdKO0sm97syujk5NWWRKIss1itZRYopDBSi808ySwW i43MgubNayO6sOUX9FkjtzCvqSzfcF9uUTVkaFloYeBDkJqhVkligVOaLnOZBYknFvmUFPMbkUXC 0uYl8YV5XsJGZLHJ08ynUMdg8BDm8++QJH/g45f3cPrhDIbPnrC12pZDrMUWKyayoEdW5lpjkQso uNBi/cjFFiituF3dGqEF/C3EFiXBBZSFFjxfKssWWtgDBFPMyp5IbyoVWrifv/Q+ciguDdh/rLza ztdVoUUbuLR92shL+vNt4tK6/E9eXayHq4KJrss7JK6OyrfbpFvprL/DhRY7ZWwVSQ/Yo5BbrCzB RZNkom6oZVtSYcsuoGL5uueqvKz1unsO8OtdlvQV4PE5wOgpwM8kgU/X1/D26goubm7gR5IUm6FQ BzIxhC23uCPxBRdNMNnEkr2f5u/hM4krSunss8uK/Jb8NcuPl5daMaXWegCbJ7kFn4reJROkVO0i +wguVCoRTtnHLF96vSgGF+JAXImDcC0exMWYCJdjQyT29WOWaedKQouiOWIJLWxBxaOKiSQXA2vZ Ij8oN0sohhfDIbwcjfYJ+zWUW0N1gopd6XVasKb0JnFF06ZVFEXxAd9vTp9KB6AoHqE3mO4HXoza p8EdbPBi/CibLtl7E/Dv4mEigjB/K2ggkhj8/G7x5ooYwhx8CNt2fbvZ1uf2aAz9GECjTehGybpB gwishz53EpEcY+kAjggetyHeyDYBc4N002Azv/PlFEXpltD6q9jvjMD/vgy2K6iPiv0XlVuU8bkd fSg+1QUz6QACAesVrFNxoJcYVGSxC6yT8TgLaVCcWDqAHuBT3Yt1gtYB/hNJB9AiIZ6bcYlpNu11 QZxn4MBDWPf7KPTA34AxmP5naOC+HEIfE/8/C/G4vS94nUAE/T3v9A22JdW4Tj7WW0gkHYAj9FW4 NAMT82XzYooFnpfAczn4n3Tf+nAzMN95aGKLvl3DoihSjKUDCJQ+n9+cSAegKEcG28nYzse2hIos mpmBaWeGJKiPpQNwhEg6gBaRPsan2XQuHEOXYL8U20HS2z0E8HcMz02GeG4a7+Xp6zmc+4DrNoHd 15f7yFg6AEUh/gnA3hnrOA0EAXQId9zpJCigocMVDQUSEjUrxH9wEqJDoqYLDSUif5D2Oj7hvoHc B6S8lmsOUHLGs+uxNytvnES2Z3c9L1rZiRPvON4ka2c9T6QWgpA2TUmePra9aDa7gLOzJ3qeJBb1 vC22gFI+AVpKQcUWVeA8iS1o3i7263A99frzap7qTpEw5RZN8dTyCiOQoJSjVNb6cSOaoPtGOGGk E/9KSQVJKUhWQUKLWmbhLqtFGLbYYq2fR/X6ODm5B7e3v/T894sv8OLDWzh6cGRtqV9ogVOSSqBg YpWvtHCCpiSzIEFFJa2AUlqR/92UWBSFxBc0JZEF3nC9tjzDJ7TQ8yK02B/ut4q7/iERocWw9YSS 5L7PdQ2x3kPoI5YQpAchtQPu13e5vpC2JfTtiFkwwb2fOIQa+XZRhe7D3uXgytkapRgtdVZii3yi 5RaV4MKVW9hHwbukVwZoTrV837lvL4ct63QFFwAbMeUPAf68Bvj9o6jiG8Djd+bxn9fX8GmxgM9X V7C4udFyCFv2QHILkkW4gou78v22hRdUVg33fWVdCi82nmc9Vi0rHnPrWlmCC4rJlmlUMoty2yr5 RV63hA25BbUhzzGzT24hUolh6+Xe7j7q594uO45QCC2WkOJBQoyJCDk2giO+IeskmYWet+rW3QVX TNEks5hMGqdumTiF6n10fAxPT093CfV5UV7BdnmF3UPyqb98sovqLXAK7Ljct9PCbuCCIAjtKO4A egQvWJUBloLQHRl3AIGDg09xEOqUOY4uwEG1mLgEL27Bi4JSTjo+xgHieIF/BvEmItkVSj40NrFF bImH8IKYVD+D+B065r7oJZj960vCMoW0L1DJivKSO4iewMR1l9xBMIKfa2zbvt8X7DctB4tGEAQi 5mQj+0DJuqaQ9u9oE3Mw+/lry/PGhOIOIEAUdwAdMuZjiT6h9xW/TzEJTgZpy1z7YAnmszbjDWMw JOliOyn1w5bcAQiD8Iw7gA6R/gIf06K84Q5iYHDsBYqMU088hMzB9BXHkgCQiOm/pUNJqd/SB9jm se1jW0jhcz6FOonYOWsk/SLt2pwvjFm4RONzxjau4RDwewrlUwriPn7Dfa5gXEkO5btKENpRkNY5 i5jIuAM4kHOQNsOB4g4gYZblFPt8JKTHfnKs/XwucNyaAnMuL3XkPzyD4g6gQ5aMdc+L8p6x/qHB 41EFaZwDjAH8LRtbvw3bGP6ndA5xn8PZF/zvVsG4zvPhtRIZdxCCgPwXgL3z520aiAL4Q2KgUIlv UFligpWVwVJnFkYm7yx8Azz0IyCxdmbrzBK+QJeOXTpVTLBUqqo0BD+fn/N8sR2X2n4vd+8XRb00 l7vn2Enu/Of9TGphGOHQl9SJnvtQ3I93NZQkr8FPDdmUWaxLmYUTUTTLJLNYLjcyCyq7x0504csv qA28U/tOmvFXofRhfPTILfwYKKWoK7sYeWpV99eJJSi16qqSTjixhZNZkLTCF1ls/u/qbYssqN5G kEGyDOq3nYODNdzcXJTlrz9O4Oj921aBBT0mWQQKLUqRBRNMVDqLWkBBYgour+ASi9v1bUNwwcu1 0GLt2uGiDCpzoQX2X34mqttmzWjYXvYE6bdKon+pZTahxbz9SCdPn6OtKdrVJn4Yq02tyxUK2kUQ c7SlSWihUTAhHbuQ0KL5sF9Uwec8W3K5oXOhqtoTdvPlFnXaaD5D5qmWfaEFT7fcVpenb/br+ymc h6ZoRp4WM6YjgN9ZUf4G8OwTwIvnAL/u7uDk8hI+np/D9+tr+LNc1otez8CYGMKXW6yYKIJEEySW wLr3nviChBckrrjnr6N61esagoyqTS7MqPvBcrFOVqwNLt/gggtgy0Ryi7ZZ5yC5hVDidsmE8dJ9 SzJV/9LLRWiKQ0ssiKZYCI0xEZpjI+aOcc5t2u+FhBa1+cETWviCilJg4YstumQW1B60D0deHR7C m5eDclS+g+bop0tQsev5LuVX3/N94oq+t9YwDGOfSSDsE+PsJHbDGJdUOgDFYBI3vAA3tARCeHFL yAlMcgg34XgXmGQ/hbguQsggrhPDkVQ6gAeQSQcwEZggNWQh0FC4JImDF02G/v6E+vuJ6y6XDkIJ GbjEORy8sDr0bdswtJJIBzAx+P1CY/kr0UhkwbFFDi6BxU/ZUFQQWxLdISTSAYxIaPuYtIDHDPA7 JAU7fvBYMKG1Px4OEUu6uJtEOoARWUgHYExOKh3AiOAcIab9/JpIi/sX6SBmBo+x4G/iQjiOOcGx YgpxiS1C3afNsbFdN7ifZZ+lAF2QpDrk38yYt+vQBMA4z45JcvBQzsDNP09lwxgNElvEkGzYMIxh ZNIBREwiHcB/kksHYBgjcwXuuBOKCnKI+7yIx0Jz4dDnF7Gd/99FIh3AiEidI3EKJrQwpiOH+M7v IgHtQjgOKfCzlcH2tRMh81k6AMNA/gnA3tnrOA0EAXh0xxUnIYIoQKKighoqJBrzCLxBGiSegDoU 9KSgoXJLwTvcC9Ac4urrro+EdAHugsfx2LMbO4lE7BnPzhetsr44u+O/eJ2L53OphePYpS2509td b5rPv8Jk8rCsk8SiqXOxBVRCC6hlFLGoAusktqA6L/x92A5vn/oM+7afaVl2OduEFqu6vim0WEss 1mKJRmZB0gn+3NT/FNuaxBVLJrdYMplFI7wIJRYkyKB+tgktfsNi8bOsf/n+CR69ehYkzY2fS6FF mWSVySSY0ALrKJvgQovyuShLWG6IK8ppuK4lFzgPzU9CC3yQKKOWWVT911KL1W0g3Gi2jP1j4WBI r6qUhBZ9o12UMHQ/WpLc99lWH+1qFT9oOG617aPS7++rLcm+U1qOoQUTYxBaHLqtHfNtyC34ayRk WK1qoUX82LfPWmyBjza5RZtgIhZYbEu1HE8ft8zf1kabyCKOg+q4XHcBrl8C/PpcdPER4EGlovx2 dQXvzs/h/cUF/FgsSilEcEVWrcdbEkpAKLggIQSJJuoCjaTihsksugrNE8xX/O1v1C7+jWLjfd20 xUCCC5JZVMtG0yS4ALa8gdAjum6mBOX8KnYIJBPGp9p3X/1rkTdoiQPREgehLR5EY0yIpv2oC4kY pT83g2FAFUs5dIjFFFxacXS0FlpUUgsqd6LpQHDBCvV77+QEHp+e7hPq06K8gO3yimP2epfqq0t2 Ua8CaB8h7Xq9ayPq3uEdx3G6sX5Tei4dgOMY44l0AArBRCZvwH+EOUYySCvpEN4I/xzSTbQ9hbTE FmMa42XSAfTETDoAZeBnD092msJ5M5MOoCdm4DezcfKivIYmud0MfP04jhSWb1anpIKpjuXbuIT1 ufaDbBgqyKQDUIYlgbNLLfrhDDwJziHJwb7Y4r50ACPAUhLdS+kAnN6xtL/6WEEGPC/k0kEMDJ7r p5Dmd154nE2lgxiQCdi/xrR0Hjgkc3CR6phJcb+2KgAmyUFKQqV9oO2Nv4GwNh7B5RnTbzv+B/9+ xXG2g8dIKp8HGhnjeGoKtv4n5jhELh2AIej6wrrYInVwDGHpfHAm0GcOaQktUBiZgb3ra61kkNb9 SnjOwfuVZsJxaCG+d8Iyfj3rqOCfAOydQWrbQBRAP20IFEJC14Vi8Kal5ACBQmeRU2TlVc/RRU/Q XRcF9QY5gk+QA9Sr7LLKwhtTrETx1+hbf8ZSrBDJfzTznzEe2dLMlz22JY30n0otFCUOnkvmRK/h xfyX+yqaTs/Byw3pySyKUmZhRRRumWQW63Uts6CynbaiC19+QXXgneqntnxUbjFYiw3TvtBim0Z0 e/eFFnWZiy3WW1lFLaxwxRZWVsFfX4MvtrB1Ud3t783x8T0sl//g4uIL/Fn8hvefP7C1coUWJLAo +x2XWVRCi1JmUYknuNCCSyxIXEHlVbGyIovivyPAKKerclkbyiyK3GmLbqXIohJa+Il9VWjxAqTf qtSEFkO2Lf1ZvpbQZAFjqGuIemMWWoQkgOijPunl+6zrNcunth5jFUyMRWhx6HWp5tsnqige6/0e Pt/OMh3aLOUWxRv7+JzgguprklI0pWcG9hwvv/WWaxJiNKVk9tMx8/LRZo/nI8D9bPP0L4B333H/ BuB2tYKfiwVc3dzA9d0dLPN8uxo7sgewe2XFZv0doQUr50xSQYILEmGQuILPl7PnH4tdMQY9OjKL lrYeWB1cvsEFF8DWieQWvmKxLFfr3JSknM8/FFLJ0SWT1Usnyh+q/VCS/4cURyixIKHFg4QYExFq XByJGMV+NxumSTTBJRZUdiQVLeKKozaZBdUHzZsd05MT+HR62iXsr+DKK9oEFfteb9OH7dtK6vJh hd/RFUVRumGkAxgQvKBRk3koSn/EdtJ7H+BJt2ZzvxaOQ3k5qSUdwr6KF1+m/r84A3sxRgqMJfEQ fhdjTECNiafn0kEESAY2+T9+D1P47zTSAQwACpIy6SACZA71RcCacF5RZDDSAQwIShsMxJWcrU9+ gCsXShEjHUBAGOkAegT7tCYRUMZCBnFfiD/GhGaH5pt0AD2S+vHTFJhIB9Ajc+kAEgWP/aQyXorb pJh8KBOOQxo8lh3zto5P7ImHJtIBBAZ+z7F/pyAijxUcaz2TDuLA0LkPsY7HpCQ56AKdlxXr543g fmgK8uYYzwtRlD7B3/7U/tNDYozv/Uw6AEVRRgGJLW6F4xgSIx2AMDGNY0r00wzSElr8hTiFkaGC x+1SOFeewP5lQMfbfTJIY4wJx04n0kEoypMA7J29btNQFMf/pJnaCokywtCJB+iO5IfgAbIAAyOI OQsPkLFbNoTEwhvkFSqkbkhZyk6lCoHygY/tEx9frpNUtXOufc/PsnIdf9zj2HWvr+zzM6mFYfQT X1KnN7tWmky+4OTkLCuzxKIsS7EFCqEFNjIKV1RBZRZbcFmOcj3ajtw+1yk/XUxu0Wgtnukikeh6 tUNokUstcqEFiyxYSEGCir+ez1JkIWUXVZFFVWiRp2VdFPX4OToapPN/4O7uJ969f4W3Xz/g8bMz sVfVIZNZFMKOlRgykcV6UcospNCikFNkI/5syiy22EyjOi1FFjTw9rOhEFvIGHxCi23JgA0P2j+V CS1s223VoX1uHxoTWrS/jdDOUe31m9yWCS3iE0wcur7AhRb/f7VFbsFChrXbai+/27dOllgMaGC5 xSOP3MIVVvjSK8vUy+6yQDXdsy8V831SNzspnNdPgN8v0zuoy7SKT8DT4vXDzzc3eH11hY/X1/h+ e5tJIaTsgaUQLIRgKYSUVvjkE1JSsRQyi7pxKWQVC7H+Zr4UVnjqWjoxrJzlpaTD3Rc+3CTuSA9u uWzNvXPTcgttqYQW2ony26pfe78Yi8NPaPEQIcbEhBwbc+gYQxKQsMwiK6P8LbLmhSu3cIQWQ993 NdKLgTNyvafDIZ4fH+8T6ot0vMB2eYVsAQ2cstuKcltDQH0raJ/5dQc0jANtGIZxPxLtAFokpof/ DOMQ9Omh9yaghOUJ7KHbrjJGPEmH6AFx+vu1FxByRsgTH8RAF5JdJNoBtMRYO4CAmaEb5+ZDoetu F19638VYO4CAoTahtZcNQ49z7QBagJIKkqxhrBxHF5ghvwbH0s53SbQDCIg+/S+2/iaja0yR90EZ 8XGuHUDD2PW3//SpvTDXDiBCqF8zlgRXJkuvMkU8bZ1EO4CW6ZOM66FQ31MCE9d0nT61bfZhgnyf 58pxtM0M+b7GzjfE81zWGP1ONGwYxm5G2gEYnboXSmD3NoZh7A+L835pB2K0Qp/6BeYHrItkAzPE 099PUP/2SDuIyKB3Wvv4HLkPkjaMYO8r1TFFHGKLGN4PMQLnnwDsnb9u01AUh48gqoSCBDwAklE3 JIRYkZA88ACwMiEhFhY6dgxSn6C8QB6DMU/QgbVLWSsxIldKW+Nj58Q313bt1Dc+N76/L7ISO/b1 z5YT/4lzPkgtANh/7iriJO99zLr3bQ0dHr6qDNuUWaS5zKIQUWy+FpnFclnKLOR10V+ILmz5hbTB nbQv8+oC5Ba9WqU2oUXBrTG8EFgUcokbKoUW8lrEFnWCCxFY1EkvRHCxtKY3ZRmSp8pk8oCurn5n 21VCP35+o7fHH2j67LGxVFU5RC62SEuRxfqRzVOEFvmzIbTIHyuxBUsrkjQphBYriYX0m+ILmc4W Wsi8bKGFXchXMoMtCHF1QWjhV9u7mofP7fkqfHDZjmsgtPBvepdtQWgRhmBi6Oz3aVdje2oZz5RV 1L5vnPv0lbyJ3CJ/FsFFWiO4KCdoF1TU9deJMer6m8oyNw1jHmZnWs+J/n7JBp0SPfpKdHBA9CdJ 6OT8nD6dndGvy0v6d1MKANciC1qdyRlCiPyszpRLiJjCkFSIoMKUUVxb410b46ZUCjEqz0a7tw3z apRbyLKst4dScMEyC1meja6D3KLPxyJEqYR2QfhdzV97uXzLwfiSg/FpvQg+ZhJ8ziZoZPRlndgp RGixPlwwhBYsrpjUiCrsrm4cU4rRdDjzYjqll0863YvxjjblFU2Sirb371KGdVR9dV61AACwb4y1 0KoAqQUAbhnTTe994Zu6Y8JNt/tKnHXftUMMBP6AUIU/t5+1QwxErB2gA2Pct3CxiYV2CKBOrB1g B/AfW+faIQAAoIFIO4BjuHhoRDim2IYLKva/IYotULSmJNIO4JCFdgAA7sERjbMA4xivXbgk0g7g kBCPI0JkTJ/pC+0AgcFFrubaIQaCvw9jwjZmw8c6IewrXtO49u8mkXYAj5BrTyEUih87sXaAgeDf qLhGzZF2kAGZUdhFZ/leFy6EF9J9WTPtAAAANSLCbz0+8FQ7wBbMtAMAAPYOPv+faYfYEZF2AGUi 7QAOWQw0HxFahHT8hf+TDA9fwwphG+NrV28onN/P+jCn8UtsIbUA6vwXgL1zx20bCALomIAVGAKC wOlSqUmTJkXKIAB9E+dziVRJLuDYXbqk9S3sGxhuAncCfAUDAgLJCmepMYfUUqZkkjPcnQcQXC4l 7Sw/Etcm55nUwjDCw5fM6ctjbzo7O4fx+NCVSWJRlLnYAlZCC3iQUVRFFVj2iS1o4u/Dz+GfT23y eRNMbrH1J3nqCnlFLpCgNKg0LVb1fDkXThQCCxJScGkFCStIaPGvtI6EFvl8zl6/cHVFu35Goz2Y za5d+eT8K7z5fASj8TPW03qhBc5JKuFkFst5STxBMgsnsViJK0hiQeIKqsMyF1/Q3KksthRauLIJ LXZDw+bqO4ZQhRZdYkILXUnzu0SrGEOD0KJtpIUUmo5pLftmCP3QKJiQEFoMQXzRdl9ozLdBVOGu je+Xa9K3qgCuSbsksUiWSSG32PPILbhYoi7dsi8VMy0DlNM/+4QWiaduUxpnVl6+AJh9yEZSv7Im vgG8fJ/X/769hU9XV/D95gb+3t0V228lgHgY3dEySS+4TALKcgkut3BlJrOgidaXJBW0PqubV14/ Z23de9qqE1wsWOyub9m+q/aFJt7XJoKLbYhRKiGdEL6r9qX7RWiKQ0ssiKZYCI0xEZpjIyRi1Lpd SGbhylDE6ewQSVISXCQ+kUX2mlJdZbkkuGATtft8fx9eHRw0CfV1Nr2DzfIKfsWTwPpVzibRBUD9 FVCT9XU7WOeONwzD8BP6zUIX0gEYRmBMpANQgt3UPWxiSjr0EexYrQMf0PohHUQPYOIh7Q/cptIB dICJ1QwkpASJhB3bhmFoJpUOoEVwzIm/IzEl62oL3GYpxJFktEqI1x67ENJ2mEoHYBg7EKpINGQ5 fBuk0gG0yFQ6AKNzJhDWOX0hHUBknEJYx08dl5B/t9uYdJ1Qr3V8pNIBdERIY8anQOIaO8/DYCId QA/QMRvb/6nwHD2VDkKIWO91+QNhykINw3icY+kADMdQxgspxJEg2TCM9sHxxaV0EB0wkQ5AmKH8 fjVh2kMbJLR420NbWsDnJY6lg4gMPC9/SgfRA/g3O+yriZObE7o83cYphjj/BWDvjHXaBsI4fqIs UZF4AtRI2Sp16RN4YkNsrO2AxNo+Qb11Zuieh+heXoCJiY2VgYFKCAmZuP7O/q53iR1bwfZ3vvv/ LCu2Y3/+O4IkZ13uB6kFANNm2+BN/NxpMR+3FVosPm1sc2UWuZZZlCIKd5llFiywoHVbbFEKLzbl F1yDZq7P59oVyC06HV2zvjLLZd2NIUEtoUU53GgpnXg1IgpXZOHKLFyRxYvZ9/9+tuAiq86R6XNs E1rMZiv19HSjl3/9+amOTj5bV+UOdmvLIkhooUUWPJHQgqdKbMFiCpZXrEssnvNnR3BhLxuhRV7W 4bostKBlW2jxqq8zN+v2NYCJAaGF//V9GaRdEp8G/x+yLoQWw9foq5b08X3Wkj6+L8a4Dh8FEz5L ICTPP5DQwt20XVRht382pHVd20XVblpuUUz6kQUXqkZwwce0CSj2rP3rZBfvavZtWm8bupnX94sW 00Kph4ti02XRLjpX6v1MaaHFj9tbdXZ9rX7f36u/WWZePyOyqC4rXxNCOHIJllPYsgpVCixYNEF1 Mkt0YT+a59e2ZzV1Vw3nqpNbaJmF9fdgWq01cgtnfqPcIlaphPSA8BBajIMvORjf8hA+ZmJ8zkZI vH/6Jmlh1hOx0ELbIipZRZPMomneb5JZVDXqvmYQi4MD9fGw0+98SZ9lyyuaJBVtz3dRhLVpvrq+ tAAAMCUS6QADQh2u8QNsAPolpE7vu/JdoVP31EmL+YN0iBGgH/kvpUN4TqrC7hTOJNIBWgix8/pS OgDwgkQ6wADENlgQAGBahNReXUoHmDh0P5BEvo/SQUYmpP+BtxDS63AnHQCAHblSpaAJxENI770Y cCN85tIBeiSGe9s+kRTzF+kQI0Cf4YlCP4tt0GfFpXSIEUikAwxESN9bdgVCi/CYSwcYGJYtxfpd nQadje0+Z+x9XVLpAAAAEb5KBwCauXSAjqTSAQAAk+abdADQOyH1wR667R+j0ILa2Kl0iAhZSgcY Ab7PfCcbY5KE3q8xkQ4A4uafAOydMW7bMBRAfwwvRjoULZChk4aiR2inAD5Mpy45QBcDvUACdOoU dOvYG/gCHbJkaBYPOUEAo0mbWM0X9elPWnIYW/Knyf8MQpRMkZ+y4NAIxadSC0VJi6ZFnD49ddLZ 2Q84PHxV5UliscxzsQXUQguwMgpfVEEyC5N43iR+HtbD66c2+XZTVG7RekbDfmnzq0ILI7EggQXl jXji3tku8/9qQYUvsiCJBaVledwaocUDq++hId4lo9FfuLm5rPLffp3C0Ye3rFflyrYSWlSLoTKZ BBNakGyCCy2q7WO6g7sVcUW1D7dWcoFlqDwJLfCFdWOexBbUvpValAtHuOH3QXkG0pdMhRbx1y99 j2xKTAv291VX1/XGKrTogpiuTxd1SZ/fJTH1ZZu6chVahJKb0CKUDttcJ6qwMoOytOX8V2i7XGRh 5RZMcFEXcsUS/hLMbZIKXg6gWW7hyy9Clnb2Y8KuvQT4cwww/wow/Azw+r05/v36Gj5eXMCXqyv4 PZ87129RSye4EMJKLzwxBZdL0DE6fr8ucUkFO9ZU1tbrtWV/hbJYFuw9K+Zg5zcJLnhf235D8/LO fZKhVEJ6Qfi+2pfuV2xxILHEgcR0XYgYYyJijo2QiC/2a0KQzAIZsM/yoN4feHKKFZHFYOAe8/Yd wQVL1O6L4RDejEYhob57TGgQXievaDrWNiryRzsA60c8T73f9oHvx42gKIqS9gPbU+kAFCVBUpr0 vgk4qftUOghlK/Dv3ol0EDsg94f8n0MOD2jFPN4rpAPoAXzIINdFVRSXFAVKU+kAFEVRWsCHjoMs 2nvCVDqABJiBeQA0JwrpACKgAP0uUJRYmEgHoOyUQjqADplKB6D0zlg6gA6ZSQeQGefSAeyAn6AL qYYygbQXHEJi/t/SNqTar1BQXIPXQIUWaZHyPB6VLZm+5ySd17ku5vNOfZyhKIrLGNKcX7KPFNIB BDCGtMd/iqL0D85tVTl9OhTSAXRMn3OvcxVanEsHkSETSP8+U3Hydswg7Tk1Y+kAlLz5LwB7548b NRDF4VckkVAKQk1jFAkJpDT0SCZXQKLego4rILHcICUFBYfgAMsBUiCaCJpQRoLGTRTFivF4/Jzn sb0OkcdvbP++1Sj+s575eXflXTu774PUAoDpsq1oE697nbfjvo4OD48ay+oyi6yQWVgRRX2aZRYs sDDzctoKL5ryC+7DNO6fxxoSyC1q92qZL6UP2U25fVXus2pmXbvcQootrkuZxVWPyOK6uq9dx0IL llikYozu/dnd/UNJ8pNeHb+gz78+0aNnj8Ve1YUWLLCwhU6FzKIUWhQyi1I8IYUWUmLB4gqevswu rcgiu6oJMIr5crrozcgssrQ2Ft8KkUUptHAL8EJocQ+0HzLt8ccEQotxxwmlyL3Pvsbo9z74yBKC 9CCk14H29kP2F9K+hL4fUxZMaD9PGkILxTH7RBXZze05kLxfY5uecSuxRX6rBBfOrVE2WZZq5vmu JuUWrghDloKWy9xxXNkFtfzdyc+mnhL9fZcvOiF68JZob4/oR5LQ+7MzenN6Sl8vLihJU/uwSJFF +TBljhCikkiQEEvkrRJRCMkEL2OZReos5+3d5e52sl+zTEo0anINR7JxKzupyzqkrKLWtpxDV2fK C5RKaBeE9zW+9n4xIeUIJYshpCxMiJmYkLMxEFq04yaUogkWWHTJLLraTpfMgvujdiPEk/19ev7w TrVlXlK3vMKVWGxb3/UJqU/pdZcnNvwnHwAAmpgfKs+pyJfLkn7QCcAYRNoBlMGXuufBEqQkHwmv 1f9hk7dv2iE8E2sH2MIciwdttAOAIIi1A3jA/AgJP0ACAITKnD5T/NYOMCM2ZM+PlkKsHSAAIu0A A4JjAZg652QLY8+JWDtAwMypKMe5dgDgnUg7wIBArDsea5p/gVFz7W+lHWJCmOuka+0QnjHv7wfa ITwQaQdQxPw/dKUdAgzOnK6LupgiqyvtEIGwhO+5GPC9LMvSRCYAALzfhcQUPluttQOAAohFwNT5 oh1gYKZw/PZFpB1gQL577BtCCzAW5nj0QTuEZyC0GAZzvc/ncU+TWDsAWDb/BGDvjHmbBqI4/rDo UFVqBd1g8cJewVwpfIN+AxhQt0rsLJnZMnWNysS3yFfoihQpQwfWDi1CEIrP9bs8X+9Sq/L5XS7/ X2TZviSXvx2nOTfJ+0FqAUA++Io3nT52p8nkO+3tvayXWWKxWpZiC2qEFmRlFK6owiy7Ygs5yfuZ fmT//Jhy3ieQW6wXWtzTRWjBAgqWU7gCiz/UTWQh21mMsbTzEEXxrLrNnG5vf9Lp2Ql9+HZGB68P xVa1L7XMgu5aQguWWhjZhJVZSKFFI6eoJ/ptl1lsYdepvS5FFlZowZdGbCEz+IQW64r2gjVo7zKN x9faZggthn0c7eLpQ/QVo9/UxA999ZnqduWC5r5J5fWZktAiRcGEdvYtE1o8bA6LKqzM4M49G1i1 dUUKLmq5hS027cgt5Nm3LOUcmvPtXHmFb50815PTZ0imwfvkBdGv4+qs65zo+Reiw7f37RdXV/Tp 8pK+zuf04+amtf/+NYIIKYTgNp67YgkWXLhyi+AkxBVL0Ra6PYs1/gqxxtKTRQourJhDZvcILuS2 uufRsuD/6sx5GDSLsmsXhM9ZaJGSRCKVHExqeQwpZmJSzmbQONZTen11xeQtiqL9dt5sQ/12z2KK gOCiFllU92+1OestwYWYWKKxv7NDr3Z3u8R9U03vaDUK8cktfG3uaCgkuiB6OKLxKbxC14ee/M06 KAAA28hIO0BErgmFPADom1I7gCITwpe6c+Aj5f9jMlPYYawdYgMZaweITMrHfY4/JsMYFBhK7QAR mGkHAACANeQ0plhoB8iMMeX7A1CXUjtAAoy0A/QIzitADky1A4BByGkcZlhoBwDRyemYxXhhGMpq +qwdIjIoQPQ0TMGh3GV0Of3NZLapcJ3EvM5PtEOAKJTaASIBoUUbM+671g4RGfOcT7VDJMRMOwAA YDBMgWWM09LhQDvAI4wo7e8BAgA2hxnl9T2KHMWsXRlpB+iRRaR+j5q+t+X/gub/B+8J59haTLUD RAafJ/VLrp8/5vjZEtgg/gvA3vnkNg1EcfiBskFEQpyASAhV4gpsDFeoBNtcAE7AohIcoEuW5Qbd sTV7umLTZdeVKlVsogqH4LH7i8fjP2lTT97L8/uiUZJxMv7FdRPbcd5nUgvD2E/6ijVh2mHe3m0a 6OCg+TlUl1msCplFKaKo34bMAgILd98XW5TCi6b8AmO4hvExr9iMQWzhqIpytpXg7BNaFGVDC4FF KbFYUiW0wG2ILdoEF387RBaYlnnX1RjVuMjTZDJ5RDc3v/P1aEFfv32kt18+0NPnU+9VNeUQhdhi VYks1pf89UBo4a4hsygaVWILJ61YrBal0OJWYoH7vvgCz4PQAhILzAsXCC3CgrvIbGwB92Ibk9Ai NtJFCbuej5Qi9zHHijGuVPGDhP9baeso9/OHHItTJBFrLM55SxRM7IPQYuixhM5zk6jClxP4j7uX PO72YZBbFNcQXEBuAcKSyn6J5q5SzW3lnH15hV8aum36XfrQP8n3tl4RXX3Ku46JnszL7l/X1/T5 /Jzen53Rj8tL+pNl62UG+YO/hxiKLSCRCOUWy1VTcLH0ZBZZ0A8RRdifef3/gvllwfPbRBdQM1ay k7qsw99TrrWe4wW7kFtwFWXnLggfa/7cr8vPIQVpWSTlcUjMBCRnAxz5pC+TNh4HmSG0WG8i9Mgs utqkS2aB8YhaN09eTqf0+tmdzv19Q93yilBi0Tc9bJumt+nEuti/lcEwjLGTcAeISModwDAUknAH YML9cFrryaJjwv1g5Zg7RGSssMP2pHn7yR0iMlJPDp9xB4hAyh3AEMGMO0AELrgDGIZh9CB1W2cb Uu4ACplzB9gRL7gDCGDGHWBArEi1oYFT0l9009D13qv9+KBRoqlokW0v7Ab33ZL0opYPwX1WJ2QF iLblhDtAZBLuAAOj6fjRfbBCY7rRuF7beQ/tnHIHiIjbF5tzhxCG5r+3YRh1nNBCyz7nd+4AA5Fw B+jhiDvAQGhZVwxj3znhDmAMgqbjAjG+83DLJyU921ubwPH+lDfGaDkiXd9Dhthx5uFJSec5Cu49 d8Ydwhgv/wVg73xS2waiOPwwwiHQRaC7rmbV7nuA1jdoT1C6KPQOpdCsu6p33bXbrkJukCuYrgMJ OYQgYLua0TzpSYwcUc/4jZ7eZwbJoz/zk61IimzPp1ILRZFBqNOmz08ttF7/gbOz+tofJRbtOBVb gBdaQCOj6IsqUGZRFzpeF7qcXQ9dP7ZJhymhHZ3KZh/Y1rZr0lpo0XRR6svW19PnrbyillSgjAJF Fo/NtFZo8diZ1hVcUKHF1o9v4ZDQYrlcQFn+deM/rr7Cqw9voFgWuJUHhRZ2iEIJJ7Oo2kXxBAot 7HMnsfDiCpRYoLgC6+w4FV/g0KksiNACHyi0cCILm4cILbAOMyv/AffLNjehRcq2ud/LY8lNFjCF daVYr2ShRU4CiBjr414+5rqkCC1OsR1TFUxMRWhx6m3JoM1Door9rv1faOgxNgeKLKzgAuUWKLtw XVCHBBb9rpkXB4Z9oUVfZhGSW4TaAlIX6P55fwFQrqqRnwDFF4Dnr+v6Xw8P8Gmzge+3t3BflvW8 VAZBJBe7AYlESHDRkVH4umDxwgu6/DYwX9NuYN5QwflQbrHz29QIOnqCi+qNhb0tfvrQfQMqwYgF Z2f13B3Cp2qfe7uQnHLkksWSUxYkx0xIztmQU2fMbZ8eSz8zyizcOJnuTu8ophgQXDiRxWLRres9 7wguSMF2nxUFvDg/HxP9ZVXslQNedYTkFqG60FVPSGQB0L2C6dc/NX1oZ5jeTqIoypyQ9AXWPjfc ARRFIIY7AAPXoD+clsIlyP5Bgv2SuMpXjkO69MRwBxjAcAdQlEQY7gAJ0I4SFUXJGcMdICJ6vI2P fU3n0jmK5Pu9YzDcASKixwJFCtoJo3wknXvuuAMoyZG0v1ruuAPMgFVV3nGHSIgKLY7HfrYkWeJl uANERtp5YAz6dy4fafu1yg2GkXqvyB6n3nOHyBB73N5wh1AU5SR85A4Qkd9VuecOEYEL7gADrKry ljtEBNag97QUJRf0MzwZGO4AEbmJvL65Ci2k3j/IHVOVb9whEqL3mdNxyR0gEdLuWysT4p8A7J29 jtNAEMdHiCJIJ/EAFGcpEgUS4gmQoOIFEHWe4Kjo09HS0PMYdBd6rqG4Ov3ppGuOk9DJxuPN2Lub rJM7f8xm/f9Zq3NsZ3fs+PyRrOcHqQUAx0dbkiaZ97Es7/dVNJ+/9qZI4sZGbMEyCyOicMdFZiEC C34tYgsZ5+LLL6QOLlK/tDU2acst3PViUYURR5h5Zr2lNHKLRmhRpQfdvKcRW7giC1dm4Yos/tXL NsvZgovDhRazWU63t3+q8e/nX+nFh0aM50shbFkECy0qkYUMLLSQYSO2EDGFyCt8icVdcecILuzx WmhRmHqk3kpmsWlPhBYi1DBJVM3grwN4INqbDUIL1D1UG9r79thAaDF8HbHto9rv77MuCC2mJ5gY u70jkUt0pmObrZIKcu/7dsnwHhJHJbcojNBCBBe13MIssJ1i2RdchEqbwMJOFW2/9uUWT6i9fWZW 3oW9JLo+Kyd9I3q2MJN/39zQl8tL+nRxQT+vruhvntebpdh8SVBYEggRR+TW+C65RTVe1iXzZZrI LO6t6bn1nq2/1vJ+W774Ypd4Q+50HWEHkSu2kPW1S8v3Bn3ILTSTsmsnhB+i/VgS3ccSBxNLHEJs 8TAxxsTEtB+F0Igx9m2yC387+WsgQov6dN4iswiVpyGZhdRH25cezPzkhF49P6h/0FsKyyt8iUXb /NAV0CFXTPs4vp0DADBVsrKcagcxICvtAABIkKl1KuSHgxfaQYBeyMryWTuIAZGH/NFJvBv8gFYK D9aGiPUYHuuDwAB0JdMOAAAAJkYKCTyEtXYAibLUDmAkpn59jWMBAPGx0g4ADM477QB6BEle0ifT DqBHfmkHMBFSl2EvCMe+rvBvcyknAIz1t6XHkmkHMDJINDYNUvo/5T46kBuESfWcjb4uYVL8zFOW gQHwGDJK53cN7nO3ojSOXbFeXy21A+gBPg8stYMAANSsKe0+01Phzf5FjoZ1j3VBaAHG5od2AAOC 75mHZUVpno9jva8CE+C/AOydsW7bMBBAr06GBOlQtECHLtWQfECRIas/RUv3rv2Eju5SdCnSsX/h P0inDkEGIb+QAE1QVK5I+aQTTcZpQOro0z2DIC1T5NGwLVqW+VRqoSi7j2+xpvfbdlosfsDR0Utb plIJLFO5RSu0gE5G4YoqUGbRJlpuE93PtEPbxj5pPjby5BbuWPqlNo20oq5rsq2XWKDAAssosqB5 X/6zFlS4IguUWGDq67dSDJRYYHt/PfH2HBzcwc3NL1v++vMzvD47JqMKCC3soqVEJkGEFqZsJBRU aGHzJt3D/Ya4wt6Hu05yYepgfRRamJtp25RRbIH9d1KLVT0QbrhjUP6TKT5tKrTIq+1UfeTcXq7C h5jtxEaFFvntH7MtFVpMQzAxduxPaTcjucST60UCJRVBAUH3PXcFG7fVw2IM0onlGbmh3MLmKLig YgnMZ4HclU/45BZUVuGW95xtuA8lsCT06gXA73lT+NI08xHg1bt2+7fraygvLuDT1RVc3t52Q6eS ByqF8EkkfIKLmgop1ts6IYW5vxZXDGQVzTZab7AP9uv05Y2B1EO5BQotajIOKrnAxzr5ReDcAa3/ WDgXq+deKD9V/7ksdJ9THLnEYsgtHkOOMSG5xkXhiHEXnheXbTGjzMKWSX17OEcxRUBwYUUWs9lw m3N/ILggCft9vr8Pbw4PHzOUkyadQj/r8MktfNt8sxyfyAJgc8bim1GFHg890bv3olEUZQpIvjjI XDCnF2MqSnwkXfS+DZUEyEL6okPmtVpxByEEyQsPzbkDCDClY4uiKIqiKGkouAOIjJ7TSkPVpO/c QYyA5HO+25A2dv0sUKSw5A5ASU7BHUBE9LNXPpLmCxV3ABOgBNnnrxcg+zeRMTnnDiAh0t4Dc+4A RqYEnd9MgbfcAUSkBL1G5yGW3AEkwIjaltxBZEzFHUAC9LikKENK7gAicr7OJbzPC+4APBQgQ4Bi ruPV+Z6i5IWEz+0pI+k3D0MVqZ2pCS2MJLQAfT9zYv7LI2GuFuID6OsrNRL/7ybtGKXsEP8EYO/s eaOGwTj+8FIJVZVAbGyRTuqAxMzCEDEhFgbEwsQnQOwsZecDdGC4z8F07LewVYKhzAWpqEN1apsQ J36ujs9JimTf4zj/X2Sdc/Elf99FraO8/CC1AGBc9D2ciZe9rsrzoRXNZk823rsWWpAhsSi01IKl FNcyCxZYqHkWW3BdFVt+wetQpX6AZFGutxkDacgt+oUWTf8KXb8illqoebfcwhRbXGhRxWpAZHGh 27L0wiW04G10f987O7/p7OwnvXj5lL78OKSH+4+MXrWFFiywqPcrU2ahhRZqMsUTLLQwJRYsruD6 eXneiCzKVUuAUc/req20UOssLxtpRnlF5lSLLLTQgie7D+A/ieFr23aGVIUWIYHQIq6H5ockVjFG DEIL30gLKWLap2P5bcbQjxgFExJCizGIL6SEFoHaucbfrWbGsZ8ptOj7jIu12IJutwQXt0ott2ga bT5y2ZZQuIr9uGeibtkFz9/R9dLRxrV9bnuvOjrbJ/rzvnrrM9Hu26b58vSUPh4d0Zvlkr6enNCq FiRacgtDAsFSiMKou+QWdb0o1m25PS9rCSuMz2y8agnG5dC2HOINU/VoCi5YYMHzZLaz+u7iJnIL aaGEJKG2L90vBjncxJZHEWMmJuZszLYzxiwg6aMvs72EhRbrf989MouucrdLZsHro83hhmK2t0eP 79/oWqFn1C2vsCUWfcuHRj19ZYjx7SgAgCmS8sVBuFgOAP+k/DfDBSQB6ZBX5ZV0iIB8Itzk75O5 dICAPJAOMCHwXQNFijco5dIBAACgg0w6gEe+SwdInBRvALWZ8lg0kw7gkW/SAQDwyLF0ABCclB6i i/OL6ZNLB/AI9tewqHH1gXSIgKjx5gfpEAmxqMov6RAByaQDeCSTDrBF1DlkiGvSJ5cO4JG/hPHN FDmWDhA5C+kAAIDgvJMO4JG5fl0IZvBFJh3AwYF0AA+o8d4UztUCMDZwHDZuUrq/x9c1EjlNT2iR E6RRkqjzSSmPcZQgfS4dYgLMpQMEYMrXMAJh/gnA3tnrtA1FcfwoYUFUqkQ7weKlc4c+QLN079Cx iC6dEANi6pa1I1OHToyMfYLyBDxARaWw9QWIhEQIPnbOzbG5JqFc51zf/H/Rla8/87fJh+2I84PU AoBu4yvS9HXRSicnZ7S1tV30tVSi7OsCjdNCblHKKO6ckEKLKkRmUTbdL5usU0ot5tIMqf9YH8ZA d+UWjwstSqR0p8gsJvnfReQWEyedKMUTIqfQAgstq1gkstDTRYwxccMm+v1enukPjcf/6OD4E+2d HtLL3Vdqr6qPQmZB04rQQqQWIptg8QQ3kVGInKJodOP6IrZw41Qd1yILJ7SgqtBCZ/AJLZ5aKBdE BoQW8W8/liLtlsRU/L/N7UJo0f42Qm3Lev2Q27JePxSr2I8YBRMxSyAsn78joor/Xe5RucWdFjP4 H8vmEMEFCy1EblEMZ48HpZi1XGLR0Nf3zZPt9j3T9DjV5qnp0/zSa/wh7/zIN/ON6PXMh/nz6oo+ X1zQ98tL+nt97Q5JRXBBcymEiCNEIvGg0UylqOQUuvG0W8+8Wz3P09yyer1aBpdJZdVyCyfbkOXV vsnVtOxn0/0DvXzldWJUlN26IHxbz2+9X7HlYGLJwcR0XIQYMwkxZxMsMsZ+THw89TiJzKLo03yf i69vEVM0CC4KkUWvV51WG68ILlST532xsUE7m5vLRH2Tt3c0P6vwyS180+pnN02iC1L9ushimflN B717LyIAQOoMrAO0yLl1AAASJLMOsEKOCJ8jKTG0DtAi/A8cQ+sQicH/oJVq4aG31gHWiIF1AABa IrMOAAAADQysAwQEBQPahY9v6uKQzDqAISkVbBhZBwAgMBC1pMvAOkBAuKgaCr6kT2YdICC4dmgX Fj6kJO3R8OfdR+sQCZKyPCCzDhAILqCU6vu6Dn5DXh8y6wABwbnNcqR2fT2yDgAAAIbwdVkq56f8 /TSa9UfNi3WG99YBamR527cOEQC+14L7rwDEx7l1APAsMusAAQlxX+BL3n4ThBZgtaT8exIE6auD 38e/rEMEJrbrKrBG3AvA3tnktA0FcXxoI4oEEhwBKVIXSJyALiJxg1btmiOgrtggdceGBQdAgpNU PkBW3bAN+yzYQdNg13Y89uT5Iwm2mefn/w89+QuP51nG+CXW/CC1AKA7VBVl4m1fw3a6KtBweJxb l8ksKBFZUCKiCISYwk9lFiywiJZZbMHzUTPlFzJOXCjSD9Jj2kp35BZFpTKrhBbLUgsWTfg+yyZY PDEXUym4+JfKLEzJBQsssmkWI4vL+eQZDLbo5eVPeJ3M6Or2nL5cfqPt3U+iV3k5RCy2CDKRRfoT 9o2FFtE0FlKE87GcgmZLIovn4HkhtEgkFrwsxRexDINmqdAiEmbIY5lCC7MwLucMaqB9+iC0sD++ 9jXyVmwq2N9WrKbj2iq0aAKbzk8TsbT3bxKb+lInVl+FFuvSN6HFulgmqnjL762SVMjxX27cse64 MMjkFh9oIbRgwUWl3MKUVpSVaS4q/2zuZ277aMTh/cuOz+yEI7jPRNOf4eprot0fi9Xjpye6eHig 7+Mx/Z5O6a/vp6czEJKHJbmFEEkUCSOi5Zycgigns5BSirmxPp0mMot5ErtMpPEqtvvGOim4kKIO Xk77K1vF5wfxWsVi9doF4ds6vna/GJvysCWXCJtyYWzMibE5N0Yjxy6cF5ONZBYFyyyaYIFFmcyi rA3KZBYcj6jwUWO4t0dH+2u9N3RC5fIKU2JRtd1sq7abKW9yagEAwDZcKvJl4mknAICDuHzPkEQv 3t5oJwEaY0TuvgyLokPtgcJDoC4j7QQAaImRdgIAAFCCS+PViXYCPcD1Mf+hdgKK4F4AAADvj0v3 XhTR7QcuFZXBNdseUeF7l4v0nBGKXLWBp51Ai7jy/96VfqwC3yH3C5euazzb9BNPOwHLcfHvwtNO AACLcOmZ7V7MT2jxTNp1DrQTEPzSTqABHmn5OgEAANAMI+0EGmRSc/+zsN3VT6MzQGhhB4fk7vdJ +Jz5/fG0EwDAFf4LwN4Z47YNQ2H4OREMBMmUjl00FAU6FejaRWPPUBSop56gYwcfIZkyd+xU9AY6 QZbuQYZcITCQ2lVNUrSeaEY2alGPpv7PIERLsvRLFmTKsvlBagHA8eLrnOnLrhddX/+g8/NLXedS CVPnHTFWtdyiLaRwBRaqbgqvm9LIMMyyrDTD9vPoDmMlbrmFL1cjrzBCi0ZiwYsRWujuO1vyCiOp WDI5hZJVPNXTnuryZ2ta+zkXWqzqul2fn+l0QovFb12/+vmNXn18T9k0q7dyWw7BhRZqaKUSWmax Xq8VT1ihxUZkQUZkYSUWXG5hRRZqfi6y0EIM9WBCC/voElroOoQW/SC9+6TXPyQQWgy7nlg6uQ+5 rCGW+z+EyBKD9CCm40D69X0uL6ZtiX07jlkwIf0+SQgtYl1niPk2s1eb9rp3ekvMwIbONck+OSbs YeUWelh1CC54V9DkPHeHu4QWE7aMU884V2ThLqPeruqS6PHDun5DlH0levHGTLq5v6dPt7d0dXdH D4vFZje0BBe0LYUwV6GN2EKJKOz0VbUtp1h5ChdlLOv5XTHGkr2eiyus4MK7bJaLyy18Mg4utfjL ttP9DsF2cM7nHwrpDuEhtBiGWHJYYsujiDGTJeZsCglhSmySln04NLOVWeg6NceF/mi2YopnBBda ZHFy0h7nPG8JLlix673IMnp5drZP1Nfr8o6aFoNPbuEb52vF+EQWRO3WjTt+1/QuMTgAAMRAvi57 WYSOlBT/0AeANIV0gAHAD2/TYy4dICAzwh8RQlFKBwhILh1gJLwl7GuQJqrjx0I6BAAAeMilA/RI KR1gBKQssRs7KXXkWEoHAKBnSukAIBi5dIAeKaUDgOAU0gF6RN3Pwv2BcKgOiFL9LcUvwjVRKFLe rzF15noIKV0zdjEjfEaMiZSOa/zWb5zgfe8G53MA0kW1sT9Lh+gJ9R2Fez2Uwvk9lnZWTmkcK3Pp AIEopAMA0AMpnLPHTC4doEcOORZnNC6hxXcybRVcM8ozp3TvJ80Ix9jQpHifqZAOAMbJPwHYO3sd p4Egjo8jpLviiruCGkfpkBAFDRUg8QKIJ8gDUPAIqelorqbkMQ4hSmiQqE1HcyekKyhQvHh2Z5zJ 5lOc7dls5hdZ61uvx387H7vrS+Z/T1uAYRh7sS0ZE2973SwvdwWaTB6t1C3MLICMLICMKNySMUUw tQiGFsG4Yt4aWLDJBS5sfoF1cRyfELJ27TEPCdabTlK1+PrJ9JgLc5IoxSYZXbRpRMlsQhpPBDOK omCTCza3+LtSLtYXphhYBqMMjsvrm5/v09Mabm9/+PXLz+/g/pOxOCu3UtZkjoGGFvzw1hJkMIEP aWyBpTeoECYVbHARm1j4v5sHG1hgHcfguO1R3LKZRe1IlzCzkNqN/0T78mkcX+uczdBi2ONoJ08f IlYfcVMzfugqZqrnlQua1yaV92dKhhYpGkxoa0/VXCJ1o4o7vk7kOL1YM+129WIOyG2xnVzfRwe3 8/s287Q2Hu3nChHAQZjlYznaHdu3rcU+XDqxfZ1GbluIbU7Ux22Rk2a29xDgulmK62Ye9xXgz0eA Lzc3fkHejMfw9OICTkajsJuc9zfnXVNdK5eSaTuqazNeY1uqW8mETdewLak9x6ipLZfytGS9Py7O 75v95DFcFK9NLk5GFq1JBW/nc4ifG9K3jvjp6Rrt+xZmZjEcpmU7KWpiUtbGaGg8hOsScyczC1ju P4oQEArqm8CPGULfx2YW/s7uGsMKaXIxj+rm1G+OqOShA5tmYJ87OTuDX+fn8P33zu88PGuWbxDM K3jEssnEQi5ydCMlyCGAHJVsM7bYZ4RkM2TDMFIklR9b9MFPsC/OGUYflNoCBmAK9vmREy+a5bm2 iJ6wpEP9cqUtoEdKbQFHxAxCv2IYuTED+5GJYRjp8VhbQIdU2gKOAJz3f4J854s53/fdxQNtAR1i yUMMwzgUcup3Km0BRu+U2gI6xMYK/YGJRd9qi+gJTDQ61RaRObnONXPp70ttAQPwHux/yMdGLu9P pNIWYAyOGbUdJ5W2AMNIhFfaAjoEx5/x5/kVHP7cqNQWQMy0BXQAzpU/aIswDGMjNiY/XPBetn1H 4jgNLabaIgxPCXmYj63D7jPrUEH4TXROn+2GocI/Adg7n9u2YSiMP8s+BEiBFs2lp8KHjtABcuoU PeTUCTqAR8ihgIGeukI38AIN0AniQ3ew4dhS9UQ+maZp2AhEP4r6fgJBUqLIT4oU/Un0vkJbAADg VYQiZX07t9J8/ptub983ZddUwpTF2MKEezTmFoeGFGJaIcYVLy9Va2qx2ZRtmZNrhMF9iWmGxLP0 8z6x30+qKgJ139Bib2QhJhau0YSpGzMKMbJwTSvKclOXN3U5nJtyyNDi0BzjvKHFujW0+Pnn8SJD C94+11DCN7QQQwrOxcRCjCvYtGJdramZqvVRWdqI2YX0ta0nLnPeGFvY8Xk8MbRo9cHQoju0d9+Q DC1ik7pRwrXHSSXIfcy+YvSbqvFDCudtaseo9vpd9qVpJBGrL82xUzSY6IOhRdd9pTxm7G04sV5l p1A7eQZskj9V3npnxh45UzEqjCkD53Y6etoPujo4OQXm+2Gk/ZDQoxPL3Hl0op1syh3R6ktdmBNN vhPdfTTzfzw/09enpyb/t1qZthyQW4Jwt/uR2nppg2vvbH1nkyyT+rYsTS51L99JP159a9ts3bbS l82bZNvu/OToquzx4OqWZaUsb/ad2ebK3ebAe4TKSV2hHRAehhbXoTFTSUQLk5IWIUVNQsraBBha XEaXmsUkqSk7fYvxRJts3TeyGBfF4TyvLsnta2zH5PRmMqEPNzeXSP1Up8+0v0MY07GBRWiefxcT Wn6wC7xEFy4/9UPp3wEGAMiRnD5q9UEQDwDikPs/RsIkID9m2gIigaBD8eGPtP5qi4jEVFvAgOAP VabaIgCIAAceuNcWAQAADrm941pqCxgIOT//v9UWoMS9toAOQUA/AECfyOlebKktAEQnp+MVfw+P Bxta5HpP/UC4z4zNQltAJN5pC+iInK4DIfhZcqYtAlwVPjdzumYttAWAq4N72mGy1BYAQCLkZKb4 KzAvh9/xU20BlE+g5Jm2AAAAyJSc3nVxEPfXvLt+IBhaAD0etQVEgs/HmbaIAbPQFtAxOV2rQI/4 LwB7Z8zTNhDF8ScUqRJCSKx0oerSsrAjhkjsrVq1O1+h3yB7J3aE+Ap8A2dnZesQxkpkQl1aYddn +5zz2UcCnPOeX/4/6xR0Pp+fTSKfz/L7QWoBgHyeSsJk133Ny+myjvb337XqFjILqkQWVIkosoaY opRapEWx4ory76ySWCzqSvFF2uqnSPyYZvU+hw6f3CIstMiyNCC0SIt1VKcKXQguSvGEK6ZwhRV/ A+UfLQQYtr0vtLDyjO5zZBKzjUa/6eHhF336ckKXswva+/jWOaqm0MIKLIrvkSuzcIQWRjhRiCjy pRBZ5MtSiYUjsHAFGLYPK8cwIguzuPIMsxQii0po4SfChdDilXCfPgk/by375v5fvhZpsoAh9NVH v5qFFpIEEDH6494+Zl9ahBbrOI6hCiaGIrRY97FI3udz2r1gu2WiCvc+0G3XkmIs2XcttqCthuCi IbfoStG8SsrnkAQjJLTwRRZ+Ouiuvixv8ru/Q6L5JK/+SbT9rayezuf04/aWvt/c0PT+nv48Ptan wZVb1EILV2BB1BJL2Ha+oKIuaVp/un10Sip8EYbfjqi13hdm1AILT2bREFtQU1ph24fmEWLILbgT wmsWWkiSSEiJwyItHoPEmCySYzNwfNcl/b5WJWbMXT4rK7iwAouQzCJURiGZhe2PvOFBdSzvd3bo w+7uKmEfU1he4Ussnlof0m6F1neNVFY9tQAAIIExdwA9ouFlGACkMeYOoGcgCdDHmMqk2xqZEJIO rYOEOwCggivuAADoCa0vYwEAhommF9+m3AFsEAl3ACA6B9wBRATz2wCAoXBASKILhoWmeweMF/rB JAfXlFjU5Zp0y/2kkHAH0BNapBZanx1bzgjPkDcNTWObO+4AAAsY024muFYBUM6pHXEHEQlzDU86 6mfrDaMXJIy1JtwBRMA8/064gwAAAKVIuFbFYvaCbcxc/iYJLc4J7ztJYpyXz9xB9MQZ4d6dE23z ZVqeL4GB8V8A9s5et4kgiONzl6BIIURCKIgUSFfxAJSUKWmAJwCaSBT0lH6FSDxAWiQewg9AQ0eq 0NBSpKAw8h47vpnz3PpsE8V3cx7Pzzrth+/2/vdh764/5r+vLcBxnFvTFozpw7qNLi6+wPHx41le mkpUeRlYsSRzi6YhRWVUUS1YZjMLNraYTOaGF2x+UZlazE0zOG5jmm47fC77Cb622tCiIoh6aWgx pTybTUxrA4q5oQUbXEzI7OJvnZ+bWHBeprKtQHWsZ5E8z+I9chXvmwmcf3wNLz69gvsPj8RRLQaH 5eCyQTwahhZkOoEmFJhvmFRQygYW+KjLlEfjClwPU26DU2meEZIHB7JNNTt3RPsUuqGFt93VPrTv 7b5xQ4vu2xjaPaq9/SbbckOL3TOY6Ht/FswlhrrPu7RfyizN9Vqm4bN5IK/bMhVsbLNm33JdzJdZ WaU8b894Ei32h0ugtFyTBrGNdFuApI5lhKTM08ss2SZxYSgfAfx5GTNnAPeuAB58Bfj9C+Dz9TVA XM5OTuDN6Sk8OThoNInHOWs6zqlndVTmOXZORhEyinV9aPE5DM6NknOSjoG7sU0ut6XysHOpA9ui tCQNgdpqRNzGYON0fTAPrJG2qz8nEMfBp7JxzMnz8tLIS7AO7WDwls0skKHoQFzLaoaoiRmyNkZD 4zacl5QuNWeyTxFl7ntqUwrq/1Iji2mew158rq6L5akoB+ozQ6wPIcza434L93G0vw9PDw/hx83N OqnP4vI8Lt9IKppbcDfLyx41L+vSLnnB/wlWW3elo5wUWd82AsuW1DuO4/RFoS2gQ8baAhzHIJZ+ 9N7GCPyHt9YYaQvoCPyTnwcS7wdrPwhnrL+fDw0MkIR/nPLXrWMNDLCA97XVIH+O42wXhbaADWJ1 DDpE8FyjwaWlQNy7jqW5jr8XOI6zLRTaAjbId20BTi9YGi/81BZglHdgc46Acx//HK8frI7lLQTc LbQFdAx+h+zGNbuHj212E0sGPVb7TWc1ft0dx9b87HJJvYXXunbw1SIub5U1bAJL97vjOM7QKLQF bJDxLde/BBv95P/yHpaPuxwdRtoCOgIN0sfaInYcC3Mpx1HnnwDsnT9u1EAUh58tAhEpkhuwaEuE aJCokPYIFNDnBuQI6Si5AMVyhFwApaGlQKJ36iCkFESCaG38xh777di7C8jjNzv+fZHl/zO/daQd e3Z3PkgtAAibTSNkJWLfG6osYluZz592trUyC6pFFlSLKFqZRSu1aKUVUmbBy6tVvia9sEILu52X jYwgL5o6Y8Sv3KLvmv2t0GLlLFfyCSuhqAQUVmBx5wgs7pztv5vj1891RRmbhRYHBynd3n41y+8+ nNHs9Qu6d79tjjYJLfLyNfKc5RKN1KKsy6gsavEEyyl43Ugqyj+WVhh5Bf3qLNt1K7wwKgtHaGGF GVKeYUQWVEBo4ZMpXkIILcIq21cdIZcXqvBhyHKGBkKL8M4fsiwILaYhmBg7+/+UG7JcQuv9WUEg 0iu3kDIH8SzYeR4o+qUYfSRF0tTD5TTlWadFIsq2ogqi3cMzbxoGWkoppNAicfa76/J48TobDssn yGdEP8op+U708DPRzwuiT9fXZmLO5nN6fnJCD9K0Od3KLKwcgpz1RnZRTym10gkzmnZSXekiz812 Ka/gc/O6jLQ+bm2/ub5tHR0BhlO/HGy8EGWaS+j0DdiBwhObz/3/bOlL2OJNadAeEB5Ci3EIJYcl tDxMiJksIWezjJ1xH65JH97e86hHamTbrXrZ2CGEzML09jpii47kwtnG0ouUZRZ1OYVsW+v1x0dH 9OT4mL7d3OyK/bKcvlC/vMJOSc+2QszlnYds4qWGy91PYr7rLg8SCwBAaDzSDuARfIELgOGZaQfw yBVhsPHY4MEbYvohv+RcO8CEyLQDeEL7B7dT5D1V4qSlcg4wPjyIVKztEfOWqmevpXIOAABYaAcY kEw7wMTgdizWtprv+6cm74xpIEf0bwMA9oWFdoABybQDAO/w/VFMsoJL7QCREutAi/w5aKYdYiLw cxgEimEy0w7gmVPtAECFmPpCLrUDABUy7QBgdK60AwAQCK+0AwzIcsu+ff/OjHb2c+X6h+Aj4TMv AADwSUz9Atk/HLskCC2ALgvSv1f0AX+2caodAqCfFIAh+CMAe2es20QMxvEvVzpUlRAgJCQWbukT sDLkDdgRQxdmXoAhjxCWdoO+AeIN8gIdeIBKUSdWBtQ0ahPOPn+2z/jSQ9j3Ofb3O1n22Rff/xwr ttvE/4paAMMw/4Rv16wPD73o/Pw7HB8/k2nbVKJNo7FFuztla27RNbawDSvEOZpZoLHFem0ML/A1 bR3QMbPAe9pxjpj2DFajJ8+YV7SGFsbEwg7GYOK+x4wCDSvWYAws1urcFxvDCxPuoGuUscvQYqIN LebfPsHJuzfa0MJnDtFnaCHNLJTxBMZoUCENK5pjtV21AVY6fbO9kTGaWoijz9hCG2Y0xy5DC8xD zcx/kkITjq0hV0OLmLChRVqb5sckVWOMFAwtQkNtSJFSn07lvdmH50jRYILC0GIfjC+oDC1SMNII +P7oFUrPes9eC+J17jpnqM6JdVSTqjVpELE4hPmFva0zgOXy4MTQk29vG1051/rK3XP7vnad7mM9 B/j9tkmcATz6CPD0RZs/v7qC95eX8OX6Gn7e3uom0KvbLbafWt2Kvy2IAO3qU6TvVdD56vzOF6vy TV+5iDcbXYcOKk+U4XVy9WvfH+u2dMnVOmpzyjZY3vfMnv5lX9/pJ4SbwkuTjgj3j1XvvuoQpKID SU2PIEVNgpT6UR8UGlNvEx9jthOaIMk0mPaSw62cD6igzl0ji4Oq6ubhuZNfqWfC+nBIf3x4CC+P joZIPWnCazCzgAP428DCl+fOSnzlnSZwAgws32UYzjAMQ8GUWkBExJfoStuwjWHGIKcvvbucUgtg gpPrpkPiR34LahEFsaAWUBA/qAWMgNg0LOexlCmXr8BzKYZh6KmpBQSEN/UYlwW1gIiUOPfM6ZmX 1AIYhmEGUlMLCAjPw/Inp7kCbwQbh9MmvKIWEQHRX+bUIgqDx5Q0mVILiMhn4HVkqdTUAgLCn53D qKkFBGZBLYAZnSW1AIZJAGFokcvaU5hWLHeU5zC+PyG6bw15bNY921GWQ/9gmFyg+qwLTYm/Icvp /x5Dx4ULyGOMHAobWqTJjFpAJGZQ5mdpivyiFhCQKbUApkz+CMDe2eO2DQRhdGKkEGAE7g0Xcp0i OYCBKJXbFDlALpA7CEgRIAdI7VukFZDGlQvnAmpdqTMQwCajJTnc5YiklGTJGS2/RyxEcsnliPoj l+I8SC0AsEtf0iWu+7gt7/c1dH5+uTPPyyyoEllQLaNgMYWXWnhpRSizKCUWWUN64erk+m47brlS bmElS/DwxJFbyPU55WU5zjISkQqzkEuUgomy+PE2oYUUW0iRBcsr/HS53FPQ/n6hxWyW0ePjr2L8 +89vdHH9dkcGET7WAok8K0UW1eAkFvWwHXdCCieiYDFFLayoCgstpOxiR2iRl2IMbreQWbghEFqw UKNITloN/pWZzns7aSC0sN++lSTtmlhK/j9kuxBaDN9GrLa014/Zlvb6sRjjeVgUTFiWQGhu37qA Qntf/2McfbKKXMgJ8pbh0G3XYgs68Y8vvPCiM4XziZhuK13yC5liWi6fi2kf7G4qama2PQt9Q7T5 ul3kC9Gr63L2j4cH+nx/T5/u7uh2s6HfWdY4w2XRQyiuqIUW1JRJhFKKJ1kqKUUoo3jmeUFdWMJt SCFGvd2gXkouGgILIbPIgml+CzRKT39CMVc5Uf5Q27aS6N5SHFZicViLx2ExJsZqXCEaMR7DfpGM JrNomWbBBQssumQWXeUljwdCC9lO4/Cgeq6Xp6f0+uzskLCvqFteISUWffVtRyl99fII6G92LQAA aJHSn1cluMkBgGFI9XvD3Vi30g4CRGVO6d6ssNQOYIKk9IdwxuINaFO4AcJ1bKwIyf+nxlo7gJGA 2AIAoIk7tkkl8YsD/Vrjgv2dDu674KCLiUfCSjsAAAZgoR1AJPDb0SSl6wZ4bdNnoR1ARPB+HYZU helLmkYfvCVS/YwutAP4T1I6bglx1zKX2kEANd5pBxCRtXYAR8JcO4CIQNQ2TVbaAQBggA/aAUTk Zk/9eoQYhkbrPCKFPop98j30VQBgh1T6TFLtk+tiTmn9R+KQ1++G0r1HROL6/CC0sMmc0uqTYyBI t8XUftMAiM4fAdg7e92ogSCOjy+JkjQnREEglRtoKXiBoyQPQH0N7xEegCJ0dGmp4A2gp4GCLkgn 0SOha9BJZ+Px7azHa0d2LuubvfX8otXa6/2YdZzbXed2/ofSBiiK0ps250tvugpdXX2E6fRReUxC FtUxd5SYG3GLurAFF6zAcxKzIGGL1aoSvKAymzoq0Qzyw8iFNPbRgdm20D2/e5/bBC0ql5ebeklU IbMhzzN27opbkKCFK2yB5ysWUxqJXrjluKAFiVnc7on15OQfLJc35fGH7+/h4bMn3YIWORO2IFGL fG3FLVCEAoUnMMYfEqYgsQoSsSBxCxSvKGNHyILq4EIZ1JYVssB+GoGNNke0KmjhCenbqIIW4dcv /YxsS0gO+4eqy3e9oQpa+CCk++OjLunyPgmpL/epa6yCFn0Zm6BFX0IXqghM0KKZbNZ8fNlu18HV erBt3ZDk/deJPC/Vh23adX5iFTcq4QkSobAF2TWKcTk3Yfna8vDlKIlg8Pxuu9BSzuTJzgGWr4vj C4DDXwDTTwB/fq/h3c1mzfjq7AwuivD4+LhWJfYz2XS+TCMzMtN/dMxNx7zrvIu1GB15F/kb6TzG 68bht12Nox2TibVn4rRR88ht2iD7gAlZ4LntE9TfGTT6zK5T7P5ad4UKWuyGUOwgQrMHCdEmImTb EBWz6I+U3QkbMxJ2TmOLFbkw45QrZLFGEYvi2oGJyzSWJ6NQ1JOZ+khUCduYHh3B+ekp/Pzb6Uv0 aRFeFOGbMRXFLWhIpHBgqudp7pDb0HeCpmQXD+5MxYWnt83g3BmSoijKLkilDRiQr9IGKEqEpBDX l945l9IGKN6ZSxswEG8hjo2e+wZ+ITy2jQfPpQ1oIcb73AaOpej8Hx3u6saPcbCQNmCH4LONG1xj 2FivbM+sCF+kjVB68xLieIcSy+Z6BDeHqvOO3bKQNkDxRmyfBYqihIuO1XVCfM+0LeoYIn5SaQM8 os+rf2YQ12cagXPLa2kjRojOF8IklTZgIPD/TfrMjZNU2gDP6PymHzNpAzyykDZgT3ggbYBndMxS xg7+TcfiiBk3d33uyBPD+J4KtInPyVygXZ+o+J6iKMrwpNIGeORHjzzXEM88qgscR2cQx1wqRi6l DRiIubQBSg19f6Io9+S/AOydPY7TQBSAnxGpghQhSgqGElEAFQVNRIVoWAkOsDS0XIEbIG7ALegg HACJI7hCrIQQUrpFcfCzZ+zn8TjJBo/fZOZ9q5F/xvE8O/735n0itRCEMBnKlpWRupdlebpvRkrd 642jcolaZAGNjMKIKVqpRSutoDKLWmJRdKQXWGd/vhITFNumzTaGY0UPp8vVlnlYaFFLK5CCjLeF Fhs93JVZtEKKv0RQcQlGcNH2XzqnrcdtSNe0Ncxs9gvW65/w7PljePXhNSxu3yJL1RVaGImFEVrQ PyO0oBIKKrQwsgojrugILUgdnb4jtNAyC+xHeQX2m7ZFaDEB3KuRu/0pEaHFtO2EkuTe57ymmO8x +IglBOlBSNsB9+fHnF9IyxL6cpyyYIL7e+IQWoTapo/pjv3MiHE0cguHqILeDzeCC2ue2S41wbY/ XSW0QLGFNb+qn6Zxpk8SXLeatNkhoQXsmMYl0aDCC5fcArlR3lk+APhdlms/AOZfANafAT5dXFTl 5mwGb5SCR4tFlYC7CVcn8C4s4YNJxJ1pkQQNky6GEU9gIvBMJ/LOyLwLI7vQMotmerOqdH1HmGGN szNud+LTwwV5RkAFFs2wY7UPYftFfCAyi+mQWHYTYkyGkGMziNDiMNhkFuCQFhEJUyN2IjILI6Zw ii2KAq6X3Q0KLkg9Ci6oFMM+R+Hw3fkc7pfn4APEFk/K8g3c8gpTMse4LekW0D2FZqQOAHqnWCq8 AOifNvetWkEQBA5iSvJlk3MHIAgRorgD8MRXiCOJq9AlxmTaeCMkCfB5kH8In4bU1vN7qH9wdA7p LXtqpPajsrdQ32uegWzbqRLzs4YYieUYFdN2l3MHkCCx7AdCXAn9ZLsUrspSdzHRFT0vPoR+4sP/ EUpiMpE/uuB2muvyHQ67/o/pnC3UxPad5twBCN5R3AGMiFwvjM85dwCeeMcdQKLIPhomMYpr5B1y 2sR0PX5I8kqhRnEHMCIr7gBOhJj2dUSuk4TUOeMOYERQaLHvufBqgjh8oxjaxP9/XTC0OyYpyfeW EMe2LvhBQXscoe/t7Hd6Zto7R7aDzwfMdZZ5b7eC9p3ePmK75kyFJXcAI5LvqMP95WNZXkwSCT8i tAgbBXHKVeR3deGBx4BUjnuC4IV/ArB39jpOA0EAnlgc0QkUqKLoKlf3ADS019HcAyDRXEeHkGjo uJYnuJaW7ngD01NQIaFrQklFQUXANt5djz3ebMB3t/Gs1/NFq/XvepJs4p/E84nUQhDGgSuL1vP/ rXRx8QEWi6UeplIJM4xiC5NZ0sgtumILKqxQ4yizQLHFZtMKL3Ad00YrzcC8nXaNiNzCuYRjvK/Q oiuzMEILI6FAcUUrq9jo2kzbdKa1y1L5BbaTk/Yxnm2SZFb1kS9V/8jhxeun8PjVKdy9NyfPqpVD UFmELbTQKgsUWpR/jIiieqhhlFVsCS3KX43UAgUXKLLQGoxahqHawDrHR5lvCTV0f7aEFiKz8Aj3 S8mxfa7nLEKLYbfDnTx9iLb20W5o4gdfbYb6vGKB87UJ5fMZktAiRMEEd+whyyU4tsnxHG7T/jUl GfRcwSWq0OeEJZFbQCuocK7zj+3TZRtxQl3rVWeN6QJX2JExG7pyir5CC7CGbbtCT8FFcQTw8xlo feedrwD33wP8+P4b3l5d6fmnqxU8WS5hNZ/rhN4FdEMBFEoQoYWiEVEAbK1T1PM7NUkcbs8v6/ll PZ+KLgpLkJFY2+hk6K63AfUwxg6kfSrrwLqJ3zEfcb2tPhChxTCEEgcSWjyKEGNCQo4NEaFFP0KJ eUb2ETMyjvuSBGsiuNBCiyQxGuJqem6LLsh4gQWMFAP3dbifWRwcwNHhYR+pxXFVHlXlUx2qklvg LhCLS3jh2tXahcor7GIftdjQ6a6jKRFdCIIwNCl3AHtkzR2AIETICXcAe+KcOwDBO2cw/hv6XEzp Jr/QkD+ED0NWlTfcQQyM6leqf52B3AgSM2vuABhQSXLXYPr2JWskAgdyk/N4UBfaYzm+TLkD8EjG HcBEUZ+HGM8jp0bKHYBHJDmBQEnrgolusFbTbprY5qbQJMD2tRJMlpOR2j7WkO/a+Ei5A/DIR+4A hEG4jdgnNNbcAURGCnEmIfoGJtmXMDyxXHOJiVivW8pvyNMmpn4t10L6k3IH4BF536dJxh2AIDDz kjsAj7zruZySV41ZMDf0MZe6/j/2fiLyPWFKnED39zv8zhj6WvQDsk2s6f9x1XfxZ+j+lkd5CMIY SbkD8Miu80PVNzMY97HEdRChRfiM/ThtF+fcAQiCIPjmrwDsnb1u1EAQgCcngk46KWlRmjiiRArU FAjegYLyJGregYKHoOUJEBI1nERPwRMcokmJhJSGYONZe+zxsudYyOvZn/mklX/OXo+T9d/eeT6V WihKeBzKmnXEPntel2e3VXR2dvHPvF5mAa3IAjoZBYkpeqlFL63gMotGYlEOpBf4mb2+kROUVbfN MVRuYea4lurmjwst/ljjjYCCRBRuUcVvNm0Pb6z1bmAoyRgXWhwfr+D6+psZf/P2Fdx/8Rju3O0v OYeEFmW9jzhEuUQntai3Z1QWJLSoY8QhCSq4uMIep2kSX7iEFiTM4PIMI7KASoUWSyD9p8xJaOGb 0EUJS28nlCT3PuvyUW+o4ocQjtvQ2qj0+nPWJSmS8FWX5LZDFEzEILSYuy6JfQ5FaCEZh2NZp6iC PBP8OfnAo/BRNe0Z2dRfMTmG9ZjZyS14nLZkwiW8oOVsI4QttHDNs1NMHxJr8O2t6yfQS4CfdVn9 ANh8Afj1CeDj1ZUp99ZreHl+DpcnJyYhN63eVWkLH9hz96pNDO7a1U5GYckpzLK4HiYId8gs7OFA mNHKK/j2+DKdhIRNlyxe2h8SXzQSFIuRvhTbL/K/pCy0CCEGIqRYkNDiQUKMiQg5NkRlFtMIJWan e4pJl6C9HnCZBYkpjNCiLDtxBRddoOSCz0PBBZdi2NcknL7YbODB6ekUscWTunwFt7xirFRsSHcb AxcUDO8Y7M+BDW+7a1OJhaIo0iyd7GhJdtIBKEqCFNIBeACTVO2kg1BmZysdgAf0JT8lB3J9AQfv yT/X5R00L7po4qH0yLVt44uy7+vyAZq2vReNRlmSQjoAZTIpnZ9SSt62lw4gU/B4SCnBca4U0gHM SErnaGU6j9pSQJ8AJ6bkHJQsh59PMZH2DtLqg/0uHUBg6H2YEhMptVdE7xfmZSsdgCdeSwegKAGR 2nWA0O+Q8yaldr2XDiAiUurH3EsHEAkpHevar6LkTgFx9fmOQX2/U8A+jJj3e+lE7/gbm9gF0fob OCU1Cui/v6NxvEeL6Vh92BYu9qX3KLA8XTwiP+TWb57Ss4Lrf5eb0ALlM1vIrx3HBLbJrXQQHtD3 6hRFSZK/ArB39rhRA2EYfrdYRaHYLkgBIbmgpeMAlhAtPy0NESfgBJCGntxg20gp4AZLywlI55KC jhRoUWw8Y3+e8ayzdsLYnz3+Hsmxveufd3atnZ11Zh6RWgjC+GkaTetd205nZ+dYre7rZVsqUSyT 2KIYzrGQW9TFFrawQq2TzILEFtutEV7QPsUxjDSDxud05/uYr9wiaygzSSPMe2XG9zLLRmhhCyeu G8QUf1EXWzTNaXtXbGELLVLsE1ocHABXV4XQ4vPXD3j4/IkpqyOF2Ce0IMGEElioZRJRKEGFElOQ qEKLK7CtJBa0bj9H25MQg+YkzNDnzM9/k9AitcorQguPcL+UcxNa9Hlu7vfyfxmbLKAvRGjBd8wx CSB8HI97f5/HCkVoMUQ5piqYmIrQYqxyCRFaeDu33Y5YNDTz7bZwJcLIrOU2NUHNj7Go5BZ0PL1O vwuQ9KJNbkHH1YYG67mbhBbuMbKGbeFs45bBKkf6CPj9Jl94ASx/APcugJ+//uDT5aV+/vXxMZ4d HWnRhXvaRfGi6pbswpJLAEZAAey6OqiotXkpm6g9Xg4AXs2xK7hIHUGGK76gxwAjwKCBxFX2rBxs vCobXSP6T13o0UVuUe3bkZBlFoqx5FBIlv2MMRMx5myECC26MdbMVZ0A1OoIXYeUdYwWW+Tz1BFa kMji2pZblDILWk9pQiHFoOqeBBer5RIPDg+7SC0e59PTfPpeRtWR0C61cKverGGy5RXutFP9O9iP N31bE9GFIAhDEXMH6JHWSkIQhDsR0j+9E2vuAIJ3IoTVgZ/4Aunkx0nCHWAmqGtcdciZS+cjF9VZ 8BWKTr1r3ihCD6gOPyHWT114iaL9qQbWOmVNIgzFXK/1KbLhDuCRkK476ZgsCHcnpM+ChDuA0Dsx jMRCTaG2hZXI8S3qA+RMnYQ7wMiIuQN4RL6HhU/EHcAj37gDBMgJd4AeUAOMrrlDzJgNdwBhh4g7 QA8oYbrcQ543EXcAj2y4A0yEiDuAZ6Qd1o2hB1Pvk4Q7gCAw8547gEfWt9g26SnDUAx5/0l95k/9 OpHfI4SpE8Hcv4sxPXnFbSBZ/UfuIB6Z2+8kId1jdtuHcxRaxJjfNTw1ThBmnXDKHUBoZIOw6mhB GJx/ArB3xspNA0EA3chNwniSio4JYqhoaKCiSkPPH8CnuKaiooU/4BNQJi0NFa2GgtRMqBgsoZVv pdXZsqWJ5D2t9mludJZPdyvb0UmO755JLQwjLNpmz+JTSuKgyteHKorjZ1vbapkFOJEFVDIKElPU UotaWsFlFhuJRdaQXuBz/v7YDtbLhRp9mJfcwk0sWh1zvW230CJz2ym/EU3UQot/Lu8LKri44i80 hRa17KIpwuCSDMq3v5+np2u4u/tR5j/evIeHL56wo9wWWpAsAoUStJQqCye0KKUWRSwktMA1yirK xMQV5YICC3zM8pXQosjzOqjeqpV8DRlfcheXE1z4x2AMgPRLaUILq3usNkKvb2hMaDF+HaF9pqT3 H7IuE1rMTzBx7PY0yCVCbfM+9Uv3F3l9X7FPbrGPrf1adqFyvuCCyucnbMddMgtugfDbaBNaAHSb HtoXYOw7nmVxp/oS4HeRop8AD24A/nwF+HJ7W6ZHZ2fw9vISnp+flxN0+4dDE3OXzbrJwCkfuYnC G+Vd2YUrQ/uX253EgksqDq0bwgwmyKBtDdGFk1uQ5IL0itVzVJYJMBpCD/9YW17aQ9+0mNDiOIQS BxFaPEiIMREhx0aY0KIbIcbsd6UkNDpxfQi48z/2Y4sogjzLKjHFoiWR5IJvWzuBUuT6HupHqj6m ePx0uYRfFxddxBavivQNNl1oGV7HlLM1dY088SuRfMfzwNZdr0AMwzCOjaaBbj422NEwxkHbD8Jt 4JROpj6gr42VdAAzJ5UOYEbgdZy2/qYPONDlE2zOZZgS0WiMIUlA1yTLfcHPNg6seedSIhiLMS6x dABGL1LpAAYilg5gYOx7LRnwdZ9zX60BbTJWOxfoIoZ64htMc77vNfQRSwcwIHbu1Y+m64VUOgBl 4Lj4x9JBjMBKOgDDCIwr6QBG4IN0AIY4mu4vU+kAJoKma9rv0gFMCE3veyIdgGEI80Y6gAH53KNs AtOfjBXHXRxjkmn8vdjUJ0peSQdgGD25gub/8ab+N2jMB033CUjK8ia0MEJF41ila7B7dcMwlPJf APbOYLdpIAjDI1SqRkIV6oEqHFBOfQBegFy5IHHmAGeeohdegEvVWzlya5+g8AYcqcTBBx4AqUig KNh4djP2eL1102rtWa/ni6x1nHjzN3G9dhTPp1ILRYkbX0Wt97etdHJyAfv7T8w8l0rYeRJb2LKH Vm7RFFtwYQXeJ5kFiS1Wq1p4QevYPmppBtXhdNu7kr7cwn1jCuByCztPZSzzaqqFFlZq0ZRPkJCC 2lpcAbBibVt20VxvDU2hRe7JW7O39xeur3+Y+dNvH+HgaM7/qlZrhBFFUYkjfEILFFKsyxu2rtDC yCxQXuGZ59IL3seabiS0YDILvG9yFDYP3dy/QQnAFN9KFVrE1XdfrxFzf9IFvIfoJzQqtIhv/ZB9 qdBiGoKJobPfp9+Y5RJS+2dpgciAffJzDJ+oopJfkIwCakGFd50OqucWdX+mL/q+gAQXPuvBTcIL X1normVdIgwqYe324fSVPwP4/aaceQXw8DvA7DPAz19/4MPVlXn89XwOLw8P4WB3txXT+iMLc5ZL 8gju7aCXJ/kEbAp755vHaXnhW47tpiB41YJfcAE3LKe32BQZZ2ILKmROn9UDLu5gEgtwhB7Q8X1K q1A6v5+w0CKGDERMWZDY8iAxZiJizoaozGI7xpKZhExcgERjFAktuJjCJ7L4x5dtZBZ0P6cJrBSD DBI03j3a2YGns9k2UoujcnoOVmxh4kE9THZN7pBaeCZ+lOBOreHegS/3Hbmp6EJRlCFI7QesnEw6 gKIkSIr7jDPpAEovvJMO0AOfQMc2ZTqcl9Nb6RARgBdiXZbTBdgLYDLRNEoIcNse+wX6IcDigLht 40VQx6AXQqVIiucNKZNJBwjEQjpAQLSIlxx6Yfj4WUgHCIjuC8YPFtlYgi1Qhm2KRbKnjI4ZTVLa vlVqkT4pnbNm0gESI6WiogT+qO5cOoSiRMZCOkBg8NxRj1+mzVI6QEBw3MqkQ4yElI5pdR+2PY+l AwREP3dlyqQkVMTffGR3eH4K//s4Bn/p+TVwfz/2Qsm4bZxJh1CUWyCBBe6XX8hGUXogkw4wIAvp AAH5yuZVaKHEyhLSOZ7nHEsHUBRF6Yv/ArB39spNA0Ec30RVCIw7KpIxBVUamKFmAh0VFFBAQx4l HW0eQW/A8AR4hp5nEJUrqtAEJhZa+/ZudT5hw0jau9P+Mjf6sD7+sp2cpNj7U6mFosRDVxUtXjry TdOe79rQycmjrXlOZgFGZAFWRkFiCie1cNIKLrOgcS69wGl//bWoYFXbffZBnnKLbaEFr+i5Wm2G m0MmuQUXWtya6bbMwgkpfjNBxS87JIGFm9dedjPvlg1pX2EwX1Es4fr6B7x99wJefnwP9+47Gaov tCCJBQkt+A8JLbiEoktogeM3cOOEFuwxvnxLaGFkFjiO8gocp32r0GIkYngqx86Qq9BiSFRoEVfR /CGJVYwRg9Cib6SFFDG9p2N5bVI4jhgFExJCixTEF1JCixhEGkO8PgKSjJaowpdf8Otq/5K4ptl7 XCvXbjkrx/BKPAflFiGZxYG3TEhyceCt0yXC6CpB7W+DL3+3uYp92rTHAIdLgDtfAX5+Afi0XK7b g6Mj+HB6Ck9ms5Yfw0ZnMggqDk7jWE0bC4DXTCphZRQ4bZax80lAAduyiq2hWZ+ykCgDRRiF2UbN 9hmq3E3aSypsbo/DrEfbt0+3f6yBpx/AyTL6Jpb7OLHkQDTL34kxExFzNkKFFvuRQuZQtwqmb1r3 Gab/OjT9UsHEFEVHI8kFn4eCCy7FoH7D9inN9MPjYzhr+tQ9xBbPmvYNNkILjL9LaEGtZkNSXfFG jwGEu0hgw11naCqxUBRFgrl0gAGppAMoSobMpQMMQCkdQOkd/ILRbOdS6VFKB1CUEVlIB4iMV6ah 3OYS9Dw3ZfAL+ngTK8d+6n/ALwSj3ELf2/mRUzGlKbCQDtAT59IBeqSSDqAoCZNTH5RDcacpgu/B 16ZNpcDGVNHfUce5dIAewWt2LRaTPzmdLyykA2QEFsjKUbRcgv5dUxSf3AqOXUkHUMSZSwfoEb3O 2p+czmkr6QAJkVOx5Uo6gKIIkpNQsfzH5fH69DukfU4+H2EfKLRI/XNFl9IBFCUA3v8jEX2unzNX HJV0gBHJ8foQj6mE6fy//XPTLkDv5afChXSAAUChzEI6hKIoylD8EYC9M9ZxGgjC8BxK4KRIV1Ac zSG54BGoqFIhUUFBgWi4go7mJBpKGp7hHoLmeIPUdBQU6VLwCAhOET7j2fXE67V9RGGdWW/+z1rZ WWXXE58v9jr2fJBaABAvXZm13v6r0eXlF5rN7ptlVyphl0VsYdMbWrlFU2zhCiv4tSuzaC7XMgvb Ry3NkHyb/jwE6cgtbhda2I95Y+pMIrGjgmqhRVNmYYUWVkJhRRQireDXazO3detGXf1eV34h/eRO /5Iysw3/HfJ8Sev1mt69f0lPPrygu7N7zqeq5RCuLMIXWhiVhQgtij9WRFFOvCyyCl9ocV1ctwQX IrIwGoxKhsF9yDyXqchbQg2z/3pCC8gsEgRCi/j7jyVJuyYxJf8fsl8ILYbvI1Rf2u1D9qXdPhT7 +BwxCiZilkBorj92AYX2tt5HHAH7dAUWXaIKd0y8WRZBRU+bvhiOqonbWhFC0Ria9goufLkFeXX+ ELJLaNEnwNhWkCHrnJSre0j083VZ/Yxo+r0sn4l+/PpNn5ZL87ZXZ2f09PSUTiaTTscGD8B55HtH ZBAdUokbr42RUVAtpZA2jXqeVwnCN3Nqiy5Mn9KHI8jYrL9KNE7VukReQc4+IEIK08aRWJB/7aTn moqIMNzNHYJYrt0gjm5ii4eJMSYh5tiEfcc4hm3SxRjjFoGFMT9UxxOqvu9dIYXMu0QWuVtXySzk 9Y0UslIMMUjI8e1kOqUHx8fbSC0eleVxWb6SPZyw3EIOf7cV/xBadBRXXuGX1uHdwz+DaG3innoA AAhFph3AgOBBVwDCk9JN7wzffLvSDgIE51w7gAHghzkX2kEAsEf4wRx+SOe5diCR8aYqLADgB5jx ANM4uaI0E+T9D+6+/ZFwfpYCqY0bUuabdgABSWm/wzUtAHYnpe+ClXYAYGtEYjGncSfjAmBXMu0A AoLzsMMgpe9q7LPhSCmpqAuS3QPQZK4dwABcaQcA1Mm0AwgIzm22J9MOICAL7QBGQqYdQGDw/w4O lZSEivwA1y7noisa97WZbOD+eR+5GHgdQ4OkyCAmMqp/x0tJEAaAy1w7gIDwOIHv+VjQ4Yhn+J7Z c+0gwNakdD7vgt+SwL5YaAcADpO/ArB3PrtNA0EcniSUQ6tW4gEi+QJHOBYkDpF4AYS4cckj8Ajc eAkOOfIW5MCxJ57ASBUSZ6SqKsLGs/bY48VO3LDO7K7nk1aJE3vzs5t0N388n0otFMUP+ipp8RKR b4r2al9Hy+Xjf25rZBZQiSygllGQmKKRWjTSii6ZBZde4LK9vZEVZHn9mGMRrtyi65hkretcaFG2 UmaBbTbLoC20aEQU3aKK32z5ruN+Wv5TLVNfjTyjj5OTOdzcfDPXP356D8nbS3jwsBlW+oQWGe4L 5EYuUUstin0wKgsSWhSZ8LIltKjEFVxigddpmdbrElqQMIPLM4zIAnIVWhwT6UOqQgv/+5d+jhyK TwX7x+rLdb++Ci1c4NPxcdGX9PYu8Wlf/qevqQothjI1ocVQfBdVhCi0OEKfu0QVecZW7nlbXG+3 JwOtR4ILW2ZRL9NtfTILbn/YJamw7RBDy0jb5ait0tT5I4C7l0V7DjD/AXD2BeDXV4DP19emJaen 8G65hKcXF6aAN++GCoTPqoLhfBdJQFEei0YqQZHneSkF4ZIKYHIKW2JhXy74LnUIMvhj8WyUiXtE SIJRZ2cCDL49PYZZt+NzFf6nOgRfPqvxJQfiUxbEtzyIj5kQX3NxJDKGcFxsgswM7SGSBExGgmRW mNWiC1xeMDHFwmoksiDJBb8vq+4jKUY9TkAzNj05P4eft7dDxBYvinYF5RBn4g1sObvkMwo+9HUN ifawDbB/ZqESC0VRjk0iHWBEtMivorgnpsKAyEY6gOIc/KF4jEXwP0gHUBQB8MTnGF/PLsATYvBE SzyJZANa7DY0NhDnSU0uULlFPCTSAZTBpNIBHJJIB3DIVjrAhIn188RY96uLRDqAQ7bSAZSdvGZt KgU1lDapdACPiOl7Ay2qGT8r6QAOwR9JTWmeNzZr6QAjgOLoVDqEYsCCnlo40Q9imrcg+DrXsUBZ SQdwSCodICCeSQdwSCodIBBiGsNiEq4ryn2JSaiIv+s6ZC66hbDfH61G7h+FFqF/5xC6lEMJnwTK /7driGverAxnavPNRDqAY7YQ/lg4FBVahMdaOsAIfAcVJyuKEjl/BWDv7HGjBqIA/GxFEatQIEoK 2AKJmjpNboFEgVLQcAckaGhooEubG6y4QfqcIBXucgBEEkVem3keP3tmbO96F8/Oj99njcZ/M37e tdd/6/nS7bMwDOOAvha2Pm0rdHHxC05Onlf9qlRC9pPYQrY4KeUWuthCFVbgsCqz0PtbmYWso5Vm kMfCzG3RrlMImHFS+1xtv1yXopNIYoHiCZJRtCILU1xBw4/18KMynnK1XN7krSRjs9Di+DhphBY/ V5/h9fvTRmjRJ4cYElpUMotaPEE5CilQUFEJK2pxxUP5AFVXynRf3lc5SS2wGxJbNMIM0W0SWtA4 ipmZGNcfqevlHxIWWhx2Ob40cm+zrkPUuw82YvFBeuDTduC6/JT1+bQuvq9HyIIJ19+TC6GFr8u0 Md++ZQIVWuiT9GusjvxCuS7uXIvtcr1cSrFFKroqT9JakNB2WrPRALqdoVSGU2W82Ry1amRIB6b1 5X0JoBuTuDQtXgL8+SBGfxeDHwEWTwCyuzv4dnMD766vYXV7C3/X66ZYUcssNL1k/blWykeRmykf GM6NMrmZF0UzDeer5jfrqcvn9fzmstZK/YUSK8VN69PcYaDpynhqCH3TfZVSSWPxpdF4n+LwJRbE t3gQH2MifI1LhYUW4wgxZpVKnpSm+qEvSZp+klqouSa0EGX7JBfUnxr9SZ2ToAnT06MjeLFYjAn3 jUhvQfc3jZFamEf/vunm0X9IajH2rEH7mMesHMMwzJ68ch2ARbjhGYaZnphekEX4z7fxEdOLnyq8 rTJzBLf7rfbKGYMvbX0R6TdIScLSZTDMTlyBfAmIGQbFFrxthw2/FB4OMd07iWm7y1wHMGNi2idU Yl2vPvi3gLEJ3htFuWAm0grkeetcGtRgumSuA/CImJ4bzOmYOVeWrgOYEN5ep2MJYTeoOcSl6wAY xkOWrgOYGH6GzCB8Pj4/zlwHMCH4f4DMdRCBwPs6w8RBTI39X+5ZLvTfgGeW6z+3XL9tsHHu0L/j /+HMdQAzBvfNc5DXyfifsx8Q13NjZjfmJgCN6Z1A3Hf5+TvjMzGdzxNfXQfAMAxjm38CsHfGulED QRgeqCJFiPRRJFNQ0VMhcV1KKurwBnR0SNQUlLSkyQPwBkipIyRQ+kN5g0hRJNDd4bE96/GebczF zuyu/89ane98tx47Pu/e2pkPUgsA7OlLoiTLXtOAgZWjo6cNsQRTyyyoElmQk1GImKKWWtTSijaZ hZZe8HP/80Wyx/XGrfM+CV9u0Sa02DTmRTjSFFqslGSinC/FFn/yfS1Cii6xhRZa/C6Wl6V+Xgsu VjRUaLG3t6abm5/F/Ofzj3R4XI8x+VIILYtgoUQhsqgmlli4KZ9nIYUILVhM4YQVGyW2EJEFqedU v6cQWnAd+aPUW8gseFJCCxFqlAlKy8nfBjAi1rvUYv3W2zwVsYsSQkqwH0tdU9QbmvhhrDpD3a5U sNw3oXw/QxJahCiYsI49ZLmExTottuEu9QcstNh660bJLdqWOXGBevSlGANiEIkFCy6c3OJBi9xC j2jolNNEzZTUuwot9Dr65BZ+Ef/HQf5L9znR7af84++JHr0oXz+7uqKTiwt6d3lJP66vG/tvXYki nORCJBGefMLN07b0ok1EIa+JtELmdVmJ8EJ/nrYFGV1l7RX3GqmRBidAUdtITfFF1yHyr0M1lKTx iKOd0OJhQoxJCDk2xkIGErKApI8YY9Y89OIXoYVrZpWAwpdZdIks2iQXTmpR1dloWqsYnuzv07PH g+5ZelmFN1Ro0Sex8PVYfcvbeihdxH1gAABiIrMOYGLmdjMyAPdBSje9fyWcJ1IkRakF/6MfjlUw R/i4RzKeYUAAEB+n1gFEgj62U0rUkjoL6wDAf5FKQonUzhFL6wAAiJSFdQAjgoR+4SBJcLjN/J6X t5TWGCnYHYzX1aTUF1taBwAmJ7MOYERS+T0XAileW+L+JMbXAdgmpX4Lg+854N+sKSV7/GYdQCRk 1gGMCPq0w0mpDVtaBwCAERmlk2D9F+3ebsd+7p/yb/iG4r/+8ME6ADA7uI90SmX/4kteXlkGA4Jh TtfwFtYBgDvB98dm1kGAwXCbE3tfzQfXkuIgsw5gRObURoOA+CsAe2eQ2jYQheFHSSAh0EWhm0Jh Cr1BewDfoftiKHTdI7jL7tpNsyrkBiU3cLc5QMim0K5yAGPiRSJVM6OneaPK8YTM+M1I7xNCI0sa /ZYVy3bs94nUQhDyY6iY0sddG52ensPJyTPT9uUSVGxhSxBauYUvtqDCCj1PZRZ+28ksbB9OmoF1 D/vTfZKn3CJEaEFLZtrRCiycZMKXT1iRRVVZaYUVVNCpE1r4Mgts35J+sI372n78jo42sFpdmvaP y+/w/M0rcq+2CC1qK7TAeSqY0IOWUJihFVp0IotWXHFT38AGNp3EwswTuUUns2j70IMWWeg2ii2o UMMoLOrKE27074MQEe5DOjWhRcp95y5K2Pd+cilyn7KvFP3mKn7gfq7S5HaOcm8fsy9OkUSqvjj3 naNgogShRey+OO5zLkILzhzMQgu67i5RRV2598Z0vZ1yiwFQbmGmKLggQ7sS3WC73OKhQov++iEl rGv4v5z1QfOu+iXA6n3T/tLMfgA4PAT4vV7D56sreHdxAT+vr2F9d2ePE4oswEkfqPjBKCgHpBKd nKInobjFbdr+uttbiUU3pev3+yH7HJJm0OUVyYq5jcxCFyVvRm95u443Bsgt6NJcCt3nkkOTSw5N TscFyTETknM2hCNf7sdkiBIey/sYyo8yC9MG97iYSyQRUuDUE1oMiCwOSJtKMZ60+8bb8LL6tLl4 vjg+Don/uhnfgrtyh8ot+q8ItokuAIZfBUDg8vtE44IgCLFR3AES8pc7gCCMkBl3gMgsuQMI0dEF G8b4gyT5orgwZRbcAQqDCgBmrEmEXXzlDlAY+tzWBYSXIOd2CSjuAMKDKL1oCKK4A0TkF3cAQSgY xR0gImN5fi4ZBX4RnLEUGxPiIX+nFimiK5TGjDtAROR5KB5z7gAJOOMOIHgo7gBCx5gKgp+DFIAS xnVOy3f9wlHcASIir2nDUdwBIrLkDiAITHziDhCRs0ds+wds8dySUYn6XSTqd198AxEXCftjDk5I r79XNqb/UwiPZ0rvM8b0ucBUWXAHEIKZcwdIgP6dknzGnD+KO0BEpnSNFjLinwDsnUFu00AUhp8b lo0qNuwiLCGExJYFC5DoCVBZsEMiR+AIvQFXCBKHYEcPwAIW7C0qISFWVbepjZ9nnj2eOo1Lxn32 5P8qy47tTP44ke1x4/fd0w4AwJ5zU/EkWfaWevyga7F43CmRkEKERmRBtYxCxBSN1KKRVnTJLFzp BT/2n98WaehXhpYM+oXLbhJa5PYza5XItPMbuQWXvTTCibWdbgspjMjCjJNk7Ugu1lZk0Ugwrkss ZCzlNbvhzTib/aHLy7/0+s1LOvm4pPmD5nqTL7QQWYQp9tn+E6GFK54QGQXLKarByi14WsQV8liW uetfk1jY9lleUYssbCYRWvjFXCG0GADtTQqhxTTavgvGJgsYCggt9NockwAiRHvazw/ZVixCi7t4 H1MVTExFaDFWuQSEFuFf+zYEen3py9Rlrl35hds/39A9Top+/WZpn8dFYvtT7mslLetG+8qG2xU+ cKb95Ym3LHfW95f589zX7ULWu1/2hJ+X42dl07+I5l+ILr4TfT4/r4an8zm9WyzoyeGhIwZpColX 01YEIRElkjg4Cl63XMePyfNyu0yKhG9yetRjbqdct7BSigObpbDt58668hbdzV97QVhmIddKnPdD Nlc1ba+h1JllPnVfXyk2zNcAOboZWx5mjJmEMWcTILToxxQzu1yTWZAnEzIrmeOJneblIrSYicDI k1iIyOLKSi5YhOQuy+1wZY9TchyQ4wY/flQeH38fHdHPi62/cX5RDt/ICC2qeD2Hwhnn1BzS3ENb 1yGvS2yx7WzL37QAADAEqXaAAcm0AwAQIal2gMBAFBAfJ9oBBoALN+C7CvaZjExh51fKOabGezvw tmN5AvYj44NvAvpE5nMC/eF9wddy+EHmu71STQM2kWoHALci0w4QiJhu0saNewD8P6l2gIBgX6DH MZnCEeiHAtCPmM7DUER3P4jpO5tpB4iElOKUV620A4AWD7UDgIqU4ipyeaYdAIwCnNvsJ8faAQKS aQeYEDGds2baAQBQYqkdICCrHZ/P/wOZ8jX4lMLvy5Y07b4j38R3qh0CRA9Ltj/YIab+PQC7kGoH ADvD97/w/g1igfGz1A4wAHxt8Uw7BNhKqh0AgKnzTwD2zl/HaSCIw5MjAp2CEEJXUZxCwQPwBOeS h6C4goaCjooC5S2uPCSegDcINRVCikTnV0BXnUQuZLwee7xxLrlkndmsf19krf/ujp0oazvOfJBa ABAXbdm23m/a6OrqO41GLyqhhOSslPF6vsgtmmILLazgaS2zaI7XMgvZXrfh2myW1tjKLfYVWszJ SSx43BdRiKSiFlrw9N2dK7XAQpbV01qQMS/bkTScq5ycDOj29ncx/unLO3rz8S09Hj1Re1XLIbQs whdaFCoLEVos/jkRxfLF4yKr0NKKSmThCS5EZFFoMEoZBtch5Vxei/mKUKP4vHpCC8gsOsL6sEJo gbq7aiP2+kIDoUX3dcT2mbLePmRdEFr0TzBx6PZSkEvE2uY+9Vv3F4bt62ubQcvtBX19XIkwFmp8 rQ1iFV5Xtq3qaxNc+PIKmSdpp/0M3bsILaTcJLTw01sPl028Ivr7gYqfIYd/lqt8I5rd3NDn2axY 5fL8nC7OzujZcFheT8rxU9WJvEIl/9a7WOyGlxhc75bsZlWWicSr0lu+8OoVwQYpUUbVvrRb3hMZ qFhlXJYt1HK3sncwW+6v6G2reWvegq6IKXF9TLEwscXDxBiTEHNsDGQW23GMMfts2odiuZIryXTR v7DUouwPpGwILVpEFiK5eFSWso1IMaTvkX7s6bJPfHl6uo3U4jUVCin6WYbKcgvpzu4b2ro+f/BF FnrwzxJ82s4KGod4zXwAANiVsXUAAICjIqU/w3Nyqtw6CBCcFKUWSEQPuuaXdQBbMCGXxB48nIty 4H5vQu47BX98iocJQWqxK5y05ZrcMfxKTnCBz3Y8ZNYBgK35YR1AQDLrAAKSWwfQc55bB9ABfUrQ nVkHEJDcOoAeckkuCU5KCQJBd6R0HrUvmXUAAYFQKH34XC+lZGdT6wASIbMOoAP4GgDfaQCsMrYO IDD4HRkwKT3HM7UO4IhI6X3HOct2ZNYBBIT/5JFbBwGAAfxcYyr3JPjeaL5nHccutegi+e8kcH2H Zt/ndqaB4gBpMiY8ZwcextQ6gAOS0vVhX+FzRH5OYWIcB7iflM7nNXg+Bhya3DoA0E/+C8DeGePG CURh+C2xO8vJBawgRanizkWaFFHaFC5ygc0NojQpI1dpfQAX65vsCVy7iYJ8B0vWysuGgXnMgMEL 61neMPwfGgEDDM+YHZhdmC+SDgCACdPWO9XMWvYtS1+2FXRy8r5RIsEyC1tiYcssjNTCSCuaZBa2 9ELNG7EFlWILVS7vz0dY6jHQ3qif0CKldqGFGrO4whZZrCxZxUrPr8p8Nc2pKr8oxBZGbvG80OLw MCqFFn+uftDZz6+dhBbpxhJZWJKJXGShRRQsp8jlFWQkFg+bhzxxPs+XeVp0wQIMVZ4a14UWPEBo IcAUDyuEFn6Vva99+FyedAfeQ5TjGggt/NveZVkQWkxDMDF07LuU67NcQqp+lhaI+FBm33X7ULok TLvnySq6fbxJq22kenupy35meojUMIvyjrXzpIfKNxxExugQUbX76ahhuj5uy+Py25a1JZs3WSv5 Y9Z6vsw2/0V0fFpkL+7u6PvNDV3c3tLf+/vK8UtzkaNp1Zd5Oq2t5Ws9v7anOaVp1p7d0COPOyS1 TWXbWtmP1v7Thn02xmqtnyc+T+y/UedvOzWGql586rzet1h8ikfhY0yMz7ExEFp0Y4wx22w7F+tL WGhRXlq1kCKyxBRt6cCSXLStw2VWLp86vndHR/ThdafnQz7p8F6RuQOwp7ukpqt4n6v+NsZ94gAA xkCInbQxeOERAPeE9ND7UjoA4Bx1TTuXDmIPLKQDAMEzhk7gl4TOIl/KWyoEAAkVLz7FgrEAQ5Kl a+kgRo46t39TcSwXhHPbF0JqN4ROIh2AQ2LpAByC77RkCbEOS6QDGJCQ/n+oC4ZjTsXnRLWZ8MI+ AP2JpQNwCOre8AnpXmFK4rJ9A2E6ALuxlA5gBz5LB+AQdR1IpIMAXhBLB+AQ3I93A6K2aRJLB+AQ fNbBVJlLB+CQhYMyxl4XuH7/Yk7F8y9jRQmLLqWDAEESU1Hn/CMILQBoI6TfPaaMklqE/H5nCIT4 WxIAEiTSAYBp8l8A9s6Yt00oCMCXlFqK0ilzB1S1v6Bjh/o/dKsyZOxSqVPndOucJWv/QhUps+eM kbJnzOwhkSpkhwMO7mEcU/nB3Xvch9B7PDA+A+IZG+4zqYVh6KEredK3XS+6vPwLx8cnRb1MrAhO 3R03pRZcWIHTXGbh1rnMYl3LLGjd5Xu6pUaGl1t0ySwo9WNZL9+fp4qkdpJMZFAKLUg+kTGBBS+5 yOJfq50EGDSP1tFfaDGbHcDj421Rv7j+Be+/foJkllSfalMOwYUWWJJQopBZ5PGgyIJKElEUUgtg MgtoBBZP6ydHZIEDiSywpPXgQMIMHEhoUYgsMB4mtKA2itkYAA2bdewYYhVaDIkJLXQlzR8SrWIM DUIL30gLKTQd01r2TQifQ6NgQkJoEYL4QkpooUGkISlu0iC02HPZraIK57cD97quXe8bE8ktipIE FzisdwguDlrTXfP7Si76prjm78Gn80ve1TuA5fe8/hvg9WnZfLtcws+7O/hycwNXDw+wzLJ6+60q 8YNz5U9tTBjhiCXyeRmbXrWWydplJbGoSzZ/43UAtdCCL9s1cnkF1Sn2+pcLkltU7fmOree/9BvL mo1DoCV5vTYhgqZYCI0xEZpjI0xo0Y8QY+b8b/wksyjq7PVFF8iEFFQ6QosOkUXCZRZMinFYneOo jbrNN0kCb4+O+oT6IR8/QtMzv4Kmp94lsjh8Ydk+IgtnE22Zv23Dh31AGYahjZhvYA0hQbNhhEZM 54yFdACGd+bSAQwAJiMJ/QFOw/DFD+kAIgETnKAAAB/0/ANxnjtD4xzKh7uN/cBjGx9exmMbk/bN RaOZNrElU4qdmL5rhpzko01M+8UwxiS2PmghHcAEOINGZhFTP2KMg/XXDal0AB6x/Ro/Mf3PdS8d QCSYMN0wpkUqHYBHFtIBGGr4LB2AR+6lAwiEmL7TmqitP6l0AB6xa29jisR07Yn3t/gQKYZ+Lph7 Xt+55/WNDd7XZ89tGD5JwWQWxn4spAMYiRTiukdiyuB+tPvkdWNSC8PYH3tewhDjWQD2zh43bhgI o2OkcWEkcZnCgFOkSXIFA7pE+vUp3KYJ0qZx75zEPoGbVC4MLHyHbYKs1hqRI3G5tMFFqB2S+h4h 6GclaiRIoiVL8yC1AECH15IlyW/fKOJB29nZp6BEwpVYiISibSkgtDDCCul8mYUrveDxUWxBg9iC 65f1lcI0couQ0GKzNWzW6Ust1o5kwgy7QotRRCFCi5DIwp/+d5BYjFKMeKHF8fGaVqs//fD17U/6 0Hx2tmqz0xdZBAslepGFLSyxGEo3zEKKLaGFCCs2jthCRBbkjNM4Ty+04Dq6vtTbyyy4OEILEWqY 5Jym+NsAKgRCi/zrzyVJuyY5Jf+fsl4ILaavI1Vd2sunrEt7+VQcYjtyFEzkLIHQXH/uAgrtfX2I OFLWqTjvIKoIPkNwxQXhEotVWfSCi15yYRNiSwmmlJYU1f74Ee2ms/aFFqH5XxNhxKTBZk67O+2L rn/dLX5F9ParmXzz9ESX9/f04+GBHlerrf3XWjnEptve4Y7fEUgE5RK0K7hYt20/7Z/0I7q1FV70 fVunSDD89YVEG278rozDV3KK3MIVebjiixAp5RY5SSRyiUPILR4mx5iEnGNjNI71nM6vWEqM2Wef +P05RWgxNIWOgMKXWbwksghJLgbBha1zq6m08X48OaEv76Leybqw4b2hscV2h2O6UIu9Tyu/764F AAAAANAAiQFB7tT4oniKD0BBWt5rBzBj+GPm39pBVAZ/8HlLZt8udEOZNcuu+6UdRGVwMgg+tpdk jm1cuw9LTcmU5kDpyUKERjuAhPCHe0j4AVIzl2OqpjYICf2mpSHTBkJmAf6HuVxbY0ASXVASNf29 cKcdQCU02gFMAITpALxMTe0AznPAnGsHkBgc13HUdC1bagdQEI12AAlZagcAgAIL7QASwu8zpng2 Wnq7n/I9lAWV/b8Kfg5xox0EqAY+t74TZBYAxHKuHQBICkst8K5rnjRU17d0AGhR+n0gKJhnAdg7 Y96mgSiOv4YItSoTAxODkdi7ILH2OzCxVcwMTKx05BPQCYmv0LFbWDsgMRTWzN1CBe3gJuTd+Z3f Gcc17bnv7vx+keVL4pz/dq1cnNTvp1ILRYmDtqJJb2560dHRMezuPjZtWzwQvLY/cbkFSS2WTlbB 5RZNsQXOa5nFysksqG+7Tn+eCuHkFn2EFq7co5uswKKWTFiJhSk/WbWttMIXV/j3/YlEFvQ8l2LQ usqWvDXb23/g4uKnaX/+8QmevHzOtmqD0GJlhRZ0nwsm8IYSCnOrhBZOZFGJKy5Xl3AFV05iYe4z uYWTWVR94A1FFtgmsQUXahiFxWrpCTea26AMgPSuVaFF/P1LHyO3JaaC/UP1FbrfWIUWIYhp/4To S/r1IYlpW+7S11iFFn0Zm9CiL7GLKlIUWkj2OfCyN4kq+HkyX860/vP8meQWZr418eQWnuCCtoOX poaO+33kFptKXQN0l7xulr+ers/WnwH8ertufwR4+No+/G2xgPdnZ/Dq9BROzs/h9/U1Vvr2JA9L JoBwkggur2iRW5Tseb5M2ZxXwgo3J3FGta6yIcwoG32VzfWzdbr8tC1mv2zV32h4EhTwpwHlFjEV ro8tS0x5kBgzETFnIyTyxb5P2kgxM+euxyLJLEwb6v1hhj4mpKC5J7RoEVlMWZtLMSZVTnqMhslH 0yk83dnpExW/XH4B9Yj8APxRu0tkMelYtktiwVVZsGEZaLT/2cV9Nk5RFKUHhXSAAdF/dFKUsOR0 UTQWCZ1Lh1CCsy8dYABUahEfOb0XEil9ZsILdhbSITJkD2wxV7zo/BDyPkeIFZRaaOHi8OBF/3hs z8Hu40IyzIjIcazMmZQ+B3SR03GXy99EiYuxHFc5vRfMpQNkSgG2ADgK0PZEkyg5MJMOEAk5vfci Yxkzx0whHSAgeryGQYXpyn2Q23iJpPpbTU7nATPpAEoUFNIBAvJdOkBCFNIBAjKTDpAQOX2e0HMZ ZYwcSAcIyJeAfaU8/oc8tzgM2JcE76QDKNmAx9J8PX0QzqGkz1fpAPfIvnQAJSgoTTiQDqG0kuNv SYoiQQhBoqLcir8CsHf2OHEDURx/aGvYNCkRliKkSDlCCqwoF6CgoEHcgJKWMl2aVCjKWfYCXAAp iVPlAIhmxXqzj/nwsxkvExj7zYzfz7LsXdvjv3e9/lp7fiK1EITx2VZJkhl2vGk/P1fQ/v6hUyJB JRaNyAKsmEIJLVRXiSvWVmKB7XJZE+HF2oovGrEFWLEFlm/mlzKvk1tsE1rUumyX0KImr1dEaEGl FVReYQQXbZEFwBK6kgsqtMBuI7NY9S4F1ns2m/2Fu7tfcHL6CX5U32GveEuWql3xaa0bVdFl3cgs iNAChRNGRoFdl9CC9j8RWWCzXrbKsGILKrQgzaPIQgstuhW1itBiQLg/Wu75j4kILcadTyyV3A9Z 1hjlvoQhssQgPYjpM46N2EUQY5QVi9CCY34xZn/JNBwyiNhFFSK0iHpcH7mFEhc8FV08e35FBlOR hZVb7DjkFi6ZhUtY0Se06I7bfQ96hm1rKW82Z+BHm+63zeSXAPP36u3rqoKzmxv4cnsLP+/v7eIb wYURQ9grAEYiQfpdgouubOJBSyyMlIK2j9PoYSstuli5xjXDOvNz5TDSCiOysFnIstRkPDMuFXu4 rrVQCYYvsVReH5sQIaYshhgzGWLOZhg7Y2zrtC8pZqa8SmbheG0EF1Zk0RFT9LVGZOGSXFjBhS6z tXvU+d/t7sKH+dwn9kcdbwbNXpj2+7R98gpfhdX/frSCIAihOOAOMCByo5MghKXkDhAQeTg2P/Dh 7dz2aVgZzII7hDAJUjpmwqzyIOxw4EUUfCj0N6iH0AvOMBMD1+1z7hAZg+v2BTTrdskZZgIU3AEE b/B4M6XjgG0U3AECsuAOIOBdF0Ki5FSx24I7QGbg7/oK1PHgEW8UQciOgjtAQKZUydGUyWk/UHEH yISSO8AAiNQiPnI8z0zx//aczhmRFL8DITwld4CAVNwBEiKn7Zlsy/zAYwmvByISQb53YWrgdjsX udofCPv/RerbgyJAGeeQ9n2veE1VrkO0yen641iUoLYHXyGvYx6Bj1zuhfKh4A4gBEfukY8TkVoI QhhSPwcUEuafAOydv27TQBzHfyQVUqlYGJgYzMAT8AJ9BKSuSFSsrIgROrKWpWseAR4AkbVizQN4 r1DFgBpBYuOz+/P94Ry79NLf+fL9RKez3Mv564vby5/mPpBaACCPb7GkN313Ojv7TAcHj+rtZpFA srbtYsotWGpRtLIKLiy2UNtKbMGSCy2zKFuZBffdHNOux8zN5RZ9QoumJmt5R1No0cgmtHTCllGw qELXv53a3P+HtMTC7INlFkXnWUwm96rHfEHL5Q96+/4lvfj0mh4+1u9FmQuW1tIIKtpFTQvjVoss ylo10YonWEKhhBSu0EKVq/Kq3a4LLXU7JbYwRRakZRYszyjcm0doMWjBVfD/SA+txPGlz3lbjF2U AKFFHP3GKn6IQXoQ2zUqff9t9SV57FSEFjEKJqSzxyyXkDimxDncpn8ILXrb9okqysKQWwx5rdVx vFZsUd0swUV5LbdoGv27HPXEs69LgOGTWbhCC58Io0to4bZT7FWvsJ8S/VQfXX4kun/U7P5+eUnv Fgs6Oj+nrxcX9Gu9boeDJQ+FIYAwhRVro3blFiyjKJw2K0eMsfLUbntTmLFyfmaJNEhLK6xCtqjD lF5o8YlTNrzX0ie3iGnB/VhyMLHlUcSYSRHTddSFRMbYx8THGB7LPkLmZ5lFvW30XU9dhpCCa0to 4RFZ7JkyC0OKMbked97HU+KD6ZSe7O8PifqsKs9Jz6hTsmfpTSKLyYa2m2Zxnv27JBfufu8QDzk5 AAAAAIBAZNIBAjKXDgCCcygdYAvgy34A+JlV5Yt0iB3gFUEAcNfMq3IqHWIHUNf2N2rG+1A0Sbqk tJhS6qT0BbGUrrtcOgBI6npicukAd0QmHSAgKf2NlkYtLqDG84N0EJAcc+kAkZDSvJlLBwBbJ5MO EBg8X7g9GY174UgfEKYD0E0mHSAgkHEBJqXn43huM5yUFkrOpQOMhJR+19WC+Lu0yDAAimPpAAGZ Be5v7PN/FqCPkwB9SHIiHQCMGiXumlHzf1ypyH9AHIx9frkJmXQAEBz1mcWxdAhgoV6Tp/ZZEgBS 5NIBwO7yVwD2zlipbSAIw8tkIEWYiWsqJ02qVNTMuEmVJlVK8DOEF6DMpKJKDU/AK+gBaJh0zITR S1AwwVZ0Pt3dSpyEDXfau/V+Go9ksO7+0xjOluz9RGohCOMyVBzJ/O47rHHB6+Dgo1cigSUWTmQB VkyhhRZ6rQUWVUtmgbed7GKBxBZgxRbLZWX748bzY/KVXRwSWthykB2hxaIRWjghhRZVqPtGVOET WvxD9x/R44zEAgstTH9+dnd34OHhz2r71+UpHP74Cnvv3qJRPS1YuhJbVE5kYZd6LFZoAVpkYWUW 4EQVRmDRFVy0ZBag91XLSopRL0qYgfsyixFa9BVZFSJCfXi3TWgRs+/URQlj95NKkfuYbcVoN0Xx Q6w2NyW15yj1/iHbohRJxGqLsu8UBRM5CC1Ct0Ux5lSEFpQ5uAotNuSJqAJvVpW79SzrZjOCCyW0 MHKL1bpZeuUSAO1y1c8JLcz+Q0KLofLYLrD/55P63fmXen1e734K8P6T/vHvuzs4vr6Gn7e38Pf+ 3h5KI7joSiEWSBrRElt0BBdWOoGEFY9Dt+VS71evF83a9xjcV18GLOYwIgucG4+j6owPiz1851yw BMMe8kQK16dWRD+1PIoUMxlSzYWhyJjDcemSY2ZMyL+TbitGaGGnNCSg6Mos+kQWPsmFFVw0bbam wmYsH/b34fNksk7soybeG3CzLt5e59Ynr/CpqsDz2E0PrSAIwmvh9GU3QRDiM6UOEJBt+rLCtjCj DhCBgjqA4GVGHSACBXWAFzAHXZxLiI8IAMblDHQhDyE+6vPP8tyOA6diStzh9L6I0zmukjqAwJKS OsBIcJqDSuoADFAXiJUw9AqkwIAQHjkn4ZDXYUJOcHq+3lAHYMI36gARKKgDCF6m1AEiUFIHeAGc 5oGSOoCQDFPqAAEpqANkwpQ6QGA4XaeIicxhgpA3c+oAAbkI3F7u88Br/z+r8xI5X79Qsr2COoSQ LXPQrwtOaGMITCmpA4wIp89ICI4z6gBCixl1AEFgREkdQNhe/gvA3hnrNg2EcfxTsKIMqGwMTEZi Z2Fg7Bt0QOydmDuxs/AALB3hETp19lqx9gH8AJUKAy1CdYPP5y++u5wTt5z9nY//z7LOsePPf6dO 3NjR/SC1AEAWXydJH/atdHp6RgcHz5tp3RkgWdP2aMotWGqhZRa2uMIWW7DsggUYVaWXmdvQ27Tb lOjraNEvs+AuGvW0Xu9+a9QCi6YrStJCi05A0YkpzNYUWfyhfuFFt14ntKhon9BiuSS6udFCiy/n n+jl+7eULbN2r7blED6hRdMqmUW9TSWy4JZFFI3UggyZBf3eSCxu17e2zKIeWGShWq6jBhZmqIGF Fo3IQuUxhBY8jzODEZF+eSG0mEftKYhNFjAWEFrI1YxJABGinvT6IWulIrSYYj/mKpiYi9AiVrkE hBbht/0QYhFaPHLfmm9Ya0dwYS43vjObQostKcaebCyxWJAWWrDgYiO3UHBX1Gva7sKaBjweIrQw H5NTx63t1lCs6m/fr4h+ntSzPtcPj/Ts79fX9PHykt5dXFBxdUW/qop3fSOmYMGFJbcwhBFeuUX7 3Dt3OYsuWlEFLzdbs+bd2hFmtHV31b93R/KLOlhiwftrjb3XXNpDNpLO62PrRD+2PIoYMzExZ1NI yEBiFpD0McfMLmPmZ5lFM21sqzlVGUIKbi2hhUdkkZkyC0OKsWj/DjyPt/U0y+jFajUkan2WpDfU nUGfkH2m3SWyWOx4rk904Z7V+yQX7nzvSzxk5wAAoIdB1p8ZU0oHACAxUvrReykdAATnSDrACBTS AQCImB+UZodjMcMCgG+UXmcpMYFje3ogtwhLLh0APIi5dxLC5PX4TDpEQArpACD5a6apkksHCEwq n9FSqP+pS0rzehGIA7xHO1LqWLOQDgBGJ6XjFZ9DYTiUDjACZ9IBgJdcOsAIlNIBHsGhdICA4DwA mNfSAQJSSgeYCbl0gIBA1DacXDpAQArpAABMjLpWncp9TCUwKAPXLALXm5p/vad4EiSFHMfSAcAs Ue+boh6/UjqfjyA+SukAE5HSPQ9go6RXx9IhwAb8phuAcBTSAcD/y18B2Dt7HKeBKI6/Fc0WK9CW FCuChCjgBlQuOQElH1fgBHAABBINJZyAK6Sk2JJyI4ZDRKLIxnhsP/tlbO862Rm/8eT/syyPE3vm bysfTjb7fpBaADAdNxVF4vte0YhiBRcXT3slElJi0YosqJZSsNCiWlYCi7wjs+C2nVlkwfvavuz6 drst++fxUme30GKf0CLfaVfbdqUWrdDiumxLoUUludg4ogpXZDF0u9vHph6TpRb9nJ5uaL3+Xba/ /fpED7Nn4qjyzpJlEVYosaVWamElFs1UtK2QYkdowcKKXIgtWGRBYp3abUqhhe2jWHK/pczCTkJo wUKN8nFfT+4xgEBon14ILdB3qDFi7883MQktQgChRXz7++wLQovjE0xMPV4KcolYx7xL/3OST2j2 6aPvXDZHyC2E0MKdxmY7ERPLLcqlnfKTbslpVy7RJ6E4RGgxJLOQ60Tdkth8aOdE/14WjS/FLu+J 7j+pbv+6WtHry0v6fHVFq/W6OQ1ScOFKIVga4cokXMlEI62oZRYdyYWci23K7XlbXhbj8H3NNrfM LK6QcotruS6y587x8XHL711k8XopwdAgpiL6MRb1jzETE3M2RiNf7OekjzlmloR8LLq9smSieQsT AgpXZjEksuiTXDSCi7rPZhwh03h8dkbPH4z6reOLOt49at9pZXvMPCSv6LsqoJ5t9z21AAAAhjHa AQBIiNR+9I4iD2mRaQcIgP3nfaMdAvSSYoFbox3gQJbF/FE7xBHyppj/UCW3SPH5EAP2OuWddogj BOIWPyy0A4C9MNoBPLHQDuARFPGKg5SKATJL7QATkNJ3V3gtOBz7GcUWcv5JKIQDwmK0A0TEI+0A HsHfDdInpesFox0gETLtAAFYagcAIGIW2gE8gusWYEnp2sZitAPMhEw7gEeMdoAZkdLz3WgHAGBi 3moH8Mj3QP3+DdTvFGR33PfW2n0R84Pwmg72h6X0c37sg3lwLN+bLLQDgKB80A4AGvC+BYAf5vzZ DyTAfwHYO2PepoEwDH+ESFHVSkiUEaEsMHboL/AvACT+BDsSc0bWLmxIXdnaH4AUpC7dK8TovaoE VKhFAhuf7c8+O+fUSc/+zuf3iayc3fOXN05rx25yD6QWAMhhGhzp7V0rHR19pt3dx2k7G/SPKu3q pMstWGqRySxYXFGXWag2yy5YgMHrVh8jW549trVt4jRxHNUkHiahRTEsI+kyi1JoEeXSiXSoyLyd ySmq4orqfHVikQX/XBda/Ctqrxv2cTb7TdfX3+nJ/iP69O0j7R88055Vg9AizoQWPK8LJtRNSSjS Wy60KEQWubjiJr6hW7otJBbpvCa3KGQWeQ11UyIL1WaxBQs1CqlFHFWEG/XnADpijJsXQgu3anf1 GC7Xc3kAbdfq2KznkgDCRj3p9W3WgtBiHIKJvrNvU9dluYTU+xdpgYgLNTftuwl9ZWj0UDRIKuJS bsHnzXrflfXuyFaILWhS3j8ohReNw1XXpRNNUopNhBb1uvU6tGb5jCh6TvTrXdL+kMy+zBafXV3R +4sLenN+Tl8uL+lPFBWbRRdX1KUQur7SJJcwCiwMwou/Wj+WWaRXEmrLjf30+Qbhhi64MIk6yt+R VXFFkzy1T7mFa0IEl7IwLmZiXM7GQGjRjiFm1ukzvy6YYOkEtyeakILvK0ILg8hiqsssNClG2k76 8zLeX+5Np/R0Z6dN1BfJdEjlEfMhVY+860QWkzV9TaIL0xGeGvpQrb2yids8OQAAMDCXDgAAGAxz 6QAW+SodAFgnkA7QAUvpAKARHwe4DaUD3INFMp1KhxgpSm4REr441RXHlH0BHPQPi1sWBHHLNgTS AcBGLKUDWCKQDmCRUDoAAAPGp4HdxjLIhm0Cyvajr2RjgJEQSgdwhEA6gEV+JtMP6RCgc+bSASyy lA7gAer9o28SLDUYTCgdAhgJpAN0wFI6wBZAxgV8w6drIfgcT3t8et2xL2uPTwNo4nUHY0J93sCX 69Xq2tlJR7WHvF+4z2dKFrZCCLGQDgAGhfpbOSZI6UF/jOX/PT6dH4JV1LXM19IhAF4DACwy5HM/ 4AH/BWDvXHabBqIwfApdVu2KvasuEW9AJW/ZVOoOsSFPgHgDYIuEhITE65B9xaIP0DYsWSJVlUBK jI8z4xxPx8QNY5/x+P+skVPHl9924svUmQ9SCwCG4V+NIdn3XpbldNuMTk6eeSUSUjSxEVlQ1bfF SirWAovinszCvuayXNp+c152GYWnwcq0EcKEQsormJUzTAotVuLvpRBQSGmFlFdYwUVTZEH0h1zJ hRRacH8ttLDCDD/cntn+/k+6vb2hs/Pn9PH7JzrMnoi1LBqNja5MV+1309UaCyO0YOGElVFwv5ZZ lMVKLKTcwhVZWJmFnEcttjBCCynP4K4SWRihhds4KoQWPRPD5h06Q6pCiz6B0CKuRvP7BEKL4dAW UsT0mY5t3+xKLMfKoQUTGkILbbmAxrrEPt7/ThNqnjEILWIYd4dpG/di3jqKTX3Bva5oEWO0sCe6 R3tNuUVDcLGZwN+c9TahxS7vuc1h+5ZvOSL6/aLsfy5n8Ybo8Hg9+Ov1Nb26uKAvV1e0uLsz27cp uKi2VrneUhRRCy4cuYWUXLgyC+94ZGQWQnhRl3KYry+n983biiuk3EKKOaQIo6pT4soKs352vdvq m1wJRmhia0Q/tjxMjJksMWdjNIQpsUlaujDGzC5D5XeXYoUW9SlLSClcmUWbyMInuZDFdxpkjg8O 6OlRp2cfT028x7Q5s8rXXUrb2d49c7eJLNo24bbhAADwUDLtAACA0ZDSQ+8L7QAgOLl2gB6YawcA XlJs3PyXdoAAzMpyqR1ionBFyztan1tz1SRpMiM04qMJf7b5BzT4UdrDSOm+IXV+aAcISKYdICD4 4Z4+KR7HpnKtnNK+W2gHGCHvy/KN0BAOGI65doBIyLQDBATXYdMgJWHxQjtAAuTaAXpgrh0AgIjJ tQMEBDIuYMm0AwQE1+PdybQDBGSuHWAkZNoBAoPvO5gSM+0AAWGhRV/XoGM+Luxa15TTuIVFHwh1 U6A7/D9c/p6/1g4CJsOUnrdM6RkJ4OetdgCQVL0yANqM+d4PJMBfAdg7Y922YSAMn2QjBeJOfoDW CFCg6Nqlo/ImRtupr9ChXbv1ATLkCVJ06qq96FR01wMECNotRixVFHXyiZatBKF0JHWfQJCSRfKX JZsKI98/5xYgCBOlKyjS+75KFxc/YLFYEkMJvR3L7UTNLdDUQptZoHGFaWahymh2gQYYWJf2ofs0 c13wPeBYN2aoRB0+UR+yCrkY1XkTdhLahhZb0IYWVahI0CYUW0Azip2xxV2H0QVu35D9d7luF80s sL9u4jiC29vfVfnjl3fw6u05nCyekKPaBRY1A47mZGkZWhR3lekENaHYgDaoUAs1uKDrzT7UwKJc VHuYU/OM3FjMwKioWZgAYmjhfvuuBGnnxKXg/0O2K4YWw7dhqy3u+jbb4q5vq60xjsNFgwmXTSA4 +3fdgIL7vR5Dh802fdv3sRS7v8WiA/Gf6XxBUy6Xvnq0D7pfVTcixhiYRUW7Dg1jXZBtx9ZjUp/W BdIeXc9Jmb7e1T++Vv4Znr8E+FcmuAE4+QWwuQJIr6+rpPhwdgZvlktYzGaV2QMaPWBT1dyLsR7V 6/SQaI6zFxjpe1YHPS/yXJ8b43VsV/Ub1/W7cnpem2ji9ba9iOJUJ84f1X3gtr3L98h8k3lqHotL c1ouaUFc1IS4rA3h0OjD+2Lio2YKp34cG5rhjXznVqYW6vuc5C1DiziuzIbM9W29nqtUbsvLMSOv jS2oyZDq4+l8Ds9OT+HP3954nS/K9LpMP+uqytACh5VjyRyCio7UZXaBw9sW2kMj9JT33uID2wVB EARBEGwQ0kPvGbcAwTohXZ9Iyi1A6CTEay2Eh8PVj6YT0J+bkALT+cRz0AFkv4P+Ub4EU7KHMlRI Qa5tLtS1/Q30j13XIPeR92HFLUC4NyHcAyAh3aOFdF58JUQju6ncm624BVgk5RbgEeozq4Jp+Rz8 SfCTqXy39iH3YYJPJNwCLKIefMq4RQRAwi1gAFJuAcJBQhozkZRbwANZcQuwiNy3CEjCLcAiGbcA jwjpf4YZtwBPWHELsMhUDJgFAVlzC7DI5YBtp2X6NGD7Q4MB+x/C5wF0jIWal/rKLULwhjXo60VM 6YUxybgFjEiIc45CG/UcRAL+zcWGRMItQBACIuUWIEyb/wKwd/a6bcNAHD8r3jIEHbK0Q7y3r1Ag Q/Z06hhka5cCfYQOfYaiyJI+ih8gzxAo6EMkMWyp5sfJJ0ZylJTmUef7CQRFWiJPsizKFHn/4vlN FEX5T/o8WVG/fp9hwGDf4+N3jYgEhYpYbIQswMYYUKTCCVjUT8QscN2E1QrjdllYB9bXhRO/kOLb CX1hUSqSV/lzsSICFqGgBRWeQIEKKmSxIAIWC59ekPwFEbTA7VDQgopbbBe0mE43ghY/f3+DD1/O BglaVDURsoBAyMILUaA4hQmP4EQrHuqHJlghC3hsp0Nxi/WCghihoAUuKmiRAdynmbv+lKigRVpy cXK/y7Jil5uroEUMcjo/Mcri3j8mOR2LClq8rqzU9Y1B0GIouQtVjFHQgrPMXLaNvH/4P+3J51Xd 9Bn0LUPtMXIMxXqx8aRwjrtxqSftHheAtloDTdM8mp50rIfpvnLCugDabrUpb9b/+s/ADh0pvgIc vXXZv25v4eLmBq7KEv7e3zenAnskquY8+t4A019jBSmdx26zvgoCbrP02y2ryuYv/edhTPexUpr+ M7NfV0zrwrJpsD0sxM5WjLb7dTy2zmPu6HOi3sxfg71+MnKkn5MtSI42ITnbhqigxTDGaDOFy/6w 1kbQAjZCQzQcbAnTjnSYV3hRi1A1wnByeAjvjwaNhfwIrrU8gE1LSteHhD7xirAVpy10V4u87f2N oiiKoihKKmbcBkRkzm2AEhUzIUPahCcziVsd4+WJOrjNF3Mcl+Amzip8nIObFPiJ2Q5JoGiLOvjg xYybNk4IvnMbMgIkOVOSjiTnd5KuO0nfy1iROOl/X64rSfeCktuAkWB+ryWooIXCw77cW59DUrup 36l8ZtwGRESv1zhIuochc24DlF6kvcscI5J+83NuA5RsmHEbEBF9vhmGpHuZoeQ2YCScchsQkZLb AEVJiLlnS3lvcQe7fQYtd1h2Cl46nvAUxv1ewwgUSBlvqOyWP+twDdonoqSn5DYgISfcBihJ+MFt wB5jnvOkPNMrSg7MuQ1Q9pt/ArB39rpNQ1EcP4SoVSXUkYkhAxIbEzPyE7CxQhdmXoCBoTtU6gOw MsGKWMrYCfUNvFadmCJQm+Bj++R+5Np1otjn+OT8oqt7m/rjb8ftta34/kxqYRjDkxoM6d19M52d fYXj48dluxrED4J2WHy5BUktKpkFiStimQW2SXZBAgya119Htc6wTjF+uUWcnYZSdO1q+3yRxd2q VMNI3tbvOwGFE1P4tS+y+AfNwgs3nxNa0LqahRaHh0uYzyuhxfnPU3j25iVMD6b1lqzLIVJCi7Je OqEF1qXSohZRxEILX2IxX85DmUXxIpEF1rQcfJXrqF8ktChFFpin3ucruYUJLYaFezdzrJ9rm01o Mex6pAxy3+eyhljuNvSRRYL0QNI+loZ0EcQQy5IitOBYn8Ts28zDIYOQLqowocU4p93F/G33BFrk FuXvvXsGqWvSrnlIZIGCi1JuAQ8CwUVyOOtYQgHQLKXYRGjRRZyRWj5yUFzVPwf486FonxbX8a+q t39cX8P7qyt4fXkJFzc38HexCGQPJHqIpRB3tYgiEE14oorb+0osrCjq1HIbhRj1NLHsYiXK8PIv om2Jt40OhaC03HPaVHAhbRB9aXkQiZkIydkQDmGKNElLF8aYOUZKfpJZlG1wuVZyi6gOBBaTydrP /nv+PLEogz7DR9MpPDk66hL1aVFegOsRH0LYc7aJLCYt06ZEF6keHCDsiZvaa7u4y8YZhmEYhmFs gaYv49rD8LrQ9tA+YseoXOx4kw1uSwYmtuAGH0T9VpTvoFMEw4GJLWSAx/YnqB6qmbEmkYvGflIz Ws4BtB13OXcAQ+X5yz4MLJNxB9gxOXeAEXBSlN9gA+EYPNi1mUPTuVjOHcDonRl3gB2i5XqOkxno G/ALBxnNuUMYSTT1l8Qv7gBboOlzyLkDGCLAe1ia+jI7v+mGpv9lY+xLuND0udvfurFPnHAH2CFf el5+DuP+rle24fQfe8gwFHjv4TN3iJGQcQdgBK9VsM9/yx3E2FsuuAMMRMYdwBgMlGFl3CH2lIw7 gGEowu4FGuz8F4C9M8aNE4jC8Ns4hQtLltxE6YhcpIisHMANZTqnSZEuZY7hOmWKSKmSI+QIK7lz n9IyrnwBF45kTDLAg2F28LLKwP8Y3rdCw7K7Mz8IGHa1zKdSC0UZl6cGP+LXPtCAC6zj4xOvRMKW WLQiCypLnlhSUQksig2ZBc+bKc+57NbFbXB7Q5mn3MIntCg689U6daUWrdiCBRZ5R2hRSS4eHFGF LbTwLWeRhVvHQ91m7snbsr+f093d73L+28UXenH62lqrYqNkWYQRSrA8woglGplFLbQwQoqO0IKF FUUrtmhEFpbggsUXZiqFFqaOf6UtyihVFpbQgoUaLLSwB0ZVocVEoDfzkoQWYzN3UYIKLWTUK1X8 IOG4lbaPoj8/Vl3ItmMRWkgUTKCzS5ZLINpErMP/1K9CC1FCi+7b6kefgIBFBoWtWOw+H8qqqOQW peTCCC5Wq1Z0YQsumg/Q5hDWPkmFT1qxy2u+ttxl9vIjoj/vqPwL0rPPRIcvK0HE16sr+nh5Sd+v r+n2/r7evtUvA2XpkUI0sgvrva5kIq/lFZ2yT1axRZqxIcPwtOFm4/oerXyP1no0z+tl3nXeIrjo Q8og9AaJg/pLzMRIzsYg8knfJj7mmNlGyr7oJmChRdMlORKKvSem5yy06JFdNFIL8ndlrw4O6M3h oPFNTut4e9T2nPb8kKlPXuH2zL4e2V0+ZNMqiqLsSooOoCjKLEjRAQJibn5bwmCOSyJFBxiBNTqA 0kuCDjACGTpAYFRsIYczqvavFBsjGlRsIQdzk6A517xHBxFITIPqLIEMHSAQCTpAQPTGPRnEeC5b owNMQIIOEBA9F2zHDJj0Ax1CWTQZOoAQzMBUMYll1ugAyuik6AABydABIiDG634dIFguKk+UQUzH fYYOoIggpn3aDI48x/MKggQdICB67TKcBB0gIGt0AEWZkE/oAAH5OUEbc+4XdvnOl1L1n5O5ck7j X7fdjFy/Mi7me4o5nt+igyiLJkMHmIgEHUCZlHN0gIUS0+9vioLmFzqAovwVgL3z140ahuP4T+jU Si0SEn9WCAMrS1/gXgCJR2BjYOAJkHgKOiH1DWBl4gbWSp1gzdqhA7qhlQoNcZyfz3FNLlFj/xzf 93OyLskl9jd3vksaNf5AagFAXHyDIL3dttHx8Vc6PHzYTOvB+qgz3S223IKlFlpmweIKV2ahpll2 wQIM3tZuQ7fZfR7KfOQWQ4QWZvhEq/xtJBZ6qEg1z2KL61ZAcd1Oc3FFFnrZprDIgl+3hRbczh9P 3g37+2tar3/R40cP6PPPT/Tk6Lm1V/8RWlRaaMHztmBCiSeUhKJ5tEILI7JoxRWX1SVd0ZWRWDTz ltzCyCzaOtSD61XPTVutUMNILaqbjnDD3QcQGOm3edeEFiHbTl2UELudVAa5D1lXiHpzFlqkJICY oj7p7aesS1IkEaouybZTFEzMQWgxdV0S+5yK0EIyR65Ci7sSSGjhrr9NUmGuG1TddQfJLayXWWLB ggsecLxXbuGTUPTNj5VduG35htd2l+8R3bwk+v2hXlSXvVd68bfzc3p3dkZvTk/px8VFI32wZQ8s ejBCi/Z1I6WgjVSCRRNGStFXXGGFJcBwBRZeIQbdlmpwjspdRrdlFva+8UfeKSPkFqkMQs+klIVJ MROTcjYmdsbU+vRQ5pjZJtX8LLNopq355lDTyijs547QQsksLInFwpVZWNu4ogzuh/cXC3p6cDAk 6ou6HFFXaGEfSftEFvd61vWJK9yjsnsmQOQ/Onvf4iE7BwAAAAAwgkI6wITM+eY34CfHfxZHP02X QjpAAErpAAFgsQVucpVHDW75nXBD1VRAbJEOqm9/IT2gMthQSAcAo8jlnDOnvwdK6QCgAYONzpNC OsCE5PL7HIqTuryXDgF2HnxPNTmdh+Ea0m6QU5/F79Ddyak/MOgX6bKUDhCAufU3yLhAjuR0LCul A8yIpXSACSmlA8yInAaFLqUDABCJ15TP+acScZcR2llFaCMUY87LPoYKEQF1DfUkQjtlhDZAGNR3 YVWXZ8I5ACilA0Qip+sCYDtKilVIh9hBltIBAMiIlXQAAP4JwN7Z6zgNBHF8nFCclCuO6pTiRCo6 XgFF11Ag0YFEgXSPwBvAAyBeAR7h7g3CA1BRoWvcIUSD0FXcJcaz3onHa+fjxNqzu5lfZK3j/Zrd OGt7k53/A2kDFCVhtjk9orhXsIfS69nZ404RCS5iUQtZgAlpI5GKSsCiaIlZ0D5uyyWFzbKoDqrv f8D8oTr82i5osbKfwYodr0UtKqGLStyiEri4s8drMYq2SMVtQ9SifbwpYlHFceGMbrB7x+OfcHPz C16+PofnH97A5OExa1XTISiJRZjP2XmhwIQRmyhfJDxhBC2sMAWGKFaBIe2jiAV/T/uU3ghZFHem LApJPIPXbYQsrKCF69BUGQjprlZBizjKHoLQxAL6QgUt5MoMSQDCR3nS+X2WlYqgxRDtiFVgIhZB i1DFJVTQwn/d9yEUQYshx0oP6fkzXeZOnRTOM1/H9EFXnk2QkAWWiXMRRVVBLbSRrRU36voyp0yq jvKNoJ2n6EjL47KOOB7v5nfaVkwB/pYbnJfVfwc4vgL48+MWPl5fm/hnp6fwYjqF6dHRujjulZuE IYzDcZyXsXHohHxl53l40zHE4xRvQtt0NyQP4VS+Sc+7pXw/Ho1MvQVLz+toeBy3NpJ9mS2DnLGb MpjNYOeY1m1m81bu/BPZyPtHmhDnyEK0CQnVLo6EjTH0i0uMNruE2IbOyxcb92kMJUGLsR3bV0zQ gkSFUMxiieIWOIbbuKXdpzxLLMcKEfFxHOt4NJnAk5MT+PZ7px+fp+X2FZqiFChusYLtwhYFC10T so407mUOoHkpKKDdhZu6VlEURVEUxTczaQM8EpuDDWU3KS3eJvQ8DZcUFwGler5hu2ihZIrjRGy8 g2pxDy7cPwSnyn1CwhYL0HM7BNCh8txuem7rIr6Y+CJtgEfm0gZ4JNX7stjYuWYmQg7h3JpLG+CR XNqAQEEntJeQ5ndUiY9DGFf3IaV5slzaAKV31Jm54jKXNqAHFtIGKBuZSRvQA7m0AfckpfsWFeNS iJm0AR5ZSBsQETNpAzyiz9b7kdI1DMmlDVCUgbiQNsAjnweqJx+onj6Y7ZluDnH/xvFW2gAlaC7K 7ZO0EYoCaf0fahepPSsou3kPad1nxkDM926KEhL4u4bOBSri/BOAvTPmjRqG4vjLUR2VjoF2YiMS ezeYb2DnI1AJBr4BKxIfoisfoSsSw22IuV8gG+oIE4e4C3HsF15clwbOyXOS/y+ynPRi513OsXvR xT9ILQAYjtBMV6/vKnRxcUmr1WkjlOC5+Xi9naTcgqUWVmbB4gpfZmHWWXbBAgwuK49hj9nO/xcW Y6Q1+dehQgsWT5h1KaNgSYWUWoSEFua1ny7/1cptvVwXHzfMYpHRdntVr799f05nb57TcnVfvKu2 HKJZPKEFSybMwuIJI6MwQotaakFWVGGWbbltktxu9nEii7qsE1pwvuPFE1rUUouyFWETMxgI7VMN oQXq7usYqdcXm5SEFn0AoUV65WPWBaHF/AQTQx9vCnKJVI95SP1jkk9o1hmjbgWhxc1dWE6QhQUY 4v5B6PtgVna7r8AiDBZc+DKLZpv/1jJC/NmvmRrbnx6bRBlfaPE3EUaoHt+4IN929fV+f0b0vUrZ 12rzM9GPT0Qfr6/rdLpc0qs8p2cnJ/WE5C2ZBdnz2bw197oUSfiiCZ4lfHFb7sSlfi7LmbpYShES YshTIOs2aSdfk/HyNlETN2+3Tp9oPyHBhfzYhiate2KWFGNiUo6NgdCiG2OMWTKW+DPX9zZ9rOiL F66/lnkttNjvrcDCCSvu3ZJ2rkwtuHCCjJLaw9qDoyN6dHxMV3eH+qRKT6v0hboLLUKOpTKQfNGF HGp4iPFHZjmah3RU5O0PAAAAABCDtXYAESm0AwBRWWsH0ANzeqBmjExp4jPDN5r2JOw8+T8mPk0D 8xlsyD5UhQcTDsO0bfNQ4ocqvdQNBZCVixRk+5u5t+1cOwDQmUI7gIjk2gFEZO59SAo81A6gB+Yy 2WWuHUBE0BfcxFybG4LUDaQDrlPLlCbL2WgHAHpnSu11Lv/f9c2U2gSD8Sldcu0AeqDQDuAfWWsH EBFc64CZ0lhWaAcwEsz9kcfaQUQE/Vk3pnSt4/dQYC6Y/vqFdhCRML8ruxzoWGMeF7qOz2OWQpg+ fKi2AMbHOUFoAdKh0A5gQKb0XQF0w/xW+B3Nq51rgmsMgHhstAMAwPBbAPbOWLlNIAigK9nunEmX mRSeYSYzadKmSZWkTpdJen1AOv+A09q/kMZ/ota/4IouXWrMBCmcuIW7EyDknNhl2ae54YBjWSQM +GTfWx5uoijKM+ga3WrhrPtWls+HAl1dvW2VSLgSi0ZkAbspFpRUVAKL7Z7MAuumFAVO/Vi4D9xf TCppBvXYT+7olIgvr/CFFr7MopFNuOIJFFKgtAIlFrmdPtl6boUWuSO0cLcJ5Rb9QouLi0ZocXt/ De+vvwwSWmy2jsgCJRYosrAiCpRTmPIElbQi22ZeMcvreiC6QAEGCjFCoQW+VGjBhDm+1Sq04BX7 VPvgHI/zANrc4sSMx0kAESMe9fYxY6nQYh6CibFzf05cznIJqucXaoEIh5jHtj2GsXJgILTwm/u/ /+2td/oP6nZb6N2mKy+ja1iWr910sbTCh+bl9dwA+MNg4zwOqb3omcf2Xevatgu3DefdQ3kNkH0t K7dlkx8AL14B/MlzuHt8hO8PD/ArTeF3ltXv38YObl73eNhlu54GWy+wja2H5e9m409xeTAtMF4Z K1xeOG3dEu6jsJ+5m2OBdRvXPSY8BhR5uMeK70FbH5Q7+vlYcBwUn2NOCOfcDG3SFIn7/F+mmHPI FPIPM6zFRdCIhtxyZoUWnrjCzp/b+nlXO4wD/m0Mc3hzeQnvXg4aj/QD7EsrzlqW9ZUueUV453Xv sG1p932voyiKoiiKciok/UHulP/5TdlH0rmJ6DnKl0/UCZyAOZxvKLa4J85DqTCD0K5B5vWbglVZ flInoewwnYxrqD6TuSJtMCXppNQJRETSeTeHZzPuSHxGSakTGAFp9yC9Fvio0ELhSEqdABMS6gQi otde+Uh6zkupExBAAvIE1kZ2IllgPXUkXYOQNXUCR5JQJxARfW5RkI/UCUREz+thSLqf6LPLcBLq BCKiP+vKXFhRJxARIzEY63o99WvEoft0AtOWndxQJ6CwZQUqtFB4kVInMBLmO3RpfdzKMG6oE5gR kvphFIUaFeQpLPgnAHtnr9tEEMTxIbIioqRA1BRHQ0GZitKvkIIa0yDEM1CYV6BJyyOkSeqjTZM8 gunSRQgpUpCwub31nGc3m7MT7+7MbeYXrW7vc//3YVu+nPenUgtFyUOo06PP61Y6Pj6B/f2Xbd12 vgdO3S1UbmGFFlZYsejEFb7MwtRRdoECDNwGbcO26Q5jwie38NvELg+xjrnmd4oVWGCZByUUZriS VlB5hR3acktEFii9sOOrba3auY/dXYCbGyu0+H72DV6/f0f26q4cIiS0aIdLwUSrtGjabpUWSxGF L7SgEgtHbrG47ZbrhBaLv50gA4UZ5g/ba0UWJs9SaNHJLVRokR8Jhzp3hlKFFilRoYWsTvNTokKL fHALKSRd09LOzWOR8l6ZWzDBIbTglgtw7Iv05bZdJ9Y2JQgtJCy77bqpl/fW2URusZi7IsR1UowQ KLEwgotObvFsjdyCdp1Np903/hChhb+dUNv+dMMBwPwtwJ9pM+srwPOxnXx6dQVfLi/h08UFnF9f O8cPRREosKDCiH+kTuf1CSmcYqQUZDs4zR/S+X3iC5RXoLCCSjOo3MIXXHT3mZpzStWlffegUsst JHbqLzETIjkbwpFP+jEJMcTMlCFciyFQZtHWyXj7kUIEFp1FgsgqRp68wh/fIdvwRRl4vA5GI3i1 t7dJ1DdNOQRXaEE/KftEFjs9y4bEFfRTFw8NePWQ/CJ4iDfZOUVRlMLRhwgVZXtKe+i95g6gRKXi DpCAof9As2Qq7gAJeErX26QpH5vymzmHop3/x2balCPQa1sC5to2P9SeMOfgQr9/D4uaO0AkxtwB ImLex7UTL35KfC+ruQNkoKTzph36uajQQpHIT+4AgiipE90ZdwAlORV3gIjU3AEKoOIOkICndK9/ aJT2v3bDL+4Aj6DiDhARfb0rhoo7QGT0ut6Mku6BzbgDDIgxd4CIzLgDKEomJtwBIvIjc3tDvvf6 Ys38aY4QiTDnpeYOoYhkAiq0UORRcwfIREnfD5WH8QHKuy8klTF3AEUpBPNcrEotFBH8F4C9s9eN GojC6JVIkSKIggqqoQTeAe0r0FCn4zXokJDoKSh4lJTbIqVJ5546CquwDDvjvfh6/LOGjH1nxt+J rPHa3vFnr+WxHHsOpBYAxGeskyOe944mPGRozMteiYSUWDQiC/JlONQCC9uRWfC4G/Z7Ltt18Tp4 fXOzrNyiT2hhW+N1lq7Uoi202AdCCymoqGUWjcCimdaU92LeL+rKMX4f1zO8X87P7+n29tqPf9l+ pmebV2KrbKdkWYQTSrA8wosshGzCjTshRUtoYYXQ4lDe2btGZEG7rtDCCqGFk1kc6/UyC/cnhBYs 1GChheyIFEKLlQGhRfr1p9JJuyYpdf4/Z70QWsxfR6y6tL8fsy7t78eqa4ntSFEwkbIEQnP9qQso tPf1Ejli1pnbsg9lYaFFe/K4qELeQ5gkuBjJxnILXx4FF760JwQXoczioUKLvi63+2QXcprcxOdE P90dp0+HRd4TPX5K9GO3o483N/R2u6WvVeU/8/6TIggrpoVCCzkeyidYUPFXVEHUWc7VF8orhiQW cgjXsQ+kHFLGIQUXflsOvyFLOyxPC7Z16D6UFUMsUuwQP8VMTMrZGAgtppFjZkmO+cPEQ0ILllCw 3EJKK/jzWTDvLFyO66FuE+Z4cXFBr59Mem/0DXWlFI96pp2SXPS1pH0tLQ0s37cLh3YtAACA0y+J AABOU9JD7zl2sAHGKen4ZCrtAGAQHG/5843ql0zQHuiz9s7/Y+Ne9nDnqO/aQYBnrcd2ie1kyZTS SZjRDhCRUn6T3DHaAWag0g6wACW1QZV2gISA0AKkSqUdIBGMdoDI4FqsfHC9ACQb7QAzgPNYupR0 /mEq7QD/AWRcoDSMdoCI4H9b0zHaASJypR0gI4x2gIjgmhWsAXf9X8o9bfds1dXC68z5PLEZmWeo 7oA6Vy61A4AkuSQILUCa5NyW/Asb7QBAlQ/aAVaC0Q4AQCFAaAGS4Y8A7J1Bb9MwFMdfp0rtpIki AQe4kMPO24UPsG8AH4EDF07wEbhN3PgAO3QfAu0aaZy4cyY3dmSqkBDQhNjxS168tA3FyXOc95ss 24v9/Nymdueu7z/ldkAQRkBTsKPXuzpdXFzBfL4oBSUwxh6W64mKWxR5IViRlcIVtpiFKqPYhcpp XzpGMWY97xoMKNhd0LA2ghapqduCFrT+x9SpCAXmv41oBRW6wFxd/9XQB9Pa2EXhjM3MZj9gtfoK Dx8s4P31OdyLHpFZbRC0IMIRKGiBAhNUeEIJWqifUpwCKmELWsY6ttEiFlkhYqHK1C6ORcU0tB9Z 2hh4VAQteob74eYev09E0KJffAly36Ut13Z9FbRwgU+Pjwtb3P1d4tNcRNBiP1t9jzcEQYu2+C5U MURBC06bvrTtor9r2y374N+GOiS3rVVBDismWsigaluWs3bnCxNzhKP7KrvYDc9FJmTwDOohsOnR wgGpYxu8ZtmsXcN6arWjNmg/2pfaOMpNnAKsTvIm3wBmnwB+xgAfb250ejyfw6sogtPFQkcML4cx Qc/V3MvI3upshpzTHBCBCOqCfuyNwIRqg21pjn309PLfqUDod3JiO4UqCnmtL9Sjk69JGc+SJmYO 5bhWHe0Vk998DmU/bfvgY1B8H31CfPZNIWIW7RiizzbBzMGs27gG4hallSDM2qvzvE7FKpSgxXpL fW36qnJK7NI19mg6hSeHh/Dl9naXq8d5epanz1AJWuA2sC2lVp41pCbxCtxKcAuxd2V7Fwao77Rg tRcEQRAEQdiXkAJtJNwOCM4JKQAJEnM7IGwkpPUQGcsXuChqzuq5XObpOa8rAlRfbl1yOhEICRT3 9oc8veF1RYBx3tsRtwNCa9Rh+HduJxwR0vuzmNsBQRPSPYUk3A70QMTtgENibgc8QQQtBJ8Z41lK EyHtmRJEdxyE9FmCrEP/T0hrGCL3hb+ccTvQATG3A/9IaK95eb0LijNuBxyScDswIEJazxJuBwaC OiN7yu2EQ2QPE8bAW24HHLJkGDNhGNMV97dce9eXEx1wCcN+XoRueAkiaCH4SUj/D7WLiNsBgZUX ULz3GMv9zkVIny0KAiciaiF4w18B2Dt/3TiBIIzPca4SS27tKkgp8wZRCitPkEh24crxm0RKZynv ECkvcilduHfnixt3riwZoeM2LOzgZflz5A6YYW9+aAUL3O4HrFlA3vkCagGC4BlNka7sMIcXafq0 qaDj43e1JhK2icWrkQVkc0xoUpEbWKiKmQUu65QkOC+XhXVgfRTk5hp9191maLE2da7NuiZDCx3r qmxI8bqsjStiy8AiNvnYybtmF3ZZCaC5RRvz+SM8P9/D+cVnuL79WTG0sA0i0EQCDS0KMwtjMrGC qpGFbVoR6UlFeT6dXtRLKV+YW6iyuUVRpjG5KIwtzNRkaOGaWwgjQH26KeqnOmYxtBi3Hi5B7ocs a4xyt2EILRwCeXM6x9zgbgQxRllcDC0o6uOofZvfUJhBcDeq4PLsIoYW498ruVx7+yeqaoZY2a6c 90q1xTumyo0tgnTK5rMgDwQ+y/OZ9YL9pQegHCYb8xhye9aSd8Nr1+3n7hM49bh1m2PIZicA0Xm6 cA0wvwJ48xbgMYrgx90dnN3cwO+HB3iK4+L8rU3wc/wyotclxqxibZYTs1+RT7cl1rbVhjmW12W/ lZOSmoS6i685qNfoUtYxoW5c5x5r07coOzp6VzKTEGZB8TlqQjhrQ8TQohtT1Gwzhba4CVd91n0E QWEeFBgTimyORhXpdtvUAvMHzrYDdz9TRl23pXl/eAgfjo66yP4IVdOKec26ttTUc9b1utCwf90p bDq1giAIgiAIu+LToOgFtQChV0JqAQPwl1qA0IpP90NkQS2ACD2QRw/quYJ8IJtAix7k+o1ahEfo IAlfQdo2B/atbfvYT/qKT0GDfGp3S2oBQoZPbQpZUAsYAZ+u25JaABP0gGYxtBC44tOz1C74dO+V a+o/IbWAnpE2uzshtYABWFILEBoJqQUMwNTuQyG1gB75Qy1AYIM8j+8nPgVTlOveDZ/+1vX/Q0nA VWEf+EItoEd+EdQ55f6h6Z4dpulyRB19851awIQ5pRYwEKcghhYCX6bcj/wvIbUAgRQ9EN4nMzWO +PQ+LgiU6LEMYmohsOGfAOydsY7TQBCG/+Qi7nRBOomOBm1FQYOEeAGegFdAcG9BAyUd3bX3BIhH iIToaJCgj4R0PQ2KiGLj8e74xs4mOcC5WW/mi1Zrb3Z3xnayazvx/BNtBwwjc2JBjs53Nbq4+Ijp 9F4IpIdG3EKuXycpbuEFLbxgRdkIV3TFLGiZxS5YAIP7WLfZzjXgYIL/H0xsl6CFz9EKaygFLeow jWGZRShYgGLZEbZYipzKf4d8XcTC59yntIHodh8dAYvFt+r4Aa/fvcKjl89wZ3ostmpdHKJ+CUGL RtSi9OISJDZRC1Bg2YhQsDAFvaTAhVxv6lSJ21IZ9UvrLRGLqqzovGRAUumzccto7/JDErTYN0MX SjBBizT6TVX4IYXvbWqfUe32++pL03YughYpCkxo+56yuISGzX1vg6YfJmjRT/vU6kfa8LXjKHLr pRElKLEx/HSs3bZ6lJNNukZnsYzaxEjYAtohsfn2ApfF1iHalRuWiaLTb6xPdMokU2D1FPhVpdEP 4PgTsPgMfLi6qtP9kxOcO4fHZ2d1BPHGTAiATvu0MUH3KeS9GhYSobqhHpsfl36fbcrZ9XrzqrJx 6KOVi02kehSVvBDv1WUhoHrBfslDEXxsytgul4X11sdly72o7qGJkWJA/BR9YlL2jTFBi5sxRJ8l Q/c/xkiMlTzmgcdi+HF6HMblWkVCiFWQoMVqy/oqtKXlIvQnRYDI3t3JBA9OT/H9585Yfw+r9KRK X3AtaMHD/rZUdPIykmLiFSx0sUJ8Fu7OusD67CrrG4ZhHCL0R8KZthOGMXCctgM9ckgPKxwCTtuB PTDXdsDYiIN/CCQnTETFP4A9C3lOQUCGyHv4edrm6n6gB0Ac/Gf7uaonBj/IfanpxC1h4+hwyGms zekB0rm2A4ad8w+YnOagnMbof+USeR1TIz/se+qx8zBjSDhtB3rkq7YDmZCjeJbNT+mS05zJzLUd +EtyOgZzbQeMZHDaDvTITNuBgeC0HegZO3e5GTaHGcaweIF8fmciMbW5gt2Zgs2+cBvK39yiD33z FjZ+G23o3MSCEhspc0jXGfZ7ukGiFvS/axMP3A9O2wHDyAQ7dzSS4o8A7J2/btRAEMbnnKu4Al7g FFc08AxRCh4gSEhINIiKNrwBEgUSFQ9AQcdruM0bpLSUgp4mJuRsPF7v7dzEdi6X9c16b37Wam3f /vl8l/OeN/Z8ibQARYmIvohXNJzh2zqd3NfQcvncBWBscWYTxoDCGVlAk/NkDCyqO2YWbr2sy5l1 W8e2Zfuw/YWCeQ92jXzJ65VkHze02DSzcMYVK7J+uzapcMYVmN+AMbC4Ydv/SG7qOkML1yY3tODH PZ/PGkML5OuPc3j58dVWhhZlRYwsrImFNbKoGjuKtTkFpr9gTCuKqoDr6rrJeaJGF7hYAwxs1+bU 0MIuamgRGNJv+aEZWozZd+hGCfvuJ5Qg92O2NUa7MRtahGQA4aM96fo+25I0khirLcm+QzSYmIKh he+2JI5ZDS3iNbR4LKEZVHj+HvPrSl6HXlN3XTM/pK8ZWZJZYgKCY94uGzNAAC5c9oxt2300pDYv T8tCTz1ejvZNy/JDXAIU7+qVbwBHHwCeLAB+FwV8ubyENxcX8OvqCv6gk2b7/pVVtZ4tqdp9K3Cz JxjUnKfbnu2+fNUYccJW5ey2TVxD2X7mJXnNrtvtihxTSerYGSR6rH1zUTRaOiXEoPgharKErA1p DAH2rFGiz8cyRc2cqevnbBgRgTO0WA8b1tSiGctao4ok2TC1sNtz9tqcl2vb6BqmkOPFAl483eoe 8hO4a1px1LFvKPWNlHyUpaNzl+yh//coiqIohmfSAhQlAmK66T2XFqB45VRawAhk0gKUXmIKFmA5 pAe4hsjBnE8+1elet0tlNHBSJgN9EMgn+LDaWZ1eg/5tS4MPD8Y4jlBSaQHKg4jlNwDO+cQSGAbJ pAUoUZ6rY/m+D5FKC/DMIXxmQ3yu03tpEYoyAF5baWAQQyotwCOZtABldE6lBXgklxYQAam0gBFQ s5OwURMVeWK63s+lBSjBENO5JZcWMBFSaQEe0d8u25NKC/BIJi1AUfbAmbQAj/wU7Huq48Rxx74U pvs/D5wL/y4tQgkKvD8jg7ju0VDiY2pzVrsS01yXsjt4Pj6XFhEx+j1TFD+oqYUSFP8FYO/8daMG gjA+jk66KIdS0CAa5EhINBQp6GjuDXgFOuh4BCh4BKS01FT0SCg0FPT0pkhFE6QIIch58dg79nht 5+7Ad7O7nt9pNf6zXn++u6yd9Xm+mbQARYmYvuRGz9dtdHb2HhaL28zEolqOsTGaoMLNLaqIJhVo ZlHFPjMLY9dXhW/bt08efYGSCW6WaMwVz9MNVtNVezxlYWNoYdMd2vlrO71ihhSVSUVjbPHbiX+Y kUVjaNEYWPA2aX/9zOcGrq4qQ4s3H17DnccP2FGZTnQNLcjUAudLY4vihWYTaGhBRhRocIERjSrI pIKbV7jrMJaWGKYq1/Rihha0v9LIAvVYQwuad49B2SPSb7kaWoTR9j7wzSxgV6ihhVybPhlAjNGe 9PZjthWLocU+jiNUg4lQDC18NZfwxahiU0IwtNgGXwwt9tlX+lZ/y23o/8rEdMcLWsYEA8MJfdv1 1oOkjrjPMiamMdJI2L4MtFNkG7aM1zlg0+DUH1qXO/XcNnla7j73hQXA6hHAz9OiyneA+UeAX58B 3l1clOXu4SE8OzmBh8fHZUbxWo5Nik6mD1wSTdeSsa4xdX3kAOcx+flAJOnl4RXLDmwbrci0mDwv Y+6sA+h6itQfBY4pWV2U6N3Y/fF50mLscoD+8SgDTbJ4n/A5Sb/P2ggJjSG8Ly4hauaErn8IflyJ 7fPqUxL1gWRsYfvPMhbz3KwCDS1WN8yv7LY4ndv2uOkP7u/WbAb3jo7g64+1Of7uF6U4M8EXaAwt clhvZJE70fSUPvMKOmWtAFqnjwTaZ1J3uvN2DyxXFEVRFEW5iVRawMhM5WGFqRCjcVEmLUAZJMaH E7RPbIMP4r615YmokumCD1nhwwtL0CShY4LvaQpVguAXokqmCzdtifW7nUoLULYikxYwEjFdn32T FqCUxPSdIqZwzZ9KCxiRUBM1jcXToryUFhEReNOb+gCMdB16CcN9w7kzj2NvvG9c2nhq18Vkhrwp U+hXN0WT6CohEdN1nvZD/08qLWAHZNIClEGW0gJ2wCdpAf9ATOeBc2kBihfE9J1GMmkBgbCUFjAi mbSAgIjp7z2TFqAoOyaFeH5rhGPLkolHMwh37BH7bT5280pIxxjg7+hi/X2Lsj1qaDE+eF/4Err3 7fg9PU4G3espul+HpE7BdVP8vDJpAXsilRageAOaWug5ezcspQUoSgRI/2+pKB3+CsDe+fu2CURx /NmuLEUZ6sVDhyR06dapaweG/gFZW6lq/pTOnTJ1zty/Aqlrt6rKytY1UhZLkaG8gwePMxZ2c/jd wftYCGzD3ReMzO/7qNRCUdywr+Ur3mzhx6J731fQxcWbdkOLAC3ZBAooGpEFmD51JKkoBRb5jsyi Gc6K8cphmpbKIlEGSTN8pl9ucazQopFa5PmWfbat3nMRhS2paGQWzXdPHWILLrSgMrNeocXZWQaP j/dm+PvPb7B+95rN1a7QwhZHkNACJRb0QvEECS2wb0QVtsgCSoHFXqFF/lRLLYwkoyoXX6bOfFvX TYINMHOqQgtxpBe5Ci207KHq8L081/gktBgCFVr4N73LslRoMT3BxKnrm4pcwhdBhKRYIyT5xSnL 9k1QMbDQgk/DjzG7NAP8fAIXYdTDR6gJuAijLo87LUhwwZvJ5pIJW3gBe77vElrYsotWMPZdVzl8 mhfF21cAm09gbvNb/AFY/gD4u9nA1/vyXMTny0v4sF7Dy+WylllwyQN+tuVCiDyvq6GqycHBpRVd LZFT37Q0TrIK6/sFSSeYMIPXMbfqos9IPpGzrGY+qjrAkltUM9iaF+g4HzVj49g/gRQ+N9Tvczbi 1BlDWCZdhJqbCD3/Pmi+bNMCSX1m/D+PhBZQ/rdm8zlkWdaILYr3i2IcI7Ooho3cohjeVsPmzHYl u5ibc9JtawRmuDo/h7erFfx+6L2PB6+h/IK2tOIQuUXO+naEWcc4PB73HxE57C5Cvih9PZOiKIpy SmLpAIoSOGN6OHbqDQOOkTGtn0QqHUDZSywdYAAS6QAegicErqH8ve+K7koyzETBB9PxIasb4Rxj A9dtfIANHw7B5RtqAwAhw6UtYySWDqAcRSIdwBGxdACHaMO0fhBLBxiAKaxbsXQAh6TSAQTBczy3 0iECBKVIKZTbdmr0JgV369IDtPcbko5xIih/P96N+Vh6Cv+rhxBLB3AINqSQSodQBieSDuCQRDrA CIilAwyAbp/8ZYzXMkNc38a0fxri8lfcE0kHcEiIohwpIukADtH/ssMZ075EKh1AUQbmWjqAQ/C+ BsmGkXE7EaogZMWGo6L7IpTjueC1B71mo3D0XrP/A4930qojWUXisPxD9qtjKPcpo6o/dmF9Ih3g RIzpOEF5HnhP6g3odnsIVv2jKIrSw510AEWx+ScAe2evGzUQBOC5U6QQGREpLShxkSYVBYjaT4Lg DSioaLi3SHsSLxClpXFNwTOYIPEApEACHcZj79jjtX1ncrZnvTdftFr7ZK/Hu771T877qdRCUcah bTSst7tWur6+gSA4q0ksEC6Y4HKLSkhRCC1QUlHlbTILWq4SYFA5bdvkucu0yy36CC1IIvG3lirB xAYq+UQhoKiEFras4g+bJ5nF75Z1aJrKJIFGd0UfH/+E+/vvcHV1Ae9vP8CTp2dsr+pCC5JFkNCC 5rnQIldOGPEEyihQUJHnltCiJrcw811CC14ubYu2z4UWKfuz90GZkEOschVauFX2WNtwuTyXB9B2 rZwhy3NJADFEedLrD1mWCi0OQzAxdewPKddluYTU9YsrQgtpWYf0sblvDC4KKv6XgY7FbaKKUubJ h7O22Cq4SJvLYY4ii/Jel7JF2lyPSym2CSz6CC240aFLimEP220/KkECgM0rgF8vskV+ADz6nE1/ Bfh0d5enMAjg9fk5PD89zQcyz1flMgtgz2lYVdFo4kVdLEppRCmjwHkzGHpbboswSDyxNFKKJduG XS4tw6t9wabLWHF/aF+ADQpv7x9tg33eht1sU+LqQP2uxsWRiHEO9WIzx5htfNgHm237tDB9XHlq oD7PCC2WJLcwwotSaoECCyOs6JrfmHVzwYUpL4X6qefx0RE8OznpI7W4zNLLLH2B/kKLNjdS2pJs 0QUXXmygeRbmZ057ulHFHZ8riqIoiqJ04dOP3vWlaP8IpQMYAT1O3cWn/pDQ462bGIo+BiUAKyhe /FGmA1/qjkFfZhiDGIr+7A0UL7LpsT0t+GLwyiTfCKUDUHrzTTqAAQmlAxgQvS5zA73mnyc+tdsh tFcbOBjAGvTadBd4DsdjJDY5DX4jTWLSDfsM2xS/mxFUg+X40r6H+j21CaUDGBBt08PApwHXEukA PMDHgYgS6QCUTiLpAEZgbufOSDqAAUEZlwv3AIo8Pj0LSaQDmBE+tXssHcBMCMGf5ylILB2AoozM O+kABmQtvP04Sx+FY3goEVT93Uosiv1Zgd57KBXYv81V0DIlKLCIofofXiIZDCOG5nUYSeojk/vy /Nyn30Ptwqf7Q2V/sJ9WqcXw+NI3Kooka+kAFMXmnwDsnbFy00AQhldOMjSBNBk6D6Kh4RWYgdDR wzBQEV4AnoGGkldQzVPoAWhSZNKqZahSeAgTLKGVbqX1WYptLGvvzvtlNDrbp8tvWSPJsr2fSi0U ZXv6KkVF7LHX5XS2aqDp9ElbUNHAZRMooCAJBW+jsGI+z6t2LbAolmQWbbvuWy9DY0EjtsAxuUTD J1q5xdIj0NaTyo2oI2f33yW0+Aut2IKEFFxccWsJLfBxLrO4ZW0uxsjZuN1gQbHDw58wm/2CN+9e wquv7+H+w/YzMlsO0SW0aMQSRS2dQMEESigaoQXKKaCe/yn/KmlFOd0UNwu3eZv645zkGDS3hRaU qUtooTILIVxY7WNnCFVosUtcLVLs63gubwcqtBgPaSGFS9u0a6/N/+LKvnJswYSE0EJaLiDxXFzv t+0yQ43pgtDChb7bLjuG0MIBaQZ/D7ogqiDpBBNmchFGrxTjjoyR+cNlm/EWnBbFctnsLhEFWH3o cVtoAT3390kx+iQafLyD8uYU4PfHsv22HPoS4N53gGw2gy9XV1WX8ziGs9NTeHB01MgsGmeGEUDM uRDCEllwD8eE3e6qTE5zGmdVPy6zsP+HvYoBFvNFZjkwhd2BpBrs+eF9VDy+MH1pHBu+WnddQt/l Iv0uZyNUaLEePmbm+J6/j77nZZsWSOIT8X0cCS2gllnkkwnked6KLcrbB2WfSmZh2pXcomzPTbu6 qm5kFxOzn+bWCMzw+PgYnp6cwOX19aqn86ycfsCitGIduUXB5naEqKMPj8e1T0QBy6uwb9UqiqLs I8+lAyiK54T0pfdMOoAyOI+kA+wA/TGgm4RUfJG4AN3e1gF/6JNA/WPdT6JJ9g9c9yno8XtXJFAX nf1sptD2cS6DxRdw3ftW/G0VIb1vCJ1MOsCAxNIBBiS0fYKPxBDe8RA/6MqkQ4xALB1gQFLpAEIk oAUBusDCKymbMrkoG4PXG1Jot+mQrj9k0gEcIZYOMCB6HhY+ob1fzaQDBEBo2wSSSQdQeglxe0ul A2xILB1gQPS8RSFeSAcYEN2u1yekayeZdABPiKUDDMiFdABF2TF43h/K9xjpurQkPp8fkEgzBn8l ALgNJNIhFGfA/ds36RCOQhILmnyCxBsJ1N8bDOU19vn4sSmxdADFKfA89APo8XtIQryuryhjg+8r 9unYrHjCPwHYO2Mdp4EgDE8SCUQinRD9oRRIV1CC6JDuDegpEB0SFU+A8gJIdFdeHiE9jWkpqHgA V7wCClIwHntns95sOB9Ze3bn5rNWdiJ7/Tux7NhJ5lOphaLEJ1Q96v1NC11dbWCxeNSRWCCuYKIr twArpSCZBYkrqPliC5RdUCMxBsks/HW643zYv05IW8jrtkILklngNEksSGhBIgtXbOEKLn57ogua l8bUp7uOMLPZBLbbH/X7BvDx0zu4ePMS7i3uO1valUPYwRNakGQCBxJPoIwChRaN1AJaUQUO22pr m/vYzmNEFrScK7TY0eAJLRqpRdVJaDMrdxQVWqTffypF2jlJqfj/kP2q0GL4PmL1xb18zL64l4/V 1xjbkaJgImUJBOf6UxdQcL/WY+SI2Wdu855KikKL/+UW67GiiiogIHBvhhypex5aLjif6aARXEzo nsW+f3rOhDqUWYTEE76ogp7zbzHQfG5J71Cfx8QaLou6mxcAv57V0z8BHnypp78DXJdl056encHr 8/NmbP0YrszC2W6qKO5PV6bAultZHMUUE1McfeqIJf5QMfZ/jWEvsfBlFq7wgvLSPADdfI05lbYF 9kXjp+1GWrOqrXruiT18/LcxJikX6k85G6Iyi37kmNlHwjaE6LtdE3NMs6cCOvYaoQUdb6dGeGGl FiiwMMKKY493ZtlGcGH6q6B76pnPZvB4Pu8jtXhSt+d1+wb9hRYhx1EVaL7owhVe7ODwrOsKL/zp g5f4yPOKoiiKoighltwBIlJwB1CisuQOMAD6J+50kfjnBP2ReH+w+Cb+eQ8lCyvI90/HuYFFpdcg qzBPauC+vYJ238am+/Z4rEHeuUVSMSXpFNwBIiJJZFpyB1BEfuYouAOMhKRzUMkdgAG81nrFHSIh 8N7QBmRJ0LCIlyRpUMEdIBEuuQNEpOQOoAyOpOvvr9wBhPDw5lmyo+QOoARZgpzCtkSO8kRJ5wEp 1wjK6Sy5A0RE9+t+SDqWISV3gEy45A4QkZI7gKIMzAfuABFZcweA9rcsWAA1x+spOme/5QxxIpL2 Z+U08B7ahjtEQuA9EfoOrwA5QndJ1xp36fpS0m8klDisII3PcVKQ+D2SoozNZ+4AihLirwDsnb+S lEAQxlu8q9K6xBfYEhOzewSrCHyAM9Jwy8zY0ERDfQrvEe4NLrsn2ByjyzfZc70FaWYbhlnYRQR6 aPpHTQ2ww/ABw78F+gtOF1EU5QhN0aLsMIQfsvTmVEWLxetq4ESAitmEMbIozSiof7dLCmMLY15h 0nZbZ2yR5OWxn6Yhc4zcDCGh+U0x7tKhZjSjKI0jbEOLasIypXHFzup/LEwqSuMKzLdgDCy2zvAf KzfTloYWZZ2nDC3Oz4Pc0AL5cf0ZLj+9bWVokaSWkQWZWJCRRZrbURTmFJh+gzGteEgfYJNu8pwS DdtGF9iRAQbWi/W5hhbUqaGFp3Cveu75j4kaWoyLL0Huh6xrjHq74JMWQg0t+p2+T3xaFjW06FbX 2PObgqFFW3w3qpiioQVnnb6UHWL6vuv2fBr3fvWgSJqWRqNUzpruX0ALBTTDwC54EphA4lZX+ScJ oOrGYA/TODtBw2914+vK1c3H1YNgSPEFwOZjln/PBt8DPH8GsFqv4ctqBVd3d3Bzfw9rdOgEs1mS NHXWI+SBz5PclLPs31npcZ+KcWCijNvjEqd8qzxJjs+HdNXoo3+RCtOO/bC9fAeR063ldrHL/S95 W/I0UL/P2gg1tGjHFDXbTKEtdqHtcrklCkOLfX9AphaYk1FFEFRMLWj4zPntzC23r6PpdPXy4gIu X7R69wSfqbimFU9rxh1LTeYV7tnOPgvWyT72HEhRFGXuRNwCFGXCSHrpPeYWoPRKyC1gAKR85CSR iFvAANxyC5ggMZiPjl9l6ZpVyXzAYOVX3CJmAJ5/lqBte0zwGltSIABJHzjPASkfcUtrd1K2y5SJ uAUMwBzalbRjQcwtYGRw+33lFuEBGJzrG5jrcVonkvZfSfvpL24BHiFpu0ra35R6Qm4BPaLttR8k PfskYm4BSi0Rt4ABuOUW0AG9blEkMsUAz01ou25HyC2gR9SorT0ht4Ae0X1dkY6k91p+cgvYE3ML 6Ajef+CHaFN9HwTP0z6YGOh5ww8wELGke4+u3GTpHZh9ewlmH5H0rnfILaBH5nLsiLgFKF6Cx+sl twhBRNwCFEUAPtxXKMoBfwVg7/ydm4ahOP6ay9BeesfBzGCOkbl3LBzmj2AFFnbgL0g3Ro6hK/wJ TMz5A7oxself6HXIHWlsLMnPeVaVHxjZT1beJ6eznFTyV44bJ26jj0gtBCEsvkmM3u9rdHX1A2az R6aOEotNvWzdb4UW0EgpdLHSirIpKLHQYovVam3EFvRxFGOgzMLdJl2OAzcsTi1o61ooURRUZNFM PVjLJrAUjYRiI7S4M5IKv7jCFVus6vs3S9qPrRc7hRanpwDL5S9T//rzEp68fk5GdV8OYcQRHqEF CiaM0qIWUGixhVFS1EILFFhQuQVdR5GFXup2pn35pxFkoDBD33B7KLNYG6FIuZFbiNCCH+5dz7F9 rjGL0GLY7cQyyX2fffXRb2zih1B9xjquVIhdBDFEX7EILTi2F2P2Lm04ZBCxiypiee8iQovhXytj ee4jaXOI3KIs2uLGfVIM3zZRYjHRN5RbnHjkFttkFgD+6bldccW2abwnnj7AaQeevlxmAOsXAMvP 1cOfqtVn9u5vSsGb62sjufh9e9sMnQougKz7JBVYx6s4PhHFHZVUVEtc37l0SqtfR3hBBRf3JBwA bQEGOIILHJ8z7n2Ciy7EPEl/zNkQEVocxhgzU8aefxtdx4UyC1Mn6ydERtEsq0JlFVNHXuGuY9tG bEEKnu/Op1N4fHZ2SNSnVbmAttCCns12iSwmO37Wd4akZz3cNeDUffIL7y4+ZHCCIAgJkXEHEISR knMHCMgNjPeLboKfjDtADxzLF2rGSM4doAfkeOuOAhEADMkX7gBHhAI5todkDvYLzymQcQcQ/gnF HSAQGXeAgMgkXnGQcwfogQV3gAFIaXLSY3wt+F6VB9whGNGT4LwCe06bQzrnaJecO0BA5FqKRX+O Sel3d8EdQOidnDtAQBR3gARI5VoMRaRL8ZLS5xVkwR2gAyk9D4o7gBAFOXeAgOj/40lpMtg+kdey 4ySl512uqQgp8w7SuVam/06huEPULLgDdEQfCx9gvMfEnDtATSrvEXPuAP+BlvW85Q7BiL7e9rEq D8Hui5QnZX7JHSAgijvAQGTcAUbEDXeAgZlzBxAEQajR/w+luEMIgo+/ArB3xrxtAlEcf0o8Rurc Jb0sHdqhc5fIHyFb5m4ds2Vspc6V2q2jv0K/QTIla6Vk95atQ5QqkhNMeeCD47jDjg28u8f7RQR8 Bu6PDfiM8P1EaiEI29PWaZF+7jQbjtet6PDwbaNjO1M2UYgsKhmFnk6SZSm2QImFllmgxMKcfn5O crkFzo9lehktx8jlA0tdX2w9ObuEFmltutimQm5RSCy00AJFE5XUopJPPDmkFYW4oj6Ygoum2KIu tEhWMos2oUUCDw+3+fSv6+/wevrO2Kq0Mc5lEXnnioZMYiW0KHUTWf2lkEILLdJKWoESi8f0sRRa 5H8otjCFFumiHJ7AElqkldCilFqspB2mzMLMLhBA/dKPSWjRN6GLEoauh7rz9CHW1cd6QxU/hHDc hraPUi/f17oo6+YitAhRMEGdPWS5BEWdfW8DZQ4RWnSzfGjzD7nM2lV6RBWrh6acwBZPer/3eoq1 3CIfa8EFOAQX1QJN8YQtqrDlFnb33eAoa1uHr0xv1342OgL49zmb/pY9PAWYTABu7+/h/OYGTq6u 4PfdHfxdLMpFbMkD/rfFEbrMFlrUyrJ5zLKlY961Y4fMwq6nJrSwhBe2zGJpbZ++SlUOG8gtNt2t Q+6oP+RsiO5cn3uduxJjZpvY8/vYZrvsJWpCC4C60EKLKvb2atIK/XhiPTex5zMEGbY1Ajk6OID3 rza6l/gjNKUU+46ydZILl7zCpYECz/yul9D30gqCIJhwufG/DUUdQBAiRVEH6BD5cSw/FHWAHhjD Z3KMqGx4Qx2iY/CHOnJe3J05iABgCPD4O6MOMTLmUO3bP2F8P+4bCt2ZAQc4daozBri0ATjtd3Pq AALLNj/C5XhvQ1EH6JAxvF8mX7PhA3UIArBtjd8fsa2NneBckKYZBkUdoEPGdpz64NQOk47gx4Gi DtAhch7aHU7nMM2cOoDg5YQ6QA/Edh4SGZfAEU6fZbGdUyiZUgfoEHnfN4fTtTN53wXOcGr3z6gD GMR83vhCHWBLUGpyQR1CCAL8Lj2jDkEEHgefoLim/AP439OtqAN0TMyfHS9BUQeIhD9QXEO5pA4y IHjfE6e2KSVT6gCCEDkz6gCC4OO/AOydP3LUMBSHXwhFZtNkQkOVUUXDDAU1hTlBrsBQUTKcYKGm 3i5DjpAjLAdIQUNIp5wh27HYWPY++dkRjkMkP1l+n0djabOWf/Z4/C+JPpFaCII/XIMXfbhvodXq Ag4Pj6s6SiyaemHrKLNAEQWWWl5R2NIVW9SlIKKLRopBxRm4HjqPnyFCi3xXz4HKLPJ8u2tXQyAS +QTWf5M5lVW0ZRb1z/AzVz/b3TpRpuHm4GADm80vUOo5nP1cwbNXJ2Sr2kILFFhUMhIyodDCTEY4 YUQWZqpEFtCILMyEEgv83LbJd6zQYifDoKIMM3VlGpVoo8gb4YYILeKAe9fPTWgRct2xixLGXk8s g9yH7CtEvykLLWISQPjoj3t5n31xiiRC9cW57hgFE1MQWvjui2ObRWiRrtDiscQmqIhdaPGA5fpE FUVLXHBXbmGXG7A+lFgYwYWVW+w55Bb0zRMdqrvbdgkt7hvW29WHS6LxryHADUcAf94AbL+W9U8A i5f1x9+0hveXl/Dl6gqub2/tbqGCCyBtK5CAu2ILl3hiSwtKKso5tnvnjmL7zfPmbRIKLUim3FFv yS6gLbzAt1MusUeXPrlFzKKBmLMhHPli3ycuppiZMoVj8X/wtV0os6jqpL1HZBR2XhYqq3jakVd0 27isFVuQgvkX+/twslgMifqiLK+hLbSgV7k+kcWTnu+6roj0Koe7Bjp1l/zCuYuHbJwgCLNgDn+8 m3EHEISJorgDeGQO57q5ccQdIACaO4DgJOMOEIA1d4DE0NAIAD6DCABCsIQ0z/uxo6GWLiiQYzsU Zv+mcGwvof9dppS4SiqkNHib5g4gJHnPb/5BP/VBNgwZdwCPaO4AI6JguoM6PQZzT62gfn7UnEFG RnEH8Ii8Y66R+zBhSphn7pTkZXIeEoTpoCCt8w+y5g7wQFK6b7nhDiBEg+IO4JE1d4AJobgDeETu aYeR0jXMoLkDCEIgVFlOuUN4wvw9yAV3CIJcL8bnHXcAIRrOIS1B5BC+l+Ut1L97PmdNMi4p3XP+ 4A4wIhl3gAlgjocM6ueQJWcQBj5yBxAEYfbE9mwpCC3+CsDe2eu4CQQBeHS+7qQoTerYZYq8QZRQ pT4pVXTFKY+QKq2lFHmNy0OkJ0V0Xap7ANJEV15xPylsHMYweFgWG1trZneZz1oBXlgGjM2PYT6V WijKYWxLVkR1H4vyZldDs9mrVgI7LpvgMgvqL4UWeS22KCUWTZkF9eN4OIxdElpgHU27FiPkND/p 7Pf7sE1okVfrsC20KOs2cgsqJKHY9HOBBZdXmN0FG6cUW2yEFutUh1W/fd1iEq/J5C/c3/+Bi8v3 MP/1DZ5NX7ClaibDJFlEl9CillkwoQWVtbwC/tUCCyxPq6eW4KKWWVRCC2yLt0tiiyV7caGFLZmn IoT0qlehRRhtD4FvsoBjoUILuTZ9EkC4aE96epdtxSK0GGI5QhVMhCK08FUu4Yuooi8hCC32QXr+ Ltr2TVARkdCiMZkhrrDWr/gZ8aox3T6Q3GLdJcEFe1Uj8Qna4omuYbOYqb9tUgxbG3zeYHkfU47P AB5R9fq1GPxQlGL633d38OXmBs6vr+HH7S08LBbleoJK8lD1kwSCSyKWrNslt1hW0gn+Xm4Zd2e3 EmNwacWCtWfGkRt1psyiMcyXky/vDrkF1fqcpN/n2AgVWvQjxJg5ocffhROZhWW4FloANIUWJKo4 OWlIK2j41Kg7NcdjggxbZq+XZ2fw+nmvvHJvoS2lmFje2yW5sO0FbXtJ6Bjftgq7Vq2iKMqYiOmG a0UZkkQ6AIdk0gEozonxtz2TDkCxci4dwBFIpQOIlAzKB6CmRfkMmmDIJfigbIzfxVDAhNhzKBNB fgLdtl2C27Y+SKgohxHT+UAqHYAS1fUPIpUOYCCm0gE4ZEwJmq6kAxiY71BKEOcwDtmMyTvpAByS SQfgCXocpoRETNsrXo8Z437ENTFtE0QqHYBiJZEO4Aj8lA7gAGL6zo/pnFHZTkzbdSYdQEDEJErS 37N+TKUDcEiIxxCK0peY7mPBpKM+XXfIpAMYGfg/RiYdhOIFCcQj6+kDXnPFe+ESGOc1tpjOL8d0 nhHT53YMcJ+WwOa4JoVxnZPgf/OJdBARENM9DooyNFfSASjKNv4LwN7Z8zYNhHH8iZqhhUrAzpCB iZkP4K79CkioEhIjYmcJbJUQ6k6HfAS2rt07VULqgtR8A4TUpYI4+Hx57MfHObHg7Ods/3/RyS/J 2X87dvzS+n6QWgAQBl+jRW92VTo/v6D9fSvRZIlF2b+ujGexBcsoTLHyinVRXLGFLeX7si7LLEzh +chuvMim/Hzj0s0ypGK8K7TImzgkK5xYVcQUpbCCJRVSYOEXXZSf/SXEGHYeZvp17O1Nsu/nG93f /6D3p6/p+NMrevjkUCxVVQ7BQgsjj3CFFkYywbKJXEAhhRZkhRYsrXAlFtyfd43QgqpCi/y1kVmw PCN1XzVCC6CI9uqH0ALTbmsesU8vNDEJLdoAQov46oecFoQW4xNMdD2/scglYhFEaIo1tOUTbYod ILTopk7Aeo3kFo7gwr1ebgJLLIzgwiu38DWzXSem8DXhLev66tW916TZb3mX7DHRKsnK52z0W6IH z+3oL7e39PLqij7e3ND3uzvTqnr1Ls5mPbIkohBIiP6tgguycovfQlKxyro8vLXr1vfMKxVl5cmX uv0su6Cq8IKXd01V8YV/o5hEe1ofu0Qg3386zqgxz/+lj5ld+p6/jjaWi2UWeb8YnggZRdHNipRV TB15hTvMdQuxhSi8nR1Op/T04KBJ1GdZeUFVoYU8ym0TWbjqpl2iC3kk5FVDTr/vKOhdxU0WDgAA BoD5Q/dMOwQAPWSmHSAgY3pYAQAQlkQ7QAtcagcYOOZhqDOyx1EIAMIx1w4AchZUbttjetivTYzU opFVFwBQAY14gZAk2gFa4FI7QAeY4yd+C/rHCY2nAYDrrByRXealahI9htaoylj2013MtAMEBN/p 8BnS79BSO8BAwD0Y0BWJdoAW+Kod4B8Y0nEA5y2AGdJ2vdQO0BMS7QAB+UlxNZgeM9jXAegH77QD BORMO4AH/E9Kd8y1A4BoWGgH6JAPZM+5Fso5NME5Z/8w97cfaYeIGCO0OKG/rzvnnSfRZa4dAAAw amK8tgSg4I8A7J0xbtswFIafnARdAmQLslUJ0KkX6NDBvUGWDt06du8FMvcU7hV6Ah2gyFJ0dw9Q IFkaoI3E6lF88qOi2KlL6VHU+wxBpClSv2SZlijr/YfSAhRlgmwLUkRl7+rp9a6Gzs6ePwhU1wSv 40YWjQkFT5dl1ZpTNCYWvpkFpXE5zOMcTS2a+lVrjkHGFrSu+IN+9YXuq1iZYYYWD00tGoOJ0uVL licjisbcIsvumUnFH/f+77aczCt4vU26cnky0Ojn6GgBd3ffbPrT549w/vZVZ0t9cwh6kXkEmktY QwtTAr1aQwtmREEGFWRq0aZZngwsaI7teEYWbB2Ubg027HaaNs31K4LMcferoUVcbQ+1jpjbiyGA 9lTaCdleTAYQIdqTrh+yLTW0mIfBxNja92k3ZnMJqfOXWAwtpM06pI/N/9UQo0HFvzJBQwu/aFOY 9QwVGWcimlkjAtMux9NPxdpYmKZu2x7TZjLj66URKhoW4asynfKHK/Pb6bbL2+T57vLdugd18gXA r3qCnwCH1wD3XwCub27shHy4uIA3p6fwbLHwVoPjDra5ettLl854ec8mLQztq+YzQMMIHtmc6lQu X7H3Mei6qSo7t/V65lS36wHSp6kNFs+2w5ZT3r3nYTbHT3e8rru7JYl/LFFG4xT2S5cpauZMXf9j DGJmAX73T/0S9Um2D3R9HZlZVHW/XNX9YmtcUecP6mXQzKJ0aWtuUadLl7Yj8liO7ThjH94voobz 42N4eXIC329vd8nGey1fwTelQHOLCrYbWxg270rIepbp/sQA+N0t7+Z37VpFURRkLg8K4p+u19Ii FGVCpBYYsJAWoAQnlxYwABqMJD7w/CG1B4Dw4laPtfFYuekSmofZ5xK8dQjwvAT34xQDZ6XIyk1L aB6C02N7f/B3Bo/tlbAORZkSS2kBAdEgXvLgOX9K4x9EIS1gBFIKsjGXvgDHG+fy8DIGwrmSFhEB ubSAgGgAtQ0pXf+tpQUog5NLCwhIIS1AiZY5nEdOkUtpAQNQSAvYg1xaQED03p6C5JDWvetCWsBE SGkMTPuyp7OUFhAQ/dyVVEnp/tIPiPO7ippSGouMFbyfsZYWoUTBFaTTr20DTenfQ5z93tjk0gIC UkgLGImUrg9Ds+3+fAHN+c4c+jgEz5+WMJ/vRWhS/J7hb5/eS1LGYA16baFEzl8B2Dt73aiBIAAP lya6KBKBgiZCLpBSIiE6mkPiHWhDQ80jXMELIKEoHTxCKhqaq+koaaKDZ4gooviM57zjjNd2zsQ/ M17Pd1qtfeefWdu3d9lz5jOphWG0pyqz1PtdK52dXcDBwaOCxALJphM2TXILyEUWWDJ5RZIXX2yR ldvX+bpV+0Q2LOGiPvx8UDxrIgktuMSCyyxIchG7+Rs3HTMpxa2oYrO5BhJVAFy757nggmpaJva2 SfurZn8f4OoqE1p8/v4Rnrw6Ya1KSjXJIlBoQY+tWCLJahJPoIgChRQkqMB5lFeQrCKXWeBzbp4L LXB5rEmOsX2k0yS0oP3lUThpBwku/DYYQmg4/EPHEKrQok+0Jike6/Y0XwcmtBgOaSGFpmta27m5 L1r6yqEFExJCC2m5gERbtC/Xdp2utqlBaKFh2bYMIbTQKM1ou6//WK8kquDCCS4zrRlu2Sm4SMrL cVlGXj1IiutUySuqRBVezLXL0VDH7I5t8DTgNe2AxwA3b9L6dVr+AMy/Afz9BXB+ebktL46O4O3x MZwcHhZGfijhOokqgCVgB/Yabz5lO9++5pK2b9y2ZjTvakzS7ssvmtT8UOeHz0sQD7RdFivJLoC1 jeQWhcPIBBdVh5OfgiHROX5YZOgYx3BMqhhr3MTY469jiHZRn5T3Y9R3OaHFjOQWrg/LpRYosHDC irr52K27FVy47SVQ/KiY7+3B0/m8idTiWVpepuUHNBdacGcRdxf5xRddcOFFDGXdE++i/enSIa55 3jCM6TCVG7LxxkJLgGsYzQnpZtzf0gEYvRDiPxbYzeL6OJUOoAfs+5AMF64swAQAbTgFu4a1sYLs usayBLu27wtKb75KB2EYIyKSDqBDpjIup5mFdAA9MJV/Rg5p7GoqfQF+5wkp+WYVOA6JCYynck53 EdL7dC0dgBIi6QA6xt6r4WP9kOGzkA6gB6wv04cJ0/UQ0nj1WjoAQwWRdAAd8lM6gBERSQfQISvp AEZEJB1Ah4zxO4RhNOGDdAAdolVGbf1H/+DfelrPvzEsKKYPqV+r4xNMo51NeS4dQIespQMYiJB+ 8+iSd7D73stlWr70HokelhDm7yFD8FA6gB7Az76VdBDGOCnkoDKMAPgnAHtnrN00DIXhG5OtA4/Q ZOTwCgyZWaCHiY2dB2DkCdgZeQQegMFM7cTSw56OncrQQ5uS2ORaki2rdpyA7Csr/+ejI9mW5N+O EyV2fP+kuwoAwKItkpQdu+7tNr3o6mg+f/ZoULHNJpSRhTKhsMubTVaaUygTi7qZhSlzPZ7nnE0t VPusNMfgbfEy20SjriOkAe9QQ4sq5bkymqibWHDZmFOopJazgcWDnufyShtcPJR1q/WmrWtu0WVo saHb259F+fPFp70MLXjf2LTCNrTgedt4whhTlHlemVjc5/d0l98VeZFI5cV6WlXmFmxskf8hM5Xm FrkyzSjNLWBoAXYBQ4vw+w8lSLskIQX/77NfGFr034evvqTb++xLur2vvobYjxANJkI2gQhp+0Nt c2yGFpImJiEYTwxpaNHntkIxPvG1nQEMLerNdl9Psa+35Hpyy/tomegp2U5FPklUIHJreuyyQJUL Q9d8U1hvu07irGvrk6iuwzXZ4JDkc6Lf77f5R6LpS7X4x80Nfbi8pDfn5/Tt+ppWWVYeitLGVB9L LnPg9EynjZXbac1p28/aLNPtTOJ+11bdja5/SG63zRwdbjnT27T3w55Xx2tSj7y+43qdfaWsb4pz LXATAQmNoR+TJsbwWnYxdv1NDPG6uL2Xhha6nBhTC86NUUWS1EwtzPzUWTd16+k+moYY5vTkhJ4/ 3etZU77n4ppWPGlYtiu1jXJNoyC11G86hG2HFgAAjoWFtAAARkZMf3pfSgsAAIyWhbSAHkilBRw5 Kanziq2Uv4sqGSevKM4HhmIgJZzb/wM/JBzT928A+iam9wuCscjzWlpAD6TSAgZiJi3AI6m0gAGY UfxBYvh7MI9R+GyviGnMXkoLCISZtACPIIjucRBTMHOMLwCMh3fSAnoglRbwD8ykBXgG4wBgFtIC PLKUFjAi8Nv6ODmVFuARjGEgVmK6v/RVWkAL+PzoHza0+CUtAgQBnwuxGXTasIHLGcV/r/IQFtIC PMKv71JaxEDE9PvQB+a9/WWPulznqk8xgcH3x3C+AAO+VwMAgOavAOydP27bMBSHHwIDCZpu2QsV aNEtQIAewGNv0LFZcoDeIOjapUPhrUNv0N5AY07QdGgAXyGAt/xRJUuPemYZR1FJPZL+fQIhOSGl n6xYlumIH6QWAAzHNSCR62dnj61osfhBBwdtnwNLLPrlyiyzzIJFFFxaeUVlii22aEv/e9lWijN4 O3IuiUNuMURoYYY0FOWuE1q0y718Qi43hUUVLK6w5zeW2EK2lcv3Yntu9vevabX6TScnr+nbrwUd Hb8Qe7UptGCBxVo+IiYWWjRTI5xgCQULLYzIohNXrOUV1MstjMzCFlp0MgwpymgmW6axFm1U971w A0KLuNA+BNrbnxIILaYllkHuQ65rivWOIaYsDIQWftv7JKZ9gdBi3Lqm3l4qQotYtxmi3tg2IXJo rjOWuiHa+153bm3+p51oW4nJWY1FBlVFD01Ds0iRhZFbCMFFV2m7vMIlqth7oJ1LaPHYOlwZbOnG EdHtu3r+uS4fiZ69aaUTX6+u6P3FBX26vKQ/q5V5WmwJBD++E8IIW2xhiyduuV5Xl6UXZj6i2Nva kFuITK6sXLeqj5+9b06hh6PPTkowQpCCQEAjYwrPi02KmSU5CDlcaP39bpyeWW4hZBRmXhcpq5hZ 8gr7Mbc1YgtR+Bg+n83o5eHhkKiv6vKWNoUW8h1nm8hib0tdl7jCpXUia9n1zuZ8iofsHAAgW3bl ZoScBi0BYAoK7QAeKbUDADCAa+0A4B8KagcZz41Yb0TeNUrqBQAYRPFp5DQwQI6UBLnFWE61AwCQ EDnddIubRnVpZFk59hmW2gEmIqdzwVI7wAScU96D4Xyn9jp4V75vGUpOr9NSO0AkzLUDeGSpHQAE p9AO4Bl8dgAgHXLsw07xu6WcrkXxPRJgCu0AHsG1zXByOp8ttQMkwlw7gEea/4VCfxnIkVPKp7/7 J8V7fsb1Qliagb2/aIcAUVDU5YN2iIA01yNzSrNvIySFdgCP7NL7RaEdICLGvLbPgySJF4h8xjHX DhAAfC4HAICOvwKwd/Y8ccNgHH96h1SJoWLphoRv7NCPUPU2VtQJqQvMHbp06oT4JP0QHTtkYuzA Z6gqMTFR2sLliHEc7OAk3GHfYzv/3ynKm+08Se7y4kv8g9QCgOdjNlh0WHXvhjLMZm8eNTxnyiZM mYUeVlKKspFTKImFLbPQw3qeTC+lFip/2cgx7kUJpV7ecDN3fHKLPqFFWcflElqU9XTZKZGFEk5o icUNaZmFOWwLLkyRhcqjO1tosajLv3XEq5hMXtB0+puurn7Rx6N9+vz9K70Sr421shut1LKILqFF I7MwhRbL/w/iCvprSSyul9ePBBeNzKIWWsiyzHK12GJhfO6jqIUWZrx9DXWCDcK9C2I4ROSy3NRF Cb6XE0sj9yHLClFubOIHX2XGul65ELsIYhNlxSK04FhejLGvkwdCi/XTrQuEFmHS+sgfy75PJc9z 8vXkHbpnNutcrHvt5Wr32o3Yovo0ggsakFuYzXxTx3iftGJo3lCZrvGXVTcj+vOp6p8STT+oyT8v L+nL+TkdnJ3Rj4sL+leW9TZ7kFto2UNbErEw+k7BRVVWV5rbdr9O+9R+p+DCMdwILVqiDj2u19fq eursfMstYhcIcEgOUhQrpBhzm9Tj72Lj31/HeCO0ILKFFlpUMZlY0go5vqVlFsa8rXY6Q5DRtkZI dre36e3OzlPClv+9tKUUU8e0IcmFS17h0j5RR3rXJuzatACAcTOmh3hzbDwAgFDgpWgQM3PuAAIw pvNxKuR43SAbvcGLCXFRkDrnHpN6WRgMk+NvM0cKgrhlVebcAQCQELhfBb7I9bqi4A5gQ+BYkA6C 8m4MR97PHXEHESl73AF4BHV3ipyOvdin+SO4A/AI6lb8IbgDCADq/ONCUF7XQJqCO4A1wHULyBF8 r8eHoHwaTZcU3AEkAn7rAMRPTv8vxd7IO+pEwnFCqFMITSrn9BPuAAIijyGCcE3iQnAH4JEx7d/3 3AFEgnzWek6r7/tvNK7ntOUzGoI7CAAAACAm7gRg79x124ahMHzceEiQDOneQUAfIFN3zVk6dgrQ oUCnDn2BInuQrcisR+gjOFseIFOAAHqDokOGGK5cUfKRD1naJgRSh5TOZxCSdf3pm24WP5FaCIIb toaIbMO+HFrQ3d0vOD5ur3OhxGLbv+76qdgCRRaqtPKKdVdMsYU5ns5LxRm4Hto9xHByC1uze6bQ ou1uh5tCC5RYVERosdIkFaq7FVdQkcWSTLMEXYSBZdWto12+naOjGSyXj/D6+ht+3H6Fy5srOH17 RmqlyyFQaKHkEZrMon4oyUSjsUABBRFaNI+N2IIKLVBigf1NVwktQBda0OWiPKMyHtigpplZiADu t2FKQovQxC5KGHo93I2nD7GsEMuNVfwQw/c2ts8o9/yhlsW57rEILWIUTHBnj1kuwbHO0HXgzCFC Cz/zxzb9kPP0JfA2xDye/m88igyMY+9D89loNBbr2VZuMdMlF9Zmuc1mvHc1++0qtDDHwZ7lmeOR c4C/ed29qQd/AzjN2sE/n5/h08MD3D49Qfnysnl9dcGFKYWoqOxiM8wmr0DBxMocX1XNsL5lp9yC ZFJCi2486GIO+hzrhvVb0zpbzttRCUYfUpAgcOSL/TWxkWJmSgqfxT7EUC+UWTT95PmMyCi6bl1M YQUtc1NmsZm3E1uQgnU/m8/h3cmJS9T3dfkAutCCbnH2iSze7Jl23xYKr6PSN8m25TK3YtpL7FI5 QRCExMm5AwhCQozpT+9TullBEAR/fOYOEIDYb0SeMgW0Nw99r8sf1iTx8xGas/JCIixAxC2uXIDc RCgILqhtgDTiJfhiTI0OIfcwjQZoMpDfgpS45g4QELWfW3CHiJScO4BH1HH6FH5bXci4A3hkwR1A CE7OHcAjJXeAETFG2YBcB42LMR5nqgYgS+4QPUil8VAXSu4AQjRccAfwiGy/3Mi4A3hEGiV3J+MO 4JEFdwBBCEAG7f9WxoA671lwhziA7DOEQf1/p+AOMQFSuJaZwXjF9Gr/Mwe5vrOLnDuAR0ruAAOR cQeIBPXdVuf9+u4jFP6iJME1dwCBnXvuAIIgCDHxTwD2zli3bRgIwwclaYYE6CvQQ4ei6BNk8dC1 QKfOXbsFHTq3nTvkEbr0LToUKJA9QB/Aa4CsReAAUeqTRImkpFiyxRxJ/Z8gUJZo8mTLtkxI90Fq AcB+mImK3tOABASLxctWgjlTNmHKLPRyKaXIazlFKbGwZRZ6mevxYy5ZalE+P6/lGNwXrzMlGmPx K7foateWVzRCi/bcCCyKtICVfEILLUyxxV0lp7gjW2xhSy+0xKJcttvivkqBRjdHRxmt13+L5e8/ P9Prj2/o2cmxsae2HEJPLLTgUsssWDDBQotiqspaZsEiC0NcUUwPzXz7cFuLLAqZRVXfFVpwu2Z/ eoLQIgKk34a5CS189h26KOGp+wklyb3Ptny0m7LQIiQBxBTtST9/yrYkRRK+2pLsO0TBRAxCi6nb kthnCC3SFVrsS2iCitCFFk/9e7BDf1sFF3kz7tI1djA0Ji2xyCizBBe13KKs1E7H7Yoo+sQUY4QW u8gt9OPjzS69IPr3abP8jejgbbn6z80NnV9d0bvLS/p1fU3rPK9335JZGFIILYC4N9a5cyGh2LR1 X5UtwYVbVnWHli3BhRFH7m4zJByuqKM5Rpz5kXG7sXIL6UT7Q4DQYhgxxmwSe/x9SO+X27sltCCy hRZaVJFltshi8/hQyyyMbYduPUOQ0fXVvzg9pVfPB11XekZtKcVBx7ptkos+ZZO7nXrqd72EfS8t AGDezOWmwRQTCADgAyUdwMTgxjYAwFgUpZUURAOpRfhcUHn8fRWOI3SW0gGA0fyg8mZCPrYhbuln KR0AABGQUkJCyH5kYUFKKkmHTOZyzq+kA5iQ1MfmFaWbDAdCi8dR0gFMCMaXG1IaL1tJBwC8o6QD mBB8DwEQDx+kA/BArP8zlXQAE/JbOgAQBCmNizIr6QAiYSkdwISspAOIiJQ+7yvpAADwQErXocdw ro8xET+cSwcAguGLdACegNBiOymdc87ltyKl92xXODn/kvb7bPM12nO6fpWv1VDSQUSGkg4AAACA P/4LwN6547YNBGF4/ABsCAHiNk3CADlCkFpFLuDKV3DhQ6hIlSoGXLrJEVKlSOPSfWoDAnIHGylk mbvUkKMVX2GWnN3V/xELUiK5O3xIXELifJBaANBNXQKiuvcuuyq6vf1Jp6dFYiaWWBSSiUow4Yot WGRhSiGvWJfFFVsUpZov15XiDG5HjofgX2zh1sep+niak/KxxIKnVxvBBMssnjfSiUpiUUkrjMRi W2ZRTct5vM62EIPb4naaODlZ09PTbzt98+sLZeefxFbtyiGsOGIjtDCDK5hgoYVVUORxGSGFFVXQ 31JgsSW3EK95OSu1oEqGYeqRogwzcHsss1jZ/bqu5BYQWoSF9mGA0CKOuqcgNFnAWEBooVdnSAII H/Vpr++zrlSEFlNsR6yCiViEFqHKJUIRVfQlBqHFv6Ddvo+6QxNUpCq0UBRo7Igq5CSLDBzRZKsU oyGmAzGw3MKOWXAhU3QzblrvPqnA24QWXXW0CS6YM6LV53z8NX/7iujVm+Ltm4cHuri/t+M/j4/l rpASCN6nUhTxvN6VSbjyCp7vyi3kckMKizXq2l6J+a78whV1SOEFby/LO5oEF1KC0YR2sv0ubOL9 iWPUaPN/iTFml9jjbyK07WKZhZ0Wrw+EjKIc58UVVshy7MosNuuWYgtR+BydHR3R29msT6gf8vKR toUW8grTJrI4bFm27YrEv6XKg1Z3paq7mrrLAwD2j335w/Y7wh8MAehDph2AR1JPDAgAGIeUHkBm TNLkfXl4K3ZM33yRl/dUPIQFdplrBwAGwee2ecDyh24owTLXDgCACEjpIW30zXRJsc9vuNMOYCLm 2gF4ZKkdwMgstAMYiWuC0KILXLPTI6VjalhqBwBGJ6VzFt9DAMSB+d5JSQDFxJDoto6UjsVSOwAQ BJl2AB7B75/9ybQD8Aj6tP1J6V5mqR0AACOQkgzgm3YAPcD1wz+mLxbrfR7wS0ZpiulNsvo57c/z UUM4y8tr7SA8cqcdwESkdJ8whO/k57Nt1o+hD+SThXYAkZFpBwAAAGA8XgRg79x1owaiMHy0iYQi pUhHFRGKiIonQEhLSQcd5b4APRXiEah5lkh06ZBSUbuNUiGxioSWNR7PzuyZiSfrLOOcufzfyrK9 O5fjS9ZrOz4fpBYA7A9PUPShG17vqnB6eh4UQfgyCzOtpRRrK6fQEgtXZmGmzWeqvJJa6PprK8fQ Ag0jt4iTsTOUHG+PlgbmW2da98OlFnpwJRNcbrHaiCn0oN8fElv8seX88baekVuYvsLLfHS0ouXy Zz/97cdXevrqxR0ZxB2hRZ+skMkkNkILq5voYrBCCiamMNIKJbG4bW+t0KJ/seleaMFkFuZlhRbt VmhhpRatlnZwmQWPHQgjvRkgtEDbU/WRenuxSUloMQUQWqRXP2ZbEFrUJ5h47P5qlkv8b5/S63uq vlPo/6HlIbR4nDoS9SLT0v3XV/j1F1+Uac/TRyyLFVvQzBFcOHILXXA75mnAKTC/j9Ai1MYYucWT bnHPiX5/6qY/Ex281W9fXF/Tx6srend5Sd9vbmi5WunE8d3gXE3iQguioFTCEVys13q+G/diis14 V92/m7J8bPo18zweLtLwhRtcaMFlFnze7ArOcM/1O19ukYMEQSK+1NfJEDnGzMlhX9yH1JbLj8QR WhC5QgsjqpjNXJFFN39oZBbss0O/HBNkDH3VPz8+ppcnJ2PCVvdifCnFwcB7uyQXIUWT/zkFyg+t wtCqBQDUS00PfZSasA6AmMylA4hIIx0AACBLFtIBTAAeRs2PhvQx+T1pKQnYUvsDernTkD4ve0PY t33m0gEAkAElHQNquh6XIiVeI6xJZHcmHUBESt5m6oZqiX9rKmFGSYnLpgLH7PIoaZsiiW4dlJTM HN9DAOTBQjqACcj1PHMuHUBEVDLORjoIkAQl/R5vpAPIiJK2e47HEwnOCAmGAUgZ9b38TDqISOTy Wz+HGHPji3QAIBlKvNcFocU4SjrPqOl/D0vabg9F3Z9fRGxPSS1+RWwvdZTAaNTD8AAAAEDp/BOA vfPXbRqI4/gvFFUt6oKQWECqJaY8ADOMbDwAS9j6GqxMdAkT78AjZO7WBQlVlbLxAGUogsT4bP/s n6+uczFnfufz92Od/Cfn88+J7XMuzn0gtQCgm7aOh9qWne0qaLn8SoeHJ/l0IZWgUjJRCyZssQWL LEwq5BVplWyxhf26XLfouK4on7cjxz74N7mFi9BiS3eFFptSMlFMF9IJKaDgaSmw+E212ELKLORr LLSQZfC2uoUWR0c/6ebmO83np/Tl25Iez5+JvWoKLVhgkR8HYmChhRmMcIIlFCy0qEQWQlzxi2q5 RT5f5pECDJ6Wogwz2DKNXLSRbmvhBoQW4THFjwFCi7DKHmobIZcXQgfaYynHZ3khCSB8lKe9vs+y QqmLpiS0cGXMcow+5WqcF6ELMkIRWmiWuW/efZiq0KIPsQstBjp3UzG0ZmORQZo28sp5V2ZiYLkF yy4qwcWsscLdbr5dugbvElrsKsPuOpxa5p8Qbd5k44/Z4jOik6fF4vOrK3p3cUGfr6/px+1t+f7W iVuaUksU0SaTaEtbll10jYXEokrZdv6Ueey0EXG0CTM4ztZpa56FF3Jfq+UtbXj5kuwYCOU27z4g tHBjjDFLxh7/fYS+XyyzyKfF/EzIKKpxlmxhhUwPbZlFuW4lthCJRR+PDg7o+fGxS6gvsvSSmkIL WaN0iSwedOTtqoX491S7RiJq1kx2LdV4i112DgAQHVN6cHuhHQAAIyCmh97xpzYAwL6Ya2BMHZ4x K+0AQG+MkMQcl+fagQTEK+0AgBdWVHTM8kE3jKAwHWDgD4QAdJNoB+ARfF/VI8nSW+0gBmBKIju0 XY2DBcXVCZ/hkuLs5GcIYjpP19oBBEKiHYBHYr72goKYrkGGtXYAAAAnYhS6jfV7ZqIdgEdw3wKY 19oBeATHtTsxPbeAz92NRDsAj1xqBwDAAMTUNvxJOwBHzP8bptRh+dAY2e9KOwgQBObZpIV2EANg rtO479xNTO3na+0A/iOJdgBKvCf/1ytzfzHWds++xHQfCwAAAPTmrwDsnb1O21AUx08dpC4IunTG GVGnjoglHSt16tgpLFXfoEOlKo9C34KBwQgpW94hXSoGlkqpQCg49cU55twbOzjJvT7X1+cXWf66 vvk7WBHxx/mJ1EIQtoMWJvqSDacvbdDvH1dKH0yZBU7nUoq0kFPkEgtdZoHTuE61V1KLfPu0kGPk Ag2UW7grT7e53GKd0CJd9lcmtEiXy9VApRMotDBlFSi2MMcPxXy+7FmIkW+H8+uFFlH0Cnq9PzCb /Yazr5/g++UIDuK3ZK/0F8oiqoQWhcyCCi0WD8/iCrjXJBZ3i7sVwcWT1IIILVRftF8UWzyS11OK pdCCFsPctDCm4BAf/gxNZwhVaOESX4sUt7U/n48DEVo0B7cEwqdjmnt7W/jyXdm0YIJDaMEtF+DY F9/b7bqNrT59EFr40HZXmhBa+CjN2PW9PBRarC6uJ7igbc3pOhRii0WkCS5W5BZmue7IWEbnzXZ1 hRZmn+sEF+b862zfjwFmP7LpnwC9j/nii5sb+DaZwOfxGK5vb+HffK7JHqjwISViiTKRxdycRmlF Np4vJRba2JRWlPSL4gtzTPOUyS000QWRYaDMgs4D6EIPlHnQc3i02D49O+cLWPQ+9PfclTZmNml7 /ip83i8zmSa0ANCFFiiqiCJdZJHN76HMgqzbM9sRQUbZV3t/fx/eHdaqwXICq1KKXsmylyQXVUom cz1UtC/7CKs+WkEQukmXbt5WD3vG3CEEwXNi7gAWSbgDCE4YcAcQgmbIHcABf6F7D+CEhnqISj1U 9AHkYW0kpIcru84oG96DFDZB5NgWhPWEJDaacgfoMCEWGlUk3AEaRAr6tYMQCyMMoVuS8G1RxZBC Epok3AE8YcAdwCJT7gCCc2LuABa54g4gCEIt1O/MI+4QDjjnDrAlMXcAi4T8m1HYjJg7gEXkuK5H aNeLptwBWsKAO4BFptwBBMEy6pxnSNeX2nQfmfzvYI8hd4CaJNwBOoD6PgvpOo7iF7T3PEbThPRb I+EO0CAh3SNRFyW0OHfU98hRv76i7t14wx1CEARBELj5LwB7Z68bNRDE8TmOIiE0CEoKV+nhCVJQ 8AiIKhJCoqWmpgDRpElDxRuQN6BNT5MmckdJmxzkjNd76xuvvT4jrW/W4//Psnzns8ezp/PH+WN+ kFoAEKar4FDXuLe7Ap2ff6eDA3vOwUolaCOZ2AomfLGFE1mY3sorirr3xRb+53xeW6DOxnfL4cOx 2C236CqP5wst7JBapQad0MJJLEJCC19ssWqJLNw0zen/1HG3se+CLVkuF7Ra/aTb29/04dMbevHx FR09esha1S4sWYktCk9mUXZGMlFpLJyAggktqm4jtuBCCyexcO+rcUU1tiG04HGdPGPtdbbwYVto AUANhBbpx0+lSLskKRX/HzMuhBbjx4gVS3r+mLGk548Vax/tSFEwkbIEIqXl72uZUxNaSEpMUhBP 7FNoMeayUhGfxFqOYqFFe7IeucW6qM/DhM5BDM1jwTpfbtEQXDhCIopdpcL/V3ZBgXj+Z47HRHcv y+HncvQ7oqMnVibx5eqKXl9e0tfra/p1c1M3fe0NC08UsS7aMomQbMKJL/iQSzJ8eYUvzWiJMFge fwPLdPFbr702OOEFb2v9E+g4j8clGJJIyABSFhCEmGLOHA1Cji6m1i4ns6hes/cLJqOoh2XvCyt4 f9+XWWzmrcUWrHff04Plkp4eHg5J9bjsn1NTaMH3IH0ii3s90/Ypldw1VX9PSNS/V2p8xUMaBwBQ xdyKMJ1KJwBA4mi66T2XTgAAMDlOpRMYgSk9iAz6+UH2ocJvwnmkQCadAIiKKUJgfttn0okkgKYH hwGITSadQGRQgEUOjYX25ySy07avzKUTGAmNRX3fE7bdQ9G0nkIsuSWTTiAiWJf1o2k7lEsnAAAY hKbitg5zHDTVfeaJdAIRyaUTAMmg6T/2VLct+yaTTiAiELUNJ5NOICJY14E2NBWAv6BpHWdiexIH c69ZLp0ESAZt18vNOQxtbRqTTDqBiMxlH6HpmscQzP0vz2hcUU1O87oP2xzHYjsJAABg9vwTgL2z x40aCMPwx5IlBZHgCNkyoggHQOCSlpIK09HQIqVAygEocgQabsABUtGlQOIA26WKRIPCSiuDvzXj nRmP2Z+M55sZv49lebL2jF/vrvwX7zyQWgCwO3qHRK/r8dmmCrPZSa/gwZZZqHIjpahaOUUjsTBl Fqqs5vHyLLVo6letHKMRaCi5Rdhu6NxyC1cGU16xFlp0x7XAgoUTS0tooYst1jILvdyVXujlpdFW 03bVu33T6YQWix+r8qcvH+jp+5f04OGhtqX9QgueKpkFCyZYaLEa/k1bmQWLLHRxBf02BBa3f25b kUUrvnAILbhdfX1qgNAiIaQ/Dun1hwRCi7DE0sn9kG2FaHcfYsqigNDCb32fxLQtEFrs11bo9aUi tIh1nUMst2+dIXJIthnLskPU9912bnXuUu+udT211xFVWG3Ycgv7nsS2OVqxBQ9KbnHPIbfQu+92 SShcwotdhRbbjvY6mMN6806Ifn2sy2dE06J5+ev1Nb27uloJLr7d3NCiqgzZQzvqQgsip8hiaZeV rKKe6mKLbcZO25YAQ8/jklsYogtbaKFtU3uvrv5M9Tty/5PUSsktQssAUhMQKFLMrJN6/j5S2i47 qSG0IDKFFkpUMZmYIov67wMls9DmHdjLaYIM1658dnRETx5t9Vz6c+pKKe47XtskuehTMNnzqWd5 11vY99YCAMbHpXSAwJTSAQCImNweep9LBwAAJEVJ+fwAWeezdADgFRbSlfX4lpofb42V3M5ZQAP/ cO4Vjfu7/Vg6AAARk9O+/7t0gBFTUF6dACrGIrRgjqUDeCTnDv1K6QCe4f32hXSIhCikA3hkLh0g Evg6Jafj51g6ORozhXQAj+D7CkD88HHyjXSIAUj5OjOne0g4DgCmkA7gEf7/z0/pEImQ075sLh0g IY6lA3gExzCQG6V0AI+kdq5/KR0gE86lA4Bo4PPMU+kQnikJ1xm78EI6gEfm0gECkdP14Sb4vkFB Ya4nzgOsIyb42Vw8mwoAAGDU/BWAvTPWbRsGwvAFMJAgyBx0CjT0EYrOeYOiS+cAXTL2FQp0aecC XTL4FTpl6OItD5AlSwB36hMUCRInro7iyTRDp4wt6ij6/wxCjGWSJ8mxRMG+D1ILAMKEEg2Fnjv9 X0dnZ+e0t9f8LreRSpCVTCwEE77YQkQWXBp5xbwtvtjCX++2bRLREUkuOn/ZJ4ukeCHBxaNTl9dJ +kCpPxjBRCOdaEQTi/rMEVOwtIIlFvd2eWfX3QXWSZtlIYaMJeOsYnd3Tjc3l6b+/dcXqt6/dbbq afJII46wQgt++IIJEVoYBUUdFwspWpGFLUtyC+dvU2xdxBamj3rpijL4IeOJzOLB7Nf5Qm4BoUWe aB8OjfG1thlCi37HySXJfcq+UvSbm/ihqz5z3a5SyF0E0UdfuQgtNMbLMfZ12kBosf7r1gVCizSv 7aJ9Lsd+KG02abdp20T9ibxi5TpPcNEM67WJiEPkFmZpBRdm6Qsu5m2DpzKLmNThMUKLVWnGnxNc CK+I7jll07f66Y9EB4dEf2cz+np1RR8uLujH9TX9ub1td4sruRDhgy+K8GUSq4ovp4hdurIMX34h cYRkGBJnqG62xcosRHDhb2v7fOAmortvUqIhlxiSgEAYqoTDZejxhxj6cRGZhak7f+84Mop2WRdf WOGWkS+zsG1bsYVTZL8djEZ0tL8fE+rruryhZaGFezaJEVrEii7cM5HsGvLqz52FlnZxzMYBAIri t3YAPcKJd461gwAgU0r60nvJiQEBAGk40Q4gAXyNN9EOAiRhTM017TZdx7vgx1XlwgkU+Jp0WxO+ H2sHAEDGlDRfRTInPT5pB5CIoSUg2oSSPgum2gEkgq/V32kH0TEn2gEMjEo7gA6ZaAeQCSV99vJ9 FCS3Kp9KO4AOwdwBgPwpdZ451g5gTXg+UpLAfqIdAMiCSjuADsG1TTwlzcOm2gEMCCQYBiBPKirn /5MTRY+1g3ghU+0ACuAzYT9qkeM1XWn3MX4S5s4vIcf35CZsyxyz0g6gJ/j7ovwe7eu4Tqn5DNkW +J5paeeAFFTaAQAAAEjHPwHYO3vlNoEgAG9sZ6zCRTqVkitXzgPYKfQI6dOQLq+Q8Uu4Tpe3cOna GrWpKVW5sseZzFiE5XRo7wD9zcHez34MAwIOVpw4GBD7idRCEA6DJiL6VvY3uwqMx5PWBHCILbPQ 40pKsarlFEpiYcos9Lieh8uj1EKVX9VyDCXQ0HIL7izPdkI8mgKPCi2o1EL1pmTivSG0QEGFklTg 9Daxxb96OXu4KaflFnpb3ftrNHqH19c/1fivxT2Mb68aMoiG0KJKLEhkEmuhRa2bKGPQQgoUVOCw 6onc4q1420gu4K8xXgktio3QAjtDaFFshBa11KJQ0g4qs6CxC57AXR0pCS36xndRwtDb4U6ePsS6 +livr+IHH45b336j3OX7WhfntmMRWvgomOCO3We5BMc2+/4OnHGI0MJNed+WH7LMsfgktHCB4aXo lltU8y25Rd1tkWK0oSUWWnChk49XXfHBTPkN0JRU0Gl2yu99xBe70ozvklvoz+flPvkM8HJXjv8E +PhFTX5YLuHHYgHf53N4en6uJBD2XSotfFgRsUSrxAKH63m2kOKYfpsgg8bTJrcwRBdEhqFlFvQz gCmt0DKPznub0M/hwSEDCFFAEGLMlNDFD12E/J3syA2hBYAptNCiipMTU2RRfj7TMgsy78xejggy 2pruy4sLuP60Vw5FbMVtKcVpy7RtMotDNErQsXzbLuzatYIgpEfOHcDAZNwBCIKnTLkDcEgqLyoI guAGfBEmlheQKSklt00RPNelmvw/thcsBZMclNxBJGWCIFBiavtz7gASZQrxJdpHMAFRStf9M+4A HBLrvauMOwDH/IZ466ovYjpnS90rYqrTnDsAYRAm3AE4RNohQfCfjDuAHkAJVKjtT0zXLalKzYUm Mf2uQ21bOIip3h+5AwiEmOockeNdiImMOwCHhPg8KQf1LEw4Dtx399xBJMxeLxwOzFfuABwjCdoP I6ZrzpT+MzvjDmAAsD5nMPxzvNTOkRl3AAEQ0zNGZModgCAIgk/8F4C988lpG4ji8KuohKBIVVEX SHThRbvoqkLqAXIGpK4bwUXYsOEGVcOip+g23eQKVKqEvOsOIcQCgcD1jP3i52EITjP2mz/vsyw7 djzzcxwYx4nnE6mFIDzG1sGQbdnBcwVNJj9ha2tbz1dSCaglE41gwhRboMhCjZW8opiPptjCXE+3 rTqcq8rHeuh0eNoVF8WDHpt1Rf3YFFrc15KJar6STlABBc5TgcUdNGILKrOg61BoQcvAuhYLLdbX r+D6+jfs7X2A0z/f4M3HXbKXbaEFCiz0cacyi1pooQYlnEAJBUostNhCiSyIuEKJLqjYQq3XIov6 +XRbKspQA9aF9WvRRvHQCDdEaOEv3IcjNaFFn3X7LkoYuh5fOrnvs6w+yo1ZaOGTAMJFedzbuyzL l07AY2kffBRMhCC0cF0Wxz6L0CJeocWq+Cao8F1oMXR74OO50xPbU2GFdX1LXPB4WAYqt9BTlFvU Q6uLbwB7t+BdRRXm82zl2JYvElwgOwB3X8rpSbn4EODVW4CL21s4PjuD/dkMvp+fw9+bm/o1I2IL aIQPVBSB8yi/sAovDCnFslNTnkHFF5iDijBQvKHFFeVxuic558sBWvuAwovWPuNyy8VFKsFYBQ7J QYhihRAzm4Se/yli2i+UWeh58vgFkVHMp+VoCivo+NKUWdTbzsUWZMT39+baGrzb2OgS9X05foa2 0MKUViwjuOjSOuF3q2ZLB7C41Wm9xF12ThCEaJhyBxiYryA/zhMEGyPuAA7JuQMIvZFzB+gBH29e S41Yb25L7YabFLmEqv1O6SY9IQ3wvf2DOcfQxHTzsCC4JuMO4JApd4BEifWcP8QOiFYh4w7gkFg7 dhtzB3DMEXeAwFDXuD5xh3BIzh3AEzLuAA6J9X+v0DDiDuAQ1engJXcIwXtG3AESZwzxdXKlCPm7 pZiur+bcAQRviOl9Lefj3YmpfZHj3o2MO4BDfnEHEATHjLkDOCTUc31pS/4fdczl+pKAKKHFa+4Q DlG/Kcu5QwSGfL4Mk4w7QM+ov+UR8LRXU0jr84u61jDmDiEMSkzXlwRBEFbmnwDsnbFOwlAUhg8V 42CiiSuDxNXEJzCGzdXNwYXFxM1ZExMexVcw4QGcDbxDjYMbG4tRsLfltqfXFove9tx7ej7S2F7a 278FCkJ7PpFaCEJ1cAGiy2g4+22BXu+osNCbwpRZ6PFESrFIJRWJxCIvs9Dj+j49f7L8IpVjJAIN LbdwqQpwVuZOSSQywYUptNDtasDSCS20yOQVWFzx8+9HOp20ZUKMZDk9vV5oERfsCt5gPn+Dq+E5 3I7vYa93gLYqf9OyCCy0SMUWSySzwEILLbNYxjqLbHwls9Aii/impRZIaKH6wv1qsQUWWsQJVkIL XLjyL0UshZqhfjhEaOFH303gmiygLkRoQdenSwIIG/1RL2+zLy5Ciya2w1fBhC9CC1flEq6IKqri g9BiE6jXb6Nv1wQVXIUWLgk0GnpP+1VusbAjuOgsO6nYIugEaTHyH3ILs7x3YLSZ01WEFlWlGFXk FjvRfjgBmD9E43cA26dJ8/j9HW6mU7ieTOBlNoslEFj2kBM+oLYvQzJRJLj4tDCUiTLwOlUbzoWz 4PlSoQVkgovsOWIMJXILPO+mUMgAfBQQ+JgZw0HIUQSn7TK3Iie0AMgLLbSoIgjyIotouqtlFui+ rjkfEmQUHaoPd3fheL/SOZ3qqG1KKbYK2tbJLMrkFUXaJCiZv2gXlu1aQRDaRUgdgACuhewE4T/0 qQNYpE0XK7SNkDpADXAq9ucjfUiEV9xQkoOQOoTQCCK2EDgzjIYn6hANwunicUGwDafPzCF1gBai iqwPqUPUxCN1gIbhdME1x++u+sDreC3FcDaHUzEcBcfX6V/g9LiG1AGE2uH0fJVjkCC4D9dzTnyW J3J6H3imDiA4A6fndUgdwBMG1AEsIqK26shrXRDcZAB8fpd4BX+/a3imDuAp6jH3VWQi1MMFdQDL jKgDeMiAOoBFQuoADaHOdeHyWaQI9Xv8EGj/bxwRrpuCEXUAx2mT5EQQBKF1fAvA3tnrOA1EYfSC LK20u812VCgFj0CPa0okSlA6JB4CQQEN4g1W+xq0rvYJkLbc0FLSbVYheMa+mevZycZOJr72+DuR 5djJzHx2pPh/DqQWADQJdSwUmvdxV0WXlz/p5KR6DqqSSlAtmXCCCV9sUQktnMzCiCp48MUW1bT7 XJZ1IgvatCPH/RHqxk7O+1fNqaUWTmAhhRYssQgJLVhQcS/EFssHIgv+rnzvZBYrUfdq65Jk2dNy nf+i5fIvffrxgV5/f0dnF+diqR7KIazYYi1EFvXLSCasxoIFFEJoYV+12EIKLVhiwdN2Xi23kEIL Wa9tbb1yIov6ZTseDAgtwMDQ/kkgtEDdx2pj6PXFZkhCi2MAocXwysesC0KL6Qkm+m5vynKJQ9vU Xt/HansI7Xf9PoQW/ZTRKHcMFLZpQVGFfNsQF3SUW3gfs9zCjllwQQHBhSvwuJSii9DCr2dbN+S7 ZBeGZ0T3b8vxt7L4e6KzC6I/d3f09eaG3lxf09XtrZ3mVWDPbpXLyoKLNQsiiILSCBZaNAQXnpSi 63ibMIPFGv7nUnAhc8r5Um7Bggsp9JByi5DgQkowdgGhRTvGmFky9vzbSHW5DCyzsO/F9BMho9iM y8EXVsgh82UWddmN2EIMLAk5zzJ6fnraJuqLcnhJTaGFL63oIrhoo03i66v+lo2ouWXxtzKNVdxm 4QAASTDWB1UOYU7VTb4AgIrUbnqf4v8aAGA/Uu10CA+lTgsWW/xWztEXr7QDgF6ZE6QtAEydXDtA REwnXgvtEBPE7POnKA4y+36FdogeybUDRCTVDv3QGQ7ItQNEBMcgjpSOwXHdIH1m2gEiUmgHAAA8 Sk5pCd0YIxheaIc4gJl2gIhgvwUYzH08KZ3TKrQDjISZdoCI4L+sPZBaADBM5toBIjLm+8gW2gFG ymdK81oU2J+UruNBTL8fKZ3LKrQD9ERKxwk+X2gY+1oFTeu6sHlebK4dAvRKrh0AAACGwn8B2Dub 3aaBIABPQyNVooeoN1QhNdy5wAGJA+oL8ARcCm/BLU/QVyBXbvAGleCIxKEvEC4VRy6oUmnWeNY7 yfiP/LD27K7nkyyvvfF6bCeb2LHnO5QOQFEigSceepMPLzctcHr6BNrStlVlFlQupBRmJakoJBZl mQWVqY5eXyxvVu0VAg2SW4SSkdWwOhJ7kMSimFcWWyyhkFvcs+l7N10VW9y5eXesrj4uylVRhmGx 1RmPR3B7e23Llx/fw+PXzypb2i60wDFJJUgwQWILK7RwIgoUU+AYRRVWauFkFSS3WMkrmPiCRBbU jhVZsHVwoYWNhwktDNteFVoEyBAPiQotwmq7q3WE3F4ICbRjacdneyEJIHy0J728z7ZC+S4aktBi W2KWY+zTrsTnInRBRihCC8k2d33tLgxVaLEPqQstQvjs+lwe3Pl/VsgnanXs2hEmEm+6VtC0XBP0 OhxnB+vrJdQkzXMV9ZTefB6VD2C9D3gdbKj7F03r4cs+BDDPAX7nA/wEGH8B+PMV4PPNjR0eHR3B u+kUXpycMDHIOuk7zltlNMd96qZtvSs3bV7Vx7HvGNsbsfUaVoeSiuI4t2drL9XRa9k2ZFA5fG4f NCX4rx4eQmUW2xFjzFVS2IYmkt0uKHejditZ30V9CwktUExhRiMwxqzFFfn0IYp08vIyLz/Iy1Zu kZeXrmyvymM9tuPEOtV+aHp8DE8nE7j+tfF+31f58A3KUgqUWxhol1nwOnL2NMkrMjaudpMA5e4t g/oubNu1iqIMhyE+QIgP/WJCu5lwHIoSCind9I5JHfVhLCU2MCGFvm/7B/f7hXQQHYAJUj9JB6H0 DvYh+PDpd+lAFMUz9N7G89aUkjcpirI9Z9IBeGSI1+Ckwd/8qYrs5tIB9ExK165S7QsupAPwSOzJ fKU4lw7AI6l+TnflTDoAzyykA1A6J6XfCwvpAJQowPf8lXQQA2UmHUBHzKUD+E9SknEtpANQgiCl 3zY/pAOIiJSOu55bb09Kx/1KOgBF8QT+v5RSAviY7yPT75Pdwd9ec+kglKDA/iyle65iFvVIcS4d gGcW0gH0RErnCZy3ENb3FPYpH6SD6JEZhLX/lW6ZSAegKIoSCn8FYO/scduGoQD8YheIEeQARYdW N+hQoLMvkAIduhY5Qq9QoO0JOmbwkjN06JIOOUCnrEKWAtkyxY5/WJHik55oJVZsmo9i3icQlCiJ epRkW2FsfgPuAAQhItpGoGorO91U0dnZLxiNyv6GUioBVjJRDxLoii1KoQWVWSgjq9DJFVuUy/V6 uq+RFqhqHLm1PAzuwXA8KJzHOKnQAqUVpWiiTgtbPjdiilJOcW/lFXOb39t1tIzmVGixgKbQYgmP CS0OD1UltPj5+xu8PnlHWlVPuFwJJNSqFFk4ggmjsihiQJGFnlBcMVXTSmCh5+/UXVkGs4bcwogv rNhCyyx0jvXiRIUWKNQw96CdaBuEyIjhkoSOIVWhxT6JdZDivtYX830gQotwcA80HdM9zb2/L2J5 rwwtmOAQWnDLBTjaEvt2u+7jq84YhBYxbLsrIYQWMUozdj1WSkILX2AfkdOfsbaZUkTSsC7ypHVt 4oBMg4OBFT7UU0MjC9C0MuCyO7T4wFnusu4x+wNN7jGRlwDzT0X+o9jtM8DRMcC/6RS+X13Bh8tL OL++hpvZrDp/K6Wq3i5FykxPmJ1fYpmdX9gc02K12jo3vWykLjzGsljnHqfaxu7jxonlirQJ12GZ 21Z6D1EUSSK06EYfY6aY13zP29BGqu1qA0U9Zp4s6xylFlUOUEstWtILZxn3HWJdJOE5PhoO4dVo 1CVUbRl/D02hBf102JQe2vYh9w9uj6cGnPm2T5bWU9ylcYIgJMEf7gAY0APayRf0BKEkpS+959wB CMIWpPQa7BP6WSClH+sh+ofIIkl5nugfcn/lDkIQ9kAO6Q4UJwjCZjLuADwig66EJ9Vnfs2EO4DA ZNwBeOSCO4A9oPvZ33IH4ZEJdwA9RN8DMohwemTcAXgm5w5A2Dsp9bPn3AEIvUC+68DDGNJ67kH0 oKd9Hug24w7AM9KHJGjG3AF4RO7p7qT0TCvXvTtvuAPwiFx3IRVSGgC+7xJneV95Ol+4AxCiY8wd gEf+grwvbENKoiZNzh1AIDLuADxzW6SPEN//4ifwvGSc+u/PU+4ghGCk1M8kCIKwE/8FYO/8dZuG ojh8CEWqhCpGhi4WDAyMTIjFj9IBiWdg68KO2Ni69i3C3kiwMEfqAxSGMlARk+Pr63t8bdOQXPt3 fX0+y4od/7m/2JbjOMn5VGqhKPcjCw5x+br8vgVOT591Fm5jfJmFHTZSio2QVGxaMgsnuzDT7Pxm +U0txzACDSu3QFenL8RzTmjhyt01eyO6YNGEk1AYYQWP35GRVPBwl9jidyWw8IUWcjkpt/jTkddx fHxHt7ffy+HPXz/R0zcvGoUc/cdSaFEWAhQyiUpoUesmtu1aIUX9KOQWVmZRiy64K6qejPTCLsNC C+4aQovCCS1qqUVhJBZWuOH2TCxVNZWoQJ8yUmobXeA79jYOIabi/0OuV4UWw68j1LrQy4dcF3r5 UOsa43XEKJiIWQIRU/tjtTk1oQVSYhKDeGJMocWQ11qxiE9CtaNCi8HXsYvcwogLRCfGd6UWW3D3 YNESXFQzNct/y3LifdP3kV3s2vttMo+JNq+Ifn3YDr8nepSbpy+vr+nt1RW9W61odXPjJBBCDFHe CZNCi2rcDhdiWkNu8Z99eVetklfIx5bgwhNpyHlawgtfeuEJLpwERcgtxDHUOh62+17eMRyaqQoI pphZMvX8faT6unz8V9kQWhA1hRZWVLFYNEUW1fiRN+3In08IMrpOxc9PTujlk51+s/6a2lKKhx3P /Utm0Sev6NIhUc/8XZuwb9MqijIf5vjjbj556x83FMWQoQMEZIkOoCh7oIWHxoe3earXAR/RARQo vP/n9AcrZT7wsf0NHUJRFAg5OkBA1ugAMyPla34WFK/RIUYmpT9ar9EBBiClQihcTGPKxXxR5OgA gVmiA0RCjg4QkJ/oAMrgZJROsUlmiQ6QICmeBzJ0gJlyjg4wEBfoAAeSoQMERO+DK5YMHSAgc/xd 4r7oPbD5kaMDBISvuX+gQyhKIM7QAQKSwv3uL+gAE4K3VQr7XAlLSt/jXaADTJQcHSAgc3pPSOnz IX9WyCne96hzdICROUMHUEYjpfOIoijKQfwVgL1zx20bCALoGA5gR2WqpEnYOK1h5ADWFVznBjmF 0uQI6gLwCDlCKh9BhSu5ch3DhQHGVjgkRxyuVjEt7XKWo3nEYvnb5VAUPzDleSa1MIwaXyIh37xv L3U0n/+C09P6d1q1VKJJSvfcCiZcsUUtsagLCitQVEHFFVvU0+1y3rZOFFf3T9vhdXz6CC3Wafw2 Sr2MZBN/HQlF0UgrSGBRQCu26Mos2nGf0OKpHH+CNsWen5OTe3h4uIGLizP4uZjDu88f2F51hRYk sKiOM5dZNEILHFA4QRIKLrTwiStIbIE1yS1cAQbW1CcJLbjMAodKtLF6boUbJrRIH+nDIr39ITGh xbCkkuQ+Zl9D9LsLKcVCpJLYOVRf0u1DktK+mNBit76G3t5YhBapbjPGeru2iRGHZJ+prBuifezY tLXZp92+bWP1N1AfXFrhXU5yglV33dfKLZAjNlRyC2fYEEnwNOI07aYa7yu0cNORu2nKt2VUd6eR 9wDFVVn/KGd/BXg7Abh7fITviwVcXV9Xoos/RbH+/LgIgoQPrtyCSyNc6QQXT2yrXVnFtrqznUZ8 4ZVZQCuy4G1o/sojt6B5ndLM98kl+HoxGKOAYKwSDs7Y49+G1v16CZJZVONs+ojJKNZ1Wbis4o0j r3Cnqe1abMEKnQuT42P4OJn0CfWsLF+gK7RwpRWvEVz00SLRe1b3zgXgv5N4P+I+O2cYxug51H8e xcR2mXQQxuBY8vhNNP1YdSkdgBEVrfcrTefgWJiBriRnBCa60XqeGP3AJBEz6SAMIxJaE5MbhvF/ ND0r23PasOB9Q+MzP5JLByCApmvBUjqACEylAwhIqok0UkdTQiRkKR1AImi69tpzmH4y6QACYsnM 46DxOpBJB3CATMtyKR1EJHLpAPZkKh1AQDRer4zdyKQDCIh9r/uBv2fT9PfM39IBjIRMOoCA2Llu aCEDPc/9mEA6lw4iAHZ96c9MOgAjObKyfJIOIiC5dAAjJCvLuXQQATmke4KW5xEE3yWnfOzystxK BzEg+N2aSgdhDIKm9/2GYRh78U8A9s4Yt20giKJjxnAjIEiT2nSZIm2QIoWOkDZFAFdpAsOVm1Qu coAcwSlygxxAaQ0EvgLhHMBpDMOwLZnL5VCzi6UsUyRndzRPIEyJ3OVfSqYAkpqnUgtFWQ0tNPSp nD481eDg4E0jr/DxZRY4b6UU80ZSYSUWrswC53EZrm/bzxs5hhVooNxizCrJq4QWtlxfWGhhn1vR BEonqNDizpFUGGnFfH4LS6HFHRFb2OdUYuH2dV9v5yGQ15JlplBWAdfX/+DL0Uc4/v0NXuavyajc B8oiqNCiEVssiMyCCi1QZlFLLJr5ekKRRfVAqQURWlQiCxRa4KMcoxFZOAlqoQUtMNml2KQyEtxv C8f2ucasQotxtxNLkfsh+xqi31gKIPfdZ6zjkkLsIogx+opFaMGxvRizd2mjQovu63VFhRbDrNtH +1je+1TabNJu07ZD9cfUR+u5g8VSTtCIWzcQXFQKi4UpaJ5VcotKcLETkFvQcuC0vDi0LO8iu1h3 8rdpmJT74R3Azfdy/gRg7719+dflJXw+P4evFxfw9+pqKYEgYojqrBiVRgA48wuyzJdW0AnPdvmv 39fCi1V/H7xttAkuQqILZx7zAxFc4Bir/bbjiC9C9C23SFFAkGJmigQhRwip43oKf8SO0ALAFVqg qCLLHGmFeb6LMguybNdfjwgyQofe/ckE3r5aqz62uenHl1K8CLy2SmbRJq8I6Y+gZf3QLmzbtYqi bAcz7gBMmB+CnnKHUEbFfGHPQG/C9ZF0s2rMN7wrm/OfO8BA5NwBtoy8nI65QwzED+4AShScgf1h uqJIYwbb9eNBRVG0iJfSnRzkypCkFCB6DjnosSB2ptwBekSlFt2YcgfoEXOcLbhDRELOHUBRnsGU O0CPFNwBlGSQdH03FaReg/kJ6R97JP0/FNwBlGiQVLyy4A6QCJKOZXo9b30kve96z54ihUPuAD0i 5Xx3wR0gEf6AzGtQqRLLd7wkKbmRAUu9h3xIJH0GDAV3gJHIuQP0zIw7wBqccQcYmVPuABEi8TvG iK1y7hCKoigx8CgAe2es0zgQBNCJiATSUdy16ArrfoCOFv8C0nVXkO7uK5Bo6Gip8wEUfAIVPRKi Rjp+gOLQEThC1uu1Zzdr4hxrz3p2nrWynWR3x7FjhyWeJ1ILQfAnEPI99mtVQ2dnF7C5qX/TraUS ZfK511ow4YottNCillkoUYUprthCr9fP47o6IZxu3/SD593hSzfnCi0ACS2w1GJeSCa0dEJLLWq5 xUspsTCSCiOuqNdNweILV4JhRBlalmFS/PnZ2BjBbHazeJ//wNHpT9g/+g6fvmyjrVqWQxRiizkS WZSTkkwUGgsjoEBCi2IqxRaW0AL+WnKLSnABT5bQArdb9Db/tyS00IkDl4UWQqRQ75qUhBZdE7so oe9+qJOn99FWF+3GkgC5jzbXJbZjlLp+V21R9s1FaBGjYII69pjlEhR9dr0NlHGI0CJM/dhe32ed /yUmoUUIIojJGlfwOS48cgt3eUUHFSM0GblFMXcFF3UFv9zClVa4r10lu/ClLW/KsO6uq5TpXwFm Sot7snj4B8DWFsDvx0c4vr2Fg6srOL+/h4fn5+r9ey3FD9WomUdugaUR70knlKTCO3fqNc2tfpD4 olFu4dQxggsjs8ByC7O7rdKh3GKoAoIhxowZevxNcN2udTEyi2IZrY+QjKKaL4orrMBl7MosyrqV 2AIV83neHo9hR51UV/NtUfbAFlq40op1BBdtNEj4igPO8ntaJOstbrNxgiAMmjtI92bCQ+CV6ERo xggtdoHXjWcfJQNeiQHlBllhiGTUASQG16RDKSa3FZqZUgfQISLsSBuu53BBEPzEkughBKmOu1Gh rhecxjowKV4LM+oAAsLxXJCBvhGeC1ySfPWJul5zOgZkfLlmlzqAgMh+5U9GHUBA5HgV2qL+5vlM HURCTIDXtREzpQ4gABl1AAG5pA5AiAJO46IK+X7Tjpw6gIDIPm8Pp8+77HeBCxPqAALC5X9Kcn5p x4Q6AMEiljGbnDqAgEypAxgoOXUAgUnlmpBRBxCQa+oAWqK+N6X022QlU82pg4gMrueXnDoAQRCE GHgTgL0zxokbiMLw0wZCgRBXsEQVRelQpNDggp4DoAjaVKmSmoqKQ5BIHIAbmJYKJA6w3GBLCLAb z3rH+zzMwAAz+2ae34csz67t8W/vYo+89nwitRAEN7iDob162HppgaL4BK4u10yZhS43UopxK6lo JBZdmYUu62l6/mb5cSvHaAQaWm6xiN4Pbesw5RVaaPF0mMss1GtTaPEwK98b4gpTZvGvI7yYCy0e OnU1dY+dW7K8PIC7u+tp+fj0N3z5sQMfV1fQlrqFFmqsZRZKMKGEFtO/2biVWSiRBXhILOqhFV9Y hBaqXrw+l9BiWhahRfpQfzR9E1rEXHfqooRFryeVTu5j1hWjXs5Ci5QEECHqo14+ZF2pdALO5fyQ omAiB6FF6LootlmEFnyFFu8lNUFF6kKLRZ8PUmw7pdS2nNXznKhCywlMwaYp2/TJ1ootYCa00B2a m3IL3D047m4cjOk2gYVLaGGKMHwHc52K1XoTvwLcHtXlXwArm83bf29u4PvFBfy8vISr0WgugUBi iOkVNSyNAOiU8bxaJNGKLXwHJK2wjX1FGo8o1+OkK7fQwo5J/flhwQW+ajjB71uuZWIJhi85Cghy lXBocs/vgut2vRZzD3SEFgBdoYUWVQwGXZFF/XpJyyzQtCVzPiTIsB1qN9bW4PO6Vx9J3+CplOKD 5b3nZBYueYVNdwSO+W270LVrBUHoBxV1AEK4PLgjuMFCC8U+pPPACDUFdYCA5HLTu/A+OHYAuU0d oEeU9bBLHSIS0p4RMCfUASLC9cEhwQ/pZFgQ+gWnzpyG1AF6RAl82/yKE+oABJTUAQLCsS1bUgcI yBl1gEw5oA4QGI7/p2+BUztMMaIOIESH03dWjkNxqKgDRILTdz9l1H0Fh9QhIqF+X6+oQwSAk3Bk SB1ASIKCOkBAzqkDZERBHSAg0qb1h1N7bkgdQBACUAIfga+6x5LL8biiDpABf0COw4KdkjpAQCrq ABlSAL97J7ic216ipA4QkCF1AE/Ub4l9uw//kDqAsBBK6gCCIAgp8F8A9s4gp20gCsMPqIjIhgtU lTc9QaVuyxHKAYqy4AC9ABIL1BNUrDlAF913kxUXqFjXCy7AAkUQgcl48uznkW3sMvabeX5fZI2d yON/QiIPYL9PpRbK1KkrHFT33OlrHV1e/oaDA1tQCaUSpWQiK56nYgsrtKAyiyyXVZjFFVvY7fJ1 uq89lu0fj0PbYXA7LyUWWG7O5sISe/j6U76UkgkrsrASChRSrLfrj0RSgeKKR/JaKbso96FCDDxO u9BiNstgtfqbr//8cwHJ8WcyqmoBRiqLMEIL86gILaAUWhgBBQopjKiCiitwfZWt7HPwUAgtcB3F FkZmYVoqysB1KrQwx88/c9sHHYMSKNw/GhVaxNH3GIQmCxgKFVrw9RlKYWdf/XHv77MvKUKLMcYR q2AiFqFFqHKJUEQVXYlBaNEH7uP76Ds0QYVUoUVIAo1Q5gkD9dMqqgCoyAnqBKF9slG5xe7ObkVu URFclDvUyy2apBVNsou6cuZNZcxfk1uYEurvAR6+bdofm91PAGb7AP/u7+Hs5gaOr6/h1+0t3K3X xfuHMohCG9sgt6iTWRTbz8/trSOraGtduQX2USu3IC2OgcosKttEcJGRsTaJersILmIUEMSYmRJ7 /iakjuutoMwiXyfbO0RGUbSbxRVW0OWdK7PY7luILciCgpH53h58mM+7RP24WT5BVWjhSiv6CC7a RBf0TIFvDTjrbWeKylvcZXCKokTNkjsAI+YG93PuEMpgmJs/zQXsbiGDxfhRguSIO4BHUu4Ayiik 3AEGQtKN6iEj+YYTyWNT+mPmPnfcIRRlAFKQKzKTKO5SlLciaY685A4wIa64AwzIVAvSJNwBPCKx yMYRdwCPSPz5jMGCO4BnUu4AgZBwB1CUnkgqZq7nI6UPkn5vDpnvIKewrYuE/y1J+x6k3AGUIJD0 uU65A0REwh3AIzqn7YYRZx1yh/DIkjuAonhgwR3AIxLm+hSp14n44pw7gCdS7gDCSEDOXMNcB6lz zP585Q7gGXNt3VQk5pL+LhDTd9fMn6Z03fUXkPVZU+qRdi5QFEX5L14EYO/slZsGgji+hBSeIUU6 WlExFKkoCUNeg4J3oIEW6CipqTI8AY8g2sykyQzU8itkJjN8JBe8Pp+0dz7FinzSntb782h8+v5b 1ofjyPtTqYWixKGFhV4vuuNNMxTFs9aiayixQPmEk1k4sYWVUhgiqTBrMotGdmHHuent/KaWYzQC DWjNkY6Y0OLWa9sMdbk6r7OiCyuz8CUU157Ewrb/EqGF7adtO65Zjh1Ol3sTydswm/2Dq6tfy/bX 8y/w+MVTr+Bi+LwUWiwL9BGZBBFaYBtlE05IUT+Hcgv4XUsssO3kFm64mweFFvjwhBYos1itv5Za 3BpPuNG8M7lWllfY3xoVWuiyh1pH7stLTW5Fh1OjQov85k+5LBVa7J5gYuz17bJcYtt1cm/vodad w/rvO70KLcaZh2O+Icjlc8JI26SL3MKKC8iD9HfFSSxQcFHLLR5E5Ba0XDgtPw7B+LA0eay/TYQR m2ZT53gEYJ4D/Pm8aL8DmB3Zwd/mc3hzdgbvLy7g5+Wlt/3MSmCx/IbNSSMAPIFE2A67666dMXc+ 3xizJriIii2g+RaQDnM5DZ0mkFvQ19pFcFHvI6t9YkpMMXPI1PO3IfV1bUO4RTyhBYAvtHCiir09 X2Sx6N93Mgsybj+cjggyYqfTJwcHcHR42CX2S1iXUjyMDLtLZtEmr4hdCaBl+tgmbNu0iqLIp+QO wAwWItAbMuWB72kJ8SITb8eNki0Fd4CETOmmd6U/Un+Qoteg4cHzvqTiZhQsbiv12FD6o9dFRSpS 9+2KO4CiZEjBHSAhUs9dufER5BYaRU65AzBRcAdIiMRzgaTvM0ruABMECyBIKYjkkHic9kHSsa3I R9r+WnEHEErFHWAgTrgD7AB4jvnAHWIgsBDgKXeIBEi6DvzgDqBkg6T9uuIOMCFecQdISMUdYCJI Otbn3AEUJQH4IyBJBV+/cwdITMUdIGM+gZztU3EHEMYJd4CE6P9u+iHttzIVd4ARKbgDJKTkDnAP 8D58aZ+hNiHtPLENJXeAgcD7OST9naMoitKL/wKwd/46DcNAHD4EosDGDEMHFsTKwpYn4AUYYGDh Edg6MbMihMQDsDCxZuEJWBAsHXiBCgakiD9xkkts15QEnJ5zua+y3DbY/bVp07Ql94nUQugzroJB rutOfpvo8vIOVlby/xVFqYTqUTKRX/9VyixQRIGtElfkzRZb5Jer5fpYvK3qdszeP3WEFmUJuqmW L0PZhC20UH1Sii0qaUViiC2q63BsYsksPmoJLQaDCby9PcHe3g5cPV/A+vaGdq9MoQUKLLL1qMss CqFFJrNITyih0IUWKK7IpBWFuEL1KLIoJRaWAEP1OCcKLfC28JSJLAqhhV0UUoQWAdPHVcNVaNEm IrQIq2h+m3OGNo/P+UIp7OxrPurxPucKZdvYJ6FFXbosx/jLvBSvi9AFGfOUCPiYsy1BBPVz878Z QhRUNIW70CKE167P8b7naTCX6zsJYznKCb5MEUZTuYUC5RZZj4ILcAguqgFuuYVdmtz+W1to4Spv XkdsATCdSZVU3wR4P077s3TRAcBgGeDx9RVOHx5g//4ebl5eYJIk5eP3WYgf8Bs31T40QcRPYguX eEJJKpy9NWZWb8stcA5dZGELNwyhhSazMC47BBe/yS3SJ0Ewu7Z16bo0gYOQwwXX++UblFlk57XL C5qMouzTZgsr9LZkyyyKsaXYQmu4ftYWF2FzdbVO1K207YIptLClFU0EF7NEF/o7Az40YJ2f9c5g PMR17pwgCJ1lDP0+uEz9mH5NHULwCgotfiqqpYocRvMKEzCcDpCVg1b6Adf1HFEHYM4Q8gK3XBlR BxCCJKYO0BIxdQCBHK77AoIgTCNFvIQmcC40qlCFLWPqEETItiBcVJEvTvLImDpABzmiDtACMXWA QIioA3hGPkfyZkgdwCNSzLw9xtQBWoLT77yhck4doEVG1AE8MaQO4BHZZxEQTtv3mDpAR+C0zhWy PatHRB3AI7LOBQ5wEvjeAr/PwbKdcTMB3p9bhf/BaR8zpg7QQSLIj5XhREwdYI5w+g1+TB2gISPq AHPmEHh9vyq4EamFIAi951sA9s5fN2ogiMNDSINOQhHtFVh0FLRIFEjpKXgBkFxBm4IHSMljXKgp eITUaXgBCkfiASiSIsU5eL0Ze3e9e3Eua8/c3Hyn1dl39vln3/mPfPZ8KrVQlCFuQaFPTXt33wjL 5StIVfpDiQVKLkxbr+uu9ZKKeiCz6GUX9j0cHj8D5RgozEChxnRsElrYUnNxoYXtN7IJFFoY6cRQ SoHPVmbhCy3653D4UGhhu+vkXNgCWBVcX/+F8ssH+PrzGzxfvnDmyn+0Mgu49YQWndTi1pFZuEIL lFncSSy67rtm+tsGN14/Ci1akQUKLfDRLC8zTTdDTGixTVFIZUY4fDVzZ5AstOBQbJnLNDh/Hof1 LgXH4sW5Po/bcqcuNM3pN009fi64bCvnFkxQCC2o93cU88J9uG3HocwredjHMofQgqM047HTkiS0 yAWD440xcgsrLog/xoISCyO46OQWTyJyi1BYkRJchKXKNwkt3PdcucUYyUVYxnzRLJe3ADffm+4T gGev7cs/Li/h88VFK7n4c3XViRvaM2yB5KKOCCRiDcUTnYhiTGvG2fS8rmtPVhGTaHiCC4BBtye7 gF5wATi/znyHggtXQOCepeTMrksTdj1/CqnzlZNwCXlCCwBfaIGiioMDX2TR9B+izMJ57zAczhFk xDafLxcLeHN0NCb2exhKKZ5GXtsks0jJK2JbfkgMH1uEqUWrKIp8flEHIMZc/HtKHULJQtm033D/ TWbl5En4I+mid71xbT/4Rx1gIo6pAwhnBXJuPA45g9276UeZB6nbS0WResx3Th1AUZhRUAfIjNRt FxfMnzIr6hATs6IOQISkYisGadsCSd/PPgu/t6Vo2kfqEJnR30FPQR0gM3qORDaS9kcVdQDBVNQB JsIUpiuoQwjmBGRJ9lzMcc+KOkQmjqkDZKSiDqCwQVLhUWnnQqaioA6QERW1jaegDpARXdcVCZTU ATIi8V6Ac+oATDFCCz33qaSQdN5UjzUeTkkdYAIq6gAzIWndNVTUAR5IBfa6/H3ilDoAEyTva4y8 ZFTBA0VRFKn8F4C9M9aNGgjC8ERycyINfQojnoE+DS2iikQHFdQ8AJiCEok+BXkEOlqKvMBJ0LvJ AyQSOokEHbveG3u89jk+WO+sx/OdVr7z3Y5/W4p9Odv7qdRCWSp9AwX1zXt1X6Hz82+wWrn7clEq gQILHGMNpRNWQuGEFK5ZQUUjrnDNF1u418372BdlFm6ZUC+fTsNyn9ACiNCCSi22lWjCCSyccKIR T9wRKQVKK37Xr/vmOdkF9r2r66Aowy1jv9Aiy47MNv1h2i949+k1PP34Ah48PCZr1ZVDVGKLLRFZ 4MOsR6WxQAEFEVpUDyK22Gw3teCCyi1qoQW0hRa0Li7LF1r4g0BiZkUZRIUW6ddPZZB2ThIYjDdK XRVaTF8jVC3u/iFrcfcPVSvGeqQomEhZApHS8mMtc+lCi0NIQTwRU2gx5XetGEKLfyVmNmlCi1Rq BKzVEVV4NbctccH/iTpRblFNUXABPYKLpsN+uYX/3iGyi7FiC4BuJjvE+iOAzRsz/WDKnJlZptbP mxt4u17Ds8tL+Hp1Bde3t7vt1EgeUHBh2x8iiNgnuegTT6DwojP1+vROYffL3IBEoyW2ILlaQota eNKWW+A82oYY+7nYoHhlzsw9/z6krteUoMyiek5eHxEZRT01zRdW0Jb5Motd31psQRr+HR1nGZys VmOiPjbtCbSFFr604hDBxZDogh4JcNOA93zoSNDaxGNWTlGU2fKdO0ACvAdZN70vkcK0LyM/u/SL M/Wid2WOSL1gXAcemg7Jgw5ZCu4ASrJI3V9KXS9FURSlTc4dICBr7gALoABZ0k4fSYONHkrOHSAg Egf0O+UOEJCSO8AMKbgDTEDJHSAhJA2iq8hH0rmukjuAYEruABPynDuAUOy+peAOMSEX3AECknMH CIie/1Asp9wBAnINOsjyWPQ77TLJuQMERI9hytzJQc61Zfb4e8EdYgJ0P9PFnj/8zB1CSRop+zVL yR1gZuTg7pGRRskdIBKS/j+c6zUSBXeAyNj9Rc4dIgGk/4b1kjuAoigKJ38FYO8MctoGojD8SIGq KhLdszHdVRUnQEJZcIeuKrHtCg4AUg7QRU9QwQkoN/CWfZZI5ApILKDEST02L8wM49ZOZvxmXt8X jSY4nvEfhwTHCe8TqYUgmOiFhL6U7eBfA3Z2Pi6K8NmgyAIlFyi0wF7JK7C3ZRYvsov6tqKo5Rb1 2Fk1L4otUKDRlGM1XGXgTHlFXWAOJRZmM0UTttAChRQor0DBxe9neYW97Elb/0mbB4UWuF03GxsD eHgYV9d/XJ7C3rdD2Hz/VrunzUIL1aNUQgkmpvNpJZzAHmUWKKhYSCvgWVoxfzQlFmVD8QX2KLJQ FzWvLs9oElpU10VokQ7UDxH19vtEhBb9ElkB3SBz9THvMsSUBeFWlJl6vE9iui8itFhurr63l4rQ ItZthlhv2TEhclDOGcu6PsbHeNwa85hVxq06NtR8scwRYi6cct4sqpgb4gL3pS0osVCCi4XcYs0h t9DLievlyQFelyVvK7Sw5xhYfZuGfACY7QMU36EqCfjuU7345+0tfL2+hrPxGG7u7+v9By+Ci5kl hNAlEi65hEs8MW3TyjHYq7N8Bc6hLZ9aczZtv9AEHPp1Q3YBpvCifFAXZyZ18YWLWOQWqUsTOAg5 XHC9XyGx95YhtAAwhRYoqhgMTJFF+fM6yiy029bt9TRBhuvlcndrCz5vb7eJvQ+vpRRvHMv+JrNo kle4XumhYX3XLmzatYIg8OYXdYBIUPshow4hdEbJKc6hFpN04ch7knTIqAN4JNUvvQvdmVAHCIgU HvIP96JDF8D7OSEILrj/45Dw/5JTBxCEyBhSB/CIFFkJi3ofdUwdIjAj6gCEcCrYwPE4NqMO4JGc OkBiqHPxHM9j5dQBImFIHUAQOsLpeCGnDsAcrsLBIXUAppyXrdWX/xJEFbnlUvhUHZdyknHJOSRB kVEH8Ij8TreH0zHthDpAQkihaUGIhyPqAB7h+n8A6jOWO+oQkTECnp89CX7IqAN4Rt5bdOOEOkAg cuoAPZFRB/BIqs/dSdmuqEP0zIg6QCRw/RxJwfVvgyAIQiv+CMDeGSM3DURh+DGhiKnooTAz9Gk4 AB0dzHABXDKUnCDMcAQmdY5AQUeTIgcIwwWcJnUaRjPBttBKetLTspZlW+u3u/6/mZ1dKdrdJytR bEl+H6QW4BhxJQhyrfu0aaCLi+80mVTPTrBUggUWnEuNpRNGQsEyi0pkUdUssDDl4cEILJaN2KL6 Wd4U7stijGpOauaX9TjYg3FqPG5z0jhez3WZ0q4WWPAySyz+UiulkLIKFlu0MgvZbre3hRaLZr4+ ocXp6Yqy7HfZ/vbzKz17cyb2qpsoUcoijNCiFFkIwUSts2gEFCymkPIKKbHI8qwjuJDtRmiRV+NI UQa3pdBiWQo88mZZ7gMIHO1DpDG/1j6HmBhYc1zf84SaQDf04xRa8uKxxgx1v1IhdBHEIcYKRWih MV+Ise/SB0KL3bfbFQgt/Gw7Rv/Qtg+9zz799u3ra7xQxvAxlmPMTaIKKSdwiUe3geUWZc2CC3II LtoObrmF62frhBYuEcZQsYU9p8GkXH9BlH0s6i/F4vtq9a/7e/p8c0Nvr6/px90d/Vks6teplTyw 4MKUpRBErJNcsLDCJbz4r+Zt6vEWYoxV3i+zsIUXUryxstq2zCIvjmFZy3WyBCq3iF2aEHv860h1 vw4JyyzKtlh+JGQUTV0UW1ghy2NbZlH3bcQWorCM5MnJCT2fTIaE+rIor6grtLClFdsILvpEF/LM zy8NWe2+M3/nJR6ycwCAaDm2hy9dmBvs5os9T7UDAYOZUvWg+ocd+h7zw5n4UjSIkbl2AB6ZaQeQ IJeUbtIhw7l2AAAocKUdAACeQLIBALrg8yoYgvk9udQOwjO3lP4+9pHSuSDWhA19TLUDAGqYa+op Xm+ZawcQCLg3BmIDyczBUObaAXjiHeHcPTZG+HC2cat4Oad0rkWm9JnRfP5P5biA/ZhqBzAieG8z nJTOZ1faAURCSsfcgL93EDsz7QBGJBWBnQuca1qO/f5hDGj/r58qzz8mENpsh7lOONMOwgO32gEc kNfaAYzIXDuAPUj5PZUL8z083GdI+/qsuZ860w4CAAC0+CcAe2ePEzcUxPHJQkEkCrq0ThVR5AKJ BD4CbZQmN8gVyAVSpEsqcoMcwekoaRBNhDjEFhGw6+zYO/b48Ry8q/d2nsfzW1n+WH/87V2eDdjz M6mFYbTwAkIfV9275xbIsuPeYmkksiDJBQktqI8SC5JbYIciC5xWCy0WleCiHsf5arlFveyyEWSQ MIOEGmHxCS3KznBXaNHtyrKVWbTyCRpuJRb18D0TWtTjfLh+z7eeR7aN/v0/OHiA+fymGv5+9Q1e vX/D9qp80q+EFlUhPSaTYEILHEbZBBdaVH0mt+Diimoc/jaSi9WUdv610AJfJMpoZBbr7TdSi3LZ EW64+2AkjPRHNCWhRWxSFyXsejupFtBN/XNKrXhxzHVuSmrfUenlY61LcttahBYpCiaks6csl5DY Zux9kMxhQoswy6c2/y6X2ZaUhBYhSC3Tjq8vN5VbuK+hkMQCBReN3OKFR27hCiz6ypVvIrRwJRkz zzJDZBfIEcDidNX/CtWj6y+P68k/bm/hw+UlfLm+hj/z+fqYtYILkluQIIJLJFyxhCuz8EkvHh2Z BUkq3P6C1uFOH9hxAceS5XfHudxiyfa7T3DBJRixoe/amBl7/j607teucI9eR2gB0BVakKhiNuuK LFbj+ySzYO/tu/MxQYaveXx9eAhvjwbdy3MCT6UUe55p/5NZ9J0VfC079MzvO4R9h9YwDN38kg6Q CFik4EI6hDGIM6gfVtq2sATenJkHSzMucukAAbEH1qbFb+kAkcB2LJMOoQjtRYd+wrgf+DGMbbCH VA3N2PWsYXTJpAMEpJAOoBT8B8wF6CyqzjmXDiCMdMGXkGg8159KBwhIIR1gRGD7q1UUfScdIBE0 tb1ELh3AiEYuHSAg+HcvzcVyUkDj9RhxJh1AEXgsP0uHiAgWANRUkE3TdcuddAAjGXLpAAHRfO4N jYnapkcmHSAgWu/hMqZDDnraYbze19wOF9IBEuKTdADjWaQLg+fC2w+J5nYtBiamHz+ZdICAjPnn t4Dp/a6j9R6ATSikA0TmXDqAYRiGFP8EYO/8dZwGgjg8SJHuTqK6DonCUNDQI13HCwCvkAaJmhfA vEQqCt7g6GlSXIt0NBRUaa86CZ0UoYMLHidj7zqbYF/WmfXk90Wrjf/s7jhO7Dix5oPUAhwaocRA oXlv/9fRZPKFjo+X15gilRCBheRME+mESChYYiEiC65ZWMHiCpFXyHQtuJDldVsuMlY9jl/vThuh RZUqbq0sl9XCiXURxW0ltqilFbee2KKeJ22ljfTz1xljM0dHv+jm5iednT2nTz8mdPrskbNVvtBC BBblfnNlFiuhRSmzWIknXKGFK7GYL+bVc65lmtcJCTBKqQU/WGax+OONJY9SZLESWjSTN0JoMQC0 d9GhCS36HDt1UcK+x0klyX2fffXRr2WhRUoCiBj9abeP2VcqScCtnB9SFEwMQWgRuy+NbYbQwq7Q YldSE1SkLrTY9/kgxe9OKX23jNnPPfrcJqpYNOQE7npd5RaMyC3KWgQXFBBc1A3WxRQhSUVX2UUX oUUzJk7B/oRo/q6oPxaTr5azv11f0/vLS3p9cUFfr67oN/8YSb7k4c4RQLjCiE2SC09kEVjWtr7b 0k4kGqExpN2a0MKRWXjTzvZVZYPcghrrxWbo0gQLQo4QVrdLE5FZlM+d6QeOjKKqi9IUVrhl1JRZ rNpWYgunyL58OBrR45OTNqE+LcoL8oUWTWlFF8FFmyO7/P/aPLMQbT/Sey9xm40DAAwSSC1q3hDE FqnDCRfOafeb78e7hzJIMu0AIjLkm95Bd2baAfQIEg/FYUy2kw4xuXYAIHky7QB6AOd7YJXv2gEA kCCW5GQz7QCMMiVb75MQnHzos3YQylhJJMVYS1KtnYwH6JGTzWQ4DK45l+DzDYZEph1ARHAM6h/L r/FYOwAjZGT/GizXDiAymXYAEZlqBwCSAbKWw+OldgARgaitPfisA5AOY+0AImJJYBfC8nV9FzjB 9lQ7CJA8mXYAQIWsKB+0g+iJqXYAe8TSPRJDP3fn2gHsGZZaHPr/xDPtAHqGjy+5dhAAAKDBPwHY O2OcuIEogP4sVAiJNPSTBinKCaIUocgRoEnDAUiBREUHF6DJBXIEkhNsRU9BRYSQuAIUidg1/p4d 77eZ2TXLrP/M3/+s0ay93tlvGzyWd/yfSi0UxUITB30vy5d5HzDmI4TSnjmRhZNcOKGFq1FU4eQW WKYSi6KWWzQlF7i+LdiuE1s4gUYoOdtizBJaWJGFX2hh56lsAoUUL6UU/0ndFlpMayq+sJILn9Bi HNwKm6DsFh4f7+HweA9+/DmBLbNNtqo5VTILKBpCi1pqURCZBRVaFFZoURX4V7+upBYTkYV7j847 oUUlssCpeIJ6mogtaAw+ocUiyRsVBrgPkQot8mi7D1KTBSwLFVrwtZlKYudY7XF/PmZbUoQWfWxH roKJXIQWqcolUhFVdCUHocVr4P7+GG2nJqiQKrRISaCRynVCau1EaHPWvY6iIS7wT12hIotabvHO I7doCyxC6ctfI7RotzEILJ8nu0DeA4y+lfU5VD9lb+zYxT9vbmD/8hLOrq/h78PDZN9OBRfjlhCC iiPaYgkqnnACjLaMoms9KuvRpG4sDxR3x5HO+2QcY7IuFV64baRij3mCixjkLk3IPf4QUreLi/be bAgtAJpCCyeqGAyaIotyft3JLMh76+31iCDDdzr8sLkJn7Y65fT4DC+lFGueZbNkFqFewHcmh8D6 vl0Y2rWKosgFHyz8zR1EQhyA/MQFOWLADnKOlbAck8iv4gBcHfSu5Irk433EHYAA8OF/6Q/pnoH8 ByeUt2O4A1gCQ+4AlCQw3AEsAcnXNoqyCJKSOSF33AEI5BfIF1ogp9wBMLPLHUBkpPX30s7VSjcM yJaIauJNi/5/Kzkh6e9V2rVCikjex19B5j2zPsGxAhcgV96FSBQnSuoH7rgDUJIAz0WSzkND7gAy wXAHEBHJ11ux0T5MUdIA+94D7iAicsEdwJLRfsZyyh2AkgWGOwCFBenjpleBXe4AIoL3InP/7XVY livuIHoE70mt+nMsq3C9icfYcAehKIrSN88CsHf2OFLDUBx/q0GgHRpOgELBCeho2JYG9gh0CNFR Ua24AO3WOQLcYBDbIm3BAYZ6ixUNA2iUwY7zPLaZj0Rjz7Nf3m8U5WMn9j/JbiabcfwTqYUwJjZ1 CLRp2Zt9BV1efoLTU/O9JUolUGCBfaOhdEJLKFBmgSILPUZhBUor1gKLVbfcfz9ON03T1Qm2fnd8 GPuEFuAILVypxaoVTRiBhRFOrMUTS0dKEYotcNlfb5mRXeC6S1sOijJMHduFFpPJidqP39X+WsDF x9fw9P053L1/z9mq/+UQrdhi5Ygs8KW2o9VYdAIKV2jRvjqxhZZWLFYLI7SA31Zs4QkuwBdauOVi XaHQIuysETMLBUB9mERoIWWnqiP38mKTc2fBMRChRX7rxyxLhBbjE0wcu74xyyUOrZN6f6eqO4f6 h75fhBbHWYdivRTkcp2Q0z4JiZBtn6TClRMcIgC1Ygv18gQXKLcwb/LvHrrdloc/HyK02NU9+j6h RTivu2R/BPDrrRpfqNnnZvG321t4d30NL66u4OvNDfxpunt7sJY8WMEFiiMCYUQol9glo1gOGDc7 1guXe6KLYNoKLRyZhTfvCC7skEhugXKUUik9/za4bldOoMyinXbmTxwZhR2rIRRWuMOdUGbRrWvF Fs6Ax3Y6mcDD6bRP1MdqeAK+0CKUVgwRXPQ5k+N3sOEnCcDmM/vGXdxn4wRBKBLuD7YMRcQWeaEb UerGojE7L9SNK84jllcCZ9QBIvITym/0LgyDc4NxLZsZ2/koJvph4xnw6uwjRJ/z5OEzoQ8VdYAE cD7/C/2pqAMkQH63BcGHU2dOX6gDMKQGXh0MbUM/GF9ThyCmog4QGW73rirqAAIJNXWAhMhnNm84 XV8KPpyOrdwbSM8czP11rnygDlA4NfCXJ76iDpCAZ9QBIiKfA4KG07XND+oABVFRB4iInMv6U1EH iMiMOoAgHACnNnqfgb9kZk4dIAP0cZ5RhxCKgNP/FkI/ztTwkjpEQmbUAY4Ep7/dOXWASIytvb5+ Vu8BdQhCxnBfQz9jU1OHEARBODb/BGDv7HWbCIIAPJikQSmQeIGDjiI9DRIFRV6AMg+ARMEDUFAi IUEe4d4AHsFVeiSKRErhh0jjyEe48Xmc2fOuc3F2PXuz851Oa5/P48n9rM+X1XwmtTAMt2DQaTu/ ue8NVfU6WPyMRBYkuSChBbUorCBBBc4kscCW5BZcctGJLNwYKLZoGpJbxKpG3Y/jyiu6gm9Uxs6d XdFEX2iBLZdXcLHFDVvGxRYLtt5iHbOLRZ/r5/BwAvP53+Xjs19f4Pjj+7XQwieH4EILbEkqgYKJ xe1iKZyglmQWJKhYSytgJa24nbsSi3Ym8QW1JLLACeNyeUZIaLF8bEKLcVHibtIqtEiJCS3yKpqf MmZucWLGy6Wwc6x40u+PGSuXvrEkocVQxizH2CWuxHmRuyBjnxKBGDFTCSKkj83H5pCjoOKhaBda 5HDuxnx/7DixYyWI17+Ps/G6Iy7wT0N5wiaSWyxbElz4xBLbSpk/RGjRjzMZED9UBv0FQHPStj/a xZ8Anr3qFn+/vIQP5+fw7eICrq6vV9v3TnDxj8kfuMwCn/fFEvfJKJx1VgKMUNvgPc5VS8ubLZ+5 IbmAOwGH85jJOLjwgqQXXOzhu7fKJRhDGLs0Yez5h9D6d+VCf+s6QgsAV2hBoorJxBVZtM8PSGbB Xjvor8cEGb6u8OXRERw/HzSW5y1sSimeepZtk1mEen1fzw2B9X2bMLRpDcPQSw26Czrsgokt5Kmg G5D+E9IUK/+cIGbOaBr0XsLgYcNlKp1AYkrrj2JRgtAC+Qr6iqEaaaikE0iAfecbiKbrWMKObcNw qaQTiIid33GpoQyhBWK/C3V95/+RTiABlXQCxt7BfklT0WAjjMb9XHLxFe1oul6YSSdQCJp/o+Fv JevvdqMG3UX/EBR4TaWTiEwlnUBkNPdPxnDs2qZM3kknEJGZdAIjQpNMayadgGE8Ak3/i/ktncCe KF1OrOmYNdKifQyt4YL3BGvpJBJTypjpSjqBiEylE4hEDWWJO/H7o/TrjRKuN3E8QOn72TCMwvgv AHtnjNs2EATAtWXAUL6QAGaR/CAPUJcqeUO6lAb8AhnIA1Kkc+O8IoUbFkZqA/mAWgNuUiQCbMkK T+SeltRRomSKu9zbAQ48UkdySVFHiRR3TGphxEIoEVBo2pdtC7q6+gnDYX5tAaUSKLDAHGhuGsot UESBIgs3RGFFVWCBggtsh0MsmGQN1+OWTcf3ozozpnfDOq63lPYNconFvBBY5DKLdYnF01p9Ja94 LF7D+izQni5zDitxRpjT0wVMp7+X9e83X+H1h9X9pqoUgsoinNBiKbIggolCZ+EFFCimoPIKKrGY LqYlwQWte6HFIl8OFWVgnQot5kuBx8KPV7fBEI6Et6nrGDQLLSQkW5ayDsnLk/C5q0Ni8uK2lidt v3MnmpZ0THPP3xZS+squBRMcQgvu8x3Htkhvt+88nPFqbvtSuhBaSJRmvHRdmoQWbSHp+0bHbJNU UDlBSGjaFC+2gOOS4MLLLfJG66nKjwPTANZTnO8iu2haIDA+yLb9HcC/86x+mY1+zCf/eniAi7s7 +HR7Czf39/B3Niv200pu8ez3Y1kSMSfDpvKKOgFGaOivNm4QZoQEGs+VuhdaEJkFHcdtK5UauQVt Gzxe3LHRc3FC3+OvQ+t2SQVlFss6GT8iMgo/zEpVWEHLSVVmUczrxRak4Gfw1WAAb4bDJqG+zcp7 KAstqtKKTdKLurabemm8D0sPyrozhokuDCM+YnnAZRdMbMGH+8Oke4j/kMmU3M17TQ+IbyPhDqBF Uu4ADBY0JoREXF834g6ih6Sg68H/EO7BmG/cQRi9QVsSSnf8T7iDMESg8Tt7yh2AYQhjxB1Ai0y4 A1DENcQjtNCYbHQfNJ3zNSbZsITJcZFALtnUTModgHFQtF0jMXLcuUhTcraUO4BISLkDODCWhGh3 3D6L4bemxmMj4Q6gRTTf9zZ2Q9O1kJQ7gB6h6X03QU8zRtwBtMgfsPsgRn9JQM//zNxn8Zo7iI6I +VzzA6zPNZqRcAdgdM44K2fcQRyYWPp/Tb8PJ9wBtMiYO4CO+cwdADOx9Ddj0NXnaEDjfRzDEMN/ Adg7e92ogSAAT04pIiUSdBRpDA1FHoACiit4CRp0JR2PQOpQoISKzo/AI4QuJRVSlILwCClOSviJ 4/Vmzuu9XZ+D1jvr2fksy/bZHo99OfviW88nUgshd8xCQW/r/sWmFfb3n3mLnKHIAiUXKLTAoRJW oKyi7bXMwhRcoORCzbdjYNxWqOEvurYZl9Ci6ox3hRbdvqqw3JyWTmj5BIooWomFHv9tCC30tDmO YotWYmELLf468m3Z2fkDy+WPZvzL9xN48vK5sVceoUVT8M6QSRhCCzWuZBOm0KIZ1v0N3KyJK5pp uF5JLtQyuDwKLVSHooyVzOJ++yupRXXbEW7Y+yAIGxGhRfrxUynSTskUivGmJH1IsShzKjFCxaJe P2Qs6vVDxYqxHykKJlKWQKS0/VjbzF1o8RBSEE/EFFqM+V0rhtDif4mZGzehRSoxxog1ZkznZtrO Od+4V+brhrJldCi3aIYouLDLj9uSCldZ86FCCzvObEB8X1n0xwD/XtfDo/rldwC7hX7588UFvDk7 g4/n5/Bzubw/vmrdLa8UAoURpkxiiLxiTYJhCzDqmD4xhjl0xVqTXBj5dcatadw33L/K3GfHvVZT gqEP07RrzHMQcrjgul+pYh/pjtACoCu0QFHFbNYVWdTT2yizMOZt28sZggzXqe/p3h4cPBr0LP0r 6BdX+IQVmyQWvjM1eJZ3HULfoRUEgS8ldQKJogoaqEaKUrQrDnPQx/sTxClMk1MjQE4NUC+pExBI OKVOYGQOqROYGCXwedC4jwV1AsJk4HSdR3J5UEjopwB+D+F+o05AEBKkoE4gIHL9CkMJeRQZRRbU CSQCx++0nOD2/sj9/n5K4FU4XvDD+bNQUCcgBIfTtegXdQIZcUqdwMh8ADnfPYQF6HYI3DkGnvcn 5tQJBOSSOgEhGQrqBALC8bwzBiJqy5OCOoGAyGddmDKc2gp/pU4gIrmed5S45JA6CWEyFNQJCFGZ 1/176iRG5oo6gYhw+t2D0zW7hLx+x1HtcxfUSRDC6W+3D3U/Sv0fwbl9wFRQ7wE+N1vQpiIIfLkT gL0z5o0ahgLwo4eKeiMbC7oBIbFXYuRGxIAqfkEHdsQ/KP+AqWJAan8C7EhEont3WLJWlZhaVaiH jjjJSxzHPZw29nOe31dZl8vF9sslzSU53/tEaiGkgC0BkG3e2/81dHj4BXZ2qu+uWqkENJKJav66 kVugiAJFFuoRhRWmwEKJLVBkoS+PBZOptf2Yj0PlFi5CiyalW69Ur7XCib6I4roRW7TSiuuO2KKd h3WxDrbzV+vDjspRtr39Gy4ufsLLV8/h869P8PDpI22tukILFFiU20mXWdRCi1JmUYsndKGFLrFA cQVOX62vKpHF+k9PgIHTZWtKZrFedfrCv1JkUQstzCSLIrSYENSbirr/kIjQIiyxJtBNYTvFFAvC LSkzdf0xiWldRGhxu7ZC9zcVoUWsffpY7rZ1fMRB2WYsy45RP8bz1pjr3KXeXev6ai+WNny05bNN p27dBBf6sua0C43YArY6goue3MJMXb5lmQfQT3k+RHbhWsDy/EGx7s8ALt8X0x8AZm+q2T/Oz+Hd 6Sm8PjmBb2dncLla1e+TIbOwCC3M6Y64wlFOUfZRv7ZJjHGTKGNlicWMD2O3iTrafcQom+61Fts/ psuAoXCVPnBdr6mAMotyWnt+T5NRNI9FMYUVerlvyizquo3YQisoMpnPZvB4PncJ9UlRdqErtDCl FZukFzctu+mojN/FmiokAPuR2/oWu6ycIAiTI4O0Bl4OQSXNVgPGOA0ajo0FVIN/v0PYJOV7kM6g TE77b04dgEBCRh2AZ15A2j8IGMIxpJHg9ivw3+8R9Xm8Tx3ExNmjDsADGXUAI6DOvz5SBzFxltQB eCCjDkAQIkNdk3OS16TyQ1dfqP0hgzTO9xGVbDSnDiICJKGfEBpO90rH5gCq+1TcyagDiATO/wtL 6gCE0VlSBzAict0QjhTea7n/6MZ+UY6ogwgA58SnnM5bUjg2CW5wuvbKqQOYCJyOZTLO1J0FdQAj Ip9hwpThNK4mpevAnDoAItQ2zqmDEAQiOF0njY36Tj0FsVEq55wL4DVGgtt2O6YOIDAH1AEQklEH EBA1RjOjDiJxllCd5+PvZjldpwpCVPwTgL0z5m0aiOL4I+oYiUodO3CMDHwApA79AEhdOzCEBXWD b0BnRgYWlnyTulNn5naIxMAKSySQoPjZec75aqeOc87/fPd+1slx4ju/cyzbcez3U6mFkjJ2gqA3 eXn1WAVjXrQmMxORhUguRGghYxZWiKxiXUqZhS24EMkFf+62Ie2KUKOJbnKLTUKLUmTRLLQop23Z BAspHkop/lhjV2ixHtvii1Jy0SS0+NfaizJP2YKWyx/09t1rOv96QU+Pj6xe1YdCZkH3NaGFSC1Y NlHJLGyhxX0ptCgK/a5ei9iimqb6tAgtCpEFD6v25TUv046hSWixbZJFBQz6q0IsH9XnEBMDI9sd ejmhJtAN/XsKLXmxrzZD7VcshC6C2EdboQgtEMsLMfY+dVRo0X++vqjQYph5fdQPbf7Q6+xSb9e6 Q7UXShtDtDVkmz3oIrcoZQbNQ1eeWIPILYqxK7hYV9ic6nwboYXbzqRD+21p0g+J/vLtRp/yty+I pis/7OfbWzq/uaEvd3f0fblcrdt1aZJCtMkuHkguXAnFqr5MF+04wguZv6sgwxVe2OKMahn2a2da +ib9q/U5L5I8v9q2rDIWYhU/xNqvMeCu+ZrQgqgutBBRxWRSF1nk0wcis7A+O3DnswQZTbu659Mp vTzslCP7hDaLK9qEFY9JLNr2zNQyf9MqbFu1iqLES0oPumyL3Lz3ARxHbPDB8pLKm5gRCQv5RvAU bgI0FNdN7xk6AAVChg5gD/BxOBXRTl/mlEaCW046lMo5B2/zvO1zMqk5NpRRE+P5TAwPYM7z8p50 296FGLftDB2AogRGbEm8fqKDGDG8LWSUVpKKmJONbktM+4JYie16hUEHECh8/v0RHYSieOIUHYDi HYMOwCOxJXcKGf6Ndo0OYmDOKM5raD6ZURpCC4b/W4r12oRBB+CRDB2AEgQGHYBn9PymGzFdA1ug AxgRp+gAPLJAB6AoPeHfTM/QQXiC/49M6biboQMAwP8f6vMc4wN5nmeAyx4Kgw4gUDKK63mQ1DHo ADzyDR3AAPCx+Bc6iD3C58ozdBAgFpSWuJNlCnN0EIlymZcrqh/LZ5BIFCUB/gvA3hnzNg1EAfiV REINLPwCMrAwdekPyMSGEDMLGxISOxMwMLGwInXxv+iGPHTtyO6tUmdQBZQUP59ffLlcErs9+53f vc86OUlj37PPtc+O/T6VWijS8SX+8X32Zt+MTk5O4fDQHJtIKkECC3JIVLKEWm5BIgoSWeCYhBWu wALFFiSysL9PhSQVTT3rYx9+uYUvzZortABLaLEutUDRhBFYGOFEI564tqQUttjCllf8gUZ28beW XdC016v5kCjD1LFdaDGdHpTr7UdZfsHnb+/g2ZdX8ODRQ2upNuUQldjiphFZrIZyOUhoUY0toUU1 1GILlFZc3VwZoUUtsXDlFjjYQotqqOdLdblCCzepIsWsjAju5kpJaNE3sYsShq4n1gS6sbdTbMmL +5xnV2LbRrmn72tenHXHvhxjFkxwxx6zXIKjzr6XgTMOFVqEmT627w85zW2JSWgRgthiktq/dNgn qbCvl91FLLoSW0AttKhlBxtyCzeV+T3PZwCbKdC7yC7aiC18KdWR++WyPwX4+b58/QFg8tx8fHpx AW/Pz+Hl2Rl8v7yE38vl+pXCej22EVrYogmSUdiv3fE/FFXUxZVWbBNkuDIL+/3SGbtCC5+oo9lG rCunZfvukgnHLrhwhRxSkLpcY4VkFtVr6/2BJaNYjcviCivsMnVlFvW0K7GFVWg7mE0m8Hg2axPq k7Icw7rQwpVW7JJebPvurr0w/R7rqo8A/Htq7ypus3CKooyODNK68bIr+OP8VzAJdqUl8RoaklkU YJJkcd5gn0LS8Dl3AAGReNO70g5MwCK9/XFfmHEHESl43MghDaEFgg/DFNxBDAQeh+nBcWzfDLSf 1RV8KPaIO4jA4ANCBXcQdwS3bWoX3LYxqYBu293A9fWCO4jA4Pl2zh2EokSGJvFSkNdg9o/S+jT7 kJxstCsL7gCUvUj7/5R0/AkFrpOMO4gBKbgDUHpnwR2AEpw5dwABSSn5ZAzk3AEMQAZ67XEbeN6V itACBS4ZdxA9IumcpOAOQIkCSeel0u/jCImkds+5AxgRktpdz2WUsSJJBJii7CC1vga2cUq/H0pp X87nIOaMdfeFpP5TKDKQdW1kF6n0ORfcAQSk4A6gB/BYnFq/6xN3AIzk3AEMDD2voQzDHMyx7aPn b0cgsy+nKOz8F4C9s1eOGgYC8ObmQhMKZqiYzDAeGip6KpKCR6AFruQV6FJTJB31tenyCG7yBjSZ SWFaOroEwgSvzWJJJ599IGvl1X4Zj3yxLa9/zpZ1sj6VWii5YnYM9LYeXg4tcHj4rLfTMhJZkOSC hBaUorCCZBXd0MosTMEFSS5wupsH5UtCjbF0na35lrHlFe28ncTCFVq0ogmf0AJTU17x05FX/IBN scWdMd/d3zzbvGi9fvb39+Dm5kszfnr+EZ6/ewXLB8tum7cILTAlqUQjs7hvJRaY4h/JLBqJhSmu gE5c4YosSHxBKYkszHyHhBbNuAot5gn34cpNaDHlulMXJcReT6qd3Kd+nCQLLVISQITIj3v5kHml 0gl4TtsRWzAxB6FF6Lw4tlmFFnKFFv9LaoKK1IUWsZ8XUiw7pVS2DJnP1HkGxJWHbkwnkcG9Pd/Q cj5MucVib2HJLSzBRbfA9q7PdxFauJKMxYj8+7pNfwzw63Wdfqr//QHg4RNo5BBnV1fw5vISPl9f w7fb2z/7qatV9Ekh+mQXNH1ITmFJKUwRhkde4ZNj9AkuLKmFEZ817nxu6lVRaGFss3n++EhNbiFV +iB1u+aIeyQsoQWALbQgUcViYYss6s9LklkY05bufIYgw3dpe3pwAC8ejXpn+Ai2iyv6hBVDEou+ KzH0zO/bhX27VlEUmWDDywvuIGYAdqxagawXnWKRksyCwEaA0l9+OOYOICAVdwAKKyV3ABHAe8yK O4jEIKHFEXMcscAXNU+4g4gE3n/dBvr4okQJ2kB/FyQKuub+TFLA5vcYy5wlyC93hkTiuV1yB6Ao CVJwBxCQkjuAGYJl/TW0HYymUEcUE+mdje5KwR2Akh36YrgNPqeUkNe1uOIOQJkclKjq73iykFQ/ XHEHkBlzr2scg0rT/azr4Yw7iEigTHfFHcSESKtXr7gDUJJA0nmdS4ejISi4AwiIHvdxYB24pPqW kjsARfkH8Hv4njuIgOTwjOuS0z3nK+TTbpDISeChjOeYO4DEWIOse9kQuVwXCu4AAiL1Xo1Si+/c QUQEf1tdcQfBRI5lbBJbqDB9Wk6gvUZuE1NpmwZFmYDfArB3xrptw0AAvcABGmfIF7SAO3btktVr hvyDgfQjOhXeunbplKV/UGTKGCdjvsKZMmQNYBRwpPokn0LTlMXEko483jMIUY5FHyVHpmTpnkot FMm4Ev64nvvW1NDl5TUMhydFnaQSJLCg3GV5nldyCxJRkMgCpySssAUWKLYgkYX5eiqUHO31fTan ftiJ1igNG9VN8UVmTEuJRSmwwPnlen5bYmGLLEp5Bf2N6svqNdtCiyW8SjPqhRZHRxksFqXQ4vfN T/h0/tXs5VYiQpJFoNCiEFnQA4UW9FiLLUhMQbIKW2KxyBcbgguzXgkt8rIdapeEFlg3hRYvhcAj r+bNPigRwb25VGgRR9t9EJosoCtUaMHXZiiJndtqj3v5NtuKSQTR1fLSBROxCC1ClUuEIqrwJQah xVvgfv822g5NUCFVaBGSQCOUcUJo7XTdZoc0SSpsuYUtuPCFJBYouKjkFgcOuYWd2twWU7gkFW+V XfiILVwp1pEPq75/AXj+vqr/ABiclU9fPz7Cxf19Ibi4e3qCf1lWyRtIVpE3CC1cook6MYU5fUFR xbo0ySvqBBiukll1in1DZrEq1bzRX+p76HILqeIHqf2SAMksiroxf2DIKGhqyyrscmjLLNbLVmIL o9A+93gwgI/DoU+on1flFDaFFra0Ypf0ou61u/a69JusrToCcO+ZnavYp3OKokTHlDuASMCbDf+C Jl32ZQThySxMJCbMNRlxB9AiUi96V/z4wx1AT2BCV0lJLPYB10PThdzSmHAH0CO/ap7H7Y3bfdxf KNEi7eZ7YsYdwJ7gZ9s13iWxhd6A0gx+tiWO0VO8+U1RmpA07p1zBxAZYyjHfBLHMj5MuAMIjBF3 AEqSjLkDCAQSDIV2zl7pB+lJKvT4Ww6SjhsQ/a2rX3B9p5B4CqXpU+4gAgG/3/A8XErHm3hOes4d RIeMuANokVvuAJRgkDS+mXMHEBEqaksPSf/rD9wBKMo7kXR+6ArS3P+mdB5lyh2AogSCpH33vuD1 cymd40oJSccKUr+rUbCS2vWeE+4AmJhxB8AEfr/MQP41AxyModw3+tw/O+k6GEVJkf8CsHf2Ok4D QQAeBZqTUiAhIaErMIgWUSKoUtLxADSUPEZooTiJAomON8GPABVXnEQ6XuCk4wLEZNYeZ73x2s7F 9qxn5zutvIn/xuvceuN491OphRIj9oBAr7fpRdsKp6ePvBIJElmQ5IKEFjRFYQXJKnYpl1nYgguS XOB8dxu0XRJqHEZ1+SzbmLSb5wotqilfFkUTttCCRBR/ium6yK8toUX+2s6T2GInsXCFFn/34rU5 OVnD5eUPk//87SPce/bYOspsb2qEFmZgOksmYQktMI8SCltoYabbdA3Xe+IK8xp+l5ILXIaWJ6EF /uG2MU9iC9p/KbXINhXhhnsMykTgPl0qtNBtD7WP0LfXNyEPFtwHKrQIb/0+t6VCi/gEE2PvL2a5 xLH75C7vofYdwv4PXV6FFuOsw7HeEITSTgipTFxCjq0FV1qxN5/kFo7gom29OkhuYaYkuIAawcVu heah0A8RWriSjFmH7fuGUb8L8O/ldvp++/ZbgPl9MDKLD+fnRm7x6eICfl1dFeVrqXLLcqy+t6mR SbjJJ6ewJRUbkl145BVeOUbDOq6MA2UWZb44jvJ18V5FcGF9flwyK40FDfAvDanHJQH3rFSEFgBV oYUlpqiILGYzI7K4XeRLuYWVv2VLLaC+Kns4n8OTO52e63gOzeIKn7CiTWLhq3nBs3xdEfqKVlEU mawg7/iidAM7m/6EfNCnhDWSMFlAXjZYRiHKLAjs/CD5QcyEO4AekfrQu9KNWAYeQlKQ1WHlJmDd nG7TA+Y4xuQdxFPPYWe7pkE7sM3wFbSzbhs+MciUwXp+yh3BsO561TCf5Hh47iS3P48F64hQvzsc w5Q/24oyFJIG8VqCtuG7QIOLYlsvpra+Dbb7V9xBBIakugBZcQegdEKiRO1Q8LqVQlwyUeQ7dwAB Ib3tggNxJNxBKL2QcAfQIzqYOQ+x3JPB3+PfcAfBDLVvmu7RSgPbNkvuIAZGUpsllt8BlXYS7gB6 JOUOYCIk3AH0jNZn3ZB0DVtxB6AoN0TSfeBYvtu6xHLNQXnQF+4gFCUQ8DmCBXcQAYDPF55xB8FA yh3ASEj6fVbytXrJHcDI4LM7C+4gGECBSaz9aLEuwv9hSfcvOEkgb9Pjc5Fd6/mnIO++oaKw818A 9s5eN2ogCMATJdIpV6Sgo+IqJFrEAwTEA/AASKRCdLRU6B4DKUhcniLtVShFJB4gjbs0KYAgRShE xmN7fOtl7ewdt5717Hynle2TvTe+n7313e58KrVQpOJK9OO67919FR0fn8L+/kG5TlIJElhQjrI8 zxu5BYkoSGSBSxJW2AILFFuQyMLcnwolQVs9Tnt5P/aOq/RpJLeopBV9QouVcOJfEcVtLawwpRW3 LbHF6j46lo6heu6Mx3CDecomk59wfX0Bz188hc8Xn+DB44fGWbWFFiSwKF8XU2ZRCy3wZoonSGhh SixIXEHrN/lNJbLIf7cEGOV2vV4qLbDO/E8lzcjvwLyVIotaaGEnQ1ShxchI8eWSKrQIiQot4kqa H5JYkxer0CK+47dZVyyfiZSEFr6MWY6xSb0cn4vYBRlDSgS2UWcoQQT3e/N/Y4hRULEu0oUWMXx2 QxBTfyN0fYz4Ci7Mfe11H0higYKLRm6x45Bb2KnObTGFS1KxruzCt4Bje1Kc+xOAXx+K9Y8Aey+r u08vL+Ht+Tm8PjuDr1dXpSzClj0gLaEFQK/Mgta7xBSNoKJYUumSV3SJMvqKLbcwRRymqIO2wTpf U3DhYgi5hVTpg9TzkgjJLMp1Y3vHkFE0y6LYwgqz7Nkyi/rYRmxhFGpjp7u78Gg69QkVrdnPoC20 sKUVfdKLrn37Wln6X9ZWGwG4W2LnU+xzcoqijA6JyXFDg4lxcCDfHHQwGSYnxIlg+HzgQLw3vOF4 gQlzX3EHERBJiQElD3pX/Ehlcia2SwtIN+E59kUw6bvEhOZdpJB0iMD39dxzX0zChW3/LFQwIwYn kIyhn7UuY27n8b3tey31HlRg1MUMZCWWIHDS23fuIBQlMmbcAWwZTKywhDQn9/pAfcAM0kouapNS v98Xif2hjDsAxQucGH7IHQQjqQotEO2Xp8WCO4CBoL6WxOtpRFJ/IeMOIFHG/JvjunyBdMUWJEtP rX9zxB3AABxyB7BFMu4AlGiQ1FZl3AGMBEl9WpVF+iPpdV9yB6AoGzADOd+5PyCd37lsUhkzfMQd gKJExpw7AGYWUI0vVGQi6ToBybgDCEhWlBPuIAZmzh0AE0vuABjBMY/fQO7/zENA/9Xjtcsmczsk z2dVFBb+CsDe+fs2DQVx/BR1KxJIlVhQwQsjO2P+AQY2FoRHFpDYGLMhdWFjjtR/JJX6P3SgEkEM jKhDVdGUBJ+da86un+O4tu/53n2iJ+eH7XwdOy+WY9/HpBZGaPBCQG+T9nLbBIeHz50SCRJZkOSC hBY0RGEFySo2LZNZcMEFSS7w9eI8aL4k1KiPW2hBZdY2Yot/sJFZZGXYuGwChRR3pRTXbHjNRBZc bLEALr7IJBdlQoulcymwCNVy+R0uL3/Bx89v4N3xB3j45IAtVf6WyixglRNakNSCZBMonkhbcksF FWs5Rdrg7+19ElvcPob845zIAm/r+XOhBc9QJrTYtRii4QE+rK6+M2gWWvhQbNmX9/B5fj6vJxNa 9Ie0BMKnbVp6+rbwpa/sWzAhIbSQ7kcllsX38ZpOI5lX87j3pQ+hhY/SjPu+lzahhS/z6GJeyqkj t8hkBneP5+wquEC5RTokwQWUCC42E5TLLZoILYol1keO56sEF8QBwM2rZHiUPP0e4MFjgIvFAr6c ncHr01P4dn4Ov6+u0klWJIMAJn1g4oiiNMIlmihKKcokFUsmtKiSWLgEGDeUad1KBRfsPpdbcOFF cVldgosVa21BBf21oXW5NFJcSzmhBUBeaEGiitEoL7JIHu+RzIK9tlccjwkyyrqup/v78OJRrVq0 WHC6SlzhElZsk1i4elpwjF/2Ebo+WsMwdDJL2ol0iAGChbex8PIPyE4k13aycRX4QxdDVhDkT9K+ wvAuBtN6Aqa27XAuHcAQJ6TCQ9iPzkDf97iKCLKTuUO8GCuWDtAjU9hNWILfBdwutP5WNwH3vabS ITpiyII93Eaf7TA+btt4IdCkkzTDZQo6pUYh7cMYRl0i6QAdgP0XCj5tvyVPDNn+HB4309jH70Is HcBDIukAHTCWDmDUZiIdQAgq+Bx6n2yEAZ6DEUuH6BAuDiM5rEY0HSOfSwcIFDwucyEdokdCE1uQ bDg0WTryCfT2/ZxIOkCLhLC+jO2MpQO0CP6+zqVDDARN+7TWl9Unkg7QIrbejSGi6f+6kM83QEnx T+kQHYPXbMykQxiGZ+Cx/bF0CAHwOBf2+U0KYhvDIZIO0CIhXHc4kQ7QM6H2vyHvbxN4HegMdPVR XVP8r77pf1RxO3EMwyD+C8De2es4DQQBeKKAouNo6ClCSUWJqPAbHI+AKEDiCUAU+J6B8hpegera q08peQB3V16DdFKEDnbsjDNZ7PiHtWd/5otWdnL27tiXOOuNPZ9KLZQYaUrw0/Tah66KLi4uYbU6 LedJKkECC8pFViZi28ktSERBIguckrDCFlig2IJEFnx5KpTsbN/O4fQ4XUILKGUWwFKtkdyiKpXM 4lA88ZtJKbjYwpZXbNky21qGsZdi7EUZVRvtQovlcmH200+zP7Zw/u0jvPp0BqdPHrOtak4miPII ElnUD7MdJLTAKZdZbGE/j9KKuz93ldBiJ7Gg51x8Ua5vHiTHoHqpLVtowZMf8pgVZTAqtPC/fl+S tEsSQjJen5IOa1Lm6euSXt9lXdLru6prju3wUTDhswTCp/bnajN1ocUQfBBPzCm0mLKvNYfQYixz xqZCi2nqmKKuKev0jC5JhS23GCssJYkFCi5qucWiQW7BU5zztOnQ8vcxsou+xW4TWZltfw7w64uZ /wzwMKtevry5gfebDby7vobN7e3BviMxRDkayYUWAEdlFm1Cin8EFWZKpXWZFvFFGQOuu1uWt3tv zd9b81xwUY/pApNbsH3QhAu5RazSh1i3KwVIZlHOs+cLJqOop6bYwgpeHtgyi926tdiCFTqmPlou 4enJSZ9Qn5nyEvoJLZqWsQUXfY609NusrTICOH7kPdjFfTZOUZTgyKUDCBy8kBwT1OLNfG+hulAt NmyRBSbHOJMM6D/BpMIx3UBMrKUDcEgKF70r3aSWeCglsQXeSIzfm6FJkVyQStIhJINx/QW8yJ9u lkjh89AFJuiK8bOCN6GH+lnA9+XXketS0snMWTThgu/t19JBTAD2Xb5LB6EoHpJJBzAh1G+JcTyo L7jt2McvoBozGiJ+ipVzCLevMyXav1ckwb7nG+kgZiaHNBM+K2mD55qxfd+0JciIta+xlg7AIVfS ASRMagmJUhFbZJCuLB1/Ow9ZEj2EmMYUYv2uVoaxlg7AIfqe7k9M5ySFdAABEdPvnoV0AIoygpjG flPp+7cRe58jlw5AUTwltWMfnjNcQdj34yj90PPDsChM+SEdxMzk0gEIUEB6/+cmcBwD+965cBy+ swY3MgviBcQ1Zqwo4vwVgL2z13EaCALwEOVouOLokK4xlEj0V4aehheASDSUPAFKTUVL51fgCbB0 r5D2RGipaAMcR2Y3I6+ddXzxz856dr5T5MT2rseJbK/Xe/Op1EJJCTcB0BuwiYqOcnn5rFEiQSIL klyQ0IKmKKwgWUX5sjILV3BBkgtcXq+D6iWhRju+FGhVeYVJtWeEFvXXLZBsohRRuEILnJayilJi QfKK384yElv8ddYr67R10Xb9nJ09gO12bd5//voRnr97CfOH8/1e+pMHktACpySVMDKL3fZQPIFT ElrgZxJUGIHFXmJB4gqaZ6QXe4GFOyWRhVtvm9DCvFehxbTh/tm4tx8SFVqEJdYEuin8TjHFQkhL ysxdfkhi2hcVWnSrK/T2piK0iHWbY6zXtcwYcXDWGcu6Q5SPsd0ac5k+5fqWHau+WOoYo64x64yY er/TwfKKuODw7xRIbmGmJLgAj+CiLOCXW3QRWtRTrs8a5rfJLpAnAH9e76afdrPfAzx6DPBzu4XV eg2vrq/hy82N+UzfnyuCuHPmkRjin0cmcSC4aJma8o7IwrfcFWq48otbEmR41qvH6c535RYkuKj2 yjpyFE9f753zOgWp4gep+yWd+q9WEVoAVIUWJKqYzaoii93nOcksnGXz+nqOIMN3enp6fg4vLu6V v+oKDoUUx+QW9TNr05mz6cwKDev7vsKmr1ZRFJkUoAnkhwAHlmHCCJQ+YKKMJUw7oeEC7MA7HKQo QWRR5wN3ACOgg94VieTcAQQGBzmjKGnJHMdY4HkKryuY+DfFhIopJR1C8p7l8Z8l8HjA72zKbao+ 4L6/5Q5iJKZ8LPSNHe8bvoE9RrK+wUyUJchNPpdzB6AokSLpftUHtls2ILcd30QG9rq4AdvGl5R4 sg/Y7l9xBxEp0s8FSvzkkEYbPAP73KerjE8SG+4AIqLgDiAQ2OdYgIxrTgbNCTJQqPgreERhkCR3 lZ6EMWZSk1og+Cw/B5l96bhPOdg+1RTvO/GcLylB7zEW3AEMiORrtXIaGXcAA6Jtm/uTcQcwIAV3 ABMh4w5gYPR4V6YGtpel3Cv8AD0GJe8/Jk8uuINQlEjBfuEVdxCBwP9hwXGxkvrCu1JwBxCABXcA AyL5Gu0y5bHNXcAxbwvuIBhI8TmSD3z+jM+hN5DeuMc2FmCfTX2HYWQWLqk881GUIPwXgL0zVpIS CAJon6e1tQb+gAYkBgZGplZJ4n9QVpmbmpEZGhldcv9wgaFremXiH2By6ZWBtcmduM3Q7DALu8gO 20NPv6spuAWGHo4DFph+KrVQpNGV2Kfrs/eHKrq4+ArL5ZNqnKQSJLCgnGNVwrVabkEiChJZ4JCE Fa7AAsUWJLKw56fSJMZr1tMeduNOpHRpNG6KqfuvNZ1kFve17OIOtnKLtsTCFVkYeQVNo/HtcrtC i7tmffuEFotFCeu1EVp8+fYJnr59abWq3BmSLAKFFpXIgn5QaEE/tdiCxBQkr3AlFuty3RJc2OON 0KI09VC9JLTAcVtocV9t07L53W2DMjO4/2wc6+dqc4iJgTnrnXo9oSbQDf3vFFryYl91htouKYQu gjhFXaEILTjWF2LsY5ZRocX4+caiQotp5vWxfGjzh77MMcsdu+xU9YVSxxR1TVnnjBgit/AhuCCJ BQouGrnFWYfcwk55bqdRh57pY2QXhyQWfePIYrMdXgD8yTfjHwEevTYfX93cwLvr66r8uL2t5BG0 7UgMUd2ptIUWAC2pRK/cwpJRdA0rOUVddqbZEos+YUY9vWu+RnhRyysa6YUjuNjuI239cJ/cAqx5 9kH7iTSktitGSGZRjVu/n1kyChq6sgq3POz47IEttrAK7UOPz8/h2XI5JNTnm/IKtkfEfUKLrnlc wcWQIys9n3XVRQD7j7StTTykcYqizI6cOwBhoPyBBBcrMNs35QvnIAmYl+JyMPHiJSEmhcAX76S+ MI/tlZbUQ0KSJqLgDkAJhkvuAJjAcwi+LC/lOEUJh2LuiBVT0iEkB38dxjHxfVHXKeV/YgjYMUpq 0n/kkjuAkWCn0jee6kJhCXb0yyGufTsDc56TSmydGhVlKAl3ACcAOy7i8W0FYd8DOhY8Z2Vg2omd NvF6JUZhXR943Z9xBxEwCXcASvTg8UrS/ZYu8DsLfs/w9b1l7hTcASgskNgi5Q1jNCkcTpAhNXFQ yh2ARzSZOS94vv/FHQQDeL9xBbKeGeO1TQFy5c9DyCCe44mkfVfquVr5f1LuADxScAcwIyS9E1Fw BzATJJ3DfnIHoCgjkPQ+lr5vIPta+gN3AIo3JJ37QwLvh2fcQUxIAube3WfeMJQTk3AH4BHJ52ib 1aZ85w7ixGTcATCAz5F+cwcRENjnA997LCDO/YFIYPtcCvvUTvVsKpuoXkWJkn8CsHf+Ok7DcBz/ qWI5cdLdhFhOBAlG5mPsI7AwIkXiBXiETuywsfWeAPEGGe4BGE7MmRnYTqIBUvqN49R186c9Of05 9u9ziuJLE+eX/nFc1/ZHpBZCLJgT/7zbLK+HDri6etkpkdAiCy250EILvYawQssqtouSWZiCCy25 wON2HjpfLdTop01osbbSbUILtSiZBUQT+0KLsiyqNIQValthCC3U/2Zaiy22EgtbaPG3Jd4tZ2cF 3d//qNJfvn+mJ9cvjKvqEFpUE8gZMglDaIE0JBSm0KJab5YVrfbEFdX/9LuRXGAfvb8WWuAPeSOt xRb6/I3UYl3uCDfsaxAmBvfLFpPQYmx8FyWc+jy+TqDr++vk2+TFY+Z5LL69R7mPHysvznP7fh1T Fkxwx+6zXILjnGNfA2ccIrRwc7xv+5/ymIfik9DCBb7FFGr90hOGRBVtcgs7fShablGta8FFtbYF F9sD+qdOP0ZoYecz61h3iS7MuJ4S/Xm7WX/cbH5P9PiC6OdqRYu7O3pze0s3eU6/iqJ5/kwRxNrY psUQpSGQ6BRcDKyr42uhRTmwny3M+GcILpq8iHZi0nHq7WtLblEa2+xrHZJb2I+GKn0I9bpiw34V d4QWRLtCC0tQ0SyzWSWyeFSnG7lFnTZFGDq/tuLp+fk5vbo8aD4UTChiCyn65BZ2SdpVEneVoNSx f9tT2PXU9u0rCMJ0yTbLN+4gAgVlPTrZo0MbqlcZqYFHKZ1+8PJlfc4PdQyIBRMgYGKcr3WcsUx2 hUmAQhrMBkIaJJNxByB4AwZAxDpgGoKknKbdaRn3nQXJhEMA95xYJh1KSNUpXHJR55lTHAKAJYUt tLihaX4edJnmktje2/gOErLQAoMZc+4gBMFTQprEawi0q6ANCINf57yhOAP3J9Rnl6TKOZTlsbQf HUtKci/oI6ayYMqEPnAf78OMwqt7z0m1o2EiHJENCYL6HKBOtmCO41ASOm6CjGzccNhIuANwSCyT O/nMkjsAJlDXgWAc7XBTru+kpMrE2Os2n0i1L8RCwh2AQzLuAARvCKkfj9RvDmPOHYBD0EaUcwcx EeSzLgh84HtPSH3SYqr/dxFqOYS+Ujl3EIIzptzm4jvoi5ByB+EY3ecQ43Wkn0V8POMOwCGh3qPb WHAHcGJQn064gzgx6MMude99TLkFfruOoc6Da0xJvR9wr8bvUmOX3fgtLxn5HIIQDf8FYO/8eZsG wjD+JG0VlQqpUyeGCKkrYoKRjIilTKxkYenERwifACbWemdiZ4gEAyviC0TqABOqVLFQgslj3+va jpt/PefO5/cXnc527Lv37Phydz6/z65rAxTFIqs69DldltDZ2Sf0egdGUEIciyETmSCJYzUjbiFC FCJkwVgEK8oCFhS2ECGL/P4SMgd4WT7FeJ7lghapaAW5SdDir1mn+ASFJ6YoilJcGdGKdDn97o+J r3LbqkUsinlUQ39le3u/cHn5A0+fPcaL969w9+h6rktZ0ELEIpLrUPpQYIIfEZxIZCjywhZG3IIC FnlxC1nPhC9yAhhzIhYmfYpXZEIWxiYRtCg7LlRBi4bi+rK1TdCizrx9F0rYdj6+Orn3/TqFLGjh kwCEjfRcH28zLV+cgLepHNsWmGiCoIXttFyUWQUtwhW0uC2+CVT4Lmix7f6Cj20nn9qWNtOpO81A kPGdTsWwY0GY4AY341XHLdqPcZKnHCZjhZ1cXjGKrtDj0jZZ7lwfX05v4XerUs6THMwWHwC/ZwE/ gb3PwNUX4MP5eRKOej2cHh/j4eEhdvPJGAf4PKdZ0TiAGMv5LxapULzZPnRy36mKu90kTo5ZtJ/k b9LlqGZXYto0+/6fieOSPZlnemNvtk32lW1mXY6fK2vF6SXdQIUfVNAiTOS+ze4Tc491RNjC3G9J DBSFLUqBAhfT3PrUHMvlfya9GMUq8M7ODu7t7+P7xVIfjfdn4dEsfEV6u++YZG4StSjvI9VEXBHK IhdxbnmK+Rq4qgYH1q+VFUVpLpxwduLaiBbwBPMT0vkSKCf5XuB6su8Em73AwpckD0vLDOo0bh7+ 5iPXRlhEJ70roRK6A+xFcPISy/7ahLFTa1anj9TeIdrtbEh4g+ZcOxtENaYtAgAi0MW8JjXmt23Y dosQfrtt5NqADYlQX52W/23zxZgRwvpt95Gev3I/KDRGrg1QFE8JyZnTOpyYQMEbtlua9iIsr9vA BB0vXI22ORtdl4FrA2pi4NqAGuC4XOjtNhG2oGDPxKklt6ePdrS1FWVT2NceIu2vRS4NqaCPtB4a Yv2xoIllW3yh79oAi+hzLvdEsC++3CQomjxE2h9laILIsAgqjhDWc+9N+YZ0vLhNhDSGNHFtgOIF rNdCelY+dm1AQ+i7NsAi2qZdHf0PUxR3PHdtgEU+Qu9BMkE6pz6kdhTLM3JthBIEY7RjvItzptmf eufakFvCMsjc75DqNGV1Bq4NsAj/y5owxmyLMdLx2dDncucZITxRoWXwf+alayM8hc9o3prAfkqE sObEybzIIdzd5+zLNr2toyhe8F8A9s5eR2oYiONzCycKVmKpDp3EaXkAOqgoSA1CNCBdx1JTIMEL 7JsAPe/A1tRXUKHQ8gCL+LgNmdizmfV+3zoZ25l/ZCVxHHt2kziJY89PoRaqLmjuR6zU6zI82LbD ycndtRAJAlkQ5IKAFjRHYAXBKupgYBYccEGQC9zu5kH5ElBjvdxtBYszAAkDlOD+kzjQggAWJph1 DqXgsIo/C3Eu6IKAFjXYgud5CduAFkXxHabTX/Dm/Qt4+O4p3LzdZ7+qhkNwWIQLtKhQFgS0KP4Z EEU54fIqWAWBLHCar9tlBFhgOoJhEByDgBZUlgvUqAAoDtBCYRYRS/rQSZQv+ZubLFv6WB6q0GAB Takpu0JyFhyqw+FQHDv7yk96f595xQSCaGr/tuEHqZcXQvmxl3mIJO2VvgeF+qx3FYftIaVvc5+Y 9msyz5CeLX3m03SeCYq392wCXBhwQTFPtwmKsU5HdsJ9Kb9qneC4BLjgLtG5i/TlDJfTFzts4+vu nIu7YOd53QH4+7KcPwHofQO48Rng5/Q3jC8uqs3nZ2fw7PQUbh0f2zY2WIBGYGPpJTCn+E5xBJ9Y C6OwIIqeG7/D3M2TAzAKC8A4smWALWPBkz2LBwduATZu4a9j50+dpE7DD0fsUphFmlpVdQC7dvFa KQhoAQZmMev1YDab1SCLcv06XvcIsCiXr5XLFdyiXL60y9WXDgu76FXfC5ahN/f6fbg/GOwCtnhU hq9QQyswCwRXzGA11IKKo/WCxa0CWXCIhQuvcGvNdbX4qvhNNb5KpYpTORjna2+F7eiisKM6OZ1S R4HtCTsfYmfEFAbhZtIGeFTXOr2rtgs7QGOH3S4P6sH66guYARLkyD9EkRM2vZfVQifGY2kjWtQI 2nGkSQAADJ/A1BMxD5agAYxdGHSK10QubcQVlEE7dRue269sSGUgEJ7bY0j/Po736Im0ESpVoBpK GyCsxzbgu+5HG0Jsh8hgEWSRer3tW110NrqvBtuTqFStCttasD6OFXycgXnOVpiFald1uc0dnW6g E6yxDfieLfV/ZGDaUHF+iIOM3IMtISqTNsCjcmkDVNUxwLbjLjskigUSje+iI1BQOhe2IWTSRghI HYKrUlNK5/QPaQMi0lDaAI8KsR07VA2lDfCoibQBKtWeSunbTOx9Q3wqNfg2vpPn0kaoVJEJnWhn YNqLYvu+oTALFSmldoEuvh/i/fuDtBEtCr+ljKFbzyx4XmOf9pSeO5vQcxvwu8UEzHsLznMxi/YX 7xOJIYT78wgUaqFSedF/Adi7fh+nYSj8tSqgm25moqgzEitM5b9gLBMTQvwHRWLnRqRb7r+4tQIW ZsRMtxuYbrm79tqEvMSv+dG0TS9OnmP7O1l+9sWvdhI7jp/zvt5+h/keXYWDjqDKGpx1BsTy9yi8 2qfo/PwSo1HyLsKkEkxgwTERT6TEFQGWy4SkYrGgsMbdXRJubzms4vjmJpX5GCpDZUkH6coTW6S/ n0dZvw0z+WWEFiwnBBMJ2QTlrVSayShWBXmpYiawSMktUpKL9Va5VGeAfYQWg0E/Og+/Y/nLtw8Y vX2NweOUb2cXoUUQtY1iIpfYkFpEbYqpLBTxBJFTUDomqYj+iLQiJq/AYkvmNBNexFQWBUILJszI kmfERBYIPaGFjZC+dBK/L9lmU50cS+pu6jdM1meyQ17T9OjUZ4pjZ136pMvr1NWmk/YmdbXRji4T TEgQNzSlV6ItEnU79thjyzRRj6baJn1vPkR3nbKmHd9mGYlydcs2oc/EOaFp58hxHCKqyBEUoFyu itx6WRjm8lSiWCCfV5R3pQ/9b1+8TybQkuI/4NEP4P5nmv305ATvRyO8OD3Fk35/k9/r9ba8v/eU Q/yi3GeiCc6jWOXpill3LlbXmNNZUosN6QWQyy9L59rI5fes+XfVGuCgHcMp5Lq/IpzgmAhm1iqs ggCrKL6P4jhE8jKK47BeYxHFCyUvlbxQMh/LZVcZvRSCMBkj/1xf4/Lqqkq16UPqX0gNHVmm77Kw LknvCoGKw0w6zOQVGcqzASXpXafbenjbtkdXUPM5R5uo5zBjg5aHRxugZ/BEuhIaMIE9m6ZpY/BY uhIexmEKN5y9VwVtCmeyD+kPRdjZEDljeyZbFeNAzj3o/HTto7qHQnoeSeeb+sUF5PtFVdA5o74z hTv95w266QhjDrlrZLoT9F2YwK17+x266QzZw6MNTOHn8kXwfH6GZGxvc3wfI5mDvFRhiHoOlT2S 6zmE4LzfdNuFWq+ews6xgK6/bYQdF3DP+TMTUs5kq3EQdK9NkDjBcWWeXRef4RbZ6CGY/cBoF0Qk OUM6H2sCPNcaK1mnQxRtm57anEdUsGHTfMoWG3VX18BswxgJYbhHChr/mCRa0nYxREqU7t9Jt+Hi GDKMwl/pSmiE36DsQaB3t6/SldAEv4+nOmawxxniJ3jnelVh0/v2c2h0TGn62rWHPGrudx/Cnjmk jbaGOpjCHpuSuB3RIMxgzzxJ6r19CHvGvaqgPnSmgun9aIxkrcs1O2sd2L5+QvftR+lKaIKrNtc5 3LLL2/Jt3TGYwJ7v8NoGfbcxg8z+x10o7onUbaPXDa1rMFXh12o8bMN/Adg7f9y2YSiMPycxugTw 6qEB1KFTlxygg6cW6JIu3QqkN2gP0MFH6BF8gaJHqPZOBdJdW9duHtxI1Sfygc+sjdgOpUdJ/AEE KVIin/6QlmiS38XDuyQSvUYKWrynBwQtwNXV871pTmiCw06AwohclELswolebDZVI1whHeKRvi1i 4RwLavzPrrhSpBlnjvVFLcyaSUbswq2lZMQnWJhiQ9siFixeIcUtpKDFXyuQIfOQazTtF7SYTie0 XhtBiy/fPtPT19dbi+8dKmjBAhMQsGBhCwhSQKCC/UbAAsIVItw4smIWQtCCj+N8ZL5NmXX5+wQt SnG+SdCix4zx1mmec1+vdxd2x75AbcyL8YYkxsWLQ+UXy8LOofLTPj5kXrHUCc3z0BIr6LK8rvNq M1+Nc2nr2rSRXxt1uo3zb2vfY+jKhrbqzKn7n0KXz2LXxz322C7yO5WY3jfazm+EyL6gXUIV3NeH AZ+8L/aT4UPZEsWw+TV5scDFpGKj+ADjuKvQL4q35f7VAWly2/clfpnYPq/dnGjzrvbf1Mm/iJ58 Jfq9XtPy7q7Z7TbL6NV8TrPp1Pa/8fna7LBwvY2bVO4OcDri0VvHaYjD9lkAX54ul8GCF5UQtGiE LJAm7bK2cTzxOVWVu0w8MJh98fz4+LejDyRBi+Gzq6kgW1e5blS23qAenKO+np1RWZZNuHH19gXq eR2+r8PndRjxF3WYhSua45COfKxoxkQ42PDs8pJezGaNuMUDvKzdDzLVnKs6WqtSxEnHxfF2JeKk 4zT49555vl4P0f7WdNel3ReXSCT6DQZ7Y1JtGpSXGAtvtQ0IxLW2AQGJYTBrIj5WNJyJiiHAwl63 1skFceGKlsvmgd4LMm3oUBYZCw3uC65P7BPpQoIJWJrPAyYOfbSOBS5y68dGRuad+wONqw5hwZtc 24gTWJLuxDQ8I/LZzsk937G1MRmZ5xpuTJP5cF9W2kYkEhGz0DYgQuT7PIPfycJz5IV3gXdzucgN T870wzFP0Ow7C4rvNzlGhtR3JUF9Rl0b0jNQaBugANrI72TaYnzbxvQdyWKIcDfKtiQSQ+KGXJ1C Px4vtPFH+OSFJZl1zML6XYiG/Wwxb03Q3g2pnyzXNiDRkJP5fU/fQw5u/zAepAuBHwZ1fEHuv6Ux 9R0eC8Rzc20jFMi0DQjIUH+rE8eTaRsQkFzbgB4xpD6wNH7rMIZ0z/F9XGgbkUgcwSdtAwISU590 DBTaBgSkDwvxJ/pDoW2AAugzxthxtPmoTyuK6zosyP2Pl/q7Ej5D+lYotA1QYknjmluJcWxLGtf9 XpH+GPG+gmvmj39E33hB2/+7gzxQmRm5PlceM8lx2O7bf814f0iCsonEI/knAHtXr9s2DITPRQEP WbJ0t5EXaFGgs/sIfYL6Udq1D9AlS/oEHTN0ERB0KFCgY8dqy9ChU37s6Kc6i2dRjOTYFiVSx/uE A0mLPJKWLJNH6r6JMLXwRGAOoZo6qzsBovj3Qt7sUnR+fglnZ+U8hEgliMCCQiSgqIgrMlivS5KK 1Qolhfv7Uu7uSJJNeHtbxSkPlsGyqAN11QkuqvorNHmDy424SWiRbaUks0BJVLoioijJKHQSCyKv 0Eku2ggvTHIMIs1of75Mpxnc3PzexD9ffYIXr+dar/JHIZFFIKEEHUQwQWQTSZ5siSjwMMkqiMRi Q26BaUVoQWQXejnUhXHSm9KRp5DpR67apQguzD4IRggfLt3QbXDZ577r9sHZsk91+OpA1+frZKtt Pjoc9kWHLV2uy9vU5bq8LV1D9GNoIgUf6zskn8v6bffF93zHlnHZXs55h66r7/tkDGW6lOtati99 vujoQ1efOgVPElXodtwaUcUR1AQ1glgit9Av7C7Tonm+6ZxphiRkRr5d4a44Ak2KfwGm3wBWP6uP 5ycn8H4+h5enp/Bc/84mk0fe4CfKQT6de6byU9o8T3lshnodVH9jm4z4luzC0LXtb0Nf2+DrCkFg axfBo/ZzV4QTFGaKlAIlyTJIivChCDei4qtC1mm6CSm+VvGViq+1/A9KT6pJlpdrJkhocXl9vU+z vxTyA2jhhBZD6mld0oZ0m+iLJ5TOtc90pnJToCHd9nWzhqxtC8YCS/95EYhzB0E4QMcQF64b0RER 8PnNcrgegn5wAfVNz4JmkBO2COpO2A51OEAbvckRG5FZjG2ztyu8g7BeOF5A6QDUVxCZAkqbM8K+ sYDqJcY+HRv6jLcwPqc3s0L+uG7EDuALQBFU93bsoA1EdLQEubcFAkEzYpAXPwV84YUNw/e1C2Wv joCP7coEt7EAzlm+um6EYxBRIpHJDQnd4TNKqGNsW/gIpRMKQYkI+D6LQwI6obdG2D7kOOKJNewF +G1fPAT4PzJz3QjBFksIy+lUF6AdneznkfosasvcgpkhtLYkdoH9gHsHl64b4QgfoHRSyQFW/6sF o0YEfMbfoa19Hwuc0/9z3QiLkBcv9sMS+Iw3cTy4sKnQd9u1wD067nePgc9c4xUImZAOnEf+ct0I CxAbUR0R8Bkfu1wbjIHPs+9Y4Lyb1vDigeumfXIksp+6G7jPOdDOyuUe4bYn4hDEENZzN8T19SXw mdePAThGjvfMOwPevz98B2BwAiSx1Qi44b8A7J29ktMwEMc3HzfczBXcUIXi5txAx/AGkIqWGXqG e4ODJyBvwEdHlwfgIdLTMMMVzFBg3oDiroAQC6+tjdc6+5KLZUtW9pfRWIqt1VqxbEe29B+7dkAQ WoQLWuCA6hsFLZCTkwe163KhiULcggtQ5CIXCRO7KEQvlkuVCVfwgN/j+rKIhSqV0Y6gRTF3klKm mAXFSbxiyUQuqgQtzHyFWEZeRj2Hh3/h8vJHFv/09SPce3if7ZW6tswEI5RaC0eQoAUKTNAHBSm4 oAUuTeEKErQgEQsStyDRC27jH31I0IKJWWA680Ml68kCRdBCsEbXh4/Lw7Xtstuy30Wd+T5Bra+2 bNu15ZtMyty+Ldf5bdpynd+WrS72o2shBR/Lu812PpXfVZmutts1j4s638Vm37ZtI79t26HlaZKv ad627Pliow1bbdoUMng/UZVQBT10wpdAaVvcjse3ZaA/mJfsZWkSuBgocooy5IG6Fs2iKJ0Y2/J1 mB6yOM+rKpalnTfKxPQoDROAPy/T5YvU9HeAO58Bfl5dweziItvsVRTBs8kE7h4c5H2oQPWnzWE/ IgpCKF0PuIRyZ3G2S+n3JByR6N2wtRxUlKGYiAZVxZBVw1rAIs0z0vujtI11NZkvC7Pjx8T8OXxA BC32D7PpZ0cAtU/IxVuUbifYHvDYT4ZDSJIEVmkc06M0PUaBijS+SuMj3UbGaXyl49lTEFyPdrRo Bm/36MPp0RE8Oj6Gb783zpn5JA1fIG+i1KTx7JSw73ig4iitAK65MGDrcLky3DM1awDqz55VVVv3 nSAI/ec1hDEgRBC24Qw8mICwIZ2/yNgisWsHBG+ZgYhabAMOgHkKNw8AxBegq/6ghDJo0DVvYP8m 9Xjv2oENUJugCZFoQMRCL3loCheDwTAFaVsITsa1cO3EDsxdO7CBxzqc63SVsFEM9u6vplA+tkXs qBDNEQShnpAHFgr7zQfw/17BJ0LquzKZQlj3A7FrBzwAr13nUNxn0z2fOclzE8z/jjLhczuEfO4R 9pdQJzgMqb3Grh0QSswhf74k19jN8GdLbyvW1000JH2EdsB7zjPXTjgkcu2ARUK9Vgu3J6Tng7Fr B3pCSPe0v1w70CMi1w5YRK5hQp9AEbFQ/ufhOVfaX5lQ6mPm2gEhSGII5/y3K891QPAcuoD8vGHz PTm8tychenqmF9J/PF/Aut042Lan4L6F1Ge6cO2AQ/D9+HeunegQHEuK+xxq26xiDvIcqUtOQeqa wPf/I5C+V0FoxH8B2Dt7HaeBII7PQRR0OpRDtFCYjgIJCQrawBPwAEh3oqHlEcJjoCs4noKCJlS0 8AZpEC3FSQghEjy2//F4s7582Z71Zn4nyx9nr2cTa/2R9fxMamH0HV8WLN+y1+sKurj4RMPhSTYt pRKQTGA5SyikzAIiCx5DWOEKLFhsAZGFXF+WhfLluMSX8Q3L5sU2czGPnEkQWkBmkYsnynlIKnj6 rxBWlCKL6jI5llKMUpaBeHxwzrLh8BddXf2g5y+e0Kv3b2h0766o1aIyhsQCQgv5B6GFlFBAaJGJ KgpZBcQVFaGFEFksx+lQEVoUMgueZnkFT2PfJrSIGO2vT3v/XdJ2XUMWJWgQagLdQ/ieQooFxJaU WXv7JgmpLia02K2srvfXF6FFqPtsY71dt2kjDs0yQ1m3ie1DvG4NeZt9ttt327bKC6WMNspqs0zD y3WiiopRvSbv/6aCC6y3lGNIAQUJuQWWSduDK7jwSSuOPPPu/+ZUWw8v7j6Zk7SYp0S/ubvRT6Jb n4n+fCP6OJtlw8PRiM6ThB6dnpafn5AmQAiBsFANiCZkVWVW+YqMYt+xU+4NiDacaiO5/5FYl6SM o6jXUnBRzC8z3gvxxXWCCy2lhMksDAbSluVxL+QzmQ0CcgseUy64qBsGhcAC8/+KbTPBRVHegqpN 2u3BgO4fH28itXiQDs/S4SvlTcdNKlvDukGuA/nFwjP4JBeYhujCbV1l6+i2lIZhxA936n5H/mQF hhEb/JJBQv3tCGid3o1DYUZ5UvQz5Thi4LF2ABHDx2jogoemmVD/jim8EFH3ouEXZx6JS13GYprP x337HLqCRQsT7SB24Jz69zLqOrGRHdvN81Y7AMMInLF2AIbREnzdb+eA7Yjp2ZVLTAkLmViSRTVJ 3TW2vL6GVM4FSW9AQvaCfpfcWb/KQTGl/t3nGqvE2k7HdD6dagdgrDBJhw/aQUQAnqsbzcMy+pfa QSgT03kg1nO1sR2JdgANY8f1ZsTUls20A+gRY+0AGmSmHYBhbEFM18+H1s9sU/j5e5+fZXKi/Uvt IAJjSv3+TkNhSvY5SvhZ1Rmt9it35ay+PnKQVch56yPXLfz5T7WDaImY7g+/awegzCXlvzHE3OdF wvXk/lAT5Ti6ZkL2O5KhA9/b2j2hYezBfwHYO3sdp4EgAI8DyhV30klUV3CSKa7iAZCoUlAi0SJR AC+AkGiu416BN7gXQII3oKU96SREFR7hTkpBFDt4dnfiyeLE97P2rDfzRZb/17Pxb2J7PpVaKKnC U7G9qZrnbTMcH59sHIfSCd5wuYWVVJQrWUXdWJkFF1yQ5ALHkxSjqWwSalj83ERLNowLLXhepCah hW1sP8korKSi7p57w+ZQiy+40GLBylu4ZbUJLbKqfr9hNpvDh9PX8OzTSxjv77Fa1XIILovwhRZG ZUFCi+XCiiiqD3Y3ySpIZEFSCxJckMjCaDCcDAPLoHZBn2Xxn1DDrB9PaKEyiwSQXoUSy5eqc4yJ gSXL7Xo5sSbQjX09xZa8OFSZsdYrFSSTeMeyf/ZRj77rGlIMIL2e+q5vzMvsYrq70kUckmXGMm2I +WObvs957orkOaSL8mIpo4uyuixTaYX/j7RNcGHlB8vVdNukGJvI3AfnpfJMv1vGSnDBU6hTGnWe Ph3Y+CYbBLBpKZ07L5fP67fXKu8tE/sxVfxjgL/vq/asGn0JsPcV4Nf1NZxeXJjJ3uY5vDg6gkfj sQ3PSR5McU6oUJAkIstW432fB2ySUQRoZ03LYCILYOPWMt9T4n/zHbpxTGLhCy64MdmXSfirow9U aKH4uzpty7Qdj9w+OXIyCiOmGI2gLMtaZFH1P6ymQZFFUXU/qLqN3KLqLly3uSPiZBcjc19h3SCB MTw5OICnh4dweXXVFjbeU/oJtbQCi8CjUQnNUgtaHPUv2bAmkQWXWPjyCv8o2HS0bPpqNw1TFGX4 nIF9OEofzlZ2gY8w3GSEKT30/kc6ACV6zkClFkq8fAebBH+XyGG4589t+C9+6oug9wNftphKB3FL 8CXVFF8S0W07LF9AEzkpShsp/V5VFAJf2E/xGrhLcukAOmYiHUAH4Hau9wXa8a+nX4lEoSg3Zyod gBKEVH+H5tIBBCTVdTRkzsFew+v1jRIj+DDhBJrlw7tESvunngcUJJcOICC7nrzyNuTSAQTkh3QA AyKXDiAgeg5ThgI+z5HS84PfpAOIlCkM+5mWd9IBKJ0imYhfz9c3w5ezDvl4ogyTiXQAAZlKByAM /m+LzxJ/lg6kR/B+CtZ5l/6zPge9j6TIoFILRbkn/wRg7wxynIahMPzSoBHqLOAEUIk1S5DY9Qac AKlrOAAshw0XYDkbOAIrtrCb7UhzgFyB1VRlmpCX+DWuJ2k61Mlzkv+LLLuOY/9JWyuyE/+z9iIA BEvdalh1eR/aKrq8/ElnZ+dF2jaVEJMJyU/TyuDCNrQoDSyq2DawYGMLMbIQ4wvbEIPrkvoZu82H G1qIuYRtOCEmFlvLsOKvMaqQNJtXbKy8jclzy4mhRWmCUdV/2NAijqP8Otzk57uhz1/f05tPb48y tEgzy8jCMpkojCxyXRwXxhR5ujCsoMrEYp2t6Ta7LeJiy6ogZWwDDK6DY9fQQjYYWowc7a9wSoYW XRO6UULf7YS6gG7o31Noixd3WedDCe03qn18V3Vpth36eQzZYEJbe8jmEhptdn0OmjpgaOHn+NDK 93lM322demxXhKZprPeXYG+M6d6+LKtCw3YsYm4xy7ciFZlgtnsOD/bS7HZeVLPP/dy0z62jLZCT Zs7z6/KaaP2Fiqnpxy/L7O9JQu+urujj9TXdmMXqdyOmvLh9lu1GTzm9NUHSvHh+an3mcOek7/Iy PuKt2wa3TbSXz3lbsyj/TqtJi87UOp+dSYnJk3PPrH0u9khzV8DQArhEUbT/9xZjFzaiMKYWu5hK g4tHYmzhBMlnYwvJm1mxHaTPm8cxPZvPj5H6Ig+vqOrBYqo3s5g1lIkaytSZXNhpuTTkpA/1jACA abDSFgBAT6y0BZzAUluAR/CyDWgjoXIBaQBCgxfzWGmLUOBbHp5oiwBBw4ZVF9oi/gN+QQS/bXAI ngy40BYBwABYaAsAwDN837+kab247YOFtoCO4fvGpbYIz/zSFgCAJ55qCwgMjL+Pg0RbQEeMaVGx RFsAqAXGdCBEYGhRMjZT1ERbAAiCpbYAjyTaAgbEmPqzRFvAQOBxh+etpYYDxg3AUFhpC/DID0Kf 28SQ+6TfhHmWsaM59zDk/wYAU2KhLcAj6HfK54n/aIvoEX4GZopzKlM8Z6APz5HjuRYATuCfAOyd QW6bQBSGXyynyiKLXCCSs+imUtUTVHLX2WTfRZHac1Tppuseoftu2hukOUMPECn7rGtHrcvDPGYG BofaA28Y/g8RMJjhAWZwJpP3QWoBUsRO6JPRNvHQTs7Pn7euE4mFjJwDzJZSGFmFiCw2lczCFlyI 5ILXixSjXvZfxwtRTylWl1dsSqGFb2SBhcgmRGjxSEZIYWQWZn4rszByi7W1rCm0MGXLPv0cHx/R avWrmP/y4yO9eP+G5s/m1lG2Cy14KkKJQmaR7/cxH2QqQopCUkErI66wJBYithCRBQ+yXSHE4GFT /KyEGTyI0KIQWXA8ltBClknMYORoX8KpCS363HfsooSh9xNrkvvYr1PKQouYBBAhytPePmRZsSQB n9JxDC2YGIPQInRZGscMoUW6QotDiU1QkaLQ4hBi/O4U03fLkOX0XSY4iKdEFRtHXNBsT/sfbLnF 7GjmyC0cwYXZoF1u4VvXJrTwpXR/6rVvnwynjr8g+v0hn37OF78lOjmhQmjBYovL21v6dn9PD+t1 eZ6M/EEEFzz+sQQRjjDCFk+UgomGjCLAVFpWfcKLSm5RCjcaQotKeOLKLWSZM3aQW4SsFkQgAIBQ /zQ4QgsiV2gh4opSVjETgUX+em7N1yUXIsGopBbkr04uTk/p5Vmn/gWvqSmk2CW3qNd8vhDsmq6u +6GW9/tOYdup3fVeAMC44Q6on7SDAGAAuONtph3Eniy0AwgIOr2DLlzTtP4xAMTPVBPbXlFayeZA P2TaAezBMh/faQcBoiej6dX7AOxDSkm8AGBZ15JQ/wM/V9oBBAZtdCAVXmkHEBm4t8fPT+0AemKh HUBgcK/FyQ2lew+BcSJCC9QZaT0HUM8AIaV2UdRT3Unpb+e47t1I6V7n9m+0fYOxkGkHEJDv2gFE zJifRdfaAYCkuaPtcxuAFFhqB9AjC+0AAjLmZ3Io+Helr9pBDMwUBQ83tJXOATA0qfU5A2BQ/gnA 3tkrtQ0EcXyBDB+hyAOEwkOfljfIY2TGTR4hdahICwUVjd+CMi5pM0ORDl4hNGRIkNHqdPLqkGxh zux9/H83Nz4kfFoLOAlJtz9ILUCsDE3U83VZRxcXl7S9vV+1Oa+XSfBFjcDCLmfhhJVPzKUWRSOw YFkFiyseHh7LKpcXQnwxawkx7Da4b7ntdgoxm5bMtk01ScgKsd5ILFhmYWQXVmbxXwgp/jkSCyuv mMssTFuul+2XCS12dgq6vzdCi/OfP+jj50/iU82eJeBrBBKzwogs6sISi6aUbRZSsIjCiikaYUVd rdDClV08E1rMjBjD9lvJLLgIoYUValQJ7+oiPwOIHO0fIYQWcfT9FoQmC1gXEFro9RlKYmdf/Wm/ 32dfMYkg1vX+1AUTsQgtQpVLhCKqGEoMQouXoL19H32HJqhIVWgRkkAjlPOE0PpZd5/AK0PkFla+ 2lWGYiUWLLho5BYbHXILV1jRJ7joS+tOS9b1ySwWpXaXV4L3y/1yRPT3pGx/I9qtL0FObm7oy9UV fb++pt93d2b/0VxwUThCiEchjqhea5lES3Dhyi1qGcUqr9UV1g6ZRafcwgouhIBDtluyC2oLL1pX kcXvTxc+5BaQWYBlWJlF1RZfbwgZxaYjqeir7zqWbUqxhah2jHu/tUUHe3tDQj0s6xHNR6xFQouu 73EFF31qH3d0tLuGnPaikRAAkAfHhInXIA/G2gGsyEg7AI/goXcwBJ4YcKwdBAA1uQot2Ng40Q4C BM8ZmUk+sXGqHQAIHp64huQSAAwjpYROIG842ShPIM3tvN8XOYwFY+0APINzHQDSBff74uZWO4A1 kdK5wi/tAMBCxtoBACDg/zFxb9yQ0nHgVjsAEAwj7QA8MtUOIBJG2gF4BseoYeAYBsDbw393qYhs +d7TRDuIgJlqB7Ai/DzJVDsIkDxT7QAAAEuB9DA9cnuu+APleU+FZR5/tIMA2QGpBQCv4EkA9s6Y p20giuNPKAMDA1MnkIIEY+cOXbJ36NYVkPgAlfgC4St069jP0C+AmBmysXphReqAFBGSNO/sZ5/t c+IEO+98/v+sky82Ob8z6HzY5/tBagFCw57I55LiCYfWcnp6UblPJBaSeK4vW0qRSSoWRmgh21hk wWKL2WxutnMSuYVIMbIy45RJNIpCi2Uuz8KKstAiTrHMQoQT85LMIi+0yEQW8ba3ZFsmtojzdhnv adlxqp7i7PBwSq+vTyb/e/KLPn05t2q1LK2N0MJMxmbJJCzBBC8soTCLJbQwUguyZBY0TSUWkhe5 hUgvRGjBC4ssOC9iCzl+KrVYLnLCjWIdQIfp468QQgu/ym7rGL6X1zQ+TxbcBBBa+Pf9JsuC0KJ/ gol9lLVLuRp18V3upS0QaevYbR1/W/YVr2+CCggt2seXfoJP56SIz7GBEptEFbacoCiP3fbelcgt zFoEF+QQXGRfcMstXPu2kV3UFVyQ4zNPJX9CNL1Zre9WxfwgGgyIHl9e6HYyoW8PD/T3+Zn+zWbJ ecokDwtLADG3BBE5YYRDZuGSUdRZGyVxxf6NgguWWyTCjZLQwpJZ5D5b9UtTDbnFtk0GhBZgHcW/ jpzQgigvtHAIKoy04uDAiCwGST6VWyR5W4Qh5bmaj7OjI/p8fFwn7K9UFlKsk1sUW7qqFs3eThV5 V6tX59Su+1kAQPfhAVIYmAdChwePD7WD2IGQBr1H2gGAzsAvBmByKKAN941G1M+JbccUv7ACQBXc Ro+1g9iBMYUzAQJoB277r7SDAKAjDAn9BRAG0u/Hi/q7U+vBWMcJ7YV+/j8X911AKIy0A/CMe+0A wIeItANoiZAmgkWf0W8iMqM7AVDnmnBNthlpB9AguA4AIaRnTZF2AB1hqB1Ag+CeUH2G2gE0yL12 AADU5Eo7gAaBXHozXbwm/dQOAPQCtB8gFEJ6NmATWr0i7QA8IVqlP9pB7JmxdgAKRNTPegNdvlM/ xtYB0Ar/BWDvjHWjBoIwPCFRQkKD6JCQsBSJLh1SChpKREVNlYqWR4CaijJSEMpbpD2qvEA6dJJ5 A6Sk4hLEjdd7Hm8c20fWnt31/1nWrS/23n+O7XOc83yQWoAY6Vug50NXRycnZ7S9/ahoc/0uU8iL hGCCyulKcFFJLYyoYrEwIgsWVxiRxe3RCi2kEMO+hum7KZ0sG2YEFkZaUU3XhRaVzIIfKwHFdSmu 4PYfR16xEM9JuYWVYMg+ZP83ret1Z+c3XV3N6c3bQ/qef6MnL56Kd1UXWliBRVE8TsoshNCChROF iGI5FCKL5dAmsViJLKzEQggwbB9WjsEiCx6kPIOHQmRRCi3cQoAQWiRACL/CsTOkKrQYEggt4ijY 7oNQixdDaBHe8j77CmWfmJLQoi+hyjGGKp4f8nvRkkSMKRHw0edQgojY5r3vsmMIKtYldaFFCPvu EIR0vjF0f2BU+sgtjLigeeiLlViw4GIlt9hokFu4Aou2su19hRbyZ7Lke5fkgpw285jo7yui6y9U fBXx4YF5+ng+p/fn5/Tp4oJ+Xl6W67YSXEi5xUoaIdulTKImuHBFFKXwoumxuLJaLtM232r+O17D CjduynlqAg6i27ILqgsv7JVlKfboEly0YbcTAPpiZRZFW0xvCBnFA0dSsWXFFs641SC2kDIMOdpt dW9zk57t7vaJur8cX1J1hGoTWjTN4wou7lL5uEdDu2rIabcd+QAA04CLWL3TDgHACMR2Q1FqX3pH kQewDrHtryAtpiy04M+ej9ohQNDYov+x7R8Z4bMFdMN/F8e2bQOgRaYdAAAPQGgB1uFIO4BnTrUD AOAJ3PxfZ6YdANyLmXaAgUjpf125dgDQCUvTf2mHAJOGhRan2iECI9MO4BFcPwBMSuc2TK4dIBJe awfwSK4dICJS2t9z7QAA9ORIO4BHvmoHiIBcO8CacKHrXDsEmAQz7QAAeCLTDjAQmXYAj/zQDhAY n7UDjMxzSuv8uy98no5tH4wN7tkG4D/5JwB756/TMAzE4ROsIJjYEDAwIjY2BDsbEwuCgRUEG2N5 BN4A3gAW5ooZiTdALIiNDYk/A8RJL7aD2yTUzTnO75MsN43tXpvWbVP3PkgtQEyYCXwOkrJR1mFx cXXoPpZYcFE5vUwphZZUZOIKvk6LLnTN0gvVloUW2ZhmUbfK6cGKQgsaCC2sdGNkCy24mAIKFlew vELXLLfQEouvvK3u801akMHjOw0cBk/0/v5CJ+d7tH99TLMLc/meYjK9VGZBP5bQgqUWLJtQ4om0 DCQUSkiRCytIiytyscVAaMGCi1xsYYgscqEF2UILMwaX0KJuEkAQKCEcQggtwh8/1CTFTRJyMl6f 40Jo0RzSEoiQntPS/X0RylzZtJQhZAlEXUK+L6G3+28fyXhjbjsuTQgtQpm7XUBoEdYYkxgLREWZ qMKUE4x7XovlFmnNggtyCC50B52WnbeL8gvedqVwH7avithiWIp3lVp+hejjKKkvks3d7OqHtzc6 fXyknft7unt9pc+BddiUW7DgIhdauIQRDpmFJbgwatWXRRV57WjnqotjmsILlluYsVhCC0NmYW7z /bVKBblFcS9kFqAOxWeLJbQgsoUWhpiC61RgMTWV1nzZJbqYNqUW5J4uVmZmaG2+Uu6MTforpBgl tyjKKkZpf4bNYKNmuSoP7ai2AID200/KmXQQAEyYti0EXJYOwCNY+Avq0k/KpXQQoJN0PbHtlXQA IHiUGKKNr4+rpMyVNQKd5oLwx3AA6rAtHQAAY9L1z/2gPlsU19x3Ix0AAJ6IKcGkD/qUvceBdhLr 55Jl6QA80pcOAJSiZKWH0kGAzgKhhZsl6QA8Eut7NahHTN9BsI6nOjEdd8xl1dmSDsAjOO6gDai1 vbGs6VCyRbzuymnTY6TOufakgwCdQZ3fupUOAgAPrEsHMCFi+n74LB1AYDxTJrHqEj3pAIQ4JPym Dpqlbf9lBSAYfgVg74x124aBMHypA7dwlr5BDXTumKGb3yBAnyBbp+7dmqFzkaVAt/hBOnjICxRI gABZ9AhFFhdGHNcn6iyaUhzKpnSU9H+CIMoSqZMNy5JM3QepBWgbvol5Pr/U0NXVbxoOT9Iy5+kS sYQILOR1zmcmEopcavFkSSuMsGKxMHILexShBU+lPpe5vi3J8BdaSOqxXGKRCycerfminCKXV7iS i3yZKT9mbRmZha/Q4vj41XrfbtfjnL7/+kIfv57R8OT1ZnlZEr1UbLHKRRabYbXMhRZkRBZcTuUU tNgSWcxXcyOzoH8FsYWsz/V5SKUY64GFGfa2ZBChhUnyVhRaABAECC3ib7+tX/dYE+jG/DlBaFF/ G6Ha0q4fsi3t+qHaamI/YhRMxCyBiGn7TW2z70KLKsQgnmhSaFHn+VxTQouY6xxS79C6dbUXSxt1 tFVnm0AdH7mFe5/rJSlGGbbIYiO3OCqRW7gCi11p3MvSvj+3rEyM4SO5cAUXb4mW3GX9B6Up3d58 MC//vL+nT9fX9O3mhu4eHrL3dltwYc8vLVlEWs6EEluCC0dE8SQyCnfMRBhVpq7kojBm62wJOIgK sguZF+GF3HmW/fQRXEBoAQ5BZBZp2Zo/smQUMt0lrhiI4KJEaLERW1ijHMNGgwG9G418Qn2/Hk8p P0LtElqUreMKLp5T97hHP3lryCnvUvkAAPrDJfWvEyboD9zptG0dAdHpHfSdCzIPeQLQFH/IHHvb 9NBsSFhW0NUHyUAY+Fphqh3EHvA5YJeSjoDw8MPgF9pBANAyxtoBAHAAfJ05of6e94P9udQOICAJ mWtgANrORDuACJlpBwD2gv/D+qsdRE106X5joh0A8GJGkKaD5oHQopyJdgAB6fJvNajGWDuAgODe mD9j7QACMtMOoCWMtQMIDL7voA2cawcQkC79l1AnM+0AKsCfaaIdBOgVU+0AAAhEl56FEbq0T4l2 ABEy1Q6gYVhIfK4dhAIJob8waJYzSrPRAACq8l8A9s4fp3EgisMPFLahoaVZZSuqvQIK9WrFngCl 2AMgbYtWe4Q9wt4AaKlY6i2QuEBKKiS6wEoIP9svM7HHjpOM/cbj32dZ4ziemef8mTiO8z5ILUAs 2Il7ppQlGKrl8HBceZ9ILGS2BRSZmMLILVheIeuM6MKU2XpT1wgy3iyBRlFoYVKIZUIL18wCC5FN iNDiPxkhhRFWmOVMZmGEFq8F8YVd35ZlSJ9u9vZ2aD5/SJd/X17Q0dkxjT6M8j0qyyFsoQWXIpRI ZRZJvyyykFJEFKmkgl6MuMKSWIjYQkQWPInIIhVi5O3wJMIMnkRokYosOB5LaCHrJGYQCdpPpXb/ XQKhRbf9hJpAt+/PUxNCikWILSmzdn2fhLQvEFps1pav/tpsS0NoEWqfbWy3aZ024tBsM5RtfdQP 8bg15Drb1Nu2blvthdJGG2212SYIilWiCltO4DpP15SF2CKZlgQX5BBcmEplMYVLUkFULbSokmQ0 EVsU+2Q41fwnovn3pPyZ3Pyarf739EQ/7u/py90d3Tw+0stbLhwmI7cQwcVCaOESRhQlE8n9tuRC xBSVZUGMsaqU5ZLwIpdt2GINideWWdi3ZX+XZofcQqQAsg0A61A0MCwJLYiWhRYOQUUqrdjdTUUW o3x5IbfIl20RhrTnGh4+7u/T54NG1xgcU1lIUSe3KI5edZqfqhGrblRr8tDWbQsAiIMpIZkViA9+ TU+of3/QxEXvYOhwYpCpdhBgMMhnxUw3DDXGhD9ogHr4PTLVDmID+ATNH+0gQND09bUNgDYxfV8F w2LoIjuwHZyU+1w7CI8gsRaIARyTlLnSDgBsRKzHJhPtADzCycxn2kGAxvwiSNNBN/DYcEI4B13F WDsAj8T6WQ3WZ6IdgEdm2gH0CIjahsdYOwCP4Fpg0Af4uo5T7SA8gvNzzejLMTZ/78PvKaBreBx5 1g4CAA/E+DteTPt0qx1AgNwm81/tIDompmtg1oGP7661gwCD4pt2AAD0kXcB2DtjncaBIAwPBwLB FRRXgnSh4RVoXZx0PU+Q4h4kUNJdcw0Pcm2k4xGg4Zo8wkkUSDni4Nn12svihI219qw3/2etvA72 eBITx7Hj+SC1AEPCtyDPj48C3d7+pv39z6rP9bh0YS6yJBNUTpMloahFFrW0YqmkFvO5llvo/kKN a6FF7izvCjPysijY+6Yfz6mWXGiJBcsstOzCyCyMhIKbFlnUkgojr5hX4/d/t4UW/zcSWhwc5PT8 fK/6v/7c0Mn3+nqfK4WwZREstFAii3JgiUU1FH0WUhihBYspKmFF2YzQwpVdGKEFP66EFhyjGJu4 SmbBgyW0MEKN5XJZTbvPASSA9KaUWL/Uc46xMLBk3K7XE2sB3di3U2zFi0PFjPV5pULsIog+YsUi tJBYX6yxuoob6+siOV9bILToZt4Qy8c2f5/LtAVCi25idBGry5gganzkFkbq2jT4YossKrnFToPc oklgsaqsu6/QwpVkfPKI31QWnvlCtPhWjG9IXdI/OtcP/3x8pMu7O7p+eKC/T0/la/tWcGFPLyxZ hOrneSW7cGUWbntxWzHfpuOmuK7gwuS4UsZhTRvhxZuz0w1yC4N9VhuATTAyC9W3pncsGUU1Ji2q 2DNiC6ftOWILV4ZhN7PPOtrdpdPDQ59Uz4p2QfUeaZ3QomkeV3CxStXj7u3MS0NOf526BwCwXWSE m9lAOgxVaMGMpBMIyFQ6ATBYpkW7kk4CJI/5rPgnnIckfHPGsXQSIFq4AFwmnURLJoT/bbAavgF8 TNu9/wegLSkV8QLbA477QQgmlE6hChTEASnA3/dSeU+GAu/tYTLEa1g+jKQTCEiq2yhVIE0HfcCf txnhOvg6UjpOm0onAKJhJJ1AQHB840dK+zJmJp3AQMikEwjITDoBADwYSycQEC6MO5NOYiDwd/ch nMfk39Th2uJ2EcvxH2QqIAUy6QQ64Kt0AgHBeYFmJtIJ9Az/BjCTTkKIMUGQDvoDUgsAWvAqAHvn r9M2FMXhI6hUBgaWjkhl6MjE2MU7qniDir0DfYIqz8DGFt6AR6DZmGDryh5lpEAlkvr4+iTXjm1s sH2Ob36fZfk6ubaP4z9xbuzzQWoBQsBP2POdXGKhSvb3v5S+5wsnRHLhCylYVCFyC5ZXyGtOauHe c8ILkVpkhRaJOGFOaVmWKnILSRFWJLRwvasjwomXnMxiJadwQxFZiLjCySzWy/48VvN2fXkqsp2d f/Tw8CcpX9yd06ejg+V7pUKLJJGaJ5PwBBPcsYQi6VKhxVJkkYorHheP9ERPS4mFlKWO1Jd5cMci Cy6L2EKWv5RaLOYZ4UZ+HUAAaG/KTRJadI11UULfy7GaQNf6drKWvLjLeTbF2j6qPX1X89JctvX1 0JZC9LG8TRNa1GVoQgvNOCC0aGd6a/X7nKbvZb132q6wFlOo15dAjddEFQtPUODXe6vcYivuMoIL kVu4Suup1/NiijL5RRPZRROhRT4F/EdKUtb//REPfxFtf3Mv38xm9PP2lo4nE5pMp/Q8n6ef00pu IYKLjNwi/gxEEPGaxKJIfLE29KatMywVabBswxv3hRa+zMIfl/WNN2zSJ63XNQQXAFSRNzBkhBZE WaGFiCtSWcWWCCzi8Q9eOS+5EAmGL7coOh0c7O7S4d5enbC/0rqQokpukT9blZ2x/NeppFx0Fqvz 0VbVBQCEgSR5GMLDIgBUcUnu4ZKhPlAUUpJQ3PQO3sMo7n9rBwGChfetiIb7XdEGfJP8iXYQwCz8 m4D3kSEeI3wdeKYdBDCLJJ3DdSoAzbGSxAGAJnAbUUTDvKYBtuAE+uO4r/UnoHH4eBhrBwFAC0Ta ARiDj+0r7SBAY0L9bfpZO4AWCXUbhcw1QZoOugNti/UIqQ3pXjsAYAJuC0Dyys0jpHMZ7rupT0jb Hcc6GAKn2gG0CNrlmmH9HMVJjkfaQYDesfIf4Fg7AABaINIOoGUi7QBahNs3cf9MMde0eb+fR9oB KMHHAN8fj2dnQR/wszpWrjMBGAz/BWDv3JWbBqIwfEwYF04HFRUaClq6UOKCgqFieAMqGoo8Qipm QgV9huhBKFLkBWiSggI9AVXSeGIHHa2PvN5IlpysfHal/9Ps6OJo9csX2Vbk80FqAWKhbSGez00d nZ7+ovF4v5jmulumABeVAgtZzvXJRGyxklIsClkFSytMW9BsZuQWZvlqWkQXvD7Py/rSn9nW7Z22 WMzzJhILV2hhCyduLBnFTSmuMBILI7MQ0cVq2brQwkgw7D5coUU94/E/urr6Q+/ev6af2Qk9efms vM0tmicCi0LoYcssLKEFCydmeS6WUPC4SmhhT5fzy1ascTtb60PEFiyy4MGWZ/BQiCyWQgu3YB+E Fj1C+6EcmtCiy22HLkrY9XZCLXIf+uPUZ6FFSAIIH/1pr++zr1CKgA9pP3YtmIhBaOG7L419htCi v0KLhxKaoKKPQouHEOJnp5A+W/rsp+s+QbS0kVsYmUH10JaRNYjcohiL4KKqJHtTmfe2Qgu3j0c1 y5tkF8xTovnbfPwtX/yFaD8xi48vL+nj+Tl9vbigv9fXy/t2XXDhzoscwhVb1Eks6sQXfPt9xnXb FcGFSDjmVl5XdjGX/bL3z9rPOsGFfdYbgE2IzKKYtuZHSxlFKbcguiOucNtjGVuSC1toIZIMbqNl m+zt0fPJpE3UF3k7oNURaJPQoupvXMFF1RGw6ugmdw0505tUPQCAYcE/FJkSLs4D8fKJ4v6x21Q7 gEdw0TvwAS4YB12Awrbm4vjv2iFAsMRemCvVDgCC5pDifW4DoE2iHQCALflB5hzRkD/3A7+wiDbV DuEJfB8EfWCqHSBAUu0AYGsy7QAdMdUO4JFMOwC4F0c0vOJToHt+kzk3gnOLzfSpIHimHQAEQZ+e 01ygGefK2pFoB/AI3rvak2gH8MiZdgAAGuD311faITzB19ik2iEi40w7QANH2gHAoMnIXN8KQMyw GLJP36UT7QAewffDzaTaAXbMG+rX//S2gV8Lh9ohwGD4oB0AgNj4LwB755PbNBDF4UeCxKJC7YpN JaiEumTBDXoB1AuA6AFgUYk1am+S3oALIEWqWPYKKKxQpW5pgSKbvExm8mawE6cd82Ymv68axXHs 6S//HGtsvw9SC5A7slDPWzIFhZayu/u89TErsbCNa3EthBb1TFQh5RZ2npFZ1E54YaUW5vHKrW/7 4779sl6mDFhdL0QWPG0kE1JoYZsUUNwKoYWUWNw6ucVCYvHbLSvXWQgybP9V+wv+gF/ur3R9/Z0+ fHxNb87e0+Mn2+5xWexuJo2guTRCCC2s1MLKJlg8MWtzCQULKZqEFjf1jSe0+Em+3EKKLJzQgnyh hczQJLRYt1gfSBzttxJCizz6/h+kJgvoCwgt9PpMpbBzrP6014/ZV04iiL7WL10wkYvQIlW5RCqi iq7kILRYB+3/H6Pv1AQVpQotUhJopLKfkFo/ffcJimDVuJeUE9xnvMyJLWjgCS7k3z/l16WAwt4P 5Rd3kV2sI7QIMz2aPvd9oh/H0+lTouErM/vL1RW9u7igw/Nz+nx5Sb8qM5ZaT5+jlVjI1iSMaBRc iNZFgPFHrNflNuzHZakqL1Mo5DCfAXL3azHPay1yC7ksAJLQwOAJLYh8oUUgqLC3w8FgJrJ4OJ8O JRdShCHlFuHX/+nWFr3Y2ekSm0/8CYUUy+QWcus0pPYtlJxPLdNNW60uL+2yZQEA5QCxBcgR/ry+ pPxPJN7TDhARnPQOYsAFFXASL4jJKeUtP4oFX4jxTDsESBbe7ub6O86f7VIKH4D4sABvpB0CgIwp 6YJzUD68zcfFx6APDqmM/YkJoSAOyB/+PnY6KL9BjMkU3Ab5MNYO0BN72gEikusYGTBjnN+0Q4Bi YEnKAaEQfBd4/2x75VL5MNYOAJKgpHHRiXaAjDjQDhCRiXaAjCjpOPNEOwAAKzjSDhCRT9oBMiTl 8RYeSxhphwAbz4l2AAAicKQdICIljQuk/BucAiPavOMKJ9oBFBlN27F2CLAR4Ho4ANbkrwDsnTFS 20AUhp+xJwRoOECY0R1o6JIiXYrM5AJQpEwaLgAFFQVDusxQ5RRpXXCENHRUuYJnCJait6snLSsZ y7bsfVr/n8ZoLVmrt5ItibX1PkgtQB9om4Dn67yK7u5+02j01pQ5v5ZNtEWlwEKmcx4yEVtUUou0 lFbYR0pPT2khtODy1IxFaMFlXsZdXsp1oQU5QguZZgUTLJtI038kMotKQFGXU1TyCiu2ELmFO8+W n1/U1VZoMRwO8nb9yds3oauf3+n4/BO9Odgt5zcluzNii6wSWZRDNq2EFmRFFlwWkYWIKkRiYeQV 5D0XmQUPmflrpRj5wMIMd10yiNDC7PsGoQWIiG3cnRBa6Kp7XevQXl/XaE4W3AUQWuhbvsu6ILTY PsHEJupapt4QbdEu9wotEFnXute1/kXZVLzaBBUQWqwfLdcJmraJj+bYgBr8PrHa/EJO4PefzVuu CVdkUcotBg1yi1kCi6a0722FFn49Oy3qb0obzxwSTT/m4+t88jeigyMysoibhwf6cn9vxn8nk2L7 1iUQGVFNFjF1RBeueKImr3AkFL6c4nmJsS/SeFFvsa4y9qIdvuxCnkvb5HWZ2+YGwYXbKw6Ai8gs TNl5PihkFKXcgipJxcgTWPjTR47kwhVaiCRjR45H+WN/OKR3e3ttQuUEoidUHXFeE1r4r/GPVk3y i1lHM9k05JVfU/MAALYPiC1An+AkEgnF8SPrJHQAHRLD/gA6GJNNSArAKvA1Db+PLgPHoQG+weoi dBBALfw5GYcOYkkSwmcczAZCCwBWJ6abtEG8xCI9Bbo5JXvN3Pdk+ix+Qf8/6Du4+b/ObegAQGti TYrD58eYZLr4rqu/iDQd1ztgVVgG94EgtGhLTP1HsZ6rweIkoQPokHHoAHpEEjqADsE1bTtiOocx j6EDAGAOZ6ED6BD0xy2O5nPTWegAACB7Hv8ROggAViSm7/Bi+l9B8zlYC5ehA9gw7ykuseei8LX8 r9BBgOj5TP3/jRkAG+W/AOydT07bQBSHn1KUbpDgBtm0opseoBuUrtmxp8qmexYcoLlCT5BTsKiE RLbskDiAl8kBIkShgJ+dF48njrGL7Zl5/n2WZWc8Ns8O47/x+yC1ACFjJug5ozSRUCmj0ZetMsmt JRIL6bk8E1K8JKIKU24hZanIIp3GsotUfJFNl2kiyMiSeRUJLZ6tnqUWIrd4NAQUqdTCFFaIyCIT WojI4q8lvnikvBxDZBnPVCa0GA6JHh7ukvHfl1M6+nFMe8O99ZpsyyFMoQUPRSiRyCziv8siCxmK iMIUWiTiCsoEFvcv9zmRBXciskiEGOvlcCfCDO5EaJGILDgeQ2ghZRIzUIQPX2fXMWgVWrQJhBZh JGxvAl+TF0No4d/8TS7LlzbRJ6FFVXyVY7SVPN/ndXEliehSItDEMtsSRIRW973zdiGoqIt2oYUP bbcNfDrfaHt5oBdUFVyYde3xKmzEFnGXE1yI3CKttJ2afVBQRta0urKLOkIL+/PHeN0/E60u4vEp 0YfTtPhquaSfNzd0Mp/Tn8WCVk9P6+2UyS3M/p8xtMdt6cSuvqh+0fxlQ1ukUSSvYNGFLeTYiDqM z7K+uX6H3MKsC/qNbWDICS2I8kILS1AxEIHFYJAMZdyWXJgiDFNuYTfvT/v79PWw0u8MvtG2kKJM bmHujWzBRZF6p0xYUbSXqrJpy+oCAHQBsQUIgfhMWlUSibHrABokch0AUMWM8JIW+H846cyYkNhW wMvUoAg+5/9OYbcT/t8+cB0E8BIILQBoBk0vaQOd3JIe6WkI9H0784v9vA1C3jfy/VRcH/YDzc94 zl0H4CEzQgLmUNB6LA352GjDbUnL88e+wu1MU/I00D18X3HiOojAGLsOoEG0HqtBfTSd30SuAwgE iNr6iaa2PncdAABvwNdpWn7bwfcOsJ+tT+Q6gB3w/vPadRCBEbkOQDG/SPfzHZCh9Xvmayot92Y1 XStErgMIgBn171nrxHUAjpkQxBagfbQcEwHohFcB2Dt/3bZhIA6fGwMugg6dCnRqgG5dgg6dkzfo 1rVZC/QhPGfr0iVLXqFT1wBF5k4dsmXKIySAE0vViaREM0xKO6x4Pv0+gaD+mTkpMi3L0n2QWgDp pCbe+fKvhk5OftJ0+rwd5zxaJqFWX7v5VdULLnqpRWVlFbUtFS0WRl5hxpdWblF5IotqRWrhxBYG J5CoI0KLZVfMMjd9Z6UWvpzi1hNW+GKLhRVa3AaSC19ukS60mM1qur7+045//3VMrw/fdctCKYQv i2ChRCuysANLLLqhGWchhRNasJiiE1bUntjCiSzIm6Z+nVZowW00tWu3lVnw4AktnFCjrutuOtwG oAQJ/04ILeS3LzVJ8ZBITsabs10ILYajtARC0jFd+vW5kNJXDi1lkCyBWBfJ2yJ9vU1fUzJezes+ lSGEFlL67hgQWshq43+0BUAmUuQWThYbG1KZeIOTW7S1E1z46dqJ7qd6j6WBTxVahO08S2g/ll6e eUm05NQXx83sr0QvXpnZ3y4u6NP5eVtf3dzYfduXFSlEIItY+jKJiHQiuX5IctEsv4vUK+tF/n4n 43CCC7tOKMDwt81d8V7Z5ojgwt83YNw4mUU77k1PrIyik1sQ3RNXhGXqak9y4QstnCSDy8SW2c4O vdndTQn1bVM+UN/DPCa0CNcJe6eY/OKh3svtGgrGH+upAADjBGILIBW+Ufg9mYc2NKHppnc8rAdy w0nqcMM4WBd+2JT7VvRJBn4fHZQOAoiDz/UPabsfzOaHPT6WDgKIBEILAPKhKYkX0AdLEPm8H0mH hwP72vSLv8mIIZJM9wKZ0/gSMowR/r6kNZnhPulKnJyLeekAQBJar1dq+p3rsnQAIAtnZK4PAbAO fM2c70U4LRzHNrJXOoCMaP2sBuuj6bdVHNdpaDqnhagtnb3SAWQE73UgnaPSAWQE4ujNkXjNel46 gC3ksnQAiuFzOIi99cN9oeYk1xqOYb4PQIuMizkrHcCWMLZzvM+k6zvxJhw15UfpIIBqNH/eA5Cd vwKwd8Y6TgNBGB75kFJcARLQcqFAoqGiRkqLKBBvkIaaB0BCeQo6pDwCNVWO8jqaq0N3uppTDgls MlmPs944to+sM7v2/1mr2BvvepyzHftizwepBYgVOzHPlEwCoVrOzp7v1EkOLZFYSOH6rdDCFlMY cYXUGZGFjGeF5EIEGNJG5i/LKySJl123LVkmwglTjITCCCnS1AgsjLjCFFtosRVXiMRC2ktf0rcI M/anDBuNVnRzc0mPHt6nL5ef6fHLp9vPb5/QIjNCC5m2BRM8sIRiM+RCi0JkkYsrVtmKbum2kFjI uMxTyCzyPnhgkQWPi9jCFmpsFBZZWhJuuOsAgDcgtAi//1h3+1AT6Ib8d4LQovs+fPWl3d5nX9rt ffV1jPUIUTARsgQipOUfa5lDF1rchRDEE8cUWnR5PncsoUXIbQ5pd2jbrvoLpY8u+uqyTzBYmkQV tpzAnu9/5RYJJSXBxY7cwk3VnlTUkfPeXWUXbQtVTI/W6/6M6NfH9fgnopPXpvrb1RW9v7igN+fn 9P36mn6naUn2kNpSCEseUSWjKIkp2pQW8oo/zuvfPK66ZRfvi9zCEnIUog5rmqgsrcic7ccFcoth 4hoYSkILorLQwhFUyOtJkmxEFvfycVdyYYswbLmFuzs/OT2lFw9a5bB5RbtCijq5hX30cQUXVaqd OmFF1VGpzUdbNy8AoH9AbAFCQxIV9u0BTNz0DkAzU8IN46A9/H0xISRpEPh7ZqYdBAgOEVrEfF7F 2/bQHiIDzSDxHAB+mWgHAMAe+Hj/jvqRDCE2ltoBBMQHMp/HjOKUW0y1AwCdwkm8FxT3NV8TM+0A AmS+Lj+0gwCN9HW/HGsH4JGFdgDAG3OC2AK0h5MJjqm/x+muGWsH4BFsA4AZawfgGWzX7eiT1GKp HUBETLQD8MhSOwAAauD/ob/VDsIjX7UDiJjQzkv4ntSFdhAAOMwpTAEM8AP/jsMJrkM7HvqEJZET 7SAOpE/Xhz+1A4iIOQ3v+cmZdgABMCX8xg66g6+DY7ynDAAV/gnA3hnzNg1EcfyFRhVFiAUxICFh 8SFgJGPFhPgCZIRPQRmphMSI1CV8CtZInZm7VMgTI1tVyWoc8uJ79vnkpiY+550v/5918sXJPb84 iZM4zvtBagFCpm3BnY93BTo7+0nj8f11n+tlFYWzqrksz/NKcFFJLSpJhYgrsiwvBRZZtjDXV4IL kWDwco7F8/ZCi4WRTki7MXKKG6sv0orMNBFa1K8TsUV9vMgtJP7tHB7+paur33T85hWd/vpKj5In 5XVucbvcTMvlsuyXGgsjtGDhhMgoeN4ktLD75WXT1iOWWS2GiC1YZMGTLc/gaS2yMEILt7AehBYR ov2Qaq9/l0Bosdv1hFpAd+iPUxtCykWIrSiz9nifhHRfILTYLpav9fUZS0NoEeo6+7jdtmP6yEMz Zii39TE+xM+tIY/pMq7r2L7ihRKjj1h9xgTA0EZuUcgMtpdbMCNrErnFeu4KLqoBm6UU/yO0cOPc axG/qdw885hocbyan64WfyB6+LRY/OXigt6dn9P3y0v6c31ttlPValIIRxZRk0k0SS7yvN3clVjY bRW/SYThCjBqgguRcIjgwuSYW3KL8rJZJstr97lBcGFvG7BfiMxi3bcuj4yMopRbUCWpGDsCC3f5 2JJc2EILkWRwG5n24OCAnh0dtUn1xaq9pGqPsklo4d7G3Rs1yS9u21vJpiGnv2nPBADYX/hk6YRw gh7QxS5UGGOBcpz0DkA7poT3I7AZFLZtZkZxyZNAd3hfmtDw/xjJr/Xn2kmAoODPohMa/nMbgJBI tBMAoAEu4MHHUlAwSIdUO4HA4O9an6jYLjMa1h+R51RIIUF8cPHumenP9dLonRgK4vQBjouFT6qd QE/E9FtXqp0A8MqMILYAd/OZIEvvymvtBDySaicAgiDRTsAjOMeiPYl2Ah6ZaycwIBLtBDyC30hB yEy1E/AISxBS7SQGTGj7KhxPBaEypf0rrL4P8PezCRXHoLjF/L+LE+0EOjLRTsAjob33hgy/Lr9p J7Fj3lNc34u3gR93/p3zh3YiIFreaicAwFD4JwB7Z8/bNBSF4VOrEkuRmFhTNhhYmBmM1J2NDSkS YmSGCSrxR8pv4A90ydK9u5eqQ1fUAkIpPnZOfO71xXWD43N98z7RVWwnuTmJE38k9vtAagGmiA7k eVe2F3c9YDZ72pomWVkisZDG0xuhRSOoELkFD4vQQkQWLLloxBbLtdBCHl8Hc0lclx53GwsnaqHF H2pLKERUwcO/lbSCh3954yK2EMmF7qsWZ9TX/3iD9/bKus/p+vqSPn6d09tvH+jh4+YcWT+krpJZ rF7XUl0qkcVKNsHiiaqtJBQspPCFFtxubm8cocVPcuUWWmSxFlqQK7TQNYSEFpsE64EJYD1LLZ7f 6jXHGAxs2e+2nyfWAN3Y51Ns4cVD9Rnr60qF2EUQY/QVi9BiyOcbsi9r0UasconYRRWxbLtAaBG/ 0GIMYcaYcopNgNBiO31so69t9glAgJAw1rndk1v4l76sxRaUOYKLltzCj27PAtPIu+2+sou+jQLj D8r35BnRj0/l8Gei/aN68veLC3p/dkZvFgtaXF1Vsggte1gqWcRSySO6ZBYinbizhaQVFJZldAow fLmF9CFyC1X3WtRBjcSCyJVW3KrPTwjILXYD38DgCC2IXKGFJ6jIRGCRZdW1DPuSCy3C0HIL/+v7 5OCAnj/qlVvzktpCii65hV7a+IKLkFqnS1gRWgr1eWu77gsASBM+QC+n+kQcAMaGDww9pLSDChH0 A0A/ZH2E0AUQAsG2YfKyvbYuAkQFb9PnNP1wLv6+f7EuAkQFbx/w5wInYQIwLCntr4I0kKDRwraM nQf75W34JKncuogN4LAmzM+00EIL5tSmjNE4oWnJZMbglBC4ETup7remFGae6jzaZU4IYgsQhsMh X9H0Q/asSe33I6wHAJNbFzAghXUBEyKl5VlhXcCEmFkXMCBYh4GYmVsXMCA4Nu3/KKwLUPDvqIV1 EcCcWLcBC0pr2QlcoYWQ8jqF/zOYsjjo0LqAAcF+wv1gqcWuSYWOrQuIhDnhf3YAADDlrwDsnbuO 00AUhk9IBLuAREGFRGHxAkCzNR0VAp6AiIpm3yHFioIKCiSkbfIWtNl9BrTNVjS8AVoh5YKP7fGM J45zWdvnePx/luVLPPZJfMmME58PUguglV0T7XzctqLz8580Gh0l45wXK02QZYdm/nJpBRdWamFk FausX2YCi6LYwpdc2PFUbEFOarJ1oUWSOswTThgJhZFSuIIKI62wYgsrs3Cni2KMdHpB24QWw+Eg jv1XMn7245RenL6muw/u5a+XySESscXKiizybrWwQgtKRRa5zIL+5aIKV2LhCi4KMgtKy3KXSDHi joUZ7rZMZ4QWfiI9EzMIEOnd2iehRdNoFyW0vR2tCXS17ydtyYubXOe+aDtGpcs3tS7JbWt/H1pF Chq31+R6JWQQXRNaSMYBoUU95bUt32aZtrd127JNoS2mUOuXoJfsIrfwlztEMjtwOl9uURBc2ALl cotDhBZ+qvk7G+ZXCS4Mj4nmb+Lhl3j2J6KHT4j+zuf0+eqK3l5e0vfra/pzc5N9Ts6dZFcKYUQX 2XhBJlEhvKgacvlNry+c6TURRoXwIpdaGMFFFuPSk1u4783Md+UWZYIL97MBYWNkFsm4Mz3IZBS5 3IJoTVzh9yMzdCQXrtDCSDK4H2T9/eGQnh4f7xLqs7g/IXsFqRJa+Mv4V58y+cWmq5P5aMgbr7oS AQD6Df95+l3cf5MOBPSG35QmkBhT95Mub0PrAzGHMJMOAAQPXw/4nMEfxoELEttuZiodAFAFnytc pw+hbvVVOgCgCm6ncv0ghGMbAG2E1F4F3YYTPLwkPEitBSQ9KGdM3ayPcBuhb0kZQsUXWjB8TIYs LOfEkxPpIBTCSYJwXuvkQjqAhoikA6gZ1HXCZEoQW4AiXEeKCL9v10EkHUCNhPpdDfYnkg6gRlC3 2R2I2vrHK+kAaoTvA3Tx3iToB/x743PpIGqCz7WpdBAdZyYdQAbvy4l0EEAFj6QDqICFB3h2JwzK hBbMrPVI2mVC3W1fR9IB1Ajah/vB5+lUOoiW+UBhHfO3YUx4TgnUB7c53lP/rikAHMx/Adg7Y522 wSCOHxFpFwZeAClDq6pD104V4kVAWZjbbp0Qj5CJmUegS18BlY03CAsbGxICIdKc3YsvXz4bk9i+ y5f/z7I+x/liX2wn2IdzP0gtwLqhC/HwCdXXqs5nZxe0t/dxYb7UxBKJhYw8vxBaTDJBhZZb8HRM YJG3k9nz8jpudVmucqGFyCZCCcW83ILbXFzxFEgunv73DeUWWmbxrNYbp9/fosfHXGgx+n1Cn472 afvddr7NInKImNAia1lmMV0viyykFRFFJrUgJbOgQmDxMHmYE1nwICILbmU5PIgwgwcRWmQiC45H CS1knsQMEsR6t26a0KLNdXsXJXS9Hq9F7r3vp5SFFp4EEE0sz/r1TS7LSxHwTXofEFosj4WsAUIL u3V76bsq3gQVKQotVsHjuZOnc8sml9P2MgF4I3XkFqF0Nswx1mEmtuBB5BZbEbmFLuWuy8BTyfPL yC7qjhR5/H66XT4T3f+aTp8Q9Q/y2X9ub+n46ooOLy/p791dJovQWeUXJYt4UfKIKpmFSCfKxixb /EqfUFrxPCmXWSzILYhmcoww7lBwUUhQlNxCHUMxILdIk9DAMCe0IJoXWgSCip4ILHq9rJXpUHKh RRhabhF+XD/s7NCX3d06YX+jRSFFldxCf7uEgouYSqdKWBH71qmzaav6AgDShgvhcLEHFMMBbcIF lweU/o36wsA6gAbBTe+gK4aEG8YBCtu+xinlxR0B4HN3loWdGsfRFHxNklJRGbA8fGzz9ekP60AA SBhILYAHOE/ExyJyDn7AvljkJ61vLnNMaRXw21RiQgvhosM4LPhOea4QFIioHvhjbB1ASwysA2iQ a+sAQKucE8QWoCgilIoA2gMp5Y/G1gEAN6R0XCOPU4+BdQANg/1eD3zWAeiGoXUADZJ6rrUrPORf RoTzf7Ae8D1RKcvLN4EyoQXDf1duOo2mW1gaw++x1o9rnZHS/alj6wDWkJF1AAYMrQNwxJDwvySw OiJWxzUkAG/gnwDsnT9u2zAUh1+TIkbSAB0KdOlQJXvRK2Tp3Ct4bE/RomOBDN2yVUfoEZxMOUDG DEYP0DEB7FaqnihKFC0rikP5kfTvMwiRskQ/y7b+WNL7ILUAPjI0wc7nhzo6PDymg4MXZZ3zX6lE WM1Qj88yJbgwhRZaZMGyClUyWiyyltTCbjeyCzVsCy1WZRZKaGG2TZmFFlQs67oSVSyrcW25RTOt LcYYJrSYTDK6v1dCi4vrc3rz4V39nC2FMGURLJTIqJFasMSifhR1FlK0hBZaWJEbYgstsiCjTc00 pdCC+yiGut9SZsEPQ2ihhRp5ntdt+z2AyJD+WCG0CKPvbeCbLGAsILSQ69OXxM6u+pOe32VfIYkg xpp/1wQT23690OUSvogqhhKC0OIxSL++i759E1TEKrTwSaDhy36Cb/2M3ScAT+AhUUWX4GLIfF1o uUU51IIL6hBcNDN0yy02EVrYqef31ozvE1xoXhEt+fa678XoT0THr4n+LBb07eaGPl5d0cXtLf2+ u6uWU1Oyejkasouq3pJJrBFemM9rAcbQ4T9bmFG0/+arIo1abGGJLGrBRRWDLbcw31tLcGF8f2zM ZQPiQsssyrrRflbJKGq5BdGKuMIuz/XQkFyYQgstydjTwpyiTPb36e3R0ZBQT0nJ1/Uao09oYU9j r2265Bfr1kZ60ZBV71vzAAAAk5K6sNqHm0pAXFwW5YTiSbg8FFz0DsBmTEklNwW7CRLb9pMU5Yt0 EMALeP8qoXAT7NrwDY5fpYMAXsDHo7wdSIXjACBmeJ37UjoIsNPwfgwkdn4ykw7AM1i6GXpSAz62 xk35YcJJmXldmfZM84viF5X/JMhZbGZF+SEdBFhhLh3ASJxJB+CQuXQAYHRSUgLg2LeNoBskERqH mBKCz6UDAN7wXjoAh+B8+jAS6QAcgms6h5NIB+CQmXQAAPQwlQ7AIaGfC/AF6f0T/k8AnyUIiSlh Hy9U+Dwy/2/SJ1ZNtxOKGHx8nUoH8UgS6QAcI73dDZE5qd/vLsESpRAFNGOREs4lgc1gWRV/dyBW B2AD/gvA3vnrNg3EcfxHCwpSBpAYK1VITAx06Qv4DRBvUNjYYEQseQY2tr4DL2DGqAtbVy8du1Gl Q1qTn88/+3y1UxOdc/++H8uq4yR3P8eOfedcfx9ILUBI6Al4Pm3m08fecHT05sE6yX3FEgt9VnKL VmqxXqtZ5Ba8rIQV5QOJBcstRGQhUguVZEuJJLriijttvQgnWhFFV1zBj1txhVpuZRat0GLdU47M d1U9KoZ+ZrMV3dxc0nz+nH7++UGvTo7bz2tIaFEqoYU81gUTPLGEoppqoUUjsqjFFatyRbd020gs qsea3KKRWdRl8MQiC14WsYUINRqpRXnfEW6Y2wAiI8XdCqGFX2VPVYfv5dnG52TBNoDQwr/32ywL Qos0hBb7lmPsUq6L48l3uZdrgchUdU9V//+yr3h9E1RAaDE9vrQTfPpMTHyODQBqRRWDzxtyC1Nw MRaRWLDgopFbPOmRW+ip3fW08DTw/C6yi7GzWScz22z7W6K/3zfL34ieZWr1r6sr+nxxQR+XS1pe X1eyCF32IAKIe0MeMSS00IUXHSHFLnOPxGLdU5+5rhFq1HKLkqgjvTC3jbTtbeQVA3IL0l4DwsY0 MHSEFkRdoYUhqJC/hwcHlcjiab1sSi50EYaU1/d1PZ7P6d3LUeN5OJm1KaTYJrfQzyam4KJPnbNN WNF3lhnz0W57LQAgfnhgKw+wRkIcYAMZtJdRekkCXrsOwDIY9A72zYJU0kUMGE8HJLYdR0FK/IHv Rrrwvv9Kqn0V0z9F8LYsCMd26ojYqHAcBwCxE1NCQhAWfJ3nfl5GuM/gK7xf0B5TcAKZL66DsMQ5 QWwRGiJ6e+xcyf2oFBI38zaeuQ7CM/j89Nt1EKBD7jqAiYip74D2ZxrkpPobSAaYDjwe4QMhidBU xHQdyF0HALwgpmOaKVwHEAiZ6wAsUrgOICBi+r4XrgMAYABug79wHYQluF+B+wZ2KBzXz0IL9A1B SPDxmhHuZYUGj908G/G682nD8IL3pH7HCyVhfkz9BPxOuDsL1wHsGW6zxzL2xRY5qfMBrr9gDDyO Tsa2525DASBc/gnA3vnkNg1EcfjRekFhh1iAhFSvOEMXLHICEDdAcJGIBReAZaWUI7DvIuoZyrIo bFh0X7WijUOePWM/T5zECR7PeOb3WSNPJo79nMTj/Bm/D1IL4BttE+t83LaiyeSckuRxXuc8V0XC q2qu27OsLrMoihRZLFYEFrrwMnWhRSXDWBVaZKLMldBClwchsXgQEov7UmJRCS1km1mXgou52g7X VRKwhqRfSXJNNze/6O37N/T15zd69vpleZ+ZXC5TU54wTU2lxkIJLVg4oWUUPG8SWsj6isiCp8Xf 2jq02IJFFjxJeQZPuchCCS3MBHgQWgSKDy9r3zGEKrSwCYQWfiXNt4mvyYshtPDv8V2uy5djIiah RVt8FVrYSp7v8764kkT0KRHoYp22BBFDW/Z/H9uHoGJXQhda+HDs2sCnzxu21weARZp+p6vdXxMX 7C+3YLTcIp9rwQU1CC6qBzTLLfYRWpip6A/WtG+TXTAviO758rsvy+ZPRE+fE13f3dHny0t6d3FB p1dX9Of2Vj1PlexBSyB0PVMCiaxBKCGFFPL2vvO5IbgoZRnGdso45FzJLTIRX7kfYl90W01wodsb BBcLUcCw0TKLvC5uPxIyigNDUpEYAguzPRGSCynDkEVLcp4cHtKro6M2oR4vywlVPcQmoYW5jNm7 NMkv1vU++qkho75JpQMAABIetMgygt+uAwGDhN83nCgtpXgH7YU06B2DdYErzggXbMUAEtvuzpiK 88x3x3GA/uEL0UZUXIQdIrxfKUGwFyN8rofYCID+GLkOAEQJn99TiiNxw9CJIUH+NvizyYjCSnx0 RhBbDAXuL3cRvY2tReIPnGhjQki2YcKJA/G7qT+E+rtm6jqADpm6DgD0Bh+Po2X54TgOYB/9uQnf Yexx7DqADgn1XA12I3UdQIcgeWV7UtcBdAj6svaENG5v5joAANbwwXUAHRLqGBwXTB1um8etjx1u H4B9gdhiOHA/w+Pb2p43ZhTHGF8WW0xpGN+98D0BMDOK49iU8P/sQ5HP9MWMij4B49XBJvi/Rn6f jCmsMWQA9M4/Adg7Y562gSiOPyJ1KoitC0tQRyQYEVu+QqduqAyVujJVHZBAfAumfAO+Amv4BB09 ZKsYGCoiNUDz7jj7fDmCbRy/893/h04+Ett5ji/nOPa9H6QWoC/YiXeOF+XwrQV2dj4vPWZyXLHE wi5abmELLbSYoiy3sKeF4KKQXvD0UdWNxGK10GJOhcTC1I2kgutliYWRVxTP/3NEGHNrnU/qf/06 y3Cyr8FgY7F9v2k2+0M/L7/R16sftPWpECW7yeSUzIKeS0ILI7UwsgkWT6jyIqFgIYUrtODy8PyQ 11WhWTEfiy0skUUutKCy0MKOwSe0aJIAD/SEEHYrhBbhrz/UJMVdEnIy3jbXC6FFd0hLIEJq09LL t0UofWXXUoaQJRB1CXlbQp+v6TKS8cY873vpQmgRSt/tA0KLsNaxjnUB0HOqyC20uMD/VxUjsWDB RS632PDILexU73aaeHrl+SayizpCCzfl/MfF+7JP9PdsUf9F9GGkH76eTun77S2dTCY0ubtT8ghb 9mAEEE+WPMI878ot3FISUjQpHonF3Jm69VIxgouX+HKhhbNtZG1vLq94RW5B1jygX7gGhpLQgqgs tPAIKpTAYjBQU1N3JRe2CMMs6/t47m5u0t72NlXgiJaFFKvkFnbv4QoufKqcVcIKX69S5a1dNS8A IB1uCDfpgXpwYvIL0u1mLBuKODHd9I5B0UASk3wotcEDqYDEts3JSA8QZwkZkpbED3/HOqU05C88 6IMHUO0S2nYqmPOH2Ns2ACExlA4AJAUfz/m4zsd3DO7sB6knhOXv3pwoPsb2OiaILUKG294Xqi9u yCid381i+s29Dbif4v7qXjoQoPZBjMcN5kA6gBbJpAMAnWL6yFPpQMBa4PNMTiCI88z1MpIOoEVi PlaDesR0TpFJB9AjYtrvuJZWjSFpQWYs3EgHAICHIekE1rGQ+nWRNpE8Vp0LvjYA7wVii/Dha3FN 7m87bz+UIBlKB1CRmM4PM+kAes5YOoCO4XPkuvchpAK/LzwWA9fcgQ1fh+J2wdcaM9lQAIiD/wKw d8Y4TgNRGH5kLUDZgpYK+Qg09Oko4QiRKBESR0AU0HIApM0Vtqew9gzpN7QU1KusbOPnyfOMZ51N SMae8fj/LMuOE8+82NbYccbvg9QChMSxCXU+Hiro6uoXJcnzep7zWanEVnoqy4vClFnoUYssyp24 wpRY2NO8nm63ef15Sav1UGiRG6IJLbVQYgo16vntbl6LLdrv37ckFno+b+pRdXaTJLMq3nUdy/ef n+n1p7f09PJZ836XHKIWW5RaZNEMVRmN0IKUyKKRWZAWVYjAwhZctGQWpNbloZZiVAMLM8y6ZBCh hZ3wTmIGoDcgtAi//LE2AaEm0A15P4UqtHBBSNvHRVm+13dJSN/FZzLysQomQpZAhFT/UHVOXWjx P4QgnhhSaNFnuz+U0CLkdc5Z79x1+yovlDL6KKvPMgEYmEOiirIlLjhdbsGI3KKeiuCCOgQXeoVu ucUpQgs7Nf1sz/JDsgvmJdE9pzX4Vi3+QHT5gujP3R19Xa/p3c0NrW5v6e92u9tmWvZQGAIIUxLR KbSwhBTy+typWd4+8UVuxFWYcgtDcFFacovCWNYSXBiCFJvSGMG4EJlFPW+8frKTUTRyC6IH4gp7 TGRqSC5MoYVIMmYixKnG+cUFvZrPjwmVLetvSLcIjwkt7M/YrUmX/GJfayObhqz5x9Q5AABgI0ll uTPWb8+xgHARmUVKqvM9EgKg0zsALuE2ZUkqsR86jMcBEtu6IyP1QCMnJsW1Wpxck7qu+OE7kIHZ kDq28TskXuRc8MVzHABMkdR3AGASyMOdC8J9hbHByZumev3F9xwWFPcxuyLcXwkRToST0unJ0/j+ Suz7lBM5LX0HESAbUu1W7Ps/dGJNLBvT/1zMxncAwAt8T5XlB0gIGAf8O4WvZRcUb9sbEqnvAByC 4wUIC98BOATH9fHEJGrDfj+O1HcADsF1LAiV974DcAj3ydn4DiIiuB+gj/+YuM6Vh3oBcImILa49 xwHacPvC/R6WdFpf5w2pZ2xiZ0njOJ+mvgNwSOY7gJGTkerXNCUgtdhPRqp9wDkYmP0dM6+RABAZ /wRg74x124aBMHw1kmZIgGbP4qJd2yFrh+g5AhQoUPQhuqV9g/YJunfP7C1o5jyAkT1jkSZoneoo n0XRtKLYpI+i/k8QRMgidZJlSpaE+yC1AH3ATrjzsRyPH6twdPRqaZ7ksmKJhT1WcgsRWlQyCx6r 8szMryUWIrBYHvnz2UzkFSKysIUWrsziryOmqMUVlcji3pFc3M+XrT+vRRd2OyLS8LO3R3R3d2XK 38+/0OvTd7TzfKfaRx45hE9oYaYssyjjZ5GFTEVEYaQWZMks6M9CYnH7cNuUWZSDiCx4Ku3wIMIM HkRoYUQWHM9caLGQW0BoMQy0v17t9W8TCC22u55UE+j2/XvqQooJh3NLyqxdP2R7KW1L6tuRqmAi 1PpitqUhtEh1nTGWW7dOjDg020xl2RD1U7xuTbnOJvU2rRurvVTaiNFWzDYBUKaL3CKE4EIkFiy4 WMgtnnnkFnbqdzttPK34fB3ZxWMSi7YU9PvlfnhL9PtrWf5MtFtUs39eX9P7iwv6dHlJv25ujDzC 7J1yG0UC8eBIIuzyP6fckFHYQop1xnldt0176pYbowguqCnmsAUX9TFiyS2sY8gH5Bb9wDUwNIQW RE2hhSOoGInAYjQyUym7kgtbhGHLLdyf5suDA3pzeNgl7BNaFlK0yS3s3sIVXPjUOG29ha9H6bJr 25YFAAyPCVUv6fFL1UiOAwTILFYz1g4gIBPtAACYw4n9OJEWXhjvL0hsG48fhGu13OAEFfx74WQA U91QVJlQdWxD3JIPdvK5qWokAAyXE+0AQNZwP8/n7YJwP6HPDE2oxvCxW9AwkgPy/ZWCcH2dApsm whG47lmAeFJFhDPAD/dbBeF+kCa5njtykloMLTERaMK/UT6eh5A8Llfkf+aY1peAgaeT03kg13M1 eDpj7QACguO6Gzn1ZcxUO4CeUGgHEJCpdgAArCCnhLj4jxEejeuUDwrrBCAG/LyH3xX8ph0IMPD3 wP8pJhu2w8/ec34uy/dd+3I+hfQQ2JxpB7BlXhCumdqQczC/v5Fznw38QGYBQGT+C8DeGSM3DQVh eElcOBkOADPMIFo6OkrfgBvQcAJuoKGg4AAUqcxM7kDrCVfIUKuihiaZjEyEVspKKyErgjxpn57+ z6N5UmyvVpb99BTL+0FqAXxhaCGdd/cFOjv7SqvVupBVlFPWaJlSZKFlFvXEIguWWqRpLbMohRbN 9uamuczPo0K0IFIJafdKaPGbRGihBRW10KIUVdSyiqbcon7sXsURUYaWaXSzXmd0dfW9mP/87RM9 3bys7mtLISpxBGWFUELkESyWYIlFdcvnWUjREFqIsCJTYgsRWZBapvoxhdCCY+StxC3EFnxTQgsR aojQQhexg9AicKx3r8X6rbbZx8LAlnHHXo+vBXR930++FS92FdPX7QoF30UQU8TyRWjhcn0uY1mL NnyVS/guqvBl7AKhhf9CiymEGVPKKf4HCC3GiTFGrDFjAuAR94kqXMktGJFbFK0ILqhDcFE/oV9K 8S9Ci3acowPtIdGFzusJUcolwT7mT3tLdPqY6Mf1NX24vKQ3Fxd0niT0K03vXrNa9iASCJ7XkohO ocXtbefyQ1sdb9/x90q0oVuRWyjBhWyHyC30tjUEFy1BiiZTE/AbkVkU82r50Z2MopJbEP0lrmhP K2mV5EILLUSScSQCnHw6PT6mZycnQ1KN8uk11T1An9Ci/Zh279ElvzjUu8hLQ635PlUOAAD0EVN5 cfYX4zyALVI4gs1OMUFm0UVIF70n1gkAoEiovGCcz3xRqG0+SHH+DeFC77GJCXKLuSPjLBc/iAyJ LdXF5/Denie8394Tis8BYE1oRbyAP+gio1vTTIALtrSsMRefs3L/uKTCD1LcGeJQG7QseucoJhfE CbFouwgt8B1EP/yZjqjsz8D0JNYJjERknYBDlnSMB4eJ8+kVhXm8DBUZM/G4dWubyiIJ6X9IOA4A 4bl1Ag7B+3oYkXUCDsEYZjiRdQIOwWcd+AiPE0M5pvI5x9Y6iQCZuu/iY+Ru4nWC+TDXc1uWB+Ea aTu4X3lB5X5w8f3UTwpLCKXh35TF1kkMZGOdgEO4b8B3pw9nR8s7146tE5gBO8K16ksCMgsAJuKP AOydvW7bMBDHDwYKBGiGLAU6BSrQjp2CbB30Gt089CW6eeneLt0KZOval8gQIHO7Ki+QLV9AHTVn ivKJkFW5lXgn6v8zCMkfIk+iLdOweD9ILYB1ZKKd5VM5/dsGx8dvhLyirOUWDEssZHFyCy+0cDIL LrzuRRVSZuHKuhZaPDys68e3IouSmkILt2yKKKS4gu9vxRVufSuz2AotfrfU44uUabRzcHBLNze/ KMte0refX+nFyav6uZ1Ci9IJLfx9KZjgG0soNrdKaFGLLCpxxV15R/d0X0ssNveF3KKWWVR18I2F FrzOy01blVCjllqUjw3hRrgPIFG0u3dOQouxsS5KiN2O1QS61vvJWvLiMevcF2vvUe3tx6pLs23r +2FVpGCxvTHr1ZBBTE1ooRkHhBbDbG/t9TG3id3W/247FtZiSnV8CUBE+sgthhBceIkFCy5YbhEK LnaKJRYtj1Hw3L6yi74lbJN5TvR4QnT76Wn9I9Gzd+7h71dX9P78nD5cXNDl9XV1vLayBy+AkJII ub4O1hsyCimk+JdSbRvWKZedxQsuqCnmCPeNxP7W8oodcgt5fIAtQgNDQ2hB1BRaBIKKhRdYLBab pV8PJRdShOHra/v4vT48pLdHR33CllILX12X3EKeHULBRZsKp0tY0XbW6HNou14LAJgvBbn/5vkP 5bldxDl3uL95kkRGmMzVRa4dwIDwhbiFdhAAtMDJsDNyF4wDu/gLvZGcPy48WWlFEJFNDZnw/0w1 Erv493ZGmDA0JWTC3s+6oQAAKK1kTsAGfsyfEcYwKeHHXXOApQ45zTPpA+8zi0P5dwjG1vHwY+PV CHUvKb2+5CQ/SODYD/5M5wRZjQapvkdz7QAGpNAOAJiBP685OSFfat+ZKcHSRDlmmuNY3QJTTfzZ RqEdADBBrh3AgCB5ZX9wLpsnKfV7qr83wbRJKSn3D+0AEiX2uWsVuT0wLXpN9DMKn6N4XIO5OvFg cbhPbF0MXDf355eB69SGj9dSO4g9yLQDGBD8ThiOM+0AIsNyuqV2EBMA8zDSh/uV50TnhDlOAETh jwDsnb+O00AQhyd3KCgggSiQKChc0CMkJNqU6CoaWh6Ajhc4uUC8xqW+Z6DwK3BPYF1BR0FxusIk 4LE99twSX3yXdWZt/z5rtev8WU/i2No4m/kgtQAh0DWBzuddHZ2dfaf5/HHR1kILEViUt/O6llk0 hSUWWmSRZX9roYUWW4jMguUW3BaJRSOwEKHFulpfV+sisfijJBaZkliI0KK57f+2FlyU2y7X29Nu zee/6Ooqpfcn7+g0+UpPouf1fW7it021FInNqqXWWFRCCxZOiIyC61pmkReRWGi5hSuyEJmF7qMW W2ihhVoKkUUltHAT1UFoMXKsd+/UhBZ9btt6X+5LaLKAIfTVR79jFlqEJIDw0Z/18332FUoS8Cm9 Dggt7o+FrAFCC7tth/LYfQlNUDFGocU+hDh2Cmls6bOfvvsEYCDsElVsk1u47a7M1CJyi6J2BRfN E7bLLe4jtHBT1x+11G1yCx3XC6LsY15/y5/2iWjxiOjn9TWdXlzQSZLQ+eUl/c6y6n1qZA8igeC2 lkSsVV3LJzabrev71m3SDPe+G3GJ3EIJLuR1aLmF3HZDcNFBboFTcHiIzKJoq/WZklEcOZKKtvJA aiW50DIMXWZVeXh8TC8Xiy6hvsrLW2qO+NuEFu5j3LPFNvlF29lE3hpy2repcQAAoAsplRO4ePI2 JsyPF/4ztJ6whz9y7SayDsAjmPQOQkYmjPP5CRPGw0IS2y4JE70tSakRkeEYCRdO0MVJ1CJCwv+u QG4xDLTMIiYkWAIgFMaUzAnYwuPLN4Qx/5jhsekP6yB6hhOHsNRh6uMU3tdIitM/co09pv4+cymN KwkFf1deWQcxMERWAxHwYUmsA+iJyDoAj+C3LuCyIlxbDBF9rTwmjNMt4aSfT62D8EhiHQAIgjFd F8XYpjtL6wA8gv3endfWAXgE+x2EyAfrADyCOTr9cMhzFwt+kwNuD4BDk1I5psU1rH6Ra1L8vTHp cTsxjef3d34dS+sg7khkHYBH8D3BHysqzwFTIrYOYECk1PwPA/Nphg8f61/y8ozK/ZpaBgPA1Pgn AHvnruM0EIXhX1mJhkXaimYLLEFLRUMHr0BJgeSCFkGDaCOxD7K8AY+QZssVHeXKLdWWiUIu5Hgy yczEMd7E9lzyf6tRrGQ9c+wk44k9Ph+lFiRkzAQ7H6Emxtdyefkcbj4qnaBKJBZm0bILJbQQmcXS KkpiMd9ILERgoUUW8jiZzMvXVf0LQ2BhCi30czNDRKElFbJcJbGYGq//dUQYs82yalO3U83Z2WC1 bb8xHv/Bt+85Pvz4hCdPt3MN3KRvpcwCS0tooaUWs+WslE1o8YSWUZQFU0taIRKL8XK8EVqUBZOt 0AJTW2QBQ2ZhyDPMGKqEFockqiOR4fvtpdCCdXfVhu/P9j4otPBXZyiJnduqz/f6bdYVkwiiq/VP TTDRd3spyCVCbfOY+kM9XhxTZ6jjsdAEFakKLUISaIQyTgitnq7rJCRSmsgtlLig+q8pG7EFBpbg YkduYaaGN9PKY8/rh8gumha3TeExsHgFjK9Wy1+BR6/V09d3d3h/c4PPt7f4dX+/3rdb2YOWQJiS iHnN8o6MYi2iOKjodfdILva1uSO4gC3mWDjbBmN7LaHHfwQXxC+ugcESWgC20KJCUFEKLAaD8lEv u5ILU4Sh1636ur04P8fLi4smYb/BrpCiTm5h9gau4KJKfVMnrKjqJZrs2rr/JYQQYYSt3IIJk9NB JpvrpBE5OGHvIWS+A2gRTnonMVBA9VOULPnFlSCNfAZDLApQbhEi5ljrGkzQdQiUW4QJk88REjYp JW9jv98/0sfLMVfGlTl4zuAUyH0H0BHSf7xblS++AwmIAuq3vIzj2L+2h+xLkafofrPooc2f6zZj h0KL4xhC3WN7aklYfJDqPpbJL898B9EiHLeSKnhuMRzk2p6MzzPw+B8KKZ0/SvVYTR5O5juAFhn5 DiAiMt8BtAjHtM1I6RgmFL4DIMQhRzryMxknsm/thgL9/cbmdZ724fciTIagoL4L+j4npcXksZ+H 1EKL2OYEvvUdQIsUvgNIjKHvAHpGrv/lvoOIjAK8ZzZW9P1N8t5lUGLD2I5fhCTBPwHYO3/lpoEg Dq9tDcFQ0afwQzCT1nVoaGmYoaFnUtJQUVDxBjEtHX0KvYJn6Gg0eYUMjVFstJLW9yeS7Sgn3Un6 fZ6bO3nsu41sy/JFtx+kFsA3pybO+Xiso+vrG4qi53m7SEZF+yKIyIJLmm5LoYWILLZ5YZmFXlhg wTWLLURkwW2u+fGmwELfVgKKQkxRFNXelO2NJrT4Zz02Ldu20OK+3N7W7o8ommYx/s7b335c0eur N/Ts5ZnaFxVyiFxssVMiC7kZQgtdZpEVXWQhRQQXxrYltOAb98c1978fbafGFaGFnZhOYgYDZ4wv MYQWYfXd1hih9+eakJMFuwBCi/Ce77IvCC3GIbToWo7RpN+Q5RK+3uu+BSIh9NkmXcUbmqACQov2 CeU8IaR9YhNybAB45JioYmeIC54mxZ1oN5Fb5LUtuFBPqJZbNBFa2KnspzV1ndxCtjkt/jnR5l1W f82e9p5o/oLoz90dfV6v6TKO6eftLf1N03I/VcgeyJRE3Gu1LbPQt53UR8Y5KLfQBBfyd+hyC7nP KCfILXB49o/ILPK2tj0pZRR7uQXRA3GFXSKpNcmFLrQQSQaXSVnOZjM6n89PCZWTllyQ+oTPatrT ivvto0OV/KLu6CG7hqz2IRUOAAA8lpjMhMl9v+B6jPBCLUmyxYsfVoQL9pqw9B2AQxLfAQDwCGIq Pn+csA0XjHcHf3d8IkiQ+kBCxWv0ipCkyyeyOELOtcDTQQK6MPhF5kJf/I4AIEyGlNCJF/tDbNcN +jH+C+Gcf0xw4poPvoNwDL+fF1Qk/gcPWZE6rwbN0edKOKlW0vH4PGaf58YgtHADH8P53A+f53ZJ fAfQEkP63cDHZMxRgENgbtEPuvxrSTg/D40hfQ8gISsQhvS+TnwH0CMgahsfC98BOAT/+wAh8tZ3 AA757juAgdPF9xbPgScdjDM2MI8WLgmphNprr5H0H7l+c0ndz0kl1O91Jn0VWjBDmhfA70O3rGh8 YlyIwZoRk7lmFoQLXxvG150sqHjNYo+xAAAy/gvA3hnjtg1DYfjFBdKhAZo9i9vOQYdMRZfcIFN2 F+gV2rHo0APkCL5Cb+AhB8iQOfARuhmpYbv+Rb2IolVFdkSRov7PEGgnlkTLokTRT++j1ILEip1Y 56uYG5JrOTv7IG7eKU1EpSILMxWvV6t1LrPYyHK5yctCZvH4aGQWKIvX60xugdLIJUxpprLQAoIK W0ahwgrzdyOyKEss/ubvXVqiC53PFlqoQKOa4+Ojbf2M0OLm9w95f/2p2CYVcogqoUVWbgqhBcpM aZGLKFyhhS2xWGwWO4ILFVmg1OXgka0jf6jQIhNZoD650OJJbkGhxXCI4Svuug6pCi18QqFFXEnz fRJr8mIKLeKbv81lxdImhiS0aEqsQgtfyfNj/iwhxBeHLs9Hmw4ttOjbe186bxeCin3p8lwRQmgR Q9v1QUz9Dd/LIyRRmsgtXEnuc1KMKp7EFjIqCS525BZ2qng7zbz85//7yC7sZTSZ3HWCNyLrC5HF r+3zbyKv8/Cc6cODXN/eyve7O7n/Y+KMVN5gSyBsScSq5rk7qYjioEnnrZBZ1MktdgQXUhZzrJ3P Zn/ektDjGcEF6RbXwFASWoiUhRaOoGKkAovRKCv1uSu5sEUYttzCbV7vTk7k/PS0SbU/y66Q4pWU W3iVsKJKcFGluqkTVlQdFZps2rr3EkKIy1xM0NdYTBAYA+fjRhNGIOZiLGGSbKXGOHQFWoRB76SP YL+diAkYx/GNCYjaB9sUwfh67sCNvn28SWmo2Em60Fcb2s04IdCEpjguTYQ3R/hC920MznDf7gZs YyT7w76NBBZMPkdI/KSWxGsmReIGJnhqF4znof8CIRqP8cNmKmncjI3rWMhZsD/z+rUe7VfzRvz9 sSVAocdKMM7ft99mtJ1OA9cjJez2zL6SH2ahK+CJlJI7zUNXgPQGjpt3g/aXMIbLuIR4Sek8wHgH oqS0X89DV6AnXIauQIvgepnjWc1gWyfEH+PtdBW6Ei3C37384rsfjnPjT8/rICRWZmL6PBy/2g87 xm0iYcf2cYz8EnD9h4LfjS+ln9cmGIt8G7oSLTILXYEEGZrw7KOkNW7SNXMx5xLE1CG2jufjOFCR hcY6TqWf5yxCkuSfAOydsW7bMBCGz3UCxHmFZhC6d+3spUunPEFh5EkydeteZPLcrVNXjXmB7kL2 zoELOE1O1IknRnIkmxYp+v8CQnQiCSfaphSKug9SCxCSvglzbt7a0d3dbzo/X5R1k3SK6iJw3cos 7JKlFiK30EILI7HY1sWILLb0+KiFFiKzEKGFFlhI3QgqrNDiH1mJBS+bcgu7rt6PiDJEotEttLi4 4Bj/lPUf99/p/eePr2QQeimyCBZKiDyCxRK1zKISWrCQoiG0+L9pFJFYaMGFCC1knVJsURUtyihV FkpoIUINEVroZHMQWoBRgNAi/v2nlqR4H2JOxutzvxBajEdoCURMn+nQ2/silr5ybClDzBKIocR8 LLGvt+82Id/zGMQTYwkthjKG0GKs4xkzttSEFrHs4xj7AgDsxVuiCi0naJP8DmGmfly5RUNwYTdo l1t0SSu6ZBduuvuZ8zd3211yC06Tf0W04Vu23142+8pjyVQKLVhs8SXP6efDA/3dbKp2apE9UFMS sVXLTvHE01MtuTho2SHN6CW3EKGFOo7GayW4qEsPuQVOBeMjMouyrl7PKhlFLbcgeiWukHLmLpXk QgstRJLBZVaVy/mcrhaLPqF+eCmfyH6L5x31dy2/d3uDNvlFlxpHmoac+q7eAQAADoEnf63JTJzn pNc8kRmJxeOAJ02KyEISRuBhfj9we6aUJDQPHQAAB1CQ6d8kuTkStx2GiCwk2dCKcO6YOnKtlpF5 X3+FDCZBXHEYP/RUBIzn1FiTaXdOco5EvH6R8wG3bUYmUUARLhwAwACWoQPwiJvEKydzfJKAHeNP +yEiC25HHs8LnZAdxMOKpn1NxQlKMkKSqqEUZKWh3IboW9uJVfTG/feSpiO24DiXFE/7pUZBEIEd i1THR7PQAXgkDx0AmBx63Bxji37g87xOJITzffxkoQPwSKrnajCMjJC88hRJSW6Avqw/y9ABeATv O4iN69ABeITnRxWhg0icY/dhmIMFgB2/wtzo3cic54zimuO2pmmJLfhe6IqmO38kpf8PkTz/OKzp 9OZD3IYOIAG4T+Tr0ozs/aRT+xyFRD/bBJEFAJHzLAB7Z5OjRBDF8cckk5CY4CzGPZmdiYlHkBvo DcQTeATZGRfGA7gYjuCSnegFXBh3GtmZzM4MGJkGxvo3XfTrhgYHqro+eD/yUtUfVf2A/qiu6n7/ RlVQHiFsEFwnAKpELXhAna6y97sqGgy+0+npvTTPRS20iEUuYHFbEK+AOAUXq4BNJrNVOpkkdH09 o/E4SafH41maJsksE57QYhNVghZlcYtlmgta8HnFckVBC9giE9GoPmabzany7wedn9+nN59fU6v9 YLWsUtCCCUdoQQstMKGFJ/CBoAU+K2EKyoUteF5P63WQoizqQJ7Xq7fFxTRSP24XG4PSiaDFkeD6 bxZBC//r9zngcF31+VqX6Xp9FbQwUadPv4+JulyXN1mfT9/F9+/ho8CEzyIQrrfv6zZtrLdvGRt+ uKzTl3VNlLftW2xlDil3aFlb9flSh426bNYpCEdIY0ecdt5vztfdVW4TBaEMJp7BVigXKM4r56um y8sWpfW2pdvyAN3Nv4iaA6K/X/PZj87O6MXFBT1stQqrF6LiZ7+lDv5fzp9QLjhwooUHKBcf4PMP TRuZiIFOacMyYtvm36VRMa3nFdIt4y5BjMgEzmr3ZiIkXLRkngmdzDLRk0SliUpvkFc2RX4+T1Oe x/Kpyt+UysyzPBdKgf1R6366uqJvv3c+f/JT2VvKB330oFJCfCBo3XIl9WKaDxatp9y4Jo3OE5tH tH6Wqfq5vUTGtoVQCGS83hbPmMX00rDv4IUFBIgYkrz0aJOOso+unTAEHnpvu3ZCEAzTpuX1p6vs sVNPwgA3Nh+YCfHTpuXxAYtJpKkucO3U7S05ZvxCi/FA7Ej27bsj1wNBiIOuskvXThgCfRydLctx 3tft/ic1+BMyCNyj2y8jp55Eju9jF//ZX91T9squJ0bBy8s9kn3bFPrcijb1sfep6Hu/PoXR195X 9ty1E1uAIGSPJLhAnXRo+ZtLO2k/cA4YUo33yHW2I7I2wZDi2T8QGKzv2gkheHQ7CPbUsS+hIPea YeP3DezdgPB4CG12wS4diuc5HggFxRSM0yYIKvjStROGQADZnmsnAmFE8YwFIyDmsI4N+d53Lbgn 6ysYUTzHl/QV2AftlS+W6sbzK22S/mSbxHRhqO166gE47jCGJ+/n5P1SMN/PFR1a+unrf4bxkC6F fxzh2Hjn2glD7HpeStifHoX1PIwJjuk6WSddkvEkWxzNe7HSVyPExj8B2Dt/3LZhKA4/o/DUAm22 jAKy9goFil6gfy7QoED3HiF36AFioFP3jh28FejUsejSTFmyFBkSt7Hs6lmi9URQiuOI4iP1+wyC Ek3RlC1LNinyg9QiUSKYJKNNaGFis/ydyk7lVk5Pv1KWPd2IK2yhBVMLLVYbqQXLLHiZhRYss+D4 +roUWVxdLYuQVwILFlnkm5jFFiy4YKnFYmGEE/W8Q+1CC5nnn0i7aaQ18+ZCZsHxqkrLO9/Q6fSi qNsFvXzzjF5/fEcPDx5tn7OFFkZiYYQW8iGFFkZGwfFGTlFJLf4WDyO34OXFetFYN8smP8dGjmFi W2ixFWs4hBaQWYyI0B91iNcPtc8QWgz7Olon0NX+OWmbvLivMrXtV+j90fR907Qv2vcjZsFEiLJ8 lav1fQmZb99tILTwk7eP7bXl177Nfba777a+ytNSho+yfJYJAOgUVfQttzCx7G/ZtmneJreQebrk FowttOgSYbjKttMkf4r9/0X04DPRclknvz86oheHh/R4Ot2mNRryHVIIe9kWXbiEF3vFHTILl9RC prnqKveDrDRypLtQ3zMTMY1DuBJZmHhViSfySmixrIQUHLukFlJkIddvRH6zfS7Cal1+z39eXtKX 8/Ndqv2pCN+oKa3oklvkjvW2IEUWZn1dLdtiCzuQY73t7VYH+rZBLETQXz8UZvKH55TOgCct8EDm uQjab8pPBdz0DkA8ZATBhQu+fpgBXUnf7A1uBQMdd2M0AyQSgo/tYyqPbfwHaQfXAwDS44TSGXzL k19/2DFvRvjdL5HtRRAVDYj2vos7tFfz92lGev8j8GRGMyonLjwLWpO0yaj+vziW39SxiSxsNLZb pzIRTsxkVB4bx6T3vK4BvrbMRRj8HBBAasF9iqkcE5iQB/QNBBdupPCHY9ybEC9ZEX6HrkSP4OYs wJxQOu2iPDnrq9CViIQ5QdQ2RnQ3wt6NAxroN5X2tmsQnslk4lNQMDTczvMkdCVGgq+TC2RP/knp wjDGtsGxtl3FJLKwyaist7b7WVKS0s+K8DZ0JXoC10F/8PnzjNLpH9sFjBfzD8bM7o/po/9BdT/9 aEBbDUiN/wKwd/a6UQNBAJ67SBAJpcgbnCLRIvIGLngAHiEFBR0l7Um09LTwFiiVJV4AKQUl7ijS oERCl/gO49ndsdeO785c1p717nynlX2OvZ6THf+svfOJ1CJQJpAkY5vUws4Z9aYsn/ZVdHn5E46O jtV4W2pBRUstaqHF/X0ttVitNkpogWILlFloocW6Elvc3ORKdHF7m6tpmGdICyZyM94ltMgtSQXN k1tCi3raQxEG5SzSeYn0dztbWZP5fF7+ph9qvvcfLuDF21fw5NnT6u9tOUT1aQktSDKhhBZGPIEy ChRaKKkFaFEFfu6Ku6rY36t5jMiClsN6SWyxoU9LaKGkFkUjwipmIRK4N7UILfyvX4QW/tY1RL2+ JS92VaePv4v7N/myX8vv6L+8ryIFH9c3ZL2+bgfO+XyKQ4QWbpb3bf4xlxl7XY9ddqj6fKljiLqG rFMQhAb7RBWuBRdVu2bR0b65T3BxqNCi/bddw13jCDZH/wI4/gqwuqonn5+ewsXZGTw/OWnMvk0C Me8Y3yazAHik3KJjuEt4YU9T4x1ijq7vNK0xFMHFqFS7c1FU/wZ/jWxCmR2MiGJt5Ba5kVt0iS22 SS7sZTZmnKQWhVnHn3Leb9fXcPV773t7WVk+Qj+hRZfMYt0a2kKL9tAubakFHSVoGkDzSDIpsYU8 2xamwgSe13OAHZ8S0C/shdKpdExEYuEHC1NCIANJ/ifEA3XkSiC+l8bl/CH0gSQACfjXeW5ssBNP CrqThCSCnj64b1Onodj3bTkfCEL4pBBOe8uhSbwWULc94TCGjsh47WJ37pTjOxO+P7v4z/ZqvIde luXdIMEcBl7LoMhiiolKpk7I19SYACcFvV9lrJG4AbfVZ+DfTpj0egmSkNM3XlslhmukXeA5ha6f voMHIhsGqUUy2gqHJ+UOQAieBOp7TO5z7JiQxIJKxheK4Bi833vJHYRDUu4ABC9YgLzHEyN4LAsl aTnek0h7Vz8S7gAcko61It/brgV+ZrNZSNeIeDxlb+uJhBTcP5vGe9GF4zqFhyTcATgk9uso+73o 0Nr+SUafQjjvcC7BDyHjF9CxZLxhOCWk+8MMwto2vhHSvtKXlDuAiKA+s1RCOi+7gN5xpOf0GWcw 3EhbjRAa/wRg74yVmwaCMLyTeGjoU4smFQUddIh3SA/0FLwFL8FMXFBSUFCmcMHwBGSGUlVqSJHJ 4EjCa2mt1VmyY/skrc7/N3NzJ1k6nWxZlu+k/SC1CBTjQTLahBaSS/nHIr3cVNHl5RVF0fOluMIV WjCV0CKj+VzyQmrBMguWWhRCi5Tu7rTQopBZcJllFpKzOKKSVfxzZBTrEotqvhZa6GUf1LJpWZb4 RNlWocVkcrLYh1/L8qfPH+nZxSs6fXK6er1NaJHl2TJnuYQIJUQ4sRJa5POamIJFFVpiwdP3+X1t WosvuB4RWXAuwgwtz1iKLCiH0AIMHx7rmIQWXW/buiih7+1YDaBr/XOyFrzYZ52WxAk+6ht6fZ91 WQkCPob9GKtgAkKLw5az3DZr7YDQws/61pbvc52+t3Xoul3Vaena0mc9XdcJANjIJlGFb7mF5HoM ZtXfuU1uoZdpEl88VnbRFrJ+m+hC+EN0cr14D75yIP9q9ofzc3p9dkZPJ5PVvFoHf4MUwi27oos2 4cXOuSOz0NtuEl6stdGZ5+5H0/6S85qL6dGakVE7ZEuRheRZKZ5IS6HFQymk4LxJaqFFFnp6rpaX 9VOVsrz4Xv++vaXvNzePafaXRfpJdWnFJrlF2jDdlrTIQqbzsuyKLdxEDdNtb7cpMLYNxoLx8Xor xCrxzXu4Ya9CAuroG/a2gnMkAMcLfnd2JqLqxnHOQwn+yw9y6d+O2ZCNAaOFH9iJKbzvRxN7XXOB 0SLHtj7/h/ofhI/thKoAnbMB2wIA6A8O1hDKee0N+Tl3xRRW35M83JlQdY4HRrDeL7dnv0FERUCL tz7bsgN8TTOlcIQDIaD/L3IaU2Dnv1TvL5kN2JaueUfFd7dPqSu/v99UAraJ6TgCtHNfaUJVUAwp m2MAqQUAYD8k0GtM4fzPZPR1kuTHHBASABNY72cAAAAAQDigrwDsyZT8jx+9J8iSATiEMQfT1jJq TsmAbemSiIYZf+d7TXj8bkro9wMAgL544aSQn8fQ8G9OQuvj9ECB/n8QGv8FYO9sctoGojj+ggSq VLFg2Z2F1E1X7Q18g/YEFUfgClyASt33GlVWle+A2FUVu0psWlaA4hD87HnxePDkA2bwG+f/i0Zj J/HYSfz5Jn4/SC1GivKgoU9qYQstvlblx7qGptPftL//th4WqUUjuGhqLmXZiC1YZsFSCxZa3N8/ 1EILFluwzKIRWsxrmQULLERiwWKLRmoxq6ZrZRWTiS2j6JNYlJbEYuYIL9pcRe3zttBibsYlD1E/ BwcTur29rIe//zyjd/mH5WuuFMIVWtgPEUywyIKHRUTBYgqf0EJKn9BCRBhcSnkYYUYtsqjm3ye0 kHH3M4AdYOifGkILtB1rHpqS3MdqK0a7GsQRsdrUktg5VHtDTx+yLS1JwFP4HKkKJlIQWoSef+rz 3OZ9mpZjrEKL57z/NecFocUw08VsU9O5Zch2YrcJANiYdaKK0IKLZZx20Y3bmhF3Ar9sYlOhha8N X71qmOGQ9V+iN1Oiu4v26U9HR3RyfEzvDw87b/dJIPYsSYQrtXDlFEQvlFusqH1Siz2zrCLH6Pss EFwMz3L1XSyWq/qDkU3UZgcjoiiN3GJm5BYzEVdYYguf5EKm4eG5GRaphczvrizp1/U1Xd7crFvk P1U5p82EFn0yi9KpbaGFW9vFlVrIHkOeI3q65/B93apA3zZIBeX99VrJqP2zXk7jSQKxiqAJdbCP BGB3wXEnCHzcyag9FvGw1qRufAMX31hUkPKEbGA0ZNTdNmQ8lXM1vkGCtxmRV1wRkkCDhsyUnNJf t68IxwMAdhlOrPlv6IUISKwLHPt8Jjf1ayb83gSJFfG+3T3nB4rRHpd7YdyA9zFfTPkcZIH64Wvd wipIqJEGOXX3rxpuxLfj7vZ14K5xQvG2WxGrFgTR0hjIqbstazs/8iFJ2JnCqv9TYuskpBYAJE1G 6cQX7etNqeXaEwCgDO1xBgAAAACMB8QKwDM5rcq3gO1xH9HHgO0BAJ7em8PjGuL/kuxaYlPFkAsz EBk1+1Hux4vxm/B3bPfjIf4HAAA6cO9X4v9jafiPzTZIX5Nb0N+0BYj/g7HxKAB7Z6/bNgzE8QMa IEPXdFeGAJnTpaP6TH2LPkCGjH2FFl0ro0sLdG9HTZmbDEkRR1Z9Ek86MpQ/KYuS/z/jcJRk0Yqt D4ek9YPUYqJE3GjYJbSQLOWfy7haVdHNzVe6uLgyEotaZCEyC4YzyyxYZDGfS7aFFo+PHCy0qENk FiyxuLurhRYc/JxaQvFEWlhRyy1smUUrq/DJLZ5VbqMs9b2JFmuFFqenJT08/K7K198/0pu3580y n9BiYepiaYVMV4qJsmhkEyyeEKEF50pUoWQVLK/4t3y4ggtLaFHOG6lFJckw9fJDBBry2iLYqD4r CC2Ol6E/aggtUHdfrxFrfRBaDFdnLDd2DlXf0OuHrAtCi+MQTBx623dZZ+xyiaFlDjFsx9DyiT7F DhBaHGadMa3XZ50xfbcMWU/fdQIAdmaVqCK03EKy7pdp2kL3kVusE1psI7VYJbdg/hK9+kVUfLZn f7i8pHdnZ/T65KSZZzX8e6QQbtkVXXQJL7bOqi5XZrFOdOHbVv13kDOPPPO7iLYXJ3KsXdSILCQv jHiiMEKLZyOk4PykxRaO1KKRXZhlc/V8Wb9QsSjr4/jP/T19ub3dZLM/LeMH2dKKVXKLwjPdFVpk IdOlKbtiCzfIM931dkcD+rbBWIi4v35s8AA9PVgvNfPHNGhvZnKmci831ME5EoDjBdedXpFrkWQm MSHLQ8kvRFbB5NTecFEGeWOwN4gROT4Sao8LXZbp0D++kx9FCJnJ+ntWRgDsjuzb+vyvy0xC4fdt fVNOIvvcn3nmAQAAky7j29AbEQi+xicHfs3UyXINkHKIm5HOVDmnl9/19TwwQmJvlwvcbpBSe/Pz bX9gLd/jIeaaNr62lFQt3/fcqttPMpO1DAjYSN8Kh/S3bPL+u8IALYvE/yPTJyX/MRyyLVQzc6bd fjS9301uH4TUAoDJkprsa2dkQo150G3l+vyZOwEAGBGxtzMAAAAAYDqgrQDsSEph+6ffE9r3ATgU ug/PHfe5bx+A7lvKOwLYiHSEI6HN33/pL83ppcgWAADA+EhN7upT6kOo7o5XZzJV9o1fBwFA+z+Y Gv8FYO/scRoHojj+BE22SYGERDnt9nsAH4GWmgtwAbgBot1rbIO0VG72AFvRQURLgyjCl4nxxDPx 5MXjxGRsv9j/XzSyPZ55HufTGkfvB6lFTxE8aeiTWrg5oE6z8ntdoJube9rfH83XrdQiF1zkS12S JBdbaJmFllpYoYUuWmgxnepihRYfc6nF83Mhs9BiC11fiCrembAil1wUOYcKcYUrt8jrdNtPZ3/i bBe5h3LBhf9zORq9ZuO9I6WO6Pz6gsbqcLHPJ7TIEzrNSoUWc+WEEU9YKYUrtNDiCldi4W77hBZu XHusmXm4QovUefBzAANAwkvd9hggtJAVu6ljSI4nOSGvtDgh40lJ7BwqXtf9Q8aC0EKu1EDi8eq0 ayruUMQXddvW7dO1UKLPbbftK619m3266Ldt3ybiSbwmlPYcAQAaY52oIpTgYmUON13eNhu802aC i7qyi6pl1bpGT2M/EP34S/RyW1T/OjigE6Xo53i81JxLIWzdniOE4FKLMklFEMmFJ26Z1GLPjNXK McrOxXduS8uKezZi7+YIZvF2TdPFW3tmZBNzs4MRUSRGbvFh5BZWVGFlFm9s3Uot3lmfT7NupRap OcY0a/vv8ZH+P63Nl3CflUvaTGhRJrNI2NIVWvClW7jUwtrUbR3R6jeF7+kWA+5tg11B8P36vhGZ pSJ/EuWQCXZ4Up0JVSeIaBV8RwIwXPC7I5bIUx+3OAYAdoGoYl/c0hgAaAI3KTqnd0k4AQCdcpaV q64HEYg/WTnuehBrUFQu3pgQkjAMFunzci3OGyha/nzgmgfUISqpw3uoOXgShAnhdwx8n6hiX9zS GHYWSC0AAAzfnCKuiwAYENLnGQAAAADQHzBXALYgChgrDhgLABAeRav/keByahAWPkcYdzQOAAAA suH/+3DBb7VQMP8P+saXAOydMU4CQRRAf0KIlSXWlBQ2VjYewHgAWytP4AX0EraYeAQt7U1sbD0B DbGhQmEX97P7l9nJsigu7gjvkZ8/MzvzM4A2O2QfUostJdCbhsuEFpat/ZLEUVWhfv9Jut3DTGKR iixMZqFoVpmFiiwmk1RqoZEKLWIZj1VqMZ1LLVRaoVKLVGShUovPudjCIo5dkcUkF1mk2eQWi+vF viu+sHFfZqE5zsaiyg+w3R4mex/K6dmxnN9eyv7BQprlPwzNJBYmtHBfKplQ6YQKJlRCYUKLuZwi k1p8JC+TW2h7PBsX+ta2+ZpNjmHZF1rkYo0SoQUyix0jhK8boUX49RFahP0w3jrrhvjw4rrqhVKj rlpNr6+zVtPr66qD0CKsWpus+9+FFpuYt+6aJve7zXN/uzZEQcVfSiYQWoRVYxO1NlkTAGqnSlRR l9xCce+Numc1+b3SdeUWfn/VtbK8aszlXaT1KhI9FIevej056XRkr9XKxwoHAiVSCL/tiy7y7Mxd S2Th1nKyyGrRRdle/fdR9n7Fu+YT5KlOoBT+JDORheU4E09EmdBimgkpNJdJLVyRhdufOPNtfeRE PEv/b99GI3kcDL6z7fsknqUoraiSW0Ql/WXhiiysP8vavtjCDynpL/u4g4CzbQAAAAAAAACAYH8n DgDNcJfERdObqImbJK6b3gTAT+HsAgAAAAAAAAAAAAAAAAAAAAAAAAAAdoUvAdg7n9yoYTCO/jIZ gcR0UQl10Q2t2MMBYIXUS7BjwYIbcADWXIc7sENCSBVLTtDVVB0mGew4n+OETP+MMpNUei+y7Dif XSfxZGFVfvOxBwCgttDio+4QWnhOT8+jwMKwfwT39Sa1KEvVeRBcNKKLUqtVkFz43EsuQlrr+rqo 0nK5du3WtWgi7C1kUopGaPG3I7zwcask3vYkWtdlk1tYn2G/oXBebr3fPM/cOH+58Uufv3zQ608X erJ42tx7Rw4Rj47QwiQT/jDxhJdReKFFJbVQEFX442ZzE1N6HmNqkYW1S4UWhR0doUUltdi0RhjH DHBQEFpMv//HKLQYmqlvxjtUv1MRA+yjv6n0MVRfY7cfsq+x2w/FVL6VCC12Z8r3MvW4XduM+c6n IJ44lNDioUxRaLErCC0efx/76GuffQLAXrD1yj5RRWtDkkwxLl3jvK/gwuKq9lmzXhqzLPlbG7VX 0vu+Kd1rWae87Vp63q2/DYt7LhUXLn/n0h/p2Tdp+Vv6enlZpbcnJ3p/dqaXR0etHfQz9yyrYWVZ qHfnJpFQfa0Vr7CK7mO8UMDkExYzq2PulVv7bq72o07LWdJeFp+MNQotknPVG8vFR2v3bLE9j1Nq Xhf00zd9Vb9HE5f4Z5273M+ZVu7S3KViNtPcCypcOXflvI63VFh7X/Z1CvMulan4mBeLhV4dH+vn 1dVdw37j0neFKWTTseo2qUtTqWbK5WqkE1afTkmbYtL/01dqT6nbful99Q/5KgAAAAAAAAAAAADA 4TkfewAD8mPsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAADAdv4JwN4Z4zQMQwH0N1RUqlgZEUIsHAA2 JI7ALVgYuQVHYOMMSNyAmYUDsFeMVAKahtj1d5wQlAIJNug9yfpxEn87sZPRD6kF/BZtezC1nTvr SnR1dSuTyZYVVVhBQiG+GKzIoSa2qIQWRmChxQgtXl4qocV8nsvz88KX19eFE1asBBYqr/gotFhJ LFbnF158oTKLSmhh6rk7VqnFslNoMR5n5Tgf7PHl9YXsnB7KeLP6dD8TWiyLpY1GLqFCCRVOeKFF 8VYTUxhRRVNiEdZVeKHR5DHtNaowI5RnWJGFFAgtoCL2lCO0SD9/7DXyXVLdQDfleUpVaNEHKb2f PnLFbt8nKT1LzM3I/7Jg4rf7G2qD+hhyhdRFFX9RaBEzZyr3DtG+79z/rc1P2v207VD5UskxRK4h cwLA4HSJKrzgIrgUCi7WlVvovdp2NHI5QqeFCi5CKYVuNR9uXd80MkjjmnRcW5dmnwaz7f6eyPy8 jE9l9V4kvxG5m81sMVwcHMjx9rZMNjaqoRf6vsQKBEIpRNGINYlFsXpXGr34wgknvhylMglkYV+B 8MLbA5w0YeT6VqFFU9ShdR1f/R265x61rC0XkVt0oyIRv0Z0HnTO3PxlTlKRB+IKLWN33scss8IK sxb0fl0num5z18e0XMu70+k6Uov9shxJJbZQUYUet8kt9J5QZKHLMCw150pwztRz+fjVt/01RL7+ JwAAAAAAAAAAAACA+JzEHkCPPMYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8zrsA7J1LTiMxEEAr ICGQWLMZCaHZcwZWHIEbcI65wUizm3OwYcGWM8wWDsCGn4LoDz0ux9VxOp2EX2MD70WlqnbbbpxA Fm3Ub9Q+dAm+FH0PQUrMIqnFKDp37OLvqonOzi5lfX3T1ya1mAgupBVZaKjIoiwbF7WXWKi4QiUW 43HlQ8UV9/eV3N6WIQq5uSnl+rqQuzsTWWguOrkMdSy2sLqSqeRiIrGYyi1ioUUdjvU5RIuFFhsb I3l4+OfrPye/5MfhfnuuK4XoCi3ilwkmVGShtYkoVEzxGqGFiTA0KnsFYYYXWbjr9wkt7Li7BvhG pP7IU1w/1ZoRWnzsdXJ9gG7un1NuDy9+rzlzW1fq9eT095bTWnJfR65Ci1znGmreXN+XlP1eOwah xTB932N8bv1zH/OWcW8dO9R8ucwxxFxDzgkAyVglqojvzcd9XyK4UObu/zazx+Fgvu5rs7rpqZ9z blleViu1W/uFyNapyPhi2nywsyNHu7vyc3t7pnu7aRDex77jtVCvhXZr68urzr80e4lGNG/cJtZv yc8eH1vbTF6yt5Pdrk8GtL+OQWrh7Q+6F2FCiieVfTeTcHXpcqnZReHiUXNd+xzX/pyri2iM1nWo NdfhmnqNset7fnX1HLHFpYvfYkZ0s6HHlvT+sI2lqpMtnnpyHE2UrZaoTWT+m2DR250c9rYBAAAA AAAAALL8P3EASMOeTO49fxX4coNPCXsXAAAAAAAAAAAAAAAAAAAAAAAAAADwXfgvAHtnjBQ3DAXQ v+tlgFBRUKWiyDDp6GhyoHRcJXUaDkFLQ5WGFClzBapUYYCRHX1JX6s13pgwNvaE93Y0kiz5S5a1 W2yht5p6AvAm2Ca0aPO5L9DFxZXs7OwniUUUWVhS4rUmtNe1iHN1ElzEpHILFVtoUsnF3Z1LeRRc RNFFPDuoX2jxUAgtrH88gyjKK+x613lDda/QYm/P+fn8DOWv37/I4cf3ua1LaNEWRwSZhX4al2UT Kp4woYXmQVSRZBVZZCH3TwQXG0KL5jFLLYIkI8XVjwk0bGwTbEh4UoQWb56pXzlCi/nHR2gx31hj xJ3b4cVDxZzrc/0vzF0E8Rqx5iK0GHK8IWMhtJjPmGP0eykILcbpO8T9c+v/mve8FIQW48QYI9aY MQFgUux/zW2SCjuwRA8UK/v23dfG+tm9OZ79F64FC9XIph2haV2zsrVJq0162p5LOabVK599EPl9 7su/fPVGxF2KXN/ehrTyz3V+ciKfjo5kt6rWU7d1lHQ4m6+Xj1DmZVllBkEyYfmWe8r+KqLYmkuU Z1ielym1L9L1Js1T3/8ijZ2lGmnuEt6h5Poi1TfXcL1/upbX1gQ2sT2S94Ste9oDy/S+NK987nzS fNVRzvlyGcQVwRKR+ti+sH3q0hjv/N49Pjh4jtTi2Kczn75J3DpVCmVl22plsj61rLe8bbsylW1S XNO6k6ff8q5fCZF//+YDAAAAAAAAAAAAwHScTj2BAfkx9QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 4O/8EYC9s8lpG4gC8IvDAoVNusNSVGXFDnEBNkhIXfcSvUN7h265RrvpIdixRCzYcIZKKChJPcN7 9stgB1DxD+T7otF44jdvZmxHiryYD6kF9IltsBP4VpSTbcEXF78kz+dRWOGxTcJMZPFY1lFmEeog s3h4WMWyWCxjbUKLILMIIgsrQWgRJBQmq6jkFV5osdg4tymxsOPHUgktrL2S0SjIJ8J3zfsC7e/f F/O5lfn8UL7//iGfjvJqvYnQwmQR24QWUTmh4gmTUtQJLTbkFtpuElr4vDbWSj9eaLF2n3QNsEP0 fct3SWjRNkMXJXQ9zlA30B36fRra5sVt5nwtQ3tG++7fVq4+x96ldXQtZXgPQou3zjXkMdteQ5/z QGjxNv2HFt9ln67H+t++bTG0OX3U/5cA0Br+HWedqMLeW2tALa8VXMRjlVtE2YWOsR6VpotqPL99 /dOET+NfIrvw7W35xcX4XFOR5XlRnxWnbkQmf0T+3q3l5/V1LF/yXL7OZvL54KDs4iUQdVIIk11Y vIknShnFM9KKJuFFmcvi0trFe+GFL9EsYPGJmCNti0osyjnYmi02ubT+duwydY+nOJFIpqKRTOUW YxWVxFpFFeMsk70iZqnHYxVfWFlqe2UCDFF5io6XacxsMpHj6fQlYovTolxKJa0IaZqEFuZUsUfK BBep5GLDr+IuRyqvSLUzTb/kuu+f+9UDAAAAAAAAAAAAQPd8JKnFVd8TAAAAAAAAAAAAAAAAAAAA AAAAAAAAAIDt/BOAvTNIShiGAuiHwkLQhTPsHXd4Ar2A3sFx4cYbeAcv5MoTuPEQbhy2bGSAmYoN 7U9DKFgGsCm8x/xJ0oafkAaGVR5SC9g3RWcqFV17+ivRycmZtNvded0cQmTO68pjZsPILNL48YQW aRiRxWSSSi1GIxO51GI6dUUWq4QWUyu9yOUWJlSG4Qst4qxtShVarFgscyBS9JXMZSgPj3dy+3Iv 3fNTe9+XQ/hCC/dlJBNGOmEEE0ZCoUKLuZwik1pMkpfKLcaz8ULbrWt/U6ocQ0tfaGHFGgVCC2QW R0rVj/3YhBb7HLvqZ7ktockC6pBrH3kPWWgRkgBiF/mqfv8uc4VyCHgdPkddBRN1EVr892cJecxN +oU0j0MVWmxLaIKKQxRabEOI/51C+m+5yzz7zgkAwVJWcKFCCu3n1sug/fS9Np86LRrOj49/jP3M u6b1skIL/15Z3DG1HSXFlch3EjJMmh8i8avI22AwD8Nzvy83vZ50W6186rqOsiyF8MUUC9KJWbpW TS0lNwCsK/2cVoghuWnA7SuO8MLaBTKpQiMbW+e+TtSxtMTO/ilaXl2TY0f3hN0Dus7ZM2+q3CKT VMSZtKJVULdlszkXVphnrX10H+i+jLMxOlEkF51OGanFZRLXSbzLoqhC60VyC+3jiix0m7mx4FRx rpl2LMvf6qJfBZHNv+kAAAAAAAAAAAAAUA2HJLX4rHoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCe XwHYO5uchIEwgH4Wo0E2bJGEmLgzceHauDAx8QReQI/hCVx4HPduPYGs3HgEAgmBgkw7XzsMLWCE tsh7k8lM25lvpn9AWMxDagFloQvrGIzQ4mpVh3b7fGGfLgZmislEcyq2UKGFSi2MzGI4nEQyCyO3 6PdH0uvFeTAYeSKLPKGF7hvb+lhSuYUKLUJbj6UW8XYstcgjCAIZjz9nOZTnlye5eLyVo8Zxeq6e HCJJntBCJRMmqXjCyCiM0CKSWkgsqjBpOB0m2d1O2liRhfZzhRahJk9oEUktpnMzTOYMe0jZtx2h BbG3NUbZz3bRVGmx4KouOFyVhZ03Fa/s/puMhdBi/wQTRY/3H+QSVR3zL/Gr+n1R1fGL/KysWvsi ++xSv23GrNJvy03G2XZMANgZlokq9P9s2yCT3wouoront4jGUsGFu3y9u5z9YsDF9uvILtztZfHF aePGaoqEd7PyZnboS+TkTaT/LfLa7UaH71steeh05LReT7q4EogsKUQkl3CGy5JcBI6cYN1yQV7h l+4YkgovXMvAgdvfE3P422IlFsml1XPWtt6ldW/HPpH1OIojDgmsWKRmhSRzpRVV1IJADo003dZr tr3mUPurAEOsLMWOF9g2nUZDLpvNdcQW17P8Iam0woTJE1qoQ0UfIxVc+JKLOZ+Kczl8eYWvmcl7 c7P2r3rLAQAAAAAAAAAAAKBYzsqewAZ5L3sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCcHwHYO5vc NGIoAD+GkajKMidINlFX3VW5SM7QbaTcoodAyhmyitQDdJdND9Adq+5okFJgahu/4dlM+KkCWOL7 0JM9Y8+z8QwjBNJ8SC3gkHQ9O6lr39dtiUaj71LXH4K8IggTGjERxQ5GZuHrXmQxmzUhvMjCCy2m 06XM4uXFCy1mMpksw0stcnmFjVRo8WoEFqnMIhVaLKUWTbOQbUKLuq7c/H6G+reHe7m8vUna3xJa LFxuX3q5RBBaNK1qYiW0aP4mYgovqgjyCvdq62ZbhRda+jx6vM9nx9B6EFlIkwgtFub9IrQ4U87x tCO0KCv3ocYoOV/JD+Qt9Z6A0KK8498zF0KL8xBMHHvu/5O3ZLnEqe7PpxaIlJBz3777cKw5lCao QGhxeEr5nlDSmuSUPDcAOCqb5BahPQouWiFF7LvtuBztF47trX5HboueuTHlj7Vvsn3WArGL0CJv 2xU7pm4PXPFJ5I8L+S3SfxaZP4o8jcchBv2+3F1fy83FRai3U9d1lFQKkQstctFEEBK4/pWWkoon tpVrggxZmQfyPrlVoBclC704tu7bJOpYW2Jz/XQtr67JuaHXgF1ru85VlFOopGIepRV1R70tqyr0 D//0xD563vU6nMcxPrpr83I43EVqceXii4sfkooqtN4lt9A+VmShEgsbtk3MPr89l/VPcdddQGT/ TzYAAAAAAAAAAAAAHJ/Pp57AO/Lr1BMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgM38E4C9s0lpGIgC 8DMVwboRXFko7lwIghcQXbhy6R08iEtXgrdw4dZDeAAP4Ma1IK1/acxL5sXJ2NYW22bU7yvDy8/L ZNKkNCTwPqQW0ARWUEc5zdveuOSLiyvpdrdrQgvFin5pGAykJrUwoYVGlVm8vg7k+TktWq+XekKL t0JooWKKUGaRZS/yKbJ4cfIKE1qUrZxO3bwKLd7dfNlKwYW20bV/VlaWpN8vhRaXN2eyebhTrfNF FhZNFqFCC/sUYomsjCaeUBGFCilUTGFCC5VXmKyiklnosmCdRhNZmMyi+OT9mdDC9leNInPjcoKL 8BjgnxHDaV/0GP6q0GKeILSIq2j+PIm1eHEMQotZ03Sh6Ziu6VjOzW84jhgFE00ILeZVPD/mY4k9 76fbzKrPGIQWMeT+dNtFCCqmZZH/FU0ILWK8d5oFMd1vAABMgP98dJiowp5zu4ShTCO4MDFGJcvw nRYmuPDL2fvl7b92+DV/EtmFPz+uf/Fy/L42RNKjPO7nq+5F1q5Fnh5SOb+7K1Yfdzpy0u1KZ3W1 1nU2RgqhLxISb3ehaKKSU0wZqz703YXtx4kUalHqwgvfOrBUDr7M88QcJk2weTu22tfmXT+h4CI8 HX+ZYZefeKKQxIlEWk5AUotOVNFKElnOc1I33XL51kyEMTABhjg5ittf4nK22m3ZXV+fRGxxkLdb +ZRWaDejhBbmTLHLxgQXoeTCF134CptQXhFqZUb9Uoct/+5XDQAAAAAAAAAAAACL4bDpAcyQR0Fq AQAAAAAAAAAAAAAAAAAAAAAAAAAAABA9HwKwd/Y4DcNQAH5NW7VShRADEwMsHTgC4jxIHIFjMHMQ JlbYkFi5QDemInXoT4gdv8YxqVKqNjHV9yHLqfP8/BPCUCR/SC3gUFSdkVTVdleXaDQ6kSTpl9py wUV+SJXKLIzYIpdaFEKLXGphhBYLmc0KoYUpRmYxnS6ymEJoUV2HQgvTNncCi1Bmkde5zGIldUKL 4dDM59NeP70/ytn1RbHGDUILu2YnjlChhZFY6I8RT6jQwtRWVBGKLCQXWPjXJaFFOl9LLVRoYcYw tR0zXa7HtvNAaAGxgdAi/vzHdkjxLvyHw3hjkj7EeChzLDn2lavt/vvM1Xb/fdHEOmIUTMQsgfgr Ma8l9rhd+7T5zGMQTzQltPgrTQgtmlpPk3M7NqFFLDkOkeuQOQHgqNDvSzdJKlRwsRZSuNi6fiEa Z/t20uJ7Wq063h+s8Jj7NGjzLRDbCC3Ce+H9Tfhj6udBVo1Fvh+y6y+R3pvI4kXkeTKx5bTfl/vx WG7Pz6Xnyx50H0VKkohQaBGKJqygIItPtJayeGLbOg1yryruhZaBjpMudNzYYWyVqCN8VOL9/lRt r0h5i48Vfeb+3vr7mjg5hUoqlp64QkvPta/rJLHx9r8+LkbFJvoclm6MQbdrxRZbSC0us3KTlVcp iyr0ukpuoTG+yEIlFn7x74nXZj4v5fdbW/XWi9S/uQAAAAAAAAAAAADQHldtT2CPfLQ9AQAAAAAA AAAAAAAAAAAAAAAAAAAAAACo50cA9s4gp20gCqAf000UCUWqKhEWKCxZsOAS7arL3qDXoHsOw5Yr 9AZZV2xYgxQkSKg7Y893vweHpomNJ+G9yBqPPfNnPHaycKT/kFrAW1PlYHJ8d9v5vzpMJqdF6RM6 5Zp0K+z4wkstVGzxUmjxLE9Pz0FosSi22WxeCC3u7+eubgUWj1IXWdhShRblVu4v5KXQwtdVZuHL 14QWD24uv9z1HcrF9Q85mHyqzsVCC5VFqNBC61ZoUagn8lJAUYgpgpQiFlrU5BahvkxoYePqWDq+ FVrk5hNfA7xD+r71CC3Sj9/3M7IuqSbQTfk+pSq0aIOU1qeNWH33b5OUrqXPZOTbLJh46/G6SlDf h1whdVHFNgot+oyZStsu+rcde9f6bNJv075dxUslRhexuowJADuLfXfaJKrQ99+hQSP/I7hQMUYl y7BOCxVc2PT2TXKLeD6rCC3iODZ1/mu/m00p9T+KLL668rM7dSMyvBK5u53L5XRanP4yHsu342M5 GgxqofMggWiSQvg/GDKpT68mpQjSgnVLP1au44R6rZS68MJaCPbKyZftjJgjM9dRLbkVeoR+1e2K BBexa2SXiB8rXZs9u3ZBZOHXvVaqwCLL5INrU4gr3P6+21exhRVh/NZjEmQoYbwstDkZDuVsNFpF bOGlFj/lr7TCh1kmtFBHij4mKriIJRdWdGGVNbG8ItbILPtmNh1fRVUDAAAAAAAAAAAAAN0y6XsC LYLUAgAAAAAAAAAAAAAAAAAAAAAAAAAAAGAL+CMAe2eT0jAQBtCvaUVBQcQbCOIFxLUbvYO4cOnS rSfwED2IILgWj+FGXAkuLKRiq5npfOnXdLRRmybqe2GY/5lkpimFwjykFlAFsbOQYmWnswbqdi+l 01mxZzD5tMosnMhiOBQjtRgJLV5eRiFNh15okaYjqYXKLFxw6bG4om/iNCK0cPFnQotByKvMYvDx 4riDjtr30us9yfHJoRxcHMnqxtr4+YwcwsoirNAiF0u8Tcos3KUiCyemcHE/u3ysIouQt3W2vYvz 8UJcFFqoVCMmtEBm8c+pe/vrnn+RILRY7DxNPUD3t+9TGZp44PBfO5S57v7zHK9Jz9L05/jNgom6 96kOoUVT56yi3Xf7ILSopu08+jfxd2uT+/yk30/7VjVeU8aoYqwqxwSAf0NZwUUupAjtbLoM2s73 bRlBsUYt82VmLQ+aL4om7BH5UqiTGXVlicktlrPktsjzeZZ+FOnciLxei1w9PPiwvrQkZzs7sru5 6WUE+TBBPODTRhJRFFoUy3Ta5G0kBVHrwFfjXJQhYzNBsW5q/iBhaIW5p9pGRB1TLhLz+Yktr9i2 fwjdY7uWdh2TIAxJgqRCpRWdD9I+nyReWOH/AQplKjDRdR+EOZbbbS+2KCG12MrCXhZuZVJUoemY 3ELbWJGFSixssHViylx+INNvaewtF/n6mwsAAAAAAAAAAAAAi2G/7huYI3d13wAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAzOZdAPbuX6VhKArA+CGKYl0EN+3iruITOImbPoOL4Bu46+v4JE4OnX0Cl4KD Ytt4b3JPcm5IWyu1uer3K6FN2vxvoCDmI2qBVbK3wbp2w8m8GQ4ODkPEIo9iFl45rY5ZjMeTImih gw9ZvL2NiqjF6+uoGHzIwg/DYRmrKIMV71KHK94boYuPlqBFGbUoAxZ11KIc16hFuyzL3LYNZORm u72/kuObM9nY3qzenxa00HhEFbMIkQn/0PCEj1H4oEURtZAyVOEfVczCDXZcXxfzSD2fDVqM9dEI WhRRizxKblTbjH+s69Pfxfq72ucUbwzc5XJ/ej2p3kA39fOU2s2Ll7XMVPfrr0g9BLGKZaUUtEgx MNH1tqcal0g9VJHKbxeCFukHLVYRzFhlnOI7UgpaLENqv51S/H0JAMasUEVuy89TKgSLBC40jFHF MmzTQgMX9nb3esv7qJjQ2J6vBC3se3a8OX0W/dyuyOjCPZ+72Z9Feg8iw5cPuRsMircv9/flst+X va2taNPzEIGQlihEFEJwwyTP63hEGM9MzGDRZ7+uPIQVJmHdOj0z020UQ8y46OdMmCMz+1Edchv0 sPus+9lyOKt5f7G2r5do0ELCsQohC3+co2cNWGSZrPu/PYXXa+61DVyMdX6dJuF7IvGl0u/15Ghn 5ythi1M3PEodrfCLmBa00CaKfj00cNGMXNjQRXXqJb7iROJTPutKbJu+yFULAAAAAAAAAFi+uf+L 8Ys8db0BAAAAAAAAAAAAAAAAAAAAAID5PgVg74xxGgeiAPoThaVFSkWXhmq1VHsHDsMJuARHSEVD T0mBKLbcmhNQEUWKhMCT2GbG9uBvr52wyDiT8B76+jPD+I+ToCjKoHmDykFIsDfUDyXqc+k1Y1pq 8dfGr3WFptNbmUx+VqQWTmjhs5dZGJNLLIxxEoskE1k8P+exWCyzmM+NjUhms0ieniI759XWyUPk pciRylpoYaQUWqykKrTIpRZ5P5F1QovRaChRlB+mdXl9IcdnpzL6UXplNgktnFwiE1qk76qJUmhR E1M4oUUmr7A/723V98ILn10df72rp9fw7UxkUYg1EFrAP2z75f9OQouvXjt0UULf64R6gG7or1No hxd3WTMkcUIX9bZ9fZe1QjkEfBceR1eShH1fL4T1d33N/5kX0n3sq9DiM/P7XGvfhBZ9yzNC/OwU 0mfLLut8dU0AAMUmSYXeB9BzPyq30FS+600bvvOtv+eltbF6u62/6XdNedOYZiZycC+yvCuHxoeH cn5yIr/H40xO4NEbFv659OKDentYzGkaG6rxz+SsRkseqPsY1Mb82vqxDFr6fqyS1+wj7bLcovIn kqbZro3PTj4RF7FKElnZvCyysdm1IxsmjvPs+rZt/HjRX6r5/vpYRVJI2R8WC7l5fPzIbV/Z+CPl xpMLtykVizetVyNu6LdFosL306Kdqn5TSEO/7enuDfa2AQAAAAAAAAC2+n/iABAGRzbm276JDuFN DXYa9i4AAAAAAAAAAAAAAAAAAAAAAAAAAOC78CYAe2ePGzUQBeC33kiRSJGCCiWhoISGlo6aLpyC a8AFInELJOqcgQNAQckBkGJFirSsHDNvZp732XKyWfBiW3yfNRp7PH7z/BetHGm+g+1dAAbBzw/1 TrYILS4uPsnJybOW0GJT6ii18GKLqlKxRR3FFqvVbZRb3NxUoSS5xfX1WspyLVdX67DvV5ZWpGLr 7fouoYWut+cHSkILm/unn8NDCbkkocXHy/fy5PXzZl9XCmHiCEWFFrZEsUSdahNPqIhChRQmqNBt lVeYrKKRWWhb3vZCC+2vtckx4hLWTWhh4zVZ1DmvLLjongP8p4x9+xFazCP2v2BqsoA5xNpH3CmI I/YVcyoTOw8Vb+zjh4w1lUnA53AecxVMILSY35i79JtSHggtxhkLocXfMcXfTlP6bTlknH3HBADo 4L+79okqbHIUnbys7xvtLnKLRV40ThPPOy0WtSVlB6Ry199DG9r3rx+wz2/fF7+L9Xsssj4P9Ztw +HeRR59FfpYr+fA1fZ8/PzuTt6enUXRhs/THYcK1jGmFc6/yuh/e+mlRYUG6RpttlUv8ab3Q/4Fk WUUcz7UXrr0RXOScCsvbCS/isfk84jH2jOQ2fy7iJtfpToDXvR1zou9xknw9TRCi122p9yBst+pQ VHxSFYUcqKAirC/D+jL3t+L7xz6SnwtpvxpPj47kxfGxfCvLbWm/CuWLpNta5BAxrGvz5VY2j8NS NtIJa/ePS3PLO+l1PSci9795fe27vKUAAAAAAAAAAAAAMBwvx05gQH6MnQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAPIzfArB3BjsJw2AA/hkYUQ4kcvJojB496RN59G28+RS+gvHmzbsXE85eCETDGHOt /WcZlWEENvD7SNOOtf/fdSyQkPRDagGrJLS3Uei967JA3W5PWq2DXGhh0A26TBUSWsTxVMZjI7RI sjKR9/eJDIcTGQxiJ7UYZ8cqtPiq0/RDwkILX2yhMgsjtkjcscosplImtGi3YxmNXmz77vlWjs6P 83M/CS2suMOJI1RoYSQW+jLiCRVaqJhiTmQhXwILvz0jtEhjO9bUKrQwOUxtc6ZJntvOA6EFhKj6 9iO0IPa6clT92d40ddosuK4bDtdlY+dVxat6/CpjIbT4f4KJTefbBblEXXP+JX5dvy/qmh+hxWbG bNO4dcas02/LVcZZd0wAgBIWCS7SgpzgL4IL7WcFF430O5ZWDS92cVv8tPCeb2JYRmhRPLeIUB5/ 7H7WvBAZZUXeRPYeReIHkft+3xYjtbg5O5PLXs9KDPIwTkxg204SkQshPCmCaYcuL3KSCbUS/KoO SCzUaDD1+k69nL69oOFy+3NV2YV/bXrsL5v+EVOUW/hLum1yC0OjeK9UbuHWOXJrHjlpReKkFa1A O6+jSJIkmemvghJdV8132GzKSaezjNTiNCtXWXmSWVGFtkNyC+3jiyxUYlGciu9DSb3jROafwrKn CwAAAAAAAAAAAACqZ5ekFq9VTwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAluNTAPbuWCdhKArA8Elx cdHBmJC4oKvv4Ojg5gM4+hg6OPkYrr6As7uri5svYOKgRIT22t7eQw/XiqgIN+H/DKkt5bbQQozG /kQtsAh6wZzKqXzzTxSXl1eys7M3say6npKNWRSF+OloVJQ3DVrkMhjkPmrR7+c+aKFRi+fnd39r 4hVvLUGLan5oohdDP18vq0MWddBiVM5rzKKaTgta9OX19VF6va6c3ZzLRm+7eU7fBC00HmGDFj49 4eoAhQ9ThChFHLSYiFuE+a+CFnZc3ZZu3wYtnPmKnwNW1CoefoIWaY39X9tIebyUL8ib6mcCQYv0 Hj/PsQharEZgYtH7/ptxU45LLOvzedkBkRTG/Om6P7GofUgtUEHQ4v+l8nNCSq9JLOV9A7Ay9Pey baEKZ+IEf4lb6Lo+biGuGc82LTRwYS+Hby+P/3nAz+vPEruw8/F0Gr1/S2R4XE6Pyoc9iKxfizy9 DOTi/t7ffbK7K4fdrg9d2AqAM0GL3EQinBlelxXONfGIMJ+Z2MFvp+Pt6XxL+MLWCjLd77CORh2y 8Dw0bjF+yW3QI2xn/JJHgYv4cKSs7fQRDVpIHSZxIWRR/ZVnYhpCFZ0sk7VynTx83wnrd6KwRaFx CwnnQdheFs6bKmqxv7k5S9jioLzdSROtqIb5KmihrRM9/Bq4iCMXNnRhEzRxvMIe0mnvsLbls7wb AQAAAAAAAADz1Vv2DszR7bJ3AAAAAAAAAAAAAAAAAAAAAAAwmw8B2LtjnYShKADDpwVjiCwsDMbF GFfj5ugLuPkELkafwofxUTRx9Q0cXFwlkSAKtbfcUw/1qhgqvZr/I01bKOW2QCQO/YlaoC6haxiF 7jv/bkf9/pa0253igkI2ZjFbz8qwhYtZuKiFC1q4mMXz81RGo6kMh6/y9OSCFi8yGIzl8VGDFuN8 7xqzsEGLkZ/boMVYZkGLVx+0eI9aZJnGLCafn4wkkTS9z8cxkJPTIzm8OJaNXrd8vBqH0ICFDVqU YYlsPmbhbhqycGEKG60oQxb5TdfLoIXfXufl/vy8GrTQMYWCFsQsEMVHYNVj+K9Bi99E0CKui+b/ plgvXhxD0KJuTV9oOqbPdCzvzV84jhgDE00ELZqOCzRxLLFvt+xz6tpnDEGLGLZd9rmrCFT81Cr/ VjQRtIjxt1MdYvq9AQCRWyRuUTy+ZOBCtysCF4n537bOErPv6mXys8p9tsSwSNCi+thXQq9jn7ue L+6JDPNJHkTWrkRerkUu7+6KabPTkbPdXdnv9aRtYw8+VFAs+0hEGYQwkQS3HDq81EcmtFLwo3kg YqGFg6nZNhTaSHTsbmxmrBq7sMem6/a0aeCiGrewpzT2uIWTVN8bjVv485r6c5z6aMVEwxWBZXuf hjB0XUMkeh4n/jXWWy3Z6XYXiVps59NBPt3IfKhCl0NxC93Ghiw0YmGnav8kM+sT+fit++7bBAAA AAAAAABo1n7TA6jRbdMDAAAAAAAAAAAAAAAAAAAAAAAs5k0A9s4eJ3IYCsBvgrSDRLkFPSUFEg0X gINQcoM9wLYrUewlKLgFR4CCknoACQkWdn5MsJ0482Q8MBLJxMD3RU/POPFzZghNjPwN9MZG8HVI bTLU9ZQL+gbq3JGNv28VOT4+ke3tPVlbWw/7JdVCC1EyCyeyKGUyCSIL40UWDw8zub+fNhKL29ux 3NyMZTT6b88/2RpViOh2EFqMFwgtqlzt6WNqoUWQWqQpisLe34Vv//p9KDtHB/JjY9icj+UQ4Qjy iEZmUUsm3OEkFj67o6yikVWIklnUEou47cfIfJwWWphwREILL7UoS0FoAUn6fgwQWuRf/7NuUpzr Bro5/54QWnRfo61afY9vs1bf49uqtYrPkaNgImcJRJ/z5y6g6Pu77vI+kF+sfq5ViU9yHvORcR8d 21W9XGp0UavLmgAALfOWqEKvG+jrlpVbaOL3xWGtKRZeqAGv++N2mWgvc26ZnJrT8U+kuBQZnoo8 Pc67D7e2ZH9zU34O5+/2tasjfJeD6Oeibut+3Ve0kaOaqevCNRL1pe5Vfw6R+DlJ96fIUXDRPAa1 1MLbH5xc3AvGRczzs5dPTG3MbNvlqcs2JjbGLhvjs25PogjXm3q8y6ae083xaMedXV/L+d3de7d8 ZeOPVAtTLtwilZGwaLU4wuLVLMp6USvOOkqVQ1tUn8jrv8RFX3fnsLYNAAAAAAAAANDL/4kDQF58 pRelu4LYAj45rF0AAAAAAAAAAAAAAAAAAAAAAAAAAMB34UUA9s4mJ24YCsBvfuiisxiN1G0rkDgA hQ2X4BJseoZeomfotqforuIUXKALpNlQMUyCn+OXcdygGZiEeND3IcuOYz87drIZJH/ToScA74Ln hBYp19sCzeefZDrdCC00N6GFSS1MbPH4WMpqVXi5hYotYrnFcqlyi5Xc3T24ukpYsZFX/PNpI7Jo E1qsXLl5HlAltLDzfdo5Ohq7eVRCix+/vsvnq/PG/W1CC5VLeKFFWasmagFFKqZQoYWXV7i/uhxd m/DCco1j/TVePIaVvcgiiDVMaFFEz4vQAjxDvwYILfKPP/Q78lpyPUA3533KVWjRBTmtTxexhu7f JTk9C0KL18V66/EOQWixK7mLKhBaHGbbPvp3Hfu99dmn3759+4qXS4w+YvUZEwCgB+w33DZRReMw lWfOO9tVcGHtNNcx9QA1P7b9tj+KxiqlaYQokzor2z1J7smWe7uSjqnMRIoLkfszV/4r8uG3yMON yM/bW5++zGby7fRUvi4WjdP8R24tbUr+8LhwLVF5HMrp42muUoVaTiHystz19aIKy6X6r8U4yuPl isf3ooswdjzXhqjD6vyebvqX9oxR23R5JVrinBilexHWr5aNhLXUfOLytUuaT1vKcZ2uZ9y+CHFs 3dZhjI+TiZy4d2kHqcWxS5cu/ZFquyYhlJVti+NkbQppbnWZpMZrENXp9Vr+/8ravlKRl395AAAA AAAAAAAAANAtx0NPoGMQWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcCE8CsHf2qm1DUQA+VX4oXrwm wdBi6JQpc5Zs2bpny5C3yNQnMPQpMnXsM3T1UOjcJ0hIjIkGOTq690hXF8k1sRUp5fuEOLryuT/S lcDYcD+kFtAltkCOcpPvZ+uSZ7M7mUy+lCILXSApy1zUvRJaOKlFmmby/Kwyi6wQWiwWTmjx+OiE Fvf3aR4rcYWIyiyWRXTHodgiFFqkXmARCy10b1+r5/DwgyyXTmjx/ec3Obk4rQks4hgKLWwrxBIr F008oSIKFVKYoELLKq8wWUUps9BzvhwKLTRfo8kxii0/NqGF9VeOYuUkFia4MBBaQEHfj0Hf/b8l CC3etp+hLqD73udpE4a44PD/tihz3/V32d6QrmXo1/GeBRN9z1MfQouh9tlF3mvrILToJncX9Yf4 vXXIdbapt23drtobShtdtNVlmwAAHRP+nrtOcFHKKKQSVLTVaSPMtfaKtnwfpeAiXC6/SW4hwedx /iayi7Acx5C4Ty2rFuBIJL3K41eR5I/Ixx8if58WcjufF2nX06lcHh/L+OCgWfagcoNAEtEklYhl FiZB2DbWhBkiNeFFkzMksXH7HJM+JP46QnGH+HP1e1g9PzHxdPRJ0+MhJrQQJx5ZeZGF3rda9KKK vSSRff2Pyh/v5cel4CIvZ1lW5hc54ufZ95f45+LTaCSn47H8fnj417DP8/2XVNIKbaZNaGEuE5NT mOAillyEootQMRPLK+I3o+kNarq1becAAAAAAAAAAAAAYPd87nsAO2Te9wAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAYHNeBGDvjnkSBsIADH8UjSSEQIyjCyEOJm4Orv4ZF3+Ns5P/xNFFE1cXJmdGiCCt 3HEfuZaCRSt3Me9jmhZSufagCWHoS9QCv1V2T6Ky526/e6Fu90SS5FDvhbRam7CFiVmkqUYtUpnN MplO5zZsMZl8ynhsghYzF7SY2qDFaKTBimXMQoMWJmahoYtlyKIsaGG2lyGLKkGLVstENd7s9v3L nRyfn24NWthgRJatwhEatDARC/0z4QkNWmiYYi1kIcuAhb+dC1pkM/u/Zq1BCzOGrv2YhgY27JwT tECZ0B+DEOOHOucYbwwc8nX/epxYb6Ab+/sU282L63rNWM/rvwg5N7FcnzEFLWIMTIQ+9ljjErGH KmL57kLQIv6gxT6CGfuMU/xETEGLOsT23SnG75cAEIFtoQoNT7gdSlUNXOh+GsdYBTP0N/+GN5Zf WtDHWeFxscSwS+yiquKYRlskvRQZLxZ5Fzl6FPl4FnkYDu1y1unIzWAgF71ePlzhQgZ220UiNKIg XkTBbBdPryx4sdNaIxYbIheJ5KfLH9+GLNzY/rGuYhfeuWncYi3o4e1bnF7xpjikRnHuNW7h5itx c5e4yMXcRS0ONmzrYksS3vMaGtGP9NyNcdRsSr/drhK16C+Wq8XyJPlQhW6XxS10Hz9koRELf8m9 7d5z5vFc1q+qsqtSZPcrDQAAAAAAAABQn+vQB1Cj19AHAAAAAAAAAAAAAAAAAAAAAACo7ksA9s4g pWEgCqCfKHRRkKILFxWFggsXBS/gyhu4F1x6AHHhmVx5C3eCG8GNeIEKKlIwrZlkfvo7NK1i24z2 vTJM0kzmTyaTErr4D6kFLAqbjuo8K91ZJ7Tb++W2S4Tkcmk5kYUWFVo4kYWWj480F1q8v3+WQote rxBapKkKLYpSSCz6gdCiHwgtPrO6KCOZhcsBNE1o8ZbFf5aDgz25uLmSjfZmpdBCZREqtNB9K7TI 1RPDQkCRiym8lCKXVxiJxZjcwu9XCS1svzaWxlahxdB8yntBbiJw1L0MVklosWhiFyUsO06sCXRj v0+xJS9eZJ8/JbY1Wvf58+wrliTgqyTmWLaU4S8ILebdV8wxF30NdY7jvwotfktsgorYhRbL/p2J 8d0phncvS4xzBAAQGfa/3mmCi1JGISNBRdU5Vdi22l/el49RCi5s+nxNoW9T54s57hgEbe2xSbIL ux/WljCmHt8R6Z9m9YlI8iDSuBZ5fH2Vy7six9JZpyPH29uy1WiMDX1oJBCpkUSEw7BDUfGEShF+ XUsgs5ggvAjjD43koZQ++Ouw4g7x341NnVk/IeHtWCaTloOYa8sFFF5k4eZsrFZ5RZLIetYm9dtr 2bYKLtaz/cFgULbP24iXlPh4iV8Hu82mdFstuX95mTXso6zcykha4bqpElokMnoyrOAilFxY0UXp IjFTZPtRqp6YSVNb9R0AAAAAAAAAAAAAzJfDugcwR57qHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA fJ8vAdg7e5yGYTCAfv0RSO1STkAPwMbCCeAMCAkhcRauUXEPGJiYOUFXWFi6tKVKSuP6C46bQvob p7wXWXZqx5/tJFUmP6QWsAl5ew/l/Xb/V0e93rM0m0dGXmGED7HY3BVaTGUyiY3YYjyOjNBiOEyE FpEMBhOT5kKLLxmNxo7MQoUWP+dZscVcajEXWiRyi8gRWkTLJ59sVtT8mMX/lJu7K7l8uJbWSTut LyK00CORTLgyi+RQkYUvq0hFFp7gwrSxEgzN0/5srkILP76RiHhCC2QWkFL2o/DfhBa7jF32vdyU 0GQBVehrF/0estAitI2dyx5PSM91KJuAV2EeVRVMVEVose+5hBxzlXYhjeOQhRb7/K8Mrf0+r9nk unUJ8dsppG/Lbfaz6z4BAALiN1GFiidsg1yKCi60ncoxUmGGOi1qTizXtKDnU++87pTFq9PzZXVF 8WMmtEXic5Fhsk3Uu8jxk8j4TeSx3zfprNOR227X5FO3Gys2MOVE9uCIFMSp86ev5dhKJtRqsFKu EoscmcWC8MKLb5ZZYztjVdmFOHOrWeHFgtDDaesvrzhLvE/0HqRzVbmFXZ+6Xau6lVxEVmrRXFL2 k/6uYhFdl8jGaDUactpqFZFadGfpYpZeJSuq0HKe3ELbuCILlVi4KXObJfvEiyy+Rf4bse6bBQAA AAAAAAAAAADboVv2ALbIS9kDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDifAvA3tnjNAyDAfQjRRSp SyWGDiCGSixICGY2xEX4EVdg4QSchmswdqA7R8gQRKlKSpzGyVcrKVXJH/BeZdmO7c+Om6pVBz+k FlAF+tipuyidfTdgf/8ollcY7HlZRmyxLLUIZTo1QotQJhMrtJhJECyEFr4/jaUWQeAKLEx6l4Xc okhoYWQWszhlQouwcL2dzla0lnG0JpGHx1s5vrmQnV43bXflEPYVzhdii1RmkUgmrHjC1I2Mwggt YqmFElmYshVa6LKt2/4mjs11XIQWsBFNPwoILYhd1RxNP9t106bDgtt64HBbDnYuK17T48uMhdDi /wkm6p7vL8gl2jrnT+K39fuirfMjtKhnzG8aV2XMNv22LDNO1TEBAFqK/i94leAilVFIJqgoGlOE 7mvjxbGSOVLBhT5O3x6p7x67Lzltq4QWuk3X3VzjzmnqRhtwIPJxHeVvUfNYZPdJ5MX35X40irtd DYdyORjIXrebL3sw8gMliXCXoZfi6bFKlrBxLo7MIkd44c4/V9KHVAKR3IcWd0hybXkPs+fHpU65 Rd7bL+peYgFFIrIwe7SUW2mF58l21OczKXeicp7gIrTXRBLJuaRzmPJhrycn/f46YovzKD1LJq0w YYqEFp5kMgstuHAlF1p0kbpH1BbpOJaiT0je1hZdAwAAAAAAAAAAAIDyOG16ASXy2vQCAAAAAAAA AAAAAAAAAAAAAAAAAAAAAGB9vgRg72xSGoihAPzsn1Ch0KUr0Z0bUQSv4CU8gTfwEh5B3HqGXsKF 6+LOXaFQkNJqncnkpc9ptD/YTsDvKyGZTOblzU+GruZDagGbEvvOUKzvdlmgh4eeNBotJ69wgoWZ OImFCi2m05lMJoXQIq9VaDEaTZ3MYjjMZRZjJ7QYDMZBZlEILN5LcotCZFHUE9lEaNFs1rIcXlz7 /ulODq/PpNGaL6VlQotcLuGEFrOgmggCCiezkEWhRf4LbbPtiszrPI4en8ezc2jbiSy8WEOFFp/m fBFaQOA/PgoILdKKva05Uo6X8gd5U30nILRI7/i/jIXQ4n8IJnad+yZxU5ZLVPV+rlogkkLMdceu w65ySE1QgdBi+6TyPyGla1Im5dwAALbMb6IKFU/4AVFWFVzouCDHKAkogtxC+6xGOya4iAksytvl feXP9i/DzqmxDrLmlcj7ZdZ+E9nviYyfRR77fVcuul25OT6W004nHGIlEK6dyx6MWEHMPjutlVF8 esmEbq9Vq8QiIrNYEF7I98tfcx1+bpOryi7EnJvKLRaEHmasvbTKTgQXPvdwbiq38Nej5uUWH1p7 WUXjh7YWZ5Iw/fY+5XN9+DXUrtflqN1eRWpxkpXsCQtiCxVVaDsmt9AxVmShKdjy7bZKfFWVV9Be ZCz/nAAAAAAAAAAAAAB2y3nVCfwxr1UnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACr8yUAe2eP2zYM BeBnJc7iIZkyGEWWIlOTIxTtVbolx+gVeoteIHvWLp1yCg8OEDiGUlsqKevRT4Ks1LFiscb3CQIp iaT5I0GCh/chtYCuseGlbt1+9VqF8fhjEFpkmZh8XsgtFossiC3SdFlILZ6flzKbLeTp6Y88Pr4U QovJZO7qzGUwUIGFCi18mha7SGqEFi9bCy1OTlxr85XQ4sfddxl//VQRWNRTK7TQrRBL5KtUxRNe ROGFFCqo8MdeXqGyiiCz8OfKYyu08OV9qnKMYnN5FVro74Ve5KsxquBCQWgBgRhuhX334VCFFu8J Qou4gua/J7EGL45BaNE1fQeajumejmVt/odxxCiY6ENo0bdcoI+xxF5u1zpdtRmD0CKGsrvW3Yeg Ylv2+a7oQ2gR47dTF8T0vQEAAI3Y/4nbBBc+YL8VYbRJMTYxKDdfN7RnnRYquLDh9TXEfj0MvzRc 2yS0sKH863UHsvkd0xTO32sEPoik31w6c5cf3KmfIr+n02L33FxeypfzczkdDivdy40EYmkkEXkt tV1KbN1SnpDskkpVZqGCi7bfz40EIkghynFYcYeU56pzuL5/mqbXLkeX1JdV+6t99XORlyILP/5K qvKKJJFjV2ZZ5o9cXgUXx+44y7JQvigjq7nS+dT5vhiN5Prs7F/EFp/d/kvW0grfzCahRSLrpbOC i7rkwoougmvETJFtR2l7MprOtz1FAAAAAAAAAAAAAPB2Dklqcd93BwAAAAAAAAAAAAAAAAAAAAAA AAAAAABgO/4KwN7Z4yQQRAH4oSQSiYV2dkKivTHR69h4ISttuAgHsKXnAFZQEAQBzbizOw+GZUXA dXcw30deZnZ582aGn4RQzIfUAnYh6yyhrHsPPxVqtdpSrdbiM4ySMHG7EFokMZ0mQovx2AotPmQ4 nMlgkMgs+v2J9HqTKM9KK96jsaOoxiiWW9jrRGxhQ8UWU9lFaFGrzeTtrRv3nzuPcnZ1vlZoEQsj jJmLI1RoYSUW+rDiCSukmJnZvF0RWUgisEj3bU48zhurQgs7h7a+TEMFGyIILSBwEFqEX/+/HVK8 C/twGG9I0ocQD2UOpUZetcoen2etssfnRRH7CFEwEbIEosz5QxdQlP1aF7GOPGvuW+5vKUJoUdR+ ilzbfxNahFLjL2r9ZU0AgD1nnahC5RYuIZNNBReaFwsuKmbxf7U2FW8u37Sg12nBRVo8sU5o4T+X rrHt79N61L0V+biJ+q8iR22RSUfkqduN4/r0VO6bTbk8OZkPWZJAOCmEeKIF7S/le1vJEl5s1Tq5 xUqbMUfFiR98M4I4wYW/VpVdSGpv/vqNJ75YJ7jIW24xn8+YxUdJ5RZu3wdObvGprZNaVL/pp0Pv q/xDDRKf7jtzfHgojXp9E6lFI4q7KF5kWVSh/Sy5heb4Igtdgh9Lb6Nkf4tMql/JyOUXFAAAAAAA AAAAAEBxXJS9gBzplL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAANiOLwHYO5uUhoEoAD9bQXChIi4U BRfSpTdw4c5zuPMmoqfwCN5CXIh4Ar1BLaKttk2cTGbSl5hWbVMzle8L6eRv3sy8DBRamA+pBVSJ XkbqzOyHkx4+P7+SnZ2DTGKRliLDYWTPB4NI+v3ICi0+PobS66VCi9fXgby89KXT6Uu7nQot3t5S eUUcdyUVWHSt3CIpizKL6YQWXdPuo2xtrcvFzaWs7W5m94pCCy+L8EILf66FFlY9EacCikRSoYUW RXFFz4xLn3vpha2nhBY6rm7Lt+2FFrHaimMAsNQ9HRBahB+/7jkyLaEuoBvyewpVaFEFIeWnilh1 16+SkMZS52LkiyyY+Ov2FkFo8VNCF1UsotCizpihPDuP+lXH/m91Zqk3a915xQslxjxizTMmAMA/ Qv+GPElwYaUHSoQxSYoxjiW3JXWzeNpp4QUXerl9v+R+2bL7+t4koUXxnr//3XdE2fL+iVZgT+T9 1JTP5vTBlNci9+223N/d2UfOWi052d6WlWZz1HWfR/uRShX0EHSZk1k4eYKXKEROTDF1KQWZhUuR Fl5o0cVSHGdt5yQRbhw5cYe7ls/haP6UpTfLyYwUX6fvn+9bw+Ww6XKQK720otGQZfPM0B03zXGZ 4CLydUTc/0WStZEc76+uyuHGxk/EFkdmv5Wv4ooyoUVDRjILLbgoSi606CJzi6gU6TgePQW/S+24 awAAAAAAAAAAAAAwG8d1d6BCnuruAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8jk8B2DtjnYSBMAD/ GBJNMEYZWFxgdDcxcfERdPUF2Nx9FN/FB3B1Z3FzI4REE5SK3HF/vV4LFktpMd9HLn8p//1319KE MNyH1ALWJWvfoKxz/d8KdTqn0mwe2M18VGyhbTqdSRTNnNTCCC2+5P09skKL8fhTRqMPK7QYDifz 95OE0MJE835xrPFHapEUWphohBbZ++rYjZcaL/Nx36R/dyOX99fSOjmMPw/lEFlCC30ZyYQvszAv FVmEsgojsLAtEFzYHCfB0BjXc1GFFuH49joHQgtkFpCi6q9E1eNvE4QW2x2nrhvo7vp9ykMdNxz+ b5syV91/k/XqtJa6r2OXBRNV36cqhBZ1HbOMvL/2QWhRTu4m+tfxd2ud+xTpV7RvWfXqUqOMWmXW BAD4x6wSVajcwiVkkldwoXlWcNHw/ovX0PDG8k0PXk5QMPnZKqFFKMkIrRJ50LxjkehKFmqCV5H9 R5HJs8jDYGDbebstt92unB0dxV0SEggnhRBPvKDHiXxvKSkZhXc+V1R5RRiXXJLQlCCa781VZRcS rM2f/8wTX4SCi5SMoiA6t3gNKrdw69xzcotIo5NVNJcch82c3/NqqkEics+IkZn0Wq08UovevF3M 25OkBRbL5BYqs/BFFjoFvyVum3cuvkySfipCbYxI/qcCAAAAAAAAAAAAAIrRrXoCG+S56gkAAAAA AAAAAAAAAAAAAAAAAAAAAAAAwHp8C8DeGeM0DEMB9DcgkGDpxAJSN5jgDAwcBDY2Rg7A0GtwAu6B xILEMaACCalKaQP5jn/qlBAFVIiB9yLXjpPa33YqRR38kFrAsgi3izrN037TzcPhpWxv7xbyh0x8 XiSVWajUYjLJXErTTMbjqRNaPD9P5elp4qQWDw+p3N+nXlwxdqkQWpjcQkUWet1kFppPpa3QIkkS eXm5c+Xzi2M5OD2Stc318vqiHMKO7LUQWziRhczeCS20TmUUKrRwUotAZKFlE1qEZTu3+7Udy8N2 TWihh8WA0AJa0/Uj0UX/XY05xo2Bu2z3u/uJdQPd2Ncpts2Ll9VmrOP6K3Q5N7H8PmMSWsQomOg6 9ljlErGLKmJ5d0FoEb/Q4ieEGT8pp/gKMQktlkFs704xvl8CAPxjwv+YmwQXPSdlmIswmqQYH9Hz h363bC90WpjgItx+f1FMIUE5vFYntFAyqd+yv43Yom67f9UM7IikJ3n+mJ/eisyuRG5GI5eUs709 OdzacsKDMnSbR/dRSBbqPBthnZKYTMHnmRdNfDn3UxWKMzKRivCijEXXSPsNJBGlNMKPoyLu8HXV OZw/P3XTGy7HZ1hcPovHYkl87Ct+zJXcpBVJIqv5PTNfXsnLdYKLzCe3lk6GLmUfWh5sbMh+v99G bKFKlGtpJ7SwZepJVXCxKLkIRRelSySYorAdo0ntUlf/GQ0MAAAAAAAAAAAAADTTz9Og6yCWCFIL AAAAAAAAAAAAAAAAAAAAAAAAAAAAgF/GmwDs3UFOwkAUgOFHAwsTTAwLNsYFie6NMXHpCTyCW+/g JUw8hkfwBB7BsNRDIElTkZZ57ZtSoCjQQf6PTIqltEMBw6o/UQuso+raQFXrHlbtqN8/lShqm6CF eFGLONagRSKjkQYt4oVBiyJmkQ5dXw5axNmYxSyWBy06nUjG41nQ4unlUc7urrzHVwUtbMxCbxqg yGIWMh+0SG/5ffN3NqRYps/T/aRLewy9n4UsXNRCgxbf2bWHivkDnqY/EocUtNi20EMJuz5OqBfQ Df19Cu3ixdvc57pC+4w2/fxN7iuUi4AfUphj11GGfQhabHpfIR9z26+hyXn816DFX4UWqAg9aLHr /zMh/nYK4beXFeI5AgDkloUqNG7hNqhUN3Bht7OxjHzRMseypQezTWmH/mM2aFEVu7CRjHJVog7d 7kQkuZVZquBT5OhV5Otd5Hk4zMZ1ryf3g4FcHB/nT/EiEC6UkIYfIncuxD3mbS9+hMKua5n1tZYa rygvF5yScjlBdHszV41dSOm12flPTPhiWeBi3bhFvr/JpJizxi3c64pc3CLRpYtVtBfcL490fWTC IlqQSNx3Io2XnHe7daIWg+m4mY43mQ9YLIpbaMzChix0CnZ4b5NZl58mmf8WlDMxIvW/BQAAAAAA AACA37lsegIb9CFZAhwAAAAAAAAAAAAAAAAAAAAAsE9+BGDvbHISiKEA/ABD4o4NcYEbN8rGeACN 53HvFUy4gAfwBF7AE5i44QaeANxBgAGnM32l0/CPwwz4faTpAO3ra6eBBJJ+SC3gL/CPhXqKy+2q xp3Om7Ra16LnWBmhRRRNE6HFZDIXWoxGkQwGqdQiFVqMpd9PhRamjMeh0GKYyCxSocUwEFtsLrSo 1+Oog1Ro8frxIhf3N+49X2ShtcoijNBCH4lYYpbWKp4wIgsjtnCCikBW4WQWcdHnfhvT39QmhrlW UYYKLXQ8l8XM5mUFF+EcABxFb4n/JrTIc+yi7+W+lE0WcAyx8oh7ykKLsh3sXHQ+ZdrXZTkE/Bjm cayCiWMRWhx6LmUec5t2Zcqj6O+gPHM95Gdl2dofss8+/Xal6H2bR/+yxsk7JgAAZH5/XiW48IUU pt0qKcYitJ32dfF8p4UKLvzj+EMxhXjX/nvLhBYiux/hv+j4f6MduBIZmH9WfuKnXZHoXeSr10uK 4bndlodmMxEguNR1HeMyDSQRs6D2U3dyhZmumY1hhRNb13apQnGGeMILl4sZz4zrSSOcRCKZTCUj 7tD8sms43z+LllfXZB2hh0TH17GrNteanWOmVmlFtSpncZvIXtfi60WCi6m+Jun+d0IRG/Py/Fzu Gg3prhdbPMblUzYTWuhtqUhWcBFKLnzRhXOHeEvkx1H8LbZuaZe9BgAAAAAAAAAAAADbc0pSi++i EwAAAAAAAAAAAAAAAAAAAAAAAAAAAACA7fkVgL2zyUkYiALww7jAyEIXXbHAuPMIRhPP4QE8jolr D+LajUv3uPEEJBACJkBL7d8bpqVAiUAn+H1k8qbtzJthGAKr+ZBaQFXKzgEqu/e0KZHntaXROE3O HgqCMJFZqNDC9/NCi7iMRr4MhzMZDKbS70+k15vIeKwCi1hmsRBaxDGtxyKLaRRTmUUssqgitGg2 gyj3V1J//XyRy5u2ebZKaJEeQjQ314liIgyMbEIlFLNwZuKSyEJSgUWxHrdJ+ll9/ewVj6HRlmkk 80BoAVWpe0sgtCD3vsaoe28fGpcOC3b1wGFXDnbeVb66++8yF0KL/yeYOPR4xyCXcHXMv+Sv+/ei 7vEPmds1QcWxCi1cEmi48j/BtTz7zgkAAEusE1Wo3CJrUMq2goukbskyTGhYY9mmB6tNIWH+2Tqh RZkdYd2R/2VouwuR4CGK91H3b5GzN5GfKD53u0m58zx57HTkutUyXWwJRJkUQmUXufaysCDMLfmE EV/IwnSwMWr/YpT8Utt126Rg5BcFMUfxWjKJhVlafc/atmQ5RUTyT8rRscwcVW6RvY+TTG4RaMxk FSqw0FiUWWjR+6EKRbI5Btl3IJaVdM7Pq0gtOlG5jcqHLAssVsktVGZhiyx0CnbJfSzWPXspi7u+ qIURqb7rAQAAAAAAAAAAAGB7ruqewA55r3sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAALA9vwKwd/c6 CUNhAIY/wIlFEsPEwEQig8YL8H4cHZi8KQfvwTgbb8CdRSAQ0EjtafsdPtoqP/Jzou9jSIu0p4dC CNGkL1EL/Ja9/NNNfLtctUOr1UmCFi5kkQQh4qWLW7ioRRq0mMt0mgYtRqMPGQ7fl4IWg8EsC1pM xAUtbNwiXXdhi5kPW7ioRRq3WBW0mMh4/Crdblt6D3dy2jrzj+WDFhqL0KCF3rdBiyQ9EaUBChep sEGLfLhiGs85Wc9iF3ZpgxZuXF3aY9k5uKBFZH7yzwHw/uNbgqBFWGPv6xghjxfyBXlD/UwgaBHe /rsci6DF/whMHHru24wbclziWJ/Pxw6IhDDmpttu4lBzCC1QQdBi/0L5nhDSOckLeW4A8EfZv03/ FLiwQQq33U9RjDK6ne7rx/ONi6g8SqGX6C+7TP+6QYttL+lflgOoxasdkcltvP4W330W+bwXeez3 k5vTOz+X62YzCSL4qet5lGIUIsot7fpcYwuRnrPi4y48sfZSsmCGLAIYycxM8MKPr7EHE5HwUYnk yRRDHYVTbN4/ZadXz8kqejw9VjWbWy17TktLjVZUq1LLttH1k0oxcDHXfUSy/yuJP4Zbb9frctFo yMvqsIWLWjzJekELfRkqshy4yEcubOjCt0Jk8TLZceyp/S7dUvb7TTIvAAAAAAAAAIByV8eewA69 HnsCAAAAAAAAAAAAAAAAAAAAAIDNfQnA3rnrJBBEAfQCndjYUGJvYuEXaG9rY2flb/ghdn6CsfMH rIy1hbGBEBISE+JjZR/OLDswjMuKurAjnkNu7s4wc5lNNoHskD0187AgWC/yHt7zm3IFfbbU4lbF blGh8/Nrabd3UomFkVnoGI1smUUow2E4kVkMBoH0+2/S671Kt/ui5mmZxbMkyTREXiyxRZCJLcZS iyTRMgsjtIg/n4hafaPRlSB4kpPTQzk4O5Lm1ubkfVsOYcsibKGFeWnJhC2z0C8jsnBlFVpikYYj uEjHZBIMkyf1smyEFu7n6zW5QgtkFpCLD5fFqtewrkKLZdZHaOHXQ/OXWdfXhxf7cm4+XQdVzy+z VtXzy6qzivk+CiaqEFos68H2Pp+L7+N+OqfK9a7z2N/O9VFQsUrJRBVCC347rbbWMmsCAMC3+UpU Ye9x2GMXFVwY3PvkZk9s5r65+92QOH3ucVIwrui9olx0rInUuT+IbFyJPD9Ou/dbLTne3pZ2szkz fGIrqNXmtuvZcT3rN315OZVeLDBu0ezWs/vEjCtYu902fTO5YI9snl0hTsZXhZFO6HaURRjHaX5X OczySIXOQRSNs3P87oQer+uMrLo60s9VcT8cymWnM3fdFhcqbmS88WVCm92jLIdORDnteRFbYdqJ TI3xpp0XktO2Ke1XGHvbAAAAAAAAAACl/08cAP4G63RzdE/FXdWLACgL9i4AAAAAAAAAAAAAAAAA AAAAAAAAAOC/8CEAe2es00YQhOE5r0UkKhoqiqRBIgVvQMG7pEjaKH1KurwD78AT0EZ0ES+BEDIS EBxsX3bOO3dj45MRnLk76fus0ezezs6O986Nbe0/bLsA6DVe0OKbrBG0ODk5lb29/ULMQv+zrV5t MpmVohbj8VQeHtQmcnc3kdvbJ7m5+RdtLNfXjzFexSr+FgIWJmIh8phELMaFoIX6+bk9T0nQwp/F s0gIWVz3MtYg8vPXV/n85ViGW9XHok7QYpbP5l6FLGT6TNBCr6kYhQpaFKIWTshC2yZo4dvWt3jN Y97nNUELfVkNCFpA70DQovv5+yho0TRdP4y3qbxdEQbYRL6u5GgqV9vzm8zV9vymQNCiW7naXr/r AhRt7/V71NFkzr7FvpUuClq8FgQt+p9jE7k2mRMAAF6F/+56lVCFHfyiB7NZrMb59kuwOJtb5vOa FlluRdmkSvkgl+pXkHxpTJbGZM3YS/FrWj9Ety9y/z22R7F7ITI9Ezm/uipM+XFwIEe7u/IhhKp0 20dJh9zFvn8L3vu2Ci0UIhPmZf4Ly6Bmrp+nghTPfJq7nEPSeJau56lOvf9ZWttqz1LtUtxDKftZ 6i/uYfX8rNreVZSRbq1BqiWk97Dgo6kPg4GEFGPtYWxPbTzZzOZIJZxha2j74/a2HO7syJ/RqKbC kuNov9OWmQW3vctWLpXi7PGw65kb90+ffyx8Hr+VdRohq67XxQIAAAAAAAAAAADAej61XUDDIGgB AAAAAAAAAAAAAAAAAAAAAAAAAAAA0EP+C8De3eMkEIQBGP4gUqCNBQ0UqIewMbEzsbbwDN7AU+gx PIB38AImFtTa0RAKw49Z4s443zI7LIK4uIN5HzMZfnZnd3HrfYlaYJWiJ0MVfXazaqFWqyO12p7M ZiJJMnNBi6+hQYvRyAwTtPiQ4XAqg8HEBi36/XH6/WLQwsQs8kGLaTpr0MLMJmZhwhaLQYtGoy7j 8Yt9ffdwK0dXp7nvVwUt/JiF/mmAwsYsZB60sMEKE7WQSRa3sMO9t0Pms9lP1zGzfwx9bUMWLmqh QYuZd50ELbBU1bcGQYv416/6HtlUrA/Qjfn/FGvQogwx/T5lrFX1/mWK6VqqfBj5Lgcm/vp4uxC0 WFfsoYpdDFpUuWYs225j/7LX/m/7/Ga/3+67rfViWWMba21zTQBAKb4LVWjcwm1Q6KeBC/vai2Vk U807VlHAYnHB3P5rxy7896se8x9GNYxDkeQinc/Tr15F9h9F3t9E7ns9Oy7bbbnudqXTbGa7+BGI oiiEjUt4h9DwRBajWBarCOaiy6q7Y9VdLCI3e9v7wYuwtJDFL4IwR/heXMQiOwe9Zt12TbmQhkY3 XLgi0ciFi1VowELnMGahw3xeD0Ih5jwTd4+bGMnJwcE6UYtuOs7S8SSLAYtlcQuNWfghCz0Ff+R+ dsnfgfrThHd1mH0R+f6uBgAAAAAAAAD83HHVJ1Ci56pPAAAAAAAAAAAAAAAAAAAAAACwmU8B2Dt7 nASCKAA/wWBCRUJhQ2KlNNqT2HgdOwuPIDew9xjG2BuPYUdDQEIICLq4s+ybDMsIBFh2Md+32czA vnnztwWhmA+pBWyKPSMo5Da8L5cFN5tPUqtdeIQWQSS0mEwCK7To97+l15tItzuWTmcs7fZIBoOv WGDhCi2GsdBilBBajGUmsvhbaFEqhRmGM6HF4+uDnF7X7TNXZKGlyiKM0EKvSCwxnZUqnlCRhbl8 sgojshiFY3Y/uzHazsgxTF1FGSq00P7sKKbxuGLBRXIOAAtk/Wpk3f8+QWix337yeoDuoe/TOuTx wOH/dihz1u13mS9Pc8n7PA5ZMJH1PmUhtMhrn2nEbdoGoUU6sbton8ffrXlus027bdumlS8vOdLI lWZOAADYOe7/2ssEF66QwsQtk2L40Dhta/NZx8XUf0y/HuHvO8Z/XaHFpkf+J9UC5vNJWJyLDO7D +qdI8V3k51nkpdWKbiNJuKvXpVGtRnU7dF1HmZdCJKeSrAcqY3CkDGo/WFZOPXkiEUYcEyRixRFe qHUh2iPTryOZsNKJaDKLoo6FJXben1W4uQtx38V4zFoWXGlFoSDFOEbrxx7BRaAyDJm9z2qY0PU4 K5flqlJZR2zRCO83WU9ooct8JPOCi6TkYm7JdSmcrXHz2FV1ni8so+f7VRoXAAAAAAAAAAAAAPBz k/UAdshH1gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgM34FYC9s8dpGAYD6AdiaOkCA0OphICNC7Az wQW4AndhY+YW3IIFiYmFDQ6AQCoqgRBix1/rOmmhpdQWei+y7NQ/n+2kUiY/pBYwjaaTfZp+O/tu oK2tnhTFmpVZmHOD8rywIgsjtMiy3AotBoNKaPHyksnzcyZPT29WaGHySmDxKkZmoUILESOyMEKL zJar3EgtPsqySi3qQotW6136/Xtbvry5kM2D3rBuktCiOlzoc3hvFRNFPpRNqIRChRYm98UVNkkl sAjLpo3t5/X9cJeJobkv07DzKKr56BWuAaBG7FcjRvxYa07xYOCY4/51nFQP0E39OaV2ePGixkx1 Xf+FmHuTyv8zJaFFioKJ2HNPWS4RI2aMNfxmfIQW6QstliHMWKacYh5SElosgtS+nVL8vgQAgChM E1Wo3MI1aGRWwYUtO7mFlV24GMWKF6tJYFEfcNRWgrbT6vz77479D6Uahg2R/KTMj8qqB5H1K5H+ Yy7nd3e2+rjbldOdHdlut4ddfAlEkxTCyiWCZTfKKWbMbV8Xa9XJI8ZyP4aMhBe+dcHOWdt7Yo5Q 1KFr87et0DVr24CxR6ZjqWTDiStylVw4WYUKLDQPZRaazO+rgRjExMrd+2bkI3udzk+kFvtlOizT tdQFFpPkFiqz8EUWOgU/+XX+1jVukdTfyHnVLQAAAAAAAAAAAAAwmd3YE1ggt7EnAAAAAAAAAAAA AAAAAAAAAAAAAAAAAADz8SUAe3eskzAUBWD4CCQkLBLdcGAy0UQTB2ffx1kXH4Dn8B3cTBycHHwM FwejExiM2Hpv6SmHUhAR6VX+zzSttrTXCyFEk/5ELbCI7F5AzqlbDmYd3OlcSqu1mwQt/DIYRG4Z RS36/Q95fR1It+ujFu9J0OLlxQct3uTpqZ8GLEYxCw1axLHf95Zu+5jFMGoRxz5mocu4er0rvd6D 7O+35ezqQjZ3trN9+aCFRiw0aGG/NGiRpCfiYYDCRyps0CIfrui78SbbaezCrm3Qwp9X1zaeodcm aIGFlP3SWKegxW8LPZSw6uuEegPd0J+n0G5e/Jvn/K7QXqNlP36Z5wrlJuDrFOZYdWDiLwQtln2u Mn7nUIIWZY7jvwYtfiq0QEXoQYtVv8+E+NkphM9eVohzBAAonf2b96zAhQYp9LhZUYwiepw+Njtf bMZRdNt+vaV/0W395w1aLJoAyKcG/Pd1t9oV6Z277WeR2p3I4Ebk+vExWXw04XxvT463tpLtbOg6 jzIehcgHLfKhiUjjDCbSYMMTX60nAhnpvqjgmHxUI3mO/HVNdGIjjWNMC3VMTHE8fdL1WhU9lxlj VcdqghW1SiWLXVTddtVt1woCF5HGMETS/z+lc5Kes91oyGGzOU/Y4sQt9zJf0EKndUPGAxf5yIUN XdhXuZ2OyOwTc2zRZBb9/KtsCwAAAAAAAABg0lHZA1ii27IHAAAAAAAAAAAAAAAAAAAAAABYzKcA 7N1NTsJAGIDhD3UlbIwbSIjRxL074wl0YVyYeAqWegYP5CW8AXt/1mxISIBQ60zbKdOxVv7KDPF9 zKRo22mpjS5I+hK1wG/KnvTk/kzfP72/Jmq3zySOD5KgRRSlwwQtJhMdtEijFsOhCVpMZTDQUYux 2mcs85jFuBC0ENFjql6nMQuRmXo9S5bpsE68oce7Os5Iek8Pcvl4K82jVr7ejkPYsQg3aJHEJeKv QsxCf5mQhRur0BGLZDiBi2SbLIJhlvl82dIELdyghj4nN2hBzAKVfN8e/y1oUeexff8u1xVaLKAu BC38zRnag519n09IIYhQHgK+C+9jVwMTuxK0CDUuQdBi88deRihBi23+rQxt+23us85+q/J939ax f6jz1D0nAMCrqlBFbMcJSj7dWDRu4W5r4hZJ7CI7RtzISxfz41U9pn+ZoIU7j11xqPrf5kY1tGOR 2Z1aXqtVHyKHLyKjz0ie+/1k9U2nI/fdrpw0m4Wp44oohI5A2MUDNzSRxymWXOZz6M9ksjDFXtlS isELu8LQSE8+3c4Kc7ihDvPe3MtmX0r78ku2r/k+KURkIY/9kmiFCVm4P7ejFpETAtGzR9kxdGzk vNVaJGpxqsaVGq/yM2DxW9zCxCzskIU5BXvY68oulXsXl2Vd3MsJAAAAAAAAAFjdhe8T2KA33ycA AAAAAAAAAAAAAAAAAAAAAFjNtwDs3b9Kw1AUgPHTaJVOCtJN3ESddHAVfBcHcXJx9gEKPofP4CZO roIP4NahiINIKf0Tc09zmmuoMdZqLvX7Sci1jSehBnTKR9QC3zV55k/iLNl2iw5uta6l2dyaBC0G g3HMwjYXs+h2B/L6Og5avLyMgxadTk96PT9o0dW1H7SIYxeysKBFPw1aDNMtE0WR9PuPur68OpW9 k2NZXslu/c+CFi5e4fYasrCoRTychCfc6y5G4YIWGrXwQhZuPS1oYe/Z8W6O7f25FrRwX3otBC0w q6pvD4IWzP6tc4Q+b95CelhwqA8cDuXBzvOaV/XPz3MWQYv/F5j46/MtQlwi1HP+ZH7Vfy+qPv9f zg4tULGoQYuQAhqh/J8Q2pzfngkACEZR3ELftwBBGqTIKxu4sOM0aCFxNs+aFjVvtv8Yf3vE/7TH /JcNWsyaBMinB9z3q8luW+TtIlk/i9TvRPq3Ijfttm5r9bqc7+zI4caGBhkmY9IIhK69KEQ+aJEP TYws1uBFG/zwRNl9nJs9mvJePqqhvyN33vTc9lqtINRR5iPW60qPjdPr0ECF7S1oEUUap9CARbJe StbLucDF0ItbaGFC4+rZOdx6s9GQ/fV1efg6bHGUbPdSLmhhH2NNPgYu8pELP3Th39X2UftzTFF6 ZdrrX2VaAAAAAAAAAACZg6ovYM6eqr4AAAAAAAAAAAAAAAAAAAAAAMBs3gVg7w5yEgbCAAr/FokL wkZ3kIg3cOsNTFiYeATv4coTeBHjGdx4Ak/gxg0LJCSUNFA70xk7DAUKAToJ7yNNpZTpKA0YTfqI WqBM2RWdyrY9bRqo3b6UND3XUQsVtEiSfJlOZzKZ5MtopIIWiQyHedBiMIhlPI51vKKIWdi4hQ1a qJjF1Kz9oEVxHZxmM5I4zoMWr+/P0r2/XZhf1aCFDUyomw1Q6JhFdlPBCrXWwQoVr/AiFva+XqRY q+fbcdTaPYb9WocsTNTCBi3m+lpBxfyBlU7x9CBoEdbYhzpGyOOFfEHeUN8TCFqE9/x9jkXQ4jQC E8ee+y7jhhyXqOv9ue6ASAhjbrvvNo41h9ACFQQtDi+U3xNC+pn4Qp4bAGCv3L+Pl4UqbNzC7LCk atzC39ePW+hj2cCFG6Uoi1v486kStPAv/+9WHNZ97vlRDeVKJHnM1v3soW+R1pvI708iL1/5/1Ee ul3pdzpy3WotTD1dE4VQsQu3gOCHJlTkQscadlyrY6UmUDE3x7bbI2d75B3f3he7nxPmiJzv4//l Olt9PvhxjMiMEZmAhRut0HELs83fbpe5ecwNf6iZzMx8LhoN6WWvQYWoRS9b7rLlU5YDFqviFjZm 4YYs7BTcxX1MZPlM9s/asoyLyPqzFAAAAAAAAACw2U3dE9ijj7onAAAAAAAAAAAAAAAAAAAAAADY 3Z8A7N09TgJBGIDhDzSSUJmQmFDZSEliYWLhiYwXsKbxBLYewtrEzth7ARtKMQSj/Iozw37LOC66 IrKjeR+ymUGW2eUnkWpfohb4Dr2AjXVstuZnO7daF1KvN5KgxWwbjaYyHL5Kvz+R5+ex9Hojt3W7 Q+l0Bi5q8fg4SAIWfszCzgcyD1oMzTgy4zjY5sGHrS3z7JfZhZjOr89k53AvfcwPWeiosQgbtNCb C0uY+y46sSBo4ccqNGKhgQt78+cawLCjXcvOdV0NWtjjadDC3abJeSWBi/A1AJli+Hqs+xz+a9Di NxG0iOui+b8p1osXxxC0WLWiLzQd03c6ls/mL7yOGAMTRQQtio4LFPFaYt/vp89Z1ZoxBC1i2Pen z11HoOK71vm/ooigRYy/nVYhpt8bAAAk8gYu0iBFIG/gQvezow1ZpGvpUPLW9rMAej/rsv95gxbL JgLCFIG9XzFDQ+Tp1MwfRDZvRMZXIpfttttqlYqcNBpyUKu5QEO6TBJ1cHMvEhEGLcLQhJ6yH3Hw wxO5xoyIRXiMrKiG+8ztcZNjf9g3I3Cx6G3Wc9fjukCFjhq0KJddnMIFLMx8w8w3g8DFxItbuMLE dJoWJsrJmrvVqjS3t+Xu67DFkdluJV/QQk+/JO8DF2Hkwg9d6Fviv7X+Ouqz1ErW37/KsgAAAAAA AAAAZvaLPoEVui/6BAAAAAAAAAAAAAAAAAAAAAAAy3sTgL27x2kdiAIofHEKIqVCCAoiCkpWQEtF hxC7YB2sgJptsAiqJ73iNYgdgJAoQEAce/CMZ5L7hgRQcOwJOl9k2fnxeIxcUcwhaoHYrJWb4s/s YjVnXw20tbUjxvR80KKUPC9lNCrk5aUOWjw95dU2lsfHadDi/v51ErOogxavbrNBi/p45I/tPneb MYXUa+dMgxb9fi7Pz7fu+PLPhWzsDyffzQta1IsGlZP3LjFhiklsIkQoQtDC7nW4IgQtdNwiHNvf uPPUuWP/stcIex3TcPMw9XzCK74HIFkELdIf/7ctUryIVViMN6XoQ4qLMqcyRlNjdX1+k2N1fX5T 2riPFAMTKUcgurx+6gGKrv/WbcyjyTFX7bc/1UbQoq37aXNuvy1okcoYyxhrmWMCAFZO+P/5MuMW 4bcubiFmOp5uWoTAhY5ShGX849CEyMeawndjF/r9V5mAOKphbYqMj6v9UfXVjcjgSuTh7k3O/9XR 8NPdXTkZDmW73/9v6sYHLURFIUIkwsYudBGhNGYaj/DvXbxhwb29llGBizX1eTYjXJH5W83UZ3qu ceBinrj2YK+V+XvNVLTCxS18vKKIPg9b6b/ToQ87ZuGf0fVeT/YGg+9ELfaq7aDaruVjwGJe3CLE LHTIIkxBb/GfMH5y46d0VrZF5POnEgAAAAAAAADwucOuJ9Cgv11PAAAAAAAAAAAAAAAAAAAAAACw uHcB2LtjlYahKADDp7VQKIiFgo461EVBF5dOPo2go2/RJ9HRF3AWHH0GXR0qClra6r03PfG0RA0m NTfyfyXkpk1ubNqpQn6iFshLb1zjnbll77udh8ML2dralek0CVqMx8ny+uqjFhN5eZmEoMVo5IMW 4zRoMZv5gEUStkjiFrrt10nQQmMWn0GLiVum6bnb7Sc3/4MMBvtycnku65sb6WvLQQuNWGjQwj40 aBHSE+9JgMJHKmzQIqQr3t8WxrodHmZtgxZ+Xl3beIaem6AFCqn6K0LQIv75q/6O/FasN9CN+XOK NWhRhpiuTxlzVX18mWJ6L1XejLzOgYm/Pl8dghZ5xR6qqGPQoso5Y9l3FceXPfd/O6bIcUWPXdV8 scyxirlWOScAoNbyxC3C6wUDF7pfCFw0zO/5umqYuW0mQLezMgB5gxa/TQZk5Qbabngg8uwWeRRp 3YhMrkWu7u/D4qMWp/2+HPV6IdiQTjOPQoSxiUSIGTfn46y3Z6MOWk/Ivc6IWGjBYWb2nZlzLkQt 5ufWoIW+l6zLtUz3X9NwhXtOAxatZjPEKULAwo3X3Li1FLiYmrhFKEyE/1NJer388dudjhx2u3L3 c9ji2C23ki9ooZenIYuBi+XIhQ1d6GWxH5+dx16qr9IqWc//lGEBAAAAAAAAAIjsVP0HlIioBQAA AAAAAAAAAAAAAAAAAADU2IcA7J0xTsMwFEB/laES7QLdOpB79AAMSAhWLgATOzMH4hQcoQsHYGEp U0VomxCndvIbEiikaVz0XmS5buxvx8lQNdJ/SC1AU5Wrp+q7258CDYcnEseBLBZxVgqhxaoktIhk NjNCi0iiKLIyi3kutFi3jcjiQ9VGaLFMayezMDlz1omHguBF5vM3ubm7ksn9pQyOh/matBxCyyLK QotMLpHEGzILcziRRVlW4UQW5nDtvI+VYLg6j2drJ7QoCzWSZGOF+ZoBfqTrx6Tr+fcJQov9zuNr At1Dv0/b4GPCYd+SMjfFh/3YVTyfrsX36zhkwUTX96kLoYWvc7bR769jEFq003cX43383erzmCbj mo5tK54vMdqI1WZMAAD4N+j/1r8TXNTJLerG1fXL5Bb2nUUWTzstnOBCSylcWn+tDhB1vtx/G9mF bv9GG+D6jUSWF2l9lg5/Fjl6FHmdvcvDdJqdvg5DOR+PZdTvbyw9UUKLlf2sp9dSiThxe1S0jcyh aZ3P59oV4gtnaxApxBd56RU3oc4Z0lNxzRuqwM6fSyqc3MLKK7TMQpfYntNiDzPXyrb7QSDhYLCN 1OI0LZO0PMlXgUWd3MLJLLTIwi1Bl/KWlZ/U8lNZpWmp2kYAAAAAAAAAAAAA2I6w6wXsEKQWAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAfMpwDs3b1OwlAYgOGPSpQwkZCwuhATB51cHEy8EXf1Lly4Aa/B eBPOLo7GC2BzICEOkkgAPee0Hz2QApW/HuV9TNNSy2mLVQlDX6IWyENvWGPdmOl43sat1oM0Gs2J oEW/b4MWA+n10qBFt2ujFn3pdL7MOg1YxDGLOGgRT/HyZNAinux9duKoRRSVzL7eZGBW393fytHV hZT308t7VtDCxivs3IUsNGrxPRyHJ+x6G6OwQQsXtfBDFhLHLNxjfzmJWuj2dhyd++Nq0MJ+uWMh aIFVFX2ZFLH/os95U/56KCHEG/mGPtYmxg3t5sXrGjPE8/pPf4uKPJdQfj9DClqEGJgo+thDjksU sc8izmGV8QlahB+02EYwY5tximWEFLRYh9DeO4X4/hIAsFP0s/Z5cQv3fS9woZGKWc/Lotu555bS z/rHs5L3D8zPBujjrCxA3qDFsgmBrPzAgVk8Ffk0k7yLlF9EBk8ij+22mxqVilw3m3JWr7uAw3iY JGjhlu16/3EyRcn6rNPzIw9aU8g9z4hYaNFh5G078vY5EbVI9u0fv14b080Q3afdX5TEKSKNVkSR 7CWhi7JZtqGK8lTgYujFLVxhwkXY09fHLh9Wq3JSq8nr4rDFuZmeJV/QQl+OkkwGLqYjF37oQq8O /8flj6PmpVSy1v8muwIAAAAAAAAAu+ay6ANYow8zLfywGwAAAAAAAAAAAAAAAAAAAAAQrh8B2LuX nISBOADjf3nEREhcuHGBIdzAuHHvHvdewRu49QDew8R7uGXB1guYQJANllBqZ+jAdHg2PDrC9yNN rbHTUhttNJmPqAWMRTMxuZ9T98vzuoGq1SsJw4KMRlEStBjLYBDqRQUt+v2h9HoqahFIpxNIt5sO Wtgxi0nIYihu0CKKVMxiErQolQoSBG197Lf3F7lp3qXOZ9OghQlMqPCECVvomEX8UrEKtbYjFtO4 RRK4UNt6kdla7W/GMeO6QQsdskiiFiZoMdZzAM3OH1gr79vk1IIW+zy276GEQx/H1wl0ff8++TZ5 8T7HzMq3ezTv/Xc5li+TgB/L7wcfAxP/IWix67HyeM++BC3yPI9jDVpsy7dAhe9Bi0P/nPHx2cmH Zy+bj9cIAHCy7L+7rwpcLItbLNtvkbPkpfadjmc3LUzgwo5SrJrmP0vQwh3Hrjhkfe6+Fhk14/VD vPuXyMWHyPfPr7y2J/+fearX5bFWk8tyOdXliJKghej3ng5eiPV1OjQRmWs029Zxhy3XbuBiUfjC 1BvE+Vii9RfKRCjmwhYqaOGELNztcbJthzzUEcPkuOfFojQqlU2iFo14uY+XT5kPWCyLW5iYhR2y MKdgL+4lsiMX5hK4d52bZRHh6Q0AAAAAAAAAsrrN+wR2qJX3CQAAAAAAAAAAAAAAAAAAAAAAtvMn AHv3r5MwFAVg/BSURF0MIQ4uGo2Jkw46+zz6Hkw+gE9g4muYOBhHBx/AzcSBMKhB/tR7b3rwFFCK Ai3h+5HmFmxvW2gc+xG1wDj6oBrvwi2Hv21cr19LrbY/FLR4f+8kQYu2NJttaTQ+Q9Di9dUGLD5M 3KLlxlYYfdBCxAYt/NgLS6USu/mfwrGv7i5l62QvFbAYHDUW4YMW+gphCfc+RCd81CLuDAUtbKxC IxajAhcastD9/Fx+Xee1QYuefcXJeSWBC0XQApnkfZsQtFiMueehaLGAWSFokd+cRXuwc97nU6QQ RFEeAr4I17GogYlFCVoUNS5B0GL6x55EUYIW8/xfWbTt57nPf/b7q7zv21nsX9R5Zj0nAGAp/Raq iG3QIJLUdjZ2kYVuF/aNvmPc/SEyx7IZAE0EjMoEZA1aTJIUGJcj2HCrRyJvbpEXkdV7kfatyM3z c1i219bk/OBATqvVdLjCxCx8vEFM7ELXS8n6qMuz0QetK2QeNWJhYhZaeOiZbfvHsl9dlP6Fw08R x0N/93OXNVjh3odoRakk5eTzFbfeTdbt0jVxi3IytxYmQpjDjTvr63K8uSmP48MWZ255kGxBC738 SNKBi8HIhQ1d2LtSvzI7j/2afkqnjPp8kswKAAAAAAAAACyT3bxPYIpu8z4BAAAAAAAAAAAAAAAA AAAAAMD/fAnA3t3rJAyFARj+AiZoWDAuTRwMo5urN8DuBbh6GV6Ds3fgjbi5uDmYODkZBpDwZ1t7 2n71s1SQgPZE34eQUgrnlJ9Eo8l5iVrAqVpxqXyfW8zmYtVAnU4gYdjIgxahTCahjMdZ0GI4nMtg MEuDFv3+VF5ephJFNmbhAhZuf5qHLmbJNgtaxPFcsrBFKBq02N2dy2j0kM57fXcl+8eHK4MW2WJA UbGvgQm9aIRCwxRuWw5XlG9r3KIIWpjnvuUXN4dubUwjPY84Ox+9KIIW+Ja6vyYELRj7p+bwfbxt 82mxYF8XHPZlYedtjVf387c5FkGL/xeY+O35/kJcwtc5Nxm/7p8Xdc//m2P7Fqj4q0ELnwIavvye 4Ns4Pz0mAADy8Xf5qlCFBi5cxMA+bt24hT5Wn1uMZ5sWGriwUYply/6vE7Qoj1OUJkpby+YM7FiB yPws2faSw48iezciz69juby/Tw+fd7vSCwI5aLU+dTliE7QI89t2Whu1iGJ9jz7209jDhlv7ctMi Q8X9TkMW/2Gmr8XSUEczf002XLFj4hVV+1G+b8Mdbvww/861mk05are/E7U4Sq6nyfVWFkMWX8Ut NGZhQxZ6CvZqj9mPqXgLZPFbtiyPAgAAAAAAAABY7aTuE9iip7pPAAAAAAAAAAAAAAAAAAAAAACw mXcB2LuDlQSiKADDR4UEE9NNuwiSIAgKn6lVm7btfZXa9wgt6y3ctBMDF0ZKNs0d77HT6MhoqZf8 v7jMJaczk4gEgT9RCyyiH1DjXMfrbNHJ7fa91GpHM0GLwWCy+n0XsxhJrzeUbncYP/6exCt0TeIW uh/6yIUGLT7EBS2iaJwcy+XXeOaLtFqncvNwK9XDg+l9pIMWGrHQoIX90qBFkp6IJgEKF6hwUYok VOFjFRqu0IiFDVnY40zQIp45TWb4a+m1CVrg13bxZULQIqzZ67pGyPNC/kDeUN8TCFqE9/N/OYug xW4EJjZ976vMDTkusa33520HREKYuey5y9jUPYQWqCBosX6h/J0Q0nOSFvK9AQD+jTxxC3/CXHkD F3peErgomP9taNOiYK5lswCaDJiXDcgbtFg1MTAvT7Afby9E3s7jfVdk71Fk9Cxy1+kk66Ralatm U1qNxs9whQ9aJHsfhdDYhe6Lfp/+9WzwQsMTSx01YpERucgsN7jARhRNH4tMlEOjGRq2SIoRxaKU NHJh92aNTdyi5Gd+mplu1nGlIpf1ep6whYtaPEm+oEVRvmMWNnCRjlzY0IV9FerTZueorESKZHx/ UbYFAAAAAAAAAHYVUQsAAAAAAAAAAAAAAAAAAAAAQDC+BGDv/nUSBuIAjv8CEiOYEDYHEozvoC9h wuTCEzi46egT+RaujjyALs4EBoL8Sal3tQfXoyCkwJ3m+yGXWijnAU0kDv0StUDelZXc+/R5cv/b RNVqQ2azkhqRTCZzGY2iJGYxHM6SoMVgMJV+fyK93ljdZ2IWX6JjFiLjNGKhxzQNWawGLUqlWI1P NXdfHp7u5PrxVmqN88Ua7DiEHYtwgxZJXCKeZ2IW+qZjFHmxChOy0Dezb2IXyXNkGbRYzJduTdDC DWrEcWaFizUDWwnhVDn2Gv5r0OKQCFqEddH8Qwr14sUhBC32zfeFpkM6p0P5bP7C6wgxMOEjaOE7 LuDjtYR+XNHn7GvOEIIWIRxb9LnHCFTs6ph/K3wELUL87rQPIX3fAADAM/t/9psCF0nowAphbIpi rGMfa+ZL5jIBBRO4sKMUmzIAuwQt3HnswsO6NIFbe9D7OolwITLtqG1bPfwucvYi8jEcynO3mxzW abWk3WxKvVLJdDliK2gRWaEIdxl5MYt5GqYovJVl+GLu/N6fpS1jG/bbkXnr0lCGiVWU0rn1/okV sLB/NkELc7x5bXreKN0/LZelVattE7W4UuNGjTdZDVmsi1uYmIUdsjBLsIf9WN5Z4J5ledkV9y0D AAAAAAAAAOS7VKPuexF79Op7AQAAAAAAAAAAAAAAAAAAAACAYr4FYO9uchIGwgAMf7RGE0wICQfQ 4EbizxX0KsaFC+8gJ/AULjyGe2NijCdw5YoNC6EFrJ2hU4aGIkJpC76PmbRAO0wbdiZ9iVogjXkw jXIbjuN5B7fbD9JoHInnjaTf/5Zeb6iHilp0u4MoaOFLp+PpsIUKWqiQxThm0Y9ee1HYwhcVtBiP oZiohetWxPdf9ffd3d9I6/pSdnYnP+G0oIWKV6itDlmYqEUwisMT6n2dowgGcaAiDlnIOGahX9v7 UdRC7cfnJoIWI/MXjLd6LQQtsC0IWpR//m17SPEyNuFhvGWKPpTxocxlmSOruYo+P8u5ij4/K3lc RxkDE2WOQBT5/WUPUBR9r/NYR5Zzbtqxq8ojaJHX9eS5tm0LWpRljnXMtc45AQBY0LxQhQlPRAfM tGjgwhxn4hhxMMM0LSrWd00VF2Q6PWB/vmjQYtnkwKxcwX64ey7ydRLuf4rsPYl4LyKPHx96tGo1 uWo25bRej0/R01jRCDsi4czYT17erODFn7ZRgCLeyqQAITL9jzP7dgdBMHULk2EL1x6OI270mT1G VtzCNdeRuL6DalXOwvv1/nvY4iIcz7JY0MKRSczCDlwkIxd26MK+DWZ59jxGWhJFUt6fl2kBAAAA AAAAgP/msOgFZOit6AUAAAAAAAAAAAAAAAAAAAAAAFb3IwB796/SMBQFYPxIKRlKJ4cuBbFP4Ogo OLi7C44+gZMP4Us4+xguDt2cBJ+g0FJqI5KYfye9uW01NIm51e8nIWhyTxPN5JCPqMX/tukNSvbP 4mfk5qdB/f5AlksR30+DFovFp8znadBiOk2jFpOJn0Qt0nBFHLJ4N+IWq6BFGH5kew1aBNLthtHc 5+Sz7h/vZHhxUohAlA1aaGAiDk9o2EKDFHGgQkMVGrHI4xZZ4EKP5edFX/F6naNz7aBFErLIohYa tAiSd/usrh8ore3HhaCF+/PbfkZ25eoLdF3+O7katKiDS7+fOma1vb5OLt1Lmy8j3+fAxG9/3j4E LcpyPVSxj0GLNme6cm4T6+ue/dfWVFlXdW1T81yZ0cSsJmcCALAD8//53wUu8hiFrAIV29ZsY56r 85JZ2WfkgYtCUUHW4xZiHLfPLxO7ML+396ZNcYs4kTAU8a+i/WV0+FXEexB5mc3kdjxOTrkejeR8 MJBDzytcepiFHSSOPhiRB/syzEvRSEWQhSmq7jVscWBt9m2bYRMzbBHPMDc7ZmFuQRa30HV5NCOb 6XU6ctzrlYlaHEXbabQ9yXrIYlvcQmMW5u1qxMK+FD1m/9X19u2nyM6siKw/PQAAAAAAAACAorO2 L6BGb21fAAAAAAAAAAAAAAAAAAAAAACgui8B2Lt/nYShKADjRzSRIJAwuZjoIIMxcXBx8n30Hdh9 Anfjazi4OhmegNWRgQEIFuxte+AUAYv86UW/H2laSO/tpTI49SNqgVnsM3nuw+180cmNxrOUyyfS 68VBi243iIIWnc4gilrYoEUQuHBFHLOYxC1cxKIvcdjCHQ+SoEUg7tk5xeIwnC8OWjy+PsjxTT0V sJjeayzCBS30FYUlwvdRdMJFLUaf34MWJlahEQu3nw5caMhCx7m53LHOa4MWQ/saJetKAheKoAWW kvfPJe/rbxNBi+1ex9cH6O763ykLHx847NtDmf8a30MQ25jLl6BFHtfzce2/GZNHDML3UAVBi908 dx3jffy/1ecxq4xbdeym5vNljk3Mtck5AQBYg0WhChs5mNexyBq40PM0jjEOZmjTYs9cy2YH9P2s rEDWoMU6EgQ69ig8vBLpXYbHHyKHLyL9pshTqxVtF9Wq3NXrUq9UxkOi5SZBi+g4/O6SvC+Y49T5 kq4puECFG6fBi6X2Jm4xL2qh19VNb5sNW6QCFoWC7IefHyQRC/08sHtd99T3OS2V5LpWk/d2+6e7 fhtub5ItaFGQSczCBi6mIxc2dKG3wS7PzmNvzawEisz5fN65AAAAAAAAAPDfnOW9gDVq5r0AAAAA AAAAAAAAAAAAAAAAAMDqvgRg7w5yEgaiAAw/S1CSLgxLogkJO3duPYHX0HgAr+LaI3gQd8Sl3oLQ hKQSoHZKX50ORUSBDvB/pKnYdjrVLogm/YlaHK+qZ+5Ufe9h1UCtVlviOEmXaRa0GI0mWdQiisYy GGjQYpxuj0sxi3nQohyzEJnkyzRbwjCW4fAtO89z/0naVxcrgxbmQVEajtCghQlM6EsjFBqmMGs3 XOF+rXGLImhhHTvRlwYtrJiFeZ/NI5nPR1+KoAXWUvftUsf5677mbdn3UIKPD/L1faxtjOvbw4s3 NaaP11X3Ne3Dfb3rcx9K0MLHwETdc/c5LlHHOeu4hv+MT9DC/6DFLoIZu4xT/IVPQYtN8O2zk4+f LwEA2AH7b/0/BS6KGIV8ByqWHbOMva+Ol42Vn6MIXJTqCrIYtxBruzFz9rW3VcUuqt5XcYMahkkm XIp83qfrkUjwIXL6IvIeRfLY72e73PV6ctvpyHmzWZp6kocexMQfrOhD4qztqQX2selxszw0se5a rMBF8SM4mb8rfv5J+T8/QR62MHs1nLiFHbsI8u0attBz2rEMM8ZZoyHdMPxN1KKbLjfp8iqLIYtl cQuNWdh3g0Ys3KnoNve3LLJ4F1VlVURW3z0AAAAAAAAAcMyu657ABhG1AAAAAAAAAAAAAAAAAAAA AIAD8CUAe/fPkzAQxnH8wcXEGGRycNPEwcRF35Gji6u8CCffga/AF2Dim3BzcnARSYBBUAqtd7UP Xs+CYioe5fshT669tnfyJ6Ghpr+a3mQF1aI30Zm1y5S+mrPt1NTlrEGazSvZ2TmWfj8xNTZlwywi 6fVsmMVQ2u1XeX5+lU5nIEkyMEf0Tav1YtYHadDFR8CFbW3AhQ23iGRj48mMdS9HR/tydn0um9tb k3n9QAsNsdBAC/ehgRYaPGEfNqDChlKkQRVZWIUGV2iIhRtkkWtN2TEmgRYaZuGEZ+jcBFqgNP/9 cVm1QIu/nDv0oIRFzxPqDXRDf59Cu3lxmWOGFABRxnj/fXyZY4VyE/BleB5lBTNUfb4Q5l/2OefZ L6S/o6qBFr/Zf5FzVS3QYtHhGSGeO4V0blnmOH89JgAAC/JdUIV7HScXVDFHwIVyrz9MwhXcL1L/ OzXx+vzlaev+trhgjGntrGX1KLJ+I/Lm3NrqsNGQk709OajXc7tOLmg5r+Oas54mLmTL2q99uW0F /bPamjOWzuM/pTi9ViVp6IatURzLyLSRaW0NC+ptPE7bKNvPLutxOk6cld1+22rJXbdb8CLmPJi6 kM9Eea2ooM+tcVYjr9WKC1qtxFvWdXH6RL5+snxTzwS5tg0AAAAAAPCj/xMHsPyq9GPornz8Zg1U EtcuAAAAAAAAAAAAAAAAAAAAsCreBWDv7nUahqEwDJ8kZQoLSycGWJhZkNi4AFZugBkmel/cBhti YGJiZSkVVVW1UJmcJKcYU1BLf5xK7xNZThrbcZJKIFXy14o9AUTxW6CFL5Mq1OJPed6WwcDJcDgp yof0++9l6fXG8vo6km53VNbOjcSCKyzEQmRc7I+9uloTJ02dZNmTvL29yFXnQk5uziXf251e89vi TP4WBFr4IRMWZmFhFLPCKizIQrfpcb1f9pGq1k3H01rH1zHtWmGghs4pDLQgzAILi/2VIdBiO8be hKaFBawLgRbxxmzKws6rGi92/1WO1ZRFwLfhPrY1YIJAi+275iLtmjSP2H+DCLRYT/tN9lmm33/F /t6uo39Tx1n3mAAAbJD/W8CsoApb3EYXn7O22s7fn1dSb9rXxiuPLeAicTYp61AVixUILxWeS4K+ SuMJ0unN/uz7F/+aftt9kdFlUQ+KoR+Kcivy2OtJ5/6+PH19dCRn7bbkrdbX9Ow56pR0IT/nvk3Z r/2ppa5+VnWtYRHpHLXUt+2HWtgCgtVvQvXj8RYvSup5lcEYRdE684p/PKnb6b7eT+q9CruPnTSV wzyfJ9TioCinRbmTrzdmJZvxmX1uQRT22MJpuOBc+Fbt0bhgP5nRlv/6AAAAAAAAAOCn49gTWLHn 2BMAAAAAAAAAAAAAAAAAAAAAACzvUwD27lgnYSAM4PhHMYZgGFhdNBgHR1dNfA5HX8CNR/ARHBx9 DDfj5ubgxgs4EhKGRpTaO3rn14ZijYVe8P9LLkhT7o6mA4lJ/0QtoLkH0BgmaHGy6uTh8F46nX2Z Tj8ljj/SVzNmMpm82+HCFjpksYhbuMiFCVnMxMUszGi3k3SuRzv/zd21HF2eyc7u921aFrSYJ3P7 auISPmqRBSdMgMIcN3EKH7XQIQtZxCzs++xv996dZ1MWKmih59XxDLsXghaoU9O3DEEL5l7XGqHP V7eQHxZcB4IW4X2+zrkIWvy/wMSm19uGuESoa/5l/qYfUN/0+pucO7RAxbYGLUL6HRXK74TQ5ln3 nAAANGhVqCJR8YOyjkXVwIU7z8cxCtkAH7dwx/R/hZYFLorZgVVBi7IQRpXIhd6TsZcucZ4Ok2N4 E+k8iMSvIrejkR2n/b5cDQZy3Ov5j7jAhd2iDXuID1xEKnaRO199lVbhWEsdL77qwIW+hIsl82GL JBvunCjbj4tb+KBFFEk7PU+HLeywQXfJrWXmP+h27XV4GY9/uqoX6XiWakGLqPD1XeCiGLnQoYtc 3yM7pufxl0bK74Zlx39z5wAAAAAAAADAtjlsegM1emp6AwAAAAAAAAAAAAAAAAAAAACAenwJwN79 5CQMRAEYfw0EEty4YSdu2RqXxit4CxOXrr2E93DjDVy6JMYbeAJiYKOhFDvtvDId/mOhk/D9CFZo +9oICSQm/YhanJ5lVz7ynzOPHzYNarXOZTxOSkGL0WhSBC2Gw1+J4zxgMY9amGUes5jNJs4ylnZb 0hlv2eznlyfp3V2Xjrdt0EIDEyY8oWELDVK4oQqNWBRxCxu40HXFdunN7K9z3LnZMdPj67E1aqFB i6S41BBBC+zhFN8yBC3Cmn2oY4Q8L+QL8oY2p8p5oVzYuap5de9f5SyCFqcRmDj2ue8zN+S4RF3f X+oOiIQwc9dtd3GscwgtUEHQotp9DzEv1O+EVQr53AAA+Cf3/wTrAhdRFJVCGOuiGKtE9mb2Lea5 TQsNXLhRCj9MIc7v7rplQQsj8fYTZ/2mz3j/mIZJKlyI/Nyny+/04afI9FWykMPHYJBt8tjvy223 K2fN5vzU9e+Y/cgjEcs6G+5zhglIRDYkYZYar/CXIvPARfbIbu9KbNxiodRgghZmjuRxi1JRwolc TG3gItFt7LzIBjrajYb0Op1tohaX6f0mvb/LYshiVdxCYxZuyEIjFu7dXSdSfhX1JfCzJ/47S4Rv gAAAAAAAAADgu6r7BCr0VfcJAAAAAAAAAAAAAAAAAAAAAACq8ScAe3eskzAQBnD8K06kCYHF0YiT Tsa4mvgivoAT7+Hm4uhTuDibuDsZnsCVhEFCKLV33IfHgQgC7QX/v6YpqdejhUad+idqATV99k7h tlhPlw3udB6lXj+Sfv+noMVQBoNJ0EJksua5iVkMvX3m9UhM0CJNx8Vxz3buh5c7Obw8mQlYhFuN RZighC4amNDYxCgfzQctvFiFRizMNgxcaMhCjzNzmdc6b6ZLnsnYX3J3Xi5woQhaYG0x3DJln8O+ Bi12iaBFXA/N36VYH14cQ9Bi26p+0HRM93Rs381fxfK7suzARBVBi6rjAlVcS+zjNj1mW3PGELSI Yeymx5YRqFhXmX8rCFpsT0z/bwAA8I8tC1Vo3MINWGjVwIWOs4GL5DsePt0k3nv5mQJvTDDh7M/8 oMWi2EWYP/CrEqvQcU2R7LrYXhXrh0j9SeTzXeS+27XrRaslN+22nDUa00M0cKFxC7vfBSU0DuGf ip6aXkoS7Eu8/X7gIpH5jy33ohZh3CJx719zcxwEa+a29jxcBMPGMNz520hJsT1OUzlvNuWt1/vt UzRRi1dZLWhRCy5XAxdh5MIPXeil+9+yP49a9u0v2r/OnQIAAAAAAAAA+4SoBQAAAAAAAAAAAAAA AAAAAAAgOl8CsHc/OQkDUQDGHyVEEsLCBStNdIk3cOGBjFsv4tpruDfu3Gg8CoZA2BR1pvTBc7Qg Wtqhfr9mwj87TEt3Jv2IWvwv393hKHyv48bVpom63YGMx3OZTtNshEGLyWQVtLBhCx+yWIx0GbTo 92dun/ts3tvnGzk8O9oYtPA369FwhAYtfGBCNx+ksEEL/xiGK8LnGrdYBi3MvqluGrQwMQv/OlvH +2I9uimCFthLBC3in79pNyn+jX24GW9M0YcYb8ocyxxlzVX3/mXOVff+Zc1VxXHEGJiIOQJR5/fH HqCo+1xXsY4y59y3v/2rKoIWVR1PlWtrWtAiljl2Mdcu5wQAIHL2fwjrAhdZyMCEMNZFMYq08s3v u5zPNi00cGGjFGGYQsxz+1lR0EKC/bYRfqfnEwvHIrNL9/jqXj6JzO9EXkajbHjXw6FcDAZy0G6v lq7n0Y03E7QIOxv2PS/JIxL6qDELG7oIoxa6XBu2sFomVJGYEYYtkjzAkeTPw0hGJ0nkpNf7SdTi 1I1zNx7la8iiKG6hMQt7mBqxsMN+JvL5V9NTHl4V4ZUksv3VAQAAAAAAAABN1qSoxUPdCwAAAAAA AAAAAAAAAAAAAAAAlONDAPbuICeBGArj+JOlhBgTcMnOlXsT4j28AVsTz2FcegZv4AE8gu5MXOiW sCAkgMCALfRhZ4QhyoxTh/+PvLTUtgNKYmLNfAd6MxyUi70RzrrhDWP+vXauTN2m7d1u30m9fi69 3jLQot+fuDCLD+l2lzWfj8zMgWmHph16rR0fuaCLsVSrr2bts7RaZ9K+v5baydHqOslACw2x0EAL /6GBFho8YR82oMKGUiyCKlxYhQZXaIiFH2QRa01pKIYfZmH7NrzC9vXaBFogc0V/bIq4flHvmUCL v71OqDfQDfnnFGqgRRZ7hvT9yWKvotdnuV9I7yX09/GfQxn2LdAi5GvmMe+3a/J4HUXuGcrcLNbn /drKtmaXdbuuzWu/UPbIY6889wQA4J/aFlThnwH5c38ScKH8cw09M4ydbSR/RydTGpL9ecq8tK+l tWl9KzL1LnL4IDJ4+Rq+aDTkstmU01otNn11MOa+j+ueV1y/4sZ1zJ+rz8Ub2xRsYcMwFmVfrmmn s5lMtHX9sesnW1tTO9dU5MruZfceRZE8djrytD3Y4s3Ujdi0+XhN1oz5FbmaJlqt2ZpWa57o63Px xkS+fzqSYmOcbQMAAAAAAGz8P3EA5VGmP4QeyyKmGigvzi4AAAAAAAAAAAAAAAAAAACwLz4FYO/+ eRIGwjiOP7RGBpiZTAwTb8E48RIcfA0uDA4uvirfhTGOvgoHJhJCokDOXntPOY4asFA4yffTXK6l vT+VG0hM7ndx6gngaH4LtPDZ9fCwraNO5yoPtJjNFjKdzvNQi8mkKDbcwoZViHy5+luMsfU8q4t9 cYxZSJqKJMl79vynjJ7u5fb5Ti477XKMtU2U/CMItMijLDTQwoVZaBhFVViFBlnYo7x253kbKWp7 2P60XuphlhuBGsWGRGZjzkAtp146BFrE3z+BFvH2dYx+64hxw+HYNmU+N7EHQRyjr1gCLU4xXoxz r9OGQIv6z9VtQ6BFM88eon2Mv1tjbrNPu33bNtVfLH000VeTfQIA8I/5/2OoCqrQjXHsxnX6rH3O P99Vyx22bdmfn2nRMjopbVAUjSHQoUxwT4J7suXersIxrTQrfZHZSPJtsdIPkeWLyOt4nBfrcTCQ Ya8n7TRdTV3/juI2Acyu/Vfwa3/qibu2wRJJGIxRMV0NtijPg3HzgAzbl/vM1okLzSiLm284hn2f fre7S6jFdVZusvImRaBE4pW04jP9XIModOhEVt++vwr0nsj6t6SvGq6CcOWI/H01AAAAAAAAAMA5 Gp56Agc0EQItAAAAAAAAAAAAAAAAAAAAAOBs/AjA3h3rJAzEARj/o4aEhIEJF0OMg24+gYSncHRg 1LfwEYw+hQ/AMzi6svgQJJCoafHu6LXXBpqiLXfg90vOs9gerXRg6kfUAu7zb+7VuCrbeTx+UT9P ZbFYxSxs0GI2+zJBiyjS8QodtPhMZxu30GELPdptkfn81az3+Pwgl3dDOWlnt+KmoEW8jM2s4xJp 1GIZrTIWSXhCxyn0tolUyHcuXKFns538brdt8MKkLApBCxvMcOMZJmQhS4IWqJ/vW+c/BS2atu+h hBAf5Bv6Wk2sG9rDi5tcc1uh3aO+j29qLZ/vfShBixADE77PPeS4hI/39HENf1mfoEX4QYtdBDN2 Gaf4jZCCFnUI7TvhoX6/BAAgYGWhinVxi6KqgQt3v9x6dmo567sZA2efwoL5v1WNXbjbxdfL2P16 ItFIzTfq8A+RzkRkoean6dSMUb8vt4OBXHS76SE2cGFOy1y7E5BwYhe5/SULW5gwhT2mtf5zsvWH WLIShHu5mo5XHKsR6fWSyIWNWrSSgEZcCG9oZ52OXPd6VcIWQzXepFrQ4kiymIUbuCiLXNhLcU/R XSf9l8jmT3fd69vcCQAAAAAAAACw7859n0CN3n2fAAAAAAAAAAAAAAAAAAAAAACgPj8CsHc3OQkD YQCGP36CCbJlZ3Rl2LJ04d6TuOYCHsJbuNMzuHLtNVgYQogJiNbOlA8+x1JMrHSk75M0DtROayH+ xGReohb1kLdiUficW4zmetdEnU5fJpM3mc2WfptON0GL+XxhghZZyCJJspBF9nEpvV4iLy93fq7b hxs5uRr6cRixsOO8oIUGJlzAwo01ROECFS5MoaEKH66QxTpiYR9r4EJDFj6IsYpZ2FCGm9+f08Q0 NGbx4dfhIWSBElT9Fqpb0OIvzx17KGHf54l1Ad3YX6fYFi8uc86YAhBlzFf18WXOFcsi4Ify8yHG wMR/CFqUPVcVX3MsQYsqr+NQgxa/FVugIvagxb6/z8T4u1PVfyeGYrxHAADUSNH/IRIfOmjkfq6N LISBi6Lghdvn5vGBCzO/nzsvQqHP2bRBEuyTYJ/s2Fck7zz22FY6PBd5HaXjSfrwWeT9XuRxPPab MxoM5LLfl+N2e3PpGgqRr0GLsLPRKNhyL1fDFiZwofRcGsWwcYvmKmbRXI3XAY1sUn/8Uaslp93u T6IWZ+l2kW5P8j1ksS1uoTGLbSGL8HY0zSthb0d463a9ggAAAAAAAABQV8OqL6BERC0AAAAAAAAA AAAAAAAAAAAA4IB8CsDeHas0DIQBHP/MaKFkEgrBwc3FxVVwdHbuK/gkbjr4Br6Bb+DiK3SRPkC3 ksViztx51ybnNY3SmAv9/0oItul3qS0qCPkTtThs1evr3JXbedPB0+mjKJVJnn/Icrlabzpokeer SsgiHLQYjwtZLJ7NrKfXezm5PKucyNGPCzKFghYuMuFuOkihAxQ6SOHCFGbzQhbm5oUt3HHmuXaO 25tgho1auIiGiVm46IaqnWh9D/xW358dghbM7mqNWOcRtOhvZt8/73x9X2g6phBELBcBH8LrGGpg YihBi1jjEgQt9r/2kNb/6/H/uRZBi36e1+XMmP623OecrmcCAHBoKsmAbdELpQL3b29ZtNP29/iu mIX7OhTF8MMZTeeyK42Qinxel/ur8uF3keMXkXwu8jCbme1mMpHbLJPT0aj+7x8btBAd9pDv4EUo dtEmauHmFbJ5T/ywhduv6xA2ZqHXTey6iZ3hHi9sJEOf+0WatglblN8FeZN2QYtENjGLauCiKXLh vxTlzfHbIKF3OXR/208EAAAAAAAAAAwdUQsAAAAAAAAAAAAAAAAAAAAAQJS+BGDv/nUSBuIAjv9K NR0YuzExGBPegEdyNPFV3HwG3X0BZwcfwK2bBAIJ8id6d97hWQ5KtHAFvx/T9A+9owYHjcl9iVqc vtD6OeVr52q7qpooyzoyGMxkPF7IZLIwQYvhcC6jkY5WzOz2Ljpk8XU8t9tC8nwoRXFv5rl7vpX8 srNaYCm00JIftHBfLmjhxyf0Xocp9N7FKvR++jE1x3rvzl3cQkcs3L16nIth6Pl0yMJELWw4YxWw MKsM/XhAls5BPWL/HBG0YO59vUeT52vygrxNm6fO+ZqysHNd88UeX+dcBC3iBx8O8X6HjmP8Zsyx xyViBxqa8Byx4xP7DDsQtDjMmBjj/jp2H/M17XfC2H+3AgCAeuwasth0XygWIVuuha5vC1tUnVc9 fzmREHreVJ1eiEyu1fGbOn0RWT6IPBaF2c6SRG56PennuWRp+j2tjVAEgxaBwEX52/Ufoxy28CU2 YJF4MQs9R6qOlzZoYV4T799U9p6s1ZJuu71L1KKrtr7anmQ9YLEpbuFiFptCFn6KxL0msv7JlT+h XZIkAAAAAAAAAPDfnFLU4jX2AwAAAAAAAAAAAAAAAAAAAAAA6vMpAHv3k5MwEMVx/LkDExNZGVxw CL2BLjwBew9gPIiJiRfwEt7AxDu4c6ErQghsTCjQ1s4wgwO2/C10ar+f5uWV0o7UNMY4cX5HaYum oPz0IjpmN+1tmV9b5z6px2XjtdtPUqtdSK8X6DALFWQxGIyk3w9kMhlJHA+Ts4YLPUh6II3Gu3Q6 r3J1fSm3z3dycnaqx1TPnt30axVikWy220CL0Gw2cMIGWqggCl0myMKGVqgAC1uzQAtzfDHQwnYb aKG+jl6SJzI37vbZikMZHdiUD8+OD5/hUMoaOkGghV+L5u9zTN/GyXM8XxZ2zmu8oq/PcyyfFgDf RdkCLQ4dMFFUIMM+xi178MUm522jyoEWvpy767U+BlQQaFHseNvy6feNfY8HAADSLc4OrQqFyEpj yEvWnEq8xrG018v6uvtKmNzuh8jxi8j31+/hm2ZT2q2WnNfrc6fPhVmsOOZ29xZssEWkelKhqYmq KNJ97HRdZj903gvN9VE8nWkbhqG8dbvrBFt8JvUgKpV+WuPpd8Ik1WdXmNLdilK6W7HT7b7I31m4 ZU9LaiAIAAAAAABA1bh/iwLwr6h/tOgX/SFyxA8rVAJzFwAAAAAAAAAAAAAAAAAAAKiKHwHYu3+c hmEwDsOfk6hILQtDF4ZudGYFzsDKFRhgokdjgZ2JWzCgqgfI0qYEJzjFtZqQVvlj0fepLCch/uI0 bFH9i/qeADrn/jBgoNv9X4MGg/M80CKOkzzUogi2SJKVpOlSn5EFW2Rr3axMn0gYpqLUsywWn/Iw u5Or2a2Mzk531ncDLdbpehNmkW0XYRb5x4RRZAEVeVCFLLeCLLaaWMEWJszCDsPIamXhGVtL6exa Vkek/gJIQB0+/N90PYc+77nta7dVn0CLZvn8nAi0aL9GU7X6Ht9krb7HN6WL+/AxYMLnEAifrt/V NX0IvugzqMKHMImuQir2cayBFoeOI9DCrxpt1GqzJgAAx6xqOai6S0W5CQz7/v0QZbEFVddPrf20 ohdn261lHw/17oVI/CT5MmHhu8j6ReR1Ps/bKIrkcTqVm/FYIqU2r42UWZwon5o5LvpY1Vdl33IR RFH09pSU0wJdP9DnhbrPzi/2N3Mx/UkQyGQ4rBNqMdHtWrc3MzyUn7digWmqZPvLnpb8vkWzm/0V uK3sKZU9YVfZcQAAAAAAAAD4Ly77nkCDPvqeAAAAAAAAAAAAAAAAAAAAAACgWd8CsHf/Kg0DcQDH f6Eg1C4VnFpw7OgTODgIglB3H8HNpxBdnXwQX8Hdqav4Bl1KaY2euTNX70ppanpJrvr9lBDy535N cXHKl6jF31b0+iHtOtsG64YMh3cynx/KZDIzMQsbtpjN3hchC39Lpd1OZDx+MOtvH29kcHUirb3W YqYyL9tRXsxCByx0YMJELbJPqlKxHxOyyEMUNkphgxVTNfVCFvpYf2zIwg1a6L2epWdnX+GHLOyx cs7L0rllvDoHu4qgRfzzdzFoEXpmrLPqmFsGL2WuflbT60POanp9KAQt4ppVRsy/Jfb7yq5p8m8e Q6SizvhFld9VVzQi1gDItuu2XVvVvFhmVDGrypkAAODbb4ITq+4tE7QIGbtYF7lY9z/EJmGLohSC vXYg8nGe7c+yJa8i+08ik7dU7kcjc/mi15PLfl+OOh3vcd3AhTm2kYtVX+XEKD7zdeac8lfoGUke sFi1N9fFKUbo9dk5/WzH3e4mYQsdtXiWn1iFG7GwkYtE/JiFvUc557zHdu5TzrG7ibMvClcQsQAA AAAAAADw35w2/QABvTT9AAAAAAAAAAAAAAAAAAAAAACAsL4EYO/ucRIIwgAMf7IhWBCsaM2aGHo7 Ey/gTWwsvIEnsPEidibewJPQ0BiCBQoZd0ZmHDYLrvzNh7zPZt2fDPsjGklM9iVqcbjsg2BaxXzz 28BWK5fBYCyj0cQFLYZDG7aIIxYfIW5hzEQ6naNi/IN77ePTvZxeX4iJnjljH8zjQxbxcmqm4icb nfi0k3FfQ8hibKdZqMIHLELIYhaz8Pt88MK/zi5duMIHLPx6HLbw21JaLopaAKtI/bOU4vyp7jn1 93pV2h8evIvjaT3WNo6r7eHFm6LtvlJHHDT9vmm6F+3Ro30OTGzyfKvQGqHYp1BFXamDFimPuc2x 69pmpEJz0GKX4QxNn3+0fO7R/jda03sGAMChqxO1WLa9aL28b53YhVmwvmxcfP7y/r/kEbJi6LnI +12x/lZsvopMX0Se+303nzSbctvryVW3O3cJocRgqk8Uxvmwhft/2fz++HLDekXYohHFMUw0/jjL 5KzdrhO1yIv5Un7CFnGQohy5aMh83KI8rnwpy2IWVQkS4hUAAAAAAAAA8C1PfQEbRNQCAAAAAAAA AAAAAAAAAAAAAP6ZLwHYu5ucBoEwAMNf3dWNTUxjakxjYly78ADutBfwDl7EuPEA3sMrmLh20RPI BUx/YkqtzlAxA0JRHOBrfZ+GAO0woO2CFS9Ri/8l/figK7McrzpgMLiR6XRXJpNXs57LaBTKeGwD FvNEyMLu26XbDSUIlkGLu4db2Ts9+gpaxDELa+G83JiF3bYRCxu1mMlsZcwisUhyPx5r13bOKGBh L9GNWrgRi3dJBi7SQQvAl6Z/TwQt9M/f9G+kLK0P0NX+PWl7eHGVc/6WpgiEhuN9zaXhu41pD3Os c2CiiQhEVfNq/b80Oa7u+es+97qN9aHKAEaZ8dqP+ctxVdByP6flXqPOOQEAQDlF8Yq8z3xt/+S8 WbLuJ/LCFz7u/+P3d0Tezs36zFzys8j2vchLEMr1cBh9fNHryWW/L/vtdvGUTszCWrjvZYyPYxYt SYYttj7XbmGitTxBdNyBuZaTTkeeisMW5q+SR/kesXAXN2bhxi0kY2w6YJHez+KGLSRjO288AAAA AAAAAGyiw6YvwCOiFgAAAAAAAAAAAAAAAAAAAACwYT4EYO/+dRoE4gCO/wxpcOjG0MRBE2N9AicX H8fByXfRzRfp7OjkG9ip6WQcIDFtQe4ickXCvwB3ab+f5gLUctCUVF34ErU4XFU3h1HDT8d93SST yYWs1986aKFiFmG41RGLLGiRj63MZl+yXD7p/V7enyW4PjNuzJPHLNTteVTAIk7iv5iFilioxybZ 6KiFjlmkDxWlyAIVKlaRLaMk2otZRHGk17Ofq310xCKWPGaRjbgwspCFlKyby+I60NYxXj823/OQ x3Y9lDD2cVy9tl3/nFy7efGQc7bl2jVqe/+h5rJ57GMKWjQ1dhxj7NBGl3ltvM7W948rQQvb4QcX IhUufef3Mf8hxilc+FvF5MI148rv6DHnBAAA3XSJS1QlCU5Kni97fZvYRZNzqgtRlG13+b/A3MdP N69Ewsd0/VPEexPZLUQWq5Uege/Lw3wuN0EgXtWUZUGLlmELtdR1CXO/38iFClucep5cTqdNohbn 6bhNx6vsRyzMpRmz2BW2i12NusBFIv+vkLpPhogFAAAAAAAAgGNyZ/sEevRh+wQAAAAAAAAAAAAA AAAAAAAAAP36EYC9+8dpGAbjMPx1rEBiqMRAz4CEuAFCHeEMHACJe1RcgSuwsrMxcQMW1KUZy9A/ iYsTkmKMaUOV2GnzPtEnuyly0rRFkVz51ykWT8F+6aQr2jh2G3Wn637dGIPBUOL4VKJoJpPJIqvp dJ4HWsx0pf25bqfS673IaPQkF5fncvNwK4fHR9kYS2NTxWaFWaTtxjALvRXBFWa7CrfIAy4WavEV YlGUGWRh9peO1l4xyLVoEbCt0J+jEMffl4XXfSHQYjfeNwIt/IxRpdALTTfpO9KU9ybk6/AdVuE7 bCFEGEddxw8Z1uD7mD7DAKoaL3RIRlPDy+oOnPARaLEN35/hpnxnqtCke8sqx6l7TAAAUL2/ginK /u02+9aFW5QN2th0r/HfkIsy80LmczN9Ku8iB48iH+Pv3Vf9vlzrOul2f4VZrKajjEAKpftZ5f3E UbFSElv92HheGZWdWpLIcxSVCbZ40zWUn7NraaWTgYmjb8/A2dHy9sycGTOfFC/Z0Yrx2LxU9lVP rx13mQAAAAAAoPXcPxMHsOPOdL2GPokK8Y8KrcHUBQAAAAAAAAAAAAAAAAAAANriUwD27iClYSAM w/CfMqSC3dSdO6nQA7jqJdx7AxeCGxE8i9fwAOJCepK4KrgxtULTOEkaGWNiQozOpL4PDJNm0sk0 LSE07XzK9gDQnZo/KJmNQ13O6/s7lMXiTcJwLcvlWlarfF6abL6aJNxCqVjXtxIET3J5cyazq1Px 94dpeEUx0CKKo6wuCbNI6jzMIgmyyEsaVRG/puEVZphFGIcf65M6iqJsaOa0Oma9KSkiXwMtyqbH 4ffl6DsCLfrR919wOdCiy/5cf59cDY5wdVw/YTsEwqVAC1f23YdAi676shHwYHN/fQ+XsBkI4sLx 7kPQSZtt22zflmsBFa6+7r497ze5du3ryvkNAADY0ybYommYRVV700CMJmNqour6pC7Moqrd16uO RV6u9fKziJqLrO9F7oIgLQe+LxfTqZyMx6Iq7uGZkxzlQRc581Ak9wC97bbJ8kDXAyMYQ69M68H2 8Z5SMhmNmoRaTHSZ6fJo7NLbdhUZy5tCu/kpKCvFNpHv39nYaC8uf944uyGarmeSKAAAAAAA8F/x vQiwezzPO7I9hg49cJ4CAAAAAAAAAAAAAAAAAAAAgN3zLgB7d4/TMAzHYfgvQB3ShTJXSAzssDJF TIwwcgMkDsABYOEE3IJjsLJ0hwuUIlUtEkobbLduQ2g+qubDoe8TWWkcO7bSKspS/wi12C52AZgb VY7TGvr+owyHBzIef5lQC1302jVhqPc6OSKQdntH+v070/7h6VaOrs9kt7VnwipskIX+M4INsjBb OFE9AxNqsSrMwuzVpoMqbGjFaDoyYRZ6b8ItIiUMwllwxWxK0cyN2fI6E1mGWoSyDLSwn0X+BlpI ymdgXXX/fuoev2pNDbRo4vfkaqBF0dcq85qbcPH+/7d7VHf/IjUpCKLM/kWN4WIIRd52Vc+9zPHr eA66ENCwjjLm0aTwi3XbV/ncJtCi2n6b9i2Da0EUrt0fAADgjqwQibzhFnmO0/on1aXNM1q36n0n 6x0oK+gifm5fJLhQ+3M19JuI9yzy8fkt972eOX3Z7cqVKp1Wa7HgYJ4htEUyxDzMYqr622ObOKGv ac7N6/TxoefJaacjr4NBxgjiq/Iiv0Mo4sEW8fpoyEXilFfURQMrEoMrAAAAAAAAAGALndQ9gQK9 1z0BAAAAAAAAAAAAAAAAAAAAAEDxfgRg7/5ZGgbCOI4/xVQUCtJuDoI41MnF1dl34+iiL8LXou+g uvk+2qng1hKKcl4TU89whlz+PpTvpxy5Npfr3bWkLYX8CLXYT0WXGTqWNNSiuIPBmSyXsazXXxLH bqBFWp9MBrJY3Cdtn14e5fT2KgmySAItfoIs3Ns2xMIXZrExm9JhFivzG2qxC7LIihtm4QZZZFs3 yMLd+gItgKZoeF91PQYNc26DlgtOa36OOjRdNL/NPrW+DhoCLbStjab59Lk2muah5VzZ9YX/uw60 qKLpNdEaCBLSrqwq/fUZPtFWQISG4IkuwxK0nM/qtK96TB2aAi20fG/R9Dnddn8AAKBfRf84+YIn 8vXQcIvQ8IvQMfqE/q4uan9od1+KrB5s/UMkehf5nIk8z+dJORkO5W46levxOAmlCLFLlLDHbYdw 4BuSMWndtjmKIrkYjcqEWpzbcmPLm/xd9f+CLSR3Px9ykS/uFLKtyT1uPI/n9wMAAAAAAADAvnvt ewANmfU9AAAAAAAAAAAAAAAAAAAAAABA874FYO+OcRqGwTAM/yyVGBFDxg6MHIClE7fgGAzsLIiB hatwARZWjoBE51bqgFoIEYmJDSaWcUlbJcFp3yeyYrdN6kRNGsmSvz0dQIDt4Ex+E5oFx04cc16W m7/2Mxpdy2JxLJPJW7n+kCz7SpBQSqdHZJIkmYzHF+azt/eXcnhyZOrKWXS4RaEKs9ZhFrnKTYiF DrPQiw6xsGVZmMW8mP+EWeiSFmkVYuGGWtggC722QRZ+qMWyIItQoAWXBJqwi7+jbZl4vUsxTmrc 9f6aFONE103uow2xHFtM56cP4QuriulYYv+P6DoUIsYAjU33tQvnpY3vbfua6Et/+x5ose72MT77 bdqnLu/rBFr89t/3fgAAANcqwRZuvW5t6350Qui9utfatM5z1HvZnSeR/TuR15fq5bPhUE6TRA4G AymUktyExoup27YtftsvhbOtGfr6Hv9N81weplN5nM3qevlcliupouTdETh/NM6Pmc8DbX/ELlT8 OHoJ1JVTd5k249wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABANz4FYO/udRKGwjCOvwzYybDoxmBC YrwILsdbcXPzAlzcvAoHnV2cWAiTGwMkQG2t/eDoaVNqobZ9qf9f86YfQM85TRtISM5DqEWHFIRa mH0nrNewLovOMx4/yHR6IquVF1cSaBGtXRkO32UyuYnfd/d2K6cXZ6kwiyjIIlr87eIFXhxq4Qbu d5hFtL0O1kltAy1MmIUdYhFtL4OlbD43yXQ5rqQDLXZNm2NPk2Omu8lOjSM5axuPBapq+x5qu/0m aZkUWqM6+v7fJtDtWmCDTcvYNF0fTSEQVXVlLE2MQ2soQ9PttR0Y0Mb3i/aAjDr7sO85j+U+qrMP VdvSGGjR5GcOpSnQ4i9o++2k8RoBAIDjlRdOUfRamZCLssEXZfaz7e7q6z4OCU2fi/RfRD6efw6d O45cj0ZyNRhIv9dLBVjYYRe/hVuYQAuzNiaLhTzOZmVGdB/Wk6T/gcuWn7PtF5QdYpGNojclkh9N Lzn7Yh0n1AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyJcA7N0xSsNgGIfx/1RQEKfarTcQt46i R3DoAXoDr6C7R/ACzo4O3sALCHZsp4LQFBNMzJekGEOiplby9uP5lZBSaL6ktHQIvA9RC4/8Impx mW433x1jNLpSEJxoPl9pucxn0uRBi0iDwaOm0zudnR/r4nai/aMDrcfixCrFLJI8aBElURa0cPsw fbighQtZuP3KPYqYRRAHX2IW6y2LWbiQRTlmEap+fE51NE55LE41bCE1j8ABfNDF99rX35KFwcyW WB2ga/3ztDa8eFt8uy5fIhCOpWvp8nPZ5cCExfUsrG854tF19KHt8XclkmH5HLr+fW3jPZuwfG7/ uaaV/3lf/qMBAID/mmIRdaGJNnGKv4Yvml6rO++2wYu2AfUwXeJZ2ruXgtfPl8fDoU77fR32enqP 4/y2V028oil6kRTPs+WLe8Bv6XEeZjM9LRY/XcVLul0rvytXjldsGrao3rWrbnVZeqIWAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAgEEfArB3BysNw3Acx/+C0jlhV88DD/oEewDPewbP3vUBfBC9+hoe PHny7mHMJxA6GNSUmFSzhdpmq6tr130/oaRkNGnGGBuF/49Qiw5ZEWpxbI5Xc5yF5hiNHmQy6ct8 riRNv+vRRNGBKHUncfwu17djubi5lKOTKAu0yKIstBdoYZrSKguzSHQin6bZEAt7bkMsbKiF7W2z YRY2vMIGWsz0bBFmkaTJMsjC78tK5rhyOPmSOEUlcER+l8EB6rSPn6mm9ryr73WbCw5vyz4V4+1a 8IPTxX21ubh5FeyjnuurztX19dqw/q6vucl8Td4H4Rf/c33d87f59yWBFvVp+rsfAACgqlUBEWUh FP55KNziL0EXRWuGxovuq2x8k//zHyKHzyLqZTl02uvJ1XAo54PBIrzCBVcUhVy4122vf3rfWxzL 43S6xk3KvTmeJBxkkQ+zCIVa5Pv8Uzz/SZ7L41g3pl7znBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AADYji8B2LuDlYZhOI7jfx0TevAiO+4VBGE338KD14Gv4FnBuy/gi3j17FOI143tVJBhHbOpDatd lmhHmzR8PyWUNTT5pww2KORHqEVEHKEWt3l7tN0/mTxImp7LbLaSLPvZgyZJjmS5vCn6756mcnZ9 IYOTwTbQojxUkIUOtFBBFirEojjyswq1KIIsyqZCLFTTIRY60CL7ynbDLFyBFvUtcNTn6tY3G9nd 7sa47Y37+QJOvr9HvufvWpvr7fuzjHUj37pQ69JiDH7QQt8M/L9iWs8htYSyji7qCDVIoc/zNRk3 5N8rX2toOr7P8Anf36M2a/AxV0yBFofc15TvIJa2EGgBAAD6yBVqUe0zvdWyBVrsu17tOzbMbxvH VrOt/r/0m5j+l33mQ72JJM8iH+n28tV4LJejkZwOh3vDLarBFpvy/Gvo9Vpe5nN5XSxclb3n7V7M QRb1N3W2YAtboIV+m1ePqLeFWpieGqEWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEe+BWDvjpET BKIwjr80mXGwsncmk8nkAJ4ifS6QJvfIRaxSegXLXCCTKhWNVVptVkDCw6AbXJAkTljk/2N2VlBg FQSq9xFqcUa+Qi1cpXMGWXvN2k3d+pPJVMJwIMZsa8+MRheyWDzk7z3NHiW4u81fa4iFnjdJMaVJ 9ulYojTKAy20Nzql5lughR1mob2GWaw2K4mTeB9iYeQwzCKy+sTRitI25RI4xaltl74RcZS8qftV gI5o4zw+1/+OD4WZfeLruPtwnCjK/D8ItPj7uqfmS6hFlwMm2r5Gdj1cwpewjTbH0aV7kK8hEL/Z ly/Xv7b31bd7UhOnGocv3wcAAPRPVehDXXDET0MsXIEVx4Iu6oItjgVduOarljVhP6vpNj5ELl9E 1m/7xVdBIPfjsVwPh7sAi40j1EL78qOfbvJ9uZTnMGwymmnW5nIYauGadwValIMtyqEWdquKqS8C Lgi1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADzwKQB7d6zSMBAHYPy/FLq4dHLIAzgJHXwOX8PF wd1ujr5NoU/g5CMUXBw6FApdtKWkOXNHr73hco2S9M7k+0loYqp3gRSFwH1ELTqkImqhj5/K7TX0 s+Pxi6zXN7JcbkSpvWTZVubzB3Nu8vYow9tr0UvgFPZLFSZooWMWucpNzGKndmbTQQv9amMWNmhh Yxb61cQs8vwUr3A3G7VwgxbuUjnuMjh1lr0J3eLc/mhC7Pso9viX9l+vt2uLFP9FX+aX6nWmMK9U ForvyvgughbNjpFiICFG3KGt39u3UEWb93Xs+ETs8duaQ4xx+nrdTY2X0t8yK7U5pfB5BQAA/fCb qEMoElEnOGH364QrfNGL0Huqjs/t+4597Huq/qey57/L3U+R4Uxk83U6fZ9lcjcaydVgcAxbmMdk h7jFsQJR7h+eH8q+KGS6WMj7anVudh/l9iz1oxa+sEVV0MLN1bvfFwk/5fM98SNqAQAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAFzIjwDs3bFqwkAcx/E/InWJSzcnsdjVB+mzdG5fpWPxQRw7dSgU6pjV wcGlIIFLmpyIGi7pKcH7e3w/8Cfh1Lv/QQyIkB+hFhFpCLVIyvoq66Hts7PZu6RpX4zJZTxeyXL5 YsdfP59l8Hhvgyz2oRamMDbQogqyqAItMslOAi22xdZWPdDCVv67C7NoCrJwhVrk4n4UjivQQhzn riMQixDXdKzfo1vfl/b+NT+YvEtae+uiL217C91P6PWPEWjR7Rpa71chg3c07uPc+TTv4RrzxxSK cum817zf3eI10uU6/EaJPyytork3AACgn28IxLkhFz7hFD7nvnO1jdV7bhtrs39/9d/YWuTuQyT7 Obw8SRJ5Go1kOhz+G2rRK4/fm43M09Rn5beyFuIOtTDiDrZoqnqoxXGgReE4NgVaEGoBAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAABPInAHv3r5owFAVg/CBYoUMHh4K6O7r0DYS69XE69BH6AO7u7l2E Tr5G6JbFxaUo2Ns0N/WakCYqWrjn6vcLIeKf5EQEBSEfUYsLUhO1eE7X10Ov7XanslyupNN5lyia yPCxL4PxSG7ub/OYxXaxIQu7bJJNFrbIYhbJNmYhedDCxiyyoMX3b9DCfJm/MQsXsSjGLOxqClt3 aRx3qZuqmEUxZOG2TlJzGzjXNX6efJ5zqO93iHNrnvkaZtN4jtpm8j1PSBfH1358R0vQ4j/3pfVz 4jsuoPlcNOzPZ9DC9z617vcSAhUhBD20fB9ZWmbRMkcVzbMBAIAwHBt2KMcqyo+dGro49NixQYtT Yxfl1+67r2relUjjQ6Q1S29+5k976vXkod2Wu2Yzi1mUf7bZqMXaGHmLY5kvFjUH24nS9UXOj1pU /bu3758+ohYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQj8CsHfHqAkEURjHP0UiRFsru5g2N/AG uUZ6y+Qm4hFyhtwgrZZC6pSKzQZhM7Nk4zAxzGZlw3P9/+DhKOPMW1hEWJiPUIsWORJq0Xe1dHWb +u5o9Kwse9J2+6aHx6n6szt1r3vFoTdhoIUPsvCBFj7IoigFgRZfVYZZ+GCLXb5Tvnf3WKZDcEU4 jsMs9voZZhEee5NH4zDIInW0DdA2l3SPt+Ew4aZY7916f56lHi0cqN4EK3149GJn/9KpfVgMlLmE teqsa/larK9Xd30CLc4j0KHJPdp2/Rb2TLHW0zn9DgAAAIR+C4+IP0sFSdQNs6gyr+r7Kn3HUiEZ 5fhdunqVPpaHaZPhUPfjsW4Gg++/bsX0Tkdd97rabLRYrxMNFOauXnR6qEVZx8It4jCLvzz5I9QC AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+CefArB3x7gJw1AYx79EtAMrM0Nv0ZkjMHAKRoaeoWvP 0b1jr9GhExsXQCpRQuzKpXXbxAgBz/D/ocjCCc8vCgMSkj9CLS7IH6EWi/Z43KfG/Gmi9exOxW3h Ay1CmEXVVD7MwoVa+CiL5jPMwr1CmIULsQhhFm78CrAIgRUhzCIOtHBjFR21dlvhxNvcNOoOtQj6 3gOHuLbv0yXfb873Zr136/05lnrMbUP1VFb6cOjFzvqBxQ3gT1HrHD3lEhhg8Xkdq96xa+dS03Ld 3J75Naxz7jX7WOvJWj8AAAD7+C8MIvW61OCJ1HNdc06ZuF7XXHy+r6fy29y6Hd6lmxfpY7P76HQ8 1v1opOFg4C8ri0JVXet5udTratXRgPfWHg/6HWZxaKhFiLBv9PPfv75QCyn6lUuqBQAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAHAaWwHYu4MUhWEojONv5c61m24GxoO48AJewr33mKPMNeYCghTEO+hC sA7aSbSlNSatiNKXzv8XQoOS9FUKLgL5CLXoEU+oxcb0j0fnz7+nsp+MJDftlJ/kbJoNsrDjX9uK QItLmEXRD3INsyh7ds6qoIoytCKrjd2gC9vdQAvfUTe+o21EqqNtcrk90qaOVxx985/e6Viflbpf S2tdJa31aahLQw0lTbVYXdaj5bfQcti81hAFrWu9c13NzxxbuEEsa8a4blf362M4hZb/I0tLLVrq CNFeHwAAiFtTwEPbHN/cUJBE6PtQKMUzoRdt85o+a6rNXdvX7b7ZVmTwI3JcVkuMh0OZJYl8mqsN tljtdvKVpp6b31mYvpZq566+m9cWauHG1odCLXxx9u6YUAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AACgQ38CsHc/NwjCUBzHX3ABPXtyBOMGrmFcwnXcwpsO4dUB3AEJKdSCQbEh/NGoD/x+SFNQfH1N PPdHqMWAeKEWUzfObX+7OizlshhLatM8zCJxVxZoYay5B1rkQRbuim2cB1hENspHaENJTXo7usYP rYjlOeQiG6Y0Z98lpdk/5sY/0sa/rwqyaHoG3vGP/6eh7rnv+9Lcv+beCpp61NRLgZ70rV/Q0kdG Uy9VtAYkaK31qbpaa/Wh3jfq96XmJ+v+Yq1v7GWIIRi/XLOJtp609QMAANBW12CLuvfrQi3qwiZe CbOoe6/L3LRW4H1WHkHFc+RuTyKjvYhJHuXXs5nMJxPZHI/SwtaNnXQPtHg11KI8CLUAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAlLgKwN7d3TQMQ2EAtfLCDizDIyOwUhdghi7CAgzCAH2AElMqTOqE qD/JTTjHspKmjX0jNU+W/Am1WJFOqMVT27dj7nt8fUj7+7u0b9v7d8thFrnlAIscapEDLfL5V5BF OoRZ7D52P8EUZYBFGWJRu368Z2jrm3ILm7KndLp1TS3YAtbov/3Pl/i8S6w5i1p31LqOotYXoa4I NZSi1XOJKM8yZx1RQxKuNVbEmm49buRnXvM7t5QxbznuHHOtKdBi6rnmmG+MaDVFqwcAYAq1cIu+ QIva+dhQifTH9b7vms7vho5DYzWVYzfIoql8zv2t7c/pHC9t36Tfq3ljAi36Qi1qq399oRbdVcCT FUGhFgAAAAAAAAAAAAAAAAAAAAAwjU8B2LvbHAdBIADDY9IT9Bh7ht7/9+499gR1hQKhWW2py8eI bvM+iYGAyNRayy/mtHcAUDXf8uaSO+j89S3y6VNaGDHWHTK5MqS2kMn6Y3T1UX58aa8ymUlct7gu MSaW7ght93ZfjrGMfWbW57emCWPiFjW+DGPjtjXW/rYHs21rlrvVxHMBDZXP0rs+gr0+V/U8e9/4 jPk1Qjzc3tyKARVdauVktZB6zKGgJhate92q9T87e3jhPHt8vy/nzAymOOZe915/atVJHteRPebc ROsz3jn2rX67JeNXL32El/zGi4YjfMQFzfXE4V9QDTolCemxlvoHl6+jFFTrugAAAAB/yEl68ao9 lXQidW4qOUbp+JX6kEqC8Vgf5DkJhqvbUywTIWT4kHSCiRxaK9pB8VoAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAKtwEYO8OTgCEgSAAclVakqVYiG1pYj7CceStKDOwEPaVfyAb3SLAb0RE/uZmGdne ugsAAAAAAADwafvIOnKWHJPuTivnlrpeupa6Op6RRzSmoxrdQzcAAAAAAAAAAAAAAAAAAAAAPOIS gL07NgEAhKEoiO4/ljM4j42FVQQhBOGuSZHmb/B69QDSjOoBAAAAAAAAwLfmvrfQxBmXiEIT0a89 bgQAAAAAAAAAAAAAAAAAAAAAki0B2LtXGwBAIAagt/98eBRrENBc0HzyXlJT1Q3q1OJfbaaeHgEA AAAAAAA8qcz0yAcWaxeRzy12XWw6AAAAAAAAAAAAAAAAAAAAAOBSQwD27tgGABCGgSD7L8BoVOwC PUIpE9Cd5N4bvKjF33r2AQAAAAAAAOA5Y2+2M2hxi1REcYuI0AUAAAAAAAAAAAAAAAAAAAAAFLUE YO9ebQAAYSiK7i+QDMKChEpCqjB8ck7yTFU3uKIWfyuxdvoJAAAAAAAA4Ck11pdlgYs5RpHddwIX AAAAAAAAAAAAAAAAAAAAAMBFhgDs3TENACAMAMH6xQ/u6gUWJkLKCrlLXsebWvyvhbEFAAAAAAAA cKfPMvZJRTW5WE4jC0MLAAAAAAAAAAAAAAAAAAAAAHjQEIC9OzYBEAiCKLo9WoexjVmMqdFVIThg JNzFHvIeDJtuB1/U4v9atmRbdn78CwAAAAAAADCnI1uzvZ5oxVXjiEXVO3bRC1v0QhejCwAAAAAA AAAAAAAAAAAAAABM6haAvTtIYRgEogCqJ8h90t7/BumuZ+gJgpmSCEbqNpTwHnwm6sa9kJ9L8Z+Q u8ih32rmN1PkGXkcma+7HQAAAAAAAPBHPpHXkSXyTnuRRVtmsTZz7da/zmvBRV+IUfdHs36nNC7P OD1sFw/dAAAAAAAAAAAAAAAAAAAAAHCJTQD27hgFQBiGAmi197+ySsEhxLQ4irwHISEoVVeHL9Ti R16EWsR51H5Xu/s26bHGrqddX/S+uC7uZ2dVPT5vnqt3fnyqyR4AAAAAAAC+oPqJm0Me4lzVKkgi BlIci93bIIt8/5nmKtyiNaEWAAAAAAAAAAAAAAAAAAAAAPB5lwDs3UEOhCAMBVBG5/431riRpKkU ZzVs3ktIoVEDHoD/Xb0BluqXw3zuuhU1Pr+n3uzb8Z1+0cwWah9n+y3MIoZxtME8B1lU89EaAAAA AAAAVnsLs4i9WbhFDo3I9WjPsIkz9XNoxSicotpLFVCRzzU7W/U/AAAAAAAAAAAAAAAAAAAAAIA/ ugRg745WAARhKIDq//9zRQ/BHMt6C+kcEBmC6PNgV6jFv51DYHK4w2x4TG9jEEY1GKeHfRZ+kQfr xHvuwjX6w7rEWngFAAAAAAAAq8v9uzeBElsbe3B5r4IqcsBFVe/FHbGO75q9Pf+tOgMAAAAAAAAA AAAAAAAAAAAAPnYIwN4dpAAIwwAQjPj/N+upUEPS3kRkBqRBRKlXwRW1+LcqWtFdc6V5XkdYYvyM 5oxnxKKau2ftYhZHsY45pnN5ntdqz917EL0AAAAAAADgC7qgQxeByOGI1Xe4iD5ssYtbrAIX+R5d VCMfq/3u9g8AAAAAAAAAAAAAAAAAAAAAvOgWgL07SAEYhIEAqP9/c6Gnwjao9Sh0BiQhiO1dcIVa /E8++tJjliEWuS9rBlpkyEX2s2+uHtR5zhjV3t7BFtegr8EW7WMGAAAAAAAAp1uFWeRsJ9yihk7M 6u5anZv3hqM7x/zP2gMAAAAAAAAAAAAAAAAAAAAAh7kFYO/OUQAEgigKive/smLU0HxmCRWsAnFo xSUWfKIW/9GDFbvzSg9d1D4jFjVbOWOdP9HJ+9R5PWZxDNajoMUoZpHELQAAAAAAAPiqXeAhgxB9 Notb1Pe8DFn0mEWfX3FsFbe4B9dfbfncs3fLOQAAAAAAAAAAAAAAAAAAAADwgkcA9u4dBUAYCKBg 9P531mphDZvVTpGZJj8UrQWfqMW/rMIVXdAifgCzTfN8Vo0Rt3gauagiFnkd1+7jGs8YaS+ebY5Z 5PVI+6PYnwlcAAAAAAAA8AVduOG4mXdBiydxi2pcxSuqs3zv7htj955V4AIAAAAAAAAAAAAAAAAA AAAAeNkpAHt3kAIgCIRhtPvfOYoWQz+DiJtA6L2NMkl1Aj9Ri3/q8Yqa9ZhFncnwRA9Z5AU1z+w8 3hhFvrvO53fzcp0es8jQRa2zkEV/vkLQAgAAAAAAgF2sRhxmsYgv4xbXYD+b5Tr6r74HAAAAAAAA AAAAAAAAAAAAADZ0C8DeHaQACMMAEOz//6x4CoSQaG8KzkAxrSj9wYpa/FvEKrqgRZzHPocs8rsc ulhlrhGL/Mz/yXepEYturWZeD/PdGQAAAAAAAHzJFHqoIYt8PgUtYn82cxef2IlWHM1305ruvROz ELwAAAAAAAAAAAAAAAAAAAAAgJddArB3xyYAwzAUBbX/zoGUgY9sqwok3DUywuABXDxRi//LYMUq 6pABigxedIGLblbsrnpiGBnFWEUtTiGLDFd0cYuKOwAAAAAAAPBF08DFLmiRf31dfKILXOxCFqeZ 70/O04iF2AUAAAAAAAAAAAAAAAAAAAAAvOQWgL07SAEQBAIoavc/dK0GZJwmahPUeyCBItla6Ita /EcOWsw/etnS+p7mI1Ax7+kCF7G3eo6xxi3m812FLM7CFvkdQhYAAAAAAAB8TXVfl+e6yEU34p6v ilM8DVl0EYu73wkAAAAAAAAAAAAAAAAAAAAAvOAQgL07SAEQhgEgqP9/s9RTMYSYXEVmLk0Khf5g RS2IcsxipTnaEYs45/M6noBFDFlsOW5xhvspYlGFLPIubAEAAAAAAMCfdLGHKWiR9ylwUe1d6OLt bfeHagcAAAAAAAAAAAAAAAAAAAAAPuQWgL07SQEYBKIo6P0PHbJqkE/HDKuEVK20FfQGT9TifzIs kSGL0ezzrGZHYYu6P+9LF7LIcEX+8W7YYpzMAQAAAAAA4Iu68EMXspjPVgGJrVlfDVysAhb51pNo hcgFAAAAAAAAAAAAAAAAAAAAALzALgB795IDIAgDUBC9/5mNG01qA4Wl0Zkdn0C4AE/U4ntyECLO 9YIWVfih+igmRixi2OKOTexpnO/a2zNKsRV7R1GLNpgDAAAAAACAP1gJWuT1WXhiFrWoYhbHdW6M Zazc33sTAAAAAAAAAAAAAAAAAAAAAPACpwDs3TEKgDAMQNHg/a+suFisoVG6uPS9pSkUSk7wRS3W NIpbRNxBiSjuWYtWtHO73uegRR+62OMZrsjBiipg8RWxELcAAAAAAABgFVUwIr+ZiVq0+zGYZyIW /fz2V7XP204AAAAAAAAAAAAAAAAAAAAAwM9OAdi7oxQAQhCAgt7/1H0FIeZufwUzEGge4olasAYu 5nwStljlyEV+OWQRP/Yo7pFu1VztAAAAAAAA8KqvGMRJ1KL620UpushFN3cRi91dxAIAAAAAAAAA AAAAAAAAAAAALjMEYO8OUgCEYSAARv//aBEUohhte/CgM5c0WfqGVWrxH7mwIs89iziWQPQUW6zZ XLynbe8ptIiGGY07AAAAAAAAfNFTGcRVgUW+V7dzXmWtf+72EYovAAAAAAAAAAAAAAAAAAAAAOBF iwDs3TEKwCAMBdDc/86V4lAqEoN0Kch7k0kUsjt8oRaMqnCLLNjiCbDosxZvKMV47q7YC7SIqVf1 5/mqBgAAAAAAgNNk/3arO1+CLeY6m7WNd6s627vaFwAAAAAAAAAAAAAAAAAAAAD4yS0Ae3eQAiAI RVH073/VESHE74k5izhnEqmoK/CKWvzT+cBLijuM8f7tcxXWVT3DFilgMUIX9z37Gf3sFLeoMCZq AQAAAAAAAJfdsEVavxO2WP2/3W92HwAAAAAAAAAAAAAAAAAAAADggw4B2LtjGwBAEACC7D+1lYkh iFrZ3HWiMWzwohasusjFVIUtbkIXscxyuCLPIgQtAAAAAAAA4OQ1bJHf7IIT1d3ruft/t3e1IwAA AAAAAAAAAAAAAAAAAADw0RCAvTtIARiEASDY/7/aUyGEBEVEKJ25CEbUH6yoxf/EWEVc4/wpZlXI 4p3nEEYXs6j28vunYxZCFwAAAAAAAHzdLPKQQxWzeRWV2I1bdGe6u7q/rYQsxC4AAAAAAAAAAAAA AAAAAAAA4LIhAHt3bAMwCENRcP+tqSy5MPqQJlJy12EhYAKeqMW/pbBFmcIWNd99PNNDFn22O+82 ZnESuwAAAAAAAICvSvGKtGeKSUxhir5+Okv3pTcDAAAAAAAAAAAAAAAAAAAAAC9ZArB3xygAgzAA RZv7H9pOtqAm4tKhvLeJgRxA8Edr/gT5i4ip6VBFHlaBiHG+Ck3ENYcrYjO723sashCxAAAAAAAA gFcWjDiNW/RzFqLIYhbZ3nG+mqs89965AQAAAAAAAAAAAAAAAAAAAOAbtwDs3UEKABAQQNH731op G5kMStF7G6E4wCy+qMVHFqMW/f1u2KKtmfPZe9H70T5L/AIAAAAAAIBXnQx0dyMXUYBiFLOYnY/+ Owpa1I05NwAAAAAAAAAAAAAAAAAAAABcUQRg7w5SAIRhIABa8P9vFg9CiRqNUFSYOZWE0r5gd377 Awy1JrlkhQ79fjvHO2dpMG3ah83Et/rZ0S7OW5hnSTSVogqlFgAAAAAAAPxVpb2hUgyRlVzcKaV4 srt6FwAAAAAAAAAAAAAAAAAAAAD4mEUA9u4gBWAYBAIg/v/R6d0m2xRKD2HmqobcBbfGcCfkFFXT 7IadQIceLJFme0hF76lQW82lP87eTwRYAAAAAAAAcLo34RVPM18GXaT6qrazsL712HMDAAAAAAAA AAAAAAAAAAAAwD8uAdi7cxsAQBgIgv13jeT8jCEgQDMZfwEEK2rxkRC1qKXJ8TBOZydxi9O7pmMA AAAAAABgZhe4OIldpJBFt6d77ypoUZP+uQEAAAAAAAAAAAAAAAAAAADgiSUAe3eQAiAMAwHQgP9/ s3gQpMbW9qBYZm5tQsgLsuvXC/CK/aJLKxjiuPoSp3ck/2V/JpbrMZrarLtdsrlPCMEAAAAAAABg Vj1pDiOhET2BF63eWl0qBQAAAAAAAAAAAAAAAAAAAAD8wCYAe3eOAgAIAwGQ/P/RWguRqIiFzFQe W9gH3GjNXyG/iCi7HE5LIap9dj5br7xpNw8AAAAAAACMqkKKlWx2v1N6kWWulHKYcwMAAAAAAAAA AAAAAAAAAADAG10A9u4cBQAQBgLg/38t2IlgDsFCZkqNi32KVWrxkUSpxRyrRAZnlfKJbDFG9T8A AAAAAADArrMIjgooTpk3bzN566U9NwAAAAAAAAAAAAAAAAAAAAA8MQRg745NAACBGADuv7VgYSeG IBZy1/pmgRQxavGRcNRinjbxQUaS2/wzZgEAAAAAAACdUyG8e0+K5GS44uqYxTrScwMAAAAAAAAA AAAAAAAAAADAE0MA9u7UCAAYBAJg/13HoWI4mIjMrmR4CkCcUIuPNEItaiQ9Nail+wEAAAAAAIC5 9EHcCazYvHFv9OcGAAAAAAAAAAAAAAAAAAAAgCeOAOzduwoAIAgFUIL+/5ubgoaSHpDLOaMOugvX mr0AqXrSy+kTiTEhpkxqu1ZzJdAAAAAAAADAf9Gd7rb3MhMAAAAAAAAAAAAAAAAAAAAASNYEYO+O TQCAQSgKkv2XDuksgqDYCHetfBzhiVrw/CIVnW10klvcVv8BAAAAAAAAsyphiakIhZgFAAAAAAAA AAAAAAAAAAAAACxwBWDvjk0AAEAYCO6/tb1gFQSFuwGyQIoXtaBLAhfTDgAAAAAAAHDb9r/nPwQA AAAAAAAAAAAAAAAAAACAh0oAAdi7gxIAABAGgP1bW0Bk4Eu5K7AAg82pBZNuWGZzdJFmAAAAAAAA AHfpAAEAAAAAAAAAAAAAAAAAAADgiRKAvTs4AQAAYSC2/9aOUAQfQpNB7kwt2EoBmuvpBQAAAAAA APCPcQUAAAAAAAAAAAAAAAAAAAAAFBgB2LuDIgAAGIRh/l1PAzf4JUJaUwvaVvEaswwAAAAAAADI GE8AAAAAAAAAAAAAAAAAAAAAAC8nADt3TAMAAIAAaPYPrbcdIAhpPSYAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAC8CcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzd gQAAAACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSS WgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAA AAAAAAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABM ArB3BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5g hRJJagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAwCcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACA IH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAA AAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMArB3BwIA AAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJagEA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCcDe HQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACAIH/rAVYo kaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA JIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMArB3BwIAAAAAgvyt B1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJagEAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCcDeHQgAAAAA CPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACAIH/rAVYokaQWAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJIAA7N2B AAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMArB3BwIAAAAAgvytB1ihRJJa AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJagEAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwC sHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCcDeHQgAAAAACPK3HmCF EklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACAIH/rAVYokaQWAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJIAA7N2BAAAAAIAg f+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMArB3BwIAAAAAgvytB1ihRJJaAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJagEAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAA AACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCcDeHQgAAAAACPK3HmCFEklqAQAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4d CAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiR pBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMArB3BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAk gADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0H WKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI 8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAABMArB3BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEA AAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAwCSAAOzdgQAAAACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKw dwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUS SWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAABMArB3BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA MAnA3h0IAAAAAAjytx5ghRJJagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/ 6wFWKJGkFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAwCcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAwCSAAOzdgQAAAACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAA AIL8rQdYoUSSWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAA AAAAAAAAAAAAAAAAAAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAABMArB3BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0I AAAAAAjytx5ghRJJagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGk FgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAwCcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSA AOzdgQAAAACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdY oUSSWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAA AAAAAAAAAAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AABMArB3BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjy tx5ghRJJagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAwCcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAA AACAIH/rAVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAA AAAAAAAAAADAJIAA7N2BAAAAAIAgf+sBViiRpBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMArB3 BwIAAAAAgvytB1ihRJJaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAnA3h0IAAAAAAjytx5ghRJJ agEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAkgADs3YEAAAAAgCB/6wFWKJGkFgAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAEwCsHcHAgAAAACC/K0HWKFEkloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw CcDeHQgAAAAACPK3HmCFEklqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCSAAOzdgQAAAACAIH/r AVYokaQWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAKwdwcCAAAAAIL8rQdYoUSSWgAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAADAJwN4dCAAAAAAI8rceYIUSSWoBAAAAAAAAAAAAAAAAAAAAAAAAAAAA AADAJIAAAwAfQ0TgmPenEQAAAABJRU5ErkJggg== "
+         id="image20717"
+         x="105.37292"
+         y="56.097622" />
+      <text
+         id="text22112"
+         y="65.034897"
+         x="149.03789"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         xml:space="preserve"><tspan
+           style="stroke-width:0.26458332px"
+           y="65.034897"
+           x="149.03789"
+           id="tspan22110"
+           sodipodi:role="line">.a / .so</tspan></text>
+      <text
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         x="186.46439"
+         y="64.873085"
+         id="text22207"><tspan
+           sodipodi:role="line"
+           id="tspan22205"
+           x="186.46439"
+           y="64.873085"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:monospace;-inkscape-font-specification:monospace;stroke-width:0.26458332px">amici::runAmiciSimulation(...)</tspan></text>
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker22465)"
+         d="m 172.5999,63.621046 h 10.83586"
+         id="path22461"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="cc" />
+      <path
+         sodipodi:nodetypes="cc"
+         inkscape:connector-curvature="0"
+         id="path23223"
+         d="M 96.399857,63.621047 H 136.86905"
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker23227)" />
+      <g
+         transform="matrix(0.03846954,0,0,0.03846954,80.975678,56.588143)"
+         id="g12153-2">
+        <path
+           style="fill:#00599c"
+           inkscape:connector-curvature="0"
+           d="M 302.107,258.262 C 304.508,254.103 306,249.417 306,245.209 V 99.14 c 0,-4.208 -1.49,-8.893 -3.892,-13.052 L 153,172.175 Z"
+           id="path12119-9" />
+        <path
+           style="fill:#004482"
+           inkscape:connector-curvature="0"
+           d="m 166.25,341.193 126.5,-73.034 c 3.644,-2.104 6.956,-5.737 9.357,-9.897 L 153,172.175 3.893,258.263 c 2.401,4.159 5.714,7.793 9.357,9.896 l 126.5,73.034 c 7.287,4.208 19.213,4.208 26.5,0 z"
+           id="path12121-2" />
+        <path
+           style="fill:#659ad2"
+           inkscape:connector-curvature="0"
+           d="m 302.108,86.087 c -2.402,-4.16 -5.715,-7.793 -9.358,-9.897 L 166.25,3.156 c -7.287,-4.208 -19.213,-4.208 -26.5,0 L 13.25,76.19 C 5.962,80.397 0,90.725 0,99.14 v 146.069 c 0,4.208 1.491,8.894 3.893,13.053 L 153,172.175 Z"
+           id="path12123-7" />
+        <g
+           id="g12127-8">
+          <path
+             style="fill:#ffffff"
+             inkscape:connector-curvature="0"
+             d="m 153,274.175 c -56.243,0 -102,-45.757 -102,-102 0,-56.243 45.757,-102 102,-102 36.292,0 70.139,19.53 88.331,50.968 l -44.143,25.544 C 188.083,130.951 171.15,121.175 153,121.175 c -28.122,0 -51,22.878 -51,51 0,28.121 22.878,51 51,51 18.152,0 35.085,-9.776 44.191,-25.515 l 44.143,25.543 c -18.192,31.441 -52.04,50.972 -88.334,50.972 z"
+             id="path12125-6" />
+        </g>
+        <g
+           id="g12131-8">
+          <polygon
+             style="fill:#ffffff"
+             points="232.334,155.175 232.334,166.508 221,166.508 221,177.841 232.334,177.841 232.334,189.175 243.666,189.175 243.666,177.841 255,177.841 255,166.508 243.666,166.508 243.666,155.175 "
+             id="polygon12129-8" />
+        </g>
+        <g
+           id="g12135-7">
+          <polygon
+             style="fill:#ffffff"
+             points="274.834,155.175 274.834,166.508 263.5,166.508 263.5,177.841 274.834,177.841 274.834,189.175 286.166,189.175 286.166,177.841 297.5,177.841 297.5,166.508 286.166,166.508 286.166,155.175 "
+             id="polygon12133-4" />
+        </g>
+      </g>
+    </g>
+    <g
+       id="g28045">
+      <rect
+         style="opacity:0.79018399;fill:#f2f2f2;fill-opacity:1;stroke:#f9f9f9;stroke-width:0.19996412;stroke-linecap:round;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:0.59989232, 0.59989232;stroke-dashoffset:0;stroke-opacity:1"
+         id="rect25367"
+         width="253.77472"
+         height="25.000847"
+         x="8.8035564"
+         y="81.323578"
+         ry="4.95432" />
+      <text
+         id="text12584"
+         y="87.52021"
+         x="55.99157"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         xml:space="preserve"><tspan
+           style="text-align:center;text-anchor:middle;stroke-width:0.26458332px"
+           y="87.52021"
+           x="56.541924"
+           id="tspan12582"
+           sodipodi:role="line">Symbolic Math </tspan><tspan
+           id="tspan12586"
+           style="text-align:center;text-anchor:middle;stroke-width:0.26458332px"
+           y="92.481148"
+           x="55.99157"
+           sodipodi:role="line">Toolbox</tspan><tspan
+           id="tspan20647"
+           style="text-align:center;text-anchor:middle;stroke-width:0.26458332px"
+           y="97.442085"
+           x="55.99157"
+           sodipodi:role="line">Matlab &lt; R2018a</tspan></text>
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker20369)"
+         d="M 37.700158,93.382046 H 76.581827"
+         id="path20365"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="cc" />
+      <g
+         transform="translate(-0.566964,-0.91629448)"
+         id="g22773">
+        <image
+           y="93.018463"
+           x="16.722965"
+           id="image12579"
+           xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABHNCSVQICAgIfAhkiAAADwpJREFU aIG9mn+wXVV1x79r7bPvvef+ej/yXkJ+EX4IWAMBQaUoikLHikptZXSUap1aaq2dcYrTGVq1rU61 /mqn1BlEjEpV2g4FURSq+GPAQJQKUkFSQDGEhISEJO+9vF/3vnP2/q7+sc9LQhIez5h2v7lz95y9 z7177fPZa33Xuk+wQLvh2/davwyQQ64bgGbe2Nob23PRLz9z1W/9zgf/4tZNsftDK4rVUo3LQXMP vR84cNEMe95xyXmjC63jqNvnvnqXmVm01A5+j2Zmp178V7ZxDeyJaz5rh44trs8YY7SbvvcTu+0H P11yNGvUZx05513L0/4BpIGM+98B4N13TPDEb30ML73rFdz611cwxDQ7xggzQ4zxiH0yIgaiDCX6 cwHFXMBZp63GbBH33HzH/cPHzoBnzCEAVQBQdfrkdNDPf/hjegEc4vKarn798frge/8cAqjq/Dw9 pA8FARNVUShE4VQUmWC400QRSzjo3tt/9NDIMTRAAICAgDSm5YBrr7qfL3/wRq5ZdRzCHDlwzjCf +tIXAYAmQgBg1Q70hVAC6RqdCARCJ4o895yc7PPcM07CxGRv9+0bH1p6jAw40LJMAAguvOa/IE88 jJPGH8fw0jZslnDLFd1WE9tv/cYCH2j7v87MABhEBRCBdw7RIpYt6eBFa9dgbHp21+0bF/cknsMA AxIBAKiv+ofv4o5NO3Tdxi/qaDvX1kADbluh4kwHVg3iic9dqwCUPBghHgEnVRGFCNSJQUWVFAWA k1aM4OzTjsfEdG/3YnBa0ACVhNCbr70H8s4b+fC9P8HpM1u54uEN7LQ7bLYEfEoICjvL2xi7awMB UJ3AjDQjSd2PE0lYukgAMDOKCESFThN6EOGpa5bxZWeejKnpud23bnhg2VEb8PKzn4d1V/9M/vP+ x3DO9jtx+mP3oL7pB1jWydGs15A3FOWYwEpBY9ghbzex7eabIQDI9BKZfwlEBJURMDNI2iDQrPJ3 htn+HJ7euw/BDC84YRlEdOcN37n3Wc9EtpAB//S3n4L//kZ5Wc3gpvbpjhdfghO/82kdHOkgb3j4 msJmoKQh6zjkg4O69QvXYPUb3whAKmgM5Hx/P4/P2EAFtNtq4PK/+woG27l22jnqmaKMRN6o4ZSV S3fdcudPj3vDK8/atSgDTvnE/R9f0apf+ciTj2Jo302U3rjOja6i3/GormjWWM8ytBsOmRdlH0QG aFO0NdDgtrvvRgRUM6XFCCQSaTSIqhpJVPyTpHOqpPHSi87GW17zYnUihBkCobO9OU71+vj5lqd1 1/jkThwhqO/fjZd8+oGXn/3pnz3w2usesdVDjSs9CwyNLuXABz4PNziKnWdfjNX/8z0M5TU0Mo88 d8icgCXAAkBuaLUc8uFhbF5/LRQAjaAZGA0EEBlBCBgjIg0GQSiJCKJec3AVTjEajOlap1nHRec+ H/25Eh+8+utnHWbA6R/6/p9cdtMOWzHQ2LCina2LMERGODOwLLQeCu1feR2GNt6oq5oejcxro5Zp q+E0cwIrTSVC4QX1dqb1bke3rv8MAGikKEmQpiGYxkCUMWiIpkUZURSlFiGgnAva6wWd7Qf05grt FUGLUKIMUWO0BKIBu8YnD6NFH/rQRdf+/K6vb5DBpQjiEAKJADpGKMDpxiB3feVTOLm3mwMNjzzL 2M49W3lG9RXiJWgK1LqOebPG/pYt2Lf9SWotIyNAGA1kMMIIBkaaRUSCNKCMxhADAwNCmfplNJQh MlYeC0fiZx6h+/75PRd87f1vuxSNFiA19RbhEREbTTx017ex9sFbsXIgR555NBoZuk1Fq+GgmcAM AAyOfWQyjhb6aA4MYMs1V0MABIakhUIEAxFjBGCIEUkXxVjpLIKRoKXx1BfYkbXs4WcAm267+dtv XSkz2x7dO9RdovtKww/v+J6+5JaP6IlLB5HXatpueAy16jrQybTb9CrOAIHK5A4dW34eJt7+CS1e /Tr1M5N46rr16gCFagpezqWTq6qAqggggEo1blU/HXTR5HapYlzQ1R/mhe758OtH7jn+Fedh9Pk/ /+67X7Tna7cArayObr3G4W5dRwczDnfraLYF8FBMPMnpt1+PFevO1zpAfdUbsPnSP9RHXnQmt3/z Foxc8gZFf46kgDAVAwUCgmpiVDOlgWYCEagFYzSDiikpZKUGnvsJHNy2bvgRgFrrde/Ab7/ncnRj iZUjTT3xuByrlrV06RKvvmOqszsw9ZYv6bJ152uYnkFvpqfTs31dvm4d1j62VR/+8AcVAIoyaAil sggIIWgR5jSEiFBQixAQYlCy1LIMCIxqjDpvkHDhYLtgINv045/g8qvX8+4f36gnnTXIWp6pKGkq kOmdmHjt3+gJ51zAUASIqGbe0Sgopmd01fGr6W78Jqaf3K7N0VEyGMyomcvIdKw1ilFF1ETIwiDq VAyMluIHCFIW2OiFBgAAKXnRtX95OVpnzMGdBsgqhavvRvzNN2HshX8AYcoWxAxmAgoBcZjrF1iy ajVqg0NgMIgA0QwUQkwQLfl6EYFYkheQpFJBS29CzCdVR/UE5pu76H1wd96gyJvgrp06Pnoh7Pc+ Djz2SxRLV2lZRBShgLeo9Dni9Bhid4litodQBDjv1GCIIUANGkgAAlrUpI2gIYT5papFgyFWB/6A AUcyZVH5QD64AkXrBbTeZkysfT9H37aea1ogAPjM03tP7zx8vc36+GYOf2wlarNPM8vbdN7Be0/v MzrJIM7Re0/nHTJxdJmHc47OObrMIVNHKKiqIFMwX2htizJACPDML2D2gsex8pw/givDgV0xwKq/ WBM0rvtdicedjua/XQarASZpHCYwsQoZgURDFENKMwVGIHkn2b/bAlRY/ZoGlEWBwdFVunPn09ix Y7cyBr3vgV8mD1MUWvQLDRTgvpuVMxMy+ebPIk7tVb3t77XMOijmCp0rCi2KkORDUWg/FAhF0CIU CMWcBgYtiwIxBI2WMKJQ7blylsUYoKqIIXD18iEMDXYpqjxn3ckJIe/p6zVq3kLrlveiuOx6YmQd ype+01oP/rtl+7bBNZoJM+/gvaNWyDnvmfkMPqsnhHwN2exOjvzHZSaZAyDEsUAIMBgNzWYdtZoD CVj1uaw+pvHdjyKuOc/CqRfCYoni3D+1ctlaDH7pdWDTA1bhZgJYCk8yj40wjdda6N7+fimOPy8l PAR4sJKww3FalAExEgLoY48/hT179ykZ9f4HH1cAKItC54q+ytZ7MfXqj0oxPZUUZq+vk6/5pFgI qN/2Ee1pU4uiSMiFoKEIKEOhRVGgLIIWhGLrffCPb5CJ868UCyVoPCSQHa6LFo0QFBwebKNeb9Cp 4wvPOOkAQpnn7GXXI1uyhr6W0TuX8OiMcPzd30Hrzk+iVkzQ1fNqfsbMZ3A+o88yZDVP7Q5z6U2/ j5nzrzAX5wh1ENUqMV1gbYsxYF49Dgy00G7WUhCyCqFKjVpkwspQeRSkYOS6mH7jtTZ81RnCVieh IwKDQVglzNpA+8frYWUfUxd+wIxl2m1yv1ear7kelQEhRhiibtn6NPaMJYR++tCWAwj1Cy1iqLxN X4sQUBTJ85T9PqbWvlnKzkrpfvXP0JeGFkVCp6gQ6mVeB751pe6+9Mvg1LhGmsYYYCIqx8ILiQpU HLvtJmoVQmeuPeEgL+QrbGr0vl55G8/kZTzq7HHsffew899fRr5vC7Nag97X4H1G1xzEyMZ/pOWD CM97JVzmqCKscn/SjkkgS9pleLCdEOKBojnFDsImlUfMgGjJy8x7HDfTx+533Y3ha1+mCGNIUkLA mkPr+x/V3W/6V2pvGnIw8qkKueDaFueFGGAx6pbtu/H0noTQA5sqL9SfR6jyMHN9LYsCZVFoEQoN ZcKp7M/q9JLfwOzzLsbAly/TOfUopKGD178V/VXnYnb0DA1lH2UIGkmNMVYIyTEIZJJBM8dmvYZG 3qCo4xkvOJ4AEjZ1T5/5Cps6nfeoeV9pHl9pIc96mMLk2/+FtcltNnjf5+DynPnD38C+t6yn5xyd 98i8/5UQWpQapRAIiiVL2nDqUTIILTOgwsYAMyZsqu8z4BlPf76rMz3s/uMNNnLNedJ4+Bsyd9pr Qb8UCJP7K3qH3vNrGxBLg2jAjl1jyPM6Blq5bXrsiXkthFQiCfCWRFkIRVWBBooipFIigLIIMJtF aK/E5Avfge4Pr5LtVzwKm51CiEVVbkyBEwBU5TnNWJQBmilURBuNGhq1hopzWPv81dj0yDZ479Wg MDN475UAIAbnvQrSgfbeV3X11HdhGrMXfQgz518Bl9UhRkVpcM4BgAIRqqn/HAQtzgAjEcU41Oko 1GhmSEkJNCkWQ/rdRegIUFWdCklAnSjEmBJcUYhQAVjsKbVGBVUgVBU4VaWBTglR1cjA/WILOKIW WtwZMINQNBqBKCpCgA5mhkd/8eRhxdqj6B9xfGR0SOcr2M/WFmVARSJV049EiCk6Dw511CwVbib2 zejAQIsCwcS+aR3oNkkIpiZntN3JCQDTUz1ttXOaAUVZaigC8lYDAuHsTE/zdh0g2Jud01pegwgZ k2R5Vm+5uENMQjVlS2JEFAFCxJLBVgpSouh2czh1gAq6nRxwCjHDQDdPYpDEQLcN59JvBAJBtEiF qDjFQCenaiqExXaT6rTKnY9BIIMIQFExIlJUErcakpLTvWOTum3HOKCi4+PTunnbLqiYhhD1kUe3 I4SoqqqP/GIbxiamVQDd9tRe7Ng5oeoUO3eO6+atu1Rchr3jU/r49t0KMRioz7XGRT0BADAhjaIw MJU8ACE0Gllv1LA8r2sMZL2WYcWyYY3ByGg4Yc1SFQGLEHHKicuVZowkRoY6CoBlSe12W+x0mgih 1HazwVajhhDT4X7GIT5aA4wEoFVNB6DI/mxJYPD1LCXnFuHrGYSpBqSZoOGyKsABLhMIU0E4q7nq HkOWpeqJxfncozq4h2ZkR2tAjAaoqdAQARUzxEq1GaBgWqHBtEoQYJKupwoQFAYkdS8pVqRp835e sT+uV8XctHidD2q/lgHLRgYWM+3/vB0poVnQgFazji9+feOz/LvJ/29rNxtoNmq1Q68vZEDR68+9 fmKmJ7JAdenIA0wVrWPULBHqv3DLxs2Hjv0v9Gvd+ZwIHGYAAAAASUVORK5CYII= "
+           preserveAspectRatio="none"
+           height="12.7"
+           width="12.7" />
+        <g
+           transform="matrix(0.26458333,0,0,0.26458333,14.746444,82.868887)"
+           style="overflow:visible"
+           id="g20553">
+          <switch
+             id="switch20551">
+            <foreignObject
+               height="1"
+               width="1"
+               y="0"
+               x="0"
+               requiredExtensions="http://ns.adobe.com/AdobeIllustrator/10.0/" />
+            <g
+               id="g20549"
+               i:extraneous="self">
+              <linearGradient
+                 y2="34.067001"
+                 x2="34.244301"
+                 y1="-6.6968002"
+                 x1="33.799301"
+                 gradientUnits="userSpaceOnUse"
+                 id="linearGradient20447">
+                <stop
+                   id="stop20437"
+                   style="stop-color:#FFFFFF"
+                   offset="0" />
+                <stop
+                   id="stop20439"
+                   style="stop-color:#FAFAFB"
+                   offset="0.2236" />
+                <stop
+                   id="stop20441"
+                   style="stop-color:#EBEDEF"
+                   offset="0.4981" />
+                <stop
+                   id="stop20443"
+                   style="stop-color:#D2D7DC"
+                   offset="0.798" />
+                <stop
+                   id="stop20445"
+                   style="stop-color:#BDC5CC"
+                   offset="1" />
+              </linearGradient>
+              <path
+                 id="path20449"
+                 d="m 67.942,25.446 c 0,2.18 -1.813,3.947 -4.049,3.947 H 4.173 c -2.236,0 -4.048,-1.767 -4.048,-3.947 V 4.073 c 0,-2.181 1.812,-3.948 4.048,-3.948 h 59.72 c 2.236,0 4.049,1.767 4.049,3.948 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:url(#linearGradient20555);stroke:#231f20;stroke-width:0.25" />
+              <path
+                 id="path20451"
+                 d="m 48.309,4.939 h -0.065 l -6.685,21.522 h -1.37 L 33.504,4.939 H 33.439 V 26.461 H 32.07 V 3.179 h 2.217 l 6.62,20.936 h 0.065 L 47.429,3.179 h 2.25 v 23.283 h -1.37 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:#0054a6;stroke:#0054a6;stroke-width:0.5" />
+              <path
+                 id="path20453"
+                 d="m 53.429,3.179 h 1.37 v 22.044 h 9.75 v 1.239 h -11.12 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:#0054a6;stroke:#0054a6;stroke-width:0.5" />
+              <g
+                 id="g20541">
+                <g
+                   id="g20483">
+                  <radialGradient
+                     gradientUnits="userSpaceOnUse"
+                     gradientTransform="matrix(1.0223,0,0,0.9987,120.8042,52.6105)"
+                     r="20.6565"
+                     cy="-41.148899"
+                     cx="-104.4189"
+                     id="radialGradient20479">
+                    <stop
+                       id="stop20455"
+                       style="stop-color:#BCE6FB"
+                       offset="0" />
+                    <stop
+                       id="stop20457"
+                       style="stop-color:#B7E4FB"
+                       offset="0.042" />
+                    <stop
+                       id="stop20459"
+                       style="stop-color:#A8E0FA"
+                       offset="0.0935" />
+                    <stop
+                       id="stop20461"
+                       style="stop-color:#8FD9F8"
+                       offset="0.1501" />
+                    <stop
+                       id="stop20463"
+                       style="stop-color:#6CCFF6"
+                       offset="0.2099" />
+                    <stop
+                       id="stop20465"
+                       style="stop-color:#6ACEF6"
+                       offset="0.2135" />
+                    <stop
+                       id="stop20467"
+                       style="stop-color:#65C9F3"
+                       offset="0.3103" />
+                    <stop
+                       id="stop20469"
+                       style="stop-color:#56BCEB"
+                       offset="0.4293" />
+                    <stop
+                       id="stop20471"
+                       style="stop-color:#3DA6DD"
+                       offset="0.5598" />
+                    <stop
+                       id="stop20473"
+                       style="stop-color:#1A88CA"
+                       offset="0.6976" />
+                    <stop
+                       id="stop20475"
+                       style="stop-color:#0071BC"
+                       offset="0.7865" />
+                    <stop
+                       id="stop20477"
+                       style="stop-color:#0054A6"
+                       offset="1" />
+                  </radialGradient>
+                  <path
+                     id="path20481"
+                     d="M 27.574,14.861 C 27.555,14.231 27.68,13.8 28.037,13.325 29.006,12.036 29.445,10.366 29.151,8.583 28.49,5.056 25.757,2.447 22.109,1.802 20.478,1.554 18.962,1.792 17.673,2.589 c -1.325,0.818 -2.786,2.605 -2.786,5.638 0,1.589 -0.391,2.856 -1.302,3.832 -0.741,0.621 -1.823,1.268 -3.474,1.278 -2.78,0.018 -4.216,-2.144 -3.93,-4.321 0.387,-2.374 2.335,-4.189 4.796,-4.536 0.833,-0.091 1.615,0.046 2.3,0.306 0.54,0.204 0.974,-0.054 1.251,-0.459 0.361,-0.528 0.31,-1.401 -0.765,-1.932 -1.146,-0.567 -2.472,-0.692 -3.87,-0.48 -3.647,0.646 -6.379,3.254 -7.04,6.781 -0.294,1.783 0.153,3.406 1.114,4.742 1.519,2.113 3.861,2.704 5.316,2.976 3.198,0.599 4.592,2.335 4.769,4.804 0.1,2.442 -1.715,3.773 -3.835,3.401 C 8.114,24.193 6.468,22.456 6.05,20.306 5.889,19.366 6.083,18.516 6.458,17.808 6.678,17.392 6.343,16.915 5.667,16.545 4.954,16.155 4.278,16.055 3.996,16.434 c -0.814,1.093 -1.142,2.78 -0.816,4.432 0.749,3.375 3.337,5.906 6.813,6.645 1.6,0.31 2.865,-0.017 4.36,-0.678 0.863,-0.382 2.259,-0.348 3.353,0.13 1.272,0.556 2.724,0.942 4.324,0.686 3.582,-0.64 6.301,-3.164 7.038,-6.639 0.317,-1.691 -0.105,-3.202 -0.986,-4.579 -0.221,-0.348 -0.508,-0.768 -0.508,-1.57 z m -1.472,5.488 c -0.33,2.276 -2.185,4.029 -4.547,4.362 -2.353,0.263 -4.342,-1.222 -4.345,-3.732 0.077,-2.515 2.347,-4.731 4.99,-4.834 2.604,-0.028 4.161,1.906 3.902,4.204 z m -3.334,-7.877 c -2.613,-0.1 -4.888,-2.316 -4.987,-4.803 -0.019,-2.46 1.956,-3.898 4.307,-3.643 2.332,0.329 4.179,2.053 4.544,4.307 0.296,2.248 -1.241,4.157 -3.864,4.139 z"
+                     inkscape:connector-curvature="0"
+                     style="fill:url(#radialGradient20557)" />
+                </g>
+                <radialGradient
+                   gradientUnits="userSpaceOnUse"
+                   gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+                   r="7.8785"
+                   cy="-123.4775"
+                   cx="-39.161598"
+                   id="radialGradient20509">
+                  <stop
+                     id="stop20485"
+                     style="stop-color:#BCE6FB"
+                     offset="0" />
+                  <stop
+                     id="stop20487"
+                     style="stop-color:#B7E4FB"
+                     offset="0.042" />
+                  <stop
+                     id="stop20489"
+                     style="stop-color:#A8E0FA"
+                     offset="0.0935" />
+                  <stop
+                     id="stop20491"
+                     style="stop-color:#8FD9F8"
+                     offset="0.1501" />
+                  <stop
+                     id="stop20493"
+                     style="stop-color:#6CCFF6"
+                     offset="0.2099" />
+                  <stop
+                     id="stop20495"
+                     style="stop-color:#6ACEF6"
+                     offset="0.2135" />
+                  <stop
+                     id="stop20497"
+                     style="stop-color:#65C9F3"
+                     offset="0.3103" />
+                  <stop
+                     id="stop20499"
+                     style="stop-color:#56BCEB"
+                     offset="0.4293" />
+                  <stop
+                     id="stop20501"
+                     style="stop-color:#3DA6DD"
+                     offset="0.5598" />
+                  <stop
+                     id="stop20503"
+                     style="stop-color:#1A88CA"
+                     offset="0.6976" />
+                  <stop
+                     id="stop20505"
+                     style="stop-color:#0071BC"
+                     offset="0.7865" />
+                  <stop
+                     id="stop20507"
+                     style="stop-color:#0054A6"
+                     offset="1" />
+                </radialGradient>
+                <path
+                   id="path20511"
+                   d="m 26.102,20.349 c -0.33,2.276 -2.185,4.029 -4.547,4.362 -2.353,0.263 -4.342,-1.222 -4.345,-3.732 0.077,-2.515 2.347,-4.731 4.99,-4.834 2.604,-0.028 4.161,1.906 3.902,4.204 z"
+                   inkscape:connector-curvature="0"
+                   style="fill:url(#radialGradient20559)" />
+                <radialGradient
+                   gradientUnits="userSpaceOnUse"
+                   gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+                   r="8.8347998"
+                   cy="-135.5493"
+                   cx="-38.2202"
+                   id="radialGradient20537">
+                  <stop
+                     id="stop20513"
+                     style="stop-color:#BCE6FB"
+                     offset="0" />
+                  <stop
+                     id="stop20515"
+                     style="stop-color:#B7E4FB"
+                     offset="0.042" />
+                  <stop
+                     id="stop20517"
+                     style="stop-color:#A8E0FA"
+                     offset="0.0935" />
+                  <stop
+                     id="stop20519"
+                     style="stop-color:#8FD9F8"
+                     offset="0.1501" />
+                  <stop
+                     id="stop20521"
+                     style="stop-color:#6CCFF6"
+                     offset="0.2099" />
+                  <stop
+                     id="stop20523"
+                     style="stop-color:#6ACEF6"
+                     offset="0.2135" />
+                  <stop
+                     id="stop20525"
+                     style="stop-color:#65C9F3"
+                     offset="0.3103" />
+                  <stop
+                     id="stop20527"
+                     style="stop-color:#56BCEB"
+                     offset="0.4293" />
+                  <stop
+                     id="stop20529"
+                     style="stop-color:#3DA6DD"
+                     offset="0.5598" />
+                  <stop
+                     id="stop20531"
+                     style="stop-color:#1A88CA"
+                     offset="0.6976" />
+                  <stop
+                     id="stop20533"
+                     style="stop-color:#0071BC"
+                     offset="0.7865" />
+                  <stop
+                     id="stop20535"
+                     style="stop-color:#0054A6"
+                     offset="1" />
+                </radialGradient>
+                <path
+                   id="path20539"
+                   d="m 22.768,12.472 c -2.613,-0.1 -4.888,-2.316 -4.987,-4.803 -0.019,-2.46 1.956,-3.898 4.307,-3.643 2.332,0.329 4.179,2.053 4.544,4.307 0.296,2.248 -1.241,4.157 -3.864,4.139 z"
+                   inkscape:connector-curvature="0"
+                   style="fill:url(#radialGradient20561)" />
+              </g>
+              <g
+                 id="g20547">
+                <path
+                   id="path20543"
+                   d="M 62.074,3.269 H 61.569 V 3.086 h 1.23 v 0.183 h -0.508 v 1.479 h -0.217 z"
+                   inkscape:connector-curvature="0"
+                   style="fill:#231f20" />
+                <path
+                   id="path20545"
+                   d="M 64.379,4.019 C 64.367,3.787 64.352,3.506 64.352,3.302 h -0.005 c -0.06,0.192 -0.126,0.401 -0.21,0.631 L 63.844,4.739 H 63.681 L 63.41,3.947 C 63.331,3.711 63.267,3.498 63.22,3.301 H 63.215 C 63.21,3.508 63.198,3.784 63.183,4.035 L 63.139,4.747 H 62.934 L 63.05,3.085 h 0.273 l 0.284,0.804 c 0.069,0.205 0.123,0.387 0.167,0.56 h 0.005 c 0.044,-0.167 0.104,-0.35 0.178,-0.56 l 0.296,-0.804 h 0.273 l 0.104,1.662 h -0.212 z"
+                   inkscape:connector-curvature="0"
+                   style="fill:#231f20" />
+              </g>
+            </g>
+          </switch>
+        </g>
+      </g>
+      <g
+         id="g20623"
+         transform="matrix(0.03846954,0,0,0.03846954,80.976157,86.753904)">
+        <path
+           id="path20605"
+           d="M 302.107,258.262 C 304.508,254.103 306,249.417 306,245.209 V 99.14 c 0,-4.208 -1.49,-8.893 -3.892,-13.052 L 153,172.175 Z"
+           inkscape:connector-curvature="0"
+           style="fill:#00599c" />
+        <path
+           id="path20607"
+           d="m 166.25,341.193 126.5,-73.034 c 3.644,-2.104 6.956,-5.737 9.357,-9.897 L 153,172.175 3.893,258.263 c 2.401,4.159 5.714,7.793 9.357,9.896 l 126.5,73.034 c 7.287,4.208 19.213,4.208 26.5,0 z"
+           inkscape:connector-curvature="0"
+           style="fill:#004482" />
+        <path
+           id="path20609"
+           d="m 302.108,86.087 c -2.402,-4.16 -5.715,-7.793 -9.358,-9.897 L 166.25,3.156 c -7.287,-4.208 -19.213,-4.208 -26.5,0 L 13.25,76.19 C 5.962,80.397 0,90.725 0,99.14 v 146.069 c 0,4.208 1.491,8.894 3.893,13.053 L 153,172.175 Z"
+           inkscape:connector-curvature="0"
+           style="fill:#659ad2" />
+        <g
+           id="g20613">
+          <path
+             id="path20611"
+             d="m 153,274.175 c -56.243,0 -102,-45.757 -102,-102 0,-56.243 45.757,-102 102,-102 36.292,0 70.139,19.53 88.331,50.968 l -44.143,25.544 C 188.083,130.951 171.15,121.175 153,121.175 c -28.122,0 -51,22.878 -51,51 0,28.121 22.878,51 51,51 18.152,0 35.085,-9.776 44.191,-25.515 l 44.143,25.543 c -18.192,31.441 -52.04,50.972 -88.334,50.972 z"
+             inkscape:connector-curvature="0"
+             style="fill:#ffffff" />
+        </g>
+        <g
+           id="g20617">
+          <polygon
+             id="polygon20615"
+             points="243.666,155.175 232.334,155.175 232.334,166.508 221,166.508 221,177.841 232.334,177.841 232.334,189.175 243.666,189.175 243.666,177.841 255,177.841 255,166.508 243.666,166.508 "
+             style="fill:#ffffff" />
+        </g>
+        <g
+           id="g20621">
+          <polygon
+             id="polygon20619"
+             points="286.166,155.175 274.834,155.175 274.834,166.508 263.5,166.508 263.5,177.841 274.834,177.841 274.834,189.175 286.166,189.175 286.166,177.841 297.5,177.841 297.5,166.508 286.166,166.508 "
+             style="fill:#ffffff" />
+        </g>
+      </g>
+      <g
+         transform="translate(14.405912,-4.2333335)"
+         id="g22216">
+        <image
+           y="86.603798"
+           x="-41.902004"
+           id="image12009"
+           xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA4EAAAMmCAYAAABLs4SaAAAABmJLR0QA/wD/AP+gvaeTAAAACXBI WXMAAA7DAAAOwwHHb6hkAAAAB3RJTUUH2AMYEyU4PiVEEgAAIABJREFUeNrsvVmMbNl5nbn2Pici cr5D3RpYrOJYHETZEDzAL7IsiWKSUhUlG3rRi93dpiTbaMGC0TDa9oOAhoEGGt1Gd7+0u9vwIFuU HwwDHmSJkEiJZFGyYMMPgm3AgLtttCGSNd355nAzM+LsfvjPH/vf++x9IjLvrao7rA84iMiYIzKL jHXX/6/lQggghBBCCCGEEPJ04PkREEIIIYQQQghFICGEEEIIIYQQikBCCCGEEEIIIRSBhBBCCCGE EEIeC1p+BIQQQggh4+x/4QsB3gOTCTCZoGkbtI3HxAHNYgHfLdCGDm3XwXUL+K7D6a3b+OXXf9fx 0yOEPGo4poMSQgghhBSE3w//cMBiAXzyk8B0CrQt3GKOZj5Hu5ijnc/RLOZo52doFgs0izmabi7n /9W/QuOAxgEO8QCA//2N2xSGhBCKQEIIIYSQR0b8ff/3B+zvyw8hAF0HzOfA6Sna0xO0Z2dozk7R zM/QnJ2hmZ+hPTtB+zu/g8YBrQMaAN7J3k3Tn3oj/UIA/pfvUgwSQigCCSGEEELeH+H3V/5KwGwm 455NAzgnSi2EpQB09++jvX+M9vgIk+MjtEeHaHrh1/TCT8+r+FMxqI6gR+8KGvn3P36bYpAQQhFI CCGEEPLeiL+/9JcCNjaAjQ0kIjAE4OxMjvv34e7fR3N8hPboCO3xIZqTE7Tfej0Rf21BDOp53wu/ pQg0QlAV4P/w+xSDhBCKQEIIIYSQd0f8/dzPBWxuAltbwPY2sLkpe3/Z+Cfu3wcOD+EPD9Ee3utF 4BEmv/PbA9HXWgfQuoCIo6HOnF9+GTPnf4FCkBBCEUgIIYQQ8pAF4J/7cwHPPANcuxYdwLYPTFcB eHIiAvDuXeD2bbRHh3IcH6H91rfQ9qKvNQ5gi14IWgdQ9wGROoHepWExlltz7gsSQigCCSGEEEIe jgD8s3824KWXgMuXgUuX4gioCsCTE+DoSMTfvXvA4SHc4WEUgd96fSn2EgHYC7+lO5iNgnqzE2gF oJ5Xgjn9q/+FQpAQQhFICCGEEHIx8fen/3TAJz8J7O3JsbMT9/8Acf/u3xcBeO+eiMCbN4F799Ae HKA9OsDkd//lUgBOjPizTmDj0tHQkhPos9oI+3Pojy7I6X9PIUgIoQgkhBBCCDmnAPypnwr4vu8D rlyRY3cX8D4mgC4W4gAeHwMHByIA794Frl9Hc+MGJr/51aXAy8dAJ+Y0TwT1vWB0lZFQl4nB3BEM ADoAf/n/oxAkhFAEEkIIIYSsJwB/9mfFAXzmGRGAuv9nHcDjY3H/bt8G7tyR49Yt+Nu30f7m1zDp Rd7EpU5fW0kCtUJQxaMdBy2lhNZUXhdECN6Ys0qCEPLw8PwICCGEEPJECsA/82cCPvMZ4KWXgKtX JQFU6yDaNtZAaAjM6akcJydy+XwOIHXlgKF7py6fFYBtLwBtQbwrHTYsBr14zB5z4oDnJsDf+Mhl /ss9IeSh0PIjIIQQQsgTJf7+1J8KuHIF+MEflPqHrS0RgDYEZrGIp1b83b+/3A303/zGsuh9OfJp XLsQMLDwcoFnKyFqSaGuv6M+lEcMiFER6oPc/3/9yOXw33E8lBDygNAJJIQQQsiTIwB/4icCrl0D /tgfE8dPuwC3tuRnGwajAvDsLIpAKwSR7uoFI/TUpfN5DQSGu34+OwZ7gZkb6DB0BF3/PFMH/G90 BAkhDwh3AgkhhBDyZAjAP//nA773e8Xxm82kAmJ3V9zA6VTCYGwJ/NGR7AHevAncuAFcvy7Hb/xG sgc46AREWgVhU0HtXuBSKKLsBuqoqBWaLhsfDRDHMRgR2gXgLAB/iY4gIeSC0AkkhBBCyOMvAH/u 5wI+8Qlx+65ckSCY3V0Rg02ThsEcHkr4y40bcty6JT8fHAD37xfTOq1YcwXxtvxiVegILHUG5r2B uaNonUHvhsJy5oH/42N0BAkhFIGEEEIIeRoF4M//vBTATybi9ukI6OamHNvbIgLV/SuNfx4fy+nr rxeTOl0mBIsiDuV9wJpwzJNBByOkrhAWk4lFCkFCyEXgOCghhBBCHl8B+Nf/eliKva0tGQG9dCkV gd6LwDs8lCoI6wLeuCHjoDdvAq+/vuz2GxzZ5U1lPNSWxNu+wGIoTB4Og2FIjMWOhdpS+Q7Af/uf ORpKCFkfOoGEEEIIeTwF4C/8QsB0KiOg29vA3h6wsxPdP90FDEGcv8VCdgK1/kHPn54Cr7++FGGl MU9kTl7i2rmCw4fy7eEqVRGIITHF50B5bFRHTf8mHUFCCEUgIYQQQp5oAfhX/2rAxoY4fnt7cQ/w 2jX5eWsrCsD790UAquDT8c/Dw3ioaHMxiTNP9fS9InOF3T3n6qOe9rQ4PuqG4rAqOFHpJHTA/0Uh SAihCCSEEELIEykA/9pfC8vOv7YVFdW2IvpmM3ECJ5Oo6NpWRkCvXwfeeUeO69clEObuXeCb34wi 0IgwG8jSmq7ABiOunEsFmi+kg5acP18QezVRmIfGeJNQ+n9TCBJCKAIJIYQQ8kQJwL/8lwN2d4HL l2MFxAsvAC++KJdNp2kX4NmZpH5qEMzxsRxHR3J87WtLgTXJdgBtIEs+tlkKgclFZMkJzO9Tdf7c iiMXhUZk0hEkhFAEEkIIIeTJYWMjun07OzICurcXL9vaEucPkJ0/LX63KaAqAI+Olg872AXM+voG 4S0YSfl0K4SgS3cEYcSdnh+IwopIVGdx2U8IEbF/6+MUgoQQikBCCCGEPObs/8IvBOzsiODb24u7 f00jikgdQOdkB1DdPxWBKgB1D/DrXx8IPRSElqXk5BWF4jpC0A2dRr9K/JVu5+KXusYIQzqChBCK QEIIIYQ8vgLw538+wHtx+WYzcQAvX5Zx0O3tKAa9jyEwKgD1UAF4cJCEwcAIM7sDOHFxRLRx9SqH 3D0ciL9c+I2MecLVuwPHxke9uZ+6gq0D/qcPUwgSQigCCSGEEPK4CcC/+BcDrl6VBNDnnpNjMknH Qjc3RSDaGohcBGpP4N27wLe+tXz8SbYHqLuAVmA1le7A0uWNPfVAkx8uDZaxY53VnUCMB8fkDqUK wWst8D9TCBJCKAIJIYQQ8tgIwB/5kbCsfdjeFuGn1RA7O7EKQsdAvZfT+Vycv5s3gW9/G3jzTeD2 bRGA2RgoUA5rqQms0sjn8rEqDt9S9PnsyISgd8PniS8wPaqv1ySONg54pgX+BoUgIcTQ8iMghBBC yCPLJz8Z9/329qLg8/2/Y6uacg7oOnEAdfRTDw2EuXdvOAaK8cL2/Lb2Pij8nCSIWnHno6OY3D/0 5ysSzUGqDqv0DxRC9pqcPKQL8ryX+Y2PEGKgE0gIIYSQR5L9v/AXwrL6YW9PnL8rV+TnnZ0YDGPT QI+Pxe3T4+BALrtxQ5zA118fF4GZuCoFviT3den53PlrPNA2cRTU9ZctRWHmBuYhMsAaDiWG46TI 7jtxwN9hYighhCKQEEIIIY+sAPzsZwNefjkGv2xsiBuoNRCaEqp9gPO5pIHqcXQkzt/t27IbeHKS jIECsjc38cMAmGVHYLarp0megxJ53+/+9ZepMWnDXnR803vA6W5gY4xMOx7q66KwFhADDMvnPbI9 QQf8XQpBQghFICGEEEIeOQH44z8e8If+kKgXDXwBZBR0d1eOrS0RhUoI8QBESTWN3EcrIjIB2LjU zVsKKld3/6zoGtzHuIAq8tpGBOKkPz/pf7b7gL6yD+hcvbvQXlQaaUVFLHrH/UBCCHcCCSGEEPKo cXiIZRjMZCIu4EsvySiojoBau+3sLNZCaAro3bviAv7n/yyjoL/5m8lTdIhOmQo9dc/UBWwKKaCN uZ3PRWMm6JosDEZHP604Cx0A1a9dr2H78w5xVXC5G6gvOCQnQ2Hq0l1C3+8IdgF4ZsI/MUKedugE EkIIIeSRYf9nfzbg858XoTebyemVK+LohRBdQbW7ul45zefi9h0diQC8eRN45x0RhZkAhBF7yehk Nk7pMHQGbWWEPV3u8Ol5O+LZiCto3UH7czExNB8pRZZG6oavCyinlw7cQAC/+ArdQEIoAgkhhBBC HgUB+B/+g7h/k0nc93vuOXEGr1yJqknV0cmJhL/cvi3C7/r1GAJzcDAYA1Uh1Lh0bNLnYhD1EUuL deLaPgRGR0BV7C1FX5Nd1oqmbdtUGNbqI0qC1BmFlws9VxK25v4UgoRQBBJCCCGEvL+EAPzET4jr t7Eh+4DPPy+CMIQ+WtOIwMVCnMDFIs4+No3cXq8/PR0+DWQc1NYqdNnlIRON6gAmY54ujpE6BwQb 4uLjWqI6fk2bnZrUUG/K5H2TNl+4QkhMLmpd5gwClRRRpCOpFIKEPJ1wJ5AQQggh7zv7P/MzAa+8 EtWRKp1nn43CTt1B76P4K+0C3rolp0dHg0RQYMQlMyLJu3ofYDCHHQFtPDBpjRtoHUEj8pLH7adZ u0V/AICeurjLF3IVaxYGk73BwmfrMLy963+mAiTk6YROICGEEELeXwH40z8dMJ2miZ6bm8DHPhb3 AK0tthRDZhfw8BC4c0fGQd98E/jud4F/9s/KX376kBethWhN5YMGv+jIqF7vM/3l++ubPvlz0sQe QHX1WqNdp1NgNhWRODEjoG02LmoPrY4YuIGunAIKDMvu89FRG4Cj5/8e3UBCKAIJIYQQQt5TATib SfqndgBq9cPGRuwJ3NyUy33/1WWxEAE4n4sr6Fy8XsVh5YuPL4kjc7l3WXIoTDcgsg4/NyyKt+Og 3u4JtlEULsXgRC6f9pe3lVFRXyiVB8pOJTC8vtYvSCFIyNMJx0EJIYQQ8v4RAvBv/g3wkY9ElTSd Ai+8INc1TaqMVACqCDw7A46PZfzz+vU4Cvrrv14WgW59IZikcaI+aqnuX9uIsJtOelHX9i5hG0dC 7ZipVkKEBdCZ6gfXv0VL12FQDwHEPUQ72qmTn1oTkVdNwAE+9COn/XvlXCghTxd0AgkhhBDyvrD/ pS8FbG4CP/7jckHTiPt37Rpw+bI4gDYIRlksRPjdvCnHrVty3L4tAvDwsPh8+VikqwjB3DFDQQgO HqtwLANhchcwP6a99jVuYJ4Y2hg3MBkRRersITu/bu0FQDeQEIpAQgghhJB3WwA2jQS3aB9g0wCX LokQtGmguQt4dhYP3QW8cwe4d09qIY6Pi88ZCqpwpRB0qXvoTRqot6OfhX5A56MArIrANt0L9GMj pvY1FzoEsYaITQSxuX3DsVBCnio4DkoIIYSQ957ZTI6f+in5eWdHfj49FQdwa0vGQm1SqJ6GEOsf 2lZ+Pj0VAXjrVjERFCiMgGK8EzBRj24oHmE6/DTTZtIA01ZCYGZTYGMa9wFbdfPM44ZOUkEXC6BZ yGWJCASwME/vOhnj7LrYilEa+7RiLx8NLd0ggGOhhDxN0AkkhBBCyHvK/pe+FNC2MvK5uSnhL2qZ 7exEF3CZrNLKz10X6yCOjuT8jRvxuH0b+NrXqs/rMJKaOXJZ0VIrOHLeBMLoy3dewl82Z8DGTESh CsSpcQSnE5Mm2qZrkPo4PnuuZZcghsIRGC+8H7idiE7n36cbSAhFICGEEELIQxWA2venYk/HPvf2 RBju7sZU0Ok0CsDTUxn1PDyU0c+TE7ns9DSOh44IQD9Sn1C7zt63yYrivRFm3qe7f7Ne9G1uAFsb cfdvOgNmG/K2pkYINir8THG8LxwqAJPRzyzABq6yH4jxCgnL36UQJOSJhuOghBBCCHlvcU5E3s6O HHt7ooCuXhXht7ERuwFhlIvPklZOTsQRPDgQUfhrv1Z9SnW6GsSOwLwX0HbnLXsAs7oIYFjFYF05 nwW4eA/4RgSgTQeF70dBfRbc4lLBd2bcOy29WPS3DejHQoHlGOmyEN4BzpbDY9AxnwhETQzNi+UJ IU8mdAIJIYQQ8p6w/6UvSSfg5ctxoS0Esc2uXk2X3FQJqWO4WMRS+Lt3gW9/G/jOd4C33pI9wIOD 0efuMF7xUBoFHQgl+0OhE9A6gdNpP/65EYviZ5n7t+wLzMJirJi0yaC5O5i/h8HLLF2GNPDGZULQ itxfpBtIyBMLnUBCCCGEvDcCUHf7NAV0c1NcwKaJ458bG1FFqbLRXUDtA7x9W/YCdTT04AD4yleq z+0g7p8d5RzszrmhwzdICO0fozUBMLrjtzmTY2uj77zfkMs1GVRXG3WHD0G0bbcAujkw93JogIv3 afrnkmCOPjOnW8TOP9XV+r7UEcw7BEufkZ7xId7v775yOXzp/73t+BdMCEUgIYQQQsj5mUzEBVQb S6sgNOFT1ZcdA02USi8guy6Ogup+4JqEviR9bP/PjYjJ/OXkQq0D0AVg0cXEzaaRcJjZNCZwakn8 AsA8AL6Lzly+b+gKGjB/YS6b8SwJQb3/wNksqEI/phgJIRSBhBBCCCFjLMNg1A7TPcDpNBbD7+3J ofOTbf8VZT6Pgu/ePekDPDgQJ1BHQ7/61epz625f2x+6E1gbAwVGAlcyuhDHNJdjoBNxCHW0s9WR z1Z2A31j1FwHtIt0V9CGt/jcCezFY64EnRGfy7lXU/1gtVxpN9BlYi+oG9jf7u+9cjn8WbqBhFAE EkIIIYSsLQA1CnNnJ7p8i4UoGt35m06NCjH7gtoHqGOfBwciCE9ORCCGcatKA1eW4S+armkFUHb7 kpBcdgH2x6QFZhO5v9Y96Ohna2oeJv3P7QTwU4gKVRHYJ7y0SB1IHRNdmF3ARR8w03RA8L2T2IfB BE0L7cc4gXheR0Fd7g5i6Ajm7qEvJckQQigCCSGEEELWQsc8t7ZkaW57W5w/PW2aNB1F1ZAqE+9F DN6+Dfz+7wPvvANcvw78yq+MC0CXpm/mhfEDAVhwA0vKUHWR9zL62fWCbCkQtR5iU86j7QVgY4RV F4Vg48tOpM/HQYM5umKPffL68l9BSQiGigC2j/GLr1wO/w3dQEKeGJgOSgghhJB3hWUa6MaGiL3N XhFNJqJGrlyRn71RQNbZUxfw6EjE3507MhKqZfHr7gKGNE9FxY9WRtgqCHX9SoISKBSy9xWGS72q rpxps0ALYAJgmp1O0p+9cRSbfnQ0CUo1j2kP38TkULunqKK2lnQ6KJV3w+5Eb05ZIk/IkwOdQEII IYS8OwKwaaL71zRyqsmfV67EToVlc/o0joWensa9v3v34mFHQd24MZWIGZfuBzbI9vBQ7gJ0Rhg2 XpJBp20c9/RedKweWgcxNTuBmPTfuNQN1Ac2TqBe5vs9wcXc7Ar24m+h46CdCM/OA67LHEyX6uiB 45elhQ6Eru0a7B9P00IDJSAhFIGEEEIIIVXUpprNRD3s7PTKpbfNtCA+dwHVWpvPYwXEvXuyC3h4 KCJQncCvf330JViR5yuiz2XKryQGl+6eiixEweV7caRvS++07PKzTqCKQJ3D6lIBqMprkr8eF2sl 9Ag2JMa81q7vitDT5d5gKAvBPHnUPtaykN4BTf84f/+Vy+G/5lgoIRSBhBBCCCGW/Z/+6bAc+5zN UstsY0MEoLarqzOoVpoqGFuWp5fN59IXeHIy2gtodNuy20+dwJL4y4Whh7iF3qUuoo5ZNl6cvs0N 6Qnc6Pf/Njbk/MyamtYF1MOKvgWiO6jCcCEf2fxMXMDlSGgTGzK6hTiBSzcwfz/m51VCMBG8/Zma 60f1RwhFICGEEEJI4dtFG8c/vZcieOdkJ3BnRy7f2YnnNzdFMXkfbbX798UBvHkTePtt4M03ge9+ F3jjDeCf/JNzvZwu9K6WS4VM0Q0cETx5fYPPegKXbqBenjuBE6ROYEA5jSWIQNsIBVFnSuYXC3kN nTufQLNCELXEUHOdhzyHC/J8/+CVy+G/ohtIyGMNg2EIIYQQ8tDY/5mfCUuXD4hjoZubol42N8Uy a9tUQWl1xMmJjH1qJYSOgh4cyHjoyQnwQz+01hccG/RiHT3VON6EwTQuhsR4F4Wchsa0TXr4JtYe TifiAG5tpm7gwAVszHkNhJn1x9Sc9vdzWeALgpmoRRSa+nGrU5gXzbsRkTgWGpME4CA6qYQQikBC CCGEEBGAn/ucdAJOJqKGNBTGe3H6rl6NvYBNk46Bei/qZrGIs4tnZ7L7d3QkAvD+fQmM+cY3Rl+H FXNWvNi0zFVipiiOXFbd4EyFRL8raPcCY/woUjewFhYTzLez/j6TafyYNvtcnWV6qE9fhzOKLU8J zZNC8/dUe+8ofHaNA37pE0wKJYQikBBCCCHkIx/p29P73b6miUokBNnpm81kDFSvs8tnWg6fF8Pf vSsVETdvAl/72krx5rK6B1fYByydr1pl1kkz4mq51tiK87e50U+3bgBt5uoNDlsPsdGfTofiUJ0+ FbTLQvrsSGojfH+/TKSuIwRLwTl2V9K6g7/IyghCHlu4E0gIIYSQB2b/c58L+PSnxbZSNbLRp6Xo LuB0Km6fczE5dHOzT0Hp00Dn83gsFjHVRGcv10SDN2HEoK2HyHsB8wTRxgbKuDiWqae5C6caNgSz b2fdQJsQaucq+xRPTDEsMwzxKlVo+rEsFlIZ4RcFxw+ICaIrPqfzBsXo7VUQEkIeT+gEEkIIIeTB BOD+fsBHPxrHPlXkAXLZxkYUfNvbcfwzKbTrlcx8LiOfx8fiBKoDeOOGOIRriJp838+h3AfoKj2B DhImUxNQzgS/2KrDjf4tbmwB2AawA2AXwBai2zcpHOoalo4+TEaN08nEHK30EC7dQOMIFoXqGgXy llD4XJ0RygDdQEIeV+gEEkIIIeTB0JTPySSqj9lMlMf2dqyICEEu39uLdRF6+cmJ7ABaF1DL7nTu csUuoIqVPBBmIPTcuCBE5gY23hwmrGXgBKLXtV1/OAzDYNQJVLQwXp2/DsAccVewv7+KzRPj+sHV 0001Z0drIWwB/NiHl/cH2k5EGGFsqzQIIY8fdAIJIYQQcmH29/cDnn022lSAiDtAxN58HkXh3p5c p6OiKhptkd3ZmQTAHB4Cd+4At24B16+vVQthRxSrAm9EEFohCZe6ga5PCJ204vhtbwE728Dutpza A9sANiFOXlM58oCYfHzUZ7fv3b6NXjvPNrDM4LF7gZpaivy950Exhc8ElfP2c1w6q+Zz/jJDYgh5 7KATSAghhJCL8+KLUSHoqRa963ioJoIC8XLd8wtBxj8PD2X0U0XfW2/F4/bttV5KQLnawIa+uIKI SUZIbS2E74++FqLReohCKqfdC3TBvKA8HdTuBAZzOkO6K2idQS2QXwCLuZimy7HMLKjGOyCYhg59 TfZ08Nz24kJ3YOk8+ufv1tg7JIQ8etAJJIQQQsiF2N/fD8u0T3X4dAxUheB0Kotye3syGrq7Gxfc lurDuIA6CqqXnyMMppYACpTHJktl8cXudiN0tJ/P+9jLN2nFkZvNALcBcQE3IbuApcVEXxGHLhOB Oio6l9PFmbyWyQTY2JTnm06lRmKS7QM6n+pyPXUrKiFKCaL5Z1hyVekGEvJ4QSeQEEIIIecXgJ// fMDHPhZdPWuHOQdcvpzaYzoCquJQheDJSdoBmAfC3L4NfPWrK1+PJn626uJBzquz5zFeDzEYCTWp oHlRfOPTrsCyckR0AvN6CBWGJgE0Rm6a65v0/s0kVimqAltWQdjUUg/4TvRjjXznr3abohPozK6h A3wYfy5CyKMHnUBCCCGEnJ9798Sl07RPde1UIcxm4vptb8fCeE0I3dyMI6IqFBeL6ARqjYQ+3hoE DPvtYPWUqYfwWW8gUN4lXLqAed2CEV3qBE4n4sphBkkC3UTsAbRJn3qowLNvbwpxD9VJ3EBMDu3d QmuilkZBrRjMk0JdXnCfve9EIJo00aoraG7rwQJ5Qh4n6AQSQggh5Fzsf/7zAd/3faIwtBKibaNa unQpjaf0XmYY7a4gIILv5ERcQHUCtRxeXcB799Z6Td4V9vxcuf4hD0MplqdbJ7AXeRMNYMl2AoMR jM7s8CU7ffoEdjw0j+HskI6MFtxAPwGmXXy40AFdvyuoj9l1WfuGOc1rH2o/n+e65e+A/2kQ8tjA /14JIYQQcj4BeHwsamhzM71yqYpC7Afc3pbTK1diJUTu7umM48mJCEPgXC5gqQtwKX5cWey5khNW KF1XcadtFfZtam3DbCpvzW1CnDvr9HkkTt5S0GXJn8vbAuWi+TY+rvcFN9COgjbZ7l/WEzgIyxnZ iaxhPydvfqYbSMjjAZ1AQgghhJyPP/AHZLRTQ1usitjcjCIwhL5FfSOOfqqCWSzE+VMXUJ3AgwNx AW/dEkdwjW5Aq5vGCuBz0Vd1AlXcmG7A6UTE3lava3e2gN0dYG9HcnGmMyPWrAB0RgDanUBFl+km iJZiLRzmTO6/FIEuCjy7D9h4IPTTto399QSg8+Ie6s/L/T6Xuof6GYT+81zuANqXaLoD1R2ku0DI 4wH/WyWEEELIWux/9rPSCTid9gtwiJYYEBfRNjdjEuj2tqgkFY15KigQ9wFPTqQS4s4dGQP9jd84 lwBEQQjmpfFrP1ZWAL/ozcpFJ48FvXzRm5eqhBqI87eBuN+nDwSU00Fz4WhvZ91A3SeciiCdaWfg LPYFNm05q8eqXDdSMl8Sw7XL9LHy/Uq6gYQ8+tAJJIQQQsh6TCZS9WAdPUXrIEIQ0dd14uzN57HX YDYTkajXHRyI4/fOO8Abb4j4a9vyyGgFFXmlhM+liOsFmwaYeHOqqaLLfsC+G3DSyDFrgdkklrRv bshLm82iEJvZ4Bc72pkLOCv28p3ABcpzraWx0aavgLBCzEUXcNEAfjHyEYb0dPlSCm5gSSDmu4E2 NdRT/hHyWEAnkBBCCCEr2f/CFwI+/vG452fFH3qV1bYiANWWunRJdgG3t+WyXJXosp0GxOgo6I0b wK/8ylqvK0nsRFr8ri6VjkSeywnM9VKIq4vOyUueL6I7iA7DJBVXEIFWJOYCbwLZKdSE0SlilUTf FWgdx7ZPJJ1tyDjqZCJOYGOSQbXkvslK7ouAHo13AAAgAElEQVSKOXv5yfmR7kArwvWKf/AK3UBC HmXoBBJCCCFktQC045+ukCiiLqAqpq0tEYKaqKL36zoZ/bx/X5JA9Tg5MU3n67mADlL70Jr6B1sF 0eQCBdmIKNIC9TwgxXYBalJo0/QO4NQUtecCzzqBqiRzgajXdeZ0gfKLbXqBOEeya7gUtmbdUl/j YiE/L0phMA5w5vUEY++tkwIKlG8LfVuO/80Q8qhDJ5AQQggh4+zsAB/6kAi7ra0o6rTrDxAltNOn pGgx/N6e3H46jY6hYhNBVQTeuCHHnTtrf4mpddfZPcBVO3BWz9pdOlcIXXEOOJuLE7iYy1vo1Ans MlVUGue04TAO6UxlKAhGn93PCMx8vXI5EmrcP90THHMDk8+m4pi6ketKt3UAvszdQEIeWegEEkII IaTK/o/+aMCVK6lCUuGns5HaEdh1EgqzuyvLcjoiquOhIYgLeHgoHYA3bgDXr8vpyUncIfzmN9d+ fXkdhLIsendDtwqIO4Klx1qKIa1ecMOwldlMRjCnk94JzPcBazUPNvxFaZB2CtqdPR0F1XFRHQvt AN8B05C+p66Tw5u9wKQOAqn7qemeQNn5GziDxkVMPkJzQyo/Qh596AQSQgghpM7GBvDMM7HqQcWg OnsqCkMQAdg0opA0FXQ6jemhqlTURVxaVU0UgWdna4u/Uh2Eun9J8Av68Jf81JWzWPRxvSsLQG/c QN0LrO4EWjGXJ4R6pKOjtkjePo6Og+ajpq7gBqoLaF5z0Sp16XhoXQ3Xr3Ijt9HPlm4gIY8mdAIJ IYQQUmT/J38y4Lnn5IfpdBgfqYJuOhUBOJmIArHC0GV9Cqen4gTeuSMO4FtvSSCMdgYeH68vAlEo LUeWFjqSHDoQMy4VMc6lYsoerdkNbNZxAvPD0vQiMheAtnYi3znsHzu5eQd0vSjtQjrO2vhMpAag M24gesfUhWFS6MAhdOZ2+QdJN5CQxwI6gYQQQgipfEvoax9mMzns5ToKqmJvNpM5xKaJ/YAbG2k3 oM4q2rCYpokVETdurD0Kmjt3yLRTGFN7hdsvb2KEXmMDWLKjC9ENDAssRzSXQS9jTqB+A7OHTQid IiaEzozAnCDpCsQUcLP465lt9D2BTaEr0KUiNwmWccWPZfSzz/cDc5HtEF1XuoGEPHrQCSSEEELI gP2f+qmAD3xA1MRsVk9VUQWyWAAf+IAEweSJoCoAtQri8DD2A77zjlx2cgJ84xvrC0BXGeFEoTvQ pULFIxsZNf2ArdYq+FTo5CmijY/Vh24DUgq/BWDbHJsFIWedPKtC7Shoft2ZOXLB2UUdjmBCYTyw KJTGWwG4FIIV927dpNDkdpkbyKBQQh5N6AQSQgghJBWAP/ZjAd6LizebYVkPod/y5/P+W0T/NWIy kXFQ7+X08mXpCJzN0h5BTQS1e4FaHH///rm+vOhen1ZCtP3PpT1BoGwCJqImZLdXYdhI+MtsKkXx O/2q4/Y2sNX38y2L4u0oKDDc/cv3/1zl59xF1FHQCYpuYGPqKpYitk1XLrUz0DdxNDSEwpinS8dj 3Qo1Xlw3NJfrXibdQEIeLegEEkIIISTl6lUJg2kaJP2AofA9XvsAQ4iVEbo/qDOJKvIODmIq6Ntv SzLo3bviAn7962u9tFogjHUCSw7g8tSlHYDedACiVBNR2AlEkP27RSc1Ec0ZJLUzr4iwSrPUFeiy 69v+MSZInD6cId0J1PNzpJ2Brhd/C6CZp32BzqHsbBb2AYE1k0LX+F1R+RHyaEInkBBCCCFL9n/s xwKaRtw93888Wuyo52QiKmM6FeG4vS0OYI46gF2XuoBADItZkzwFVFFXa2xk0Z7mBGT1CZUDGrTS ApNWXDioG6giLXcCc8cvd/u67AiZoGxQLqI3wTPaY6i/Gt+7gW1fYdGaPUEgFbeDzyVb7lsnEXTw eWeppQ2AX6YbSMgjA51AQgghhESef16EnHOxEsKigTAaGjOZiAJ77jm5vZ1B9D4KwLMzSf68d0/2 AW/elITQw8Nzi0BvBJtNBLWXD0ZCXbUpYZCi2fi4V6dHUrKO6ARiAXHkdF+vKzyJr4jAgOHcaskx BMouonk81498qmbXpNC5EX2NB0LTP8VZ3/nnCuueIfYBhhW/i1BJCg0jb4kQ8v5DJ5AQQgghAHoX 8NKluAvY9v9WbGse9GedNdzYAJ59Noo+qyg0sWQ+l3HQe/dkFPSdd4A33wS++13gH/0j4Ld+a30B 6KL4swEwuWZa/jw2EpoJxhAk9bML0bRM9uZ05NRHrZukeeZOIDIVFCqK1u4NaoCMHf+cIgbM6KF7 iCZwRnf/EuFlxk3tZQOHc43Pvnq+khTqss5GB7qBhFAEEkIIIeTREYCvvhrw0kt9CV4bLSVVCItF DITRRbPZTFSS7g9OJvHQ/cB536OggTCqUjQt9ByUQl3sxKQ3BfB+rB/QCCIVfapv1flrTcqmz5xA 52PQSlLrYMNhrBoqjYHmTmGz4lhDQGpRvA25yXcbfX8e/akvlcqPffDn+B0VBTz/UyOEIpAQQggh jwjb23LoLqAvfEXQfT7tBFS7TJNEcyfQir2jI3EBb9yQcJh799YuhkdBUzVG8DmXjh+W9v/y5E+7 W+iz/j9bZ6gC0ZqgQLxdcRw0jIg1X1BKpRee38e6ifq8+tz9sZjL1C3s+zSHN6eNEYADkeuGKZ+l zxMjb6PktCpMCiXk/Yc7gYQQQshTzv6rrwZ86lN9gkgrI555GqieV0W0sSHJoB/9aHT4JhPZE9Qx Ut0FPDuT88tZxZA6i+sKQOv0FUTHylCYQjqm3sBWGrRmtNLuBi6DYVzcG0yqG7TgfROxJzDvCPSF F6dOoE0IXSB1AnU9syuIwP5UtbgNydFfl4pa3zufrjM7e6Ec/GpfYhj5gFddn7xVRoYS8khAJ5AQ Qgh52nn++aiMSm7eYhEDYfRU1cPWFnDlipTnTadpL6Cqj7Oz1AW8e1cCYc5RC5ELv7yJobiX5tI+ QR0TLU1l2vsnTmCXOYFGOCVO4BzAKcQR1BfYoZz8WVOpyFRt/sbHwmEaCYdJDFzzKwiF94SCIF61 J3ie3cAS+rR0Awl5f6ETSAghhDzF7L/6asCnPx2TPts2uoB6Op9H1aAdgFtbwIsvpi6g7gICIvwO DkT4HRzEmUNbGr8mNv1zIOSy3b8GRvChLGYGjiCylNA+9KVtoyvom3R/zlsnMN8LzJVrXglRU0Z2 1DMXlguk4TKuLARLGr40DlqzAbQBJHlpF5Brg8qJYES2E0eSEPL+QSeQEEIIeZoF4Mc/nqqFPBFU RzadE4UwnQKbmyLmrlwBdndFDeXKQ0c+T0/F9bt+XRJB33hDUkF/7dfOJSjs/p4KwcZF0afBMDUx UqqFsEXxbR/00viYFKrVhks30DygJokmY5lniE5gafyzJgSX6hVpIbzPLrcpoVMjOk2SqC20twLQ +T4IxgTDjJE7nw5YO9WlthuI7GcmhRLy/kEnkBBCCHma0R0+DXYpofaQFXvPPJMWv+tj6Mjo6Slw ciKn1p46pwuYCBMVJ64sOjCisULlSPSZ3ffzUgbftlK63niTOGo6BZG7geoEniLd6dNx0DUEWDVV NH/hpYTQCTBZxF+ZfmZ2FNR34saNVUMkK6HZKKrLXkJy3lwQVv0yCSHvG3QCCSGEkKeQ/VdfDfie 74lpIhrqkieE6M+qKpyT252dyWUqAq1qUNUxn4sIvH5dugGvX5eC+K99be3XaXf7ltUPhfqH5Yin S52n0vRk/rMGvjiY+oc2isDlSKgv7MuVhJR1AYsLiGuIIisE8zL5MbHos3FX+/lkdRGl91AcJcX4 +63tBg4+a9MbqL9TuoGEvD/QCSSEEEKeNgH42msBW1tR2Vh1Y8Xc6akcQEz3dE5CYD74QWBvT+oi vI/7gIuFVD/cuQO8/ba4gZoQOs86DNYUgcs9wEKoC9xwPc7ep0EWelIQf4mQMWEqi0qQihVVRXQ0 dAJx/+wbqaGuYofUQbRu4xQxXCZPCW375zWdfyF7rd7FKgjvgdAMRajq+vzfAPQtVMzBUS0bUM61 AZNCCXnfoBNICCGEPI185CMi3GYzOabT+m0Xi+gUbmyIkNOaCBWCGqF5fCyHjoGenkpH4MGBdAN+ 5SvnFoFWkNQMM3tbN7Yb6AqBMi6KJ9XESzdwAmzMgM0NYHtLjq1NecvLfbzStynrBo45gGNv2lXu nwfI6C7iqfysaaBWsHqzE+j9sLjdjbiB9jK7G+gqLxlriEP7RZRuICHvPXQCCSGEkKeI/ddeC0md g93Xs9/+dW/PdiRsbooq+tjHgMuXRQRa1aQ20tmZ1EAcHYkIVBfwnLuAy9AXlyaElkrIS0mhiWtY uq8rl5nbdovFAjibiysIxOnZqYa0bCKGtaggDCiPg55X/doxT6umSjuBprOwte5lL5ztTqDrjJNp 3VCXBsMi+0zWde50N9CF6AKmV6Y/O0pAQt5z6AQSQgghTxsf+lDc5VNVs/ym36uB+Ry4fz9NFWnb tC5CBaA2lOu4p3YJ3rgB/P7vA9/+tiSC/tN/ei4NZIVbEsqC4T4gMp2U6yWE9OdQ0DMqgjQYpm1k L3A6kfOuJOZs/599QK120DL3bg0B1WA4CqpCz9ZQTBETQq0b2d/e7kcmoravewxmvVODcHwzHHEN 2XtalRTqChcMuhtRdhr/Id1AQigCCSGEEPLw2X/ttYC9vaGAy7/9q9BT8dc00gvYdcCnPiUjoFtb 4gpq9592KhwfSyH8rVsxHXQ+HxbQrSA3nkKlZN0VBEoph2W5F5eLSqSO4FIg9hUQiw6YL+Iqo1sl AIP5hpW7geu86VxV1e4fsm9zFecx2Pfo41jowAXE0BB2aziY7oJ/i/bz947/bRJCEUgIIYSQd0cA TqfAyy/LWKdWQmi5uwo5Rff+7Gxk08h5myhaShHRmoiTExGFug94DppMrA1EW0H42dRJ5wquU1hD VGqASt8bqCmhycqkMy7ZWOdEkwm4VWKn9Bi1ncB8JNRWVfS/Gl3jnM76qovG7AO6QvKnfeoHFGZu 5Ofax/FLdAMJec/gTiAhhBDyNLC7K+4dEF3A6TQrhEMc6bRjnyFIL+ArrwCXLkk66OZm2hs4n8sO 4M2bkgx6cBCTQReLiuoq4zEMLllHSIQRLaXCxrv01LkRJ7CLKaHzebZD6JCmds4gu4G6H+gho6C2 8F17AsfeuE0IXWQib4KYBqoOpP58lgrGxNwNaeiN78c/m5AlhBrylFD9M1juDCJ2Aq7qDcx3A0u/ G8+kUELeU+gEEkIIIU84Sxfw2WeB7e1oEWk5fP5tfz6P3/oBCYDR4JdFPxt5ehrHQbUcXpWS7gfa ZNDXX7/wF5XGmZoIDGseaqEw3g0FZQjlfUArEpeF8U3cC5xMzvnCrXhb1RGIgpK1j1O6b+4G2nHQ wvioc2lKqO1GrL4FVxfhD4OSE0k3kBCKQEIIIYQ8DAG4tdV3GiBN8wRSsRdCXH7THb8QRDjqKGjT yGPt7qb30W7Au3dl9PPoKDqB59gHzENgcgGSl8JbnVQSfRi5jc+dvcwZtM5Z01chanl8Nf0zoFzi vq4ALI161sZBSymhheeyfYGlWsj88a2LmAi1kigcqYsY+x3XXN2G/8kSQhFICCGEkIfx//Zexjln M2MHZSkgtgri5ER+1pHREIAPfCAGwmgvoIpAuwt4ciKhMN/5jhxvvQV87Wtrv9RgNOmgWqAiHKyW LY2CFvVTKBTAq57yppy+F4Bw0dw8PQPCHGnyp03/tEXu+e3CCnVUEph6Xnf+8nRQHQfV5+i/4elO 43QSBaz9NwBNBdU0VL28JBKdGwrEVULPCkXnygJRRabucQbQDSTkvYA7gYQQQsgTyv5rrwVcugS8 8IJcsLERE0L0G7gqocUi7fLTmofJRO6v5fDb2zEZVG93/74kgt68Kae6D3h0BPzWb51PryJ18ooB MC4dE20yBzAxtzLx4rMj3/NzhdJ46zpq4IrLaxxqC2/ncQKtSlVhd2aEpIpJPfS2uWA0H0Cyo5c7 gT52BtbcwGVnYBi+PX2LYcU+X+3q0uXcDSTkvYFOICGEEPKkCsDNzejmbWxk9g7S9E/d47OXA3Lf K1eAq1fFAdRKCPsYQNwv7DoZAT05iY93AQGY7/olO34Y2Ql09R47K2JCf5vGxS5A3f2btFErWzGp 9Yknp0B3VhBmnXnw3AmcIzqEq0Rgl6nekp1pBWNpNLUwErroewK7RW/8GvM36QN0wz+V2k5jMK9n LMgn/zl52IJLSDeQEIpAQgghhJwX58S1e/llUTObm3Em0N4GiLt/6uqpC7i5GWMy79+PfYE2VfT0 NPYC3r4tO4FHR3L5r//6uV5yXrHXuF7fuMIemUvvp6OgViCVOgOXNRLGCczFz+A64wR6LyLRtxiW uufRmKVdvVWOoK17yO+v46ATc0zrz5H3/HnTE+jzUnlXGdXM3VJkO4OZeitpVXu73NlF4eNSZ5cQ 8u7BcVBCCCHkCWP/i1+UMJjSkpf9hm8dP5v/rz9vbACf+YyIx52dOAJqE0FPTtLZQU0PPTk5n2a1 OmbNsJHRlNAxJ7APb1HhaE3NRQecLQB/JnrZ9U7h5gawsQlszPqPoUV5HLT6As+hhAPSgJnSB2AV VmMOIxR9B0x6xw/9r8YvYtCrD3I05jmXa41dtjcZ6lOa5xn3xAPcjhDy8OA/tBBCCCFPmgDc3pYQ lxdeEMWio6C2188Kv5MTEXR62Xwubp8qgb096Qfc24spozr2eXAgqaCaDHpwEJ3Ac1DaNQPKO4H6 MtfVWdbFsj2BGgCzvI253bJY3dQpIMSWDJwi7uvl4TA2GCY/Vn0I9jFc4TobMBOyDy8MxaQNy2n8 8H3lCaFJCmvuhhb2BkdV+grhl5wWXMJf5kgoIe8adAIJIYSQJw1bBq+nVgBax89aPoeHsSVcL9dI Sau89H5628VChN+tW5IG+p3vPFAgTHEn0A1DYVY5SLV6vaVG6kVdPmZqqyHyugTf9GExJTcwF2Kl WdRVL1hvY8vi88L4rhef+twtJC00L5BfAG2/B+i9eer+PTVeyuJDJ65hlwvnQum8VW72z2G0MD57 jy6s8TE4YEEJSMi7938T/AgIIYSQJ4P9L34xYG8PuHwZuHYtHQetFcNrKqh+q18sRPhtb8so6DIh xQ1F4MFBug+o/YDnFIAoaIzSJKR1jfQCj2FRfNEVzFJAl/UPJv1zKTL9sEdQn7fpqxdQ2wlcV43W PoBSB2BjRKAvnHcYuoFZ76HXyoiJnDaNCFrvo7Bt2vTXPRitLbyP87iBtaCYgfA3l3+ZbiAh7wp0 AgkhhJAnRQBOp/It/soVCXXRQBhbDK8VELYMXgNe9HLrDrathMHs7spYqfdxJtIu03WdiEktmz8H SYaKG17ujNjLq/OS7JSsCD4/r+LPGdEVggktyUNTbE+e0b6LBdDOsXoc1CaE+uyNXqQ8fuyDy4Wj uX4pan3/WhB/bfnRmcpHOwb7IHt7A2dwDTeQEPLuQieQEEIIeRKYTGTs8/Ll+A1+Mqm3fOv5o6NU EXgvITDf8z3iJmo1hO4Pdp04fnfvyh7gzZvAjRty3L4dH++cIqHW8Tc6zlk4X9JI+XipLYHXIvhi d2CWoKndel4dwAnGx0Hti8jPr/strTVHUzg8ymOmds/PCNzkJm5YgTEYf/VDIYxcaxaSQlfVRdQu t5UgmhL6f36MbiAhDxs6gYQQQshjzv4Xvxhw9aq4fru7Iv6StvNcSfXhL/O5iLqTk3i0beoCakG8 dg7q/ZyTHcLjY3ERdT/QuQd+P7XxzqJYdJV+wTFRmJXDNz6KQu/rO4EhyP5c16ds4gyxssH2BI6p URWKpRdY2icsuYElYTlD2YVcAM0inQguvba8AsLadyoGO6S7g5q0GkL9ba+r3moaGgB2G/43TsjD hk4gIYQQ8rij3X3XrsnprO8xUCfQVjiMCTUNkXnuORF1Ggpjv+WrgLx7N1ZBHB7Kz7dvA1/96vkE X0XgoaaTCmOE1anJgmC0h7p+mnGz6E87Oxppnm/gBFqHzgqnrizGismeqwgjb9COg6J+vQ27mUz6 vcBJ3P+za6MqfJveOXRZCEyoiPbz/s6TJNKCGLSP7QH8g1foBhJCEUgIIYQQAL0LqOJt+a3Zl60f 3fVbLOR8flkIIiCvXpWjbWU0VPcKrYN4dpa6iSowHxKD6gCTDroskndpT7pHeaS05HT5rFRdxVDT GEfQDQNSlrt1ttR9AnHi7DFFmh6aj4yuK2lKYnLeH2fmWKwhBAv6P3dFB2OwGH4GztWFulvjd5qL 9Orv3HxR9Y7/rRPyMOE4KCGEEPI4c+mSjGvq7l7uAg6+eLuYbnLvXhwHPT0V0Xf5ctwN1NFQRWsk Tk+B+/ejA3jrluwG/tqvXUjsje0D2hwVXymCHzPL9AbBmfq93uXz5saNT49kHNS8/S6YcVAVYie9 6BvZy6v2VdiRzzxMZoG4F2hFYElYov44XR8AO1ftbzsEOzPmGqIrmo94DgJdegHe9c9rw2OT81iv SN4hnZIN2Z+spw9IyEOFTiAhhBDymLJ0AS9fNt+WbcO5wXb6LWf7TCwkIPuEzz8vwnJzU4Tl9rYI Sk0QdU5cQHUC9fEu6AKOlYbngiDvpUtqHcwpam6XFZVZRs5Cx0F7JaIaeDaVj2JjA9iYARtTwKvT p12BLeqjoLmTZ29T2vVDRSyOjYLmjqS+tv71DUrvC4+TOICF9NJaH33p5T4MXCGI5pdYF0HIQ4NO ICGEEPI4CsDXXgt49llgb09GQbUeQlNBS+SiT8Vc18l9trbkus1N2S9URxAQsXd4KOmfp6cSCHPv nuwB3rwJ/PN//mAC0NW7Ab0r7wwOdFLv+JXMNzvOqadtA0xaOdom9uct3UA3DFd1dvbU7gb67I3l M6pjgq6ktKwC7lYIQbdCLJrgm7YBwmQorkPvjAbfu6QOA6tA/x0hV4OhVCNRsQDH6iJc/eUvn4MQ 8nCgE0gIIYQ8rjSNiMCmiRURtTFQnfHTUdDjYzl/dhYdvpdfFvdvZ6e3vjZSAekccP068NZbcqqV EPP5xV6+7vUVEj4Bc3nhupK75125gi/feSvt+jV9kGpbCElJNLQ6enY8U/fy7Dim3d+rBcKEypGL vDyEJi+pLwnJTCQuKyLcyM0KNRE14Y6aqzg8u5ZT6Aq6tpT0+jdZF0HIQ4FOICGEEPKYsf/aawEv vihirW1T1aIuoP0WryEw1gXUWgc99vai1aOJoBobqS7g7dvRBTw4iF2Bt2+f+z3kIsGKvcaIPrjo 8tU66HJNlffVuVL5u0tv15m++7aNSaHJCGruBOaOYEkANkhHQn32QktzlrmgG0sHzR3JvLC+fx2+ IO5yQWdFclewZYtF7/3PcIWqCFszgcwBRPqYYy6fve0l1kUQ8lCgE0gIIYQ8jjSNiMDJJC6tte1Q AJZE4P37qSDM00HVXSw9zslJ3AfUxz3nPqANe6msqBVdPlcQj0lyJ6IbqAmiywJ4DB0m2PvquGQ/ GtqMOYF57YOmdYZMkJUK3j3S/cFVvlZAfSS01qdREGO2NrJt08PWRDg/dOCS7kCgWCxvhfK78WXV /t7oBhLy4NAJJIQQQh4j9l97LeDDHwaeeUYE2/Lbu4s7gXlQi4a52KJ3IKZ8XrkCfPzjEjAzyQrk QhDX7969mAx6dCQ/37kjyaDf/Oa530cpAGaVDippn9LtghFFAeLyOaOB8wdT90vHQW1CaKkqYdQJ tKOiNgCmy15gSbTV9gXX6QosPRZSJe19ecRyUP/goxls/53A1k3m66U1sR/WcAOXv4cw/GhKDuMe 3UBCKAIJIYSQp0YA/sRPBEynolb027t2BDaVb8aLRXT59Nv00VEMhNEdQQ2H2d6WgJiNjTgKqt/8 5/PoBD5AN2BNgCw1iyu7gWOCMR8pTTRSYRw0D6IJQUZA5wugWZTHQQdCK78sLyqsibxVPYEhU0se 6bhph9RVrD1f9sEk77/wAeafFcZ2A42Ke9DQlrG759URngExhDwUOA5KCCGEPA4C8A//4YCtLeDD H46Onc736elYoodNBAVEzB0dyeWf+pSkgV69KvUQ+phdJ7c5OIjJoNoPqC7gb/3Wub/w50EutgA+ H0HM+wFrIjHXV8txz5FAGbvrpuOgOi5pDdZRoWYF2wLAaX+cIQ2Fsa7gqserXd8VBKJVv1oTMUFa YeGRjnBmWrFYFO+GjlwiAJGKT5clqZ77HwOMEM2vL9VFfJl1EYQ8EHQCCSGEkMeBj35UHL+9vZgE qrUQOgZaGwVVEVjaAXzhhdTls7UQ9v6LhQhI6wRetBswC3hxBZGYd9ANOgHN+Xwf0KP8+IO6h+zj 0SL4RV+uvpgMncCwSsDZWoiaG9hlb2rsYxxLDy09Rilopn9NXiswWqA1o7H6JxPQl8YbFzTkotz+ iY1UO9iXdxG1VquLANYbISaEjEMnkBBCCHnE2X/ttYCmkSJ3VTE25aOGVkDM57Ee4uAgij1NAA1B QmY++EEZB1VldHQkrp91Ak9OZB/w5k3gq1+90Jf7Wh9g3g2oAi8Jc0Hq4uWPmbtZvlQLUXIHNUSm MW6g1ipghUhDJgJXjYOOCb1cwJVK4RuUOwhReJ5sntatGPF02dhoZXJ0ecato8gq1RHn+Vtx2b8U OAB/6+N0Awm5KHQCCSGEkEddAO7uShDM5qaEwcxmsRrCpng6V15iU8GnYjAEEXR7e8CLLwIf+ICc V4tHU0GsTaZO4P37ct5f7N+RB31wBTdPhUxw4/evaqmsyHygvfLaB5ueabT1dApszmJl4sYG0M4A zCDjlpoA6lEuuqsJvZoYtGOjpYCZ0kjpWE2EraxYY8fPiuHggUadwuxPCR5wlX1Ju8NXDYEp3H55 Pq+gQLoPqM/ZAdimlUHIheF/PoQQQhQHM4oAACAASURBVMijTtOICNTxz7wTMBeAen6xGH7TB0QA dp3sAYYg7p5WPmxuyu20C/DWLSmH/853gP/yX4A33pCi+K985UICMK9nsJosyUIxxe+jdRJ53QOG XYDeVZzCTNxoV6COg56eFoRcSXzpLl6LtDze1kh0GCaE1h47FE5LArJmq5aeo3+t3lZETOKhO5De mVL5ghuYTxoXQ3dqKn31VcsbjDVe2J//Nt1AQi4EnUBCCCHkEWX/1VcDrl0Tty7/5j2dRjcun/Gz YlB/1joIHQvd3ZUgmL09EZjXrklVRL5XqGLy9FTEYtc9PBcwE3nerTcuWDLb8sCYwX3syKd1+yb9 iuUknp+0ciSTtjUlskqYoXA/69KtsxOIEXFXE10lwVpL/QxGNPcu39hnufzTCmWHr+gGuvE6ify1 h4KutXq26x98g3YGIReC/+kQQgghj6oA3N4WtTKdxjHQ2QyDmohBo3lI7Sy1tO7fT8Xg5mYsnLfC 7+REdgDv3QPu3pVT3Qc8OAD+xb+40BeOxqSANoipoNb1szqquhdYqIDwGEmWrO0F9jfyBYHYNCIE B7qqtrtXEFwDO6s2Drpu8IvtJfRrCk4ts+/TShcLCb9ZBr+ETES7FVUS9s9sXdVf+7lwcSkltCT0 gfpKJCGEIpAQQgh5PAXgzo7UNbz88rCzIHcAbYO3Xp6LQr2NJnt+8pMi6qZTcQAvXUrHS/W+XRfF 5P378tw/8APnfk/rFsNbkRfW1BbqHNWSO5fF5oUHdUbQ6Nu1I6HJC6mNbK5qsw8XPMbub8WdjpsG pGOqE8j+ogmRGYSs2JdtdiOXRxPDcrwfCuhRwgPoQzd+vf3HAdZFEHJ+OA5KCCGEPIrot3AVgFoL MZnEOcVaFYTWPyhdJzt+gOz47e7K9ZcuibNoxePJSdwHvHtX+gDv3YuporduAd/61oXflnX1fOFn 74b1Dw7l9bdi0XzhNr6WDtrfKHEBfeoGAiPBMrkw64w4c4gF70mTPcqVDiXRVEoNtX2BwHr1EsZB 9A3QdPInFGxNhBHBpT7G/M9Mz4+OeF6wH6I0TkoIecj/F8OPgBBCCHl02H/11YBLl8Sde+GFtBC+ ZMXklowNhTk7k1PnZJzz6CgKxclE9gGffVaea3s7FY1aBXF8LC6guoivv36hL/W5mCv1+12oPiB7 XFsAn+wBuhh64rLduOQwLlhjXLBlXUTNzixVMpTEXJ7yGUYeC4XHtC5facmy5Bo6lJV0hjqg3UJC ckI2MpoIeVceIc2rJUqjnlhDv+ZvHyjvgerfDt1AQigCCSGEkMdTAH7xi2Hp9j37rHQS2EoI54aV EPY0hOG3dufk272yvS2joJoyancBz85E8Ont21ZmIo+OxAEcxGWeU7AVxE5e6ZDrHVsMn++E6X2D UQpLUenNx2Jua4VXKTHUOoKACKKzM+BsDizmqKd9rnrDuYNXcvjG9g1Lt11nvjbvLiyMhOqYrHPp vzOMicaxHsGBcjun2Ft5mWNhPCEPCsdBCSGEkEeFphHBd+VKr2hMjKWOhZYEYFKMl42BqqgLAbhx Q4JgLl+WbsAXXogjofp46gKenMh9F4s4I3h29mAiMKtssKOfpfHO0uMsJypL46JGeNhwGSvucseq uAt4Bpz2Hz0m0Qn0tc6KmhBEReTVZh3HdgHzn7vCh2IrK/LOQfOaq5+vN25okPdshbN9aYv+T6LW 6xfO8bdRTRh1qWAPa4pEQghFICGEEPJYsP+TPxmwtwdsbYkwm07TpA51AXP3Lhd/1g1U4Xb/vog6 APjEJ8Rp1MfRx1cldHqadgRevw688w7wj//xxQVg5Zv6WG96Lgp99ji1bnZX6ZjLDVJbXZAf9iNX ba6XVedW7U6gdgVaW7PrT8fe9HmCYUpOYM0ey0Sijrjme4FdVxiXRSqs7bhtWFP1jRXHhwv8PekZ /X36/kG//InL4U//P7epCwlZA46DEkIIIe+3APyxHwvwXhy53V250FZB2DAYoBwI41yMtJzP+xnG s+jsASIwdR9QhZ+6i3q/xSIepbTRCzJYS3PDnsCxlbVQEYe5MEme0z6HLwTEIAuPydYuFf1o5qVx 0LGR0Fz1rJMG2hWOvIdQHb/qh4vynuAK1eV83TEdfK4jx2DktHB/lK8q/uHUJku9Wz91lhBCEUgI IYQ8WgJwb0/E32wmQm1jI83pL9lTeTWEjnzm6OVvvy17hioCr1yRkvjNzXjbxSJ2BN65Iy7gW2/J GOlDEn/LEVDEUdCiUEB5PxBI6x5CRdjY0dP8I/QuTQYdXJenjhoTtqhWrcCqpZisEn+1sU9UHiMv mncjH3ztF4N0J9LuaI7VauSrp6U/u7BCcGL8ZY0KxNrbcgB+iQExhKwFx0EJIYSQ9xt1+1SUaRCM 9hSoWzeWCGq/nQOx209HPHXM9JlnYjm8Oobey22s5bVYxMfW8+d9W+iL4bPdv1wDJdqqEDYymIB0 aal4fp98VS8RNUEcr0krR9sCbT8iaRNDkZmt2pmHWkKo7e+zNRG5kh0TeFgh/ELhtqX75R9GO3yc pgO6Rv48fD8GmotCNYtDk4ru0KX/BlGqish3+lYJv4sqNzsG7AMrJQhZFzqBhBBCyPvE/o/+aMAz z4grd/Vq+u1bhaEWuNcauvNlNx0J1dseHsr5y5f7b/xeAmF2dmLvICB1ENevA2++Cbzxhhxvvil7 gV//+oW+nOdjfwM3cCRdcqw/sDg6mnf/YZj4ad2+pXBw2WMWRku7zoyD5oEsLaSuYdKfb3v1WwuP WbXzVxJ0vnA4jO8X5h96KRk1G+O0+UPWdF4Gw/Sntd3M5DJXv35dYXeevzH7e6cbSAhFICGEEPLo CsDt7ZjQoTuAWgWRqBafqqPSqQpCy8GBnN65Iw7giy8CH/qQqJqmEddxsZAgGHUFNQ20ZvGc84t8 rc/PrbgOFY20HEEs6KUauRuoDRghSMrl2QKYm1XIrut78kKqv5tc2LkVL6I2Dtoh7Qwcc/bGxkab THg2RoCOuZbZa3OFf2OwAtp5c+T9in5kJ3BEBTq3nvBzmcB3I1qXNiAh68NxUEIIIeT9EIC7u7IH eOmSnDaNiEA7CmrFn87mJeom6zZQ1A1UC2t7O4q67W3ZOdzYSHcKT08lRfTevZgKevs28Ou/fuH3 uU5oR74fOHZaGgHNA16cKwtQbzsAm1SENH0vYNOPiE4n8qvYmEWzVGsViw7fukJQE0Lt7d0KwVe6 PFe4tgrCjqPOISmlc9T3Jq2o82nnIkoCrLCSuqyK6F9PLTV0MPY5Mge66ralu3qHQZUFIaT+v72E EEIIea+xxe/5DJ4rRTRi3AXM9/jOzmIq6AsvANeuAXt78q19d1dcQE0OPT6OaaKaCloSnRcRgG74 c22vr0ooaKawInzEDe9vOwH1NkloTKkaIcgOXNe7hEtxpWIrd/gWmSDT29oY1FzErXOgIDYdUiex 9jnY/sB+bNX1e5C+GWYOLcVfpqZLE8n5n2ipQN6VficrfmXrXJ68huz2HAklZBw6gYQQQsh7yP6P /mjApUuyB7i9LYc6gLNZOQymtgu4VDNIe/5OT/tZx37UMwR57MuXYz1E6X6Hh+ICvvOOOIG/+qsX eo+JiwcJhlknvLI6NuqGU5jrFMsn3X/maLzZTcxrI/LXalwyn+/klfb9cuVSu02tMH5ECA8cvznq LmFtvjaUhboekzZ9vYNQnb5EfoG+JD4M11KLgrXyO7pIZ6BDGsQaMkHIgBhC1vvfaUIIIYS8FwLw 1VfDcr7Q+ziambuAuftn0z9LQnA+T78FW9TZm8/jXOPGRjoCqmXy8/kD7wKWdIA+0li4S3WH0NX3 BGvCwbkRMeiHh6v04tmxRh0lRV4YvyqYxaqW0k5grRpizA20jz+2F+hR3kvsn3fRxT3I+Vzczq7w XK4wEurML2sgoPOE1bFewJHrSmEzY0EzLhOWf+fjdAMJoQgkhBBC3m907+/KFRnPVDFoRWCtsTxX N1akJVZNf7+bNyUQ5qWXgOeeA55/XvYPr11Li+dVRJ6eyu3fekvue/fuhd5inv7ZuJG9wHXCQULd YKsFyyDXaFkozKIPflkGwSziamVet+iypNFBsz1G1GhJDZ+3J3BV0fs6QnENt9TnY7D5n1xhJDT5 vO04qLniIumgF/mbsw6u/v3N+C2XkCocByWEEELeA/b/5J+UUnhNBAXS8U9NBrWpJbVR0BKqaE5O xNmzKZ+LhYyCavKoFY9dF/cHF4s4Kvrbv/1Q3ncIqWiwY6KlbsDaKKgVGkXxV1CBpRoEWxY/cAQL 07cqHtU1a+aIO3YLpB18dlzTFwRjm4m30jjogwrAUBCA+noLXYGLDvALk/xZUOWD5E83fKpQqLxw rrC3uWIE9rydgQ/SMUjI0wz/jYQQQgh5twXgF74Q0DQi+nZ3JaBlNhs6f0Bd/NmfrW2lKaD5bd55 B/jwh6V/8PJl+ZbetrEo/uxMxOLxsRwnJ9INqA7iBVnW2hVGP1HWGNWfUdAzdg9wLC/FikSbDGrF TJN1By6vLz2/umVjO4EYUSS2SL40DmqPXBHn5/MPa52dRKDoFubl8L6JrSX67xP2T3QpoJt+t9KX w2EGY56VsU+34he/6m8ifx8++8eGLzMghpAidAIJIYSQd5vdXXEAZ7O4B6hVEFoIP2joRprDX9vR s0JQ0z318hBEcL70koyCWpdRQ2Nu3QK+8x05re0erkmtAD539EriTn8YC4IB1usfzD8+VxCAQHTB Fh5YNPEjC0bQ2YoJt2oncN1xzlzsrXIDKwKuKgBLyhlDxVxySvXzWSawmjFae5oLzqQuYlXtw4q6 h9rPDn0VRTiXuUgIqfzvNSGEEELeJfY//3lxASeTuAdo7RW7C1gKhkm+vBfiGq3iUd5+W54jBHH4 tPJBx1BPT4GjI0kDPTwUR/DWLTnu3gW++c0LvdflypyLp66iSbyr7/Ohoo3GdgaXYs1Hh8+Kx66T qgcVMPb2th7CZS8khH5/sCtURNScvNJhUz277AgjAnDVuKetfyiFwowV2xeCXaq/W5eN3ZZEfEF8 u1VFkWsQsM4fQnl8mF90CaEIJIQQQt57rl2TIJhnnhl+Q85HQc+zA2ix1RCnpyLkPvQhCYT51Kfk NVy9Kt2AVkwuFnEf8AFdwLGOtyYThbmrB6wOfLE3HJTGu9U1EsltzMedj4QOaiJKwTBjyZvnSfcM 57zv2KhpbSTUvuasKxDZSGf+bwmDf19w6edfvd3D/AMa+TspnYYwrGTkSCghFIGEEELIe0biAk6n cQx0YyPWNdgwmFwE5rN1XRcDX3QMdLEYJpk0jQjPq1ejC6iBL7oLqC7g0RFw+7bsAt68Cfzmb174 O/xyXwxxJ6sk7mr3bVAf73QjYtFjKO7g6qOO+gAhAPM+T2ehqaHqGGbiZhA+k4uqiRFX6sp5rHbB wppCriaWxsZF17FYsx5ENYyXe4FtITzH7FDWgnUGLnAWKuPWSYa9gG4s1YPwyy4hFIGEEELIeyMA 9/cDPvABEWOazGm/LasAzL9Fl77NjrlzzqXLbP/u3wHPPiuOoD7/xkYUgdYBPD4GDg7iY9jy+Qdk +ZILY58++4JenHwtfNt3FQ211D/ZWGWnh931y/bhisEwhQDV5cdji9rnqI9+2lHPgPLIJ1YIwIuk hJZe4xzD0dOQ6cRVjqpLBXF1JNOtr+zGGjbWCQ0KlX8YKPFLdAMJoQgkhBBC3lUB+OlPyxdO3f1T t286FSdQ9wJ1R2/0mzSG4TD2VJ1B7fqbz+U5nn8+JnWo0lEXUPcBT0/l+tPTYUHeObG7fqtSQQdf 6kM98KUmCGwpuXXp7D6YBro0/Z6guluT/mj7X0EzkhCaCKTkBWJYAl8ThHp+bCfwoj2BY3uBNWVU cAJ9nu5Z+JNMaiLM7ZKXaP40bW1lLtby53Hn/FuDG/nbyv/BgW4gIQOYDkoIIYQ8bF5+GfjIR4Cd HUkDnU5jD2Du+tWK4fNv1PYyFX8hs7lCAD7xCRF7H/qQOILqBOr1Z2ci+u7fB+7dA27ciN2C3/jG xQWgq2qM8p6f6Qv0bqhRXCirv8GnlPft+Sx8phJ8stRX2pVnxkG7UA4jGYyD5sqiJOpqDl/+2h1W 7wjWhCCw/k5g9pgu9D2Blc/IKrRa2ItDIdHzIiumK1JDS7d3gcmghFwE/sMIIYQQ8hDZ/8IXAqZT sZi2tyWMRS0oFYLnKYUvCUAg7gdaIfhv/62cvvhivJ2thNAKCd0lVKvm9FSuuyAqAprcBTznoteg /B0VN9Cl4jMXMK6yD5g7hh5xF67x5Z7AgPgRL8bGQbvK+XWEIM4h8uxrWBSEp32MsV7BgsB1diew jTuBy8/Gpw5rMsns10gZPcd4KFa8hdq4aM1J9uBIKCEWOoGEEELIwxKAn/tcwO6u7OJdvSqiT79V 547fOrn8JSGoP+t9dQRURd1kArzyijz/zo58k9f7zOfi+B0cSB3E228D3/62BMJc0AW0X8CrVXWu 3ulnC92LAtDVw2GAcs+61jr4vFEDQ/E4CDgxgjEU3kdxHLQk+jqs1xU4JviAugu4anTUKiKMiE+s bibJx25dIbHHjueu6gvM/z7C6AUPxvJv08nfAyFEoBNICCGEPAwB+OlPB2xuyj6e3fXLRWApBMZ+ G7dCzzp/1vVTN08dwPlcnLw/+AeBD384JoSq42jvpzuE1gWczy/8vhuIA2jDMMeSQFfp3ID1REAx JdToa1+ph8h1Vpd9NIvOCMZQeEIU3qRHOnapo5d5nYR18laNjq5yEkujqR5pMukqIWhv4tN9ytJt a+Exg4/I1cVlvruJB00JreyO1tzAv/1xuoGEUAQSQgghD0sAfvrTwNYW8MILwN6eiMHNTSxHQyeT GAhjewLtN+SadWIjKu03civofu/35PFfflk6CXd35bkBuY2Gwuge4FtvAe+8IyLwt3/7Qu/bunZV FxDje4FFbeVW98Hl7pR3I2OgJTFihKN3w5HQ2nsZKMkOwBmGJfKlMc3i7xar+wRXVT3UnMNSpUUe INOsHuXMxXRVXBpRVnuc0g9u9IbnF4ljt9nkN19CAHAclBBCCHlwPvhBEXeXLsUgmLaVb8IqAle5 gLnoG7tMbSvrFH70o/JcIchzz2bxeRKry+wCLhYiAi9I7sIVRz9HUhxhwl+cG+akrPySb+4QdPzQ ZSOgpXHQTBTacdBW1zf7asfpRJJEmwbwpe6/sKZAW1UT4Vbcb52gGBWlqCnn+geadAU2QNMNA2m7 ALhObpMb1Us6oDvnSOhgBDSMXz243ATEDP5++usc5HU5+oCEAKATSAghhDwQ+z/yIwHPPCPu37PP iviyh62ISL7BVlqzl4oopEmg+k08L4fvOuBf/2u57jOfAa5dExdQhae6haen4gLevAm88Ya4gQcH DxQIM6YvXOEtVR3BgqgcrJ1ltQTFbrs1gmFyDWZN1kUXp2xXUnPcgPH9v3WrIFaNg5ZeSxgRlzWB 2gHdAljM5bTrJDE1EYDm88/dwrGahtqf98p/8zhHgIw772MD+DscCSWETiAhhBDyQALwuedEdO3t ZYrHxX3AfPRzrA6i9s1Vv5WrYskL2T7xiVgBcXIitRBNI+cPD4G7d0X0nZxEkblYAL/zOxd677ba Ie9l8yOCrvhYhR2zVW5gSfvonRKXryIEEyHq07FQV6qmyHsBV73QWmdg/iGu88Y61EviS/dZRy2F 9L25VSOnKOcaYeTfMOzp8qMybm2pHQN4uNkwTp1i8/vmSCghdAIJIYSQiwnAT386LANYJhNx/TY2 4qFjoOoClkZBS7uA+Qxj6VutlsOfnMhtPvIR2QXc2ZHXsbMjr2k+j7c7OABu35Y9wFu3RBQeH1/s izXSPBRgvUqIWlJo/vZW7QbWnEN1q+zH11XSQZELRTMKaX8ti94lOzsDzk4x3PsLiPuApetqLt66 bt+Ygi7t/LVIOwzz4Jp8L7AtiOTKv1HYf38o/om6oQPoLrrE5y72d1n7W1n1URJCEUgIIYSQcQH4 mc8EvPiiCK8rV2QXsGnSFFAVh+vsANpv2qXL7Fio7vTpdb/7u/H6ppFwGh091eTQvBdQv9E/QCqo /WLdYDz4pfjlO5z/e3+y54X6uGfVCbRKIAzHQe3qpE0HXfbQ5yJqYkRXzUVbd6zzIgmh+edob6OC NO8TVHFqRap1Q/uAHP1zbtr4bxlju5RJvUZBCBaDddwFfveFn92KBygFELEzkDztcByUEEIIOS8v vBCF3+5uTP20QlCPsW+mJeGX2yzWesnvE4JUQvzIj4gDuLsrwTRtG8vhz86AoyPgzh3pBXznHTl+ 9Vcv/PZtITz6QBc/JviyRM6qI+jK+4CjwTJ6PxUwbjjaWRWKGIpFvd8gnMQVqhNqO4E1YdchrYoY fCjnFI9jO4RjH1ylLH50djfUU1ZLqmwQCuPqwj8UrneQsJ/BZRf9xwo7guqAhhKQPOXQCSSEEELO wf7nPhcwm0kAy/PPR9HXtiIGp9NhFcQ6xfBj9RAa7mIrIUIAvvnNKBQ1lVSFp15+dhbTTmxa6ENi pClgWKfnUgFZc3eWtQ/Z/cb6/0o7haOji0asJMmYRrsP0kTXEVS5QKyFvuT3XZUiWnu82vOu+gXZ +5Q+y8Kfa74HWHTg3HDcthTg49ZJLg3n/2OsjYSqALTHL75CN5A8vdAJJIQQQtYVgD/8wwGXLokT eOVK7P5T4aczc+oIrhKA1tGzl+XZ/PY6FYP374sL+MEPyvNvbsoo6GQSxd/JiaSC3r0rvYA3bshe 4MHBhT+DkohLQmFc+bQW+jKmBQZR/1aM1MSKERvqBPos/MRWTOR5O4v+4520mQAcC3/RMcu5+SD0 Mo96Aqi1thzqFRI2lKYrHMH+clBO5smL7AuBNW5EMAaIUEZn9j9LbmBX/hNe7mSO2HmDqx5iQkyp rmLCBUFCEUgIIYSQlQJwczOmbuo3S3UB2zbtBFy3C3DwTTmUryulggLApz4Vnzd/fO0B1FqJUun8 BViKM7e6z69UB2EvA4bVD3CV21jx5uJOX75blpTAr9obRGUcFCtGHmuuW00oYkQA1j5kYHU3IEZu d45fphbGaziO72K4begf8yzI5xPynsCQ6dfQ9/b179GZMdfShOjafYIjonGsM9D+XYUgOnjxMCNI CXkM4TgoIYQQso4AnEyA557DshJC00BnszQQRp3ARGms6QQO2rlHBJuOgoaQjp9aa0uTQd94Q/oB 79wRF/CCtRDJaCbKKZ4PQuLQVfROLRDGOlNLg8ukgw6cNQx/RSoAc+GIdd+fqwhFG8SSO3jrFMHX xkRLgrGowFHf93Mjj4e0KzD/THIBnz+3w7hIDtlz5Ne72mWVn9ftrFSB6AF8mQEx5CmFTiAhhBAy JgD/6B8N2NmRccsrV0T0Tafi/OXxiCoAS6LvPFbHmDjUnz/8YeCzn5XR1MuXpRZiOhXxd3QkY59v vSWnVlRq8fwDUhv7TEZASymhhVHS/LTkGuYfj3XnxqofrDZHZcct3wsEohj0lTHSwShoB0nhzAWY rwg3YGhjrRMMYx+jO6eorAnEipgtJX0u3VebnBrKQh1rGuJjU7E1UXfhgBgsp1YReteQEIpAQggh hKTs7ABXr0odxHQqhxWCuv+ndRBWXdhvzxcRejYdVAWc7QfMXUB7P73drVty3LkD3LsnDuIFvzyP rZytrW8x7uaUbpuHXRZdwOyOIdRDYZz5iLuQ1kPM5yL85gvjDC6AhQe6BvCrxi3HEkJLP59H0eQi 0QrNLvuFjFVJ5PQ7go3++XT9yKf59w01pHMn1vs4/pn8ftbYAVxH1Z33rTgj7sZGQlf97RHypMNx UEIIIaTC/g/9UFj27mkBvIqukguY10LURkDDiEpZVRkBAP/pP4kLePVqLKpvW/mmfnoqTuDRkYTH OCfq5uRELntAwsiX75Igqxa7Y0U6KArJnyOpoi77ol8a82waCXxpzZG3ejgjopwfmeZdZydwnb2+ gPGqh5qjN/YhqLCzvYZNpuJzRQ8Ux2VhPk/tD/RN/GxKt0ucxDV17XlUmTv/XUb/ZjkSSp5G6AQS QgghJQH4gz8oY6C7uzJ6mVdAqBjUsdA8DbSooEa+a+ZCT+sg7HX57WyLt6KW1tmZjILeuCFO4N27 F94FBFaMebpCEKUb/5dmVwiCqYnOZFfQld3EgYi0/X/e9BqWRGnFVfSFZNGqKnYjQjDvCdTUUD0d U9ur9gVXqaR1w2IqI6Olncv8M04cQXMfW7ERxv71IDzUINAoSENl4taJo9uZ84Q8bdAJJIQQQkoC UJ0/FVpqG+XOn90D9H71EpQVg2PuXy4O9fxXviL9hEBMJp1O5brTU3H/1AnUb98qCh+AUPn+vtLp yfYBbcVEXiGR9AAaQWkna6v1EKVQFvPxLbqYJJrvrHlXrjxwvj9K7zUXd4vC0WH1OOiqYJhabyAw HhZTeuyu8lq7cS1ZnGx2BUGfpa+W/lOpZiUVHq8oai/wB7vO3X+JbiB5yqATSAghhFgBqEmgW1vi Ar7wQhSCpTHQvJrhPKKv5O4peR3EYiHHyy8D3/u9Mgq6vS2vy+4BHh+LA3h8HHsC5/MHCoRJugEL I5mD8c2KkFs1CuoK4hG1cBlXuC3qxeRWny+TQ/tdwPmivx5p40e3AOa9SFw0QNPJkYi7MfUEjAe0 hDXu5zCslsg/3PxyVETi4BeW3j6ZPO7S7sRiUG1p9TUPkBn5RwT7+wsjbqCrfFSh8rPuBZaEYG2i lq4IoQgkhBBCnlYB+Cf+RFgGv7StOG5bW2kZfO4KrqqAWDcYxl6u37a19F1HQ0MALl2S0+3tmFYa QhR/d+7I+bt3RQCencnxL//lQ/2sViV4lrTMmFYq3c/1Z5ZBH2bMMB8THYyU1lJCMRST1rHKxaV3 qSAd/1AKKndsv8+NCMIwcvkqMIGXigAAIABJREFUt1Cf35bCj6X69GLSt0Bj8oi0K9B3QOfKwsue sZ8neq2MLjrAXWEsNBkVPedM6MqbZyOhycvt7xz6f+Do6AOSpwz+wwchhBCibG6K+3fpkhxAtIZy 0WdDYB6kC9BeVksI1cv+/b8H/sgfka7CnZ3UhXQuClW9XMdDj48f6IvCaNWcy0Y9rdYwY5+5PqoF vQzCY9xwb3DwWiq7egFpyOrSySoExwwEIGJtRFIRkQs36wrmY5ahILxKYq5U7wDUXcSLFsOXxOqY uM1DXnwMh0lM8cx9HdWypeaU8+45XuzmxcvtR8GRUPI0QSeQEEIIQe8Cbm+Ls7a7C+ztiRC0ATCl OMlVrBoFLWEVi7297v7pHmLTxF3A42OpgLh1C3jnHeA735GC+Fu3gG9848KfS0BdfI1lpeS1dyv3 slzqLBVTQF293L3pBYr38by9LNHsMPevpVhmoSeaiomm//akR2NE3pjYy8XbecvxgNV7hRj5Zayz 1BnKYjzZDaxYunYc1I0F6CBtMymNbtbE23lGQtcdK7XX0RkhTxP8eyeEEEIB+AM/ELC3FwvXd3el EsLu/eU1EG4syeIcwlDHPEtOoL3N7/0e8P3fD1y7JgJ1Ok2fP39dp6eyE/j1r1/4cxmEt2T7eUVh 6NLWgdL1pb1AV9cM6cdmDquhXFZwXhSM/ZN0ZsVyue8WshL0rJpxPpcdwWLYyyrhVjpqoTFj99XL 8mqH5T8eoBxMgxXKaKQwHiMVGcuXlu0Slnr4Eje1ICoHbu9554dHbrpOzoxz/FJMKAIJIYSQp0sA Xr0qu3+bmzJqubUlO3e2EN46gXk2fulb63n6AO11eXN5ft+miaX1QOwGPDwU1++tt4Dr1+M+4LvI mPZ1WeonsF6OSs1hTGoKcvfOVbRTPhIaMiGbr3QWxiTzkdDRN5K/iXXHNtcZAQVWp4aWPkQVjLWu wHXEVEUI1pzCZA+zP7Bqr3IdgRfOd7fa8wXUQ45+mSOh5CmB46CEEEJI08R9QB23LLmAKtjW7QI8 7z5g6bH08s9+VgTqlSsiUFV8Wsuq69Jy+Pv3H0zkoZ74WXL3BuXuKDuCGLkehUqJQTWEER0lx2cQ /GJOgb430KfVEInGC9lrKI2M5q6e9v45iAuneKzu+hubaxwTjRdxJGuCtQ+RaWw6qJdDg2HW+QeB Wieg7ekrJXeGdd77BcdGL3IbQp506AQSQgh5atn/43884IUXRPxtbcV9QB0LzYvhS6Og9pvvOgKw VvxuXcD8W/R//I9yOp+Lw3d6Kj+fnQEHB7L79/bbwJtvyvmDg1gN8QAC8NyEERGJrAMwc/KCeYx1 e81rYqNUE7F0pbIgmLHkz9Feu1W7diUB1mF1EEx+us5tziP+KqXwpfeQCHMXxXPjgaaVHck8WdW5 crG8PWPd4bE/todRF2jfS/Exs9fkHf93kVAEEkIIIU+2AHzpJRF829viBNa6APOyubwcrTbauU4v 4JgDqIcGwkwm8jq3t9PuQBWOzvXFd/MHroVQ0WZ3AvO+v0HLQGFncEQjFnXIIA20sDOWdAUWRvqS MVCknYC+tjdYeK3/P3vvFiNLetx3RmT3ud/nzBnOcEiKIjnkSCIogZZEQkPJEix6vV4YEFZYw9Zl BWgBr58MCFhjoQcv4AcDKyz8YD/4QQsYu7oYCz0YhoEVVhBpeixR4k33mwVJfjEkW5zbufc5p7vy 24evvsrIyIj44svMmjnnTARQ6O6qzKysrOzu/NU/4v/v+zwHWDpzN9KcXY2ia7OA3jB5nk84CmEE mXJqxjFYYUbmijpqyU3szcP6aKxm9CMBGYe3tT/MoIesw2gJjQoIjIqKioqKevoB8K/+1ZwHWObr zp4dVD9uAsPbQa2yYI+7fVrQR+trXwP41m8dDGHOncv3lwzB+/dzNuBrr+WZwDt3slNoUQtXLgph NcgbtWfidF0UluH3i9vBKTACMnMY8jhtB92w8POeGMNILwJZK+lo1q9GuFKbpxUkX5sNtB6XDn5t HtARMG/NBJoQD1OgAzAcRj3kppx3ayiGCMuBMyoqIDAqKioqKupxBcBXXklw/jzA+98/tIEeHmYQ LD+XvD0pB1DLAvREQXhzAcuM32YD8MEPDuHwly5lCCyKH1UCS0tqka0WQKAnBoJC2chBFBoj6Cqh 85LA1UkgKG2XZwAyKLSUQAosI3MYDn5UoevJjWYF1mCNg6S3xTM1LtsIXACgmvAk/n7RY0lF9O1t Mn+Jywx255zU6hyqUD/zkVADo57uCmOYqKioqKh3FwCeO5dn/4oZTJn9K9CntYJKACjFOWhfLVMY CQxTAvjyl7MhzPPP530tuYAAGfYePAC4fTvPA77+elYDX38d4Jd+aa3r5gnkdew+zjCjC22UL7ql kPdkMYlw2Mv6KcE0Y5ABCQrzbR3ab62kPqKhmKn7nIwbKl8tiKs9zp9bAlYp1L4cm4OdR8zOJKZ8 xqDB8qhVtAZiyZcLWD0xV0C0xIC/S04wjooKCIyKioqKinqCAPDiRYCrV3Nb5YUL4xnAogaWEHYa BeG6olRUPel7DpDabGB57OhomAcs7p9lSE1SAReUpeqBAnOI9RxADool7k5UAdGIiYCp6Qsn0d08 4NbVskBrOcIa21Mw5aJsgcZTnQFiNUC0lkGBhGstp6XlM4EdtJgqbyAIx7Afz0RSvyLE/OsxYtCU AU8D6slL3d7Jx2rLqbxbxwl8WDmciUIoO8SoMHRU1NNc0Q4aFRUVFfX0A+BHP5rgypXcTlkiFk6f zopguRXoK3OAiPU2UEoLlurXohCW2xe/CPC935vB9OrVIRcwpakj6BtvANy8me9fGAsB4GuXQzQg w9gWKoAHKMPgCM6EdsKJgyXLAdy5WXYAhwf5ay/MBRYTGU1VmzhHJgf8aSBYm+uzjGIA6oYvoCyr vTkwhejR+8Kg0ZrLk9p0kwDoYuafp48YlkUNtpz7YRAT9TRXKIFRUVFRUU83AH7sYwmefTaD3fXr Gfho8HvXZdAq93fd+Kp0bh6gBICW+selp1LXr+fbxYt5X0r0w8nJWAUs633xi4sugCUzF8kdtCwj OYbyC3K3mAq+mcCd0oeCyEXDyoXIAmRh5gdb5j88zJB4eAhweGo4PcrjZmC8BoOlBVM60JLq580H tACSv5lFKSw9njTPUKOnND2e6nxoOW23t8QAuvw6lafE7TcptZ2XyXFnat2Gcn8591MgYFRAYFRU VFRU1BMKgNev55D1K1cGF1Ca/0dVQHrl2xnNMhbM9b0MhxYoFimqrPvFLwK88sowq0h75vo+g+C9 e1kBfPPN7A565052Cl2hXIYwNXDDejg8f66ay6PUglpAbveVJXloUIrCMoAyDKD2eYCl/FkKXBKg z2oHtSAzQd1QxoJEhxMnVpalD/M5u5QU6GInEIIBXSu0hLrO+0iRj3oXVbSDRkVFRUU9nQD40Y9m AHzhhdxOeeXKWAGkeYAlLkLLAZSAr9b2SZU9yfSlZhZz6tQYAsvjJRpisxn2jzqFLoU/IZ+Pz+ol CZLAgC4KXyCHxQN7DqxcrNNcwhHrpCHyISUhoUExhuHQtFO3SuvohuQEltgFGrUgAVcNEr3toKBs A6Du/unJCmRxEgcH2zD44o0knBcSAda6p8WZT/Spv0vOaX6HxyW0nF/REhr1tFYogVFRUVFRTycA PvssjMLgC1AVuCpK4KlT4yB4LROwZujiVf2kZfn93/Zt+euZM3n/L17M+3V8nGf+Hj3KLqBvvTVW AX/1V5dDIL+2xzEjSPA14QmcLmuCXQJTdkThrUg4PnTqbCAIQfKke7bMCEpzanR7gEo7aE2lAwXa tD5Eax3psc5xDEHZV4W2EkyX281Y9gCpEz7z6LdmL8Z5MTJnKcYwZddReH5DmaPmMi3ndxBdVNT4 T0dUVFRUVNTTAYDf/M0JnntuUPeKC2hxAKUqYAFCrgCqF9GNkQ+cOiwVsDiUvPpqVi5ffHGIhqDP v9kAPHyYfy4xEffuAXz+84svCMzMPpzywggOBQVvFP6OctC8lBUoPd/EGZSrTlouoGBqsou+qPn+ 4LQFdUQSHlOYmkJXA70Wl9Ga0kdD451ym9gya3wCYP4a4RSwvSnt3rnSpeoh/dCjfIgRFRUQGBUV FRUV9TgD4Ld8S3YBvXgxh8Ffvz7M/Z0/n4GqzAUWI5gWF1AOgLUbBb8aJJb66Efzz6dPD/uMmGHv zTcB/vN/BvjLv8zfv/VWzgm8d2/dA4lThqAgpJnEaO19E3ZJMlyO5u9gUBG5yQv9uUMFEgXYnICN wf7cqXLSDpmU10Khq3xfsvlomLw106e1h7YYw2hvQC0LIQkviwE0sOOAwvHvWGA8j+WoMaDWkb0K 8FXalvnxiJbQqIDAqKioqKiox7kuX86Q9/zzeQbwFLF5pG6gJQZCioLg4OeFOM98oAaR5f5XXwV4 73sBbtwYFEq6LycngwoIsO4sIOj5fybQVS7QRQMYqhommU+sK/OdO6jwNvTCoQUFaDpJMaQ5g7R1 dHsbhatb8OZV8ObA3RwYlNpX0QBBwSGUAtSIhaV2WeM8g4b4zSr0Yf0uT6QEd8Wlrz0ulqMCAqOi oqKioh7T+uynP53gwgWAD30ot4CWVs8zZzIYFlMYbrjibQP1GLt4HtcAEiDPMKaU4bQogWUW8Ogo z/09eJAVwKIC3r0L8Gu/ttpxlGBQCo/XYLHW3SdZ/aOybYBx26BkLIMs+oG3jPKL/QnYbYSsQOOY iFAlvTCrvdPTTlqDRTTeMAsAJQLqYGQMg1tjmPKZiQRHIlAha5utkJfW2iu9b54PHuaCpHYf7Zr9 2VADowICo6KioqKiHkMAvHIlz9KdPTtWALnyV2YD0SlHeBS/uWohfY4vfCHDXoHAU6eGxx4+zEYw d+9mUxieFbjwovgAh9suE7Ay41cesLoLJeXPITypaQYURpC1hKIUFg/G/CGOfYDQcKmczBbWohhq 84AczGrGMjVVkd5H2045NFLYq/VDEiCmrbO0zZP+SvHWWhEahfMHGj4wwJXm8zzPz58rLpijnrYK d9CoqKioqCcfAM+ezVejzz03KH3UAZS3hAKMXUBrbqCtYfDaV+n78vP16wAvv5xbQS9eBLh2Le/j yUmGQ4Cs/D16lNXA+/fz7T/8h1WPJ4Jh6CIwQ6fY/aPgOGk5inpnC3d8RMLid9EQaes8CdN2Uf6k E3hU6AP5a/IYmXCAkzi9MyARDVicOxfIlyuwyGcVewKAxK+o32wdQHu93XY0a5nGcZs9ZGdRQICe OYQuPV9bN1GLI5TyDrvQAaOesooPNqKioqKinmwAPH8e4NIlgA9/eAA+6gJKb1TKAEYrNJC9Rf1r vfFt9H129jw5yT9fupRhVhtoe/gwQ+HJySqzgJ0BeOo6zjkplJ5HUQWlfEINUHfwyQCt05RAnL42 FOYCrRewe65E4EkCqB7aDVss4NOoxTs76H2TtHVRoXW2bupZPmOqhL9jXZFDxZHW8xqsuUCeVwjO Dyh+LlpCo56iCiUwKioqKurJBMBPfSrBxYvZDOb554c2z6ICFiWwQGHpX9sNObF2UE2tG10YN5i/ 8G3xbdLlL14E+NZvzcH2V67kOcaDgwx6d+/mVtD/8l9yHiBVAr/whdWOp6T2jezy0ZgJBN9YGipA h3MYpRw+VKIj+PbZW11mArseADfb7DvKV0QF22wGWDyFkGMWvIqgBWP0oFRy8cR+2dZ5QHpzuKck BsyTk4WtP5nZROFXieYD4qDcVk/OJHy/tFoyBkMNjAoIjIqKioqKeocB8Lu+K8GZMxnySpYeV/2k waWu08PgNdCr3adFPdRaQcvPn//8kAVY9lfqswPINPLo0aAErgF+qHwFxc0Tp5AoOYlKy4AT+nhL 6WR9lBl+1w7KW0LZTnFg7DqVa4b9YA6iVfcbzTkUFOjTtlvLIvQMUxaS5+2g9LEehizBBNAd5G/7 DTtuBiQh+OB4BICOVJYaB3qD4yfbENaJQPmogMCoqKioqKjHDf6+5VsSXLuW3T/PncvumcVIpUAh dQGVYiCsanXz9OT+Saoive/0aYBPfSqrgDdu5HbQrhsMYW7dAviLvwB4442sCBZn0JVUwFonpHa/ CXJYX0bLBwQGmqOgd5DVvvKcJT+w64avBx3A4ZatD7e3g4N8/0E3bQdNjC4mamWqHDwN+ji4tdJG aoDD2rrVN2cMqqNj3mVFLBGgLKqpmKfIn7MfA3oV3HBQfPeiBlqHhkSGlH35Vy9dTT/0JzcjQj4q IDAqKioqKuptAcBPfSrB1asD8F26lNsoeR4gVwEt9c9q0fRCoLVsDQQ/97lB+SsGMIfbf807R46t q8jKKqB0nS6Fwottonx5w/1Ti44Q4bOmsNG3ALZKDgVKLW5ACDnnyxx0g3fQ4YEMiKMqc4EgHCQO gpqBayccLD6LZ5nAtMwfWjETCjAmmCrEFqyN1FWcvr6+zwpjf0Je6h6BTtq0Jr5aXI4Vno6KehIr jGGioqKioh5/APzO70xw6lSGv4sXs5PmxYtZCSzgV9Q/mgMozQBavWeW+Uvfr2cGQ+//7u8GePbZ 7AZ68WLe577Ps4CvvQbw538OcPPmEA/x4AHAr/zK4mN6ANM4CIMHplCH8rIFHjvwiU0TkFBgUZv7 A9AVQjTsRfs05uyJx44CfxP1qpZ50aLQpcZtaKYtFix63+DyHic/AHlbQiWzHnW5lg805uhz6HxN pMIgJuppqFACo6KioqIefwAsge8XL+bbmTO5JfT8+bEbaMfCzBDbAHBOC2hLGyh/7NSp/P3p0/n1 XL5MXEs2gwrY91n9K0rgHkpS9LghDG/z1ExiPFBH75DMaCYzhhzy+DLbw4bbWbNOijAgOzABx05+ TdLbVgVA/r3WFioOtxnAaEGipQR25PlqWYdgwK90bHBefh86HELL8V4iFnrXramGdL/DICYqIDAq KioqKmrfAHj27HgG8Ny5fDt1amz8wucAKQhqAOgJc6+5gFptoBYMfu5zGWhTAnjmmcEcBiCD3p07 AP/1v2YV8M4dgKOjQQlcAfhUEATSCmoAIBisgsL33uKOnx2y9A4Y5wMCg5EOhfgI5TVO2kZhUAhP NsM2+z5n25VRTfRAgBXzUJsJ9JrDWK2gNdvWjm2jgCKd7SuvGQAOEmT5GIZjUG6tbzJ1DXWZuhRH Uboe2p+ztP5CWNsq4NcbTB8V9aRVtINGRUVFRT2+AFiiHg4O8tdLl2DXFnr+/DgGohjAUEWwShtg t27SFtDSN7hWK+gzzwD8lb+SW1sfPMigW1pBqQqYUv75+DhD4Je+tAoEdpiv6Q/IV9oaWpuNEucB FZVuotpx10+AqToHU1WuY+YvB8T8pdynwd3oBQhqYIdTRkMN7gDkfMBegbKkABw0wF1ybMd6Xuu1 gHyMNJVOYsvdZy5klpLOU4qGPo5gSlzBgsWRhiGq2wC64+3PR0to1BNeoQRGRUVFRT1+APjpT+cZ wKL+XbiQb2fO5Nvp00MuIA+Hpy2h0lWkpeLVoNCjAHrkic99DuC9783LXriQ5wFLUQgscsdmM7SD LixrBrCWAUiBrlpEIXLG0g3LJWL6QnmI3k+cK/lbV6IiuqR78qQeoO/ITGCfYbIoTtiNU0V2p9ch TIceRSqCqaMIndHrQJ4t1IxhwIC+ltZQ6Q0wFEnU+iSpa6sG2zCAZBLaXidZgey5WpW/OW2jcw1q wh40KiAwKioqKipqTQD8ru9KcP58ngE8dy4DUlH8iunL2bM6/NVaPyWI88z9rdUGWh77yEcAnnsu 3555ZnAJ3WwA7t0bWkFv384/l3bQNUu4WMfGVdWvimOoFUnB153ESOA0u4/CimoOw55QcxFNoM8x jgDLQwPegHjtwHoVPWQ0Q105E8iSKhqvp5FwJpmOgvLXbZ+z34Lc7ngT8JowmAJlVVabQYItLqEl UjEoMOpJr2gHjYqKiop6fADwO74jjSIgrl2DnSkMzQHsOv2m9gKCDHX7unFALLfPfS63gF65AnD1 aobastzR0QB9Zb2iAh4fA/z6ry9mPvGGwuNGyLsWFt/BVClEBaxA2C4PogeQoc40qCEtoxOnSw6C YMdKzK5aVqD0WDJuoCynAafmDFpiLTagx1bAFKy7A3Kjv261+E3hPZjkOm5bSKlBDxotydZ7Sj/M qHEtOn9frIqW0KgnuUIJjIqKiop6fADwwoUMfMUJlOf/HR7mx8rPPAxeuzLUgMyCQm1Zej//3npe Wt/yLXkO8PTp7Ah6eDjA3r17ORT+1q0MhHfvAty/n4PjVyjuvlnUDY941OG027GW95caLrr5Jrrt NzsjmETUI8XBkraDouAOyk8VOg+YUjaEKfcV5aqnp4EUvyCRtdaiyfdfav+0Yic8MRIWJHKJs9Nf E1oGNezk4OAvAeVEjAcwVbs1IwTntonSDyiomQ1AKClRT3bF+RsVFRUV9XgA4OXLGYieeSbfigJY bsUVtKb+eQFwDXMX7+PS8s8+m18PXf/kZAiso1ERRQlcCoDS9TtOmUAzexltB2VFEMhjIiQqpjAA SjyDZDajqIHcUZQvk2Aa/VjmAVM/BkNp3nAWdWiZfVLQuxUMP6dt0wOCjg8NLIqiavHBgfDryd4P 6jqKShuv1L5rncet5766HWz/sCLUwKgntUIJjIqKiop65wHw2rUB8krr57lz+Ss1fylOoYeHRh8f yC4SGrhRx0+6nPb93FlARIDPfx7g05/Or+uZZ3Jb6OFh3ofj43x77TWAt94CePNNgDfeyN//8i+v AoCqcsdYAR0X01hZNzkvvjn0aXN9Yn6gZFCigCBwqFXAw2pxLBCJNbrQ2kE9DjkJ7IgIALtVFKAt aB4YoJJb8SeyTmmQgt/RfrPpr2eqnGgIgjkMshNsJoY1q4PkudLMbURFBQRGRUVFRb274e/llxNc vJjdP2kExMHBOO+vQF8Bv9L+ac3/SaHtc7IANQDk64hXmEm2rrxxA+D55/NrpY9tNoPxC1cBVyxt LrC0enbOyAdrWyPYFOYNqxfnaZwft2MeCgHCFf0uR7C0hPZjl1HgoNlN5//UMHqLHtABYlqAohdq LJWQxlOU9tTS5tlVyN5QGFFzaOWpKf3QMmuddEidQPl7Vzmca537yfi5dVuA2/zEqKgnsKIdNCoq Kirq7QfAb//2BFeuDDNxly/nGcAyC1jC4UtOYFEBS0A8H+qyaEICO577x0GNL6fdp60jPfb5zwN8 4hNZBSyvuTiClviHP//zrPyVecDiCroW+BkyXmrYFl8/OWBTel7JEZRnyIn5cgKMgqQesrhI7lgp nTmbfnzrt3ESiUAmAPhzAmtqnTXn1/rmtGQEAoHFAxgGQ9mwJ5IsRmrES41huBKY2GvUfj0Axq23 kvkPkPeWgqn1a6+ZwzQBHsjtydLz/t8fiZbQqCevQgmMioqKinr7AbAEvl+9mh1AS/RDAT6qAFJz GJoBWDODWTIHyNejP4+ucsE3LFb62K5eHYxtyv3FDObrXx+W3w2rbVYJh5egrOQF0q+a6YupACqt gKL4lEBUmehDCfSYCakldBJIjyxYvhv7B5W3bNOP59MKsEhuqGLrpEYOEoBxYxjheFTzAVvvs0AU HdtAQ5FjgfK7Ftxu+iuIsM1rxEGVHXVrs6+jXS/LpzrLLlH0RiJsZWO8HThhXExHBQRGRUVFRUXV AbAA3bPPZtWP5v1xGCw3j/nLEvizoK8lG1CCP4CsAn7kI3n5Mg9YZgEfPcpOobdu5VzAW7cA7twZ XEHXAkDLvVFnNfc6EnBOABRloxir5XQkmBGn0Mm+aZmB7O0YfW6AlZiBNWMipLD4WhsoOrbngULP fipvJNZ6M40+X83cRwqOpwHy0gcDbpJbaVH17RDGjSMyMCogMCoqKioqSoO/kv93eJgz8i5eHICP hsGfOzcGQ8tOUAJAK6OPL1dz95S26VUB+dXue9+b20GvXRtvb7PJhjDl9RQFsNwW1kjxg6n616E/ 96+qCoLtkwIaXBpzeLXsQunJdhERW7XvAKaKIYAMnMDbT9m2q8KvJ+ePRkhIIKipgckJctbzW/ET bBnrvfS4eoJi4kN/pft+G8dRAGsuzK5cXlDsIEeJ/PxLV9MP/8nN4MGogMCoqKioqKgdAJa2zlOn shFMCYEvN6r+8f49ywVUg7E1ox40uKTPZbWjfuELAC++OKiAJf+w77PS99ZbuR304cOsCh4fD1ER fb/o2Ndm8jxsMBkjRDk3cGIkI/1sXXGj7CjKs/2AgeDEnZLN/XU8VgINwxfYmpxsObxDgL4D6HqA 1DFAkbICgUGdpx20F16wdCBSBTI9cDrn5JEAUAF5bTtShOLoMxLympHCOPtVKuvwr9JnLi0topNl iYENgqxIIsxO3YiKCgiMioqKinoXACBt8bx0Kd+K8lfUPgqJEgB6swDntIIW0JozDyj9PLqY3O7r hz8M8A3fkF932db9+0MI/N27Q1vo0VG+/949gK98ZbX3wpqtk7L2eGYgGFyCnot/SWXE6SwfdxTd tYHCYNGfNGCU4h/IHGBRnVI3LF9MTqjpiXqaVWbTzLlADpAe8raUQGt20LRrFZbp2L4RMC3HKDHg LMdzZOLjOvnkBBf6hk9aQnH8eYs3s7Fl2clhVShSawmNigoIjIqKiooK+Pv2b0/QdbAzgDl3LiuA V67kK+2SBXjmzAB/pVXUTJKuhMG3AKCVD8jdP6WvNRAsV6DldnCQX39RAanNIsCgAhYlcKEKCOBX 43ZGKpVlUNmuCH0Gt6D2FhbgTGOwEHMDQYe03Vu8bQs94GayhixptTkmC7qU/RnBleR+IwFggnpO QktOoLclVAJ5FhMByThWXTaBGS22hXZ6vhj8t8zlBawNty+GUFcD6XLREhoVEBgVFRUV9e4GQKr+ FQgss36nTmUIPHduMIJLB0cpAAAgAElEQVShOYDeFlAOZjwAXgNCCn+tKqAGfBoA/vt/D/A93wPw sY8BfPCD+fWmlEHv6CgbwLzxRlYCHz4cq4AruYIChzTJEdSYC+SKYAe+AHgJRMv2+RW0FALPl9Py /EACURYaPwEWmJrl8It6GlWBwmmH2gHwDEgiA8POCS6SupigbVbQs9yc06vSDjo5NtIu0KzHym7h AjVuLmcm6TMe+vpDHYwKCIyKioqKetcC4NmzA+ydPp3n/woQnj07zvujgfBcAey68dV7DQC1WT4p 589rADM3EoLvZ2l5pQNM9DWVoPgVVcCuxiMJdHMVB+i5Zv04+IAgghWliGy3g7Exzeiwk9bAiSMo CFmAKERdKC2MXEHcbPKyPWmJHEUb9KC3WmrgY9lfanEREgBK+YL8/tQAelyttGCNwdDIaEeRgKUM x8K+tK0U2bqpQm+459bMmldPyH5RAYFRUVFRUe9u+Dt1Koe802y/a9eG1s8Cf9QNlEZASHN/tfZP q6WzBoD8MQv+WhxByzKvvprVTgCA979/gNq+z6rfnTsAr78O8Oab+etbbw0REV/+8joXsCiPhfFZ Py3CwQK9BJUZMLoNNMbSUIAzZuYyOi2QBcqzdsXRW7yFuW572Psu/9z3BOqMl4BK/2rabtd87VIr qIciPDOByQF4HFbpvJ8Ubm+dQ9s2TzoXSI8zwlSp1Y4NJrktdJTRx8gL6QcGCgy2AqHV/jnZHw0M ESZzoj/30tX0I9ESGhUQGBUVFRX1VMPfxz6W4OLFDHlF5Su3c+emeX8F/CQVUAqB5yBYi23wzAFa 8Cd974FACn/05+/4DoAPfWhodS0QWG4AUxVwBQCsuYLyQHaLZ8XtKgHx1bgIIWoCQGnttJ7X2g5X AjkQazOFRAFDFmUAFd4yAaxlHlAiETDgMTlOgEL9yVimE/ZXcl6FOsjW2oIT2lTGZwOXdll6AuCb t2dwfxf/FqICAqOioqKinmr4Qxyy/grcFaWvqH/lazF/KY+fOePL/RtdeDrz/DQF0FIFLfjzAGBi bhmvvjpITS+8MLY1fPQoq4CvvZaVvzIPWJxBV7hIlWb4qPlLh3rmH/8qQp/yvC44QvfdkygIbhDD AYNCXtfBaLZQyv5DI+CcH4MmCpTUP00N7BVi9swFWi2hc/Z5zmIMulNRDcmvDG5zAFO/vVkuqzhW WVtNZPAddO6MucCogMCoqKioqKcf/oqKd/bsYPRy/vyg9BUzGBoEX0CxtH8WEBxdpRsZgHPz/1rm AjUg1CBQA9ZXXslK4NWr+XUDjJXI8vPx8aAErhAOjwJAoXN56SsYcOaaCURdyQMl/H0yNkdUNBro zk8jJJJMmTMbibNM5ZvADW8l7QE2yGISgLRF8kgF3H5/wIAM2fdWL621jDcTsAaeMwFwsjjKc5bS CTbJdWSmKik5HUKVTMG9wZeSGbh7q4SW0H/10tX0Q9ESGhUQGBUVFRX11ABg1+W5vxLpUGb9Ll8e t3yWllCaAcgB0Bv/IMHZnBgIfp+0Pf5ccyGwPMeDB8NV7slJVvpu3swq4K1bWRE8OhqUwJVyAani 1QFzAxXcMT2wCCA7akLtZzBi8agpDIOeURsngccO5fbRSXwFcwotUNcjCYE35uFGIfXYyEuedlCt 5dMTDQEChErfSwCIBgBqLaOO8220eak91BETMYJDrcVUmAukLZ9LVcDJXGDjhy8p1MCogMCoqKio qKcC/l5+Oat/h4dZ2aOzf+fPD9EP5VbgsLSBFvijuXitraAtAOgxg9GiIbT7NAicSE0A8IUvAHzf 9wF89KMAH/jA4Ara91npo8+92QxK4MnJ+m+e4a9Tg6gRCIETEMGXU863vdtHnM74jQABBDdKkGf4 JpESMDWX0aAVLQ5aAhqanDQhiQqwJfC3g6aGfVOemxrDjMxhYPiZA7P2Pk5yBWEw6ul79qGA9hI4 LKaxWcsScxiowGkNEgsEh0FMVEBgVFRUVNSTC4Df9E0JDg7GmX6lzbO0fkrGL+fPj1tAJeMXbwD8 nPbPuXOAtWB4PvtHAbB8//zzYxWwrCe1glIIXCEXUIKu8lWKXbBaQDWBygN4EwiFqTI3ggJ2AW3Z ke7eJrJMARHqCJoYIIkuo1a2HTeZ6cZ+Rk09sV4lEMB2B/VCHX0e1ZYVdHMYYOtLu5AUSNZ2CYkx jNASOgGzBSHv4jIzFTpsOOT0+IRBTFRAYFRUVFTUkwd/3/zNCQ4Pc+snwNjkpcwAHh6OTWGKOlhm Amn8A4dAmgFoVS3AvcUARrpf2rYXAqX64hcBvvu7Ad7zHoBPfGI8C/joUQ6Bf/PN3Ap6+3Y2hTk6 yo+tAIC07XMUBg/DbF3CeiuoBHycQVokjlGXI2t5LMYhGneMzGFAaNEU3Dwns4ccBEE36EyQzUv6 7bKb7cJdD3BAsgKRtl9Kb0YPMiXxg5ucZFEDQI9BjOeNEtbDytOhYA4DgjkMeuBKaglNyuMGcK4V FWG9LYmcmylaQKMCAqOioqKinmgA/PjHE5w/D7sW0NLayY1faBwEzfwrP9PoBx4GbwHgmvN/0mNS tqD1tQaB9IrzwYM8H/nii2O62WzGraBFBTw5yUrg8fEqECi5eI5cQitKYI3LJwClzAOaIhl7UnTE C/BsQDHLkM864jQIvidGL5iGmcCRwEs2qsVJpBpkJeN7T0B8qpCIJydwQraN+0myBPs+K6zSZyU0 8WT0ayd9YkCOZzI+90m1/YaGY9VCdwtWl8AzWkKjAgKjoqKioh5v8HvppWz6culSBr3S+3b6dFYD r1wZt3wWwxfeCnr27NT8RQuCXwKAHrdPOv9H76PbnwuBOztDcuX3678O8P3fn0Hwve/Nx4EC4P37 AG+8MVYB799fxRDG6vaz1gGoKIAot5e2zP559tkyepGAJhE3yd3bWcLggbSHGqBci35AYZ0knRYt Tp0TCUn42ZsnCAokJeMxcO6rAuHSMpPPdND4gELN3RBAq2YMw18r6B3aa3zAIrWTSoH39PWGQUxU QGBUVFRU1OMJfy+/nC9TrlwZDz0VF9CzZ6ezfzwAnkdAcABscQBdM/tPUwABxjCoAWj5Xgqrn1wl kmG1D394+ppOTob4h+ISevs2wFtvAfzKr6z2fvLWSVA4wwuFGiOgd2cY5Knjfskwr+HmMEJO4Cgy gs7vlRm+7fddJ7h+YuUl0GVr6psHvJJBDx4gs54nOUFR+rSgBMqXYbYNTBXR4qhKNlmiOLznkGQM A0BmOVlOoMnZBmil5F50VkuotCxGW2hUQGBUVFRU1GMLfi+9lHbtmZcu5asWquaV2+XL4zZPvgw1 gqHzf3McQGvGLRz2WpRAzRVUAj4NCKXsQq4G3rs3zErSKuYvr7+eoe/mzRwNUVTAteBPAC3a/tmh 3jrJw9PF7dVaQReAI2/fHMUKKPtJFahOgkOUgQcVoxSeE8izAgGGUVbXC+4FSvC0kaIBh0n4qrVN tiqWSdkPNAArjUEZuwxwO7hL018Zfl4lmMJ80oxxWBstprc5NF7JDOQ835G3/+dfupp+OFpCowIC o6KioqLeMfgrqt+pU1nlo/N6xfmz5P6VrxQKKfxxACxXx60ZgLW8vpb5vpbl+HNbXz1Xk1/6EsDf /ttZBXzxxXxsUsr5f6X1s2yz77MaeHIC8NWvrgOAwn1eALOYzq36CRsQlT/JqIU+5Own3b2NHXME BWNeb9symnAbSYCkxc8wQuGZimkuYKXWAwrL2gklh9DU+Jxo834ioA6VUV9wtINKUKidkKOwedh/ 52XLc4QYGBUQGBUVFRX1zoLfN31T2l2ZHRyM5/0QM+wVoCvOn4eHeVlq/KIpgdz5U2oDrV7Jw3RW rxX4WmcHWyBQvCIUZgK5ClhyAB89yiB48+YwD3jvXm4JXeniVFL2OmoIA7I5jNTGJ96w8jP45gIl VW9yfb+FO9SGFWGqBKJTCfR+NkHfZqAqZRqcQ6EHOKDP1cNU8atRAho/11pEPaY0/Odi9sIVxF7Y b3R8SgC2u+yIgTXzGO24J3+GH5XkrLnAJVERLZC4i2XB/AFFVFRAYFRUVFTU/sHvpZfSLpuvgNnZ s+N5v64bYO7MmSHXr4BdUQelts9iCqO1fXadL/pBshpsbfn0OH/yeUDrq9QSWqsvfxngM5/Jx/E9 7xlUwJOTDIAl/oEGxhclcOWL0DkPYuNzNEOis42Ut6SC9hwotxXyoHLLmRSxcgBQcC3FceRBFcA8 LZ81h1BQftbMX2qupNK+pMp9pI22xD90aXxKIz9mKIMdog5O/PMVwEr0YlkmtRmELga9SkSFBLDR EhoVEBgVFRUVtR/oK06UKY3dOc+ezfcXcONgd+7c8FhJwS6KFm/7lIxfJPdPepXNP4q3Qtq9rZ2a 82drSLz1tQUCS509O95Oafu8fTsrgNwVdMVW0J3SV1PolBnB0fcCuFm5eqCAlkZ5GtQBOJxBkZ0+ OA6HpwrThG/o41s1r+PcDwxutuDTUwjywF8NAKUDV3MPlQAQKjAo7Qt/fi00vgeX04sUxyGeC0y5 3R3XrVlPt3V3hd45z+fIC2wGPMd90uOovLUhAkYFBEZFRUVFrQt+3/zNaXc1deYMc8nohvvKz2Xm j877AUxn/Cjwle8pJNaMX5BZQo4ugCvB756Ih9ZWUa4AWiAo3WddjSLmaIfPfCYHw3/DN4xjIR4+ XM34xYRA1K+7KywlLj953GgLbImEMPdt+6RiF6SQMSe1gwJUIiAMJVGFDLZAAiXuoCNfOwZz1CCm A7/aBwoo1iBPO75pxsnF4F2DPaRq4XZOsyNuo6UdlB77ROYUNUWwuSV03UX15Z0AWj5giZbQqIDA qKioqKh50Pfyy7nFs8yhUTOWcsVUlLxyK22dfOavXKnRlk/u8knnAMu2aKunBYBSpIIGfuV7r/un JyaCBrLvQwVEnC5z5sx43UeP8tzfw4f5+wcPsvp3715WAr/4xXUAEGT46dCev+OwZ7V2ztmn5m2h nHU42eeSEUheALIYAxFgmHkJNzMZgZXw/FpovApb1mxfqgBfsvermWrmvJk1GEXH8uwhbHj+UUto sg9V9RAszX+oHB/LJZQuGi2hUQGBUVFRUVE+8Pv4x9NI2QOQlbhSGgSWmb/yc4E/Hv1AFb/Dw0FN 1ACwQCgqtoAe5Y/CmgRzfa87e242bfOCLeBXywMEAPja17IK+IEPjGcBHzzIpi8PH2bgK3OBZQ6w 71c9T7Tr+5FJDEwNYbg5jAaIKuCBMvPHL/4rF/s021ASk3nraIdjJ9ER41RgTdoWzxOURG5g0Ike aAKDvD0uoakCXPRrz75PoMdHWI85XwsaYJdq77cRE4GQVbO03a/kAED6g+TXtHZbpsdcZhcbGv/G ogICo6KioqJc4Pet35qg7wd3TnqVVWb9gF2BUbgrtwJ2ZeZPeowrgOXx06d1xU+6OkYjSMyay5sz zzfHCXTfs4A8F5C2zQJMlcAVwuElAOtAd+6swZgEeQCOlkkvnBrREKIKyHacQhvfr1Gmn+A3NGIf lgG46bfti/xxEiUxgsY+Z6iX/epQgSpPHETNFAYNqpLaQS2TGL59fhOMYMxkdfK1nOY0Z7FEd5gK qrIfHmOY0aHTsgJn0N/cVlHtLSv3R0toVEBgVFRUVJQMf5/8ZNoBxJkzU6VvdEWF44w/3vZZbgVQ JNCjBjCnTg3rl6s6K/LB462vAaD0mKQEWu2hdM6Pr2uB51IVkNdnPgPw0Y8CfOxjw/E+Ockq4J07 AG++CfCXfzlEQ9y6lUFwpRJdL7XrdTYz14Ev0sF+0nmPSypaEkxjaAA8sF8D3ss6mfFTMuhQAMuW SvT5NDIBBmVUqevA7wiqHdNaRIRnvzzVjdfBNMz7oXX8UHi/G4+z1HFdA7bJ4autqxxvT/doS9QE DY7/uZeuph+JltCogMCoqKioqM9+53cOAe50zg8l6YTduKJXlEMKcNK8H53zK2YxXO2rwZ+m/tVM XzQAtKDQMwfoNZuxTGCqV52k1+w3fxPglVdgN6cpvVcAgznM/fv59qUvrQqAlvuny3FTeInurD9l eUn9s7Y5aQ/EKbhxQ5ddRzSFRRw7VWqAJ22vBX5N+KOAZjl9eoGvBm1W9EMLGM5ZthIOz4GbNjFI n2lRF1aPL9PkmElK6p7Ut+T8XQISX9GFXWhUQGBUVFRU1GdfeSXP+xWjFumqCECGMKrmFfjjs4Jc 9aNKYXmsPDeHPc3504I/8UopzY988KiDc24WAPKfpSvQct8rr2QF8AMfGK5uSzD83bsAb7wB8NZb +efj46wQbjarAWC5qDwAu2UTHdDoUQItiKNHqAMW+o72RifGNoKiuTODIYphYjs2gVBJGcXpc2Hl yn7ymlMF2Gqv2zMTaMVIaPvB5wBrb2aRp6w8EfC9dxYVoXIga3mBNRDcLW+4i5pPsMLvYDK2K90d /BcVEBgVFRX1boa/7/u+tIt14FdDktrHAY23e9J20AJvFPooLNKbpPR5HT+1mjvHVwM+zf2zQFWr CuhpA7UkiN/+7dwKenIyVm/p6wEYwuKLUcyv//p6EIhjy34toJ2+dbW2PFWBawTEVsCkF8i7dk+Y Gr2osQ5bONzNBJb7ktweuJsfLPN+2xFck57JhkbrgjAX6K0lM4GjgzbjJPLCInmO3axkyVmkvk0a GzvOAW7yQj8T4+fEhJO38Cu1amIaWjZVBlwaLZH0rEBUVoqW0KiAwKioqKh3GwB+//fnmAcJsPj3 EqQVh0+u2HE30PI9bRctkQ8Avqy/lsw/AD2Wgd/nUfPKMpr7p9cAZu1ZwHJ1+pnP5EzAF14Y309V wJs3h4iIogSuXLWWTemrxoEuEUgxd5HaOM0nVOIgxBZOkh9YwCVxlY/96nBTG+l18DZTUPZlIo53 srpoum/ytlAL/gD8auESAISG9Y12UHp8drAIAF0aNzcA6h3uiZxEBeJFAEw6yGGylbmF/Ceu0zIX CLAVX6MlNCogMCoqKupdBH9/82/mf/s0wJ0rbDzsvcBZUfF4UDvN+qPQx4FQm/mzlL+a+idl/UlA VYM1KQJibcfQFhfQ2jxg3wP83u/lVtDnngO4enUAa/5a+n5QAo+OVskFLBeSHY7zyCe5gAYIarmC reDpystDB0uiMrvIwAGFub+JCqoBhxB6PgmdT4M76KYfz6mlToEfL3AVYxgrKF4iDQsYOQjW1EJt vzi09uxmvHnIPhuRfmUodLcAVhJ+VecoeVqUBMwEuTlgyY9PF/8SowICo6Kiop5y+PuBHxjgjwLe 5CoJpurcwUG+cpAUPu3GW0BpMLxm/GIpkhrcUQCUAt9rRi5WLqCVD+ht+WyJhvACYJEkXnkF4BOf yKpseWyzyaB361ZWAW/fzorg/ftDPuBKF5iTTDyy+7xFdPTZggZhML5Q1wxfPGHvAEo7Ktih9VTt 21nqgzC7J8z/8ee14FdUK3GqNI1AEqfQhDXgsyIiWmcCtZbQ5Hx+DwxqhE6zRyCrbZi2YEyOkctM F6d//lLZJlEEd3+iYKuagdAOmqafM+xcW1OdrefCXMvCNW+aaAmNCgiMioqKehrh7+/8nfx//+zZ MUhoLZZl1k9qCZUgcGSP2I1bP4tyyEHPav2UoFS8YDTm6uYYwMw1g/FAoAaqGvR55wEBcovnpUtD OPxmk2+lJfbhwwyEX/96BsJf+7W9nGcUblxKINr5f6kCifa5IS+DPNePKXAd6KdkUYNGs4ykHZQD 5OgUAKVDM03zAHsEwAP5mInrp0Ex3KmCrfOA2gFXh8sUcKsZ1UjKIzLA65UTK9mw6HabVT6BQO0p 2eufdKLXZiVhr8ags56v7HK0hEYFBEZFRUU9jfD3Yz82OH7yKyEKbxxMpFw+S/njEEijHwD8M3/8 Kl2DIgkAPUC2DwDUgual/dDAtUUFpO/hlSvZDfSZZ8brHh/n+b+33sq3W7fyz8UZdKWLzA58EQ4W zHiA0rW8MQ+ohdVzgOAunqKCxzMAse74ac0cWgcIW9o8wZkVKAGy1eLpjZKg60ltnS1KYFp4YvKn IaDdJ/lXlR9zaS6Qb5ivjyiHxlPhnn5tpUPPogi+ZIrRPqTm2MSoqIDAqKioqMcS/v7+38/wd/Hi 8N+e3iRHBA0QeQC8BH9U3SuRD2vk/IkXiQoM1rL9ai2g/DEJEOe0gFowaL0m60q/PP7ccwDveQ/A 9esDcHMVsO/zzycnGQC/+tVVzzURnhyuoIhT2FPNWGaA4qg1L4EaXg+e9cmFtBQPMdkn0poozQ2q 8IrjUHp1B1P9uIhgxefuylygRdtS+vnaxLAW+Al5iwcdAbZuaxCDfrDazegpHxxIwFmb+2sFu1lw WGke4PDaJYCff+lq+uFoCY0KCIyKiop6QgHwJ34iTZQ/+p9fgy4L2rjxi9bOWeIJyk2DSmnmz3O1 4oUvT+C7dF9x/1wrC5DvK38NHgDUWkE/+MFsBEPnO8trODoaHEFv3crzgEdHWQlcEf5mXqeb29Cg sHUecKTkoa0ASpytze+JCiAHzAQjpSj1AzjSq3WrHXSSt+gIbXcbw3jfvFqovBU+N9ccxrtfzvMx KQuUY+sCQGN/d7/aqR0ANYpbag6jKYBWVER0g0YFBEZFRUU9qfD3kz+ZIKUMBRJYWMDFw+Al5Y6a vdBlynNp68zJ+ZNAyQOAlpon3a+1iFqGMnOgb04uoPY+lWUePMjv9dWrQ0ZjcQCleYXlvuNjgC9/ eTUAHM39bWfpOvL9ZC4QZQBEAXYsAGwhUNSoE+V2zAk4MkOWyWsRlM3RAYKp6gla9iFrM+23Sl3J DSwtiiNoZCDSFxDpt94pPC9QkjctYNOWdczAAQNi8daDv020BoPMrMf8IIJ+BtWNvGZG5jClFbQs 1/UAPZlZTCgcCu/xmQl5axnEaPWzL11NPxpqYFRAYFRUVNQTAoD/+B+nEfxp/uhYc8pAXQEsSp8E cTWjF6/yZ6l+FGrmBL5LX2vfL3X/5POCGuR6IbDU9esAN24MjqAc+F57LSuAt28D3LmTXUEfPNjL uTdHEcQZ61omMZZSyEPcvS2Nu0VKzhx350Q7i5C3he4+Q9neuvJZChfIGUBCBWwWKzie7D80QFBa Ps08iagxDBo3QmwdjM16qi3F5E9RUiBpMheYfFELEmUhgcXRXCD40jmWvre1ucCdw+y2JTQqKiAw Kioq6kmAv5/6qbH6J4GGpbxJoWdc6QMYK4kc7GpqX4vyJ30/pwW0zMF5VcJW5Y/ujzUvyPe79lrB c5UJ2einOK7S2mwG4xfqEnpysmo4PFfoqAqouYNyJQ8NgLPgsSzfNYDkRFUUwE01hcHB8GPkDKoA JSpZghNWYgoebk8l+paP2k+dBOharubwyTfmiYhYA0bL14bA+MTPKXTwJsrclqQ/M/04E3DSYinS lbB/xuFOK/1OTrYVrp9RAYFRUVFRTyEA/vN/nmf/JADRQI8DHV/m9Gl7XQ3yrFZPT8C7BHx8We/M X+37pQD4ds0CakB448bQBvrMM0MsRMkFfP11gDffHN/+3b9bFwCVi1pUfkaU16+INdULXjFgvnGj E9dOZuqiAoTyIhJ58SPI64eQd+TPBRUnUP5rlZwvMTGA04xheshDiBqpWGHxFsw5wXV2lIX1AYWQ AZi2sM3Pm1Q52SbuoNKwnfLLQNVkul5NCbTmAltdQqX7dm/p9psOAMrHRNESGhUQGBUVFfW4AuBP /3QaqX8cPCwIo+2ddF0P6NFtaIDouohLuspVU9qsmAcN9Lyzf9IyEoR6nUJbINcDgADZDfTGjZwL SNffbHIeIN33lRVAepHN1b9OmQXsiHLHlTxUDFwkwKs5gYpcIsCnGu3ANphgqg4CKooin1uUoBcF 2OS/SmwfavEQCeQrfayt1HQQG7aTFAiVIiJqcDfHJMajArL3bbIO+mGs9RfHCo7fm2onPK/WItoh wCbiIqICAqOioqIeQ/j7mZ/J7Z+nT+uKkwZ5HtCQvlKXz9qyFvTxffCaqUiANSfeoSX/b+5MoLQc f61eCJQg+T3vya2gly4BXL48qICPHmUAvH17cAS9fTtnAx4dva3naItr51obt8bHJqyQpkDGZ/CQ zf/x+ydGujQmE8c/TyIi2Omf+u0IHI7bDgGG9lAk7qLUGGbHWUxx7Le/tihBWO3gS1ClqYCWqtcC fC3ruT6lqJ9Do/dxaw5zUJ6/I59TEXOYopoWqE98v1ujLhRlcM3fxbTm729UVEBgVFRU1DsAgL/w C1P1T4MMC8S8EDi6GnYsawEOBRor9J1DlCfWYYnxCzVs0dpBa0CoAaIEul4AtOrMmTy3Sdfv+/Es IM0GXHsWEMaqWgdj5Y+rYNbpNicbcLRtnLfPkvjD1bjRfpFOapoVKIKV5P6ptHpKILkzjumYYiUd 0yXUUAuM5/e1AuRcwEeBYCSwKzEcDKh3Nx7f4D1vOCTCAIKmBww6jwM1ifEcskaSmwuTuzlbzB8m /NxLV9OPREtoVEBgVFRU1DsMgP/m36Sd6lOLHNAAQ4MzCe400JPW0Z6fKpPegPda2yc1e9GUPJ71 p7WJesxlPOpeDfwsCGwBwBdeGJTAEgvR91npu3kzfz0+Hm4lMP63fmtdCKzZ70M93692DV5bV3ou kzpnDB8mDrsoGLWQmT5tG4kZwJQLbamlVAQG9OW4my9Ha8vkgfF8o5oxTKqAz1JVLzmIftugUMLf 0TjBOKh5P0CYALA0z4ftn+OsAXStsGe5hEZFBQRGRUVFPY4A+Iu/qAMgnwG0VCZvWygHQI/CyJej 92mwpEGhpvrV2jg1A5ia4UutFXRuDqDHEMb7XpTlDg6GcPiyfoHe+/dzW+iDB/n7u3fzbcUL0lJF /etAN3ppcu2E+W2iraNs1uvipjDIIA8FOKtm00kOn8wVFIU2T22G0ANMk7iJDuw3C8CvBHodQi0Q 9Fpm0jzBcksz3k7Ne1sAACAASURBVFjjAw3RIAblX8HRfCCLV9BmE3eHUDGX4W6wawOlNtPIg+NT kGFUQGBUVFTUYwSAv/zLCQ4PdYMSDcok2GiBQG2b0nPMuXJpcfSUzFw0cCvqFwdHAHsmkD4uPad0 7L3q35xgeH5MX3wR4NlnAa5cyWpg+VCg7FupR4+yClgC4/njK1xQmqIaykoeNYHh1/zY8uTCz6pS qClrUI9dGPEON4ZBXXlE0J0+J53VUpwmDHEUE4gsamQ3nTnk3FTe9o6HwVsg6VECPW+cBn3azFxy QKPz3Jgc/26IEtm9t2VWUvjEQjvurj9vRjvojsFq5jAmya0EhFDJDoQhMzBaQqMCAqOioqLebvh7 9dVsAHN42NYCauXRtc6k1VTE5PgY26uweVw7PbN/2s8aCLa2gmowqB3juRAoweDly7kltNTJSW4B vX07x0B8/esAb72Vv795E+DVV9cHQGM8FKBB/UM5N9BqBa0xoQas2nZQiWYYKYAMsMoFfDFpmUQB CAqSBnodKLmFFFhKdiDdVnKCnQZ4lskLOta3ll8D6GrrWUDJJD2VnYxMQSk2YndOdNl4BzqArgfo sf7rvHTub82W0Nqfmn2a1ERFBQRGRUVF1QDw134tqfDnMVfxzqa1AJ4H+pYErNeMX6T2Tg8oekDP A6fS69MAcSkE8uP6vvdl+Lt6FeDcufzBgHTM6SzgZrM+ADKI66A+p4fgUN488Ij2c7kJlJ322E3B VHq9FPJG4Ib2UychEL4Yb4zaQAnQ8NMClRm3WrbdIpiz1tlXYDzddskudPQLtwLS5IMHphrunjaN lUBRPWMtoSk5Qa8ogqUlVNnm0kNp3RmgFxUQGBUVFfU4AeBXvpLg4KAeS2BdbVo/a6DCv3I3Tz5z WLvi8YS4W7EP3u+9INcSD+GJhHi7ALBU1+UW0FJ9n1s/790blD86D3jv3l7OT3N2D32KHVf5upoK iDJUuvcL9EM9Yhl6moOcOSjuU8XlxmoNlYxhxCxBDtKp/v4gpUUvzBWTmBpYe9pBPWqgNRtYM4ch AE/NYTwB8JLzq3XierMCi5qmhcB7zFlag+OboJC0o4pCMAHebrtSBMdHBQRGRUVF7RsAf/M30876 f47ZyBzDEg34KIjMdfdcCmUF8spsm+XyWcDIs31PO6h1vOY4gdZacCVjH0SA979/cAW9cmUYAuOv fbMZzwOu6AhKIyB4HAQHNBFY0Aa+OeXpXJxczCsh8RwIVBWQw67mgiMYwVDFCYQ4jWpigWLmIrmP UsfPLgmREprJi3UQLXD0RCMk55vKl/W2hYITXIVPDEzHWxyyAkUDHgnOUDlEaQAxse2St+g6gc9S PFPjeintR+SNigoIjIqKitIA8Hd/d1AAvWqTVy3kkMfhrxYdUVMea2BVM3+RvkoGL9oMIDVI8UCf dzaxNchee39qEChBNr3v3LkhGL7rhtbPO3cAXnstzwQWZ9Cjo/z9SmWZSSqcpT62e9k4vjAGHksJ 9S5ADfQmcFr5Kq0LdB5QSZ1PEhDxIHicQlpKsuto7eCKgpV3JpAv2xr3ID1WAz8N6Kx5vlZoNE40 cRZzGwiPPXn/jXlWryLHtyP+uWQ/pNprTssPx6zDJ/wpOoh/z1EBgVFRUVF7AsA/+IMEXWcDVsvs nRYh0QJ7c56PL09Brqb2aYogVQMp5NXUvJY4CQ/4SQ6hFgBKXyUItADwgx8EuH49w9/Dh3kmECAD 4MOHQzh832f179GjwRV0DxeIFJ6KqUkHY7VvAnJozwZKSmLzPoFj/jCRC1yuvpXHwJdfCEJ8pmls w2InUr+dOyOzgYkGn/PPWsjy2BO4tPYTp69PBTjPbGDLsjX5yVp2Ju0kGKutyelQpKmso/ZJnBrD dAjQlwFC4TOdicMsjBW/qkPoSvN7NXHRUhHJy4uW0KiAwKioqKjVAfCP/ijt1B0JDjQo4cCgRQFI 2+GPSYAyJ1PP2+KpZflpLZ+e7ZT9XgJ/kiOoB/zmQqDHe/70aYALFwCuXcs/l7bPu3fzLOCdO3n+ 7+hoUAJXbAW1ruEpyHXA3C6Va34OKi1PqLWQWjmBqjLIYE5qERW5BevbGy2LejSEdBzQpE/QQ9CV 9dEDcS0Ooy3toB41UHu/cSH9QP2TBRTeo/JZ3M4cZlMPhRcbMjTQerusPpfAInmdHQJsoi80KiAw KioqamUA/OM/HgBwN5GPNmxYsGdexKXpcp7MQb4s3xcP4FnmLx7jl3ID8CuB2v7MaQNdAoIaBFr3 AwB86EMAN25k+LtwYQy5NP+v/Hx8PCiBK18cToxcwI5wqKmAIpTwdde71hd/VUSgRPm18B8mLaXC CqqDKf+V1eIlUgWaE+MqZSYQUp4LdBnDeABFmiNsmfeDhmVT4/LexcmxSv32ZrxuMStQkNh2+Y6V Y0hVRhoW71LtrNlEL+wxJbK2bhf/qqMCAqOioqJWBMA/+RMdAOnXAi7lCrCsw6Gk62RArGX4Ta6M +rZIBW9cg6fdk4KNlQHobf/0GsK0zmF6XEG9sCeRQVn+4sXcAlrmAVPKkHfvHsAbb2RH0Js3czbg W29lVfCrX10P/mAbSg5GRmDlZ23boECiBoQWnGFj7kRpCZ3MJKahjVB8XaSlNJGvKMDsSPBK085r HkAPaAOraCAjOX/OeiOgLWsQwJZfNZBbOgOo9f/SzD70v2y6TU3l87RQTsYqyR3JWElsCZ1pDrOk RPfS7TcdAJTm8mgJjQoIjIqKiloKgH/6p2l6xauAYIE+DfC8sREW4NQAygI47XFu7KKpgJuNbibD lcICiLUWT4/zp9YOSo+RBYAW/C2BQACAj3wkO4JevDjOBOSwXI5zyQf8yldWPU9Ru/5GWd1DNK7V HeHvNYhLMG2dRMUQhm9n0sKJ8ovkWYEWkKmB43zOUXjBkjmMNC63yxfsSYsi+hIUsAZzlrKntXzW YDBVKMNrCJOE7af6aqPcP2YIQxWtPo2Pk+quKRjMJI8KiMIHCGVfl4Je4zo199Cqiyhu1eSoqIDA qKioqAUA+Gd/lqqtm5Jrp2d+jMOfBoOamQtdtha23qL88Z8BpvDHWz497aQeyNPA1XNcPK6s2vGe A4H0fT86yurfpUsZBMv+378P8PrrALduZVfQe/dyNuCjR3sBQG3eDY3lxQUqgOfdJy9EVpelBjE4 DZ23guB5K2i3nSXruu33AjjwZcrbSd/ylCpjckpovMVc7jKlrQo0tuwIKmAIy1+I1vFdwHPyWVnl REqwNeVRDJc73BqnFFMhclzUqAUpHF4htRYjl7k8ueb6UVEBgVFRUVEaAP6n/5TUC38OAS0GMR7F j0OLp92yNrdnuXtqM30WOFqPaYqhB/xaYyC8kRz88SUQWN7nl17KkRDXrgGcOTOs+/BhBsD798fH 5+Qk34pT6Jog6AQ1VMDRDHt3LuMBvVkwWVPvOHgJge6IUzDjaqOmTNJlAaYOq9pBXq0XrxXoAOr5 gp5tpArZ0G23BNYlMNs6+a/j5NxjwF5kw9QPbZvS7J4GUDtlsBFsa3C4BqTR2UItKURrCf25l66m H4mW0KiAwKioqKgGAPyzP0vVq22PI6e1XOvcnOW+qW1HA0O+/MmJfzueGUKPq2dNtbSOoacVVLtv KQTyK9fr1wGeey6D4KlTA+wdHeUZwNu38/zf3bsZCh88APiN31gP/kAcu5qGvSutoBJriNToIEtP sLxm8lLjkxG/lfk+YZs7JQ+nz1MiHPCA/MyiHxLKEDoCkG5QCw+4qtgN6qIERxZvlX3A0k3egR0Y X4t+0HoIWxxCy8896NmBybksWadJOat9KsHn9+ivqJK16G3WGMVPkLnSJBxbdf5woUGMBpVq6+h2 NrgPqTAqIDAqKipqJQAcXU065vpaQ9Brapu1nDfGQWrtbH0+ryroAcElZjAW/HnUP8tD3gOAZ88O ofB0/ePjIf+PqqObzV4cQVugbaIEOrL/TNdQYRmQwI1fzCYDFFFWHEePs5B4CWwnRi3GcmrIOwdn NMw2FbMc+ppFEKDHIhl0bgXGWzQ/1yG01UnU2wE/84MO6T5+/EdOmtj261wFQFgOcp7jUJsLdINr VFRAYFRUVJQTAP/0T5N5BSiBnqX+actr6xdAkyCJPuZp59Tm+Pi8nzc6wnpeb1unZBrjbQNtDX7X 8hbnQiC/Ynz55dwCeu1avpVZwGL8UnIBqQpY8gFXBECq+HWgqII0KB5WmNEzllHFKcEkRoVE6ghq MK5pNMoMYShYSpmDkilMuZimcQ7YD+tIp9XodN+uc2qrGlKVEBnXcXVzds3NF7RUwFYY5KDKbl23 zbPj2YyKOcwmwaQFOFWgTVLoRo+TDyLUVBgC755RyFZwa4I1Q020nvvnX7qafjhaQqMCAqOioqIM APyTP0nVi38PzHljEKzHW5W30tJZmx30zvTV2k9r6p/X3XOOK6gXADXYq7V/it7zOHWaeM97AJ59 NruClirwXUDv5GSYD7xzB+BXfmXVc3bWjB3KIGapfCYsCsHtWMsT1B5H2zXUzTXK6xopgag/H5// kxxWvUkXyIiip7mA/bbjsxu3GYr5jJ75Pm++IFTIxUsZqXFbbLkaBCXtkwdjX3F7HEcKcbdtsS3x FAS6VUVacwht57TZv9tJgNvdzKPA52UuMFTAqIDAqKioKC8A/vEfyy6g9OJfghwOhjVVzIKo8hwS ANLHaqYrHqXQA6VWbETNaMajkq7RBlqb+ZtrBFNzev2mb8qtoJcuDY6gm82QCXjnzuAIeufO4Aq6 BwBEnCp+HcoqYHO4uxLpoLmQuquiSk2UOwWyUPnKuGucFZiYpxN5fKfICbOBIERVYA2QyY4k7kop tGi6lcDkOKbYsC5/zBsTweGSupI43v6JeKjIfNy4ByVH1468b0b75uj9TAbgsffG3aLZ2MuJsMw1 VusS7mCbxRhEGBUQGBUVFaUA4H/8j2l34Y9GYrVX2WoJaZ/jvllz/awpeJ7n9s4JzlUBPW2j2nHn 90vw5oVAtQ8s6QBY6swZgIOD8XMU5Y++jj3NAnogpLau1xXUuy8ogKMFeLUdnXQUCtu24i4mIKkR pJE/OHk+9IH5KNgchLB7gbPQA2kt4O2dIZSet1HVa1kHYavGVWioiWHS+L3ic4GjbfFIipV/J1ui IrzbWbKNaAmNCgiMioqK4gD4h3+YRld2HAQtta+1FbTFgMVrzmKZtnicQT1xEzWzlyUQaKmlEux5 wt/5cnMg0Hr84x/PraBnzgBcuTI4gj58mNW+hw+zAnjr1qACHh0B/OZvrn6xOVL5mOIngR5XCHGF fViyoNayySGuw+lMn2QOAyiolKz9s0PFeMZq8zTMZ6zXWl2uzMjBOLNwR4WlbTQ5yKBmJqNBpOUO 6g2L1wBQIyL0nTKpBqp8HSRqouYSWkA/NbZ5IpvdZO2kySC2fYtxo7eZPHeIgFEBgVFRUVESAP7+ 7w8AKCk/PArC0764FP5a2jnnwJ431mHO7F8r/GnHj8Oft9VzrvrXEg6/+893mCGwrP/oUY6DKMYv jx4NmYClrXZtAFQYawQqqMyoGW2eGsxI84PavphdiSgf0tbaOYwCyUmzICgNF/AdVNRB9r14CsPU NCSBbAzTaQDGWKsq9NVcP63X3pLj54Uvaf7QCW27Wb2ymX7c3plwPMMJFThPCJMoilTZF5rBVwNA ukyrKrd2VyYah5z+GysfoERURFRAYFRUVFQBwN/5nTRyiJhcQWM73NSMVTRg4o6gLZBYAKOlDbRl brFl3q/FEMaC61oIvAZ1+4TAcj584hM5F/Dy5ZwNeHg45AICZBfQ4+OsBh4d5dv9+wBf+crqEMgh TnL/lFRAer/EEO52ULJyDV6wwiqIylcFTEcgWomHkExhdrOBQObIEpiqGeosa95P1aMq2NWgznOw PdtoAb3yInqDXPn6XjtMTzwDEMdQHhzfs3ZbBoa7D0KYOQxu8v2jGc3Khw3Sjo1ejof01qBBBUhr m47g+KiAwKioqCiADE/cKlCDQG/4eWueX83506vm1Vo3W7ddczXV2kA9St8S+Gs1flkjF5CeC6Wu XAF4/nl9+UePMghSJXAfAFiJUGjIeG94QF5GMopBYzk1XiKBaboyaRd1vN6ROJSmIfWqyQ1/LawF 1QNQlNs6J7C5xv5qwCYFpdcAkX/vafUE5bm2zqfipw58Nx3ghOIQ4fjDgKS8rsmvPg2Mh7fP+XNO VMSSuUDJsycqKiAwKirqXV2f/epX08RaLiU5CqJ8X8u9WzIL6IW8lozAObOKa6h/2jyfty1UOvZr qoCtIEjPiW/7NoAXXsgQePbs4Aj64EFuBX3ttaz6PXqU79uTCshhqkO5RROUebdOiUMwDWJQBrfm VtAKaFptqRa7UP6oZQSOgA5Yy6GyT4D6a66uh86215o7qIcOk0IA3nbQ5PiZ38AJjcIJbEKR4fKp ZQUWl1AgDNpB/hOzU4H5PF8FBEeHzXB9mbD3O+TMSduji9oN6O96j4oKCIyKino6AfBLX0pyWJii ALaamcwBQ6/hS83N0zOv1zo3OCffz5rro1Cnbb8Gfy0w6IVA6X7JGbTrshGM9lwlI7AogSurgFWw gvZA+Lk74Wr/XJhDqL5mlIF09PxCnMBkm5JKabl/MtORUQREgpHrZOqJt0tXP9ij0HjYtilKpAvO N64lXxAWAJ1nPyRKaVnGYySDtpkvdwndwREMLaFcmdzBXAvcrtwSqkVpUDiOltCogMCoqKgoCwB/ 9VeTGDDFryC0KIIlkRAtweytkEbnAltm/rz5gmvGO3iD4DUQbIXBFgikj/OryU9+MreA3riRcwGL 3HB8nB1Av/71rAbevDnOB/zqV1c9h3cukmC7fdby8zyxEN5wdDAADyuQiJWFtGUQGIxxl1CAifpF zWMQsllGR/MDUW4ZpXDX98RjhrUg8n0C1mjQ93mubXTKs+xCVQ1EB7m3zhbCiqAH87bZIUC/NYdJ /fSYAwFq60TS4I+GrGsALcIgcdfkMRLUKbSsQ02Clny448kLTA3bipbQqIDAqKioAMBXX02i+udR ATnQzJ230zL9NLBsaQttmeNrUf9qc3tz4iAsQNTgrzXyYakRDA+LBxjC4U+dGl/Zl2X3rAJ6c/u4 K+jIxRPbWzS1fUAOP3wT3D1U6ROVIiKslkuJh9TluTkI3Y4SFTGBBJThbnJRzvcPHYeWgypWlluS E+h1B20xevFQTONJjo5N0RlPzURYhKKiBm5jN1I/fECguYcC+Fo7eQvo3vMClVbZhVweFRUQGBUV 9RQB4Oc/nybw13V1AJRgpcUsZY4Bi6ftc06gey3OoRYFsST6QYI5K/h9LgS2ZAG2xEJ88pMAL76Y 3UAPDvKt7/PM361bWQW8fTvnAT58OOQFrpwLyC8MO/TN7GkAsjQcfnRx7YCT6jgbAxasbEPzPuFX vXQGTFRE2edB3fbPQ9cN2X00ww+NgzSZMaQ7W2kJrQXKV6/mW9tF90kJ2klIIYm2XybjkwYc3EE7 /r6iw1SlFu+ArB2UAHxix2W1MT/UoTMtfK+kzMAOAHrMyncEx0cFBEZFRb07APCXfkmeAdxshis9 CTxaZtjmzAC2REjUWkU9WX2tuYC11+yBPu/Ptfk/L+StZQZDKaksc/16zgU8e3ZYtxzTcpxOTrIK eHy8FxXQE/CuzsWBHCZfu4bXTGJAeR6JAcC6vheC4UfbktotFc6gQfD0Mx4+m8j326JUdBwbejqV bEDk7Z7eS24vAHpaPaWZQAsQ9ykTzZkLrIDRSLnV2kKJWrZ7jN7HQJGfdynVoRLY+kn5E7ImM1LV 0TsPGBUVEBgVFfXuAcBf/MWpAkhvEhhpYOGZ9WvJ3lvDNVTKGGwJr68ttwT8vPCnLcMB0AN7a5jB 8Ku37/gOgGeeyarfhQvDPh0f50zA11/PKuDdu0NQ/MOHAL/xG6tDIP0qzQJ2Aug1KXvOBefG0M16 wdKPwswdKpENSTD+oF2R/VYlSUpS+8QMk52+eDBWDS1I35nFdMZM4FxAlNo9a7BntYdqLaFeZ9Ek rEMPZPkTBs60C8MoZqJ+bz8E6GGbC4gkSxCZ4izsexL+9JgA6CK2OtSu/fcigDAqIDAqKurdCYD/ 9t8mFf4oGNZm1+gVXG1uToOrFqjzzPe1tGx6FEMt4oGuy6Gsdeavtr4F3nPAr2UOUJr/o/edPw9w 7VoOiC/h8MWMp+zjZpOVwEePhuD4tQEQ9ZB3sfOOzQJ2K+1MTeWjO1KbB5T2uaY8jiAPhMBu5t5J 2zdFxdKIcPDsC4oHYAZocyjcBptD+WoBXA0OJYBMDpjTHt+DuiU+Tk54qY2zulFm2qLODrJZPn58 E/mZG8mkGbN5c0jNUgM9byFtCf1XL11NPxQtoVEBgVFRUU8dAP7rf60DIM8G9CpWtB1TApRW0Fsr W7DFwdOC1Fq+Xw389tEGKn31wt7cOUC6zKc+lVXAixcz/JXq+5z/9/WvZwfQu3fzzw8eZAj82tdW P6cnSocCTRZv0bG0lmzAKs+gAYMO9imvKcEUVtS5QMWFE/j+0zm/0i7aTWf8RstDxbmUPV/isRBE 6RPhC21e034Wr/KtIUmAtnZQgHpovASgyfje84HCVsZGAOj6DCq78PdUMYqxWkFBBsgRyHfb5yRg Z8K2g9LcbNfY/urpnhUTQXCA4aiogMCoqKinFwB/4RfqALi76kztIGhBlBaNYCl+BSo00CuPe9Q/ qUWTxkdoEOZtAW2FuiVtoF7wsxS/pYYw584BXL2ab5cuDYYwm824DbeogGUecB8AiA6YQlk1dLWF GsRhRUVgw+ZaZgs9gfGi+Q0x9KCxC5Z7afXAogG4kiTrVUvJ+tq+ut8nTzyEZxsaALZmCLbmADYC kXRMk2Od2oye1PbpneubKNLUTGYFq9A1XEIjOD4qIDAqKurprZMTwRlCmQf0OlK2tE22KnneGcO5 EQ6ts31L4K/F5bMlFH4uBM4FQcSsAl68mM1gDg6Gx46OchbgX/5lVgHv3cu3Bw/yLODKEEjn+zRj GI8TaO0C2pMFSOEBBThFBqMeN1C0LECNuUAOfogCBCNT81B+PbtTEsZ5gfyUmATFow64tdbL2rie SwX0blCCyzkQUJsPTMabpTiEQmUTSZj9xC5DD1LFkKqB2gyeq/9UNofhkSBI20STvI23jbOSDIsR HB8VEBgVFfWuqc/+zM+kEeRJcRBWFASHEk/LpQSBHBC1VlD6uAR91j7MNXDRtj0H6uaavFjHfwkE tgIff6xc6X3ykxn+Ll7Mc4AXL2YQPDkZbnQWsCiBJycAv/Vbb8u5PomIEOBIArzO0fYpwZ3VHmq5 gqKxMKIjO4/BnrhoYq1vQKAO5fgKuqzWDkqfZPIrtDU36Q7syIgRM5X1tqcdDapH+hV8kRs1UBfd Qedu8x2AGXBm8yE4sgWZS+g+2iNp1mCrd4z38Za5wMmfNjZHG8HxUQGBUVFRTwcA/st/mVQFMCU/ AGqA43Xe9MZHtLqNWo6erZEWVlagBnItQe8S9Fnb0d4DDdbWjoLgy50+naMgDg/z+USPz/Hx4Ah6 61a+3b6db3twBC3g1kFFrUM9pFwFMsfzz70YRoGt5zyx1BaKAsyNzF9gOuunHS+sDVIq+0PX3UVC CCHzk8+hlP2bLMNn0ag5jNchFKE9JoI+p2cwrQXs0jzO3Kl7bGHJEIgf83LoRi6hwrHYtVO2SHhS REOrEthg7LLk70gSfmeiJTQqIDAqKurJB8Cf/umxAqi1gkoAI4FHa4ulB7Y8MOed9Vtj/1qNYLww WANAL/ytCYGtIPjccwDPPpsdQS9cGGYBj4+z8Us5R+g84MqOoLXrdG3eb6IE1lozJcBBu72xdp9m DKPNJiJX5EBvqxRNYRhYgZAzOGkN5bAGFSMclGcYpa/ae4ce+FJaEF2E0BIW75kLnAFzLSRDP5/r EKDvxsYwdBkVzi33UMfzqjEQxuuYzB9i43FxgGBzOymbC/QaxERwfFRAYFRU1JMLgP/iXyRx3g+F j4VbFKw1IJACZU0RrLV7zm3d9Cp+rTEPLXDnUQQ5rC1p+VwCgt/93VkFPHVqkBLKuicnAH/xF1n1 466gv/M7qwPgqH1TMUyxjFI88Oi9lneZnIDuUloDL2wlKmkfE5upKxe9JLBdur7n84Bq+yiBQWQH clHGHwz7iWuFLZo04ICWNXoVrW2xZb2GopZ5kRXSPgmFx/EHECWKA6WdQOXlpAqHk32Q2jbntoSu 8bclRMCogMCoqKgnGwD/2T9LLhOYrhvcHOe2gmpGMq2xDN62zqWGLxRAvcDaMgdowZxX8Xu7IdBa hl7FnzmTswHPncsqIA2GL+tSl9A9qIAeMBTjHkhLZIe+jDttfnACbE4+oawh7ZtrZQvEQMgW1MLj 0VZER/tm0CuNfBiFxUNbTmCLm+os8MPKfa1P1NISqsFTyTrU2lIlAmTunLUPNlItKqKcC8kxQ+ek JFERNF5fK3wl5+7NdQntcDujGhUVEBgVFfVEAeA//adpuEJQQLDrZAC0AKVVHbNaLD0zg3NmDT1K nkcZrG3Dc5zWgL+5WYAtYOiBwu/5ntwKSh1By/E6ORkUQKoCHh2tbgbTgT4LqBmtzAIIXPCwEbmg tXLW+GPUkikY01hvnRT7UDWyQWG/tXVwagCD5PQoEFDmzYr/yyg+T/p1hGk8xO44tTp6YgMMzqGP JXDasOwk2L0fMxV2W67sh3lBNPIEy3tDDYQktS6xfUjJqUzuCaSaN11xCY2W0KiAwKioqCcfAH/q p9Ik869cERTwK//dPcqXBUMa9Hhn7DwA2AKJUhZgK7hKz1eDuzmzfa1B8O9UCyjA0Pp5eDgogeUD hIcPM+xRKKTzgCtf+JVTWgMyrt5RaFRdQJXcwBpk1Vo+NWAs7ZkTRQ4ciqBk6ILyMeIq4AjY+LFU 9gWFdbTAgQvLFQAAIABJREFUetS2jxVIdba00rbWxCMLPLSfFi7jbRGVKHcGAKJjE+bMH3Fr7YU/ aeq2BLVwMlJpuIh6cwn3xZDiejM21iHAJtTAqIDAqKioJwIA/8k/scPgy0U6n+fyzgFKy7dAYmsr 6dK2z9Z9aQFHzzFaCwBbIHAO8FmPHRzkWcBnn82h8KdPD8sfH2fl78GDbApzfDwYwWw2gyq7IgRq sQyT0Ph3+LN7CwQnENeqRDlaQoFa/rO3mro1akHso1xA0t5JZ/NE4GwAZvE1YNtrVk8Q67m0uIUW ExPvoF7LthQgK5/fcSfPCawJvZC8pXe3rV7YJsmGXExmksNorSWzcZ5yH0IjYo4n6SHfoqICAqOi op6MagmDl+BLg4w1VUHp/tYWTm8MxFxFUANTC+LWVPu884BrgmCtLl0a2kG7LoNfCYK/fTsD4MOH +eejo9wO+tu/vTpUjUCPwchoOVCUPmx4MnZxqLlzatzhaQWV9sllCsO7u0E3/ZViI8wYCBDm+QhU 7Fw62Z+IPmX1hIbK12bWPIdfSndQ2zqljYgbmAGZLWBXcdFcFCfRAkMIVWlOMoYp50UBRui2sFiZ G3Rl81H1csFcYAODzpoLLF+jJTQqIDAqKuqxrs/+o3/ki4LQnEAL+NArUgvwOLh5oIuCyByVTwPI JXEOcx7TgG3ubB/v0Vo6B7gWCB4eZhXwhRcArlwZsgFLq2dR+1LKSmBRA/egAk7AToA7y0RT3Ra2 tYDSDUhupOgIRkdBdcMZr3sCdh7uQT/Eaq2hXeks539ehP0rAAElL5CYyNAdpIpjD9uweBgrlbMd QmvKoOd+C8wkVTA17BMyWplDQzgfFHfdq1K7qKCaWu9BmVncvbWPid1mU8QhklnayAyMCgiMiop6 rAHwJ38yTaAvJRkEN5s64Elw1Qo+cyBsKfCt9fze19NybDTAW6MFdC70ea5uEHNL6OHh2BBms8mK 382bWRF89GhQAu/fX90QBp33a3DoygV0giKFBS/ASfsnPU/rAUHlPgT9e54hCDwSQJv/E1+MzyRn qYwy28hTioNofTIv2Kl05dg/z8uQgAzroEUdQi0lTFTxFNOYFvLaJwfO3SeJuZHAcJkn3v63hJ97 6Wr6kVADowICo6KiHisA/If/MO3UPU8mYEumXVLcBOZAoLRMq4q3Rm7fEgj0Qtyc9s53AgKtOnUq O4I+/3yeB7x6dTxXSluKN5vxTOAeZgGBwFPHQKoV7mbRJucDQ0XzckYHSitoAxUlkCMheF4fkhZO 6vhYVdfInFifskI3UvCockfUvCTMo1nqEY/doAfSax6jzpPxJ5G+b3UbXQh1VVh1EA7d7V2jB24D 5bvBfCg5YGzkEupp9wSY3RJKH58s1pgXuJpxjLFsF2pgVEBgVFTUYweAP/ETOgBqA0Ktc26aSsgv 9KU5Qu+2+XK13MEW6FsyH7gmALZCYQ38WqMf5l7FnDkDcOHC8HPfZ+C7fTtnA968mW80JH7lcHgL jjQAq84Jgs8VVIO0WiuoOg9osAkY92kvyhKsME0PADdz4RtRYzasLEHUW1W1ZelpqWU0Si8s4fRX BWv0XZsJBMdjNfpoaQX1LEfNVMp71Y2NYVIDLFqwJc7mqXkS0xlCCwApNKqA6VUyl0C2cszF+MKA vqiAwKioqMcaAP/BP0jD8MJCANQgrlWRs+YJLRCrwedc+GsNvW9ZtwZ2c5S+pfl/a8HgmTNZBXzx RYAbN3IwfFGWSyTE8fFYBdy3I6igAkpwB7ggjL1RSvS0gs55SkQhoqECqNqxkNo1JRXVA3ZWVIT1 YjUwnBw/tA/2KjOBmtqHzjfVA3xrJZ87XpcFLEjbRem/gw6g67NiuHMI3ZAZOGDHuds6ZvbscQHO dm2r/OeGtyrBOsuLwfFzWlS3C0ZLaFRAYFRU1ONRxQmUm75oRjA1oPEqedZjBQC4kmcBU4sCuUT1 a3mOGiiv5e5pLb9PELTq7Nnhfbx2bYiEKPOkDx9mte/NN7P6d//+2Bn0935v9VO9pixJy2pxBJYK WAVR9iSeVlB0AFHLPODoolZwR00gzwCWVkEaOC/mBTrfBA6oEzgB9meBmsOUz66E1tLSrkrNYVCb vUwVqLMgzxoy9GYFpspX74k9sw0VrZdsOICKc4FELmx1+OSvYbIPliPpCiS4D1fRYkbUQYblUAaj AgKjoqIei/rs3/t7SYU9aS5wLqysreZJSqFXrVsb3ubMMNbAeQ4Aer+3wG5NGDw5Afi+7wN45pkM dc89N5xbm83YEbTv8/JUCVwZ/joYwt1rKuBkNg58bYoq7DUA6Rp065kHRMHQhc79jaI0lJgIGrpO ZwU1l1E651d+jVMPkLrh/klExdY9tEOllRT9h4bHQrhmBNPCNysJ8Dhn/TnLaVST5pEPVQNdbZfJ bgndQaT0JlntlhxAW6Bz7d+7pBvDaB2rXVx6RAUERkVFvaMA+OM/nkT1T2sLXQIoXgj0Pt4SvG7B 2pz9aFl/X8DXAoYawC01gLGWO38+Ax1i/v7q1eGxMgt49y7AG28M839HR4Mz6B5UQAmONOfPDnRn TBWkLCBDff5PWnbyOE73t8ZArfOASJW0cpEONiiJSqB17IW2WunPjElz6HufxZ/JQVnEdjUVsJY9 KN2/xmygc3mrtXJOhrsEgHRuT90mknlTkOcDzYiIBXEWM3lvtW1HS2hUQGBUVNQ7A4A/9mNpEv1A HUDp/VIbaA1g6DJLVTbtPg3u1gDBln30bFvb9zXAbm4LaCscttb3f39WAZ99FuDy5eEck1TAkhdY XEFXrAJ0HeowosYgNKiAzVdzHOzYfdZ2k2OZSUi8BL/C49rnP9L2gWcqaiYzKJM4YtuBnCiXHvJF /XUhzgQpjwPPXMpMC9ehUFlC2RP5qsEYmfvDbjjWHQz/GkrkgenESY1okkOgZOYvfCE6K8gBcxQ5 YVKp8KOy/JKoCHWRaAmNCgiMiop6LADwR34k7f4zbTZT8Ou6MRDSNlAPrEiP7WM+rqXF1ANgc+cd W1/nXPDbh/q3hurH68IFgG/7tmwCc+VKngWk29ls8vzfa6+NVcAHDzIE/u7vrn7OoyNjzoQYDUY0 8AI7U1AFOwUcUOeo8X2oO5+iMGuFAqwk5saIjuPJgbBmzAIk+qHau0paNxNu4yVoCykFhVZwsmbo 1mgTTY7XthJomOsx6C4OoakfzgGPo+WoHZTetFZP2kbcbaF0+8kM9uR8cwKc59jssyV0xu4s/7Ao KiogMCoqahUA/Lt/N02uBijs8XlADQRa3SeXRCB43Ef5915IW2LIMndbc8DPOsZeKPfA3FofUV++ nFXAZ54BuHhx+MDhwYMMfffuDceszAMWJXDlizbR3EQBNATFERR8his1gxgKSdr8YfPFIge4WrQC h0UUQBKnCikHZco4KTFoTEogPNmJsh6k8VxgDZw0JXA3awhk3pCYxPQ9wMEBA9C5peUDSu9LEt7Q 1AiDa0RFaE/dZ7CefF6WxnA4eYycTyVTsHx+uDsPHS2h/DwcHdq3Ce4WQ6Ggelpzgd32zmgJjQoI jIqKevuqKH8cAMvP5aK8qIJL4K8FiPb5dc4sovaYZ7m5s3+t3y9R+jywNwcIL14E+PSnczTE4eGY avo+Q979+9kR9O7dfLt/P8Phw4erQ6AFTJay5mn59ECi6uApPR/aIOoBxaawe5y6flrtqBJ8NSmB 5Io4JZjMI9YMdyYA3fJaOWQQMCzRBh19LXMAsCUOoraMNCeYjJt13LW2zFR5XDi3UouBTEXZG7Vl gnA/COp1mvcr/7jBY1RUQGBUVNTbWp/9wR9MqhsDv/Kphbh7YWEtpW3OtvbVguqBzH2B3xwYX9Px 05sNeOZMVgMvXhw+fCjzfsX5k88DnpwA/MEfrMp71OiFmr1I7qCgqIIdzHMI9YDoCoup5i8imKLO M/QOi3M4FCKDuW7r5jlx9ZT+3HjpG0BWOF2hgQQGkhETUVm/ubzb2QecpPpjyQNvkksnMqhiy4wU Rf58aQqnAPaMnsGRi/42pJkbm9sSiorjaVRUQGBUVNR+AfAHfiCJTp+aW4LWYtkKBEugbx+waIFi 6z7MVQ73DYEt9y2FQlqXLgF8/OMA169nM5jz58fbLWHwr7+eZwFv3cpfb9/OiuDbmAuoAePogs1x LY/WDeXltP3zPK65hGpKpObsKa0PbPugwJ4EZVbOIlfuOMxN1nVEPuASkOagK4Cva6jLkxPYAmvJ sUzLNj20ktqAiP5rqI3x8e2Ky5fzLTU4ktJ1cPp1DaheuhnrLSj3ddv51p996Wr60WgJjQoIjIqK 2gsA/q2/lcSP4a2fawDl7Q1qnXlbEoq+Rlun9zmk7a7Z/tnyWCv07cMMppwT169nFfDChWwMU2ZN j48zAJZ2z6I0F6fQPQHgSAW0At61Gb0G4JgLprzN0tVSaYEie0s8s4ajYHhyIEQHULJSma1L9HQR oKjkAhY1aJQrmMbjyFrYOs0X7LdOi2WbSFtNcapEJcjrHODUgGeW8Od1A02Vg24RxJKICOGkmxi1 FHOYzfTx8hj2w7yf+Ce/ZgqTDBfRJM8ZrkFnaxi4NAMjdyuVwHgLfnM+qIoKCIyKiopqL+oAavmk S3mANRjxwMI+XTHXUPbm7tOaxi9rgF/re7OmT/mVKwDf+I35+zNn8hU9fZ7S8vkXf5HVvzt3sjlM mQfcAwDWHnMZuAjLWg6gYKxHN4wz9hfAMHRBZRlhX0QjGDAMcrR9QqU1FOXlKFCqsRTe46A8kIzH 0AF1LiBUINUEwtX6Fx37NhcQGz/vSRWFD7kDLD//OgAsneHo+33gzrVVxbZl+QWQaC074t40PY8j OD4qIDAqKmov9dm/8TeSq/2TXkm2th62wN+aAOgBujUVxhYQXPq9B+oeB/Wv1PveB/CBD2Ql8PTp rAQCZOXvwYMMfW+9NTwHVQHLjODKENgpKqBFF1KL5ZxP6nFJoDk0Gp5o20O/V4klYImco4GeQNqT tlNseBHGMvz1WaH2gMIyXA0k82noySG0HEK9ZjFeeEszToLUTjImDLJGEWomhN00T3C0PQqMOD3x MC1n2VZwW7ZSfXOSGghKA024hEYFBEZFRa0LgJ/9bDJbPvmNGsEsMRuZC4JrfN8KZV5IbAVMz+Nz j/O+QbC1rl4d2jxfeGEAwPKcxRTm9u2xCliyAVc0gwEYG8BogGa1gYJzXRUiFZCrzfxZvKHNGHqB FLmjJrLXIigxYjwEyHOEXOmjLyLR7nIUshBRVzit/eJg0glGNBwW3VfZLeHvlkNoq2voPh0sG+bm PAYxrvW9KmPD9quLasC58odMc98uahDTIcAmXEujAgKjoqJWBcC/9tfSBPokCKT3tQKLBhr8CmJO +2MNwPYBdS3PU3vOtwsC58DgPsDw5ZcB3vtegFOnhnD4k5MMeffuZfArz8fnAVe+OKOw0xmgN1ln e1FmtX1q6825gAQGVVCBRg9PNM0vGi6aKqQqEMRBr2OAOIIxlOESKpEPu0QEOobbk/Byx7GWWmhH AMtbWpNx5Y/LjrNJEUvnAj1zc46x7lltlMj+DRh5gaN9qJAVkplP/j4sNoVR1l3KkK7ZRAToAgSj AgKjoqJWKz4HKAEgbwNthT/vvJln/aVw6AXBuaC39LneSehbAnq1dZ95BuAjH9n+lzrMt7JegcDj 4/xzMYYpcRCbDcDv//7b8usgwiGsYMqAUyBEVGDOyvfjywvLarOFkisnomFqQ1s1UVAHGQwhKiof CMYxQotmIhf7VAmkQfPUyEVr2RRhF8eOnomABzWGKTmAibR87sxlmHKELdTdMhNYmxFcc+avRVkj JjDAY2O37xfS5WDc+slNZbh/GEjunXReryxj7DsFSjrnR82A5sz/rSkUTpxLG58nWkKjAgKjoqIW 12e/53vSZHBD+pnev9RkRFvWCyb7UAiXQubaM41rQuAacL5Wve99ADdu5EzAs2fzfcfHQ/j7/ftZ CSz3PXiQb0dH+4E9JJCHRvC6EvZeM3+ZFTuB81tB57hX0gtmFMLVJ/OCBAYT2YlRl6MwBwigK338 c6ddq2bH8gR5bmAbf6+7bC383TMTiA3gN4s03oF/KgXiUtt+cYdWfv4kZ2C9x0G0Bn+PQ2g8dQnd tYRCdl8NNTAqIDAqKmoZAH7mM+M20BoIeiBhDjjUWiWXgNFcEJwLa97ZwLVfz9L3Zsn75qnr1wG+ 4Rvy95cvA1y7lr8vrZ7la7mCe/RorALSGdS1ANABAd7lPM9lZQO6tu9oBfXMA1rREFijTO21sZgI 85gKytxEjUR5/5HfX2vtRBms+Qyldnoj+pepnkhrEbzU9rlGVAQ52MiVWNqyqchWLWBFAafrtrEf mFXY3XvFVTscf2ihxaPs9rXxGDwO4BcVFRAYFRW1fwD83u9Nu/++pVdHcgblVzprtxF6IKcVXlph rsU8ZS0Y9Kzjhb6lx2et97JW3/iNeRbw0qUhFqLvM+gdHeUQ+Lfeyt8/ejQogUdHAH/4h+tDIFEB OzRiDwQVsGuFu5mB5d5c9ARj+/hqzESLkymNawAldqKyryPWIUDB2z93f2qMbD40XpcXomdT/Vrx EDWVsAUA5yxTW0+APB9FjVsd1celbZP3HYV2YAqDlhGNO6NwBhSq++4/PIuXKRUtoVEBgVFRUe0A +Nf/eoKDgyloFbWl5ga6JjDMhaoloLQk13BfJjZvNwi2vn9L3ucbN7ITKEBuAb14cdgmVQLLOXZy kttBj4/3pgLW4NBa1ptMoN2s5STDE+v7mlI1L91c3k5S5vyo+ocKsKlqHnPllFo9OTvRlkERGilQ 0kD4HqDvtnNrON7G6HMaDvJzoxvmQJ62THKA3j5dSUi78CrunV6DFiVfkLZIJn6sl/Pf3g6juCzq c4FCQsbu+8gMjAoIjIqKaq/TpwcDDnoxDjC94N5nhMBS6KJXavsCuDXBcU3A29eM39oq4I0b+Zz6 2McA3v/+bA5T3rvNJit+R0dDNuCtW/l2926+fe1re7lQ01w++TIgQA+HsFVMY2p84FUSlVk8/ph6 nzbrqHWEA8ltQ+GCVZj54/A4aQEV8ibECIoaqCnxFJ7jPTKi2cLjxBiGwYjL9EV7bB8zgQu2lVof 48fFgiICPZoYKOUGSucuz2wEqX0UxgC72B10RRCcs345D1O0rUYFBEZFRbXUf/ODP5h20DcayCBf 6eP7BIWl7pZLZgjngtVaymELBLbu7+MEhCcnORICIGcEnjkz9GvR6Ify4UPJCSzOoHu4QAPQ2yFR UK24imfGRzikQ23+rkkBlCCnsh5U9pu+zsTAxIy8kJRAFFRKoiZy90/JJdU8jugIk/cwIq7wJ8w7 S9liJOMlNK8KmJb/3pRNlH8V9D3YtW3SVs4OAPppODwo7qASAe0YGX2HYQR/yQarncNrIxTWWkLT zOPK1+dGSymNPzNIEC2hUQGBUVFRzvpvf/iHEiAAdh2kMpNV/lNSECz3S214a378ONcN1AtYc0HO ux9rhLUvheGlMLiP97XUc89lJfB97wN49tk843fp0nBuHR/nmb87dwDefDN/vX8/q4NlJnAPRWGu MwLgqzyH9SzBmkrYkhe+RtScBcBceUNUnEEtAEYDiqTt0hZOcrErBsWzi3yABhW2ERr5QeRREFVe q8U+tC63xgkv0Qa91SgGnY8pLZwUvCz1VIIsLPCZYOseMzyWhKiRpn1vX2yv2/Cu35FDERUVEBgV FaXWf/c//XhCRMCuAzjoIB0cTGf9OBDSsO59gcIakQZzoG4feYb7hsBWaF0Ce2u81w8eAJw/n78/ dy6DYEpZ7Xv4MLeBFhOYcn9RAk9OAP7oj1a9Dubtn9ZyI2gBWS1ruWavbcecB3S6gk6WcZinVOlR us9QZdABSYm15onwKTyPmo+Iyu7SDMA0VjdTyQNk8Enz/3Yd57iQ0ebEQ3gC4638wLTsF4WrtxrU aQCjLstzFtO4IWXyQYPl8kmcTME4LO79lnIJQVYJ54JeVZF07juuRaxRAYFRUVFPf3Xnz+1aavq+ B9zk3pzR/5ACf+VKrdwKLC4x6EBcF2zmqIhrKWlLoO3tcPfcBxS21nvek+f/PvShHA9x9erwWAG9 Bw/y3N+tW4MKWALjHz1afZc4gHWou3p6FCZ0wF1LjoSnFdTiC2v/tXnAEWyhDQU1Z1AxD5A/FztO mqEMGDxKjV92UOk81nOOsXbQJ8CpXb23OoRqP8+ljNSwPvtzmdi/glEXfoHE8jVlpW4E3Z79VAcD GYiBAEpJEDRR2FSSYU9qBW2KitDmFWEdNbAmvHYA8LMvXU0/Gi2hUQGBUVFRUv3A//q/JESE1HWA XQd4cABYlEBESAXwaFxE38vxDDUY9MwRru1k6VmnpXX07YbAfcPg2uDohf4Pfzgrgc89lx1Bi9pX 8v9KBiCdDyzzgH/wB6sDYO1iX4MZ0QDGCRwaKMJcAAEhrB70/DwP6Iggi/LxmECkNu+IQ7h7103N hieKk2YKU/kT07Q8yuDNzWp4NOpONQTFjESAeLchjBPI3I/V1pmhFDY5Xkqf9fE/vUlQZ6U/QdS9 VSMinCqBow8M+L5tH8R30FjFUknRgGckHxjQ/8DhEhoVEBgVFSXWf/+P/7cEuIW/7gBgC4Dd4QGk DY6yuEb/ha1YiLlA1rrsmsYnLTC2FgDOOU5L2j33AYVz6oUXch7gxYtZATx9mlxNb3MBqQp4925W AUtr6PHx6hddHJQsFXAEU41wh066QwNSJQfMFlCkbZYJFiheBq1O5gSp22eFfUTljkY+AJkLVHbH dWwkZXTG8ZReRHNbqGcmcC4cphmvofXPA4mI2MFHl2EE++EcSIlBMWn1LOfIrg0U6tGELlXOaNeU DKSRwfsSxW/lVdRtVMTSqKiAwKioqHH9D//H/57nAAEgbb3OU7+duyof1acuu7iVfyopTVtCtY/I i1po/hdDP3Q8iVC4L6hbI9vvnYDD8n5/9KPZCfTy5TwPWFRA6vxZzp+iAhZ18Pd+b3UIrIEdh7vR fchyudABnVgPka+qdsbsIIDuJjpZRnDVlFpBsQYuhhMmdy5EpuxNoiaUzEFgr9viUu5EStVHFOIg dooSgm0UI8DYol672kygBxbnQF5LG+iS52mEHysfTyIf0Uwm2R9YoOPPGQpvxwJPmTmsveg5dpCd wiU0KiAwKiqKVXfhPIG5fnex3Z8QEGT/QJO3bZK6iUpto0vgqHW5fc70LQWzfW13CbTtWwW8cQPg ypU8C3ju3Ph5Cwjeu5dzAe/dy7ejo2wWs/IsoCfsXXPAdI/zoS8Yfm+FOjy2QMyEP5T2SQ16Qcn9 G7FPGgMoBTcOgiCAM815Swmg314EW3EWk4vtYnzcDcYwiGP1cU3hrgp4c41hPI9hw/akNtukm5Zo vwvJyPjbAR2dy9s+FzWH2X12SM1fynKQ33frtSfn2wH8dWngWYHZpbCdZsDpah9SRAUERkVFPV31 Q//X/5n/124dQeksIB7meUDse0hdB2mzAeh6wM0GEiKk7dfRxTtXBGmPD3UVnVwR7Em1WrOdcw2g 26eKORfe9gWIWLnk+PjHswp44UL+mlJW+Er0w6NHGQbLOcOVwJX5aBIIb0CbZKhitX26zWO4IqaA lRVT0Qp4CRrNbVDeb2s20ONWSn9W1T4UP5NSd9p9/HF87LynsAmVqcpQsjHMhIihHhZfM4fx5gOm lX6ZvG2ZDlnNA1HqZvi/lrntmri/8HhvokbrsUCyDFVUo6ICAqOi3uX1P/7r/yf1xycDqB10ACMA PAQ8PMyDHFQN3F7/I5nUTzQ0XgPA0jrKlcG1wGdNSFzaFvl2gN6+gHCtda313/e+3AYKkOcAS8xI uZVswEePhlzAcrt7F+C3fmv1i7Da/eide9MAyjkLmJINHmr8AfgjKGr3VbeTxopebUPijJ7S7smV QAl6drxCw8dZTIP03qGjPVfLo6ud5pNrcqyznQp1c6TFNS/upfbQOSHpAqe65taE6AXUlLgCeRTS asfDAGZUVOknpcyoiG1FS2hUQGBU1Luwfvz/+7cp9T2kvs+mLwCQHiJghzsFEA6zAphvhwC4yf9B NuP/mMM8T/4vnA4Oxv9JuWHMaOKf/Pe2WkT3DStrmNa0bOfthtl9Hj9tHXReW7z4IsC1a1kBPHs2 b+/4OLd7FiOY+/eHc6dkAxZlcOULp4kJjGUOA/IMnuWQ6YUKbGzRTOCbiWuCXA3mUIA7wVFmNHcH gtsngzmxTVWaxTNaSdFy0AGj9ZS2jEJu+6QZgOoxZIY0i4x1LNBbYybQygyc6yxquHB6exO1BhDR kMVQ4qqzg2y/d/9ylsRprLk8vH3B8bPPzaiAwKioqCez/ufP/78p+7ggJOighzwkkzZ9bgPFLQge dJC6QQnsDjfQl+v9lAD7NKT27j7pTlP4mwzopDo0FGXQCxH7BMc1oWip0jh3vTU+vt4HtL7//RkA AfJM4IULw3o0/uHhwzwDWNS//5+9N2uWJTnuO90zs6rOubeXiwaxkyABotmSUdwkUCRIiQQI6lNQ GrN5mXkYM3wY2rzMmI2NmQhKHIkbuIwkahntu0QSJHAJoLFIepoHTaP7LmepqvR5iIqqyEh3D4/I yDrndmeaHTvnVGXlEpmVEb9w9//fq4J++cvVAVADQ/Z1o2KoaveAeXWBWjolZp6oFvGSfPpEHkl5 Jmr7iVI7Q6GWMKU1Bk/p3FMRTRTaBZX5C6uvoJXtJn2gRAymxCJCWg/tn0UBwI/WGeFcoKYQSopx OvePlrYZ1PFJp6GmZU4wh69ZFyhl03KZw/HtS0tK6LIsELgsy/LuX/6XP/gSETZAiICHbgARncgB tEAdRnB2GFLtdrC/QYCdSwHFpgFoCQDagbLfoNds3HYorAcMlUPDv2NYOOpxIw+MOaqhtcBmDkir DZ1fipbWAAAgAElEQVTnBMqaywc/6FJBP/xhgNUKoOtO6Z83Nw70rq6cNUSYHprynZw4qNLM4TVI TAGhBThjMBxBVaIGjiBtF4GZx4QJSBwAW8rT0GD0HkblUholImREjRLWcQ285pSU0XjpCaDpAaiB QdppaK9h/bohGqHOGvqtoRBaExhzCSYBTv66hGm/g+vegAvfBqnDZNl/0HZshDfcN+kwmHOeFZtM PQ7LbpeU0GVZIHBZluVdtnzh93/djXMOAi+DacvD4JYAgRoAwgaoD2oA28ZFA7sVNF0HtOoA2gaw b4F2O6CdA0ridNXhNCokxGHKXtiLcimh0iisVqpoCfjMCVZz1D/OCXc1t/fxjzsxmNdecxHArjvt IwTB58/d77AO8OlTgD/+41kAMDXuPsKhADzZwAnlyqBsrRvk1wOiAp9WaOVOTIygRicdp4fG9YFc rSMCv27qZDlxHQqiRQRDNdLYQkIr6uMiL0d4jICVpPoz4gElmRLKfVajgRxw0WoOhZsFA/i2qGWG 9XwDARMOwpiQ1yi6JsBiqCYKZIvIWbTKJMGYc0QDzV9LHPoeesXUZokGLssCgcuyLO8S+Pu/f2NY M9/vnYJn0zpVzwYd9IGDwP4w+miaFqDbA+xaoBAGV04UBvseaLcDaFoXDaQ2GBG0p9FU460lDiDo hT5SEGHxD7wLCDwHDJ7zeOaExJKlbR0ArlZuwuDmxkGet3/o+5MZ/G7n1pkhChhH80LIS0X2pChg rjk8MXCpqYKqMAdjEEMJiGSuGc/tQKJmMBi9UyoqSMz+miDtD5laQ+RvYQrgKpXKiSjDPxqL+TAD wswAnWP8nhKGSSmEZj0nZlqXA87E+yPxFwNgiZGyKB3SoigaRn4lwK1p+J71HtMmOZYRy7JA4LIs y7K8qPD3935TFYnGfn8aZiIconiHd/v+AG4eDQObiLaFZtUB7fbDPCpihtB9D7TvXW7OIS30aDo/ GLEJZvIW6b6aEcEXIfXyvnn65e6Du5bf//0Av/ALLh30tdcAHjwYXlsfQb6+dtE/HxW8vnY/lY3h AXSbAovtQTF0gt26oBQqSNtHRrqoxDkonJxmXXEctGLkFwjj9FIt0hevU6SmmhKWyWj7VGooFVy/ ImEYq8iLNe2zslJJEri4VFGlLlCCO1K2oxIVE9LNSsW8B9SVcwj/2ycf0f/8rSUldIHAZVmWZXmx 4O/v/xZZB+u43x+jdQ1GKZ1N4yIyXB0eItDNLfQ3N+NCoEGPs3Iqozs8RBydf+CxL429AwF4G4lB zs49h8Ep27pLy4a73KZP/WwaFwkEcNfbe/7FEb8wCjijIigXBQQwRPmMUcBcZo6hkxVCUTwIpRRR LRUU4nPGNBSDBspCTih3TKNzSNlMxDYQSgQuTPP06Z89AbQ4PF/psxjNfVEY7SQ+6gkZzJZl/p5N k5VgjvLfH0XlgnKEPgA2Ct4frNO4OszeAG4juAuOSQUi4SJpdhXZMJZZ/zgF+DTbjbBeMkwJfbld xlILBC7LsizLiwN//+C3bf1HlM+CfX8yfG8aOAnGACAQYIPQtK1LzwM6RAMboNUKcNVBf30DdHPj OnAi10v7gbkHuUMU8Pj7oMFN3GiXs46IR6SaUuhd1QreZ8A7d5pnLOijLT/wAwA/93MuCvjqq84b 0NcB7nanOsAnTwC++12A//7fXXros2fu9a98ZbbTyKmFK6njQ5CjiTnbSgGdKAiDtu1lewUqYUFr 5JRgGNUbmbsrqaXx+yIQIvO54BES1qaFAiSng8u4UFrUjnvbmptbUy00BXKSZKb0I5BJTe2UQTQw +hAFJvex9QNxky2Ja0HMfTILwU1sk7va3rIsELgsy7Is54a/P/gSmQb5iWp23O9d4mfTQ0MHa4iu BUSEPphG7XtyEcR9D7jfA672AP0esD+kj7aBGmhLTjqvJUD/PwyLLogzkg8VRGMYDKfvByM24hVG 7xsMzrHd2pCIWGcfqc984hMAn/+8SwF9+WXnC3icTIj8/+5BFJDz/SuJAuZAJwtimX6BEhtIyqEW nmC9+qRjF/SiAPkEAmQG2gPBEOBTLAeMRun14/ZkI4vA+whyjYLC+0d4oLG4CTIpsCyEWdRDc8Gv 1AcwY+YEjY8CNsKWgEbOSsJHCyHsMsLauFSIDKJ1o4MTPqLXIt4lnRk9GQfKp4ffS0roAoHLsizL cl/h7x/+DqmAN5JZSy/NfgdELfRNc5rsbhpousNA6aAsil0L1HVOJGbVQb/qALsV9Dc+KkjQIDrl UMRjdPE02tkdBgb90PyJA7/w9Tg1lIsIUqQYcBdiJy96JPJcbfbqq+73auUAMLzOXBTwnXccBN7e uvf+7M9mOaxkvZkGaJbtK4IwGiymonKo1PNpaaNsGinyf6fYRBzcazafHDDF5xD5BnINIaWPausP fOqYbU25X5JMlgtylqhfygxOgzkr4FWoB7TYKaiKmQjJ+jzOI3B0fb2VBMipo8l9BJMMI5GYM4Xb rFo6OYf10pISukDgsizLstwj8PtHv0vJQTqnrS2twwAi7nfQ7gGa1sEgoksTRUT3/0Ecpm9aAK8a 2rj/sW0cQPa9Az1qnGooHdRDD1FCX/fVUAe9n4Hc7xVDLsE+IiUYI/kL3tXyotTtzXUM4fX65CcB Pv1pgPe/H+Cll1xdIOLJ8y+OAhKdzOJ9JLDycrB7O3oBNgKwWaN6FssH1W+w1hy8QexFqwVk/wZd 7dSipBrX8qFkvYDpVE82ypgAMApTCQ/PoXAeanLzGyJzA+6I7SU0uEMoUw8tBcAJ61DB7UpGeNK6 O9ZuAkCMLqb8BLksV/OjD2yG8lNhzwzRhs8sxvELBC7LsizLfYC/f/x7ZB58T/WjO/SYuN9Du9sB tt0RArE91As27u+ma10UcLWCZrOG/VV3HEX1NzdAt7fQwxZ8UQb1DQD20e4CD8HUyHeUO6aYxQ9M kKL16J73bnMe312ee7jvT3zCXZfLyxMAArgo3/W1iwA+feqif2+/7aKBV1enSGDlKCCC8fZjQEO1 fLCAnZIyKqWCjo6dqW9L1TSaICcCCCxp1Bj2QBeBGbQn2lJWQYJEHHr7NQ2fhhn79XnhmIHNRGxY H9WXEWOFoZUvhx8mmNDOEiSWkljNRIZckpF8/hSoGkS3BKsILVmGnTzgvAmZc8pItDFR3RS/QHMd JXe7RAIxfvnff/AR/U/fXFJCFwhclmVZlvOC3z/5/fTzHAWXYcqPAEqQ0Ox30IOL9jWAzkz2AHoU dBc9ETR97zrlpgFoGugBAPcnuwmMa/cOQOm9CUkDFR8l8u+HqaEp9dA4RZTbD87Qz50LuOgFm7L9 wR90kcDXXnNpoOu1a/+w1i+OAvoU0e12lihgDCCcLyC3XurriaDYTGR8NgmHChckdUS0SCHy9YAj 4lTATxPA4fiFPQbkj1NNC0VdJVQ1mMdMGEOVncvoCWttbCLBWSwkNPITCubCSCcG50qcwfvhS9n0 Qc2fX9eQ9DL4W1h/UF7OTCr01vOPjp+EFNhzZIpqJZCWfT9slrHYAoHLsizLcj74+6d/j0RQM9X5 0TRYYHqmZr+HZreD/WoFDaCTU29bB294pECAfu/qAHct4KqDZucMv/u+P4nD0DCphvoesDlM0XtB mfiYY/sIgGEtYdhesYCMtC1OYOaulxcJ5nKONb4OP/3Tzgtws3GpweE18bWAV1cuEvj22+738+fu 9e0W4PHj6gOlBmxRQK7ezCIAo6VE5gpNphgkpYqJSsRJSwUtAeHjoF5mNtF6YzA4Dx9PWqpnGK0j N3BvI4g6cgBFv7HwGqDu7Sh52fVwsqQwESSNIQNSKaM5sGddx7o+TaAcxfxd6hLDiC4eQDHuLlnj +AgYBxMSknhM/BjkopI1CS79cvHmF5XQZVkgcFmW5S7B75/9fVJhxJIjklMLmNvzHD7TbrfQty1Q 0zr7CEQXFey6Uw+IrmZwKB6zgv76BuDmBghc1NAVA/ZH+AuVQ4k77jDS5yNDnJ+gphDKTQvfNxB8 N4JleAyvv+5qAC8v3c9mczKD9/V+/sdf89tbZwnx9tsAX/1q9cOLo23WKCAaNpqMIqL9+EpUQbVI YsYhHL+XDRMF1HwPB0bvoO+Um++RLER9imfDCAvHqaDq3ISSnmuKBk60ZxjVBAbbTKqapo7F8lnK /D+zLTj/w6weyJI6mlkXqMGlV5Plzh8Lm6US+1XZaAr84u9oQwC/+voj+qVvLCmhCwQuy7IsS134 ++f/gExpmWToekoH+5boYvBes9tBAzvouw4QnWcg+jrBxqWNYusEZPrY24966A++hIgItEPosWFH Y6yZfAh84Wtk0cAGPRIojUbf6wBXe/n85136Z9cNVThC4Zfr6xP0vfOO+/v6el4AtFgdMCOlXBsI MAAlYjr9M2UCn4IYMkJhvM2wPi6ORKm1kYxNxMADMKzP4wRoBBXP0bVktsH6ASLzOQW+czkwbmPW ZiMGo/h8ciN7JWqjUPDeFEphICz+myJfv4Hfn7Ceqv0VGtMHkWKIkkpKH7mD+UQ4pYDGv62qqHMC pCSyGtfEItgVgJdlgcBlWZZlsYLfv/gDGvRqqZ7F+ogvrlA39EjMdpvdzqXyHUVjnKfgCQibY20g tIff/qfvod/t3Gcbcu8TAUCgSd33Q1sJCfhCOPQRQun42QIR4FNK6V2aIKOB/hwgGm739dfd7/Ua 4OJiHAW8vXU/vjYw9Avc7WYbNIVwwEUBNVVM6ZTjdThQxJwoYK3zjYHRsAMCpc4O0wceA3QjRe4g UV6YSCtNieNYfQTRSHbhdo5vh5YBlvYtMXvXDOOtIFiqEJr7uAnnAGO4O072lW10IA6jzWGGgCN5 Bhb2kFO7CgkKTcI4xuONFT9z1EXhXdwVLssCgcuyLOeDv3/5D8kEdXMASK6AjKmnoyMIUtMeQQxX AQS2LWDXQb9aQb9aw77rTrB4fQP99fXBRxCBAKEfDVwOqqGcEIgEbTm2EVxU8L6D4H02rde2+8Yb Lgp4eekgMK4F9LC33Z6igE+euL+vrhwczgCAA7BJgCIagI+t+1NkOkfiL0b1T8vr1kgfC1lKPSBI 7YE6CAAw6Y0xVEltLBi5DzYTqXNStA8UrnusIOrBhIJBcLIW0fDIMcO9BnlWUMwFvBnVQ1Vvvagx GgTYY+S759/34tIHgZg96MInWVQXRgujg7YA4Lulri5WCfXntKSELhC4LMuyLLng96/+EVPrVxDJ MwHJDF2Qqqvt/mi8imPXAeBBEfQQGWyInPDLfudSRDtXK4jrFeC+BzyoPxL2hxQuDFJTTqECCg3j /agqTiUMYcICJVJU8NyQ9F5Z3njD/X7lFVcTGEYBvfn7zY37O44C7vcAX/vaPIMe5QUW6rBMxCVX AEb18cv4W4Q8yDsB4gAMx1YO4t8gm7azqaLCV49w7Kk3OB9U0mjD447TSzFxHTDBXlr9YQCng5do fLym9E2E/GhgCRjdxRxXDGXaYUXgFqZ5NnBSEY3n+Uyni2loJxLaT4vszcPZRZfaKgyzkN8Cgcuy LMuSA3//+h9TCp5Gj3pNnMSSPkpg+LwRalQo4ruMdrsF6FaAiNA2CPumhf4QEdwHUcF91wF2nUsV RScSg31/NJVvqHXCMeTdnJth28TwF6uCpuwitHN/t6aFktF1ueZ2w+298QbA932fA8DV6mTWBuCu 1e2tUwB96y33++nTYRTw5maWgVBcv9ZEv9kUzugUJVN4NeVTiQKmAKTmYBsJkhFD5FIkLZCBY0AS /QDj9ZiGjFNHJdJjI6XRcRNF3mg4jlBaU0Itl+i4utBuYcQSUX7NeiwjYMylDipYR0lb9H/kVDdY t01oOxbxkZ6o1cMpUBbVA6r7kvwCK3F7zvZGnoFLSugCgcuyLMuSAL9/808o/0nJmAZx05U5yp9T wKU0IubVQ3dOPbRvGkDwyqEAAKtDraCDwd7D4GrlUkXXK+ivrqG/voaeABpEoKY5pIruHQvu8cDQ OD4Wrx7q4S9V6c/ZSeS0xaIimre9j33sMFPQuojxajW0g7i+dj++HtBPAvhIYGVjeIkjrB8QI3mY AE4w+AMmjlFKHU3ZQrD70RQ9FRhEpQ4QtfMN/pEYhRLnDDBODZVSSEFIIRWFZqK2Qeu9wQkFcYb0 nM1IBAIjtdCcCYBcYZgU9N3RI0izcdDgRiqjp56vR4zPffSdsCiZStUFYK95PGsQVoBNyzEsKaEL BC7LsixLCH7/9v8he5Qt8ZjleiWqNEBX0zozQSAx8+rUQwH6rnPKnw26gT8dPAH7HnC/gmYTGIH7 Y2wQqO8BdjC0j/BT90S8aujx8wH8hZFBi2CM1A7vBbGYOZc//+fdzyuvuHrALupawlrAmxvnB/jO O+7n6VOAL395lnEQG+lTat8Qgwgh2KKAOQCaFD0xApz4OQaIpFRREwgj3w4W2PCCwKY6QwEAU+DN zaPFbYeGGYEQ4BoULC8CWOjByeqX1A+aAa+mebxmCaFF2OYkF0XAhLOPSD6a43q/8NqEKaMArCeg 1OZo6DKnqIFanKFKwdIaGTw2EzpXp2VZIHBZlmWBv3/3T4kTSlF7WFJSQLMfz+Wrmz6oRsY4H8Hx 6s1uC9B2BwVQdH6BDULfuUhgv15Bv9lAf72B/uIC9s+euRRRAOhvboFubk72EYjgZACY3YUegt4r 0FtIaKCnnW9qVBG/b02LvKvlLo/v1VdPgN627gdgaAp/deUigT7tM4wCzjfOVCFrAH05UaGoabX0 UFNE0JCSGEcB0QKdlnZAI6RhTsOeLjGizDnseSXajgVrHD4KQsl+ikAOuEhOYChvATtUoGH00lSY SxnGxw9Mi0KoBopUdojT+yoDYHHm7+Fb0RscZKrAlkjXlNJMq5LbGRbJMcr/+X9+6hH9j28u0cAF ApdlWd5r4Pfv/5lu6A7G4oRkRDCzNrBWtDDsyQQ1UDMUHVb36qHobSQ6byPh/j8V6DgBGedG3QA2 V075rb9mzOQPhvL7PeMeHZjGh1AYRwK1CKDVOsIqLHPfo4dzHt+nPw3wkz8J8PLLAA8eOFXQUOAn 9AV8/txBoI8CPnsG8JWvzDLIkaKAHPSx4CTAHRYejwRZ6nvG/WWUtU2HEaXBOcsM6T128xSl/aWg lKsRRB2UxTZDg2E8ju1Ow2ikCEXMI3ZQR3d4HbHC9aj5VSfm9/ARzTMojl+kaNIhtHIYKYT6a9EA 0J5JZxTyG62AZ4qy04QomxBNNQnV0PRnHylAi4bhxHrBvwUCl2VZ3jPg9x/+GVWFrJwHe25tYG66 Yq4ADZUdf+M93lZrJ7rRNLA/2EiEvT7t90DbLeC2A1x10OxWAPs99H3vADEOA3iLgfAnjAjGvoKc jQQp6gFSG5WA4Ht1+dmfPamB+lRQIlf79/y5E3958uRkCr/bnTwCzxwFxIrbFtMkUQY6K5CINhSG 89GsISS7DFWwRjnIUWosUxcXvye2TwxaIBi+R8AWRhC5KCImopaYQdkl2i3coyUGyVH7c7KOWInq ab71KfM7JNYEMhAVP7ZjYCRhOyOPRxIM6GOwzUkLFUBvoiaOrQsu5MZQDCZw54D5nsjLskDgsizL vYK/fz5+bN+lKRAVrqT5A6regQnI5KYUpTySw9Jub6FvOycac7CDaLoOYEPHnhyb9iAY40Rjjj/X N9Df3AABnLwECYDCusAwGsjBbZgqqoGxBIslwDeXKueLsPzwDx9GD4c00PC6xHWbftlu3c9ul1Z4 nQiAKAFbBCkNKuvCNNP3ZBalABi5+h+SNcQoPTUBg6w1BOTVBhK5mkAQQBY5AhTSXlPEFZvC59pi WJ62R2/CxAXPYrSaQIcTP5/bF0WRPjUKKnWnXLqmZLuQqAvExHojwIyuK0Bg7ZFQDsXovos9JlkC TKiEzvH8KzGOP54fLSmhCwQuy7K8G8HvP/4LMg/oWREXa/pmwoW2ZmphrjWEFSQLRWya/Q6aHUHT rWDfNtA3CH17UAxtO9i3LWDbwr5tDhYSYTFPD33fAxI5P0HcO/XQvfs9igaGgMhOE0fHK8m8WaGa e//d5j9oBdYf/mGAv/bXxmmgREMBGB8FfOst99p266KEt7ezKIKy6pIoDxxLfQClFTjhmLjeMIyO cZYK3Osc3FnH/0QOdIv5I5EGygG3BCgjL0LB4F2MviXqBkNlyPixMNg5KkI0hlOfZRKwtnl80URj /nasKY45AirZnIQRlAlznYMmxkS3CGX1jpP4rwIgSsUpbOGKoCe3pIQuELgsy/Lugb//9C/lbotS Yi/WJ34i+Z+MfoG5nbj6ZCf9ODWQ1XZgKIP0ojHYNABtA4DdwWC+gX3bAhzA8AiEh/+haYCePR9H ACVgiT0FuWigBn+SHUVpfeCLvljP69Ej93u1cqbwXXdSgvWpnj7a519/9sz9PH8O8Kd/Og/DQiKq h4pipLIN7tYz1bkVsBULtRG4pLbHpaLimN1GXwEsORGO+VBlRrW9KIIGyYQeI4/BAdwpKZyYexGU pyJan9toFJSxwB8HjGBoXCu5zagQyjroplJCQZm3RLk7H0TEAFyNYZ8JclHkkINCTrwml3JrpoRa t1WgZrAsCwQuy7K8IOD3n/8ViYCTfMoJKaIs0Bkf2akIk+lpb3TjJaYHp8zeP7v+cLz9Zrd1cIAu 6oeHOkFsGsCuhX7VQb9aAa7X0G82sF89c3DYNM5P8OYWCHfQe32ZPTPKCWsDByPeYN2BDYXQVlqN IPd6CgqlWsN3w/IjP+LEYF591UUBQ0uIvj8JwTx75uoAv/td93cYBZwJADno4f6WfhqLD6BQ8zaK ADKAJUGSpOZpOm8lFTQFXNq5JukSxp55I1BGXeBGBVfUlTbDeiZWWETYwUCEhobqkmggO8yA43C0 3TsOYfN8sYa6T0mUkLOLyDWVzwUezKivO4g59Qebh9F8Hg2jixgI7RzvAxKEaxLNQpEQDlXyArxL 0JLmjOPhEQLAF19/RH998QxcIHBZluWFgr8//NeUVPZMPoUTkUJrpC/Va1ohywqLWs1eTcEZ67wk 4tFTcL9aAQVm8s2qA6BN0Mm6Xhab5mgyj6tr6K9vAG5uXVoo7KHXoCqMAvrf0nmlonzcb+2aWdJE a0YPLddsLuj81KdOUVif0tv3Du58Gujz5w4Et9uhSuh+D/D1r882wCmJAsYRv9Q2UjCTgqpsA/sY chnIFFNJURBUSdQDAozrAdWDTkWjODEUbpPIQ/wI7kAQk8lsUCy4x6SvdBi5lIlaAbeUIIzFRzC+ DqWPnJzIYeHjq8Gg/hvHdXZa3SBG6yDC0Q9wsI0Jh65ZRORELdmmpenHY1qXi7JaJpXojKnQy7JA 4LIsyyTw+6N/Q2VRq5z3cyKJEx7h5lrEgvMqAYlK22pvbwFWa6AGgNYd7LsW9r5GsGmOU7bU905t dH/wkNu7dMK+7wEaAiRyqaIA7n3OPkIylw/bUkoNrakWOmfaaC3RGgs4hpG7T38a4BOfAPjgB10a 6Gp12tdu59b1dhBPn7p6wBAI7zgKyMEiQJ4YjEURNNdIHpjjn1oLmGKOXOpBoe2Ox21JR0QblGnq pLHCJmbcC5Z9E7AuB6NH7FSArOYhmNvHaX2HJeeQEYYpNTwXd6HU9JHhETaav/OPfSMcj1JJ424C xrAJgT8lUqRYasjZrNWOJW1+jKouw8kFApdlWV4o+NMGvlazbxOvlTyZC/cf76+GNQRMiDpq71lf g4N6aNdBj049tGkbBxGHnhrbFnC1gn69hn6zhv16Bbi+BrxeAa6ceijc3EJ/mAomxCEIhrDnYVBS A43bSYsGWtvrRa8V3G719z/9aYDPfMbZQYSKoD4F1JvDP39+SgP1JvG3t+79r31tloFME4BcA3IU EAW4mQqfFp5OKYLWOIZUrV+1ekCjCXwMbtxPE9pK4NAAvsHxtYu9+SgaqPuBdKjaOKq304RhCuAM c2HNYjRfheInTBSWJIdwKbzAi7BYKymSj15FBVP0zUNDRI7ZLiJfbVEUpZsB5nLv1VRxyK++/oh+ aUkJXSBwWZbl3oDfH/9bmgR4JmAsACVrvZ4VuJJQlwtyDFSWpKOaUk6Z17yn4G4HDRE0XQd928K+ QWjaBvarDvr1Cpr1GvarNfRrZx3Rr1YuPbRtnXhM0wA876Gnve244/RQrY05u4iUSEwOJOZc1znr B1Owpx2TB8C4CKzvTx6AXhDGC/V4kZjdbpbTkQAHFH5h6/eYD6ogGcCEVAvIvSedA1rFTCSAE6Kg I1EZJRV0JMJi8NnTUm65ekA0POqOT6tmfMFEiESmlhAzga0WjRd0RVhSxDmHWmhqDpHyN1sCPuKj k4MvKdIWghynFCoQEVs4Uduwr+AzU1JCpesTvt0c/u6XyOACgcuyLPcK/r7870g0/5krfSIZVSyo A0y9b64ut0fgTD2KFVYoE1YFWHK1gjtoug72bQNNs4Z920J/qAfsN2toNhewv7iA5vIC+qtL2D95 Cvv2mTvc21vob7dHC4nRaEoCOul4SyN6llrAkghh6cQGYjnkactP/iTAL/6is4LYbNzvtj3V+t3e ut9XV84W4q23TlFAbw0xw3FxqX+Y8P1jVSYzx/EWewlJ8T+nJrBGKmhOSZkGv+L5CwV+A6EWlI3S 42uBguwqC9OoTwpw6x6FYXCoRkqCgqcVylkuMyqrFonN5IJgLj1wfawlTxaCMm8Yiqyw+lzBese/ aSxwzXaRQhRQWif0+RsdNyqUBIZoY0Z/ew6riNGEDeUJmC7LAoHLsiz3A/5SHVpWikvlJ6u2cyoB Km2bBdFPFkA49dAKEUs1lZQ/rWa7BepWANgANQ1A1wLAyg0GG7c92u0Arm+OQiS4WgH2PTSHWkEK RxUcrEuRwDg1VLKS4MRhaqSBTk0fnSmyph7vauXgL46G7vcnEPTt7NNDr64AvvKVWQBQrFED2ffL tOoAACAASURBVDS+AT26xyqHoixUklIEBQZAsRLoaamgyTrJFPwic64o1P8x+aCxemcMZMhE+BJc eTofTj0Uyu0fSgR6zPQNTOph0DAYA2o2ucP98A8MH/MClUlegeKc7uGcQoXQAcwF0T61+8TIHJ6Z 9ABmsiC8RpQ4aa327xzKoVMtH6TuaFEJXSBwWZbl/PD3J/+eZAP2UgKEunVbUwf+2QqStSrvZ7Kw sO4zSi9td1toAQBXa6CuBepa2B/SQAGbo22ETwl16aEN9IhuQHBDJxD0voH+fxSkA6UawRQIWu6l qdHAc8NdavnLf9lFAS8uXAQwjALe3jr7h7ffPhnDv/22e+3q6hQFnItLYRwFjCEPwGYOrwm9SHCS BWdYNk7ntoVGmXsu0qadr7gBGkOvqB7KwBoHfRaYZaetiK8HjAEztq9omDrDwXHGpx7WruFw/zHd UqSoGIqK5PoJjv431hSK4js15z1p+jqjaPzBvw/DyQPjfGJYF9hgkMrIPe6jSJx4yEHkTzolreIi tBuZJPQyY8gu5RV4tOcggH4Zji4QuCzLcl74y+m8hCdlKpVzamSrxvtTYFTUq1Z6ZDLuV4U/JqfF avyUOLzu9gb23eogHIOAXQvtegXQXxwB7yges1rBfrUCvFpBfxCN6W9uh6mhoVhMHA309YIchEuq oVp9oCUtdO5JibmWN9441QM+eDAEwOvrk/DL06cnMRgPgLe3s1pCpMBMU/FM+f2BAlxiXWFh9IlL dRQ9/1BfD4VtxrAMURsMon0QlX0yIco4wxoFMZdUrSYXoUQlMjiwhmAaVUsVBQsUCxdK9HjEPBCX 3kwaxls3XgHUzJ+lYepmcRY78Obx4uFqdYGxjYTQfQ1sAGnsC8jdGMh1E73cpqMIZw7Y5SXVTOLG uCsPHDeWZYHAZVmWM8Dfn/6Hsu5jVoGYRO0fpXS1a9kvQL7kt/bh5Pa41Eplv1o7ZAJnu9sCeoP5 roP9AdawbQG7DvpV514/KFMiBoU9RLC/oSHoxU7WFqEYzkC+BARLga/r7k808Kd+CuDjHwd4+WV3 XPH0uq8JvLlxf3vg9oIw+/0sh4VQFgVE63ZBThE1A0bm38DBUDZZyBmEqvgIyoIwUrSPq91DkBvN cg0GRu4BkI6iiSC3TfhYYr37pgBgfLBNxoAe9Ucu4vTtTIGLKZ/hLBVG16XAnoFbnyL4JA7cuPub FIsPlA8Np1RwpM5zDqIzjgZMuz6026+8/oj+xpISukDgsixLdfj7yn+k80VCLJEZME47WoAytS9j 2iBVBF7LSaQUMdVeu8BmIVriOkHqWoC+A9p3QNsOmvUKaLd2Ub9+f1IgOIxU91dBLWB8bTwASnAi WUik2oe7flMsNe4DCP7UTwF85CPu+NrWHVPTuOPabk9RQC/+8tZbzh5i5iigquopgVgMNUIUMAtA IS32Ipq4G2BECsJhQvESBfsDVFIwQWtPo1AJao9cNFsFngbtkZDLgIFQF7fRAO8YLGIe1QPhW1Tu L+2cC3qlYmuIGlBYec7yXMvAS1A4fuR8/Go0i1aAp+Vacp8t8UKEeY3jY1BsYFkWCFyWZakJflAb bDKe5lp9YcqsPdUjcBCQk5qqRpJgepW3pZ2zlU6NB5aRIunrBJtuBc2qg33TOIuItnW1gm0L2DiL CT9qwwZd7WDTwP7mFig0Jo+vQ5gOSkH0UJqSTxaqFBrK57bNOZfXXgP4C3/BpYFuNqd6yxCoPRDe 3Ayn5n0kcOZBoMYqaiTPCECI+mdJgDOc+ZyTKaPaOWIC+iwbgSitFtNUmUwLFQRfWDEZSNddSmDP HoNw/CSk+GU1GgUQzISiMAIZX09mrgfMAcHSx7ikDgpBRCuxfZMZOpPKORCHQXvtoAiCQp6jvz4o gBBE6rGk8N+LBNupy7EsCwQuy7LUgb+v/ieSZT0VgZRaf5/l4czsO2XFwD2FkwZJCVEZqiEgUwNc phnPt7tbgHblABDX0DQtNKsVtJs17C8voHm6gWa9ht3qmfMQBADqaawc6oGPU/qMR/AxLGpAWAJv L0Ja6Oc/D/DBDx5GX83pxwNfaAj/1luuHtBHAX1k8BvfmGXAwv00EWg0CrylooBqjSHqkUiLIAyC YG1RChnM8Y1Akbl9tUYeKaKG4BVCDaTrMRF4URgu6he3TRIMmePOGcFiJgVjSXeQ4f9XM7A3y0LT VjGBYHht4vnXyO6BSIh0MebwKd+7MMIMHO9qiTBSPSKe7EigxL2pkpdgTnQRo7rJBgH6JSV0gcBl WZZy8DNw3zl9/ko7OxN0Jh7LZHQaKoE8K0wmFUpz20P7wPTChna3BVqtoUUA7NpoRvbQ4zYHj8H1 6lAz6KrDeiKgvj9F/vw5+7o1D4dcfWDKR9BqKP8iRgO3W1cL+PChUwXtumG7eAP4MAroI4O3twBf +9pshyaqUUrcjulIICaAz1pTqG1XMqTXPqdZRoiQlzhOZOr/UNnJqMYyLLUVyC8JhsLBczWMGmir AAGJGk5DemzqopOSxpcL8yKcW70DS0i1Rh+cmb9ozZLkSSwB/xgBXdDtHiOxNS0xcBhBJAuM5fgF Tmz21IdytrGkhC4QuCzLYgO/x/85b75QTMmEiXYQRijKeuLPIO2Vmxaac8K1YNKqADoo1MhVsyHx pW57C317qElrG4D16jBCbAC7FnDVOYP5iw00qxU06zU0q+ewX6+gv76G/fXBqiBMC01dz1A9VPMO LIkMWu0l7iIa+JnPAPz8zzsxmAcPnDcgojuO62sX8Xv69PRzc+MsIbwtxOPH88FfDBMwjvpZjc45 7z7NP5BT5cQYrMAe+BHrCVGHW+2YYvCx1hECKPWRqECNZOiO+rc+5ZkYajkNUvlAj0DG9X6DyIbB loKkdomjkoYZAc5v3XJfiNYQUzwD72EK4shXEqJonCGkOHqMouFzxjbhrh1F3y2a4AlYMHqo1vho SGfF+3nrLMsCgctyb+Hvz/6QVMCwiKaQAmxkAZkMYZbcx1sV9VFl3znqkrNOIU6o8TNHHhNJKwxU NbstNACw71bQtA3scQXYoKsL9F1W3wNtd0D73kUAg+31TXN4DY7rqmqhXCRwNDJV2iU+b2mb9wkE P/MZV/8XK6v2vTump0+dH6BPBX3nHQfXu92saqDxgBwMA2sW+gwwVG2QG4GYBZJyj4tLLR2Nr5GB 1UQdoQRYDTARUrQJypSqgwITdZTAOQXU3AaQGwln3htFHu4K1E0Si5k6cg8TPLhkj9KU0Iw+a7Qq ylFXtaZtQtZ+kR1uxecHVd54VgQ2et+nhC7G8QsELsuyjMHPAklTo1wms3jKVNKs/ejOANBUuilU +nxObWF2MUFBSqrVXF1Z7yQa07moX+vqBJvNGvrNxkUDH1xC++wS9s+fQ/P8CvZPn8K+eQ57AKDt 1oGL5iOo3YecwXzpSOO+La++6szhX3rplAbq0z+vr8cGbkQOAP3PjJ6AKEAdJuBEBMIIHky1bTnw JRw/gCEaKFCGWfQEE2AiAQSO4TFsS2LgAxUYGTi0pFRNY+gTQNWiXpoE7UBQOBQ1ER+HKATlcgVZ GMEToAx/ybnUQCu6GR3Pk9t2Rngp+TgNoN2i+jlq40gghqzJO6l+MkFbbEpo5aFIiR0hRvc1LSHA BQKXZVlY8PvaH1Fy0G59gpTA4Ug6jMo6sixhmdJ6wMRTOhUZymkfnNoGGszWMra3pkumYbLdOk9B bBpo1ofoYNe69NC2dR6D/nMe7poG+qtr1/ff3o59BKXRmDUKmBrJlJrKn2P5mZ8BuLw89A6dSwMF cMDc9ydbiKdPXQTwrbdcG263p98zLtYooCYcY93HlNo/y+vWdbWUUSz4Go7aEY0m9wRjM3nQlTUx cf1Gx4YGGI8uLCYaHjMaXfMKTN1r1aYRA6hhLQfmgkJLOIhTB5U+l7LQNfrjhde3wQOzHeDNtxEx IBiCVVaGPtjaITeqNoPlXzUQtKiD+rTqZgHDBQKX5T0Of7lgodX4UaEDehY4WiKImY/UrGm2BDCG 25oMA8YDoxIXolT6JjBegVN6vkR94+HvZreDBgC2nVMQbS8uYNd2zlz+qBbaA+120G+30Gx3QF0H uN+71FAfEfRRQCxwdM4RibGC37lTQn/mZ1wU8Ed/1NUC+pRQfww+1XO3O4nq+Ne3W/f7jFHAUeRP AQgU4DAlGCOlkWq1gMnXGUBJ1fix4/7Ip07yA2RtNDIsJcRCx1QUUXnssBG+QHFU9PUDGEj4h4NT AL12kk0DRh1YzYRnBOhsIATdo5DtS4rp0/g+Vdym9sTPkrMcTlIcIREgbSXBCKUkv3wwtow47iO4 R4lTBi1NiRU+l9vFxibwakAzior7815SQhcIXJb3Evh9/Y8ZM/fU/xNYq7gTy43O5VimKttMzqBa c1rAbiReDHcyTGX1KOwxpYAwZawOQ93vrEtFsNrewr5bwR4RmqaBZrUCuriAdu9gBZsGsO1gv1o5 EZmrDvY3HfQ3hwhWGMXSagOlUeQUELwPlhGIAB/7mPvb20EAnMRgnj1ztYBvv+1qAb/73ZMhvFcJ nXFRo0gcuCnm7KVjeQ70pGPIOS9IHacxFdRyXiFAEhjqFQVBlVAsJZWCG95i/qfBcapoCuI5YEam jo6Ygbpmi8FZiJgihBQN0rX2lMA8aN+kdce994+w34umAKG1ND2APa1btdhE5JwIknKs3Bwm8JHK YqKb9rGsbdxFJHNZFghclruGPwto5KSBmt8zRg+nRM5EMZnMqc6q4jMzPGZLigNSn0+azRdcK6tQ jagjfqoV3HcraC43sF91sFu7WsFmvXb2ESsXJdw3zXG01/vj8yBj8RC0RvessDd1AmDK8rM/C/Dh DwN87/c6g/jV6qSMGtf87fcnkZjbW6cUen09iyfgCLqAjwKOxtnIszoX2cMEOMbrxmPxlEdgKo2T tOM2bgPRAKKMwieirEaKOAa9I6zE31nOjkHxXeRAjqsZjK/pKBVUg0WLeidFNYFgTxu2Ahm7GvMi qw6qbcT6Wu7zdsbHzUh5MjzWBoB64EVphK52VFuHumVHCG8AY4A3RdqEdcVg30R6mgO+tMCkqa5y 8QxcIHBZ3qXg940vU3Ft3xToU33qzjAILu4QCx/RpTWFSfVQGZCKwbPIqYKZerWKvyTPN51u2m5v AbqVqw28vHBRwIONBHb+p3W/2xb2beOUQ5vGAY2vIdQ8BKVrWlskZu600L/yVxz8ff/3OzsIPyL3 UHxzMzSI99HA58/da7vdbADIgRj7PgMcsX1ECjBBAgopwoNp4GL/jdM4tX0byUKKIOWK1OTYEXCR QO4A2Bo+HG5bBINwOxltxF0byQcyFgaKISJ+BKL5IvFgR8H1p2AF5NRBSyJ/uZ6C0jOeKvcJcCqB Jxj/WFI/uchb0nePqwvUCvfirwGlux5x/i8DBueKtKnbVaKVsXE8DXkdeliWBQKX5d0FfzUgz2wP UcFq4V4kJ1QWi+GexlntVpJamoCqogiV8fynpqWS/GK72zpgahvAizU0bQNN1wF6D0GvIrrZQPP8 OeyfPoPdc3Sf9pYHIQz2vf0eLTWRvyvLiNXKAeAxOhqci6+b9G3io4B9f6oRnBEAY3DRooAxRLBp osDXyWlKohnj/nRkUAIUVEAFEn6Fkh+gUg8IKasIJpdWTPfMgA7W+oGBQymqOoBPIb10dO04Si2w gci59lYwS01yHD/KCcSUiMVQpRNlXH4QZc/6FICRcb/x94DIDlsYtVtz+LOPDkKM/BG/DiXK560g NodKaM3Fw9+SFrpA4LK8W8FvrlTPSWBp6MwsoFQrjbS0w8yCKOG8c9RDzXYRFYGQ8wAsgUia0o4Y gOAOWiLYrtZAbQvUddBu1kego/0O+ptbQHQ1cNg0QF132rb3vONAMJXWWRsER0/vCiD4V/+qiwJ+ 6lMOBFcrt10Al+p5c3OKBF5duSjgW2+5v6+v3Tozp4E2qEOeFAETgY5JAxUH8pnRNVBgrgZQxGI2 KlRaAYcYyOMEc6KNotU0PmpszmGEa3eOdY4cQUNBGKmdOH9Bra1yuLZ0yhDPtdGphvF3BSOhmIpp IhFUBdCs2juLTObheGponmWrd2qAC9Pnm6Xf3ITZkhK6QOCyvKjw9+aflNX6qTkkKaCpUCdYE9zC HsMEUWSHlZJ1rJ0xTZQHS2aGJiJ4ZLzOUyO2JWmtCjyttrcAqzW0FxvoN2vYXWxgt14fxGKcnQS0 DgL76xvY39y41FBfI8jVBmptYI3o5ZzLXPWBH/3oCSq9GIw/D+8PGEYB/Xs+Ejjz/MmAIVD262Nf R1s0DxOm5qNtaMqfGjQmolxT4YMM58eJoITwlzNXZxVaUcFcSBlFofYvlY6JUjRRqD2kDHDGTGjP unahAw0o9YE5NFnDMD61TmTNS0K0TH18kfFBkIC8kcsPoxIqzXcCjBU/tWMlYd5v0AVApA5q9DOs DeeqrneG+A4lvs/LskDgsrwo4FdS96flP8Q1fDRxX7V6N0tUMPcxShnAq5namx/qNlGUms1mghNV 5ATskuJsGmg58EnvO/XQDgjRmcuvV9A+uADq9wBEh7rBDvrnV4DXK+ivb6C/vQG63QK07UkYxadD gjLa1uoDLcqh1vOaEg38uZ8D+JEfcbYQm80wCnhz46J93g/w7bdPP2eIAlqgiI0CJqwPUIkCWgY1 pZ5/OV51YIRGSMGeZg2B49TQUTvEPoLMMY8A3JhSq73GpXsOjkEDQ7BllJuuB4LuH6J1KZiAOFAg NOULWHuh+7l5UzartS5Q6hY4ewhLd1xwkucIrBbtI9GFcwDdHF7rl7zQBQKX5Z7D3zf/lIqgKwvc jOmbufuheyRYnGUODmmZsFSgTGyHjHTN5PtlVgzZ1ye1T8owprfaTAjvt9vtUTAGLjbHSKCvFcT1 CvbrNTTPV7BfdbC/aqFvb5yNhB+R3t7KgjFaGmguCM6pDPpzPwfwQz90Moa/vARYr93+rq8dBPrf 3gLCw+/MUUBO1IWLAiLyY/W4Ti784cbVqNgfsBCj2UIocIJog1vpPWu9oAkYE0bko3YK4RETJvGa 6iXwkbfR/uIU1WhfJlgXDOUtbcuJw4BS72Y5KNKaKrSJAD4NFg1Aeb7+sGx1NN7wpKRrSpE0rS6w xDg+B1SL7HHPPIQRd5dTv8gsS0roAoHLch/BTxqkW17LTQvNepBVMIcf/H8GK4k5es5SUx4OmFKC NFkprhPdgko6tlRNYc79a0hhdYIxK6C2AVh1QPs10G4PzdbbH9CRArBpYH9QEe2vb4BuDzB4c2NL +9RA0AK5lrTQkmggooO8V191gjBtO2yrMA3U20C8884pCnhzM0sU0GTODuk0UbRsH/jt54BZjXVT YJhKJ2XhFBPQGqfNxfV+XLuiEvETwn9qbSbwkCelc47EZdCu+CkCHuqQUmzZRwHAheqfHiZpCDWT hF6mwGGG3W9VakrN9QXtlpMqqiWVcGmjAKBKXeYIcYsQyhTYSQqm5wZEab5aqgnEM90my7JA4LJM gT8rSJXC0aRInxEmzZHHgqfl7AqjhogfVWxjDRBUoCwZNBRAWJYHY4bPnjWtkjn/dreFlgh2qxU0 Dy9ht+qgWXWwv7yA5vIK2qsr2F9eQX91DfjkCezhGdC+B9rvHRy17SkqFoeS2OIQsoOhZap6Cgj+ /M8DfPCDAG+8cYoA+simF4K5uhqmfXqlVB8F7OcVCEdBDKZhIISNBnJQiDo4AaTFYxD5Gj5V3VOB N06dE4VjMz2XUzChQFlWPWC8LcFCQqrzQ8EuAs0zBLIlhXWmATHdLsWzGIVsFkb8CAWLCCldtEaU MFupBEbRuaNCKEVRVCrcH3NhuMkB62GD8ng9WlhQBgAaPAYHvxORtxLNmqo0mHmrN8vQe4HAZblD 8PvWn5JNwMNY5Z0yBacJAjBmCDGaxo8ApATuhFq/WhHFEtsDrS24vyWRG+4cc1Izp4CnpYex5uVM vhbyFGy33QJ2K8D1GpqmgWazgfbyAvqbB7B78gx2T564QcchbXTftbC/aoHa9gRHoZVEfGxWAMw1 kWef5gYQ/OxnAV55BeB7vmdceMWJvnh/wLffdkB4piig9pow3s7avpbuKQGAqsKJdoGXEiEYFhZR PgY2LTWu8bPUAwp/j6KBUeTP4hjRGODUwgWmv7H8vrFy91zbOmsGKN3BdgXVErSKR4dpnjAUhcE+ gFAAWbBac09PASBFnnowFIaRZDZHQGgYH8ytEmqBZ2S6piUldIHAZTk7/H2FxIcrGU14klYMmWmi 6v85MGfsPMwWAwXKpJYnaS40Usa6OTxYs2cuEFwpft86NSyBdFHm6vjFdreFvltB07XQdS3s1yvY rVaATQvYtdB0q2O9IK5XgG0Lu+dNUL54SJ3UQikW4MsViuHWSYHgZgPw4Q8DfOxjpyigTwX1gOej gGEkEOAEhV//+qzPtpGiJ+riI5ZaQUtUjDOHL/EJTMGbRjqlUUAJeHIPmHI/hoZoqwD2g2gR2mAn BXBxMPT4jSfZKkK9Nmca1sbG8GwAkFNjnRINfFFz+hSpSzGqhpFKJ8hJI3CAM4swDYZRSGtUk/NX 5I57BppLqYSWKpcu9LdA4LKcG/64qJ0lkmd+baqOcUbdYG0TeSt85vrUzfkktqwsgUEyRbPQxL6k E5pce5lxUMnUU/vxeeXQHhvAg3oobdbQUg8ACNg20KxW0Gw2zk6iaWCPCH1seCaldZaIw1igMEfl 4HOfczWAFxcBPR2O30cB93sHgs+euejfW2+5v8NawJm+ElJaZ5NYP2eQwoFkaW2g1SLCsg1uDM8Z yYtRQAEWUucmWV+oNYCpkJ1RGKYBpf5POs44vZQBUu3QuHpACX4HdXvKo0ZSoVQbAdLzRcUqofdF PAYqWCFIc5UwtqUYpXCSADxSYkiGsMvo0LiUWFK4jyq20zlZG8eiSQ0A7GBZFghcljPBnzbALRyk JyOHiSgeC58VQCEVWRSfXjVVFWdIEa2x/+QTvEYbMN3AXF6NJeSZspYwG9u7pd3toAWApu2gWXfQ HHwD8QB8AAC020GzXkO7WQPtdkB9DxRuz0fNwrbSjiPHLmJKWujnPufg733vA/jQh5wYjK8F9OB3 fe0EYPzP1dXpfHwd4Le+NeugQ6rTkuAtGQU0pihqdYYAehQJlGMewZvwOVTawDS+x0QUMZEKOlL8 TMGYETpGbYi29FtJPwSN4jAcAB/PH6NU4MP/DfLHKFpZRNnUmGifEAA85IURGO5EinkuFdJNjR/m qlmfYdI0jN7F4bRBZIuLFmYKsnDwl2wPNfzGr0IzNlnqcCxNMpgsQYCGAP7mpx7R//DmkhK6QOCy zAt/WSCXWW8lwleiN8hNI5Xe0yCPSiOL1k6Tpn0+69xyPle5E51qAZFM9yxs83OMFMgGlO1+By0R 7LsVtJcXsFs524jdxcbVDh7M5puLDeyfPof91RXsnj0/Rcm8nULfj9srN5W2RC2UA0FEB4Gr1XBE DnCyevAw6AHQ20P4SOCf/dl88CcNsq0gkgmaEuwBZNToQYVUUTAog6I90hgDaO5xxWmJ0sgvjhIC B0RRWDec4wAFrllrCrDbZnDQV3pxqtf7ZVKdeB2NIkAjGKTKj9tCVUuTvYbgxxHDPwlegaNhCp2E X+LHpwjsUpuFiqTWpo0tKpgU1axmLEwXpYmXXFraBf8WCFyWivD37a+Qvd6vwPah9HMpGMv5vAp9 OU+ggsgiGYVypoBfarOW48lND2RhrkIPUNJVTPYstKRJWs8psSJzLdrdFqDtALsGmuYCmlUHTdvC tmmO61FPQH0Pbd/D3h+bN5b3SqKp+6WGf6B2P3z+864O8IMfBPjAB1wt4GrlPuPr/K6uHOx5APQm 8f4cZvIEjOFMApowNdTsG4h5aaNWUREO0LQUTg3QzINk5nhYVVK0A6pkxWF3ppfbBVE2gIcogzqG HOLaP1YGReZ1AbpIAE7LdSii+hg+MKNMT6n7o1IQLHnuzyhFiWgs2Zf0xADGCp9CTWD4/sCiQ4M7 kiP2oTOV/4lFauIM3sFnIH2cc/fR6i6UNiehq1mM4xcIXJZq4PdVUoGgFOysuaNJP8AZTYVy0k+K av5K/AkF5dBzLjkpqFUiiLmOt9bjrQDP6nYn5i8J0OWjgrBaA646aF55CbBzgjHoBVV6Zx3Rb116 6FFd0xephAAVy8dxIGiF5Jzl8vIEgGEa6PW1++1VTj28+n1tt6fX5oK/GEpgaBKfTUkJ0GSjgBmm 65jzTEP7sQHwqZwq1GWkEKLxIGKIUzeiiOhY2wUFuJZq/Kakfx4jMDC2MSDO+zDDoD73FrBEB1Xw m7Xfmb5eKPgDHBQlHvHHyF34w9T+DSoBYOwB2PTOBjCuBVRtKxKQKP0/JYJnFYdR01krg2JuoHdR CV0gcFmmwF8OAE55oFcxjIcZo4A56aQlbWD0J5zjWsy5lNpR5IAbWTWsa0BMTggzJaBjENhRltX2 FnbdytU/dB20Fxughw+cbyAAgLeQuL52pvJtewIoD1xWf71SZVDOO/Czn3V2EA8euPe7zh2Pt4Ag csd4e3uKBj554kRhQguMGWoBvahAyui9Mah/5kYB0QIQYIsCSrCmGrtzx8H5BaKtHUf7Y/4O6wHj bWtQaYmokgSoaghyHM1LpW7Gcz5cG2EIf4kLL553JPoSR6+K6/Tu6/C4dtlBzi5y+qqEnQSlJghi aAtrM5V7ZXDZDuby4SQCJeZPa6t95giRZn9eeVMzjl88AxcIXJZS8PNfJUnt0GTvMAFYSj0FszqZ jNTP4o5sSk9S+Qk8+RgnbjvHAykn1TIJdgPdtonnLRx4DuzWSDn1D8vdFjoi2F2sYbdewfbiAtrL S2guL6DZbGC3XkPz7BnsV1ewv76B3tfUhRG27XbYJlI0sEZa6Gc/C/DokfMF/MhHXBQw6TnofwAA IABJREFUiF7C7a1L/3z27PRzfT30PZw5CshwgQk6pPW1fUnG8JiI9Eyp+2O3lQgNkQKpEpRqcJnl PWcAlRzgHgiogAz7Vq/GeJtiJDQSBCm9htboJjG1dyORmQk3j0ko9JyQaXBWkoYtIzXPGqmqWl1g lOKpCcjk6OgMIMhoV2RKA41hcsJ4YypfA3PfEdMFNwCwh2VZIHBZMsEvNUA2AqBYCW3YT1GKKenq oUlPwAxIMkcTwb7eVFN4qritc3fYWd6HNYb5nL9fZk3blG4uJ4XWuItuewvQrQAuNoANArbOS7A5 iMc0m2fQPH8O++cd7K87oNtbB1weAH1UMM5rKgHB1Gj9lVcAPvrRYR1gmK663bpju752EPj0qYsE +uPd7QC++c3ZADBb7RPSUTwNCnOEVVTgStTeIcpQJgEbYiZ0ThjwI6MSOgJl7UCMeZojRUzjaUwR BBpEAtGQ1ovlj1RMnJvEZ3HtH0XbCYVDsmwiSkCQJvQXhbCYBI+SqGJKICaEQeS/z1Z74VEtJqUh KnOqc05WzzouMt4K/pp98fVH9NeXlNAFApfFAH/iIJQyUvGo3C7C9BQpSQudC2aspu80337vQypo 9eNJFDWIbZtTDFFo/TB5lJGI9Fn2xbzd7baAXQe4XgM2DTRdB81m7RRDLzawe7KBZr0GfPIUdkAu bXS/d6mYbGFLYX2gtO7nPudqAN/3vqEvoE//9Kbw2+0J9kIw9VHCGQAQIA12SXgBexQvJ8IEhu1K KaApAORSSOMNaamgGiRy8BanfqbsJ7g2ToIfA+Ds9VUuMuvRB0ZhG87ewSrEYi0wNDKXFFk91hqy DvBMLWK03iRBmIlzd6bwUEEkL1l2lwjLceI5pto1acc4tB8BD5JGkjLbTgSKoCNl0DOZw5duY/Q7 SKVFOIumzbIsEPgCgd93vkr51gq5AAhQrCBauk7uoHySmEypcXwJQL1Aj6+agiEK1/FQJvRaWRFG qniu02r9prR9u3OiMditgdY9tHDpgHCzAexWgG1z/My+aaBvWwdfYUqorxGU4LSkPvBznwN4//vd zwc+4OoAu8Ojfr8/2T/4Y/G2EF4R9PraQeCMAAgcMBiigBZ4Y8EPhfTTDNGPmmmhFuaYajkR1wKK 546yJYcl1Xbw6CA3z1EyIWA6dxyngqLyOEMFOMN0tloX2ZL6yfJNjpk8RDYelCDo3L6ywC/QX3si 5uOhskvs3VfS62vCKgpUWdM3B2mqOYkiAeyHYG/pqkeHbSAqBGMqagk0RnC7AN4Cgctihr/HZI9Y FcBbyfpUyfB7qqfglFTP4nOYsU4wV0Rmyvqm3qgQgmpDZc4+2P1l1rdm1TkWqHAm2mS9uwXYrAA2 K9hdbGB7dQ3YNgcV0Q6aVQe7VedqBbsOiKsVDGFQAkFrfSAiwGYD8NJL7v+2HUYafTrofj9M+/TH 4N+bi6M5sMuMUGk+gkVwoTCAZCuQMoC3gJrmDageU+S1BwJYSydH9mYftqfBliO+yKrBOoKqFJqa I9WAK7vGE2WKpIK2Eu0hqAASQbCPyN3I1IlCQ27gKPOfAe9akBJfJ4wtR3wbNADUgyjkMti40fhv UGOY0SYlBvXnqgtMjZ44KIyvd7OkhC4Q+J4Ev1JoKwHAnNdN8GSpH6ykKFrjyZWjOkol7T81skbT zo8b2OfWIdYA2HMvgylVsntFUsb1LI1CJpb17hb27Qqoa4EuLtxg1tcLrlYHk/kNYPcU9m0Dfahb 75c4Kph7fIgAv/ALTg30tdcAXn3V1QL6KKD3A/RRQA+jXhXURwFvbgDefHNeAJTSBiEvCigBCgeP qWOwwmEJ5GULgwRWBjHoWY+JS6mMvQ05eMvyCtTep9MgGVOTAYrvX059oDVqXHLf5sLW4C1B9Mck 9FIKdFO9A2co0c4FEtROCQu6r1gkRtsnGpuHDN2XUqNYt++c/jHpPCw1hABLxHCBwAX+bJClvj4T AEJh5JD7aHaa5wQT+qyBu/EpdA61Umtz3CcripxomwQkpdHEJIcbhGbYNMqJ3ofa+QU9ZrvbQgsA 7WoFu/YBYNsCosuNo/0eaLeD9nYDtNsD7XugGOC8Xx9XHxj+Dq8T19avvOLgD+CUmxfWIW63Lv3z 7bcd+L39thOD8QAYpqvOAIHxIF6LLmmjcO0zJVFADhqzbCGwsC24Wr/MCJQkXIOZXBBDtZmIIj8+ ACbaF0UHuYF0PAiXjOI1k/hsdkUoF1NB5nFCMrjnXozJAT2aef1K/SUq/Fv72UNaBUEByaQ+oolZ j85RE5lJeQaeccgSnxtnF7EsCwS++8HPMlDPVf6cDQDBphZqOU7LtmuClTkqSApIVEiBLYnATTH0 mbPGTcvnMF1fYxvUtHOQlEuzopoGp95kiqquoNrtti76drlxaaGrFTSbDTSbNexWq4PRfOPqBP0o Oa4T5NJDU8vnP++sIF55xUUBN5vTSHS3cxE//+Pr/mJBGCKAb397XgBEAaIgAXpgq+VDAegA9Chg JvNkAa+kJpozOE7ZRLCRzSiyx6mCjlgI5fayPCpDgAUJxrl60ATgce1RFPGL9xOdA844gsUEqB/3 H9eVQcJY/j57EE7o3qdsTKoRjO/xpgHoCZyjPDCiNGSEP0yv74/n+EhHvmtJ+Q7WbEirSqilPhDB iTT1S0roAoEL/BVGd2YDQOPTgQrgLTctVAM3FjqNB1SqTlmVs4T2s1hO1EynTcGLRQKuuFYuw3w+ ByqrTw1Lgjc51Cw8WLdOPbRZr6BpW2g3K2gvNtA+eADtSw+he/IUtt99G7bvPIH9s+dj86xUHWD8 9y/8glMCfe0197Nen2oBd7uTB6AHQJ8K+vy5iwL69NCvf322gZ43hm+CgX8DukWENKLnon6cVUQO tKmAFYGcFfLQuD/JmgIgkQqaSkWM0kpVWMipUxOUQVNpvCX1k9JxEHMdUkG9kYdg5jEVP4KVyG5O 1ieXYnrndBaZA5Ym8Ywezca2ReEmGwjoKCLqFPVNbHSO67/i70DYfTHCMJLYiofDUC20qKsrnIsu zfo9tjHK3fWyLBD47gI/01OtIMKnvpe5vVLYs0II1VT/hLS9hAqlGe1Z0i7nTsesBTlixMxwnqX1 hmL6ZUYkMKeBStNPa/s6KsfR7nbQAgB0h5rA1kUAAQGg76Hf7oAOEb89opuSbhoXFfTCLD4iyKWD hvu7vHRCMOv1Yeet25ZPMfWf8f97f8DwvZnud07IJQVtwAzsxXRRBfakmjgOJCXAtAxupFpAyeog CSrARzxNtYGotI0hysdBkSgKg4IADfLXECasawG8GJBZIZoM0IwfHaZ6sdI8ZO1mSNlGzAGFFYRI Uo9ma6JM6k1LAgjSYSaqD44vqFsd2Dgw5x8KwCAcooeBgqg1yWW2HM6ZIoFFYHj4vUQDFwh898Af UF4kwwwgBXrJWfuhsmheaa+QhLgpj5vSusHCYxCfjlOFaApEaI7Hktl+tSAsmZ5p+XviseYK7nB/ J2v7IF1vmDlpsN7ewq5bwQ5boIsN0P7hYQSBgE1zMJvvYHfVAV3fOIDzip3eX/AoEMREYz//eZf+ +dprLhq42Zz8CH0aqI8CxumgYRTwG9+YFQJjEEvW9KEMgBxUWY3eUbn91EGkBHOp1FS0MQO3LllN 1oW6QlWEhGsjZD6LZdebU/+csm4KCgd+hFiuZ1N0f0xkvKx15vIJrEUCeum0JdOyyvFolhGsuGii PjD8PlBoSh+AIac6Oqmqw6AkOgdTiuciHE58reGgEjqfxvSyLBB4DvDLsSHIFX5JPejOmRbKRfMs KoyT0kBL/jf2EFVUMhWgM7Gd8qQWGdCSsppjIJQJYbmTBFPqHWuBqJkCS+lxohm9f9DuttABwO5i A+16DbvLS9g+fADtwwfQvn0Ju3eeQPP0KeyePof91dUwKuhFY/b7cZroL/6ii/759E8IRtT7vUsD 9cbwYSqoTwfljOsrDyZiqEiN9a2KoZAArJwooFQjWFLPl0oTxQyosKaCxu3B1gpqhvFoFJcxiMJw 6XUpo/h40Jy8ltGNgAZFUYC0Emk1iIojVIyFgQb4WtqoCpBTlETnhMOJ7FMMohzcKTsSrWjjezSw nMg5/uwuLLdNZq4LLH3+L8sCge8x+IMJgjEzAqD5s4bzPDsAThCamap4ViICg9EIJzcaOyktFetB svWzEgBRRkPXAta5hiOTClzoCIPQrQA2a6C+d0qh2y302y20ux3Qfg9AvZtBlURj/LH89E+7vy8u nBjMo0fDKKBPKd3v3Taurx0UPnnifp4/d69dXwN861uztiAHVSm4KxlgcGmn2mdS9XsEadsHrNVG OFZNTUGj5s6AE65VuJFUPWD41RhYTQgCLCLgY54pPQYDckubYO7NpKzHtm/pjWC9WNL1qHXx5wY/ 4/zlqPuVfsISatDnUzGsC4zr7lCZhIjq/LjXVRN6rYIBTnWAg9/xRytFA2umfXJCMZJS6JISukDg iwF+1oF6ciBNeYbptQFwlkjhuXuMzDrDYpP5grTQAeBo6alnvqmz6vegTlooTTh5roerroZaGSqz DO/le67b3ro6wQcX0LSNE4+52MDu8gKadzaw2zyD5tlz2D2/Arq+PiioNCdzea8e+vLLAB/4gIO/ hw9P6wEMUz+fPz/9hKmgZ4gCFomlgNE3EO01ZGo9oqJWagUTNP6uxQ25qaAovM+CJY63O6ir0/4H vf4PrWFgCdQZuCTiHysoPQ1I2H4GCGLNCCIMRUxGCqEWvz+s85ic+oU/ipsE243TMo1BufR3BRNd nhGeABQz9jiqGDd5JGCDsTdmIPZCFSJ057SEECE083iXZYHAewx/meA3CfAKP5tb/zcFbovFYjI/ kxvlK7K2YD5YnF5qhP/7BnuTKDAzKplrknSW5jIAZo1etUA0Z5AeulrBdrOG9uICmosLaFYr2B5g bkfk/ASJHPj5KN8v/uLJD/DhQycK4y0hvPCLjwZ6FdAQAL1X4M0NwHe+M+sVGMABpuHOWnvFZfRx HoOlfyNMjAIyQh6s2AuzLckCIyWGIwIujoE3tU1R8ROV68UBJBT6PqKTm2dFXcKvXDNsR+66SHWl mHiUIfM1R6MoDJE7/mJwY+w9zANrq2HbHBk1BaborGk5ZnTXeNR8GQ17wqihtMOwnamkgsAATWKq KRkbpEL3nrJ3qBopzG3PZVkg8Czgl3tHTkmrtG5jzvRPmvD5KmqhuT0GZYJcBf8/DfTM0GV2qa8M dLV6eCNAiTBlkT9LtREVH2JWFDFXyTRVZmgRm5EewLtb2Lcr2Dy4hKZrjx6C2HXHn33XwT40cvdG 8F3nUkG9J2DTOFD0EBhG/25vT+Iwz545OOz72QCwNArIwoNBIEYdnKMCfIk6spwgS0pRdEoKX8pb Uau7wwQommr/MJM1gtRFcRMJo3e03GBCTaDlYmGmRcVgF/GJKydafF/RGCoRMwN/ZCDdM/Y45rq2 1MYKolOalYRaF5jYV+yLGaeaImXU8lnXP9MSn4f11llSQhcIvEfwV/iNmr0usGJkMAsKqd75W+wi KOd/yM4ENYPd3I9Vs8BMzXsvg5K048s6Hqm3rGG9IMi3mbReKIM1Lecv5C9l5ebYQHqz28KuWwGt VgAPH4BTDW2PPoO79Rqa589h9/QZ0O0twI/9mAO/l15yEBiGSbZbgKdPT1YQocKoTyP1qqHeHmIm ALRGAZvgdsrV6tAAZ0pEkK3RS/yWwDPlrxcOJDNKw0YfGInDKJYC2SAhNBQL5ZgBwJo9BBrurxTg 5t5AiWtqJUZKgPmge8BEbaeiEpM0kS/p+mYOFXEgS9L9lgOCXGQuNmdnPj9SEU1dX27YU6gfVty8 E1RCc6KBqfW0ukBrMHpZFgisCH5fJdUZdArQ5a5XWjM4J+iZX68U8csGvAkm85OEZApulnP5CU7x 86OpXQLTg+UqpmbDXOEHc7g217RJ6rWrXPY4PXQN3XoN28sL2D18ANuXHkD78Ans3nkK2//vLYAf /3FnA/G+951qATcbt6kQ7LwP4PW1iwY+e3b68fYT3/727M/kVBRQUwydEgU0AV+BmXz5BzJ4AnVA tB43AW9lAYl6QJQujiV9kakZTE4WYJ79AmXcX9LrZFQvnXrdKYjuQAQlk7oFMNQKvsCLGYg4U/bS 7yOORYdI+X6O7klKiMQIMHh8LZ4DFSB1TpVQqrOZ42cbAOhxSQldIHBO8Pv2VyfIRmY+PUqiYzkA OLn+r+B1iz3E5PO2guaEp9XUHjUJURMdb3PuM0tqo8XLzjL9WAsmxX0ZImq55841Qqloy5TRSY6f oHGb3W4HHRF0lxvYbtbQPbiE7YMHsH3wAJ5945tu2217soXwdYBh7Z+v+Qu9BsMo4IxqoFytmBYF lD6fsy/1f7RDYTwg1EzerbWClqihJQqoRQzjurHRvjAB2swGzfV/BvN5iLz7ksbxGNUyonyPWeCQ YyWudjSPwGpP9unbPDKCBpBzqILO2Cezc8CHHy66lhXotEb5pNrAQ4EhGodwsUhMaDZPSnfFRtRq hPTmhm9IRwPjdX/19Uf0S0tK6AKB88HfDNCXtf4EuwjRly83pZPq1gDmvJYNhYn1C0y5xY2bt0X2 4zW9Z7wnpkZZaUotXSbUiIBjuFdNejSU2fgz9XDiuWb6EJpAfHz+3W4L1K2A1ivoLy/g//39PzhF AV99FeDBAweB8ajQC8hst66GMI4EngkAG5SFODilzlKzeAAlCphQmZRAyzLwzG0XK+xJnwEFHjUW GG2HU/MMARIVsRfpvsWMR3HC11GNCBtVOdF6DTETUKK2JKUdrFG62PcdoshQdrRvKgha5SjjkT/A QB3U17WNSqRnViZBBroGkxxcl6yc46g+z1KvCPxnimr9tDaZSedM3GZsrbEsCwS+UOBXWwnUuk6x X2BmVDALQCcMtLPrACFfHXRSG1KiFrCw2rx2tG+uxQS4kl535uPdEl2cwnI5GtW5dX6iCMyMKqIW OAz+Xu22sCKCx7/+OwA/8RMA738/wGuvDf0AvRjM7a2rBfTAF/6+uXERQQ+IMy1cJGgAhmCHNUyI laiiHSAL06RYwBQFROF14bc0PufSENHqj4jj440jr/HXIzflEoUDZ20ipPOIontoAS+SYWugAIpj f0EsvWkN97R0j1V2i8iDu0RNYdF+Kq4XVwwk6+eU7zhNOV4J7GjYFXKOOVw5YKh8yaVr+gmP44SA 1MXkDDmyJzFhFuN4bS5gIMJz2MiSErpA4B2B38yCMFPBRR0s54BeQQSSSo+joA5wKshkq4UmHmk5 dYT3CuImggZlXu9sP8XM1MxMl4o8IJXqBqlO++ee3wSAfPzF3ziN4L0aqF+8XcR2C/DOOyfj99vb UxQw9Au8vgZ4883ZATD28osBKmkUL20b5HRPC1jGn8lSLRUAUCVK+1tZqaDisRNPxxbbDdZXMCV3 mnhNvLaKGAtXIziYXJDaH8sjuRzQsunKtc0e49FzJv/V+0DdOa1awwAz1IX/NwDYD98nZg70aCcR TDSEUVepK2EDgdIQo0QgO/RaVJJotKjqOY3jc/uIJSV0gcAZ4W9uMRjjutXhLwV6GfuwRgXntJDI 3YY5d2MqVGUcx5yiMKW2B6lznzSLaIEqKj/R3JrG0nYRP2dR8RSUVkVV1Ern+uqrAD/4gy4N9KWX AFYrB4KrlXt/vz95Avb96f+4HvBMpvAavLHpnZBOA40H2rlRQA0ANZjgookEhbWCBm9AC/SJtYAM 8GHifxGWhaif+WbIoFtLbV6YJmmbiYC0h2PctVqhD23nMoBIiqJCWMZqcV1gqAw6igbekWiMCT4M dgOprFFtnxIwIXNPTSUmqf6NhAMJo5BnAbFaiq6QbxzPPVeWaOACgRXgj2aINt0x/BWBIeRFDM3r lkZCCyCxqBaO5rnGVdRDjeqlaj1g6T06sXcu6hkMkJQbdcwVp7mTKU2Dz2CF+/Pxr/w6wF/6SwAf /KAzhn/5ZecR2HUnMZibG5cG6qOAXCTQp4TOEAVUo3qZUbOUYmVuFLCGv58EiBrQScIsltsqBQBi E6Le5iZhFCmdFMefEY3krQcet0/s+weyIA0muulROp7h4s/BSzkcVuIbeC8Ij+p2VamSu+zHvbGO zVSvaHz52DNEirDiseEQ8Ek7h9wGKNSzQw2uM7wMl/rBBQIL4G8up8w5agJhJuXMxP4pU8Aky0je 8FmLXH6NXiEbGqnevVICZuZE+oKo1qSom7Z/yPPgs/xtqrGbEOWTnHynpGnOWfMn9YzKOo+/+BsA P/RDLvrXti71Mwzp+Mie//FRwN1ubA0xEwCqQAinOkBLFFASjEkNuiwKoTHYWKOAEiRiQbtYoFH9 DDKwmHAht5rTo8HLDnD8jZf86TTPQNBgMViBDNc6Benma6WO5PnXBodLuTsUeG4KNc6hDFra1cxU dj9KTpH2F0NKKm2SE5AxnlcSoqR9o21eMwlqxnOb+7mf8gwMu+3FOH6BwCH8fesrM92id2gSb12n WvSv0utWFdRzAN1UBVea4EI/99TVpNo77cluzBmWIGqWvyuNIKrZXRi62yopqRXur1decQqgl5dO DfTy0gGhP6fb21MtoK/5u7lxr+92pzTQmcRgROsAYUBuHZ0j8DWEwADdaHMKAHHiKLllb1mgBxki Msifh3SMSe9DHP9vMa3nLB/Y9NAUmaEcMUxedIFtTObTuemgFb4DJv9E5v6UoriUoRCqsl+OW7el O7GIIUOgDoqn6JZpzswKkdxsBCVWzTWeF4ZyoXhMEuIUuAyfRTS34mYFvbspuwyhsKFDLeayLBBY H/4mRBDnSDEsAbnk4HFG0LNCGBV8tkbEjiYaGFkFYUrfU9vJmpNhfCRTbrKMst1ZDOgrff+y/fYm 1A1awDyrHcp73sdf/A2AT3/aAeCDBy4a+PChSwMFOKmB3t6e/vdRQG8Sf3U1uyVECGSWCF/OOtzY 1RoF1EArJ/pmhrkC2jBqgogHSzBWW7V+RVAgyVR6qAp+JWFb6V5CWbzH4i05gFc0TGBYJynQfCrV b4ZJgb57YiovPva4Ij4Qav9SIi3MNsWodAPQ9AcoObSR1rUO0jtTXbvVakP77B36BeZyc7zukgK6 QOCM8FcrXTRjOzUhschMvpIyaEnkUd1XybWgOqmjOTV8d/1EEgGU7LBoup8q6kGbIKpA4ChnkmFy xDQDDi2CMFN8BiWlVg4A33jD1f+98spJDCZcvDH8s2dD5c8wErjf34kYzAg0rANsaeAFsnDMaHNY fi6ap2AKFnOjgFAAoyBsc9BOaIAiCfgs5462GtDRvZAAxpR5/MAfMBZ/QeN2DHN0iIX3qeURHUAE hFG+TE4bicJYWU+LCla2hZgbVrjIMKlFbPZjs0QkE5moI7uIVB0fBgqmJv6b0CVVA0Oh1lI6/via LSmh7zEILAe/yvWBs5jE14C/UtDL2ddEERnzJjPVPk2wOtUmYgKUz3mf1ShplCKJJUI02eeQq1Et 9F7ZNYETrsckKLKoiE6AQz8KffllpwB6eel+Li5OUcD93v08eXISfQl9AWMw/Pa3ZwNAyRRejQKi LVJoqe9KRQGtKZnaNkXwKgAFMmwfBUuN0XEgPyBF5UQ5tVU2MohCmi8xURDUAZ0kwJo40aAOxokH ZfOkBCWIIwPWqrGkQn2hSihY6jvveDmCUXDcOfxGzA97jwXtI547I3ISfh9IuxeY51QcrSSIDlI5 wQEwBr9Dy4iSgOK5aJHlcBymuy4poe8xCLTBH834cHqB6wK194o+Y+0QKtpIzJUGOklBcybFUKrs ymoFlyltMfmYp2i4WQpMLPV4lHfM91iu7PEXfwPge7/Xnd9mc6oF9HWAoQWEr/WLbSG229mjgAC6 KXzNVDkEvkaQG7CltiP+xrSCaZEJOfcS8jV8GhyOjgPlqGLK+1ACBrSwB8pCPuJ1kwziFfN4ZAbU iBn3CRc5NByn9XqSBotQeL9k8p/tzfMvd/FoRWEiYGD+bqxljDfEgWU4EaKpZMY1iUgTvd4FldCp noETe+nRtbdmsy7RwHcpBH7hm39Kd/oIonv0maLUz0IAnFwXmBNxLDXirrCdXKuOnJo+87pUx8qh RE20Ro/JKnca0y1nT/zPjdpZRHJmFq2xXitFNfXxF3/DWUF89KMAjx45CHz55RMA+hRQH/0Lf66u XBrozY2DQP/3d75TH/wgMxUQ6kQBNcayRAFzBpOWusSULURVa4AJH5KsIUAATFbARCNLY31gWOvX oF5jOAJPTJxXAYAlRWruE1VFvoJqSiiVRV3PQmpkv1+nSqSNImmGjQxSHSHyeRRuD5M6KLMie9xK tK+015qjpFBSHk1VloTf6YYA9gt/vbsg8O7g71zgVwv+oFw0hrLzQu3r5qSikrGtrMAlvjZB4TMb pixP6YnwUywyM4G8zD6EE0FpisCMqN55hlFH1scnblObOHjtNYAf+AGA97/f/f3gwXDdOAoY20L4 KODt7fxRwAKhl5zoIAd0WsSsOAqIefBmXhfzoTEGVnVfqHwWhfo/oyfjwPRcOB5EJgpogENUVjP7 DsL0tFystVIN2KLAPB2HyqAS6M0zs1DnkRqqmobdiTkKlgP0ZBQuyUhMYQEvs2vkooqxYX1YEzpS B62YrTK7tkxBhHNZ3kUQeF7wq3CnEc2378mqodo+Ct6bbCQPRiGYEqGXUu/BHKjMPC6VLyfUhlKF +bvwCV1iQD8bDUBajNTk1zfBM7Bm9yO181wkdTi3x1/6Awd/iK72b712kcC2dev4KKA3fQ+jgbE1 xHYL8PWvz3KpxUG5EvHjwCUVGUwNALmo4ZQooNm2IffzKQA0gi0yqaDIAF8qFVSDO664kEsFHQ0A wW4UH4uh5FFeYiKB2ZcUwZTmOxGjbgOH0aC4TcSUWILpniOZkw9nyQqlGZ6zU0jvDW+bAAAgAElE QVTECmTS/cvAuHSeVo/CUORlBIWU2Kbkd2htr6k2GDNcwrAWMKz88vfrkhL6gkLgF978E5osyQZz Tx9M3P7Z6gJLawZzga5GGqkFniwwdgaYoorb04Cw2AokY3+5mzG7zc6UZprb29C5qhYS0DmH7FoC ah//6m864PvQh1wE8KWX3E/TuHV3Owd4Xv3TR/v8a14ExgPhvn6STUroBUCurSqJBnJqoCyI4jRA w6mNUqltc4BVPRRMgCBFghwgt6sUQVTJAwu8IxP0gkrtoHY9LO2pTT7kiNJAAk4pthcIPeLApuXC GXKflwDrPIZHXRPKaZdZN79CJKYU0zCipQDZqIuO7htSxF5yukgxJfScE5UT2DFlco/3uDZ/gUAN /NiB6n26klPAL/ezM4vCVIv+QaWoYKU6wBJBmbmN5LNqAyvdp2aQLDhvMj6Os30BJ7aFlH466NjO ENGcIy1VqfdLLj/2YwDf8z0A73ufqwPUjtunfe52J6VQbwrvo4ZnGBRoYCelhsaDAC0KyIFK6j0p Cqh5+xWZvGPm55C3iZDG76IKKObbYUjWEJhyoA8ObJD+ydBjCGrHbeMY4jBF/CmqyiUz4f2iesBC yBoptmYwtboCF60N35oKhpOzrqYTRU4qo+ivmFNkyMC6dEBovD8IZKBUE2EsUT6uCy2JOM4EgtrS wFIT+MJA4Aj+7t1yrohfDXirAIfVIn0VIHIq3NUa6OdCovpEyzShN8Njhbo3CZZKgKcIaDSgzNyn pT1qRipzzzX374Ju8vGv/qaLACK6yF/XuRTQMAp4e+sifk+fntI9/Ws+Cuh/druziMGElyepFplp sD1SuJTULzPFY+7bkmKwnG0AyPWBXLuNrl9ozo66qicrCgT6etzFZScKkIdGogl2DxxgW2BSmN2I jytu56yo3BRQw/t/j9d6LKcutbkuMANSJbAkzB82WDmU7e6Emrs5AmlTBGIGUAuyOuhgDuNwvktK 6D2EwC+8+WW6v4+XqZYSd6UGatzOWQAwRzCmNAJYS4ExNypYolJayIDnetqmjs0qHGPdL1VsECk1 dVId4NT2nwZv00A6AMDNBuATn3BpoN4Y/pgnRkMbCB/liyOB4fszeAKKwFcwhk7BY27kLwYcLbWS i8wVRQGV32CMAnJegDmQiMgDnwqUkvcfB+nIQ7jY8AqEDTjHf8Wb8ZMFreCGxskKLkI5F8mfY8hT wyPwnH1ZUM+WEg4pARzJ0iF1mUwRsURtoHTvTi1zjMvla5ZI3mX2JUbQ96JM1L0nIfAL3/gyPz2P JZeLxpXllsfAHHcqzWn6XSHyVwp/tQBw6rqlEb+500At55TTtqWpoTmfs6ZilkDNVPAsipqfo5fB 8ujvXBMaEkj7Y33llaEYzGYzfN+LwVxfn0zgnz4dW0N4YZg335yl8xbTPS0gh7LPn4Uh2DRSBuK0 cdzcA/8UOFo3N6U2UFUJ5W5Lxchc0zRhr7Mh8sbaiBiiiUllIG4Azg0yM1I8c6KOOPH2CQFOUwi1 Mt69rBUUnsGat51FIXSQZplBYZJYVR/dP1ptoKgiqoGqAKMIvFZaEn4p0YZ3MAegZawic7mWlNB7 BIFD+Et940oHQ+e8U89UG1gj8ncuAJwrWmiJxJ0rDXTU3pSnKEo585WFgFoKtjTlPoR52n8OoCxJ WZXMiizFECaA1Lz/DIqn0Xk//lu/5dJAP/QhZwvx8KGDwOYQIul7F+27vgZ48uQEepIozDe/OSsA WjwBhTG6CAQcFMaQaRlsaxBlMYafGgWcCgraOF2sDQRbJDYUd2H/F8BRixYSgZj+KN4fnOegUtMW Q+fofjz8NHFNIij1h0YQrGryTsPzDUVhSv38BtYRys1zH/iv1HKgSrlExvdzBJShmEwqp9EAaylA Mp/7PQI+65upw20QYL+khN7p0gAA/PLrP/ouaHw6pVDRzJ9N+nAZt6Vup/C9qameGrRR6hioTAjG AlWmaGONXqiAAeeIWBYDnBWisHKDFPQoJaNmtv1h4sbmaAdi2/rx3/5tgFdfdWmgH/rQqQbQjwx9 HeDtrfvbp4T6130qqE8BnamzT/n9qZBobHrM+L8kCggT1zF/iARA44AU7dAKwNtCcB/gxF6kCC5w MIyJVFDmNQm6xHpAAQxTEwjI3HQWr8bkhAUJI/Mcz8H7Zixf4zFdazuG71IoJMTeb7W+o8LzDRKT OqlIMgo/gPq2UbuPLKq6yB+fKWmvcnTbMjlXMmm4LGeEwBcLBCmCthLwK/ks2UyYyZoeSgUAqbwn HRvNpAJataNIROzyC9kywanSE2/yk5QqNCZOh8VUaGLWnqQkHw4Lzl+iDcz7Gyx/HwDwb/2WSwH9 +Mdd/d9mA3Bx4XwBwzRQHwV8+nTsA3iGKGDO5eEgsUHXsVhAMTcKaInise9x4JMCNOMApxQERimZ GV8vqc5NhLZE7V/ycYC2Qan4hCHhHDBtA3Hs2oIfgsT5TBwMm9Q8wy6XYHqylPa+VUCa+/uOpf1o pik5i0ARgLGWGfm6UhH0MucryXgfhgJNUkr3RC2heS6G4RGm2v0sy91DoAfBX379R/H0xC19bE2A OxHUAgCaFOmjMml7qgWIBYCXOoZaqZ5kTPcsThUFW/QwtWlTFDATCqlQ6ZPdt/W7MoP9BJHtQU8Z 58OuR/mPh5JeaEovYR2dW5RNp6av+uNZrZwNxMOH7ufi4gSAXuTFC74AnKKAu939jAKCPosuec2V RgEBZDEY1N4ThG0skUsEZUAmqTQazeGTtz0aDdvjCB8aB+ackijK94X8gj5BwAnGUNzrkz7YH7U7 ynCcAmdTanMORGLho3wOB6L7vhiVOpNiQdEDS43Kpb4PNL4nSSO4TIopvs1KJ5ix3uVJvZd6hqYO pTms8MXXHy3OgXcNgUcY/KEfQ3fzayBGlX8g2u4EmKQ4WjhhO6mavMlpnwYQyk0LJapjGWFN8ibK h7C5wEcCzZz3a+7bOgVYlX5mGlGgESJzz8nqRYgFgDcFHMXoX/5xPP7bvw3wgQ8AfPKTLgLYdaca QN8GYRTw2bOT+IsUCfzWt+aDQEynfTaMfYMm+CIpdHLG8BxnYMGtWmq7YPUFrH3bmc6XWTeluseB IuZ+ZdEgCJSoB5QmFpID62iwLz3uBl3RYRiA0XvhUEPMaDFMNte4B2jCCpScgCzoC6juswRASFlU rl98GapRDBaASk6oUXsL+e8tGLoYUCahctp3ThDMen8J/91/CDyC4IuycFE+qrSdIqizDpCN+yoB xywANKaRThF44dpsLsGY3MdSDsDSjMB45tMuG3Xk9hiYhr1z5KkkBrfzbBdPAPjaa84Q/uWXXS3g +953igL66N9+P4z0ha+H1hB9f/7bBRVWBjnl0Bp9EdeFyMcO0nVq0uBJAzm0AiEYrB0wva4EfbEx u5bqmhpASrWJlvRQ0dydIk6K/MHM9YAFI0nTWDxlf5F7HDXojobARiC3swWQZus27kMcBgXAMaQN i10uAZ8/HG6zMdY+aymo8fcHx/CHjJiR+P1OPZtwcvPOfitYJ82aw88SDbxHEHi/QTCKItYCyMlQ xxyfut+Cz1NBXWAJAE5t0yqfozq2ETnHk4oSzjWNpZ6X1YS+MLfILHVoqYsraXvjPq2TI6ZtnYMC g+XRIweCmw3A5eWwDtDD3m7nIn3Png3tH+JI4NVVdU/AVMSvCTrqJlHflzQRFwZYqSuDiUF/cbRO qwU0CBhpdYeWuQdE2wBKVAmNjN5Bi/hxaZ9KKqgkRjOqnZpy0ylf1xIbCVQaXIxwY56okbbqHUxj mmUNqr9n3W04P684gqERdNTHf6zJhYb7JGdSIBIoGj0HMfP6GUWTkvd8rkBMBViUJpyS9dQoP/+X 5bxLl1rBg+AXvv7HZyR0qvLwkQFrps/V8BWs7mmYWUtY2zPQ+hoV6AtnwxS30cyoX47YylwRxan3 hwaLObWQk4c1uYI/oea2ZNtg3C5VEBsybPfxr30J4KMfBfjIR1wUcL0ep4F6CNxuAd555+QD6FNC /Y8Hwu98Z9ZbxWoKnxo7SQNugLRCn6QGmgV4liggzhcMKoEKcXCqbMqSNqtlM4vpZJg+Hm0gixos Kk7x5hTRxHUPPxbbAGDifrEKw/jPjKwzzrxoEUTkHmk47TEHlZ6esd0Fke1Rrj7+U3OBqVW0FSgS KmJALK5xjY3tY+ciJN5ZiL0/KdNWQush8W6v/bLcj6WxrvjLP/Rj6GoFC+r9BrJeGfWB1aCvhoqo YT1LrzGl9i9bnKICABJNjBYWyojOFRVU24fyj2mOqTaaQS2gdj3dVOVNcVvauc9QsDJ9JXF5/Gtf cmqgn/iEUwP1SqA+DdQbwl9dOT/AJ0/GaaBeEGa7df9XnjxQ6/4SNWCSYEvuzC6m0vYyIPRctYAW 9VFx20oUEQQAE9NcBUEYZD4Ye+kNHoEGq0w1emacHUDhPZH1BEXQXCjVFFWzvv6UNxFi7oKIT/mk uR7NxrrHWUb4eAZyKEknlu7xOG0UedsSMUpu9aiME22YCRo6Q9PVmPQq+S749v+VJSX0fkLgEQbf +HEsemjQue7UGkqgmYIvk5VDE4BXu2aw1LvP0haWY6cSKKzUG2oClwUMKbZ3ElBrWCxQ2bHWAAk0 WjFYo4zZPftcI5GJUO3rAH/tSw78Hj1yr11cALzyinst/L6EHoBXV7IgjF/nv/yXWTpv1kRcAETr 4Co3Cqj640Han84EdqAb1de6dVK+gAhjGXg0bhQTMJE1z4R8LV1KPZO4x3sBNOUMlLOukzSXbIgs moOPeKYnT410zFlG+zMCBRY8v0CHuOyNzdA0qIBTziSV9vc5LvMUkS6tj1mWFwACPQgWwWBt2Jvs F5gDakZoywE4KKzvSx5DwobC2k3QhHO3HrPFhL5W3eKsKZhYfixENpi0pnFy2yxpEzQOLRDP045S MQnV8FfMPJzUbjYbVwP4kY84c/gHD5wiaNeN4c//hGDoo4ChPcScUcCMGg2tlk+DRctgT/IQ1EBJ q50DBQCtAzTr79zBENcOo4gips8dJZjjrkdcP5h6TQEyi4LsaACOebVO6iyD8f4+PiJYXwoFcHPU QQvnp2p9o2muDU94ZiIKEyEFz1zVujbpW1MIeFPTuA33C6WGVWiYENImh7DuOZo/imUQiaVQsizn hcAQBuuz3blSRieYxU+2hIAy378UOCa3m/H6VOP5WjV+ULq/SWG9/NTTLGN2Mo4mKj6RS9rV7CV4 ByMOq0gNThx+FSguPP47v+uUQD/+cVcH+OCBSwPdbE6Q560gfMTv9nZY/8dFAv/rf52tKZP+gCmR ESMscnYQVisIzW8vlcaZ881Ay0Eogx7xOGv1lgWpoDmDU9RA3aL0yQy20aoQqkntK36PFs/Cuwg7 xF0mGeYitWnaWFyF7uLxq8xZ8gebB16cYm6s5gmW6J6SEoqKCXzqPlXvQxDWjc+BmSzDyt4Oc1tF qOtTegKMywzxnoFLSuj5lm7qBjwIfuFrf2QfVZ398k7YZ1Z0cOr2LJHDgm2XRAxrAllO+mmp32DW /ijP4D0XMNW0x9y00TKGLdqmWpWeevQb2nzqiRQVsksfil63bDtsn0FbnT78+P/6nVPtH6IDvwcP 3GsApwjgdntS+3z+/BQVvLk5eQGGP//tv9UFP2A8+kBJq2IAjk3pNMBikq+QPzaAgqgC5EUBi2oB DaCqAqIQBeTmOVI8Jg7ekIne4unOxYz7JR4Eq19lZP4Ov2to268KeGC0psgZyBqFYXxbemGYBiJL E80CItXw3PsES95cTleAup+muH5ck8nt0DDfyPl3DkRZmAgy2w0H6yPVKYage3GB+I8u0cDzLdXa +pff+HE0R/DONgVXoS7QvK5xPeuUYcn7ua/nGL8XK4HmKJBC2WeT1ykhtJIrxDIFVO/1/FZhamhV /78KlQg48dSxrH0e/53fdf5/H/84wPd9n6sHfPgQYLU69exhymf4/+3tyQdwt3PpoH6dGfrn1MBZ BUDLQB34qGIINSjAaNGgHcqjgDkWD5aBpvWe1JRKLb6Hlb4tbMqoFi2JL/xoXYgiOH6bURTEcuCj LE6Sk0woU+erZqocFjzmacY+IY4Q0qQNVfyoNLGBwvcIJzzbzLMK8nFaLS1zJqNUNdzU8ymzbbQJ jeoZConvhRYN5Ja/+aklGvhCQSAAwC//uZ+4gzkqSZF0wnZyQNG63UlwWFk1lCpoTNVOAbWIypTW Bk5NG86dQJgycSH9X/pe6amWpn/SjPSr1VGWHKsJCI1GVXRY9+FDZwb/6JFLBb28dHWA/jNeEdRH AJ8+dbYQb7/tfr/zjnvNewV+4xvzRQHRXk6T+hyALTpkgaWSKGAK4FKefNocxpQoJHsshTlWWn2e lAqKmPZiZNsey+fpQnhL2XaK9yDqYh9JkE1OXKXnvCYNZsh8WUWCnFjQcCfzjVUFPjHv2YE5zxvl oXe8l5qTGmiDztknVAfFzAkjUp4x4UQJgKAOiulJp6n+gFMgL/dhLwnEeB/adol4n2Xpam/Qg+AX /uwPqfrjpeYWq/vx5R7vRN9BovzPZkMhzO8PaG7TSv6D2f9P6GpTUdFaUR7MgK/JCp3JHQq7runf B2I6pn4MFcWEopydx3/391wU8JOfdEIwL7009AT0ALjdngzhnzxxqZ5haqhPBb25AXjzzVlm/aQI Xao2UAQS0AVJpCggCPsHBQCt4wyEDGsGmDArbqgFREW4AQ1efGgAiFQqKAeJbARGMo5PvS6oi3Kg J4WSkYsWZtYOxpMI2bWdEbyOvA1riDoXgBWWrvSipo9mphNqq6MxTEsIQ5VdwQtQVcS1VDMIqaVs mudh3TB7lLjPpdprYnomzbj+stztMlvqrS0qmOkdWAP8SiKFWZ+j6amdluhh6ljnAkCr798kG4rC iCJl53GW9cilkDGXMA4VTsdhhf3nRM5NPWWhiI10XojT2sLw+cd/9/dc9O8Tn3ARwAcPXApo151g MfT+C/3+fGTwTGmgU5pdqxmM37fsHxPb1raBBhgraSBTDV+FcbXlWmj1ghKII/c7dRwkpyaqghcw jkKqoAdjkBSvN5OWnBJ/gcREhfUiYJK8M96LrDs4gWOisZl9avLgPrObWaCICr4vyE8aQIlKqPIy KT+qKI2wXxQijsB9r0urHpC/f/Ec1zzxbAfj8y5uui8uAjEvLgSeQFADvZmnDKakiBaBXwVT+aTy ZwEcFtULGtVBierXyBWlgVqigpn7mRw1rAR6NCFNl0pSNyuNZjNhKg2Iwt81lEu1FFCUAfPxr/++ s4J43/tOHoBtewJALwRzfe3SP589c+meT564/30k0EcB/c83v1m9o7akgVqigJaO3hIFHAy8tCgd 6hA5yaB9YqPmRgFRqYlS62cEpU0uEEHMABylATXw1hDxObJ1fMy21S5dGhhb1wdjCh5Nf7xh7iPN 8MShiY/QkTJo5nlmt8eclRZMqD4H2tH6rMuc1Rqlewopy5Yumaujjb0xzSnMiQLBGs+yGt28dTep 7TV4ylpZlhcYAh0I/kX85T/3F89zLSfVBRZ+ljJUQcmw71zAS8GlqMJZEBm0dAE522WVMwuVRbON kqZYPpS0W+X9lXTD5vvrzCBZcqqWuj12iFoC0vzfj//X/+OkAPqhD7n0z647pYD6bYVpoL4OMLaA 8Omg/z97bx5k+3bV963Vt7tv39t3fJN4TxJISA9LQhOIJwQGM9jPNigm2MFxkEM55ZhUUaRe7HIV VSGVP2IxmACSuCA0ghgkMJMAgxj0ADuMTgiJqRi6YsdYaH4SoDfc+fY5O3/8et+zz/6tce/9O326 e++qU7fvOb953J+91vp+b95sDoAterwbBoGXDaGjjv5V2jcXGwjLoCAUg8z3Rlit7VCRthpMR1IS 2cFcpCU9V2j0iFT8JEXRIe615329Q7b9grgRu90K2GonKgAtOK0mKKDjOVfShVmHXmVwDJpQ0+Dy vYdoA0CsuP+ltHRuAEP7uM8/OgVmGjznJ++Yo5FtccXb1dvqIPAuDL64JQhOIAZTqiBaO50pdVQT hvHMFwrEO4INvNjoYUsRGWMdYFC2Yeq35crWh9MvEx33UwlIWtUcikyVgn9HrHmTDz44+AF+1mcN gjCXLg3RwNOnBxBMTd9jGmhM9Ux/i6qg8fcJzqZo5m2YhgIM1ibC2LkaGZ2DPQ0ThT57SRSw1ghe ulQ8UUDS/lJIAx2llFG1eUjDEAjzitFBWFbrHHVymfpAAOU3w/FEZwe6xjKiWBymhSpno8G20Hp7 QuXzs/L1hW0Wo59fzuqGq7sc5YwC6W0IzL2r+nM6Qd+TEorTnCrToJZ2ThAA3tNTQo8HBOogGHxG 8U0AshD8TCmdoUy8RQMvy9PA7QsoPeAZN9jQWIts1Ybz1VDnPpB1x+IwW5EyKBreaM7lmyHOWgeI /nmiH+DP/NJQA/ic5wzzbm0NkcBoB5FD3q1bQ/QvKn/GlNCoCBrTQ//kTyZD+pI0UATeDxAYoCMh S+iQTFlfp01njc5Yo4DNzhcK4x4of59vi1kww3psGeEXzfKAA0FvISl6f8NxBQoFsem2F1lO1Iyf tYKyBsLfh/GetdyHqFwXHqljNF5rALxCrfhxDiKMotZI/E1c4yNxJ1zBg9TzbCV+DML7qbdjDoER BK+8+HNxWv9ApQ6xCBgb2EHkkCj+rm2Td/0FtYaBA0DjS8ObiloEhQXG7uo0XsCtFaRxpAGvwiqi 9OmPDWr9xBwsYw/HaiVR9NBB2HvvLw9RwN3dQQk0egGeOrU8aQTBO3cGAHz66QH00lTQGAWczyeJ AsYUzQ1DjR/V4RkJekhnSvEURAUai6KAKMAayMbwU3SKTLWBKANl3oFC5/aFwHj+EfOh1BFHHvrV 2kHmxFOpoqKSqGfUIAjLc6aDYuWjsAVjhYqn1Eqe97XAWrp+x/giB23m7cOybTJPjuMuVZji2MPq 7SOqB+2Se/ZHezTw+EDgXRh8yasaX44tBWe8wOgQhZky+lf6m+t765eOVNRSg/kSj0BTWmvl26yK MSsuXHQAVAsvQc/mWgOnoQzM2OMgAWbBqvbe8JZBBObiRYB77x18AGMEMBeDidYPEfTi/sXU0HSa 27cB/vRPJwFA7QXLisE4jN4RbAKrSABOKQBqhvNaGqhaC2j8HjRLCCFq6k1XRMvfucyhskCUgA+F 844yXKrBddQjMpo3pasz7rUZqeyhpKqfI9/EkL0SjSIvI3EY6hGqzBxaPatLAUQY9bD6znGekW5R GA+1mY1Ux/vGKpkS94ElrXkylqsQiMGCZxcWzNtb27Z5mCuPIPjYH/+BV4VjguGxUCaf1cS6wLCs UiGXlaiJ1nzX0A6iBegUQWJLZxzPsir2V1rNFCI1ma8euy3SdEXnUNhR57r23vhWgBe/eFAD/bRP GwAwQuD29jBRKgJz8+bC9D1+oiLozZsLQLx9G+ADH5jsXW5JA6VetGTGlVTXAnR0x7JsaR8sEUDP clTQK9xOS39T8zs0p4Iyvn+ogBhn4cDVDmo7Gw7Myzak5XIHKvqbGcZrqI67JmIzVW8ywODNloJ2 3A8MIEZJzfYJU22+5hu4RvGWpdeCZTwDK9J3gwBXhV0URLlrh8mOBe11lfkFmnsMh2zaJ3ojcsfs YD/nYPA/7K26bazDRpiigs1TRwvTRK3zmNNIjctqCoChDQCGYFP4rAILaJfWWLJdlnRTT0pm05RN R15M8cs+lG2PK23VuvhDGg+Mq33+84fUz9Onh205dWrxye+JCIO3bw/gl6eBphHCxmmgmocfFdHZ QLv3n1nwJfv/Bui1h/nyrCPEWnQODACYd9qleay9cs5wfSQGQ6h0UlE6YICWtOEQLCAQFJ/roIwG pOvCZBbn48JVO8W8KlExiEfJnB5gOVIDQqmwsh/NRm2482Ct99Mer8GR0ONZrnf/8ldCIHz4HOqg VZU/AgCm9aNal85yPUtemmp1hcUqoiCleUItn/p32cEgU08JPcYQuABBQQymFQTU1ga2gpZaX8Eq AGyxrkprAitAWiN+raJ+BWMJTUFlKqBEz06UPvJDY2ArrfUzHhPz+UfY+/n3A+zsDAqgDzwwGMKf Pj2kgUZLiFQEJkYCb95cXJ+pYXyc9s6d5mmg4hlEpQMtdCI06wfNE9DSSbFGyqxwWDKEYUlVsprK a8sxTdMoBU9TBUWwwaJpfdxyalSBkDH0NlSAaEJH6XHmstNTWOdSEVdp0u15oocW11SJ6A36rh1z WqAi+mK5bk2po+hbp/RwHKWDAiHssg4whr5ry7NNh6Rb09tRgMABBD8Pr3z25zU61y0tJJyAaVmm aXkF84dScRhPR1mypaiBRSM8TgV41VAY6n0WW8Bjcfe3FkpbP82lWj80Tlf6xlnMuPfz7x/g73nP G9RAz54dgHB7exEFzFVAYxrorVsLJdBnnln8HVVCG6uBpn2MaLh790P8fzQvI+5C1fVJ9g6cdx0o UUMVtNAOYtIypChg67s0WKEP6c6nlAo6+j9m6w3Gu4yCRUM9IAl7Qq0jV3uqF0Ixy+IGMohzkEdz wtS+eivutbpTIUN2cFb4ujIfn0CfR2qbrQMWJdYfo0yFzFhezLFH/vAFAm5ZdVCu1ljLGEBloMZ5 udbCqjbYFvdzg9iXHg085hB4FwZdIMgpgVZ2qL3wZ15uxfJK00aL/ASFp35wrNtcB2iBmFIoDI3S MrVtRN86Qsm+MDOLvVlF69waVZuit+I5D0UDAEaLCGYZe2986zDd2bODIfzu7gICox1EDoExAnjt 2vBdjP6lPoGzGcAHPzgJAG7gGPBKRs3R0Hny/F8VP2hhtm6ARDNwKuCIaP8/on97uWNiDepz60VN ARSZDiNxsSDKEIvG80TBI6sYKlyIkhgPtQ9aHaIrMlXSYQ7Zqz00Go+0PlWzmJwAACAASURBVIZD 4weQBJolN7UxnIcChKEkzGJRuEL9+qJHHHyDXebDYxnj1Ox2D0OJBctnswz09HaMIFAHwZZKoOCP GIaC9FCrt2DRMJwWHWwEjcFZ7xcqQK4mA7WJUXsYw1EOUkGZ3gWdoW6fXEBZ6NnnSSldF6/DCj/H vTe9DeCFLwT4zM8EePjhcQQwCsvMZot0zwh5cb2p+uft24tU0Tt3Jtldrs9u8gMkvtug6gVB9sNC lO0OqAghalYPHIgxv0sHyBMF1BRBtfEFaSSeFbpBwUoCmWOK9HQA44ghdY5ctyz3WJAe40IB4lKE LrkuqHTPYOjIovXesMyvjBOF/HUQyjrAWklgEMbPamBuZU9pImpV6g+Xp1BKAyzelFC0Tixdg8gM TEiDalmNKgiR9lL4a8lpUxnHkwNoYK8R7+0YQWAEwQEGJ8jhKEkTdU3vhEp1WZY3kWN7Sw3lqwAQ 2il/QrB/Z1mWup1KzMMiXTYVvNQCpelRX3HfhVB2XMxRwdINQxkAX/ACgPvvH+APcYC/06cXAJhG 9XJF0KtXF7CXA+DNmwAf+lDzPtaGEe60Po6lA205mubolTJPib9VqyigeR6pw+cAA7TOjrKwixRZ IzvUwAvIACipoCALXZhsIAgPN27AgQSfoB8vAEc0gdiO4OgIj7oqYYLI27oC34QUggWwnp9Ik9MD 2p8ZKNifSIby6Yag8xyaLA2x/PlZQ1wW4/iC7O+77d09JbRp2zwKG3nlsx8ZrCT+3e/XSEyWPQW9 EQ0XJFYuK7QUxGjpJehILy2tZauxpdD2m4RL77mpnF59zHoiv8L05uglgtGNiga9wOQ5BYetBKsZ LtlAQJkVxgtfOBjCP/vZgw3E7u7gA5i36Al4+/YCAJ95Zvg7qoHGf2/fnlQN1AwaAigCKOl5ROee s6PQ5tE8Aa2wpkUBqXpEcxSwQX8Wkd9ONGyjVOK6pORKRPyC4dpABtwwU2nMxX+p9FGuHpAVhSmQ JbRApb93WnDua0zTvPSGlhOaTRralEeLz9IJJPwRBmsATF+9mK0qCOOJ1IBAarFgBM2wAYBz20AD EschlBxWwQoinXb0e/ZFk9MSqnohxZfV3X08eP3H87GBAPOOf83bxlHa2CsvfUTXLeLURb0Xz5RR whpVUPX3kt9aKYaCr57RnAZamutiURYt2KYwhVTEOgxM1AhFY7vtbXrYrOIyi7b3prctIn9nzw4Q GM3gNzYWUcDbt5c9AG/dGiAvRgcjHKaRwNu3AT7ykUkg0OIHSJpuo9wvRwPMWUbPgYHGGsCzwKJn WskuQov6oXCJiSlwQn2a6B+I9mtDSwXlTN+536ho4NIxQyaSh0QqsfVRotU7WgQw0P/IlCpOPDWv kzdlEDTUPlYbKIquhKldOZ6282katCjIXbQoj3KjRqNnI/LXfZFATMVFjJWXLddtiMt9xwt6NPBE QmAEwQUMTpgm6pm2ZR2hCRALfhPVRhvcne7va+oFS1M8C6KOJcutFoSZsL6uiWUC+HwARXYsfNOE BtvJAeDDDwM89NCgBrq1NcDg1tZyGuj+/jgN9Pr1ZVXQ6AOYCsJ8+MPNAZDr+4DD44zz6jMLvSAD hgzEoQfElGkRDfYOE0YBsVUdjjVqg/JtxMGkKYXTc9+FcSdWE+1lBS7QaBYPjmVS2x4KVDQ5qMrF XMqHyY5ka5LeWpJnDrb0Qus9LYpjFXiDWrcLKaEl4L0rEX3XEa7ZRaeKNhmeq/Fy29mA3k4qBKYw 2CwNYQqhF++0wWj9UFIbCA09A8EJei7V0FYACGWS12sjZuIAwipriEbwWPzWh0Z1f6X+iBkAfs/b AT7rs4Y6wMuXh7dQjABGAIwRvviJaaDXrw91gBEAoxl8WhP4n/5T84f3XesHpK0YNJN4i1dfDpWU HYTljFMCMpZODBo71R7zdwkYLamZWhQQLdNaOkTIgDQyAIwExKOx84y6kbUYwbS86lAYqEA5aijB oSd90+qJaX6EFMg+hgwcKWVQbuyQej0ccm5KEQStCjxIsGJ8+6wDZWytHxhqDrFy4Ih4YB2WZyBO tDpucDO+5zoDdggcQPBlry4PI7iFYcLhwp+2XeLvHmgsiDS6RGBCW4sIKBSRCYXGSBo4hkNWyZS2 bwo7Bu8GhfYiLuW/LbZl7w1vGQAwegHefz/A+fNDOmhqBRH3IUYB80hfmgqai8JM8bJEOYpn8VLL pwOqI+MRSiA6O5xAiTUNlIoyaiDJ2j0YoE6LtllBllye1RaiwBMPCzr3nCAMMsCmTW8GoXwDC5yR KAGW5p1UXOMongW2gu96WJd90gaHRoMWSIsINTEQtKaXEqmoI+g0rrIKulqqhOIEpxGNQWBhIT0l tEOgEQRr6wM984R28GfpMGvRP868vcROgmWwBuqgpkheKLeNKFa1nIDQalNHJ3y5lvVu17CjgFZv wOHvvTe9bTjuDzwwCMBcvDjUAZ46tagBBFiGuxgJvHVriAJGMZgoAJMDYsM6QEv6khQB3DBCIfV/ ZKCRgy1v/6kaioWFmrO4sFDZlIsCCjWCWqco9+/LYczyvcUMXvqefAwxqWqAPDwCA44qKFOdesNv JMDV1qghD8/5/oSw/OoqNO0hX4VTvMKm7lFjK5sIzSOSeUg2ffYY6w2ReQjmUcj0/6PrymkVwZnF IwfT03BkfRdEGbQ608OBHQJTEFzAYKM6QfP83nUZI3tV0T9wRv+UZTbxB4QK6wdoazofCur6TMA2 MdBVew1ORMClnoQ1RB6s22M4r/v7AI88AnDp0hABPH16UQO4sbEAwFj/d+PGAH1PPjl8nnpq+O76 9UVd4NWrw+f69eZpoCzwGb3/SCgEWdmT6vewUb4cKnKwUToyJk9A8EcBR8vX/PpAVujEBvVIZOdV uRNF2GaUQilQYu0oAg1SkvonBUXUdknX8ai/rInncL+h0mdH29MmUOOPYexf2KzziwWPY2slxBGJ mYyElHCcyjkFpATC4N3MfagMpOH4wlpKRAv8s0BSukXmX/X4WsWRJgA7MD7LLMceAeCdPRrYITCH waqHnStF1AmZppo+o21EibKomnLq7OCHBrWBTWEPypU9w5ThxAqoCxOqiLYEVpzoeNT2JLSNCwH2 vvP7AF7+8iECuL198FTcGEcB4/2ZWkLEOsAYAUxrAWPE8E//tG0nSeiMSFE67ZRZDd4l2GoWyWul BiqkXXrEZwBlKKQ6rwCKUh8oojXIwDQX7UPh3Am1Q1QkDg05pRwIBmUea8QugNMKVAHyFNwszzZv h3Qlz0fL2ynovx2rXrNHIdcwkcnXD+i6aM4DUNpeNlInpJ6j1Uun5eDUdKfH9G4CYrALAeB0jwZ2 CByB4Ms/33HdhXJRGC/8tej8lqaHNvcT9IrGOJbdEiBawt1hiMjUKPfVHltEaeenebNgo1eS8dzs XXkHwCtfCbCzM0QB77tv+Ht7ewGBISzX90XD99u3h+hgBMP5fCwaM5tNBoBpgfyGcOisfoDk9Mir rSMKNXcNPAE1eEPNdBhlwRcOPk3boEQj3NYRAshYazI1oJI2UrKMQKoXLZhuo+HAWKwhUBjLodQT NRCskr1HPgLZhO8SldHDBrRJ1o8FvzsFScS0dqE+zzqIlSeXBeflxInKaPeJ69VYKkdrGSxccXUI 9cxFOP6Kux0CJwfB0lTRKURkworEY1oCIMhiLzVRPA8sNrVMMKxTXV+oTxWtfiMbh8qLQAp9qw7S fpeCaFvQ3PuetwO85CVD/d/znjdYQuQACLAAwBQCo9jLM88sjOBzRdD9fYAPfrA5AKZKoBbYk+Tz ubo/aRoOgopq6BgQw4IrttW06Oj8qIqgBr8uLQq4BGnC9xTMkR1crRY0S8EDNEaWtZpDyxOLMEKX UkwlURhpP6zPDqy80Go6qEF5XoYpoe0oNOKcaqqfJpBnonhU6j0JlsoztOiicTxcpYG5VUCbC9gL FWTzffvRh3tKaE3bPK47FkHwsT/8N2UXSBFoGMGyVeRPnaZhmqcbDMHnDxgaH6dSeCyZppU/Zc31 F6onsM/rBbmQFT2EkmMgbYNv+/auvAPgsz97YQS/uTls56lTi0+MAEbgizYQac1fjAqm0cFUEKYx ACLXaQfZ+oFUeiQ6NwB8bSAQwCMBjiUK6H3pr0MUcLR/yj6ZhS8M6YwowBIIAEl2dkHOmg4gC7FQ 83CKoRJkWTO38ygKBb2qfYTxXIG2f6ugQO06CPLFEiqilAGcqa7ZeCE65BGkLgG3zPyVUrKZ7Hmy lrcHZrlMFJ7MsA7L92GAYT9TMSZMu0eeY+s9Ngi2ceRJVk7/l1rd6Jkdul1EbTv2x+/KK16DV17x GnsprCvil3VYTfV8DZVDW9f5lUQNXSmjFQqfHlgyA+BEtYCr8O7zphhXbQK2285ip2a092AlAPye ty97AJ45A3DvvUMUMIrBACxbPqSpnjEiGPctpoLm6aATRAFJOwgw1Ahy8xk6udT0mq+eJw3UYgmx 9LuQMukRaLH4BnpN5NFZC4iCfx+1j8iAmHYu80gicuqaHOxZO8aWZTG3slYvKAGnRfTFA8DifCWP vqBfK1jz9jHU+h1KXSBW/E75Y3L+ehN52WnXEwV2nOALcAN4yK9PEonJ6wNZ5VVHrfIKxzJMywyW 5+VBe9cLezSwQ6ABBlXwc19GoQ2wqfDkmMYCh26IbVADyH7vhMtW0Ebtb6np/CralDWI3tRVrHiD FBsQNRLNOX8e4NnPHsDvwQcBPv3Tl9NAAQaYm80W6Z83by7SPmPq57VrQzro1avD39euDVHCGzea isF4SygthsWcfQMIwEhCIfDpp1L0sGUaKNt59ECd0Uyem0C1FkMFhhnhgxzgyM4eCCCJ9Y8x0Tge HAqjxucCq0KqXcTGjvsITlEQ5whjG8M8OWFVr4fgPInrVCtF1rYJEI4N99FjD0jWPhufqeRAGbY7 gCIAFpzz4sGNiSwlPIN6uao1AMBmLw4sbpsnaWcjCD72h78XqlVEW3fcTfBXs4zCyKA31dOdfmqc 1gqFofI8eLejqPZv6q5DgQhM6bXqVRkNh7e/e1feAfDSlw51gOfPD76A0Q4i1gDGiF6M6sVU0Bs3 FmmgqfBLWjN45w7Ahz/ctPNEQdYGMDUqQNcBbsD4N2v9SqkQTN4pMoMVNy3azN+L4FACKQPMjoCQ S5mcKGLBdhapc4tjAMK0vspqBI/MYATyaaAl9VFShJD1DhSeEnfT7Q5eVYjtjrfrxAZwR5q9T0Q8 xPlXSphBeK1JrwmUMxwxnQ3tr527681TRpmVxfvSNI8zJVNM9XQsuzYTlEvtDA0WHt+JvZW1E3ns rrziCwqeb42N4D3ThkoALEoNhTZAp/kPTt73b1gv2IpgVq00OrUVhbkXoxCh2SfLk2I6/H/ve98J 8LKXDRHABx4AeNazhrd1tIHIXZ4jCMZPTPkMYVn8Jf1tPm/ev0k74FEJFAxKoBtwICKjACCVSucy dkefQibXAdI8Ab2d8tqoolaH6BmFN0c+FUEYRHp6lGTnKb9ADfQUNUxRiTHrDKPhus63ZSmtDnxp juandGkYqVESRFD+JQcemMGFKXwBtd0U7YazicwVAGi7t/NrnAMx6jtJxAWEARTxgWt8TuYPV1Eh ND1eQREKMj48V2EOX6Pv7Y0G5s+YnhJa1jZP6o5feeUAgo/9298LRWBVPX1tZM8BgC1/c3/vWL4r ulgRGSwlzFXBW2to84y01a47eDYEC3pvxHxLkczxzu593w8MXoAXLwJcuDB4Ap4+PXxSJdD5fIC7 GzcWpvC5CXyqABrrA+PnIx+ZhKU5JU8xdY6rLUO5k4pMhwqVPkaLOkBrBxC8y0G9jpHssDlP1gju hLCcJCxjPR6SNQNVT4SoH9MAQqrqwY8BaJVTAFn9lFph4K53ZMSMDAeKU8UVa64c90gzkrK+hpKQ 1F3Bl1z8pXHoLjTcBfdT3SlSkkbSkHlNWRcJAoyHwDxnNw5mmC/WnYq9ACwLvli7f0v3UBK5DqHN q36aBUx7bUj7v9VTQovaiY+iRhhcvjvDdADoMYVXIVKJspX8VgJ67ppBT+oht/0GWGyaVjqRsmhz aAxKwK1xfmbVgzdMsP/Lbe9Nbx8A8PJlgHvuGSKB588vRGAiAM5mC6iLaaARBFMATBVA00hgw/Mq evUZojGe2pYNpsOtqVpS4GVVEdUuJStsAthq+TxwSAJjbRTQCIZLwEIIPSwBjqdGULjbOKEY1sAa /WbpQdgo1NJEUR6kQCetoWGgZCVw53w0hoLZQvvNmKyD75reWANKXiPZB60ROSBM4FHfPnYbqfsg 2xYpYqk9gxDaC8Qc1rlHBtLTd+IGQPcM7BBYCYJF4jATpIhWp4eG8uifGwClY+a0faitnStNDTXb eijbSymCliiZWpY7YWfDPXOo2JeJ6wP33vjWAfwQhxTQy5cHW4jNzYUVBOIAcSng3bmzDIBXry7q AuP/r11biMV84AMAH/3oZADIdhzAbhFBdhCUFzEiD5dajZ4JzFD3OUZLRx3tEFHd75E6c+iwhAB9 u7hInyQSgtkCUQA+64HQ6gHJKKRDHXQ0n6HDnB9zTmDH0km3Hg+uFhS1V6khrXWlbUqFUDRG1IPh WKNSY2u5bgVgQ+kB3IhokBnIGJnGWzbBM+JVNELjgOnW0CcMGgbteZS07hnob5v9EByA4Od84ZAe +n//rp7v5gZF66SV4jClgFcEaGAsDKh4EpnSLz0m9VYubFEzZ8ircC83+FNSq8BrYoGZ4k6McR3P fe5Q+/fgg8tv3FQJNNo8xL+j0EuM8s1mi2li9C9NB53ACkICQu07LnKCTAohJShD1p8Z+h4lkTJn P1xdbkkUkIQ4Zl882wLSsnAM1KiZwwMPWWxHChUoQ/o7Mq2TAy60eQRa+tdmddD0kRjXGUD1LuSu s8DMT6XSpul+tZ58licwFv1YPXmzAbulNyEuNgRDIlqS/1uw8HzWkV2Dh8QN20ECy8F8S+mgta/E 5PpOUyLTFNXiQ0j59FV6BqLzkuHSgEv2p0cD/a1HAhkYJDuewQl0Hu/AKaN/asc5tKsBlMCKi4SZ IK7WZL4hnEyV9qnt89SWFiowBtC7Uq3WHQqf9MOPe2/+QYCHHwZ46KEh/fPcuSEKePr0QgwGYGEF kX9u3lyogUZbiAh+qRhMQwCk4GwEg8CIumRgQfrE5Z1xIwBSo9clMCZFEsmaQ602C0G2ljAaw9co lpIAyaVeAeN9VrBy7hoRz7kSIVbv7jSiFYRBDMqHEAkVUkHoRHt1asJEo30Kxldpw86kOeh6SLYT pfw35faJ0Sbk65vNy/SI/WA2AGIQlUFQUui924qG45KdF1Y7Btte05NfaKCrVVODRl0gpkNgQxAs qQ9s6QkIdabw6vyhTDm0Jt3UAmsto3jsMQq2FM5Wr8mStE5vT6WJfYX0xMe67Z3wZZG2ve9/F8Dn fM6Q9nn69GAIf/bsch1gVACN0HfjxgB8Tz8N8KlPATz55PD3rVvDJ06XRgI/9KFmHZ8lRU9cKIFu AGPnwERZuDpAYICx1QtespLg6sq0lzwAbz4PTgD1XMmmWkCsN56X1iml23I1gZaOcchWKIHjCMRx bEnCATei/Jt2HXofPVwnl7SQMKTtHbWQQgrmwfKcDJM8eqelh0C4E2mvMIRxLWtedwcE5MXPhmBQ X2O4jjRcUssl7xVOlAmMKpyoD4qtvGHZ8zoHmi4Q42s9HVQBwcf+r99pnB4KDkisXG8VrLWMDDoi c1W+gZVvM4sKqanOD/zTlFwzKiRm6ZneVBtXHWRlLaOUSuo413tv/sEBAE+fHlRAYxQwF4JJB0ei N2AUhImpoPG3mAoaxWMap4Fy/QsO4rTUUKojzsEUJwSDSl9HMoVXQacAmDhvQs94hTRfiZCN2tnT 1FGZWjfSXJ7MX1S2AQXhlwwcl1JQufRUAqakerg0ZTIdbg4hOQ8BWNoV9TcsKajOTqU6wGAE7VoA QhDO9cTpp4c1vmd+NaXpn0l97N00RsjSCJWEknkwpo1avfaYgY3R7crUZVJQliqMBmlzPNtYcUKm 8AxssaxVVaMct9YjgRoMfu5fRnFYynzRWaOKwRjdcwyZuR7pwZGiWQGAwbjNoYZaKr8LYUXm5mEa 777g8NOrXr9zONEDlFYA/P53AXzu5wLs7AzRv1j7l1fgxyjgrVtDqmf6iVHB69cXaaBpKuj+fvM0 UIsQjAaAIjAxnQwu6kOqjDIKopRZPfsv6nBpjbCJVyGW1epxx2L0f5TTO0GCWqW+z7JvwAE+CoBk sIeQrglw1ANK4MiCKOjpvGiM9GnHTtrukhsYjY/EVTU85M0Jq9gZDtA1oBcUPVFS/hSAyJIqSmVD jK4jhGZ5yOmATv6d9o44jAEByeLG4hmYH7of7imhHQKnAcEwXW2gCSpDnXhMMKR/NksNDU4hF+ey ixnQsf4SIA0N0jzX4U3tfjO0XCC6f957yw8N9X8bG4MK6P33D/+mUcAUAmOKZ4S89JPWAaaKoTEa 2DgNVLOCsAAgFdFbsoEAQpBEgDgPhGkAWHvGUel4o+Ff5NJQG4T+pFpAEGCRi0xKUUAyfVPyBiSm 59KFuYgaZzhPrgvlbVAfPyj4AoIikgKKhhlRe6elWXMrpVJapahtYMb+Vtn5tr4Kq59rpZFSpK/7 PELNDrZoAwCCgXzps9sNOJTYksG4HnNYzLYdhSi1aZDCYSyPxoNQYxxvulyQfmZuAMCpnhJqbj0d 1AmCj/3Bb9uem9W1cc6n9VTKoEUACNPZQ3iWYa4tLIxAhka1gKHBulsbzGuiMF7T+JqILoJugHXv vQMEXrw4RALPnl22g4hWEPv7C8C7eXNhBB+9AK9epYViUm/AqQHQOo0AgFxHyGPnAAI4kjCgdMJU SESDR6AGgIZOiWrVV1ALiBbDeANIx8ub2i9KSXQ0wo+2u4tbH7edVmVJMSXTEClcSu+iVow6nIkg kF1rqSro3dRCQ+otm9JqfLpZOuZ3FSDhkEsUw8TTFz4/zemjhleKOjuKi1PvnXwmz3LSOt67KaF5 WiyVkhqcCp2OPM019ZTvraD1SKAXBl/1RbI+k0tIplYVtAUAVhjOTwbAU3kMOtJAvdBlAafSN+YU XoHrkANiBkh58r13/wzA858PcOHCUAe4szOOAMYU0Ahx0fYhrQW8dWt5umgeH3/7wAcAPvKRyQEw Nb9lQUtQAgWQRVQ41UgK9AB99VNaGqgVzkzgZF2mwdS5xN+P7ukZABwNwC14/Wn3hsX+gY0QIg/l VNRMjagG/lqjhDksy0UF8DRRGvcjEad5RAbq33A8O9dk7XBpbaNV0aqidpKz6zGdVKrOkJ7MrIBr GcCz1DVL5QC1XQTvMrSUXW8q/0b23H939ww0tR4JrADBRVRwIu/A2vTDmtTE0uXWRupaAEeoSRdt uEGW/JuqiFnD7V3p0F67+se9H/xxgJe/fIC/3d0h+rezk/QmceH/F8EuGsGnnxgdvHFjWQ00RgFX kQIKciSD++Qd7Hx6LgUUQFbzRO27gjRQdlqLqbsCpK4ooAKA1iggMsDEbQ9pH2GQlNf8AjmrEBBq +tAorqJtK2odWObuFyOi1po9LtJoBRIJIBsS0EgUpNF6QuZJhzBB5LDm3WCZN6PhEOyvMXbxOBZS ASL6zR2r/BoNofx8Ux6UUZRG3c3oOwiE1yJ3AJwiNpzP4roNIlg8A+8+v0KPVFpbjwTWwqC5PjD4 vQNrprFE/1pH+VyWD956v0rlSPM2hDJgh0a1gJah/lrDeBVGV6EFB3zPy9iD2XvbjwC84hVDBPDS paEG8NKlAQajH2Aa2bt9e6HwmYJgTAWNoi8xQph+GgOg1qHV0kC5ekEAehSb/BsVWBLEFsxegVge 6ZOg0OIpiAZwBGm7JcjlUj5R3wbSIJ74jhVzQFvUEAzXGlfPh0KNEAePYKkTJK5pUISNRFEXatrk /ElqizVPLSx50k0AmKiA71p1hK2hJ+WhQtWkLdX9oq4W7H4mGUKBpLgXGMSfGLsIpOpj0SD8JQx0 1b6apzjt0uCRNRrITdc9AzsETg+Cn/fF+jXuBcUqQLT8XrLswt+C+Uv+p1q4DBVqoOYawkYXlLr+ VQjPKNJoXugM7RUQ9n7kpwAeeWSoAbx4cZEKurU1fGKLdYC3bi17/KWAN58P25imf8YU0Nu3m6SA Up03rxAM29FX0gvJjjUqgCXU3klw5AEwFeDALwThTSGyRjU9NX9FnSFjmqJaC4hC/V3aiQz6LYfO W5QUmsHlDjrbQRWij9aOJPeaZZeF+u8SRK+6Tq+R1Z5/jHPVY4ItAbtA+IVLpRf9BFGI/Au+f5J4 EjVyqAnEkOI6OB70kXwCrRcetrwwHefbKqLTPQNtraeDNgTBx/7P3wrFnd8W4jBgsJYoWn8oM571 RgBr3SBq34ZWUCw5n5ZonDlU2NgjURWVafD0Du0gce8d7x6ifhsbQ8Tv3LkhBXRra/guvgHn8wHs bt5cAF4a/YsRwOvXl/0BUzBsZDzkUQLlOiMWddClv5FPG7W+XLFwX7WRdwsAah1urxAOB5OISqfG AIAm9U90AHaB4IvpvAWiY6zVBGrG8hotogCJwrCTJkxjUvY0AMNIHAYWoBzQABuo7H5cThh33i2d W6x91q+4I9ySGaNgSTyGslGeIKTS9g1Knp9A3CuaT6E0oBKyVM10HeR+Ybn9c6tXe9P5qVRYw7IQ ADZwkW7bm9x6JLA5DDrEYUJwpH4eFgBKd2Boo/jJMpgzlTTUCL9UvH5LhFtKa0JX4YbqTc8svn6M 688B8LnPBXj4YYAHHxzSP3d2Bk/AVAk0poFGmItpoLdvD1CYgmBqA5F+9vcBPvaxJi/KjYMX04Yh AhinAxh3njlYHP2N8nQUOHLwZI0C5gBoUQP19q1rhB6s83utLkyKrWHrXgAAIABJREFUoAx8IgVb KJ9bBD5Fl0spMxvHg54KSsI5Z/SOxOvOcNuT16pRdZSESqMNqZpOG4hXcukjeV06qa3BAOvuUe80 xdF4s9yt73pBy6K0yCUXuRYGJUIwPM+mGhDA+nNrmdb7HN8AgB/pKaEdAlcLgn/FmB7qgEQTSJYs I1Qoi5Z4ChZChGUhwZre2TI6y0HmCl/GbmuIYDtuLTsJjTwH9975nsEK4gUvALjvvgX4xehfGgFM RWDSFM8IgNEOIprEpwbxEQo/+tEm70YubVIThlHFYJAHA8l7DsFfw4cNT7llPZLgSg5SYABZDjpR DS/JoOfJpFI7YbkgBnHhUEDGnVOTjQRXEyjAFhKqnlyUL1CQKhxvKmrqHRhQQUHxRLNEONF5M2DF 4/9Iq4YqYGKWGfYcT/Q9lEcpnWrxdsE7QPEAUv0CLeJRNWm1nvTQ1fKjbcBOWMhGTwkVW08HnQIE HxlA8LHf/81gBqcSUKm2hqhZdgE0uoDRo/BZmx5ZU0fY6mU5kVXEKEckS64Y5VpMcSzrD8/eD/zY EPn79E8f0j5Pn158treHCGBcf4z6xTTQFASjSmiMEKY2EemnIQCSpu5KZE/1EJQAULCJEAEV69RA TT5+DTrPXgA01xmiz9qC2k5N/ZONAoLdFoKrBfR04jC9NykvOi5KyAEyMx8yoM32s1EBZ66u0OEl qIJjaUhqDXgLw5ptmzeXr+F676aQQpZOGXyrle4psqKDWedoOYH4k3jmzC1+EtIrnzvclpRa8HsI Nr1snOvN7+OeEqq3HgmcGAYjENpTOo3RJy29U/29EEiKVUVdJFkHxx6wcy2z8fJW0jPw1vuh8yBM 3zna+9Y3DG+25z1vSP08c2b47OwMEBhTQAGWATAVd7l1a/g+RvyuXl38lhrB7++vxguQeXlLkT8Q 4GcEB/m2IG0HIZ1Ck6hLyaVgjQJKy/Iq36FvPyWwRPR9b4IzReAFHRRN1u5JyqMClIkSUYFYTwZ5 5O8SwGXrCMQXqD3mAg2tWCiAUXPdWeAytBxMnHAMcmUk6zk3qD//Sk93w2AgKRBDPeilDI3RPZtF EUuOmfXgmJ7zFSmh7owK425E78Af7Z6BHQIPGwbVJ3BwRAlrInhQET0s+i3YUzXNsKytd4JoVrHx e/CnaFrfypM81sLE0/uO/d63fDfAQw8BvOY1A/DlELi5ObwB5/NFuuf16wPgxb+vXQN45hmAv/gL gKeeGv6+dYuGwA9/eHoAVCweuA6ORwjGDDfAyJFT02iQZoE74zRWUPSomub7I4Ip2s+1BRjJdaMe wXVZfRj97kZgmO2AJNOOjEQ/OUZmBEi1w2eJ7BHThOxxEoId6lz9Zyx7YgbvQ+UwnvBTdZ1RBmWc ZlVF0OGFPcrWwfSu0AaILNcnow6KKA9MYeU1iNNeIiZQp0oppty+DoG9+UDw1V+CV179JUjCn7Vz XJ3+OZF4jLdu0Jsy6rWDCMb5zW84o5JnM3a01OkVTFOiWLrqIWLMAPCRRwBe/OLhCR/9AM+eXcBf 3EYqAphGAVP1z3gvpZ6A8bcJARAMAGipF5SEYCg4keDC0tnVzMxddhCGadSOmxfQHCbyWloooh1O 8rq50Xf59gUFcJBREAW+pjSfj6u5U1NBmUifBIiUEA13vMzbJlwLVE1UGoEZCeXkpt7B+WZAY95E yKJ9K36kBsdr7jDGEYPn1YBMvTAWAiQq15ahPlBKbTZtj9GDUPMJRHRcs+gAc89jt4K2PBBsvXYw EWPr0cAOgWsDg/a0TwlgHIBoNag/VAAEd3Zo9VumxgOwNDW0VYQPJxjbMllWKM7L6nGx1TXufct3 A7zsZQPwXb48AGBaAxjtIAAWIJfW+cXvUu+/mApKRQFnsyZ1gABMHZQHAEFXmLMYxbMgKgEP+CJw 1DI0NVBtGpGtpLpF9PsE1nRcLDWRrvUYVUIlMGwBLpZjL9XjaenLnEk82/EFQRmU6097OrQoL4c9 vsGYyjmhp2DLMbritNRG95MXPqp8N80yntMwD6d+y5rFawdGUMi1ZHBYB7amrBapufS0WvneOgSu GQh+KV75/C9FE/zVwJvpLVGjHhra3dHBq/pZIebi2YZikGvpO1gYGax+A+O0vQ4GKvde/12DBcTF iwAPPDD4AJ49OxaCiWmgEfZu3FgAXlT9TKOB164tfs+tIPb328AfB2zGzjEFS9T8VvXMIpABOQ3U m97pAbTS7WR9CQUPwJZRQDbdFAXFU8HKwWICzz0hqHRPZPz/NO8/dp2h/iaRjiObikpECdmaQmsU 0jBNI8bhr2mtXjc4jn0rJdEVxU2QuSGxSlXKsX7N8B30Wj1u9E4Dr/R8BcNLRXvetcyBxJJrAguX a4R6l21P9v8N6NHADoHrBoMcCFrhrxYAxfUYUkc93n7g/d4JdZPaUrQAOShL+7TO1+IN7o3ihfbr 2Pu2Nw4CMPfeC/DsZwPs7i7q/7a3h8/GxjDf/v4AdFevLuwdYg3g1atD7d/TTw91gJ/61HL0LxeD +fjHq16WG8B7AW7g4vcc6jaAnlayjQALdIEcZVxKUaSWgT4AlICtxA7CAno5PKh1f8I0XgC0gINW 62SJcop/S9FAzRcQeECSQIy1bkDZ3kGqOZU6m6JOiGYfkCyj1Cew6RDXUQlLOJQo3WAwUW3jKJU3 jK9llDz4LJtOWUk4LyTSagVp5d38GS3el57Di466Z5z4BvGsDm0DgyRH95Bgh8AjAYIe/8AaQAyh wj6ipTpowT56Ukw90BlqTOVNG9kQOg2wpk1TYjehPbErl7n3rW8YLCB2dgYQPHduSAM9f374e2dn uQ4wQmBM9YzpnteuDf/euLGoEUztINIU0Q99qMoQXhol5oy3ERm7KEYIhrSXQn45AIK1BAMb3po9 8zRoV/uUUkpZIDWMiKueZI06Lqp1BdEBQ2Pd26jzmB8r5MGX88XjlsmldJL1fpQwTOD3SU05NNQD qoI1hmuN7WBK6ciKb2Pxc/OQOG/VDdfseLiiScYIFzZYKRIR+lxBFAmwpepvMVMVVcqPqwRzcOrz Wehahutz23UI7I0HQT09FNqJw2i3UhDmLYmsSZDmsY6oNnr35Mk0BsWWgqMr6WVY4LPdtu992xsB PuMzhvq/V71qkQIaI4CnTi1M4SP8RchLI3qz2ULoJUb80mnTaGADJVAO7ixm8GQnHvhaP6qjwUX4 PPYMYnSMu7qwXOxFU/SULmdv5FHpw/P7w9XYKFFAySfQfDyNQMKlRYopk0K0MjDXNAn0Eohp9YLE RWzyQvS+toxqqenO56+koAHpIT2d17lZX9Pm8jKDoI5qxxK7PlnEUI00W+SWmfuASvlW91/pZqn1 jJ6BIO54aZHSw1IJNVpQSD65PSW0Q+B6w+BrvgyL4a0quqc9fQojg+Ib4RDA0LP9phTMae0Rismq Sb1gg8e5sed1NwX0/Pkh/RNxUP+M6Z8pBEYl0Bj9S2v7Yu1frAe8eXOYJoXDKCAzn7cBPycAkiUk qPgCGiDHLOJi+M0DTNp2WqBQ65x44dFidF9Tu2I9HiyAIw9maPULlG77oHemSEhFx/EJQqcXCEVU yZbCck2jrMCoCgoZO7TWYLF3ICNkoGlkm5WDWZNOe7HykLHzT6i8mu5nh1JISLpUQTBrR2BqA/Nu FTF/MAzUjQZkmPRQtJ5r5gJ3C8S0OreVi7ZG+WKpxkkYhOkQeNxAsFocxiIwU1obWJE26rWOqAVD dp3W+WvmbWT50KrHQK17inpAg1H93re/CeD5zwe4557BD/D5zx+igZcvD0CYisBA9maOKZ55jV8K ejFtNI0M3r5dpQQ6quUTTN6lVE/IO8VCpzetGURiG/JOvAXeJL9A7wsZC38zp4taOwbGhbnFYHDZ 3oFKsaIihlR0TvRHpEAQZFEgMgKISiRPWyZxLVIAqT2a0Bk10CKJVOeVFRYBXbl0tB4HJKSwkO88 KvvVeLitN+MgU+0ySVikgJGAVmsNnpqSqchIm9RBtfUINbRaCjROcLwt9ZAAui1Q/LpHAxdtsx+C 9QXBx37vN0IZuLWapkY4xgusznrCMFVksCHYueix0Xa0qPWDgk0uWO/ev/h5gJe+dIC9c+cGJdDz 54cU0FOnhmhgqgK6v78whI/pnVERNI3+5cqgEQJTMKx4QXHgpb0FJc9AAL0OUBIXQa/qZQHgafWE 2kvYagdhEpRB4/ToF4MxHxuDcAwYoMMs4Y4EqDGQydb7KcsE6jfmXJFCNCCkvTm9A+NjJR3/WfJU xMVTBpPvlp5A2TwB6+qeNGidqsVdy//lprPu6zrBW0y9xYNtJ/OTg2dh+rwIB+sSTqPndTFajXWb pW3E5FomBh3S2RCT7ZX22bMtnn2A1deb5vcFdS+HPujCth4JXGcY/IIvr1QPrQDAWuVQ7ysuuAiw DWCaQG4KqFz1I7IBbDZe795P/Msh2vesZw1iMA8+OADg2bODGujp0wtD+Bjxi7WAUQk0Wj2k5vAp BKY+gDESWKkEmr+cJYCLKShUKhsp9sJApRRBygGk1AtQGz122TwUmA6XAqD1ijPBGvLTirCt1Axq UUAKvCwROw1KtBrC0XXMRAGBgjglhVQCSJeYJDe4YUiLs/gcatM3fKpOsgz2gGK7RZXsCOIqdpxf 9lJEHHVVWrUmOV2W5OcnPE+AGkQxKIRy25PXHYJjcIV6JnhOV4vTi6XrdNYGLgEPdgjsEHikQTBU +v5l07gsHoxvCjEF1CnWUpvCKS2/efpl8B8r77ZMAmtTvaT5COXeT/7CkP75wAMAly4Nkb/Tpxf/ xhTQdN79/QHsotdfVPeMwi8pAObRwfj/O3eqlEA3QDF5z1M1mY6mmB4KfM0gBXpSETw0BkAJ2mrs IFydBocaKKJu0wDcMUAeqkzRH8O6QIJDtEUBEWhBFssxRLQ9plS/MKbOD43pj5qQBRI3CpIXlRNG mF0KEw/WlcjVi4MxVssDa03aYQxqou0+ag4fWL+J1ENbtUSxqISabh5FnThXCUVm2UQq+dR1gS0v GZNNRPZdTwkdWk8HPUIg+Njv/npleigUirhYfg9lKaDeeaoVQpm3Vu1yi0GzYQppE6uIRi91Zhl7 P/2+Ifp37twiDTT1AtzaWgBgjABGa4eYyhnFYWJ6aF4LmM6b/lYIgFRtHyf6Ir2cuPpBEliEZUjv 56kigCL4GYCTA0BQfrdsB5cGCkrHmRXD4aKFVAonyscbDFFArY5FAl4L6FmiX6LVhJZimqRmonZO GYEb0aQeSbFHQCYn0qRQ2rDvynk3HnYneWXNkS6I4/ED26yWCT3pos53XVVWJxLfazYpVhmEwKef LqWGGtfF7efdtNlMECqE+lMRGhxz73I3AGAOvQH0SODRgsEv/Kvl6aFVAFjpK+j9yQuA3oiYVfkz hPp1NQEoi3BL6dMSC66bsnXvve83AO6/fwC/8+cHD8CzZ4foX4S/dHui6EtqAB+jfmk0MI8EpjYQ URG0UAjGAoAg+PuRwEicAsnUXYIGzjpiin4e1291RfQUP8Ca2kVL/5qMrDpGvNnIIpMGyoIeCpFN QUWUrctTbCHY6BszX57qpnnrAdhUP13ehGBbjgWQi5gMDQMVSD8qLa9aTiX0RIUnClUki+EAm29i +5kz7TNxedzzg7O4AUfdcov9w4kuF7Sfb0mkrUcDOwQeSRBcgkGrrUAVAHqhxQKnDer3SoC3RvnT c2xDS0sJb9GFA3aL7CTQPc/ez/7KAHtnzy4AMEb/trcHCNzcHGwgIgDGaF+sA6QAMLeFSNNEYwTw Ix9p9g632DsgpeCJfAopMFBEvbyl2rSlF98EdYCasqgEhaZaPqUOEMBoQ4G29Uoga/Hus1oOoEH1 k0sRzesKkfAdG6WKog1aNKBRxWSEgRDLc4l6PaDlNYQ6JLKvoSA8StGwrHx7Qj20tTSzlvYzeJex AtgLXvKlTNCZe97KKKP6QcHbr5SJvN9DBnNL9zuM7SJqTyAaRtOaKjYbj0GNUnWv/esQeOxh0Fw3 ViziYvQW9C5XrEd0vpaapIdWzG/dXnLfjNYM1u9K3u5WYyxpG4V59r7jCuz93K8OwHfu3AB/ly4N KaDxc+bMAIIpAKaWDnkEMP1E2IupojF9NIXIwj6LZgMhASDZ0WAAED3QAwYhGMOLEa0pnpYXs0UI poESaG0aqNkOQvpemhbpKG1QOl2qJYSh5k+N9FGdPWtdEgogyNhRSLYSyKiWitdTeg0EZiwsq5FE JrVV6vS2sCuxdO4Po5OKq0gVKF0fVpSglZg7ek6wRRimwFoHlR9dz2KkB5tQud5rwd+0zxXdruC4 Zkrf7z/ywpMdDewQeJRB8C//NSwCtBYAGEpqAKEAGieuGzxM9c/QcPklyyL9AQsWzIDs3v/6vQAv etEAfffdNwDgzs7wZooWEKkNRATACG9R+TOvDUzVPmMkMBV/iZ/COkDJysEaAdTSSKnOACrQo6aH MmBUAoAuOwjhN2vHoVVH2yIQQIIpJ3yDCsgqwgwgAInFJ4+DaUQZ9kToBB6yPCbx+SO6SPVTqVkE gwVLy/I7LbrX1NOy9NFfGn08al1d9N3b7DWPsupyi/MyesCjwqgowCXo6ezu043yIA/rPWp5sE+Y EoqN7x8yA+eEhwy7MMwxAcHHfufXggnerKBUEz1sBoAwcd2gx7S+8Rt0anP4ZlYXBeXZCLD39ncD vPjFQ6Tv7Nlx5C9G/06dGiKAUeyFArvc+iF6BMb6v7QGMLWEKIwCQtZZ1aAuny4HOgtYcp1ei9hM SwDUopBgXJ4GShw0SdE+dR5NOc8QSTNJpgsHBCVgo44xGvcH7R0bKoUUsnTS9HcqBdUi6CL5FrKA x6SSUtE7U70jB/NOSAYNPInlo7S+qWlw4hbWafM8wjNoGwOmhE5avgkxmSH3IQzO17G6T5yQjOA5 iKHMhpEUiIF6cZepRGDS4yf5CJ7k1iOBxwoGrf6Boez3EKZRCIWG80wBgGwqZ6hY/yG81VvApAEu 9978LoCHHloof0YIPH9++O7cueUU0NQDMDd7v3FjEIW5fn34RDCM0Jf6AaYQOJsBPPFE+Ugh8N5N JIAB07kF2nsNjcAJoAvBeAHQ0z/VUji146gBIEg+cAoAjnyyQFBrrU0DZVIjKYN2NbKKuvXECOQo qERDWiMDTqq8uhQdyKDNDGgEPJKbj8LjSxjBd/m+QdsogyS5z9WlLgnDBL+w5XFolmcStt55p4qW V3SraWS4wqsSBe9RUx2AMZXUtJ0rigZ63n2pZ+BJFojpEHisQPDRadNDVbgsgcqC9QXP/lX497mh KhgtGEq/m1qxNFTPsvc9bwd4/vOXI3+7u0MqaATC06fHNhBRxTPC4I0by0AXAS+CYgRBgHGa6Ic/ XGQIzxm8S+meG3jwAT5ddKkzIXn+SS8zNHQ4fe/2IiEYVz8CDcIHjfp0IliW1L1qxwT5NF5rp4hT 4rRAHtfJ0qJz6Myps54/zSNQE1rR0lUxmyGAP+vf64Wo+SOGbHvyR3EouYgnfGxP2ss9JCHtEvDA kuUYYbVZOaK1LtAw8pGr0NYKqKDz4gqTn2h7aYBWknESG4bQ/RKPY3vstx8P5jdg7e+hMJq3ippC i3deyfdN4c74nQcAtXnN0Glf7t53fz/AS16yiPbFyN/OzlAXGG0gogBM7vcXUz1TAEwjg3mUMAJh TCGNAFjwHpH8/th6P7TX9GlpoxYlUGldItxV1AB6gFSSIHelgVo9/EBWAiWjbYopvOV7NQrI1NVw Bu+quAyOp6f+zxnJj4BT2lYm2mdJJ2V/cyieavOy67LsT7ZMUkDDsxzlOErnlbouPNfh6P4S7DJQ gaNSvRTTWCuTOLIE0CF73QjThLCY7u7fYTzezE0XkrHUu9Mn0y1NS33m9Pfp+kfTU+sEYXkw3g4A ZXstxyM7LtS/6XHP01ZDELoBFhAMxZeRLoOQdVUo25UUhtPv52HwDAwA8HX/4ckTx4O9JvCYtitf NEQFH/vt94fy+r6K32ttJ1pAo0fNsxYAocYmouUwqlFxtGh9AgC++QcBXvrSBfzFz9bWEP3b2Fh8 8jdmquiZfhfhLvUCTOEvmsOn/xYCoAcMRylvwKgYgl4HSNUNStDiBUBLx85k32AchDaNyGIBPFqU QGHFAAg8AIICgMABArMu0teQ8/Czpmh6VTuVcx9va3GQgIpyMheD5XoUxT5Qvu68pDN175C1JTkS 4QRo4pWBYVFzxi4y/f3geIVgmy5/PeY1bpb6sqJuEjE9mQil7btw2O/+TX4pH+/Rcc++A2W5pu01 TCSa1VdecmltYH5OeiSwt2PdHvut9wd/p3+K6F/FclcuBAM+/7+po4XW9Zoin4XzEdu098a3DpG+ F75wiPZdujT8/8yZhQl8rP/b3BzDXwS9GAW8fn0s/pJH/27dWqSJRkXQ27fdSqAq6AkASE1bAoBa BNCSummNAGrLkYDOskzz8tAWjQSwp2OS33migozZuxYBzJdjjRxp0SZxXpSjfQB8lI5dr3F+AD2i SEbchLrCkv3wLgPAOS2zLva6sUYCDRFBk/fdCiKB7s6xMbnk7j+BmEaLSuVRr/i7FgXMpqMialoU UIwQtpoW5ChgHtUko5zJvqbzLh1rwueS/Y04Z+T/rSBcqEkYDMvkooH5PubRwFmicHzSooE9EngC 2pUv/uu4BIO1AAiN1UGLf/OCYe0jx/N0apwaWryJxHhZKFk2IQDzprcNtX7Pe94Q9Tt7doC+CIER BKMJfAp/sc4vjexF8EuFXyLs5ZHC1A5if78IAAHktE4JADkA0WCO69R5zNcRy+o5LPNoZu7S9JMA oHUfWwMg1cE2dOS5ZbDbawVAMEYBgYdMaj7Rs07z/wObqAx1PDVfTPKa0WoOjYIvpmmRfizfjSaU itL0ZnlDjSEjuN/K5Stmrp3QcLHpNbZUq5fup2Y0WqAw2kLJU1tHfZ/Fvn1k9FOYN91GTGDwJN+z XRjmpMFgCwAMpfO2hkPr9MEJhuA3rV95qxCXKdovHAPgffcBfOZnLqt+RkXQnZ0BCKMPYNyWVAQm jQLGCGBM/5RSQWMkMAJiBQBSv1FKilIKKEr1b9RyQEgN1X4z7pPFCsJTB2jyDES7mIzW6ZZSPl0G 8KUAiIZj7VQPzYHfk4KLBpELVMzdTXAEtCm7tHIyjVRJKc1H7FUPQeWxFoSOKQeSluPuHURxLbsn YTWlZspSBS3TWrbPoB5yN1ps/XCHAPXtl56JLY+1NGCCzuVjg3NdIlJqeXeeZK/ADoEnDQT/yt/A YgAMpQAYGltEgFMkxTss5VhOTd0f1Cxv1cyZ1P99z9sBHn4Y4LnPHaJ9UQE0QuDOziL9c2NjvJxo CZFG+dLvcwDMQTAawc9mAB/9qPslohq8ow5t1PcbluWAkqZpqHNr5gVYAIDeF69p39AOnhqMsqBC /d+Smkd551k6GpLvH5PKJ0UcyUEHizddoDtikqIoZGmiHOCh9UkleCGS15awzWjtkOZRlODzZ7PK 6WPN07+HDFfBhuqCl57LhHm75WFnhQiPEiUS66AEoICr97U8H9AJbDj9OZu89hZlVe53nzC7iA6B HQRhOancC3EWeCyASlFV1JOq6VQn9XgCeqDTU4to2p7CfbdsmxA93Pvp9w0AeP48wOXLAPffD3DP PUMt4PnzizTQGAmMaaC5jUNeC5imgaaRwNwSIjWDrxCC4awdJADMvxdtIJAGQzCqgHIv5RZKoOD5 TvImBHtUS1MC9S4PONiSUjstIKeBJ1MXxh57Q50fCYIWeLSCHAPEqADoqDNoMGXXrCGkKB8K6zEZ 0QvQL90I2rSelNGpO7iW+aXaq2IQruhwrxp8i8R/0LdPua1L0+MZiC5ZkBeIjnOB2oAd8rcMTnKC 6q69UnXbfL828GSOy3RhmBPeHvvNXw11Sp6NrR5Klum2oWi0/MOwieC2v6XFBCUA830/MIDexYvD v1EFNHr/pUIwaQQw1vJRAHj9OsDVq3S6J/VJAfHOHVcaqJqKqdQFaubslmVpdYMiaFUAoLQsdfoK Owi1DtAbETXYQVgA0CoEI303glijyAd6hURAF3VxiasYLRBGthCG+cVpvMtSLB2K9t2w397pSpcD UCYMIyrsGiOtVnGYog5xY3EYUqCEszmYWBzGI/bimZ9dLrNfkk0EZYWRHl/SKgJ0mw5RIMYpa1Br FyGOZee+ncQ8gRhfD3BgE5EIxPzXJ0QgpkcCT3gT00PDRACopYB6TOdDgUupJz00NBCOad1CzXb7 3/R7P/Bji4jfPfcsagDPnh0+sQYwTQFFXAbACIER4O7cAXjmGRry8kggFQVsAIBAwFgOgMB0oNh0 EoM/nguGKgFwVIZiiOyN0olAmEerA7SmnGrgqQGgcgGYYZEYCZd6yWpkEvhomyUNND0WQbuHheik JYo4MqdXhBZc6zA+Qj11heb1WGFHs6eoddmuBSywKyxO8po5xIZTLRTbrp8tGWDWhcJCxOcP+rct BF/XAAzvrpIRBJzshPrPWxd06hDYGwBc+ZK/iW6I09JHi8Fy4ldYiXm9B1RN6wtt9ytUvLWUiOLe 979riPDt7g7pnxEAd3eH6F+sAYxRwCgCEwEwgl9qAXH16vBJPQKpSGGaCpp+HHWAlvo/c10g6DWA rDooB1RSemglAJqgBZwKnkYAVNNQOSsIixCMBnooHD/rdNyxJ2oETSmiDGihAFLWeSmQ0aJh5DUq AKhF8ROYdbDnk0n1DG2e9GqKLKIyoCDUVInTGSAxcNvvkaAshQIse1WsFeRZcgDRPqnlGgvKQAwa BGBG9YZUHSIYRVgKd8abZq8RU7MocotloOH9ZuwvdAjs7YSCYGX9X016aCuPQG9PIoTymj33Cms9 BRtujrJ/e2/5oQHwLl4cIoExFfSeewDuvXf4O00DTY3gc/XAdzzeAAAgAElEQVRPKr0zguG1a8Pn 6tUhOhgh8caN5cjg/j7Axz/eBAAB5BRQYGCRAzkKJEECQ8tLaoUpoJ5aPA0ktUiiqxNa4gcIsnm8 uDopbQ/1SKJJ0MVy/lE4rsI2oeH25iIMgQEbr9l6MA5CoACUatTS04HNUgeDeAMY62iRV5ENwfes XpUAylo3XP1i0lTKkf9dwdgsleaZL9sNpEhYtOQDPTgeSENmXstK8RhcLiYRL+Y9H9tJEYjpPoG9 jUDwsX/9y8EPgBXm8lAQnQst53G+OarArhIgrdtjfZIyk+699YcXgi8xAphGAbe2Fp8U/tLIXvw7 V/28dWsAvFQQJk/7nM3Gb9X5vAkAsqmSAhgC8ADIAZ7a6UefdUOJCIzVugGMcGKKzqEupqHBpxmM JSCTRFE0ewdwpi0pgi4ScILBUN6U6mmxbJAEaEDxJBSOFXcNU+dB3R8FEqkLRJuWA2VufaOBCoNt xdq1E2yAZvW8Q0x8+hLDvnjoQihcLkyQ8JQsFAEgeFaSTuswC0zXw/199ziGNTnn6TYazwue4Fum C8P0xrZlGKyBPCiI5jUWnCmKJlaau6+NcIwdUve+48pC+OXiRYBP+7Th/5cuDRG/06eH2r9TpxYi MPENEMEvrf/L0zpv3Bh+iwCYf9KoX0EU0GLu7hWBKUrllACvAACp+TVQk6DLa09hAUA14oj68sTt KQRAcxqoEvGTpqeAEsEoOkMIm3DLz8VTlgYuhN9UkRZm202CNh7RG6cYjEnoxSm2g0in2ubnUBR9 QeN1xS2LAFi2hhQMwjCKz6ZJREYZFCodpxy9ajSBkUCLxojiJowYSsiVNvNoHTNd/H90L0qnowRd 4nQjoRcoEIZh5hltq7aP3PHIugTUcQ/AnAvD30un2ZKsFYouKfK3IHR50gB9vu/5b/MTJBDT00F7 Y9uVL/0KXDw9BFAqBcDSO78laHr2qRYAJ9157+wEAL79Rwfvv4ceAnjOc4Z/L14cxF82Nwf4iyAY LSAoAEwhME/9jGAYxWFiHWC0fIjzRUiM0xoBMNbqbRApmhtAp5pxPnBUmicHhlJtIAdwHGyxQMsA DyjQpRrGA68CqgGbaR6pNymAoXiMpDQnqABAahnIf6cpPI464EoUDxhQHMFW9j0S3mYjaCGUNrWO v/QYE+s3c0hE3R5De3RRNXdmYQc0ppChvhz1+8OIGq7LWH7LYrAGQjwjT1Srf1563TimG9X5AeHp h8T0pc9P5zRoPJaey1x6/rcwYS+1i0Cln6ANpra6nNe99Uhgb6b22L/6JTq3caXRQZjeDsL7/aoi g+Zpy+wj9t75niHdM6Z/bm8vDOCjCujOzgCDuQJoCn5pBC+v/6P+TtNAoxH8/r5bBMbi68dF7sjp BYCyirl4IoDSssEIkKU2EKWm8aVWECiBBMrRRXIaRQjGCoNiBMf5GwdyIzijlmepQWwQAdPsFUiQ NKxvtI1SBA0ZASXF9mHpuDuik2ZrjoJjSx4zyyAE2q9tCVY1oSAg7gtLZ7dFNDAwSjicTYQpKsjZ RCR/L02b/DbPo2yOyJ3VLoKL8Inzzunp0rFpzv5CinqOjh3xL2vJYT1nlnNPXSoVdhFiMUyQLSLi 3yc9Gtgjgb2Z2pUv+0oc3dmh5LbNntBNABD8dhCu9RfYUxQP31YCZEHb+8EfXxi/X7w4wN7OzgL+ og9g6gEYTeBzAIwRvjQN9MYN2gYi/cTfYkQwRhY98Ed0hDjhlg0QFEMFGNIAEA1egLUAqEX3tIF1 gAKxErSLw5g7kPn+TAmAFliWLBwEIRCq5gyJlMv8gGgACNz5J9ICVbsJNBrDM1GDEpN6MQoQygBG GjDgJi5S3yyIPFCdW7ZjzHWCC7cPj0EXFVe4HFz1duJyV4IVbcrrVjlhGBwLwzTfWWtYrfH5qz0X 3jpzLbPmuEcDuzBMb24QpKOCDjhp6i3YUggm+Hm2CuJq12U4FpoC6A/9xAB/0e9vd3dhAn/mzEL9 c3NzqAOMEcB8HWktYA6AEvhRPoARJJUUUA7AQAE6SgRGEoYxASAqdXcGL0AJ3NAgfW21VEDlBa4J vbjqCY1CMOZOvvHlDQJAqxEaA0iTtX4gABiMgZcVdBFga+Q1aJjGVPdosLTQoolUaisrqGKxmaCm F2DaNBDh7NFN5SNWvaxcweIoKVq0Uk3JlhMY43nza7WhmsvSovLlGnw4717Pwan9ks2HuOgWeMRb XDoy1okt8zdowbBf+b8TXQZHovVIYG/FMOi/BUNh9Cq0MX4XgcxrE+EBxtoav8aPpBBg7/XfBXv/ 4ucHq4cIfhcuDOmfEf5iCuj29sIDMCqBptG/PAIYo3kxkseJxaSfvD6wBQAarBskI3kvALIfbV5B vTSHAzXyVxDZq/ICRCcAIpg9+SQoHEFb/hvKKqEaeIqCLiD8pgCYVKsJAkR64QKdy7DaIVDApm0z Kvtlqi0UzlfRPoEzBTLYVSHBONDR9JFe8jpeBaw2WJn5HiipGcSxzQIXYROjQlSdn2D4Zx2cs+4f OpaDhkEj6Rx4U4fRUleJ5T+j8/+WAUWEQVcg/v2eY2wX0SGwtzIQ/PLXogvWVD4sMXEvSQ9tcS87 De89JvTW7a3wENz7n78N4HnPG+DvnnsAnv3sRSpoNH+PIJjCXxxKpMzdI9ylUcD4oVJBUwBMhWHi xwCAqgk86Obw2ovUlAJq6Ix7BGQoAAQB6PL9krZV6pyWmMFbO93ueZ1KoCaVUKYOEA1A7AkJiZFS Q+QNlGsBKdN3JXVTSxnlOoXSc8XreWgFgZLrTNtAFG8yA7Q5rULQeGOUQr5587j02BV3aVeRrooT LRQZI3hUDN61wUu1zxCcqcw4wcEpSANFPPzzptbETnS4jmLr6aC9VYPgY7/xvlBnMF8Kjk7Qa/Z9 LcSFupewFWQpC4h3vgfgRS8aAO/yZYAHHlikfO7sLP976tTwiW+6WMyQRwDzNM+YBppCYGoBQXkB pgIzn/iE2unUBGC0aJ4nBdQq5OIRcbG+jEDvt/o6zpZIoWLI7bWKaGkF4emMgBChLBGCIUEMHCmW HAhI9gFaOqhQSweKqikaBgRY2HRewBKYYgacAe0qreTyrUq3FuAvGwdoAksogWLtBkzZy/Xm0xHT 301dxMR43fgejvMu+dpF77/Ap2mmPnPPegcvBPKhr7NHhfLrKgTHIdOOI+PZJy6fme4opEU67A2b rCdGA+fHPDe0q4P21qQ99uu/GIqg5bB9AqdWFW3q91e3zL0f+9mF0Mvly0MUMAW/7e3hc+bMsgIo AB39yyN/qcqnpAKa+/9FINzfB/jYx8wAOII/sHn6qXWBQHT0FZhwp3Cint5pNYNHpbbPVZuoQKUV AJf2XVonKsu1mLyDogSqgZzR+8/tJQc8HJrmlVJJGdXMUp8767YUK29atp9blqbQaZ2OUyJltpEd LCj0jGRB3zstd586xHVwSnVQBtCKvAJhGQJFRcsgewly6pn3vGUa5cf/8F9cCiPvv7lBSRT47y2K oaJKKnVM8uMI4+/yc8WeN28XB+jltYgJBOpay34b/ZtNO4cFBAYA+PvHUCW0Q2BvE4JghYVE09+c oNcKJNfERH7vW98A8MIXLur8dncHE/iY8hlBcHt7YQFx6tRiOTkApqBHpXdSn1QBNPcJjMtmooAm yAN7BBDAbg5Pgpzmv2cEQAB/BLHUCF5bLrVtFgA0bRM6TOWtJu/AyPJbAdACZQ6gGA0aGARWxOms y/DYNRSAKGu7YLRYsArMQMU+lIAsQP0+eCwgzEbwHQLHr9RgszMQ7SEO/r74vYffif+jr7oUNOP4 ucHuIf49nwvHwXhsqiGQOOcW96qWIKjZRYjwJ0BgSKwiOgT21psHBouM1CcAx8OAOs9TcEKvwb3v ejPAZ3zGQvjl4sXh79T7L4e/jaRUOAJgjNZFeItAl6d7Xrs2tn2I0Jd+lwvBPPEEC38czEnpnFw0 zyIm0woAPfNry9CArVi9szEAmqKKBd+Za/1Aicoo35sgjJrPCUDadqKSDipG5RrDkwX+TECHfCqo evw8kUoJ1AznrdRLsAQCPV6W6r14nCEwhxIFdHbfeHQ66//Pa5OIYcgihiB7BgIQ3oJARwZH84U6 +CuJBpo0/krF5R0QqIFgOl2MBnYI7K03Dwj+2i8EPwBC++hgszTQiaJ9Uyw3AuA3vx7gVa8awO/y 5YUJfBr9SyOA0f8vF4CJADib0Sbwsf7vzp3h7+vXh08OgGkqqQKAOexx9X9QGM1rDYBcmmVJBNBS s2cRbJEAUAJYcZkof29R/bTUALLHBZX1OlPstBpBEyxYQMICdo7le8EsjxxWgWACdZZ9Q8F30Que 2rmdKlq4tF7FKL41BHL3RUsIlGBvnSAwnSaFmDPfdTw65//2bx4AIWMav1YpoQVG8Sb3sHWMBiZw eNxAsENgbysEwSnSQ1dQO7jqNNCKiOH8/AX4f/+n1wP8pb80RP4uXVqYv8eoH5UCGuEvrQHM6/Vm s+Vavxs3Fp847fXry9/fvLmc8pl+ZjPWCsICgNb6vxwSOMsIbR4WEBV4K40gegDQXbdXApUeAHSk e6rzemv9jB1vqxCMGwBhBWmgsJooIFcTWAtYFjEdaX0ABcuGijRdI+gDll+LcMwhkFK7VCFQgI8Q AHa+8/hFZmL7g0eztNEMAEfRPaX2cQSBYIsGlkYC3d2pFUOgFQQDLKeFdgjsrbcSGKyJABaBnnee NRGIcYHlYtrZpcswv3gR/r9v/KcDAJ47N0BgTAGNoi8R/NIU0FQAJoRF1C+mfqYWECkE5hYQuThM LgJz69ayDYSQAiqlc1ojgNa0UPF3BQBVgGRgzBJFpJZjAkUDAJaKwIAFXgvq/dwAqPkEghPWFKiR IIIFS6+ACrSrk7OkY1Zvb4GYihZR5OodTamdSups6fE1Q6AD7A4dAokvm6aEWl531mhgBiLb33F8 wY9rv/9Xx3WEQInICBCoAaEX/KaAwClAMHDXHPHvXfDLIDAk37+uQ2BvvRWA4OP/skw9dFUqoU2+ nyoyyCw7BJjddz/M7rkX/uPX//eD+MvW1lDzF2sAL1xYQN/W1sIOYmtr2egoBcAo/pIrgabgF6N8 KfBJSqDz+WKZH/0oe9o2wCYAw4GeFwA1gNOM3lmwM8AfCKBpBSuAwrROI1S6RWBAMf+2gFtjACTB xgGAKkg4gIpVpGyx/EZiMOJ0JdFJKK/vY+exQqoGYeivxdTgT71u8nunVTpodgPhMYJAAICtf37y 4C9v/8eXHaSLpnCn1AKy6qmcKEyhOEwrEFz3aCDA8QLBDoG9HS4MtgbApnWDjQBugvTQ2X33DfD3 3z0G8OCDA9jFNM+LF4c00DQCGCEwpoSmPavYUhVQygA+TfO8cWMc6cstIeJvMfIXl5tFAKUInAcA rcIwVhVPiweglN5pBUBxORqIeaDNCZUlAKjCHvedYABvtoIwfO/q3BvhULWQsKSeGn0HJeDyRM+K I2LO5XD1fwD21FMP2JkEXIhoJVUvycGdFdq1a468FxtFAqXpWGCcGAI583MJAje/vYMf1/7NlwxA 6IkAtkwHpborNWDoBcHgv/zI69AKgXdrBEOHwN56awOCK7OIKAHKCdNAK5ex/8CzYHbvffAn//Sb B6iL1g+XLw8RwHPnhn9T4ZcIgZubYwDMbSByAKTSQCkfQAoC0/RPwgfQGpmTxFy0SJxFAMYKgJzK pif90wJ/0rKoTpnFL7AFAIrbXhIBFDqzZshjIBI0oCuFMCccej0FW0HZKN2ygf1ECZyCsDyvsqp6 vpzH1nKMVei31AGiTdm2Q+DwOtr8tg5/nva7X+wHwhy4V2YVYenGGSBQmiRo3wW/QMzdiOAxiwZu 9tunt1W3K49+FT72/p8P/ltb+a1ppK/FOgoUS5k2v3AB5ucvwPzcOfiPj33TIvIXrR5S+LtwYRkA I/ylKaBxO+InVQKNAJimgaagl8Je7vuXTh+XOZsNf8/nKgBq0TwK5jwASHVutPRPDrrIzlEFAIIC axq0gXXaGgAU9tvS+Rx9l3dcUd9/gMrIINjTBcl9Rn37rJE3FiwssCFFsYQBBOC2Bek0QREMDPsH QrqkCBvaTahsawAADADBcB01BSDjzJ1yxu3Ut3b4K2lf+FvDcfudLxpqB5cusjD+bxQARxtrHU6b auNCdiy4f5Huqq31MSs5zD0S2NthtjEMSgqiheqiraKDU9YTEt/Nz1+A+fnzMD93DmZnd2F+5ix8 8O993UL05fLlwfg9AuA99yzgb2trAX9p9C8+2SL4RRXQCICxHjD1AoxQF+0fuEhgCoVxmfGTqYBy Kp8cAFqighTImQVgwJbiyW5nJQCazdQ5OEPldwFSuWWZt6vUHxCVY+PwT2uqFGq1PgDmO6fXn7SM qgig8K+35q1k+8zbqR2Pihq/FpFAt+2D06aEvT+PWyQQaJsIAICNb+nw17L99hcStYPJ3+m5aJkS arWKULtmMH1KaPp/MT000NHA4xIJ7BDY2/qAYGkKaImy59RQx36vi8fM7rlnUPu8cAFmu+dgtnMG PvIV//lC3fPSJYD77hsA8Ny54d/771/2/jt1amH8npq/AyzgL4W03AQ+jfpFAZjUHJ4Cv1xNNIJg kgKq1fhJv9UIvbT0ACxRAJUAUFqWCozWFNBGACjtlwsKS4APDJ5sTgAsVZT01qN5wcxlWeFNVy21 kdC2WZuuwr6ito7SU5dZYhMhXXesAJAD7GohkAK5QzeMB4CN13f4m7L91hcwQjIcBILPNzCHNRcE BgPEVaSEWkCwFALjd8cBBDsE9rYeIPirPxf8kNcY2oyQVjW98DSc3XMvzC5fhtmFizA7N8DfbHML nnjtVy/gLlo+XLo0RAIvXRqLv2xtLSCQiwDmYi1pxI8DPUn9MwXB1BdwNgP4xCdMAOgVhQEHGJLp pAK8mQVgQE4d1H73AqAIX6sGQPRHCiU4I4G8EPS4aSTIIyGiBCw84AEVnoJOELNCVomAS4vpNOVT CcChYPnktYHCNVhoBF8aCfROy97DawqBHQBX1/631yQWEwkQjmCQgr8M8MhomlYX6IFDJwi2FojJ QfC420V0COxt/WGwZa1f0W+NwJCYZ35uSPec7+4O8Lcb4W8TZoDwZ3/rbw/wF83e779/AYG7u0M9 4NbWMgBubsoAGFNAIwDGFFBKACZaQVy/zkNfKiIjAKCp/o+BQ0vKqLYsbT6A9YkAqiDYEgC1GkA0 bmtDALSAnisSUwBhLrCohDcOGmrSRUUwg3aWDxp0NhWZcUKXuG4H2KvTl8CiBnaK+NFRhcAOf4cE gp9/KbhSQg2poWYILO2OGSBQmqTGLiJk2ziKBgLA1/77DoG99TYtDB66Sig0qjVcfDe/eBFmFy7C /Nx5mO0OtX7z06dhtrkJc9yAeQD4s0e+AOChhwbIi3V/u7uLv2MdYIS+VAAmpoGmb/kIf7kKaPw7 F35JAfDOnQECr19fWEOk4jE5+DEASEX6vJE8zYvPZBwvwJsnAqgtoxYAq0VbLNM6on+gba9FHVSI dLjMtp3fW4BIgo3WAFibnlgV2VNgCbT9MByjfHkadJZGIYtg2wndEgxap7MOfNTUBK47BOI/6/C3 Du1fv/pSuAs2TDSQ82o01Qg2hEArCLauDbTYRRyXaGCHwN7WFwR/5WeD/6mxIvGYAsicX7wEs4sX YXb+Asx3z8HszBmYb2/D7NQmzABgtj+D2c1b8PSX/TWAZz97AL6Y/rm1NUBf/OzujtU/PSmgefSP igJGALxzZyEKE8Hw5s3l5aX/HgCgyeIh7VAxMOap4yudDwoBUFtGKQCWQh0LW2AANAMEogXsrN85 6wDdkRUNUgzLbyUE40khVNU+FT89y7Z5QSz9d6NyP9kUTwOIVZm5o2DU7gFnJ1ha4O64Q2AHwPVq /+rVi/TQEfxJkUADBHLdo7WMBhJdNioayHkGHodoYIfA3o4eDJZE+UqfQg2+n126PADggdDL/MwZ mG1tw+zUKZiHsIC/L38U4DnPWUT7zp4dbCCiwud99wHce++y6mf6saaApnWAueBLGgnkvP9u3VqO BDIASEXzSrz8vEbsKAGaAwDRAGOWNFIRBA8pAiiCJzrmK1ABNQNg6+9LUgmhMFLlhMTi9RTU93mX R25bQ+9Db41lybKLI3uN6gBXAYEk1CEPcauAwA5/aw6DjxwIxzAiMaJHoGQa3xACrSDoiQayfpXg jwZ2COytt1WCYNWTpJEpvGFZ87O7EM6eHYDv0iWYnTsPs7O7A/whwv4B+M2uXYNrX3VQ93f//Qvf v7Nnh4hfrAe8dGkREczBL08BTQEwhLEITA6BVA1gCn2ULyADgPjEE2OIWlH6Jxjnran/I5cL9RFA MEInC2fGZXLbWASAWocWFCN3BSrN0ZgSwCvo1LdI8Sy1jXABjgeAGoi8WKa/O40WofSk4TZI77Sk vxZfa8o1pkGgCK3cveqJBGZftrSJwP+lw99Rab/xeQdRQbCng0p/e8BwVRAogmCFQAwcAxDsENjb 0QHBX35vKHuKNKwDFOwo5ufOw3x3EHmZnz0L850zMNvdhdn2DsxOnYJZAJjf2YfZrVswu3Ydrn31 3xmifhcvDhAX/f8uXFhW+9zeBnjWs2gAjBCY1wDmaaAR/NJPCoE3biwDYJoqyqmCphYTsxngbAbw yU+y6Z8pOFmsHDwG8GoEzxABtNb/aQCogl2lVyDUwCLKUGoGQDRESBtEAGs64FZFSTGttBS4nADY SvHSCqYtlum1tkhBkJwe2qSCWs8bd568Yi+WdGRzhO8QIVADPWsvtwPgEQTBV10KSxEvg0eg5BfI daGKBNthYruISs/ADoG99XbYILgylVAaAgdD9wOVz7O7A/ztnIb51jbMNrdgPwDMbt+G/WvXYfbU 03Dj73/dAH7R9y9CXVT9jEqg0fcvRgC3t8cQmEb/ljYqEYKhwI9K9Uz9AKlU0RQCUwDc3wf8+MdN 3n9FdXwGERcv3LUQgJkUADnQAl2opWh5hvo/FxRK/n5GiMvPn9WbzZ06WAgHVYIwwvKLwcu4Tgtc tbSEAGF7m/jyVUZvVchkQM0cBTwhENjh7+i3X3/VkB5alBKqQGHR2HpDEGxhHh8CnS56lEGwQ2Bv RxwGC9M53U+p8W/z8xcOAPAczM4uVD7nW1swP7UJM0SYzeYwu3kL9q9dg2t/+2sWEb7o+3fmzPCJ yp+pHUQKgLn9Qy4Ck25jbgSfRgE5KwgKAOP0eZ1guuz5HHB/HzBVAkVakdNi1+BJ4RTB0QBvVgN5 Fe4cAGj1ADT5+lGdTSiIEDpTQL0AKHWUUahzQi2VTlMWnQAAqe1qmdppAsgG0UILLGnnwGJcry6z UGzFEwUU53EsW4VGZjruuj1OENgB8Pi0X/vchXqoCoHM31JXqjQaaAXBKQViAI5fNLBDYG9HGAR/ JpQJwZSlh4bTpxef7dOwf+99MD9zBuand2C+tQ3zzU2Yb2zAHADm8wDz/RncuXoV9j/1JNz8b/7h AvDOnl0GwXvvvQuDj3/TNxU/SB79zd8MIxuI2YwGwBTubtygxV/SdNDUB/BguTibAWQRQKv6J9V5 90IjQHl6pzV9VIO15gDoqf+zTt8wAij6+mmdXwkAW6eAUp36gg6/2y6iQaRNmlYFJSyLVmmG89UC MxosGqBRAz/zOW4hDuOYzgWBICvXSvf+YUBgh7/jDYOlNYISsE0dDWxtHq8JxMARB8EOgb0dbRD8 pZ8JvqeJHwDnu7sQzh7U+Z05C/MzOzA/swuznR2Yb27BLAW/O/swv30b5jdvwf6TT8LNf/iPFmmb acRvdxcef9vbJn9gPPre94YlJc8c8K5eHX/HGcKnn/19wNkMMCqBUgbvBCSopvACgLWo/6tN/wQD iObbVisAw9UCTuEDKKWsejz/SEC2iLowHXOvIEyR0IsTSqTlWIRGilIoFSj1QJoXUptYYJRGKTXf SM5iowXUFV6PpnRQh+IntoZAtIEe91sHwOPfHv+chWiMBoHk/0ObrpkHAqVJaszjcxA8LtHADoG9 HT8QbFDrd1fd80DgJezsDBG/09sQtrZgtrkN81OnYA4I8xBgvr8Ps1u3YX7zJsyuXYcbX/cPlpU7 D6KAj7/3vYf6kHj0ypWwZPqeg1/8O40cxr8Tiwnc3wd84gkTzGmiMM0EXArSPz0AaIE/aXlWqOR+ dwFjaQpogedfVQQQ/NE9bpoqpU8LZJVaBFhtF8AR4UuPBZbXwRVHMgtTS93QaIG6wmMOXvVYIYIq XqetIFBZ7iohsAPgCYPBVx4Ix4TpxGG031YFghIE3oU+ooYwAMB/1SGwt94OGQYrU0Dnu7sQdncH gZczZ2C+M6R7hu3tu7V+840NmB/U+0W1z/mNGzC/dh1u/J2vGdQ9o3jLgcn7YcMfCYT/5J8EsgYw /zcC4IElBMYo4Cc/udSp0yKAXMqoBQBL6vdWDYBFdg0WYANl9F+AycMEQFcEUPleAzUWSARYEoHE aNKuQYhrOU5vPguETZbumk/TuLaR26epYNBt+QDjcmwvBBZB3SF7BXb4O7nt/a9MooKlkUDfWPyh QCAFfyQMBrpu8KiBYIfA3o4fDL7vpx0KogHC9mkIW9sD6B0IvUT4m29vw3xzC+anTkFI0j5nd/Zh fusWzK7fgNnVazB/5hm4/T/847sqno8//viRehA8+rrXhVEqaGosH+sADwAQkjRQKQI4efqnwdxd BchCAJRgsgQUvdE/CyROqQJKHlvNNxD9IjBaBDBfblGUT4OBilpCEyQWmq5LAGiB3JI6RBM8W2v1 HEAOVnAsBE3PtWOxhzhqEKi9sDY6AHYQfMWlkINY07pAOGSBGGdKaA6ARzEa2CGwt+MPgsQ1HrYH 6IvwN/y7BbMLF2F27hzMds4MUT/EJaGX+Z07ML8RwY8nl4QAACAASURBVO8qzJ5+Gvb/x28G+IZv AHj6aXj8G7/xSL8oH3300ZCmfS6lgEYxmCQN1AOAtaIxFGx5vfsQ7OmaIuxwIOYBQLCby9d4AHpA T5z2ECKAJnXQhlYPTcRZBEiYEgBLllcVqSyEttpooBXQtPWbILDCJP64QGCHv97y9quvuBTWHQKL QFCAwBwEgxA1PEog2CGwt2MOgz+1pCAadnYgnN6B+c5pCDHNc/s0hO1tmO3uwvz0GZhtHYi9zAPM ZzOY7+9DuH0g+HLrFsyvXoXZ08/A7KmnYf7UUwP8ff3XH6sX5aNf+IUhB0CYzRZ+gExUj/zeAYDW CJ8ETyUAWBP98wBgy/o/y/KkjqAZ9oTOpqVjWwuA1k54ifBHsU9fAfxYAK8UkGoM6au2oVBYpSoV tLBuz5riaR5MAIPtxBpDoEUdtANgbywIvlyOCkpQV5MO6gHBFkqhmnn8XSjsENhbb2sKgr/4UyHs 7BwIvAzwN9+OVg9DrV/Y2oL56R2YbS4AcLa/D/Nbt2F+4ybMb94c6v6u34DZn/8FzP78z+Hx173u 2L8gH33lK0MaBcRPfMINgNS0XMQQQDF4r6jbKwXAHCBJ0FuBAAw7LdOR83gAssdF8/zzAKAH5Cyd 7ULlUAsAksvy1AIWAFNpZLJoeRW2F61AGhocT+85dwOdNdJIDFiI97FFUbQAGk3gaITADoC9WUBQ rQs0gqHlt8OAQBL+su3tENhbb0egfcMf/u8DDB4A4HxrUPoMm5sw39yE2ebWXcGX2e07MLtxE+bX rsHsmaswf/ppmD35FMyffhoe/9qvPXEvx7/xohcF/PjHTabunAm8RzUUoE3kTgJMDwCKYFcAgBzQ ucDSWf/nTv+kvjf6+Zk655bvjb8X1Q82BjcTLBUAm1XZsilYNkxF9YCr9zx7a/aKLUgqotZVtg/a oMwEENjhrzdv+5WXXwrNVEI90cA1sYuI/z+KINghsLcT1f7REx8MYWsL5psD/IVTp2C+sQEBN2CG CLP9Gcxu3oLZtWtDyueTT8HsU5+CX/2KrzzxL8avuHwpWAAQAEw1gxwAtlTubOn/V2LV4KrpA0cE cAUWEKP5jWmeqwZAFSCAN0EvAaKm6pMN6g5dEUEBVk0+h9L6Lema+T46xHPMwKicH2tUWgPAIwOB EghmX5zqANhbKQi+7FLwQCALe41TQj0gKEFgDoAUBKb//r0Ogb31tp7tH9x8OoSNA7VPRAiAEABg NjsAwOvXYfb0VZg99RT80iOv7i/FrL02gUFPDSAHemjwBlShTJjGEq1zA+CaCMCY4Y+bD+2RwqYA 6IAGj8iLuN6KqJwr+sVtSwvfwMYA6PIbFKZtFjm0TFMSqUOfmbunflCFuQoI9NYE1kBgB8DeWoFg WIE4jAcEW3oGWiHwqEQDOwT2dmLb62a3whwCzGdzmN26DbMbN2D2zFX4hRc83F+GSvtbly+FFjWA mmgMC1VGaLNGEScDwAoLCA0mXduGhVFBT20TTBgBlECJmbeknq5Z5E4BQaspuxcAS4DWve9xOmME 0Hp+1X1zivKIy1UgrQoCPWC3CmEYBQI7/PXWGgSrIoHabw0hkPrNkxJ6FwiPcDSwQ2BvJ7r93ZvX wnx/H+Y3b8LP3ves/jJ0tK+6J4kIZp0uLd2TqxkE4IVhvNBWKgAjrteZ1nlkIoBIHztxX7ym7g7A swJivp01aZSloFKcmph/N2FUrxiwC9JBiwVbvCmbBam3ZphzDDB4IVAbLOCec15otEDg5j/rANjb NO2XX3opqKAmwJ5LIEYhvVYCMRToHfXawA6BvfXWW3H76gMQrAXAtBOP4FfXtKiIVgEg2qCPWrYm 7lIKk14AJAGFg+kJLCCo7apRaqxVeayCu8paQNd6K1Mu3ce1gQqnNarXAlgl4Na2xxrZa6UMCpXz UhAoQmMHwN7WBQSDD/ZWlRJK/XaSooEb/TLtrbfeStvP/cXwgLMC4KgDDDQgArMsSmyGSz0llwF2 L0IWerS/URapAScAQgMA5I7N6LxRYh2NARCp6JfBOgK1eZEBF2U6FhCYY011qDUwAQICzFDJXDdg BVAvSGmrpEzRcQx5WkMcR3PNjTkB0iCPYzHkOeeOkeaTBgwA1rRQOU8HwN5W0b7i35VfZ9jimWD/ 2Twt94jDI3pHdQjsrbfeqtrP/sWTyMEQCUrIwJ8EZZryJ/jSP7ko3ai+0RCZBDAqhBLbyUGilBqr LgOZ+VDo4IJtegRDuibS86DmtQdyiiOXsmqBHQoixQgU0tPcvXYQfGqiDChR9XMiVErQJhCNRVSF nI7bVmJ+RBswUgqYIsQqyxfBp4CWQknnEf0dzRad1ZLWAbC3QwHBNb7qsOF9nb+PfuKzLq11umVP B+2tt96atK+596BGEIVImac2UABAsbMJDer/kPfvYz3+jCmo3HZYpuHSwNTaQlSOF1ZMjwTcowBq DgCsqQPTUhAlgGvpWSftQ5UVA7StfSxNB3XVEYIxCov8dedNNfXsg3RttaoJFNM1tRo/Q6onN81W h7/eDrn90kuX/QTVgRqjQIylLlCbpCQlNP07rQ3Mf1/nlNAeCeytt96atJ/+czoimFtHSN8DAW1s 2icDGRpMSgBIjpQZABCFFNRRh7AGAKXoJBqjiciDuTo90qmWJNhQx59L53SqZUqRPRTSPkfTMcti BwUo4GkNgNgOALnIJ3XxqSAHBoEUZUDFmjYqDpxIOZxgyASQZxePT4t2GOPuHQB7W4f2lUR6aIs0 yikubmvdvmV71jka2CGwt956a9Z+8s+fxByAKLCQOpFWlVBL+qe1lhCIaTmg46AOte1E3/JIAAT7 cSSXJaXigU0BdAT0TPonB3ejFFGggUWCEbbzYAUx5GHRAncAzHFCWRgoP5ccmXCpjt4IIHvsmehT EHo1JlEV1M+DufclqGKaUmIV6iNrbtE+OFTcAdVSWA3AaBk86gDY21qC4B85rsfGdYFTzKrVIa/7 zdchsLfeemvafuLPnkStBlD6m4QR4CNiAPZUUg9QctE/se4O9EiDdXmqhYM0H+qehZTv29JvDp8/ CgokSGTn1VQncQyJZARQgjvqHKCxbhCU9VHrVaanQBhQqKMsEHixGKt7xWm0mj3uBjCn9lrBDo0d MfR3/iSp+JV0Np09yBwat17fAbC3ow2CeEjTsc+gwvWsazSwQ2BvvfXWvP34AQiy6qDAG8uL9YFp Z1UDSyMAWoHOZeoOQjTO+DcK+ytuhwaAQkppqQIoGgCIVec01PapNgkOnz8qJZSFERzDZ1G6Jk6X VgpGUAUBAFFK62xh3SB1lJBW4gRlQMcijNNsVF6450f1QRN19bzbvt0BsLdjAoKrap40T6v1VNVz p0Ngb731dlTbj/3ZODWUUwI1G8WjUh8odBhNBvQSjIEielMCi8iDMvX2ELfDEBUc1V+iMZ1TAEA1 FRL5bRGX3QA+tCihRVAFjWAnprMyy2dho6FJOmiqmkSUTgQ/6mYPNoBCRW1PjAIa4My0XUoqqNp5 Qx1qD7t1AOztqIDgV/7Rk9jKXsF6/2Hxwn21gUehdQjsrbfeJmvv+WSWGsqAXN4J0+r6WLBDWU0U QY/SaWBpAkdj/R/3rmGjdVxkkYn+STVZyNg3jH6TIAN9cDdKEc3TJamPA7AsFhDIReEkkRjUBWNG 14iikCoK2hiuERcwUtAK4K7ZW4LEUiGb7CC6FF4V2Od8LT2dQS/IHXZHMHQA7O0YwCCWDvQ0blh5 f3MDrgjrmRLaIbC33nqbtP3oJxeqoZQS6AiABMARFTit5u/EMsWooBEWTXCnQKIoAGO0f8gBcgTQ QoSP7KzjONIoCbqo6p8oiMsoCp/x3w0GHFVIlaJj2YFlFT211E5QjgMjaCLCoeDbR16Y3NeasAvI tY5UR0dbP3djiVE21AdfqC9V/0FuPos79AQUGLQvgjAt0U5/SwfA3o4oCP5xw2u3cTRwEoGoDoG9 9dbbSWk/8sknUVK3RDTpP9D/otNMvrD+r8Qqwh1R9Pj/IW/nwNZRWe0f8mUp8ICod76tBvGm6BAa hWAA6Cgh2COAJLxqUUXu+BlTVYHYH67Oz+ybJ4j4ACjnQDnnmnonB9tayimrVqsIyKAwyqSy6gp7 c6WrCh0AezuG7bV/vL7XsKbYbLmv1zEa2CGwt956W0n74U8QqaGgR8UQdPN30Z4BZPVPC5iaYLHC /w+N/n9W9U+qYw4G+wcWDsEQoWOmFSEJBcjLYE/6jbwmKB9DLeKI4DIYX4JeDsqY2kK3ITwBdFYx HA3MRRgHOWVUre+jBgicXT009LZQGFgRA30G1dBD65kaV9wBsLdjDYIl6dkV0UBUBl6s82k10B0C e+uttxPV3vWJzFAe9c6bGAEEY6ROkM4vMXTnxFi8kOiNRJJQiGA2gNfsHxDl+irRvsCZ/qnVxLHL piDVU0PIedqBwVuQATutTpITXwEjAFI9CZM9hRcARZpjphcgVbWGEKARS92ZuZpAJ9U1sYdgfDlb tp0OgL2dABB0X+SN421euwjUH6Nr0TCE0K+43nrrbaXtv33gUuCieBbPPkn8xQRSBlA09R+xEOSg MP3TMr9BkASk35BfniU6pka7QBdQsap2ioChCYhIy9a2u1CpFIzbgVxNnFMZ1LUfBMShYdmu7dHS OxUhGXdqKnHtchFzChype8w6PzIQqN3D3P1ErWvnWzsA9na82/tekqRPGgdkghMEg+P71AYmMNOG /F9i+v/y36/Hvdsjgb311tvK2w98graPACMAogUAEdi6JLPoCsiRPYtXoTfSqaV/UmIvrCAM8NE/ yjdwBNpW2wOwKXPmHXfUTNEFtdARmApwMfL446KGIEQeFb9BAINiKtpAlAKa1gDIXh9IX8cuAEQm omcZdFDWQ4/GEOtSIo7ctk3aAv1fi61M3joA9nYSWkmd4OQ3Bhr7Caverg6BvfXW21Fp73ziSbK8 ygKAwACgZrDuEaURAZBYjtTBNEcdUd5nc0RQqN0Sa/g8qZuctQPIqZnaMgH0OkAOUk0iL/k5ciiL ikI4xmiVaJFgsNFoBYCjayevSzWE2UvEWiz1fdx6pOMrLqoyFwtbTY86GwaeGe9+caYDYG8dBJvd uFNBm/SM+sk1EYjpENhbb70dWnvHE4lYDBHdAgGqRp80ygMGU3mkl8ktX1MW1Qzgtagjap1oCkAZ OwgAR40f8PVXlto41+8KnAAYImXgi9oB8MBKwrEVpITlUh8Kurh1gDWKBkaAtQAgMLYgwiCCWawF +QELYO5zEydyiqAGr0Bkaiyn7hjWLqsDYG8nFgQdnoFT3SStagPXpXUI7K233g61Uf6BlFm85QGq WUt4on+W1M/RvJpCKPLiMhwUcimhkh0El/5pEoYBIf0TFCDTIEVLs0TGZkFINTWlYArLGkEiGEVm KKEYYOrogBbJUQEXCiKAIFtNiADIdVys6aBgM58f3Q+Cj18L83Ys7MCthOo8APhtHQB7O+EguOJ7 0mh7an6Gpm0dooEdAnvrrbdDbW9NooFUh00TgZE8ycgHuBL946CNesi7on+oexayETuphk/y99M6 7pKKpyO9EwrmMX1nTNXk0lM3UF8WB54gTE+dBwpoqWMricEg6ima5igs6GmJbAQwWxcogIbCKAwK NX2mex3lgZRRB0vbNgC3cmCwzhqKFm9qZzsA9tYbvHZvmvsAC58HazhW1CGwt956O1rtLR9nQLAQ AEGANQ7oqHWbRvxKon9gTAlVvP/Y1E+mA26KVoHseaeBB6Dxd1TEZEAQMzHCZFGqKPj8EDnoVgGc u2a5yKoRnkkfRYP/ITnoYK07tECdAxzBYPZuNW42d9jQ9lPLDpx12zoA9tbbov1nRhBcVUqoOato DUGwW0T01ltva9O+8dMuhRYRQDeoFUyvTmcQfwEwGrZrQIhy59v8fcnvRvNxC2SOgNVgFUGtl1yG MSWSnV473lYPPqWeTwMmyu5CnLbE5qFiPo9tg3cd5P2CttpDZKKQ+fTq/YrKM6DGIoK4VnY7APbW G9l+8cV6OmVwjQTZ7SJyGwrud84uIv3uMO0ieiSwt956W5v25o8fWEe0AkB0AiCT1klBYgvxF+TW iUoNHpf+iU4AxPYA6DJt1wzoIVPw9NQUogJ0jKIpaEqjnO2Edhyo1FQheqnZenBpo95IngaApJCL JeWS/8pW52cEOtNoO+rbZJmvVm3Q2zoA9tYb36wRwRY3JCrPCE1ISstG6hDYW2+99QYA3/fxJ1mF eirtUQRAEEAN6pQ/RZC0gB4w+4F6hMki/oLW9EwoU//01PR5psuBrrimEIBPPTXMTx0PCZg8XooA BoVT4EE3Xy8H96JIiwUAgVcsNUUOGcBn61YtyqBoh0Zqf1o2yWi+GgC/vQNgb73VgmAzexcPGII9 LbRDYG+99dYb8zA1R9gkkNJA0KD8icALyix1ANFe4kSmfwpphGJ9HxrBEMq8+yQ/P1BAhpyOgj/B UgG9HxCieIY6RRF8mYhbfp1wEcv8PI9ghYn4USmrYuqhdE1Z002NCrGWiDMJZWgDVAuEqXAr3oyH /KDrANhbb5OB4FQtKP/nps/f/YepEtohsLfeelu7duVjT6I2eiYBIDfN6G8hqselv0mRSdJXkEr1 VNI/RRN3pD0BTWmhhdE963LcUbocVjkABZBTRgm4IKFH2FYSuI2CK6jBYj4fGIRsiJo3ct+YdSDn H+mI5InHAJjtY24+NeLoVAYFqe5S6phN2d1S1EEtPdVzHQB7660pCLaK0ospoehIM1+j1oVheuut t7Vt//jBYYTMWgNoBkC0pWt4Uj9Ny0d5WreQi9aZLqjz89T+cdN5BV3M9YjG+sSm24E+YPICluVY s/N55ueuh0b7xV6H2jqhrE5RU8FlARV1Dy+23kdLm5WOtzIPAsC5f94BsLfeaholFhOcA0DB+VsL kRgAgL97CAIxPRLYW2+9rXXzAqBkOh+nUy0btNo/wUDeJf5irP8DJfoH+TqYqJQlWjfaloI6PwA5 VdNkNyFZOYCSUgoGERhQUluF+kkPKCHKtX2a4I04H9jM2lXVSu474T4Uax2N20iOvDA3nSllFRsa whtFblq1DoC99VbfqIhgy7rAFjepWKvdIbC33nrrbWhv+tiT6AVAEKbRIntU+qa1LtEj/kKlf5L7 w6Q+arV/HIzUAB5YAA+FVEgC0qR1gqCmaYWzkfWCZV9A3h4KPkzTW8FR2yfwp+h6bCSo+kNvxFAC QKDsPLLfqJRQqsWRdK7XZyn/K1UKbdJRPJjwfAfA3nqbFARbjuKUKoXefW6t0bHqENhbb72tdaNg zAuAwIi6oKGjiGBQHEUjdCIBbFL9n9ChJiNZldE/BLvgigkgC5RDSYEYg3gNWLZXEn8BO7iSgG4w aSf/FtbJAZUGjiMgI7bRBJ1UXaJSlydCnKBYioIYjOrZh46HifId1jyoCloHwN56mx4EV32TWQTs 8ufgTx2CQEyHwN56622t2xs++iTmMOiOAILP94/sfKL8EKe2a+l7pvZPEnIxRZmyfTR5AxLAwNX2 qV53RsAzQZcAjJqip1nZ1AqiIMOcKgbDpPCyEV1UPCGRuGYUAETgI4GW+sNcFdcUDcy2DUD3E3TX BEr3vtLbW6lQTAfA3npbGxBcCQ2i/FjRQLBDYG+99dZb1r77o0+iBF/sA5ap65HSP8lpDPNyy6PU Qy3+fioUGsCjOFIHNvsHE6R5t0FT9LRENi2AJBmtU4BbACsjsFLg0Zz+iYZU0GwbqZo5LaUzv3Gs +6h1krgOUND7VuNtZCKIllJDV6cw2H8P+XYR+33hOzoA9tbboYCgneVc06uKyWvYOgT21ltvR6KV AKBUS2hS/qRS3NAW/SO/M1g8AMhpmyy4UDDgiICBA7JE03Us/06DPY/VBaDiMwhOIHVE/ywiMGx0 DG37ZPJjBF2lUowAUlF0tPtekte2MI+1jrCoo4aV0zr037VJOwD21tvqQXDVAjEl5vGrTgntENhb b70difadMRpoAUBQxGQqon8alLLm3pKRPNUpF6JCIwAB2Qw+BwQJfMwAyQnMOODPHS10CMtwaask RAswhQXwp6WBivOAHnXMrwUxEpjDoFGkJl8GEGDG1R9q1iSWeUCBztqBpMNqHQB76+3wQLDlg6Ap VB7SU6H7BPbWW29Hqn3Tsy8FCfIoULTUEFIdTnGZChBSnWCqs016BGKBZ6Dj9xL/vZpp2P0Dozef o87RlAKqLNsyj3jeDQBn3WZyXuc1YPW7K05ztVz7Dv9C7d75/9s7t1Db2vOuP+/cSTBqk5UTSGOs tdLvC0WptEKoWjQWpWCTnvCARalQxAoqng/xEG3TNEmLIhREQeqFWLRNvkSQQKmIeFFRURT6RbEe mnrh1fbKG7/1erHX3N9Y73yO7xhzrnn4/WCx5mHMMcYca++152//n/d5QnEUv+uo98HLLCtNnov3 83onAgjwpPzTD969sJ4NZgZaz3tzA7Xbjx57uHOqmYEkgQBwUagNYhYfzB41SSkIYGXtnyS2U8c4 eKJmpWrip3xR10yv9NMSJXd9YGEbmUjtSgmdMj4is7awtH7RGHthNW+ZLSHNjAMx50t6stqcDrdG N9BsV89WKNOM1hCGAuq9ThwB9D7A9fh3zVYggABPT3WNYFv5fHl/J/4tgQQCwEXxw7+ot35uLf7g qY6GaIUyTzkswzQHwYtTzumUDGbn1LnyGO1HcuMUSuvoZtcEtoIwOjMIU+f08LUzvpvvdZSvqFNq cg1gMz4lZOUv+vMgYne4FU/monWLEnc8tUqcsx920gncuF/reiY+cLUNPulpm77zUwggwLnwbT/3 Yv7w0UnODXxKkEAAuDisURGj6FkCOMrcwZeWKFrdQJf7NT6oR+MbtA/0mUYx7lB3Q6R2hcYo2rF3 lTl+mXQuKX+msEkyaZRYqLXrl1rz1xID5IPzluH8ln+mvLV4XhKo/Zk8+HPrrFsMS1a1c1X+k8V6 vYi/H+s/ZdIfrGbkTXtNYdVMRwABLkMEt3W9g88n0e8ga15xa6drEIMEAsDF8clFGugKoPHd+gWu lZkdJB2SKP0UuxFINNevlLbNpHpS35dEZaGZ/Ymfwu0yZZjWUPjmCHDyfYrkUkBv6HtqgLwjkAfX OlkGaiaBijxWhtC7x/Veoxzf+rtn/Z1LS9zkR7lWqSOdPMYdAghwviL4+un+frbE7acACQSAi+SH fvF5CwWw5RvHmGMfsqWd4nx41/aXkCBVDCWZDCbLQrPD2tNr5TJjH7wRFVKTSlP6BlGxhsxLRt5a LH/W+j9pifWDYpT2in1d3P8AySSBifM1mxotxU15jfV3xpLIR/ebf+yyJG7woQ0BBLhdETzGX+Sw u/mJfnsggQBw0bSKABolnVH6J+KXdor4yY3Z/j9otDK7Xi6UPm2dXEX6RnndBUme14xlxVxBTw7D uYeSaFQjEpdiNiPRasbIkBY3R8l05HTnRjoSl+pc6rxv98ORtgbGWgcYdNMMO3FG5xOsx6k2Rm+F 7e4+jQACXJMIrhK9ybWB/+SV45eEIoEAcLF84svPm/cB0PqlrM7WEyPJE2fGmyKHqbJLrWxT4pl+ B9vMiFUh8fPW4clEKWi6BLXV1hVGs/ystFG9jonOne5QdWN/VumoBK+TQvmpO7vQkq6g7DQacaJK 70LUyjMCx7+zziiGVR/QKlZX2AYBBLg9EczGiTMD5JFAAACDH/zy8xbOCLTKNsX/MNqMNE/EXvcn YpdvqkIpiSYmsiIFnJWuzGu94+1qSWGqM6rzGsm8N/Gb5qTX/xkpYNjV1TjX7BD6cR/jnyNLYkUO z1v7O6KuIRRdQL30MlMOagpgm/tElPlPoJLYVWDcMsDNi+CaXzXdeM2x08C38GMHgGvAmwPYxBmI LXND3cWTweUHaW9/VqMP5bnMcPbMftxtJo6ZGvYutUHs2miB6DpG1z96v9lySlNgvHJKcQTKO07z 17J6jUy89SWz5159HzMC2JLvQfsQ1ZIfwNb+l79VBvsuUkCAqxDBL7z6WL5a4v96MttkX7tmX6Xj 9s5/YQHA5fOXP3DXVQFswVrBxAd9VyCb/gG9In0H5+mIljvkPSli3nbp/TVHgDeWwEpHS5k9rhQG oa8UqKoETb0uELKp91IQ7pJAF66bZMTOW4PTDFm0ZgYmRRcBBLguRhGUpJh177F++HxP3P7uLx3n 9wtJIABcBVZDiUgAtQ/JJfmzBMb4wJwVkUoS522Xla7qfjdJAguCnPo5Oe85c9w14qX92ZuSSKkl b9qfyVQSGEictxbPFcDmJ22Z9y8bCKAkBdDdX/LYCCDA9fFtrz9vmghu8Vklk/qdIg0kCQSAq+Gv fuDFL+wo8XMTMgnSwEQS5cpWQXw2K9VsdeEyxxZUJDBzvdYmfxMDzTPlpmURdGR17b5aQpqi8zf/ 4yN57IzAqR1EM2sAZb4M1JLAbApoSm7iWouIvPszCCDANbMUwdkk8NHj/XC7p0oDkUAAuDoR9Eoz S0JoCUZSeDLr/apyt7n8ac9bM+SGfVaEbtPXJMTHFZZsYrmBtLRsghYJWEEiI/nLvJdMEmhJZHQO GZldI4CnkkAEEOC2RHCNBL58riCBy/vHkEDKQQHgqmiTCWBLJBwlkVrKlCNsGWmbKdWcSf5mj1sR Oje1S0ig9nOZEcLS9hvJnydAUclrVp7CJLD4XlokR8FawNR7SFwPV/6Wn5aSzXIAALLsS0M3aRDz sMFyO+t2an9rPi+RBALAtfHxX/VQFuolgNo4iEDyVDEslDPOCpgpZkeSv2qTGFfetpTAlcKXLT3N HDsSv6z8TIlgIE5ecpcWSOeYmZ9H+H4SQpsWwOQg++b8x1FKlhf7IQUEuD2+8Opd36Qk9OFOJgFc 3t86DSQJBICrI7UmUOy1ei0hHrOjHiryF0lg4Qa0pgAAIABJREFUWtKc52Ty2JJ93xNNXMoiZ0ln VQIzslUYv5CSP6eUMjWGodrQxXlfpX0UylqzglUu/ywIYHp/CRBAgNtknwiujs+6/rvo1LEcSSAA XCV/46sSTWI0AQzkbvyQHpZMVrexxNCQwOkGM4XXtibzqWIkjQlhnGn+EknUZmMfHEny7pfKRxPy Z12PSLysP9vqOU1Icer6Gu8nI5FZUXSbhmbXUIrIe34EAQS4dT6f6Brao8fOYG0gEggAVy2C1hpB TULCtXuONFVn6GVESpWySkK4Qv6iY1jbedfJHKHR4mYj1Y6hGVE5xuDzijCl9rPRWsRQuoKRKFNp YPL9BE63WgC9l1SEGQEEgKwIznQJzYggEggAkOAHfvWbA+S9JjCVx0qyVJG/yWSu2hk0LZ9JSQxl U448s6/YPVQkt07R7CSZTMpWiVskf4XmKxnhKsttcD7eKIpIitcIoHWergQm1wMigABQlcGMCFYk cGsR3PHjA4Br5WP//cUvyrZI+tTbgyAefLduS5zIpb+0YzaR3U5kt/jedg+PK/vYtcPntMfU1w37 f/m1e/M81O/L11aOZ1wDafp1WPUliWN755LY76PzlsPHlvs6+PMx7OcgmVauzVJiXr5ODpNt7dxE OZ9IttvyhjM6pbVDcTyVADZxRkAUHgcAyPKR19cJWXPuV36fTR2bJBAArp1PfPWLRDBai1edr6du X03+JEjxZhrHTDaIscpOveM9kodK05Y1IxsSJbqR1KTWH0ot1VL/gU6uJ5ztwOldE/VDQyHhnE0Q PXFrhfJP6/qnhW5lCri/SQoIABFaIhjODFzceIpOoXQHBYCrxxPAUaA8eRKxSyzXzvWLxG5qXENG /rLCmJFAyTeLWdXsJfH6rHBl5utFopVt2LJK2GblNClxqWtuPJYalSH2ezT9ref/fucerIMAAkCG j7z+vI0iONvxM3rdVr+USAIB4Cb45K95s0lMRuSy3UJbyzdpmVq/p51fQSZdcfSkLdtdNCF+B49J LfELh5LPrB/09mH8K7smAcxKqfaPfDVxa835sJBJAqNrZYlpi2Vvphy0LICJY2RE/70IIAAUqSSC a5rEfNcGSSASCAA3wae+5nBkRKrTptjljl5aF+03I1hhV9C1Emg0sgnFVAqD4YOy0UgIq/PxMuMi LBmJ0kBTkJJylZKthGCZKaB17tlzq8jazLzEEwugt00kgQggAGwlgseQwC1EEAkEgJvh019z16sC mHl8U+lrufWJWpMRMSQtI4nqa1Z0CNVELppHV1qrF3T8dEUmkQB6zUgqs/ui/W697q7S3dTazxrR jQT1lAJobRcJPgIIAFuKYFYCqyKIBAIAFPjMr30sgtHavsq6vkxCl96HJ4eJElF33mHLS1x5+Lz4 IyE8aaiMbFgz7D2TRGrykpWatqaUtLimcPp8KknnRMppXb/N1rIkHswkmEggADyVCEbD4zP314gg jWEA4KawSj1nEz5V/KJ1hoUh8FvJX2Wd4MxsQe31qgwawhZJYEo4CjP/Sg1kApnJrC9z5S+z3s4S 0VaTrnQSmDyvKXHeWgDbdvtEAAFgK7RmMePvnSiKm20uk/q9RxIIALfGj37twxB5ZT6fJ1qZsQzl 9DC5z8r22YQxM6Q9+zp3TESQ0lniUR5iXpHAcR/Zhi+WHEm9XDMjk+n3npS0rKSmroMh38cQvxkB zDbF2W/73h9FAAHgOHz+1bs+mwaOj22VBpIEAsDNYTZ/CQTQ684ZdgvNlIhW1hQm9229R1UAJUj5 VnQK9SQwVZqZGLOQLfn09pESreQ+D+5OlH+a7z8haavPr7CuMBJT89PLrAC2wraBAAoCCABH5iOv P2+vKangMZO+8HcqSSAA3CJ/85XFyAglydMSuGgUhJscZoVODkdLSJtLCg+OI3FipyVkafFbikSb WKsnyYYxmX1lxxdMzMWTwn7d4xVlayYFrJxjVs6tc7LkL3TAxMeQVQIYSOD7EEAAOBGvGeWhlU6h 2v2ZNJAkEABukl3zZU59TJIlo05pqNfkRZWn7JrFRLJY7vbpyF9lVERWAqvNXsYP/GEnzWT5Y6kE 1Ntv9piOaEXyaElPuQS0IH+Z9Y7meS0+vLRI6nrW8IKnEEAAOBM+qiSCmThuTAy3SBBJAgHgZvnb H3yRBmoC6D1eKcvMrB+sDmj39j87TH754d5bnzc9KkJypZ5ZYaw0e9HEpZIaVkXNFJKN1utF5z8j bLOSGl7breiTAuhcHwQQAJ4KUwST4yK0x6ppIEkgANwszVnfp64JHMstE9JYSQlLnT1XrEHMyJu6 TvAYMwItSSmWkaa6aWbHPATrx2Y7c5py5YmaI37WMbYUVVf8EudnfnIp/2Xd9nUIIAA8JWMi+DLZ K0Z8axJBkkAAuGl+7Ose1gYm1/W9FLidI42F9XuZzp4HAjicY3rYfEb8gkYta7qEpgVwPI8mq4aW h50uC6nXJiIo8ciLlKwmzrUlzjF7rDBBVI4TTks+th8q7wMBBIBz4TVtluCJ0kCSQAC4aR4JYKZk U+zyUC0tnErsMiMeJsZOmPP7giYvmwngKEeTyVy6e2Zl7IP45aRTIhgcc0tBc6+NcSe7hm46DZT5 /93eRAABAM6cj77+Qtpee/XF6KpTpoEkgQBw8/ydX//il+8ohKO8HQijU/bpSZlaJirFNYHFIfKP 0kYxBrl7j41ykBBKd19ZSZtoVLKJBCYto5L+meeaaNaiClbm3JJNa9aUlWZk7BiJYEs+udyOFBAA zpXXlrMET5AGkgQCwM0TNn6xkr9IHDPdQxfPewIYzhqMEkdF1DwBdGfxJbqNWvuqNjiJyiY3baKS lLFIBKN/fSNp9Y5faQAzLapt3b61TylbJ4It+QQCCACXwkdff94+ty8PPUEaSBIIACAif+/rD9cG Wgnf8muniZ/TWEYVtYmuoNZ+yo1hhuOo0ra4be2nKoBr1vil5am41m+qy+XEOr3UsSZSukjMKqWq 4TU39p/pe95FthsaHzzREEAAuDBeimAxDVw+nkkDSQIBAMRf3zdK166tKw2N5viF6wOD5jKZpjKm CDq3MwIYSt/WAujJzEoJXC2CwQ7SHTudc4/KVsvrASVIRIPr86ghjPFf001EuvYzC8TQnBIRvHcE EAAuiW9/WCf4uVfv+lGbapEEAgC84O9/w0MamJDCFohgRtaidYGhOAaC6H5X5NOTteh1lkyaMijF GXkTXTijBjLRsUvm4ImgYyhVSUuXZiauz0wSaMm29kFl1TrAHl/vzFMIIABcMp975U4tntgiCUQC AQAe+PFvfLMkVBIiuNuPiqjInzGX8OX2lpxVRFDETRpTHT6V+1UBrDR4cYXDSfpciSmsbRtldUYE NxU0Ryy9812zv/DaGdfHK+/crCFMRwABABGMRLDSIAYJBABY8A9+47A20JDAsSR0t1PEUSsVFTux C4VPCqMkknMHZ+b5tSA5DJu5VJqiFEo910qgtc1WIhhJVZvcd0uc7NT1K0hmJHtr1wGmrz0CCABX KoJbp4GsCQQAWLDbxesClwngzpBCd11gQvaksNZvZ5SYZgVQWyc4SseB7BkJoDdrb3Y8wmYCGJhW Ze3bjDxtIWZpGTRe2CbP30wy+3AzWgd4JBHE+ADgmvn2B6H77CtvDpe3fqXuH//JV+66J4IkgQAA A//wQ4k0cKekgUZ5qEg8OzAzAzB6bUUAW6I5TCiCSQFMz/FLykcrpF0ZMZstkVwtJa3eCCbzXjPn 0CbTyoMPH8NHiKdIBMe3QgoIANfMUgS9X6dd/DSQJBAAYPxQqQjeS6nbGeWgRhmoK24F2bNeGyaG lgwO8pgSvoT0eTMBQwGcXCNXSvnWSKB2px9fLqNyzy0ltjRMXg7TvUwiKE1kq/9/RgAB4Nb4ji89 b0sRnP79SRIIAPCYn/hNRhJoyN5uWBuYauKSKBWtiJ9UOoWKlDqDeqMWNkn/JgaYW8epStRUmWdh o9L+28R5TDSxmVq3eGB5bzKTCIqsF0EEEABumc8aDWPG38VWGogEAgAo/OPf8qYIuuI3pIa7VhC+ ZKloJeVz08NI+qIOnsb9ME10HltdDnmkJiwVMVLn182OmpAVawrHB3teMKN9tUDurE8iqU8oAR0B BABwZdD7VfqdSCAAQJ6f/GY9DfTkb/9YZoZfdoB8Zo3ggewFAhimeJnmLY4AZqQrOyNwjfyJzDdf KcmSFAeZJ+WsJU/kGN1Lo/ealcCUCBalUBBAAIBH/FRQHqqJIBIIAGDw2d/6WAQ1AXzUDGZIDR9J nieATnlnep5goruoiNMptCiCqvR5JaWOgJXLIGdLLo8ogFUZq7z/dsT3VipxHcWvIILa9ltJIRII AOCLIBIIAFDgtQ8fpoHa+j9tZmAq6ZvtCLpiMLy1PlC9PViCWcpZXE/oiU82/ZqRrrZSFVrCUbYs M5Ut5NAQ95lzGiWvmghOi6AjhAggAEBOBkcRRAIBABy+8C2HawOXpZ9WCtgKTWHMdYPL11ZFLxoR MbzOlMBIvpID4y0Ryww630yyjimBXVavNwzfY9Ot82gJYELiVDE8pggu9o0AAgDkRXCUQEZEAAA4 WCnfzpgV+KhD6Ch2Ew1iMh1BR/nKNIXRRDCc32eIR2VAfEbKyp/s2+BIfXsBLO0iK2ZBHelUOhgN ZJ+5Dt0W0XFMRIsdUNraERFN5H0/ggACAFjshc8rESUJBABw+Ge/80US+EjsWjAo3ukUqiaEQcOY aBTE+N1rGhPJ3+zcvlQzGeXOqk/yGdnqxxVAr/yxZa0oOFjb+C1VXpst+ZwpDZU+NzceAQQAyLMU wWUaiAQCAAR88Vvv+sH6v51RHqoNjB8lcBDAR6IXNIRJl3kmS0cPBM7rVtn8x6LZgK6EOEPQx5LL rQ0gWuvnHS/6JzRqJpMSs+a8UJJJZ6J7TTPeV1r6JkdEVD6FIIAAAPMiuJRAykEBAAKeLRM+ozPo y9uii6AnfGpjmKhRTCR4K+UvHF3gzQy0ZFAxjswn+upYiBkp22r7tfttK0/IlM7iesVlyeb+592d MtDxNeOfFVOWm0jrsbsigAAA8yzLQ/e3SQIBABL8zEfuutsZ1EkCTQFcMUTek0F13aDkx0Nk5CvV KXRC+LYUtK06d3oH6BvtZ7MS2Q2u4aMUsJgIuvMCe/IHpfBeBBAAYFNIAgEAEuwS8uetG/SSvnCu 4Ch6s+MgkuMhQlEwSj4zoyEebVL9WJ+xun4imVq7MC+qN7WuXw9eGjWGyZqhUXbaE41huvPzVkWw +T9nBBAAAAkEAHgaCdwp5Z8J+WtKmegoe9EcQWutoEi9acxS+NwGLlH6Z8hgqwjNjJxUtjlWoYsn gF2OMlDwpVwF13L8mfbCZdyneI9ELpA+Tfy87p/77qV97c8ZAADW/ZNKOSgAQI5/9V13fZTAcWTE gQQ+yKOskMAp0cuuHzRkzvtQHg5/z4hK9kN/1++mX7L1P3Hdd7ujymdFRifPxywF7f62mfvjOWVO 672fIQUEADgGJIEAAEl2u8O1fztrWPzOHx6/MzqIZge/l2XPmxU4yFimOUkogrJRQ5ch2auGgdIS HSq3lK7JMtHeC+WxD++lZxPWljv+/mcY3X60X6cxTEs0hOkIIADAk0ASCABQ4Gd/75sNYnZGKugJ YtQURsROCw9krzomwrudkLxI+pbHnvCQrPvkSy7TO0y+vCfOa/Z99YQ89/gwbjVsz4ng8na5MUwi MRx30BFAAICTQxIIAFDgWdAVdBTBcVuzW6gngXIoj6oELgXO2GelgUsmmQpLSoNRE2lv6olksSWk Qzu3rt49tJ2NtGSUxnRTnqachlMf25LrEHu3fyDjqAhtPaAEiaG7DnAxIqIjgAAAJ4MkEACgyL/7 noc00OgMqpaIDrK4lDzt9iMJjBrEJMZAuDMBCxJS2WbrT/Llss5ek0znrrujbBK4WVnqRvtR077k msCp9YDez+PhifcggAAAJ4EkEACgyDNtbeCQ9I3p3yiLjyRPE7xKY5jqTEDF0FpgbSUZTDSSmRG/ 5Tn2THq3vx6JMkoJOl6mTrT576GtvRjLN9HihqNZOXXX7m2Jtw6wibzn0wggAMCpIAkEAJjgP36v sTYwUy6qiF6mM2hUOup+X1jCKCPZ8k316arwrRjhEP5zFcler6/7y4iUtVauSVGuenDNenBeSXPN JoB9vKZbpIHGzwEBBAA4LSSBAAATPKuK33i7IHuZdYOa8FniNyZ2LW18851Ds/v3hC6cMbd/P93w qqask1O22ayTqBQ7frZg6WF7LJjqxsE1teb5qWv55PGSw4PkMegGal7KIRFEAAEATg9JIADAJF/6 vhdzA1X5W64XVERRnA6hqgRKoUtoVgIzIli2wOL2mX+Ceu6xzDq+3pOHCrpghvudWI84W95pNkvt /rl6ieDsvMDydegi70YCAQBODkkgAMAku2cvpO5lumfMBtw5swNF7CHy5v1B8kqjINoJxG6LfXVj m24/Zpaq9trpHLs76Ox+tfSvi55uLv9TIJJCq6Nnel6gt69gHiACCADwNJAEAgCs4Oe//67vdi9E 8CDx2xkyGM0B1MpEjcTPGjTvilalhPDYUjiTBPbJ/fX8cUuJ1vhcphHNxNrD8BwT2z76vjhvNc0z np+5r12/d38KAQQAeCpIAgEAVvDsmd4cRksEoyRQWyeolY6KHHYHfSRis9L3FB/JM0Pfx0TPS/iy 6V+wXRsjwSDRKkvvymvde7DeMHOui/d4MA/QeT51X+z1mB0BBAB4ckgCAQBW8gt//K6/lEGtUYyS BkqLU7+lCI6Jn7RBJlogVpX07yk+nq9J8CrJYOX1Pb9dOgn01jIm/znulbWOSpo3uyYwPO5wHaxZ ge9CAAEAnhySQACAlTx7dpgAah1Bd4bkeV1ClwIoSwH0JHDmfpYtP75H6/7G57roCd7aZHBNR9Au ZkfUpgle8/cTXq4hAexOF9LeH59EWxzG6hKqPba/rXVnfbSvxKxFBBAA4DwgCQQA2ID//Wfuujkz UEkG07MAmyF+UQK4Ng1cI4Mz/6zMpHHVtYHVRHE2Rey169F7sHnPvW7cfi+Ny+9brAl01/sFaeC7 fhgJBAA4B0gCAQA2YLcLBsfvhlJQcbqEaqlflATOSOBaEZwRREtwrCTQWw9YTQCjxK8F26vD8oLH EglfiyTWWjfZDPEbr9Hi+8tUT0T65JpArQPo8ufTZEgoH8QQAQQAQAIBAK5OAneFAfKh+GkSuHUS eCwJjITPOn5PPNZ18TCPMTEmYpP32ZLiqUhii8SxvxC4Ntx/+Xa76n+Pvy+k8OX2TSkhNUZCRCWl 4/MIIADAeUE5KADARvyfj931nTc0fqcMeY9Svi0l8JQi2Fduly0D7YX9LtO52WYyfYPtK/tKHOug /LInSkGH13qPac9l7u9fd/dJBBAA4NwgCQQA2IhHHUKV9G8vgSXBi7YRyXcIPScJ3KoM1Er6vHLQ sVzzXPASQCcRPUj/jAjw4O0rTWPURjKLhHBZ6nkwNkNpDPNOBBAA4CwhCQQA2JD/+/GhQczu8ZzA UPKiVFC7LSslMCOCibVtrlRNJFzm/ZmREd34nt1H3+Bcq9eouJ2XAoapoNQTwuXxtcYw7/whBBAA 4FwhCQQA2JB9GjiuDZTqlziPWcK3RgKt53th354ATSRcB/ezzWG8Zi3Z5i6nRmv00grb7Zu+yEM6 1w6/j9su7x8kfj2RGor+s2ld5B0IIADAWUMSCACwMf/vE3d9mQDKbgMJFIkTwC0ksPQviCF83mPW c1skgdmxEH3DY1Zel71O1aRwWOt4kPhF6aAkU8DkKIh3fAIBBAA4d0gCAQA2Zp8GSlUAZbH9JUig t98uua6d47bZJDC6Lc7z5tR0OW4i2FdcfycB9M57v0bQSwUfvXXvseUawGE94H4TBBAAAAkEALhJ 2p973uTTd/2l0G2ZBI4yKLLdusBjyE53jpkp78w0hGmBeM7KXVY218hkVAbaA2n2rpUjiKnq2KAs 9EAK+asPAIAEAgDcNM+KAriUu50jgU0RqrWzAo8hgdrtrPxYMhhJnSdjidRslTBWZW9LwR7Oe7ne bzkY3k0DnZTvYP/GJfqKHyQFBAC4FFgTCABwLP7WXZdqWahIbT6gJ31PmQRWZLDy2jVrA601gTNr +vrK91E5ljjn3e33VukOWl0T2Ifz/uUIIADARUESCABwLHYL+dutkL7Z0RBPIYFaUlXtdGnJkZYW ZjuGithrAr3075jrBqO5gNk1gIUy0OhSWCWgj1JEWXQSFQQQAOASIQkEADgmP/awNjAzI7AqhJrQ nYMEavKW2c573WxCqL3WSwVlg+NkzrdyTO2cu/N+ZtJAq/On1xm0i/yyH0AAAQAuEZJAAIBjEq0N lJUSmL19agkcY6ZRbLLNYLQ1feP+RXKNWyqdQkV5vch8EphpAJNJBaPuqcP1UdcBapdAWwcYgAAC AFwuJIEAAMfm7951eeZIXlT+6UnjuUhgJn3LbJ95/UwqmEkDZ/e55j1kjuUlflG6Gc0IzH4fbv/S v44AAgBcMiSBAADH5plsMyR+KwncQgR7sL9IgDKpmJXUeY9p79PbX5dct9FqAqglodb7rVzvTAfU 4T2MaaCWCnp/TpZdQ6UjgAAA1wBJIADAKfjxh7WBkhRAkbkOod7jx5TAjADOrA2sJoGZ9M5LBUXm 08BMAmm9T+t2lPxtsDZwXCPopYBv/zgCCABwDZAEAgCcgmhEhEhcDpqRwFMkgVGSlZFAr6unJkrZ JNAbIp9N9bJrDY9x7cQ4fzHOwXu/y80SaeDB2xvWCSKAAABIIAAAbCWBIuvGRJx6VmCUAraEDGZG QzTxR0V4oleRuqacY+U1GazXWe+hUuqakVWjLFREl8OxScwvQQABAJBAAAAo8vufN/lHd90UvtlU UAq3txDAjARaQtMSAqgJZKajp/dcN+R4RuYyorcFWRlde1wrHVRkEQAAkEAAAKgyOytQJJ4TeA4S 6I2FsL5XyzdnRHBmKHxWtNYImNU0xpJBceRZxB8boY2MSFyKJiJv+2ukgAAASCAAABxHAkXm1wVW RPAYEmiJX5N4ZmCmJDIzfzArgJnnPGak0usWKuJ3W83IZ3PEWhNB8aVwPzvwbX8FAQQAuEboDgoA cEp+6q5vuibw1BLYE4/15Pfo9sx+KnMB18wOrHQWzR430/kzOycweN9ml9DF7bcigAAAVwtJIADA KdklBTAjh9r3jASuEcHMmIdsKWimm2dmbaFX8lkpF5XgdSK1zqLZ62mlfs255pXzdNJAqyPoWxBA AICrhiQQAODUfH5IA3cSzwmUjUVwKwmMUkBL/mbSw2MkgFayJrI+DawkgD14vJoKSvxYNxLBt3wM AQQAuHZIAgEATk00M3BWArO3vce8OXZRI5NMSmfJibVNZT7gbMOY8baX+kXdTmdlWjteK+ynJX8G w/UYO4O+5S8hgAAASCAAAGzPM0XqsusAd4YAasKXGRzvSV1LyKGXgGmPafIlkisHzZaCZuf6dUeO rfLQSsfRGTH0GsJU5wUGz49v4RkCCABwM1AOCgDwFHxxKAkVWdcYZjYNXCstGRk8RmOX6r6zDVTW npsE55gt81xbGpq8Zvsy0PYXEUAAgFuCJBAA4CnYyTajIkTyaeCWImilVtnGMF5iF20zbp9J6LKN XjJjH6LREtkSUWtkRrUhTPb9GQ1iBAEEAEACAQDgRBJYkb0oAVwzPH4LAbTm/3nyN1MOWhHA/f7u C7LUDaFb2xE0O2i+JYQw2wHVu657/gICCACABAIAwGn47c+b/POHklBN/tbMCTymCHrNYSpr9byO ms2QvxkB7A/CnUkVs0J3TKyEtRUkPPN+nvp9AgAAEggAcJPMpIEic4ngFmWhlgC2QAZF/DRQJC4H 7c4+MvMDvSYzGQGcbQRT2dYrDfX2mz2n8T38eVJAAIBbhcYwAABPyb8cGsRkG8BkBXCrofE98Xh1 Pp72nLZdZh5edR8itQYrM+8n83WffL+Z5jCV9/FnEUAAgFuGJBAA4CnZbSCAmcYwLSF9XkMSqwQ0 Wo+WkaaojLRSEmrto7ouUBLHE2OfFYnWXpstT/Xeh4i9VhMBBABAArkEAABPSLQWUJTnROZTwkgE M89nO4NWhrRrr4/KQSvz+nbOfjMSV2GmBNR6fQ9EvCWkfPnaP40AAgAA5aAAAE/Pzy5KQkVqnUDX lIRWdaAXhKWSAnplnCLblmpG+8/OC7Ru30u+FLRS6rlmTuD+/p9CAAEA4AUkgQAAT83sSIgtRkZE MmglUVHpoVeqGZWFeg1crOeyM/zG962VYWrHyrKTw/LTSKTF+HlkS0ijNFBE5E8igAAAgAQCAJwP u6TcWUJXFcJI/CJBzI4osLqGeiWZIn6ZpjduIlN22p1jZGb2WaJ1nxS55ghh5jWSEL7xOQQQAADG f1ooBwUAOAP+7dAl1BI8mRRGr2lMhkp30FH8rO9eV83M7b7iWF7JpfeYSFyueV98vNoRNNMhdP/9 TyCAAABwCEkgAMA5sEvK3xYiaGlBJqUan8+Ug2oCZSVzrXg7WxIqEqeKo1hZ3Um1fUWynJHuvuJ1 2rVHAAEAwPqnhSQQAOBM+A933ZTA2TRwi5LQSFK2aA6zxe3MttmZfiL5mXzV5C/TPEZkPg38Y8gf AAD4kAQCAJwLMw1hMiIoUpsX6J2fJn+V5jCZdYHR7cx5evu2mr5kkz9rLaN3XaQo3734M9lvjwAC AEDmnw+SQACAM+I/PawNHKUwWtOXnTeoScgWUhKNVFg+NjMGYnZcRDXVy4yL8JK8e8mnffey3dpA EZE/igACAEAOkkAAgHMi2xxGxE4EMyKYlT9vW2t9nYg9FmK5rXU7mxZmu4RmRy2Isn9NzlriOsxe U0+4vU6t348AAgBA4Z91kkAAgDPj55TehDz9AAALM0lEQVS1gdk5gGslsCom43NPsSZwbRJYTePu Jb/Gb/a56PyWX38EAQQAgBokgQAA54aXBHoCuAsEUGS+JDRKv/aPVdYEbiF+mcHx2c6eYrymicgb xvvV7lvXrbI2MPv/swggAAAggQAAVySBlfTPEr5sY5g2cY7iyFA0GsKSssptr3S00vRFxC8d7Q+C vU/vrGvQAomrpKyZn8cfRgABAGDyowbloAAAZ8h/GUpCI+mrloPOlIVmS0JH+ZNBBDU5FKkPZ49e Mz6/ZiD7vdTKQdeUiGbO8fsQQAAAmIckEADgHKmMecg0hrH2pQlfZpj8KHhaieSYyHlNXLwh8CL+ iAbteF4S6F3zUcbEOBcRvxx0TYlo9H+zCCAAAKz9mEESCABwpvxXZVxERhDXDo1fO0TeaxSz5dD3 8b6XPlabwGjJ3xuST/aiEREzz/8h5A8AALaBJBAA4FyZ7QwqgRB6ErhmiHxmyHs0MF57bSYt9EpC o3PXtteSP21d4HjNssPtWyDS4/PfiwACAMCGHzFIAgEAzpj/9pAGVkXO+rJkcY0EWjITjYuo3rae r64LnBn9cC/xMPgt1gZqj/1BBBAAALaFJBAA4JyplHO2QAIzEplpEpMdvp4ZF1G9LcM+s1Laktda 27+1xtA7RiYRtNYSLo/9BxBAAAA4wscLkkAAgDPnfy46ha4VwczIiMoawZ58vDrUPXN75v742L3o 6V4l8buXXBfRytrAexH5HgQQAACOA0kgAMAl0BLPRV1CJRDAmRmCVtLldeeMOodWZwVK8nlNUJu8 WOt3v/iuXYsevDeRw3TSSlC9eYV7EEAAAEACAQAQwDD504RjZpD8jAiKxHMEWyCSnrhlms1kxz94 IyC879p19R7zxmZ4/D4EEAAAjvzRgnJQAIAL4BeGcRHZ79X1gWsaxkSpW098ny0FHZ+LmsIsyzDf EL8MNBoOfy/zpaHj478HAQQAgONDEggAcAlUBTC7v2gfFRHUSkMzw8+t7bOloJnjNnmc/llNX7Tk zxuBIc62TeIGMctr+rsRQAAAQAIBAGDPr3ze5Mt3eZ3KdsOMxkasHSSfET5tjWBWNLOSeb+Qs65I 3XI9oLY2UJM6EbtjaFP2tRvOY893I38AAIAEAgCAJ3ZrU8BIBqN9ton9Z2SvD8fNDJLX7mvrA5sh deJIXk+cu7cWM0oqRUS+EwEEAIDTs+MSAABcCO9/EIZjL+W2ykKb5EpCZ792w3ftOe35aHvvvDzB tV67M45pCbW1r+9AAAEA4GkgCQQAuDRa8vmZxK7SMfSp3numHNTq7Dk+tizb3Ddq8cpBPQm3jqOd 70cRQAAAQAIBAOCY4hR1Cq3IZDvyuXploJlRE8sGMNHsP2+MQ3deY5W1duO9LM/lIwggAAA8LZSD AgBcEu9/3srloNFwcqspjCeGWcHMln7uiq/TXhO9H6u8U8Qv3RTJla5K4lx+FwIIAABPD0kgAMCl sUYjenIfs2WhzThmSzyWed9rx01oKWDUyTMzTsLa9/JcvhUBBAAAJBAAAGb4yudN/tddd7tXNrHH GojEM+ssSZtZI9hWiN+sEFpdOkX8OYAzHUIt4dzzO5A/AABAAgEA4CnIpoCW7M0Okd9C9kax6s57 HN/nMtWzzr07Qqd93+9z2VBG2++3IIAAAIAEAgDA1mJXTQMzc+5GQaoIYLYk1Ht8zbXwxDeT/Gly 2ILXasf4MAIIAADnCY1hAAAuka+caBCzF5Su3I8ax0SPR91GrXl62a8MVpMYbZtx+0qDGhG72cz+ 9m9DAAEA4HwhCQQAuHQqaaCWcK2lMkLiKRLBZTmoJsHa+7ESxChh/WbkDwAAzh+SQACAS2U5LiL7 /X4QIS8B9J7PpIPW81aiFnUkzaaFXiJoJZIzx9snh/t/SX8zAggAAJcBSSAAwKWTXQ8oEieDIrVu nmsaxLTie6zuLzvSYflaLTXsiXP4JgQQAAAuB5JAAIBL5v0P8hElgEupuR++NNmJpKuvEDpN3qKk bmYNYXYQfLRNdC4fQgABAOCyIAkEALh0ohl2S7nRtrU6h1r7OBZWaimF8xNDAL3h79bt6Lp+I/IH AABIIAAAPJUERsKXeb4nZc+Spy1FMNOcpSLHorzWSgKXMwDfMLb/BgQQAAAuF8pBAQAunQ88NIjR vu6Nx9+Qw5JQa1trjERmePsxWFsO2oLbIn4J6NcjgAAAcNmQBAIAXANRCeh4fywF9dYSRgPYjyF5 maY11nWoNJGpDoD/dQggAABcPq33zlUAALgG/sddfyQume/7EQfa7fH7/jVW6ra1HmnNaqpf9859 7fa98dwHkT8AALgeSAIBAK6Fyv/pNdG7gu7XwmnfjyF62fMUmRsp0Yz71u2xkUxHAAEAAAkEAIBL k0CvkYomfn14nVWaKYpoHatJzIzkjvLXg/PWGsm8ggACAMD1QTkoAMA18fNKSWhUFroTvSzUKg9d 7tcqD91abmdLQ7Vy0HuJS0W/GvkDAIDrhSQQAOCa6MZj3miFpQTtFrdlIYljWugd8xj65JV1etdB e512Lfb3vwr5AwAAJBAAAC6Je7EHnVvlj288PP7MESpv7uCxtak5UleRRq/L6AeQPwAAuB0oBwUA uDb+811XSz+9EtFnYpeFNuUxWTz2FGWh2uzCShfQ/e1fgfwBAMDtQRIIAHBt7CVHSwKtJi73wz6W ZaFjOejyeRG7xPSYZaHe8cZjj+d9LyLvQ/4AAOB22XEJAACujFeeN3fm3b1y+43F/fuH+28sbi+3 taRzTOZOJYDjc1oaubz9XgQQAABuG5JAAIBrZLk2cBQjKxXUmsFopZ3LVC2Ss1PJYDfEdMm7kD8A AAAkEADgWuly2BTFE8GlEN7Lm2sENW3aDfI4M8x9jQBax7Mav7wD+QMAAND+KQcAgGvi6563gzl4 Y3OUsTT0DUUWRfSGL9asvVOVhTbn8eXXVyCAAAAAIySBAADXyrJBjIjdIVQrD43EzhpDIaLP39v6 fUW8HfkDAACwYEQEAMA18+8fxkV4qd7y/n4ExDN5syT02fD4crvd8NpTjovQhPWtyB8AAEAESSAA wDVzr8hYDx4TQ7CWIyP2t0UerxFcckwdG5PHZ8gfAAAAEggAAPl1eZVy0LHM1CoH7UcWwiYiDfkD AAAo/xNKOSgAwJXzbxYloV5p6LK8s1oOOt7WSkQ3BfkDAACYhSQQAODaWa6fs9bpaU1eonLQTCK4 eRqI/AEAAKyFJBAA4Bb413f9pYhZX2O6p6WBWjqoJYBeoxjkDwAA4EkhCQQAuAXuDQHThsaPYx00 gVsmg/IgfPuU0NoP8gcAAHAWMCweAOAW+NDD8Pjxaxwgv5wF2J3nx2Hw1siG6QHyzxsCCAAAcBxI AgEAboVR2sYyzXtnexE/1dsngc/kcapYBvEDAAA4NiSBAAC3wjct0kArnbNKRr00UEsPNYkM5Q8B BAAAOAUkgQAAt8Q4PH751RfPa11Bm/K8JYx9cTztvxvbUv4AAAAACQQAgONgiVvTBE0Rt2XZqFZC uhRKEadBDPIHAADwVDAiAgDg1vgXyvB4b/zDOCze2k772u/7bUgfAADAuUASCABwayyHvI/jIZbb jCzLQT326d/bET8AAIBzhCQQAOAW+ZkhDYyGwb9V9FRwTP7eg/gBAACcOySBAAC3yLKD5zgmQmv8 ojWGuReR9yN9AAAAlwZJIADArfLTD2lglO7t5MV/GT4TkVeRPgAAgEuHJBAA4FZZjosQOez82UXk NyB9AAAA1wZJIADALfPFu/4y/fswwgcAAIAEAgAAAAAAwFWx4xIAAAAAAADcDv8feMy+pEVhtcMA AAAASUVORK5CYII= "
+           preserveAspectRatio="none"
+           height="21.447393"
+           width="23.868874" />
+        <text
+           xml:space="preserve"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+           x="-24.001488"
+           y="108.57887"
+           id="text21646"><tspan
+             sodipodi:role="line"
+             id="tspan21644"
+             x="-24.001488"
+             y="108.57887"
+             style="stroke-width:0.26458332px">Matlab</tspan></text>
+      </g>
+      <path
+         sodipodi:nodetypes="cc"
+         inkscape:connector-curvature="0"
+         id="path21702"
+         d="M 96.399857,93.382046 H 136.86905"
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker21706)" />
+      <text
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         x="150.62598"
+         y="94.425766"
+         id="text22195"><tspan
+           sodipodi:role="line"
+           id="tspan22193"
+           x="150.62598"
+           y="94.425766"
+           style="stroke-width:0.26458332px">.mex</tspan></text>
+      <text
+         id="text22199"
+         y="94.427704"
+         x="186.30936"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         xml:space="preserve"><tspan
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:monospace;-inkscape-font-specification:monospace;stroke-width:0.26458332px"
+           y="94.427704"
+           x="186.30936"
+           id="tspan22197"
+           sodipodi:role="line">simulate_...(...)</tspan></text>
+      <path
+         sodipodi:nodetypes="cc"
+         inkscape:connector-curvature="0"
+         id="path22563"
+         d="m 172.5999,93.382046 h 10.83586"
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker22567)" />
+    </g>
+    <g
+       id="g27878">
+      <rect
+         ry="4.95432"
+         y="26.268724"
+         x="8.8035564"
+         height="25.000847"
+         width="253.77472"
+         id="rect25365"
+         style="opacity:0.79018399;fill:#f2f2f2;fill-opacity:1;stroke:#f9f9f9;stroke-width:0.19996412;stroke-linecap:round;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:0.59989232, 0.59989232;stroke-dashoffset:0;stroke-opacity:1" />
+      <g
+         transform="matrix(0.26458333,0,0,0.26458333,14.17948,35.269858)"
+         style="overflow:visible"
+         id="g5719">
+        <switch
+           id="switch5654">
+          <foreignObject
+             height="1"
+             width="1"
+             y="0"
+             x="0"
+             requiredExtensions="http://ns.adobe.com/AdobeIllustrator/10.0/" />
+          <g
+             id="g5652"
+             i:extraneous="self">
+            <linearGradient
+               y2="34.067001"
+               x2="34.244301"
+               y1="-6.6968002"
+               x1="33.799301"
+               gradientUnits="userSpaceOnUse"
+               id="linearGradient11010">
+              <stop
+                 id="stop11000"
+                 style="stop-color:#FFFFFF"
+                 offset="0" />
+              <stop
+                 id="stop11002"
+                 style="stop-color:#FAFAFB"
+                 offset="0.2236" />
+              <stop
+                 id="stop11004"
+                 style="stop-color:#EBEDEF"
+                 offset="0.4981" />
+              <stop
+                 id="stop11006"
+                 style="stop-color:#D2D7DC"
+                 offset="0.798" />
+              <stop
+                 id="stop11008"
+                 style="stop-color:#BDC5CC"
+                 offset="1" />
+            </linearGradient>
+            <path
+               id="path5555"
+               d="m 67.942,25.446 c 0,2.18 -1.813,3.947 -4.049,3.947 H 4.173 c -2.236,0 -4.048,-1.767 -4.048,-3.947 V 4.073 c 0,-2.181 1.812,-3.948 4.048,-3.948 h 59.72 c 2.236,0 4.049,1.767 4.049,3.948 z"
+               inkscape:connector-curvature="0"
+               style="fill:url(#linearGradient20631);stroke:#231f20;stroke-width:0.25" />
+            <path
+               id="path5557"
+               d="m 48.309,4.939 h -0.065 l -6.685,21.522 h -1.37 L 33.504,4.939 H 33.439 V 26.461 H 32.07 V 3.179 h 2.217 l 6.62,20.936 h 0.065 L 47.429,3.179 h 2.25 v 23.283 h -1.37 z"
+               inkscape:connector-curvature="0"
+               style="fill:#0054a6;stroke:#0054a6;stroke-width:0.5" />
+            <path
+               id="path5559"
+               d="m 53.429,3.179 h 1.37 v 22.044 h 9.75 v 1.239 h -11.12 z"
+               inkscape:connector-curvature="0"
+               style="fill:#0054a6;stroke:#0054a6;stroke-width:0.5" />
+            <g
+               id="g5644">
+              <g
+                 id="g5588">
+                <radialGradient
+                   gradientUnits="userSpaceOnUse"
+                   gradientTransform="matrix(1.0223,0,0,0.9987,120.8042,52.6105)"
+                   r="20.6565"
+                   cy="-41.148899"
+                   cx="-104.4189"
+                   id="radialGradient11039">
+                  <stop
+                     id="stop11015"
+                     style="stop-color:#BCE6FB"
+                     offset="0" />
+                  <stop
+                     id="stop11017"
+                     style="stop-color:#B7E4FB"
+                     offset="0.042" />
+                  <stop
+                     id="stop11019"
+                     style="stop-color:#A8E0FA"
+                     offset="0.0935" />
+                  <stop
+                     id="stop11021"
+                     style="stop-color:#8FD9F8"
+                     offset="0.1501" />
+                  <stop
+                     id="stop11023"
+                     style="stop-color:#6CCFF6"
+                     offset="0.2099" />
+                  <stop
+                     id="stop11025"
+                     style="stop-color:#6ACEF6"
+                     offset="0.2135" />
+                  <stop
+                     id="stop11027"
+                     style="stop-color:#65C9F3"
+                     offset="0.3103" />
+                  <stop
+                     id="stop11029"
+                     style="stop-color:#56BCEB"
+                     offset="0.4293" />
+                  <stop
+                     id="stop11031"
+                     style="stop-color:#3DA6DD"
+                     offset="0.5598" />
+                  <stop
+                     id="stop11033"
+                     style="stop-color:#1A88CA"
+                     offset="0.6976" />
+                  <stop
+                     id="stop11035"
+                     style="stop-color:#0071BC"
+                     offset="0.7865" />
+                  <stop
+                     id="stop11037"
+                     style="stop-color:#0054A6"
+                     offset="1" />
+                </radialGradient>
+                <path
+                   id="path5586"
+                   d="M 27.574,14.861 C 27.555,14.231 27.68,13.8 28.037,13.325 29.006,12.036 29.445,10.366 29.151,8.583 28.49,5.056 25.757,2.447 22.109,1.802 20.478,1.554 18.962,1.792 17.673,2.589 c -1.325,0.818 -2.786,2.605 -2.786,5.638 0,1.589 -0.391,2.856 -1.302,3.832 -0.741,0.621 -1.823,1.268 -3.474,1.278 -2.78,0.018 -4.216,-2.144 -3.93,-4.321 0.387,-2.374 2.335,-4.189 4.796,-4.536 0.833,-0.091 1.615,0.046 2.3,0.306 0.54,0.204 0.974,-0.054 1.251,-0.459 0.361,-0.528 0.31,-1.401 -0.765,-1.932 -1.146,-0.567 -2.472,-0.692 -3.87,-0.48 -3.647,0.646 -6.379,3.254 -7.04,6.781 -0.294,1.783 0.153,3.406 1.114,4.742 1.519,2.113 3.861,2.704 5.316,2.976 3.198,0.599 4.592,2.335 4.769,4.804 0.1,2.442 -1.715,3.773 -3.835,3.401 C 8.114,24.193 6.468,22.456 6.05,20.306 5.889,19.366 6.083,18.516 6.458,17.808 6.678,17.392 6.343,16.915 5.667,16.545 4.954,16.155 4.278,16.055 3.996,16.434 c -0.814,1.093 -1.142,2.78 -0.816,4.432 0.749,3.375 3.337,5.906 6.813,6.645 1.6,0.31 2.865,-0.017 4.36,-0.678 0.863,-0.382 2.259,-0.348 3.353,0.13 1.272,0.556 2.724,0.942 4.324,0.686 3.582,-0.64 6.301,-3.164 7.038,-6.639 0.317,-1.691 -0.105,-3.202 -0.986,-4.579 -0.221,-0.348 -0.508,-0.768 -0.508,-1.57 z m -1.472,5.488 c -0.33,2.276 -2.185,4.029 -4.547,4.362 -2.353,0.263 -4.342,-1.222 -4.345,-3.732 0.077,-2.515 2.347,-4.731 4.99,-4.834 2.604,-0.028 4.161,1.906 3.902,4.204 z m -3.334,-7.877 c -2.613,-0.1 -4.888,-2.316 -4.987,-4.803 -0.019,-2.46 1.956,-3.898 4.307,-3.643 2.332,0.329 4.179,2.053 4.544,4.307 0.296,2.248 -1.241,4.157 -3.864,4.139 z"
+                   inkscape:connector-curvature="0"
+                   style="fill:url(#radialGradient20633)" />
+              </g>
+              <radialGradient
+                 gradientUnits="userSpaceOnUse"
+                 gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+                 r="7.8785"
+                 cy="-123.4775"
+                 cx="-39.161598"
+                 id="radialGradient11067">
+                <stop
+                   id="stop11043"
+                   style="stop-color:#BCE6FB"
+                   offset="0" />
+                <stop
+                   id="stop11045"
+                   style="stop-color:#B7E4FB"
+                   offset="0.042" />
+                <stop
+                   id="stop11047"
+                   style="stop-color:#A8E0FA"
+                   offset="0.0935" />
+                <stop
+                   id="stop11049"
+                   style="stop-color:#8FD9F8"
+                   offset="0.1501" />
+                <stop
+                   id="stop11051"
+                   style="stop-color:#6CCFF6"
+                   offset="0.2099" />
+                <stop
+                   id="stop11053"
+                   style="stop-color:#6ACEF6"
+                   offset="0.2135" />
+                <stop
+                   id="stop11055"
+                   style="stop-color:#65C9F3"
+                   offset="0.3103" />
+                <stop
+                   id="stop11057"
+                   style="stop-color:#56BCEB"
+                   offset="0.4293" />
+                <stop
+                   id="stop11059"
+                   style="stop-color:#3DA6DD"
+                   offset="0.5598" />
+                <stop
+                   id="stop11061"
+                   style="stop-color:#1A88CA"
+                   offset="0.6976" />
+                <stop
+                   id="stop11063"
+                   style="stop-color:#0071BC"
+                   offset="0.7865" />
+                <stop
+                   id="stop11065"
+                   style="stop-color:#0054A6"
+                   offset="1" />
+              </radialGradient>
+              <path
+                 id="path5615"
+                 d="m 26.102,20.349 c -0.33,2.276 -2.185,4.029 -4.547,4.362 -2.353,0.263 -4.342,-1.222 -4.345,-3.732 0.077,-2.515 2.347,-4.731 4.99,-4.834 2.604,-0.028 4.161,1.906 3.902,4.204 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:url(#radialGradient20635)" />
+              <radialGradient
+                 gradientUnits="userSpaceOnUse"
+                 gradientTransform="matrix(1.0223,0,0,0.9987,63.3037,147.4845)"
+                 r="8.8347998"
+                 cy="-135.5493"
+                 cx="-38.2202"
+                 id="radialGradient11094">
+                <stop
+                   id="stop11070"
+                   style="stop-color:#BCE6FB"
+                   offset="0" />
+                <stop
+                   id="stop11072"
+                   style="stop-color:#B7E4FB"
+                   offset="0.042" />
+                <stop
+                   id="stop11074"
+                   style="stop-color:#A8E0FA"
+                   offset="0.0935" />
+                <stop
+                   id="stop11076"
+                   style="stop-color:#8FD9F8"
+                   offset="0.1501" />
+                <stop
+                   id="stop11078"
+                   style="stop-color:#6CCFF6"
+                   offset="0.2099" />
+                <stop
+                   id="stop11080"
+                   style="stop-color:#6ACEF6"
+                   offset="0.2135" />
+                <stop
+                   id="stop11082"
+                   style="stop-color:#65C9F3"
+                   offset="0.3103" />
+                <stop
+                   id="stop11084"
+                   style="stop-color:#56BCEB"
+                   offset="0.4293" />
+                <stop
+                   id="stop11086"
+                   style="stop-color:#3DA6DD"
+                   offset="0.5598" />
+                <stop
+                   id="stop11088"
+                   style="stop-color:#1A88CA"
+                   offset="0.6976" />
+                <stop
+                   id="stop11090"
+                   style="stop-color:#0071BC"
+                   offset="0.7865" />
+                <stop
+                   id="stop11092"
+                   style="stop-color:#0054A6"
+                   offset="1" />
+              </radialGradient>
+              <path
+                 id="path5642"
+                 d="m 22.768,12.472 c -2.613,-0.1 -4.888,-2.316 -4.987,-4.803 -0.019,-2.46 1.956,-3.898 4.307,-3.643 2.332,0.329 4.179,2.053 4.544,4.307 0.296,2.248 -1.241,4.157 -3.864,4.139 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:url(#radialGradient20637)" />
+            </g>
+            <g
+               id="g5650">
+              <path
+                 id="path5646"
+                 d="M 62.074,3.269 H 61.569 V 3.086 h 1.23 v 0.183 h -0.508 v 1.479 h -0.217 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:#231f20" />
+              <path
+                 id="path5648"
+                 d="M 64.379,4.019 C 64.367,3.787 64.352,3.506 64.352,3.302 h -0.005 c -0.06,0.192 -0.126,0.401 -0.21,0.631 L 63.844,4.739 H 63.681 L 63.41,3.947 C 63.331,3.711 63.267,3.498 63.22,3.301 H 63.215 C 63.21,3.508 63.198,3.784 63.183,4.035 L 63.139,4.747 H 62.934 L 63.05,3.085 h 0.273 l 0.284,0.804 c 0.069,0.205 0.123,0.387 0.167,0.56 h 0.005 c 0.044,-0.167 0.104,-0.35 0.178,-0.56 l 0.296,-0.804 h 0.273 l 0.104,1.662 h -0.212 z"
+                 inkscape:connector-curvature="0"
+                 style="fill:#231f20" />
+            </g>
+          </g>
+        </switch>
+      </g>
+      <path
+         sodipodi:nodetypes="cc"
+         inkscape:connector-curvature="0"
+         id="path12287"
+         d="M 37.133194,39.179512 H 76.014863"
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Lend)" />
+      <g
+         transform="translate(8.6153814,4.2333335)"
+         id="g22231">
+        <g
+           id="g12235"
+           transform="matrix(0.07232254,0,0,0.07232254,-38.85841,28.876233)">
+          <path
+             d="m 184.61344,61.929363 c 0,-14.56215 -4.15226,-22.03817 -12.45678,-22.44755 -3.30427,-0.15595 -6.53055,0.37039 -9.66912,1.58878 -2.505,0.89673 -4.19124,1.78372 -5.07823,2.68045 v 34.75812 c 5.31216,3.33351 10.02976,4.88329 14.14303,4.63962 8.70415,-0.57508 13.0611,-7.64172 13.0611,-21.21942 z m 10.24419,0.60432 c 0,7.39804 -1.73498,13.53871 -5.22444,18.422 -3.88909,5.5266 -9.27923,8.37275 -16.17042,8.52871 -5.1952,0.1657 -10.54635,-1.46207 -16.05346,-4.87355 v 31.590317 l -8.90884,-3.17755 V 42.903043 c 1.46206,-1.79346 3.34325,-3.3335 5.62407,-4.63961 5.30242,-3.08983 11.74524,-4.67861 19.32848,-4.75658 l 0.12671,0.12671 c 6.93018,-0.08773 12.27159,2.75843 16.02422,8.5287 3.4992,5.29267 5.25368,12.07665 5.25368,20.37142 z"
+             style="fill:#646464;fill-opacity:1"
+             id="path46"
+             inkscape:connector-curvature="0" />
+          <path
+             d="m 249.30487,83.265743 c 0,9.92254 -0.9942,16.794237 -2.9826,20.615097 -1.99816,3.82086 -5.79952,6.8717 -11.41385,9.14277 -4.55189,1.79346 -9.47417,2.76817 -14.75709,2.93387 l -1.47181,-5.61432 c 5.37064,-0.73103 9.15252,-1.46207 11.34561,-2.1931 4.31796,-1.46206 7.28108,-3.70389 8.90884,-6.706 1.30611,-2.446517 1.94942,-7.115367 1.94942,-14.026057 v -2.3198 c -6.09193,2.76817 -12.47628,4.14251 -19.15303,4.14251 -4.38619,0 -8.25579,-1.37434 -11.58929,-4.14251 -3.74289,-3.01186 -5.61433,-6.83272 -5.61433,-11.46258 v -37.07793 l 8.90884,-3.05084 v 37.3216 c 0,3.98656 1.28662,7.0569 3.85985,9.21101 2.57323,2.1541 5.90674,3.18729 9.99077,3.10932 4.08403,-0.08773 8.46047,-1.66676 13.10983,-4.75658 v -43.54025 h 8.90884 z"
+             style="fill:#646464;fill-opacity:1"
+             id="path48"
+             inkscape:connector-curvature="0" />
+          <path
+             d="m 284.08249,88.997033 c -1.06243,0.08772 -2.03714,0.12671 -2.93387,0.12671 -5.03925,0 -8.96733,-1.19889 -11.77449,-3.60642 -2.79742,-2.40753 -4.20099,-5.73129 -4.20099,-9.97127 v -35.08953 h -6.10168 v -5.60457 h 6.10168 v -14.88381 l 8.89909,-3.16781 v 18.05162 h 10.01026 v 5.60457 h -10.01026 v 34.84585 c 0,3.34325 0.89673,5.71179 2.6902,7.09588 1.54004,1.14041 3.98656,1.79347 7.32006,1.95917 z"
+             style="fill:#646464;fill-opacity:1"
+             id="path50"
+             inkscape:connector-curvature="0" />
+          <path
+             d="m 338.02288,88.266003 h -8.90884 v -34.38773 c 0,-3.49921 -0.81876,-6.51106 -2.44651,-9.02581 -1.88119,-2.84615 -4.49342,-4.26923 -7.84641,-4.26923 -4.08404,0 -9.19152,2.15411 -15.32242,6.46233 v 41.22044 h -8.90885 V 6.0687929 l 8.90885,-2.80716 V 40.700203 c 5.6923,-4.14251 11.91093,-6.21864 18.66566,-6.21864 4.7176,0 8.53846,1.58877 11.46258,4.75658 2.93388,3.1678 4.39594,7.11537 4.39594,11.83296 z"
+             style="fill:#646464;fill-opacity:1"
+             id="path52"
+             inkscape:connector-curvature="0" />
+          <path
+             d="m 385.37424,60.525783 c 0,-5.59483 -1.06242,-10.21495 -3.17755,-13.87011 -2.51474,-4.45442 -6.42332,-6.80347 -11.70625,-7.04715 -9.76658,0.56534 -14.64012,7.56375 -14.64012,20.97574 0,6.15042 1.01369,11.28713 3.06057,15.41015 2.61223,5.25368 6.53056,7.84641 11.755,7.75869 9.80557,-0.07798 14.70835,-7.81717 14.70835,-23.22732 z m 9.75685,0.05848 c 0,7.96338 -2.03714,14.5914 -6.10168,19.88407 -4.47391,5.92623 -10.65357,8.89909 -18.53897,8.89909 -7.81716,0 -13.90909,-2.97286 -18.30503,-8.89909 -3.98656,-5.29267 -5.97497,-11.92069 -5.97497,-19.88407 0,-7.48576 2.15411,-13.78238 6.46232,-18.90935 4.5519,-5.43888 10.53661,-8.16806 17.93464,-8.16806 7.39805,0 13.42174,2.72918 18.06137,8.16806 4.3082,5.12697 6.46232,11.42359 6.46232,18.90935 z"
+             style="fill:#646464;fill-opacity:1"
+             id="path54"
+             inkscape:connector-curvature="0" />
+          <path
+             d="m 446.20583,88.266003 h -8.90884 v -36.33715 c 0,-3.98656 -1.19889,-7.09588 -3.59667,-9.33772 -2.39779,-2.23208 -5.59483,-3.31401 -9.58139,-3.22628 -4.23023,0.07798 -8.25579,1.46206 -12.07664,4.14251 v 44.75864 h -8.90884 v -45.86006 c 5.12697,-3.73313 9.84456,-6.16991 14.15276,-7.31032 4.06455,-1.06243 7.65148,-1.58877 10.74131,-1.58877 2.11512,0 4.10352,0.20469 5.97496,0.61406 3.49921,0.80901 6.34535,2.31006 8.53845,4.51291 2.44651,2.43677 3.6649,5.3609 3.6649,8.78212 z"
+             style="fill:#646464;fill-opacity:1"
+             id="path56"
+             inkscape:connector-curvature="0" />
+          <path
+             id="path1948"
+             d="m 60.510156,6.3979729 c -4.583653,0.021298 -8.960939,0.4122177 -12.8125,1.09375 C 36.35144,9.4962267 34.291407,13.691825 34.291406,21.429223 v 10.21875 h 26.8125 v 3.40625 h -26.8125 -10.0625 c -7.792459,0 -14.6157592,4.683717 -16.7500002,13.59375 -2.46182,10.212966 -2.5710151,16.586023 0,27.25 1.9059283,7.937852 6.4575432,13.593748 14.2500002,13.59375 h 9.21875 v -12.25 c 0,-8.849902 7.657144,-16.656248 16.75,-16.65625 h 26.78125 c 7.454951,0 13.406253,-6.138164 13.40625,-13.625 v -25.53125 c 0,-7.266339 -6.12998,-12.7247775 -13.40625,-13.9375001 -4.605987,-0.7667253 -9.385097,-1.1150483 -13.96875,-1.09375 z m -14.5,8.2187501 c 2.769547,0 5.03125,2.298646 5.03125,5.125 -2e-6,2.816336 -2.261703,5.09375 -5.03125,5.09375 -2.779476,-1e-6 -5.03125,-2.277415 -5.03125,-5.09375 -1e-6,-2.826353 2.251774,-5.125 5.03125,-5.125 z"
+             style="fill:url(#linearGradient1478);fill-opacity:1"
+             inkscape:connector-curvature="0" />
+          <path
+             id="path1950"
+             d="m 91.228906,35.054223 v 11.90625 c 0,9.230755 -7.825895,16.999999 -16.75,17 h -26.78125 c -7.335833,0 -13.406249,6.278483 -13.40625,13.625 v 25.531247 c 0,7.26634 6.318588,11.54032 13.40625,13.625 8.487331,2.49561 16.626237,2.94663 26.78125,0 6.750155,-1.95439 13.406253,-5.88761 13.40625,-13.625 V 92.897973 h -26.78125 v -3.40625 h 26.78125 13.406254 c 7.79246,0 10.69625,-5.435408 13.40624,-13.59375 2.79933,-8.398886 2.68022,-16.475776 0,-27.25 -1.92578,-7.757441 -5.60387,-13.59375 -13.40624,-13.59375 z m -15.0625,64.65625 c 2.779478,3e-6 5.03125,2.277417 5.03125,5.093747 -2e-6,2.82635 -2.251775,5.125 -5.03125,5.125 -2.76955,0 -5.03125,-2.29865 -5.03125,-5.125 2e-6,-2.81633 2.261697,-5.093747 5.03125,-5.093747 z"
+             style="fill:url(#linearGradient1475);fill-opacity:1"
+             inkscape:connector-curvature="0" />
+          <path
+             sodipodi:nodetypes="ccccccccccccccccccccccc"
+             id="text3004"
+             style="font-style:normal;font-weight:normal;font-size:15.16445827px;line-height:125%;font-family:'Bitstream Vera Sans';fill:#646464;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+             d="m 463.5544,26.909383 h 1.56195 v -9.79624 h 3.70013 v -1.16766 h -8.96221 v 1.16766 h 3.70013 v 9.79624 m 6.64702,0 h 1.33447 v -8.94703 l 2.89641,8.945906 h 1.48569 l 3.01816,-8.915576 v 8.9167 h 1.45579 v -10.9639 h -1.92589 l -3.29831,9.392857 -2.81297,-9.392857 h -2.15335 v 10.9639"
+             inkscape:connector-curvature="0" />
+          <ellipse
+             transform="matrix(0.73406,0,0,0.809524,16.24958,27.00935)"
+             id="path1894"
+             style="opacity:0.44382025;fill:url(#radialGradient1480);fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:20;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+             cx="61.518883"
+             cy="132.28575"
+             rx="48.948284"
+             ry="8.6066771" />
+        </g>
+        <text
+           xml:space="preserve"
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+           x="-16.819941"
+           y="40.732136"
+           id="text20653"><tspan
+             sodipodi:role="line"
+             id="tspan20651"
+             x="-16.819941"
+             y="40.732136"
+             style="stroke-width:0.26458332px">&gt;= 3.6</tspan></text>
+      </g>
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker21180)"
+         d="M 96.399857,39.179512 H 136.86905"
+         id="path21176"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="cc" />
+      <text
+         xml:space="preserve"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         x="155.04527"
+         y="37.720478"
+         id="text22116"><tspan
+           id="tspan22187"
+           sodipodi:role="line"
+           x="155.59563"
+           y="37.720478"
+           style="text-align:center;text-anchor:middle;stroke-width:0.26458332px">Python </tspan><tspan
+           id="tspan22191"
+           sodipodi:role="line"
+           x="155.04527"
+           y="42.681416"
+           style="text-align:center;text-anchor:middle;stroke-width:0.26458332px">module / package</tspan></text>
+      <text
+         id="text22211"
+         y="40.431553"
+         x="186.46439"
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         xml:space="preserve"><tspan
+           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:monospace;-inkscape-font-specification:monospace;stroke-width:0.26458332px"
+           y="40.431553"
+           x="186.46439"
+           id="tspan22209"
+           sodipodi:role="line">amici.runAmiciSimulation(...)</tspan></text>
+      <path
+         sodipodi:nodetypes="cc"
+         inkscape:connector-curvature="0"
+         id="path22251"
+         d="m 172.5999,39.179512 h 10.83586"
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker22255)" />
+      <g
+         id="g27880"
+         transform="matrix(0.9376105,0,0,0.9376105,-2.1982307,3.9585137)">
+        <path
+           style="fill:#d7d7d7;stroke-width:0.1155237"
+           d="m 114.75939,40.904881 c -0.17996,-0.116465 -1.33954,-5.788057 -1.2099,-5.9177 0.10294,-0.102938 4.79926,-1.292524 11.35915,-2.877288 2.4029,-0.580503 3.31161,-0.695302 3.3979,-0.429263 0.0258,0.07942 0.36868,1.38282 0.76204,2.896439 0.4927,1.89587 0.67802,2.789214 0.59569,2.871543 -0.15189,0.151891 -13.44332,3.395073 -14.21962,3.469666 -0.31825,0.03058 -0.62662,0.02455 -0.68526,-0.0134 z m 3.03817,-2.437234 c 0.0434,-0.07028 -0.12356,-0.114831 -0.4264,-0.113754 -0.36396,0.0013 -0.4512,0.03187 -0.3245,0.113754 0.22675,0.146543 0.66033,0.146543 0.7509,0 z m 0.13318,-1.208738 c -0.11737,-0.08892 -0.29932,-0.128652 -0.40434,-0.08829 -0.15333,0.05893 -0.13405,0.08923 0.0979,0.153835 0.45435,0.126556 0.53676,0.108931 0.30647,-0.06555 z m 2.4661,-0.646459 c 0,-0.05979 -0.078,-0.108706 -0.17328,-0.108706 -0.17865,0 -0.22951,0.136314 -0.0994,0.266415 0.0923,0.0923 0.27269,-0.01204 0.27269,-0.157709 z m 6.21622,-0.370932 c 0.0957,-0.115343 0.0248,-0.137457 -0.33178,-0.103451 -0.24945,0.02379 -0.42477,0.0898 -0.3896,0.146703 0.0953,0.154147 0.58176,0.124979 0.72138,-0.04325 z"
+           id="path27916"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#c7c7c7;stroke-width:0.1155237"
+           d="m 114.74904,40.845856 c -0.0548,-0.06902 -0.36048,-1.373153 -0.67936,-2.898065 -0.44765,-2.140678 -0.54875,-2.805448 -0.44363,-2.916834 0.12262,-0.129928 2.61235,-0.775249 8.85022,-2.29392 4.44044,-1.081068 4.97578,-1.200812 5.36856,-1.200812 0.34474,0 0.41407,0.04608 0.47799,0.317691 0.0411,0.174729 0.34678,1.357403 0.67923,2.628164 0.33246,1.27076 0.63235,2.42553 0.66642,2.566154 0.0341,0.140625 -7e-4,0.307633 -0.0772,0.371129 -0.13646,0.113252 -1.63915,0.505133 -6.01756,1.569295 -1.20722,0.293412 -3.36462,0.81822 -4.79423,1.16624 -2.95235,0.718714 -3.882,0.878086 -4.03047,0.690958 z m 3.15687,-2.366604 c 0.0353,-0.05716 -0.16955,-0.122513 -0.45528,-0.145237 -0.49728,-0.03955 -0.61023,0.0044 -0.44248,0.17214 0.11448,0.114479 0.82351,0.09323 0.89776,-0.0269 z m 2.14436,-0.697929 c 0,-0.05979 -0.052,-0.140835 -0.11552,-0.180103 -0.0635,-0.03927 -0.11553,0.0096 -0.11553,0.108705 0,0.09906 0.052,0.180104 0.11553,0.180104 0.0635,0 0.11552,-0.04892 0.11552,-0.108706 z m 0.92419,-0.231047 c 0,-0.05979 -0.052,-0.140835 -0.11552,-0.180104 -0.0635,-0.03927 -0.11553,0.0096 -0.11553,0.108706 0,0.09906 0.052,0.180103 0.11553,0.180103 0.0635,0 0.11552,-0.04892 0.11552,-0.108705 z m -2.84463,-0.175706 c -0.0809,-0.210769 -0.43731,-0.330436 -0.71845,-0.241207 -0.1262,0.04005 -0.3379,-0.03076 -0.51986,-0.173885 -0.21993,-0.172997 -0.30696,-0.196498 -0.30696,-0.08289 0,0.270416 0.2597,0.435746 0.68737,0.437591 0.22556,9.71e-4 0.48808,0.05216 0.58339,0.113755 0.24862,0.160667 0.34915,0.141125 0.27451,-0.05336 z m 2.38254,-0.625633 c 0,-0.151492 -0.29863,-0.370153 -0.38608,-0.282698 -0.15816,0.158156 -0.067,0.384076 0.15503,0.384076 0.12708,0 0.23105,-0.04562 0.23105,-0.101378 z m 6.05875,-0.432069 c 0.10227,-0.03925 0.24029,-0.1729 0.30671,-0.297012 0.11673,-0.218105 0.11083,-0.219144 -0.17627,-0.03103 -0.17798,0.116612 -0.43606,0.174229 -0.64384,0.143734 -0.33363,-0.04897 -0.43215,0.01627 -0.26977,0.178642 0.0967,0.09671 0.53759,0.0999 0.78317,0.0057 z m 0.41057,-1.332512 c 0,-0.133367 -0.5474,-0.124763 -0.63064,0.0099 -0.0367,0.05932 0.0902,0.103395 0.28199,0.09794 0.19176,-0.0055 0.34865,-0.05399 0.34865,-0.107856 z m -1.15348,-1.117817 c -0.077,-0.02566 -0.22584,0.04105 -0.33079,0.148251 -0.17863,0.182456 -0.16969,0.185437 0.13997,0.04666 0.18194,-0.08154 0.26781,-0.169246 0.19082,-0.194908 z"
+           id="path27914"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#b7b7b7;stroke-width:0.1155237"
+           d="m 114.74945,40.790279 c -0.16738,-0.335644 -1.20468,-5.527441 -1.13871,-5.699369 0.0367,-0.09568 0.42993,-0.255822 0.91267,-0.371704 0.46648,-0.111982 2.71964,-0.662972 5.007,-1.224423 9.01183,-2.212014 8.54565,-2.12117 8.7167,-1.698629 0.16216,0.400588 1.39462,5.201456 1.39303,5.426386 -0.002,0.256516 0.0724,0.235905 -7.39492,2.054065 -7.06497,1.720195 -7.36278,1.780335 -7.49577,1.513674 z m 2.99794,-2.211173 c 0.37023,-0.19814 0.25518,-0.297902 -0.35416,-0.307094 -0.59602,-0.009 -0.72759,0.0968 -0.37546,0.301906 0.26093,0.151974 0.4528,0.153338 0.72962,0.0052 z m 2.30288,-0.808227 c 0,-0.12907 -0.078,-0.264596 -0.17328,-0.301169 -0.0953,-0.03657 -0.17329,-0.135941 -0.17329,-0.220818 0,-0.148631 -0.44415,-0.976195 -0.52392,-0.976195 -0.0214,0 0.12374,0.389892 0.32264,0.866428 0.35993,0.8623 0.54785,1.079001 0.54785,0.631754 z m 0.92419,-0.227421 c 0,-0.127076 -0.052,-0.231048 -0.11552,-0.231048 -0.0635,0 -0.11553,0.103972 -0.11553,0.231048 0,0.127076 0.052,0.231047 0.11553,0.231047 0.0635,0 0.11552,-0.103971 0.11552,-0.231047 z m -2.89131,-0.292694 c -0.0832,-0.10029 -0.34116,-0.169401 -0.63222,-0.169401 -0.37909,0 -0.53312,-0.0595 -0.67293,-0.259928 -0.18077,-0.259137 -0.18134,-0.259181 -0.18738,-0.01415 -0.008,0.339852 0.21444,0.492262 0.8463,0.578867 0.29713,0.04073 0.57432,0.129208 0.61599,0.196627 0.0507,0.08208 0.0915,0.07547 0.12329,-0.02002 0.0262,-0.07843 -0.0157,-0.218829 -0.093,-0.312 z m 2.69702,-0.475716 c 0.0747,-0.07473 -0.4316,-0.386827 -0.62758,-0.386827 -0.0563,0 -0.10232,0.103971 -0.10232,0.231047 0,0.176683 0.077,0.231047 0.32732,0.231047 0.18002,0 0.36119,-0.03387 0.40258,-0.07527 z m 5.99936,-0.595577 c 0.11119,-0.0955 0.20216,-0.245109 0.20216,-0.33247 0,-0.113988 -0.0955,-0.08821 -0.33832,0.0913 -0.32395,0.239502 -0.47081,0.245 -0.9902,0.03707 -0.21068,-0.08434 -0.21612,-0.07418 -0.0618,0.11534 0.33758,0.414484 0.77116,0.446878 1.18813,0.08877 z m -9.45415,-0.02891 0.35666,-0.08526 -0.36131,-0.01183 c -0.21172,-0.0069 -0.42695,0.0691 -0.51986,0.183636 -0.13519,0.166669 -0.13451,0.180971 0.005,0.09709 0.0898,-0.0541 0.3237,-0.136742 0.51986,-0.183637 z m 9.7286,-1.094676 c -0.0727,-0.189574 -0.76543,-0.238397 -0.76543,-0.05395 0,0.06354 0.1316,0.115524 0.29244,0.115524 0.16862,0 0.32433,0.08312 0.36777,0.196325 0.0493,0.128435 0.0918,0.147092 0.12279,0.05395 0.0261,-0.07831 0.0182,-0.218638 -0.0176,-0.311849 z m -1.33399,-0.98299 c 0.13393,-0.07168 0.38163,-0.09911 0.55044,-0.06096 0.2926,0.06612 0.29646,0.06118 0.0827,-0.105701 -0.47273,-0.369041 -1.06309,-0.04734 -1.16275,0.633609 l -0.0592,0.404332 0.17265,-0.370478 c 0.095,-0.203763 0.28223,-0.429123 0.41615,-0.500799 z"
+           id="path27912"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#a7a7a7;stroke-width:0.1155237"
+           d="m 114.80128,40.905524 c -0.11077,-0.179233 -1.24588,-5.801023 -1.18383,-5.863076 0.0379,-0.03792 2.57705,-0.687372 5.6425,-1.443221 7.21511,-1.77903 8.51587,-2.082744 8.73737,-2.040087 0.11819,0.02276 0.25111,0.300366 0.37632,0.785924 0.10646,0.412902 0.43791,1.681375 0.73654,2.818827 0.44616,1.699379 0.51594,2.09385 0.39136,2.212543 -0.0834,0.07944 -3.16709,0.876525 -6.85267,1.771289 -7.11918,1.728349 -7.775,1.875248 -7.84759,1.757801 z m 3.10355,-2.388367 c 0.29236,-0.292361 0.21905,-0.340635 -0.45368,-0.298746 -0.65187,0.04059 -0.73845,0.100119 -0.49691,0.341655 0.19627,0.196278 0.73576,0.171926 0.95059,-0.04291 z m 2.18594,-0.681547 c 0.0359,-0.09347 0.002,-0.236429 -0.0743,-0.31769 -0.0767,-0.08126 -0.32042,-0.49432 -0.54155,-0.917908 -0.22113,-0.423589 -0.43844,-0.747677 -0.4829,-0.720196 -0.0445,0.02748 0.0768,0.397554 0.26938,0.822384 0.19263,0.42483 0.39565,0.891879 0.45117,1.037885 0.11512,0.302803 0.28243,0.345062 0.37819,0.09553 z m -2.00901,-0.586511 c -0.0772,-0.09308 -0.33567,-0.167736 -0.5806,-0.167736 -0.32271,0 -0.48888,-0.06778 -0.61795,-0.252055 -0.23493,-0.335414 -0.0496,-0.556611 0.4664,-0.556611 0.39387,0 0.56291,-0.219682 0.18802,-0.24435 -0.69303,-0.0456 -0.99158,0.170362 -0.99158,0.717296 0,0.456496 0.28299,0.682291 0.85511,0.682291 0.2555,0 0.4893,0.07652 0.58442,0.191276 0.14726,0.177655 0.16129,0.17726 0.19697,-0.0055 0.0211,-0.108254 -0.0242,-0.272307 -0.10079,-0.364561 z m 2.8927,0.236597 c 0,-0.29495 -0.15767,-0.385463 -0.29223,-0.167754 -0.0961,0.155494 0.018,0.456563 0.17308,0.456563 0.0655,0 0.11915,-0.129964 0.11915,-0.288809 z m -0.11556,-0.779785 c -3e-5,-0.218793 -0.0625,-0.259928 -0.39444,-0.259928 -0.45576,0 -0.58606,0.09087 -0.48985,0.341588 0.0438,0.114107 0.21524,0.178268 0.47637,0.178268 0.34606,0 0.40795,-0.03944 0.40792,-0.259928 z m 5.95476,-0.485725 c 0.20469,-0.204687 0.28356,-0.409614 0.28356,-0.736759 0,-0.596352 -0.23389,-0.804468 -0.66768,-0.594107 l -0.31427,0.152399 0.34657,0.0675 c 0.24811,0.04832 0.35729,0.142931 0.38432,0.333038 0.0537,0.377485 -0.17774,0.599398 -0.62502,0.599398 -0.55492,0 -0.85678,-0.366209 -0.85678,-1.039417 0,-0.708405 0.20444,-0.974306 0.73749,-0.959196 0.43063,0.01221 0.55729,-0.118073 0.23501,-0.24174 -0.3829,-0.146933 -0.73075,-0.06241 -0.96411,0.234267 -0.28527,0.362656 -0.30009,0.720195 -0.063,1.51871 0.27738,0.934038 0.94162,1.228162 1.50387,0.665912 z m -5.99133,-0.777816 c -0.0369,-0.09216 -0.0642,-0.06478 -0.0698,0.0698 -0.005,0.121781 0.0223,0.190012 0.0607,0.151625 0.0384,-0.03839 0.0425,-0.138027 0.009,-0.221421 z"
+           id="path27910"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#979797;stroke-width:0.1155237"
+           d="m 114.79406,40.778478 c -0.25721,-0.810401 -1.18742,-5.617401 -1.1033,-5.701515 0.0993,-0.09927 1.4451,-0.440486 9.76746,-2.476406 4.77835,-1.16894 4.63911,-1.14319 4.72018,-0.872921 0.0351,0.117107 0.27939,1.044693 0.54281,2.061301 0.26342,1.016609 0.5817,2.205598 0.70731,2.642198 0.15871,0.551704 0.19156,0.830617 0.10771,0.91447 -0.0664,0.06636 -3.04662,0.833297 -6.6228,1.704309 -8.72763,2.125693 -8.03981,1.979259 -8.11937,1.728564 z m 3.29357,-2.455235 c 0.29349,-0.481345 0.29075,-0.834346 -0.009,-1.133882 -0.18117,-0.181177 -0.32128,-0.220408 -0.58235,-0.163068 -0.38732,0.08507 -0.68088,-0.09119 -0.68088,-0.40881 0,-0.237612 0.22279,-0.344786 0.71673,-0.344786 0.29914,0 0.32993,-0.02572 0.20746,-0.173286 -0.2155,-0.259658 -0.6678,-0.209135 -0.9872,0.110273 -0.51487,0.514868 -0.23687,1.21825 0.48149,1.21825 0.52172,0 0.85228,0.179948 0.85228,0.463958 0,0.255948 -0.41168,0.403365 -0.87767,0.314285 -0.1945,-0.03718 -0.3182,0.0019 -0.36127,0.114123 -0.0861,0.224391 0.16652,0.374432 0.63414,0.376626 0.30246,0.0014 0.42248,-0.07258 0.60606,-0.373683 z m 2.07817,-0.563264 c 0,-0.127565 -0.12403,-0.397422 -0.27562,-0.599681 -0.15159,-0.20226 -0.38658,-0.588683 -0.5222,-0.85872 -0.20965,-0.417426 -0.47295,-0.652941 -0.47295,-0.423048 0,0.122284 0.8258,1.950108 0.94735,2.09687 0.15566,0.187948 0.32342,0.07621 0.32342,-0.215421 z m 0.83262,-1.227354 c -0.0251,-0.651265 -0.0927,-1.184118 -0.15031,-1.184118 -0.0576,0 -0.1047,0.230868 -0.1047,0.513039 0,0.551566 -0.089,0.685879 -0.34821,0.52566 -0.20526,-0.126858 -0.46045,0.06937 -0.46045,0.354058 0,0.142372 0.10151,0.220909 0.31769,0.245783 0.2385,0.02744 0.32765,0.108539 0.35764,0.325363 0.0472,0.340878 0.25393,0.62601 0.35961,0.495872 0.0409,-0.05035 0.0538,-0.624392 0.0287,-1.275657 z m 2.29714,-0.03878 -0.1115,-0.278911 -0.007,0.298436 c -0.004,0.16414 0.0306,0.336343 0.0769,0.382673 0.13718,0.137181 0.16206,-0.101634 0.0419,-0.402198 z m 3.49727,-0.229534 c 0.25572,-0.201152 0.30439,-0.331019 0.30439,-0.812291 0,-0.629546 -0.13282,-0.759829 -0.64385,-0.631568 -0.37274,0.09355 -0.3065,0.342724 0.10402,0.391323 0.60123,0.07118 0.25866,0.829874 -0.37471,0.829874 -0.42073,0 -0.70751,-0.333369 -0.78523,-0.912785 -0.0929,-0.692712 0.17727,-1.051118 0.79239,-1.051118 0.40786,0 0.45362,-0.02405 0.32976,-0.173286 -0.20876,-0.251534 -0.87948,-0.217998 -1.15524,0.05776 -0.43254,0.432543 -0.26367,1.699985 0.31112,2.335127 0.24948,0.275675 0.74345,0.26107 1.11735,-0.03304 z M 123.036,35.365803 c -0.0755,-0.327203 -0.18038,-0.594914 -0.233,-0.594914 -0.12148,0 -0.12006,0.0445 0.0119,0.370016 0.0591,0.14595 0.13964,0.414459 0.1789,0.596686 0.0393,0.182227 0.0957,0.306978 0.12548,0.277224 0.0297,-0.02975 -0.008,-0.321809 -0.0832,-0.649012 z"
+           id="path27908"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#878787;stroke-width:0.1155237"
+           d="m 114.79178,40.745163 c -0.4031,-1.656014 -1.1682,-5.591558 -1.10092,-5.662947 0.0482,-0.05115 0.62804,-0.223345 1.28851,-0.382648 0.66047,-0.159302 2.89039,-0.706383 4.95538,-1.215735 6.36927,-1.571052 8.01855,-1.946404 8.11752,-1.847426 0.12549,0.125482 1.47095,5.153909 1.47095,5.497394 0,0.308075 0.58022,0.148186 -8.60652,2.371659 -3.1769,0.768908 -5.84064,1.419961 -5.91941,1.446784 -0.0788,0.02682 -0.17125,-0.06636 -0.20551,-0.207081 z m 3.26571,-2.351055 c 0.36649,-0.403131 0.35241,-1.015777 -0.0291,-1.265747 -0.16426,-0.107627 -0.41641,-0.165022 -0.58414,-0.13296 -0.28346,0.05419 -0.62864,-0.154643 -0.62864,-0.38032 0,-0.161478 0.41904,-0.345361 0.7144,-0.313491 0.17364,0.01874 0.26755,-0.03196 0.26755,-0.144417 0,-0.116348 -0.14018,-0.184937 -0.42663,-0.208747 -0.52059,-0.04327 -0.90189,0.281623 -0.90189,0.768461 0,0.427145 0.29279,0.681243 0.89614,0.777724 0.26718,0.04272 0.54978,0.154796 0.628,0.249049 0.22561,0.271835 -0.20245,0.525949 -0.74436,0.441887 -0.38123,-0.05914 -0.43321,-0.03887 -0.43321,0.168934 0,0.268872 0.39978,0.473443 0.7509,0.38424 0.12708,-0.03228 0.34802,-0.18736 0.49098,-0.344613 z m 2.08777,-0.664379 c 0.0205,-0.173672 -0.0198,-0.384531 -0.0896,-0.468575 -0.0944,-0.113717 -0.0846,-0.169007 0.0382,-0.216127 0.23414,-0.08985 0.5112,0.159093 0.55474,0.498431 0.0522,0.406601 0.38572,0.381008 0.3764,-0.02888 -0.004,-0.17473 -0.017,-0.737908 -0.0289,-1.251507 -0.0153,-0.660154 -0.0617,-0.920458 -0.15841,-0.888233 -0.0752,0.02507 -0.14019,0.250342 -0.1444,0.500602 -0.007,0.426305 -0.0278,0.45291 -0.32648,0.421589 -0.25249,-0.02647 -0.34257,0.02905 -0.433,0.26688 -0.13924,0.366253 -0.27765,0.294978 -0.5807,-0.299049 -0.12746,-0.249841 -0.28267,-0.454257 -0.34492,-0.454257 -0.16943,0 -0.14116,0.139017 0.17248,0.848221 0.15711,0.355258 0.36432,0.834176 0.46045,1.064263 0.19907,0.476428 0.44835,0.479713 0.50412,0.0066 z m 3.2552,-0.863543 c 0,-0.279079 -0.49602,-2.053282 -0.60194,-2.153059 -0.0855,-0.08052 -0.10077,-0.02801 -0.0505,0.173286 0.0397,0.158845 0.15958,0.691698 0.26644,1.184118 0.10686,0.492419 0.23742,0.895308 0.29014,0.895308 0.0527,0 0.0958,-0.04484 0.0958,-0.09965 z m 3.4331,-0.62237 c 0.30375,-0.330743 0.43261,-0.926195 0.26728,-1.235104 -0.14726,-0.275158 -0.7106,-0.326259 -0.91266,-0.08279 -0.16078,0.193719 -0.0552,0.307061 0.28609,0.307061 0.36392,0 0.44556,0.189704 0.22591,0.524937 -0.33237,0.507259 -1.00027,0.315031 -1.22013,-0.351165 -0.25338,-0.76773 0.0887,-1.385461 0.7223,-1.304431 0.36889,0.04718 0.4039,-0.170862 0.0551,-0.343462 -0.20604,-0.101968 -0.38228,-0.11211 -0.58813,-0.03384 -0.28735,0.109247 -0.65158,0.646674 -0.65158,0.961404 0,0.359907 0.35735,1.323231 0.57919,1.56135 0.32059,0.344107 0.91868,0.342193 1.23658,-0.004 z"
+           id="path27906"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#777777;stroke-width:0.1155237"
+           d="m 114.80496,40.691478 c -0.12043,-0.390705 -1.10849,-5.25227 -1.10849,-5.454108 0,-0.157988 0.18953,-0.249671 0.83754,-0.405159 0.46066,-0.11053 2.91698,-0.712645 5.4585,-1.338034 8.2956,-2.041286 8.0862,-1.999316 8.18382,-1.640261 0.71424,2.627108 1.3557,5.268886 1.30894,5.390734 -0.0376,0.09788 -1.14844,0.425036 -2.92826,0.862378 -6.57168,1.614806 -11.4251,2.785132 -11.55312,2.78585 -0.0751,4.22e-4 -0.16466,-0.09021 -0.19893,-0.2014 z m 3.22916,-2.182938 c 0.34515,-0.372423 0.38708,-1.066547 0.0811,-1.34298 -0.11119,-0.100463 -0.41011,-0.199495 -0.66426,-0.220071 -0.37261,-0.03017 -0.4621,-0.08216 -0.4621,-0.268459 0,-0.184284 0.0891,-0.238389 0.44026,-0.267322 0.57674,-0.04752 0.56418,-0.406807 -0.0162,-0.46263 -0.58754,-0.05651 -0.94395,0.236573 -0.94395,0.776232 0,0.55123 0.20491,0.735362 0.90842,0.816292 0.43371,0.04989 0.54227,0.108208 0.57057,0.306487 0.0405,0.283658 -0.28847,0.414896 -0.78902,0.314787 -0.43452,-0.08691 -0.56981,0.168645 -0.23346,0.441004 0.36899,0.298794 0.77699,0.264441 1.10857,-0.09334 z m 2.18805,-0.614148 c 0.0396,-0.124676 0.0129,-0.337071 -0.0593,-0.471989 -0.14965,-0.27962 -0.0854,-0.399662 0.16293,-0.304373 0.0935,0.03587 0.18668,0.211242 0.20715,0.389724 0.0277,0.241541 0.10833,0.334563 0.31538,0.36382 l 0.27818,0.03931 -0.0743,-1.29874 c -0.0409,-0.714307 -0.0976,-1.32204 -0.12608,-1.350517 -0.14839,-0.148385 -0.2982,0.160967 -0.2982,0.615759 0,0.487234 -0.0152,0.511429 -0.27932,0.445135 -0.20929,-0.05253 -0.31167,-0.0096 -0.40839,0.171085 -0.18687,0.349159 -0.2755,0.303901 -0.56276,-0.287384 -0.14433,-0.297075 -0.31885,-0.506857 -0.39848,-0.478991 -0.19764,0.06917 -0.1397,0.285593 0.37774,1.41092 0.45069,0.980152 0.7198,1.215291 0.86549,0.756244 z m 3.00108,-2.030544 c -0.14368,-0.6093 -0.29255,-1.139131 -0.33082,-1.177404 -0.18507,-0.185065 -0.18704,0.147436 -0.006,0.97045 0.24613,1.117374 0.36872,1.456366 0.49783,1.376572 0.055,-0.03399 -0.0176,-0.560319 -0.16125,-1.169618 z m 3.72272,0.390559 c 0.18904,-0.156886 0.31198,-0.825565 0.21952,-1.193949 -0.059,-0.234876 -0.14317,-0.289235 -0.44593,-0.2878 -0.20528,9.7e-4 -0.44489,0.04715 -0.53245,0.102608 -0.22643,0.143418 -0.0532,0.357718 0.28922,0.357718 0.24743,0 0.28433,0.04601 0.25311,0.315564 -0.0263,0.226694 -0.12941,0.348034 -0.36627,0.430862 -0.29003,0.101423 -0.36303,0.07657 -0.6065,-0.206482 -0.199,-0.231347 -0.27678,-0.46104 -0.27678,-0.817291 0,-0.640429 0.26933,-0.910665 0.80155,-0.804223 0.32564,0.06513 0.37144,0.0461 0.33571,-0.139433 -0.0644,-0.334406 -0.71284,-0.473915 -1.08113,-0.232602 -0.47294,0.309882 -0.58414,0.673625 -0.43024,1.407333 0.15552,0.741452 0.50614,1.284596 0.86745,1.343755 0.28053,0.04593 0.74285,-0.08527 0.97274,-0.27606 z"
+           id="path27904"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#676767;stroke-width:0.1155237"
+           d="m 114.84991,40.624631 c -0.21343,-0.514386 -1.17442,-5.41661 -1.0792,-5.505254 0.0545,-0.05071 2.12648,-0.592358 4.60447,-1.203658 7.72622,-1.906001 9.52603,-2.314849 9.64901,-2.191877 0.14521,0.145215 1.52333,5.358722 1.46,5.5233 -0.026,0.06767 -0.4048,0.213426 -0.8417,0.32391 -2.33868,0.591408 -11.63808,2.838326 -13.47971,3.256963 -0.13354,0.03036 -0.2463,-0.04295 -0.31287,-0.203384 z m 3.01181,-1.929361 c 0.26321,-0.140867 0.57122,-0.696551 0.57122,-1.030552 0,-0.388886 -0.40691,-0.698879 -0.91737,-0.698879 -0.2504,0 -0.48882,-0.05426 -0.5298,-0.120584 -0.12166,-0.196839 0.18026,-0.457034 0.53031,-0.457034 0.4327,0 0.52449,-0.180703 0.19852,-0.390803 -0.34963,-0.225347 -0.84625,-0.11702 -1.13264,0.247061 -0.29111,0.370083 -0.28841,0.613966 0.011,0.99459 0.18041,0.22935 0.34417,0.304825 0.66427,0.306158 0.52147,0.0022 0.77031,0.145998 0.67633,0.390904 -0.0504,0.13143 -0.22047,0.184945 -0.58763,0.184945 -0.59951,0 -0.75185,0.15346 -0.46595,0.469374 0.22228,0.245616 0.63612,0.289801 0.98176,0.10482 z m 2.41718,-1.160233 c -0.075,-0.261433 -0.0595,-0.33815 0.0683,-0.33815 0.10656,0 0.16522,0.123041 0.16522,0.346571 0,0.293855 0.0445,0.346571 0.29259,0.346571 h 0.29259 l -0.0327,-1.299642 c -0.0267,-1.063703 -0.0641,-1.299641 -0.20595,-1.299641 -0.12128,0 -0.18395,0.147356 -0.20881,0.490975 -0.0312,0.430499 -0.0695,0.490976 -0.31114,0.490976 -0.15159,0 -0.35422,0.112226 -0.4503,0.249392 l -0.17468,0.249392 -0.20732,-0.373565 c -0.36825,-0.663529 -0.47002,-0.770985 -0.60471,-0.638464 -0.13424,0.132071 0.55588,1.89274 0.89207,2.275917 0.16286,0.185616 0.19558,0.187377 0.38002,0.02046 0.15596,-0.141142 0.17978,-0.259475 0.10483,-0.520791 z m 3.19711,-0.709559 c -0.0368,-0.140736 -0.15542,-0.665518 -0.26359,-1.166182 -0.16993,-0.786496 -0.38475,-1.162797 -0.56238,-0.985162 -0.026,0.02602 0.0487,0.435333 0.16603,0.90958 0.11734,0.474248 0.24583,1.005229 0.28554,1.179959 0.0418,0.18387 0.14994,0.31769 0.25676,0.31769 0.13366,0 0.1661,-0.07058 0.11764,-0.255885 z m 3.39905,-0.543895 c 0.27409,-0.274095 0.33768,-0.436486 0.33768,-0.862363 0,-0.382669 -0.055,-0.554141 -0.20339,-0.633532 -0.26841,-0.143646 -0.83818,-0.02886 -0.92041,0.185427 -0.0749,0.195241 0.18609,0.401125 0.40615,0.320365 0.28125,-0.103216 0.30536,0.314933 0.031,0.537116 -0.34183,0.276801 -0.4228,0.269316 -0.76262,-0.0705 -0.19636,-0.196365 -0.28355,-0.411838 -0.28355,-0.700736 0,-0.656735 0.1673,-0.864085 0.6972,-0.864085 0.50621,0 0.63189,-0.245395 0.23458,-0.45803 -1.02337,-0.547689 -1.76255,0.732501 -1.1728,2.031174 0.40164,0.884437 1.05972,1.091639 1.63619,0.515169 z"
+           id="path27902"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#575757;stroke-width:0.1155237"
+           d="m 114.85101,40.691478 c -3.8e-4,-0.04765 -0.26085,-1.303439 -0.57881,-2.790635 -0.31796,-1.487196 -0.55376,-2.72834 -0.524,-2.758098 0.06,-0.06002 7.13547,-1.825647 11.42728,-2.85159 1.51634,-0.362475 2.79613,-0.615637 2.84398,-0.562583 0.11518,0.127691 1.52669,5.483891 1.46216,5.548414 -0.0772,0.07718 -0.88486,0.282222 -6.54238,1.660896 -8.15759,1.987914 -8.08647,1.972495 -8.08823,1.753596 z m 3.28285,-2.232694 c 0.58838,-0.699249 0.26883,-1.550977 -0.57294,-1.527116 -0.63948,0.01813 -0.66744,-0.420675 -0.031,-0.486346 0.43229,-0.0446 0.44092,-0.04916 0.44092,-0.232864 0,-0.240112 -0.49585,-0.447427 -0.85472,-0.357357 -0.35876,0.09004 -0.76262,0.503377 -0.76262,0.780515 0,0.596321 0.41971,0.941729 1.27076,1.045808 0.49279,0.06027 0.35515,0.379089 -0.17328,0.4014 -0.25415,0.01073 -0.52708,0.02373 -0.6065,0.02888 -0.21665,0.01406 -0.17378,0.442877 0.0578,0.577736 0.41094,0.239352 0.91566,0.144828 1.23161,-0.230657 z m 2.15362,-0.402896 c 0.0918,-0.110641 0.24897,-0.155869 0.40526,-0.116641 0.4263,0.106993 0.49473,-0.129931 0.41425,-1.43424 -0.0634,-1.026888 -0.10561,-1.217627 -0.27693,-1.250351 -0.16929,-0.03233 -0.20217,0.04949 -0.20217,0.503187 0,0.491327 -0.0223,0.535966 -0.23954,0.479161 -0.15254,-0.03989 -0.30871,0.01815 -0.43,0.159812 -0.2625,0.306569 -0.30575,0.287495 -0.54346,-0.239643 -0.13404,-0.297254 -0.28454,-0.462094 -0.42188,-0.462094 -0.31167,0 -0.27035,0.195212 0.30257,1.42961 0.51534,1.110313 0.69965,1.283345 0.9919,0.931199 z m 3.006,-2.147549 c -0.27856,-1.219971 -0.39837,-1.48698 -0.58393,-1.301416 -0.0869,0.08687 -0.0455,0.442306 0.14114,1.212033 0.2951,1.217164 0.40216,1.456226 0.57482,1.283567 0.0756,-0.07564 0.0308,-0.480856 -0.13203,-1.194184 z m 3.38128,0.582645 c 0.3913,-0.178289 0.55978,-0.549132 0.51682,-1.137541 -0.0442,-0.604731 -0.27676,-0.800417 -0.75253,-0.633098 -0.4454,0.156638 -0.44489,0.556513 8.1e-4,0.607617 0.35659,0.04089 0.39274,0.312166 0.0688,0.51615 -0.66581,0.419232 -1.33519,-0.699783 -0.84081,-1.405606 0.14563,-0.207913 0.26032,-0.253786 0.50978,-0.203894 0.19937,0.03987 0.3712,0.0049 0.45146,-0.09177 0.19566,-0.235799 -0.15963,-0.527193 -0.64283,-0.527193 -0.46778,0 -0.96074,0.417751 -0.98214,0.832296 -0.0401,0.776136 0.11756,1.341342 0.49345,1.769457 0.37261,0.424383 0.68625,0.497272 1.17721,0.273579 z"
+           id="path27900"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#474747;stroke-width:0.1155237"
+           d="m 114.89398,40.606146 c -0.0363,-0.09459 -0.31097,-1.343853 -0.61039,-2.776149 -0.37237,-1.78123 -0.50552,-2.632684 -0.42136,-2.694389 0.0677,-0.04962 0.38298,-0.151415 0.70067,-0.226216 0.31769,-0.0748 2.60136,-0.633775 5.07482,-1.242165 6.0281,-1.482715 8.30521,-2.016938 8.36068,-1.961466 0.0798,0.07976 1.40929,5.158909 1.40929,5.383858 0,0.237503 0.0499,0.220593 -2.54914,0.864253 -5.33498,1.321234 -11.60616,2.824249 -11.7839,2.824249 -0.0631,0 -0.14437,-0.07739 -0.18067,-0.171975 z m 3.27903,-2.087055 c 0.37827,-0.429849 0.357,-1.113557 -0.0445,-1.429343 -0.17098,-0.134491 -0.47478,-0.239433 -0.69314,-0.239433 -0.21382,0 -0.38875,-0.04642 -0.38875,-0.103163 0,-0.125709 0.28562,-0.243408 0.59069,-0.243408 0.28278,0 0.40515,-0.294323 0.21675,-0.521327 -0.22831,-0.275102 -0.89103,-0.214254 -1.21703,0.111743 -0.62216,0.622162 -0.16471,1.564821 0.75938,1.564821 0.39148,0 0.46867,0.03583 0.43554,0.202167 -0.0312,0.156419 -0.15725,0.202166 -0.55721,0.202166 -0.44122,0 -0.52213,0.03644 -0.55239,0.248774 -0.0894,0.627462 0.95008,0.775798 1.45062,0.207003 z m 2.5704,-0.498591 0.40434,-0.08043 -0.0315,-1.321495 c -0.0173,-0.726823 -0.0823,-1.372306 -0.1444,-1.434408 -0.18593,-0.185927 -0.39384,0.127325 -0.39796,0.599575 -0.003,0.354512 -0.0417,0.424698 -0.21725,0.394653 -0.11741,-0.0201 -0.31995,0.05788 -0.45009,0.173286 -0.13013,0.115406 -0.25521,0.157844 -0.27795,0.09431 -0.10781,-0.301268 -0.51221,-0.866428 -0.61997,-0.866428 -0.27359,0 -0.23683,0.404967 0.11315,1.246431 0.52088,1.252381 0.66193,1.449789 0.96718,1.35369 0.13757,-0.04331 0.43207,-0.114936 0.65445,-0.159176 z m 2.77257,-1.045935 c 0,-0.122277 -0.10949,-0.69787 -0.24331,-1.279094 -0.22293,-0.968213 -0.43252,-1.326967 -0.64886,-1.110627 -0.0705,0.0705 0.20611,1.451898 0.44785,2.236591 0.12507,0.405978 0.44432,0.516003 0.44432,0.15313 z m 3.31564,-0.528941 c 0.47436,-0.332252 0.62374,-1.448675 0.22756,-1.70069 -0.2122,-0.134981 -0.70653,-0.104151 -0.92812,0.05788 -0.27618,0.201949 -0.12774,0.54569 0.23565,0.54569 0.22894,0 0.27727,0.05075 0.24757,0.259929 -0.0575,0.405133 -0.60105,0.418301 -0.86146,0.02087 -0.46369,-0.707685 -0.12902,-1.524279 0.56246,-1.372404 0.23937,0.05257 0.3393,0.02009 0.39647,-0.1289 0.10548,-0.27487 -0.25222,-0.512351 -0.77171,-0.512351 -0.64137,0 -0.98407,0.425284 -0.9658,1.198563 0.0153,0.649069 0.36543,1.480907 0.707,1.679821 0.2988,0.174005 0.86698,0.150094 1.15038,-0.04841 z"
+           id="path27898"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#373737;stroke-width:0.1155237"
+           d="m 114.91143,40.636554 c -0.0861,-0.25002 -1.09944,-5.165509 -1.09944,-5.333321 0,-0.111835 1.2421,-0.465532 4.2455,-1.20894 6.56355,-1.624625 9.502,-2.32702 9.73501,-2.32702 0.11733,0 0.24126,0.09098 0.27538,0.202166 0.20599,0.671192 1.33981,5.048776 1.33981,5.172902 0,0.101504 -1.32024,0.474293 -4.07221,1.14985 -3.61214,0.886713 -9.39525,2.279242 -10.11086,2.434618 -0.15362,0.03335 -0.2835,-0.0041 -0.31319,-0.09026 z m 3.07054,-1.854891 c 0.2467,-0.188258 0.56649,-0.821763 0.56649,-1.122196 0,-0.390153 -0.50576,-0.809152 -0.9767,-0.809152 -0.51205,0 -0.5307,-0.162888 -0.0349,-0.305074 0.39961,-0.114606 0.56607,-0.464379 0.30097,-0.632384 -0.27845,-0.176459 -0.86838,-0.107874 -1.17991,0.137177 -0.23223,0.182678 -0.30439,0.342206 -0.30439,0.673005 0,0.553936 0.38137,0.931605 1.02836,1.018385 0.7933,0.106403 0.56674,0.339178 -0.26473,0.271996 -0.29786,-0.02407 -0.52583,0.131866 -0.53081,0.363084 -9.7e-4,0.04518 0.112,0.188139 0.25106,0.31769 0.28133,0.262099 0.858,0.306168 1.14458,0.08747 z m 2.76144,-0.743793 0.40434,-0.09909 0.0329,-1.179653 c 0.0331,-1.187032 -0.0697,-1.641663 -0.3712,-1.641663 -0.19066,0 -0.2971,0.251717 -0.2971,0.702591 0,0.280758 -0.0473,0.337122 -0.28307,0.337122 -0.15569,0 -0.33154,0.08661 -0.39078,0.192464 -0.091,0.162513 -0.15499,0.117568 -0.41152,-0.288809 -0.31122,-0.493007 -0.57265,-0.611873 -0.6875,-0.312588 -0.0545,0.141913 0.34485,1.157431 0.87998,2.237932 0.13957,0.281823 0.17777,0.283581 1.12393,0.0517 z m 2.81799,-0.936529 c 0.0631,-0.102166 -0.41759,-2.207012 -0.55475,-2.428948 -0.13185,-0.21333 -0.41486,-0.152359 -0.41486,0.08937 0,0.240412 0.45025,2.206582 0.5378,2.348476 0.0717,0.116251 0.35811,0.110346 0.43181,-0.0089 z m 3.44917,-0.839502 c 0.22318,-0.238403 0.31769,-0.46136 0.31769,-0.749463 0,-0.640144 -0.17058,-0.857011 -0.6741,-0.857011 -0.71596,0 -0.97392,0.470161 -0.39449,0.71901 0.43277,0.18586 0.42683,0.177359 0.26225,0.375674 -0.34735,0.41853 -0.92651,-0.03467 -0.92651,-0.725008 0,-0.555109 0.16295,-0.716247 0.72428,-0.716247 0.397,0 0.44289,-0.02897 0.41011,-0.258846 -0.0455,-0.31885 -0.58608,-0.596506 -0.97256,-0.499505 -0.69163,0.173587 -0.95938,0.802697 -0.74649,1.753983 0.29934,1.33758 1.22781,1.782083 1.99982,0.957413 z"
+           id="path27896"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#2b2b2b;stroke-width:0.1155237"
+           d="m 114.92056,40.460431 c -0.23007,-0.74729 -1.09377,-5.172376 -1.02293,-5.240868 0.0834,-0.08062 12.78229,-3.233438 13.69056,-3.399025 0.23827,-0.04344 0.43322,-0.04448 0.43322,-0.0023 0,0.04216 0.31287,1.253052 0.69528,2.690868 0.3824,1.437816 0.65235,2.65714 0.59988,2.709608 -0.11473,0.114729 -13.72103,3.441382 -14.08163,3.442867 -0.14005,5.78e-4 -0.27981,-0.08883 -0.31438,-0.201127 z m 3.3642,-1.980987 c 0.33815,-0.503357 0.33471,-0.956077 -0.0103,-1.357192 -0.21281,-0.247407 -0.36943,-0.315861 -0.70119,-0.306457 -0.48537,0.01376 -0.45484,-0.0756 0.0855,-0.250263 0.47392,-0.15319 0.4982,-0.517011 0.0489,-0.732368 -0.71513,-0.342749 -1.58207,0.357832 -1.41035,1.139699 0.0924,0.420645 0.56252,0.801642 0.98917,0.801642 0.1783,0 0.35777,0.05436 0.39884,0.120798 0.048,0.07763 -0.0857,0.111334 -0.37423,0.09431 -0.53128,-0.03135 -0.72651,0.06614 -0.72651,0.362776 0,0.333578 0.45419,0.59011 0.97818,0.552492 0.37456,-0.02689 0.50652,-0.104645 0.72202,-0.425439 z m 2.44667,-0.357813 c 0.2158,-0.05465 0.43645,-0.168111 0.49034,-0.252129 0.0539,-0.08402 0.0691,-0.62063 0.0338,-1.192472 -0.0904,-1.464236 -0.12323,-1.581752 -0.42959,-1.538189 -0.20497,0.02915 -0.26305,0.123795 -0.29208,0.476044 -0.0239,0.289949 -0.10258,0.460008 -0.23105,0.499409 -0.10714,0.03286 -0.29084,0.111538 -0.40822,0.17484 -0.24684,0.133122 -0.22098,0.151585 -0.468,-0.334127 -0.20047,-0.39417 -0.60172,-0.51264 -0.71718,-0.211749 -0.0619,0.161427 0.61414,1.833017 0.95445,2.359845 0.13038,0.201837 0.23868,0.251355 0.42507,0.194368 0.13757,-0.04206 0.42668,-0.121186 0.64247,-0.17584 z m 2.85865,-0.983407 c 0.0679,-0.177053 -0.36743,-2.142417 -0.5564,-2.51174 -0.12544,-0.245155 -0.39323,-0.264534 -0.48138,-0.03484 -0.0862,0.224637 0.48768,2.524596 0.65678,2.632201 0.20327,0.129347 0.30749,0.105925 0.381,-0.08563 z m 3.48385,-0.816804 c 0.21619,-0.248871 0.25911,-0.415204 0.23104,-0.895418 -0.0291,-0.49756 -0.0817,-0.616156 -0.3363,-0.758547 -0.25506,-0.142618 -0.35896,-0.14512 -0.67034,-0.01614 -0.29887,0.123794 -0.3619,0.209364 -0.33355,0.452808 0.0225,0.193527 0.11705,0.314765 0.26601,0.341252 0.37011,0.06581 0.44847,0.21795 0.18491,0.359002 -0.20552,0.109994 -0.28986,0.08506 -0.53225,-0.157332 -0.30652,-0.306513 -0.3691,-0.73989 -0.16257,-1.12579 0.10213,-0.190834 0.19767,-0.220899 0.51362,-0.161627 0.3062,0.05745 0.41215,0.02797 0.50185,-0.139638 0.13259,-0.247747 0.0545,-0.402641 -0.2958,-0.587045 -0.72124,-0.379633 -1.42109,0.0745 -1.50796,0.97851 -0.0694,0.722024 0.31431,1.702063 0.76578,1.955994 0.42564,0.239403 1.05103,0.127546 1.37556,-0.24603 z"
+           id="path27894"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#232323;stroke-width:0.1155237"
+           d="m 114.79957,39.825051 c -0.72223,-3.297953 -0.95722,-4.610311 -0.83242,-4.648913 0.15948,-0.04933 4.39757,-1.093253 9.88957,-2.435982 2.18885,-0.53515 4.01751,-0.933984 4.06368,-0.886298 0.14495,0.149698 1.48048,5.280817 1.39515,5.360164 -0.0967,0.08992 -13.87233,3.448576 -14.14445,3.448576 -0.13964,0 -0.23538,-0.215827 -0.37153,-0.837547 z m 3.15452,-0.944407 c 0.36682,-0.189691 0.59437,-0.618157 0.59437,-1.119169 0,-0.483301 -0.1619,-0.738964 -0.57678,-0.910813 -0.34579,-0.143229 -0.34875,-0.150934 -0.11994,-0.311204 0.31407,-0.219983 0.29576,-0.452426 -0.0537,-0.681383 -0.62134,-0.40712 -1.56008,0.136746 -1.56008,0.903849 0,0.23329 0.12124,0.463781 0.38012,0.722659 0.35036,0.350366 0.36392,0.390225 0.17328,0.509283 -0.29689,0.185409 -0.25492,0.53471 0.0976,0.811968 0.35787,0.281503 0.62866,0.300522 1.06514,0.07481 z m -0.70527,-0.951601 c 0.0794,-0.03205 0.20939,-0.03205 0.28881,0 0.0794,0.03205 0.0144,0.05827 -0.1444,0.05827 -0.15885,0 -0.22383,-0.02622 -0.14441,-0.05827 z m 3.45127,0.237902 c 0.63483,-0.146937 0.65975,-0.215553 0.58063,-1.598554 -0.0804,-1.405678 -0.24633,-1.791413 -0.61285,-1.4249 -0.10508,0.105085 -0.18654,0.35016 -0.18101,0.544611 0.007,0.251648 -0.0434,0.353548 -0.17529,0.353548 -0.10194,0 -0.27276,0.07911 -0.37959,0.175794 -0.17705,0.160222 -0.22149,0.134638 -0.50172,-0.288809 -0.33498,-0.506195 -0.31957,-0.495777 -0.58354,-0.394482 -0.26734,0.102587 -0.22965,0.329843 0.23664,1.426933 0.50043,1.177439 0.69581,1.431202 1.03589,1.345449 0.13679,-0.03449 0.39817,-0.09731 0.58084,-0.13959 z m 2.90218,-1.202094 c 0.0157,-0.158301 -0.0905,-0.751418 -0.23595,-1.318036 -0.2704,-1.053297 -0.51799,-1.409716 -0.7902,-1.13751 -0.10639,0.106393 -0.0774,0.393699 0.12777,1.268164 0.14594,0.621835 0.31389,1.22472 0.37322,1.339744 0.15148,0.293625 0.49071,0.195203 0.52516,-0.152362 z m 3.39059,-0.552957 c 0.3158,-0.282167 0.36256,-0.40053 0.37067,-0.938332 0.007,-0.476547 -0.0398,-0.651348 -0.20835,-0.774577 -0.3168,-0.231648 -0.83094,-0.194829 -1.1049,0.07912 -0.28964,0.289646 -0.24738,0.464677 0.16016,0.663345 0.39083,0.190521 0.39783,0.369148 0.0144,0.369148 -0.2313,0 -0.3336,-0.09311 -0.47556,-0.432859 -0.15763,-0.37726 -0.15981,-0.470001 -0.0169,-0.722023 0.13544,-0.23895 0.2363,-0.282784 0.58081,-0.252422 0.34788,0.03066 0.43059,-0.0064 0.49961,-0.223876 0.11039,-0.347811 -0.29695,-0.679294 -0.83474,-0.679294 -0.47232,0 -1.0686,0.517452 -1.08803,0.944184 -0.0827,1.815353 1.06811,2.892111 2.10283,1.967582 z"
+           id="path27892"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#1b1b1b;stroke-width:0.1155237"
+           d="m 114.96723,40.596041 c 0,-0.0467 -0.2385,-1.223104 -0.53001,-2.614224 -0.2915,-1.39112 -0.50397,-2.597159 -0.47214,-2.680086 0.0318,-0.08293 0.23133,-0.181361 0.44336,-0.21874 0.21203,-0.03738 3.2286,-0.772715 6.70349,-1.634079 3.4749,-0.861363 6.43808,-1.566089 6.58485,-1.566056 0.25026,5.5e-5 0.30892,0.158374 0.9426,2.543834 0.37165,1.399076 0.65013,2.610503 0.61883,2.69206 -0.0313,0.08156 -0.30938,0.208491 -0.61797,0.282076 -0.30859,0.07359 -2.38057,0.579767 -4.6044,1.124849 -7.60095,1.863064 -9.06861,2.198132 -9.06861,2.070366 z m 3.15854,-1.78802 c 0.39192,-0.308285 0.59885,-0.979318 0.43447,-1.408915 -0.0668,-0.1747 -0.28162,-0.414986 -0.47727,-0.533968 -0.27479,-0.167108 -0.31487,-0.232011 -0.17617,-0.285237 0.25554,-0.09806 0.22554,-0.621041 -0.0439,-0.765234 -0.42196,-0.225826 -0.92928,-0.139872 -1.28725,0.218096 -0.43306,0.43306 -0.45646,1.005231 -0.0604,1.475951 0.2364,0.280945 0.25524,0.359725 0.12774,0.53409 -0.20525,0.280709 -0.0895,0.631089 0.27372,0.828456 0.4307,0.234043 0.85961,0.211608 1.20902,-0.06324 z m 2.55988,-0.618125 c 0.57889,-0.198871 0.75075,-0.520625 0.68033,-1.27366 -0.1666,-1.78146 -0.16749,-1.785434 -0.41924,-1.865336 -0.29858,-0.09477 -0.5499,0.203571 -0.5499,0.652785 0,0.197047 -0.0741,0.332318 -0.20216,0.369146 -0.1112,0.03197 -0.28572,0.09273 -0.38783,0.135022 -0.13407,0.05553 -0.22579,-0.02001 -0.33011,-0.271861 -0.14508,-0.350256 -0.47887,-0.549151 -0.6962,-0.414838 -0.19605,0.121171 -0.13061,0.615738 0.1573,1.188597 0.15061,0.299694 0.31406,0.674862 0.36322,0.833707 0.24838,0.802641 0.53728,0.937524 1.38459,0.646438 z m 2.94521,-1.252938 c -3.5e-4,-0.206498 -0.0554,-0.583394 -0.12235,-0.837547 -0.40987,-1.556221 -0.45902,-1.675093 -0.69252,-1.675093 -0.36168,0 -0.37986,0.252841 -0.10556,1.468223 0.27657,1.225454 0.37299,1.419869 0.70417,1.419869 0.16783,0 0.21676,-0.08495 0.21626,-0.375452 z m 3.38414,-0.478426 c 0.53896,-0.499491 0.53436,-1.612586 -0.008,-1.857625 -0.18611,-0.08413 -0.23141,-0.17927 -0.181,-0.380107 0.10152,-0.404483 -0.24698,-0.720672 -0.79432,-0.720672 -0.60555,0 -0.88447,0.168805 -1.08943,0.659342 -0.28749,0.688069 0.0759,1.973393 0.677,2.394402 0.39273,0.275079 1.04373,0.2306 1.39543,-0.09534 z m -1.1834,-0.982083 c -0.20937,-0.505465 -0.11745,-0.986623 0.19702,-1.031285 0.32591,-0.04629 0.33063,0.05816 0.0142,0.314378 -0.31152,0.252252 -0.20542,0.673841 0.19486,0.774306 0.31188,0.07828 0.27067,0.276754 -0.0575,0.276754 -0.12291,0 -0.26769,-0.138764 -0.34862,-0.334153 z"
+           id="path27890"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#121212;stroke-width:0.1155237"
+           d="m 115.03609,40.449505 c -0.14453,-0.233848 -1.09545,-5.043707 -1.01347,-5.126234 0.0453,-0.04565 0.7573,-0.245716 1.58212,-0.444595 0.82482,-0.198878 2.46141,-0.615467 3.63687,-0.925754 1.17545,-0.310286 3.02094,-0.772838 4.10109,-1.027894 1.08014,-0.255056 2.528,-0.597309 3.21746,-0.760562 0.68945,-0.163254 1.28082,-0.269554 1.31415,-0.236223 0.0333,0.03333 0.26208,0.80353 0.50833,1.711553 0.24625,0.908022 0.55917,2.05496 0.69539,2.548751 0.13621,0.49379 0.21629,0.929173 0.17794,0.967518 -0.11186,0.111861 -12.72322,3.195582 -13.66773,3.342024 -0.29052,0.04504 -0.50601,0.02608 -0.55215,-0.04858 z m 2.87303,-1.4529 c 0.87505,-0.365621 1.01563,-1.728516 0.22209,-2.153205 -0.24855,-0.133022 -0.25884,-0.167012 -0.10276,-0.339478 0.38088,-0.420869 0.042,-0.808843 -0.70649,-0.808843 -0.39473,0 -0.58386,0.067 -0.80041,0.283558 -0.36489,0.364883 -0.38733,1.094612 -0.0483,1.570715 0.20017,0.281107 0.21322,0.365651 0.0875,0.56697 -0.19129,0.306303 -0.0355,0.571507 0.49459,0.842121 0.47337,0.241645 0.3771,0.237343 0.85381,0.03816 z m 2.72964,-0.716751 c 0.3243,-0.10607 0.62976,-0.2917 0.70194,-0.426565 0.15278,-0.285489 0.0494,-2.275469 -0.1363,-2.62237 -0.24421,-0.45631 -0.80756,-0.202888 -0.80756,0.363279 0,0.233591 -0.0883,0.359074 -0.34179,0.485513 -0.33518,0.167213 -0.34627,0.162911 -0.57372,-0.222586 -0.2684,-0.454902 -0.75247,-0.548441 -0.873,-0.168692 -0.0828,0.260809 0.67251,2.122177 1.02225,2.519286 0.27326,0.310276 0.27888,0.310678 1.00818,0.07214 z m 3.10827,-1.207747 c 0,-0.06416 -0.13066,-0.647168 -0.29035,-1.295577 -0.28256,-1.147343 -0.49538,-1.513618 -0.80942,-1.393107 -0.25296,0.09707 -0.28484,0.350253 -0.11739,0.932382 0.0874,0.303908 0.21866,0.850888 0.29164,1.215511 0.14208,0.709882 0.37133,0.954037 0.72037,0.767234 0.11283,-0.06039 0.20515,-0.162285 0.20515,-0.226443 z m 3.37907,-0.685422 c 0.24893,-0.273217 0.31769,-0.462441 0.31769,-0.874309 0,-0.594797 -0.15862,-0.972534 -0.4084,-0.972534 -0.11684,0 -0.16922,-0.126976 -0.16922,-0.410228 0,-0.361883 -0.0491,-0.430727 -0.4163,-0.584169 -0.51529,-0.215304 -0.9685,-0.127086 -1.33093,0.259069 -0.22362,0.238259 -0.27369,0.413621 -0.27041,0.947078 0.0105,1.715292 1.33691,2.667511 2.27757,1.635093 z m -1.1071,-0.653099 c -0.14033,-0.140322 -0.0798,-0.26338 0.0963,-0.195808 0.0953,0.03657 0.17328,0.11292 0.17328,0.16966 0,0.121116 -0.15915,0.136554 -0.26955,0.02615 z m -0.30807,-0.89079 c 0,-0.184368 0.32114,-0.482425 0.41675,-0.386805 0.0355,0.03553 -0.0437,0.1729 -0.17607,0.305271 -0.16497,0.164967 -0.24068,0.190614 -0.24068,0.08153 z"
+           id="path27888"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#0d0d0d;stroke-width:0.1155237"
+           d="m 115.09214,40.218045 c -0.20009,-0.37388 -0.70253,-2.935641 -0.70253,-3.581978 0,-0.956699 0.0528,-1.009207 1.36304,-1.356404 0.8008,-0.212196 1.17848,-0.208645 1.17848,0.01108 0,0.27764 0.41298,0.199693 0.55138,-0.10407 0.0913,-0.200473 0.25643,-0.299327 0.59556,-0.356623 0.25805,-0.0436 0.49858,-0.126839 0.53452,-0.184982 0.19151,-0.309872 1.99766,-1.024594 3.17054,-1.254634 0.34946,-0.06854 0.73935,-0.145201 0.86642,-0.170356 0.12708,-0.02516 0.56896,-0.124192 0.98196,-0.22008 0.41299,-0.09589 1.03682,-0.227097 1.38628,-0.291576 0.34946,-0.06448 1.03973,-0.196451 1.53395,-0.293271 0.4942,-0.09682 0.97657,-0.146102 1.07191,-0.109514 0.2298,0.08818 0.61379,0.945449 0.8714,1.945392 0.11459,0.444767 0.33668,1.266398 0.49355,1.825847 l 0.28521,1.017182 -0.30851,0.117318 c -0.62296,0.236892 -12.48419,3.097048 -13.20637,3.184514 -0.46421,0.05622 -0.55439,0.03217 -0.66679,-0.177848 z m 3.0612,-1.275072 c 0.72581,-0.442598 0.80746,-1.475794 0.15971,-2.020843 -0.19011,-0.159966 -0.29138,-0.320639 -0.22712,-0.360353 0.20751,-0.128245 0.13196,-0.734482 -0.10749,-0.862634 -0.62818,-0.33619 -1.6588,0.05433 -1.79637,0.680675 -0.0954,0.434367 0.0146,0.985559 0.23291,1.166711 0.1156,0.09594 0.1424,0.278505 0.0934,0.636116 -0.0652,0.475486 -0.0485,0.513919 0.32142,0.739418 0.4844,0.295316 0.86373,0.301309 1.32356,0.02091 z m 2.58258,-0.65711 c 0.37272,-0.121912 0.59811,-0.274718 0.68433,-0.463952 0.14338,-0.314666 0.0688,-1.827826 -0.12075,-2.451014 -0.10326,-0.33944 -0.15674,-0.378007 -0.48054,-0.346571 -0.31014,0.03011 -0.37937,0.09613 -0.46529,0.44369 -0.0632,0.255598 -0.20441,0.457148 -0.37759,0.538875 -0.24741,0.116761 -0.2946,0.09584 -0.44653,-0.197964 -0.30344,-0.586781 -0.98109,-0.584251 -0.98109,0.0037 0,0.178112 0.15592,0.653417 0.34648,1.056235 0.19057,0.402817 0.34652,0.790367 0.34657,0.861221 1.7e-4,0.240511 0.47785,0.737602 0.7088,0.737602 0.12641,0 0.47993,-0.0818 0.78561,-0.181784 z m 2.88348,-0.963529 c 0.19732,-0.124942 0.14289,-0.613393 -0.2163,-1.940825 -0.27539,-1.017746 -0.53576,-1.282246 -0.90185,-0.916153 -0.1634,0.163395 -0.15044,0.304783 0.1382,1.507322 0.17519,0.729858 0.37909,1.351765 0.45312,1.382015 0.21164,0.08648 0.35285,0.07781 0.52683,-0.03236 z m 3.26161,-0.652977 c 0.69892,-0.361425 0.8772,-1.687124 0.27955,-2.07872 -0.18343,-0.120187 -0.24602,-0.251766 -0.20982,-0.44111 0.065,-0.339782 -0.43598,-0.764922 -0.90129,-0.764922 -1.08804,0 -1.5538,0.994274 -1.08638,2.319095 0.36369,1.030814 1.08735,1.395169 1.91794,0.965657 z m -3.65384,-2.68788 c 0,-0.208943 -0.22611,-0.170798 -0.27096,0.04571 -0.025,0.120459 0.0184,0.17327 0.11553,0.14088 0.0855,-0.0285 0.15543,-0.112462 0.15543,-0.18659 z"
+           id="path27886"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#090909;stroke-width:0.1155237"
+           d="m 115.58027,40.056098 c -0.23565,-0.259646 -0.30591,-0.532819 -0.49452,-1.922682 -0.13652,-1.005986 0.0631,-1.507628 0.60195,-1.512379 0.12274,-0.0011 0.26945,0.162963 0.37792,0.422585 0.0975,0.233394 0.23938,0.499138 0.31523,0.590542 0.0759,0.0914 0.12233,0.347274 0.10326,0.568602 -0.051,0.592019 0.33049,0.958023 0.99857,0.958023 0.42741,0 0.57569,-0.06442 0.90405,-0.39278 0.32706,-0.327055 0.39278,-0.477402 0.39278,-0.898485 0,-0.278137 -0.0809,-0.621243 -0.17984,-0.762456 -0.14169,-0.202299 -0.14698,-0.256753 -0.0249,-0.256753 0.0852,0 0.30909,0.324911 0.49753,0.722024 0.45303,0.954713 0.74783,1.105909 1.58291,0.811827 0.85233,-0.30016 0.94853,-0.518354 0.8439,-1.91401 -0.097,-1.293849 -0.28608,-1.668662 -0.77932,-1.544867 -0.18043,0.04528 -0.34998,0.20963 -0.43967,0.426164 -0.32747,0.790578 -0.80874,0.618623 -0.75077,-0.268247 0.0513,-0.785113 0.72014,-1.189012 2.14169,-1.293357 0.34758,-0.02551 0.86219,-0.130075 1.14358,-0.232358 0.28139,-0.102284 0.64528,-0.172279 0.80866,-0.155545 0.16338,0.01673 0.53099,-0.02781 0.81691,-0.099 1.40827,-0.350591 1.7265,-0.381496 2.21066,-0.214687 0.44258,0.152481 0.47642,0.148706 0.53079,-0.05921 0.0608,-0.232594 0.26217,-0.310135 0.26217,-0.100966 0,0.06661 0.10435,0.337081 0.23188,0.601053 0.15993,0.330999 0.20982,0.597571 0.16079,0.858953 -0.0624,0.332659 -0.0343,0.393014 0.23021,0.493564 0.17007,0.06466 0.30131,0.204758 0.30131,0.321647 0,0.1139 0.12599,0.392509 0.27999,0.619132 0.30965,0.455701 0.49458,1.19496 0.32512,1.299693 -0.20103,0.124241 -3.06347,0.86403 -6.32354,1.634297 -1.77906,0.420346 -3.97213,0.943215 -4.87349,1.161931 -0.90136,0.218717 -1.71107,0.397666 -1.79936,0.397666 -0.0883,0 -0.26669,-0.116967 -0.39643,-0.259928 z m 8.14561,-3.004264 c 0.0452,-0.392689 -0.29695,-1.991221 -0.52059,-2.432386 -0.12884,-0.254163 -0.23221,-0.316921 -0.4757,-0.288809 -0.4093,0.04726 -0.45616,0.441743 -0.1895,1.595468 0.28361,1.227077 0.45206,1.524552 0.83809,1.479982 0.24267,-0.02802 0.31914,-0.105928 0.3477,-0.354255 z m 3.44065,-0.594299 c 0.24974,-0.249736 0.39278,-0.50465 0.39278,-0.69996 0,-0.175369 0.0496,-0.276543 0.11553,-0.235782 0.26212,0.162004 0.36511,-0.09051 0.13527,-0.331656 -0.69173,-0.725746 -0.82842,-0.913418 -0.82842,-1.137426 0,-0.44488 -0.32672,-0.668454 -0.97097,-0.664432 -0.6857,0.0043 -0.92547,0.153227 -1.16342,0.722713 -0.20348,0.48701 -0.0929,1.303511 0.27402,2.022677 0.26025,0.510125 0.57999,0.697794 1.20766,0.708828 0.35746,0.0063 0.52188,-0.06929 0.83755,-0.384962 z m -3.813,-2.397314 c 0.092,-0.148876 -0.27837,-0.471352 -0.43219,-0.376289 -0.0542,0.03348 -0.0985,0.161783 -0.0985,0.285109 0,0.249097 0.39152,0.316365 0.53069,0.09118 z"
+           id="path27884"
+           inkscape:connector-curvature="0" />
+        <path
+           style="fill:#060606;stroke-width:0.1155237"
+           d="m 116.22469,39.767289 c -0.007,-0.04765 -0.004,-0.177618 0.007,-0.288809 0.0113,-0.111192 -0.0347,-0.202167 -0.10222,-0.202167 -0.0675,0 -0.12279,-0.103971 -0.12279,-0.231047 0,-0.274152 0.36361,-0.31563 0.57146,-0.06519 0.0757,0.09122 0.28942,0.199194 0.47491,0.239936 0.37485,0.08233 0.57514,0.287347 0.28072,0.287347 -0.10359,0 -0.26633,0.07798 -0.36164,0.173285 -0.17811,0.178114 -0.72395,0.241365 -0.7477,0.08664 z m 3.08583,-0.588453 c -0.04,-0.06468 -0.0221,-0.148855 0.0397,-0.187049 0.1873,-0.11576 -10e-4,-0.408379 -0.26536,-0.412129 -0.21374,-0.003 -0.22157,-0.01869 -0.0573,-0.114603 0.1307,-0.07631 0.32665,-0.0541 0.62595,0.07095 0.33471,0.13985 0.49938,0.153024 0.71048,0.05684 0.15114,-0.06886 0.36726,-0.125203 0.48027,-0.125203 0.32298,0 1.02338,-0.925063 0.87822,-1.159936 -0.0377,-0.06095 0.007,-0.110824 0.0983,-0.110824 0.0918,0 0.25125,-0.128856 0.35444,-0.286346 0.18115,-0.276465 0.17765,-0.288848 -0.10144,-0.358894 -0.15898,-0.0399 -0.25729,-0.123946 -0.21847,-0.186765 0.0388,-0.06282 0.0196,-0.226227 -0.0427,-0.363129 -0.41978,-0.921903 -0.58685,-1.186378 -0.8131,-1.287139 -0.14082,-0.06272 -0.25605,-0.149664 -0.25605,-0.193207 0,-0.160928 1.27704,-0.472197 1.44501,-0.352211 0.063,0.04501 0.12019,0.445736 0.12706,0.890502 0.0136,0.877425 0.30452,2.033368 0.58155,2.310398 0.27892,0.278924 0.71967,0.216731 0.87465,-0.12342 0.10446,-0.229251 0.10161,-0.446118 -0.0125,-0.953071 -0.0812,-0.360958 -0.17581,-0.90322 -0.21016,-1.205026 -0.0577,-0.506801 -0.0431,-0.548737 0.1909,-0.548737 0.13933,0 0.34907,-0.05123 0.46607,-0.113852 0.17839,-0.09547 0.23312,-0.05539 0.33898,0.248286 0.0694,0.199176 0.12624,0.460423 0.12624,0.580549 0,0.348935 0.42091,1.078202 0.81246,1.407673 0.41153,0.346276 0.92009,0.392451 1.42458,0.129344 0.57139,-0.298001 1.03145,-0.153576 0.91608,0.287583 -0.086,0.328651 -1.28871,0.709987 -4.19283,1.329338 -1.37272,0.292754 -2.33876,0.520466 -2.7308,0.643697 -0.19941,0.06268 -0.51133,0.108222 -0.69315,0.101205 -0.18181,-0.007 -0.44167,0.02224 -0.57746,0.06501 -0.13579,0.04277 -0.2796,0.02484 -0.31958,-0.03984 z m 8.71089,-2.204263 c 0,-0.05475 0.078,-0.129461 0.17328,-0.166034 0.0953,-0.03657 0.17329,-0.0217 0.17329,0.03304 0,0.05475 -0.078,0.129462 -0.17329,0.166035 -0.0953,0.03657 -0.17328,0.0217 -0.17328,-0.03304 z"
+           id="path27882"
+           inkscape:connector-curvature="0" />
+      </g>
+      <g
+         id="SympyLogo"
+         transform="matrix(0.01708268,0,0,0.01708268,50.293056,30.468805)">
+        <g
+           id="SymPy_text">
+          <g
+             style="font-style:normal;font-weight:normal;font-size:160px;font-family:FreeSerif;fill:#000000;fill-opacity:1;stroke:#7d7d7d;stroke-width:1.99999976;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1"
+             id="text3266">
+            <path
+               style="text-anchor:middle"
+               id="path3393"
+               d="m 215.8375,613.4 c -6e-5,-5.01331 -1.76006,-9.43997 -5.28,-13.28 -3.52005,-3.94663 -7.78672,-7.30662 -12.8,-10.08 -5.01337,-2.77329 -10.0267,-5.59995 -15.04,-8.48 -4.90669,-2.98661 -9.12002,-6.77327 -12.64,-11.36 -3.52001,-4.5866 -5.28001,-9.91993 -5.28,-16 -1e-5,-8.10658 2.71999,-14.66657 8.16,-19.68 5.54664,-5.11989 12.0533,-7.67989 19.52,-7.68 4.47996,1.1e-4 9.33328,0.90677 14.56,2.72 5.22661,1.81344 8.37327,2.7201 9.44,2.72 2.77327,10e-5 4.47993,-1.81323 5.12,-5.44 h 3.36 l 3.52,34.08 h -4 c -2.56007,-9.38658 -6.50673,-16.31991 -11.84,-20.8 -5.22672,-4.4799 -11.04005,-6.7199 -17.44,-6.72 -4.9067,10e-5 -8.9067,1.38677 -12,4.16 -3.09336,2.77343 -4.64003,6.34676 -4.64,10.72 -3e-5,4.26675 1.81331,8.32008 5.44,12.16 3.62663,3.84007 9.65329,8.10673 18.08,12.8 10.55994,5.65339 18.1866,11.25338 22.88,16.8 4.69326,5.44004 7.03992,11.4667 7.04,18.08 -8e-5,8.21335 -3.14674,15.14668 -9.44,20.8 -6.2934,5.54667 -14.02672,8.32 -23.2,8.32 -5.33337,0 -10.77337,-0.90667 -16.32,-2.72 -5.44002,-1.81333 -8.80002,-2.72 -10.08,-2.72 -1.17335,0 -2.18668,0.53334 -3.04,1.6 -0.85335,0.96 -1.33335,2.18667 -1.44,3.68 h -3.52 l -4.8,-33.92 h 3.68 c 3.94665,9.70669 8.53331,16.85335 13.76,21.44 5.22664,4.58667 11.4133,6.88 18.56,6.88 5.86662,0 10.61328,-1.65333 14.24,-4.96 3.62661,-3.41332 5.43994,-7.78665 5.44,-13.12"
+               inkscape:connector-curvature="0" />
+            <path
+               style="text-anchor:middle"
+               id="path3395"
+               d="m 261.9725,656.44 c 2.98664,-2e-5 6.1333,-3.30668 9.44,-9.92 3.30663,-6.61334 4.95996,-11.46667 4.96,-14.56 -4e-5,-2.34666 -2.3467,-7.73332 -7.04,-16.16 l -2.4,-4.8 -18.72,-40.64 c -1.28001,-2.77327 -4.00001,-4.47993 -8.16,-5.12 V 563 h 32.96 v 2.4 c -3.41337,0.10674 -5.81336,0.48007 -7.2,1.12 -1.38669,0.64007 -2.08003,1.70673 -2.08,3.2 -3e-5,1.60006 0.53331,3.62673 1.6,6.08 l 18.4,40.48 15.52,-44.16 c 0.4266,-0.95994 0.63994,-1.8666 0.64,-2.72 -6e-5,-2.6666 -2.56006,-3.99993 -7.68,-4 V 563 h 21.6 v 2.4 c -1.92007,0.2134 -3.46674,0.8534 -4.64,1.92 -1.06674,0.96007 -2.08007,2.72006 -3.04,5.28 l -24.64,65.28 c -4.26671,11.51999 -8.53337,19.73331 -12.8,24.64 -4.16003,4.90663 -8.90669,7.35997 -14.24,7.36 -3.41335,-3e-5 -6.24001,-0.9067 -8.48,-2.72 -2.24001,-1.7067 -3.36,-3.89336 -3.36,-6.56 0,-1.92002 0.69333,-3.57336 2.08,-4.96 1.38666,-1.38669 2.98666,-2.08002 4.8,-2.08 2.34665,-2e-5 4.85332,0.47998 7.52,1.44 2.66664,0.95998 4.31998,1.43998 4.96,1.44"
+               inkscape:connector-curvature="0" />
+            <path
+               style="text-anchor:middle"
+               id="path3397"
+               d="m 316.165,571.32 v -2.72 c 7.67999,-2.13326 15.14665,-4.53326 22.4,-7.2 l 1.12,0.32 v 12 c 6.6133,-5.01327 11.51996,-8.31993 14.72,-9.92 3.19996,-1.59993 6.55995,-2.39993 10.08,-2.4 8.42661,7e-5 14.07993,4.48007 16.96,13.44 8.31992,-8.95993 17.01325,-13.43993 26.08,-13.44 12.37323,7e-5 18.55989,9.4934 18.56,28.48 v 32.96 c -1.1e-4,5.97334 2.29322,9.12 6.88,9.44 l 4.16,0.32 v 2.4 h -35.04 v -2.4 c 4.69324,-0.53333 7.62657,-1.44 8.8,-2.72 1.17323,-1.27999 1.7599,-4.21332 1.76,-8.8 v -33.76 c -10e-5,-6.61328 -0.85343,-11.19994 -2.56,-13.76 -1.70676,-2.55994 -4.85343,-3.83993 -9.44,-3.84 -7.04008,7e-5 -12.85341,3.2534 -17.44,9.76 v 40.32 c -7e-5,5.01334 0.7466,8.37334 2.24,10.08 1.59993,1.70667 4.69326,2.61334 9.28,2.72 v 2.4 h -35.84 v -2.4 c 4.58662,-0.32 7.51995,-1.17333 8.8,-2.56 1.38661,-1.38666 2.07994,-4.31999 2.08,-8.8 v -34.72 c -6e-5,-11.19994 -3.52005,-16.79993 -10.56,-16.8 -2.77338,7e-5 -5.70671,0.64006 -8.8,1.92 -3.09337,1.1734 -5.65336,2.66673 -7.68,4.48 -1.60003,1.60006 -2.40003,2.61339 -2.4,3.04 v 45.12 c -3e-5,3.09334 0.74664,5.22667 2.24,6.4 1.4933,1.06667 4.3733,1.70667 8.64,1.92 v 2.4 h -35.52 v -2.4 c 4.47999,-0.10666 7.46666,-0.90666 8.96,-2.4 1.49332,-1.49333 2.23999,-4.42666 2.24,-8.8 v -40.48 c -10e-6,-3.83994 -0.42668,-6.50661 -1.28,-8 -0.74668,-1.49327 -2.18668,-2.23994 -4.32,-2.24 -1.60001,6e-5 -3.30667,0.2134 -5.12,0.64"
+               inkscape:connector-curvature="0" />
+            <path
+               style="text-anchor:middle"
+               id="path3399"
+               d="m 524.22,558.04 c -9e-5,2.77341 -0.32009,5.44007 -0.96,8 -0.64009,2.56007 -1.92008,5.28006 -3.84,8.16 -1.81341,2.88006 -4.26674,5.38672 -7.36,7.52 -3.0934,2.02672 -7.30673,3.73338 -12.64,5.12 -5.33339,1.38671 -11.52005,2.08005 -18.56,2.08 -3.20004,5e-5 -6.88004,-0.15995 -11.04,-0.48 v 29.12 c -3e-5,5.86668 0.90663,9.70667 2.72,11.52 1.91996,1.70667 6.02663,2.66667 12.32,2.88 V 635 h -44.8 v -3.04 c 6.07999,-0.53333 9.81332,-1.65333 11.2,-3.36 1.49332,-1.81333 2.23998,-6.07999 2.24,-12.8 v -69.28 c -2e-5,-5.75991 -0.74668,-9.4399 -2.24,-11.04 -1.49335,-1.5999 -5.22668,-2.7199 -11.2,-3.36 v -3.04 h 42.24 c 4.79995,1.1e-4 9.43995,0.48011 13.92,1.44 4.47994,0.85344 8.9066,2.29344 13.28,4.32 4.47992,2.02676 8.05325,5.01343 10.72,8.96 2.66658,3.94675 3.99991,8.69342 4,14.24 m -54.4,-17.6 v 41.6 c 3.62663,0.32005 6.66663,0.48005 9.12,0.48 18.55994,5e-5 27.83993,-7.83994 27.84,-23.52 -7e-5,-8.21325 -2.56007,-14.23991 -7.68,-18.08 -5.12006,-3.94657 -13.06672,-5.9199 -23.84,-5.92 -2.13337,10e-5 -3.57337,0.37343 -4.32,1.12 -0.7467,0.74676 -1.12003,2.18676 -1.12,4.32"
+               inkscape:connector-curvature="0" />
+            <path
+               style="text-anchor:middle"
+               id="path3401"
+               d="m 550.7225,656.44 c 2.98664,-2e-5 6.1333,-3.30668 9.44,-9.92 3.30663,-6.61334 4.95996,-11.46667 4.96,-14.56 -4e-5,-2.34666 -2.3467,-7.73332 -7.04,-16.16 l -2.4,-4.8 -18.72,-40.64 c -1.28001,-2.77327 -4.00001,-4.47993 -8.16,-5.12 V 563 h 32.96 v 2.4 c -3.41337,0.10674 -5.81336,0.48007 -7.2,1.12 -1.38669,0.64007 -2.08003,1.70673 -2.08,3.2 -3e-5,1.60006 0.53331,3.62673 1.6,6.08 l 18.4,40.48 15.52,-44.16 c 0.4266,-0.95994 0.63994,-1.8666 0.64,-2.72 -6e-5,-2.6666 -2.56006,-3.99993 -7.68,-4 V 563 h 21.6 v 2.4 c -1.92007,0.2134 -3.46674,0.8534 -4.64,1.92 -1.06674,0.96007 -2.08007,2.72006 -3.04,5.28 l -24.64,65.28 c -4.26671,11.51999 -8.53337,19.73331 -12.8,24.64 -4.16003,4.90663 -8.90669,7.35997 -14.24,7.36 -3.41335,-3e-5 -6.24001,-0.9067 -8.48,-2.72 -2.24001,-1.7067 -3.36,-3.89336 -3.36,-6.56 0,-1.92002 0.69333,-3.57336 2.08,-4.96 1.38666,-1.38669 2.98666,-2.08002 4.8,-2.08 2.34665,-2e-5 4.85332,0.47998 7.52,1.44 2.66664,0.95998 4.31998,1.43998 4.96,1.44"
+               inkscape:connector-curvature="0" />
+          </g>
+        </g>
+        <g
+           id="SnakeTail"
+           mask="url(#Mask-5)">
+          <g
+             style="display:inline"
+             id="layer1-7">
+            <path
+               style="fill:#72ba45;fill-opacity:1;fill-rule:evenodd;stroke:#293720;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3272"
+               d="m 170.92127,334.28345 c 0,0 -17.6669,-10.23477 -40.08013,-15.97623 -22.41323,-5.74146 -26.89588,-4.24368 -49.572798,-6.9896 -22.676918,-2.74591 -41.134874,-3.99406 -41.134874,-3.99406 l -1.054741,-78.88265 c 0,0 33.080135,3.74442 59.448643,7.98811 26.36851,4.24369 27.92691,4.49332 46.02539,8.98664 18.09848,4.49332 26.36851,8.98663 26.36851,8.98663 z"
+               inkscape:connector-curvature="0" />
+          </g>
+          <path
+             style="fill:#c7e06d;fill-opacity:1;fill-rule:evenodd;stroke:#c7e06d;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:0.53947371"
+             id="path3274-8"
+             d="m 162.55026,277.04847 c 0,0 -22.75,-10.26558 -55,-15.76434 -32.250008,-5.49875 -75.000008,-8.23067 -75.000008,-8.23067 l -0.5,-9.86285 c 0,0 44.5,2.0823 77.500008,7.03117 33,4.94888 53,12.76435 53,12.76435 z"
+             inkscape:connector-curvature="0" />
+          <path
+             style="fill:#2e642c;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+             id="path3276"
+             d="m 167.58579,331.03375 c 0,0 -13.25,-9.40357 -45.5,-16.0344 -32.250004,-6.63083 -84.914218,-8.38916 -84.914218,-8.38916 l 0.414214,-30.09115 c 0,0 44,0.91672 77.000004,6.88446 33,5.96775 52.5,13.91387 52.5,13.91387 z"
+             inkscape:connector-curvature="0" />
+          <path
+             style="fill:#4f873b;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+             id="path3278"
+             d="m 167.20711,314.61954 c 0,0 -13.25,-10.29864 -45.5,-14.74006 -32.25,-4.44143 -84.914219,-5.61918 -84.914219,-5.61918 l 0.414214,-20.15547 c 0,0 44.000005,3.61403 77.000005,7.61131 33,3.99728 52.5,14.3197 52.5,14.3197 z"
+             inkscape:connector-curvature="0" />
+          <g
+             style="opacity:0.647343"
+             id="TailSpots">
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5172"
+               transform="translate(6.1263726,4.9387864)"
+               d="m 151.32084,278.78738 a 16.970562,18.384775 0 1 1 -33.94112,0 16.970562,18.384775 0 1 1 33.94112,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5174"
+               transform="translate(6.1263726,4.9387864)"
+               d="m 83.438599,268.88788 a 20.506096,21.213203 0 1 1 -41.012192,0 20.506096,21.213203 0 1 1 41.012192,0 z"
+               inkscape:connector-curvature="0" />
+          </g>
+        </g>
+        <g
+           id="Cube">
+          <path
+             style="fill:#decd85;fill-opacity:1;fill-rule:evenodd;stroke:#505050;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:0.61842107"
+             id="path3284"
+             d="m 172.63069,123.73147 200,60 v 270 l -200,-60 z"
+             inkscape:connector-curvature="0" />
+          <path
+             style="fill:#b9b083;fill-opacity:1;fill-rule:evenodd;stroke:#505050;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+             id="path3286"
+             d="m 572.63069,123.73147 -200,60 v 270 l 200,-60 z"
+             inkscape:connector-curvature="0" />
+          <path
+             style="fill:#eee5bd;fill-opacity:1;fill-rule:evenodd;stroke:#505050;stroke-width:8;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:0.65789472"
+             id="path3288"
+             d="m 172.6305,123.73168 200,60 200,-60 -200,-69.999997 z"
+             inkscape:connector-curvature="0" />
+          <g
+             id="g3290">
+            <g
+               style="font-style:normal;font-weight:normal;font-size:180px;fill:#897751;fill-opacity:1;stroke:none"
+               id="text3292"
+               transform="matrix(0.9140294,-0.3682282,-0.03940923,1.1099332,0,0)">
+              <path
+                 id="path3404"
+                 d="m 472.43859,536 c -5.28002,-4e-5 -9.96002,-1.38003 -14.04,-4.14 -3.96001,-2.76003 -5.94001,-6.48003 -5.94,-11.16 -1e-5,-2.28002 0.71999,-4.08002 2.16,-5.4 1.55999,-1.32001 3.35999,-1.98001 5.4,-1.98 2.03998,-1e-5 3.77998,0.65999 5.22,1.98 1.55998,1.31998 2.33998,3.11998 2.34,5.4 -2e-5,2.15998 -0.66002,3.89998 -1.98,5.22 -1.32002,1.31997 -2.94002,2.09997 -4.86,2.34 3.11998,2.51997 7.01998,3.77997 11.7,3.78 11.63996,-3e-5 17.45996,-12.42002 17.46,-37.26 V 379.22 c -4e-5,-11.03987 2.93995,-20.63986 8.82,-28.8 5.99994,-8.27984 13.85993,-12.41984 23.58,-12.42 5.27992,1.6e-4 9.89991,1.38016 13.86,4.14 4.07991,2.76016 6.1199,6.48015 6.12,11.16 -10e-5,2.40014 -0.7801,4.26014 -2.34,5.58 -1.44009,1.20014 -3.18009,1.80014 -5.22,1.8 -2.04009,1.4e-4 -3.84008,-0.59986 -5.4,-1.8 -1.44008,-1.31986 -2.16008,-3.17986 -2.16,-5.58 -8e-5,-2.15985 0.65992,-3.89985 1.98,-5.22 1.31992,-1.31985 2.93991,-2.09985 4.86,-2.34 -3.12008,-2.51984 -7.02008,-3.77984 -11.7,-3.78 -11.64006,1.6e-4 -17.46006,12.42015 -17.46,37.26 v 115.56 c -6e-5,11.03999 -3.00006,20.63998 -9,28.8 -5.88004,8.27997 -13.68004,12.41996 -23.4,12.42"
+                 inkscape:connector-curvature="0" />
+            </g>
+          </g>
+          <g
+             id="g3296-2">
+            <g
+               style="font-style:normal;font-weight:normal;font-size:110px;fill:#897751;fill-opacity:1;stroke:none"
+               id="text3298"
+               transform="matrix(0.8246541,-0.2574405,0,1.2126296,0,0)">
+              <path
+                 id="path3407"
+                 d="m 612.97,400 v -3.41 c -7.69999,0 -8.58,-0.77001 -8.58,-6.16 v -66.77 l -15.84,1.21 v 3.41 c 7.69999,0 8.58,0.77001 8.58,6.16 v 23.76 c -3.19,-3.96 -7.92001,-6.82 -13.86,-6.82 -12.97999,0 -24.53,10.78001 -24.53,24.97 0,13.96999 10.78001,24.86 23.32,24.86 7.03999,0 11.99,-3.74 14.74,-7.26 v 7.26 L 612.97,400 M 596.8,387.02 c 0,1.98 0,2.2 -1.21,4.07 -3.3,5.27999 -8.25,7.7 -12.98,7.7 -4.95,0 -8.91,-2.86 -11.55,-7.04 -2.86,-4.51 -3.19,-10.78 -3.19,-15.29 0,-4.07 0.22,-10.67 3.41,-15.62 2.31,-3.41 6.49001,-7.04 12.43,-7.04 3.85,0 8.47,1.65 11.88,6.6 1.21,1.87 1.21,2.09 1.21,4.07 v 22.55"
+                 inkscape:connector-curvature="0" />
+              <path
+                 style="font-style:italic"
+                 id="path3409"
+                 d="m 669.91047,384.27 c 0,-1.1 -0.88,-1.1 -1.65,-1.1 -1.32,0 -1.43,0.11 -1.98,1.87 -2.97,9.45999 -8.47001,13.75 -13.09,13.75 -2.2,0 -5.17,-1.32001 -5.17,-7.04 0,-2.64 1.21,-7.37 2.09,-11.11 l 3.74,-15.07 c 1.54,-5.71999 4.51,-11.77 9.68,-11.77 0.33,0 3.08,0 4.84,1.54 -4.4,1.1 -4.4,5.28 -4.4,5.28 0,1.43 0.99,3.52 3.85,3.52 1.98,0 5.39,-1.54 5.39,-5.83 0,-5.60999 -6.38,-6.93 -9.57,-6.93 -6.05,0 -9.68,5.39 -10.78,7.48 -2.42,-6.59999 -7.81,-7.48 -10.56,-7.48 -10.99999,0 -16.94,14.41 -16.94,16.94 0,1.1 1.1,1.1 1.65,1.1 1.43,0 1.43,-0.11 1.98,-1.87 2.97,-9.45999 8.69,-13.75 13.09,-13.75 3.19,0 5.28,2.53 5.28,6.93 0,2.64 -1.32,8.03 -2.31,12.1 l -2.53,10.01 c -1.76,7.14999 -4.07001,15.95 -10.67,15.95 -0.33,0 -2.97,0 -4.84,-1.54 3.3,-0.88 4.29,-3.63 4.29,-5.28 0,-2.86 -2.31,-3.52 -3.74,-3.52 -2.75,0 -5.5,2.31 -5.5,5.94 0,4.29 4.62,6.82 9.68,6.82 5.27999,0 8.91,-4.18 10.78,-7.48 2.2,6.26999 7.59,7.48 10.45,7.48 11.32999,0 16.94,-14.74 16.94,-16.94"
+                 inkscape:connector-curvature="0" />
+            </g>
+          </g>
+          <g
+             id="g3304-8">
+            <g
+               style="font-style:normal;font-weight:normal;font-size:244px;fill:#897751;fill-opacity:1;stroke:none"
+               id="text3306"
+               transform="matrix(0.8385983,0.2552685,0,1.192466,0,0)">
+              <path
+                 id="path3412"
+                 d="m 403.169,201.40559 h -6.1 c -4.392,40.74796 -20.98404,47.336 -59.292,47.336 h -67.344 l 61.244,-69.296 c 2.19599,-2.43999 2.196,-3.904 2.196,-3.904 0,-1.22 -0.976,-2.44 -1.708,-3.416 l -50.02,-72.223996 h 56.364 c 41.23596,0 53.436,8.784036 58.56,47.335996 h 6.1 l -6.832,-54.899996 h -135.42 c -5.856,0 -6.344,5e-6 -6.344,5.612 l 60.756,88.327996 -58.072,66.124 c -2.44,2.684 -2.44,3.172 -2.44,3.904 0,2.684 2.44,2.684 6.1,2.684 h 135.42 l 6.832,-57.584"
+                 inkscape:connector-curvature="0" />
+            </g>
+          </g>
+          <g
+             id="g3310">
+            <g
+               style="font-style:normal;font-weight:normal;font-size:50px;display:inline;fill:#9a8354;fill-opacity:1;stroke:none"
+               id="text3312"
+               transform="matrix(1.4265625,-0.3736626,1.32988,0.3526474,0,0)">
+              <path
+                 style="font-weight:bold"
+                 id="path3415"
+                 d="m -40.3,292 v -2.35 h -7 v -28.8 c 0,-1.1 -1e-6,-1.6 -1.3,-1.6 -0.549999,0 -0.65,0 -1.1,0.35 -3.849996,2.85 -9.000001,2.85 -10.05,2.85 h -1 v 2.35 h 1 c 0.799999,0 3.550003,-0.05 6.5,-1 v 25.85 H -60.2 V 292 c 2.199998,-0.15 7.500002,-0.15 9.95,-0.15 2.449998,0 7.750002,0 9.95,0.15"
+                 inkscape:connector-curvature="0" />
+              <path
+                 style="font-weight:bold"
+                 id="path3417"
+                 d="m 9.3015625,276.05 c 0,-4.85 -0.050012,-16.8 -12.1,-16.8 -12.0499875,0 -12.1000005,11.9 -12.1000005,16.8 0,4.95 0.05001,16.5 12.1000005,16.5 11.999988,0 12.1,-11.5 12.1,-16.5 m -6.4,-0.6 c 0,2.8 -3e-7,7.35 -0.35,9.95 -0.6999993,4.65 -3.8500015,5.35 -5.35,5.35 -1.7999982,0 -4.6000006,-1.1 -5.25,-4.75 -0.4499996,-2.6 -0.45,-7.8 -0.45,-10.55 0,-3.6 4e-7,-6.85 0.4,-9.45 0.5999994,-4.45 4.1000012,-4.95 5.3,-4.95 1.84999815,0 3.900001,0.95 4.85,3.15 0.8499992,1.85 0.85,7.15 0.85,11.25"
+                 inkscape:connector-curvature="0" />
+              <path
+                 style="font-weight:bold"
+                 id="path3419"
+                 d="m -38.55,350.05 c 0,-4.85 -0.05001,-16.8 -12.1,-16.8 -12.049988,0 -12.1,11.9 -12.1,16.8 0,4.95 0.05001,16.5 12.1,16.5 11.999988,0 12.1,-11.5 12.1,-16.5 m -6.4,-0.6 c 0,2.8 0,7.35 -0.35,9.95 -0.699999,4.65 -3.850002,5.35 -5.35,5.35 -1.799998,0 -4.600001,-1.1 -5.25,-4.75 -0.45,-2.6 -0.45,-7.8 -0.45,-10.55 0,-3.6 0,-6.85 0.4,-9.45 0.599999,-4.45 4.100001,-4.95 5.3,-4.95 1.849998,0 3.900001,0.95 4.85,3.15 0.849999,1.85 0.85,7.15 0.85,11.25"
+                 inkscape:connector-curvature="0" />
+              <path
+                 style="font-weight:bold"
+                 id="path3421"
+                 d="m 7.5515625,366 v -2.35 h -7 v -28.8 c 0,-1.1 -1.3e-6,-1.6 -1.3,-1.6 -0.5499994,0 -0.6500005,0 -1.1,0.35 -3.8499961,2.85 -9.0000015,2.85 -10.0500005,2.85 h -1 v 2.35 h 1 c 0.8,0 3.5500034,-0.05 6.5000005,-1 v 25.85 H -12.348437 V 366 c 2.199997,-0.15 7.5000019,-0.15 9.9499995,-0.15 2.44999755,0 7.7500022,0 9.95,0.15"
+                 inkscape:connector-curvature="0" />
+            </g>
+          </g>
+          <g
+             style="display:inline"
+             id="g3318"
+             transform="matrix(0.7152743,-0.2134016,0.6667979,0.2013996,-410.97556,263.60616)">
+            <g
+               style="font-style:normal;font-weight:bold;font-size:160px;font-family:font-family;fill:#9a8354;fill-opacity:1;stroke:none"
+               id="text3320"
+               transform="matrix(0.6991488,0.00805929,0.01450938,1.4304778,0,0)">
+              <path
+                 id="path3424"
+                 d="m 1136.88,240 v -9.76 h -16.64 V 89.76 h 16.64 V 80 h -26.4 v 160 h 26.4"
+                 inkscape:connector-curvature="0" />
+              <path
+                 id="path3426"
+                 d="M 1398.4,240 V 80 H 1372 v 9.76 h 16.64 V 230.24 H 1372 V 240 h 26.4"
+                 inkscape:connector-curvature="0" />
+            </g>
+          </g>
+        </g>
+        <g
+           id="g3326">
+          <g
+             id="SnakeShadowOnCube">
+            <path
+               style="opacity:0.5;fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+               id="path3329"
+               d="m 361,258.36218 c -16.75,-14 62.75,3.25 90,12 27.25,8.75 43.25,17 60,31 11.33477,9.47384 24.42395,31.77646 26.49137,45.08194 0.98772,6.35675 5.31849,60.74691 -3.49137,57.91806 -1.06953,-0.34343 -30.58008,10.45047 -14.97959,4.11095 C 553.73372,394.36679 377.09258,271.8127 361,258.36218 Z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.08229625px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+               id="path3331"
+               d="m 238.15783,193.79605 c -4.6711,41.77964 23.21085,78.9437 53.62131,101.28922 23.93562,17.76425 50.20176,35.46237 79.73433,38.66778 22.62966,-2.00055 51.60989,-4.88351 64.27626,19.81778 18.49993,14.19304 34.72971,-17.24671 22.16329,-32.73091 -20.50575,-31.161 -53.92626,-48.24665 -83.70721,-67.32708 -45.58322,-26.67745 -81.4267,-66.81777 -127.84568,-91.69958 -4.18445,5.4129 -6.45208,18.17567 -8.2423,31.98279 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+               id="path3333"
+               d="m 532,109.36218 c -54.43793,-2.20109 -110.70185,-3.89948 -162.71356,15.00701 -24.07729,7.59167 -46.17027,28.99154 -47.17492,55.31512 0.99907,10.79836 2.99194,21.11095 4.83219,31.77672 3.22089,12.79811 11.08139,24.30234 12.55466,37.50128 -5.68381,5.29372 -17.71713,-4.56965 -25.91182,-5.40461 -8.21075,-4.66608 -24.4249,-4.1548 -27.27405,-12.28927 3.22916,-31.96875 6.45834,-63.9375 9.6875,-95.90625 33.66667,-15.33333 67.33333,-30.66666 101,-45.999997 45,6.666668 90,13.333337 135,19.999997 z"
+               inkscape:connector-curvature="0" />
+          </g>
+          <g
+             id="SnakeBody">
+            <path
+               style="fill:#72ba45;fill-opacity:1;fill-rule:evenodd;stroke:#344829;stroke-width:8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3336"
+               d="m 248.76738,444.18516 c -5.12947,-4.39883 -17.69479,-21.13307 -22.2545,-26.63224 -9.85802,-11.88911 5.44154,-3.3438 18.80805,-0.17505 38.31224,10.5211 82.08483,24.11202 120.35467,34.61487 21.39325,-1.75072 46.72259,-6.40242 64.08498,-20.29343 18.40328,-24.12475 22.83497,-59.44769 10.10528,-87.07301 -19.03525,-24.88418 -52.69045,-29.63012 -80.93694,-38.09533 -34.11995,-7.74274 -64.14645,-27.04835 -88.68612,-51.55904 -31.22122,-25.39248 -31.34681,-71.70204 -17.39928,-106.32974 8.15527,-27.74666 28.00887,-52.043346 55.78705,-61.613318 44.02385,-19.399692 92.7684,-22.2495 140.17657,-19.602942 45.6465,2.044748 91.17091,10.306448 133.40139,28.133935 19.52665,7.871435 35.51289,8.143605 56.87645,4.457025 10.85708,3.85097 23.3021,9.7053 29.78305,16.19099 11.74284,11.75143 18.03434,32.84682 28.66856,45.22551 20.13161,22.85063 -10.35476,50.69262 -34.5927,36.82391 -24.51302,-7.42788 -59.27977,-0.93786 -71.11851,-30.09578 -5.65189,-15.94435 -18.44611,-20.32276 -17.83234,-40.59718 -15.55356,-14.81994 -42.92172,-17.18441 -63.17764,-20.58093 -59.99385,-9.001939 -126.86123,-11.640898 -180.37543,21.95856 -22.55209,13.85073 -36.06769,46.78551 -20.63639,70.2983 19.62962,19.3369 49.71097,19.97355 74.76058,28.00809 48.57379,11.07831 101.24422,28.80981 128.59833,73.79792 14.28665,23.12036 14.07072,51.74151 15.90426,78.0563 1.09817,41.76119 -11.00848,80.01368 -55.88599,107.91201 -46.93252,20.14123 -87.03848,16.76304 -130.53624,6.69765 -37.84847,-9.04751 -63.90374,-20.80423 -93.87714,-49.52708 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#000000;fill-opacity:1;stroke:#505050;stroke-width:6;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3338"
+               transform="translate(-3.5147186,12.242641)"
+               d="m 646.2956,162.82185 a 6.3639612,5.6568542 0 1 1 -12.72792,0 6.3639612,5.6568542 0 1 1 12.72792,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#000000;fill-opacity:1;stroke:#505050;stroke-width:6;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3340"
+               transform="translate(-7.7573593,6.5857864)"
+               d="m 674.57984,131.00204 a 6.3639612,6.3639612 0 1 1 -12.72792,0 6.3639612,6.3639612 0 1 1 12.72792,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:none;stroke:#9d2020;stroke-width:6;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3342"
+               d="m 699.68521,195.61348 c 4.40722,5.24471 6.64759,11.31371 16.97056,11.31371 0.84379,4.21894 0,9.73869 0,14.14214"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:none;stroke:#9d2020;stroke-width:6;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3344"
+               d="m 716.49156,206.93455 c 0.0183,0.0914 11.9877,0 16.97056,0"
+               inkscape:connector-curvature="0" />
+          </g>
+          <g
+             id="SnakeShadowsOnHimself">
+            <path
+               style="fill:#2e642c;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3347"
+               d="m 247.06512,201.86764 c 1.23552,14.8792 3.85173,27.33542 12.41152,38.68717 15.44547,20.48333 35.43746,36.04792 58.92937,48.49625 9.53528,5.05273 21.87191,9.3161 32.16339,12.16067 29.3203,8.85585 63.59133,15.44236 86.94409,37.54982 16.69756,19.60154 -1.21302,-17.27368 -16.59063,-28.92819 -42.86834,-32.4894 -105.80462,-26.42057 -145.42419,-65.61546 -11.29779,-12.05426 -22.1684,-27.17504 -28.43355,-42.35026 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:#2e642c;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3349"
+               d="m 523.94862,350.50954 c -1.92051,36.11977 -9.32335,81.59128 -33.95162,107.82436 -42.39924,29.90848 -111.31137,31.9416 -159.20628,15.15078 -26.04853,-8.08515 -46.1684,-19.90861 -69.90385,-33.31978 -9.28627,-5.26737 -21.15102,-18.148 -25.0315,-19.54549 -5.42831,-1.95491 5.48649,15.11707 11.71143,21.59197 28.78325,32.91722 65.95663,42.62636 116.38048,54.37355 43.88156,5.74838 74.33495,9.26503 118.99806,-17.75552 31.70243,-24.22432 36.65843,-44.21023 41.63306,-67.82542 3.9957,-36.67574 1.15541,-34.61895 -0.62978,-60.49445 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:#2e642c;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3351"
+               d="m 307.358,201.83211 c -9.58287,-27.38101 -5.84416,-50.95254 11.36351,-65.68176 21.44881,-18.3595 36.7853,-24.06087 67.88027,-33.46211 33.55903,-2.850363 48.22782,-2.52697 123.09099,1.60879 -57.34912,-10.270508 -133.4335,-19.895675 -186.61849,8.781 -30.8782,17.81976 -44.48474,59.19741 -15.71628,88.75408 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:#2e642c;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3353"
+               d="m 576,122.86218 c 1.30319,1.14583 1.69415,7.73437 6.25532,14.89583 4.56117,7.16146 8.07978,7.01823 11.98936,13.75 3.90958,6.73177 2.08512,6.58856 3.64895,13.1771 1.56383,6.58854 3.90956,13.89322 2.60637,13.17707 -1.30319,-0.71615 -3.25798,-8.59375 -7.81915,-16.04167 -4.56117,-7.44792 -6.51595,-6.58854 -10.42553,-13.75 -3.90958,-7.16146 -3.64894,-8.59375 -5.21277,-14.89583 -1.56383,-6.30208 -2.34574,-11.45833 -1.04255,-10.3125 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:#4f873b;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3355"
+               d="m 522.64319,350.78705 c -3.42346,22.38072 -10.29113,50.82418 -21.04718,68.87544 -18.65057,24.06141 -26.78182,29.51753 -51.23445,41.49624 -39.02155,12.01284 -89.71864,16.62167 -135.59707,-1.0193 -24.22596,-8.37937 -49.39605,-16.18543 -69.66018,-33.56766 -2.75422,-5.43511 -16.99282,-13.1013 -9.04722,-1.51486 19.06759,33.02699 54.2761,48.30707 87.41496,57.31422 35.22549,9.61256 73.00732,16.51453 108.73485,5.85207 36.39573,-6.61297 64.84748,-25.70875 83.51457,-63.25121 5.51457,-12.86201 9.00357,-43.63763 7.77005,-57.7858 0.0529,-5.56959 -1.39449,-10.86169 -0.84833,-16.39914 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:#4f873b;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3357"
+               d="m 247.42428,191.09585 c 1.23552,14.8792 3.85173,27.33542 12.41152,38.68717 15.44547,20.48333 35.43746,36.04792 58.92937,48.49625 9.53528,5.05273 21.87191,9.3161 32.16339,12.16067 29.3203,8.85585 62.09133,18.94236 85.44409,41.04982 8.19756,7.10154 -0.71302,-11.77368 -16.09063,-23.42819 C 377.41368,275.57217 311.4774,279.641 271.85783,240.44611 260.56004,228.39185 253.68943,206.27107 247.42428,191.09585 Z"
+               inkscape:connector-curvature="0" />
+          </g>
+          <g
+             id="SnakeHighlight">
+            <path
+               style="fill:#c7e06d;fill-opacity:1;fill-rule:evenodd;stroke:#c7e06d;stroke-width:13.42280579;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:0.52631579"
+               id="path3360"
+               d="m 489.7672,394.90659 c -0.29691,-28.04121 -5.46934,-77.5371 -36.00531,-100.9745 -35.92731,-36.02516 -101.64396,-26.70064 -143.4266,-52.77911 -17.19136,-15.58002 29.21192,-4.30903 67.8021,5.38282 39.26909,9.14362 86.22738,17.74234 109.84219,52.02132 19.12527,32.54391 22.726,74.71543 1.78762,96.34947 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="fill:#c7e06d;fill-opacity:1;fill-rule:evenodd;stroke:#c7e06d;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:0.51315792"
+               id="path3362"
+               d="m 263.1579,189.5392 c -4.74945,-27.3249 2.95249,-57.61502 24.60496,-75.98206 32.02015,-28.124455 75.84873,-37.041755 117.35959,-37.853421 57.22552,-2.747702 114.83034,5.845541 168.76481,25.166661 13.38846,4.66984 26.75894,9.48324 39.65488,15.40058 -42.82157,-8.27363 -84.18345,-23.64591 -127.72895,-28.447671 -35.39798,-4.295059 -71.32523,-5.58274 -106.86354,-2.82665 -30.69445,4.099793 -64.0426,10.443042 -85.84973,34.485041 -12.76171,10.44391 -21.75105,25.32345 -22.77836,42.01893 -3.98589,18.82851 2.03822,40.06595 15.70395,52.92052 15.24579,10.62373 14.66766,11.29425 26.25416,15.84645 7.05994,2.77377 7.12215,3.86769 8.61377,7.99504 0.75318,2.08407 -0.40588,4.24319 1.34671,6.0016 -7.05547,-1.22969 -12.47926,-1.65733 -18.44911,-4.48693 -6.47881,-3.07084 -10.98315,-6.20515 -20.49301,-14.12752 C 273.1104,215.2277 265.01053,204.99266 263.1579,189.5392 Z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#c7e06d;fill-opacity:1;stroke:#650606;stroke-width:0;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3364"
+               d="m 660.49999,124.8622 c 0.6488,3.244 -4.85341,-4.51506 -7.5,-6.5 -2.73789,-2.05341 -5.70871,-2.35435 -8,-3.5 -2.73683,-1.36841 -3.23118,-2.23117 -5.5,-4.5 -4.01209,-4.01209 3.47628,-1.5 7,-1.5 1.87671,0 6.78317,3.89159 9,5 2.61386,1.30693 5.53486,3.02615 7.5,4.5 2.05466,1.54099 2.14668,3.79336 3,5.5 0.83333,1.66667 -3.73224,0.41074 -5.5,1 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#c7e06d;fill-opacity:1;stroke:#650606;stroke-width:0;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3366"
+               d="m 685.49999,192.3622 c -2.38601,3.18134 4.85518,-4.21037 7,-8.5 1.03207,-2.06416 0.0338,-8.86465 -0.5,-11 -0.8324,-3.32958 -2.55027,-5.40035 -4.5,-8 -1.61555,-2.15407 5.09168,1.79584 7.5,3 1.58265,0.79133 2,4.02402 2,6.5 0,2.5 0,5 0,7.5 0,2.69271 -1.0684,5.63679 -2,7.5 -0.71004,1.42008 -2.95061,1 -4.5,1"
+               inkscape:connector-curvature="0" />
+            <path
+               style="opacity:0.5;fill:#c7e06d;fill-opacity:1;stroke:#650606;stroke-width:0;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path3368"
+               d="m 613.76867,167.06451 c 3.9556,-7.23377 9.5964,-9.89949 19.79899,-9.89949 11.27222,0 16.39614,0.26535 11.31371,-9.8995 -3.82193,-7.64385 -8.85847,-10.56732 -4.24264,-19.79899 6.159,-12.318 -9.16957,-3.02232 -11.31371,-1.41421 -7.89044,5.91783 -12.20562,5.65685 -22.62741,5.65685 -6.03253,0 -4.24264,3.1655 -4.24264,8.48528"
+               inkscape:connector-curvature="0" />
+          </g>
+          <g
+             style="display:inline;opacity:0.647343"
+             id="Spots">
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5123"
+               transform="translate(2.978574,-1.5883554)"
+               d="m 576.99911,108.37466 a 4.2426405,4.9497476 0 1 1 -8.48528,0 4.2426405,4.9497476 0 1 1 8.48528,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5125"
+               transform="translate(-5.021426,-2.5883554)"
+               d="m 544.47224,97.060944 a 6.3639607,4.9497476 0 1 1 -12.72792,0 6.3639607,4.9497476 0 1 1 12.72792,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5129"
+               transform="matrix(0.8536968,0,0,0.6741498,75.153544,26.774045)"
+               d="m 493.56051,88.575668 a 7.07107,7.7781768 0 1 1 -14.14214,0 7.07107,7.7781768 0 1 1 14.14214,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5131"
+               transform="translate(0.978574,-3.5883554)"
+               d="m 452.54832,86.454346 a 7.778175,5.6568546 0 1 1 -15.55635,0 7.778175,5.6568546 0 1 1 15.55635,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5133"
+               transform="translate(-0.02142598,-4.5883554)"
+               d="m 403.05086,89.282776 a 8.485281,7.0710678 0 1 1 -16.97056,0 8.485281,7.0710678 0 1 1 16.97056,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5135"
+               transform="translate(-0.02142598,-5.5883554)"
+               d="m 357.79601,101.30359 a 9.8994951,7.7781744 0 1 1 -19.79899,0 9.8994951,7.7781744 0 1 1 19.79899,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5137"
+               transform="translate(2.978574,-1.5883554)"
+               d="m 315.36963,122.51679 a 12.020815,10.606602 0 1 1 -24.04163,0 12.020815,10.606602 0 1 1 24.04163,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5141"
+               transform="translate(2.978574,-0.5883554)"
+               d="m 288.49956,167.77162 a 12.727921,12.020815 0 1 1 -25.45584,0 12.727921,12.020815 0 1 1 25.45584,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:6.7851944;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5144"
+               transform="matrix(1.1968479,0,0,1.1614925,-61.374176,-37.616965)"
+               d="m 318.19804,229.28992 a 14.142136,14.142136 0 1 1 -28.28427,0 14.142136,14.142136 0 1 1 28.28427,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5148"
+               transform="translate(2.978574,-1.5883554)"
+               d="m 400.22243,268.88788 a 20.506096,18.384775 0 1 1 -41.01219,0 20.506096,18.384775 0 1 1 41.01219,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5150"
+               transform="translate(2.978574,-1.5883554)"
+               d="m 473.76152,306.36456 a 16.970565,17.677673 0 1 1 -33.94113,0 16.970565,17.677673 0 1 1 33.94113,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5152"
+               transform="translate(2.978574,-1.5883554)"
+               d="m 504.87422,375.66101 a 15.55635,19.091884 0 1 1 -31.1127,0 15.55635,19.091884 0 1 1 31.1127,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:8;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5154"
+               transform="translate(2.978574,-1.5883554)"
+               d="m 489.31787,434.35086 a 14.849242,15.556349 0 1 1 -29.69848,0 14.849242,15.556349 0 1 1 29.69848,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:5.81596088;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5158"
+               transform="matrix(1.5743387,0,0,1.2018184,-254.19056,-88.883685)"
+               d="m 446.89147,469.70621 a 11.31371,9.8994969 0 1 1 -22.62742,0 11.31371,9.8994969 0 1 1 22.62742,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:5.34536552;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5168"
+               transform="matrix(1.4431355,0,0,1.5520942,-175.51534,-257.01053)"
+               d="m 376.1808,470.41333 a 11.313708,6.3639607 0 1 1 -22.62741,0 11.313708,6.3639607 0 1 1 22.62741,0 z"
+               inkscape:connector-curvature="0" />
+            <path
+               style="display:inline;opacity:0.5;fill:#3b4f87;fill-opacity:1;stroke:#066506;stroke-width:5.09605265;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+               id="path5170"
+               transform="matrix(1.3927047,0,0,1.7695104,-111.40259,-342.37397)"
+               d="m 301.22748,447.78589 a 12.020815,3.5355339 0 1 1 -24.04163,0 12.020815,3.5355339 0 1 1 24.04163,0 z"
+               inkscape:connector-curvature="0" />
+          </g>
+          <g
+             style="display:inline;opacity:0.50724637"
+             id="g3387">
+            <path
+               style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.97098225px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+               id="path38439"
+               d="m 228.40187,414.05208 c 48.09211,12.44211 96.18424,24.88422 144.27637,37.32633 4.24342,-1.33308 8.48686,-2.66617 12.73028,-3.99925 -3.83604,4.51333 -7.70079,9.04522 -12.41809,12.75545 -4.46835,5.06183 -1.45368,11.98047 -1.95992,17.89437 0.71573,5.23068 -2.00981,12.17541 -8.85066,10.91989 -9.77783,-0.49321 -18.57911,-5.19627 -28.00143,-7.3143 -21.21789,-5.37132 -42.87254,-11.70795 -61.22062,-22.59091 -16.58645,-9.83807 -29.9397,-24.43987 -44.90955,-36.6598 0.11787,-2.77726 0.23574,-5.55452 0.35362,-8.33178 z"
+               inkscape:connector-curvature="0" />
+          </g>
+        </g>
+      </g>
+      <g
+         transform="matrix(0.03846954,0,0,0.03846954,80.975678,32.55137)"
+         id="g12153-2-8">
+        <path
+           style="fill:#00599c"
+           inkscape:connector-curvature="0"
+           d="M 302.107,258.262 C 304.508,254.103 306,249.417 306,245.209 V 99.14 c 0,-4.208 -1.49,-8.893 -3.892,-13.052 L 153,172.175 Z"
+           id="path12119-9-5" />
+        <path
+           style="fill:#004482"
+           inkscape:connector-curvature="0"
+           d="m 166.25,341.193 126.5,-73.034 c 3.644,-2.104 6.956,-5.737 9.357,-9.897 L 153,172.175 3.893,258.263 c 2.401,4.159 5.714,7.793 9.357,9.896 l 126.5,73.034 c 7.287,4.208 19.213,4.208 26.5,0 z"
+           id="path12121-2-5" />
+        <path
+           style="fill:#659ad2"
+           inkscape:connector-curvature="0"
+           d="m 302.108,86.087 c -2.402,-4.16 -5.715,-7.793 -9.358,-9.897 L 166.25,3.156 c -7.287,-4.208 -19.213,-4.208 -26.5,0 L 13.25,76.19 C 5.962,80.397 0,90.725 0,99.14 v 146.069 c 0,4.208 1.491,8.894 3.893,13.053 L 153,172.175 Z"
+           id="path12123-7-7" />
+        <g
+           id="g12127-8-2">
+          <path
+             style="fill:#ffffff"
+             inkscape:connector-curvature="0"
+             d="m 153,274.175 c -56.243,0 -102,-45.757 -102,-102 0,-56.243 45.757,-102 102,-102 36.292,0 70.139,19.53 88.331,50.968 l -44.143,25.544 C 188.083,130.951 171.15,121.175 153,121.175 c -28.122,0 -51,22.878 -51,51 0,28.121 22.878,51 51,51 18.152,0 35.085,-9.776 44.191,-25.515 l 44.143,25.543 c -18.192,31.441 -52.04,50.972 -88.334,50.972 z"
+             id="path12125-6-0" />
+        </g>
+        <g
+           id="g12131-8-1">
+          <polygon
+             style="fill:#ffffff"
+             points="232.334,189.175 243.666,189.175 243.666,177.841 255,177.841 255,166.508 243.666,166.508 243.666,155.175 232.334,155.175 232.334,166.508 221,166.508 221,177.841 232.334,177.841 "
+             id="polygon12129-8-9" />
+        </g>
+        <g
+           id="g12135-7-7">
+          <polygon
+             style="fill:#ffffff"
+             points="274.834,189.175 286.166,189.175 286.166,177.841 297.5,177.841 297.5,166.508 286.166,166.508 286.166,155.175 274.834,155.175 274.834,166.508 263.5,166.508 263.5,177.841 274.834,177.841 "
+             id="polygon12133-4-8" />
+        </g>
+      </g>
+    </g>
+    <text
+       id="text12239"
+       y="120.29613"
+       x="16.054379"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93888903px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       xml:space="preserve"><tspan
+         style="font-weight:bold;font-size:4.93888903px;stroke-width:0.26458332px"
+         y="120.29613"
+         x="16.054379"
+         id="tspan12237"
+         sodipodi:role="line">Model</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93888903px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       x="56.859608"
+       y="120.29613"
+       id="text12243"><tspan
+         sodipodi:role="line"
+         id="tspan12241"
+         x="56.859608"
+         y="120.29613"
+         style="font-weight:bold;font-size:4.93888903px;text-align:center;text-anchor:middle;stroke-width:0.26458332px">Model import</tspan><tspan
+         sodipodi:role="line"
+         x="56.859608"
+         y="126.46974"
+         style="font-weight:normal;font-size:4.23333359px;text-align:center;text-anchor:middle;stroke-width:0.26458332px"
+         id="tspan23003">symbolic processing</tspan><tspan
+         sodipodi:role="line"
+         x="56.859608"
+         y="132.83791"
+         style="font-weight:normal;font-size:4.23333359px;text-align:center;text-anchor:middle;stroke-width:0.26458332px"
+         id="tspan12247">&amp; C++ code generation</tspan></text>
+    <text
+       id="text12255"
+       y="120.29613"
+       x="95.160294"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93888903px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       xml:space="preserve"><tspan
+         id="tspan12253"
+         style="font-weight:bold;font-size:4.93888903px;stroke-width:0.26458332px"
+         y="120.29613"
+         x="95.160294"
+         sodipodi:role="line">Model compilation</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93888903px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       x="186.39174"
+       y="120.29613"
+       id="text12264"><tspan
+         sodipodi:role="line"
+         x="186.39174"
+         y="120.29613"
+         style="font-weight:bold;font-size:4.93888903px;stroke-width:0.26458332px"
+         id="tspan12262">Model simulation</tspan></text>
+    <text
+       id="text20627"
+       y="120.29613"
+       x="-31.988312"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.96875px;line-height:125%;font-family:Arial;-inkscape-font-specification:'Arial, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       xml:space="preserve"><tspan
+         id="tspan20625"
+         style="font-weight:bold;font-size:4.93888903px;stroke-width:0.26458332px"
+         y="120.29613"
+         x="-31.988312"
+         sodipodi:role="line">AMICI interfaces</tspan></text>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:0.79499996, 0.79499996;stroke-dashoffset:0;stroke-opacity:1;marker-end:url(#marker21324)"
+       d="M 86.887644,85.876548 V 74.862425"
+       id="path21320"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:0.79499996, 0.79499996;stroke-dashoffset:0;stroke-opacity:1;marker-end:url(#marker21832)"
+       d="m 80.627903,42.770111 c -4.309613,16.093963 -4.002435,31.261321 0,46.59948"
+       id="path21828"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cc" />
+    <path
+       sodipodi:nodetypes="cc"
+       inkscape:connector-curvature="0"
+       id="path33669"
+       d="M 86.8503,46.904115 V 57.918238"
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:0.79499996, 0.79499996;stroke-dashoffset:0;stroke-opacity:1;marker-end:url(#marker33673)" />
+  </g>
+</svg>
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/recreate_reference_list.py b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/recreate_reference_list.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6c4ab538c48bae51d10dc551e04a6f186dc8fcc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/recreate_reference_list.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Create AMICI publication list by year
+
+For macOS with clang: download and install biblib-simple to avoid compiler
+issues
+
+Requires pandoc
+"""
+
+import biblib.bib
+import biblib.messages
+import biblib.algo
+import os
+import sys
+import subprocess
+
+
+def get_keys_by_year(bibfile):
+    """Get bibtex entry keys as dict by year"""
+
+    with open(bibfile, 'r') as f:
+        db = biblib.bib.Parser().parse(f, log_fp=sys.stderr).get_entries()
+        recoverer = biblib.messages.InputErrorRecoverer()
+        by_year = {}
+        for ent in db.values():
+            with recoverer:
+                if 'year' in ent:
+                    try:
+                        by_year[ent['year']].append(ent.key)
+                    except KeyError:
+                        by_year[ent['year']] = [ent.key]
+                else:
+                    print("Missing year for entry", ent.key)
+        recoverer.reraise()
+    return by_year
+
+
+def get_sub_bibliography(year, by_year, bibfile):
+    """Get HTML bibliography for the given year"""
+
+    entries = ','.join(['@' + x for x in by_year[year]])
+    input = '---\n' \
+            f'bibliography: {bibfile}\n' \
+            f'nocite: "{entries}"\n...\n' \
+            f'# {year}'
+
+    out = subprocess.run(['pandoc', '--filter=pandoc-citeproc',
+                          '-f', 'markdown'],
+                         input=input, capture_output=True,
+                         encoding='utf-8')
+    if out.returncode != 0:
+        raise AssertionError(out.stderr)
+    return out.stdout
+
+
+def main():
+    script_path = os.path.dirname(os.path.realpath(__file__))
+    bibfile = os.path.join(script_path, 'amici_refs.bib')
+    outfile = os.path.join(script_path, 'references.md')
+
+    by_year = get_keys_by_year(bibfile)
+    num_total = sum(map(len, by_year.values()))
+    with open(outfile, 'w') as f:
+        f.write('# References\n\n')
+        f.write('List of publications using AMICI. '
+                f'Total number is {num_total}.\n\n')
+        f.write('If you applied AMICI in your work and your publication is '
+                'missing, please let us know via a new Github issue.\n\n')
+
+        for year in reversed(sorted(by_year.keys())):
+            cur_bib = get_sub_bibliography(year, by_year, bibfile)
+            f.write(cur_bib)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/documentation/references.md b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/references.md
new file mode 100644
index 0000000000000000000000000000000000000000..759461b4372caf73896a2957f475b0ee05e806d4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/documentation/references.md
@@ -0,0 +1,117 @@
+# References
+
+List of publications using AMICI. Total number is 32.
+
+If you applied AMICI in your work and your publication is missing, please let us know via a new Github issue.
+
+<h1 id="section" class="unnumbered">2019</h1>
+<div id="refs" class="references">
+<div id="ref-DharmarajanKal2019">
+<p>Dharmarajan, Lekshmi, Hans-Michael Kaltenbach, Fabian Rudolf, and Joerg Stelling. 2019. “A Simple and Flexible Computational Framework for Inferring Sources of Heterogeneity from Single-Cell Dynamics.” <em>Cell Systems</em> 8 (1). Elsevier: 15–26.e11. <a href="https://doi.org/10.1016/j.cels.2018.12.007" class="uri">https://doi.org/10.1016/j.cels.2018.12.007</a>.</p>
+</div>
+<div id="ref-FischerFie2017">
+<p>Fischer, David S., Anna K. Fiedler, Eric Kernfeld, Ryan M. J. Genga, Aimée Bastidas-Ponce, Mostafa Bakhti, Heiko Lickert, Jan Hasenauer, Rene Maehr, and Fabian J. Theis. 2019. “Inferring Population Dynamics from Single-Cell Rna-Sequencing Time Series Data.” <em>Nature Biotechnology</em> 37: 461–68. <a href="https://doi.org/10.1038/s41587-019-0088-0" class="uri">https://doi.org/10.1038/s41587-019-0088-0</a>.</p>
+</div>
+<div id="ref-GreggSar2019">
+<p>Gregg, Robert W, Saumendra N Sarkar, and Jason E Shoemaker. 2019. “Mathematical Modeling of the cGAS Pathway Reveals Robustness of Dna Sensing to Trex1 Feedback.” <em>Journal of Theoretical Biology</em> 462 (February): 148–57. <a href="https://doi.org/10.1016/j.jtbi.2018.11.001" class="uri">https://doi.org/10.1016/j.jtbi.2018.11.001</a>.</p>
+</div>
+<div id="ref-KapferSta2019">
+<p>Kapfer, Eva-Maria, Paul Stapor, and Jan Hasenauer. 2019. “Challenges in the Calibration of Large-Scale Ordinary Differential Equation Models.” <em>Accepted for Publication in Proc. Of the Foundations of Syst. Biol. In Engin. (FOSBE)</em>.</p>
+</div>
+<div id="ref-LinesPas2019">
+<p>Lines, Glenn Terje, Lukasz Paszkowski, Leonard Schmiester, Daniel Weindl, Paul Stapor, and Jan Hasenauer. 2019. “Efficient Computation of Steady States in Large-Scale Ode Models of Biochemical Reaction Networks.” <em>Accepted for Publication in Proc. Of the Foundations of Syst. Biol. In Engin. (FOSBE)</em>.</p>
+</div>
+<div id="ref-NousiainenInt2019">
+<p>Nousiainen, Kari, Jukka Intosalmi, and Harri Lähdesmäki. 2019. “A Mathematical Model for Enhancer Activation Kinetics During Cell Differentiation.” In <em>Algorithms for Computational Biology</em>, edited by Ian Holmes, Carlos Martín-Vide, and Miguel A. Vega-Rodríguez, 191–202. Cham: Springer International Publishing.</p>
+</div>
+<div id="ref-PittBan2019">
+<p>Pitt, Jake Alan, and Julio R Banga. 2019. “Parameter Estimation in Models of Biological Oscillators: An Automated Regularised Estimation Approach.” <em>BMC Bioinformatics</em> 20 (1): 82. <a href="https://doi.org/10.1186/s12859-019-2630-y" class="uri">https://doi.org/10.1186/s12859-019-2630-y</a>.</p>
+</div>
+<div id="ref-SchmiesterSch2019">
+<p>Schmiester, Leonard, Yannik Schälte, Fabian Fröhlich, Jan Hasenauer, and Daniel Weindl. 2019. “Efficient parameterization of large-scale dynamic models based on relative measurements.” <em>Bioinformatics</em>, July. <a href="https://doi.org/10.1093/bioinformatics/btz581" class="uri">https://doi.org/10.1093/bioinformatics/btz581</a>.</p>
+</div>
+<div id="ref-VillaverdeRai2019">
+<p>Villaverde, Alejandro F., Elba Raimúndez, Jan Hasenauer, and Julio R. Banga. 2019. “A Comparison of Methods for Quantifying Prediction Uncertainty in Systems Biology.” <em>Accepted for Publication in Proc. Of the Foundations of Syst. Biol. In Engin. (FOSBE)</em>.</p>
+</div>
+<div id="ref-WangSta2019">
+<p>Wang, Dantong, Paul Stapor, and Jan Hasenauer. 2019. “Dirac Mixture Distributions for the Approximation of Mixed Effects Models.” <em>Accepted for Publication in Proc. Of the Foundations of Syst. Biol. In Engin. (FOSBE)</em>.</p>
+</div>
+</div>
+<h1 id="section" class="unnumbered">2018</h1>
+<div id="refs" class="references">
+<div id="ref-BallnusSch2018">
+<p>Ballnus, Benjamin, Steffen Schaper, Fabian J Theis, and Jan Hasenauer. 2018. “Bayesian Parameter Estimation for Biochemical Reaction Networks Using Region-Based Adaptive Parallel Tempering.” <em>Bioinformatics</em> 34 (13): i494–i501. <a href="https://doi.org/10.1093/bioinformatics/bty229" class="uri">https://doi.org/10.1093/bioinformatics/bty229</a>.</p>
+</div>
+<div id="ref-BastCal2018">
+<p>Bast, Lisa, Filippo Calzolari, Michael Strasser, Jan Hasenauer, Fabian J. Theis, Jovica Ninkovic, and Carsten Marr. 2018. “Subtle Changes in Clonal Dynamics Underlie the Age-Related Decline in Neurogenesis.” <em>Cell Reports</em>.</p>
+</div>
+<div id="ref-FroehlichRei2018">
+<p>Fröhlich, Fabian, Anita Reiser, Laura Fink, Daniel Woschée, Thomas Ligon, Fabian Joachim Theis, Joachim Oskar Rädler, and Jan Hasenauer. 2018. “Multi-Experiment Nonlinear Mixed Effect Modeling of Single-Cell Translation Kinetics After Transfection.” <em>Npj Systems Biology and Applications</em> 5 (1): 1. <a href="https://doi.org/10.1038/s41540-018-0079-7" class="uri">https://doi.org/10.1038/s41540-018-0079-7</a>.</p>
+</div>
+<div id="ref-KaltenbacherPed2018">
+<p>Kaltenbacher, Barbara, and Barbara Pedretscher. 2018. “Parameter Estimation in Sdes via the Fokker–Planck Equation: Likelihood Function and Adjoint Based Gradient Computation.” <em>Journal of Mathematical Analysis and Applications</em> 465 (2): 872–84. <a href="https://doi.org/https://doi.org/10.1016/j.jmaa.2018.05.048" class="uri">https://doi.org/https://doi.org/10.1016/j.jmaa.2018.05.048</a>.</p>
+</div>
+<div id="ref-LoosKra2018">
+<p>Loos, Carolin, Sabrina Krause, and Jan Hasenauer. 2018. “Hierarchical Optimization for the Efficient Parametrization of ODE Models.” <em>Bioinformatics</em> 34 (24): 4266–73. <a href="https://doi.org/10.1093/bioinformatics/bty514" class="uri">https://doi.org/10.1093/bioinformatics/bty514</a>.</p>
+</div>
+<div id="ref-LoosMoe2018">
+<p>Loos, Carolin, Katharina Moeller, Fabian Fröhlich, Tim Hucho, and Jan Hasenauer. 2018. “A Hierarchical, Data-Driven Approach to Modeling Single-Cell Populations Predicts Latent Causes of Cell-to-Cell Variability.” <em>Cell Systems</em> 6 (5). Elsevier: 593–603. <a href="https://doi.org/10.1016/j.cels.2018.04.008" class="uri">https://doi.org/10.1016/j.cels.2018.04.008</a>.</p>
+</div>
+<div id="ref-SchaelteSta2018">
+<p>Schälte, Y., P. Stapor, and J. Hasenauer. 2018. “Evaluation of Derivative-Free Optimizers for Parameter Estimation in Systems Biology.” <em>FAC-PapersOnLine</em> 51 (19): 98–101.</p>
+</div>
+<div id="ref-StaporFro2018">
+<p>Stapor, Paul, Fabian Fröhlich, and Jan Hasenauer. 2018. “Optimization and Profile Calculation of ODE Models Using Second Order Adjoint Sensitivity Analysis.” <em>Bioinformatics</em> 34 (13). Oxford University Press: i151–i159.</p>
+</div>
+<div id="ref-VillaverdeFro2018">
+<p>Villaverde, Alejandro F., Fabian Froehlich, Daniel Weindl, Jan Hasenauer, and Julio R Banga. 2018. “Benchmarking Optimization Methods for Parameter Estimation in Large Kinetic Models.” <em>Bioinformatics</em>, bty736.</p>
+</div>
+</div>
+<h1 id="section" class="unnumbered">2017</h1>
+<div id="refs" class="references">
+<div id="ref-BallnusHug2017">
+<p>Ballnus, B., S. Hug, K. Hatz, L. Görlitz, J. Hasenauer, and F. J. Theis. 2017. “Comprehensive Benchmarking of Markov Chain Monte Carlo Methods for Dynamical Systems.” <em>BMC Syst. Biol.</em> 11 (63). <a href="https://doi.org/10.1186/s12918-017-0433-1" class="uri">https://doi.org/10.1186/s12918-017-0433-1</a>.</p>
+</div>
+<div id="ref-FroehlichKes2017">
+<p>Fröhlich, Fabian, Thomas Kessler, Daniel Weindl, Alexey Shadrin, Leonard Schmiester, Hendrik Hache, Artur Muradyan, et al. 2017. “Efficient Parameterization of Large-Scale Mechanistic Models Enables Drug Response Prediction for Cancer Cell Lines.” <em>bioRxiv</em>. Cold Spring Harbor Labs Journals. <a href="https://doi.org/10.1101/174094" class="uri">https://doi.org/10.1101/174094</a>.</p>
+</div>
+<div id="ref-FroehlichKal2017">
+<p>Fröhlich, F., B. Kaltenbacher, F. J. Theis, and J. Hasenauer. 2017. “Scalable Parameter Estimation for Genome-Scale Biochemical Reaction Networks.” <em>PLoS Comput. Biol.</em> 13 (1): e1005331. <a href="https://doi.org/10.1371/journal.pcbi.1005331" class="uri">https://doi.org/10.1371/journal.pcbi.1005331</a>.</p>
+</div>
+<div id="ref-FroehlichThe2016">
+<p>Fröhlich, F., F. J. Theis, J. O. Rädler, and J. Hasenauer. 2017. “Parameter Estimation for Dynamical Systems with Discrete Events and Logical Operations.” <em>Bioinformatics</em> 33 (7): 1049–56. <a href="https://doi.org/10.1093/bioinformatics/btw764" class="uri">https://doi.org/10.1093/bioinformatics/btw764</a>.</p>
+</div>
+<div id="ref-KazeroonianThe2017">
+<p>Kazeroonian, A., F. J. Theis, and J. Hasenauer. 2017. “A Scalable Moment-Closure Approximation for Large-Scale Biochemical Reaction Networks.” <em>Bioinformatics</em> 33 (14): i293–i300. <a href="https://doi.org/10.1093/bioinformatics/btx249" class="uri">https://doi.org/10.1093/bioinformatics/btx249</a>.</p>
+</div>
+<div id="ref-MaierLoo2017">
+<p>Maier, C., C. Loos, and J. Hasenauer. 2017. “Robust Parameter Estimation for Dynamical Systems from Outlier-Corrupted Data.” <em>Bioinformatics</em> 33 (5): 718–25. <a href="https://doi.org/10.1093/bioinformatics/btw703" class="uri">https://doi.org/10.1093/bioinformatics/btw703</a>.</p>
+</div>
+</div>
+<h1 id="section" class="unnumbered">2016</h1>
+<div id="refs" class="references">
+<div id="ref-BoigerHas2016">
+<p>Boiger, R., J. Hasenauer, S. Hross, and B. Kaltenbacher. 2016. “Integration Based Profile Likelihood Calculation for PDE Constrained Parameter Estimation Problems.” <em>Inverse Prob.</em> 32 (12): 125009. <a href="https://doi.org/10.1088/0266-5611/32/12/125009" class="uri">https://doi.org/10.1088/0266-5611/32/12/125009</a>.</p>
+</div>
+<div id="ref-FiedlerRae2016">
+<p>Fiedler, A., S. Raeth, F. J. Theis, A. Hausser, and J. Hasenauer. 2016. “Tailored Parameter Optimization Methods for Ordinary Differential Equation Models with Steady-State Constraints.” <em>BMC Syst. Biol.</em> 10 (80). <a href="https://doi.org/10.1186/s12918-016-0319-7" class="uri">https://doi.org/10.1186/s12918-016-0319-7</a>.</p>
+</div>
+<div id="ref-FroehlichTho2016">
+<p>Fröhlich, F., P. Thomas, A. Kazeroonian, F. J. Theis, R. Grima, and J. Hasenauer. 2016. “Inference for Stochastic Chemical Kinetics Using Moment Equations and System Size Expansion.” <em>PLoS Comput. Biol.</em> 12 (7): e1005030. <a href="https://doi.org/10.1371/journal.pcbi.1005030" class="uri">https://doi.org/10.1371/journal.pcbi.1005030</a>.</p>
+</div>
+<div id="ref-HrossFie2016">
+<p>Hross, S., A. Fiedler, F. J. Theis, and J. Hasenauer. 2016. “Quantitative Comparison of Competing PDE Models for Pom1p Dynamics in Fission Yeast.” In <em>Proc. 6th IFAC Conf. Found. Syst. Biol. Eng.</em>, edited by R. Findeisen, E. Bullinger, E. Balsa-Canto, and K. Bernaerts, 49:264–69. 26. IFAC-PapersOnLine. <a href="https://doi.org/10.1016/j.ifacol.2016.12.136" class="uri">https://doi.org/10.1016/j.ifacol.2016.12.136</a>.</p>
+</div>
+<div id="ref-KazeroonianFro2016">
+<p>Kazeroonian, A., F. Fröhlich, A. Raue, F. J. Theis, and J. Hasenauer. 2016. “CERENA: Chemical REaction Network Analyzer – A Toolbox for the Simulation and Analysis of Stochastic Chemical Kinetics.” <em>PLoS ONE</em> 11 (1): e0146732. <a href="https://doi.org/10.1371/journal.pone.0146732" class="uri">https://doi.org/10.1371/journal.pone.0146732</a>.</p>
+</div>
+<div id="ref-LoosFie2016">
+<p>Loos, C., A. Fiedler, and J. Hasenauer. 2016. “Parameter Estimation for Reaction Rate Equation Constrained Mixture Models.” In <em>Proc. 13th Int. Conf. Comp. Meth. Syst. Biol.</em>, edited by E. Bartocci, P. Lio, and N. Paoletti, 186–200. Lecture Notes in Bioinformatics. Springer International Publishing. <a href="https://doi.org/10.1007/978-3-319-45177-0" class="uri">https://doi.org/10.1007/978-3-319-45177-0</a>.</p>
+</div>
+</div>
+<h1 id="section" class="unnumbered">2015</h1>
+<div id="refs" class="references">
+<div id="ref-LoosMar2015">
+<p>Loos, C., C. Marr, F. J. Theis, and J. Hasenauer. 2015. “Computational Methods in Systems Biology.” In, edited by O. Roux and J. Bourdon, 9308:52–63. Lecture Notes in Computer Science. Springer International Publishing.</p>
+</div>
+</div>
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amidata/amidata.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amidata/amidata.m
new file mode 100644
index 0000000000000000000000000000000000000000..3ccc65a305d34a2ed6ff7a295ea9c4d26117b53a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amidata/amidata.m
@@ -0,0 +1,252 @@
+%
+% @file amidata
+% @brief definition of amidata class
+%
+classdef amidata < handle
+    % AMIDATA provides a data container to pass experimental data to the
+    % simulation routine for likelihood computation. 
+    % when any of the properties are updated, the class automatically 
+    % checks consistency of dimension and updates related properties and 
+    % initialises them with NaNs
+    
+    properties
+        % number of timepoints
+        nt=0;
+        % number of observables
+        ny=0;
+        % number of event observables
+        nz=0;
+        % number of events
+        ne=0;
+        % number of conditions/constants
+        nk=0;
+        % timepoints of observations
+        t = double.empty();
+        % observations
+        Y = double.empty();
+        % standard deviation of observations
+        Sigma_Y = double.empty();
+        % event observations
+        Z = double.empty();
+        % standard deviation of event observations
+        Sigma_Z = double.empty();
+        % experimental condition
+        condition = double.empty();
+        % experimental condition for preequilibration
+        conditionPreequilibration = double.empty();
+    end
+    
+    methods
+        function D = amidata(varargin)
+            % amidata creates an amidata container for experimental data 
+            % with specified dimensions amidata.
+            % 
+            % AMIDATA(amidata) creates a copy of the input container
+            %
+            % AMIDATA(struct) tries to creates an amidata container from the
+            %                 input struct. the struct should have the following
+            %                 fields:
+            %                 t [nt,1]
+            %                 Y [nt,ny]
+            %                 Sigma_Y [nt,ny]
+            %                 Z [ne,nz]
+            %                 Sigma_Z [ne,nz]
+            %                 condition [nk,1]
+            %                 conditionPreequilibration [nk,1]
+            %                 if some fields are missing the function will try
+            %                 to initialise them with NaNs with consistent
+            %                 dimensions
+            %
+            % AMIDATA(nt,ny,nz,ne,nk) constructs an empty data container with
+            %                 in the provided dimensions intialised with NaNs
+            %
+            % 
+            %
+            % Parameters:
+            %    varargin:
+            %
+            % Return values:
+            %
+            
+            
+            % initialisation via struct
+            if isa(varargin{1},'amidata')
+                    if strcmp(class(varargin{1}),class(D))
+                        D = varargin{1};
+                    else
+                        thisProps = properties(D);
+                        for i = 1:length(thisProps)
+                            try %#ok
+                                % Try to set one of the properties of the
+                                % old object in the new one.
+                                D.(thisProps{i}) = varargin{1}.(thisProps{i});
+                            end
+                        end
+                    end
+            elseif(isstruct(varargin{1}))
+                if(isfield(varargin{1},'t'))
+                    D.nt = numel(varargin{1}.t);
+                    D.t = varargin{1}.t(:);
+                elseif(isfield(varargin{1},'Y'))
+                    D.nt = size(varargin{1}.Y,1);
+                else
+                    error('Cannot construct valid amidata object from input struct. There is no field D.t or D.Y in the input struct!');
+                end
+                if(isfield(varargin{1},'Y'))
+                    D.ny = size(varargin{1}.Y,2);
+                    D.Y = varargin{1}.Y;
+                else
+                    D.ny = 0;
+                end
+                if(isfield(varargin{1},'Z'))
+                    D.nz = size(varargin{1}.Z,2);
+                    D.ne = size(varargin{1}.Z,1);
+                    D.Z = varargin{1}.Z;
+                else
+                    D.nz = 0;
+                end
+                if(isfield(varargin{1},'Sigma_Y'))
+                    D.Sigma_Y = varargin{1}.Sigma_Y;
+                end
+                if(isfield(varargin{1},'Sigma_Z'))
+                    D.Sigma_Z = varargin{1}.Sigma_Z;
+                end   
+                if(isfield(varargin{1},'condition'))
+                    D.nk = numel(varargin{1}.condition);
+                    D.condition = varargin{1}.condition;
+                else
+                    D.nk = 0;
+                end
+                if(isfield(varargin{1},'conditionPreequilibration'))
+                    assert(D.nk == numel(varargin{1}.conditionPreequilibration));
+                    D.conditionPreequilibration = varargin{1}.conditionPreequilibration;
+                end
+            elseif(nargin == 5)
+                D.nt = varargin{1};
+                D.ny = varargin{2};
+                D.nz = varargin{3};
+                D.ne = varargin{4};
+                D.nk = varargin{5};
+            end
+
+        end
+        
+        function set.nt(this,nt)
+            this.nt = nt;
+            this.t = 1:nt;
+            this.Y = NaN;
+            this.Sigma_Y = NaN;
+        end
+        
+        function set.ny(this,ny)
+            this.ny = ny;
+            this.Y = NaN;
+            this.Sigma_Y = NaN;
+        end
+        
+        function set.nz(this,nz)
+            this.nz = nz;
+            this.Z = NaN;
+            this.Sigma_Z = NaN;
+        end
+        
+        function set.ne(this,ne)
+            this.ne = ne;
+            this.Z = NaN;
+            this.Sigma_Z = NaN;
+        end
+        
+        function set.nk(this,nk)
+            this.nk = nk;
+            this.condition = NaN(nk,1);
+        end
+        
+        function set.t(this,value)
+            assert(isnumeric(value),'AMICI:amimodel:t:numeric','t must have a numeric value!')
+            assert(ismatrix(value),'AMICI:amimodel:t:ndims','t must be a two dimensional matrix!')
+            assert(numel(value)==this.nt,'AMICI:amimodel:t:ndims',['t must have ' num2str(this.nt) ' (D.nt) elements!'])
+            this.t = double(value(:));
+        end
+        
+        function set.condition(this,value)
+            assert(isnumeric(value),'AMICI:amimodel:condition:numeric','condition must have a numeric value!')
+            assert(ismatrix(value),'AMICI:amimodel:condition:ndims','condition must be a two dimensional matrix!')
+            assert(numel(value)==this.nk,'AMICI:amimodel:condition:ndims',['condition must have ' num2str(this.nk) ' (D.nk) elements!'])
+            this.condition = double(value(:));
+        end
+        
+        function set.conditionPreequilibration(this,value)
+            assert(isnumeric(value),'AMICI:amimodel:condition:numeric','condition must have a numeric value!')
+            assert(ismatrix(value),'AMICI:amimodel:condition:ndims','condition must be a two dimensional matrix!')
+            assert(numel(value)==this.nk,'AMICI:amimodel:condition:ndims',['condition must have ' num2str(this.nk) ' (D.nk) elements!'])
+            this.conditionPreequilibration = double(value(:));
+        end
+        
+        function set.Y(this,value)
+            assert(ismatrix(value),'AMICI:amimodel:Y:ndims','Y must be a two dimensional matrix!')
+            assert(all(all(or(isnumeric(value),isnan(value)))),'AMICI:amimodel:Y:numeric','Y must have a numeric value!')
+            
+            if(all(size(value)==[this.nt this.ny]))
+                this.Y = double(value);
+            elseif(all(size(value)==[this.nt 1]))
+                this.Y = repmat(double(value),[1,this.ny]);
+            elseif(all(size(value)==[1 this.ny]))
+                this.Y = repmat(double(value),[this.nt,1]);
+            elseif(all(size(value)==[1 1]))
+                this.Y = repmat(double(value),[this.nt,this.ny]);
+            else
+                error('AMICI:amimodel:Y:size',['Y must have size [' num2str(this.nt) ',' num2str(this.ny) '] ([D.nt,D.ny])!'])
+            end
+        end
+        
+        function set.Sigma_Y(this,value)
+            assert(ismatrix(value),'AMICI:amimodel:Sigma_Y:ndims','Sigma_Y must be a two dimensional matrix!')
+            assert(all(all(or(isnumeric(value),isnan(value)))),'AMICI:amimodel:Sigma_Y:numeric','Sigma_Y must have a numeric value!')
+            if(all(size(value)==[this.nt this.ny]))
+                this.Sigma_Y = double(value);
+            elseif(all(size(value)==[this.nt 1]))
+                this.Sigma_Y = repmat(double(value),[1,this.ny]);
+            elseif(all(size(value)==[1 this.ny]))
+                this.Sigma_Y = repmat(double(value),[this.nt,1]);
+            elseif(all(size(value)==[1 1]))
+                this.Sigma_Y = repmat(double(value),[this.nt,this.ny]);
+            else
+                error('AMICI:amimodel:Sigma_Y:size',['Sigma_Y must have size [' num2str(this.nt) ',' num2str(this.ny) '] ([D.nt,D.ny])!'])
+            end
+        end
+        
+        function set.Z(this,value)
+            assert(ismatrix(value),'AMICI:amimodel:Z:ndims','Z must be a two dimensional matrix!')
+            assert(all(all(or(isnumeric(value),isnan(value)))),'AMICI:amimodel:Z:numeric','Z must have a numeric value!')
+            if(all(size(value)==[this.ne this.nz]))
+                this.Z = double(value);
+            elseif(all(size(value)==[this.ne 1]))
+                this.Z = repmat(double(value),[1,this.nz]);
+            elseif(all(size(value)==[1 this.nz]))
+                this.Z = repmat(double(value),[this.ne,1]);
+            elseif(all(size(value)==[1 1]))
+                this.Z = repmat(double(value),[this.ne,this.nz]);
+            else
+                error('AMICI:amimodel:Z:size',['Z must have size [' num2str(this.ne) ',' num2str(this.nz) '] ([D.ne,D.nz])!'])
+            end
+        end
+        
+        function set.Sigma_Z(this,value)
+            assert(ismatrix(value),'AMICI:amimodel:Sigma_Z:ndims','Sigma_Z must be a two dimensional matrix!')
+            assert(all(all(or(isnumeric(value),isnan(value)))),'AMICI:amimodel:Sigma_Z:numeric','Sigma_Z must have a numeric value!')
+            if(all(size(value)==[this.ne this.nz]))
+                this.Sigma_Z = double(value);
+            elseif(all(size(value)==[this.ne 1]))
+                this.Sigma_Z = repmat(double(value),[1,this.nz]);
+            elseif(all(size(value)==[1 this.nz]))
+                this.Sigma_Z = repmat(double(value),[this.ne,1]);
+            elseif(all(size(value)==[1 1]))
+                this.Sigma_Z = repmat(double(value),[this.ne,this.nz]);
+            else
+                error('AMICI:amimodel:Sigma_Z:size',['Sigma_Z must have size [' num2str(this.ne) ',' num2str(this.nz) '] ([D.ne,D.nz])!'])
+            end
+        end
+    end
+    
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amievent/amievent.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amievent/amievent.m
new file mode 100644
index 0000000000000000000000000000000000000000..098a4e4372e55973adb9e0f0d70484a922cf382f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amievent/amievent.m
@@ -0,0 +1,79 @@
+%
+% @file amievent
+% @brief definition of amievent class
+%
+classdef amievent
+    % AMIEVENT defines events which later on will be transformed into appropriate
+    % C code
+    
+    properties ( GetAccess = 'public', SetAccess = 'private' )
+        % the trigger function activates the event on every zero crossing @type symbolic
+        trigger = sym.empty();
+        % the bolus function defines the change in states that is applied on every event occurence @type symbolic
+        bolus = sym.empty();
+        % output function for the event @type symbolic
+        z = sym.empty();
+        % flag indicating that a heaviside function is present, this helps
+        % to speed up symbolic computations
+        hflag = logical.empty();
+    end
+    
+    methods
+        function AE = amievent(trigger,bolus,z)
+            % amievent constructs an amievent object from the provided input.
+            %
+            % Parameters:
+            %  trigger: trigger function, the event will be triggered on
+            %      at all roots of this function
+            %  bolus: the bolus that will be added to all states on every
+            %      occurence of the event
+            %  z: the event output that will be reported on every occurence
+            %      of the event
+            %
+            % Return values:
+            %  AE: amievent object
+            %
+            if(~isa(trigger,'sym'))
+                if(isa(trigger,'double'))
+                    AE.trigger = sym(trigger);
+                    warning('Constant trigger function will never trigger. Please check the event definition.')
+                else
+                    error('trigger function must be a symbolic expression')
+                end
+            else
+                AE.trigger = trigger;
+            end
+            if(numel(AE.trigger)>1)
+                error('The trigger function must be scalar.')
+            end
+            
+            if(~isa(bolus,'sym'))
+                if(isa(bolus,'double'))
+                    AE.bolus = sym(bolus(:));
+                else
+                    error('bolus function must be a symbolic expression')
+                end
+            else
+                AE.bolus = bolus;
+            end
+            
+            if(~isa(z,'sym'))
+                if(isa(z,'double'))
+                    if(~isempty(z))
+                        AE.z = sym(z);
+                        warning('Constant outputs are not informative. Please check the event definition.')
+                    else
+                        AE.z = sym(zeros(0,1));
+                    end
+                else
+                    error('output function must be a symbolic expression')
+                end      
+            else
+                AE.z = z;
+            end
+        end
+        
+        this = setHflag(this,hflag);
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amievent/setHflag.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amievent/setHflag.m
new file mode 100644
index 0000000000000000000000000000000000000000..da22d6527e165131ff9fd1f0b44d722b42a5390c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amievent/setHflag.m
@@ -0,0 +1,24 @@
+function this = setHflag(this,hflag)
+    % gethflag sets the hflag property.
+    %
+    % Parameters:
+    %  hflag: value for the hflag property @type double
+    %
+    % Return values:
+    %  this: updated event definition object @type amievent
+    
+    try
+        if(all(size(this.bolus) == size(hflag)))
+            if(isa(hflag,'double'))
+                this.hflag = hflag~=0;
+            elseif(islogical(hflag))
+                this.hflag = hflag;
+            else
+                error('provided hflag is not a double/logical value!');
+            end
+        else
+            error('provided hflag does not match the bolus dimension!');
+        end
+    catch
+        error('provided hflag does not match the bolus dimension!');
+    end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/amifun.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/amifun.m
new file mode 100644
index 0000000000000000000000000000000000000000..6743434cb894594a807088f721681f8a1ba8031b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/amifun.m
@@ -0,0 +1,75 @@
+%
+% @file amifun
+% @brief definition of amifun class
+%
+classdef amifun
+    % AMIFUN defines functions which later on will be transformed into
+    % appropriate C code
+    
+    properties ( GetAccess = 'public', SetAccess = 'public' )
+        % symbolic definition struct @type symbolic
+        sym = sym([]);
+        % symbolic definition which was not optimized (no dependencies on w) @type symbolic
+        sym_noopt = sym([]);
+        % short symbolic string which can be used for the reuse of precomputed values @type symbolic
+        strsym = sym([]);
+        % short symbolic string which can be used for the reuse of old values @type symbolic
+        strsym_old = sym([]);
+        % name of the model @type char
+        funstr = char.empty();
+        % name of the c variable @type char
+        cvar = char.empty();
+        % argument string (solver specific) @type char
+        argstr = char.empty();
+        % dependencies on other functions @type cell
+        deps = cell.empty();
+        % nvec dependencies
+        nvecs = cell.empty();
+        % indicates whether the function is a sensitivity or derivative
+        % with respect to parameters
+        sensiflag = logical.empty();
+    end
+    
+    methods
+        function AF = amifun(funstr,model)
+            % amievent constructs an amifun object from the provided input.
+            %
+            % Parameters:
+            %  funstr: name of the requested function
+            %  model: amimodel object which carries all symbolic
+            %  definitions to construct the function
+            %  
+            %
+            % Return values:
+            %  AF: amifun object
+            %
+            AF.funstr = funstr;
+            AF = AF.getDeps(model);
+            AF = AF.getArgs(model);
+            AF = AF.getNVecs();
+            AF = AF.getCVar();
+            AF = AF.getSensiFlag();
+        end
+        
+        writeCcode_sensi(this,model,fid)
+        
+        writeCcode(this,model,fid)
+        
+        writeMcode(this,model)
+        
+        gccode(this,model,fid)
+        
+        [ this ] = getDeps(this,model)
+        
+        [ this ] = getArgs(this,model)
+        
+        [ this ] = getNVecs(this)
+        
+        [ this ] = getCVar(this)
+        
+        [ this ] = getSensiFlag(this)
+
+        [ this, model ] = getSyms(this,model)
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/gccode.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/gccode.m
new file mode 100644
index 0000000000000000000000000000000000000000..66b2476a21bf3d6465502db429911a3e2ad38c82
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/gccode.m
@@ -0,0 +1,166 @@
+function this = gccode(this,model,fid)
+    % gccode transforms symbolic expressions into c code and writes the
+    % respective expression into a specified file
+    %
+    % Parameters:
+    %  model: model definition object @type amimodel
+    %  fid: file id in which the expression should be written @type fileid
+    %
+    % Return values:
+    %  this: function definition object @type amifun
+    
+    
+    if(any(any(any(this.sym~=0))))
+        
+        % replace unknown partial derivatives
+        if(model.maxflag)
+            this.sym = subs(this.sym,sym('D([1], am_max)'),sym('D1max'));
+            this.sym = subs(this.sym,sym('D([2], am_max)'),sym('D2max'));
+            this.sym = subs(this.sym,sym('am_max'),sym('max'));
+        end
+        
+        % If we have spline, we need to parse them to get derivatives
+        if (model.splineflag)
+            symstr = char(this.sym);
+            if (strfind(symstr, 'spline'))
+                tokens = regexp(symstr, 't\,\s(\w+\.\w+)\,', 'tokens');
+                nNodes = round(str2double(tokens{1}));
+            end
+            if (regexp(symstr, 'D\(\[(\w+|\w+\,\w+)\]\,.spline'))
+                isDSpline = true;
+            else
+                isDSpline = false;
+            end
+            
+            if (isDSpline)
+                [~, nCol] = size(this.sym);
+                for iCol = 1 : nCol
+                    for iNode = 1 : nNodes
+                        if (model.o2flag)
+                            for jNode = 1:nNodes
+                                this.sym(:,iCol) = subs(this.sym(:,iCol),sym(['D([' num2str(iNode*2+2) ', ' num2str(jNode*2+2) '], spline_pos)']),sym(['D' num2str(iNode*2+2) 'D' num2str(jNode*2+2) 'spline_pos']));
+                                this.sym(:,iCol) = subs(this.sym(:,iCol),sym(['D([' num2str(iNode*2+2) ', ' num2str(jNode*2+2) '], spline)']),sym(['D' num2str(iNode*2+2) 'D' num2str(jNode*2+2) 'spline']));
+                            end
+                        end
+                        this.sym(:,iCol) = subs(this.sym(:,iCol),sym(['D([' num2str(iNode*2+2) '], spline_pos)']),sym(['D' num2str(iNode*2+2) 'spline_pos']));
+                        this.sym(:,iCol) = subs(this.sym(:,iCol),sym(['D([' num2str(iNode*2+2) '], spline)']),sym(['D' num2str(iNode*2+2) 'spline']));
+                    end
+                end
+            end
+        end
+        
+        cstr = ccode(this.sym);
+        if(~strcmp(cstr(3:4),'t0'))
+            if(any(strcmp(this.funstr,{'J','JB','JDiag','dJydsigma','dJydy','dJzdsigma','dJzdz','dJrzdsigma','dJrzdz','dydx','dzdx','drzdx','M','dfdx'}) ))
+                cstr = regexprep(cstr,'T\[([0-9]*)\]\[([0-9]*)\]',[this.cvar '[$1+$2*' num2str(size(this.sym,1)) ']']);
+            else
+                cstr = regexprep(cstr,'T\[([0-9]*)\]\[0\]',[this.cvar '_$1']);
+                cstr = regexprep(cstr,'T\[0\]\[([0-9]*)\]',[this.cvar '_$1']);
+            end
+        else
+            cstr = strrep(cstr,'t0',[this.cvar '_0']);
+        end
+        
+        cstr = strrep(cstr,'log','amici::log');
+        % fix derivatives again (we cant do this before as this would yield
+        % incorrect symbolic expressions
+        cstr = regexprep(regexprep(cstr,'D([0-9]*)([\w]*)\(','D$2\($1,'),'DD([0-9]*)([\w]*)\(','DD$2\($1,');
+        cstr = strrep(strrep(cstr, 'DDspline', 'DDspline'), 'Dspline', 'Dspline');
+        
+        if (model.splineflag)
+            if (strfind(symstr, 'spline'))
+                % The floating numbers after 't' must be converted to integers
+                cstr = regexprep(cstr, '([D]*(spline|spline_pos))\(t\,\w+\.\w+\,', ['amici::$1\(t\,', num2str(nNodes), '\,']);
+                cstr = regexprep(cstr, '([D]*(spline|spline_pos))\((\w+)\,t\,\w+\.\w+\,', ['amici::$1\($2\,t\,', num2str(nNodes), '\,']);
+                cstr = regexprep(cstr, '([D]*(spline|spline_pos))\((\w+)\,(\w+)\,t\,\w+\.\w+\,', ['amici::$1\($2\,$3\,t\,', num2str(nNodes), '\,']);
+            end
+        end
+        
+        if(numel(cstr)>1)
+            
+            % fix various function specific variable names/indexes
+            
+            cstr = regexprep(cstr,'var_x_([0-9]+)','x[$1]');
+            cstr = regexprep(cstr,'var_dx_([0-9]+)','dx[$1]');
+            cstr = regexprep(cstr,'var_sx_([0-9]+)','sx[$1]');
+            cstr = regexprep(cstr,'var_sdx_([0-9]+)','sdx[$1]');
+            % sxdot needs to preces xdot
+            cstr = regexprep(cstr,'var_sxdot_([0-9]+)','sxdot[$1]');
+            cstr = regexprep(cstr,'var_xdot_([0-9]+)','xdot[$1]');
+            cstr = regexprep(cstr,'var_xBdot_([0-9]+)','xBdot[$1]');
+            cstr = regexprep(cstr,'xdot_old_([0-9]+)','xdot_old[$1]');
+            cstr = regexprep(cstr,'xdot_([0-9]+)','xdot[$1]');
+            cstr = regexprep(cstr,'var_xB_([0-9]+)','xB[$1]');
+            cstr = regexprep(cstr,'var_dxB_([0-9]+)','dxB[$1]');
+            cstr = regexprep(cstr,'var_qBdot_([0-9]+)','qBdot[$1]');
+            cstr = regexprep(cstr,'var_v_([0-9]+)', 'v[$1]');
+            cstr = regexprep(cstr,'var_vB_([0-9]+)', 'vB[$1]');
+            cstr = regexprep(cstr,'var_JSparse_([0-9]+)', 'JSparse->data[$1]');
+            cstr = regexprep(cstr,'J_([0-9]+)', 'J[$1]');
+            cstr = regexprep(cstr,'var_JSparseB_([0-9]+)', 'JSparseB->data[$1]');
+            cstr = regexprep(cstr,'JB_([0-9]+)', 'JB[$1]');
+            cstr = regexprep(cstr,'var_Jv_([0-9]+)', 'Jv[$1]');
+            cstr = regexprep(cstr,'var_JvB_([0-9]+)', 'JvB[$1]');
+            cstr = regexprep(cstr,'var_x0_([0-9]+)','x0[$1]');
+            cstr = regexprep(cstr,'var_dx0_([0-9]+)','dx0[$1]');
+            cstr = regexprep(cstr,'var_sx0_([0-9]+)','sx0[$1]');
+            cstr = regexprep(cstr,'var_sdx0_([0-9]+)','sdx0[$1]');
+            cstr = regexprep(cstr,'var_root_([0-9]+)', 'root[$1]');
+            
+            cstr = regexprep(cstr,'var_p_([0-9]+)','p[$1]');
+            cstr = regexprep(cstr,'var_k_([0-9]+)','k[$1]');
+            cstr = regexprep(cstr,'h_([0-9]+)','h[$1]');
+            cstr = regexprep(cstr,'var_w_([0-9]+)','w[$1]');
+            cstr = regexprep(cstr,'var_dxdotdp_([0-9]+)','dxdotdp[$1]');
+            cstr = regexprep(cstr,'var_stau_([0-9]+)','stau[0]');
+            cstr = regexprep(cstr,'dfdx_([0-9]+)','dfdx[$1]');
+            cstr = regexprep(cstr,'M_([0-9]+)','M[$1]');
+            cstr = regexprep(cstr,'var_dwdx_([0-9]+)','dwdx[$1]');
+            cstr = regexprep(cstr,'var_dwdp_([0-9]+)','dwdp[$1]');
+            cstr = regexprep(cstr,'tmp_J_([0-9]+)','J->data[$1]');
+            cstr = regexprep(cstr,'tmp_dxdotdp_([0-9]+)','dxdotdp[$1]');
+            
+            cstr = regexprep(cstr,'var_y_([0-9]+)','y[$1]');
+            cstr = regexprep(cstr,'my_([0-9]+)','my[$1]');
+            cstr = regexprep(cstr,'var_z_([0-9]+)','z[$1]');
+            cstr = regexprep(cstr,'mz_([0-9]+)','mz[$1]');
+            cstr = regexprep(cstr,'var_rz_([0-9]+)','rz[$1]');
+            cstr = regexprep(cstr,'var_srz_([0-9]+)','srz[$1]');
+            cstr = regexprep(cstr,'var_sy_([0-9]+)','sy[$1]');
+            cstr = regexprep(cstr,'var_sz_([0-9]+)','sz[$1]');
+           
+            cstr = regexprep(cstr,'var_dydx[_\[]*([0-9\+\*]+)[\]]*','dydx[$1]'); % matches both _... and [...]
+            cstr = regexprep(cstr,'var_dzdx[_\[]*([0-9\+\*]+)[\]]*','dzdx[$1]');
+            cstr = regexprep(cstr,'var_drzdx[_\[]*([0-9\+\*]+)[\]]*','drzdx[$1]');
+            cstr = regexprep(cstr,'var_dydp_([0-9]+)',['dydp[$1]']);
+            cstr = regexprep(cstr,'var_dzdp_([0-9]+)',['dzdp[$1]']);
+            cstr = regexprep(cstr,'var_drzdp_([0-9]+)',['drzdp[$1]']);
+            cstr = regexprep(cstr,'var_drootdp_([0-9]+)',['drzdp[$1]']);
+            cstr = regexprep(cstr,'var_deltax_([0-9]+)','deltax[$1]');
+            cstr = regexprep(cstr,'var_deltaxB_([0-9]+)','deltaxB[$1]');
+            cstr = regexprep(cstr,'var_deltasx_([0-9]+)','deltasx[$1]');
+            cstr = regexprep(cstr,'var_deltaqB_([0-9]+)','deltaqB[$1]');
+            cstr = regexprep(cstr,'var_sigma_y_([0-9]+)','sigmay[$1]');
+            cstr = regexprep(cstr,'var_sigma_z_([0-9]+)','sigmaz[$1]');
+            cstr = regexprep(cstr,'var_dsigma_zdp_([0-9]+)',['dsigmazdp[$1]']);
+            cstr = regexprep(cstr,'var_dsigma_ydp_([0-9]+)',['dsigmaydp[$1]']);
+            
+            cstr = regexprep(cstr,'var_dsdydp_([0-9]+)',['dsigmaydp[ip*' num2str(model.ny) ' + $1]']);
+            cstr = regexprep(cstr,'var_dsdzdp_([0-9]+)',['dsigmazdp[ip*' num2str(model.nz) ' + $1]']);
+            cstr = regexprep(cstr,'var_Jy_([0-9]+)','nllh[$1]');
+            cstr = regexprep(cstr,'var_Jz_([0-9]+)','nllh[$1]');
+            cstr = regexprep(cstr,'var_Jrz_([0-9]+)','nllh[$1]'); % not a typo; we dont want to creat an additional variable that we end the end add to Jz anyways.
+            cstr = regexprep(cstr,'var_dJydy[_\[]*([0-9\+\*]+)[\]]*','dJydy[$1]'); % matches both _... and [...]
+            cstr = regexprep(cstr,'var_dJzdz[_\[]*([0-9\+\*]+)[\]]*','dJzdz[$1]');
+            cstr = regexprep(cstr,'var_dJrzdz[_\[]*([0-9\+\*]+)[\]]*','dJrzdz[$1]');
+            cstr = regexprep(cstr,'var_dJydsigma[_\[]*([0-9\+\*]+)[\]]*','dJydsigma[$1]');
+            cstr = regexprep(cstr,'var_dJzdsigma[_\[]*([0-9\+\*]+)[\]]*','dJzdsigma[$1]');
+            cstr = regexprep(cstr,'var_dJrzdsigma[_\[]*([0-9\+\*]+)[\]]*','dJrzdsigma[$1]');
+            cstr = regexprep(cstr,'var_JDiag[_\[]*([0-9\+\*]+)[\]]*','JDiag[$1]');
+        end
+        
+        %%
+        % print to file
+        fprintf(fid,[cstr '\n']);
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getArgs.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getArgs.m
new file mode 100644
index 0000000000000000000000000000000000000000..8973601fb103f7563f2b006863b816a481ce88cd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getArgs.m
@@ -0,0 +1,130 @@
+function this = getArgs(this,model)
+    % getFArgs populates the fargstr property with the argument string of
+    % the respective model function (if applicable). model functions are not
+    % wrapped versions of functions which have a model specific name and
+    % for which the call is solver specific.
+    %
+    % Parameters:
+    %  model: model definition object @type amimodel
+    %
+    % Return values:
+    %  this: updated function definition object @type amifun
+    %
+        
+    if(strcmp(model.wtype,'iw'))
+        dx = ', const realtype *dx';
+        sdx = ', const realtype *sdx';
+        dxB = ', const realtype *dxB';
+        M = ', const realtype *M';
+        cj = ', const realtype cj';
+    else
+        dx = '';
+        sdx = '';
+        dxB = '';
+        M = '';
+        cj = '';
+    end
+    
+    switch(this.funstr)
+        case 'xdot'
+            this.argstr = ['(realtype *xdot, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' dx ', const realtype *w)'];
+        case 'xBdot'
+            this.argstr = ['(realtype *xBdot, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *xB' dx dxB ', const realtype *w, const realtype *dwdx)'];
+        case 'qBdot'
+            this.argstr = ['(realtype *qBdot, const int ip, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *xB' dx dxB ', const realtype *w, const realtype *dwdp)'];
+        case 'x0'
+            this.argstr = '(realtype *x0, const realtype t, const realtype *p, const realtype *k)';
+        case 'dx0'
+        case 'Jv'
+            this.argstr = ['(realtype *Jv, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' cj dx ', const realtype *v, const realtype *w, const realtype *dwdx)'];
+        case 'JvB'
+            this.argstr = ['(realtype *JvB, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' cj ', const realtype *xB' dx dxB ', const realtype *vB, const realtype *w, const realtype *dwdx)'];
+        case 'J'
+            this.argstr = ['(realtype *J, const realtype t, const realtype *x, const double *p, const double *k, const realtype *h' cj dx ', const realtype *w, const realtype *dwdx)'];
+        case 'JDiag'
+            this.argstr = ['(realtype *JDiag, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' cj dx ', const realtype *w, const realtype *dwdx)'];
+        case 'JSparse'
+            this.argstr = ['(SUNMatrixContent_Sparse JSparse, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' cj dx ', const realtype *w, const realtype *dwdx)'];
+        case 'JB'
+            this.argstr = ['(realtype *JB, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' cj ', const realtype *xB' dx dxB ', const realtype *w, const realtype *dwdx)'];
+        case 'JSparseB'
+            this.argstr = ['(SUNMatrixContent_Sparse JSparseB, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' cj ', const realtype *xB' dx dxB ', const realtype *w, const realtype *dwdx)'];
+        case 'sxdot'
+            this.argstr = ['(realtype *sxdot, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ip' dx ', const realtype *sx' sdx ', const realtype *w, const realtype *dwdx, const realtype *J' M ', const realtype *dxdotdp)'];
+        case 'sx0'
+            this.argstr = '(realtype *sx0, const realtype t,const realtype *x0, const realtype *p, const realtype *k, const int ip)';
+        case 'root'
+            this.argstr = ['(realtype *root, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h' dx ')'];
+        case 'y'
+            this.argstr = '(double *y, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *w)';
+        case 'z'
+            this.argstr = '(double *z, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h)';
+        case 'rz'
+            this.argstr = '(double *rz, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h)';
+        case 'sz'
+            this.argstr = '(double *sz, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *sx, const int ip)';
+        case 'srz'
+            this.argstr = '(double *srz, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *sx, const int ip)';
+        case 'dydp'
+            this.argstr = '(double *dydp, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ip, const realtype *w, const realtype *dwdp)';
+        case 'dydx'
+            this.argstr = '(double *dydx, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *w, const realtype *dwdx)';
+        case 'dzdp'
+            this.argstr = '(double *dzdp, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ip)';
+        case 'dzdx'
+            this.argstr = '(double *dzdx, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h)';
+        case 'drzdp'
+            this.argstr = '(double *drzdp, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ip)';
+        case 'drzdx'
+            this.argstr = '(double *drzdx, const int ie, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h)';
+        case 'deltax'
+            this.argstr = '(double *deltax, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ie, const realtype *xdot, const realtype *xdot_old)';
+        case 'deltaxB'
+            this.argstr = '(double *deltaxB, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ie, const realtype *xdot, const realtype *xdot_old, const realtype *xB)';
+        case 'deltaqB'
+            this.argstr = '(double *deltaqB, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ip, const int ie, const realtype *xdot, const realtype *xdot_old, const realtype *xB)';
+        case 'deltasx'
+            this.argstr = '(double *deltasx, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *w, const int ip, const int ie, const realtype *xdot, const realtype *xdot_old, const realtype *sx, const realtype *stau)';
+        case 'dxdotdp'
+            this.argstr = ['(realtype *dxdotdp, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const int ip' dx ', const realtype *w, const realtype *dwdp)'];
+        case 'sigma_y'
+            this.argstr = '(double *sigmay, const realtype t, const realtype *p, const realtype *k)';
+        case 'dsigma_ydp'
+            this.argstr = '(double *dsigmaydp, const realtype t, const realtype *p, const realtype *k, const int ip)';
+        case 'sigma_z'
+            this.argstr = '(double *sigmaz, const realtype t, const realtype *p, const realtype *k)';
+        case 'dsigma_zdp'
+            this.argstr = '(double *dsigmazdp, const realtype t, const realtype *p, const realtype *k, const int ip)';
+        case 'stau'
+            this.argstr = '(double *stau, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *sx, const int ip, const int ie)';
+        case 'Jy'
+            this.argstr = '(double *nllh, const int iy, const realtype *p, const realtype *k, const double *y, const double *sigmay, const double *my)';
+        case 'dJydy'
+            this.argstr = '(double *dJydy, const int iy, const realtype *p, const realtype *k, const double *y, const double *sigmay, const double *my)';
+        case 'dJydsigma'
+            this.argstr = '(double *dJydsigma, const int iy, const realtype *p, const realtype *k, const double *y, const double *sigmay, const double *my)';
+        case 'Jz'
+            this.argstr = '(double *nllh, const int iz, const realtype *p, const realtype *k, const double *z, const double *sigmaz, const double *mz)';
+        case 'Jrz'
+            this.argstr = '(double *nllh, const int iz, const realtype *p, const realtype *k, const double *rz, const double *sigmaz)';
+        case 'dJzdz'
+            this.argstr = '(double *dJzdz, const int iz, const realtype *p, const realtype *k, const double *z, const double *sigmaz, const double *mz)';
+        case 'dJzdsigma'
+            this.argstr = '(double *dJzdsigma, const int iz, const realtype *p, const realtype *k, const double *z, const double *sigmaz, const double *mz)';
+        case 'dJrzdz'
+            this.argstr = '(double *dJrzdz, const int iz, const realtype *p, const realtype *k, const double *rz, const double *sigmaz)';
+        case 'dJrzdsigma'
+            this.argstr = '(double *dJrzdsigma, const int iz, const realtype *p, const realtype *k, const double *rz, const double *sigmaz)';
+        case 'w'
+            this.argstr = '(realtype *w, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *tcl)';
+        case 'dwdp'
+            this.argstr = '(realtype *dwdp, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *w, const realtype *tcl, const realtype *stcl)';
+        case 'dwdx'
+            this.argstr = '(realtype *dwdx, const realtype t, const realtype *x, const realtype *p, const realtype *k, const realtype *h, const realtype *w, const realtype *tcl)';
+        case 'M'
+            this.argstr = '(realtype *M, const realtype t, const realtype *x, const realtype *p, const realtype *k)';
+        otherwise
+            %nothing
+    end
+    
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getCVar.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getCVar.m
new file mode 100644
index 0000000000000000000000000000000000000000..f9f68cf48aa9abec2f16c7d7c9b82542807f14aa
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getCVar.m
@@ -0,0 +1,30 @@
+function [ this ] = getCVar(this)
+    % getCVar populates the cvar property
+    %
+    % Parameters:
+    %
+    % Return values:
+    %  this: updated function definition object @type amifun
+    
+    switch(this.funstr)
+        case 'J'
+            this.cvar =  'J';
+        case 'JSparse'
+            this.cvar =  'var_JSparse';
+        case 'Jv'
+            this.cvar =  'var_Jv';
+        case 'JvB'
+            this.cvar =  'var_JvB';
+        case 'JB'
+            this.cvar =  'JB';
+        case 'JSparseB'
+            this.cvar =  'var_JSparseB';
+        case 'M'
+            this.cvar =  'M';
+        case 'dfdx'
+            this.cvar =  'dfdx';
+        otherwise
+            this.cvar = ['var_' this.funstr];
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getDeps.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getDeps.m
new file mode 100644
index 0000000000000000000000000000000000000000..efb5cb09d279748940474cd8242a25289335fe27
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getDeps.m
@@ -0,0 +1,252 @@
+function [ this ] = getDeps(this, model)
+    % getDeps populates the sensiflag for the requested function
+    %
+    % Parameters:
+    %  model: model definition object @type amimodel
+    %
+    % Return values:
+    %  this: updated function definition object @type amifun
+    
+    switch(this.funstr)
+        case 'xdot'
+            if(strcmp(model.wtype,'iw'))
+                this.deps = {'M','p','x','k','dx'};
+            else
+                this.deps = {'p','x','k'};
+            end
+            
+        case 'dfdx'
+            this.deps = {'xdot','x','dwdx'};
+            
+        case 'J'
+            if(strcmp(model.wtype,'iw'))
+                this.deps = {'dfdx','M','x','xdot'};
+            else
+                this.deps = {'xdot','x','dwdx'};
+            end
+            
+        case 'JB'
+            this.deps = {'J'};
+            
+        case 'dxdotdp'
+            this.deps = {'xdot','p','dwdp'};
+            
+        case 'sx0'
+            this.deps = {'x0','p'};    
+            
+        case 'sdx0'
+            this.deps = {'dx0','p'}; 
+            
+        case 'sxdot'
+            if(strcmp(model.wtype,'iw'))
+                this.deps = {'dfdx','M','dxdotdp','sdx','sx'};
+            else
+                this.deps = {'J','dxdotdp','sx'};
+            end
+            
+        case 'dydx'
+            this.deps = {'y','x'};
+            
+        case 'dydp'
+            this.deps = {'y','p'};
+          
+        case 'sy'
+            this.deps = {'dydp','dydx','sx'};
+            
+        case 'Jv'
+            this.deps = {'J'};
+            
+        case 'JvB'
+            this.deps = {'J'};
+            
+        case 'xBdot'
+            if(strcmp(model.wtype,'iw'))
+                this.deps = {'J','M','xB','dxB'};
+            else
+                this.deps = {'J','xB'};
+            end
+            
+        case 'qBdot'
+            this.deps = {'dxdotdp','xB'};
+            
+        case 'dsigma_ydp'
+            this.deps = {'sigma_y','p'};
+            
+        case 'dsigma_zdp'
+            this.deps = {'sigma_z','p'};
+            
+        case 'root'
+            this.deps = {'x','k','p'};
+            
+        case 'drootdp'
+            this.deps = {'root','p','drootdx','sx'};
+            
+        case 'drzdp'
+            this.deps = {'rz','p',};
+            
+        case 'drootdx'
+            this.deps = {'root','x'};
+            
+        case 'drzdx'
+            this.deps = {'rz','x',};
+            
+        case 'drootdt'
+            % w is necessary for xdot_noopt
+            this.deps = {'root','drootdx','xdot','w'};
+            
+        case 'deltax'
+            this.deps = {'x','k','p'};
+            
+        case 'ddeltaxdp'
+            this.deps = {'deltax','p'};
+            
+        case 'ddeltaxdx'
+            this.deps = {'deltax','x'};
+            
+        case 'ddeltaxdt'
+            this.deps = {'deltax'};
+            
+        case 'deltasx'
+            this.deps = {'deltax','deltaxdot','ddeltaxdx','ddeltaxdp','ddeltaxdt','dtaudp','xdot','sx','stau'};
+        
+        case 'deltaqB'
+            this.deps = {'ddeltaxdp','xB'};
+            
+        case 'deltaxB'
+            this.deps = {'deltax','dtaudp','xdot','xB','ddeltaxdx'};
+            
+        case 'z'
+            this.deps = {'x','k','p'};
+            
+        case 'rz'
+            this.deps = {'z','root'};
+            
+        case 'srz'
+            this.deps = {'rz','root','drootdx','drootdp','sx'};
+            
+        case 'dzdp'
+            this.deps = {'z','p','dtaudp'};
+            
+        case 'dzdx'
+            this.deps = {'z','x','dtaudx'};
+            
+        case 'dzdt'
+            % w is necessary for xdot_noopt
+            this.deps = {'z','x','xdot','w'};
+            
+        case 'sz'
+            this.deps = {'dzdp','dzdx','dzdt','sx','dtaudp','stau'};
+            
+        case 'sz_tf'
+            this.deps = {'dzdp','dzdx','sx'};
+            
+        case 'dtaudp'
+            this.deps = {'drootdp','drootdt'};
+            
+        case 'dtaudx'
+            this.deps = {'drootdx','drootdt'};
+            
+        case 'stau'
+            this.deps = {'sroot','drootdt'};
+            
+        case 'sroot'
+            this.deps = {'drootdp','drootdx','sx'};
+ 
+        case 'x0'
+            this.deps = {'p','k','x'};
+            
+        case 'JBand'
+            this.deps = {'J'};
+            
+        case 'JBandB'
+            this.deps = {'JB'};
+            
+        case 'JSparse'
+            this.deps = {'J'};
+            
+        case 'JSparseB'
+            this.deps = {'JB'};
+            
+        case 'JDiag'
+            this.deps = {'J'};
+            
+        case 'y'
+            this.deps = {'x','p','k'};
+            
+        case 'sigma_y'
+            this.deps = {'p','k'};
+        
+        case 'sigma_z'
+            this.deps = {'p','k'};
+            
+        case 'rhs'
+            this.deps = {'xdot'};
+            
+        case 'dx0'
+            this.deps = {'x','p','k'};
+            
+        case 'M'
+            this.deps = {'x','p','k'};
+            
+        case 'x'
+            this.deps = {};
+            
+        case 'dx'
+            this.deps = {};
+            
+        case 'xB'
+            this.deps = {};
+            
+        case 'dxB'
+            this.deps = {};
+            
+        case 'k'
+            this.deps = {};
+            
+        case 'p'
+            this.deps = {};
+            
+        case 'sx'
+            this.deps = {};
+            
+        case 'sdx'
+            this.deps = {};
+        
+        case 'deltaxdot'
+            this.deps = {'xdot'};
+            
+        case 'Jy'
+            this.deps = {'y','sigma_y'};
+        case 'dJydy'
+            this.deps = {'Jy','y'};
+        case 'dJydsigma'
+            this.deps = {'Jy','sigma_y'};
+            
+        case 'Jz'
+            this.deps = {'z','sigma_z'};
+        case 'dJzdz'
+            this.deps = {'Jz','x'};
+        case 'dJzdsigma'
+            this.deps = {'Jz','sigma_z'};
+        case 'Jrz'
+            this.deps = {'rz','sigma_z'};
+        case 'dJrzdz'
+            this.deps = {'Jrz','x'};
+        case 'dJrzdsigma'
+            this.deps = {'Jrz','sigma_z'};
+            
+        case 'w'
+            this.deps = {'xdot'};
+        case 'dwdp'
+            this.deps = {'w','p'};
+        case 'dwdx'
+            this.deps = {'w','x'};
+            
+        case 's2root'
+            this.deps = {'sroot'};
+
+        otherwise
+            error(['unknown function string: ' this.funstr ])
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getNVecs.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getNVecs.m
new file mode 100644
index 0000000000000000000000000000000000000000..4b75133a0ed134069e9bf809119d03f9a98f3e6b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getNVecs.m
@@ -0,0 +1,26 @@
+function this = getNVecs(this)
+    % getfunargs populates the nvecs property with the names of the
+    % N_Vector elements which are required in the execution of the function 
+    % (if applicable). the information is directly extracted from the
+    % argument string
+    %
+    % Parameters:
+    %
+    % Return values:
+    %  this: updated function definition object @type amifun
+    %
+    
+    vecs = {'x,','dx,','sx,','*sx,','sdx,','xB,','dxB,',...
+        '*sxdot,','sxdot,','xdot,','xBdot,','qBdot,',...
+        'x0,','dx0,','*sx0,','*sdx0,',...
+        'v,','vB,','JDiag,','Jv,','JvB,',...
+        'xdot_old,'};
+    
+    this.nvecs = {};
+    for iv = 1:length(vecs)
+        if strfind(this.argstr,['N_Vector ' vecs{iv}])
+            this.nvecs = [this.nvecs,vecs{iv}(1:(end-1))];
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getSensiFlag.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getSensiFlag.m
new file mode 100644
index 0000000000000000000000000000000000000000..9d646509cb981bf9ec7587ab1cd24b742b928f8c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getSensiFlag.m
@@ -0,0 +1,75 @@
+function [ this ] = getSensiFlag(this)
+    % getSensiFlag populates the sensiflag property
+    %
+    % Parameters:
+    %
+    % Return values:
+    %  this: updated function definition object @type amifun
+    
+    switch(this.funstr)
+        case 'dxdotdp'
+            this.sensiflag = true;
+            
+        case 'sx0'
+            this.sensiflag = true;  
+            
+        case 'sdx0'
+            this.sensiflag = true;
+            
+            
+        case 'dydp'
+            this.sensiflag = true;
+          
+        case 'sy'
+            this.sensiflag = true;
+            
+        case 'qBdot'
+            this.sensiflag = true;
+            
+        case 'dsigma_ydp'
+            this.sensiflag = true;
+            
+        case 'dsigma_zdp'
+            this.sensiflag = true;
+            
+        case 'drzdp'
+            this.sensiflag = true;
+            
+        case 'ddeltaxdp'
+            this.sensiflag = true;
+            
+        case 'deltasx'
+            this.sensiflag = true;
+        
+        case 'deltaqB'
+            this.sensiflag = true;
+            
+        case 'dzdp'
+            this.sensiflag = true;
+            
+        case 'sz'
+            this.sensiflag = true;
+            
+        case 'dtaudp'
+            this.sensiflag = true;
+            
+        case 'stau'
+            this.sensiflag = true;
+            
+        case 'sroot'
+            this.sensiflag = true;
+            
+        case 'srz'
+            this.sensiflag = true;
+            
+        case 'sx'
+            this.sensiflag = true;
+            
+        case 'sdx'
+            this.sensiflag = true;
+
+        otherwise
+            this.sensiflag = false;
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getSyms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getSyms.m
new file mode 100644
index 0000000000000000000000000000000000000000..425268babfee26ae83b936b7aee85ef290876ba1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/getSyms.m
@@ -0,0 +1,862 @@
+function [this,model] = getSyms(this,model)
+    % getSyms computes the symbolic expression for the requested function
+    %
+    % Parameters:
+    %  model: model definition object @type amimodel
+    %
+    % Return values:
+    %  this: updated function definition object @type amifun
+    %  model: updated model definition object @type amimodel
+    
+    % store often used variables for ease of notation, dependencies should
+    % ensure that these variables are defined
+    
+    persistent x p sx w ndw jacw
+    
+    nx = model.nx;
+    nevent = model.nevent;
+    np = model.np;
+    nk = model.nk;
+    nz = model.nz;
+    ny = model.ny;
+    
+    fprintf([this.funstr ' | '])
+    switch(this.funstr)
+        case 'x'
+            % create cell array of same size
+            xs = cell(nx,1);
+            % fill cell array
+            for j=1:nx
+                xs{j} = sprintf('var_x_%i',j-1);
+            end
+            % transform into symbolic expression
+            this.sym = sym(xs);
+            x = this.sym;
+            
+        case 'dx'
+            % create cell array of same size
+            dxs = cell(nx,1);
+            % fill cell array
+            for j=1:nx
+                dxs{j} = sprintf('var_dx_%i',j-1);
+            end
+            % transform into symbolic expression
+            this.sym = sym(dxs);
+            
+        case 'p'
+            % create cell array of same size
+            ps = cell(np,1);
+            % fill cell array
+            for j=1:np
+                ps{j} = sprintf('var_p_%i',j-1);
+            end
+            % transform into symbolic expression
+            this.sym = sym(ps);
+            p = this.sym;
+            
+        case 'k'
+            % create cell array of same size
+            ks = cell(nk,1);
+            % fill cell array
+            for j=1:nk
+                ks{j} = sprintf('var_k_%i',j-1);
+            end
+            % transform into symbolic expression
+            this.sym = sym(ks);
+            
+        case 'sx'
+            % create cell array of same size
+            sxs = cell(nx,1);
+            % fill cell array
+            for j = 1:nx
+                sxs{j} = sprintf('var_sx_%i', j-1);
+            end
+            % transform into symbolic expression
+            this.sym = repmat(sym(sxs),[1,np]);
+            sx = this.sym;
+            
+        case 'sdx'
+            % create cell array of same size
+            sdx = cell(nx,np);
+            % fill cell array
+            for j = 1:nx
+                for i = 1:np
+                    sdx{j,i} = sprintf('var_sdx_%i', j-1);
+                end
+            end
+            % transform into symbolic expression
+            this.sym = sym(sdx);
+            
+        case 'xB'
+            % create cell array of same size
+            xBs = cell(nx,1);
+            % fill cell array
+            for j = 1:nx
+                xBs{j} = sprintf('var_xB_%i', j-1);
+            end
+            % transform into symbolic expression
+            this.sym = sym(xBs);
+            
+        case 'dxB'
+            % create cell array of same size
+            dxBs = cell(nx,1);
+            % fill cell array
+            for j = 1:nx
+                dxBs{j} = sprintf('var_dxB_%i', j-1);
+            end
+            % transform into symbolic expression
+            this.sym = sym(dxBs);
+            
+        case 'y'
+            this.sym = model.sym.y;
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            this = makeStrSymsFull(this);
+            
+            
+            % activate splines
+            for iy = 1:ny
+                if(not(all([model.splineflag,model.minflag,model.maxflag])))
+                    str = char(this.sym(iy));
+                    if(strfind(str,'spline'))
+                        model.splineflag = true;
+                    end
+                    if(strfind(str,'max'))
+                        model.maxflag = true;
+                    end
+                    if(strfind(str,'min'))
+                        model.minflag = true;
+                    end
+                end
+            end          
+            
+        case 'x0'
+            this.sym = model.sym.x0;
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            
+        case 'dx0'
+            this.sym = model.sym.dx0;
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            
+        case 'sigma_y'
+            this.sym = model.sym.sigma_y;
+            this = makeStrSymsFull(this);
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            
+        case 'sigma_z'
+            this.sym = model.sym.sigma_z;
+            this = makeStrSymsFull(this);
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            
+        case 'M'
+            this.sym = sym(model.sym.M);
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            this = makeStrSyms(this);
+            
+        case 'xdot'
+            this.sym = model.sym.xdot;
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            
+            if(strcmp(model.wtype,'iw'))
+                if(size(this.sym,2)>size(this.sym,1))
+                    this.sym = -transpose(model.fun.M.sym*model.fun.dx.sym)+this.sym;
+                else
+                    this.sym = -model.fun.M.sym*model.fun.dx.sym+this.sym;
+                end
+            end
+            
+            % create cell array of same size
+            xdots = cell(nx,1);
+            xdot_olds = cell(nx,1);
+            % fill cell array
+            for j=1:nx
+                xdots{j} = sprintf('xdot_%i',j-1);
+                xdot_olds{j} = sprintf('xdot_old_%i',j-1);
+            end
+            this.strsym = sym(xdots);
+            this.strsym_old = sym(xdot_olds);
+            
+            % activate splines
+            for ix = 1:nx
+                if(not(all([model.splineflag,model.minflag,model.maxflag])))
+                    str = char(this.sym(ix));
+                    if(strfind(str,'spline'))
+                        model.splineflag = true;
+                    end
+                    if(strfind(str,'max'))
+                        model.maxflag = true;
+                    end
+                    if(strfind(str,'min'))
+                        model.minflag = true;
+                    end
+                end
+            end
+            
+        case 'w'
+            optimize = getoptimized(optsym(model.fun.xdot.sym));
+            tmpxdot = sym(char(optimize(end)));
+            nw = (length(optimize)-1);
+            model.nw = nw;
+            if(nw>0)
+                exprs = arrayfun(@(x) children(x),optimize(1:(end-1)),'UniformOutput',false); % extract symbolic variable
+                S.subs = {2};
+                S.type='()';
+                C = cellfun(@(x) subsref(x,S),exprs,'UniformOutput',false); % get second element
+                this.sym = [C{:}]; % transform cell to matrix
+                S.subs = {1};
+                C = cellfun(@(x) subsref(x,S),exprs,'UniformOutput',false);
+                temps = [C{:}];
+            end
+%             model.nw = 0;
+%             nw = 0;
+%             this.sym = sym(zeros(0,1));          
+            
+
+            
+            ws = cell(nw,1);
+            ts = cell(nw,1);
+            % fill cell array
+            for iw = 1:nw
+                ws{iw} = sprintf('var_w_%i', iw-1);
+            end
+            % transform into symbolic expression
+            this.strsym = sym(ws);
+            ndw = 0;
+            if(nw>0)
+                tmpxdot = mysubs(tmpxdot,temps,this.strsym); % replace common expressions
+                this.sym = mysubs(this.sym,temps,this.strsym);
+                model.updateRHS(tmpxdot); % update rhs
+                ndw = 1;
+                jacw = jacobian(this.sym,this.strsym);
+                vv = sym('v',[length(this.strsym),1]);
+                while(sum(jacw^ndw*vv)~=0)
+                    ndw = ndw+1;
+                end
+                ndw = ndw - 1;
+            else
+                model.updateRHS(tmpxdot); % update RHS anyways to generate sym_noopt for fun.xdot
+            end
+            w = this.strsym;
+
+        case 'dwdx'
+            if(length(model.fun.w.sym)>0)
+                jacx = jacobian(model.fun.w.sym,x);
+                this.sym = jacx;
+                for idw = 1:ndw
+                    this.sym = this.sym + (jacw^idw)*jacx; % this part is only to get the right nonzero entries 
+                end
+                % fill cell array
+                idx_w = find(this.sym);
+                this.strsym = sym(zeros(size(jacx)));
+                if(numel(idx_w)>0)
+                    for iw = 1:length(idx_w)
+                        this.strsym(idx_w(iw)) = sym(sprintf('var_dwdx_%i', iw-1));
+                    end
+                    model.ndwdx = length(idx_w);
+                    % update dwdx with simplified expressions, here we can exploit
+                    % the proper ordering of w to ensure correctness of expressions
+                    tmp = jacx + jacw*this.strsym;
+                    this.sym = tmp(idx_w);
+                else
+                    this.strsym = sym(zeros(size(jacx)));
+                end
+            else
+                this.sym = sym(zeros(0,nx));
+                this.strsym = sym(zeros(0,nx));
+            end
+            
+        case 'dwdp'
+            if(length(model.fun.w.sym)>0)
+                jacp = jacobian(model.fun.w.sym,p);
+                this.sym = jacp;
+                for idw = 1:ndw
+                    this.sym = this.sym + (jacw^idw)*jacp; % this part is only to get the right nonzero entries 
+                end
+                % fill cell array
+                idx_w = find(this.sym);
+                this.strsym = sym(zeros(size(jacp)));
+                if(numel(idx_w)>0)
+                    for iw = 1:length(idx_w)
+                        this.strsym(idx_w(iw)) = sym(sprintf('var_dwdp_%i', iw-1));
+                    end
+                    model.ndwdp = length(idx_w);
+                    % update dwdx with simplified expressions, here we can exploit
+                    % the proper ordering of w to ensure correctness of expressions
+                    tmp = jacp + jacw*this.strsym;
+                    this.sym = tmp(idx_w);
+                end
+            else
+                this.sym = sym(zeros(0,nx));
+                this.strsym = sym(zeros(0,nx));
+            end
+            
+        case 'dfdx'
+            this.sym=jacobian(model.fun.xdot.sym,x) + jacobian(model.fun.xdot.sym,w)*model.fun.dwdx.strsym;
+            this = makeStrSyms(this);
+            
+        case 'J'
+            if(strcmp(model.wtype,'iw'))
+                syms cj
+                this.sym = model.fun.dfdx.sym - cj*model.fun.M.sym;
+            else
+                if(~isempty(w))
+                    this.sym = jacobian(model.fun.xdot.sym,x)  + jacobian(model.fun.xdot.sym,w)*model.fun.dwdx.strsym;
+                    this.sym_noopt = jacobian(model.fun.xdot.sym_noopt,x);
+                else
+                    this.sym = jacobian(model.fun.xdot.sym,x);
+                    this.sym_noopt = this.sym;
+                end
+            end
+            
+            this = makeStrSymsSparse(this);
+               
+        
+            
+        case 'JDiag'
+            this.sym = diag(model.fun.J.sym);
+            this = makeStrSyms(this);
+            
+        case 'JB'
+            this.sym = sym(zeros(model.nx, model.nx));
+            % Augmentation needs a transposition in the submatrices
+            if(model.nx>0)
+                for ix = 1 : model.ng
+                    for jx = 1 : model.ng
+                        this.sym((ix-1)*model.nxtrue+1:ix*model.nxtrue, (jx-1)*model.nxtrue+1:jx*model.nxtrue) = ...
+                            -transpose(model.fun.J.sym((ix-1)*model.nxtrue+1:ix*model.nxtrue, (jx-1)*model.nxtrue+1:jx*model.nxtrue));
+                    end
+                end
+            end
+            
+        case 'dxdotdp'
+            if(~isempty(w))
+                this.sym=jacobian(model.fun.xdot.sym,p)  + jacobian(model.fun.xdot.sym,w)*model.fun.dwdp.strsym;
+                this.sym_noopt = jacobian(model.fun.xdot.sym_noopt,p);
+            else
+                this.sym=jacobian(model.fun.xdot.sym,p);
+                this.sym_noopt = this.sym;
+            end
+            
+            %%
+            % build short strings for reuse of dxdotdp
+            % create cell array of same size
+            dxdotdps = cell(nx,1);
+            % fill cells with strings
+            for ix = 1:nx
+                dxdotdps{ix} = sprintf('tmp_dxdotdp_%i',ix-1);
+            end
+            % create full symbolic array
+            this.strsym = sym(dxdotdps);
+            
+        case 'sx0'
+            this.sym=jacobian(model.fun.x0.sym,p);
+            
+        case 'sdx0'
+            this.sym=jacobian(model.fun.dx0.sym,p);
+            
+        case 'sxdot'
+            if(np>0)
+                if(strcmp(model.wtype,'iw'))
+                    this.sym=model.fun.J.strsym*sx(:,1)-model.fun.M.strsym*model.fun.sdx.sym(:,1)+model.fun.dxdotdp.strsym;
+                else
+                    this.sym=model.fun.J.strsym*sx(:,1)+model.fun.dxdotdp.strsym;
+                end
+            else
+                this.sym = sym(zeros(size(sx,1),0));
+            end
+            
+        case 'dydx'
+            this.sym=jacobian(model.fun.y.sym,x);
+            % create cell array of same sizex
+            this.strsym = sym(zeros(ny,nx));
+            % fill cell array
+            this = makeStrSyms(this);
+            
+        case 'dydp'
+            this.sym=jacobian(model.fun.y.sym,p);
+            % create cell array of same size
+            this = makeStrSyms(this);
+            
+        case 'Jv'
+            % create cell array of same size
+            vs = cell(nx,1);
+            % fill cells
+            for j=1:nx
+                vs{j} = sprintf('var_v_%i',j-1);
+            end
+            % transform to symbolic variable
+            vs = sym(vs);
+            % multiply
+            this.sym = model.fun.J.sym*vs;
+            
+        case 'JvB'
+            % create cell array of same size
+            vs = cell(nx,1);
+            % fill cells
+            for j=1:nx
+                vs{j} = sprintf('var_vB_%i',j-1);
+            end
+            % transform to symbolic variable
+            vs = sym(vs);
+            % multiply
+            this.sym = model.fun.JB.sym*vs;
+            
+        case 'xBdot'
+            if(strcmp(model.wtype,'iw'))
+                syms t
+                this.sym = diff(transpose(model.fun.M.sym),t)*model.fun.xB.sym + transpose(model.fun.M.sym)*model.fun.dxB.sym - transpose(model.fun.dfdx.sym)*model.fun.xB.sym;
+            else
+                this.sym = model.fun.JB.sym * model.fun.xB.sym;
+            end
+            
+        case 'qBdot'
+            % If we do second order adjoints, we have to augment
+            if (model.nxtrue < nx)
+                this.sym = sym(zeros(model.ng, model.np));
+                this.sym(1,:) = -transpose(model.fun.xB.sym(1:model.nxtrue)) * model.fun.dxdotdp.sym(1:model.nxtrue, :);
+                for ig = 2 : model.ng
+                    this.sym(ig,:) = ...
+                        -transpose(model.fun.xB.sym(1:model.nxtrue)) * model.fun.dxdotdp.sym((ig-1)*model.nxtrue+1 : ig*model.nxtrue, :) ...
+                        -transpose(model.fun.xB.sym((ig-1)*model.nxtrue+1 : ig*model.nxtrue)) * model.fun.dxdotdp.sym(1:model.nxtrue, :);
+                end                    
+            else
+                this.sym = -transpose(model.fun.xB.sym)*model.fun.dxdotdp.sym;
+            end
+
+        case 'dsigma_ydp'
+            this.sym = jacobian(model.fun.sigma_y.sym,p);
+            this = makeStrSyms(this);
+            
+        case 'dsigma_zdp'
+            if(nz>0)
+                this.sym = jacobian(model.fun.sigma_z.sym,p);
+            else
+                this.sym = sym(zeros(model.nz,np));
+            end
+            this = makeStrSyms(this);
+            
+        case 'root'
+            if(nevent>0)
+                this.sym = transpose([model.event.trigger]);
+                this = unifySyms(this,model);
+            else
+                this.sym = sym(zeros(0,1));
+            end
+            for ir = 1:nevent
+                if(not(all([model.splineflag,model.minflag,model.maxflag])))
+                    str = char(this.sym(ir));
+                    if(strfind(str,'spline'))
+                        model.splineflag = true;
+                    end
+                    if(strfind(str,'max'))
+                        model.maxflag = true;
+                    end
+                    if(strfind(str,'min'))
+                        model.minflag = true;
+                    end
+                end
+            end
+            
+        case 'drootdp'
+            this.sym = jacobian(model.fun.root.sym,p);
+            
+        case 'drootdx'
+            this.sym = jacobian(model.fun.root.sym,x);
+            
+        case 'drootdt'
+            % noopt is important here to get derivatives right
+            this.sym = diff(model.fun.root.sym,'t') + model.fun.drootdx.sym*model.fun.xdot.sym_noopt;
+            
+        case 'sroot'
+            this.sym = model.fun.drootdp.sym + model.fun.drootdx.sym*sx;
+            
+        case 'srz'
+            if(isfield(model.sym,'rz')) % user defined input or from augmentation
+                this.sym = jacobian(model.fun.rz.sym,p) + jacobian(model.fun.rz.sym,x)*sx;
+            else
+                for iz = 1:length(model.z2event)
+                    this.sym(iz,:) = model.fun.sroot.sym(model.z2event(iz),:);
+                end
+            end
+          
+        case 's2root'
+            switch(model.o2flag)
+                case 1
+                    s2x = reshape(sx((model.nxtrue+1):end,:),[model.nxtrue,np,np]);
+                    vec = sym(eye(np));
+                case 2
+                    s2x = reshape(sx((model.nxtrue+1):end,:),[model.nxtrue,np,1]);
+                    vec = model.sym.k((end-np+1):end);
+            end
+            for ievent = 1:nevent
+                
+                this.sym(ievent,:,:) = (jacobian(model.fun.sroot.sym(ievent,:),p) + jacobian(model.fun.sroot.sym(ievent,:),x(1:model.nxtrue))*sx(1:model.nxtrue,:) + jacobian(model.fun.sroot.sym(ievent,:),x(1:model.nxtrue))*sx(1:model.nxtrue,:))*vec;
+                for ix = 1:model.nxtrue
+                    this.sym(ievent,:,:) = this.sym(ievent,:,:) + model.fun.drootdx.sym(ievent,ix)*s2x(ix,:,:);
+                end
+            end
+            
+        case 'dtaudp'
+            this.sym = sym(zeros(nevent,np));
+            for ievent = 1:nevent
+                this.sym(ievent,:) = - model.fun.drootdp.sym(ievent,:)/model.fun.drootdt.sym(ievent);
+            end
+            
+        case 'dtaudx'
+            this.sym = sym(zeros(nevent,nx));
+            for ievent = 1:nevent
+                this.sym(ievent,:) = - model.fun.drootdx.sym(ievent,:)/model.fun.drootdt.sym(ievent);
+            end
+            
+        case 'stau'
+            this.sym = sym(zeros(nevent,np));
+            for ievent = 1:nevent
+                this.sym(ievent,:) = - model.fun.sroot.sym(ievent,:)/model.fun.drootdt.sym(ievent);
+            end
+            % create cell array of same size
+            staus = cell(1,np);
+            % fill cells
+            for j=1:np
+                staus{j} = sprintf('var_stau_%i',j-1);
+            end
+            % transform to symbolic variable
+            staus = sym(staus);
+            % multiply
+            this.strsym = staus;
+                
+        case 'deltax'
+            if(nevent>0)
+                this.sym = [model.event.bolus];
+                this = unifySyms(this,model);
+            else
+                this.sym = sym(zeros(0,1));
+            end
+            
+        case 'deltaxdot'
+            this.sym = model.fun.xdot.strsym-model.fun.xdot.strsym_old;
+            
+        case 'ddeltaxdp'
+            this.sym = sym(zeros(nx,nevent,np));
+            for ievent = 1:nevent
+                this.sym(:,ievent,:) = jacobian(model.fun.deltax.sym(:,ievent),p);
+            end
+            
+        case 'ddeltaxdx'
+            this.sym = sym(zeros(nx,nevent,nx));
+            if(nx>0)
+                for ievent = 1:nevent
+                    this.sym(:,ievent,:) = jacobian(model.fun.deltax.sym(:,ievent),x);
+                end
+            end
+             
+        case 'ddeltaxdt'
+            this.sym = diff(model.fun.deltax.sym,'t');
+            
+        case 'deltasx'
+            
+            if(nevent>0)
+                for ievent = 1:nevent
+                    
+                    % dtdp  = (1/drdt)*drdp
+                    dtdp = model.fun.stau.strsym; % this 1 here is correct, we explicitely do not want ievent here as the actual stau_tmp will only have dimension np
+                    
+                    % if we are just non-differentiable and but not
+                    % discontinuous we can ignore some of the terms!                
+                    if(any(logical(model.fun.deltax.sym(:,ievent)~=0)))
+                        % dxdp  = dx/dt*dt/dp + dx/dp
+                        dxdp = sym(zeros(nx,np));
+                        for ix = 1:nx
+                            dxdp(ix,:) = model.fun.xdot.sym(ix)*dtdp + sx(ix,:);
+                        end
+                        
+                        this.sym(:,:,ievent) = ...
+                            + permute(model.fun.ddeltaxdx.sym(:,ievent,:),[1 3 2])*dxdp ...
+                            + model.fun.ddeltaxdt.sym(:,ievent)*dtdp ...
+                            + permute(model.fun.ddeltaxdp.sym(:,ievent,:),[1 3 2]);
+                    else
+                        this.sym(:,:,ievent) = sym(zeros([nx,np]));
+                    end
+                    if(any(model.event(ievent).hflag))
+                        this.sym(model.event(ievent).hflag,:,ievent) = ...
+                            this.sym(model.event(ievent).hflag,:,ievent) ...
+                            - model.fun.deltaxdot.sym(model.event(ievent).hflag)*dtdp;
+                    end
+                end
+            end
+            
+        case 'deltaqB'
+            if (model.nxtrue < nx)
+                ng_tmp = round(nx / model.nxtrue);
+                this.sym = sym(zeros(np*ng_tmp,nevent));
+            else
+                this.sym = sym(zeros(np,nevent));
+            end
+            
+            for ievent = 1:nevent
+                this.sym(1:np,ievent) = -transpose(model.fun.xB.sym)*squeeze(model.fun.ddeltaxdp.sym(:,ievent,:));
+                % This is just a very quick fix. Events in adjoint systems
+                % have to be implemented in a way more rigorous way later
+                % on... Some day...
+            end
+            
+        case 'deltaxB'
+            this.sym = sym(zeros(nx,nevent));
+            for ievent = 1:nevent
+                this.sym(:,ievent) = -transpose(squeeze(model.fun.ddeltaxdx.sym(:,ievent,:)))*model.fun.xB.sym;
+            end
+            
+            
+        case 'z'
+            if(nevent>0)
+                this.sym = transpose([model.event.z]);
+                this = unifySyms(this,model);
+            else
+                this.sym = sym(zeros(0,1));
+            end
+            % construct the event identifyer, this is a vector which maps
+            % events to outputs z
+            model.z2event = zeros(length(this.sym),1);
+            iz = 0;
+            for ievent = 1:nevent
+                for jz = 1:length(model.event(ievent).z)
+                    iz = iz+1;
+                    model.z2event(iz) = ievent;
+                end
+            end
+            this = makeStrSymsFull(this);
+            
+        case 'rz'
+            this.sym = sym(zeros(size(model.fun.z.sym)));
+            if(isfield(model.sym,'rz'))
+                this.sym = model.sym.rz;
+            else
+                for iz = 1:length(model.z2event)
+                    this.sym(iz) = model.fun.root.sym(model.z2event(iz));
+                end
+            end
+            this = unifySyms(this,model);
+            this = makeStrSymsFull(this);
+            
+        case 'dzdp'
+            this.sym = jacobian(model.fun.z.sym,p);
+                
+            for iz = 1:nz
+                this.sym(iz,:) = this.sym(iz,:) + diff(model.fun.z.sym(iz),sym('t'))*model.fun.dtaudp.sym(model.z2event(iz),:);
+            end
+            % create cell array of same size
+            this = makeStrSyms(this);
+            
+        case 'drzdp'
+            this.sym = jacobian(model.fun.rz.sym,p);
+            this = makeStrSyms(this);
+            
+        case 'dzdx'
+            this.sym = jacobian(model.fun.z.sym,x);
+            for iz = 1:nz
+                this.sym(iz,:) = this.sym(iz,:)+ diff(model.fun.z.sym(iz),sym('t'))*model.fun.dtaudx.sym(model.z2event(iz),:);
+            end
+            this = makeStrSyms(this);
+            
+        case 'drzdx'
+            this.sym = jacobian(model.fun.rz.sym,x);
+            this = makeStrSyms(this);
+            
+        case 'dzdt'
+            if(nz>0)
+                this.sym = diff(model.fun.z.sym,'t')+jacobian(model.fun.z.sym,x(1:model.nxtrue))*model.fun.xdot.sym_noopt(1:model.nxtrue);
+            else
+                this.sym = sym.empty();
+            end
+            
+        case 'sz'
+            this.sym = sym(zeros(nz,np));
+            tmpsym = sym(zeros(nz-model.nztrue,np));
+            for iz = 1:nz
+                if iz <= model.nztrue
+                    this.sym(iz,:) = ...
+                        + jacobian(model.fun.z.sym(iz),p) ...
+                        + jacobian(model.fun.z.sym(iz),x(1:model.nxtrue))*sx(1:model.nxtrue,:) ...
+                        + model.fun.dzdt.sym(iz)*model.fun.stau.sym(model.z2event(iz),:);
+                else
+                    % I have discovered a truly marvelous proof of these equations, which this margin is too small to
+                    % contain.
+                    %
+                    % we need (dtau/dt)\(ddzdpdt*dtdp + dtdpddzdtdp + ddzdpdp       + dtdp*ddzdtdt*dtdp here
+                    % term above:        jacx*sx+jacp   dzdt*st       jacx*sx+jacp    dzdt*st
+                    % term in aug z:     drootdt        dzdp          dzdp            drootdt
+                    % augmented is always drootdt\dzdp or linear combinations
+                    % we cannot correctly compute ddzdpdt, but only ddzdtdp so we omit the drootdt part of jacx*sx-jacp
+                    % symmetrise it and add it later on.
+                    % also the dzdp part contains second order sensitivities and the drootdt part does not (this leads
+                    % to 1:model.nxtrue indexing)
+                    
+                    
+                    if(model.o2flag==1)
+                        tmpsym(iz-model.nztrue,:) = jacobian(1/model.fun.drootdt.sym(model.z2event(iz)),p)*model.fun.z.sym(iz)*model.fun.drootdt.sym(model.z2event(iz)) ...
+                            + jacobian(1/model.fun.drootdt.sym(model.z2event(iz)),x(1:model.nxtrue))*sx(1:model.nxtrue,:)*model.fun.z.sym(iz)*model.fun.drootdt.sym(model.z2event(iz));
+                    else
+                       error('sz for directional second order sensis was never implemented and I do not know how to, you are on your own here.'); 
+                    end
+                    
+                    this.sym(iz,:) = ...
+                        + jacobian(model.fun.z.sym(iz)*model.fun.drootdt.sym(model.z2event(iz)),p)/model.fun.drootdt.sym(model.z2event(iz)) ...
+                        + jacobian(model.fun.z.sym(iz)*model.fun.drootdt.sym(model.z2event(iz)),x)*sx/model.fun.drootdt.sym(model.z2event(iz)) ...
+                        + model.fun.dzdt.sym(iz)*model.fun.stau.sym(model.z2event(iz),:);
+                end
+            end
+            if(model.nz>0)
+                if(model.o2flag==1)
+                    % THIS IS WHAT YOU NEED TO FIX FOR model.o2flag == 2, transpose does not do the deal :(
+                    % we need to pay attention here, some sensitivities are encoded as sx and some as augmented x.
+                    % the sx ones are not transposable (as the parameter is encoded in the matrix column) so we need to
+                    % convert all of them to augmented x.
+                    for ip = 1:np
+                        tmpsym(:,ip) = subs(tmpsym(:,ip),sx(1:model.nxtrue,1),x((model.nxtrue*ip+1):(model.nxtrue*(ip+1))));
+                    end
+                    this.sym(model.nztrue+1:end,:) = this.sym(model.nztrue+1:end,:) + tmpsym + transpose(tmpsym);
+                    % you might not believe this, but this matrix should (and hopefully will) actually be symmetric ;)
+                end
+            end
+            
+            % create cell array of same size
+            szs = cell(nz,np);
+            % fill cell array
+            for j = 1:nz
+                for i = 1:np
+                    szs{j,i} = sprintf('sz_%i', j-1);
+                end
+            end
+            % transform into symbolic expression
+            this.strsym = sym(szs);
+            
+        case 'JBand'
+            %do nothing
+        case 'JBandB'
+            %do nothing
+        case 'JSparse'
+            %do nothing
+        case 'JSparseB'
+            %do nothing
+            
+        case 'Jy'
+            this.sym = model.sym.Jy;
+            % replace unify symbolic expression
+            this = unifySyms(this,model);
+            tmp = arrayfun(@(iy)sym(sprintf('y_%i',iy-1)),1:ny,'UniformOutput',false);
+            this.sym = mysubs(this.sym,[tmp{:}],model.fun.y.strsym);
+            tmp = arrayfun(@(iy)sym(sprintf('sigma_y_%i',iy-1)),1:ny,'UniformOutput',false);
+            this.sym = mysubs(this.sym,[tmp{:}],model.fun.sigma_y.strsym);
+        case 'dJydy'
+            this.sym = sym(zeros(model.nytrue, model.ng, model.ny));
+            for iyt = 1 : model.nytrue
+                this.sym(iyt,:,:) = jacobian(model.fun.Jy.sym(iyt,:),model.fun.y.strsym);
+            end
+        case 'dJydsigma'
+            this.sym = sym(zeros(model.nytrue, model.ng, model.ny));
+            for iyt = 1 : model.nytrue
+                this.sym(iyt,:,:) = jacobian(model.fun.Jy.sym(iyt,:),model.fun.sigma_y.strsym);
+            end
+        case 'Jz'
+            this.sym = model.sym.Jz;
+            this = unifySyms(this,model);
+            z = arrayfun(@(iz)sym(sprintf('z_%i',iz-1)),1:nz,'UniformOutput',false);
+            this.sym = mysubs(this.sym,[z{:}],model.fun.z.strsym);
+            tmp = arrayfun(@(iz)sym(sprintf('sigma_z_%i',iz-1)),1:nz,'UniformOutput',false);
+            this.sym = mysubs(this.sym,[tmp{:}],model.fun.sigma_z.strsym);
+        case 'Jrz'
+            this.sym = model.sym.Jrz;
+            this = unifySyms(this,model);
+            tmp = arrayfun(@(iz)sym(sprintf('rz_%i',iz-1)),1:nz,'UniformOutput',false);
+            this.sym = mysubs(this.sym,[tmp{:}],model.fun.z.strsym);
+            tmp = arrayfun(@(iz)sym(sprintf('sigma_z_%i',iz-1)),1:nz,'UniformOutput',false);
+            this.sym = mysubs(this.sym,[tmp{:}],model.fun.sigma_z.strsym);
+        case 'dJzdz'
+            this.sym = sym(zeros(model.nztrue, model.ng, model.nz));
+            for iz = 1 : model.nztrue
+                this.sym(iz,:,:) = jacobian(model.fun.Jz.sym(iz,:),model.fun.z.strsym);
+            end
+            this = makeStrSyms(this);
+        case 'dJrzdz'
+            this.sym = sym(zeros(model.nztrue, model.ng, model.nz));
+            for iz = 1 : model.nztrue
+                this.sym(iz,:,:) = jacobian(model.fun.Jrz.sym(iz,:),model.fun.rz.strsym);
+            end
+            this = makeStrSyms(this);
+        case 'dJzdsigma'
+            this.sym = sym(zeros(model.nztrue, model.ng, model.nz));
+            for iz = 1 : model.nztrue
+                this.sym(iz,:,:) = jacobian(model.fun.Jz.sym(iz,:),model.fun.sigma_z.strsym);
+            end
+        case 'dJrzdsigma'
+            this.sym = sym(zeros(model.nztrue, model.ng, model.nz));
+            for iz = 1 : model.nztrue
+                this.sym(iz,:,:) = jacobian(model.fun.Jrz.sym(iz,:),model.fun.sigma_z.strsym);
+            end
+            
+        otherwise
+            error('unknown function name')
+    end
+end
+
+function this = unifySyms(this,model)
+    % unifySyms replaces model specific variable names with general
+    % ones which conforms with C naming schemes
+    %
+    % Parameters:
+    %  model: model definition object @type amimodel
+    this.sym = mysubs(this.sym,model.sym.x,model.fun.x.sym);
+    this.sym = mysubs(this.sym,model.sym.p,model.fun.p.sym);
+    this.sym = mysubs(this.sym,model.sym.k,model.fun.k.sym);
+end
+
+function this = makeStrSymsSparse(this)
+    this.strsym = sym(zeros(size(this.sym)));
+    idx = find(this.sym);
+    for isym = 1:length(idx)
+        this.strsym(idx(isym)) = sym(sprintf([this.cvar '_%i'], isym-1));
+    end
+end
+
+function this = makeStrSyms(this)
+    this.strsym = sym(zeros(size(this.sym)));
+    idx = find(this.sym);
+    idx = transpose(idx(:));
+    for isym = idx
+        this.strsym(isym) = sym(sprintf([this.cvar '_%i'], isym-1));
+    end
+end
+
+function this = makeStrSymsFull(this)
+    this.strsym = sym(zeros(size(this.sym)));
+    for isym = 1:numel(this.strsym)
+        this.strsym(isym) = sym(sprintf([this.cvar '_%i'], isym-1));
+    end
+end
+
+function out = mysubs(in, old, new)
+    % mysubs is a wrapper for ther subs matlab function
+    %
+    % Parameters:
+    %  in: symbolic expression in which to replace @type symbolic
+    %  old: expression to be replaced @type symbolic
+    %  new: replacement expression @type symbolic
+    %
+    % Return values:
+    %  out: symbolic expression with replacement @type symbolic
+    if(~isnumeric(in) && ~isempty(old) && ~isempty(symvar(in)))
+        matVer = ver('MATLAB');
+        if(str2double(matVer.Version)>=8.1)
+            out = subs(in, old(:), new(:));
+        else
+            out = subs(in, old(:), new(:), 0);
+        end
+    else
+        out = in;
+    end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeCcode.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeCcode.m
new file mode 100644
index 0000000000000000000000000000000000000000..1b36ed48c04ad29f1153be2f8329a020b242fdec
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeCcode.m
@@ -0,0 +1,101 @@
+function writeCcode(this,model,fid)
+% writeCcode is a wrapper for gccode which initialises data and reduces
+% overhead by check nonzero values
+%
+% Parameters:
+%  model: model defintion object @type amimodel
+%  fid: file id in which the final expression is written @type fileid
+%
+% Return values:
+%  void
+
+nonzero_idx = find(this.sym);
+nonzero = zeros(size(this.sym));
+nonzero(nonzero_idx) = 1;
+
+nevent = model.nevent;
+if(strcmp(this.funstr,'JSparse'))
+    tmpfun = this;
+    tmpfun.sym = model.fun.J.sym(model.sparseidx);
+    tmpfun.gccode(model,fid);
+elseif(strcmp(this.funstr,'JSparseB'))
+    tmpfun = this;
+    tmpfun.sym = model.fun.JB.sym(model.sparseidxB);
+    tmpfun.gccode(model,fid);
+elseif(ismember(this.funstr,{'rz','z','sz','srz'}))
+    if(any(nonzero))
+        fprintf(fid,'    switch(ie) { \n');
+        for ievent=1:nevent
+            tmpfun = this;
+            % set all z that do not belong to this event to zero
+            % dont shorten the vector as we need the indices
+            fprintf(fid,['        case ' num2str(ievent-1) ': {\n']);
+            tmpfun.sym(model.z2event~=ievent) = 0;
+            tmpfun.gccode(model,fid);
+            fprintf(fid,'\n');
+            fprintf(fid,'        } break;\n\n');
+        end
+        fprintf(fid,'    } \n');
+    end
+elseif(strcmp(this.funstr,'stau') )
+    if(any(nonzero))
+        fprintf(fid,'    switch(ie) { \n');
+        for ievent=1:nevent
+            tmpfun = this;
+            % set all z that do not belong to this event to zero
+            % dont shorten the vector as we need the indices
+            fprintf(fid,['        case ' num2str(ievent-1) ': {\n']);
+            tmpfun.sym = tmpfun.sym(ievent);
+            tmpfun.gccode(model,fid);
+            fprintf(fid,'\n');
+            fprintf(fid,'        } break;\n\n');
+        end
+        fprintf(fid,'    } \n');
+    end
+elseif(strcmp(this.funstr,'deltax') || strcmp(this.funstr,'deltasx') || strcmp(this.funstr,'deltaxB') || strcmp(this.funstr,'deltaqB'))
+    if(any(any(nonzero)))
+        fprintf(fid,'              switch(ie) { \n');
+        tmpfun = this;
+        for ievent=1:nevent
+            if(any(nonzero(:,ievent)))
+                fprintf(fid,['              case ' num2str(ievent-1) ': {\n']);
+                tmpfun.sym = this.sym(:,ievent);
+                tmpfun.gccode(model,fid);
+                fprintf(fid,'\n');
+                fprintf(fid,'              } break;\n\n');
+            end
+        end
+        fprintf(fid,'              } \n');
+    end
+elseif(any(strcmp(this.funstr,{'Jy','dJydsigma','dJydy'})))
+    tmpfun = this;
+    if(any(any(any(nonzero))))
+        fprintf(fid,['switch(iy){\n']);
+        for iy = 1:model.nytrue
+            fprintf(fid,['    case ' num2str(iy-1) ':\n']);
+            tmpfun.sym = permute(this.sym(iy,:,:),[2,3,1]);
+            tmpfun.gccode(model,fid);
+            fprintf(fid,'    break;\n');
+        end
+        fprintf(fid,['}\n']);
+    end
+elseif(any(strcmp(this.funstr,{'Jz','dJzdsigma','dJzdz','Jrz','dJrzdsigma','dJrzdz'})))
+    tmpfun = this;
+    if(any(any(any(nonzero))))
+        fprintf(fid,['switch(iz){\n']);
+        for iz = 1:model.nztrue
+            fprintf(fid,['    case ' num2str(iz-1) ':\n']);
+            tmpfun.sym = permute(this.sym(iz,:,:),[2,3,1]);
+            tmpfun.gccode(model,fid);
+            fprintf(fid,'    break;\n');
+        end
+        fprintf(fid,['}\n']);
+    end
+else
+    if(any(any(any(nonzero))))
+        this.gccode(model,fid);
+    end
+end
+
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeCcode_sensi.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeCcode_sensi.m
new file mode 100644
index 0000000000000000000000000000000000000000..b9238d3fc5370e7e7aa06ff442ede0f1304f201c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeCcode_sensi.m
@@ -0,0 +1,91 @@
+function writeCcode_sensi(this,model,fid)
+% writeCcode_sensi is a wrapper for writeCcode which loops over parameters and reduces
+% overhead by check nonzero values
+%
+% Parameters:
+%  model: model defintion object @type amimodel
+%  fid: file id in which the final expression is written @type fileid
+% 
+% Return values:
+%  void
+      
+np = model.np;
+ng = model.ng;
+
+nonzero_idx = find(this.sym);
+nonzero = zeros(size(this.sym));
+nonzero(nonzero_idx) = 1;
+
+if(strcmp(this.funstr,'deltaqB'))
+    if(any(nonzero))
+        tmpfun = this;
+        for ip=1:np*ng
+            if(nonzero(ip))
+                fprintf(fid,['  case ' num2str(ip-1) ': {\n']);
+                tmpfun.sym = this.sym(ip,:);
+                tmpfun.writeCcode(model,fid);
+                fprintf(fid,'\n');
+                fprintf(fid,'  } break;\n\n');
+            end
+        end
+    end
+elseif(strcmp(this.funstr,'deltasx'))
+    if(any(any(any(nonzero))))
+        tmpfun = this;
+        for ip=1:np
+            if(any(any(any(nonzero(:,ip,:)))))
+                fprintf(fid,['  case ' num2str(ip-1) ': {\n']);
+                tmpfun.sym = permute(this.sym(:,ip,:),[1,3,2]);
+                tmpfun.writeCcode(model,fid);
+                fprintf(fid,'\n');
+                fprintf(fid,'  } break;\n\n');
+            end
+        end
+    end
+elseif(strcmp(this.funstr,'s2root'))
+    if(any(any(any(nonzero))))
+        tmpfun = this;
+        for ip=1:np
+            if(any(any(any(nonzero(:,ip,:)))))
+                fprintf(fid,['  case ' num2str(ip-1) ': {\n']);
+                tmpfun.sym = squeeze(this.sym(model.z2event(1:model.nztrue),ip,:));
+                tmpfun.writeCcode(model,fid);
+                fprintf(fid,'\n');
+                fprintf(fid,'  } break;\n\n');
+            end
+        end
+    end
+elseif(strcmp(this.funstr,'qBdot'))
+    nonzero = this.sym ~=0;
+    if(any(any(nonzero)))
+        tmpfun = this;
+        for ip=1:np
+            if(any(nonzero(:,ip)))
+                fprintf(fid,['  case ' num2str(ip-1) ': {\n']);
+                tmpfun.sym = this.sym(:,ip);
+                tmpfun.writeCcode(model,fid);
+                fprintf(fid,'\n');
+                fprintf(fid,'  } break;\n\n');
+            end
+        end
+    end
+else 
+    nonzero = this.sym ~=0;
+    if(any(any(nonzero)))
+        tmpfun = this;
+        for ip=1:np
+            if(any(nonzero(:,ip)))
+                fprintf(fid,['  case ' num2str(ip-1) ': {\n']);
+                if(strcmp(this.funstr,'sroot'))
+                    tmpfun.sym = this.sym(model.z2event,ip);
+                else
+                    tmpfun.sym = this.sym(:,ip);
+                end
+                tmpfun.writeCcode(model,fid);
+                fprintf(fid,'\n');
+                fprintf(fid,'  } break;\n\n');
+            end
+        end
+    end
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeMcode.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeMcode.m
new file mode 100644
index 0000000000000000000000000000000000000000..d78af5e628835e4f241c916911aed408b35fd07c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amifun/writeMcode.m
@@ -0,0 +1,27 @@
+function writeMcode(this,model)
+% writeMcode generates matlab evaluable code for specific model functions
+%
+% Parameters:
+%  model: model defintion object @type amimodel
+%
+% Return values:
+%  void
+
+
+% replace heaviside placeholder vars
+if(~isempty(model.event))
+    h_vars = [sym('h_0');sym('h_',[length(model.event)-1,1])];
+    h_rep= sym(zeros(size(h_vars)));
+    if(~isfield(model.fun,'root'))
+        model.getFun([],'root');
+    end
+    for ievent = 1:length(model.event)
+        h_rep(ievent) = heaviside(model.fun.root.sym(ievent));
+    end
+    this.sym_noopt = subs(this.sym_noopt,h_vars,h_rep);
+end
+    
+ami_mfun(this.sym_noopt, 'file', fullfile(model.wrap_path,'models',...
+    model.modelname,[ this.funstr '_',model.modelname,'.m']), ...
+    'vars', {'t',model.fun.x.sym,model.fun.p.sym,model.fun.k.sym},'varnames',{'t','x','p','k'});
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/amimodel.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/amimodel.m
new file mode 100644
index 0000000000000000000000000000000000000000..1b77aac6bf5920444eef6be4cee16183a36f497c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/amimodel.m
@@ -0,0 +1,271 @@
+%
+% @file amimodel
+% @brief definition of amimodel class
+%
+classdef amimodel < handle
+    % AMIMODEL carries all model definitions including functions and events
+    
+    properties ( GetAccess = 'public', SetAccess = 'private' )
+        % symbolic definition struct @type struct
+        sym = struct.empty();
+        % struct which stores information for which functions c code needs to be generated @type struct
+        fun = struct.empty();
+        % struct which stores information for which functions c code needs
+        % to be generated @type amievent
+        event = amievent.empty();
+        % name of the model @type string
+        modelname = char.empty();
+        % struct that contains hash values for the symbolic model definitions @type struct
+        HTable = struct.empty();
+        % flag indicating whether debugging symbols should be compiled @type bool
+        debug = false;
+        % flag indicating whether adjoint sensitivities should be enabled @type bool
+        adjoint = true;
+        % flag indicating whether forward sensitivities should be enabled @type bool
+        forward = true;
+        % default initial time @type double
+        t0 = 0;
+        % type of wrapper (cvodes/idas) @type string
+        wtype = char.empty();
+        % number of states @type int
+        nx = double.empty();
+        % number of original states for second order sensitivities @type int
+        nxtrue = double.empty();
+        % number of observables @type int
+        ny = double.empty();
+        % number of original observables for second order sensitivities @type int
+        nytrue = double.empty();
+        % number of parameters @type int
+        np = double.empty();
+        % number of constants @type int
+        nk = double.empty();
+        % number of objective functions @type int
+        ng = double.empty();
+        % number of events @type int
+        nevent = double.empty();
+        % number of event outputs @type int
+        nz = double.empty();
+        % number of original event outputs for second order sensitivities @type int
+        nztrue = double.empty();
+        % flag for DAEs @type *int
+        id = double.empty();
+        % upper Jacobian bandwidth @type int
+        ubw = double.empty();
+        % lower Jacobian bandwidth @type int
+        lbw = double.empty();
+        % number of nonzero entries in Jacobian @type int
+        nnz = double.empty();
+        % dataindexes of sparse Jacobian @type *int
+        sparseidx = double.empty();
+        % rowindexes of sparse Jacobian @type *int
+        rowvals = double.empty();
+        % columnindexes of sparse Jacobian @type *int
+        colptrs = double.empty();
+        % dataindexes of sparse Jacobian @type *int
+        sparseidxB = double.empty();
+        % rowindexes of sparse Jacobian @type *int
+        rowvalsB = double.empty();
+        % columnindexes of sparse Jacobian @type *int
+        colptrsB = double.empty();
+        % cell array of functions to be compiled @type *cell
+        funs = cell.empty();
+        % cell array of matlab functions to be compiled @type *cell
+        mfuns = cell.empty();
+        % optimisation flag for compilation @type string
+        coptim = '-O3';
+        % default parametrisation @type string
+        param = 'lin';
+        % path to wrapper
+        wrap_path = char.empty();
+        % flag to enforce recompilation of the model
+        recompile = false;
+        % storage for flags determining recompilation of individual
+        % functions
+        cfun = struct.empty();
+        % flag which identifies augmented models 
+        %  0 indicates no augmentation
+        %  1 indicates augmentation by first order sensitivities (yields
+        %  second order sensitivities)
+        %  2 indicates augmentation by one linear combination of first
+        %  order sensitivities (yields hessian-vector product)
+        o2flag = 0;
+    end
+    
+    properties ( GetAccess = 'public', SetAccess = 'public' )
+        % vector that maps outputs to events
+        z2event = double.empty();
+        % flag indicating whether the model contains spline functions
+        splineflag = false;
+        % flag indicating whether the model contains min functions
+        minflag = false;
+        % flag indicating whether the model contains max functions
+        maxflag = false;
+        % number of derived variables w, w is used for code optimization to reduce the number of frequently occuring
+        % expressions @type int
+        nw = 0;
+        % number of derivatives of derived variables w, dwdx @type int
+        ndwdx = 0;
+        % number of derivatives of derived variables w, dwdp @type int
+        ndwdp = 0;
+    end
+    
+    methods
+        function AM = amimodel(symfun,modelname)
+            % amimodel initializes the model object based on the provided
+            % symfun and modelname
+            %
+            % Parameters:
+            %  symfun: this is the string to the function which generates
+            %  the modelstruct. You can also directly pass the struct here @type string
+            %  modelname: name of the model @type string
+            %
+            % Return values:
+            %  AM: model definition object
+            if(isa(symfun,'amimodel'))
+                AM = symfun;
+            else
+                if(isa(symfun,'char'))
+                    if(exist(symfun,'file')==2)
+                        fun = str2func(symfun);
+                        model = fun();
+                    else
+                        error(['"' symfun '" must be the name of a matlab function in a matlab file, with the corresponding name, in the matlab path. Please check whether the folder containing "' symfun '" is in the matlab path. AMICI currently does not support absolute or relative paths in its input arguments.'])
+                    end
+                elseif(isa(symfun,'struct'))
+                    model = symfun;
+                elseif(isa(symfun,'function_handle'))
+                    model = symfun();
+                else
+                    error('invalid input symfun')
+                end
+                
+                if(isfield(model,'sym'))
+                    AM.sym = model.sym;
+                else
+                    error('symbolic definitions missing in struct returned by symfun')
+                end
+                
+                
+                
+                props = fields(model);
+                
+                for j = 1:length(props)
+                    if(~strcmp(props{j},'sym')) % we already checked for the sym field
+                        if(isfield(model,props{j}))
+                            try
+                                AM.(props{j}) = model.(props{j});
+                            catch
+                                error(['The provided model struct or the struct created by the provided model function has the field ' props{j} ' which is not a valid property of ' ...
+                                    'the amimodel class. Please check your model definition.']);
+                            end
+                        end
+                    else
+                        AM.makeSyms();
+                        AM.nx = length(AM.sym.x);
+                        if(isempty(AM.nxtrue)) % if its not empty we are dealing with an augmented model
+                            AM.nxtrue = AM.nx;
+                        end
+                        AM.ng = size(AM.sym.Jy,2);
+                        AM.np = length(AM.sym.p);
+                        AM.nk = length(AM.sym.k);
+                        AM.ny = length(AM.sym.y);
+                        if(isempty(AM.nytrue)) % if its not empty we are dealing with an augmented model
+                            AM.nytrue = AM.ny;
+                        end
+                    end
+                end
+                
+                AM.modelname = modelname;
+                % set path and create folder
+                AM.wrap_path=fileparts(fileparts(fileparts(mfilename('fullpath'))));
+                if(~exist(fullfile(AM.wrap_path,'models'),'dir'))
+                    mkdir(fullfile(AM.wrap_path,'models'));
+                    mkdir(fullfile(AM.wrap_path,'models',AM.modelname));
+                else
+                    if(~exist(fullfile(AM.wrap_path,'models',AM.modelname),'dir'))
+                        mkdir(fullfile(AM.wrap_path,'models',AM.modelname))
+                    end
+                end
+                AM.makeEvents();
+                AM.nz = length([AM.event.z]);
+                if(isempty(AM.nztrue))
+                    AM.nztrue = AM.nz;
+                end
+                AM.nevent = length(AM.event);
+                
+                % check whether we have a DAE or ODE
+                if(isfield(AM.sym,'M'))
+                    AM.wtype = 'iw'; % DAE
+                else
+                    AM.wtype = 'cw'; % ODE
+                end
+            end
+        end
+        
+        function updateRHS(this,xdot)
+            % updateRHS updates the private fun property .fun.xdot.sym
+            % (right hand side of the differential equation)
+            %
+            % Parameters:
+            %  xdot: new right hand side of the differential equation
+            %
+            % Return values:
+            %  void
+            this.fun.xdot.sym_noopt = this.fun.xdot.sym;
+            this.fun.xdot.sym = xdot;
+        end
+        
+        function updateModelName(this,modelname)
+            % updateModelName updates the modelname
+            %
+            % Parameters:
+            %  modelname: new modelname
+            %
+            % Return values:
+            %  void
+            this.modelname = modelname;
+        end
+        
+        function updateWrapPath(this,wrap_path)
+            % updateModelName updates the modelname
+            %
+            % Parameters:
+            %  wrap_path: new wrap_path
+            %
+            % Return values:
+            %  void
+            this.wrap_path = wrap_path;
+        end
+        
+        parseModel(this)
+        
+        generateC(this)
+        
+        compileC(this)
+        
+        generateM(this,amimodelo2)
+        
+        getFun(this,HTable,funstr)
+        
+        makeEvents(this)
+        
+        makeSyms(this)
+        
+        cflag = checkDeps(this,HTable,deps)
+        
+        HTable = loadOldHashes(this)
+        
+        modelo2 = augmento2(this)
+        
+        modelo2vec = augmento2vec(this)
+        
+    end
+    
+    methods(Static)
+        compileAndLinkModel(modelname, modelSourceFolder, coptim, debug, funs, cfun)
+        
+        generateMatlabWrapper(nx, ny, np, nk, nz, o2flag, amimodelo2, wrapperFilename, modelname, pscale, forward, adjoint)
+    end
+
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/augmento2.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/augmento2.m
new file mode 100644
index 0000000000000000000000000000000000000000..baf51b70fe65f0aa13d5bb0718f2f961d6524b13
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/augmento2.m
@@ -0,0 +1,160 @@
+function [modelo2] = augmento2(this)
+    % augmento2 augments the system equation to also include equations for
+    % sensitivity equation. This will enable us to compute second order
+    % sensitivities in a forward-adjoint or forward-forward apporach later on.
+    %
+    % Parameters:
+    %
+    % Return values:
+    %  this: augmented system which contains symbolic definition of the
+    %  original system and its sensitivities @type amimodel
+    
+    syms Sx Sdot Sy S0
+   
+    augmodel.nxtrue = length(this.sym.x); % number of states
+    augmodel.nytrue = length(this.sym.y); % number of observables
+    if(this.nevent>0)
+        augmodel.nztrue = length([this.event.z]); % number of observables
+    else
+        augmodel.nztrue = 0;
+    end
+    np = this.np;
+    
+    % augment states
+    Sx = sym(zeros(length(this.sym.x),np));
+    for j = 1:length(this.sym.x)
+        for k = 1:np
+            eval(['syms S' num2str(j) '_' num2str(k)]);
+            eval(['Sx(j,k) = S' num2str(j) '_' num2str(k) ';']);
+        end
+    end
+    Sdot = jacobian(this.sym.xdot,this.sym.x)*Sx+jacobian(this.sym.xdot,this.sym.p);
+    
+    % augment output
+    Sy = jacobian(this.sym.y,this.sym.x)*Sx+jacobian(this.sym.y,this.sym.p);
+   
+    % generate deltasx
+    this.getFun([],'deltasx');
+    this.getFun([],'sz');
+    this.getFun([],'srz');
+    for ievent = 1:this.nevent;
+        if(numel(this.event(ievent).z)>0)
+            Sz = this.fun.sz.sym(this.z2event==ievent,:);
+            for ip = 1:np
+                Sz(:,ip) = subs(Sz(:,ip),this.fun.sx.sym(:,ip),Sx(:,ip));
+            end
+            Srz = this.fun.srz.sym(this.z2event==ievent,:);
+            for ip = 1:np
+                Srz(:,ip) = subs(Srz(:,ip),this.fun.sx.sym(:,ip),Sx(:,ip));
+            end
+            znew = [this.event(ievent).z,reshape(Sz,[sum(this.z2event==ievent),np])];
+        else
+            znew = this.event(ievent).z;
+        end
+        tmp=subs(this.fun.deltasx.sym(:,:,ievent),this.fun.xdot.strsym_old,this.fun.xdot.sym);
+        tmp=subs(tmp,this.fun.xdot.strsym,subs(this.fun.xdot.sym,this.fun.x.sym,this.fun.x.sym+this.event(ievent).bolus));
+        tmp=subs(tmp,this.fun.stau.strsym,this.fun.stau.sym(ievent,:));
+        for ip = 1:np
+            tmp(:,ip)=subs(tmp(:,ip),this.fun.sx.sym(:,ip), Sx(:,ip));
+        end
+        bolusnew = [this.event(ievent).bolus;tmp(:)];
+        % replace sx by augmented x
+        for ip = 1:np
+            bolusnew(this.nxtrue*ip+(1:this.nxtrue)) = mysubs(bolusnew(this.nxtrue*ip+(1:this.nxtrue)), this.fun.sx.sym(:,ip),Sx(:,ip));
+        end
+        augmodel.event(ievent) = amievent(this.event(ievent).trigger,bolusnew,znew);
+    end
+    
+    % augment likelihood
+    this.getFun([],'dsigma_ydp');
+    this.getFun([],'y');
+    this.getFun([],'dydp');
+    this.getFun([],'Jy');
+    tmp = arrayfun(@(x) sym(['var_y_' num2str(x)]),0:(augmodel.nytrue*(1+np)-1),'UniformOutput',false);
+    tmp = transpose([tmp{:}]);
+    aug_y_strsym =  reshape(tmp((augmodel.nytrue+1):end),[augmodel.nytrue,np]);% the update Jy must not contain any
+    % references to x (otherwise we have to deal with sx in sJy), thus
+    % we replace sy with the corresponding augmented y that we are about to
+    % create
+    SJy = jacobian(this.fun.Jy.sym,this.sym.p) ...
+        + jacobian(this.fun.Jy.sym,this.fun.sigma_y.strsym)*this.fun.dsigma_ydp.sym ...
+        + jacobian(this.fun.Jy.sym,this.fun.y.strsym)*aug_y_strsym;
+    
+    this.getFun([],'dsigma_zdp');
+    this.getFun([],'rz');
+    this.getFun([],'Jz');
+    tmp = arrayfun(@(x) sym(['var_z_' num2str(x)]),0:(augmodel.nztrue*(1+np)-1),'UniformOutput',false);
+    tmp = transpose([tmp{:}]);
+    aug_z_strsym =  reshape(tmp((augmodel.nztrue+1):end),[augmodel.nztrue,np]);% the update Jz must not contain any
+    % references to x (otherwise we have to deal with sx in sJy), thus
+    % we replace sy with the corresponding augmented y that we are about to
+    % create
+    SJz = jacobian(this.fun.Jz.sym,this.sym.p);
+    if(~isempty(this.fun.sigma_z.strsym))
+        SJz = SJz + jacobian(this.fun.Jz.sym,this.fun.sigma_z.strsym)*this.fun.dsigma_zdp.sym ...
+              + jacobian(this.fun.Jz.sym,this.fun.z.strsym)*aug_z_strsym;   
+    end
+    this.getFun([],'Jrz');
+    tmp = arrayfun(@(x) sym(['var_rz_' num2str(x)]),0:(augmodel.nztrue*(1+np)-1),'UniformOutput',false);
+    tmp = transpose([tmp{:}]);
+    aug_rz_strsym =  reshape(tmp((augmodel.nztrue+1):end),[augmodel.nztrue,np]);% the update Jz must not contain any
+    % references to x (otherwise we have to deal with sx in sJy), thus
+    % we replace sy with the corresponding augmented y that we are about to
+    % create
+    SJrz = jacobian(this.fun.Jrz.sym,this.sym.p);
+    if(~isempty(this.fun.sigma_z.strsym))
+        SJrz = SJrz + jacobian(this.fun.Jrz.sym,this.fun.sigma_z.strsym)*this.fun.dsigma_zdp.sym ...
+              + jacobian(this.fun.Jrz.sym,this.fun.rz.strsym)*aug_rz_strsym;   
+    end
+    
+    % augment sigmas
+    this.getFun([],'sigma_y');
+    this.getFun([],'sigma_z');
+    S0 = jacobian(this.sym.x0,this.sym.p);
+    
+    augmodel.sym.x = [this.sym.x;Sx(:)];
+    augmodel.sym.xdot = [this.sym.xdot;Sdot(:)];
+    augmodel.sym.f = augmodel.sym.xdot;
+    augmodel.sym.y = [this.sym.y;Sy(:)];
+    augmodel.sym.x0 = [this.sym.x0;S0(:)];
+    augmodel.sym.Jy = [this.sym.Jy,SJy];
+    augmodel.sym.Jz = [this.sym.Jz,SJz];
+    augmodel.sym.Jrz = [this.sym.Jrz,SJrz];
+    if(numel([this.event.z]))
+        augmodel.sym.rz = [this.fun.rz.sym,Srz];
+    end
+    augmodel.sym.p = this.sym.p;
+    augmodel.sym.k = this.sym.k;
+    augmodel.sym.sigma_y = [transpose(this.sym.sigma_y(:)), reshape(transpose(this.fun.dsigma_ydp.sym), [1,numel(this.fun.dsigma_ydp.sym)])];
+    augmodel.sym.sigma_z = [transpose(this.sym.sigma_z(:)), reshape(transpose(this.fun.dsigma_zdp.sym), [1,numel(this.fun.dsigma_zdp.sym)])];
+    
+    modelo2 = amimodel(augmodel,[this.modelname '_o2']);
+    modelo2.o2flag = 1;
+    modelo2.debug = this.debug;
+    modelo2.forward = this.forward;
+    modelo2.adjoint = this.adjoint;
+    modelo2.param = this.param;
+end
+
+
+function out = mysubs(in, old, new)
+    % mysubs is a wrapper for ther subs matlab function
+    %
+    % Parameters:
+    %  in: symbolic expression in which to replace @type symbolic
+    %  old: expression to be replaced @type symbolic
+    %  new: replacement expression @type symbolic
+    %
+    % Return values:
+    %  out: symbolic expression with replacement @type symbolic
+    if(~isnumeric(in) && ~isempty(old) && ~isempty(symvar(in)))
+        matVer = ver('MATLAB');
+        if(str2double(matVer.Version)>=8.1)
+            out = subs(in, old(:), new(:));
+        else
+            out = subs(in, old(:), new(:), 0);
+        end
+    else
+        out = in;
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/augmento2vec.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/augmento2vec.m
new file mode 100644
index 0000000000000000000000000000000000000000..48df87e9c3ef9600cb99ba6938cc14fb73f6ece1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/augmento2vec.m
@@ -0,0 +1,134 @@
+function [modelo2vec] = augmento2vec(this)
+    % augmento2 augments the system equation to also include equations for
+    % sensitivity equation. This will enable us to compute second order
+    % sensitivities in a forward-adjoint or forward-forward apporach later on.
+    %
+    % Parameters:
+    %
+    % Return values:
+    %  modelo2vec: augmented system which contains symbolic definition of the
+    %  original system and its sensitivities @type amimodel
+    
+    syms Sx Sdot Sy S0
+    
+
+   
+    augmodel.nxtrue = length(this.sym.x); % number of states
+    augmodel.nytrue = length(this.sym.y); % number of observables
+    augmodel.nztrue = this.nz;
+    augmodel.coptim = this.coptim;
+    augmodel.debug = this.debug;
+    
+    % multiplication vector (extension of kappa
+    vecs = cell([length(this.sym.p),1]);
+    for ivec = 1:length(this.sym.p)
+        vecs{ivec} = sprintf('k_%i', length(this.sym.k) + ivec-1);
+    end
+    vec = sym(vecs);
+    
+    if(this.nevent>0)
+        augmodel.nztrue = length([this.event.z]); % number of observables
+    else
+        augmodel.nztrue = 0;
+    end
+    np = this.np;
+    
+    % augment states
+    sv = sym('sv',[length(this.sym.x),1]);
+    Sdot = jacobian(this.sym.xdot,this.sym.x)*sv+jacobian(this.sym.xdot,this.sym.p)*vec;
+    
+    % augment output
+    Sy = jacobian(this.sym.y,this.sym.x)*sv+jacobian(this.sym.y,this.sym.p)*vec;
+   
+    % generate deltasx
+    this.getFun([],'deltasx');
+    for ievent = 1:this.nevent;
+        if(numel(this.event(ievent).z)>0)
+            Sz = jacobian(this.event(ievent).z,this.sym.x)*sv+jacobian(this.event(ievent).z,this.sym.p)*vec;
+            znew = [this.event(ievent).z,Sz];
+        else
+            znew = this.event(ievent).z;
+        end
+        tmp=subs(this.fun.deltasx.sym(:,:,ievent),this.fun.xdot.strsym_old,this.fun.xdot.sym);
+        tmp=subs(tmp,this.fun.xdot.strsym,subs(this.fun.xdot.sym,this.fun.x.sym,this.fun.x.sym+this.event(ievent).bolus));
+        tmp=subs(subs(tmp,this.fun.stau.strsym,this.fun.stau.sym(ievent,:)),this.fun.sx.sym*vec,sv);
+        bolusnew = [this.event(ievent).bolus;tmp*vec];
+        % replace sx by augmented x
+        bolusnew(this.nxtrue+(1:this.nxtrue)) = mysubs(bolusnew(this.nxtrue+(1:this.nxtrue)), this.fun.sx.sym(:,1),sv);
+
+        hflagold = this.event(ievent).hflag;
+        augmodel.event(ievent) = amievent(this.event(ievent).trigger,bolusnew,znew);
+        augmodel.event(ievent) = augmodel.event(ievent).setHflag([hflagold;zeros([numel(sv),1])]);
+    end
+    
+    % augment likelihood
+    this.getFun([],'dsigma_ydp');
+    this.getFun([],'y');
+    this.getFun([],'dydp');
+    this.getFun([],'Jy');
+    tmp = arrayfun(@(x) sym(['var_y_' num2str(x)]),0:(augmodel.nytrue*2-1),'UniformOutput',false);
+    aug_y_strsym = transpose([tmp{(augmodel.nytrue+1):end}]); % the update Jy must not contain any
+    % references to x (otherwise we have to deal with sx in sJy), thus
+    % we replace sy with the corresponding augmented y that we are about to
+    % create
+    SJy = (jacobian(this.fun.Jy.sym,this.sym.p) ...
+        + jacobian(this.fun.Jy.sym,this.fun.sigma_y.strsym)*this.fun.dsigma_ydp.sym) ...
+        * vec + jacobian(this.fun.Jy.sym,this.fun.y.strsym)*aug_y_strsym;
+    this.getFun([],'dsigma_zdp');
+    
+    this.getFun([],'dzdp');
+    this.getFun([],'Jz');
+    SJz = jacobian(this.fun.Jz.sym,this.sym.p);
+    if(~isempty(this.fun.sigma_z.strsym))
+        SJz = SJz + jacobian(this.fun.Jz.sym,this.fun.sigma_z.strsym)*this.fun.dsigma_zdp.sym ...
+              + jacobian(this.fun.Jz.sym,this.fun.z.strsym)*Sz;
+    end
+
+    % augment sigmas
+    this.getFun([],'sigma_y');
+    this.getFun([],'sigma_z');
+    
+    S0 = jacobian(this.sym.x0,this.sym.p)*vec;
+    
+    augmodel.sym.x = [this.sym.x;sv];
+    augmodel.sym.xdot = [this.sym.xdot;Sdot];
+    augmodel.sym.f = augmodel.sym.xdot;
+    augmodel.sym.y = [this.sym.y;Sy];
+    augmodel.sym.x0 = [this.sym.x0;S0];
+    augmodel.sym.Jy = [this.sym.Jy,SJy];
+    augmodel.sym.Jz = [this.sym.Jz,SJz*vec];
+    augmodel.sym.k = [this.sym.k;vec];
+    augmodel.sym.p = this.sym.p;
+    augmodel.sym.sigma_y = [this.sym.sigma_y, transpose(this.fun.dsigma_ydp.sym * vec)];
+    augmodel.sym.sigma_z = [this.sym.sigma_z, transpose(this.fun.dsigma_zdp.sym * vec)];
+    
+    modelo2vec = amimodel(augmodel,[this.modelname '_o2vec']);
+    modelo2vec.o2flag = 2;
+    modelo2vec.debug = this.debug;
+    modelo2vec.forward = this.forward;
+    modelo2vec.adjoint = this.adjoint;
+    modelo2vec.param = this.param;
+end
+
+
+function out = mysubs(in, old, new)
+    % mysubs is a wrapper for ther subs matlab function
+    %
+    % Parameters:
+    %  in: symbolic expression in which to replace @type symbolic
+    %  old: expression to be replaced @type symbolic
+    %  new: replacement expression @type symbolic
+    %
+    % Return values:
+    %  out: symbolic expression with replacement @type symbolic
+    if(~isnumeric(in) && ~isempty(old) && ~isempty(symvar(in)))
+        matVer = ver('MATLAB');
+        if(str2double(matVer.Version)>=8.1)
+            out = subs(in, old(:), new(:));
+        else
+            out = subs(in, old(:), new(:), 0);
+        end
+    else
+        out = in;
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/checkDeps.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/checkDeps.m
new file mode 100644
index 0000000000000000000000000000000000000000..caebb514b7d7f22e0fb829f7f0812e26de9ed528
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/checkDeps.m
@@ -0,0 +1,50 @@
+function cflag = checkDeps(this,HTable,deps)
+    % checkDeps checks the dependencies of functions and populates sym
+    % fields if necessary
+    %
+    % Parameters:
+    %  HTable: struct with reference hashes of functions in its fields
+    %  @type struct
+    %  deps: cell array with containing a list of dependencies @type cell
+    %
+    % Return values:
+    %  cflag: boolean indicating whether any of the dependencies have 
+    %  changed with respect to the hashes stored in HTable @type
+    %  bool
+    
+    if(~isempty(HTable))
+        cflags = zeros(length(deps),1);
+        for id = 1:length(deps)
+            if(ismember(deps{id},{'w','dwdx','dwdp'}))
+                cflags(id) = 0;
+            else
+                if(~isfield(this.HTable,deps{id}))
+                    % check subdependencies
+                    fun = amifun(deps{id},this);
+                    fun = fun.getDeps(this);
+                    cflagdep = this.checkDeps(HTable,fun.deps);
+                    cflags(id) = cflagdep;
+                else
+                    if(~isfield(HTable,deps{id})) %newly added field in HTable, need to recompile
+                        cflags(id) = 1;
+                    else
+                        cflags(id) = ~strcmp(this.HTable.(deps{id}),HTable.(deps{id}));
+                    end
+                end
+            end
+        end
+        cflag = any(cflags);
+    else
+        cflag = 1;
+    end
+    if(cflag)
+        % if the function needs to be computed, we need to make sure that
+        % all symbolic definitions are generated. this is forced by passing
+        % an empty HTable to getFun
+        for id = 1:length(deps)
+            if(~isfield(this.fun,deps{id}))
+                this.getFun([],deps{id});
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/compileAndLinkModel.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/compileAndLinkModel.m
new file mode 100644
index 0000000000000000000000000000000000000000..b5c4f233404f61e31ddee5ffe72f184511379505
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/compileAndLinkModel.m
@@ -0,0 +1,345 @@
+function compileAndLinkModel(modelname, modelSourceFolder, coptim, debug, funs, cfun)
+    % compileAndLinkModel compiles the mex simulation file.
+    % It does not check if the model files have changed since generating
+    % C++ code or whether all files are still present.
+    % Use only if you know what you are doing. The safer alternative is
+    % rerunning amiwrap().
+    %
+    % Parameters:
+    %  modelname: name of the model as specified for amiwrap()
+    %  modelSourceFolder: path to model source directory
+    %  coptim: optimization flags
+    %  debug: enable debugging
+    %  funs: array with names of the model functions, will be guessed
+    %   from source files if left empty
+    %  cfun: struct indicating which files should be recompiled
+    %
+    % Return values:
+    %  void
+
+    % if no list provided, try to determine relevant files from model
+    % folder
+    if(isempty(funs))
+        ls = dir(fullfile(modelSourceFolder, [modelname '_*.cpp']));
+        ls = {ls.name};
+        % extract funs from filename (strip of modelname_ and .cpp
+        funs = cellfun(@(x) x((length(modelname)+2):(length(x)-4)), ls, 'UniformOutput', false);
+    end
+
+    objectFileSuffix = '.o';
+    if(ispc)
+        objectFileSuffix = '.obj';
+    end
+
+    % compile flags
+    COPT = ['COPTIMFLAGS=''' coptim ' -DNDEBUG'' CXXFLAGS=''$CXXFLAGS -std=c++0x'''];
+    if(debug)
+        DEBUG = ' -g CXXFLAGS=''$CXXFLAGS -Wall  -std=c++0x -Wno-unused-function -Wno-unused-variable'' ';
+        COPT = ''; % no optimization with debug flags!
+    else
+        DEBUG = '';
+    end
+
+    compilerVersion = getCompilerVersionString();
+    amiciRootPath = fileparts(fileparts(fileparts(mfilename('fullpath'))));
+    baseObjectFolder = fullfile(amiciRootPath,'models',mexext,version('-release'),compilerVersion);
+    baseModelObjectFolder = fullfile(modelSourceFolder,version('-release'),compilerVersion);
+    if(debug)
+        objectFolder = fullfile(baseObjectFolder, 'debug');
+        modelObjectFolder = fullfile(baseModelObjectFolder, 'debug');
+    else
+        objectFolder = fullfile(baseObjectFolder, 'release');
+        modelObjectFolder = fullfile(baseModelObjectFolder, 'release');
+    end
+    % compile directory
+    if(~exist(objectFolder, 'dir'))
+        mkdir(objectFolder);
+    end
+    if(~exist(modelObjectFolder, 'dir'))
+        mkdir(modelObjectFolder);
+    end
+
+    %% Third party libraries
+    dependencyPath = fullfile(amiciRootPath, 'ThirdParty');
+    gslPath = fullfile(dependencyPath, 'gsl');
+    [objectsstr, includesstr] = compileAMICIDependencies(dependencyPath, objectFolder, objectFileSuffix, COPT, DEBUG);
+    includesstr = strcat(includesstr,' -I"', modelSourceFolder, '"', ' -I"', gslPath, '"');
+
+    %% Recompile AMICI base files if necessary
+    [objectStrAmici] = compileAmiciBase(amiciRootPath, objectFolder, objectFileSuffix, includesstr, DEBUG, COPT);
+    objectsstr = [objectsstr, objectStrAmici];
+
+    %% Model-specific files
+    for j=1:length(funs)
+        baseFileName = [modelname '_' strrep(funs{j}, 'sigma_', 'sigma')];
+        cfun(1).(funs{j}) = sourceNeedsRecompilation(modelSourceFolder, modelObjectFolder, baseFileName, objectFileSuffix);
+    end
+
+    funsForRecompile = {};
+
+    % flag dependencies for recompilation
+    if(~isempty(cfun))
+        if(isfield('J',cfun(1)))
+            if(cfun(1).J)
+                if(ismember('JBand',funs))
+                    cfun(1).JBand = 1;
+                end
+            end
+        end
+
+        if(isfield('JB',cfun(1)))
+            if(cfun(1).JB)
+                if(ismember('JBandB',funs))
+                    cfun(1).JBandB = 1;
+                end
+            end
+        end
+
+        if(isfield('JSparse',cfun(1)))
+            if(cfun(1).JSparse)
+                if(ismember('sxdot',funs))
+                    cfun(1).sxdot = 1;
+                end
+            end
+        end
+        if(isfield('dxdotdp',cfun(1)))
+            if(isfield(cfun(1),'dxdotdp'))
+                if(cfun(1).dxdotdp)
+                    if(ismember('sxdot',funs))
+                        cfun(1).sxdot = 1;
+                    end
+                    if(ismember('qBdot',funs))
+                        cfun(1).qBdot = 1;
+                    end
+                end
+            end
+        end
+        funsForRecompile = funs(structfun(@(x) logical(x), cfun(1)));
+        funsForRecompile = cellfun(@(x) strrep(x, 'sigma_', 'sigma'), funsForRecompile, 'UniformOutput', false);
+    end
+
+    if(numel(funsForRecompile))
+        fprintf('ffuns | ');
+
+        sources = cellfun(@(x) fullfile(modelSourceFolder,[modelname '_' x '.cpp']),funsForRecompile,'UniformOutput',false);
+        sources = strjoin(sources,' ');
+
+        eval(['mex ' DEBUG COPT ...
+            ' -c -outdir ' modelObjectFolder ' ' ...
+            sources ' ' ...
+            includesstr ]);
+        cellfun(@(x) updateFileHashSource(modelSourceFolder, modelObjectFolder, [modelname '_' x]),funsForRecompile,'UniformOutput',false);
+    end
+
+    % append model object files
+    for j=1:length(funs)
+        filename = fullfile(modelObjectFolder, [modelname '_' strrep(funs{j}, 'sigma_', 'sigma') objectFileSuffix]);
+        if(exist(filename,'file'))
+            objectsstr = strcat(objectsstr,...
+                ' "',filename,'"');
+        end
+    end
+
+    % compile the wrapfunctions object
+    fprintf('wrapfunctions | ');
+    eval(['mex ' DEBUG COPT ...
+        ' -c -outdir ' modelObjectFolder ' ' ...
+        fullfile(modelSourceFolder,'wrapfunctions.cpp') ' ' ...
+        includesstr]);
+    objectsstr = [objectsstr, ' "' fullfile(modelObjectFolder,['wrapfunctions' objectFileSuffix]) '"'];
+
+    % now we have compiled everything model-specific, so we can replace hashes.mat to prevent recompilation
+    try
+        movefile(fullfile(modelSourceFolder,'hashes_new.mat'),...
+        fullfile(modelSourceFolder,'hashes.mat'),'f');
+    end
+
+    %% Linking
+    fprintf('linking | ');
+
+    if(isunix)
+        if(~ismac)
+            CLIBS = 'CLIBS="-lrt -lmwblas -ldl"';
+        else
+            CLIBS = 'CLIBS="-lmwblas"';
+        end
+    else
+        if(strcmp(mex.getCompilerConfigurations('c++').Name,'MinGW64 Compiler (C++)'))
+            CLIBS = 'LD="g++"';
+        else
+            CLIBS = '-lmwblas';
+        end
+    end
+
+    mexFilename = fullfile(modelSourceFolder,['ami_' modelname]);
+    eval(['mex ' DEBUG ' ' COPT ' ' CLIBS ...
+        ' -output ' mexFilename ' ' objectsstr])
+end
+
+function [objectStrAmici] = compileAmiciBase(amiciRootPath, objectFolder, objectFileSuffix, includesstr, DEBUG, COPT)
+    % generate hash for file and append debug string if we have an md5
+    % file, check this hash against the contained hash
+    cppsrc = {'amici', 'symbolic_functions','spline', ...
+        'edata','rdata', 'exception', ...
+        'interface_matlab', 'misc', ...
+        'solver', 'solver_cvodes', 'solver_idas', ...
+        'model', 'model_ode', 'model_dae', 'returndata_matlab', ...
+        'forwardproblem', 'steadystateproblem', 'backwardproblem', 'newton_solver', ...
+        'abstract_model', 'sundials_matrix_wrapper', 'sundials_linsol_wrapper', ...
+        'vector'
+    };
+    % to be safe, recompile everything if headers have changed. otherwise
+    % would need to check the full include hierarchy
+    amiciIncludePath = fullfile(amiciRootPath,'include','amici');
+    amiciSourcePath = fullfile(amiciRootPath,'src');
+    recompile = headersHaveChanged(amiciIncludePath,objectFolder);
+    objectArray = cellfun(@(x) [' "', fullfile(objectFolder, x), objectFileSuffix, '"'], cppsrc, 'UniformOutput', false);
+    objectStrAmici = strjoin(objectArray, ' ');
+    sourcesForRecompile = cppsrc(cellfun(@(x) recompile || sourceNeedsRecompilation(amiciSourcePath, objectFolder, x, objectFileSuffix), cppsrc));
+    if(numel(sourcesForRecompile))
+        fprintf('AMICI base files | ');
+        sourceStr = '';
+        for j = 1:numel(sourcesForRecompile)
+            baseFilename = fullfile(amiciSourcePath, sourcesForRecompile{j});
+            sourceStr  = [sourceStr, ' "', baseFilename, '.cpp"'];
+        end
+        eval(['mex ' DEBUG COPT ' -c -outdir ' objectFolder ...
+            includesstr ' ' sourceStr]);
+        cellfun(@(x) updateFileHashSource(amiciSourcePath, objectFolder, x), sourcesForRecompile);
+        updateHeaderFileHashes(amiciIncludePath, objectFolder);
+    end
+
+end
+
+function headersChanged = headersHaveChanged(includePath, objectFolder)
+    list = dir([includePath '/*.h']);
+    headersChanged = false;
+    for file = {list.name}
+        headersChanged = headerFileChanged(includePath, objectFolder, file{:});
+        if(headersChanged)
+            break;
+        end
+    end
+end
+
+function updateHeaderFileHashes(includePath, objectFolder)
+    list = dir([includePath '/*.h']);
+    for file = {list.name}
+        updateFileHash(includePath, objectFolder, file{:});
+    end
+end
+
+
+function hash = getFileHash(file)
+    % getFileHash computed the md5hash of a given file
+    %
+    % Parameters:
+    %  file: path of the file @type string
+    %
+    % Return values:
+    %  hash: md5 hash of the provided file @type string
+    hash = CalcMD5(file,'File','hex');
+end
+
+function updateFileHashSource(sourceFolder,objectFolder,baseFilename)
+    fileName = [baseFilename '.cpp'];
+    if(exist(fullfile(sourceFolder,fileName), 'file'))
+        updateFileHash(sourceFolder,objectFolder,fileName);
+    end
+end
+
+
+function updateFileHash(fileFolder,hashFolder,filename)
+    hash = getFileHash(fullfile(fileFolder,filename));
+    fid = fopen(fullfile(hashFolder,[filename '.md5']),'w');
+    fprintf(fid,hash);
+    fclose(fid);
+end
+
+function headerChanged = headerFileChanged(includePath, objectFolder, fileName)
+    % headerFileChanged checks whether fileName.h  has changed since last compilation
+    %
+    % Parameters:
+    %  * includePath: path to directory containing header file @type string
+    %  * objectFolder: path to directory containing compiled md5 file @type string
+    %  * fileName: name of header @type string
+    %
+    % Return values:
+    %  headerChanged: flag indicating whether we need to recompile filestr.cpp
+    hashFileSufffix = ['.md5'];
+    headerFile = fullfile(includePath,fileName);
+    hashFile = fullfile(objectFolder,[fileName hashFileSufffix]);
+    if(~exist(headerFile , 'file') && exist(hashFile, 'file'))
+        % header file has been removed, recompile and remove stray
+        % hash file
+        headerChanged = true;
+        delete(hashFile);
+    elseif(~exist(hashFile, 'file'))
+        % there exists a header file but no corresponding hash file
+        headerChanged = true;
+    else
+        % hash file exist, did hash change?
+        headerChanged = hashHasChanged(headerFile, hashFile);
+    end
+end
+
+function recompile = sourceNeedsRecompilation(amiciSourcePath, objectFolder, fileName, o_suffix)
+    % sourceNeedsRecompilation checks whether fileName.cpp  has already been
+    % compiled as fileName.o and whether the md5 hash of fileName.cpp matches
+    % the one in fileName.md5
+    %
+    % Parameters:
+    %  * amiciSourcePath: path to directory containing source file @type string
+    %  * objectFolder: path to directory containing compiled object and md5 file @type string
+    %  * fileName: name of source @type string
+    %  * o_suffix: OS specific suffix for compiled objects @type string
+    %
+    % Return values:
+    %  recompile: flag indicating whether we need to recompile filestr.cpp
+
+    sourceFile = fullfile(amiciSourcePath,[fileName '.cpp']);
+
+    if(~exist(sourceFile,'file'))
+        % cpp does not exist, we don't need to compile :)
+        recompile = 0;
+    elseif(~exist(fullfile(objectFolder,[fileName o_suffix]),'file'))
+        % object file does not exist, we need to recompile
+        recompile = 1;
+    else
+        hashFile = fullfile(objectFolder,[fileName '.cpp.md5']);
+        if(~exist(hashFile, 'file'))
+            % source file hash does not exist, we need to recompile
+            recompile = 1;
+        else
+            % hash files exists, did they change?
+            recompile = hashHasChanged(sourceFile, hashFile);
+        end
+    end
+end
+
+function hasChanged = hashHasChanged(sourceFilename, hashFilename)
+    % checkHash checks whether the given file matches the saved hash
+    %
+    % Parameters:
+    %  * sourceFilename: the file to hash (has to exist)
+    %  * hashFilename: the file where the hash is saved (has to exist)
+    % Return values:
+    %  * hasChanged: true if file and saved hash do not match
+
+    hash = getFileHash(sourceFilename);
+    fid = fopen(hashFilename);
+    tline = fgetl(fid);
+    fclose(fid);
+    hasChanged = ~strcmp(tline, hash);
+end
+
+function versionstring = getCompilerVersionString()
+    [~,systemreturn] = system([mex.getCompilerConfigurations('c++').Details.CompilerExecutable ' --version']);
+    newlinePos = strfind(systemreturn, sprintf('\n'));
+    str = systemreturn(1:(newlinePos(1)-1));
+    str = regexprep(str,'[\(\)]','');
+    str = regexprep(str,'[\s\.\-]','_');
+    versionstring = genvarname(str); % fix everything else we have missed
+end
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/compileC.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/compileC.m
new file mode 100644
index 0000000000000000000000000000000000000000..4056b77a3b03949061736ebe1421167ccf7d277a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/compileC.m
@@ -0,0 +1,8 @@
+function compileC(this)
+    % compileC compiles the mex simulation file
+    %
+    % Return values:
+	%  void
+	
+    amimodel.compileAndLinkModel(this.modelname, fullfile(this.wrap_path,'models',this.modelname), this.coptim, this.debug, this.funs, this.cfun);
+end        
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateC.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateC.m
new file mode 100644
index 0000000000000000000000000000000000000000..3ef9cf1ce3902b706705701e0879494a4a30cc70
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateC.m
@@ -0,0 +1,301 @@
+function generateC(this)
+% generateC generates the c files which will be used in the compilation.
+%
+% Return values:
+%  void
+
+% different signatures for cvodes / idas
+if(strcmp(this.wtype,'iw'))
+    dxvec = 'dx,';
+    rtcj = 'cj,';
+else
+    dxvec = 'NULL,';
+    rtcj = '0.0,';
+end
+
+
+% write fun ccode
+
+for ifun = this.funs
+    cppFunctionName = strrep(ifun{1}, 'sigma_', 'sigma');
+    if(isfield(this.fun,ifun{1}))
+        bodyNotEmpty = any(this.fun.(ifun{1}).sym(:)~=0);
+        if(strcmp(ifun{1},'JSparse'))
+            bodyNotEmpty = any(this.fun.J.sym(:)~=0);
+        end
+        if(strcmp(ifun{1},'JSparseB'))
+            bodyNotEmpty = any(this.fun.JB.sym(:)~=0);
+        end
+
+        if(bodyNotEmpty)
+            fprintf([ifun{1} ' | ']);
+            fid = fopen(fullfile(this.wrap_path,'models',this.modelname,[this.modelname '_' cppFunctionName '.cpp']),'w');
+            fprintf(fid,'\n');
+            fprintf(fid,'#include "amici/symbolic_functions.h"\n');
+            fprintf(fid,'#include "amici/defines.h" //realtype definition\n');
+
+            if(ismember(ifun{1},{'JSparse','JSparseB'}))
+                fprintf(fid,'#include <sunmatrix/sunmatrix_sparse.h> //SUNMatrixContent_Sparse definition\n');
+            end
+
+            fprintf(fid,'typedef amici::realtype realtype;\n');
+            fprintf(fid,'#include <cmath> \n');
+            fprintf(fid,'\n');
+            fprintf(fid,'using namespace amici;\n');
+            fprintf(fid,'\n');
+
+            % function definition
+            fprintf(fid,['void ' cppFunctionName '_' this.modelname '' this.fun.(ifun{1}).argstr ' {\n']);
+            if(strcmp(ifun{1},'JSparse'))
+                for i = 1:length(this.rowvals)
+                    fprintf(fid,['  JSparse->indexvals[' num2str(i-1) '] = ' num2str(this.rowvals(i)) ';\n']);
+                end
+                for i = 1:length(this.colptrs)
+                    fprintf(fid,['  JSparse->indexptrs[' num2str(i-1) '] = ' num2str(this.colptrs(i)) ';\n']);
+                end
+            end
+            if(strcmp(ifun{1},'JSparseB'))
+                for i = 1:length(this.rowvalsB)
+                    fprintf(fid,['  JSparseB->indexvals[' num2str(i-1) '] = ' num2str(this.rowvalsB(i)) ';\n']);
+                end
+                for i = 1:length(this.colptrsB)
+                    fprintf(fid,['  JSparseB->indexptrs[' num2str(i-1) '] = ' num2str(this.colptrsB(i)) ';\n']);
+                end
+            end
+
+            if(strcmp(ifun{1},'JBand'))
+                fprintf(fid,['return(J_' this.modelname removeTypes(this.fun.J.argstr) ');']);
+            elseif(strcmp(ifun{1},'JBandB'))
+                fprintf(fid,['return(JB_' this.modelname removeTypes(this.fun.JB.argstr) ');']);
+            else
+                if( strcmp(ifun{1},'qBdot') )
+                    fprintf(fid,'switch (ip) {\n');
+                    this.fun.(ifun{1}).writeCcode_sensi(this,fid);
+                    fprintf(fid,'}\n');
+                elseif(this.fun.(ifun{1}).sensiflag)
+                    fprintf(fid,'switch (ip) {\n');
+                    this.fun.(ifun{1}).writeCcode_sensi(this,fid);
+                    fprintf(fid,'}\n');
+                else
+                    this.fun.(ifun{1}).writeCcode(this,fid);
+                end
+            end
+            fprintf(fid,'}\n');
+            fprintf(fid,'\n');
+            fclose(fid);
+        end
+    end
+end
+
+fid = fopen(fullfile(this.wrap_path,'models',this.modelname,'wrapfunctions.h'),'w');
+fprintf(fid,'#ifndef _amici_wrapfunctions_h\n');
+fprintf(fid,'#define _amici_wrapfunctions_h\n');
+fprintf(fid,'\n');
+fprintf(fid,['#include "' this.modelname '.h"\n']);
+fprintf(fid,'\n');
+fprintf(fid,'std::unique_ptr<amici::Model> getModel();\n');
+fprintf(fid,'\n');
+fprintf(fid,'#endif /* _amici_wrapfunctions_h */\n');
+fclose(fid);
+
+%
+%----------------------------------------------------------------
+% modelname.h
+% model specific function declarations
+%----------------------------------------------------------------
+%
+matVer = ver('MATLAB');
+fid = fopen(fullfile(this.wrap_path,'models',this.modelname,[this.modelname '.h']),'w');
+fprintf(fid,['#ifndef _amici_' this.modelname '_h\n']);
+fprintf(fid,['#define _amici_' this.modelname '_h\n']);
+fprintf(fid,['/* Generated by amiwrap ' matVer.Release ' ' getCommitHash(fileparts(fileparts(mfilename('fullpath')))) ' */\n']);
+fprintf(fid,'#include <cmath>\n');
+fprintf(fid,'#include <memory>\n');
+fprintf(fid,'#include "amici/defines.h"\n');
+fprintf(fid,'#include <sunmatrix/sunmatrix_sparse.h> //SUNMatrixContent_Sparse definition\n');
+if(~strcmp(this.wtype,'iw'))
+    fprintf(fid,'#include "amici/solver_cvodes.h"\n');
+    fprintf(fid,'#include "amici/model_ode.h"\n');
+else
+    fprintf(fid,'#include "amici/solver_idas.h"\n');
+    fprintf(fid,'#include "amici/model_dae.h"\n');
+end
+fprintf(fid,'\n');
+fprintf(fid,'namespace amici {\nclass Solver;\n}\n');
+fprintf(fid,'\n');
+fprintf(fid,'\n');
+
+for ifun = this.funs
+    if(~isfield(this.fun,ifun{1}))
+
+        this.fun(1).(ifun{1}) = amifun(ifun{1},this); % don't use getfun here
+        % as we do not want symbolics to be generated, we only want to be able
+        % access argstr
+    end
+    if(checkIfFunctionBodyIsNonEmpty(this,ifun{1}))
+        cppFunctionName = strrep(ifun{1}, 'sigma_', 'sigma');
+        fprintf(fid,['extern void ' cppFunctionName '_' this.modelname this.fun.(ifun{1}).argstr ';\n']);
+    end
+end
+
+% Subclass Model
+fprintf(fid,'\n');
+if(strcmp(this.wtype,'iw'))
+    baseclass = 'Model_DAE';
+else
+    baseclass = 'Model_ODE';
+end
+
+fprintf(fid,['class Model_' this.modelname ' : public amici::' baseclass ' {\n']);
+fprintf(fid,'public:\n');
+fprintf(fid,['    Model_' this.modelname '() : amici::' baseclass '(' num2str(this.nx) ',\n']);
+fprintf(fid,['                    ' num2str(this.nxtrue) ',\n']);
+fprintf(fid,['                    ' num2str(this.nx) ',\n']);
+fprintf(fid,['                    ' num2str(this.nxtrue) ',\n']);
+fprintf(fid,['                    ' num2str(this.ny) ',\n']);
+fprintf(fid,['                    ' num2str(this.nytrue) ',\n']);
+fprintf(fid,['                    ' num2str(this.nz) ',\n']);
+fprintf(fid,['                    ' num2str(this.nztrue) ',\n']);
+fprintf(fid,['                    ' num2str(this.nevent) ',\n']);
+fprintf(fid,['                    ' num2str(this.ng) ',\n']);
+fprintf(fid,['                    ' num2str(this.nw) ',\n']);
+fprintf(fid,['                    ' num2str(this.ndwdx) ',\n']);
+fprintf(fid,['                    ' num2str(this.ndwdp) ',\n']);
+fprintf(fid,['                    0,\n']);
+fprintf(fid,['                    {},\n']);
+fprintf(fid,['                    ' num2str(this.nnz) ',\n']);
+fprintf(fid,['                    ' num2str(this.ubw) ',\n']);
+fprintf(fid,['                    ' num2str(this.lbw) ',\n']);
+switch(this.o2flag)
+    case 1
+        fprintf(fid,'                    amici::SecondOrderMode::full,\n');
+    case 2
+        fprintf(fid,'                    amici::SecondOrderMode::directional,\n');
+    otherwise
+        fprintf(fid,'                    amici::SecondOrderMode::none,\n');
+end
+fprintf(fid,['                    std::vector<realtype>(' num2str(this.np) ',1.0),\n']);
+fprintf(fid,['                    std::vector<realtype>(' num2str(this.nk) ',1.0),\n']);
+fprintf(fid,'                    std::vector<int>(),\n');
+initstr = num2str(transpose(double(this.id)), '%d, ');
+fprintf(fid,['                    std::vector<realtype>{' initstr(1:end-1) '},\n']);
+initstr = num2str(transpose(this.z2event), '%d, ');
+fprintf(fid,['                    std::vector<int>{' initstr(1:end-1) '})\n']);
+fprintf(fid,['                    {};\n\n']);
+fprintf(fid,['    virtual amici::Model* clone() const override { return new Model_' this.modelname '(*this); };\n\n']);
+fprintf(fid,['    const  std::string getAmiciCommit() const override { return "' getCommitHash(fileparts(fileparts(mfilename('fullpath')))) '"; };\n\n']);
+
+for ifun = this.funs
+    cppFunctionName = strrep(ifun{1}, 'sigma_', 'sigma');
+    fprintf(fid,['    virtual void f' cppFunctionName this.fun.(ifun{1}).argstr ' override {\n']);
+    if(checkIfFunctionBodyIsNonEmpty(this,ifun{1}))
+        fprintf(fid,['        ' cppFunctionName '_' this.modelname '' removeTypes(this.fun.(ifun{1}).argstr) ';\n']);
+    end
+    fprintf(fid,'    }\n\n');
+end
+fprintf(fid,'};\n\n');
+
+fprintf(fid,['#endif /* _amici_' this.modelname '_h */\n']);
+fclose(fid);
+
+
+fid = fopen(fullfile(this.wrap_path,'models',this.modelname,'wrapfunctions.cpp'),'w');
+fprintf(fid,'#include "amici/model.h"\n');
+fprintf(fid,'#include "wrapfunctions.h"\n\n');
+fprintf(fid,'std::unique_ptr<amici::Model> getModel() {\n');
+fprintf(fid, ['    return std::unique_ptr<amici::Model>(new Model_' this.modelname '());\n']);
+fprintf(fid,'}\n\n');
+fclose(fid);
+
+fprintf('CMakeLists | ');
+generateCMakeFile(this);
+
+fprintf('swig | ');
+generateSwigInterfaceFiles(this)
+
+fprintf('main | ');
+generateMainC(this);
+
+fprintf('\r')
+end
+
+
+function argstr = removeTypes(argstr)
+% removeTypes transforms an argument string from a string with variable
+% types (for function definition) to a string without variable types
+% (for function calling)
+%
+% Parameters:
+%  argstr: function definition argument string @type *char
+%
+% Return values:
+%  argstr: function call argument string @type *char
+
+argstr = strrep(argstr,'realtype','');
+argstr = strrep(argstr,'int','');
+argstr = strrep(argstr,'const','');
+argstr = strrep(argstr,'double','');
+argstr = strrep(argstr,'SUNMatrixContent_Sparse','');
+argstr = strrep(argstr,'*','');
+argstr = strrep(argstr,' ','');
+argstr = strrep(argstr,',',', ');
+
+end
+
+
+function generateCMakeFile(this)
+    sourceStr = '';
+    for j=1:length(this.funs)
+        funcName = this.funs{j};
+        if(checkIfFunctionBodyIsNonEmpty(this,funcName))
+            cppFunctionName = strrep(funcName, 'sigma_', 'sigma');
+            sourceStr = [ sourceStr, sprintf('${MODEL_DIR}/%s_%s.cpp\n', this.modelname, cppFunctionName) ];
+        end
+    end
+
+    t = template();
+    t.add('TPL_MODELNAME', this.modelname);
+    t.add('TPL_SOURCES', sourceStr);
+    t.add('TPL_AMICI_VERSION', '');
+    CMakeFileName = fullfile(this.wrap_path,'models',this.modelname,'CMakeLists.txt');
+    CMakeTemplateFileName = fullfile(fileparts(fileparts(fileparts(mfilename('fullpath')))), 'src' , 'CMakeLists.template.cmake');
+    t.replace(CMakeTemplateFileName, CMakeFileName);
+end
+
+function generateSwigInterfaceFiles(this)
+
+    modelSwigDir = fullfile(this.wrap_path,'models',this.modelname,'swig');
+    amiciSwigDir = fullfile(fileparts(fileparts(fileparts(mfilename('fullpath')))),'swig');
+    if(~exist(modelSwigDir,'dir'))
+        mkdir(modelSwigDir)
+    end
+
+    %interface file
+    t = template();
+    t.add('TPL_MODELNAME', this.modelname);
+    SwigInterfaceFile = fullfile(modelSwigDir,[this.modelname '.i']);
+    SwigInterfaceTemplateFileName = fullfile(amiciSwigDir, 'modelname.template.i');
+    t.replace(SwigInterfaceTemplateFileName, SwigInterfaceFile);
+
+    %CMakeLists.txt
+    if(~exist(fullfile(this.wrap_path,'models',this.modelname,'swig'),'dir'))
+        mkdir(fullfile(this.wrap_path,'models',this.modelname),'swig');
+    end
+    copyfile(fullfile(amiciSwigDir,'CMakeLists_model.cmake'),fullfile(modelSwigDir,'CMakeLists.txt'));
+
+end
+
+
+
+function generateMainC(this)
+    mainFileSource = fullfile(fileparts(fileparts(fileparts(mfilename('fullpath')))), 'src/main.template.cpp');
+    mainFileDestination = fullfile(this.wrap_path,'models',this.modelname,'main.cpp');
+    copyfile(mainFileSource, mainFileDestination);
+end
+
+function nonempty = checkIfFunctionBodyIsNonEmpty(this,ifun)
+    % if we don't have symbolic variables, it might have been generated before and symbolic expressions were simply not
+    % regenerated. any() for empty (no generated) variables is always false.
+    cppFunctionName = strrep(ifun, 'sigma_', 'sigma');
+    nonempty = or(exist(fullfile(this.wrap_path,'models',this.modelname,[this.modelname '_' cppFunctionName '.cpp']),'file'),any(this.fun.(ifun).sym(:)~=0));
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateM.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateM.m
new file mode 100644
index 0000000000000000000000000000000000000000..be85528e80119503505235e0c9396db20ab80120
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateM.m
@@ -0,0 +1,26 @@
+function generateM(this, amimodelo2)
+% generateM generates the matlab wrapper for the compiled C files.
+%
+% Parameters:
+%  amimodelo2: this struct must contain all necessary symbolic
+%  definitions for second order sensivities @type amimodel
+%
+% Return values:
+%  void
+wrapperFilename = fullfile(this.wrap_path,'models',this.modelname,['simulate_',this.modelname,'.m']);
+this.generateMatlabWrapper(this.nx, this.ny, this.np, this.nk, this.nz, ...
+    this.o2flag, amimodelo2, wrapperFilename, this.modelname, this.param, ...
+    this.forward, this.adjoint)
+
+%% Generation of the file which computes the Jacobian
+
+for fun = this.mfuns
+    if(isfield(this.fun,fun{1}))
+        fprintf([fun{1} ' | ']);
+        this.fun.(fun{1}).writeMcode(this);
+    end
+end
+
+
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateMatlabWrapper.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateMatlabWrapper.m
new file mode 100644
index 0000000000000000000000000000000000000000..4ee29db931c1d9e05bc60411944caad95bfe0ef4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/generateMatlabWrapper.m
@@ -0,0 +1,467 @@
+function generateMatlabWrapper(nx, ny, np, nk, nz, o2flag, amimodelo2, wrapperFilename, modelname, ...
+    pscale, forward, adjoint)
+    % generateMatlabWrapper generates the matlab wrapper for the compiled C files.
+    %
+    % Parameters:
+    %  nx: number of states
+    %  ny: number of observables
+    %  np: number of parameters
+    %  nk: number of fixed parameters
+    %  nz: number of events
+    %  o2flag: o2flag
+    %  amimodelo2: this struct must contain all necessary symbolic
+    %  definitions for second order sensivities @type amimodel
+    %  wrapperFilename: output filename
+    %  modelname: name of the model
+    %  pscale: default parameter scaling
+    %  forward: has forward sensitivity equations
+    %  adjoint: has adjoint sensitivity equations
+    %
+    % Return values:
+    %  void
+    amiciRootDir = fileparts(fileparts(fileparts(mfilename('fullpath'))));
+
+    if(~isempty(amimodelo2))
+        nztrue = amimodelo2.nztrue;
+        nxtrue = amimodelo2.nxtrue;
+        nytrue = amimodelo2.nytrue;
+        o2flag = amimodelo2.o2flag;
+    else
+        nztrue = nz;
+        nxtrue = nx;
+        nytrue = ny;
+        o2flag = o2flag;
+    end
+    
+    [commit_hash,branch,url] = getCommitHash(amiciRootDir);
+    if(isempty(commit_hash))
+        commit_hash = '#';
+    end
+    
+    if(o2flag)
+        nxtrue = amimodelo2.nxtrue;
+        nytrue = amimodelo2.nytrue;
+    end
+    
+    
+    %% Generation of the simulation file
+    
+    fid = fopen(wrapperFilename,'w');
+    fprintf(fid,['%% simulate_' modelname '.m is the matlab interface to the cvodes mex\n'...
+        '%%   which simulates the ordinary differential equation and respective\n'...
+        '%%   sensitivities according to user specifications.\n'...
+        '%%   this routine was generated using AMICI commit ' commit_hash ' in branch ' branch ' in repo ' url '.\n'...
+        '%%\n'...
+        '%% USAGE:\n'...
+        '%% ======\n'...
+        '%% [...] = simulate_' modelname '(tout,theta)\n'...
+        '%% [...] = simulate_' modelname '(tout,theta,kappa,data,options)\n'...
+        '%% [status,tout,x,y,sx,sy] = simulate_' modelname '(...)\n'...
+        '%%\n'...
+        '%% INPUTS:\n'...
+        '%% =======\n'...
+        '%% tout ... 1 dimensional vector of timepoints at which a solution to the ODE is desired\n'...
+        '%% theta ... 1 dimensional parameter vector of parameters for which sensitivities are desired.\n'...
+        '%%           this corresponds to the specification in model.sym.p\n'...
+        '%% kappa ... 1 dimensional parameter vector of parameters for which sensitivities are not desired.\n'...
+        '%%           this corresponds to the specification in model.sym.k\n'...
+        '%% data ... struct containing the following fields:\n'...
+        '%%     Y ... 2 dimensional matrix containing data.\n'...
+        '%%           columns must correspond to observables and rows to time-points\n'...
+        '%%     Sigma_Y ... 2 dimensional matrix containing standard deviation of data.\n'...
+        '%%           columns must correspond to observables and rows to time-points\n'...
+        '%%     T ... (optional) 2 dimensional matrix containing events.\n'...
+        '%%           columns must correspond to event-types and rows to possible event-times\n'...
+        '%%     Sigma_T ... (optional) 2 dimensional matrix containing standard deviation of events.\n'...
+        '%%           columns must correspond to event-types and rows to possible event-times\n'...
+        '%% options ... additional options to pass to the cvodes solver. Refer to the cvodes guide for more documentation.\n'...
+        '%%    .atol ... absolute tolerance for the solver. default is specified in the user-provided syms function.\n'...
+        '%%        default value is 1e-16\n'...
+        '%%    .rtol ... relative tolerance for the solver. default is specified in the user-provided syms function.\n'...
+        '%%        default value is 1e-8\n'...
+        '%%    .maxsteps    ... maximal number of integration steps. default is specified in the user-provided syms function.\n'...
+        '%%        default value is 1e4\n'...
+        '%%    .tstart    ... start of integration. for all timepoints before this, values will be set to initial value.\n'...
+        '%%        default value is 0\n'...
+        '%%    .sens_ind ... 1 dimensional vector of indexes for which sensitivities must be computed.\n'...
+        '%%        default value is 1:length(theta).\n'...
+        '%%    .x0 ... user-provided state initialisation. This should be a vector of dimension [#states, 1].\n'...
+        '%%        default is state initialisation based on the model definition.\n'...
+        '%%    .sx0 ... user-provided sensitivity initialisation. this should be a matrix of dimension [#states x #parameters].\n'...
+        '%%        default is sensitivity initialisation based on the derivative of the state initialisation.\n'...
+        '%%    .lmm    ... linear multistep method for forward problem.\n'...
+        '%%        1: Adams-Bashford\n'...
+        '%%        2: BDF (DEFAULT)\n'...
+        '%%    .iter    ... iteration method for linear multistep.\n'...
+        '%%        1: Functional\n'...
+        '%%        2: Newton (DEFAULT)\n'...
+        '%%    .linsol   ... linear solver module.\n'...
+        '%%        direct solvers:\n'...
+        '%%        1: Dense\n'...
+        '%%        2: Band (not implemented)\n'...
+        '%%        3: LAPACK Dense (not implemented)\n'...
+        '%%        4: LAPACK Band  (not implemented)\n'...
+        '%%        5: Diag (not implemented)\n'...
+        '%%        implicit krylov solvers:\n'...
+        '%%        6: SPGMR\n'...
+        '%%        7: SPBCG\n'...
+        '%%        8: SPTFQMR\n'...
+        '%%        sparse solvers:\n'...
+        '%%        9: KLU (DEFAULT)\n'...
+        '%%    .stldet   ... flag for stability limit detection. this should be turned on for stiff problems.\n'...
+        '%%        0: OFF\n'...
+        '%%        1: ON (DEFAULT)\n'...
+        '%%    .sensi   ... sensitivity order.\n'...
+        '%%        0: OFF (DEFAULT)\n'...
+        '%%        1: first\n'...
+        '%%        2: second\n'...
+        '%%    .sensi_meth   ... method for sensitivity analysis.\n'...
+        '%%        0: no sensitivity analysis\n'...
+        '%%        1 or ''forward'': forward sensitivity analysis (DEFAULT)\n'...
+        '%%        2 or ''adjoint'': adjoint sensitivity analysis \n'...
+        '%%        3 or ''ss'': defined but not documented \n'...
+        '%%    .adjoint   ... flag for adjoint sensitivity analysis.\n'...
+        '%%        true: on \n'...
+        '%%        false: off (DEFAULT)\n'...
+        '%%        NO LONGER USED: Replaced by sensi_meth\n'...
+        '%%    .ism   ... only available for sensi_meth == 1. Method for computation of forward sensitivities.\n'...
+        '%%        1: Simultaneous (DEFAULT)\n'...
+        '%%        2: Staggered\n'...
+        '%%        3: Staggered1\n'...
+        '%%    .Nd   ... only available for sensi_meth == 2. Number of Interpolation nodes for forward solution. \n'...
+        '%%        default is 1000. \n'...
+        '%%    .interpType   ... only available for sensi_meth == 2. Interpolation method for forward solution.\n'...
+        '%%        1: Hermite (DEFAULT for problems without discontinuities)\n'...
+        '%%        2: Polynomial (DEFAULT for problems with discontinuities)\n'...
+        '%%    .ordering   ... online state reordering.\n'...
+        '%%        0: AMD reordering (default)\n'...
+        '%%        1: COLAMD reordering\n'...
+        '%%        2: natural reordering\n'...
+        '%%    .newton_maxsteps   ... maximum newton steps\n'...
+        '%%        default value is 40\n'...
+        '%%        a value of 0 will disable the newton solver\n'...
+        '%%    .newton_maxlinsteps   ... maximum linear steps\n'...
+        '%%        default value is 100\n'...
+        '%%    .newton_preeq   ... preequilibration of system via newton solver\n'...
+        '%%        default value is false\n'...
+        '%%    .pscale   ... parameter scaling\n'...
+        '%%        []: (DEFAULT) use value specified in the model (fallback: ''lin'')\n'...
+        '%%        0 or ''lin'': linear\n'...
+        '%%        1 or ''log'': natural log (base e)\n'...
+        '%%        2 or ''log10'': log to the base 10\n'...
+        '%%\n'...
+        '%% Outputs:\n'...
+        '%% ========\n'...
+        '%% sol.status ... flag for status of integration. generally status<0 for failed integration\n'...
+        '%% sol.t ... vector at which the solution was computed\n'...
+        '%% sol.llh ... likelihood value\n'...
+        '%% sol.chi2 ... chi2 value\n'...
+        '%% sol.sllh ... gradient of likelihood\n'...
+        '%% sol.s2llh ... hessian or hessian-vector-product of likelihood\n'...
+        '%% sol.x ... time-resolved state vector\n'...
+        '%% sol.y ... time-resolved output vector\n'...
+        '%% sol.sx ... time-resolved state sensitivity vector\n'...
+        '%% sol.sy ... time-resolved output sensitivity vector\n'...
+        '%% sol.z ... event output\n'...
+        '%% sol.sz ... sensitivity of event output\n'...
+        ]);
+    
+    
+    fprintf(fid,['function varargout = simulate_' modelname '(varargin)\n\n']);
+    fprintf(fid,'%% DO NOT CHANGE ANYTHING IN THIS FILE UNLESS YOU ARE VERY SURE ABOUT WHAT YOU ARE DOING\n');
+    fprintf(fid,'%% MANUAL CHANGES TO THIS FILE CAN RESULT IN WRONG SOLUTIONS AND CRASHING OF MATLAB\n');
+    fprintf(fid,'if(nargin<2)\n');
+    fprintf(fid,'    error(''Not enough input arguments.'');\n');
+    fprintf(fid,'else\n');
+    fprintf(fid,'    tout=varargin{1};\n');
+    fprintf(fid,'    theta=varargin{2};\n');
+    fprintf(fid,'end\n');
+    
+    fprintf(fid,'if(nargin>=3)\n');
+    fprintf(fid,'    kappa=varargin{3};\n');
+    fprintf(fid,'else\n');
+    fprintf(fid,'    kappa=[];\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    if(nk==0)
+        fprintf(fid,'if(nargin==2)\n');
+        fprintf(fid,'    kappa = [];\n');
+        fprintf(fid,'end\n');
+    end
+    
+    fprintf(fid,['if(length(theta)<' num2str(np) ')\n']);
+    fprintf(fid,'    error(''provided parameter vector is too short'');\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    
+    fprintf(fid,'\n');
+    fprintf(fid,'xscale = [];\n');
+    fprintf(fid,'if(nargin>=5)\n');
+    fprintf(fid,'    if(isa(varargin{5},''amioption''))\n');
+    fprintf(fid,'        options_ami = varargin{5};\n');
+    fprintf(fid,'    else\n');
+    fprintf(fid,'        options_ami = amioption(varargin{5});\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'else\n');
+    fprintf(fid,'    options_ami = amioption();\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'if(isempty(options_ami.sens_ind))\n');
+    fprintf(fid,['    options_ami.sens_ind = 1:' num2str(np) ';\n']);
+    fprintf(fid,['end\n']);
+    if(o2flag == 0)
+        fprintf(fid,'if(options_ami.sensi>1)\n');
+        fprintf(fid,'    error(''Second order sensitivities were requested but not computed'');\n');
+        fprintf(fid,'end\n');
+    end
+    fprintf(fid,'\n');
+    
+    
+    fprintf(fid,'if(isempty(options_ami.pscale))\n');
+    fprintf(fid,['    options_ami.pscale = ''' pscale ''' ;\n']);
+    fprintf(fid,'end\n');
+    
+    if(o2flag == 2)
+        fprintf(fid,'if(nargin>=6)\n');
+        fprintf(fid,'    chainRuleFactor = getChainRuleFactors(options_ami.pscale, theta, options_ami.sens_ind);\n');
+        fprintf(fid,'    v = varargin{6};\n');
+        fprintf(fid,'    v = v(:).*chainRuleFactor(:);\n');
+        fprintf(fid,'else\n');
+        fprintf(fid,'    if(options_ami.sensi==2)\n');
+        fprintf(fid,'        error(''6th argument (multiplication vector is missing'');\n');
+        fprintf(fid,'    end\n');
+        fprintf(fid,'end\n');
+    end
+    
+    if(o2flag)
+        fprintf(fid,'if(nargout>1)\n');
+        fprintf(fid,'    if(nargout>6)\n');
+        fprintf(fid,'        options_ami.sensi = 2;\n');
+        fprintf(fid,'        options_ami.sensi_meth = ''forward'';\n');
+        fprintf(fid,'    elseif(nargout>4)\n');
+        fprintf(fid,'        options_ami.sensi = 1;\n');
+        fprintf(fid,'        options_ami.sensi_meth = ''forward'';\n');
+        fprintf(fid,'    else\n');
+        fprintf(fid,'        options_ami.sensi = 0;\n');
+        fprintf(fid,'    end\n');
+        fprintf(fid,'end\n');
+    else
+        fprintf(fid,'if(nargout>1)\n');
+        fprintf(fid,'    if(nargout>4)\n');
+        fprintf(fid,'        options_ami.sensi = 1;\n');
+        fprintf(fid,'        options_ami.sensi_meth = ''forward'';\n');
+        fprintf(fid,'    else\n');
+        fprintf(fid,'        options_ami.sensi = 0;\n');
+        fprintf(fid,'    end\n');
+        fprintf(fid,'end\n');
+    end
+    if(~forward)
+        fprintf(fid,'if(options_ami.sensi>0)\n');
+        fprintf(fid,'    if(options_ami.sensi_meth == 1)\n');
+        fprintf(fid,'        error(''forward sensitivities are disabled as necessary routines were not compiled'');\n');
+        fprintf(fid,'    end\n');
+        fprintf(fid,'end\n');
+    end
+    if(~adjoint)
+        fprintf(fid,'if(options_ami.sensi>0)\n');
+        fprintf(fid,'    if(options_ami.sensi_meth == 2)\n');
+        fprintf(fid,'        error(''adjoint sensitivities are disabled as necessary routines were not compiled'');\n');
+        fprintf(fid,'    end\n');
+        fprintf(fid,'end\n');
+    end
+    fprintf(fid,['nplist = length(options_ami.sens_ind); %% MUST NOT CHANGE THIS VALUE\n']);
+    fprintf(fid,['if(nplist == 0)\n']);
+    fprintf(fid,['    options_ami.sensi = 0;\n']);
+    fprintf(fid,['end\n']);
+    if(o2flag)
+        fprintf(fid,['if(options_ami.sensi > 1)\n']);
+        fprintf(fid,['    nxfull = ' num2str(amimodelo2.nx) ';\n']);
+        fprintf(fid,['else\n']);
+        fprintf(fid,['    nxfull = ' num2str(nxtrue) ';\n']);
+        fprintf(fid,['end\n']);
+    else
+        fprintf(fid,['nxfull = ' num2str(nx) ';\n']);
+    end
+    fprintf(fid,'plist = options_ami.sens_ind-1;\n');
+    fprintf(fid,['if(nargin>=4)\n']);
+    fprintf(fid,['    if(isempty(varargin{4}))\n']);
+    fprintf(fid,['        data=[];\n']);
+    fprintf(fid,['    else\n']);
+    fprintf(fid,['        if(isa(varargin{4},''amidata''))\n']);
+    fprintf(fid,['             data=varargin{4};\n']);
+    fprintf(fid,['        else\n']);
+    fprintf(fid,['            data=amidata(varargin{4});\n']);
+    fprintf(fid,['        end\n']);
+    fprintf(fid,['        if(data.ne>0)\n']);
+    fprintf(fid,['            options_ami.nmaxevent = data.ne;\n']);
+    fprintf(fid,['        else\n']);
+    fprintf(fid,['            data.ne = options_ami.nmaxevent;\n']);
+    fprintf(fid,['        end\n']);
+    fprintf(fid,['        if(isempty(kappa))\n']);
+    fprintf(fid,['            kappa = data.condition;\n']);
+    fprintf(fid,['        end\n']);
+    fprintf(fid,['        if(isempty(tout))\n']);
+    fprintf(fid,['            tout = data.t;\n']);
+    fprintf(fid,['        end\n']);
+    fprintf(fid,['    end\n']);
+    fprintf(fid,['else\n']);
+    fprintf(fid,['    data=[];\n']);
+    fprintf(fid,['end\n']);
+    fprintf(fid,['if(~all(tout==sort(tout)))\n']);
+    fprintf(fid,['    error(''Provided time vector is not monotonically increasing!'');\n']);
+    fprintf(fid,['end\n']);
+    fprintf(fid,['if(max(options_ami.sens_ind)>' num2str(np) ')\n']);
+    fprintf(fid,['    error(''Sensitivity index exceeds parameter dimension!'')\n']);
+    fprintf(fid,['end\n']);
+    fprintf(fid,['if(length(kappa)<' num2str(nk) ')\n']);
+    fprintf(fid,'    error(''provided condition vector is too short'');\n');
+    fprintf(fid,'end\n');
+    
+    if(o2flag == 2)
+        fprintf(fid,'if(nargin>=6)\n');
+        fprintf(fid,'    kappa = [kappa(:);v(:)];\n');
+        fprintf(fid,'end\n');
+    end
+    
+    fprintf(fid,'init = struct();\n');
+    fprintf(fid,'if(~isempty(options_ami.x0))\n');
+    fprintf(fid,'    if(size(options_ami.x0,2)~=1)\n');
+    fprintf(fid,'        error(''x0 field must be a column vector!'');\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'    if(size(options_ami.x0,1)~=nxfull)\n');
+    fprintf(fid,'        error(''Number of rows in x0 field does not agree with number of states!'');\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'    init.x0 = options_ami.x0;\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'if(~isempty(options_ami.sx0))\n');
+    fprintf(fid,'    if(size(options_ami.sx0,2)~=nplist)\n');
+    fprintf(fid,'        error(''Number of columns in sx0 field does not agree with number of model parameters!'');\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'    if(size(options_ami.sx0,1)~=nxfull)\n');
+    fprintf(fid,'        error(''Number of rows in sx0 field does not agree with number of states!'');\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'end\n');
+    
+    
+    if(o2flag)
+        fprintf(fid,'if(options_ami.sensi<2)\n');
+        fprintf(fid,['    sol = ami_' modelname '(tout,theta(1:' num2str(np) '),kappa(1:' num2str(nk) '),options_ami,plist,xscale,init,data);\n']);
+        fprintf(fid,'else\n');
+        switch(o2flag)
+            case 1
+                fprintf(fid,['    sol = ami_' modelname '_o2(tout,theta(1:' num2str(np) '),kappa(1:' num2str(nk) '),options_ami,plist,xscale,init,data);\n']);
+            case 2
+                fprintf(fid,['    sol = ami_' modelname '_o2vec(tout,theta(1:' num2str(np) '),kappa(1:' num2str(amimodelo2.nk) '),options_ami,plist,xscale,init,data);\n']);
+        end
+        fprintf(fid,'end\n');
+    else
+        fprintf(fid,['sol = ami_' modelname '(tout,theta(1:' num2str(np) '),kappa(1:' num2str(nk) '),options_ami,plist,xscale,init,data);\n']);
+    end
+    
+    if(o2flag)
+        fprintf(fid,'if(options_ami.sensi == 2)\n');
+        fprintf(fid, '    if(~(options_ami.sensi_meth==2))\n');
+        
+        fprintf(fid,['        sz = zeros(size(sol.z,1),' num2str(nztrue) ',length(theta(options_ami.sens_ind)));\n']);
+        fprintf(fid,['        ssigmaz = zeros(size(sol.z,1),' num2str(nztrue) ',length(theta(options_ami.sens_ind)));\n']);
+        fprintf(fid,['        srz = zeros(size(sol.z,1),' num2str(nztrue) ',length(theta(options_ami.sens_ind)));\n']);
+        fprintf(fid,['        for iz = 1:' num2str(nztrue) '\n']);
+        fprintf(fid,['            sz(:,iz,:) = sol.sz(:,2*iz-1,:);\n']);
+        fprintf(fid,['            ssigmaz(:,iz,:) = sol.ssigmaz(:,2*iz-1,:);\n']);
+        fprintf(fid,['            srz(:,iz,:) = sol.srz(:,2*iz-1,:);\n']);
+        fprintf(fid,['        end\n']);
+        switch(o2flag)
+            case 1
+                fprintf(fid,['        sol.s2x = reshape(sol.sx(:,' num2str(nxtrue+1) ':end,:),length(tout),' num2str(nxtrue) ',' num2str(np) ',length(options_ami.sens_ind));\n']);
+                fprintf(fid,['        sol.s2y = reshape(sol.sy(:,' num2str(nytrue+1) ':end,:),length(tout),' num2str(nytrue) ',' num2str(np) ',length(options_ami.sens_ind));\n']);
+                fprintf(fid,['        sol.s2sigmay = reshape(sol.ssigmay(:,' num2str(nytrue+1) ':end,:),length(tout),' num2str(nytrue) ',' num2str(np) ',length(options_ami.sens_ind));\n']);
+            case 2
+                fprintf(fid,['        sol.s2x = sol.sx(:,' num2str(nxtrue+1) ':end,:);\n']);
+                fprintf(fid,['        sol.s2y = sol.sy(:,' num2str(nytrue+1) ':end,:);\n']);
+                fprintf(fid,['        sol.s2sigmay = sol.ssigmay(:,' num2str(nytrue+1) ':end,:);\n']);
+        end
+        switch(o2flag)
+            case 1
+                fprintf(fid,['        s2z = zeros(size(sol.z,1),' num2str(nztrue) ',' num2str(np) ',length(options_ami.sens_ind));\n']);
+                fprintf(fid,['        s2sigmaz = zeros(size(sol.z,1),' num2str(nztrue) ',' num2str(np) ',length(options_ami.sens_ind));\n']);
+                fprintf(fid,['        s2rz = zeros(size(sol.z,1),' num2str(nztrue) ',' num2str(np) ',length(options_ami.sens_ind));\n']);
+            case 2
+                fprintf(fid,['        s2z = zeros(size(sol.z,1),' num2str(nztrue) ',length(theta(options_ami.sens_ind)));\n']);
+                fprintf(fid,['        s2sigmaz = zeros(size(sol.z,1),' num2str(nztrue) ',length(theta(options_ami.sens_ind)));\n']);
+                fprintf(fid,['        s2rz = zeros(size(sol.z,1),' num2str(nztrue) ',length(theta(options_ami.sens_ind)));\n']);
+        end
+        fprintf(fid,['        for iz = 1:' num2str(nztrue) '\n']);
+        switch(o2flag)
+            case 1
+                fprintf(fid,['            sol.s2z(:,iz,:,:) = reshape(sol.sz(:,((iz-1)*(' num2str(np) '+1)+2):((iz-1)*(' num2str(np) '+1)+' num2str(np) '+1),:),options_ami.nmaxevent,1,' num2str(np) ',length(options_ami.sens_ind));\n']);
+                fprintf(fid,['            sol.s2sigmaz(:,iz,:,:) = reshape(sol.ssigmaz(:,((iz-1)*(' num2str(np) '+1)+2):((iz-1)*(' num2str(np) '+1)+' num2str(np) '+1),:),options_ami.nmaxevent,1,' num2str(np) ',length(options_ami.sens_ind));\n']);
+                fprintf(fid,['            sol.s2rz(:,iz,:,:) = reshape(sol.srz(:,((iz-1)*(' num2str(np) '+1)+2):((iz-1)*(' num2str(np) '+1)+' num2str(np) '+1),:),options_ami.nmaxevent,1,' num2str(np) ',length(options_ami.sens_ind));\n']);
+            case 2
+                fprintf(fid,['            sol.s2z(:,iz,:) = reshape(sol.sz(:,2*(iz-1)+2,:),options_ami.nmaxevent,1,length(theta(options_ami.sens_ind)));\n']);
+                fprintf(fid,['            sol.s2sigmaz(:,iz,:) = reshape(sol.ssigmaz(:,2*(iz-1)+2,:),options_ami.nmaxevent,1,length(theta(options_ami.sens_ind)));\n']);
+                fprintf(fid,['            sol.s2rz(:,iz,:) = reshape(sol.srz(:,2*(iz-1)+2,:),options_ami.nmaxevent,1,length(theta(options_ami.sens_ind)));\n']);
+        end
+        fprintf(fid,'        end\n');
+        fprintf(fid,['        sol.sx = sol.sx(:,1:' num2str(nxtrue) ',:);\n']);
+        fprintf(fid,['        sol.sy = sol.sy(:,1:' num2str(nytrue) ',:);\n']);
+        fprintf(fid,['        sol.ssigmay = sol.ssigmay(:,1:' num2str(nytrue) ',:);\n']);
+        fprintf(fid,['        if(iz>0)\n']);
+        fprintf(fid,['            sol.sz = sz;\n']);
+        fprintf(fid,['            sol.ssigmaz = ssigmaz;\n']);
+        fprintf(fid,['            sol.srz = srz;\n']);
+        fprintf(fid,'         end\n');
+        fprintf(fid,'    end\n');
+        fprintf(fid,['    sol.x = sol.x(:,1:' num2str(nxtrue) ');\n']);
+        fprintf(fid,['    sol.y = sol.y(:,1:' num2str(nytrue) ');\n']);
+        fprintf(fid,['    sol.sigmay = sol.sigmay(:,1:' num2str(nytrue) ');\n']);
+        fprintf(fid,['    sol.z = sol.z(:,1:' num2str(nztrue) ');\n']);
+        fprintf(fid,['    sol.rz = sol.rz(:,1:' num2str(nztrue) ');\n']);
+        fprintf(fid,['    sol.sigmaz = sol.sigmaz(:,1:' num2str(nztrue) ');\n']);
+        fprintf(fid,'end\n');
+    end
+    
+    fprintf(fid,'if(nargout>1)\n');
+    fprintf(fid,'    varargout{1} = sol.status;\n');
+    fprintf(fid,'    varargout{2} = sol.t;\n');
+    fprintf(fid,'    varargout{3} = sol.x;\n');
+    fprintf(fid,'    varargout{4} = sol.y;\n');
+    fprintf(fid,'    if(nargout>4)\n');
+    fprintf(fid,'        varargout{5} = sol.sx;\n');
+    fprintf(fid,'        varargout{6} = sol.sy;\n');
+    if(o2flag)
+        fprintf(fid,'        if(nargout>6)\n');
+        fprintf(fid,'            varargout{7} = sol.s2x;\n');
+        fprintf(fid,'            varargout{8} = sol.s2y;\n');
+        fprintf(fid,'        end\n');
+    end
+    fprintf(fid,'    end\n');
+    fprintf(fid,'else\n');
+    fprintf(fid,'    varargout{1} = sol;\n');
+    fprintf(fid,'end\n');
+    
+    fprintf(fid,'function chainRuleFactors = getChainRuleFactors(pscale, theta, sens_ind)\n');
+    fprintf(fid,'    if(length(pscale) == 1 && length(sens_ind) ~= length(pscale))\n');
+    fprintf(fid,'        chainRuleFactors = arrayfun(@(x, ip) getChainRuleFactor(x, theta(ip)), repmat(pscale, 1, length(sens_ind)), sens_ind);\n');
+    fprintf(fid,'    else\n');
+    fprintf(fid,'        chainRuleFactors = arrayfun(@(x, ip) getChainRuleFactor(x, theta(ip)), pscale, sens_ind);\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+
+    fprintf(fid,'function chainRuleFactor = getChainRuleFactor(pscale, parameterValue)\n');
+    fprintf(fid,'    switch (pscale)\n');
+    fprintf(fid,'        case 1\n');
+    fprintf(fid,'            chainRuleFactor = exp(parameterValue);\n');
+    fprintf(fid,'        case 2\n');
+    fprintf(fid,'            chainRuleFactor = 10.^parameterValue*log(10);\n');
+    fprintf(fid,'        otherwise\n');
+    fprintf(fid,'            chainRuleFactor = 1.0;\n');
+    fprintf(fid,'    end\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+
+    fprintf(fid,'end\n');
+    
+    fclose(fid);
+    
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/getFun.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/getFun.m
new file mode 100644
index 0000000000000000000000000000000000000000..4d126c585c297e26d015b27c7480e1bb330b74fa
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/getFun.m
@@ -0,0 +1,46 @@
+function getFun(this,HTable,funstr)
+    % getFun generates symbolic expressions for the requested function.
+    %
+    % Parameters:
+    %  HTable: struct with hashes of symbolic definition from the previous
+    %  compilation @type struct
+    %  funstr: function for which symbolic expressions should be computed @type string
+    %
+    % Return values:
+    %  void
+    
+    [wrap_path,~,~]=fileparts(fileparts(which('amiwrap.m')));
+    
+    fun = amifun(funstr,this);
+    
+
+    if(~isfield(this.fun,funstr)) % check whether we already computed the respective fun
+        if(~all(strcmp(fun.deps,funstr))) % prevent infinite loops
+            if(this.recompile)
+                cflag = this.checkDeps([],fun.deps);
+            else
+                cflag = this.checkDeps(HTable,fun.deps);
+            end
+        else
+            if(~isempty(fun.deps))
+                if(~isfield(this.strsym,[fun.deps{1} 's']))
+                    cflag = 1;
+                else
+                    cflag = 0;
+                end
+            else
+                cflag = 1;
+            end
+        end
+    else
+        cflag = 0;
+    end
+        
+    
+    if(cflag)
+        fun = amifun(funstr,this);
+        [fun,this] = fun.getSyms(this);
+        this.fun(1).(funstr) = fun;
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/loadOldHashes.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/loadOldHashes.m
new file mode 100644
index 0000000000000000000000000000000000000000..088aa826ef0cfa013da469718e3a2ab1978382a5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/loadOldHashes.m
@@ -0,0 +1,67 @@
+function HTable = loadOldHashes(this)
+    % loadOldHashes loads information from a previous compilation of the model.
+    %
+    % Return values:
+    %  HTable: struct with hashes of symbolic definition from the previous
+    %  compilation @type struct
+    
+    [wrap_path,~,~]=fileparts(fileparts(which('amiwrap.m')));
+    try
+        load(fullfile(wrap_path,'models',this.modelname,['hashes.mat']))
+        try
+            this.nw = nw;
+            this.ndwdp = ndwdp;
+            this.ndwdx = ndwdx;
+            this.z2event = z2event;
+            this.nnz = nnonzeros;
+            this.id = id;
+            this.ubw = ubw;
+            this.lbw = lbw;
+            this.colptrs = colptrs;
+            this.rowvals = rowvals;
+            this.sparseidx = sparseidx;
+            this.colptrsB = colptrsB;
+            this.rowvalsB = rowvalsB;
+            this.sparseidxB = sparseidxB;
+        catch err
+        end
+        
+    catch
+        HTable = struct();
+    end
+    DHTable.x = '';
+    DHTable.k = '';
+
+    DHTable.p = '';
+    DHTable.x0 = '';
+    DHTable.y = '';
+    DHTable.sigma_y = '';
+    DHTable.sigma_z = '';
+    DHTable.z = '';
+    DHTable.trigger = '';
+    DHTable.deltax = '';
+    DHTable.xdot = '';
+    if(strcmp(this.wtype,'iw'))
+        DHTable.dx0 = '';
+        DHTable.M = '';
+    end
+    DHTable.Jy = '';
+    DHTable.Jz = '';
+    
+    DHTable.generateC = '';
+    DHTable.makeSyms = '';
+    DHTable.makeEvents = '';
+    DHTable.gccode = '';
+    DHTable.getArgs = '';
+    DHTable.getCVar = '';
+    DHTable.getFArgs = '';
+    DHTable.getSensiFlag = '';
+    DHTable.getSyms = '';
+    DHTable.printLocalVars = '';
+    DHTable.writeCcode = '';
+    DHTable.writeCcode_sensi = '';
+    DHTable.tdata = '';
+
+    
+    HTable = am_setdefault(HTable,DHTable);
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/makeEvents.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/makeEvents.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3eddaa6b7965697d4223d900199dc1aae50878f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/makeEvents.m
@@ -0,0 +1,289 @@
+function makeEvents( this )
+% makeEvents extracts discontiniuties from the model right hand side
+% and converts them into events
+%
+% Parameters:
+%
+% Return values:
+%  void
+
+nevent = length(this.event);
+nx = length(this.sym.x);
+
+% extract trigger and bolus, also check dimensions here
+for ievent = 1:nevent
+    trigger{ievent} = this.event(ievent).trigger;
+    if(length(this.event(ievent).bolus) == nx)
+        bolus{ievent} = this.event(ievent).bolus(:);
+    elseif(numel(this.event(ievent).bolus) == 1)
+        bolus{ievent} = this.event(ievent).bolus*ones(nx,1);
+    else
+        error(['Bolus of event ' num2str(ievent) ' is neither a scalar nor does it match the state dimension!']);
+    end
+    z{ievent} = transpose(this.event(ievent).z(:));
+end
+
+ievent = nevent;
+nx = length(this.sym.x);
+triggerstr = '';
+triggers = {};
+
+% collect all the triggers
+for ix = 1:nx
+    tmp_str = char(this.sym.xdot(ix));
+    % find discontinuity inducing functions
+    idx_start = [strfind(tmp_str,'heaviside') + 9,strfind(tmp_str,'dirac') + 5]; % find
+    if(~isempty(idx_start))
+        % compute bracket level
+        brl = cumsum(tmp_str == '(') - cumsum(tmp_str == ')');
+        for iocc = 1:length(idx_start) % loop over occurances
+            % extract argument
+            idx_end = find(brl(idx_start(iocc):end)-brl(idx_start(iocc))==-1,1,'first');
+            arg = tmp_str((idx_start(iocc)+1):(idx_start(iocc)+idx_end-2));
+            triggers{end+1} = arg;
+            triggers{end+1} = ['-(' arg ')']; % for dirac we need both +to- and -to+ transitions
+        end
+    end
+end
+
+% select the unique ones
+utriggers = unique(arrayfun(@char,betterSym(triggers),'UniformOutput',false));
+for itrigger = 1:length(utriggers)
+    ievent = ievent + 1;
+    trigger{ievent} = betterSym(utriggers{itrigger});
+    bolus{ievent} = sym(zeros(nx,1));
+    z{ievent} = sym.empty([0,0]);
+end
+
+% update number of events
+if(exist('trigger','var'))
+    nevent = length(trigger);
+else
+    nevent = 0;
+end
+
+if(nevent>0)
+    % initialis tmp_bolus
+    tmp_bolus = cell([nevent,1]);
+    for ievent = 1:nevent
+        tmp_bolus{ievent} = sym(zeros([nx,1]));
+    end
+    syms polydirac
+    
+    % initialise hflag
+    hflags = zeros([nx,nevent]);
+    
+    % heaviside
+    event_dependency = zeros(nevent);
+    for ievent = 1:nevent
+        symchar = char(trigger{ievent});
+        if(~isempty(strfind(symchar,'heaviside')))
+            for jevent = 1:nevent
+                % remove the heaviside function and replace by h
+                % variable which is update on event occurrence in the
+                % solver
+                triggerchar = char(trigger{jevent});
+                str_arg_h = ['heaviside(' triggerchar ')' ];
+                event_dependency(ievent,jevent) = event_dependency(ievent,jevent) + ~isempty(strfind(symchar,str_arg_h));
+                mtriggerchar = char(-trigger{jevent});
+                str_arg_h = ['heaviside(' mtriggerchar ')' ];
+                event_dependency(ievent,jevent) = event_dependency(ievent,jevent) + ~isempty(strfind(symchar,str_arg_h));
+            end
+        end
+    end
+    
+    % check for loops
+    if(any(any(event_dependency^(size(event_dependency,1)))))
+        error('Found loop in trigger dependency. This can lead to the simulation getting stuck and is thus currently not supported. Please check your model definition!')
+    end
+    
+    P = 1:size(event_dependency,1);
+    
+    % make matrix upper triangular, this is to ensure that we dont end
+    % up with partially replaced trigger functions that we no longer recognise
+    while(~isempty(find(triu(event_dependency(P,P))-event_dependency(P,P))))
+        for ip = 1:length(P)
+            jp = ip+find(event_dependency(P(ip+1:end),P(ip)),1,'first');
+            while ~isempty(jp)
+                pp = P(ip);
+                P(ip) = P(jp);
+                P(jp) = pp;
+                jp = ip+find(event_dependency(P(ip+1:end),P(ip)),1,'first');
+            end
+        end
+    end
+    trigger = trigger(P);
+    bolus = bolus(P);
+    z = z(P);
+    
+    
+    
+    for ix = 1:nx
+        symchar = char(this.sym.xdot(ix));
+        symvariable = this.sym.xdot(ix);
+        if(strfind(symchar,'dirac'))
+            for ievent = 1:nevent
+                % remove the dirac function and replace by adding
+                % respective bolus
+                symvariable = subs(symvariable,dirac(trigger{ievent}),sym('polydirac'));
+                % extract coefficient
+                [cfp,t] = coeffs(symvariable,polydirac);
+                if(any(double(t==sym('polydirac'))))
+                    tmp_bolus{ievent}(ix) = tmp_bolus{ievent}(ix) + cfp(logical(t==sym('polydirac')));
+                    idx_mirror = find(cellfun(@(x) double(x==-trigger{ievent}),trigger));
+                    if(~isempty(idx_mirror))
+                        tmp_bolus{idx_mirror}(ix) = tmp_bolus{idx_mirror}(ix) + cfp(logical(t==sym('polydirac'))); % for dirac we need both +to- and -to+ transitions
+                    end
+                end
+                % remove dirac
+                symvariable = subs(symvariable,sym('polydirac'),sym('0'));
+            end
+        end
+        if(strfind(symchar,'heaviside'))
+            
+            for ievent = 1:nevent
+                % remove the heaviside function and replace by h
+                % variable which is updated upon event occurrence in the
+                % solver
+                
+                % h variables only change for one sign change but heaviside
+                % needs updating for both, thus we should 
+                symvariable = subs(symvariable,heaviside( trigger{ievent}),betterSym(['h_' num2str(ievent-1)]));
+                symvariable = subs(symvariable,heaviside(-trigger{ievent}),betterSym(['(1-h_' num2str(ievent-1) ')']));
+                % set hflag
+                
+                % we can check whether dividing cfp(2) by
+                % trigger{ievent} reduced the length of the symbolic
+                % expression. If it does, this suggests that
+                % trigger{ievent} is a factor of cfp(2), which will be
+                if(or(...
+                    ismember(sym(['h_' num2str(ievent-1)]),symvar(symvariable)),...
+                    ismember(sym(['h_' num2str(find(-trigger{ievent}==trigger)-1)]),symvar(symvariable))...
+                    ))
+                    hflags(ix,ievent) = 1;
+                else
+                    hflags(ix,ievent) = 0;
+                end
+            end
+        end
+        if(strfind(char(symvariable),'heaviside'))
+            warning(['Missed heaviside function in state ' num2str(ix) '. AMICI will continue and produce a running model, but this should be fixed!'])
+        end
+        % update xdot
+        this.sym.xdot(ix) = symvariable;
+    end
+    
+    % loop until we no longer found any dynamic heaviside functions in the triggers in the previous loop
+    nheavy = 1;
+    while nheavy>0
+        nheavy = 0;
+        for ievent = 1:nevent
+            symchar = char(trigger{ievent});
+            for jevent = 1:nevent
+                % remove the heaviside function and replace by h
+                % variable which is update on event occurrence in the
+                % solver
+                triggerchar = char(trigger{jevent});
+                str_arg_h = ['heaviside(' triggerchar ')' ];
+                nheavy = nheavy + length(strfind(symchar,str_arg_h));
+                symchar = strrep(symchar,str_arg_h,['h_' num2str(jevent-1)]);
+                mtriggerchar = char(-trigger{jevent});
+                str_arg_h = ['heaviside(' mtriggerchar ')' ];
+                nheavy = nheavy + length(strfind(symchar,str_arg_h));
+                symchar = strrep(symchar,str_arg_h,['(1-h_' num2str(jevent-1) ')']);
+                % set hflag
+            end
+            trigger{ievent} = betterSym(symchar);
+        end
+    end
+    
+    % compute dtriggerdt and constant trigger functions
+    for ievent = 1:nevent
+        dtriggerdt(ievent) = diff(trigger{ievent},sym('t')) + jacobian(trigger{ievent},this.sym.x)*this.sym.xdot(:);
+    end
+    triggeridx = logical(dtriggerdt~=0);
+    
+    % multiply by the dtriggerdt factor, this should stay here as we
+    % want the xdot to be cleaned of any dirac functions
+    ievent = 1;
+    for ievent = 1:nevent
+        if(not(triggeridx(ievent)))
+            if(any(bolus{ievent}~=0))
+                error(['Event ' num2str(ievent) ' has a constant trigger function but non-zero bolus.' ...
+                    ' Please check your model definition!'])
+            end
+            if(~isempty(z{ievent}))
+                error(['Event ' num2str(ievent) ' has a constant trigger function but non-empty output.' ...
+                    ' Please check your model definition!'])
+            end
+        else
+            bolus{ievent} = bolus{ievent} + tmp_bolus{ievent}/abs(dtriggerdt(ievent));
+            ievent = ievent+1;
+        end
+    end
+    
+    % update hflags according to bolus
+    for ievent = 1:nevent
+        if(any(double(bolus{ievent}~=0)))
+            for ix = 1:nx
+                if(~hflags(ix,ievent))
+                    for j = transpose(find(double(bolus{ievent}~=0)))
+                        if(ismember(this.sym.x(j),symvar(this.sym.xdot(ix))))
+                            hflags(ix,ievent) = 1;
+                        end
+                    end
+                end
+            end
+        end
+    end
+    
+    this.event = amievent.empty();
+    
+    % update events
+    for ievent = 1:nevent
+        this.event(ievent) = amievent(trigger{ievent},bolus{ievent}(:),z{ievent});
+        % do not add a (:) after z{ievent} this will transform an
+        % [ empty sym ] into Empty sym: 0-by-1 which will lead to a
+        % zero entry if we apply [this.event.z]
+        this.event(ievent) = this.event(ievent).setHflag(hflags(:,ievent));
+    end
+end
+
+if(~isfield(this.sym,'sigma_z'))
+    this.sym.sigma_z = sym(ones(length([this.event.z]),1));
+end
+if(numel(this.sym.sigma_z) == 1)
+    this.sym.sigma_z = this.sym.sigma_z*sym(ones(length([this.event.z]),1));
+end
+
+if(~isfield(this.sym,'Jz'))
+    this.sym.Jz = sym(zeros(length([this.event.z]),1));
+    for iz = 1:length([this.event.z])
+        this.sym.Jz(iz) = betterSym(['0.5*log(2*pi*sigma_z_' num2str(iz-1) '^2) + 0.5*((z_' num2str(iz-1) '-mz_' num2str(iz-1) ')/sigma_z_' num2str(iz-1) ')^2']);
+    end
+end
+
+z = sym(arrayfun(@(iz) ['z_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+var_z = sym(arrayfun(@(iz) ['var_z_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+sigma_z = sym(arrayfun(@(iz) ['sigma_z_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+var_sigma_z = sym(arrayfun(@(iz) ['sigma_z_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+
+this.sym.Jz = subs(this.sym.Jz,z,var_z);
+this.sym.Jz = subs(this.sym.Jz,sigma_z,var_sigma_z);
+
+rz = sym(arrayfun(@(iz) ['rz_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+mz = sym(arrayfun(@(iz) ['mz_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+var_rz = sym(arrayfun(@(iz) ['var_rz_' num2str(iz-1)],1:length([this.event.z]),'UniformOutput',false));
+
+if(~isfield(this.sym,'Jrz'))
+    this.sym.Jrz = sym(zeros(size(this.sym.Jz)));
+    for iz = 1:length([this.event.z])
+        tmp = subs(this.sym.Jz(iz,:),var_z,var_rz);
+        this.sym.Jrz(iz,:) = subs(tmp,mz,sym(zeros(size(mz)))); 
+    end
+end
+
+this.sym.Jrz = subs(this.sym.Jrz,rz,var_rz);
+
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/makeSyms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/makeSyms.m
new file mode 100644
index 0000000000000000000000000000000000000000..13f0226780a22e0880099d9a99084bf4b24b49ae
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/makeSyms.m
@@ -0,0 +1,144 @@
+function makeSyms( this )
+% makeSyms extracts symbolic definition from the user provided model
+% and checks them for consistency
+%
+% Parameters:
+%
+% Return values:
+%  void
+
+
+
+% check whether sym is properly defined
+if(~isfield(this.sym,'xdot'))
+    if(isfield(this.sym,'f'))
+        try
+            this.sym.xdot = betterSym(this.sym.f(:));
+            this.sym = rmfield(this.sym,'f');
+        catch
+            error('Could not transform model.sym.f into a symbolic variable, please check the definition!')
+        end
+    else
+        error('field xdot/f is missing in model definition')
+    end
+else
+    if(isfield(this.sym,'f'))
+        if(~isequaln(this.sym.f,this.sym.xdot))
+            error('Model this contains conflicting definitions sym.f and sym.xdot of DE right hand side');
+        end
+    else
+        try
+            if(~isa(this.sym.xdot(:),'sym'))
+                this.sym.xdot = betterSym(this.sym.xdot(:));
+            else
+                this.sym.xdot = this.sym.xdot(:);
+            end
+        catch
+            error('Could not transform model.sym.xdot into a symbolic variable, please check the definition!')
+        end
+    end
+end
+
+if(~isfield(this.sym,'x'))
+    error('Model this is missing the definition of the state vector x (.sym.x)!')
+else
+    try
+        this.sym.x = sym(this.sym.x(:));
+    catch
+        error('Could not transform model.sym.x into a symbolic variable, please check the definition!')
+    end
+end
+if(numel(this.sym.x)~=numel(this.sym.xdot))
+    error('Size of model.sym.x and model.sym.xdot does not agree.')
+end
+
+if(~isfield(this.sym,'p'))
+    error('Model this is missing the definition of the parameter vector p (.sym.p)!')
+else
+    try
+        this.sym.p = sym(this.sym.p(:));
+    catch
+        error('Could not transform model.sym.y into a symbolic variable, please check the definition!')
+    end
+end
+if(~isfield(this.sym,'x0'))
+    error('Model this is missing the definition of the vector of initial conditions x0 (.sym.x0)!')
+else
+    try
+        if(~isa(this.sym.x0(:),'sym'))
+            this.sym.x0 = betterSym(this.sym.x0(:));
+        else
+            this.sym.x0 = this.sym.x0(:);
+        end
+    catch
+        error('Could not transform model.sym.x0 into a symbolic variable, please check the definition!')
+    end
+end
+if(numel(this.sym.x)~=numel(this.sym.x0))
+    error('Size of model.sym.x and model.sym.x0 does not agree.')
+end
+if(any(ismember(symvar(this.sym.x0),this.sym.x)))
+    error('initial states x0 must not contain state variables x');
+end
+
+if(~isfield(this.sym,'y'))
+    error('Model this is missing the definition of the vector of observables y (.sym.y)!')
+else
+    try
+        this.sym.y = sym(this.sym.y(:));
+    catch
+        error('Could not transform model.sym.y into a symbolic variable, please check the definition!')
+    end
+end
+
+% complete optional fields
+if(~isfield(this.sym,'u'))
+    this.sym.u = sym(zeros(0,0));
+end
+if(~isfield(this.sym,'k'))
+    this.sym.k = sym(zeros(0,0));
+else
+    try
+        this.sym.k = sym(this.sym.k(:));
+    catch
+        error('Could not transform model.sym.k into a symbolic variable, please check the definition!')
+    end
+    
+end
+
+if(isfield(this.sym,'root'))
+    error('The definition of events via a root function is deprecated and no longer supported. Please update the model definition syntax!')
+end
+if(~isfield(this.sym,'sigma_y'))
+    this.sym.sigma_y = sym(ones(length(this.sym.y),1));
+end
+if(numel(this.sym.sigma_y) == 1)
+    this.sym.sigma_y = this.sym.sigma_y*sym(ones(length(this.sym.y),1));
+end
+if(numel(this.sym.sigma_y)~=length(this.sym.y))
+    error('Size of model.sym.y and model.sym.sigma_y does not agree.')
+end
+
+if(any(ismember(this.sym.k,this.sym.p)))
+    error(['Invalid Model: ' char(this.sym.k(find(ismember(this.sym.k,this.sym.p),1))) ' is contained in both p and k!'])
+end
+
+if(~isfield(this.sym,'Jy'))
+    this.sym.Jy = sym(zeros(numel(this.sym.y),1));
+    for iy = 1:length(this.sym.y)
+        this.sym.Jy(iy) = betterSym(['0.5*log(2*pi*sigma_y_' num2str(iy-1) '^2) + 0.5*((y_' num2str(iy-1) '-my_' num2str(iy-1) ')/sigma_y_' num2str(iy-1) ')^2']);
+    end
+end
+
+symvars = symvar(this.sym.xdot);
+for ivar = 1:length(symvars)
+    if(isequaln(symvars(ivar),sym('E')))
+        error('The symbolic entities named ''E'' are currently not supported due to restrictions of the symbolic math toolbox!');
+    end
+end
+%     svaridx = not(ismember(symvars,[this.sym.p;this.sym.k;this.sym.x;sym('t')]));
+%     if(any(svaridx))
+%         error(['The symbolic variable ' char(symvars(find(svaridx,1))) ' is used in the differential equation right hand side but was not specified as parameter/state/constant!']);
+%     end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/parseModel.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/parseModel.m
new file mode 100644
index 0000000000000000000000000000000000000000..722f890c0b995b1ce2b334d764bdbd12658bf815
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amimodel/parseModel.m
@@ -0,0 +1,264 @@
+function parseModel(this)
+% parseModel parses the model definition and computes all necessary symbolic expressions.
+%
+% Parameters:
+%
+% Return values:
+%  void
+
+% load old hashes
+HTable = this.loadOldHashes();
+
+nevent = length(this.event);
+this.nevent = nevent;
+
+% fix z2event if z was computed previously
+if(isfield(this.fun,'z'))
+    this.fun = rmfield(this.fun,'z');
+    this.getFun([],'z');
+end
+
+nx = length(this.sym.x);
+np = length(this.sym.p);
+nk = length(this.sym.k);
+ny = length(this.sym.y);
+nz = length([this.event.z]);
+if(this.nytrue == 0) % only set this if it still has the default value, if 0 is already the non default value it does not matter anyways
+    nytrue = length(this.sym.sigma_y);
+    this.nytrue = nytrue;
+end
+if(this.nztrue == 0)
+    nztrue = length(this.sym.sigma_z);
+    this.nztrue = nztrue;
+end
+if(this.nxtrue == 0)
+    nxtrue = length(this.sym.x);
+    this.nxtrue = nxtrue;
+end
+
+
+%check zero trigger events
+for ievent = 1:nevent
+    if(isequaln(this.event(ievent).trigger,sym(0)))
+        error('Trigger functions cannot be equal to zero. Please check your event definition!')
+    end
+end
+
+this.nx = nx;
+this.ny = ny;
+this.nz = nz;
+this.np = np;
+this.nk = nk;
+
+% initial hashes
+this.HTable(1).y = CalcMD5(char(this.sym.y));
+this.HTable(1).x = CalcMD5(char(this.sym.x));
+this.HTable(1).p = CalcMD5(char(this.sym.p));
+this.HTable(1).k = CalcMD5(char(this.sym.k));
+this.HTable(1).x0 = CalcMD5(char(this.sym.x0));
+if(nevent>0)
+    this.HTable(1).root = CalcMD5(char([this.event.trigger]));
+    this.HTable(1).deltax = CalcMD5(char([this.event.bolus]));
+    this.HTable(1).z = CalcMD5(char([this.event.z]));
+end
+if(strcmp(this.wtype,'iw'))
+    this.HTable(1).xdot = CalcMD5(char(this.sym.xdot));
+    this.HTable(1).dx0 = CalcMD5(char(this.sym.dx0));
+    this.HTable(1).M = CalcMD5(char(this.sym.M));
+else
+    this.HTable(1).xdot = CalcMD5(char(this.sym.xdot));
+end
+this.HTable(1).sigma_y = CalcMD5(char(this.sym.sigma_y));
+this.HTable(1).sigma_z = CalcMD5(char(this.sym.sigma_z));
+this.HTable(1).Jy = CalcMD5(char(this.sym.Jy));
+this.HTable(1).Jz = CalcMD5(char(this.sym.Jz));
+this.HTable(1).Jrz = CalcMD5(char(this.sym.Jrz));
+
+% check if code generation changed
+codegen_amifun = {'gccode','getArgs','getCVar',...
+    'getSensiFlag','getSyms','writeCcode',...
+    'writeCcode_sensi'};
+for ifile = 1:length(codegen_amifun)
+    this.HTable(1).(codegen_amifun{ifile}) = CalcMD5(fullfile(this.wrap_path,'matlab','@amifun',[codegen_amifun{ifile} '.m']),'File');
+end
+codegen_amimodel = {'generateC','makeSyms','makeEvents'};
+for ifile = 1:length(codegen_amimodel)
+    this.HTable(1).(codegen_amimodel{ifile}) = CalcMD5(fullfile(this.wrap_path,'matlab','@amimodel',[codegen_amimodel{ifile} '.m']),'File');
+end
+if(not(this.recompile))
+    this.recompile = not(strcmp(this.HTable(1).x,HTable.x));
+end
+if(not(this.recompile))
+    this.recompile = not(strcmp(this.HTable(1).p,HTable.p));
+end
+if(not(this.recompile))
+    this.recompile = not(strcmp(this.HTable(1).k,HTable.k));
+end
+if(nevent>0)
+    if(not(this.recompile))
+        this.recompile = not(strcmp(this.HTable(1).root,HTable.root));
+    end
+end
+
+
+ifile = 1;
+while(not(this.recompile) & ifile<=length(codegen_amifun))
+    this.recompile = not(strcmp(this.HTable(1).(codegen_amifun{ifile}),HTable.(codegen_amifun{ifile})));
+    ifile = ifile+1;
+end
+ifile = 1;
+while(not(this.recompile) & ifile<=length(codegen_amimodel))
+    this.recompile = not(strcmp(this.HTable(1).(codegen_amimodel{ifile}),HTable.(codegen_amimodel{ifile})));
+    ifile = ifile+1;
+end
+if(this.recompile)
+    if(~strcmp(HTable.generateC,''))
+        disp('Code generation routines changed! Recompiling model!')
+        cleanUpModelFolder(this);
+    end
+end
+% compute functions
+
+funs = {'xdot','w','dwdx','J','x0','JSparse','JDiag','y','z','rz','deltax','root','Jy','Jz','Jrz','sigma_y','sigma_z'};
+
+if(this.forward)
+    funs = {funs{:},'sx0','sz','deltasx','stau','srz','dJydy','dJydsigma','dJzdz','dJzdsigma','dJrzdz','dJrzdsigma','dwdp','dxdotdp','dydp','dsigma_ydp','dsigma_zdp','dydx','dzdx','dzdp','drzdx','drzdp'};
+end
+if(this.adjoint)
+    funs = {funs{:},'JB','JSparseB','dydx','dzdx','dzdp','drzdx','drzdp','deltaxB','deltaqB','dsigma_ydp','dsigma_zdp','sx0','dJydy','dJydsigma','dJzdz','dJzdsigma','dJrzdz','dJrzdsigma','dwdp','dxdotdp','dydp'};
+end
+
+if(strcmp(this.wtype,'iw'))
+    funs = {funs{:},'M'};
+end
+
+funs = unique(funs);
+
+this.funs = funs;
+
+%this.mfuns = {'J','dxdotdp'};
+this.mfuns = {};
+
+% compute symbolic expressions
+for ifun = 1:length(funs)
+    this.getFun(HTable,funs{ifun});
+end
+
+if(isfield(this.fun,'J'))
+    fprintf('sparse | ')
+    M = double(logical(this.fun.J.sym~=sym(zeros(size(this.fun.J.sym)))));
+    this.sparseidx = find(M);
+    
+    [ubw,lbw] = ami_bandwidth(M);
+    
+    this.ubw = ubw;
+    this.lbw = lbw;
+    this.nnz = length(find(M(:)));
+    
+    I = arrayfun(@(x) find(M(:,x))-1,1:nx,'UniformOutput',false);
+    this.rowvals = [];
+    this.colptrs = [];
+    for ix = 1:nx
+        this.colptrs(ix) = length(this.rowvals);
+        this.rowvals = [this.rowvals; I{ix}];
+    end
+    this.colptrs(ix+1) = length(this.rowvals);
+    
+    if(this.adjoint)
+        if(isfield(this.fun,'JB'))
+            fprintf('sparseB | ')
+            MB = double(logical(this.fun.JB.sym~=sym(zeros(size(this.fun.JB.sym)))));
+            this.sparseidxB = find(MB);
+            I = arrayfun(@(x) find(MB(:,x))-1,1:nx,'UniformOutput',false);
+            this.rowvalsB = [];
+            this.colptrsB = [];
+            for ix = 1:nx
+                this.colptrsB(ix) = length(this.rowvalsB);
+                this.rowvalsB = [this.rowvalsB; I{ix}];
+            end
+            this.colptrsB(ix+1) = length(this.rowvalsB);
+        end
+    end
+end
+
+if(strcmp(this.wtype,'iw'))
+    if(isfield(this.fun,'M'))
+        this.getFun([],'M');
+        this.id = double(logical(sum(this.fun.M.sym,2)~=0));
+    else
+        
+    end
+else
+    this.id = zeros(nx,1);
+end
+
+switch(this.o2flag)
+    case 1
+        this.ng = this.np + 1;
+    case 2
+        this.ng = 2;
+    otherwise
+        this.ng = 1;
+end
+
+% save hashtable
+HTable = this.HTable;
+nxtrue = this.nxtrue;
+nytrue = this.nytrue;
+nx = this.nx;
+ny = this.ny;
+np = this.np;
+nk = this.nk;
+nz = this.nz;
+ng = this.ng;
+nw = this.nw;
+ndwdx = this.ndwdx;
+ndwdp = this.ndwdp;
+nevent = this.nevent;
+z2event = this.z2event;
+nnonzeros = this.nnz;
+id = this.id;
+ubw = this.ubw;
+lbw = this.lbw;
+colptrs = this.colptrs;
+rowvals = this.rowvals;
+sparseidx = this.sparseidx;
+colptrsB = this.colptrsB;
+rowvalsB = this.rowvalsB;
+sparseidxB = this.sparseidxB;
+
+save(fullfile(this.wrap_path,'models',this.modelname,'hashes_new.mat'),'HTable','nxtrue','nytrue','nx','ny','np','nk','nevent','nz','z2event','nnonzeros','id','ubw','lbw','colptrs','rowvals','sparseidx','colptrsB','rowvalsB','sparseidxB','ndwdx','ndwdp','nw');
+
+fprintf('\r')
+
+end
+
+function [ubw,lbw] = ami_bandwidth(M)
+% ami_bandwidth implements a bandwidth function for older versionsn of MATLAB
+%
+% Parameters:
+%  M: matrix for which the bandwidth is to be computed
+%
+% Return values:
+%  ubw: upper matrix bandwidth
+%  lbw: lower matrix bandwidth
+if(isempty(M) || isempty(find(M)))
+    ubw = 0;
+    lbw = 0;
+else
+    [i,j] = find(M);
+    ubw = max(max(j-i),0);
+    lbw = max(max(i-j),0);
+end
+end
+
+function cleanUpModelFolder(this)
+     fileList = dir(fullfile(this.wrap_path,'models',this.modelname));
+     for ifile = 1:length(fileList)
+         file = fileList(ifile);
+         if(any([regexp(file.name,'[\w]*\_[\w]*\.mat')==1,
+                 regexp(file.name,['[' this.modelname '|main|wrapfunctions]+[\w_]*\.[h|cpp|md5|o|obj]'])==1]));
+             delete(fullfile(this.wrap_path,'models',this.modelname,file.name));
+         end
+     end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amioption/amioption.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amioption/amioption.m
new file mode 100644
index 0000000000000000000000000000000000000000..474ce265c9b67496d9f3058f70c7bcb204123a4a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amioption/amioption.m
@@ -0,0 +1,271 @@
+%
+% @file amioption
+% @brief definition of amioption class
+%
+classdef amioption < matlab.mixin.CustomDisplay
+    %AMIOPTION provides an option container to pass simulation parameters to the
+    %simulation routine.
+    
+    properties
+        % absolute integration tolerace
+        atol = 1e-16;
+        % relative integration tolerace
+        rtol = 1e-8;
+        % maximum number of integration steps
+        maxsteps = 1e4;
+        % absolute quadrature tolerace
+        quad_atol = 1e-12;
+        % relative quadrature tolerace
+        quad_rtol = 1e-8;
+        % maximum number of integration steps
+        maxstepsB = 0;
+        % absolute steady state tolerace
+        ss_atol = 1e-16;
+        % relative steady state tolerace
+        ss_rtol = 1e-8;
+        % index of parameters for which the sensitivities are computed
+        sens_ind = double.empty();
+        % starting time of the simulation
+        tstart = 0;
+        % linear multistep method.
+        lmm = 2;
+        % iteration method for linear multistep.
+        iter = 2;
+        % linear solver
+        linsol = 9;
+        % stability detection flag
+        stldet = true;
+        % interpolation type
+        interpType = 1;
+        % forward sensitivity mode
+        ism = 1;
+        % sensitivity method
+        sensi_meth = 1;
+        % sensitivity order
+        sensi = 0;
+        % number of reported events
+        nmaxevent = 10;
+        % reordering of states
+        ordering = 0;
+        % steady state sensitivity flag
+        ss = 0;
+        % custom initial state
+        x0 = double.empty();
+        % custom initial sensitivity
+        sx0 = double.empty();
+        % newton solver: maximum newton steps
+        newton_maxsteps = 40;
+        % newton solver: maximum linear steps
+        newton_maxlinsteps = 100;
+        % preequilibration of system via newton solver
+        newton_preeq = false;
+        % mapping of event ouputs to events
+        z2event = double.empty();
+        % parameter scaling
+        % Single value or vector matching sens_ind.
+        % Valid options are "log","log10" and "lin" for log, log10 or
+        % unscaled parameters p.
+        % Use [] for default as specified in the model (fallback: 'lin').
+        pscale = [];
+    end
+    
+    methods
+        function obj = amioption(varargin)
+            %amioptions Construct a new amioptions object
+            %   OPTS = amioption() creates a set of options with each option set to its
+            %   default value.
+            %
+            %   OPTS = amioption(PARAM, VAL, ...) creates a set of options with the named
+            %   parameters altered with the specified values.
+            %
+            %   OPTS = amioption(OLDOPTS, PARAM, VAL, ...) creates a copy of OLDOPTS with
+            %   the named parameters altered with the specified value
+            %
+            %   Note: to see the parameters, check the
+            %   documentation page for amioption
+            %
+            % Parameters:
+            %  varargin: input to construct amioption object, see function
+            %            function description
+            %
+            % Return values:
+            %  obj: amioption object constructed from inputs
+            %
+            
+            % adapted from SolverOptions
+            
+            if nargin > 0 
+                
+                % Deal with the case where the first input to the
+                % constructor is a amioptions/struct object.
+                if isa(varargin{1},'amioption')
+                    if strcmp(class(varargin{1}),class(obj))
+                        obj = varargin{1};
+                    else
+                        % Get the properties from options object passed
+                        % into the constructor.
+                        thisProps = properties(obj);
+                        % Set the common properties. Note that we
+                        % investigated first finding the properties that
+                        % are common to both objects and just looping over
+                        % those. We found that in most cases this was no
+                        % quicker than just looping over the properties of
+                        % the object passed in.
+                        for i = 1:length(thisProps)
+                            try %#ok
+                                % Try to set one of the properties of the
+                                % old object in the new one.
+                                obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                            end
+                        end
+                    end
+                    firstInputObj = true;
+                elseif isstruct(varargin{1})
+                    fieldlist = fieldnames(varargin{1});
+                    for ifield = 1:length(fieldlist)
+                        obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+                    end
+                    firstInputObj = true;
+                elseif isempty(varargin{1})
+                    firstInputObj = true;
+                else
+                    firstInputObj = false;
+                end
+                
+                % Extract the options that the caller of the constructor
+                % wants to set.
+                if firstInputObj
+                    pvPairs = varargin(2:end);
+                else
+                    pvPairs = varargin;
+                end
+                
+                % Loop through each param-value pair and just try to set
+                % the option. When the option has been fully specified with
+                % the correct case, this is fast. The catch clause deals
+                % with partial matches or errors.
+                haveCreatedInputParser = false;
+                for i = 1:2:length(pvPairs)
+                    try
+                        obj.(pvPairs{i}) = pvPairs{i+1};
+                    catch ME %#ok
+                        
+                        % Create the input parser if we haven't already. We
+                        % do it here to avoid creating it if possible, as
+                        % it is slow to set up.
+                        if ~haveCreatedInputParser
+                            ip = inputParser;
+                            % Structures are currently not supported as
+                            % an input to optimoptions. Setting the
+                            % StructExpand property of the input parser to
+                            % false, forces the parser to treat the
+                            % structure as a single input and not a set of
+                            % param-value pairs.
+                            ip.StructExpand =  false;
+                            % Get list of option names
+                            allOptionNames = properties(obj);
+                            for j = 1:length(allOptionNames)
+                                % Just specify an empty default as we already have the
+                                % defaults in the options object.
+                                ip.addParameter(allOptionNames{j}, []);
+                            end
+                            haveCreatedInputParser = true;
+                        end
+                        
+                        % Get the p-v pair to parse.
+                        thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                        ip.parse(thisPair{:});
+                        
+                        % Determine the option that was specified in p-v pairs.
+                        % These options will now be matched even if only partially
+                        % specified (by 13a). Now set the specified value in the
+                        % options object.
+                        optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                        obj.(optionSet{1}) = ip.Results.(optionSet{1});
+                    end
+                end
+            end
+            
+            
+        end
+        
+        function this = set.sensi_meth(this,value)
+            if(ischar(value))
+                switch(value)
+                    case 'forward'
+                        this.sensi_meth = 1;
+                    case 'adjoint' 
+                        this.sensi_meth = 2;
+                    case 'ss'
+                        this.sensi_meth = 3;
+                    otherwise
+                        error('Unknown sensitivity method. Must be either ''forward'' or ''adjoint''!');
+                end
+            else
+                assert(isnumeric(value),'The option sensi_meth must have a numeric value!')
+                assert(floor(value)==value,'The option sensi_meth must be an integer!')
+                assert(value<=3,'Only 1 and 2 are valid options for sensi_meth!')
+                assert(value>=0,'Only 1 and 2 are valid options for sensi_meth!')
+                this.sensi_meth = value;
+            end
+        end
+        
+        function this = set.sensi(this,value)
+            assert(isnumeric(value),'The option sensi must have a numeric value!')
+            assert(floor(value)==value,'The option sensi must be an integer!')
+            assert(value<=4,'Only 0, 1, 2 are valid options for sensi!')
+            this.sensi = value;
+        end
+        
+        function this = set.pscale(this,value)
+            if(~isempty(value))
+                if(isnumeric(value))
+                    arrayfun(@(x) assert(x == 0 || x == 1 || x == 2, ...
+                        'No valid parametrisation chosen! Valid integer options are 0 (lin), 1 (log), 2 (log10).'), value);
+                elseif(ischar(value))
+                    value = getIntegerPScale(value);
+                else
+                    value = arrayfun(@(x) getIntegerPScale(x), value);
+                end
+            end
+            this.pscale = value;
+        end
+                
+        function this = set.newton_maxsteps(this,value)
+            assert(isnumeric(value),'The option newtons_maxsteps must have a numeric value!')
+            assert(floor(value)==value,'The option newton_maxsteps must be an integer!')
+            this.newton_maxsteps = value;
+        end
+        
+        function this = set.newton_maxlinsteps(this,value)
+            assert(isnumeric(value),'The option newton_maxlinsteps must have a numeric value!')
+            assert(floor(value)==value,'The option newton_maxlinsteps must be an integer!')
+            this.newton_maxlinsteps = value;
+        end
+
+        function this = set.newton_preeq(this,value)
+            if(isnumeric(value))
+                assert(floor(value)==value,'The option newton_preeq must be a logical!')
+                assert(value<=1,'Only 0 and 1 are valid options for newton_preeq!')
+                assert(value>=0,'Only 0 and 1 are valid options for newton_preeq!')
+            else
+                assert(islogical(value),'The option newton_preeq must have a logical value!')
+            end
+            this.newton_preeq = value;
+        end
+    end
+end
+
+function pscaleInt = getIntegerPScale(pscaleString)
+    switch (pscaleString)
+        case 'lin'
+            pscaleInt = 0;
+        case 'log'
+            pscaleInt = 1;
+        case 'log10'
+            pscaleInt = 2;
+        otherwise
+            assert(0, ...
+                'No valid parametrisation chosen! Valid string options are "log", "log10" and "lin".')
+    end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amised/amised.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amised/amised.m
new file mode 100644
index 0000000000000000000000000000000000000000..2d69c2bb27d5ab5ae114825c5dace5be4d025702
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@amised/amised.m
@@ -0,0 +1,125 @@
+%
+% @file amised
+% @brief definition of amised class
+%
+classdef amised < handle
+    % AMISED is a container for SED-ML objects
+    
+    properties ( GetAccess = 'public', SetAccess = 'private' )
+        % amimodel from the specified model
+        model = struct('event',[],'sym',[]);
+        % cell array of model identifiers
+        modelname = {};
+        % stores the struct tree from the xml definition
+        sedml = struct.empty();
+        % count the number of outputs per model
+        outputcount = [];
+        % indexes for dataGenerators
+        varidx = [];
+        % symbolic expressions for variables
+        varsym = sym([]);
+        % symbolic expressions for data
+        datasym = sym([]);
+        
+    end
+    
+    properties ( GetAccess = 'public', SetAccess = 'public' )
+ 
+    end
+    
+    methods
+        function ASED = amised(sedname)
+            %amised reads in an SEDML document using the JAVA binding of 
+            % of libSEDML
+            %
+            % Parameters:
+            %  sedname: name/path of the SEDML document
+            %
+            % Return values:
+            %  ASED: amised object which contains all the information from
+            %        the SEDML document
+            
+            % get models
+            for imodel = 1:length(ASED.sedml.listOfModels.model)
+                % get the model sbml
+                % check if this is a biomodels model
+                if(length(ASED.sedml.listOfModels.model{imodel}.Attributes.source>=23))
+                    if(strcmp(ASED.sedml.listOfModels.model{imodel}.Attributes.source,ASED.modelname))
+                        ASED.model(imodel) = ASED.model(find(strcmp(ASED.sedml.listOfModels.model{imodel}.Attributes.source,ASED.modelname)));
+                        ASED.modelname{imodel} = ASED.sedml.listOfModels.model{imodel}.Attributes.id;
+                        ASED.model(imodel).sym.y = sym([]);
+                        ASED.outputcount(imodel) = 0;
+                        continue
+                    end
+                    if(strcmp(ASED.sedml.listOfModels.model{imodel}.Attributes.source(1:23),'urn:miriam:biomodels.db'))
+                        modelxml = websave([ASED.sedml.listOfModels.model{imodel}.Attributes.source(25:end) '.xml'],['http://www.ebi.ac.uk/biomodels-main/download?mid=' ASED.sedml.listOfModels.model{imodel}.Attributes.source(25:end)]);
+                    else
+                        modelxml = ASED.sedml.listOfModels.model{imodel}.Attributes.source;
+                    end
+                else
+                    modelxml = ASED.sedml.listOfModels.model{imodel}.Attributes.source;
+                end
+                modelxml = strrep(modelxml,'.xml','');
+                % convert model sbml to amici
+                SBML2AMICI(modelxml,ASED.sedml.listOfModels.model{imodel}.Attributes.id);
+                eval(['model = ' ASED.sedml.listOfModels.model{imodel}.Attributes.id '_syms();'])
+                if(~isfield(model,'event'))
+                    model.event = [];
+                end
+                ASED.model(imodel) = model;
+                % clear output;
+                ASED.model(imodel).sym.y = sym([]);
+                ASED.outputcount(imodel) = 0;
+                ASED.modelname{imodel} = ASED.sedml.listOfModels.model{imodel}.Attributes.id;
+            end
+            % apply changes
+            if(isfield(ASED.sedml,'listOfChanges'))
+                %TBD apply changes
+            end
+            % construct outputs
+            for idata = 1:length(ASED.sedml.listOfDataGenerators.dataGenerator)
+                if(length(ASED.sedml.listOfDataGenerators.dataGenerator)>1)
+                    dataGenerator = ASED.sedml.listOfDataGenerators.dataGenerator{idata};
+                else
+                    dataGenerator = ASED.sedml.listOfDataGenerators.dataGenerator;
+                end
+                tasks = [ASED.sedml.listOfTasks.task{:}];
+                tasksatts = [tasks.Attributes];
+                taskids = {tasksatts.id};
+                for ivar = 1:length(dataGenerator.listOfVariables.variable)
+                    if(length(dataGenerator.listOfVariables.variable)>1)
+                        variable = dataGenerator.listOfVariables.variable{ivar};
+                    else
+                        variable = dataGenerator.listOfVariables.variable;
+                    end
+                    task_id = find(strcmp(variable.Attributes.taskReference,taskids));
+                    if(isempty(task_id))
+                        error(['Invalid taskReference in dataGenerator ' num2str(idata) ': ' variable.Attributes.taskReference]);
+                    end
+                    model_idx = find(strcmp(ASED.sedml.listOfTasks.task{task_id}.Attributes.modelReference,ASED.modelname));
+                    if(isempty(model_idx))
+                        error(['Invalid modelReference in task ' num2str(task_id) ': ' ASED.sedml.listOfTasks.task{task_id}.Attributes.modelReference]);
+                    end
+                    if(isfield(variable.Attributes,'symbol'))
+                        if(strcmp(variable.Attributes.symbol,'urn:sedml:symbol:time'))
+                            ASED.model(model_idx).sym.y(ASED.outputcount(model_idx)+1) = sym('t');
+                        end
+                    end
+                    if(isfield(variable.Attributes,'target'))
+                        if(strfind(variable.Attributes.target,'/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species'))
+                            ASED.model(model_idx).sym.y(ASED.outputcount(model_idx)+1) = sym(variable.Attributes.target(60:end-2));
+                        end
+                    end
+                    ASED.outputcount(model_idx) = ASED.outputcount(model_idx)+1;
+                    ASED.varidx(idata,ivar,:) = [model_idx,ASED.outputcount(model_idx)];
+                    ASED.varsym(idata,ivar) = sym(variable.Attributes.id);
+                end
+                ASED.datasym(idata) = sym(variable.Attributes.id);
+                
+            end
+
+            
+        end
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@optsym/optsym.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@optsym/optsym.m
new file mode 100644
index 0000000000000000000000000000000000000000..b825a34bae090307c10ddc8f2dd3e7a50c5ec41d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/@optsym/optsym.m
@@ -0,0 +1,35 @@
+%
+% @file optsym.m
+% @brief wrapper class for sym to make symob::optimize accessible
+%
+classdef optsym<sym
+    %OPTSYM is an auxiliary class to gain access to the private symbolic
+    %property 's' which is necessary to be able to call symobj::optimize 
+    %on it
+
+    properties
+    end
+    
+    methods
+        function obj=optsym(symbol)
+            %optsym converts the symbolic object into a optsym object
+            %
+            % Parameters:
+            %  symbol: symbolic object @type sym
+            %
+            % Return values:
+            %  obj: cast symbolic object @type optsym
+            obj=obj@sym(symbol);
+        end
+        function out=getoptimized(obj)    
+            %getoptimized calls symobj::optimize on the optsym object
+            %
+            % Parameters:
+            %
+            % Return values:
+            %  out: optimized symbolic object @type sym
+            out = mupadmex('symobj::optimize',obj.s);
+        end
+    end
+    
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/AMICI2D2D.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/AMICI2D2D.m
new file mode 100644
index 0000000000000000000000000000000000000000..0cadde9611490bfce00f7cc9cd8f5eb8fa07e51c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/AMICI2D2D.m
@@ -0,0 +1,39 @@
+function AMICI2D2D( filename, modelname )
+    
+    eval(['model = ' filename '();'])
+    
+    fid = fopen([modelname '.def'],'w');
+    
+    fprintf(fid,'DESCRIPTION\n');
+    fprintf(fid,['"' modelname '"\n']);
+    fprintf(fid,'\n');
+    fprintf(fid,'PREDICTOR\n');
+    fprintf(fid,'t               T   min         time	0	60');
+    fprintf(fid,'\n');
+    fprintf(fid,'COMPARTMENTS\n');
+    fprintf(fid,'cell             V   "pl"      "vol."        1\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'STATES\n');
+    fprintf(fid,strjoin(cellfun(@(x) [char(x) '\t\tC\t"nM"\t"conc."\tcell\n'],num2cell(model.sym.x),'UniformOutput',false),''));
+    fprintf(fid,'\n');
+    fprintf(fid,'INPUTS\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'ODES\n');
+    tmp = strjoin(cellfun(@(x) ['"' char(x) '"\n'],num2cell(model.sym.xdot),'UniformOutput',false),'');
+    tmp = regexprep(tmp,'heaviside\(t - ([0-9/]*)\)','step1(t,0.0,$1,1.0)');
+    tmp = regexprep(tmp,'heaviside\(([0-9/]*) - t\)','step1(t,1.0,$1,0.0)');
+    fprintf(fid,tmp);
+    fprintf(fid,'\n');
+    fprintf(fid,'DERIVED\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'OBSERVABLES\n');
+    fprintf(fid,strjoin(cellfun(@(x,y) ['y_' num2str(y) '\tC\t"au"\t"conc."\t1\t0\t"' char(x) '"\n'],num2cell(model.sym.y),num2cell(1:length(model.sym.y)),'UniformOutput',false),''));
+    fprintf(fid,'\n');
+    fprintf(fid,'ERRORS\n');
+    fprintf(fid,strjoin(cellfun(@(x) ['y_' num2str(x) '\t"sd_y_' num2str(x) '"\n'],num2cell(1:length(model.sym.y)),'UniformOutput',false),''));
+    fprintf(fid,'\n');
+    fprintf(fid,'CONDITIONS\n');
+    fprintf(fid,strjoin(cellfun(@(x,y) ['init_' char(x) '\t"' char(sym(y)) '"\n'],num2cell(model.sym.x),num2cell(model.sym.x0),'UniformOutput',false),''));
+    fprintf(fid,strjoin(cellfun(@(x) [ char(x) '\t"1"\n'],num2cell(model.sym.k),'UniformOutput',false),''));
+    fclose(fid);
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBML2AMICI.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBML2AMICI.m
new file mode 100644
index 0000000000000000000000000000000000000000..ad73de42fe6b0931d175c9fc509ed35df924137c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBML2AMICI.m
@@ -0,0 +1,30 @@
+function  SBML2AMICI( filename, modelname )
+    % SBML2AMICI generates AMICI model definition files from SBML.
+    %
+    % Parameters:
+    %  filename: name of the SBML file (withouth extension)
+    %  modelname: name of the model, this will define the name of the
+    %  output file (default: input filename)
+    %
+    % Return values:
+    %  void
+    if(nargin<2)
+        modelname = filename;
+    end
+    amiciMatlabPath=fileparts(mfilename('fullpath'));
+    if(~exist(fullfile(amiciMatlabPath,'SBMLimporter'),'dir'))
+        error('SBMLimporter is not available, try running `git submodule update --init`')
+    end
+    addpath(fullfile(amiciMatlabPath,'SBMLimporter'));
+    ODE = SBMLode(filename);
+    ODE.writeAMICI(modelname);
+    pnom = ODE.pnom;
+    knom = ODE.knom;
+    vnom = ODE.volume;
+    kvnom = ODE.kvolume;
+    save([modelname '_pnom.mat'],'pnom');
+    save([modelname '_knom.mat'],'knom');
+    save([modelname '_vnom.mat'],'vnom');
+    save([modelname '_kvnom.mat'],'kvnom');
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/.gitrepo b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/.gitrepo
new file mode 100644
index 0000000000000000000000000000000000000000..8c0c8f6aa22f8ba735018445e1520983284c06a2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/.gitrepo
@@ -0,0 +1,11 @@
+; DO NOT EDIT (unless you know what you are doing)
+;
+; This subdirectory is a git "subrepo", and this file is maintained by the
+; git-subrepo command. See https://github.com/git-commands/git-subrepo#readme
+;
+[subrepo]
+	remote = https://github.com/ICB-DCM/SBMLimporter
+	branch = master
+	commit = a63f0fb53d0513c058ac0e32f47e30bc1221173b
+	parent = 9f9ec23ee55d8a330d44432f0098de4f9dcaf92c
+	cmdver = 0.3.1
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/SBMLode.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/SBMLode.m
new file mode 100644
index 0000000000000000000000000000000000000000..484e15d00561334230824d3d9a0dc1698a4805cf
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/SBMLode.m
@@ -0,0 +1,76 @@
+classdef SBMLode < handle
+    %SBMLMODEL provides an intermediate container between the SBML
+    %definition and an amimodel object
+    
+    properties
+        % states
+        state = sym.empty();
+        % observables
+        observable = sym.empty();
+        % names of observables
+        observable_name = sym.empty();
+        % parameter names
+        param = sym.empty();
+        % parameter expressions 
+        parameter = sym.empty();
+        % constants
+        constant = sym.empty();
+        % reactions
+        reaction = sym.empty();
+        % compartments
+        compartment = sym.empty();
+        % compartment volumes
+        volume = sym.empty();
+        % condition volumes
+        kvolume = sym.empty();
+        % initial condition of states
+        initState = sym.empty();
+        % condition
+        condition = sym.empty();
+        % reaction fluxes
+        flux = sym.empty();
+        % reaction stochiometry
+        stochiometry = sym.empty();
+        % right hand side of reconstructed differential equation
+        xdot = sym.empty();
+        % event triggers
+        trigger = sym.empty();
+        % event boli
+        bolus = sym.empty();
+        % mathematical experessions for function
+        funmath = cell.empty();
+        % string function signature
+        funarg = cell.empty();
+        % symbol of time
+        time_symbol = char.empty();
+        % nominal parameters
+        pnom = double.empty();
+        % nominal conditions
+        knom = double.empty();
+    end
+    
+    methods
+        function model = SBMLode(filename)
+            % SBMLode extracts information from an SBML definition and
+            % stores it in a symbolic format
+            %
+            % Parameters:
+            %  filename: target name of the model (excluding the suffix
+            %  .xml/.sbml)
+            %
+            % Return values:
+            %
+            model.importSBML(filename);
+            model.checkODE();
+        end
+        
+        importSBML(this,filename)
+
+        checkODE(this)
+        
+        writeAMICI(this,modelname)
+        
+    end
+    
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/checkODE.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/checkODE.m
new file mode 100644
index 0000000000000000000000000000000000000000..c1bc2094771f8db0f137c873bd528e3a1311adfd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/checkODE.m
@@ -0,0 +1,16 @@
+function checkODE(this)
+    % checkODE checks whether the length of various variable names exceeds
+    % namelengthmax (would cause troube with symbolic processing later on).
+    %
+    % Parameters:
+    %
+    % Return values:
+    % void
+length_states = arrayfun(@(x) length(char(x)),this.state);
+assert(all(length_states<=namelengthmax),['Some species have identifiers are longer than ' num2str(namelengthmax) ' which MATLAB cannot handle, please shorten the identifiers!'])
+length_parameters = arrayfun(@(x) length(char(x)),this.parameter);
+assert(all(length_parameters<=namelengthmax),['Some parameters have identifiers are longer than ' num2str(namelengthmax) ' which MATLAB cannot handle, please shorten the identifiers!'])
+length_conditions = arrayfun(@(x) length(char(x)),this.condition);
+assert(all(length_conditions<=namelengthmax),['Some conditions have identifiers are longer than ' num2str(namelengthmax) ' which MATLAB cannot handle, please shorten the identifiers!'])
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/importSBML.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/importSBML.m
new file mode 100644
index 0000000000000000000000000000000000000000..9a179b041c8d774a49986546e13b4a2e8ce1eaca
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/importSBML.m
@@ -0,0 +1,774 @@
+function importSBML(this,filename)
+% importSBML parses information from the SBML definition and populates
+% the SBMLode object from this information.
+%
+% Parameters:
+%  filename: target name of the model
+%
+% Return values:
+%  void
+
+extension = [];
+if(exist([filename],'file'))
+    extension = '';
+elseif(exist([filename '.sbml'],'file'))
+    extension = '.sbml';
+    if(exist([filename '.xml'],'file'))
+        error(['Found both ' filename '.sbml and ' filename '.xml . please specify the filename with an explicit extension.']);
+    end
+elseif(exist([filename '.xml'],'file'))
+    extension = '.xml';
+else
+    error([filename ' could not be found in the matlab path!'])
+end
+
+if(~isempty(which('TranslateSBML')))
+    try
+        [model,err] = TranslateSBML([filename extension]);
+        if(~isempty(err))
+            error(err.message);
+        end
+    catch err
+        error(['TranslateSBML failed to read the provided sbml file: ' err.message ]);
+    end
+else
+    error('TranslateSBML is not available, please install libSBML and add TranslateSBML to your path');
+end
+
+if(isfield(model,'fbc_objective'))
+   error('Flux Balance Constraints are currently not supported!') 
+end
+
+%% COMPARTMENTS
+
+fprintf('loading compartments ...\n')
+
+% initialise
+compartments_sym = sym({model.compartment.id});
+this.compartment = compartments_sym;
+
+% set initial assignments
+if(isfield(model,'initialAssignment'))
+    initassignments_sym = sym({model.initialAssignment.symbol});
+    initassignments_math = cleanedsym({model.initialAssignment.math});
+else
+    initassignments_sym = sym([]);
+    initassignments_math = sym([]);
+end
+setInitialAssignment(this,model,'compartment',initassignments_sym,initassignments_math)
+
+% extract compartment sizes, default to 1
+this.compartment = subs(this.compartment,compartments_sym(logical([model.compartment.isSetSize])),sym([model.compartment.size]));
+
+% set remaining ones to default value 1
+this.compartment = subs(this.compartment,compartments_sym,sym(ones(size(compartments_sym))));
+
+%% RULES
+
+fprintf('applying rules ...\n')
+
+rule_types = {model.rule.typecode};
+if(any(strcmp(rule_types,'SBML_ALGEBRAIC_RULE')))
+    %DAE part TBD
+    error('Algebraic rules are currently not supported!');
+end
+
+all_rulevars = sym({model.rule.variable});
+if(any(arrayfun(@(x) ismember(x,compartments_sym),all_rulevars)))
+    error('Rules for compartments are currently not supported!');
+end
+all_rulemath = cleanedsym({model.rule.formula}); 
+% remove rate rules
+rulevars = all_rulevars(not(strcmp({model.rule.typecode},'SBML_RATE_RULE')));
+rulemath = all_rulemath(not(strcmp({model.rule.typecode},'SBML_RATE_RULE')));
+repeat_idx = ismember(rulevars,symvar(rulemath));
+while(any(repeat_idx))
+    rulemath= subs(rulemath,rulevars,rulemath);
+    repeat_idx = ismember(rulevars,symvar(rulemath));
+end
+
+applyRule(this,model,'compartment',rulevars,rulemath)
+
+%% SPECIES
+
+fprintf('loading species ...\n')
+
+% extract species
+species_sym = sym({model.species.id});
+species_sym = species_sym(:);
+this.state = species_sym;
+
+nx = length(this.state);
+
+% extract corresponding volumes
+compartments = sym(sanitizeString({model.species.compartment}));
+this.volume = subs(compartments(:),sym({model.compartment.id}),this.compartment);
+if(any(arrayfun(@(x) ~isempty(regexp(char(x),'[\w]+\(')),this.volume)))
+    error('Functions in volume definitions is currently not supported.')
+end
+
+initConcentration = [model.species.initialConcentration];
+initConcentration = initConcentration(:);
+initAmount = [model.species.initialAmount];
+initAmount = initAmount(:);
+this.initState = species_sym;
+hasAssignmentRule = ismember(this.state,all_rulevars(strcmp({model.rule.typecode},'SBML_ASSIGNMENT_RULE')))';
+hasRateRule = ismember(this.state,all_rulevars(strcmp({model.rule.typecode},'SBML_RATE_RULE')))';
+
+% set initial assignments
+setInitialAssignment(this,model,'initState',initassignments_sym,initassignments_math)
+
+
+
+% remove conditions species (boundary condition + no initialisation)
+if(~isempty(this.state))
+    cond_idx = all([logical([model.species.boundaryCondition]);transpose(logical(this.state==this.initState));~hasAssignmentRule;~hasRateRule]);
+    bound_idx = all([logical([model.species.boundaryCondition]);transpose(logical(this.state~=this.initState));~hasAssignmentRule;~hasRateRule]);
+    condition_sym = this.state(cond_idx);
+    conditions = this.state(cond_idx);
+    boundary_sym = this.state(bound_idx);
+    boundaries = this.initState(bound_idx);
+else
+    
+    cond_idx = [];
+    bound_idx = [];
+    condition_sym = sym([]);
+    conditions = sym([]);
+    boundary_sym = sym([]);
+    boundaries = sym([]);
+end
+
+nk = length(conditions);
+
+applyRule(this,model,'condition',rulevars,rulemath)
+
+% set initial concentrations
+concentration_idx = logical([model.species.isSetInitialConcentration]);
+onlysubstance_idx = logical([model.species.hasOnlySubstanceUnits]);
+this.initState = subs(this.initState,species_sym(concentration_idx),sym(initConcentration(concentration_idx)));
+
+% set initial amounts
+amount_idx = logical([model.species.isSetInitialAmount]);
+this.initState = subs(this.initState,species_sym(amount_idx),sym(initAmount(amount_idx))./this.volume(amount_idx));
+% this.initState = subs(this.initState,species_sym(amount_idx),sym(initAmount(amount_idx)));
+
+% apply rules
+applyRule(this,model,'initState',rulevars,rulemath)
+
+while(any(ismember(symvar(this.initState),this.state)))
+    this.initState = subs(this.initState,this.state,this.initState);
+end
+while(any(ismember(symvar(boundaries),this.state)))
+    boundaries = subs(boundaries,this.state,this.initState);
+end
+
+%% PARAMETERS
+
+fprintf('loading parameters ...\n')
+
+% extract this.param
+parameter_sym = sym({model.parameter.id});
+parameter_val = transpose([model.parameter.value]);
+parameter_sym = parameter_sym(:);
+this.param = parameter_sym;
+
+np = length(this.param);
+
+%% CONSTANTS
+
+% remove constant species
+const_idx = logical([model.species.constant]) & not(cond_idx);
+constant_sym = this.state(const_idx);
+
+this.knom = double(subs([this.initState(cond_idx);this.initState(const_idx)],parameter_sym,parameter_val));
+
+
+
+
+
+%% REACTIONS
+
+fprintf('parsing reactions ...\n')
+
+nr = length(model.reaction);
+if(nr>0)
+    for ir = 1:nr
+        if(model.reaction(ir).isSetFast)
+            if(model.reaction(ir).fast)
+                error('Fast reactions are currently not supported!');
+            end
+        end
+    end
+end
+
+kLaw = [cellfun(@(x) x.math,{model.reaction.kineticLaw},'UniformOutput',false)];
+
+checkIllegalFunctions(kLaw);
+
+this.flux = cleanedsym(kLaw);
+this.flux = this.flux(:);
+% add local parameters to global parameters, make them global by
+% extending them by the reaction_id string
+species_idx = transpose(sym(1:nx));
+if(length({model.reaction.id})>0)
+    try
+        tmp = cellfun(@(x,y) sym(cellfun(@(x) [x '_' y], ...
+                                 {x.parameter.id}, ...
+                                 'UniformOutput',false)), ...
+                      {model.reaction.kineticLaw}, ...
+                      {model.reaction.id}, ...
+                      'UniformOutput',false);
+        plocal = transpose([tmp{:}]);
+        tmp = cellfun(@(x) cellfun(@double,{x.parameter.value}),{model.reaction.kineticLaw},'UniformOutput',false);
+        pvallocal = transpose([tmp{:}]);
+        % replace local parameters by globalized ones
+        tmp = cellfun(@(x,y,z) subs(x,sym({y.parameter.id}), ...
+            sym(cellfun(@(x) [x '_' z],{y.parameter.id},'UniformOutput',false))),...
+            transpose(num2cell(this.flux)),...
+            {model.reaction.kineticLaw},...
+            {model.reaction.id},...
+            'UniformOutput',false);
+        this.flux = [tmp{:}];
+        this.flux = this.flux(:);
+        
+    catch
+        tmp = cellfun(@(x,y) sym(cellfun(@(x) [x '_' y],{x.localParameter.id},'UniformOutput',false)),{model.reaction.kineticLaw},arrayfun(@(x) ['r' num2str(x)],1:length({model.reaction.id}),'UniformOutput',false),'UniformOutput',false);
+        plocal = transpose([tmp{:}]);
+        tmp = cellfun(@(x) cellfun(@double,{x.localParameter.value}),{model.reaction.kineticLaw},'UniformOutput',false);
+        pvallocal = transpose([tmp{:}]);
+        % replace local parameters by globalized ones
+        tmp = cellfun(@(x,y,z) subs(x,sym({y.localParameter.id}),sym(cellfun(@(x) [x '_' z],{y.localParameter.id},'UniformOutput',false))),transpose(num2cell(this.flux)),{model.reaction.kineticLaw},arrayfun(@(x) ['r' num2str(x)],1:length({model.reaction.id}),'UniformOutput',false),'UniformOutput',false);
+        this.flux = [tmp{:}];
+        this.flux = this.flux(:);
+        
+    end
+    
+    this.param = [this.param;plocal];
+    parameter_sym = [parameter_sym;plocal];
+    parameter_val = [parameter_val;pvallocal];
+    np = length(this.param);
+    
+    reactants = cellfun(@(x) {x.species},{model.reaction.reactant},'UniformOutput',false);
+    % species index of the reactant
+    reactant_sidx = double(subs(sym(cat(2,reactants{:})),species_sym,species_idx));
+    % reaction index
+    tmp = cumsum(cell2mat(cellfun(@(x) [ones(1,1),zeros(1,max(length(x)-1,0))],reactants,'UniformOutput',false)));
+    wreact = cell2mat(cellfun(@(x) [ones(1,length(x)),zeros(1,isempty(x))],reactants,'UniformOutput',false));
+    reactant_ridx = tmp(logical(wreact));
+    products = cellfun(@(x) {x.species},{model.reaction.product},'UniformOutput',false);
+    % species index of the product
+    product_sidx = double(subs(sym(cat(2,products{:})),species_sym,species_idx));
+    % reaction index
+    tmp = cumsum(cell2mat(cellfun(@(x) [ones(1,1),zeros(1,max(length(x)-1,0))],products,'UniformOutput',false)));
+    wprod = cell2mat(cellfun(@(x) [ones(1,length(x)),zeros(1,isempty(x))],products,'UniformOutput',false));
+    product_ridx = tmp(logical(wprod));
+    if(model.SBML_level>=3)
+        reactant_stochiometry = cellfun(@(x) stoich_initAssign_rule(x,initassignments_sym,initassignments_math,rulevars,rulemath),{model.reaction.reactant},'UniformOutput',false);
+%         reactant_math = cellfun(@(x) sym({x.stoichiometry}),{model.reaction.reactant},'UniformOutput',false);
+        reactant_id = cellfun(@getId,{model.reaction.reactant},'UniformOutput',false);
+        product_stochiometry = cellfun(@(x) stoich_initAssign_rule(x,initassignments_sym,initassignments_math,rulevars,rulemath),{model.reaction.product},'UniformOutput',false);
+%         product_math = cellfun(@(x) sym({x.stoichiometry}),{model.reaction.product},'UniformOutput',false);
+        product_id = cellfun(@getId,{model.reaction.product},'UniformOutput',false);
+    else
+        % addition is necessary due to 1x0 struct that is returned by libSBML which is not properly handled by MATLAB,
+        % the concatenation is necessary because MATLAB treats 1x0 structs as empty input
+        symbolic_expr = @(x) num2cell(cell2sym(cellfun(@(z) math_expr(z),arrayfun(@(y) y.stoichiometryMath,x,'UniformOutput',false),'UniformOutput',false)) + sym(arrayfun(@(y) y.stoichiometry,x)).*arrayfun(@(y) isempty(y.stoichiometryMath),x));
+        reactant_stochiometry = cellfun(@(x) {symbolic_expr(x)},{model.reaction.reactant},'UniformOutput',false);
+        reactant_id = cellfun(@getId,{model.reaction.reactant},'UniformOutput',false);
+        product_stochiometry = cellfun(@(x) {symbolic_expr(x)},{model.reaction.product},'UniformOutput',false);
+        product_id = cellfun(@getId,{model.reaction.product},'UniformOutput',false);
+    end
+    eS = sym(zeros(nx,nr));
+    pS = sym(zeros(nx,nr));
+    tmp_rs = cellfun(@(x)[x{:}],reactant_stochiometry,'UniformOutput',false);
+    tmp_rs = [tmp_rs{:}];
+    tmp_rid = cat(2,reactant_id{:});
+    for iidx = 1:length(reactant_sidx)
+        if(strcmp(tmp_rid{iidx},''))
+            tmp = tmp_rs(iidx);
+        else
+            tmp = sym(tmp_rid{iidx});
+        end
+        eS(reactant_sidx(iidx),reactant_ridx(iidx)) = eS(reactant_sidx(iidx),reactant_ridx(iidx)) + tmp;
+    end
+    tmp_ps = cellfun(@(x)[x{:}],product_stochiometry,'UniformOutput',false);
+    tmp_ps = [tmp_ps{:}];
+    tmp_pid = cat(2,product_id{:});
+    for iidx = 1:length(product_sidx)
+        if(strcmp(tmp_pid{iidx},''))
+            tmp = tmp_ps(iidx);
+        else
+            tmp = sym(tmp_pid{iidx});
+        end
+        pS(product_sidx(iidx),product_ridx(iidx)) = pS(product_sidx(iidx),product_ridx(iidx)) + tmp;
+    end
+
+    this.stochiometry = - eS + pS;
+    
+    this.xdot = this.stochiometry*this.flux;
+else
+    this.xdot = sym(zeros(size(this.state)));
+end
+
+reactionsymbols = sym({model.reaction.id}');
+
+if(length({model.reaction.id})>0)
+    stoichsymbols = [reactant_id{:},product_id{:}];
+    stoichmath = [tmp_rs,tmp_ps];
+    
+    stoichidx = not(strcmp(stoichsymbols,''));
+    stoichsymbols = stoichsymbols(stoichidx);
+    stoichmath = stoichmath(stoichidx);
+else
+    stoichsymbols = sym([]);
+    stoichmath = sym([]);
+end
+
+%% RATE RULES
+
+fprintf('converting to concentrations ...\n')
+
+%extract model conversion factor
+if(isfield(model,'conversionFactor'))
+    if(strcmp(model.conversionFactor,''))
+        conversionfactor = sym(ones(nx,1));
+    else
+        conversionfactor = sym(model.conversionFactor)*ones(nx,1);
+    end
+else
+    conversionfactor = ones(nx,1);
+end
+
+if(isfield(model.species,'conversionFactor'))
+    if(any(not(strcmp({model.species.conversionFactor},''))))
+        tmp = {model.species.conversionFactor};
+        idx = ~strcmp({model.species.conversionFactor},'');
+        conversionfactor(idx) = sym(tmp(idx));
+    end
+end
+
+for irule = 1:length(model.rule)
+    if(strcmp(model.rule(irule).typecode,'SBML_RATE_RULE'))
+        state_rate_idx = find(this.state == sym(model.rule(irule).variable));
+        param_rate_idx = find(parameter_sym == sym(model.rule(irule).variable));
+        stoich_rate_idx = find(stoichsymbols == sym(model.rule(irule).variable));
+        if(~isempty(state_rate_idx))
+            this.xdot(state_rate_idx) = cleanedsym(model.rule(irule).formula);
+            if(~onlysubstance_idx(state_rate_idx))
+                this.xdot(state_rate_idx) = this.xdot(state_rate_idx).*this.volume(state_rate_idx);
+            end
+        elseif(~isempty(param_rate_idx))
+            this.state = [this.state; parameter_sym(param_rate_idx)];
+            this.xdot = [this.xdot; cleanedsym(model.rule(irule).formula)];
+            if(ismember(parameter_sym(param_rate_idx),initassignments_sym))
+                this.initState = [this.initState; initassignments_math(find(initassignments_sym==parameter_sym(param_rate_idx)))];
+            else
+                this.initState = [this.initState; parameter_val(param_rate_idx)];
+            end
+            this.volume = [this.volume; 1];
+            concentration_idx = [concentration_idx, false];
+            onlysubstance_idx = [onlysubstance_idx, false];
+            conversionfactor = [conversionfactor; 1];
+            cond_idx = [cond_idx, false ];
+            const_idx = [const_idx, false ];
+            bound_idx = [bound_idx, false];
+            nx = nx + 1;
+            parameter_val(param_rate_idx) = [];
+            parameter_sym(param_rate_idx) = [];
+            this.param(param_rate_idx) = [];
+            np = np - 1;
+            setInitialAssignment(this,model,'initState',initassignments_sym,initassignments_math);
+        elseif(~isempty(stoich_rate_idx))
+            this.state = [this.state; stoichsymbols(stoich_rate_idx)];
+            this.xdot = [this.xdot; cleanedsym(model.rule(irule).formula)];
+            this.initState = [this.initState; stoichmath(stoich_rate_idx)];
+            this.volume = [this.volume; 1];
+            concentration_idx = [concentration_idx, false];
+            onlysubstance_idx = [onlysubstance_idx, false];
+            conversionfactor = [conversionfactor; 1];
+            cond_idx = [cond_idx, false ];
+            const_idx = [const_idx, false ];
+            bound_idx = [bound_idx, false];
+            nx = nx + 1;
+            stoichmath(stoich_rate_idx) = [];
+            stoichsymbols(stoich_rate_idx) = [];
+        end
+    end
+    if(strcmp(model.rule(irule).typecode,'SBML_ASSIGNMENT_RULE'))
+        state_rate_idx = find(this.state == sym(model.rule(irule).variable));
+        param_rate_idx = find(parameter_sym == sym(model.rule(irule).variable));
+        if(~isempty(state_rate_idx))
+            this.state(state_rate_idx) = [];
+            this.xdot(state_rate_idx) = [];
+            this.initState(state_rate_idx) = [];
+            this.volume(state_rate_idx) = [];
+            concentration_idx(state_rate_idx) = [];
+            onlysubstance_idx(state_rate_idx) = [];
+            conversionfactor(state_rate_idx) = [];
+            cond_idx(state_rate_idx) = [];
+            const_idx(state_rate_idx) = [];
+            bound_idx(state_rate_idx) = [];
+            nx = nx-1;
+            this.observable = [this.observable;cleanedsym(model.rule(irule).formula)];
+            this.observable_name = [this.observable_name;sym(model.rule(irule).variable)];
+        end
+    end
+end
+
+applyRule(this,model,'xdot',rulevars,rulemath)
+
+
+%% CONVERSION FACTORS/VOLUMES
+
+% this.xdot = conversionfactor.*subs(this.xdot,this.state,this.state.*this.volume)./this.volume;
+this.xdot = conversionfactor.*subs(this.xdot,this.state(onlysubstance_idx),this.state(onlysubstance_idx).*this.volume(onlysubstance_idx))./this.volume;
+
+% this.xdot = conversionfactor.*this.xdot;
+
+%% EVENTS
+
+fprintf('loading events ...\n')
+
+if(sum(cellfun(@(x)numel(x),{model.event.delay})>0))
+    error('Events with delays are currently not supported!');
+end
+if(~strcmp(model.delay_symbol,''))
+    error('Delay symbols are currently not supported!');
+end
+if(model.SBML_level>=3)
+    if(sum(cellfun(@(x)numel(x),{model.event.priority})>0))
+        error('Event priorities are currently not supported!');
+    end
+end
+    
+try
+    tmp = cellfun(@(x) sym(sanitizeString(x)),{model.event.trigger},'UniformOutput',false);
+    this.trigger = [tmp{:}];
+catch
+    tmp = cellfun(@(x) sym(sanitizeString(x.math)),{model.event.trigger},'UniformOutput',false);
+    this.trigger = [tmp{:}];
+end
+this.trigger = this.trigger(:);
+this.trigger = subs(this.trigger,sym('ge'),sym('am_ge'));
+this.trigger = subs(this.trigger,sym('gt'),sym('am_gt'));
+this.trigger = subs(this.trigger,sym('le'),sym('am_le'));
+this.trigger = subs(this.trigger,sym('lt'),sym('am_lt'));
+
+this.bolus = sym(zeros([length(this.state),length(this.trigger)]));
+if(length(this.trigger)>0)
+    for ievent = 1:length(this.trigger)
+        tmp = cellfun(@(x) {x.variable},{model.event(ievent).eventAssignment},'UniformOutput',false);
+        assignments = sym(cat(2,tmp{:}));
+        
+        tmp = cellfun(@(x) {x.math},{model.event(ievent).eventAssignment},'UniformOutput',false);
+        assignments_math = cleanedsym(cat(2,tmp{:}));
+        
+        for iassign = 1:length(assignments)
+            state_assign_idx = find(assignments(iassign)==this.state);
+            param_assign_idx = find(assignments(iassign)==this.param);
+            cond_assign_idx = find(assignments(iassign)==condition_sym);
+            bound_assign_idx = find(assignments(iassign)==boundary_sym);
+            stoich_assign_idx = find(assignments(iassign)==stoichsymbols);
+            vol_assign_idx = find(assignments(iassign)==compartments_sym);
+            
+            if(np>0 && ~isempty(param_assign_idx))
+                error('Assignments of parameters via events are currently not supported')
+                this.param(param_assign_idx) = this.param(param_assign_idx)*heaviside(-this.trigger(ievent)) + assignments_math(iassign)*heaviside(this.trigger(ievent));
+            end
+            
+            if(nk>0 && ~isempty(cond_assign_idx))
+                error('Assignments of constants via events are currently not supported')
+                conditions(cond_assign_idx) = conditions(cond_assign_idx)*heaviside(-this.trigger(ievent)) + assignments_math(iassign)*heaviside(this.trigger(ievent));
+            end
+            
+            if(length(boundaries)>0 && ~isempty(bound_assign_idx))
+                error('Assignments of boundary conditions via events are currently not supported')
+                boundaries(bound_assign_idx) = conditions(bound_assign_idx)*heaviside(-this.trigger(ievent)) + assignments_math(iassign)*heaviside(this.trigger(ievent));
+            end
+            
+            if(length(stoichsymbols)>0 && ~isempty(stoich_assign_idx))
+                error('Assignments of stoichiometries via events are currently not supported')
+                stoichmath(stoich_assign_idx) = stoichmath(stoich_assign_idx)*heaviside(-this.trigger(ievent)) + assignments_math(iassign)*heaviside(this.trigger(ievent));
+            end
+            
+            if(length(compartments_sym)>0 && ~isempty(vol_assign_idx))
+                error('Assignments of compartment volumes via events are currently not supported')
+            end
+            
+            if(length(this.state)>0 && ~isempty(state_assign_idx))
+                
+                this.bolus(state_assign_idx,ievent) = -this.state(state_assign_idx);
+                addToBolus = sym(zeros(size(this.bolus(:,ievent))));
+                addToBolus(state_assign_idx) = assignments_math(iassign);
+                
+                this.bolus(:,ievent) = this.bolus(:,ievent) + addToBolus;
+            end
+
+        end
+    end
+else
+    addToBolus = sym([]);
+end
+
+
+
+
+%% FUNCTIONS
+
+fprintf('loading functions ...\n')
+
+tmp = cellfun(@(x) x(8:end-1),{model.functionDefinition.math},'UniformOutput',false);
+lambdas = cellfun(@(x)argScan(x),tmp);
+
+if(~isempty(lambdas))
+    this.funmath = cellfun(@(x) x{end},lambdas,'UniformOutput',false);
+    % temp replacement for any user defined function
+    tmpfun = cellfun(@(x) ['fun_' num2str(x)],num2cell(1:length(model.functionDefinition)),'UniformOutput',false);
+    this.funmath = strrep(this.funmath,{model.functionDefinition.id},tmpfun);
+    % replace helper functions
+    
+    checkIllegalFunctions(this.funmath);
+    this.funmath = replaceLogicalFunctions(this.funmath);
+    
+    this.funmath = strrep(this.funmath,tmpfun,{model.functionDefinition.id});
+    this.funarg = cellfun(@(x,y) [y '(' strjoin(transpose(x(1:end-1)),',') ')'],lambdas,replaceReservedFunctionIDs({model.functionDefinition.id}),'UniformOutput',false);
+    
+    % make functions available in this file
+    
+    for ifun = 1:length(this.funmath)
+        token = regexp(this.funarg(ifun),'\(([0-9\w\,]*)\)','tokens');
+        start = regexp(this.funarg(ifun),'\(([0-9\w\,]*)\)');
+        eval([replaceReservedFunctions(this.funarg{ifun}(1:(start{1}-1))) ' = @(' token{1}{1}{1} ')' this.funmath{ifun} ';']);
+    end
+end
+
+
+%% CLEAN-UP
+
+fprintf('cleaning up ...\n')
+
+% remove constant/condition states
+this.state(any([cond_idx;const_idx;bound_idx])) = [];
+this.kvolume = this.volume(any([cond_idx;const_idx;bound_idx]));
+this.volume(any([cond_idx;const_idx;bound_idx])) = [];
+this.initState(any([cond_idx;const_idx;bound_idx])) = [];
+this.xdot(any([cond_idx;const_idx;bound_idx])) = [];
+this.bolus(any([cond_idx;const_idx;bound_idx]),:) = [];
+
+% substitute with actual expressions, do this twice to resolve co-dependencies, do we need a loop here?
+makeSubs(this,boundary_sym,boundaries);
+makeSubs(this,condition_sym,conditions);
+makeSubs(this,compartments_sym,this.compartment);
+%makeSubs(this,stoichsymbols,stoichmath);
+makeSubs(this,reactionsymbols,this.flux);
+
+% set initial assignments
+for iIA = 1:length(initassignments_sym)
+    if(ismember(initassignments_sym(iIA),this.param))
+        if(ismember(sym(model.time_symbol),symvar(initassignments_math(iIA))))
+            error('Time dependent initial assignments are currently not supported!')
+        end          
+        param_idx =  find(initassignments_sym(iIA)==this.param);
+        parameter_sym(param_idx) = [];
+        parameter_val(param_idx) = [];
+        this.param(param_idx) = [];
+        this.xdot = subs(this.xdot,initassignments_sym(iIA),initassignments_math(iIA));
+        this.trigger = subs(this.trigger,initassignments_sym(iIA),initassignments_math(iIA));
+        this.bolus = subs(this.bolus,initassignments_sym(iIA),initassignments_math(iIA));
+        this.initState = subs(this.initState,initassignments_sym(iIA),initassignments_math(iIA));
+        this.param = subs(this.param,initassignments_sym(iIA),initassignments_math(iIA));
+        rulemath = subs(rulemath,initassignments_sym(iIA),initassignments_math(iIA));
+        np = np-1;
+    end  
+end
+applyRule(this,model,'param',rulevars,rulemath)
+
+makeSubs(this,parameter_sym(1:np),this.param);
+
+% apply rules to dynamics
+for irule = 1:length(rulevars)
+    eval(['syms ' strjoin(arrayfun(@char,rulevars(irule),'UniformOutput',false),' ') ' ' strrep(strrep(strjoin(arrayfun(@char,symvar(sym(rulemath(irule))),'UniformOutput',false),' '),'true',''),'false','')]);
+    eval(['rule = ' char(rulemath(irule)) ';']);
+    rule_idx = find(rulevars(irule)==this.state);
+    if(nx>0)
+        this.xdot(rule_idx) = jacobian(rule,this.state)*this.xdot;
+        this.initState(rule_idx) = rulemath(irule);
+        if(~isempty(this.bolus))
+            this.bolus(rule_idx,:) = jacobian(rule,this.state)*this.bolus;
+        end
+    end
+end
+
+state_vars = [symvar(this.xdot),symvar(this.initState)];
+event_vars = [symvar(this.bolus),symvar(this.trigger)];
+
+applyRule(this,model,'xdot',rulevars,rulemath)
+
+isUsedParam = or(ismember(parameter_sym,event_vars),ismember(parameter_sym,state_vars));
+isPartOfRule = and(ismember(parameter_sym,symvar(cleanedsym({model.rule.formula}))),ismember(parameter_sym,symvar(sym({model.rule.variable}))));
+isRuleVar = ismember(parameter_sym,sym({model.rule.variable}));
+hasAssignment = ismember(parameter_sym,initassignments_sym);
+this.parameter = parameter_sym(and(not(isRuleVar),not(isPartOfRule)));
+this.pnom = parameter_val(and(not(isRuleVar),not(isPartOfRule)));
+
+this.condition = [condition_sym;constant_sym];
+obs_idx = all([isRuleVar,not(isPartOfRule),not(isUsedParam),not(hasAssignment)],2);
+this.observable = [this.observable;this.param(obs_idx(1:length(this.param)))];
+this.observable_name = [this.observable_name;parameter_sym(obs_idx(1:length(this.param)))];
+
+equal_idx = logical(this.observable(:)==this.observable_name(:)); % this is the unused stuff
+this.observable(equal_idx) = [];
+this.observable_name(equal_idx) = [];
+
+this.observable = subs(this.observable,parameter_sym(1:np),this.param);
+this.observable = subs(this.observable,condition_sym,conditions);
+this.observable = subs(this.observable,boundary_sym,boundaries);
+this.observable = subs(this.observable,compartments_sym,this.compartment);
+this.observable = subs(this.observable,stoichsymbols,stoichmath);
+this.observable = subs(this.observable,reactionsymbols,this.flux);
+
+applyRule(this,model,'observable',rulevars,rulemath);
+
+this.time_symbol = model.time_symbol;
+
+prohibited = sym({'null','beta'});
+alt_prohib = sym({'null_sym','beta_sym'});
+this.parameter = subs(this.parameter,prohibited,alt_prohib);
+this.state = subs(this.state,prohibited,alt_prohib);
+this.condition = subs(this.condition,prohibited,alt_prohib);
+while(any(ismember(symvar(this.initState),this.state)))
+    this.initState = subs(this.initState,this.state,this.initState);
+end
+end
+
+function setInitialAssignment(this,~,field,initassignments_sym,initassignments_math)
+this.(field) = subs(this.(field),initassignments_sym,initassignments_math);
+end
+
+
+function applyRule(this,~,field,rulevars,rulemath)
+this.(field) = subs(this.(field),rulevars,rulemath);
+end
+
+function args = argScan(str)
+brl = computeBracketLevel(str);
+
+l1_idx = find(brl==0); % store indexes
+
+% find commas but only in lowest bracket level
+c_idx = strfind(str(brl==0),',');
+str(l1_idx(c_idx)) = '@'; % replace by something that should never occur in equations
+args = textscan(str,'%s','Whitespace','@');
+end
+
+function makeSubs(this,old,new)
+this.xdot = subs(this.xdot,old,new);
+this.trigger = subs(this.trigger,old,new);
+this.bolus = subs(this.bolus,old,new);
+this.initState = subs(this.initState,old,new);
+end
+
+function checkIllegalFunctions(str)
+
+if(any(cell2mat(strfind(str,'factorial'))))
+    error('Factorial functions are currently not supported!')
+end
+if(any(cell2mat(strfind(str,'ceil'))))
+    error('Ceil functions are currently not supported!')
+end
+if(any(cell2mat(strfind(str,'floor'))))
+    error('Floor functions are currently not supported!')
+end
+end
+
+function csym = cleanedsym(str)
+if(nargin>0)
+    matVer = ver('MATLAB');
+    if(str2double(matVer.Version)>=9.4)
+        csym = str2sym(sanitizeString(strrep(str,'time','__time_internal_amici__')));
+    else
+        csym = sym(sanitizeString(strrep(str,'time','__time_internal_amici__')));
+    end
+    csym = subs(csym,sym('__time_internal_amici__'),sym('time'));
+else
+    csym = sym(0);
+end
+end
+
+function str = sanitizeString(str)
+% wrapper for replaceDiscontinuousFunctions() and replaceReservedFunctions()
+str = replaceLogicalFunctions(str);
+str = replaceReservedFunctions(str);
+end
+
+function str = replaceLogicalFunctions(str)
+% replace imcompatible piecewise defintion
+% execute twice for directly nested calls (overlapping regexp expressions)
+for logicalf = {'piecewise','and','or','lt','gt','ge','le','ge','le','xor','eq'}
+    str = regexprep(str,['^' logicalf{1} '('],['am_' logicalf{1} '(']);
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+end
+end
+
+function str = replaceReservedFunctions(str)
+% replace reserved matlab functions
+
+if(strcmp(str,'this'))
+    error('SBML functions may not be called ''this''');
+end
+
+for logicalf = {'divide','minus','multiply','plus'}
+    str = regexprep(str,['^' logicalf{1} '('],['am_' logicalf{1} '(']);
+    % execute twice for directly nested calls (overlapping regexp expressions)
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+end
+end
+
+function str = replaceReservedFunctionIDs(str)
+% replace reserved matlab functions
+for logicalf = {'divide','minus','multiply','plus'}
+    str = regexprep(str,['^' logicalf{1} '$'],['am_' logicalf{1} '']);
+end
+end
+
+function z = delay(x,y)
+error('Events with delays are currently not supported!');
+end
+
+function x = stoich_initAssign_rule(y,initassignments_sym,initassignments_math,rulevars,rulemath)
+x = {};
+for iy = 1:length(y)
+    x{iy} = sym(y(iy).stoichiometry);
+    if(~isempty(sym(y(iy).id)))
+        if(~isempty(initassignments_sym))
+            if(ismember(sym(y(iy).id),initassignments_sym))
+                x{iy} = subs(sym(y(iy).id),initassignments_sym,initassignments_math);
+            end
+        end
+        if(~isempty(rulevars))
+            if(ismember(sym(y(iy).id),rulevars))
+                x{iy} = subs(sym(y(iy).id),rulevars,rulemath);
+            end
+        end
+    end
+end
+end
+
+function expr = math_expr(y)
+    if(isfield(y,'math'))
+    expr = cleanedsym(y.math);
+    else
+    expr = cleanedsym();       
+    end
+end
+
+function id = getId(x)
+    if(isfield(x,'id'))
+        id = {x.id};
+    else
+        id = {x.species};
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/writeAMICI.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/writeAMICI.m
new file mode 100644
index 0000000000000000000000000000000000000000..422a805150e37ced05dbe3ce46289e0e5d59eef3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/@SBMLode/writeAMICI.m
@@ -0,0 +1,102 @@
+function writeAMICI(this,modelname)
+    % writeAMICI writes the symbolic information from an SBMLode object
+    % into an AMICI model definition file
+    %
+    % Parameters:
+    %  modelname: target name of the model (_syms.m will be appended to the name )
+    %
+    % Return values:
+    % void
+    
+    fprintf('writing file ...\n')
+    fid = fopen([modelname '_syms.m'],'w');
+    
+    fprintf(fid,['function model = ' modelname '_syms()\n']);
+    fprintf(fid,'\n');
+    if(strcmp(this.time_symbol,''))
+        fprintf(fid,'t = sym(''t'');\n');
+    else
+        fprintf(fid,[this.time_symbol ' = sym(''t'');\n']);
+    end
+    fprintf(fid,'\n');
+    fprintf(fid,'avogadro = 6.02214179e23;');
+    
+%     fprintf(fid,'model.debug = true;\n');
+    writeDefinition('STATES','x','state',this,fid)
+    writeDefinition('PARAMETERS','p','parameter',this,fid)
+    writeDefinition('CONDITIONS','k','condition',this,fid)
+    writeDerived('DYNAMICS','xdot','xdot',this,fid)
+    writeDerived('INITIALIZATION','x0','initState',this,fid)
+    writeDerived('OBSERVABLES','y','observable',this,fid)
+    fprintf(fid,'\n');
+    fprintf(fid,'\n');
+    fprintf(fid,['% EVENTS\n']);
+    for ievent = 1:length(this.trigger)
+        str_trigger = char(this.trigger(ievent));
+        str_bolus = strjoin(arrayfun(@char,this.bolus(:,ievent),'UniformOutput',false),',');
+        fprintf(fid,['model.event(' num2str(ievent) ') = amievent(' ...
+            str_trigger ', ...\n' ...
+            '[' str_bolus '], ...\n' ...
+            '[]);\n']);
+    end
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'function r = pow(x,y)\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'    r = x^y;\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'function r = power(x,y)\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'    r = x^y;\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    
+    for ifun = 1:length(this.funmath)
+        fprintf(fid,['function r = ' this.funarg{ifun} '\n']);
+        fprintf(fid,'\n');
+        fprintf(fid,['    r = ' this.funmath{ifun} ';\n']);
+        fprintf(fid,'\n');
+        fprintf(fid,'end\n');
+        fprintf(fid,'\n');
+    end 
+    
+    for fun = {'factorial','cei','psi'}
+        fprintUnsupportedFunctionError(fun{1},fid)
+    end
+    
+    fclose(fid);
+end
+
+function writeDefinition(header,identifier,field,this,fid)
+    fprintf(fid,'\n');
+    fprintf(fid,'\n');
+    fprintf(fid,['%%%%\n%% ' header '\n']);
+    if(length(this.(field))>0)
+        fprintf(fid,['syms ' strjoin(cellfun(@char,num2cell(this.(field)),'UniformOutput',false)) '\n']);
+    end
+    fprintf(fid,['model.sym.' identifier ' = [' strjoin(cellfun(@char,num2cell(this.(field)),'UniformOutput',false),',') '];\n']);
+end
+
+function writeDerived(header,identifier,field,this,fid)
+    fprintf(fid,'\n');
+    fprintf(fid,'\n');
+    fprintf(fid,['%%%%\n%% ' header '\n']);
+    fprintf(fid,'\n');
+    if(strcmp(header,'OBSERVABLES'))
+        fprintf(fid,['%% ' strjoin(cellfun(@char,num2cell(this.observable_name),'UniformOutput',false),'\n%% ')  '\n']);
+    end
+    fprintf(fid,['model.sym.' identifier ' = [' strjoin(cellfun(@char,num2cell(this.(field)),'UniformOutput',false),', ...\n') '];']);
+end
+
+function fprintUnsupportedFunctionError(functionName,fid)
+    fprintf(fid,['function r = ' functionName '(x)\n']);
+    fprintf(fid,'\n');
+    fprintf(fid,['    error(''The ' functionName ' function is currently not supported!'');\n']);
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/LICENSE b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..38d252073e1304268d94c744e3b540ca55d8d75c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2017, Data-driven Computational Modelling
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/README.md b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3336013a867809686b55e3c4c9f70d95e05a4a81
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/README.md
@@ -0,0 +1,2 @@
+# SBMLimporter
+MATLAB toolbox to generate ODE models from SBML files
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/computeBracketLevel.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/computeBracketLevel.m
new file mode 100644
index 0000000000000000000000000000000000000000..ec1c6621dbf927d3e2a7b556281b96d4dc46beec
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/SBMLimporter/computeBracketLevel.m
@@ -0,0 +1,29 @@
+function [ brl ] = computeBracketLevel( cstr )
+    % Compute the bracket level for the input string cstr. The bracket
+    % level is computed for every char in cstr and indicates how many
+    % brackets have been opened up to this point. The bracket level is
+    % useful to parse the arguments of functions in cstr. For this purpose
+    % functions will have the same bracket level as the opening bracket of
+    % the corresponding function call.
+    %
+    % Parameters:
+    %  cstr: input string @type *char
+    %
+    % Return values:
+    %  brl: bracket levels @type *int
+    
+    % compute bracket levels add one for each (, (before) remove 1 for each
+    % ) (after)
+    open = (cstr == '(');
+    close = (cstr == ')');
+    close = [0,close(1:end-1)];
+    brl = cumsum(open) - cumsum(close);
+    % take care of functions
+    fun_startidx = regexp(cstr,'([\w_]+\()','start');
+    fun_endidx = regexp(cstr,'([\w_]+\()','end');
+    for ifun = 1:length(fun_startidx)
+        brl(fun_startidx(ifun):(fun_endidx(ifun)-1)) = brl(fun_endidx(ifun));
+    end
+    
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/amiwrap.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/amiwrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..c8d889b01bd652c071509de82b1fce6644bde99d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/amiwrap.m
@@ -0,0 +1,216 @@
+function amiwrap( varargin )
+    % AMIWRAP generates c++ mex files for the simulation of systems of differential equations via CVODES and IDAS.
+    %
+    % Parameters:
+    %  varargin:
+    %  modelname: specifies the name of the model which will be later used for the naming of the simulation file @type string
+    %  symfun: specifies a function which executes model definition see @ref matlab_interface for details @type string.
+    %  tdir: target directory where the simulation file should be placed @type string @default $AMICIDIR/models/modelname
+    %  o2flag: boolean whether second order sensitivities should be enabled @type boolean @default false
+    %
+    % Return values:
+    %  void
+    
+    matVer = ver('MATLAB');
+    if(str2double(matVer.Version) >= 9.4)
+        error('MATLAB R2018a or higher is currently not supported (see https://github.com/ICB-DCM/AMICI/issues/307)')
+    end
+    
+    %% 
+    % check for MSVS
+    if(~isempty(strfind(mex.getCompilerConfigurations('c++').Name,'Microsoft Windows')) || ~isempty(strfind(mex.getCompilerConfigurations('c++').Name,'Microsoft Visual')))
+        warning('AMICI does not officially support Microsoft Visual Studio Compilers. If the compilation fails, we recommend using MinGW.')
+    end
+    
+    %%
+    % check inputs
+    if(nargin<2)
+        error('Must provide modelname and symfun.')
+    end
+    modelname = varargin{1}; % this is the target modelname
+    if(~ischar(modelname))
+        error('modelname must be a string.')
+    end
+    symfun = varargin{2}; % this is the function which generates the symbolic struct
+    if nargin > 2
+        tdir = varargin{3};
+    else
+        tdir = pwd;
+    end
+    
+    if nargin > 3
+        o2flag = varargin{4};
+        if(~ismember(o2flag,[0,1,2]))
+            error('Parameter o2flag must have value 0, 1 or 2.');
+        end
+    else
+        o2flag = false;
+    end
+    
+    
+    if(isempty(mex.getCompilerConfigurations('C')))
+        error('No C compiler setup. Please install and configure with MATLAB')
+    end
+    if(~isempty(tdir))
+        if(exist(tdir,'file') ~= 7)
+            error('provided tdir is not a valid path')
+        end
+    end
+    
+    warningreset = warning;
+    warning('off','symbolic:mupadmex:MuPADTextWarning')
+    warning('off','MATLAB:dispatcher:nameConflict')
+    warning('off','symbolic:sym:sym:DeprecateExpressions')
+    warning('off','symbolic:generate:FunctionNotVerifiedToBeValid')
+    
+    %% 
+    % Display AMICI version
+    disp(['amiwrap version ' getCommitHash(fileparts(mfilename('fullpath')))])
+    
+    %% 
+    % computations
+    matlabRootPath=fileparts(mfilename('fullpath'));
+    amiciRootPath=fileparts(matlabRootPath);
+    
+    addpath(genpath(fullfile(matlabRootPath,'auxiliary')));
+    addpath(fullfile(matlabRootPath,'symbolic'));
+    
+    % compile CalcMD5 if necessary
+    try
+        CalcMD5('TEST','char','hex');
+    catch
+        try
+            addpath(fullfile(matlabRootPath,'auxiliary','CalcMD5'))
+            CalcMD5('TEST','char','hex');
+        catch
+            disp('CalcMD5 has not been compiled yet. Compiling now!')
+            tmpdir = pwd;
+            cd(fullfile(matlabRootPath,'auxiliary','CalcMD5'))
+            mex(fullfile(matlabRootPath,'auxiliary','CalcMD5','CalcMD5.c'))
+            addpath(fullfile(matlabRootPath,'auxiliary','CalcMD5'))
+            cd(tmpdir);
+        end
+    end
+    
+    % try to load
+    if(~isstruct(symfun))
+        if(exist(symfun,'file')==2)
+            model_hash = CalcMD5(which(symfun),'File');
+        else
+            model_hash = [];
+        end
+    else
+        model_hash = [];
+    end
+    
+    commit_hash = getCommitHash(amiciRootPath);
+    
+    if(~exist(fullfile(amiciRootPath,'models',modelname),'dir'))
+        mkdir(fullfile(amiciRootPath,'models',modelname));
+    end
+    addpath(fullfile(amiciRootPath,'models',modelname));
+    if(exist([commit_hash '_' model_hash '.mat'],'file')==2);
+        load([commit_hash '_' model_hash '.mat']);
+        % update modelname according to this function call
+        model.updateModelName(modelname);
+        % update wrap_path to this function call
+        model.updateWrapPath(amiciRootPath);
+    end
+    
+    if(~exist('model','var'))
+        disp('Generating model struct ...')
+        model = amimodel(symfun,modelname);
+        
+
+        if(~isempty(model_hash) && ~isempty(commit_hash))
+            save(fullfile(amiciRootPath,'models',modelname,[commit_hash '_' model_hash]),'model')
+        end
+    end
+    
+    switch(o2flag)
+        case 0 
+            o2string = [];
+        case 1
+            o2string = 'o2';
+        case 2
+            o2string = 'o2vec';
+    end
+    
+    if(~isempty(o2string))
+        o2_hash = CalcMD5(fullfile(matlabRootPath,'@amimodel',['augment' o2string '.m']),'File');
+        try
+            if(~exist(fullfile(amiciRootPath,'models',[modelname '_' o2string]),'dir'))
+                mkdir(fullfile(amiciRootPath,'models',[modelname '_' o2string]));
+            end
+           addpath(fullfile(amiciRootPath,'models',[modelname '_' o2string])); 
+        end
+        if(exist([commit_hash '_' model_hash '_' o2_hash '.mat'],'file')==2);
+            load([commit_hash '_' model_hash '_' o2_hash '.mat']);
+            % update modelname according to this function call
+            modelo2.updateModelName([modelname '_' o2string]);
+            % update wrap_path to this function call
+            modelo2.updateWrapPath(amiciRootPath);
+        end
+        if(~exist('modelo2','var'))
+            disp('Augmenting to second order ...')
+            modelo2 = feval(['augment' o2string],model);
+            
+            
+            if(~isempty(model_hash) && ~isempty(commit_hash))
+                save(fullfile(amiciRootPath,'models',[modelname '_' o2string],[commit_hash '_' model_hash '_' o2_hash]),'modelo2')
+            end
+        end
+    end
+    
+    disp('Parsing model struct ...')
+    model.parseModel();
+    if(o2flag)
+        modelo2.parseModel();
+    end
+
+    % generate C code out of symbolic computations
+    disp('Generating C code ...')
+    model.generateC();
+    if(o2flag)
+        modelo2.generateC();
+    end
+    
+    % compile the previously generated C code
+    disp('Compiling mex file ...')
+    model.compileC();
+    if(o2flag)
+        modelo2.compileC();
+    end
+    
+    % generate the matlab wrapper
+    disp('Generating M code ...')
+    if(o2flag)
+        model.generateM(modelo2);
+    else
+        model.generateM([]);
+    end
+    
+    if(~isempty(tdir))
+        clear(['simulate_' modelname ]);
+        clear(['ami_' modelname ]);
+        clear(['ami_' modelname o2string]);
+        movefile(fullfile(amiciRootPath,'models',modelname,['simulate_' modelname '.m']),fullfile(tdir,['simulate_' modelname '.m']));
+        movefile(fullfile(amiciRootPath,'models',modelname,['ami_' modelname '.' mexext]),fullfile(tdir,['ami_' modelname '.' mexext]));
+        % make files available in the path
+        tmp = which(fullfile(tdir,['simulate_' modelname '.m']));
+        tmp = which(fullfile(tdir,['ami_' modelname '.' mexext]));
+        for fun = model.mfuns
+            copyfile(fullfile(amiciRootPath,'models',modelname,[fun{1} '_' modelname '.m']),fullfile(tdir,[fun{1} '_' modelname '.m']));
+            tmp = which(fullfile(tdir,[fun{1} '_' modelname '.m']));
+        end
+        % clear .m and .mex files from memory
+        if(~isempty(o2string))
+            movefile(fullfile(amiciRootPath,'models',[modelname '_' o2string],[ 'ami_' modelname '_' o2string '.' mexext]),fullfile(tdir,['ami_' modelname '_' o2string '.' mexext]));
+            tmp = which(fullfile(tdir,['ami_' modelname '_' o2string '.' mexext]));
+        end
+    else
+        addpath(fullfile(amiciRootPath,'models',modelname));
+    end
+    warning(warningreset);
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/CalcMD5.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/CalcMD5.m
new file mode 100644
index 0000000000000000000000000000000000000000..687f1138e2f26c2ea3c94d22a3cd88cf6e89772b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/CalcMD5.m
@@ -0,0 +1,71 @@
+function MD5 = CalcMD5(Data, InClass, OutClass)  %#ok<STOUT,INUSD>
+% 128 bit MD5 checksum: file, string, byte stream [MEX]
+% This function calculates a 128 bit checksum for arrays and files.
+% Digest = CalcMD5(Data, [InClass], [OutClass])
+% INPUT:
+%   Data:   Data array or file name. Either numerical or CHAR array.
+%           Currently only files and arrays with up to 2^32 bytes (2.1GB) are
+%           accepted.
+%   InClass: String to declare the type of the 1st input.
+%           Optional. Default: 'Char'.
+%           'File': [Data] is a file name as string. The digest is calculated
+%                   for this file.
+%           'Char': [Data] is a char array to calculate the digest for. Only the
+%                   ASCII part of the Matlab CHARs is used, such that the digest
+%                   is the same as if the array is written to a file as UCHAR,
+%                   e.g. with FWRITE.
+%           'Unicode': All bytes of the input [Data] are used to calculate the
+%                   digest. This is the standard for numerical input.
+%   OutClass: String, format of the output. Just the first character matters.
+%           Optional, default: 'hex'.
+%           'hex': [1 x 32] string as lowercase hexadecimal number.
+%           'HEX': [1 x 32] string as uppercase hexadecimal number.
+%           'Dec': [1 x 16] double vector with UINT8 values.
+%           'Base64': [1 x 22] string, encoded to base 64 (A:Z,a:z,0:9,+,/).
+%
+% OUTPUT:
+%   Digest: A 128 bit number is replied in a format depending on [OutClass].
+%           The chance, that different data sets have the same MD5 sum is about
+%           2^128 (> 3.4 * 10^38). Therefore MD5 can be used as "finger-print"
+%           of a file rather than e.g. CRC32.
+%
+% EXAMPLES:
+%   Three methods to get the MD5 of a file:
+%   1. Direct file access (recommended):
+%     MD5 = CalcMD5(which('CalcMD5.m'), 'File')
+%   2. Import the file to a CHAR array (binary mode for exact line breaks!):
+%     FID = fopen(which('CalcMD5.m'), 'rb');
+%     S   = fread(FID, inf, 'uchar=>char');
+%     fclose(FID);
+%     MD5 = CalcMD5(S, 'char')
+%   3. Import file as a byte stream:
+%     FID = fopen(which('CalcMD5.m'), 'rb');
+%     S   = fread(FID, inf, 'uint8=>uint8');
+%     fclose(FID);
+%     MD5 = CalcMD5(S, 'unicode');  // 'unicode' can be omitted here
+%
+%   Test string:
+%     CalcMD5(char(0:511), 'char', 'HEX')
+%       => F5C8E3C31C044BAE0E65569560B54332
+%     CalcMD5(char(0:511), 'unicode', 'HEX')
+%       => 3484769D4F7EBB88BBE942BB924834CD
+%
+% Tested: Matlab 6.5, 7.7, 7.8, WinXP, [UnitTest]
+% Author: Jan Simon, Heidelberg, (C) 2009-2010 J@n-Simon.De
+% License: This program is derived from the RSA Data Security, Inc.
+%          MD5 Message Digest Algorithm, RFC 1321, R. Rivest, April 1992
+%
+% See also CalcCRC32.
+% Michael Kleder has published a Java call to compute the MD5 (and further
+% check sums): http://www.mathworks.com/matlabcentral/fileexchange/8944
+
+% $JRev: R5.00j V:015 Sum:zh2gTrvHwbd7 Date:17-Dec-2009 02:46:53 $
+% $File: CalcMD5\CalcMD5.m $
+% History:
+% 015: 15-Dec-2009 16:53, BUGFIX: UINT32 has 32 bits on 64 bit systems now.
+%      Thanks to Sebastiaan Breedveld!
+
+% If the current Matlab path is the parent folder of this script, the
+% MEX function is not found - change the current directory!
+error(['JSim:', mfilename, ':NoMex'], 'Cannot find MEX script.');
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/TestCalcMD5.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/TestCalcMD5.m
new file mode 100644
index 0000000000000000000000000000000000000000..5cc14e4d2feaca5e3885b738aaed3b601f7869b6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/TestCalcMD5.m
@@ -0,0 +1,191 @@
+function TestCalcMD5(doSpeed)
+% Automatic test: CalcMD5 (Mex)
+% This is a routine for automatic testing. It is not needed for processing and
+% can be deleted or moved to a folder, where it does not bother.
+%
+% TestCalcMD5(doSpeed)
+% INPUT:
+%   doSpeed: Optional logical flag to trigger time consuming speed tests.
+%            Default: TRUE. If no speed test is defined, this is ignored.
+% OUTPUT:
+%   On failure the test stops with an error.
+%   The speed is compared to a Java method.
+%
+% Tested: Matlab 6.5, 7.7, 7.8, WinXP
+% Author: Jan Simon, Heidelberg, (C) 2009-2010 J@n-Simon.De
+
+% $JRev: R5.00g V:013 Sum:uNknB6D/Ksze Date:12-Dec-2009 00:14:15 $
+% $File: CalcMD5\TestCalcMD5.m $
+
+% Initialize: ==================================================================
+% Global Interface: ------------------------------------------------------------
+FuncName = 'TestCalcMD5';  % $Managed by AutoFuncPath$
+
+% Initial values: --------------------------------------------------------------
+if nargin == 0
+   doSpeed = true;
+end
+
+% Program Interface: -----------------------------------------------------------
+% User Interface: --------------------------------------------------------------
+% Do the work: =================================================================
+disp(['==== Test CalcMD5,  ', datestr(now, 0)]);
+
+TestData = {'', 'd41d8cd98f00b204e9800998ecf8427e'; ...
+      'a', '0cc175b9c0f1b6a831c399e269772661'; ...
+      'abc', '900150983cd24fb0d6963f7d28e17f72'; ...
+      'message digest', 'f96b697d7cb7938d525a2f31aaf161d0'; ...
+      'abcdefghijklmnopqrstuvwxyz', 'c3fcd3d76192e4007dfb496cca67e13b'; ...
+      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', ...
+      'd174ab98d277d9f5a5611c2c9f419d9f'; ...
+      ['123456789012345678901234567890123456789012345678901234567890123456', ...
+         '78901234567890'], '57edf4a22be3c955ac49da2e2107b67a'; ...
+      char(0:255), 'e2c865db4162bed963bfaa9ef6ac18f0'};  % Not in RFC1321
+
+fprintf('  Known answer test from RFC 1321 for strings and files:');
+TestFile = tempname;
+
+% Loop over test data:
+for iTest = 1:size(TestData, 1)
+   % Check string input:
+   Str = CalcMD5(TestData{iTest, 1}, 'char');
+   if strcmpi(Str, TestData{iTest, 2}) == 0
+      fprintf('\n');
+      error(['*** ', FuncName, ': Failed for string:', ...
+            char(10), '[', TestData{iTest, 1}, ']']);
+   end
+   
+   % Check file input:
+   FID = fopen(TestFile, 'wb+');
+   if FID < 0
+      fprintf('\n');
+      error(['*** ', FuncName, ': Cannot open test file [', TestFile, ']']);
+   end
+   fwrite(FID, TestData{iTest, 1}, 'uchar');
+   fclose(FID);
+   
+   Str2 = CalcMD5(TestFile, 'file');
+   if strcmpi(Str2, TestData{iTest, 2}) == 0
+      fprintf('\n');
+      error(['*** ', FuncName, ': Failed for file:', ...
+            char(10), '[', TestData{iTest, 1}, ']']);
+   end
+end
+fprintf(' ok\n');
+delete(TestFile);
+
+% Check different output types:
+N = 1000;
+fprintf('  %d random tests with hex, HEX, dec and base64 output: ', N);
+for i = 1:N
+   data      = uint8(fix(rand(1, 1 + fix(rand * 100)) * 256));
+   lowHexOut = CalcMD5(data, 'char', 'hex');
+   upHexOut  = CalcMD5(data, 'char', 'HEX');
+   decOut    = CalcMD5(data, 'char', 'Dec');
+   b64Out    = CalcMD5(data, 'char', 'Base64');
+   
+   if not(strcmpi(lowHexOut, upHexOut) && ...
+         isequal(sscanf(lowHexOut, '%2x'), decOut(:)) && ...
+         isequal(Base64decode(b64Out), decOut))
+      fprintf('\n');
+      error(['*** ', FuncName, ': Different results for output types.']);
+   end
+   
+   % Check unicode, if the data length is a multiple of 2:
+   if rem(length(data), 2) == 0
+      doubleData = double(data);
+      uniData    = char(doubleData(1:2:end) + 256 * doubleData(2:2:end));
+      uniOut     = CalcMD5(uniData, 'unicode', 'dec');
+      if not(isequal(uniOut, decOut))
+         fprintf('\n');
+         error(['*** ', FuncName, ': Different results for unicode input.']);
+      end
+   end
+end
+fprintf('ok\n');
+fprintf('  Unicode input: ok\n\n');
+
+% Speed test: ------------------------------------------------------------------
+if doSpeed
+   disp('== Test speed:');
+   disp('(Short data: mainly the overhead of calling the function)');
+   Delay = 2;
+   
+   for Len = [10, 100, 1000, 10000, 1e5, 1e6, 1e7]
+      [Number, Unit] = UnitPrint(Len);
+      fprintf('  Data length: %s %s:\n', Number, Unit);
+      data = uint8(fix(rand(1, Len) * 256));
+      
+      % Measure java time:
+      iniTime  = cputime;
+      finTime  = iniTime + Delay;
+      javaLoop = 0;
+      while cputime < finTime
+         x        = java.security.MessageDigest.getInstance('MD5');
+         x.update(data);
+         javaHash = double(typecast(x.digest, 'uint8'));
+         javaLoop = javaLoop + 1;
+      end
+      javaLoopPerSec = javaLoop / (cputime - iniTime);
+      [Number, Unit] = UnitPrint(javaLoopPerSec * Len);
+      fprintf('    java: %6s %s/sec\n', Number, Unit);
+      
+      % Measure Mex time:
+      iniTime = cputime;
+      finTime = iniTime + Delay;
+      mexLoop = 0;
+      while cputime < finTime
+         mexHash = CalcMD5(data, 'char', 'dec');
+         mexLoop = mexLoop + 1;
+      end
+      mexLoopPerSec = mexLoop / (cputime - iniTime);
+      [Number, Unit] = UnitPrint(mexLoopPerSec * Len);
+      fprintf('    mex:  %6s %s/sec: %.1f times faster\n', ...
+         Number, Unit, mexLoopPerSec / javaLoopPerSec);
+      
+      % Compare the results:
+      if ~isequal(javaHash(:), mexHash(:))
+         error(['*** ', FuncName, ': Different results from java and Mex.']);
+      end
+   end
+end
+
+fprintf('\nCalcMD5 seems to work well.\n');
+   
+return;
+
+% ******************************************************************************
+function Out = Base64decode(In)
+% Decode from base 64
+
+% Initialize: ==================================================================
+Pool = [65:90, 97:122, 48:57, 43, 47];  % [0:9, a:z, A:Z, +, /]
+v8   = [128, 64, 32, 16, 8, 4, 2, 1];
+v6   = [32; 16; 8; 4; 2; 1];
+
+% Do the work: =================================================================
+In          = reshape(In, 1, []);
+Table       = zeros(1, 256);
+Table(Pool) = 1:64;
+Value       = Table(In) - 1;
+
+X   = rem(floor(Value(ones(6, 1), :) ./ v6(:, ones(length(In), 1))), 2);
+Out = v8 * reshape(X(1:fix(numel(X) / 8) * 8), 8, []);
+
+return;
+
+% ******************************************************************************
+function [Number, Unit] = UnitPrint(N)
+
+if N < 1000
+   Number = sprintf('%d', round(N));
+   Unit   = 'Byte';
+elseif N < 1e6
+   Number = sprintf('%.1f', N / 1000);
+   Unit   = 'kB';
+else
+   Number = sprintf('%.1f', N / 1e6);
+   Unit   = 'MB';
+end
+
+return;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/license.txt b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..02a898748158629c113c8512ecd211dfd64d3a05
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/CalcMD5/license.txt
@@ -0,0 +1,24 @@
+Copyright (c) 2009, Jan Simon
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/am_setdefault.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/am_setdefault.m
new file mode 100644
index 0000000000000000000000000000000000000000..bb3f0c533fb5d20db87f28f664c99dcc75f6ddc4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/am_setdefault.m
@@ -0,0 +1,15 @@
+function robj = am_setdefault(obj,dobj)
+    % sets the undefined fields of the struct obj to the default values specified in the default struct dobj.
+    %
+    % Parameters:
+    %  obj: struct which is supposed to be updated based on default struct @type struct
+    %  dobj: obj which carries d fields @type struct
+    %
+    % Return values:
+    %  robj: updated obj @type struct
+    
+    fieldlist = fieldnames(obj);
+    for i = 1:length(fieldlist)
+        dobj.(fieldlist{i}) = obj.(fieldlist{i});
+    end
+    robj = dobj;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/ami_mfun.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/ami_mfun.m
new file mode 100644
index 0000000000000000000000000000000000000000..2873445e2f08d5863795e7aa62e3260b97b5932c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/ami_mfun.m
@@ -0,0 +1,225 @@
+function g = mfun(f,varargin)
+% adapted from matlabFunction, follows the same syntax, but supports
+% sparsity
+%matlabFunction Generate a MATLAB file or anonymous function from a sym
+%   G = matlabFunction(F) generates a MATLAB anonymous function from sym object
+%   F. The free variables of F become the inputs for the resulting function
+%   handle G. For example, if x is the free variable of F then G(z) computes in
+%   MATLAB what subs(F,x,z) computes in the symbolic engine. The function handle
+%   G can be used by functions in MATLAB like FZERO or by functions in other
+%   toolboxes. The order of the inputs of G matches the order returned by
+%   symvar(F).
+%
+%   G = matlabFunction(...,PARAM1,VALUE1,...) uses the specified parameter/value
+%   pairs to customize the generated function. The parameters modify the
+%   declaration that appears in the generated code. The template for the
+%   generated code is
+%      function [OUT] = NAME(IN1,IN2)
+%   The parameter names can be any of the following
+%
+%     'file': The value, FILE, must be a string with a valid MATLAB function
+%             name. If FILE does not end in '.m' it will be appended. If the
+%             file already exists it will be overwritten.  A function handle to
+%             the function will be returned in G. If the file name parameter is
+%             empty an anonymous function is generated. The NAME in the function
+%             template is the file name in FILE.
+%
+%     'vars': The value, IN, must be either
+%                1) a cell array of M strings or sym arrays, or
+%                2) a vector of M symbolic variables.
+%             IN specifies the input variable names and their order IN1,
+%             IN2,... INM in the function template. If INj is a sym array then
+%             the name used in the function template is 'inj'.  The variables
+%             listed in IN must be a superset of the free variables in all the
+%             Fk. The default value for IN is the union of the free variables in
+%             all the Fk.
+%
+%   Note: not all MuPAD expressions can be converted to a MATLAB function.
+%   For example piecewise expressions and sets will not be converted.
+
+
+narginchk(1,inf);
+
+% process inputs
+funs = sym(f);
+args = varargin(1:end);
+opts = getOptions(args);
+
+% compute non-trivial defaults and verify inputs
+funvars = getFunVars(funs);
+vars = checkVars(funvars,opts);
+varnames = format(opts.varnames);
+
+% generate anonymous function or file
+if ~isempty(opts.file)
+    file = normalize(opts.file,'.m');
+%     body = renameFileInputs(vars,inputs,funvars);
+    clear(char(file)); % necessary to avoid problems in for-loops
+    g = writeMATLAB(funs,file,varnames);
+    tmp = exist(char(file),'file'); %#ok
+                                    % necessary to make the function available
+                                    % on the PATH right away
+end
+
+% compute the default value for 'vars'.
+% returns the sorted union of the symvars of the funs
+function funvars = getFunVars(f)
+vars = symvar(f);
+vars = unique(vars);
+funparams = argnames(f);
+funvars = unique([funparams, vars], 'stable');
+
+% get the 'vars' value and check it for errors
+function v = checkVars(funvars,opts)
+if isempty(opts.vars)
+    v = funvars;
+else
+    v = opts.vars;
+end
+[v,vexpanded] = var2cell(v);
+if ~isempty(vexpanded)
+    if ~iscellstr(vexpanded)
+        error(message('symbolic:sym:matlabFunction:InvalidVars'));
+    elseif ~all(cellfun(@(x)isvarname(x),vexpanded))
+        error(message('symbolic:sym:matlabFunction:InvalidVarName'));
+    end
+end
+checkVarsSubset(vexpanded,funvars);
+
+% check that the funvars are a subset of the expanded vars.
+function checkVarsSubset(vexpanded,funvars)
+vars = var2cell(funvars);
+missing = cellfun(@(x)~any(strcmp(char(x),vexpanded)),vars);
+if any(missing)
+    misvars = vars(missing);
+    varnames = format(misvars);
+    if length(misvars) > 1
+        error(message('symbolic:sym:matlabFunction:FreeVariables', varnames));
+    end
+    error(message('symbolic:sym:matlabFunction:FreeVariable', varnames));
+end
+
+% convert a string or sym array into a 1-by-N cell array of strings
+% also optionally return the cellstr of expanded sym array vars joined together
+function [v,vexpand] = var2cell(v)
+if isa(v,'sym')
+    v = privsubsref(v,':');
+    v = num2cell(v.');
+    v = cellfun(@(x)char(x),v,'UniformOutput',false);
+elseif ischar(v)
+    v = {v};
+end
+if nargout > 1
+    vexpand = cellfun(@var2cell,v,'UniformOutput',false);
+    vexpand = [vexpand{:}];
+end
+
+function inputs = getInputs(v)
+inputs = cell(size(v));
+for k = 1:length(v)
+        inputs{k} = sprintf('in%d',k);
+end
+
+% file = normalizeFile(file,ext) append extension ext if file doesn't
+% have one already.
+function file = normalize(file,ext)
+[~,~,x] = fileparts(file);
+if isempty(x)
+    file = [file ext];
+end
+
+% Horzcat sym array or cell array v with commas
+function varnames = format(v)
+if isempty(v)
+    varnames = '';
+else
+    if ~iscell(v)
+        v = num2cell(v);
+    end
+    varnames = cellfun(@(x)[char(x) ','],v,'UniformOutput',false);
+    varnames = [varnames{:}];
+    varnames(end) = [];
+end
+
+% Generate MATLAB. f is the expr to generate. file is file name.
+% varnames is the formatted input variables
+% outputs is the cell array of output names
+% mapping is string with input to variable mapping
+function g = writeMATLAB(f,file,varnames)
+[fid,msg] = fopen(file,'wt');
+if fid == -1
+    error(message('symbolic:sym:matlabFunction:FileError', file, msg));
+end
+tmp = onCleanup(@()fclose(fid));
+% [f,tvalues,tnames] = optimize(f);
+[~,fname] = fileparts(file);
+writeHeader(fid,fname,varnames);
+writeOutput(fid,f);
+g = str2func(fname);
+
+% write out the function declaration and help
+function writeHeader(fid,fname,varnames)
+symver = ver('symbolic');
+if ~isempty(varnames)
+    varnames = ['(' varnames ')'];
+end
+symver = symver(1);
+fprintf(fid,'function out = %s%s\n',fname,varnames);
+fprintf(fid,'%%%s\n',upper(fname));
+fprintf(fid,'%%    out = %s%s\n\n',upper(fname),upper(varnames));
+fprintf(fid,'%%    This function was generated by the Symbolic Math Toolbox version %s.\n',symver.Version);
+fprintf(fid,'%%    %s\n\n',datestr(now));
+
+
+% write the assignments to the output variables
+function writeOutput(fid,expr)
+idx = find(expr); % find nonzero entries
+fprintf(fid,['out = sparse([],[],[],' num2str(size(expr,1)) ',' num2str(size(expr,2)) ',' num2str(length(idx)) ');\n']); % initialise with zero values
+
+for k = 1:length(idx)
+    str = char(expr(idx(k)));
+    for var = {'p','x','k'}
+        t = regexp(str,[var{1} '_([0-9]*)'],'tokens');
+        ts = cellfun(@(x) [var{1} '_' x{1} ],t,'UniformOutput',false);
+        td = cellfun(@(x) [var{1} '(' num2str(str2double(x)+1) ')'],t,'UniformOutput',false);
+        ts = unique(ts);
+        td = unique(td);
+        [~,idx_ts] = sort(cellfun(@(x) length(x),ts),'descend');
+        ts = ts(idx_ts);
+        td = ts(idx_ts);
+        for it = 1:length(ts)
+            str = strrep(str,ts{it},td{it});
+        end
+    end
+    fprintf(fid,['out(' num2str(idx(k)) ') = ' str ';\n']);
+end
+
+% validator for variable parameter
+function t = isVars(x)
+t = iscell(x) || (ischar(x)&&size(x,1)==1) || isa(x,'sym');
+
+% validator for file parameter
+function t = isFunc(x)
+[~,file] = fileparts(x);
+if length(file)>namelengthmax
+    error('filename is longer than what matlab can handle.')
+end
+t = isempty(file) || isvarname(file);
+
+% parse inputs and return option structure output
+function opts = getOptions(args)
+ip = inputParser;
+verMAT = ver('MATLAB');
+if(str2double(verMAT.Version)>=8.2)
+    ip.addParameter('vars',{},@isVars);
+    ip.addParameter('file','',@isFunc);
+    ip.addParameter('outputs',{},@iscellstr);
+    ip.addParameter('varnames',{},@iscellstr);
+else
+    ip.addParamValue('vars',{},@isVars);
+    ip.addParamValue('file','',@isFunc);
+    ip.addParamValue('outputs',{},@iscellstr);
+    ip.addParamValue('varnames',{},@iscellstr);
+end
+ip.parse(args{:});
+opts = ip.Results;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/betterSym.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/betterSym.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3eec9baf97f816c90af344dc3857088a83b95d2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/betterSym.m
@@ -0,0 +1,8 @@
+function csym = betterSym(str)
+    matVer = ver('MATLAB');
+    if(str2double(matVer.Version)>=9.4)
+        csym = str2sym(str);
+    else
+        csym = sym(str);
+    end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/compileAMICIDependencies.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/compileAMICIDependencies.m
new file mode 100644
index 0000000000000000000000000000000000000000..d433ce45bb5108ecea9d26508cc150981b387633
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/compileAMICIDependencies.m
@@ -0,0 +1,371 @@
+function [objectsstr, includesstr] = compileAMICIDependencies(dependencyPath, objectFolder, o_suffix, COPT, DEBUG)
+    %COMPILEAMICIDEPENDENCIES Compiles Sundials and SuiteSparse libraries required by AMICI
+
+    sundials_path = fullfile(dependencyPath,'sundials');
+    sundials_ver = '4.0.2';
+
+    ssparse_path = fullfile(dependencyPath,'SuiteSparse');
+    ssparse_ver = '4.5.3';
+
+    lapack_path = fullfile(dependencyPath,'lapack-3.5.0'); % currently not used, lapack implementation still needs to be done
+    lapack_ver = '3.5.0';
+
+
+    version_file = fullfile(objectFolder, 'versions.txt');
+    [del_sundials, del_ssparse, del_lapack] = checkVersions(version_file, sundials_ver, ssparse_ver, lapack_ver);
+
+    % assemble objectsstr
+    objectsstr = '';
+    objects_sundials = getObjectsSundials(o_suffix);
+    for j=1:length(objects_sundials)
+        objectsstr = strcat(objectsstr,' "',fullfile(objectFolder,objects_sundials{j}),'"');
+    end
+
+    objects_ssparse = getObjectsSSparse(o_suffix);
+    for j=1:length(objects_ssparse)
+        objectsstr = strcat(objectsstr,' "',fullfile(objectFolder,objects_ssparse{j}),'"');
+    end
+
+    includesstr = getIncludeString(fullfile(fileparts(dependencyPath)), sundials_path, ssparse_path);
+
+    % collect files that need to be recompiled
+    sources_sundials = getSourcesSundials();
+    sourcesToCompile = '';
+    for j=1:length(sources_sundials)
+        if(del_sundials || ~exist(fullfile(objectFolder,objects_sundials{j}), 'file'))
+            sourcesToCompile = [sourcesToCompile, ' ', fullfile(sundials_path,sources_sundials{j})];
+        end
+    end
+    sources_ssparse = getSourcesSSparse();
+    for j=1:length(sources_ssparse)
+        if(del_ssparse || ~exist(fullfile(objectFolder,objects_ssparse{j}), 'file'))
+            sourcesToCompile = [sourcesToCompile, ' ', fullfile(ssparse_path,sources_ssparse{j})];
+        end
+    end
+
+    % sundials compatible int type for suitesparse
+    COPT = [COPT ' -DDLONG'];
+
+    % compile
+    if(~strcmp(sourcesToCompile, ''))
+        eval(['mex ' DEBUG ' ' COPT ' -c -outdir ' ...
+            objectFolder ...
+            includesstr ' ' sourcesToCompile ]);
+    end
+
+    % only write versions.txt if we are done compiling
+    fid = fopen(version_file,'w');
+    fprintf(fid,[sundials_ver '\r']);
+    fprintf(fid,[ssparse_ver '\r']);
+    fprintf(fid,[lapack_ver '\r']);
+    fclose(fid);
+end
+
+function includesstr = getIncludeString(amici_root_path, sundials_path, ssparse_path)
+    includesstr = '';
+    includesstr = strcat(includesstr,' -I"', fullfile(sundials_path, 'include'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(sundials_path, 'src'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(amici_root_path), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(amici_root_path, 'src'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(amici_root_path, 'include'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(ssparse_path, 'KLU','Include'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(ssparse_path, 'AMD','Include'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(ssparse_path, 'COLAMD','Include'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(ssparse_path, 'BTF','Include'), '"');
+    includesstr = strcat(includesstr,' -I"', fullfile(ssparse_path, 'SuiteSparse_config'), '"');
+end
+
+
+function [del_sundials, del_ssparse, del_lapack] = checkVersions(version_file, sundials_ver, ssparse_ver, lapack_ver)
+    % read version number from versions.txt and decide whether object have to
+    % be regenerated
+    if(~exist(version_file,'file'))
+        del_sundials = true;
+        del_ssparse = true;
+        del_lapack = true;
+        fid = fopen(version_file,'w');
+        fprintf(fid,[sundials_ver '\r']);
+        fprintf(fid,[ssparse_ver '\r']);
+        fprintf(fid,[lapack_ver '\r']);
+        fclose(fid);
+    else
+        fid = fopen(version_file,'r');
+        sundials_objver = fgetl(fid);
+        ssparse_objver = fgetl(fid);
+        lapack_objver = fgetl(fid);
+        fclose(fid);
+        del_sundials = isnewer(sundials_ver,sundials_objver);
+        if(del_sundials)
+            display('Newer version of Sundials! Recompiling ...')
+        end
+        del_ssparse = isnewer(ssparse_ver,ssparse_objver);
+        if(del_ssparse)
+            display('Newer version of SuiteSparse! Recompiling ...')
+        end
+        del_lapack = isnewer(lapack_ver,lapack_objver);
+        if(del_lapack)
+            display('Newer version of Lapack! Recompiling ...')
+        end
+    end
+end
+
+function sources_sundials = getSourcesSundials()
+    sources_sundials = {
+        fullfile('src', 'sunmatrix', 'dense',   'sunmatrix_dense.c');
+        fullfile('src', 'sunmatrix', 'sparse',  'sunmatrix_sparse.c');
+        fullfile('src', 'sunmatrix', 'band',    'sunmatrix_band.c');
+        fullfile('src', 'sunlinsol', 'spgmr',   'sunlinsol_spgmr.c');
+        fullfile('src', 'sunlinsol', 'sptfqmr', 'sunlinsol_sptfqmr.c');
+        fullfile('src', 'sunlinsol', 'klu',     'sunlinsol_klu.c');
+        fullfile('src', 'sunlinsol', 'dense',   'sunlinsol_dense.c');
+        fullfile('src', 'sunlinsol', 'spfgmr',  'sunlinsol_spfgmr.c');
+        fullfile('src', 'sunlinsol', 'pcg',     'sunlinsol_pcg.c');
+        fullfile('src', 'sunlinsol', 'spbcgs',  'sunlinsol_spbcgs.c');
+        fullfile('src', 'sunlinsol', 'band',    'sunlinsol_band.c');
+        fullfile('src', 'idas', 'idas_direct.c');
+        fullfile('src', 'idas', 'idaa.c');
+        fullfile('src', 'idas', 'idas_ic.c');
+        fullfile('src', 'idas', 'idas_nls_stg.c');
+        fullfile('src', 'idas', 'idas.c');
+        fullfile('src', 'idas', 'idas_bbdpre.c');
+        fullfile('src', 'idas', 'idas_spils.c');
+        fullfile('src', 'idas', 'idas_nls.c');
+        fullfile('src', 'idas', 'idas_ls.c');
+        fullfile('src', 'idas', 'idas_io.c');
+        fullfile('src', 'idas', 'idas_nls_sim.c');
+        fullfile('src', 'idas', 'idaa_io.c');
+        fullfile('src', 'sundials', 'sundials_math.c');
+        fullfile('src', 'sundials', 'sundials_mpi.c');
+        fullfile('src', 'sundials', 'sundials_sptfqmr.c');
+        fullfile('src', 'sundials', 'sundials_matrix.c');
+        fullfile('src', 'sundials', 'sundials_pcg.c');
+        fullfile('src', 'sundials', 'sundials_direct.c');
+        fullfile('src', 'sundials', 'sundials_spgmr.c');
+        fullfile('src', 'sundials', 'sundials_spbcgs.c');
+        fullfile('src', 'sundials', 'sundials_nvector_senswrapper.c');
+        fullfile('src', 'sundials', 'sundials_dense.c');
+        fullfile('src', 'sundials', 'sundials_nvector.c');
+        fullfile('src', 'sundials', 'sundials_version.c');
+        fullfile('src', 'sundials', 'sundials_spfgmr.c');
+        fullfile('src', 'sundials', 'sundials_sparse.c');
+        fullfile('src', 'sundials', 'sundials_iterative.c');
+        fullfile('src', 'sundials', 'sundials_nonlinearsolver.c');
+        fullfile('src', 'sundials', 'sundials_linearsolver.c');
+        fullfile('src', 'sundials', 'sundials_band.c');
+        fullfile('src', 'sunnonlinsol', 'newton', 'sunnonlinsol_newton.c');
+        fullfile('src', 'sunnonlinsol', 'fixedpoint', ...
+                     'sunnonlinsol_fixedpoint.c');
+        fullfile('src', 'nvector', 'serial', 'nvector_serial.c');
+        fullfile('src', 'cvodes', 'cvodes_spils.c');
+        fullfile('src', 'cvodes', 'cvodes_nls_stg.c');
+        fullfile('src', 'cvodes', 'cvodes_ls.c');
+        fullfile('src', 'cvodes', 'cvodes_nls_stg1.c');
+        fullfile('src', 'cvodes', 'cvodes_bbdpre.c');
+        fullfile('src', 'cvodes', 'cvodes.c');
+        fullfile('src', 'cvodes', 'cvodes_bandpre.c');
+        fullfile('src', 'cvodes', 'cvodea.c');
+        fullfile('src', 'cvodes', 'cvodes_nls_sim.c');
+        fullfile('src', 'cvodes', 'cvodea_io.c');
+        fullfile('src', 'cvodes', 'cvodes_nls.c');
+        fullfile('src', 'cvodes', 'cvodes_diag.c');
+        fullfile('src', 'cvodes', 'cvodes_io.c');
+        fullfile('src', 'cvodes', 'cvodes_direct.c');
+        };
+end
+
+
+
+function sources_ssparse = getSourcesSSparse()
+    sources_ssparse = {
+        fullfile('KLU','Source','klu_analyze_given.c');
+        fullfile('KLU','Source','klu_analyze.c');
+        fullfile('KLU','Source','klu_defaults.c');
+        fullfile('KLU','Source','klu_diagnostics.c');
+        fullfile('KLU','Source','klu_dump.c');
+        fullfile('KLU','Source','klu_extract.c');
+        fullfile('KLU','Source','klu_factor.c');
+        fullfile('KLU','Source','klu_free_numeric.c');
+        fullfile('KLU','Source','klu_free_symbolic.c');
+        fullfile('KLU','Source','klu_kernel.c');
+        fullfile('KLU','Source','klu_memory.c');
+        fullfile('KLU','Source','klu_refactor.c');
+        fullfile('KLU','Source','klu_scale.c');
+        fullfile('KLU','Source','klu_sort.c');
+        fullfile('KLU','Source','klu_solve.c');
+        fullfile('KLU','Source','klu_tsolve.c');
+        fullfile('KLU','Source','klu.c');
+        fullfile('AMD','Source','amd_1.c');
+        fullfile('AMD','Source','amd_2.c');
+        fullfile('AMD','Source','amd_aat.c');
+        fullfile('AMD','Source','amd_control.c');
+        fullfile('AMD','Source','amd_defaults.c');
+        fullfile('AMD','Source','amd_dump.c');
+        fullfile('AMD','Source','amd_global.c');
+        fullfile('AMD','Source','amd_info.c');
+        fullfile('AMD','Source','amd_order.c');
+        fullfile('AMD','Source','amd_post_tree.c');
+        fullfile('AMD','Source','amd_postorder.c');
+        fullfile('AMD','Source','amd_preprocess.c');
+        fullfile('AMD','Source','amd_valid.c');
+        fullfile('COLAMD','Source','colamd.c');
+        fullfile('BTF','Source','btf_maxtrans.c');
+        fullfile('BTF','Source','btf_order.c');
+        fullfile('BTF','Source','btf_strongcomp.c');
+        fullfile('SuiteSparse_config','SuiteSparse_config.c');
+        };
+end
+
+function objects_ssparse = getObjectsSSparse(o_suffix)
+
+    objects_ssparse = {
+        'klu_analyze_given.o';
+        'klu_analyze.o';
+        'klu_defaults.o';
+        'klu_diagnostics.o';
+        'klu_dump.o';
+        'klu_extract.o';
+        'klu_factor.o';
+        'klu_free_numeric.o';
+        'klu_free_symbolic.o';
+        'klu_kernel.o';
+        'klu_memory.o';
+        'klu_refactor.o';
+        'klu_scale.o';
+        'klu_sort.o';
+        'klu_solve.o';
+        'klu_tsolve.o';
+        'klu.o';
+        'amd_1.o';
+        'amd_2.o';
+        'amd_aat.o';
+        'amd_control.o';
+        'amd_defaults.o';
+        'amd_dump.o';
+        'amd_global.o';
+        'amd_info.o';
+        'amd_order.o';
+        'amd_post_tree.o';
+        'amd_postorder.o';
+        'amd_preprocess.o';
+        'amd_valid.o';
+        'colamd.o';
+        'btf_maxtrans.o';
+        'btf_order.o';
+        'btf_strongcomp.o';
+        'SuiteSparse_config.o';
+        };
+
+    if(~strcmp(o_suffix, '.o'))
+        objects_ssparse = strrep(objects_ssparse, '.o', o_suffix);
+    end
+end
+
+function objects_sundials = getObjectsSundials(o_suffix)
+    objects_sundials = {
+        'sunmatrix_dense.o';
+        'sunlinsol_spgmr.o';
+        'sunlinsol_sptfqmr.o';
+        'sunlinsol_klu.o';
+        'idas_direct.o';
+        'idaa.o';
+        'idas_ic.o';
+        'idas_nls_stg.o';
+        'idas.o';
+        'idas_bbdpre.o';
+        'idas_spils.o';
+        'idas_nls.o';
+        'idas_ls.o';
+        'idas_io.o';
+        'idas_nls_sim.o';
+        'idaa_io.o';
+        'sundials_math.o';
+        'sundials_mpi.o';
+        'sundials_sptfqmr.o';
+        'sundials_matrix.o';
+        'sundials_pcg.o';
+        'sundials_direct.o';
+        'sundials_spgmr.o';
+        'sundials_spbcgs.o';
+        'sundials_nvector_senswrapper.o';
+        'sundials_dense.o';
+        'sundials_nvector.o';
+        'sundials_version.o';
+        'sundials_spfgmr.o';
+        'sundials_sparse.o';
+        'sundials_iterative.o';
+        'sundials_nonlinearsolver.o';
+        'sundials_linearsolver.o';
+        'sundials_band.o';
+        'sunlinsol_dense.o';
+        'sunmatrix_band.o';
+        'sunlinsol_spfgmr.o';
+        'sunnonlinsol_newton.o';
+        'sunnonlinsol_fixedpoint.o';
+        'sunmatrix_sparse.o';
+        'nvector_serial.o';
+        'sunlinsol_pcg.o';
+        'sunlinsol_spbcgs.o';
+        'sunlinsol_band.o';
+        'cvodes_spils.o';
+        'cvodes_nls_stg.o';
+        'cvodes_ls.o';
+        'cvodes_nls_stg1.o';
+        'cvodes_bbdpre.o';
+        'cvodes.o';
+        'cvodes_bandpre.o';
+        'cvodea.o';
+        'cvodes_nls_sim.o';
+        'cvodea_io.o';
+        'cvodes_nls.o';
+        'cvodes_diag.o';
+        'cvodes_io.o';
+        'cvodes_direct.o';
+        };
+
+    if(~strcmp(o_suffix, '.o'))
+        objects_sundials = strrep(objects_sundials, '.o', o_suffix);
+    end
+end
+
+function result = isnewer(ver1str,ver2str)
+    % isnewer checks whether the version indicated in ver1str is newer than
+    % the on in ver2str
+    %
+    % Parameters:
+    %  ver1str: version string 1, this should be a string in the format %d.%d.%d @type string
+    %  ver2str: version string 1, this should be a string in the format %d.%d.%d @type string
+    %
+    % Return values:
+    %  result: flag indicating whether ver1 ist newer than ver2 @type boolean
+
+    ver1Parts = getParts(ver1str);
+    ver2Parts = getParts(ver2str);
+    if ver2Parts(1) ~= ver1Parts(1)     % major version
+        result = ver2Parts(1) < ver1Parts(1);
+    elseif ver2Parts(2) ~= ver1Parts(2) % minor version
+        result = ver2Parts(2) < ver1Parts(2);
+    elseif ver2Parts(3) ~= ver1Parts(3) % revision version
+        result = ver2Parts(3) < ver1Parts(3);
+    else
+        result = ver2Parts(4) < ver1Parts(4);
+    end
+end
+
+function parts = getParts(V)
+    % getParts takes an input version string and returns an array
+    % containing the major minor and subminor version number
+    %
+    % Parameters:
+    %  V: version string, this should be a string in the format %d.%d.%d @type string
+    %
+    % Return values:
+    %  parts: array containing the version numbers @type double
+
+    parts = sscanf(V, '%d.%d.%d.%d')';
+    if length(parts) < 3
+        parts(3) = 0; % zero-fills to 3 elements
+    end
+    if length(parts) < 4
+        parts(4) = 0; % zero-fills to 3 elements
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/getCommitHash.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/getCommitHash.m
new file mode 100644
index 0000000000000000000000000000000000000000..b33e820e4996eaa94429e6bd73d1fc181026f6c9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/getCommitHash.m
@@ -0,0 +1,41 @@
+function [ commit_hash,branch,url ] = getCommitHash( wrap_path )
+    % extracts the commit hash from the git HEAD, when available. returns
+    % empty array when no git directory is available.
+    %
+    % Parameters:
+    %  wrap_path: path to AMICI folder @type char
+    %
+    % Return values:
+    %  commit_hash: extracted hash value @type char
+    %  branch: branch of the repository @type char
+    %  url: employed remote origin @type char
+    
+    try
+        fid = fopen(fullfile(wrap_path,'..','.git','FETCH_HEAD'));
+        str = fgetl(fid);
+        fclose(fid);
+        if(str~=-1)
+            t_hash = regexp(str,'^([\w]*)','tokens');
+            commit_hash = t_hash{1}{1};
+            t_branch = regexp(str,'branch ''([\w]*)''','tokens');
+            branch = t_branch{1}{1};
+            idx_url = strfind(str,'https://github.com');
+            url = str(idx_url:end);
+        else
+            fid = fopen(fullfile(wrap_path,'.git','ORIG_HEAD'));
+            commit_hash = ['dev_' fgetl(fid)];
+            fclose(fid);
+            
+            fid = fopen(fullfile(wrap_path,'.git','HEAD'));
+            branch = strrep(fgetl(fid),'ref: refs/heads/','');
+            fclose(fid);
+            
+            url = 'local';
+        end
+    catch
+        commit_hash = [];
+        branch = 'unknown branch';
+        url = 'unknown repository';
+    end
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/struct2xml/license.txt b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/struct2xml/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21b570d1cf8957d4dc437b3a06308b2e57a95b7b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/struct2xml/license.txt
@@ -0,0 +1,24 @@
+Copyright (c) 2010, Wouter Falkena
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/struct2xml/struct2xml.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/struct2xml/struct2xml.m
new file mode 100644
index 0000000000000000000000000000000000000000..acdbc6a5cf75e63c0e7bf60d0e12245cc4f41094
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/struct2xml/struct2xml.m
@@ -0,0 +1,198 @@
+function varargout = struct2xml( s, varargin )
+%Convert a MATLAB structure into a xml file 
+% [ ] = struct2xml( s, file )
+% xml = struct2xml( s )
+%
+% A structure containing:
+% s.XMLname.Attributes.attrib1 = "Some value";
+% s.XMLname.Element.Text = "Some text";
+% s.XMLname.DifferentElement{1}.Attributes.attrib2 = "2";
+% s.XMLname.DifferentElement{1}.Text = "Some more text";
+% s.XMLname.DifferentElement{2}.Attributes.attrib3 = "2";
+% s.XMLname.DifferentElement{2}.Attributes.attrib4 = "1";
+% s.XMLname.DifferentElement{2}.Text = "Even more text";
+%
+% Will produce:
+% <XMLname attrib1="Some value">
+%   <Element>Some text</Element>
+%   <DifferentElement attrib2="2">Some more text</Element>
+%   <DifferentElement attrib3="2" attrib4="1">Even more text</DifferentElement>
+% </XMLname>
+%
+% Please note that the following strings are substituted
+% '_dash_' by '-', '_colon_' by ':' and '_dot_' by '.'
+%
+% Written by W. Falkena, ASTI, TUDelft, 27-08-2010
+% On-screen output functionality added by P. Orth, 01-12-2010
+% Multiple space to single space conversion adapted for speed by T. Lohuis, 11-04-2011
+% Val2str subfunction bugfix by H. Gsenger, 19-9-2011
+    
+    if (nargin ~= 2)
+        if(nargout ~= 1 || nargin ~= 1)
+            error(['Supported function calls:' sprintf('\n')...
+                   '[ ] = struct2xml( s, file )' sprintf('\n')...
+                   'xml = struct2xml( s )']);
+        end
+    end
+
+    if(nargin == 2)
+        file = varargin{1};
+
+        if (isempty(file))
+            error('Filename can not be empty');
+        end
+
+        if (isempty(strfind(file,'.xml')))
+            file = [file '.xml'];
+        end
+    end
+    
+    if (~isstruct(s))
+        error([inputname(1) ' is not a structure']);
+    end
+    
+    if (length(fieldnames(s)) > 1)
+        error(['Error processing the structure:' sprintf('\n') 'There should be a single field in the main structure.']);
+    end
+    xmlname = fieldnames(s);
+    xmlname = xmlname{1};
+    
+    %substitute special characters
+    xmlname_sc = xmlname;
+    xmlname_sc = strrep(xmlname_sc,'_dash_','-');
+    xmlname_sc = strrep(xmlname_sc,'_colon_',':');
+    xmlname_sc = strrep(xmlname_sc,'_dot_','.');
+
+    %create xml structure
+    docNode = com.mathworks.xml.XMLUtils.createDocument(xmlname_sc);
+
+    %process the rootnode
+    docRootNode = docNode.getDocumentElement;
+
+    %append childs
+    parseStruct(s.(xmlname),docNode,docRootNode,[inputname(1) '.' xmlname '.']);
+
+    if(nargout == 0)
+        %save xml file
+        xmlwrite(file,docNode);
+    else
+        varargout{1} = xmlwrite(docNode);
+    end  
+end
+
+% ----- Subfunction parseStruct -----
+function [] = parseStruct(s,docNode,curNode,pName)
+    
+    fnames = fieldnames(s);
+    for i = 1:length(fnames)
+        curfield = fnames{i};
+        
+        %substitute special characters
+        curfield_sc = curfield;
+        curfield_sc = strrep(curfield_sc,'_dash_','-');
+        curfield_sc = strrep(curfield_sc,'_colon_',':');
+        curfield_sc = strrep(curfield_sc,'_dot_','.');
+        
+        if (strcmp(curfield,'Attributes'))
+            %Attribute data
+            if (isstruct(s.(curfield)))
+                attr_names = fieldnames(s.Attributes);
+                for a = 1:length(attr_names)
+                    cur_attr = attr_names{a};
+                    
+                    %substitute special characters
+                    cur_attr_sc = cur_attr;
+                    cur_attr_sc = strrep(cur_attr_sc,'_dash_','-');
+                    cur_attr_sc = strrep(cur_attr_sc,'_colon_',':');
+                    cur_attr_sc = strrep(cur_attr_sc,'_dot_','.');
+                    
+                    [cur_str,succes] = val2str(s.Attributes.(cur_attr));
+                    if (succes)
+                        curNode.setAttribute(cur_attr_sc,cur_str);
+                    else
+                        disp(['Warning. The text in ' pName curfield '.' cur_attr ' could not be processed.']);
+                    end
+                end
+            else
+                disp(['Warning. The attributes in ' pName curfield ' could not be processed.']);
+                disp(['The correct syntax is: ' pName curfield '.attribute_name = ''Some text''.']);
+            end
+        elseif (strcmp(curfield,'Text'))
+            %Text data
+            [txt,succes] = val2str(s.Text);
+            if (succes)
+                curNode.appendChild(docNode.createTextNode(txt));
+            else
+                disp(['Warning. The text in ' pName curfield ' could not be processed.']);
+            end
+        else
+            %Sub-element
+            if (isstruct(s.(curfield)))
+                %single element
+                curElement = docNode.createElement(curfield_sc);
+                curNode.appendChild(curElement);
+                parseStruct(s.(curfield),docNode,curElement,[pName curfield '.'])
+            elseif (iscell(s.(curfield)))
+                %multiple elements
+                for c = 1:length(s.(curfield))
+                    curElement = docNode.createElement(curfield_sc);
+                    curNode.appendChild(curElement);
+                    if (isstruct(s.(curfield){c}))
+                        parseStruct(s.(curfield){c},docNode,curElement,[pName curfield '{' num2str(c) '}.'])
+                    else
+                        disp(['Warning. The cell ' pName curfield '{' num2str(c) '} could not be processed, since it contains no structure.']);
+                    end
+                end
+            else
+                %eventhough the fieldname is not text, the field could
+                %contain text. Create a new element and use this text
+                curElement = docNode.createElement(curfield_sc);
+                curNode.appendChild(curElement);
+                [txt,succes] = val2str(s.(curfield));
+                if (succes)
+                    curElement.appendChild(docNode.createTextNode(txt));
+                else
+                    disp(['Warning. The text in ' pName curfield ' could not be processed.']);
+                end
+            end
+        end
+    end
+end
+
+%----- Subfunction val2str -----
+function [str,succes] = val2str(val)
+    
+    succes = true;
+    str = [];
+    
+    if (isempty(val))
+        return; %bugfix from H. Gsenger
+    elseif (ischar(val))
+        %do nothing
+    elseif (isnumeric(val))
+        val = num2str(val);
+    else
+        succes = false;
+    end
+    
+    if (ischar(val))
+        %add line breaks to all lines except the last (for multiline strings)
+        lines = size(val,1);
+        val = [val char(sprintf('\n')*[ones(lines-1,1);0])];
+        
+        %transpose is required since indexing (i.e., val(nonspace) or val(:)) produces a 1-D vector. 
+        %This should be row based (line based) and not column based.
+        valt = val';
+        
+        remove_multiple_white_spaces = true;
+        if (remove_multiple_white_spaces)
+            %remove multiple white spaces using isspace, suggestion of T. Lohuis
+            whitespace = isspace(val);
+            nonspace = (whitespace + [zeros(lines,1) whitespace(:,1:end-1)])~=2;
+            nonspace(:,end) = [ones(lines-1,1);0]; %make sure line breaks stay intact
+            str = valt(nonspace');
+        else
+            str = valt(:);
+        end
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/structToHDF5Attribute.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/structToHDF5Attribute.m
new file mode 100644
index 0000000000000000000000000000000000000000..a692ed69ebaa8de90a07ac53d87739ef56c9657f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/structToHDF5Attribute.m
@@ -0,0 +1,42 @@
+function [ ] = structToHDF5Attribute( hdffile, path, mystruct )
+%STRUCTTOHDF5ATTRIBUTE Write structs to HDF5 file
+%   ...
+
+try
+    try
+        fid = H5F.open(hdffile, 'H5F_ACC_RDWR', 'H5P_DEFAULT');
+    catch
+        fid = H5F.create(hdffile, 'H5F_ACC_TRUNC', 'H5P_DEFAULT', 'H5P_DEFAULT');
+    end
+    lcpl = H5P.create('H5P_LINK_CREATE');
+    H5P.set_create_intermediate_group(lcpl,1);
+    gid = H5G.create(fid, path, lcpl, 'H5P_DEFAULT', 'H5P_DEFAULT');
+    H5G.close(gid);
+    H5F.close(fid);
+catch me
+    if ~strcmp(me.identifier,'MATLAB:imagesci:h5create:datasetAlreadyExists')
+        rethrow(me)
+    end
+end
+
+fields = fieldnames(mystruct);
+for i = 1:numel(fields)
+    f = fields{i};
+    d = mystruct.(f);
+    if(isstruct(d))
+        structToHDF5Attribute( hdffile, [path '/' f], d )
+    else
+        if isa(d, 'logical')
+            d = int32(d);
+        end
+        if(numel(d)>0)
+            if(numel(d)>1 && sum(size(d)>1)>1)
+                h5create(hdffile, [path '/' f], size(d));
+                h5write(hdffile, [path '/' f], d);
+            else
+                h5writeatt(hdffile, path, f, d);
+            end
+        end
+    end
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/template.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/template.m
new file mode 100644
index 0000000000000000000000000000000000000000..2d1ff3732ea8fbf3ca3774fb160fcfa2e9f97f8a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/template.m
@@ -0,0 +1,45 @@
+classdef template < handle
+    %TEMPLATE A class to replace strings in template files
+    
+    properties
+        % strings in the template to be replaced
+        templateStrings = {};
+        % strings for replacement
+        templateReplacements = {};
+    end
+    
+    methods
+        function replace(this, infile, outfile)
+            % apply all provided template substitutions to infile and write
+            % results to outfile
+            fin = fopen(infile, 'r');
+            fout = fopen(outfile, 'w');
+            while(~feof(fin))
+                s = fgetl(fin);
+                s = this.replaceStr(s);
+                fprintf(fout, '%s\n', s);
+            end
+            fclose(fin);
+            fclose(fout);
+        end
+        
+        function add(this, templateStr, replacementStr)
+            % add a new template string and replacement
+            nextIdx = numel(this.templateStrings);
+            this.templateStrings{nextIdx + 1} = templateStr;
+            this.templateReplacements{nextIdx + 1} = replacementStr;
+        end
+        
+        function s = replaceStr(this, s)
+            % apply all provided template substitutions to s 
+            
+            % do not use cellfun to guarantee order of replacements
+            for n = 1:numel(this.templateStrings)
+                s = strrep(s, this.templateStrings(n), this.templateReplacements(n));
+                s = s{1};
+            end
+        end
+    end
+    
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/xml2struct/license.txt b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/xml2struct/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21b570d1cf8957d4dc437b3a06308b2e57a95b7b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/xml2struct/license.txt
@@ -0,0 +1,24 @@
+Copyright (c) 2010, Wouter Falkena
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/xml2struct/xml2struct.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/xml2struct/xml2struct.m
new file mode 100644
index 0000000000000000000000000000000000000000..bd0412d69c461461986d5f72263fdf3d811d4c59
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/auxiliary/xml2struct/xml2struct.m
@@ -0,0 +1,183 @@
+function [ s ] = xml2struct( file )
+%Convert xml file into a MATLAB structure
+% [ s ] = xml2struct( file )
+%
+% A file containing:
+% <XMLname attrib1="Some value">
+%   <Element>Some text</Element>
+%   <DifferentElement attrib2="2">Some more text</Element>
+%   <DifferentElement attrib3="2" attrib4="1">Even more text</DifferentElement>
+% </XMLname>
+%
+% Will produce:
+% s.XMLname.Attributes.attrib1 = "Some value";
+% s.XMLname.Element.Text = "Some text";
+% s.XMLname.DifferentElement{1}.Attributes.attrib2 = "2";
+% s.XMLname.DifferentElement{1}.Text = "Some more text";
+% s.XMLname.DifferentElement{2}.Attributes.attrib3 = "2";
+% s.XMLname.DifferentElement{2}.Attributes.attrib4 = "1";
+% s.XMLname.DifferentElement{2}.Text = "Even more text";
+%
+% Please note that the following characters are substituted
+% '-' by '_dash_', ':' by '_colon_' and '.' by '_dot_'
+%
+% Written by W. Falkena, ASTI, TUDelft, 21-08-2010
+% Attribute parsing speed increased by 40% by A. Wanner, 14-6-2011
+% Added CDATA support by I. Smirnov, 20-3-2012
+%
+% Modified by X. Mo, University of Wisconsin, 12-5-2012
+
+    if (nargin < 1)
+        clc;
+        help xml2struct
+        return
+    end
+    
+    if isa(file, 'org.apache.xerces.dom.DeferredDocumentImpl') || isa(file, 'org.apache.xerces.dom.DeferredElementImpl')
+        % input is a java xml object
+        xDoc = file;
+    else
+        %check for existance
+        if (exist(file,'file') == 0)
+            %Perhaps the xml extension was omitted from the file name. Add the
+            %extension and try again.
+            if (isempty(strfind(file,'.xml')))
+                file = [file '.xml'];
+            end
+            
+            if (exist(file,'file') == 0)
+                error(['The file ' file ' could not be found']);
+            end
+        end
+        %read the xml file
+        xDoc = xmlread(file);
+    end
+    
+    %parse xDoc into a MATLAB structure
+    s = parseChildNodes(xDoc);
+    
+end
+
+% ----- Subfunction parseChildNodes -----
+function [children,ptext,textflag] = parseChildNodes(theNode)
+    % Recurse over node children.
+    children = struct;
+    ptext = struct; textflag = 'Text';
+    if hasChildNodes(theNode)
+        childNodes = getChildNodes(theNode);
+        numChildNodes = getLength(childNodes);
+
+        for count = 1:numChildNodes
+            theChild = item(childNodes,count-1);
+            [text,name,attr,childs,textflag] = getNodeData(theChild);
+            
+            if (~strcmp(name,'#text') && ~strcmp(name,'#comment') && ~strcmp(name,'#cdata_dash_section'))
+                %XML allows the same elements to be defined multiple times,
+                %put each in a different cell
+                if (isfield(children,name))
+                    if (~iscell(children.(name)))
+                        %put existsing element into cell format
+                        children.(name) = {children.(name)};
+                    end
+                    index = length(children.(name))+1;
+                    %add new element
+                    children.(name){index} = childs;
+                    if(~isempty(fieldnames(text)))
+                        children.(name){index} = text; 
+                    end
+                    if(~isempty(attr)) 
+                        children.(name){index}.('Attributes') = attr; 
+                    end
+                else
+                    %add previously unknown (new) element to the structure
+                    children.(name) = childs;
+                    if(~isempty(text) && ~isempty(fieldnames(text)))
+                        children.(name) = text; 
+                    end
+                    if(~isempty(attr)) 
+                        children.(name).('Attributes') = attr; 
+                    end
+                end
+            else
+                ptextflag = 'Text';
+                if (strcmp(name, '#cdata_dash_section'))
+                    ptextflag = 'CDATA';
+                elseif (strcmp(name, '#comment'))
+                    ptextflag = 'Comment';
+                end
+                
+                %this is the text in an element (i.e., the parentNode) 
+                if (~isempty(regexprep(text.(textflag),'[\s]*','')))
+                    if (~isfield(ptext,ptextflag) || isempty(ptext.(ptextflag)))
+                        ptext.(ptextflag) = text.(textflag);
+                    else
+                        %what to do when element data is as follows:
+                        %<element>Text <!--Comment--> More text</element>
+                        
+                        %put the text in different cells:
+                        % if (~iscell(ptext)) ptext = {ptext}; end
+                        % ptext{length(ptext)+1} = text;
+                        
+                        %just append the text
+                        ptext.(ptextflag) = [ptext.(ptextflag) text.(textflag)];
+                    end
+                end
+            end
+            
+        end
+    end
+end
+
+% ----- Subfunction getNodeData -----
+function [text,name,attr,childs,textflag] = getNodeData(theNode)
+    % Create structure of node info.
+    
+    %make sure name is allowed as structure name
+    name = toCharArray(getNodeName(theNode))';
+    name = strrep(name, '-', '_dash_');
+    name = strrep(name, ':', '_colon_');
+    name = strrep(name, '.', '_dot_');
+
+    attr = parseAttributes(theNode);
+    if (isempty(fieldnames(attr))) 
+        attr = []; 
+    end
+    
+    %parse child nodes
+    [childs,text,textflag] = parseChildNodes(theNode);
+    
+    if (isempty(fieldnames(childs)) && isempty(fieldnames(text)))
+        %get the data of any childless nodes
+        % faster than if any(strcmp(methods(theNode), 'getData'))
+        % no need to try-catch (?)
+        % faster than text = char(getData(theNode));
+        text.(textflag) = toCharArray(getTextContent(theNode))';
+    end
+    
+end
+
+% ----- Subfunction parseAttributes -----
+function attributes = parseAttributes(theNode)
+    % Create attributes structure.
+
+    attributes = struct;
+    if hasAttributes(theNode)
+       theAttributes = getAttributes(theNode);
+       numAttributes = getLength(theAttributes);
+
+       for count = 1:numAttributes
+            %attrib = item(theAttributes,count-1);
+            %attr_name = regexprep(char(getName(attrib)),'[-:.]','_');
+            %attributes.(attr_name) = char(getValue(attrib));
+
+            %Suggestion of Adrian Wanner
+            str = toCharArray(toString(item(theAttributes,count-1)))';
+            k = strfind(str,'='); 
+            attr_name = str(1:(k(1)-1));
+            attr_name = strrep(attr_name, '-', '_dash_');
+            attr_name = strrep(attr_name, ':', '_colon_');
+            attr_name = strrep(attr_name, '.', '_dot_');
+            attributes.(attr_name) = str((k(1)+2):(end-1));
+       end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/amiExamples.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/amiExamples.m
new file mode 100644
index 0000000000000000000000000000000000000000..9dd4b5bb3e3a38019fa46cde030c338afadfcb6a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/amiExamples.m
@@ -0,0 +1,17 @@
+oldpath = addpath(genpath('.'));
+example_events
+example_dirac
+example_dirac_adjoint
+example_dirac_secondorder
+example_dirac_secondorder_vectmult
+example_adjoint
+example_jakstat_adjoint
+example_steadystate
+example_nested_events
+example_adjoint_hessian
+example_dirac_adjoint_hessVecProd
+example_jakstat_adjoint_hvp
+example_robertson
+example_neuron
+example_dae_events
+path(oldpath);
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/example_adjoint.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/example_adjoint.m
new file mode 100644
index 0000000000000000000000000000000000000000..fc0584b2da90ccb801bee37f2e9762d1454e5696
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/example_adjoint.m
@@ -0,0 +1,130 @@
+function example_adjoint()
+
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_adjoint.m'));
+% compile the model
+amiwrap('model_adjoint','model_adjoint_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,4,5);
+p = [1.1,0.3,1];
+k = [];
+
+D.Y = [     1.0171
+    1.3423
+    1.6585
+    0.9814
+    0.3288];
+
+D.Sigma_Y = 0.1*ones(size(D.Y));
+
+
+options.sensi = 1;
+options.sensi_meth = 'adjoint';
+options.maxsteps = 1e4;
+options.rtol = 1e-12;
+options.atol = 1e-12;
+
+% load mex into memory
+[~] = which('simulate_model_adjoint'); % fix for inaccessability problems
+sol = simulate_model_adjoint(t,log10(p),k,D,options);
+
+%%
+% Plot
+if(usejava('jvm'))
+    figure
+    subplot(3,1,1)
+    errorbar(t,D.Y,D.Sigma_Y)
+    hold on
+    % plot(t,sol.y)
+    
+    xlabel('time t')
+    ylabel('observable')
+    title(['log-likelihood: ' num2str(sol.llh) ])
+    
+    y = (p(2)*t + p(3)).*(t<2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(t-2))+p(2)/p(1) ).*(t>=2);
+    
+    
+    tfine = linspace(0,4,100001);
+    xfine = (p(2)*tfine + 1).*(tfine<2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(tfine-2))+p(2)/p(1) ).*(tfine>=2);
+    
+    mu = zeros(1,length(tfine));
+    for it = 1:length(t)
+        if(t(it)<=2)
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*(tfine<=t(it));
+        else
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(tfine-t(it))).*(tfine<=t(it)).*(tfine>2) + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(2-t(it))).*(tfine<t(it)).*(tfine<=2);
+        end
+    end
+    plot(tfine,xfine)
+    legend('data','simulation')
+    xlim([min(t)-0.5,max(t)+0.5])
+    subplot(3,1,2)
+    plot(tfine,mu)
+    ylabel('adjoint')
+    xlabel('time t')
+    xlim([min(t)-0.5,max(t)+0.5])
+    
+    subplot(3,1,3)
+    
+    plot(fliplr(tfine),-cumsum(fliplr(-mu.*xfine.*(tfine>2)))*p(1)*log(10)*(t(end)/numel(tfine)))
+    hold on
+    plot(fliplr(tfine),-cumsum(fliplr(mu))*p(2)*log(10)*(t(end)/numel(tfine)))
+    plot(tfine,-mu(1)*p(3)*log(10)*(tfine<2))
+    xlim([min(t)-0.5,max(t)+0.5])
+    ylabel('integral')
+    xlabel('time t')
+    
+    legend('p1','p2','p3')
+    
+    grad(1,1) = -trapz(tfine,-mu.*xfine.*(tfine>2))*p(1)*log(10);
+    grad(2,1) = -trapz(tfine,mu)*p(2)*log(10);
+    grad(3,1) = -mu(1)*p(3)*log(10);
+    
+    plot(zeros(3,1),grad,'ko')
+end
+
+%%
+% FD
+
+eps = 1e-5;
+xi = log10(p);
+grad_fd_f = NaN(3,1);
+grad_fd_b = NaN(3,1);
+for ip = 1:3;
+    options.sensi = 0;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_adjoint(t,xip,k,D,options);
+    grad_fd_f(ip,1) = (solp.llh-sol.llh)/eps;
+    xip = xi;
+    xip(ip) = xip(ip) - eps;
+    solp = simulate_model_adjoint(t,xip,k,D,options);
+    grad_fd_b(ip,1) = -(solp.llh-sol.llh)/eps;
+end
+
+if(usejava('jvm'))
+    figure
+    plot(abs(grad),abs(grad_fd_f),'o')
+    hold on
+    plot(abs(grad),abs(grad_fd_b),'o')
+    plot(abs(grad),mean([abs(grad_fd_b),abs(grad_fd_f)],2),'o')
+    plot(abs(grad),abs(sol.sllh),'o')
+    plot([1e1,1e2],[1e1,1e2],'k:')
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    axis square
+    legend('forward FD','backward FD','central FD','adjoint sensintivity analysis','Location','SouthEast')
+    xlabel('analytic absolute value of gradient element')
+    ylabel('computed absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/example_adjoint.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/example_adjoint.html
new file mode 100644
index 0000000000000000000000000000000000000000..24fe24b409df7b4e4c90351d798c0426ee9a93a1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/example_adjoint.html
@@ -0,0 +1,316 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_adjoint</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_adjoint.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_adjoint()
+</pre><p>COMPILATION</p><pre class="codeinput">    [exdir,~,~]=fileparts(which(<span class="string">'example_adjoint.m'</span>));
+    <span class="comment">% compile the model</span>
+    amiwrap(<span class="string">'model_adjoint'</span>,<span class="string">'model_adjoint_syms'</span>,exdir)
+</pre><pre class="codeoutput">Generating model struct ...
+Parsing model struct ...
+Generating C code ...
+headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput">    <span class="comment">% time vector</span>
+    t = [linspace(0,4,5)];
+    p = [1.1,0.3,1];
+    k = [];
+
+    D.Y = [     1.0171
+        1.3423
+        1.6585
+        0.9814
+        0.3288];
+
+    D.Sigma_Y = 0.1*ones(size(D.Y));
+
+
+    options.sensi = 1;
+    options.sensi_meth = <span class="string">'adjoint'</span>;
+    options.maxsteps = 1e4;
+    options.rtol = 1e-12;
+    options.atol = 1e-12;
+    <span class="comment">% load mex into memory</span>
+    [~] = which(<span class="string">'simulate_model_adjoint'</span>); <span class="comment">% fix for inaccessability problems</span>
+    sol = simulate_model_adjoint(t,log10(p),k,D,options);
+</pre><p>Plot</p><pre class="codeinput">    figure
+    subplot(3,1,1)
+    errorbar(t,D.Y,D.Sigma_Y)
+    hold <span class="string">on</span>
+    <span class="comment">% plot(t,sol.y)</span>
+
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'observable'</span>)
+    title([<span class="string">'log-likelihood: '</span> num2str(sol.llh) ])
+
+    y = (p(2)*t + p(3)).*(t&lt;2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(t-2))+p(2)/p(1) ).*(t&gt;=2);
+
+
+    tfine = linspace(0,4,100001);
+    xfine = (p(2)*tfine + 1).*(tfine&lt;2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(tfine-2))+p(2)/p(1) ).*(tfine&gt;=2);
+
+    mu = zeros(1,length(tfine));
+    <span class="keyword">for</span> it = 1:length(t)
+        <span class="keyword">if</span>(t(it)&lt;=2)
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*(tfine&lt;=t(it));
+        <span class="keyword">else</span>
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(tfine-t(it))).*(tfine&lt;=t(it)).*(tfine&gt;2) + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(2-t(it))).*(tfine&lt;t(it)).*(tfine&lt;=2);
+        <span class="keyword">end</span>
+    <span class="keyword">end</span>
+    plot(tfine,xfine)
+    legend(<span class="string">'data'</span>,<span class="string">'simulation'</span>)
+    xlim([min(t)-0.5,max(t)+0.5])
+    subplot(3,1,2)
+    plot(tfine,mu)
+    ylabel(<span class="string">'adjoint'</span>)
+    xlabel(<span class="string">'time t'</span>)
+    xlim([min(t)-0.5,max(t)+0.5])
+
+    subplot(3,1,3)
+
+    plot(fliplr(tfine),-cumsum(fliplr(-mu.*xfine.*(tfine&gt;2)))*p(1)*log(10)*(t(end)/numel(tfine)))
+    hold <span class="string">on</span>
+    plot(fliplr(tfine),-cumsum(fliplr(mu))*p(2)*log(10)*(t(end)/numel(tfine)))
+    plot(tfine,-mu(1)*p(3)*log(10)*(tfine&lt;2))
+    xlim([min(t)-0.5,max(t)+0.5])
+    ylabel(<span class="string">'integral'</span>)
+    xlabel(<span class="string">'time t'</span>)
+
+    legend(<span class="string">'p1'</span>,<span class="string">'p2'</span>,<span class="string">'p3'</span>)
+
+    grad(1,1) = -trapz(tfine,-mu.*xfine.*(tfine&gt;2))*p(1)*log(10);
+    grad(2,1) = -trapz(tfine,mu)*p(2)*log(10);
+    grad(3,1) = -mu(1)*p(3)*log(10);
+
+    plot(zeros(3,1),grad,<span class="string">'ko'</span>)
+</pre><img vspace="5" hspace="5" src="../examples/example_adjoint/html/example_adjoint_01.png" alt=""> <p>FD</p><pre class="codeinput">    eps = 1e-5;
+    xi = log10(p);
+    grad_fd_f = NaN(3,1);
+    grad_fd_b = NaN(3,1);
+    <span class="keyword">for</span> ip = 1:3;
+        options.sensi = 0;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_adjoint(t,xip,k,D,options);
+        grad_fd_f(ip,1) = (solp.llh-sol.llh)/eps;
+        xip = xi;
+        xip(ip) = xip(ip) - eps;
+        solp = simulate_model_adjoint(t,xip,k,D,options);
+        grad_fd_b(ip,1) = -(solp.llh-sol.llh)/eps;
+    <span class="keyword">end</span>
+
+    figure
+    plot(abs(grad),abs(grad_fd_f),<span class="string">'o'</span>)
+    hold <span class="string">on</span>
+    plot(abs(grad),abs(grad_fd_b),<span class="string">'o'</span>)
+    plot(abs(grad),mean([abs(grad_fd_b),abs(grad_fd_f)],2),<span class="string">'o'</span>)
+    plot(abs(grad),abs(sol.sllh),<span class="string">'o'</span>)
+    plot([1e1,1e2],[1e1,1e2],<span class="string">'k:'</span>)
+    set(gca,<span class="string">'XScale'</span>,<span class="string">'log'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    axis <span class="string">square</span>
+    legend(<span class="string">'forward FD'</span>,<span class="string">'backward FD'</span>,<span class="string">'central FD'</span>,<span class="string">'adjoint sensintivity analysis'</span>,<span class="string">'Location'</span>,<span class="string">'SouthEast'</span>)
+    xlabel(<span class="string">'analytic absolute value of gradient element'</span>)
+    ylabel(<span class="string">'computed absolute value of gradient element'</span>)
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_adjoint/html/example_adjoint_02.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_adjoint()
+    
+    %%
+    % COMPILATION
+    
+    [exdir,~,~]=fileparts(which('example_adjoint.m'));
+    % compile the model
+    amiwrap('model_adjoint','model_adjoint_syms',exdir)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    t = [linspace(0,4,5)];
+    p = [1.1,0.3,1];
+    k = [];
+    
+    D.Y = [     1.0171
+        1.3423
+        1.6585
+        0.9814
+        0.3288];
+    
+    D.Sigma_Y = 0.1*ones(size(D.Y));
+    
+    
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    options.maxsteps = 1e4;
+    options.rtol = 1e-12;
+    options.atol = 1e-12;
+    % load mex into memory
+    [~] = which('simulate_model_adjoint'); % fix for inaccessability problems
+    sol = simulate_model_adjoint(t,log10(p),k,D,options);
+    
+    %%
+    % Plot
+    
+    figure
+    subplot(3,1,1)
+    errorbar(t,D.Y,D.Sigma_Y)
+    hold on
+    % plot(t,sol.y)
+    
+    xlabel('time t')
+    ylabel('observable')
+    title(['log-likelihood: ' num2str(sol.llh) ])
+    
+    y = (p(2)*t + p(3)).*(t<2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(t-2))+p(2)/p(1) ).*(t>=2);
+    
+    
+    tfine = linspace(0,4,100001);
+    xfine = (p(2)*tfine + 1).*(tfine<2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(tfine-2))+p(2)/p(1) ).*(tfine>=2);
+    
+    mu = zeros(1,length(tfine));
+    for it = 1:length(t)
+        if(t(it)<=2)
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*(tfine<=t(it));
+        else
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(tfine-t(it))).*(tfine<=t(it)).*(tfine>2) + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(2-t(it))).*(tfine<t(it)).*(tfine<=2);
+        end
+    end
+    plot(tfine,xfine)
+    legend('data','simulation')
+    xlim([min(t)-0.5,max(t)+0.5])
+    subplot(3,1,2)
+    plot(tfine,mu)
+    ylabel('adjoint')
+    xlabel('time t')
+    xlim([min(t)-0.5,max(t)+0.5])
+    
+    subplot(3,1,3)
+    
+    plot(fliplr(tfine),-cumsum(fliplr(-mu.*xfine.*(tfine>2)))*p(1)*log(10)*(t(end)/numel(tfine)))
+    hold on
+    plot(fliplr(tfine),-cumsum(fliplr(mu))*p(2)*log(10)*(t(end)/numel(tfine)))
+    plot(tfine,-mu(1)*p(3)*log(10)*(tfine<2))
+    xlim([min(t)-0.5,max(t)+0.5])
+    ylabel('integral')
+    xlabel('time t')
+    
+    legend('p1','p2','p3')
+    
+    grad(1,1) = -trapz(tfine,-mu.*xfine.*(tfine>2))*p(1)*log(10);
+    grad(2,1) = -trapz(tfine,mu)*p(2)*log(10);
+    grad(3,1) = -mu(1)*p(3)*log(10);
+    
+    plot(zeros(3,1),grad,'ko')
+    
+    %%
+    % FD
+    
+    eps = 1e-5;
+    xi = log10(p);
+    grad_fd_f = NaN(3,1);
+    grad_fd_b = NaN(3,1);
+    for ip = 1:3;
+        options.sensi = 0;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_adjoint(t,xip,k,D,options);
+        grad_fd_f(ip,1) = (solp.llh-sol.llh)/eps;
+        xip = xi;
+        xip(ip) = xip(ip) - eps;
+        solp = simulate_model_adjoint(t,xip,k,D,options);
+        grad_fd_b(ip,1) = -(solp.llh-sol.llh)/eps;
+    end
+    
+    figure
+    plot(abs(grad),abs(grad_fd_f),'o')
+    hold on
+    plot(abs(grad),abs(grad_fd_b),'o')
+    plot(abs(grad),mean([abs(grad_fd_b),abs(grad_fd_f)],2),'o')
+    plot(abs(grad),abs(sol.sllh),'o')
+    plot([1e1,1e2],[1e1,1e2],'k:')
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    axis square
+    legend('forward FD','backward FD','central FD','adjoint sensintivity analysis','Location','SouthEast')
+    xlabel('analytic absolute value of gradient element')
+    ylabel('computed absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+    
+end
+
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/example_adjoint.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/example_adjoint.tex
new file mode 100644
index 0000000000000000000000000000000000000000..02eeb858acc10f78991503488c48a8dd0f02f6d9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/example_adjoint.tex
@@ -0,0 +1,169 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_adjoint()
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    [exdir,~,~]=fileparts(which('example_adjoint.m'));
+    % compile the model
+    amiwrap('model_adjoint','model_adjoint_syms',exdir)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+Parsing model struct ...
+
+Generating C code ...
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    % time vector
+    t = [linspace(0,4,5)];
+    p = [1.1,0.3,1];
+    k = [];
+
+    D.Y = [     1.0171
+        1.3423
+        1.6585
+        0.9814
+        0.3288];
+
+    D.Sigma_Y = 0.1*ones(size(D.Y));
+
+
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    options.maxsteps = 1e4;
+    options.rtol = 1e-12;
+    options.atol = 1e-12;
+    % load mex into memory
+    [~] = which('simulate_model_adjoint'); % fix for inaccessability problems
+    sol = simulate_model_adjoint(t,log10(p),k,D,options);
+\end{DoxyCode}
+\begin{par}
+Plot
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    subplot(3,1,1)
+    errorbar(t,D.Y,D.Sigma_Y)
+    hold on
+    % plot(t,sol.y)
+
+    xlabel('time t')
+    ylabel('observable')
+    title(['log-likelihood: ' num2str(sol.llh) ])
+
+    y = (p(2)*t + p(3)).*(t<2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(t-2))+p(2)/p(1) ).*(t>=2);
+
+
+    tfine = linspace(0,4,100001);
+    xfine = (p(2)*tfine + 1).*(tfine<2) + ( (2*p(2)+p(3)-p(2)/p(1))*exp(-p(1)*(tfine-2))+p(2)/p(1) ).*(tfine>=2);
+
+    mu = zeros(1,length(tfine));
+    for it = 1:length(t)
+        if(t(it)<=2)
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*(tfine<=t(it));
+        else
+            mu = mu + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(tfine-t(it))).*(tfine<=t(it)).*(tfine>2) + ((y(it)-D.Y(it))/(D.Sigma_Y(it)^2))*exp(p(1)*(2-t(it))).*(tfine<t(it)).*(tfine<=2);
+        end
+    end
+    plot(tfine,xfine)
+    legend('data','simulation')
+    xlim([min(t)-0.5,max(t)+0.5])
+    subplot(3,1,2)
+    plot(tfine,mu)
+    ylabel('adjoint')
+    xlabel('time t')
+    xlim([min(t)-0.5,max(t)+0.5])
+
+    subplot(3,1,3)
+
+    plot(fliplr(tfine),-cumsum(fliplr(-mu.*xfine.*(tfine>2)))*p(1)*log(10)*(t(end)/numel(tfine)))
+    hold on
+    plot(fliplr(tfine),-cumsum(fliplr(mu))*p(2)*log(10)*(t(end)/numel(tfine)))
+    plot(tfine,-mu(1)*p(3)*log(10)*(tfine<2))
+    xlim([min(t)-0.5,max(t)+0.5])
+    ylabel('integral')
+    xlabel('time t')
+
+    legend('p1','p2','p3')
+
+    grad(1,1) = -trapz(tfine,-mu.*xfine.*(tfine>2))*p(1)*log(10);
+    grad(2,1) = -trapz(tfine,mu)*p(2)*log(10);
+    grad(3,1) = -mu(1)*p(3)*log(10);
+
+    plot(zeros(3,1),grad,'ko')
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_adjoint/html/example_adjoint_01.png}
+\begin{par}
+FD
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    eps = 1e-5;
+    xi = log10(p);
+    grad_fd_f = NaN(3,1);
+    grad_fd_b = NaN(3,1);
+    for ip = 1:3;
+        options.sensi = 0;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_adjoint(t,xip,k,D,options);
+        grad_fd_f(ip,1) = (solp.llh-sol.llh)/eps;
+        xip = xi;
+        xip(ip) = xip(ip) - eps;
+        solp = simulate_model_adjoint(t,xip,k,D,options);
+        grad_fd_b(ip,1) = -(solp.llh-sol.llh)/eps;
+    end
+
+    figure
+    plot(abs(grad),abs(grad_fd_f),'o')
+    hold on
+    plot(abs(grad),abs(grad_fd_b),'o')
+    plot(abs(grad),mean([abs(grad_fd_b),abs(grad_fd_f)],2),'o')
+    plot(abs(grad),abs(sol.sllh),'o')
+    plot([1e1,1e2],[1e1,1e2],'k:')
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    axis square
+    legend('forward FD','backward FD','central FD','adjoint sensintivity analysis','Location','SouthEast')
+    xlabel('analytic absolute value of gradient element')
+    ylabel('computed absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+
+    drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_adjoint/html/example_adjoint_02.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/model_adjoint_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/model_adjoint_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..9b26c41af1ed5aa11103a9445bb9a7e8ee81210c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/model_adjoint_syms.html
@@ -0,0 +1,156 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_adjoint_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_adjoint_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_adjoint_syms()
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [x1];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1 p2 p3];
+
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -p1*x1*heaviside(t-2) + p2;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = p3;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x1;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_adjoint_syms()
+
+%%
+% STATES
+
+% create state syms
+syms x1
+
+% create state vector
+model.sym.x = [x1];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 
+
+% create parameter vector 
+model.sym.p = [p1 p2 p3];
+
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1*heaviside(t-2) + p2;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = p3;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x1;
+
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/model_adjoint_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/model_adjoint_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..93fd135d162cf0bcf80b09c192c109919afeed9b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/html/model_adjoint_syms.tex
@@ -0,0 +1,84 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_adjoint_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1
+
+% create state vector
+model.sym.x = [x1];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3
+
+% create parameter vector
+model.sym.p = [p1 p2 p3];
+
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1*heaviside(t-2) + p2;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = p3;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x1;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/model_adjoint_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/model_adjoint_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..8473fcc6d48fef4c7f91062d136cf7281e0a6e9c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint/model_adjoint_syms.m
@@ -0,0 +1,51 @@
+function [model] = model_adjoint_syms()
+
+%%
+% STATES
+
+% create state syms
+syms x1
+
+% create state vector
+model.sym.x = [x1];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 
+
+% create parameter vector 
+model.sym.p = [p1 p2 p3];
+
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1*heaviside(t-2) + p2;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = p3;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x1;
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint_hessian/example_adjoint_hessian.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint_hessian/example_adjoint_hessian.m
new file mode 100644
index 0000000000000000000000000000000000000000..6133dc65609f4e8599cbe1c1be5ebf1f0e9d6b6b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint_hessian/example_adjoint_hessian.m
@@ -0,0 +1,94 @@
+function success = example_adjoint_hessian()
+
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_adjoint_hessian.m'));
+% compile the model
+amiwrap('model_adjoint_hessian','model_adjoint_hessian_syms',exdir,1)
+
+%%
+% SIMULATION
+
+% time vector
+t = [linspace(0,4,5)];
+p = [1.1,0.3,1];
+k = [];
+
+D.Y = [     1.0171
+    1.3423
+    1.6585
+    0.9814
+    0.3288];
+
+D.Sigma_Y = 0.1*ones(size(D.Y));
+
+
+options.sensi = 1;
+options.sensi_meth = 'adjoint';
+options.maxsteps = 1e4;
+options.rtol = 1e-12;
+options.atol = 1e-12;
+% load mex into memory
+[~] = which('simulate_model_adjoint'); % fix for inaccessability problems
+sol = simulate_model_adjoint_hessian(t,log10(p),k,D,options);
+g = sol.sllh;
+
+% fprintf('First calculated gradient: \n')
+% disp(g);
+
+eps1 = [1e-7, 0, 0];
+eps2 = [0, 1e-7, 0];
+eps3 = [0, 0, 1e-7];
+
+sol = simulate_model_adjoint_hessian(t,log10(p)+eps1,k,D,options);
+g_p1 = sol.sllh;
+sol = simulate_model_adjoint_hessian(t,log10(p)-eps1,k,D,options);
+g_m1 = sol.sllh;
+h1 = (g_p1-g_m1) / (2e-7);
+
+sol = simulate_model_adjoint_hessian(t,log10(p)+eps2,k,D,options);
+g_p2 = sol.sllh;
+sol = simulate_model_adjoint_hessian(t,log10(p)-eps2,k,D,options);
+g_m2 = sol.sllh;
+h2 = (g_p2-g_m2) / (2e-7);
+
+sol = simulate_model_adjoint_hessian(t,log10(p)+eps3,k,D,options);
+g_p3 = sol.sllh;
+sol = simulate_model_adjoint_hessian(t,log10(p)-eps3,k,D,options);
+g_m3 = sol.sllh;
+h3 = (g_p3-g_m3) / (2e-7);
+H = [h1, h2, h3];
+
+% fprintf('  Finite difference computations: \n\n');
+% fprintf('  Gradient: \n');
+% disp(g);
+% fprintf('  Hessian: \n');
+% disp(H);
+% fprintf('  Hessian vector product: \n');
+% disp(H * g);
+
+fprintf('\n\n    Second order adjoint computations: \n\n')
+options.sensi = 2;
+options.sensi_meth = 'adjoint';
+options.maxsteps = 1e4;
+options.rtol = 1e-12;
+options.atol = 1e-12;
+% load mex into memory
+[~] = which('simulate_model_adjoint'); % fix for inaccessability problems
+sol1 = simulate_model_adjoint_hessian(t,log10(p),k,D,options);
+% fprintf('  Likelihood: \n');
+% disp(sol1.llh);
+% fprintf('  Gradient: \n');
+% disp(sol1.sllh);
+% fprintf('  Hessian: \n');
+% disp(sol1.s2llh);
+
+if (sum(sum(abs(H - sol1.s2llh))) < 0.01)
+    disp(sum(sum(abs(H - sol1.s2llh))));
+    success=1;
+else
+    success=0;
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint_hessian/model_adjoint_hessian_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint_hessian/model_adjoint_hessian_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..05b06bd4d78ded415449ff7536595e742c993edc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_adjoint_hessian/model_adjoint_hessian_syms.m
@@ -0,0 +1,51 @@
+function [model] = model_adjoint_hessian_syms()
+
+%%
+% STATES
+
+% create state syms
+syms x1
+
+% create state vector
+model.sym.x = [x1];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 
+
+% create parameter vector 
+model.sym.p = [p1 p2 p3];
+
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1*heaviside(t-2) + p2;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = p3;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x1;
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_calvetti/example_calvetti.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_calvetti/example_calvetti.m
new file mode 100644
index 0000000000000000000000000000000000000000..334f977be0d455a43b5e513f73f1d211cf3c6aa3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_calvetti/example_calvetti.m
@@ -0,0 +1,101 @@
+function example_calvetti()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_calvetti.m'));
+% compile the model
+amiwrap('model_calvetti','model_calvetti_syms',exdir)
+
+% time vector
+t = linspace(0,20,201);
+p = [];
+k = [0.29 0.74 0.44 0.08 0.27 0.18];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4);
+D = amidata(length(t),6,0,2,4);
+% load mex into memory
+[~] = which('simulate_model_calvetti'); % fix for inaccessability problems
+sol = simulate_model_calvetti(t,p,k,D,options);
+
+tic
+sol = simulate_model_calvetti(t,p,k,D,options);
+disp(['Time elapsed with cvodes: ' num2str(toc) ])
+
+%%
+% ODE15S
+
+y0 = [k(1); k(3); k(5); 1; 1; 1;];
+M = [1 0 0 0 0 0 
+     0 1 0 0 0 0
+     0 0 1 0 0 0
+     0 0 0 0 0 0
+     0 0 0 0 0 0
+     0 0 0 0 0 0];
+ 
+function [xdot] = dae_system(t,x,p,k,it)
+    if it<3
+        h0 = 0;
+    else
+        h0 = 1;
+    end
+    if it<4
+        h1 = 0;
+    else
+        h1 = 1;
+    end
+    xdot = [
+    h0/31 - h1/31 - (100*x(1))/(899*k(1)) + (2*x(1)*(k(2)/2 - 1))/(31*k(1)*(x(4)*((k(2)*k(1)^2)/x(1)^2 + (k(4)*k(3)^2)/x(2)^2) + x(5)*((k(4)*k(3)^2)/x(2)^2 + (k(6)*k(5)^2)/x(3)^2) + (k(6)*k(5)^2*x(6))/x(3)^2)) + 129/899;
+    (2*x(2)*(k(2) + k(4)/2 - 1))/(163*k(3)*(x(5)*((k(4)*k(3)^2)/x(2)^2 + (k(6)*k(5)^2)/x(3)^2) + (k(6)*k(5)^2*x(6))/x(3)^2)) - (100*x(2))/(8313*k(3)) + 151/8313;
+    (x(3)^3*(k(2) + k(4) +k(6)/2 - 1))/(61*k(6)*k(5)^3*x(6)) - x(3)/(121999878*k(5)) + 500000/60999939;
+    h1/31 - h0/31 - x(4) + (100*x(1))/(899*k(1)) + (2*x(1)^2)/(k(2)*k(1)^2) - (x(1)^2*(x(4)*((k(2)*k(1)^2)/x(1)^2 + (k(4)*k(3)^2)/x(2)^2) + x(5)*((k(4)*k(3)^2)/x(2)^2 + (k(6)*k(5)^2)/x(3)^2) + (k(6)*k(5)^2*x(6))/x(3)^2))/(k(2)*k(1)^2) - (2*x(1)*(k(2)/2 - 1))/(31*k(1)*(x(4)*((k(2)*k(1)^2)/x(1)^2 + (k(4)*k(3)^2)/x(2)^2) + x(5)*((k(4)*k(3)^2)/x(2)^2 + (k(6)*k(5)^2)/x(3)^2) + (k(6)*k(5)^2*x(6))/x(3)^2)) - 129/899;
+    x(4) - x(5) + (100*x(2))/(8313*k(3)) - (2*x(2)*(k(2) + k(4)/2 - 1))/(163*k(3)*(x(5)*((k(4)*k(3)^2)/x(2)^2 + (k(6)*k(5)^2)/x(3)^2) + (k(6)*k(5)^2*x(6))/x(3)^2)) - 151/8313;
+    x(5) - x(6) + x(3)/(121999878*k(5)) - (x(3)^3*(k(2) + k(4) +k(6)/2 - 1))/(61*k(6)*k(5)^3*x(6)) - 500000/60999939;
+];
+end
+
+options_ode15s = odeset('Mass',M, ...
+                        'RelTol',options.rtol, ...
+                        'AbsTol',options.atol);
+
+tic
+X_ode15s = [];
+tt = t;
+tstop = [0,10,12,20];
+for it = 2:4
+    [~, y] = ode15s(@(t,x) dae_system(t,x,p,k,it),t(t>=tstop(it-1) & t<=tstop(it)),y0,options_ode15s);
+    X_ode15s = [X_ode15s;y(1:end-1,:)];
+    y0 = y(end,:);
+end
+X_ode15s = [X_ode15s;y(end,:)];
+disp(['Time elapsed with ode15s: ' num2str(toc) ])
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,1,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+    end
+    legend('x1','x1_{ode15s}','x2','x2_{ode15s}', ...
+           'x3','x3_{ode15s}','x4','x4_{ode15s}', ...
+           'x5','x5_{ode15s}','x6','x6_{ode15s}', ...
+           'Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,1,2)
+    plot(t,abs(sol.x-X_ode15s),'--')
+    set(gca,'YScale','log')
+    legend('error x1','error x2','error x3','error x4','error x5','error x6','Location','NorthEastOutside')
+    legend boxoff
+    ylabel('x')
+    
+    set(gcf,'Position',[100 300 1200 500])
+end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_calvetti/model_calvetti_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_calvetti/model_calvetti_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..5fc3661ebfa26528c4e98cb25c26e907dad92802
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_calvetti/model_calvetti_syms.m
@@ -0,0 +1,75 @@
+function [model] = model_calvetti_syms()
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+
+model.param = 'lin';
+
+%%
+% STATES
+% create state syms 
+syms V1 V2 V3 f1 f2 f3
+% create state vector
+model.sym.x = [V1, V2, V3, f1, f2, f3];
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms                                                                
+% create parameter vector 
+model.sym.p = [ ];
+%%  
+% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+syms V1ss R1ss V2ss R2ss V3ss R3ss
+% create parameter vector 
+model.sym.k = [V1ss, R1ss, V2ss, R2ss, V3ss, R3ss];
+%%
+% SYSTEM EQUATIONS
+% create symbolic variable for time
+syms t f0 
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+p1=1;
+p2=1-R1ss;
+p3=1-(R1ss+R2ss);
+L1=(R1ss*(V1ss^2))^(1/3);
+C1ss=V1ss/(p1-0.5*R1ss);
+
+C2ss=V2ss/(p2-0.5*R2ss);
+L2=(R2ss*(V2ss^2))^(1/3);
+C3ss=V3ss/(p3-0.5*R3ss);
+L3=(R3ss*(V3ss^2))^(1/3);
+R2=(L2^3)/(V2^2);
+R1=(L1^3)/(V1^2);
+R3=(L3^3)/(V3^2);
+s=am_stepfun(t,10,1,12,0);
+model.sym.xdot(1)=(1/31)*(((1.29 -(V1/V1ss))/(1.29-1))+s-2*(V1/(C1ss*((R1+R2)*f1+(R2+R3)*f2+R3*f3))));
+model.sym.xdot(2)=(1/163)*(((1.51 -(V2/V2ss))/(1.51-1))- 2*(V2/(C2ss*((R2+R3)*f2+R3*f3))));
+model.sym.xdot(3)=(1/122)*(((1000000 -(V3/V3ss))/(1000000-1))- 2*(V3/(C3ss*(R3*f3))));
+f0=(2/R1)-((R1+R2)*f1 + (R2+R3)*f2 +R3*f3)/R1;
+model.sym.xdot(4)=f0-model.sym.xdot(1)-f1;
+model.sym.xdot(5)=f1-model.sym.xdot(2)-f2;
+model.sym.xdot(6)=f2-model.sym.xdot(3)-f3;
+
+
+model.sym.M=[1 0 0 0 0 0; 0 1 0 0 0 0; 0 0 1 0 0 0; 0 0 0 0 0 0;0 0 0 0 0 0;0 0 0 0 0 0;];
+%%
+% INITIAL CONDITIONS
+model.sym.x0(1) = V1ss;
+model.sym.x0(2)=V2ss;
+model.sym.x0(3)=V3ss;
+model.sym.x0(4)=1;
+model.sym.x0(5)=1;
+model.sym.x0(6)=1;
+model.sym.dx0 = sym(zeros(size(model.sym.x)));
+
+% OBSERVALES
+model.sym.y = sym(zeros(1,6));
+model.sym.y(1) =V1;
+model.sym.y(2)=V2;
+model.sym.y(3)=V3;
+model.sym.y(4)=f0;
+model.sym.y(5)=f1;
+model.sym.y(6)=f2;
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/example_dirac.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/example_dirac.m
new file mode 100644
index 0000000000000000000000000000000000000000..937a5900279f3565ef0e6740d3a566ff05c79116
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/example_dirac.m
@@ -0,0 +1,179 @@
+function example_dirac()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_dirac.m'));
+% compile the model
+amiwrap('model_dirac','model_dirac_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,3,1001);
+p = [1;0.5;2;3];
+k = [];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4);
+
+options.sens_ind = 1:4;
+
+options.sens_ind = [3,4,1,2];
+
+% load mex into memory
+[msg] = which('simulate_model_dirac'); % fix for inaccessability problems
+sol = simulate_model_dirac(t,log10(p),k,[],options);
+
+tic
+sol = simulate_model_dirac(t,log10(p),k,[],options);
+disp(['Time elapsed with amiwrap: ' num2str(toc) ])
+
+%%
+% ODE15S
+
+sig = 1e-2;
+delta_num = @(tau) exp(-1/2*(tau/sig).^2)/(sqrt(2*pi)*sig);
+
+ode_system = @(t,x,p,k) [-p(1)*x(1)+delta_num(t-p(2));
+    +p(3)*x(1) - p(4)*x(2)];
+
+options_ode45 = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+tic
+[~, X_ode45] = ode45(@(t,x) ode_system(t,x,p,k),t,[0;0],options_ode45);
+disp(['Time elapsed with ode45: ' num2str(toc) ])
+
+%%
+% PLOTTING
+
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode45(:,ix),'--','Color',c_x(ix,:))
+    end
+    
+    legend('x1','x1_{ode45}','x2','x2_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode45),'--')
+    set(gca,'YScale','log')
+    ylim([1e-10,1e0])
+    legend('error x1','error x2','Location','NorthEastOutside')
+    legend boxoff
+    
+    subplot(2,2,3)
+    plot(t,sol.y,'.-','Color',c_x(1,:))
+    hold on
+    plot(t,X_ode45(:,2),'--','Color',c_x(1,:))
+    legend('y1','y1_{ode45}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    
+    subplot(2,2,4)
+    plot(t,abs(sol.y-X_ode45(:,2)),'--')
+    set(gca,'YScale','log')
+    ylim([1e-10,1e0])
+    legend('error y1','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    set(gcf,'Position',[100 300 1200 500])
+end
+
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 1;
+
+sol = simulate_model_dirac(t,log10(p),k,[],options);
+
+%%
+% FINITE DIFFERENCES
+
+eps = 1e-4;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(options.sens_ind(ip)) = xip(options.sens_ind(ip)) + eps;
+    solp = simulate_model_dirac(t,xip,k,[],options);
+    sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+    sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    for ip = 1:length(options.sens_ind)
+        subplot(length(options.sens_ind),2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,ip),'--','Color',c_x(ix,:))
+        end
+        ylim([-2,2])
+        legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('x')
+        box on
+        
+        subplot(length(options.sens_ind),2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'r--')
+        legend('error x1','error x2','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    for ip = 1:length(options.sens_ind)
+        subplot(length(options.sens_ind),2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.sy(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,sy_fd(:,iy,ip),'--','Color',c_x(iy,:))
+        end
+        ylim([-2,2])
+        legend('y1','y1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('y')
+        box on
+        
+        subplot(length(options.sens_ind),2,ip*2)
+        plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'r--')
+        legend('error y1','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/example_dirac.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/example_dirac.html
new file mode 100644
index 0000000000000000000000000000000000000000..21d9354dda067f0575aa6957fa4f1dff80796111
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/example_dirac.html
@@ -0,0 +1,396 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_dirac</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_dirac.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_dirac()
+</pre><p>COMPILATION</p><pre class="codeinput">    [exdir,~,~]=fileparts(which(<span class="string">'example_dirac.m'</span>));
+    <span class="comment">% compile the model</span>
+    amiwrap(<span class="string">'model_dirac'</span>,<span class="string">'model_dirac_syms'</span>,exdir)
+</pre><pre class="codeoutput">Generating model struct ...
+Parsing model struct ...
+Generating C code ...
+headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput">    <span class="comment">% time vector</span>
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+
+    options = amioption(<span class="string">'sensi'</span>,0,<span class="keyword">...</span>
+        <span class="string">'maxsteps'</span>,1e4);
+
+    <span class="comment">% load mex into memory</span>
+    [msg] = which(<span class="string">'simulate_model_dirac'</span>); <span class="comment">% fix for inaccessability problems</span>
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+
+    tic
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+    disp([<span class="string">'Time elapsed with amiwrap: '</span> num2str(toc) ])
+</pre><pre class="codeoutput">Time elapsed with amiwrap: 0.0049341
+</pre><p>ODE15S</p><pre class="codeinput">    sig = 1e-2;
+    delta_num = @(tau) exp(-1/2*(tau/sig).^2)/(sqrt(2*pi)*sig);
+
+    ode_system = @(t,x,p,k) [-p(1)*x(1)+delta_num(t-p(2));
+        +p(3)*x(1) - p(4)*x(2)];
+
+    options_ode45 = odeset(<span class="string">'RelTol'</span>,options.rtol,<span class="string">'AbsTol'</span>,options.atol,<span class="string">'MaxStep'</span>,options.maxsteps);
+
+    tic
+    [~, X_ode45] = ode45(@(t,x) ode_system(t,x,p,k),t,[0;0],options_ode45);
+    disp([<span class="string">'Time elapsed with ode45: '</span> num2str(toc) ])
+</pre><pre class="codeoutput">Time elapsed with ode45: 0.097728
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    c_x = get(gca,<span class="string">'ColorOrder'</span>);
+    subplot(2,2,1)
+    <span class="keyword">for</span> ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        hold <span class="string">on</span>
+        plot(t,X_ode45(:,ix),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+    <span class="keyword">end</span>
+
+    legend(<span class="string">'x1'</span>,<span class="string">'x1_{ode45}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{ode15s}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'x'</span>)
+    box <span class="string">on</span>
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode45),<span class="string">'--'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    ylim([1e-10,1e0])
+    legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+
+    subplot(2,2,3)
+    plot(t,sol.y,<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(1,:))
+    hold <span class="string">on</span>
+    plot(t,X_ode45(:,2),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(1,:))
+    legend(<span class="string">'y1'</span>,<span class="string">'y1_{ode45}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'y'</span>)
+    box <span class="string">on</span>
+
+    subplot(2,2,4)
+    plot(t,abs(sol.y-X_ode45(:,2)),<span class="string">'--'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    ylim([1e-10,1e0])
+    legend(<span class="string">'error y1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'y'</span>)
+    box <span class="string">on</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+</pre><img vspace="5" hspace="5" src="../examples/example_dirac/html/example_dirac_01.png" alt=""> <p>FORWARD SENSITIVITY ANALYSIS</p><pre class="codeinput">    options.sensi = 1;
+
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+</pre><p>FINITE DIFFERENCES</p><pre class="codeinput">    eps = 1e-4;
+    xi = log10(p);
+    <span class="keyword">for</span> ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac(t,xip,k,[],options);
+        sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+        sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    <span class="keyword">end</span>
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    <span class="keyword">for</span> ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold <span class="string">on</span>
+        <span class="keyword">for</span> ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+            plot(t,sx_fd(:,ix,ip),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        <span class="keyword">end</span>
+        ylim([-2,2])
+        legend(<span class="string">'x1'</span>,<span class="string">'x1_{fd}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'state sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'x'</span>)
+        box <span class="string">on</span>
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),<span class="string">'r--'</span>)
+        legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'state sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'error'</span>)
+        ylim([1e-12,1e0])
+        set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+        box <span class="string">on</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    figure
+    <span class="keyword">for</span> ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold <span class="string">on</span>
+        <span class="keyword">for</span> iy = 1:size(sol.y,2)
+            plot(t,sol.sy(:,iy,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(iy,:))
+            plot(t,sy_fd(:,iy,ip),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(iy,:))
+        <span class="keyword">end</span>
+        ylim([-2,2])
+        legend(<span class="string">'y1'</span>,<span class="string">'y1_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'observable sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'y'</span>)
+        box <span class="string">on</span>
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),<span class="string">'r--'</span>)
+        legend(<span class="string">'error y1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'observable sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'error'</span>)
+        ylim([1e-12,1e0])
+        set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+        box <span class="string">on</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_dirac/html/example_dirac_02.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_dirac/html/example_dirac_03.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_dirac()
+    %%
+    % COMPILATION
+    
+    [exdir,~,~]=fileparts(which('example_dirac.m'));
+    % compile the model
+    amiwrap('model_dirac','model_dirac_syms',exdir)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+    
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+    
+    % load mex into memory
+    [msg] = which('simulate_model_dirac'); % fix for inaccessability problems
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+    
+    tic
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+    disp(['Time elapsed with amiwrap: ' num2str(toc) ])
+    
+    %%
+    % ODE15S
+    
+    sig = 1e-2;
+    delta_num = @(tau) exp(-1/2*(tau/sig).^2)/(sqrt(2*pi)*sig);
+    
+    ode_system = @(t,x,p,k) [-p(1)*x(1)+delta_num(t-p(2));
+        +p(3)*x(1) - p(4)*x(2)];
+    
+    options_ode45 = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+    
+    tic
+    [~, X_ode45] = ode45(@(t,x) ode_system(t,x,p,k),t,[0;0],options_ode45);
+    disp(['Time elapsed with ode45: ' num2str(toc) ])
+    
+    %%
+    % PLOTTING
+    
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode45(:,ix),'REPLACE_WITH_DASH_DASH','Color',c_x(ix,:))
+    end
+    
+    legend('x1','x1_{ode45}','x2','x2_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode45),'REPLACE_WITH_DASH_DASH')
+    set(gca,'YScale','log')
+    ylim([1e-10,1e0])
+    legend('error x1','error x2','Location','NorthEastOutside')
+    legend boxoff
+    
+    subplot(2,2,3)
+    plot(t,sol.y,'.-','Color',c_x(1,:))
+    hold on
+    plot(t,X_ode45(:,2),'REPLACE_WITH_DASH_DASH','Color',c_x(1,:))
+    legend('y1','y1_{ode45}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    
+    subplot(2,2,4)
+    plot(t,abs(sol.y-X_ode45(:,2)),'REPLACE_WITH_DASH_DASH')
+    set(gca,'YScale','log')
+    ylim([1e-10,1e0])
+    legend('error y1','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    set(gcf,'Position',[100 300 1200 500])
+    
+    
+    %%
+    % FORWARD SENSITIVITY ANALYSIS
+    
+    options.sensi = 1;
+    
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+    
+    %%
+    % FINITE DIFFERENCES
+    
+    eps = 1e-4;
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac(t,xip,k,[],options);
+        sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+        sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    end
+    
+    %%
+    % PLOTTING
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,ip),'REPLACE_WITH_DASH_DASH','Color',c_x(ix,:))
+        end
+        ylim([-2,2])
+        legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'rREPLACE_WITH_DASH_DASH')
+        legend('error x1','error x2','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.sy(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,sy_fd(:,iy,ip),'REPLACE_WITH_DASH_DASH','Color',c_x(iy,:))
+        end
+        ylim([-2,2])
+        legend('y1','y1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('y')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'rREPLACE_WITH_DASH_DASH')
+        legend('error y1','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+    
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/example_dirac.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/example_dirac.tex
new file mode 100644
index 0000000000000000000000000000000000000000..5f520666a37f527ce4db9db87daf9db443bcb903
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/example_dirac.tex
@@ -0,0 +1,226 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_dirac()
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    [exdir,~,~]=fileparts(which('example_dirac.m'));
+    % compile the model
+    amiwrap('model_dirac','model_dirac_syms',exdir)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+Parsing model struct ...
+
+Generating C code ...
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    % time vector
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+
+    % load mex into memory
+    [msg] = which('simulate_model_dirac'); % fix for inaccessability problems
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+
+    tic
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+    disp(['Time elapsed with amiwrap: ' num2str(toc) ])
+\end{DoxyCode}
+
+         \begin{DoxyCode}Time elapsed with amiwrap: 0.0045507
+\end{DoxyCode} 
+    \begin{par}
+ODE15S
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    sig = 1e-2;
+    delta_num = @(tau) exp(-1/2*(tau/sig).^2)/(sqrt(2*pi)*sig);
+
+    ode_system = @(t,x,p,k) [-p(1)*x(1)+delta_num(t-p(2));
+        +p(3)*x(1) - p(4)*x(2)];
+
+    options_ode45 = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+    tic
+    [~, X_ode45] = ode45(@(t,x) ode_system(t,x,p,k),t,[0;0],options_ode45);
+    disp(['Time elapsed with ode45: ' num2str(toc) ])
+\end{DoxyCode}
+
+         \begin{DoxyCode}Time elapsed with ode45: 0.080371
+\end{DoxyCode} 
+    \begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode45(:,ix),'--','Color',c_x(ix,:))
+    end
+
+    legend('x1','x1_{ode45}','x2','x2_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode45),'--')
+    set(gca,'YScale','log')
+    ylim([1e-10,1e0])
+    legend('error x1','error x2','Location','NorthEastOutside')
+    legend boxoff
+
+    subplot(2,2,3)
+    plot(t,sol.y,'.-','Color',c_x(1,:))
+    hold on
+    plot(t,X_ode45(:,2),'--','Color',c_x(1,:))
+    legend('y1','y1_{ode45}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+
+    subplot(2,2,4)
+    plot(t,abs(sol.y-X_ode45(:,2)),'--')
+    set(gca,'YScale','log')
+    ylim([1e-10,1e0])
+    legend('error y1','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    set(gcf,'Position',[100 300 1200 500])
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac/html/example_dirac_01.png}
+\begin{par}
+FORWARD SENSITIVITY ANALYSIS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    options.sensi = 1;
+
+    sol = simulate_model_dirac(t,log10(p),k,[],options);
+\end{DoxyCode}
+\begin{par}
+FINITE DIFFERENCES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    eps = 1e-4;
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac(t,xip,k,[],options);
+        sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+        sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    end
+\end{DoxyCode}
+\begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,ip),'--','Color',c_x(ix,:))
+        end
+        ylim([-2,2])
+        legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'r--')
+        legend('error x1','error x2','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.sy(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,sy_fd(:,iy,ip),'--','Color',c_x(iy,:))
+        end
+        ylim([-2,2])
+        legend('y1','y1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('y')
+        box on
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'r--')
+        legend('error y1','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac/html/example_dirac_02.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac/html/example_dirac_03.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/model_dirac_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/model_dirac_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..2ab780a1227f2e7944bb52179bd1f3cae35d051e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/model_dirac_syms.html
@@ -0,0 +1,159 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_dirac_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_dirac_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_dirac_syms()
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span> <span class="string">x2</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [ x1 x2 ];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1,p2,p3,p4];
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+<span class="comment">% inhomogeneous</span>
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_dirac_syms()
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/model_dirac_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/model_dirac_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..2a8bd67c0fba58b92b03bdc40e16b35fd2245c19
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/html/model_dirac_syms.tex
@@ -0,0 +1,86 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_dirac_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/model_dirac_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/model_dirac_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..6c89ab26e2abc582a49f151d217841a80897b359
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac/model_dirac_syms.m
@@ -0,0 +1,52 @@
+function [model] = model_dirac_syms()
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(p2-t);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/example_dirac_adjoint.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/example_dirac_adjoint.m
new file mode 100644
index 0000000000000000000000000000000000000000..f5f2b23da0ae233454378dd3ea27d328953699ce
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/example_dirac_adjoint.m
@@ -0,0 +1,85 @@
+function example_dirac_adjoint()
+%%
+% COMPILATION
+[exdir,~,~]=fileparts(which('example_dirac_adjoint.m'));
+% compile the model
+amiwrap('model_dirac_adjoint','model_dirac_adjoint_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+tout = linspace(0,4,9);
+tfine = linspace(0,4,10001);
+p = [1;0.4;2;3];
+k = [];
+
+D.Y = [  0.00714742903826096
+    -0.00204966058299775
+    0.382159034587845
+    0.33298932672138
+    0.226111476113441
+    0.147028440865854
+    0.0882468698791813
+    0.0375887796628869
+    0.0373422340295005];
+
+D.Sigma_Y = 0.01*ones(size(D.Y));
+
+
+options.sensi = 1;
+options.sensi_meth = 'adjoint';
+options.maxsteps = 1e5;
+sol = simulate_model_dirac_adjoint(tout,log10(p),k,D,options);
+options.sensi = 0;
+solfine = simulate_model_dirac_adjoint(tfine,log10(p),k,[],options);
+if(usejava('jvm'))
+    figure
+    errorbar(tout,D.Y,D.Sigma_Y)
+    hold on
+    plot(tfine,solfine.y)
+    legend('data','simulation')
+    xlabel('time t')
+    ylabel('observable')
+    title(['log-likelihood: ' num2str(sol.llh) ])
+end
+
+%%
+% FD
+
+eps = 1e-4;
+xi = log10(p);
+grad_fd_f = NaN(4,1);
+grad_fd_b = NaN(4,1);
+for ip = 1:4;
+    options.sensi = 0;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solpf = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+    grad_fd_f(ip,1) = (solpf.llh-sol.llh)/eps;
+    xip = xi;
+    xip(ip) = xip(ip) - eps;
+    solpb = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+    grad_fd_b(ip,1) = -(solpb.llh-sol.llh)/eps;
+end
+
+if(usejava('jvm'))
+    figure
+    plot(abs(grad_fd_f),abs(sol.sllh),'o')
+    hold on
+    plot(abs(grad_fd_b),abs(sol.sllh),'o')
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    hold on
+    axis square
+    plot([1e2,1e4],[1e2,1e4],'k:')
+    xlim([1e2,1e4])
+    ylim([1e2,1e4])
+    legend('forward FD','backward FD','Location','SouthEast')
+    xlabel('adjoint sensitivity absolute value of gradient element')
+    ylabel('computed absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/example_model_5_paper.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/example_model_5_paper.m
new file mode 100644
index 0000000000000000000000000000000000000000..d3c0758f60edb29f544cdeb67967e0080239f9eb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/example_model_5_paper.m
@@ -0,0 +1,249 @@
+clear
+%% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_model_5.m'));
+cd(exdir)
+% compile the model
+amiwrap('model_example_5','example_model_5_syms',exdir)
+
+%% SIMULATION
+
+% time vector
+tout = linspace(0,4,9);
+tfine = linspace(0,4,10001);
+p = [1;0.5;2;3];
+k = [];
+
+D.Y = [  0.00714742903826096
+      -0.00204966058299775
+         0.382159034587845
+          0.33298932672138
+         0.226111476113441
+         0.147028440865854
+        0.0882468698791813
+        0.0375887796628869
+        0.0373422340295005];
+
+D.Sigma_Y = 0.01*ones(size(D.Y));
+
+
+options.sensi = 1;
+options.sensi_meth = 'adjoint';
+options.maxsteps = 2e4;
+sol = simulate_model_example_5(tout,log10(p),k,D,options);
+options.sensi = 0;
+solfine = simulate_model_example_5(tfine,log10(p),k,[],options);
+
+figure
+errorbar(tout,D.Y,D.Sigma_Y)
+hold on
+plot(tfine,solfine.y)
+legend('data','simulation')
+xlabel('time t')
+ylabel('observable')
+title(['log-likelihood: ' num2str(sol.llh) ])
+
+%% SYMBOLIC SOLUTION
+
+syms x1(t) x2(t)
+eqn1 = diff(x1) == -p(1)*x1;
+eqn2 = x1(p(2)) == 1;
+eqn3 = diff(x2) == p(3)*x1 - p(4)*x2;
+eqn4 = x2(p(2)) == 0;
+
+S = dsolve(eqn1,eqn2,eqn3,eqn4);
+xx1 = matlabFunction(S.x1);
+xx2 = matlabFunction(S.x2);
+
+tfine = linspace(0,4,10001);
+x1fine = xx1(tfine).*(tfine>=p(2));
+x2fine = xx2(tfine).*(tfine>=p(2));
+
+syms xB1(t) xB2(t)
+eqn1B = diff(xB1) == p(1)*xB1 - p(3)*xB2;
+eqn3B = diff(xB2) == p(4)*xB2;
+
+syms sigma my 
+x = sym('x',[2,1]);
+J = -0.5*((x(2) - my)/sigma)^2;
+dJdx = jacobian(J,x);
+m0 = matlabFunction(dJdx);
+
+mu1fine = zeros(size(x1fine));
+mu2fine = zeros(size(x2fine));
+for it = 1:length(tout);
+    mm0 = m0(D.Y(it),D.Sigma_Y(it),x2fine(tfine == tout(it)));
+    eqn2B = xB1(tout(it)) == mm0(1);
+    eqn4B = xB2(tout(it)) == mm0(2);
+    S = dsolve(eqn1B,eqn2B,eqn3B,eqn4B);
+    xxB1 = matlabFunction(S.xB1);
+    xxB2 = matlabFunction(S.xB2);
+    mu1fine = mu1fine + xxB1(tfine).*(tfine<=tout(it));
+    mu2fine = mu2fine + xxB2(tfine).*(tfine<=tout(it));
+end
+
+grad(1,1) = trapz(tfine,-x1fine.*mu1fine)*p(1)*log(10);
+t_idx = find(tfine == p(2));
+grad(2,1) = -(p(3)*mu2fine(t_idx)-p(1)*mu1fine(t_idx))*p(2)*log(10);
+grad(3,1) = trapz(tfine,x1fine.*mu2fine)*p(3)*log(10);
+grad(4,1) = trapz(tfine,-x2fine.*mu2fine)*p(4)*log(10);
+
+%% FD
+
+eps = 1e-7;
+xi = log10(p);
+grad_fd_f = NaN(4,1);
+grad_fd_b = NaN(4,1);
+for ip = 1:4;
+    options.sensi = 0;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solpf = simulate_model_example_5(tout,xip,k,D,options);
+    grad_fd_f(ip,1) = (solpf.llh-sol.llh)/eps;
+    xip = xi;
+    xip(ip) = xip(ip) - eps;
+    solpb = simulate_model_example_5(tout,xip,k,D,options);
+    grad_fd_b(ip,1) = -(solpb.llh-sol.llh)/eps;
+end
+
+figure
+scatter(abs(grad_fd_f),abs(sol.sllh))
+hold on
+scatter(abs(grad_fd_b),abs(sol.sllh))
+set(gca,'XScale','log')
+set(gca,'YScale','log')
+hold on
+plot([1e1,1e4],[1e1,1e4],'k:')
+xlim([1e1,1e4])
+ylim([1e1,1e4])
+legend('forward FD','backward FD')
+
+%% figures paper
+
+fs = 20;
+lw = 2;
+lwf = 1.5;
+cm = lines;
+
+% system
+
+figure
+plot(tout,D.Y,'x','LineWidth',2*lw,'Color',cm(5,:),'MarkerSize',15)
+hold on
+plot(tfine,solfine.y,'k','LineWidth',lw)
+xlabel('time t')
+ylabel('observable')
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+xlim([-0.1,4.1])
+ylim([-0.05,0.4])
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['y'])
+
+% finite differences
+figure
+plot(tfine,solfine.y,'k:','LineWidth',lw)
+hold on
+xip = xi;
+xip(1) = xip(1) + 1e-1;
+solp = simulate_model_example_5(tfine,xip,k,[],options);
+plot(tfine,solp.y,'LineWidth',lw,'Color',cm(1,:))
+xlabel('time')
+ylabel('observable')
+xlim([-0.1,4.1])
+ylim([-0.05,0.4])
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['sy_fd'])
+
+
+figure
+bar(1:4,grad_fd_b,'LineWidth',lw,'FaceColor',[0.5,0.5,0.5])
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+ylabel('sensitivity J')
+xlabel('parameters')
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+ylim([-300,300])
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['sJ_fd'])
+
+% forward sensitivities
+options.sensi = 1;
+options.sensi_meth = 'forward';
+options.maxsteps = 1e6;
+% load mex into memory
+sol = simulate_model_example_5(tfine,log10(p),k,[],options);
+
+figure
+hold on
+plot(tfine,sol.sy(:,:,1),'LineWidth',lw,'Color',cm(2,:))
+box on
+xlabel('time')
+ylabel('obs. sensitivity')
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+ylim([-0.6,0.4])
+xlim([-0.1,4.1])
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['sy_fsa'])
+
+sol = simulate_model_example_5(tout,log10(p),k,[],options);
+sJ = -(squeeze(sol.sy)')*((sol.y-D.Y)./(D.Sigma_Y.^2));
+figure
+bar(1:4,sJ,'LineWidth',lw,'FaceColor',[0.5,0.5,0.5])
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+xlabel('parameters')
+ylabel('sensitivity J')
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+ylim([-300,300])
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['sJ_fsa'])
+
+% adjoint sensitivities
+
+figure
+plot(tfine,mu1fine,'LineWidth',lw,'Color',cm(3,:))
+hold on
+plot(tfine,mu2fine,'LineWidth',lw,'Color',cm(3,:))
+xlabel('time')
+ylabel('adjoint state')
+xlim([-0.1,4.1])
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['sy_asa'])
+
+figure
+bar(0,sum(-x1fine.*mu1fine*(4/(length(tfine)-1))*p(1)*log(10)),'LineWidth',lw,'FaceColor',[0.5,0.5,0.5])
+hold on
+plot(tfine,fliplr(cumsum(fliplr(-x1fine.*mu1fine*(4/(length(tfine)-1))*p(1)*log(10)))),'LineWidth',lw,'Color',cm(3,:))
+scatter(0,sum(-x1fine.*mu1fine*(4/(length(tfine)-1))*p(1)*log(10)),40,cm(3,:),'o','LineWidth',lw)
+xlabel('time')
+ylabel('sensitivity J')
+set(gca,'FontSize',fs)
+set(gca,'LineWidth',lwf)
+set(gca,'XTick',[])
+set(gca,'YTick',[])
+ylim([-300,300])
+xlim([-0.1,4.1])
+set(gcf,'PaperPositionMode','auto','Position',[100 300 300 200])
+print('-depsc','-r300',['sJ_asa'])
+
+
+
+
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/example_dirac_adjoint.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/example_dirac_adjoint.html
new file mode 100644
index 0000000000000000000000000000000000000000..28ebfd25110ed52a3f6b7230c2302e98b375178d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/example_dirac_adjoint.html
@@ -0,0 +1,232 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_dirac_adjoint</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_dirac_adjoint.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_dirac_adjoint()
+</pre><p>COMPILATION</p><pre class="codeinput">    [exdir,~,~]=fileparts(which(<span class="string">'example_dirac_adjoint.m'</span>));
+    <span class="comment">% compile the model</span>
+    amiwrap(<span class="string">'model_dirac_adjoint'</span>,<span class="string">'model_dirac_adjoint_syms'</span>,exdir)
+</pre><pre class="codeoutput">Generating model struct ...
+Parsing model struct ...
+Generating C code ...
+headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput">    <span class="comment">% time vector</span>
+    tout = linspace(0,4,9);
+    tfine = linspace(0,4,10001);
+    p = [1;0.4;2;3];
+    k = [];
+
+    D.Y = [  0.00714742903826096
+        -0.00204966058299775
+        0.382159034587845
+        0.33298932672138
+        0.226111476113441
+        0.147028440865854
+        0.0882468698791813
+        0.0375887796628869
+        0.0373422340295005];
+
+    D.Sigma_Y = 0.01*ones(size(D.Y));
+
+
+    options.sensi = 1;
+    options.sensi_meth = <span class="string">'adjoint'</span>;
+    options.maxsteps = 1e5;
+    sol = simulate_model_dirac_adjoint(tout,log10(p),k,D,options);
+    options.sensi = 0;
+    solfine = simulate_model_dirac_adjoint(tfine,log10(p),k,[],options);
+    figure
+    errorbar(tout,D.Y,D.Sigma_Y)
+    hold <span class="string">on</span>
+    plot(tfine,solfine.y)
+    legend(<span class="string">'data'</span>,<span class="string">'simulation'</span>)
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'observable'</span>)
+    title([<span class="string">'log-likelihood: '</span> num2str(sol.llh) ])
+</pre><img vspace="5" hspace="5" src="../examples/example_dirac_adjoint/html/example_dirac_adjoint_01.png" alt=""> <p>FD</p><pre class="codeinput">    eps = 1e-4;
+    xi = log10(p);
+    grad_fd_f = NaN(4,1);
+    grad_fd_b = NaN(4,1);
+    <span class="keyword">for</span> ip = 1:4;
+        options.sensi = 0;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solpf = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+        grad_fd_f(ip,1) = (solpf.llh-sol.llh)/eps;
+        xip = xi;
+        xip(ip) = xip(ip) - eps;
+        solpb = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+        grad_fd_b(ip,1) = -(solpb.llh-sol.llh)/eps;
+    <span class="keyword">end</span>
+
+    figure
+    plot(abs(grad_fd_f),abs(sol.sllh),<span class="string">'o'</span>)
+    hold <span class="string">on</span>
+    plot(abs(grad_fd_b),abs(sol.sllh),<span class="string">'o'</span>)
+    set(gca,<span class="string">'XScale'</span>,<span class="string">'log'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    hold <span class="string">on</span>
+    axis <span class="string">square</span>
+    plot([1e2,1e4],[1e2,1e4],<span class="string">'k:'</span>)
+    xlim([1e2,1e4])
+    ylim([1e2,1e4])
+    legend(<span class="string">'forward FD'</span>,<span class="string">'backward FD'</span>,<span class="string">'Location'</span>,<span class="string">'SouthEast'</span>)
+    xlabel(<span class="string">'adjoint sensitivity absolute value of gradient element'</span>)
+    ylabel(<span class="string">'computed absolute value of gradient element'</span>)
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_dirac_adjoint/html/example_dirac_adjoint_02.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_dirac_adjoint()
+    %%
+    % COMPILATION
+    [exdir,~,~]=fileparts(which('example_dirac_adjoint.m'));
+    % compile the model
+    amiwrap('model_dirac_adjoint','model_dirac_adjoint_syms',exdir)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    tout = linspace(0,4,9);
+    tfine = linspace(0,4,10001);
+    p = [1;0.4;2;3];
+    k = [];
+    
+    D.Y = [  0.00714742903826096
+        -0.00204966058299775
+        0.382159034587845
+        0.33298932672138
+        0.226111476113441
+        0.147028440865854
+        0.0882468698791813
+        0.0375887796628869
+        0.0373422340295005];
+    
+    D.Sigma_Y = 0.01*ones(size(D.Y));
+    
+    
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    options.maxsteps = 1e5;
+    sol = simulate_model_dirac_adjoint(tout,log10(p),k,D,options);
+    options.sensi = 0;
+    solfine = simulate_model_dirac_adjoint(tfine,log10(p),k,[],options);
+    figure
+    errorbar(tout,D.Y,D.Sigma_Y)
+    hold on
+    plot(tfine,solfine.y)
+    legend('data','simulation')
+    xlabel('time t')
+    ylabel('observable')
+    title(['log-likelihood: ' num2str(sol.llh) ])
+    
+    %%
+    % FD
+    
+    eps = 1e-4;
+    xi = log10(p);
+    grad_fd_f = NaN(4,1);
+    grad_fd_b = NaN(4,1);
+    for ip = 1:4;
+        options.sensi = 0;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solpf = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+        grad_fd_f(ip,1) = (solpf.llh-sol.llh)/eps;
+        xip = xi;
+        xip(ip) = xip(ip) - eps;
+        solpb = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+        grad_fd_b(ip,1) = -(solpb.llh-sol.llh)/eps;
+    end
+    
+    figure
+    plot(abs(grad_fd_f),abs(sol.sllh),'o')
+    hold on
+    plot(abs(grad_fd_b),abs(sol.sllh),'o')
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    hold on
+    axis square
+    plot([1e2,1e4],[1e2,1e4],'k:')
+    xlim([1e2,1e4])
+    ylim([1e2,1e4])
+    legend('forward FD','backward FD','Location','SouthEast')
+    xlabel('adjoint sensitivity absolute value of gradient element')
+    ylabel('computed absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/example_dirac_adjoint.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/example_dirac_adjoint.tex
new file mode 100644
index 0000000000000000000000000000000000000000..c112059a4c079afa997da79de608e52711c87e10
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/example_dirac_adjoint.tex
@@ -0,0 +1,126 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_dirac_adjoint()
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    [exdir,~,~]=fileparts(which('example_dirac_adjoint.m'));
+    % compile the model
+    amiwrap('model_dirac_adjoint','model_dirac_adjoint_syms',exdir)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+Parsing model struct ...
+
+Generating C code ...
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    % time vector
+    tout = linspace(0,4,9);
+    tfine = linspace(0,4,10001);
+    p = [1;0.4;2;3];
+    k = [];
+
+    D.Y = [  0.00714742903826096
+        -0.00204966058299775
+        0.382159034587845
+        0.33298932672138
+        0.226111476113441
+        0.147028440865854
+        0.0882468698791813
+        0.0375887796628869
+        0.0373422340295005];
+
+    D.Sigma_Y = 0.01*ones(size(D.Y));
+
+
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    options.maxsteps = 1e5;
+    sol = simulate_model_dirac_adjoint(tout,log10(p),k,D,options);
+    options.sensi = 0;
+    solfine = simulate_model_dirac_adjoint(tfine,log10(p),k,[],options);
+    figure
+    errorbar(tout,D.Y,D.Sigma_Y)
+    hold on
+    plot(tfine,solfine.y)
+    legend('data','simulation')
+    xlabel('time t')
+    ylabel('observable')
+    title(['log-likelihood: ' num2str(sol.llh) ])
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac_adjoint/html/example_dirac_adjoint_01.png}
+\begin{par}
+FD
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    eps = 1e-4;
+    xi = log10(p);
+    grad_fd_f = NaN(4,1);
+    grad_fd_b = NaN(4,1);
+    for ip = 1:4;
+        options.sensi = 0;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solpf = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+        grad_fd_f(ip,1) = (solpf.llh-sol.llh)/eps;
+        xip = xi;
+        xip(ip) = xip(ip) - eps;
+        solpb = simulate_model_dirac_adjoint(tout,xip,k,D,options);
+        grad_fd_b(ip,1) = -(solpb.llh-sol.llh)/eps;
+    end
+
+    figure
+    plot(abs(grad_fd_f),abs(sol.sllh),'o')
+    hold on
+    plot(abs(grad_fd_b),abs(sol.sllh),'o')
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    hold on
+    axis square
+    plot([1e2,1e4],[1e2,1e4],'k:')
+    xlim([1e2,1e4])
+    ylim([1e2,1e4])
+    legend('forward FD','backward FD','Location','SouthEast')
+    xlabel('adjoint sensitivity absolute value of gradient element')
+    ylabel('computed absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+
+    drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac_adjoint/html/example_dirac_adjoint_02.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/model_dirac_adjoint_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/model_dirac_adjoint_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..ad7f799377fafaaa9c65a8978bc3628b5a7944c3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/model_dirac_adjoint_syms.html
@@ -0,0 +1,161 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_dirac_adjoint_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_dirac_adjoint_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_dirac_adjoint_syms()
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span> <span class="string">x2</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [ x1 x2 ];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1,p2,p3,p4];
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+<span class="comment">% inhomogeneous</span>
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_dirac_adjoint_syms()
+
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/model_dirac_adjoint_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/model_dirac_adjoint_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..a7a9033e5f59f192b59bb2da6fa78f523f1742be
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/html/model_dirac_adjoint_syms.tex
@@ -0,0 +1,86 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_dirac_adjoint_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/model_dirac_adjoint_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/model_dirac_adjoint_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..488d97b901c74d801925700c087bd8fcfdd3a02b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint/model_dirac_adjoint_syms.m
@@ -0,0 +1,54 @@
+function [model] = model_dirac_adjoint_syms()
+
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint_hessVecProd/example_dirac_adjoint_hessVecProd.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint_hessVecProd/example_dirac_adjoint_hessVecProd.m
new file mode 100644
index 0000000000000000000000000000000000000000..25cbd23ffb30fbefc6b93446089788ccff981cb1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint_hessVecProd/example_dirac_adjoint_hessVecProd.m
@@ -0,0 +1,59 @@
+
+% COMPILATION
+[exdir,~,~]=fileparts(which('example_dirac_adjoint_hessVecProd.m'));
+% compile the model
+amiwrap('model_dirac_adjoint_hessVecProd','model_dirac_adjoint_hessVecProd_syms',exdir,2)
+
+%%
+% SIMULATION
+
+% time vector
+tout = linspace(0,4,9);
+tfine = linspace(0,4,10001);
+p = [1;0.4;2;3];
+k = [];
+options.rtol = 1e-13;
+options.atol = 1e-13;
+options.maxsteps = 1e5;
+options.sensi_meth = 'adjoint';
+
+D.Y = [  0.00714742903826096
+    -0.00204966058299775
+    0.382159034587845
+    0.33298932672138
+    0.226111476113441
+    0.147028440865854
+    0.0882468698791813
+    0.0375887796628869
+    0.0373422340295005];
+D.Sigma_Y = 0.01*ones(size(D.Y));
+
+
+% Calculation of gradient for direction
+% options.sensi = 1;
+% preSol = simulate_model_dirac_adjoint(tout,log10(p),k,D,options);
+% v = preSol.sllh;
+% vNorm = v / sqrt(sum(v.^2));
+v = [-489.2922358301243; 0; -145.7917085979483; -499.2157643879079];
+vNorm = v / sqrt(sum(v.^2));
+
+% Calculation of Hessian vector product
+options.sensi = 2;
+sol = simulate_model_dirac_adjoint_hessVecProd(tout,log10(p),k,D,options,v);
+ASA_HVP = sol.s2llh;
+format long;
+fprintf('2nd order Adjoints, HVP: \n');
+disp(ASA_HVP);
+
+% Verification using Finite Differences
+delta = 1e-7;
+options.sensi = 1;
+sol_p = simulate_model_dirac_adjoint_hessVecProd(tout, log10(p) + delta * v, k, D, options);
+sol_m = simulate_model_dirac_adjoint_hessVecProd(tout, log10(p) - delta * v, k, D, options);
+FD_HVP = (sol_p.sllh - sol_m.sllh)/(2*delta);
+
+% Output of results
+
+fprintf('Finite differences, HVP: \n');
+disp(FD_HVP);
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint_hessVecProd/model_dirac_adjoint_hessVecProd_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint_hessVecProd/model_dirac_adjoint_hessVecProd_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..b254bfcc5f59aff04292a1e26c8d7789acf38796
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_adjoint_hessVecProd/model_dirac_adjoint_hessVecProd_syms.m
@@ -0,0 +1,54 @@
+function [model] = model_dirac_adjoint_hessVecProd_syms()
+
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/example_dirac_secondorder.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/example_dirac_secondorder.m
new file mode 100644
index 0000000000000000000000000000000000000000..cba5ba56cc822768a83787c97e9622d280837067
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/example_dirac_secondorder.m
@@ -0,0 +1,94 @@
+function example_dirac_secondorder()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_dirac_secondorder.m'));
+% compile the model
+amiwrap('model_dirac_secondorder','model_dirac_secondorder_syms',exdir,1)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,3,1001);
+p = [1;0.5;2;3];
+k = [];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4);
+options.sens_ind = [3,1,2];
+
+% load mex into memory
+[msg] = which('simulate_model_secondorder_dirac'); % fix for inaccessability problems
+options.sensi = 2;
+sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 2;
+
+sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+
+%%
+% FINITE DIFFERENCES
+
+optionsfd = options;
+optionsfd.sensi = 1;
+optionsfd.sens_ind = 1:4;
+
+eps = 1e-4;
+xi = log10(p);
+solfd = simulate_model_dirac_secondorder(t,xi,k,[],optionsfd);
+for ip = 1:length(options.sens_ind);
+    xip = xi;
+    xip(options.sens_ind(ip)) = xip(options.sens_ind(ip)) + eps;
+    solp = simulate_model_dirac_secondorder(t,xip,k,[],optionsfd);
+    s2x_fd(:,:,:,ip) = (solp.sx - solfd.sx)/eps;
+    s2y_fd(:,:,:,ip) = (solp.sy - solfd.sy)/eps;
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    for ip = 1:4
+        for jp = 1:length(options.sens_ind)
+            subplot(length(options.sens_ind),4,(jp-1)*4+ip)
+            hold on
+            for ix = 1:size(sol.x,2)
+                plot(t,sol.s2x(:,ix,ip,jp),'.-','Color',c_x(ix,:))
+                plot(t,s2x_fd(:,ix,ip,jp),'--','Color',c_x(ix,:))
+            end
+            ylim([-10,10])
+            legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+            legend boxoff
+            title(['state sensitivity for p' num2str(ip) '-p' num2str(options.sens_ind(jp))])
+            xlabel('time t')
+            ylabel('x')
+            box on
+        end
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    figure
+    for ip = 1:4
+        for jp = 1:length(options.sens_ind)
+            subplot(length(options.sens_ind),4,(jp-1)*4+ip)
+            plot(t,abs(sol.s2x(:,:,ip,jp)-s2x_fd(:,:,ip,jp)),'r--')
+            legend('error x1','error x2','Location','NorthEastOutside')
+            legend boxoff
+            title(['state sensitivity for p' num2str(ip) '-p' num2str(options.sens_ind(jp))])
+            xlabel('time t')
+            ylabel('error')
+            ylim([1e-12,1e0])
+            set(gca,'YScale','log')
+            box on
+        end
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/example_dirac_secondorder.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/example_dirac_secondorder.html
new file mode 100644
index 0000000000000000000000000000000000000000..01a3a714e4942ad94e9746fa2b0cd626fff91ee1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/example_dirac_secondorder.html
@@ -0,0 +1,242 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_dirac_secondorder</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_dirac_secondorder.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_dirac_secondorder()
+</pre><p>COMPILATION</p><pre class="codeinput">    [exdir,~,~]=fileparts(which(<span class="string">'example_dirac_secondorder.m'</span>));
+    <span class="comment">% compile the model</span>
+    amiwrap(<span class="string">'model_dirac_secondorder'</span>,<span class="string">'model_dirac_secondorder_syms'</span>,exdir,1)
+</pre><pre class="codeoutput">Generating model struct ...
+x | k | p | deltax | xdot | deltaxdot | ddeltaxdx | ddeltaxdp | ddeltaxdt | root | drootdx | sx | drootdp | drootdt | dtaudp | sroot | stau | deltasx | sigma_y | dsigma_ydp | y | dydp | sigma_z | dsigma_zdp | z | dzdp | Parsing model struct ...
+z | Generating C code ...
+deltasx | deltax | dsigma_ydp | dsigma_zdp | dydp | dzdp | root | sigma_y | sigma_z | stau | xdot | y | z | headers | wrapfunctions | headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput">    <span class="comment">% time vector</span>
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+
+    options = amioption(<span class="string">'sensi'</span>,0,<span class="keyword">...</span>
+        <span class="string">'maxsteps'</span>,1e4);
+
+    <span class="comment">% load mex into memory</span>
+    [msg] = which(<span class="string">'simulate_model_secondorder_dirac'</span>); <span class="comment">% fix for inaccessability problems</span>
+    options.sensi = 2;
+    sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+</pre><p>FORWARD SENSITIVITY ANALYSIS</p><pre class="codeinput">    options.sensi = 2;
+
+    sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+</pre><p>FINITE DIFFERENCES</p><pre class="codeinput">    options.sensi = 1;
+
+    eps = 1e-4;
+    xi = log10(p);
+    <span class="keyword">for</span> ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac_secondorder(t,xip,k,[],options);
+        s2x_fd(:,:,:,ip) = (solp.sx - sol.sx)/eps;
+        s2y_fd(:,:,:,ip) = (solp.sy - sol.sy)/eps;
+    <span class="keyword">end</span>
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    c_x = get(gca,<span class="string">'ColorOrder'</span>);
+    <span class="keyword">for</span> ip = 1:4
+        <span class="keyword">for</span> jp = 1:4
+            subplot(4,4,(ip-1)*4+jp)
+            hold <span class="string">on</span>
+            <span class="keyword">for</span> ix = 1:size(sol.x,2)
+                plot(t,sol.s2x(:,ix,ip,jp),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+                plot(t,s2x_fd(:,ix,ip,jp),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+            <span class="keyword">end</span>
+            ylim([-10,10])
+            legend(<span class="string">'x1'</span>,<span class="string">'x1_{fd}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+            legend <span class="string">boxoff</span>
+            title([<span class="string">'state sensitivity for p'</span> num2str(ip) <span class="string">'/p'</span> num2str(jp)])
+            xlabel(<span class="string">'time t'</span>)
+            ylabel(<span class="string">'x'</span>)
+            box <span class="string">on</span>
+        <span class="keyword">end</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+    figure
+    <span class="keyword">for</span> ip = 1:4
+        <span class="keyword">for</span> jp = 1:4
+            subplot(4,4,(ip-1)*4+jp)
+            plot(t,abs(sol.s2x(:,:,ip,jp)-s2x_fd(:,:,ip,jp)),<span class="string">'r--'</span>)
+            legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+            legend <span class="string">boxoff</span>
+            title([<span class="string">'state sensitivity for p'</span> num2str(ip) <span class="string">'/p'</span> num2str(jp)])
+            xlabel(<span class="string">'time t'</span>)
+            ylabel(<span class="string">'error'</span>)
+            ylim([1e-12,1e0])
+            set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+            box <span class="string">on</span>
+        <span class="keyword">end</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_dirac_secondorder/html/example_dirac_secondorder_01.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_dirac_secondorder/html/example_dirac_secondorder_02.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_dirac_secondorder()
+    %%
+    % COMPILATION
+    
+    [exdir,~,~]=fileparts(which('example_dirac_secondorder.m'));
+    % compile the model
+    amiwrap('model_dirac_secondorder','model_dirac_secondorder_syms',exdir,1)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+    
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+    
+    % load mex into memory
+    [msg] = which('simulate_model_secondorder_dirac'); % fix for inaccessability problems
+    options.sensi = 2;
+    sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+    
+    %%
+    % FORWARD SENSITIVITY ANALYSIS
+    
+    options.sensi = 2;
+    
+    sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+    
+    %%
+    % FINITE DIFFERENCES
+    
+    options.sensi = 1;
+    
+    eps = 1e-4;
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac_secondorder(t,xip,k,[],options);
+        s2x_fd(:,:,:,ip) = (solp.sx - sol.sx)/eps;
+        s2y_fd(:,:,:,ip) = (solp.sy - sol.sy)/eps;
+    end
+    
+    %%
+    % PLOTTING
+    figure
+    c_x = get(gca,'ColorOrder');
+    for ip = 1:4
+        for jp = 1:4
+            subplot(4,4,(ip-1)*4+jp)
+            hold on
+            for ix = 1:size(sol.x,2)
+                plot(t,sol.s2x(:,ix,ip,jp),'.-','Color',c_x(ix,:))
+                plot(t,s2x_fd(:,ix,ip,jp),'REPLACE_WITH_DASH_DASH','Color',c_x(ix,:))
+            end
+            ylim([-10,10])
+            legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+            legend boxoff
+            title(['state sensitivity for p' num2str(ip) '/p' num2str(jp)])
+            xlabel('time t')
+            ylabel('x')
+            box on
+        end
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    figure
+    for ip = 1:4
+        for jp = 1:4
+            subplot(4,4,(ip-1)*4+jp)
+            plot(t,abs(sol.s2x(:,:,ip,jp)-s2x_fd(:,:,ip,jp)),'rREPLACE_WITH_DASH_DASH')
+            legend('error x1','error x2','Location','NorthEastOutside')
+            legend boxoff
+            title(['state sensitivity for p' num2str(ip) '/p' num2str(jp)])
+            xlabel('time t')
+            ylabel('error')
+            ylim([1e-12,1e0])
+            set(gca,'YScale','log')
+            box on
+        end
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+    
+end
+
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/example_dirac_secondorder.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/example_dirac_secondorder.tex
new file mode 100644
index 0000000000000000000000000000000000000000..2bfcf40493320c905730e500790d4712b4064fe1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/example_dirac_secondorder.tex
@@ -0,0 +1,140 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_dirac_secondorder()
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    [exdir,~,~]=fileparts(which('example_dirac_secondorder.m'));
+    % compile the model
+    amiwrap('model_dirac_secondorder','model_dirac_secondorder_syms',exdir,1)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+x | k | p | deltax | xdot | deltaxdot | ddeltaxdx | ddeltaxdp | ddeltaxdt | root | drootdx | sx | drootdp | drootdt | dtaudp | sroot | stau | deltasx | sigma_y | dsigma_ydp | y | dydp | sigma_z | dsigma_zdp | z | dzdp | Parsing model struct ...
+z | 
+
+Generating C code ...
+deltasx | deltax | dsigma_ydp | dsigma_zdp | dydp | dzdp | root | sigma_y | sigma_z | stau | xdot | y | z | headers | wrapfunctions | 
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    % time vector
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+
+    % load mex into memory
+    [msg] = which('simulate_model_secondorder_dirac'); % fix for inaccessability problems
+    options.sensi = 2;
+    sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+\end{DoxyCode}
+\begin{par}
+FORWARD SENSITIVITY ANALYSIS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    options.sensi = 2;
+
+    sol = simulate_model_dirac_secondorder(t,log10(p),k,[],options);
+\end{DoxyCode}
+\begin{par}
+FINITE DIFFERENCES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    options.sensi = 1;
+
+    eps = 1e-4;
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac_secondorder(t,xip,k,[],options);
+        s2x_fd(:,:,:,ip) = (solp.sx - sol.sx)/eps;
+        s2y_fd(:,:,:,ip) = (solp.sy - sol.sy)/eps;
+    end
+\end{DoxyCode}
+\begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    c_x = get(gca,'ColorOrder');
+    for ip = 1:4
+        for jp = 1:4
+            subplot(4,4,(ip-1)*4+jp)
+            hold on
+            for ix = 1:size(sol.x,2)
+                plot(t,sol.s2x(:,ix,ip,jp),'.-','Color',c_x(ix,:))
+                plot(t,s2x_fd(:,ix,ip,jp),'--','Color',c_x(ix,:))
+            end
+            ylim([-10,10])
+            legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+            legend boxoff
+            title(['state sensitivity for p' num2str(ip) '/p' num2str(jp)])
+            xlabel('time t')
+            ylabel('x')
+            box on
+        end
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    figure
+    for ip = 1:4
+        for jp = 1:4
+            subplot(4,4,(ip-1)*4+jp)
+            plot(t,abs(sol.s2x(:,:,ip,jp)-s2x_fd(:,:,ip,jp)),'r--')
+            legend('error x1','error x2','Location','NorthEastOutside')
+            legend boxoff
+            title(['state sensitivity for p' num2str(ip) '/p' num2str(jp)])
+            xlabel('time t')
+            ylabel('error')
+            ylim([1e-12,1e0])
+            set(gca,'YScale','log')
+            box on
+        end
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac_secondorder/html/example_dirac_secondorder_01.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac_secondorder/html/example_dirac_secondorder_02.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/model_dirac_secondorder_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/model_dirac_secondorder_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..a61048f12a50d5bc1d32059e6d87fb3634e7f82f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/model_dirac_secondorder_syms.html
@@ -0,0 +1,159 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_dirac_secondorder_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_dirac_secondorder_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_dirac_secondorder_syms()
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span> <span class="string">x2</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [ x1 x2 ];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1,p2,p3,p4];
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+<span class="comment">% inhomogeneous</span>
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_dirac_secondorder_syms()
+    
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/model_dirac_secondorder_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/model_dirac_secondorder_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..fd51e9978fd4fed30d4845b510d3c4ce6296b6a9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/html/model_dirac_secondorder_syms.tex
@@ -0,0 +1,86 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_dirac_secondorder_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/model_dirac_secondorder_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/model_dirac_secondorder_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..657f2216a8c22752986776ca6d81365624ca20da
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder/model_dirac_secondorder_syms.m
@@ -0,0 +1,52 @@
+function [model] = model_dirac_secondorder_syms()
+    
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/example_dirac_secondorder_vectmult.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/example_dirac_secondorder_vectmult.m
new file mode 100644
index 0000000000000000000000000000000000000000..327e268fafb094a24e05f143362d0c6222504e39
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/example_dirac_secondorder_vectmult.m
@@ -0,0 +1,113 @@
+function example_dirac_secondorder_vectmult()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_dirac_secondorder_vectmult.m'));
+% compile the model
+amiwrap('model_dirac_secondorder_vectmult','model_dirac_secondorder_vectmult_syms',exdir,2)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,3,1001);
+p = [1;0.5;2;3];
+k = [];
+v = [0.7;0.3;1.4;0.1];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4);
+
+% load mex into memory
+[msg] = which('model_dirac_secondorder_vectmult'); % fix for inaccessability problems
+options.sensi = 2;
+sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 2;
+
+sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+
+%%
+% FINITE DIFFERENCES
+
+options.sensi = 1;
+
+eps = 1e-4;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_dirac_secondorder_vectmult(t,xip,k,[],options);
+    s2x_fd(:,:,ip) = sum(bsxfun(@times,(solp.sx - sol.sx)/eps,permute(v,[3,2,1])),3);
+    s2y_fd(:,:,ip) = sum(bsxfun(@times,(solp.sy - sol.sy)/eps,permute(v,[3,2,1])),3);
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.s2x(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,s2x_fd(:,ix,ip),'--','Color',c_x(ix,:))
+        end
+        ylim([-10,10])
+        legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2x(:,:,ip)-s2x_fd(:,:,ip)),'r--')
+        legend('error x1','error x2','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.s2y(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,s2y_fd(:,iy,ip),'--','Color',c_x(iy,:))
+        end
+        ylim([-10,10])
+        legend('y1','y1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('y')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2y(:,:,ip)-s2y_fd(:,:,ip)),'r--')
+        legend('error y1','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult.html
new file mode 100644
index 0000000000000000000000000000000000000000..ecade6db2098de3ff13f93fbd0537ac23fe22e73
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult.html
@@ -0,0 +1,288 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_dirac_secondorder_vectmult</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_dirac_secondorder_vectmult.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_dirac_secondorder_vectmult()
+</pre><p>COMPILATION</p><pre class="codeinput">    [exdir,~,~]=fileparts(which(<span class="string">'example_dirac_secondorder_vectmult.m'</span>));
+    <span class="comment">% compile the model</span>
+    amiwrap(<span class="string">'model_dirac_secondorder_vectmult'</span>,<span class="string">'model_dirac_secondorder_vectmult_syms'</span>,exdir,2)
+</pre><pre class="codeoutput">Generating model struct ...
+x | k | p | deltax | xdot | deltaxdot | ddeltaxdx | ddeltaxdp | ddeltaxdt | root | drootdx | sx | drootdp | drootdt | dtaudp | sroot | stau | deltasx | sigma_y | dsigma_ydp | y | dydp | sigma_z | dsigma_zdp | z | dzdp | Parsing model struct ...
+z | Generating C code ...
+deltasx | deltax | dsigma_ydp | dsigma_zdp | dydp | dzdp | root | sigma_y | sigma_z | stau | xdot | y | z | headers | wrapfunctions | headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput">    <span class="comment">% time vector</span>
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+    v = [0.7;0.3;1.4;0.1];
+
+    options = amioption(<span class="string">'sensi'</span>,0,<span class="keyword">...</span>
+        <span class="string">'maxsteps'</span>,1e4);
+
+    <span class="comment">% load mex into memory</span>
+    [msg] = which(<span class="string">'model_dirac_secondorder_vectmult'</span>); <span class="comment">% fix for inaccessability problems</span>
+    options.sensi = 2;
+    sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+</pre><p>FORWARD SENSITIVITY ANALYSIS</p><pre class="codeinput">    options.sensi = 2;
+
+    sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+</pre><p>FINITE DIFFERENCES</p><pre class="codeinput">    options.sensi = 1;
+
+    eps = 1e-4;
+    xi = log10(p);
+    <span class="keyword">for</span> ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac_secondorder_vectmult(t,xip,k,[],options);
+        s2x_fd(:,:,ip) = sum(bsxfun(@times,(solp.sx - sol.sx)/eps,permute(v,[3,2,1])),3);
+        s2y_fd(:,:,ip) = sum(bsxfun(@times,(solp.sy - sol.sy)/eps,permute(v,[3,2,1])),3);
+    <span class="keyword">end</span>
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    c_x = get(gca,<span class="string">'ColorOrder'</span>);
+    <span class="keyword">for</span> ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold <span class="string">on</span>
+        <span class="keyword">for</span> ix = 1:size(sol.x,2)
+            plot(t,sol.s2x(:,ix,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+            plot(t,s2x_fd(:,ix,ip),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        <span class="keyword">end</span>
+        ylim([-10,10])
+        legend(<span class="string">'x1'</span>,<span class="string">'x1_{fd}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'state sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'x'</span>)
+        box <span class="string">on</span>
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2x(:,:,ip)-s2x_fd(:,:,ip)),<span class="string">'r--'</span>)
+        legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'state sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'error'</span>)
+        ylim([1e-12,1e0])
+        set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+        box <span class="string">on</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    figure
+    <span class="keyword">for</span> ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold <span class="string">on</span>
+        <span class="keyword">for</span> iy = 1:size(sol.y,2)
+            plot(t,sol.s2y(:,iy,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(iy,:))
+            plot(t,s2y_fd(:,iy,ip),<span class="string">'--'</span>,<span class="string">'Color'</span>,c_x(iy,:))
+        <span class="keyword">end</span>
+        ylim([-10,10])
+        legend(<span class="string">'y1'</span>,<span class="string">'y1_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'observable sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'y'</span>)
+        box <span class="string">on</span>
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2y(:,:,ip)-s2y_fd(:,:,ip)),<span class="string">'r--'</span>)
+        legend(<span class="string">'error y1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'observable sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'error'</span>)
+        ylim([1e-12,1e0])
+        set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+        box <span class="string">on</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult_01.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult_02.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_dirac_secondorder_vectmult()
+    %%
+    % COMPILATION
+    
+    [exdir,~,~]=fileparts(which('example_dirac_secondorder_vectmult.m'));
+    % compile the model
+    amiwrap('model_dirac_secondorder_vectmult','model_dirac_secondorder_vectmult_syms',exdir,2)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+    v = [0.7;0.3;1.4;0.1];
+    
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+    
+    % load mex into memory
+    [msg] = which('model_dirac_secondorder_vectmult'); % fix for inaccessability problems
+    options.sensi = 2;
+    sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+    
+    %%
+    % FORWARD SENSITIVITY ANALYSIS
+    
+    options.sensi = 2;
+    
+    sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+    
+    %%
+    % FINITE DIFFERENCES
+    
+    options.sensi = 1;
+    
+    eps = 1e-4;
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac_secondorder_vectmult(t,xip,k,[],options);
+        s2x_fd(:,:,ip) = sum(bsxfun(@times,(solp.sx - sol.sx)/eps,permute(v,[3,2,1])),3);
+        s2y_fd(:,:,ip) = sum(bsxfun(@times,(solp.sy - sol.sy)/eps,permute(v,[3,2,1])),3);
+    end
+    
+    %%
+    % PLOTTING
+    
+    figure
+    c_x = get(gca,'ColorOrder');
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.s2x(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,s2x_fd(:,ix,ip),'REPLACE_WITH_DASH_DASH','Color',c_x(ix,:))
+        end
+        ylim([-10,10])
+        legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2x(:,:,ip)-s2x_fd(:,:,ip)),'rREPLACE_WITH_DASH_DASH')
+        legend('error x1','error x2','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.s2y(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,s2y_fd(:,iy,ip),'REPLACE_WITH_DASH_DASH','Color',c_x(iy,:))
+        end
+        ylim([-10,10])
+        legend('y1','y1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('y')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2y(:,:,ip)-s2y_fd(:,:,ip)),'rREPLACE_WITH_DASH_DASH')
+        legend('error y1','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+    
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult.tex
new file mode 100644
index 0000000000000000000000000000000000000000..588100d5539284ed9da7bd04eed9b1840f0bfb34
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult.tex
@@ -0,0 +1,163 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_dirac_secondorder_vectmult()
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    [exdir,~,~]=fileparts(which('example_dirac_secondorder_vectmult.m'));
+    % compile the model
+    amiwrap('model_dirac_secondorder_vectmult','model_dirac_secondorder_vectmult_syms',exdir,2)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+x | k | p | deltax | xdot | deltaxdot | ddeltaxdx | ddeltaxdp | ddeltaxdt | root | drootdx | sx | drootdp | drootdt | dtaudp | sroot | stau | deltasx | sigma_y | dsigma_ydp | y | dydp | sigma_z | dsigma_zdp | z | dzdp | Parsing model struct ...
+z | 
+
+Generating C code ...
+deltasx | deltax | dsigma_ydp | dsigma_zdp | dydp | dzdp | root | sigma_y | sigma_z | stau | xdot | y | z | headers | wrapfunctions | 
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    % time vector
+    t = linspace(0,3,1001);
+    p = [1;0.5;2;3];
+    k = [];
+    v = [0.7;0.3;1.4;0.1];
+
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+
+    % load mex into memory
+    [msg] = which('model_dirac_secondorder_vectmult'); % fix for inaccessability problems
+    options.sensi = 2;
+    sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+\end{DoxyCode}
+\begin{par}
+FORWARD SENSITIVITY ANALYSIS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    options.sensi = 2;
+
+    sol = simulate_model_dirac_secondorder_vectmult(t,log10(p),k,[],options,v);
+\end{DoxyCode}
+\begin{par}
+FINITE DIFFERENCES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    options.sensi = 1;
+
+    eps = 1e-4;
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_dirac_secondorder_vectmult(t,xip,k,[],options);
+        s2x_fd(:,:,ip) = sum(bsxfun(@times,(solp.sx - sol.sx)/eps,permute(v,[3,2,1])),3);
+        s2y_fd(:,:,ip) = sum(bsxfun(@times,(solp.sy - sol.sy)/eps,permute(v,[3,2,1])),3);
+    end
+\end{DoxyCode}
+\begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    c_x = get(gca,'ColorOrder');
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.s2x(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,s2x_fd(:,ix,ip),'--','Color',c_x(ix,:))
+        end
+        ylim([-10,10])
+        legend('x1','x1_{fd}','x2','x2_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2x(:,:,ip)-s2x_fd(:,:,ip)),'r--')
+        legend('error x1','error x2','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.s2y(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,s2y_fd(:,iy,ip),'--','Color',c_x(iy,:))
+        end
+        ylim([-10,10])
+        legend('y1','y1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('y')
+        box on
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.s2y(:,:,ip)-s2y_fd(:,:,ip)),'r--')
+        legend('error y1','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        ylim([1e-12,1e0])
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult_01.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_dirac_secondorder_vectmult/html/example_dirac_secondorder_vectmult_02.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/model_dirac_secondorder_vectmult_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/model_dirac_secondorder_vectmult_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..15ee3389837e176382026e3d18fe2449daa038fb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/model_dirac_secondorder_vectmult_syms.html
@@ -0,0 +1,159 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_dirac_secondorder_vectmult_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_dirac_secondorder_vectmult_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_dirac_secondorder_vectmult_syms()
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span> <span class="string">x2</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [ x1 x2 ];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1,p2,p3,p4];
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+<span class="comment">% inhomogeneous</span>
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_dirac_secondorder_vectmult_syms()
+    
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/model_dirac_secondorder_vectmult_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/model_dirac_secondorder_vectmult_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..3574b25f42f7b40224f02368bcb0b5dea468640e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/html/model_dirac_secondorder_vectmult_syms.tex
@@ -0,0 +1,86 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_dirac_secondorder_vectmult_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/model_dirac_secondorder_vectmult_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/model_dirac_secondorder_vectmult_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..cc366495f17259a11062f257362cdde0050585dd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_dirac_secondorder_vectmult/model_dirac_secondorder_vectmult_syms.m
@@ -0,0 +1,52 @@
+function [model] = model_dirac_secondorder_vectmult_syms()
+    
+%%
+% STATES
+
+% create state syms
+syms x1 x2
+
+% create state vector
+model.sym.x = [ x1 x2 ];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*x1 + dirac(t-p2);
+% inhomogeneous
+model.sym.xdot(2) = p3*x1 - p4*x2 ;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = 0;
+model.sym.x0(2) = 0;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = x2;
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/example_events.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/example_events.m
new file mode 100644
index 0000000000000000000000000000000000000000..1f5e2a47f4939f23f533dc7a6e5714d0f26a45a1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/example_events.m
@@ -0,0 +1,195 @@
+function example_events()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_events.m'));
+% compile the model
+amiwrap('model_events','model_events_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,10,20);
+p = [0.5;2;0.5;0.5];
+k = [4,8,10,4];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4);
+D = amidata(length(t),1,2,2,4);
+% load mex into memory
+[~] = which('simulate_model_events'); % fix for inaccessability problems
+sol = simulate_model_events(t,log10(p),k,D,options);
+
+tic
+sol = simulate_model_events(t,log10(p),k,D,options);
+disp(['Time elapsed with cvodes: ' num2str(toc) ])
+
+%%
+% ODE15S
+
+ode_system = @(t,x,p,k) [-p(1)*heaviside(t-p(4))*x(1);
+    +p(2)*x(1)*exp(-0.1*t)-p(3)*x(2);
+    -1*x(3)+heaviside(t-4)];
+% event_fn = @(t,x) [x(3) - x(2);
+%     x(3) - x(1)];
+% 'Events',event_fn
+options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+tic
+[~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+disp(['Time elapsed with ode15s: ' num2str(toc) ])
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+    end
+    stem(sol.z(:,1),sol.z(:,1)*0+10,'r')
+    stem(sol.z(:,2),sol.z(:,2)*0+10,'k')
+    legend('x1','x1_{ode15s}','x2','x2_{ode15s}','x3','x3_{ode15s}','x3<x2','x3<x1','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode15s),'--')
+    set(gca,'YScale','log')
+    legend('error x1','error x2','error x3','Location','NorthEastOutside')
+    legend boxoff
+    ylabel('x')
+    
+    subplot(2,2,3)
+    plot(t,sol.y,'.-','Color',c_x(1,:))
+    hold on
+    plot(t,p(4)*sum(X_ode15s,2),'d','Color',c_x(1,:))
+    legend('y1','y1_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    
+    subplot(2,2,4)
+    plot(t,abs(sol.y-p(4)*sum(X_ode15s,2)),'--')
+    set(gca,'YScale','log')
+    legend('error y1','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('y')
+    box on
+    
+    set(gcf,'Position',[100 300 1200 500])
+end
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 1;
+
+sol = simulate_model_events(t,log10(p),k,D,options);
+
+%%
+% FINITE DIFFERENCES
+
+eps = 1e-4;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_events(t,xip,k,D,options);
+    sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+    sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    sz_fd(:,:,ip) = (solp.z - sol.z)/eps;
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,ip),'d','Color',c_x(ix,:))
+        end
+        legend('sx1','sx1_{fd}','sx2','sx2_{fd}','sx3','sx3_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('sx')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'--')
+        legend('error sx1','error sx2','error sx3','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for iy = 1:size(sol.y,2)
+            plot(t,sol.sy(:,iy,ip),'.-','Color',c_x(iy,:))
+            plot(t,sy_fd(:,iy,ip),'d','Color',c_x(iy,:))
+        end
+        legend('sy1','sy1_fd','Location','NorthEastOutside')
+        legend boxoff
+        title(['observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('sy')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'--')
+        legend('error sy1','Location','NorthEastOutside')
+        legend boxoff
+        title(['error observable sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    for ip = 1:4
+        subplot(4,2,2*ip-1)
+        bar(1:D.ne,sol.sz(1:D.ne,:,ip),0.8,'grouped')
+        hold on
+        bar(1:D.ne,sz_fd(1:D.ne,:,ip),0.4)
+        legend('x3>x2','x3>x1','x3>x2 fd','x3>x1 fd','Location','NorthEastOutside')
+        legend boxoff
+        title(['event sensitivity for p' num2str(ip)])
+        xlabel('event #')
+        ylabel('sz')
+        box on
+        
+        subplot(4,2,2*ip)
+        bar(1:D.ne,sol.sz(1:D.ne,:,ip)-sz_fd(1:D.ne,:,ip),0.8)
+        hold on
+        legend('error x3>x2','error x3>x1','Location','NorthEastOutside')
+        legend boxoff
+        title(['error event sensitivity for p' num2str(ip)])
+        xlabel('event #')
+        ylabel('sz')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/example_events.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/example_events.html
new file mode 100644
index 0000000000000000000000000000000000000000..20a09915494f102acebf4cef00e480251c232326
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/example_events.html
@@ -0,0 +1,441 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_events</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_events.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_events()
+</pre><p>COMPILATION</p><pre class="codeinput">[exdir,~,~]=fileparts(which(<span class="string">'example_events.m'</span>));
+<span class="comment">% compile the model</span>
+amiwrap(<span class="string">'model_events'</span>,<span class="string">'model_events_syms'</span>,exdir)
+</pre><pre class="codeoutput">Generating model struct ...
+Parsing model struct ...
+Generating C code ...
+headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput"><span class="comment">% time vector</span>
+t = linspace(0,10,20);
+p = [0.5;2;0.5;0.5];
+k = [4,8,10,4];
+
+options = amioption(<span class="string">'sensi'</span>,0,<span class="keyword">...</span>
+    <span class="string">'maxsteps'</span>,1e4,<span class="keyword">...</span>
+    <span class="string">'nmaxevent'</span>, 2);
+D = amidata(length(t),1,2,2,4);
+<span class="comment">% load mex into memory</span>
+[~] = which(<span class="string">'simulate_model_events'</span>); <span class="comment">% fix for inaccessability problems</span>
+sol = simulate_model_events(t,log10(p),k,D,options);
+
+tic
+sol = simulate_model_events(t,log10(p),k,D,options);
+disp([<span class="string">'Time elapsed with cvodes: '</span> num2str(toc) ])
+</pre><pre class="codeoutput">Time elapsed with cvodes: 0.0033863
+</pre><p>ODE15S</p><pre class="codeinput">ode_system = @(t,x,p,k) [-p(1)*heaviside(t-p(4))*x(1);
+    +p(2)*x(1)*exp(-0.1*t)-p(3)*x(2);
+    -1.5*x(3)];
+<span class="comment">% event_fn = @(t,x) [x(3) - x(2);</span>
+<span class="comment">%     x(3) - x(1)];</span>
+<span class="comment">% 'Events',event_fn</span>
+options_ode15s = odeset(<span class="string">'RelTol'</span>,options.rtol,<span class="string">'AbsTol'</span>,options.atol,<span class="string">'MaxStep'</span>,options.maxsteps);
+
+tic
+[~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+disp([<span class="string">'Time elapsed with ode15s: '</span> num2str(toc) ])
+</pre><pre class="codeoutput">Time elapsed with ode15s: 0.13084
+</pre><p>PLOTTING</p><pre class="codeinput">figure
+c_x = get(gca,<span class="string">'ColorOrder'</span>);
+subplot(2,2,1)
+<span class="keyword">for</span> ix = 1:size(sol.x,2)
+    plot(t,sol.x(:,ix),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+    hold <span class="string">on</span>
+    plot(t,X_ode15s(:,ix),<span class="string">'d'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+<span class="keyword">end</span>
+stem(sol.z(:,1),sol.z(:,1)*0+10,<span class="string">'r'</span>)
+stem(sol.z(:,2),sol.z(:,2)*0+10,<span class="string">'k'</span>)
+legend(<span class="string">'x1'</span>,<span class="string">'x1_{ode15s}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{ode15s}'</span>,<span class="string">'x3'</span>,<span class="string">'x3_{ode15s}'</span>,<span class="string">'x3==x2'</span>,<span class="string">'x3==x1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+legend <span class="string">boxoff</span>
+xlabel(<span class="string">'time t'</span>)
+ylabel(<span class="string">'x'</span>)
+box <span class="string">on</span>
+subplot(2,2,2)
+plot(t,abs(sol.x-X_ode15s),<span class="string">'--'</span>)
+set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'error x3'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+legend <span class="string">boxoff</span>
+ylabel(<span class="string">'x'</span>)
+
+subplot(2,2,3)
+plot(t,sol.y,<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(1,:))
+hold <span class="string">on</span>
+plot(t,p(4)*sum(X_ode15s,2),<span class="string">'d'</span>,<span class="string">'Color'</span>,c_x(1,:))
+legend(<span class="string">'y1'</span>,<span class="string">'y1_{ode15s}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+legend <span class="string">boxoff</span>
+xlabel(<span class="string">'time t'</span>)
+ylabel(<span class="string">'y'</span>)
+box <span class="string">on</span>
+
+subplot(2,2,4)
+plot(t,abs(sol.y-p(4)*sum(X_ode15s,2)),<span class="string">'--'</span>)
+set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+legend(<span class="string">'error y1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+legend <span class="string">boxoff</span>
+xlabel(<span class="string">'time t'</span>)
+ylabel(<span class="string">'y'</span>)
+box <span class="string">on</span>
+
+set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+</pre><img vspace="5" hspace="5" src="../examples/example_events/html/example_events_01.png" alt=""> <p>FORWARD SENSITIVITY ANALYSIS</p><pre class="codeinput">options.sensi = 1;
+
+sol = simulate_model_events(t,log10(p),k,D,options);
+</pre><p>FINITE DIFFERENCES</p><pre class="codeinput">eps = 1e-4;
+xi = log10(p);
+<span class="keyword">for</span> ip = 1:4;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_events(t,xip,k,D,options);
+    sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+    sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    sz_fd(:,:,ip) = (solp.z - sol.z)/eps;
+<span class="keyword">end</span>
+</pre><p>PLOTTING</p><pre class="codeinput">figure
+<span class="keyword">for</span> ip = 1:4
+    subplot(4,2,ip*2-1)
+    hold <span class="string">on</span>
+    <span class="keyword">for</span> ix = 1:size(sol.x,2)
+        plot(t,sol.sx(:,ix,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        plot(t,sx_fd(:,ix,ip),<span class="string">'d'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+    <span class="keyword">end</span>
+    legend(<span class="string">'sx1'</span>,<span class="string">'sx1_{fd}'</span>,<span class="string">'sx2'</span>,<span class="string">'sx2_{fd}'</span>,<span class="string">'sx3'</span>,<span class="string">'sx3_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    title([<span class="string">'state sensitivity for p'</span> num2str(ip)])
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'sx'</span>)
+    box <span class="string">on</span>
+
+    subplot(4,2,ip*2)
+    plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),<span class="string">'--'</span>)
+    legend(<span class="string">'error sx1'</span>,<span class="string">'error sx2'</span>,<span class="string">'error sx3'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    title([<span class="string">'state sensitivity for p'</span> num2str(ip)])
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'error'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    box <span class="string">on</span>
+<span class="keyword">end</span>
+set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+figure
+<span class="keyword">for</span> ip = 1:4
+    subplot(4,2,ip*2-1)
+    hold <span class="string">on</span>
+    <span class="keyword">for</span> iy = 1:size(sol.y,2)
+        plot(t,sol.sy(:,iy,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(iy,:))
+        plot(t,sy_fd(:,iy,ip),<span class="string">'d'</span>,<span class="string">'Color'</span>,c_x(iy,:))
+    <span class="keyword">end</span>
+    legend(<span class="string">'sy1'</span>,<span class="string">'sy1_fd'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    title([<span class="string">'observable sensitivity for p'</span> num2str(ip)])
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'sy'</span>)
+    box <span class="string">on</span>
+
+    subplot(4,2,ip*2)
+    plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),<span class="string">'--'</span>)
+    legend(<span class="string">'error sy1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    title([<span class="string">'error observable sensitivity for p'</span> num2str(ip)])
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'error'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    box <span class="string">on</span>
+<span class="keyword">end</span>
+set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+figure
+<span class="keyword">for</span> ip = 1:4
+subplot(4,2,2*ip-1)
+bar(1:options.nmaxevent,sol.sz(1:options.nmaxevent,:,ip),0.8)
+hold <span class="string">on</span>
+bar(1:options.nmaxevent,sz_fd(1:options.nmaxevent,:,ip),0.4)
+legend(<span class="string">'x3==x2'</span>,<span class="string">'x3==x1'</span>,<span class="string">'x3==x2 fd'</span>,<span class="string">'x3==x1 fd'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+legend <span class="string">boxoff</span>
+title([<span class="string">'event sensitivity for p'</span> num2str(ip)])
+xlabel(<span class="string">'event #'</span>)
+ylabel(<span class="string">'sz'</span>)
+box <span class="string">on</span>
+
+subplot(4,2,2*ip)
+bar(1:options.nmaxevent,sol.sz(1:options.nmaxevent,:,ip)-sz_fd(1:options.nmaxevent,:,ip),0.8)
+legend(<span class="string">'error x3==x2'</span>,<span class="string">'error x3==x1'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+legend <span class="string">boxoff</span>
+title([<span class="string">'error event sensitivity for p'</span> num2str(ip)])
+xlabel(<span class="string">'event #'</span>)
+ylabel(<span class="string">'sz'</span>)
+box <span class="string">on</span>
+<span class="keyword">end</span>
+set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_events/html/example_events_02.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_events/html/example_events_03.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_events/html/example_events_04.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_events()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_events.m'));
+% compile the model
+amiwrap('model_events','model_events_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,10,20);
+p = [0.5;2;0.5;0.5];
+k = [4,8,10,4];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4,...
+    'nmaxevent', 2);
+D = amidata(length(t),1,2,2,4);
+% load mex into memory
+[~] = which('simulate_model_events'); % fix for inaccessability problems
+sol = simulate_model_events(t,log10(p),k,D,options);
+
+tic
+sol = simulate_model_events(t,log10(p),k,D,options);
+disp(['Time elapsed with cvodes: ' num2str(toc) ])
+
+%%
+% ODE15S
+
+ode_system = @(t,x,p,k) [-p(1)*heaviside(t-p(4))*x(1);
+    +p(2)*x(1)*exp(-0.1*t)-p(3)*x(2);
+    -1.5*x(3)];
+% event_fn = @(t,x) [x(3) - x(2);
+%     x(3) - x(1)];
+% 'Events',event_fn
+options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+tic
+[~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+disp(['Time elapsed with ode15s: ' num2str(toc) ])
+
+%%
+% PLOTTING
+
+figure
+c_x = get(gca,'ColorOrder');
+subplot(2,2,1)
+for ix = 1:size(sol.x,2)
+    plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+    hold on
+    plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+end
+stem(sol.z(:,1),sol.z(:,1)*0+10,'r')
+stem(sol.z(:,2),sol.z(:,2)*0+10,'k')
+legend('x1','x1_{ode15s}','x2','x2_{ode15s}','x3','x3_{ode15s}','x3==x2','x3==x1','Location','NorthEastOutside')
+legend boxoff
+xlabel('time t')
+ylabel('x')
+box on
+subplot(2,2,2)
+plot(t,abs(sol.x-X_ode15s),'REPLACE_WITH_DASH_DASH')
+set(gca,'YScale','log')
+legend('error x1','error x2','error x3','Location','NorthEastOutside')
+legend boxoff
+ylabel('x')
+
+subplot(2,2,3)
+plot(t,sol.y,'.-','Color',c_x(1,:))
+hold on
+plot(t,p(4)*sum(X_ode15s,2),'d','Color',c_x(1,:))
+legend('y1','y1_{ode15s}','Location','NorthEastOutside')
+legend boxoff
+xlabel('time t')
+ylabel('y')
+box on
+
+subplot(2,2,4)
+plot(t,abs(sol.y-p(4)*sum(X_ode15s,2)),'REPLACE_WITH_DASH_DASH')
+set(gca,'YScale','log')
+legend('error y1','Location','NorthEastOutside')
+legend boxoff
+xlabel('time t')
+ylabel('y')
+box on
+
+set(gcf,'Position',[100 300 1200 500])
+
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 1;
+
+sol = simulate_model_events(t,log10(p),k,D,options);
+
+%%
+% FINITE DIFFERENCES
+
+eps = 1e-4;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_events(t,xip,k,D,options);
+    sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+    sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    sz_fd(:,:,ip) = (solp.z - sol.z)/eps;
+end
+
+%%
+% PLOTTING
+figure
+for ip = 1:4
+    subplot(4,2,ip*2-1)
+    hold on
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+        plot(t,sx_fd(:,ix,ip),'d','Color',c_x(ix,:))
+    end
+    legend('sx1','sx1_{fd}','sx2','sx2_{fd}','sx3','sx3_{fd}','Location','NorthEastOutside')
+    legend boxoff
+    title(['state sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('sx')
+    box on
+    
+    subplot(4,2,ip*2)
+    plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'REPLACE_WITH_DASH_DASH')
+    legend('error sx1','error sx2','error sx3','Location','NorthEastOutside')
+    legend boxoff
+    title(['state sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('error')
+    set(gca,'YScale','log')
+    box on
+end
+set(gcf,'Position',[100 300 1200 500])
+
+figure
+for ip = 1:4
+    subplot(4,2,ip*2-1)
+    hold on
+    for iy = 1:size(sol.y,2)
+        plot(t,sol.sy(:,iy,ip),'.-','Color',c_x(iy,:))
+        plot(t,sy_fd(:,iy,ip),'d','Color',c_x(iy,:))
+    end
+    legend('sy1','sy1_fd','Location','NorthEastOutside')
+    legend boxoff
+    title(['observable sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('sy')
+    box on
+    
+    subplot(4,2,ip*2)
+    plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'REPLACE_WITH_DASH_DASH')
+    legend('error sy1','Location','NorthEastOutside')
+    legend boxoff
+    title(['error observable sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('error')
+    set(gca,'YScale','log')
+    box on
+end
+set(gcf,'Position',[100 300 1200 500])
+
+figure
+for ip = 1:4
+subplot(4,2,2*ip-1)
+bar(1:options.nmaxevent,sol.sz(1:options.nmaxevent,:,ip),0.8)
+hold on
+bar(1:options.nmaxevent,sz_fd(1:options.nmaxevent,:,ip),0.4)
+legend('x3==x2','x3==x1','x3==x2 fd','x3==x1 fd','Location','NorthEastOutside')
+legend boxoff
+title(['event sensitivity for p' num2str(ip)])
+xlabel('event #')
+ylabel('sz')
+box on
+
+subplot(4,2,2*ip)
+bar(1:options.nmaxevent,sol.sz(1:options.nmaxevent,:,ip)-sz_fd(1:options.nmaxevent,:,ip),0.8)
+legend('error x3==x2','error x3==x1','Location','NorthEastOutside')
+legend boxoff
+title(['error event sensitivity for p' num2str(ip)])
+xlabel('event #')
+ylabel('sz')
+box on
+end
+set(gcf,'Position',[100 300 1200 500])
+
+drawnow
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/example_events.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/example_events.tex
new file mode 100644
index 0000000000000000000000000000000000000000..f827837418c8ef741c84a721ed6af447af60c930
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/example_events.tex
@@ -0,0 +1,251 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_events()
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+[exdir,~,~]=fileparts(which('example_events.m'));
+% compile the model
+amiwrap('model_events','model_events_syms',exdir)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+Parsing model struct ...
+
+Generating C code ...
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% time vector
+t = linspace(0,10,20);
+p = [0.5;2;0.5;0.5];
+k = [4,8,10,4];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4,...
+    'nmaxevent', 2);
+D = amidata(length(t),1,2,2,4);
+% load mex into memory
+[~] = which('simulate_model_events'); % fix for inaccessability problems
+sol = simulate_model_events(t,log10(p),k,D,options);
+
+tic
+sol = simulate_model_events(t,log10(p),k,D,options);
+disp(['Time elapsed with cvodes: ' num2str(toc) ])
+\end{DoxyCode}
+
+         \begin{DoxyCode}Time elapsed with cvodes: 0.0037064
+\end{DoxyCode} 
+    \begin{par}
+ODE15S
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+ode_system = @(t,x,p,k) [-p(1)*heaviside(t-p(4))*x(1);
+    +p(2)*x(1)*exp(-0.1*t)-p(3)*x(2);
+    -1.5*x(3)];
+% event_fn = @(t,x) [x(3) - x(2);
+%     x(3) - x(1)];
+% 'Events',event_fn
+options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+tic
+[~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+disp(['Time elapsed with ode15s: ' num2str(toc) ])
+\end{DoxyCode}
+
+         \begin{DoxyCode}Time elapsed with ode15s: 0.074866
+\end{DoxyCode} 
+    \begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+figure
+c_x = get(gca,'ColorOrder');
+subplot(2,2,1)
+for ix = 1:size(sol.x,2)
+    plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+    hold on
+    plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+end
+stem(sol.z(:,1),sol.z(:,1)*0+10,'r')
+stem(sol.z(:,2),sol.z(:,2)*0+10,'k')
+legend('x1','x1_{ode15s}','x2','x2_{ode15s}','x3','x3_{ode15s}','x3==x2','x3==x1','Location','NorthEastOutside')
+legend boxoff
+xlabel('time t')
+ylabel('x')
+box on
+subplot(2,2,2)
+plot(t,abs(sol.x-X_ode15s),'--')
+set(gca,'YScale','log')
+legend('error x1','error x2','error x3','Location','NorthEastOutside')
+legend boxoff
+ylabel('x')
+
+subplot(2,2,3)
+plot(t,sol.y,'.-','Color',c_x(1,:))
+hold on
+plot(t,p(4)*sum(X_ode15s,2),'d','Color',c_x(1,:))
+legend('y1','y1_{ode15s}','Location','NorthEastOutside')
+legend boxoff
+xlabel('time t')
+ylabel('y')
+box on
+
+subplot(2,2,4)
+plot(t,abs(sol.y-p(4)*sum(X_ode15s,2)),'--')
+set(gca,'YScale','log')
+legend('error y1','Location','NorthEastOutside')
+legend boxoff
+xlabel('time t')
+ylabel('y')
+box on
+
+set(gcf,'Position',[100 300 1200 500])
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_events/html/example_events_01.png}
+\begin{par}
+FORWARD SENSITIVITY ANALYSIS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+options.sensi = 1;
+
+sol = simulate_model_events(t,log10(p),k,D,options);
+\end{DoxyCode}
+\begin{par}
+FINITE DIFFERENCES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+eps = 1e-4;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_events(t,xip,k,D,options);
+    sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+    sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    sz_fd(:,:,ip) = (solp.z - sol.z)/eps;
+end
+\end{DoxyCode}
+\begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+figure
+for ip = 1:4
+    subplot(4,2,ip*2-1)
+    hold on
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+        plot(t,sx_fd(:,ix,ip),'d','Color',c_x(ix,:))
+    end
+    legend('sx1','sx1_{fd}','sx2','sx2_{fd}','sx3','sx3_{fd}','Location','NorthEastOutside')
+    legend boxoff
+    title(['state sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('sx')
+    box on
+
+    subplot(4,2,ip*2)
+    plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'--')
+    legend('error sx1','error sx2','error sx3','Location','NorthEastOutside')
+    legend boxoff
+    title(['state sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('error')
+    set(gca,'YScale','log')
+    box on
+end
+set(gcf,'Position',[100 300 1200 500])
+
+figure
+for ip = 1:4
+    subplot(4,2,ip*2-1)
+    hold on
+    for iy = 1:size(sol.y,2)
+        plot(t,sol.sy(:,iy,ip),'.-','Color',c_x(iy,:))
+        plot(t,sy_fd(:,iy,ip),'d','Color',c_x(iy,:))
+    end
+    legend('sy1','sy1_fd','Location','NorthEastOutside')
+    legend boxoff
+    title(['observable sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('sy')
+    box on
+
+    subplot(4,2,ip*2)
+    plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'--')
+    legend('error sy1','Location','NorthEastOutside')
+    legend boxoff
+    title(['error observable sensitivity for p' num2str(ip)])
+    xlabel('time t')
+    ylabel('error')
+    set(gca,'YScale','log')
+    box on
+end
+set(gcf,'Position',[100 300 1200 500])
+
+figure
+for ip = 1:4
+subplot(4,2,2*ip-1)
+bar(1:options.nmaxevent,sol.sz(1:options.nmaxevent,:,ip),0.8)
+hold on
+bar(1:options.nmaxevent,sz_fd(1:options.nmaxevent,:,ip),0.4)
+legend('x3==x2','x3==x1','x3==x2 fd','x3==x1 fd','Location','NorthEastOutside')
+legend boxoff
+title(['event sensitivity for p' num2str(ip)])
+xlabel('event #')
+ylabel('sz')
+box on
+
+subplot(4,2,2*ip)
+bar(1:options.nmaxevent,sol.sz(1:options.nmaxevent,:,ip)-sz_fd(1:options.nmaxevent,:,ip),0.8)
+legend('error x3==x2','error x3==x1','Location','NorthEastOutside')
+legend boxoff
+title(['error event sensitivity for p' num2str(ip)])
+xlabel('event #')
+ylabel('sz')
+box on
+end
+set(gcf,'Position',[100 300 1200 500])
+
+drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_events/html/example_events_02.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_events/html/example_events_03.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_events/html/example_events_04.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/model_events_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/model_events_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..32de5948185301f1ff8c5021003704699c0b38ac
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/model_events_syms.html
@@ -0,0 +1,207 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_events_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_events_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_events_syms()
+</pre><pre class="codeinput"><span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span> <span class="string">x2</span> <span class="string">x3</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [
+x1 x2 x3
+];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1,p2,p3,p4];
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>CONSTANTS ( for these no sensitivities will be computed ) this part is optional and can be ommited</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">k1</span> <span class="string">k2</span> <span class="string">k3</span> <span class="string">k4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.k = [k1 k2 k3 k4];
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -p1*heaviside(t-p4)*x1;
+<span class="comment">% inhomogeneous</span>
+model.sym.xdot(2) = +p2*x1*exp(-0.1*t)-p3*x2 ;
+model.sym.xdot(3) = -1.5*x3;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = p4 * (x1+x2+x3);
+</pre><p>EVENTS this part is optional and can be ommited</p><pre class="codeinput">syms <span class="string">t</span>
+
+<span class="comment">% events fire when there is a zero crossing of the root function</span>
+model.event(1) = amievent(x3-x2,0,t);
+model.event(2) = amievent(x3-x1,0,t);
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+    param: 'log10'
+      sym: [1x1 struct]
+    event: [1x2 amievent]
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_events_syms()
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% STATES
+
+
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+syms k1 k2 k3 k4
+
+% create parameter vector 
+model.sym.k = [k1 k2 k3 k4];
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*heaviside(t-p4)*x1;
+% inhomogeneous
+model.sym.xdot(2) = +p2*x1*exp(-0.1*t)-p3*x2 ;
+model.sym.xdot(3) = -1.5*x3;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = p4 * (x1+x2+x3);
+
+
+%%
+% EVENTS
+% this part is optional and can be ommited
+syms t
+
+% events fire when there is a zero crossing of the root function
+model.event(1) = amievent(x3-x2,0,t);
+model.event(2) = amievent(x3-x1,0,t);
+
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/model_events_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/model_events_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..4cfaa06d190345d6e72aba020a9ed5b1a14313da
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/html/model_events_syms.tex
@@ -0,0 +1,116 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_events_syms()
+\end{DoxyCode}
+\begin{DoxyCode}
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+CONSTANTS ( for these no sensitivities will be computed ) this part is optional and can be ommited
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms k1 k2 k3 k4
+
+% create parameter vector
+model.sym.k = [k1 k2 k3 k4];
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*heaviside(t-p4)*x1;
+% inhomogeneous
+model.sym.xdot(2) = +p2*x1*exp(-0.1*t)-p3*x2 ;
+model.sym.xdot(3) = -1.5*x3;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = p4 * (x1+x2+x3);
+\end{DoxyCode}
+\begin{par}
+EVENTS this part is optional and can be ommited
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+syms t
+
+% events fire when there is a zero crossing of the root function
+model.event(1) = amievent(x3-x2,0,t);
+model.event(2) = amievent(x3-x1,0,t);
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+    param: 'log10'
+      sym: [1x1 struct]
+    event: [1x2 amievent]
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/model_events_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/model_events_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..f98298c8ddbc6bc0ce0db4044315cbad2cba1544
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_events/model_events_syms.m
@@ -0,0 +1,82 @@
+function [model] = model_events_syms()
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+
+%%
+% STATES
+
+
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+%%
+% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+syms k1 k2 k3 k4
+
+% create parameter vector 
+model.sym.k = [k1 k2 k3 k4];
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -p1*heaviside(t-p4)*x1;
+% inhomogeneous
+model.sym.xdot(2) = +p2*x1*exp(-0.1*t)-p3*x2 ;
+model.sym.xdot(3) = -1*x3+heaviside(t-4);
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+
+%%
+% OBSERVALES
+
+model.sym.y = sym(zeros(1,1));
+
+model.sym.y(1) = p4 * (x1+x2+x3);
+
+
+%%
+% EVENTS
+% this part is optional and can be ommited
+syms t
+
+% events fire when there is a -zero crossing of the root function
+model.event(1) = amievent(am_ge(x2,x3),0,t);
+model.event(2) = amievent(am_ge(x1,x3),0,t);
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/example_jakstat_adjoint.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/example_jakstat_adjoint.m
new file mode 100644
index 0000000000000000000000000000000000000000..55cd78dbe0b1d66fa6abca7a0ebe6d94735b2e5d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/example_jakstat_adjoint.m
@@ -0,0 +1,117 @@
+function example_jakstat_adjoint()
+    
+    % compile the model
+    [exdir,~,~]=fileparts(which('example_jakstat_adjoint.m'));
+    amiwrap('model_jakstat_adjoint','model_jakstat_adjoint_syms',exdir,1)
+    
+    num = xlsread(fullfile(exdir,'pnas_data_original.xls'));
+    
+    D.t = num(:,1);
+    D.condition= [1.4,0.45];
+    D.Y = num(:,[2,4,6]);
+    D.Sigma_Y = NaN(size(D.Y));
+    D = amidata(D);
+    
+    xi =  [0.60
+        3
+        -0.95
+        -0.0075
+        0
+        -2.8
+        -0.26
+        -0.075
+        -0.41
+        -5
+        -0.74
+        -0.64
+        -0.11
+        0.027
+        -0.5
+        0
+        -0.5];
+    
+    options.sensi = 0;
+    sol = simulate_model_jakstat_adjoint([],xi,[],D,options);
+    
+    if(usejava('jvm'))
+    figure
+    for iy = 1:3
+        subplot(2,2,iy)
+        plot(D.t,D.Y(:,iy),'rx')
+        hold on
+        plot(sol.t,sol.y(:,iy),'.-')
+        xlim([0,60])
+        xlabel('t')
+        switch(iy)
+            case 1
+                ylabel('pStat')
+            case 2
+                ylabel('tStat')
+            case 3
+                ylabel('pEpoR')
+        end
+        ylim([0,1.2])
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    end
+    
+    % generate new
+    xi_rand = xi + 0.1;
+    options.sensi = 2;
+    options.sensi_meth = 'adjoint';
+    sol = simulate_model_jakstat_adjoint([],xi_rand,[],D,options);
+    options.sensi_meth = 'forward';
+    solf = simulate_model_jakstat_adjoint([],xi_rand,[],D,options);
+    
+    options.sensi = 1;
+    eps = 1e-4;
+    fd_grad = NaN(length(xi),1);
+    for ip = 1:length(xi)
+        xip = xi_rand;
+        xip(ip) = xip(ip) + eps;
+        psol = simulate_model_jakstat_adjoint([],xip,[],D,options);
+        fd_grad(ip) = (psol.llh-sol.llh)/eps;
+        fd_hess(:,ip) = (psol.sllh-sol.sllh)/eps;
+    end
+    
+    if(usejava('jvm'))
+    figure
+    subplot(1,2,1)
+    plot(abs(solf.sllh),abs(fd_grad),'rx')
+    hold on
+    plot(abs(solf.sllh),abs(sol.sllh),'bo')
+    hold on
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    ylim([1e-2,1e2])
+    xlim([1e-2,1e2])
+    plot([1e-2,1e2],[1e-2,1e2],'k:')
+    legend('finite differences','adjoint sensitivities','Location','best')
+    box on
+    axis square
+    xlabel('absolute value forward sensitivity gradient entries')
+    ylabel('absolute value gradient entries')
+    
+    subplot(1,2,2)
+    plot(abs(solf.s2llh(:)),abs(fd_hess(:)),'rx')
+    hold on
+    plot(abs(solf.s2llh(:)),abs(sol.s2llh(:)),'bo')
+    hold on
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    ylim([1e-5,1e3])
+    xlim([1e-5,1e3])
+    plot([1e-5,1e3],[1e-5,1e3],'k:')
+    legend('finite differences','adjoint sensitivities','Location','best')
+    box on
+    axis square
+    xlabel('absolute value forward sensitivity hessian entries')
+    ylabel('absolute value hessian entries')
+    
+    set(gcf,'Position',[100 300 1200 500])
+    end
+    
+    
+    drawnow
+    
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/example_jakstat_adjoint.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/example_jakstat_adjoint.html
new file mode 100644
index 0000000000000000000000000000000000000000..711bc3bfe1a85e947c9c12abce3c6c02caba6f2d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/example_jakstat_adjoint.html
@@ -0,0 +1,259 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_jakstat_adjoint</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_jakstat_adjoint.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_jakstat_adjoint()
+
+    <span class="comment">% compile the model</span>
+    [exdir,~,~]=fileparts(which(<span class="string">'example_jakstat_adjoint.m'</span>));
+    amiwrap(<span class="string">'model_jakstat'</span>,<span class="string">'model_jakstat_adjoint_syms'</span>,exdir)
+
+    num = xlsread(fullfile(exdir,<span class="string">'pnas_data_original.xls'</span>));
+
+    D.t = num(:,1);
+    D.condition= [1.4,0.45];
+    D.Y = num(:,[2,4,6]);
+    D.Sigma_Y = NaN(size(D.Y));
+    D = amidata(D);
+
+    xi =  [0.60
+        3
+        -0.95
+        -0.0075
+        0
+        -2.8
+        -0.26
+        -0.075
+        -0.41
+        -5
+        -0.74
+        -0.64
+        -0.11
+        0.027
+        -0.5
+        0
+        -0.5];
+
+    options.sensi = 0;
+    sol = simulate_model_jakstat([],xi,[],D,options);
+
+    figure
+    <span class="keyword">for</span> iy = 1:3
+        subplot(2,2,iy)
+        plot(D.t,D.Y(:,iy),<span class="string">'rx'</span>)
+        hold <span class="string">on</span>
+        plot(sol.t,sol.y(:,iy),<span class="string">'.-'</span>)
+        xlim([0,60])
+        xlabel(<span class="string">'t'</span>)
+        <span class="keyword">switch</span>(iy)
+            <span class="keyword">case</span> 1
+                ylabel(<span class="string">'pStat'</span>)
+            <span class="keyword">case</span> 2
+                ylabel(<span class="string">'tStat'</span>)
+            <span class="keyword">case</span> 3
+                ylabel(<span class="string">'pEpoR'</span>)
+        <span class="keyword">end</span>
+        ylim([0,1.2])
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    <span class="comment">% generate new</span>
+    xi_rand = xi + 0.1;
+    options.sensi = 1;
+    options.sensi_meth = <span class="string">'adjoint'</span>;
+    sol = simulate_model_jakstat([],xi_rand,[],D,options);
+
+    options.sensi = 0;
+    eps = 1e-4;
+    fd_grad = NaN(length(xi),1);
+    <span class="keyword">for</span> ip = 1:length(xi)
+        xip = xi_rand;
+        xip(ip) = xip(ip) + eps;
+        psol = simulate_model_jakstat([],xip,[],D,options);
+        fd_grad(ip) = (psol.llh-sol.llh)/eps;
+    <span class="keyword">end</span>
+
+    figure
+    scatter(abs(sol.sllh),abs(fd_grad))
+    set(gca,<span class="string">'XScale'</span>,<span class="string">'log'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    xlim([1e-2,1e2])
+    ylim([1e-2,1e2])
+    box <span class="string">on</span>
+    hold <span class="string">on</span>
+    axis <span class="string">square</span>
+    plot([1e-2,1e2],[1e-2,1e2],<span class="string">'k:'</span>)
+    xlabel(<span class="string">'adjoint sensitivity absolute value of gradient element'</span>)
+    ylabel(<span class="string">'finite difference absolute value of gradient element'</span>)
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+
+    drawnow
+
+<span class="keyword">end</span>
+</pre><pre class="codeoutput">Generating model struct ...
+Parsing model struct ...
+Generating C code ...
+headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><img vspace="5" hspace="5" src="../examples/example_jakstat_adjoint/html/example_jakstat_adjoint_01.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_jakstat_adjoint/html/example_jakstat_adjoint_02.png" alt=""> <p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_jakstat_adjoint()
+    
+    % compile the model
+    [exdir,~,~]=fileparts(which('example_jakstat_adjoint.m'));
+    amiwrap('model_jakstat','model_jakstat_adjoint_syms',exdir)
+    
+    num = xlsread(fullfile(exdir,'pnas_data_original.xls'));
+    
+    D.t = num(:,1);
+    D.condition= [1.4,0.45];
+    D.Y = num(:,[2,4,6]);
+    D.Sigma_Y = NaN(size(D.Y));
+    D = amidata(D);
+    
+    xi =  [0.60
+        3
+        -0.95
+        -0.0075
+        0
+        -2.8
+        -0.26
+        -0.075
+        -0.41
+        -5
+        -0.74
+        -0.64
+        -0.11
+        0.027
+        -0.5
+        0
+        -0.5];
+    
+    options.sensi = 0;
+    sol = simulate_model_jakstat([],xi,[],D,options);
+    
+    figure
+    for iy = 1:3
+        subplot(2,2,iy)
+        plot(D.t,D.Y(:,iy),'rx')
+        hold on
+        plot(sol.t,sol.y(:,iy),'.-')
+        xlim([0,60])
+        xlabel('t')
+        switch(iy)
+            case 1
+                ylabel('pStat')
+            case 2
+                ylabel('tStat')
+            case 3
+                ylabel('pEpoR')
+        end
+        ylim([0,1.2])
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    % generate new
+    xi_rand = xi + 0.1;
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    sol = simulate_model_jakstat([],xi_rand,[],D,options);
+    
+    options.sensi = 0;
+    eps = 1e-4;
+    fd_grad = NaN(length(xi),1);
+    for ip = 1:length(xi)
+        xip = xi_rand;
+        xip(ip) = xip(ip) + eps;
+        psol = simulate_model_jakstat([],xip,[],D,options);
+        fd_grad(ip) = (psol.llh-sol.llh)/eps;
+    end
+    
+    figure
+    scatter(abs(sol.sllh),abs(fd_grad))
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    xlim([1e-2,1e2])
+    ylim([1e-2,1e2])
+    box on
+    hold on
+    axis square
+    plot([1e-2,1e2],[1e-2,1e2],'k:')
+    xlabel('adjoint sensitivity absolute value of gradient element')
+    ylabel('finite difference absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+    
+    
+    drawnow
+    
+end
+
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/example_jakstat_adjoint.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/example_jakstat_adjoint.tex
new file mode 100644
index 0000000000000000000000000000000000000000..44e9688a17ff9c97b0bb517e97ee52cc3fa68904
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/example_jakstat_adjoint.tex
@@ -0,0 +1,127 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_jakstat_adjoint()
+
+    % compile the model
+    [exdir,~,~]=fileparts(which('example_jakstat_adjoint.m'));
+    amiwrap('model_jakstat','model_jakstat_adjoint_syms',exdir)
+
+    num = xlsread(fullfile(exdir,'pnas_data_original.xls'));
+
+    D.t = num(:,1);
+    D.condition= [1.4,0.45];
+    D.Y = num(:,[2,4,6]);
+    D.Sigma_Y = NaN(size(D.Y));
+    D = amidata(D);
+
+    xi =  [0.60
+        3
+        -0.95
+        -0.0075
+        0
+        -2.8
+        -0.26
+        -0.075
+        -0.41
+        -5
+        -0.74
+        -0.64
+        -0.11
+        0.027
+        -0.5
+        0
+        -0.5];
+
+    options.sensi = 0;
+    sol = simulate_model_jakstat([],xi,[],D,options);
+
+    figure
+    for iy = 1:3
+        subplot(2,2,iy)
+        plot(D.t,D.Y(:,iy),'rx')
+        hold on
+        plot(sol.t,sol.y(:,iy),'.-')
+        xlim([0,60])
+        xlabel('t')
+        switch(iy)
+            case 1
+                ylabel('pStat')
+            case 2
+                ylabel('tStat')
+            case 3
+                ylabel('pEpoR')
+        end
+        ylim([0,1.2])
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    % generate new
+    xi_rand = xi + 0.1;
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    sol = simulate_model_jakstat([],xi_rand,[],D,options);
+
+    options.sensi = 0;
+    eps = 1e-4;
+    fd_grad = NaN(length(xi),1);
+    for ip = 1:length(xi)
+        xip = xi_rand;
+        xip(ip) = xip(ip) + eps;
+        psol = simulate_model_jakstat([],xip,[],D,options);
+        fd_grad(ip) = (psol.llh-sol.llh)/eps;
+    end
+
+    figure
+    scatter(abs(sol.sllh),abs(fd_grad))
+    set(gca,'XScale','log')
+    set(gca,'YScale','log')
+    xlim([1e-2,1e2])
+    ylim([1e-2,1e2])
+    box on
+    hold on
+    axis square
+    plot([1e-2,1e2],[1e-2,1e2],'k:')
+    xlabel('adjoint sensitivity absolute value of gradient element')
+    ylabel('finite difference absolute value of gradient element')
+    set(gcf,'Position',[100 300 1200 500])
+
+
+    drawnow
+
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+Parsing model struct ...
+
+Generating C code ...
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    
+\includegraphics[width=\textwidth]{../../examples/example_jakstat_adjoint/html/example_jakstat_adjoint_01.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_jakstat_adjoint/html/example_jakstat_adjoint_02.png}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/model_jakstat_adjoint_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/model_jakstat_adjoint_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..8c5dbe071df66b7948497809481a6c6c7e94cdbd
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/model_jakstat_adjoint_syms.html
@@ -0,0 +1,186 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_jakstat_adjoint_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_jakstat_adjoint_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_jakstat_syms()
+</pre><p>STATES</p><pre class="codeinput">    syms <span class="string">STAT</span> <span class="string">pSTAT</span> <span class="string">pSTAT_pSTAT</span> <span class="string">npSTAT_npSTAT</span> <span class="string">nSTAT1</span> <span class="string">nSTAT2</span> <span class="string">nSTAT3</span> <span class="string">nSTAT4</span> <span class="string">nSTAT5</span>
+
+    model.sym.x = [
+        STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 <span class="keyword">...</span>
+        ];
+</pre><p>PARAMETERS</p><pre class="codeinput">    syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span> <span class="string">init_STAT</span> <span class="string">Omega_cyt</span> <span class="string">Omega_nuc</span> <span class="string">sp1</span> <span class="string">sp2</span> <span class="string">sp3</span> <span class="string">sp4</span> <span class="string">sp5</span> <span class="string">offset_tSTAT</span> <span class="string">offset_pSTAT</span> <span class="string">scale_tSTAT</span> <span class="string">scale_pSTAT</span> <span class="string">sigma_pSTAT</span> <span class="string">sigma_tSTAT</span> <span class="string">sigma_pEpoR</span>
+
+    model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+
+    model.param = <span class="string">'log10'</span>;
+
+    model.sym.k = [Omega_cyt,Omega_nuc];
+</pre><p>INPUT</p><pre class="codeinput">    syms <span class="string">t</span>
+    u(1) = spline_pos5(t, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+</pre><pre class="codeoutput">Warning: Support of strings that are not valid variable names or define a number
+will be removed in a future release. To create symbolic expressions, first
+create symbolic variables and then use operations on them. 
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput">    model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+    model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+    model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+    model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+    model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+    model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+    model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+    model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+    model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+    model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">    model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+    model.sym.x0(1) = init_STAT;
+</pre><p>OBSERVABLES</p><pre class="codeinput">    model.sym.y = sym(zeros(3,1));
+
+    model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+    model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+    model.sym.y(3) = u(1);
+</pre><p>SIGMA</p><pre class="codeinput">    model.sym.sigma_y = sym(size(model.sym.y));
+
+    model.sym.sigma_y(1) = sigma_pSTAT;
+    model.sym.sigma_y(2) = sigma_tSTAT;
+    model.sym.sigma_y(3) = sigma_pEpoR;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_jakstat_syms()
+    
+    %%
+    % STATES
+    
+    syms STAT pSTAT pSTAT_pSTAT npSTAT_npSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+    
+    model.sym.x = [
+        STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+        ];
+    
+    %%
+    % PARAMETERS
+    
+    syms p1 p2 p3 p4 init_STAT Omega_cyt Omega_nuc sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT sigma_pSTAT sigma_tSTAT sigma_pEpoR
+    
+    model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+    
+    model.param = 'log10';
+    
+    model.sym.k = [Omega_cyt,Omega_nuc];
+    
+    %%
+    % INPUT
+    syms t
+    u(1) = spline_pos5(t, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+    
+    %%
+    % SYSTEM EQUATIONS
+    
+    model.sym.xdot = sym(zeros(size(model.sym.x)));
+    
+    model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+    model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+    model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+    model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+    model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+    model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+    model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+    model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+    model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+    
+    %%
+    % INITIAL CONDITIONS
+    
+    model.sym.x0 = sym(zeros(size(model.sym.x)));
+    
+    model.sym.x0(1) = init_STAT;
+    
+    %%
+    % OBSERVABLES
+    
+    model.sym.y = sym(zeros(3,1));
+    
+    model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+    model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+    model.sym.y(3) = u(1);
+    
+    %%
+    % SIGMA
+    
+    model.sym.sigma_y = sym(size(model.sym.y));
+    
+    model.sym.sigma_y(1) = sigma_pSTAT;
+    model.sym.sigma_y(2) = sigma_tSTAT;
+    model.sym.sigma_y(3) = sigma_pEpoR;
+    
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/model_jakstat_adjoint_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/model_jakstat_adjoint_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..67b5416988808cdef4b57206f093c46c17361c24
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/html/model_jakstat_adjoint_syms.tex
@@ -0,0 +1,109 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_jakstat_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    syms STAT pSTAT pSTAT_pSTAT npSTAT_npSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+
+    model.sym.x = [
+        STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+        ];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    syms p1 p2 p3 p4 init_STAT Omega_cyt Omega_nuc sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT sigma_pSTAT sigma_tSTAT sigma_pEpoR
+
+    model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+
+    model.param = 'log10';
+
+    model.sym.k = [Omega_cyt,Omega_nuc];
+\end{DoxyCode}
+\begin{par}
+INPUT
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    syms t
+    u(1) = spline_pos5(t, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+\end{DoxyCode}
+
+         \begin{DoxyCode}Warning: Support of strings that are not valid variable names or define a number
+will be removed in a future release. To create symbolic expressions, first
+create symbolic variables and then use operations on them. 
+\end{DoxyCode} 
+    \begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+    model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+    model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+    model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+    model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+    model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+    model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+    model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+    model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+    model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+    model.sym.x0(1) = init_STAT;
+\end{DoxyCode}
+\begin{par}
+OBSERVABLES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    model.sym.y = sym(zeros(3,1));
+
+    model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+    model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+    model.sym.y(3) = u(1);
+\end{DoxyCode}
+\begin{par}
+SIGMA
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    model.sym.sigma_y = sym(size(model.sym.y));
+
+    model.sym.sigma_y(1) = sigma_pSTAT;
+    model.sym.sigma_y(2) = sigma_tSTAT;
+    model.sym.sigma_y(3) = sigma_pEpoR;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/model_jakstat_adjoint_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/model_jakstat_adjoint_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..d1426d53bebac7ec4dbc9bbfc9790ac29336486b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint/model_jakstat_adjoint_syms.m
@@ -0,0 +1,69 @@
+function [model] = model_jakstat_syms()
+    
+    %%
+    % STATES
+    
+    syms STAT pSTAT pSTAT_pSTAT npSTAT_npSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+    
+    model.sym.x = [
+        STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+        ];
+
+    %%
+    % PARAMETERS
+    
+    syms p1 p2 p3 p4 init_STAT Omega_cyt Omega_nuc sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT sigma_pSTAT sigma_tSTAT sigma_pEpoR
+    
+    model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+    
+    model.param = 'log10';
+    
+    model.sym.k = [Omega_cyt,Omega_nuc];
+    
+    %%
+    % INPUT
+    syms t
+    % u(1) = spline_pos5(t, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+    u(1) = am_spline_pos(t, 5, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+    
+    %%
+    % SYSTEM EQUATIONS
+    
+    model.sym.xdot = sym(zeros(size(model.sym.x)));
+    
+    model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+    model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+    model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+    model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+    model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+    model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+    model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+    model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+    model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+    
+    %%
+    % INITIAL CONDITIONS
+    
+    model.sym.x0 = sym(zeros(size(model.sym.x)));
+    
+    model.sym.x0(1) = init_STAT;
+    
+    %%
+    % OBSERVABLES
+    
+    model.sym.y = sym(zeros(3,1));
+    
+    model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+    model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+    model.sym.y(3) = u(1);
+    
+    %%
+    % SIGMA
+    
+    model.sym.sigma_y = sym(size(model.sym.y));
+    
+    model.sym.sigma_y(1) = sigma_pSTAT;
+    model.sym.sigma_y(2) = sigma_tSTAT;
+    model.sym.sigma_y(3) = sigma_pEpoR;
+    
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint_hvp/example_jakstat_adjoint_hvp.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint_hvp/example_jakstat_adjoint_hvp.m
new file mode 100644
index 0000000000000000000000000000000000000000..2654e7bd93c0c0463844b0febe6e3e9fee69da25
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint_hvp/example_jakstat_adjoint_hvp.m
@@ -0,0 +1,108 @@
+function example_jakstat_adjoint_hvp()
+    
+    % compile the model
+    [exdir,~,~]=fileparts(which('example_jakstat_adjoint_hvp.m'));
+    amiwrap('model_jakstat_adjoint_hvp','model_jakstat_adjoint_hvp_syms',exdir,2)
+    num = xlsread(fullfile(exdir,'pnas_data_original.xls'));
+    
+    D.t = num(:,1);
+    D.condition= [1.4,0.45];
+    D.Y = num(:,[2,4,6]);
+    D.Sigma_Y = NaN(size(D.Y));
+    D = amidata(D);
+    
+    xi =  [0.60
+        3
+        -0.95
+        -0.0075
+        0
+        -2.8
+        -0.26
+        -0.075
+        -0.41
+        -5
+        -0.74
+        -0.64
+        -0.11
+        0.027
+        -0.5
+        0
+        -0.5];
+    
+    
+    % generate new
+    xi_rand = xi - 0.1;
+    options.atol = 1e-12;
+    options.rtol = 1e-12;
+    
+    % Get time for simulation
+    tic;
+    options.sensi = 0;
+    sol0 = simulate_model_jakstat_adjoint_hvp([],xi_rand,[],D,options);
+    t0 = toc;
+    
+    % Get time for usual evaluation
+    tic;
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    sol1 = simulate_model_jakstat_adjoint_hvp([],xi_rand,[],D,options);
+    t1 = toc;
+    
+    % Get time for Finite Differences
+    hvp = zeros(17,1);
+    hvp_f = zeros(17,1);
+    hvp_b = zeros(17,1);
+    tic;
+
+    sol2 = simulate_model_jakstat_adjoint_hvp([],xi_rand,[],D,options);
+    v = sol2.sllh;
+    delta = 1e-5;
+    solp  = simulate_model_jakstat_adjoint_hvp([],xi_rand + delta*v,[],D,options);
+    solm  = simulate_model_jakstat_adjoint_hvp([],xi_rand - delta*v,[],D,options);
+    hvp = hvp + (solp.sllh - solm.sllh) / (2*delta);
+    hvp_f = hvp_f + (solp.sllh - sol2.sllh) / (delta);
+    hvp_b = hvp_b + (sol2.sllh - solm.sllh) / (delta);
+    t2 = toc;
+    
+    % Get time for Second order adjoints
+    hvpasa = zeros(17,1);
+    tic;
+    options.sensi = 1;
+    options.sensi_meth = 'adjoint';
+    presol = simulate_model_jakstat_adjoint_hvp([],xi_rand,[],D,options);
+    v = presol.sllh;
+    options.sensi = 2;
+    sol  = simulate_model_jakstat_adjoint_hvp([],xi_rand,[],D,options,v);
+    hvpasa = hvpasa + sol.s2llh';
+    t3 = toc;
+    options.sensi_meth = 'forward';
+    solf  = simulate_model_jakstat_adjoint_hvp([],xi_rand,[],D,options,v);
+    options.sensi_meth = 'adjoint';
+
+if(usejava('jvm'))
+    figure();
+    
+    subplot(1,2,1);
+    bar([abs((sol.s2llh-hvp)./sol.s2llh),abs((sol.s2llh-hvp_f)./sol.s2llh),abs((sol.s2llh-hvp_b)./sol.s2llh),abs((sol.s2llh-solf.s2llh)./sol.s2llh)])
+    hold on
+    set(gca,'YScale','log')
+    ylim([1e-16,1e0])
+    box on
+    hold on
+    %     plot([1e-2,1e2],[1e-2,1e2],'k:')
+    xlabel('parameter index')
+    ylabel('relative difference to adjoint sensitivities')
+    legend('FD_{central}','FD_{forward}','FD_{backward}','forward sensitivities','Orientation','horizontal')
+    legend boxoff
+    set(gcf,'Position',[100 300 1200 500])
+    
+    subplot(1,2,2);
+    hold on;
+    bar([t0,t1,t2,t3]);
+    xlabel('runtime [s]')
+    set(gca,'XTick',1:4,'XTickLabel',{'ODE Integration', 'Gradient computation (ASA)', 'HVP from FD via 1st order ASA', 'HVP via 2nd order ASA'},'XTickLabelRotation',20);
+    
+    box on;
+    hold off;
+end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint_hvp/model_jakstat_adjoint_hvp_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint_hvp/model_jakstat_adjoint_hvp_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..b14eaacdb5fe0a0386a90649b4b445615ad850ea
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_jakstat_adjoint_hvp/model_jakstat_adjoint_hvp_syms.m
@@ -0,0 +1,69 @@
+function [model] = model_jakstat_adjoint_hvp_syms()
+    
+    %%
+    % STATES
+    
+    syms STAT pSTAT pSTAT_pSTAT npSTAT_npSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+    
+    model.sym.x = [
+        STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+        ];
+    
+    %%
+    % PARAMETERS
+    
+    syms p1 p2 p3 p4 init_STAT Omega_cyt Omega_nuc sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT sigma_pSTAT sigma_tSTAT sigma_pEpoR
+    
+    model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+    
+    model.param = 'log10';
+    
+    model.sym.k = [Omega_cyt,Omega_nuc];
+    
+    %%
+    % INPUT
+    syms t
+    u(1) = am_spline_pos(t, 5, 0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0);
+    % u(1) = spline_pos5(t, 0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0);
+    
+    %%
+    % SYSTEM EQUATIONS
+    
+    model.sym.xdot = sym(zeros(size(model.sym.x)));
+    
+    model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+    model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+    model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+    model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+    model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+    model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+    model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+    model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+    model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+    
+    %%
+    % INITIAL CONDITIONS
+    
+    model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+    model.sym.x0(1) = init_STAT;
+    
+    %%
+    % OBSERVABLES
+    
+    model.sym.y = sym(zeros(3,1));
+    
+    model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+    model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+    model.sym.y(3) = u(1);
+    
+    %%
+    % SIGMA
+    
+    model.sym.sigma_y = sym(size(model.sym.y));
+    
+    model.sym.sigma_y(1) = sigma_pSTAT;
+    model.sym.sigma_y(2) = sigma_tSTAT;
+    model.sym.sigma_y(3) = sigma_pEpoR;
+    
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_nested_events/example_nested_events.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_nested_events/example_nested_events.m
new file mode 100644
index 0000000000000000000000000000000000000000..1bd5ed9d5b330bdb38b2f385105e8bc5f8279eab
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_nested_events/example_nested_events.m
@@ -0,0 +1,129 @@
+function example_events()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_nested_events.m'));
+% compile the model
+amiwrap('model_nested_events','model_nested_events_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+t = linspace(0,20,100);
+p = [ 0.1
+    1000
+    2
+    8e-1
+    1.6   ];
+k = [];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4,...
+    'rtol',1e-12,...
+    'ato',1e-10,...
+    'nmaxevent', 2);
+D = amidata(length(t),1,0,2,0);
+% load mex into memory
+[~] = which('simulate_model_events'); % fix for inaccessability problems
+sol = simulate_model_nested_events(t,log10(p),k,D,options);
+
+tic
+sol = simulate_model_nested_events(t,log10(p),k,D,options);
+disp(['Time elapsed with cvodes: ' num2str(toc) ])
+
+%%
+% ODE15S
+
+sig = 1e-2;
+delta_num = @(tau) exp(-1/2*(tau/sig).^2)/(sqrt(2*pi)*sig);
+
+ode_system = @(t,x,p,k) +p(2)*delta_num(t-p(3)) + x*p(4)*heaviside(x-1) - x*p(5);
+
+options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+tic
+[~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,p(1),options_ode15s);
+disp(['Time elapsed with ode15s: ' num2str(toc) ])
+
+%%
+% PLOTTING
+
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(1,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+    end
+    legend('x1','x1_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    set(gca,'YScale','log')
+    box on
+    subplot(1,2,2)
+    plot(t,abs(sol.x-X_ode15s),'--')
+    set(gca,'YScale','log')
+    legend('error x1','Location','NorthEastOutside')
+    legend boxoff
+    ylabel('x')
+    
+    set(gcf,'Position',[100 300 1200 300])
+end
+
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 1;
+
+sol = simulate_model_nested_events(t,log10(p),k,D,options);
+
+%%
+% FINITE DIFFERENCES
+
+eps = 1e-8;
+xi = log10(p);
+for ip = 1:5;
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_nested_events(t,xip,k,D,options);
+    sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    for ip = 1:5
+        subplot(5,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,ip),'d','Color',c_x(ix,:))
+        end
+        legend('sx1','sx1_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('sx')
+        box on
+        
+        subplot(5,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,ip)),'--')
+        legend('error sx1','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_nested_events/model_nested_events_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_nested_events/model_nested_events_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..42a1b48ae1ce2a23322e72329e87efc14994b414
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_nested_events/model_nested_events_syms.m
@@ -0,0 +1,64 @@
+function [model] = model_nested_events_syms() 
+
+%% CVODES OPTIONS
+% set the parametrisation of the problem options are 'log', 'log10' and 'lin' (default)
+model.param = 'log10';
+
+%% STATE VARIABLES
+% create state variables syms
+syms Virus
+
+% create state variable vector
+x = [Virus];
+
+%% PARAMETERS
+% create parameters syms
+syms V_0
+syms V_0_inject
+syms t_0
+syms rho_V
+syms delta_V
+
+% create parameter vector
+p = [V_0
+     V_0_inject
+     t_0
+     rho_V
+     delta_V];
+
+%% CONSTANTS
+% create constant vector
+k = [];
+
+%% RIGHT-HAND SIDE OF DIFFERENTIAL EQUATION
+% create symbolic variable for time
+syms t
+
+% symbolic expression for right-hand side of differential equation
+xdot = sym(zeros(1,1));
+xdot(1) = V_0_inject*dirac(t-t_0) + Virus*rho_V*heaviside(Virus-1) - Virus*delta_V;
+
+%% INITIAL CONDITION
+x0 = sym(zeros(1,1));
+x0(1) = V_0;
+
+%% OBSERVABLE
+y = sym(zeros(1,1));
+y(1) = Virus;
+
+%% EVENTS
+% this part is optional and can be ommited
+
+% events fire when there is a zero crossing of the root function
+event = sym(zeros(0,1));
+
+%% SYSTEM STRUCT
+model.sym.x = x;
+model.sym.k = k;
+model.sym.event = event;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_neuron/example_neuron.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_neuron/example_neuron.m
new file mode 100644
index 0000000000000000000000000000000000000000..d05b0cfe65fa43638437f9479ce9faa9b4b3f14d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_neuron/example_neuron.m
@@ -0,0 +1,304 @@
+function example_neuron()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_neuron.m'));
+% compile the model
+amiwrap('model_neuron','model_neuron_syms',exdir,1)
+
+%%
+% SIMULATION
+
+p = [0.02 0.3 65 0.9];
+
+k = [-60,10];
+
+t = linspace(0,100,100);
+
+
+options = amioption('sensi',0,...
+    'maxsteps',1e5,...
+    'nmaxevent',22);
+
+% load mex into memory
+[msg] = which('simulate_neuron_dirac'); % fix for inaccessability problems
+sol = simulate_model_neuron(t,log10(p),k,[],options);
+
+tic
+sol = simulate_model_neuron(t,log10(p),k,[],options);
+
+D = amidata(length(t),1,size(sol.z(sol.z<t(end)),2),size(sol.z(sol.z<t(end)),1),2);
+
+rng(0);
+D.Z = sol.z(sol.z<t(end));
+t = linspace(0,D.Z(end)-0.1,100);
+D.Z = D.Z + 0.5*randn(size(D.Z));
+D.Z(3) = NaN;
+D.Sigma_Z = 0.5*ones(size(D.Z)); 
+D.Z = D.Z + D.Sigma_Z.*randn(size(D.Z));
+
+D.t = t;
+D.condition = k;
+
+sol = simulate_model_neuron([],log10(p),[],D,options);
+
+llh = 0;
+for ie = 1:size(D.Z,1)
+    if(~isnan(D.Z(ie,1)))
+        llh = llh - 1/2*log(2*pi*D.Sigma_Z(ie,1)^2) - 1/2*((sol.z(ie,1)-D.Z(ie,1))/D.Sigma_Z(ie,1))^2;
+        if(sol.rz(ie,1)~=0)
+            llh = llh - 1/2*log(2*pi*D.Sigma_Z(ie,1)^2) - 1/2*((sol.rz(ie,1))/D.Sigma_Z(ie,1))^2;
+        end
+    end
+end
+
+%%
+% PLOTTING
+
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,1,1)
+    for iz = 1:size(sol.x,2)
+        plot(t,sol.x(:,iz),'.-','Color',c_x(iz,:))
+        hold on
+    end
+    stem(sol.z,zeros(size(sol.z)))
+    
+    legend('x1','x2','events','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,1,2)
+    plot(-sol.llh,-llh,'bo')
+    xlabel('amici nllh')
+    ylabel('true nllh')
+    set(gca,'XScale','log','YScale','log')
+    hold on
+    plot([1,1e4],[1,1e4],'k:')
+    legend boxoff
+    axis square
+end
+
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 2;
+options.sens_ind = 1:length(p);
+
+sol = simulate_model_neuron(t,log10(p),k,D,options);
+
+%%
+% FINITE DIFFERENCES
+
+options.sensi = 1;
+
+eps = 1e-5;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(options.sens_ind(ip)) = xip(options.sens_ind(ip)) + eps;
+    solp = simulate_model_neuron(t,xip,k,D,options);
+    srz_fd(:,:,ip) = (solp.rz - sol.rz)/eps;
+    s2rz_fd(:,:,:,ip) = (solp.srz - sol.srz)/eps;
+    sllh_fd(ip,1) = (solp.llh - sol.llh)/eps;
+    s2llh_fd(ip,:) = (solp.sllh - sol.sllh)/eps;
+end
+
+eps = 1e-3;
+xi = log10(p);
+for ip = 1:4;
+    xip = xi;
+    xip(options.sens_ind(ip)) = xip(options.sens_ind(ip)) + eps;
+    solp = simulate_model_neuron(t,xip,k,D,options);
+    sz_fd(:,:,ip) = (solp.z - sol.z)/eps;
+    s2z_fd(:,:,:,ip) = (solp.sz - sol.sz)/eps;
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    subplot(2,3,1)
+    hold on
+    plot(abs(sol.sz(:)),abs(sz_fd(:)),'bo')
+    hold on
+    plot([1e-5,1e5],[1e-5,1e5],'k:')
+    xlim([1e-5,1e5])
+    ylim([1e-5,1e5])
+    title('event output sensitivity')
+    xlabel('sz')
+    ylabel('sz_{fd}')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,4)
+    plot(abs(sol.sz(:)),abs(sol.sz(:)-sz_fd(:)),'ro')
+    hold on
+    plot([1e-5,1e5],[1e-5,1e5],'k:')
+    xlim([1e-5,1e5])
+    ylim([1e-5,1e5])
+    title('event output sensitivity')
+    xlabel('sz')
+    ylabel('error')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,2)
+    hold on
+    plot(abs(sol.srz(:)),abs(srz_fd(:)),'bo')
+    hold on
+    plot([1e2,1e5],[1e2,1e5],'k:')
+    xlim([1e2,1e5])
+    ylim([1e2,1e5])
+    title('event root sensitivity')
+    xlabel('srz')
+    ylabel('srz_{fd}')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,5)
+    plot(abs(sol.srz(:)),abs(sol.srz(:)-srz_fd(:)),'ro')
+    hold on
+    plot([1e2,1e5],[1e2,1e5],'k:')
+    xlim([1e2,1e5])
+    ylim([1e2,1e5])
+    title('event root sensitivity')
+    xlabel('srz')
+    ylabel('error')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,3)
+    hold on
+    plot(abs(sol.sllh),abs(sllh_fd),'ko')
+    hold on
+    plot([1e3,1e7],[1e3,1e7],'k:')
+    xlim([1e3,1e7])
+    ylim([1e3,1e7])
+    xlabel('sllh')
+    ylabel('sllh_{fd}')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    title('abs llh sensitivity')
+    box on
+    axis square
+        
+    subplot(2,3,6)
+    plot(abs(sol.sllh),abs(sol.sllh-sllh_fd),'ro')
+    hold on
+    plot([1e3,1e7],[1e3,1e7],'k:')
+    xlim([1e3,1e7])
+    ylim([1e3,1e7])
+    xlabel('sllh')
+    ylabel('error sllh')
+    title('abs llh sensitivity')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    subplot(2,3,1)
+    hold on
+    plot(abs(sol.s2z(:)),abs(s2z_fd(:)),'bo')
+    hold on
+    plot([1e-5,1e5],[1e-5,1e5],'k:')
+    xlim([1e-5,1e5])
+    ylim([1e-5,1e5])
+    title('second order event output sensitivity')
+    xlabel('sz')
+    ylabel('sz_{fd}')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,4)
+    plot(abs(sol.s2z(:)),abs(sol.s2z(:)-s2z_fd(:)),'ro')
+    hold on
+    plot([1e-5,1e5],[1e-5,1e5],'k:')
+    xlim([1e-5,1e5])
+    ylim([1e-5,1e5])
+    title('second order event output sensitivity')
+    xlabel('sz')
+    ylabel('error')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,2)
+    hold on
+    plot(abs(sol.s2rz(:)),abs(s2rz_fd(:)),'bo')
+    hold on
+    plot([1e5,1e8],[1e5,1e8],'k:')
+    xlim([1e5,1e8])
+    ylim([1e5,1e8])
+    title('second order event output sensitivity')
+    xlabel('sz')
+    ylabel('sz_{fd}')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,5)
+    plot(abs(sol.s2rz(:)),abs(sol.s2rz(:)-s2rz_fd(:)),'ro')
+    hold on
+    plot([1e5,1e8],[1e5,1e8],'k:')
+    xlim([1e5,1e8])
+    ylim([1e5,1e8])
+    title('second order event output sensitivity')
+    xlabel('sz')
+    ylabel('error')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    
+    subplot(2,3,3)
+    hold on
+    plot(abs(sol.s2llh),abs(s2llh_fd),'ko')
+    hold on
+    plot([1e2,1e10],[1e2,1e10],'k:')
+    xlim([1e2,1e10])
+    ylim([1e2,1e10])
+    xlabel('sllh')
+    ylabel('sllh_{fd}')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    title('abs llh sensitivity')
+    box on
+    axis square
+        
+    subplot(2,3,6)
+    plot(abs(sol.s2llh),abs(sol.s2llh-s2llh_fd),'ro')
+    hold on
+    plot([1e2,1e10],[1e2,1e10],'k:')
+    xlim([1e2,1e10])
+    ylim([1e2,1e10])
+    xlabel('sllh')
+    ylabel('error sllh')
+    title('abs llh sensitivity')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_neuron/model_neuron_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_neuron/model_neuron_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..e5786fb8ee73509d9168db12173c29d5d5b47362
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_neuron/model_neuron_syms.m
@@ -0,0 +1,40 @@
+function model = neuron_syms()
+    
+    model.param = 'log10';
+    
+    syms a b c d 
+    
+    p = [a b c d];
+    
+    syms v0 I0
+    
+    k = [v0,I0];
+    
+    syms v u
+    
+    x = [v u];
+    
+    syms I t
+    
+    I = I0;
+    
+    f(1) = 0.04*v^2 + 5*v + 140 - u + I ;
+    f(2) = a*(b*v - u);
+
+    y(1) = v;
+    
+    
+    x0 = [v0,b*v0];
+    
+    event = amievent(v-30,[-c-v,d],t);
+    
+    model.sym.p = p;
+    model.sym.k = k;
+    model.sym.x = x;
+    model.sym.y = y;
+    model.sym.f = f;
+    model.event = event;
+    model.sym.x0 = x0;
+    
+    
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_robertson/example_robertson.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_robertson/example_robertson.m
new file mode 100644
index 0000000000000000000000000000000000000000..a5daeaa8b4676588d25785780c398a2c95136820
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_robertson/example_robertson.m
@@ -0,0 +1,131 @@
+function example_robertson()
+%%
+% COMPILATION
+
+[exdir,~,~]=fileparts(which('example_robertson.m'));
+% compile the model
+amiwrap('model_robertson','model_robertson_syms',exdir)
+
+%%
+% SIMULATION
+
+% time vector
+t = [0 4*logspace(-6,6)];
+p = [0.04;1e4;3e7];
+k = [0.9];
+
+options = amioption('sensi',0,...
+    'maxsteps',1e4,...
+    'atol',1e-6,...
+    'rtol',1e-4);
+% load mex into memory
+[~] = which('simulate_model_robertson'); % fix for inaccessability problems
+sol = simulate_model_robertson(t,log10(p),k,[],options);
+
+tic
+sol = simulate_model_robertson(t,log10(p),k,[],options);
+disp(['Time elapsed with cvodes: ' num2str(toc) ])
+
+%%
+% ODE15S
+
+dae_system = @(t,y,p,k) [-p(1)*y(1) + p(2)*y(2).*y(3)
+   p(1)*y(1) - p(2)*y(2).*y(3) - p(3)*y(2).^2
+   y(1) + y(2) + y(3) - 1 ];
+y0 = [k(1); 0; 0];
+M = [1 0 0
+   0 1 0
+   0 0 0];
+options_ode15s = odeset('Mass',M,'RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+tic
+[~, X_ode15s] = ode15s(@(t,x) dae_system(t,x,p,k),t,y0,options_ode15s);
+disp(['Time elapsed with ode15s: ' num2str(toc) ])
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.y(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        if(ix==2)
+            scale = 1e4;
+        else
+            scale = 1;
+        end
+        plot(t,scale*X_ode15s(:,ix),'d','Color',c_x(ix,:))
+    end
+    legend('x1','x1_{ode15s}','x2','x2_{ode15s}','x3','x3_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    set(gca,'XScale','log')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode15s),'--')
+    set(gca,'YScale','log')
+    legend('error x1','error x2','error x3','Location','NorthEastOutside')
+    legend boxoff
+    ylabel('x')
+    
+    set(gcf,'Position',[100 300 1200 500])
+end
+
+%%
+% FORWARD SENSITIVITY ANALYSIS
+
+options.sensi = 1;
+
+sol = simulate_model_robertson(t,log10(p),k,[],options);
+
+%%
+% FINITE DIFFERENCES
+
+eps = 1e-2;
+xi = log10(p);
+for ip = 1:length(p);
+    xip = xi;
+    xip(ip) = xip(ip) + eps;
+    solp = simulate_model_robertson(t,xip,k,[],options);
+    sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+end
+
+%%
+% PLOTTING
+if(usejava('jvm'))
+    figure
+    for ip = 1:length(p)
+        subplot(length(p),2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sy(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sy_fd(:,ix,ip),'d','Color',c_x(ix,:))
+        end
+        legend('sy1','sy1_{fd}','sy2','sy2_{fd}','sy3','sy3_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        set(gca,'XScale','log')
+        ylabel('sx')
+        box on
+        
+        subplot(length(p),2,ip*2)
+        plot(t,abs(sol.sy(:,:,ip)-sy_fd(:,:,ip)),'--')
+        legend('error sy1','error sy2','error sy3','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        set(gca,'XScale','log')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    
+    drawnow
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_robertson/model_robertson_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_robertson/model_robertson_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..bf95c212124f1ce85337803c73cefa16024c7600
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_robertson/model_robertson_syms.m
@@ -0,0 +1,68 @@
+function [model] = model_robertson_syms()
+
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+
+%%
+% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+syms k1
+
+% create parameter vector 
+model.sym.k = [k1];
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+model.sym.xdot(1) = -p1*x1+p2*x2*x3;
+model.sym.xdot(2) = p1*x1-p2*x2*x3-p3*x2^2;
+model.sym.xdot(3) = x1+x2+x3-1;
+
+model.sym.M = [1 0 0; 0 1 0; 0 0 0];
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = 0;
+model.sym.x0(3) = 0;
+
+model.sym.dx0 = sym(zeros(size(model.sym.x)));
+
+%%
+% OBSERVALES
+
+model.sym.y = model.sym.x;
+model.sym.y(2) = 1e4*model.sym.x(2);
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/example_steadystate.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/example_steadystate.m
new file mode 100644
index 0000000000000000000000000000000000000000..e0ce88b5a15095329d014720af2d448d7120b66d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/example_steadystate.m
@@ -0,0 +1,238 @@
+function example_steadystate
+    %%
+    % COMPILATION
+    
+    [exdir,~,~]=fileparts(which('example_steadystate.m'));
+    % compile the model
+    amiwrap('model_steadystate','model_steadystate_syms',exdir)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    t = linspace(0,100,50);
+    p = [1;0.5;0.4;2;0.1];
+    k = [0.1,0.4,0.7,1];
+    
+    options = amioption(...
+        'sensi', 0, ...
+        'maxsteps', 1e4 ...
+        );
+    
+    % load mex into memory
+    simulate_model_steadystate(t,log10(p),k,[],options);
+    
+    tic;
+    sol = simulate_model_steadystate([t, inf],log10(p),k,[],options);
+    display(['Time elapsed with cvodes: ' num2str(toc) ' seconds']);
+    
+    %%
+    % ODE15S
+    
+    ode_system = @(t,x,p,k) [-2*p(1)*x(1)^2 - p(2)*x(1)*x(2) + 2*p(3)*x(2) + p(4)*x(3) + p(5);
+        + p(1)*x(1)^2 - p(2)*x(1)*x(2) - p(3)*x(2) + p(4)*x(3);
+        + p(2)*x(1)*x(2) - p(4)*x(3) - k(4)*x(3)];
+    options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+    
+    tic;
+    [~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+    disp(['Time elapsed with ode15s: ' num2str(toc) ' seconds'])
+    
+    %%
+    % PLOTTING
+    
+    if(usejava('jvm'))
+        figure('Name', 'Example SteadyState');
+        c_x = get(gca,'ColorOrder');
+        subplot(2,1,1);
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.x(1:end-1,ix),'.-','Color',c_x(ix,:));
+            hold on;
+            plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:));
+            plot([t(1), t(end)],sol.x(end,ix)*[1, 1],'--','Color',c_x(ix,:));
+        end
+        legend('x1','x1_{ode15s}','x1_{ss, Newton}','x2','x2_{ode15s}','x2_{ss, Newton}','x3','x3_{ode15s}','x3_{ss, Newton}','Location','NorthEastOutside');
+        legend boxoff;
+        xlabel('time t');
+        ylabel('x');
+        box on;
+        subplot(2,1,2);
+        plot(t,abs(sol.x(1:end-1,:)-X_ode15s),'--');
+        set(gca,'YScale','log');
+        legend('error x1','error x2','error x3','Location','NorthEastOutside');
+        legend boxoff;
+        set(gcf,'Position',[100 300 1200 500]);
+    end
+    
+    %%
+    % FORWARD SENSITIVITY ANALYSIS
+    
+    options.sensi = 1;
+    options.sens_ind = [3,1,2,4];
+    sol = simulate_model_steadystate([t, inf],log10(p),k,[],options);
+    
+    %%
+    % FINITE DIFFERENCES
+    
+    eps = 1e-3;
+    
+    xi = log10(p);
+    sx_ffd = zeros(length(t)+1, 3, length(p));
+    sx_bfd = zeros(length(t)+1, 3, length(p));
+    sx_cfd = zeros(length(t)+1, 3, length(p));
+    for ip = 1:4;
+        xip = xi;
+        xim = xi;
+        xip(ip) = xip(ip) + eps;
+        xim(ip) = xim(ip) - eps;
+        solp = simulate_model_steadystate([t, inf],xip,k,[],options);
+        solm = simulate_model_steadystate([t, inf],xim,k,[],options);
+        sx_ffd(:,:,ip) = (solp.x - sol.x) / eps;
+        sx_bfd(:,:,ip) = (sol.x - solm.x) / eps;
+        sx_cfd(:,:,ip) = (solp.x - solm.x) / (2*eps);
+    end
+    
+    %%
+    % PLOTTING
+    if(usejava('jvm'))
+        % Sensitivities for time series
+        figure('Name', 'Example SteadyState');
+        for ip = 1:4
+            subplot(4,2,ip*2-1);
+            hold on;
+            for ix = 1:size(sol.x,2)
+                plot(t,sol.sx(1:end-1,ix,ip),'.-','Color',c_x(ix,:));
+                plot(t,sx_cfd(1:end-1,ix,options.sens_ind(ip)),'d','Color',c_x(ix,:));
+            end
+            legend('x1','x1_{fd}','x2','x2_{fd}','x3','x3_{fd}','Location','NorthEastOutside');
+            legend boxoff;
+            title(['state sensitivity for p' num2str(options.sens_ind(ip))]);
+            xlabel('time t');
+            ylabel('x');
+            box on;
+
+            subplot(4,2,ip*2);
+            plot(t,abs(sol.sx(1:end-1,:,ip)-sx_cfd(1:end-1,:,options.sens_ind(ip))),'--');
+            legend('error x1','error x2','error x3','Location','NorthEastOutside');
+            legend boxoff;
+            title(['error of state sensitivity for p' num2str(options.sens_ind(ip))]);
+            xlabel('time t');
+            ylabel('error');
+            set(gca,'YScale','log');
+            box on;
+        end
+        set(gcf,'Position',[100 300 1200 500]);
+        
+        sxss = squeeze(sol.sx(length(t),:,:));
+        sxss_fd = squeeze(sx_cfd(length(t),:,options.sens_ind));
+        
+        % Sensitivities for steady state
+        figure('Name', 'Example SteadyState');
+        subplot(1,2,1);
+        hold on;
+        plot([-1,1], [-1,1], 'k:');
+        type = {'o','x','d','*'};
+        for ip = 1:4
+            for ix = 1:size(sol.x,2)
+                plot(sxss(ix,ip), sxss_fd(ix,ip), type{ip}, 'Color', c_x(ix,:));
+            end
+        end
+        legend('SA = FD',...
+            's^{x1}_{p3}','s^{x2}_{p3}','s^{x3}_{p3}',...
+            's^{x1}_{p1}','s^{x2}_{p1}','s^{x3}_{p1}',...
+            's^{x1}_{p2}','s^{x2}_{p2}','s^{x3}_{p2}',...
+            's^{x1}_{p4}','s^{x2}_{p3}','s^{x3}_{p4}',...
+            'Location','NorthEastOutside');
+        legend boxoff;
+        title('Steady state sensitivies');
+        xlabel('Steady state sensitivities');
+        ylabel('finite differences');
+        box on;
+        
+        
+        subplot(1,2,2);
+        hold on;
+        for ip = 1:4
+            for ix = 1:size(sol.x,2)
+                ind = 3*(ip-1)+ix;
+                plot(ind, abs(sxss(ind)-sxss_fd(ind)), type{ip}, 'Color', c_x(ix,:));
+            end
+        end
+        title('Error of steady state sensitivies');
+        set(gca,'XTick',1:12);
+        set(gca,'XTickLabel',...
+            {'s^{x1}_{p3}','s^{x2}_{p3}','s^{x3}_{p3}',...
+            's^{x1}_{p1}','s^{x2}_{p1}','s^{x3}_{p1}',...
+            's^{x1}_{p2}','s^{x2}_{p2}','s^{x3}_{p2}',...
+            's^{x1}_{p4}','s^{x2}_{p3}','s^{x3}_{p4}'});
+        xlabel('Sensitivity index');
+        xlim([0.5,12.5])
+        ylabel('Error');
+        box on;
+        set(gca,'YScale','log');
+        set(gcf,'Position',[100 300 1200 500]);
+    end
+    
+    %%
+    % XDOT FOR DIFFERENT TIME POINTS
+    
+    t = [10,25,100,250,1000];
+    options.sensi = 0;
+    ssxdot = NaN(length(t), size(sol.x, 2));
+    for it = 1:length(t)
+        tt = [0,t(it)];
+        solss = simulate_model_steadystate(tt,log10(p),k,[],options);
+        ssxdot(it,:) = solss.diagnosis.xdot;
+    end
+
+    % Compute steady state wihtout integration before
+    sol = simulate_model_steadystate(inf,log10(p),k,[],options);
+    
+
+    % Test recapturing in the case of Newton solver failing
+    options.newton_maxsteps = 4;
+    options.maxsteps = 300;
+    sol_newton_fail = simulate_model_steadystate(inf,log10(p),k,[],options);
+    
+    %%
+    % PLOTTING
+    if(usejava('jvm'))
+        figure('Name', 'Example SteadyState');
+        subplot(1,3,[1 2]);
+        hold on;
+        for ix = 1:size(sol.x,2)
+            plot(t,abs(ssxdot(:,ix)),'o-','Color',c_x(ix,:));
+            plot([10 1000], abs(sol_newton_fail.diagnosis.xdot(ix))*[1, 1],'--','Color',c_x(ix,:));
+        end
+        plot(t,sqrt(sum(ssxdot.^2,2)), 'ko-');
+        plot([10 1000],sqrt(sum(sol_newton_fail.diagnosis.xdot.^2,2))*[1, 1], 'k--');
+        legend('dx_1/dt','dx_1/dt, ss','dx_2/dt','dx_2/dt, ss',...
+            'dx_3/dt','dx_3/dt, ss','||dx/dt||','||dx/dt||, ss',...
+            'Location','NorthEastOutside');
+        legend boxoff;
+        title('ODE right hand side over time');
+        xlabel('time t');
+        ylabel('xdot');
+        box on;
+        set(gca,'YScale','log');
+        set(gca,'XScale','log');
+        
+        subplot(1,3,3);
+        hold on;
+        bar(sol_newton_fail.diagnosis.newton_numsteps([1, 3]));
+        legend boxoff;
+        title('Number of Newton steps');
+        xlabel('Solver run');
+        ylabel('Newton steps');
+        xlim([0.5,2.5]);
+        ylim([-1 5]);
+        a = gca();
+        a.Children.BarWidth = 0.6;
+        box on;
+        
+        set(gcf,'Position',[100 300 1200 500]);
+    end
+    
+end
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/example_steadystate.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/example_steadystate.html
new file mode 100644
index 0000000000000000000000000000000000000000..1ac1b766c3d564bdd8d1b45c3dbae58bab0655b1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/example_steadystate.html
@@ -0,0 +1,391 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>example_steadystate</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="example_steadystate.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> example_steadystate
+</pre><p>COMPILATION</p><pre class="codeinput">    [exdir,~,~]=fileparts(which(<span class="string">'example_steadystate.m'</span>));
+    <span class="comment">% compile the model</span>
+    amiwrap(<span class="string">'model_steadystate'</span>,<span class="string">'model_steadystate_syms'</span>,exdir)
+</pre><pre class="codeoutput">Generating model struct ...
+Parsing model struct ...
+Generating C code ...
+headers | wrapfunctions | Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+</pre><p>SIMULATION</p><pre class="codeinput">    <span class="comment">% time vector</span>
+    t = linspace(0,300,20);
+    p = [1;0.5;0.4;2;0.1];
+    k = [0.1,0.4,0.7,1];
+
+    options = amioption(<span class="string">'sensi'</span>,0,<span class="keyword">...</span>
+        <span class="string">'maxsteps'</span>,1e4);
+    <span class="comment">% load mex into memory</span>
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+
+    tic
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+    disp([<span class="string">'Time elapsed with cvodes: '</span> num2str(toc) ])
+</pre><pre class="codeoutput">Time elapsed with cvodes: 0.0040652
+</pre><p>ODE15S</p><pre class="codeinput">    ode_system = @(t,x,p,k) [-2*p(1)*x(1)^2 - p(2)*x(1)*x(2) + 2*p(3)*x(2) + p(4)*x(3) + p(5);
+        + p(1)*x(1)^2 - p(2)*x(1)*x(2) - p(3)*x(2) + p(4)*x(3);
+        + p(2)*x(1)*x(2) - p(4)*x(3) - k(4)*x(3)];
+    options_ode15s = odeset(<span class="string">'RelTol'</span>,options.rtol,<span class="string">'AbsTol'</span>,options.atol,<span class="string">'MaxStep'</span>,options.maxsteps);
+
+    tic
+    [~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+    disp([<span class="string">'Time elapsed with ode15s: '</span> num2str(toc) ])
+</pre><pre class="codeoutput">Time elapsed with ode15s: 0.10806
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    c_x = get(gca,<span class="string">'ColorOrder'</span>);
+    subplot(2,2,1)
+    <span class="keyword">for</span> ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        hold <span class="string">on</span>
+        plot(t,X_ode15s(:,ix),<span class="string">'d'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+    <span class="keyword">end</span>
+    legend(<span class="string">'x1'</span>,<span class="string">'x1_{ode15s}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{ode15s}'</span>,<span class="string">'x3'</span>,<span class="string">'x3_{ode15s}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    xlabel(<span class="string">'time t'</span>)
+    ylabel(<span class="string">'x'</span>)
+    box <span class="string">on</span>
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode15s),<span class="string">'--'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'error x3'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+    legend <span class="string">boxoff</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+</pre><img vspace="5" hspace="5" src="../examples/example_steadystate/html/example_steadystate_01.png" alt=""> <p>FORWARD SENSITIVITY ANALYSIS</p><pre class="codeinput">    options.sensi = 1;
+    options.sens_ind = [3,1,2,4];
+
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+</pre><p>FINITE DIFFERENCES</p><pre class="codeinput">    eps = 1e-3;
+
+    xi = log10(p);
+    <span class="keyword">for</span> ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_steadystate(t,xip,k,[],options);
+        sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+        sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    <span class="keyword">end</span>
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    <span class="keyword">for</span> ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold <span class="string">on</span>
+        <span class="keyword">for</span> ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+            plot(t,sx_fd(:,ix,options.sens_ind(ip)),<span class="string">'d'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        <span class="keyword">end</span>
+        legend(<span class="string">'x1'</span>,<span class="string">'x1_{fd}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{fd}'</span>,<span class="string">'x3'</span>,<span class="string">'x3_{fd}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'state sensitivity for p'</span> num2str(options.sens_ind(ip))])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'x'</span>)
+        box <span class="string">on</span>
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,options.sens_ind(ip))),<span class="string">'--'</span>)
+        legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'error x3'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'error of state sensitivity for p'</span> num2str(options.sens_ind(ip))])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'error'</span>)
+        set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+        box <span class="string">on</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+</pre><img vspace="5" hspace="5" src="../examples/example_steadystate/html/example_steadystate_02.png" alt=""> <p>STEADY STATE SENSITIVITY</p><pre class="codeinput">    sssens = NaN(size(sol.sx));
+    <span class="keyword">for</span> it = 2:length(t)
+        tt = [0,t(it)];
+        options.sensi_meth = <span class="string">'ss'</span>;
+        solss = simulate_model_steadystate(tt,log10(p),k,[],options);
+        sssens(it,:,:) = solss.sx;
+        ssxdot(it,:) = solss.xdot;
+    <span class="keyword">end</span>
+</pre><p>PLOTTING</p><pre class="codeinput">    figure
+    <span class="keyword">for</span> ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold <span class="string">on</span>
+        <span class="keyword">for</span> ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),<span class="string">'.-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+            plot(t,sssens(:,ix,ip),<span class="string">'d-'</span>,<span class="string">'Color'</span>,c_x(ix,:))
+        <span class="keyword">end</span>
+        legend(<span class="string">'x1'</span>,<span class="string">'x1_{ss}'</span>,<span class="string">'x2'</span>,<span class="string">'x2_{ss}'</span>,<span class="string">'x3'</span>,<span class="string">'x3_{ss}'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'state steady sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'x'</span>)
+        box <span class="string">on</span>
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sssens(:,:,ip)),<span class="string">'--'</span>)
+        legend(<span class="string">'error x1'</span>,<span class="string">'error x2'</span>,<span class="string">'error x3'</span>,<span class="string">'Location'</span>,<span class="string">'NorthEastOutside'</span>)
+        legend <span class="string">boxoff</span>
+        title([<span class="string">'error of steady state sensitivity for p'</span> num2str(ip)])
+        xlabel(<span class="string">'time t'</span>)
+        ylabel(<span class="string">'error'</span>)
+        set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+        box <span class="string">on</span>
+    <span class="keyword">end</span>
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    figure
+    scatter(sqrt(sum((ssxdot./sol.x).^2,2)),sqrt(sum(sum((sol.sx-sssens).^2,2),3)))
+    hold <span class="string">on</span>
+    plot([1e-15,1e5],[1e-15,1e5],<span class="string">'k:'</span>)
+    set(gca,<span class="string">'YScale'</span>,<span class="string">'log'</span>)
+    set(gca,<span class="string">'XScale'</span>,<span class="string">'log'</span>)
+    box <span class="string">on</span>
+    axis <span class="string">square</span>
+    xlabel(<span class="string">'||dxdt/x||_2'</span>)
+    ylabel(<span class="string">'error steady state approximation'</span>)
+    set(gca,<span class="string">'FontSize'</span>,15)
+    set(gca,<span class="string">'LineWidth'</span>,1.5)
+    set(gcf,<span class="string">'Position'</span>,[100 300 1200 500])
+
+    drawnow
+</pre><img vspace="5" hspace="5" src="../examples/example_steadystate/html/example_steadystate_03.png" alt=""> <img vspace="5" hspace="5" src="../examples/example_steadystate/html/example_steadystate_04.png" alt=""> <pre class="codeinput"><span class="keyword">end</span>
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function example_steadystate
+    %%
+    % COMPILATION
+    
+    [exdir,~,~]=fileparts(which('example_steadystate.m'));
+    % compile the model
+    amiwrap('model_steadystate','model_steadystate_syms',exdir)
+    
+    %%
+    % SIMULATION
+    
+    % time vector
+    t = linspace(0,300,20);
+    p = [1;0.5;0.4;2;0.1];
+    k = [0.1,0.4,0.7,1];
+    
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+    % load mex into memory
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+    
+    tic
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+    disp(['Time elapsed with cvodes: ' num2str(toc) ])
+    
+    %%
+    % ODE15S
+    
+    ode_system = @(t,x,p,k) [-2*p(1)*x(1)^2 - p(2)*x(1)*x(2) + 2*p(3)*x(2) + p(4)*x(3) + p(5);
+        + p(1)*x(1)^2 - p(2)*x(1)*x(2) - p(3)*x(2) + p(4)*x(3);
+        + p(2)*x(1)*x(2) - p(4)*x(3) - k(4)*x(3)];
+    options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+    
+    tic
+    [~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+    disp(['Time elapsed with ode15s: ' num2str(toc) ])
+    
+    %%
+    % PLOTTING
+    
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+    end
+    legend('x1','x1_{ode15s}','x2','x2_{ode15s}','x3','x3_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode15s),'REPLACE_WITH_DASH_DASH')
+    set(gca,'YScale','log')
+    legend('error x1','error x2','error x3','Location','NorthEastOutside')
+    legend boxoff
+    set(gcf,'Position',[100 300 1200 500])
+    
+    %%
+    % FORWARD SENSITIVITY ANALYSIS
+    
+    options.sensi = 1;
+    options.sens_ind = [3,1,2,4];
+    
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+    
+    %%
+    % FINITE DIFFERENCES
+    
+    eps = 1e-3;
+    
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_steadystate(t,xip,k,[],options);
+        sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+        sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    end
+    
+    %%
+    % PLOTTING
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,options.sens_ind(ip)),'d','Color',c_x(ix,:))
+        end
+        legend('x1','x1_{fd}','x2','x2_{fd}','x3','x3_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('x')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,options.sens_ind(ip))),'REPLACE_WITH_DASH_DASH')
+        legend('error x1','error x2','error x3','Location','NorthEastOutside')
+        legend boxoff
+        title(['error of state sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    
+    %%
+    % STEADY STATE SENSITIVITY
+    
+    sssens = NaN(size(sol.sx));
+    for it = 2:length(t)
+        tt = [0,t(it)];
+        options.sensi_meth = 'ss';
+        solss = simulate_model_steadystate(tt,log10(p),k,[],options);
+        sssens(it,:,:) = solss.sx;
+        ssxdot(it,:) = solss.xdot;
+    end
+    
+    %%
+    % PLOTTING
+    
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sssens(:,ix,ip),'d-','Color',c_x(ix,:))
+        end
+        legend('x1','x1_{ss}','x2','x2_{ss}','x3','x3_{ss}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state steady sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+        
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sssens(:,:,ip)),'REPLACE_WITH_DASH_DASH')
+        legend('error x1','error x2','error x3','Location','NorthEastOutside')
+        legend boxoff
+        title(['error of steady state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+    
+    figure
+    scatter(sqrt(sum((ssxdot./sol.x).^2,2)),sqrt(sum(sum((sol.sx-sssens).^2,2),3)))
+    hold on
+    plot([1e-15,1e5],[1e-15,1e5],'k:')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    xlabel('||dxdt/x||_2')
+    ylabel('error steady state approximation')
+    set(gca,'FontSize',15)
+    set(gca,'LineWidth',1.5)
+    set(gcf,'Position',[100 300 1200 500])
+    
+    drawnow
+    
+end
+
+
+
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/example_steadystate.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/example_steadystate.tex
new file mode 100644
index 0000000000000000000000000000000000000000..aa1f66c48cd8c40a7732afeeeb913bed42aa0093
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/example_steadystate.tex
@@ -0,0 +1,230 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function example_steadystate
+\end{DoxyCode}
+\begin{par}
+COMPILATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    [exdir,~,~]=fileparts(which('example_steadystate.m'));
+    % compile the model
+    amiwrap('model_steadystate','model_steadystate_syms',exdir)
+\end{DoxyCode}
+
+         \begin{DoxyCode}Generating model struct ...
+Parsing model struct ...
+
+Generating C code ...
+headers | wrapfunctions | 
+Compiling mex file ...
+amici | Building with 'Xcode with Clang'.
+MEX completed successfully.
+Building with 'Xcode with Clang'.
+MEX completed successfully.
+\end{DoxyCode} 
+    \begin{par}
+SIMULATION
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    % time vector
+    t = linspace(0,300,20);
+    p = [1;0.5;0.4;2;0.1];
+    k = [0.1,0.4,0.7,1];
+
+    options = amioption('sensi',0,...
+        'maxsteps',1e4);
+    % load mex into memory
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+
+    tic
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+    disp(['Time elapsed with cvodes: ' num2str(toc) ])
+\end{DoxyCode}
+
+         \begin{DoxyCode}Time elapsed with cvodes: 0.004374
+\end{DoxyCode} 
+    \begin{par}
+ODE15S
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    ode_system = @(t,x,p,k) [-2*p(1)*x(1)^2 - p(2)*x(1)*x(2) + 2*p(3)*x(2) + p(4)*x(3) + p(5);
+        + p(1)*x(1)^2 - p(2)*x(1)*x(2) - p(3)*x(2) + p(4)*x(3);
+        + p(2)*x(1)*x(2) - p(4)*x(3) - k(4)*x(3)];
+    options_ode15s = odeset('RelTol',options.rtol,'AbsTol',options.atol,'MaxStep',options.maxsteps);
+
+    tic
+    [~, X_ode15s] = ode15s(@(t,x) ode_system(t,x,p,k),t,k(1:3),options_ode15s);
+    disp(['Time elapsed with ode15s: ' num2str(toc) ])
+\end{DoxyCode}
+
+         \begin{DoxyCode}Time elapsed with ode15s: 0.066508
+\end{DoxyCode} 
+    \begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    c_x = get(gca,'ColorOrder');
+    subplot(2,2,1)
+    for ix = 1:size(sol.x,2)
+        plot(t,sol.x(:,ix),'.-','Color',c_x(ix,:))
+        hold on
+        plot(t,X_ode15s(:,ix),'d','Color',c_x(ix,:))
+    end
+    legend('x1','x1_{ode15s}','x2','x2_{ode15s}','x3','x3_{ode15s}','Location','NorthEastOutside')
+    legend boxoff
+    xlabel('time t')
+    ylabel('x')
+    box on
+    subplot(2,2,2)
+    plot(t,abs(sol.x-X_ode15s),'--')
+    set(gca,'YScale','log')
+    legend('error x1','error x2','error x3','Location','NorthEastOutside')
+    legend boxoff
+    set(gcf,'Position',[100 300 1200 500])
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_steadystate/html/example_steadystate_01.png}
+\begin{par}
+FORWARD SENSITIVITY ANALYSIS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    options.sensi = 1;
+    options.sens_ind = [3,1,2,4];
+
+    sol = simulate_model_steadystate(t,log10(p),k,[],options);
+\end{DoxyCode}
+\begin{par}
+FINITE DIFFERENCES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    eps = 1e-3;
+
+    xi = log10(p);
+    for ip = 1:4;
+        xip = xi;
+        xip(ip) = xip(ip) + eps;
+        solp = simulate_model_steadystate(t,xip,k,[],options);
+        sx_fd(:,:,ip) = (solp.x - sol.x)/eps;
+        sy_fd(:,:,ip) = (solp.y - sol.y)/eps;
+    end
+\end{DoxyCode}
+\begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sx_fd(:,ix,options.sens_ind(ip)),'d','Color',c_x(ix,:))
+        end
+        legend('x1','x1_{fd}','x2','x2_{fd}','x3','x3_{fd}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('x')
+        box on
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sx_fd(:,:,options.sens_ind(ip))),'--')
+        legend('error x1','error x2','error x3','Location','NorthEastOutside')
+        legend boxoff
+        title(['error of state sensitivity for p' num2str(options.sens_ind(ip))])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_steadystate/html/example_steadystate_02.png}
+\begin{par}
+STEADY STATE SENSITIVITY
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    sssens = NaN(size(sol.sx));
+    for it = 2:length(t)
+        tt = [0,t(it)];
+        options.sensi_meth = 'ss';
+        solss = simulate_model_steadystate(tt,log10(p),k,[],options);
+        sssens(it,:,:) = solss.sx;
+        ssxdot(it,:) = solss.xdot;
+    end
+\end{DoxyCode}
+\begin{par}
+PLOTTING
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+    figure
+    for ip = 1:4
+        subplot(4,2,ip*2-1)
+        hold on
+        for ix = 1:size(sol.x,2)
+            plot(t,sol.sx(:,ix,ip),'.-','Color',c_x(ix,:))
+            plot(t,sssens(:,ix,ip),'d-','Color',c_x(ix,:))
+        end
+        legend('x1','x1_{ss}','x2','x2_{ss}','x3','x3_{ss}','Location','NorthEastOutside')
+        legend boxoff
+        title(['state steady sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('x')
+        box on
+
+        subplot(4,2,ip*2)
+        plot(t,abs(sol.sx(:,:,ip)-sssens(:,:,ip)),'--')
+        legend('error x1','error x2','error x3','Location','NorthEastOutside')
+        legend boxoff
+        title(['error of steady state sensitivity for p' num2str(ip)])
+        xlabel('time t')
+        ylabel('error')
+        set(gca,'YScale','log')
+        box on
+    end
+    set(gcf,'Position',[100 300 1200 500])
+
+    figure
+    scatter(sqrt(sum((ssxdot./sol.x).^2,2)),sqrt(sum(sum((sol.sx-sssens).^2,2),3)))
+    hold on
+    plot([1e-15,1e5],[1e-15,1e5],'k:')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    box on
+    axis square
+    xlabel('||dxdt/x||_2')
+    ylabel('error steady state approximation')
+    set(gca,'FontSize',15)
+    set(gca,'LineWidth',1.5)
+    set(gcf,'Position',[100 300 1200 500])
+
+    drawnow
+\end{DoxyCode}
+
+\includegraphics[width=\textwidth]{../../examples/example_steadystate/html/example_steadystate_03.png}
+
+\includegraphics[width=\textwidth]{../../examples/example_steadystate/html/example_steadystate_04.png}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/model_steadystate_syms.html b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/model_steadystate_syms.html
new file mode 100644
index 0000000000000000000000000000000000000000..3ce3a449d3ea3b9beb5c5049bc9d8cd39ebc665a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/model_steadystate_syms.html
@@ -0,0 +1,180 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>model_steadystate_syms</title><meta name="generator" content="MATLAB 9.0"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2016-05-04"><meta name="DC.source" content="model_steadystate_syms.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><pre class="codeinput"><span class="keyword">function</span> [model] = model_steadystate_syms()
+</pre><p>STATES</p><pre class="codeinput"><span class="comment">% create state syms</span>
+syms <span class="string">x1</span> <span class="string">x2</span> <span class="string">x3</span>
+
+<span class="comment">% create state vector</span>
+model.sym.x = [
+x1 x2 x3
+];
+</pre><p>PARAMETERS ( for these sensitivities will be computed )</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">p1</span> <span class="string">p2</span> <span class="string">p3</span> <span class="string">p4</span> <span class="string">p5</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.p = [p1,p2,p3,p4,p5];
+
+<span class="comment">% set the parametrisation of the problem options are 'log', 'log10' and</span>
+<span class="comment">% 'lin' (default).</span>
+model.param = <span class="string">'log10'</span>;
+</pre><p>CONSTANTS ( for these no sensitivities will be computed ) this part is optional and can be ommited</p><pre class="codeinput"><span class="comment">% create parameter syms</span>
+syms <span class="string">k1</span> <span class="string">k2</span> <span class="string">k3</span> <span class="string">k4</span>
+
+<span class="comment">% create parameter vector</span>
+model.sym.k = [k1 k2 k3 k4];
+</pre><p>SYSTEM EQUATIONS</p><pre class="codeinput"><span class="comment">% create symbolic variable for time</span>
+syms <span class="string">t</span>
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+<span class="comment">% piecewise defined function</span>
+model.sym.xdot(1) = -2*p1*x1^2 - p2*x1*x2 + 2*p3*x2 + p4*x3 + p5;
+<span class="comment">% inhomogeneous</span>
+model.sym.xdot(2) = +p1*x1^2 - p2*x1*x2 - p3*x2 + p4*x3;
+model.sym.xdot(3) = p2*x1*x2 - p4*x3 - k4*x3;
+</pre><p>INITIAL CONDITIONS</p><pre class="codeinput">model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+</pre><p>OBSERVALES</p><pre class="codeinput">model.sym.y = model.sym.x;
+</pre><pre class="codeinput"><span class="keyword">end</span>
+</pre><pre class="codeoutput">ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+</pre><p class="footer"><br><a href="http://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2016a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+function [model] = model_steadystate_syms()
+
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4 p5
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4,p5];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+
+%%
+% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+syms k1 k2 k3 k4
+
+% create parameter vector 
+model.sym.k = [k1 k2 k3 k4];
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -2*p1*x1^2 - p2*x1*x2 + 2*p3*x2 + p4*x3 + p5;
+% inhomogeneous
+model.sym.xdot(2) = +p1*x1^2 - p2*x1*x2 - p3*x2 + p4*x3;
+model.sym.xdot(3) = p2*x1*x2 - p4*x3 - k4*x3;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+
+%%
+% OBSERVALES
+
+model.sym.y = model.sym.x;
+end
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/model_steadystate_syms.tex b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/model_steadystate_syms.tex
new file mode 100644
index 0000000000000000000000000000000000000000..d856dfb66582da818abbed443ff92336a8b2ecff
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/html/model_steadystate_syms.tex
@@ -0,0 +1,98 @@
+
+% This LaTeX was auto-generated from MATLAB code.
+% To make changes, update the MATLAB code and republish this document.
+
+
+
+
+
+
+
+
+
+
+
+    
+    \begin{DoxyCode}
+function [model] = model_steadystate_syms()
+\end{DoxyCode}
+\begin{par}
+STATES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+\end{DoxyCode}
+\begin{par}
+PARAMETERS ( for these sensitivities will be computed )
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms p1 p2 p3 p4 p5
+
+% create parameter vector
+model.sym.p = [p1,p2,p3,p4,p5];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10';
+\end{DoxyCode}
+\begin{par}
+CONSTANTS ( for these no sensitivities will be computed ) this part is optional and can be ommited
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create parameter syms
+syms k1 k2 k3 k4
+
+% create parameter vector
+model.sym.k = [k1 k2 k3 k4];
+\end{DoxyCode}
+\begin{par}
+SYSTEM EQUATIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -2*p1*x1^2 - p2*x1*x2 + 2*p3*x2 + p4*x3 + p5;
+% inhomogeneous
+model.sym.xdot(2) = +p1*x1^2 - p2*x1*x2 - p3*x2 + p4*x3;
+model.sym.xdot(3) = p2*x1*x2 - p4*x3 - k4*x3;
+\end{DoxyCode}
+\begin{par}
+INITIAL CONDITIONS
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+\end{DoxyCode}
+\begin{par}
+OBSERVALES
+\end{par} \vspace{1em}
+\begin{DoxyCode}
+model.sym.y = model.sym.x;
+\end{DoxyCode}
+\begin{DoxyCode}
+end
+\end{DoxyCode}
+
+         \begin{DoxyCode}ans = 
+      sym: [1x1 struct]
+    param: 'log10'
+\end{DoxyCode} 
+    
+
+
+
+    
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/model_steadystate_syms.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/model_steadystate_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..713cd1ad6a1d184f163e380b6f570b0e5e74d1a7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/examples/example_steadystate/model_steadystate_syms.m
@@ -0,0 +1,66 @@
+function [model] = model_steadystate_syms()
+
+
+%%
+% STATES
+
+% create state syms
+syms x1 x2 x3
+
+% create state vector
+model.sym.x = [
+x1 x2 x3
+];
+
+%%
+% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms p1 p2 p3 p4 p5
+
+% create parameter vector 
+model.sym.p = [p1,p2,p3,p4,p5];
+
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+
+
+%%
+% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+syms k1 k2 k3 k4
+
+% create parameter vector 
+model.sym.k = [k1 k2 k3 k4];
+
+%%
+% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+% piecewise defined function
+model.sym.xdot(1) = -2*p1*x1^2 - p2*x1*x2 + 2*p3*x2 + p4*x3 + p5;
+% inhomogeneous
+model.sym.xdot(2) = +p1*x1^2 - p2*x1*x2 - p3*x2 + p4*x3;
+model.sym.xdot(3) = p2*x1*x2 - p4*x3 - k4*x3;
+
+%%
+% INITIAL CONDITIONS
+
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = k1;
+model.sym.x0(2) = k2;
+model.sym.x0(3) = k3;
+
+%%
+% OBSERVALES
+
+model.sym.y = model.sym.x;
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/installAMICI.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/installAMICI.m
new file mode 100644
index 0000000000000000000000000000000000000000..9a6ccbc1c4a60fe87d7c2bde0ce7698a21cd3115
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/installAMICI.m
@@ -0,0 +1,6 @@
+amipath = fileparts(mfilename('fullpath'));
+addpath(amipath)
+addpath(fullfile(amipath,'auxiliary'))
+addpath(fullfile(amipath,'auxiliary','CalcMD5'))
+addpath(fullfile(amipath,'symbolic'))
+addpath(fullfile(amipath,'SBMLimporter'))
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/MatlabDocMaker.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/MatlabDocMaker.m
new file mode 100644
index 0000000000000000000000000000000000000000..cdbcfd7dd98f217ba3d780f34c5aed2919652d6b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/MatlabDocMaker.m
@@ -0,0 +1,682 @@
+classdef MatlabDocMaker
+% MatlabDocMaker: Automated documentation creation using doxygen and mtoc++ from within MatLab
+%
+% Currently documentation creation for unix and windows environment is
+% supported.
+%
+% Prerequisites:
+% The following tools must be installed and present on the PATH or
+% reside inside the folder returned by
+% MatlabDocMaker.getConfigDirectory.
+% - \c mtocpp, \c mtocpp_post (the main tool)
+% - \c doxygen (mtoc++ is a filter for doxygen)
+%
+% Strongly recommended:
+% - \c latex Doxygen supports built-in latex formulas and
+% MatlabDocMaker/mtoc++ allows for easy extra latex inclusions and
+% notation in code
+% - \c dot Doxygen creates really nice inheritance graphs and
+% collaboration diagrams with dot.
+%
+% @author Daniel Wirtz @date 2011-10-13
+%
+% @change{1,5,dw,2013-12-03} Fixed default value selection for properties,
+% now not having set a description or logo does not cause an error to be
+% thrown.
+% 
+% @change{1,5,dw,2013-02-21} Fixed the callback for suggested direct documentation creation
+% after MatlabDocMaker.setup (Thanks to Aurelien Queffurust)
+%
+% @change{1,5,dw,2013-02-12} Also added the escaping for the Logo file. Thanks to Chris Olien
+% for the hint.
+%
+% @change{1,5,dw,2013-01-07} Included some backslash escaping for paths on windows platforms.
+% Thanks to MathWorks Pilot Engineer '''Arvind Jayaraman''' for providing the feedback and code!
+%
+% @change{1,4,dw,2012-10-18} Removed \c m4 dependency and included constant properties for
+% configuration file names.
+%
+% @new{1,4,dw,2012-10-16}
+% - Added two more configuration variables "ProjectDescription" and "ProjectLogo" for easier
+% configuration of the MatlabDocMaker in many cases. Thanks to Wolfgang
+% Mennerich <http://www.mathworks.com/matlabcentral/fileexchange/authors/272859> for the suggestion.
+% - Restructured the configuration, now only the project name function has to be implemented
+% (the preferences tag depends on it, there might be more than one project within the same
+% Matlab installation whos documentation is created using this tool). The rest can be provided
+% either at setup time or later via suitable setters for the version, description and logo.
+% - Automatically setting HaveDot in the doxygen config whenever its found on the environment
+% path.
+% - Added basic support for LaTeX documentation creation. Using the parameter 'latex'=true for
+% the create method creates the LaTeX version of the documentation in a folder "latex" in the
+% OutputDirectory (default behaviour)
+%
+% @change{1,4,dw,2012-09-27} Added automatic dot Graphviz tool detection on
+% call to create.
+%
+% @change{1,3,dw,2012-02-16}
+% - Now also collecting error messages from mtocpp_post and adding them to
+% the warnings.log file.
+% - Added the directive "LD_LIBRARY_PATH= " for unix systems, as MatLab
+% sets it inside its executing environment. This can lead to errors if
+% doxygen and/or mtoc++ have been built using never GLIBC (libstd) versions
+% than the one shipped with MatLab.
+%
+% @change{1,3,dw,2012-01-16}
+% - Properly using the correct file separators everywhere now
+% - Hyperlinked the log file so it can be opened directly
+%
+% @change{1,3,dw,2012-01-14} Not displaying the "generated warnings"-text if there have not
+% been any during documentation creation.
+%
+% @change{1,2,dw,2011-11-27}
+% - Included documentation creation for the Windows platform and
+% combined the old methods into one (small effective differences)
+% - No longer storing the doxygen binary file in the prefs as a lot of
+% tools must be present on the path anyways. The new paradigm is to
+% expect all required 3rd-party programmes to be available on PATH. As
+% backup the configuration files directory is
+% added to the Matlab PATH environment \b nonpermanently and any
+% executables found there will thus also be usable.
+% - Included checks for \c dot and \c latex at the setup stage to
+% recommend installation of those tools if not present (the default
+% doxygen settings in Doxyfile.m4 are to use both)
+%
+% @change{1,2,dw,2011-11-08} Improved the createUnix method by displaying the warnings and writing the output to
+% a log file afterwards. Not using cprintf anymore as this is 3rd party software.
+%
+% @change{1,2,dw,2011-11-07} Fixed a recursion bug caused by copy and paste. Now the preferences
+% are stored on an per-application basis.
+%
+% @change{1,2,dw,2011-11-04} Changed the name to MatlabDocMaker in
+% order to export it into the mtoc++ distribution later.
+%
+% @new{1,2,dw,2011-10-13} Added this class and moved documentation related
+% stuff here from the KerMor class.
+%
+% This class is part of the mtoc++ tool
+% - \c Homepage http://www.morepas.org/software/mtocpp/
+% - \c License http://www.morepas.org/software/mtocpp/docs/licensing.html
+%
+% Copyright (c) 2012, Daniel Wirtz
+% All rights reserved.
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted only in compliance with the BSD license, see
+% http://www.opensource.org/licenses/bsd-license.php
+
+    properties(Constant)
+        % File name for the doxygen configuration file processed by the MatlabDocMaker.
+        %
+        % Assumed to reside in the MatlabDocMaker.getConfigDirectory
+        %
+        % @type char @default 'Doxyfile.template'
+        DOXYFILE_TEMPLATE = 'Doxyfile.template';
+        
+        % File name for the latex extras style file processed by the MatlabDocMaker.
+        %
+        % Assumed to reside in the MatlabDocMaker.getConfigDirectory.
+        % If not found, no latex extras are used.
+        %
+        % @type char @default 'latexextras.template'
+        LATEXEXTRAS_TEMPLATE = 'latexextras.template';
+        
+        % File name the mtoc++ configuration file.
+        %
+        % Assumed to reside in the MatlabDocMaker.getConfigDirectory.
+        % If not found, no special configuration is used.
+        %
+        % @type char @default 'mtocpp.conf'
+        MTOCPP_CONFIGFILE = 'mtocpp.conf';
+    end
+
+    methods(Static)
+        function name = getProjectName
+            % Returns the project name.
+            %
+            % @note Changing the return value of this method will require
+            % another execution of MatlabDocMaker.setup as the preferences
+            % storage key also depends on it.
+            %
+            % Return values:
+            % name: The project name @type char
+            
+            %error('Please replace this by returning your project name as string.');
+            % Example:
+            name = 'AMICI';
+        end
+    end
+    
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    %% End of user defined part.
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    
+    methods(Static, Sealed)
+        function dir = getOutputDirectory
+            % Returns the directory where the applications source files
+            % reside
+            %
+            % Return values:
+            % dir: The output directory @type char
+            dir = MatlabDocMaker.getPref('outdir');
+        end
+        
+        function dir = getSourceDirectory
+            % Returns the directory where the applications source files
+            % reside
+            %
+            % Return values:
+            % dir: The project source directory @type char
+            dir = MatlabDocMaker.getPref('srcdir');
+        end
+        
+        function dir = getConfigDirectory
+            % Returns the directory where the applications documentation
+            % configuration files reside
+            %
+            % This folder must contain at least the files "mtoc.conf" and
+            % "Doxyfile.template"
+            %
+            % Return values:
+            % dir: The documentation configuration directory @type char
+            dir = MatlabDocMaker.getPref('confdir');
+        end
+        
+        function desc = getProjectDescription
+            % Returns the short project description.
+            %
+            % Return values:
+            % desc: The short project description @type char @default []
+            %
+            % See also: setProjectDescription
+            desc =  MatlabDocMaker.getPref('proj_desc', '');
+        end
+        
+        function setProjectDescription(value)
+            % Sets the project description.
+            %
+            % Parameters:
+            % value: The description @type char
+            %
+            % See also: getProjectDescription
+            if ~ischar(value)
+                error('The description must be a char array.');
+            end
+            MatlabDocMaker.setPref('proj_desc', value);
+        end
+        
+        function version = getProjectVersion
+            % Returns the current version of the project.
+            %
+            % @note The built-in @@new and @@change tags from the
+            % Doxyfile.template support two-level versioning a la X.X.
+            %
+            % Return values:
+            % version: The project version @type char @default []
+            %
+            % See also: setProjectVersion
+            version = MatlabDocMaker.getPref('proj_ver', '0');
+        end
+        
+        function setProjectVersion(value)
+            % Sets the project version.
+            %
+            % Parameters:
+            % value: The version string @type char
+            %
+            % See also: getProjectVersion
+            if ~ischar(value)
+                error('The project version must be a char array.');
+            end
+            MatlabDocMaker.setPref('proj_ver', value);
+        end
+        
+        function fullPath = getProjectLogo
+            % Returns the logo image file for the project. Either an absolute path or a plain
+            % filename. For the latter case the image file is assumed to reside inside the
+            % directory returned by MatlabDocMaker.getConfigDirectory.
+            %
+            % Return values:
+            % logoFile: The projects logo image file. @type char @default []
+            %
+            % See also: setProjectLogo
+            logoFile = MatlabDocMaker.getPref('proj_logo','');
+            fullPath = '';
+            if ~isempty(logoFile)
+                if isempty(fileparts(logoFile))
+                    fullPath = fullfile(MatlabDocMaker.getConfigDirectory,logoFile);
+                else
+                    fullPath = logoFile;
+                end
+                if exist(fullPath,'file') ~= 2
+                    warning('MatlabDocMaker:getLogo',['Could not find logo file "%s".\n'...
+                        'No logo will be shown in documentation output.'],logoFile);
+                end
+            end
+        end
+        
+        function setProjectLogo(value)
+            % Sets the project logo. Set to '' to unset.
+            %
+            % See the doxygen documentation for valid logo file types (wont be checked here).
+            %
+            % Parameters:
+            % value: The logo file to use. Must be either an absolute path or a plain filename,
+            % in which case the image is assumed to reside inside the
+            % MatlabDocMaker.getConfigDirectory directory. @type char
+            %
+            % See also: getProjectLogo
+            if nargin < 1
+                [f, p] = uigetfile('*.*', 'Select project logo', pwd);
+                if f ~= 0
+                    value = fullfile(p,f);
+                else
+                    fprintf(2,'No file selected. Aborting.\n');
+                    return;
+                end
+            end
+            if ~ischar(value)
+                error('The project logo file must be a char array.');
+            end
+            if ~isempty(value)
+                fullPath = value;
+                if isempty(fileparts(value))
+                    fullPath = fullfile(MatlabDocMaker.getConfigDirectory,value);
+                end
+                if ~exist(fullPath,'file')
+                    error('Invalid logo file: Could not find "%s"',fullPath);
+                end
+            end
+            MatlabDocMaker.setPref('proj_logo', value);
+        end
+    end
+        
+    methods(Static)
+        
+        function open
+            % Opens the generated documentation.
+            %
+            % Depending on the system's type the generated index.html is opened in the system's
+            % default browser.
+            index = fullfile(MatlabDocMaker.getOutputDirectory, 'index.html');
+            if ispc
+                winopen(index);
+            else
+                [s, m] = system(sprintf('xdg-open "%s"',index));
+                if s ~= 0
+                    fprintf(2,'Could not find/execute xdg-open: %s',m);
+                    web(index);
+                end
+            end
+        end
+        
+        function create(varargin)
+            % Creates the Doxygen documentation
+            %
+            % Parameters:
+            % varargin: Optional parameters for creation.
+            % open: Set to true if the documentation should be opened after
+            % successful compilation @type logical @default false
+            % latex: Set to true if `\text{\LaTeX}` output should be generated, too. @type logical
+            % @default false
+           
+            %% Preparations
+            ip = inputParser;
+            ip.addParameter('open',false,@islogical);
+            ip.addParameter('latex',false,@islogical);
+            ip.parse(varargin{:});
+            genlatex = ip.Results.latex;
+            
+            % Check for correct setup
+            cdir = MatlabDocMaker.getConfigDirectory;
+            srcdir = MatlabDocMaker.getSourceDirectory;
+            outdir = MatlabDocMaker.getOutputDirectory;
+            % Check if doxygen config file template exists
+            doxyfile_in = fullfile(cdir,MatlabDocMaker.DOXYFILE_TEMPLATE);
+            if exist(doxyfile_in,'file') ~= 2
+                error('No doxygen configuration file template found at "%s"',doxyfile_in);
+            end
+            
+            lstr = '';
+            if genlatex
+                lstr = '(+Latex)';
+            end
+            fprintf(['Starting creation of doxygen/mtoc++ powered HTML%s documentation for "%s" (%s)\n'...
+                'Sources: %s\nOutput to: <a href="matlab:MatlabDocMaker.open">%s</a>\nCreating config files...'],lstr,...
+                MatlabDocMaker.getProjectName,MatlabDocMaker.getProjectVersion,...
+                srcdir,outdir);
+            
+            % Operation-system dependent strings
+            strs = struct;
+            if isunix
+                strs.null = '/dev/null';
+                strs.silencer = '';
+            elseif ispc
+                strs.null = 'NUL';
+                strs.silencer = '@'; % argh that took a while to remember..
+            else
+                error('Current platform not supported.');
+            end
+            
+            % Save current working dir and change into the KerMor home
+            % directory; only from there all classes and packages are
+            % detected properly.
+            curdir = pwd;
+            cd(srcdir);
+            
+            % Append the configuration file directory to the current PATH
+            pathadd = [pathsep cdir];
+            setenv('PATH',[getenv('PATH') pathadd]);
+            
+            mtoc_conf = fullfile(cdir,MatlabDocMaker.MTOCPP_CONFIGFILE);
+            filter = sprintf('%smtocpp',strs.silencer);
+            if exist(mtoc_conf,'file')
+                if isunix
+                    strs.filter = 'mtocpp_filter.sh';
+                    strs.farg = '$1';
+                elseif ispc
+                    strs.filter = 'mtocpp_filter.bat';
+                    strs.farg = '%1';
+                else
+                    error('Current platform not supported.');
+                end
+                %% Creation part
+                cdir = MatlabDocMaker.getConfigDirectory;
+                % Create "configured" filter script for inclusion in doxygen 
+                filter = fullfile(cdir,strs.filter);
+                f = fopen(filter,'w');
+                fprintf(f,'%smtocpp %s %s',strs.silencer,strs.farg,mtoc_conf);
+                fclose(f);
+                if isunix
+                    unix(['chmod +x ' filter]);
+                end
+            end
+            
+            %% Prepare placeholders in the Doxyfile template
+            m = {'_OutputDir_' strrep(outdir,'\','\\'); ...
+                 '_SourceDir_' strrep(MatlabDocMaker.getSourceDirectory,'\','\\');...
+                 '_ConfDir_' strrep(cdir,'\','\\');...
+                 '_ProjectName_' MatlabDocMaker.getProjectName; ...
+                 '_ProjectDescription_' MatlabDocMaker.getProjectDescription; ...
+                 '_ProjectLogo_' strrep(MatlabDocMaker.getProjectLogo,'\','\\'); ...
+                 '_ProjectVersion_' MatlabDocMaker.getProjectVersion; ...
+                 '_MTOCFILTER_' strrep(filter,'\','\\'); ...
+                 };
+             
+            % Check for latex extra stuff
+            texin = fullfile(cdir,MatlabDocMaker.LATEXEXTRAS_TEMPLATE);
+            latexextras = '';
+            if exist(texin,'file') == 2  
+                latexstr = strrep(fileread(texin),'_ConfDir_',strrep(cdir,'\','/'));
+                latexextras = fullfile(cdir,'latexextras.sty');
+                fid = fopen(latexextras,'w+'); fprintf(fid,'%s',latexstr); fclose(fid);
+            end
+            % Always use "/" for latex usepackage commands, so replace "\" (effectively windows
+            % only) by "/", and dont pass the extension ".sty" as latex automatically adds it.
+            m(end+1,:) = {'_LatexExtras_' strrep(latexextras(1:end-4),'\','/')};
+            L = 'NO';
+            if genlatex
+                L = 'YES';
+            end
+            m(end+1,:) = {'_GenLatex_',L};
+            
+            % Check how to set the HAVE_DOT flag
+            [s, ~] = system('dot -V');
+            if s == 0
+                HD = 'YES';
+            else
+                HD = 'NO';
+                fprintf('no "dot" found...');
+            end
+            m(end+1,:) = {'_HaveDot_',HD};
+            
+            % Read, replace & write doxygen config file
+            doxyfile = fullfile(cdir,'Doxyfile');
+            doxyconfstr = regexprep(fileread(doxyfile_in),m(:,1),m(:,2));
+            fid = fopen(doxyfile,'w'); fprintf(fid,'%s',doxyconfstr); fclose(fid);
+            
+            % Fix for unix systems where the MatLab installation uses older
+            % GLIBSTD libraries than doxygen/mtoc++
+            ldpath = '';
+            if isunix
+                ldpath = 'LD_LIBRARY_PATH= ';
+            end
+            % Call doxygen
+            fprintf('running doxygen with mtoc++ filter...');
+            [~,warn] = system(sprintf('%sdoxygen "%s" 1>%s',ldpath, doxyfile, strs.null));
+            
+            % Postprocess
+            fprintf('running mtoc++ postprocessor...');
+            [~,postwarn] = system(sprintf('%smtocpp_post "%s" 1>%s',ldpath,...
+                outdir, strs.null));
+            if ~isempty(postwarn)
+                warn = [warn sprintf('mtoc++ postprocessor messages:\n') postwarn];
+            end
+            
+            % Create latex document if desired
+            if genlatex
+                oldd = pwd;
+                latexerr = false;
+                latexdir = fullfile(outdir,'latex');
+                if exist(latexdir,'dir') == 7
+                    if exist(fullfile(latexdir,'refman.tex'),'file') == 2
+                        fprintf('compiling LaTeX output...');
+                        cd(latexdir);                        
+                        [s, latexmsg] = system('make');
+                        if s ~= 0
+                            warn = [warn sprintf('LaTeX compiler output:\n') latexmsg];
+                            latexerr = true;
+                        end
+                    else
+                        fprintf('cannot compile LaTeX output: no refman.tex found...');
+                    end
+                end
+                cd(oldd);
+            end
+            
+            % Tidy up
+            fprintf('cleaning up...');
+            if isfield(strs,'filter')
+                delete(filter);
+            end
+            if ~isempty(latexextras)
+                delete(latexextras);
+            end
+            delete(doxyfile);
+            
+            %% Post generation phase 
+            cd(curdir);
+            % Restore PATH to previous value
+            curpath = getenv('PATH');
+            setenv('PATH',curpath(1:end-length(pathadd)));
+            fprintf('done!\n');
+            
+            % Process warnings
+            showchars = 800;
+            warn = strtrim(warn);
+            if ~isempty(warn)
+                dispwarn = [warn(1:min(showchars,length(warn))) ' [...]'];
+                fprintf('First %d characters of warnings generated during documentation creation:\n%s\n',showchars,dispwarn);
+                % Write to log file
+                log = fullfile(outdir,'warnings.log');
+                f = fopen(log,'w'); fprintf(f,'%s',warn); fclose(f);
+                fprintf(2,'MatlabDocMaker finished with warnings!\n');
+                fprintf('Complete log file at <a href="matlab:edit(''%s'')">%s</a>.\n',log,log);
+                % Check for latex log file
+                log = fullfile(outdir,'_formulas.log');
+                if exist(log,'file')
+                    fprintf('Found LaTeX formula log file. Check <a href="matlab:edit(''%s'')">%s</a> for any errors.\n',log,log);
+                end
+                % Check for errors on latex generation
+                if genlatex && latexerr
+                    log = fullfile(latexdir,'refman.log');
+                    fprintf('There have been errors with LaTeX compilation. See log file at <a href="matlab:edit(''%s'')">%s</a>.\n',log,log);
+                end
+            else
+                fprintf('MatlabDocMaker finished with no warnings!\n');
+            end
+            
+            % Open index.html if wanted
+            if ip.Results.open
+                MatlabDocMaker.open;
+            end
+        end
+        
+        function setup
+            % Runs the setup script for MatlabDocMaker and collects all
+            % necessary paths in order for the documentation creation to
+            % work properly.
+            
+            %% Validity checks
+            fprintf('<<<< Welcome to the MatlabDocMaker setup for your project "%s"! >>>>\n',MatlabDocMaker.getProjectName);
+            
+            %% Setup directories
+            % Source directory
+            srcdir = MatlabDocMaker.getPref('srcdir','');
+            word = 'keep';
+            if isempty(srcdir) || exist(srcdir,'dir') ~= 7
+                srcdir = pwd;
+                word = 'set';
+            end
+            str = sprintf('Do you want to %s %s as your projects source directory?\n(Y)es/(N)o?: ',word,strrep(srcdir,'\','\\'));
+            ds = lower(input(str,'s'));
+            if isequal(ds,'n')
+                d = uigetdir(srcdir,'Please select the projects source directory');
+                if d == 0
+                    error('No source directory specified. Aborting setup.');
+                end
+                srcdir = d;
+            end
+            MatlabDocMaker.setPref('srcdir',srcdir);
+            
+            % Config directory
+            confdir = MatlabDocMaker.getPref('confdir','');
+            word = 'keep';
+            if isempty(confdir) || exist(confdir,'dir') ~= 7
+                confdir = fullfile(srcdir,'documentation');
+                word = 'set';
+            end
+            str = sprintf('Do you want to %s %s as your documentation configuration files directory?\n(Y)es/(N)o?: ',word,strrep(confdir,'\','\\'));
+            ds = lower(input(str,'s'));
+            if isequal(ds,'n')
+                d = uigetdir(confdir,'Please select the documentation configuration directory');
+                if d == 0
+                    error('No documentation configuration directory specified. Aborting setup.');
+                end
+                confdir = d;
+            end
+            MatlabDocMaker.setPref('confdir',confdir);
+            
+            % Output directory
+            outdir = MatlabDocMaker.getPref('outdir','');
+            word = 'keep';
+            if isempty(outdir) || exist(outdir,'dir') ~= 7
+                outdir = confdir;
+                word = 'set';
+            end
+            str = sprintf('Do you want to %s %s as your documentation output directory?\n(Y)es/(N)o?: ',word,strrep(outdir,'\','\\'));
+            ds = lower(input(str,'s'));
+            if isequal(ds,'n')
+                d = uigetdir(outdir,'Please select the documentation output directory');
+                if d == 0
+                    error('No documentation output directory specified. Aborting setup.');
+                end
+                outdir = d;
+            end
+            MatlabDocMaker.setPref('outdir',outdir);
+            
+            %% Additional Project properties
+            if isequal(lower(input(['Do you want to specify further project details?\n'...
+                    'You can set them later using provided set methods. (Y)es/(N)o?: '],'s')),'y')
+                MatlabDocMaker.setPref('proj_ver',input('Please specify the project version, e.g. "0.1": ','s'));
+                MatlabDocMaker.setPref('proj_desc',input('Please specify a short project description: ','s'));
+                MatlabDocMaker.setProjectLogo;
+            end
+            
+            %% Check for necessary and recommended tools
+            hasall = true;
+            setenv('PATH',[getenv('PATH') pathsep confdir]);
+            fprintf('[Required] Checking for doxygen... ');
+            [st, vers] = system('doxygen --version');
+            if st == 0
+                fprintf(' found %s\n',vers(1:end-1));
+            else
+                fprintf(2,' not found!\n');
+                hasall = false;                
+            end
+            fprintf('[Required] Checking for mtoc++... ');
+            ldpath = '';
+            if isunix
+                ldpath = 'LD_LIBRARY_PATH= ';
+            end
+            [st, vers] = system(sprintf('%smtocpp --version',ldpath));
+            if st == 0
+                fprintf(' found %s\n',vers(1:end-1));
+            else
+                fprintf(2,' not found!\n');
+                hasall = false;
+            end
+            fprintf('[Recommended] Checking for dot... ');
+            [st, vers] = system('dot -V');
+            if st == 0
+                fprintf(' found %s\n',vers(1:end-1));
+            else
+                fprintf(2,'dot Graphviz tool not found!\nInstall dot for nicer class diagrams.\n');
+            end
+            fprintf('[Recommended] Checking for latex... ');
+            [st, vers] = system('latex --version');
+            if st == 0
+                fprintf(' found %s\n',vers(1:strfind(vers,sprintf('\n'))-1));
+            else
+                fprintf(2,'latex not found!\nA LaTeX installation available on the system path is strongly recommended with mtoc++.\n');
+            end
+            % Ghostscript
+            fprintf('[Recommended] Checking for ghostscript... ');
+            if ispc
+                [st, vers] = system('gswin32c --version');
+                if st ~= 0
+                    [st, vers] = system('gswin64c --version');
+                end
+            else
+                [st, vers] = system('gs --version');
+            end
+            if st == 0
+                fprintf(' found %s\n',vers(1:strfind(vers,sprintf('\n'))-1));
+            else
+                fprintf(2,'ghostscript not found!\nCreating LaTeX formulas might not work properly.\n');
+            end
+
+            if ~hasall
+                fprintf(2,'Please make sure all prerequisites can be found on PATH or copy the executables into %s.\n',confdir);
+                fprintf('<<<< MatlabDocMaker setup finished with warnings. >>>>\n');
+            else
+                fprintf('<<<< MatlabDocMaker setup successful. >>>>\nYou can now create your projects documentation by running <a href="matlab:MatlabDocMaker.create(''open'',true)">MatlabDocMaker.create</a>!\n');
+            end
+        end
+    end
+    
+    methods(Static, Access=private)
+        function value = getProjPrefTag
+            % Gets the tag for the MatLab preferences struct.
+            % 
+            % @change{0,7,dw,2013-04-02} Now also removing "~" and "-" characters from ProjectName tags for preferences.
+            str = regexprep(strrep(strtrim(MatlabDocMaker.getProjectName),' ','_'),'[^\d\w]','');
+            value = sprintf('MatlabDocMaker_on_%s',str);
+        end
+        
+        function value = getPref(name, default)
+            if nargin < 2
+                def = [];
+            else 
+                def = default;
+            end
+            value = getpref(MatlabDocMaker.getProjPrefTag,name,def);
+            if nargin < 2 && isempty(value)
+                error('MatlabDocMaker preferences not found/set correctly. (Re-)Run the MatlabDocMaker.setup method.');
+            end
+        end
+        
+        function value = setPref(name, value)
+            setpref(MatlabDocMaker.getProjPrefTag,name,value);
+        end
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/Doxyfile.template b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/Doxyfile.template
new file mode 100644
index 0000000000000000000000000000000000000000..5241a95ee2fa2102435efc554a86e69a9eb266da
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/Doxyfile.template
@@ -0,0 +1,1815 @@
+############################################################################
+# DOXYGEN CONFIGURATION FILE TEMPLATE (Doxygen version => 1.8.2)
+############################################################################
+#
+# IMPORTANT NOTICE: This file is included with the tool "mtoc++", and contains some changes
+# in order to make mtoc++ run together with doxygen. The settings in this file are a default
+# configuration for Doxygen which we thought might be useful in a MatLab setting/project.
+# USING MTOC++ DOES NOT EXCLUDE THE REQUIREMENT TO KNOW AND UNDERSTAND DOXYGEN ITSELF!
+# We've had lots of feedback and problem reports which actually had to do with settings purely
+# regarding doxygen, so we strongly recommend having a look through this file before contacting
+# us. Thanks!
+#
+############################################################################
+################# mtoc++ related information ###############################
+############################################################################
+# Feel free to make any changes within this doxygen configuration file to 
+# taylor the output towards your needs. Any changes made by us to the doxygen
+# config file in order to have mtoc++ running smoothly have been moved to the
+# END of the file in order to easily keep custom changes over new mtoc++ versions.
+#
+# Depending on the output preferred style, checkout the 
+# OPTIMIZE_OUTPUT_FOR_C and OPTIMIZE_OUTPUT_FOR_JAVA settings.
+#
+# Most importantly, this file gets processed (when using our tools, e.g. 
+# MatlabDocMaker) in order to replace some values:
+# - _ProjectName_: The project name configured in the tools
+#       (in MatlabDocMaker:MatlabDocMaker.getProjectVersion) 
+# - _ProjectVersion_: Is substituted by the value returned by 
+#       MatlabDocMaker.getProjectVersion inside MatLab. We decided to keep
+#       this flexible as project versions change over time and the documentation
+#       should of course reflect that with minimum effort (thus, only a change
+#       inside Matlab is necessary, where you're expected to be working anyways)
+# - _ProjectDescription_: A short description of the project
+# - _ProjectLogo_: An absolute path to an image file to include as project logo
+# - _OutputDir_: The output directory for the created documentation
+# - _SourceDir_: The source directory containing the files of the project
+# - _ConfDir_: The configuration directory for mtoc++, containing this file
+#       and some more.
+# - _FileSep_: The file separator character, "/" for linux and "\" for windows.
+# - _GenLatex_: Switch to tell doxygen to also generate LaTeX output.
+# - _HaveDot_: "YES" or "NO" depending on automatic GraphViz detection on MatlabDocMaker.create
+# Use these tags wherever you would insert the respective values.
+#
+# Furthermore, there are some settings that are included as convenience
+# (e.g. the @new tags) that can be removed (but will likely cause errors if
+# done wrongly). Check the ALIASES setting in the doxygen documentation.
+#
+# We recommend to leave
+# EXTRACT_PRIVATE   = NO
+# if you make extensive use of classes as these methods are of course not
+# thought to be public (cunning, isn't it?) and blow up the documentation.
+#
+# Last, have a look at DOCSET_FEEDNAME and DOCSET_BUNDLE_ID.
+#
+# Enjoy!
+#
+###########################################################################
+################## List of changes: #######################################
+#
+# mtoc++ 1.4: - Updated the doxyfile config to version 1.8.
+#             - Added placeholders for project description and logo
+#             - Set SOURCE_BROWSER = YES and FILTER_SOURCE_FILES = YES in
+#               order to have automatic inclusion of call graphs in the generated documentation.
+#             - Set EXLUDE_SYMLINKS = YES as default
+#
+# mtoc++ 1.4: - Added alias for an @events tag, creating a page of all events
+#			  - Changed naming convention for alias-tags new and change as newer doxygen
+#               versions seem not to recognize \1\2-like combinations of arguments any more (?)
+#               now pages named "newfeat\1_\2" with underscore are created, please update your static
+#               references in your misc documentation files
+#
+# mtoc++ 1.3: - Changed the default value of SHOW_FILES to YES in order to avoid more
+#               confusion about what mtoc++ actually does (NOT replacing the 
+#               requirement to know doxygen)
+#             - Included a warning in the beginning of this file
+#
+# mtoc++ 1.3: Included a new placeholder "_FILESEP_", as doxygen itself can manage
+#             using only "/" as file separator, however, the EXTRA_PACKAGES command
+#             leads to an inclusion line inside latex, which is not that tolerant.
+#
+# mtoc++ 1.2: Restructured this file during tests for Windows doc creation.
+#             - Config stuff is now at the END of the file.
+#             - New macro _MTOCFILTER_ for .sh and .bat file support.
+#
+# mtoc++ 1.2: First version to contain this file.
+#
+################################################################################
+
+############### DEFAULT (DOXYGEN ONLY) CONFIGURATION ###########################
+# The following settings can be adjusted to customize doxygen's behaviour and 
+# hence the output when using the tools like MatlabDocMaker
+################################################################################
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a hash (#) is considered a comment and will be ignored.
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ").
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = NO
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = YES
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding
+# "class=itcl::class" will allow you to use the command class in the
+# itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = YES
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
+# comments according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you
+# can mix doxygen, HTML, and XML commands with Markdown formatting.
+# Disable only in case of backward compatibilities issues.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented classes,
+# or namespaces to their corresponding documentation. Such a link can be
+# prevented in individual cases by by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = YES
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = YES
+
+# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
+# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
+# their name and scope. Since this can be an expensive process and often the
+# same symbol appear multiple times in the code, doxygen keeps a cache of
+# pre-resolved symbols. If the cache is too small doxygen will become slower.
+# If the cache is too large, memory is wasted. The cache size is given by this
+# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = YES
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = YES
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = YES
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS       = NO
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = YES
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST      = NO
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page.
+# This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE            =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC       = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = "src/solver_cvodes.cpp" \
+                         "src/solver_idas.cpp" \
+                         "src/wrapfunctions.ODE_template.h" \
+                         "src/model_header.ODE_template.h" \
+                         "include/amici/solver_cvodes.h" \
+                         "include/amici/solver_idas.h" \
+                         "python/amici/setup.template.py"
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS       = YES
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = "_SourceDir_/models/*" \
+                         "_SourceDir_/tests/*" \
+                         "_SourceDir_/scripts/*" \
+                         "_SourceDir_/ThirdParty/*" \
+                         "_SourceDir_/matlab/examples/*" \
+                         "_SourceDir_/matlab/mtoc/*" \
+                         "_SourceDir_/matlab/auxiliary/*" \
+                         "_SourceDir_/matlab/SBMLImporter/*" \
+                         "_SourceDir_/python/test/*" \
+                         "_SourceDir_/python/sdist/*" \
+                         "_SourceDir_/python/examples/example_*/model_*" \
+                         "_SourceDir_/build/*" \ 
+                         "_SourceDir_/build_xcode/*" \
+                         "_SourceDir_/swig/*"
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output.
+# If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER           =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = YES
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code.
+# Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+# See on bottom of file for mtoc++ related HTML settings.
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+# for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is adviced to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = "_ConfDir_/customdoxygen.css"
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES       = 
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the stylesheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS  = YES
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME        = "_ProjectName_ documentation"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = _ProjectName_._ProjectVersion_
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = _ProjectName_
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE               =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING     =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+#  will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = ALL
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the
+# mathjax.org site, so you can quickly see the result without installing
+# MathJax, but it is strongly recommended to install a local copy of MathJax
+# before deployment.
+
+MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvantages are that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX          = YES
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER           =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES     = YES
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE      = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader.
+# This is useful
+# if you want to understand what is going on.
+# On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+#
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+#
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will write a font called Helvetica to the output
+# directory and reference it in all dot files that doxygen generates.
+# When you want a differently looking font you can specify the font name
+# using DOT_FONTNAME. You need to make sure dot is able to find the font,
+# which can be done by putting it in a standard location or by setting the
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
+# containing the font.
+
+DOT_FONTNAME           = Arial
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the output directory to look for the
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a
+# different font using DOT_FONTNAME you can set the path where dot
+# can find it using this tag.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = NO
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS           =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 100
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 3
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+############### MTOC++ RELATED CONFIGURATION ###################################
+# The following are set by us or the tools (MatlabDocMaker) and should be 
+# changed with care in order to keep mtoc++ running
+################################################################################
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = "_ProjectName_"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER         = _ProjectVersion_
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "_ProjectDescription_"
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+# Recall that you can use all the macros like _ConfDir_ at this setting, too.
+
+PROJECT_LOGO           = "_ProjectLogo_"
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = "_OutputDir_"
+
+# What to generate? HTML by default, directly into _OutputDir_
+GENERATE_HTML          = YES
+HTML_OUTPUT            = "_OutputDir_"
+
+# Latex is an extra option.
+GENERATE_LATEX         = YES
+
+# NO causes LaTeX to stop when errors occur
+LATEX_BATCHMODE        = YES
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = "synupdate=\xrefitem synupdate \"Syntax Update\" \"Syntax needs to be updated\"" \
+                         "docupdate=\xrefitem docupdate \"Documentation Update\" \"Documentation needs to be updated\"" \
+                         "event=\xrefitem event \"Events\" \"List of all Events\"" \
+                         "default=\par Default:\n" \
+                         "type=<br><b>Type</b>: " \
+                         "changexref{2}=\xrefitem changelog\1_\2 \"Change in \1.\2\" \"Changes in _ProjectName_ Version \1.\2\"" \
+                         "change{4} = \changexref{\1,\2} (\ref \3, \4) " \
+                         "change{3} = \changexref{\1,\2} (\ref \3, undated) " \
+                         "newxref{2}=\xrefitem newfeat\1_\2 \"New in \1.\2\" \"New features in _ProjectName_ Version \1.\2\"" \
+                         "new{4} = \newxref{\1,\2} (\ref \3, \4) " \
+                         "new{3} = \newxref{\1,\2} (\ref \3, undated) " \
+                         "propclass{1}=\xrefitem propclass_\1 \"Property class \1\" \"Properties with level \1\""
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = _HaveDot_
+                         
+############### CRITICAL MTOC++ RELATED CONFIGURATION ##########################
+# The following tags should NOT be changed in order to keep mtoc++ running
+################################################################################
+
+# assign C++-styled code interpretion to .m files
+EXTENSION_MAPPING = .m=C++
+
+# input is configured by MatlabDocMaker
+INPUT             = "_SourceDir_/README.md"
+USE_MDFILE_AS_MAINPAGE = "_SourceDir_/README.md"
+INPUT            += "_SourceDir_/LICENSE.md"
+INPUT            += "_SourceDir_/CONTRIBUTING.md"
+INPUT            += "_SourceDir_/INSTALL.md"
+INPUT            += "_SourceDir_/documentation/PYTHON.md"
+INPUT            += "_SourceDir_/documentation/MATLAB.md"
+INPUT            += "_SourceDir_/documentation/CPP.md"
+INPUT            += "_SourceDir_/documentation/FAQ.md"
+INPUT            += "_SourceDir_/documentation/development.md"
+INPUT            += "_SourceDir_/documentation/CI.md"
+INPUT            += "_SourceDir_/documentation/README.md"
+INPUT            += "_SourceDir_"
+
+# doxygen bothers to look at .m files at all
+FILE_PATTERNS     = *.m \
+                    *.c \
+                    *.cc \
+                    *.cpp \
+                    *.mex \
+                    *.h \
+                    *.hh \
+                    *.hpp \
+                    *.dox \
+                    *.md \
+                    *.py \
+
+# the link between mtoc++ and doxygen (the `' separates the macros)
+FILTER_PATTERNS   = *.m="_MTOCFILTER_" \
+                    *.py=py_filter 
+
+# latex styles inclusion file
+EXTRA_PACKAGES    = "_LatexExtras_"
+
+# leave empty so MatlabDocMaker can capture doxygen warnings
+WARN_LOGFILE      = 
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/customdoxygen.css b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/customdoxygen.css
new file mode 100644
index 0000000000000000000000000000000000000000..6a24a8c7d37842ddf9ee7fda9e18f2273279bb51
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/customdoxygen.css
@@ -0,0 +1,1530 @@
+body, table, div, p, dl {
+  font: 400 14px/22px "Lato", "proxima-nova", "Helvetica Neue", Arial,sans-serif;
+}
+
+/* @group Heading Levels */
+
+h1 {
+  font-size: 150%;
+  font-weight: bold;
+}
+
+.title {
+  font-size: 175%;
+  font-weight: bold;
+}
+
+h2 {
+  color: #354C7B;
+  font-size: 150%;
+  font-weight: bold;
+  margin-top: 1.75em;
+  padding-top: 8px;
+  padding-bottom: 4px;
+  width: 100%;
+}
+
+h3 {
+  font-size: 125%;
+  font-weight: bold;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin-right: 15px;
+}
+
+h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
+  text-shadow: 0 0 15px cyan;
+}
+
+dt {
+  font-weight: bold;
+}
+
+div.multicol {
+  -moz-column-gap: 1em;
+  -webkit-column-gap: 1em;
+  -moz-column-count: 3;
+  -webkit-column-count: 3;
+}
+
+p.startli, p.startdd {
+  margin-top: 2px;
+}
+
+p.starttd {
+  margin-top: 0px;
+}
+
+p.endli {
+  margin-bottom: 0px;
+}
+
+p.enddd {
+  margin-bottom: 4px;
+}
+
+p.endtd {
+  margin-bottom: 2px;
+}
+
+/* @end */
+
+caption {
+  font-weight: bold;
+}
+
+span.legend {
+        font-size: 70%;
+        text-align: center;
+}
+
+h3.version {
+        font-size: 90%;
+        text-align: center;
+}
+
+div.qindex, div.navtab{
+  background-color: #EBEFF6;
+  border: 1px solid #A3B4D7;
+  text-align: center;
+}
+
+div.qindex, div.navpath {
+  width: 100%;
+  line-height: 140%;
+}
+
+div.navtab {
+  margin-right: 15px;
+}
+
+/* @group Link Styling */
+
+a {
+  color: #3D578C;
+  font-weight: normal;
+  text-decoration: none;
+}
+
+.contents a:visited {
+  color: #4665A2;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+a.qindex {
+  font-weight: bold;
+}
+
+a.qindexHL {
+  font-weight: bold;
+  background-color: #9CAFD4;
+  color: #ffffff;
+  border: 1px double #869DCA;
+}
+
+.contents a.qindexHL:visited {
+        color: #ffffff;
+}
+
+a.el {
+  font-weight: bold;
+}
+
+a.elRef {
+}
+
+a.code, a.code:visited, a.line, a.line:visited {
+  color: #4665A2; 
+}
+
+a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
+  color: #4665A2; 
+}
+
+/* @end */
+
+dl.el {
+  margin-left: -1cm;
+}
+
+pre.fragment {
+        border: 1px solid #C4CFE5;
+        background-color: #FBFCFD;
+        padding: 4px 6px;
+        margin: 4px 8px 4px 2px;
+        overflow: auto;
+        word-wrap: break-word;
+        font-size:  9pt;
+        line-height: 125%;
+        font-family: monospace, fixed;
+        font-size: 105%;
+}
+
+div.fragment {
+        padding: 4px 6px;
+        margin: 4px 8px 4px 2px;
+  background-color: #FBFCFD;
+  border: 1px solid #C4CFE5;
+}
+
+div.line {
+  font-family: monospace, fixed;
+        font-size: 13px;
+  min-height: 13px;
+  line-height: 1.0;
+  text-wrap: unrestricted;
+  white-space: -moz-pre-wrap; /* Moz */
+  white-space: -pre-wrap;     /* Opera 4-6 */
+  white-space: -o-pre-wrap;   /* Opera 7 */
+  white-space: pre-wrap;      /* CSS3  */
+  word-wrap: break-word;      /* IE 5.5+ */
+  text-indent: -53px;
+  padding-left: 53px;
+  padding-bottom: 0px;
+  margin: 0px;
+  -webkit-transition-property: background-color, box-shadow;
+  -webkit-transition-duration: 0.5s;
+  -moz-transition-property: background-color, box-shadow;
+  -moz-transition-duration: 0.5s;
+  -ms-transition-property: background-color, box-shadow;
+  -ms-transition-duration: 0.5s;
+  -o-transition-property: background-color, box-shadow;
+  -o-transition-duration: 0.5s;
+  transition-property: background-color, box-shadow;
+  transition-duration: 0.5s;
+}
+
+div.line.glow {
+  background-color: cyan;
+  box-shadow: 0 0 10px cyan;
+}
+
+
+span.lineno {
+  padding-right: 4px;
+  text-align: right;
+  border-right: 2px solid #0F0;
+  background-color: #E8E8E8;
+        white-space: pre;
+}
+span.lineno a {
+  background-color: #D8D8D8;
+}
+
+span.lineno a:hover {
+  background-color: #C8C8C8;
+}
+
+div.ah, span.ah {
+  background-color: black;
+  font-weight: bold;
+  color: #ffffff;
+  margin-bottom: 3px;
+  margin-top: 3px;
+  padding: 0.2em;
+  border: solid thin #333;
+  border-radius: 0.5em;
+  -webkit-border-radius: .5em;
+  -moz-border-radius: .5em;
+  box-shadow: 2px 2px 3px #999;
+  -webkit-box-shadow: 2px 2px 3px #999;
+  -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
+  background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000);
+}
+
+div.classindex ul {
+        list-style: none;
+        padding-left: 0;
+}
+
+div.classindex span.ai {
+        display: inline-block;
+}
+
+div.groupHeader {
+  margin-left: 16px;
+  margin-top: 12px;
+  font-weight: bold;
+}
+
+div.groupText {
+  margin-left: 16px;
+  font-style: italic;
+}
+
+body {
+  background-color: white;
+  color: black;
+        margin: 0;
+}
+
+div.contents {
+  margin-top: 10px;
+  margin-left: 12px;
+  margin-right: 8px;
+}
+
+td.indexkey {
+  background-color: #EBEFF6;
+  font-weight: bold;
+  border: 1px solid #C4CFE5;
+  margin: 2px 0px 2px 0;
+  padding: 2px 10px;
+        white-space: nowrap;
+        vertical-align: top;
+}
+
+td.indexvalue {
+  background-color: #EBEFF6;
+  border: 1px solid #C4CFE5;
+  padding: 2px 10px;
+  margin: 2px 0px;
+}
+
+tr.memlist {
+  background-color: #EEF1F7;
+}
+
+p.formulaDsp {
+  text-align: center;
+}
+
+img.formulaDsp {
+  
+}
+
+img.formulaInl {
+  vertical-align: middle;
+}
+
+div.center {
+  text-align: center;
+        margin-top: 0px;
+        margin-bottom: 0px;
+        padding: 0px;
+}
+
+div.center img {
+  border: 0px;
+}
+
+address.footer {
+  text-align: right;
+  padding-right: 12px;
+}
+
+img.footer {
+  border: 0px;
+  vertical-align: middle;
+}
+
+/* @group Code Colorization */
+
+span.keyword {
+  color: #008000
+}
+
+span.keywordtype {
+  color: #604020
+}
+
+span.keywordflow {
+  color: #e08000
+}
+
+span.comment {
+  color: #800000
+}
+
+span.preprocessor {
+  color: #806020
+}
+
+span.stringliteral {
+  color: #002080
+}
+
+span.charliteral {
+  color: #008080
+}
+
+span.vhdldigit { 
+  color: #ff00ff 
+}
+
+span.vhdlchar { 
+  color: #000000 
+}
+
+span.vhdlkeyword { 
+  color: #700070 
+}
+
+span.vhdllogic { 
+  color: #ff0000 
+}
+
+blockquote {
+        background-color: #F7F8FB;
+        border-left: 2px solid #9CAFD4;
+        margin: 0 24px 0 4px;
+        padding: 0 12px 0 16px;
+}
+
+/* @end */
+
+/*
+.search {
+  color: #003399;
+  font-weight: bold;
+}
+
+form.search {
+  margin-bottom: 0px;
+  margin-top: 0px;
+}
+
+input.search {
+  font-size: 75%;
+  color: #000080;
+  font-weight: normal;
+  background-color: #e8eef2;
+}
+*/
+
+td.tiny {
+  font-size: 75%;
+}
+
+.dirtab {
+  padding: 4px;
+  border-collapse: collapse;
+  border: 1px solid #A3B4D7;
+}
+
+th.dirtab {
+  background: #EBEFF6;
+  font-weight: bold;
+}
+
+hr {
+  height: 0px;
+  border: none;
+  border-top: 1px solid #4A6AAA;
+}
+
+hr.footer {
+  height: 1px;
+}
+
+/* @group Member Descriptions */
+
+table.memberdecls {
+  border-spacing: 0px;
+  padding: 0px;
+}
+
+.memberdecls td, .fieldtable tr {
+  -webkit-transition-property: background-color, box-shadow;
+  -webkit-transition-duration: 0.5s;
+  -moz-transition-property: background-color, box-shadow;
+  -moz-transition-duration: 0.5s;
+  -ms-transition-property: background-color, box-shadow;
+  -ms-transition-duration: 0.5s;
+  -o-transition-property: background-color, box-shadow;
+  -o-transition-duration: 0.5s;
+  transition-property: background-color, box-shadow;
+  transition-duration: 0.5s;
+}
+
+.memberdecls td.glow, .fieldtable tr.glow {
+  background-color: cyan;
+  box-shadow: 0 0 15px cyan;
+}
+
+.mdescLeft, .mdescRight,
+.memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+  background-color: #F9FAFC;
+  border: none;
+  margin: 4px;
+  padding: 1px 0 0 8px;
+}
+
+.mdescLeft, .mdescRight {
+  padding: 0px 8px 4px 8px;
+  color: #555;
+}
+
+.memSeparator {
+        border-bottom: 1px solid #DEE4F0;
+        line-height: 1px;
+        margin: 0px;
+        padding: 0px;
+}
+
+.memItemLeft, .memTemplItemLeft {
+        white-space: nowrap;
+}
+
+.memItemRight {
+  width: 100%;
+}
+
+.memTemplParams {
+  color: #4665A2;
+        white-space: nowrap;
+  font-size: 80%;
+}
+
+/* @end */
+
+/* @group Member Details */
+
+/* Styles for detailed member documentation */
+
+.memtemplate {
+  font-size: 80%;
+  color: #4665A2;
+  font-weight: normal;
+  margin-left: 9px;
+}
+
+.memnav {
+  background-color: #EBEFF6;
+  border: 1px solid #A3B4D7;
+  text-align: center;
+  margin: 2px;
+  margin-right: 15px;
+  padding: 2px;
+}
+
+.mempage {
+  width: 100%;
+}
+
+.memitem {
+  padding: 0;
+  margin-bottom: 10px;
+  margin-right: 5px;
+        -webkit-transition: box-shadow 0.5s linear;
+        -moz-transition: box-shadow 0.5s linear;
+        -ms-transition: box-shadow 0.5s linear;
+        -o-transition: box-shadow 0.5s linear;
+        transition: box-shadow 0.5s linear;
+        display: table !important;
+        width: 100%;
+}
+
+.memitem.glow {
+         box-shadow: 0 0 15px cyan;
+}
+
+.memname {
+        font-weight: bold;
+        margin-left: 6px;
+}
+
+.memname td {
+  vertical-align: bottom;
+}
+
+.memproto, dl.reflist dt {
+        border-top: 1px solid #A8B8D9;
+        border-left: 1px solid #A8B8D9;
+        border-right: 1px solid #A8B8D9;
+        padding: 6px 0px 6px 0px;
+        color: #253555;
+        font-weight: bold;
+        text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+        background-image:url('nav_f.png');
+        background-repeat:repeat-x;
+        background-color: #E2E8F2;
+        /* opera specific markup */
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        border-top-right-radius: 4px;
+        border-top-left-radius: 4px;
+        /* firefox specific markup */
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        -moz-border-radius-topright: 4px;
+        -moz-border-radius-topleft: 4px;
+        /* webkit specific markup */
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        -webkit-border-top-right-radius: 4px;
+        -webkit-border-top-left-radius: 4px;
+
+}
+
+.memdoc, dl.reflist dd {
+        border-bottom: 1px solid #A8B8D9;      
+        border-left: 1px solid #A8B8D9;      
+        border-right: 1px solid #A8B8D9; 
+        padding: 6px 10px 2px 10px;
+        background-color: #FBFCFD;
+        border-top-width: 0;
+        background-image:url('nav_g.png');
+        background-repeat:repeat-x;
+        background-color: #FFFFFF;
+        /* opera specific markup */
+        border-bottom-left-radius: 4px;
+        border-bottom-right-radius: 4px;
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        /* firefox specific markup */
+        -moz-border-radius-bottomleft: 4px;
+        -moz-border-radius-bottomright: 4px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        /* webkit specific markup */
+        -webkit-border-bottom-left-radius: 4px;
+        -webkit-border-bottom-right-radius: 4px;
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+dl.reflist dt {
+        padding: 5px;
+}
+
+dl.reflist dd {
+        margin: 0px 0px 10px 0px;
+        padding: 5px;
+}
+
+.paramkey {
+  text-align: right;
+}
+
+.paramtype {
+  white-space: nowrap;
+}
+
+.paramname {
+  color: #602020;
+  white-space: nowrap;
+}
+.paramname em {
+  font-style: normal;
+}
+.paramname code {
+        line-height: 14px;
+}
+
+.params, .retval, .exception, .tparams {
+        margin-left: 0px;
+        padding-left: 0px;
+}       
+
+.params .paramname, .retval .paramname {
+        font-weight: bold;
+        vertical-align: top;
+}
+        
+.params .paramtype {
+        font-style: italic;
+        vertical-align: top;
+}       
+        
+.params .paramdir {
+        font-family: "courier new",courier,monospace;
+        vertical-align: top;
+}
+
+table.mlabels {
+  border-spacing: 0px;
+}
+
+td.mlabels-left {
+  width: 100%;
+  padding: 0px;
+}
+
+td.mlabels-right {
+  vertical-align: bottom;
+  padding: 0px;
+  white-space: nowrap;
+}
+
+span.mlabels {
+        margin-left: 8px;
+}
+
+span.mlabel {
+        background-color: #728DC1;
+        border-top:1px solid #5373B4;
+        border-left:1px solid #5373B4;
+        border-right:1px solid #C4CFE5;
+        border-bottom:1px solid #C4CFE5;
+  text-shadow: none;
+  color: white;
+  margin-right: 4px;
+  padding: 2px 3px;
+  border-radius: 3px;
+  font-size: 7pt;
+  white-space: nowrap;
+  vertical-align: middle;
+}
+
+
+
+/* @end */
+
+/* these are for tree view inside a (index) page */
+
+div.directory {
+        margin: 10px 0px;
+        border-top: 1px solid #9CAFD4;
+        border-bottom: 1px solid #9CAFD4;
+        width: 100%;
+}
+
+.directory table {
+        border-collapse:collapse;
+}
+
+.directory td {
+        margin: 0px;
+        padding: 0px;
+  vertical-align: top;
+}
+
+.directory td.entry {
+        white-space: nowrap;
+        padding-right: 6px;
+  padding-top: 3px;
+}
+
+.directory td.entry a {
+        outline:none;
+}
+
+.directory td.entry a img {
+        border: none;
+}
+
+.directory td.desc {
+        width: 100%;
+        padding-left: 6px;
+  padding-right: 6px;
+  padding-top: 3px;
+  border-left: 1px solid rgba(0,0,0,0.05);
+}
+
+.directory tr.even {
+  padding-left: 6px;
+  background-color: #F7F8FB;
+}
+
+.directory img {
+  vertical-align: -30%;
+}
+
+.directory .levels {
+        white-space: nowrap;
+        width: 100%;
+        text-align: right;
+        font-size: 9pt;
+}
+
+.directory .levels span {
+        cursor: pointer;
+        padding-left: 2px;
+        padding-right: 2px;
+  color: #3D578C;
+}
+
+.arrow {
+    color: #9CAFD4;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    cursor: pointer;
+    font-size: 80%;
+    display: inline-block;
+    width: 16px;
+    height: 22px;
+}
+
+.icon {
+    font-family: Arial, Helvetica;
+    font-weight: bold;
+    font-size: 12px;
+    height: 14px;
+    width: 16px;
+    display: inline-block;
+    background-color: #728DC1;
+    color: white;
+    text-align: center;
+    border-radius: 4px;
+    margin-left: 2px;
+    margin-right: 2px;
+}
+
+.icona {
+    width: 24px;
+    height: 22px;
+    display: inline-block;
+}
+
+.iconfopen {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('folderopen.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+.iconfclosed {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('folderclosed.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+.icondoc {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('doc.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+table.directory {
+    font: 400 14px Roboto,sans-serif;
+}
+
+/* @end */
+
+div.dynheader {
+        margin-top: 8px;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+address {
+  font-style: normal;
+  color: #2A3D61;
+}
+
+table.doxtable {
+  border-collapse:collapse;
+        margin-top: 4px;
+        margin-bottom: 4px;
+}
+
+table.doxtable td, table.doxtable th {
+  border: 1px solid #2D4068;
+  padding: 3px 7px 2px;
+}
+
+table.doxtable th {
+  background-color: #374F7F;
+  color: #FFFFFF;
+  font-size: 110%;
+  padding-bottom: 4px;
+  padding-top: 5px;
+}
+
+table.fieldtable {
+        /*width: 100%;*/
+        margin-bottom: 10px;
+        border: 1px solid #A8B8D9;
+        border-spacing: 0px;
+        -moz-border-radius: 4px;
+        -webkit-border-radius: 4px;
+        border-radius: 4px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+        -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+        box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+}
+
+.fieldtable td, .fieldtable th {
+        padding: 3px 7px 2px;
+}
+
+.fieldtable td.fieldtype, .fieldtable td.fieldname {
+        white-space: nowrap;
+        border-right: 1px solid #A8B8D9;
+        border-bottom: 1px solid #A8B8D9;
+        vertical-align: top;
+}
+
+.fieldtable td.fieldname {
+        padding-top: 3px;
+}
+
+.fieldtable td.fielddoc {
+        border-bottom: 1px solid #A8B8D9;
+        /*width: 100%;*/
+}
+
+.fieldtable td.fielddoc p:first-child {
+        margin-top: 0px;
+}       
+        
+.fieldtable td.fielddoc p:last-child {
+        margin-bottom: 2px;
+}
+
+.fieldtable tr:last-child td {
+        border-bottom: none;
+}
+
+.fieldtable th {
+        background-image:url('nav_f.png');
+        background-repeat:repeat-x;
+        background-color: #E2E8F2;
+        font-size: 90%;
+        color: #253555;
+        padding-bottom: 4px;
+        padding-top: 5px;
+        text-align:left;
+        -moz-border-radius-topleft: 4px;
+        -moz-border-radius-topright: 4px;
+        -webkit-border-top-left-radius: 4px;
+        -webkit-border-top-right-radius: 4px;
+        border-top-left-radius: 4px;
+        border-top-right-radius: 4px;
+        border-bottom: 1px solid #A8B8D9;
+}
+
+
+.tabsearch {
+  top: 0px;
+  left: 10px;
+  height: 36px;
+  background-image: url('tab_b.png');
+  z-index: 101;
+  overflow: hidden;
+  font-size: 13px;
+}
+
+.navpath ul
+{
+  font-size: 11px;
+  background-image:url('tab_b.png');
+  background-repeat:repeat-x;
+  background-position: 0 -5px;
+  height:30px;
+  line-height:30px;
+  color:#8AA0CC;
+  border:solid 1px #C2CDE4;
+  overflow:hidden;
+  margin:0px;
+  padding:0px;
+}
+
+.navpath li
+{
+  list-style-type:none;
+  float:left;
+  padding-left:10px;
+  padding-right:15px;
+  background-image:url('bc_s.png');
+  background-repeat:no-repeat;
+  background-position:right;
+  color:#364D7C;
+}
+
+.navpath li.navelem a
+{
+  height:32px;
+  display:block;
+  text-decoration: none;
+  outline: none;
+  color: #283A5D;
+  font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+  text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+  text-decoration: none;        
+}
+
+.navpath li.navelem a:hover
+{
+  color:#6884BD;
+}
+
+.navpath li.footer
+{
+        list-style-type:none;
+        float:right;
+        padding-left:10px;
+        padding-right:15px;
+        background-image:none;
+        background-repeat:no-repeat;
+        background-position:right;
+        color:#364D7C;
+        font-size: 8pt;
+}
+
+
+div.summary
+{
+  float: right;
+  font-size: 8pt;
+  padding-right: 5px;
+  width: 50%;
+  text-align: right;
+}       
+
+div.summary a
+{
+  white-space: nowrap;
+}
+
+div.ingroups
+{
+  font-size: 8pt;
+  width: 50%;
+  text-align: left;
+}
+
+div.ingroups a
+{
+  white-space: nowrap;
+}
+
+div.header
+{
+        background-image:url('nav_h.png');
+        background-repeat:repeat-x;
+  background-color: #F9FAFC;
+  margin:  0px;
+  border-bottom: 1px solid #C4CFE5;
+}
+
+div.headertitle
+{
+  padding: 5px 5px 5px 10px;
+}
+
+dl
+{
+        padding: 0 0 0 10px;
+}
+
+/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */
+dl.section
+{
+  margin-left: 0px;
+  padding-left: 0px;
+}
+
+dl.note
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #D0C000;
+}
+
+dl.warning, dl.attention
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #FF0000;
+}
+
+dl.pre, dl.post, dl.invariant
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #00D000;
+}
+
+dl.deprecated
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #505050;
+}
+
+dl.todo
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #00C0E0;
+}
+
+dl.test
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #3030E0;
+}
+
+dl.bug
+{
+        margin-left:-7px;
+        padding-left: 3px;
+        border-left:4px solid;
+        border-color: #C08050;
+}
+
+dl.section dd {
+  margin-bottom: 6px;
+}
+
+
+#projectlogo
+{
+  text-align: center;
+  vertical-align: bottom;
+  border-collapse: separate;
+}
+ 
+#projectlogo img
+{ 
+  border: 0px none;
+}
+ 
+#projectalign
+{
+  vertical-align: middle;
+}
+
+#projectname
+{
+  font-size: 200%;
+  font-weight: bold;
+}
+    
+#projectbrief
+{
+  font-size: 100%;
+  font-weight: bold;
+}
+
+#projectnumber
+{
+  font: 50% Tahoma, Arial,sans-serif;
+  margin: 0px;
+  padding: 0px;
+}
+
+#titlearea
+{
+  padding: 0px;
+  margin: 0px;
+  width: 100%;
+  margin-bottom: 0em;
+}
+
+.image
+{
+        text-align: center;
+}
+
+.dotgraph
+{
+        text-align: center;
+}
+
+.mscgraph
+{
+        text-align: center;
+}
+
+.diagraph
+{
+        text-align: center;
+}
+
+.caption
+{
+  font-weight: bold;
+}
+
+div.zoom
+{
+  border: 1px solid #90A5CE;
+}
+
+dl.citelist {
+        margin-bottom:50px;
+}
+
+dl.citelist dt {
+        color:#334975;
+        float:left;
+        font-weight:bold;
+        margin-right:10px;
+        padding:5px;
+}
+
+dl.citelist dd {
+        margin:2px 0;
+        padding:5px 0;
+}
+
+div.toc {
+        padding: 14px 25px;
+        background-color: #F4F6FA;
+        border: 1px solid #D8DFEE;
+        border-radius: 7px 7px 7px 7px;
+        float: right;
+        height: auto;
+        margin: 0 20px 10px 10px;
+        width: 200px;
+}
+
+div.toc li {
+        background: url("bdwn.png") no-repeat scroll 0 5px transparent;
+        font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif;
+        margin-top: 5px;
+        padding-left: 10px;
+        padding-top: 2px;
+}
+
+div.toc h3 {
+        font: bold 12px/1.2 Arial,FreeSans,sans-serif;
+  color: #4665A2;
+        border-bottom: 0 none;
+        margin: 0;
+}
+
+div.toc ul {
+        list-style: none outside none;
+        border: medium none;
+        padding: 0px;
+}       
+
+div.toc li.level1 {
+        margin-left: 0px;
+}
+
+div.toc li.level2 {
+        margin-left: 15px;
+}
+
+div.toc li.level3 {
+        margin-left: 30px;
+}
+
+div.toc li.level4 {
+        margin-left: 45px;
+}
+
+.inherit_header {
+        font-weight: bold;
+        color: gray;
+        cursor: pointer;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+.inherit_header td {
+        padding: 6px 0px 2px 5px;
+}
+
+.inherit {
+        display: none;
+}
+
+tr.heading h2 {
+        margin-top: 12px;
+        margin-bottom: 4px;
+}
+
+/* tooltip related style info */
+
+.ttc {
+        position: absolute;
+        display: none;
+}
+
+#powerTip {
+  cursor: default;
+  white-space: nowrap;
+  background-color: white;
+  border: 1px solid gray;
+  border-radius: 4px 4px 4px 4px;
+  box-shadow: 1px 1px 7px gray;
+  display: none;
+  font-size: smaller;
+  max-width: 80%;
+  opacity: 0.9;
+  padding: 1ex 1em 1em;
+  position: absolute;
+  z-index: 2147483647;
+}
+
+#powerTip div.ttdoc {
+        color: grey;
+  font-style: italic;
+}
+
+#powerTip div.ttname a {
+        font-weight: bold;
+}
+
+#powerTip div.ttname {
+        font-weight: bold;
+}
+
+#powerTip div.ttdeci {
+        color: #006318;
+}
+
+#powerTip div {
+        margin: 0px;
+        padding: 0px;
+        font: 12px/16px Roboto,sans-serif;
+}
+
+#powerTip:before, #powerTip:after {
+  content: "";
+  position: absolute;
+  margin: 0px;
+}
+
+#powerTip.n:after,  #powerTip.n:before,
+#powerTip.s:after,  #powerTip.s:before,
+#powerTip.w:after,  #powerTip.w:before,
+#powerTip.e:after,  #powerTip.e:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.nw:after, #powerTip.nw:before,
+#powerTip.sw:after, #powerTip.sw:before {
+  border: solid transparent;
+  content: " ";
+  height: 0;
+  width: 0;
+  position: absolute;
+}
+
+#powerTip.n:after,  #powerTip.s:after,
+#powerTip.w:after,  #powerTip.e:after,
+#powerTip.nw:after, #powerTip.ne:after,
+#powerTip.sw:after, #powerTip.se:after {
+  border-color: rgba(255, 255, 255, 0);
+}
+
+#powerTip.n:before,  #powerTip.s:before,
+#powerTip.w:before,  #powerTip.e:before,
+#powerTip.nw:before, #powerTip.ne:before,
+#powerTip.sw:before, #powerTip.se:before {
+  border-color: rgba(128, 128, 128, 0);
+}
+
+#powerTip.n:after,  #powerTip.n:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.nw:after, #powerTip.nw:before {
+  top: 100%;
+}
+
+#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after {
+  border-top-color: #ffffff;
+  border-width: 10px;
+  margin: 0px -10px;
+}
+#powerTip.n:before {
+  border-top-color: #808080;
+  border-width: 11px;
+  margin: 0px -11px;
+}
+#powerTip.n:after, #powerTip.n:before {
+  left: 50%;
+}
+
+#powerTip.nw:after, #powerTip.nw:before {
+  right: 14px;
+}
+
+#powerTip.ne:after, #powerTip.ne:before {
+  left: 14px;
+}
+
+#powerTip.s:after,  #powerTip.s:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.sw:after, #powerTip.sw:before {
+  bottom: 100%;
+}
+
+#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after {
+  border-bottom-color: #ffffff;
+  border-width: 10px;
+  margin: 0px -10px;
+}
+
+#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before {
+  border-bottom-color: #808080;
+  border-width: 11px;
+  margin: 0px -11px;
+}
+
+#powerTip.s:after, #powerTip.s:before {
+  left: 50%;
+}
+
+#powerTip.sw:after, #powerTip.sw:before {
+  right: 14px;
+}
+
+#powerTip.se:after, #powerTip.se:before {
+  left: 14px;
+}
+
+#powerTip.e:after, #powerTip.e:before {
+  left: 100%;
+}
+#powerTip.e:after {
+  border-left-color: #ffffff;
+  border-width: 10px;
+  top: 50%;
+  margin-top: -10px;
+}
+#powerTip.e:before {
+  border-left-color: #808080;
+  border-width: 11px;
+  top: 50%;
+  margin-top: -11px;
+}
+
+#powerTip.w:after, #powerTip.w:before {
+  right: 100%;
+}
+#powerTip.w:after {
+  border-right-color: #ffffff;
+  border-width: 10px;
+  top: 50%;
+  margin-top: -10px;
+}
+#powerTip.w:before {
+  border-right-color: #808080;
+  border-width: 11px;
+  top: 50%;
+  margin-top: -11px;
+}
+
+@media print
+{
+  #top { display: none; }
+  #side-nav { display: none; }
+  #nav-path { display: none; }
+  body { overflow:visible; }
+  h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
+  .summary { display: none; }
+  .memitem { page-break-inside: avoid; }
+  #doc-content
+  {
+    margin-left:0 !important;
+    height:auto !important;
+    width:auto !important;
+    overflow:inherit;
+    display:inline;
+  }
+}
+
+/* @group custom modifications */
+
+#top {
+  background-color: #2980B9;
+  color: #fcfcfc;
+  font-weight: normal;
+}
+
+div.header {
+  background-color: #343131;
+  background-image: none;
+  border-bottom: none;
+  background-color: #FFFFFF;
+}
+
+#nav-tree {
+  background-color: #343131;
+  background-image: none;
+}
+
+#nav-tree a {
+  color: #b3b3b3;
+  line-height: 18px;
+  font-size: 110%;
+  font-family: "Lato", "proxima-nova", "Helvetica Neue", Arial, sans-serif;
+}
+
+#nav-tree .selected {
+  background-image: none;
+}
+
+div .ui-resizable-handle.ui-resizable-e {
+  width: 0px;
+}
+
+div#main-nav ul.sm.sm-dox {
+  background-image: none;
+  border-top: none;
+}
+
+.sm-dox a {
+  background-image: none;
+  color: #fcfcfc;
+  font-size: 110%;
+  font-family: "Lato", "proxima-nova", "Helvetica Neue", Arial, sans-serif;
+  text-shadow: none;
+}
+
+.sm-dox a:hover {
+  background-image: none;
+  color: #fcfcfc;
+  font-size: 110%;
+  font-family: "Lato", "proxima-nova", "Helvetica Neue", Arial, sans-serif;
+}
+
+li.footer {
+  display: none;
+}
+
+div#nav-path ul {
+    background-image: none;
+    border: none;
+}
+
+.memproto {
+  background-image: none;
+  -webkit-box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
+  border-bottom: 1px solid #d1d5da;
+  border-left: 1px solid #d1d5da;
+  border-right: 1px solid #d1d5da;
+  background-color: #f6f8fa;
+}
+
+.memdoc {
+  background-image: none;
+  -webkit-box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
+  border-bottom: 1px solid #d1d5da;
+  border-left: 1px solid #d1d5da;
+  border-right: 1px solid #d1d5da;
+}
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/latexextras.template b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/latexextras.template
new file mode 100644
index 0000000000000000000000000000000000000000..352d89e27ef60b4e3bce7233bb0ac48e73ca4cda
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/latexextras.template
@@ -0,0 +1,15 @@
+% Additional LaTeX inclusions for mtoc++/doxygen tools
+%
+% Use the _ConfDir_ tag to insert the folder where this file resides.
+% Thus you can include more custom latex files/styles/packages which reside in this folder  
+
+% Default packages
+\usepackage{amsmath}
+\usepackage{amssymb}
+
+% Inclusion example:
+% Please note that, independent of windows or unix, latex uses forward-slash-type paths in bibliography.
+%\input{_ConfDirFwdSlash_/myexternalstyle.sty}
+\setcounter{tocdepth}{2}
+
+%\uchyph=0
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp
new file mode 100644
index 0000000000000000000000000000000000000000..bf9aabd13855997acf1e9b5df6ae230a613876c8
Binary files /dev/null and b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp differ
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp.conf b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp.conf
new file mode 100644
index 0000000000000000000000000000000000000000..2a792649a1a1e446f1898974cd627940a2eddb75
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp.conf
@@ -0,0 +1,107 @@
+# ########################### mtoc++ configuration file ############################
+# This configuration file is not mandatory.
+# All default values are also hardcoded in mtocpp.
+
+# ########################### mtoc++ variables ############################
+# File Patterns
+# ALL := *.m;
+
+# Flag indicating whether automatic struct fields or object members
+# documentation is generated.
+# The fields documentation types are
+#  - required fields,
+#  - optional fields and
+#  - generated fields.
+PRINT_FIELDS := false;
+
+# Flag indicating whether undocumented field names are added to documentation
+# with documentation text equal to the field name.
+AUTO_ADD_FIELDS := false;
+
+# Flag indicating whether undocumented parameters and return values are added
+# to documentation with documentation text equal to the parameter / return
+# value name.
+AUTO_ADD_PARAMETERS := false;
+
+# Flag indicating whether undocumented member variables are added to
+# documentation with documentation text equal to the parameter / return value
+# name.
+AUTO_ADD_CLASS_PROPERTIES := false;
+
+# Flag indicating whether undocumented classes are added to documentation with
+# documentation text equal to the class name.
+# AUTO_ADD_CLASSES := true;
+
+# Flag indication whether the first argument in abstract non-static methods
+# shall be a this pointer, and therefore removed in the C++ output.
+# REMOVE_FIRST_ARG_IN_ABSTRACT_METHODS := true
+
+# Flag indicating whether the string "of type" is parsed in the the first two
+# lines
+#   - of the documentation header of properties and
+#   - the documentation block of method/function parameters and return values.
+# If enabled, the word following the string "of type" is interpreted as the
+# type for the class property, the parameter or the return value. This
+# equivalent to using the mtocpp @type keyword, but enables the user to write
+# documentation also read-able in doc strings created with the MATLAB commands
+# 'help' or 'doc'.
+ENABLE_OF_TYPE_PARSING := false;
+
+# Flag indicating whether the typename void shall be inserted for return values
+# with no specified type. If this is not set to true, the typename is
+# eliminated in the output by the postprocessor.
+VOID_TYPE_IN_RETURN_VALUES := false;
+
+# Integer flag indicating whether return value names shall be printed in the
+# function synopsis. If this flag is deactivated only the type names are
+# written.
+# The flag can be set to either 0, 1 or 2:
+#   - 0: means that no return value names shall be printed at all.
+#   - 1: means that return value names shall be printed for return value lists
+#        with more than one element only.
+#   - 2: means that return value names shall be printed always.
+PRINT_RETURN_VALUE_NAME := 0;
+
+# Flag indicating whether the documentation of fields in 'Required fields of param',
+# 'Optional fields of param' or 'Generated fields of retval' shall be copied,
+# in case the Parameter 'param' or 'retval' have a type.
+COPY_TYPIFIED_FIELD_DOCU := false;
+
+# Flag indicating whether  documentation for subfunctions shall be generated.
+# By default their documentation strings are ignored.
+GENERATE_SUBFUNTION_DOCUMENTATION := true;
+
+# Leave this ## there, it marks the end of variable definitions 
+# and switches the parser to mtoc++ rules!
+## 
+
+# ########################### mtoc++ rules ############################
+
+# ###############################################################
+# Default documentation for parameters
+# ###############################################################
+# Syntax:
+# add(params) = <pname> => """ <text> """;
+
+# ###############################################################
+# Default documentation for fields
+# ###############################################################
+# Syntax:
+# add(fields) = ( <pname>.<fieldname1> => """ <text1> """,
+#                 <pname>.<fieldname2> => """ <text2> """);
+
+# ###############################################################
+# Global group settings
+# ###############################################################
+# Syntax:
+# glob = <folder or filename (regexp allowed)> {
+#  groups = <groupref>;
+#  add(doc)      = """ <some extra doc for all files> """;
+#  add(extra)    = """ <text at end of comments> """;
+#  glob = <subfolder or files> {
+#    <statements>
+#  };
+# }
+ 
+# add(doc)      = """ docu for all functions !!! """;
+# add(extra)    = """ extra comments: @ref s_rand !!!! """;
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp_post b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp_post
new file mode 100644
index 0000000000000000000000000000000000000000..002c61daba43bb0a3a2cff7aef514cec6178012b
Binary files /dev/null and b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/config/mtocpp_post differ
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/makeDocumentation.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/makeDocumentation.m
new file mode 100644
index 0000000000000000000000000000000000000000..f9356203bc3c85beda5528aa7b0a3a26ed5bde09
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/mtoc/makeDocumentation.m
@@ -0,0 +1,5 @@
+setenv('PATH', [getenv('PATH') ':/Library/TeX/texbin/'])
+setenv('PATH', [getenv('PATH') ':/usr/local/bin'])
+MatlabDocMaker.create('latex',true)
+[wrap_path,~,~] = fileparts(fileparts(which('amiwrap.m')));
+movefile(fullfile(wrap_path,'doc','latex','refman.pdf'),fullfile(wrap_path,'AMICI_guide.pdf'))
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_and.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_and.m
new file mode 100644
index 0000000000000000000000000000000000000000..6362b6e8a05cbaefebbe307f4125d17e21db33b7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_and.m
@@ -0,0 +1,11 @@
+function fun = am_and(a,b)
+% am_and is the amici implementation of the symbolic and function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+fun = am_min(a,b);
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_eq.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_eq.m
new file mode 100644
index 0000000000000000000000000000000000000000..6ede0e56090c8fce247a54eb3fa47e6bfc59f2ea
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_eq.m
@@ -0,0 +1,10 @@
+function fun = am_eq(varargin)
+% am_eq is currently a placeholder that simply produces an error message
+%
+% Parameters:
+%  varargin: elements for chain of equalities 
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+error('Logical operator ''eq'' is currently not supported!');
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_ge.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_ge.m
new file mode 100644
index 0000000000000000000000000000000000000000..8225db70699ae07cba3b6d2b53925ebe1ac0f43e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_ge.m
@@ -0,0 +1,17 @@
+function fun = am_ge(varargin)
+% am_ge is the amici implementation of the n-ary mathml greaterorequal function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} >= varargin{2},varargin{2} >= varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a >= b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = a-b;
+if(nargin>2)
+    fun = am_and(a-b,am_ge(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_gt.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_gt.m
new file mode 100644
index 0000000000000000000000000000000000000000..3c076b3ab076170c8b775441ebc26ec3ad6a5586
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_gt.m
@@ -0,0 +1,17 @@
+function fun = am_gt(varargin)
+% am_gt is the amici implementation of the n-ary mathml greaterthan function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} > varargin{2},varargin{2} > varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a > b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = a-b;
+if(nargin>2)
+    fun = am_and(a-b,am_gt(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_if.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_if.m
new file mode 100644
index 0000000000000000000000000000000000000000..6673023a68a8c4af7a62d61e91df2942f43c3e30
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_if.m
@@ -0,0 +1,24 @@
+function fun = am_if(condition, truepart, falsepart)
+% am_if is the amici implementation of the symbolic if function
+%
+% Parameters:
+%  condition: logical value @type sym
+%  truepart: value if condition is true @type sym
+%  falsepart: value if condition is false @type sym
+%
+% Return values:
+%  fun: if condition is true truepart, else falsepart
+if(islogical(condition))
+    if(condition)
+        fun = truepart;
+    else
+        fun = falsepart;
+    end
+else
+    if(logical(condition~=0))
+        fun = falsepart + heaviside(condition)*(truepart-falsepart);
+    else
+        fun = falsepart;
+    end
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_le.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_le.m
new file mode 100644
index 0000000000000000000000000000000000000000..3016b7d6b2414d6c49934f3937b52c161f40667c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_le.m
@@ -0,0 +1,17 @@
+function fun = am_le(varargin)
+% am_le is the amici implementation of the n-ary mathml lessorequal function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} <= varargin{2},varargin{2} <= varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a <= b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = b-a;
+if(nargin>2)
+    fun = am_and(b-a,am_le(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_lt.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_lt.m
new file mode 100644
index 0000000000000000000000000000000000000000..67ec79f6019eac2a7778ae51a1c6fe45343c2e5c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_lt.m
@@ -0,0 +1,17 @@
+function fun = am_lt(varargin)
+% am_lt is the amici implementation of the n-ary mathml lessthan function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} < varargin{2},varargin{2} < varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a < b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = b-a;
+if(nargin>2)
+    fun = am_and(b-a,am_lt(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_max.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_max.m
new file mode 100644
index 0000000000000000000000000000000000000000..54ba55fd0bf56b84c20cd16fdd807b2025bdcf1c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_max.m
@@ -0,0 +1,11 @@
+function fun = am_max(a, b)
+% am_max is the amici implementation of the symbolic max function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: maximum of a and b
+fun = sym(['am_max(' char(sym(a)) ',' char(sym(b)) ',0.0)']);
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_min.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_min.m
new file mode 100644
index 0000000000000000000000000000000000000000..068d2dc2d6721fb3b2ba526ea7784e0ffaef1f11
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_min.m
@@ -0,0 +1,11 @@
+function fun = am_min(a, b)
+% am_min is the amici implementation of the symbolic min function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: minimum of a and b
+fun = -am_max(-a,-b);
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_or.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_or.m
new file mode 100644
index 0000000000000000000000000000000000000000..e948070061b08d2fe71354750f5b8bb54913b055
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_or.m
@@ -0,0 +1,11 @@
+function fun = am_or(a,b)
+% am_or is the amici implementation of the symbolic or function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+fun = am_max(a,b);
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_piecewise.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_piecewise.m
new file mode 100644
index 0000000000000000000000000000000000000000..7a9be67bff3b6f3f916351a2c9cecabd56091b8c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_piecewise.m
@@ -0,0 +1,13 @@
+function fun = am_piecewise( piece,condition,default )
+% am_piecewise is the amici implementation of the mathml piecewise function
+%
+% Parameters:
+%  piece: value if condition is true
+%  condition: logical value
+%  default: value if condition is false
+%
+% Return values:
+%  fun: return value, piece if condition is true, default if not
+    fun = am_if(condition,piece,default);
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_spline.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_spline.m
new file mode 100644
index 0000000000000000000000000000000000000000..ff33784f66a0ff3b1b229a1ed3c0f19bcf0a9ae1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_spline.m
@@ -0,0 +1,14 @@
+function splinefun = am_spline(varargin)
+    n = nargin;
+    str= '';
+    if (round(n/2) - n/2 < 0.1)
+        error('Input arguments of am_spline must have the following form: t, t1, p2, ..., tn, pn, intss, dudt');
+    end
+    for i = 1 : n-1
+        str = strcat(strcat(str, char(varargin{i})), ',');
+    end
+    str = strcat('(',strcat(strcat(str, char(varargin{n})), ')'));
+    str = strrep(str, ' ', '');
+    str = regexprep(str,'\,([0-9]*)\,','\,$1\.0\,'); % Black magic of sym
+    splinefun = sym(strcat('spline', str));
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_spline_pos.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_spline_pos.m
new file mode 100644
index 0000000000000000000000000000000000000000..32775d48e6f0a8b306aacb57359459908a86f0ba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_spline_pos.m
@@ -0,0 +1,33 @@
+function splinefun = am_spline_pos(varargin)
+    n = nargin;
+    str= '';
+    if (round(n/2) - n/2 > 0.1)
+        error('Input arguments of am_spline must have the following form: t, #ofNodes, t1, p1, ..., tn, pn, intss, dudt');
+    end
+    for i = 1 : n
+        if (i < n)
+            switch class(varargin{i})
+                case 'sym'
+                    str = strcat(strcat(str, char(vpa(varargin{i}))), ',');
+                case 'double'
+                    str = strcat(strcat(str, char(vpa(sym(varargin{i}))), ','));
+                otherwise
+                    error(['Input argument ' num2str(i) ' of the splinefunction seems to be neither a symbolic nor a double. Please check, if it is correctly defined.']);
+            end
+        else
+            switch class(varargin{i})
+                case 'sym'
+                    str = strcat(str, char(vpa(varargin{i})));
+                case 'double'
+                    str = strcat(str, char(vpa(sym(varargin{i}))));
+                otherwise
+                    error(['Input argument ' num2str(i) ' of the splinefunction seems to be neither a symbolic nor a double. Please check, if it is correctly defined.']);
+            end
+        end
+
+    end
+    str = strcat('(',strcat(strcat(str, char(varargin{n})), ')'));
+    str = strrep(str, ' ', '');
+    
+    splinefun = sym(strcat('spline_pos', str));
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_stepfun.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_stepfun.m
new file mode 100644
index 0000000000000000000000000000000000000000..53749f1d4c7c4b8bf45529851423452d485d6419
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_stepfun.m
@@ -0,0 +1,14 @@
+function fun = am_stepfun(t,tstart,vstart,tend,vend)
+% am_stepfun is the amici implementation of the step function 
+%
+% Parameters:
+%  t: input variable @type sym
+%  tstart: input variable value at which the step starts
+%  vstart: value during the step
+%  tend: input variable value at which the step end
+%  vend: value after the step
+%
+% Return values:
+%  fun: 0 before tstart, vstart between tstart and tend and vend after tend
+fun = heaviside(t-tstart)*vstart - heaviside(t-tend)*(vstart-vend);
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_xor.m b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_xor.m
new file mode 100644
index 0000000000000000000000000000000000000000..9f8b26a238f42ba7b14590c2cbc023d3432c7dae
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/matlab/symbolic/am_xor.m
@@ -0,0 +1,12 @@
+function fun = am_xor(a,b)
+% am_xor is the amici implementation of the symbolic exclusive or function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+
+fun = am_and(am_or(a,b),-am_and(a,b));
+end
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/pytest.ini b/Requirements/AMICI-0.10.11_SS_eventFix/pytest.ini
new file mode 100644
index 0000000000000000000000000000000000000000..8917fb87d5964cb1acfc8bcacace3239f8fbd3ce
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/pytest.ini
@@ -0,0 +1,4 @@
+[pytest]
+# hundreds of SBML <=5.17 warnings
+filterwarnings =
+    ignore:.*inspect.getargspec\(\) is deprecated.*:DeprecationWarning
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/python/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8d8d164a150966afd40f6adc4a7e18dbb43df1f7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/CMakeLists.txt
@@ -0,0 +1,40 @@
+if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
+    if(DEFINED ENV{PYTHON_EXECUTABLE})
+        set( PYTHON_EXECUTABLE $ENV{PYTHON_EXECUTABLE} )
+    endif()
+    find_package(PythonInterp 3.6 REQUIRED)
+    set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
+else()
+    find_package (Python3 COMPONENTS Interpreter)
+endif()
+
+
+add_custom_target(install-python
+    COMMENT "Installing AMICI base python package"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/sdist
+    COMMAND ${Python3_EXECUTABLE} setup.py install --prefix= --user)
+
+
+# Create python wheel
+# Note that we have to run build_ext explicitely before bdist_wheel, otherwise the swig-generated
+# amici.py will not be added to the module build folder, because it does not yet exist at the
+# build_py stage
+add_custom_target(python-wheel
+    COMMENT "Creating wheel for AMICI base python package"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/sdist
+    COMMAND ${Python3_EXECUTABLE} setup.py build_ext
+    COMMAND ${Python3_EXECUTABLE} setup.py bdist_wheel --dist-dir=${CMAKE_CURRENT_BINARY_DIR}
+)
+
+
+add_custom_target(python-sdist
+    COMMENT "Creating sdist for AMICI base python package"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/sdist
+    COMMAND ${Python3_EXECUTABLE} setup.py sdist --dist-dir=${CMAKE_CURRENT_BINARY_DIR}
+)
+
+
+add_custom_command(
+    OUTPUT always_rebuild
+    COMMAND cmake -E echo
+    )
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/MANIFEST.template.in b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/MANIFEST.template.in
new file mode 100644
index 0000000000000000000000000000000000000000..eb3b1b450fdc3eaa0176315e3fdb79c5b0910d75
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/MANIFEST.template.in
@@ -0,0 +1 @@
+include *.cpp *.h
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/__init__.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fdf6654add15f5fb1bfbfcc9ac95408e523ade0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/__init__.py
@@ -0,0 +1,180 @@
+""" @package amici
+The AMICI Python module (in doxygen this will also contain documentation about the C++ library)
+
+The AMICI Python module provides functionality for importing SBML models and turning them into C++ Python extensions.
+
+Getting started:
+```
+# creating a extension module for an SBML model:
+import amici
+amiSbml = amici.SbmlImporter('mymodel.sbml')
+amiSbml.sbml2amici('modelName', 'outputDirectory')
+
+# using the created module (set python path)
+import modelName
+help(modelName)
+```
+
+Attributes:
+    amici_path: absolute root path of the amici repository
+    amiciSwigPath: absolute path of the amici swig directory
+    amiciSrcPath: absolute path of the amici source directory
+    amiciModulePath: absolute root path of the amici module
+    hdf5_enabled: boolean indicating if amici was compiled with hdf5 support
+    has_clibs: boolean indicating if this is the full package with swig
+               interface or the raw package without
+    capture_cstdout: context to redirect C/C++ stdout to python stdout if
+        python stdout was redirected (doing nothing if not redirected).
+"""
+
+import os
+import re
+import sys
+from contextlib import suppress
+
+# redirect C/C++ stdout to python stdout if python stdout is redirected,
+# e.g. in ipython notebook
+capture_cstdout = suppress
+if sys.stdout != sys.__stdout__:
+    try:
+        from wurlitzer import sys_pipes as capture_cstdout
+    except ModuleNotFoundError:
+        pass
+
+hdf5_enabled = False
+has_clibs = False
+
+try:
+    from . import amici
+    from .amici import *
+    hdf5_enabled = True
+    has_clibs = True
+except (ImportError, ModuleNotFoundError, AttributeError):  # pragma: no cover
+    try:
+        from . import amici_without_hdf5 as amici
+        from .amici_without_hdf5 import *
+        has_clibs = True
+    except (ImportError, ModuleNotFoundError, AttributeError):
+        pass
+
+# determine package installation path, or, if used directly from git
+# repository, get repository root
+if os.path.exists(os.path.join(os.path.dirname(__file__), '..', '..', '.git')):
+    amici_path = os.path.abspath(os.path.join(
+        os.path.dirname(__file__), '..', '..'))
+else:
+    amici_path = os.path.dirname(__file__)
+
+amiciSwigPath = os.path.join(amici_path, 'swig')
+amiciSrcPath = os.path.join(amici_path, 'src')
+amiciModulePath = os.path.dirname(__file__)
+
+# Get version number from file
+with open(os.path.join(amici_path, 'version.txt')) as f:
+    __version__ = f.read().strip()
+
+# get commit hash from file
+_commitfile = next(
+    (
+        file for file in [
+            os.path.join(amici_path, '..', '..', '..', '.git', 'FETCH_HEAD'),
+            os.path.join(amici_path, '..', '..', '..', '.git', 'ORIG_HEAD'),
+        ]
+        if os.path.isfile(file)
+    ),
+    None
+)
+
+if _commitfile:
+    with open(_commitfile) as f:
+        __commit__ = str(re.search(r'^([\w]*)', f.read().strip()).group())
+else:
+    __commit__ = 'unknown'
+
+
+try:
+    # These module require the swig interface and other dependencies which will
+    # be installed if the the AMICI package was properly installed. If not,
+    # AMICI was probably imported from setup.py and we don't need those.
+    from .sbml_import import SbmlImporter, assignmentRules2observables
+    from .numpy import ReturnDataView, ExpDataView
+    from .pandas import getEdataFromDataFrame, \
+        getDataObservablesAsDataFrame, getSimulationObservablesAsDataFrame, \
+        getSimulationStatesAsDataFrame, getResidualsAsDataFrame
+    from .ode_export import ODEModel, ODEExporter
+    from .pysb_import import pysb2amici, ODEModel_from_pysb_importer
+except ImportError:
+    pass
+
+
+def runAmiciSimulation(model, solver, edata=None):
+    """ Convenience wrapper around amici.runAmiciSimulation (generated by swig)
+
+    Arguments:
+        model: Model instance
+        solver: Solver instance, must be generated from Model.getSolver()
+        edata: ExpData instance (optional)
+
+    Returns:
+        ReturnData object with simulation results
+
+    Raises:
+
+    """
+    if edata and edata.__class__.__name__ == 'ExpDataPtr':
+        edata = edata.get()
+
+    with capture_cstdout():
+        rdata = amici.runAmiciSimulation(solver.get(), edata, model.get())
+    return numpy.ReturnDataView(rdata)
+
+
+def ExpData(*args):
+    """ Convenience wrapper for ExpData constructors
+
+    Arguments:
+        args: arguments
+
+    Returns:
+        ExpData Instance
+
+    Raises:
+
+    """
+    if isinstance(args[0], ReturnDataView):
+        return amici.ExpData(args[0]['ptr'].get(), *args[1:])
+    elif isinstance(args[0], ExpDataPtr):
+        # the *args[:1] should be empty, but by the time you read this,
+        # the constructor signature may have changed and you are glad this
+        # wrapper did not break.
+        return amici.ExpData(args[0].get(), *args[:1])
+    else:
+        return amici.ExpData(*args)
+
+
+def runAmiciSimulations(model, solver, edata_list, failfast=True,
+                        num_threads=1):
+    """ Convenience wrapper for loops of amici.runAmiciSimulation
+
+    Arguments:
+        model: Model instance
+        solver: Solver instance, must be generated from Model.getSolver()
+        edata_list: list of ExpData instances
+        failfast: returns as soon as an integration failure is encountered
+        num_threads: number of threads to use
+                     (only used if compiled with openmp)
+
+    Returns:
+        list of ReturnData objects with simulation results
+
+    Raises:
+
+    """
+    with capture_cstdout():
+        edata_ptr_vector = amici.ExpDataPtrVector(edata_list)
+        rdata_ptr_list = amici.runAmiciSimulations(solver.get(),
+                                                   edata_ptr_vector,
+                                                   model.get(),
+                                                   failfast,
+                                                   num_threads)
+    return [numpy.ReturnDataView(r) for r in rdata_ptr_list]
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/__init__.template.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/__init__.template.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68a5bae90f1ad46f0145a268dd989f8238eeba9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/__init__.template.py
@@ -0,0 +1,16 @@
+"""AMICI-generated module for model TPL_MODELNAME"""
+
+import amici
+
+# Ensure we are binary-compatible, see #556
+if 'TPL_AMICI_VERSION' != amici.__version__:
+    raise RuntimeError('Cannot use model TPL_MODELNAME, generated with AMICI '
+                       'version TPL_AMICI_VERSION, together with AMICI version'
+                       f' {amici.__version__} which is present in your '
+                       'PYTHONPATH. Install the AMICI package matching the '
+                       'model version or regenerate the model with the AMICI '
+                       'currently in your path.')
+
+from TPL_MODELNAME.TPL_MODELNAME import *
+
+__version__ = 'TPL_PACKAGE_VERSION'
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/gradient_check.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/gradient_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a6f73483a78bdb440aaa2da347e3e98436168f8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/gradient_check.py
@@ -0,0 +1,137 @@
+from . import (runAmiciSimulation, SensitivityOrder_none,
+               SensitivityMethod_forward)
+import numpy as np
+import copy
+
+
+def check_finite_difference(x0, model, solver, edata, ip, fields,
+                            assert_fun, atol=1e-4, rtol=1e-4, epsilon=1e-3):
+    old_sensitivity_order = solver.getSensitivityOrder()
+    old_parameters = model.getParameters()
+    old_plist = model.getParameterList()
+
+    # sensitivity
+    p = copy.deepcopy(x0)
+    plist = [ip]
+
+    model.setParameters(p)
+    model.setParameterList(plist)
+    rdata = runAmiciSimulation(model, solver, edata)
+
+    # finite difference
+    solver.setSensitivityOrder(SensitivityOrder_none)
+
+    # forward:
+    p = copy.deepcopy(x0)
+    p[ip] += epsilon/2
+    model.setParameters(p)
+    rdataf = runAmiciSimulation(model, solver, edata)
+
+    # backward:
+    p = copy.deepcopy(x0)
+    p[ip] -= epsilon/2
+    model.setParameters(p)
+    rdatab = runAmiciSimulation(model, solver, edata)
+
+    for field in fields:
+        sensi_raw = rdata[f's{field}']
+        fd = (rdataf[field]-rdatab[field])/epsilon
+        if len(sensi_raw.shape) == 1:
+            sensi = sensi_raw[0]
+        elif len(sensi_raw.shape) == 2:
+            sensi = sensi_raw[:, 0]
+        elif len(sensi_raw.shape) == 3:
+            sensi = sensi_raw[:, 0, :]
+        else:
+            assert_fun(False)  # not implemented
+
+        check_close(sensi, fd, assert_fun, atol, rtol, field, ip=ip)
+
+    solver.setSensitivityOrder(old_sensitivity_order)
+    model.setParameters(old_parameters)
+    model.setParameterList(old_plist)
+
+
+def check_derivatives(model, solver, edata, assert_fun,
+                      atol=1e-4, rtol=1e-4, epsilon=1e-3):
+    """Finite differences check for likelihood gradient
+
+    Arguments:
+        model: amici model
+        solver: amici solver
+        edata: exp data
+        atol: absolute tolerance
+        rtol: relative tolerance
+        epsilon: finite difference step-size
+    """
+    from scipy.optimize import check_grad
+
+    p = np.array(model.getParameters())
+
+    rdata = runAmiciSimulation(model, solver, edata)
+
+    fields = ['llh']
+
+    leastsquares_applicable = \
+        solver.getSensitivityMethod() == SensitivityMethod_forward
+
+    if 'ssigmay' in rdata.keys():
+        if rdata['ssigmay'] is not None:
+            if rdata['ssigmay'].any():
+                leastsquares_applicable = False
+
+    if leastsquares_applicable:
+        fields += ['res', 'x', 'y']
+
+        check_results(rdata, 'FIM',
+                      np.dot(rdata['sres'].transpose(), rdata['sres']),
+                      assert_fun,
+                      1e-8, 1e-4)
+        check_results(rdata, 'sllh',
+                      -np.dot(rdata['res'].transpose(), rdata['sres']),
+                      assert_fun,
+                      1e-8, 1e-4)
+    for ip in range(len(p)):
+        check_finite_difference(p, model, solver, edata, ip, fields,
+                                assert_fun, atol=atol, rtol=rtol,
+                                epsilon=epsilon)
+
+
+def check_close(result, expected, assert_fun, atol, rtol, field, ip=None):
+    close = np.isclose(result, expected, atol=atol, rtol=rtol, equal_nan=True)
+
+    if not close.all():
+        if ip is None:
+            index_str = ''
+            check_type = 'Regression check  '
+        else:
+            index_str = f'at index ip={ip} '
+            check_type = 'FD check '
+        print(f'{check_type} failed for {field} {index_str}for '
+              f'{close.size - close.sum()} indices:')
+        adev = np.abs(result - expected)
+        rdev = np.abs((result - expected)/(expected + atol))
+        print(f'max(adev): {adev.max()}, max(rdev): {rdev.max()}')
+
+    assert_fun(close.all())
+
+
+def check_results(rdata, field, expected, assert_fun, atol, rtol):
+    """
+    checks whether rdata[field] agrees with expected according to provided
+    tolerances
+
+    Arguments:
+        rdata: simulation results as returned by amici.runAmiciSimulation
+        field: name of the field to check
+        expected: expected test results
+        atol: absolute tolerance
+        rtol: relative tolerance
+    """
+
+    result = rdata[field]
+    if type(result) is float:
+        result = np.array(result)
+
+    check_close(result, expected, assert_fun, atol, rtol, field)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/numpy.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb27364939f14302f35b73cd4bd2f30af22306a5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/numpy.py
@@ -0,0 +1,303 @@
+import numpy as np
+import copy
+import collections
+from . import ExpDataPtr, ReturnDataPtr, ExpData, ReturnData
+
+
+class SwigPtrView(collections.abc.Mapping):
+    """ Interface class to expose std::vector<double> and scalar members of
+    swig wrapped C++ objects as numpy array attributes and fields. This
+    class is memory efficient as copies of the underlying C++ objects is
+    only created when respective fields are accessed for the first time.
+    Cached copies are used for all subsequent calls.
+
+    Attributes:
+        _swigptr: pointer to the c++ object
+            @type SwigPtr
+        _field_names: names of members that will be exposed as numpy arrays
+            @type list
+        _field_dimensions: dimensions of numpy arrays @type list
+        _cache: dictionary with cached values @type dict
+    """
+
+    _swigptr = None
+    _field_names = []
+    _field_dimensions = dict()
+
+    def __getitem__(self, item):
+        """Access to field names, copies data from C++ object into numpy
+        array, reshapes according to field dimensions and stores values in
+        cache.
+
+        Arguments:
+            item: field name
+
+        Returns:
+            value @type numpy.array or float
+        """
+        if self._swigptr is None:
+            raise NotImplementedError('Cannot get items from abstract class.')
+
+        if item == 'ptr':
+            return self._swigptr
+
+        if item in self._cache:
+            return self._cache[item]
+
+        if item not in self._field_names:
+            self.__missing__(item)
+
+        value = fieldAsNumpy(
+            self._field_dimensions, item, self._swigptr
+        )
+        self._cache[item] = value
+        return value
+
+    def __missing__(self, key):
+        """Default behaviour for missing keys
+
+        Arguments:
+            key: field name
+
+        Returns:
+
+        Raises:
+            KeyError
+        """
+        raise KeyError(f'Unknown field name {key}.')
+
+    def __getattr__(self, item):
+        """Attribute accessor for field names
+
+        Arguments:
+            item: field name
+
+        Returns:
+            value @type numpy.array or float
+        """
+        return self.__getitem__(item)
+
+    def __init__(self, swigptr):
+        """Constructor
+
+        Arguments:
+            swigptr: pointer to the C++ object
+
+        """
+        self._swigptr = swigptr
+        self._cache = dict()
+        super(SwigPtrView, self).__init__()
+
+    def __len__(self):
+        """Returns the number of available keys/fields
+
+        Returns:
+            length of _field_names @type int
+        """
+        return len(self._field_names)
+
+    def __iter__(self):
+        """Create an iterator of the keys/fields
+
+        Returns:
+            iterator over _field_names @type iter
+        """
+        return iter(self._field_names)
+
+    def __copy__(self):
+        """Create a shallow copy
+
+        Arguments:
+
+        Returns:
+            SwigPtrView shallow copy @type SwigPtrView
+        """
+        other = SwigPtrView(self._swigptr)
+        other._field_names = self._field_names
+        other._field_dimensions = self._field_dimensions
+        other._cache = self._cache
+        return other
+
+    def __contains__(self, item):
+        """Faster implementation of __contains__ that avoids copy of the field
+
+        Arguments:
+
+        Returns:
+            whether item is available as key @type bool
+        """
+        return item in self._field_names
+
+    def __deepcopy__(self, memo):
+        """Create a deep copy
+
+        Arguments:
+
+        Returns:
+            SwigPtrView deep copy @type SwigPtrView
+        """
+        other = SwigPtrView(self._swigptr)
+        other._field_names = copy.deepcopy(self._field_names)
+        other._field_dimensions = copy.deepcopy(self._field_dimensions)
+        other._cache = copy.deepcopy(self._cache)
+        return other
+
+
+class ReturnDataView(SwigPtrView):
+    """ Interface class for C++ Return Data objects that avoids possibly costly
+    copies of member data.
+    """
+
+    _field_names = [
+        'ts', 'x', 'x0', 'x_ss', 'sx', 'sx0', 'sx_ss', 'y', 'sigmay',
+        'sy', 'ssigmay', 'z', 'rz', 'sigmaz', 'sz', 'srz',
+        'ssigmaz', 'sllh', 's2llh', 'J', 'xdot', 'status', 'llh',
+        'chi2', 'res', 'sres', 'FIM', 'wrms_steadystate', 't_steadystate',
+        'newton_numlinsteps', 'newton_numsteps', 'newton_cpu_time',
+        'numsteps', 'numrhsevals', 'numerrtestfails',
+        'numnonlinsolvconvfails', 'order', 'cpu_time',
+        'numstepsB','numrhsevalsB', 'numerrtestfailsB',
+        'numnonlinsolvconvfailsB', 'cpu_timeB'
+    ]
+
+    def __init__(self, rdata):
+        """Constructor
+
+        Arguments:
+            rdata: pointer to the ReturnData instance
+
+        """
+        if not isinstance(rdata, (ReturnDataPtr, ReturnData)):
+            raise TypeError(f'Unsupported pointer {type(rdata)}, must be'
+                            f'amici.ExpDataPtr!')
+        self._field_dimensions = {
+            'ts': [rdata.nt],
+            'x': [rdata.nt, rdata.nx],
+            'x0': [rdata.nx],
+            'x_ss': [rdata.nx],
+            'sx': [rdata.nt, rdata.nplist, rdata.nx],
+            'sx0': [rdata.nplist, rdata.nx],
+            'sx_ss': [rdata.nplist, rdata.nx],
+
+            # observables
+            'y': [rdata.nt, rdata.ny],
+            'sigmay': [rdata.nt, rdata.ny],
+            'sy': [rdata.nt, rdata.nplist, rdata.ny],
+            'ssigmay': [rdata.nt, rdata.nplist, rdata.ny],
+
+            # event observables
+            'z': [rdata.nmaxevent, rdata.nz],
+            'rz': [rdata.nmaxevent, rdata.nz],
+            'sigmaz': [rdata.nmaxevent, rdata.nz],
+            'sz': [rdata.nmaxevent, rdata.nplist, rdata.nz],
+            'srz': [rdata.nmaxevent, rdata.nplist, rdata.nz],
+            'ssigmaz': [rdata.nmaxevent, rdata.nplist, rdata.nz],
+
+            # objective function
+            'sllh': [rdata.nplist],
+            's2llh': [rdata.np, rdata.nplist],
+
+            'res': [rdata.nt * rdata.nytrue],
+            'sres': [rdata.nt * rdata.nytrue, rdata.nplist],
+            'FIM': [rdata.nplist, rdata.nplist],
+
+            # diagnosis
+            'J': [rdata.nx_solver, rdata.nx_solver],
+            'xdot': [rdata.nx_solver],
+            'newton_numlinsteps': [rdata.newton_maxsteps, 2],
+            'newton_numsteps': [1, 3],
+            'numsteps': [rdata.nt],
+            'numrhsevals': [rdata.nt],
+            'numerrtestfails': [rdata.nt],
+            'numnonlinsolvconvfails': [rdata.nt],
+            'order': [rdata.nt],
+            'numstepsB': [rdata.nt],
+            'numrhsevalsB': [rdata.nt],
+            'numerrtestfailsB': [rdata.nt],
+            'numnonlinsolvconvfailsB': [rdata.nt],
+        }
+        super(ReturnDataView, self).__init__(rdata)
+
+    def __getitem__(self, item):
+        """Custom getitem implementation shim to map `t` to `ts`
+
+        Arguments:
+            item field/attribute key
+
+        Returns:
+            self[item] @type numpy.array/float
+        """
+        if item == 't':
+            item = 'ts'
+        return super(ReturnDataView, self).__getitem__(item)
+
+
+class ExpDataView(SwigPtrView):
+    """ Interface class for C++ Exp Data objects that avoids possibly costly
+    copies of member data.
+    """
+
+    _field_names = [
+        'observedData', 'observedDataStdDev', 'observedEvents',
+        'observedEventsStdDev', 'fixedParameters',
+        'fixedParametersPreequilibration',
+        'fixedParametersPresimulation'
+    ]
+
+    def __init__(self, edata):
+        """Constructor
+
+        Arguments:
+            edata: pointer to the ExpData instance
+
+        """
+        if not isinstance(edata, (ExpDataPtr, ExpData)):
+            raise TypeError(f'Unsupported pointer {type(edata)}, must be'
+                            f'amici.ExpDataPtr!')
+        self._field_dimensions = {  # observables
+            'observedData': [edata.nt(), edata.nytrue()],
+            'observedDataStdDev': [edata.nt(), edata.nytrue()],
+
+            # event observables
+            'observedEvents': [edata.nmaxevent(), edata.nztrue()],
+            'observedEventsStdDev': [edata.nmaxevent(), edata.nztrue()],
+
+            # fixed parameters
+            'fixedParameters': [len(edata.fixedParameters)],
+            'fixedParametersPreequilibration': [
+                len(edata.fixedParametersPreequilibration)],
+            'fixedParametersPresimulation': [
+                len(edata.fixedParametersPreequilibration)],
+        }
+        edata.observedData = edata.getObservedData()
+        edata.observedDataStdDev = edata.getObservedDataStdDev()
+        edata.observedEvents = edata.getObservedEvents()
+        edata.observedEventsStdDev = edata.getObservedEventsStdDev()
+        super(ExpDataView, self).__init__(edata)
+
+
+def fieldAsNumpy(field_dimensions, field, data):
+    """ Convert data object field to numpy array with dimensions according to
+    specified field dimensions
+
+    Arguments:
+        field_dimensions: dimension specifications
+            dict({field: list([dim1, dim2, ...])})
+        data: object with fields
+        field: Name of field
+
+    Returns:
+        Field Data as numpy array with dimensions according to specified field
+        dimensions
+
+    Raises:
+
+    """
+    attr = getattr(data, field)
+    if field in field_dimensions.keys():
+        if len(attr) == 0:
+            return None
+        else:
+            return np.array(attr).reshape(field_dimensions[field])
+    else:
+        return float(attr)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/ode_export.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/ode_export.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfcb1fd97d200ead3ad28f6ea8c9b1e76f63e593
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/ode_export.py
@@ -0,0 +1,2847 @@
+""" @package amici.ode_export The C++ ODE export module for python
+"""
+#!/usr/bin/env python3
+
+import sympy as sp
+import re
+import shutil
+import subprocess
+import sys
+import os
+import copy
+import numbers
+import itertools
+try:
+    import pysb
+except ImportError:
+    ## pysb import dummy
+    pysb = None
+
+
+from string import Template
+import sympy.printing.ccode as ccode
+
+from . import (
+    amiciSwigPath, amiciSrcPath, amiciModulePath, __version__, __commit__
+)
+
+## Template for model simulation main.cpp file
+CXX_MAIN_TEMPLATE_FILE = os.path.join(amiciSrcPath, 'main.template.cpp')
+## Template for model/swig/CMakeLists.txt
+SWIG_CMAKE_TEMPLATE_FILE = os.path.join(amiciSwigPath,
+                                        'CMakeLists_model.cmake')
+## Template for model/CMakeLists.txt
+MODEL_CMAKE_TEMPLATE_FILE = os.path.join(amiciSrcPath,
+                                         'CMakeLists.template.cmake')
+
+## prototype for generated C++ functions, keys are the names of functions
+#
+# signature: defines the argument part of the function signature,
+# input variables
+# should have a const flag
+#
+# assume_pow_positivity: identifies the functions on which
+# assume_pow_positivity will have an effect when specified during model
+# generation. generally these are functions that are used for solving the
+# ODE, where negative values may negatively affect convergence of the
+# integration algorithm
+#
+# sparse: specifies whether the result of this function will be stored in
+# sparse format. sparse format means that the function will only return an
+# array of nonzero values and not a full matrix.
+functions = {
+    'J': {
+        'signature':
+            '(realtype *J, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w, const realtype *dwdx)',
+        'assume_pow_positivity':
+            True,
+    },
+    'JB': {
+        'signature':
+            '(realtype *JB, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *xB, const realtype *w, const realtype *dwdx)',
+        'assume_pow_positivity':
+            True,
+    },
+    'JDiag': {
+        'signature':
+            '(realtype *JDiag, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w, const realtype *dwdx)',
+        'assume_pow_positivity':
+            True,
+    },
+    'JSparse': {
+        'signature':
+            '(realtype *JSparse, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w, const realtype *dwdx)',
+        'sparse':
+            True,
+        'assume_pow_positivity':
+            True,
+    },
+    'JSparseB': {
+        'signature':
+            '(realtype *JSparseB, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *xB, const realtype *w, const realtype *dwdx)',
+        'sparse':
+            True,
+        'assume_pow_positivity':
+            True,
+    },
+    'Jy': {
+        'signature':
+            '(realtype *Jy, const int iy, const realtype *p, '
+            'const realtype *k, const realtype *y, const realtype *sigmay, '
+            'const realtype *my)',
+    },
+    'dJydsigmay': {
+        'signature':
+            '(realtype *dJydsigmay, const int iy, const realtype *p, '
+            'const realtype *k, const realtype *y, const realtype *sigmay, '
+            'const realtype *my)',
+    },
+    'dJydy': {
+        'signature':
+            '(realtype *dJydy, const int iy, const realtype *p, '
+            'const realtype *k, const realtype *y, '
+            'const realtype *sigmay, const realtype *my)',
+        'sparse':
+            True,
+    },
+    'dwdp': {
+        'signature':
+            '(realtype *dwdp, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w, const realtype *tcl, const realtype *dtcldp, '
+            'const int ip)',
+        'assume_pow_positivity':
+            True,
+    },
+    'dwdx': {
+        'signature':
+            '(realtype *dwdx, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w, const realtype *tcl)',
+        'sparse':
+            True,
+        'assume_pow_positivity':
+            True,
+    },
+    'dxdotdw': {
+        'signature':
+            '(realtype *dxdotdw, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w)',
+        'sparse':
+            True,
+        'assume_pow_positivity':
+            True,
+    },
+    'dxdotdp': {
+        'signature':
+            '(realtype *dxdotdp, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const int ip, const realtype *w)',
+        'assume_pow_positivity':
+            True,
+    },
+    'dydx': {
+        'signature':
+            '(realtype *dydx, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w, const realtype *dwdx)',
+    },
+    'dydp': {
+        'signature':
+            '(realtype *dydp, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const int ip, const realtype *w, const realtype *dwdp)',
+    },
+    'dsigmaydp': {
+        'signature':
+            '(realtype *dsigmaydp, const realtype t, const realtype *p, '
+            'const realtype *k, const int ip)',
+    },
+    'sigmay': {
+        'signature':
+            '(realtype *sigmay, const realtype t, const realtype *p, '
+            'const realtype *k)',
+    },
+    'w': {
+        'signature':
+            '(realtype *w, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, '
+            'const realtype *h, const realtype *tcl)',
+        'assume_pow_positivity':
+            True,
+    },
+    'x0': {
+        'signature':
+            '(realtype *x0, const realtype t, const realtype *p, '
+            'const realtype *k)',
+    },
+    'x0_fixedParameters': {
+        'signature':
+            '(realtype *x0_fixedParameters, const realtype t, '
+            'const realtype *p, const realtype *k)',
+    },
+    'sx0': {
+        'signature':
+            '(realtype *sx0, const realtype t,const realtype *x, '
+            'const realtype *p, const realtype *k, const int ip)',
+    },
+    'sx0_fixedParameters': {
+        'signature':
+            '(realtype *sx0_fixedParameters, const realtype t, '
+            'const realtype *x0, const realtype *p, const realtype *k, '
+            'const int ip)',
+    },
+    'xdot': {
+        'signature':
+            '(realtype *xdot, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, const realtype *h, '
+            'const realtype *w)',
+        'assume_pow_positivity':
+            True,
+    },
+    'y': {
+        'signature':
+            '(realtype *y, const realtype t, const realtype *x, '
+            'const realtype *p, const realtype *k, '
+            'const realtype *h, const realtype *w)',
+    },
+    'x_rdata': {
+        'signature':
+            '(realtype *x_rdata, const realtype *x, const realtype *tcl)',
+    },
+    'total_cl': {
+        'signature':
+            '(realtype *total_cl, const realtype *x_rdata)',
+    },
+    'x_solver': {
+        'signature':
+            '(realtype *x_solver, const realtype *x_rdata)',
+    },
+}
+
+## list of sparse functions
+sparse_functions = [
+    function for function in functions
+    if 'sparse' in functions[function]
+    and functions[function]['sparse']
+]
+## list of sensitivity functions
+sensi_functions = [
+    function for function in functions
+    if 'const int ip' in functions[function]['signature']
+    and function is not 'sxdot'
+]
+## list of multiobs functions
+multiobs_functions = [
+    function for function in functions
+    if 'const int iy' in functions[function]['signature']
+]
+
+
+def var_in_function_signature(name, varname):
+    """Checks if the values for a symbolic variable is passed in the signature
+    of a function
+
+    Arguments:
+
+        name: name of the function @type str
+
+        varname: name of the symbolic variable @type str
+
+    Returns:
+
+    Raises:
+
+    """
+    return name in functions \
+           and re.search(
+                    f'const (realtype|double) \*{varname}[0]*[,)]+',
+                    functions[name]['signature']
+                )
+
+
+class ModelQuantity:
+    """Base class for model components
+
+    Attributes:
+
+    """
+    def __init__(self, identifier,  name, value):
+        """Create a new ModelQuantity instance.
+
+        Arguments:
+            identifier: unique identifier of the quantity @type sympy.Symbol
+
+            name: individual name of the quantity (does not need to be unique)
+            @type str
+
+            value: either formula, numeric value or initial value
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+
+        if not isinstance(identifier, sp.Symbol):
+            raise TypeError(f'identifier must be sympy.Symbol, was '
+                            f'{type(identifier)}')
+        self._identifier = identifier
+
+        if not isinstance(name, str):
+            raise TypeError(f'name must be str, was {type(name)}')
+        self._name = name
+
+        if isinstance(value, sp.RealNumber) \
+                or isinstance(value, numbers.Number):
+            value = float(value)
+        if not isinstance(value, sp.Basic) and not isinstance(value, float):
+            raise TypeError(f'value must be sympy.Symbol or float, was '
+                            f'{type(value)}')
+        self._value = value
+
+    def __repr__(self):
+        """Representation of the ModelQuantity object
+
+        Arguments:
+
+        Returns:
+        string representation of the ModelQuantity
+
+        Raises:
+
+        """
+        return str(self._identifier)
+
+    def get_id(self):
+        """ModelQuantity identifier
+
+        Arguments:
+
+        Returns:
+        identifier of the ModelQuantity
+
+        Raises:
+
+        """
+        return self._identifier
+
+    def get_name(self):
+        """ModelQuantity name
+
+        Arguments:
+
+        Returns:
+        name of the ModelQuantity
+
+        Raises:
+
+        """
+        return self._name
+
+    def get_val(self):
+        """ModelQuantity value
+
+        Arguments:
+
+        Returns:
+        value of the ModelQuantity
+
+        Raises:
+
+        """
+        return self._value
+
+
+class State(ModelQuantity):
+    """A State variable defines an entity that evolves with time according to
+    the provided time derivative, abbreviated by `x`
+
+    Attributes:
+        conservation_law: algebraic formula that allows computation of this
+        species according to a conservation law
+
+    """
+
+    conservation_law = None
+
+    def __init__(self, identifier, name, value, dt):
+        """Create a new State instance. Extends ModelQuantity.__init__ by dt
+
+        Arguments:
+            identifier: unique identifier of the state @type sympy.Symbol
+
+            name: individual name of the state (does not need to be unique)
+            @type str
+
+            value: initial value @type symengine.Basic
+
+            dt: time derivative @type symengine.Basic
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(State, self).__init__(identifier, name, value)
+        if not isinstance(dt, sp.Basic):
+            raise TypeError(f'dt must have type sympy.Basic, was '
+                            f'{type(dt)}')
+
+        self._dt = dt
+        self.conservation_law = None
+
+    def set_conservation_law(self, law):
+        """Sets the conservation law of a state. If the a conservation law
+        is set, the respective state will be replaced by an algebraic
+        formula according to the respective conservation law.
+
+        Arguments:
+            law: linear sum of states that if added to this state remain
+            constant over time
+
+        Returns:
+
+        Raises:
+        TypeError:
+            is thrown if law type does not match documented type
+        """
+        if not isinstance(law, sp.Basic):
+            raise TypeError(f'conservation law must have type sympy.Basic, '
+                            f'was {type(law)}')
+
+        self.conservation_law = law
+
+    def set_dt(self, dt):
+        """Sets the time derivative
+
+        Arguments:
+            dt: time derivative @type symengine.Basic
+
+        Returns:
+
+        Raises:
+        TypeError:
+            is thrown if dt type does not match documented type
+        """
+        if not isinstance(dt, sp.Basic):
+            raise TypeError(f'time derivative must have type sympy.Basic, '
+                            f'was {type(dt)}')
+        self._dt = dt
+
+    def get_dt(self):
+        """Sets the time derivative
+
+        Arguments:
+
+        Returns:
+        time derivative @type symengine.Basic
+
+        Raises:
+        """
+        return self._dt
+
+
+class ConservationLaw(ModelQuantity):
+    """ A conservation law defines the absolute the total amount of a
+    (weighted) sum of states
+
+    """
+    def __init__(self, identifier, name, value):
+        """Create a new ConservationLaw instance.
+
+        Arguments:
+            identifier: unique identifier of the ConservationLaw
+            @type sympy.Symbol
+
+            name: individual name of the ConservationLaw (does not need to be
+            unique) @type str
+
+            value: formula (sum of states) @type symengine.Basic
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(ConservationLaw, self).__init__(identifier, name, value)
+
+
+class Observable(ModelQuantity):
+    """An Observable links model simulations to experimental measurements,
+    abbreviated by `y`
+
+    """
+    def __init__(self, identifier, name, value):
+        """Create a new Observable instance.
+
+        Arguments:
+            identifier: unique identifier of the Observable @type sympy.Symbol
+
+            name: individual name of the Observable (does not need to be
+            unique) @type str
+
+            value: formula @type symengine.Basic
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(Observable, self).__init__(identifier, name, value)
+
+
+class SigmaY(ModelQuantity):
+    """A Standard Deviation SigmaY rescales the distance between simulations
+    and measurements when computing residuals, abbreviated by `sigmay`
+
+    """
+    def __init__(self, identifier, name, value):
+        """Create a new Standard Deviation instance.
+
+        Arguments:
+            identifier: unique identifier of the Standard Deviation
+            @type sympy.Symbol
+
+            name: individual name of the Standard Deviation (does not need to
+            be unique) @type str
+
+            value: formula @type symengine.Basic
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(SigmaY, self).__init__(identifier, name, value)
+
+
+class Expression(ModelQuantity):
+    """An Expressions is a recurring elements in symbolic formulas. Specifying
+    this may yield more compact expression which may lead to substantially
+    shorter model compilation times, but may also reduce model simulation time,
+    abbreviated by `w`
+
+    """
+    def __init__(self, identifier, name, value):
+        """Create a new Expression instance.
+
+        Arguments:
+            identifier: unique identifier of the Expression @type sympy.Symbol
+
+            name: individual name of the Expression (does not need to be
+            unique) @type str
+
+            value: formula @type symengine.Basic
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(Expression, self).__init__(identifier, name, value)
+
+
+class Parameter(ModelQuantity):
+    """A Parameter is a free variable in the model with respect to which
+    sensitivites may be computed, abbreviated by `p`
+
+    """
+
+    def __init__(self, identifier, name, value):
+        """Create a new Expression instance.
+
+        Arguments:
+            identifier: unique identifier of the Parameter @type sympy.Symbol
+
+            name: individual name of the Parameter (does not need to be
+            unique) @type str
+
+            value: numeric value @type float
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(Parameter, self).__init__(identifier, name, value)
+
+
+class Constant(ModelQuantity):
+    """A Constant is a fixed variable in the model with respect to which
+    sensitivites cannot be computed, abbreviated by `k`
+
+    """
+
+    def __init__(self, identifier, name, value):
+        """Create a new Expression instance.
+
+        Arguments:
+            identifier: unique identifier of the Constant @type sympy.Symbol
+
+            name: individual name of the Constant (does not need to be unique)
+             @type str
+
+            value: numeric value @type float
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(Constant, self).__init__(identifier, name, value)
+
+
+class LogLikelihood(ModelQuantity):
+    """A LogLikelihood defines the distance between measurements and
+    experiments for a particular observable. The final LogLikelihood value
+    in the simulation will be the sum of all specified LogLikelihood
+    instances evaluated at all timepoints, abbreviated by `Jy`
+
+    """
+
+    def __init__(self, identifier, name, value):
+        """Create a new Expression instance.
+
+        Arguments:
+            identifier: unique identifier of the LogLikelihood
+            @type sympy.Symbol
+
+            name: individual name of the LogLikelihood (does not need to be
+             unique) @type str
+
+            value: formula @type symengine.Basic
+
+        Raises:
+        TypeError:
+            is thrown if input types do not match documented types
+        """
+        super(LogLikelihood, self).__init__(identifier, name, value)
+
+
+## indicates which type some attributes in ODEModel should have
+symbol_to_type = {
+    'species': State,
+    'parameter': Parameter,
+    'fixed_parameter': Constant,
+    'observable': Observable,
+    'sigmay': SigmaY,
+    'llhy': LogLikelihood,
+    'expression': Expression,
+}
+
+
+class ODEModel:
+    """An ODEModel defines an Ordinay Differential Equation as set of
+    ModelQuantities. This class provides general purpose interfaces to
+    compute arbitrary symbolic derivatives that are necessary for model
+    simulation or sensitivity computation
+
+    Attributes:
+        _states: list of State instances  @type list
+
+        _observables: list of Observable instances  @type list
+
+        _sigmays: list of SigmaY instances  @type list
+
+        _parameters: list of Parameter instances  @type list
+
+        _loglikelihoods: list of LogLikelihood instances  @type list
+
+        _expressions: list of Expression instances  @type list
+
+        _conservationlaws: list of ConservationLaw instances @type list
+
+        _symboldim_funs: define functions that compute model dimensions, these
+        are functions as the underlying symbolic expressions have not been
+        populated at compile time @type dict
+
+        _eqs: carries symbolic formulas of the symbolic variables of the model
+        @type dict
+
+        _sparseeqs: carries linear list of all symbolic formulas for sparsified
+        variables  @type dict
+
+        _vals: carries numeric values of symbolic identifiers of the symbolic
+        variables of the model  @type dict
+
+        _names: carries names of symbolic identifiers of the symbolic variables
+        of the model  @type dict
+
+        _syms: carries symbolic identifiers of the symbolic variables of the
+        model  @type dict
+
+        _strippedsyms: carries symbolic identifiers that were stripped of
+        additional class information @type dict
+
+        _sparsesyms: carries linear list of all symbolic identifiers for
+        sparsified variables  @type dict
+
+        _colptrs: carries column pointers for sparsified variables. See
+        SUNMatrixContent_Sparse definition in <sunmatrix/sunmatrix_sparse.h>
+        @type dict
+
+        _rowvals: carries row values for sparsified variables. See
+        SUNMatrixContent_Sparse definition in <sunmatrix/sunmatrix_sparse.h>
+        @type dict
+
+        _equation_prototype: defines the attribute from which an equation
+        should be generated via list comprehension (see
+        ODEModel.generateEquation()) @type dict
+
+        _variable_prototype: defines the attribute from which a variable should
+        be generated via list comprehension (see ODEModel.generateSymbol())
+        @type dict
+
+        _value_prototype: defines the attribute from which a value should be
+        generated via list comprehension (see ODEModel.generateValue())
+        @type dict
+
+        _total_derivative_prototypes: defines how a total derivative equation
+        is computed for an equation, key defines the name and values should
+        be arguments for ODEModel.totalDerivative() @type dict
+
+        _multiplication_prototypes: defines how a multiplication equation is
+        computed for an equation, key defines the name and values should be
+        arguments for ODEModel.multiplication() @type dict
+
+        _lock_total_derivative: set this to true when computing a total
+        derivative from a partial derivative call to enforce a partial
+        derivative in the next recursion. prevents infinite recursion
+
+    """
+
+    def __init__(self):
+        """Create a new ODEModel instance.
+
+        Arguments:
+
+        Raises:
+
+        """
+        self._states = []
+        self._observables = []
+        self._sigmays = []
+        self._parameters = []
+        self._constants = []
+        self._loglikelihoods = []
+        self._expressions = []
+        self._conservationlaws = []
+        self._symboldim_funs = {
+            'sx': self.nx_solver,
+            'v': self.nx_solver,
+            'vB': self.nx_solver,
+            'xB': self.nx_solver,
+            'sigmay': self.ny,
+        }
+        self._eqs = dict()
+        self._sparseeqs = dict()
+        self._vals = dict()
+        self._names = dict()
+        self._syms = dict()
+        self._strippedsyms = dict()
+        self._sparsesyms = dict()
+        self._colptrs = dict()
+        self._rowvals = dict()
+
+        self._equation_prototype = {
+            'total_cl': '_conservationlaws',
+            'x0': '_states',
+            'y': '_observables',
+            'Jy': '_loglikelihoods',
+            'w': '_expressions',
+            'sigmay': '_sigmays',
+        }
+        self._variable_prototype = {
+            'tcl': '_conservationlaws',
+            'x_rdata': '_states',
+            'y': '_observables',
+            'p': '_parameters',
+            'k': '_constants',
+            'w': '_expressions',
+            'sigmay': '_sigmays'
+        }
+        self._value_prototype = {
+            'p': '_parameters',
+            'k': '_constants',
+        }
+        self._total_derivative_prototypes = {
+            'J': {
+                'eq': 'xdot',
+                'chainvars': ['w'],
+                'var': 'x',
+            },
+            'sxdot': {
+                'eq': 'xdot',
+                'chainvars': ['x'],
+                'var': 'p',
+                'dydx_name': 'JSparse',
+                'dxdz_name': 'sx',
+            },
+            'sx_rdata': {
+                'eq': 'x_rdata',
+                'chainvars': ['x'],
+                'var': 'p',
+                'dxdz_name': 'sx',
+            },
+        }
+        self._multiplication_prototypes = {
+            'Jv': {
+                'x': 'J',
+                'y': 'v',
+            },
+            'JvB': {
+                'x': 'JB',
+                'y': 'vB',
+            },
+            'xBdot': {
+                'x': 'JB',
+                'y': 'xB',
+            },
+        }
+
+        self._lock_total_derivative = False
+
+    def import_from_sbml_importer(self, si):
+        """Imports a model specification from a amici.SBMLImporter instance.
+
+        Arguments:
+            si: imported SBML model @type amici.SbmlImporter
+
+
+        Returns:
+
+
+        Raises:
+
+        """
+
+        symbols = copy.copy(si.symbols)
+
+        # setting these equations prevents native equation generation
+        self._eqs['dxdotdw'] = si.stoichiometricMatrix
+        self._eqs['w'] = si.fluxVector
+        self._syms['w'] = sp.Matrix(
+            [sp.Symbol(f'flux_r{idx}') for idx in range(len(si.fluxVector))]
+        )
+        self._eqs['dxdotdx'] = sp.zeros(si.stoichiometricMatrix.shape[0])
+        if len(si.stoichiometricMatrix):
+            symbols['species']['dt'] = \
+                si.stoichiometricMatrix * self.sym('w')
+        else:
+            symbols['species']['dt'] = sp.zeros(
+                *symbols['species']['identifier'].shape
+            )
+
+        for symbol in [s for s in symbols if s != 'my']:
+            # transform dict of lists into a list of dicts
+            protos = [dict(zip(symbols[symbol], t))
+                      for t in zip(*symbols[symbol].values())]
+            for proto in protos:
+                self.add_component(symbol_to_type[symbol](**proto))
+
+        self.generateBasicVariables()
+
+    def add_component(self, component):
+        """Adds a new ModelQuantity to the model.
+
+        Arguments:
+            component: model quantity to be added @type ModelQuantity
+
+        Returns:
+
+        Raises:
+            Exception: invalid component type
+
+        """
+        for comp_type in [Observable, Expression, Parameter, Constant, State,
+                          LogLikelihood, SigmaY, ConservationLaw]:
+            if isinstance(component, comp_type):
+                getattr(self, f'_{type(component).__name__.lower()}s').append(
+                    component
+                )
+                return
+        Exception(f'Invalid component type {type(component)}')
+
+    def add_conservation_law(self, state, total_abundance, state_expr,
+                             abundance_expr):
+        """Adds a new conservation law to the model.
+
+        Arguments:
+            state: symbolic identifier of the state that should be replaced by
+            the conservation law
+            total_abundance: symbolic identifier of the total abundance
+            state_expr: symbolic algebraic formula that replaces the the state
+            abundance_expr: symbolic algebraic formula that computes the
+            total abundance
+
+        Returns:
+
+        Raises:
+            Exception if the specified state does not correspond to a valid
+            state in the model
+
+        """
+        try:
+            ix = [
+                s.get_id()
+                for s in self._states
+            ].index(state)
+        except ValueError:
+            raise Exception(f'Specified state {state} was not found in the '
+                            f'model states.')
+
+        state_id = self._states[ix].get_id()
+
+        self.add_component(
+            Expression(state_id, str(state_id), state_expr)
+        )
+
+        self.add_component(
+            ConservationLaw(
+                total_abundance,
+                f'total_{state_id}',
+                abundance_expr
+            )
+        )
+
+        self._states[ix].set_conservation_law(state_expr)
+
+    def nx_rdata(self):
+        """Number of states.
+
+        Arguments:
+
+        Returns:
+        number of state variable symbols
+
+        Raises:
+
+        """
+        return len(self.sym('x_rdata'))
+
+    def nx_solver(self):
+        """Number of states after applying conservation laws.
+
+        Arguments:
+
+        Returns:
+        number of state variable symbols
+
+        Raises:
+
+        """
+        return len(self.sym('x'))
+
+    def ncl(self):
+        """Number of conservation laws.
+
+        Arguments:
+
+        Returns:
+        number of conservation laws
+
+        Raises:
+
+        """
+        return self.nx_rdata()-self.nx_solver()
+
+    def ny(self):
+        """Number of Observables.
+
+        Arguments:
+
+        Returns:
+        number of observable symbols
+
+        Raises:
+
+        """
+        return len(self.sym('y'))
+
+    def nk(self):
+        """Number of Constants.
+
+        Arguments:
+
+        Returns:
+        number of constant symbols
+
+        Raises:
+
+        """
+        return len(self.sym('k'))
+
+    def np(self):
+        """Number of Parameters.
+
+        Arguments:
+
+        Returns:
+        number of parameter symbols
+
+        Raises:
+
+        """
+        return len(self.sym('p'))
+
+    def sym(self, name, stripped=False):
+        """Returns (and constructs if necessary) the identifiers for a symbolic
+        entity.
+
+        Arguments:
+            name: name of the symbolic variable @type str
+            stripped: (optional) should additional class information be
+            stripped from the symbolic variables? @type bool
+
+        Returns:
+        containing the symbolic identifiers @type symengine.DenseMatrix
+
+        Raises:
+        ValueError if stripped symbols not available
+        """
+        if name not in self._syms:
+            self._generateSymbol(name)
+
+        if stripped:
+            if name not in self._variable_prototype:
+                raise ValueError('Stripped symbols only available for '
+                                 'variables from variable prototypes')
+            return self._strippedsyms[name]
+        else:
+            return self._syms[name]
+
+    def sparsesym(self, name):
+        """Returns (and constructs if necessary) the sparsified identifiers for
+        a sparsified symbolic variable.
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        linearized symengine.DenseMatrix containing the symbolic identifiers
+
+        Raises:
+
+        """
+        if name not in sparse_functions:
+            raise Exception(f'{name} is not marked as sparse')
+        if name not in self._sparsesyms:
+            self._generateSparseSymbol(name)
+        return self._sparsesyms[name]
+
+    def eq(self, name):
+        """Returns (and constructs if necessary) the formulas for a symbolic
+        entity.
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        symengine.DenseMatrix containing the symbolic identifiers
+
+        Raises:
+
+        """
+
+        if name not in self._eqs:
+            self._compute_equation(name)
+        return self._eqs[name]
+
+    def sparseeq(self, name):
+        """Returns (and constructs if necessary) the sparsified formulas for a
+        sparsified symbolic variable.
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        linearized symengine.DenseMatrix containing the symbolic formulas
+
+        Raises:
+
+        """
+        if name not in sparse_functions:
+            raise Exception(f'{name} is not marked as sparse')
+        if name not in self._sparseeqs:
+            self._generateSparseSymbol(name)
+        return self._sparseeqs[name]
+
+    def colptrs(self, name):
+        """Returns (and constructs if necessary) the column pointers for
+        a sparsified symbolic variable.
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        symengine.DenseMatrix containing the column pointers
+
+        Raises:
+
+        """
+        if name not in sparse_functions:
+            raise Exception(f'{name} is not marked as sparse')
+        if name not in self._sparseeqs:
+            self._generateSparseSymbol(name)
+        return self._colptrs[name]
+
+    def rowvals(self, name):
+        """Returns (and constructs if necessary) the row values for a
+        sparsified symbolic variable.
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        symengine.DenseMatrix containing the row values
+
+        Raises:
+
+        """
+        if name not in sparse_functions:
+            raise Exception(f'{name} is not marked as sparse')
+        if name not in self._sparseeqs:
+            self._generateSparseSymbol(name)
+        return self._rowvals[name]
+
+    def val(self, name):
+        """Returns (and constructs if necessary) the numeric values of a
+        symbolic entity
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        list containing the numeric values
+
+        Raises:
+
+        """
+        if name not in self._vals:
+            self._generateValue(name)
+        return self._vals[name]
+
+    def name(self, name):
+        """Returns (and constructs if necessary) the names of a symbolic
+        variable
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+        list of names
+
+        Raises:
+
+        """
+        if name not in self._names:
+            self._generateName(name)
+        return self._names[name]
+
+    def _generateSymbol(self, name):
+        """Generates the symbolic identifiers for a symbolic variable
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        if name in self._variable_prototype:
+            component = self._variable_prototype[name]
+            self._syms[name] = sp.Matrix([
+                comp.get_id()
+                for comp in getattr(self, component)
+            ])
+            self._strippedsyms[name] = sp.Matrix([
+                sp.Symbol(comp.get_name())
+                for comp in getattr(self, component)
+            ])
+            if name == 'y':
+                self._syms['my'] = sp.Matrix([
+                    sp.Symbol(f'm{strip_pysb(comp.get_id())}')
+                    for comp in getattr(self, component)
+                ])
+            return
+        elif name == 'x':
+            self._syms[name] = sp.Matrix([
+                state.get_id()
+                for state in self._states
+                if state.conservation_law is None
+            ])
+            return
+        elif name == 'dtcldp':
+            self._syms[name] = sp.Matrix([
+                sp.Symbol(f's{strip_pysb(tcl.get_id())}')
+                for tcl in self._conservationlaws
+            ])
+            return
+        elif name in sparse_functions:
+            self._generateSparseSymbol(name)
+            return
+        elif name in self._symboldim_funs:
+            length = self._symboldim_funs[name]()
+        elif name in sensi_functions:
+            length = self.eq(name).shape[0]
+        else:
+            length = len(self.eq(name))
+
+        self._syms[name] = sp.Matrix([
+            sp.Symbol(f'{name}{i}') for i in range(length)
+        ])
+
+    def generateBasicVariables(self):
+        """Generates the symbolic identifiers for all variables in
+        ODEModel.variable_prototype
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        for var in self._variable_prototype:
+            if var not in self._syms:
+                self._generateSymbol(var)
+
+    def get_appearance_counts(self, idxs):
+        """Counts how often a state appears in the time derivative of
+        another state and expressions for a subset of states
+
+        Arguments:
+            idxs: list of state indices for which counts are to be computed
+
+        Returns:
+            list of counts for the states ordered according to the provided
+            indices
+
+        Raises:
+
+        """
+        free_symbols_dt = list(itertools.chain.from_iterable(
+            [
+                str(symbol)
+                for symbol in state.get_dt().free_symbols
+            ]
+            for state in self._states
+        ))
+
+        free_symbols_expr = list(itertools.chain.from_iterable(
+            [
+                str(symbol)
+                for symbol in expr.get_val().free_symbols
+            ]
+            for expr in self._expressions
+        ))
+
+        return [
+            free_symbols_dt.count(str(self._states[idx].get_id()))
+            +
+            free_symbols_expr.count(str(self._states[idx].get_id()))
+            for idx in idxs
+        ]
+
+    def _generateSparseSymbol(self, name):
+        """Generates the sparse symbolic identifiers, symbolic identifiers,
+        sparse equations, column pointers and row values for a symbolic
+        variable
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        matrix = self.eq(name)
+
+        if name == 'dJydy':
+            # One entry per y-slice
+            self._colptrs[name] = []
+            self._rowvals[name] = []
+            self._sparseeqs[name] = []
+            self._sparsesyms[name] = []
+            self._syms[name] = []
+            base_index = 0
+            for iy in range(self.ny()):
+                symbolColPtrs, symbolRowVals, sparseList, symbolList, \
+                sparseMatrix = csc_matrix(matrix[iy, :], name,
+                                          base_index=base_index)
+                base_index += len(symbolList)
+                self._colptrs[name].append(symbolColPtrs)
+                self._rowvals[name].append(symbolRowVals)
+                self._sparseeqs[name].append(sparseList)
+                self._sparsesyms[name].append(symbolList)
+                self._syms[name].append(sparseMatrix)
+        else:
+            symbolColPtrs, symbolRowVals, sparseList, symbolList, \
+                sparseMatrix = csc_matrix(matrix, name)
+
+            self._colptrs[name] = symbolColPtrs
+            self._rowvals[name] = symbolRowVals
+            self._sparseeqs[name] = sparseList
+            self._sparsesyms[name] = symbolList
+            self._syms[name] = sparseMatrix
+
+    def _compute_equation(self, name):
+        """computes the symbolic formula for a symbolic variable
+
+        Arguments:
+            name: name of the symbolic variable @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        match_deriv = re.match(r'd([\w_]+)d([a-z_]+)', name)
+
+        if name in self._equation_prototype:
+            self._equationFromComponent(name, self._equation_prototype[name])
+
+        elif name in self._total_derivative_prototypes:
+            args = self._total_derivative_prototypes[name]
+            args['name'] = name
+            self._lock_total_derivative = True
+            self._total_derivative(**args)
+            self._lock_total_derivative = False
+
+        elif name in self._multiplication_prototypes:
+            args = self._multiplication_prototypes[name]
+            args['name'] = name
+            self._multiplication(**args)
+
+        elif name == 'xdot':
+            self._eqs[name] = sp.Matrix([
+                s._dt for s in self._states
+                if s.conservation_law is None
+            ])
+
+        elif name == 'x_rdata':
+            self._eqs[name] = sp.Matrix([
+                state.get_id()
+                if state.conservation_law is None
+                else state.conservation_law
+                for state in self._states
+            ])
+
+        elif name == 'x_solver':
+            self._eqs[name] = sp.Matrix([
+                state.get_id()
+                for state in self._states
+                if state.conservation_law is None
+            ])
+
+        elif name == 'sx_solver':
+            self._eqs[name] = sp.Matrix([
+                self.sym('sx_rdata')[ix]
+                for ix, state in enumerate(self._states)
+                if state.conservation_law is None
+            ])
+
+        elif name == 'sx0':
+            self._derivative(name[1:], 'p', name=name)
+
+        elif name == 'sx0_fixedParameters':
+            # deltax = -x+x0_fixedParameters if x0_fixedParameters>0 else 0
+            # deltasx = -sx+dx0_fixedParametersdx*sx+dx0_fixedParametersdp
+            # if x0_fixedParameters>0 else 0
+            # sx0_fixedParameters = sx+deltasx =
+            # dx0_fixedParametersdx*sx+dx0_fixedParametersdp
+            if len(self.sym('p')):
+                self._eqs[name] = \
+                    self.eq('x0_fixedParameters').jacobian(self.sym('p'))
+            else:
+                self._eqs[name] = sp.zeros(
+                    len(self.eq('x0_fixedParameters')),
+                    len(self.sym('p'))
+                )
+
+            if len(self.sym('x')):
+                dx0_fixedParametersdx = \
+                    self.eq('x0_fixedParameters').jacobian(self.sym('x'))
+            else:
+                dx0_fixedParametersdx = sp.zeros(
+                    len(self.eq('x0_fixedParameters')),
+                    len(self.sym('x'))
+                )
+
+            if dx0_fixedParametersdx.is_zero is not True:
+                for ip in range(self._eqs[name].shape[1]):
+                    self._eqs[name][:,ip] += \
+                        dx0_fixedParametersdx \
+                        * self.sym('sx0') \
+
+            for index, formula in enumerate(self.eq('x0_fixedParameters')):
+                if formula == 0 or formula == 0.0:
+                    self._eqs[name][index, :] = \
+                        sp.zeros(1, self._eqs[name].shape[1])
+
+        elif name == 'JB':
+            self._eqs[name] = -self.eq('J').transpose()
+
+        elif name == 'JDiag':
+            self._eqs[name] = getSymbolicDiagonal(self.eq('J'))
+
+        elif name == 'x0_fixedParameters':
+            k = self.sym('k')
+            self._eqs[name] = sp.Matrix([
+                eq
+                # check if the equation contains constants
+                if any([sym in eq.free_symbols for sym in k])
+                # if not set to zero
+                else 0.0
+                for eq in self.eq('x0')
+            ])
+
+        elif name in ['JSparse', 'JSparseB']:
+            self._eqs[name] = self.eq(name.replace('Sparse', ''))
+
+        elif name == 'dtotal_cldx_rdata':
+            # not correctly parsed in regex
+            self._derivative('total_cl', 'x_rdata')
+
+        elif name == 'dtcldx':
+            # this is always zero
+            self._eqs[name] = sp.zeros(self.ncl(), self.nx_solver())
+
+        elif name == 'dtcldp':
+            # force symbols
+            self._eqs[name] = self.sym(name)
+
+        elif match_deriv:
+            self._derivative(match_deriv.group(1), match_deriv.group(2))
+
+        else:
+            raise Exception(f'Unknown equation {name}')
+
+        if name in ['Jy', 'dydx']:
+            # do not transpose if we compute the partial derivative as part of
+            # a total derivative
+            if not self._lock_total_derivative:
+                self._eqs[name] = self._eqs[name].transpose()
+
+    def symNames(self):
+        """Returns a list of names of generated symbolic variables
+
+        Arguments:
+
+        Returns:
+        list of names
+
+        Raises:
+
+        """
+        return list(self._syms.keys())
+
+    def _derivative(self, eq, var, name=None):
+        """Creates a new symbolic variable according to a derivative
+
+        Arguments:
+            eq: name of the symbolic variable that defines the formula
+            @type str
+
+            var: name of the symbolic variable that defines the identifiers
+            with respect to which the derivatives are to be computed @type str
+
+            name: name of resulting symbolic variable, default is d{eq}d{var}
+            @type str
+
+
+        Returns:
+
+        Raises:
+
+        """
+        if not name:
+            name = f'd{eq}d{var}'
+
+        # automatically detect chainrule
+        chainvars = []
+        ignore_chainrule = {
+            ('xdot', 'p'): 'w'  # has generic implementation in c++ code
+        }
+        for cv in ['w', 'tcl']:
+            if var_in_function_signature(eq, cv) \
+                    and not self._lock_total_derivative \
+                    and var is not cv \
+                    and min(self.sym(cv).shape) \
+                    and (
+                            (eq, var) not in ignore_chainrule
+                            or ignore_chainrule[(eq, var)] != cv
+                    ):
+                chainvars.append(cv)
+
+        if len(chainvars):
+            self._lock_total_derivative = True
+            self._total_derivative(name, eq, chainvars, var)
+            self._lock_total_derivative = False
+            return
+
+        # this is the basic requirement check
+        needs_stripped_symbols = eq == 'xdot' and var != 'x'
+
+        # partial derivative
+        if eq == 'Jy':
+            eq = self.eq(eq).transpose()
+        else:
+            eq = self.eq(eq)
+
+        if pysb is not None and needs_stripped_symbols:
+            needs_stripped_symbols = not any(
+                isinstance(sym, pysb.Component)
+                for sym in eq.free_symbols
+            )
+
+        # now check whether we are working with energy_modeling branch
+        # where pysb class info is already stripped
+        # TODO: fixme as soon as energy_modeling made it to the main pysb
+        #  branch
+        sym_var = self.sym(var, needs_stripped_symbols)
+
+        if min(eq.shape) and min(sym_var.shape) \
+                and eq.is_zero is not True and sym_var.is_zero is not True:
+            self._eqs[name] = eq.jacobian(sym_var)
+        else:
+            self._eqs[name] = sp.zeros(eq.shape[0], self.sym(var).shape[0])
+
+    def _total_derivative(self, name, eq, chainvars, var,
+                          dydx_name=None, dxdz_name=None):
+        """Creates a new symbolic variable according to a total derivative
+        using the chain rule
+
+        Arguments:
+            name: name of resulting symbolic variable @type str
+
+            eq: name of the symbolic variable that defines the formula
+            @type str
+
+            chainvars: names of the symbolic variable that define the
+            identifiers with respect to which the chain rules are applied
+            @type list
+
+            var: name of the symbolic variable that defines the identifiers
+            whith respect to which the derivatives are to be computed @type str
+
+            dydxname: defines the name of the symbolic variable that
+            defines the derivative of the `eq` with respect to `chainvar`,
+            default is d{eq}d{chainvar} @type str
+
+            dxdzname: defines the name of the symbolic variable that
+            defines the derivative of the `chainvar` with respect to `var`,
+            default is d{chainvar}d{var} @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        # compute total derivative according to chainrule
+        # Dydz = dydx*dxdz + dydz
+
+        # initialize with partial derivative dydz without chain rule
+        self._eqs[name] = copy.deepcopy(
+            self.sym_or_eq(name, f'd{eq}d{var}')
+        )
+
+        for chainvar in chainvars:
+            if dydx_name is None:
+                dydx_name = f'd{eq}d{chainvar}'
+            if dxdz_name is None:
+                dxdz_name =  f'd{chainvar}d{var}'
+
+            dydx = self.sym_or_eq(name, dydx_name)
+            dxdz = self.sym_or_eq(name, dxdz_name)
+            # Save time for for large models if one multiplicand is zero,
+            # which is not checked for by sympy
+            if dydx.is_zero is not True and dxdz.is_zero is not True:
+                if dxdz.shape[1] == 1 and \
+                        self._eqs[name].shape[1] != dxdz.shape[1]:
+                    for iz in range(self._eqs[name].shape[1]):
+                        self._eqs[name][:, iz] += dydx * dxdz
+                else:
+                    self._eqs[name] += dydx * dxdz
+
+    def sym_or_eq(self, name, varname):
+        """Returns symbols or equations depending on whether a given
+        variable appears in the function signature or not.
+
+        Arguments:
+            name: name of function for which the signature should be checked
+            varname: name of the variable which should be contained in the
+            function signature
+
+        Returns:
+        the variable symbols if the variable is part of the signature and
+        the variable equations otherwise.
+
+        Raises:
+
+        """
+        if var_in_function_signature(name, varname):
+            return self.sym(varname)
+        else:
+            return self.eq(varname)
+
+    def _multiplication(self, name, x, y,
+                        transpose_x=False, sign=1):
+        """Creates a new symbolic variable according to a multiplication
+
+        Arguments:
+            name: name of resulting symbolic variable, default is d{eq}d{var}
+             @type str
+
+            x: name of the symbolic variable that defines the first factor
+            @type str
+
+            y: name of the symbolic variable that defines the second factor
+            @type str
+
+            transpose_x: indicates whether the first factor should be
+            transposed before multiplication @type bool
+
+            sign: defines the sign of the product, should be +1 or -1 @type int
+
+
+        Returns:
+
+        Raises:
+
+        """
+        if sign not in [-1, 1]:
+            raise TypeError(f'sign must be +1 or -1, was {sign}')
+
+        variables = dict()
+        for varname in [x, y]:
+            if var_in_function_signature(name, varname):
+                variables[varname] = self.sym(varname)
+            else:
+                variables[varname] = self.eq(varname)
+
+        if transpose_x:
+            xx = variables[x].transpose()
+        else:
+            xx = variables[x]
+
+        if xx.is_zero is not True and variables[y].is_zero is not True \
+                and len(xx) and len(variables[y]):
+            self._eqs[name] = sign * xx * variables[y]
+        else:
+            self._eqs[name] = sp.zeros(len(xx), len(variables[y]))
+
+    def _equationFromComponent(self, name, component):
+        """Generates the formulas of a symbolic variable from the attributes
+
+        Arguments:
+            name: name of resulting symbolic variable @type str
+
+            component: name of the attribute @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        self._eqs[name] = sp.Matrix(
+            [comp._value for comp in getattr(self, component)]
+        )
+        # flatten conservation laws in expressions
+        if name == 'w':
+            self._eqs[name] = self._eqs[name].subs(
+                self.get_conservation_laws()
+            )
+
+    def get_conservation_laws(self):
+        """ Returns a list of states with conservation law set
+
+        Arguments:
+
+        Returns:
+        list of state identifiers
+
+        Raises:
+
+        """
+        return [
+            (state.get_id(), state.conservation_law)
+            for state in self._states
+            if state.conservation_law is not None
+        ]
+
+    def _generateValue(self, name):
+        """Generates the numeric values of a symbolic variable from value
+        prototypes
+
+        Arguments:
+            name: name of resulting symbolic variable @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        if name in self._value_prototype:
+            component = self._value_prototype[name]
+        else:
+            raise Exception(f'No values for {name}')
+
+        self._vals[name] = [comp._value for comp in getattr(self, component)]
+
+    def _generateName(self, name):
+        """Generates the names of a symbolic variable from variable prototypes or
+        equation prototypes
+
+        Arguments:
+            name: name of resulting symbolic variable @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        if name in self._variable_prototype:
+            component = self._variable_prototype[name]
+        elif name in self._equation_prototype:
+            component = self._equation_prototype[name]
+        else:
+            raise Exception(f'No names for {name}')
+
+        self._names[name] = [comp._name for comp in getattr(self, component)]
+
+    def state_has_fixed_parameter_initial_condition(self, ix):
+        """Checks whether the state at specified index has a fixed parameter
+        initial condition
+
+        Arguments:
+            ix: state index
+
+        Returns:
+            boolean indicating if any of the initial condition free
+            variables is contained in the model constants
+
+        Raises:
+
+        """
+        ic = self._states[ix].get_val()
+        if not isinstance(ic, sp.Basic):
+            return False
+        return any([
+            fp in [c.get_id() for c in self._constants]
+            for fp in ic.free_symbols
+        ])
+
+    def state_has_conservation_law(self, ix):
+        """Checks whether the state at specified index has a conservation
+        law set
+
+        Arguments:
+            ix: state index
+
+        Returns:
+            boolean indicating if conservation_law is not None
+
+        Raises:
+
+        """
+        return self._states[ix].conservation_law is not None
+
+    def state_is_constant(self, ix):
+        """Checks whether the temporal derivative of the state is zero
+
+        Arguments:
+            ix: state index
+
+        Returns:
+            boolean indicating if constant over time
+
+        Raises:
+
+        """
+        return self._states[ix].get_dt() == 0.0
+
+
+
+class ODEExporter:
+    """The ODEExporter class generates AMICI C++ files for ODE model as
+    defined in symbolic expressions.
+
+    Attributes:
+
+        model: ODE definition @type ODEModel
+
+        outdir: see sbml_import.setPaths() @type str
+
+        verbose: more verbose output if True @type bool
+
+        assume_pow_positivity: if set to true, a special pow function is
+        used to avoid problems with state variables that may become negative
+        due to numerical errors @type bool
+
+        compiler: distutils/setuptools compiler selection to build the
+        python extension @type str
+
+        functions: carries C++ function signatures and other specifications
+        @type dict
+
+        modelName: name of the model that will be used for compilation
+        @type str
+
+        modelPath: path to the generated model specific files @type str
+
+        modelSwigPath: path to the generated swig files @type str
+
+        allow_reinit_fixpar_initcond: indicates whether reinitialization of
+        initial states depending on fixedParmeters is allowed for this model
+        @type bool
+    """
+
+    def __init__(
+            self,
+            ode_model,
+            outdir=None,
+            verbose=False,
+            assume_pow_positivity=False,
+            compiler=None,
+            allow_reinit_fixpar_initcond=True
+    ):
+        """Generate AMICI C++ files for the ODE provided to the constructor.
+
+        Arguments:
+            ode_model: ODE definition @type ODEModel
+
+            outdir: see sbml_import.setPaths() @type str
+
+            verbose: more verbose output if True @type bool
+
+            assume_pow_positivity: if set to true, a special pow function is
+            used to avoid problems with state variables that may become
+            negative due to numerical errors @type bool
+
+            compiler: distutils/setuptools compiler selection to build the
+            python extension @type str
+
+            allow_reinit_fixpar_initcond: see ODEExporter
+
+        Raises:
+
+        """
+
+        self.outdir = outdir
+        self.verbose = verbose
+        self.assume_pow_positivity = assume_pow_positivity
+        self.compiler = compiler
+
+        self.modelName = 'model'
+        output_dir = os.path.join(os.getcwd(),
+                                  f'amici-{self.modelName}')
+        self.modelPath = os.path.abspath(output_dir)
+        self.modelSwigPath = os.path.join(self.modelPath, 'swig')
+
+        # Signatures and properties of generated model functions (see
+        # include/amici/model.h for details)
+
+        self.model = ode_model
+
+        # To only generate a subset of functions, apply subselection here
+        self.functions = copy.deepcopy(functions)
+
+        self.allow_reinit_fixpar_initcond = allow_reinit_fixpar_initcond
+
+    def generateModelCode(self):
+        """Generates the native C++ code for the loaded model and a Matlab
+        script that can be run to compile a mex file from the C++ code
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        self._prepareModelFolder()
+        self._generateCCode()
+        self._generateMCode()
+
+    def compileModel(self):
+        """Compiles the generated code it into a simulatable module
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        self._compileCCode(compiler=self.compiler, verbose=self.verbose)
+
+    def _prepareModelFolder(self):
+        """Remove all files from the model folder.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        for file in os.listdir(self.modelPath):
+            file_path = os.path.join(self.modelPath, file)
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+
+    def _generateCCode(self):
+        """Create C++ code files for the model based on ODEExporter.model
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        for function in self.functions.keys():
+            self._writeFunctionFile(function)
+            if function in sparse_functions:
+                self._write_function_index(function, 'colptrs')
+                self._write_function_index(function, 'rowvals')
+
+        for name in self.model.symNames():
+            self._writeIndexFiles(name)
+
+        self._writeWrapfunctionsCPP()
+        self._writeWrapfunctionsHeader()
+        self._writeModelHeader()
+        self._writeCMakeFile()
+        self._writeSwigFiles()
+        self._writeModuleSetup()
+
+        shutil.copy(CXX_MAIN_TEMPLATE_FILE,
+                    os.path.join(self.modelPath, 'main.cpp'))
+
+    def _compileCCode(self, verbose=False, compiler=None):
+        """Compile the generated model code
+
+        Arguments:
+            verbose: Make model compilation verbose @type bool
+
+            compiler: distutils/setuptools compiler selection to build the
+            python extension @type str
+
+        Returns:
+
+        Raises:
+
+        """
+
+        # setup.py assumes it is run from within the model directory
+        moduleDir = self.modelPath
+        script_args = [sys.executable, os.path.join(moduleDir, 'setup.py')]
+
+        if verbose:
+            script_args.append('--verbose')
+        else:
+            script_args.append('--quiet')
+
+        script_args.extend(['build_ext', f'--build-lib={moduleDir}'])
+
+        if compiler is not None:
+            script_args.extend([f'--compiler={compiler}'])
+
+        # distutils.core.run_setup looks nicer, but does not let us check the
+        # result easily
+        try:
+            result = subprocess.run(script_args,
+                                    cwd=moduleDir,
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.STDOUT,
+                                    check=True)
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf-8'))
+            raise
+
+        if verbose:
+            print(result.stdout.decode('utf-8'))
+
+    def _generateMCode(self):
+        """Create a Matlab script for compiling code files to a mex file
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        # creating the code lines for the Matlab compile script
+        lines = []
+
+        # Events are not yet implemented. Once this is done, the variable nz
+        # will have to be replaced by "self.model.nz()"
+        nz = 0
+
+        # Second order code is not yet implemented. Once this is done,
+        # those variables will have to be replaced by
+        # "self.model.<var>true()", or the corresponding "model.self.o2flag"
+        nxtrue_rdata = self.model.nx_rdata()
+        nytrue = self.model.ny()
+        o2flag = 0
+
+        # a preliminary comment
+        lines.append('% This compile script was automatically created from Python SBML import.')
+        lines.append('% If mex compiler is set up within MATLAB, it can be run from MATLAB ')
+        lines.append('% in order to compile a mex-file from the Python generated C++ files.')
+        lines.append('')
+
+        # write the actual compiling code
+        lines.append('''modelName = '{model_name}';'''.format(
+            model_name=self.modelName))
+        lines.append('''amimodel.compileAndLinkModel(modelName, '', [], [], [], []);''')
+        lines.append('''amimodel.generateMatlabWrapper({nx}, {ny}, {np}, {nk}, {nz}, {o2flag}, [], ...
+            ['simulate_' modelName '.m'], modelName, 'lin', 1, 1);'''.format(
+            nx=nxtrue_rdata,
+            ny=nytrue,
+            np=self.model.np(),
+            nk=self.model.nk(),
+            nz=nz,
+            o2flag=o2flag
+            ))
+
+        # write compile script (for mex)
+        with open(os.path.join(self.modelPath, 'compileMexFile.m'), 'w') as fileout:
+            fileout.write('\n'.join(lines))
+
+    def _writeIndexFiles(self, name):
+        """Write index file for a symbolic array.
+
+        Arguments:
+            name: key in self.model._syms for which the respective file should
+            be written @type str
+
+        Returns:
+
+        Raises:
+
+
+        """
+        lines = []
+        if name in self.model.symNames():
+            if name in sparse_functions:
+                symbols = self.model.sparsesym(name)
+            else:
+                symbols = self.model.sym(name).T
+        else:
+            raise Exception('Unknown symbolic array')
+
+        for index, symbol in enumerate(symbols):
+            symbol_name = strip_pysb(symbol)
+            lines.append(
+                f'#define {symbol_name} {name}[{index}]'
+            )
+
+        with open(os.path.join(self.modelPath, f'{name}.h'), 'w') as fileout:
+            fileout.write('\n'.join(lines))
+
+    def _writeFunctionFile(self, function):
+        """Generate equations and write the C++ code for the function
+        `function`.
+
+        Arguments:
+            function: name of the function to be written (see self.functions)
+            @type str
+
+        Returns:
+
+        Raises:
+
+        """
+
+        # first generate the equations to make sure we have everything we
+        # need in subsequent steps
+        if 'sparse' in self.functions[function] and \
+                self.functions[function]['sparse']:
+            symbol = self.model.sparseeq(function)
+        elif not self.allow_reinit_fixpar_initcond \
+                and function == 'sx0_fixedParameters':
+            # Not required. Will create empty function body.
+            symbol = sp.Matrix()
+        else:
+            symbol = self.model.eq(function)
+
+        # function header
+        lines = [
+            '#include "amici/symbolic_functions.h"',
+            '#include "amici/defines.h"',
+            '#include "sundials/sundials_types.h"',
+            '#include <cmath>',
+            ''
+        ]
+
+        # function signature
+        signature = self.functions[function]['signature']
+
+        lines.append('')
+
+        for sym in self.model.symNames():
+            # added |double for data
+            # added '[0]*' for initial conditions
+            if re.search(
+                    f'const (realtype|double) \*{sym}[0]*[,)]+', signature
+            ):
+                lines.append(f'#include "{sym}.h"')
+
+        lines.append('')
+
+        lines.append(f'void {function}_{self.modelName}{signature}{{')
+
+        # function body
+        body = self._getFunctionBody(function, symbol)
+        if self.assume_pow_positivity \
+                and 'assume_pow_positivity' in self.functions[function].keys()\
+                and self.functions[function]['assume_pow_positivity']:
+            body = [re.sub(r'(^|\W)pow\(', r'\1amici::pos_pow(', line)
+                    for line in body]
+            # execute this twice to catch cases where the ending ( would be the
+            # starting (^|\W) for the following match
+            body = [re.sub(r'(^|\W)pow\(', r'\1amici::pos_pow(', line)
+                    for line in body]
+        self.functions[function]['body'] = body
+        lines += body
+        lines.append('}')
+        #if not body is None:
+        with open(os.path.join(
+                self.modelPath, f'{self.modelName}_{function}.cpp'), 'w'
+        ) as fileout:
+            fileout.write('\n'.join(lines))
+
+    def _write_function_index(self, function, indextype):
+        """Generate equations and write the C++ code for the function
+        `function`.
+
+        Arguments:
+            function: name of the function to be written (see self.functions)
+            @type str
+            indextype: type of index {'colptrs', 'rowvals'}
+
+        Returns:
+
+        Raises:
+
+        """
+
+        if indextype == 'colptrs':
+            values = self.model.colptrs(function)
+        elif indextype == 'rowvals':
+            values = self.model.rowvals(function)
+        else:
+            raise ValueError('Invalid value for type, must be colptr or '
+                             'rowval')
+
+        # function signature
+        if function in multiobs_functions:
+            signature = f'(sunindextype *{indextype}, int index)'
+        else:
+            signature = f'(sunindextype *{indextype})'
+
+        lines = [
+            '#include "sundials/sundials_types.h"',
+            '',
+            f'void {function}_{indextype}_{self.modelName}{signature}{{',
+        ]
+        if function in multiobs_functions:
+            # list of index vectors
+            cases = {switch_case: [' ' * 4 + f'{indextype}[{index}] = {value};'
+                     for index, value in enumerate(idx_vector)]
+                         for switch_case, idx_vector in enumerate(values)}
+            lines.extend(getSwitchStatement('index', cases, 1))
+        else:
+            # single index vector
+            lines.extend(
+                [' ' * 4 + f'{indextype}[{index}] = {value};'
+                 for index, value in enumerate(values)]
+            )
+        lines.append('}')
+        with open(os.path.join(
+                self.modelPath,
+                f'{self.modelName}_{function}_{indextype}.cpp'
+        ), 'w') as fileout:
+            fileout.write('\n'.join(lines))
+
+    def _getFunctionBody(self, function, symbol):
+        """Generate C++ code for body of function `function`.
+
+        Arguments:
+        function: name of the function to be written (see self.functions)
+        @type str
+
+        symbol: symbolic defintion of the function body @type str
+        symengine.DenseMatrix
+
+        Returns:
+
+        Raises:
+
+        """
+
+        lines = []
+
+        if len(symbol) == 0 or (isinstance(symbol, sp.Matrix)
+                                and min(symbol.shape) == 0):
+            return lines
+
+        if not self.allow_reinit_fixpar_initcond \
+                and function in ['sx0_fixedParameters', 'x0_fixedParameters']:
+            return lines
+
+        if function == 'sx0_fixedParameters':
+            # here we only want to overwrite values where x0_fixedParameters
+            # was applied
+            cases = dict()
+            for ipar in range(self.model.np()):
+                expressions = []
+                for index, formula in enumerate(
+                        self.model.eq('x0_fixedParameters')
+                ):
+                    if formula != 0 and formula != 0.0:
+                        expressions.append(f'{function}[{index}] = '
+                                                f'{symbol[index, ipar]};')
+                cases[ipar] = expressions
+            lines.extend(getSwitchStatement('ip', cases, 1))
+
+        elif function in sensi_functions:
+            cases = {ipar : self._getSymLines(symbol[:, ipar], function, 0)
+                     for ipar in range(self.model.np())}
+            lines.extend(getSwitchStatement('ip', cases, 1))
+
+        elif function in multiobs_functions:
+            if function == 'dJydy':
+                cases = {iobs: self._getSymLines(symbol[iobs], function, 0)
+                         for iobs in range(self.model.ny())}
+            else:
+                cases = {iobs : self._getSymLines(symbol[:, iobs], function, 0)
+                         for iobs in range(self.model.ny())}
+            lines.extend(getSwitchStatement('iy', cases, 1))
+
+        else:
+            lines += self._getSymLines(symbol, function, 4)
+
+
+        return [line for line in lines if line]
+
+    def _writeWrapfunctionsCPP(self):
+        """Write model-specific 'wrapper' file (wrapfunctions.cpp).
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        templateData = {'MODELNAME': self.modelName}
+        applyTemplate(
+            os.path.join(amiciSrcPath, 'wrapfunctions.template.cpp'),
+            os.path.join(self.modelPath, 'wrapfunctions.cpp'),
+            templateData
+        )
+
+    def _writeWrapfunctionsHeader(self):
+        """Write model-specific header file (wrapfunctions.h).
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        templateData = {'MODELNAME': str(self.modelName)}
+        applyTemplate(
+            os.path.join(amiciSrcPath, 'wrapfunctions.ODE_template.h'),
+            os.path.join(self.modelPath, 'wrapfunctions.h'),
+            templateData
+        )
+
+    def _writeModelHeader(self):
+        """Write model-specific header file (MODELNAME.h).
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+
+        tplData = {
+            'MODELNAME': str(self.modelName),
+            'NX_RDATA': str(self.model.nx_rdata()),
+            'NXTRUE_RDATA': str(self.model.nx_rdata()),
+            'NX_SOLVER': str(self.model.nx_solver()),
+            'NXTRUE_SOLVER': str(self.model.nx_solver()),
+            'NY': str(self.model.ny()),
+            'NYTRUE': str(self.model.ny()),
+            'NZ': '0',
+            'NZTRUE': '0',
+            'NEVENT': '0',
+            'NOBJECTIVE': '1',
+            'NW': str(len(self.model.sym('w'))),
+            'NDWDP': str(len(self.model.eq('dwdp'))),
+            'NDWDX': str(len(self.model.sparsesym('dwdx'))),
+            'NDXDOTDW': str(len(self.model.sparsesym('dxdotdw'))),
+            'NDJYDY': 'std::vector<int>{%s}'
+                      % ','.join(str(len(x))
+                                 for x in self.model.sparsesym('dJydy')),
+            'NNZ': str(len(self.model.sparsesym('JSparse'))),
+            'UBW': str(self.model.nx_solver()),
+            'LBW': str(self.model.nx_solver()),
+            'NP': str(self.model.np()),
+            'NK': str(self.model.nk()),
+            'O2MODE': 'amici::SecondOrderMode::none',
+            'PARAMETERS': str(self.model.val('p'))[1:-1],
+            'FIXED_PARAMETERS': str(self.model.val('k'))[1:-1],
+            'PARAMETER_NAMES_INITIALIZER_LIST':
+                self._getSymbolNameInitializerList('p'),
+            'STATE_NAMES_INITIALIZER_LIST':
+                self._getSymbolNameInitializerList('x_rdata'),
+            'FIXED_PARAMETER_NAMES_INITIALIZER_LIST':
+                self._getSymbolNameInitializerList('k'),
+            'OBSERVABLE_NAMES_INITIALIZER_LIST':
+                self._getSymbolNameInitializerList('y'),
+            'PARAMETER_IDS_INITIALIZER_LIST':
+                self._getSymbolIDInitializerList('p'),
+            'STATE_IDS_INITIALIZER_LIST':
+                self._getSymbolIDInitializerList('x_rdata'),
+            'FIXED_PARAMETER_IDS_INITIALIZER_LIST':
+                self._getSymbolIDInitializerList('k'),
+            'OBSERVABLE_IDS_INITIALIZER_LIST':
+                self._getSymbolIDInitializerList('y'),
+            'REINIT_FIXPAR_INITCOND':
+                'true' if self.allow_reinit_fixpar_initcond else
+                'false',
+            'AMICI_VERSION_STRING':  __version__,
+            'AMICI_COMMIT_STRING': __commit__,
+        }
+
+        for fun in [
+            'w', 'dwdp', 'dwdx', 'x_rdata', 'x_solver', 'total_cl', 'dxdotdw',
+            'dxdotdp', 'JSparse', 'JSparseB', 'dJydy'
+        ]:
+            tplData[f'{fun.upper()}_DEF'] = \
+                get_function_extern_declaration(fun, self.modelName)
+            tplData[f'{fun.upper()}_IMPL'] = \
+                get_model_override_implementation(fun, self.modelName)
+            if fun in sparse_functions:
+                tplData[f'{fun.upper()}_COLPTRS_DEF'] = \
+                    get_sunindex_extern_declaration(fun, self.modelName, 'colptrs')
+                tplData[f'{fun.upper()}_COLPTRS_IMPL'] = \
+                    get_sunindex_override_implementation(fun, self.modelName, 'colptrs')
+                tplData[f'{fun.upper()}_ROWVALS_DEF'] = \
+                    get_sunindex_extern_declaration(fun, self.modelName, 'rowvals')
+                tplData[f'{fun.upper()}_ROWVALS_IMPL'] = \
+                    get_sunindex_override_implementation(fun, self.modelName, 'rowvals')
+
+        if self.model.nx_solver() == self.model.nx_rdata():
+            tplData['X_RDATA_DEF'] = ''
+            tplData['X_RDATA_IMPL'] = ''
+
+        applyTemplate(
+            os.path.join(amiciSrcPath, 'model_header.ODE_template.h'),
+            os.path.join(self.modelPath, f'{self.modelName}.h'),
+            tplData
+        )
+
+    def _getSymbolNameInitializerList(self, name):
+        """Get SBML name initializer list for vector of names for the given
+        model entity
+
+        Arguments:
+            name: any key present in self.model._syms @type str
+
+        Returns:
+        Template initializer list of names
+
+        Raises:
+
+        """
+        return '\n'.join(
+            [
+                f'"{strip_pysb(symbol)}",'
+                for symbol in self.model.name(name)
+            ]
+        )
+
+    def _getSymbolIDInitializerList(self, name):
+        """Get C++ initializer list for vector of names for the given model
+        entity
+
+        Arguments:
+            name: any key present in self.model._syms @type str
+
+        Returns:
+        Template initializer list of ids
+
+        Raises:
+
+        """
+        return '\n'.join(
+            [
+                f'"{strip_pysb(symbol)}",'
+                for symbol in self.model.sym(name)
+            ]
+        )
+
+    def _writeCMakeFile(self):
+        """Write CMake CMakeLists.txt file for this model.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        sources = [self.modelName + '_' + function + '.cpp '
+                   for function in self.functions.keys()
+                   if self.functions[function]['body'] is not None]
+
+        # add extra source files for sparse matrices
+        for function in sparse_functions:
+            sources.append(self.modelName + '_' + function
+                           + '_colptrs.cpp')
+            sources.append(self.modelName + '_' + function
+                           + '_rowvals.cpp ')
+
+        templateData = {'MODELNAME': self.modelName,
+                        'SOURCES': '\n'.join(sources),
+                        'AMICI_VERSION': __version__}
+        applyTemplate(
+            MODEL_CMAKE_TEMPLATE_FILE,
+            os.path.join(self.modelPath, 'CMakeLists.txt'),
+            templateData
+        )
+
+    def _writeSwigFiles(self):
+        """Write SWIG interface files for this model.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        if not os.path.exists(self.modelSwigPath):
+            os.makedirs(self.modelSwigPath)
+        templateData = {'MODELNAME': self.modelName}
+        applyTemplate(
+            os.path.join(amiciSwigPath, 'modelname.template.i'),
+            os.path.join(self.modelSwigPath, self.modelName + '.i'),
+            templateData
+        )
+        shutil.copy(SWIG_CMAKE_TEMPLATE_FILE,
+                    os.path.join(self.modelSwigPath, 'CMakeLists.txt'))
+
+    def _writeModuleSetup(self):
+        """Create a distutils setup.py file for compile the model module.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+
+        templateData = {'MODELNAME': self.modelName,
+                        'AMICI_VERSION': __version__,
+                        'PACKAGE_VERSION': '0.1.0'}
+        applyTemplate(os.path.join(amiciModulePath, 'setup.template.py'),
+                      os.path.join(self.modelPath, 'setup.py'), templateData)
+        applyTemplate(os.path.join(amiciModulePath, 'MANIFEST.template.in'),
+                      os.path.join(self.modelPath, 'MANIFEST.in'), {})
+        # write __init__.py for the model module
+        if not os.path.exists(os.path.join(self.modelPath, self.modelName)):
+            os.makedirs(os.path.join(self.modelPath, self.modelName))
+
+        applyTemplate(
+            os.path.join(amiciModulePath, '__init__.template.py'),
+            os.path.join(self.modelPath, self.modelName, '__init__.py'),
+            templateData
+        )
+
+    def _getSymLines(self, symbols, variable, indentLevel):
+        """Generate C++ code for assigning symbolic terms in symbols to C++ array
+        `variable`.
+
+        Arguments:
+            symbols: vectors of symbolic terms @type list
+
+            variable: name of the C++ array to assign to @type str
+
+            indentLevel: indentation level (number of leading blanks) @type int
+
+        Returns:
+            C++ code as list of lines
+
+        Raises:
+
+        """
+
+        return [' ' * indentLevel + f'{variable}[{index}] = '
+                                    f'{self._printWithException(math)};'
+                for index, math in enumerate(symbols)
+                if not (math == 0 or math == 0.0)]
+
+    def _printWithException(self, math):
+        """Generate C++ code for a symbolic expression
+
+        Arguments:
+            math: symbolic expression @type symengine.Basic
+
+        Returns:
+        C++ code for the specified expression
+
+        Raises:
+        Exception:
+            The specified expression contained an unsupported function
+
+        """
+        try:
+            ret = ccode(math)
+            ret = re.sub(r'(^|\W)M_PI(\W|$)', r'\1amici::pi\2', ret)
+            return ret
+        except:
+            raise Exception(
+                f'Encountered unsupported function in expression "{math}"!'
+            )
+
+    def setPaths(self, output_dir):
+        """Set output paths for the model and create if necessary
+
+        Arguments:
+            output_dir: relative or absolute path where the generated model
+            code is to be placed. will be created if does not exists. @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        self.modelPath = os.path.abspath(output_dir)
+        self.modelSwigPath = os.path.join(self.modelPath, 'swig')
+
+        for directory in [self.modelPath, self.modelSwigPath]:
+            if not os.path.exists(directory):
+                os.makedirs(directory)
+
+    def setName(self, modelName):
+        """Sets the model name
+
+        Arguments:
+            modelName: name of the model (must only contain valid filename
+            characters) @type str
+
+        Returns:
+
+        Raises:
+
+        """
+        self.modelName = modelName
+
+
+def getSymbolicDiagonal(matrix):
+    """Get symbolic matrix with diagonal of matrix `matrix`.
+
+    Arguments:
+        matrix: Matrix from which to return the diagonal
+        @type symengine.DenseMatrix
+
+    Returns:
+    A Symbolic matrix with the diagonal of `matrix`.
+
+    Raises:
+    Exception: The provided matrix was not square
+    """
+    if not matrix.cols == matrix.rows:
+        raise Exception('Provided matrix is not square!')
+
+    diagonal = [matrix[index,index] for index in range(matrix.cols)]
+
+    return sp.Matrix(diagonal)
+
+
+class TemplateAmici(Template):
+    """Template format used in AMICI (see string.template for more details).
+
+    Attributes:
+        delimiter: delimiter that identifies template variables @type str
+
+    """
+    delimiter = 'TPL_'
+
+
+def applyTemplate(sourceFile,targetFile,templateData):
+    """Load source file, apply template substitution as provided in
+    templateData and save as targetFile.
+
+    Arguments:
+        sourceFile: relative or absolute path to template file @type str
+
+        targetFile: relative or absolute path to output file @type str
+
+        templateData: template keywords to substitute (key is template
+        variable without TemplateAmici.delimiter) @type dict
+
+    Returns:
+
+    Raises:
+
+    """
+    with open(sourceFile) as filein:
+        src = TemplateAmici(filein.read())
+    result = src.safe_substitute(templateData)
+    with open(targetFile, 'w') as fileout:
+        fileout.write(result)
+
+
+def strip_pysb(symbol):
+    """Strips pysb info from a pysb.Component object
+
+    Arguments:
+        symbol: symbolic expression @type sympy.Basic
+
+    Returns:
+    stripped sympy.Basic
+
+    Raises:
+
+    """
+    # strip pysb type and transform into a flat sympy.Basic.
+    # this ensures that the pysb type specific __repr__ is used when converting
+    # to string
+    if pysb and isinstance(symbol, pysb.Component):
+        return sp.Symbol(symbol.name)
+    else:
+        # in this case we will use sympy specific transform anyways
+        return symbol
+
+
+def get_function_extern_declaration(fun, name):
+    """Constructs the extern function declaration for a given function
+
+    Arguments:
+        fun: function name @type str
+        name: model name @type str
+
+    Returns:
+    c++ function definition string
+
+    Raises:
+
+    """
+    return \
+        f'extern void {fun}_{name}{functions[fun]["signature"]};'
+
+
+def get_sunindex_extern_declaration(fun, name, indextype):
+    """Constructs the function declaration for an index function of a given
+    function
+
+    Arguments:
+        fun: function name @type str
+        name: model name @type str
+        indextype: index function {'colptrs', 'rowvals'} @type str
+
+    Returns:
+    c++ function declaration string
+
+    Raises:
+
+    """
+    index_arg = ', int index' if fun in multiobs_functions else ''
+    return \
+        f'extern void {fun}_{indextype}_{name}(sunindextype *{indextype}{index_arg});'
+
+
+def get_model_override_implementation(fun, name):
+    """Constructs amici::Model::* override implementation for a given function
+
+    Arguments:
+        fun: function name @type str
+        name: model name @type str
+
+    Returns:
+    c++ function implementation string
+
+    Raises:
+
+    """
+    return \
+        'virtual void f{fun}{signature} override {{\n' \
+        '{ind8}{fun}_{name}{eval_signature};\n' \
+        '{ind4}}}\n'.format(
+            ind4=' '*4,
+            ind8=' '*8,
+            fun=fun,
+            name=name,
+            signature=functions[fun]["signature"],
+            eval_signature=remove_typedefs(functions[fun]["signature"])
+        )
+
+
+def get_sunindex_override_implementation(fun, name, indextype):
+    """Constructs the amici::Model:: function implementation for an index
+    function of a given function
+
+    Arguments:
+        fun: function name @type str
+        name: model name @type str
+        indextype: index function {'colptrs', 'rowvals'} @type str
+
+    Returns:
+    c++ function implementation string
+
+    Raises:
+
+    """
+    index_arg = ', int index' if fun in multiobs_functions else ''
+    index_arg_eval = ', index' if fun in multiobs_functions else ''
+
+    return \
+        'virtual void f{fun}_{indextype}{signature} override {{\n' \
+        '{ind8}{fun}_{indextype}_{name}{eval_signature};\n' \
+        '{ind4}}}\n'.format(
+            ind4=' '*4,
+            ind8=' '*8,
+            fun=fun,
+            indextype=indextype,
+            name=name,
+            signature=f'(sunindextype *{indextype}{index_arg})',
+            eval_signature=f'({indextype}{index_arg_eval})',
+        )
+
+
+def remove_typedefs(signature):
+    """Strips typedef info from a function signature
+
+    Arguments:
+        signature: function signature @type str
+
+    Returns:
+    string that can be used to construct function calls with the same
+    variable names and ordering as in the function signature
+
+    Raises:
+
+    """
+    # remove * pefix for pointers (pointer must always be removed before
+    # values otherwise we will inadvertently dereference values,
+    # same applies for const specifications)
+    #
+    # always add whitespace after type definition for cosmetic reasons
+    typedefs = [
+        'const realtype *',
+        'const double *',
+        'const realtype ',
+        'double *',
+        'realtype *',
+        'const int ',
+        'int ',
+        'SUNMatrixContent_Sparse ',
+    ]
+
+    for typedef in typedefs:
+        signature = signature.replace(typedef, ' ')
+
+    return signature
+
+
+def getSwitchStatement(condition, cases,
+                  indentation_level=0,
+                  indentation_step=' ' * 4):
+    """Generate code for switch statement
+
+    Arguments:
+        condition: Condition for switch @type str
+
+        cases: Cases as dict with expressions as keys and statement as
+        list of strings @type dict
+
+        indentation_level: indentation level
+
+        indentation_step: indentation whitespace per level
+
+    Returns:
+    Code for switch expression as list of strings
+
+    Raises:
+
+    """
+    lines = list()
+
+    if not cases:
+        return lines
+
+    for expression, statements in cases.items():
+        if statements:
+            lines.append((indentation_level + 1) * indentation_step
+                         + f'case {expression}:')
+            for statement in statements:
+                lines.append((indentation_level + 2) * indentation_step
+                             + statement)
+            lines.append((indentation_level + 2) * indentation_step + 'break;')
+
+    if lines:
+        lines.insert(0, indentation_level * indentation_step
+                     + f'switch({condition}) {{')
+        lines.append(indentation_level * indentation_step + '}')
+
+    return lines
+
+
+def csc_matrix(matrix, name, base_index=0):
+    """Generates the sparse symbolic identifiers, symbolic identifiers,
+    sparse matrix, column pointers and row values for a symbolic
+    variable
+
+    Arguments:
+        matrix: dense matrix to be sparsified @type sp.Matrix
+        name: name of the symbolic variable @type str
+        base_index: index for first symbol name, defaults to 0
+
+    Returns:
+        symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix
+    Raises:
+
+    """
+    idx = 0
+    symbol_name_idx = base_index
+    sparseMatrix = sp.zeros(matrix.rows, matrix.cols)
+    symbolList = []
+    sparseList = []
+    symbolColPtrs = []
+    symbolRowVals = []
+    for col in range(0, matrix.cols):
+        symbolColPtrs.append(idx)
+        for row in range(0, matrix.rows):
+            if not (matrix[row, col] == 0):
+                symbolName = f'{name}{symbol_name_idx}'
+                sparseMatrix[row, col] = sp.Symbol(symbolName)
+                symbolList.append(symbolName)
+                sparseList.append(matrix[row, col])
+                symbolRowVals.append(row)
+                idx += 1
+                symbol_name_idx += 1
+
+    symbolColPtrs.append(idx)
+    sparseList = sp.Matrix(sparseList)
+
+    return symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/pandas.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/pandas.py
new file mode 100644
index 0000000000000000000000000000000000000000..feef1a948149c131ce3ba0dea2cf84b18406dda8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/pandas.py
@@ -0,0 +1,557 @@
+import pandas as pd
+import numpy as np
+import math
+import copy
+
+from .numpy import ExpDataView
+import amici
+from amici import ExpData
+
+
+def getDataObservablesAsDataFrame(model, edata_list, by_id=False):
+    """ Write Observables from experimental data as DataFrame.
+
+    Arguments:
+        model: Model instance.
+        edata_list: list of ExpData instances with experimental data.
+            May also be a single ExpData instance.
+        by_id: bool (optional, default = False)
+            If True, uses observable ids as identifiers in dataframe,
+            otherwise the possibly more descriptive observable names
+            are used.
+
+    Returns:
+        pandas DataFrame with conditions and observables.
+
+    Raises:
+
+    """
+    if isinstance(edata_list, (amici.amici.ExpData, amici.amici.ExpDataPtr)):
+        edata_list = [edata_list]
+
+    # list of all column names using either ids or names
+    cols = _get_extended_observable_cols(model, by_id=by_id)
+
+    # initialize dataframe with columns
+    df_edata = pd.DataFrame(columns=cols)
+
+    # append all converted edatas
+    for edata in edata_list:
+        npdata = ExpDataView(edata)
+        for i_time, timepoint in enumerate(edata.getTimepoints()):
+            datadict = {
+                'time': timepoint,
+                'datatype': 'data'
+            }
+            # add observables and noises
+            for i_obs, obs in enumerate(_get_names_or_ids(
+                    model, 'Observable', by_id=by_id)):
+                datadict[obs] = npdata['observedData'][i_time, i_obs]
+                datadict[obs + '_std'] = \
+                    npdata['observedDataStdDev'][i_time, i_obs]
+
+            # add conditions
+            _fill_conditions_dict(datadict, model, edata, by_id=by_id)
+
+            df_edata.loc[len(df_edata)] = datadict
+
+    return df_edata
+
+
+def getSimulationObservablesAsDataFrame(
+        model, edata_list, rdata_list, by_id=False):
+    """ Write Observables from simulation results as DataFrame.
+
+    Arguments:
+        model: Model instance.
+        edata_list: list of ExpData instances with experimental data.
+            May also be a single ExpData instance.
+        rdata_list: list of ReturnData instances corresponding to ExpData.
+            May also be a single ReturnData instance.
+        by_id: bool, optional (default = False)
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        pandas DataFrame with conditions and observables.
+
+    Raises:
+
+    """
+    if isinstance(edata_list, (amici.amici.ExpData, amici.amici.ExpDataPtr)):
+        edata_list = [edata_list]
+    if isinstance(rdata_list, (amici.amici.ReturnData, amici.amici.ReturnDataPtr)):
+        rdata_list = [rdata_list]
+
+    # list of all column names using either names or ids
+    cols = _get_extended_observable_cols(model, by_id=by_id)
+
+    # initialize dataframe with columns
+    df_rdata = pd.DataFrame(columns=cols)
+
+    # append all converted rdatas
+    for edata, rdata in zip(edata_list, rdata_list):
+        for i_time, timepoint in enumerate(rdata['t']):
+            datadict = {
+                'time': timepoint,
+                'datatype': 'simulation',
+            }
+            # append simulations
+            for i_obs, obs in enumerate(_get_names_or_ids(
+                    model, 'Observable', by_id=by_id)):
+                datadict[obs] = rdata['y'][i_time, i_obs]
+                datadict[obs + '_std'] = rdata['sigmay'][i_time, i_obs]
+
+            # use edata to fill conditions columns
+            _fill_conditions_dict(datadict, model, edata, by_id=by_id)
+
+            # append to dataframe
+            df_rdata.loc[len(df_rdata)] = datadict
+
+    return df_rdata
+
+
+def getSimulationStatesAsDataFrame(
+        model, edata_list, rdata_list, by_id=False):
+    """ Compute model residuals according to lists of ReturnData and ExpData.
+
+    Arguments:
+        model: Model instance.
+        edata_list: list of ExpData instances with experimental data.
+            May also be a single ExpData instance.
+        rdata_list: list of ReturnData instances corresponding to ExpData.
+            May also be a single ReturnData instance.
+        by_id: bool, optional (default = False)
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        pandas DataFrame with conditions and observables.
+
+    Raises:
+
+    """
+    if isinstance(edata_list, (amici.amici.ExpData, amici.amici.ExpDataPtr)):
+        edata_list = [edata_list]
+    if isinstance(rdata_list, (amici.amici.ReturnData, amici.amici.ReturnDataPtr)):
+        rdata_list = [rdata_list]
+
+    # get conditions and state column names by name or id
+    cols = _get_state_cols(model, by_id=by_id)
+
+    # initialize dataframe with columns
+    df_rdata = pd.DataFrame(columns=cols)
+
+    # append states
+    for edata, rdata in zip(edata_list, rdata_list):
+        for i_time, timepoint in enumerate(rdata['t']):
+            datadict = {
+                'time': timepoint,
+            }
+
+            # append states
+            for i_state, state in enumerate(
+                    _get_names_or_ids(model, 'State', by_id=by_id)):
+                datadict[state] = rdata['x'][i_time, i_state]
+
+            # use data to fill condition columns
+            _fill_conditions_dict(datadict, model, edata, by_id=by_id)
+
+            # append to dataframe
+            df_rdata.loc[len(df_rdata)] = datadict
+
+    return df_rdata
+
+
+def getResidualsAsDataFrame(model, edata_list, rdata_list, by_id=False):
+    """ Convert a list of ExpData to pandas DataFrame.
+
+    Arguments:
+        model: Model instance.
+        edata_list: list of ExpData instances with experimental data.
+            May also be a single ExpData instance.
+        rdata_list: list of ReturnData instances corresponding to ExpData.
+            May also be a single ReturnData instance.
+        by_id: bool, optional (default = False)
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        pandas DataFrame with conditions and observables.
+
+    Raises:
+
+    """
+    if isinstance(edata_list, (amici.amici.ExpData, amici.amici.ExpDataPtr)):
+        edata_list = [edata_list]
+    if isinstance(rdata_list, (amici.amici.ReturnData, amici.amici.ReturnDataPtr)):
+        rdata_list = [rdata_list]
+
+    # create observable and simulation dataframes
+    df_edata = getDataObservablesAsDataFrame(
+        model, edata_list, by_id=by_id)
+    df_rdata = getSimulationObservablesAsDataFrame(
+        model, edata_list, rdata_list, by_id=by_id)
+
+    # get all column names using names or ids
+    cols = _get_observable_cols(model, by_id=by_id)
+
+    #  initialize dataframe with columns
+    df_res = pd.DataFrame(columns=cols)
+
+    # iterate over rdata rows
+    for row in df_rdata.index:
+        datadict = {
+            'time': df_rdata.loc[row]['time'],
+            't_presim': df_rdata.loc[row]['t_presim']
+        }
+
+        # iterate over observables
+        for obs in _get_names_or_ids(model, 'Observable', by_id=by_id):
+            # compute residual and append to dict
+            datadict[obs] = abs(
+                (df_edata.loc[row][obs] - df_rdata.loc[row][obs]) /
+                df_rdata.loc[row][obs + '_std'])
+
+        # iterate over fixed parameters
+        for par in _get_names_or_ids(model, 'FixedParameter', by_id=by_id):
+            # fill in conditions
+            datadict[par] = df_rdata.loc[row][par]
+            datadict[par + '_preeq'] = df_rdata.loc[row][par + '_preeq']
+            datadict[par + '_presim'] = df_rdata.loc[row][par + '_presim']
+
+        # append to dataframe
+        df_res.loc[len(df_res)] = datadict
+
+    return df_res
+
+
+def _fill_conditions_dict(datadict, model, edata, by_id) -> dict:
+    """
+    Helper function that fills in condition parameters from model and
+    edata.
+
+    Arguments:
+        datadict: dictionary in which condition parameters will be inserted
+            as key value pairs.
+        model: Model instance.
+        edata: ExpData instance.
+        by_id: bool
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        dictionary with filled condition parameters.
+
+    Raises:
+
+    """
+    datadict['t_presim'] = edata.t_presim
+
+    for i_par, par in enumerate(
+            _get_names_or_ids(model, 'FixedParameter', by_id=by_id)):
+        if len(edata.fixedParameters):
+            datadict[par] = edata.fixedParameters[i_par]
+        else:
+            datadict[par] = model.getFixedParameters()[i_par]
+
+        if len(edata.fixedParametersPreequilibration):
+            datadict[par + '_preeq'] = \
+                edata.fixedParametersPreequilibration[i_par]
+        else:
+            datadict[par + '_preeq'] = math.nan
+
+        if len(edata.fixedParametersPresimulation):
+            datadict[par + '_presim'] = \
+                edata.fixedParametersPresimulation[i_par]
+        else:
+            datadict[par + '_presim'] = math.nan
+    return datadict
+
+
+def _get_extended_observable_cols(model, by_id) -> list:
+    """ Construction helper for extended observable dataframe headers.
+
+    Arguments:
+        model: Model instance.
+        by_id: bool
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        column names as list.
+
+    Raises:
+
+    """
+    return \
+        ['time', 'datatype', 't_presim'] + \
+        _get_names_or_ids(model, 'FixedParameter', by_id=by_id) + \
+        [name + '_preeq' for name in
+            _get_names_or_ids(model, 'FixedParameter', by_id=by_id)] + \
+        [name + '_presim' for name in
+            _get_names_or_ids(model, 'FixedParameter', by_id=by_id)] + \
+        _get_names_or_ids(model, 'Observable', by_id=by_id) + \
+        [name + '_std' for name in
+            _get_names_or_ids(model, 'Observable', by_id=by_id)]
+
+
+def _get_observable_cols(model, by_id):
+    """ Construction helper for observable dataframe headers.
+
+    Arguments:
+        model: Model instance.
+        by_id: bool
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        column names as list.
+
+    Raises:
+
+    """
+    return \
+        ['time', 't_presim'] + \
+        _get_names_or_ids(model, 'FixedParameter', by_id=by_id) + \
+        [name + '_preeq' for name in
+         _get_names_or_ids(model, 'FixedParameter', by_id=by_id)] + \
+        [name + '_presim' for name in
+         _get_names_or_ids(model, 'FixedParameter', by_id=by_id)] + \
+        _get_names_or_ids(model, 'Observable', by_id=by_id)
+
+
+def _get_state_cols(model, by_id):
+    """ Construction helper for state dataframe headers.
+
+    Arguments:
+        model: Model instance.
+        by_id: bool
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        column names as list.
+
+    Raises:
+
+    """
+    return \
+        ['time', 't_presim'] + \
+        _get_names_or_ids(model, 'FixedParameter', by_id=by_id) + \
+        [name + '_preeq' for name in
+            _get_names_or_ids(model, 'FixedParameter', by_id=by_id)] + \
+        [name + '_presim' for name in
+            _get_names_or_ids(model, 'FixedParameter', by_id=by_id)] + \
+        _get_names_or_ids(model, 'State', by_id=by_id)
+
+
+def _get_names_or_ids(model, variable, by_id):
+    """
+    Obtains a unique list of identifiers for the specified variable.
+    First tries model.getVariableNames and then uses model.getVariableIds.
+
+    Arguments:
+        model: Model instance.
+        variable: variable name.
+        by_id: bool
+            If True, ids are used as identifiers, otherwise first the possibly
+            more descriptive names are used.
+
+    Returns:
+        column names as list.
+
+    Raises:
+
+    """
+    # check whether variable type permitted
+    variable_options = ['Parameter', 'FixedParameter', 'Observable', 'State']
+    if variable not in variable_options:
+        raise ValueError('Variable must be in ' + str(variable_options))
+
+    # extract attributes
+    names = list(getattr(model, f'get{variable}Names')())
+    ids = list(getattr(model, f'get{variable}Ids')())
+
+    # find out if model has names and ids
+    has_names = getattr(model, f'has{variable}Names')()
+    has_ids = getattr(model, f'has{variable}Ids')()
+
+    # extract labels
+    if not by_id and has_names and len(set(names)) == len(names):
+        # use variable names
+        return names
+    elif has_ids:
+        # use variable ids
+        return ids
+    else:
+        # unable to create unique labels
+        if by_id:
+            msg = f"Model {variable} ids are not set."
+        else:
+            msg = f"Model {variable} names are not unique and " \
+                  f"{variable} ids are not set."
+        raise ValueError(msg)
+
+
+def _get_specialized_fixed_parameters(
+        model, condition, overwrite, by_id) -> list:
+    """
+    Copies values in condition and overwrites them according to key
+    value pairs specified in overwrite.
+
+    Arguments:
+        model: Model instance.
+        condition: dict/pd.Series containing FixedParameter values.
+        overwrite: dict specifying which values in condition are to be replaced.
+        by_id: bool
+            If True, ids are used as identifiers, otherwise the possibly more
+            descriptive names.
+
+    Returns:
+        overwritten FixedParameter as list.
+
+    Raises:
+
+    """
+    cond = copy.deepcopy(condition)
+    for field in overwrite:
+        cond[field] = overwrite[field]
+    return [float(cond[name]) for name in _get_names_or_ids(
+        model, 'FixedParameter', by_id=by_id)]
+
+
+def constructEdataFromDataFrame(df, model, condition, by_id=False):
+    """ Constructs an ExpData instance according to the provided Model and DataFrame.
+
+    Arguments:
+        df: pd.DataFrame with Observable Names/Ids as columns.
+            Standard deviations may be specified by appending '_std' as suffix.
+        model: Model instance.
+        condition: pd.Series with FixedParameter Names/Ids as columns.
+            Preequilibration conditions may be specified by appending '_preeq' as suffix.
+            Presimulation conditions may be specified by appending '_presim' as suffix.
+        by_id: bool, optional (default = False)
+            Indicate whether in the arguments, column headers are based on ids or names.
+            This should correspond to the way `df` and `condition` was created in the
+            first place.
+
+    Returns:
+        ExpData instance.
+
+    Raises:
+
+    """
+    # initialize edata
+    edata = ExpData(model.get())
+
+    # timepoints
+    df = df.sort_values(by='time', ascending=True)
+    edata.setTimepoints(df['time'].values.astype(float))
+
+    # get fixed parameters from condition
+    overwrite_preeq = {}
+    overwrite_presim = {}
+    for par in list(_get_names_or_ids(model, 'FixedParameter', by_id=by_id)):
+        if par + '_preeq' in condition.keys() \
+                and not math.isnan(condition[par + '_preeq']):
+            overwrite_preeq[par] = condition[par + '_preeq']
+        if par + '_presim' in condition.keys() \
+                and not math.isnan(condition[par + '_presim']):
+            overwrite_presim[par] = condition[par + '_presim']
+
+    # fill in fixed parameters
+    edata.fixedParameters = \
+        condition[_get_names_or_ids(model, 'FixedParameter', by_id=by_id)].values
+
+    # fill in preequilibration parameters
+    if any([overwrite_preeq[key] != condition[key] for key in
+            overwrite_preeq.keys()]):
+        edata.fixedParametersPreequilibration = \
+            _get_specialized_fixed_parameters(
+                model, condition, overwrite_preeq, by_id=by_id)
+    elif len(overwrite_preeq.keys()):
+        edata.fixedParametersPreequilibration = copy.deepcopy(
+            edata.fixedParameters
+        )
+
+    # fill in presimulation parameters
+    if any([overwrite_presim[key] != condition[key] for key in
+            overwrite_presim.keys()]):
+        edata.fixedParametersPresimulation = _get_specialized_fixed_parameters(
+            model, condition, overwrite_presim, by_id=by_id
+        )
+    elif len(overwrite_presim.keys()):
+        edata.fixedParametersPresimulation = copy.deepcopy(
+            edata.fixedParameters
+        )
+
+    # fill in presimulation time
+    if 't_presim' in condition.keys():
+        edata.t_presim = float(condition['t_presim'])
+
+    # fill in data and stds
+    for obs_index, obs in enumerate(
+            _get_names_or_ids(model, 'Observable', by_id=by_id)):
+        if obs in df.keys():
+            edata.setObservedData(df[obs].values.astype(float), obs_index)
+        if obs + '_std' in df.keys():
+            edata.setObservedDataStdDev(
+                df[obs + '_std'].values.astype(float), obs_index
+            )
+
+    return edata
+
+
+def getEdataFromDataFrame(model, df, by_id=False):
+    """ Constructs a ExpData instance according to the provided Model and DataFrame.
+
+    Arguments:
+        df: pd.DataFrame with Observable Names/Ids, FixedParameter Names/Ids and time as columns.
+            Standard deviations may be specified by appending '_std' as suffix.
+            Preequilibration fixedParameters may be specified by appending '_preeq' as suffix.
+            Presimulation fixedParameters may be specified by appending '_presim' as suffix.
+            Presimulation time may be specified as 't_presim' column.
+        model: Model instance.
+        by_id: bool, optional (default = False)
+            Whether the column names in `df` are based on ids or names,
+            corresponding to how the dataframe was created in the first place.
+
+    Returns:
+        ExpData instance.
+
+    Raises:
+
+    """
+    edata_list = []
+
+    # aggregate features that define a condition
+
+    # fixed parameters
+    condition_parameters = _get_names_or_ids(model, 'FixedParameter', by_id=by_id)
+    # preeq and presim parameters
+    for par in _get_names_or_ids(model, 'FixedParameter', by_id=by_id):
+        if par + '_preeq' in df.columns:
+            condition_parameters.append(par + '_preeq')
+        if par + '_presim' in df.columns:
+            condition_parameters.append(par + '_presim')
+    # presimulation time
+    if 't_presim' in df.columns:
+        condition_parameters.append('t_presim')
+    # drop duplicates to create final conditions
+    conditions = df[condition_parameters].drop_duplicates()
+
+    # iterate over conditions
+    for row in conditions.iterrows():
+        # subselect rows that match condition
+        selected = np.ones((len(df),), dtype=bool)
+        for par_label, par in row[1].iteritems():
+            if math.isnan(par):
+                selected = selected & np.isnan(df[par_label].values)
+            else:
+                selected = selected & (df[par_label] == par)
+        edata_df = df[selected]
+
+        edata_list.append(constructEdataFromDataFrame(edata_df, model, row[1], by_id=by_id))
+
+    return edata_list
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/plotting.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/plotting.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed459c50e66482866717f7a1c820ad7348d28e08
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/plotting.py
@@ -0,0 +1,52 @@
+"""@package amici.plotting Plotting related functions"""
+
+import matplotlib.pyplot as plt 
+
+def plotStateTrajectories(rdata, state_indices=None, ax = None):
+    """Plot state trajectories
+    
+    Arguments:
+    rdata: AMICI simulation results as returned by amici.getSimulationResults()
+    state_indices: Indices of states for which trajectories are to be plotted
+    ax: matplotlib.axes.Axes instance to plot into
+    
+    Returns:
+
+    Raises:
+
+    """
+    if not ax:
+        fig, ax = plt.subplots()
+    if not state_indices:
+        state_indices = range(rdata['x'].shape[1])
+    for ix in state_indices:
+        ax.plot(rdata['t'], rdata['x'][:, ix], label='$x_{%d}$' % ix)
+        ax.set_xlabel('$t$ (s)')
+        ax.set_ylabel('$x_i(t)$ (mmol/ml)')
+        ax.legend()
+        ax.set_title('State trajectories')
+    
+    
+def plotObservableTrajectories(rdata, observable_indices=None, ax = None):
+    """Plot observable trajectories
+    
+    Arguments:
+    rdata: AMICI simulation results as returned by amici.getSimulationResults()
+    observable_indices: Indices of observables for which trajectories are to be plotted
+    ax: matplotlib.axes.Axes instance to plot into
+
+    Returns:
+
+    Raises:
+
+    """
+    if not ax:
+        fig, ax = plt.subplots()
+    if not observable_indices:
+        observable_indices = range(rdata['y'].shape[1])
+    for iy in observable_indices:
+        ax.plot(rdata['t'], rdata['y'][:, iy], label='$y_{%d}$' % iy)
+        ax.set_xlabel('$t$ (s)')
+        ax.set_ylabel('$y_i(t)$ (AU)')
+        ax.legend()
+        ax.set_title('Observables')
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/pysb_import.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/pysb_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7a0e6bd599626b811f07184897d54546e972be8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/pysb_import.py
@@ -0,0 +1,1159 @@
+from .ode_export import (
+    ODEExporter, ODEModel, State, Constant, Parameter, Observable, SigmaY,
+    Expression, LogLikelihood
+)
+
+import sympy as sp
+import numpy as np
+import itertools
+
+try:
+    import pysb.bng
+    ## bool indicating whether pysb is available
+    pysb_available = True
+    import pysb.pattern
+except ImportError:
+    pysb_available = False
+
+
+def pysb2amici(model,
+               output_dir=None,
+               observables=None,
+               constant_parameters=None,
+               sigmas=None,
+               verbose=False,
+               assume_pow_positivity=False,
+               compiler=None,
+               compute_conservation_laws=True,
+               ):
+    """Generate AMICI C++ files for the model provided to the constructor.
+
+    Arguments:
+        model: pysb model, model.name will determine the name of the
+        generated module @type pysb.Model
+
+        output_dir: see sbml_import.setPaths()  @type str
+
+        observables: list of pysb.Expressions names that should be
+        interpreted as observables @type list
+
+        sigmas: list of pysb.Expressions names that should be
+        interpreted as sigmas @type list
+
+        constantParameters: list of pysb.Parameter names that should be
+        interpreted as constantParameters
+
+        verbose: more verbose output if True @type bool
+
+        assume_pow_positivity: if set to true, a special pow function is
+        used to avoid problems with state variables that may become
+        negative due to numerical errors @type bool
+
+        compiler: distutils/setuptools compiler selection to build the
+        python extension @type str
+
+        compute_conservation_laws: if set to true, conservation laws are
+        automatically computed and applied such that the state-jacobian of
+        the ODE right-hand-side has full rank. This option should be set to
+        True when using the newton algorithm to compute steadystates @type bool
+
+    Returns:
+
+    Raises:
+
+    """
+    if observables is None:
+        observables = []
+
+    if constant_parameters is None:
+        constant_parameters = []
+
+    if sigmas is None:
+        sigmas = {}
+
+    ode_model = ODEModel_from_pysb_importer(
+        model, constants=constant_parameters, observables=observables,
+        sigmas=sigmas, compute_conservation_laws=compute_conservation_laws,
+    )
+    exporter = ODEExporter(
+        ode_model,
+        outdir=output_dir,
+        verbose=verbose,
+        assume_pow_positivity=assume_pow_positivity,
+        compiler=compiler,
+    )
+    exporter.setName(model.name)
+    exporter.setPaths(output_dir)
+    exporter.generateModelCode()
+    exporter.compileModel()
+
+
+def ODEModel_from_pysb_importer(model, constants=None,
+                                observables=None, sigmas=None,
+                                compute_conservation_laws=True):
+    """Creates an ODEModel instance from a pysb.Model instance.
+
+
+    Arguments:
+        model: pysb model @type pysb.Model
+
+        constants: list of Parameters that should be constants @type list
+
+        observables: list of Expressions that should be observables
+        @type list
+
+        sigmas: dict with observable Expression name as key and sigma
+        Expression name as expression @type list
+
+        compute_conservation_laws: see pysb2amici
+
+
+    Returns:
+    New ODEModel instance according to pysbModel
+
+    Raises:
+
+    """
+
+    ODE = ODEModel()
+
+    if not pysb_available:
+        raise ImportError(
+            "This function requires an installation of pysb."
+        )
+
+    if constants is None:
+        constants = []
+
+    if observables is None:
+        observables = []
+
+    if sigmas is None:
+        sigmas = {}
+
+    pysb.bng.generate_equations(model)
+
+    _process_pysb_species(model, ODE)
+    _process_pysb_parameters(model, ODE, constants)
+    if compute_conservation_laws:
+        _process_pysb_conservation_laws(model, ODE)
+    _process_pysb_expressions(model, ODE, observables, sigmas)
+    _process_pysb_observables(model, ODE)
+
+    ODE.generateBasicVariables()
+
+    return ODE
+
+
+def _process_pysb_species(model, ODE):
+    """Converts pysb Species into States and adds them to the ODEModel
+    instance
+
+
+    Arguments:
+        model: pysb model @type pysb.Model
+
+        ODE: ODEModel instance @type ODEModel
+
+
+    Returns:
+
+    Raises:
+
+    """
+    xdot = sp.Matrix(model.odes)
+
+    for ix, specie in enumerate(model.species):
+        init = sp.sympify('0.0')
+        for ic in model.odes.model.initial_conditions:
+            if pysb.pattern.match_complex_pattern(ic[0], specie, exact=True):
+                # we don't want to allow expressions in initial conditions
+                if ic[1] in model.expressions:
+                    init = model.expressions[ic[1].name].expand_expr()
+                else:
+                    init = ic[1]
+
+        ODE.add_component(
+            State(
+                sp.Symbol(f'__s{ix}'),
+                f'{specie}',
+                init,
+                xdot[ix]
+            )
+        )
+
+
+def _process_pysb_parameters(model, ODE, constants):
+    """Converts pysb parameters into Parameters or Constants and adds them to
+    the ODEModel instance
+
+
+    Arguments:
+        model: pysb model @type pysb.Model
+
+        constants: list of Parameters that should be constants @type list
+
+        ODE: ODEModel instance @type ODEModel
+
+
+    Returns:
+
+    Raises:
+
+    """
+    for par in model.parameters:
+        if par.name in constants:
+            comp = Constant
+        else:
+            comp = Parameter
+
+        ODE.add_component(
+            comp(par, f'{par.name}', par.value)
+        )
+
+
+def _process_pysb_expressions(model, ODE, observables, sigmas):
+    """Converts pysb expressions into Observables (with corresponding
+    standard deviation SigmaY and LogLikelihood) or Expressions and adds them
+    to the ODEModel instance
+
+    Arguments:
+        model: pysb model @type pysb.Model
+
+        observables: list of Expressions that should be observables
+        @type list
+
+        sigmas: dict with observable Expression name as key and sigma
+        Expression name as expression @type list
+
+        ODE: ODEModel instance @type ODEModel
+
+
+    Returns:
+
+    Raises:
+
+    """
+    for exp in model.expressions:
+        if exp.name in observables:
+            # here we do not define a new Expression from the
+            # pysb.Expression but define an observable, so we do not need
+            # to expand observables as these can be defined as Expressions
+            y = exp
+            ODE.add_component(
+                Observable(
+                    y,
+                    f'{exp.name}',
+                    exp.expand_expr(expand_observables=False))
+            )
+
+            sigma_name, sigma_value = _get_sigma_name_and_value(
+                model, exp.name, sigmas
+            )
+
+            sy = sp.Symbol(sigma_name)
+            ODE.add_component(
+                SigmaY(
+                    sy,
+                    f'{sigma_name}',
+                    sigma_value
+                )
+            )
+
+            my = sp.Symbol(f'm{exp.name}')
+            pi = sp.sympify('pi')
+            ODE.add_component(
+                LogLikelihood(
+                    sp.Symbol(f'llh_{exp.name}'),
+                    f'llh_{exp.name}',
+                    0.5*sp.log(2*pi*sy**2) + 0.5*((y - my)/sy)**2
+                )
+            )
+
+        elif exp.name in sigmas.values():
+            # do nothing
+            pass
+        else:
+            # here we do define a new Expression from the pysb.Expression
+            # so we do need to expand observables as these would otherwise
+            # lead to dependencies between different Expressions
+            ODE.add_component(
+                Expression(
+                    exp,
+                    f'{exp.name}',
+                    exp.expand_expr(expand_observables=True))
+            )
+
+
+def _get_sigma_name_and_value(model, name, sigmas):
+    """Tries to extract standard deviation symbolic identifier and formula
+    for a given observable name from the pysb model and if no specification is
+    available sets default values
+
+
+    Arguments:
+        model: pysb model @type pysb.Model
+
+        name: name of the observable
+
+        sigmas: dict with observable Expression name as key and sigma
+        Expression name as expression @type list
+
+
+    Returns:
+    tuple containing symbolic identifier and formula for the specified
+    observable
+
+    Raises:
+
+    """
+    if name in sigmas:
+        if sigmas[name] not in model.expressions:
+            raise Exception(f'value of sigma {name} is not a '
+                            f'valid expression.')
+        sigma_name = model.expressions[sigmas[name]].name
+        sigma_value = model.expressions[sigmas[name]].expand_expr()
+    else:
+        sigma_name = f'sigma_{name}'
+        sigma_value = sp.sympify(1.0)
+
+    return sigma_name, sigma_value
+
+
+def _process_pysb_observables(model, ODE):
+    """Converts pysb observables into Expressions and adds them to the ODEModel
+    instance
+
+
+    Arguments:
+        model: pysb model @type pysb.Model
+
+        ODE: ODEModel instance @type ODEModel
+
+
+    Returns:
+
+    Raises:
+
+    """
+    # only add those pysb observables that occur in the added
+    # Observables as expressions
+    for obs in model.observables:
+        if obs in ODE.eq('y').free_symbols:
+            ODE.add_component(
+                Expression(
+                    obs,
+                    f'{obs.name}',
+                    obs.expand_obs()
+                )
+            )
+
+
+def _process_pysb_conservation_laws(model, ODE):
+    """Removes species according to conservation laws to ensure that the
+    jacobian has full rank
+
+
+    Arguments:
+        model: pysb model @type pysb.core.Model
+
+        ODE: ODEModel instance @type ODEModel
+
+
+    Returns:
+
+    Raises:
+
+    """
+
+    monomers_without_conservation_law = set()
+    for rule in model.rules:
+        monomers_without_conservation_law |= \
+            _get_unconserved_monomers(rule, model)
+
+    monomers_without_conservation_law |= \
+        _compute_monomers_with_fixed_initial_conditions(model)
+
+    cl_prototypes = _generate_cl_prototypes(
+        monomers_without_conservation_law, model, ODE
+    )
+    conservation_laws = _construct_conservation_from_prototypes(
+        cl_prototypes, model
+    )
+    _add_conservation_for_constant_species(ODE, conservation_laws)
+
+    _flatten_conservation_laws(conservation_laws)
+
+    for cl in conservation_laws:
+        ODE.add_conservation_law(**cl)
+
+
+def _compute_monomers_with_fixed_initial_conditions(model):
+    """Computes the set of monomers in a model with species that have fixed
+    initial conditions
+
+    Arguments:
+        model: pysb model @type pysb.core.Model
+
+    Returns:
+        set of monomer names
+
+    Raises:
+
+    """
+    monomers_with_fixed_initial_conditions = set()
+
+    for monomer in model.monomers:
+        # check if monomer has an initial condition that is fixed (means
+        # that corresponding state is constant and all conservation
+        # laws are broken)
+        if any([
+            ic.fixed  # true or false
+            for ic in model.initials
+            if monomer.name in extract_monomers(ic.pattern)
+        ]):
+            monomers_with_fixed_initial_conditions |= {monomer.name}
+
+    return monomers_with_fixed_initial_conditions
+
+
+def _generate_cl_prototypes(excluded_monomers, model, ODE):
+    """Constructs a dict that contains preprocessed information for the
+    construction of conservation laws
+
+    Arguments:
+        excluded_monomers: list of monomer names for which no prototypes
+        should be computed @type list
+        model: pysb model @type pysb.core.Model
+        ODE: ODEModel instance @type ODEModel
+
+    Returns:
+        dict('monomer.name':{'possible_indices': ..., 'target_indices': ...}
+
+    Raises:
+
+    """
+    cl_prototypes = dict()
+
+    _compute_possible_indices(cl_prototypes, model, ODE, excluded_monomers)
+    _compute_dependency_idx(cl_prototypes)
+    _compute_target_index(cl_prototypes, ODE)
+
+    return cl_prototypes
+
+
+def _compute_possible_indices(cl_prototypes, model, ODE, excluded_monomers):
+    """Computes viable choices for target_index, ie species that could be
+    removed and replaced by an algebraic expression according to the
+    conservation law
+
+    Arguments:
+        cl_prototypes: dict in which possible indices will be written @type
+        dict
+        model: pysb model @type pysb.core.Model
+        ODE: ODEModel instance @type ODEModel
+        excluded_monomers: monomers for which no conservation laws will be
+        computed @type list
+
+    Returns:
+
+    Raises:
+
+    """
+    for monomer in model.monomers:
+        if monomer.name not in excluded_monomers:
+
+            compartments = [
+                str(mp.compartment) # string based comparison as
+                # compartments are not hashable
+                for cp in model.species
+                for mp in cp.monomer_patterns
+                if mp.monomer.name == monomer.name
+            ]
+
+            if len(set(compartments)) > 1:
+                raise Exception('Conservation laws involving species in '
+                                'multiple compartments are currently not '
+                                'supported! Please run pysb2amici with '
+                                'compute_conservation_laws=False')
+                # TODO: implement this, multiply species by the volume of
+                # their respective compartment and allow total_cl to depend
+                # on parameters + constants and update the respective symbolic
+                # derivative accordingly
+
+            prototype = dict()
+            prototype['possible_indices'] = [
+                ix
+                for ix, specie in enumerate(model.species)
+                if monomer.name in extract_monomers(specie)
+                and not ODE.state_is_constant(ix)
+            ]
+
+            prototype['species_count'] = len(
+                prototype['possible_indices']
+            )
+
+            if prototype['possible_indices']:
+                cl_prototypes[monomer.name] = prototype
+
+
+def _compute_dependency_idx(cl_prototypes):
+    """Compute connecting species, this allows us to efficiently compute
+    whether the respective conservation law would induce a cyclic dependency.
+    Adds a 'dependency_idx' field to the prototype dict that
+    itself is a dict where keys correspond to indexes that, when used as
+    target index yield dependencies on conservation laws of monomers in
+    the respective values
+
+    Arguments:
+        cl_prototypes: dict in which possible indices will be written @type
+        dict
+
+    Returns:
+
+    Raises:
+
+    """
+    #
+    for monomer_i, prototype_i in cl_prototypes.items():
+        if 'dependency_idx' not in prototype_i:
+            prototype_i['dependency_idx'] = dict()
+
+        for monomer_j, prototype_j in cl_prototypes.items():
+            if monomer_i == monomer_j:
+                continue
+
+            if 'dependency_idx' not in prototype_j:
+                prototype_j['dependency_idx'] = dict()
+
+            idx_overlap = set(prototype_i['possible_indices']).intersection(
+                set(prototype_j['possible_indices'])
+            )
+            if len(idx_overlap) == 0:
+                continue
+
+            for idx in idx_overlap:
+                if idx not in prototype_i['dependency_idx']:
+                    prototype_i['dependency_idx'][idx] = set()
+
+                if idx not in prototype_j['dependency_idx']:
+                    prototype_j['dependency_idx'][idx] = set()
+
+                prototype_i['dependency_idx'][idx] |= {monomer_j}
+                prototype_j['dependency_idx'][idx] |= {monomer_i}
+
+
+def _compute_target_index(cl_prototypes, ODE):
+    """Computes the target index for every monomer
+
+
+    Arguments:
+        cl_prototypes: dict that contains possible indices for every monomer
+        @type dict
+        ODE: ODEModel instance @type ODEModel
+
+    Returns:
+
+    Raises:
+
+    """
+    possible_indices = list(set(list(itertools.chain(*[
+        cl_prototypes[monomer]['possible_indices']
+        for monomer in cl_prototypes
+    ]))))
+
+    # Note: currently this function is supposed to also count appearances in
+    # expressions. However, expressions are currently still empty as they
+    # are also populated from conservation laws. In case there are many
+    # state heavy expressions in the model (should not be the case for mass
+    # action kinetics). This may lead to suboptimal results and could improved.
+    # As this would require substantial code shuffling, this will only be
+    # fixed if this becomes an actual problem
+    appearance_counts = ODE.get_appearance_counts(possible_indices)
+
+    # in this initial guess we ignore the cost of having cyclic dependencies
+    # between conservation laws
+    for monomer in cl_prototypes:
+        prototype = cl_prototypes[monomer]
+        # extract monomer specific appearance counts
+        prototype['appearance_counts'] = \
+            [
+                appearance_counts[possible_indices.index(idx)]
+                for idx in prototype['possible_indices']
+            ]
+        # select target index as possible index with minimal appearance count
+        if len(prototype['appearance_counts']) == 0:
+            raise Exception(f'Failed to compute conservation law for monomer '
+                            f'{monomer}')
+
+        idx = np.argmin(prototype['appearance_counts'])
+
+        # remove entries from possible indices and appearance counts so we
+        # do not consider them again in later iterations
+        prototype['target_index'] = prototype['possible_indices'].pop(idx)
+        prototype['appearance_count'] = prototype['appearance_counts'].pop(idx)
+
+        # this is only an approximation as the effective species count
+        # of other conservation laws may also be affected by the chosen
+        # target index. As long as the number of unique monomers in
+        # multimers has a low upper bound and the species count does not
+        # vary too much across conservation laws, this approximation
+        # should be fine
+        prototype['fillin'] = \
+            prototype['appearance_count'] * prototype['species_count']
+
+    # we might end up with the same index for multiple monomers, so loop until
+    # we have a set of unique target indices
+    while not _cl_prototypes_are_valid(cl_prototypes):
+        _greedy_target_index_update(cl_prototypes)
+
+def _cl_prototypes_are_valid(cl_prototypes):
+    """Checks consistency of cl_prototypes by asserting that target indices
+    are unique and there are no cyclic dependencies
+
+    Arguments:
+        cl_prototypes: dict that contains dependency and target indexes for
+        every monomer @type dict
+
+    Returns:
+
+    Raises:
+
+    """
+    # target indices are unique
+    if len(cl_prototypes) != len(set(get_target_indices(cl_prototypes))):
+        return False
+    # conservation law dependencies are cycle free
+    if any(
+        _cl_has_cycle(monomer, cl_prototypes)
+        for monomer in cl_prototypes
+    ):
+        return False
+
+    return True
+
+def _cl_has_cycle(monomer, cl_prototypes):
+    """Checks whether monomer has a conservation law that is part of a
+    cyclic dependency
+
+    Arguments:
+        monomer: name of monomer for which conservation law is to be checked
+        cl_prototypes: dict that contains dependency and target indexes for
+        every monomer @type dict
+
+    Returns:
+
+    Raises:
+
+    """
+
+    prototype = cl_prototypes[monomer]
+
+    if prototype['target_index'] not in prototype['dependency_idx']:
+        return False
+
+    visited = [monomer]
+    root = monomer
+    return any(
+        _is_in_cycle(
+            connecting_monomer,
+            cl_prototypes,
+            visited,
+            root
+        )
+        for connecting_monomer in prototype['dependency_idx'][
+            prototype['target_index']
+        ]
+    )
+
+def _is_in_cycle(monomer, cl_prototypes, visited, root):
+    """Recursively checks for cycles in conservation law dependencies via
+    Depth First Search
+
+    Arguments:
+        monomer: current location in cl dependency graph
+        cl_prototypes: dict that contains dependency and target indexes for
+        every monomer @type dict
+        visited: history of visited monomers with conservation laws
+        root: monomer at which the cycle search was started
+
+    Returns:
+
+    Raises:
+
+    """
+    if monomer == root:
+        return True # we found a cycle and root is part of it
+
+    if monomer in visited:
+        return False # we found a cycle but root is not part of it
+
+    visited.append(monomer)
+
+    prototype = cl_prototypes[monomer]
+
+    if prototype['target_index'] not in prototype['dependency_idx']:
+        return False
+
+    return any(
+        _is_in_cycle(
+            connecting_monomer,
+            cl_prototypes,
+            visited,
+            root
+        )
+        for connecting_monomer in prototype['dependency_idx'][
+            prototype['target_index']
+        ]
+    )
+
+
+def _greedy_target_index_update(cl_prototypes):
+    """Computes unique target indices for conservation laws from possible
+    indices  such that expected fill in in symbolic derivatives is minimized
+
+
+    Arguments:
+        cl_prototypes: dict that contains possible indices and non-unique
+        target indices for every monomer @type dict
+
+    Returns:
+
+    Raises:
+        Exception if no suitable solution could be found
+
+    """
+
+    target_indices = get_target_indices(cl_prototypes)
+
+    for monomer, prototype in cl_prototypes.items():
+        if target_indices.count(prototype['target_index']) > 1 or \
+                _cl_has_cycle(monomer, cl_prototypes):
+            # compute how much fillin the next best target_index would yield
+
+            # we exclude already existing target indices to avoid that
+            # updating the target index removes uniqueness from already unique
+            # target indices, this may slightly reduce chances of finding a
+            # solution but prevents infinite loops
+            for target_index in list(set(target_indices)):
+                try:
+                    local_idx = prototype['possible_indices'].index(
+                        target_index
+                    )
+                except ValueError:
+                    local_idx = None
+
+                if local_idx:
+                    del prototype['possible_indices'][local_idx]
+                    del prototype['appearance_counts'][local_idx]
+
+            if len(prototype['possible_indices']) == 0:
+                prototype['diff_fillin'] = -1
+                continue
+
+            idx = np.argmin(prototype['appearance_counts'])
+
+            prototype['local_index'] = idx
+            prototype['alternate_target_index'] = \
+                prototype['possible_indices'][idx]
+            prototype['alternate_appearance_count'] = \
+                prototype['appearance_counts'][idx]
+
+            prototype['alternate_fillin'] = \
+                prototype['alternate_appearance_count'] \
+                * prototype['species_count']
+
+            prototype['diff_fillin'] = \
+                prototype['alternate_fillin'] - prototype['fillin']
+        else:
+            prototype['diff_fillin'] = -1
+
+    if all(
+        prototype['diff_fillin'] == -1
+        for prototype in cl_prototypes.values()
+    ):
+        raise Exception('Could not compute a valid set of conservation '
+                        'laws for this model!')
+
+    # this puts prototypes with high diff_fillin last
+    cl_prototypes = sorted(
+        cl_prototypes.items(), key=lambda kv: kv[1]['diff_fillin']
+    )
+    cl_prototypes = {
+        proto[0]: proto[1]
+        for proto in cl_prototypes
+    }
+
+    for monomer in cl_prototypes:
+        prototype = cl_prototypes[monomer]
+        # we check that we
+        # A) have an alternative index computed, i.e. that
+        # that monomer originally had a non-unique target_index
+        # B) that the target_index still is not unique or part of a cyclic
+        # dependency. due to the sorting, this will always be the monomer
+        # with the highest diff_fillin (note that the target index counts
+        # are recomputed on the fly)
+
+        if prototype['diff_fillin'] > -1 \
+                and (
+                    get_target_indices(cl_prototypes).count(
+                        prototype['target_index']
+                    ) > 1
+                    or _cl_has_cycle(monomer, cl_prototypes)
+        ):
+            prototype['fillin'] = prototype['alternate_fillin']
+            prototype['target_index'] = prototype['alternate_target_index']
+            prototype['appearance_count'] = \
+                prototype['alternate_appearance_count']
+
+            del prototype['possible_indices'][prototype['local_index']]
+            del prototype['appearance_counts'][prototype['local_index']]
+
+
+def get_target_indices(cl_prototypes):
+    """Computes the list target indices for the current
+    conservation law prototype
+
+    Arguments:
+        cl_prototypes: dict that contains target indices for every monomer
+        @type dict
+
+    Returns:
+
+    Raises:
+
+    """
+    return [
+        cl_prototypes[monomer]['target_index'] for monomer in cl_prototypes
+    ]
+
+
+def _construct_conservation_from_prototypes(cl_prototypes, model):
+    """Computes the algebraic expression for the total amount of a given
+    monomer
+
+    Arguments:
+        cl_prototype: output of _generate_cl_prototypes @type dict
+        model: pysb model @type pysb.core.Model
+
+
+    Returns:
+
+    Raises:
+
+    """
+    conservation_laws = []
+    for monomer_name in cl_prototypes:
+        target_index = cl_prototypes[monomer_name]['target_index']
+
+        # T = sum_i(a_i * x_i)
+        # x_j = (T - sum_i≠j(a_i * x_i))/a_j
+        # law: sum_i≠j(a_i * x_i))/a_j
+        # state: x_j
+        target_expression = sum(
+            sp.Symbol(f'__s{ix}')
+            * extract_monomers(specie).count(monomer_name)
+            for ix, specie in enumerate(model.species)
+            if ix != target_index
+        ) / extract_monomers(model.species[target_index]).count(monomer_name)
+        # normalize by the stoichiometry of the target species
+        target_state = sp.Symbol(f'__s{target_index}')
+        # = x_j
+
+        total_abundance = sp.Symbol(f'tcl__s{target_index}')
+        # = T/a_j
+
+        state_expr = total_abundance - target_expression
+        # x_j = T/a_j - sum_i≠j(a_i * x_i)/a_j
+
+        abundance_expr = target_expression + target_state
+        # T/a_j = sum_i≠j(a_i * x_i)/a_j + x_j
+
+        conservation_laws.append({
+            'state': target_state,
+            'total_abundance': total_abundance,
+            'state_expr': state_expr,
+            'abundance_expr': abundance_expr,
+        })
+
+    return conservation_laws
+
+
+def _add_conservation_for_constant_species(ODE, conservation_laws):
+    """Computes the algebraic expression for the total amount of a given
+    monomer
+
+    Arguments:
+        cl_prototype: output of _generate_cl_prototypes @type dict
+        model: pysb model @type pysb.core.Model
+
+
+    Returns:
+
+    Raises:
+
+    """
+
+    for ix in range(ODE.nx_rdata()):
+        if ODE.state_is_constant(ix):
+            target_state = sp.Symbol(f'__s{ix}')
+            total_abundance = sp.Symbol(f'tcl__s{ix}')
+
+            conservation_laws.append({
+                'state': target_state,
+                'total_abundance': total_abundance,
+                'state_expr': total_abundance,
+                'abundance_expr': target_state,
+            })
+
+
+def _flatten_conservation_laws(conservation_laws):
+    """ Flatten the conservation laws such that the state_expr not longer
+    depend on any states that are replaced by conservation laws
+
+    Arguments:
+        conservation_laws: output of _construct_conservation_from_prototypes
+        @type dict
+
+    Returns:
+
+    Raises:
+
+    """
+    conservation_law_subs = \
+        _get_conservation_law_subs(conservation_laws)
+
+    while len(conservation_law_subs):
+        for cl in conservation_laws:
+            if _sub_matches_cl(
+                    conservation_law_subs,
+                    cl['state_expr'],
+                    cl['state']
+            ):
+                # this optimization is done by subs anyways, but we dont
+                # want to recompute the subs if we did not change anything
+                valid_subs = _select_valid_cls(
+                    conservation_law_subs,
+                    cl['state']
+                )
+                if len(valid_subs) > 0:
+                    cl['state_expr'] = cl['state_expr'].subs(valid_subs)
+                    conservation_law_subs = \
+                        _get_conservation_law_subs(conservation_laws)
+
+def _select_valid_cls(subs, state):
+    """ Subselect substitutions such that we do not end up with conservation
+    laws that are self-referential
+
+    Arguments:
+        subs: substitutions in tuple format
+        state: target symbolic state to which substitutions will
+        be applied
+
+    Returns:
+    list of valid substitutions
+
+    Raises:
+
+    """
+    return [
+        sub
+        for sub in subs
+        if str(state) not in [str(symbol) for symbol in sub[1].free_symbols]
+    ]
+
+
+def _sub_matches_cl(subs, state_expr, state):
+    """ Checks whether any of the substitutions in subs will be applied to
+    state_expr
+
+    Arguments:
+        subs: substitutions in tuple format
+        state_expr: target symbolic expressions in which substitutions will
+        be applied
+        state: target symbolic state to which substitutions will
+        be applied
+
+    Returns:
+    boolean indicating positive match
+
+    Raises:
+
+    """
+
+    sub_symbols = set(
+        sub[0]
+        for sub in subs
+        if str(state) not in [
+            str(symbol) for symbol in sub[1].free_symbols
+        ]
+    )
+
+    return len(sub_symbols.intersection(state_expr.free_symbols)) > 0
+
+
+def _get_conservation_law_subs(conservation_laws):
+    """ Returns a list of (state, law) tuples for conservation laws that still
+    appear in other conservation laws
+
+    Arguments:
+        conservation_laws: output of _flatten_conservation_laws @type dict
+
+    Returns:
+    list of tuples containing substitution rules to be used with sympy subs
+
+    Raises:
+
+    """
+    free_symbols_cl = _conservation_law_variables(conservation_laws)
+    return [
+        (cl['state'], cl['state_expr']) for cl in conservation_laws
+        if cl['state'] in free_symbols_cl
+    ]
+
+
+def _conservation_law_variables(conservation_laws):
+    """Construct the set of all free variables from a list of conservation laws
+
+
+    Arguments:
+        conservation_laws: list of conservation laws (sympy.Basic) @type list
+
+    Returns:
+    Set union of all free_symbols
+
+    Raises:
+
+    """
+    variables = set()
+    for cl in conservation_laws:
+        variables |= cl['state_expr'].free_symbols
+    return variables
+
+
+def has_fixed_parameter_ic(specie, model, ODE):
+    """Wrapper to interface ODE.state_has_fixed_parameter_initial_condition
+    from a pysb specie/model arguments
+
+    Arguments:
+        specie: pysb species @type pysb.core.ComplexPattern
+        model: pysb model @type pysb.core.Model
+        ODE: ODE model @type amici.ODE
+
+    Returns:
+    False if the species does not have an initial condition at all.
+    Otherwise the return value of
+    ODE.state_has_fixed_parameter_initial_condition
+
+    Raises:
+
+    """
+    # ComplexPatterns are not hashable, so we have to compare by string
+    ic_index = next(
+        (
+            ic
+            for ic, condition in enumerate(model.initial_conditions)
+            if pysb.pattern.match_complex_pattern(condition[0],
+                                                  specie, exact=True)
+        ),
+        None
+    )
+    if ic_index is None:
+        return False
+    else:
+        return ODE.state_has_fixed_parameter_initial_condition(
+            ic_index
+        )
+
+
+def extract_monomers(complex_patterns):
+    """Constructs a list of monomer names contained in complex patterns.
+    Multiplicity of names corresponds to the stoichiometry in the complex.
+
+    Arguments:
+        specie: (list of) complex pattern(s) @type pysb.core.ComplexPattern
+
+    Returns:
+    list of monomer names
+
+    Raises:
+
+    """
+    if not isinstance(complex_patterns, list):
+        complex_patterns = [complex_patterns]
+    return [
+        mp.monomer.name
+        for cp in complex_patterns
+        if cp is not None
+        for mp in cp.monomer_patterns
+    ]
+
+
+def _get_unconserved_monomers(rule, model):
+    """Constructs the set of monomer names for which the rule changes the
+    stoichiometry of the monomer in the specified model.
+
+    Arguments:
+        rule: rule @type pysb.core.Rule
+        model: model @type pysb.core.Model
+
+    Returns:
+    set of monomer names for which the stoichiometry is not conserved
+
+    Raises:
+
+    """
+    unconserved_monomers = set()
+
+    if not rule.delete_molecules \
+            and len(rule.product_pattern.complex_patterns) == 0:
+        # if delete_molecules is not True but we have a degradation rule,
+        # we have to actually go through the reactions that are created by
+        # the rule
+        for reaction in [r for r in model.reactions if rule.name in r['rule']]:
+            unconserved_monomers |= _get_changed_stoichiometries(
+                [model.species[ix] for ix in reaction['reactants']],
+                [model.species[ix] for ix in reaction['products']]
+            )
+    else:
+        # otherwise we can simply extract all information for the rule
+        # itself, which is computationally much more efficient
+        unconserved_monomers |= _get_changed_stoichiometries(
+            rule.reactant_pattern.complex_patterns,
+            rule.product_pattern.complex_patterns
+        )
+
+    return unconserved_monomers
+
+
+def _get_changed_stoichiometries(reactants, products):
+    """Constructs the set of monomer names which have different
+    stoichiometries in reactants and products.
+
+    Arguments:
+        reactants: (list of) complex pattern(s) @type pysb.core.ComplexPattern
+        products: (list of) complex pattern(s) @type pysb.core.ComplexPattern
+
+    Returns:
+    set of monomer name for which the stoichiometry changed
+
+    Raises:
+
+    """
+
+    changed_stoichiometries = set()
+
+    reactant_monomers = extract_monomers(
+        reactants
+    )
+
+    product_monomers = extract_monomers(
+        products
+    )
+
+    for monomer in set(reactant_monomers + product_monomers):
+        if reactant_monomers.count(monomer) != product_monomers.count(monomer):
+            changed_stoichiometries |= {monomer}
+
+    return changed_stoichiometries
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/sbml_import.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/sbml_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e2a74f9262558c8120a5a8513b63fbf9e44da62
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/sbml_import.py
@@ -0,0 +1,1375 @@
+"""@package amici.sbml_import The SBML import module for Python."""
+
+import sympy as sp
+import libsbml as sbml
+import re
+import math
+import itertools as itt
+import warnings
+from typing import Dict, Union, List, Callable, Any, Iterable
+
+from .ode_export import ODEExporter, ODEModel
+from . import has_clibs
+
+from sympy.logic.boolalg import BooleanTrue as spTrue
+from sympy.logic.boolalg import BooleanFalse as spFalse
+
+class SBMLException(Exception):
+    pass
+
+
+## default dict for symbols
+default_symbols = {
+    'species': {},
+    'parameter': {},
+    'fixed_parameter': {},
+    'observable': {},
+    'expression': {},
+    'sigmay': {},
+    'my': {},
+    'llhy': {},
+}
+
+
+class SbmlImporter:
+    """The SbmlImporter class generates AMICI C++ files for a model provided in
+    the Systems Biology Markup Language (SBML).
+
+    Attributes:
+
+        show_sbml_warnings: indicates whether libSBML warnings should be
+        displayed @type bool
+
+        symbols: dict carrying symbolic definitions @type dict
+
+        sbml_reader: the libSBML sbml reader [!not storing this will result
+        in a segfault!]
+
+        sbml_doc: document carrying the sbml definition [!not storing this
+        will result in a segfault!]
+
+        sbml: sbml definition [!not storing this will result in a segfault!]
+
+        speciesIndex: maps species names to indices @type dict
+
+        speciesCompartment: compartment for each species @type
+        sympy.Matrix
+
+        constantSpecies: ids of species that are marked as constant @type list
+
+        boundaryConditionSpecies: ids of species that are marked as boundary
+        condition @type list
+
+        speciesHasOnlySubstanceUnits: flags indicating whether a species has
+        only substance units @type list
+
+        speciesConversionFactor: conversion factors for every species @type
+        sympy.Matrix
+
+        compartmentSymbols: compartment ids @type sympy.Matrix
+
+        compartmentVolume: numeric/symbolic compartment volumes @type
+        sympy.Matrix
+
+        stoichiometricMatrix: stoichiometric matrix of the model @type
+        sympy.Matrix
+
+        fluxVector: reaction kinetic laws @type sympy.Matrix
+
+        local_symbols: model symbols for sympy to consider during sympification
+        see `locals`argument in `sympy.sympify` @type dict
+
+    """
+
+    def __init__(
+            self,
+            sbml_source: Union[str, sbml.Model],
+            show_sbml_warnings: bool = False,
+            from_file: bool = True):
+        """Create a new Model instance.
+
+        Arguments:
+
+            sbml_source: Either a path to SBML file where the model is
+                specified, or a model string as created by
+                sbml.sbmlWriter().writeSBMLToString() or an instance of
+                `libsbml.Model`.
+
+            show_sbml_warnings: Indicates whether libSBML warnings should be displayed.
+
+            from_file: Whether `sbml_source` is a file name (True, default), or
+                an SBML string
+
+        Raises:
+
+        """
+        if isinstance(sbml_source, sbml.Model):
+            self.sbml_doc = sbml_source.getSBMLDocument()
+        else:
+            self.sbml_reader = sbml.SBMLReader()
+            if from_file:
+                sbml_doc = self.sbml_reader.readSBMLFromFile(sbml_source)
+            else:
+                sbml_doc = self.sbml_reader.readSBMLFromString(sbml_source)
+            self.sbml_doc = sbml_doc
+
+        self.show_sbml_warnings = show_sbml_warnings
+
+        # process document
+        self.process_document()
+
+        self.sbml = self.sbml_doc.getModel()
+
+        # Long and short names for model components
+        self.symbols = dict()
+        self.reset_symbols()
+
+        self.local_symbols = {}
+
+    def process_document(self):
+        """Validate and simplify document.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        # Ensure we got a valid SBML model, otherwise further processing
+        # might lead to undefined results
+        self.sbml_doc.validateSBML()
+        checkLibSBMLErrors(self.sbml_doc, self.show_sbml_warnings)
+
+        # apply several model simplifications that make our life substantially
+        # easier
+        if len(self.sbml_doc.getModel().getListOfFunctionDefinitions()) > 0:
+            convertConfig = sbml.SBMLFunctionDefinitionConverter()\
+                .getDefaultProperties()
+            self.sbml_doc.convert(convertConfig)
+
+        convertConfig = sbml.SBMLLocalParameterConverter().\
+            getDefaultProperties()
+        self.sbml_doc.convert(convertConfig)
+
+        # If any of the above calls produces an error, this will be added to
+        # the SBMLError log in the sbml document. Thus, it is sufficient to
+        # check the error log just once after all conversion/validation calls.
+        checkLibSBMLErrors(self.sbml_doc, self.show_sbml_warnings)
+
+    def reset_symbols(self):
+        """Reset the symbols attribute to default values
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        self.symbols = default_symbols
+
+    def sbml2amici(self,
+                   modelName: str,
+                   output_dir: str = None,
+                   observables: Dict[str, Dict[str, str]] = None,
+                   constantParameters: List[str] = None,
+                   sigmas: Dict[str, Union[str, float]] = None,
+                   noise_distributions: Dict[str, str] = None,
+                   verbose: bool = False,
+                   assume_pow_positivity: bool = False,
+                   compiler: str = None,
+                   allow_reinit_fixpar_initcond: bool = True,
+                   compile: bool = True
+                   ) -> None:
+        """Generate AMICI C++ files for the model provided to the constructor.
+
+        The resulting model can be imported as a regular Python module (if
+        `compile=True`), or used from Matlab or C++ as described in the
+        documentation of the respective AMICI interface.
+
+        Note that this generates model ODEs for changes in concentrations, not
+        amounts. The simulation results obtained from the model will be
+        concentrations, independently of the SBML `hasOnlySubstanceUnits`
+        attribute.
+
+        Arguments:
+            modelName: name of the model/model directory
+
+            output_dir: see sbml_import.setPaths()
+
+            observables: dictionary( observableId:{'name':observableName
+                (optional), 'formula':formulaString)}) to be added to the model
+
+            constantParameters: list of SBML Ids identifying constant parameters
+
+            sigmas: dictionary(observableId:
+                    sigma value or (existing) parameter name)
+
+            noise_distributions: dictionary(observableId: noise type).
+                If nothing is passed
+                for some observable id, a normal model is assumed as default.
+
+            verbose: more verbose output if True
+
+            assume_pow_positivity: if set to True, a special pow function is
+                used to avoid problems with state variables that may become
+                negative due to numerical errors
+
+            compiler: distutils/setuptools compiler selection to build the
+                python extension
+
+            allow_reinit_fixpar_initcond: see ode_export.ODEExporter
+
+            compile: If True, compile the generated Python package,
+                if False, just generate code.
+
+        Returns:
+
+        Raises:
+
+        """
+        if observables is None:
+            observables = {}
+
+        if constantParameters is None:
+            constantParameters = []
+
+        if sigmas is None:
+            sigmas = {}
+
+        if noise_distributions is None:
+            noise_distributions = {}
+
+        self.reset_symbols()
+        self.processSBML(constantParameters)
+        self.processObservables(observables, sigmas, noise_distributions)
+        ode_model = ODEModel()
+        ode_model.import_from_sbml_importer(self)
+        exporter = ODEExporter(
+            ode_model,
+            outdir=output_dir,
+            verbose=verbose,
+            assume_pow_positivity=assume_pow_positivity,
+            compiler=compiler,
+            allow_reinit_fixpar_initcond=allow_reinit_fixpar_initcond
+        )
+        exporter.setName(modelName)
+        exporter.setPaths(output_dir)
+        exporter.generateModelCode()
+
+        if compile:
+            if not has_clibs:
+                warnings.warn('AMICI C++ extensions have not been built. '
+                              'Generated model code, but unable to compile.')
+            exporter.compileModel()
+
+    def processSBML(self, constantParameters: List[str] = None):
+        """Read parameters, species, reactions, and so on from SBML model
+
+        Arguments:
+            constantParameters: SBML Ids identifying constant parameters
+
+        Returns:
+
+        Raises:
+
+        """
+
+        if constantParameters is None:
+            constantParameters = []
+
+        self.checkSupport()
+        self._gather_locals()
+        self.processParameters(constantParameters)
+        self.processSpecies()
+        self.processReactions()
+        self.processCompartments()
+        self.processRules()
+        self.processVolumeConversion()
+        self.processTime()
+        self.cleanReservedSymbols()
+        self.replaceSpecialConstants()
+
+    def checkSupport(self):
+        """Check whether all required SBML features are supported.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        if len(self.sbml.getListOfSpecies()) == 0:
+            raise SBMLException('Models without species '
+                                'are currently not supported!')
+
+        if hasattr(self.sbml, 'all_elements_from_plugins') \
+                and len(self.sbml.all_elements_from_plugins) > 0:
+            raise SBMLException('SBML extensions are currently not supported!')
+
+        if len(self.sbml.getListOfEvents()) > 0:
+            raise SBMLException('Events are currently not supported!')
+
+        if any([not(rule.isAssignment())
+                for rule in self.sbml.getListOfRules()]):
+            raise SBMLException('Algebraic and rate '
+                                'rules are currently not supported!')
+
+        if any([reaction.getFast()
+                for reaction in self.sbml.getListOfReactions()]):
+            raise SBMLException('Fast reactions are currently not supported!')
+
+        if any([any([not element.getStoichiometryMath() is None
+                for element in list(reaction.getListOfReactants())
+                + list(reaction.getListOfProducts())])
+                for reaction in self.sbml.getListOfReactions()]):
+            raise SBMLException('Non-unity stoichiometry is'
+                                ' currently not supported!')
+
+    def _gather_locals(self):
+        """Populate self.local_symbols with all model entities.
+
+        This is later used during sympifications to avoid sympy builtins
+        shadowing model entities.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        for s in self.sbml.getListOfSpecies():
+            self.local_symbols[s.getId()] = sp.Symbol(s.getId())
+
+        for p in self.sbml.getListOfParameters():
+            self.local_symbols[p.getId()] = sp.Symbol(p.getId())
+
+    def processSpecies(self):
+        """Get species information from SBML model.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        species = self.sbml.getListOfSpecies()
+
+        self.speciesIndex = {
+            species_element.getId(): species_index
+            for species_index, species_element in enumerate(species)
+        }
+
+        self.symbols['species']['identifier'] = sp.Matrix(
+            [sp.Symbol(spec.getId()) for spec in species]
+        )
+        self.symbols['species']['name'] = [spec.getName() for spec in species]
+
+        self.speciesCompartment = sp.Matrix(
+            [sp.Symbol(spec.getCompartment()) for spec in species]
+        )
+
+        self.constantSpecies = [species_element.getId()
+                                for species_element in species
+                                if species_element.getConstant()]
+
+        self.boundaryConditionSpecies = [
+            species_element.getId()
+            for species_element in species
+            if species_element.getBoundaryCondition()
+        ]
+        self.speciesHasOnlySubstanceUnits = [
+            specie.getHasOnlySubstanceUnits() for specie in species
+        ]
+
+        concentrations = [spec.getInitialConcentration() for spec in species]
+        amounts = [spec.getInitialAmount() for spec in species]
+
+        def get_species_initial(index, conc):
+            # We always simulate concentrations!
+            if self.speciesHasOnlySubstanceUnits[index]:
+                if species[index].isSetInitialAmount() \
+                        and not math.isnan(amounts[index]):
+                    return sp.sympify(amounts[index]) \
+                           / self.speciesCompartment[index]
+                if species[index].isSetInitialConcentration():
+                    return sp.sympify(conc)
+            else:
+                if species[index].isSetInitialConcentration():
+                    return sp.sympify(conc)
+
+                if species[index].isSetInitialAmount() \
+                        and not math.isnan(amounts[index]):
+                    return sp.sympify(amounts[index]) \
+                           / self.speciesCompartment[index]
+
+            return self.symbols['species']['identifier'][index]
+
+        species_initial = sp.Matrix(
+            [get_species_initial(index, conc)
+             for index, conc in enumerate(concentrations)]
+        )
+
+        species_ids = [spec.getId() for spec in self.sbml.getListOfSpecies()]
+        for initial_assignment in self.sbml.getListOfInitialAssignments():
+            if initial_assignment.getId() in species_ids:
+                index = species_ids.index(
+                        initial_assignment.getId()
+                    )
+                symMath = sp.sympify(_parse_logical_operators(
+                    sbml.formulaToL3String(initial_assignment.getMath())),
+                    locals=self.local_symbols
+                )
+                if symMath is not None:
+                    symMath = _parse_special_functions(symMath)
+                    _check_unsupported_functions(symMath, 'InitialAssignment')
+                    species_initial[index] = symMath
+
+        for ix, (symbol, init) in enumerate(zip(
+                    self.symbols['species']['identifier'], species_initial
+        )):
+            if symbol == init:
+                species_initial[ix] = sp.sympify(0.0)
+
+        # flatten initSpecies
+        while any([species in species_initial.free_symbols
+                   for species in self.symbols['species']['identifier']]):
+            species_initial = species_initial.subs([
+                (symbol, init)
+                for symbol, init in zip(
+                    self.symbols['species']['identifier'], species_initial
+                )
+            ])
+
+        self.symbols['species']['value'] = species_initial
+
+        if self.sbml.isSetConversionFactor():
+            conversion_factor = sp.Symbol(self.sbml.getConversionFactor())
+        else:
+            conversion_factor = 1.0
+
+        self.speciesConversionFactor = sp.Matrix([
+             sp.sympify(specie.getConversionFactor())
+             if specie.isSetConversionFactor()
+             else conversion_factor
+             for specie in species
+        ])
+
+    def processParameters(self, constantParameters: List[str] = None):
+        """Get parameter information from SBML model.
+
+        Arguments:
+            constantParameters: SBML Ids identifying constant parameters
+
+        Returns:
+
+        Raises:
+
+        """
+
+        if constantParameters is None:
+            constantParameters = []
+
+        # Ensure specified constant parameters exist in the model
+        for parameter in constantParameters:
+            if not self.sbml.getParameter(parameter):
+                raise KeyError('Cannot make %s a constant parameter: '
+                               'Parameter does not exist.' % parameter)
+
+        parameter_ids = [par.getId() for par
+                         in self.sbml.getListOfParameters()]
+        for initial_assignment in self.sbml.getListOfInitialAssignments():
+            if initial_assignment.getId() in parameter_ids:
+                raise SBMLException('Initial assignments for parameters are'
+                                    ' currently not supported')
+
+        fixedParameters = [parameter for parameter
+                           in self.sbml.getListOfParameters()
+                           if parameter.getId() in constantParameters
+                           ]
+
+        rulevars = [rule.getVariable() for rule in self.sbml.getListOfRules()]
+
+        parameters = [ parameter for parameter
+                       in self.sbml.getListOfParameters()
+                       if parameter.getId() not in constantParameters
+                       and parameter.getId() not in rulevars]
+
+        loop_settings = {
+            'parameter': {
+                'var': parameters,
+                'name': 'parameter',
+
+            },
+            'fixed_parameter': {
+                'var': fixedParameters,
+                'name': 'fixedParameter'
+            }
+
+        }
+
+        for partype in loop_settings:
+            settings = loop_settings[partype]
+
+            self.symbols[partype]['identifier'] = sp.Matrix(
+                [sp.Symbol(par.getId()) for par in settings['var']]
+            )
+            self.symbols[partype]['name'] = [
+                par.getName() for par in settings['var']
+            ]
+            self.symbols[partype]['value'] = [
+                par.getValue() for par in settings['var']
+            ]
+            setattr(
+                self,
+                f'{settings["name"]}Index',
+                {
+                    parameter_element.getId(): parameter_index
+                    for parameter_index, parameter_element
+                    in enumerate(settings['var'])
+                }
+            )
+
+    def processCompartments(self):
+        """Get compartment information, stoichiometric matrix and fluxes from
+        SBML model.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        compartments = self.sbml.getListOfCompartments()
+        self.compartmentSymbols = sp.Matrix(
+            [sp.Symbol(comp.getId()) for comp in compartments]
+        )
+        self.compartmentVolume = sp.Matrix(
+            [sp.sympify(comp.getVolume()) if comp.isSetVolume()
+            else sp.sympify(1.0) for comp in compartments]
+        )
+
+        compartment_ids = [comp.getId() for comp in compartments]
+        for initial_assignment in self.sbml.getListOfInitialAssignments():
+            if initial_assignment.getId() in compartment_ids:
+                index = compartment_ids.index(
+                        initial_assignment.getId()
+                    )
+                self.compartmentVolume[index] = sp.sympify(
+                    sbml.formulaToL3String(initial_assignment.getMath()),
+                    locals=self.local_symbols
+                )
+
+        for comp, vol in zip(self.compartmentSymbols, self.compartmentVolume):
+            self.replaceInAllExpressions(
+               comp, vol
+            )
+
+    def processReactions(self):
+        """Get reactions from SBML model.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        reactions = self.sbml.getListOfReactions()
+        nr = len(reactions)
+        nx = len(self.symbols['species']['name'])
+        # stoichiometric matrix
+        self.stoichiometricMatrix = sp.SparseMatrix(sp.zeros(nx, nr))
+        self.fluxVector = sp.zeros(nr, 1)
+
+        assignment_ids = [ass.getId()
+                          for ass in self.sbml.getListOfInitialAssignments()]
+        rulevars = [rule.getVariable()
+                                for rule in self.sbml.getListOfRules()
+                                if rule.getFormula() != '']
+
+        reaction_ids = [
+            reaction.getId() for reaction in reactions
+            if reaction.isSetId()
+        ]
+
+        def getElementFromAssignment(element_id):
+            assignment = self.sbml.getInitialAssignment(
+                element_id
+            )
+            sym = sp.sympify(sbml.formulaToL3String(assignment.getMath()),
+                             locals=self.local_symbols)
+            # this is an initial assignment so we need to use
+            # initial conditions
+            if sym is not None:
+                sym = sym.subs(
+                    self.symbols['species']['identifier'],
+                    self.symbols['species']['value']
+                )
+            return sym
+
+        def getElementStoichiometry(element):
+            if element.isSetId():
+                if element.getId() in assignment_ids:
+                    symMath = getElementFromAssignment(element.getId())
+                    if symMath is None:
+                        symMath = sp.sympify(element.getStoichiometry())
+                elif element.getId() in rulevars:
+                    return sp.Symbol(element.getId())
+                else:
+                    # dont put the symbol if it wont get replaced by a
+                    # rule
+                    symMath = sp.sympify(element.getStoichiometry())
+            elif element.isSetStoichiometry():
+                symMath = sp.sympify(element.getStoichiometry())
+            else:
+                return sp.sympify(1.0)
+            symMath = _parse_special_functions(symMath)
+            _check_unsupported_functions(symMath, 'Stoichiometry')
+            return symMath
+
+        def isConstant(specie):
+            return specie in self.constantSpecies or \
+                specie in self.boundaryConditionSpecies
+
+        for reactionIndex, reaction in enumerate(reactions):
+            for elementList, sign in [(reaction.getListOfReactants(), -1.0),
+                                       (reaction.getListOfProducts(), 1.0)]:
+                elements = {}
+                for index, element in enumerate(elementList):
+                    # we need the index here as we might have multiple elements
+                    # for the same species
+                    elements[index] = {'species': element.getSpecies()}
+                    elements[index]['stoichiometry'] = getElementStoichiometry(
+                        element
+                    )
+
+                for index in elements.keys():
+                    if not isConstant(elements[index]['species']):
+                        specieIndex = self.speciesIndex[
+                            elements[index]['species']
+                        ]
+                        self.stoichiometricMatrix[specieIndex, reactionIndex] \
+                            += sign \
+                            * elements[index]['stoichiometry'] \
+                            * self.speciesConversionFactor[specieIndex] \
+                            / self.speciesCompartment[specieIndex]
+
+            # usage of formulaToL3String ensures that we get "time" as time
+            # symbol
+            math = sbml.formulaToL3String(reaction.getKineticLaw().getMath())
+            try:
+                symMath = sp.sympify(_parse_logical_operators(math),
+                                     locals=self.local_symbols)
+            except SBMLException as Ex:
+                raise Ex
+            except:
+                raise SBMLException(f'Kinetic law "{math}" contains an '
+                                    'unsupported expression!')
+            symMath = _parse_special_functions(symMath)
+            _check_unsupported_functions(symMath, 'KineticLaw')
+            for r in reactions:
+                elements = list(r.getListOfReactants()) \
+                           + list(r.getListOfProducts())
+                for element in elements:
+                    if element.isSetId() & element.isSetStoichiometry():
+                        symMath = symMath.subs(
+                            sp.sympify(element.getId(),
+                                       locals=self.local_symbols),
+                            sp.sympify(element.getStoichiometry())
+                        )
+
+            self.fluxVector[reactionIndex] = symMath
+            if any([
+                str(symbol) in reaction_ids
+                for symbol in self.fluxVector[reactionIndex].free_symbols
+            ]):
+                raise SBMLException(
+                    'Kinetic laws involving reaction ids are currently'
+                    ' not supported!'
+                )
+
+    def processRules(self):
+        """Process Rules defined in the SBML model.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        rules = self.sbml.getListOfRules()
+
+        rulevars = getRuleVars(rules, local_symbols=self.local_symbols)
+        fluxvars = self.fluxVector.free_symbols
+        specvars = self.symbols['species']['identifier'].free_symbols
+        volumevars = self.compartmentVolume.free_symbols
+        compartmentvars = self.compartmentSymbols.free_symbols
+        parametervars = sp.Matrix([
+            sp.Symbol(par.getId()) for par in self.sbml.getListOfParameters()
+        ])
+        stoichvars = self.stoichiometricMatrix.free_symbols
+
+        assignments = {}
+
+        for rule in rules:
+            if rule.getFormula() == '':
+                continue
+            variable = sp.sympify(rule.getVariable(),
+                                  locals=self.local_symbols)
+            # avoid incorrect parsing of pow(x, -1) in symengine
+            formula = sp.sympify(_parse_logical_operators(
+                sbml.formulaToL3String(rule.getMath())),
+                locals=self.local_symbols)
+            formula = _parse_special_functions(formula)
+            _check_unsupported_functions(formula, 'Rule')
+
+            if variable in stoichvars:
+                self.stoichiometricMatrix = \
+                    self.stoichiometricMatrix.subs(variable, formula)
+
+            if variable in specvars:
+                raise SBMLException('Species assignment rules are currently'
+                                    ' not supported!')
+
+            if variable in compartmentvars:
+                raise SBMLException('Compartment assignment rules are'
+                                    ' currently not supported!')
+
+            if variable in parametervars:
+                try:
+                    idx = self.parameterIndex[str(variable)]
+                    self.symbols['parameter']['value'][idx] \
+                        = float(formula)
+                except:
+                    self.sbml.removeParameter(str(variable))
+                    assignments[str(variable)] = formula
+
+            if variable in fluxvars:
+                self.fluxVector = self.fluxVector.subs(variable, formula)
+
+            if variable in volumevars:
+                self.compartmentVolume = \
+                    self.compartmentVolume.subs(variable, formula)
+
+            if variable in rulevars:
+                for nested_rule in rules:
+                    nested_formula = sp.sympify(
+                        sbml.formulaToL3String(nested_rule.getMath()),
+                        locals=self.local_symbols)
+                    nested_formula = \
+                        nested_formula.subs(variable, formula)
+                    nested_rule.setFormula(str(nested_formula))
+
+                for variable in assignments:
+                    assignments[variable].subs(variable, formula)
+
+        # do this at the very end to ensure we have flattened all recursive
+        # rules
+        for variable in assignments.keys():
+            self.replaceInAllExpressions(
+                sp.sympify(variable, locals=self.local_symbols),
+                assignments[variable]
+            )
+
+    def processVolumeConversion(self):
+        """Convert equations from amount to volume.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        compartments = self.speciesCompartment
+        for comp, vol in zip(self.compartmentSymbols, self.compartmentVolume):
+            compartments = compartments.subs(comp, vol)
+        for index, bool in enumerate(self.speciesHasOnlySubstanceUnits):
+            if bool:
+                self.fluxVector = \
+                    self.fluxVector.subs(
+                        self.symbols['species']['identifier'][index],
+                        self.symbols['species']['identifier'][index]
+                        * compartments[index]
+                    )
+
+    def processTime(self):
+        """Convert time_symbol into cpp variable.
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        sbmlTimeSymbol = sp.Symbol('time')
+        amiciTimeSymbol = sp.Symbol('t')
+
+        self.replaceInAllExpressions(sbmlTimeSymbol, amiciTimeSymbol)
+
+    def processObservables(self, observables: Dict[str, Dict[str, str]],
+                           sigmas: Dict[str, Union[str, float]],
+                           noise_distributions: Dict[str, str]):
+        """Perform symbolic computations required for objective function
+        evaluation.
+
+        Arguments:
+            observables: dictionary(observableId: {'name':observableName
+                (optional), 'formula':formulaString)})
+                to be added to the model
+
+            sigmas: dictionary(observableId: sigma value or (existing)
+                parameter name)
+
+            noise_distributions: dictionary(observableId: noise type)
+                See `sbml2amici`.
+
+        Returns:
+
+        Raises:
+
+        """
+
+        if observables is None:
+            observables = {}
+
+        if sigmas is None:
+            sigmas = {}
+        else:
+            # Ensure no non-existing observableIds have been specified
+            # (no problem here, but usually an upstream bug)
+            unknown_ids = set(sigmas.keys()) - set(observables.keys())
+            if unknown_ids:
+                raise ValueError(
+                    f"Sigma provided for unknown observableIds: "
+                    f"{unknown_ids}.")
+
+        if noise_distributions is None:
+            noise_distributions = {}
+        else:
+            # Ensure no non-existing observableIds have been specified
+            # (no problem here, but usually an upstream bug)
+            unknown_ids = set(noise_distributions.keys()) - set(observables.keys())
+            if unknown_ids:
+                raise ValueError(
+                    f"Noise distribution provided for unknown observableIds: "
+                    f"{unknown_ids}.")
+
+        speciesSyms = self.symbols['species']['identifier']
+
+        # add user-provided observables or make all species observable
+        if observables:
+            # Replace logX(.) by log(., X) since symengine cannot parse the
+            # former. Also replace symengine-incompatible sbml log(basis, x)
+            for observable in observables:
+                observables[observable]['formula'] = re.sub(
+                    r'(^|\W)log(\d+)\(', r'\g<1>1/ln(\2)*ln(',
+                    observables[observable]['formula']
+                )
+                repl = replaceLogAB(observables[observable]['formula'])
+                if repl != observables[observable]['formula']:
+                    print(
+                        f'Replaced "{observables[observable]["formula"]}" by '
+                        f'"{repl}", assuming first argument to log() was the '
+                        f'basis.'
+                    )
+                    observables[observable]['formula'] = repl
+
+            observableValues = sp.Matrix([
+                sp.sympify(observables[observable]['formula'],
+                           locals=self.local_symbols)
+                for observable in observables
+            ])
+            observableNames = [
+                observables[observable]['name'] if 'name' in observables[
+                    observable].keys()
+                else f'y{index}'
+                for index, observable in enumerate(observables)
+            ]
+            observableSyms = sp.Matrix([
+                sp.symbols(obs, real=True) for obs in observables.keys()
+            ])
+        else:
+            observableValues = speciesSyms
+            observableNames = [
+                f'x{index}' for index in range(len(speciesSyms))
+            ]
+            observableSyms = sp.Matrix(
+                [sp.symbols(f'y{index}', real=True) for index in range(len(speciesSyms))]
+            )
+
+        sigmaYSyms = sp.Matrix(
+            [sp.symbols(f'sigma{symbol}', real=True) for symbol in observableSyms]
+        )
+        sigmaYValues = sp.Matrix(
+            [1.0] * len(observableSyms)
+        )
+
+        # set user-provided sigmas
+        for iy, obsName in enumerate(observables):
+            if obsName in sigmas:
+                sigmaYValues[iy] = sigmas[obsName]
+
+        measurementYSyms = sp.Matrix(
+            [sp.symbols(f'm{symbol}', real=True) for symbol in observableSyms]
+        )
+        measurementYValues = sp.Matrix(
+            [0.0] * len(observableSyms)
+        )
+
+        # set cost functions
+        llhYStrings = []
+        for y_name in observableNames:
+            llhYStrings.append(noise_distribution_to_cost_function(
+                noise_distributions.get(y_name, 'normal')))
+
+        llhYValues = []
+        for llhYString, o_sym, m_sym, s_sym \
+                in zip(llhYStrings, observableSyms,
+                       measurementYSyms, sigmaYSyms):
+            f = sp.sympify(llhYString(o_sym), locals={str(o_sym): o_sym,
+                                                      str(m_sym): m_sym,
+                                                      str(s_sym): s_sym})
+            llhYValues.append(f)
+        llhYValues = sp.Matrix(llhYValues)
+
+        llhYSyms = sp.Matrix(
+            [sp.Symbol(f'J{symbol}') for symbol in observableSyms]
+        )
+
+        # set symbols
+        self.symbols['observable']['identifier'] = observableSyms
+        self.symbols['observable']['name'] = l2s(observableNames)
+        self.symbols['observable']['value'] = observableValues
+        self.symbols['sigmay']['identifier'] = sigmaYSyms
+        self.symbols['sigmay']['name'] = l2s(sigmaYSyms)
+        self.symbols['sigmay']['value'] = sigmaYValues
+        self.symbols['my']['identifier'] = measurementYSyms
+        self.symbols['my']['name'] = l2s(measurementYSyms)
+        self.symbols['my']['value'] = measurementYValues
+        self.symbols['llhy']['value'] = llhYValues
+        self.symbols['llhy']['name'] = l2s(llhYSyms)
+        self.symbols['llhy']['identifier'] = llhYSyms
+
+    def replaceInAllExpressions(self, old: sp.Symbol, new: sp.Symbol):
+        """Replace 'old' by 'new' in all symbolic expressions.
+
+        Arguments:
+            old: symbolic variables to be replaced
+
+            new: replacement symbolic variables
+
+
+        Returns:
+
+        Raises:
+
+        """
+        fields = [
+            'stoichiometricMatrix', 'fluxVector',
+        ]
+        for field in fields:
+            if field in dir(self):
+                self.__setattr__(field, self.__getattribute__(field).subs(
+                    old, new
+                ))
+        symbols = [
+            'species', 'observables',
+        ]
+        for symbol in symbols:
+            if symbol in self.symbols:
+                self.symbols[symbol]['value'] = \
+                    self.symbols[symbol]['value'].subs(old, new)
+
+
+    def cleanReservedSymbols(self):
+        """Remove all reserved symbols from self.symbols
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        reservedSymbols = ['k','p','y','w']
+        for str in reservedSymbols:
+            old_symbol = sp.Symbol(str)
+            new_symbol = sp.Symbol('amici_' + str)
+            self.replaceInAllExpressions(old_symbol, new_symbol)
+            for symbol in self.symbols.keys():
+                if 'identifier' in self.symbols[symbol].keys():
+                    self.symbols[symbol]['identifier'] = \
+                        self.symbols[symbol]['identifier'].subs(old_symbol,new_symbol)
+
+    def replaceSpecialConstants(self):
+        """Replace all special constants by their respective SBML
+        csymbol definition
+
+        Arguments:
+
+        Returns:
+
+        Raises:
+
+        """
+        constants = [
+            (sp.Symbol('avogadro'), sp.Symbol('6.02214179e23')),
+        ]
+        for constant, value in constants:
+            # do not replace if any symbol is shadowing default definition
+            if not any([constant in self.symbols[symbol]['identifier']
+                        for symbol in self.symbols.keys()
+                        if 'identifier' in self.symbols[symbol].keys()]):
+                self.replaceInAllExpressions(constant, value)
+            else:
+                # yes sbml supports this but we wont. Are you really expecting
+                # to be saved if you are trying to shoot yourself in the foot?
+                raise SBMLException(
+                    f'Encountered currently unsupported element id {constant}!'
+                )
+
+
+def getRuleVars(rules, local_symbols=None):
+    """Extract free symbols in SBML rule formulas.
+
+    Arguments:
+        rules: sbml definitions of rules @type list
+        local_symbols: locals to pass to sympy.sympify
+
+    Returns:
+    Tuple of free symbolic variables in the formulas all provided rules
+
+    Raises:
+
+    """
+    return sp.Matrix(
+        [sp.sympify(sbml.formulaToL3String(rule.getMath()),
+                    locals=local_symbols)
+         for rule in rules if rule.getFormula() != '']
+    ).free_symbols
+
+
+def replaceLogAB(x):
+    """Replace log(a, b) in the given string by ln(b)/ln(a)
+
+    Works for nested parentheses and nested 'log's. This can be used to
+    circumvent the incompatible argument order between symengine (log(x,
+    basis)) and libsbml (log(basis, x)).
+
+    Arguments:
+        x: string to replace @type str
+
+    Returns:
+    string with replaced 'log's
+
+    Raises:
+
+    """
+
+    match = re.search(r'(^|\W)log\(', x)
+    if not match:
+        return x
+
+    # index of 'l' of 'log'
+    logStart = match.start() \
+            if match.end() - match.start() == 4 \
+            else match.start() + 1
+    level = 0 # parenthesis level
+    posComma = -1 # position of comma in log(a,b)
+    for i in range(logStart + 4, len(x)):
+        if x[i] == '(':
+            level += 1
+        elif x[i] == ')':
+            level -= 1
+            if level == -1: break
+        elif x[i] == ',' and level == 0:
+            posComma = i
+
+    if posComma < 0:
+        # was log(a), not log(a,b), so nothing to replace
+        return x
+
+    prefix = x[:logStart]
+    suffix = x[i+1:]
+    basis = x[logStart+4: posComma]
+    a = x[posComma+1: i]
+
+    replacement = f'{prefix}ln({a})/ln({basis}){suffix}'
+
+    return replaceLogAB(replacement)
+
+
+def l2s(inputs):
+    """Transforms a list into list of strings.
+
+    Arguments:
+        inputs: objects @type list
+
+    Returns:
+    list of str(object)
+
+    Raises:
+
+    """
+    return [str(inp) for inp in inputs]
+
+
+def checkLibSBMLErrors(sbml_doc, show_warnings=False):
+    """Checks the error log in the current self.sbml_doc.
+
+    Arguments:
+        sbml_doc: SBML document @type libsbml.SBMLDocument
+        show_warnings: display SBML warnings @type bool
+
+    Returns:
+
+    Raises:
+        raises SBMLException if errors with severity ERROR or FATAL have
+        occurred
+    """
+    num_warning = sbml_doc.getNumErrors(sbml.LIBSBML_SEV_WARNING)
+    num_error = sbml_doc.getNumErrors(sbml.LIBSBML_SEV_ERROR)
+    num_fatal = sbml_doc.getNumErrors(sbml.LIBSBML_SEV_FATAL)
+
+    if num_warning + num_error + num_fatal:
+        for iError in range(0, sbml_doc.getNumErrors()):
+            error = sbml_doc.getError(iError)
+            # we ignore any info messages for now
+            if error.getSeverity() >= sbml.LIBSBML_SEV_ERROR \
+                    or (show_warnings and
+                        error.getSeverity() >= sbml.LIBSBML_SEV_WARNING):
+                category = error.getCategoryAsString()
+                severity = error.getSeverityAsString()
+                error_message = error.getMessage()
+                print(f'libSBML {severity} ({category}): {error_message}')
+
+    if num_error + num_fatal:
+        raise SBMLException(
+            'SBML Document failed to load (see error messages above)'
+        )
+
+
+def _check_unsupported_functions(sym, expression_type, full_sym=None):
+    """Recursively checks the symbolic expression for unsupported symbolic
+    functions
+
+        Arguments:
+            sym: symbolic expressions @type sympy.Basic
+            expression_type: type of expression
+
+        Returns:
+
+        Raises:
+            raises SBMLException if an unsupported function is encountered
+    """
+    if full_sym is None:
+        full_sym = sym
+
+    unsupported_functions = [
+        sp.functions.factorial, sp.functions.ceiling, sp.functions.floor,
+        sp.function.UndefinedFunction
+    ]
+
+    unsupp_fun_type = next(
+        (
+            fun_type
+            for fun_type in unsupported_functions
+            if isinstance(sym.func, fun_type)
+        ),
+        None
+    )
+    if unsupp_fun_type:
+        raise SBMLException(f'Encountered unsupported expression '
+                            f'"{sym.func}" of type '
+                            f'"{unsupp_fun_type}" as part of a '
+                            f'{expression_type}: "{full_sym}"!')
+    for fun in list(sym._args) + [sym]:
+        unsupp_fun_type = next(
+            (
+                fun_type
+                for fun_type in unsupported_functions
+                if isinstance(fun, fun_type)
+            ),
+            None
+        )
+        if unsupp_fun_type:
+            raise SBMLException(f'Encountered unsupported expression '
+                                f'"{fun}" of type '
+                                f'"{unsupp_fun_type}" as part of a '
+                                f'{expression_type}: "{full_sym}"!')
+        if fun is not sym:
+            _check_unsupported_functions(fun, expression_type)
+
+
+def _parse_special_functions(sym, toplevel=True):
+    """Recursively checks the symbolic expression for functions which have be
+    to parsed in a special way, such as piecewise functions
+
+        Arguments:
+            sym: symbolic expressions @type sympy.Basic
+            toplevel: as this is called recursively,
+                are we in the top level expression?
+        Returns:
+
+        Raises:
+    """
+    args = tuple(_parse_special_functions(arg, False) for arg in sym._args)
+
+    if sym.__class__.__name__ == 'abs':
+        return sp.Abs(sym._args[0])
+    elif sym.__class__.__name__ == 'xor':
+        return sp.Xor(*sym.args)
+    elif sym.__class__.__name__ == 'piecewise':
+        # how many condition-expression pairs will we have?
+        return sp.Piecewise(*grouper(args, 2, True))
+    elif isinstance(sym, (sp.Function, sp.Mul, sp.Add)):
+        sym._args = args
+    elif toplevel:
+        # Replace boolean constants by numbers so they can be differentiated
+        #  must not replace in Piecewise function. Therefore, we only replace
+        #  it the complete expression consists only of a Boolean value.
+        if isinstance(sym, spTrue):
+            sym = sp.Float(1.0)
+        elif isinstance(sym, spFalse):
+            sym = sp.Float(0.0)
+
+    return sym
+
+
+def _parse_logical_operators(math_str: str) -> str:
+    """Parses a math string in order to replace logical operators by a form
+    parsable for sympy
+
+        Arguments:
+            math_str: str with mathematical expression
+
+        Returns:
+            math_str: parsed math_str
+
+        Raises:
+    """
+    if math_str is None:
+        return None
+
+    if ' xor(' in math_str or ' Xor(' in math_str:
+        raise SBMLException('Xor is currently not supported as logical '
+                            'operation.')
+
+    return (math_str.replace('&&', '&')).replace('||', '|')
+
+
+def grouper(iterable: Iterable, n: int, fillvalue: Any = None):
+    """Collect data into fixed-length chunks or blocks
+
+    E.g. grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx"
+
+    Arguments:
+        iterable: any iterable
+        n: chunk length
+        fillvalue: padding for last chunk if length < n
+
+    Returns:
+        itertools.zip_longest of requested chunks
+    """
+    args = [iter(iterable)] * n
+    return itt.zip_longest(*args, fillvalue=fillvalue)
+
+
+def assignmentRules2observables(sbml_model,
+                                filter_function=lambda *_: True):
+    """Turn assignment rules into observables.
+    Arguments:
+    sbml_model: an sbml Model instance
+    filter_function: callback function taking assignment variable as input
+    and returning True/False to indicate if the respective rule should be
+    turned into an observable
+    Returns:
+    A dictionary(observableId:{
+        'name': observableName,
+        'formula': formulaString
+    })
+    Raises:
+    """
+    warnings.warn("This function will be removed in future releases. "
+                  "This functionality is now included in "
+                  "https://github.com/ICB-DCM/PEtab .", DeprecationWarning)
+    observables = {}
+    for p in sbml_model.getListOfParameters():
+        parameter_id = p.getId()
+        if filter_function(p):
+            observables[parameter_id] = {
+                'name': p.getName(),
+                'formula': sbml_model.getAssignmentRuleByVariable(
+                    parameter_id
+                ).getFormula()
+            }
+
+    for parameter_id in observables:
+        sbml_model.removeRuleByVariable(parameter_id)
+        sbml_model.removeParameter(parameter_id)
+
+    return observables
+
+
+def noise_distribution_to_cost_function(
+        noise_distribution: str) -> Callable[[str], str]:
+    """
+    Parse cost string to a cost function definition amici can work with.
+
+    Arguments:
+
+    noise_distribution: A code specifying a noise model. Can be any of
+    [normal, log-normal, log10-normal, laplace, log-laplace, log10-laplace].
+    @type str
+
+    Returns:
+
+    A function that takes a strSymbol and then creates a cost function string
+    from it, which can be sympified.
+
+    Raises:
+    """
+    if noise_distribution in ['normal', 'lin-normal']:
+        llhYString = lambda strSymbol: \
+            f'0.5*log(2*pi*sigma{strSymbol}**2) ' \
+            f'+ 0.5*(({strSymbol} - m{strSymbol}) ' \
+            f'/ sigma{strSymbol})**2'
+    elif noise_distribution == 'log-normal':
+        llhYString = lambda strSymbol: \
+            f'0.5*log(2*pi*sigma{strSymbol}**2*m{strSymbol}**2) ' \
+            f'+ 0.5*((log({strSymbol}) - log(m{strSymbol})) ' \
+            f'/ sigma{strSymbol})**2'
+    elif noise_distribution == 'log10-normal':
+        llhYString = lambda strSymbol: \
+            f'0.5*log(2*pi*sigma{strSymbol}**2*m{strSymbol}**2) ' \
+            f'+ 0.5*((log({strSymbol}, 10) - log(m{strSymbol}, 10)) ' \
+            f'/ sigma{strSymbol})**2'
+    elif noise_distribution in ['laplace', 'lin-laplace']:
+        llhYString = lambda strSymbol: \
+            f'log(2*sigma{strSymbol}) ' \
+            f'+ Abs({strSymbol} - m{strSymbol}) ' \
+            f'/ sigma{strSymbol}'
+    elif noise_distribution == 'log-laplace':
+        llhYString = lambda strSymbol: \
+            f'log(2*sigma{strSymbol}*m{strSymbol}) ' \
+            f'+ Abs(log({strSymbol}) - log(m{strSymbol})) ' \
+            f'/ sigma{strSymbol}'
+    elif noise_distribution == 'log10-laplace':
+        llhYString = lambda strSymbol: \
+            f'log(2*sigma{strSymbol}*m{strSymbol}) ' \
+            f'+ Abs(log({strSymbol}, 10) - log(m{strSymbol}, 10)) ' \
+            f'/ sigma{strSymbol}'
+    else:
+        raise ValueError(
+            f"Cost type {cost_code} not reconized.")
+
+    return llhYString
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/setup.template.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/setup.template.py
new file mode 100644
index 0000000000000000000000000000000000000000..b31b3ea01448092ccd908e0a3ee76bcd78eca48e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/setup.template.py
@@ -0,0 +1,117 @@
+"""AMICI model package setup"""
+
+from setuptools import find_packages
+from distutils.core import setup, Extension
+from distutils import sysconfig
+import os
+from amici import amici_path, hdf5_enabled
+
+from amici.setuptools import (getBlasConfig,
+                              getHdf5Config,
+                              addCoverageFlagsIfRequired,
+                              addDebugFlagsIfRequired)
+
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+
+def getModelSources():
+    """Get list of source files for the amici base library"""
+    import glob
+    modelSources = glob.glob('*.cpp')
+    try:
+        modelSources.remove('main.cpp')
+    except ValueError:
+        pass
+    return modelSources
+
+
+def getAmiciLibs():
+    """Get list of libraries for the amici base library"""
+    return ['amici',
+            'sundials', 'suitesparse'
+            #'sundials_nvecserial', 'sundials_cvodes', 'sundials_idas',
+            #'klu', 'colamd', 'btf', 'amd', 'suitesparseconfig'
+            ]
+
+cxx_flags = ['-std=c++11']
+linker_flags = []
+
+addCoverageFlagsIfRequired(cxx_flags, linker_flags)
+addDebugFlagsIfRequired(cxx_flags, linker_flags)
+
+h5pkgcfg = getHdf5Config()
+
+blaspkgcfg = getBlasConfig()
+linker_flags.extend(blaspkgcfg.get('extra_link_args', []))
+
+libraries = [*getAmiciLibs(), *blaspkgcfg['libraries']]
+if hdf5_enabled:
+    libraries.extend(['hdf5_hl_cpp', 'hdf5_hl', 'hdf5_cpp', 'hdf5'])
+
+sources = ['swig/TPL_MODELNAME.i', *getModelSources()]
+
+
+# Remove the "-Wstrict-prototypes" compiler option, which isn't valid for
+# C++ to fix warnings.
+cfg_vars = sysconfig.get_config_vars()
+for key, value in cfg_vars.items():
+    if isinstance(value, str):
+        cfg_vars[key] = value.replace("-Wstrict-prototypes", "")
+
+# compiler and linker flags for libamici
+if 'AMICI_CXXFLAGS' in os.environ:
+    cxx_flags.extend(os.environ['AMICI_CXXFLAGS'].split(' '))
+if 'AMICI_LDFLAGS' in os.environ:
+    linker_flags.extend(os.environ['AMICI_LDFLAGS'].split(' '))
+
+# Build shared object
+model_module = Extension('TPL_MODELNAME._TPL_MODELNAME',
+                         sources=sources,
+                         include_dirs=[os.getcwd(),
+                                       os.path.join(amici_path, 'include'),
+                                       os.path.join(amici_path, 'ThirdParty/gsl'),
+                                       os.path.join(amici_path, 'ThirdParty/sundials/include'),
+                                       os.path.join(amici_path, 'ThirdParty/SuiteSparse/include'),
+                                       *h5pkgcfg['include_dirs'],
+                                       *blaspkgcfg['include_dirs']
+                                       ],
+                         libraries = libraries,
+                         library_dirs=[
+                             *h5pkgcfg['library_dirs'],
+                             *blaspkgcfg['library_dirs'],
+                             os.path.join(amici_path, 'libs')],
+                         swig_opts=['-c++', '-modern', '-outdir', 'TPL_MODELNAME',
+                                    '-I%s' % os.path.join(amici_path, 'swig'),
+                                    '-I%s' % os.path.join(amici_path, 'include'),],
+                         extra_compile_args=cxx_flags,
+                         extra_link_args=linker_flags
+                         )
+
+# Install
+setup(
+    name='TPL_MODELNAME',
+    version='TPL_PACKAGE_VERSION',
+    description='AMICI-generated module for model TPL_MODELNAME',
+    url='https://github.com/ICB-DCM/AMICI',
+    author='model-author-todo',
+    author_email='model-author-todo',
+    #license = 'BSD',
+    ext_modules=[model_module],
+    packages=find_packages(),
+    install_requires=['amici==TPL_AMICI_VERSION'],
+    extras_require={'wurlitzer': ['wurlitzer']},
+    python_requires='>=3.6',
+    package_data={
+    },
+    zip_safe = False,
+    include_package_data=True,
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Science/Research',
+        #'License :: OSI Approved :: BSD License',
+        'Operating System :: POSIX :: Linux',
+        'Operating System :: MacOS :: MacOS X',
+        'Programming Language :: Python',
+        'Programming Language :: C++',
+        'Topic :: Scientific/Engineering :: Bio-Informatics',
+    ],
+)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/setuptools.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/setuptools.py
new file mode 100644
index 0000000000000000000000000000000000000000..3cdb44a42809af6a9469c989523f4d7869618e6d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/amici/setuptools.py
@@ -0,0 +1,233 @@
+"""Helper functions for AMICI core and module package preparation"""
+
+import os
+import platform
+import shlex
+import subprocess
+import shutil
+
+from .swig import find_swig
+
+try:
+    import pkgconfig # optional
+    # pkgconfig python module might be installed without pkg-config binary being available
+    pkgconfig.exists('somePackageName')
+except (ModuleNotFoundError, EnvironmentError):
+    pkgconfig = None
+
+
+def getBlasConfig():
+    """
+    Find CBLAS-compatible BLAS
+
+    Arguments:
+
+    Returns:
+
+    Raises:
+
+    """
+
+    blaspkgcfg = {'include_dirs': [],
+                  'library_dirs': [],
+                  'libraries': [],
+                  'define_macros': [],
+                  'extra_compile_args': [],
+                  'extra_link_args': []
+                  }
+
+    # Check environment variables
+    if 'BLAS_CFLAGS' in os.environ:
+        blaspkgcfg['extra_compile_args'].extend(
+            shlex.split(os.environ['BLAS_CFLAGS'])
+        )
+
+    if 'BLAS_LIBS' in os.environ:
+        blaspkgcfg['extra_link_args'].extend(
+            shlex.split(os.environ['BLAS_LIBS'])
+        )
+
+    if 'BLAS_CFLAGS' in os.environ or 'BLAS_LIBS' in os.environ:
+        # If options have been provided by the user, we don't try to detect
+        # anything by ourselves
+        return blaspkgcfg
+
+    # Try environment modules
+    # MKL
+    if 'MKLROOT' in os.environ:
+        if 'MKL_INC' in os.environ:
+            blaspkgcfg['extra_compile_args'].extend(
+                shlex.split(os.environ['MKL_INC'])
+            )
+        if 'MKL_LIB' in os.environ:
+            blaspkgcfg['extra_link_args'].extend(
+                shlex.split(os.environ['MKL_LIB'])
+            )
+        blaspkgcfg['define_macros'].append(('AMICI_BLAS_MKL', None),)
+        return blaspkgcfg
+
+
+    # Try pkgconfig
+    if pkgconfig:
+        if pkgconfig.exists('cblas'):
+            blaspkgcfg = pkgconfig.parse('cblas')
+            blaspkgcfg['extra_compile_args'] = [pkgconfig.cflags('cblas')]
+            blaspkgcfg['extra_link_args'] = [pkgconfig.libs('cblas')]
+
+            return blaspkgcfg
+
+    # If none of the previous worked, fall back to libcblas in default paths
+    blaspkgcfg['libraries'] = ['cblas']
+
+    return blaspkgcfg
+
+
+def getHdf5Config():
+    """Find HDF5 include dir and libs
+
+    Arguments:
+
+    Returns:
+
+    Raises:
+
+    """
+    if pkgconfig:
+        h5pkgcfg = {}
+        try:
+            h5pkgcfg = pkgconfig.parse('hdf5')
+        except pkgconfig.PackageNotFoundError:
+            pass
+        # NOTE: Cannot use pkgconfig.exists('hdf5f'), since this is true
+        # although no libraries or include dirs are available
+        h5pkgcfg['found'] = 'include_dirs' in h5pkgcfg \
+                            and h5pkgcfg['include_dirs']
+        if h5pkgcfg['found']:
+            return h5pkgcfg
+
+    h5pkgcfg = {'include_dirs': [],
+                'library_dirs': [],
+                'libraries': [],
+                'define_macros': []
+                }
+
+    # try for hdf5 in standard locations
+    hdf5_include_dir_hints = [
+        '/usr/include/hdf5/serial',
+        '/usr/local/include',
+        '/usr/include',  # travis ubuntu xenial, centos
+        '/usr/local/Cellar/hdf5/1.10.2_1/include'  # travis macOS
+    ]
+    hdf5_library_dir_hints = [
+        '/usr/lib/x86_64-linux-gnu/',  # travis ubuntu xenial
+        '/usr/lib/x86_64-linux-gnu/hdf5/serial',
+        '/usr/local/lib',
+        '/usr/lib64/',  # CentOS
+        '/usr/local/Cellar/hdf5/1.10.2_1/lib'  # travis macOS
+    ]
+
+    # Check for Environment Modules variables
+    if 'HDF5_BASE' in os.environ:
+        hdf5_include_dir_hints.insert(
+            0, os.path.join(os.environ['HDF5_BASE'], 'include'))
+        hdf5_library_dir_hints.insert(
+            0, os.path.join(os.environ['HDF5_BASE'], 'lib'))
+
+    for hdf5_include_dir_hint in hdf5_include_dir_hints:
+        hdf5_include_dir_found = os.path.isfile(
+            os.path.join(hdf5_include_dir_hint, 'hdf5.h'))
+        if hdf5_include_dir_found:
+            print('hdf5.h found in %s' % hdf5_include_dir_hint)
+            h5pkgcfg['include_dirs'] = [hdf5_include_dir_hint]
+            break
+
+    for hdf5_library_dir_hint in hdf5_library_dir_hints:
+        # check for static or shared library
+        for lib_filename in ['libhdf5.a', 'libhdf5.so']:
+            hdf5_library_dir_found = os.path.isfile(
+                os.path.join(hdf5_library_dir_hint, lib_filename))
+            if hdf5_library_dir_found:
+                print(f'{lib_filename} found in {hdf5_library_dir_hint}')
+                h5pkgcfg['library_dirs'] = [hdf5_library_dir_hint]
+                break
+        if hdf5_library_dir_found:
+            # break to not override hdf5_library_dir_found
+            break
+    h5pkgcfg['found'] = hdf5_include_dir_found and hdf5_library_dir_found
+
+    return h5pkgcfg
+
+
+def addCoverageFlagsIfRequired(cxx_flags, linker_flags):
+    """Add compiler and linker flags if gcov coverage requested
+
+    Arguments:
+    cxx_flags: list of existing cxx flags
+    linker_flags: list of existing linker flags
+
+    Returns:
+
+    Raises:
+
+    """
+    if 'ENABLE_GCOV_COVERAGE' in os.environ and \
+            os.environ['ENABLE_GCOV_COVERAGE'] == 'TRUE':
+        print("ENABLE_GCOV_COVERAGE was set to TRUE."
+              " Building AMICI with coverage symbols.")
+        cxx_flags.extend(['-g', '-O0',  '--coverage'])
+        linker_flags.extend(['--coverage','-g'])
+
+
+def addDebugFlagsIfRequired(cxx_flags, linker_flags):
+    """Add compiler and linker debug flags if requested
+
+    Arguments:
+    cxx_flags: list of existing cxx flags
+    linker_flags: list of existing linker flags
+    force: flag to force debug mode ignoring env settings
+
+    Returns:
+
+    Raises:
+
+    """
+    if 'ENABLE_AMICI_DEBUGGING' in os.environ \
+            and os.environ['ENABLE_AMICI_DEBUGGING'] == 'TRUE':
+        print("ENABLE_AMICI_DEBUGGING was set to TRUE."
+              " Building AMICI with debug symbols.")
+        cxx_flags.extend(['-g', '-O0'])
+        linker_flags.extend(['-g'])
+
+
+def generateSwigInterfaceFiles():
+    """Compile the swig python interface to amici
+    """
+    swig_outdir = '%s/amici' % os.path.abspath(os.getcwd())
+    swig_exe = find_swig()
+
+    # Swig AMICI interface without HDF5 dependency
+    swig_cmd = [swig_exe,
+                '-c++',
+                '-python',
+                '-Iamici/swig', '-Iamici/include',
+                '-DAMICI_SWIG_WITHOUT_HDF5',
+                '-outdir', swig_outdir,
+                '-o', 'amici/amici_wrap_without_hdf5.cxx',
+                'amici/swig/amici.i']
+    print(f"Running SWIG: {' '.join(swig_cmd)}")
+    sp = subprocess.run(swig_cmd)
+    assert (sp.returncode == 0)
+    shutil.move(os.path.join(swig_outdir, 'amici.py'),
+                os.path.join(swig_outdir, 'amici_without_hdf5.py'))
+
+    # Swig AMICI interface with HDF5 dependency
+    swig_cmd = [swig_exe,
+                '-c++',
+                '-python',
+                '-Iamici/swig', '-Iamici/include',
+                '-outdir', swig_outdir,
+                '-o', 'amici/amici_wrap.cxx',
+                'amici/swig/amici.i']
+    print(f"Running SWIG: {' '.join(swig_cmd)}")
+    sp = subprocess.run(swig_cmd)
+    assert (sp.returncode == 0)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/bin/amici_import_petab.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/bin/amici_import_petab.py
new file mode 100644
index 0000000000000000000000000000000000000000..2329cded19605c19e5a82ab45e5fe68f4666907a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/bin/amici_import_petab.py
@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+
+"""
+Import a model in the PEtab (https://github.com/ICB-DCM/PEtab/) format into
+AMICI
+"""
+
+import amici
+import petab
+import os
+import time
+import argparse
+import math
+import logging
+from colorama import init as init_colorama
+from colorama import Fore
+
+logger = logging.getLogger(__name__)
+
+
+def parse_cli_args():
+    """Parse command line arguments"""
+
+    parser = argparse.ArgumentParser(
+        description='Import PEtab-format model into AMICI.')
+
+    # General options:
+    parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
+                        help='More verbose output')
+    parser.add_argument('-o', '--output-dir', dest='model_output_dir',
+                        help='Name of the model directory to create')
+    parser.add_argument('--no-compile', action='store_false',
+                        dest='compile',
+                        help='Only generate model code, do not compile')
+
+    # Call with set of files
+    parser.add_argument('-s', '--sbml', dest='sbml_file_name',
+                        help='SBML model filename')
+    parser.add_argument('-m', '--measurements', dest='measurement_file_name',
+                        help='Measurement table')
+    parser.add_argument('-c', '--conditions', dest='condition_file_name',
+                        help='Conditions table')
+    parser.add_argument('-p', '--parameters', dest='parameter_file_name',
+                        help='Parameter table')
+
+    # or with model name, following default naming
+    parser.add_argument('-n', '--model-name', dest='model_name',
+                        help='Model name where all files are in the working '
+                        'directory and follow PEtab naming convention. '
+                        'Specifying -[smcp] will override defaults')
+
+    args = parser.parse_args()
+
+    if args.model_name:
+        if not args.sbml_file_name:
+            args.sbml_file_name = petab.get_default_sbml_file_name(
+                args.model_name)
+        if not args.measurement_file_name:
+            args.measurement_file_name = \
+                petab.get_default_measurement_file_name(args.model_name)
+        if not args.condition_file_name:
+            args.condition_file_name = petab.get_default_condition_file_name(
+                args.model_name)
+        if not args.parameter_file_name:
+            args.parameter_file_name = petab.get_default_parameter_file_name(
+                args.model_name)
+
+    if not args.model_name and \
+            (not args.sbml_file_name
+             or not args.condition_file_name
+             or not args.measurement_file_name):
+        parser.error('When not specifying a model name, sbml, '
+                     'condition and measurement file must be specified')
+
+    return args
+
+
+def show_model_info(sbml_model):
+    """Log some model quantities"""
+
+    logger.log(logging.INFO, f'Species: {len(sbml_model.getListOfSpecies())}')
+    logger.log(logging.INFO, 'Global parameters: '
+               + str(len(sbml_model.getListOfParameters())))
+    logger.log(logging.INFO,
+               f'Reactions: {len(sbml_model.getListOfReactions())}')
+
+
+def get_fixed_parameters(condition_file_name, sbml_model,
+                         const_species_to_parameters=False):
+    """Determine, set and return fixed model parameters
+
+    Parameters specified in `condition_file_name` are turned into constants.
+    Only global SBML parameters are considered. Local parameters are ignored.
+
+    Arguments:
+        condition_file_name:
+            PEtab condition table
+        sbml_model:
+            libsbml.Model instance
+        const_species_to_parameters:
+            If `True`, species which are marked constant within the SBML model
+            will be turned into constant parameters *within* the given
+            `sbml_model`.
+    """
+
+    condition_df = petab.get_condition_df(condition_file_name)
+    logger.log(logging.INFO, f'Condition table: {condition_df.shape}')
+
+    # column names are model parameter names that should be made constant
+    # except for any overridden parameters
+    # (Could potentially still be made constant, but leaving them might
+    # increase model reusability)
+    fixed_parameters = list(condition_df.columns)
+    try:
+        fixed_parameters.remove('conditionName')
+    except ValueError:
+        pass
+    # remove overridden parameters
+    fixed_parameters = [p for p in fixed_parameters
+                        if condition_df[p].dtype != 'O']
+
+    # must be unique
+    assert(len(fixed_parameters) == len(set(fixed_parameters)))
+
+    if const_species_to_parameters:
+        # Turn species which are marked constant in the SBML model into
+        # parameters
+        constant_species = constant_species_to_parameters(sbml_model)
+
+        logger.log(logging.INFO, "Constant species converted to parameters "
+                   + str(len(constant_species)))
+        logger.log(logging.INFO, "Non-constant species "
+                   + str(len(sbml_model.getListOfSpecies())))
+
+    # ... and append them to the list of fixed_parameters
+    for species in constant_species:
+        if species not in fixed_parameters:
+            fixed_parameters.append(species)
+
+    # Ensure mentioned parameters exist in the model. Remove additional ones
+    # from list
+    for fixed_parameter in fixed_parameters[:]:
+        # check global parameters
+        if not sbml_model.getParameter(fixed_parameter) \
+                and not sbml_model.getSpecies(fixed_parameter):
+            logger.log(logging.warning,
+                       f"{Fore.YELLOW}Parameter or species '{fixed_parameter}'"
+                       " provided in condition table but not present in"
+                       " model.")
+            fixed_parameters.remove(fixed_parameter)
+
+    return fixed_parameters
+
+
+def constant_species_to_parameters(sbml_model):
+    """Convert constant species in the SBML model to constant parameters.
+
+    This can be used e.g. for setting up models with condition-specific
+    constant species for PEtab, since there it is not possible to specify
+    constant species in the condition table.
+
+    Arguments:
+        sbml_model: libsbml model instance
+
+    Returns:
+        List of IDs of SBML species that have been turned into constants
+
+    Raises:
+
+    """
+    transformables = []
+    for species in sbml_model.getListOfSpecies():
+        if not species.getConstant() and not species.getBoundaryCondition():
+            continue
+
+        if species.getHasOnlySubstanceUnits():
+            logger.warning(
+                f"Ignoring {species.getId()} which has only substance units."
+                " Conversion not yet implemented.")
+            continue
+
+        if math.isnan(species.getInitialConcentration()):
+            logger.warning(
+                f"Ignoring {species.getId()} which has no initial "
+                "concentration. Amount conversion not yet implemented.")
+            continue
+
+        transformables.append(species.getId())
+
+    # Must not remove species while iterating over getListOfSpecies()
+    for speciesId in transformables:
+        species = sbml_model.removeSpecies(speciesId)
+        par = sbml_model.createParameter()
+        par.setId(species.getId())
+        par.setName(species.getName())
+        par.setConstant(True)
+        par.setValue(species.getInitialConcentration())
+        par.setUnits(species.getUnits())
+
+    # Remove from reactants and products
+    for reaction in sbml_model.getListOfReactions():
+        for speciesId in transformables:
+            # loop, since removeX only removes one instance
+            while reaction.removeReactant(speciesId):
+                pass
+            while reaction.removeProduct(speciesId):
+                pass
+            while reaction.removeModifier(speciesId):
+                pass
+
+    return transformables
+
+
+def import_model(sbml_file: str,
+                 condition_file: str,
+                 measurement_file: str = None,
+                 model_name: str = None,
+                 model_output_dir: str = None,
+                 verbose: bool = True,
+                 allow_reinit_fixpar_initcond: bool = False,
+                 **kwargs):
+    """Import AMICI model"""
+
+    if model_name is None:
+        model_name = os.path.splitext(os.path.split(sbml_file)[-1])[0]
+
+    if model_output_dir is None:
+        model_output_dir = os.path.join(os.getcwd(), model_name)
+
+    if verbose:
+        logger.log(logging.INFO,
+                   f"{Fore.GREEN}Importing model '{sbml_file}' "
+                   f"using fixed parameters file '{condition_file}'")
+        logger.log(logging.INFO,
+                   f"{Fore.GREEN}Model name is '{model_name}' "
+                   f"Writing model code to '{model_output_dir}'")
+
+    sbml_importer = amici.SbmlImporter(sbml_file)
+    sbml_model = sbml_importer.sbml
+
+    show_model_info(sbml_model)
+
+    observables = petab.get_observables(sbml_importer.sbml, remove=True)
+
+    sigmas = petab.get_sigmas(sbml_importer.sbml, remove=True)
+
+    measurement_df = petab.get_measurement_df(measurement_file)
+
+    noise_distrs = petab_noise_distributions_to_amici(
+        petab.get_noise_distributions(measurement_df))
+
+    # Replace observables in assignment
+    import sympy as sp
+    for observable_id, formula in sigmas.items():
+        repl = sp.sympify(formula).subs(observable_id, observables[observable_id]['formula'])
+        sigmas[observable_id] = str(repl)
+
+    if verbose:
+        logger.log(logging.INFO, f'Observables {len(observables)}')
+        logger.log(logging.INFO, f'Sigmas {len(sigmas)}')
+
+    if not len(sigmas) == len(observables):
+        raise AssertionError(
+            f'Number of provided observables ({len(observables)}) and sigmas '
+            f'({len(sigmas)}) do not match.')
+
+    fixed_parameters = get_fixed_parameters(condition_file, sbml_model)
+
+    if verbose:
+        logger.log(logging.INFO,
+                   f"Overall fixed parameters {len(fixed_parameters)}")
+        logger.log(logging.INFO, "Non-constant global parameters "
+                   + str(len(sbml_model.getListOfParameters())
+                         - len(fixed_parameters)))
+
+    # Create Python module from SBML model
+    start = time.time()
+    sbml_importer.sbml2amici(
+        model_name,
+        output_dir=model_output_dir,
+        observables=observables,
+        constantParameters=fixed_parameters,
+        sigmas=sigmas,
+        allow_reinit_fixpar_initcond=allow_reinit_fixpar_initcond,
+        noise_distributions=noise_distrs,
+        **kwargs)
+    end = time. time()
+
+    if verbose:
+        logger.log(logging.INFO, f"{Fore.GREEN}Model imported successfully in "
+                                 f"{round(end - start, 2)}s")
+
+
+def petab_noise_distributions_to_amici(noise_distributions):
+    """
+    Map from the petab to the amici format of noise distribution
+    identifiers.
+
+    Arguments:
+        noise_distributions: as obtained from `petab.get_noise_distributions`
+    """
+    amici_distrs = {}
+    for id_, val in noise_distributions.items():
+        amici_val = ''
+        if val['observableTransformation']:
+            amici_val += val['observableTransformation'] + '-'
+        if val['noiseDistribution']:
+            amici_val += val['noiseDistribution']
+        amici_distrs[id_] = amici_val
+    return amici_distrs
+
+
+def main():
+    args = parse_cli_args()
+
+    init_colorama(autoreset=True)
+
+    # First check for valid PEtab
+    pp = petab.Problem.from_files(
+        sbml_file=args.sbml_file_name,
+        condition_file=args.condition_file_name,
+        measurement_file=args.measurement_file_name,
+        parameter_file=args.parameter_file_name)
+    petab.lint_problem(pp)
+
+    import_model(model_name=args.model_name,
+                 sbml_file=args.sbml_file_name,
+                 condition_file=args.condition_file_name,
+                 measurement_file=args.measurement_file_name,
+                 model_output_dir=args.model_output_dir,
+                 compile=args.compile,
+                 verbose=True)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/createModelPresimulation.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/createModelPresimulation.py
new file mode 100644
index 0000000000000000000000000000000000000000..5593f8122ffb80531dc26c7079caf023e4057b81
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/createModelPresimulation.py
@@ -0,0 +1,62 @@
+from pysb.core import (
+    Rule, Parameter, Model, Monomer, Expression, Initial, Observable
+)
+
+import pysb.export
+import os
+
+import libsbml
+
+model = Model()
+
+prot = Monomer('PROT', ['kin','drug','phospho'], {'phospho': ['u', 'p']})
+prot_0 = Parameter('PROT_0', 10)
+Initial(prot(phospho='u', drug=None, kin=None),
+        Expression('initProt',prot_0))
+
+drug = Monomer('DRUG', ['bound'])
+drug_0 = Parameter('DRUG_0', 9)
+Initial(drug(bound=None),
+        Expression('initDrug', drug_0))
+
+kin = Monomer('KIN', ['bound'])
+kin_0 = Parameter('KIN_0', 1)
+Initial(kin(bound=None),
+        Expression('initKin', kin_0))
+
+Rule('PROT_DRUG_bind',
+     drug(bound=None) + prot(phospho='u', drug=None, kin=None) |
+     drug(bound=1) % prot(phospho='u', drug=1, kin=None),
+     Parameter('kon_prot_drug', 0.1),
+     Parameter('koff_prot_drug', 0.1)
+     )
+
+Rule('PROT_KIN_bind',
+     kin(bound=None) + prot(phospho='u', drug=None, kin=None) >>
+     kin(bound=1) % prot(phospho='u', drug=None, kin=1),
+     Parameter('kon_prot_kin', 0.1),
+     )
+
+Rule('PROT_KIN_phospho',
+     kin(bound=1) % prot(phospho='u', drug=None, kin=1) >>
+     kin(bound=None) + prot(phospho='p', drug=None, kin=None),
+     Parameter('kphospho_prot_kin', 0.1)
+     )
+
+Rule('PROT_dephospho',
+     prot(phospho='p', drug=None, kin=None) >>
+     prot(phospho='u', drug=None, kin=None),
+     Parameter('kdephospho_prot', 0.1)
+     )
+
+pProt = Observable('pPROT', prot(phospho='p'))
+tProt = Observable('tPROT', prot())
+
+Expression('pPROT_obs', pProt/tProt)
+
+sbml_output = pysb.export.export(model, format='sbml')
+
+outfile = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                       'model_presimulation.xml')
+with open(outfile, 'w') as f:
+    f.write(sbml_output)
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/model_presimulation.ipynb b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/model_presimulation.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..7d1f740317c20eed5c93d1bfb4ce8ca9ea3f6001
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/model_presimulation.ipynb
@@ -0,0 +1,414 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AMICI Python example \"presimulation\"\n",
+    "In this example we will explore some more options for the initialization of experimental conditions, including how to reset initial conditions based on changing values for fixedParameters as well as an additional presimulation phase on top of preequilibration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SBML model we want to import\n",
+    "sbml_file = 'model_presimulation.xml'\n",
+    "# Name of the model that will also be the name of the python module\n",
+    "model_name = 'model_presimulation'\n",
+    "# Directory to which the generated model code is written\n",
+    "model_output_dir = model_name\n",
+    "\n",
+    "import libsbml\n",
+    "import amici\n",
+    "import amici.plotting\n",
+    "import os\n",
+    "import sys\n",
+    "import importlib\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model Loading\n",
+    "Here we load a simple model of protein phosphorylation that can be inhibited by a drug. This model was created using PySB (see `createModel.py`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Species:  [('__s0', \"PROT(kin=None, drug=None, phospho='u')\"), ('__s1', 'DRUG(bound=None)'), ('__s2', 'KIN(bound=None)'), ('__s3', \"DRUG(bound=1) ._br_PROT(kin=None, drug=1, phospho='u')\"), ('__s4', \"KIN(bound=1) ._br_PROT(kin=1, drug=None, phospho='u')\"), ('__s5', \"PROT(kin=None, drug=None, phospho='p')\")]\n",
+      "\n",
+      "Reactions:\n",
+      " r0:  __s0 +  __s1 <->      __s3\t\t[__s0 * __s1 * kon_prot_drug - __s3 * koff_prot_drug]\n",
+      " r1:  __s0 +  __s2  ->      __s4\t\t[__s0 * __s2 * kon_prot_kin]\n",
+      " r2:       __s4  -> __s2 +  __s5\t\t[__s4 * kphospho_prot_kin]\n",
+      " r3:       __s5  ->      __s0\t\t[__s5 * kdephospho_prot]\n",
+      "Parameters:  [('PROT_0', 'PROT_0'), ('DRUG_0', 'DRUG_0'), ('kon_prot_drug', 'kon_prot_drug'), ('koff_prot_drug', 'koff_prot_drug'), ('KIN_0', 'KIN_0'), ('kon_prot_kin', 'kon_prot_kin'), ('kphospho_prot_kin', 'kphospho_prot_kin'), ('kdephospho_prot', 'kdephospho_prot'), ('__obs0', 'pPROT')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "sbml_reader = libsbml.SBMLReader()\n",
+    "sbml_doc = sbml_reader.readSBML(sbml_file)\n",
+    "sbml_model = sbml_doc.getModel()\n",
+    "dir(sbml_doc)\n",
+    "\n",
+    "print('Species: ', [(s.getId(),s.getName()) for s in sbml_model.getListOfSpecies()])\n",
+    "\n",
+    "print('\\nReactions:')\n",
+    "for reaction in sbml_model.getListOfReactions():\n",
+    "    reactants = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfReactants()])\n",
+    "    products  = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfProducts()])\n",
+    "    reversible = '<' if reaction.getReversible() else ''\n",
+    "    print('%3s: %10s %1s->%10s\\t\\t[%s]' % (reaction.getName(), \n",
+    "                        reactants,\n",
+    "                        reversible,\n",
+    "                         products,\n",
+    "                        libsbml.formulaToL3String(reaction.getKineticLaw().getMath())))\n",
+    "    \n",
+    "print('Parameters: ', [(p.getId(),p.getName()) for p in sbml_model.getListOfParameters()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create an SbmlImporter instance for our SBML model\n",
+    "sbml_importer = amici.SbmlImporter(sbml_file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For this example we want specify the initial drug and kinase concentrations as experimental conditions. Accordingly we specify them as fixedParameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fixedParameters = ['DRUG_0','KIN_0']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The SBML model specifies a single observable named `pPROT` which describes the fraction of phosphorylated Protein. We load this observable using `amici.assignmentRules2observables`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Observables: {'__obs0': {'name': 'pPROT', 'formula': '__s5 / (__s0 + __s3 + __s4 + __s5)'}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Retrieve model output names and formulae from AssignmentRules and remove the respective rules\n",
+    "observables = amici.assignmentRules2observables(\n",
+    "        sbml_importer.sbml, # the libsbml model object\n",
+    "        filter_function=lambda variable: variable.getName() == 'pPROT' \n",
+    "    )\n",
+    "print('Observables:', observables)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now the model is ready for compilation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sbml_importer.sbml2amici(model_name, \n",
+    "                         model_output_dir, \n",
+    "                         verbose=False,\n",
+    "                         observables=observables,\n",
+    "                         constantParameters=fixedParameters)\n",
+    "sys.path.insert(0, os.path.abspath(model_output_dir))\n",
+    "# load the compiled module\n",
+    "model_module = importlib.import_module(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To simulate the model we need to create an instance via the `getModel()` method in the generated model module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create Model instance\n",
+    "model = model_module.getModel()\n",
+    "# set timepoints for which we want to simulate the model\n",
+    "\n",
+    "\n",
+    "# Create solver instance\n",
+    "solver = model.getSolver()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The only thing we need to simulate the model is a timepoint vector, which can be specified using the `setTimepoints()` method. If we do not specify any additional options, the default values for fixedParameters and Parameters that were specified in the SBML file will be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Run simulation using default model parameters and solver options\n",
+    "model.setTimepoints(np.linspace(0, 60, 60)) \n",
+    "rdata = amici.runAmiciSimulation(model, solver)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Simulation options can be specified either in the Model or in an ExpData object. The ExpData object can also carry experimental data. To initialize an ExpData object from simulation routines, amici offers some convenient constructors. In the following we will initialize an ExpData object from simulation results, but add noise with standard deviation `0.1` and specify the standard deviation accordingly. Moreover, we will specify custom values for `DRUG_0=0` and `KIN_0=2`. If fixedParameter is specfied in an ExpData object, runAmiciSimulation will use those parameters instead of the ones specified in the Model object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "edata = amici.ExpData(rdata, 0.1, 0.0)\n",
+    "edata.fixedParameters = [0,2]\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For many biological systems, it is reasonable to assume that they start in a steady state. In this example we want to specify an experiment where a pretreatment with a drug is performed _before_ the kinase is added. We assume that the pretreatment is sufficiently long such that the system reaches steadystate before the kinase is added. To implement this in amici, we can specify `fixedParametersPreequilibration` in the ExpData object. Here we set `DRUG_0=3` and `KIN_0=2` for the preequilibration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "edata.fixedParametersPreequilibration = [3,0]\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The resulting trajectory is definitely not what one may expect. The problem is that the `DRUG_0` and `KIN_0` set initial condtions for species in the model. By default these initial conditions are only applied at the very beginning of the simulation, i.e., before the preequilibration. Accordingly, the fixedParameters that we specified do not have any effect. To fix this, we need to activate reinitialization of states that depend on fixedParameters via `setReinitializeFixedParameterInitialStates`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.setReinitializeFixedParameterInitialStates(True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With this option activated, the kinase concentration will be reinitialized after the preequilibration and we will see the expected change in fractional phosphorylation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On top of preequilibration, we can also specify presimulation. This option can be used to specify pretreatments where the system is not assumed to reach steadystate. Presimulation can be activated by specifying `t_presim` and `edata.fixedParametersPresimulation`. If both `fixedParametersPresimulation` and `fixedParametersPreequilibration` are specified, preequilibration will be performed first, followed by presimulation, followed by regular simulation. For this example we specify `DRUG_0=10` and `KIN_0=0` for the presimulation and `DRUG_0=10` and `KIN_0=2` for the regular simulation. We do not overwrite the `DRUG_0=3` and `KIN_0=0` that was previously specified for preequilibration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3.0, 0.0)\n",
+      "(10.0, 0.0)\n",
+      "(10.0, 2.0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEZCAYAAABvpam5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzt3Xl8VOXZ//HPlR1Cwhb2Lagsgihiimi1VXGtC62l7kqfqnRxqa1dtM9jqz5Pf1ZttbYura1ai3utWlyxiitWNIAIYZGwJ+yBBMieyfX7Yw40pgEykMzJJN/36zWvmbPMzHXCMN+5z33OfczdERERiUVS2AWIiEjiUXiIiEjMFB4iIhIzhYeIiMRM4SEiIjFTeIiISMwUHiKAmd1sZo+FXcfe7KtGM1tlZifHsybpuBQe0mGY2TfNbIGZVZjZBjN7wMy6hV2XSCJSeEiHYGbXA7cDPwa6AhOAIcA/zSwtTjWkxON9ROJB4SHtnpllA7cA17j7a+5e6+6rgPOAXOCSYNUMM3vazHaY2VwzO6LBa/zUzIqDZUvNbGIwP8nMbjCz5WZWYmbPmFmPYFmumbmZXW5ma4CZZvaqmV3dqL75ZnZu8PgeM1trZtvNbI6ZHd9oc/ZYY6PX3FtdGWb2WDC/1Mw+NrM+B/ZXlo5G4SEdwbFABvBcw5nuvhN4BTglmDUJ+BvQA3gCeMHMUs1sBHA18AV3zwJOA1YFz7kG+CrwZaA/sA24r9H7fxk4NHjek8CFuxaY2SiiLaCXg1kfA2Mb1PA3M8to8FpN1tjENu+trilEW1+DgJ7Ad4DKJl5DZI8UHtIR5ABb3L2uiWXrg+UAc9z9WXevBe4iGjgTgAiQDowys1R3X+Xuy4PnfAf4b3cvcvdq4GZgcqNdVDe7e7m7VwLPA2PNbEiw7GLgueC5uPtj7l7i7nXu/pvgfUc0eK091djY3uqqJRoah7h7xN3nuPv2ff8ZRf5N4SEdwRYgZw99Dv2C5QBrd81093qgCOjv7oXAdUS/gDeZ2VNm1j9YdQjwfLD7pxRYTDRsGu4Gavi6O4i2Mi4IZl0IPL5ruZn9yMwWm1lZ8Hpd+Xe47bHGJrZrb3VNA2YAT5nZOjO7Yw+tF5E9UnhIR/AvoBo4t+FMM+sCnAG8Gcwa1GBZEjAQWAfg7k+4+3FEv5SdaOc7RL/Mz3D3bg1uGe5e3OCtGg9d/SRwoZkdQ7Tl8FbwnscDPyHaF9Pd3bsBZYA1eO4ea2xkj3UFfT63uPsoorv0zgIua/pPJ9I0hYe0e+5eRrTD/PdmdnrQj5ELPEP0l/u0YNWjzOzcoIVyHdHA+dDMRpjZSWaWDlQR7R+oD57zB+CXu3ZDmVkvM5u0j5JeIRpCtwJPBy0IgCygDtgMpJjZz4HsRs9tssYm3mOPdZnZiWY2xsySge1Ed2PVN/EaInuk8JAOwd3vAH4G/JroF+Zsor/OJ+7qbwD+AZxPtHP5UuDcoG8hHfgV0d1bG4DewI3Bc+4BpgOvm9kOol/kR++jlmqinfcnE+303mUG8BrwGbCaaFCtbfT0PdXY2N7q6gs8G/wdFgPv8O8AFWkW08WgREQkVmp5iIhIzBQeIiISM4WHiIjETOEhIiIxa7cDteXk5Hhubm7YZYiIJJQ5c+Zscfde+1qv3YZHbm4u+fn5YZchIpJQzGx1c9bTbisREYmZwkNERGKm8BARkZi12z6PptTW1lJUVERVVVXYpcQsIyODgQMHkpqqwU9FJHwdKjyKiorIysoiNzcXM9v3E9oId6ekpISioiKGDh0adjkiIh1rt1VVVRU9e/ZMqOAAMDN69uyZkC0mEWmfOlR4AAkXHLskat0i0j51qN1WIiJhidQ7tZF6aiL11NbVUxv593Rd8Lg2Uk9dsF5dxKmr33Uf3ILlkQbTkQbTux4P75PFmYf3a9XtUXiISIfi7tRE6qmojlBRG6Gypo6KmgiVNREqayNU1UbvK2vqd09X10aoqqsPHtdTXRehKrivrqunuq6emuBWXReJPo7U776vjUS/1OPlrMP7KTxERHapqo1QVlnL9spatlfVsr2yLnpfVcfOqjp2Vteys6qOHdW7pusor66jvCZCeXV0uqImsl9f5BmpSWSkJpORkkx6atLu+7TkJDJSk+jaKZW05CTSUqK39JQkUndNJ0cfp6bY7nVSd81LNlKSovepyUmkNJhOSU4iJcmCedH5yUnR9ZKTjOQGy5KTjGSL3sdjN7fCI84WLlzI1KlT+eCDDwCYO3cuP/7xj3nzzTf38UyR9sPdqaiJsLW8hi07q9laXkNJeQ3bymvYWlFDaXlt9L6ihtKKWsoqaymtrKWmbu9Xy01OMrIyUuiS/u9bt85pDOieTGZaCpnpKXROSyYzPYVOqcl0Tkumc4PHGcF9p9To406p0YBIT0lSv2MjHTY8bnmxgEXrtrfoa47qn80vzh6993VGjWLFihVEIhGSk5P54Q9/yF133dWidYiExd3ZWl7Dhu1VbNpevft+885d99Vs3lHNlp3VVNU2HQRpyUl0z0yle+c0unVO5eBeXejWOZWunVLpGtxnZ6SS3SmV7IwUsjulkpWRQnZGqr7k46jDhkdYkpKSGD16NAUFBSxbtowhQ4Ywbtw4ysvL+d73vkdaWhonnHACF198cdilivyHqtoIRdsqWbutgnWllcGtiuLSStaXVbKxrJqayH+GQo/MNHp1SadXVjq5uZn0zEwjJyudnplp9OySRs/MdHpkptEjM43OackKgAQQ1/Aws9OBe4Bk4M/u/qtGy9OBvwJHASXA+e6+ysxSgT8D44Ka/+rutx1ILftqIbSmCRMmMGvWLO6//35ee+01AJ577jkmT57M2Wefzfnnn6/wkNBsr6pl1ZZyVm4pZ9WWClaXlLNmawVrt1WwcXv159ZNTjL6ZmfQv1sGRw7qTr8xGfTNjt76dM2gT3YGvbqkk5bS4c4KaPfiFh5mlgzcB5wCFAEfm9l0d1/UYLXLgW3ufoiZXQDcDpwPfANId/cxZtYZWGRmT7r7qnjV35ImTJjAN7/5Ta666ioGDBgARM9+HzNmDADJyclhlicdgLuzrqyKwk07d9+Wb9rJ8s07KSmv2b2eGfTLzmBQj84cP6wXg7p3ZlCPTgzq0ZmB3TvROyuD5CS1EjqieLY8xgOF7r4CwMyeAiYBDcNjEnBz8PhZ4F6Ltl8dyDSzFKATUAO0bIdFHI0cOZL09HR++tOf7p43cOBAioqKGDt2LPX1e+8UFInFjqpalmzYwZL126P3G3bw2YYd7Kiu271O986pHNK7C6eM6sPQnExyczIZmpPJ4B6dyUjVjxn5T/EMjwHA2gbTRcDRe1rH3evMrAzoSTRIJgHrgc7AD9x9a+M3MLOpwFSAwYMHt3T9Leaee+7htttuIzMzc/e8c889l6uvvpqXX36Zs88+O8TqJJGVVdaysLiMhcVlLCguo2DddlZuKd+9PDsjhZH9svnauAEM75PFsN5dOKR3F3p2SQ+xaklEidJhPh6IAP2B7sB7ZvbGrlbMLu7+IPAgQF5eXvzOyGmm5cuXc+aZZ/LFL36RKVOmfG5ZZmYmjzzySEiVSSKK1DufbdzBvDWlzFuzjXlrSynctHP38gHdOjFmQFe+Pm4Ao/t3ZWS/LPpmZ6gzWlpEPMOjGBjUYHpgMK+pdYqCXVRdiXacXwS85u61wCYzmwXkAStIIAcffDBLliwJuwxJUDV19SwoLmX2yq18tHIr+au2sTPY9dQjM40jB3Xjq2P7c/jAbhw2oCs9MtNCrljas3iGx8fAMDMbSjQkLiAaCg1NB6YA/wImAzPd3c1sDXASMM3MMoEJwG/jVrlICCL1zsLiMt4v3MKswi3MXbNt97kRw3p3YdLY/uTldmfc4O4M7tFZLQqJq7iFR9CHcTUwg+ihug+7e4GZ3Qrku/t04CGiAVEIbCUaMBA9SusRMysADHjE3T+NV+0i8bK+rJK3l27mvWWb+WB5CaUVtQCM7JvFheMHc/TQnnwht7v6KCR0ce3zcPdXgFcazft5g8dVRA/Lbfy8nU3N388aEvIXmnub68KRFlBf73xaXMbMxRt5Y/EmFq2PHkTYNzuDkw/tw/HDcjj24Bx6ZSkspG1JlA7zFpGRkUFJSUnCXRBq15UEMzIywi5FWkBdpJ7ZK7fy8oL1/HPRRjbvqCbJ4Kgh3bnhjJGcNLI3w3p3SajPqHQ8HSo8dp1LsXnz5rBLidmua5hLYqqN1POv5SW8unA9Mwo2srW8hs5pyZw4ojcnj+rNCcN7010d3JJAOlR4pKam6hrgEjfuTsG67fx9bhHTP1lHSXkNmWnJTDy0D18Z05cvD+9NpzSdgCeJqUOFh0g8bCir4vl5xTw3t4hlm3aSlpzExEN7M2nsAE4Y0UtnbEu7oPAQaQH19c67yzbz+Ow1zFyyiUi9c9SQ7vzya4dx1pj+dO2cGnaJIi1K4SFyADbvqOaZ/LU89fEa1m6tpGdmGlcefxDnf2EQQ3My9/0CIglK4SGyH5Zs2M5D763kH5+soyZSzzEH9eQnp43ktNF9Nfy4dAgKD5Fmcnfe+WwzD72/kveWbaFTajIXjB/ElGNzObhXl7DLE4krhYfIPkTqnZc+Xcd9bxXy2cad9MlO5yenj+Ci8YPp1lmH10rHpPAQ2YO6SD3T56/j3pmFrNhSzvA+XbjrvCM46/D+2jUlHZ7CQ6SRukg9z80r5r63ClldUsHIvlk8cPE4ThvdlyRdNU8EUHiI7ObuvL5oI3e8toTlm8s5bEA2D156FCcf2kehIdKIwkMEmLN6K7e9soT81ds4qFcmf7jkKE4b3UfjS4nsgcJDOrRVW8q57dXFzCjYSK+sdP7f18ZwXt5AUpLVpyGyNwoP6ZAqayLc91YhD767gtRk4/pThnP58UPpnKb/EiLNof8p0qG4OzMKNvC/Ly2muLSSr47tz8++cii9szXcvUgsFB7SYazaUs7Ppxfw7mebGdEni6enTuDog3qGXZZIQlJ4SLsXqXcefn8lv359KanJSdx01iguO2YIqerXENlvCg9p15Zt3MGPn/2UT9aWMnFkb375tTH07apdVCIHSuEh7VJdpJ4/vruCe95YRuf0ZO65YCznHNFfh96KtBCFh7Q7q0vKufapT5i/tpSvjOnLLeccRq+s9LDLEmlXFB7Srjw3t4ibXlhIcpJx70VHctbh/cMuSaRdUnhIu7CjqpabXljIC5+sY/zQHvz2/LH079Yp7LJE2i2FhyS8eWu28f2nPqG4tJIfnjKcq048hGSNRSXSqhQekrDcncc+XM2tLy2id1YGz3x7AkcN6RF2WSIdgsJDElJVbYT/eWEhz84p4sQRvfjt+UfStXNq2GWJdBgKD0k4xaWVfGfaHBYUl3HtxGFcN3GYhkwXiTOFhySUDwq3cPWT86itq+dPl+Vxyqg+YZck0iEpPCRhPDF7DTf9YyFDczL546VHcXCvLmGXJNJhKTykzauvd+58fSkPvL2cLw/vxX0Xj6NLuj66ImHS/0Bp06pqI/zob/N56dP1XHT0YG49Z7Qu1CTSBig8pM3aVl7DlX/NJ3/1Nm48YyRTv3SQxqYSaSMUHtImrd1awWUPf0RxaSX3XTSOMw/vF3ZJItKAwkPanMJNO7nkz7OprI3wxBVHk5erE/9E2hqFh7QpBevKuOyhjzAznv72BEb2zQ67JBFpgnoepc2Ys3obFzz4IekpSTyj4BBp09TykDZhVuEWrvxrPr2z0nn8ygkM0Ii4Im2awkNC9/bSTUydNoehPTOZdsV4emfpMrEibZ3CQ0I1q3AL3542h2G9u/D4FUfTrXNa2CWJSDPEtc/DzE43s6VmVmhmNzSxPN3Mng6Wzzaz3AbLDjezf5lZgZktMDP9PE1wH63cyhWP5jM0J5PHLldwiCSSuIWHmSUD9wFnAKOAC81sVKPVLge2ufshwN3A7cFzU4DHgO+4+2jgBKA2TqVLK5i7Zhv/9chH9O+WwbTLj6Z7poJDJJHEs+UxHih09xXuXgM8BUxqtM4k4NHg8bPARIueUnwq8Km7zwdw9xJ3j8SpbmlhC4vLmPLwR+RkpfPElRPolZUedkkiEqN4hscAYG2D6aJgXpPruHsdUAb0BIYDbmYzzGyumf2kqTcws6lmlm9m+Zs3b27xDZADt2TDdi55aDbZGak8ceUE+mRr76NIIkqU8zxSgOOAi4P7r5nZxMYrufuD7p7n7nm9evWKd42yD8WllUx5+CPSU5J4UofjiiS0eIZHMTCowfTAYF6T6wT9HF2BEqKtlHfdfYu7VwCvAONavWJpMaUVNUx5+CMqqiM8+q3xDO7ZOeySROQAxDM8PgaGmdlQM0sDLgCmN1pnOjAleDwZmOnuDswAxphZ5yBUvgwsilPdcoCqaiNc+dd81pRU8MfLjtKZ4yLtQNzO83D3OjO7mmgQJAMPu3uBmd0K5Lv7dOAhYJqZFQJbiQYM7r7NzO4iGkAOvOLuL8erdtl/kXrnB09/wsertvH7C4/k2INzwi5JRFqARX/Ytz95eXmen58fdhkdmrtzy4uL+MsHq/ifMw/liuMPCrskEdkHM5vj7nn7Wi9ROswlAf3pvRX85YNVXHHcUAWHSDuj8JBWMXPJRm57dQlnjunHz75yaNjliEgLU3hIiyvctINrn/yEUf2y+fU3jiApSZeOFWlvFB7Sokorarji0XwyUpP402V5dEpLDrskEWkFGlVXWkxdpJ6rn5jHutIqnpx6NP11EqBIu6XwkBbzy1cW837hFu6YfDhHDdF1x0XaM+22khbx9MdreGTWKi4/bijn5Q3a9xNEJKEpPOSALSwu46YXCjh+WA43njEy7HJEJA4UHnJAyipr+e7jc8jpksbvLjiSlGR9pEQ6AvV5yH5zd378t/msL63i6W8fows6iXQg+pko++2h91fy+qKN3HDGSI4a0j3sckQkjhQesl/mrN7Kr15dwmmj+3D5cUPDLkdE4kzhITHbWl7D1U/Mo3+3Ttwx+QiiVwoWkY5EfR4Sk/pgiPWS8hqe++6xdO2UGnZJIhICtTwkJo98sIp3PtvMTWeN4rABXcMuR0RCovCQZluyYTu3v7aEkw/tzSVHDw67HBEJUczhYWaZZqbR7jqYqtoI1z31CdkZKfzq64ern0Okg9tneJhZkpldZGYvm9kmYAmw3swWmdmdZnZI65cpYbtzxlKWbNjBnZOPIKdLetjliEjImtPyeAs4GLgR6Ovug9y9N3Ac8CFwu5ld0oo1SsjeX7aFh95fyaUThnDiyN5hlyMibUBzjrY62d1rG890963A34G/m5kOuWmntpXXcP3fPuHgXpm6IqCI7Nac8Lim0f5tB7YA77v7SoCmwkUSn7vz3y8sYGt5DQ9N+YIu7CQiuzVnt1VWo1s2kAe8amYXtGJtErLp89fxyoIN/OCU4TosV0Q+Z58tD3e/pan5ZtYDeAN4qqWLkvBt2VnNzdMLOGJQN779pYPDLkdE2pj9Ps8j6PPQ8Zrt1C+mF1BeHeHXkw8nOUn/zCLyefsdHmZ2IrCtBWuRNuK1het5+dP1fP/kYQzrkxV2OSLSBu1zt5WZLSDaSd5QD2AdMKU1ipLwlFbU8D8vFDC6fzZTv3RQ2OWISBvVnKOtzmo07UCJu5e3Qj0SsltfWkRpRQ2PfusLpOqqgCKyB83pMF/d1HwzOw640N2vavGqJBRvLdnEc3OLufakQxjdX0dXiciexTQku5kdCVwEfANYCTzXGkVJ/G2vquVnzy9geJ8uXHWSRpwRkb1rTp/HcODC4LYFeBowdz+xlWuTOPrNjKVs3F7FA5d8kfQUnQwoInvXnJbHEuA94Cx3LwQwsx+0alUSV58WlTLtw9VcOmEIYwd1C7scEUkAzekRPRdYD7xlZn8ys4no/I52I1Lv/PfzC+nZJZ3rTxsRdjkikiD2GR7u/oK7XwCMJDrC7nVAbzN7wMxObe0CpXU99uFqFhSXcdNZo8jO0PiWItI8zT4W093L3f0Jdz8bGAjMA37aapVJq9u0vYpfz1jK8cNyOPvwfmGXIyIJpDkXg/qPXVTuvs3dH3T3iXtaR9q+/315MdWRem6ddJiuDCgiMWnWxaDM7Boz+9xFq80szcxOMrNH0ZnmCee9ZZt5cf46vnfCwQzNyQy7HBFJMM052up04FvAk2Y2FCgFMoBk4HXgt+4+r/VKlJZWVRvhphcWktuzM9/5skbMFZHYNecM8yrgfuD+4IqBOUClu5e2dnHSOh58dwWrSiqYdvl4MlJ1ToeIxC6mwYvcvdbd1+9vcJjZ6Wa21MwKzeyGJpanm9nTwfLZZpbbaPlgM9tpZj/an/cXWFdayf1vF3LGYX05flivsMsRkQQVt5HvzCwZuA84AxgFXGhmoxqtdjmwzd0PAe4Gbm+0/C7g1dautT371atLcEfXIxeRAxLPYVPHA4XuvsLda4hegXBSo3UmAY8Gj58FJu46ksvMvkp0PK2CONXb7ny8aivT56/j2186iEE9OoddjogksJjDw8wyg1ZErAYAaxtMFwXzmlzH3euAMqCnmXUhek5Jk5fEbVDbVDPLN7P8zZs370eJ7Vd9vXPLiwX0zc7gOyeok1xEDkxzzvNIMrOLzOxlM9tEdKyr9Wa2yMzuNLN4DMF6M3C3u+/c20rBuSd57p7Xq5f25zf0tzlrWVi8nRu/MpLOaTENpiwi8h+a8y3yFvAGcCOw0N3rAcysB3AicLuZPe/uj+3jdYqBQQ2mBwbzmlqnyMxSgK5ACXA0MNnM7gC6AfVmVuXu9zaj/g5ve1Utd85YylFDunPOEf3DLkdE2oHmhMfJ7l5rZrm7ggPA3bcCfwf+HhzCuy8fA8OCc0WKgQuIXhukoelETzj8FzAZmOnuDhy/awUzuxnYqeBovntnFlJSXsMj3xyvM8lFpEU0Z2DE2uDhf1z4ycwmNFpnb69TB1wNzAAWA8+4e4GZ3Wpm5wSrPUS0j6MQ+CHwH4fzSmxWbN7JI7NW8o2jBjJmoK4OKCItozkXgzoPGAdkmdmhwNIGLZAHgcOb+2bu/grwSqN5P2/wuIroVQr39ho3N/f9BP7fK4tJT0nmRxpuXURaUHN2W80iOhzJFUTPsxhhZqXAOqCyFWuTA/ThihLeWLyJH582gt5ZGWGXIyLtSHOGJykG/mpmy919FoCZ9QRyiR55JW1Qfb1z2yuL6dc1g8uPGxp2OSLSzjRnt5V51Kxd89y9hOhRUJ9bp5VqlP3w8oL1zC8q487Jh2v8KhFpcRqSvR2qrotwx4wljOybxbnjBoZdjoi0Q/s7JHsnosGjIdnboMc+XMParZX89VvjSU7Sobki0vI0JHs7U1ZZy+9nLuP4YTl8abjOsheR1hHTOBXByYLfBVLM7BPgE3f/rHVKk/1x/9uFlFXWcuMZGjVXRFpPzIMcufvPzawPMBb4mpkd4u5XtnxpEquibRU8MmsV5x45kFH9s8MuR0TasWaHh5n9E/iRu893941EzxSf0WqVSczuev0zDLj+1OFhlyIi7VwsQ7L/FPitmT1iZv1aqyDZP0s2bOf5T4r55hdz6d+tU9jliEg71+zwcPe57n4i8BLwmpn9wsz0LdVG/Ob1z+iSnsJ3v6xrdYhI64vpYlDBVf2WAg8A1wDLzOzS1ihMmm/umm38c9FGvv2lg+jWOS3sckSkA2h2eJjZLKJDqd9N9Ip/3wROAMab2YOtUZw0z69nLCWnSxr/9UUNQyIi8RHL0VZTgUVNDENyjZktbsGaJAbvL9vCB8tL+MXZo8hM1xUCRSQ+mv1t4+4Fe1l8ZgvUIjFyd+6csYT+XTO46OjB+36CiEgLianPY0/cfUVLvI7EZkbBRuYXlXHdycNJT9HghyISPy0SHhJ/kXrnN68v5aBemZw7bkDY5YhIB6PwSFAvzCtm2aadXH/KCFKS9c8oIvGlb50EVFNXz2/f/IzR/bM547C+YZcjIh2QwiMB/X1uEWu3VnL9qcNJ0pDrIhIChUeCqa6LcO/MQsYO6saJI3qHXY6IdFAKjwTzTH4RxaWV/PCU4URP+BcRiT+FRwKpqo1w38xC8oZ05/hhOWGXIyIdmMIjgTz10Ro2bK9Sq0NEQqfwSBBVtRHuf3s544f24JiDe4Zdjoh0cAqPBPH47DVs2lGtVoeItAkKjwRQUVPHA28XcuzBPZlwkFodIhI+hUcCeOzD1WzZWcMPTtHlZUWkbVB4tHEVNXX88Z0VHD8shy/k9gi7HBERQOHR5k3712pKymu47mS1OkSk7VB4tGEVNXU8+G601XHUkO5hlyMispvCow17/MM1QatjWNiliIh8jsKjjaqsifDHd5dz3CE5HDVEfR0i0rYoPNqox2dHj7D6vlodItIGKTzaoKraCH98dwXHHtxTR1iJSJuk8GiDnpi9hs07qrl2olodItI2KTzamKraCH94ZzlHD+2hs8lFpM1SeLQxT30UHcNKfR0i0pbFNTzM7HQzW2pmhWZ2QxPL083s6WD5bDPLDeafYmZzzGxBcH9SPOuOl6raCA+8s5zxuT04Rq0OEWnD4hYeZpYM3AecAYwCLjSzUY1WuxzY5u6HAHcDtwfztwBnu/sYYAowLT5Vx9ff8teycXu01aGRc0WkLYtny2M8UOjuK9y9BngKmNRonUnAo8HjZ4GJZmbuPs/d1wXzC4BOZpYel6rjpLouer2OvCHdOVbX6xCRNi6e4TEAWNtguiiY1+Q67l4HlAGNv0m/Dsx19+pWqjMUz84pYn1ZFddOVKtDRNq+lLALiIWZjSa6K+vUPSyfCkwFGDx4cBwrOzA1dfXc/9ZyjhzcTdcmF5GEEM+WRzEwqMH0wGBek+uYWQrQFSgJpgcCzwOXufvypt7A3R909zx3z+vVq1cLl996np9XRHFppVodIpIw4hkeHwPDzGyomaUBFwDTG60znWiHOMBkYKa7u5l1A14GbnD3WXGrOA5qI/Xc+1Yhhw/sygnDEyfwRKRji1t4BH0YVwMzgMXAM+5eYGa3mtk5wWoPAT3NrBD4IbDrcN6rgUOAn5vZJ8Gtd7xqb00vzCtm7dZKrj1JrQ4RSRzm7mHX0Cry8vI8Pz8/7DL2qi6K6CpwAAAKvklEQVRSz8l3vUNmegovXXOcwkNEQmdmc9w9b1/r6QzzEL346TpWlVSor0NEEo7CIySReuf3MwsZ2TeLUw7tE3Y5IiIxUXiE5KVP17FicznXThxGUpJaHSKSWBQeIYjUO797cxkj+mRx+ui+YZcjIhIzhUcIXvp0Hcs3l/P9k9XqEJHEpPCIs0i9c8+byxjZV60OEUlcCo84e3F+tK/j++rrEJEEpvCIo119HSP7ZnGaWh0iksAUHnE0fX4xK7aUc536OkQkwSk84qQuUs/v34ye13HqKLU6RCSxKTzi5MVP16nVISLthsIjDuoi9fzuzUIO7ZetVoeItAsKjziYPn8dK7foCCsRaT8UHq2spq6eu9/4jFH9sjlttMawEpH2QeHRyp7+eA1rt1by49NHaORcEWk3FB6tqKKmjt/NLGR8bg9dJVBE2hWFRyv6ywer2Lyjmp+o1SEi7YzCo5WUVdTyh7eXc9LI3uTl9gi7HBGRFqXwaCV/fHc526vq+NGpI8IuRUSkxSk8WsGmHVU8MmsV5xzRn1H9s8MuR0SkxSk8WsG9MwupidTzg1OGh12KiEirUHi0sLVbK3jyozWclzeIoTmZYZcjItIqFB4t7K5/fkaSGd+fOCzsUkREWo3CowXNWb2N5+cV863jhtK3a0bY5YiItBqFRwupr3dunl5An+x0rj7xkLDLERFpVQqPFvK3OWtZUFzGz75yKJnpKWGXIyLSqhQeLaCsspY7XltK3pDunHNE/7DLERFpdfqJ3ALueWMZWytqePSc8RqGREQ6BLU8DtBnG3fw6L9WceH4wRw2oGvY5YiIxIXC4wC4O7e8WEBmWrKGIRGRDkXhcQBmFGxgVmEJ1586gh6ZaWGXIyISNwqP/VRWUcutLy5iZN8sLj56cNjliIjElcJjP7g7P/n7fDbtqOZXXz+clGT9GUWkY9G33n6Y9uFqZhRs5Kenj2TsoG5hlyMiEncKjxgVrCvj/15azIkjenH5cUPDLkdEJBQKjxiUV9dxzRPz6J6Zym/OG0tSks7pEJGOSScJxuCmFxayqqScJ66coKOrRKRDU8ujmZ6dU8Rz84q5duIwJhzUM+xyRERCpZbHPtRG6vnzeyu5+43PmHBQD645SdfpEBGJa8vDzE43s6VmVmhmNzSxPN3Mng6Wzzaz3AbLbgzmLzWz0+JR77w12zj79+9z+2tLOHFEL+67aBzJ6ucQEYlfy8PMkoH7gFOAIuBjM5vu7osarHY5sM3dDzGzC4DbgfPNbBRwATAa6A+8YWbD3T3SGrXuqKrlzhlLmfbhavpkZfDgpUdx6ui+rfFWIiIJKZ67rcYDhe6+AsDMngImAQ3DYxJwc/D4WeBeiw5TOwl4yt2rgZVmVhi83r9aushPi0q58q/5bNpRzZRjcvnRaSPooutziIh8Tjy/FQcAaxtMFwFH72kdd68zszKgZzD/w0bPHdD4DcxsKjAVYPDg/RsyZHCPzgzvk8UfL83TCYAiInvQrn5Su/uDwIMAeXl5vj+v0a1zGtMub5xpIiLSUDw7zIuBQQ2mBwbzmlzHzFKArkBJM58rIiJxEs/w+BgYZmZDzSyNaAf49EbrTAemBI8nAzPd3YP5FwRHYw0FhgEfxaluERFpJG67rYI+jKuBGUAy8LC7F5jZrUC+u08HHgKmBR3iW4kGDMF6zxDtXK8DrmqtI61ERGTfLPrDvv3Jy8vz/Pz8sMsQEUkoZjbH3fP2tZ6GJxERkZgpPEREJGYKDxERiZnCQ0REYtZuO8zNbDOw+gBeIgfY0kLlhKm9bAdoW9qi9rIdoG3ZZYi799rXSu02PA6UmeU354iDtq69bAdoW9qi9rIdoG2JlXZbiYhIzBQeIiISM4XHnj0YdgEtpL1sB2hb2qL2sh2gbYmJ+jxERCRmanmIiEjMFB4iIhIzhUcjZna6mS01s0IzuyHsemJhZg+b2SYzW9hgXg8z+6eZLQvuu4dZY3OY2SAze8vMFplZgZl9P5ifiNuSYWYfmdn8YFtuCeYPNbPZwefs6eAyBQnBzJLNbJ6ZvRRMJ+S2mNkqM1tgZp+YWX4wLxE/Y93M7FkzW2Jmi83smHhsh8KjATNLBu4DzgBGARea2ahwq4rJX4DTG827AXjT3YcBbwbTbV0dcL27jwImAFcF/w6JuC3VwEnufgQwFjjdzCYAtwN3u/shwDbg8hBrjNX3gcUNphN5W05097ENzolIxM/YPcBr7j4SOILov03rb4e76xbcgGOAGQ2mbwRuDLuuGLchF1jYYHop0C943A9YGnaN+7FN/wBOSfRtAToDc4GjiZ79mxLM/9znri3fiF7F803gJOAlwBJ4W1YBOY3mJdRnjOjVVlcSHPwUz+1Qy+PzBgBrG0wXBfMSWR93Xx883gD0CbOYWJlZLnAkMJsE3ZZgN88nwCbgn8ByoNTd64JVEulz9lvgJ0B9MN2TxN0WB143szlmNjWYl2ifsaHAZuCRYFfin80skzhsh8KjA/Hoz5CEOTbbzLoAfweuc/ftDZcl0ra4e8TdxxL91T4eGBlySfvFzM4CNrn7nLBraSHHufs4oruprzKzLzVcmCCfsRRgHPCAux8JlNNoF1VrbYfC4/OKgUENpgcG8xLZRjPrBxDcbwq5nmYxs1SiwfG4uz8XzE7IbdnF3UuBt4ju2ulmZrsuA50on7MvAueY2SrgKaK7ru4hMbcFdy8O7jcBzxMN9kT7jBUBRe4+O5h+lmiYtPp2KDw+72NgWHD0SBrRa6hPD7mmAzUdmBI8nkK0/6BNMzMjej37xe5+V4NFibgtvcysW/C4E9G+m8VEQ2RysFpCbIu73+juA909l+j/jZnufjEJuC1mlmlmWbseA6cCC0mwz5i7bwDWmtmIYNZEYBFx2A6dYd6ImX2F6H7dZOBhd/9lyCU1m5k9CZxAdDjmjcAvgBeAZ4DBRIeoP8/dt4ZVY3OY2XHAe8AC/r1v/WdE+z0SbVsOBx4l+nlKAp5x91vN7CCiv957APOAS9y9OrxKY2NmJwA/cvezEnFbgpqfDyZTgCfc/Zdm1pPE+4yNBf4MpAErgP8i+KzRituh8BARkZhpt5WIiMRM4SEiIjFTeIiISMwUHiIiEjOFh4iIxEzhISIiMVN4iIhIzBQeIi3MzAaa2fl7WNbJzN4Jhv9vanmamb3bYLgPkTZJ4SHS8iYSHV+oKd8CnnP3SFML3b2G6JDnTYaPSFuh8BBpQcHQKncBk4Mr1B3UaJWLCcYZCsZXejm4yuDCBq2VF4L1RNosNY1FWpC7v29mHxMd92lhw2XBYJsHufuqYNbpwDp3PzNY3jWYvxD4QpxKFtkvanmItLwRwJIm5ucApQ2mFwCnmNntZna8u5dB9PofQM2uUV9F2iKFh0gLMrMcoKzBlfUaqgQydk24+2dE+0YWAP9nZj9vsG46UNWatYocCO22EmlZucC6pha4+7bgkrQZ7l5lZv2Bre7+mJmVAlcABMOCb3H32rhVLRIjtTxEWtYSICfoAD+2ieWvA8cFj8cAHwXXN/8F8H/B/BOBl1u9UpEDoOt5iMSRmY0DfuDul+5lneeAG4LdWiJtkloeInHk7nOBt/Z2kiDwgoJD2jq1PEREJGZqeYiISMwUHiIiEjOFh4iIxEzhISIiMVN4iIhIzBQeIiISs/8PN2Hlk0u2DUkAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "edata.t_presim = 10\n",
+    "edata.fixedParametersPresimulation = [10.0,0.0]\n",
+    "edata.fixedParameters = [10.0,2.0]\n",
+    "print(edata.fixedParametersPreequilibration)\n",
+    "print(edata.fixedParametersPresimulation)\n",
+    "print(edata.fixedParameters)\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/model_presimulation.xml b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/model_presimulation.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a79d6b6585c7587a637cb65c6b9e96c78cb1f712
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_presimulation/model_presimulation.xml
@@ -0,0 +1,180 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sbml xmlns="http://www.sbml.org/sbml/level3/version2/core" level="3" version="2">
+  <model name="createModelPresimulation">
+    <listOfCompartments>
+      <compartment id="default" spatialDimensions="3" size="1" constant="true"/>
+    </listOfCompartments>
+    <listOfSpecies>
+      <species id="__s0" name="PROT(kin=None, drug=None, phospho=&apos;u&apos;)" compartment="default" hasOnlySubstanceUnits="true" boundaryCondition="false" constant="false"/>
+      <species id="__s1" name="DRUG(bound=None)" compartment="default" hasOnlySubstanceUnits="true" boundaryCondition="false" constant="false"/>
+      <species id="__s2" name="KIN(bound=None)" compartment="default" hasOnlySubstanceUnits="true" boundaryCondition="false" constant="false"/>
+      <species id="__s3" name="DRUG(bound=1) ._br_PROT(kin=None, drug=1, phospho=&apos;u&apos;)" compartment="default" initialAmount="0" hasOnlySubstanceUnits="true" boundaryCondition="false" constant="false"/>
+      <species id="__s4" name="KIN(bound=1) ._br_PROT(kin=1, drug=None, phospho=&apos;u&apos;)" compartment="default" initialAmount="0" hasOnlySubstanceUnits="true" boundaryCondition="false" constant="false"/>
+      <species id="__s5" name="PROT(kin=None, drug=None, phospho=&apos;p&apos;)" compartment="default" initialAmount="0" hasOnlySubstanceUnits="true" boundaryCondition="false" constant="false"/>
+    </listOfSpecies>
+    <listOfParameters>
+      <parameter id="initProt" name="initProt" constant="false"/>
+      <parameter id="initDrug" name="initDrug" constant="false"/>
+      <parameter id="initKin" name="initKin" constant="false"/>
+      <parameter id="pPROT_obs" name="pPROT_obs" constant="false"/>
+      <parameter id="PROT_0" name="PROT_0" value="10" constant="true"/>
+      <parameter id="DRUG_0" name="DRUG_0" value="9" constant="true"/>
+      <parameter id="KIN_0" name="KIN_0" value="1" constant="true"/>
+      <parameter id="kon_prot_drug" name="kon_prot_drug" value="0.1" constant="true"/>
+      <parameter id="koff_prot_drug" name="koff_prot_drug" value="0.1" constant="true"/>
+      <parameter id="kon_prot_kin" name="kon_prot_kin" value="0.1" constant="true"/>
+      <parameter id="kphospho_prot_kin" name="kphospho_prot_kin" value="0.1" constant="true"/>
+      <parameter id="kdephospho_prot" name="kdephospho_prot" value="0.1" constant="true"/>
+      <parameter id="__obs0" name="pPROT" constant="false"/>
+      <parameter id="__obs1" name="tPROT" constant="false"/>
+    </listOfParameters>
+    <listOfInitialAssignments>
+      <initialAssignment symbol="__s0">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> initProt </ci>
+        </math>
+      </initialAssignment>
+      <initialAssignment symbol="__s1">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> initDrug </ci>
+        </math>
+      </initialAssignment>
+      <initialAssignment symbol="__s2">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> initKin </ci>
+        </math>
+      </initialAssignment>
+    </listOfInitialAssignments>
+    <listOfRules>
+      <assignmentRule variable="initProt">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> PROT_0 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="initDrug">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> DRUG_0 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="initKin">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> KIN_0 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="pPROT_obs">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <apply>
+            <divide/>
+            <ci> __s5 </ci>
+            <apply>
+              <plus/>
+              <ci> __s0 </ci>
+              <ci> __s3 </ci>
+              <ci> __s4 </ci>
+              <ci> __s5 </ci>
+            </apply>
+          </apply>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="__obs0">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> __s5 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="__obs1">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <apply>
+            <plus/>
+            <ci> __s0 </ci>
+            <ci> __s3 </ci>
+            <ci> __s4 </ci>
+            <ci> __s5 </ci>
+          </apply>
+        </math>
+      </assignmentRule>
+    </listOfRules>
+    <listOfReactions>
+      <reaction id="r0" name="PROT_DRUG_bind" reversible="true">
+        <listOfReactants>
+          <speciesReference species="__s0" constant="true"/>
+          <speciesReference species="__s1" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="__s3" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <minus/>
+              <apply>
+                <times/>
+                <ci> __s0 </ci>
+                <ci> __s1 </ci>
+                <ci> kon_prot_drug </ci>
+              </apply>
+              <apply>
+                <times/>
+                <ci> __s3 </ci>
+                <ci> koff_prot_drug </ci>
+              </apply>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r1" name="PROT_KIN_bind" reversible="false">
+        <listOfReactants>
+          <speciesReference species="__s0" constant="true"/>
+          <speciesReference species="__s2" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="__s4" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> __s0 </ci>
+              <ci> __s2 </ci>
+              <ci> kon_prot_kin </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r2" name="PROT_KIN_phospho" reversible="false">
+        <listOfReactants>
+          <speciesReference species="__s4" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="__s2" constant="true"/>
+          <speciesReference species="__s5" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> __s4 </ci>
+              <ci> kphospho_prot_kin </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r3" name="PROT_dephospho" reversible="false">
+        <listOfReactants>
+          <speciesReference species="__s5" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="__s0" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> __s5 </ci>
+              <ci> kdephospho_prot </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+    </listOfReactions>
+  </model>
+</sbml>
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_steadystate/ExampleSteadystate.ipynb b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_steadystate/ExampleSteadystate.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d11d8edd646d811f9351e25fd69e4d0dbff60764
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_steadystate/ExampleSteadystate.ipynb
@@ -0,0 +1,3508 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AMICI Python example \"steadystate\"\n",
+    "\n",
+    "This is an example using the [model_steadystate_scaled.sbml] model to demonstrate and test SBML import and AMICI Python interface."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SBML model we want to import\n",
+    "sbml_file = 'model_steadystate_scaled.xml'\n",
+    "# Name of the model that will also be the name of the python module\n",
+    "model_name = 'model_steadystate_scaled'\n",
+    "# Directory to which the generated model code is written\n",
+    "model_output_dir = model_name\n",
+    "\n",
+    "import libsbml\n",
+    "import importlib\n",
+    "import amici\n",
+    "import os\n",
+    "import sys\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The example model\n",
+    "\n",
+    "Here we use `libsbml` to show the reactions and species described by the model (this is independent of AMICI)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Species:  ['x1', 'x2', 'x3']\n",
+      "\n",
+      "Reactions:\n",
+      " r1:       2 x1  ->        x2\t\t[p1 * x1^2]\n",
+      " r2:   x1 +  x2  ->        x3\t\t[p2 * x1 * x2]\n",
+      " r3:         x2  ->      2 x1\t\t[p3 * x2]\n",
+      " r4:         x3  ->  x1 +  x2\t\t[p4 * x3]\n",
+      " r5:         x3  ->          \t\t[k0 * x3]\n",
+      " r6:             ->        x1\t\t[p5]\n"
+     ]
+    }
+   ],
+   "source": [
+    "sbml_reader = libsbml.SBMLReader()\n",
+    "sbml_doc = sbml_reader.readSBML(sbml_file)\n",
+    "sbml_model = sbml_doc.getModel()\n",
+    "dir(sbml_doc)\n",
+    "\n",
+    "print('Species: ', [s.getId() for s in sbml_model.getListOfSpecies()])\n",
+    "\n",
+    "print('\\nReactions:')\n",
+    "for reaction in sbml_model.getListOfReactions():\n",
+    "    reactants = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfReactants()])\n",
+    "    products  = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfProducts()])\n",
+    "    reversible = '<' if reaction.getReversible() else ''\n",
+    "    print('%3s: %10s %1s->%10s\\t\\t[%s]' % (reaction.getId(), \n",
+    "                        reactants,\n",
+    "                        reversible,\n",
+    "                         products,\n",
+    "                        libsbml.formulaToL3String(reaction.getKineticLaw().getMath())))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Importing an SBML model, compiling and generating an AMICI module\n",
+    "\n",
+    "Before we can use AMICI to simulate our model, the SBML model needs to be translated to C++ code. This is done by `amici.SbmlImporter`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create an SbmlImporter instance for our SBML model\n",
+    "sbml_importer = amici.SbmlImporter(sbml_file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, we want to specify fixed parameters, observables and a $\\sigma$ parameter. Unfortunately, the latter two are not part of the [SBML standard](http://sbml.org/). However, they can be provided to `amici.SbmlImporter.sbml2amici` as demonstrated in the following."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constant parameters\n",
+    "\n",
+    "Constant parameters, i.e. parameters with respect to which no sensitivities are to be computed (these are often parameters specifying a certain experimental condition) are provided as a list of parameter names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "constantParameters = ['k0']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Observables\n",
+    "\n",
+    "Specifying observables is beyond the scope of SBML. Here we define them manually.\n",
+    "\n",
+    "If you are looking for a more scalable way for defining observables, ideally inside the SBML file, then checkout https://github.com/ICB-DCM/PEtab. There use a convention based on SBML's [`AssignmentRule`](http://sbml.org/Software/libSBML/5.13.0/docs//python-api/classlibsbml_1_1_rule.html) to specify *Model outputs* within the SBML file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define observables\n",
+    "observables = {\n",
+    "    'observable_x1': {'name': '', 'formula': 'x1'}, \n",
+    "    'observable_x2': {'name': '', 'formula': 'x2'}, \n",
+    "    'observable_x3': {'name': '', 'formula': 'x3'}, \n",
+    "    'observable_x1_scaled': {'name': '', 'formula': 'scaling_x1 * x1'}, \n",
+    "    'observable_x2_offsetted': {'name': '', 'formula': 'offset_x2 + x2'}, \n",
+    "    'observable_x1withsigma': {'name': '', 'formula': 'x1'}\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### $\\sigma$ parameters\n",
+    "\n",
+    "To specify measurement noise as a parameter, we simply provide a dictionary with (preexisting) parameter names as keys and a list of observable names as values to indicate which sigma parameter is to be used for which observable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigmas = {'observable_x1withsigma': 'observable_x1withsigma_sigma'}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generating the module\n",
+    "\n",
+    "Now we can generate the python module for our model. `amici.SbmlImporter.sbml2amici` will symbolically derive the sensitivity equations, generate C++ code for model simulation, and assemble the python module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sbml_importer.sbml2amici(model_name, \n",
+    "                         model_output_dir, \n",
+    "                         verbose=False,\n",
+    "                         observables=observables,\n",
+    "                         constantParameters=constantParameters,\n",
+    "                         sigmas=sigmas)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Importing the module and loading the model\n",
+    "\n",
+    "If everything went well, we need to add the previously selected model output directory to our PYTHON_PATH and are then ready to load newly generated model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sys.path.insert(0, os.path.abspath(model_output_dir))\n",
+    "model_module = importlib.import_module(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And get an instance of our model from which we can retrieve information such as parameter names:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model parameters: ('p1', 'p2', 'p3', 'p4', 'p5', 'scaling_x1', 'offset_x2', 'observable_x1withsigma_sigma')\n",
+      "Model outputs:    ('observable_x1', 'observable_x2', 'observable_x3', 'observable_x1_scaled', 'observable_x2_offsetted', 'observable_x1withsigma')\n",
+      "Model states:     ('x1', 'x2', 'x3')\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = model_module.getModel()\n",
+    "\n",
+    "print(\"Model parameters:\", model.getParameterIds())\n",
+    "print(\"Model outputs:   \", model.getObservableIds())\n",
+    "print(\"Model states:    \", model.getStateIds())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using the python-generated AMICI model from Matlab\n",
+    "\n",
+    "It is also possible to use a Python-AMICI imported model from Matlab. You might want to do this because:\n",
+    "- you don't have the Symbolic Math Toolbox available\n",
+    "- model generation using the AMICI Python interface can be significantly faster\n",
+    "- python SBML import has some extra features that are not available through the matlab interface\n",
+    "- model equations will differ between Python- and Matlab-import"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "To use python-generated model in Matlab, ensure you added AMICI to your matlab path and run:\n",
+      "\n",
+      "modelName = 'model_steadystate_scaled';\n",
+      "modelDir = '/home/dweindl/src/AMICI-devel/python/examples/example_steadystate/model_steadystate_scaled';\n",
+      "amimodel.compileAndLinkModel(modelName, modelDir, [], [], [], []);\n",
+      "amimodel.generateMatlabWrapper(3, 6, 8, 1, 0, 0, [], [ modelDir '/simulate_' modelName '.m'], modelName, 'lin', 1, 1);\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('''To use python-generated model in Matlab, ensure you added AMICI to your matlab path and run:\n",
+    "\n",
+    "modelName = '{model_name}';\n",
+    "modelDir = '{model_output_dir}';\n",
+    "amimodel.compileAndLinkModel(modelName, modelDir, [], [], [], []);\n",
+    "amimodel.generateMatlabWrapper({nx}, {ny}, {np}, {nk}, {nz}, {o2flag}, [], [ modelDir '/simulate_' modelName '.m'], modelName, 'lin', 1, 1);\n",
+    "'''.format(model_name=model_name, \n",
+    "           model_output_dir=os.path.abspath(model_output_dir),\n",
+    "           nx = model.nxtrue_rdata,\n",
+    "           ny = model.nytrue,\n",
+    "           np = model.np(),\n",
+    "           nk = model.nk(),\n",
+    "           nz = model.nz,\n",
+    "           o2flag = model.o2mode\n",
+    "          ))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This will use the matlab compiler to generate a mex file and will create a Matlab wrapper script. You have to run this only once after generating the Python model. Afterwards you can use the model from Matlab just as if it was generted using `amiwrap.m` directly."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running simulations and analyzing results\n",
+    "\n",
+    "After importing the model, we can run simulations using `amici.runAmiciSimulation`. This requires a `Model` instance and a `Solver` instance. Optionally you can provide measurements inside an `ExpData` instance, as shown later in this notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Create Model instance\n",
+    "model = model_module.getModel()\n",
+    "\n",
+    "# set timepoints for which we want to simulate the model\n",
+    "model.setTimepoints(np.linspace(0, 60, 60)) \n",
+    "\n",
+    "# Create solver instance\n",
+    "solver = model.getSolver()\n",
+    "\n",
+    "# Run simulation using default model parameters and solver options\n",
+    "rdata = amici.runAmiciSimulation(model, solver)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulation was run using model default parameters as specified in the SBML model:\n",
+      "(1.0, 0.5, 0.4, 2.0, 0.1, 2.0, 3.0, 0.2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Simulation was run using model default parameters as specified in the SBML model:')\n",
+    "print(model.getParameters())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Simulation results are provided as `numpy.ndarray`s in the returned dictionary:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         ptr:  <amici.amici.ReturnDataPtr; proxy of <Swig Object of type 'std::unique_ptr< amici::ReturnData > *' at 0x7fdc43ec3cc0> >\n",
+      "           t:  [ 0.          1.01694915  2.03389831  3.05084746  4.06779661  5.08474576\n",
+      "  6.10169492  7.11864407  8.13559322  9.15254237 10.16949153 11.18644068\n",
+      " 12.20338983 13.22033898 14.23728814 15.25423729 16.27118644 17.28813559\n",
+      " 18.30508475 19.3220339  20.33898305 21.3559322  22.37288136 23.38983051\n",
+      " 24.40677966 25.42372881 26.44067797 27.45762712 28.47457627 29.49152542\n",
+      " 30.50847458 31.52542373 32.54237288 33.55932203 34.57627119 35.59322034\n",
+      " 36.61016949 37.62711864 38.6440678  39.66101695 40.6779661  41.69491525\n",
+      " 42.71186441 43.72881356 44.74576271 45.76271186 46.77966102 47.79661017\n",
+      " 48.81355932 49.83050847 50.84745763 51.86440678 52.88135593 53.89830508\n",
+      " 54.91525424 55.93220339 56.94915254 57.96610169 58.98305085 60.        ]\n",
+      "           x:  [[0.1        0.4        0.7       ]\n",
+      " [0.57995051 0.73365809 0.0951589 ]\n",
+      " [0.55996496 0.71470091 0.0694127 ]\n",
+      " [0.5462855  0.68030366 0.06349394]\n",
+      " [0.53561883 0.64937432 0.05923555]\n",
+      " [0.52636487 0.62259567 0.05568686]\n",
+      " [0.51822014 0.59943346 0.05268079]\n",
+      " [0.51103767 0.57935661 0.05012037]\n",
+      " [0.5047003  0.56191593 0.04793052]\n",
+      " [0.49910666 0.54673518 0.0460508 ]\n",
+      " [0.49416809 0.53349812 0.04443206]\n",
+      " [0.48980688 0.52193768 0.043034  ]\n",
+      " [0.48595477 0.51182733 0.04182339]\n",
+      " [0.48255177 0.50297415 0.04077267]\n",
+      " [0.47954512 0.49521321 0.03985882]\n",
+      " [0.47688834 0.48840307 0.03906254]\n",
+      " [0.4745405  0.48242201 0.03836756]\n",
+      " [0.47246548 0.47716503 0.0377601 ]\n",
+      " [0.47063147 0.4725413  0.03722844]\n",
+      " [0.46901037 0.46847203 0.03676259]\n",
+      " [0.4675774  0.46488882 0.03635397]\n",
+      " [0.46631066 0.46173208 0.03599523]\n",
+      " [0.46519082 0.45894988 0.03568002]\n",
+      " [0.46420083 0.45649685 0.03540285]\n",
+      " [0.4633256  0.45433333 0.03515899]\n",
+      " [0.46255181 0.45242458 0.0349443 ]\n",
+      " [0.46186769 0.45074017 0.0347552 ]\n",
+      " [0.46126283 0.44925338 0.03458856]\n",
+      " [0.46072804 0.44794076 0.03444166]\n",
+      " [0.46025521 0.44678169 0.03431212]\n",
+      " [0.45983714 0.44575805 0.03419785]\n",
+      " [0.4594675  0.44485389 0.03409701]\n",
+      " [0.45914066 0.44405515 0.03400802]\n",
+      " [0.45885167 0.44334948 0.03392946]\n",
+      " [0.45859615 0.44272595 0.03386009]\n",
+      " [0.45837021 0.44217497 0.03379883]\n",
+      " [0.45817044 0.44168806 0.03374473]\n",
+      " [0.45799379 0.44125773 0.03369693]\n",
+      " [0.4578376  0.44087739 0.03365471]\n",
+      " [0.45769949 0.44054121 0.0336174 ]\n",
+      " [0.45757737 0.44024405 0.03358444]\n",
+      " [0.45746939 0.43998138 0.03355531]\n",
+      " [0.45737391 0.43974917 0.03352956]\n",
+      " [0.45728949 0.4395439  0.03350681]\n",
+      " [0.45721483 0.43936243 0.0334867 ]\n",
+      " [0.45714882 0.43920199 0.03346892]\n",
+      " [0.45709046 0.43906015 0.03345321]\n",
+      " [0.45703884 0.43893475 0.03343932]\n",
+      " [0.45699321 0.43882387 0.03342704]\n",
+      " [0.45695285 0.43872585 0.03341618]\n",
+      " [0.45691717 0.43863918 0.03340658]\n",
+      " [0.45688562 0.43856255 0.0333981 ]\n",
+      " [0.45685772 0.43849479 0.0333906 ]\n",
+      " [0.45683305 0.43843488 0.03338397]\n",
+      " [0.45681123 0.43838191 0.0333781 ]\n",
+      " [0.45679194 0.43833508 0.03337292]\n",
+      " [0.45677489 0.43829366 0.03336833]\n",
+      " [0.4567598  0.43825705 0.03336428]\n",
+      " [0.45674647 0.43822467 0.0333607 ]\n",
+      " [0.45673468 0.43819604 0.03335753]]\n",
+      "          x0:  [0.1 0.4 0.7]\n",
+      "        x_ss:  [nan nan nan]\n",
+      "          sx:  None\n",
+      "         sx0:  None\n",
+      "       sx_ss:  None\n",
+      "           y:  [[0.1        0.4        0.7        0.2        3.4        0.1       ]\n",
+      " [0.57995051 0.73365809 0.0951589  1.15990103 3.73365809 0.57995051]\n",
+      " [0.55996496 0.71470091 0.0694127  1.11992992 3.71470091 0.55996496]\n",
+      " [0.5462855  0.68030366 0.06349394 1.092571   3.68030366 0.5462855 ]\n",
+      " [0.53561883 0.64937432 0.05923555 1.07123766 3.64937432 0.53561883]\n",
+      " [0.52636487 0.62259567 0.05568686 1.05272975 3.62259567 0.52636487]\n",
+      " [0.51822014 0.59943346 0.05268079 1.03644027 3.59943346 0.51822014]\n",
+      " [0.51103767 0.57935661 0.05012037 1.02207534 3.57935661 0.51103767]\n",
+      " [0.5047003  0.56191593 0.04793052 1.0094006  3.56191593 0.5047003 ]\n",
+      " [0.49910666 0.54673518 0.0460508  0.99821332 3.54673518 0.49910666]\n",
+      " [0.49416809 0.53349812 0.04443206 0.98833619 3.53349812 0.49416809]\n",
+      " [0.48980688 0.52193768 0.043034   0.97961375 3.52193768 0.48980688]\n",
+      " [0.48595477 0.51182733 0.04182339 0.97190953 3.51182733 0.48595477]\n",
+      " [0.48255177 0.50297415 0.04077267 0.96510354 3.50297415 0.48255177]\n",
+      " [0.47954512 0.49521321 0.03985882 0.95909024 3.49521321 0.47954512]\n",
+      " [0.47688834 0.48840307 0.03906254 0.95377669 3.48840307 0.47688834]\n",
+      " [0.4745405  0.48242201 0.03836756 0.94908099 3.48242201 0.4745405 ]\n",
+      " [0.47246548 0.47716503 0.0377601  0.94493097 3.47716503 0.47246548]\n",
+      " [0.47063147 0.4725413  0.03722844 0.94126294 3.4725413  0.47063147]\n",
+      " [0.46901037 0.46847203 0.03676259 0.93802075 3.46847203 0.46901037]\n",
+      " [0.4675774  0.46488882 0.03635397 0.93515479 3.46488882 0.4675774 ]\n",
+      " [0.46631066 0.46173208 0.03599523 0.93262131 3.46173208 0.46631066]\n",
+      " [0.46519082 0.45894988 0.03568002 0.93038165 3.45894988 0.46519082]\n",
+      " [0.46420083 0.45649685 0.03540285 0.92840166 3.45649685 0.46420083]\n",
+      " [0.4633256  0.45433333 0.03515899 0.9266512  3.45433333 0.4633256 ]\n",
+      " [0.46255181 0.45242458 0.0349443  0.92510362 3.45242458 0.46255181]\n",
+      " [0.46186769 0.45074017 0.0347552  0.92373537 3.45074017 0.46186769]\n",
+      " [0.46126283 0.44925338 0.03458856 0.92252566 3.44925338 0.46126283]\n",
+      " [0.46072804 0.44794076 0.03444166 0.92145609 3.44794076 0.46072804]\n",
+      " [0.46025521 0.44678169 0.03431212 0.92051042 3.44678169 0.46025521]\n",
+      " [0.45983714 0.44575805 0.03419785 0.91967428 3.44575805 0.45983714]\n",
+      " [0.4594675  0.44485389 0.03409701 0.91893499 3.44485389 0.4594675 ]\n",
+      " [0.45914066 0.44405515 0.03400802 0.91828132 3.44405515 0.45914066]\n",
+      " [0.45885167 0.44334948 0.03392946 0.91770334 3.44334948 0.45885167]\n",
+      " [0.45859615 0.44272595 0.03386009 0.91719229 3.44272595 0.45859615]\n",
+      " [0.45837021 0.44217497 0.03379883 0.91674042 3.44217497 0.45837021]\n",
+      " [0.45817044 0.44168806 0.03374473 0.91634087 3.44168806 0.45817044]\n",
+      " [0.45799379 0.44125773 0.03369693 0.91598759 3.44125773 0.45799379]\n",
+      " [0.4578376  0.44087739 0.03365471 0.9156752  3.44087739 0.4578376 ]\n",
+      " [0.45769949 0.44054121 0.0336174  0.91539899 3.44054121 0.45769949]\n",
+      " [0.45757737 0.44024405 0.03358444 0.91515475 3.44024405 0.45757737]\n",
+      " [0.45746939 0.43998138 0.03355531 0.91493879 3.43998138 0.45746939]\n",
+      " [0.45737391 0.43974917 0.03352956 0.91474783 3.43974917 0.45737391]\n",
+      " [0.45728949 0.4395439  0.03350681 0.91457897 3.4395439  0.45728949]\n",
+      " [0.45721483 0.43936243 0.0334867  0.91442967 3.43936243 0.45721483]\n",
+      " [0.45714882 0.43920199 0.03346892 0.91429765 3.43920199 0.45714882]\n",
+      " [0.45709046 0.43906015 0.03345321 0.91418091 3.43906015 0.45709046]\n",
+      " [0.45703884 0.43893475 0.03343932 0.91407769 3.43893475 0.45703884]\n",
+      " [0.45699321 0.43882387 0.03342704 0.91398641 3.43882387 0.45699321]\n",
+      " [0.45695285 0.43872585 0.03341618 0.9139057  3.43872585 0.45695285]\n",
+      " [0.45691717 0.43863918 0.03340658 0.91383434 3.43863918 0.45691717]\n",
+      " [0.45688562 0.43856255 0.0333981  0.91377123 3.43856255 0.45688562]\n",
+      " [0.45685772 0.43849479 0.0333906  0.91371543 3.43849479 0.45685772]\n",
+      " [0.45683305 0.43843488 0.03338397 0.91366609 3.43843488 0.45683305]\n",
+      " [0.45681123 0.43838191 0.0333781  0.91362246 3.43838191 0.45681123]\n",
+      " [0.45679194 0.43833508 0.03337292 0.91358389 3.43833508 0.45679194]\n",
+      " [0.45677489 0.43829366 0.03336833 0.91354977 3.43829366 0.45677489]\n",
+      " [0.4567598  0.43825705 0.03336428 0.91351961 3.43825705 0.4567598 ]\n",
+      " [0.45674647 0.43822467 0.0333607  0.91349294 3.43822467 0.45674647]\n",
+      " [0.45673468 0.43819604 0.03335753 0.91346935 3.43819604 0.45673468]]\n",
+      "      sigmay:  [[1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]]\n",
+      "          sy:  None\n",
+      "     ssigmay:  None\n",
+      "           z:  None\n",
+      "          rz:  None\n",
+      "      sigmaz:  None\n",
+      "          sz:  None\n",
+      "         srz:  None\n",
+      "     ssigmaz:  None\n",
+      "        sllh:  None\n",
+      "       s2llh:  None\n",
+      "           J:  [[-2.04603672  0.69437133  0.21909802]\n",
+      " [ 0.57163266 -0.62836734  0.22836734]\n",
+      " [ 2.          2.         -3.        ]]\n",
+      "        xdot:  [-1.08973588e-05 -2.64550670e-05 -2.92781904e-06]\n",
+      "      status:  0.0\n",
+      "         llh:  nan\n",
+      "        chi2:  nan\n",
+      "         res:  [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      "        sres:  None\n",
+      "         FIM:  None\n",
+      "wrms_steadystate:  nan\n",
+      "t_steadystate:  nan\n",
+      "newton_numlinsteps:  None\n",
+      "newton_numsteps:  [[0 0 0]]\n",
+      "    numsteps:  [  0 100 145 172 188 199 206 210 214 217 221 224 226 229 231 233 236 238\n",
+      " 240 243 245 248 250 252 255 256 258 259 261 262 264 265 267 269 270 272\n",
+      " 273 275 276 278 279 281 282 283 284 285 286 287 288 289 290 291 292 293\n",
+      " 294 295 296 297 298 299]\n",
+      " numrhsevals:  [  0 115 161 189 206 218 226 232 236 239 243 247 250 253 255 257 260 262\n",
+      " 264 267 269 272 274 276 279 281 283 284 286 287 289 290 292 294 295 297\n",
+      " 298 300 301 303 304 307 308 309 310 311 312 313 314 315 316 317 318 319\n",
+      " 320 321 322 323 324 325]\n",
+      "numerrtestfails:  [0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
+      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]\n",
+      "numnonlinsolvconvfails:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
+      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
+      "       order:  [0 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5\n",
+      " 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5]\n",
+      "   numstepsB:  None\n",
+      "numrhsevalsB:  None\n",
+      "numerrtestfailsB:  None\n",
+      "numnonlinsolvconvfailsB:  None\n"
+     ]
+    }
+   ],
+   "source": [
+    "#np.set_printoptions(threshold=8, edgeitems=2)\n",
+    "for key, value in rdata.items():\n",
+    "    print('%12s: ' % key, value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A note on datatypes\n",
+    "\n",
+    "You might have wondered about expression such as `rdata['y'].flatten()` or `amici.ExpData(model.get())`. This is currently required to convert between Python data types and internal C++ datatypes. The [SWIG](http://swig.org/) interface does not yet do this conversion automatically."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1.0, 0.5, 0.4, 2.0, 0.1, 2.0, 3.0, 0.2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(model.getParameters())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plotting tractories\n",
+    "\n",
+    "The simulation results above did not look too appealing. Let's plot the trajectories of the model states and outputs  them using `matplotlib.pyplot`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEZCAYAAABiu9n+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XucXXV97//XZ19m9twzmUlCyG0SgmAAQYwaRFoEtQheKfXaKi3ncLCgtervKD3+bO1Dj1LPz5ajVX4crbdSxSJSKqAiQlUqagggCeGWkJBJQmYySea+Z/be63P+WGtm9uzsnZlJZvaey/v5YD3WWt/vd631WTub+ex1/Zq7IyIiUkys0gGIiMjspSQhIiIlKUmIiEhJShIiIlKSkoSIiJSkJCEiIiUpSciCYmZ/Y2b/XOk4jmWiGM1sl5m9tpwxycKlJCHzjpldaWaPm9mAmb1gZl8xs0WVjktkLlKSkHnFzD4C3AD8P0ATsAlYA9xrZlVliiFRju2IlIOShMwbZtYIfAr4gLv/yN0z7r4LeDvQBvxx1DRlZreaWa+ZbTGzs/PW8TEz2xvVPWVmF0flMTP7uJntMLMuM/uemS2O6trMzM3sKjN7HviZmd1jZtcVxPeYmV0eTd9oZnvMrMfMHjazCwp2p2SMBes8VlwpM/vnqPyImf3WzJad2KcsC42ShMwnrwJSwO35he7eB9wNvC4qegvwr8Bi4F+AO8wsaWanAdcBL3f3BuAPgF3RMh8A3gr8PnAycBj4x4Lt/z7w4mi57wDvGqkwsw2ERzR3RUW/Bc7Ji+FfzSyVt66iMRbZ52PF9T7Co6lVQAtwDTBYZB0iJSlJyHzSChx092yRuv1RPcDD7n6bu2eALxAmlk1ADqgGNphZ0t13ufuOaJlrgP/h7u3uPgT8DXBFwamlv3H3fncfBH4AnGNma6K69wC3R8vi7v/s7l3unnX3/y/a7ml56yoVY6FjxZUhTA7r3T3n7g+7e8/EH6PIGCUJmU8OAq0lrgksj+oB9owUunsAtAMnu/uzwIcI/9B2mNl3zezkqOka4AfRaZsjwHbCpJJ/+iZ/vb2ERw3vjIreBdwyUm9mHzWz7WbWHa2vibEkVjLGIvt1rLi+DfwY+K6Z7TOzvytxNCJSkpKEzCe/AoaAy/MLzaweeANwX1S0Kq8uBqwE9gG4+7+4+6sJ//g64UVwCP9ov8HdF+UNKXffm7epwlcqfwd4l5mdR3gkcH+0zQuA/054raTZ3RcB3YDlLVsyxgIl44quyXzK3TcQnop7I/De4h+dSHFKEjJvuHs34YXrL5rZJdF1hjbge4S/xL8dNX2ZmV0eHXF8iDCxPGRmp5nZRWZWDaQJz98H0TI3AZ8ZOX1kZkvM7C0ThHQ3YbL5W+DW6IgAoAHIAp1Awsw+CTQWLFs0xiLbKBmXmb3GzM4yszjQQ3j6KSiyDpGSlCRkXnH3vwP+CvhfhH8Yf034a/vikesBwL8B7yC8yPsnwOXRuf9q4HOEp6VeAJYC10fL3AjcCfzEzHoJ/2C/coJYhggvor+W8OLziB8DPwKeBnYTJqQ9BYuXirHQseI6Cbgt+hy2A//BWKIUmRRTp0MiIlKKjiRERKQkJQkRESlJSUJEREpSkhARkZLm/IvIWltbva2trdJhiIjMKQ8//PBBd18yUbs5nyTa2trYvHlzpcMQEZlTzGz3ZNrpdJOIiJSkJCEiIiUpSYiISElKEiIiUpKShIiIlKQkISIiJSlJiIhISXP+OYnpFATO1v/YS019kiWrG2haUoPFbOIFRUTmKSWJPHu2H+IXtz49Op9MxVmyqoElqxpYc2YLK05vJqakISILiJJEnt1bu0gkY7z1w+fSta+Pzud76Xy+l22/2MtjP9tDbWMVp25cxoteuYwlqxswU8IQkflNSSLi7ux+/CArTm9m2dpGlq1thPPDumwmx+7Hu3j6Nwd4/OftPPazPSxaVsv6jUs55aVLaVlRp4QhIvOSkkSku2OQnoNpznnt6qPqEsk4p5y7lFPOXUq6P8OOLR08/ZsDbL57F5vv2kXjkhpOOWcJ6166hGVtjbqOISLzhpJEZPfWLgDWnNlyzHapuiRnXLCCMy5YwUDPMM891snORzt57Gd7eOTe56lprGLVi5tZvaGFVS9eTG1jVTnCFxGZEUoSkd1bD9J8Ui2NrTWTXqa2sWo0YQwNZNj1eBe7t3bx/LZDPP3rAwC0rqpn9YbFLF+/iOXrF1Fdo49cROYO/cUChtNZ9j5zhJe8ZtVxr6O6NslprzyJ0155Eh44nXt6eX7bIZ5/ootH793Dlh8/DwatK+s5OUoYS9saaFic0vUMEZm1lCSA9icPE2R9wlNNk2UxY+maRpauaWTjpW1khnMceK6Hfc8cYf+zR3jiwX387v52AGoakixta4zah7fb1jZVKXGIyKygJAHs3tZFMhVn+SlNM7L+ZFWclac1s/K0ZgByuYCDe/ro2NVDx+4eOnb3htdEPGyfqkvSsrKO1hUNtKyso3l5Hc0n1elUlYiU3YL/q+PuPL+1i1UvXkw8UZ63lMTjMZa1NbKsrXG0bDid5eCeXg6299O1t4+uvX1s++VessPBaJvapiqaT6qleVkdTUtraFpSQ+OSGppaa0hUxcsSu4gsLGVLEmaWAn4OVEfbvc3d/7qgzZXA54G9UdGX3P2rMxnXoX399B0e4uVvnJ5TTcerKpXg5FObOfnU5tGyIHB6Ogc5/EI/h18Y4PCBAQ7v7+fp3x5geDA7bvm6pioaW2uoX5yioSVFw+JwqF9cTf2iaqpqEjqFJSJTVs4jiSHgInfvM7Mk8Eszu8fdHypod6u7X1euoEZvfT2jskmimFjMWLSslkXLall79li5u5Puz9DdOUhP5+DouKcrzQs7u9nxcAdB4OPWlaiKUddUTd2icKhtrBo31DRWUVNfRU19knhS730UkVDZkoS7O9AXzSajwUsvUR67t3bRuqqeukXVlQ5l0sws+oNexUlrj76OEgTOQPcQvV1p+g4P0XdkiP7uIfqPhMOB57oZ6M2QHcoVXX8yFaemPkmqvopUXZJUXYLquiSp2rFxVW2S6poE1bUJqmrCIVkd17utROaZsl6TMLM48DCwHvhHd/91kWZ/aGa/BzwN/KW77ymynquBqwFWrz76CenJGhrIsH9HN+e+/vjXMRvFYkZ9c4r65tQx2w2nswz2DjPQk2GgZ4h0X4bB3gyDfcPhdF+GdN8wRw70MzSQZWgge8z1ASSr41Sl4iRTiWgcJ1kdJpBwOk6yKhwnqmIkRqaT4fTouCpGPBkjkYxH4xixuOmUmUiZlTVJuHsOOMfMFgE/MLMz3X1rXpN/B77j7kNm9t+AbwIXFVnPzcDNABs3bjzuo5E92w/jwfTd+jrXVKUSVKUSNC2ZXPsgcIYGMgwPhgljaDDLcJQ8htNZhgezDKdzDKezZEbGQzn6DqfD+aEcmaEc2eHc8R1DGiQSYfKIJWKj0/GEEU/EiMVjxJNGPB7Wx+M2No4bsXgsGo9NxxOGxaL5mI3W28h0VGexMPlazI4ah0NUb8XmGSsfNx+NLRxjRG2KlCs5SoVU5O4mdz9iZvcDlwBb88q78pp9Ffi7mYxj99aDVNcmwpf5yYRisbHTXCfC3cllAjLDUdIYCshmcmSHx49zmYDscEAuG5DNBOF8JpzPZcP5kXGQ89HyzFCWXDYsC3IBQdbJ5UbmnWCkLqj42c7JC3PF+KRhYGHhuMQy1r6gTd56OFZbCtrnJaj8+vx5G2mcP8rLa4VJrmjOK1hnieqxDYyLp/gypbZfet35hUVbTm7ZKZj08kUarn/ZUjacf/KJBTCBct7dtATIRAmiBngdcENBm+Xuvj+afTOwfabi8cDZvbWL1We0EIvrQm05mVl0SilOTX3l4nAPE4VHCWM0ieQ8rMuNJZMg53jgeBAeUXngo+PRaadgPmwfjvPqR8fhNM74tqPl4TgIfLRNOM6bJm868PAAbWRZ8tZdrDz8EPKmwRnbRvQhjR30jZb72HzeNsZ/tkfP5K/nqDZ56ywoGb+OInm9WFnJdZZoW1heuD8loprSEXHxVU5uBaXCyWWC4hXTqJxHEsuBb0bXJWLA99z9h2b2t8Bmd78T+KCZvRnIAoeAK2cqmM49vQz2ZhbsqSYJk1U8bqBHTERKKufdTb8DXlqk/JN509cD15cjnoGeYRpbU6zesLgcmxMRmZMW7BPXbWe10nZWa6XDEBGZ1XQyXkRESlKSEBGRkpQkRESkJCUJEREpSUlCRERKUpIQEZGSlCRERKQkJQkRESlJSUJEREpSkhARkZKUJEREpCQlCRERKUlJQkRESlKSEBGRkpQkRESkJCUJEREpqWxJwsxSZvYbM3vMzLaZ2aeKtKk2s1vN7Fkz+7WZtZUrPhEROVo5jySGgIvc/WzgHOASM9tU0OYq4LC7rwf+HrihjPGJiEiBsiUJD/VFs8lo8IJmbwG+GU3fBlxsZlamEEVEpEBZr0mYWdzMHgU6gHvd/dcFTVYAewDcPQt0Ay1F1nO1mW02s82dnZ0zHbaIyIJV1iTh7jl3PwdYCbzCzM48zvXc7O4b3X3jkiVLpjdIEREZVZG7m9z9CHA/cElB1V5gFYCZJYAmoKu80YmIyIhy3t20xMwWRdM1wOuAJwua3Qm8L5q+AviZuxdetxARkTJJlHFby4FvmlmcMDl9z91/aGZ/C2x29zuBrwHfNrNngUPAO8sYn4iIFChbknD33wEvLVL+ybzpNPBH5YpJRESOTU9ci4hISUoSIiJSUjmvSZRNJpOhvb2ddDpd6VCmLJVKsXLlSpLJZKVDERGZn0mivb2dhoYG2tramEsPbLs7XV1dtLe3s3bt2kqHIyIyP083pdNpWlpa5lSCADAzWlpa5uQRkIjMT/MySQBzLkGMmKtxi8j8NG+ThIiInDglCRERKUlJYoZs3bqVV73qVaPzW7Zs4eKLL65gRCIiUzcv727K96l/38YT+3qmdZ0bTm7kr990xrHbbNjAzp07yeVyxONxPvzhD/OFL3xhWuMQEZlp8z5JVEosFuOMM85g27ZtPPPMM6xZs4Zzzz2X/v5+/vzP/5yqqiouvPBC3vOe91Q6VBGRkuZ9kpjoF/9M2rRpEw8++CBf/vKX+dGPfgTA7bffzhVXXMGb3vQm3vGOdyhJiMispmsSM2jTpk184hOf4G1vexsrVqwAwgf9Vq1aBUA8Hq9keCIiE1KSmEGnn3461dXVfOxjHxstW7lyJe3t7QAEQVCp0EREJmXen26qpBtvvJHPfvaz1NXVjZZdfvnlXHfdddx111286U1vqmB0IiITU5KYATt27OCyyy7j/PPP533ve9+4urq6Or7+9a9XKDIRkalRkpgBp5xyCk8+Wdgzq4jI3KNrEiIiUlLZkoSZrTKz+83sCTPbZmZ/UaTNhWbWbWaPRsMni61LRETKo5ynm7LAR9x9i5k1AA+b2b3u/kRBu1+4+xvLGJeIiJRQtiMJd9/v7lui6V5gO7CiXNsXEZGpq8g1CTNrA14K/LpI9Xlm9piZ3WNmRR+XNrOrzWyzmW3u7OycwUhFRBa2sicJM6sHvg98yN0L37y3BVjj7mcDXwTuKLYOd7/Z3Te6+8YlS5bMbMAiIgtYWZOEmSUJE8Qt7n57Yb2797h7XzR9N5A0s9ZyxigiImPKeXeTAV8Dtrt70Xdmm9lJUTvM7BVRfF3lilFERMYr55HE+cCfABfl3eJ6qZldY2bXRG2uALaa2WPA/wbe6e5exhinjTodEpH5oGy3wLr7LwGboM2XgC9N64bv+Ti88Pi0rpKTzoI3fO6YTdTpkIjMB3otxwwp1enQzp07+cxnPkN3dze33XZbpcMUETmm+Z8kJvjFP5OKdTq0bt06vva1r3HFFVdULC4Rkcma/0migjZt2sSVV17JtddeO9rpkIjIXKIX/M2gYp0OiYjMJUoSM6hYp0NdXV1cc801PPLII3z2s5+tYHQiIhPT6aYZcKxOh1paWrjpppsqFJmIyNRMOUmYWR2QdvfcDMQzL6jTIRGZLyY83WRmMTN7t5ndZWYdwJPA/qhfiM+b2fqZD1NERCphMtck7gdOAa4HTnL3Ve6+FHg18BBwg5n98QzGKCIiFTKZ002vdfdMYaG7HyJ8Wd/3oxf3iYjIPDOZJPGB6J17Ixw4CPzS3Z8DKJZERERk7pvM6aaGgqER2AjcY2bvnMHYRESkwiY8knD3TxUrN7PFwE+B7053UCIiMjsc98N00TWJY77VVURE5rbjThJm9hrg8DTGIiIis8xknpN43Mx+VzC0AzcA1858iHOTOh0SkflgMnc3vbFg3oEud++fgXim3Q2/uYEnD03v08+nLz6dj73i2C/tU6dDIjIfTObC9e5i5Wb2auBd7q6jiSJKdTp0xx13cNddd9HT08NVV13F61//+kqHKiJS0pTe3WRmLwXeDfwR8Bxw+xSWXQV8C1hGeDRys7vfWNDGgBuBS4EB4Ep33zKVGAtN9It/JhXrdOitb30rb33rWzl8+DAf/ehHlSREZFabMEmY2YuAd0XDQeBWwNz9NVPcVhb4iLtvMbMG4GEzu9fdn8hr8wbg1Gh4JfCVaDwnHavToU9/+tNce60OwkRkdpvM3U1PAhcBb3T3V7v7F4EpvwHW3fePHBW4ey+wHSjsru0twLc89BCwyMyWT3Vbs0WxTofcnY997GO84Q1v4Nxzz61gdCIiE5vM6abLgXcC95vZjwgfnjuh5yPMrA14KfDrgqoVwJ68+faobH/B8lcDVwOsXr36REKZUcU6HfriF7/IT3/6U7q7u3n22We55pprKhihiMixTebC9R3AHVE/Em8BPgQsNbOvAD9w959MZYNmVk/4YsAPuXvPccSMu98M3AywceNGP551zKRjdTr0wQ9+kA9+8IMVikxEZGomfeE6uuX1X4B/MbNmwovXHwMmnSSit8V+H7jF3Ytd9N4LrMqbXxmVzSnqdEhE5ovJPEx31Kkldz/s7je7+8Wl2pRYz9eA7e5e6oGBO4H3WmgT0O3u+0u0FRGRGTaZI4n7zez7wL+5+/MjhWZWRdjx0PsIOyb6xgTrOR/4E+BxM3s0KvsrYDWAu98E3E14++uzhLfA/umk90RERKbdZJLEJcCfAd8xs7XAESAFxAlPNf2Duz8y0Urc/ZdMcMHb3R296kNEZNaYzIXrNPBl4MvRNYVWYNDdj8x0cCIiUllTeuI66oFO1whERBaI435VuIiIzH9KEiIiUtKUk4SZ1ZlZfCaCERGR2WUyz0nEzOzdZnaXmXUQvstpv5k9YWafN7P1Mx/m3KNOh0RkPpjUcxLAT4Hrga3uHgCY2WLgNcANZvYDd//nmQvz+L3wP/8nQ9un9+nn6hefzkl/9VfHbKNOh0RkPphMknitu2fMrG0kQQC4+yHCV2x8P7o1VvKU6nRo+/bt3HjjjRw8eJCLL76Y97///ZUOVUSkpMk8J5GJJm8Hxr3b2sw2uftDeW1mnYl+8c+kYp0OvfjFL+amm24iCALe+973KkmIyKw2mWsSbzezzwENZvZiM8tf5uaZC23u27RpE5/4xCd429veNq7ToTvvvJPLLruMSy+9tILRiYhMbDJ3Nz0IPAE0A18AnjWzLWb2Q2BwJoOb64p1OgTw5je/mXvuuYdbbrmlQpGJiEzOZE437QW+ZWY73P1BADNrAdoI73SSEop1OvTAAw9w++23MzQ0pCMJEZn1JtPHtUXdiT44UubuXUBXYZsZinHOOVanQxdeeCEXXnhhZQITEZmicr4qfMFQp0MiMl8c76vCawivZ0z6VeEiIjL36FXhIiJS0pRfFW5m7wcSUe9yj7r70zMTmoiIVNqUX/Dn7p8EbgS6gbeZ2f+ZzHJm9k9m1mFmW0vUX2hm3Wb2aDR8cqqxiYjI9Jr0kYSZ3Qt81N0fc/cDwI+jYbK+AXwJ+NYx2vzC3d84hXWKiMgMmsqRxMeAfzCzr5vZ8qluyN1/Dhya6nIiIlI5k04S7r7F3V8D/BD4kZn9tZnVTHM855nZY2Z2j5mdMc3rFhGRKZrSNQkzM+Ap4CvAB4BnzOxPpimWLcAadz8b+CJwxzHiuNrMNpvZ5s7OzmnavIiIFJp0kjCzB4G9wN8DK4ArgQuBV5jZCb/oz9173L0vmr4bSJpZa4m2N7v7RnffuGTJkhPd9IxQp0MiMh9M5RbYq4Enirx+4wNmtv1EAzGzk4AD7u5m9grCBNY1wWIT+sX3nubgnr4TXc04ravqueDtLzpmG3U6JCLzwVSuSWw7xvuZLptoeTP7DvAr4DQzazezq8zsGjO7JmpyBbDVzB4D/jfwzrn8Pqj8Toe+//3vj3Y6BNDf38/GjRv54Q9/WOEoRUSObUoP05Xi7jsn0eZdE9R/ifAW2Wk10S/+mVSs0yGAG264gbe//e0Vi0tEZLKmJUlIcZs2beLKK6/k2muvHe106N5772XDhg2k0+kKRyciMjEliRlUrNOhBx54gP7+fp544glqamq49NJLicWm/OC7iEhZKEnMoGKdDn3mM58B4Bvf+Aatra1KECIyq+kv1AzYsWMHp59+OoODg0d1OjTiyiuv5I1v1BtIRGR205HEDFCnQyIyX+hIQkRESlKSEBGRkpQkRESkJCUJEREpSUlCRERKUpIQEZGSlCRERKQkPSeRx7NZhp59llhNDfHFi4nV1xP2syQisjDpSCJPkE7j2Sy5/n6Gd+9m6JlnyHYexLPZKa9LnQ6JyHww748k7v/GzXTsnvBN5kB4JOFDQ8RqavDA8UwGghxgWDwO8TgWj7N07Sm85sqrj7kudTokIvOBjiTyBVEfRxbDEnFiNSliNTVYIoEHAT48RDA4QPbIETL795Pr6Sl5lFGq06EHHniACy64gGuuuYYHHnigfPsmInIc5v2RxES/+PNl9u8nd/gwqQ0bjqpzd3x4mKC3l1xfH9lDh6Ar7F3VqqqI1dQSq60Jk0oqhcViRTsdMjPq6+tJp9OsXLlyenZSRGSGzPskMRWezUKi+EdiZlh1NbHqahKtrXgQEAwO4gODBIMDBP195LqPjLQmVl3Fy9av579+5CO8/+qrOXnZMgAuuOACfv/3f58DBw7w4Q9/mFtuuaVMeyciMnVlSxJm9k/AG4EOdz+zSL0BNwKXAgPAle6+pVzxAXgmgyWSk2prsRjxujqI+opwD69h+OAgQTpNkE7zouXLqUok+NDll5N+8kksHseqU8RS1TSYke7vJxgexpJJ3UUlIrNSOY8kvkHYh/W3StS/ATg1Gl4JfCUal41ns8Rqao5rWTPDqqqgqop4UxMAN33+83z2s5+lecMGPJ0mGBriB/92J/c+cD9Henq4+h3vYOjpp8FixKqrsKpwCPr76XvwQapWriS5fHm4XhGRCihbknD3n5tZ2zGavAX4lrs78JCZLTKz5e6+v0zx4Zks1jC5I4lj2bFjB5dddhnnn38+V151VVhYXw/AO/78/bz9/deM3knlw8Oj4yCdxnt7yXV3s+fa68LlYjESS5eSPOkkkicvJ7F8OcnlJ5NYtpTk0qUkli4l0dqKJU88bhGRQrPpmsQKYE/efHtUdlSSMLOrgasBVq9ePT1bDwLwAEue+EcyUadDZhb+US/yh93dSbiz5tvfYnhPO5n2djL795PZv5/BbdvI/vQ+fHi4cIXEFy8msWQJiZYWEq2txFtbSLS0kmhtId7cTLx5MYnmRcSbm4nV1p7wPorIwjCbksSkufvNwM0AGzdu9GlZZyYTTpS4cF0uZuEzGbUvfzm1L3/5UfXuTu7QIbIHDpDp6CB7oINsRwfZjgNkOw+S7epi6Lmd5A52HZ1MRrZRXU180SLiTU3hsKiJWGMj8cYm4o0NxBoaw3F9A/GGemL1Y0O8rk6nv0QWkNmUJPYCq/LmV0ZlZTHyvMNsP21jZuHRQktL0Vt1R7g7QV8fua4usocPkzt8OEwuhw+TO3yEXPcRct3dBEe6Gd61m1x3N7neXnxwcOIYkklitbXE6uqI1dUSqw3HlgpvAY7V1mA1NeFtwanqqDyFpVLEUqnRu8RsZDqViq7HVGNVybCuqgqrcMIWkdmVJO4ErjOz7xJesO4u1/UIyEsS8+QPk5kRb2gg3tBAVVvbpJfzTIZcXx9BTw+5nh6C/v4w2fT2EfT1EfT1EgwMEPQPhHUD0XhwkODQYYLBgfC24IEBgnQacrnj34lYbPRiviWT0XQSSyTD+ZEhkQiHZBKSibA+KiMRj6aT4d1lyQTEE+ET9Ik4Fk9g8dhYWTyGxROjY4vHIBYfHYflcYiO+IjFsZiFdbGozGJR+1jBtGGxgmmzcD+jMWZgMTDG1UPefNTGjLz5aD1jX4CjBt1BJ8ejnLfAfge4EGg1s3bgr4EkgLvfBNxNePvrs4S3wP7piWzP3af2P0V0uqnSSSK8bl85lkySaG6G5uZpWZ9nMuEtwYOD+NDQ6NiHhgjSQ/hQeLuwD2fGLuQPDxEMDYW3FGcyYd3wcDhks2PlmeGwLpvB+6P22WzekIFsblwZuRyey8FxvI9r3iiSQIAwweTNF60v1qagbFy7YuOSZSOjIu1KLVOs3bjyYkWTXP5EykqZZNOiMRax6O1vp+WqP5v89o9DOe9uetcE9Q5cOx3bSqVSdHV10dLSMulE4dksFot+JVaIu9PV1UUqlapYDNPNkkniySTxhoZKhzKOu0MQjCWOIIBsFs/l8GwOghyeCyCXDccj80HUNgii5Xx8WRCE7TwoUuZ55dFy7uCM3jjhQRDOe9h+tK074GP1QQCE5ePWEe5dXnlU53nrKCyH0bqReS9an9dupE20ueLtOLrtuDYUKRtXOP7f66j6o5oVlBdrO8myIist+gNuKr/pJvsDcAo/FBPRQ7ozaX6cWymwcuVK2tvb6ezsnPQy2UOH8GyW5PbtMxjZxFKplF7XUQZmNvrCRhEpbV4miWQyydq1a6e0zK53vwdLJlnzzW/MTFAiInOQ3gIbyXZ2kliypNJhiIjMKkoShOcasx0dJJYurXQoIiKzipIEEPT04ENDJJbqSEJEJJ+SBJDt6AAgqSMJEZFxlCQIr0cAuiYdlBuBAAAT8klEQVQhIlJASQLIREcSiaVLoeNJ6D9Y4YhERGaHeXkL7FRlO6IjidwL8OXXh4WNK2H52WND2/lQPbseCBMRmWkLNkk81/0c9z1/H+8+/d1kOzqINTQQe/5+wODi/xc6tsO+R+GpuwGHRA2cfimc9XZYfzHEZ/eLAEVEpsOCTRI7u3dy45Yb2bR8E4tGnpF45iewciNc8JGxhkO9sO8R2HYHbPsBbP0+1CyGM94GZ/4hrN4UvtxNRGQeWrBJYm1T+ET2zu6dvKSjg0TLItj7ILzmr8Y3rG6Atb8XDpd8DnbcB7/7Hjx6C2z+GtQtgdMvgxe/Cdp+DxLqa0FE5o8FmyRWNawiYQl2HtnJho4Oata1AA6nvq70QokqOO0N4TDUC8/cC9v/HR6/DR7+BlQ3wamvhVMuDk9JNZxUrt0REZkRCzZJJGNJVjeuZueRHWQ7Okiuc6hbCiedPbkVVDfAmZeHQyYNOx8IE8YzPwlPSQEsPQPWXwSnXAQrXwHV9TO2PyIiM2HBJgmAdU3r2LvvKTyTIZHeBaf+wWgHL1OSTMFpl4RDEMCBreFpqWfvg4dugv/8IlgcTj4HVp8Ha84Pr2XULp72fRIRmU4LOkmsbVrLMw/fB0Ai2Qenvo4gCIgdT6IYEYvB8peEw6v/Eob6YM9DsPtXsPs/4Tf/B371pbBt81pY8TJYcS6cfG64TFXdNOyZiMj0WNBJYt2idTT1ht1rJmphZ/w0bn3PFWSStXjrKlrbTuFFZ57BKzaeRVPjcZ4qqq6H9a8NBwhPTe17BJ7/FezbAs8/BFtvC+ssBi3rYdkZ0XBWOG5aObXer0REpsnCThJN62juC6cTp7yE/3z4KaqCYdL1K0l07CK993F+9+AdPPr/G4NVjeQaWqhevJSmZcs5aeVKVq1ZQduqFbS2NE3+6COZgjXnhcOI3gNhwtj3CBzYBnu3hLfbjqiqD5PHktOg9VRofREsPgUWr9WRh4jMqLImCTO7BLgRiANfdffPFdRfCXwe2BsVfcndvzpT8bQ1to0libP/gPafP41ZnOv//n+Rqq7i+fYDPLzlMZ7b/hR07IMjB2HHI6SfeYhdwC7gF0DGkgxVNxDUNpKoX0R1YzN1zc00t7TQsqSVZSct4eRlS0onk4ZlY3dNjUj3hA/0HXgcDj4DnU/Brgfhd7eOX7ZuaZgsmtdC8xpoWgWLVoXjppWQqJ6Rz05EFoayJQkziwP/CLwOaAd+a2Z3uvsTBU1vdffryhFTbbKWlQNJhqrTxM64lMFbvwT1y0hVh886rF65jNUrXw9vfv245fYf6OKpZ3ayr30/hzs6yBzqgiNd0HcE9u+A5/tJE7Af2A9sjZbLEWM4UUO2qhZP1RFL1ZOorSNV30CqoZH6xkYaFzXS2NhI86ImFi9eTeuGl1BfVzO28aE+6HoGDu2EQ8/B4efg0C7Y9YsogRT0j1u3FBqXQ8PJ4S25jSdDw3KoXxoOdUvDZz30fIeIFFHOI4lXAM+6+04AM/su8BagMEmU1ck9Ad31Rm7xi6jp3k+w/mUTLrN8WQvLl7WUrA+CgAOdh9m3/wAv7O+k6+BBeo8cYaCnG3p7oL8XBnuhfy92YBDPpUkDaaDYqwVzxMjEq8kmqvFkCk9WY1UpYlUpEqnlJKrXUVVTQ3VLFQ2JYRpiAzTSR4P3UJ87TN3QIVK97aTSD1M9fJCEBcQKL3HUNENtK9S2QF00rm0J78CqaR4/pBZBqgmSNbpWIjLPlTNJrAD25M23A68s0u4Pzez3gKeBv3T3PYUNzOxq4GqA1atXH39E2WEWdw+zryHGo9ufIekZmk859fjXF4nFYmOJ5JyJ22eyWQ52ddPR2cXhI910H+mhr6eXvt5e0n195Ab6YXAA0oMwNAjDaeg9BNkhPDcMuWFyBAwAA8CBoltZFA2nARCYgcWwmBGPOQlzErEcVZajyg5Qbe1U2xAJC4hbQNw8GgckzIlZgMUM4lV4oio8rZWoDq+5JGuwZAqqarCqGmJVtVhVLbHqOmLVtcRT9cSq64hXh2XJ2gZi1TUkUw0kklUkEnGqknHi8ThViQTxhF57IlIps+3C9b8D33H3ITP7b8A3gYsKG7n7zcDNABs3bvTC+kl7/lfU9zldrdC15SEAzjz7jONe3fFKJhITHp1MZDA9RE9PHz19A/T19dPb28/AwCAD/QOk02mG0mmG02kyQ0MMp9P48DC5zDBBZpggmyHIDOPZLJ7LQC4DuSyWzRAPssSDDLEgS8xzmAeYO6WPH3JAXzRMH8PBCLc7svGRoxgzRio9mvbRsti4MicGFtVbDLcYPtIur71bLG/ZkWXC9iPrxWzctsGiWYumj47PsNG4zQwftwzRMjZ2gDZu/dHy+fs+ukxYZlBQbwVt8j/TvOXGFizy4R9dZiW2X0zR0gnWeUxTOHotus5JLn8ix8iT3pcT9KIzN/D6i8+f0W2UM0nsBVblza9k7AI1AO7elTf7VeDvZjIgf/rHJAeMw/Uw8OxW6i3BOWeeNpObnDE1qWpqUtUsW3r8iWYqMtksQ0PDDAwOk04PkclmGB7OMjQ8TGY4SyYzzHAmQ24oTS7dRzDUjw/1EQwNQCaNZ9KQTePDaTw7BLkMlhuOElQ4WJDDgiyey2GehSCHeQ4PAswD8AALAiAAd8wDHMPdCAD38H/UAMMdRlKbuxF4VBa18ajcyW8XTnveumB82bj2edsZKxu/jSjdjcYxVn50/cjESHlB8VEzE/1a8tEGJ/4HzEtMS3ntPPgMzKMk8VvgVDNbS5gc3gm8O7+BmS139/3R7JuB7TMZUO7xn2CBcbjeSHbuY6BhGVVVegX4ZCQTCZKJBPV1tZUOZYx7lGCGoyEDQWZserQsm1cXzY+W5cLyIDdWnl/muWg+qh+Z92B8/ejYx7cZHXLh0/n4+PIgl1fmpct8ZNlowPPaecE4KFJGibYlxiOfL04Q5KW1KPO455WNth3fZqRuLFnlpZfAjyobW2ex9Y5Lp8W/DtOQDI9HOZNmcN4kzmefoLIlCXfPmtl1wI8Jb4H9J3ffZmZ/C2x29zuBD5rZm4EscAi4csYCOryL7N7ngKUML6pn8Y4+fP2ZM7Y5KQOz8C4t3ak1o2Z1d5b5icWL/bkuUlaWdqVMsm2pdcZm/k94Wa9JuPvdwN0FZZ/Mm74euL4swez+FdnB8IJoqv4kkkGOlvUvKsumRWSG5F8L0J1302JW/yiYUee8i+yrPw2A5RYBcMZZ5b9oLSIymy3cJAFk+wMAvK+KTDxg1fryXPQVEZkrFnaS6Ogg3tREomuIQ43DtA8c9UiGiMiCtqCTRKajg9iSVup7uulqGmZn985KhyQiMqss6CSR7ezkcNMikp7jSFPAc93PVTokEZFZZWEniY5O9iXC5yKqTl6qIwkRkQILNkl4EJDt7OSAB2Qsyeq2U5UkREQKLNgkkTt8GLJZerJDDDYu45TFp/BC/wsMZAYqHZqIyKyxYJNEtrMzfL9PboDU8jWsbVoLwHM9ui4hIjJi4SaJjg76U1XECFix/kWsa1oHwM4jOuUkIjJiwSYJSybpbAuPHs46+0xWN6wmbnHd4SQikmfBJom6887jd2e9nIwlecmG9STjSVY1rNLFaxGRPLOt06GySr/wPDQtH+35bF3TOiUJEZE8C/ZIYng4Q23vAWqWrxktW7doHXt69pAJMhWMTERk9liwSeLRrU+R8CwrTx17Pfi6pnVkPcueHr3DSUQEFvDppiceDzu9y+/T+pRFpwDwpz/+U1550is57+Tz2LR8E8vrl1ckRhGRSjOfUi9Ks8/GjRt98+bNU14uCAK2P/0cp69vG70m4e7c89w9/GLvL3ho/0McHDwIwOqG1axqXEVDsoGGqrGhLllHTaJmdKhN1FKTqKE6Xk0qkSKVSIXT8RSJWKJsnaOLiEzEzB52940TtluoSWIi7s6OIzt4aP9D/OaF33Bw8CC9w730DPfQO9w75esWMYtRFauiKl5Fdbyaqng4nYwlR8uT8STJ2NiQiCVGx4XTiViCuMXDaUsQj8VH52MWGz8d1Y2Uj0yPzJtZyTIzI0aMWCwWji2GmWHYaHvDwnYWG93XkfqR+ZGy0fpoHYYR/je2TiVTkZk32SRR1tNNZnYJcCNhH9dfdffPFdRXA98CXgZ0Ae9w913ljDEvFtY3r2d983r+eMMfH1WfzqYZyA4wkBlgMDvIYHaQgewAg5lBhnJDpHNphrLhOJ1NMxwMM5wbZig3NG6cCTIMB8NkchmGskP0B/1kgsy4IRtkjx48W4FPpbxGkk9hMjmqLi+p5M+PLhfOFK0fNy6SnIq1HzdtHF12jHWVKpsoMRZddpLbKLnOE1z+RJTrh0C59qcciu3L2059G+87430zut2yJQkziwP/CLwOaAd+a2Z3uvsTec2uAg67+3ozeydwA/COcsU4FSOnkxanFldk++5OznPhEOTIBBlyniPwgGyQDaeDgKxnR8sCD8Jpz44uP1KW89xoWX6dM1Y20tYJp919XD1QtH5kPFJXWD46xsEhYPyywNHTUVuPOpIft45ofvSzKmiTXz8yX/jZjttOwfoK11tqe8XWWWr5Kbeb5LKlFFu+WNEJrW8a2p6IuX6WJF+pz6ylZuZ70yznkcQrgGfdfSeAmX0XeAuQnyTeAvxNNH0b8CUzM59P/9rTxMxIWIIEifC4TERkBpTzFtgVQP69pe1RWdE27p4FuoGjUqWZXW1mm81sc2dn5wyFKyIic/I5CXe/2d03uvvGJUuWVDocEZF5q5xJYi+wKm9+ZVRWtI2ZJYAmwgvYIiJSAeVMEr8FTjWztWZWBbwTuLOgzZ3AyKX6K4Cf6XqEiEjllO3Ctbtnzew64MeEl1r/yd23mdnfApvd/U7ga8C3zexZ4BBhIhERkQop63MS7n43cHdB2SfzptPAH5UzJhERKW1OXrgWEZHyUJIQEZGS5vy7m8ysE9h9nIu3AgenMZxK0r7MTvNlX+bLfoD2ZcQad5/wGYI5nyROhJltnswLruYC7cvsNF/2Zb7sB2hfpkqnm0REpCQlCRERKWmhJ4mbKx3ANNK+zE7zZV/my36A9mVKFvQ1CRERObaFfiQhIiLHoCQhIiIlLdgkYWaXmNlTZvasmX280vFMhZn9k5l1mNnWvLLFZnavmT0TjZsrGeNkmNkqM7vfzJ4ws21m9hdR+Vzcl5SZ/cbMHov25VNR+Voz+3X0Pbs1ernlnGBmcTN7xMx+GM3PyX0xs11m9riZPWpmm6OyufgdW2Rmt5nZk2a23czOK8d+LMgkkdeV6huADcC7zGxDZaOakm8AlxSUfRy4z91PBe6L5me7LPARd98AbAKujf4d5uK+DAEXufvZwDnAJWa2ibAL3r939/XAYcIueueKvwC2583P5X15jbufk/dMwVz8jt0I/MjdTwfOJvy3mfn9cPcFNwDnAT/Om78euL7ScU1xH9qArXnzTwHLo+nlwFOVjvE49unfCPtAn9P7AtQCW4BXEj4Nm4jKx33vZvNA2N/LfcBFwA8Bm8P7sgtoLSibU98xwr51niO62aic+7EgjySYXFeqc80yd98fTb8ALKtkMFNlZm3AS4FfM0f3JTo98yjQAdwL7ACOeNgVL8yt79k/AP8dCKL5FubuvjjwEzN72Myujsrm2ndsLdAJfD06BfhVM6ujDPuxUJPEvObhz4o5c2+zmdUD3wc+5O49+XVzaV/cPefu5xD+Cn8FcHqFQzouZvZGoMPdH650LNPk1e5+LuHp5WvN7PfyK+fIdywBnAt8xd1fCvRTcGpppvZjoSaJyXSlOtccMLPlANG4o8LxTIqZJQkTxC3ufntUPCf3ZYS7HwHuJzwlsyjqihfmzvfsfODNZrYL+C7hKacbmZv7grvvjcYdwA8IE/hc+461A+3u/uto/jbCpDHj+7FQk8RkulKda/K7fn0f4fn9Wc3MjLA3wu3u/oW8qrm4L0vMbFE0XUN4bWU7YbK4Imo2J/bF3a9395Xu3kb4/8bP3P09zMF9MbM6M2sYmQZeD2xljn3H3P0FYI+ZnRYVXQw8QTn2o9IXZCp4IehS4GnC88b/o9LxTDH27wD7gQzhL4yrCM8Z3wc8A/wUWFzpOCexH68mPDz+HfBoNFw6R/flJcAj0b5sBT4Zla8DfgM8C/wrUF3pWKe4XxcCP5yr+xLF/Fg0bBv5f32OfsfOATZH37E7gOZy7IdeyyEiIiUt1NNNIiIyCUoSIiJSkpKEiIiUpCQhIiIlKUmIiEhJShIiIlKSkoSIiJSkJCFynMxspZm9o0RdjZn9R/Ra+mL1VWb287zXXIjMSkoSIsfvYsL35xTzZ8Dt7p4rVunuw4RPyhZNMiKzhZKEyHEws1cDXwCuiHo8W1fQ5D1E79GJ3h90V9Rr3da8o487onYis5YOdUWOg7v/0sx+C3zU3bfm10UvjVzn7ruiokuAfe5+WVTfFJVvBV5eppBFjouOJESO32nAk0XKW4EjefOPA68zsxvM7AJ374aw/wlgeOQtpSKzkZKEyHEws1ag28d6ass3CKRGZtz9acJrF48DnzazT+a1rQbSMxmryInQ6SaR49MG7CtW4e6Ho65MU+6eNrOTgUPu/s9mdgT4LwBm1gIcdPdM2aIWmSIdSYgcnyeB1uhC9KuK1P+EsL8MgLOA30T9X/818Omo/DXAXTMeqcgJUH8SIjPAzM4F/tLd/+QYbW4HPh6djhKZlXQkITID3H0LcP+xHqYD7lCCkNlORxIiIlKSjiRERKQkJQkRESlJSUJEREpSkhARkZKUJEREpCQlCRERKen/AmMJMhVDUAbvAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import amici.plotting\n",
+    "amici.plotting.plotStateTrajectories(rdata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Computing likelihood\n",
+    "\n",
+    "Often model parameters need to be inferred from experimental data. This is commonly done by maximizing the likelihood of of observing the data given to current model parameters. AMICI will compute this likelihood if experimental data is provided to `amici.runAmiciSimulation` as optional third argument. Measurements along with their standard deviations are provided through an `amici.ExpData` instance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Log-likelihood -87.232753\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create model instance and set time points for simulation\n",
+    "model = model_module.getModel()\n",
+    "model.setTimepoints(np.linspace(0, 10, 11)) \n",
+    "\n",
+    "# Create solver instance, keep default options\n",
+    "solver = model.getSolver()\n",
+    "\n",
+    "# Run simulation without experimental data\n",
+    "rdata = amici.runAmiciSimulation(model, solver)\n",
+    "\n",
+    "# Create ExpData instance from simulation results\n",
+    "edata = amici.ExpData(rdata, 1.0, 0.0)\n",
+    "\n",
+    "# Re-run simulation, this time passing \"experimental data\"\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "\n",
+    "print('Log-likelihood %f' % rdata['llh'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sensitivity analysis\n",
+    "\n",
+    "AMICI can provide first- and second-order sensitivities using the forward- or adjoint-method. The respective options are set on the Model and Solver objects."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Forward sensitivity analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "          sx:  [[[ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.00747251e-01  1.19873139e-01 -9.44167984e-03]\n",
+      "  [-1.02561396e-01 -1.88820454e-01  1.01855972e-01]\n",
+      "  [ 4.66193077e-01 -2.86365372e-01  2.39662449e-02]\n",
+      "  [ 4.52560292e-02  1.14631370e-01 -3.34067917e-02]\n",
+      "  [ 4.00672911e-01  1.92564093e-01  4.98877760e-02]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.23007240e-01  1.53979022e-01 -1.26885280e-02]\n",
+      "  [-1.33426939e-01 -3.15955239e-01  9.49575028e-02]\n",
+      "  [ 5.03470377e-01 -3.52731535e-01  2.81567411e-02]\n",
+      "  [ 3.93630714e-02  1.10770683e-01 -1.05673871e-02]\n",
+      "  [ 5.09580305e-01  4.65255489e-01  9.24843702e-02]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.14278105e-01  1.63465065e-01 -1.03268419e-02]\n",
+      "  [-1.60981967e-01 -4.00490453e-01  7.54810651e-02]\n",
+      "  [ 4.87746420e-01 -3.76014315e-01  2.30919334e-02]\n",
+      "  [ 4.28733678e-02  1.15473583e-01 -6.63571668e-03]\n",
+      "  [ 6.05168647e-01  7.07226039e-01  1.23870915e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.05888039e-01  1.69308690e-01 -7.93085689e-03]\n",
+      "  [-1.84663808e-01 -4.65451966e-01  5.95026120e-02]\n",
+      "  [ 4.66407067e-01 -3.87612082e-01  1.76410135e-02]\n",
+      "  [ 4.52451106e-02  1.19865711e-01 -4.73313045e-03]\n",
+      "  [ 6.90798450e-01  9.20396632e-01  1.49475828e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.98803165e-01  1.73327269e-01 -6.03008194e-03]\n",
+      "  [-2.04303740e-01 -5.16111389e-01  4.68785776e-02]\n",
+      "  [ 4.47070329e-01 -3.94304031e-01  1.32107443e-02]\n",
+      "  [ 4.69732052e-02  1.22961726e-01 -3.35899414e-03]\n",
+      "  [ 7.68998997e-01  1.10844286e+00  1.70889328e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.92789113e-01  1.75978657e-01 -4.54517629e-03]\n",
+      "  [-2.20500139e-01 -5.55540706e-01  3.68776525e-02]\n",
+      "  [ 4.30424856e-01 -3.97907707e-01  9.75257132e-03]\n",
+      "  [ 4.82793653e-02  1.24952071e-01 -2.30991631e-03]\n",
+      "  [ 8.40805132e-01  1.27504628e+00  1.89020151e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.87672774e-01  1.77588334e-01 -3.38318223e-03]\n",
+      "  [-2.33807210e-01 -5.86081383e-01  2.89236334e-02]\n",
+      "  [ 4.16201398e-01 -3.99295277e-01  7.06598589e-03]\n",
+      "  [ 4.92546647e-02  1.26089711e-01 -1.50412008e-03]\n",
+      "  [ 9.06806543e-01  1.42334018e+00  2.04522708e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.83320440e-01  1.78410041e-01 -2.47240697e-03]\n",
+      "  [-2.44690164e-01 -6.09568484e-01  2.25774268e-02]\n",
+      "  [ 4.04061655e-01 -3.99063011e-01  4.97908397e-03]\n",
+      "  [ 4.99612483e-02  1.26581014e-01 -8.85891392e-04]\n",
+      "  [ 9.67473969e-01  1.55589415e+00  2.17895305e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.79620591e-01  1.78640115e-01 -1.75822432e-03]\n",
+      "  [-2.53540124e-01 -6.27448860e-01  1.75019835e-02]\n",
+      "  [ 3.93704969e-01 -3.97656642e-01  3.35895468e-03]\n",
+      "  [ 5.04492283e-02  1.26586733e-01 -4.13401193e-04]\n",
+      "  [ 1.02322336e+00  1.67481439e+00  2.29524046e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.76478441e-01  1.78430281e-01 -1.19867655e-03]\n",
+      "  [-2.60686972e-01 -6.40868688e-01  1.34365064e-02]\n",
+      "  [ 3.84873835e-01 -3.95414932e-01  2.10369506e-03]\n",
+      "  [ 5.07601806e-02  1.26231632e-01 -5.46464877e-05]\n",
+      "  [ 1.07443160e+00  1.78183962e+00  2.39710937e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]]]\n",
+      "         sx0:  [[0. 0. 0.]\n",
+      " [0. 0. 0.]\n",
+      " [0. 0. 0.]\n",
+      " [0. 0. 0.]\n",
+      " [0. 0. 0.]\n",
+      " [0. 0. 0.]\n",
+      " [0. 0. 0.]\n",
+      " [0. 0. 0.]]\n",
+      "       sx_ss:  [[nan nan nan]\n",
+      " [nan nan nan]\n",
+      " [nan nan nan]\n",
+      " [nan nan nan]\n",
+      " [nan nan nan]\n",
+      " [nan nan nan]\n",
+      " [nan nan nan]\n",
+      " [nan nan nan]]\n",
+      "      sigmay:  [[1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]\n",
+      " [1.  1.  1.  1.  1.  0.2]]\n",
+      "          sy:  [[[ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  1.00000000e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.00747251e-01  1.19873139e-01 -9.44167984e-03 -4.01494501e-01\n",
+      "    1.19873139e-01 -2.00747251e-01]\n",
+      "  [-1.02561396e-01 -1.88820454e-01  1.01855972e-01 -2.05122791e-01\n",
+      "   -1.88820454e-01 -1.02561396e-01]\n",
+      "  [ 4.66193077e-01 -2.86365372e-01  2.39662449e-02  9.32386155e-01\n",
+      "   -2.86365372e-01  4.66193077e-01]\n",
+      "  [ 4.52560292e-02  1.14631370e-01 -3.34067917e-02  9.05120584e-02\n",
+      "    1.14631370e-01  4.52560292e-02]\n",
+      "  [ 4.00672911e-01  1.92564093e-01  4.98877760e-02  8.01345822e-01\n",
+      "    1.92564093e-01  4.00672911e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.80072436e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.23007240e-01  1.53979022e-01 -1.26885280e-02 -4.46014480e-01\n",
+      "    1.53979022e-01 -2.23007240e-01]\n",
+      "  [-1.33426939e-01 -3.15955239e-01  9.49575028e-02 -2.66853878e-01\n",
+      "   -3.15955239e-01 -1.33426939e-01]\n",
+      "  [ 5.03470377e-01 -3.52731535e-01  2.81567411e-02  1.00694075e+00\n",
+      "   -3.52731535e-01  5.03470377e-01]\n",
+      "  [ 3.93630714e-02  1.10770683e-01 -1.05673871e-02  7.87261428e-02\n",
+      "    1.10770683e-01  3.93630714e-02]\n",
+      "  [ 5.09580305e-01  4.65255489e-01  9.24843702e-02  1.01916061e+00\n",
+      "    4.65255489e-01  5.09580305e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.60534515e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.14278105e-01  1.63465065e-01 -1.03268419e-02 -4.28556210e-01\n",
+      "    1.63465065e-01 -2.14278105e-01]\n",
+      "  [-1.60981967e-01 -4.00490453e-01  7.54810651e-02 -3.21963935e-01\n",
+      "   -4.00490453e-01 -1.60981967e-01]\n",
+      "  [ 4.87746420e-01 -3.76014315e-01  2.30919334e-02  9.75492840e-01\n",
+      "   -3.76014315e-01  4.87746420e-01]\n",
+      "  [ 4.28733678e-02  1.15473583e-01 -6.63571668e-03  8.57467356e-02\n",
+      "    1.15473583e-01  4.28733678e-02]\n",
+      "  [ 6.05168647e-01  7.07226039e-01  1.23870915e-01  1.21033729e+00\n",
+      "    7.07226039e-01  6.05168647e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.46870655e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-2.05888039e-01  1.69308690e-01 -7.93085689e-03 -4.11776078e-01\n",
+      "    1.69308690e-01 -2.05888039e-01]\n",
+      "  [-1.84663808e-01 -4.65451966e-01  5.95026120e-02 -3.69327617e-01\n",
+      "   -4.65451966e-01 -1.84663808e-01]\n",
+      "  [ 4.66407067e-01 -3.87612082e-01  1.76410135e-02  9.32814134e-01\n",
+      "   -3.87612082e-01  4.66407067e-01]\n",
+      "  [ 4.52451106e-02  1.19865711e-01 -4.73313045e-03  9.04902212e-02\n",
+      "    1.19865711e-01  4.52451106e-02]\n",
+      "  [ 6.90798450e-01  9.20396632e-01  1.49475828e-01  1.38159690e+00\n",
+      "    9.20396632e-01  6.90798450e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.36280366e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.98803165e-01  1.73327269e-01 -6.03008194e-03 -3.97606330e-01\n",
+      "    1.73327269e-01 -1.98803165e-01]\n",
+      "  [-2.04303740e-01 -5.16111389e-01  4.68785776e-02 -4.08607480e-01\n",
+      "   -5.16111389e-01 -2.04303740e-01]\n",
+      "  [ 4.47070329e-01 -3.94304031e-01  1.32107443e-02  8.94140657e-01\n",
+      "   -3.94304031e-01  4.47070329e-01]\n",
+      "  [ 4.69732052e-02  1.22961726e-01 -3.35899414e-03  9.39464104e-02\n",
+      "    1.22961726e-01  4.69732052e-02]\n",
+      "  [ 7.68998997e-01  1.10844286e+00  1.70889328e-01  1.53799799e+00\n",
+      "    1.10844286e+00  7.68998997e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.27091251e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.92789113e-01  1.75978657e-01 -4.54517629e-03 -3.85578227e-01\n",
+      "    1.75978657e-01 -1.92789113e-01]\n",
+      "  [-2.20500139e-01 -5.55540706e-01  3.68776525e-02 -4.41000277e-01\n",
+      "   -5.55540706e-01 -2.20500139e-01]\n",
+      "  [ 4.30424856e-01 -3.97907707e-01  9.75257132e-03  8.60849711e-01\n",
+      "   -3.97907707e-01  4.30424856e-01]\n",
+      "  [ 4.82793653e-02  1.24952071e-01 -2.30991631e-03  9.65587306e-02\n",
+      "    1.24952071e-01  4.82793653e-02]\n",
+      "  [ 8.40805132e-01  1.27504628e+00  1.89020151e-01  1.68161026e+00\n",
+      "    1.27504628e+00  8.40805132e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.18989205e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.87672774e-01  1.77588334e-01 -3.38318223e-03 -3.75345548e-01\n",
+      "    1.77588334e-01 -1.87672774e-01]\n",
+      "  [-2.33807210e-01 -5.86081383e-01  2.89236334e-02 -4.67614420e-01\n",
+      "   -5.86081383e-01 -2.33807210e-01]\n",
+      "  [ 4.16201398e-01 -3.99295277e-01  7.06598589e-03  8.32402797e-01\n",
+      "   -3.99295277e-01  4.16201398e-01]\n",
+      "  [ 4.92546647e-02  1.26089711e-01 -1.50412008e-03  9.85093295e-02\n",
+      "    1.26089711e-01  4.92546647e-02]\n",
+      "  [ 9.06806543e-01  1.42334018e+00  2.04522708e-01  1.81361309e+00\n",
+      "    1.42334018e+00  9.06806543e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.11829985e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.83320440e-01  1.78410041e-01 -2.47240697e-03 -3.66640879e-01\n",
+      "    1.78410041e-01 -1.83320440e-01]\n",
+      "  [-2.44690164e-01 -6.09568484e-01  2.25774268e-02 -4.89380328e-01\n",
+      "   -6.09568484e-01 -2.44690164e-01]\n",
+      "  [ 4.04061655e-01 -3.99063011e-01  4.97908397e-03  8.08123310e-01\n",
+      "   -3.99063011e-01  4.04061655e-01]\n",
+      "  [ 4.99612483e-02  1.26581014e-01 -8.85891392e-04  9.99224967e-02\n",
+      "    1.26581014e-01  4.99612483e-02]\n",
+      "  [ 9.67473969e-01  1.55589415e+00  2.17895305e-01  1.93494794e+00\n",
+      "    1.55589415e+00  9.67473969e-01]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.05500234e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.79620591e-01  1.78640115e-01 -1.75822432e-03 -3.59241182e-01\n",
+      "    1.78640115e-01 -1.79620591e-01]\n",
+      "  [-2.53540124e-01 -6.27448860e-01  1.75019835e-02 -5.07080249e-01\n",
+      "   -6.27448860e-01 -2.53540124e-01]\n",
+      "  [ 3.93704969e-01 -3.97656642e-01  3.35895468e-03  7.87409939e-01\n",
+      "   -3.97656642e-01  3.93704969e-01]\n",
+      "  [ 5.04492283e-02  1.26586733e-01 -4.13401193e-04  1.00898457e-01\n",
+      "    1.26586733e-01  5.04492283e-02]\n",
+      "  [ 1.02322336e+00  1.67481439e+00  2.29524046e-01  2.04644672e+00\n",
+      "    1.67481439e+00  1.02322336e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  4.99901907e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]\n",
+      "\n",
+      " [[-1.76478441e-01  1.78430281e-01 -1.19867655e-03 -3.52956881e-01\n",
+      "    1.78430281e-01 -1.76478441e-01]\n",
+      "  [-2.60686972e-01 -6.40868688e-01  1.34365064e-02 -5.21373944e-01\n",
+      "   -6.40868688e-01 -2.60686972e-01]\n",
+      "  [ 3.84873835e-01 -3.95414932e-01  2.10369506e-03  7.69747669e-01\n",
+      "   -3.95414932e-01  3.84873835e-01]\n",
+      "  [ 5.07601806e-02  1.26231632e-01 -5.46464877e-05  1.01520361e-01\n",
+      "    1.26231632e-01  5.07601806e-02]\n",
+      "  [ 1.07443160e+00  1.78183962e+00  2.39710937e-01  2.14886320e+00\n",
+      "    1.78183962e+00  1.07443160e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  4.94949118e-01\n",
+      "    0.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    1.00000000e+00  0.00000000e+00]\n",
+      "  [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
+      "    0.00000000e+00  0.00000000e+00]]]\n",
+      "     ssigmay:  [[[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]\n",
+      "\n",
+      " [[0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 0.]\n",
+      "  [0. 0. 0. 0. 0. 1.]]]\n",
+      "      sigmaz:  None\n",
+      "          sz:  None\n",
+      "         srz:  None\n",
+      "     ssigmaz:  None\n",
+      "        sllh:  [nan nan nan nan nan nan nan nan]\n",
+      "       s2llh:  None\n",
+      "      status:  0.0\n",
+      "        sres:  [[0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]\n",
+      " [0. 0. 0. 0. 0. 0. 0. 0.]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = model_module.getModel()\n",
+    "model.setTimepoints(np.linspace(0, 10, 11)) \n",
+    "model.requireSensitivitiesForAllParameters()              # sensitivities w.r.t. all parameters\n",
+    "# model.setParameterList([1, 2])                          # sensitivities \n",
+    "# w.r.t. the specified parameters\n",
+    "model.setParameterScale(amici.ParameterScaling_none)         # parameters are used as-is (not log-transformed)\n",
+    "\n",
+    "solver = model.getSolver()\n",
+    "solver.setSensitivityMethod(amici.SensitivityMethod_forward)        # forward sensitivity analysis\n",
+    "solver.setSensitivityOrder(amici.SensitivityOrder_first) # first-order sensitivities\n",
+    "\n",
+    "rdata = amici.runAmiciSimulation(model, solver)\n",
+    "\n",
+    "# print sensitivity-related results\n",
+    "for key, value in rdata.items():\n",
+    "    if key.startswith('s'):\n",
+    "        print('%12s: ' % key, value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Adjoint sensitivity analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Log-likelihood: -862.683106\n",
+      "Gradient: [-1.91102072e+01 -7.10905588e+00  3.96506777e+01  9.94087022e-01\n",
+      "  1.27425627e+01  5.63237660e+00  5.14250302e+00  1.43782082e+04]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Set model options\n",
+    "model = model_module.getModel()\n",
+    "p_orig = np.array(model.getParameters())\n",
+    "p_orig[list(model.getParameterIds()).index('observable_x1withsigma_sigma')] = 0.1 # Change default parameter\n",
+    "model.setParameters(p_orig.flatten())\n",
+    "model.setParameterScale(amici.ParameterScaling_none)\n",
+    "model.setTimepoints(np.linspace(0, 10, 21)) \n",
+    "\n",
+    "solver = model.getSolver()\n",
+    "solver.setMaxSteps(10**4) # Set maximum number of steps for the solver\n",
+    "\n",
+    "# simulate time-course to get artificial data\n",
+    "rdata = amici.runAmiciSimulation(model, solver)\n",
+    "edata = amici.ExpData(rdata, 1.0, 0)\n",
+    "edata.fixedParameters = model.getFixedParameters()\n",
+    "# set sigma to 1.0 except for observable 5, so that p[7] is used instead\n",
+    "# (if we have sigma parameterized, the corresponding ExpData entries must NaN, otherwise they will override the parameter)\n",
+    "edata.setObservedDataStdDev(rdata['t']*0+np.nan,\n",
+    "                            list(model.getObservableIds()).index('observable_x1withsigma'))\n",
+    "\n",
+    "# enable sensitivities\n",
+    "solver.setSensitivityOrder(amici.SensitivityOrder_first) # First-order ...\n",
+    "solver.setSensitivityMethod(amici.SensitivityMethod_adjoint)        # ... adjoint sensitivities\n",
+    "model.requireSensitivitiesForAllParameters()              # ... w.r.t. all parameters\n",
+    "\n",
+    "# compute adjoint sensitivities\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "#print(rdata['sigmay'])\n",
+    "print('Log-likelihood: %f\\nGradient: %s' % (rdata['llh'], rdata['sllh']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Finite differences gradient check\n",
+    "\n",
+    "Compare AMICI-computed gradient with finite differences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sllh: |error|_2: 0.003233\n",
+      "\n",
+      "sllh: p[0]: |error|_2: 0.000035\n",
+      "sllh: p[1]: |error|_2: 0.000048\n",
+      "sllh: p[2]: |error|_2: 0.000063\n",
+      "sllh: p[3]: |error|_2: 0.000031\n",
+      "sllh: p[4]: |error|_2: 0.000013\n",
+      "sllh: p[5]: |error|_2: 0.000009\n",
+      "sllh: p[6]: |error|_2: 0.000022\n",
+      "sllh: p[7]: |error|_2: 0.003258\n",
+      "\n",
+      "sy: p[0]: |error|_2: 0.000001\n",
+      "sy: p[1]: |error|_2: 0.000000\n",
+      "sy: p[2]: |error|_2: 0.000001\n",
+      "sy: p[3]: |error|_2: 0.000006\n",
+      "sy: p[4]: |error|_2: 0.000003\n",
+      "sy: p[5]: |error|_2: 0.000001\n",
+      "sy: p[6]: |error|_2: 0.000000\n",
+      "sy: p[7]: |error|_2: 0.000000\n",
+      "\n",
+      "sx: p[0]: |error|_2: 0.000001\n",
+      "sx: p[1]: |error|_2: 0.000001\n",
+      "sx: p[2]: |error|_2: 0.000001\n",
+      "sx: p[3]: |error|_2: 0.000000\n",
+      "sx: p[4]: |error|_2: 0.000001\n",
+      "sx: p[5]: |error|_2: 0.000000\n",
+      "sx: p[6]: |error|_2: 0.000000\n",
+      "sx: p[7]: |error|_2: 0.000000\n",
+      "\n",
+      "ssigmay: p[0]: |error|_2: 0.000000\n",
+      "ssigmay: p[1]: |error|_2: 0.000000\n",
+      "ssigmay: p[2]: |error|_2: 0.000000\n",
+      "ssigmay: p[3]: |error|_2: 0.000000\n",
+      "ssigmay: p[4]: |error|_2: 0.000000\n",
+      "ssigmay: p[5]: |error|_2: 0.000000\n",
+      "ssigmay: p[6]: |error|_2: 0.000000\n",
+      "ssigmay: p[7]: |error|_2: 0.000000\n"
+     ]
+    }
+   ],
+   "source": [
+    "from scipy.optimize import check_grad\n",
+    "\n",
+    "def func(x0, symbol='llh', x0full=None, plist=[], verbose=False):\n",
+    "    p = x0[:]\n",
+    "    if len(plist):\n",
+    "        p = x0full[:]\n",
+    "        p[plist] = x0\n",
+    "    verbose and print('f: p=%s' % p)\n",
+    "    \n",
+    "    old_parameters = model.getParameters()\n",
+    "    solver.setSensitivityOrder(amici.SensitivityOrder_none)\n",
+    "    model.setParameters(p)\n",
+    "    rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "    \n",
+    "    model.setParameters(old_parameters)\n",
+    "    \n",
+    "    res = np.sum(rdata[symbol])\n",
+    "    verbose and print(res)\n",
+    "    return res\n",
+    "\n",
+    "def grad(x0, symbol='llh', x0full=None, plist=[], verbose=False):\n",
+    "    p = x0[:]\n",
+    "    if len(plist):\n",
+    "        model.setParameterList(plist)\n",
+    "        p = x0full[:]\n",
+    "        p[plist] = x0\n",
+    "    else:\n",
+    "        model.requireSensitivitiesForAllParameters()\n",
+    "    verbose and print('g: p=%s' % p)\n",
+    "    \n",
+    "    old_parameters = model.getParameters()\n",
+    "    solver.setSensitivityMethod(amici.SensitivityMethod_forward)\n",
+    "    solver.setSensitivityOrder(amici.SensitivityOrder_first)\n",
+    "    model.setParameters(p)\n",
+    "    rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "    \n",
+    "    model.setParameters(old_parameters)\n",
+    "\n",
+    "    res = rdata['s%s' % symbol]\n",
+    "    if not isinstance(res, float):\n",
+    "        if len(res.shape) == 3:\n",
+    "            res = np.sum(res, axis=(0, 2))\n",
+    "    verbose and print(res)\n",
+    "    return res\n",
+    "\n",
+    "err_norm = check_grad(func, grad, p_orig, 'llh')\n",
+    "print('sllh: |error|_2: %f' % err_norm)\n",
+    "# assert err_norm < 1e-6\n",
+    "print()\n",
+    "\n",
+    "for ip in range(model.np()):\n",
+    "    plist = [ip]\n",
+    "    p = p_orig.copy()\n",
+    "    err_norm = check_grad(func, grad, p[plist], 'llh', p, [ip])\n",
+    "    print('sllh: p[%d]: |error|_2: %f' % (ip, err_norm))\n",
+    "\n",
+    "print()\n",
+    "for ip in range(model.np()):\n",
+    "    plist = [ip]\n",
+    "    p = p_orig.copy()\n",
+    "    err_norm = check_grad(func, grad, p[plist], 'y', p, [ip])\n",
+    "    print('sy: p[%d]: |error|_2: %f' % (ip, err_norm))\n",
+    "\n",
+    "print()\n",
+    "for ip in range(model.np()):\n",
+    "    plist = [ip]\n",
+    "    p = p_orig.copy()\n",
+    "    err_norm = check_grad(func, grad, p[plist], 'x', p, [ip])\n",
+    "    print('sx: p[%d]: |error|_2: %f' % (ip, err_norm))\n",
+    "\n",
+    "print()\n",
+    "for ip in range(model.np()):\n",
+    "    plist = [ip]\n",
+    "    p = p_orig.copy()\n",
+    "    err_norm = check_grad(func, grad, p[plist], 'sigmay', p, [ip])\n",
+    "    print('ssigmay: p[%d]: |error|_2: %f' % (ip, err_norm))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Export as DataFrame\n",
+    "\n",
+    "Experimental data and simulation results can both be exported as pandas Dataframe to allow for an easier inspection of numeric values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# run the simulation\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>time</th>\n",
+       "      <th>datatype</th>\n",
+       "      <th>t_presim</th>\n",
+       "      <th>k0</th>\n",
+       "      <th>k0_preeq</th>\n",
+       "      <th>k0_presim</th>\n",
+       "      <th>observable_x1</th>\n",
+       "      <th>observable_x2</th>\n",
+       "      <th>observable_x3</th>\n",
+       "      <th>observable_x1_scaled</th>\n",
+       "      <th>observable_x2_offsetted</th>\n",
+       "      <th>observable_x1withsigma</th>\n",
+       "      <th>observable_x1_std</th>\n",
+       "      <th>observable_x2_std</th>\n",
+       "      <th>observable_x3_std</th>\n",
+       "      <th>observable_x1_scaled_std</th>\n",
+       "      <th>observable_x2_offsetted_std</th>\n",
+       "      <th>observable_x1withsigma_std</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.024431</td>\n",
+       "      <td>0.169439</td>\n",
+       "      <td>-0.112275</td>\n",
+       "      <td>-0.156135</td>\n",
+       "      <td>4.591891</td>\n",
+       "      <td>-0.461117</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>-0.048291</td>\n",
+       "      <td>-0.672858</td>\n",
+       "      <td>-0.166120</td>\n",
+       "      <td>-0.246694</td>\n",
+       "      <td>4.145442</td>\n",
+       "      <td>-0.182429</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.539596</td>\n",
+       "      <td>0.619225</td>\n",
+       "      <td>1.307691</td>\n",
+       "      <td>0.821159</td>\n",
+       "      <td>4.584188</td>\n",
+       "      <td>2.428329</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.930428</td>\n",
+       "      <td>1.082986</td>\n",
+       "      <td>0.713558</td>\n",
+       "      <td>2.934550</td>\n",
+       "      <td>3.943787</td>\n",
+       "      <td>-0.612084</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.734583</td>\n",
+       "      <td>1.858265</td>\n",
+       "      <td>1.333083</td>\n",
+       "      <td>1.228891</td>\n",
+       "      <td>3.776846</td>\n",
+       "      <td>0.853197</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>2.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.491161</td>\n",
+       "      <td>1.330449</td>\n",
+       "      <td>-0.187078</td>\n",
+       "      <td>3.317399</td>\n",
+       "      <td>4.241527</td>\n",
+       "      <td>0.384136</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.267422</td>\n",
+       "      <td>2.563478</td>\n",
+       "      <td>-0.815568</td>\n",
+       "      <td>0.569572</td>\n",
+       "      <td>2.035637</td>\n",
+       "      <td>-0.196271</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>3.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.507608</td>\n",
+       "      <td>1.227280</td>\n",
+       "      <td>0.009140</td>\n",
+       "      <td>2.158644</td>\n",
+       "      <td>2.811899</td>\n",
+       "      <td>0.192859</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>4.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.889391</td>\n",
+       "      <td>2.717031</td>\n",
+       "      <td>-0.966199</td>\n",
+       "      <td>3.871869</td>\n",
+       "      <td>3.722095</td>\n",
+       "      <td>1.507652</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>4.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>-0.087687</td>\n",
+       "      <td>0.513524</td>\n",
+       "      <td>-1.007304</td>\n",
+       "      <td>1.053572</td>\n",
+       "      <td>3.759065</td>\n",
+       "      <td>0.752053</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>3.526411</td>\n",
+       "      <td>-1.430472</td>\n",
+       "      <td>1.923501</td>\n",
+       "      <td>0.418906</td>\n",
+       "      <td>2.919740</td>\n",
+       "      <td>2.236638</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>5.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.365648</td>\n",
+       "      <td>-0.399467</td>\n",
+       "      <td>0.777448</td>\n",
+       "      <td>3.405444</td>\n",
+       "      <td>3.593012</td>\n",
+       "      <td>0.931441</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>6.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.588553</td>\n",
+       "      <td>0.994930</td>\n",
+       "      <td>1.690150</td>\n",
+       "      <td>1.003723</td>\n",
+       "      <td>2.909611</td>\n",
+       "      <td>1.193227</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>6.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.163786</td>\n",
+       "      <td>0.735783</td>\n",
+       "      <td>-0.667029</td>\n",
+       "      <td>0.966362</td>\n",
+       "      <td>5.729384</td>\n",
+       "      <td>0.230227</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>7.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.851443</td>\n",
+       "      <td>-0.544395</td>\n",
+       "      <td>0.058794</td>\n",
+       "      <td>1.945118</td>\n",
+       "      <td>3.200816</td>\n",
+       "      <td>0.901044</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>7.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.344363</td>\n",
+       "      <td>1.609499</td>\n",
+       "      <td>0.934498</td>\n",
+       "      <td>1.108364</td>\n",
+       "      <td>4.041441</td>\n",
+       "      <td>-0.804747</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>8.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.023536</td>\n",
+       "      <td>0.326682</td>\n",
+       "      <td>0.665340</td>\n",
+       "      <td>1.914369</td>\n",
+       "      <td>5.218419</td>\n",
+       "      <td>-0.466391</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>8.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>-0.270099</td>\n",
+       "      <td>-1.417993</td>\n",
+       "      <td>1.169516</td>\n",
+       "      <td>1.239814</td>\n",
+       "      <td>3.182998</td>\n",
+       "      <td>0.209709</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>9.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.363280</td>\n",
+       "      <td>0.719389</td>\n",
+       "      <td>1.861780</td>\n",
+       "      <td>-0.647324</td>\n",
+       "      <td>4.869684</td>\n",
+       "      <td>-0.206207</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>9.5</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.723910</td>\n",
+       "      <td>1.294062</td>\n",
+       "      <td>-0.641339</td>\n",
+       "      <td>2.746924</td>\n",
+       "      <td>3.686706</td>\n",
+       "      <td>0.677104</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>10.0</td>\n",
+       "      <td>data</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.216199</td>\n",
+       "      <td>-0.937043</td>\n",
+       "      <td>-1.225093</td>\n",
+       "      <td>1.984324</td>\n",
+       "      <td>4.109546</td>\n",
+       "      <td>0.803328</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    time datatype  t_presim   k0  k0_preeq  k0_presim  observable_x1  \\\n",
+       "0    0.0     data       0.0  1.0       NaN        NaN       0.024431   \n",
+       "1    0.5     data       0.0  1.0       NaN        NaN      -0.048291   \n",
+       "2    1.0     data       0.0  1.0       NaN        NaN       1.539596   \n",
+       "3    1.5     data       0.0  1.0       NaN        NaN       2.930428   \n",
+       "4    2.0     data       0.0  1.0       NaN        NaN       1.734583   \n",
+       "5    2.5     data       0.0  1.0       NaN        NaN       1.491161   \n",
+       "6    3.0     data       0.0  1.0       NaN        NaN       1.267422   \n",
+       "7    3.5     data       0.0  1.0       NaN        NaN       3.507608   \n",
+       "8    4.0     data       0.0  1.0       NaN        NaN       0.889391   \n",
+       "9    4.5     data       0.0  1.0       NaN        NaN      -0.087687   \n",
+       "10   5.0     data       0.0  1.0       NaN        NaN       3.526411   \n",
+       "11   5.5     data       0.0  1.0       NaN        NaN       0.365648   \n",
+       "12   6.0     data       0.0  1.0       NaN        NaN       1.588553   \n",
+       "13   6.5     data       0.0  1.0       NaN        NaN       1.163786   \n",
+       "14   7.0     data       0.0  1.0       NaN        NaN       0.851443   \n",
+       "15   7.5     data       0.0  1.0       NaN        NaN       0.344363   \n",
+       "16   8.0     data       0.0  1.0       NaN        NaN       1.023536   \n",
+       "17   8.5     data       0.0  1.0       NaN        NaN      -0.270099   \n",
+       "18   9.0     data       0.0  1.0       NaN        NaN       0.363280   \n",
+       "19   9.5     data       0.0  1.0       NaN        NaN       1.723910   \n",
+       "20  10.0     data       0.0  1.0       NaN        NaN       0.216199   \n",
+       "\n",
+       "    observable_x2  observable_x3  observable_x1_scaled  \\\n",
+       "0        0.169439      -0.112275             -0.156135   \n",
+       "1       -0.672858      -0.166120             -0.246694   \n",
+       "2        0.619225       1.307691              0.821159   \n",
+       "3        1.082986       0.713558              2.934550   \n",
+       "4        1.858265       1.333083              1.228891   \n",
+       "5        1.330449      -0.187078              3.317399   \n",
+       "6        2.563478      -0.815568              0.569572   \n",
+       "7        1.227280       0.009140              2.158644   \n",
+       "8        2.717031      -0.966199              3.871869   \n",
+       "9        0.513524      -1.007304              1.053572   \n",
+       "10      -1.430472       1.923501              0.418906   \n",
+       "11      -0.399467       0.777448              3.405444   \n",
+       "12       0.994930       1.690150              1.003723   \n",
+       "13       0.735783      -0.667029              0.966362   \n",
+       "14      -0.544395       0.058794              1.945118   \n",
+       "15       1.609499       0.934498              1.108364   \n",
+       "16       0.326682       0.665340              1.914369   \n",
+       "17      -1.417993       1.169516              1.239814   \n",
+       "18       0.719389       1.861780             -0.647324   \n",
+       "19       1.294062      -0.641339              2.746924   \n",
+       "20      -0.937043      -1.225093              1.984324   \n",
+       "\n",
+       "    observable_x2_offsetted  observable_x1withsigma  observable_x1_std  \\\n",
+       "0                  4.591891               -0.461117                1.0   \n",
+       "1                  4.145442               -0.182429                1.0   \n",
+       "2                  4.584188                2.428329                1.0   \n",
+       "3                  3.943787               -0.612084                1.0   \n",
+       "4                  3.776846                0.853197                1.0   \n",
+       "5                  4.241527                0.384136                1.0   \n",
+       "6                  2.035637               -0.196271                1.0   \n",
+       "7                  2.811899                0.192859                1.0   \n",
+       "8                  3.722095                1.507652                1.0   \n",
+       "9                  3.759065                0.752053                1.0   \n",
+       "10                 2.919740                2.236638                1.0   \n",
+       "11                 3.593012                0.931441                1.0   \n",
+       "12                 2.909611                1.193227                1.0   \n",
+       "13                 5.729384                0.230227                1.0   \n",
+       "14                 3.200816                0.901044                1.0   \n",
+       "15                 4.041441               -0.804747                1.0   \n",
+       "16                 5.218419               -0.466391                1.0   \n",
+       "17                 3.182998                0.209709                1.0   \n",
+       "18                 4.869684               -0.206207                1.0   \n",
+       "19                 3.686706                0.677104                1.0   \n",
+       "20                 4.109546                0.803328                1.0   \n",
+       "\n",
+       "    observable_x2_std  observable_x3_std  observable_x1_scaled_std  \\\n",
+       "0                 1.0                1.0                       1.0   \n",
+       "1                 1.0                1.0                       1.0   \n",
+       "2                 1.0                1.0                       1.0   \n",
+       "3                 1.0                1.0                       1.0   \n",
+       "4                 1.0                1.0                       1.0   \n",
+       "5                 1.0                1.0                       1.0   \n",
+       "6                 1.0                1.0                       1.0   \n",
+       "7                 1.0                1.0                       1.0   \n",
+       "8                 1.0                1.0                       1.0   \n",
+       "9                 1.0                1.0                       1.0   \n",
+       "10                1.0                1.0                       1.0   \n",
+       "11                1.0                1.0                       1.0   \n",
+       "12                1.0                1.0                       1.0   \n",
+       "13                1.0                1.0                       1.0   \n",
+       "14                1.0                1.0                       1.0   \n",
+       "15                1.0                1.0                       1.0   \n",
+       "16                1.0                1.0                       1.0   \n",
+       "17                1.0                1.0                       1.0   \n",
+       "18                1.0                1.0                       1.0   \n",
+       "19                1.0                1.0                       1.0   \n",
+       "20                1.0                1.0                       1.0   \n",
+       "\n",
+       "    observable_x2_offsetted_std  observable_x1withsigma_std  \n",
+       "0                           1.0                         NaN  \n",
+       "1                           1.0                         NaN  \n",
+       "2                           1.0                         NaN  \n",
+       "3                           1.0                         NaN  \n",
+       "4                           1.0                         NaN  \n",
+       "5                           1.0                         NaN  \n",
+       "6                           1.0                         NaN  \n",
+       "7                           1.0                         NaN  \n",
+       "8                           1.0                         NaN  \n",
+       "9                           1.0                         NaN  \n",
+       "10                          1.0                         NaN  \n",
+       "11                          1.0                         NaN  \n",
+       "12                          1.0                         NaN  \n",
+       "13                          1.0                         NaN  \n",
+       "14                          1.0                         NaN  \n",
+       "15                          1.0                         NaN  \n",
+       "16                          1.0                         NaN  \n",
+       "17                          1.0                         NaN  \n",
+       "18                          1.0                         NaN  \n",
+       "19                          1.0                         NaN  \n",
+       "20                          1.0                         NaN  "
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# look at the ExpData as DataFrame \n",
+    "df = amici.getDataObservablesAsDataFrame(model, [edata])\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# from the exported dataframe, we can actually reconstruct a copy of the ExpData instace\n",
+    "reconstructed_edata = amici.getEdataFromDataFrame(model, df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>time</th>\n",
+       "      <th>t_presim</th>\n",
+       "      <th>k0</th>\n",
+       "      <th>k0_preeq</th>\n",
+       "      <th>k0_presim</th>\n",
+       "      <th>observable_x1</th>\n",
+       "      <th>observable_x2</th>\n",
+       "      <th>observable_x3</th>\n",
+       "      <th>observable_x1_scaled</th>\n",
+       "      <th>observable_x2_offsetted</th>\n",
+       "      <th>observable_x1withsigma</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.075569</td>\n",
+       "      <td>0.230561</td>\n",
+       "      <td>0.812275</td>\n",
+       "      <td>0.356135</td>\n",
+       "      <td>1.191891</td>\n",
+       "      <td>5.611173</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.587658</td>\n",
+       "      <td>1.357536</td>\n",
+       "      <td>0.357611</td>\n",
+       "      <td>1.325429</td>\n",
+       "      <td>0.460763</td>\n",
+       "      <td>7.217960</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.959523</td>\n",
+       "      <td>0.114062</td>\n",
+       "      <td>1.211267</td>\n",
+       "      <td>0.338986</td>\n",
+       "      <td>0.850900</td>\n",
+       "      <td>18.482569</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.360028</td>\n",
+       "      <td>0.352334</td>\n",
+       "      <td>0.637482</td>\n",
+       "      <td>1.793751</td>\n",
+       "      <td>0.213135</td>\n",
+       "      <td>11.824829</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.174049</td>\n",
+       "      <td>1.142429</td>\n",
+       "      <td>1.263389</td>\n",
+       "      <td>0.107822</td>\n",
+       "      <td>0.061010</td>\n",
+       "      <td>2.926629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>2.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.938105</td>\n",
+       "      <td>0.631698</td>\n",
+       "      <td>0.253379</td>\n",
+       "      <td>2.211288</td>\n",
+       "      <td>0.542776</td>\n",
+       "      <td>1.689200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.720551</td>\n",
+       "      <td>1.881516</td>\n",
+       "      <td>0.879301</td>\n",
+       "      <td>0.524169</td>\n",
+       "      <td>1.646325</td>\n",
+       "      <td>7.431420</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>3.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.966248</td>\n",
+       "      <td>0.561171</td>\n",
+       "      <td>0.052367</td>\n",
+       "      <td>1.075924</td>\n",
+       "      <td>0.854209</td>\n",
+       "      <td>3.485010</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.353110</td>\n",
+       "      <td>2.065728</td>\n",
+       "      <td>1.025694</td>\n",
+       "      <td>2.799308</td>\n",
+       "      <td>0.070792</td>\n",
+       "      <td>9.713711</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>4.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.619225</td>\n",
+       "      <td>0.123990</td>\n",
+       "      <td>1.064957</td>\n",
+       "      <td>0.009505</td>\n",
+       "      <td>0.121550</td>\n",
+       "      <td>2.205146</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.999320</td>\n",
+       "      <td>2.055154</td>\n",
+       "      <td>1.867541</td>\n",
+       "      <td>0.635276</td>\n",
+       "      <td>0.704941</td>\n",
+       "      <td>17.095472</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>5.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.157266</td>\n",
+       "      <td>1.012200</td>\n",
+       "      <td>0.723048</td>\n",
+       "      <td>2.359615</td>\n",
+       "      <td>0.019721</td>\n",
+       "      <td>4.085265</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.069564</td>\n",
+       "      <td>0.393327</td>\n",
+       "      <td>1.637190</td>\n",
+       "      <td>0.034255</td>\n",
+       "      <td>0.691992</td>\n",
+       "      <td>6.742378</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>6.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.648487</td>\n",
+       "      <td>0.144554</td>\n",
+       "      <td>0.718658</td>\n",
+       "      <td>0.064236</td>\n",
+       "      <td>2.138155</td>\n",
+       "      <td>2.850718</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>7.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.339613</td>\n",
+       "      <td>1.125950</td>\n",
+       "      <td>0.008395</td>\n",
+       "      <td>0.921458</td>\n",
+       "      <td>0.380739</td>\n",
+       "      <td>3.892141</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>7.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.164205</td>\n",
+       "      <td>1.036970</td>\n",
+       "      <td>0.885239</td>\n",
+       "      <td>0.091229</td>\n",
+       "      <td>0.468912</td>\n",
+       "      <td>13.133151</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.518036</td>\n",
+       "      <td>0.237421</td>\n",
+       "      <td>0.617136</td>\n",
+       "      <td>0.903369</td>\n",
+       "      <td>1.654316</td>\n",
+       "      <td>9.718916</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>8.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.772714</td>\n",
+       "      <td>1.974227</td>\n",
+       "      <td>1.122292</td>\n",
+       "      <td>0.234584</td>\n",
+       "      <td>0.373236</td>\n",
+       "      <td>2.929067</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>9.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.136622</td>\n",
+       "      <td>0.170508</td>\n",
+       "      <td>1.815465</td>\n",
+       "      <td>1.647128</td>\n",
+       "      <td>1.320802</td>\n",
+       "      <td>7.061092</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>9.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1.226561</td>\n",
+       "      <td>0.752054</td>\n",
+       "      <td>0.686809</td>\n",
+       "      <td>1.752224</td>\n",
+       "      <td>0.144698</td>\n",
+       "      <td>1.797547</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>10.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.278751</td>\n",
+       "      <td>1.472624</td>\n",
+       "      <td>1.269778</td>\n",
+       "      <td>0.994425</td>\n",
+       "      <td>0.573965</td>\n",
+       "      <td>3.083792</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    time  t_presim   k0  k0_preeq  k0_presim  observable_x1  observable_x2  \\\n",
+       "0    0.0       0.0  1.0       NaN        NaN       0.075569       0.230561   \n",
+       "1    0.5       0.0  1.0       NaN        NaN       0.587658       1.357536   \n",
+       "2    1.0       0.0  1.0       NaN        NaN       0.959523       0.114062   \n",
+       "3    1.5       0.0  1.0       NaN        NaN       2.360028       0.352334   \n",
+       "4    2.0       0.0  1.0       NaN        NaN       1.174049       1.142429   \n",
+       "5    2.5       0.0  1.0       NaN        NaN       0.938105       0.631698   \n",
+       "6    3.0       0.0  1.0       NaN        NaN       0.720551       1.881516   \n",
+       "7    3.5       0.0  1.0       NaN        NaN       2.966248       0.561171   \n",
+       "8    4.0       0.0  1.0       NaN        NaN       0.353110       2.065728   \n",
+       "9    4.5       0.0  1.0       NaN        NaN       0.619225       0.123990   \n",
+       "10   5.0       0.0  1.0       NaN        NaN       2.999320       2.055154   \n",
+       "11   5.5       0.0  1.0       NaN        NaN       0.157266       1.012200   \n",
+       "12   6.0       0.0  1.0       NaN        NaN       1.069564       0.393327   \n",
+       "13   6.5       0.0  1.0       NaN        NaN       0.648487       0.144554   \n",
+       "14   7.0       0.0  1.0       NaN        NaN       0.339613       1.125950   \n",
+       "15   7.5       0.0  1.0       NaN        NaN       0.164205       1.036970   \n",
+       "16   8.0       0.0  1.0       NaN        NaN       0.518036       0.237421   \n",
+       "17   8.5       0.0  1.0       NaN        NaN       0.772714       1.974227   \n",
+       "18   9.0       0.0  1.0       NaN        NaN       0.136622       0.170508   \n",
+       "19   9.5       0.0  1.0       NaN        NaN       1.226561       0.752054   \n",
+       "20  10.0       0.0  1.0       NaN        NaN       0.278751       1.472624   \n",
+       "\n",
+       "    observable_x3  observable_x1_scaled  observable_x2_offsetted  \\\n",
+       "0        0.812275              0.356135                 1.191891   \n",
+       "1        0.357611              1.325429                 0.460763   \n",
+       "2        1.211267              0.338986                 0.850900   \n",
+       "3        0.637482              1.793751                 0.213135   \n",
+       "4        1.263389              0.107822                 0.061010   \n",
+       "5        0.253379              2.211288                 0.542776   \n",
+       "6        0.879301              0.524169                 1.646325   \n",
+       "7        0.052367              1.075924                 0.854209   \n",
+       "8        1.025694              2.799308                 0.070792   \n",
+       "9        1.064957              0.009505                 0.121550   \n",
+       "10       1.867541              0.635276                 0.704941   \n",
+       "11       0.723048              2.359615                 0.019721   \n",
+       "12       1.637190              0.034255                 0.691992   \n",
+       "13       0.718658              0.064236                 2.138155   \n",
+       "14       0.008395              0.921458                 0.380739   \n",
+       "15       0.885239              0.091229                 0.468912   \n",
+       "16       0.617136              0.903369                 1.654316   \n",
+       "17       1.122292              0.234584                 0.373236   \n",
+       "18       1.815465              1.647128                 1.320802   \n",
+       "19       0.686809              1.752224                 0.144698   \n",
+       "20       1.269778              0.994425                 0.573965   \n",
+       "\n",
+       "    observable_x1withsigma  \n",
+       "0                 5.611173  \n",
+       "1                 7.217960  \n",
+       "2                18.482569  \n",
+       "3                11.824829  \n",
+       "4                 2.926629  \n",
+       "5                 1.689200  \n",
+       "6                 7.431420  \n",
+       "7                 3.485010  \n",
+       "8                 9.713711  \n",
+       "9                 2.205146  \n",
+       "10               17.095472  \n",
+       "11                4.085265  \n",
+       "12                6.742378  \n",
+       "13                2.850718  \n",
+       "14                3.892141  \n",
+       "15               13.133151  \n",
+       "16                9.718916  \n",
+       "17                2.929067  \n",
+       "18                7.061092  \n",
+       "19                1.797547  \n",
+       "20                3.083792  "
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# look at the States in rdata as DataFrame \n",
+    "amici.getResidualsAsDataFrame(model, [edata], [rdata])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>time</th>\n",
+       "      <th>datatype</th>\n",
+       "      <th>t_presim</th>\n",
+       "      <th>k0</th>\n",
+       "      <th>k0_preeq</th>\n",
+       "      <th>k0_presim</th>\n",
+       "      <th>observable_x1</th>\n",
+       "      <th>observable_x2</th>\n",
+       "      <th>observable_x3</th>\n",
+       "      <th>observable_x1_scaled</th>\n",
+       "      <th>observable_x2_offsetted</th>\n",
+       "      <th>observable_x1withsigma</th>\n",
+       "      <th>observable_x1_std</th>\n",
+       "      <th>observable_x2_std</th>\n",
+       "      <th>observable_x3_std</th>\n",
+       "      <th>observable_x1_scaled_std</th>\n",
+       "      <th>observable_x2_offsetted_std</th>\n",
+       "      <th>observable_x1withsigma_std</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.100000</td>\n",
+       "      <td>0.400000</td>\n",
+       "      <td>0.700000</td>\n",
+       "      <td>0.200000</td>\n",
+       "      <td>3.400000</td>\n",
+       "      <td>0.100000</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.539367</td>\n",
+       "      <td>0.684679</td>\n",
+       "      <td>0.191491</td>\n",
+       "      <td>1.078734</td>\n",
+       "      <td>3.684679</td>\n",
+       "      <td>0.539367</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.580072</td>\n",
+       "      <td>0.733287</td>\n",
+       "      <td>0.096424</td>\n",
+       "      <td>1.160145</td>\n",
+       "      <td>3.733287</td>\n",
+       "      <td>0.580072</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.570399</td>\n",
+       "      <td>0.730652</td>\n",
+       "      <td>0.076076</td>\n",
+       "      <td>1.140799</td>\n",
+       "      <td>3.730652</td>\n",
+       "      <td>0.570399</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.560535</td>\n",
+       "      <td>0.715836</td>\n",
+       "      <td>0.069694</td>\n",
+       "      <td>1.121069</td>\n",
+       "      <td>3.715836</td>\n",
+       "      <td>0.560535</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>2.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.553056</td>\n",
+       "      <td>0.698751</td>\n",
+       "      <td>0.066301</td>\n",
+       "      <td>1.106112</td>\n",
+       "      <td>3.698751</td>\n",
+       "      <td>0.553056</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.546871</td>\n",
+       "      <td>0.681963</td>\n",
+       "      <td>0.063733</td>\n",
+       "      <td>1.093741</td>\n",
+       "      <td>3.681963</td>\n",
+       "      <td>0.546871</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>3.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.541360</td>\n",
+       "      <td>0.666109</td>\n",
+       "      <td>0.061506</td>\n",
+       "      <td>1.082720</td>\n",
+       "      <td>3.666109</td>\n",
+       "      <td>0.541360</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>4.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.536280</td>\n",
+       "      <td>0.651302</td>\n",
+       "      <td>0.059495</td>\n",
+       "      <td>1.072561</td>\n",
+       "      <td>3.651302</td>\n",
+       "      <td>0.536280</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>4.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.531538</td>\n",
+       "      <td>0.637515</td>\n",
+       "      <td>0.057653</td>\n",
+       "      <td>1.063076</td>\n",
+       "      <td>3.637515</td>\n",
+       "      <td>0.531538</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.527091</td>\n",
+       "      <td>0.624681</td>\n",
+       "      <td>0.055960</td>\n",
+       "      <td>1.054183</td>\n",
+       "      <td>3.624681</td>\n",
+       "      <td>0.527091</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>5.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.522915</td>\n",
+       "      <td>0.612733</td>\n",
+       "      <td>0.054400</td>\n",
+       "      <td>1.045829</td>\n",
+       "      <td>3.612733</td>\n",
+       "      <td>0.522915</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>6.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.518989</td>\n",
+       "      <td>0.601603</td>\n",
+       "      <td>0.052960</td>\n",
+       "      <td>1.037978</td>\n",
+       "      <td>3.601603</td>\n",
+       "      <td>0.518989</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>6.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.515299</td>\n",
+       "      <td>0.591229</td>\n",
+       "      <td>0.051629</td>\n",
+       "      <td>1.030598</td>\n",
+       "      <td>3.591229</td>\n",
+       "      <td>0.515299</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>7.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.511830</td>\n",
+       "      <td>0.581555</td>\n",
+       "      <td>0.050399</td>\n",
+       "      <td>1.023660</td>\n",
+       "      <td>3.581555</td>\n",
+       "      <td>0.511830</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>7.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.508568</td>\n",
+       "      <td>0.572529</td>\n",
+       "      <td>0.049259</td>\n",
+       "      <td>1.017136</td>\n",
+       "      <td>3.572529</td>\n",
+       "      <td>0.508568</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>8.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.505500</td>\n",
+       "      <td>0.564103</td>\n",
+       "      <td>0.048203</td>\n",
+       "      <td>1.011000</td>\n",
+       "      <td>3.564103</td>\n",
+       "      <td>0.505500</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>8.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.502615</td>\n",
+       "      <td>0.556234</td>\n",
+       "      <td>0.047224</td>\n",
+       "      <td>1.005231</td>\n",
+       "      <td>3.556234</td>\n",
+       "      <td>0.502615</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>9.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.499902</td>\n",
+       "      <td>0.548881</td>\n",
+       "      <td>0.046315</td>\n",
+       "      <td>0.999804</td>\n",
+       "      <td>3.548881</td>\n",
+       "      <td>0.499902</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>9.5</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.497350</td>\n",
+       "      <td>0.542008</td>\n",
+       "      <td>0.045471</td>\n",
+       "      <td>0.994700</td>\n",
+       "      <td>3.542008</td>\n",
+       "      <td>0.497350</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>10.0</td>\n",
+       "      <td>simulation</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.494949</td>\n",
+       "      <td>0.535581</td>\n",
+       "      <td>0.044686</td>\n",
+       "      <td>0.989898</td>\n",
+       "      <td>3.535581</td>\n",
+       "      <td>0.494949</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    time    datatype  t_presim   k0  k0_preeq  k0_presim  observable_x1  \\\n",
+       "0    0.0  simulation       0.0  1.0       NaN        NaN       0.100000   \n",
+       "1    0.5  simulation       0.0  1.0       NaN        NaN       0.539367   \n",
+       "2    1.0  simulation       0.0  1.0       NaN        NaN       0.580072   \n",
+       "3    1.5  simulation       0.0  1.0       NaN        NaN       0.570399   \n",
+       "4    2.0  simulation       0.0  1.0       NaN        NaN       0.560535   \n",
+       "5    2.5  simulation       0.0  1.0       NaN        NaN       0.553056   \n",
+       "6    3.0  simulation       0.0  1.0       NaN        NaN       0.546871   \n",
+       "7    3.5  simulation       0.0  1.0       NaN        NaN       0.541360   \n",
+       "8    4.0  simulation       0.0  1.0       NaN        NaN       0.536280   \n",
+       "9    4.5  simulation       0.0  1.0       NaN        NaN       0.531538   \n",
+       "10   5.0  simulation       0.0  1.0       NaN        NaN       0.527091   \n",
+       "11   5.5  simulation       0.0  1.0       NaN        NaN       0.522915   \n",
+       "12   6.0  simulation       0.0  1.0       NaN        NaN       0.518989   \n",
+       "13   6.5  simulation       0.0  1.0       NaN        NaN       0.515299   \n",
+       "14   7.0  simulation       0.0  1.0       NaN        NaN       0.511830   \n",
+       "15   7.5  simulation       0.0  1.0       NaN        NaN       0.508568   \n",
+       "16   8.0  simulation       0.0  1.0       NaN        NaN       0.505500   \n",
+       "17   8.5  simulation       0.0  1.0       NaN        NaN       0.502615   \n",
+       "18   9.0  simulation       0.0  1.0       NaN        NaN       0.499902   \n",
+       "19   9.5  simulation       0.0  1.0       NaN        NaN       0.497350   \n",
+       "20  10.0  simulation       0.0  1.0       NaN        NaN       0.494949   \n",
+       "\n",
+       "    observable_x2  observable_x3  observable_x1_scaled  \\\n",
+       "0        0.400000       0.700000              0.200000   \n",
+       "1        0.684679       0.191491              1.078734   \n",
+       "2        0.733287       0.096424              1.160145   \n",
+       "3        0.730652       0.076076              1.140799   \n",
+       "4        0.715836       0.069694              1.121069   \n",
+       "5        0.698751       0.066301              1.106112   \n",
+       "6        0.681963       0.063733              1.093741   \n",
+       "7        0.666109       0.061506              1.082720   \n",
+       "8        0.651302       0.059495              1.072561   \n",
+       "9        0.637515       0.057653              1.063076   \n",
+       "10       0.624681       0.055960              1.054183   \n",
+       "11       0.612733       0.054400              1.045829   \n",
+       "12       0.601603       0.052960              1.037978   \n",
+       "13       0.591229       0.051629              1.030598   \n",
+       "14       0.581555       0.050399              1.023660   \n",
+       "15       0.572529       0.049259              1.017136   \n",
+       "16       0.564103       0.048203              1.011000   \n",
+       "17       0.556234       0.047224              1.005231   \n",
+       "18       0.548881       0.046315              0.999804   \n",
+       "19       0.542008       0.045471              0.994700   \n",
+       "20       0.535581       0.044686              0.989898   \n",
+       "\n",
+       "    observable_x2_offsetted  observable_x1withsigma  observable_x1_std  \\\n",
+       "0                  3.400000                0.100000                1.0   \n",
+       "1                  3.684679                0.539367                1.0   \n",
+       "2                  3.733287                0.580072                1.0   \n",
+       "3                  3.730652                0.570399                1.0   \n",
+       "4                  3.715836                0.560535                1.0   \n",
+       "5                  3.698751                0.553056                1.0   \n",
+       "6                  3.681963                0.546871                1.0   \n",
+       "7                  3.666109                0.541360                1.0   \n",
+       "8                  3.651302                0.536280                1.0   \n",
+       "9                  3.637515                0.531538                1.0   \n",
+       "10                 3.624681                0.527091                1.0   \n",
+       "11                 3.612733                0.522915                1.0   \n",
+       "12                 3.601603                0.518989                1.0   \n",
+       "13                 3.591229                0.515299                1.0   \n",
+       "14                 3.581555                0.511830                1.0   \n",
+       "15                 3.572529                0.508568                1.0   \n",
+       "16                 3.564103                0.505500                1.0   \n",
+       "17                 3.556234                0.502615                1.0   \n",
+       "18                 3.548881                0.499902                1.0   \n",
+       "19                 3.542008                0.497350                1.0   \n",
+       "20                 3.535581                0.494949                1.0   \n",
+       "\n",
+       "    observable_x2_std  observable_x3_std  observable_x1_scaled_std  \\\n",
+       "0                 1.0                1.0                       1.0   \n",
+       "1                 1.0                1.0                       1.0   \n",
+       "2                 1.0                1.0                       1.0   \n",
+       "3                 1.0                1.0                       1.0   \n",
+       "4                 1.0                1.0                       1.0   \n",
+       "5                 1.0                1.0                       1.0   \n",
+       "6                 1.0                1.0                       1.0   \n",
+       "7                 1.0                1.0                       1.0   \n",
+       "8                 1.0                1.0                       1.0   \n",
+       "9                 1.0                1.0                       1.0   \n",
+       "10                1.0                1.0                       1.0   \n",
+       "11                1.0                1.0                       1.0   \n",
+       "12                1.0                1.0                       1.0   \n",
+       "13                1.0                1.0                       1.0   \n",
+       "14                1.0                1.0                       1.0   \n",
+       "15                1.0                1.0                       1.0   \n",
+       "16                1.0                1.0                       1.0   \n",
+       "17                1.0                1.0                       1.0   \n",
+       "18                1.0                1.0                       1.0   \n",
+       "19                1.0                1.0                       1.0   \n",
+       "20                1.0                1.0                       1.0   \n",
+       "\n",
+       "    observable_x2_offsetted_std  observable_x1withsigma_std  \n",
+       "0                           1.0                         0.1  \n",
+       "1                           1.0                         0.1  \n",
+       "2                           1.0                         0.1  \n",
+       "3                           1.0                         0.1  \n",
+       "4                           1.0                         0.1  \n",
+       "5                           1.0                         0.1  \n",
+       "6                           1.0                         0.1  \n",
+       "7                           1.0                         0.1  \n",
+       "8                           1.0                         0.1  \n",
+       "9                           1.0                         0.1  \n",
+       "10                          1.0                         0.1  \n",
+       "11                          1.0                         0.1  \n",
+       "12                          1.0                         0.1  \n",
+       "13                          1.0                         0.1  \n",
+       "14                          1.0                         0.1  \n",
+       "15                          1.0                         0.1  \n",
+       "16                          1.0                         0.1  \n",
+       "17                          1.0                         0.1  \n",
+       "18                          1.0                         0.1  \n",
+       "19                          1.0                         0.1  \n",
+       "20                          1.0                         0.1  "
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# look at the Observables in rdata as DataFrame \n",
+    "amici.getSimulationObservablesAsDataFrame(model, [edata], [rdata])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>time</th>\n",
+       "      <th>t_presim</th>\n",
+       "      <th>k0</th>\n",
+       "      <th>k0_preeq</th>\n",
+       "      <th>k0_presim</th>\n",
+       "      <th>x1</th>\n",
+       "      <th>x2</th>\n",
+       "      <th>x3</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.100000</td>\n",
+       "      <td>0.400000</td>\n",
+       "      <td>0.700000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.539367</td>\n",
+       "      <td>0.684679</td>\n",
+       "      <td>0.191491</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.580072</td>\n",
+       "      <td>0.733287</td>\n",
+       "      <td>0.096424</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.570399</td>\n",
+       "      <td>0.730652</td>\n",
+       "      <td>0.076076</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.560535</td>\n",
+       "      <td>0.715836</td>\n",
+       "      <td>0.069694</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>2.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.553056</td>\n",
+       "      <td>0.698751</td>\n",
+       "      <td>0.066301</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.546871</td>\n",
+       "      <td>0.681963</td>\n",
+       "      <td>0.063733</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>3.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.541360</td>\n",
+       "      <td>0.666109</td>\n",
+       "      <td>0.061506</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.536280</td>\n",
+       "      <td>0.651302</td>\n",
+       "      <td>0.059495</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>4.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.531538</td>\n",
+       "      <td>0.637515</td>\n",
+       "      <td>0.057653</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.527091</td>\n",
+       "      <td>0.624681</td>\n",
+       "      <td>0.055960</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>5.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.522915</td>\n",
+       "      <td>0.612733</td>\n",
+       "      <td>0.054400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.518989</td>\n",
+       "      <td>0.601603</td>\n",
+       "      <td>0.052960</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>6.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.515299</td>\n",
+       "      <td>0.591229</td>\n",
+       "      <td>0.051629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>7.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.511830</td>\n",
+       "      <td>0.581555</td>\n",
+       "      <td>0.050399</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>7.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.508568</td>\n",
+       "      <td>0.572529</td>\n",
+       "      <td>0.049259</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.505500</td>\n",
+       "      <td>0.564103</td>\n",
+       "      <td>0.048203</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>8.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.502615</td>\n",
+       "      <td>0.556234</td>\n",
+       "      <td>0.047224</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>9.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.499902</td>\n",
+       "      <td>0.548881</td>\n",
+       "      <td>0.046315</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>9.5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.497350</td>\n",
+       "      <td>0.542008</td>\n",
+       "      <td>0.045471</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>10.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.494949</td>\n",
+       "      <td>0.535581</td>\n",
+       "      <td>0.044686</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    time  t_presim   k0  k0_preeq  k0_presim        x1        x2        x3\n",
+       "0    0.0       0.0  1.0       NaN        NaN  0.100000  0.400000  0.700000\n",
+       "1    0.5       0.0  1.0       NaN        NaN  0.539367  0.684679  0.191491\n",
+       "2    1.0       0.0  1.0       NaN        NaN  0.580072  0.733287  0.096424\n",
+       "3    1.5       0.0  1.0       NaN        NaN  0.570399  0.730652  0.076076\n",
+       "4    2.0       0.0  1.0       NaN        NaN  0.560535  0.715836  0.069694\n",
+       "5    2.5       0.0  1.0       NaN        NaN  0.553056  0.698751  0.066301\n",
+       "6    3.0       0.0  1.0       NaN        NaN  0.546871  0.681963  0.063733\n",
+       "7    3.5       0.0  1.0       NaN        NaN  0.541360  0.666109  0.061506\n",
+       "8    4.0       0.0  1.0       NaN        NaN  0.536280  0.651302  0.059495\n",
+       "9    4.5       0.0  1.0       NaN        NaN  0.531538  0.637515  0.057653\n",
+       "10   5.0       0.0  1.0       NaN        NaN  0.527091  0.624681  0.055960\n",
+       "11   5.5       0.0  1.0       NaN        NaN  0.522915  0.612733  0.054400\n",
+       "12   6.0       0.0  1.0       NaN        NaN  0.518989  0.601603  0.052960\n",
+       "13   6.5       0.0  1.0       NaN        NaN  0.515299  0.591229  0.051629\n",
+       "14   7.0       0.0  1.0       NaN        NaN  0.511830  0.581555  0.050399\n",
+       "15   7.5       0.0  1.0       NaN        NaN  0.508568  0.572529  0.049259\n",
+       "16   8.0       0.0  1.0       NaN        NaN  0.505500  0.564103  0.048203\n",
+       "17   8.5       0.0  1.0       NaN        NaN  0.502615  0.556234  0.047224\n",
+       "18   9.0       0.0  1.0       NaN        NaN  0.499902  0.548881  0.046315\n",
+       "19   9.5       0.0  1.0       NaN        NaN  0.497350  0.542008  0.045471\n",
+       "20  10.0       0.0  1.0       NaN        NaN  0.494949  0.535581  0.044686"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# look at the States in rdata as DataFrame \n",
+    "amici.getSimulationStatesAsDataFrame(model, [edata], [rdata])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.7"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_steadystate/model_steadystate_scaled.xml b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_steadystate/model_steadystate_scaled.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e9b768c086ce4436b9d3f1af5e3516be937f2388
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/examples/example_steadystate/model_steadystate_scaled.xml
@@ -0,0 +1,199 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" level="3" version="1">
+  <model substanceUnits="mole" timeUnits="second" extentUnits="mole">
+    <listOfUnitDefinitions>
+      <unitDefinition id="litre_per_second">
+        <listOfUnits>
+          <unit kind="litre" exponent="1" scale="0" multiplier="1"/>
+          <unit kind="second" exponent="-1" scale="0" multiplier="1"/>
+        </listOfUnits>
+      </unitDefinition>
+      <unitDefinition id="mole_per_litre">
+        <listOfUnits>
+          <unit kind="mole" exponent="1" scale="0" multiplier="1"/>
+          <unit kind="litre" exponent="-1" scale="0" multiplier="1"/>
+        </listOfUnits>
+      </unitDefinition>
+      <unitDefinition id="mole_per_second">
+        <listOfUnits>
+          <unit kind="mole" exponent="1" scale="0" multiplier="1"/>
+          <unit kind="second" exponent="-1" scale="0" multiplier="1"/>
+        </listOfUnits>
+      </unitDefinition>
+      <unitDefinition id="litre2_per_mole_per_second">
+        <listOfUnits>
+          <unit kind="litre" exponent="2" scale="0" multiplier="1"/>
+          <unit kind="mole" exponent="-1" scale="0" multiplier="1"/>
+          <unit kind="second" exponent="-1" scale="0" multiplier="1"/>
+        </listOfUnits>
+      </unitDefinition>
+    </listOfUnitDefinitions>
+    <listOfCompartments>
+      <compartment id="c1" spatialDimensions="3" size="1" units="litre" constant="true"/>
+    </listOfCompartments>
+    <listOfSpecies>
+      <species id="x1" name="x1" compartment="c1" initialAmount="0.1" substanceUnits="mole" hasOnlySubstanceUnits="false" boundaryCondition="false" constant="false"/>
+      <species id="x2" name="x1" compartment="c1" initialAmount="0.4" substanceUnits="mole" hasOnlySubstanceUnits="false" boundaryCondition="false" constant="false"/>
+      <species id="x3" name="x1" compartment="c1" initialAmount="0.7" substanceUnits="mole" hasOnlySubstanceUnits="false" boundaryCondition="false" constant="false"/>
+    </listOfSpecies>
+    <listOfParameters>
+      <parameter id="p1" name="p1" value="1" units="litre2_per_mole_per_second" constant="true"/>
+      <parameter id="p2" name="p2" value="0.5" units="litre2_per_mole_per_second" constant="true"/>
+      <parameter id="p3" name="p3" value="0.4" units="litre_per_second" constant="true"/>
+      <parameter id="p4" name="p4" value="2" units="litre_per_second" constant="true"/>
+      <parameter id="p5" name="p5" value="0.1" units="mole_per_second" constant="true"/>
+      <parameter id="k0" name="k0" value="1" units="litre_per_second" constant="true"/>
+      <parameter id="observable_x1" value="1" units="mole_per_litre" constant="false"/>
+      <parameter id="observable_x2" value="1" units="mole_per_litre" constant="false"/>
+      <parameter id="observable_x3" value="1" units="mole_per_litre" constant="false"/>
+      <parameter id="scaling_x1" name="scale" value="2" units="dimensionless" constant="true"/>
+      <parameter id="observable_x1_scaled" value="1" units="mole_per_litre" constant="false"/>
+      <parameter id="offset_x2" name="offset" value="3" units="mole_per_litre" constant="true"/>
+      <parameter id="observable_x2_offsetted" value="1" units="mole_per_litre" constant="false"/>
+      <parameter id="observable_x1withsigma_sigma" name="sigma" value="0.2" units="dimensionless" constant="true"/>
+      <parameter id="observable_x1withsigma" value="1" units="mole_per_litre" constant="false"/>
+    </listOfParameters>
+    <listOfRules>
+      <assignmentRule variable="observable_x1">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> x1 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="observable_x2">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> x2 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="observable_x3">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> x3 </ci>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="observable_x1_scaled">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <apply>
+            <times/>
+            <ci> scaling_x1 </ci>
+            <ci> x1 </ci>
+          </apply>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="observable_x2_offsetted">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <apply>
+            <plus/>
+            <ci> offset_x2 </ci>
+            <ci> x2 </ci>
+          </apply>
+        </math>
+      </assignmentRule>
+      <assignmentRule variable="observable_x1withsigma">
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <ci> x1 </ci>
+        </math>
+      </assignmentRule>
+    </listOfRules>
+    <listOfReactions>
+      <reaction id="r1" reversible="false" fast="false">
+        <listOfReactants>
+          <speciesReference species="x1" stoichiometry="2" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="x2" stoichiometry="1" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> p1 </ci>
+              <apply>
+                <power/>
+                <ci> x1 </ci>
+                <cn type="integer"> 2 </cn>
+              </apply>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r2" reversible="false" fast="false">
+        <listOfReactants>
+          <speciesReference species="x1" stoichiometry="1" constant="true"/>
+          <speciesReference species="x2" stoichiometry="1" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="x3" stoichiometry="1" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> p2 </ci>
+              <ci> x1 </ci>
+              <ci> x2 </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r3" reversible="false" fast="false">
+        <listOfReactants>
+          <speciesReference species="x2" stoichiometry="1" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="x1" stoichiometry="2" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> p3 </ci>
+              <ci> x2 </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r4" reversible="false" fast="false">
+        <listOfReactants>
+          <speciesReference species="x3" stoichiometry="1" constant="true"/>
+        </listOfReactants>
+        <listOfProducts>
+          <speciesReference species="x1" stoichiometry="1" constant="true"/>
+          <speciesReference species="x2" stoichiometry="1" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> p4 </ci>
+              <ci> x3 </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r5" reversible="false" fast="false">
+        <listOfReactants>
+          <speciesReference species="x3" stoichiometry="1" constant="true"/>
+        </listOfReactants>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <apply>
+              <times/>
+              <ci> k0 </ci>
+              <ci> x3 </ci>
+            </apply>
+          </math>
+        </kineticLaw>
+      </reaction>
+      <reaction id="r6" reversible="false" fast="false">
+        <listOfProducts>
+          <speciesReference species="x1" stoichiometry="1" constant="true"/>
+        </listOfProducts>
+        <kineticLaw>
+          <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <ci> p5 </ci>
+          </math>
+        </kineticLaw>
+      </reaction>
+    </listOfReactions>
+  </model>
+</sbml>
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/MANIFEST.in b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/MANIFEST.in
new file mode 100644
index 0000000000000000000000000000000000000000..e73b987b0828fb1fc76ecab1afb142c8800ff4de
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/MANIFEST.in
@@ -0,0 +1,11 @@
+recursive-include amici/ThirdParty/SuiteSparse *.c *.h LICENSE.txt
+recursive-include amici/ThirdParty/sundials *.c *.h LICENSE
+recursive-include amici/ThirdParty/gsl *.hpp
+recursive-include amici/include *.h
+recursive-include amici/swig *.i *.h
+include amici/*
+include amici/src/*template*
+include amici/swig/CMakeLists_model.cmake
+include setup_clibs.py
+include custom_commands.py
+include version.txt
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/README.md b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe840054137e2ccda075344f21e728249a60a2fc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/README.md
@@ -0,0 +1 @@
+../../README.md
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/MANIFEST.template.in b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/MANIFEST.template.in
new file mode 100644
index 0000000000000000000000000000000000000000..7615b2cce2b0681c2df7f22322ba93a59fa56f9a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/MANIFEST.template.in
@@ -0,0 +1 @@
+../../amici/MANIFEST.template.in
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/ThirdParty b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/ThirdParty
new file mode 100644
index 0000000000000000000000000000000000000000..dbca061d2f0124a454aeda6d933c370a6ba9b39a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/ThirdParty
@@ -0,0 +1 @@
+../../../ThirdParty/
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/__init__.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce45fc83fa3b3a69742d94cccdb9ebc705fde7b8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/__init__.py
@@ -0,0 +1 @@
+../../amici/__init__.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/__init__.template.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/__init__.template.py
new file mode 100644
index 0000000000000000000000000000000000000000..165798fd5f57cf3ea5c39b363f5bb47f06091daa
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/__init__.template.py
@@ -0,0 +1 @@
+../../amici/__init__.template.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/gradient_check.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/gradient_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..3402ef0822b39d8a22c987ed520136544cd0a41e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/gradient_check.py
@@ -0,0 +1 @@
+../../amici/gradient_check.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/include b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/include
new file mode 100644
index 0000000000000000000000000000000000000000..b85a409837d1b78a33b0bef7fd3f16b80369dd96
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/include
@@ -0,0 +1 @@
+../../../include/
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/numpy.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..54495e0290fecc59a891a59fcdd4615c84c41ec0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/numpy.py
@@ -0,0 +1 @@
+../../amici/numpy.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/ode_export.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/ode_export.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6a27b74d44868d417590c6bea16d578db0582e6
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/ode_export.py
@@ -0,0 +1 @@
+../../amici/ode_export.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/pandas.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/pandas.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e1bc9cfffc4afa2e06234a1a8d399a91ca8b47d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/pandas.py
@@ -0,0 +1 @@
+../../amici/pandas.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/plotting.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/plotting.py
new file mode 100644
index 0000000000000000000000000000000000000000..5195d2f4c7c12c185b5d98ac563606792a193dca
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/plotting.py
@@ -0,0 +1 @@
+../../amici/plotting.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/pysb_import.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/pysb_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3ad0bdb51c2b3cbaebae13c0a059fa54ed031a4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/pysb_import.py
@@ -0,0 +1 @@
+../../amici/pysb_import.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/sbml_import.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/sbml_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5ebad6b679de42cc8d6fdeb628c9fed2f115c73
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/sbml_import.py
@@ -0,0 +1 @@
+../../amici/sbml_import.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/setup.template.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/setup.template.py
new file mode 100644
index 0000000000000000000000000000000000000000..92581602530db48ac846e53f22fb803962f4b3de
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/setup.template.py
@@ -0,0 +1 @@
+../../amici/setup.template.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/setuptools.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/setuptools.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fc45c94baf320dede5f3205708e1dc22e47c95d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/setuptools.py
@@ -0,0 +1 @@
+../../amici/setuptools.py
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/src b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/src
new file mode 100644
index 0000000000000000000000000000000000000000..a1d005e30490a183e9cabcd33dd2e1ba435da40a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/src
@@ -0,0 +1 @@
+../../../src/
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/swig b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/swig
new file mode 100644
index 0000000000000000000000000000000000000000..e8211bd47f0efb06ec1ea05162db16228cf4c059
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/swig
@@ -0,0 +1 @@
+../../../swig/
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/swig.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/swig.py
new file mode 100644
index 0000000000000000000000000000000000000000..e00a83e64e2a9c0c4c022c89a57b1e0938b9ca3a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/amici/swig.py
@@ -0,0 +1,59 @@
+"""Functions for downloading/building/finding SWIG"""
+
+import sys
+import os
+import subprocess
+
+
+def find_swig():
+    """Get name of SWIG executable
+
+    We need version >=3.0. Probably we should try some default paths and names,
+    but this should do the trick for now.
+
+    Debian/Ubuntu systems have swig3.0 ('swig' is older versions),
+    OSX has swig 3.0 as 'swig'."""
+
+    candidates = ['swig4.0', 'swig3.0', 'swig']
+    # Environment variable has priority
+    if 'SWIG' in os.environ:
+        candidates.insert(0, os.environ['SWIG'])
+
+    for candidate in candidates:
+        if swig_works(candidate):
+            return candidate
+
+    raise RuntimeError("Unable to find SWIG executable with default names. "
+                       "Ensure you have SWIG installed, e.g. by "
+                       "`sudo apt install swig3.0` or `brew install swig`. "
+                       "As non-root user, you can install SWIG using "
+                       "https://github.com/ICB-DCM/AMICI/blob/master/scripts/"
+                       "downloadAndBuildSwig.sh, or by following the "
+                       "instructions at http://www.swig.org/Doc4.0/"
+                       "SWIGDocumentation.html#Preface_installation. "
+                       "If was not found despite being installed, set the SWIG"
+                       " environment variable to the full path of the correct "
+                       "executable.")
+
+
+def swig_works(swig, verbose = True):
+    """Test if `swig` looks like a working SWIG executable."""
+
+    try:
+        # For python3.6 compatibility no `capture_output=True`
+        result = subprocess.run([swig, '-version'],
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE)
+    except (FileNotFoundError, PermissionError):
+        if verbose:
+            print(f'Testing SWIG executable {swig}... FAILED.')
+        return False
+
+    if verbose:
+        if result.returncode == 0:
+            print(f'Testing SWIG executable {swig}... SUCCEEDED.')
+            print(result.stdout.decode('utf-8'))
+        else:
+            print(f'Testing SWIG executable {swig}... FAILED.')
+
+    return result.returncode == 0
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/bin b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/bin
new file mode 100644
index 0000000000000000000000000000000000000000..353d1e9f9ebd021a616fec107d22c6633754d475
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/bin
@@ -0,0 +1 @@
+../bin/
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/custom_commands.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/custom_commands.py
new file mode 100644
index 0000000000000000000000000000000000000000..6aee6a70e7dc26c615789535d5c13644978d7af5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/custom_commands.py
@@ -0,0 +1,230 @@
+"""Custom setuptools commands for AMICI installation"""
+
+import glob
+import os
+import sys
+import subprocess
+from shutil import copyfile
+
+from setuptools.command.build_ext import build_ext
+from setuptools.command.sdist import sdist
+from setuptools.command.install_lib import install_lib
+from setuptools.command.develop import develop
+from setuptools.command.install import install
+from setuptools.command.build_clib import build_clib
+
+from amici.setuptools import generateSwigInterfaceFiles
+
+
+class my_install(install):
+    """Custom install to handle extra arguments"""
+
+    # Passing --no-clibs allows to install the Python-only part of AMICI
+    user_options = install.user_options + [
+        ('no-clibs', None, "Don't build AMICI C++ extension"),
+    ]
+
+    def initialize_options(self):
+        install.initialize_options(self)
+        self.no_clibs = False
+
+    def finalize_options(self):
+        if self.no_clibs:
+            self.no_clibs = True
+        install.finalize_options(self)
+
+    def run(self):
+        install.run(self)
+
+
+def compile_parallel(self, sources, output_dir=None, macros=None,
+            include_dirs=None, debug=0, extra_preargs=None,
+            extra_postargs=None, depends=None):
+    """Parallelized version of distutils.ccompiler.compile"""
+    macros, objects, extra_postargs, pp_opts, build = \
+        self._setup_compile(output_dir, macros, include_dirs, sources,
+                            depends, extra_postargs)
+    cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
+
+    # parallel compilation
+    num_threads = 1
+    if 'AMICI_PARALLEL_COMPILE' in os.environ:
+        max_threads = int(os.environ['AMICI_PARALLEL_COMPILE'])
+        num_threads = min(len(objects), max_threads)
+        num_threads = max(1, num_threads)
+
+    def _single_compile(obj):
+        try:
+            src, ext = build[obj]
+        except KeyError:
+            return
+        self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
+
+    if num_threads > 1:
+        import multiprocessing.pool
+        # convert to list, imap is evaluated on-demand
+        list(multiprocessing.pool.ThreadPool(num_threads).imap(
+            _single_compile, objects))
+    else:
+        for obj in objects:
+            _single_compile(obj)
+
+    return objects
+
+
+class my_build_clib(build_clib):
+    """Custom build_clib"""
+
+    def build_libraries(self, libraries):
+        no_clibs = self.get_finalized_command('develop').no_clibs
+        no_clibs |= self.get_finalized_command('install').no_clibs
+
+        if no_clibs:
+            return
+
+        # Override for parallel compilation
+        import distutils.ccompiler
+        distutils.ccompiler.CCompiler.compile = compile_parallel
+
+        build_clib.build_libraries(self, libraries)
+
+
+class my_develop(develop):
+    """Custom develop to build clibs"""
+
+    # Passing --no-clibs allows to install the Python-only part of AMICI
+    user_options = develop.user_options + [
+        ('no-clibs', None, "Don't build AMICI C++ extension"),
+    ]
+
+    def initialize_options(self):
+        develop.initialize_options(self)
+        self.no_clibs = False
+
+    def finalize_options(self):
+        if self.no_clibs:
+            self.no_clibs = True
+        develop.finalize_options(self)
+
+    def run(self):
+        if not self.no_clibs:
+            generateSwigInterfaceFiles()
+            self.run_command('build')
+
+        develop.run(self)
+
+
+class my_install_lib(install_lib):
+    """Custom install to allow preserving of debug symbols"""
+    def run(self):
+        """strip debug symbols
+
+        Returns:
+
+        """
+        if 'ENABLE_AMICI_DEBUGGING' in os.environ \
+                and os.environ['ENABLE_AMICI_DEBUGGING'] == 'TRUE' \
+                and sys.platform == 'darwin':
+            search_dir = os.path.join(os.getcwd(),self.build_dir,'amici')
+            for file in os.listdir(search_dir):
+                if file.endswith('.so'):
+                    subprocess.run(['dsymutil',os.path.join(search_dir,file),
+                                    '-o',os.path.join(search_dir,file + '.dSYM')])
+
+
+        # Continue with the actual installation
+        install_lib.run(self)
+
+
+class my_build_ext(build_ext):
+    """Custom build_ext to allow keeping otherwise temporary static libs"""
+
+    def run(self):
+        """Copy the generated clibs to the extensions folder to be included in the wheel
+
+        Returns:
+
+        """
+        no_clibs = self.get_finalized_command('develop').no_clibs
+        no_clibs |= self.get_finalized_command('install').no_clibs
+
+        if no_clibs:
+            return
+
+        if not self.dry_run:  # --dry-run
+            libraries = []
+            build_clib = ''
+            if self.distribution.has_c_libraries():
+                # get the previously built static libraries
+                build_clib = self.get_finalized_command('build_clib')
+                libraries = build_clib.get_library_names() or []
+                library_dirs = build_clib.build_clib
+
+            # Module build directory where we want to copy the generated libs
+            # to
+            if self.inplace == 0:
+                build_dir = self.build_lib
+            else:
+                build_dir = os.getcwd()
+
+            target_dir = os.path.join(build_dir, 'amici', 'libs')
+            self.mkpath(target_dir)
+
+            # Copy the generated libs
+            for lib in libraries:
+                libfilenames = glob.glob(
+                    '%s%s*%s.*' % (build_clib.build_clib, os.sep, lib)
+                )
+                assert len(libfilenames) == 1, \
+                    "Found unexpected number of files: " % libfilenames
+
+                copyfile(libfilenames[0],
+                         os.path.join(target_dir, os.path.basename(libfilenames[0])))
+
+        # Continue with the actual extension building
+        build_ext.run(self)
+
+
+class my_sdist(sdist):
+    """Custom sdist to run swig and add the interface files to the source distribution
+
+    Could have relied on letting build_ext run swig. However, that would require any user having swig installed
+    during package installation. This way we can postpone that until the package is used to compile generated models.
+    """
+
+    def run(self):
+        """Setuptools entry-point
+
+        Returns:
+
+        """
+        self.runSwig()
+        self.saveGitVersion()
+        sdist.run(self)
+
+    def runSwig(self):
+        """Run swig
+
+        Returns:
+
+        """
+
+        if not self.dry_run:  # --dry-run
+            # We create two SWIG interfaces, one with HDF5 support, one without
+            generateSwigInterfaceFiles()
+
+    def saveGitVersion(self):
+        """Create file with extended version string
+
+        This requires git. We assume that whoever creates the sdist will work inside
+        a valid git repository.
+
+        Returns:
+
+        """
+        with open("amici/git_version.txt", "w") as f:
+            sp = subprocess.run(['git', 'describe',
+                                 '--abbrev=4', '--dirty=-dirty',
+                                 '--always', '--tags'],
+                                 stdout=f)
+        assert(sp.returncode == 0)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/setup.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba239f35345d6136da4e7c81fbbfb2e576dea4cc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/setup.py
@@ -0,0 +1,220 @@
+"""Setuptools file for creating AMICI module
+
+This file is based on setuptools alone and does not require CMake.
+All sources are compiled anew.
+
+This file expects to be run from within its directory.
+
+Requires:
+- swig3.0
+- setuptools
+- pkgconfig python+executables
+- hdf5 libraries and headers
+"""
+
+from setuptools import find_packages, setup, Extension
+
+import os
+import sys
+import sysconfig
+import subprocess
+import setup_clibs # Must run from within containing directory
+from custom_commands import (my_install, my_build_clib, my_develop,
+                             my_install_lib, my_build_ext, my_sdist)
+
+
+def try_install(package):
+    """Try installing the given package using pip. Exit on error."""
+    errno = subprocess.call([sys.executable, "-m", "pip", "install", package])
+    if errno:
+        print(f"Failed trying to install {package}. Please install manually.")
+        raise SystemExit(errno)
+
+
+try:
+    # required for include directory
+    import numpy as np
+except ImportError:
+    # We need numpy, but setup_requires fires too late
+    try_install('numpy')
+    # retry
+    import numpy as np
+
+
+sys.path.insert(0, os.getcwd())
+from amici import __version__
+
+from amici.setuptools import (
+    getBlasConfig,
+    getHdf5Config,
+    addCoverageFlagsIfRequired,
+    addDebugFlagsIfRequired,
+)
+
+# Python version check. We need >= 3.6 due to e.g. f-strings
+if sys.version_info < (3, 6):
+    sys.exit('amici requires at least Python version 3.6')
+
+
+def main():
+    # Extra compiler flags
+    cxx_flags = []
+    amici_module_linker_flags = []
+    define_macros = []
+
+    blaspkgcfg = getBlasConfig()
+    amici_module_linker_flags.extend(blaspkgcfg['extra_link_args'])
+    amici_module_linker_flags.extend(
+        '-l%s' % l for l in blaspkgcfg['libraries'])
+    define_macros.extend(blaspkgcfg['define_macros'])
+
+    h5pkgcfg = getHdf5Config()
+
+    if h5pkgcfg['found']:
+        # Manually add linker flags. The libraries passed to Extension will
+        # end up in front of the clibs in the linker line and not after, where
+        # they are required.
+        print("HDF5 library found. Building AMICI with HDF5 support.")
+        amici_module_linker_flags.extend(
+            ['-l%s' % l for l in
+             ['hdf5_hl_cpp', 'hdf5_hl', 'hdf5_cpp', 'hdf5']])
+        extension_sources = [
+            'amici/amici_wrap.cxx',  # swig interface
+        ]
+        define_macros.extend(h5pkgcfg['define_macros'])
+    else:
+        print("HDF5 library NOT found. Building AMICI WITHOUT HDF5 support.")
+        extension_sources = [
+            'amici/amici_wrap_without_hdf5.cxx',  # swig interface
+        ]
+
+    addCoverageFlagsIfRequired(
+        cxx_flags,
+        amici_module_linker_flags,
+    )
+
+    addDebugFlagsIfRequired(
+        cxx_flags,
+        amici_module_linker_flags,
+    )
+
+    # compiler and linker flags for libamici
+    if 'AMICI_CXXFLAGS' in os.environ:
+        cxx_flags.extend(os.environ['AMICI_CXXFLAGS'].split(' '))
+    if 'AMICI_LDFLAGS' in os.environ:
+        amici_module_linker_flags.extend(
+            os.environ['AMICI_LDFLAGS'].split(' '))
+
+    libamici = setup_clibs.getLibAmici(
+        h5pkgcfg=h5pkgcfg, blaspkgcfg=blaspkgcfg,
+        extra_compiler_flags=cxx_flags)
+    libsundials = setup_clibs.getLibSundials(extra_compiler_flags=cxx_flags)
+    libsuitesparse = setup_clibs.getLibSuiteSparse(
+        extra_compiler_flags=cxx_flags + ['-DDLONG']
+    )
+
+    # Build shared object
+    amici_module = Extension(
+        name='amici._amici',
+        sources=extension_sources,
+        include_dirs=['amici/include',
+                      'amici/ThirdParty/gsl/',
+                      *libsundials[1]['include_dirs'],
+                      *libsuitesparse[1]['include_dirs'],
+                      *h5pkgcfg['include_dirs'],
+                      *blaspkgcfg['include_dirs'],
+                      np.get_include()
+                      ],
+        # Cannot use here, see above
+        # libraries=[
+        #    'hdf5_hl_cpp', 'hdf5_hl', 'hdf5_cpp', 'hdf5'
+        # ],
+        define_macros=define_macros,
+        library_dirs=[
+            *h5pkgcfg['library_dirs'],
+            *blaspkgcfg['library_dirs'],
+            'amici/libs',  # clib target directory
+        ],
+        extra_compile_args=['-std=c++11', *cxx_flags],
+        extra_link_args=amici_module_linker_flags
+    )
+
+    # Readme as long package description to go on PyPi
+    # (https://pypi.org/project/amici/)
+    with open("README.md", "r", encoding="utf-8") as fh:
+        long_description = fh.read()
+
+    # Remove the "-Wstrict-prototypes" compiler option, which isn't valid for
+    # C++ to fix warnings.
+    cfg_vars = sysconfig.get_config_vars()
+    for key, value in cfg_vars.items():
+        if type(value) == str:
+            cfg_vars[key] = value.replace("-Wstrict-prototypes", "")
+
+    # Install
+    setup(
+        name='amici',
+        cmdclass={
+            'install': my_install,
+            'sdist': my_sdist,
+            'build_ext': my_build_ext,
+            'build_clib': my_build_clib,
+            'install_lib': my_install_lib,
+            'develop': my_develop,
+        },
+        version=__version__,
+        description='Advanced multi-language Interface to CVODES and IDAS (%s)',
+        long_description=long_description,
+        long_description_content_type="text/markdown",
+        url='https://github.com/ICB-DCM/AMICI',
+        author='Fabian Froehlich, Jan Hasenauer, Daniel Weindl and Paul Stapor',
+        author_email='fabian_froehlich@hms.harvard.edu',
+        license='BSD',
+        libraries=[libamici, libsundials, libsuitesparse],
+        ext_modules=[amici_module],
+        py_modules=['amici/amici',  # the swig interface
+                    'amici/amici_without_hdf5',   # the swig interface
+                    ],
+        packages=find_packages(),
+        package_dir={'amici': 'amici'},
+        scripts=['bin/amici_import_petab.py'],
+        install_requires=['sympy',
+                          'python-libsbml',
+                          'h5py',
+                          'pandas',
+                          'pkgconfig'],
+        setup_requires=['setuptools>=40.6.3'],
+        python_requires='>=3.6',
+        extras_require={'wurlitzer': ['wurlitzer'],
+                        'petab': ['petab>=0.0.0a14']},
+        package_data={
+            'amici': ['amici/include/amici/*',
+                      'src/*template*',
+                      'swig/*',
+                      'libs/*',
+                      'amici.py',
+                      'amici_without_hdf5.py',
+                      'setup.py.template',
+                      ],
+        },
+        zip_safe=False,
+        include_package_data=True,
+        exclude_package_data={
+            '': ['README.txt'],
+        },
+        test_suite="tests",
+        classifiers=[
+            'Development Status :: 5 - Production/Stable',
+            'Intended Audience :: Science/Research',
+            'License :: OSI Approved :: BSD License',
+            'Operating System :: POSIX :: Linux',
+            'Operating System :: MacOS :: MacOS X',
+            'Programming Language :: Python',
+            'Programming Language :: C++',
+            'Topic :: Scientific/Engineering :: Bio-Informatics',
+        ],
+    )
+
+
+if __name__ == '__main__':
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/setup_clibs.py b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/setup_clibs.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea33f37b693ef42c8ff56c2649cb21f7736d4898
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/setup_clibs.py
@@ -0,0 +1,240 @@
+"""Provides setuptools clibs for AMICI core, Sundials and SuiteSparse
+
+We could compile all source together into the AMICI base Python module,
+however we want to keep the static libs to avoid recompilation for AMICI-generated models.
+"""
+
+import os
+import glob
+import re
+
+
+def getSundialsSources():
+    """Get list of Sundials source files"""
+    srcs = [
+        os.path.join('src', 'sunmatrix', 'dense',   'sunmatrix_dense.c'),
+        os.path.join('src', 'sunmatrix', 'band',    'sunmatrix_band.c'),
+        os.path.join('src', 'sunmatrix', 'sparse',  'sunmatrix_sparse.c'),
+        os.path.join('src', 'sunlinsol', 'spgmr',   'sunlinsol_spgmr.c'),
+        os.path.join('src', 'sunlinsol', 'sptfqmr', 'sunlinsol_sptfqmr.c'),
+        os.path.join('src', 'sunlinsol', 'klu',     'sunlinsol_klu.c'),
+        os.path.join('src', 'sunlinsol', 'dense',   'sunlinsol_dense.c'),
+        os.path.join('src', 'sunlinsol', 'spfgmr',  'sunlinsol_spfgmr.c'),
+        os.path.join('src', 'sunlinsol', 'pcg',     'sunlinsol_pcg.c'),
+        os.path.join('src', 'sunlinsol', 'spbcgs',  'sunlinsol_spbcgs.c'),
+        os.path.join('src', 'sunlinsol', 'band',    'sunlinsol_band.c'),
+        os.path.join('src', 'idas', 'idas_direct.c'),
+        os.path.join('src', 'idas', 'idaa.c'),
+        os.path.join('src', 'idas', 'idas_ic.c'),
+        os.path.join('src', 'idas', 'idas_nls_stg.c'),
+        os.path.join('src', 'idas', 'idas.c'),
+        os.path.join('src', 'idas', 'idas_bbdpre.c'),
+        os.path.join('src', 'idas', 'idas_spils.c'),
+        os.path.join('src', 'idas', 'idas_nls.c'),
+        os.path.join('src', 'idas', 'idas_ls.c'),
+        os.path.join('src', 'idas', 'idas_io.c'),
+        os.path.join('src', 'idas', 'idas_nls_sim.c'),
+        os.path.join('src', 'idas', 'idaa_io.c'),
+        os.path.join('src', 'sundials', 'sundials_math.c'),
+        os.path.join('src', 'sundials', 'sundials_mpi.c'),
+        os.path.join('src', 'sundials', 'sundials_sptfqmr.c'),
+        os.path.join('src', 'sundials', 'sundials_matrix.c'),
+        os.path.join('src', 'sundials', 'sundials_pcg.c'),
+        os.path.join('src', 'sundials', 'sundials_direct.c'),
+        os.path.join('src', 'sundials', 'sundials_spgmr.c'),
+        os.path.join('src', 'sundials', 'sundials_spbcgs.c'),
+        os.path.join('src', 'sundials', 'sundials_nvector_senswrapper.c'),
+        os.path.join('src', 'sundials', 'sundials_dense.c'),
+        os.path.join('src', 'sundials', 'sundials_nvector.c'),
+        os.path.join('src', 'sundials', 'sundials_version.c'),
+        os.path.join('src', 'sundials', 'sundials_spfgmr.c'),
+        os.path.join('src', 'sundials', 'sundials_sparse.c'),
+        os.path.join('src', 'sundials', 'sundials_iterative.c'),
+        os.path.join('src', 'sundials', 'sundials_nonlinearsolver.c'),
+        os.path.join('src', 'sundials', 'sundials_linearsolver.c'),
+        os.path.join('src', 'sundials', 'sundials_band.c'),
+        os.path.join('src', 'sunnonlinsol', 'newton', 'sunnonlinsol_newton.c'),
+        os.path.join('src', 'sunnonlinsol', 'fixedpoint',
+                     'sunnonlinsol_fixedpoint.c'),
+        os.path.join('src', 'nvector', 'serial', 'nvector_serial.c'),
+        os.path.join('src', 'cvodes', 'cvodes_spils.c'),
+        os.path.join('src', 'cvodes', 'cvodes_nls_stg.c'),
+        os.path.join('src', 'cvodes', 'cvodes_ls.c'),
+        os.path.join('src', 'cvodes', 'cvodes_nls_stg1.c'),
+        os.path.join('src', 'cvodes', 'cvodes_bbdpre.c'),
+        os.path.join('src', 'cvodes', 'cvodes.c'),
+        os.path.join('src', 'cvodes', 'cvodes_bandpre.c'),
+        os.path.join('src', 'cvodes', 'cvodea.c'),
+        os.path.join('src', 'cvodes', 'cvodes_nls_sim.c'),
+        os.path.join('src', 'cvodes', 'cvodea_io.c'),
+        os.path.join('src', 'cvodes', 'cvodes_nls.c'),
+        os.path.join('src', 'cvodes', 'cvodes_diag.c'),
+        os.path.join('src', 'cvodes', 'cvodes_io.c'),
+        os.path.join('src', 'cvodes', 'cvodes_direct.c')
+    ]
+    return [os.path.join('amici', 'ThirdParty', 'sundials', src) for src in srcs]
+
+
+def getSuiteSparseSources():
+    """Get list of SuiteSparse source files"""
+    srcs = [
+        os.path.join('KLU', 'Source', 'klu_analyze_given.c'),
+        os.path.join('KLU', 'Source', 'klu_analyze.c'),
+        os.path.join('KLU', 'Source', 'klu_defaults.c'),
+        os.path.join('KLU', 'Source', 'klu_diagnostics.c'),
+        os.path.join('KLU', 'Source', 'klu_dump.c'),
+        os.path.join('KLU', 'Source', 'klu_extract.c'),
+        os.path.join('KLU', 'Source', 'klu_factor.c'),
+        os.path.join('KLU', 'Source', 'klu_free_numeric.c'),
+        os.path.join('KLU', 'Source', 'klu_free_symbolic.c'),
+        os.path.join('KLU', 'Source', 'klu_kernel.c'),
+        os.path.join('KLU', 'Source', 'klu_memory.c'),
+        os.path.join('KLU', 'Source', 'klu_refactor.c'),
+        os.path.join('KLU', 'Source', 'klu_scale.c'),
+        os.path.join('KLU', 'Source', 'klu_sort.c'),
+        os.path.join('KLU', 'Source', 'klu_solve.c'),
+        os.path.join('KLU', 'Source', 'klu_tsolve.c'),
+        os.path.join('KLU', 'Source', 'klu.c'),
+        os.path.join('AMD', 'Source', 'amd_1.c'),
+        os.path.join('AMD', 'Source', 'amd_2.c'),
+        os.path.join('AMD', 'Source', 'amd_aat.c'),
+        os.path.join('AMD', 'Source', 'amd_control.c'),
+        os.path.join('AMD', 'Source', 'amd_defaults.c'),
+        os.path.join('AMD', 'Source', 'amd_dump.c'),
+        os.path.join('AMD', 'Source', 'amd_global.c'),
+        os.path.join('AMD', 'Source', 'amd_info.c'),
+        os.path.join('AMD', 'Source', 'amd_order.c'),
+        os.path.join('AMD', 'Source', 'amd_post_tree.c'),
+        os.path.join('AMD', 'Source', 'amd_postorder.c'),
+        os.path.join('AMD', 'Source', 'amd_preprocess.c'),
+        os.path.join('AMD', 'Source', 'amd_valid.c'),
+        os.path.join('COLAMD', 'Source', 'colamd.c'),
+        os.path.join('BTF', 'Source', 'btf_maxtrans.c'),
+        os.path.join('BTF', 'Source', 'btf_order.c'),
+        os.path.join('BTF', 'Source', 'btf_strongcomp.c'),
+        os.path.join('SuiteSparse_config', 'SuiteSparse_config.c'),
+    ]
+    return [os.path.join('amici', 'ThirdParty', 'SuiteSparse', src) for src in srcs]
+
+
+def getAmiciBaseSources(withHDF5=True):
+    """Get list of source files for the amici base library
+
+    Expects that we are inside $AMICI_ROOT/python/sdist
+
+    Arguments:
+        withHDF5: compile with HDF5 support
+    """
+
+    amiciBaseSources = glob.glob('amici{s}src{s}*.cpp'.format(s=os.sep))
+    amiciBaseSources = [src for src in amiciBaseSources if not re.search(
+        r'(matlab)|(\.template\.)', src)]
+
+    if not withHDF5:
+        try:
+            # sometimes this fails for unknwon reasons...
+            amiciBaseSources.remove('amici{s}src{s}hdf5.cpp'.format(s=os.sep))
+        except ValueError:
+            print('Warning: could not find %s in %s' % ('amici{s}src{s}hdf5.cpp'.format(s=os.sep),
+                                                        amiciBaseSources))
+
+    return amiciBaseSources
+
+
+def getLibSundials(extra_compiler_flags=None):
+    """Get sundials library build info for setuptools
+
+    Arguments:
+        extra_compiler_flags: Extra compiler flags
+    """
+    if extra_compiler_flags is None:
+        extra_compiler_flags = []
+
+    libsundials = ('sundials', {
+        'sources': getSundialsSources(),
+        'include_dirs': ['amici/ThirdParty/sundials/include',
+                         'amici/ThirdParty/sundials/src',
+                         'amici/ThirdParty/SuiteSparse/KLU/Include/',
+                         'amici/ThirdParty/SuiteSparse/AMD/Include/',
+                         'amici/ThirdParty/SuiteSparse/COLAMD/Include/',
+                         'amici/ThirdParty/SuiteSparse/BTF/Include/',
+                         'amici/ThirdParty/SuiteSparse/SuiteSparse_config',
+                         'amici/ThirdParty/SuiteSparse/include'],
+        'cflags': ['-Wno-misleading-indentation', *extra_compiler_flags]
+    })
+    return libsundials
+
+
+def getLibSuiteSparse(extra_compiler_flags=None):
+    """Get SuiteSparse library build info for setuptools
+
+    Arguments:
+        extra_compiler_flags: Extra compiler flags
+    """
+    if extra_compiler_flags is None:
+        extra_compiler_flags = []
+
+    libsuitesparse = ('suitesparse', {
+        'sources': getSuiteSparseSources(),
+        'include_dirs': ['amici/ThirdParty/SuiteSparse/KLU/Include/',
+                         'amici/ThirdParty/SuiteSparse/AMD/Include/',
+                         'amici/ThirdParty/SuiteSparse/COLAMD/Include/',
+                         'amici/ThirdParty/SuiteSparse/BTF/Include/',
+                         'amici/ThirdParty/SuiteSparse/SuiteSparse_config',
+                         'amici/ThirdParty/SuiteSparse/include'
+                         ],
+        'cflags': ['-Wno-unused-but-set-variable', *extra_compiler_flags]
+
+    })
+    return libsuitesparse
+
+
+def getLibAmici(extra_compiler_flags=None, h5pkgcfg=None, blaspkgcfg=None):
+    """Get AMICI core library build info for setuptools
+
+    Arguments:
+        extra_compiler_flags: Extra compiler flags
+        h5pkgcfg:  hdf5 package info
+        blaspkgcfg: blas package info
+    """
+
+    if extra_compiler_flags is None:
+        extra_compiler_flags = []
+
+    libamici = ('amici', {
+        'sources': getAmiciBaseSources(
+            withHDF5=(h5pkgcfg
+                      and 'include_dirs' in h5pkgcfg
+                      and h5pkgcfg['include_dirs'])
+            ),
+        'include_dirs': ['amici/include',
+                         'amici/ThirdParty/SuiteSparse/KLU/Include/',
+                         'amici/ThirdParty/SuiteSparse/AMD/Include/',
+                         'amici/ThirdParty/SuiteSparse/COLAMD/Include/',
+                         'amici/ThirdParty/SuiteSparse/BTF/Include/',
+                         'amici/ThirdParty/SuiteSparse/SuiteSparse_config/',
+                         'amici/ThirdParty/SuiteSparse/include',
+                         'amici/ThirdParty/sundials/include',
+                         'amici/ThirdParty/sundials/src',
+                         'amici/ThirdParty/gsl/',
+                         ],
+        'cflags': ['-std=c++11', *extra_compiler_flags],
+        'macros': [],
+    })
+
+    if h5pkgcfg and 'include_dirs' in h5pkgcfg:
+        libamici[1]['include_dirs'].extend(h5pkgcfg['include_dirs'])
+
+    if h5pkgcfg and 'define_macros' in h5pkgcfg:
+        libamici[1]['macros'].extend(h5pkgcfg['define_macros'])
+
+    if blaspkgcfg and 'include_dirs' in blaspkgcfg:
+        libamici[1]['include_dirs'].extend(blaspkgcfg['include_dirs'])
+
+    if blaspkgcfg and 'define_macros' in blaspkgcfg:
+        libamici[1]['macros'].extend(blaspkgcfg['define_macros'])
+
+    if blaspkgcfg and 'extra_compile_args' in blaspkgcfg:
+        libamici[1]['cflags'].extend(blaspkgcfg['extra_compile_args'])
+
+    return libamici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/version.txt b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/version.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7fa4c866fa1b105c767af9bda6d51e88b14bffb9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/python/sdist/version.txt
@@ -0,0 +1 @@
+../../version.txt
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/README.md b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..136104b17479de2c2b22e120109cf54c5d762693
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/README.md
@@ -0,0 +1,129 @@
+# Contents of `scripts/`
+
+This directory contains a number of build, installation, and CI scripts. 
+
+* `buildAll.sh`
+   
+   Build AMICI along with dependencies and test suite
+
+* `buildAmici.sh`
+
+   Build AMICI library and test models
+
+* `buildBNGL.sh`
+
+   Download nad build 
+   [BioNetGen](https://www.csb.pitt.edu/Faculty/Faeder/?page_id=409) (required for some tests)
+
+* `buildCpputest.sh`
+
+   Download and build [CppUTest](https://cpputest.github.io/)
+   (required for C++ test suite)
+
+* `buildModel.sh`
+
+   @review: is this used anywhere?
+   
+* `buildSuiteSparse.sh`
+
+   Build [SuiteSparse](http://faculty.cse.tamu.edu/davis/suitesparse.html)
+   included in this repository
+   
+* `buildSundials.sh`
+
+   Build [Sundials](https://computation.llnl.gov/projects/sundials/)
+   included in this repository
+
+* `buildSuperLUMT.sh`
+
+   Download and build the SuperLU-MT solver. Required to build CVODES/AMICI
+   with SuperLU-MT support.
+
+* `buildValgrind.sh`
+
+   Download and build [Valgrind](http://valgrind.org/).
+   This is used if Valgrind versions provided by homebrew or apt are buggy.
+
+* `buildXcode.sh`
+
+   Build AMICI and C++ test models and test with XCode
+
+* `deployPyPi.sh`
+
+  Script for PyPi deployment (currently unused)
+
+* `downloadAndBuildSwig.sh`
+
+  Download and build [SWIG](http://www.swig.org/) 
+
+* `doxyfilter_python.py`
+
+  Doxygen input filter for Python used for generating documentation.
+
+
+* `installAmiciArchive.sh`
+
+  Create a Python virtual environment and do an AMICI development installation
+
+* `installAmiciSource.sh`
+  
+  Create a Python virtual environment and do a regular AMICI installation
+
+
+* `py_filter`
+
+  Doxygen filter file for Python
+
+* `run-codecov.sh`
+
+  Script for Python test code coverage analysis
+
+* `run-cppcheck.sh`
+
+  Run static code analysis
+
+* `run-cpputest.sh`
+
+  Run C++ unit and integration tests
+
+* `run-doxygen.sh`
+
+  Run doxygen to create AMICI documentation
+
+* `runNotebook.sh`
+
+  Script for running Jupyter notebooks from the command line. Used for CI
+  to ensure functioning notebooks.
+
+* `run-python-tests.sh`
+
+  Run the AMICI Python test suite
+
+* `run-SBMLTestsuite.sh`
+
+  Download and run the semantic 
+  [SBML Test Suite](https://github.com/sbmlteam/sbml-test-suite/)
+
+* `run-valgrind.sh`
+
+  Run memory leak check using valgrind for all unit and integration tests.
+  Assumes they have been built before in the default location. 
+
+* `travis_wrap.sh`
+
+  Wrapper script for Travis CI to enable output folding in Travis CI logs
+  
+
+## Unused
+
+* `patch-hdf5.sh`, `hdf5-1.8.7-mingw.patch`
+
+  Probably outdated HDF5 patch for Windows
+
+* `build-mingw.ps1`
+
+  Outdated Windows build script
+
+* `build-msvs.ps1`
+
+  Outdated Windows build script
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/build-mingw.ps1 b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/build-mingw.ps1
new file mode 100644
index 0000000000000000000000000000000000000000..73c1d8ef649357d17910e07a0386e1d6f1902ee3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/build-mingw.ps1
@@ -0,0 +1,64 @@
+cd .\SuiteSparse\SuiteSparse_config
+
+mingw32-make library -e CC="gcc"
+
+cd .\..\AMD
+
+mingw32-make library -e CC="gcc" 
+
+cd .\..\BTF
+
+mingw32-make library -e CC="gcc" 
+
+cd .\..\CAMD
+
+mingw32-make library -e CC="gcc" 
+
+cd .\..\COLAMD
+
+mingw32-make library -e CC="gcc"  
+
+cd .\..\KLU
+
+mingw32-make library -e CC="gcc" 
+
+mkdir .\..\..\sundials\build\
+cd .\..\..\sundials\build\
+
+$envPaths = $env:Path -split ';'
+
+if ($envPaths -contains 'C:\Program Files\Git\usr\bin') {
+    $envPaths = $envPaths | where { $_ -and $_ -ne 'C:\Program Files\Git\usr\bin' }
+    $env:Path = $envPaths -join ';'
+}
+
+cmake .. -DCMAKE_INSTALL_PREFIX="C:/projects/amici/build/sundials" `
+-DBUILD_ARKODE=OFF `
+-DBUILD_CVODE=OFF `
+-DBUILD_IDA=OFF `
+-DBUILD_KINSOL=OFF `
+-DBUILD_SHARED_LIBS=OFF `
+-DBUILD_STATIC_LIBS=ON `
+-DEXAMPLES_ENABLE=OFF `
+-DEXAMPLES_INSTALL=OFF `
+-DKLU_ENABLE=ON `
+-DKLU_LIBRARY_DIR="C:/projects/amici/SuiteSparse/lib" `
+-DKLU_INCLUDE_DIR="C:/projects/amici/SuiteSparse/include" `
+-G "MinGW Makefiles"
+
+mingw32-make
+mingw32-make install
+
+cd ..\..
+
+cmake CMakeLists.txt `
+-DHDF5_DIR="C:/Program Files/HDF_Group/HDF5/1.8.17/cmake" `
+-DCMAKE_VERBOSE_MAKEFILE=ON `
+-G "MinGW Makefiles"
+
+mingw32-make 
+
+if ( (Test-Path ".\model_dirac.exe") -eq $false)
+{
+	throw "build unsuccessfull, model_dirac failed to compile!"
+}
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/build-msvs.ps1 b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/build-msvs.ps1
new file mode 100644
index 0000000000000000000000000000000000000000..5532708a6805479dd720de7fba64a4e0c3e198d1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/build-msvs.ps1
@@ -0,0 +1,59 @@
+cd .\SuiteSparse\SuiteSparse_config
+
+nmake library -e CC="gcc"
+
+cd .\..\AMD
+
+$CurrentDir = $(get-location).Path;
+
+nmake library -e CC="gcc" 
+
+cd .\..\BTF
+
+nmake library -e CC="gcc" 
+
+cd .\..\CAMD
+
+nmake library -e CC="gcc" 
+
+cd .\..\COLAMD
+
+nmake library -e CC="gcc"  
+
+cd .\..\KLU
+
+nmake library -e CC="gcc" 
+
+
+mkdir .\..\..\sundials\build\
+cd .\..\..\sundials\build\
+
+ls C:\projects\amici\SuiteSparse\lib
+
+cmake .. -DCMAKE_INSTALL_PREFIX="C:/projects/amici/build/sundials" `
+-DBUILD_ARKODE=OFF `
+-DBUILD_CVODE=OFF `
+-DBUILD_IDA=OFF `
+-DBUILD_KINSOL=OFF `
+-DBUILD_SHARED_LIBS=ON `
+-DBUILD_STATIC_LIBS=OFF `
+-DEXAMPLES_ENABLE=OFF `
+-DEXAMPLES_INSTALL=OFF `
+-DKLU_ENABLE=ON `
+-DKLU_LIBRARY_DIR="C:/projects/amici/SuiteSparse/lib" `
+-DKLU_INCLUDE_DIR="C:/projects/amici/SuiteSparse/include" `
+
+msbuild ALL BUILD.vcxproj
+msbuild INSTALL.vcxproj
+
+cd ..\..
+
+cmake CMakeLists.txt
+msbuild model_dirac.vcxproj
+
+ls
+
+if ( (Test-Path ".\main.exe") -eq $false)
+{
+	throw "build unsuccessfull, model_dirac failed to compile!"
+}
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildAll.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildAll.sh
new file mode 100644
index 0000000000000000000000000000000000000000..78d19b8b5916bbef5934fe29061f11734b112c62
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildAll.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+#
+# Build AMICI along with dependencies and test suite
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+SCRIPT_PATH=$(cd $SCRIPT_PATH && pwd)
+
+${SCRIPT_PATH}/buildSuiteSparse.sh
+${SCRIPT_PATH}/buildSundials.sh
+${SCRIPT_PATH}/buildCpputest.sh
+${SCRIPT_PATH}/buildBNGL.sh
+${SCRIPT_PATH}/buildAmici.sh
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildAmici.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildAmici.sh
new file mode 100644
index 0000000000000000000000000000000000000000..82d9e7b084063717891f952604e4b24cdaaddfbc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildAmici.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+#
+# Build libamici
+#
+set -e
+CMAKE=${CMAKE:-cmake}
+MAKE=${MAKE:-make}
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+mkdir -p ${AMICI_PATH}/build
+cd ${AMICI_PATH}/build
+CPPUTEST_BUILD_DIR=${AMICI_PATH}/ThirdParty/cpputest-master/build/
+CppUTest_DIR=${CPPUTEST_BUILD_DIR} ${CMAKE} -DCMAKE_BUILD_TYPE=Debug ..
+${MAKE}
+
+${MAKE} python-sdist
+set -x
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildBNGL.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildBNGL.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ce36921c00bd24e38a6ffcfe7dd638448dcf7f47
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildBNGL.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+#
+# Build BNGL (required for pysb)
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+mkdir -p ${AMICI_PATH}/ThirdParty
+cd ${AMICI_PATH}/ThirdParty
+
+if [ ! -d "BioNetGen-2.3.2" ]; then
+    if [ ! -e "bionetgen.tar.gz" ]; then
+        if [[ "$OSTYPE" == "linux-gnu" || "$OSTYPE" == "linux" ]]; then
+            wget -q -O bionetgen.tar.gz https://bintray.com/jczech/bionetgen/download_file?file_path=BioNetGen-2.3.2-linux.tar.gz
+        elif [[ "$OSTYPE" == "darwin"* ]]; then
+            wget -q -O bionetgen.tar.gz https://bintray.com/jczech/bionetgen/download_file?file_path=BioNetGen-2.3.2-osx.tar.gz
+        fi
+    fi
+    tar -xzf bionetgen.tar.gz
+fi
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildCpputest.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildCpputest.sh
new file mode 100644
index 0000000000000000000000000000000000000000..cee5f0b14985dec20fb25f0f13148ce00cfd7981
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildCpputest.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+#
+# Build CppUTest
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+CMAKE=${CMAKE:-cmake}
+MAKE=${MAKE:-make}
+
+# Cpputest
+mkdir -p ${AMICI_PATH}/ThirdParty
+cd ${AMICI_PATH}/ThirdParty
+export CPPUTEST_BUILD_DIR=${AMICI_PATH}/ThirdParty/cpputest-master/
+
+if [ ! -d "cpputest-master" ]; then
+    if [ ! -e "cpputest-master.zip" ]; then
+        wget -q -O cpputest-master.zip https://codeload.github.com/cpputest/cpputest/zip/master
+    fi
+    unzip -q cpputest-master.zip
+    #cd cpputest-master/ && ./autogen.sh && ./configure && make
+fi
+
+cd cpputest-master
+mkdir -p build
+cd build
+${CMAKE} -DTESTS=OFF -DBUILD_TESTING=OFF -DCMAKE_BUILD_TYPE=Release -DC++11=ON -DMEMORY_LEAK_DETECTION=OFF ..
+${MAKE} -j4
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildModel.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildModel.sh
new file mode 100644
index 0000000000000000000000000000000000000000..617c962fd0193be7888ce61e43cb7689939c9b4c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildModel.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+#
+# Build amici tests
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+CMAKE=${CMAKE:-cmake}
+MAKE=${MAKE:-make}
+
+mkdir -p ${AMICI_PATH}/models/$1/build
+cd ${AMICI_PATH}/models/$1/build
+${CMAKE} -DCMAKE_CXX_STANDARD=11 -DCMAKE_CXX_STANDARD_REQUIRED=ON -DCMAKE_BUILD_TYPE=Release ..
+${MAKE}
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSuiteSparse.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSuiteSparse.sh
new file mode 100644
index 0000000000000000000000000000000000000000..de7ce6db79194d41b7fff985ac2790fef36e6913
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSuiteSparse.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+#
+# Build SuiteSpare
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+SUITESPARSE_ROOT="${AMICI_PATH}/ThirdParty/SuiteSparse"
+
+for subdir in SuiteSparse_config BTF AMD CAMD COLAMD KLU
+  do cd ${SUITESPARSE_ROOT}/${subdir} && make library
+done
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSundials.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSundials.sh
new file mode 100644
index 0000000000000000000000000000000000000000..173e7c7b33ab53f2fc1f81bba8deb3a4fcba517c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSundials.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# Build Sundials
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+SUITESPARSE_ROOT="${AMICI_PATH}/ThirdParty/SuiteSparse"
+SUNDIALS_BUILD_PATH="${AMICI_PATH}/ThirdParty/sundials/build/"
+
+CMAKE=${CMAKE:-cmake}
+MAKE=${MAKE:-make}
+
+# enable SuperLUMT support if library exists
+SuperLUMT=""
+if [[ -f ${AMICI_PATH}/ThirdParty/SuperLU_MT_3.1/lib/libsuperlu_mt_PTHREAD.a ]]
+then
+    SuperLUMT="-DSUPERLUMT_ENABLE=ON -DBLAS_ENABLE=ON \
+         -DSUPERLUMT_INCLUDE_DIR=${AMICI_PATH}/ThirdParty/SuperLU_MT_3.1/SRC/ \
+         -DSUPERLUMT_LIBRARY_DIR=${AMICI_PATH}/ThirdParty/SuperLU_MT_3.1/lib/"
+fi
+
+mkdir -p ${SUNDIALS_BUILD_PATH}
+cd ${SUNDIALS_BUILD_PATH}
+
+${CMAKE} -DCMAKE_INSTALL_PREFIX="${SUNDIALS_BUILD_PATH}" \
+-DCMAKE_BUILD_TYPE=Debug \
+-DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+-DBUILD_ARKODE=OFF \
+-DBUILD_CVODE=OFF \
+-DBUILD_IDA=OFF \
+-DBUILD_KINSOL=OFF \
+-DBUILD_SHARED_LIBS=ON \
+-DBUILD_STATIC_LIBS=ON \
+-DEXAMPLES_ENABLE_C=OFF \
+-DEXAMPLES_INSTALL=OFF \
+-DKLU_ENABLE=ON \
+-DKLU_LIBRARY_DIR="${SUITESPARSE_ROOT}/lib" \
+-DKLU_INCLUDE_DIR="${SUITESPARSE_ROOT}/include" \
+${SuperLUMT} \
+..
+
+${MAKE}
+${MAKE} install
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSuperLUMT.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSuperLUMT.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0164a7af89ea68fa530810cd68fdac2995bcb806
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildSuperLUMT.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+#
+# Build SuperLUMT
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd ${SCRIPT_PATH}/.. && pwd)
+
+cd ${AMICI_PATH}/ThirdParty
+
+if [[ ! -d SuperLU_MT_3.1 ]]; then
+    if [[ ! -f superlu_mt_3.1.tar.gz ]]; then
+        wget https://crd-legacy.lbl.gov/~xiaoye/SuperLU/superlu_mt_3.1.tar.gz
+    fi
+    tar -xzf superlu_mt_3.1.tar.gz SuperLU_MT_3.1/
+fi
+
+cd SuperLU_MT_3.1/
+# interferes with std::queue
+test -f SRC/queue && mv SRC/queue SRC/queue.bak
+cp MAKE_INC/make.pthread make.inc
+# Add -fPIC
+sed -ri 's/(CFLAGS\W*=\W*.*)(\#.*)/\1-fPIC \2/' make.inc
+# Use 64bit integers
+sed -ri 's/# (CFLAGS\W*+=.*-D_LONGINT.*)/\1/' make.inc
+sed -ri 's/# (FFLAGS\W*+=.*-fdefault-integer-8.*)/\1/' make.inc
+
+make superlulib
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildValgrind.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildValgrind.sh
new file mode 100644
index 0000000000000000000000000000000000000000..951817d88789cc425bbda67f9feaa8caeef0c17e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildValgrind.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+#
+# Build Valgrind
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+# Valgrind
+mkdir -p ${AMICI_PATH}/ThirdParty
+cd ${AMICI_PATH}/ThirdParty
+
+if [ ! -d "valgrind-3.14.0" ]; then
+    if [ ! -e "valgrind.tar.bz2" ]; then
+        wget -q -O valgrind-3.14.0.tar.bz2 http://www.valgrind.org/downloads/valgrind-3.14.0.tar.bz2
+    fi
+    tar xjf valgrind-3.14.0.tar.bz2
+fi
+
+cd valgrind-3.14.0
+./configure
+make
+sudo make install
+cd ..
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildXcode.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildXcode.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d78edde4bd40f948ccf06b9f97d3ec65ff7bc832
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/buildXcode.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+#
+# Build amici tests
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+CMAKE=${CMAKE:-cmake}
+
+${AMICI_PATH}/scripts/buildSuiteSparse.sh
+${AMICI_PATH}/scripts/buildSundials.sh
+${AMICI_PATH}/scripts/buildAmici.sh
+${AMICI_PATH}/scripts/buildCpputest.sh
+
+
+cp ${AMICI_PATH}/tests/cpputest/expectedResults.h5 ./expectedResults.h5
+
+mkdir -p ${AMICI_PATH}/build_xcode
+cd ${AMICI_PATH}/build_xcode
+CPPUTEST_BUILD_DIR=${AMICI_PATH}/ThirdParty/cpputest-master/build/
+CppUTest_DIR=${CPPUTEST_BUILD_DIR} ${CMAKE} -G"Xcode" -DCMAKE_BUILD_TYPE=Debug ..
+
+for model in steadystate robertson neuron neuron_o2 jakstat_adjoint jakstat_adjoint_o2 dirac events nested_events
+do
+    cp ${AMICI_PATH}/build/tests/cpputest/external_model_${model}-prefix/src/external_model_${model}-build/libmodel_${model}.a \
+       ${AMICI_PATH}/build_xcode/tests/cpputest/external_model_${model}-prefix/src/external_model_${model}-build/libmodel_${model}.a
+done
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/deployPyPi.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/deployPyPi.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5bbd7cdd1bd55cc6064e91e94420df3f4a73f526
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/deployPyPi.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+#
+# Deploy amici to pypi
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+pip3 install twine
+# in case we are running with pyenv, we need to update pyenv shims after installing packages with binaries
+if [[ -n "${PYENV_VERSION}" ]]; then
+    pyenv rehash
+fi
+
+# authentication via env variables set in travis
+twine upload $(ls -t ${AMICI_PATH}/build/python/amici-*.tar.gz | head -1)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/downloadAndBuildSwig.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/downloadAndBuildSwig.sh
new file mode 100644
index 0000000000000000000000000000000000000000..83dd5305d0414ac76ff5ff52df7874a52bb12035
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/downloadAndBuildSwig.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Download and build SWIG
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+SWIG_URL='http://prdownloads.sourceforge.net/swig/swig-4.0.0.tar.gz'
+SWIG_ARCHIVE='swig-4.0.0.tar.gz'
+SWIG_DIR='swig-4.0.0'
+PREFIX=${AMICI_PATH}/ThirdParty/${SWIG_DIR}/install
+SWIG_BIN_DIR=${PREFIX}/bin
+
+cd ${AMICI_PATH}/ThirdParty/
+
+if [[ ! -d ${SWIG_DIR} ]]; then
+    if [[ ! -f ${SWIG_ARCHIVE} ]]
+        then wget ${SWIG_URL}
+    fi
+
+    tar -xzf ${SWIG_ARCHIVE}
+fi
+
+cd ${SWIG_DIR}
+./configure --prefix=${PREFIX}
+make
+make install
+
+echo
+echo "================"
+echo "SWIG installation successful"
+echo
+echo "To use this version of SWIG, add directory ${SWIG_BIN_DIR} to your PATH,"
+echo "e.g. adding the following line to your .bashrc:"
+echo "    export PATH=\$PATH:${SWIG_BIN_DIR}"
+echo "================"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/hdf5-1.8.7-mingw.patch b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/hdf5-1.8.7-mingw.patch
new file mode 100644
index 0000000000000000000000000000000000000000..e33994437d53696480294bf02dcbf81ecf7667d8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/hdf5-1.8.7-mingw.patch
@@ -0,0 +1,24 @@
+diff --git a/c:/Users/sharpie/Downloads/HDF5-1.8.7_win_x86/include/H5public.h b/c:/swarm/include/H5public.h
+index fc7c570..c55a9d7 100644
+--- a/include/H5public.h
++++ b/include/H5public.h
+@@ -125,6 +125,11 @@ typedef int herr_t;
+ typedef unsigned int hbool_t;
+ typedef int htri_t;
+ 
++
++/* Contrary to popular belief, MinGW **does** define ssize_t */
++#ifdef __MINGW32__
++#  define H5_SIZEOF_SSIZE_T H5_SIZEOF_LONG
++#else
+ /* Define the ssize_t type if it not is defined */
+ #if H5_SIZEOF_SSIZE_T==0
+ /* Undefine this size, we will re-define it in one of the sections below */
+@@ -142,6 +147,7 @@ typedef long long ssize_t;
+ #   error "nothing appropriate for ssize_t"
+ #endif
+ #endif
++#endif
+ 
+ /*
+  * The sizes of file objects have their own types defined here, use a 64-bit
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/installAmiciArchive.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/installAmiciArchive.sh
new file mode 100644
index 0000000000000000000000000000000000000000..80995681bc679ef623480081031463dc2eac71c4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/installAmiciArchive.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+#
+# Build libamici
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+# Disabled until cmake package is made compatible with updated setup.py
+#make python-wheel
+#pip3 install --user --prefix= `ls -t ${AMICI_PATH}/build/python/amici-*.whl | head -1`
+
+rm -f ${AMICI_PATH}/python/sdist/amici/*.cxx
+rm -f ${AMICI_PATH}/python/sdist/amici/*.so
+rm -f ${AMICI_PATH}/python/sdist/amici/amici.py
+rm -f ${AMICI_PATH}/python/sdist/amici/amici_without_hdf5.py
+
+# test install from archive
+set +e
+python3 -m venv ${AMICI_PATH}/build/venvArchive --clear
+# in case this fails (usually due to missing ensurepip, try getting pip
+# manually
+if [[ $? ]]; then
+    set -e
+    python3 -m venv ${AMICI_PATH}/build/venvArchive --clear --without-pip
+    source ${AMICI_PATH}/build/venvArchive/bin/activate
+    curl https://bootstrap.pypa.io/get-pip.py -o ${AMICI_PATH}/build/get-pip.py
+    python ${AMICI_PATH}/build/get-pip.py
+else
+    set -e
+    source ${AMICI_PATH}/build/venvArchive/bin/activate
+fi
+
+pip install --upgrade pip setuptools pkgconfig wheel
+pip install $(ls -t ${AMICI_PATH}/build/python/amici-*.tar.gz | head -1)
+deactivate
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/installAmiciSource.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/installAmiciSource.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c4b05e9bfd2493276e79bd7db3dcd41a41c0fa87
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/installAmiciSource.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+#
+# Build libamici
+#
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+# Disabled until cmake package is made compatible with updated setup.py
+#make python-wheel
+#pip3 install --user --prefix= `ls -t ${AMICI_PATH}/build/python/amici-*.whl | head -1`
+
+rm -f ${AMICI_PATH}/python/sdist/amici/*.cxx
+rm -f ${AMICI_PATH}/python/sdist/amici/*.so
+rm -f ${AMICI_PATH}/python/sdist/amici/amici.py
+rm -f ${AMICI_PATH}/python/sdist/amici/amici_without_hdf5.py
+rm -f ${AMICI_PATH}/python/sdist/amici/libs/*
+rm -rf ${AMICI_PATH}/python/sdist/build/
+
+
+# test install from setup.py
+set +e
+python3 -m venv ${AMICI_PATH}/build/venv --clear
+# in case this fails (usually due to missing ensurepip, try getting pip
+# manually
+if [[ $? ]]; then
+    set -e
+    python3 -m venv ${AMICI_PATH}/build/venv --clear --without-pip
+    source ${AMICI_PATH}/build/venv/bin/activate
+    curl https://bootstrap.pypa.io/get-pip.py -o ${AMICI_PATH}/build/get-pip.py
+    python ${AMICI_PATH}/build/get-pip.py
+else
+    set -e
+    source ${AMICI_PATH}/build/venv/bin/activate
+fi
+
+# install wheel separately to prevent build_wheel fail in next step
+pip install --upgrade wheel
+pip install --upgrade pip setuptools pkgconfig scipy matplotlib pysb coverage
+pip install --verbose -e ${AMICI_PATH}/python/sdist
+deactivate
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/patch-hdf5.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/patch-hdf5.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f7075726def01da1b5ae87240fca024eef37c89c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/patch-hdf5.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+#cd 'C:/Program Files/HDF_Group/HDF5/1.8.17/bin/'
+#for dll in *.dll; do
+#	  base_def=$(basename $dll .dll)
+#      def_file="${base_def}.def"
+#      lib_file="lib${base_def}.a"
+#      pexports $dll > $def_file
+#      dlltool -d $def_file -l $lib_file
+#done 
+patch -p1 -d 'C:/Program Files/HDF_Group/HDF5/1.8.17/' < C:/projects/amici/scripts/hdf5-1.8.7-mingw.patch
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/py_filter b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/py_filter
new file mode 100644
index 0000000000000000000000000000000000000000..da843b7bae7b9a43c37c5d0c931c85fe4188ab0b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/py_filter
@@ -0,0 +1,2 @@
+#!/bin/bash
+doxypypy -a -c $1
\ No newline at end of file
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-SBMLTestsuite.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-SBMLTestsuite.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0d77a4bd6120eb08614eb53203380b73bcebe0b1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-SBMLTestsuite.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+# Download and run SBML test suite
+REPO_URL="https://github.com/sbmlteam/sbml-test-suite/"
+set -e
+
+# run tests
+if [ ! -d "tests/sbml-test-suite" ]; then
+    git clone --depth=1 ${REPO_URL}
+    mv -f ./sbml-test-suite ./tests/sbml-test-suite
+fi
+
+source build/venv/bin/activate
+if [[ -z "$*" ]]; then
+  args="1-1780" # run all tests
+else
+  args="$@" # use user selection
+fi
+python ./tests/testSBMLSuite.py "${args}"
+ret=$?
+if [[ $ret != 0 ]]; then exit $ret; fi
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-codecov.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-codecov.sh
new file mode 100644
index 0000000000000000000000000000000000000000..4bdf5b4b781325c46373db24f725c4181c0e175d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-codecov.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+# Check code coverage via codecov
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+source ${AMICI_PATH}/build/venv/bin/activate
+pip install coverage
+
+if [[ -z "${BNGPATH}" ]]; then
+    export BNGPATH=${AMICI_PATH}/ThirdParty/BioNetGen-2.3.2
+fi
+
+python ./tests/testCoverage.py
+ret=$?
+if [[ $ret != 0 ]]; then exit $ret; fi
+
+
+lcov --compat-libtool --no-external --directory ${AMICI_PATH}/build/CMakeFiles/amici.dir/src --base-directory ${AMICI_PATH} --capture --output-file coverage.info
+
+rm -rf ./test_model_steadystate_scaled
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-cppcheck.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-cppcheck.sh
new file mode 100644
index 0000000000000000000000000000000000000000..721d3486201b3dac7321e055d91bb301bcdb5978
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-cppcheck.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+# Check test suite with valgrind
+# Note: CppuTest memcheck should be disabled
+# Note: Consider using ctest -T memcheck instead
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+cd ${AMICI_PATH}
+
+cppcheck -i${AMICI_PATH}/src/doc ${AMICI_PATH}/src  -I${AMICI_PATH}/include/ --enable=style 2> cppcheck.txt
+
+# suppress alloca warnings
+grep -v "(warning) Obsolete function 'alloca' called." cppcheck.txt > cppcheck_tmp.txt
+mv cppcheck_tmp.txt cppcheck.txt
+
+
+# suppress header warnings for standard libraries
+grep -v "Cppcheck cannot find all the include files" cppcheck.txt > cppcheck_tmp.txt
+mv cppcheck_tmp.txt cppcheck.txt
+
+grep -v "'AmiVectorArray' does not have a operator=" cppcheck.txt > cppcheck_tmp.txt
+mv cppcheck_tmp.txt cppcheck.txt
+
+grep -v "Member variable 'ExpData::nytrue_' is not initialized in the constructor" cppcheck.txt > cppcheck_tmp.txt
+mv cppcheck_tmp.txt cppcheck.txt
+
+grep -v "Member variable 'ExpData::nztrue_' is not initialized in the constructor" cppcheck.txt > cppcheck_tmp.txt
+mv cppcheck_tmp.txt cppcheck.txt
+
+grep -v "Member variable 'ExpData::nmaxevent_' is not initialized in the constructor" cppcheck.txt > cppcheck_tmp.txt
+mv cppcheck_tmp.txt cppcheck.txt
+
+# check if error log was created
+if [ -f cppcheck.txt  ]; then
+    # check if error log is empty
+    if [ -s cppcheck.txt ]; then
+        echo "CPPCHECK failed:"
+        cat cppcheck.txt
+        rm cppcheck.txt
+        exit 1
+    else
+        rm cppcheck.txt
+        exit 0
+    fi
+else
+    exit 1
+fi
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-cpputest.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-cpputest.sh
new file mode 100644
index 0000000000000000000000000000000000000000..781a31d32f89263c38ceb1d19c6fa283bbe924af
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-cpputest.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+if [[ "$ENABLE_GCOV_COVERAGE" == TRUE ]]; then lcov --base-directory ${AMICI_PATH} --directory ${AMICI_PATH}/build/CMakeFiles/amici.dir/src --zerocounters -q; fi
+
+# run tests
+cd ${AMICI_PATH}/build
+
+ctest -V
+ret=$?
+if [[ $ret != 0 ]]; then exit $ret; fi
+mv ${AMICI_PATH}/tests/cpputest/writeResults.h5 ${AMICI_PATH}/tests/cpputest/writeResults.h5.bak
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-doxygen.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-doxygen.sh
new file mode 100644
index 0000000000000000000000000000000000000000..3e6fcfb53e18edc38c58400a1cac6a7852fce9a8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-doxygen.sh
@@ -0,0 +1,91 @@
+#!/bin/bash
+# generate code documentation via doxygen
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+# build mtocpp
+cd ${AMICI_PATH}/ThirdParty
+if [ ! -d "mtocpp-master" ]; then
+    if [ ! -e "mtocpp-master.zip" ]; then
+        wget -O mtocpp-master.zip https://github.com/mdrohmann/mtocpp/archive/master.zip
+    fi
+    unzip mtocpp-master.zip
+    mkdir ./mtocpp-master/build
+    cd ./mtocpp-master/build && cmake .. && make mtocpp mtocpp_post
+    if [ $? -ne 0 ] ; then
+        exit 1
+    fi
+fi
+
+# make py_filter available
+PATH=${AMICI_PATH}/scripts:$PATH
+
+echo $PATH
+
+cd ${AMICI_PATH}
+MTOC_CONFIG_PATH=${AMICI_PATH}/matlab/mtoc/config
+# generate filter
+echo "$AMICI_PATH/ThirdParty/mtocpp-master/build/mtocpp \$1 ${MTOC_CONFIG_PATH}/mtocpp.conf" > ${MTOC_CONFIG_PATH}/mtocpp_filter.sh
+
+chmod +x ${MTOC_CONFIG_PATH}/mtocpp_filter.sh
+
+# generate doxyfile
+DOXYFILE=${MTOC_CONFIG_PATH}/Doxyfile
+cp ${MTOC_CONFIG_PATH}/Doxyfile.template ${DOXYFILE}
+DOXY_WARNING_FILE=${AMICI_PATH}/matlab/mtoc/warnings.log
+
+sed -i -e "s#_OutputDir_#$AMICI_PATH/doc#g" ${DOXYFILE}
+sed -i -e "s#_SourceDir_#$AMICI_PATH#g" ${DOXYFILE}
+sed -i -e "s#_ConfDir_#${MTOC_CONFIG_PATH}#g" ${DOXYFILE}
+sed -i -e "s#_ProjectName_#AMICI#g" ${DOXYFILE}
+sed -i -e "s#_ProjectDescription_#Advanced Multilanguage Interface for CVODES and IDAS#g" ${DOXYFILE}
+sed -i -e "s#_ProjectLogo_##g" ${DOXYFILE}
+sed -i -e "s#_ProjectVersion_##g" ${DOXYFILE}
+sed -i -e "s#_MTOCFILTER_#${MTOC_CONFIG_PATH}/mtocpp_filter.sh#g" ${DOXYFILE}
+sed -i -e "s#_LatexExtras_#${MTOC_CONFIG_PATH}/latexextras#g" ${DOXYFILE}
+sed -i -e "s#_GenLatex_#YES#g" ${DOXYFILE}
+sed -i -e "s#_HaveDot_#YES#g" ${DOXYFILE}
+sed -i -e "s#WARN_LOGFILE      =#WARN_LOGFILE      =${DOXY_WARNING_FILE}#g" ${DOXYFILE}
+
+# generate latexextras
+
+cp ${MTOC_CONFIG_PATH}/latexextras.template ${MTOC_CONFIG_PATH}/latexextras.sty
+sed -i -e "s#_ConfDir_#${MTOC_CONFIG_PATH}#g" ${MTOC_CONFIG_PATH}/latexextras.sty
+
+export PATH=/Library/TeX/texbin:$PATH
+
+doxygen "${DOXYFILE}"
+
+#cleanup
+#rm ${AMICI_PATH}/mtoc/config/latexextras.sty
+rm ${DOXYFILE}
+rm ${MTOC_CONFIG_PATH}/mtocpp_filter.sh
+
+cd ${AMICI_PATH}/doc/latex
+
+make
+cp ./refman.pdf ${AMICI_PATH}/AMICI_guide.pdf
+
+# suppress doxygen warnings about status badges
+grep -v "warning: Unexpected html tag <img> found within <a href=...> context" ${DOXY_WARNING_FILE} > ${DOXY_WARNING_FILE}_tmp
+mv ${DOXY_WARNING_FILE}_tmp ${DOXY_WARNING_FILE}
+
+# suppress doxygen warning about unresolved external links (problem unclear)
+grep -v "warning: unable to resolve reference to \`https" ${DOXY_WARNING_FILE} > ${DOXY_WARNING_FILE}_tmp
+mv ${DOXY_WARNING_FILE}_tmp ${DOXY_WARNING_FILE}
+
+# check if warnings log was created
+if [ -f ${DOXY_WARNING_FILE}  ]; then
+    # check if warnings log is empty
+    if [ -s ${DOXY_WARNING_FILE} ]; then
+        echo "DOXYGEN failed:"
+        cat ${DOXY_WARNING_FILE}
+        #rm ${DOXY_WARNING_FILE}
+        exit 1
+    else
+        exit 0
+    fi
+else
+    exit 1
+fi
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-python-tests.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-python-tests.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7c00ee6a171b4955e3d24f1d7d5273ad560f25eb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-python-tests.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+# Test python model wrapping inside virtual environment
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+set -e
+
+if [[ -z "${BNGPATH}" ]]; then
+    export BNGPATH=${AMICI_PATH}/ThirdParty/BioNetGen-2.3.2
+fi
+
+cd ${AMICI_PATH}/tests
+source ${AMICI_PATH}/build/venv/bin/activate
+pip install scipy h5py
+python testModels.py
+python testSBML.py
+python testPYSB.py
+python testCPP.py
+python testPreequilibration.py
+python testMisc.py
+python testPandas.py
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-valgrind.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-valgrind.sh
new file mode 100644
index 0000000000000000000000000000000000000000..bec2c9453b2f066d3c66671439f5b0878dec5aba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/run-valgrind.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+# Check test suite with valgrind
+# Note: CppuTest memcheck should be disabled
+# Note: Consider using ctest -T memcheck instead
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+set -e
+
+# run tests
+cd ${AMICI_PATH}/build/tests/cpputest/
+
+VALGRIND_OPTS="--leak-check=full --error-exitcode=1 --trace-children=yes --show-leak-kinds=definite"
+set -x
+for MODEL in $(ctest -N | grep "Test[ ]*#" | grep -v unittests | sed -E 's/ *Test[ ]*#[0-9]+: model_(.*)_test/\1/')
+    do cd ${AMICI_PATH}/build/tests/cpputest/${MODEL}/ && valgrind ${VALGRIND_OPTS} ./model_${MODEL}_test
+done
+cd ${AMICI_PATH}/build/tests/cpputest/unittests/ && valgrind ${VALGRIND_OPTS} ./unittests
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/runNotebook.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/runNotebook.sh
new file mode 100644
index 0000000000000000000000000000000000000000..437fb7217a572dd3b5a2f43f992d48f45a6e4a3e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/runNotebook.sh
@@ -0,0 +1,39 @@
+#!/bin/bash
+# Run jupyter notebooks as given on command line, show output only on error.
+# If a directory is provided, run all contained notebooks non-recursively.
+set -x
+set -e
+
+SCRIPT_PATH=$(dirname $BASH_SOURCE)
+AMICI_PATH=$(cd $SCRIPT_PATH/.. && pwd)
+
+runNotebook () {
+    set +e
+    tempfile=$(mktemp)
+    jupyter nbconvert --debug --stdout --execute --ExecutePreprocessor.timeout=300 --to markdown $@ &> $tempfile
+    ret=$?
+    if [[ $ret != 0 ]]; then
+      cat $tempfile
+      exit $ret
+    fi
+    rm $tempfile
+    set -e
+}
+
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 [notebook.ipynb] [dirContainingNotebooks/]"
+    exit 1
+fi
+
+source ${AMICI_PATH}/build/venv/bin/activate
+pip3 show ipython || (pip3 install --upgrade jupyter jupyter_contrib_nbextensions && python3 -m ipykernel install --user --name amici --display-name "Python (amici)")
+
+for arg in "$@"; do
+    if [ -d $arg ]; then
+        for notebook in $(ls -1 $arg | grep -E ipynb\$); do
+            runNotebook $arg/$notebook
+        done
+    elif [ -f $arg ]; then
+        runNotebook $arg
+    fi
+done
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/scripts/travis_wrap.sh b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/travis_wrap.sh
new file mode 100644
index 0000000000000000000000000000000000000000..58314beeacaee695adf53e3b1774204797f3e403
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/scripts/travis_wrap.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+# wrapper script to enable code folding on travis-ci
+#
+# Note: Expects travis functions exported in before_script
+#
+# Usage: travis_wrap.sh fold-block-id script [script args]
+# fold-block-id should not contain special characters, blanks newlines, ...
+
+set -e
+travis_time_finish
+travis_fold start "$1"
+    travis_time_start
+        bash -c "${@:2:$#}"
+    travis_time_finish
+travis_fold end "$1"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/CMakeLists.template.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/src/CMakeLists.template.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0b1e27e91f0d80fabcb9f4958c13fe90a1589353
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/CMakeLists.template.cmake
@@ -0,0 +1,78 @@
+cmake_minimum_required(VERSION 2.8)
+
+if(POLICY CMP0060)
+  cmake_policy(SET CMP0060 NEW)
+endif(POLICY CMP0060)
+if(POLICY CMP0065)
+  cmake_policy(SET CMP0065 NEW)
+endif(POLICY CMP0065)
+
+project(TPL_MODELNAME)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+include(CheckCXXCompilerFlag)
+set(MY_CXX_FLAGS -Wall -Wno-unused-function -Wno-unused-variable -Wno-unused-but-set-variable)
+foreach(FLAG ${MY_CXX_FLAGS})
+    unset(CUR_FLAG_SUPPORTED CACHE)
+    CHECK_CXX_COMPILER_FLAG(${FLAG} CUR_FLAG_SUPPORTED)
+    if(${CUR_FLAG_SUPPORTED})
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}")
+    endif()
+endforeach(FLAG)
+
+find_package(Amici TPL_AMICI_VERSION HINTS ${CMAKE_CURRENT_LIST_DIR}/../../build)
+message(STATUS "Found AMICI ${Amici_DIR}")
+
+set(MODEL_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+set(SRC_LIST_LIB TPL_SOURCES
+${MODEL_DIR}/wrapfunctions.cpp
+)
+
+add_library(${PROJECT_NAME} ${SRC_LIST_LIB})
+add_library(model ALIAS ${PROJECT_NAME})
+
+target_include_directories(${PROJECT_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(${PROJECT_NAME}
+    PUBLIC Upstream::amici
+)
+
+set(SRC_LIST_EXE main.cpp)
+
+add_executable(simulate_${PROJECT_NAME} ${SRC_LIST_EXE})
+
+target_link_libraries(simulate_${PROJECT_NAME} ${PROJECT_NAME})
+
+if($ENV{ENABLE_GCOV_COVERAGE})
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 --coverage")
+endif()
+
+## SWIG
+option(ENABLE_SWIG "Build swig/python library?" ON)
+if(ENABLE_SWIG)
+    if(NOT(${CMAKE_VERSION} VERSION_LESS 3.8))
+        add_subdirectory(swig)
+    else()
+        message(WARNING "Unable to build SWIG interface, upgrade CMake to >=3.8.")
+    endif()
+endif()
+
+
+# <Export cmake configuration>
+include(GNUInstallDirs)
+install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}Targets
+    ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+export(EXPORT ${PROJECT_NAME}Targets FILE ${PROJECT_NAME}Config.cmake
+    NAMESPACE Upstream::
+    )
+# </Export cmake configuration>
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/abstract_model.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/abstract_model.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba89b0f53ab6d3a1d0a5779a235eabe274da13ac
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/abstract_model.cpp
@@ -0,0 +1,310 @@
+#include "amici/abstract_model.h"
+
+namespace amici {
+
+const std::string AbstractModel::getAmiciVersion() const {
+    throw AmiException("Version not set during code generation");
+}
+
+const std::string AbstractModel::getAmiciCommit() const {
+    throw AmiException("Commit not set during code generation");
+}
+
+void AbstractModel::fx0(realtype * /*x0*/, const realtype  /*t*/, const realtype * /*p*/,
+                        const realtype * /*k*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+bool AbstractModel::isFixedParameterStateReinitializationAllowed() const {
+    return false;
+}
+
+void AbstractModel::fx0_fixedParameters(realtype *x0, const realtype t,
+                                        const realtype *p, const realtype *k) {}
+
+void AbstractModel::fsx0_fixedParameters(realtype *sx0, const realtype t,
+                                         const realtype *x0, const realtype *p,
+                                         const realtype *k, const int ip) {}
+
+void AbstractModel::fsx0(realtype * /*sx0*/, const realtype  /*t*/, const realtype * /*x0*/,
+                         const realtype * /*p*/, const realtype * /*k*/, const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdx0(AmiVector &x0, AmiVector &dx0) {}
+
+void AbstractModel::fstau(realtype * /*stau*/, const realtype  /*t*/, const realtype * /*x*/,
+                          const realtype * /*p*/, const realtype * /*k*/,
+                          const realtype * /*h*/, const realtype * /*sx*/, const int  /*ip*/,
+                          const int  /*ie*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fy(realtype * /*y*/, const realtype  /*t*/, const realtype * /*x*/,
+                       const realtype * /*p*/, const realtype * /*k*/, const realtype * /*h*/,
+                       const realtype * /*w*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdydp(realtype * /*dydp*/, const realtype  /*t*/, const realtype * /*x*/,
+                          const realtype * /*p*/, const realtype * /*k*/,
+                          const realtype * /*h*/, const int  /*ip*/, const realtype * /*w*/,
+                          const realtype * /*dwdp*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdydx(realtype * /*dydx*/, const realtype  /*t*/, const realtype * /*x*/,
+                          const realtype * /*p*/, const realtype * /*k*/,
+                          const realtype * /*h*/, const realtype * /*w*/,
+                          const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fz(realtype * /*z*/, const int  /*ie*/, const realtype  /*t*/,
+                       const realtype * /*x*/, const realtype * /*p*/, const realtype * /*k*/,
+                       const realtype * /*h*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fsz(realtype * /*sz*/, const int  /*ie*/, const realtype  /*t*/,
+                        const realtype * /*x*/, const realtype * /*p*/, const realtype * /*k*/,
+                        const realtype * /*h*/, const realtype * /*sx*/, const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::frz(realtype * /*rz*/, const int  /*ie*/, const realtype  /*t*/,
+                        const realtype * /*x*/, const realtype * /*p*/, const realtype * /*k*/,
+                        const realtype * /*h*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fsrz(realtype * /*srz*/, const int  /*ie*/, const realtype  /*t*/,
+                         const realtype * /*x*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*h*/,
+                         const realtype * /*sx*/, const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdzdp(realtype * /*dzdp*/, const int  /*ie*/, const realtype  /*t*/,
+                          const realtype * /*x*/, const realtype * /*p*/,
+                          const realtype * /*k*/, const realtype * /*h*/, const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdzdx(realtype * /*dzdx*/, const int  /*ie*/, const realtype  /*t*/,
+                          const realtype * /*x*/, const realtype * /*p*/,
+                          const realtype * /*k*/, const realtype * /*h*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdrzdp(realtype * /*drzdp*/, const int  /*ie*/, const realtype  /*t*/,
+                           const realtype * /*x*/, const realtype * /*p*/,
+                           const realtype * /*k*/, const realtype * /*h*/, const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdrzdx(realtype * /*drzdx*/, const int  /*ie*/, const realtype  /*t*/,
+                           const realtype * /*x*/, const realtype * /*p*/,
+                           const realtype * /*k*/, const realtype * /*h*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdeltax(realtype * /*deltax*/, const realtype  /*t*/,
+                            const realtype * /*x*/, const realtype * /*p*/,
+                            const realtype * /*k*/, const realtype * /*h*/, const int  /*ie*/,
+                            const realtype * /*xdot*/, const realtype * /*xdot_old*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdeltasx(realtype * /*deltasx*/, const realtype  /*t*/,
+                             const realtype * /*x*/, const realtype * /*p*/,
+                             const realtype * /*k*/, const realtype * /*h*/,
+                             const realtype * /*w*/, const int  /*ip*/, const int  /*ie*/,
+                             const realtype * /*xdot*/, const realtype * /*xdot_old*/,
+                             const realtype * /*sx*/, const realtype * /*stau*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdeltaxB(realtype * /*deltaxB*/, const realtype  /*t*/,
+                             const realtype * /*x*/, const realtype * /*p*/,
+                             const realtype * /*k*/, const realtype * /*h*/, const int  /*ie*/,
+                             const realtype * /*xdot*/, const realtype * /*xdot_old*/,
+                             const realtype * /*xB*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdeltaqB(realtype * /*deltaqB*/, const realtype  /*t*/,
+                             const realtype * /*x*/, const realtype * /*p*/,
+                             const realtype * /*k*/, const realtype * /*h*/, const int  /*ip*/,
+                             const int  /*ie*/, const realtype * /*xdot*/,
+                             const realtype * /*xdot_old*/, const realtype * /*xB*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fsigmay(realtype * /*sigmay*/, const realtype  /*t*/,
+                            const realtype * /*p*/, const realtype * /*k*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdsigmaydp(realtype * /*dsigmaydp*/, const realtype  /*t*/,
+                               const realtype * /*p*/, const realtype * /*k*/,
+                               const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fsigmaz(realtype * /*sigmaz*/, const realtype  /*t*/,
+                            const realtype * /*p*/, const realtype * /*k*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdsigmazdp(realtype * /*dsigmazdp*/, const realtype  /*t*/,
+                               const realtype * /*p*/, const realtype * /*k*/,
+                               const int  /*ip*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fJy(realtype * /*nllh*/, const int  /*iy*/, const realtype * /*p*/,
+                        const realtype * /*k*/, const realtype * /*y*/,
+                        const realtype * /*sigmay*/, const realtype * /*my*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fJz(realtype * /*nllh*/, const int  /*iz*/, const realtype * /*p*/,
+                        const realtype * /*k*/, const realtype * /*z*/,
+                        const realtype * /*sigmaz*/, const realtype * /*mz*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fJrz(realtype * /*nllh*/, const int  /*iz*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*z*/,
+                         const realtype * /*sigmaz*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdJydy(realtype * /*dJydy*/, const int  /*iy*/, const realtype * /*p*/,
+                           const realtype * /*k*/, const realtype * /*y*/,
+                           const realtype * /*sigmay*/, const realtype * /*my*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdJydsigma(realtype * /*dJydsigma*/, const int  /*iy*/,
+                               const realtype * /*p*/, const realtype * /*k*/,
+                               const realtype * /*y*/, const realtype * /*sigmay*/,
+                               const realtype * /*my*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdJzdz(realtype * /*dJzdz*/, const int  /*iz*/, const realtype * /*p*/,
+                           const realtype * /*k*/, const realtype * /*z*/,
+                           const realtype * /*sigmaz*/, const realtype * /*mz*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdJzdsigma(realtype * /*dJzdsigma*/, const int  /*iz*/,
+                               const realtype * /*p*/, const realtype * /*k*/,
+                               const realtype * /*z*/, const realtype * /*sigmaz*/,
+                               const realtype * /*mz*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdJrzdz(realtype * /*dJrzdz*/, const int  /*iz*/, const realtype * /*p*/,
+                            const realtype * /*k*/, const realtype * /*rz*/,
+                            const realtype * /*sigmaz*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fdJrzdsigma(realtype * /*dJrzdsigma*/, const int  /*iz*/,
+                                const realtype * /*p*/, const realtype * /*k*/,
+                                const realtype * /*rz*/, const realtype * /*sigmaz*/) {
+    throw AmiException("Requested functionality is not supported as (%s) is "
+                       "not implemented for this model!",
+                       __func__);
+}
+
+void AbstractModel::fw(realtype *w, const realtype t, const realtype *x,
+                       const realtype *p, const realtype *k, const realtype *h,
+                       const realtype *tcl) {}
+
+void AbstractModel::fdwdp(realtype *dwdp, const realtype t, const realtype *x,
+                          const realtype *p, const realtype *k,
+                          const realtype *h, const realtype *w,
+                          const realtype *tcl, const realtype *stcl) {
+}
+
+void AbstractModel::fdwdp(realtype *dwdp, const realtype t, const realtype *x,
+                          const realtype *p, const realtype *k,
+                          const realtype *h, const realtype *w,
+                          const realtype *tcl, const realtype *stcl,
+                          const int ip) {
+}
+
+void AbstractModel::fdwdx(realtype *dwdx, const realtype t, const realtype *x,
+                          const realtype *p, const realtype *k,
+                          const realtype *h, const realtype *w,
+                          const realtype *tcl) {}
+
+void AbstractModel::fdwdx_colptrs(sunindextype *indexptrs) {}
+
+void AbstractModel::fdwdx_rowvals(sunindextype *indexvals) {}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/amici.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/amici.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d71a03c9ebc1236625cbed14aed3f7d3379319bb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/amici.cpp
@@ -0,0 +1,152 @@
+/**
+ * @file   amici.cpp
+ * @brief  core routines for integration
+ */
+
+#include "amici/amici.h"
+
+#include "amici/backwardproblem.h"
+#include "amici/forwardproblem.h"
+#include "amici/misc.h"
+
+#include <sundials/sundials_types.h> //realtype
+#include <cvodes/cvodes.h> //return codes
+
+#include <type_traits>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <cstdarg>
+#include <memory>
+
+// ensure definitions are in sync
+static_assert(AMICI_SUCCESS == CV_SUCCESS, "AMICI_SUCCESS != CV_SUCCESS");
+static_assert(AMICI_DATA_RETURN == CV_TSTOP_RETURN,
+              "AMICI_DATA_RETURN != CV_TSTOP_RETURN");
+static_assert(AMICI_ROOT_RETURN == CV_ROOT_RETURN,
+              "AMICI_ROOT_RETURN != CV_ROOT_RETURN");
+static_assert(AMICI_ILL_INPUT == CV_ILL_INPUT,
+              "AMICI_ILL_INPUT != CV_ILL_INPUT");
+static_assert(AMICI_NORMAL == CV_NORMAL, "AMICI_NORMAL != CV_NORMAL");
+static_assert(AMICI_ONE_STEP == CV_ONE_STEP, "AMICI_ONE_STEP != CV_ONE_STEP");
+static_assert(std::is_same<amici::realtype, realtype>::value,
+              "Definition of realtype does not match");
+
+
+namespace amici {
+
+msgIdAndTxtFp errMsgIdAndTxt = &printErrMsgIdAndTxt;
+msgIdAndTxtFp warnMsgIdAndTxt = &printWarnMsgIdAndTxt;
+
+
+std::unique_ptr<ReturnData> runAmiciSimulation(Solver &solver, const ExpData *edata, Model &model, bool rethrow) {
+    std::unique_ptr<ReturnData> rdata;
+
+    /* Applies condition-specific model settings and restores them when going
+     * out of scope */
+    ConditionContext conditionContext(&model, edata);
+
+    try{
+        rdata = std::unique_ptr<ReturnData>(new ReturnData(solver, model));
+
+        if (model.nx_solver <= 0) {
+            return rdata;
+        }
+
+        auto fwd = std::unique_ptr<ForwardProblem>(new ForwardProblem(rdata.get(),edata,&model,&solver));
+        fwd->workForwardProblem();
+
+        auto bwd = std::unique_ptr<BackwardProblem>(new BackwardProblem(fwd.get()));
+        bwd->workBackwardProblem();
+
+        rdata->status = AMICI_SUCCESS;
+    } catch (amici::IntegrationFailure const& ex) {
+        rdata->invalidate(ex.time);
+        rdata->status = ex.error_code;
+        if(rethrow) throw;
+        amici::warnMsgIdAndTxt("AMICI:mex:simulation","AMICI forward simulation failed at t = %f:\n%s\n",ex.time,ex.what());
+    } catch (amici::IntegrationFailureB const& ex) {
+        rdata->invalidateSLLH();
+        rdata->status = ex.error_code;
+        if(rethrow) throw;
+        amici::warnMsgIdAndTxt(
+                    "AMICI:mex:simulation",
+                    "AMICI backward simulation failed when trying to solve until t = %f"
+                    " (see message above):\n%s\n",
+                    ex.time, ex.what());
+    } catch (amici::AmiException const& ex) {
+        rdata->invalidate(model.t0());
+        rdata->status = AMICI_ERROR;
+        if(rethrow) throw;
+        amici::warnMsgIdAndTxt("AMICI:mex:simulation","AMICI simulation failed:\n%s\nError occured in:\n%s",ex.what(),ex.getBacktrace());
+    }
+
+    rdata->applyChainRuleFactorToSimulationResults(&model);
+
+    return rdata;
+}
+
+void printErrMsgIdAndTxt(const char *identifier, const char *format, ...) {
+    if(identifier && *identifier != '\0')
+        fprintf(stderr, "[Error] %s: ", identifier);
+    else
+        fprintf(stderr, "[Error] ");
+    va_list argptr;
+    va_start(argptr,format);
+    vfprintf(stderr, format, argptr);
+    va_end(argptr);
+    fprintf(stderr, "\n");
+}
+
+void printWarnMsgIdAndTxt(const char *identifier, const char *format, ...) {
+    if(identifier && *identifier != '\0')
+        printf("[Warning] %s: ", identifier);
+    else
+        printf("[Warning] ");
+    va_list argptr;
+    va_start(argptr,format);
+    vprintf(format, argptr);
+    va_end(argptr);
+    printf("\n");
+}
+
+std::vector<std::unique_ptr<ReturnData> > runAmiciSimulations(const Solver &solver,
+                                                              const std::vector<ExpData*> &edatas,
+                                                              const Model &model,
+                                                              const bool failfast,
+#if defined(_OPENMP)
+                                                              int num_threads
+#else
+                                                              int /* num_threads */
+#endif
+)
+{
+    std::vector<std::unique_ptr<ReturnData> > results(edatas.size());
+    // is set to true if one simulation fails and we should skip the rest.
+    // shared across threads.
+    bool skipThrough = false;
+
+#if defined(_OPENMP)
+    #pragma omp parallel for num_threads(num_threads)
+#endif
+    for(int i = 0; i < (int)edatas.size(); ++i) {
+        auto mySolver = std::unique_ptr<Solver>(solver.clone());
+        auto myModel = std::unique_ptr<Model>(model.clone());
+
+        /* if we fail we need to write empty return datas for the python
+         interface */
+        if (skipThrough) {
+            ConditionContext conditionContext(myModel.get(), edatas[i]);
+            results[i] =
+                std::unique_ptr<ReturnData>(new ReturnData(solver, model));
+        } else {
+            results[i] = runAmiciSimulation(*mySolver, edatas[i], *myModel);
+        }
+
+        skipThrough |= failfast && results[i]->status < 0;
+    }
+
+    return results;
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/backwardproblem.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/backwardproblem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..564517252358d29c6381fd1ed8b1e4373121093d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/backwardproblem.cpp
@@ -0,0 +1,184 @@
+#include "amici/backwardproblem.h"
+
+#include "amici/model.h"
+#include "amici/solver.h"
+#include "amici/exception.h"
+#include "amici/edata.h"
+#include "amici/rdata.h"
+#include "amici/forwardproblem.h"
+
+#include <cstring>
+
+namespace amici {
+
+BackwardProblem::BackwardProblem(const ForwardProblem *fwd) :
+    model(fwd->model),
+    rdata(fwd->rdata),
+    solver(fwd->solver),
+    t(fwd->getTime()),
+    llhS0(static_cast<decltype(llhS0)::size_type>(fwd->model->nJ * fwd->model->nplist()), 0.0),
+    xB(fwd->model->nx_solver),
+    dxB(fwd->model->nx_solver),
+    xQB(fwd->model->nJ*fwd->model->nplist()),
+    x_disc(fwd->getStatesAtDiscontinuities()),
+    xdot_disc(fwd->getRHSAtDiscontinuities()),
+    xdot_old_disc(fwd->getRHSBeforeDiscontinuities()),
+    sx0(fwd->getStateSensitivity()),
+    nroots(fwd->getNumberOfRoots()),
+    discs(fwd->getDiscontinuities()),
+    irdiscs(fwd->getDiscontinuities()),
+    iroot(fwd->getRootCounter()),
+    rootidx(fwd->getRootIndexes()),
+    dJydx(fwd->getDJydx()),
+    dJzdx(fwd->getDJzdx()) {}
+
+
+void BackwardProblem::workBackwardProblem() {
+
+
+    if (model->nx_solver <= 0 ||
+        solver->getSensitivityOrder() < SensitivityOrder::first ||
+        solver->getSensitivityMethod() != SensitivityMethod::adjoint ||
+        model->nplist() == 0) {
+        return;
+    }
+    
+    int it = rdata->nt - 1;
+    model->initializeB(xB, dxB, xQB);
+    handleDataPointB(it);
+    solver->setupB(&which, rdata->ts[it], model, xB, dxB, xQB);
+    
+    --it;
+    --iroot;
+
+    while (it >= 0 || iroot >= 0) {
+
+        /* check if next timepoint is a discontinuity or a data-point */
+        double tnext = getTnext(discs, iroot, it);
+
+        if (tnext < t) {
+            solver->runB(tnext);
+            solver->writeSolutionB(&t, xB, dxB, xQB, this->which);
+            solver->getDiagnosisB(it, rdata, this->which);
+        }
+
+        /* handle discontinuity */
+        if (model->ne > 0 && rdata->nmaxevent > 0 && iroot >= 0) {
+            if (tnext == discs.at(iroot)) {
+                handleEventB(iroot);
+                --iroot;
+            }
+        }
+
+        /* handle data-point */
+        if (tnext == rdata->ts[it]) {
+            handleDataPointB(it);
+            it--;
+        }
+
+        /* reinit states */
+        solver->reInitB(which, t, xB, dxB);
+        solver->quadReInitB(which, xQB);
+    }
+
+    /* we still need to integrate from first datapoint to tstart */
+    if (t > model->t0()) {
+        /* solve for backward problems */
+        solver->runB(model->t0());
+        solver->writeSolutionB(&t, xB, dxB, xQB, this->which);
+        solver->getDiagnosisB(0, rdata, this->which);
+    }
+
+    computeLikelihoodSensitivities();
+    rdata->cpu_timeB = solver->getCpuTimeB();
+}
+
+
+void BackwardProblem::handleEventB(const int iroot) {
+    for (int ie = 0; ie < model->ne; ie++) {
+
+        if (rootidx[iroot * model->ne + ie] == 0) {
+            continue;
+        }
+
+        model->addAdjointQuadratureEventUpdate(xQB, ie, t, x_disc[iroot], xB,
+                                               xdot_disc[iroot],
+                                               xdot_old_disc[iroot]);
+        model->addAdjointStateEventUpdate(xB, ie, t, x_disc[iroot],
+                                          xdot_disc[iroot],
+                                          xdot_old_disc[iroot]);
+
+        for (int ix = 0; ix < model->nxtrue_solver; ++ix) {
+            for (int iJ = 0; iJ < model->nJ; ++iJ) {
+                if (model->nz > 0) {
+                    xB[ix + iJ * model->nxtrue_solver] +=
+                            dJzdx[iJ + ( ix + nroots[ie] * model->nx_solver ) * model->nJ];
+                }
+            }
+        }
+
+
+
+        nroots[ie]--;
+    }
+
+    model->updateHeavisideB(&rootidx[iroot * model->ne]);
+}
+
+
+void BackwardProblem::handleDataPointB(const int it) {
+    for (int ix = 0; ix < model->nxtrue_solver; ix++) {
+        for (int iJ = 0; iJ < model->nJ; iJ++)
+            // we only need the 1:nxtrue_solver (not the nx_true) slice here!
+            xB[ix + iJ * model->nxtrue_solver] +=
+                dJydx[iJ + ( ix + it * model->nx_solver ) * model->nJ];
+    }
+}
+
+realtype BackwardProblem::getTnext(std::vector<realtype> const& troot,
+                                   const int iroot, const int it) {
+    if (it < 0
+            || (iroot >= 0 && model->ne > 0 && troot.at(iroot) > rdata->ts[it])) {
+        return troot.at(iroot);
+    }
+
+    return rdata->ts[it];
+}
+
+
+void BackwardProblem::computeLikelihoodSensitivities()
+{
+    for (int iJ = 0; iJ < model->nJ; iJ++) {
+        if (iJ == 0) {
+            for (int ip = 0; ip < model->nplist(); ++ip) {
+                llhS0[ip] = 0.0;
+                for (int ix = 0; ix < model->nxtrue_solver; ++ix) {
+                    llhS0[ip] += xB[ix] * sx0.at(ix,ip);
+                }
+            }
+        } else {
+            for (int ip = 0; ip < model->nplist(); ++ip) {
+                llhS0[ip + iJ * model->nplist()] = 0.0;
+                for (int ix = 0; ix < model->nxtrue_solver; ++ix) {
+                    llhS0[ip + iJ * model->nplist()] +=
+                        xB[ix + iJ * model->nxtrue_solver] * sx0.at(ix,ip)+
+                        xB[ix] * sx0.at(ix + iJ * model->nxtrue_solver,ip);
+                }
+            }
+        }
+    }
+
+    for (int iJ = 0; iJ < model->nJ; iJ++) {
+        for (int ip = 0; ip < model->nplist(); ip++) {
+            if (iJ == 0) {
+                rdata->sllh.at(ip) -= llhS0[ip] + xQB[ip*model->nJ];
+            } else {
+                rdata->s2llh.at(iJ - 1 + ip * (model->nJ - 1)) -=
+                    llhS0[ip + iJ * model->nplist()] +
+                    xQB[iJ + ip*model->nJ];
+            }
+        }
+    }
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/cblas.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/cblas.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..377ca092f780ad3b4065bf92471218d8bc09caba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/cblas.cpp
@@ -0,0 +1,44 @@
+/**
+ * @file   cblas.cpp
+ * @brief  BLAS routines required by AMICI
+ *
+ **/
+
+#include "amici/cblas.h"
+
+#ifdef __APPLE__
+#include <Accelerate/Accelerate.h>
+#elif defined(AMICI_BLAS_MKL)
+#include <mkl.h>
+#else
+extern "C"
+{
+   #include <cblas.h>
+}
+#endif
+
+namespace amici {
+
+void amici_dgemm(BLASLayout layout, BLASTranspose TransA,
+                 BLASTranspose TransB, const int M, const int N,
+                 const int K, const double alpha, const double *A,
+                 const int lda, const double *B, const int ldb,
+                 const double beta, double *C, const int ldc) {
+    cblas_dgemm((CBLAS_ORDER)layout, (CBLAS_TRANSPOSE)TransA,
+                (CBLAS_TRANSPOSE)TransB, M, N, K, alpha, A, lda, B, ldb, beta,
+                C, ldc);
+}
+
+void amici_dgemv(BLASLayout layout, BLASTranspose TransA,
+                 const int M, const int N, const double alpha, const double *A,
+                 const int lda, const double *X, const int incX,
+                 const double beta, double *Y, const int incY) {
+    cblas_dgemv((CBLAS_ORDER)layout, (CBLAS_TRANSPOSE)TransA, M, N, alpha, A,
+                lda, X, incX, beta, Y, incY);
+}
+
+void amici_daxpy(int n, double alpha, const double *x, const int incx, double *y, int incy) {
+    cblas_daxpy(n, alpha, x, incx, y, incy);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/edata.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/edata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..67c772062e140735da4a5a621cf1b7ab9180de84
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/edata.cpp
@@ -0,0 +1,416 @@
+#include "amici/edata.h"
+#include "amici/rdata.h"
+#include "amici/symbolic_functions.h" // getNaN
+#include "amici/defines.h"
+#include "amici/model.h"
+
+#include <cstring>
+#include <random>
+#include <utility>
+#include <algorithm>
+
+namespace amici {
+
+ExpData::ExpData(int nytrue, int nztrue, int nmaxevent)
+    : nytrue_(nytrue), nztrue_(nztrue), nmaxevent_(nmaxevent)
+{
+    applyDimensions();
+}
+
+ExpData::ExpData(int nytrue, int nztrue, int nmaxevent,
+                 std::vector<realtype> ts_)
+    : nytrue_(nytrue), nztrue_(nztrue), nmaxevent_(nmaxevent), ts(std::move(ts_))
+{
+    applyDimensions();
+}
+
+ExpData::ExpData(int nytrue, int nztrue, int nmaxevent,
+                 std::vector<realtype> ts_,
+                 std::vector<realtype> fixedParameters_
+                 )
+    : fixedParameters(std::move(fixedParameters_)), nytrue_(nytrue), nztrue_(nztrue), nmaxevent_(nmaxevent), ts(std::move(ts_))
+{
+    applyDimensions();
+}
+
+ExpData::ExpData(int nytrue, int nztrue, int nmaxevent,
+                 std::vector<realtype> ts_,
+                 std::vector<realtype> const& observedData,
+                 std::vector<realtype> const& observedDataStdDev,
+                 std::vector<realtype> const& observedEvents,
+                 std::vector<realtype> const& observedEventsStdDev)
+    : nytrue_(nytrue), nztrue_(nztrue), nmaxevent_(nmaxevent), ts(std::move(ts_))
+{
+    applyDimensions();
+    setObservedData(observedData);
+    setObservedDataStdDev(observedDataStdDev);
+    setObservedEvents(observedEvents);
+    setObservedEventsStdDev(observedEventsStdDev);
+}
+
+ExpData::ExpData(Model const& model)
+    : ExpData(model.nytrue, model.nztrue, model.nMaxEvent(),
+              model.getTimepoints(), model.getFixedParameters()) {}
+
+ExpData::ExpData(ReturnData const& rdata, realtype sigma_y, realtype sigma_z)
+    : ExpData(rdata, std::vector<realtype>(rdata.nytrue*rdata.nt, sigma_y), std::vector<realtype>(rdata.nztrue*rdata.nmaxevent, sigma_z)) {}
+
+ExpData::ExpData(ReturnData const& rdata, std::vector<realtype> sigma_y,
+                 std::vector<realtype> sigma_z)
+    : ExpData(rdata.nytrue, rdata.nztrue, rdata.nmaxevent, rdata.ts)
+{
+    if (sigma_y.size() != (unsigned) nytrue_ && sigma_y.size() != (unsigned) nytrue_*nt())
+        throw AmiException("Dimension of sigma_y must be %d or %d, was %d", nytrue_, nytrue_*nt(), sigma_y.size());
+
+    if (sigma_z.size() != (unsigned) nztrue_ && sigma_z.size() != (unsigned) nztrue_*nmaxevent_)
+        throw AmiException("Dimension of sigma_z must be %d or %d, was %d", nztrue_, nztrue_*nmaxevent_, sigma_z.size());
+
+    std::random_device rd{};
+    std::mt19937 gen{rd()};
+
+    realtype sigma;
+
+    checkSigmaPositivity(sigma_y, "sigma_y");
+    checkSigmaPositivity(sigma_z, "sigma_z");
+
+    for (int iy = 0; iy < nytrue_; ++iy) {
+        for (int it = 0; it < nt(); ++it) {
+            sigma = sigma_y.size() == (unsigned) nytrue_ ? sigma_y.at(iy) : sigma_y.at(iy + nytrue_ * it);
+            std::normal_distribution<> e{0, sigma};
+            observedData.at(iy + nytrue_ * it) = rdata.y.at(iy + rdata.ny * it) + e(gen);
+            observedDataStdDev.at(iy + nytrue_ * it) = sigma;
+        }
+    }
+
+    for (int iz = 0; iz < nztrue_; ++iz) {
+        for (int ie = 0; ie < nmaxevent_; ++ie) {
+            sigma = sigma_z.size() == (unsigned) nztrue_ ? sigma_z.at(iz) : sigma_z.at(iz + nztrue_ * ie);
+            std::normal_distribution<> e{0, sigma};
+            observedEvents.at(iz + rdata.nztrue * ie) = rdata.z.at(iz + rdata.nz * ie) + e(gen);
+            observedDataStdDev.at(iz + rdata.nztrue * ie) = sigma;
+        }
+        }
+}
+
+void ExpData::setTimepoints(const std::vector<realtype> &ts) {
+    if (!std::is_sorted(ts.begin(), ts.end()))
+        throw AmiException("Encountered non-monotonic timepoints, please order timepoints such that they are monotonically increasing!");
+    this->ts = ts;
+    applyDataDimension();
+}
+
+std::vector<realtype> const& ExpData::getTimepoints() const {
+    return ts;
+}
+
+int ExpData::nt() const {
+    return ts.size();
+}
+
+realtype ExpData::getTimepoint(int it) const {
+    return ts.at(it);
+}
+
+void ExpData::setObservedData(const std::vector<realtype> &observedData) {
+    checkDataDimension(observedData, "observedData");
+
+    if (observedData.size() == (unsigned) nt()*nytrue_)
+        this->observedData = observedData;
+    else if (observedData.empty())
+        this->observedData.clear();
+}
+
+void ExpData::setObservedData(const std::vector<realtype> &observedData, int iy) {
+    if (observedData.size() != (unsigned) nt())
+        throw AmiException("Input observedData did not match dimensions nt (%i), was %i", nt(), observedData.size());
+
+    for (int it = 0; it < nt(); ++it)
+        this->observedData.at(iy + it*nytrue_) = observedData.at(it);
+}
+
+bool ExpData::isSetObservedData(int it, int iy) const {
+    return !observedData.empty() && !isNaN(observedData.at(it * nytrue_ + iy));
+}
+
+std::vector<realtype> const& ExpData::getObservedData() const {
+    return observedData;
+}
+
+const realtype *ExpData::getObservedDataPtr(int it) const {
+    if (!observedData.empty())
+        return &observedData.at(it*nytrue_);
+
+    return nullptr;
+}
+
+void ExpData::setObservedDataStdDev(const std::vector<realtype> &observedDataStdDev) {
+    checkDataDimension(observedDataStdDev, "observedDataStdDev");
+    checkSigmaPositivity(observedDataStdDev, "observedDataStdDev");
+
+    if (observedDataStdDev.size() == (unsigned) nt()*nytrue_)
+        this->observedDataStdDev = observedDataStdDev;
+    else if (observedDataStdDev.empty())
+        this->observedDataStdDev.clear();
+}
+
+void ExpData::setObservedDataStdDev(const realtype stdDev) {
+    checkSigmaPositivity(stdDev, "stdDev");
+    std::fill(observedDataStdDev.begin() ,observedDataStdDev.end(), stdDev);
+}
+
+void ExpData::setObservedDataStdDev(const std::vector<realtype> &observedDataStdDev, int iy) {
+    if (observedDataStdDev.size() != (unsigned) nt())
+        throw AmiException("Input observedDataStdDev did not match dimensions nt (%i), was %i", nt(), observedDataStdDev.size());
+    checkSigmaPositivity(observedDataStdDev, "observedDataStdDev");
+
+    for (int it = 0; it < nt(); ++it)
+        this->observedDataStdDev.at(iy + it*nytrue_) = observedDataStdDev.at(it);
+}
+
+void ExpData::setObservedDataStdDev(const realtype stdDev, int iy) {
+    checkSigmaPositivity(stdDev, "stdDev");
+    for (int it = 0; it < nt(); ++it)
+        observedDataStdDev.at(iy + it*nytrue_) = stdDev;
+}
+
+bool ExpData::isSetObservedDataStdDev(int it, int iy) const {
+    return !observedDataStdDev.empty() && !isNaN(observedDataStdDev.at(it * nytrue_ + iy));
+}
+
+std::vector<realtype> const& ExpData::getObservedDataStdDev() const {
+    return observedDataStdDev;
+}
+
+const realtype *ExpData::getObservedDataStdDevPtr(int it) const {
+    if (!observedDataStdDev.empty())
+        return &observedDataStdDev.at(it*nytrue_);
+
+    return nullptr;
+}
+
+void ExpData::setObservedEvents(const std::vector<realtype> &observedEvents) {
+    checkEventsDimension(observedEvents, "observedEvents");
+
+    if (observedEvents.size() == (unsigned) nmaxevent_*nztrue_)
+        this->observedEvents = observedEvents;
+    else if (observedEvents.empty())
+        this->observedEvents.clear();
+}
+
+void ExpData::setObservedEvents(const std::vector<realtype> &observedEvents, int iz) {
+    if (observedEvents.size() != (unsigned) nmaxevent_) {
+        throw AmiException("Input observedEvents did not match dimensions nmaxevent (%i), was %i", nmaxevent_, observedEvents.size());
+    }
+
+    for (int ie = 0; ie < nmaxevent_; ++ie)
+        this->observedEvents.at(iz + ie*nztrue_) = observedEvents.at(ie);
+}
+
+bool ExpData::isSetObservedEvents(int ie, int iz) const {
+    return !observedEvents.empty() && !isNaN(observedEvents.at(ie * nztrue_ + iz));
+}
+
+std::vector<realtype> const& ExpData::getObservedEvents() const {
+    return observedEvents;
+}
+
+const realtype *ExpData::getObservedEventsPtr(int ie) const {
+    if (!observedEvents.empty())
+        return &observedEvents.at(ie*nztrue_);
+
+    return nullptr;
+}
+
+void ExpData::setObservedEventsStdDev(const std::vector<realtype> &observedEventsStdDev) {
+    checkEventsDimension(observedEventsStdDev, "observedEventsStdDev");
+    checkSigmaPositivity(observedEventsStdDev, "observedEventsStdDev");
+
+    if (observedEventsStdDev.size() == (unsigned) nmaxevent_*nztrue_)
+        this->observedEventsStdDev = observedEventsStdDev;
+    else if (observedEventsStdDev.empty())
+        this->observedEventsStdDev.clear();
+}
+
+void ExpData::setObservedEventsStdDev(const realtype stdDev) {
+    checkSigmaPositivity(stdDev, "stdDev");
+    std::fill(observedEventsStdDev.begin() ,observedEventsStdDev.end(), stdDev);
+}
+
+void ExpData::setObservedEventsStdDev(const std::vector<realtype> &observedEventsStdDev, int iz) {
+    if (observedEventsStdDev.size() != (unsigned) nmaxevent_)
+        throw AmiException("Input observedEventsStdDev did not match dimensions nmaxevent (%i), was %i", nmaxevent_, observedEventsStdDev.size());
+    checkSigmaPositivity(observedEventsStdDev, "observedEventsStdDev");
+
+    for (int ie = 0; ie < nmaxevent_; ++ie)
+        this->observedEventsStdDev.at(iz + ie*nztrue_) = observedEventsStdDev.at(ie);
+}
+
+void ExpData::setObservedEventsStdDev(const realtype stdDev, int iz) {
+    checkSigmaPositivity(stdDev, "stdDev");
+
+    for (int ie = 0; ie < nmaxevent_; ++ie)
+        observedEventsStdDev.at(iz + ie*nztrue_) = stdDev;
+}
+
+bool ExpData::isSetObservedEventsStdDev(int ie, int iz) const {
+    if (!observedEventsStdDev.empty()) // avoid out of bound memory access
+        return !isNaN(observedEventsStdDev.at(ie * nztrue_ + iz));
+
+    return false;
+}
+
+std::vector<realtype> const& ExpData::getObservedEventsStdDev() const {
+    return observedEventsStdDev;
+}
+
+const realtype *ExpData::getObservedEventsStdDevPtr(int ie) const {
+    if (!observedEventsStdDev.empty())
+        return &observedEventsStdDev.at(ie*nztrue_);
+
+    return nullptr;
+}
+
+void ExpData::applyDimensions() {
+    applyDataDimension();
+    applyEventDimension();
+}
+
+void ExpData::applyDataDimension() {
+    observedData.resize(nt()*nytrue_, getNaN());
+    observedDataStdDev.resize(nt()*nytrue_, getNaN());
+}
+
+void ExpData::applyEventDimension() {
+    observedEvents.resize(nmaxevent_*nztrue_, getNaN());
+    observedEventsStdDev.resize(nmaxevent_*nztrue_, getNaN());
+}
+
+void ExpData::checkDataDimension(std::vector<realtype> const& input, const char *fieldname) const {
+    if (input.size() != (unsigned) nt()*nytrue_ && !input.empty())
+        throw AmiException("Input %s did not match dimensions nt (%i) x nytrue (%i), was %i", fieldname, nt(), nytrue_, input.size());
+}
+
+void ExpData::checkEventsDimension(std::vector<realtype> const& input, const char *fieldname) const {
+    if (input.size() != (unsigned) nmaxevent_*nztrue_ && !input.empty())
+        throw AmiException("Input %s did not match dimensions nt (%i) x nytrue (%i), was %i", fieldname, nmaxevent_, nztrue_, input.size());
+}
+
+void checkSigmaPositivity(std::vector<realtype> const& sigmaVector, const char *vectorName) {
+    for (auto&& sigma : sigmaVector)
+        checkSigmaPositivity(sigma, vectorName);
+}
+
+void checkSigmaPositivity(const realtype sigma, const char *sigmaName) {
+    if (sigma <= 0.0)
+        throw AmiException("Encountered sigma <= 0 in %s! value: %f", sigmaName, sigma);
+}
+
+int ExpData::nytrue() const
+{
+    return nytrue_;
+}
+
+int ExpData::nztrue() const
+{
+    return nztrue_;
+}
+
+int ExpData::nmaxevent() const
+{
+    return nmaxevent_;
+}
+
+ConditionContext::ConditionContext(Model *model, const ExpData *edata)
+    : model(model),
+      originalx0(model->getInitialStates()),
+      originalsx0(model->getInitialStateSensitivities()),
+      originalParameters(model->getParameters()),
+      originalFixedParameters(model->getFixedParameters()),
+      originalTimepoints(model->getTimepoints()),
+      originalParameterList(model->getParameterList()),
+      originalScaling(model->getParameterScale())
+{
+    applyCondition(edata);
+}
+
+ConditionContext::~ConditionContext()
+{
+    restore();
+}
+
+void ConditionContext::applyCondition(const ExpData *edata)
+{
+    if(!edata)
+        return;
+
+    // this needs to go first, otherwise nplist will not have the right
+    // dimension for all other fields that depend on Model::nplist
+    if(!edata->plist.empty())
+        model->setParameterList(edata->plist);
+
+    // this needs to go second as setParameterScale will reset sx0
+    if(!edata->pscale.empty()) {
+        if(edata->pscale.size() != (unsigned) model->np())
+            throw AmiException("Number of parameters (%d) in model does not"
+                               " match ExpData (%zd).",
+                               model->np(), edata->pscale.size());
+        model->setParameterScale(edata->pscale);
+
+    }
+
+    if(!edata->x0.empty()) {
+        if(edata->x0.size() != (unsigned) model->nx_rdata)
+            throw AmiException("Number of initial conditions (%d) in model does"
+                               " not match ExpData (%zd).",
+                               model->nx_rdata, edata->x0.size());
+        model->setInitialStates(edata->x0);
+    }
+
+    if(!edata->sx0.empty()) {
+        if(edata->sx0.size() != (unsigned) model->nx_rdata * model->nplist())
+            throw AmiException("Number of initial conditions sensitivities (%d)"
+                               " in model does not match ExpData (%zd).",
+                               model->nx_rdata * model->nplist(),
+                               edata->sx0.size());
+        model->setInitialStateSensitivities(edata->sx0);
+    }
+
+    if(!edata->parameters.empty()) {
+        if(edata->parameters.size() != (unsigned) model->np())
+            throw AmiException("Number of parameters (%d) in model does not"
+                               " match ExpData (%zd).",
+                               model->np(), edata->parameters.size());
+        model->setParameters(edata->parameters);
+    }
+
+    if(!edata->fixedParameters.empty()) {
+        // fixed parameter in model are superseded by those provided in edata
+        if(edata->fixedParameters.size() != (unsigned) model->nk())
+            throw AmiException("Number of fixed parameters (%d) in model does"
+                               " not match ExpData (%zd).",
+                               model->nk(), edata->fixedParameters.size());
+        model->setFixedParameters(edata->fixedParameters);
+    }
+
+    if(edata->nt()) {
+        // fixed parameter in model are superseded by those provided in edata
+        model->setTimepoints(edata->getTimepoints());
+    }
+}
+
+void ConditionContext::restore()
+{
+    // parameter list has to be set before initial state sensitivities
+    model->setParameterList(originalParameterList);
+    // parameter scale has to be set before initial state sensitivities
+    model->setParameterScale(originalScaling);
+    model->setInitialStates(originalx0);
+    model->setUnscaledInitialStateSensitivities(originalsx0);
+    model->setParameters(originalParameters);
+    model->setFixedParameters(originalFixedParameters);
+    model->setTimepoints(originalTimepoints);
+
+}
+
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/exception.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/exception.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2ea1e9b1c0eefb025823ed57094a0ad540d6880
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/exception.cpp
@@ -0,0 +1,55 @@
+#include "amici/exception.h"
+#include "amici/misc.h"
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstring>
+
+
+namespace amici {
+
+AmiException::AmiException(const char *fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(msg, sizeof(msg), fmt, ap);
+    va_end(ap);
+    storeBacktrace(12);
+}
+
+AmiException::AmiException(const amici::AmiException &old) {
+    snprintf(msg, sizeof(msg), "%s", old.msg);
+    snprintf(trace, sizeof(trace), "%s", old.trace);
+}
+
+const char *AmiException::what() const noexcept {
+    return msg;
+}
+
+const char *AmiException::getBacktrace() const {
+    return trace;
+}
+
+void AmiException::storeBacktrace(const int nMaxFrames) {
+    snprintf(trace, sizeof(trace), "%s", backtraceString(nMaxFrames).c_str());
+}
+
+CvodeException::CvodeException(const int error_code, const char *function) :
+    AmiException("Cvode routine %s failed with error code %i",function,error_code){}
+
+IDAException::IDAException(const int error_code, const char *function) :
+    AmiException("IDA routine %s failed with error code %i",function,error_code){}
+
+IntegrationFailure::IntegrationFailure(int code, realtype t) :
+    AmiException("AMICI failed to integrate the forward problem"),
+    error_code(code), time(t) {}
+
+IntegrationFailureB::IntegrationFailureB(int code, realtype t) :
+    AmiException("AMICI failed to integrate the backward problem"),
+    error_code(code), time(t) {}
+
+NewtonFailure::NewtonFailure(int code, const char *function) :
+    AmiException("NewtonSolver routine %s failed with error code %i",function,code) {
+    error_code = code;
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/forwardproblem.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/forwardproblem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0fb6749b1f474a34e724f2bdae5580aa04751d78
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/forwardproblem.cpp
@@ -0,0 +1,551 @@
+#include "amici/forwardproblem.h"
+
+#include "amici/cblas.h"
+#include "amici/misc.h"
+#include "amici/model.h"
+#include "amici/solver.h"
+#include "amici/exception.h"
+#include "amici/edata.h"
+#include "amici/rdata.h"
+#include "amici/steadystateproblem.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+namespace amici {
+
+extern msgIdAndTxtFp warnMsgIdAndTxt;
+
+
+ForwardProblem::ForwardProblem(ReturnData *rdata, const ExpData *edata,
+                               Model *model, Solver *solver)
+    : model(model),
+      rdata(rdata),
+      solver(solver),
+      edata(edata),
+      rootidx(static_cast<decltype (rootidx)::size_type>(model->ne * model->ne * model->nMaxEvent()), 0),
+      nroots(static_cast<decltype (nroots)::size_type>(model->ne), 0),
+      rootvals(static_cast<decltype (rootvals)::size_type>(model->ne), 0.0),
+      rvaltmp(static_cast<decltype (rvaltmp)::size_type>(model->ne), 0.0),
+      discs(static_cast<decltype (discs)::size_type>(model->nMaxEvent() * model->ne), 0.0),
+      irdiscs(model->nMaxEvent() * model->ne, 0.0),
+      x_disc(model->nx_solver, model->nMaxEvent()*model->ne),
+      xdot_disc(model->nx_solver, model->nMaxEvent()*model->ne),
+      xdot_old_disc(model->nx_solver, model->nMaxEvent()*model->ne),
+      dJydx(model->nJ * model->nx_solver * model->nt(), 0.0),
+      dJzdx(model->nJ * model->nx_solver * model->nMaxEvent(), 0.0),
+      t(model->t0()),
+      rootsfound(model->ne, 0),
+      Jtmp(SUNMatrixWrapper(model->nx_solver,model->nx_solver)),
+      x(model->nx_solver),
+      x_rdata(model->nx_rdata),
+      x_old(model->nx_solver),
+      dx(model->nx_solver),
+      dx_old(model->nx_solver),
+      xdot(model->nx_solver),
+      xdot_old(model->nx_solver),
+      sx(model->nx_solver,model->nplist()),
+      sx_rdata(model->nx_rdata,model->nplist()),
+      sdx(model->nx_solver,model->nplist()),
+      stau(model->nplist())
+{
+}
+
+
+void ForwardProblem::workForwardProblem() {
+    bool computeSensitivities =
+        solver->getSensitivityOrder() >= SensitivityOrder::first &&
+        model->nx_solver > 0;
+
+    model->initialize(x, dx, sx, sdx, computeSensitivities);
+    solver->setup(model->t0(), model, x, dx, sx, sdx);
+    // update x0 after computing consistence IC, only important for DAEs
+    x.copy(solver->getState(model->t0()));
+
+    model->fx_rdata(x_rdata, x);
+    if(solver->getSensitivityOrder() >= SensitivityOrder::first) {
+        model->fsx_rdata(sx_rdata, sx);
+    }
+
+    if(edata){
+        rdata->initializeObjectiveFunction();
+    }
+
+    /* if preequilibration is necessary, start Newton solver */
+    if (solver->getNewtonPreequilibration() || (edata && !edata->fixedParametersPreequilibration.empty())) {
+        handlePreequilibration();
+    } else {
+        model->fx_rdata(x_rdata, x);
+        rdata->x0 = x_rdata.getVector();
+        if (solver->getSensitivityMethod() == SensitivityMethod::forward &&
+                solver->getSensitivityOrder() >= SensitivityOrder::first) {
+            model->fsx_rdata(sx_rdata, sx);
+            for (int ix = 0; ix < rdata->nx; ix++) {
+                for (int ip = 0; ip < model->nplist(); ip++)
+                    rdata->sx0[ip*rdata->nx + ix] = sx_rdata.at(ix,ip);
+            }
+        }
+    }
+
+    /* perform presimulation if necessary */
+    if (edata && edata->t_presim > 0)
+        handlePresimulation();
+
+    /* loop over timepoints */
+    for (int it = 0; it < model->nt(); it++) {
+        auto nextTimepoint = model->getTimepoint(it);
+
+        if (nextTimepoint > model->t0()) {
+            if (model->nx_solver == 0) {
+                t = nextTimepoint;
+                break;
+            }
+
+            // Solve for nextTimepoint
+            while (t < nextTimepoint) {
+                if (std::isinf(nextTimepoint)) {
+                    SteadystateProblem sstate = SteadystateProblem(solver, x);
+                    sstate.workSteadyStateProblem(rdata, solver, model, it);
+                    sstate.writeSolution(&t, x, sx);
+                } else {
+                    int status = solver->run(nextTimepoint);
+                    solver->writeSolution(&t, x, dx, sx);
+                    /* sx will be copied from solver on demand if sensitivities
+                     are computed */
+                    if (status == AMICI_ILL_INPUT) {
+                        /* clustering of roots => turn off rootfinding */
+                        solver->turnOffRootFinding();
+                    } else if (status == AMICI_ROOT_RETURN) {
+                        handleEvent(&tlastroot, false);
+                    }
+                }
+            }
+        }
+        handleDataPoint(it);
+    }
+
+    /* fill events */
+    if (model->nz > 0) {
+        getEventOutput();
+    }
+
+    // set likelihood
+    if (!edata) {
+        rdata->invalidateLLH();
+        rdata->invalidateSLLH();
+    }
+
+    storeJacobianAndDerivativeInReturnData();
+    rdata->cpu_time = solver->getCpuTime();
+}
+
+void ForwardProblem::handlePreequilibration() {
+    // Are there dedicated condition preequilibration parameters provided?
+    bool overrideFixedParameters =
+        edata && !edata->fixedParametersPreequilibration.empty();
+
+    std::vector<realtype>
+        originalFixedParameters; // to restore after pre-equilibration
+
+    if (overrideFixedParameters) {
+        if (edata->fixedParametersPreequilibration.size() !=
+            (unsigned)model->nk())
+            throw AmiException(
+                "Number of fixed parameters (%d) in model does not match "
+                "preequilibration parameters in ExpData (%zd).",
+                model->nk(), edata->fixedParametersPreequilibration.size());
+        originalFixedParameters = model->getFixedParameters();
+        model->setFixedParameters(edata->fixedParametersPreequilibration);
+        model->initialize(x, dx, sx, sdx,
+                          solver->getSensitivityOrder() >=
+                              SensitivityOrder::first);
+    }
+
+    // pre-equilibrate
+    SteadystateProblem sstate = SteadystateProblem(solver, x);
+
+    sstate.workSteadyStateProblem(rdata, solver, model, -1);
+    sstate.writeSolution(&t, x, sx);
+
+    if (overrideFixedParameters) {
+        // Restore
+        model->setFixedParameters(originalFixedParameters);
+    }
+
+    updateAndReinitStatesAndSensitivities(true);
+}
+
+void ForwardProblem::updateAndReinitStatesAndSensitivities(bool isSteadystate) {
+
+    if (isSteadystate) {
+        model->fx_rdata(x_rdata, x);
+        rdata->x_ss = x_rdata.getVector();
+    }
+
+    model->fx0_fixedParameters(x);
+    solver->reInit(t, x, dx);
+    model->fx_rdata(x_rdata, x);
+
+    rdata->x0 = x_rdata.getVector();
+    if (solver->getSensitivityOrder() >= SensitivityOrder::first) {
+        if (isSteadystate) {
+            model->fsx_rdata(sx_rdata, sx);
+            for (int ip = 0; ip < model->nplist(); ip++)
+                std::copy_n(sx_rdata.data(ip), rdata->nx,
+                            &rdata->sx_ss.at(ip * rdata->nx));
+        }
+
+        model->fsx0_fixedParameters(sx, x);
+        model->fsx_rdata(sx_rdata, sx);
+
+        for (int ip = 0; ip < model->nplist(); ip++)
+            std::copy_n(sx_rdata.data(ip), rdata->nx,
+                        &rdata->sx0.at(ip * rdata->nx));
+
+        if (solver->getSensitivityMethod() == SensitivityMethod::forward)
+            solver->sensReInit(sx, sdx);
+    }
+}
+
+void ForwardProblem::handlePresimulation()
+{
+    // Are there dedicated condition preequilibration parameters provided?
+    bool overrideFixedParameters = edata && !edata->fixedParametersPresimulation.empty();
+
+    std::vector<realtype> originalFixedParameters; // to restore after pre-equilibration
+
+    if(overrideFixedParameters) {
+        if(edata->fixedParametersPresimulation.size() != (unsigned) model->nk())
+            throw AmiException("Number of fixed parameters (%d) in model does not match presimulation parameters in ExpData (%zd).",
+                           model->nk(), edata->fixedParametersPresimulation.size());
+        originalFixedParameters = model->getFixedParameters();
+        model->setFixedParameters(edata->fixedParametersPresimulation);
+    }
+    t = model->t0() - edata->t_presim;
+    updateAndReinitStatesAndSensitivities(false);
+
+    solver->run(model->t0());
+    solver->writeSolution(&t, x, dx, sx);
+    if(overrideFixedParameters) {
+        model->setFixedParameters(originalFixedParameters);
+    }
+    t = model->t0();
+    updateAndReinitStatesAndSensitivities(false);
+}
+
+
+void ForwardProblem::handleEvent(realtype *tlastroot, const bool seflag) {
+    /* store heaviside information at event occurence */
+    model->froot(t, x, dx, rootvals);
+
+    if (!seflag) {
+        solver->getRootInfo(rootsfound.data());
+    }
+
+    if (iroot < model->nMaxEvent() * model->ne) {
+        std::copy(rootsfound.begin(), rootsfound.end(),
+                  &rootidx[iroot * model->ne]);
+    }
+
+    rvaltmp = rootvals;
+
+    if (!seflag) {
+        /* only extract in the first event fired */
+        if (solver->getSensitivityOrder() >= SensitivityOrder::first &&
+            solver->getSensitivityMethod() == SensitivityMethod::forward) {
+            sx.copy(solver->getStateSensitivity(t));
+        }
+
+        /* only check this in the first event fired, otherwise this will always
+         * be true */
+        if (t == *tlastroot) {
+            throw AmiException("AMICI is stuck in an event, as the initial"
+                               "step-size after the event is too small. To fix "
+                               "this, increase absolute and relative tolerances!");
+        }
+        *tlastroot = t;
+    }
+
+    if(model->nz>0)
+        getEventOutput();
+
+    /* if we need to do forward sensitivities later on we need to store the old
+     * x and the old xdot */
+    if (solver->getSensitivityOrder() >= SensitivityOrder::first) {
+        /* store x and xdot to compute jump in sensitivities */
+        x_old = solver->getState(t);
+        if (solver->getSensitivityMethod() == SensitivityMethod::forward) {
+            model->fxdot(t, x, dx, xdot);
+            xdot_old = xdot;
+            dx_old = dx;
+
+            /* compute event-time derivative only for primary events, we get
+             * into trouble with multiple simultaneously firing events here (but
+             * is this really well defined then?), in that case just use the
+             * last ie and hope for the best. */
+            if (!seflag) {
+                for (int ie = 0; ie < model->ne; ie++) {
+                    if (rootsfound.at(ie) == 1) {
+                        /* only consider transitions false -> true */
+                        model->getEventTimeSensitivity(stau, t, ie, x, sx);
+                    }
+                }
+            }
+        } else if (solver->getSensitivityMethod() == SensitivityMethod::adjoint) {
+            /* store x to compute jump in discontinuity */
+            if (iroot < model->nMaxEvent() * model->ne) {
+                x_disc[iroot] = x;
+                xdot_disc[iroot] = xdot;
+                xdot_old_disc[iroot] = xdot_old;
+            }
+        }
+    }
+
+    model->updateHeaviside(rootsfound);
+
+    applyEventBolus();
+
+    if (iroot < model->nMaxEvent() * model->ne) {
+        discs[iroot] = t;
+        ++iroot;
+    } else {
+        warnMsgIdAndTxt("AMICI:mex:TOO_MUCH_EVENT",
+                        "Event was recorded but not reported as the number of "
+                        "occured events exceeded (nmaxevents)*(number of "
+                        "events in model definition)!");
+        /* reinitialise so that we can continue in peace */
+        solver->reInit(t, x, dx);
+        return;
+    }
+
+    if (solver->getSensitivityOrder() >= SensitivityOrder::first
+            && solver->getSensitivityMethod() == SensitivityMethod::forward) {
+        /* compute the new xdot  */
+        model->fxdot(t, x, dx, xdot);
+        applyEventSensiBolusFSA();
+    }
+
+    int secondevent = 0;
+
+    /* check whether we need to fire a secondary event */
+    model->froot(t, x, dx, rootvals);
+    for (int ie = 0; ie < model->ne; ie++) {
+        /* the same event should not trigger itself */
+        if (rootsfound.at(ie) == 0) {
+            /* check whether there was a zero-crossing */
+            if (0 > rvaltmp.at(ie) * rootvals.at(ie)) {
+                if (rvaltmp.at(ie) < rootvals.at(ie)) {
+                    rootsfound.at(ie) = 1;
+                } else {
+                    rootsfound.at(ie) = -1;
+                }
+                secondevent++;
+            } else {
+                rootsfound.at(ie) = 0;
+            }
+        } else {
+            /* don't fire the same event again */
+            rootsfound.at(ie) = 0;
+        }
+    }
+    /* fire the secondary event */
+    if (secondevent > 0) {
+        handleEvent(tlastroot, TRUE);
+    }
+
+    /* only reinitialise in the first event fired */
+    if (!seflag) {
+        solver->reInit(t, x, dx);
+
+        if (solver->getSensitivityOrder() >= SensitivityOrder::first) {
+            if (solver->getSensitivityMethod() == SensitivityMethod::forward) {
+                solver->sensReInit(sx, sdx);
+            }
+        }
+    }
+}
+
+void ForwardProblem::storeJacobianAndDerivativeInReturnData() {
+    model->fxdot(t, x, dx, xdot);
+    rdata->xdot = xdot.getVector();
+
+    model->fJ(t, 0.0, x, dx, xdot, Jtmp.get());
+    // CVODES uses colmajor, so we need to transform to rowmajor
+    for (int ix = 0; ix < model->nx_solver; ix++) {
+        for (int jx = 0; jx < model->nx_solver; jx++) {
+            rdata->J[ix * model->nx_solver + jx] =
+                Jtmp.data()[ix + model->nx_solver * jx];
+        }
+    }
+}
+
+void ForwardProblem::getEventOutput() {
+    if (t == model->getTimepoint(edata->nt() - 1)) {
+        // call from fillEvent at last timepoint
+        model->froot(t, x, dx, rootvals);
+    }
+
+    /* EVENT OUTPUT */
+    for (int ie = 0; ie < model->ne; ie++) {
+        /* only look for roots of the rootfunction not discontinuities */
+        if (nroots.at(ie) >= model->nMaxEvent())
+            continue;
+
+        /* only consider transitions false -> true or event filling */
+        if (rootsfound.at(ie) != 1 &&
+            t != model->getTimepoint(model->nt() - 1)) {
+            continue;
+        }
+
+        /* get event output */
+        model->getEvent(slice(rdata->z, nroots.at(ie), rdata->nz), ie, t, x);
+        /* if called from fillEvent at last timepoint,
+         then also get the root function value */
+        if (t == model->getTimepoint(model->nt() - 1))
+            model->getEventRegularization(slice(rdata->rz, nroots.at(ie),
+                                                rdata->nz), ie, t, x);
+
+        if (edata) {
+            model->getEventSigma(slice(rdata->sigmaz, nroots.at(ie), rdata->nz),
+                                 ie, nroots.at(ie), t, edata);
+            model->addEventObjective(rdata->llh, ie, nroots.at(ie), t, x,
+                                     *edata);
+
+            /* if called from fillEvent at last timepoint,
+               add regularization based on rz */
+            if (t == model->getTimepoint(model->nt() - 1))
+                model->addEventObjectiveRegularization(
+                    rdata->llh, ie, nroots.at(ie), t, x, *edata);
+        }
+
+        if (solver->getSensitivityOrder() >= SensitivityOrder::first) {
+            if (solver->getSensitivityMethod() == SensitivityMethod::forward) {
+                getEventSensisFSA(ie);
+            } else {
+                if (edata) {
+                model->getAdjointStateEventUpdate(slice(dJzdx, nroots.at(ie),
+                                                        model->nx_solver * model->nJ),
+                                                  ie, nroots.at(ie), t, x, *edata);
+                model->addPartialEventObjectiveSensitivity(rdata->sllh,
+                                                           rdata->s2llh,
+                                                           ie, nroots.at(ie),
+                                                           t, x, *edata);
+                }
+            }
+        }
+
+        nroots.at(ie)++;
+    }
+
+    if (t == model->getTimepoint(model->nt() - 1)) {
+        // call from fillEvent at last timepoint
+        // loop until all events are filled
+        if (std::any_of(nroots.cbegin(), nroots.cend(), [&](int curNRoots) {
+                return curNRoots < model->nMaxEvent();
+            }))
+            getEventOutput();
+    }
+}
+
+void ForwardProblem::getEventSensisFSA(int ie) {
+    if (t == model->getTimepoint(model->nt() - 1)) {
+        // call from fillEvent at last timepoint
+        model->getUnobservedEventSensitivity(slice(rdata->sz, nroots.at(ie),
+                                                   rdata->nz * rdata->nplist),
+                                             ie);
+        model->getEventRegularizationSensitivity(slice(rdata->srz,
+                                                       nroots.at(ie),
+                                                       rdata->nz * rdata->nplist),
+                                                 ie, t, x, sx);
+    } else {
+        model->getEventSensitivity(slice(rdata->sz, nroots.at(ie),
+                                         rdata->nz * rdata->nplist),
+                                   ie, t, x, sx);
+    }
+
+    if (edata) {
+        model->addEventObjectiveSensitivity(rdata->sllh, rdata->s2llh, ie,
+                                            nroots.at(ie), t, x, sx, *edata);
+    }
+}
+
+void ForwardProblem::handleDataPoint(int it) {
+    model->fx_rdata(x_rdata, x);
+    std::copy_n(x_rdata.data(), rdata->nx, &rdata->x.at(it * rdata->nx));
+
+    if (model->getTimepoint(it) > model->t0()) {
+        solver->getDiagnosis(it, rdata);
+    }
+
+    getDataOutput(it);
+}
+
+void ForwardProblem::getDataOutput(int it) {
+    model->getObservable(slice(rdata->y, it, rdata->ny), rdata->ts[it], x);
+    model->getObservableSigma(slice(rdata->sigmay, it, rdata->ny), it,
+                              edata);
+    if (edata) {
+        model->addObservableObjective(rdata->llh, it, x, *edata);
+        rdata->fres(it, *edata);
+        rdata->fchi2(it);
+    }
+
+    if (solver->getSensitivityOrder() >= SensitivityOrder::first &&
+        model->nplist() > 0) {
+
+        model->getObservableSigmaSensitivity(slice(rdata->ssigmay, it,
+                                                   model->nplist() * model->ny),
+                                             it, edata);
+
+        if (solver->getSensitivityMethod() == SensitivityMethod::forward) {
+            getDataSensisFSA(it);
+        } else {
+            if (edata) {
+                model->getAdjointStateObservableUpdate(slice(dJydx, it,
+                                                             model->nx_solver * model->nJ),
+                                                       it, x, *edata);
+                model->addPartialObservableObjectiveSensitivity(rdata->sllh,
+                                                                rdata->s2llh,
+                                                                it, x, *edata);
+            }
+        }
+    }
+}
+
+void ForwardProblem::getDataSensisFSA(int it) {
+    model->fsx_rdata(sx_rdata, sx);
+    for (int ix = 0; ix < rdata->nx; ix++) {
+        for (int ip = 0; ip < model->nplist(); ip++) {
+            rdata->sx[(it * model->nplist() + ip) * rdata->nx + ix] =
+                sx_rdata.at(ix, ip);
+        }
+    }
+
+    model->getObservableSensitivity(slice(rdata->sy, it,
+                                          model->nplist() * model->ny),
+                                    t, x, sx);
+
+    if (edata) {
+        model->addObservableObjectiveSensitivity(rdata->sllh, rdata->s2llh,
+                                                 it, x, sx, *edata);
+        rdata->fsres(it, *edata);
+        rdata->fFIM(it);
+    }
+}
+
+void ForwardProblem::applyEventBolus() {
+    for (int ie = 0; ie < model->ne; ie++)
+        if (rootsfound.at(ie) == 1) // only consider transitions false -> true
+            model->addStateEventUpdate(x, ie, t, xdot, xdot_old);
+}
+
+void ForwardProblem::applyEventSensiBolusFSA() {
+    for (int ie = 0; ie < model->ne; ie++)
+        if (rootsfound.at(ie) == 1) // only consider transitions false -> true
+            /*  */
+            model->addStateSensitivityEventUpdate(sx, ie, t, x_old, xdot,
+                                                  xdot_old, stau);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/hdf5.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/hdf5.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..694685ecd3fa711da0683b2a0dfdc84f19bcd3eb
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/hdf5.cpp
@@ -0,0 +1,854 @@
+#include "amici/hdf5.h"
+#include "amici/amici.h"
+
+#include <hdf5_hl.h>
+
+#include <cassert>
+#include <cstring>
+#include <algorithm>
+#ifdef AMI_HDF5_H_DEBUG
+#ifndef __APPLE__
+#include <cexecinfo>
+#else
+#include <execinfo.h>
+#endif
+#endif
+#include <unistd.h>
+#include <cmath>
+
+
+namespace amici {
+namespace hdf5 {
+
+/**
+ * @brief assertMeasurementDimensionsCompatible
+ * @param m
+ * @param n
+ * @param model
+ */
+void checkMeasurementDimensionsCompatible(hsize_t m, hsize_t n,
+                                          Model const& model) {
+    bool compatible = true;
+    // if this is rank 1, n and m can be swapped
+    if (n == 1) {
+        compatible &= (n == (unsigned)model.nt() || n == (unsigned)model.nytrue);
+        compatible &= (m == (unsigned)model.nytrue || m == (unsigned)model.nt());
+        compatible &= (m * n == (unsigned)model.nytrue * model.nt());
+    } else {
+        compatible &= (n == (unsigned)model.nytrue);
+        compatible &= (m == (unsigned)model.nt());
+    }
+
+    if(!compatible)
+        throw(AmiException("HDF5 measurement data does not match model. "
+                           "Incompatible dimensions."));
+}
+
+
+/**
+ * @brief assertEventDimensionsCompatible
+ * @param m
+ * @param n
+ * @param model
+ */
+void checkEventDimensionsCompatible(hsize_t m, hsize_t n, Model const& model) {
+    bool compatible = true;
+
+    // if this is rank 1, n and m can be swapped
+    if (n == 1) {
+        compatible &= (n == (unsigned)model.nMaxEvent() ||
+                       n == (unsigned)model.nztrue);
+        compatible &= (m == (unsigned)model.nztrue ||
+                       m == (unsigned)model.nMaxEvent());
+        compatible &= (m * n == (unsigned)model.nytrue * model.nMaxEvent());
+    } else {
+        compatible &= (n == (unsigned)model.nztrue);
+        compatible &= (m == (unsigned)model.nMaxEvent());
+    }
+
+    if(!compatible)
+        throw(AmiException("HDF5 event data does not match model. "
+                           "Incompatible dimensions."));
+}
+
+
+void createGroup(H5::H5File const& file,
+                 std::string const& groupPath,
+                 bool recursively) {
+
+    auto groupCreationPropertyList = H5P_DEFAULT;
+
+    if (recursively) {
+        groupCreationPropertyList = H5Pcreate(H5P_LINK_CREATE);
+        H5Pset_create_intermediate_group(groupCreationPropertyList, 1);
+    }
+
+    hid_t group = H5Gcreate(file.getId(), groupPath.c_str(),
+                            groupCreationPropertyList,
+                            H5P_DEFAULT, H5P_DEFAULT);
+    H5Pclose(groupCreationPropertyList);
+
+    if (group < 0)
+        throw(AmiException("Failed to create group in hdf5CreateGroup: %s",
+                           groupPath.c_str()));
+    H5Gclose(group);
+}
+
+std::unique_ptr<ExpData> readSimulationExpData(std::string const& hdf5Filename,
+                                               std::string const& hdf5Root,
+                                               Model const& model) {
+    H5::H5File file(hdf5Filename, H5F_ACC_RDONLY);
+
+    hsize_t m, n;
+
+    auto edata = std::unique_ptr<ExpData>(new ExpData(model));
+
+    if (model.ny * model.nt() > 0) {
+        if(locationExists(file,  hdf5Root + "/Y")) {
+            auto my = getDoubleDataset2D(file, hdf5Root + "/Y", m, n);
+            checkMeasurementDimensionsCompatible(m, n, model);
+            edata->setObservedData(my);
+        } else {
+            throw AmiException("Missing %s/Y in %s", hdf5Root.c_str(),
+                               hdf5Filename.c_str());
+        }
+
+        if(locationExists(file,  hdf5Root + "/Sigma_Y")) {
+            auto sigmay = getDoubleDataset2D(file, hdf5Root + "/Sigma_Y", m, n);
+            checkMeasurementDimensionsCompatible(m, n, model);
+            edata->setObservedDataStdDev(sigmay);
+        } else {
+            throw AmiException("Missing %s/Sigma_Y in %s", hdf5Root.c_str(),
+                               hdf5Filename.c_str());
+        }
+    }
+
+    if (model.nz * model.nMaxEvent() > 0) {
+        if(locationExists(file,  hdf5Root + "/Z")) {
+            auto mz = getDoubleDataset2D(file, hdf5Root + "/Z", m, n);
+            checkEventDimensionsCompatible(m, n, model);
+            edata->setObservedEvents(mz);
+        } else {
+            throw AmiException("Missing %s/Z in %s", hdf5Root.c_str(),
+                               hdf5Filename.c_str());
+        }
+
+        if(locationExists(file,  hdf5Root + "/Sigma_Z")) {
+            auto sigmaz = getDoubleDataset2D(file, hdf5Root + "/Sigma_Z", m, n);
+            checkEventDimensionsCompatible(m, n, model);
+            edata->setObservedEventsStdDev(sigmaz);
+        } else {
+            throw AmiException("Missing %s/Sigma_Z in %s", hdf5Root.c_str(),
+                               hdf5Filename.c_str());
+        }
+    }
+
+    if(locationExists(file,  hdf5Root + "/condition")) {
+        edata->fixedParameters = getDoubleDataset1D(file,
+                                                    hdf5Root + "/condition");
+    }
+
+    if(locationExists(file,  hdf5Root + "/conditionPreequilibration")) {
+        edata->fixedParametersPreequilibration = getDoubleDataset1D(
+                    file, hdf5Root + "/conditionPreequilibration");
+    }
+
+    if(locationExists(file,  hdf5Root + "/conditionPresimulation")) {
+        edata->fixedParametersPresimulation = getDoubleDataset1D(
+                    file, hdf5Root + "/conditionPresimulation");
+    }
+
+    if(attributeExists(file, hdf5Root, "t_presim")) {
+        edata->t_presim = getDoubleScalarAttribute(file, hdf5Root, "t_presim");
+    }
+
+    if(locationExists(file,  hdf5Root + "/ts")) {
+        edata->setTimepoints(getDoubleDataset1D(file, hdf5Root + "/ts"));
+    }
+
+    return edata;
+}
+
+void writeSimulationExpData(const ExpData &edata, H5::H5File const& file,
+                            const std::string &hdf5Location)
+{
+
+    if(!locationExists(file, hdf5Location))
+        createGroup(file, hdf5Location);
+
+    if (edata.nt())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/ts",
+                                      edata.getTimepoints());
+
+    if (!edata.fixedParameters.empty())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/condition",
+                                      edata.fixedParameters);
+
+    if (!edata.fixedParametersPreequilibration.empty())
+        createAndWriteDouble1DDataset(
+                    file, hdf5Location + "/conditionPreequilibration",
+                    edata.fixedParametersPreequilibration);
+
+    if (!edata.fixedParametersPresimulation.empty())
+        createAndWriteDouble1DDataset(
+                    file, hdf5Location + "/conditionPresimulation",
+                    edata.fixedParametersPresimulation);
+
+    H5LTset_attribute_double(file.getId(), hdf5Location.c_str(), "t_presim",
+                             &edata.t_presim, 1);
+
+    if (!edata.getObservedData().empty())
+        createAndWriteDouble2DDataset(
+                    file, hdf5Location + "/Y", edata.getObservedData(),
+                    edata.nt(), edata.nytrue());
+    if (!edata.getObservedDataStdDev().empty())
+        createAndWriteDouble2DDataset(
+                    file, hdf5Location + "/Sigma_Y",
+                    edata.getObservedDataStdDev(), edata.nt(), edata.nytrue());
+    if (!edata.getObservedEvents().empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/Z",
+                                      edata.getObservedEvents(),
+                                      edata.nmaxevent(), edata.nztrue());
+    if (!edata.getObservedEventsStdDev().empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/Sigma_Z",
+                                      edata.getObservedEventsStdDev(),
+                                      edata.nmaxevent(), edata.nztrue());
+}
+
+void writeReturnData(const ReturnData &rdata, H5::H5File const& file, const std::string &hdf5Location)
+{
+
+    if(!locationExists(file, hdf5Location))
+        createGroup(file, hdf5Location);
+
+    if (!rdata.ts.empty())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/t", rdata.ts);
+
+    H5LTset_attribute_double(file.getId(), hdf5Location.c_str(),
+                             "llh", &rdata.llh, 1);
+    H5LTset_attribute_double(file.getId(), hdf5Location.c_str(),
+                             "chi2", &rdata.chi2, 1);
+
+    H5LTset_attribute_int(file.getId(), hdf5Location.c_str(),
+                          "status", &rdata.status, 1);
+
+    if (!rdata.sllh.empty())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/sllh", rdata.sllh);
+
+    if (!rdata.res.empty())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/res", rdata.res);
+    if (!rdata.sres.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/sres", rdata.sres,
+                                      rdata.nt*rdata.nytrue, rdata.nplist);
+    if (!rdata.FIM.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/FIM",
+                                      rdata.FIM, rdata.nplist, rdata.nplist);
+
+    if (!rdata.x0.empty())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/x0", rdata.x0);
+
+    if (!rdata.x.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/x", rdata.x,
+                                      rdata.nt, rdata.nx);
+
+    if (!rdata.y.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/y", rdata.y,
+                                      rdata.nt, rdata.ny);
+
+    if (!rdata.z.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/z", rdata.z,
+                                      rdata.nmaxevent, rdata.nz);
+
+    if (!rdata.rz.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/rz", rdata.rz,
+                                      rdata.nmaxevent, rdata.nz);
+
+    if (!rdata.sigmay.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/sigmay",
+                                      rdata.sigmay, rdata.nt, rdata.ny);
+
+    if (!rdata.sigmaz.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/sigmaz",
+                                      rdata.sigmaz, rdata.nmaxevent, rdata.nz);
+
+    if (!rdata.s2llh.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/s2llh",
+                                      rdata.s2llh, rdata.nJ - 1, rdata.nplist);
+
+    if (!rdata.sx0.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/sx0", rdata.sx0,
+                                      rdata.nplist, rdata.nx);
+
+    if (!rdata.sx.empty())
+        createAndWriteDouble3DDataset(file, hdf5Location + "/sx", rdata.sx,
+                                      rdata.nt, rdata.nplist, rdata.nx);
+
+    if (!rdata.sy.empty())
+        createAndWriteDouble3DDataset(file, hdf5Location + "/sy", rdata.sy,
+                                      rdata.nt, rdata.nplist, rdata.ny);
+
+    if (!rdata.ssigmay.empty())
+        createAndWriteDouble3DDataset(file, hdf5Location + "/ssigmay",
+                                      rdata.ssigmay, rdata.nt,
+                                      rdata.nplist, rdata.ny);
+
+    if (!rdata.sz.empty())
+        createAndWriteDouble3DDataset(file, hdf5Location + "/sz", rdata.sz,
+                                      rdata.nmaxevent, rdata.nplist, rdata.nz);
+
+    if (!rdata.srz.empty())
+        createAndWriteDouble3DDataset(file, hdf5Location + "/srz", rdata.srz,
+                                      rdata.nmaxevent, rdata.nplist, rdata.nz);
+
+    if (!rdata.ssigmaz.empty())
+        createAndWriteDouble3DDataset(file, hdf5Location + "/ssigmaz",
+                                      rdata.ssigmaz,
+                                      rdata.nmaxevent, rdata.nplist, rdata.nz);
+
+    writeReturnDataDiagnosis(rdata, file, hdf5Location + "/diagnosis");
+}
+
+void writeReturnDataDiagnosis(const ReturnData &rdata,
+                              H5::H5File const& file,
+                              const std::string& hdf5Location) {
+
+    if(!locationExists(file, hdf5Location))
+        createGroup(file, hdf5Location);
+
+    if (!rdata.xdot.empty())
+        createAndWriteDouble1DDataset(file, hdf5Location + "/xdot", rdata.xdot);
+
+    if (!rdata.numsteps.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/numsteps",
+                                   rdata.numsteps);
+
+    if (!rdata.numrhsevals.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/numrhsevals",
+                                   rdata.numrhsevals);
+
+    if (!rdata.numerrtestfails.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/numerrtestfails",
+                                   rdata.numerrtestfails);
+
+    if (!rdata.numnonlinsolvconvfails.empty())
+        createAndWriteInt1DDataset(file,
+                                   hdf5Location + "/numnonlinsolvconvfails",
+                                   rdata.numnonlinsolvconvfails);
+
+    if (!rdata.order.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/order", rdata.order);
+
+    if (!rdata.numstepsB.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/numstepsB",
+                                   rdata.numstepsB);
+
+    if (!rdata.numrhsevalsB.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/numrhsevalsB",
+                                   rdata.numrhsevalsB);
+
+    if (!rdata.numerrtestfailsB.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/numerrtestfailsB",
+                                   rdata.numerrtestfailsB);
+
+    if (!rdata.numnonlinsolvconvfailsB.empty())
+        createAndWriteInt1DDataset(
+                    file, hdf5Location + "/numnonlinsolvconvfailsB",
+                    rdata.numnonlinsolvconvfailsB);
+
+    H5LTset_attribute_int(file.getId(), (hdf5Location + "").c_str(),
+                          "newton_status", &rdata.newton_status, 1);
+
+    if (!rdata.newton_numsteps.empty())
+        createAndWriteInt1DDataset(file, hdf5Location + "/newton_numsteps",
+                                   rdata.newton_numsteps);
+
+    if (!rdata.newton_numlinsteps.empty())
+        createAndWriteInt2DDataset(file, hdf5Location + "/newton_numlinsteps",
+                                   rdata.newton_numlinsteps,
+                                   rdata.newton_maxsteps, 2);
+
+    H5LTset_attribute_double(file.getId(), hdf5Location.c_str(),
+                             "newton_cpu_time", &rdata.newton_cpu_time, 1);
+
+    H5LTset_attribute_double(file.getId(), hdf5Location.c_str(),
+                             "cpu_time", &rdata.cpu_time, 1);
+    
+    H5LTset_attribute_double(file.getId(), hdf5Location.c_str(),
+                             "cpu_timeB", &rdata.cpu_timeB, 1);
+    
+    if (!rdata.J.empty())
+        createAndWriteDouble2DDataset(file, hdf5Location + "/J", rdata.J,
+                                      rdata.nx, rdata.nx);
+
+}
+
+
+void writeReturnData(ReturnData const& rdata,
+                     std::string const& hdf5Filename,
+                     std::string const& hdf5Location) {
+    auto file = createOrOpenForWriting(hdf5Filename);
+
+    writeReturnData(rdata, file, hdf5Location);
+}
+
+double getDoubleScalarAttribute(H5::H5File const& file,
+                                std::string const& optionsObject,
+                                std::string const& attributeName) {
+
+    double data = NAN;
+    herr_t status = H5LTget_attribute_double(file.getId(), optionsObject.c_str(),
+                                             attributeName.c_str(), &data);
+
+#ifdef AMI_HDF5_H_DEBUG
+    printf("%s: %e\n", attributeName.c_str(), data);
+#endif
+
+    if(status < 0)
+        throw AmiException("Attribute %s not found for object %s.",
+                           attributeName.c_str(), optionsObject.c_str());
+
+    return data;
+}
+
+int getIntScalarAttribute(H5::H5File const& file,
+                          std::string const& optionsObject,
+                          std::string const& attributeName) {
+    int data = 0;
+    herr_t status = H5LTget_attribute_int(file.getId(), optionsObject.c_str(),
+                                          attributeName.c_str(), &data);
+
+#ifdef AMI_HDF5_H_DEBUG
+    printf("%s: %d\n", attributeName.c_str(), data);
+#endif
+
+    if(status < 0)
+        throw AmiException("Attribute %s not found for object %s.",
+                           attributeName.c_str(), optionsObject.c_str());
+
+    return data;
+}
+
+
+void createAndWriteInt1DDataset(H5::H5File const& file,
+                                std::string const& datasetName,
+                                gsl::span<const int> buffer) {
+    hsize_t size = buffer.size();
+    H5::DataSpace dataspace(1, &size);
+    auto dataset = file.createDataSet(datasetName, H5::PredType::NATIVE_INT,
+                                      dataspace);
+    dataset.write(buffer.data(), H5::PredType::NATIVE_INT);
+}
+
+void createAndWriteDouble1DDataset(const H5::H5File &file,
+                                   std::string const& datasetName,
+                                   gsl::span<const double> buffer) {
+    hsize_t size = buffer.size();
+    H5::DataSpace dataspace(1, &size);
+    auto dataset = file.createDataSet(datasetName, H5::PredType::NATIVE_DOUBLE,
+                                      dataspace);
+    dataset.write(buffer.data(), H5::PredType::NATIVE_DOUBLE);
+}
+
+void createAndWriteDouble2DDataset(const H5::H5File &file,
+                                   std::string const& datasetName,
+                                   gsl::span<const double> buffer, hsize_t m,
+                                   hsize_t n) {
+    const hsize_t adims[] {m, n};
+    H5::DataSpace dataspace(2, adims);
+    auto dataset = file.createDataSet(datasetName, H5::PredType::NATIVE_DOUBLE,
+                                      dataspace);
+    dataset.write(buffer.data(), H5::PredType::NATIVE_DOUBLE);
+}
+
+void createAndWriteInt2DDataset(H5::H5File const& file,
+                                std::string const& datasetName,
+                                gsl::span<const int> buffer, hsize_t m,
+                                hsize_t n) {
+    const hsize_t adims[] {m, n};
+    H5::DataSpace dataspace(2, adims);
+    auto dataset = file.createDataSet(datasetName, H5::PredType::NATIVE_INT,
+                                      dataspace);
+    dataset.write(buffer.data(), H5::PredType::NATIVE_INT);
+}
+
+void createAndWriteDouble3DDataset(H5::H5File const& file,
+                                   std::string const& datasetName,
+                                   gsl::span<const double> buffer, hsize_t m,
+                                   hsize_t n, hsize_t o) {
+    const hsize_t adims[] {m, n, o};
+    H5::DataSpace dataspace(3, adims);
+    auto dataset = file.createDataSet(datasetName, H5::PredType::NATIVE_DOUBLE,
+                                      dataspace);
+    dataset.write(buffer.data(), H5::PredType::NATIVE_DOUBLE);
+}
+
+
+bool attributeExists(H5::H5File const& file,
+                     const std::string &optionsObject,
+                     const std::string &attributeName) {
+    AMICI_H5_SAVE_ERROR_HANDLER;
+    int result = H5Aexists_by_name(file.getId(), optionsObject.c_str(),
+                                   attributeName.c_str(), H5P_DEFAULT);
+    AMICI_H5_RESTORE_ERROR_HANDLER;
+    return result > 0;
+}
+
+bool attributeExists(H5::H5Object const& object,
+                     const std::string &attributeName) {
+    AMICI_H5_SAVE_ERROR_HANDLER;
+    int result = H5Aexists(object.getId(), attributeName.c_str());
+    AMICI_H5_RESTORE_ERROR_HANDLER;
+    return result > 0;
+}
+
+void readSolverSettingsFromHDF5(H5::H5File const& file, Solver &solver,
+                                const std::string &datasetPath) {
+
+    if(attributeExists(file, datasetPath, "atol")) {
+        solver.setAbsoluteTolerance(
+                    getDoubleScalarAttribute(file, datasetPath, "atol"));
+    }
+
+    if(attributeExists(file, datasetPath, "rtol")) {
+        solver.setRelativeTolerance(
+                    getDoubleScalarAttribute(file, datasetPath, "rtol"));
+    }
+
+    if(attributeExists(file, datasetPath, "atol_fsa")) {
+        solver.setAbsoluteToleranceFSA(
+                    getDoubleScalarAttribute(file, datasetPath, "atol_fsa"));
+    }
+
+    if(attributeExists(file, datasetPath, "rtol_fsa")) {
+        solver.setRelativeToleranceFSA(
+                    getDoubleScalarAttribute(file, datasetPath, "rtol_fsa"));
+    }
+
+
+    if(attributeExists(file, datasetPath, "atolB")) {
+        solver.setAbsoluteToleranceB(
+                    getDoubleScalarAttribute(file, datasetPath, "atolB"));
+    }
+
+    if(attributeExists(file, datasetPath, "rtolB")) {
+        solver.setRelativeToleranceB(
+                    getDoubleScalarAttribute(file, datasetPath, "rtolB"));
+    }
+
+    if(attributeExists(file, datasetPath, "quad_atol")) {
+        solver.setAbsoluteToleranceQuadratures(
+                    getDoubleScalarAttribute(file, datasetPath, "quad_atol"));
+    }
+
+    if(attributeExists(file, datasetPath, "quad_rtol")) {
+        solver.setRelativeToleranceQuadratures(
+                    getDoubleScalarAttribute(file, datasetPath, "quad_rtol"));
+    }
+
+    if(attributeExists(file, datasetPath, "ss_atol")) {
+        solver.setAbsoluteToleranceSteadyState(
+                    getDoubleScalarAttribute(file, datasetPath, "ss_atol"));
+    }
+
+    if(attributeExists(file, datasetPath, "ss_rtol")) {
+        solver.setRelativeToleranceSteadyState(
+                    getDoubleScalarAttribute(file, datasetPath, "ss_rtol"));
+    }
+
+    if(attributeExists(file, datasetPath, "ss_atol_sensi")) {
+        solver.setAbsoluteToleranceSteadyStateSensi(
+                    getDoubleScalarAttribute(file, datasetPath,
+                                             "ss_atol_sensi"));
+    }
+
+    if(attributeExists(file, datasetPath, "ss_rtol_sensi")) {
+        solver.setRelativeToleranceSteadyStateSensi(
+                    getDoubleScalarAttribute(file, datasetPath,
+                                             "ss_rtol_sensi"));
+    }
+
+    if(attributeExists(file, datasetPath, "maxsteps")) {
+        solver.setMaxSteps(
+                    getIntScalarAttribute(file, datasetPath, "maxsteps"));
+    }
+
+    if(attributeExists(file, datasetPath, "maxstepsB")) {
+        solver.setMaxStepsBackwardProblem(
+                    getIntScalarAttribute(file, datasetPath, "maxstepsB"));
+    }
+
+    if(attributeExists(file, datasetPath, "lmm")) {
+        solver.setLinearMultistepMethod(
+                    static_cast<LinearMultistepMethod>(
+                        getIntScalarAttribute(file, datasetPath, "lmm")));
+    }
+
+    if(attributeExists(file, datasetPath, "iter")) {
+        solver.setNonlinearSolverIteration(
+                    static_cast<NonlinearSolverIteration>(
+                        getIntScalarAttribute(file, datasetPath, "iter")));
+    }
+
+    if(attributeExists(file, datasetPath, "stldet")) {
+        solver.setStabilityLimitFlag(
+                    getIntScalarAttribute(file, datasetPath, "stldet"));
+    }
+
+    if(attributeExists(file, datasetPath, "ordering")) {
+        solver.setStateOrdering(
+                    getIntScalarAttribute(file, datasetPath, "ordering"));
+    }
+
+    if(attributeExists(file, datasetPath, "interpType")) {
+        solver.setInterpolationType(
+                    static_cast<InterpolationType>(
+                        getIntScalarAttribute(file, datasetPath,
+                                              "interpType")));
+    }
+
+    if(attributeExists(file, datasetPath, "sensi_meth")) {
+        solver.setSensitivityMethod(
+                    static_cast<SensitivityMethod>(
+                        getIntScalarAttribute(file, datasetPath, "sensi_meth")));
+    }
+
+    if(attributeExists(file, datasetPath, "sensi")) {
+        solver.setSensitivityOrder(
+                    static_cast<SensitivityOrder>(
+                        getIntScalarAttribute(file, datasetPath, "sensi")));
+    }
+
+    if(attributeExists(file, datasetPath, "newton_maxsteps")) {
+        solver.setNewtonMaxSteps(
+                    getIntScalarAttribute(file, datasetPath, "newton_maxsteps"));
+    }
+
+    if(attributeExists(file, datasetPath, "newton_preeq")) {
+        solver.setNewtonPreequilibration(
+                    getIntScalarAttribute(file, datasetPath, "newton_preeq"));
+    }
+
+    if(attributeExists(file, datasetPath, "newton_maxlinsteps")) {
+        solver.setNewtonMaxLinearSteps(
+                    getIntScalarAttribute(file, datasetPath,
+                                          "newton_maxlinsteps"));
+    }
+
+    if(attributeExists(file, datasetPath, "linsol")) {
+        solver.setLinearSolver(
+                    static_cast<LinearSolver>(
+                        getIntScalarAttribute(file, datasetPath, "linsol")));
+    }
+
+    if(attributeExists(file, datasetPath, "ism")) {
+        solver.setInternalSensitivityMethod(
+                    static_cast<InternalSensitivityMethod>(
+                        getIntScalarAttribute(file, datasetPath, "ism")));
+    }
+}
+
+void readSolverSettingsFromHDF5(const std::string &hdffile, Solver &solver,
+                                const std::string &datasetPath) {
+    H5::H5File file(hdffile, H5F_ACC_RDONLY, H5P_DEFAULT);
+
+    readSolverSettingsFromHDF5(file, solver, datasetPath);
+}
+
+void readModelDataFromHDF5(const std::string &hdffile, Model &model,
+                           const std::string &datasetPath) {
+    H5::H5File file(hdffile, H5F_ACC_RDONLY, H5P_DEFAULT);
+
+    readModelDataFromHDF5(file, model, datasetPath);
+}
+
+void readModelDataFromHDF5(const H5::H5File &file, Model &model,
+                           const std::string &datasetPath) {
+    if(attributeExists(file, datasetPath, "tstart")) {
+        model.setT0(getDoubleScalarAttribute(file, datasetPath, "tstart"));
+    }
+
+    if(locationExists(file, datasetPath + "/pscale")) {
+        auto pscaleInt = getIntDataset1D(file, datasetPath + "/pscale");
+        std::vector<ParameterScaling> pscale(pscaleInt.size());
+        for(int i = 0; (unsigned)i < pscaleInt.size(); ++i)
+            pscale[i] = static_cast<ParameterScaling>(pscaleInt[i]);
+        model.setParameterScale(pscale);
+    } else if (attributeExists(file, datasetPath, "pscale")) {
+        // if pscale is the same for all parameters,
+        // it can be set as scalar attribute for convenience
+        model.setParameterScale(
+                    static_cast<ParameterScaling>(
+                        getDoubleScalarAttribute(file,  datasetPath, "pscale")));
+    }
+
+    if(attributeExists(file, datasetPath, "nmaxevent")) {
+        model.setNMaxEvent(getIntScalarAttribute(file, datasetPath, "nmaxevent"));
+    }
+
+    if(attributeExists(file, datasetPath, "steadyStateSensitivityMode")) {
+        model.setSteadyStateSensitivityMode(
+                    static_cast<SteadyStateSensitivityMode>(
+                        getIntScalarAttribute(file, datasetPath,
+                                              "steadyStateSensitivityMode")));
+    }
+
+    if(locationExists(file, datasetPath + "/theta")) {
+        model.setParameters(getDoubleDataset1D(file, datasetPath + "/theta"));
+    }
+
+    if(locationExists(file, datasetPath + "/kappa")) {
+        model.setFixedParameters(getDoubleDataset1D(file, datasetPath + "/kappa"));
+    }
+
+    if(locationExists(file, datasetPath + "/ts")) {
+        model.setTimepoints(getDoubleDataset1D(file, datasetPath + "/ts"));
+    }
+
+    if(locationExists(file, datasetPath + "/sens_ind")) {
+        auto sensInd = getIntDataset1D(file, datasetPath + "/sens_ind");
+        model.setParameterList(sensInd);
+    }
+
+    if(locationExists(file, datasetPath + "/x0")) {
+        auto x0 = getDoubleDataset1D(file, datasetPath + "/x0");
+        if(!x0.empty())
+            model.setInitialStates(x0);
+    }
+
+    if(locationExists(file, datasetPath + "/sx0")) {
+        hsize_t length0 = 0;
+        hsize_t length1 = 0;
+        auto sx0 = getDoubleDataset2D(file, datasetPath + "/sx0",
+                                      length0, length1);
+        if(!sx0.empty()) {
+            if (length0 != (unsigned) model.nplist()
+                    && length1 != (unsigned) model.nx_rdata)
+                throw(AmiException("Dimension mismatch when reading sx0. "
+                                   "Expected %dx%d, got %llu, %llu.",
+                                   model.nx_rdata, model.nplist(), length0, length1));
+            model.setUnscaledInitialStateSensitivities(sx0);
+        }
+    }
+
+}
+
+H5::H5File createOrOpenForWriting(const std::string &hdf5filename)
+{
+    H5::H5File file;
+    AMICI_H5_SAVE_ERROR_HANDLER;
+    try {
+        file = H5::H5File(hdf5filename, H5F_ACC_RDWR);
+        AMICI_H5_RESTORE_ERROR_HANDLER;
+    } catch(...) {
+        AMICI_H5_RESTORE_ERROR_HANDLER;
+        file = H5::H5File(hdf5filename, H5F_ACC_EXCL);
+    }
+
+    return file;
+}
+
+bool locationExists(const H5::H5File &file, const std::string &location)
+{
+    AMICI_H5_SAVE_ERROR_HANDLER;
+    auto result = H5Lexists(file.getId(), location.c_str(), H5P_DEFAULT) > 0;
+    AMICI_H5_RESTORE_ERROR_HANDLER;
+    return result;
+}
+
+bool locationExists(const std::string &filename, const std::string &location)
+{
+    H5::H5File file(filename, H5F_ACC_RDONLY);
+    return locationExists(file, location);
+}
+
+std::vector<int> getIntDataset1D(const H5::H5File &file,
+                                 std::string const& name) {
+    auto dataset = file.openDataSet(name);
+    auto dataspace = dataset.getSpace();
+
+    int rank = dataspace.getSimpleExtentNdims();
+    if(rank != 1)
+        throw(AmiException("Expected array of rank 1 in %s", name.c_str()));
+
+    hsize_t dim;
+    dataspace.getSimpleExtentDims(&dim);
+    std::vector<int> result(dim);
+    if(!result.empty())
+        dataset.read(result.data(), H5::PredType::NATIVE_INT);
+    return result;
+}
+
+
+std::vector<double> getDoubleDataset1D(const H5::H5File &file,
+                                       const std::string &name)
+{
+    auto dataset = file.openDataSet(name);
+    auto dataspace = dataset.getSpace();
+
+    int rank = dataspace.getSimpleExtentNdims();
+    if(rank != 1)
+        throw(AmiException("Expected array of rank 1 in %s", name.c_str()));
+
+    hsize_t dim;
+    dataspace.getSimpleExtentDims(&dim);
+    std::vector<double> result(dim);
+    if(!result.empty())
+        dataset.read(result.data(), H5::PredType::NATIVE_DOUBLE);
+
+    return result;
+
+}
+
+std::vector<double> getDoubleDataset2D(const H5::H5File &file,
+                                       const std::string &name,
+                                       hsize_t &m, hsize_t &n)
+{
+    m = n = 0;
+
+    auto dataset = file.openDataSet(name);
+    auto dataspace = dataset.getSpace();
+
+    int rank = dataspace.getSimpleExtentNdims();
+    if(rank != 2)
+        throw(AmiException("Expected array of rank 2 in %s", name.c_str()));
+
+    hsize_t dims[2];
+    dataspace.getSimpleExtentDims(dims);
+    m = dims[0];
+    n = dims[1];
+
+    std::vector<double> result(m * n);
+    if(!result.empty())
+        dataset.read(result.data(), H5::PredType::NATIVE_DOUBLE);
+
+    return result;
+}
+
+std::vector<double> getDoubleDataset3D(const H5::H5File &file,
+                                       const std::string &name,
+                                       hsize_t &m, hsize_t &n, hsize_t &o)
+{
+    m = n = o = 0;
+
+    auto dataset = file.openDataSet(name);
+    auto dataspace = dataset.getSpace();
+
+    int rank = dataspace.getSimpleExtentNdims();
+    if(rank != 3)
+        throw(AmiException("Expected array of rank 3 in %s", name.c_str()));
+
+    hsize_t dims[3];
+    dataspace.getSimpleExtentDims(dims);
+    m = dims[0];
+    n = dims[1];
+    o = dims[2];
+
+    std::vector<double> result(m * n * o);
+    if(!result.empty())
+        dataset.read(result.data(), H5::PredType::NATIVE_DOUBLE);
+
+    return result;
+}
+
+} // namespace hdf5
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/interface_matlab.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/interface_matlab.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd39951644743396baf14af3d714b44c599650fc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/interface_matlab.cpp
@@ -0,0 +1,496 @@
+/**
+ * @file   interface_matlab.cpp
+ * @brief  core routines for mex interface
+ *
+ * This file defines the fuction mexFunction which is executed upon calling the
+ * mex file from matlab
+ */
+
+#include "amici/interface_matlab.h"
+
+#include "amici/model.h"
+#include "amici/exception.h"
+#include "amici/edata.h"
+#include "amici/returndata_matlab.h"
+
+#include <assert.h>
+#include <blas.h>
+#include <cstring>
+#include <memory>
+
+namespace amici {
+
+    int dbl2int(const double x);
+
+/**
+ * @brief The mexFunctionArguments enum takes care of the ordering of mex file
+ * arguments (indexing in prhs)
+ */
+enum mexRhsArguments {
+    RHS_TIMEPOINTS,
+    RHS_PARAMETERS,
+    RHS_CONSTANTS,
+    RHS_OPTIONS,
+    RHS_PLIST,
+    RHS_XSCALE_UNUSED,
+    RHS_INITIALIZATION,
+    RHS_DATA,
+    RHS_NUMARGS_REQUIRED = RHS_DATA,
+    RHS_NUMARGS
+};
+
+
+/*!
+ * amici_blasCBlasTransToBlasTrans translates AMICI_BLAS_TRANSPOSE values to
+ * CBlas readable strings
+ *
+ * @param trans       flag indicating transposition and complex conjugation
+ *
+ * @return cblastrans CBlas readable CHAR indicating transposition and complex
+ * conjugation
+ */
+char amici_blasCBlasTransToBlasTrans(BLASTranspose trans) {
+    switch (trans) {
+    case BLASTranspose::noTrans:
+        return 'N';
+    case BLASTranspose::trans:
+        return 'T';
+    case BLASTranspose::conjTrans:
+        return 'C';
+    }
+    throw std::invalid_argument("Invalid argument to amici_blasCBlasTransToBlasTrans");
+}
+
+void amici_dgemm(BLASLayout layout, BLASTranspose TransA,
+                 BLASTranspose TransB, const int M, const int N,
+                 const int K, const double alpha, const double *A,
+                 const int lda, const double *B, const int ldb,
+                 const double beta, double *C, const int ldc) {
+    assert(layout == BLASLayout::colMajor);
+
+    const ptrdiff_t M_ = M;
+    const ptrdiff_t N_ = N;
+    const ptrdiff_t K_ = K;
+    const ptrdiff_t lda_ = lda;
+    const ptrdiff_t ldb_ = ldb;
+    const ptrdiff_t ldc_ = ldc;
+    const char transA = amici_blasCBlasTransToBlasTrans(TransA);
+    const char transB = amici_blasCBlasTransToBlasTrans(TransB);
+
+    FORTRAN_WRAPPER(dgemm)(&transA, &transB,
+                           &M_, &N_, &K_,
+                           &alpha, A, &lda_, B, &ldb_, &beta, C, &ldc_);
+}
+
+void amici_dgemv(BLASLayout layout, BLASTranspose TransA,
+                 const int M, const int N, const double alpha, const double *A,
+                 const int lda, const double *X, const int incX,
+                 const double beta, double *Y, const int incY) {
+    assert(layout == BLASLayout::colMajor);
+
+    const ptrdiff_t M_ = M;
+    const ptrdiff_t N_ = N;
+    const ptrdiff_t lda_ = lda;
+    const ptrdiff_t incX_ = incX;
+    const ptrdiff_t incY_ = incY;
+    const char transA = amici_blasCBlasTransToBlasTrans(TransA);
+
+    FORTRAN_WRAPPER(dgemv)(&transA, &M_, &N_, &alpha, A, &lda_, X, &incX_, &beta, Y, &incY_);
+}
+
+void amici_daxpy(int n, double alpha, const double *x, const int incx, double *y, int incy) {
+
+    const ptrdiff_t n_ = n;
+    const ptrdiff_t incx_ = incx;
+    const ptrdiff_t incy_ = incy;
+
+    FORTRAN_WRAPPER(daxpy)(&n_, &alpha, x, &incx_, y, &incy_);
+}
+
+/** conversion from mxArray to vector<realtype>
+  * @param array Matlab array to create vector from
+  * @param length Number of elements in array
+  * @return std::vector with data from array
+  */
+std::vector<realtype> mxArrayToVector(const mxArray *array, int length) {
+    return {mxGetPr(array), mxGetPr(array) + length};
+}
+
+std::unique_ptr<ExpData> expDataFromMatlabCall(const mxArray *prhs[],
+                               Model const &model) {
+    if (!mxGetPr(prhs[RHS_DATA]))
+        return nullptr;
+
+    auto edata = std::unique_ptr<ExpData>(new ExpData(model));
+
+    // Y
+    if (mxArray *dataY = mxGetProperty(prhs[RHS_DATA], 0, "Y")) {
+        auto ny_my = static_cast<int>(mxGetN(dataY));
+        if (ny_my != model.nytrue) {
+            throw AmiException("Number of observables in data matrix (%i) does "
+                               "not match model ny (%i)",
+                               ny_my, model.nytrue);
+        }
+        auto nt_my = static_cast<int>(mxGetM(dataY));
+        if (nt_my != model.nt()) {
+            throw AmiException("Number of time-points in data matrix does (%i) "
+                               "not match provided time vector (%i)",
+                               nt_my, model.nt());
+        }
+        mxArray *dataYT;
+        mexCallMATLAB(1, &dataYT, 1, &dataY, "transpose");
+        auto observedData = mxArrayToVector(dataYT, ny_my * nt_my);
+        edata->setObservedData(observedData);
+
+    } else {
+        throw AmiException("Field Y not specified as field in data struct!");
+    }
+
+    // Sigma Y
+    if (mxArray *dataSigmaY = mxGetProperty(prhs[RHS_DATA], 0, "Sigma_Y")) {
+        auto ny_sigmay = static_cast<int>(mxGetN(dataSigmaY));
+        if (ny_sigmay != model.nytrue) {
+            throw AmiException("Number of observables in data-sigma matrix (%i) "
+                               "does not match model ny (%i)",
+                               ny_sigmay, model.nytrue);
+        }
+        auto nt_sigmay = static_cast<int>(mxGetM(dataSigmaY));
+        if (nt_sigmay != model.nt()) {
+            throw AmiException("Number of time-points in data-sigma matrix (%i) "
+                               "does not match provided time vector (%i)",
+                               nt_sigmay, model.nt());
+        }
+
+        mxArray *dataSigmaYT;
+        mexCallMATLAB(1, &dataSigmaYT, 1, &dataSigmaY, "transpose");
+        auto observedDataSigma = mxArrayToVector(dataSigmaYT, ny_sigmay * nt_sigmay);
+        edata->setObservedDataStdDev(observedDataSigma);
+    } else {
+        throw AmiException("Field Sigma_Y not specified as field in data struct!");
+    }
+
+    // Z
+    if (mxArray *dataZ = mxGetProperty(prhs[RHS_DATA], 0, "Z")) {
+        auto nz_mz = static_cast<int>(mxGetN(dataZ));
+        if (nz_mz != model.nztrue) {
+            throw AmiException("Number of events in event matrix (%i) does not "
+                               "match provided nz (%i)",
+                               nz_mz, model.nztrue);
+        }
+        auto ne_mz = static_cast<int>(mxGetM(dataZ));
+        if (ne_mz != model.nMaxEvent()) {
+            throw AmiException("Number of time-points in event matrix (%i) does "
+                               "not match provided nmaxevent (%i)",
+                               ne_mz, model.nMaxEvent());
+        }
+        mxArray *dataZT;
+        mexCallMATLAB(1, &dataZT, 1, &dataZ, "transpose");
+        auto observedEvents = mxArrayToVector(dataZT, nz_mz * ne_mz);
+        edata->setObservedEvents(observedEvents);
+    } else {
+        throw AmiException("Field Z not specified as field in data struct!");
+    }
+
+    // Sigma Z
+    if (mxArray *dataSigmaZ = mxGetProperty(prhs[RHS_DATA], 0, "Sigma_Z")) {
+        auto nz_sigmaz = static_cast<int>(mxGetN(dataSigmaZ));
+        if (nz_sigmaz != model.nztrue) {
+            throw AmiException("Number of events in event-sigma matrix (%i) does "
+                               "not match provided nz (%i)",
+                               nz_sigmaz, model.nztrue);
+        }
+        auto ne_sigmaz = static_cast<int>(mxGetM(dataSigmaZ));
+        if (ne_sigmaz != model.nMaxEvent()) {
+            throw AmiException("Number of time-points in event-sigma matrix (%i) "
+                               "does not match provided nmaxevent (%i)",
+                               ne_sigmaz, model.nMaxEvent());
+        }
+        mxArray *dataSigmaZT;
+        mexCallMATLAB(1, &dataSigmaZT, 1, &dataSigmaZ, "transpose");
+        auto observedEventsSigma = mxArrayToVector(dataSigmaZT, nz_sigmaz * ne_sigmaz);
+        edata->setObservedEventsStdDev(observedEventsSigma);
+    } else {
+        throw AmiException("Field Sigma_Z not specified as field in data struct!");
+
+    }
+
+    // preequilibration condition parameters
+    if (mxArray *dataPreeq = mxGetProperty(prhs[RHS_DATA], 0, "conditionPreequilibration")) {
+        int m = (int)mxGetM(dataPreeq);
+        int n = (int)mxGetN(dataPreeq);
+        if(m * n > 0) {
+            if (m * n != model.nk() || (m != 1 && n != 1)) {
+                throw AmiException("Number of preequilibration parameters (%dx%d) does "
+                                   "not match model (%d)", m, n, model.nk());
+            }
+            edata->fixedParametersPreequilibration =
+                    std::vector<realtype>(mxGetPr(dataPreeq), mxGetPr(dataPreeq) + m * n);
+        }
+    }
+
+    return edata;
+}
+
+/** conversion from double to int with checking for loss of data
+  *  @param x input
+  *  @return int_x casted value
+  */
+int dbl2int(const double x){
+    if((std::round(x)-x) != 0.0)
+        throw AmiException("Invalid non-integer value for integer option");
+    return(static_cast<int>(x));
+}
+
+void setSolverOptions(const mxArray *prhs[], int nrhs, Solver &solver)
+{
+    if (mxGetPr(prhs[RHS_OPTIONS])) {
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "atol")) {
+            solver.setAbsoluteTolerance(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "atol")));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "rtol")) {
+            solver.setRelativeTolerance(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "rtol")));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "quad_atol")) {
+            solver.setAbsoluteToleranceQuadratures(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "quad_atol")));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "quad_rtol")) {
+            solver.setRelativeToleranceQuadratures(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "quad_rtol")));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "ss_atol")) {
+            solver.setAbsoluteToleranceQuadratures(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "ss_atol")));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "ss_rtol")) {
+            solver.setRelativeToleranceQuadratures(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "ss_rtol")));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "maxsteps")) {
+            solver.setMaxSteps(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "maxsteps"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "maxstepsB")) {
+            solver.setMaxStepsBackwardProblem(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "maxstepsB"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "lmm")) {
+            solver.setLinearMultistepMethod(static_cast<LinearMultistepMethod>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "lmm")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "iter")) {
+            solver.setNonlinearSolverIteration(static_cast<NonlinearSolverIteration>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "iter")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "interpType")) {
+            solver.setInterpolationType(static_cast<InterpolationType>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "interpType")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "linsol")) {
+            solver.setLinearSolver(static_cast<LinearSolver>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "linsol")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "sensi")) {
+            solver.setSensitivityOrder(static_cast<SensitivityOrder>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "sensi")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "ism")) {
+            solver.setInternalSensitivityMethod(static_cast<InternalSensitivityMethod>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "ism")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "sensi_meth")) {
+            solver.setSensitivityMethod(static_cast<SensitivityMethod>(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "sensi_meth")))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "ordering")) {
+            solver.setStateOrdering(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "ordering"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "stldet")) {
+            solver.setStabilityLimitFlag(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "stldet"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "newton_preeq")) {
+            solver.setNewtonPreequilibration(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "newton_preeq"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "newton_maxsteps")) {
+            solver.setNewtonMaxSteps(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "newton_maxsteps"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "newton_maxlinsteps")) {
+            solver.setNewtonMaxLinearSteps(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "newton_maxlinsteps"))));
+        }
+    }
+}
+
+void setModelData(const mxArray *prhs[], int nrhs, Model &model)
+{
+    if (mxGetPr(prhs[RHS_OPTIONS])) {
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "nmaxevent")) {
+            model.setNMaxEvent(dbl2int(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "nmaxevent"))));
+        }
+
+        if (mxGetProperty(prhs[RHS_OPTIONS], 0, "tstart")) {
+            model.setT0(mxGetScalar(mxGetProperty(prhs[RHS_OPTIONS], 0, "tstart")));
+        }
+
+        if (mxArray *a = mxGetProperty(prhs[RHS_OPTIONS], 0, "pscale")) {
+            if(mxGetM(a) == 1 && mxGetN(a) == 1) {
+                model.setParameterScale(static_cast<ParameterScaling>(dbl2int(mxGetScalar(a))));
+            } else if((mxGetM(a) == 1 && mxGetN(a) == model.np())
+                      || (mxGetN(a) == 1 && mxGetM(a) == model.np())) {
+                auto pscaleArray = static_cast<double *>(mxGetData(a));
+                std::vector<ParameterScaling> pscale(model.np());
+                for(int ip = 0; ip < model.np(); ++ip) {
+                    pscale[ip] = static_cast<ParameterScaling>(dbl2int(pscaleArray[ip]));
+                }
+                model.setParameterScale(pscale);
+            } else {
+                throw AmiException("Provided pscale has invalid dimensions!");
+            }
+        }
+    }
+
+    if (prhs[RHS_TIMEPOINTS] &&
+                mxGetM(prhs[RHS_TIMEPOINTS]) * mxGetN(prhs[RHS_TIMEPOINTS]) > 0) {
+            model.setTimepoints(std::vector<double>(
+                                    mxGetPr(prhs[RHS_TIMEPOINTS]),
+                                    mxGetPr(prhs[RHS_TIMEPOINTS])
+                                    + (int)mxGetM(prhs[RHS_TIMEPOINTS]) * mxGetN(prhs[RHS_TIMEPOINTS])));
+
+    }
+
+    if (model.np() > 0) {
+        if (mxGetPr(prhs[RHS_PARAMETERS])) {
+            if (mxGetM(prhs[RHS_PARAMETERS]) * mxGetN(prhs[RHS_PARAMETERS]) ==
+                    model.np()) {
+                model.setParameters(std::vector<double>(mxGetPr(prhs[RHS_PARAMETERS]),
+                                                        mxGetPr(prhs[RHS_PARAMETERS])
+                                                        + mxGetM(prhs[RHS_PARAMETERS]) * mxGetN(prhs[RHS_PARAMETERS])));
+            }
+        }
+    }
+
+    if (model.nk() > 0) {
+        if (mxGetPr(prhs[RHS_CONSTANTS])) {
+            if (mxGetM(prhs[RHS_CONSTANTS]) * mxGetN(prhs[RHS_CONSTANTS]) ==
+                    model.nk()) {
+                model.setFixedParameters(std::vector<double>(mxGetPr(prhs[RHS_CONSTANTS]),
+                                                             mxGetPr(prhs[RHS_CONSTANTS])
+                                                             + mxGetM(prhs[RHS_CONSTANTS]) * mxGetN(prhs[RHS_CONSTANTS])));
+            }
+        }
+    }
+    if (mxGetPr(prhs[RHS_PLIST])) {
+        model.setParameterList(std::vector<int>(mxGetPr(prhs[RHS_PLIST]),
+                                                mxGetPr(prhs[RHS_PLIST])
+                                                + mxGetM(prhs[RHS_PLIST]) * mxGetN(prhs[RHS_PLIST])));
+    } else {
+        model.requireSensitivitiesForAllParameters();
+    }
+
+    /* Check, if initial states and sensitivities are passed by user or must be
+             * calculated */
+    if (mxGetPr(prhs[RHS_INITIALIZATION])) {
+        mxArray *x0 = mxGetField(prhs[RHS_INITIALIZATION], 0, "x0");
+        if (x0 && (mxGetM(x0) * mxGetN(x0)) > 0) {
+            /* check dimensions */
+            if (mxGetN(x0) != 1) {
+                throw AmiException("Number of rows in x0 field must be equal to 1!");
+            }
+            if (mxGetM(x0) != model.nx_rdata) {
+                throw AmiException("Number of columns in x0 field "
+                                   "does not agree with number of "
+                                   "model states!");
+            }
+        }
+    }
+
+    /* Check, if initial states and sensitivities are passed by user or must be
+             * calculated */
+    if (mxGetPr(prhs[RHS_INITIALIZATION])) {
+        mxArray *x0 = mxGetField(prhs[RHS_INITIALIZATION], 0, "x0");
+        if (x0 && (mxGetM(x0) * mxGetN(x0)) > 0) {
+            /* check dimensions */
+            if (mxGetN(x0) != 1) {
+                throw AmiException("Number of rows in x0 field must be equal to 1!");
+            }
+            if (mxGetM(x0) != model.nx_rdata) {
+                throw AmiException("Number of columns in x0 field "
+                                   "does not agree with number of "
+                                   "model states!");
+            }
+
+            model.setInitialStates(std::vector<double>(mxGetPr(x0),
+                                                       mxGetPr(x0) + mxGetM(x0) * mxGetN(x0)));
+        }
+
+        mxArray *sx0 = mxGetField(prhs[RHS_INITIALIZATION], 0, "sx0");
+        if (sx0 && (mxGetM(sx0) * mxGetN(sx0)) > 0) {
+            /* check dimensions */
+            if (mxGetN(sx0) != model.nplist()) {
+                throw AmiException("Number of rows in sx0 field "
+                                   "does not agree with number of "
+                                   "model parameters!");
+            }
+            if (mxGetM(sx0) != model.nx_rdata) {
+                throw AmiException("Number of columns in sx0 "
+                                   "field does not agree with "
+                                   "number of model states!");
+            }
+            model.setInitialStateSensitivities(std::vector<double>(mxGetPr(sx0),
+                                                                   mxGetPr(sx0) + mxGetM(sx0) * mxGetN(sx0)));
+        }
+    }
+}
+
+} // namespace amici
+
+
+/*!
+ * mexFunction is the main interface function for the MATLAB interface. It reads
+ * in input data (udata and edata) and
+ * creates output data compound (rdata) and then calls the AMICI simulation
+ * routine to carry out numerical integration.
+ *
+ * @param nlhs number of output arguments of the matlab call
+ * @param plhs pointer to the array of output arguments
+ * @param nrhs number of input arguments of the matlab call
+ * @param prhs pointer to the array of input arguments
+ */
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
+    // use matlab error reporting
+    amici::warnMsgIdAndTxt = &mexWarnMsgIdAndTxt;
+    amici::errMsgIdAndTxt = &mexErrMsgIdAndTxt;
+
+    if (nlhs != 1) {
+        amici::errMsgIdAndTxt("AMICI:mex:setup","Incorrect number of output arguments (must be 1)!");
+    } else if(nrhs < amici::RHS_NUMARGS_REQUIRED) {
+        amici::errMsgIdAndTxt("AMICI:mex:setup", "Incorrect number of input arguments (must be at least 7)!");
+    };
+
+    auto model = getModel();
+    auto solver = model->getSolver();
+    setModelData(prhs, nrhs, *model);
+    setSolverOptions(prhs, nrhs, *solver);
+
+    std::unique_ptr<amici::ExpData> edata;
+    if (nrhs > amici::RHS_DATA && mxGetPr(prhs[amici::RHS_DATA])) {
+        try {
+            edata = std::move(amici::expDataFromMatlabCall(prhs, *model));
+        } catch (amici::AmiException const& ex) {
+            amici::errMsgIdAndTxt("AMICI:mex:setup","Failed to read experimental data:\n%s",ex.what());
+        }
+    } else if (solver->getSensitivityOrder() >= amici::SensitivityOrder::first &&
+               solver->getSensitivityMethod() == amici::SensitivityMethod::adjoint) {
+        amici::errMsgIdAndTxt("AMICI:mex:setup","No data provided!");
+    }
+
+    /* ensures that plhs[0] is available */
+    auto rdata = amici::runAmiciSimulation(*solver, edata.get(), *model);
+    plhs[0] = getReturnDataMatlabFromAmiciCall(rdata.get());
+
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/main.template.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/main.template.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d6caf54a874172cd3a201d744583720f098b090
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/main.template.cpp
@@ -0,0 +1,115 @@
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <amici/amici.h>    /* AMICI base functions */
+#include <amici/hdf5.h>     /* AMICI HDF5 I/O functions */
+#include "wrapfunctions.h"  /* model-provided functions */
+
+/* This is a scaffold for a stand-alone AMICI simulation executable
+ * demonstrating
+ * use of the AMICI C++ API.
+ *
+ * This program reads AMICI options from an HDF5 file, prints some results
+ * and writes additional results to an HDF5 file. The name of the HDF5 file
+ * is expected as single command line argument.
+ *
+ * An initial HDF5 file with the required fields can be generated using MATLAB
+ * by adding the following lines
+ * at the end of simulate_${MODEL_NAME}.m file just before the final "end":
+ *
+ *    %% Write data that is passed to AMICI to HDF5
+ *    hdffile = fullfile(pwd, 'mydata.h5');
+ *    structToHDF5Attribute(hdffile, '/options', options_ami);
+ *    h5writeatt(hdffile, '/options', 'ts', tout);
+ *    h5writeatt(hdffile, '/options', 'nt', numel(tout));
+ *    h5writeatt(hdffile, '/options', 'theta', theta);
+ *    h5writeatt(hdffile, '/options', 'kappa', kappa);
+ *    if(~isempty(data))
+ *      structToHDF5Attribute(hdffile, '/data', data);
+ *    end
+ *
+ * ... and then running a simulation from MATLAB as usual.
+ *
+ * Default UserData settings can be written to an HDF5 file with:
+ *     structToHDF5Attribute('test.h5', '/options', amioption())
+ */
+
+// Function prototypes
+void processReturnData(amici::ReturnData *rdata, amici::Model *model);
+void printReturnData(amici::ReturnData *rdata, amici::Model *model);
+
+int main(int argc, char **argv) {
+    // HDF5 file to read and write data (full path)
+    const char *hdffile;
+
+    // Check command line arguments
+    if (argc != 2) {
+        fprintf(stderr, "Error: must provide HDF5 input file as first and only "
+                        "argument.\n");
+        return 1;
+    } else {
+        hdffile = argv[1];
+    }
+
+    auto model = getModel();
+    auto solver = model->getSolver();
+
+    // Read AMICI settings and model parameters from HDF5 file
+    amici::hdf5::readModelDataFromHDF5(hdffile, *model, "/options");
+    amici::hdf5::readSolverSettingsFromHDF5(hdffile, *solver, "/options");
+
+    // Read ExpData (experimental data for model) from HDF5 file
+    auto edata = amici::hdf5::readSimulationExpData(hdffile, "/data", *model);
+
+    // Run the simulation
+    auto rdata = runAmiciSimulation(*solver, edata.get(), *model);
+
+    // Do something with the simulation results
+    processReturnData(rdata.get(), model.get());
+
+    // Save simulation results to HDF5 file
+    amici::hdf5::writeReturnData(*rdata, hdffile, "/solution");
+
+    return 0;
+}
+
+void processReturnData(amici::ReturnData *rdata, amici::Model *model) {
+    // show some the simulation results
+    printReturnData(rdata, model);
+}
+
+void printReturnData(amici::ReturnData *rdata, amici::Model *model) {
+    // Print of some the simulation results
+
+    printf("\n\nStates (xdata):\n");
+    for (int i = 0; i < model->nx_rdata; ++i) {
+        for (int j = 0; j < model->nt(); ++j)
+            printf("%e\t", rdata->x[j + model->nt() * i]);
+        printf("\n");
+    }
+
+    printf("\nObservables (ydata):\n");
+    for (int i = 0; i < model->ny; ++i) {
+        for (int j = 0; j < model->nt(); ++j)
+            printf("%e\t", rdata->y[j + model->nt() * i]);
+        printf("\n");
+    }
+
+    printf("\n\ndx/dt (xdotdata):\n");
+    for (int i = 0; i < model->nx_solver; ++i)
+        printf("%e\t", rdata->xdot[i]);
+
+    //    printf("\nJacobian (jdata)\n");
+    //    for(int i = 0; i < nx_solver; ++i) {
+    //        for(int j = 0; j < nx_solver; ++j)
+    //            printf("%e\t", rdata->J[i + nx_solver * j]);
+    //        printf("\n");
+    //    }
+
+    printf("\n");
+    printf("Loglikelihood (llh): %e\n", rdata->llh);
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/misc.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/misc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73d66ee913d47a1d2841b7d8bc1ae4fca2198bdc
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/misc.cpp
@@ -0,0 +1,155 @@
+#include "amici/misc.h"
+#include "amici/amici.h"
+#include "amici/symbolic_functions.h"
+
+#include <cstdio>
+#include <cstring>
+#include <sstream>
+#if defined(_WIN32)
+#define PLATFORM_WINDOWS // Windows
+#elif defined(_WIN64)
+#define PLATFORM_WINDOWS // Windows
+#elif defined(__CYGWIN__) && !defined(_WIN32)
+#define PLATFORM_WINDOWS // Windows (Cygwin POSIX under Microsoft Window)
+#else
+#include <execinfo.h>
+#include <dlfcn.h>    // for dladdr
+#include <cxxabi.h>   // for __cxa_demangle
+#endif
+
+namespace amici {
+    
+gsl::span<realtype> slice(std::vector<realtype> &data, const int index,
+                          const unsigned size) {
+    if ((index + 1) * size > data.size())
+        throw std::out_of_range("requested slice is out of data range");
+    if (size > 0)
+        return gsl::make_span(&data.at(index*size), size);
+    else
+        return gsl::make_span(static_cast<realtype*>(nullptr), 0);
+}
+
+double getUnscaledParameter(double scaledParameter, ParameterScaling scaling)
+{
+    switch (scaling) {
+    case ParameterScaling::log10:
+        return pow(10, scaledParameter);
+    case ParameterScaling::ln:
+        return exp(scaledParameter);
+    case ParameterScaling::none:
+        return scaledParameter;
+    }
+
+    throw AmiException("Invalid value for ParameterScaling.");
+}
+
+void unscaleParameters(gsl::span<const realtype> bufferScaled,
+                       gsl::span<const ParameterScaling> pscale,
+                       gsl::span<realtype> bufferUnscaled)
+{
+    Expects(bufferScaled.size() == pscale.size());
+    Expects(bufferScaled.size() == bufferUnscaled.size());
+
+    for (gsl::span<realtype>::index_type ip = 0;
+         ip < bufferScaled.size(); ++ip) {
+        bufferUnscaled[ip] = getUnscaledParameter(bufferScaled[ip], pscale[ip]);
+    }
+}
+
+
+double getScaledParameter(double unscaledParameter, ParameterScaling scaling)
+{
+    switch (scaling) {
+    case ParameterScaling::log10:
+        return log10(unscaledParameter);
+    case ParameterScaling::ln:
+        return log(unscaledParameter);
+    case ParameterScaling::none:
+        return unscaledParameter;
+    }
+
+    throw AmiException("Invalid value for ParameterScaling.");
+}
+
+
+void scaleParameters(gsl::span<const realtype> bufferUnscaled,
+                     gsl::span<const ParameterScaling> pscale,
+                     gsl::span<realtype> bufferScaled)
+{
+    Expects(bufferScaled.size() == pscale.size());
+    Expects(bufferScaled.size() == bufferUnscaled.size());
+
+    for (gsl::span<realtype>::index_type ip = 0;
+         ip < bufferUnscaled.size(); ++ip) {
+        bufferScaled[ip] = getScaledParameter(bufferUnscaled[ip], pscale[ip]);
+    }
+
+}
+
+int checkFinite(gsl::span<const realtype> array, const char *fun)
+{
+    for (int idx = 0; idx < (int) array.size(); idx++) {
+        if (isNaN(array[idx])) {
+            warnMsgIdAndTxt(
+                "AMICI:NaN",
+                "AMICI encountered a NaN value at index %i of %i in %s!", idx,
+                (int) array.size(), fun);
+            return AMICI_RECOVERABLE_ERROR;
+        }
+        if (isInf(array[idx])) {
+            warnMsgIdAndTxt(
+                "AMICI:Inf",
+                "AMICI encountered an Inf value at index %i of %i in %s!", idx,
+                (int) array.size(), fun);
+            return AMICI_RECOVERABLE_ERROR;
+        }
+    }
+    return AMICI_SUCCESS;
+}
+
+std::string backtraceString(const int maxFrames)
+{
+    std::ostringstream trace_buf;
+
+#ifdef PLATFORM_WINDOWS
+    trace_buf << "stacktrace not available on windows platforms\n";
+#else
+    void *callstack[maxFrames];
+    char buf[1024];
+    int nFrames = backtrace(callstack, maxFrames);
+    char **symbols = backtrace_symbols(callstack, nFrames);
+
+    // start at 2 to omit AmiException and storeBacktrace
+    for (int i = 2; i < nFrames; i++) {
+        // call
+        Dl_info info;
+        if (dladdr(callstack[i], &info) && info.dli_sname) {
+            char *demangled = nullptr;
+            int status = -1;
+            if (info.dli_sname[0] == '_')
+                demangled = abi::__cxa_demangle(info.dli_sname, nullptr, nullptr,
+                                                &status);
+            snprintf(buf, sizeof(buf), "%-3d %*p %s + %zd\n", i - 2,
+                     int(2 + sizeof(void *) * 2), callstack[i],
+                     status == 0 ? demangled
+                                 : info.dli_sname == nullptr ? symbols[i]
+                                                               : info.dli_sname,
+                     static_cast<ssize_t>((char *)callstack[i] -
+                                          (char *)info.dli_saddr));
+            free(demangled);
+        } else {
+            snprintf(buf, sizeof(buf), "%-3d %*p %s\n", i - 2,
+                     int(2 + sizeof(void *) * 2), callstack[i],
+                     symbols[i]);
+        }
+        trace_buf << buf;
+    }
+    free(symbols);
+
+    if (nFrames == maxFrames)
+        trace_buf << "[truncated]\n";
+#endif
+    return trace_buf.str();
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/model.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/model.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9e21e5a6d6aaee8f6a91a2c349bb288e1b30387a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/model.cpp
@@ -0,0 +1,1846 @@
+#include "amici/model.h"
+#include "amici/amici.h"
+#include "amici/exception.h"
+#include "amici/misc.h"
+#include "amici/symbolic_functions.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <numeric>
+#include <regex>
+#include <typeinfo>
+#include <utility>
+
+namespace amici {
+
+/**
+ * @brief local helper to check whether the provided buffer has the expected
+ * size
+ * @param buffer buffer to which values are to be written
+ * @param expected_size expected size of the buffer
+ */
+static void checkBufferSize(gsl::span<realtype> buffer,
+                            unsigned expected_size) {
+    if (buffer.size() != expected_size)
+        throw AmiException("Incorrect buffer size! Was %u, expected %u.",
+                           buffer.size(), expected_size);
+}
+
+/**
+ * @brief local helper function to write computed slice to provided buffer
+ * @param slice computed value
+ * @param buffer buffer to which values are to be written
+ */
+static void writeSlice(gsl::span<const realtype> slice,
+                       gsl::span<realtype> buffer) {
+    checkBufferSize(buffer, slice.size());
+    std::copy(slice.begin(), slice.end(), buffer.data());
+}
+
+/**
+ * @brief local helper function to get parameters
+ * @param ids vector of name/ids of (fixed)Parameters
+ * @param values values of the (fixed)Parameters
+ * @param id name/id to look for in the vector
+ * @param variable_name string indicating what variable we are lookin at
+ * @param id_name string indicating whether name or id was specified
+ * @return value of the selected parameter
+ */
+static realtype getValueById(std::vector<std::string> const &ids,
+                             std::vector<realtype> const &values,
+                             std::string const &id, const char *variable_name,
+                             const char *id_name) {
+    auto it = std::find(ids.begin(), ids.end(), id);
+    if (it != ids.end())
+        return values.at(it - ids.begin());
+
+    throw AmiException("Could not find %s with specified %s", variable_name,
+                       id_name);
+}
+
+/**
+ * @brief local helper function to set parameters
+ * @param ids vector of names/ids of (fixed)Parameters
+ * @param values values of the (fixed)Parameters
+ * @param value for the selected parameter
+ * @param id name/id to look for in the vector
+ * @param variable_name string indicating what variable we are lookin at
+ * @param id_name string indicating whether name or id was specified
+ */
+static void setValueById(std::vector<std::string> const &ids,
+                         std::vector<realtype> &values, realtype value,
+                         std::string const &id, const char *variable_name,
+                         const char *id_name) {
+    auto it = std::find(ids.begin(), ids.end(), id);
+    if (it != ids.end())
+        values.at(it - ids.begin()) = value;
+    else
+        throw AmiException("Could not find %s with specified %s", variable_name,
+                           id_name);
+}
+
+/**
+ * @brief local helper function to set parameters via regex
+ * @param ids vector of names/ids of (fixed)Parameters
+ * @param values values of the (fixed)Parameters
+ * @param value for the selected parameter
+ * @param regex string according to which names/ids are to be matched
+ * @param variable_name string indicating what variable we are lookin at
+ * @param id_name string indicating whether name or id was specified
+ * @return number of matched names/ids
+ */
+static int setValueByIdRegex(std::vector<std::string> const &ids,
+                             std::vector<realtype> &values, realtype value,
+                             std::string const &regex,
+                             const char *variable_name, const char *id_name) {
+    try {
+        std::regex pattern(regex);
+        int n_found = 0;
+        for (const auto &id : ids) {
+            if (std::regex_match(id, pattern)) {
+                values.at(&id - &ids[0]) = value;
+                ++n_found;
+            }
+        }
+
+        if (n_found == 0)
+            throw AmiException("Could not find %s with specified %s",
+                               variable_name, id_name);
+
+        return n_found;
+    } catch (std::regex_error const &e) {
+        throw AmiException("Specified regex pattern could not be compiled: %s",
+                           e.what());
+    }
+}
+
+Model::Model() : dxdotdp(0, 0), x_pos_tmp(0) {}
+
+Model::Model(const int nx_rdata, const int nxtrue_rdata, const int nx_solver,
+             const int nxtrue_solver, const int ny, const int nytrue,
+             const int nz, const int nztrue, const int ne, const int nJ,
+             const int nw, const int ndwdx, const int ndwdp, const int ndxdotdw,
+             std::vector<int> ndJydy, const int nnz, const int ubw,
+             const int lbw, SecondOrderMode o2mode,
+             const std::vector<realtype> &p, std::vector<realtype> k,
+             const std::vector<int> &plist, std::vector<realtype> idlist,
+             std::vector<int> z2event)
+    : nx_rdata(nx_rdata), nxtrue_rdata(nxtrue_rdata), nx_solver(nx_solver),
+      nxtrue_solver(nxtrue_solver), ny(ny), nytrue(nytrue), nz(nz),
+      nztrue(nztrue), ne(ne), nw(nw), ndwdx(ndwdx), ndwdp(ndwdp),
+      ndxdotdw(ndxdotdw), ndJydy(std::move(ndJydy)), nnz(nnz), nJ(nJ), ubw(ubw),
+      lbw(lbw), o2mode(o2mode), idlist(std::move(idlist)),
+      J(nx_solver, nx_solver, nnz, CSC_MAT),
+      dxdotdw(nx_solver, nw, ndxdotdw, CSC_MAT),
+      dwdx(nw, nx_solver, ndwdx, CSC_MAT), M(nx_solver, nx_solver), w(nw),
+      dwdp(ndwdp), x_rdata(nx_rdata, 0.0), sx_rdata(nx_rdata, 0.0), h(ne, 0.0),
+      total_cl(nx_rdata - nx_solver),
+      stotal_cl((nx_rdata - nx_solver) * p.size()), x_pos_tmp(nx_solver),
+      unscaledParameters(p), originalParameters(p),
+      fixedParameters(std::move(k)), z2event(std::move(z2event)), plist_(plist),
+      stateIsNonNegative(nx_solver, false),
+      pscale(std::vector<ParameterScaling>(p.size(), ParameterScaling::none)) {
+
+    // Can't use derivedClass::wasPythonGenerated() in ctor.
+    // Guess we are using Python if ndJydy is not empty
+    if (!this->ndJydy.empty()) {
+        if (static_cast<unsigned>(nytrue) != this->ndJydy.size())
+            throw std::runtime_error(
+                "Number of elements in ndJydy is not equal "
+                " nytrue.");
+
+        for (int iytrue = 0; iytrue < nytrue; ++iytrue)
+            dJydy.emplace_back(
+                SUNMatrixWrapper(nJ, ny, this->ndJydy[iytrue], CSC_MAT));
+    } else {
+        dJydy_matlab = std::vector<realtype>(nJ * nytrue * ny, 0.0);
+    }
+
+    requireSensitivitiesForAllParameters();
+}
+
+bool operator==(const Model &a, const Model &b) {
+    if (typeid(a) != typeid(b))
+        return false;
+
+    return (a.nx_rdata == b.nx_rdata) && (a.nxtrue_rdata == b.nxtrue_rdata) &&
+           (a.nx_solver == b.nx_solver) &&
+           (a.nxtrue_solver == b.nxtrue_solver) && (a.ny == b.ny) &&
+           (a.nytrue == b.nytrue) && (a.nz == b.nz) && (a.nztrue == b.nztrue) &&
+           (a.ne == b.ne) && (a.nw == b.nw) && (a.ndwdx == b.ndwdx) &&
+           (a.ndwdp == b.ndwdp) && (a.ndxdotdw == b.ndxdotdw) &&
+           (a.nnz == b.nnz) && (a.nJ == b.nJ) && (a.ubw == b.ubw) &&
+           (a.lbw == b.lbw) && (a.o2mode == b.o2mode) &&
+           (a.z2event == b.z2event) && (a.idlist == b.idlist) && (a.h == b.h) &&
+           (a.unscaledParameters == b.unscaledParameters) &&
+           (a.originalParameters == b.originalParameters) &&
+           (a.fixedParameters == b.fixedParameters) && (a.plist_ == b.plist_) &&
+           (a.x0data == b.x0data) && (a.sx0data == b.sx0data) &&
+           (a.ts == b.ts) && (a.nmaxevent == b.nmaxevent) &&
+           (a.pscale == b.pscale) &&
+           (a.stateIsNonNegative == b.stateIsNonNegative) &&
+           (a.tstart == b.tstart);
+}
+
+void Model::initialize(AmiVector &x, AmiVector &dx, AmiVectorArray &sx,
+                       AmiVectorArray & /*sdx*/, bool computeSensitivities) {
+    initializeStates(x);
+    if (computeSensitivities)
+        initializeStateSensitivities(sx, x);
+
+    fdx0(x, dx);
+    if (computeSensitivities)
+        fsdx0();
+
+    if (ne)
+        initHeaviside(x, dx);
+}
+
+void Model::initializeB(AmiVector &xB, AmiVector &dxB, AmiVector &xQB) {
+    xB.reset();
+    dxB.reset();
+    xQB.reset();
+}
+
+void Model::initializeStates(AmiVector &x) {
+    if (x0data.empty()) {
+        fx0(x);
+    } else {
+        std::vector<realtype> x0_solver(nx_solver, 0.0);
+        ftotal_cl(total_cl.data(), x0data.data());
+        fx_solver(x0_solver.data(), x0data.data());
+        for (int ix = 0; ix < nx_solver; ix++) {
+            x[ix] = (realtype)x0_solver.at(ix);
+        }
+    }
+}
+
+void Model::initializeStateSensitivities(AmiVectorArray &sx, AmiVector &x) {
+    if (sx0data.empty()) {
+        fsx0(sx, x);
+    } else {
+        realtype *stcl = nullptr;
+        std::vector<realtype> sx0_solver_slice(nx_solver, 0.0);
+        for (int ip = 0; ip < nplist(); ip++) {
+            if (ncl() > 0)
+                stcl = &stotal_cl.at(plist(ip) * ncl());
+            fstotal_cl(stcl, &sx0data.at(ip * nx_rdata), plist(ip));
+            fsx_solver(sx0_solver_slice.data(), &sx0data.at(ip * nx_rdata));
+            for (int ix = 0; ix < nx_solver; ix++) {
+                sx.at(ix, ip) = (realtype)sx0_solver_slice.at(ix);
+            }
+        }
+    }
+}
+
+void Model::initHeaviside(AmiVector &x, AmiVector &dx) {
+    std::vector<realtype> rootvals(ne, 0.0);
+    froot(tstart, x, dx, rootvals);
+    for (int ie = 0; ie < ne; ie++) {
+        if (rootvals.at(ie) < 0) {
+            h.at(ie) = 0.0;
+        } else if (rootvals.at(ie) == 0) {
+            throw AmiException(
+                "Simulation started in an event. This could lead to "
+                "unexpected results, aborting simulation! Please "
+                "specify an earlier simulation start via "
+                "options.t0");
+        } else {
+            h.at(ie) = 1.0;
+        }
+    }
+}
+
+int Model::nplist() const { return plist_.size(); }
+
+int Model::np() const { return originalParameters.size(); }
+
+int Model::nk() const { return fixedParameters.size(); }
+
+int Model::ncl() const { return nx_rdata - nx_solver; }
+
+const double *Model::k() const { return fixedParameters.data(); }
+
+int Model::nMaxEvent() const { return nmaxevent; }
+
+void Model::setNMaxEvent(int nmaxevent) { this->nmaxevent = nmaxevent; }
+
+int Model::nt() const { return ts.size(); }
+
+const std::vector<ParameterScaling> &Model::getParameterScale() const {
+    return pscale;
+}
+
+void Model::setParameterScale(ParameterScaling pscale) {
+    this->pscale.assign(this->pscale.size(), pscale);
+    scaleParameters(unscaledParameters, this->pscale, originalParameters);
+    sx0data.clear();
+}
+
+void Model::setParameterScale(std::vector<ParameterScaling> const &pscaleVec) {
+    if (pscaleVec.size() != this->originalParameters.size())
+        throw AmiException("Dimension mismatch. Size of parameter scaling does "
+                           "not match number of model parameters.");
+    this->pscale = pscaleVec;
+    scaleParameters(unscaledParameters, this->pscale, originalParameters);
+    sx0data.clear();
+}
+
+const std::vector<realtype> &Model::getUnscaledParameters() const {
+    return unscaledParameters;
+}
+
+std::vector<realtype> const &Model::getParameters() const {
+    return originalParameters;
+}
+
+realtype Model::getParameterById(std::string const &par_id) const {
+    if (!hasParameterIds())
+        throw AmiException(
+            "Could not access parameters by id as they are not set");
+    return getValueById(getParameterIds(), originalParameters, par_id,
+                        "parameters", "id");
+}
+
+realtype Model::getParameterByName(std::string const &par_name) const {
+    if (!hasParameterNames())
+        throw AmiException(
+            "Could not access parameters by name as they are not set");
+    return getValueById(getParameterNames(), originalParameters, par_name,
+                        "parameters", "name");
+}
+
+void Model::setParameters(const std::vector<realtype> &p) {
+    if (p.size() != (unsigned)np())
+        throw AmiException("Dimension mismatch. Size of parameters does not "
+                           "match number of model parameters.");
+    this->originalParameters = p;
+    this->unscaledParameters.resize(originalParameters.size());
+    unscaleParameters(originalParameters, pscale, unscaledParameters);
+}
+
+void Model::setParameterById(const std::map<std::string, realtype> &p,
+                             bool ignoreErrors)
+{
+    for (auto& kv : p) {
+        try {
+            setParameterById(kv.first, kv.second);
+        } catch (AmiException&) {
+            if(!ignoreErrors)
+                throw;
+        }
+    }
+}
+
+void Model::setParameterById(std::string const &par_id, realtype value) {
+    if (!hasParameterIds())
+        throw AmiException(
+            "Could not access parameters by id as they are not set");
+
+    setValueById(getParameterIds(), originalParameters, value, par_id,
+                 "parameter", "id");
+    unscaleParameters(originalParameters, pscale, unscaledParameters);
+}
+
+int Model::setParametersByIdRegex(std::string const &par_id_regex,
+                                  realtype value) {
+    if (!hasParameterIds())
+        throw AmiException(
+            "Could not access parameters by id as they are not set");
+    int n_found = setValueByIdRegex(getParameterIds(), originalParameters,
+                                    value, par_id_regex, "parameter", "id");
+    unscaleParameters(originalParameters, pscale, unscaledParameters);
+    return n_found;
+}
+
+void Model::setParameterByName(std::string const &par_name, realtype value) {
+    if (!hasParameterNames())
+        throw AmiException(
+            "Could not access parameters by name as they are not set");
+
+    setValueById(getParameterNames(), originalParameters, value, par_name,
+                 "parameter", "name");
+    unscaleParameters(originalParameters, pscale, unscaledParameters);
+}
+
+void Model::setParameterByName(const std::map<std::string, realtype> &p,
+                               bool ignoreErrors)
+{
+    for (auto& kv : p) {
+        try {
+            setParameterByName(kv.first, kv.second);
+        } catch (AmiException&) {
+            if(!ignoreErrors)
+                throw;
+        }
+    }
+}
+
+int Model::setParametersByNameRegex(std::string const &par_name_regex,
+                                    realtype value) {
+    if (!hasParameterNames())
+        throw AmiException(
+            "Could not access parameters by name as they are not set");
+
+    int n_found = setValueByIdRegex(getParameterNames(), originalParameters,
+                                    value, par_name_regex, "parameter", "name");
+
+    unscaleParameters(originalParameters, pscale, unscaledParameters);
+    return n_found;
+}
+
+const std::vector<realtype> &Model::getFixedParameters() const {
+    return fixedParameters;
+}
+
+realtype Model::getFixedParameterById(std::string const &par_id) const {
+    if (!hasFixedParameterIds())
+        throw AmiException(
+            "Could not access fixed parameters by id as they are not set");
+
+    return getValueById(getFixedParameterIds(), fixedParameters, par_id,
+                        "fixedParameters", "id");
+}
+
+realtype Model::getFixedParameterByName(std::string const &par_name) const {
+    if (!hasFixedParameterNames())
+        throw AmiException(
+            "Could not access fixed parameters by name as they are not set");
+
+    return getValueById(getFixedParameterNames(), fixedParameters, par_name,
+                        "fixedParameters", "name");
+}
+
+void Model::setFixedParameters(const std::vector<realtype> &k) {
+    if (k.size() != (unsigned)nk())
+        throw AmiException("Dimension mismatch. Size of fixedParameters does "
+                           "not match number of fixed model parameters.");
+    this->fixedParameters = k;
+}
+
+void Model::setFixedParameterById(std::string const &par_id, realtype value) {
+    if (!hasFixedParameterIds())
+        throw AmiException(
+            "Could not access fixed parameters by id as they are not set");
+
+    setValueById(getFixedParameterIds(), fixedParameters, value, par_id,
+                 "fixedParameters", "id");
+}
+
+int Model::setFixedParametersByIdRegex(std::string const &par_id_regex,
+                                       realtype value) {
+    if (!hasFixedParameterIds())
+        throw AmiException(
+            "Could not access fixed parameters by id as they are not set");
+
+    return setValueByIdRegex(getFixedParameterIds(), fixedParameters, value,
+                             par_id_regex, "fixedParameters", "id");
+}
+
+void Model::setFixedParameterByName(std::string const &par_name,
+                                    realtype value) {
+    if (!hasFixedParameterNames())
+        throw AmiException(
+            "Could not access fixed parameters by name as they are not set");
+
+    setValueById(getFixedParameterNames(), fixedParameters, value, par_name,
+                 "fixedParameters", "name");
+}
+
+int Model::setFixedParametersByNameRegex(std::string const &par_name_regex,
+                                         realtype value) {
+    if (!hasFixedParameterNames())
+        throw AmiException(
+            "Could not access fixed parameters by name as they are not set");
+
+    return setValueByIdRegex(getFixedParameterIds(), fixedParameters, value,
+                             par_name_regex, "fixedParameters", "name");
+}
+
+bool Model::hasParameterNames() const {
+    return np() == 0 || !getParameterNames().empty();
+}
+
+std::vector<std::string> Model::getParameterNames() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasStateNames() const {
+    return nx_rdata == 0 || !getStateNames().empty();
+}
+
+std::vector<std::string> Model::getStateNames() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasFixedParameterNames() const {
+    return nk() == 0 || !getFixedParameterNames().empty();
+}
+
+std::vector<std::string> Model::getFixedParameterNames() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasObservableNames() const {
+    return ny == 0 || !getObservableNames().empty();
+}
+
+std::vector<std::string> Model::getObservableNames() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasParameterIds() const {
+    return np() == 0 || !getParameterIds().empty();
+}
+
+std::vector<std::string> Model::getParameterIds() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasStateIds() const {
+    return nx_rdata == 0 || !getStateIds().empty();
+}
+
+std::vector<std::string> Model::getStateIds() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasFixedParameterIds() const {
+    return nk() == 0 || !getFixedParameterIds().empty();
+}
+
+std::vector<std::string> Model::getFixedParameterIds() const {
+    return std::vector<std::string>();
+}
+
+bool Model::hasObservableIds() const {
+    return ny == 0 || !getObservableIds().empty();
+}
+
+std::vector<std::string> Model::getObservableIds() const {
+    return std::vector<std::string>();
+}
+
+std::vector<realtype> const &Model::getTimepoints() const { return ts; }
+
+double Model::getTimepoint(const int it) const { return ts.at(it); }
+
+void Model::setTimepoints(const std::vector<realtype> &ts) {
+    if (!std::is_sorted(ts.begin(), ts.end()))
+        throw AmiException("Encountered non-monotonic timepoints, please order"
+                           " timepoints such that they are monotonically"
+                           " increasing!");
+    this->ts = ts;
+}
+
+double Model::t0() const { return tstart; }
+
+void Model::setT0(double t0) { tstart = t0; }
+
+std::vector<bool> const &Model::getStateIsNonNegative() const {
+    return stateIsNonNegative;
+}
+
+void Model::setStateIsNonNegative(std::vector<bool> const &nonNegative) {
+    if (nx_solver != nx_rdata) {
+        throw AmiException("Nonnegative states are not supported whith"
+                           " conservation laws enabled");
+    }
+    if (stateIsNonNegative.size() != static_cast<unsigned long>(nx_rdata)) {
+        throw AmiException("Dimension of input stateIsNonNegative (%u) does "
+                           "not agree with number of state variables (%d)",
+                           stateIsNonNegative.size(), nx_rdata);
+    }
+    stateIsNonNegative = nonNegative;
+    anyStateNonNegative =
+        std::any_of(stateIsNonNegative.begin(), stateIsNonNegative.end(),
+                    [](bool x) { return x; });
+}
+
+void Model::setAllStatesNonNegative() {
+    setStateIsNonNegative(std::vector<bool>(nx_solver, true));
+}
+
+const std::vector<int> &Model::getParameterList() const { return plist_; }
+
+int Model::plist(int pos) const { return plist_.at(pos); }
+
+void Model::setParameterList(const std::vector<int> &plist) {
+    int np = this->np(); // cannot capture 'this' in lambda expression
+    if (std::any_of(plist.begin(), plist.end(),
+                    [&np](int idx) { return idx < 0 || idx >= np; })) {
+        throw AmiException("Indices in plist must be in [0..np]");
+    }
+    this->plist_ = plist;
+
+    initializeVectors();
+}
+
+std::vector<realtype> const &Model::getInitialStates() const { return x0data; }
+
+void Model::setInitialStates(const std::vector<realtype> &x0) {
+    if (x0.size() != (unsigned)nx_rdata && !x0.empty())
+        throw AmiException("Dimension mismatch. Size of x0 does not match "
+                           "number of model states.");
+
+    if (x0.empty()) {
+        x0data.clear();
+        return;
+    }
+
+    x0data = x0;
+}
+
+const std::vector<realtype> &Model::getInitialStateSensitivities() const {
+    return sx0data;
+}
+
+void Model::setInitialStateSensitivities(const std::vector<realtype> &sx0) {
+    if (sx0.size() != (unsigned)nx_rdata * nplist() && !sx0.empty())
+        throw AmiException("Dimension mismatch. Size of sx0 does not match "
+                           "number of model states * number of parameter "
+                           "selected for sensitivities.");
+
+    if (sx0.empty()) {
+        sx0data.clear();
+        return;
+    }
+
+    realtype chainrulefactor = 1.0;
+    std::vector<realtype> sx0_rdata(nx_rdata * nplist(), 0.0);
+    for (int ip = 0; ip < nplist(); ip++) {
+
+        // revert chainrule
+        switch (pscale.at(plist(ip))) {
+        case ParameterScaling::log10:
+            chainrulefactor = unscaledParameters.at(plist(ip)) * log(10);
+            break;
+        case ParameterScaling::ln:
+            chainrulefactor = unscaledParameters.at(plist(ip));
+            break;
+        case ParameterScaling::none:
+            chainrulefactor = 1.0;
+            break;
+        }
+
+        for (int ix = 0; ix < nx_rdata; ++ix) {
+            sx0_rdata.at(ip * nx_rdata + ix) =
+                sx0.at(ip * nx_rdata + ix) / chainrulefactor;
+        }
+    }
+    setUnscaledInitialStateSensitivities(sx0_rdata);
+}
+
+void Model::setUnscaledInitialStateSensitivities(
+    const std::vector<realtype> &sx0) {
+    if (sx0.size() != (unsigned)nx_rdata * nplist() && !sx0.empty())
+        throw AmiException("Dimension mismatch. Size of sx0 does not match "
+                           "number of model states * number of parameter "
+                           "selected for sensitivities.");
+
+    if (sx0.empty()) {
+        sx0data.clear();
+        return;
+    }
+
+    sx0data = sx0;
+}
+
+void Model::setSteadyStateSensitivityMode(
+    const SteadyStateSensitivityMode mode) {
+    steadyStateSensitivityMode = mode;
+}
+
+SteadyStateSensitivityMode Model::getSteadyStateSensitivityMode() const {
+    return steadyStateSensitivityMode;
+}
+
+void Model::setReinitializeFixedParameterInitialStates(bool flag) {
+    if (flag && !isFixedParameterStateReinitializationAllowed())
+        throw AmiException(
+            "State reinitialization cannot be enabled for this model"
+            "as this feature was disabled at compile time. Most likely,"
+            " this was because some initial states depending on "
+            "fixedParameters also depended on parameters");
+    reinitializeFixedParameterInitialStates = flag;
+}
+
+bool Model::getReinitializeFixedParameterInitialStates() const {
+    return reinitializeFixedParameterInitialStates;
+}
+
+void Model::requireSensitivitiesForAllParameters() {
+    plist_.resize(np());
+    std::iota(plist_.begin(), plist_.end(), 0);
+    initializeVectors();
+}
+
+void Model::getObservable(gsl::span<realtype> y, const realtype t,
+                          const AmiVector &x) {
+    fy(t, x);
+    writeSlice(this->y, y);
+}
+
+void Model::getObservableSensitivity(gsl::span<realtype> sy, const realtype t,
+                                     const AmiVector &x,
+                                     const AmiVectorArray &sx) {
+    if (!ny)
+        return;
+
+    fdydx(t, x);
+    fdydp(t, x);
+
+    this->sx.assign(nx_solver * nplist(), 0.0);
+    sx.flatten_to_vector(this->sx);
+
+    // compute sy = 1.0*dydx*sx + 1.0*sy
+    // dydx A[ny,nx_solver] * sx B[nx_solver,nplist] = sy C[ny,nplist]
+    //        M  K                 K  N                     M  N
+    //        lda                  ldb                      ldc
+    amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                BLASTranspose::noTrans, ny, nplist(), nx_solver, 1.0,
+                dydx.data(), ny, this->sx.data(), nx_solver, 1.0, dydp.data(),
+                ny);
+
+    writeSlice(dydp, sy);
+
+    if (alwaysCheckFinite)
+        checkFinite(sy, "sy");
+}
+
+void Model::getObservableSigma(gsl::span<realtype> sigmay, const int it,
+                               const ExpData *edata) {
+    fsigmay(it, edata);
+    writeSlice(this->sigmay, sigmay);
+}
+
+void Model::getObservableSigmaSensitivity(gsl::span<realtype> ssigmay,
+                                          const int it, const ExpData *edata) {
+    fdsigmaydp(it, edata);
+    writeSlice(dsigmaydp, ssigmay);
+}
+
+void Model::addObservableObjective(realtype &Jy, const int it,
+                                   const AmiVector &x, const ExpData &edata) {
+    fy(edata.getTimepoint(it), x);
+    fsigmay(it, &edata);
+
+    std::vector<realtype> nllh(nJ, 0.0);
+    for (int iyt = 0; iyt < nytrue; iyt++) {
+        if (edata.isSetObservedData(it, iyt)) {
+            std::fill(nllh.begin(), nllh.end(), 0.0);
+            fJy(nllh.data(), iyt, unscaledParameters.data(),
+                fixedParameters.data(), y.data(), sigmay.data(),
+                edata.getObservedDataPtr(it));
+            Jy -= nllh.at(0);
+        }
+    }
+}
+
+void Model::addObservableObjectiveSensitivity(std::vector<realtype> &sllh,
+                                              std::vector<realtype> &s2llh,
+                                              const int it, const AmiVector &x,
+                                              const AmiVectorArray &sx,
+                                              const ExpData &edata) {
+
+    if (!ny)
+        return;
+
+    fdJydx(it, x, edata);
+    fdJydp(it, x, edata);
+    // Compute dJydx*sx for current 'it'
+    // dJydx        rdata->nt x nJ        x nx_solver
+    // sx           rdata->nt x nx_solver x nplist()
+    sx.flatten_to_vector(this->sx);
+
+    // C := alpha*op(A)*op(B) + beta*C,
+    amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                BLASTranspose::noTrans, nJ, nplist(), nx_solver, 1.0,
+                dJydx.data(), nJ, this->sx.data(), nx_solver, 1.0, dJydp.data(),
+                nJ);
+
+    writeLLHSensitivitySlice(dJydp, sllh, s2llh);
+}
+
+void Model::addPartialObservableObjectiveSensitivity(
+    std::vector<realtype> &sllh, std::vector<realtype> &s2llh, const int it,
+    const AmiVector &x, const ExpData &edata) {
+    if (!ny)
+        return;
+
+    fdJydp(it, x, edata);
+
+    writeLLHSensitivitySlice(dJydp, sllh, s2llh);
+}
+
+void Model::getAdjointStateObservableUpdate(gsl::span<realtype> dJydx,
+                                            const int it, const AmiVector &x,
+                                            const ExpData &edata) {
+    fdJydx(it, x, edata);
+    writeSlice(this->dJydx, dJydx);
+}
+
+void Model::getEvent(gsl::span<realtype> z, const int ie, const realtype t,
+                     const AmiVector &x) {
+    fz(ie, t, x);
+    writeSliceEvent(this->z, z, ie);
+}
+
+void Model::getEventSensitivity(gsl::span<realtype> sz, const int ie,
+                                const realtype t, const AmiVector &x,
+                                const AmiVectorArray &sx) {
+    for (int ip = 0; ip < nplist(); ip++) {
+        fsz(&sz.at(ip * nz), ie, t, x.data(), unscaledParameters.data(),
+            fixedParameters.data(), h.data(), sx.data(ip), plist(ip));
+    }
+}
+
+void Model::getUnobservedEventSensitivity(gsl::span<realtype> sz,
+                                          const int ie) {
+    checkBufferSize(sz, nz * nplist());
+
+    for (int iz = 0; iz < nz; ++iz)
+        if (z2event[iz] - 1 == ie)
+            for (int ip = 0; ip < nplist(); ++ip)
+                sz.at(ip * nz + iz) = 0.0;
+}
+
+void Model::getEventRegularization(gsl::span<realtype> rz, const int ie,
+                                   const realtype t, const AmiVector &x) {
+    frz(ie, t, x);
+    writeSliceEvent(this->rz, rz, ie);
+}
+
+void Model::getEventRegularizationSensitivity(gsl::span<realtype> srz,
+                                              const int ie, const realtype t,
+                                              const AmiVector &x,
+                                              const AmiVectorArray &sx) {
+    for (int ip = 0; ip < nplist(); ip++) {
+        fsrz(&srz.at(ip * nz), ie, t, x.data(), unscaledParameters.data(),
+             fixedParameters.data(), h.data(), sx.data(ip), plist(ip));
+    }
+}
+
+void Model::getEventSigma(gsl::span<realtype> sigmaz, const int ie,
+                          const int nroots, const realtype t,
+                          const ExpData *edata) {
+    fsigmaz(ie, nroots, t, edata);
+    writeSliceEvent(this->sigmaz, sigmaz, ie);
+}
+
+void Model::getEventSigmaSensitivity(gsl::span<realtype> ssigmaz, const int ie,
+                                     const int nroots, const realtype t,
+                                     const ExpData *edata) {
+    fdsigmazdp(ie, nroots, t, edata);
+    writeSensitivitySliceEvent(dsigmazdp, ssigmaz, ie);
+}
+
+void Model::addEventObjective(realtype &Jz, const int ie, const int nroots,
+                              const realtype t, const AmiVector &x,
+                              const ExpData &edata) {
+    fz(ie, t, x);
+    fsigmaz(ie, nroots, t, &edata);
+
+    std::vector<realtype> nllh(nJ, 0.0);
+    for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+        if (edata.isSetObservedEvents(nroots, iztrue)) {
+            std::fill(nllh.begin(), nllh.end(), 0.0);
+            fJz(nllh.data(), iztrue, unscaledParameters.data(),
+                fixedParameters.data(), z.data(), sigmaz.data(),
+                edata.getObservedEventsPtr(nroots));
+            Jz -= nllh.at(0);
+        }
+    }
+}
+
+void Model::addEventObjectiveRegularization(realtype &Jrz, const int ie,
+                                            const int nroots, const realtype t,
+                                            const AmiVector &x,
+                                            const ExpData &edata) {
+    frz(ie, t, x);
+    fsigmaz(ie, nroots, t, &edata);
+
+    std::vector<realtype> nllh(nJ, 0.0);
+    for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+        if (edata.isSetObservedEvents(nroots, iztrue)) {
+            std::fill(nllh.begin(), nllh.end(), 0.0);
+            fJrz(nllh.data(), iztrue, unscaledParameters.data(),
+                 fixedParameters.data(), rz.data(), sigmaz.data());
+            Jrz -= nllh.at(0);
+        }
+    }
+}
+
+void Model::addEventObjectiveSensitivity(std::vector<realtype> &sllh,
+                                         std::vector<realtype> &s2llh,
+                                         const int ie, const int nroots,
+                                         const realtype t, const AmiVector &x,
+                                         const AmiVectorArray &sx,
+                                         const ExpData &edata) {
+
+    if (!nz)
+        return;
+
+    fdJzdx(ie, nroots, t, x, edata);
+    fdJzdp(ie, nroots, t, x, edata);
+
+    // sJz           nJ x nplist()
+    // dJzdp         nJ x nplist()
+    // dJzdx         nmaxevent x nJ        x nx_solver
+    // sx            rdata->nt x nx_solver x nplist()
+
+    // Compute dJzdx*sx for current 'ie'
+    // dJzdx        rdata->nt x nJ        x nx_solver
+    // sx           rdata->nt x nx_solver x nplist()
+    sx.flatten_to_vector(this->sx);
+
+    // C := alpha*op(A)*op(B) + beta*C,
+    amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                BLASTranspose::noTrans, nJ, nplist(), nx_solver, 1.0,
+                dJzdx.data(), nJ, this->sx.data(), nx_solver, 1.0, dJzdp.data(),
+                nJ);
+
+    // sJy += multResult + dJydp
+    writeLLHSensitivitySlice(dJzdp, sllh, s2llh);
+}
+
+void Model::getAdjointStateEventUpdate(gsl::span<realtype> dJzdx, const int ie,
+                                       const int nroots, const realtype t,
+                                       const AmiVector &x,
+                                       const ExpData &edata) {
+    fdJzdx(ie, nroots, t, x, edata);
+    writeSlice(this->dJzdx, dJzdx);
+}
+
+void Model::addPartialEventObjectiveSensitivity(std::vector<realtype> &sllh,
+                                                std::vector<realtype> &s2llh,
+                                                const int ie, const int nroots,
+                                                const realtype t,
+                                                const AmiVector &x,
+                                                const ExpData &edata) {
+    if (!nz)
+        return;
+
+    fdJzdp(ie, nroots, t, x, edata);
+
+    writeLLHSensitivitySlice(dJzdp, sllh, s2llh);
+}
+
+void Model::getEventTimeSensitivity(std::vector<realtype> &stau,
+                                    const realtype t, const int ie,
+                                    const AmiVector &x,
+                                    const AmiVectorArray &sx) {
+
+    std::fill(stau.begin(), stau.end(), 0.0);
+
+    for (int ip = 0; ip < nplist(); ip++) {
+        fstau(&stau.at(ip), t, x.data(), unscaledParameters.data(),
+              fixedParameters.data(), h.data(), sx.data(ip), plist(ip), ie);
+    }
+}
+
+void Model::addStateEventUpdate(AmiVector &x, const int ie, const realtype t,
+                                const AmiVector &xdot,
+                                const AmiVector &xdot_old) {
+
+    deltax.assign(nx_solver, 0.0);
+
+    // compute update
+    fdeltax(deltax.data(), t, x.data(), unscaledParameters.data(),
+            fixedParameters.data(), h.data(), ie, xdot.data(), xdot_old.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(deltax, "deltax");
+    }
+
+    // update
+    amici_daxpy(nx_solver, 1.0, deltax.data(), 1, x.data(), 1);
+}
+
+void Model::addStateSensitivityEventUpdate(AmiVectorArray &sx, const int ie,
+                                           const realtype t,
+                                           const AmiVector &x_old,
+                                           const AmiVector &xdot,
+                                           const AmiVector &xdot_old,
+                                           const std::vector<realtype> &stau) {
+    fw(t, x_old.data());
+
+    for (int ip = 0; ip < nplist(); ip++) {
+
+        deltasx.assign(nx_solver, 0.0);
+
+        // compute update
+        fdeltasx(deltasx.data(), t, x_old.data(), unscaledParameters.data(),
+                 fixedParameters.data(), h.data(), w.data(), plist(ip), ie,
+                 xdot.data(), xdot_old.data(), sx.data(ip), &stau.at(ip));
+
+        if (alwaysCheckFinite) {
+            amici::checkFinite(deltasx, "deltasx");
+        }
+
+        amici_daxpy(nx_solver, 1.0, deltasx.data(), 1, sx.data(ip), 1);
+    }
+}
+
+void Model::addAdjointStateEventUpdate(AmiVector &xB, const int ie,
+                                       const realtype t, const AmiVector &x,
+                                       const AmiVector &xdot,
+                                       const AmiVector &xdot_old) {
+
+    deltasx.assign(nx_solver, 0.0);
+
+    // compute update
+    fdeltaxB(deltaxB.data(), t, x.data(), unscaledParameters.data(),
+             fixedParameters.data(), h.data(), ie, xdot.data(), xdot_old.data(),
+             xB.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(deltaxB, "deltaxB");
+    }
+
+    // apply update
+    for (int ix = 0; ix < nxtrue_solver; ++ix)
+        for (int iJ = 0; iJ < nJ; ++iJ)
+            xB.at(ix + iJ * nxtrue_solver) +=
+                deltaxB.at(ix + iJ * nxtrue_solver);
+}
+
+void Model::addAdjointQuadratureEventUpdate(
+    AmiVector xQB, const int ie, const realtype t, const AmiVector &x,
+    const AmiVector &xB, const AmiVector &xdot, const AmiVector &xdot_old) {
+    for (int ip = 0; ip < nplist(); ip++) {
+        deltaqB.assign(nJ, 0.0);
+
+        fdeltaqB(deltaqB.data(), t, x.data(), unscaledParameters.data(),
+                 fixedParameters.data(), h.data(), plist(ip), ie, xdot.data(),
+                 xdot_old.data(), xB.data());
+
+        for (int iJ = 0; iJ < nJ; ++iJ)
+            xQB.at(iJ) += deltaqB.at(iJ);
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(deltaqB, "deltaqB");
+    }
+}
+
+void Model::updateHeaviside(const std::vector<int> &rootsfound) {
+    for (int ie = 0; ie < ne; ie++) {
+        h.at(ie) += rootsfound.at(ie);
+    }
+}
+
+void Model::updateHeavisideB(const int *rootsfound) {
+    for (int ie = 0; ie < ne; ie++) {
+        h.at(ie) -= rootsfound[ie];
+    }
+}
+
+int Model::checkFinite(gsl::span<const realtype> array, const char *fun) const {
+    auto result = amici::checkFinite(array, fun);
+
+    if (result != AMICI_SUCCESS) {
+        amici::checkFinite(fixedParameters, "k");
+        amici::checkFinite(unscaledParameters, "p");
+        amici::checkFinite(w, "w");
+    }
+
+    return result;
+}
+
+void Model::setAlwaysCheckFinite(bool alwaysCheck) {
+    alwaysCheckFinite = alwaysCheck;
+}
+
+bool Model::getAlwaysCheckFinite() const { return alwaysCheckFinite; }
+
+void Model::fx0(AmiVector &x) {
+    std::fill(x_rdata.begin(), x_rdata.end(), 0.0);
+    /* this function  also computes initial total abundances */
+    fx0(x_rdata.data(), tstart, unscaledParameters.data(),
+        fixedParameters.data());
+    fx_solver(x.data(), x_rdata.data());
+    ftotal_cl(total_cl.data(), x_rdata.data());
+
+    if (alwaysCheckFinite) {
+        checkFinite(x_rdata, "x0 x_rdata");
+        checkFinite(x.getVector(), "x0 x");
+    }
+}
+
+void Model::fx0_fixedParameters(AmiVector &x) {
+    if (!getReinitializeFixedParameterInitialStates())
+        return;
+    /* we transform to the unreduced states x_rdata and then apply
+     x0_fixedparameters to (i) enable updates to states that were removed from
+     conservation laws and (ii) be able to correctly compute total abundances
+     after updating the state variables */
+    fx_rdata(x_rdata.data(), x.data(), total_cl.data());
+    fx0_fixedParameters(x_rdata.data(), tstart, unscaledParameters.data(),
+                        fixedParameters.data());
+    fx_solver(x.data(), x_rdata.data());
+    /* update total abundances */
+    ftotal_cl(total_cl.data(), x_rdata.data());
+}
+
+void Model::fsx0(AmiVectorArray &sx, const AmiVector &x) {
+    /* this function  also computes initial total abundance sensitivities */
+    realtype *stcl = nullptr;
+    for (int ip = 0; ip < nplist(); ip++) {
+        if (ncl() > 0)
+            stcl = &stotal_cl.at(plist(ip) * ncl());
+        std::fill(sx_rdata.begin(), sx_rdata.end(), 0.0);
+        fsx0(sx_rdata.data(), tstart, x.data(), unscaledParameters.data(),
+             fixedParameters.data(), plist(ip));
+        fsx_solver(sx.data(ip), sx_rdata.data());
+        fstotal_cl(stcl, sx_rdata.data(), plist(ip));
+    }
+}
+
+void Model::fsx0_fixedParameters(AmiVectorArray &sx, const AmiVector &x) {
+    if (!getReinitializeFixedParameterInitialStates())
+        return;
+    realtype *stcl = nullptr;
+    for (int ip = 0; ip < nplist(); ip++) {
+        if (ncl() > 0)
+            stcl = &stotal_cl.at(plist(ip) * ncl());
+        fsx_rdata(sx_rdata.data(), sx.data(ip), stcl, plist(ip));
+        fsx0_fixedParameters(sx_rdata.data(), tstart, x.data(),
+                             unscaledParameters.data(), fixedParameters.data(),
+                             plist(ip));
+        fsx_solver(sx.data(ip), sx_rdata.data());
+        fstotal_cl(stcl, sx_rdata.data(), plist(ip));
+    }
+}
+
+void Model::fsdx0() {}
+
+void Model::fx_rdata(AmiVector &x_rdata, const AmiVector &x) {
+    fx_rdata(x_rdata.data(), x.data(), total_cl.data());
+    if (alwaysCheckFinite)
+        checkFinite(x_rdata.getVector(), "x_rdata");
+}
+
+void Model::fsx_rdata(AmiVectorArray &sx_rdata, const AmiVectorArray &sx) {
+    realtype *stcl = nullptr;
+    for (int ip = 0; ip < nplist(); ip++) {
+        if (ncl() > 0)
+            stcl = &stotal_cl.at(plist(ip) * ncl());
+        fsx_rdata(sx_rdata.data(ip), sx.data(ip), stcl, ip);
+    }
+}
+
+void Model::writeSliceEvent(gsl::span<const realtype> slice,
+                            gsl::span<realtype> buffer, const int ie) {
+    checkBufferSize(buffer, slice.size());
+    checkBufferSize(buffer, z2event.size());
+    for (unsigned izt = 0; izt < z2event.size(); ++izt)
+        if (z2event.at(izt) - 1 == ie)
+            buffer.at(izt) = slice.at(izt);
+}
+
+void Model::writeSensitivitySliceEvent(gsl::span<const realtype> slice,
+                                       gsl::span<realtype> buffer,
+                                       const int ie) {
+    checkBufferSize(buffer, slice.size());
+    checkBufferSize(buffer, z2event.size() * nplist());
+    for (int ip = 0; ip < nplist(); ++ip)
+        for (unsigned izt = 0; izt < z2event.size(); ++izt)
+            if (z2event.at(izt) - 1 == ie)
+                buffer.at(ip * nztrue + izt) = slice.at(ip * nztrue + izt);
+}
+
+void Model::writeLLHSensitivitySlice(const std::vector<realtype> &dLLhdp,
+                                     std::vector<realtype> &sllh,
+                                     std::vector<realtype> &s2llh) {
+    checkLLHBufferSize(sllh, s2llh);
+
+    amici_daxpy(nplist(), -1.0, dLLhdp.data(), nJ, sllh.data(), 1);
+    for (int iJ = 1; iJ < nJ; ++iJ)
+        amici_daxpy(nplist(), -1.0, &dLLhdp.at(iJ), nJ, &s2llh.at(iJ - 1),
+                    nJ - 1);
+}
+
+void Model::checkLLHBufferSize(std::vector<realtype> &sllh,
+                               std::vector<realtype> &s2llh) {
+    if (sllh.size() != static_cast<unsigned>(nplist()))
+        throw AmiException("Incorrect sllh buffer size! Was %u, expected %i.",
+                           sllh.size(), nplist());
+
+    if (s2llh.size() != static_cast<unsigned>((nJ - 1) * nplist()))
+        throw AmiException("Incorrect s2llh buffer size! Was %u, expected %i.",
+                           s2llh.size(), (nJ - 1) * nplist());
+}
+
+void Model::initializeVectors() {
+    dxdotdp = AmiVectorArray(nx_solver, nplist());
+    sx0data.clear();
+}
+
+void Model::fy(const realtype t, const AmiVector &x) {
+    if (!ny)
+        return;
+
+    y.assign(ny, 0.0);
+
+    fw(t, x.data());
+    fy(y.data(), t, x.data(), unscaledParameters.data(), fixedParameters.data(),
+       h.data(), w.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(gsl::make_span(y.data(), ny), "y");
+    }
+}
+
+void Model::fdydp(const realtype t, const AmiVector &x) {
+    if (!ny)
+        return;
+
+    dydp.assign(ny * nplist(), 0.0);
+
+    fw(t, x.data());
+    fdwdp(t, x.data());
+
+    // if dwdp is not dense, fdydp will expect the full sparse array
+    realtype *dwdp_tmp = dwdp.data();
+    for (int ip = 0; ip < nplist(); ip++) {
+        // get dydp slice (ny) for current time and parameter
+        if (wasPythonGenerated() && nw)
+            dwdp_tmp = &dwdp.at(nw * ip);
+
+        fdydp(&dydp.at(ip * ny), t, x.data(), unscaledParameters.data(),
+              fixedParameters.data(), h.data(), plist(ip), w.data(), dwdp_tmp);
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dydp, "dydp");
+    }
+}
+
+void Model::fdydx(const realtype t, const AmiVector &x) {
+    if (!ny)
+        return;
+
+    dydx.assign(ny * nx_solver, 0.0);
+
+    fw(t, x.data());
+    fdwdx(t, x.data());
+    fdydx(dydx.data(), t, x.data(), unscaledParameters.data(),
+          fixedParameters.data(), h.data(), w.data(), dwdx.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dydx, "dydx");
+    }
+}
+
+void Model::fsigmay(const int it, const ExpData *edata) {
+    if (!ny)
+        return;
+
+    sigmay.assign(ny, 0.0);
+
+    fsigmay(sigmay.data(), getTimepoint(it), unscaledParameters.data(),
+            fixedParameters.data());
+
+    if (edata) {
+        auto sigmay_edata = edata->getObservedDataStdDevPtr(it);
+        /* extract the value for the standard deviation from ExpData,
+         * if the data value is NaN, use the parameter value */
+        for (int iytrue = 0; iytrue < nytrue; iytrue++) {
+            if (edata->isSetObservedDataStdDev(it, iytrue))
+                sigmay.at(iytrue) = sigmay_edata[iytrue];
+
+            /* TODO: when moving second order code to cpp, verify
+             * that this is actually what we want
+             */
+            for (int iJ = 1; iJ < nJ; iJ++)
+                sigmay.at(iytrue + iJ*nytrue) = 0;
+
+            if (edata->isSetObservedData(it, iytrue))
+                checkSigmaPositivity(sigmay[iytrue], "sigmay");
+        }
+    }
+}
+
+void Model::fdsigmaydp(const int it, const ExpData *edata) {
+    if (!ny)
+        return;
+
+    dsigmaydp.assign(ny * nplist(), 0.0);
+
+    for (int ip = 0; ip < nplist(); ip++)
+        // get dsigmaydp slice (ny) for current timepoint and parameter
+        fdsigmaydp(&dsigmaydp.at(ip * ny), getTimepoint(it),
+                   unscaledParameters.data(), fixedParameters.data(),
+                   plist(ip));
+
+    // sigmas in edata override model-sigma -> for those sigmas, set dsigmaydp
+    // to zero
+    if (edata) {
+        for (int iy = 0; iy < nytrue; iy++) {
+            if (!edata->isSetObservedDataStdDev(it, iy))
+                continue;
+            for (int ip = 0; ip < nplist(); ip++) {
+                dsigmaydp[ip * ny + iy] = 0.0;
+            }
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dsigmaydp, "dsigmaydp");
+    }
+}
+
+void Model::fdJydy_colptrs(sunindextype * /*indexptrs*/, int /*index*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__);
+}
+
+void Model::fdJydy_rowvals(sunindextype * /*indexptrs*/, int /*index*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__);
+}
+
+void Model::fdJydy(const int it, const AmiVector &x, const ExpData &edata) {
+
+    fy(edata.getTimepoint(it), x);
+    fsigmay(it, &edata);
+
+    if (wasPythonGenerated()) {
+        for (int iyt = 0; iyt < nytrue; iyt++) {
+            dJydy[iyt].zero();
+            fdJydy_colptrs(dJydy[iyt].indexptrs(), iyt);
+            fdJydy_rowvals(dJydy[iyt].indexvals(), iyt);
+
+            if (!edata.isSetObservedData(it, iyt))
+                continue;
+
+            // get dJydy slice (ny) for current timepoint and observable
+            fdJydy(dJydy[iyt].data(), iyt, unscaledParameters.data(),
+                   fixedParameters.data(), y.data(), sigmay.data(),
+                   edata.getObservedDataPtr(it));
+
+            if (alwaysCheckFinite) {
+                amici::checkFinite(gsl::make_span(dJydy[iyt].get()), "dJydy");
+            }
+        }
+    } else {
+        std::fill(dJydy_matlab.begin(), dJydy_matlab.end(), 0.0);
+        for (int iyt = 0; iyt < nytrue; iyt++) {
+            if (!edata.isSetObservedData(it, iyt))
+                continue;
+            fdJydy(&dJydy_matlab.at(iyt * ny * nJ), iyt,
+                   unscaledParameters.data(), fixedParameters.data(), y.data(),
+                   sigmay.data(), edata.getObservedDataPtr(it));
+        }
+        if (alwaysCheckFinite) {
+            // get dJydy slice (ny) for current timepoint and observable
+            amici::checkFinite(dJydy_matlab, "dJydy");
+        }
+    }
+}
+
+void Model::fdJydsigma(const int it, const AmiVector &x, const ExpData &edata) {
+
+    dJydsigma.assign(nytrue * ny * nJ, 0.0);
+
+    fy(edata.getTimepoint(it), x);
+    fsigmay(it, &edata);
+
+    for (int iyt = 0; iyt < nytrue; iyt++) {
+        if (edata.isSetObservedData(it, iyt))
+            // get dJydsigma slice (ny) for current timepoint and observable
+            fdJydsigma(&dJydsigma.at(iyt * ny * nJ), iyt,
+                       unscaledParameters.data(), fixedParameters.data(),
+                       y.data(), sigmay.data(), edata.getObservedDataPtr(it));
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dJydsigma, "dJydsigma");
+    }
+}
+
+void Model::fdJydp(const int it, const AmiVector &x, const ExpData &edata) {
+    // dJydy         nJ, nytrue x ny
+    // dydp          nplist * ny
+    // dJydp         nplist x nJ
+    // dJydsigma
+
+    dJydp.assign(nJ * nplist(), 0.0);
+
+    fdJydy(it, x, edata);
+    fdydp(edata.getTimepoint(it), x);
+
+    fdJydsigma(it, x, edata);
+    fdsigmaydp(it, &edata);
+
+    for (int iyt = 0; iyt < nytrue; ++iyt) {
+        if (!edata.isSetObservedData(it, iyt))
+            continue;
+
+        if (wasPythonGenerated()) {
+            // dJydp = 1.0 * dJydp +  1.0 * dJydy * dydp
+            for (int iplist = 0; iplist < nplist(); ++iplist) {
+                dJydy[iyt].multiply(
+                    gsl::span<realtype>(&dJydp.at(iplist * nJ), nJ),
+                    gsl::span<const realtype>(&dydp.at(iplist * ny), ny));
+            }
+        } else {
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nplist(), ny, 1.0,
+                        &dJydy_matlab.at(iyt * nJ * ny), nJ, dydp.data(), ny,
+                        1.0, dJydp.data(), nJ);
+        }
+        // dJydp = 1.0 * dJydp +  1.0 * dJydsigma * dsigmaydp
+        amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                    BLASTranspose::noTrans, nJ, nplist(), ny, 1.0,
+                    &dJydsigma.at(iyt * nJ * ny), nJ, dsigmaydp.data(), ny, 1.0,
+                    dJydp.data(), nJ);
+    }
+}
+
+void Model::fdJydx(const int it, const AmiVector &x, const ExpData &edata) {
+
+    dJydx.assign(nJ * nx_solver, 0.0);
+
+    fdydx(edata.getTimepoint(it), x);
+    fdJydy(it, x, edata);
+
+    // dJydy: nJ, ny x nytrue
+    // dydx :     ny x nx_solver
+    // dJydx:     nJ x nx_solver x nt
+    for (int iyt = 0; iyt < nytrue; ++iyt) {
+        if (!edata.isSetObservedData(it, iyt))
+            continue;
+        // dJydy A[nyt,nJ,ny] * dydx B[ny,nx_solver] = dJydx C[it,nJ,nx_solver]
+        //         slice                                       slice
+        //          M  K            K  N                       M  N
+        //           lda             ldb                        ldc
+
+        if (wasPythonGenerated()) {
+            for (int ix = 0; ix < nx_solver; ++ix) {
+                dJydy[iyt].multiply(
+                    gsl::span<realtype>(&dJydx.at(ix * nJ), nJ),
+                    gsl::span<const realtype>(&dydx.at(ix * ny), ny));
+            }
+        } else {
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nx_solver, ny, 1.0,
+                        &dJydy_matlab.at(iyt * ny * nJ), nJ, dydx.data(), ny,
+                        1.0, dJydx.data(), nJ);
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dJydx, "dJydx");
+    }
+}
+
+void Model::fz(const int ie, const realtype t, const AmiVector &x) {
+
+    z.assign(nz, 0.0);
+
+    fz(z.data(), ie, t, x.data(), unscaledParameters.data(),
+       fixedParameters.data(), h.data());
+}
+
+void Model::fdzdp(const int ie, const realtype t, const AmiVector &x) {
+
+    dzdp.assign(nz * nplist(), 0.0);
+
+    for (int ip = 0; ip < nplist(); ip++) {
+        fdzdp(dzdp.data(), ie, t, x.data(), unscaledParameters.data(),
+              fixedParameters.data(), h.data(), plist(ip));
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dzdp, "dzdp");
+    }
+}
+
+void Model::fdzdx(const int ie, const realtype t, const AmiVector &x) {
+
+    dzdx.assign(nz * nx_solver, 0.0);
+
+    fdzdx(dzdx.data(), ie, t, x.data(), unscaledParameters.data(),
+          fixedParameters.data(), h.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dzdx, "dzdx");
+    }
+}
+
+void Model::frz(const int ie, const realtype t, const AmiVector &x) {
+
+    rz.assign(nz, 0.0);
+
+    frz(rz.data(), ie, t, x.data(), unscaledParameters.data(),
+        fixedParameters.data(), h.data());
+}
+
+void Model::fdrzdp(const int ie, const realtype t, const AmiVector &x) {
+
+    drzdp.assign(nz * nplist(), 0.0);
+
+    for (int ip = 0; ip < nplist(); ip++) {
+        fdrzdp(drzdp.data(), ie, t, x.data(), unscaledParameters.data(),
+               fixedParameters.data(), h.data(), plist(ip));
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(drzdp, "drzdp");
+    }
+}
+
+void Model::fdrzdx(const int ie, const realtype t, const AmiVector &x) {
+
+    drzdx.assign(nz * nx_solver, 0.0);
+
+    fdrzdx(drzdx.data(), ie, t, x.data(), unscaledParameters.data(),
+           fixedParameters.data(), h.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(drzdx, "drzdx");
+    }
+}
+
+void Model::fsigmaz(const int ie, const int nroots, const realtype t,
+                    const ExpData *edata) {
+    if (!nz)
+        return;
+
+    sigmaz.assign(nz, 0.0);
+    fsigmaz(sigmaz.data(), t, unscaledParameters.data(),
+            fixedParameters.data());
+
+    if (edata) {
+        for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+            if (z2event.at(iztrue) - 1 == ie) {
+                if (edata->isSetObservedEventsStdDev(nroots, iztrue)) {
+                    auto sigmaz_edata =
+                        edata->getObservedEventsStdDevPtr(nroots);
+                    sigmaz.at(iztrue) = sigmaz_edata[iztrue];
+                }
+
+                /* TODO: when moving second order code to cpp, verify
+                 * that this is actually what we want
+                 */
+                for (int iJ = 1; iJ < nJ; iJ++)
+                    sigmaz.at(iztrue + iJ*nztrue) = 0;
+
+                if (edata->isSetObservedEvents(nroots, iztrue))
+                    checkSigmaPositivity(sigmaz[iztrue], "sigmaz");
+            }
+        }
+    }
+}
+
+void Model::fdsigmazdp(const int ie, const int nroots, const realtype t,
+                       const ExpData *edata) {
+
+    dsigmazdp.assign(nz * nplist(), 0.0);
+
+    for (int ip = 0; ip < nplist(); ip++) {
+        // get dsigmazdp slice (nz) for current event and parameter
+        fdsigmazdp(&dsigmazdp.at(ip * nz), t, unscaledParameters.data(),
+                   fixedParameters.data(), plist(ip));
+    }
+
+    // sigmas in edata override model-sigma -> for those sigmas, set dsigmazdp
+    // to zero
+    if (edata) {
+        for (int iz = 0; iz < nztrue; iz++) {
+            if (z2event.at(iz) - 1 == ie &&
+                !edata->isSetObservedEventsStdDev(nroots, iz)) {
+                for (int ip = 0; ip < nplist(); ip++)
+                    dsigmazdp.at(iz + nz * ip) = 0;
+            }
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dsigmazdp, "dsigmazdp");
+    }
+}
+
+void Model::fdJzdz(const int ie, const int nroots, const realtype t,
+                   const AmiVector &x, const ExpData &edata) {
+
+    dJzdz.assign(nztrue * nz * nJ, 0.0);
+
+    fz(ie, t, x);
+    fsigmaz(ie, nroots, t, &edata);
+
+    for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+        if (edata.isSetObservedEvents(nroots, iztrue)) {
+            fdJzdz(&dJzdz.at(iztrue * nz * nJ), iztrue,
+                   unscaledParameters.data(), fixedParameters.data(), z.data(),
+                   sigmaz.data(), edata.getObservedEventsPtr(nroots));
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dJzdz, "dJzdz");
+    }
+}
+
+void Model::fdJzdsigma(const int ie, const int nroots, const realtype t,
+                       const AmiVector &x, const ExpData &edata) {
+
+    dJzdsigma.assign(nztrue * nz * nJ, 0.0);
+
+    fz(ie, t, x);
+    fsigmaz(ie, nroots, t, &edata);
+
+    for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+        if (edata.isSetObservedEvents(nroots, iztrue)) {
+            fdJzdsigma(&dJzdsigma.at(iztrue * nz * nJ), iztrue,
+                       unscaledParameters.data(), fixedParameters.data(),
+                       z.data(), sigmaz.data(),
+                       edata.getObservedEventsPtr(nroots));
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dJzdsigma, "dJzdsigma");
+    }
+}
+
+void Model::fdJzdp(const int ie, const int nroots, realtype t,
+                   const AmiVector &x, const ExpData &edata) {
+    // dJzdz         nJ x nz x nztrue
+    // dJzdsigma     nJ x nz x nztrue
+    // dzdp          nz x nplist()
+    // dJzdp         nJ x nplist()
+
+    dJzdp.assign(nJ * nplist(), 0.0);
+
+    fdJzdz(ie, nroots, t, x, edata);
+    fdzdp(ie, t, x);
+
+    fdJzdsigma(ie, nroots, t, x, edata);
+    fdsigmazdp(ie, nroots, t, &edata);
+
+    for (int izt = 0; izt < nztrue; ++izt) {
+        if (!edata.isSetObservedEvents(nroots, izt))
+            continue;
+
+        if (t < edata.getTimepoint(edata.nt() - 1)) {
+            // with z
+            fdJzdz(ie, nroots, t, x, edata);
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nplist(), nz, 1.0,
+                        &dJzdz.at(izt * nz * nJ), nJ, dzdp.data(), nz, 1.0,
+                        dJzdp.data(), nJ);
+        } else {
+            // with rz
+            fdJrzdz(ie, nroots, t, x, edata);
+            fdJrzdsigma(ie, nroots, t, x, edata);
+
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nplist(), nz, 1.0,
+                        &dJrzdsigma.at(izt * nz * nJ), nJ, dsigmazdp.data(), nz,
+                        1.0, dJzdp.data(), nJ);
+
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nplist(), nz, 1.0,
+                        &dJrzdz.at(izt * nz * nJ), nJ, dzdp.data(), nz, 1.0,
+                        dJzdp.data(), nJ);
+        }
+
+        amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                    BLASTranspose::noTrans, nJ, nplist(), nz, 1.0,
+                    &dJzdsigma.at(izt * nz * nJ), nJ, dsigmazdp.data(), nz, 1.0,
+                    dJzdp.data(), nJ);
+    }
+}
+
+void Model::fdJzdx(const int ie, const int nroots, const realtype t,
+                   const AmiVector &x, const ExpData &edata) {
+    // dJzdz         nJ x nz        x nztrue
+    // dzdx          nz x nx_solver
+    // dJzdx         nJ x nx_solver x nmaxevent
+
+    dJzdx.assign(nJ * nx_solver, 0.0);
+
+    fdJzdz(ie, nroots, t, x, edata);
+
+    for (int izt = 0; izt < nztrue; ++izt) {
+        if (!edata.isSetObservedEvents(nroots, izt))
+            continue;
+
+        if (t < edata.getTimepoint(edata.nt() - 1)) {
+            // z
+            fdzdx(ie, t, x);
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nx_solver, nz, 1.0,
+                        &dJzdz.at(izt * nz * nJ), nJ, dzdx.data(), nz, 1.0,
+                        dJzdx.data(), nJ);
+        } else {
+            // rz
+            fdJrzdz(ie, nroots, t, x, edata);
+            fdrzdx(ie, t, x);
+            amici_dgemm(BLASLayout::colMajor, BLASTranspose::noTrans,
+                        BLASTranspose::noTrans, nJ, nx_solver, nz, 1.0,
+                        &dJrzdz.at(izt * nz * nJ), nJ, drzdx.data(), nz, 1.0,
+                        dJzdx.data(), nJ);
+        }
+    }
+}
+
+void Model::fdJrzdz(const int ie, const int nroots, const realtype t,
+                    const AmiVector &x, const ExpData &edata) {
+
+    dJrzdz.assign(nztrue * nz * nJ, 0.0);
+
+    frz(ie, t, x);
+    fsigmaz(ie, nroots, t, &edata);
+
+    for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+        if (edata.isSetObservedEvents(nroots, iztrue)) {
+            fdJrzdz(&dJrzdz.at(iztrue * nz * nJ), iztrue,
+                    unscaledParameters.data(), fixedParameters.data(),
+                    rz.data(), sigmaz.data());
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dJrzdz, "dJrzdz");
+    }
+}
+
+void Model::fdJrzdsigma(const int ie, const int nroots, const realtype t,
+                        const AmiVector &x, const ExpData &edata) {
+
+    dJrzdsigma.assign(nztrue * nz * nJ, 0.0);
+
+    frz(ie, t, x);
+    fsigmaz(ie, nroots, t, &edata);
+
+    for (int iztrue = 0; iztrue < nztrue; iztrue++) {
+        if (edata.isSetObservedEvents(nroots, iztrue)) {
+            fdJrzdsigma(&dJrzdsigma.at(iztrue * nz * nJ), iztrue,
+                        unscaledParameters.data(), fixedParameters.data(),
+                        rz.data(), sigmaz.data());
+        }
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dJrzdsigma, "dJrzdsigma");
+    }
+}
+
+void Model::fw(const realtype t, const realtype *x) {
+    std::fill(w.begin(), w.end(), 0.0);
+    fw(w.data(), t, x, unscaledParameters.data(), fixedParameters.data(),
+       h.data(), total_cl.data());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(w, "w");
+    }
+}
+
+void Model::fdwdp(const realtype t, const realtype *x) {
+    fw(t, x);
+    std::fill(dwdp.begin(), dwdp.end(), 0.0);
+    if (wasPythonGenerated()) {
+        realtype *stcl = nullptr;
+
+        // avoid bad memory access when slicing
+        if (!nw)
+            return;
+
+        for (int ip = 0; ip < nplist(); ++ip) {
+            if (ncl())
+                stcl = &stotal_cl.at(plist(ip) * ncl());
+            fdwdp(&dwdp.at(nw * ip), t, x, unscaledParameters.data(),
+                  fixedParameters.data(), h.data(), w.data(), total_cl.data(),
+                  stcl, plist_[ip]);
+        }
+    } else {
+        // matlab generated
+        fdwdp(dwdp.data(), t, x, unscaledParameters.data(),
+              fixedParameters.data(), h.data(), w.data(), total_cl.data(),
+              stotal_cl.data());
+    }
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(dwdp, "dwdp");
+    }
+}
+
+void Model::fdwdx(const realtype t, const realtype *x) {
+    fw(t, x);
+    dwdx.reset();
+    fdwdx(dwdx.data(), t, x, unscaledParameters.data(), fixedParameters.data(),
+          h.data(), w.data(), total_cl.data());
+    fdwdx_colptrs(dwdx.indexptrs());
+    fdwdx_rowvals(dwdx.indexptrs());
+
+    if (alwaysCheckFinite) {
+        amici::checkFinite(gsl::make_span(dwdx.get()), "dwdx");
+    }
+}
+
+void Model::fx_rdata(realtype *x_rdata, const realtype *x_solver,
+                     const realtype * /*tcl*/) {
+    if (nx_solver != nx_rdata)
+        throw AmiException(
+            "A model that has differing nx_solver and nx_rdata needs "
+            "to implement its own fx_rdata");
+    std::copy_n(x_solver, nx_solver, x_rdata);
+}
+
+void Model::fsx_rdata(realtype *sx_rdata, const realtype *sx_solver,
+                      const realtype *stcl, const int /*ip*/) {
+    fx_rdata(sx_rdata, sx_solver, stcl);
+}
+
+void Model::fx_solver(realtype *x_solver, const realtype *x_rdata) {
+    if (nx_solver != nx_rdata)
+        throw AmiException(
+            "A model that has differing nx_solver and nx_rdata needs "
+            "to implement its own fx_solver");
+    std::copy_n(x_rdata, nx_rdata, x_solver);
+}
+
+void Model::fsx_solver(realtype *sx_solver, const realtype *sx_rdata) {
+    /* for the moment we do not need an implementation of fsx_solver as
+     * we can simply reuse fx_solver and replace states by their
+     * sensitivities */
+    fx_solver(sx_solver, sx_rdata);
+}
+
+void Model::ftotal_cl(realtype * /*total_cl*/, const realtype * /*x_rdata*/) {
+    if (nx_solver != nx_rdata)
+        throw AmiException(
+            "A model that has differing nx_solver and nx_rdata needs "
+            "to implement its own ftotal_cl");
+}
+
+void Model::fstotal_cl(realtype *stotal_cl, const realtype *sx_rdata,
+                       const int /*ip*/) {
+    /* for the moment we do not need an implementation of fstotal_cl as
+     * we can simply reuse ftotal_cl and replace states by their
+     * sensitivities */
+    ftotal_cl(stotal_cl, sx_rdata);
+}
+
+N_Vector Model::computeX_pos(const_N_Vector x) {
+    if (anyStateNonNegative) {
+        for (int ix = 0; ix < x_pos_tmp.getLength(); ++ix) {
+            x_pos_tmp.at(ix) =
+                (stateIsNonNegative.at(ix) && NV_Ith_S(x, ix) < 0)
+                    ? 0
+                    : NV_Ith_S(x, ix);
+        }
+        return x_pos_tmp.getNVector();
+    }
+
+    return x;
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/model_dae.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/model_dae.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..339a802b77b7b54ba6c021b2fa50c6619846a4ef
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/model_dae.cpp
@@ -0,0 +1,253 @@
+#include "amici/model_dae.h"
+#include "amici/solver_idas.h"
+
+namespace amici {
+
+void Model_DAE::fJ(const realtype t, const realtype cj, const AmiVector &x,
+                   const AmiVector &dx, const AmiVector &xdot, SUNMatrix J) {
+    fJ(t, cj, x.getNVector(), dx.getNVector(), xdot.getNVector(), J);
+}
+
+void Model_DAE::fJ(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                   N_Vector /*xdot*/, SUNMatrix J) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(J);
+    fJ(SM_DATA_D(J), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+       fixedParameters.data(), h.data(), cj, N_VGetArrayPointer(dx), w.data(),
+       dwdx.data());
+}
+
+void Model_DAE::fJSparse(const realtype t, const realtype cj,
+                         const AmiVector &x, const AmiVector &dx,
+                         const AmiVector & /*xdot*/, SUNMatrix J) {
+    fJSparse(t, cj, x.getNVector(), dx.getNVector(), J);
+}
+
+void Model_DAE::fJSparse(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                         SUNMatrix J) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(J);
+    fJSparse(static_cast<SUNMatrixContent_Sparse>(SM_CONTENT_S(J)), t,
+             N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+             fixedParameters.data(), h.data(), cj, N_VGetArrayPointer(dx),
+             w.data(), dwdx.data());
+}
+    
+void Model_DAE::fJSparseB(SUNMatrixContent_Sparse   /*JSparseB*/,
+                       const realtype  /*t*/, const realtype * /*x*/,
+                       const double * /*p*/, const double * /*k*/,
+                       const realtype * /*h*/, const realtype   /*cj*/,
+                       const realtype * /*xB*/, const realtype * /*dx*/,
+                       const realtype * /*dxB*/, const realtype * /*w*/,
+                       const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__);
+}
+
+void Model_DAE::fJv(const realtype t, const AmiVector &x, const AmiVector &dx,
+                    const AmiVector & /*xdot*/, const AmiVector &v,
+                    AmiVector &Jv, const realtype cj) {
+    fJv(t, x.getNVector(), dx.getNVector(), v.getNVector(), Jv.getNVector(),
+        cj);
+}
+
+void Model_DAE::fJv(realtype t, N_Vector x, N_Vector dx, N_Vector v,
+                    N_Vector Jv, realtype cj) {
+    N_VConst(0.0, Jv);
+    fJSparse(t, cj, x, dx, J.get());
+    J.multiply(Jv, v);
+}
+
+void Model_DAE::froot(const realtype t, const AmiVector &x, const AmiVector &dx,
+                      gsl::span<realtype> root) {
+    froot(t, x.getNVector(), dx.getNVector(), root);
+}
+
+void Model_DAE::froot(realtype t, N_Vector x, N_Vector dx,
+                      gsl::span<realtype> root) {
+    std::fill(root.begin(), root.end(), 0.0);
+    auto x_pos = computeX_pos(x);
+    froot(root.data(), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+          fixedParameters.data(), h.data(), N_VGetArrayPointer(dx));
+}
+
+void Model_DAE::fxdot(const realtype t, const AmiVector &x, const AmiVector &dx,
+                      AmiVector &xdot) {
+    fxdot(t, x.getNVector(), dx.getNVector(), xdot.getNVector());
+}
+
+void Model_DAE::fxdot(realtype t, N_Vector x, N_Vector dx, N_Vector xdot) {
+    auto x_pos = computeX_pos(x);
+    fw(t, N_VGetArrayPointer(x));
+    N_VConst(0.0, xdot);
+    fxdot(N_VGetArrayPointer(xdot), t, N_VGetArrayPointer(x_pos),
+          unscaledParameters.data(), fixedParameters.data(), h.data(),
+          N_VGetArrayPointer(dx), w.data());
+}
+
+void Model_DAE::fJDiag(const realtype t, AmiVector &JDiag,
+                       const realtype /*cj*/, const AmiVector &x,
+                       const AmiVector &dx) {
+    auto x_pos = computeX_pos(x.getNVector());
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    JDiag.set(0.0);
+    fJDiag(JDiag.data(), t, N_VGetArrayPointer(x_pos),
+           unscaledParameters.data(), fixedParameters.data(), h.data(), 0.0,
+           dx.data(), w.data(), dwdx.data());
+    if (!checkFinite(JDiag.getVector(), "Jacobian"))
+        throw AmiException("Evaluation of fJDiag failed!");
+}
+
+void Model_DAE::fdxdotdp(const realtype t, const N_Vector x,
+                         const N_Vector dx) {
+    auto x_pos = computeX_pos(x);
+    fdwdp(t, N_VGetArrayPointer(x_pos));
+    for (int ip = 0; ip < nplist(); ip++) {
+        N_VConst(0.0, dxdotdp.getNVector(ip));
+        fdxdotdp(dxdotdp.data(ip), t, N_VGetArrayPointer(x_pos),
+                 unscaledParameters.data(), fixedParameters.data(), h.data(),
+                 plist_[ip], N_VGetArrayPointer(dx), w.data(), dwdp.data());
+    }
+}
+
+void Model_DAE::fM(realtype t, const N_Vector x) {
+    SUNMatZero(M.get());
+    auto x_pos = computeX_pos(x);
+    fM(M.data(), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+       fixedParameters.data());
+}
+
+std::unique_ptr<Solver> Model_DAE::getSolver() {
+    return std::unique_ptr<Solver>(new amici::IDASolver());
+}
+
+void Model_DAE::fJB(realtype * /*JB*/, const realtype /*t*/,
+                    const realtype * /*x*/, const double * /*p*/,
+                    const double * /*k*/, const realtype * /*h*/,
+                    const realtype /*cj*/, const realtype * /*xB*/,
+                    const realtype * /*dx*/, const realtype * /*dxB*/,
+                    const realtype * /*w*/, const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__);
+}
+
+void Model_DAE::fJDiag(realtype * /*JDiag*/, const realtype /*t*/,
+                       const realtype * /*x*/, const realtype * /*p*/,
+                       const realtype * /*k*/, const realtype * /*h*/,
+                       const realtype /*cj*/, const realtype * /*dx*/,
+                       const realtype * /*w*/, const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__);
+}
+
+void Model_DAE::fJvB(realtype * /*JvB*/, const realtype  /*t*/, const realtype * /*x*/,
+                     const double * /*p*/, const double * /*k*/,
+                     const realtype * /*h*/, const realtype /*cj*/,
+                     const realtype * /*xB*/, const realtype * /*dx*/,
+                     const realtype * /*dxB*/, const realtype * /*vB*/,
+                     const realtype * /*w*/, const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_DAE::froot(realtype * /*root*/, const realtype /*t*/,
+                      const realtype * /*x*/, const double * /*p*/, const double * /*k*/,
+                      const realtype * /*h*/, const realtype * /*dx*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_DAE::fdxdotdp(realtype * /*dxdotdp*/, const realtype /*t*/,
+                         const realtype * /*x*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*h*/,
+                         const int /*ip*/, const realtype * /*dx*/,
+                         const realtype * /*w*/, const realtype * /*dwdp*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__);
+}
+
+void Model_DAE::fJB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                    N_Vector xB, N_Vector dxB, SUNMatrix JB) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(JB);
+    fJB(SM_DATA_D(JB), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+        fixedParameters.data(), h.data(), cj, N_VGetArrayPointer(xB),
+        N_VGetArrayPointer(dx), N_VGetArrayPointer(dxB), w.data(), dwdx.data());
+}
+
+void Model_DAE::fJSparseB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                          N_Vector xB, N_Vector dxB, SUNMatrix JB) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(JB);
+    fJSparseB(static_cast<SUNMatrixContent_Sparse>(SM_CONTENT_S(JB)), t,
+              N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+              fixedParameters.data(), h.data(), cj, N_VGetArrayPointer(xB),
+              N_VGetArrayPointer(dx), N_VGetArrayPointer(dxB), w.data(),
+              dwdx.data());
+}
+
+void Model_DAE::fJvB(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                     N_Vector dxB, N_Vector vB, N_Vector JvB, realtype cj) {
+    N_VConst(0.0, JvB);
+    fJSparseB(t, cj, x, dx, xB, dxB, J.get());
+    J.multiply(JvB, vB);
+}
+
+void Model_DAE::fxBdot(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                       N_Vector dxB, N_Vector xBdot) {
+    N_VConst(0.0, xBdot);
+    fJSparseB(t, 1.0, x, dx, xB, dxB, J.get());
+    fM(t, x);
+    J.multiply(xBdot, xB);
+}
+
+void Model_DAE::fqBdot(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                       N_Vector /*dxB*/, N_Vector qBdot) {
+    N_VConst(0.0, qBdot);
+    fdxdotdp(t, x, dx);
+    for (int ip = 0; ip < nplist(); ip++) {
+        for (int ix = 0; ix < nxtrue_solver; ix++)
+            NV_Ith_S(qBdot, ip * nJ) -= NV_Ith_S(xB, ix) * dxdotdp.at(ix, ip);
+        // second order part
+        for (int iJ = 1; iJ < nJ; iJ++)
+            for (int ix = 0; ix < nxtrue_solver; ix++)
+                NV_Ith_S(qBdot, ip * nJ + iJ) -=
+                    NV_Ith_S(xB, ix) * dxdotdp.at(ix + iJ * nxtrue_solver, ip) +
+                    NV_Ith_S(xB, ix + iJ * nxtrue_solver) * dxdotdp.at(ix, ip);
+    }
+}
+
+void Model_DAE::fsxdot(const realtype t, const AmiVector &x,
+                       const AmiVector &dx, const int ip, const AmiVector &sx,
+                       const AmiVector &sdx, AmiVector &sxdot) {
+    fsxdot(t, x.getNVector(), dx.getNVector(), ip, sx.getNVector(),
+           sdx.getNVector(), sxdot.getNVector());
+}
+
+void Model_DAE::fsxdot(realtype t, N_Vector x, N_Vector dx, int ip, N_Vector sx,
+                       N_Vector sdx, N_Vector sxdot) {
+    if (ip == 0) {
+        // we only need to call this for the first parameter index will be
+        // the same for all remaining
+        fM(t, x);
+        fdxdotdp(t, x, dx);
+        fJSparse(t, 0.0, x, dx, J.get());
+    }
+    N_VScale(1.0, dxdotdp.getNVector(ip), sxdot);
+    J.multiply(sxdot, sx);
+    N_VScale(-1.0, sdx, sdx);
+    M.multiply(sxdot, sdx);
+    N_VScale(-1.0, sdx, sdx);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/model_ode.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/model_ode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4284c801d3956c2b3f47a7b8d1c7044f5ab7ba8b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/model_ode.cpp
@@ -0,0 +1,350 @@
+#include "amici/model_ode.h"
+#include "amici/solver_cvodes.h"
+
+namespace amici {
+
+void Model_ODE::fJ(const realtype t, const realtype /*cj*/, const AmiVector &x,
+                   const AmiVector & /*dx*/, const AmiVector &xdot,
+                   SUNMatrix J) {
+    fJ(t, x.getNVector(), xdot.getNVector(), J);
+}
+
+void Model_ODE::fJ(realtype t, N_Vector x, N_Vector /*xdot*/, SUNMatrix J) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(J);
+    fJ(SM_DATA_D(J), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+       fixedParameters.data(), h.data(), w.data(), dwdx.data());
+}
+
+void Model_ODE::fJSparse(const realtype t, const realtype /*cj*/,
+                         const AmiVector &x, const AmiVector & /*dx*/,
+                         const AmiVector & /*xdot*/, SUNMatrix J) {
+    fJSparse(t, x.getNVector(), J);
+}
+
+void Model_ODE::fJSparse(realtype t, N_Vector x, SUNMatrix J) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(J);
+    if (wasPythonGenerated()) {
+        fJSparse(SM_DATA_S(J), t, N_VGetArrayPointer(x_pos),
+                 unscaledParameters.data(), fixedParameters.data(), h.data(),
+                 w.data(), dwdx.data());
+        fJSparse_colptrs(SM_INDEXPTRS_S(J));
+        fJSparse_rowvals(SM_INDEXVALS_S(J));
+    } else {
+        fJSparse(static_cast<SUNMatrixContent_Sparse>(SM_CONTENT_S(J)), t,
+                 N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+                 fixedParameters.data(), h.data(), w.data(), dwdx.data());
+    }
+}
+
+void Model_ODE::fJv(const realtype t, const AmiVector &x,
+                    const AmiVector & /*dx*/, const AmiVector & /*xdot*/,
+                    const AmiVector &v, AmiVector &Jv, const realtype /*cj*/) {
+    fJv(v.getNVector(), Jv.getNVector(), t, x.getNVector());
+}
+
+void Model_ODE::fJv(N_Vector v, N_Vector Jv, realtype t, N_Vector x) {
+    N_VConst(0.0, Jv);
+    fJSparse(t, x, J.get());
+    J.multiply(Jv, v);
+}
+
+void Model_ODE::froot(const realtype t, const AmiVector &x,
+                      const AmiVector & /*dx*/, gsl::span<realtype> root) {
+    froot(t, x.getNVector(), root);
+}
+
+void Model_ODE::froot(realtype t, N_Vector x, gsl::span<realtype> root) {
+    auto x_pos = computeX_pos(x);
+    std::fill(root.begin(), root.end(), 0.0);
+    froot(root.data(), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+          fixedParameters.data(), h.data());
+}
+
+void Model_ODE::fxdot(const realtype t, const AmiVector &x,
+                      const AmiVector & /*dx*/, AmiVector &xdot) {
+    fxdot(t, x.getNVector(), xdot.getNVector());
+}
+
+void Model_ODE::fxdot(realtype t, N_Vector x, N_Vector xdot) {
+    auto x_pos = computeX_pos(x);
+    fw(t, N_VGetArrayPointer(x_pos));
+    N_VConst(0.0, xdot);
+    fxdot(N_VGetArrayPointer(xdot), t, N_VGetArrayPointer(x_pos),
+          unscaledParameters.data(), fixedParameters.data(), h.data(),
+          w.data());
+}
+
+void Model_ODE::fJDiag(const realtype t, AmiVector &JDiag,
+                       const realtype /*cj*/, const AmiVector &x,
+                       const AmiVector & /*dx*/) {
+    fJDiag(t, JDiag.getNVector(), x.getNVector());
+    if (checkFinite(JDiag.getVector(), "Jacobian") != AMICI_SUCCESS)
+        throw AmiException("Evaluation of fJDiag failed!");
+}
+
+void Model_ODE::fdxdotdw(const realtype t, const N_Vector x) {
+    dxdotdw.reset();
+    auto x_pos = computeX_pos(x);
+    fdxdotdw(dxdotdw.data(), t, N_VGetArrayPointer(x_pos),
+             unscaledParameters.data(), fixedParameters.data(), h.data(),
+             w.data());
+    fdxdotdw_colptrs(dxdotdw.indexptrs());
+    fdxdotdw_rowvals(dxdotdw.indexvals());
+}
+
+void Model_ODE::fdxdotdp(const realtype t, const N_Vector x) {
+    auto x_pos = computeX_pos(x);
+    fdwdp(t, N_VGetArrayPointer(x));
+    if (wasPythonGenerated()) {
+        // python generated
+        fdxdotdw(t, x);
+        for (int ip = 0; ip < nplist(); ip++) {
+            N_VConst(0.0, dxdotdp.getNVector(ip));
+            fdxdotdp(dxdotdp.data(ip), t, N_VGetArrayPointer(x_pos),
+                     unscaledParameters.data(), fixedParameters.data(),
+                     h.data(), plist_[ip], w.data());
+            if (nw > 0)
+                dxdotdw.multiply(
+                    gsl::span<realtype>(dxdotdp.data(ip), nx_solver),
+                    gsl::span<const realtype>(&dwdp.at(nw * ip), nw));
+        }
+    } else {
+        // matlab generated
+        for (int ip = 0; ip < nplist(); ip++) {
+            N_VConst(0.0, dxdotdp.getNVector(ip));
+            fdxdotdp(dxdotdp.data(ip), t, N_VGetArrayPointer(x_pos),
+                     unscaledParameters.data(), fixedParameters.data(),
+                     h.data(), plist_[ip], w.data(), dwdp.data());
+        }
+    }
+}
+
+void Model_ODE::fdxdotdp(const realtype t, const AmiVector &x,
+                         const AmiVector & /*dx*/) {
+    fdxdotdp(t, x.getNVector());
+}
+
+std::unique_ptr<Solver> Model_ODE::getSolver() {
+    return std::unique_ptr<Solver>(new amici::CVodeSolver());
+}
+
+void Model_ODE::fJB(realtype * /*JB*/, const realtype /*t*/,
+                    const realtype * /*x*/, const realtype * /*p*/,
+                    const realtype * /*k*/, const realtype * /*h*/,
+                    const realtype * /*xB*/, const realtype * /*w*/,
+                    const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__);
+}
+
+void Model_ODE::fJSparse(SUNMatrixContent_Sparse /*JSparse*/,
+                         const realtype /*t*/, const realtype * /*x*/,
+                         const realtype * /*p*/, const realtype * /*k*/,
+                         const realtype * /*h*/, const realtype * /*w*/,
+                         const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparse(realtype * /*JSparse*/, const realtype /*t*/,
+                         const realtype * /*x*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*h*/,
+                         const realtype * /*w*/, const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparse_colptrs(sunindextype * /*indexptrs*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparse_rowvals(sunindextype * /*indexvals*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparseB(SUNMatrixContent_Sparse /*JSparseB*/,
+                          const realtype /*t*/, const realtype * /*x*/,
+                          const realtype * /*p*/, const realtype * /*k*/,
+                          const realtype * /*h*/, const realtype * /*xB*/,
+                          const realtype * /*w*/, const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparseB(realtype * /*JSparseB*/, const realtype /*t*/,
+                          const realtype * /*x*/, const realtype * /*p*/,
+                          const realtype * /*k*/, const realtype * /*h*/,
+                          const realtype * /*xB*/, const realtype * /*w*/,
+                          const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparseB_colptrs(sunindextype * /*indexptrs*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJSparseB_rowvals(sunindextype * /*indexvals*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJDiag(realtype * /*JDiag*/, const realtype /*t*/,
+                       const realtype * /*x*/, const realtype * /*p*/,
+                       const realtype * /*k*/, const realtype * /*h*/,
+                       const realtype * /*w*/, const realtype * /*dwdx*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__);
+}
+
+void Model_ODE::froot(realtype * /*root*/, const realtype /*t*/,
+                      const realtype * /*x*/, const realtype * /*p*/,
+                      const realtype * /*k*/, const realtype * /*h*/) {
+    throw AmiException("Requested functionality is not supported as %s is not "
+                       "implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fdxdotdp(realtype * /*dxdotdp*/, const realtype /*t*/,
+                         const realtype * /*x*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*h*/,
+                         const int /*ip*/, const realtype * /*w*/,
+                         const realtype * /*dwdp*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fdxdotdp(realtype * /*dxdotdp*/, const realtype /*t*/,
+                         const realtype * /*x*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*h*/,
+                         const int /*ip*/, const realtype * /*w*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fdxdotdw(realtype * /*dxdotdw*/, const realtype /*t*/,
+                         const realtype * /*x*/, const realtype * /*p*/,
+                         const realtype * /*k*/, const realtype * /*h*/,
+                         const realtype * /*w*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fdxdotdw_colptrs(sunindextype * /*indexptrs*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fdxdotdw_rowvals(sunindextype * /*indexvals*/) {
+    throw AmiException("Requested functionality is not supported as %s "
+                       "is not implemented for this model!",
+                       __func__); // not implemented
+}
+
+void Model_ODE::fJB(realtype t, N_Vector x, N_Vector xB, N_Vector /*xBdot*/,
+                    SUNMatrix JB) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(JB);
+    fJB(SM_DATA_D(JB), t, N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+        fixedParameters.data(), h.data(), N_VGetArrayPointer(xB), w.data(),
+        dwdx.data());
+}
+
+void Model_ODE::fJSparseB(realtype t, N_Vector x, N_Vector xB,
+                          N_Vector /*xBdot*/, SUNMatrix JB) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    SUNMatZero(JB);
+    if (wasPythonGenerated()) {
+        fJSparseB(SM_DATA_S(JB), t, N_VGetArrayPointer(x_pos),
+                  unscaledParameters.data(), fixedParameters.data(), h.data(),
+                  N_VGetArrayPointer(xB), w.data(), dwdx.data());
+        fJSparseB_colptrs(SM_INDEXPTRS_S(JB));
+        fJSparseB_rowvals(SM_INDEXVALS_S(JB));
+    } else {
+        fJSparseB(static_cast<SUNMatrixContent_Sparse>(SM_CONTENT_S(JB)), t,
+                  N_VGetArrayPointer(x_pos), unscaledParameters.data(),
+                  fixedParameters.data(), h.data(), N_VGetArrayPointer(xB),
+                  w.data(), dwdx.data());
+    }
+}
+
+void Model_ODE::fJDiag(realtype t, N_Vector JDiag, N_Vector x) {
+    auto x_pos = computeX_pos(x);
+    fdwdx(t, N_VGetArrayPointer(x_pos));
+    N_VConst(0.0, JDiag);
+    fJDiag(N_VGetArrayPointer(JDiag), t, N_VGetArrayPointer(x_pos),
+           unscaledParameters.data(), fixedParameters.data(), h.data(),
+           w.data(), dwdx.data());
+}
+
+void Model_ODE::fJvB(N_Vector vB, N_Vector JvB, realtype t, N_Vector x,
+                     N_Vector xB) {
+    N_VConst(0.0, JvB);
+    fJSparseB(t, x, xB, nullptr, J.get());
+    J.multiply(JvB, vB);
+}
+
+void Model_ODE::fxBdot(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot) {
+    N_VConst(0.0, xBdot);
+    fJSparseB(t, x, xB, nullptr, J.get());
+    J.multiply(xBdot, xB);
+}
+
+void Model_ODE::fqBdot(realtype t, N_Vector x, N_Vector xB, N_Vector qBdot) {
+    N_VConst(0.0, qBdot);
+    fdxdotdp(t, x);
+    for (int ip = 0; ip < nplist(); ip++) {
+        for (int ix = 0; ix < nxtrue_solver; ix++)
+            NV_Ith_S(qBdot, ip * nJ) -= NV_Ith_S(xB, ix) * dxdotdp.at(ix, ip);
+        // second order part
+        for (int iJ = 1; iJ < nJ; iJ++)
+            for (int ix = 0; ix < nxtrue_solver; ix++)
+                NV_Ith_S(qBdot, ip * nJ + iJ) -=
+                    NV_Ith_S(xB, ix) * dxdotdp.at(ix + iJ * nxtrue_solver, ip) +
+                    NV_Ith_S(xB, ix + iJ * nxtrue_solver) * dxdotdp.at(ix, ip);
+    }
+}
+
+void Model_ODE::fsxdot(const realtype t, const AmiVector &x,
+                       const AmiVector & /*dx*/, const int ip,
+                       const AmiVector &sx, const AmiVector & /*sdx*/,
+                       AmiVector &sxdot) {
+    fsxdot(t, x.getNVector(), ip, sx.getNVector(), sxdot.getNVector());
+}
+
+void Model_ODE::fsxdot(realtype t, N_Vector x, int ip, N_Vector sx,
+                       N_Vector sxdot) {
+    if (ip == 0) {
+        // we only need to call this for the first parameter index will be
+        // the same for all remaining
+        fdxdotdp(t, x);
+        fJSparse(t, x, J.get());
+    }
+    N_VScale(1.0, dxdotdp.getNVector(ip), sxdot);
+    J.multiply(sxdot, sx);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/newton_solver.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/newton_solver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26d1247baad9725b9ebdbf7e88e6469a167b3c16
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/newton_solver.cpp
@@ -0,0 +1,317 @@
+#include "amici/newton_solver.h"
+
+#include "amici/model.h"
+#include "amici/solver.h"
+#include "amici/steadystateproblem.h"
+#include "amici/forwardproblem.h"
+#include "amici/rdata.h"
+#include "amici/edata.h"
+
+#include "sunlinsol/sunlinsol_klu.h" // sparse solver
+#include "sunlinsol/sunlinsol_dense.h" // dense solver
+
+#include <cstring>
+#include <ctime>
+#include <cmath>
+
+namespace amici {
+
+NewtonSolver::NewtonSolver(realtype *t, AmiVector *x, Model *model,
+                           ReturnData *rdata)
+    : model(model), rdata(rdata), xdot(model->nx_solver), dx(model->nx_solver)
+    {
+    this->t = t;
+    this->x = x;
+}
+
+/* ------------------------------------------------------------------------- */
+
+std::unique_ptr<NewtonSolver> NewtonSolver::getSolver(
+        realtype *t, AmiVector *x, LinearSolver linsolType, Model *model,
+        ReturnData *rdata, int maxlinsteps, int maxsteps, double atol, double rtol) {
+
+    std::unique_ptr<NewtonSolver> solver;
+
+    switch (linsolType) {
+
+    /* DIRECT SOLVERS */
+    case LinearSolver::dense:
+        solver.reset(new NewtonSolverDense(t, x, model, rdata));
+        break;
+
+    case LinearSolver::band:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+
+    case LinearSolver::LAPACKDense:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+
+    case LinearSolver::LAPACKBand:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+
+    case LinearSolver::diag:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+
+    /* ITERATIVE SOLVERS */
+    case LinearSolver::SPGMR:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+
+    case LinearSolver::SPBCG:
+        solver.reset(new NewtonSolverIterative(t, x, model, rdata));
+        break;
+
+    case LinearSolver::SPTFQMR:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+
+    /* SPARSE SOLVERS */
+    case LinearSolver::SuperLUMT:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+    case LinearSolver::KLU:
+        solver.reset(new NewtonSolverSparse(t, x, model, rdata));
+        break;
+    default:
+        throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "getSolver");
+    }
+
+    solver->atol = atol;
+    solver->rtol = rtol;
+    solver->maxlinsteps = maxlinsteps;
+    solver->maxsteps = maxsteps;
+
+    return solver;
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolver::getStep(int ntry, int nnewt, AmiVector &delta) {
+    this->prepareLinearSystem(ntry, nnewt);
+
+    delta.minus();
+    this->solveLinearSystem(delta);
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolver::computeNewtonSensis(AmiVectorArray &sx) {
+    prepareLinearSystem(0, -1);
+
+    model->fdxdotdp(*t, *x, dx);
+    for (int ip = 0; ip < model->nplist(); ip++) {
+
+        for (int ix = 0; ix < model->nx_solver; ix++) {
+            sx.at(ix,ip) = -model->dxdotdp.at(ix, ip);
+        }
+        solveLinearSystem(sx[ip]);
+    }
+}
+/* ------------------------------------------------------------------------- */
+/* - Dense linear solver --------------------------------------------------- */
+/* ------------------------------------------------------------------------- */
+
+/* Derived class for dense linear solver */
+NewtonSolverDense::NewtonSolverDense(realtype *t, AmiVector *x, Model *model,
+                                     ReturnData *rdata)
+    : NewtonSolver(t, x, model, rdata),
+      Jtmp(model->nx_solver, model->nx_solver),
+      linsol(SUNLinSol_Dense(x->getNVector(), Jtmp.get()))
+{
+    int status = SUNLinSolInitialize_Dense(linsol);
+    if(status != AMICI_SUCCESS)
+        throw NewtonFailure(status, "SUNLinSolInitialize_Dense");
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolverDense::prepareLinearSystem(int  /*ntry*/, int  /*nnewt*/) {
+    model->fJ(*t, 0.0, *x, dx, xdot, Jtmp.get());
+    int status = SUNLinSolSetup_Dense(linsol, Jtmp.get());
+    if(status != AMICI_SUCCESS)
+        throw NewtonFailure(status, "SUNLinSolSetup_Dense");
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolverDense::solveLinearSystem(AmiVector &rhs) {
+    int status = SUNLinSolSolve_Dense(linsol, Jtmp.get(),
+                                      rhs.getNVector(), rhs.getNVector(),
+                                      0.0);
+    // last argument is tolerance and does not have any influence on result
+
+    if(status != AMICI_SUCCESS)
+        throw NewtonFailure(status, "SUNLinSolSolve_Dense");
+}
+
+/* ------------------------------------------------------------------------- */
+
+NewtonSolverDense::~NewtonSolverDense() {
+    if(linsol)
+        SUNLinSolFree_Dense(linsol);
+}
+
+/* ------------------------------------------------------------------------- */
+/* - Sparse linear solver -------------------------------------------------- */
+/* ------------------------------------------------------------------------- */
+
+/* Derived class for sparse linear solver */
+NewtonSolverSparse::NewtonSolverSparse(realtype *t, AmiVector *x, Model *model,
+                                       ReturnData *rdata)
+    : NewtonSolver(t, x, model, rdata),
+      Jtmp(model->nx_solver, model->nx_solver, model->nnz, CSC_MAT),
+      linsol(SUNKLU(x->getNVector(), Jtmp.get()))
+{
+    int status = SUNLinSolInitialize_KLU(linsol);
+    if(status != AMICI_SUCCESS)
+        throw NewtonFailure(status, "SUNLinSolInitialize_KLU");
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolverSparse::prepareLinearSystem(int  /*ntry*/, int  /*nnewt*/) {
+    /* Get sparse Jacobian */
+    model->fJSparse(*t, 0.0, *x, dx, xdot, Jtmp.get());
+    int status = SUNLinSolSetup_KLU(linsol, Jtmp.get());
+    if(status != AMICI_SUCCESS)
+        throw NewtonFailure(status, "SUNLinSolSetup_KLU");
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolverSparse::solveLinearSystem(AmiVector &rhs) {
+    /* Pass pointer to the linear solver */
+    int status = SUNLinSolSolve_KLU(linsol, Jtmp.get(),
+                                    rhs.getNVector(), rhs.getNVector(), 0.0);
+    // last argument is tolerance and does not have any influence on result
+
+    if(status != AMICI_SUCCESS)
+        throw NewtonFailure(status, "SUNLinSolSolve_Dense");
+}
+
+/* ------------------------------------------------------------------------- */
+
+NewtonSolverSparse::~NewtonSolverSparse() {
+    if(linsol)
+        SUNLinSolFree_KLU(linsol);
+}
+
+/* ------------------------------------------------------------------------- */
+/* - Iterative linear solver------------------------------------------------ */
+/* ------------------------------------------------------------------------- */
+
+NewtonSolverIterative::NewtonSolverIterative(realtype *t, AmiVector *x,
+                                             Model *model, ReturnData *rdata)
+    : NewtonSolver(t, x, model, rdata), ns_p(model->nx_solver),
+    ns_h(model->nx_solver), ns_t(model->nx_solver), ns_s(model->nx_solver),
+    ns_r(model->nx_solver), ns_rt(model->nx_solver), ns_v(model->nx_solver),
+    ns_Jv(model->nx_solver), ns_tmp(model->nx_solver),
+    ns_Jdiag(model->nx_solver)
+    {
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolverIterative::prepareLinearSystem(int ntry, int nnewt) {
+    newton_try = ntry;
+    i_newton = nnewt;
+    if (nnewt == -1) {
+        throw AmiException("Linear solver SPBCG does not support sensitivity computation for steady state problems.");
+    }
+}
+
+/* ------------------------------------------------------------------------- */
+
+void NewtonSolverIterative::solveLinearSystem(AmiVector &rhs) {
+    linsolveSPBCG(newton_try, i_newton, rhs);
+    rhs.minus();
+}
+
+
+void NewtonSolverIterative::linsolveSPBCG(int ntry, int nnewt,
+                                          AmiVector &ns_delta) {
+    xdot = ns_delta;
+    xdot.minus();
+
+    // Get the diagonal of the Jacobian for preconditioning
+    model->fJDiag(*t, ns_Jdiag, 0.0, *x, dx);
+
+    // Ensure positivity of entries in ns_Jdiag
+    ns_p.set(1.0);
+    N_VAbs(ns_Jdiag.getNVector(), ns_Jdiag.getNVector());
+    N_VCompare(1e-15, ns_Jdiag.getNVector(), ns_tmp.getNVector());
+    N_VLinearSum(-1.0, ns_tmp.getNVector(), 1.0, ns_p.getNVector(), ns_tmp.getNVector());
+    N_VLinearSum(1.0, ns_Jdiag.getNVector(), 1.0, ns_tmp.getNVector(), ns_Jdiag.getNVector());
+
+    // Initialize for linear solve
+    ns_p.reset();
+    ns_v.reset();
+    ns_delta.reset();
+    ns_tmp.reset();
+    double rho = 1.0;
+    double omega = 1.0;
+    double alpha = 1.0;
+
+    // can be set to 0 at the moment
+    model->fJv(*t, *x, dx, xdot, ns_delta, ns_Jv, 0.0);
+
+    // ns_r = xdot - ns_Jv;
+    N_VLinearSum(-1.0, ns_Jv.getNVector(), 1.0, xdot.getNVector(), ns_r.getNVector());
+    N_VDiv(ns_r.getNVector(), ns_Jdiag.getNVector(), ns_r.getNVector());
+    ns_rt = ns_r;
+
+    for (int i_linstep = 0; i_linstep < maxlinsteps;
+         i_linstep++) {
+        // Compute factors
+        double rho1 = rho;
+        rho = N_VDotProd(ns_rt.getNVector(), ns_r.getNVector());
+        double beta = rho * alpha / (rho1 * omega);
+
+        // ns_p = ns_r + beta * (ns_p - omega * ns_v);
+        N_VLinearSum(1.0, ns_p.getNVector(), -omega, ns_v.getNVector(), ns_p.getNVector());
+        N_VLinearSum(1.0, ns_r.getNVector(), beta, ns_p.getNVector(), ns_p.getNVector());
+
+        // ns_v = J * ns_p
+        model->fJv(*t, *x, dx, xdot, ns_p, ns_v, 0.0);
+        N_VDiv(ns_v.getNVector(), ns_Jdiag.getNVector(), ns_v.getNVector());
+
+        // Compute factor
+        alpha = rho / N_VDotProd(ns_rt.getNVector(), ns_v.getNVector());
+
+        // ns_h = ns_delta + alpha * ns_p;
+        N_VLinearSum(1.0, ns_delta.getNVector(), alpha, ns_p.getNVector(),
+                     ns_h.getNVector());
+        // ns_s = ns_r - alpha * ns_v;
+        N_VLinearSum(1.0, ns_r.getNVector(), -alpha, ns_v.getNVector(), ns_s.getNVector());
+
+        // ns_t = J * ns_s
+        model->fJv(*t, *x, dx, xdot, ns_s, ns_t, 0.0);
+        N_VDiv(ns_t.getNVector(), ns_Jdiag.getNVector(), ns_t.getNVector());
+
+        // Compute factor
+        omega = N_VDotProd(ns_t.getNVector(), ns_s.getNVector()) / N_VDotProd(ns_t.getNVector(), ns_t.getNVector());
+
+        // ns_delta = ns_h + omega * ns_s;
+        N_VLinearSum(1.0, ns_h.getNVector(), omega, ns_s.getNVector(),
+                     ns_delta.getNVector());
+        // ns_r = ns_s - omega * ns_t;
+        N_VLinearSum(1.0, ns_s.getNVector(), -omega, ns_t.getNVector(), ns_r.getNVector());
+
+        // Compute the (unscaled) residual
+        N_VProd(ns_r.getNVector(), ns_Jdiag.getNVector(), ns_r.getNVector());
+        double res = sqrt(N_VDotProd(ns_r.getNVector(), ns_r.getNVector()));
+
+        // Test convergence
+        if (res < atol) {
+            // Write number of steps needed
+            rdata->newton_numlinsteps[(ntry - 1) * maxsteps +
+                                      nnewt] = i_linstep + 1;
+
+            // Return success
+            return;
+        }
+
+        // Scale back
+        N_VDiv(ns_r.getNVector(), ns_Jdiag.getNVector(), ns_r.getNVector());
+    }
+    throw NewtonFailure(AMICI_CONV_FAILURE, "linsolveSPBCG");
+}
+
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/rdata.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/rdata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3725ddcebc957cdd1466ef78e25d3f2f1dad646d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/rdata.cpp
@@ -0,0 +1,377 @@
+#include "amici/rdata.h"
+
+#include "amici/misc.h"
+#include "amici/model.h"
+#include "amici/edata.h"
+#include "amici/symbolic_functions.h"
+#include "amici/solver.h"
+#include "amici/exception.h"
+
+#include <cstring>
+
+namespace amici {
+
+ReturnData::ReturnData(Solver const& solver, const Model &model)
+    : ReturnData(model.getTimepoints(), model.np(), model.nk(),
+                 model.nx_rdata, model.nx_solver, model.nxtrue_rdata,
+                 model.ny, model.nytrue, model.nz, model.nztrue, model.ne, model.nJ,
+                 model.nplist(), model.nMaxEvent(), model.nt(),
+                 solver.getNewtonMaxSteps(), model.getParameterScale(),
+                 model.o2mode, solver.getSensitivityOrder(),
+                 static_cast<SensitivityMethod>(solver.getSensitivityMethod())) {
+}
+
+
+ReturnData::ReturnData(
+        std::vector<realtype> ts,
+        int np, int nk, int nx, int nx_solver, int nxtrue, int ny, int nytrue,
+        int nz, int nztrue, int ne, int nJ, int nplist, int nmaxevent,
+        int nt, int newton_maxsteps, std::vector<ParameterScaling> pscale,
+        SecondOrderMode o2mode, SensitivityOrder sensi, SensitivityMethod sensi_meth)
+    : ts(std::move(ts)), np(np), nk(nk), nx(nx), nx_solver(nx_solver), nxtrue(nxtrue),
+      ny(ny), nytrue(nytrue), nz(nz),
+      nztrue(nztrue), ne(ne), nJ(nJ),
+      nplist(nplist), nmaxevent(nmaxevent), nt(nt),
+      newton_maxsteps(newton_maxsteps), pscale(std::move(pscale)),
+      o2mode(o2mode), sensi(sensi),
+      sensi_meth(sensi_meth)
+    {
+    xdot.resize(nx_solver, getNaN());
+
+    J.resize(nx_solver * nx_solver, getNaN());
+
+    // initialize with 0.0, so we only need to write non-zero values
+    z.resize(nmaxevent * nz, 0.0);
+    sigmaz.resize(nmaxevent * nz, 0.0);
+
+    rz.resize(nmaxevent * nz, 0.0);
+    x.resize(nt * nx, 0.0);
+    y.resize(nt * ny, 0.0);
+    sigmay.resize(nt * ny, 0.0);
+
+    newton_numsteps.resize(3, 0);
+    newton_numlinsteps.resize(newton_maxsteps*2, 0);
+
+    if(nt>0) {
+        numsteps.resize(nt, 0);
+        numrhsevals.resize(nt, 0);
+        numerrtestfails.resize(nt, 0);
+        numnonlinsolvconvfails.resize(nt, 0);
+        order.resize(nt, 0);
+
+        if (sensi_meth == SensitivityMethod::adjoint && sensi >= SensitivityOrder::first) {
+            numstepsB.resize(nt, 0);
+            numrhsevalsB.resize(nt, 0);
+            numerrtestfailsB.resize(nt, 0);
+            numnonlinsolvconvfailsB.resize(nt, 0);
+        }
+    }
+
+    x0.resize(nx, getNaN());
+
+    x_ss.resize(nx, getNaN());
+
+    res.resize(nt * nytrue, 0.0);
+
+    llh = getNaN();
+    chi2 = getNaN();
+    if (sensi >= SensitivityOrder::first){
+        sllh.resize(nplist, getNaN());
+        sx0.resize(nx * nplist, getNaN());
+        sx_ss.resize(nx * nplist, getNaN());
+
+        if (sensi_meth == SensitivityMethod::forward || sensi >= SensitivityOrder::second){
+            // for second order we can fill in from the augmented states
+            sx.resize(nt * nx * nplist, 0.0);
+            sy.resize(nt * ny * nplist, 0.0);
+            sz.resize(nmaxevent * nz * nplist, 0.0);
+            srz.resize(nmaxevent * nz * nplist, 0.0);
+
+            FIM.resize(nplist * nplist, 0.0);
+            sres.resize(nt * nytrue * nplist, 0.0);
+        }
+
+        ssigmay.resize(nt * ny * nplist, 0.0);
+        ssigmaz.resize(nmaxevent * nz * nplist, 0.0);
+        if (sensi >= SensitivityOrder::second) {
+            s2llh.resize(nplist * (nJ - 1), getNaN());
+            if (sensi_meth == SensitivityMethod::forward)
+                s2rz.resize(nmaxevent * nztrue * nplist * nplist, 0.0);
+        }
+    }
+
+}
+
+void ReturnData::invalidate(const realtype t) {
+    invalidateLLH();
+    invalidateSLLH();
+
+    // find it corresponding to datapoint after integration failure
+    int it_start;
+    for (it_start = 0; it_start < nt; it_start++)
+        if(ts.at(it_start)>t)
+            break;
+
+    for (int it = it_start; it < nt; it++){
+        for (int ix = 0; ix < nx; ix++)
+            x.at(ix + nx * it) = getNaN();
+        for (int iy = 0; iy < ny; iy++)
+            y.at(iy + ny * it) = getNaN();
+    }
+
+    if (!sx.empty()) {
+        for (int it = it_start; it < nt; it++){
+            for (int ip = 0; ip < nplist; ip++) {
+                for (int ix = 0; ix < nx; ix++)
+                    sx.at(ix + nx*(ip + it*nplist)) = getNaN();
+            }
+        }
+    }
+    if(!sy.empty()) {
+        for (int it = it_start; it < nt; it++){
+            for (int ip = 0; ip < nplist; ip++) {
+                for (int iy = 0; iy < ny; iy++)
+                    sy.at(iy + ny*(ip + it*nplist)) = getNaN();
+            }
+        }
+    }
+}
+
+void ReturnData::invalidateLLH()
+{
+    llh = getNaN();
+    chi2 = getNaN();
+}
+
+void ReturnData::invalidateSLLH() {
+    std::fill(sllh.begin(), sllh.end(), getNaN());
+    std::fill(s2llh.begin(), s2llh.end(), getNaN());
+}
+
+void ReturnData::applyChainRuleFactorToSimulationResults(const Model *model) {
+    // chain-rule factor: multiplier for am_p
+    std::vector<realtype> coefficient(nplist, 1.0);
+    std::vector<realtype> pcoefficient(nplist, 1.0);
+
+    std::vector<realtype> unscaledParameters = model->getParameters();
+    unscaleParameters(unscaledParameters, model->getParameterScale(), unscaledParameters);
+
+    std::vector<realtype> augcoefficient(np, 1.0);
+
+    if (sensi == SensitivityOrder::second && o2mode == SecondOrderMode::full) {
+        for (int ip = 0; ip < np; ++ip) {
+            switch (pscale[ip]) {
+            case ParameterScaling::log10:
+                augcoefficient.at(ip) = unscaledParameters.at(ip) * log(10);
+                break;
+            case ParameterScaling::ln:
+                augcoefficient.at(ip) = unscaledParameters.at(ip);
+                break;
+            case ParameterScaling::none:
+                break;
+            }
+        }
+    }
+
+    for (int ip = 0; ip < nplist; ++ip) {
+        switch (pscale[model->plist(ip)]) {
+        case ParameterScaling::log10:
+            coefficient.at(ip) = log(10.0);
+            pcoefficient.at(ip) = unscaledParameters.at(model->plist(ip)) * log(10);
+            break;
+        case ParameterScaling::ln:
+            pcoefficient.at(ip) = unscaledParameters.at(model->plist(ip));
+            break;
+        case ParameterScaling::none:
+            break;
+        }
+    }
+
+    if (sensi >= SensitivityOrder::first) {
+        // recover first order sensitivies from states for adjoint sensitivity
+        // analysis
+        if (sensi == SensitivityOrder::second && o2mode == SecondOrderMode::full) {
+            if (sensi_meth == SensitivityMethod::adjoint) {
+                for (int ip = 0; ip < nplist; ++ip)
+                    for (int ix = 0; ix < nxtrue; ++ix)
+                        for (int it = 0; it < nt; ++it)
+                            sx.at(ix + nxtrue*(ip + it*nplist)) =
+                                x.at(it * nx + nxtrue + ip * nxtrue + ix);
+
+                for (int ip = 0; ip < nplist; ++ip)
+                    for (int iy = 0; iy < nytrue; ++iy)
+                        for (int it = 0; it < nt; ++it)
+                            sy.at(iy + nytrue*(ip + it*nplist)) =
+                                y.at(it * ny + nytrue + ip * nytrue + iy);
+
+                for (int ip = 0; ip < nplist; ++ip)
+                    for (int iz = 0; iz < nztrue; ++iz)
+                        for (int it = 0; it < nt; ++it)
+                            sz.at(iz + nztrue*(ip + it*nplist)) =
+                                z.at(it * nz + nztrue + ip * nztrue + iz);
+            }
+        }
+
+        for (int ip = 0; ip < nplist; ++ip)
+            sllh.at(ip) *= pcoefficient.at(ip);
+
+        if(!sres.empty())
+            for (int iyt = 0; iyt < nytrue*nt; ++iyt)
+                for (int ip = 0; ip < nplist; ++ip)
+                    sres.at((iyt * nplist + ip)) *= pcoefficient.at(ip);
+
+        if(!FIM.empty())
+            for (int ip = 0; ip < nplist; ++ip)
+                for (int jp = 0; jp < nplist; ++jp)
+                    FIM.at(jp + ip * nplist) *= pcoefficient.at(ip)*pcoefficient.at(jp);
+
+#define chainRule(QUANT, IND1, N1T, N1, IND2, N2)                               \
+    if (!s##QUANT.empty())                                                        \
+        for (int IND1 = 0; (IND1) < (N1T); ++(IND1))                                  \
+            for (int ip = 0; ip < nplist; ++ip)                                 \
+                for (int IND2 = 0; (IND2) < (N2); ++(IND2)) {                         \
+                    s##QUANT.at(((IND2)*nplist + ip)*(N1) + (IND1)) *=                \
+                        pcoefficient.at(ip);                                    \
+                }
+
+        chainRule(x, ix, nxtrue, nx, it, nt);
+        chainRule(y, iy, nytrue, ny, it, nt);
+        chainRule(sigmay, iy, nytrue, ny, it, nt);
+        chainRule(z, iz, nztrue, nz, ie, nmaxevent);
+        chainRule(sigmaz, iz, nztrue, nz, ie, nmaxevent);
+        chainRule(rz, iz, nztrue, nz, ie, nmaxevent);
+        chainRule(x0, ix, nxtrue, nx, it, 1);
+    }
+
+    if (o2mode == SecondOrderMode::full) { // full
+        if (!s2llh.empty() && !sllh.empty()) {
+            for (int ip = 0; ip < nplist; ++ip) {
+                for (int iJ = 1; iJ < nJ; ++iJ) {
+                    s2llh[ip * nplist + (iJ - 1)] *=
+                            pcoefficient.at(ip) * augcoefficient[iJ - 1];
+                    if (model->plist(ip) == iJ - 1)
+                        s2llh[ip * nplist + (iJ - 1)] +=
+                                sllh.at(ip) * coefficient.at(ip);
+                }
+            }
+        }
+
+#define s2ChainRule(QUANT, IND1, N1T, N1, IND2, N2)                            \
+    if (!s##QUANT.empty())                                                       \
+        for (int ip = 0; ip < nplist; ++ip)                                    \
+            for (int iJ = 1; iJ < nJ; ++iJ)                                    \
+                for (int IND1 = 0; IND1 < N1T; ++IND1)                         \
+                    for (int IND2 = 0; IND2 < N2; ++IND2) {                    \
+                    s##QUANT.at((IND2*nplist + ip)*N1 + IND1 + iJ*N1T) *=      \
+                        pcoefficient.at(ip) * augcoefficient[iJ - 1];          \
+                        if (model->plist(ip) == iJ - 1)                        \
+                            s##QUANT.at((IND2*nplist + ip)*N1 + IND1 + iJ*N1T) +=   \
+                                s##QUANT.at((IND2*nplist + ip)*N1 + IND1) *    \
+                                    coefficient[ip];                           \
+}
+
+
+        s2ChainRule(x, ix, nxtrue, nx, it, nt);
+        s2ChainRule(y, iy, nytrue, ny, it, nt);
+        s2ChainRule(sigmay, iy, nytrue, ny, it, nt);
+        s2ChainRule(z, iz, nztrue, nz, ie, nmaxevent);
+        s2ChainRule(sigmaz, iz, nztrue, nz, ie, nmaxevent);
+        s2ChainRule(rz, iz, nztrue, nz, ie, nmaxevent);
+    }
+
+    if (o2mode == SecondOrderMode::directional) { // directional
+            for (int ip = 0; ip < nplist; ++ip) {
+                s2llh.at(ip) *= pcoefficient.at(ip);
+                s2llh.at(ip) += model->k()[nk - nplist + ip] * sllh.at(ip) /
+                             unscaledParameters[model->plist(ip)];
+        }
+
+#define s2vecChainRule(QUANT, IND1, N1T, N1, IND2, N2)                          \
+    if (!s##QUANT.empty())                                                        \
+        for (int ip = 0; ip < nplist; ++ip)                                     \
+            for (int IND1 = 0; IND1 < N1T; ++IND1)                              \
+                for (int IND2 = 0; IND2 < N2; ++IND2) {                         \
+                    s##QUANT.at((IND2*nplist + ip)*N1 + IND1 + N1T) *=          \
+                        pcoefficient.at(ip);                                    \
+                    s##QUANT.at((IND2*nplist + ip)*N1 + IND1 + N1T) +=          \
+                        model->k()[nk - nplist + ip] *                          \
+                        s##QUANT.at((IND2*nplist + ip)*N1 + IND1) /             \
+                        unscaledParameters[model->plist(ip)];                   \
+                }
+
+        s2vecChainRule(x, ix, nxtrue, nx, it, nt);
+        s2vecChainRule(y, iy, nytrue, ny, it, nt);
+        s2vecChainRule(sigmay, iy, nytrue, ny, it, nt);
+        s2vecChainRule(z, iz, nztrue, nz, ie, nmaxevent);
+        s2vecChainRule(sigmaz, iz, nztrue, nz, ie, nmaxevent);
+        s2vecChainRule(rz, iz, nztrue, nz, ie, nmaxevent);
+    }
+}
+
+void ReturnData::initializeObjectiveFunction()
+{
+    llh = 0.0;
+    chi2 = 0.0;
+    std::fill(sllh.begin(),sllh.end(), 0.0);
+    std::fill(s2llh.begin(),s2llh.end(), 0.0);
+}
+
+void ReturnData::fres(const int it, const ExpData &edata) {
+    if ( res.empty())
+        return;
+    
+    auto observedData = edata.getObservedDataPtr(it);
+    for (int iy = 0; iy < nytrue; ++iy) {
+        int iyt_true = iy + it * edata.nytrue();
+        int iyt = iy + it * ny;
+        if (!edata.isSetObservedData(it, iy))
+            continue;
+        res.at(iyt_true) =
+        (y.at(iyt) - observedData[iy]) / sigmay.at(iyt);
+    }
+}
+
+void ReturnData::fchi2(const int it) {
+    if (res.empty())
+        return;
+    
+    for (int iy = 0; iy < nytrue; ++iy) {
+        int iyt_true = iy + it * nytrue;
+        chi2 += pow(res.at(iyt_true), 2);
+    }
+}
+
+void ReturnData::fsres(const int it, const ExpData &edata) {
+    if (sres.empty())
+        return;
+    
+    for (int iy = 0; iy < nytrue; ++iy) {
+        int iyt_true = iy + it * edata.nytrue();
+        int iyt = iy + it * ny;
+        if (!edata.isSetObservedData(it, iy))
+            continue;
+        for (int ip = 0; ip < nplist; ++ip) {
+            sres.at(iyt_true * nplist + ip) =
+            sy.at(iy + ny * (ip + it * nplist)) /
+            sigmay.at(iyt);
+        }
+    }
+}
+
+void ReturnData::fFIM(const int it) {
+    if (sres.empty())
+        return;
+    
+    for (int iy = 0; iy < nytrue; ++iy) {
+        int iyt_true = iy + it * nytrue;
+        for (int ip = 0; ip < nplist; ++ip) {
+            for (int jp = 0; jp < nplist; ++jp) {
+                FIM.at(ip + nplist * jp) += sres.at(iyt_true * nplist + ip) *
+                    sres.at(iyt_true * nplist + jp);
+            }
+        }
+    }
+}
+    
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/returndata_matlab.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/returndata_matlab.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2535cd740c57c266dce5f617034d5c8f6945ba6c
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/returndata_matlab.cpp
@@ -0,0 +1,296 @@
+#include "amici/returndata_matlab.h"
+#include "amici/exception.h"
+#include "amici/defines.h"
+
+namespace amici {
+
+mxArray *getReturnDataMatlabFromAmiciCall(ReturnData const *rdata) {
+    mxArray *matlabSolutionStruct = initMatlabReturnFields(rdata);
+    return matlabSolutionStruct;
+}
+
+mxArray *initMatlabReturnFields(ReturnData const *rdata) {
+    const int numFields = 22;
+    const char *field_names_sol[numFields] = {"status",
+                                              "llh",
+                                              "sllh",
+                                              "s2llh",
+                                              "chi2",
+                                              "t",
+                                              "x",
+                                              "sx",
+                                              "y",
+                                              "sy",
+                                              "sigmay",
+                                              "ssigmay",
+                                              "z",
+                                              "sz",
+                                              "sigmaz",
+                                              "ssigmaz",
+                                              "rz",
+                                              "srz",
+                                              "s2rz",
+                                              "x0",
+                                              "sx0",
+                                              "diagnosis"};
+    
+    checkFieldNames(field_names_sol,numFields);
+
+    mxArray *matlabSolutionStruct =
+        mxCreateStructMatrix(1, 1, numFields, field_names_sol);
+    
+    std::vector<int> perm0 = {1, 0};
+    std::vector<int> perm1 = {0, 1};
+    std::vector<int> perm2 = {0, 2, 1};
+    std::vector<int> perm3 = {0, 2, 3, 1};
+    
+    writeMatlabField0(matlabSolutionStruct, "status", rdata->status);
+
+    writeMatlabField1(matlabSolutionStruct, "t", rdata->ts, rdata->nt);
+    writeMatlabField0(matlabSolutionStruct, "llh", rdata->llh);
+    writeMatlabField0(matlabSolutionStruct, "chi2", rdata->chi2);
+
+    if ((rdata->nz > 0) & (rdata->ne > 0)) {
+        writeMatlabField2(matlabSolutionStruct, "z", rdata->z, rdata->nmaxevent, rdata->nz, perm1);
+        writeMatlabField2(matlabSolutionStruct, "rz", rdata->rz, rdata->nmaxevent, rdata->nz, perm1);
+        writeMatlabField2(matlabSolutionStruct, "sigmaz", rdata->sigmaz, rdata->nmaxevent, rdata->nz, perm1);
+    }
+    if (rdata->nx > 0) {
+        writeMatlabField2(matlabSolutionStruct, "x", rdata->x, rdata->nt, rdata->nx, perm1);
+        writeMatlabField2(matlabSolutionStruct, "x0",  rdata->x0, rdata->nx, 1, perm1);
+    }
+    if (rdata->ny > 0) {
+        writeMatlabField2(matlabSolutionStruct, "y", rdata->y, rdata->nt, rdata->ny, perm1);
+        writeMatlabField2(matlabSolutionStruct, "sigmay", rdata->sigmay, rdata->nt, rdata->ny, perm1);
+    }
+    if (rdata->sensi >= SensitivityOrder::first) {
+        writeMatlabField1(matlabSolutionStruct, "sllh", rdata->sllh, rdata->nplist);
+        writeMatlabField2(matlabSolutionStruct, "sx0",  rdata->sx0, rdata->nplist, rdata->nx, perm0);
+
+        if (rdata->sensi_meth == SensitivityMethod::forward) {
+            writeMatlabField3(matlabSolutionStruct, "sx", rdata->sx, rdata->nt, rdata->nplist, rdata->nx, perm2);
+            if (rdata->ny > 0) {
+                writeMatlabField3(matlabSolutionStruct, "sy", rdata->sy, rdata->nt, rdata->nplist, rdata->ny, perm2);
+            }
+            if ((rdata->nz > 0) & (rdata->ne > 0)) {
+                writeMatlabField3(matlabSolutionStruct, "srz", rdata->srz, rdata->nmaxevent, rdata->nplist, rdata->nz, perm2);
+                if (rdata->sensi >= SensitivityOrder::second) {
+                    writeMatlabField4(matlabSolutionStruct, "s2rz", rdata->s2rz, rdata->nmaxevent, rdata->nplist, rdata->nztrue,
+                               rdata->nplist, perm3);
+                }
+                writeMatlabField3(matlabSolutionStruct, "sz", rdata->sz, rdata->nmaxevent, rdata->nplist, rdata->nz, perm2);
+            }
+        }
+
+        if (rdata->ny > 0) {
+            writeMatlabField3(matlabSolutionStruct, "ssigmay", rdata->ssigmay, rdata->nt, rdata->nplist, rdata->ny, perm2);
+        }
+        if ((rdata->nz > 0) & (rdata->ne > 0)) {
+            writeMatlabField3(matlabSolutionStruct, "ssigmaz", rdata->ssigmaz, rdata->nmaxevent, rdata->nplist, rdata->nz, perm2);
+        }
+
+        if (rdata->sensi >= SensitivityOrder::second) {
+            writeMatlabField2(matlabSolutionStruct, "s2llh", rdata->s2llh, rdata->nplist, rdata->nJ - 1, perm1);
+        }
+    }
+
+    mxArray *diagnosis = initMatlabDiagnosisFields(rdata);
+    mxSetField(matlabSolutionStruct, 0, "diagnosis", diagnosis);
+    
+    return(matlabSolutionStruct);
+}
+
+mxArray *initMatlabDiagnosisFields(ReturnData const *rdata) {
+    const int numFields = 17;
+    const char *field_names_sol[numFields] = {"xdot",
+                                              "J",
+                                              "numsteps",
+                                              "numrhsevals",
+                                              "numerrtestfails",
+                                              "numnonlinsolvconvfails",
+                                              "order",
+                                              "numstepsB",
+                                              "numrhsevalsB",
+                                              "numerrtestfailsB",
+                                              "numnonlinsolvconvfailsB",
+                                              "newton_status",
+                                              "newton_numsteps",
+                                              "newton_numlinsteps",
+                                              "newton_cpu_time",
+                                              "newton_t_steadystate",
+                                              "newton_wrms"
+    };
+    
+    checkFieldNames(field_names_sol,numFields);
+    
+    mxArray *matlabDiagnosisStruct =
+        mxCreateStructMatrix(1, 1, numFields, field_names_sol);
+    
+    std::vector<int> perm1 = {0, 1};
+    
+    writeMatlabField1(matlabDiagnosisStruct, "numsteps", rdata->numsteps, rdata->nt);
+    writeMatlabField1(matlabDiagnosisStruct, "numrhsevals", rdata->numrhsevals, rdata->nt);
+    writeMatlabField1(matlabDiagnosisStruct, "numerrtestfails", rdata->numerrtestfails, rdata->nt);
+    writeMatlabField1(matlabDiagnosisStruct, "numnonlinsolvconvfails", rdata->numnonlinsolvconvfails, rdata->nt);
+    writeMatlabField1(matlabDiagnosisStruct, "order", rdata->order, rdata->nt);
+
+    if (rdata->nx > 0) {
+        writeMatlabField1(matlabDiagnosisStruct, "xdot", rdata->xdot, rdata->nx);
+        writeMatlabField2(matlabDiagnosisStruct, "J", rdata->J, rdata->nx, rdata->nx, perm1);
+        writeMatlabField0(matlabDiagnosisStruct, "newton_status", rdata->newton_status);
+        writeMatlabField1(matlabDiagnosisStruct, "newton_numsteps", rdata->newton_numsteps, 3);
+        writeMatlabField2(matlabDiagnosisStruct, "newton_numlinsteps", rdata->newton_numlinsteps, rdata->newton_maxsteps, 2, perm1);
+        writeMatlabField0(matlabDiagnosisStruct, "newton_cpu_time", rdata->newton_cpu_time);
+        writeMatlabField0(matlabDiagnosisStruct, "newton_t_steadystate", rdata->t_steadystate);
+        writeMatlabField0(matlabDiagnosisStruct, "newton_wrms", rdata->wrms_steadystate);
+    }
+    if (rdata->sensi >= SensitivityOrder::first) {
+        if (rdata->sensi_meth == SensitivityMethod::adjoint) {
+            writeMatlabField1(matlabDiagnosisStruct, "numstepsB", rdata->numstepsB, rdata->nt);
+            writeMatlabField1(matlabDiagnosisStruct, "numrhsevalsB", rdata->numrhsevalsB, rdata->nt);
+            writeMatlabField1(matlabDiagnosisStruct, "numerrtestfailsB", rdata->numerrtestfailsB, rdata->nt);
+            writeMatlabField1(matlabDiagnosisStruct, "numnonlinsolvconvfailsB", rdata->numnonlinsolvconvfailsB, rdata->nt);
+        }
+    }
+
+    return(matlabDiagnosisStruct);
+}
+
+
+template<typename T>
+void writeMatlabField0(mxArray *matlabStruct, const char *fieldName,
+                       T fieldData) {
+    
+    std::vector<mwSize> dim = {(mwSize)(1), (mwSize)(1)};
+    
+    double *array = initAndAttachArray(matlabStruct, fieldName, dim);
+    
+    array[0] = static_cast<double>(fieldData);
+}
+
+template<typename T>
+void writeMatlabField1(mxArray *matlabStruct, const char *fieldName,
+                       std::vector<T> const& fieldData, int dim0) {
+    if(fieldData.size() != dim0)
+        throw AmiException("Dimension mismatch when writing rdata->%s to matlab results",fieldName);
+    
+    std::vector<mwSize> dim = {(mwSize)(dim0), (mwSize)(1)};
+    
+    double *array = initAndAttachArray(matlabStruct, fieldName, dim);
+    
+    for(int i = 0; i < dim0; i++)
+        array[i] = static_cast<double>(fieldData[i]);
+}
+
+template<typename T>
+void writeMatlabField2(mxArray *matlabStruct, const char *fieldName,
+                      std::vector<T> const& fieldData, int dim0, int dim1,
+                      std::vector<int> perm) {
+    if(fieldData.size() != dim0*dim1)
+        throw AmiException("Dimension mismatch when writing rdata->%s to matlab results",fieldName);
+    
+    if(perm.size() != 2)
+        throw AmiException("Dimension mismatch when applying permutation!");
+    
+    std::vector<mwSize> dim = {(mwSize)(dim0), (mwSize)(dim1)};
+    
+    double *array = initAndAttachArray(matlabStruct, fieldName, reorder(dim,perm));
+    
+    std::vector<int> index = {0,0};
+    /* transform rowmajor (c++) to colmajor (matlab) and apply permutation */
+    for (index[0] = 0; index[0] < dim[0]; index[0]++) {
+        for (index[1] = 0; index[1] < dim[1]; index[1]++) {
+            array[index[perm[0]] + index[perm[1]]*dim[perm[0]]] =
+                static_cast<double>(fieldData[index[0]*dim[1] + index[1]]);
+        }
+    }
+}
+
+template<typename T>
+void writeMatlabField3(mxArray *matlabStruct, const char *fieldName,
+                      std::vector<T> const& fieldData, int dim0, int dim1,
+                      int dim2, std::vector<int> perm) {
+    if(fieldData.size() != dim0*dim1*dim2)
+        throw AmiException("Dimension mismatch when writing rdata->%s to matlab results",fieldName);
+    
+    if(perm.size() != 3)
+        throw AmiException("Dimension mismatch when applying permutation!");
+    
+    std::vector<mwSize> dim = {(mwSize)(dim0), (mwSize)(dim1), (mwSize)(dim2)};
+    
+    double *array = initAndAttachArray(matlabStruct, fieldName, reorder(dim,perm));
+    
+    std::vector<int> index = {0,0,0};
+    /* transform rowmajor (c++) to colmajor (matlab) and apply permutation */
+    for (index[0] = 0; index[0] < dim[0]; index[0]++) {
+        for (index[1] = 0; index[1] < dim[1]; index[1]++) {
+            for (index[2] = 0; index[2] < dim[2]; index[2]++) {
+                array[index[perm[0]] + (index[perm[1]] + index[perm[2]]*dim[perm[1]])*dim[perm[0]]] =
+                    static_cast<double>(fieldData[(index[0]*dim[1] + index[1])*dim[2] + index[2]]);
+            }
+        }
+    }
+}
+
+template<typename T>
+void writeMatlabField4(mxArray *matlabStruct, const char *fieldName,
+                      std::vector<T> const& fieldData, int dim0, int dim1,
+                      int dim2, int dim3, std::vector<int> perm) {
+    if(fieldData.size() != dim0*dim1*dim2*dim3)
+        throw AmiException("Dimension mismatch when writing rdata->%s to matlab results!",fieldName);
+    
+    if(perm.size() != 4)
+        throw AmiException("Dimension mismatch when applying permutation!");
+    
+    std::vector<mwSize> dim = {(mwSize)(dim0), (mwSize)(dim1), (mwSize)(dim2), (mwSize)(dim3)};
+    
+    double *array = initAndAttachArray(matlabStruct, fieldName, reorder(dim,perm));
+    
+    std::vector<int> index = {0,0,0,0};
+    /* transform rowmajor (c++) to colmajor (matlab) and apply permutation */
+    for (index[0] = 0; index[0] < dim[0]; index[0]++) {
+        for (index[1] = 0; index[1] < dim[1]; index[1]++) {
+            for (index[2] = 0; index[2] < dim[2]; index[2]++) {
+                for (index[3] = 0; index[3] < dim[3]; index[3]++) {
+                    array[index[perm[0]] + (index[perm[1]] + (index[perm[2]] + index[perm[3]]*dim[perm[2]])*dim[perm[1]])*dim[perm[0]]] =
+                        static_cast<double>(fieldData[((index[0]*dim[1] + index[1])*dim[2] + index[2])*dim[3] + index[3]]);
+                }
+            }
+        }
+    }
+}
+
+double *initAndAttachArray(mxArray *matlabStruct, const char *fieldName, std::vector<mwSize> dim) {
+    if(!mxIsStruct(matlabStruct))
+        throw AmiException("Passing non-struct mxArray to initAndAttachArray!",fieldName);
+    
+    int fieldNumber = mxGetFieldNumber(matlabStruct, fieldName);
+    if(fieldNumber<0)
+        throw AmiException("Trying to access non-existent field '%s'!",fieldName);
+
+    mxArray *array = mxCreateNumericArray(dim.size(), dim.data(), mxDOUBLE_CLASS, mxREAL);
+    mxSetFieldByNumber(matlabStruct, 0, fieldNumber, array);
+    return(mxGetPr(array));
+}
+
+void checkFieldNames(const char **fieldNames,const int fieldCount) {
+    for (int ifield = 0; ifield<fieldCount; ifield++) {
+        if(!fieldNames[ifield])
+            throw AmiException("Incorrect field name allocation, number of fields is smaller than fieldCount!");
+    }
+}
+
+template<typename T>
+std::vector<T> reorder(std::vector<T> const& input,
+                       std::vector<int> const& order) {
+    if(order.size() != input.size())
+        throw AmiException("Input dimension mismatch!");
+    std::vector<T> reordered;
+    reordered.resize(input.size());
+    for(int i = 0; i < input.size(); i++)
+        reordered[i] = input[order[i]];
+    return(reordered);
+}
+
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/solver.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/solver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..944c8ea911244d6ed4d3b2acf6b68fbced2e9cd9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/solver.cpp
@@ -0,0 +1,1037 @@
+#include "amici/solver.h"
+
+#include "amici/exception.h"
+#include "amici/misc.h"
+#include "amici/model.h"
+#include "amici/rdata.h"
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+
+namespace amici {
+
+extern msgIdAndTxtFp warnMsgIdAndTxt;
+
+Solver::Solver(const Solver &other)
+    : ism(other.ism), lmm(other.lmm), iter(other.iter),
+      interpType(other.interpType), maxsteps(other.maxsteps), t(nan("")),
+      sensi_meth(other.sensi_meth), stldet(other.stldet),
+      ordering(other.ordering), newton_maxsteps(other.newton_maxsteps),
+      newton_maxlinsteps(other.newton_maxlinsteps),
+      newton_preeq(other.newton_preeq), linsol(other.linsol),
+      atol(other.atol), rtol(other.rtol), atol_fsa(other.atol_fsa),
+      rtol_fsa(other.rtol_fsa), atolB(other.atolB), rtolB(other.rtolB),
+      quad_atol(other.quad_atol), quad_rtol(other.quad_rtol),
+      ss_atol(other.ss_atol), ss_rtol(other.ss_rtol),
+      ss_atol_sensi(other.ss_atol_sensi), ss_rtol_sensi(other.ss_rtol_sensi),
+      maxstepsB(other.maxstepsB), sensi(other.sensi)
+{}
+
+int Solver::run(const realtype tout) const {
+    setStopTime(tout);
+    clock_t starttime = clock();
+    int status;
+    if (getAdjInitDone()) {
+        status = solveF(tout, AMICI_NORMAL, &ncheckPtr);
+    } else {
+        status = solve(tout, AMICI_NORMAL);
+    }
+    cpu_time += (realtype)((clock() - starttime) * 1000) / CLOCKS_PER_SEC;
+    return status;
+}
+
+int Solver::step(const realtype tout) const {
+    int status;
+    if (getAdjInitDone()) {
+        status = solveF(tout, AMICI_ONE_STEP, &ncheckPtr);
+    } else {
+        status = solve(tout, AMICI_ONE_STEP);
+    }
+    return status;
+}
+
+void Solver::runB(const realtype tout) const {
+    clock_t starttime = clock();
+    solveB(tout, AMICI_NORMAL);
+    cpu_timeB += (realtype)((clock() - starttime) * 1000) / CLOCKS_PER_SEC;
+    t = tout;
+}
+
+void Solver::setup(const realtype t0, Model *model, const AmiVector &x0,
+                   const AmiVector &dx0, const AmiVectorArray &sx0,
+                   const AmiVectorArray &sdx0) const {
+    if (nx() != model->nx_solver || nplist() != model->nplist() ||
+        nquad() != model->nJ * model->nplist()) {
+        resetMutableMemory(model->nx_solver, model->nplist(),
+                           model->nJ * model->nplist());
+    }
+    /* Create solver memory object if necessary */
+    allocateSolver();
+    if (!solverMemory)
+        throw AmiException("Failed to allocated solver memory!");
+
+    /* Initialize CVodes/IDAs solver*/
+    init(t0, x0, dx0);
+
+    applyTolerances();
+
+    /* Set optional inputs */
+    setErrHandlerFn();
+    /* attaches userdata*/
+    setUserData(model);
+    /* specify maximal number of steps */
+    setMaxNumSteps(maxsteps);
+    /* activates stability limit detection */
+    setStabLimDet(stldet);
+
+    rootInit(model->ne);
+
+    initializeLinearSolver(model);
+    initializeNonLinearSolver();
+
+    if (sensi >= SensitivityOrder::first && model->nx_solver > 0) {
+        auto plist = model->getParameterList();
+        if (sensi_meth == SensitivityMethod::forward && !plist.empty()) {
+            /* Set sensitivity analysis optional inputs */
+            auto par = model->getUnscaledParameters();
+
+            /* Activate sensitivity calculations */
+            sensInit1(sx0, sdx0);
+            initializeNonLinearSolverSens(model);
+            setSensParams(par.data(), nullptr, plist.data());
+
+            applyTolerancesFSA();
+        } else if (sensi_meth == SensitivityMethod::adjoint) {
+            /* Allocate space for the adjoint computation */
+            adjInit();
+        }
+    }
+
+    setId(model);
+    setSuppressAlg(true);
+    /* calculate consistent DAE initial conditions (no effect for ODE) */
+    if (model->nt() > 1)
+        calcIC(model->getTimepoint(1));
+}
+
+void Solver::setupB(int *which, const realtype tf, Model *model,
+                    const AmiVector &xB0, const AmiVector &dxB0,
+                    const AmiVector &xQB0) const {
+    if (!solverMemory)
+        throw AmiException(
+            "Solver for the forward problem must be setup first");
+
+    /* allocate memory for the backward problem */
+    allocateSolverB(which);
+
+    /* initialise states */
+    binit(*which, tf, xB0, dxB0);
+
+    /* Attach user data */
+    setUserDataB(*which, model);
+
+    /* Number of maximal internal steps */
+    setMaxNumStepsB(*which, (maxstepsB == 0) ? maxsteps * 100 : maxstepsB);
+
+    initializeLinearSolverB(model, *which);
+    initializeNonLinearSolverB(*which);
+
+    /* Initialise quadrature calculation */
+    qbinit(*which, xQB0);
+
+    applyTolerancesASA(*which);
+    applyQuadTolerancesASA(*which);
+
+    setStabLimDetB(*which, stldet);
+}
+
+void Solver::getDiagnosis(const int it, ReturnData *rdata) const {
+    long int number;
+
+    if (solverWasCalledF && solverMemory) {
+        getNumSteps(solverMemory.get(), &number);
+        rdata->numsteps[it] = number;
+
+        getNumRhsEvals(solverMemory.get(), &number);
+        rdata->numrhsevals[it] = number;
+
+        getNumErrTestFails(solverMemory.get(), &number);
+        rdata->numerrtestfails[it] = number;
+
+        getNumNonlinSolvConvFails(solverMemory.get(), &number);
+        rdata->numnonlinsolvconvfails[it] = number;
+
+        getLastOrder(solverMemory.get(), &rdata->order[it]);
+    }
+}
+
+void Solver::getDiagnosisB(const int it, ReturnData *rdata,
+                           const int which) const {
+    long int number;
+
+    if (solverWasCalledB && solverMemoryB.at(which)) {
+        getNumSteps(solverMemoryB.at(which).get(), &number);
+        rdata->numstepsB[it] = number;
+
+        getNumRhsEvals(solverMemoryB.at(which).get(), &number);
+        rdata->numrhsevalsB[it] = number;
+
+        getNumErrTestFails(solverMemoryB.at(which).get(), &number);
+        rdata->numerrtestfailsB[it] = number;
+
+        getNumNonlinSolvConvFails(solverMemoryB.at(which).get(), &number);
+        rdata->numnonlinsolvconvfailsB[it] = number;
+    }
+}
+
+void Solver::initializeLinearSolver(const Model *model) const {
+    switch (linsol) {
+
+        /* DIRECT SOLVERS */
+
+    case LinearSolver::dense:
+        linearSolver = std::make_unique<SUNLinSolDense>(x);
+        setLinearSolver();
+        setDenseJacFn();
+        break;
+
+    case LinearSolver::band:
+        linearSolver =
+            std::make_unique<SUNLinSolBand>(x, model->ubw, model->lbw);
+        setLinearSolver();
+        setBandJacFn();
+        break;
+
+    case LinearSolver::LAPACKDense:
+        throw AmiException("Solver currently not supported!");
+
+    case LinearSolver::LAPACKBand:
+        throw AmiException("Solver currently not supported!");
+
+    case LinearSolver::diag:
+        diag();
+        setDenseJacFn();
+        break;
+
+        /* ITERATIVE SOLVERS */
+
+    case LinearSolver::SPGMR:
+        linearSolver = std::make_unique<SUNLinSolSPGMR>(x);
+        setLinearSolver();
+        setJacTimesVecFn();
+        break;
+
+    case LinearSolver::SPBCG:
+        linearSolver = std::make_unique<SUNLinSolSPBCGS>(x);
+        setLinearSolver();
+        setJacTimesVecFn();
+        break;
+
+    case LinearSolver::SPTFQMR:
+        linearSolver = std::make_unique<SUNLinSolSPTFQMR>(x);
+        setLinearSolver();
+        setJacTimesVecFn();
+        break;
+
+        /* SPARSE SOLVERS */
+
+    case LinearSolver::KLU:
+        linearSolver = std::make_unique<SUNLinSolKLU>(
+            x, model->nnz, CSC_MAT,
+            static_cast<SUNLinSolKLU::StateOrdering>(getStateOrdering()));
+        setLinearSolver();
+        setSparseJacFn();
+        break;
+
+#ifdef SUNDIALS_SUPERLUMT
+    case LinearSolver::SuperLUMT:
+        // TODO state ordering
+        linearSolver = std::make_unique<SUNLinSolSuperLUMT>(
+            *x, model->nnz, CSC_MAT,
+            static_cast<SUNLinSolSuperLUMT::StateOrdering>(getStateOrdering()));
+
+        setLinearSolver();
+        setSparseJacFn();
+        break;
+#endif
+    default:
+        throw AmiException("Invalid choice of solver: %d",
+                           static_cast<int>(linsol));
+    }
+}
+
+void Solver::initializeNonLinearSolver() const {
+    switch (iter) {
+    case NonlinearSolverIteration::newton:
+        nonLinearSolver = std::make_unique<SUNNonLinSolNewton>(x.getNVector());
+        break;
+    case NonlinearSolverIteration::fixedpoint:
+        nonLinearSolver =
+            std::make_unique<SUNNonLinSolFixedPoint>(x.getNVector());
+        break;
+    default:
+        throw AmiException("Invalid non-linear solver specified (%d).",
+                           static_cast<int>(iter));
+    }
+
+    setNonLinearSolver();
+}
+
+void Solver::initializeLinearSolverB(const Model *model,
+                                     const int which) const {
+    switch (linsol) {
+    /* DIRECT SOLVERS */
+    case LinearSolver::dense:
+        linearSolverB = std::make_unique<SUNLinSolDense>(xB);
+        setLinearSolverB(which);
+        setDenseJacFnB(which);
+        break;
+
+    case LinearSolver::band:
+        linearSolverB =
+            std::make_unique<SUNLinSolBand>(xB, model->ubw, model->lbw);
+        setLinearSolverB(which);
+        setBandJacFnB(which);
+        break;
+
+    case LinearSolver::LAPACKDense:
+        throw AmiException("Solver currently not supported!");
+
+    case LinearSolver::LAPACKBand:
+        throw AmiException("Solver currently not supported!");
+
+    case LinearSolver::diag:
+        diagB(which);
+        setDenseJacFnB(which);
+        break;
+
+        /* ITERATIVE SOLVERS */
+
+    case LinearSolver::SPGMR:
+        linearSolverB = std::make_unique<SUNLinSolSPGMR>(xB);
+        setLinearSolverB(which);
+        setJacTimesVecFnB(which);
+        break;
+
+    case LinearSolver::SPBCG:
+        linearSolverB = std::make_unique<SUNLinSolSPBCGS>(xB);
+        setLinearSolverB(which);
+        setJacTimesVecFnB(which);
+        break;
+
+    case LinearSolver::SPTFQMR:
+        linearSolverB = std::make_unique<SUNLinSolSPTFQMR>(xB);
+        setLinearSolverB(which);
+        setJacTimesVecFnB(which);
+        break;
+
+        /* SPARSE SOLVERS */
+
+    case LinearSolver::KLU:
+        linearSolverB = std::make_unique<SUNLinSolKLU>(
+            xB, model->nnz, CSC_MAT,
+            static_cast<SUNLinSolKLU::StateOrdering>(getStateOrdering()));
+        setLinearSolverB(which);
+        setSparseJacFnB(which);
+        break;
+#ifdef SUNDIALS_SUPERLUMT
+    case LinearSolver::SuperLUMT:
+        linearSolverB = std::make_unique<SUNLinSolSuperLUMT>(
+            *xB, model->nnz, CSC_MAT,
+            static_cast<SUNLinSolSuperLUMT::StateOrdering>(getStateOrdering()));
+        setLinearSolverB(which);
+        setSparseJacFnB(which);
+        break;
+#endif
+    default:
+        throw AmiException("Invalid choice of solver: %d",
+                           static_cast<int>(linsol));
+    }
+}
+
+void Solver::initializeNonLinearSolverB(const int which) const {
+    switch (iter) {
+    case NonlinearSolverIteration::newton:
+        nonLinearSolverB =
+            std::make_unique<SUNNonLinSolNewton>(xB.getNVector());
+        break;
+    case NonlinearSolverIteration::fixedpoint:
+        nonLinearSolverB =
+            std::make_unique<SUNNonLinSolFixedPoint>(xB.getNVector());
+        break;
+    default:
+        throw AmiException("Invalid non-linear solver specified (%d).",
+                           static_cast<int>(iter));
+    }
+
+    setNonLinearSolverB(which);
+}
+
+bool operator==(const Solver &a, const Solver &b) {
+    if (typeid(a) != typeid(b))
+        return false;
+
+    return (a.interpType == b.interpType) && (a.lmm == b.lmm) &&
+           (a.iter == b.iter) && (a.stldet == b.stldet) &&
+           (a.ordering == b.ordering) &&
+           (a.newton_maxsteps == b.newton_maxsteps) &&
+           (a.newton_maxlinsteps == b.newton_maxlinsteps) &&
+           (a.newton_preeq == b.newton_preeq) && (a.ism == b.ism) &&
+           (a.linsol == b.linsol) && (a.atol == b.atol) && (a.rtol == b.rtol) &&
+           (a.maxsteps == b.maxsteps) && (a.maxstepsB == b.maxstepsB) &&
+           (a.quad_atol == b.quad_atol) && (a.quad_rtol == b.quad_rtol) &&
+           (a.getAbsoluteToleranceSteadyState() ==
+            b.getAbsoluteToleranceSteadyState()) &&
+           (a.getRelativeToleranceSteadyState() ==
+            b.getRelativeToleranceSteadyState()) &&
+           (a.getAbsoluteToleranceSteadyStateSensi() ==
+            b.getAbsoluteToleranceSteadyStateSensi()) &&
+           (a.getRelativeToleranceSteadyStateSensi() ==
+            b.getRelativeToleranceSteadyStateSensi()) &&
+           (a.rtol_fsa == b.rtol_fsa ||
+            (isNaN(a.rtol_fsa) && isNaN(b.rtol_fsa))) &&
+           (a.atol_fsa == b.atol_fsa ||
+            (isNaN(a.atol_fsa) && isNaN(b.atol_fsa))) &&
+           (a.rtolB == b.rtolB || (isNaN(a.rtolB) && isNaN(b.rtolB))) &&
+           (a.atolB == b.atolB || (isNaN(a.atolB) && isNaN(b.atolB))) &&
+           (a.sensi == b.sensi) && (a.sensi_meth == b.sensi_meth);
+}
+
+void Solver::applyTolerances() const {
+    if (!getInitDone())
+        throw AmiException(("Solver instance was not yet set up, the "
+                            "tolerances cannot be applied yet!"));
+
+    setSStolerances(this->rtol, this->atol);
+}
+
+void Solver::applyTolerancesFSA() const {
+    if (!getInitDone())
+        throw AmiException(("Solver instance was not yet set up, the "
+                            "tolerances cannot be applied yet!"));
+
+    if (sensi < SensitivityOrder::first)
+        return;
+
+    if (nplist()) {
+        std::vector<realtype> atols(nplist(), getAbsoluteToleranceFSA());
+        setSensSStolerances(getRelativeToleranceFSA(), atols.data());
+        setSensErrCon(true);
+    }
+}
+
+void Solver::applyTolerancesASA(const int which) const {
+    if (!getAdjInitDone())
+        throw AmiException(("Adjoint solver instance was not yet set up, the "
+                            "tolerances cannot be applied yet!"));
+
+    if (sensi < SensitivityOrder::first)
+        return;
+
+    /* specify integration tolerances for backward problem */
+    setSStolerancesB(which, getRelativeToleranceB(), getAbsoluteToleranceB());
+}
+
+void Solver::applyQuadTolerancesASA(const int which) const {
+    if (!getAdjInitDone())
+        throw AmiException(("Adjoint solver instance was not yet set up, the "
+                            "tolerances cannot be applied yet!"));
+
+    if (sensi < SensitivityOrder::first)
+        return;
+
+    realtype quad_rtol = isNaN(this->quad_rtol) ? rtol : this->quad_rtol;
+    realtype quad_atol = isNaN(this->quad_atol) ? atol : this->quad_atol;
+
+    /* Enable Quadrature Error Control */
+    setQuadErrConB(which, !std::isinf(quad_atol) && !std::isinf(quad_rtol));
+
+    quadSStolerancesB(which, quad_rtol, quad_atol);
+}
+
+void Solver::applySensitivityTolerances() const {
+    if (sensi < SensitivityOrder::first)
+        return;
+
+    if (sensi_meth == SensitivityMethod::forward)
+        applyTolerancesFSA();
+    else if (sensi_meth == SensitivityMethod::adjoint && getAdjInitDone()) {
+        for (int iMem = 0; iMem < (int)solverMemoryB.size(); ++iMem)
+            applyTolerancesASA(iMem);
+    }
+}
+
+SensitivityMethod Solver::getSensitivityMethod() const { return sensi_meth; }
+
+void Solver::setSensitivityMethod(const SensitivityMethod sensi_meth) {
+    if (sensi_meth != this->sensi_meth)
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->sensi_meth = sensi_meth;
+}
+
+int Solver::getNewtonMaxSteps() const { return newton_maxsteps; }
+
+void Solver::setNewtonMaxSteps(const int newton_maxsteps) {
+    if (newton_maxsteps < 0)
+        throw AmiException("newton_maxsteps must be a non-negative number");
+    this->newton_maxsteps = newton_maxsteps;
+}
+
+bool Solver::getNewtonPreequilibration() const { return newton_preeq; }
+
+void Solver::setNewtonPreequilibration(const bool newton_preeq) {
+    this->newton_preeq = newton_preeq;
+}
+
+int Solver::getNewtonMaxLinearSteps() const { return newton_maxlinsteps; }
+
+void Solver::setNewtonMaxLinearSteps(const int newton_maxlinsteps) {
+    if (newton_maxlinsteps < 0)
+        throw AmiException("newton_maxlinsteps must be a non-negative number");
+    this->newton_maxlinsteps = newton_maxlinsteps;
+}
+
+SensitivityOrder Solver::getSensitivityOrder() const { return sensi; }
+
+void Solver::setSensitivityOrder(const SensitivityOrder sensi) {
+    if (this->sensi != sensi)
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->sensi = sensi;
+
+    if (getInitDone())
+        applySensitivityTolerances();
+}
+
+double Solver::getRelativeTolerance() const {
+    return static_cast<double>(rtol);
+}
+
+void Solver::setRelativeTolerance(const double rtol) {
+    if (rtol < 0)
+        throw AmiException("rtol must be a non-negative number");
+
+    this->rtol = static_cast<realtype>(rtol);
+
+    if (getInitDone()) {
+        applyTolerances();
+        applySensitivityTolerances();
+    }
+}
+
+double Solver::getAbsoluteTolerance() const {
+    return static_cast<double>(atol);
+}
+
+void Solver::setAbsoluteTolerance(double atol) {
+    if (atol < 0)
+        throw AmiException("atol must be a non-negative number");
+
+    this->atol = static_cast<realtype>(atol);
+
+    if (getInitDone()) {
+        applyTolerances();
+        applySensitivityTolerances();
+    }
+}
+
+double Solver::getRelativeToleranceFSA() const {
+    return static_cast<double>(isNaN(rtol_fsa) ? rtol : rtol_fsa);
+}
+
+void Solver::setRelativeToleranceFSA(const double rtol) {
+    if (rtol < 0)
+        throw AmiException("rtol must be a non-negative number");
+
+    rtol_fsa = static_cast<realtype>(rtol);
+
+    if (getInitDone()) {
+        applySensitivityTolerances();
+    }
+}
+
+double Solver::getAbsoluteToleranceFSA() const {
+    return static_cast<double>(isNaN(atol_fsa) ? atol : atol_fsa);
+}
+
+void Solver::setAbsoluteToleranceFSA(const double atol) {
+    if (atol < 0)
+        throw AmiException("atol must be a non-negative number");
+
+    atol_fsa = static_cast<realtype>(atol);
+
+    if (getInitDone()) {
+        applySensitivityTolerances();
+    }
+}
+
+double Solver::getRelativeToleranceB() const {
+    return static_cast<double>(isNaN(rtolB) ? rtol : rtolB);
+}
+
+void Solver::setRelativeToleranceB(const double rtol) {
+    if (rtol < 0)
+        throw AmiException("rtol must be a non-negative number");
+
+    rtolB = static_cast<realtype>(rtol);
+
+    if (getInitDone()) {
+        applySensitivityTolerances();
+    }
+}
+
+double Solver::getAbsoluteToleranceB() const {
+    return static_cast<double>(isNaN(atolB) ? atol : atolB);
+}
+
+void Solver::setAbsoluteToleranceB(const double atol) {
+    if (atol < 0)
+        throw AmiException("atol must be a non-negative number");
+
+    atolB = static_cast<realtype>(atol);
+
+    if (getInitDone()) {
+        applySensitivityTolerances();
+    }
+}
+
+double Solver::getRelativeToleranceQuadratures() const {
+    return static_cast<double>(quad_rtol);
+}
+
+void Solver::setRelativeToleranceQuadratures(const double rtol) {
+    if (rtol < 0)
+        throw AmiException("rtol must be a non-negative number");
+
+    this->quad_rtol = static_cast<realtype>(rtol);
+
+    if (sensi_meth != SensitivityMethod::adjoint)
+        return;
+
+    for (int iMem = 0; iMem < (int)solverMemoryB.size(); ++iMem)
+        if (solverMemoryB.at(iMem))
+            applyQuadTolerancesASA(iMem);
+}
+
+double Solver::getAbsoluteToleranceQuadratures() const {
+    return static_cast<double>(quad_atol);
+}
+
+void Solver::setAbsoluteToleranceQuadratures(const double atol) {
+    if (atol < 0)
+        throw AmiException("atol must be a non-negative number");
+
+    this->quad_atol = static_cast<realtype>(atol);
+
+    if (sensi_meth != SensitivityMethod::adjoint)
+        return;
+
+    for (int iMem = 0; iMem < (int)solverMemoryB.size(); ++iMem)
+        if (solverMemoryB.at(iMem))
+            applyTolerancesASA(iMem);
+}
+
+double Solver::getRelativeToleranceSteadyState() const {
+    return static_cast<double>(isNaN(ss_rtol) ? rtol : ss_rtol);
+}
+
+void Solver::setRelativeToleranceSteadyState(const double rtol) {
+    if (rtol < 0)
+        throw AmiException("rtol must be a non-negative number");
+
+    this->ss_rtol = static_cast<realtype>(rtol);
+}
+
+double Solver::getAbsoluteToleranceSteadyState() const {
+    return static_cast<double>(isNaN(ss_atol) ? atol : ss_atol);
+}
+
+void Solver::setAbsoluteToleranceSteadyState(const double atol) {
+    if (atol < 0)
+        throw AmiException("atol must be a non-negative number");
+
+    this->ss_atol = static_cast<realtype>(atol);
+}
+
+double Solver::getRelativeToleranceSteadyStateSensi() const {
+    return static_cast<double>(isNaN(ss_rtol_sensi) ? rtol : ss_rtol_sensi);
+}
+
+void Solver::setRelativeToleranceSteadyStateSensi(const double rtol) {
+    if (rtol < 0)
+        throw AmiException("rtol must be a non-negative number");
+
+    this->ss_rtol_sensi = static_cast<realtype>(rtol);
+}
+
+double Solver::getAbsoluteToleranceSteadyStateSensi() const {
+    return static_cast<double>(isNaN(ss_atol_sensi) ? atol : ss_atol_sensi);
+}
+
+void Solver::setAbsoluteToleranceSteadyStateSensi(const double atol) {
+    if (atol < 0)
+        throw AmiException("atol must be a non-negative number");
+
+    this->ss_atol_sensi = static_cast<realtype>(atol);
+}
+
+long int Solver::getMaxSteps() const { return maxsteps; }
+
+void Solver::setMaxSteps(const long int maxsteps) {
+    if (maxsteps < 0)
+        throw AmiException("maxsteps must be a non-negative number");
+
+    this->maxsteps = maxsteps;
+    if (getAdjInitDone())
+        resetMutableMemory(nx(), nplist(), nquad());
+}
+
+long int Solver::getMaxStepsBackwardProblem() const { return maxstepsB; }
+
+void Solver::setMaxStepsBackwardProblem(const long int maxsteps) {
+    if (maxsteps < 0)
+        throw AmiException("maxsteps must be a non-negative number");
+
+    this->maxstepsB = maxsteps;
+    for (int iMem = 0; iMem < (int)solverMemoryB.size(); ++iMem)
+        if (solverMemoryB.at(iMem))
+            setMaxNumStepsB(iMem, this->maxstepsB);
+}
+
+LinearMultistepMethod Solver::getLinearMultistepMethod() const { return lmm; }
+
+void Solver::setLinearMultistepMethod(const LinearMultistepMethod lmm) {
+    if (solverMemory)
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->lmm = lmm;
+}
+
+NonlinearSolverIteration Solver::getNonlinearSolverIteration() const {
+    return iter;
+}
+
+void Solver::setNonlinearSolverIteration(const NonlinearSolverIteration iter) {
+    if (solverMemory)
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->iter = iter;
+}
+
+InterpolationType Solver::getInterpolationType() const { return interpType; }
+
+void Solver::setInterpolationType(const InterpolationType interpType) {
+    if (!solverMemoryB.empty())
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->interpType = interpType;
+}
+
+int Solver::getStateOrdering() const { return ordering; }
+
+void Solver::setStateOrdering(int ordering) {
+    this->ordering = ordering;
+    if (solverMemory && linsol == LinearSolver::KLU) {
+        auto klu = dynamic_cast<SUNLinSolKLU *>(linearSolver.get());
+        klu->setOrdering(static_cast<SUNLinSolKLU::StateOrdering>(ordering));
+        klu = dynamic_cast<SUNLinSolKLU *>(linearSolverB.get());
+        klu->setOrdering(static_cast<SUNLinSolKLU::StateOrdering>(ordering));
+    }
+#ifdef SUNDIALS_SUPERLUMT
+    if (solverMemory && linsol == LinearSolver::SuperLUMT) {
+        auto klu = dynamic_cast<SUNLinSolSuperLUMT *>(linearSolver.get());
+        klu->setOrdering(
+            static_cast<SUNLinSolSuperLUMT::StateOrdering>(ordering));
+        klu = dynamic_cast<SUNLinSolSuperLUMT *>(linearSolverB.get());
+        klu->setOrdering(
+            static_cast<SUNLinSolSuperLUMT::StateOrdering>(ordering));
+    }
+#endif
+}
+
+int Solver::getStabilityLimitFlag() const { return stldet; }
+
+void Solver::setStabilityLimitFlag(const int stldet) {
+    if (stldet != TRUE && stldet != FALSE)
+        throw AmiException("Invalid stldet flag, valid values are %i or %i",
+                           TRUE, FALSE);
+
+    this->stldet = stldet;
+    if (solverMemory) {
+        setStabLimDet(stldet);
+        for (int iMem = 0; iMem < (int)solverMemoryB.size(); ++iMem)
+            if (solverMemoryB.at(iMem))
+                setStabLimDetB(iMem, stldet);
+    }
+}
+
+LinearSolver Solver::getLinearSolver() const { return linsol; }
+
+void Solver::setLinearSolver(LinearSolver linsol) {
+    if (solverMemory)
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->linsol = linsol;
+    /*if(solverMemory)
+     initializeLinearSolver(getModel());*/
+}
+
+InternalSensitivityMethod Solver::getInternalSensitivityMethod() const {
+    return ism;
+}
+
+void Solver::setInternalSensitivityMethod(const InternalSensitivityMethod ism) {
+    if (solverMemory)
+        resetMutableMemory(nx(), nplist(), nquad());
+    this->ism = ism;
+}
+
+void Solver::initializeNonLinearSolverSens(const Model *model) const {
+    switch (iter) {
+    case NonlinearSolverIteration::newton:
+        switch (ism) {
+        case InternalSensitivityMethod::staggered:
+        case InternalSensitivityMethod::simultaneous:
+            nonLinearSolverSens = std::make_unique<SUNNonLinSolNewton>(
+                1 + model->nplist(), x.getNVector());
+            break;
+        case InternalSensitivityMethod::staggered1:
+            nonLinearSolverSens =
+                std::make_unique<SUNNonLinSolNewton>(x.getNVector());
+            break;
+        default:
+            throw AmiException(
+                "Unsupported internal sensitivity method selected: %d", ism);
+        }
+        break;
+    case NonlinearSolverIteration::fixedpoint:
+        switch (ism) {
+        case InternalSensitivityMethod::staggered:
+        case InternalSensitivityMethod::simultaneous:
+            nonLinearSolverSens = std::make_unique<SUNNonLinSolFixedPoint>(
+                1 + model->nplist(), x.getNVector());
+            break;
+        case InternalSensitivityMethod::staggered1:
+            nonLinearSolverSens =
+                std::make_unique<SUNNonLinSolFixedPoint>(x.getNVector());
+            break;
+        default:
+            throw AmiException(
+                "Unsupported internal sensitivity method selected: %d", ism);
+        }
+        break;
+    default:
+        throw AmiException("Invalid non-linear solver specified (%d).",
+                           static_cast<int>(iter));
+    }
+
+    setNonLinearSolverSens();
+}
+
+int Solver::nplist() const { return sx.getLength(); }
+
+int Solver::nx() const { return x.getLength(); }
+
+int Solver::nquad() const { return xQB.getLength(); }
+
+bool Solver::getInitDone() const { return initialized; };
+
+bool Solver::getSensInitDone() const { return sensInitialized; }
+
+bool Solver::getAdjInitDone() const { return adjInitialized; }
+
+bool Solver::getInitDoneB(const int which) const {
+    return static_cast<int>(initializedB.size()) > which &&
+           initializedB.at(which);
+}
+
+bool Solver::getQuadInitDoneB(const int which) const {
+    return static_cast<int>(initializedQB.size()) > which &&
+           initializedQB.at(which);
+}
+
+void Solver::setInitDone() const { initialized = true; };
+
+void Solver::setSensInitDone() const { sensInitialized = true; }
+
+void Solver::setAdjInitDone() const { adjInitialized = true; }
+
+void Solver::setInitDoneB(const int which) const {
+    if (which >= static_cast<int>(initializedB.size()))
+        initializedB.resize(which + 1, false);
+    initializedB.at(which) = true;
+}
+
+void Solver::setQuadInitDoneB(const int which) const {
+    if (which >= static_cast<int>(initializedQB.size()))
+        initializedQB.resize(which + 1, false);
+    initializedQB.at(which) = true;
+}
+
+realtype Solver::getCpuTime() const {
+    return cpu_time;
+}
+
+realtype Solver::getCpuTimeB() const {
+    return cpu_timeB;
+}
+
+void Solver::resetMutableMemory(const int nx, const int nplist,
+                                const int nquad) const {
+    solverMemory = nullptr;
+    initialized = false;
+    adjInitialized = false;
+    sensInitialized = false;
+    solverWasCalledF = false;
+    solverWasCalledB = false;
+
+    x = AmiVector(nx);
+    dx = AmiVector(nx);
+    sx = AmiVectorArray(nx, nplist);
+    sdx = AmiVectorArray(nx, nplist);
+
+    xB = AmiVector(nx);
+    dxB = AmiVector(nx);
+    xQB = AmiVector(nquad);
+
+    solverMemoryB.clear();
+    initializedB.clear();
+    initializedQB.clear();
+}
+
+void Solver::writeSolution(realtype *t, AmiVector &x, AmiVector &dx,
+                           AmiVectorArray &sx) const {
+    *t = gett();
+    x.copy(getState(*t));
+    dx.copy(getDerivativeState(*t));
+    if (sensInitialized) {
+        sx.copy(getStateSensitivity(*t));
+    }
+}
+
+void Solver::writeSolutionB(realtype *t, AmiVector &xB, AmiVector &dxB,
+                            AmiVector &xQB, const int which) const {
+    *t = gett();
+    xB.copy(getAdjointState(which, *t));
+    dxB.copy(getAdjointDerivativeState(which, *t));
+    xQB.copy(getAdjointQuadrature(which, *t));
+}
+
+const AmiVector &Solver::getState(const realtype t) const {
+    if (t == this->t)
+        return x;
+
+    if (solverWasCalledF)
+        getDky(t, 0);
+
+    return dky;
+}
+
+const AmiVector &Solver::getDerivativeState(const realtype t) const {
+    if (t == this->t)
+        return dx;
+
+    if (solverWasCalledF)
+        getDky(t, 1);
+
+    return dky;
+}
+
+const AmiVectorArray &Solver::getStateSensitivity(const realtype t) const {
+    if (sensInitialized) {
+        if (solverWasCalledF) {
+            if (t == this->t) {
+                getSens();
+            } else {
+                getSensDky(t, 0);
+            }
+        }
+    } else {
+        sx.reset();
+    }
+    return sx;
+}
+
+const AmiVector &Solver::getAdjointState(const int which,
+                                         const realtype t) const {
+    if (adjInitialized) {
+        if (solverWasCalledB) {
+            if (t == this->t) {
+                getB(which);
+                return xB;
+            }
+            getDkyB(t, 0, which);
+        }
+    } else {
+        dky.reset();
+    }
+    return dky;
+}
+
+const AmiVector &Solver::getAdjointDerivativeState(const int which,
+                                                   const realtype t) const {
+    if (adjInitialized) {
+        if (solverWasCalledB) {
+            if (t == this->t) {
+                getB(which);
+                return dxB;
+            }
+            getDkyB(t, 1, which);
+        }
+    } else {
+        dky.reset();
+    }
+    return dky;
+}
+
+const AmiVector &Solver::getAdjointQuadrature(const int which,
+                                              const realtype t) const {
+    if (adjInitialized) {
+        if (solverWasCalledB) {
+            if (t == this->t) {
+                getQuadB(which);
+                return xQB;
+            }
+            getQuadDkyB(t, 0, which);
+        }
+    } else {
+        xQB.reset();
+    }
+    return xQB;
+}
+
+realtype Solver::gett() const { return t; }
+
+void wrapErrHandlerFn(int error_code, const char *module,
+                      const char *function, char *msg, void * /*eh_data*/) {
+    char buffer[250];
+    char buffid[250];
+    sprintf(buffer, "AMICI ERROR: in module %s in function %s : %s ", module,
+            function, msg);
+    switch (error_code) {
+    case 99:
+        sprintf(buffid, "AMICI:mex:%s:%s:WARNING", module, function);
+        break;
+
+    case -1:
+        sprintf(buffid, "AMICI:mex:%s:%s:TOO_MUCH_WORK", module, function);
+        break;
+
+    case -2:
+        sprintf(buffid, "AMICI:mex:%s:%s:TOO_MUCH_ACC", module, function);
+        break;
+
+    case -3:
+        sprintf(buffid, "AMICI:mex:%s:%s:ERR_FAILURE", module, function);
+        break;
+
+    case -4:
+        sprintf(buffid, "AMICI:mex:%s:%s:CONV_FAILURE", module, function);
+        break;
+
+    default:
+        sprintf(buffid, "AMICI:mex:%s:%s:OTHER", module, function);
+        break;
+    }
+
+    warnMsgIdAndTxt(buffid, buffer);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/solver_cvodes.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/solver_cvodes.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4267cee5d3ffcd56292de51a65c97de5934690f7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/solver_cvodes.cpp
@@ -0,0 +1,993 @@
+#include "amici/solver_cvodes.h"
+
+#include "amici/exception.h"
+#include "amici/misc.h"
+#include "amici/model_ode.h"
+#include "amici/sundials_linsol_wrapper.h"
+
+#include <cvodes/cvodes.h>
+#include <cvodes/cvodes_diag.h>
+#include <cvodes/cvodes_impl.h>
+
+#include <amd.h>
+#include <btf.h>
+#include <colamd.h>
+#include <klu.h>
+
+#define ZERO RCONST(0.0)
+#define ONE RCONST(1.0)
+#define FOUR RCONST(4.0)
+
+namespace amici {
+
+// Ensure AMICI options are in sync with Sundials options
+static_assert((int)InternalSensitivityMethod::simultaneous == CV_SIMULTANEOUS,
+              "");
+static_assert((int)InternalSensitivityMethod::staggered == CV_STAGGERED, "");
+static_assert((int)InternalSensitivityMethod::staggered1 == CV_STAGGERED1, "");
+
+static_assert((int)InterpolationType::hermite == CV_HERMITE, "");
+static_assert((int)InterpolationType::polynomial == CV_POLYNOMIAL, "");
+
+static_assert((int)LinearMultistepMethod::adams == CV_ADAMS, "");
+static_assert((int)LinearMultistepMethod::BDF == CV_BDF, "");
+
+static_assert(AMICI_ROOT_RETURN == CV_ROOT_RETURN, "");
+
+
+/*
+ * The following static members are callback function to CVODES.
+ * Their signatures must not be changes.
+ */
+static int fxdot(realtype t, N_Vector x, N_Vector xdot, void *user_data);
+
+static int fJSparse(realtype t, N_Vector x, N_Vector xdot, SUNMatrix J,
+                    void *user_data, N_Vector tmp1, N_Vector tmp2,
+                    N_Vector tmp3);
+
+static int fJ(realtype t, N_Vector x, N_Vector xdot, SUNMatrix J,
+              void *user_data, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3);
+
+static int fJB(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+               SUNMatrix JB, void *user_data, N_Vector tmp1B,
+               N_Vector tmp2B, N_Vector tmp3B);
+
+static int fJSparseB(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                     SUNMatrix JB, void *user_data, N_Vector tmp1B,
+                     N_Vector tmp2B, N_Vector tmp3B);
+
+static int fJBand(realtype t, N_Vector x, N_Vector xdot, SUNMatrix J,
+                  void *user_data, N_Vector tmp1, N_Vector tmp2,
+                  N_Vector tmp3);
+
+static int fJBandB(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                   SUNMatrix JB, void *user_data, N_Vector tmp1B,
+                   N_Vector tmp2B, N_Vector tmp3B);
+
+static int fJDiag(realtype t, N_Vector JDiag, N_Vector x, void *user_data)
+__attribute__((unused));
+
+static int fJv(N_Vector v, N_Vector Jv, realtype t, N_Vector x,
+               N_Vector xdot, void *user_data, N_Vector tmp);
+
+static int fJvB(N_Vector vB, N_Vector JvB, realtype t, N_Vector x,
+                N_Vector xB, N_Vector xBdot, void *user_data,
+                N_Vector tmpB);
+
+static int froot(realtype t, N_Vector x, realtype *root, void *user_data);
+
+static int fxBdot(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                  void *user_data);
+
+static int fqBdot(realtype t, N_Vector x, N_Vector xB, N_Vector qBdot,
+                  void *user_data);
+
+static int fsxdot(int Ns, realtype t, N_Vector x, N_Vector xdot, int ip,
+                  N_Vector sx, N_Vector sxdot, void *user_data,
+                  N_Vector tmp1, N_Vector tmp2);
+
+
+/* Function implementations */
+
+void CVodeSolver::init(const realtype t0, const AmiVector &x0,
+                       const AmiVector & /*dx0*/) const {
+    solverWasCalledF = false;
+    t = t0;
+    x.copy(x0);
+    int status;
+    if (getInitDone()) {
+        status = CVodeReInit(solverMemory.get(), t0, x.getNVector());
+    } else {
+        status = CVodeInit(solverMemory.get(), fxdot, t0, x.getNVector());
+        setInitDone();
+    }
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeInit");
+}
+
+void CVodeSolver::sensInit1(const AmiVectorArray &sx0,
+                            const AmiVectorArray & /*sdx0*/) const {
+    int status;
+    sx.copy(sx0);
+    if (getSensInitDone()) {
+        status = CVodeSensReInit(solverMemory.get(),
+                                 static_cast<int>(getSensitivityMethod()),
+                                 sx.getNVectorArray());
+    } else {
+        status = CVodeSensInit1(solverMemory.get(), nplist(),
+                                static_cast<int>(getSensitivityMethod()),
+                                fsxdot, sx.getNVectorArray());
+        setSensInitDone();
+    }
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSensInit1");
+}
+
+void CVodeSolver::binit(const int which, const realtype tf,
+                        const AmiVector &xB0,
+                        const AmiVector & /*dxB0*/) const {
+    solverWasCalledB = false;
+    xB.copy(xB0);
+    int status;
+    if (getInitDoneB(which)) {
+        status = CVodeReInitB(solverMemory.get(), which, tf, xB.getNVector());
+    } else {
+        status =
+            CVodeInitB(solverMemory.get(), which, fxBdot, tf, xB.getNVector());
+        setInitDoneB(which);
+    }
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeInitB");
+}
+
+void CVodeSolver::qbinit(const int which, const AmiVector &xQB0) const {
+    xQB.copy(xQB0);
+    int status;
+    if (getQuadInitDoneB(which)) {
+        status = CVodeQuadReInitB(solverMemory.get(), which, xQB.getNVector());
+    } else {
+        status =
+            CVodeQuadInitB(solverMemory.get(), which, fqBdot, xQB.getNVector());
+        setQuadInitDoneB(which);
+    }
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeQuadInitB");
+}
+
+void CVodeSolver::rootInit(int ne) const {
+    int status = CVodeRootInit(solverMemory.get(), ne, froot);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeRootInit");
+}
+
+void CVodeSolver::setDenseJacFn() const {
+    int status = CVodeSetJacFn(solverMemory.get(), fJ);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacFn");
+}
+
+void CVodeSolver::setSparseJacFn() const {
+    int status = CVodeSetJacFn(solverMemory.get(), fJSparse);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacFn");
+}
+
+void CVodeSolver::setBandJacFn() const {
+    int status = CVodeSetJacFn(solverMemory.get(), fJBand);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacFn");
+}
+
+void CVodeSolver::setJacTimesVecFn() const {
+    int status = CVodeSetJacTimes(solverMemory.get(), nullptr, fJv);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacTimes");
+}
+
+void CVodeSolver::setDenseJacFnB(int which) const {
+    int status = CVodeSetJacFnB(solverMemory.get(), which, fJB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacFnB");
+}
+
+void CVodeSolver::setSparseJacFnB(int which) const {
+    int status = CVodeSetJacFnB(solverMemory.get(), which, fJSparseB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacFnB");
+}
+
+void CVodeSolver::setBandJacFnB(int which) const {
+    int status = CVodeSetJacFnB(solverMemory.get(), which, fJBandB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacFnB");
+}
+
+void CVodeSolver::setJacTimesVecFnB(int which) const {
+    int status = CVodeSetJacTimesB(solverMemory.get(), which, nullptr, fJvB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetJacTimesB");
+}
+
+Solver *CVodeSolver::clone() const { return new CVodeSolver(*this); }
+
+void CVodeSolver::allocateSolver() const {
+    if (!solverMemory)
+        solverMemory = std::unique_ptr<void, std::function<void(void *)>>(
+            CVodeCreate(static_cast<int>(lmm)),
+            [](void *ptr) { CVodeFree(&ptr); });
+}
+
+void CVodeSolver::setSStolerances(const double rtol, const double atol) const {
+    int status = CVodeSStolerances(solverMemory.get(), rtol, atol);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSStolerances");
+}
+
+void CVodeSolver::setSensSStolerances(const double rtol,
+                                      const double *atol) const {
+    int status = CVodeSensSStolerances(solverMemory.get(), rtol,
+                                       const_cast<double *>(atol));
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSensEEtolerances");
+}
+
+void CVodeSolver::setSensErrCon(const bool error_corr) const {
+    int status = CVodeSetSensErrCon(solverMemory.get(), error_corr);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetSensErrCon");
+}
+
+void CVodeSolver::setQuadErrConB(const int which, const bool flag) const {
+    int status = CVodeSetQuadErrConB(solverMemory.get(), which, flag);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetQuadErrConB");
+}
+
+void CVodeSolver::getRootInfo(int *rootsfound) const {
+    int status = CVodeGetRootInfo(solverMemory.get(), rootsfound);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetRootInfo");
+}
+
+void CVodeSolver::setLinearSolver() const {
+    int status = CVodeSetLinearSolver(solverMemory.get(), linearSolver->get(),
+                                      linearSolver->getMatrix());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "setLinearSolver");
+}
+
+void CVodeSolver::setLinearSolverB(int which) const {
+    int status =
+        CVodeSetLinearSolverB(solverMemory.get(), which, linearSolverB->get(),
+                              linearSolverB->getMatrix());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "setLinearSolverB");
+}
+
+void CVodeSolver::setNonLinearSolver() const {
+    int status =
+        CVodeSetNonlinearSolver(solverMemory.get(), nonLinearSolver->get());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetNonlinearSolver");
+}
+
+void CVodeSolver::setNonLinearSolverSens() const {
+    if (getSensitivityOrder() < SensitivityOrder::first)
+        return;
+    if (getSensitivityMethod() != SensitivityMethod::forward)
+        return;
+
+    int status = CV_SUCCESS;
+
+    switch (ism) {
+    case InternalSensitivityMethod::staggered:
+        status = CVodeSetNonlinearSolverSensStg(solverMemory.get(),
+                                                nonLinearSolverSens->get());
+        break;
+    case InternalSensitivityMethod::simultaneous:
+        status = CVodeSetNonlinearSolverSensSim(solverMemory.get(),
+                                                nonLinearSolverSens->get());
+        break;
+    case InternalSensitivityMethod::staggered1:
+        status = CVodeSetNonlinearSolverSensStg1(solverMemory.get(),
+                                                 nonLinearSolverSens->get());
+        break;
+    default:
+        throw AmiException(
+            "Unsupported internal sensitivity method selected: %d", ism);
+    }
+
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSolver::setNonLinearSolverSens");
+}
+
+void CVodeSolver::setNonLinearSolverB(const int which) const {
+    int status = CVodeSetNonlinearSolverB(solverMemory.get(), which,
+                                          nonLinearSolverB->get());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetNonlinearSolverB");
+}
+
+void CVodeSolver::setErrHandlerFn() const {
+    int status =
+        CVodeSetErrHandlerFn(solverMemory.get(), wrapErrHandlerFn, nullptr);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetErrHandlerFn");
+}
+
+void CVodeSolver::setUserData(Model *model) const {
+    int status = CVodeSetUserData(solverMemory.get(), model);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetUserData");
+}
+
+void CVodeSolver::setUserDataB(const int which, Model *model) const {
+    int status = CVodeSetUserDataB(solverMemory.get(), which, model);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetUserDataB");
+}
+
+void CVodeSolver::setMaxNumSteps(const long mxsteps) const {
+    int status = CVodeSetMaxNumSteps(solverMemory.get(), mxsteps);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetMaxNumSteps");
+}
+
+void CVodeSolver::setStabLimDet(const int stldet) const {
+    int status = CVodeSetStabLimDet(solverMemory.get(), stldet);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetStabLimDet");
+}
+
+void CVodeSolver::setStabLimDetB(const int which, const int stldet) const {
+    int status = CVodeSetStabLimDetB(solverMemory.get(), which, stldet);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetStabLimDetB");
+}
+
+void CVodeSolver::setId(const Model *model) const {}
+
+void CVodeSolver::setSuppressAlg(const bool flag) const {}
+
+void CVodeSolver::resetState(void *ami_mem, const_N_Vector y0) const {
+
+    auto cv_mem = static_cast<CVodeMem>(ami_mem);
+    /* here we force the order in the next step to zero, and update the
+     Nordsieck history array, this is largely copied from CVodeReInit with
+     explanations from cvodes_impl.h
+     */
+
+    /* Set step parameters */
+
+    /* current order */
+    cv_mem->cv_q = 1;
+    /* L = q + 1 */
+    cv_mem->cv_L = 2;
+    /* number of steps to wait before updating in q */
+    cv_mem->cv_qwait = cv_mem->cv_L;
+    /* last successful q value used                */
+    cv_mem->cv_qu = 0;
+    /* last successful h value used                */
+    cv_mem->cv_hu = ZERO;
+    /* tolerance scale factor                      */
+    cv_mem->cv_tolsf = ONE;
+
+    /* Initialize other integrator optional outputs */
+
+    /* actual initial stepsize                     */
+    cv_mem->cv_h0u = ZERO;
+    /* step size to be used on the next step       */
+    cv_mem->cv_next_h = ZERO;
+    /* order to be used on the next step           */
+    cv_mem->cv_next_q = 0;
+
+    /* write updated state to Nordsieck history array  */
+    N_VScale(ONE, y0, cv_mem->cv_zn[0]);
+}
+
+void CVodeSolver::reInitPostProcessF(const realtype tnext) const {
+    reInitPostProcess(solverMemory.get(), &t, &x, tnext);
+    forceReInitPostProcessF = false;
+}
+
+void CVodeSolver::reInitPostProcessB(const realtype tnext) const {
+    realtype tBret;
+    auto cv_mem = static_cast<CVodeMem>(solverMemory.get());
+    auto ca_mem = cv_mem->cv_adj_mem;
+    auto cvB_mem = ca_mem->cvB_mem;
+    // loop over all backward problems
+    while (cvB_mem != nullptr) {
+        // store current backward problem in ca_mem to make it accessible in
+        // adjoint rhs wrapper functions
+        ca_mem->ca_bckpbCrt = cvB_mem;
+        reInitPostProcess(static_cast<void *>(cvB_mem->cv_mem), &tBret, &xB,
+                          tnext);
+        cvB_mem->cv_tout = tBret;
+        cvB_mem = cvB_mem->cv_next;
+    }
+    forceReInitPostProcessB = false;
+}
+
+void CVodeSolver::reInitPostProcess(void *ami_mem, realtype *t, AmiVector *yout,
+                                    const realtype tout) const {
+    auto cv_mem = static_cast<CVodeMem>(ami_mem);
+    auto nst_tmp = cv_mem->cv_nst;
+    cv_mem->cv_nst = 0;
+
+    auto status = CVodeSetStopTime(cv_mem, tout);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetStopTime");
+
+    status = CVode(ami_mem, tout, yout->getNVector(), t, CV_ONE_STEP);
+
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "reInitPostProcess");
+
+    cv_mem->cv_nst = nst_tmp + 1;
+    if (cv_mem->cv_adjMallocDone == SUNTRUE) {
+        /* add new step to history array, this is copied from CVodeF */
+        auto ca_mem = cv_mem->cv_adj_mem;
+        auto dt_mem = ca_mem->dt_mem;
+
+        if (cv_mem->cv_nst % ca_mem->ca_nsteps == 0) {
+            /* currently not implemented, we should never get here as we
+             limit cv_mem->cv_nst < ca_mem->ca_nsteps, keeping this for
+             future regression */
+            throw CvodeException(AMICI_ERROR, "reInitPostProcess");
+        }
+
+        /* Load next point in dt_mem */
+        dt_mem[cv_mem->cv_nst % ca_mem->ca_nsteps]->t = *t;
+        ca_mem->ca_IMstore(cv_mem, dt_mem[cv_mem->cv_nst % ca_mem->ca_nsteps]);
+
+        /* Set t1 field of the current ckeck point structure
+         for the case in which there will be no future
+         check points */
+        ca_mem->ck_mem->ck_t1 = *t;
+
+        /* tfinal is now set to *tret */
+        ca_mem->ca_tfinal = *t;
+    }
+}
+
+void CVodeSolver::reInit(const realtype t0, const AmiVector &yy0,
+                         const AmiVector & /*yp0*/) const {
+    auto cv_mem = static_cast<CVodeMem>(solverMemory.get());
+    cv_mem->cv_tn = t0;
+    if (solverWasCalledF)
+        forceReInitPostProcessF = true;
+    x.copy(yy0);
+    resetState(cv_mem, x.getNVector());
+}
+
+void CVodeSolver::sensReInit(const AmiVectorArray &yyS0,
+                             const AmiVectorArray & /*ypS0*/) const {
+    auto cv_mem = static_cast<CVodeMem>(solverMemory.get());
+    /* Initialize znS[0] in the history array */
+    for (int is = 0; is < nplist(); is++)
+        cv_mem->cv_cvals[is] = ONE;
+    if (solverWasCalledF)
+        forceReInitPostProcessF = true;
+    sx.copy(yyS0);
+    int status = N_VScaleVectorArray(nplist(), cv_mem->cv_cvals,
+                                     sx.getNVectorArray(), cv_mem->cv_znS[0]);
+    if (status != CV_SUCCESS)
+        throw CvodeException(CV_VECTOROP_ERR, "CVodeSensReInit");
+}
+
+void CVodeSolver::reInitB(const int which, const realtype tB0,
+                          const AmiVector &yyB0,
+                          const AmiVector & /*ypB0*/) const {
+    auto cv_memB =
+        static_cast<CVodeMem>(CVodeGetAdjCVodeBmem(solverMemory.get(), which));
+    if (solverWasCalledB)
+        forceReInitPostProcessB = true;
+    cv_memB->cv_tn = tB0;
+    xB.copy(yyB0);
+    resetState(cv_memB, xB.getNVector());
+}
+
+void CVodeSolver::quadReInitB(int which, const AmiVector &yQB0) const {
+    auto cv_memB =
+        static_cast<CVodeMem>(CVodeGetAdjCVodeBmem(solverMemory.get(), which));
+    if (solverWasCalledB)
+        forceReInitPostProcessB = true;
+    xQB.copy(yQB0);
+    N_VScale(ONE, xQB.getNVector(), cv_memB->cv_znQ[0]);
+}
+
+void CVodeSolver::setSensParams(const realtype *p, const realtype *pbar,
+                                const int *plist) const {
+    int status = CVodeSetSensParams(
+        solverMemory.get(), const_cast<realtype *>(p),
+        const_cast<realtype *>(pbar), const_cast<int *>(plist));
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetSensParams");
+}
+
+void CVodeSolver::getDky(realtype t, int k) const {
+    int status = CVodeGetDky(solverMemory.get(), t, k, dky.getNVector());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetDky");
+}
+
+void CVodeSolver::getSens() const {
+    realtype tDummy = 0;
+    int status =
+        CVodeGetSens(solverMemory.get(), &tDummy, sx.getNVectorArray());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetSens");
+}
+
+void CVodeSolver::getSensDky(const realtype t, const int k) const {
+    int status =
+        CVodeGetSensDky(solverMemory.get(), t, k, sx.getNVectorArray());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetSens");
+}
+
+void CVodeSolver::getDkyB(const realtype t, const int k,
+                          const int which) const {
+    int status = CVodeGetDky(CVodeGetAdjCVodeBmem(solverMemory.get(), which), t,
+                             k, dky.getNVector());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetDkyB");
+}
+
+void CVodeSolver::getQuadB(int which) const {
+    realtype tDummy = 0;
+    int status =
+        CVodeGetQuadB(solverMemory.get(), which, &tDummy, xQB.getNVector());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetQuadB");
+}
+
+void CVodeSolver::getQuadDkyB(const realtype t, const int k, int which) const {
+    int status =
+        CVodeGetQuadDky(CVodeGetAdjCVodeBmem(solverMemory.get(), which), t, k,
+                        xQB.getNVector());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetQuadDkyB");
+}
+
+void CVodeSolver::adjInit() const {
+    int status;
+    if (getAdjInitDone()) {
+        status = CVodeAdjReInit(solverMemory.get());
+    } else {
+        status = CVodeAdjInit(solverMemory.get(), static_cast<int>(maxsteps),
+                              static_cast<int>(interpType));
+        setAdjInitDone();
+    }
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeAdjInit");
+}
+
+void CVodeSolver::allocateSolverB(int *which) const {
+    if (!solverMemoryB.empty()) {
+        *which = 0;
+        return;
+    }
+    int status = CVodeCreateB(solverMemory.get(), static_cast<int>(lmm), which);
+    if (*which + 1 > static_cast<int>(solverMemoryB.size()))
+        solverMemoryB.resize(*which + 1);
+    solverMemoryB.at(*which) =
+        std::unique_ptr<void, std::function<void(void *)>>(
+            getAdjBmem(solverMemory.get(), *which), [](void *ptr) {});
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeCreateB");
+}
+
+void CVodeSolver::setSStolerancesB(const int which, const realtype relTolB,
+                                   const realtype absTolB) const {
+    int status =
+        CVodeSStolerancesB(solverMemory.get(), which, relTolB, absTolB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSStolerancesB");
+}
+
+void CVodeSolver::quadSStolerancesB(const int which, const realtype reltolQB,
+                                    const realtype abstolQB) const {
+    int status =
+        CVodeQuadSStolerancesB(solverMemory.get(), which, reltolQB, abstolQB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeQuadSStolerancesB");
+}
+
+void CVodeSolver::getB(const int which) const {
+    realtype tDummy = 0;
+    int status = CVodeGetB(solverMemory.get(), which, &tDummy, xB.getNVector());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetB");
+}
+
+int CVodeSolver::solve(const realtype tout, const int itask) const {
+    if (forceReInitPostProcessF)
+        reInitPostProcessF(tout);
+    int status = CVode(solverMemory.get(), tout, x.getNVector(), &t, itask);
+    if (status < 0) // status > 0 is okay and is used for e.g. root return
+        throw IntegrationFailure(status, t);
+    solverWasCalledF = true;
+    return status;
+}
+
+int CVodeSolver::solveF(const realtype tout, const int itask,
+                        int *ncheckPtr) const {
+    if (forceReInitPostProcessF)
+        reInitPostProcessF(tout);
+    int status =
+        CVodeF(solverMemory.get(), tout, x.getNVector(), &t, itask, ncheckPtr);
+    if (status < 0) // status > 0 is okay and is used for e.g. root return
+        throw IntegrationFailure(status, t);
+    solverWasCalledF = true;
+    return status;
+}
+
+void CVodeSolver::solveB(const realtype tBout, const int itaskB) const {
+    if (forceReInitPostProcessB)
+        reInitPostProcessB(tBout);
+    int status = CVodeB(solverMemory.get(), tBout, itaskB);
+    if (status != CV_SUCCESS)
+        throw IntegrationFailureB(status, tBout);
+    solverWasCalledB = true;
+}
+
+void CVodeSolver::setMaxNumStepsB(const int which, const long mxstepsB) const {
+    int status = CVodeSetMaxNumStepsB(solverMemory.get(), which, mxstepsB);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetMaxNumStepsB");
+}
+
+void CVodeSolver::diag() const {
+    int status = CVDiag(solverMemory.get());
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVDiag");
+}
+
+void CVodeSolver::diagB(const int which) const {
+    int status = CVDiagB(solverMemory.get(), which);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVDiagB");
+}
+
+void CVodeSolver::getNumSteps(const void *ami_mem, long int *numsteps) const {
+    int status = CVodeGetNumSteps(const_cast<void *>(ami_mem), numsteps);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetNumSteps");
+}
+
+void CVodeSolver::getNumRhsEvals(const void *ami_mem,
+                                 long int *numrhsevals) const {
+    int status = CVodeGetNumRhsEvals(const_cast<void *>(ami_mem), numrhsevals);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetNumRhsEvals");
+}
+
+void CVodeSolver::getNumErrTestFails(const void *ami_mem,
+                                     long int *numerrtestfails) const {
+    int status =
+        CVodeGetNumErrTestFails(const_cast<void *>(ami_mem), numerrtestfails);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetNumErrTestFails");
+}
+
+void CVodeSolver::getNumNonlinSolvConvFails(
+    const void *ami_mem, long int *numnonlinsolvconvfails) const {
+    int status = CVodeGetNumNonlinSolvConvFails(const_cast<void *>(ami_mem),
+                                                numnonlinsolvconvfails);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetNumNonlinSolvConvFails");
+}
+
+void CVodeSolver::getLastOrder(const void *ami_mem, int *order) const {
+    int status = CVodeGetLastOrder(const_cast<void *>(ami_mem), order);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeGetLastOrder");
+}
+
+void *CVodeSolver::getAdjBmem(void *ami_mem, int which) const {
+    return CVodeGetAdjCVodeBmem(ami_mem, which);
+}
+
+void CVodeSolver::calcIC(const realtype tout1) const {};
+
+void CVodeSolver::calcICB(const int which, const realtype tout1) const {};
+
+void CVodeSolver::setStopTime(const realtype tstop) const {
+    int status = CVodeSetStopTime(solverMemory.get(), tstop);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeSetStopTime");
+}
+
+void CVodeSolver::turnOffRootFinding() const {
+    int status = CVodeRootInit(solverMemory.get(), 0, nullptr);
+    if (status != CV_SUCCESS)
+        throw CvodeException(status, "CVodeRootInit");
+}
+
+const Model *CVodeSolver::getModel() const {
+    if (!solverMemory)
+        throw AmiException("Solver has not been allocated, information is not "
+                           "available");
+    auto cv_mem = static_cast<CVodeMem>(solverMemory.get());
+    return static_cast<Model *>(cv_mem->cv_user_data);
+}
+
+/**
+ * @brief Jacobian of xdot with respect to states x
+ * @param N number of state variables
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xdot Vector with the right hand side
+ * @param J Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJ(realtype t, N_Vector x, N_Vector xdot, SUNMatrix J,
+                    void *user_data, N_Vector /*tmp1*/, N_Vector /*tmp2*/,
+                    N_Vector /*tmp3*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJ(t, x, xdot, J);
+    return model->checkFinite(gsl::make_span(J), "Jacobian");
+}
+
+/**
+ * @brief Jacobian of xBdot with respect to adjoint state xB
+ * @param NeqBdot number of adjoint state variables
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xB Vector with the adjoint states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param JB Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1B temporary storage vector
+ * @param tmp2B temporary storage vector
+ * @param tmp3B temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJB(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                     SUNMatrix JB, void *user_data, N_Vector /*tmp1B*/,
+                     N_Vector /*tmp2B*/, N_Vector /*tmp3B*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJB(t, x, xB, xBdot, JB);
+    return model->checkFinite(gsl::make_span(JB), "Jacobian");
+}
+
+/**
+ * @brief J in sparse form (for sparse solvers from the SuiteSparse Package)
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xdot Vector with the right hand side
+ * @param J Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJSparse(realtype t, N_Vector x, N_Vector /*xdot*/,
+                          SUNMatrix J, void *user_data, N_Vector /*tmp1*/,
+                          N_Vector /*tmp2*/, N_Vector /*tmp3*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJSparse(t, x, J);
+    return model->checkFinite(gsl::make_span(J), "Jacobian");
+}
+
+/**
+ * @brief JB in sparse form (for sparse solvers from the SuiteSparse Package)
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xB Vector with the adjoint states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param JB Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1B temporary storage vector
+ * @param tmp2B temporary storage vector
+ * @param tmp3B temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJSparseB(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                           SUNMatrix JB, void *user_data, N_Vector /*tmp1B*/,
+                           N_Vector /*tmp2B*/, N_Vector /*tmp3B*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJSparseB(t, x, xB, xBdot, JB);
+    return model->checkFinite(gsl::make_span(JB), "Jacobian");
+}
+
+/**
+ * @brief J in banded form (for banded solvers)
+ * @param N number of states
+ * @param mupper upper matrix bandwidth
+ * @param mlower lower matrix bandwidth
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xdot Vector with the right hand side
+ * @param J Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJBand(realtype t, N_Vector x, N_Vector xdot, SUNMatrix J,
+           void *user_data, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3) {
+    return fJ(t, x, xdot, J, user_data, tmp1, tmp2, tmp3);
+}
+
+/**
+ * @brief JB in banded form (for banded solvers)
+ * @param NeqBdot number of states
+ * @param mupper upper matrix bandwidth
+ * @param mlower lower matrix bandwidth
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xB Vector with the adjoint states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param JB Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1B temporary storage vector
+ * @param tmp2B temporary storage vector
+ * @param tmp3B temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJBandB(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                         SUNMatrix JB, void *user_data, N_Vector tmp1B,
+                         N_Vector tmp2B, N_Vector tmp3B) {
+    return fJB(t, x, xB, xBdot, JB, user_data, tmp1B, tmp2B, tmp3B);
+}
+
+/**
+ * @brief Diagonalized Jacobian (for preconditioning)
+ * @param t timepoint
+ * @param JDiag Vector to which the Jacobian diagonal will be written
+ * @param x Vector with the states
+ * @param user_data object with user input @type Model_ODE
+ **/
+int fJDiag(realtype t, N_Vector JDiag, N_Vector x, void *user_data) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJDiag(t, JDiag, x);
+    return model->checkFinite(gsl::make_span(JDiag), "Jacobian");
+}
+
+/**
+ * @brief Matrix vector product of J with a vector v (for iterative solvers)
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xdot Vector with the right hand side
+ * @param v Vector with which the Jacobian is multiplied
+ * @param Jv Vector to which the Jacobian vector product will be
+ *written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJv(N_Vector v, N_Vector Jv, realtype t, N_Vector x,
+        N_Vector /*xdot*/, void *user_data, N_Vector /*tmp*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJv(v, Jv, t, x);
+    return model->checkFinite(gsl::make_span(Jv), "Jacobian");
+}
+
+/**
+ * @brief Matrix vector product of JB with a vector v (for iterative solvers)
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xB Vector with the adjoint states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param vB Vector with which the Jacobian is multiplied
+ * @param JvB Vector to which the Jacobian vector product will be
+ *written
+ * @param user_data object with user input @type Model_ODE
+ * @param tmpB temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJvB(N_Vector vB, N_Vector JvB, realtype t, N_Vector x,
+         N_Vector xB, N_Vector /*xBdot*/, void *user_data,
+         N_Vector /*tmpB*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fJvB(vB, JvB, t, x, xB);
+    return model->checkFinite(gsl::make_span(JvB), "Jacobian");
+}
+
+/**
+ * @brief Event trigger function for events
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param root array with root function values
+ * @param user_data object with user input @type Model_ODE
+ * @return status flag indicating successful execution
+ */
+int froot(realtype t, N_Vector x, realtype *root,
+                       void *user_data) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->froot(t, x, gsl::make_span<realtype>(root, model->ne));
+    return model->checkFinite(gsl::make_span<realtype>(root, model->ne),
+                              "root function");
+}
+
+/**
+ * @brief residual function of the ODE
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xdot Vector with the right hand side
+ * @param user_data object with user input @type Model_ODE
+ * @return status flag indicating successful execution
+ */
+int fxdot(realtype t, N_Vector x, N_Vector xdot, void *user_data) {
+    auto model = static_cast<Model_ODE *>(user_data);
+
+    if (t > 1e200 && !amici::checkFinite(gsl::make_span(x), "fxdot")) {
+        /* when t is large (typically ~1e300), CVODES may pass all NaN x
+           to fxdot from which we typically cannot recover. To save time
+           on normal execution, we do not always want to check finiteness
+           of x, but only do so when t is large and we expect problems. */
+        return AMICI_UNRECOVERABLE_ERROR;
+    }
+
+    model->fxdot(t, x, xdot);
+    return model->checkFinite(gsl::make_span(xdot), "fxdot");
+}
+
+/**
+ * @brief Right hand side of differential equation for adjoint state xB
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xB Vector with the adjoint states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param user_data object with user input @type Model_ODE
+ * @return status flag indicating successful execution
+ */
+int fxBdot(realtype t, N_Vector x, N_Vector xB, N_Vector xBdot,
+                        void *user_data) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fxBdot(t, x, xB, xBdot);
+    return model->checkFinite(gsl::make_span(xBdot), "fxBdot");
+}
+
+/**
+ * @brief Right hand side of integral equation for quadrature states qB
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xB Vector with the adjoint states
+ * @param qBdot Vector with the adjoint quadrature right hand side
+ * @param user_data pointer to temp data object
+ * @return status flag indicating successful execution
+ */
+int fqBdot(realtype t, N_Vector x, N_Vector xB, N_Vector qBdot,
+                        void *user_data) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fqBdot(t, x, xB, qBdot);
+    return model->checkFinite(gsl::make_span(qBdot), "qBdot");
+}
+
+/**
+ * @brief Right hand side of differential equation for state sensitivities sx
+ * @param Ns number of parameters
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param xdot Vector with the right hand side
+ * @param ip parameter index
+ * @param sx Vector with the state sensitivities
+ * @param sxdot Vector with the sensitivity right hand side
+ * @param user_data object with user input @type Model_ODE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fsxdot(int /*Ns*/, realtype t, N_Vector x, N_Vector /*xdot*/,
+                        int ip, N_Vector sx, N_Vector sxdot, void *user_data,
+                        N_Vector /*tmp1*/, N_Vector /*tmp2*/) {
+    auto model = static_cast<Model_ODE *>(user_data);
+    model->fsxdot(t, x, ip, sx, sxdot);
+    return model->checkFinite(gsl::make_span(sxdot), "sxdot");
+}
+
+bool operator==(const CVodeSolver &a, const CVodeSolver &b) {
+    return static_cast<Solver const &>(a) == static_cast<Solver const &>(b);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/solver_idas.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/solver_idas.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..670b22805be052fe1a929380c0c0a65d9e79c955
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/solver_idas.cpp
@@ -0,0 +1,1025 @@
+#include "amici/solver_idas.h"
+
+#include "amici/exception.h"
+#include "amici/misc.h"
+#include "amici/model_dae.h"
+#include "amici/sundials_linsol_wrapper.h"
+
+#include <idas/idas.h>
+#include <idas/idas_impl.h>
+
+#include <amd.h>
+#include <btf.h>
+#include <colamd.h>
+#include <klu.h>
+
+#define ONE RCONST(1.0)
+
+namespace amici {
+
+/*
+ * The following static members are callback function to CVODES.
+ * Their signatures must not be changes.
+ */
+
+static int fxdot(realtype t, N_Vector x, N_Vector dx, N_Vector xdot,
+                 void *user_data);
+
+static int fJ(realtype t, realtype cj, N_Vector x, N_Vector dx,
+              N_Vector xdot, SUNMatrix J, void *user_data, N_Vector tmp1,
+              N_Vector tmp2, N_Vector tmp3);
+
+static int fJSparse(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                    N_Vector xdot, SUNMatrix J, void *user_data,
+                    N_Vector tmp1, N_Vector tmp2, N_Vector tmp3);
+
+static int fJB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+               N_Vector xB, N_Vector dxB, N_Vector xBdot, SUNMatrix JB,
+               void *user_data, N_Vector tmp1B, N_Vector tmp2B,
+               N_Vector tmp3B);
+
+static int fJSparseB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                     N_Vector xB, N_Vector dxB, N_Vector xBdot,
+                     SUNMatrix JB, void *user_data, N_Vector tmp1B,
+                     N_Vector tmp2B, N_Vector tmp3B);
+
+static int fJBand(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                  N_Vector xdot, SUNMatrix J, void *user_data,
+                  N_Vector tmp1, N_Vector tmp2, N_Vector tmp3);
+
+static int fJBandB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                   N_Vector xB, N_Vector dxB, N_Vector xBdot, SUNMatrix JB,
+                   void *user_data, N_Vector tmp1B, N_Vector tmp2B,
+                   N_Vector tmp3B);
+
+static int fJv(realtype t, N_Vector x, N_Vector dx, N_Vector xdot,
+               N_Vector v, N_Vector Jv, realtype cj, void *user_data,
+               N_Vector tmp1, N_Vector tmp2);
+
+static int fJvB(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                N_Vector dxB, N_Vector xBdot, N_Vector vB, N_Vector JvB,
+                realtype cj, void *user_data, N_Vector tmpB1,
+                N_Vector tmpB2);
+
+static int froot(realtype t, N_Vector x, N_Vector dx, realtype *root,
+                 void *user_data);
+
+static int fxBdot(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                  N_Vector dxB, N_Vector xBdot, void *user_data);
+
+static int fqBdot(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                  N_Vector dxB, N_Vector qBdot, void *user_data);
+
+static int fsxdot(int Ns, realtype t, N_Vector x, N_Vector dx,
+                  N_Vector xdot, N_Vector *sx, N_Vector *sdx,
+                  N_Vector *sxdot, void *user_data, N_Vector tmp1,
+                  N_Vector tmp2, N_Vector tmp3);
+
+
+/* Function implementations */
+
+void IDASolver::init(const realtype t0, const AmiVector &x0,
+                     const AmiVector &dx0) const {
+    int status;
+    solverWasCalledF = false;
+    t = t0;
+    x.copy(x0);
+    dx.copy(dx0);
+    if (getInitDone()) {
+        status =
+            IDAReInit(solverMemory.get(), t, x.getNVector(), dx.getNVector());
+    } else {
+        status = IDAInit(solverMemory.get(), fxdot, t, x.getNVector(),
+                         dx.getNVector());
+        setInitDone();
+    }
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAInit");
+}
+
+void IDASolver::sensInit1(const AmiVectorArray &sx0,
+                          const AmiVectorArray &sdx0) const {
+    int status;
+    sx.copy(sx0);
+    sdx.copy(sdx0);
+    if (getSensInitDone()) {
+        status = IDASensReInit(solverMemory.get(),
+                               static_cast<int>(getSensitivityMethod()),
+                               sx.getNVectorArray(), sdx.getNVectorArray());
+    } else {
+        status = IDASensInit(solverMemory.get(), nplist(),
+                             static_cast<int>(getSensitivityMethod()), fsxdot,
+                             sx.getNVectorArray(), sdx.getNVectorArray());
+        setSensInitDone();
+    }
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASensInit");
+}
+
+void IDASolver::binit(const int which, const realtype tf, const AmiVector &xB0,
+                      const AmiVector &dxB0) const {
+    int status;
+    xB.copy(xB0);
+    dxB.copy(dxB0);
+    if (getInitDoneB(which))
+        status = IDAReInitB(solverMemory.get(), which, tf, xB.getNVector(),
+                            dxB.getNVector());
+    else {
+
+        status = IDAInitB(solverMemory.get(), which, fxBdot, tf,
+                          xB.getNVector(), dxB.getNVector());
+        setInitDoneB(which);
+    }
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAInitB");
+}
+
+void IDASolver::qbinit(const int which, const AmiVector &xQB0) const {
+    int status;
+    xQB.copy(xQB0);
+    if (getQuadInitDoneB(which))
+        status = IDAQuadReInitB(solverMemory.get(), which, xQB.getNVector());
+    else {
+        status =
+            IDAQuadInitB(solverMemory.get(), which, fqBdot, xQB.getNVector());
+        setQuadInitDoneB(which);
+    }
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAQuadInitB");
+}
+
+void IDASolver::rootInit(int ne) const {
+    int status = IDARootInit(solverMemory.get(), ne, froot);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDARootInit");
+}
+
+void IDASolver::setDenseJacFn() const {
+    int status = IDASetJacFn(solverMemory.get(), fJ);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDADlsSetDenseJacFn");
+}
+
+void IDASolver::setSparseJacFn() const {
+    int status = IDASetJacFn(solverMemory.get(), fJSparse);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASlsSetSparseJacFn");
+}
+
+void IDASolver::setBandJacFn() const {
+    int status = IDASetJacFn(solverMemory.get(), fJBand);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDADlsSetBandJacFn");
+}
+
+void IDASolver::setJacTimesVecFn() const {
+    int status = IDASetJacTimes(solverMemory.get(), nullptr, fJv);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASpilsSetJacTimesVecFn");
+}
+
+void IDASolver::setDenseJacFnB(const int which) const {
+    int status = IDASetJacFnB(solverMemory.get(), which, fJB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDADlsSetDenseJacFnB");
+}
+
+void IDASolver::setSparseJacFnB(const int which) const {
+    int status = IDASetJacFnB(solverMemory.get(), which, fJSparseB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASlsSetSparseJacFnB");
+}
+
+void IDASolver::setBandJacFnB(const int which) const {
+    int status = IDASetJacFnB(solverMemory.get(), which, fJBandB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDADlsSetBandJacFnB");
+}
+
+void IDASolver::setJacTimesVecFnB(const int which) const {
+    int status = IDASetJacTimesB(solverMemory.get(), which, nullptr, fJvB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASpilsSetJacTimesVecFnB");
+}
+
+Solver *IDASolver::clone() const { return new IDASolver(*this); }
+
+void IDASolver::allocateSolver() const {
+    if (!solverMemory)
+        solverMemory = std::unique_ptr<void, std::function<void(void *)>>(
+            IDACreate(), [](void *ptr) { IDAFree(&ptr); });
+}
+
+void IDASolver::setSStolerances(const realtype rtol,
+                                const realtype atol) const {
+    int status = IDASStolerances(solverMemory.get(), rtol, atol);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASStolerances");
+}
+void IDASolver::setSensSStolerances(const realtype rtol,
+                                    const realtype *atol) const {
+    int status = IDASensSStolerances(solverMemory.get(), rtol,
+                                     const_cast<realtype *>(atol));
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASensEEtolerances");
+}
+
+void IDASolver::setSensErrCon(const bool error_corr) const {
+    int status = IDASetSensErrCon(solverMemory.get(), error_corr);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetSensErrCon");
+}
+
+void IDASolver::setQuadErrConB(const int which, const bool flag) const {
+    int status = IDASetQuadErrConB(solverMemory.get(), which, flag);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetQuadErrConB");
+}
+
+void IDASolver::getRootInfo(int *rootsfound) const {
+    int status = IDAGetRootInfo(solverMemory.get(), rootsfound);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetRootInfo");
+}
+
+void IDASolver::setErrHandlerFn() const {
+    int status =
+        IDASetErrHandlerFn(solverMemory.get(), wrapErrHandlerFn, nullptr);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetErrHandlerFn");
+}
+
+void IDASolver::setUserData(Model *model) const {
+    int status = IDASetUserData(solverMemory.get(), model);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetUserData");
+}
+
+void IDASolver::setUserDataB(int which, Model *model) const {
+    int status = IDASetUserDataB(solverMemory.get(), which, model);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetUserDataB");
+}
+
+void IDASolver::setMaxNumSteps(const long int mxsteps) const {
+    int status = IDASetMaxNumSteps(solverMemory.get(), mxsteps);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetMaxNumSteps");
+}
+
+void IDASolver::setStabLimDet(const int stldet) const {}
+
+void IDASolver::setStabLimDetB(const int which, const int stldet) const {}
+
+void IDASolver::setId(const Model *model) const {
+
+    N_Vector id = N_VMake_Serial(model->nx_solver,
+                                 const_cast<realtype *>(model->idlist.data()));
+
+    int status = IDASetId(solverMemory.get(), id);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetMaxNumSteps");
+
+    N_VDestroy_Serial(id);
+}
+
+void IDASolver::setSuppressAlg(const bool flag) const {
+    int status = IDASetSuppressAlg(solverMemory.get(), flag);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetSuppressAlg");
+}
+
+void IDASolver::resetState(void *ami_mem, const_N_Vector yy0,
+                           const_N_Vector yp0) const {
+
+    auto ida_mem = static_cast<IDAMem>(ami_mem);
+    /* here we force the order in the next step to zero, and update the
+     phi arrays, this is largely copied from IDAReInit with
+     explanations from idas_impl.h
+     */
+
+    /* Initialize the phi array */
+
+    N_VScale(ONE, yy0, ida_mem->ida_phi[0]);
+    N_VScale(ONE, yp0, ida_mem->ida_phi[1]);
+
+    /* Set step parameters */
+
+    /* current order */
+    ida_mem->ida_kk      = 0;
+}
+
+void IDASolver::reInitPostProcessF(const realtype tnext) const {
+    reInitPostProcess(solverMemory.get(), &t, &x, &dx, tnext);
+}
+
+void IDASolver::reInitPostProcessB(const realtype tnext) const {
+    realtype tBret;
+    auto ida_mem = static_cast<IDAMem>(solverMemory.get());
+    auto idaadj_mem = ida_mem->ida_adj_mem;
+    auto idaB_mem = idaadj_mem->IDAB_mem;
+    // loop over all backward problems
+    while (idaB_mem != nullptr) {
+        // store current backward problem in ca_mem to make it accessible in
+        // adjoint rhs wrapper functions
+        idaadj_mem->ia_bckpbCrt = idaB_mem;
+        reInitPostProcess(static_cast<void *>(idaB_mem->IDA_mem), &tBret, &xB,
+                          &dxB, tnext);
+        // idaB_mem->ida_tout = tBret;
+        idaB_mem = idaB_mem->ida_next;
+    }
+    forceReInitPostProcessB = false;
+}
+
+void IDASolver::reInitPostProcess(void *ami_mem, realtype *t,
+                                  AmiVector *yout, AmiVector *ypout,
+                                  realtype tout) const {
+    auto ida_mem = static_cast<IDAMem>(ami_mem);
+    auto nst_tmp = ida_mem->ida_nst;
+    ida_mem->ida_nst = 0;
+
+    auto status = IDASetStopTime(ida_mem, tout);
+    if(status != IDA_SUCCESS)
+        throw IDAException(status, "CVodeSetStopTime");
+
+    status = IDASolve(ami_mem, tout, t, yout->getNVector(), ypout->getNVector(),
+                      IDA_ONE_STEP);
+
+    if(status != IDA_SUCCESS)
+        throw IDAException(status, "reInitPostProcess");
+
+    ida_mem->ida_nst = nst_tmp+1;
+    if (ida_mem->ida_adjMallocDone == SUNTRUE) {
+        /* add new step to history array, this is copied from CVodeF */
+        auto ia_mem = ida_mem->ida_adj_mem;
+        auto dt_mem = ia_mem->dt_mem;
+
+        if (ida_mem->ida_nst % ia_mem->ia_nsteps == 0) {
+            /* currently not implemented, we should never get here as we
+             limit cv_mem->cv_nst < ca_mem->ca_nsteps, keeping this for
+             future regression */
+            throw IDAException(AMICI_ERROR, "reInitPostProcess");
+        }
+
+        /* Load next point in dt_mem */
+        dt_mem[ida_mem->ida_nst % ia_mem->ia_nsteps]->t = *t;
+        ia_mem->ia_storePnt(ida_mem,
+                            dt_mem[ida_mem->ida_nst % ia_mem->ia_nsteps]);
+
+        /* Set t1 field of the current ckeck point structure
+         for the case in which there will be no future
+         check points */
+        ia_mem->ck_mem->ck_t1 = *t;
+
+        /* tfinal is now set to *tret */
+        ia_mem->ia_tfinal = *t;
+    }
+}
+
+void IDASolver::reInit(const realtype t0, const AmiVector &yy0,
+                       const AmiVector &yp0) const {
+
+    auto ida_mem = static_cast<IDAMem>(solverMemory.get());
+    ida_mem->ida_tn = t0;
+    if (solverWasCalledF)
+        forceReInitPostProcessF = true;
+    x.copy(yy0);
+    dx.copy(yp0);
+    resetState(ida_mem, x.getNVector(), xB.getNVector());
+}
+
+void IDASolver::sensReInit(const AmiVectorArray &yyS0,
+                           const AmiVectorArray &ypS0) const {
+    auto ida_mem = static_cast<IDAMem>(solverMemory.get());
+    /* Initialize znS[0] in the history array */
+    for (int is = 0; is < nplist(); is++)
+        ida_mem->ida_cvals[is] = ONE;
+    if (solverWasCalledF)
+        forceReInitPostProcessF = true;
+    sx.copy(yyS0);
+    sdx.copy(ypS0);
+    auto status =
+        N_VScaleVectorArray(nplist(), ida_mem->ida_cvals, sx.getNVectorArray(),
+                            ida_mem->ida_phiS[0]);
+    if (status != IDA_SUCCESS)
+        throw IDAException(IDA_VECTOROP_ERR, "IDASensReInit");
+    status = N_VScaleVectorArray(nplist(), ida_mem->ida_cvals,
+                                 sdx.getNVectorArray(), ida_mem->ida_phiS[1]);
+    if (status != IDA_SUCCESS)
+        throw IDAException(IDA_VECTOROP_ERR, "IDASensReInit");
+}
+
+void IDASolver::reInitB(const int which, const realtype tB0,
+                        const AmiVector &yyB0, const AmiVector &ypB0) const {
+
+    auto ida_memB =
+        static_cast<IDAMem>(IDAGetAdjIDABmem(solverMemory.get(), which));
+    if (solverWasCalledB)
+        forceReInitPostProcessB = true;
+    ida_memB->ida_tn = tB0;
+    xB.copy(yyB0);
+    dxB.copy(ypB0);
+    resetState(ida_memB, xB.getNVector(), dxB.getNVector());
+}
+
+void IDASolver::quadReInitB(const int which, const AmiVector &yQB0) const {
+    auto ida_memB =
+        static_cast<IDAMem>(IDAGetAdjIDABmem(solverMemory.get(), which));
+    if (solverWasCalledB)
+        forceReInitPostProcessB = true;
+    xQB.copy(yQB0);
+    N_VScale(ONE, xQB.getNVector(), ida_memB->ida_phiQ[0]);
+}
+
+void IDASolver::setSensParams(const realtype *p, const realtype *pbar,
+                              const int *plist) const {
+    int status = IDASetSensParams(solverMemory.get(), const_cast<realtype *>(p),
+                                  const_cast<realtype *>(pbar),
+                                  const_cast<int *>(plist));
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetSensParams");
+}
+
+void IDASolver::getDky(const realtype t, const int k) const {
+    int status = IDAGetDky(solverMemory.get(), t, k, dky.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetDky");
+}
+
+void IDASolver::getSens() const {
+    realtype tDummy = 0;
+    int status = IDAGetSens(solverMemory.get(), &tDummy, sx.getNVectorArray());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetSens");
+}
+
+void IDASolver::getSensDky(const realtype t, const int k) const {
+    int status = IDAGetSensDky(solverMemory.get(), t, k, sx.getNVectorArray());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetSens");
+}
+
+void IDASolver::getB(const int which) const {
+    realtype tDummy = 0;
+    int status = IDAGetB(solverMemory.get(), which, &tDummy, xB.getNVector(),
+                         dxB.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetB");
+}
+
+void IDASolver::getDkyB(const realtype t, int k, const int which) const {
+    int status = IDAGetDky(IDAGetAdjIDABmem(solverMemory.get(), which), t, k,
+                           dky.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetB");
+}
+void IDASolver::getQuadB(int which) const {
+    realtype tDummy = 0;
+    int status =
+        IDAGetQuadB(solverMemory.get(), which, &tDummy, xQB.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetQuadB");
+}
+
+void IDASolver::getQuadDkyB(const realtype t, int k, const int which) const {
+    int status = IDAGetQuadDky(IDAGetAdjIDABmem(solverMemory.get(), which), t,
+                               k, xQB.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetB");
+}
+
+void IDASolver::adjInit() const {
+    int status;
+    if (getAdjInitDone()) {
+        status = IDAAdjReInit(solverMemory.get());
+    } else {
+        status = IDAAdjInit(solverMemory.get(), static_cast<int>(maxsteps),
+                            static_cast<int>(interpType));
+        setAdjInitDone();
+    }
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAAdjInit");
+}
+
+void IDASolver::allocateSolverB(int *which) const {
+    if (!solverMemoryB.empty()) {
+        *which = 0;
+        return;
+    }
+    int status = IDACreateB(solverMemory.get(), which);
+    if (*which + 1 > static_cast<int>(solverMemoryB.size()))
+        solverMemoryB.resize(*which + 1);
+    solverMemoryB.at(*which) =
+        std::unique_ptr<void, std::function<void(void *)>>(
+            getAdjBmem(solverMemory.get(), *which), [](void *ptr) {});
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDACreateB");
+}
+
+void IDASolver::setSStolerancesB(const int which, const realtype relTolB,
+                                 const realtype absTolB) const {
+    int status = IDASStolerancesB(solverMemory.get(), which, relTolB, absTolB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASStolerancesB");
+}
+
+void IDASolver::quadSStolerancesB(const int which, const realtype reltolQB,
+                                  const realtype abstolQB) const {
+    int status =
+        IDAQuadSStolerancesB(solverMemory.get(), which, reltolQB, abstolQB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAQuadSStolerancesB");
+}
+
+int IDASolver::solve(const realtype tout, const int itask) const {
+    if (forceReInitPostProcessF)
+        reInitPostProcessF(tout);
+    int status = IDASolve(solverMemory.get(), tout, &t, x.getNVector(),
+                          dx.getNVector(), itask);
+    solverWasCalledF = true;
+    if (status < 0) // status > 0 is okay and is used for e.g. root return
+        throw IntegrationFailure(status, t);
+    return status;
+}
+
+int IDASolver::solveF(const realtype tout, const int itask,
+                      int *ncheckPtr) const {
+    if (forceReInitPostProcessF)
+        reInitPostProcessF(tout);
+    int status = IDASolveF(solverMemory.get(), tout, &t, x.getNVector(),
+                           xB.getNVector(), itask, ncheckPtr);
+    solverWasCalledF = true;
+    if (status < 0) // status > 0 is okay and is used for e.g. root return
+        throw IntegrationFailure(status, t);
+    return status;
+}
+
+void IDASolver::solveB(const realtype tBout, const int itaskB) const {
+    if (forceReInitPostProcessB)
+        reInitPostProcessB(tBout);
+    int status = IDASolveB(solverMemory.get(), tBout, itaskB);
+    solverWasCalledB = true;
+    if (status != IDA_SUCCESS)
+        throw IntegrationFailure(status, tBout);
+}
+
+void IDASolver::setMaxNumStepsB(const int which,
+                                const long int mxstepsB) const {
+    int status = IDASetMaxNumStepsB(solverMemory.get(), which, mxstepsB);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetMaxNumStepsB");
+}
+
+void IDASolver::diag() const {
+    throw AmiException("Diag Solver was not implemented for DAEs");
+}
+
+void IDASolver::diagB(const int /*which*/) const {
+    throw AmiException("Diag Solver was not implemented for DAEs");
+}
+
+void IDASolver::getNumSteps(const void *ami_mem, long int *numsteps) const {
+    int status = IDAGetNumSteps(const_cast<void *>(ami_mem), numsteps);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetNumSteps");
+}
+
+void IDASolver::getNumRhsEvals(const void *ami_mem,
+                               long int *numrhsevals) const {
+    int status = IDAGetNumResEvals(const_cast<void *>(ami_mem), numrhsevals);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetNumResEvals");
+}
+
+void IDASolver::getNumErrTestFails(const void *ami_mem,
+                                   long int *numerrtestfails) const {
+    int status =
+        IDAGetNumErrTestFails(const_cast<void *>(ami_mem), numerrtestfails);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetNumErrTestFails");
+}
+
+void IDASolver::getNumNonlinSolvConvFails(
+    const void *ami_mem, long int *numnonlinsolvconvfails) const {
+    int status = IDAGetNumNonlinSolvConvFails(const_cast<void *>(ami_mem),
+                                              numnonlinsolvconvfails);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetNumNonlinSolvConvFails");
+}
+
+void IDASolver::getLastOrder(const void *ami_mem, int *order) const {
+    int status = IDAGetLastOrder(const_cast<void *>(ami_mem), order);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDAGetLastOrder");
+}
+
+void *IDASolver::getAdjBmem(void *ami_mem, int which) const {
+    return IDAGetAdjIDABmem(ami_mem, which);
+}
+
+void IDASolver::calcIC(realtype tout1) const {
+    int status = IDACalcIC(solverMemory.get(), IDA_YA_YDP_INIT, tout1);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDACalcIC");
+    status =
+        IDAGetConsistentIC(solverMemory.get(), x.getNVector(), dx.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDACalcIC");
+}
+
+void IDASolver::calcICB(const int which, const realtype tout1) const {
+    int status = IDACalcICB(solverMemory.get(), which, tout1, xB.getNVector(),
+                            dxB.getNVector());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDACalcICB");
+}
+
+void IDASolver::setStopTime(const realtype tstop) const {
+    int status = IDASetStopTime(solverMemory.get(), tstop);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDASetStopTime");
+}
+
+void IDASolver::turnOffRootFinding() const {
+    int status = IDARootInit(solverMemory.get(), 0, nullptr);
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "IDARootInit");
+}
+
+const Model *IDASolver::getModel() const {
+    if (!solverMemory)
+        throw AmiException(
+            "Solver has not been allocated, information is not available");
+    auto ida_mem = static_cast<IDAMem>(solverMemory.get());
+    return static_cast<Model *>(ida_mem->ida_user_data);
+}
+
+void IDASolver::setLinearSolver() const {
+    int status = IDASetLinearSolver(solverMemory.get(), linearSolver->get(),
+                                    linearSolver->getMatrix());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "setLinearSolver");
+}
+
+void IDASolver::setLinearSolverB(const int which) const {
+    int status =
+        IDASetLinearSolverB(solverMemoryB[which].get(), which,
+                            linearSolverB->get(), linearSolverB->getMatrix());
+    if (status != IDA_SUCCESS)
+        throw IDAException(status, "setLinearSolverB");
+}
+
+void IDASolver::setNonLinearSolver() const {
+    int status =
+        IDASetNonlinearSolver(solverMemory.get(), nonLinearSolver->get());
+    if (status != IDA_SUCCESS)
+        throw CvodeException(status, "CVodeSetNonlinearSolver");
+}
+
+void IDASolver::setNonLinearSolverSens() const {
+    if (getSensitivityOrder() < SensitivityOrder::first)
+        return;
+    if (getSensitivityMethod() != SensitivityMethod::forward)
+        return;
+
+    int status = IDA_SUCCESS;
+
+    switch (ism) {
+    case InternalSensitivityMethod::staggered:
+        status = IDASetNonlinearSolverSensStg(solverMemory.get(),
+                                              nonLinearSolverSens->get());
+        break;
+    case InternalSensitivityMethod::simultaneous:
+        status = IDASetNonlinearSolverSensSim(solverMemory.get(),
+                                              nonLinearSolverSens->get());
+        break;
+    case InternalSensitivityMethod::staggered1:
+    default:
+        throw AmiException(
+            "Unsupported internal sensitivity method selected: %d", ism);
+    }
+
+    if (status != IDA_SUCCESS)
+        throw CvodeException(status, "CVodeSolver::setNonLinearSolverSens");
+}
+
+void IDASolver::setNonLinearSolverB(int which) const {
+    int status = IDASetNonlinearSolverB(solverMemory.get(), which,
+                                        nonLinearSolverB->get());
+    if (status != IDA_SUCCESS)
+        throw CvodeException(status, "CVodeSetNonlinearSolverB");
+}
+
+/**
+ * @brief Jacobian of xdot with respect to states x
+ * @param N number of state variables
+ * @param t timepoint
+ * @param cj scaling factor, inverse of the step size
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xdot Vector with the right hand side
+ * @param J Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJ(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                  N_Vector xdot, SUNMatrix J, void *user_data,
+                  N_Vector /*tmp1*/, N_Vector /*tmp2*/, N_Vector /*tmp3*/) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fJ(t, cj, x, dx, xdot, J);
+    return model->checkFinite(gsl::make_span(J), "Jacobian");
+}
+
+/**
+ * @brief Jacobian of xBdot with respect to adjoint state xB
+ * @param NeqBdot number of adjoint state variables
+ * @param t timepoint
+ * @param cj scaling factor, inverse of the step size
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xB Vector with the adjoint states
+ * @param dxB Vector with the adjoint derivative states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param JB Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1B temporary storage vector
+ * @param tmp2B temporary storage vector
+ * @param tmp3B temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                   N_Vector xB, N_Vector dxB, N_Vector /*xBdot*/, SUNMatrix JB,
+                   void *user_data, N_Vector /*tmp1B*/, N_Vector /*tmp2B*/,
+                   N_Vector /*tmp3B*/) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fJB(t, cj, x, dx, xB, dxB, JB);
+    return model->checkFinite(gsl::make_span(JB), "Jacobian");
+}
+
+/**
+ * @brief J in sparse form (for sparse solvers from the SuiteSparse Package)
+ * @param t timepoint
+ * @param cj scalar in Jacobian (inverse stepsize)
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xdot Vector with the right hand side
+ * @param J Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJSparse(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                        N_Vector /*xdot*/, SUNMatrix J, void *user_data,
+                        N_Vector /*tmp1*/, N_Vector /*tmp2*/,
+                        N_Vector /*tmp3*/) {
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fJSparse(t, cj, x, dx, J);
+    return model->checkFinite(gsl::make_span(J), "Jacobian");
+}
+
+/**
+ * @brief JB in sparse form (for sparse solvers from the SuiteSparse Package)
+ * @param t timepoint
+ * @param cj scalar in Jacobian
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xB Vector with the adjoint states
+ * @param dxB Vector with the adjoint derivative states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param JB Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1B temporary storage vector
+ * @param tmp2B temporary storage vector
+ * @param tmp3B temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJSparseB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                         N_Vector xB, N_Vector dxB, N_Vector /*xBdot*/,
+                         SUNMatrix JB, void *user_data, N_Vector /*tmp1B*/,
+                         N_Vector /*tmp2B*/, N_Vector /*tmp3B*/) {
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fJSparseB(t, cj, x, dx, xB, dxB, JB);
+    return model->checkFinite(gsl::make_span(JB), "Jacobian");
+}
+
+/**
+ * @brief J in banded form (for banded solvers)
+ * @param N number of states
+ * @param mupper upper matrix bandwidth
+ * @param mlower lower matrix bandwidth
+ * @param t timepoint
+ * @param cj scalar in Jacobian (inverse stepsize)
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xdot Vector with the right hand side
+ * @param J Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJBand(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                      N_Vector xdot, SUNMatrix J, void *user_data,
+                      N_Vector tmp1, N_Vector tmp2, N_Vector tmp3) {
+    return fJ(t, cj, x, dx, xdot, J, user_data, tmp1, tmp2, tmp3);
+}
+
+/**
+ * @brief JB in banded form (for banded solvers)
+ * @param NeqBdot number of states
+ * @param mupper upper matrix bandwidth
+ * @param mlower lower matrix bandwidth
+ * @param t timepoint
+ * @param cj scalar in Jacobian (inverse stepsize)
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xB Vector with the adjoint states
+ * @param dxB Vector with the adjoint derivative states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param JB Matrix to which the Jacobian will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1B temporary storage vector
+ * @param tmp2B temporary storage vector
+ * @param tmp3B temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fJBandB(realtype t, realtype cj, N_Vector x, N_Vector dx,
+                       N_Vector xB, N_Vector dxB, N_Vector xBdot, SUNMatrix JB,
+                       void *user_data, N_Vector tmp1B, N_Vector tmp2B,
+                       N_Vector tmp3B) {
+    return fJB(t, cj, x, dx, xB, dxB, xBdot, JB, user_data, tmp1B, tmp2B,
+               tmp3B);
+}
+
+/**
+ * @brief Matrix vector product of J with a vector v (for iterative solvers)
+ * @param t timepoint @type realtype
+ * @param cj scaling factor, inverse of the step size
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xdot Vector with the right hand side
+ * @param v Vector with which the Jacobian is multiplied
+ * @param Jv Vector to which the Jacobian vector product will be written
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJv(realtype t, N_Vector x, N_Vector dx, N_Vector /*xdot*/,
+                   N_Vector v, N_Vector Jv, realtype cj, void *user_data,
+                   N_Vector /*tmp1*/, N_Vector /*tmp2*/) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fJv(t, x, dx, v, Jv, cj);
+    return model->checkFinite(gsl::make_span(Jv), "Jacobian");
+}
+
+/**
+ * @brief Matrix vector product of JB with a vector v (for iterative solvers)
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xB Vector with the adjoint states
+ * @param dxB Vector with the adjoint derivative states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param vB Vector with which the Jacobian is multiplied
+ * @param JvB Vector to which the Jacobian vector product will be written
+ * @param cj scalar in Jacobian (inverse stepsize)
+ * @param user_data object with user input @type Model_DAE
+ * @param tmpB1 temporary storage vector
+ * @param tmpB2 temporary storage vector
+ * @return status flag indicating successful execution
+ **/
+int fJvB(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                    N_Vector dxB, N_Vector /*xBdot*/, N_Vector vB, N_Vector JvB,
+                    realtype cj, void *user_data, N_Vector /*tmpB1*/,
+                    N_Vector /*tmpB2*/) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fJvB(t, x, dx, xB, dxB, vB, JvB, cj);
+    return model->checkFinite(gsl::make_span(JvB), "Jacobian");
+}
+
+/**
+ * @brief Event trigger function for events
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param root array with root function values
+ * @param user_data object with user input @type Model_DAE
+ * @return status flag indicating successful execution
+ */
+int froot(realtype t, N_Vector x, N_Vector dx, realtype *root,
+                     void *user_data) {
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->froot(t, x, dx, gsl::make_span<realtype>(root, model->ne));
+    return model->checkFinite(gsl::make_span<realtype>(root, model->ne),
+                              "root function");
+}
+
+/**
+ * @brief Residual function of the DAE
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xdot Vector with the right hand side
+ * @param user_data object with user input @type Model_DAE
+ * @return status flag indicating successful execution
+ */
+int fxdot(realtype t, N_Vector x, N_Vector dx, N_Vector xdot,
+                     void *user_data) {
+    auto model = static_cast<Model_DAE *>(user_data);
+
+    if (t > 1e200 && !amici::checkFinite(gsl::make_span(x), "fxdot")) {
+        /* when t is large (typically ~1e300), CVODES may pass all NaN x
+           to fxdot from which we typically cannot recover. To save time
+           on normal execution, we do not always want to check finiteness
+           of x, but only do so when t is large and we expect problems. */
+        return AMICI_UNRECOVERABLE_ERROR;
+    }
+
+    model->fxdot(t, x, dx, xdot);
+    return model->checkFinite(gsl::make_span(xdot), "fxdot");
+}
+
+/**
+ * @brief Right hand side of differential equation for adjoint state xB
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xB Vector with the adjoint states
+ * @param dxB Vector with the adjoint derivative states
+ * @param xBdot Vector with the adjoint right hand side
+ * @param user_data object with user input @type Model_DAE
+ * @return status flag indicating successful execution
+ */
+int fxBdot(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                      N_Vector dxB, N_Vector xBdot, void *user_data) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fxBdot(t, x, dx, xB, dxB, xBdot);
+    return model->checkFinite(gsl::make_span(xBdot), "xBdot");
+}
+
+/**
+ * @brief Right hand side of integral equation for quadrature states qB
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xB Vector with the adjoint states
+ * @param dxB Vector with the adjoint derivative states
+ * @param qBdot Vector with the adjoint quadrature right hand side
+ * @param user_data pointer to temp data object @type Model_DAE
+ * @return status flag indicating successful execution
+ */
+int fqBdot(realtype t, N_Vector x, N_Vector dx, N_Vector xB,
+                      N_Vector dxB, N_Vector qBdot, void *user_data) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+    model->fqBdot(t, x, dx, xB, dxB, qBdot);
+    return model->checkFinite(gsl::make_span(qBdot), "qBdot");
+
+}
+
+/**
+ * @brief Right hand side of differential equation for state sensitivities sx
+ * @param Ns number of parameters
+ * @param t timepoint
+ * @param x Vector with the states
+ * @param dx Vector with the derivative states
+ * @param xdot Vector with the right hand side
+ * @param sx Vector with the state sensitivities
+ * @param sdx Vector with the derivative state sensitivities
+ * @param sxdot Vector with the sensitivity right hand side
+ * @param user_data object with user input @type Model_DAE
+ * @param tmp1 temporary storage vector
+ * @param tmp2 temporary storage vector
+ * @param tmp3 temporary storage vector
+ * @return status flag indicating successful execution
+ */
+int fsxdot(int /*Ns*/, realtype t, N_Vector x, N_Vector dx,
+                      N_Vector /*xdot*/, N_Vector *sx, N_Vector *sdx,
+                      N_Vector *sxdot, void *user_data, N_Vector /*tmp1*/,
+                      N_Vector /*tmp2*/, N_Vector /*tmp3*/) {
+
+    auto model = static_cast<Model_DAE *>(user_data);
+
+    for (int ip = 0; ip < model->nplist(); ip++) {
+        model->fsxdot(t, x, dx, ip, sx[ip], sdx[ip], sxdot[ip]);
+        if (model->checkFinite(gsl::make_span(sxdot[ip]), "sxdot")
+                != AMICI_SUCCESS)
+            return AMICI_RECOVERABLE_ERROR;
+    }
+
+    return AMICI_SUCCESS;
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/spline.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/spline.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4cbfd82456215679c891e3091c58b39486661f41
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/spline.cpp
@@ -0,0 +1,292 @@
+/**
+ * @file   spline.cpp
+ * @brief  definition of spline functions
+ * @author Peter & Nigel, Design Software, 42 Gubberley St, Kenmore, 4069,
+ * Australia.
+ */
+
+namespace amici {
+/************************************************/
+/*  adapted from                                */
+/*  CMATH.  Copyright (c) 1989 Design Software  */
+/*                                              */
+/************************************************/
+
+
+int spline(int n, int end1, int end2, double slope1, double slope2, double x[],
+           double y[], double b[], double c[], double d[])
+    /**
+   Evaluate the coefficients b[i], c[i], d[i], i = 0, 1, .. n-1 for
+   a cubic interpolating spline
+
+   S(xx) = Y[i] + b[i] * w + c[i] * w**2 + d[i] * w**3
+   where w = xx - x[i]
+   and   x[i] <= xx <= x[i+1]
+
+   The n supplied data points are x[i], y[i], i = 0 ... n-1.
+
+   @param[in] n The number of data points or knots (n >= 2)
+   @param[in] end1 0: default condition 1: specify the slopes at x[0]
+   @param[in] end2 0: default condition 1: specify the slopes at x[n-1]
+   @param[in] slope1 slope at x[0]
+   @param[in] slope2 slope at x[n-1]
+   @param[in] x[] the abscissas of the knots in strictly increasing order
+   @param[in] y[] the ordinates of the knots
+   @param[out] b[] array of spline coefficients
+   @param[out] c[] array of spline coefficients
+   @param[out] d[] array of spline coefficients
+
+   @retval 0 normal return
+   @retval 1 less than two data points; cannot interpolate
+   @retval 2 x[] are not in ascending order
+
+   Notes
+   -----
+     - The accompanying function seval() may be used to evaluate the
+       spline while deriv will provide the first derivative.
+     - Using p to denote differentiation
+       y[i] = S(X[i])
+       b[i] = Sp(X[i])
+       c[i] = Spp(X[i])/2
+       d[i] = Sppp(X[i])/6  ( Derivative from the right )
+     - Since the zero elements of the arrays ARE NOW used here,
+       all arrays to be passed from the main program should be
+       dimensioned at least [n].  These routines will use elements
+       [0 .. n-1].
+     - Adapted from the text
+       Forsythe, G.E., Malcolm, M.A. and Moler, C.B. (1977)
+       "Computer Methods for Mathematical Computations"
+       Prentice Hall
+     - Note that although there are only n-1 polynomial segments,
+       n elements are requird in b, c, d.  The elements b[n-1],
+       c[n-1] and d[n-1] are set to continue the last segment
+       past x[n-1].
+*/
+
+{ /* begin procedure spline() */
+
+    int nm1, ib, i;
+    double t;
+    int ascend;
+
+    nm1 = n - 1;
+
+    if (n < 2) { /* no possible interpolation */
+        goto LeaveSpline;
+    }
+
+    ascend = 1;
+    for (i = 1; i < n; ++i)
+        if (x[i] <= x[i - 1])
+            ascend = 0;
+    if (!ascend) {
+        goto LeaveSpline;
+    }
+
+    if (n >= 3) { /* ---- At least quadratic ---- */
+
+        /* ---- Set up the symmetric tri-diagonal system
+                b = diagonal
+                d = offdiagonal
+                c = right-hand-side  */
+        d[0] = x[1] - x[0];
+        c[1] = (y[1] - y[0]) / d[0];
+        for (i = 1; i < nm1; ++i) {
+            d[i] = x[i + 1] - x[i];
+            b[i] = 2.0 * (d[i - 1] + d[i]);
+            c[i + 1] = (y[i + 1] - y[i]) / d[i];
+            c[i] = c[i + 1] - c[i];
+        }
+
+        /* ---- Default End conditions
+                Third derivatives at x[0] and x[n-1] obtained
+                from divided differences  */
+        b[0] = -d[0];
+        b[nm1] = -d[n - 2];
+        c[0] = 0.0;
+        c[nm1] = 0.0;
+        if (n != 3) {
+            c[0] = c[2] / (x[3] - x[1]) - c[1] / (x[2] - x[0]);
+            c[nm1] = c[n - 2] / (x[nm1] - x[n - 3]) -
+                     c[n - 3] / (x[n - 2] - x[n - 4]);
+            c[0] = c[0] * d[0] * d[0] / (x[3] - x[0]);
+            c[nm1] = -c[nm1] * d[n - 2] * d[n - 2] / (x[nm1] - x[n - 4]);
+        }
+
+        /* Alternative end conditions -- known slopes */
+        if (end1 == 1) {
+            b[0] = 2.0 * (x[1] - x[0]);
+            c[0] = (y[1] - y[0]) / (x[1] - x[0]) - slope1;
+        }
+        if (end2 == 1) {
+            b[nm1] = 2.0 * (x[nm1] - x[n - 2]);
+            c[nm1] = slope2 - (y[nm1] - y[n - 2]) / (x[nm1] - x[n - 2]);
+        }
+
+        /* Forward elimination */
+        for (i = 1; i < n; ++i) {
+            t = d[i - 1] / b[i - 1];
+            b[i] = b[i] - t * d[i - 1];
+            c[i] = c[i] - t * c[i - 1];
+        }
+
+        /* Back substitution */
+        c[nm1] = c[nm1] / b[nm1];
+        for (ib = 0; ib < nm1; ++ib) {
+            i = n - ib - 2;
+            c[i] = (c[i] - d[i] * c[i + 1]) / b[i];
+        }
+
+        /* c[i] is now the sigma[i] of the text */
+
+        /* Compute the polynomial coefficients */
+        b[nm1] = (y[nm1] - y[n - 2]) / d[n - 2] +
+                 d[n - 2] * (c[n - 2] + 2.0 * c[nm1]);
+        for (i = 0; i < nm1; ++i) {
+            b[i] = (y[i + 1] - y[i]) / d[i] - d[i] * (c[i + 1] + 2.0 * c[i]);
+            d[i] = (c[i + 1] - c[i]) / d[i];
+            c[i] = 3.0 * c[i];
+        }
+        c[nm1] = 3.0 * c[nm1];
+        d[nm1] = d[n - 2];
+
+    } /* at least quadratic */
+
+    else /* if n >= 3 */
+    {    /* linear segment only  */
+        b[0] = (y[1] - y[0]) / (x[1] - x[0]);
+        c[0] = 0.0;
+        d[0] = 0.0;
+        b[1] = b[0];
+        c[1] = 0.0;
+        d[1] = 0.0;
+    }
+
+LeaveSpline:
+    return 0;
+} /* end of spline() */
+
+/**
+  @brief Evaluate the cubic spline function
+
+  S(xx) = y[i] + b[i] * w + c[i] * w**2 + d[i] * w**3
+  where w = u - x[i]
+  and   x[i] <= u <= x[i+1]
+  Note that Horner's rule is used.
+  If u < x[0]   then i = 0 is used.
+  If u > x[n-1] then i = n-1 is used.
+
+  @param[in] n The number of data points or knots (n >= 2)
+  @param[in] u the abscissa at which the spline is to be evaluated
+  @param[in] x[] the abscissas of the knots in strictly increasing order
+  @param[in] y[] the ordinates of the knots
+  @param[in] b array of spline coefficients computed by spline().
+  @param[in] c array of spline coefficients computed by spline().
+  @param[in] d array of spline coefficients computed by spline().
+
+  @return the value of the spline function at u
+
+  Notes
+    - If u is not in the same interval as the previous call then a
+      binary search is performed to determine the proper interval.
+
+*/
+
+double seval(int n, double u, double x[], double y[], double b[], double c[],
+             double d[])
+
+{ /* begin function seval() */
+
+    int i;
+    double w;
+
+    if (u <= x[0]) {
+        i = 0;
+    } else {
+        if (u >= x[n - 1]) {
+            i = n - 1;
+        } else {
+            i = 0;
+            int j = n;
+            do {
+                int k = (i + j) / 2; /* split the domain to search */
+                if (u < x[k])
+                    j = k; /* move the upper bound */
+                if (u >= x[k])
+                    i = k; /* move the lower bound */
+            }              /* there are no more segments to search */
+            while (j > i + 1);
+        }
+    }
+
+    /* ---- Evaluate the spline ---- */
+    w = u - x[i];
+    w = y[i] + w * (b[i] + w * (c[i] + w * d[i]));
+    return (w);
+}
+
+/**
+  Integrate the cubic spline function
+
+  S(xx) = y[i] + b[i] * w + c[i] * w**2 + d[i] * w**3
+  where w = u - x[i]
+  and   x[i] <= u <= x[i+1]
+
+  The integral is zero at u = x[0].
+
+  If u < x[0]   then i = 0 segment is extrapolated.
+  If u > x[n-1] then i = n-1 segment is extrapolated.
+
+  @param[in] n the number of data points or knots (n >= 2)
+  @param[in] u the abscissa at which the spline is to be evaluated
+  @param[in] x[] the abscissas of the knots in strictly increasing order
+  @param[in] y[] the ordinates of the knots
+  @param[in] b array of spline coefficients computed by spline().
+  @param[in] c array of spline coefficients computed by spline().
+  @param[in] d array of spline coefficients computed by spline().
+
+  @return the value of the spline function at u
+
+  Notes
+    - If u is not in the same interval as the previous call then a
+      binary search is performed to determine the proper interval.
+
+*/
+
+double sinteg(int n, double u, double x[], double y[], double b[], double c[],
+              double d[]) { /* begin function sinteg() */
+
+    int i, j;
+    double sum, dx;
+
+    i = 0;
+
+    if ((x[i] > u) || (x[i + 1] < u)) { /* ---- perform a binary search ---- */
+        j = n;
+        do {
+            int k = (i + j) / 2; /* split the domain to search */
+            if (u < x[k])
+                j = k; /* move the upper bound */
+            if (u >= x[k])
+                i = k; /* move the lower bound */
+        }              /* there are no more segments to search */
+        while (j > i + 1);
+    }
+
+    sum = 0.0;
+    /* ---- Evaluate the integral for segments x < u ---- */
+    for (j = 0; j < i; ++j) {
+        dx = x[j + 1] - x[j];
+        sum += dx * (y[j] +
+                     dx * (0.5 * b[j] + dx * (c[j] / 3.0 + dx * 0.25 * d[j])));
+    }
+
+    /* ---- Evaluate the integral fot this segment ---- */
+    dx = u - x[i];
+    sum +=
+        dx * (y[i] + dx * (0.5 * b[i] + dx * (c[i] / 3.0 + dx * 0.25 * d[i])));
+
+    return (sum);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/steadystateproblem.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/steadystateproblem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ea73c352a0b08e0700fd70e97b781f5e0e1148b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/steadystateproblem.cpp
@@ -0,0 +1,336 @@
+#include "amici/steadystateproblem.h"
+#include "amici/defines.h"
+#include "amici/model.h"
+#include "amici/solver.h"
+#include "amici/solver_cvodes.h"
+#include "amici/edata.h"
+#include "amici/forwardproblem.h"
+#include "amici/newton_solver.h"
+#include "amici/rdata.h"
+
+#include <cmath>
+#include <cstring>
+#include <ctime>
+#include <sundials/sundials_dense.h>
+#include <memory>
+#include <cvodes/cvodes.h>
+
+namespace amici {
+    
+SteadystateProblem::SteadystateProblem(const Solver *solver,
+                                       const AmiVector &x0):
+    t(solver->gett()), delta(solver->nx()), ewt(solver->nx()),
+    rel_x_newton(solver->nx()), x_newton(solver->nx()), x(x0),
+    x_old(solver->nx()), dx(solver->nx()), xdot(solver->nx()),
+    xdot_old(solver->nx()), sx(solver->getStateSensitivity(solver->gett())),
+    sdx(solver->nx(), solver->nplist()) {}
+
+void SteadystateProblem::workSteadyStateProblem(ReturnData *rdata,
+                                               Solver *solver, Model *model,
+                                               int it) {
+    /**
+     * Tries to determine the steady state of the ODE system by a Newton
+     * solver, uses forward intergration, if the Newton solver fails,
+     * restarts Newton solver, if integration fails.
+     * Computes steady state sensitivities
+     *
+     * @param solver pointer to the AMICI solver object
+     * @param model pointer to the AMICI model object
+     * @param it integer with the index of the current time step
+     * @param rdata pointer to the return data object
+     */
+    double run_time;
+    clock_t starttime;
+
+    /* First, try to do Newton steps */
+    starttime = clock();
+
+    auto newtonSolver = NewtonSolver::getSolver(
+        &t, &x, solver->getLinearSolver(), model, rdata,
+        solver->getNewtonMaxLinearSteps(), solver->getNewtonMaxSteps(),
+        solver->getAbsoluteTolerance(), solver->getRelativeTolerance());
+
+    auto newton_status = NewtonStatus::failed;
+    try {
+        applyNewtonsMethod(rdata, model, newtonSolver.get(),
+                           NewtonStatus::newt);
+        newton_status = NewtonStatus::newt;
+    } catch (NewtonFailure const &ex1) {
+        try {
+            /* Newton solver did not work, so try a simulation */
+            if (it < 1) /* No previous time point computed, set t = t0 */
+                t = model->t0();
+            else /* Carry on simulating from last point */
+                t = model->getTimepoint(it - 1);
+            if (it < 0) {
+                /* Preequilibration? -> Create a new CVode object for sim */
+                auto newtonSimSolver =
+                    createSteadystateSimSolver(solver, model);
+                getSteadystateSimulation(rdata, newtonSimSolver.get(), model);
+            } else {
+                /* Solver was already created, use this one */
+                getSteadystateSimulation(rdata, solver, model);
+            }
+            newton_status = NewtonStatus::newt_sim;
+        } catch (AmiException const &ex2) {
+            /* may be integration failure from AmiSolve, so NewtonFailure
+               won't do for all cases */
+            try {
+                applyNewtonsMethod(rdata, model, newtonSolver.get(),
+                                   NewtonStatus::newt_sim_newt);
+                newton_status = NewtonStatus::newt_sim_newt;
+            } catch (NewtonFailure const &ex3) {
+                if (ex3.error_code == AMICI_TOO_MUCH_WORK)
+                    throw AmiException("Steady state computation failed to "
+                                       "converge within the allowed maximum "
+                                       "number of iterations");
+                throw;
+            }
+        }
+    }
+    run_time = (double)((clock() - starttime) * 1000) / CLOCKS_PER_SEC;
+
+    /* Compute steady state sensitvities */
+
+    if (solver->getSensitivityOrder() >= SensitivityOrder::first &&
+        (newton_status == NewtonStatus::newt ||
+         newton_status == NewtonStatus::newt_sim_newt ||
+         model->getSteadyStateSensitivityMode() != SteadyStateSensitivityMode::simulationFSA))
+        // for newton_status == 2 the sensis were computed via FSA
+        newtonSolver->computeNewtonSensis(sx);
+
+    /* Get output of steady state solver, write it to x0 and reset time if necessary */
+    writeNewtonOutput(rdata, model, newton_status, run_time, it);
+}
+
+realtype SteadystateProblem::getWrmsNorm(const AmiVector &x,
+                                         const AmiVector &xdot,
+                                         realtype atol,
+                                         realtype rtol
+                                         ) {
+    N_VAbs(x.getNVector(), ewt.getNVector());
+    N_VScale(rtol, ewt.getNVector(), ewt.getNVector());
+    N_VAddConst(ewt.getNVector(), atol, ewt.getNVector());
+    N_VInv(ewt.getNVector(), ewt.getNVector());
+    return N_VWrmsNorm(xdot.getNVector(), ewt.getNVector());
+}
+
+bool SteadystateProblem::checkConvergence(
+                                         const Solver *solver,
+                                         Model *model
+                                         ) {
+    model->fxdot(t, x, dx, xdot);
+    wrms = getWrmsNorm(x, xdot, solver->getAbsoluteToleranceSteadyState(), solver->getRelativeToleranceSteadyState());
+    bool converged = wrms < RCONST(1.0);
+    if (solver->getSensitivityOrder()>SensitivityOrder::none &&
+        solver->getSensitivityMethod() == SensitivityMethod::forward) {
+        for (int ip = 0; ip < model->nplist(); ++ip) {
+            if (converged) {
+                sx = solver->getStateSensitivity(t);
+                model->fsxdot(t, x, dx, ip, sx[ip], dx, xdot);
+                wrms = getWrmsNorm(x, xdot,
+                                   solver->getAbsoluteToleranceSteadyStateSensi(),
+                                   solver->getRelativeToleranceSteadyStateSensi());
+                converged = wrms < RCONST(1.0);
+            }
+        }
+    }
+    return converged;
+}
+
+/* ------------------------------------------------------------------ */
+/* ------------------------------------------------------------------ */
+/* ------------------------------------------------------------------ */
+
+void SteadystateProblem::applyNewtonsMethod(ReturnData *rdata, Model *model,
+                                            NewtonSolver *newtonSolver,
+                                            NewtonStatus steadystate_try) {
+    int i_newtonstep = 0;
+    int ix = 0;
+    double gamma = 1.0;
+    bool compNewStep = TRUE;
+
+    /* initialize output of linear solver for Newton step */
+    delta.reset();
+
+    model->fxdot(t, x, dx,xdot);
+
+    /* Check for relative error, but make sure not to divide by 0!
+        Ensure positivity of the state */
+    x_newton = x;
+    x_old = x;
+    xdot_old = xdot;
+
+    //rdata->newton_numsteps[newton_try - 1] = 0.0;
+    wrms = getWrmsNorm(x_newton, xdot, newtonSolver->atol, newtonSolver->rtol);
+    bool converged = wrms < RCONST(1.0);
+    while (!converged && i_newtonstep < newtonSolver->maxsteps) {
+
+        /* If Newton steps are necessary, compute the inital search direction */
+        if (compNewStep) {
+            try {
+                delta = xdot;
+                newtonSolver->getStep(steadystate_try == NewtonStatus::newt ? 1
+                                                                            : 2,
+                                      i_newtonstep, delta);
+            } catch (NewtonFailure const &ex) {
+                rdata->newton_numsteps.at(steadystate_try == NewtonStatus::newt
+                                              ? 0
+                                              : 2) = i_newtonstep;
+                throw;
+            } catch (std::exception const &ex) {
+                rdata->newton_numsteps.at(steadystate_try == NewtonStatus::newt
+                                              ? 0
+                                              : 2) = i_newtonstep;
+                throw AmiException("Newton solver failed to compute new step: "
+                                   "%s", ex.what());
+            }
+        }
+
+        /* Try a full, undamped Newton step */
+        N_VLinearSum(1.0, x_old.getNVector(), gamma, delta.getNVector(),
+                     x.getNVector());
+
+        /* Compute new xdot and residuals */
+        model->fxdot(t, x, dx, xdot);
+        realtype wrms_tmp = getWrmsNorm(x_newton, xdot, newtonSolver->atol,
+                                        newtonSolver->rtol);
+
+        if (wrms_tmp < wrms) {
+            /* If new residuals are smaller than old ones, update state */
+            wrms = wrms_tmp;
+            x_old = x;
+            xdot_old = xdot;
+            /* New linear solve due to new state */
+            compNewStep = TRUE;
+            /* Check residuals vs tolerances */
+            converged = wrms < RCONST(1.0);
+
+            if (converged) {
+                /* Ensure positivity of the found state */
+                for (ix = 0; ix < model->nx_solver; ix++) {
+                    if (x[ix] < 0.0) {
+                        x[ix] = 0.0;
+                        converged = FALSE;
+                    }
+                }
+            } else {
+                /* increase dampening factor (superfluous, if converged) */
+                gamma = fmin(1.0, 2.0 * gamma);
+            }
+        } else {
+            /* Reduce dampening factor */
+            gamma = gamma / 4.0;
+            /* No new linear solve, only try new dampening */
+            compNewStep = FALSE;
+        }
+        /* increase step counter */
+        i_newtonstep++;
+    }
+
+    /* Set return values */
+    rdata->newton_numsteps.at(steadystate_try == NewtonStatus::newt ? 0 : 2) =
+        i_newtonstep;
+    if (!converged)
+        throw NewtonFailure(AMICI_TOO_MUCH_WORK, "applyNewtonsMethod");
+}
+
+/* ------------------------------------------------------------------ */
+/* ------------------------------------------------------------------ */
+/* ------------------------------------------------------------------ */
+
+void SteadystateProblem::writeNewtonOutput(ReturnData *rdata,
+                                           const Model *model,
+                                           const NewtonStatus newton_status,
+                                           const double run_time, const int it)
+{
+
+    /* Get cpu time for Newton solve in seconds */
+    rdata->newton_cpu_time = run_time / 1000;
+    rdata->newton_status = static_cast<int>(newton_status);
+    rdata->wrms_steadystate = wrms;
+    if (newton_status == NewtonStatus::newt_sim) {
+        rdata->t_steadystate = t;
+    }
+
+    /* Steady state was found: set t to t0 if preeq, otherwise to inf */
+    if (it == AMICI_PREEQUILIBRATE) {
+        t = model->t0();
+    } else {
+        t = INFINITY;
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* ------------------------------------------------------------------ */
+/* ------------------------------------------------------------------ */
+
+void SteadystateProblem::getSteadystateSimulation(ReturnData *rdata,
+                                                  Solver *solver,
+                                                  Model *model)
+{
+    /* Loop over steps and check for convergence */
+    bool converged = checkConvergence(solver, model);
+
+    int steps_newton = 0;
+    while(!converged) {
+        /* One step of ODE integration
+         reason for tout specification:
+         max with 1 ensures correct direction (any positive value would do)
+         multiplication with 10 ensures nonzero difference and should ensure stable computation
+         value is not important for AMICI_ONE_STEP mode, only direction w.r.t. current t
+         */
+        solver->step(std::max(t, 1.0) * 10);
+        solver->writeSolution(&t, x, dx, sx);
+
+        /* Check for convergence */
+        converged = checkConvergence(solver, model);
+        /* increase counter, check for maxsteps */
+        steps_newton++;
+        if (steps_newton >= solver->getMaxSteps() && !converged) {
+            rdata->newton_numsteps.at(static_cast<int>(NewtonStatus::newt_sim) - 1) =
+                steps_newton;
+            throw NewtonFailure(AMICI_TOO_MUCH_WORK, "exceeded maximum number of steps");
+        }
+    }
+    rdata->newton_numsteps.at(static_cast<int>(NewtonStatus::newt_sim) - 1) =
+        steps_newton;
+    if (solver->getSensitivityOrder()>SensitivityOrder::none)
+        sx = solver->getStateSensitivity(t);
+}
+
+std::unique_ptr<Solver> SteadystateProblem::createSteadystateSimSolver(
+        const Solver *solver, Model *model) const
+{
+    /* Create new CVode solver object */
+
+    auto newton_solver = std::unique_ptr<Solver>(solver->clone());
+
+    switch(solver->getLinearSolver()) {
+        case LinearSolver::dense:
+        case LinearSolver::KLU:
+        case LinearSolver::SuperLUMT:
+            break;
+        default:
+            throw NewtonFailure(AMICI_NOT_IMPLEMENTED, "invalid solver for steadystate simulation");
+    }
+    if (solver->getSensitivityMethod() != SensitivityMethod::none
+        && model->getSteadyStateSensitivityMode() == SteadyStateSensitivityMode::simulationFSA)
+        newton_solver->setSensitivityMethod(SensitivityMethod::forward); //need forward to compute sx0
+    else
+        newton_solver->setSensitivityMethod(SensitivityMethod::none);
+
+    // use x and sx as dummies for dx and sdx (they wont get touched in a CVodeSolver)
+    newton_solver->setup(model->t0(), model, x, x, sx, sx);
+
+    return newton_solver;
+}
+    
+void SteadystateProblem::writeSolution(realtype *t, AmiVector &x,
+                                       AmiVectorArray &sx) const {
+    *t = this->t;
+    x.copy(this->x);
+    sx.copy(this->sx);
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/sundials_linsol_wrapper.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/sundials_linsol_wrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84ace7e0a9ed7cbba346adf98051f1c2bf25bdb2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/sundials_linsol_wrapper.cpp
@@ -0,0 +1,424 @@
+#include <amici/sundials_linsol_wrapper.h>
+
+#include <amici/exception.h>
+
+#include <new> // bad_alloc
+#include <utility>
+
+namespace amici {
+
+SUNLinSolWrapper::SUNLinSolWrapper(SUNLinearSolver linsol) : solver(linsol) {}
+
+SUNLinSolWrapper::~SUNLinSolWrapper() {
+    if (solver)
+        SUNLinSolFree(solver);
+}
+
+SUNLinSolWrapper::SUNLinSolWrapper(SUNLinSolWrapper &&other) noexcept {
+    std::swap(solver, other.solver);
+}
+
+SUNLinearSolver SUNLinSolWrapper::get() const { return solver; }
+
+SUNLinearSolver_Type SUNLinSolWrapper::getType() const {
+    return SUNLinSolGetType(solver);
+}
+
+int SUNLinSolWrapper::initialize() {
+    auto res = SUNLinSolInitialize(solver);
+    if (res != SUNLS_SUCCESS)
+        throw AmiException("Solver initialization failed with code %d", res);
+    return res;
+}
+
+void SUNLinSolWrapper::setup(SUNMatrix A) const {
+    auto res = SUNLinSolSetup(solver, A);
+    if (res != SUNLS_SUCCESS)
+        throw AmiException("Solver setup failed with code %d", res);
+}
+
+void SUNLinSolWrapper::setup(const SUNMatrixWrapper& A) const { return setup(A.get()); }
+
+int SUNLinSolWrapper::Solve(SUNMatrix A, N_Vector x, N_Vector b, realtype tol) const {
+    return SUNLinSolSolve(solver, A, x, b, tol);
+}
+
+long SUNLinSolWrapper::getLastFlag() const { return SUNLinSolLastFlag(solver); }
+
+int SUNLinSolWrapper::space(long *lenrwLS, long *leniwLS) const {
+    return SUNLinSolSpace(solver, lenrwLS, leniwLS);
+}
+
+SUNMatrix SUNLinSolWrapper::getMatrix() const { return nullptr; }
+
+SUNNonLinSolWrapper::SUNNonLinSolWrapper(SUNNonlinearSolver sol)
+    : solver(sol) {}
+
+SUNNonLinSolWrapper::~SUNNonLinSolWrapper() {
+    if (solver)
+        SUNNonlinSolFree(solver);
+}
+
+SUNNonLinSolWrapper::SUNNonLinSolWrapper(SUNNonLinSolWrapper &&other) noexcept {
+    std::swap(solver, other.solver);
+}
+
+SUNNonLinSolWrapper &SUNNonLinSolWrapper::
+operator=(SUNNonLinSolWrapper &&other) noexcept {
+    std::swap(solver, other.solver);
+    return *this;
+}
+
+SUNNonlinearSolver SUNNonLinSolWrapper::get() const { return solver; }
+
+SUNNonlinearSolver_Type SUNNonLinSolWrapper::getType() const {
+    return SUNNonlinSolGetType(solver);
+}
+
+int SUNNonLinSolWrapper::setup(N_Vector y, void *mem) {
+    auto res = SUNNonlinSolSetup(solver, y, mem);
+    if (res != SUN_NLS_SUCCESS)
+        throw AmiException("Nonlinear solver setup failed with code %d", res);
+    return res;
+}
+
+int SUNNonLinSolWrapper::Solve(N_Vector y0, N_Vector y, N_Vector w,
+                               realtype tol, int callLSetup, void *mem) {
+    return SUNNonlinSolSolve(solver, y0, y, w, tol, callLSetup, mem);
+}
+
+int SUNNonLinSolWrapper::setSysFn(SUNNonlinSolSysFn SysFn) {
+    return SUNNonlinSolSetSysFn(solver, SysFn);
+}
+
+int SUNNonLinSolWrapper::setLSetupFn(SUNNonlinSolLSetupFn SetupFn) {
+    return SUNNonlinSolSetLSetupFn(solver, SetupFn);
+}
+
+int SUNNonLinSolWrapper::setLSolveFn(SUNNonlinSolLSolveFn SolveFn) {
+    return SUNNonlinSolSetLSolveFn(solver, SolveFn);
+}
+
+int SUNNonLinSolWrapper::setConvTestFn(SUNNonlinSolConvTestFn CTestFn) {
+    return SUNNonlinSolSetConvTestFn(solver, CTestFn);
+}
+
+int SUNNonLinSolWrapper::setMaxIters(int maxiters) {
+    return SUNNonlinSolSetMaxIters(solver, maxiters);
+}
+
+long SUNNonLinSolWrapper::getNumIters() const {
+    long int niters = -1;
+    auto res = SUNNonlinSolGetNumIters(solver, &niters);
+    if (res != SUN_NLS_SUCCESS) {
+        throw AmiException("SUNNonlinSolGetNumIters failed with code %d", res);
+    }
+    return niters;
+}
+
+int SUNNonLinSolWrapper::getCurIter() const {
+    int iter = -1;
+    auto res = SUNNonlinSolGetCurIter(solver, &iter);
+    if (res != SUN_NLS_SUCCESS) {
+        throw AmiException("SUNNonlinSolGetCurIter failed with code %d", res);
+    }
+    return iter;
+}
+
+long SUNNonLinSolWrapper::getNumConvFails() const {
+    long int nconvfails = -1;
+    auto res = SUNNonlinSolGetNumConvFails(solver, &nconvfails);
+    if (res != SUN_NLS_SUCCESS) {
+        throw AmiException("SUNNonlinSolGetNumConvFails failed with code %d",
+                           res);
+    }
+    return nconvfails;
+}
+
+void SUNNonLinSolWrapper::initialize() {
+    int status = SUNNonlinSolInitialize(solver);
+    if (status != SUN_NLS_SUCCESS)
+        throw AmiException(
+            "Nonlinear solver initialization failed with code %d", status);
+}
+
+SUNLinSolBand::SUNLinSolBand(N_Vector x, SUNMatrix A)
+    : SUNLinSolWrapper(SUNLinSol_Band(x, A)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+SUNLinSolBand::SUNLinSolBand(const AmiVector &x, int ubw, int lbw) :
+    A(SUNMatrixWrapper(x.getLength(), ubw, lbw)) {
+    solver = SUNLinSol_Band(x.getNVector(), A.get());
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+
+}
+
+SUNMatrix SUNLinSolBand::getMatrix() const { return A.get(); }
+
+SUNLinSolDense::SUNLinSolDense(const AmiVector &x) :
+    A(SUNMatrixWrapper(x.getLength(), x.getLength())) {
+    solver = SUNLinSol_Dense(x.getNVector(), A.get());
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+SUNMatrix SUNLinSolDense::getMatrix() const { return A.get(); }
+
+SUNLinSolKLU::SUNLinSolKLU(N_Vector x, SUNMatrix A)
+    : SUNLinSolWrapper(SUNLinSol_KLU(x, A)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+SUNLinSolKLU::SUNLinSolKLU(const AmiVector &x, int nnz, int sparsetype,
+                           StateOrdering ordering) :
+      A(SUNMatrixWrapper(x.getLength(), x.getLength(), nnz, sparsetype)) {
+    solver = SUNLinSol_KLU(x.getNVector(), A.get());
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+
+    setOrdering(ordering);
+}
+
+SUNMatrix SUNLinSolKLU::getMatrix() const { return A.get(); }
+
+void SUNLinSolKLU::reInit(int nnz, int reinit_type) {
+    int status = SUNLinSol_KLUReInit(solver, A.get(), nnz, reinit_type);
+    if (status != SUNLS_SUCCESS)
+        throw AmiException("SUNLinSol_KLUReInit failed with %d", status);
+}
+
+void SUNLinSolKLU::setOrdering(StateOrdering ordering) {
+    auto status = SUNLinSol_KLUSetOrdering(solver, static_cast<int>(ordering));
+    if (status != SUNLS_SUCCESS)
+        throw AmiException("SUNLinSol_KLUSetOrdering failed with %d", status);
+}
+
+SUNLinSolPCG::SUNLinSolPCG(N_Vector y, int pretype, int maxl)
+    : SUNLinSolWrapper(SUNLinSol_PCG(y, pretype, maxl)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+int SUNLinSolPCG::setATimes(void *A_data, ATimesFn ATimes) {
+    return SUNLinSolSetATimes_PCG(solver, A_data, ATimes);
+}
+
+int SUNLinSolPCG::setPreconditioner(void *P_data, PSetupFn Pset,
+                                    PSolveFn Psol) {
+    return SUNLinSolSetPreconditioner_PCG(solver, P_data, Pset, Psol);
+}
+
+int SUNLinSolPCG::setScalingVectors(N_Vector s, N_Vector nul) {
+    return SUNLinSolSetScalingVectors_PCG(solver, s, nul);
+}
+
+int SUNLinSolPCG::getNumIters() const { return SUNLinSolNumIters_PCG(solver); }
+
+realtype SUNLinSolPCG::getResNorm() const { return SUNLinSolResNorm_PCG(solver); }
+
+N_Vector SUNLinSolPCG::getResid() const { return SUNLinSolResid_PCG(solver); }
+
+SUNLinSolSPBCGS::SUNLinSolSPBCGS(N_Vector x, int pretype, int maxl)
+    : SUNLinSolWrapper(SUNLinSol_SPBCGS(x, pretype, maxl)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+SUNLinSolSPBCGS::SUNLinSolSPBCGS(const AmiVector &x, int pretype, int maxl) {
+    solver = SUNLinSol_SPBCGS(x.getNVector(), pretype, maxl);
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+int SUNLinSolSPBCGS::setATimes(void *A_data, ATimesFn ATimes) {
+    return SUNLinSolSetATimes_SPBCGS(solver, A_data, ATimes);
+}
+
+int SUNLinSolSPBCGS::setPreconditioner(void *P_data, PSetupFn Pset,
+                                       PSolveFn Psol) {
+    return SUNLinSolSetPreconditioner_SPBCGS(solver, P_data, Pset, Psol);
+}
+
+int SUNLinSolSPBCGS::setScalingVectors(N_Vector s, N_Vector nul) {
+    return SUNLinSolSetScalingVectors_SPBCGS(solver, s, nul);
+}
+
+int SUNLinSolSPBCGS::getNumIters() const { return SUNLinSolNumIters_SPBCGS(solver); }
+
+realtype SUNLinSolSPBCGS::getResNorm() const {
+    return SUNLinSolResNorm_SPBCGS(solver);
+}
+
+N_Vector SUNLinSolSPBCGS::getResid() const { return SUNLinSolResid_SPBCGS(solver); }
+
+SUNLinSolSPFGMR::SUNLinSolSPFGMR(const AmiVector &x, int pretype, int maxl)
+    : SUNLinSolWrapper(SUNLinSol_SPFGMR(x.getNVector(), pretype, maxl)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+int SUNLinSolSPFGMR::setATimes(void *A_data, ATimesFn ATimes) {
+    return SUNLinSolSetATimes_SPFGMR(solver, A_data, ATimes);
+}
+
+int SUNLinSolSPFGMR::setPreconditioner(void *P_data, PSetupFn Pset,
+                                       PSolveFn Psol) {
+    return SUNLinSolSetPreconditioner_SPFGMR(solver, P_data, Pset, Psol);
+}
+
+int SUNLinSolSPFGMR::setScalingVectors(N_Vector s, N_Vector nul) {
+    return SUNLinSolSetScalingVectors_SPFGMR(solver, s, nul);
+}
+
+int SUNLinSolSPFGMR::getNumIters() const { return SUNLinSolNumIters_SPFGMR(solver); }
+
+realtype SUNLinSolSPFGMR::getResNorm() const {
+    return SUNLinSolResNorm_SPFGMR(solver);
+}
+
+N_Vector SUNLinSolSPFGMR::getResid() const { return SUNLinSolResid_SPFGMR(solver); }
+
+SUNLinSolSPGMR::SUNLinSolSPGMR(const AmiVector &x, int pretype, int maxl)
+    : SUNLinSolWrapper(SUNLinSol_SPGMR(x.getNVector(), pretype, maxl)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+int SUNLinSolSPGMR::setATimes(void *A_data, ATimesFn ATimes) {
+    return SUNLinSolSetATimes_SPGMR(solver, A_data, ATimes);
+}
+
+int SUNLinSolSPGMR::setPreconditioner(void *P_data, PSetupFn Pset,
+                                      PSolveFn Psol) {
+    return SUNLinSolSetPreconditioner_SPGMR(solver, P_data, Pset, Psol);
+}
+
+int SUNLinSolSPGMR::setScalingVectors(N_Vector s, N_Vector nul) {
+    return SUNLinSolSetScalingVectors_SPGMR(solver, s, nul);
+}
+
+int SUNLinSolSPGMR::getNumIters() const { return SUNLinSolNumIters_SPGMR(solver); }
+
+realtype SUNLinSolSPGMR::getResNorm() const { return SUNLinSolResNorm_SPGMR(solver); }
+
+N_Vector SUNLinSolSPGMR::getResid() const { return SUNLinSolResid_SPGMR(solver); }
+
+SUNLinSolSPTFQMR::SUNLinSolSPTFQMR(N_Vector x, int pretype, int maxl)
+    : SUNLinSolWrapper(SUNLinSol_SPTFQMR(x, pretype, maxl)) {
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+SUNLinSolSPTFQMR::SUNLinSolSPTFQMR(const AmiVector &x, int pretype, int maxl) {
+    solver = SUNLinSol_SPTFQMR(x.getNVector(), pretype, maxl);
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+int SUNLinSolSPTFQMR::setATimes(void *A_data, ATimesFn ATimes) {
+    return SUNLinSolSetATimes_SPTFQMR(solver, A_data, ATimes);
+}
+
+int SUNLinSolSPTFQMR::setPreconditioner(void *P_data, PSetupFn Pset,
+                                        PSolveFn Psol) {
+    return SUNLinSolSetPreconditioner_SPTFQMR(solver, P_data, Pset, Psol);
+}
+
+int SUNLinSolSPTFQMR::setScalingVectors(N_Vector s, N_Vector nul) {
+    return SUNLinSolSetScalingVectors_SPTFQMR(solver, s, nul);
+}
+
+int SUNLinSolSPTFQMR::getNumIters() const {
+    return SUNLinSolNumIters_SPTFQMR(solver);
+}
+
+realtype SUNLinSolSPTFQMR::getResNorm() const {
+    return SUNLinSolResNorm_SPTFQMR(solver);
+}
+
+N_Vector SUNLinSolSPTFQMR::getResid() const { return SUNLinSolResid_SPTFQMR(solver); }
+
+SUNNonLinSolNewton::SUNNonLinSolNewton(N_Vector x)
+    : SUNNonLinSolWrapper(SUNNonlinSol_Newton(x)) {
+}
+
+SUNNonLinSolNewton::SUNNonLinSolNewton(int count, N_Vector x)
+    : SUNNonLinSolWrapper(SUNNonlinSol_NewtonSens(count, x)) {
+    if (!solver)
+        throw(AmiException("SUNNonlinSol_NewtonSens failed"));
+}
+
+int SUNNonLinSolNewton::getSysFn(SUNNonlinSolSysFn *SysFn) const {
+    return SUNNonlinSolGetSysFn_Newton(solver, SysFn);
+}
+
+SUNNonLinSolFixedPoint::SUNNonLinSolFixedPoint(const_N_Vector x, int m)
+    : SUNNonLinSolWrapper(SUNNonlinSol_FixedPoint(x, m)) {
+}
+
+SUNNonLinSolFixedPoint::SUNNonLinSolFixedPoint(int count, const_N_Vector x, int m)
+    : SUNNonLinSolWrapper(SUNNonlinSol_FixedPointSens(count, x, m)) {
+}
+
+int SUNNonLinSolFixedPoint::getSysFn(SUNNonlinSolSysFn *SysFn) const {
+    return SUNNonlinSolGetSysFn_FixedPoint(solver, SysFn);
+}
+
+#ifdef SUNDIALS_SUPERLUMT
+
+SUNLinSolSuperLUMT::SUNLinSolSuperLUMT(N_Vector x, SUNMatrix A, int numThreads)
+    : SUNLinSolWrapper(SUNLinSol_SuperLUMT(x, A, numThreads))
+{
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+}
+
+SUNLinSolSuperLUMT::SUNLinSolSuperLUMT(
+        const AmiVector &x, int nnz, int sparsetype,
+        SUNLinSolSuperLUMT::StateOrdering ordering)
+    : A(SUNMatrixWrapper(x.getLength(), x.getLength(), nnz, sparsetype))
+{
+    int numThreads = 1;
+    if(auto env = std::getenv("AMICI_SUPERLUMT_NUM_THREADS")) {
+        numThreads = std::max(1, std::stoi(env));
+    }
+
+    solver = SUNLinSol_SuperLUMT(x.getNVector(), A.get(), numThreads);
+    if (!solver)
+        throw AmiException("Failed to create solver.");
+
+    setOrdering(ordering);
+}
+
+SUNLinSolSuperLUMT::SUNLinSolSuperLUMT(const AmiVector &x, int nnz,
+                                       int sparsetype, StateOrdering ordering,
+                                       int numThreads)
+    : A(SUNMatrixWrapper(x.getLength(), x.getLength(), nnz, sparsetype))
+{
+  solver = SUNLinSol_SuperLUMT(x.getNVector(), A.get(), numThreads);
+  if (!solver)
+      throw AmiException("Failed to create solver.");
+
+  setOrdering(ordering);
+}
+
+SUNMatrix SUNLinSolSuperLUMT::getMatrix() const
+{
+    return A.get();
+}
+
+
+void SUNLinSolSuperLUMT::setOrdering(StateOrdering ordering)
+{
+    auto status = SUNLinSol_SuperLUMTSetOrdering(solver, static_cast<int>(ordering));
+    if (status != SUNLS_SUCCESS)
+        throw AmiException("SUNLinSol_SuperLUMTSetOrdering failed with %d", status);
+}
+
+#endif
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/sundials_matrix_wrapper.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/sundials_matrix_wrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd107c5efa9c6906d92cfc0935c932826b2ac005
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/sundials_matrix_wrapper.cpp
@@ -0,0 +1,255 @@
+#include <amici/sundials_matrix_wrapper.h>
+
+#include <amici/cblas.h>
+
+#include <new> // bad_alloc
+#include <utility>
+#include <stdexcept> // invalid_argument and domain_error
+
+namespace amici {
+
+SUNMatrixWrapper::SUNMatrixWrapper(int M, int N, int NNZ, int sparsetype)
+    : matrix(SUNSparseMatrix(M, N, NNZ, sparsetype)) {
+
+    if (sparsetype != CSC_MAT && sparsetype != CSR_MAT)
+        throw std::invalid_argument("Invalid sparsetype. Must be CSC_MAT or "
+                                    "CSR_MAT");
+
+    if (NNZ && !matrix)
+        throw std::bad_alloc();
+
+    update_ptrs();
+}
+
+SUNMatrixWrapper::SUNMatrixWrapper(int M, int N)
+    : matrix(SUNDenseMatrix(M, N)) {
+    if (M && N && !matrix)
+        throw std::bad_alloc();
+
+    update_ptrs();
+}
+
+SUNMatrixWrapper::SUNMatrixWrapper(int M, int ubw, int lbw)
+    : matrix(SUNBandMatrix(M, ubw, lbw)) {
+    if (M && !matrix)
+        throw std::bad_alloc();
+
+    update_ptrs();
+}
+
+SUNMatrixWrapper::SUNMatrixWrapper(const SUNMatrixWrapper &A, realtype droptol,
+                                   int sparsetype) {
+    if (sparsetype != CSC_MAT && sparsetype != CSR_MAT)
+        throw std::invalid_argument("Invalid sparsetype. Must be CSC_MAT or "
+                                    "CSR_MAT");
+
+    switch (SUNMatGetID(A.get())) {
+    case SUNMATRIX_DENSE:
+        matrix = SUNSparseFromDenseMatrix(A.get(), droptol, sparsetype);
+        break;
+    case SUNMATRIX_BAND:
+        matrix = SUNSparseFromBandMatrix(A.get(), droptol, sparsetype);
+        break;
+    default:
+        throw std::invalid_argument("Invalid Matrix. Must be SUNMATRIX_DENSE or"
+                                    " SUNMATRIX_BAND");
+    }
+
+    if (!matrix)
+        throw std::bad_alloc();
+
+    update_ptrs();
+}
+
+SUNMatrixWrapper::SUNMatrixWrapper(SUNMatrix mat) : matrix(mat) {
+    update_ptrs();
+}
+
+SUNMatrixWrapper::~SUNMatrixWrapper() {
+    if (matrix)
+        SUNMatDestroy(matrix);
+}
+
+SUNMatrixWrapper::SUNMatrixWrapper(const SUNMatrixWrapper &other) {
+    if (!other.matrix)
+        return;
+
+    matrix = SUNMatClone(other.matrix);
+    if (!matrix)
+        throw std::bad_alloc();
+
+    SUNMatCopy(other.matrix, matrix);
+    update_ptrs();
+}
+
+SUNMatrixWrapper::SUNMatrixWrapper(SUNMatrixWrapper &&other) {
+    std::swap(matrix, other.matrix);
+    update_ptrs();
+}
+
+SUNMatrixWrapper &SUNMatrixWrapper::operator=(const SUNMatrixWrapper &other) {
+    if(&other == this)
+        return *this;
+    return *this = SUNMatrixWrapper(other);
+}
+
+SUNMatrixWrapper &SUNMatrixWrapper::
+operator=(SUNMatrixWrapper &&other) {
+    std::swap(matrix, other.matrix);
+    update_ptrs();
+    return *this;
+}
+
+realtype *SUNMatrixWrapper::data() const {
+    return data_ptr;
+}
+
+sunindextype SUNMatrixWrapper::rows() const {
+    if (!matrix)
+        return 0;
+
+    switch (SUNMatGetID(matrix)) {
+    case SUNMATRIX_DENSE:
+        return SM_ROWS_D(matrix);
+    case SUNMATRIX_SPARSE:
+        return SM_ROWS_S(matrix);
+    case SUNMATRIX_BAND:
+        return SM_ROWS_B(matrix);
+    case SUNMATRIX_CUSTOM:
+        throw std::domain_error("Amici currently does not support custom matrix"
+                                " types.");
+    default:
+        throw std::domain_error("Invalid SUNMatrix type.");
+    }
+}
+
+sunindextype SUNMatrixWrapper::columns() const {
+    if (!matrix)
+        return 0;
+
+    switch (SUNMatGetID(matrix)) {
+    case SUNMATRIX_DENSE:
+        return SM_COLUMNS_D(matrix);
+    case SUNMATRIX_SPARSE:
+        return SM_COLUMNS_S(matrix);
+    case SUNMATRIX_BAND:
+        return SM_COLUMNS_B(matrix);
+    case SUNMATRIX_CUSTOM:
+        throw std::domain_error("Amici currently does not support custom matrix"
+                                " types.");
+    default:
+        throw std::domain_error("Invalid SUNMatrix type.");
+    }
+}
+
+sunindextype *SUNMatrixWrapper::indexvals() const {
+    return indexvals_ptr;
+}
+
+sunindextype *SUNMatrixWrapper::indexptrs() const {
+    return indexptrs_ptr;
+}
+
+int SUNMatrixWrapper::sparsetype() const {
+    if (SUNMatGetID(matrix) == SUNMATRIX_SPARSE)
+        return SM_SPARSETYPE_S(matrix);
+    throw std::domain_error("Function only available for sparse matrices");
+}
+
+void SUNMatrixWrapper::reset() {
+    if (matrix)
+        SUNMatZero(matrix);
+}
+
+void SUNMatrixWrapper::multiply(N_Vector c, const_N_Vector b) const {
+    multiply(gsl::make_span<realtype>(NV_DATA_S(c), NV_LENGTH_S(c)),
+             gsl::make_span<const realtype>(NV_DATA_S(b), NV_LENGTH_S(b)));
+}
+
+void SUNMatrixWrapper::multiply(gsl::span<realtype> c, gsl::span<const realtype> b) const {
+    if (!matrix)
+        return;
+
+    if (static_cast<sunindextype>(c.size()) != rows())
+        throw std::invalid_argument("Dimension mismatch between number of rows "
+                                    "in A (" + std::to_string(rows()) + ") and "
+                                    "elements in c (" + std::to_string(c.size())
+                                    + ")");
+
+    if (static_cast<sunindextype>(b.size()) != columns())
+        throw std::invalid_argument("Dimension mismatch between number of cols "
+                                    "in A (" + std::to_string(columns())
+                                    + ") and elements in b ("
+                                    + std::to_string(b.size()) + ")");
+
+    switch (SUNMatGetID(matrix)) {
+    case SUNMATRIX_DENSE:
+        amici_dgemv(BLASLayout::colMajor, BLASTranspose::noTrans, rows(),
+                    columns(), 1.0, data(), rows(), b.data(), 1, 1.0, c.data(), 1);
+        break;
+    case SUNMATRIX_SPARSE:
+
+        switch (sparsetype()) {
+        case CSC_MAT:
+            for (sunindextype i = 0; i < columns(); ++i) {
+                for (sunindextype k = indexptrs_ptr[i]; k < indexptrs_ptr[i + 1];
+                     ++k) {
+                    c[indexvals_ptr[k]] += data_ptr[k] * b[i];
+                }
+            }
+            break;
+        case CSR_MAT:
+            for (sunindextype i = 0; i < rows(); ++i) {
+                for (sunindextype k = indexptrs_ptr[i]; k < indexptrs_ptr[i + 1];
+                     ++k) {
+                    c[i] += data_ptr[k] * b[indexvals_ptr[k]];
+                }
+            }
+            break;
+        }
+        break;
+    case SUNMATRIX_BAND:
+        throw std::domain_error("Not Implemented.");
+    case SUNMATRIX_CUSTOM:
+        throw std::domain_error("Amici currently does not support custom"
+                                " matrix types.");
+    }
+}
+
+void SUNMatrixWrapper::zero()
+{
+    if(int res = SUNMatZero(matrix))
+        throw std::runtime_error("SUNMatrixWrapper::zero() failed with "
+                                 + std::to_string(res));
+}
+
+void SUNMatrixWrapper::update_ptrs() {
+    if(!matrix)
+        return;
+
+    switch (SUNMatGetID(matrix)) {
+    case SUNMATRIX_DENSE:
+        if (columns() > 0 && rows() > 0)
+            data_ptr = SM_DATA_D(matrix);
+        break;
+    case SUNMATRIX_SPARSE:
+        if (SM_NNZ_S(matrix) > 0) {
+            data_ptr = SM_DATA_S(matrix);
+            indexptrs_ptr = SM_INDEXPTRS_S(matrix);
+            indexvals_ptr = SM_INDEXVALS_S(matrix);
+        }
+        break;
+    case SUNMATRIX_BAND:
+        if (columns() > 0 && rows() > 0)
+            data_ptr = SM_DATA_B(matrix);
+        break;
+    case SUNMATRIX_CUSTOM:
+        throw std::domain_error("Amici currently does not support"
+                                "custom matrix types.");
+    }
+}
+
+SUNMatrix SUNMatrixWrapper::get() const { return matrix; }
+
+} // namespace amici
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/symbolic_functions.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/symbolic_functions.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10fdbcd2d6aa13a07aef1ccbb3ea54cad0a17bf1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/symbolic_functions.cpp
@@ -0,0 +1,523 @@
+/**
+ * @file   symbolic_functions.cpp
+ * @brief  definition of symbolic functions
+ *
+ * This file contains definitions of various symbolic functions which
+ */
+
+#include "amici/symbolic_functions.h"
+#include "amici/spline.h"
+
+#include <algorithm>
+#include <cfloat>
+#include <cmath>
+#include <cstdarg>
+#include <cstdlib>
+#if _MSC_VER && !__INTEL_COMPILER
+#include <malloc.h>
+#define alloca _alloca
+#elif defined(WIN32) || defined(__WIN32) || defined(__WIN32__)
+// For alloca().
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+
+namespace amici {
+
+/**
+ * c++ interface to the isNaN function
+ *
+ * @param what argument
+ * @return isnan(what)
+ *
+ */
+int isNaN(double what) { return std::isnan(what); }
+
+/**
+ * c++ interface to the isinf function
+ *
+ * @param what argument
+ * @return isnan(what)
+ *
+ */
+int isInf(double what) { return std::isinf(what); }
+
+/**
+ * function returning nan
+ *
+ * @return NaN
+ *
+ */
+double getNaN() { return NAN; }
+
+/**
+ * C implementation of log function, this prevents returning NaN values for
+ * negative values
+ *
+ * @param x argument
+ * @return if(x>0) then log(x) else -Inf
+ *
+ */
+double log(double x) {
+    if (x <= 0) {
+        return -std::log(DBL_MAX);
+    }
+    return std::log(x);
+}
+
+/**
+ * C implementation of matlab function dirac
+ *
+ * @param x argument
+ * @return if(x==0) then INF else 0
+ *
+ */
+double dirac(double x) {
+    if (x == 0.0) {
+        return DBL_MAX;
+    }
+    return 0.0;
+}
+
+/**
+ * c implementation of matlab function heaviside
+ *
+ * @param x argument
+ * @return if(x>0) then 1 else 0
+ *
+ */
+double heaviside(double x) {
+    if (x <= 0.0) {
+        return 0.0;
+    }
+    return 1.0;
+}
+
+/**
+ *  c implementation of matlab function sign
+ *
+ * @param x argument
+ * @return 0
+ *
+ */
+double sign(double x) {
+    if (x > 0.0)
+        return 1.0;
+
+    if (x < 0.0)
+        return -1.0;
+
+    return 0.0;
+}
+
+/**
+ * c implementation of matlab function max
+ *
+ * @param a value1
+ * @param b value2
+ * @return if(a > b) then a else b
+ *
+ */
+double max(double a, double b, double  /*c*/) {
+    int anan = isNaN(a), bnan = isNaN(b);
+    if (anan || bnan) {
+        if (anan && !bnan)
+            return b;
+        if (!anan && bnan)
+            return a;
+        return a;
+    }
+    return (std::max(a, b));
+}
+
+/**
+ * c implementation of matlab function min
+ *
+ * @param a value1
+ * @param b value2
+ * @param c bogus parameter to ensure correct parsing as a function
+ * @return if(a < b) then a else b
+ *
+ */
+double min(double a, double b, double c) {
+    return (-max(-a,-b,c));
+}
+
+/**
+ * parameter derivative of c implementation of matlab function max
+ *
+ * @param id argument index for differentiation
+ * @param a value1
+ * @param b value2
+ * @return id == 1:  if(a > b) then 1 else 0
+ * @return id == 2:  if(a > b) then 0 else 1
+ *
+ */
+double Dmax(int id, double a, double b, double  /*c*/) {
+    if (id == 1.0) {
+        if (a > b)
+            return 1.0;
+        return 0.0;
+    }
+    if (a > b) {
+        return 0.0;
+    }
+    return 1.0;
+}
+
+/**
+ * parameter derivative of c implementation of matlab function max
+ *
+ * @param id argument index for differentiation
+ * @param a value1
+ * @param b value2
+ * @param c bogus parameter to ensure correct parsing as a function
+ * @return id == 1:  if(a > b) then 1 else 0
+ * @return id == 2:  if(a > b) then 0 else 1
+ *
+ */
+double Dmin(int id, double a, double b, double c) {
+    return Dmax(id,-a,-b,c);
+}
+
+/**
+ * specialized pow functions that assumes positivity of the first argument
+ *
+ * @param base base
+ * @param exponent exponent
+ * @return pow(max(base,0.0),exponen)
+ *
+ */
+double pos_pow(double base, double exponent) {
+    // we do NOT want to propagate NaN values here, if base is nan, so should the output be
+    return pow(std::max(base, 0.0),exponent);
+}
+
+/**
+ * @brief Spline function
+ *
+ * Takes variable argument pairs (ti,pi) with `ti`: location of node i and
+ * `pi`: spline value at node i. the last two arguments are always `ss`: flag
+ * indicating whether slope at first node should be user defined
+ * and `dudt` user defined slope at first node. All arguments must be of type
+ * double.
+ *
+ * @param t point at which the spline should be evaluated
+ * @param num number of spline nodes
+ *
+ * @return spline(t)
+ *
+ */
+double spline(double t, int num, ...) {
+
+    va_list valist;
+
+    double uout;
+    double ss;
+    double dudt;
+
+    auto *ts = (double *)alloca(num * sizeof(double));
+    auto *us = (double *)alloca(num * sizeof(double));
+
+    auto *b = (double *)alloca(num * sizeof(double));
+    auto *c = (double *)alloca(num * sizeof(double));
+    auto *d = (double *)alloca(num * sizeof(double));
+
+    /* Variable list type macro */
+    /* initialize valist for num number of arguments */
+    va_start(valist, num);
+
+    for (int i = 0; i < 2 * num; i += 2) {
+        int j = i / 2;
+        ts[j] = va_arg(valist, double);
+        us[j] = va_arg(valist, double);
+    }
+    ss = va_arg(valist, double);
+    dudt = va_arg(valist, double);
+
+    /* clean memory reserved for valist */
+    va_end(valist);
+
+    spline(num, ss, 0, dudt, 0.0, ts, us, b, c, d);
+    uout = seval(num, t, ts, us, b, c, d);
+
+    return uout;
+}
+
+/**
+ * @brief Exponentiated spline function
+ *
+ * Takes variable argument pairs (ti,pi) with `ti`: location of node i and
+ * `pi`: spline value at node i. the last two arguments are always `ss`: flag
+ * indicating whether slope at first node should be user defined
+ * and `dudt` user defined slope at first node. All arguments must be of type
+ * double.
+ *
+ * @param t point at which the spline should be evaluated
+ * @param num number of spline nodes
+ *
+ * @return spline(t)
+ *
+ */
+double spline_pos(double t, int num, ...) {
+
+    va_list valist;
+
+    double uout;
+    double ss;
+    double dudt;
+
+    auto *ts = (double *)alloca(num * sizeof(double));
+    auto *us = (double *)alloca(num * sizeof(double));
+    auto *uslog = (double *)alloca(num * sizeof(double));
+
+    auto *b = (double *)alloca(num * sizeof(double));
+    auto *c = (double *)alloca(num * sizeof(double));
+    auto *d = (double *)alloca(num * sizeof(double));
+
+    /* initialize valist for num number of arguments */
+    va_start(valist, num);
+
+    for (int i = 0; i < 2 * num; i += 2) {
+        int j = i / 2;
+        ts[j] = va_arg(valist, double);
+        us[j] = va_arg(valist, double);
+        uslog[j] = log(us[j]);
+    }
+    ss = va_arg(valist, double);
+    dudt = va_arg(valist, double);
+
+    /* clean memory reserved for valist */
+    va_end(valist);
+
+    spline(num, ss, 0, dudt, 0.0, ts, uslog, b, c, d);
+    uout = seval(num, t, ts, uslog, b, c, d);
+
+    return exp(uout);
+}
+
+/**
+ * @brief Derivation of a spline function
+ *
+ * Takes variable argument pairs (ti,pi) with `ti`: location of node i and
+ * `pi`: spline value at node i. the last two arguments are always `ss`: flag
+ * indicating whether slope at first node should be user defined
+ * and `dudt` user defined slope at first node. All arguments but id must be of
+ * type double.
+ *
+ * @param id index of node to which the derivative of the corresponding spline
+ * coefficient should be computed
+ * @param t point at which the spline should be evaluated
+ * @param num number of spline nodes
+ *
+ * @return dsplinedp(t)
+ *
+ */
+double Dspline(int id, double t, int num, ...) {
+
+    va_list valist;
+
+    double uout;
+    double ss;
+    double dudt;
+
+    double *ts = (double *)alloca(num * sizeof(double));
+    double *us = (double *)alloca(num * sizeof(double));
+    double *ps = (double *)alloca(num * sizeof(double));
+
+    double *b = (double *)alloca(num * sizeof(double));
+    double *c = (double *)alloca(num * sizeof(double));
+    double *d = (double *)alloca(num * sizeof(double));
+
+    int did = id / 2 - 2;
+
+    /* initialize valist for num number of arguments */
+    va_start(valist, num);
+
+    for (int i = 0; i < 2 * num; i += 2) {
+        int j = i / 2;
+        ts[j] = va_arg(valist, double);
+        ps[j] = va_arg(valist, double);
+        us[j] = 0.0;
+    }
+    us[did] = 1.0;
+    ss = va_arg(valist, double);
+    dudt = va_arg(valist, double);
+
+    /* clean memory reserved for valist */
+    va_end(valist);
+
+    spline(num, ss, 0, dudt, 0.0, ts, us, b, c, d);
+    uout = seval(num, t, ts, us, b, c, d);
+
+    return uout;
+}
+
+/**
+ * @brief Derivation of an exponentiated spline function
+ *
+ * Takes variable argument pairs (ti,pi) with `ti`: location of node i and
+ * `pi`: spline value at node i. the last two arguments are always `ss`: flag
+ * indicating whether slope at first node should be user defined
+ * and `dudt` user defined slope at first node. All arguments but id must be of
+ * type double.
+ *
+ * @param id index of node to which the derivative of the corresponding spline
+ * coefficient should be computed
+ * @param t point at which the spline should be evaluated
+ * @param num number of spline nodes
+ *
+ * @return dsplinedp(t)
+ *
+ */
+double Dspline_pos(int id, double t, int num, ...) {
+
+    va_list valist;
+
+    auto *ts = (double *)alloca(num * sizeof(double));
+    auto *us = (double *)alloca(num * sizeof(double));
+    auto *sus = (double *)alloca(num * sizeof(double));
+    auto *uslog = (double *)alloca(num * sizeof(double));
+
+    auto *b = (double *)alloca(num * sizeof(double));
+    auto *c = (double *)alloca(num * sizeof(double));
+    auto *d = (double *)alloca(num * sizeof(double));
+
+    double uout;
+    double ss;
+    double dudt;
+    double uspline_pos;
+    double suspline;
+
+    int did = id / 2 - 2;
+
+    /* initialize valist for num number of arguments */
+    va_start(valist, num);
+
+    for (int i = 0; i < 2 * num; i += 2) {
+        int j = i / 2;
+        ts[j] = va_arg(valist, double);
+        us[j] = va_arg(valist, double);
+        uslog[j] = log(us[j]);
+        sus[j] = 0.0;
+    }
+    ss = va_arg(valist, double);
+    dudt = va_arg(valist, double);
+    sus[did] = 1.0;
+
+    /* clean memory reserved for valist */
+    va_end(valist);
+
+    spline(num, ss, 0, dudt, 0.0, ts, uslog, b, c, d);
+    uspline_pos = exp(seval(num, t, ts, uslog, b, c, d));
+
+    spline(num, ss, 0, dudt, 0.0, ts, sus, b, c, d);
+    suspline = seval(num, t, ts, sus, b, c, d);
+    uout = suspline * uspline_pos / us[did];
+
+    return uout;
+}
+
+/**
+ * @brief Second derivation of a spline function
+ *
+ * Takes variable argument pairs (ti,pi) with `ti`: location of node i and
+ * `pi`: spline value at node i. the last two arguments are always `ss`: flag
+ * indicating whether slope at first node should be user defined
+ * and `dudt` user defined slope at first node. All arguments but id1 and id2
+ * must be of type double.
+ *
+ * @param id1 index of node to which the first derivative of the corresponding
+ * spline coefficient should be computed
+ * @param id2 index of node to which the second derivative of the corresponding
+ * spline coefficient should be computed
+ * @param t point at which the spline should be evaluated
+ * @param num number of spline nodes
+ *
+ * @return ddspline(t)
+ */
+double DDspline(int  id1, int  id2, double  t, int  num, ...) { return 0.0; }
+
+/**
+ * @brief Derivation of an exponentiated spline function
+ *
+ * Takes variable argument pairs (ti,pi) with `ti`: location of node i and
+ * `pi`: spline value at node i. the last two arguments are always `ss`: flag
+ * indicating whether slope at first node should be user defined
+ * and `dudt` user defined slope at first node. All arguments but id1 and id2
+ * must be of type double.
+ *
+ * @param id1 index of node to which the first derivative of the corresponding
+ * spline coefficient should be computed
+ * @param id2 index of node to which the second derivative of the corresponding
+ * spline coefficient should be computed
+ * @param t point at which the spline should be evaluated
+ * @param num number of spline nodes
+ *
+ * @return ddspline(t)
+ *
+ */
+double DDspline_pos(int id1, int id2, double t, int num, ...) {
+
+    va_list valist;
+
+    auto *ts = (double *)alloca(num * sizeof(double));
+    auto *us = (double *)alloca(num * sizeof(double));
+    auto *sus1 = (double *)alloca(num * sizeof(double));
+    auto *sus2 = (double *)alloca(num * sizeof(double));
+    auto *uslog = (double *)alloca(num * sizeof(double));
+
+    auto *b = (double *)alloca(num * sizeof(double));
+    auto *c = (double *)alloca(num * sizeof(double));
+    auto *d = (double *)alloca(num * sizeof(double));
+
+    double uout;
+    double ss;
+    double dudt;
+    double uspline_pos;
+    double su1spline;
+    double su2spline;
+
+    int did1 = id1 / 2 - 2;
+    int did2 = id2 / 2 - 2;
+
+    /* initialize valist for num number of arguments */
+    va_start(valist, num);
+
+    for (int i = 0; i < 2 * num; i += 2) {
+        int j = i / 2;
+        ts[j] = va_arg(valist, double);
+        us[j] = va_arg(valist, double);
+        uslog[j] = log(us[j]);
+        sus1[j] = 0.0;
+        sus2[j] = 0.0;
+    }
+    ss = va_arg(valist, double);
+    dudt = va_arg(valist, double);
+    sus1[did1] = 1.0;
+    sus2[did2] = 1.0;
+
+    /* clean memory reserved for valist */
+    va_end(valist);
+
+    spline(num, ss, 0, dudt, 0.0, ts, uslog, b, c, d);
+    uspline_pos = exp(seval(num, t, ts, uslog, b, c, d));
+
+    spline(num, ss, 0, dudt, 0.0, ts, sus1, b, c, d);
+    su1spline = seval(num, t, ts, sus1, b, c, d);
+
+    spline(num, ss, 0, dudt, 0.0, ts, sus2, b, c, d);
+    su2spline = seval(num, t, ts, sus2, b, c, d);
+
+    if (id1 == id2) {
+        uout = (su1spline * su2spline - su1spline) * uspline_pos;
+    } else {
+        uout = su1spline * su2spline * uspline_pos;
+    }
+    uout = uout / us[did1] / us[did2];
+
+    return uout;
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/vector.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/vector.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d57dd9610b2b71237db3fddab3a4904e33f5bb0
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/vector.cpp
@@ -0,0 +1,149 @@
+#include "amici/vector.h"
+
+namespace amici {
+
+AmiVector &AmiVector::operator=(AmiVector const &other) {
+    vec = other.vec;
+    synchroniseNVector();
+    return *this;
+}
+
+realtype *AmiVector::data() { return vec.data(); }
+
+const realtype *AmiVector::data() const { return vec.data(); }
+
+N_Vector AmiVector::getNVector() { return nvec; }
+
+const_N_Vector AmiVector::getNVector() const { return nvec; }
+
+std::vector<realtype> const &AmiVector::getVector() { return vec; }
+
+int AmiVector::getLength() const { return static_cast<int>(vec.size()); }
+
+void AmiVector::reset() { set(0.0); }
+
+void AmiVector::minus() {
+    std::transform(vec.begin(), vec.end(),
+                   vec.begin(), std::negate<realtype>());
+}
+
+void AmiVector::set(realtype val) { std::fill(vec.begin(), vec.end(), val); }
+
+realtype &AmiVector::operator[](int pos) {
+    return vec.at(static_cast<decltype(vec)::size_type>(pos));
+}
+
+realtype &AmiVector::at(int pos) {
+    return vec.at(static_cast<decltype(vec)::size_type>(pos));
+}
+
+const realtype &AmiVector::at(int pos) const {
+    return vec.at(static_cast<decltype(vec)::size_type>(pos));
+}
+
+void AmiVector::copy(const AmiVector &other) {
+    if(getLength() != other.getLength())
+        throw AmiException("Dimension of AmiVector (%i) does not "
+                           "match input dimension (%i)",
+                           getLength(), other.getLength());
+    std::copy(other.vec.begin(), other.vec.end(), vec.begin());
+    synchroniseNVector();
+}
+
+void AmiVector::synchroniseNVector() {
+    if (nvec)
+        N_VDestroy_Serial(nvec);
+    nvec = N_VMake_Serial(static_cast<long int>(vec.size()), vec.data());
+}
+
+AmiVector::~AmiVector() { N_VDestroy_Serial(nvec); }
+
+AmiVectorArray::AmiVectorArray(long int length_inner, long int length_outer)
+    : vec_array(length_outer, AmiVector(length_inner)) {
+    nvec_array.resize(length_outer);
+    for (int idx = 0; idx < length_outer; idx++) {
+        nvec_array.at(idx) = vec_array.at(idx).getNVector();
+    }
+}
+
+AmiVectorArray &AmiVectorArray::operator=(AmiVectorArray const &other) {
+    vec_array = other.vec_array;
+    nvec_array.resize(other.getLength());
+    for (int idx = 0; idx < other.getLength(); idx++) {
+        nvec_array.at(idx) = vec_array.at(idx).getNVector();
+    }
+    return *this;
+}
+
+AmiVectorArray::AmiVectorArray(const AmiVectorArray &vaold)
+    : vec_array(vaold.vec_array) {
+    nvec_array.resize(vaold.getLength());
+    for (int idx = 0; idx < vaold.getLength(); idx++) {
+        nvec_array.at(idx) = vec_array.at(idx).getNVector();
+    }
+}
+
+realtype *AmiVectorArray::data(int pos) { return vec_array.at(pos).data(); }
+
+const realtype *AmiVectorArray::data(int pos) const {
+    return vec_array.at(pos).data();
+}
+
+realtype &AmiVectorArray::at(int ipos, int jpos) {
+    return vec_array.at(jpos).at(ipos);
+}
+
+const realtype &AmiVectorArray::at(int ipos, int jpos) const {
+    return vec_array.at(jpos).at(ipos);
+}
+
+N_Vector *AmiVectorArray::getNVectorArray() { return nvec_array.data(); }
+
+N_Vector AmiVectorArray::getNVector(int pos) { return nvec_array.at(pos); }
+
+AmiVector &AmiVectorArray::operator[](int pos) { return vec_array.at(pos); }
+
+const AmiVector &AmiVectorArray::operator[](int pos) const {
+    return vec_array.at(pos);
+}
+
+int AmiVectorArray::getLength() const {
+    return static_cast<int>(vec_array.size());
+}
+
+void AmiVectorArray::reset() {
+    for (auto &v : vec_array)
+        v.reset();
+}
+
+void AmiVectorArray::flatten_to_vector(std::vector<realtype> &vec) const {
+    int n_outer = vec_array.size();
+    if (n_outer == 0)
+        return; // nothing to do ...
+    int n_inner = vec_array.at(0).getLength();
+
+    if (static_cast<int>(vec.size()) != n_inner * n_outer) {
+        throw AmiException("Dimension of AmiVectorArray (%ix%i) does not "
+                           "match target vector dimension (%u)",
+                           n_inner, n_outer, vec.size());
+    }
+
+    for (int outer = 0; outer < n_outer; ++outer) {
+        for (int inner = 0; inner < n_inner; ++inner)
+            vec.at(inner + outer * n_inner) = this->at(inner, outer);
+    }
+}
+
+void AmiVectorArray::copy(const AmiVectorArray &other) {
+    if (getLength() != other.getLength())
+        throw AmiException("Dimension of AmiVectorArray (%i) does not "
+                           "match input dimension (%i)",
+                           getLength(), other.getLength());
+
+    for (int iv = 0; iv < getLength(); ++iv) {
+        vec_array.at(iv).copy(other.vec_array.at(iv));
+        nvec_array[iv] = vec_array.at(iv).getNVector();
+    }
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/src/wrapfunctions.template.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/src/wrapfunctions.template.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26f64f336eff6dead166ecf4e0012fe0994f6327
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/src/wrapfunctions.template.cpp
@@ -0,0 +1,6 @@
+#include "amici/model.h"
+#include "wrapfunctions.h"
+
+std::unique_ptr<amici::Model> getModel() {
+    return std::unique_ptr<amici::Model>(new Model_TPL_MODELNAME());
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/swig/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..786afa1533d7625819b349310452585f523e11a4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/CMakeLists.txt
@@ -0,0 +1,25 @@
+#
+# Build additional AMICI interfaces via swig
+#
+
+find_package(SWIG REQUIRED 3)
+include(${SWIG_USE_FILE})
+
+set(AMICI_INTERFACE_LIST
+    ${CMAKE_CURRENT_SOURCE_DIR}/amici.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/edata.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/rdata.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/model.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/model_ode.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/model_dae.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/solver.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/solver_cvodes.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/solver_idas.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/std_unique_ptr.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/hdf5.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/abstract_model.i
+    ${CMAKE_CURRENT_SOURCE_DIR}/stdvec2numpy.h
+)
+
+# Add target to show files in IDE
+add_custom_target(swigInterface SOURCES ${AMICI_INTERFACE_LIST})
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/CMakeLists_model.cmake b/Requirements/AMICI-0.10.11_SS_eventFix/swig/CMakeLists_model.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..af0f64a76e4f997b188f5f35f8457406ddc6010b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/CMakeLists_model.cmake
@@ -0,0 +1,50 @@
+cmake_minimum_required(VERSION 3.8) # swig_add_library
+
+if(POLICY CMP0078)
+  cmake_policy(SET CMP0078 OLD)
+endif(POLICY CMP0078)
+if(POLICY CMP0074)
+  # Use package_ROOT environment variables
+  cmake_policy(SET CMP0074 NEW)
+endif(POLICY CMP0074)
+if(POLICY CMP0086)
+  cmake_policy(SET CMP0086 NEW)
+endif(POLICY CMP0086)
+
+
+find_package(SWIG REQUIRED)
+include(${SWIG_USE_FILE})
+
+if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
+    find_package(PythonLibs REQUIRED)
+    include_directories(${PYTHON_INCLUDE_DIRS})
+    set(Python3_LIBRARIES ${PYTHON_LIBRARIES})
+else()
+    find_package (Python3 COMPONENTS Development)
+    include_directories(${Python3_INCLUDE_DIRS})
+endif()
+
+set(SWIG_LIBRARY_NAME _${PROJECT_NAME})
+set(CMAKE_SWIG_FLAGS "")
+set_source_files_properties(${PROJECT_NAME}.i PROPERTIES CPLUSPLUS ON)
+
+# swig does not use INTERFACE_INCLUDE_DIRS of linked libraries, so add manually
+get_target_property(AMICI_INCLUDE_DIRS Upstream::amici INTERFACE_INCLUDE_DIRECTORIES)
+include_directories(${AMICI_INCLUDE_DIRS} ..)
+
+swig_add_library(${PROJECT_NAME}
+    TYPE MODULE
+    LANGUAGE python
+    SOURCES ${PROJECT_NAME}.i)
+
+swig_link_libraries(${PROJECT_NAME}
+    ${Python3_LIBRARIES}
+    model)
+
+# configure module setup script
+set(SETUP_PY_IN ${Amici_DIR}/model_setup.template.py)
+set(SETUP_PY_OUT ${CMAKE_CURRENT_BINARY_DIR}/setup.py)
+
+add_custom_target(install-python
+        DEPENDS ${SWIG_LIBRARY_NAME}
+        COMMAND python ${SETUP_PY_OUT} install)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/abstract_model.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/abstract_model.i
new file mode 100644
index 0000000000000000000000000000000000000000..0cba8b8476bdaefa7d057199ee3bb527c4808765
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/abstract_model.i
@@ -0,0 +1,3 @@
+%module abstract_model
+
+%include "amici/abstract_model.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/amici.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/amici.i
new file mode 100644
index 0000000000000000000000000000000000000000..b1f3c4522d64065394ee800089e41ed9b5808939
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/amici.i
@@ -0,0 +1,140 @@
+%module amici
+
+%include <exception.i>
+%exception {
+    try {
+        $action
+    } catch(std::exception const& ex) {
+        SWIG_exception_fail(SWIG_RuntimeError, ex.what());
+    } catch(...) {
+        SWIG_exception_fail(SWIG_RuntimeError, "Unknown exception occured");
+    }
+}
+
+%{
+#define SWIG_FILE_WITH_INIT
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+#include <vector>
+#include <stdexcept>
+%}
+
+// numpy
+%init %{
+import_array();
+%}
+
+// Expose vectors
+%include <stl.i>
+%template(DoubleVector) std::vector<double>;
+%template(IntVector) std::vector<int>;
+%template(BoolVector) std::vector<bool>;
+%template(StringVector) std::vector<std::string>;
+%template(StringDoubleMap) std::map<std::string, double>;
+
+// Let numpy access std::vector
+%{
+static_assert (sizeof(double) == sizeof (npy_double), "Numpy double size mismatch");
+static_assert (sizeof(int) == sizeof (npy_int), "Numpy integer size mismatch");
+
+#include "../swig/stdvec2numpy.h"
+using namespace amici;
+%}
+%include "stdvec2numpy.h"
+
+typedef double realtype;
+
+%include std_unique_ptr.i
+wrap_unique_ptr(SolverPtr, amici::Solver)
+wrap_unique_ptr(ReturnDataPtr, amici::ReturnData)
+wrap_unique_ptr(ModelPtr, amici::Model)
+wrap_unique_ptr(ExpDataPtr, amici::ExpData)
+
+%naturalvar amici::ExpData::x0;
+%naturalvar amici::ExpData::sx0;
+%naturalvar amici::ExpData::parameters;
+%naturalvar amici::ExpData::pscale;
+%naturalvar amici::ExpData::plist;
+%naturalvar amici::ExpData::fixedParameters;
+%naturalvar amici::ExpData::fixedParametersPreequilibration;
+%naturalvar amici::ExpData::fixedParametersPresimulation;
+
+// Include before any other header which uses enums defined there
+%include "amici/defines.h"
+
+%include abstract_model.i
+%include edata.i
+%include rdata.i
+%include solver.i
+%include solver_idas.i
+%include solver_cvodes.i
+%include model.i
+%include model_ode.i
+%include model_dae.i
+
+#ifndef AMICI_SWIG_WITHOUT_HDF5
+%include hdf5.i
+#endif
+
+// Return Python list of raw pointers instead of std::vector<std::unique_ptr> which is a huge pain
+%typemap(out) std::vector<std::unique_ptr<amici::ReturnData>> %{
+    $result = PyList_New($1.size());
+    for (int i = 0; i < (int) $1.size(); i++) {
+        PyObject *o = SWIG_NewPointerObj($1.at(i).release(), $descriptor(amici::ReturnData*), SWIG_POINTER_OWN);
+        PyList_SetItem($result, i, o);
+    }
+%}
+
+// Add necessary symbols to generated header
+%{
+#include "amici/amici.h"
+using namespace amici;
+%}
+
+// Prevent using ValueWrapper, but don't expose unique_ptr vector
+%ignore std::vector<std::unique_ptr<amici::ReturnData>>;
+%template(ReturnDataPtrVector) std::vector<std::unique_ptr<amici::ReturnData>>;
+
+// Process symbols in header
+%include "amici/amici.h"
+
+// Expose vectors
+%template(ExpDataPtrVector) std::vector<amici::ExpData*>;
+
+
+// Convert integer values to enum class
+// defeats the purpose of enum class, but didn't find a better way to allow for
+// vectors of enum class types in python
+%{
+namespace amici {
+std::vector<amici::ParameterScaling> parameterScalingFromIntVector(std::vector<int> const& intVec) {
+    std::vector<amici::ParameterScaling> result(intVec.size());
+    for (int i = 0; i < (int) result.size(); ++i) {
+        result[i] = static_cast<amici::ParameterScaling>(intVec[i]);
+    }
+    return result;
+}
+}; // namespace amici
+%}
+namespace amici {
+    std::vector<amici::ParameterScaling> parameterScalingFromIntVector(std::vector<int> const& intVec);
+}
+%template(ParameterScalingVector) std::vector<amici::ParameterScaling>;
+
+
+// Add function to check if amici was compiled with OpenMP
+%{
+namespace amici {
+/** AMICI extension was compiled with OpenMP? */
+bool compiledWithOpenMP() {
+#if defined(_OPENMP)
+    return true;
+#else
+    return false;
+#endif
+}
+};
+%}
+namespace amici {
+bool compiledWithOpenMP();
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/edata.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/edata.i
new file mode 100644
index 0000000000000000000000000000000000000000..95cea57c17869c7277e60a64c25ef7390d7658f5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/edata.i
@@ -0,0 +1,10 @@
+%module edata
+
+// Add necessary symbols to generated header
+%{
+#include "amici/edata.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+%include "amici/edata.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/hdf5.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/hdf5.i
new file mode 100644
index 0000000000000000000000000000000000000000..abf747c8a050af5d3004e0f28c4faaaae69c2a22
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/hdf5.i
@@ -0,0 +1,10 @@
+%module hdf5
+
+// Add necessary symbols to generated header
+%{
+#include "amici/hdf5.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+%include "amici/hdf5.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/model.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/model.i
new file mode 100644
index 0000000000000000000000000000000000000000..cb9dc8c4cfa598ba749ab6e95c43f1505b0bcbf5
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/model.i
@@ -0,0 +1,10 @@
+%module model
+
+// Add necessary symbols to generated header
+%{
+#include "amici/model.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+%include "amici/model.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/model_dae.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/model_dae.i
new file mode 100644
index 0000000000000000000000000000000000000000..f59e749552365d97c8b590d49470020cde28da1b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/model_dae.i
@@ -0,0 +1,11 @@
+%module model_dae
+
+// Add necessary symbols to generated header
+%{
+#include "amici/model_dae.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+
+%include "amici/model_dae.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/model_ode.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/model_ode.i
new file mode 100644
index 0000000000000000000000000000000000000000..e7c5a4c68131cfb769f8415ed888b24733cc4865
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/model_ode.i
@@ -0,0 +1,13 @@
+%module model_ode
+
+// Add necessary symbols to generated header
+%{
+#include "amici/model_ode.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+
+%include "amici/model_ode.h"
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/modelname.template.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/modelname.template.i
new file mode 100644
index 0000000000000000000000000000000000000000..3425d78a17c6778b4cc11d29d2058250395f408b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/modelname.template.i
@@ -0,0 +1,14 @@
+%module TPL_MODELNAME
+%import amici.i
+// Add necessary symbols to generated header
+
+%{
+#include "wrapfunctions.h"
+#include "amici/model_ode.h"
+#include "amici/model_dae.h"
+using namespace amici;
+%}
+
+
+// Process symbols in header
+%include "wrapfunctions.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/rdata.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/rdata.i
new file mode 100644
index 0000000000000000000000000000000000000000..efab480ca1744785ce77ef054c1a40195cf7cd79
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/rdata.i
@@ -0,0 +1,10 @@
+%module rdata
+
+// Add necessary symbols to generated header
+%{
+#include "amici/rdata.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+%include "amici/rdata.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver.i
new file mode 100644
index 0000000000000000000000000000000000000000..758abe237dffaff02a902bcae92ff61dbbddf96d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver.i
@@ -0,0 +1,12 @@
+%module solver
+
+// Add necessary symbols to generated header
+%{
+#include "amici/solver.h"
+using namespace amici;
+%}
+
+%rename(equals) operator==;
+
+// Process symbols in header
+%include "amici/solver.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver_cvodes.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver_cvodes.i
new file mode 100644
index 0000000000000000000000000000000000000000..deb480d22b04e56eeb878ee2969c02673da17db3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver_cvodes.i
@@ -0,0 +1,10 @@
+%module solver_cvodes
+
+// Add necessary symbols to generated header
+%{
+#include "amici/solver_cvodes.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+%include "amici/solver_cvodes.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver_idas.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver_idas.i
new file mode 100644
index 0000000000000000000000000000000000000000..c75a96ae311a07faf8259c912d84a894f724911d
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/solver_idas.i
@@ -0,0 +1,10 @@
+%module solver_idas
+
+// Add necessary symbols to generated header
+%{
+#include "amici/solver_idas.h"
+using namespace amici;
+%}
+
+// Process symbols in header
+%include "amici/solver_idas.h"
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/swig/std_unique_ptr.i b/Requirements/AMICI-0.10.11_SS_eventFix/swig/std_unique_ptr.i
new file mode 100644
index 0000000000000000000000000000000000000000..1063bd75b10ef1a82c3feba34f6d1b42b302295a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/swig/std_unique_ptr.i
@@ -0,0 +1,34 @@
+%module std_unique_ptr
+
+namespace std {
+  %feature("novaluewrapper") unique_ptr;
+  template <typename Type>
+  struct unique_ptr {
+     typedef Type* pointer;
+
+     explicit unique_ptr( pointer Ptr );
+     unique_ptr (unique_ptr&& Right);
+     template<class Type2, Class Del2> unique_ptr( unique_ptr<Type2, Del2>&& Right );
+     unique_ptr( const unique_ptr& Right) = delete;
+
+
+     pointer operator-> () const;
+     pointer release ();
+     void reset (pointer __p=pointer());
+     void swap (unique_ptr &__u);
+     pointer get () const;
+     operator bool () const;
+
+     ~unique_ptr();
+  };
+}
+
+%define wrap_unique_ptr(Name, Type)
+  %template(Name) std::unique_ptr<Type>;
+  %newobject std::unique_ptr<Type>::release;
+
+  %typemap(out) std::unique_ptr<Type> %{
+    $result = SWIG_NewPointerObj(new $1_ltype(std::move($1)), $&1_descriptor, SWIG_POINTER_OWN);
+  %}
+
+%enddef
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/SBMLTest.m b/Requirements/AMICI-0.10.11_SS_eventFix/tests/SBMLTest.m
new file mode 100644
index 0000000000000000000000000000000000000000..a3e3c1f783dcb4405ca8ee9c9063a3efd3615dad
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/SBMLTest.m
@@ -0,0 +1,109 @@
+% Run SBML tests from sbml-semantic-test-cases
+
+function runSBMLTests
+exedir = fileparts(mfilename('fullpath'));
+cd(exedir);
+fid = fopen(['./SBMLTest_log_' date '.txt'],'w+');
+
+for iTest = 21:1529
+    cd(exedir);
+    testid = [repmat('0',1,4-floor(log10(iTest))),num2str(iTest)];
+    if(~exist(fullfile(pwd,'SBMLresults',[testid '-results.csv'])))
+        try
+            runSBMLTest(iTest,fid);
+        catch error
+            fprintf(fid,['Test ' testid ' failed: ' error.message '\n']);;
+        end
+    end
+end
+fclose(fid);
+end
+
+
+function runSBMLTest(iTest,fid)
+cd(fileparts(mfilename('fullpath')))
+curdir = pwd;
+testid = [repmat('0',1,4-floor(log10(iTest))),num2str(iTest)];
+disp([' =================== ' testid ' =================== ']);
+if(exist(fullfile(pwd,'sbml-semantic-test-cases','cases','semantic',testid),'dir'))
+    cd(fullfile(pwd,'sbml-semantic-test-cases','cases','semantic',testid))
+    try
+        if(exist(fullfile(pwd,[testid '-sbml-l3v1.xml']),'file'))
+            SBML2AMICI([testid '-sbml-l3v1'],['SBMLTEST_' testid])
+        elseif(exist(fullfile(pwd,[testid '-sbml-l2v4.xml'])))
+            SBML2AMICI([testid '-sbml-l2v4'],['SBMLTEST_' testid])
+        else
+            return;
+        end
+        amiwrap(['SBMLTEST_' testid],['SBMLTEST_' testid '_syms'],pwd);
+    catch error
+        fprintf(fid,['Test ' testid ' failed: ' error.message '\n']);;
+        return
+    end
+    load(['SBMLTEST_' testid '_knom.mat'])
+    load(['SBMLTEST_' testid '_pnom.mat'])
+    load(['SBMLTEST_' testid '_vnom.mat'])
+    load(['SBMLTEST_' testid '_kvnom.mat'])
+    [t,settings,concflag] = parseSettings(testid);
+    options.sensi = 0;
+    options.maxsteps = 1e6;
+    eval(['sol = simulate_SBMLTEST_' testid '(t,pnom,knom,[],options);'])
+    results = readtable([testid '-results.csv']);
+    eval(['model = SBMLTEST_' testid '_syms;'])
+    adev = zeros(size(results{:,2:end}));
+    rdev = zeros(size(results{:,2:end}));
+    amiresults = results;
+    for ispecies = 2:length(results.Properties.VariableNames)
+        ix = find(logical(sym(results.Properties.VariableNames{ispecies})==model.sym.x));
+        ik = find(logical(sym(results.Properties.VariableNames{ispecies})==model.sym.k));
+        if(~isempty(ix))
+            if(~concflag)
+                vol = vnom(ix);
+                vol = subs(vol,model.sym.k(:),sym(knom(:)));
+                vol = subs(vol,model.sym.p(:),sym(pnom(:)));
+                vol = double(vol);
+            else
+                vol = 1;
+            end
+            amiresults{:,ispecies} = sol.x(:,ix)*vol;
+        elseif(~isempty(ik))
+            if(~concflag)
+                vol = kvnom(ik);
+                vol = subs(vol,model.sym.k(:),sym(knom(:)));
+                vol = subs(vol,model.sym.p(:),sym(pnom(:)));
+                vol = double(vol);
+            else
+                vol = 1;
+            end
+            amiresults{:,ispecies} = results{:,ispecies}*0 + knom(ik)*vol;
+        end
+        adev(:,ispecies-1) = abs(amiresults{:,ispecies}-results{:,ispecies});
+        rdev(:,ispecies-1) = abs((amiresults{:,ispecies}-results{:,ispecies})./results{:,ispecies});
+    end
+    rdev(isinf(rdev)) = 0;
+    assert(not(any(any(and(adev>settings.atol,rdev>settings.rtol)))))
+    cd(curdir)
+    mkdir(fullfile(pwd,'SBMLresults'))
+    writetable(amiresults,fullfile(pwd,'SBMLresults',[testid '-results.csv']))
+    clear all
+end
+end
+
+function [t,options,concflag] = parseSettings(testid)
+fid = fopen([testid '-settings.txt']);
+T = textscan(fid,'%s %f');
+t = linspace(T{2}(1),T{2}(2),T{2}(3)+1);
+tline = fgetl(fid);
+T = textscan(fid,'%s %f');
+options.atol = T{2}(1);
+options.rtol = T{2}(2);
+tline = fgetl(fid);
+tline = fgetl(fid);
+if(~strcmp(tline,'concentration: ') && ~strcmp(tline,'concentration:'))
+    concflag = true;
+else
+    concflag = false;
+end
+fclose(fid);
+
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2553825764a5a22a12de9bf9b236ef8be4d4a39b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/CMakeLists.txt
@@ -0,0 +1,83 @@
+project(amiciIntegrationTests)
+cmake_minimum_required(VERSION 2.8)
+
+find_package(CppUTest REQUIRED)
+# because Cpputest doesn't seem to care about MEMORY_LEAK_DETECTION=OFF
+add_definitions(-DD_MemoryLeakWarningPlugin_h)
+
+# models depend on Upstream::amici
+add_library(Upstream::amici ALIAS amici)
+
+set(CMAKE_CXX_FLAGS_OLD "${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -include sstream -include functional")
+
+# Amici testing library
+add_library(amici-testing testfunctions.cpp)
+target_compile_definitions(amici-testing
+    PUBLIC NEW_OPTION_FILE="${CMAKE_CURRENT_SOURCE_DIR}/testOptions.h5"
+    PUBLIC HDFFILE="${CMAKE_CURRENT_SOURCE_DIR}/expectedResults.h5"
+    PUBLIC HDFFILEWRITE="${CMAKE_CURRENT_SOURCE_DIR}/writeResults.h5"
+    )
+target_include_directories(amici-testing
+    PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
+    PUBLIC ${CppUTest_INCLUDE_DIRS}
+    )
+target_link_libraries(amici-testing
+    PUBLIC Upstream::amici
+    PUBLIC ${CppUTest_LIBRARIES}
+    )
+
+# Names of models for which tests are to be run
+set(TEST_MODELS
+    dirac
+    steadystate
+    jakstat_adjoint
+    jakstat_adjoint_o2
+    neuron neuron_o2
+    events
+    nested_events
+    robertson
+    calvetti
+    )
+
+if(ENABLE_SWIG AND ENABLE_PYTHON)
+    add_custom_target(python-tests
+        COMMAND ${CMAKE_SOURCE_DIR}/scripts/run-python-tests.sh
+        DEPENDS
+    )
+endif()
+
+add_subdirectory(unittests)
+
+include(ExternalProject)
+
+foreach(MODEL IN ITEMS ${TEST_MODELS})
+    # Build model
+    ExternalProject_Add(external_model_${MODEL}
+        PREFIX            ""
+        SOURCE_DIR        "${CMAKE_SOURCE_DIR}/models/model_${MODEL}/"
+        INSTALL_COMMAND   ""
+        TEST_COMMAND      ""
+        BUILD_ALWAYS      1
+        DEPENDS amici
+        )
+    # Rebuild if amici files are updated
+    ExternalProject_Add_StepDependencies(external_model_${MODEL} build amici)
+
+    add_library(model_${MODEL} STATIC IMPORTED)
+    add_dependencies(model_${MODEL} external_model_${MODEL})
+
+    set_target_properties(model_${MODEL}
+        PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES
+        "${CMAKE_SOURCE_DIR}/models/model_${MODEL}/"
+        IMPORTED_LOCATION
+        "${CMAKE_CURRENT_BINARY_DIR}/external_model_${MODEL}-prefix/src/external_model_${MODEL}-build/${CMAKE_STATIC_LIBRARY_PREFIX}model_${MODEL}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+        )
+    # Build tests for this model
+    add_subdirectory(${MODEL})
+    if(TARGET python-tests)
+        add_dependencies(python-tests external_model_${MODEL})
+    endif()
+endforeach()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/calvetti/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/calvetti/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..388fdf91526598cf41a12a93ff0f772338dabb91
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/calvetti/CMakeLists.txt
@@ -0,0 +1,19 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+add_dependencies(${PROJECT_NAME} external_model_${MODEL_NAME})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/calvetti/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/calvetti/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae9b28c3cf221041f0cd6f3d7d39c421439e0e0f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/calvetti/tests1.cpp
@@ -0,0 +1,26 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include <testfunctions.h>
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupCalvetti)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupCalvetti, testSimulation) {
+    amici::simulateVerifyWrite("/model_calvetti/nosensi/");
+}
+
+
+
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/dirac/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/dirac/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..99958ded68719a4649e289932d8b33833a5d299e
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/dirac/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/dirac/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/dirac/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b3d6758c4c132948d10a9d8b4a2eeccf85af881
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/dirac/tests1.cpp
@@ -0,0 +1,40 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include <testfunctions.h>
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupDirac)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupDirac, testSimulation) {
+    amici::simulateVerifyWrite("/model_dirac/nosensi/");
+}
+
+TEST(groupDirac, testSimulationExpData) {
+
+}
+
+TEST(groupDirac, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_dirac/sensiforward/");
+}
+
+TEST(groupDirac, testSensitivityState) {
+
+}
+
+TEST(groupDirac, testSensitivityAdjoint) {
+
+}
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/events/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/events/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/events/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/events/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/events/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f01bc9d10501e98fb46a370aca2afe11b0476e56
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/events/tests1.cpp
@@ -0,0 +1,32 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupEvents)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupEvents, testDefault) {
+    amici::simulateWithDefaultOptions();
+}
+
+TEST(groupEvents, testSimulation) {
+    amici::simulateVerifyWrite("/model_events/nosensi/");
+}
+
+TEST(groupEvents, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_events/sensiforward/");
+}
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/expectedResults.h5 b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/expectedResults.h5
new file mode 100644
index 0000000000000000000000000000000000000000..673b46ab19c18edd13d98d82fb02568962a4bae9
Binary files /dev/null and b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/expectedResults.h5 differ
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6bf40b88bb88aa8f51ad385359b2f991e5c054d2
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint/tests1.cpp
@@ -0,0 +1,139 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupJakstatAdjoint)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupJakstatAdjoint, testSimulation) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/nosensi/");
+}
+
+TEST(groupJakstatAdjoint, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensiforward/");
+}
+
+TEST(groupJakstatAdjoint, testSensitivityForwardLogParam) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensiforwardlogparam/");
+}
+
+TEST(groupJakstatAdjoint, testSensitivityAdjoint) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensiadjoint/");
+}
+
+TEST(groupJakstatAdjoint, testSensitivityForwardEmptySensInd) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensiforwardemptysensind/");
+}
+
+TEST(groupJakstatAdjoint, testSensitivityAdjointEmptySensInd) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensiadjointemptysensind/");
+}
+
+IGNORE_TEST(groupJakstatAdjoint, testSensitivityAdjointUnusedNanOutputs) {
+    /* UN-IGNORE ONCE THIS MODEL HAS BEEN IMPORTED VIA PYTHON INTERFACE */
+    auto model = getModel();
+    auto solver = model->getSolver();
+    amici::hdf5::readModelDataFromHDF5(
+                NEW_OPTION_FILE, *model,
+                "/model_jakstat_adjoint/sensiadjoint/options");
+    amici::hdf5::readSolverSettingsFromHDF5(
+                NEW_OPTION_FILE, *solver,
+                "/model_jakstat_adjoint/sensiadjoint/options");
+    auto edata = amici::hdf5::readSimulationExpData(
+                NEW_OPTION_FILE, "/model_jakstat_adjoint/sensiadjoint/data",
+                *model);
+
+    // Set output parameter p[10] to NaN and remove respective measurements
+    // -> gradient should still be finite
+
+    auto p = model->getParameters();
+    p[10] = NAN;
+    model->setParameters(p);
+
+    auto d = edata->getObservedData();
+    for (int it = 0; it < edata->nt(); ++it) {
+        for (int iy = 0; iy < edata->nytrue(); ++iy) {
+            if(iy == 1)
+                d[it * edata->nytrue() + iy] = NAN;
+        }
+    }
+    edata->setObservedData(d);
+
+    auto rdata = runAmiciSimulation(*solver, edata.get(), *model);
+
+    for(int i = 0; i < model->nplist(); ++i)
+        CHECK_FALSE(std::isnan(rdata->sllh[i]));
+}
+
+
+TEST(groupJakstatAdjoint, testSensitivityReplicates) {
+    // Check that we can handle replicates correctly
+
+    auto model = getModel();
+    auto solver = model->getSolver();
+    amici::hdf5::readModelDataFromHDF5(
+                NEW_OPTION_FILE, *model,
+                "/model_jakstat_adjoint/sensiadjoint/options");
+    amici::hdf5::readSolverSettingsFromHDF5(
+                NEW_OPTION_FILE, *solver,
+                "/model_jakstat_adjoint/sensiadjoint/options");
+    amici::ExpData edata(*model);
+
+    // No replicate, no sensi
+    edata.setTimepoints({10.0});
+    auto d = edata.getObservedData();
+    for (int it = 0; it < edata.nt(); ++it) {
+        for (int iy = 0; iy < edata.nytrue(); ++iy) {
+            if(iy == 0) {
+                d[it * edata.nytrue() + iy] = 1.0;
+            } else {
+                d[it * edata.nytrue() + iy] = NAN;
+            }
+        }
+    }
+    edata.setObservedData(d);
+    edata.setObservedDataStdDev(1.0);
+
+    solver->setSensitivityOrder(amici::SensitivityOrder::none);
+    auto rdata1 = runAmiciSimulation(*solver, &edata, *model);
+    auto llh1 = rdata1->llh;
+
+    // forward + replicates
+    edata.setTimepoints({10.0, 10.0});
+    d = edata.getObservedData();
+    for (int it = 0; it < edata.nt(); ++it) {
+        for (int iy = 0; iy < edata.nytrue(); ++iy) {
+            if(iy == 0) {
+                d[it * edata.nytrue() + iy] = 1.0;
+            } else {
+                d[it * edata.nytrue() + iy] = NAN;
+            }
+        }
+    }
+    edata.setObservedData(d);
+    edata.setObservedDataStdDev(1.0);
+
+    solver->setSensitivityOrder(amici::SensitivityOrder::first);
+    solver->setSensitivityMethod(amici::SensitivityMethod::forward);
+    auto rdata2 = runAmiciSimulation(*solver, &edata, *model);
+    auto llh2 = rdata2->llh;
+    DOUBLES_EQUAL(2.0 * llh1, llh2, 1e-6);
+
+    // adjoint + replicates
+    solver->setSensitivityMethod(amici::SensitivityMethod::adjoint);
+    auto rdata3 = runAmiciSimulation(*solver, &edata, *model);
+    auto llh3 = rdata3->llh;
+    DOUBLES_EQUAL(llh2, llh3, 1e-6);
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint_o2/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint_o2/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint_o2/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint_o2/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint_o2/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..accd3c2777c6f23cafae6ba326f555c5e447d3b3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/jakstat_adjoint_o2/tests1.cpp
@@ -0,0 +1,35 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupJakstatAdjointO2)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+
+TEST(groupJakstatAdjointO2, testSensitivityForward2) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensi2forward/");
+}
+
+TEST(groupJakstatAdjointO2, testSensitivityForward2LogParam) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensi2forwardlogparam/");
+}
+
+TEST(groupJakstatAdjointO2, testSensitivityAdjoint2) {
+    amici::simulateVerifyWrite("/model_jakstat_adjoint/sensi2adjoint/");
+}
+
+
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/main.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fff31406befd5820bdd00dcfdab4dcfb4ca66ed7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/main.cpp
@@ -0,0 +1,11 @@
+#include <time.h>
+#include <stdlib.h>
+
+#include "CppUTest/CommandLineTestRunner.h"
+#include "CppUTest/TestHarness.h"
+
+int main(int argc, char** argv)
+{
+    srand(time(NULL));
+    return CommandLineTestRunner::RunAllTests(argc, argv);
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/nested_events/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/nested_events/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/nested_events/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/nested_events/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/nested_events/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..72a950c81b02c373738b3ea0e06f9e5972318bf7
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/nested_events/tests1.cpp
@@ -0,0 +1,28 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupEvents)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupEvents, testSimulation) {
+    amici::simulateVerifyWrite("/model_nested_events/nosensi/");
+}
+
+TEST(groupEvents, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_nested_events/sensiforward/");
+}
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..82e0038585bd9108df696abc6048b5328514fbb1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron/tests1.cpp
@@ -0,0 +1,29 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupNeuron)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+
+TEST(groupNeuron, testSimulation) {
+    amici::simulateVerifyWrite("/model_neuron/nosensi/",
+                               100*TEST_ATOL, 100*TEST_RTOL);
+}
+
+TEST(groupNeuron, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_neuron/sensiforward/",
+                               10*TEST_ATOL, 10*TEST_RTOL);
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron_o2/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron_o2/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron_o2/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron_o2/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron_o2/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..958ff55b3029903ec741c9e3ed181fd49a46b0fa
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/neuron_o2/tests1.cpp
@@ -0,0 +1,26 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupNeuronO2)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+
+TEST(groupNeuronO2, testSensitivity2) {
+    amici::simulateVerifyWrite("/model_neuron/sensi2forward/", 10*TEST_ATOL, 10*TEST_RTOL);
+}
+
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/robertson/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/robertson/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..388fdf91526598cf41a12a93ff0f772338dabb91
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/robertson/CMakeLists.txt
@@ -0,0 +1,19 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+add_dependencies(${PROJECT_NAME} external_model_${MODEL_NAME})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/robertson/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/robertson/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5e31c36a88c2c394df23d564bac92c53ab5ec2e8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/robertson/tests1.cpp
@@ -0,0 +1,39 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include <testfunctions.h>
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupRobertson)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupRobertson, testSimulation) {
+    amici::simulateVerifyWrite("/model_robertson/nosensi/");
+}
+
+TEST(groupRobertson, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_robertson/sensiforward/", 1e6*TEST_ATOL, 1e2*TEST_RTOL);
+}
+
+TEST(groupRobertson, testSensitivityForwardDense) {
+    amici::simulateVerifyWrite("/model_robertson/sensiforwarddense/", 1e6*TEST_ATOL, 1e2*TEST_RTOL);
+}
+
+TEST(groupRobertson, testSensitivityForwardSPBCG) {
+    amici::simulateVerifyWrite("/model_robertson/sensiforwardSPBCG/", 1e7*TEST_ATOL, 1e2*TEST_RTOL);
+}
+
+
+
+
+
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/steadystate/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/steadystate/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3197ed7a72914ca47b6e7d8facb14dfc92cc6522
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/steadystate/CMakeLists.txt
@@ -0,0 +1,18 @@
+get_filename_component(MODEL_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+project(model_${MODEL_NAME}_test)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CppUTest_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    model_${MODEL_NAME}
+)
+
+add_test(NAME ${PROJECT_NAME} COMMAND ./${PROJECT_NAME} -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/steadystate/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/steadystate/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e6b3dc4f558231e6924b77bf547853c7e7d5956
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/steadystate/tests1.cpp
@@ -0,0 +1,171 @@
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+#include "testfunctions.h"
+
+#include <cstring>
+#include "wrapfunctions.h"
+
+TEST_GROUP(groupSteadystate)
+{
+    void setup() {
+
+    }
+
+    void teardown() {
+
+    }
+};
+
+TEST(groupSteadystate, testDefault) {
+    amici::simulateWithDefaultOptions();
+}
+
+
+TEST(groupSteadystate, testModelFromHDF5) {
+    // Test reading some python-written options
+    std::vector<double> pExp {1, 0.5, 0.4, 2, 0.1};
+    std::vector<double> kExp {0.1, 0.4, 0.7, 1.0};
+
+    auto model = getModel();
+    amici::hdf5::readModelDataFromHDF5(NEW_OPTION_FILE, *model, "/model_steadystate/nosensi/options");
+
+    amici::checkEqualArray(kExp, model->getFixedParameters(), TEST_ATOL, TEST_RTOL, "k");
+    CHECK_EQUAL(51, model->nt());
+    CHECK_EQUAL(0.0, model->getTimepoint(0));
+    CHECK_EQUAL(100.0, model->getTimepoint(model->nt() - 2));
+    CHECK_EQUAL(INFINITY, model->getTimepoint(model->nt() - 1));
+
+    for(int i = 0; i < model->np(); ++i) {
+        CHECK_EQUAL(pExp[i], model->getUnscaledParameters()[i]);
+        CHECK_EQUAL(log10(pExp[i]), model->getParameters()[i]);
+    }
+}
+
+TEST(groupSteadystate, testInequality) {
+    auto modelA = getModel();
+    auto modelB = std::unique_ptr<amici::Model>(new amici::Model_Test());
+
+    CHECK_FALSE(*modelA == *modelB);
+}
+
+
+TEST(groupSteadystate, testCopyModel) {
+    auto modelA = getModel();
+    auto modelB = std::unique_ptr<amici::Model>(modelA->clone());
+
+    CHECK_TRUE(*modelA == *modelB);
+}
+
+
+TEST(groupSteadystate, testCloneModel) {
+    auto modelA = getModel();
+    auto modelB = std::unique_ptr<amici::Model>(new Model_model_steadystate());
+
+    CHECK_TRUE(*modelA == *modelB);
+}
+
+TEST(groupSteadystate, testExpDataFromReturnData) {
+    auto model = getModel();
+    auto solver = model->getSolver();
+
+    amici::hdf5::readModelDataFromHDF5(NEW_OPTION_FILE, *model, "/model_steadystate/nosensi/options");
+    amici::hdf5::readSolverSettingsFromHDF5(NEW_OPTION_FILE, *solver, "/model_steadystate/nosensi/options");
+
+    auto rdata = runAmiciSimulation(*solver, nullptr, *model);
+    auto edata = amici::ExpData(*rdata, 0.1, 0.1);
+    runAmiciSimulation(*solver, &edata, *model);
+}
+
+TEST(groupSteadystate, testReuseSolver) {
+    auto model = getModel();
+    auto solver = model->getSolver();
+
+    amici::hdf5::readModelDataFromHDF5(NEW_OPTION_FILE, *model, "/model_steadystate/nosensi/options");
+    amici::hdf5::readSolverSettingsFromHDF5(NEW_OPTION_FILE, *solver, "/model_steadystate/nosensi/options");
+
+    runAmiciSimulation(*solver, nullptr, *model);
+    runAmiciSimulation(*solver, nullptr, *model);
+}
+
+TEST(groupSteadystate, testRethrow) {
+    auto model = getModel();
+    auto solver = model->getSolver();
+
+    amici::hdf5::readModelDataFromHDF5(NEW_OPTION_FILE, *model, "/model_steadystate/nosensi/options");
+    amici::hdf5::readSolverSettingsFromHDF5(NEW_OPTION_FILE, *solver, "/model_steadystate/nosensi/options");
+
+    // p = NaN will raise amici::IntegrationFailure
+    auto p = model->getParameters();
+    std::fill(p.begin(), p.end(), std::nan(""));
+    model->setParameters(p);
+
+    // must not throw
+    runAmiciSimulation(*solver, nullptr, *model);
+
+    // must throw
+    CHECK_THROWS(amici::IntegrationFailure, runAmiciSimulation(*solver, nullptr, *model, true));
+}
+
+TEST(groupSteadystate, testSimulation) {
+    amici::simulateVerifyWrite("/model_steadystate/nosensi/",
+                               100*TEST_ATOL, 100*TEST_RTOL);
+}
+
+TEST(groupSteadystate, testSensitivityForward) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiforward/");
+}
+
+TEST(groupSteadystate, testSensitivityForwardPlist) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiforwardplist/");
+}
+
+
+TEST(groupSteadystate, testSensitivityForwardErrorInt) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiforwarderrorint/");
+}
+
+TEST(groupSteadystate, testSensitivityForwardErrorNewt) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiforwarderrornewt/");
+}
+
+
+TEST(groupSteadystate, testSensitivityForwardDense) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiforwarddense/");
+}
+
+TEST(groupSteadystate, testSensitivityForwardSPBCG) {
+    amici::simulateVerifyWrite("/model_steadystate/nosensiSPBCG/", 10*TEST_ATOL, 10*TEST_RTOL);
+}
+
+TEST(groupSteadystate, testSensiFwdNewtonPreeq) {
+    amici::simulateVerifyWrite("/model_steadystate/sensifwdnewtonpreeq/");
+}
+
+TEST(groupSteadystate, testSensiAdjNewtonPreeq) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiadjnewtonpreeq/");
+}
+
+TEST(groupSteadystate, testSensiFwdSimPreeq) {
+    amici::simulateVerifyWrite("/model_steadystate/sensifwdsimpreeq/");
+}
+
+TEST(groupSteadystate, testSensiFwdSimPreeqFSA) {
+    amici::simulateVerifyWrite("/model_steadystate/sensifwdsimpreeqFSA/");
+}
+
+TEST(groupSteadystate, testSensiAdjSimPreeq) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiadjsimpreeq/");
+}
+
+TEST(groupSteadystate, testSensiAdjSimPreeqFSA) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiadjsimpreeqFSA/");
+}
+
+TEST(groupSteadystate, testSensiFwdByhandPreeq) {
+    amici::simulateVerifyWrite("/model_steadystate/sensifwdbyhandpreeq/");
+}
+
+TEST(groupSteadystate, testSensiAdjByhandPreeq) {
+    amici::simulateVerifyWrite("/model_steadystate/sensiadjbyhandpreeq/");
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/testOptions.h5 b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/testOptions.h5
new file mode 100644
index 0000000000000000000000000000000000000000..a1e9a43c4e13297801b325fa3f089f1ffddc4359
Binary files /dev/null and b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/testOptions.h5 differ
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/testfunctions.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/testfunctions.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2906e757dc5139d073eda550b314d70b0f72bc1
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/testfunctions.cpp
@@ -0,0 +1,386 @@
+#include "testfunctions.h"
+
+#include <cstring>
+#include <execinfo.h>
+#include <dlfcn.h>    // for dladdr
+#include <cxxabi.h>   // for __cxa_demangle
+#include <cstdio>
+#include <cmath>
+#include <utility>
+#include <unistd.h>
+
+#include <CppUTest/TestHarness.h>
+#include <CppUTestExt/MockSupport.h>
+
+extern std::unique_ptr<amici::Model> getModel();
+
+namespace amici {
+
+std::vector<std::string> getVariableNames(const char* name, int length)
+{
+    std::vector<std::string> names;
+    names.resize(length);
+    for (auto& it: names) {
+        auto index = &it - &names[0];
+        it += name + std::to_string(index);
+    }
+    return names;
+}
+
+void simulateVerifyWrite(const std::string& path)
+{
+    simulateVerifyWrite(NEW_OPTION_FILE, HDFFILE, HDFFILEWRITE, path, TEST_ATOL, TEST_RTOL);
+}
+
+void simulateVerifyWrite(std::string path, double atol, double rtol)
+{
+    simulateVerifyWrite(NEW_OPTION_FILE, HDFFILE, HDFFILEWRITE, std::move(path), atol, rtol);
+}
+
+void simulateWithDefaultOptions() {
+    using namespace amici;
+    auto model = getModel();
+    auto solver = model->getSolver();
+    std::unique_ptr<const ExpData> edata;
+    auto rdata = runAmiciSimulation(*solver, edata.get(), *model);
+}
+
+void simulateVerifyWrite(const std::string& hdffileOptions, const std::string& hdffileResults, const std::string& hdffilewrite, const std::string& path, double atol, double rtol)
+{
+    using namespace amici;
+    // read options from file
+    std::string optionsPath = path + "/options";
+    auto model = getModel();
+    auto solver = model->getSolver();
+    hdf5::readModelDataFromHDF5(hdffileOptions, *model, optionsPath);
+    hdf5::readSolverSettingsFromHDF5(hdffileOptions, *solver, optionsPath);
+
+    // read measurements from file
+    std::string measurementPath = path + "/data";
+    std::unique_ptr<const ExpData> edata;
+    if(hdf5::locationExists(hdffileOptions, measurementPath))
+        edata = hdf5::readSimulationExpData(hdffileOptions, measurementPath, *model);
+
+    // simulate & verify
+    auto rdata = runAmiciSimulation(*solver, edata.get(), *model);
+    // perform second simulation to check reuse of solver and model object
+    auto rdata_resimulation = runAmiciSimulation(*solver, edata.get(), *model);
+    std::string resultPath = path + "/results";
+
+    // write
+    // delete destination group
+    H5::H5File in(hdffileOptions, H5F_ACC_RDONLY);
+    auto out = amici::hdf5::createOrOpenForWriting(hdffilewrite);
+    if(hdf5::locationExists(out, path))
+        H5Ldelete(out.getId(), path.c_str(), H5P_DEFAULT);
+    hdf5::createGroup(out, path);
+    std::string writePath = path + "/options";
+    H5Ocopy(in.getId(), writePath.c_str(), out.getId(), writePath.c_str(), H5P_DEFAULT, H5P_DEFAULT);
+    writePath = path + "/data";
+    if(edata)
+        hdf5::writeSimulationExpData(*edata, out, writePath);
+
+    writePath = path + "/results";
+    hdf5::writeReturnData(*rdata, out, writePath);
+
+    // verify simulated results
+    verifyReturnData(hdffileResults, resultPath, rdata.get(), model.get(), atol, rtol);
+    // verify resimulated results
+    verifyReturnData(hdffileResults, resultPath, rdata_resimulation.get(), model.get(), atol, rtol);
+    // verify written results
+    verifyReturnData(hdffilewrite, writePath, rdata.get(), model.get(), atol, rtol);
+}
+
+std::unique_ptr<ExpData> getTestExpData(Model const& model) {
+    return std::unique_ptr<ExpData>(new ExpData(model));
+}
+
+bool withinTolerance(double expected, double actual, double atol, double rtol, int index, const char *name) {
+    bool withinTol =  fabs(expected - actual) <= atol || fabs((expected - actual) / (rtol + expected)) <= rtol;
+
+    if(!withinTol && std::isnan(expected) && std::isnan(actual))
+        withinTol = true;
+
+    if(!withinTol && std::isinf(expected) && std::isinf(actual))
+        withinTol = true;
+
+    if(!withinTol) {
+        fprintf(stderr, "ERROR: Expected value %e, but was %e in %s at index %d.\n",expected, actual, name, index);
+        fprintf(stderr, "       Relative error: %e (tolerance was %e)\n", fabs((expected - actual) / (rtol + expected)), rtol);
+        fprintf(stderr, "       Absolute error: %e (tolerance was %e)\n", fabs(expected - actual), atol);
+        printBacktrace(12);
+    }
+
+    return withinTol;
+}
+
+void checkEqualArray(std::vector<double> const& expected, std::vector<double> const& actual,
+                     double atol, double rtol, std::string const& name) {
+    CHECK_EQUAL(expected.size(), actual.size());
+
+    for(int i = 0; (unsigned) i < expected.size(); ++i)
+    {
+        bool withinTol = withinTolerance(expected[i], actual[i], atol, rtol, i, name.c_str());
+        CHECK_TRUE(withinTol);
+    }
+}
+
+void checkEqualArray(const double *expected, const double *actual, const int length, double atol, double rtol, const char *name) {
+    if(!expected && !actual)
+        return;
+    if(!length)
+        return;
+
+    CHECK_TRUE(expected && actual);
+
+    for(int i = 0; i < length; ++i)
+    {
+        bool withinTol = withinTolerance(expected[i], actual[i], atol, rtol, i, name);
+        CHECK_TRUE(withinTol);
+    }
+}
+
+void checkEqualArrayStrided(const double *expected, const double *actual, int length, int strideExpected, int strideActual, double atol, double rtol, const char *name) {
+    if(!expected && !actual)
+        return;
+
+    CHECK_TRUE(expected && actual);
+
+    for(int i = 0; i < length; ++i)
+    {
+        bool withinTol = withinTolerance(expected[i * strideExpected], actual[i * strideActual], atol, rtol, i, name);
+        CHECK_TRUE(withinTol);
+    }
+}
+
+void verifyReturnData(std::string const& hdffile, std::string const& resultPath,
+                      const ReturnData *rdata, const Model *model, double atol, double rtol) {
+    
+    CHECK_FALSE(rdata == nullptr);
+    
+    if(!hdf5::locationExists(hdffile, resultPath)) {
+        fprintf(stderr, "ERROR: No results available for %s!\n",
+                resultPath.c_str());
+        return;
+    }
+
+    // compare to saved data in hdf file
+    H5::H5File file(hdffile, H5F_ACC_RDONLY);
+
+    hsize_t m, n;
+    
+    std::vector<realtype> expected;
+
+    auto statusExp = hdf5::getIntScalarAttribute(file, resultPath, "status");
+    CHECK_EQUAL(statusExp, rdata->status);
+
+    double llhExp = hdf5::getDoubleScalarAttribute(file, resultPath, "llh");
+    CHECK_TRUE(withinTolerance(llhExp, rdata->llh, atol, rtol, 1, "llh"));
+
+    double chi2Exp = hdf5::getDoubleScalarAttribute(file, resultPath, "chi2");
+    CHECK_TRUE(withinTolerance(chi2Exp, rdata->chi2, atol, rtol, 1, "chi2"));
+
+    if(hdf5::locationExists(file, resultPath + "/x")) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/x", m, n);
+        checkEqualArray(expected, rdata->x, atol, rtol, "x");
+    } else {
+        CHECK_TRUE(rdata->x.empty());
+    }
+
+    //    CHECK_EQUAL(AMICI_O2MODE_FULL, udata->o2mode);
+    
+    if(hdf5::locationExists(file, resultPath + "/diagnosis/J")) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/diagnosis/J", m, n);
+        checkEqualArray(expected, rdata->J, atol, rtol, "J");
+    } else {
+        CHECK_TRUE(rdata->J.empty());
+    }
+
+    if(hdf5::locationExists(file, resultPath + "/y")) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/y", m, n);
+        checkEqualArray(expected, rdata->y, atol, rtol, "y");
+    } else {
+        CHECK_TRUE(rdata->y.empty());
+    }
+
+    if(hdf5::locationExists(file, resultPath + "/res")) {
+        expected = hdf5::getDoubleDataset1D(file, resultPath + "/res");
+        checkEqualArray(expected, rdata->res, atol, rtol, "res");
+    } else {
+        CHECK_TRUE(rdata->res.empty());
+    }
+
+    if(hdf5::locationExists(file, resultPath + "/z")) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/z", m, n);
+        checkEqualArray(expected, rdata->z, atol, rtol, "z");
+    } else {
+        CHECK_TRUE(rdata->z.empty());
+    }
+
+    if(hdf5::locationExists(file, resultPath + "/rz")) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/rz", m, n);
+        checkEqualArray(expected, rdata->rz, atol, rtol, "rz");
+    } else {
+        CHECK_TRUE(rdata->rz.empty());
+    }
+
+    if(hdf5::locationExists(file, resultPath + "/sigmaz")) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/sigmaz", m, n);
+        checkEqualArray(expected, rdata->sigmaz, atol, rtol, "sigmaz");
+    } else {
+        CHECK_TRUE(rdata->sigmaz.empty());
+    }
+
+    expected = hdf5::getDoubleDataset1D(file, resultPath + "/diagnosis/xdot");
+    checkEqualArray(expected, rdata->xdot, atol, rtol, "xdot");
+
+    expected = hdf5::getDoubleDataset1D(file, resultPath + "/x0");
+    checkEqualArray(expected, rdata->x0, atol, rtol, "x0");
+
+    if(rdata->sensi >= SensitivityOrder::first) {
+        verifyReturnDataSensitivities(file, resultPath, rdata, model, atol, rtol);
+    } else {
+        CHECK_EQUAL(0, rdata->sllh.size());
+        CHECK_EQUAL(0, rdata->s2llh.size());
+    }
+}
+
+void verifyReturnDataSensitivities(H5::H5File const& file, std::string const& resultPath,
+                                   const ReturnData *rdata, const Model *model, double atol, double rtol) {
+    hsize_t m, n, o;
+    std::vector<double> expected;
+    if(hdf5::locationExists(file, resultPath + "/sllh")) {
+        expected = hdf5::getDoubleDataset1D(file, resultPath + "/sllh");
+        checkEqualArray(expected, rdata->sllh, atol, rtol, "sllh");
+    } else {
+        CHECK_TRUE(rdata->sllh.empty());
+    }
+
+    if(rdata->sensi_meth == SensitivityMethod::forward) {
+
+        if(hdf5::locationExists(file, resultPath + "/sx0")) {
+            expected = hdf5::getDoubleDataset2D(file, resultPath + "/sx0", m, n);
+            checkEqualArray(expected, rdata->sx0, atol, rtol, "sx0");
+        } else {
+            CHECK_TRUE(rdata->sx0.empty());
+        }
+
+        if(hdf5::locationExists(file, resultPath + "/sres")) {
+            expected = hdf5::getDoubleDataset2D(file, resultPath + "/sres", m, n);
+            checkEqualArray(expected, rdata->sres, atol, rtol, "sres");
+        } else {
+            CHECK_TRUE(rdata->sres.empty());
+        }
+
+        if(hdf5::locationExists(file, resultPath + "/FIM")) {
+            expected = hdf5::getDoubleDataset2D(file, resultPath + "/FIM", m, n);
+            checkEqualArray(expected, rdata->FIM, atol, rtol, "FIM");
+        } else {
+            CHECK_TRUE(rdata->FIM.empty());
+        }
+
+
+        /* TODO REMOVE ASAP */
+        if(rdata->sensi < SensitivityOrder::second) {
+        /* /TODO REMOVE ASAP */
+
+            if(hdf5::locationExists(file, resultPath + "/sx")) {
+                expected = hdf5::getDoubleDataset3D(file, resultPath + "/sx", m, n, o);
+                for(int ip = 0; ip < model->nplist(); ++ip)
+                    checkEqualArray(&expected[ip * model->nt() * model->nxtrue_rdata],
+                            &rdata->sx[ip * model->nt() * rdata->nx],
+                            model->nt() * model->nxtrue_rdata, atol, rtol, "sx");
+            } else {
+                CHECK_TRUE(rdata->sx.empty());
+            }
+
+            if(hdf5::locationExists(file, resultPath + "/sy")) {
+                expected = hdf5::getDoubleDataset3D(file, resultPath + "/sy", m, n, o);
+                for(int ip = 0; ip < model->nplist(); ++ip)
+                    checkEqualArray(&expected[ip * model->nt() * model->nytrue],
+                            &rdata->sy[ip * model->nt() * model->ny],
+                            model->nt() * model->nytrue, atol, rtol, "sy");
+            } else {
+                CHECK_TRUE(rdata->sy.empty());
+            }
+
+
+            if(model->nz>0) {
+                expected = hdf5::getDoubleDataset3D(file, resultPath + "/sz", m, n, o);
+                for(int ip = 0; ip < model->nplist(); ++ip)
+                    checkEqualArray(&expected[ip * model->nMaxEvent() * model->nztrue],
+                            &rdata->sz[ip * model->nMaxEvent() * model->nz],
+                            model->nMaxEvent() * model->nztrue, atol, rtol, "sz");
+
+                expected = hdf5::getDoubleDataset3D(file, resultPath + "/srz", m, n, o);
+                for(int ip = 0; ip < model->nplist(); ++ip)
+                    checkEqualArray(&expected[ip * model->nMaxEvent() * model->nztrue],
+                            &rdata->srz[ip * model->nMaxEvent() * model->nz],
+                            model->nMaxEvent() * model->nztrue, atol, rtol, "srz");
+            }
+
+            if(hdf5::locationExists(file, resultPath + "/ssigmay") || !rdata->ssigmay.empty()) {
+                expected = hdf5::getDoubleDataset3D(file, resultPath + "/ssigmay", m, n, o);
+                for(int ip = 0; ip < model->nplist(); ++ip)
+                    checkEqualArray(&expected[ip * model->nt() * model->nytrue],
+                            &rdata->ssigmay[ip * model->nt() * model->ny],
+                            model->nt() * model->nytrue, atol, rtol, "ssigmay");
+            }
+            if(hdf5::locationExists(file, resultPath + "/ssigmaz") || !rdata->ssigmaz.empty()) {
+                if(model->nz>0) {
+                    expected = hdf5::getDoubleDataset3D(file, resultPath + "/ssigmaz", m, n, o);
+                    for(int ip = 0; ip < model->nplist(); ++ip)
+                        checkEqualArray(&expected[ip * model->nMaxEvent() * model->nztrue],
+                                &rdata->ssigmaz[ip * model->nMaxEvent() * model->nz],
+                                model->nMaxEvent() * model->nztrue, atol, rtol, "ssigmaz");
+                }
+            }
+        /* TODO REMOVE ASAP */
+        }
+        /* /TODO REMOVE ASAP */
+
+    }
+
+    if(rdata->sensi >= SensitivityOrder::second) {
+        expected = hdf5::getDoubleDataset2D(file, resultPath + "/s2llh", m, n);
+        checkEqualArray(expected, rdata->s2llh, atol, rtol, "s2llh");
+    } else {
+        CHECK_EQUAL(0, rdata->s2llh.size());
+        CHECK_EQUAL(0, rdata->s2rz.size());
+    }
+
+}
+
+void printBacktrace(const int nMaxFrames) {
+    void *callstack[nMaxFrames];
+    char buf[1024];
+    int nFrames = backtrace(callstack, nMaxFrames);
+    char **symbols = backtrace_symbols(callstack, nFrames);
+
+    std::ostringstream trace_buf;
+    for (int i = 0; i < nFrames; i++) {
+        Dl_info info;
+        if (dladdr(callstack[i], &info) && info.dli_sname) {
+            char *demangled = nullptr;
+            int status = -1;
+            if (info.dli_sname[0] == '_')
+                demangled = abi::__cxa_demangle(info.dli_sname, nullptr, nullptr, &status);
+            snprintf(buf, sizeof(buf), "%-3d %*p %s + %zd\n",
+                     i, int(2 + sizeof(void*) * 2), callstack[i],
+                     status == 0 ? demangled :
+                                   info.dli_sname == nullptr ? symbols[i] : info.dli_sname,
+                     (char *)callstack[i] - (char *)info.dli_saddr);
+            free(demangled);
+        } else {
+            snprintf(buf, sizeof(buf), "%-3d %*p %s\n",
+                     i, int(2 + sizeof(void*) * 2), callstack[i], symbols[i]);
+        }
+        trace_buf << buf;
+    }
+    free(symbols);
+    if (nFrames == nMaxFrames)
+        trace_buf << "[truncated]\n";
+    printf("%s\n",trace_buf.str().c_str());
+}
+
+} // namespace amici
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/CMakeLists.txt b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..376a2dbe961888658d955836e891e3f087969b8a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/CMakeLists.txt
@@ -0,0 +1,27 @@
+project(unittests)
+
+# cannot mix CppuTest new override togeter with Boost
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_OLD}")
+find_package(Boost COMPONENTS serialization)
+
+set(SRC_LIST
+    ../main.cpp
+    tests1.cpp
+)
+
+if(Boost_FOUND)
+    set(SRC_LIST ${SRC_LIST} testsSerialization.cpp)
+    include_directories("${Boost_INCLUDE_DIR}")
+endif()
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+    amici-testing
+    Upstream::amici
+    ${Boost_LIBRARIES}
+    )
+
+add_test(NAME unittests COMMAND ./unittests -c)
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/tests1.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/tests1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39227e6a9b0189707c277c4ce96cf426a2dd2895
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/tests1.cpp
@@ -0,0 +1,865 @@
+#include "testfunctions.h"
+
+#include <amici/amici.h>
+#include <amici/forwardproblem.h>
+#include <amici/model_ode.h>
+#include <amici/solver_cvodes.h>
+#include <amici/solver_idas.h>
+#include <amici/symbolic_functions.h>
+
+#include <cmath>
+#include <cstring>
+#include <exception>
+#include <vector>
+
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+std::unique_ptr<amici::Model>
+getModel()
+{
+    return std::unique_ptr<amici::Model>(new amici::Model_Test());
+}
+
+using namespace amici;
+
+void
+testSolverGetterSetters(CVodeSolver solver,
+                        SensitivityMethod sensi_meth,
+                        SensitivityOrder sensi,
+                        InternalSensitivityMethod ism,
+                        InterpolationType interp,
+                        NonlinearSolverIteration iter,
+                        LinearMultistepMethod lmm,
+                        int steps,
+                        int badsteps,
+                        double tol,
+                        double badtol);
+
+TEST_GROUP(amici){ void setup(){
+
+}
+
+                   void teardown(){
+
+                   } };
+
+TEST_GROUP(model)
+{
+    int nx = 1, ny = 2, nz = 3, nmaxevent = 4;
+    std::vector<realtype> p{ 1.0 };
+    std::vector<realtype> k{ 0.5, 0.4, 0.7 };
+    std::vector<int> plist{ 1 };
+    std::vector<realtype> idlist{ 0 };
+    std::vector<int> z2event{ 0, 0, 0 };
+    Model_Test model = Model_Test(nx,
+                                  nx,
+                                  nx,
+                                  nx,
+                                  ny,
+                                  ny,
+                                  nz,
+                                  nz,
+                                  nmaxevent,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  0,
+                                  SecondOrderMode::none,
+                                  p,
+                                  k,
+                                  plist,
+                                  idlist,
+                                  z2event);
+
+    std::vector<double> unscaled{ NAN };
+
+    void setup() {}
+
+    void teardown() {}
+};
+
+TEST(model, testScalingLin)
+{
+    model.setParameterScale(ParameterScaling::none);
+
+    CHECK_EQUAL(p[0], model.getParameters()[0]);
+}
+
+TEST(model, testScalingLog)
+{
+    model.setParameterScale(ParameterScaling::ln);
+
+    DOUBLES_EQUAL(std::log(p[0]), model.getParameters()[0], 1e-16);
+}
+
+TEST(model, testScalingLog10)
+{
+    model.setParameterScale(ParameterScaling::log10);
+
+    DOUBLES_EQUAL(std::log10(p[0]), model.getParameters()[0], 1e-16);
+}
+
+TEST(model, testParameterScalingLengthMismatch)
+{
+    // too short
+    auto pscale =
+      std::vector<ParameterScaling>(p.size() - 1, ParameterScaling::log10);
+    CHECK_THROWS(AmiException, model.setParameterScale(pscale));
+
+    // too long
+    pscale =
+      std::vector<ParameterScaling>(p.size() + 1, ParameterScaling::log10);
+    CHECK_THROWS(AmiException, model.setParameterScale(pscale));
+}
+
+TEST(model, testSetTimepoints){
+    CHECK_THROWS(AmiException,
+                 model.setTimepoints(std::vector<realtype>{ 0.0, 1.0, 0.5 }));
+}
+
+TEST(model, testNameIdGetterSetter)
+{
+    model.setParameterById("p0", 3.0);
+    DOUBLES_EQUAL(model.getParameterById("p0"), 3.0, 1e-16);
+    CHECK_THROWS(AmiException, model.getParameterById("p1"));
+    DOUBLES_EQUAL(
+      model.setParametersByIdRegex("p[\\d]+", 5.0), p.size(), 1e-16);
+    for (const auto& ip : model.getParameters())
+        DOUBLES_EQUAL(ip, 5.0, 1e-16);
+    CHECK_THROWS(AmiException, model.setParametersByIdRegex("k[\\d]+", 5.0));
+
+    model.setParameterByName("p0", 3.0);
+    DOUBLES_EQUAL(model.getParameterByName("p0"), 3.0, 1e-16);
+    CHECK_THROWS(AmiException, model.getParameterByName("p1"));
+    DOUBLES_EQUAL(
+      model.setParametersByNameRegex("p[\\d]+", 5.0), p.size(), 1e-16);
+    for (const auto& ip : model.getParameters())
+        DOUBLES_EQUAL(ip, 5.0, 1e-16);
+    CHECK_THROWS(AmiException, model.setParametersByNameRegex("k[\\d]+", 5.0));
+
+    model.setFixedParameterById("k0", 3.0);
+    DOUBLES_EQUAL(model.getFixedParameterById("k0"), 3.0, 1e-16);
+    CHECK_THROWS(AmiException, model.getFixedParameterById("k4"));
+    DOUBLES_EQUAL(
+      model.setFixedParametersByIdRegex("k[\\d]+", 5.0), k.size(), 1e-16);
+    for (const auto& ik : model.getFixedParameters())
+        DOUBLES_EQUAL(ik, 5.0, 1e-16);
+    CHECK_THROWS(AmiException,
+                 model.setFixedParametersByIdRegex("p[\\d]+", 5.0));
+
+    model.setFixedParameterByName("k0", 3.0);
+    DOUBLES_EQUAL(model.getFixedParameterByName("k0"), 3.0, 1e-16);
+    CHECK_THROWS(AmiException, model.getFixedParameterByName("k4"));
+    DOUBLES_EQUAL(
+      model.setFixedParametersByNameRegex("k[\\d]+", 5.0), k.size(), 1e-16);
+    for (const auto& ik : model.getFixedParameters())
+        DOUBLES_EQUAL(ik, 5.0, 1e-16);
+    CHECK_THROWS(AmiException,
+                 model.setFixedParametersByNameRegex("p[\\d]+", 5.0));
+}
+
+TEST(model, reinitializeFixedParameterInitialStates)
+{
+    CHECK_THROWS(AmiException,
+                 model.setReinitializeFixedParameterInitialStates(true));
+    model.setReinitializeFixedParameterInitialStates(false);
+    CHECK_TRUE(!model.getReinitializeFixedParameterInitialStates());
+    AmiVector x(nx);
+    AmiVectorArray sx(model.np(), nx);
+}
+
+TEST_GROUP(symbolicFunctions){ void setup(){
+
+}
+
+                               void teardown(){
+
+                               } };
+
+TEST(symbolicFunctions, testSign)
+{
+    CHECK_EQUAL(-1, sign(-2));
+    CHECK_EQUAL(0, sign(0));
+    CHECK_EQUAL(1, sign(2));
+}
+
+TEST(symbolicFunctions, testHeaviside)
+{
+    CHECK_EQUAL(0, heaviside(-1));
+    CHECK_EQUAL(0, heaviside(0));
+    CHECK_EQUAL(1, heaviside(1));
+}
+
+TEST(symbolicFunctions, testMin)
+{
+    CHECK_EQUAL(-1, amici::min(-1, 2, 0));
+    CHECK_EQUAL(-2, amici::min(1, -2, 0));
+    CHECK_TRUE(amici::isNaN(amici::min(amici::getNaN(), amici::getNaN(), 0)));
+    CHECK_EQUAL(-1, amici::min(-1, amici::getNaN(), 0));
+    CHECK_EQUAL(-1, amici::min(amici::getNaN(), -1, 0));
+}
+
+TEST(symbolicFunctions, testMax)
+{
+    CHECK_EQUAL(2, amici::max(-1, 2, 0));
+    CHECK_EQUAL(1, amici::max(1, -2, 0));
+    CHECK_TRUE(amici::isNaN(amici::max(amici::getNaN(), amici::getNaN(), 0)));
+    CHECK_EQUAL(-1, amici::max(-1, amici::getNaN(), 0));
+    CHECK_EQUAL(-1, amici::max(amici::getNaN(), -1, 0));
+}
+
+TEST(symbolicFunctions, testDMin)
+{
+    CHECK_EQUAL(0, amici::Dmin(1, -1, -2, 0));
+    CHECK_EQUAL(1, amici::Dmin(1, -1, 2, 0));
+    CHECK_EQUAL(1, amici::Dmin(2, -1, -2, 0));
+    CHECK_EQUAL(0, amici::Dmin(2, -1, 2, 0));
+}
+
+TEST(symbolicFunctions, testDMax)
+{
+    CHECK_EQUAL(1, amici::Dmax(1, -1, -2, 0));
+    CHECK_EQUAL(0, amici::Dmax(1, -1, 2, 0));
+    CHECK_EQUAL(0, amici::Dmax(2, -1, -2, 0));
+    CHECK_EQUAL(1, amici::Dmax(2, -1, 2, 0));
+}
+
+TEST(symbolicFunctions, testpos_pow)
+{
+    CHECK_EQUAL(0, amici::pos_pow(-0.1, 3));
+    CHECK_EQUAL(pow(0.1, 3), amici::pos_pow(0.1, 3));
+}
+
+TEST_GROUP(amiciSolver){ void setup(){
+
+}
+
+                         void teardown(){
+
+                         } };
+
+TEST(amiciSolver, testEquality)
+{
+    IDASolver i1, i2;
+    CVodeSolver c1, c2;
+
+    CHECK_TRUE(i1 == i2);
+    CHECK_TRUE(c1 == c2);
+    CHECK_FALSE(i1 == c1);
+}
+
+TEST(amiciSolver, testClone)
+{
+    IDASolver i1;
+    auto i2 = std::unique_ptr<Solver>(i1.clone());
+    CHECK_TRUE(i1 == *i2);
+
+    CVodeSolver c1;
+    auto c2 = std::unique_ptr<Solver>(c1.clone());
+    CHECK_TRUE(c1 == *c2);
+    CHECK_FALSE(*i2 == *c2);
+}
+
+TEST_GROUP(amiciSolverIdas){ void setup(){
+
+}
+
+                             void teardown(){
+
+                             } };
+
+TEST(amiciSolverIdas, testConstructionDestruction)
+{
+    IDASolver solver;
+}
+
+TEST_GROUP(edata)
+{
+    int nx = 1, ny = 2, nz = 3, nmaxevent = 4;
+    std::vector<realtype> timepoints = { 1, 2, 3, 4 };
+
+    std::unique_ptr<amici::Model> model = getModel();
+
+    Model_Test testModel = Model_Test(nx,
+                                      nx,
+                                      nx,
+                                      nx,
+                                      ny,
+                                      ny,
+                                      nz,
+                                      nz,
+                                      nmaxevent,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      SecondOrderMode::none,
+                                      std::vector<realtype>(1, 0.0),
+                                      std::vector<realtype>(3, 0),
+                                      std::vector<int>(2, 1),
+                                      std::vector<realtype>(0, 0.0),
+                                      std::vector<int>(0, 1));
+    void setup()
+    {
+        model->setTimepoints(timepoints);
+        model->setNMaxEvent(nmaxevent);
+        testModel.setTimepoints(timepoints);
+        testModel.setNMaxEvent(nmaxevent);
+    }
+
+    void teardown() {}
+};
+
+TEST(edata, testConstructors1)
+{
+    auto edata = ExpData();
+    CHECK_TRUE(edata.nytrue() == 0);
+    CHECK_TRUE(edata.nztrue() == 0);
+    CHECK_TRUE(edata.nmaxevent() == 0);
+}
+TEST(edata, testConstructors2)
+{
+    auto edata = ExpData(model->nytrue, model->nztrue, model->nMaxEvent());
+    CHECK_TRUE(edata.nytrue() == model->nytrue);
+    CHECK_TRUE(edata.nztrue() == model->nztrue);
+    CHECK_TRUE(edata.nmaxevent() == model->nMaxEvent());
+}
+
+TEST(edata, testConstructors3)
+{
+    auto edata =
+      ExpData(model->nytrue, model->nztrue, model->nMaxEvent(), timepoints);
+    CHECK_TRUE(edata.nytrue() == model->nytrue);
+    CHECK_TRUE(edata.nztrue() == model->nztrue);
+    CHECK_TRUE(edata.nmaxevent() == model->nMaxEvent());
+    CHECK_TRUE(edata.nt() == model->nt());
+    checkEqualArray(
+      timepoints, edata.getTimepoints(), TEST_ATOL, TEST_RTOL, "ts");
+}
+
+TEST(edata, testConstructors4)
+{
+    std::vector<realtype> y(ny * timepoints.size(), 0.0);
+    std::vector<realtype> y_std(ny * timepoints.size(), 0.1);
+    std::vector<realtype> z(nz * nmaxevent, 0.0);
+    std::vector<realtype> z_std(nz * nmaxevent, 0.1);
+
+    auto edata = ExpData(testModel.nytrue,
+                         testModel.nztrue,
+                         testModel.nMaxEvent(),
+                         timepoints,
+                         y,
+                         y_std,
+                         z,
+                         z_std);
+    CHECK_TRUE(edata.nytrue() == testModel.nytrue);
+    CHECK_TRUE(edata.nztrue() == testModel.nztrue);
+    CHECK_TRUE(edata.nmaxevent() == testModel.nMaxEvent());
+    CHECK_TRUE(edata.nt() == testModel.nt());
+    checkEqualArray(
+      timepoints, edata.getTimepoints(), TEST_ATOL, TEST_RTOL, "ts");
+    checkEqualArray(
+      y, edata.getObservedData(), TEST_ATOL, TEST_RTOL, "observedData");
+    checkEqualArray(y_std,
+                    edata.getObservedDataStdDev(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "observedDataStdDev");
+    checkEqualArray(
+      z, edata.getObservedEvents(), TEST_ATOL, TEST_RTOL, "observedEvents");
+    checkEqualArray(z_std,
+                    edata.getObservedEventsStdDev(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "observedEventsStdDev");
+
+    auto edata_copy = ExpData(edata);
+    CHECK_TRUE(edata.nytrue() == edata_copy.nytrue());
+    CHECK_TRUE(edata.nztrue() == edata_copy.nztrue());
+    CHECK_TRUE(edata.nmaxevent() == edata_copy.nmaxevent());
+    CHECK_TRUE(edata.nt() == edata_copy.nt());
+    checkEqualArray(edata_copy.getTimepoints(),
+                    edata.getTimepoints(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "ts");
+    checkEqualArray(edata_copy.getObservedData(),
+                    edata.getObservedData(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "observedData");
+    checkEqualArray(edata_copy.getObservedDataStdDev(),
+                    edata.getObservedDataStdDev(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "observedDataStdDev");
+    checkEqualArray(edata_copy.getObservedEvents(),
+                    edata.getObservedEvents(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "observedEvents");
+    checkEqualArray(edata_copy.getObservedEventsStdDev(),
+                    edata.getObservedEventsStdDev(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "observedEventsStdDev");
+}
+
+TEST(edata, testConstructors5)
+{
+    testModel.setTimepoints(timepoints);
+    auto edata = ExpData(testModel);
+    CHECK_TRUE(edata.nytrue() == testModel.nytrue);
+    CHECK_TRUE(edata.nztrue() == testModel.nztrue);
+    CHECK_TRUE(edata.nmaxevent() == testModel.nMaxEvent());
+    CHECK_TRUE(edata.nt() == testModel.nt());
+    checkEqualArray(testModel.getTimepoints(),
+                    edata.getTimepoints(),
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "ts");
+}
+
+TEST(edata, testDimensionChecks)
+{
+
+    std::vector<realtype> bad_std(ny, -0.1);
+
+    std::vector<realtype> y(ny * timepoints.size(), 0.0);
+    std::vector<realtype> y_std(ny * timepoints.size(), 0.1);
+    std::vector<realtype> z(nz * nmaxevent, 0.0);
+    std::vector<realtype> z_std(nz * nmaxevent, 0.1);
+
+    CHECK_THROWS(AmiException,
+                 ExpData(testModel.nytrue,
+                         testModel.nztrue,
+                         testModel.nMaxEvent(),
+                         timepoints,
+                         z,
+                         z_std,
+                         z,
+                         z_std));
+
+    CHECK_THROWS(AmiException,
+                 ExpData(testModel.nytrue,
+                         testModel.nztrue,
+                         testModel.nMaxEvent(),
+                         timepoints,
+                         z,
+                         bad_std,
+                         z,
+                         z_std));
+
+    auto edata = ExpData(testModel);
+
+    std::vector<realtype> bad_y(ny * timepoints.size() + 1, 0.0);
+    std::vector<realtype> bad_y_std(ny * timepoints.size() + 1, 0.1);
+    std::vector<realtype> bad_z(nz * nmaxevent + 1, 0.0);
+    std::vector<realtype> bad_z_std(nz * nmaxevent + 1, 0.1);
+
+    CHECK_THROWS(AmiException, edata.setObservedData(bad_y));
+    CHECK_THROWS(AmiException, edata.setObservedDataStdDev(bad_y_std));
+    CHECK_THROWS(AmiException, edata.setObservedEvents(bad_z));
+    CHECK_THROWS(AmiException, edata.setObservedEventsStdDev(bad_y_std));
+
+    std::vector<realtype> bad_single_y(edata.nt() + 1, 0.0);
+    std::vector<realtype> bad_single_y_std(edata.nt() + 1, 0.1);
+    std::vector<realtype> bad_single_z(edata.nmaxevent() + 1, 0.0);
+    std::vector<realtype> bad_single_z_std(edata.nmaxevent() + 1, 0.1);
+
+    CHECK_THROWS(AmiException, edata.setObservedData(bad_single_y, 0));
+    CHECK_THROWS(AmiException,
+                 edata.setObservedDataStdDev(bad_single_y_std, 0));
+    CHECK_THROWS(AmiException, edata.setObservedEvents(bad_single_z, 0));
+    CHECK_THROWS(AmiException,
+                 edata.setObservedEventsStdDev(bad_single_y_std, 0));
+
+    CHECK_THROWS(AmiException,
+                 edata.setTimepoints(std::vector<realtype>{ 0.0, 1.0, 0.5 }));
+}
+
+TEST(edata, testSettersGetters)
+{
+    auto edata = ExpData(testModel);
+
+    std::vector<realtype> y(ny * timepoints.size(), 0.0);
+    std::vector<realtype> y_std(ny * timepoints.size(), 0.1);
+    std::vector<realtype> z(nz * nmaxevent, 0.0);
+    std::vector<realtype> z_std(nz * nmaxevent, 0.1);
+
+    edata.setObservedData(y);
+    checkEqualArray(
+      edata.getObservedData(), y, TEST_ATOL, TEST_RTOL, "ObservedData");
+    edata.setObservedDataStdDev(y_std);
+    checkEqualArray(edata.getObservedDataStdDev(),
+                    y_std,
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "ObservedDataStdDev");
+    edata.setObservedEvents(z);
+    checkEqualArray(
+      edata.getObservedEvents(), z, TEST_ATOL, TEST_RTOL, "ObservedEvents");
+    edata.setObservedEventsStdDev(z_std);
+    checkEqualArray(edata.getObservedEventsStdDev(),
+                    z_std,
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "ObservedEventsStdDev");
+
+    std::vector<realtype> single_y(edata.nt(), 0.0);
+    std::vector<realtype> single_y_std(edata.nt(), 0.1);
+
+    for (int iy = 0; iy < ny; ++iy) {
+        edata.setObservedData(single_y, iy);
+        edata.setObservedDataStdDev(single_y_std, iy);
+    }
+    CHECK_THROWS(std::exception, edata.setObservedData(single_y, ny));
+    CHECK_THROWS(std::exception, edata.setObservedData(single_y, -1));
+    CHECK_THROWS(std::exception, edata.setObservedDataStdDev(single_y_std, ny));
+    CHECK_THROWS(std::exception, edata.setObservedDataStdDev(single_y_std, -1));
+
+    std::vector<realtype> single_z(edata.nmaxevent(), 0.0);
+    std::vector<realtype> single_z_std(edata.nmaxevent(), 0.1);
+
+    for (int iz = 0; iz < nz; ++iz) {
+        edata.setObservedEvents(single_z, iz);
+        edata.setObservedEventsStdDev(single_z_std, iz);
+    }
+
+    CHECK_THROWS(std::exception, edata.setObservedEvents(single_z, nz));
+    CHECK_THROWS(std::exception, edata.setObservedEvents(single_z, -1));
+    CHECK_THROWS(std::exception,
+                 edata.setObservedEventsStdDev(single_z_std, nz));
+    CHECK_THROWS(std::exception,
+                 edata.setObservedEventsStdDev(single_z_std, -1));
+
+    CHECK_TRUE(edata.getObservedDataPtr(0));
+    CHECK_TRUE(edata.getObservedDataStdDevPtr(0));
+    CHECK_TRUE(edata.getObservedEventsPtr(0));
+    CHECK_TRUE(edata.getObservedEventsStdDevPtr(0));
+
+    std::vector<realtype> empty(0, 0.0);
+
+    edata.setObservedData(empty);
+    edata.setObservedDataStdDev(empty);
+    edata.setObservedEvents(empty);
+    edata.setObservedEventsStdDev(empty);
+
+    CHECK_TRUE(!edata.getObservedDataPtr(0));
+    CHECK_TRUE(!edata.getObservedDataStdDevPtr(0));
+    CHECK_TRUE(!edata.getObservedEventsPtr(0));
+    CHECK_TRUE(!edata.getObservedEventsStdDevPtr(0));
+
+    checkEqualArray(
+      edata.getObservedData(), empty, TEST_ATOL, TEST_RTOL, "ObservedData");
+    checkEqualArray(edata.getObservedDataStdDev(),
+                    empty,
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "ObservedDataStdDev");
+    checkEqualArray(
+      edata.getObservedEvents(), empty, TEST_ATOL, TEST_RTOL, "ObservedEvents");
+    checkEqualArray(edata.getObservedEventsStdDev(),
+                    empty,
+                    TEST_ATOL,
+                    TEST_RTOL,
+                    "ObservedEventsStdDev");
+}
+
+TEST_GROUP(solver)
+{
+    int nx = 1, ny = 2, nz = 3, ne = 0;
+    double tol, badtol;
+    std::vector<realtype> timepoints = { 1, 2, 3, 4 };
+
+    std::unique_ptr<amici::Model> model = getModel();
+    SensitivityMethod sensi_meth;
+    SensitivityOrder sensi;
+    int steps, badsteps;
+    LinearMultistepMethod lmm;
+    NonlinearSolverIteration iter;
+    InternalSensitivityMethod ism;
+    InterpolationType interp;
+
+    Model_Test testModel = Model_Test(nx,
+                                      nx,
+                                      nx,
+                                      nx,
+                                      ny,
+                                      ny,
+                                      nz,
+                                      nz,
+                                      ne,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      0,
+                                      1,
+                                      0,
+                                      0,
+                                      SecondOrderMode::none,
+                                      std::vector<realtype>(1, 0.0),
+                                      std::vector<realtype>(3, 0),
+                                      std::vector<int>(2, 1),
+                                      std::vector<realtype>(0, 0.0),
+                                      std::vector<int>(0, 1));
+
+    CVodeSolver solver = CVodeSolver();
+
+    void setup()
+    {
+        tol = 0.01;
+        badtol = -0.01;
+        sensi_meth = SensitivityMethod::adjoint;
+        sensi = SensitivityOrder::first;
+        steps = 1000;
+        badsteps = -1;
+        lmm = LinearMultistepMethod::adams;
+        iter = NonlinearSolverIteration::fixedpoint;
+        ism = InternalSensitivityMethod::staggered1;
+        interp = InterpolationType::polynomial;
+    }
+
+    void teardown() {}
+};
+
+TEST(solver, testSettersGettersNoSetup)
+{
+    testSolverGetterSetters(solver,
+                            sensi_meth,
+                            sensi,
+                            ism,
+                            interp,
+                            iter,
+                            lmm,
+                            steps,
+                            badsteps,
+                            tol,
+                            badtol);
+}
+
+TEST(solver, testSettersGettersWithSetup)
+{
+
+    solver.setSensitivityMethod(sensi_meth);
+    CHECK_EQUAL(static_cast<int>(solver.getSensitivityMethod()),
+                static_cast<int>(sensi_meth));
+
+    auto rdata =
+      std::unique_ptr<ReturnData>(new ReturnData(solver, testModel));
+    AmiVector x(nx), dx(nx);
+    AmiVectorArray sx(nx, 1), sdx(nx, 1);
+
+    testModel.setInitialStates(std::vector<realtype>{ 0 });
+
+    solver.setup(0, &testModel, x, dx, sx, sdx);
+
+    testSolverGetterSetters(solver,
+                            sensi_meth,
+                            sensi,
+                            ism,
+                            interp,
+                            iter,
+                            lmm,
+                            steps,
+                            badsteps,
+                            tol,
+                            badtol);
+}
+
+void
+testSolverGetterSetters(CVodeSolver solver,
+                        SensitivityMethod sensi_meth,
+                        SensitivityOrder sensi,
+                        InternalSensitivityMethod ism,
+                        InterpolationType interp,
+                        NonlinearSolverIteration iter,
+                        LinearMultistepMethod lmm,
+                        int steps,
+                        int badsteps,
+                        double tol,
+                        double badtol)
+{
+
+    solver.setSensitivityMethod(sensi_meth);
+    CHECK_EQUAL(static_cast<int>(solver.getSensitivityMethod()),
+                static_cast<int>(sensi_meth));
+
+    solver.setSensitivityOrder(sensi);
+    CHECK_EQUAL(static_cast<int>(solver.getSensitivityOrder()),
+                static_cast<int>(sensi));
+
+    solver.setInternalSensitivityMethod(ism);
+    CHECK_EQUAL(static_cast<int>(solver.getInternalSensitivityMethod()),
+                static_cast<int>(ism));
+
+    solver.setInterpolationType(interp);
+    CHECK_EQUAL(static_cast<int>(solver.getInterpolationType()),
+                static_cast<int>(interp));
+
+    solver.setNonlinearSolverIteration(iter);
+    CHECK_EQUAL(static_cast<int>(solver.getNonlinearSolverIteration()),
+                static_cast<int>(iter));
+
+    solver.setLinearMultistepMethod(lmm);
+    CHECK_EQUAL(static_cast<int>(solver.getLinearMultistepMethod()),
+                static_cast<int>(lmm));
+
+    solver.setNewtonPreequilibration(true);
+    CHECK_EQUAL(solver.getNewtonPreequilibration(), true);
+
+    solver.setStabilityLimitFlag(true);
+    CHECK_EQUAL(solver.getStabilityLimitFlag(), true);
+
+    CHECK_THROWS(AmiException, solver.setNewtonMaxSteps(badsteps));
+    solver.setNewtonMaxSteps(steps);
+    CHECK_EQUAL(solver.getNewtonMaxSteps(), steps);
+
+    CHECK_THROWS(AmiException, solver.setNewtonMaxLinearSteps(badsteps));
+    solver.setNewtonMaxLinearSteps(steps);
+    CHECK_EQUAL(solver.getNewtonMaxLinearSteps(), steps);
+
+    CHECK_THROWS(AmiException, solver.setMaxSteps(badsteps));
+    solver.setMaxSteps(steps);
+    CHECK_EQUAL(solver.getMaxSteps(), steps);
+
+    CHECK_THROWS(AmiException, solver.setMaxStepsBackwardProblem(badsteps));
+    solver.setMaxStepsBackwardProblem(steps);
+    CHECK_EQUAL(solver.getMaxStepsBackwardProblem(), steps);
+
+    CHECK_THROWS(AmiException, solver.setRelativeTolerance(badtol));
+    solver.setRelativeTolerance(tol);
+    CHECK_EQUAL(solver.getRelativeTolerance(), tol);
+
+    CHECK_THROWS(AmiException, solver.setAbsoluteTolerance(badtol));
+    solver.setAbsoluteTolerance(tol);
+    CHECK_EQUAL(solver.getAbsoluteTolerance(), tol);
+
+    CHECK_THROWS(AmiException, solver.setRelativeToleranceQuadratures(badtol));
+    solver.setRelativeToleranceQuadratures(tol);
+    CHECK_EQUAL(solver.getRelativeToleranceQuadratures(), tol);
+
+    CHECK_THROWS(AmiException, solver.setAbsoluteToleranceQuadratures(badtol));
+    solver.setAbsoluteToleranceQuadratures(tol);
+    CHECK_EQUAL(solver.getAbsoluteToleranceQuadratures(), tol);
+
+    CHECK_THROWS(AmiException, solver.setRelativeToleranceSteadyState(badtol));
+    solver.setRelativeToleranceSteadyState(tol);
+    CHECK_EQUAL(solver.getRelativeToleranceSteadyState(), tol);
+
+    CHECK_THROWS(AmiException, solver.setAbsoluteToleranceSteadyState(badtol));
+    solver.setAbsoluteToleranceSteadyState(tol);
+    CHECK_EQUAL(solver.getAbsoluteToleranceSteadyState(), tol);
+}
+
+TEST_GROUP(amivector)
+{
+    std::vector<double> vec1{ 1, 2, 4, 3 };
+    std::vector<double> vec2{ 4, 1, 2, 3 };
+    std::vector<double> vec3{ 4, 4, 2, 1 };
+
+    void setup() {}
+
+    void teardown() {}
+};
+
+TEST(amivector, vector)
+{
+    AmiVector av(vec1);
+    N_Vector nvec = av.getNVector();
+    for (int i = 0; i < av.getLength(); ++i)
+        CHECK_EQUAL(av.at(i), NV_Ith_S(nvec, i));
+}
+
+TEST(amivector, vectorArray)
+{
+    AmiVectorArray ava(4, 3);
+    AmiVector av1(vec1), av2(vec2), av3(vec3);
+    std::vector<AmiVector> avs{ av1, av2, av3 };
+    for (int i = 0; i < ava.getLength(); ++i)
+        ava[i] = avs.at(i);
+
+    std::vector<double> badLengthVector(13, 0.0);
+    std::vector<double> flattened(12, 0.0);
+
+    CHECK_THROWS(AmiException, ava.flatten_to_vector(badLengthVector));
+    ava.flatten_to_vector(flattened);
+    for (int i = 0; i < ava.getLength(); ++i) {
+        const AmiVector av = ava[i];
+        for (int j = 0; j < av.getLength(); ++j)
+            CHECK_EQUAL(flattened.at(i * av.getLength() + j), av.at(j));
+    }
+}
+
+TEST_GROUP(sunmatrixwrapper)
+{
+    //inputs
+    std::vector<double> a{0.82, 0.91, 0.13};
+    std::vector<double> b{0.77, 0.80};
+    SUNMatrixWrapper A = SUNMatrixWrapper(3, 2);
+    // result
+    std::vector<double> d{1.3753, 1.5084, 1.1655};
+
+    void setup() {
+        SM_ELEMENT_D(A.get(), 0, 0) = 0.69;
+        SM_ELEMENT_D(A.get(), 1, 0) = 0.32;
+        SM_ELEMENT_D(A.get(), 2, 0) = 0.95;
+        SM_ELEMENT_D(A.get(), 0, 1) = 0.03;
+        SM_ELEMENT_D(A.get(), 1, 1) = 0.44;
+        SM_ELEMENT_D(A.get(), 2, 1) = 0.38;
+    }
+
+    void teardown() {}
+};
+
+TEST(sunmatrixwrapper, sparse_multiply)
+{
+    auto A_sparse = SUNMatrixWrapper(A, 0.0, CSR_MAT);
+    auto c(a); //copy c
+    A_sparse.multiply(c, b);
+    checkEqualArray(d, c, TEST_ATOL, TEST_RTOL, "multiply");
+
+    A_sparse = SUNMatrixWrapper(A, 0.0, CSC_MAT);
+    c = a; //copy c
+    A_sparse.multiply(c, b);
+    checkEqualArray(d, c, TEST_ATOL, TEST_RTOL, "multiply");
+}
+
+TEST(sunmatrixwrapper, dense_multiply)
+{
+    auto c(a); //copy c
+    A.multiply(c, b);
+    checkEqualArray(d, c, TEST_ATOL, TEST_RTOL, "multiply");
+}
+
+TEST(sunmatrixwrapper, multiply_throws)
+{
+    CHECK_THROWS(std::invalid_argument, A.multiply(b, a));
+    CHECK_THROWS(std::invalid_argument, A.multiply(a, a));
+    CHECK_THROWS(std::invalid_argument, A.multiply(b, b));
+    auto b_amivector = AmiVector(b);
+    auto a_amivector = AmiVector(a);
+    CHECK_THROWS(std::invalid_argument, A.multiply(b_amivector.getNVector(),
+                                          a_amivector.getNVector()));
+    CHECK_THROWS(std::invalid_argument, A.multiply(a_amivector.getNVector(),
+                                          a_amivector.getNVector()));
+    CHECK_THROWS(std::invalid_argument, A.multiply(b_amivector.getNVector(),
+                                          b_amivector.getNVector()));
+}
+
+TEST(sunmatrixwrapper, transform_throws)
+{
+    CHECK_THROWS(std::invalid_argument, SUNMatrixWrapper(A, 0.0, 13));
+    auto A_sparse = SUNMatrixWrapper(A, 0.0, CSR_MAT);
+    CHECK_THROWS(std::invalid_argument, SUNMatrixWrapper(A_sparse, 0.0, CSR_MAT));
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/testsSerialization.cpp b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/testsSerialization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cb950043f0922adbccf7531f0f37e186b61f7b22
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/unittests/testsSerialization.cpp
@@ -0,0 +1,187 @@
+#include <amici/serialization.h> // needs to be included before cpputest
+#include <amici/model.h>
+#include <amici/solver_cvodes.h>
+
+#include "testfunctions.h"
+
+#include <cmath>
+
+#include "CppUTest/TestHarness.h"
+#include "CppUTestExt/MockSupport.h"
+
+void checkReturnDataEqual(amici::ReturnData const& r, amici::ReturnData const& s) {
+    CHECK_EQUAL(r.np, s.np);
+    CHECK_EQUAL(r.nk, s.nk);
+    CHECK_EQUAL(r.nx, s.nx);
+    CHECK_EQUAL(r.nxtrue, s.nxtrue);
+    CHECK_EQUAL(r.nx_solver, s.nx_solver);
+    CHECK_EQUAL(r.ny, s.ny);
+    CHECK_EQUAL(r.nytrue, s.nytrue);
+    CHECK_EQUAL(r.nz, s.nz);
+    CHECK_EQUAL(r.nztrue, s.nztrue);
+    CHECK_EQUAL(r.ne, s.ne);
+    CHECK_EQUAL(r.nJ, s.nJ);
+    CHECK_EQUAL(r.nplist, s.nplist);
+    CHECK_EQUAL(r.nmaxevent, s.nmaxevent);
+    CHECK_EQUAL(r.nt, s.nt);
+    CHECK_EQUAL(r.newton_maxsteps, s.newton_maxsteps);
+    CHECK_TRUE(r.pscale == s.pscale);
+    CHECK_EQUAL(static_cast<int>(r.o2mode), static_cast<int>(s.o2mode));
+    CHECK_EQUAL(static_cast<int>(r.sensi), static_cast<int>(s.sensi));
+    CHECK_EQUAL(static_cast<int>(r.sensi_meth), static_cast<int>(s.sensi_meth));
+
+    using amici::checkEqualArray;
+    checkEqualArray(r.ts, s.ts, 1e-16, 1e-16, "ts");
+    checkEqualArray(r.xdot, s.xdot, 1e-16, 1e-16, "xdot");
+    checkEqualArray(r.J, s.J, 1e-16, 1e-16, "J");
+    checkEqualArray(r.z, s.z, 1e-16, 1e-16, "z");
+    checkEqualArray(r.sigmaz, s.sigmaz,1e-16, 1e-16, "sigmaz");
+    checkEqualArray(r.sz, s.sz, 1e-16, 1e-16, "sz");
+    checkEqualArray(r.ssigmaz, s.ssigmaz, 1e-16, 1e-16, "ssigmaz");
+    checkEqualArray(r.rz, s.rz, 1e-16, 1e-16, "rz");
+    checkEqualArray(r.srz, s.srz, 1e-16, 1e-16, "srz");
+    checkEqualArray(r.s2rz, s.s2rz, 1e-16, 1e-16, "s2rz");
+    checkEqualArray(r.x, s.x, 1e-16, 1e-16, "x");
+    checkEqualArray(r.sx, s.sx, 1e-16, 1e-16, "sx");
+
+    checkEqualArray(r.y, s.y, 1e-16, 1e-16, "y");
+    checkEqualArray(r.sigmay, s.sigmay, 1e-16, 1e-16, "sigmay");
+    checkEqualArray(r.sy, s.sy, 1e-16, 1e-16, "sy");
+    checkEqualArray(r.ssigmay, s.ssigmay, 1e-16, 1e-16, "ssigmay");
+    
+    CHECK_TRUE(r.numsteps == s.numsteps);
+    CHECK_TRUE(r.numstepsB == s.numstepsB);
+    CHECK_TRUE(r.numrhsevals == s.numrhsevals);
+    CHECK_TRUE(r.numrhsevalsB == s.numrhsevalsB);
+    CHECK_TRUE(r.numerrtestfails == s.numerrtestfails);
+    CHECK_TRUE(r.numerrtestfailsB == s.numerrtestfailsB);
+    CHECK_TRUE(r.numnonlinsolvconvfails == s.numnonlinsolvconvfails);
+    CHECK_TRUE(r.numnonlinsolvconvfailsB == s.numnonlinsolvconvfailsB);
+    CHECK_TRUE(r.order == s.order);
+    CHECK_TRUE(r.cpu_time == s.cpu_time);
+    CHECK_TRUE(r.cpu_timeB == s.cpu_timeB);
+    CHECK_TRUE(r.newton_cpu_time == s.newton_cpu_time);
+
+    CHECK_TRUE(r.newton_status == s.newton_status);
+    CHECK_TRUE(r.newton_numsteps == s.newton_numsteps);
+    CHECK_TRUE(r.newton_numlinsteps == s.newton_numlinsteps);
+
+    DOUBLES_EQUAL(r.newton_cpu_time, s.newton_cpu_time, 1e-16);
+    checkEqualArray(r.x0, s.x0, 1e-16, 1e-16, "x0");
+    checkEqualArray(r.sx0, s.sx0, 1e-16, 1e-16, "sx0");
+
+
+    CHECK_TRUE(r.llh == s.llh || (std::isnan(r.llh) && std::isnan(s.llh)));
+    CHECK_TRUE(r.chi2 == s.chi2 || (std::isnan(r.llh) && std::isnan(s.llh)));
+    CHECK_EQUAL(r.status, s.status);
+
+    checkEqualArray(r.sllh, s.sllh, 1e-5, 1e-5, "sllh");
+    checkEqualArray(r.s2llh, s.s2llh, 1e-5, 1e-5, "s2llh");
+}
+
+
+// clang-format off
+TEST_GROUP(dataSerialization){
+    amici::CVodeSolver solver;
+    void setup() {
+        // set non-default values for all members
+        solver.setAbsoluteTolerance(4);
+        solver.setRelativeTolerance(4);
+        solver.setAbsoluteToleranceQuadratures(4);
+        solver.setRelativeToleranceQuadratures(4);
+        solver.setAbsoluteToleranceSteadyState(4);
+        solver.setRelativeToleranceSteadyState(4);
+        solver.setSensitivityMethod(amici::SensitivityMethod::adjoint);
+        solver.setSensitivityOrder(amici::SensitivityOrder::second);
+        solver.setMaxSteps(1e6);
+        solver.setMaxStepsBackwardProblem(1e6);
+        solver.setNewtonMaxSteps(1e6);
+        solver.setNewtonMaxLinearSteps(1e6);
+        solver.setNewtonPreequilibration(true);
+        solver.setStateOrdering(static_cast<int>(amici::SUNLinSolKLU::StateOrdering::COLAMD));
+        solver.setInterpolationType(amici::InterpolationType::polynomial);
+        solver.setStabilityLimitFlag(0);
+        solver.setLinearSolver(amici::LinearSolver::dense);
+        solver.setLinearMultistepMethod(amici::LinearMultistepMethod::adams);
+        solver.setNonlinearSolverIteration(amici::NonlinearSolverIteration::newton);
+        solver.setInternalSensitivityMethod(amici::InternalSensitivityMethod::staggered);
+    }
+
+    void teardown() {
+    }
+};
+// clang-format on
+
+
+
+TEST(dataSerialization, testFile) {
+    int np = 1;
+    int nk = 2;
+    int nx = 3;
+    int nz = 4;
+    amici::CVodeSolver solver;
+    amici::Model_Test m = amici::Model_Test(nx, nx, nx, nx, 4, 4, nz, nz, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                                            amici::SecondOrderMode::none,
+                                            std::vector<realtype>(np,0.0),
+                                            std::vector<realtype>(nk,0.0),
+                                            std::vector<int>(np,0),
+                                            std::vector<realtype>(nx,0.0),
+                                            std::vector<int>(nz,0));
+
+    {
+        std::ofstream ofs("sstore.dat");
+        boost::archive::text_oarchive oar(ofs);
+        //oar & static_cast<amici::Solver&>(solver);
+        oar & static_cast<amici::Model&>(m);
+    }
+    {
+        std::ifstream ifs("sstore.dat");
+        boost::archive::text_iarchive iar(ifs);
+        amici::CVodeSolver v;
+        amici::Model_Test n;
+        //iar &static_cast<amici::Solver&>(v);
+        iar &static_cast<amici::Model&>(n);
+        //CHECK_TRUE(solver == v);
+        CHECK_TRUE(m == n);
+
+    }
+}
+
+TEST(dataSerialization, testString) {
+    int np = 1;
+    int nk = 2;
+    int nx = 3;
+    int nz = 4;
+    amici::CVodeSolver solver;
+    amici::Model_Test m = amici::Model_Test(nx, nx, nx, nx, 4, 4, nz, nz, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                                            amici::SecondOrderMode::none,
+                                            std::vector<realtype>(np,0.0),
+                                            std::vector<realtype>(nk,0.0),
+                                            std::vector<int>(np,0),
+                                            std::vector<realtype>(nx,0.0),
+                                            std::vector<int>(nz,0));
+
+    amici::ReturnData r(solver, m);
+
+    std::string serialized = amici::serializeToString(r);
+
+    checkReturnDataEqual(r, amici::deserializeFromString<amici::ReturnData>(serialized));
+}
+
+TEST(dataSerialization, testChar) {
+    int length;
+    char *buf = amici::serializeToChar(solver, &length);
+
+    amici::CVodeSolver v = amici::deserializeFromChar<amici::CVodeSolver>(buf, length);
+
+    delete[] buf;
+    CHECK_TRUE(solver == v);
+}
+
+TEST(dataSerialization, testStdVec) {
+
+    auto buf = amici::serializeToStdVec(solver);
+    amici::CVodeSolver v = amici::deserializeFromChar<amici::CVodeSolver>(buf.data(), buf.size());
+
+    CHECK_TRUE(solver == v);
+}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/wrapTestModels.m b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/wrapTestModels.m
new file mode 100644
index 0000000000000000000000000000000000000000..28963e2e3a03840bf7f6dcb825770f0838457bce
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/cpputest/wrapTestModels.m
@@ -0,0 +1,109 @@
+function wrapTestModels()
+% wrapTestModels calls amiwrap on all test models. currently necessary for continuous integrations
+% to yield meaningful results
+%
+% Return values:
+%  void
+    
+    amiciPath = fileparts(mfilename('fullpath'));
+    amiciPath = [amiciPath '/../../matlab'];
+    
+    %% EXAMPLE STEADYSTATE
+    
+    cd([amiciPath '/examples/example_steadystate/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_steadystate.m'));
+        amiwrap('model_steadystate','model_steadystate_syms',exdir);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+    
+    %% EXAMPLE DIRAC
+    cd([amiciPath '/examples/example_dirac/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_dirac.m'));
+        amiwrap('model_dirac','model_dirac_syms',exdir);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+    
+    %% EXAMPLE JAKSTAT
+    cd([amiciPath '/examples/example_jakstat_adjoint/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_jakstat_adjoint.m'));
+        amiwrap('model_jakstat_adjoint', 'model_jakstat_adjoint_syms', exdir, 1);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+
+    %% EXAMPLE NEURON
+    cd([amiciPath '/examples/example_neuron/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_neuron.m'));
+        amiwrap('model_neuron', 'model_neuron_syms', exdir, 1);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+
+    cd(fileparts(mfilename('fullpath')));
+    
+    %% EXAMPLE EVENTS
+    cd([amiciPath '/examples/example_events/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_events.m'));
+        amiwrap('model_events', 'model_events_syms', exdir);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+    
+    %% EXAMPLE NESTED EVENTS
+    cd([amiciPath '/examples/example_nested_events/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_nested_events.m'));
+        amiwrap('model_nested_events', 'model_nested_events_syms', exdir);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+
+    cd(fileparts(mfilename('fullpath')));
+    
+    %% EXAMPLE ROBERTSON
+    cd([amiciPath '/examples/example_robertson/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_robertson.m'));
+        amiwrap('model_robertson', 'model_robertson_syms', exdir);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+
+    cd(fileparts(mfilename('fullpath')));
+    
+    %% EXAMPLE CALVETTI
+    cd([amiciPath '/examples/example_calvetti/']);
+    
+    try
+        [exdir,~,~]=fileparts(which('example_calvetti.m'));
+        amiwrap('model_calvetti', 'model_calvetti_syms', exdir);
+    catch err
+        disp(err.message)
+        cd(fileparts(mfilename('fullpath')));
+    end
+
+    cd(fileparts(mfilename('fullpath')));
+    
+end
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example.py
new file mode 100644
index 0000000000000000000000000000000000000000..99a9d91cb0e1959cb368b5dedcd91a59379d4494
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example.py
@@ -0,0 +1,84 @@
+import h5py
+import numpy as np
+import pandas as pd
+
+def dict2hdf5(object, dictionary):
+    for key, value in dictionary.items():
+        if isArray(value):
+            a = np.array(value)
+            if not len(value):
+                dtype = 'f8'
+            elif isArray(value[0]):
+                if isinstance(value[0][0], (np.float64, float)):
+                    dtype = 'f8'
+                else:
+                    dtype = '<i4'
+            elif isinstance(value[0], (np.float64, float)):
+                dtype = 'f8'
+            else:
+                dtype = '<i4'
+            object.require_dataset(name=key,
+                                   data=a,
+                                   shape=a.shape,
+                                   dtype=dtype)
+        else:
+            object.attrs[key] = value
+
+def dict2attrs(object, dictionary):
+    for key, value in dictionary.items():
+        object.attrs[key] = value
+
+def isArray(var):
+    return isinstance(var, (list,
+                            tuple,
+                            np.ndarray,
+                            pd.core.frame.DataFrame,
+                            pd.core.series.Series))
+
+class AmiciExample:
+
+    def __init__(self):
+
+        self.modelOptions = {
+            #'pscale' : []
+            'theta' : [],
+            'kappa' : [],
+            'ts' : [],
+            'tstart' : 0.0,
+            'pscale' : 0
+        }
+        self.solverOptions = {
+            'atol' : 1e-16,
+            'interpType' : 1,
+            'ism': 1,
+            'iter' : 2,
+            'linsol': 9,
+            'lmm': 2,
+            'maxsteps' : 1e4,
+            'newton_maxlinsteps': 100,
+            'newton_maxsteps' : 40,
+            'newton_preeq' : 0,
+            'nmaxevent' : 10,
+            'ordering' : 0,
+            'rtol' : 1e-8,
+            'sens_ind' : [],
+            'sensi': 0,
+            'sensi_meth' : 1,
+            'stldet' : 1,
+            # sx0
+            # x0
+        }
+        #self.modelOptions['sx0'] = [1.0] * np
+        #self.modelOptions['x0'] = [1.0] * np
+        self.data = {}
+
+    def writeToFile(self, filename, root = "/"):
+        with h5py.File(filename, "a") as f:
+            g = f.require_group(root + '/options')
+            dict2hdf5(g, self.modelOptions)
+            dict2hdf5(g, self.solverOptions)
+
+            if 'data' in self.__dict__ and len(self.data):
+                g = f.require_group(root + '/data')
+                dict2hdf5(g, self.data)
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_calvetti.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_calvetti.py
new file mode 100644
index 0000000000000000000000000000000000000000..86178d684bb3623caed7167a25102679d98fd38a
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_calvetti.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+import sys
+import numpy as np
+from example import AmiciExample
+
+
+class ExampleCalvetti(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numX = 6
+        self.numP = 0
+        self.numK = 6
+
+        self.modelOptions['theta'] = []
+        self.modelOptions['kappa'] = [0.29, 0.74, 0.44, 0.08, 0.27, 0.18]
+        self.modelOptions['ts'] = np.linspace(0, 20, 201)
+        self.modelOptions['pscale'] = 0
+
+        self.solverOptions['atol'] = 1e-6
+        self.solverOptions['rtol'] = 1e-4
+        self.solverOptions['sens_ind'] = []
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+
+def writeNoSensi(filename):
+    ex = ExampleCalvetti()
+
+    ex.writeToFile(filename, '/model_calvetti/nosensi/')
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_dirac.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_dirac.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e5a0a8adeb8641bbec3da4cdede4d257cb15aa3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_dirac.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+
+import sys
+import numpy as np
+from example import AmiciExample
+
+class ExampleDirac(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numX = 2
+        self.numP = 4
+        self.numK = 0
+
+        self.modelOptions['theta'] = np.log10([1, 0.5, 2, 3])
+        self.modelOptions['ts'] = np.linspace(0, 3, 1001)
+        self.modelOptions['pscale'] = 2
+
+        self.solverOptions['atol'] = 1e-16
+        self.solverOptions['maxsteps'] = 1e4
+        self.solverOptions['nmaxevent'] = 10
+        self.solverOptions['rtol'] = 1e-8
+        self.solverOptions['sens_ind'] = []
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+
+def writeNoSensi(filename):
+    ex = ExampleDirac()
+
+    ex.writeToFile(filename, '/model_dirac/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleDirac()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_dirac/sensiforward/')
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_events.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_events.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4fc28a7c8b3c920b845c17989d7fd3448dd13ba
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_events.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+
+import sys
+import numpy as np
+
+from example import AmiciExample
+
+class ExampleEvents(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numZ = 2
+        self.numX = 3
+        self.numP = 4
+        self.numK = 4
+
+        self.modelOptions['theta'] = np.log10([0.5, 2, 0.5, 0.5])
+        self.modelOptions['kappa'] = [4.0, 8.0, 10.0, 4.0]
+        self.modelOptions['ts'] = np.linspace(0.0, 10.0, 20)
+        self.modelOptions['pscale'] = 2
+
+        self.solverOptions['atol'] = 1e-16
+        self.solverOptions['maxsteps'] = 1e4
+        self.solverOptions['nmaxevent'] = 2
+        self.solverOptions['rtol'] = 1e-8
+        self.solverOptions['sens_ind'] = []
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+        self.data['Y'] = np.full((len(self.modelOptions['ts']), 1), np.nan)
+        self.data['Sigma_Y'] = np.full((len(self.modelOptions['ts']), 1), np.nan)
+
+        self.data['Z'] = np.full((self.solverOptions['nmaxevent'], self.numZ ), np.nan)
+        self.data['Sigma_Z'] = np.full((self.solverOptions['nmaxevent'], self.numZ ), np.nan)
+
+        self.data['condition'] = self.modelOptions['kappa']
+        self.data['t'] = self.modelOptions['ts']
+
+
+def writeNoSensi(filename):
+    ex = ExampleEvents()
+
+    ex.writeToFile(filename, '/model_events/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleEvents()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+
+    ex.writeToFile(filename, '/model_events/sensiforward/')
+
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_jakstat.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_jakstat.py
new file mode 100644
index 0000000000000000000000000000000000000000..d91419273239bac8a87683b0886c473169e19f18
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_jakstat.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+
+import sys
+import numpy as np
+import pandas as pd
+import os
+
+from example import AmiciExample
+
+class ExampleJakStatAdjoint(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numX = 9
+        self.numP = 17
+        self.numK = 2
+
+        curPath = os.path.dirname(os.path.realpath(__file__))
+        dataPath = curPath + "/../../matlab/examples/example_jakstat_adjoint/pnas_data_original.xls"
+        xls = pd.ExcelFile(dataPath).parse()
+        self.modelOptions['ts'] = xls.time
+        self.modelOptions['theta'] = np.array([0.60, 3, -0.95, -0.0075, 0,
+                                               -2.8, -0.26, -0.075, -0.41, -5,
+                                               -0.74, -0.64, -0.11, 0.027, -0.5,
+                                               0, -0.5])
+        self.modelOptions['kappa'] = [1.4, 0.45]
+        self.modelOptions['pscale'] = 2
+
+        self.solverOptions['atol'] = 1e-16
+        self.solverOptions['maxsteps'] = 1e4
+        self.solverOptions['nmaxevent'] = 10
+        self.solverOptions['rtol'] = 1e-12
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+        self.data['Y'] = np.array(xls.loc[:,['pSTAT_au', 'tSTAT_au', 'pEpoR_au']])
+        self.data['Sigma_Y'] = np.full(self.data['Y'].shape, np.nan)
+        self.data['Sigma_Z'] = []
+        self.data['Z'] = []
+        self.data['condition'] = self.modelOptions['kappa']
+        self.data['t'] = self.modelOptions['ts']
+
+
+def writeNoSensi(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.modelOptions['theta'] = 0.1 + ex.modelOptions['theta']
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensiforward/')
+
+def writeSensiAdjoint(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.modelOptions['theta'] = 0.1 + ex.modelOptions['theta']
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 2
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensiadjoint/')
+
+
+def writeSensiForwardEmptySensInd(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.solverOptions['sens_ind'] = np.array([])
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensiforwardemptysensind/')
+
+
+def writeSensiAdjointEmptySensInd(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.solverOptions['sens_ind'] = np.array([])
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 2
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensiadjointemptysensind/')
+
+
+def writeSensi2Forward(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.modelOptions['theta'] = 0.1 + ex.modelOptions['theta']
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 2
+    ex.solverOptions['sensi_meth'] = 1
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensi2forward/')
+
+
+def writeSensi2Adjoint(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.modelOptions['theta'] = 0.1 + ex.modelOptions['theta']
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 2
+    ex.solverOptions['sensi_meth'] = 2
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensi2adjoint/')
+
+def writeSensiForwardLogParam(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.modelOptions['theta'] = np.log(np.power(10.0, ex.modelOptions['theta'] + 0.1))
+    ex.modelOptions['pscale'] = 1
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensiforwardlogparam/')
+
+def writeSensi2ForwardLogParam(filename):
+    ex = ExampleJakStatAdjoint()
+
+    ex.modelOptions['theta'] = 0.1 + ex.modelOptions['theta']
+    ex.modelOptions['pscale'] = 1
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 2
+    ex.solverOptions['sensi_meth'] = 1
+
+    ex.writeToFile(filename, '/model_jakstat_adjoint/sensi2forwardlogparam/')
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+    writeSensiAdjoint(filename)
+    writeSensi2Forward(filename)
+    writeSensi2Adjoint(filename)
+    writeSensiForwardLogParam(filename)
+    writeSensi2ForwardLogParam(filename)
+    writeSensiForwardEmptySensInd(filename)
+    writeSensiAdjointEmptySensInd(filename)
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_nested_events.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_nested_events.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ee44d3a4834295dcaca23880cb19799c5e5e2a9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_nested_events.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+import sys
+import numpy as np
+
+from example import AmiciExample
+
+class ExampleNestedEvents(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numX = 1
+        self.numP = 5
+        self.numK = 0
+        self.numZ = 0
+
+        self.modelOptions['theta'] = np.log10([0.1, 1000, 2, 8e-1, 1.6])
+        self.modelOptions['ts'] = np.linspace(0, 20, 100)
+        self.modelOptions['pscale'] = 2
+
+        self.solverOptions['atol'] = 1e-12
+        self.solverOptions['maxsteps'] = 1e4
+        self.solverOptions['nmaxevent'] = 2
+        self.solverOptions['rtol'] = 1e-14
+        self.solverOptions['sens_ind'] = []
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+        self.data['Y'] = np.full((len(self.modelOptions['ts']), 1), np.nan)
+        self.data['Sigma_Y'] = np.full((len(self.modelOptions['ts']), 1), np.nan)
+
+        self.data['Z'] = np.full((self.numZ, self.solverOptions['nmaxevent']), np.nan)
+        self.data['Sigma_Z'] = np.full((self.numZ, self.solverOptions['nmaxevent']), 0.5)
+
+        self.data['condition'] = self.modelOptions['kappa']
+        self.data['t'] = self.modelOptions['ts']
+
+
+def writeNoSensi(filename):
+    ex = ExampleNestedEvents()
+
+    ex.writeToFile(filename, '/model_nested_events/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleNestedEvents()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_nested_events/sensiforward/')
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_neuron.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_neuron.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c730ff56bf5c1040681c13872cd5726f427ab20
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_neuron.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+import sys
+import numpy as np
+
+from example import AmiciExample
+
+class ExampleNeuron(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numZ = 1
+        self.numX = 2
+        self.numP = 4
+        self.numK = 2
+
+        self.modelOptions['theta'] = np.log10([0.02, 0.3, 65, 0.9])
+        self.modelOptions['kappa'] = [-60,10]
+        self.modelOptions['ts'] = [0.0, 0.9991997694102649, 1.9983995388205298, 2.9975993082307943, 3.9967990776410596, 4.995998847051324, 5.995198616461589, 6.994398385871854, 7.993598155282119, 8.992797924692384, 9.991997694102649, 10.991197463512913, 11.990397232923177, 12.989597002333443, 13.988796771743708, 14.987996541153972, 15.987196310564238, 16.986396079974504, 17.98559584938477, 18.984795618795033, 19.983995388205297, 20.98319515761556, 21.982394927025826, 22.981594696436094, 23.980794465846355, 24.979994235256623, 25.979194004666887, 26.978393774077155, 27.977593543487416, 28.976793312897684, 29.975993082307944, 30.975192851718212, 31.974392621128477, 32.97359239053874, 33.97279215994901, 34.97199192935927, 35.97119169876954, 36.9703914681798, 37.969591237590066, 38.96879100700033, 39.967990776410595, 40.967190545820856, 41.96639031523112, 42.96559008464139, 43.96478985405165, 44.96398962346192, 45.96318939287219, 46.962389162282456, 47.96158893169271, 48.96078870110298, 49.959988470513245, 50.959188239923506, 51.958388009333774, 52.95758777874404, 53.95678754815431, 54.95598731756456, 55.95518708697483, 56.9543868563851, 57.95358662579537, 58.95278639520563, 59.95198616461589, 60.95118593402616, 61.950385703436424, 62.949585472846685, 63.94878524225695, 64.94798501166721, 65.94718478107748, 66.94638455048775, 67.94558431989802, 68.94478408930829, 69.94398385871854, 70.9431836281288, 71.94238339753907, 72.94158316694934, 73.9407829363596, 74.93998270576986, 75.93918247518013, 76.9383822445904, 77.93758201400065, 78.93678178341092, 79.93598155282119, 80.93518132223146, 81.93438109164171, 82.93358086105198, 83.93278063046225, 84.93198039987251, 85.93118016928278, 86.93037993869305, 87.9295797081033, 88.92877947751359, 89.92797924692384, 90.9271790163341, 91.92637878574438, 92.92557855515463, 93.92477832456491, 94.92397809397517, 95.92317786338542, 96.9223776327957, 97.92157740220595, 98.92077717161622]
+        self.modelOptions['pscale'] = 2
+
+        self.solverOptions['atol'] = 1e-16
+        self.solverOptions['maxsteps'] = 1e45
+        self.solverOptions['nmaxevent'] = 22
+        self.solverOptions['rtol'] = 1e-12
+        self.solverOptions['sens_ind'] = []
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+        self.data['Y'] = np.full((len(self.modelOptions['ts']), 1), np.nan)
+        self.data['Sigma_Y'] = np.full((len(self.modelOptions['ts']), 1), np.nan)
+
+        self.data['Z'] = np.transpose([[2.4420740245701733, 5.921007525639647, np.nan, 10.366527794075543, 12.83694308382395, 14.624269559247253, 18.722446363647578, 22.20739095602005, 28.602369747827655, 31.442843729542822, 34.01927181474919, 41.26726577405225, 44.275254172160395, 51.56486254598814, 57.100273114298204, 61.961654997481084, 69.03838073191332, 74.3546047146856, 81.21960802401809, 87.2873927650102, 93.34894804384085, 98.57346300859241]])
+        self.data['Sigma_Z'] = 0.5 * np.ones(self.data['Z'].shape)
+
+        self.data['condition'] = self.modelOptions['kappa']
+        self.data['t'] = self.modelOptions['ts']
+
+    """   
+        TODO: should generate from simulation: 
+        rng(0);
+        D.Z = sol.z(sol.z<t(end));
+        t = linspace(0,D.Z(end)-0.1,100);
+        D.Z = D.Z + 0.5*randn(size(D.Z));
+        D.Z(3) = NaN;
+        D.Sigma_Z = 0.5*ones(size(D.Z));
+        D.Z = D.Z + D.Sigma_Z.*randn(size(D.Z));       
+    """
+
+
+def writeNoSensi(filename):
+    ex = ExampleNeuron()
+
+    ex.writeToFile(filename, '/model_neuron/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleNeuron()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_neuron/sensiforward/')
+
+
+def writeSensi2Forward(filename):
+    ex = ExampleNeuron()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 2
+    ex.solverOptions['sensi_meth'] = 1
+
+    ex.writeToFile(filename, '/model_neuron/sensi2forward/')
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+    writeSensi2Forward(filename)
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_robertson.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_robertson.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9a71d4db12b4e850923f2a050d791154895ed66
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_robertson.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+import sys
+import numpy as np
+from example import AmiciExample
+
+
+class ExampleRobertson(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numX = 3
+        self.numP = 3
+        self.numK = 1
+
+
+        self.modelOptions['theta'] = np.log10([0.04, 1e4, 3e7])
+        self.modelOptions['kappa'] = [0.9]
+        self.modelOptions['ts'] = np.append(0, 4 * np.logspace(-6, 6))
+        # logspace output from matlab slightly different:
+        self.modelOptions['ts'] = [0.0, 4.0E-6, 7.030042499419172E-6, 1.2355374385909914E-5, 2.1714701757295438E-5, 3.8163819053999774E-5, 6.70733174724404E-5, 1.1788206810207238E-4, 2.071789871692485E-4, 3.641192711966091E-4, 6.39943487842423E-4, 0.0011247074791896924, 0.001976685344529533, 0.003474045495005412, 0.006105671868700933, 0.010730783181118898, 0.018859465453829577, 0.03314571091418737, 0.05825393910004978, 0.10238191690798133, 0.17993730675877775, 0.31624172843630804, 0.5557981977492555, 0.97682123781946, 1.7167737040515112, 3.017248025341849, 5.302845462360432, 9.319807242061488, 16.37966024952171, 28.787426920046055, 50.59420867421183, 88.91985930104782, 156.27759748218483, 274.6595380017199, 482.71705625573054, 848.380355168077, 1491.0374881259752, 2620.5142274381983, 4605.5815973057925, 8094.358590900622, 14225.921224892543, 25002.207701095904, 43941.64567950229, 77227.90915533014, 135728.87087581318, 238544.93266378547, 419245.253661875, 736827.9877306866, 1294983.017127056, 2275946.411607322, 4000000.0]
+        self.modelOptions['pscale'] = 2
+
+        self.solverOptions['atol'] = 1e-12
+        self.solverOptions['rtol'] = 1e-8
+        self.solverOptions['sens_ind'] = []
+        self.solverOptions['sensi'] = 0
+        self.solverOptions['sensi_meth'] = 1
+
+
+def writeNoSensi(filename):
+    ex = ExampleRobertson()
+
+    ex.writeToFile(filename, '/model_robertson/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleRobertson()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_robertson/sensiforward/')
+
+
+def writeSensiForwardDense(filename):
+    ex = ExampleRobertson()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['linsol'] = 1
+
+    ex.writeToFile(filename, '/model_robertson/sensiforwarddense/')
+
+
+def writeSensiForwardSPBCG(filename):
+    ex = ExampleRobertson()
+
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['linsol'] = 7
+    ex.solverOptions['atol'] = 1e-14
+    ex.solverOptions['rtol'] = 1e-12
+
+    ex.writeToFile(filename, '/model_robertson/sensiforwardSPBCG/')
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+    writeSensiForwardDense(filename)
+    writeSensiForwardSPBCG(filename)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_steadystate.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_steadystate.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9f2885bdd4c1031f8a54533227112237a564ff8
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfig/example_steadystate.py
@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+import sys
+import numpy as np
+from example import AmiciExample, dict2attrs
+
+class ExampleSteadystate(AmiciExample):
+
+    def __init__(self):
+        AmiciExample.__init__( self )
+
+        self.numX = 3
+        self.numP = 5
+        self.numK = 4
+
+        self.modelOptions['theta'] = np.log10([1, 0.5, 0.4, 2, 0.1])
+        self.modelOptions['kappa'] = [0.1, 0.4, 0.7, 1]
+        self.modelOptions['ts'] = np.linspace(0, 100, 50)
+        self.modelOptions['pscale'] = 2
+
+def writeNoSensi(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.append(np.linspace(0, 100, 50), np.inf)
+    ex.writeToFile(filename, '/model_steadystate/nosensi/')
+
+
+def writeSensiForward(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.append(np.linspace(0, 100, 50), np.inf)
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_steadystate/sensiforward/')
+
+
+def writeSensiForwardPlist(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.append(np.linspace(0, 100, 50), np.inf)
+    ex.solverOptions['sens_ind'] = [3, 1, 2, 4]
+    ex.solverOptions['sensi'] = 1
+
+    ex.writeToFile(filename, '/model_steadystate/sensiforwardplist/')
+
+
+def writeSensiForwardDense(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.append(np.linspace(0, 100, 50), np.inf)
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['linsol'] = 1
+    ex.writeToFile(filename, '/model_steadystate/sensiforwarddense/')
+
+
+def writeNosensiSPBCG(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.append(np.linspace(0, 100, 50), np.inf)
+    ex.solverOptions['sensi'] = 0
+    ex.solverOptions['linsol'] = 7
+
+    ex.writeToFile(filename, '/model_steadystate/nosensiSPBCG/')
+
+
+def writeSensiForwardErrorInt(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.append(np.linspace(0, 100, 50), np.inf)
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 100
+
+    ex.writeToFile(filename, '/model_steadystate/sensiforwarderrorint/')
+
+
+def writeSensiForwardErrorNewt(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = [0, np.inf]
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 100
+    ex.solverOptions['newton_maxsteps'] = 2
+
+    ex.writeToFile(filename, '/model_steadystate/sensiforwarderrornewt/')
+
+
+def writeSensiFwdNewtonPreeq(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['conditionPreequilibration'] = [0.1, 0.4, 0.7, 0.5]
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+    ex.solverOptions['newton_preeq'] = True
+    ex.solverOptions['atol'] = 10**-16
+    ex.solverOptions['rtol'] = 10**-12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 20
+
+    ex.writeToFile(filename, '/model_steadystate/sensifwdnewtonpreeq/')
+
+
+def writeSensiAdjNewtonPreeq(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['conditionPreequilibration'] = [0.1, 0.4, 0.7, 0.5]
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 2
+    ex.solverOptions['newton_preeq'] = True
+    ex.solverOptions['atol'] = 10**-16
+    ex.solverOptions['rtol'] = 10**-12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 20
+
+    ex.writeToFile(filename, '/model_steadystate/sensiadjnewtonpreeq/')
+
+
+def writeSensiFwdSimPreeq(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['conditionPreequilibration'] = [0.1, 0.4, 0.7, 0.5]
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+    ex.solverOptions['newton_preeq'] = True
+    ex.solverOptions['atol'] = 10 ** -16
+    ex.solverOptions['rtol'] = 10 ** -12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 0
+
+    ex.writeToFile(filename, '/model_steadystate/sensifwdsimpreeq/')
+
+
+def writeSensiFwdSimPreeqFSA(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['conditionPreequilibration'] = [0.1, 0.4, 0.7, 0.5]
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.modelOptions['steadyStateSensitivityMode'] = 1
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+    ex.solverOptions['newton_preeq'] = True
+    ex.solverOptions['atol'] = 10 ** -16
+    ex.solverOptions['rtol'] = 10 ** -12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 0
+
+    ex.writeToFile(filename, '/model_steadystate/sensifwdsimpreeqFSA/')
+
+
+def writeSensiAdjSimPreeq(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['conditionPreequilibration'] = [0.1, 0.4, 0.7, 0.5]
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 2
+    ex.solverOptions['newton_preeq'] = True
+    ex.solverOptions['atol'] = 10 ** -16
+    ex.solverOptions['rtol'] = 10 ** -12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 0
+
+    ex.writeToFile(filename, '/model_steadystate/sensiadjsimpreeq/')
+
+
+def writeSensiAdjSimPreeqFSA(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['conditionPreequilibration'] = [0.1, 0.4, 0.7, 0.5]
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.modelOptions['steadyStateSensitivityMode'] = 1
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 2
+    ex.solverOptions['newton_preeq'] = True
+    ex.solverOptions['atol'] = 10 ** -16
+    ex.solverOptions['rtol'] = 10 ** -12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 0
+
+    ex.writeToFile(filename, '/model_steadystate/sensiadjsimpreeqFSA/')
+
+
+def writeSensiFwdByhandPreeq(filename):
+    ex = ExampleSteadystate()
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 1
+    ex.solverOptions['newton_preeq'] = False
+    ex.solverOptions['x0'] = np.array([0.532609637980272, 0.625849232840357, 0.066666666666667])
+    ex.solverOptions['sx0'] = np.array(
+        [[-0.425457638009506, 0.499939012301881, 0], [-0.375463736779318, -0.999878024603762, -0.000000000000000],
+         [0.375463736779318, -0.441193089396203, 0], [0.300370989423454, 0.799902419683010, 0.000000000000000],
+         [0.425457638009506, 0.941132101698086, 0.153505672866270]])
+    ex.solverOptions['atol'] = 10 ** -16
+    ex.solverOptions['rtol'] = 10 ** -12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 0
+
+    ex.writeToFile(filename, '/model_steadystate/sensifwdbyhandpreeq/')
+
+
+def writeSensiAdjByhandPreeq(filename):
+    ex = ExampleSteadystate()
+
+    ex.data = {}
+    ex.data['Y'] = np.array(
+        [[0.8410,1.6662,0.3813],
+        [0.7834,1.6230,0.2233],
+        [0.8187,1.5386,0.2208],
+        [0.7906,1.4476,0.2358],
+        [0.7184,1.3543,0.1409],
+        [0.6627,1.2840,0.1268],
+        [0.7099,1.1786,0.1289],
+        [0.7104,1.1362,0.1768],
+        [0.7089,1.0326,0.1127],
+        [0.6035,0.9752,0.0923]])
+    ex.data['Sigma_Y'] = np.ones(shape=ex.data['Y'].shape)
+    ex.data['Sigma_Z'] = []
+    ex.data['Z'] = []
+    ex.data['condition'] = ex.modelOptions['kappa']
+    ex.data['t'] = np.linspace(0, 5, 10)
+
+    ex.modelOptions['ts'] = np.linspace(0, 5, 10)
+    ex.solverOptions['sensi'] = 1
+    ex.solverOptions['sensi_meth'] = 2
+    ex.solverOptions['newton_preeq'] = False
+    ex.solverOptions['x0'] = np.array([0.532609637980272, 0.625849232840357, 0.066666666666667])
+    ex.solverOptions['sx0'] = np.array(
+        [[-0.425457638009506, 0.499939012301881, 0], [-0.375463736779318, -0.999878024603762, -0.000000000000000],
+         [0.375463736779318, -0.441193089396203, 0], [0.300370989423454, 0.799902419683010, 0.000000000000000],
+         [0.425457638009506, 0.941132101698086, 0.153505672866270]])
+    ex.solverOptions['atol'] = 10 ** -16
+    ex.solverOptions['rtol'] = 10 ** -12
+    ex.solverOptions['sens_ind'] = np.arange(0, ex.numP)
+    ex.solverOptions['linsol'] = 9
+    ex.solverOptions['maxsteps'] = 10000
+    ex.solverOptions['newton_maxsteps'] = 0
+
+    ex.writeToFile(filename, '/model_steadystate/sensiadjbyhandpreeq/')
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Must provide output file as first and only argument.")
+        sys.exit(1)
+    filename = sys.argv[1]
+
+    writeNoSensi(filename)
+    writeSensiForward(filename)
+    writeSensiForwardPlist(filename)
+    writeSensiForwardDense(filename)
+    writeNosensiSPBCG(filename)
+    writeSensiForwardErrorInt(filename)
+    writeSensiForwardErrorNewt(filename)
+    writeSensiFwdNewtonPreeq(filename)
+    writeSensiAdjNewtonPreeq(filename)
+    writeSensiFwdSimPreeq(filename)
+    writeSensiFwdSimPreeqFSA(filename)
+    writeSensiAdjSimPreeq(filename)
+    writeSensiAdjSimPreeqFSA(filename)
+    writeSensiFwdByhandPreeq(filename)
+    writeSensiAdjByhandPreeq(filename)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfigurationForExamples.sh b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfigurationForExamples.sh
new file mode 100644
index 0000000000000000000000000000000000000000..578228ee313957489db737c7273ce47b05e4024b
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/generateTestConfigurationForExamples.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+# Generate AMICI configuration for test models
+
+# AMICI root directory
+AMICI_PATH="`dirname \"$BASH_SOURCE\"`"
+AMICI_PATH="`( cd \"$AMICI_PATH/..\" && pwd )`"
+
+# File with test configuration
+TEST_FILE="${AMICI_PATH}/tests/cpputest/testOptions.h5"
+
+# Delete old config
+rm ${TEST_FILE}
+
+cd ${AMICI_PATH}/tests/generateTestConfig
+./example_dirac.py ${TEST_FILE}
+./example_events.py ${TEST_FILE}
+./example_jakstat.py ${TEST_FILE}
+./example_nested_events.py ${TEST_FILE}
+./example_neuron.py ${TEST_FILE}
+./example_robertson.py ${TEST_FILE}
+./example_steadystate.py ${TEST_FILE}
+./example_calvetti.py ${TEST_FILE}
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/pysb_test_models/bngwiki_egfr_simple_deletemolecules.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/pysb_test_models/bngwiki_egfr_simple_deletemolecules.py
new file mode 100644
index 0000000000000000000000000000000000000000..648072ebab90ffc204334a696e0d9cb30c80bbcf
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/pysb_test_models/bngwiki_egfr_simple_deletemolecules.py
@@ -0,0 +1,103 @@
+"""Translation of the BioNetGen example "egfr_simple" from the BNG wiki.
+
+added delete_molecules=True to egfr_dimer_degrade to conserve adapter proteins
+
+http://bionetgen.org/index.php/Egfr_simple
+"""
+
+from __future__ import print_function
+from pysb import *
+
+Model()
+
+Parameter('NA', 6.02e23)     # Avogadro's number (molecules/mol)
+Parameter('f', 1)            # Fraction of the cell to simulate
+Expression('Vo', f*1.0e-10)  # Extracellular volume=1/cell_density (L)
+Expression('V', f*3.0e-12)   # Cytoplasmic volume (L)
+
+# Initial amount of ligand (20 nM) converted to copies per cell
+Expression('EGF_init', 20*1e-9*NA*Vo)
+
+# Initial amounts of cellular components (copies per cell)
+Expression('EGFR_init', f*1.8e5)
+Expression('Grb2_init', f*1.5e5)
+Expression('Sos1_init', f*6.2e4)
+
+# Rate constants
+# Divide by NA*V to convert bimolecular rate constants from /M/sec to
+# /(molecule/cell)/sec
+Expression('kp1', 9.0e7/(NA*Vo))  # ligand-monomer binding
+Parameter('km1', 0.06)            # ligand-monomer dissociation
+Expression('kp2', 1.0e7/(NA*V))   # aggregation of bound monomers
+Parameter('km2', 0.1)             # dissociation of bound monomers
+Parameter('kp3', 0.5)             # dimer transphosphorylation
+Parameter('km3', 4.505)           # dimer dephosphorylation
+Expression('kp4', 1.5e6/(NA*V))   # binding of Grb2 to receptor
+Parameter('km4', 0.05)            # dissociation of Grb2 from receptor
+Expression('kp5', 1.0e7/(NA*V))   # binding of Grb2 to Sos1
+Parameter('km5', 0.06)            # dissociation of Grb2 from Sos1
+Parameter('deg', 0.01)            # degradation of receptor dimers
+
+
+Monomer('EGF', ['R'])
+Monomer('EGFR', ['L','CR1','Y1068'], {'Y1068':('U','P')})
+Monomer('Grb2', ['SH2','SH3'])
+Monomer('Sos1', ['PxxP'])
+
+
+Initial(EGF(R=None), EGF_init)
+Initial(EGFR(L=None, CR1=None, Y1068='U'), EGFR_init)
+Initial(Grb2(SH2=None, SH3=None), Grb2_init)
+Initial(Sos1(PxxP=None), Sos1_init)
+
+
+Observable('EGFR_tot', EGFR())
+Observable('Lig_free', EGF(R=None))
+Observable('Dim', EGFR(CR1=ANY), match='species')
+Observable('RP', EGFR(Y1068=('P',WILD)))
+Observable('Grb2Sos1', Grb2(SH2=None, SH3=1) % Sos1(PxxP=1))
+Observable('Sos1_act', EGFR(Y1068=1) % Grb2(SH2=1, SH3=2) % Sos1(PxxP=2))
+
+
+# Ligand-receptor binding
+Rule('egf_bind_egfr',
+     EGFR(L=None, CR1=None) + EGF(R=None) | EGFR(L=1, CR1=None) % EGF(R=1),
+     kp1, km1)
+
+# Receptor-aggregation
+Rule('egfr_dimerize',
+     EGFR(L=ANY, CR1=None) + EGFR(L=ANY, CR1=None) |
+     EGFR(L=ANY, CR1=1) % EGFR(L=ANY, CR1=1),
+     kp2, km2)
+
+# Transphosphorylation of EGFR by RTK
+Rule('egfr_transphos',
+     EGFR(CR1=ANY, Y1068='U') >> EGFR(CR1=ANY, Y1068='P'), kp3)
+
+# Dephosphorylation
+Rule('egfr_dephos',
+     EGFR(Y1068='P') >> EGFR(Y1068='U'), km3)
+
+# Grb2 binding to pY1068
+Rule('grb2_bind_egfr',
+     EGFR(Y1068='P') + Grb2(SH2=None) | EGFR(Y1068=('P',1)) % Grb2(SH2=1),
+     kp4, km4)
+
+# Grb2 binding to Sos1
+Rule('sos1_bind_grb2',
+     Grb2(SH3=None) + Sos1(PxxP=None) | Grb2(SH3=1) % Sos1(PxxP=1),
+     kp5, km5)
+
+# Receptor dimer internalization/degradation
+Rule('egfr_dimer_degrade',
+     EGF(R=1) % EGF(R=2) % EGFR(L=1, CR1=3) % EGFR(L=2, CR1=3) >> None,
+     deg,
+     delete_molecules=True)
+
+
+if __name__ == '__main__':
+    print(__doc__, "\n", model)
+    print("""
+NOTE: This model code is designed to be imported and programatically
+manipulated, not executed directly. The above output is merely a
+diagnostic aid.""")
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCMakeCompilation.sh b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCMakeCompilation.sh
new file mode 100644
index 0000000000000000000000000000000000000000..82003815855efa44973d73e70de3f568500cc5d4
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCMakeCompilation.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+#
+# Check that CMake build succeeds for one of the models generated during
+# Python tests
+#
+
+set -e
+
+SCRIPT_DIR=$(dirname $BASH_SOURCE)
+MODEL_DIR=${SCRIPT_DIR}/test_model_presimulation/
+
+cd ${MODEL_DIR}
+mkdir -p build
+cd build
+
+cmake ..
+make
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCPP.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCPP.py
new file mode 100644
index 0000000000000000000000000000000000000000..34ea25daa7c7e36abf3016c954b4c869cba73771
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCPP.py
@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+
+import sys
+import amici
+import unittest
+import os
+import numbers
+import pysb
+import importlib
+import copy
+
+class TestAmiciCPP(unittest.TestCase):
+    '''
+    TestCase class for testing cpp API through swig
+    '''
+
+    expectedResultsFile = os.path.join(os.path.dirname(__file__),
+                                       'cpputest', 'expectedResults.h5')
+
+    def setUp(self):
+        self.resetdir = os.getcwd()
+        self.default_path = copy.copy(sys.path)
+
+        pysb.SelfExporter.cleanup()  # reset pysb
+        pysb.SelfExporter.do_export = True
+
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..',
+                                        'python', 'examples',
+                                        'example_presimulation'))
+        if 'createModelPresimulation' in sys.modules:
+            importlib.reload(sys.modules['createModelPresimulation'])
+            model_module = sys.modules['createModelPresimulation']
+        else:
+            model_module = importlib.import_module('createModelPresimulation')
+        model = copy.deepcopy(model_module.model)
+        model.name = 'test_model_presimulation_pysb'
+        amici.pysb2amici(model,
+                         model.name,
+                         verbose=False,
+                         observables=['pPROT_obs'],
+                         constant_parameters=['DRUG_0', 'KIN_0'])
+        sys.path.insert(0, model.name)
+        import test_model_presimulation_pysb as modelModulePYSB
+        self.model = modelModulePYSB.getModel()
+        self.solver = self.model.getSolver()
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.test_copy_constructors()
+        self.test_version_number()
+
+    def test_version_number(self):
+        self.assertEqual(self.model.getAmiciVersion(), amici.__version__)
+        self.assertEqual(self.model.getAmiciCommit(), amici.__commit__)
+
+    def test_copy_constructors(self):
+        # TODO: expand this to serialization
+        for obj in [self.model, self.solver]:
+            for attr in dir(obj):
+                if attr.startswith('__') \
+                        or attr == 'this' \
+                        or is_callable_but_not_getter(obj, attr):
+                    continue
+
+                with self.subTest(obj=obj, attr=attr):
+                    # objects will be initialized with default values so we
+                    # can check if the clone routine does the right thing by
+                    # modifying the value from default, cloning and checking
+                    # if the change was carried over to the clone
+                    val = get_val(obj, attr)
+
+                    try:
+                        modval = get_mod_val(val, attr)
+                    except ValueError:
+                        # happens for everything that is not bool or scalar
+                        continue
+
+                    try:
+                        set_val(obj, attr, modval)
+                    except AttributeError:
+                        # some attributes cannot be set
+                        continue
+
+                    obj_clone = obj.clone()
+
+                    self.assertEqual(
+                        get_val(obj, attr),
+                        get_val(obj_clone, attr)
+                    )
+
+
+def is_callable_but_not_getter(obj, attr):
+    if not callable(getattr(obj, attr)):
+        return False
+
+    if attr.startswith('get'):
+        return \
+            'set' + attr[3:] not in dir(obj) \
+            or attr.endswith('ById') \
+            or attr.endswith('ByName')
+    else:
+        return True
+
+
+def get_val(obj, attr):
+    if callable(getattr(obj, attr)):
+        return getattr(obj, attr)()
+    else:
+        return getattr(obj, attr)
+
+
+def get_mod_val(val, attr):
+    if attr == 'getStabilityLimitFlag':
+        return val - 1
+    elif isinstance(val, bool):
+        return not val
+    elif isinstance(val, numbers.Number):
+        return val + 1
+
+    raise ValueError('Cannot modify value')
+
+
+def set_val(obj, attr, val):
+    if callable(getattr(obj, attr)):
+        getattr(obj, 'set' + attr[3:])(
+            val
+        )
+    else:
+        setattr(obj, attr, val)
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciCPP())
+    unittest.main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCoverage.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCoverage.py
new file mode 100644
index 0000000000000000000000000000000000000000..64a0eff217627df1e36ce43e3d7fa9e5151c8489
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testCoverage.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+
+"""
+Generate coverage reports for the testModels and testSBML scripts
+exported format is cobertura xml
+"""
+import coverage
+# only consider amici module and ignore the swig generated amici.py
+cov = coverage.Coverage(
+    source=['amici'],
+    omit=['*/amici.py','*/amici_without_hdf5.py']
+)
+
+# ignore code blocks containing import statements
+cov.exclude('import')
+cov.set_option('report:exclude_lines', ['pragma: no cover', ' raise ',
+                                        'except:'])
+
+# coverage needs to be started before all other imports such that everything
+# that happens during module import is also added to the report
+cov.start()
+
+import unittest
+import sys
+
+import testModels
+import testSBML
+import testPandas
+import testPYSB
+import testCPP
+import testMisc
+import testPreequilibration
+
+test_modules = (
+    testSBML, testModels, testPandas, testPYSB, testCPP, testMisc,
+    testPreequilibration,
+)
+
+suite = unittest.TestSuite()
+loader = unittest.TestLoader()
+for test_module in test_modules:
+    tests = loader.loadTestsFromModule(test_module)
+    suite.addTests(tests)
+
+testRunner = unittest.TextTestRunner(verbosity=0)
+result = testRunner.run(suite)
+
+cov.stop()
+cov.xml_report(outfile='coverage_py.xml')
+
+# propagate failure
+sys.exit(not result.wasSuccessful())
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testMisc.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testMisc.py
new file mode 100644
index 0000000000000000000000000000000000000000..d34c7814aee13b63465b4954620a68d7877a2ad3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testMisc.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+
+"""Miscellaneous AMICI Python interface tests"""
+
+import amici
+import sys
+import copy
+import os
+import unittest
+import sympy as sp
+import libsbml
+from tempfile import TemporaryDirectory
+
+
+class TestAmiciMisc(unittest.TestCase):
+    """TestCase class various AMICI Python interface functions"""
+
+    def setUp(self):
+        self.default_path = copy.copy(sys.path)
+        self.resetdir = os.getcwd()
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.test_parameterScalingFromIntVector()
+
+    def test_parameterScalingFromIntVector(self):
+        """Ensure we can generate a ParameterScaling vector from Python"""
+        scale_vector = amici.parameterScalingFromIntVector(
+            [
+                amici.ParameterScaling_log10,
+                amici.ParameterScaling_ln,
+                amici.ParameterScaling_none
+            ])
+        assert scale_vector[0] == amici.ParameterScaling_log10
+        assert scale_vector[1] == amici.ParameterScaling_ln
+        assert scale_vector[2] == amici.ParameterScaling_none
+
+    def test_csc_matrix(self):
+        """Test sparse CSC matrix creation"""
+        matrix = sp.Matrix([[1, 0], [2, 3]])
+        symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix = \
+            amici.ode_export.csc_matrix(matrix, 'a')
+
+        assert symbolColPtrs == [0, 2, 3]
+        assert symbolRowVals == [0, 1, 1]
+        assert sparseList == sp.Matrix([[1], [2], [3]])
+        assert symbolList == ['a0', 'a1', 'a2']
+        assert str(sparseMatrix) == 'Matrix([[a0, 0], [a1, a2]])'
+
+    def test_csc_matrix_empty(self):
+        """Test sparse CSC matrix creation for empty matrix"""
+        matrix = sp.Matrix()
+        symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix = \
+            amici.ode_export.csc_matrix(matrix, 'a')
+        print(symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix)
+        assert symbolColPtrs == [0]
+        assert symbolRowVals == []
+        assert sparseList == sp.Matrix(0, 0, [])
+        assert symbolList == []
+        assert str(sparseMatrix) == 'Matrix(0, 0, [])'
+
+    def test_csc_matrix_vector(self):
+        """Test sparse CSC matrix creation from matrix slice"""
+        matrix = sp.Matrix([[1, 0], [2, 3]])
+        symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix = \
+            amici.ode_export.csc_matrix(matrix[:, 0], 'a')
+
+        assert symbolColPtrs == [0, 2]
+        assert symbolRowVals == [0, 1]
+        assert sparseList == sp.Matrix([[1], [2]])
+        assert symbolList == ['a0', 'a1']
+        assert str(sparseMatrix) == 'Matrix([[a0], [a1]])'
+
+        '''Test continuation of numbering of symbols'''
+        symbolColPtrs, symbolRowVals, sparseList, symbolList, sparseMatrix = \
+            amici.ode_export.csc_matrix(matrix[:, 1], 'a',
+                                        base_index=len(symbolList))
+
+        assert symbolColPtrs == [0, 1]
+        assert symbolRowVals == [1]
+        assert sparseList == sp.Matrix([[3]])
+        assert symbolList == ['a2']
+        assert str(sparseMatrix) == 'Matrix([[0], [a2]])'
+
+    def test_sbml2amici_no_observables(self):
+        """Test model generation works for model without observables"""
+
+        document = libsbml.SBMLDocument(3, 1)
+        model = document.createModel()
+        model.setTimeUnits("second")
+        model.setExtentUnits("mole")
+        model.setSubstanceUnits('mole')
+        c1 = model.createCompartment()
+        c1.setId('C1')
+        model.addCompartment(c1)
+        s1 = model.createSpecies()
+        s1.setId('S1')
+        s1.setCompartment('C1')
+        model.addSpecies(s1)
+
+        sbml_importer = amici.sbml_import.SbmlImporter(sbml_source=model,
+                                                       from_file=False)
+        tmpdir = TemporaryDirectory()
+        sbml_importer.sbml2amici(modelName="test",
+                                 output_dir=tmpdir.name,
+                                 observables=None)
+
+    def test_constant_species_to_parameters(self):
+        # test function from bin/amici_import_petab which is not really
+        # a package module
+        sys.path.append(os.path.join(
+            os.path.abspath(os.path.split(__file__)[0]),
+            '..', 'python', 'sdist', 'bin'))
+        try:
+            # skip that if PEtab is not installed which causes the import
+            # to fail
+            from amici_import_petab import constant_species_to_parameters
+        except ModuleNotFoundError:
+            return
+
+        document = libsbml.SBMLDocument(3, 1)
+        model = document.createModel()
+        model.setTimeUnits("second")
+        model.setExtentUnits("mole")
+        model.setSubstanceUnits('mole')
+
+        s = model.createSpecies()
+        s.setId('x1')
+        s.setConstant(True)
+        s.setInitialConcentration(1.0)
+
+        # Ensure species is replaced in reactions
+        r = model.createReaction()
+        r.setId('r1')
+        # Add multiple instances to ensure all are removed
+        for (coeff, name) in [(1, 'x1'), (1, 'x1')]:
+            species_ref = r.createReactant()
+            species_ref.setSpecies(name)
+            species_ref.setStoichiometry(coeff)
+        for (coeff, name) in [(1, 'x1'), (1, 'x1')]:
+            species_ref = r.createProduct()
+            species_ref.setSpecies(name)
+            species_ref.setStoichiometry(coeff)
+        for name in ['x1', 'x1']:
+            species_ref = r.createModifier()
+            species_ref.setSpecies(name)
+
+        constant_species_to_parameters(model)
+
+        assert len(list(model.getListOfParameters())) == 1
+        assert len(list(model.getListOfSpecies())) == 0
+        assert len(list(r.getListOfReactants())) == 0
+        assert len(list(r.getListOfProducts())) == 0
+        assert len(list(r.getListOfModifiers())) == 0
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciMisc())
+    unittest.main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testModels.m b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testModels.m
new file mode 100644
index 0000000000000000000000000000000000000000..3c431b602d2c3736be2883a96bd62232ba0c025f
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testModels.m
@@ -0,0 +1,180 @@
+% Run AMICI Matlab tests using pre-generated models and test setup
+
+function testModels()
+    % disable specific warnings for these tests, some tests are supposed
+    % to produce warnings
+    warningreset = warning;
+    warning('off','AMICI:mex:simulation')
+    warning('off','AMICI:mex:CVODES:CVode:TOO_MUCH_WORK')
+
+    ignoredTests = {'/model_jakstat_adjoint/sensiadjointemptysensind', ...
+                    '/model_jakstat_adjoint/sensiforwardemptysensind'};
+
+    cd(fileparts(mfilename('fullpath')))
+    addpath(genpath('cpputest'));
+    wrapTestModels()
+    cd(fileparts(mfilename('fullpath')))
+
+    hdf5file = fullfile(fileparts(mfilename('fullpath')),'cpputest','expectedResults.h5');
+
+    info = h5info(hdf5file);
+    for imodel = 1:length(info.Groups)
+        if(~isempty(regexp(info.Groups(imodel).Name(2:end),'^model_neuron')))
+            model_atol = 1e-9;
+            model_rtol = 1e-4;
+        else
+            model_atol = 1e-10;
+            model_rtol = 1e-5;
+        end
+        for itest = 1:length(info.Groups(imodel).Groups)
+            if(ismember(info.Groups(imodel).Groups(itest).Name, ignoredTests))
+                continue
+            end
+
+            [results,options,data,t,theta,kappa] = readDataFromHDF5(info.Groups(imodel).Groups(itest),hdf5file);
+            sol = getResults(info.Groups(imodel).Name(2:end),options,data,t,theta,kappa);
+            compareResults(sol,results);
+        end
+    end
+
+    warning(warningreset);
+
+    %% begin nested functions
+
+    function sol = getResults(modelname,options,data,t,theta,kappa)
+        theta = options.theta;
+        options = rmfield(options,'theta');
+        kappa = options.kappa;
+        options = rmfield(options,'kappa');
+        t = options.ts;
+        options = rmfield(options,'ts');
+        ami_options = amioption(options);
+        if(~isempty(data))
+            ami_data = amidata(data);
+        else
+            ami_data = [];
+        end
+        sol = feval(['simulate_' modelname],t,theta,kappa,ami_data,ami_options);
+    end
+
+    function compareResults(sol,results)
+        if(results.status<0)
+            assert(sol.status<0)
+            return
+        end
+
+        for ifield = transpose(fieldnames(sol))
+            if(strcmp(ifield{1},'diagnosis'))
+                for jfield = transpose(fieldnames(sol.diagnosis))
+                    if(~ismember(jfield{1},{'newton_cpu_time'}))
+                        checkAgreement(sol.diagnosis,results.diagnosis,jfield{1},0,1);
+                    end
+                end
+            else
+                if(~ismember(ifield,{'chi2'}))
+                    if(~isempty(sol.s2llh))
+                        if(ismember(ifield,{'s2llh'}))
+                            checkAgreement(sol,results,ifield{1},1e-4,1e-3)
+                        elseif(ismember(ifield,{'x','sx','s2x','y','sy','s2y','z','sz','s2z','rz','srz','s2rz','sigmay','ssigmay','s2sigmay','sigmaz','ssigmaz','s2sigmaz','x0','sx0'}))
+                            % TODO: reimplement this as soon as #264 is done
+                        else
+                            checkAgreement(sol,results,ifield{1})
+                        end
+                    else
+                        checkAgreement(sol,results,ifield{1})
+                    end
+                end
+            end
+        end
+    end
+
+    function checkAgreement(sol,results,fieldname,atol,rtol)
+        if(~isfield(results,fieldname))
+            assert(isempty(sol.(fieldname)))
+            return
+        end
+        expected = results.(fieldname);
+        actual = sol.(fieldname);
+        if(nargin<4)
+            atol = model_atol;
+        end
+        if(nargin<5)
+            rtol = model_rtol;
+        end
+        if(~isempty(expected))
+            assert(~isempty(actual));
+            actual = actual(:);
+            expected = expected(:);
+            assert(all(isnan(actual)==isnan(expected)));
+            actual = actual(~isnan(actual));
+            expected = expected(~isnan(actual));
+            assert(all(isinf(actual)==isinf(expected)));
+            actual = actual(~isinf(actual));
+            expected = expected(~isinf(actual));
+            assert(all(abs(expected - actual) <= atol) || all(abs((expected - actual) ./ (rtol + abs(expected))) <= rtol));
+        end
+    end
+
+    function [results,options,data,t,theta,kappa] = readDataFromHDF5(groups,hdf5file);
+        data = [];
+        t = [];
+        theta = [];
+        kappa = [];
+        for igroup = 1:length(groups.Groups)
+            group = groups.Groups(igroup);
+            [~,name] = fileparts(group.Name);
+            eval([name ' =  hdf2struct(group,''' group.Name ''',hdf5file);']);
+        end
+        if(isfield(options, 'sens_ind'))
+            % adapt to base 1 indexing
+            options.sens_ind = options.sens_ind + 1;
+        end
+        if(~isempty(data))
+            if(length(data.t)~=size(data.Y,1)) % no idea why this goes wrong only _sometimes_
+                data.Y = transpose(data.Y);
+                data.Sigma_Y = transpose(data.Sigma_Y);
+            end
+            if(size(data.Z,2)>0) % don't ask ...
+                data.Z = transpose(data.Z);
+                data.Sigma_Z = transpose(data.Sigma_Z);
+            end
+        end
+    end
+
+
+
+    function matlab = cpp2matlab(cpp)
+        dims = size(cpp);
+        if(sum(dims>1)>1 || length(dims)>2)
+            switch(length(dims))
+                case 3
+                    matlab = permute(cpp,[3,1,2]);
+                case 2
+                    matlab = transpose(cpp);
+                otherwise
+                    matlab = cpp;
+            end
+        else
+            matlab = cpp;
+        end
+        matlab = double(matlab);
+    end
+
+    function s = hdf2struct(group,hdf5path,hdf5file)
+        s = struct;
+        if(~isempty(group.Attributes))
+            for attr = {group.Attributes.Name};
+                s.(attr{1}) = double(h5readatt(hdf5file,hdf5path,attr{1}));
+            end
+        end
+        if(~isempty(group.Datasets))
+            for data = {group.Datasets.Name};
+                s.(data{1}) = cpp2matlab(h5read(hdf5file,[hdf5path '/' data{1}]));
+            end
+        end
+        for igroup = 1:length(group.Groups);
+            [~,name] = fileparts(group.Groups(igroup).Name);
+            s.(name) = hdf2struct(group.Groups(igroup),[hdf5path '/' name],hdf5file);
+        end
+    end
+end
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testModels.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testModels.py
new file mode 100644
index 0000000000000000000000000000000000000000..527fc1b57a2cbeac67d883a625565cab3fa795b9
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testModels.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+
+import sys
+import h5py
+import amici
+import unittest
+import importlib
+import os
+import copy
+from amici.gradient_check import check_derivatives, check_results
+
+
+class TestAmiciPregeneratedModel(unittest.TestCase):
+    """
+    TestCase class for tests that were pregenerated using the the matlab code
+    generation routines and cmake build routines
+
+    NOTE: requires having run `make python-tests` in /build/ before to build
+    the python modules for the test models
+    """
+
+    expectedResultsFile = os.path.join(os.path.dirname(__file__),
+                                       'cpputest', 'expectedResults.h5')
+
+    def setUp(self):
+        self.default_path = copy.copy(sys.path)
+        self.resetdir = os.getcwd()
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        """
+        test runner routine that loads data expectedResults.h5 hdf file and
+        runs individual models/settings as subTests
+        """
+        expected_results = h5py.File(self.expectedResultsFile, 'r')
+
+        for subTest in expected_results.keys():
+            for case in list(expected_results[subTest].keys()):
+                if case.startswith('sensi2'):
+                    model_name = subTest + '_o2'
+                else:
+                    model_name = subTest
+
+                with self.subTest(modelName=model_name, caseName=case):
+                    print(f'running {model_name}::{case}')
+
+                    def assert_fun(x):
+                        return self.assertTrue(x)
+
+                    model_swig_folder = \
+                        os.path.join(os.path.dirname(__file__), '..',
+                                     'build', 'tests', 'cpputest',
+                                     f'external_{model_name}-prefix',
+                                     'src', f'external_{model_name}-build',
+                                     'swig')
+                    sys.path.insert(0, model_swig_folder)
+                    test_model_module = importlib.import_module(model_name)
+                    self.model = test_model_module.getModel()
+                    self.solver = self.model.getSolver()
+                    amici.readModelDataFromHDF5(
+                        self.expectedResultsFile, self.model.get(),
+                        f'/{subTest}/{case}/options'
+                    )
+                    amici.readSolverSettingsFromHDF5(
+                        self.expectedResultsFile, self.solver.get(),
+                        f'/{subTest}/{case}/options'
+                    )
+
+                    edata = None
+                    if 'data' in expected_results[subTest][case].keys():
+                        edata = amici.readSimulationExpData(
+                            self.expectedResultsFile,
+                            f'/{subTest}/{case}/data', self.model.get()
+                        )
+                    rdata = amici.runAmiciSimulation(self.model, self.solver,
+                                                     edata)
+
+                    check_derivative_opts = dict()
+
+                    if model_name == 'model_nested_events':
+                        check_derivative_opts['rtol'] = 1e-2
+                    elif model_name == 'model_events':
+                        check_derivative_opts['atol'] = 1e-3
+
+                    if edata \
+                            and self.solver.getSensitivityMethod() \
+                            and self.solver.getSensitivityOrder() \
+                            and len(self.model.getParameterList()) \
+                            and not model_name.startswith('model_neuron') \
+                            and not case.endswith('byhandpreeq'):
+                        check_derivatives(self.model, self.solver, edata,
+                                          assert_fun, **check_derivative_opts)
+
+                    verify_simulation_opts = dict()
+
+                    if model_name.startswith('model_neuron'):
+                        verify_simulation_opts['atol'] = 1e-5
+                        verify_simulation_opts['rtol'] = 1e-2
+          
+                    if model_name.startswith('model_robertson') and \
+                            case == 'sensiforwardSPBCG':
+                        verify_simulation_opts['atol'] = 1e-3
+                        verify_simulation_opts['rtol'] = 1e-3
+                  
+                    verify_simulation_results(
+                        rdata, expected_results[subTest][case]['results'],
+                        assert_fun, **verify_simulation_opts
+                    )
+
+                    if model_name == 'model_steadystate' and \
+                            case == 'sensiforwarderrorint':
+                        edata = amici.amici.ExpData(self.model.get())
+
+                    if edata and model_name != 'model_neuron_o2' and not (
+                        model_name == 'model_robertson' and
+                        case == 'sensiforwardSPBCG'
+                    ):
+                        # Test runAmiciSimulations: ensure running twice
+                        # with same ExpData yields same results
+                        if isinstance(edata, amici.amici.ExpData):
+                            edatas = [edata, edata]
+                        else:
+                            edatas = [edata.get(), edata.get()]
+
+                        rdatas = amici.runAmiciSimulations(
+                            self.model, self.solver, edatas, num_threads=2,
+                            failfast=False
+                        )
+                        verify_simulation_results(
+                            rdatas[0],
+                            expected_results[subTest][case]['results'],
+                            assert_fun, **verify_simulation_opts
+                        )
+                        verify_simulation_results(
+                            rdatas[1],
+                            expected_results[subTest][case]['results'],
+                            assert_fun, **verify_simulation_opts
+                        )
+
+                    self.assertRaises(
+                        RuntimeError,
+                        self.model.getParameterByName,
+                        'thisParameterDoesNotExist'
+                    )
+
+
+def verify_simulation_results(rdata, expected_results, assert_fun,
+                              atol=1e-8, rtol=1e-4):
+    """
+    compares all fields of the simulation results in rdata against the
+    expectedResults using the provided tolerances
+
+    Arguments:
+        rdata: simulation results as returned by amici.runAmiciSimulation
+        expected_results: stored test results
+        atol: absolute tolerance
+        rtol: relative tolerance
+    """
+
+    if expected_results.attrs['status'][0] != 0:
+        assert rdata['status'] == expected_results.attrs['status'][0]
+        return
+
+    for field in expected_results.keys():
+        if field == 'diagnosis':
+            for subfield in ['J', 'xdot']:
+                check_results(rdata, subfield,
+                              expected_results[field][subfield][()],
+                              assert_fun, 1e-8, 1e-8)
+        else:
+            if field == 's2llh':
+                check_results(rdata, field, expected_results[field][()],
+                              assert_fun, 1e-4, 1e-3)
+            else:
+                check_results(rdata, field, expected_results[field][()],
+                              assert_fun, atol, rtol)
+
+    for attr in expected_results.attrs.keys():
+        check_results(rdata, attr, expected_results.attrs[attr], assert_fun,
+                      atol, rtol)
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciPregeneratedModel())
+    unittest.main()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPYSB.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPYSB.py
new file mode 100644
index 0000000000000000000000000000000000000000..1092fb20120656c4de04df1073943224afa0e4ce
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPYSB.py
@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+
+import sys
+import amici
+import unittest
+import os
+import platform
+import importlib
+import copy
+import numpy as np
+from pysb.simulator import ScipyOdeSimulator
+
+import pysb.examples
+
+class TestAmiciPYSBModel(unittest.TestCase):
+    '''
+    TestCase class for testing SBML import and simulation from AMICI python
+    interface
+    '''
+
+    expectedResultsFile = os.path.join(os.path.dirname(__file__),
+                                       'cpputest', 'expectedResults.h5')
+
+    def setUp(self):
+        self.default_path = copy.copy(sys.path)
+        self.resetdir = os.getcwd()
+
+        if os.path.dirname(__file__) != '':
+            os.chdir(os.path.dirname(__file__))
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.test_compare_to_sbml_import()
+        self.test_compare_to_pysb_simulation()
+
+    def test_compare_to_sbml_import(self):
+        constant_parameters = ['DRUG_0', 'KIN_0']
+
+        # -------------- PYSB -----------------
+
+        pysb.SelfExporter.cleanup()  # reset pysb
+        pysb.SelfExporter.do_export = True
+
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..',
+                                        'python', 'examples',
+                                        'example_presimulation'))
+        if 'createModelPresimulation' in sys.modules:
+            importlib.reload(sys.modules['createModelPresimulation'])
+            model_module = sys.modules['createModelPresimulation']
+        else:
+            model_module = importlib.import_module('createModelPresimulation')
+        model = copy.deepcopy(model_module.model)
+        model.name = 'test_model_presimulation_pysb'
+        outdir_pysb = model.name
+        amici.pysb2amici(model,
+                         outdir_pysb,
+                         verbose=False,
+                         observables=['pPROT_obs'],
+                         constant_parameters=constant_parameters)
+        sys.path.insert(0, outdir_pysb)
+        modelModulePYSB = importlib.import_module(outdir_pysb)
+        model_pysb = modelModulePYSB.getModel()
+
+        edata = get_data(model_pysb)
+
+        rdata_pysb = get_results(model_pysb, edata)
+
+        # -------------- SBML -----------------
+
+        sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
+                                'examples', 'example_presimulation',
+                                'model_presimulation.xml')
+
+        sbmlImporter = amici.SbmlImporter(sbmlFile)
+
+        observables = amici.assignmentRules2observables(
+            sbmlImporter.sbml,  # the libsbml model object
+            filter_function=lambda variable: variable.getName() == 'pPROT_obs'
+        )
+        outdir_sbml = 'test_model_presimulation_sbml'
+        sbmlImporter.sbml2amici('test_model_presimulation_sbml',
+                                outdir_sbml,
+                                verbose=False,
+                                observables=observables,
+                                constantParameters=constant_parameters)
+        sys.path.insert(0, outdir_sbml)
+        modelModuleSBML = importlib.import_module(outdir_sbml)
+        model_sbml = modelModuleSBML.getModel()
+
+        rdata_sbml = get_results(model_sbml, edata)
+
+        # check if preequilibration fixed parameters are correctly applied:
+        for rdata, model in zip([rdata_sbml, rdata_pysb],
+                                [model_sbml, model_pysb]):
+            # check equilibrium fixed parameters
+            with self.subTest(fixed_pars='preequilibration'):
+                self.assertTrue(np.isclose(
+                    [
+                        sum(rdata["x_ss"][[1, 3]]),
+                        sum(rdata["x_ss"][[2, 4]])
+                    ],
+                    edata.fixedParametersPreequilibration,
+                    atol=1e-6, rtol=1e-6
+                ).all())
+                # check equilibrium initial parameters
+                self.assertTrue(np.isclose(
+                    sum(rdata["x_ss"][[0, 3, 4, 5]]),
+                    model.getParameterByName('PROT_0'),
+                    atol=1e-6, rtol=1e-6
+                ))
+            with self.subTest(fixed_pars='simulation'):
+                # check reinitialization with fixed parameter after
+                # presimulation
+                self.assertTrue(np.isclose(
+                    [rdata["x0"][1], rdata["x0"][2]],
+                    edata.fixedParameters,
+                    atol=1e-6, rtol=1e-6
+                ).all())
+
+        for field in rdata_pysb:
+            if field not in ['ptr', 't_steadystate', 'numsteps',
+                             'newton_numsteps', 'numrhsevals',
+                             'numerrtestfails', 'order', 'J', 'xdot',
+                             'wrms_steadystate', 'newton_cpu_time',
+                             'cpu_time', 'cpu_timeB', ]:
+                with self.subTest(field=field):
+                    if rdata_pysb[field] is None:
+                        self.assertIsNone(
+                            rdata_sbml[field],
+                        )
+                    elif rdata_sbml[field] is None:
+                        self.assertIsNone(
+                            rdata_pysb[field],
+                        )
+                    else:
+                        self.assertTrue(np.isclose(
+                            rdata_sbml[field],
+                            rdata_pysb[field],
+                            atol=1e-6, rtol=1e-6
+                        ).all())
+
+    def test_compare_to_pysb_simulation(self):
+
+        sys.path.insert(0, os.path.dirname(pysb.examples.__file__))
+
+        pysb_models = [
+            'tyson_oscillator', 'robertson', 'expression_observables',
+            'bax_pore_sequential', 'bax_pore', 'bngwiki_egfr_simple',
+            'bngwiki_enzymatic_cycle_mm', 'bngwiki_simple', 'earm_1_0',
+            'earm_1_3', 'move_connected', 'michment', 'kinase_cascade',
+            'hello_pysb', 'fricker_2010_apoptosis', 'explicit',
+            'fixed_initial',
+        ]
+
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..',
+                                        'tests', 'pysb_test_models'))
+
+        custom_models = [
+            'bngwiki_egfr_simple_deletemolecules',
+        ]
+
+        atol = 1e-8
+        rtol = 1e-8
+
+        for example in pysb_models + custom_models:
+            with self.subTest(example=example):
+
+                if example == 'earm_1_3' \
+                        and platform.sys.version_info[0] == 3 \
+                        and platform.sys.version_info[1] < 7:
+                    continue
+
+                # load example
+
+                pysb.SelfExporter.cleanup()  # reset pysb
+                pysb.SelfExporter.do_export = True
+
+                module = importlib.import_module(example)
+                pysb_model = module.model
+                pysb_model.name = pysb_model.name.replace('pysb.examples.', '')
+                # avoid naming clash for custom pysb models
+                pysb_model.name += '_amici'
+
+                # pysb part
+
+                tspan = np.linspace(0, 100, 101)
+                sim = ScipyOdeSimulator(
+                    pysb_model,
+                    tspan=tspan,
+                    integrator_options={'rtol': rtol, 'atol': atol},
+                    compiler='python'
+                )
+                pysb_simres = sim.run()
+
+                # amici part
+
+                outdir = pysb_model.name
+
+                if pysb_model.name in ['move_connected_amici']:
+                    self.assertRaises(
+                        Exception,
+                        amici.pysb2amici,
+                        *[pysb_model, outdir],
+                        **{'verbose': False, 'compute_conservation_laws': True}
+                    )
+                    compute_conservation_laws = False
+                else:
+                    compute_conservation_laws = True
+
+                amici.pysb2amici(
+                    pysb_model,
+                    outdir,
+                    verbose=False,
+                    compute_conservation_laws=compute_conservation_laws
+                )
+                sys.path.insert(0, outdir)
+
+                amici_model_module = importlib.import_module(pysb_model.name)
+
+                model_pysb = amici_model_module.getModel()
+
+                model_pysb.setTimepoints(tspan)
+
+                solver = model_pysb.getSolver()
+                solver.setMaxSteps(int(1e5))
+                solver.setAbsoluteTolerance(atol)
+                solver.setRelativeTolerance(rtol)
+                rdata = amici.runAmiciSimulation(model_pysb, solver)
+
+                # check agreement of species simulation
+
+                self.assertTrue(np.isclose(
+                    rdata['x'],
+                    pysb_simres.species,
+                    1e-4, 1e-4
+                ).all())
+
+
+def get_data(model):
+    solver = model.getSolver()
+    model.setTimepoints(np.linspace(0, 60, 61))
+    model.setReinitializeFixedParameterInitialStates(True)
+    model.setSteadyStateSensitivityMode(
+        amici.SteadyStateSensitivityMode_simulationFSA
+    )
+
+    rdata = amici.runAmiciSimulation(model, solver)
+    edata = amici.ExpData(rdata, 0.1, 0.0)
+    edata.t_presim = 2
+    edata.fixedParameters = [10, 2]
+    edata.fixedParametersPresimulation = [3, 2]
+    edata.fixedParametersPreequilibration = [3, 0]
+    return edata
+
+
+def get_results(model, edata):
+    solver = model.getSolver()
+    solver.setSensitivityOrder(1)
+    model.setTimepoints(np.linspace(0, 60, 61))
+    model.setReinitializeFixedParameterInitialStates(True)
+    model.setSteadyStateSensitivityMode(
+        amici.SteadyStateSensitivityMode_simulationFSA
+    )
+    return amici.runAmiciSimulation(model, solver, edata)
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciPYSBModel())
+    unittest.main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPandas.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPandas.py
new file mode 100644
index 0000000000000000000000000000000000000000..279b60e8c3e2429fc8fe4f3da6edf30d4f6fe302
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPandas.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+
+import sys
+import amici
+import unittest
+import os
+import copy
+import numpy as np
+import itertools
+
+class TestAmiciPandasImportExport(unittest.TestCase):
+    '''
+    TestCase class for testing csv import using pandas
+    '''
+
+    def setUp(self):
+        self.default_path = copy.copy(sys.path)
+        self.resetdir = os.getcwd()
+
+        if os.path.dirname(__file__) != '':
+            os.chdir(os.path.dirname(__file__))
+
+        sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
+                                'examples', 'example_presimulation',
+                                'model_presimulation.xml')
+
+        sbmlImporter = amici.SbmlImporter(sbmlFile)
+
+        constantParameters = ['DRUG_0', 'KIN_0']
+
+        observables = amici.assignmentRules2observables(
+            sbmlImporter.sbml,  # the libsbml model object
+            filter_function=lambda variable: variable.getName() == 'pPROT'
+        )
+        outdir = 'test_model_presimulation'
+        sbmlImporter.sbml2amici('test_model_presimulation',
+                                outdir,
+                                verbose=False,
+                                observables=observables,
+                                constantParameters=constantParameters)
+        sys.path.insert(0, outdir)
+        import test_model_presimulation as modelModule
+        self.model = modelModule.getModel()
+        self.model.setTimepoints(np.linspace(0, 60, 61))
+        self.solver = self.model.getSolver()
+        rdata = amici.runAmiciSimulation(self.model, self.solver)
+        self.edata = [amici.ExpData(rdata, 0.01, 0)]
+        # test copy constructor
+        self.edata_copy = amici.ExpData(self.edata[0])
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.tests_presimulation()
+
+    def tests_presimulation(self):
+        self.model.getFixedParameterNames()
+        combos = itertools.product(
+            [(10, 5), (5, 10), ()],
+            repeat=3
+        )
+        cases = dict()
+        for icombo, combo in enumerate(combos):
+            cases[f'{icombo}'] = {
+                'fixedParameters': combo[0],
+                'fixedParametersPreequilibration': combo[1],
+                'fixedParametersPresimulation': combo[2],
+            }
+
+        for case in cases:
+            with self.subTest(**cases[case]):
+                for fp in cases[case]:
+                    setattr(self.edata[0], fp, cases[case][fp])
+
+                df_edata = amici.getDataObservablesAsDataFrame(
+                    self.model,
+                    self.edata
+                )
+                edata_reconstructed = amici.getEdataFromDataFrame(
+                    self.model,
+                    df_edata
+                )
+
+                for fp in ['fixedParameters', 'fixedParametersPreequilibration',
+                           'fixedParametersPresimulation']:
+
+                    if fp != 'fixedParameters' or cases[case][fp] is not ():
+                        self.assertTupleEqual(
+                            getattr(self.edata[0], fp),
+                            getattr(edata_reconstructed[0], fp),
+                        )
+
+                        self.assertTupleEqual(
+                            cases[case][fp],
+                            getattr(edata_reconstructed[0], fp),
+                        )
+
+                        self.assertTupleEqual(
+                            getattr(self.edata[0], fp),
+                            cases[case][fp],
+                        )
+                    else:
+                        self.assertTupleEqual(
+                            self.model.getFixedParameters(),
+                            getattr(edata_reconstructed[0], fp),
+                        )
+
+                        self.assertTupleEqual(
+                            self.model.getFixedParameters(),
+                            getattr(edata_reconstructed[0], fp),
+                        )
+
+                        self.assertTupleEqual(
+                            getattr(self.edata[0], fp),
+                            cases[case][fp],
+                        )
+
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciPandasImportExport())
+    unittest.main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPreequilibration.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPreequilibration.py
new file mode 100644
index 0000000000000000000000000000000000000000..4216aadba2e40f177e05ea8b34ece09bbc442139
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testPreequilibration.py
@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+
+import sys
+import amici
+import unittest
+import os
+import numpy as np
+import pysb
+import importlib
+import copy
+import itertools
+from testPYSB import get_data
+
+
+class TestAmiciPreequilibration(unittest.TestCase):
+    '''
+    TestCase class for testing preequilibration
+    '''
+
+    expectedResultsFile = os.path.join(os.path.dirname(__file__),
+                                       'cpputest', 'expectedResults.h5')
+
+    def setUp(self):
+        self.resetdir = os.getcwd()
+        self.default_path = copy.copy(sys.path)
+
+        pysb.SelfExporter.cleanup()  # reset pysb
+        pysb.SelfExporter.do_export = True
+
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..',
+                                        'python', 'examples',
+                                        'example_presimulation'))
+        if 'createModelPresimulation' in sys.modules:
+            importlib.reload(sys.modules['createModelPresimulation'])
+            model_module = sys.modules['createModelPresimulation']
+        else:
+            model_module = importlib.import_module('createModelPresimulation')
+
+        model = copy.deepcopy(model_module.model)
+        model.name = 'test_model_presimulation_pysb'
+        outdir = model.name
+        amici.pysb2amici(model,
+                         outdir,
+                         verbose=False,
+                         observables=['pPROT_obs'],
+                         constant_parameters=['DRUG_0', 'KIN_0'])
+        sys.path.insert(0, outdir)
+        modelModulePYSB = importlib.import_module(outdir)
+
+        self.model = modelModulePYSB.getModel()
+        self.model.setReinitializeFixedParameterInitialStates(True)
+
+        self.solver = self.model.getSolver()
+        self.solver.setSensitivityOrder(amici.SensitivityOrder_first)
+        self.solver.setSensitivityMethod(amici.SensitivityMethod_forward)
+
+        self.edata = get_data(self.model)
+        self.edata.t_presim = 2
+        self.edata.fixedParameters = [10, 2]
+        self.edata.fixedParametersPresimulation = [3, 2]
+        self.edata.fixedParametersPreequilibration = [3, 0]
+        self.edata.setTimepoints([1, 5])
+
+        self.edata_preeq = amici.ExpData(self.edata)
+        self.edata_preeq.t_presim = 0
+        self.edata_preeq.setTimepoints([np.infty])
+        self.edata_preeq.fixedParameters = \
+            self.edata.fixedParametersPreequilibration
+        self.edata_preeq.fixedParametersPresimulation = ()
+        self.edata_preeq.fixedParametersPreequilibration = ()
+
+        self.edata_presim = amici.ExpData(self.edata)
+        self.edata_presim.t_presim = 0
+        self.edata_presim.setTimepoints([self.edata.t_presim])
+        self.edata_presim.fixedParameters = \
+            self.edata.fixedParametersPresimulation
+        self.edata_presim.fixedParametersPresimulation = ()
+        self.edata_presim.fixedParametersPreequilibration = ()
+
+        self.edata_sim = amici.ExpData(self.edata)
+        self.edata_sim.t_presim = 0
+        self.edata_sim.setTimepoints(self.edata.getTimepoints())
+        self.edata_sim.fixedParameters = \
+            self.edata.fixedParameters
+        self.edata_sim.fixedParametersPresimulation = ()
+        self.edata_sim.fixedParametersPreequilibration = ()
+
+        self.pscales = [
+            amici.ParameterScaling_log10, amici.ParameterScaling_ln,
+            amici.ParameterScaling_none,
+            amici.parameterScalingFromIntVector([
+                amici.ParameterScaling_log10, amici.ParameterScaling_ln,
+                amici.ParameterScaling_none, amici.ParameterScaling_log10,
+                amici.ParameterScaling_ln, amici.ParameterScaling_none
+            ])
+        ]
+
+        self.plists = [
+            [3, 1, 2, 4], [0, 1, 2, 3, 4, 5], [5, 3, 2, 0, 4, 1],
+            [1, 2, 3, 4, 5], [1, 1, 1],
+        ]
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.test_manual_preequilibration()
+        self.test_parameter_reordering()
+
+    def test_manual_preequilibration(self):
+
+        settings = itertools.product(self.pscales, self.plists)
+
+        for pscale, plist in settings:
+
+            self.model.setInitialStates([])
+            self.model.setInitialStateSensitivities([])
+            self.model.setParameterList(plist)
+            self.model.setParameterScale(pscale)
+
+            # combined
+            rdata_auto = amici.runAmiciSimulation(
+                self.model, self.solver, self.edata
+            )
+
+            # manual preqquilibration
+            rdata_preeq = amici.runAmiciSimulation(
+                self.model, self.solver, self.edata_preeq
+            )
+
+            # manual reinitialization + presimulation
+            x0 = rdata_preeq['x'][0, :]
+            x0[1] = self.edata_presim.fixedParameters[0]
+            x0[2] = self.edata_presim.fixedParameters[1]
+            sx0 = rdata_preeq['sx'][0, :, :]
+            sx0[:, 1] = 0
+            sx0[:, 2] = 0
+            self.model.setInitialStates(x0)
+            self.model.setInitialStateSensitivities(
+                sx0.flatten()
+            )
+            rdata_presim = amici.runAmiciSimulation(
+                self.model, self.solver, self.edata_presim
+            )
+
+            # manual reinitialization + simulation
+            x0 = rdata_presim['x'][0, :]
+            x0[1] = self.edata_sim.fixedParameters[0]
+            x0[2] = self.edata_sim.fixedParameters[1]
+            sx0 = rdata_presim['sx'][0, :, :]
+            sx0[:, 1] = 0
+            sx0[:, 2] = 0
+            self.model.setInitialStates(x0)
+            self.model.setInitialStateSensitivities(
+                sx0.flatten()
+            )
+            rdata_sim = amici.runAmiciSimulation(
+                self.model, self.solver, self.edata_sim
+            )
+
+            for variable in ['x', 'sx']:
+                with self.subTest(pscale=pscale, plist=plist,
+                                  variable=variable):
+                    self.assertTrue(np.isclose(
+                        rdata_auto[variable],
+                        rdata_sim[variable],
+                        1e-6, 1e-6
+                    ).all())
+
+    def test_parameter_reordering(self):
+        rdata_ordered = amici.runAmiciSimulation(
+            self.model, self.solver, self.edata
+        )
+
+        for plist in self.plists:
+            with self.subTest(plist=plist):
+
+                self.model.setParameterList(plist)
+                rdata_reordered = amici.runAmiciSimulation(
+                    self.model, self.solver, self.edata
+                )
+
+                for ip, p_index in enumerate(plist):
+                    self.assertTrue(np.isclose(
+                        rdata_ordered['sx'][:, p_index, :],
+                        rdata_reordered['sx'][:, ip, :],
+                        1e-6, 1e-6
+                    ).all())
+
+    def test_parameter_in_expdata(self):
+        rdata = amici.runAmiciSimulation(
+            self.model, self.solver, self.edata
+        )
+
+        # set ExpData plist
+        self.edata.plist = self.model.getParameterList()
+        # perturb model parameter list
+        self.model.setParameterList([
+            i for i in reversed(self.model.getParameterList())
+        ])
+
+        # set ExpData parameters
+        self.edata.parameters = self.model.getParameters()
+        # perturb model parameters
+        self.model.setParameters(tuple(
+            p * 2 for p in self.model.getParameters()
+        ))
+
+        # set ExpData pscale
+        self.edata.pscale = self.model.getParameterScale()
+        # perturb model pscale, needs to be done after getting parameters,
+        # otherwise we will mess up parameter value
+        self.model.setParameterScale(amici.parameterScalingFromIntVector([
+            amici.ParameterScaling_log10
+            if scaling == amici.ParameterScaling_none
+            else amici.ParameterScaling_none
+            for scaling in self.model.getParameterScale()
+        ]))
+
+        self.edata.x0 = rdata['x_ss']
+        self.edata.sx0 = rdata['sx_ss'].flatten()
+
+        # perturb model initial states
+        self.model.setInitialStates(rdata['x_ss'] * 4)
+        self.model.setInitialStateSensitivities(rdata['sx_ss'].flatten() / 2)
+
+        rdata_edata = amici.runAmiciSimulation(
+            self.model, self.solver, self.edata
+        )
+        for variable in ['x', 'sx']:
+            with self.subTest(variable=variable):
+                self.assertTrue(np.isclose(
+                    rdata[variable][0, :],
+                    rdata_edata[variable][0, :],
+                    1e-6, 1e-6
+                ).all())
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciPreequilibration())
+    unittest.main()
+
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testSBML.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testSBML.py
new file mode 100644
index 0000000000000000000000000000000000000000..1767e2c16228ad83e8df6cc58f2393fe16f899a3
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testSBML.py
@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+
+import sys
+import amici
+import unittest
+import os
+import copy
+import numpy as np
+from testModels import check_derivatives
+
+
+class TestAmiciSBMLModel(unittest.TestCase):
+    """
+    TestCase class for testing SBML import and simulation from AMICI python interface
+    """
+
+    expectedResultsFile = os.path.join(os.path.dirname(__file__),
+                                       'cpputest', 'expectedResults.h5')
+
+    def setUp(self):
+        self.default_path = copy.copy(sys.path)
+        self.resetdir = os.getcwd()
+
+        if os.path.dirname(__file__) != '':
+            os.chdir(os.path.dirname(__file__))
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.test_presimulation()
+        self.test_steadystate_scaled()
+        self.test_likelihoods()
+
+    def test_presimulation(self):
+        def assert_fun(x):
+            return self.assertTrue(x)
+
+        sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
+                                'examples', 'example_presimulation',
+                                'model_presimulation.xml')
+
+        sbmlImporter = amici.SbmlImporter(sbmlFile)
+
+        constantParameters = ['DRUG_0', 'KIN_0']
+
+        observables = amici.assignmentRules2observables(
+            sbmlImporter.sbml,  # the libsbml model object
+            filter_function=lambda variable: variable.getName() == 'pPROT_obs'
+        )
+        outdir = 'test_model_presimulation'
+        sbmlImporter.sbml2amici('test_model_presimulation',
+                                outdir,
+                                verbose=False,
+                                observables=observables,
+                                constantParameters=constantParameters)
+        sys.path.insert(0, outdir)
+        import test_model_presimulation as modelModule
+        model = modelModule.getModel()
+        solver = model.getSolver()
+        solver.setNewtonMaxSteps(0)
+        model.setTimepoints(np.linspace(0, 60, 61))
+        model.setSteadyStateSensitivityMode(
+            amici.SteadyStateSensitivityMode_simulationFSA
+        )
+        solver.setSensitivityOrder(amici.SensitivityOrder_first)
+        model.setReinitializeFixedParameterInitialStates(True)
+
+        rdata = amici.runAmiciSimulation(model, solver)
+        edata = amici.ExpData(rdata, 0.1, 0.0)
+        edata.fixedParameters = [10, 2]
+        edata.fixedParametersPresimulation = [10, 2]
+        edata.fixedParametersPreequilibration = [3, 0]
+        self.assertIsInstance(
+            amici.runAmiciSimulation(model, solver, edata),
+            amici.ReturnDataView)
+
+        solver.setRelativeTolerance(1e-12)
+        solver.setAbsoluteTolerance(1e-12)
+        check_derivatives(model, solver, edata, assert_fun, epsilon=1e-4)
+
+    def test_steadystate_scaled(self):
+        """
+        Test SBML import and simulation from AMICI python interface
+        """
+
+        model_module = self.test_steadystate_import()
+
+        self.steadystate_simulation(model_module=model_module)
+
+        # Run some additional tests which need a working Model,
+        # but don't need precomputed expectations.
+        test_set_parameters_by_dict(model_module)
+
+    def test_steadystate_import(self):
+        sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
+                                'examples', 'example_steadystate',
+                                'model_steadystate_scaled.xml')
+        sbmlImporter = amici.SbmlImporter(sbmlFile)
+
+        observables = amici.assignmentRules2observables(
+            sbmlImporter.sbml,
+            filter_function=lambda variable:
+            variable.getId().startswith('observable_') and
+            not variable.getId().endswith('_sigma')
+        )
+
+        outdir = 'test_model_steadystate_scaled'
+        sbmlImporter.sbml2amici('test_model_steadystate_scaled',
+                                outdir,
+                                observables=observables,
+                                constantParameters=['k0'],
+                                sigmas={'observable_x1withsigma':
+                                            'observable_x1withsigma_sigma'})
+
+        sys.path.insert(0, outdir)
+        import test_model_steadystate_scaled as model_module
+
+        return model_module
+
+    def steadystate_simulation(self, model_module):
+        def assert_fun(x):
+            return self.assertTrue(x)
+
+        model = model_module.getModel()
+        model.setTimepoints(np.linspace(0, 60, 60))
+        solver = model.getSolver()
+        solver.setSensitivityOrder(amici.SensitivityOrder_first)
+        rdata = amici.runAmiciSimulation(model, solver)
+        edata = [amici.ExpData(rdata, 1, 0)]
+        rdata = amici.runAmiciSimulations(model, solver, edata)
+
+        # check roundtripping of DataFrame conversion
+        df_edata = amici.getDataObservablesAsDataFrame(model, edata)
+        edata_reconstructed = amici.getEdataFromDataFrame(model, df_edata)
+
+        self.assertTrue(
+            np.isclose(
+                amici.ExpDataView(edata[0])
+                ['observedData'],
+                amici.ExpDataView(edata_reconstructed[0])
+                ['observedData'],
+            ).all()
+        )
+        self.assertTrue(
+            np.isclose(
+                amici.ExpDataView(edata[0])
+                ['observedDataStdDev'],
+                amici.ExpDataView(edata_reconstructed[0])
+                ['observedDataStdDev'],
+            ).all()
+        )
+        if len(edata[0].fixedParameters):
+            self.assertListEqual(
+                list(edata[0].fixedParameters),
+                list(edata_reconstructed[0].fixedParameters),
+            )
+        else:
+            self.assertListEqual(
+                list(model.getFixedParameters()),
+                list(edata_reconstructed[0].fixedParameters),
+            )
+
+        self.assertListEqual(
+            list(edata[0].fixedParametersPreequilibration),
+            list(edata_reconstructed[0].fixedParametersPreequilibration),
+        )
+
+        df_state = amici.getSimulationStatesAsDataFrame(model, edata, rdata)
+        self.assertTrue(
+            np.isclose(
+                rdata[0]['x'],
+                df_state[list(model.getStateIds())].values
+            ).all()
+        )
+        df_obs = amici.getSimulationObservablesAsDataFrame(model, edata, rdata)
+        self.assertTrue(
+            np.isclose(
+                rdata[0]['y'],
+                df_obs[list(model.getObservableIds())].values
+            ).all()
+        )
+        amici.getResidualsAsDataFrame(model, edata, rdata)
+
+        solver.setRelativeTolerance(1e-12)
+        solver.setAbsoluteTolerance(1e-12)
+        check_derivatives(model, solver, edata[0], assert_fun, atol=1e-3,
+                          rtol=1e-3, epsilon=1e-4)
+
+
+    def test_likelihoods(self):
+        """
+        Test the custom noise distributions used to define cost functions.
+        """
+        def assert_fun(x):
+            return self.assertTrue(x)
+
+        sbmlFile = os.path.join(os.path.dirname(__file__), '..', 'python',
+                                'examples', 'example_steadystate',
+                                'model_steadystate_scaled.xml')
+        sbmlImporter = amici.SbmlImporter(sbmlFile)
+
+        observables = amici.assignmentRules2observables(
+            sbmlImporter.sbml,
+            filter_function=lambda variable:
+                variable.getId().startswith('observable_') and
+                not variable.getId().endswith('_sigma')
+        )
+
+        # assign different noise models
+
+        obs_keys = list(observables.keys())
+
+        # exponentiate observable formulas
+        obs1 = observables[obs_keys[1]]
+        obs3 = observables[obs_keys[3]]
+        obs1['formula'] = '10^(' + obs1['formula'] + ')'
+        obs3['formula'] = 'exp(' + obs3['formula'] + ')'
+
+        # customize noise distributions
+        noise_distributions = {
+            obs_keys[0]: 'normal',
+            obs_keys[1]: 'log-normal',
+            obs_keys[2]: 'laplace',
+            obs_keys[3]: 'log10-laplace',
+        }
+
+        outdir = 'test_likelihoods'
+        sbmlImporter.sbml2amici('test_likelihoods',
+                                outdir,
+                                observables=observables,
+                                constantParameters=['k0'],
+                                sigmas={'observable_x1withsigma':
+                                        'observable_x1withsigma_sigma'},
+                                noise_distributions=noise_distributions
+                                )
+
+        sys.path.insert(0, outdir)
+        import test_likelihoods as modelModule
+
+        model = modelModule.getModel()
+        model.setTimepoints(np.linspace(0, 60, 60))
+        solver = model.getSolver()
+        solver.setSensitivityOrder(amici.SensitivityOrder_first)
+
+        # run model once to create an edata
+        rdata = amici.runAmiciSimulation(model, solver)
+        edata = [amici.ExpData(rdata, 1, 0)]
+
+        # just make all observables positive since some are logarithmic
+        for ed in edata:
+            y = ed.getObservedData()
+            y = tuple([max(val, 1e-4) for val in y])
+            ed.setObservedData(y)
+
+        # and now run for real and also compute likelihood values
+        rdata = amici.runAmiciSimulations(model, solver, edata)[0]
+
+        # output for easy debugging
+        for key in ['llh', 'sllh']:
+            print(key, rdata[key])
+
+        # it would be good to compute the expected llh+sllh by hand,
+        # here, we only check if they make overall sense
+        self.assertTrue(np.isfinite(rdata['llh']))
+        self.assertTrue(np.all(np.isfinite(rdata['sllh'])))
+        self.assertTrue(np.any(rdata['sllh']))
+
+
+def test_set_parameters_by_dict(model_module):
+    """Test setting parameter via id/name => value dicts"""
+
+    model = model_module.getModel()
+    old_parameter_values = model.getParameters()
+    parameter_ids = model.getParameterIds()
+    change_par_id = parameter_ids[-1]
+    new_par_val = 0.1234
+    old_par_val = model.getParameterById(change_par_id)
+
+    assert model.getParameterById(change_par_id) != new_par_val
+    model.setParameterById({change_par_id: new_par_val})
+    assert model.getParameterById(change_par_id) == new_par_val
+    # reset and check we are back to original
+    model.setParameterById(change_par_id, old_par_val)
+    assert model.getParameters() == old_parameter_values
+
+    # Same for by-name
+    parameter_names = model.getParameterNames()
+    change_par_name = parameter_names[-1]
+    model.setParameterByName({change_par_name: new_par_val})
+    assert model.getParameterByName(change_par_name) == new_par_val
+    model.setParameterByName(change_par_name, old_par_val)
+    assert model.getParameters() == old_parameter_values
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciSBMLModel())
+    unittest.main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/tests/testSBMLSuite.py b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testSBMLSuite.py
new file mode 100644
index 0000000000000000000000000000000000000000..9dcc1284f8f55c64c7df2bc50ea618c88d3dad42
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/tests/testSBMLSuite.py
@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+Run SBML Test Suite and verify simulation results
+[https://github.com/sbmlteam/sbml-test-suite/releases]
+
+Usage:
+    testSBMLSuite.py SELECTION
+        SELECTION can be e.g.: `1`, `1,3`, or `-3,4,6-7` to select specific
+        test cases or 1-1780 to run all.
+"""
+
+import re
+import os
+import sys
+import importlib
+import numpy as np
+import sympy as sp
+import amici
+import unittest
+import copy
+from typing import List
+
+# directory with sbml semantic test cases
+test_path = os.path.join(os.path.dirname(__file__), 'sbml-test-suite', 'cases',
+                         'semantic')
+
+
+ALL_TESTS = set(range(1, 1781))
+
+
+class TestAmiciSBMLTestSuite(unittest.TestCase):
+    SBML_TEST_IDS = ALL_TESTS
+
+    def setUp(self):
+        self.resetdir = os.getcwd()
+        self.default_path = copy.copy(sys.path)
+
+    def tearDown(self):
+        os.chdir(self.resetdir)
+        sys.path = self.default_path
+
+    def runTest(self):
+        self.test_sbml_testsuite()
+
+    def test_sbml_testsuite(self):
+        for testId in self.SBML_TEST_IDS:
+            if testId != 1395:  # we skip this test due to NaNs in the
+                # jacobian
+                with self.subTest(testId=testId):
+                    self.run_sbml_testsuite_case(get_test_str(testId))
+
+    def run_sbml_testsuite_case(self, test_id):
+        try:
+            current_test_path = os.path.join(test_path, test_id)
+
+            # results
+            results_file = os.path.join(current_test_path,
+                                        test_id + '-results.csv')
+            results = np.genfromtxt(results_file, delimiter=',')
+
+            model, solver, wrapper = compile_model(current_test_path, test_id)
+            atol, rtol = apply_settings(current_test_path, test_id, solver,
+                                        model)
+
+            rdata = amici.runAmiciSimulation(model, solver)
+
+            amount_species, variables_species = get_amount_and_variables(
+                current_test_path, test_id
+            )
+
+            simulated_x = rdata['x']
+            test_x = results[1:, [
+                                     1 + wrapper.speciesIndex[variable]
+                                     for variable in variables_species
+                                     if variable in wrapper.speciesIndex.keys()
+                                 ]]
+
+            for species in amount_species:
+                if not species == '':
+                    symvolume = wrapper.speciesCompartment[
+                        wrapper.speciesIndex[species]
+                    ]
+                    volume = symvolume.subs({
+                        comp: vol
+                        for comp, vol in zip(
+                            wrapper.compartmentSymbols,
+                            wrapper.compartmentVolume
+                        )
+                    })
+                    volume = volume.subs({
+                        sp.Symbol(name): value
+                        for name, value in zip(
+                            model.getParameterIds(),
+                            model.getParameters()
+                        )
+                    })
+
+                    # required for 525-527, 530 as k is renamed to amici_k
+                    volume = volume.subs({
+                        sp.Symbol(name): value
+                        for name, value in zip(
+                        model.getParameterNames(),
+                        model.getParameters()
+                    )
+                    })
+
+                    simulated_x[:, wrapper.speciesIndex[species]] = \
+                        simulated_x[:, wrapper.speciesIndex[species]] * volume
+
+            self.assertTrue(
+                np.isclose(simulated_x, test_x, atol, rtol).all()
+            )
+            print(f'TestCase {test_id} passed.')
+
+        except amici.sbml_import.SBMLException as err:
+            print(f'TestCase {test_id} was skipped: {err}')
+
+
+def get_amount_and_variables(current_test_path, test_id):
+    settings = read_settings_file(current_test_path, test_id)
+
+    amount_species = settings['amount'] \
+        .replace(' ', '') \
+        .replace('\n', '') \
+        .split(',')
+    variables_species = settings['variables'] \
+        .replace(' ', '') \
+        .replace('\n', '') \
+        .split(',')
+
+    return amount_species, variables_species
+
+
+def apply_settings(current_test_path, test_id, solver, model):
+    settings = read_settings_file(current_test_path, test_id)
+
+    ts = np.linspace(float(settings['start']),
+                     float(settings['start'])
+                     + float(settings['duration']),
+                     int(settings['steps']) + 1)
+    atol = float(settings['absolute'])
+    rtol = float(settings['relative'])
+
+    model.setTimepoints(ts)
+    solver.setMaxSteps(int(1e6))
+    solver.setRelativeTolerance(rtol / 1000.0)
+    solver.setAbsoluteTolerance(atol / 1000.0)
+
+    return atol, rtol
+
+
+def compile_model(path, test_id):
+    sbml_file = find_model_file(path, test_id)
+
+    wrapper = amici.SbmlImporter(sbml_file)
+
+    model_dir = os.path.join(os.path.dirname(__file__), 'SBMLTestModels',
+                             test_id)
+    if not os.path.exists(model_dir):
+        os.makedirs(model_dir)
+
+    model_name = 'SBMLTest' + test_id
+    wrapper.sbml2amici(model_name, output_dir=model_dir)
+
+    # settings
+    sys.path.insert(0, model_dir)
+    model_module = importlib.import_module(model_name)
+
+    model = model_module.getModel()
+    solver = model.getSolver()
+
+    return model, solver, wrapper
+
+
+def find_model_file(current_test_path, testId):
+    """Find model file for the given test (guess filename extension)"""
+    sbmlFile = os.path.join(current_test_path, testId + '-sbml-l3v2.xml')
+
+    # fallback l3v1
+    if not os.path.isfile(sbmlFile):
+        sbmlFile = os.path.join(current_test_path, testId + '-sbml-l3v1.xml')
+
+    # fallback l2v5
+    if not os.path.isfile(sbmlFile):
+        sbmlFile = os.path.join(current_test_path, testId + '-sbml-l2v5.xml')
+
+    return sbmlFile
+
+
+def read_settings_file(current_test_path, test_id):
+    """Read settings for the given test"""
+    settings_file = os.path.join(current_test_path, test_id + '-settings.txt')
+    settings = {}
+    with open(settings_file) as f:
+        for line in f:
+            if not line == '\n':
+                (key, val) = line.split(':')
+                settings[key] = val
+    return settings
+
+
+def get_test_str(test_id):
+    test_str = str(test_id)
+    test_str = '0'*(5-len(test_str)) + test_str
+    return test_str
+
+
+def parse_selection(selection_str: str) -> List[int]:
+    """
+    Parse comma-separated list of integer ranges, return selected indices as
+    integer list
+
+    Valid input e.g.: 1 1,3 -3,4,6-7
+    """
+    indices = []
+    for group in selection_str.split(','):
+        if not re.match(r'^(?:-?\d+)|(?:\d+(?:-\d+))$', group):
+            print("Invalid selection", group)
+            sys.exit()
+        spl = group.split('-')
+        if len(spl) == 1:
+            indices.append(int(spl[0]))
+        elif len(spl) == 2:
+            begin = int(spl[0]) if spl[0] else 0
+            end = int(spl[1])
+            indices.extend(range(begin, end + 1))
+    return indices
+
+
+if __name__ == '__main__':
+    TestAmiciSBMLTestSuite.SBML_TEST_IDS = set(parse_selection(sys.argv.pop()))
+
+    suite = unittest.TestSuite()
+    suite.addTest(TestAmiciSBMLTestSuite())
+    unittest.main()
diff --git a/Requirements/AMICI-0.10.11_SS_eventFix/version.txt b/Requirements/AMICI-0.10.11_SS_eventFix/version.txt
new file mode 100644
index 0000000000000000000000000000000000000000..223df19846467e0be330ba1076105e8025ea5082
--- /dev/null
+++ b/Requirements/AMICI-0.10.11_SS_eventFix/version.txt
@@ -0,0 +1 @@
+0.10.11
diff --git a/Requirements/MEIGO/MEIGO.m b/Requirements/MEIGO/MEIGO.m
new file mode 100644
index 0000000000000000000000000000000000000000..5c56f058aabe89812e9ccafb1fbc7625041f9ce7
--- /dev/null
+++ b/Requirements/MEIGO/MEIGO.m
@@ -0,0 +1,17 @@
+function [Results] = MEIGO(problem,opts,algorithm,varargin)
+
+algorithm = upper(algorithm);
+
+if strcmpi(algorithm,'VNS')
+    Results = rvnds_hamming(problem,opts,varargin{:});
+elseif strcmpi(algorithm,'ESS')
+    Results = ess_kernel(problem,opts,varargin{:});
+elseif strcmpi(algorithm,'MULTISTART')
+    Results = ssm_multistart(problem,opts,varargin{:});
+elseif strcmpi(algorithm,'CESS')    
+    Results = CeSS(problem,opts);    
+else
+    fprintf('The method defined in "algorithm" is not valid \n');
+    fprintf('Define a valid method (VNS, eSS, or CeSS) and rerun \n');
+    Results=[];
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/README.md b/Requirements/MEIGO/PEtabMEIGO/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ab36123738cadf1ebcc22b76a167d34435c837e
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/README.md
@@ -0,0 +1,58 @@
+# PEtabMEIGO
+
+PEtab interface for MEIGO global optimization suite.
+
+## Getting Started
+
+PEtabMEIGO last version is included in MEIGO suite.
+
+### Prerequisites
+
+MATLAB interface for libSBML is the only dependency required and it's up to the user it's installation.
+
+Latest libsSBML MATLAB interface can be downloaded from [this site](https://sourceforge.net/projects/sbml/files/libsbml/MATLAB%20Interface/).
+
+### Installing
+
+As mentioned, PEtabMEIGO it's supplied with MEIGO suite.
+
+## How it works?
+
+Given the directory and model name of a problem described using PEtab format, or the absolute or relative
+path pointing to problem's **.yaml** file, PEtabMEIGO function, **getMeigoProblem** returns a struct 
+containing the following fields:
+
+* f : Problem's objective function.
+* x_L : Optimization parameters lower bounds, unscaled.
+* x_U : Optimization parameters upper bounds, unscaled.
+* x_0 : Optimization parameters initial values, unscaled.
+
+### Example of use
+
+With problem directory **problem_dir** and model name **model_name** do:
+
+```
+    out = getMeigoProblem(problem_dir, model_name);
+```
+
+or we can also use problem's **.yaml** file path, **yaml_path**:
+
+```
+    out = getMeigoProblem(yaml_path);
+```
+
+### Known Issues
+
+* TODO
+
+## Version
+
+* *PEtabMEIGO 20200401*
+
+## Authors
+
+* **Tacio Camba Espí**
+
+## Acknowledgments
+
+* TODO
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/SBMLode.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/SBMLode.m
new file mode 100644
index 0000000000000000000000000000000000000000..5d552427e5d37b9474802be5b9e591cef0fdb9e4
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/SBMLode.m
@@ -0,0 +1,74 @@
+classdef SBMLode < handle
+    %SBMLMODEL provides an intermediate container between the SBML
+    %definition and an amimodel object
+    
+    properties
+        % states
+        state = sym.empty();
+        % observables
+        observable = sym.empty();
+        % names of observables
+        observable_name = sym.empty();
+        % parameter names
+        param = sym.empty();
+        % parameter expressions 
+        parameter = sym.empty();
+        % constants
+        constant = sym.empty();
+        % reactions
+        reaction = sym.empty();
+        % compartments
+        compartment = sym.empty();
+        % compartment volumes
+        volume = sym.empty();
+        % condition volumes
+        kvolume = sym.empty();
+        % initial condition of states
+        initState = sym.empty();
+        % condition
+        condition = sym.empty();
+        % reaction fluxes
+        flux = sym.empty();
+        % reaction stochiometry
+        stochiometry = sym.empty();
+        % right hand side of reconstructed differential equation
+        xdot = sym.empty();
+        % event triggers
+        trigger = sym.empty();
+        % event boli
+        bolus = sym.empty();
+        % mathematical experessions for function
+        funmath = cell.empty();
+        % string function signature
+        funarg = cell.empty();
+        % symbol of time
+        time_symbol = char.empty();
+        % nominal parameters
+        pnom = double.empty();
+        % nominal conditions
+        knom = double.empty();
+    end
+    
+    methods
+        function obj = SBMLode(model)
+            % SBMLode extracts information from an SBML definition and
+            % stores it in a symbolic format
+            %
+            % Parameters:
+            %  filename: target name of the model (excluding the suffix
+            %  .xml/.sbml)
+            %
+            % Return values:
+            %
+            obj.importSBML(model);
+            obj.checkODE;
+        end
+        
+        importSBML(obj, model, verbose)
+
+        checkODE(obj)
+        
+        writeAMICI(obj, modelname, outdir, verbose)        
+    end    
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/checkODE.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/checkODE.m
new file mode 100644
index 0000000000000000000000000000000000000000..f2cbf6130926d948560f402b183a38529866dbe9
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/checkODE.m
@@ -0,0 +1,16 @@
+function checkODE(obj)
+    % checkODE checks whether the length of various variable names exceeds
+    % namelengthmax (would cause troube with symbolic processing later on).
+    %
+    % Parameters:
+    %
+    % Return values:
+    % void
+length_states = arrayfun(@(x) length(char(x)),obj.state);
+assert(all(length_states<=namelengthmax),['Some species have identifiers are longer than ' num2str(namelengthmax) ' which MATLAB cannot handle, please shorten the identifiers!'])
+length_parameters = arrayfun(@(x) length(char(x)),obj.parameter);
+assert(all(length_parameters<=namelengthmax),['Some parameters have identifiers are longer than ' num2str(namelengthmax) ' which MATLAB cannot handle, please shorten the identifiers!'])
+length_conditions = arrayfun(@(x) length(char(x)),obj.condition);
+assert(all(length_conditions<=namelengthmax),['Some conditions have identifiers are longer than ' num2str(namelengthmax) ' which MATLAB cannot handle, please shorten the identifiers!'])
+
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/importSBML.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/importSBML.m
new file mode 100644
index 0000000000000000000000000000000000000000..263e0a6da868d537277848df223847cec8852d84
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/importSBML.m
@@ -0,0 +1,760 @@
+function importSBML(obj, model, verbose)
+% importSBML parses information from the SBML definition and populates
+% the SBMLode object from this information.
+%
+% Parameters:
+%  filename: target name of the model
+%
+% Return values:
+%  void
+
+if nargin == 2
+    verbose = false;
+end
+
+if(isfield(model,'fbc_objective'))
+    error('Flux Balance Constraints are currently not supported')
+end
+
+%% COMPARTMENTS
+
+if verbose
+    fprintf('loading compartments ...\n')
+end
+
+% initialize
+compartments_sym = sym({model.compartment.id});
+obj.compartment = compartments_sym;
+
+% set initial assignments
+if(isfield(model,'initialAssignment'))
+    initassignments_sym = sym({model.initialAssignment.symbol});
+    initassignments_math = cleanedsym({model.initialAssignment.math});
+else
+    initassignments_sym = sym([]);
+    initassignments_math = sym([]);
+end
+setInitialAssignment(obj,model,'compartment',initassignments_sym,initassignments_math)
+
+% % extract compartment sizes, default to 1
+% obj.compartment = subs(obj.compartment,compartments_sym(logical([model.compartment.isSetSize])),sym([model.compartment.size]));
+%
+% % set remaining ones to default value 1
+% obj.compartment = subs(obj.compartment,compartments_sym,sym(ones(size(compartments_sym))));
+
+%% RULES
+if verbose
+    fprintf('applying rules ...\n')
+end
+
+rule_types = {model.rule.typecode};
+if(any(strcmp(rule_types,'SBML_ALGEBRAIC_RULE')))
+    %DAE part TBD
+    error('Algebraic rules are currently not supported!');
+end
+
+all_rulevars = sym({model.rule.variable});
+if(any(arrayfun(@(x) ismember(x,compartments_sym),all_rulevars)))
+    error('Rules for compartments are currently not supported!');
+end
+all_rulemath = cleanedsym({model.rule.formula});
+% remove rate rules
+rulevars = all_rulevars(not(strcmp({model.rule.typecode},'SBML_RATE_RULE')));
+rulemath = all_rulemath(not(strcmp({model.rule.typecode},'SBML_RATE_RULE')));
+repeat_idx = ismember(rulevars,symvar(rulemath));
+while(any(repeat_idx))
+    rulemath= subs(rulemath,rulevars,rulemath);
+    repeat_idx = ismember(rulevars,symvar(rulemath));
+end
+
+applyRule(obj,model,'compartment',rulevars,rulemath)
+
+%% SPECIES
+if verbose
+    fprintf('loading species ...\n')
+end
+
+% extract species
+species_sym = sym({model.species.id});
+species_sym = species_sym(:);
+obj.state = species_sym;
+
+nx = length(obj.state);
+
+% extract corresponding volumes
+compartments = sym(sanitizeString({model.species.compartment}));
+obj.volume = subs(compartments(:),sym({model.compartment.id}),obj.compartment);
+if(any(arrayfun(@(x) ~isempty(regexp(char(x),'[\w]+\(')),obj.volume)))
+    error('Functions in volume definitions is currently not supported.')
+end
+
+initConcentration = [model.species.initialConcentration];
+initConcentration = initConcentration(:);
+initAmount = [model.species.initialAmount];
+initAmount = initAmount(:);
+obj.initState = species_sym;
+hasAssignmentRule = ismember(obj.state,all_rulevars(strcmp({model.rule.typecode},'SBML_ASSIGNMENT_RULE')))';
+hasRateRule = ismember(obj.state,all_rulevars(strcmp({model.rule.typecode},'SBML_RATE_RULE')))';
+
+% set initial assignments
+setInitialAssignment(obj,model,'initState',initassignments_sym,initassignments_math)
+
+
+
+% remove conditions species (boundary condition + no initialisation)
+if(~isempty(obj.state))
+    cond_idx = all([logical([model.species.boundaryCondition]);transpose(logical(obj.state==obj.initState));~hasAssignmentRule;~hasRateRule]);
+    bound_idx = all([logical([model.species.boundaryCondition]);transpose(logical(obj.state~=obj.initState));~hasAssignmentRule;~hasRateRule]);
+    condition_sym = obj.state(cond_idx);
+    conditions = obj.state(cond_idx);
+    boundary_sym = obj.state(bound_idx);
+    boundaries = obj.initState(bound_idx);
+else
+    
+    cond_idx = [];
+    bound_idx = [];
+    condition_sym = sym([]);
+    conditions = sym([]);
+    boundary_sym = sym([]);
+    boundaries = sym([]);
+end
+
+nk = length(conditions);
+
+applyRule(obj,model,'condition',rulevars,rulemath)
+
+% set initial concentrations
+concentration_idx = logical([model.species.isSetInitialConcentration]);
+onlysubstance_idx = logical([model.species.hasOnlySubstanceUnits]);
+obj.initState = subs(obj.initState,species_sym(concentration_idx),sym(initConcentration(concentration_idx)));
+
+% set initial amounts
+amount_idx = logical([model.species.isSetInitialAmount]);
+obj.initState = subs(obj.initState,species_sym(amount_idx),sym(initAmount(amount_idx))./obj.volume(amount_idx));
+% this.initState = subs(this.initState,species_sym(amount_idx),sym(initAmount(amount_idx)));
+
+% apply rules
+applyRule(obj,model,'initState',rulevars,rulemath)
+
+while(any(ismember(symvar(obj.initState),obj.state)))
+    obj.initState = subs(obj.initState,obj.state,obj.initState);
+end
+while(any(ismember(symvar(boundaries),obj.state)))
+    boundaries = subs(boundaries,obj.state,obj.initState);
+end
+
+%% PARAMETERS
+if verbose
+    fprintf('loading parameters ...\n')
+end
+
+% extract this.param
+parameter_sym = sym({model.parameter.id});
+parameter_val = transpose([model.parameter.value]);
+parameter_sym = parameter_sym(:);
+obj.param = parameter_sym;
+
+np = length(obj.param);
+
+%% CONSTANTS
+
+% remove constant species
+const_idx = logical([model.species.constant]) & not(cond_idx);
+constant_sym = obj.state(const_idx);
+
+obj.knom = double(subs([obj.initState(cond_idx);obj.initState(const_idx)],parameter_sym,parameter_val));
+
+
+
+
+
+%% REACTIONS
+if verbose
+    fprintf('parsing reactions ...\n')
+end
+
+nr = length(model.reaction);
+if(nr>0)
+    for ir = 1:nr
+        if(model.reaction(ir).isSetFast)
+            if(model.reaction(ir).fast)
+                error('Fast reactions are currently not supported!');
+            end
+        end
+    end
+end
+
+kLaw = [cellfun(@(x) x.math,{model.reaction.kineticLaw},'UniformOutput',false)];
+
+checkIllegalFunctions(kLaw);
+
+obj.flux = cleanedsym(kLaw);
+obj.flux = obj.flux(:);
+% add local parameters to global parameters, make them global by
+% extending them by the reaction_id string
+species_idx = transpose(sym(1:nx));
+if(length({model.reaction.id})>0)
+    try
+        tmp = cellfun(@(x,y) sym(cellfun(@(x) [x '_' y], ...
+            {x.parameter.id}, ...
+            'UniformOutput',false)), ...
+            {model.reaction.kineticLaw}, ...
+            {model.reaction.id}, ...
+            'UniformOutput',false);
+        plocal = transpose([tmp{:}]);
+        tmp = cellfun(@(x) cellfun(@double,{x.parameter.value}),{model.reaction.kineticLaw},'UniformOutput',false);
+        pvallocal = transpose([tmp{:}]);
+        % replace local parameters by globalized ones
+        tmp = cellfun(@(x,y,z) subs(x,sym({y.parameter.id}), ...
+            sym(cellfun(@(x) [x '_' z],{y.parameter.id},'UniformOutput',false))),...
+            transpose(num2cell(obj.flux)),...
+            {model.reaction.kineticLaw},...
+            {model.reaction.id},...
+            'UniformOutput',false);
+        obj.flux = [tmp{:}];
+        obj.flux = obj.flux(:);
+        
+    catch
+        tmp = cellfun(@(x,y) sym(cellfun(@(x) [x '_' y],{x.localParameter.id},'UniformOutput',false)),{model.reaction.kineticLaw},arrayfun(@(x) ['r' num2str(x)],1:length({model.reaction.id}),'UniformOutput',false),'UniformOutput',false);
+        plocal = transpose([tmp{:}]);
+        tmp = cellfun(@(x) cellfun(@double,{x.localParameter.value}),{model.reaction.kineticLaw},'UniformOutput',false);
+        pvallocal = transpose([tmp{:}]);
+        % replace local parameters by globalized ones
+        tmp = cellfun(@(x,y,z) subs(x,sym({y.localParameter.id}),sym(cellfun(@(x) [x '_' z],{y.localParameter.id},'UniformOutput',false))),transpose(num2cell(obj.flux)),{model.reaction.kineticLaw},arrayfun(@(x) ['r' num2str(x)],1:length({model.reaction.id}),'UniformOutput',false),'UniformOutput',false);
+        obj.flux = [tmp{:}];
+        obj.flux = obj.flux(:);
+        
+    end
+    
+    obj.param = [obj.param;plocal];
+    parameter_sym = [parameter_sym;plocal];
+    parameter_val = [parameter_val;pvallocal];
+    np = length(obj.param);
+    
+    reactants = cellfun(@(x) {x.species},{model.reaction.reactant},'UniformOutput',false);
+    % species index of the reactant
+    reactant_sidx = double(subs(sym(cat(2,reactants{:})),species_sym,species_idx));
+    % reaction index
+    tmp = cumsum(cell2mat(cellfun(@(x) [ones(1,1),zeros(1,max(length(x)-1,0))],reactants,'UniformOutput',false)));
+    wreact = cell2mat(cellfun(@(x) [ones(1,length(x)),zeros(1,isempty(x))],reactants,'UniformOutput',false));
+    reactant_ridx = tmp(logical(wreact));
+    products = cellfun(@(x) {x.species},{model.reaction.product},'UniformOutput',false);
+    % species index of the product
+    product_sidx = double(subs(sym(cat(2,products{:})),species_sym,species_idx));
+    % reaction index
+    tmp = cumsum(cell2mat(cellfun(@(x) [ones(1,1),zeros(1,max(length(x)-1,0))],products,'UniformOutput',false)));
+    wprod = cell2mat(cellfun(@(x) [ones(1,length(x)),zeros(1,isempty(x))],products,'UniformOutput',false));
+    product_ridx = tmp(logical(wprod));
+    if(model.SBML_level>=3)
+        reactant_stochiometry = cellfun(@(x) stoich_initAssign_rule(x,initassignments_sym,initassignments_math,rulevars,rulemath),{model.reaction.reactant},'UniformOutput',false);
+        %         reactant_math = cellfun(@(x) sym({x.stoichiometry}),{model.reaction.reactant},'UniformOutput',false);
+        reactant_id = cellfun(@getId,{model.reaction.reactant},'UniformOutput',false);
+        product_stochiometry = cellfun(@(x) stoich_initAssign_rule(x,initassignments_sym,initassignments_math,rulevars,rulemath),{model.reaction.product},'UniformOutput',false);
+        %         product_math = cellfun(@(x) sym({x.stoichiometry}),{model.reaction.product},'UniformOutput',false);
+        product_id = cellfun(@getId,{model.reaction.product},'UniformOutput',false);
+    else
+        % addition is necessary due to 1x0 struct that is returned by libSBML which is not properly handled by MATLAB,
+        % the concatenation is necessary because MATLAB treats 1x0 structs as empty input
+        symbolic_expr = @(x) num2cell(cell2sym(cellfun(@(z) math_expr(z),arrayfun(@(y) y.stoichiometryMath,x,'UniformOutput',false),'UniformOutput',false)) + sym(arrayfun(@(y) y.stoichiometry,x)).*arrayfun(@(y) isempty(y.stoichiometryMath),x));
+        reactant_stochiometry = cellfun(@(x) {symbolic_expr(x)},{model.reaction.reactant},'UniformOutput',false);
+        reactant_id = cellfun(@getId,{model.reaction.reactant},'UniformOutput',false);
+        product_stochiometry = cellfun(@(x) {symbolic_expr(x)},{model.reaction.product},'UniformOutput',false);
+        product_id = cellfun(@getId,{model.reaction.product},'UniformOutput',false);
+    end
+    eS = sym(zeros(nx,nr));
+    pS = sym(zeros(nx,nr));
+    tmp_rs = cellfun(@(x)[x{:}],reactant_stochiometry,'UniformOutput',false);
+    tmp_rs = [tmp_rs{:}];
+    tmp_rid = cat(2,reactant_id{:});
+    for iidx = 1:length(reactant_sidx)
+        if(strcmp(tmp_rid{iidx},''))
+            tmp = tmp_rs(iidx);
+        else
+            tmp = sym(tmp_rid{iidx});
+        end
+        eS(reactant_sidx(iidx),reactant_ridx(iidx)) = eS(reactant_sidx(iidx),reactant_ridx(iidx)) + tmp;
+    end
+    tmp_ps = cellfun(@(x)[x{:}],product_stochiometry,'UniformOutput',false);
+    tmp_ps = [tmp_ps{:}];
+    tmp_pid = cat(2,product_id{:});
+    for iidx = 1:length(product_sidx)
+        if(strcmp(tmp_pid{iidx},''))
+            tmp = tmp_ps(iidx);
+        else
+            tmp = sym(tmp_pid{iidx});
+        end
+        pS(product_sidx(iidx),product_ridx(iidx)) = pS(product_sidx(iidx),product_ridx(iidx)) + tmp;
+    end
+    
+    obj.stochiometry = - eS + pS;
+    
+    obj.xdot = obj.stochiometry*obj.flux;
+else
+    obj.xdot = sym(zeros(size(obj.state)));
+end
+
+reactionsymbols = sym({model.reaction.id}');
+
+if(length({model.reaction.id})>0)
+    stoichsymbols = [reactant_id{:},product_id{:}];
+    stoichmath = [tmp_rs,tmp_ps];
+    
+    stoichidx = not(strcmp(stoichsymbols,''));
+    stoichsymbols = stoichsymbols(stoichidx);
+    stoichmath = stoichmath(stoichidx);
+else
+    stoichsymbols = sym([]);
+    stoichmath = sym([]);
+end
+
+%% RATE RULES
+if verbose
+    fprintf('converting to concentrations ...\n')
+end
+
+%extract model conversion factor
+if(isfield(model,'conversionFactor'))
+    if(strcmp(model.conversionFactor,''))
+        conversionfactor = sym(ones(nx,1));
+    else
+        conversionfactor = sym(model.conversionFactor)*ones(nx,1);
+    end
+else
+    conversionfactor = ones(nx,1);
+end
+
+if(isfield(model.species,'conversionFactor'))
+    if(any(not(strcmp({model.species.conversionFactor},''))))
+        tmp = {model.species.conversionFactor};
+        idx = ~strcmp({model.species.conversionFactor},'');
+        conversionfactor(idx) = sym(tmp(idx));
+    end
+end
+
+for irule = 1:length(model.rule)
+    if(strcmp(model.rule(irule).typecode,'SBML_RATE_RULE'))
+        state_rate_idx = find(obj.state == sym(model.rule(irule).variable));
+        param_rate_idx = find(parameter_sym == sym(model.rule(irule).variable));
+        stoich_rate_idx = find(stoichsymbols == sym(model.rule(irule).variable));
+        if(~isempty(state_rate_idx))
+            obj.xdot(state_rate_idx) = cleanedsym(model.rule(irule).formula);
+            if(~onlysubstance_idx(state_rate_idx))
+                obj.xdot(state_rate_idx) = obj.xdot(state_rate_idx).*obj.volume(state_rate_idx);
+            end
+        elseif(~isempty(param_rate_idx))
+            obj.state = [obj.state; parameter_sym(param_rate_idx)];
+            obj.xdot = [obj.xdot; cleanedsym(model.rule(irule).formula)];
+            if(ismember(parameter_sym(param_rate_idx),initassignments_sym))
+                obj.initState = [obj.initState; initassignments_math(find(initassignments_sym==parameter_sym(param_rate_idx)))];
+            else
+                obj.initState = [obj.initState; parameter_val(param_rate_idx)];
+            end
+            obj.volume = [obj.volume; 1];
+            concentration_idx = [concentration_idx, false];
+            onlysubstance_idx = [onlysubstance_idx, false];
+            conversionfactor = [conversionfactor; 1];
+            cond_idx = [cond_idx, false ];
+            const_idx = [const_idx, false ];
+            bound_idx = [bound_idx, false];
+            nx = nx + 1;
+            parameter_val(param_rate_idx) = [];
+            parameter_sym(param_rate_idx) = [];
+            obj.param(param_rate_idx) = [];
+            np = np - 1;
+            setInitialAssignment(obj,model,'initState',initassignments_sym,initassignments_math);
+        elseif(~isempty(stoich_rate_idx))
+            obj.state = [obj.state; stoichsymbols(stoich_rate_idx)];
+            obj.xdot = [obj.xdot; cleanedsym(model.rule(irule).formula)];
+            obj.initState = [obj.initState; stoichmath(stoich_rate_idx)];
+            obj.volume = [obj.volume; 1];
+            concentration_idx = [concentration_idx, false];
+            onlysubstance_idx = [onlysubstance_idx, false];
+            conversionfactor = [conversionfactor; 1];
+            cond_idx = [cond_idx, false ];
+            const_idx = [const_idx, false ];
+            bound_idx = [bound_idx, false];
+            nx = nx + 1;
+            stoichmath(stoich_rate_idx) = [];
+            stoichsymbols(stoich_rate_idx) = [];
+        end
+    end
+    if(strcmp(model.rule(irule).typecode,'SBML_ASSIGNMENT_RULE'))
+        state_rate_idx = find(obj.state == sym(model.rule(irule).variable));
+        param_rate_idx = find(parameter_sym == sym(model.rule(irule).variable));
+        if(~isempty(state_rate_idx))
+            obj.state(state_rate_idx) = [];
+            obj.xdot(state_rate_idx) = [];
+            obj.initState(state_rate_idx) = [];
+            obj.volume(state_rate_idx) = [];
+            concentration_idx(state_rate_idx) = [];
+            onlysubstance_idx(state_rate_idx) = [];
+            conversionfactor(state_rate_idx) = [];
+            cond_idx(state_rate_idx) = [];
+            const_idx(state_rate_idx) = [];
+            bound_idx(state_rate_idx) = [];
+            nx = nx-1;
+            obj.observable = [obj.observable;cleanedsym(model.rule(irule).formula)];
+            obj.observable_name = [obj.observable_name;sym(model.rule(irule).variable)];
+        end
+    end
+end
+
+applyRule(obj,model,'xdot',rulevars,rulemath)
+
+
+%% CONVERSION FACTORS/VOLUMES
+
+% this.xdot = conversionfactor.*subs(this.xdot,this.state,this.state.*this.volume)./this.volume;
+obj.xdot = conversionfactor.*subs(obj.xdot,obj.state(onlysubstance_idx),obj.state(onlysubstance_idx).*obj.volume(onlysubstance_idx))./obj.volume;
+
+% this.xdot = conversionfactor.*this.xdot;
+
+%% EVENTS
+if verbose
+    fprintf('loading events ...\n')
+end
+
+if(sum(cellfun(@(x)numel(x),{model.event.delay})>0))
+    error('Events with delays are currently not supported!');
+end
+if(~strcmp(model.delay_symbol,''))
+    error('Delay symbols are currently not supported!');
+end
+if(model.SBML_level>=3)
+    if(sum(cellfun(@(x)numel(x),{model.event.priority})>0))
+        error('Event priorities are currently not supported!');
+    end
+end
+
+try
+    tmp = cellfun(@(x) sym(sanitizeString(x)),{model.event.trigger},'UniformOutput',false);
+    obj.trigger = [tmp{:}];
+catch
+    tmp = cellfun(@(x) sym(sanitizeString(x.math)),{model.event.trigger},'UniformOutput',false);
+    obj.trigger = [tmp{:}];
+end
+obj.trigger = obj.trigger(:);
+obj.trigger = subs(obj.trigger,sym('ge'),sym('am_ge'));
+obj.trigger = subs(obj.trigger,sym('gt'),sym('am_gt'));
+obj.trigger = subs(obj.trigger,sym('le'),sym('am_le'));
+obj.trigger = subs(obj.trigger,sym('lt'),sym('am_lt'));
+
+obj.bolus = sym(zeros([length(obj.state),length(obj.trigger)]));
+if(length(obj.trigger)>0)
+    for ievent = 1:length(obj.trigger)
+        tmp = cellfun(@(x) {x.variable},{model.event(ievent).eventAssignment},'UniformOutput',false);
+        assignments = sym(cat(2,tmp{:}));
+        
+        tmp = cellfun(@(x) {x.math},{model.event(ievent).eventAssignment},'UniformOutput',false);
+        assignments_math = cleanedsym(cat(2,tmp{:}));
+        
+        for iassign = 1:length(assignments)
+            state_assign_idx = find(assignments(iassign)==obj.state);
+            param_assign_idx = find(assignments(iassign)==obj.param);
+            cond_assign_idx = find(assignments(iassign)==condition_sym);
+            bound_assign_idx = find(assignments(iassign)==boundary_sym);
+            stoich_assign_idx = find(assignments(iassign)==stoichsymbols);
+            vol_assign_idx = find(assignments(iassign)==compartments_sym);
+            
+            if(np>0 && ~isempty(param_assign_idx))
+                error('Assignments of parameters via events are currently not supported')
+                obj.param(param_assign_idx) = obj.param(param_assign_idx)*heaviside(-obj.trigger(ievent)) + assignments_math(iassign)*heaviside(obj.trigger(ievent));
+            end
+            
+            if(nk>0 && ~isempty(cond_assign_idx))
+                error('Assignments of constants via events are currently not supported')
+                conditions(cond_assign_idx) = conditions(cond_assign_idx)*heaviside(-obj.trigger(ievent)) + assignments_math(iassign)*heaviside(obj.trigger(ievent));
+            end
+            
+            if(length(boundaries)>0 && ~isempty(bound_assign_idx))
+                error('Assignments of boundary conditions via events are currently not supported')
+                boundaries(bound_assign_idx) = conditions(bound_assign_idx)*heaviside(-obj.trigger(ievent)) + assignments_math(iassign)*heaviside(obj.trigger(ievent));
+            end
+            
+            if(length(stoichsymbols)>0 && ~isempty(stoich_assign_idx))
+                error('Assignments of stoichiometries via events are currently not supported')
+                stoichmath(stoich_assign_idx) = stoichmath(stoich_assign_idx)*heaviside(-obj.trigger(ievent)) + assignments_math(iassign)*heaviside(obj.trigger(ievent));
+            end
+            
+            if(length(compartments_sym)>0 && ~isempty(vol_assign_idx))
+                error('Assignments of compartment volumes via events are currently not supported')
+            end
+            
+            if(length(obj.state)>0 && ~isempty(state_assign_idx))
+                
+                obj.bolus(state_assign_idx,ievent) = -obj.state(state_assign_idx);
+                addToBolus = sym(zeros(size(obj.bolus(:,ievent))));
+                addToBolus(state_assign_idx) = assignments_math(iassign);
+                
+                obj.bolus(:,ievent) = obj.bolus(:,ievent) + addToBolus;
+            end
+            
+        end
+    end
+else
+    addToBolus = sym([]);
+end
+
+
+
+
+%% FUNCTIONS
+if verbose
+    fprintf('loading functions ...\n')
+end
+
+tmp = cellfun(@(x) x(8:end-1),{model.functionDefinition.math},'UniformOutput',false);
+lambdas = cellfun(@(x)argScan(x),tmp);
+
+if(~isempty(lambdas))
+    obj.funmath = cellfun(@(x) x{end},lambdas,'UniformOutput',false);
+    % temp replacement for any user defined function
+    tmpfun = cellfun(@(x) ['fun_' num2str(x)],num2cell(1:length(model.functionDefinition)),'UniformOutput',false);
+    obj.funmath = strrep(obj.funmath,{model.functionDefinition.id},tmpfun);
+    % replace helper functions
+    
+    checkIllegalFunctions(obj.funmath);
+    obj.funmath = replaceLogicalFunctions(obj.funmath);
+    
+    obj.funmath = strrep(obj.funmath,tmpfun,{model.functionDefinition.id});
+    obj.funarg = cellfun(@(x,y) [y '(' strjoin(transpose(x(1:end-1)),',') ')'],lambdas,replaceReservedFunctionIDs({model.functionDefinition.id}),'UniformOutput',false);
+    
+    % make functions available in this file
+    
+    for ifun = 1:length(obj.funmath)
+        token = regexp(obj.funarg(ifun),'\(([0-9\w\,]*)\)','tokens');
+        start = regexp(obj.funarg(ifun),'\(([0-9\w\,]*)\)');
+        eval([replaceReservedFunctions(obj.funarg{ifun}(1:(start{1}-1))) ' = @(' token{1}{1}{1} ')' obj.funmath{ifun} ';']);
+    end
+end
+
+
+%% CLEAN-UP
+if verbose
+    fprintf('cleaning up ...\n')
+end
+
+% remove constant/condition states
+obj.state(any([cond_idx;const_idx;bound_idx])) = [];
+obj.kvolume = obj.volume(any([cond_idx;const_idx;bound_idx]));
+obj.volume(any([cond_idx;const_idx;bound_idx])) = [];
+obj.initState(any([cond_idx;const_idx;bound_idx])) = [];
+obj.xdot(any([cond_idx;const_idx;bound_idx])) = [];
+obj.bolus(any([cond_idx;const_idx;bound_idx]),:) = [];
+
+% substitute with actual expressions, do this twice to resolve co-dependencies, do we need a loop here?
+makeSubs(obj,boundary_sym,boundaries);
+makeSubs(obj,condition_sym,conditions);
+makeSubs(obj,compartments_sym,obj.compartment);
+%makeSubs(this,stoichsymbols,stoichmath);
+makeSubs(obj,reactionsymbols,obj.flux);
+
+% set initial assignments
+for iIA = 1:length(initassignments_sym)
+    if(ismember(initassignments_sym(iIA),obj.param))
+        if(ismember(sym(model.time_symbol),symvar(initassignments_math(iIA))))
+            error('Time dependent initial assignments are currently not supported!')
+        end
+        param_idx =  find(initassignments_sym(iIA)==obj.param);
+        parameter_sym(param_idx) = [];
+        parameter_val(param_idx) = [];
+        obj.param(param_idx) = [];
+        obj.xdot = subs(obj.xdot,initassignments_sym(iIA),initassignments_math(iIA));
+        obj.trigger = subs(obj.trigger,initassignments_sym(iIA),initassignments_math(iIA));
+        obj.bolus = subs(obj.bolus,initassignments_sym(iIA),initassignments_math(iIA));
+        obj.initState = subs(obj.initState,initassignments_sym(iIA),initassignments_math(iIA));
+        obj.param = subs(obj.param,initassignments_sym(iIA),initassignments_math(iIA));
+        rulemath = subs(rulemath,initassignments_sym(iIA),initassignments_math(iIA));
+        np = np-1;
+    end
+end
+applyRule(obj,model,'param',rulevars,rulemath)
+
+makeSubs(obj,parameter_sym(1:np),obj.param);
+
+% apply rules to dynamics
+for irule = 1:length(rulevars)
+    eval(['syms ' strjoin(arrayfun(@char,rulevars(irule),'UniformOutput',false),' ') ' ' strrep(strrep(strjoin(arrayfun(@char,symvar(sym(rulemath(irule))),'UniformOutput',false),' '),'true',''),'false','')]);
+    eval(['rule = ' char(rulemath(irule)) ';']);
+    rule_idx = find(rulevars(irule)==obj.state);
+    if(nx>0)
+        obj.xdot(rule_idx) = jacobian(rule,obj.state)*obj.xdot;
+        obj.initState(rule_idx) = rulemath(irule);
+        if(~isempty(obj.bolus))
+            obj.bolus(rule_idx,:) = jacobian(rule,obj.state)*obj.bolus;
+        end
+    end
+end
+
+state_vars = [symvar(obj.xdot),symvar(obj.initState)];
+event_vars = [symvar(obj.bolus),symvar(obj.trigger)];
+
+applyRule(obj,model,'xdot',rulevars,rulemath)
+
+isUsedParam = or(ismember(parameter_sym,event_vars),ismember(parameter_sym,state_vars));
+isPartOfRule = and(ismember(parameter_sym,symvar(cleanedsym({model.rule.formula}))),ismember(parameter_sym,symvar(sym({model.rule.variable}))));
+isRuleVar = ismember(parameter_sym,sym({model.rule.variable}));
+hasAssignment = ismember(parameter_sym,initassignments_sym);
+obj.parameter = parameter_sym(and(not(isRuleVar),not(isPartOfRule)));
+obj.pnom = parameter_val(and(not(isRuleVar),not(isPartOfRule)));
+
+obj.condition = [condition_sym;constant_sym];
+obs_idx = all([isRuleVar,not(isPartOfRule),not(isUsedParam),not(hasAssignment)],2);
+obj.observable = [obj.observable;obj.param(obs_idx(1:length(obj.param)))];
+obj.observable_name = [obj.observable_name;parameter_sym(obs_idx(1:length(obj.param)))];
+
+equal_idx = logical(obj.observable(:)==obj.observable_name(:)); % this is the unused stuff
+obj.observable(equal_idx) = [];
+obj.observable_name(equal_idx) = [];
+
+obj.observable = subs(obj.observable,parameter_sym(1:np),obj.param);
+obj.observable = subs(obj.observable,condition_sym,conditions);
+obj.observable = subs(obj.observable,boundary_sym,boundaries);
+obj.observable = subs(obj.observable,compartments_sym,obj.compartment);
+obj.observable = subs(obj.observable,stoichsymbols,stoichmath);
+obj.observable = subs(obj.observable,reactionsymbols,obj.flux);
+
+applyRule(obj,model,'observable',rulevars,rulemath);
+
+obj.time_symbol = model.time_symbol;
+
+prohibited = sym({'null','beta'});
+alt_prohib = sym({'null_sym','beta_sym'});
+obj.parameter = subs(obj.parameter,prohibited,alt_prohib);
+obj.state = subs(obj.state,prohibited,alt_prohib);
+obj.condition = subs(obj.condition,prohibited,alt_prohib);
+while(any(ismember(symvar(obj.initState),obj.state)))
+    obj.initState = subs(obj.initState,obj.state,obj.initState);
+end
+end
+
+function setInitialAssignment(this,~,field,initassignments_sym,initassignments_math)
+this.(field) = subs(this.(field),initassignments_sym,initassignments_math);
+end
+
+
+function applyRule(this,~,field,rulevars,rulemath)
+this.(field) = subs(this.(field),rulevars,rulemath);
+end
+
+function args = argScan(str)
+brl = computeBracketLevel(str);
+
+l1_idx = find(brl==0); % store indexes
+
+% find commas but only in lowest bracket level
+c_idx = strfind(str(brl==0),',');
+str(l1_idx(c_idx)) = '@'; % replace by something that should never occur in equations
+args = textscan(str,'%s','Whitespace','@');
+end
+
+function makeSubs(this,old,new)
+this.xdot = subs(this.xdot,old,new);
+this.trigger = subs(this.trigger,old,new);
+this.bolus = subs(this.bolus,old,new);
+this.initState = subs(this.initState,old,new);
+end
+
+function checkIllegalFunctions(str)
+
+if(any(cell2mat(strfind(str,'factorial'))))
+    error('Factorial functions are currently not supported!')
+end
+if(any(cell2mat(strfind(str,'ceil'))))
+    error('Ceil functions are currently not supported!')
+end
+if(any(cell2mat(strfind(str,'floor'))))
+    error('Floor functions are currently not supported!')
+end
+end
+
+function csym = cleanedsym(str)
+if(nargin>0)
+    matVer = ver('MATLAB');
+    if(str2double(matVer.Version)>=9.4)
+        csym = str2sym(sanitizeString(str));
+    else
+        csym = sym(sanitizeString(str));
+    end
+else
+    csym = sym(0);
+end
+end
+
+function str = sanitizeString(str)
+% wrapper for replaceDiscontinuousFunctions() and replaceReservedFunctions()
+str = replaceLogicalFunctions(str);
+str = replaceReservedFunctions(str);
+end
+
+function str = replaceLogicalFunctions(str)
+% replace imcompatible piecewise defintion
+% execute twice for directly nested calls (overlapping regexp expressions)
+for logicalf = {'piecewise','and','or','lt','gt','ge','le','ge','le','xor','eq'}
+    str = regexprep(str,['^' logicalf{1} '('],['am_' logicalf{1} '(']);
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+end
+end
+
+function str = replaceReservedFunctions(str)
+% replace reserved matlab functions
+
+if(strcmp(str,'this'))
+    error('SBML functions may not be called ''this''');
+end
+
+for logicalf = {'divide','minus','multiply','plus'}
+    str = regexprep(str,['^' logicalf{1} '('],['am_' logicalf{1} '(']);
+    % execute twice for directly nested calls (overlapping regexp expressions)
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+    str = regexprep(str,['([\W]+)' logicalf{1} '('],['$1am_' logicalf{1} '(']);
+end
+end
+
+function str = replaceReservedFunctionIDs(str)
+% replace reserved matlab functions
+for logicalf = {'divide','minus','multiply','plus'}
+    str = regexprep(str,['^' logicalf{1} '$'],['am_' logicalf{1} '']);
+end
+end
+
+function z = delay(x,y)
+error('Events with delays are currently not supported!');
+end
+
+function x = stoich_initAssign_rule(y,initassignments_sym,initassignments_math,rulevars,rulemath)
+x = {};
+for iy = 1:length(y)
+    x{iy} = sym(y(iy).stoichiometry);
+    if(~isempty(sym(y(iy).id)))
+        if(~isempty(initassignments_sym))
+            if(ismember(sym(y(iy).id),initassignments_sym))
+                x{iy} = subs(sym(y(iy).id),initassignments_sym,initassignments_math);
+            end
+        end
+        if(~isempty(rulevars))
+            if(ismember(sym(y(iy).id),rulevars))
+                x{iy} = subs(sym(y(iy).id),rulevars,rulemath);
+            end
+        end
+    end
+end
+end
+
+function expr = math_expr(y)
+if(isfield(y,'math'))
+    expr = cleanedsym(y.math);
+else
+    expr = cleanedsym();
+end
+end
+
+function id = getId(x)
+if(isfield(x,'id'))
+    id = {x.id};
+else
+    id = {x.species};
+end
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/writeAMICI.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/writeAMICI.m
new file mode 100644
index 0000000000000000000000000000000000000000..17eddcbfd8b80880c71cf06e175fe216272eb293
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/@SBMLode/writeAMICI.m
@@ -0,0 +1,133 @@
+function writeAMICI(obj, modelname, outdir, verbose)
+    % writeAMICI writes the symbolic information from an SBMLode object
+    % into an AMICI model definition file
+    %
+    % Parameters:
+    %  modelname: target name of the model (_syms.m will be appended to the name )
+    %
+    % Return values:
+    % void
+    
+    if nargin == 3
+        verbose = false;
+    end
+    
+    if verbose
+        fprintf('writing file ...\n')
+    end
+    
+    if ~exist(outdir)
+        fprintf("Provided directory not found.")
+        fid = fopen([modelname '_syms.m'],'w');
+    else
+        fid = fopen(fullfile(outdir, [modelname '_syms.m']),'w');
+    end
+    
+    fprintf(fid,['function model = ' modelname '_syms()\n']);
+    fprintf(fid,'\n');
+    if(strcmp(obj.time_symbol,''))
+        fprintf(fid,'t = sym(''t'');\n');
+    else
+        fprintf(fid,[obj.time_symbol ' = sym(''t'');\n']);
+    end
+    
+    fprintf(fid,'\n');
+    fprintf(fid,'avogadro = 6.02214179e23;');
+    
+%     fprintf(fid,'model.debug = true;\n');
+    writeDefinition('STATES','x','state',obj,fid)
+    writeDefinition('PARAMETERS','p','parameter',obj,fid)
+    writeDefinition('CONDITIONS','k','condition',obj,fid)
+    writeDerived('DYNAMICS','xdot','xdot',obj,fid)
+    writeDerived('INITIALIZATION','x0','initState',obj,fid)
+    writeDerived('OBSERVABLES','y','observable',obj,fid)
+    fprintf(fid,'\n');
+    fprintf(fid,'\n');
+    fprintf(fid,['% EVENTS\n']);
+    for ievent = 1:length(obj.trigger)
+        str_trigger = char(obj.trigger(ievent));
+        str_bolus = strjoin(arrayfun(@char,obj.bolus(:,ievent),'UniformOutput',false),',');
+        fprintf(fid,['model.event(' num2str(ievent) ') = amievent(' ...
+            str_trigger ', ...\n' ...
+            '[' str_bolus '], ...\n' ...
+            '[]);\n']);
+    end
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'function r = pow(x,y)\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'    r = x^y;\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'function r = power(x,y)\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'    r = x^y;\n');
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+    
+    for ifun = 1:length(obj.funmath)
+        fprintf(fid,['function r = ' obj.funarg{ifun} '\n']);
+        fprintf(fid,'\n');
+        fprintf(fid,['    r = ' obj.funmath{ifun} ';\n']);
+        fprintf(fid,'\n');
+        fprintf(fid,'end\n');
+        fprintf(fid,'\n');
+    end 
+    
+    for fun = {'factorial','cei','psi'}
+        fprintUnsupportedFunctionError(fun{1},fid)
+    end
+    
+    fclose(fid);
+end
+
+function writeDefinition(header,identifier,field,this,fid)
+    fprintf(fid,'\n');
+    fprintf(fid,'\n');
+    fprintf(fid,['%%%%\n%% ' header '\n']);
+    if(length(this.(field))>0)
+        vars = strjoin(cellfun(@char,num2cell(this.(field)),'UniformOutput',false));
+        
+        tmp_string = string(split(vars, ' '));
+        tmp_idx = find(arrayfun(@exist, tmp_string));
+        for i = 1:numel(tmp_idx)
+            idx = tmp_idx(i);
+            tmp = sprintf('%s = sym("%s");', tmp_string(idx), tmp_string(idx));
+            fprintf(fid,[tmp '\n']);
+        end
+        
+        tmp_string(tmp_idx) = [];
+        vars = char(join(tmp_string, ' '));        
+        
+        fprintf(fid,['syms ' vars '\n']);
+    end
+    fprintf(fid,['model.' identifier ' = [' strjoin(cellfun(@char,num2cell(this.(field)),'UniformOutput',false),',') '];\n']);
+end
+
+function writeDerived(header,identifier,field,this,fid)
+    fprintf(fid,'\n');
+    fprintf(fid,'\n');
+    fprintf(fid,['%%%%\n%% ' header '\n']);
+    fprintf(fid,'\n');
+    if(strcmp(header,'OBSERVABLES'))
+        fprintf(fid,['%% ' strjoin(cellfun(@char,num2cell(this.observable_name),'UniformOutput',false),'\n%% ')  '\n']);
+    elseif (strcmp(header,'DYNAMICS'))
+        compartment = string(this.compartment);
+        compartment = char(join(compartment, ' '));
+        fprintf(fid, ['syms ' compartment '\n']);
+    end
+    
+    fprintf(fid,['model.' identifier ' = [' strjoin(cellfun(@char,num2cell(this.(field)),'UniformOutput',false),', ...\n') '];']);
+end
+
+function fprintUnsupportedFunctionError(functionName,fid)
+    fprintf(fid,['function r = ' functionName '(x)\n']);
+    fprintf(fid,'\n');
+    fprintf(fid,['    error(''The ' functionName ' function is currently not supported!'');\n']);
+    fprintf(fid,'\n');
+    fprintf(fid,'end\n');
+    fprintf(fid,'\n');
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/computeBracketLevel.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/computeBracketLevel.m
new file mode 100644
index 0000000000000000000000000000000000000000..ec1c6621dbf927d3e2a7b556281b96d4dc46beec
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/SBMLimporter/computeBracketLevel.m
@@ -0,0 +1,29 @@
+function [ brl ] = computeBracketLevel( cstr )
+    % Compute the bracket level for the input string cstr. The bracket
+    % level is computed for every char in cstr and indicates how many
+    % brackets have been opened up to this point. The bracket level is
+    % useful to parse the arguments of functions in cstr. For this purpose
+    % functions will have the same bracket level as the opening bracket of
+    % the corresponding function call.
+    %
+    % Parameters:
+    %  cstr: input string @type *char
+    %
+    % Return values:
+    %  brl: bracket levels @type *int
+    
+    % compute bracket levels add one for each (, (before) remove 1 for each
+    % ) (after)
+    open = (cstr == '(');
+    close = (cstr == ')');
+    close = [0,close(1:end-1)];
+    brl = cumsum(open) - cumsum(close);
+    % take care of functions
+    fun_startidx = regexp(cstr,'([\w_]+\()','start');
+    fun_endidx = regexp(cstr,'([\w_]+\()','end');
+    for ifun = 1:length(fun_startidx)
+        brl(fun_startidx(ifun):(fun_endidx(ifun)-1)) = brl(fun_endidx(ifun));
+    end
+    
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_and.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_and.m
new file mode 100644
index 0000000000000000000000000000000000000000..6362b6e8a05cbaefebbe307f4125d17e21db33b7
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_and.m
@@ -0,0 +1,11 @@
+function fun = am_and(a,b)
+% am_and is the amici implementation of the symbolic and function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+fun = am_min(a,b);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_eq.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_eq.m
new file mode 100644
index 0000000000000000000000000000000000000000..6ede0e56090c8fce247a54eb3fa47e6bfc59f2ea
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_eq.m
@@ -0,0 +1,10 @@
+function fun = am_eq(varargin)
+% am_eq is currently a placeholder that simply produces an error message
+%
+% Parameters:
+%  varargin: elements for chain of equalities 
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+error('Logical operator ''eq'' is currently not supported!');
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_ge.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_ge.m
new file mode 100644
index 0000000000000000000000000000000000000000..8225db70699ae07cba3b6d2b53925ebe1ac0f43e
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_ge.m
@@ -0,0 +1,17 @@
+function fun = am_ge(varargin)
+% am_ge is the amici implementation of the n-ary mathml greaterorequal function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} >= varargin{2},varargin{2} >= varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a >= b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = a-b;
+if(nargin>2)
+    fun = am_and(a-b,am_ge(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_gt.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_gt.m
new file mode 100644
index 0000000000000000000000000000000000000000..3c076b3ab076170c8b775441ebc26ec3ad6a5586
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_gt.m
@@ -0,0 +1,17 @@
+function fun = am_gt(varargin)
+% am_gt is the amici implementation of the n-ary mathml greaterthan function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} > varargin{2},varargin{2} > varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a > b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = a-b;
+if(nargin>2)
+    fun = am_and(a-b,am_gt(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_if.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_if.m
new file mode 100644
index 0000000000000000000000000000000000000000..6673023a68a8c4af7a62d61e91df2942f43c3e30
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_if.m
@@ -0,0 +1,24 @@
+function fun = am_if(condition, truepart, falsepart)
+% am_if is the amici implementation of the symbolic if function
+%
+% Parameters:
+%  condition: logical value @type sym
+%  truepart: value if condition is true @type sym
+%  falsepart: value if condition is false @type sym
+%
+% Return values:
+%  fun: if condition is true truepart, else falsepart
+if(islogical(condition))
+    if(condition)
+        fun = truepart;
+    else
+        fun = falsepart;
+    end
+else
+    if(logical(condition~=0))
+        fun = falsepart + heaviside(condition)*(truepart-falsepart);
+    else
+        fun = falsepart;
+    end
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_le.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_le.m
new file mode 100644
index 0000000000000000000000000000000000000000..3016b7d6b2414d6c49934f3937b52c161f40667c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_le.m
@@ -0,0 +1,17 @@
+function fun = am_le(varargin)
+% am_le is the amici implementation of the n-ary mathml lessorequal function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} <= varargin{2},varargin{2} <= varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a <= b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = b-a;
+if(nargin>2)
+    fun = am_and(b-a,am_le(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_lt.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_lt.m
new file mode 100644
index 0000000000000000000000000000000000000000..67ec79f6019eac2a7778ae51a1c6fe45343c2e5c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_lt.m
@@ -0,0 +1,17 @@
+function fun = am_lt(varargin)
+% am_lt is the amici implementation of the n-ary mathml lessthan function
+% this is an n-ary function, for more than 2 input parameters it will check
+% whether and(varargin{1} < varargin{2},varargin{2} < varargin{3},...)
+%
+% Parameters:
+%  varargin: chain of input parameters @type sym
+%
+% Return values:
+%  fun: a < b logical value, negative for false, positive for true
+a=varargin{1};
+b=varargin{2};
+fun = b-a;
+if(nargin>2)
+    fun = am_and(b-a,am_lt(varargin{2:end}));
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_max.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_max.m
new file mode 100644
index 0000000000000000000000000000000000000000..54ba55fd0bf56b84c20cd16fdd807b2025bdcf1c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_max.m
@@ -0,0 +1,11 @@
+function fun = am_max(a, b)
+% am_max is the amici implementation of the symbolic max function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: maximum of a and b
+fun = sym(['am_max(' char(sym(a)) ',' char(sym(b)) ',0.0)']);
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_min.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_min.m
new file mode 100644
index 0000000000000000000000000000000000000000..068d2dc2d6721fb3b2ba526ea7784e0ffaef1f11
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_min.m
@@ -0,0 +1,11 @@
+function fun = am_min(a, b)
+% am_min is the amici implementation of the symbolic min function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: minimum of a and b
+fun = -am_max(-a,-b);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_or.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_or.m
new file mode 100644
index 0000000000000000000000000000000000000000..e948070061b08d2fe71354750f5b8bb54913b055
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_or.m
@@ -0,0 +1,11 @@
+function fun = am_or(a,b)
+% am_or is the amici implementation of the symbolic or function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+fun = am_max(a,b);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_piecewise.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_piecewise.m
new file mode 100644
index 0000000000000000000000000000000000000000..7a9be67bff3b6f3f916351a2c9cecabd56091b8c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_piecewise.m
@@ -0,0 +1,13 @@
+function fun = am_piecewise( piece,condition,default )
+% am_piecewise is the amici implementation of the mathml piecewise function
+%
+% Parameters:
+%  piece: value if condition is true
+%  condition: logical value
+%  default: value if condition is false
+%
+% Return values:
+%  fun: return value, piece if condition is true, default if not
+    fun = am_if(condition,piece,default);
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_spline.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_spline.m
new file mode 100644
index 0000000000000000000000000000000000000000..ff33784f66a0ff3b1b229a1ed3c0f19bcf0a9ae1
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_spline.m
@@ -0,0 +1,14 @@
+function splinefun = am_spline(varargin)
+    n = nargin;
+    str= '';
+    if (round(n/2) - n/2 < 0.1)
+        error('Input arguments of am_spline must have the following form: t, t1, p2, ..., tn, pn, intss, dudt');
+    end
+    for i = 1 : n-1
+        str = strcat(strcat(str, char(varargin{i})), ',');
+    end
+    str = strcat('(',strcat(strcat(str, char(varargin{n})), ')'));
+    str = strrep(str, ' ', '');
+    str = regexprep(str,'\,([0-9]*)\,','\,$1\.0\,'); % Black magic of sym
+    splinefun = sym(strcat('spline', str));
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_spline_pos.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_spline_pos.m
new file mode 100644
index 0000000000000000000000000000000000000000..32775d48e6f0a8b306aacb57359459908a86f0ba
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_spline_pos.m
@@ -0,0 +1,33 @@
+function splinefun = am_spline_pos(varargin)
+    n = nargin;
+    str= '';
+    if (round(n/2) - n/2 > 0.1)
+        error('Input arguments of am_spline must have the following form: t, #ofNodes, t1, p1, ..., tn, pn, intss, dudt');
+    end
+    for i = 1 : n
+        if (i < n)
+            switch class(varargin{i})
+                case 'sym'
+                    str = strcat(strcat(str, char(vpa(varargin{i}))), ',');
+                case 'double'
+                    str = strcat(strcat(str, char(vpa(sym(varargin{i}))), ','));
+                otherwise
+                    error(['Input argument ' num2str(i) ' of the splinefunction seems to be neither a symbolic nor a double. Please check, if it is correctly defined.']);
+            end
+        else
+            switch class(varargin{i})
+                case 'sym'
+                    str = strcat(str, char(vpa(varargin{i})));
+                case 'double'
+                    str = strcat(str, char(vpa(sym(varargin{i}))));
+                otherwise
+                    error(['Input argument ' num2str(i) ' of the splinefunction seems to be neither a symbolic nor a double. Please check, if it is correctly defined.']);
+            end
+        end
+
+    end
+    str = strcat('(',strcat(strcat(str, char(varargin{n})), ')'));
+    str = strrep(str, ' ', '');
+    
+    splinefun = sym(strcat('spline_pos', str));
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_stepfun.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_stepfun.m
new file mode 100644
index 0000000000000000000000000000000000000000..53749f1d4c7c4b8bf45529851423452d485d6419
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_stepfun.m
@@ -0,0 +1,14 @@
+function fun = am_stepfun(t,tstart,vstart,tend,vend)
+% am_stepfun is the amici implementation of the step function 
+%
+% Parameters:
+%  t: input variable @type sym
+%  tstart: input variable value at which the step starts
+%  vstart: value during the step
+%  tend: input variable value at which the step end
+%  vend: value after the step
+%
+% Return values:
+%  fun: 0 before tstart, vstart between tstart and tend and vend after tend
+fun = heaviside(t-tstart)*vstart - heaviside(t-tend)*(vstart-vend);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_xor.m b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_xor.m
new file mode 100644
index 0000000000000000000000000000000000000000..9f8b26a238f42ba7b14590c2cbc023d3432c7dae
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/Sbml2Meigo/symbolic/am_xor.m
@@ -0,0 +1,12 @@
+function fun = am_xor(a,b)
+% am_xor is the amici implementation of the symbolic exclusive or function
+%
+% Parameters:
+%  a: first input parameter @type sym
+%  b: second input parameter @type sym
+%
+% Return values:
+%  fun: logical value, negative for false, positive for true
+
+fun = am_and(am_or(a,b),-am_and(a,b));
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/auxiliar/Dict.m b/Requirements/MEIGO/PEtabMEIGO/auxiliar/Dict.m
new file mode 100644
index 0000000000000000000000000000000000000000..0610684f01c30da396cae889c31a62fb3da8adcf
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/auxiliar/Dict.m
@@ -0,0 +1,214 @@
+classdef Dict < handle & matlab.mixin.Copyable
+    %Implementation of python's like dictionary class.
+    %
+    %Properties:
+    %   keys [string]:
+    %       String array of dictionary keys.
+    %   values [cell array]:
+    %       Cell array of values.
+    
+    properties (SetAccess = private)
+        keys string = string.empty();
+        values cell = cell.empty();
+    end
+    
+    methods
+        %% CLASS CONSTRUCTOR
+        function obj = Dict(keys, values)
+            %Dict constructor.
+            
+            if nargin == 0
+                return
+            end
+            
+            tmp = size(keys);
+            if tmp(1) ~= 1
+                keys = transpose(keys);
+            end
+            
+            tmp = size(values);
+            if tmp(1) ~= 1
+                values = transpose(values);
+            end
+            
+            obj.addpairs(keys, values);
+        end
+        %% OVERLOADED METHODS
+        function varargout = subsref(obj,s)
+            %Custom subsref method.
+            
+            switch s(1).type
+                case '.'
+                    [varargout{1:nargout}] = builtin('subsref',obj,s);
+                case '()'
+                    if numel(s) == 1
+                        % Dict(key/s)
+                        
+                        subs = s(1).subs{:};
+                        if isnumeric(subs) %Allows indexing of Dict arrays.
+                            [varargout{1:nargout}] = builtin('subsref', ...
+                                obj, s);                            
+                            return
+                        end                        
+                        
+                        if numel(subs) > 1
+                            varargout{1} = obj.valueSearch(subs);
+                        else
+                            [varargout{1:nargout}] = obj.valueSearch(subs);
+                        end
+                        
+                        
+                    else
+                        % Use built-in for any other expression
+                    
+                        [varargout{1:nargout}] = builtin('subsref', obj, s);
+                    end
+                case '{}'
+                    [varargout{1:nargout}] = builtin('subsref', obj, s);
+                otherwise
+                    error('SUBSREF:WrongIndexExpressionError', ...
+                        'Not a valid indexing expression')
+            end
+        end
+        
+        function obj = subsasgn(obj,s,varargin)
+            %Custom subsasgn method.
+            
+            if isequal(obj,[])
+                obj = Dict();
+            end
+            
+            switch s(1).type
+                case '.'
+                    obj = builtin('subsasgn',obj,s,varargin{:});
+                case '()'
+                    if numel(s) == 1
+                        % Dict(keys) = varargin{:};
+                        
+                        subs = s(1).subs;
+                        if numel(subs) > 1
+                            subs = string(subs);
+                        else
+                            subs = string(subs{1});
+                        end
+                        
+                        if numel(subs) > 1
+                            error('SUBSASGN:AssignmentError', ...
+                                ['Multiple assignment not allowed', ...
+                                'Use addpairs method instead'])
+                        else                        
+                            obj.keys = subs;
+                            keyidx = obj.keyindex(subs);
+
+                            obj.values{keyidx} = varargin{:};
+                        end
+                    else
+                        % Use built-in for any other expression
+                        
+                        obj = builtin('subsasgn',obj,s,varargin{:});
+                    end
+                case '{}'
+                    obj = builtin('subsasgn',obj,s,varargin{:});
+                otherwise
+                    error('SUBSASGN:WrongIndexExpressionError', ...
+                        'Not a valid indexing expression')
+            end
+        end
+        %% SET METHODS
+        function set.keys(obj, keys)
+            %keys property set method.
+            
+            obj.keys = horzcat(obj.keys, keys);
+            obj.keys = unique(obj.keys, 'stable');
+        end
+        %% OBJECT METHODS
+        function obj = sort(obj)
+            %Sorts dictionary's keys in ascending order.
+            
+            obj = Dict.sortDict(obj);
+        end
+        
+        function addpairs(obj, keys, values)
+            %Add multiple key-value pairs to dictionary.
+            obj.keys = keys;
+            keyidx = map(@obj.keyindex, keys);          
+            
+            if isnumeric(values)
+                values = num2cell(values);
+            elseif isstring(values) || ischar(values)
+                values = cellstr(values);
+            end           
+            
+            obj.values(keyidx) = values;
+        end
+    end
+    
+    methods (Access = private)
+        %% AUXILIAR METHODS
+        function out = keyindex(obj, keys) %-> int
+            %Retrieves index of given  dictionary's key.
+            %
+            %Parameters:
+            %   keys [string]:
+            %       Dictionary key/s.
+            %
+            %Returns:
+            %   int:
+            %       Key/s index.
+            
+            [~, out] = intersect(obj.keys, keys);
+        end
+        
+        function out = valueSearch(obj, keys) %-> any
+            %Retrieves value of given dictionary's key.
+            %
+            %Parameters:
+            %   key [string]:
+            %       Dictionary key/s.
+            %
+            %Returns:
+            %   [cell]:
+            %       Key/s value.
+            
+            idx = obj.keyindex(keys);
+            
+            if isempty_ext(idx)
+                error('VALUESEARCH:KeyNotFoundError', ...
+                    'Key/s not in dictionary.')
+            else
+                if numel(idx) > 1
+                    out = obj.values(idx);
+                else
+                    out = obj.values{idx};
+                end
+            end
+        end
+    end
+    
+    methods (Static)
+        %% CLASS METHODS
+        function out = sortDict(dict) %-> [Dict]
+            %Returns a copy of given dictionary with keys sorted in
+            %ascending order.
+            %
+            %Parameters:
+            %   dict [Dict]:
+            %       A dictionary object.
+            %
+            %Returns:
+            %   [Dict]:
+            %       Key-sorted dictionary object.
+            
+            [sortedKeys, idx] = sort(dict.keys);
+            sortedValues = dict.values(idx);
+            
+            out = Dict(sortedKeys, sortedValues);
+        end
+        
+        function out = isDict(input) %-> bool
+            %Returns true if "input" is an instance of "Dict" class.
+            
+            out = isa(input, 'Dict');
+        end
+    end      
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/auxiliar/flatten.m b/Requirements/MEIGO/PEtabMEIGO/auxiliar/flatten.m
new file mode 100644
index 0000000000000000000000000000000000000000..8b048c8acdfcc5c33550ea3e3c29e84ed2487c50
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/auxiliar/flatten.m
@@ -0,0 +1,32 @@
+function out = flatten(input) %-> [cell, struct]
+    %Utility function to flatten a cell array/struct with nested cell 
+    %arrays/structs.
+    %
+    %Parameters:
+    %   input [cell, struct]:
+    %       Cell array or struct to be flattened.
+    %
+    %Results:
+    %   [cell]:
+    %       Flattened cell array
+    
+    if ~iscell(input) && ~isstruct(input)
+        error('FLATTEN:WrongInputTypeError', ...
+            'Input argument must be a cell array or a struct')
+    end
+    
+    if isstruct(input)
+        input = struct2cell(input);
+    end
+    
+    out = {};
+    for i = 1:numel(input)
+        if iscell(input{i}) || isstruct(input)
+            out = horzcat(out, flatten(input{i}));
+        elseif isstruct(input{i})
+            out = horzcat(out, flatten(struct2cell(input{i})));
+        else
+            out = horzcat(out, input(i));
+        end
+    end    
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/auxiliar/isempty_ext.m b/Requirements/MEIGO/PEtabMEIGO/auxiliar/isempty_ext.m
new file mode 100644
index 0000000000000000000000000000000000000000..5fca34c27134901f4b287bc5daf9e05b6067a593
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/auxiliar/isempty_ext.m
@@ -0,0 +1,6 @@
+function out = isempty_ext(input) %-> bool
+    %Returns true if "input" is empty. Matlab builtin isempty extension
+    %which considers character array '' as an empty object. 
+    
+    out = isempty(input) || isequal(input, '');
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/auxiliar/map.m b/Requirements/MEIGO/PEtabMEIGO/auxiliar/map.m
new file mode 100644
index 0000000000000000000000000000000000000000..7e5d846908917d0bda2b756e74833d854ef81c48
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/auxiliar/map.m
@@ -0,0 +1,12 @@
+function varargout = map(handle, varargin)
+    %TODO       
+    
+    if iscell(varargin{1})
+        [varargout{1:nargout}] = cellfun(handle, varargin{:});
+    elseif isnumeric(varargin{1}) || isstring(varargin{1})
+        [varargout{1:nargout}] = arrayfun(handle, varargin{:});
+    else
+        error('MAP:WrongListTypeError', ...
+            '"list" input must be of type cell or string array')
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/conditions/get_condition_df.m b/Requirements/MEIGO/PEtabMEIGO/conditions/get_condition_df.m
new file mode 100644
index 0000000000000000000000000000000000000000..99374e6385edba2eda945a25f9c2db032ac8ee5a
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/conditions/get_condition_df.m
@@ -0,0 +1,35 @@
+function out = get_condition_df(condition_file_name) %-> [table]
+    %Read the provided condition file into a table.
+    %
+    %Conditions are rows, parameters are columns.
+    %
+    %Parameters:
+    %   condition_file_name Union[string, table, []]:
+    %                        File name of PEtab condition file.
+    %
+    %Returns:
+    %   [table]: 
+    %       Condition table.
+    
+    out = condition_file_name;
+    if isempty_ext(condition_file_name) || istable(condition_file_name)       
+        return
+    elseif ~exist(condition_file_name, 'file')
+        error('GET_CONDITION_DF:FileNotFoundError', ...
+            'No such file')
+    end        
+    
+    out = readtable(condition_file_name, ...
+        'FileType', 'text', ...
+        'ReadVariableNames', true, ...
+        'PreserveVariableNames', true, ...
+        'Delimiter', 'tab');
+    
+    columns = string(out.Properties.VariableNames);
+    if ~ismember('conditionId', columns)
+        error('GET_CONDITION_DF:MandatoryFieldNotInTableError', ...
+            'Condition table missing mandatory field "conditionId"')
+    end    
+    
+    assert_no_leading_trailing_whitespace(columns, 'condition') 
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/core/concat_tables.m b/Requirements/MEIGO/PEtabMEIGO/core/concat_tables.m
new file mode 100644
index 0000000000000000000000000000000000000000..e868faaa67d16e182e69ea45faf076effcaa5448
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/core/concat_tables.m
@@ -0,0 +1,31 @@
+function out = concat_tables(tables, file_parser) %-> [table]
+    %Concatenate tables provided as tables or filenames, and a parser.
+    %
+    %Parameters:
+    %   tables [table, string]:
+    %       Tables to join, as tables or filenames.
+    %   file_parser [function handle]:
+    %       Function used to read the table in case filenames are provided,
+    %       accepting a filename as only argument.
+    %
+    %Returns:
+    %   [table]
+    %       The concatenated tables.
+    
+    if istable(tables)
+        out = tables;
+        return
+    elseif isscalar(tables) || ischar(tables)
+        out = file_parser(tables);
+        return
+    end
+    
+    if isstring(tables)
+        tables = map(file_parser, tables);
+    end
+    
+    out = tables{1};
+    for i = 2:numel(tables)
+        out = union(out, tables{i}, 'stable', 'rows');
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/core/get_notnull_columns.m b/Requirements/MEIGO/PEtabMEIGO/core/get_notnull_columns.m
new file mode 100644
index 0000000000000000000000000000000000000000..9997d0be82a206e2f981b9eb0c5894cf800c162b
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/core/get_notnull_columns.m
@@ -0,0 +1,21 @@
+function out = get_notnull_columns(df, candidates) %-> [string]
+    %Return list of 'df' columns in 'candidates' which are not all NaN.
+    %
+    %Parameters:
+    %   df [table]:
+    %       MATLAB table.
+    %   candidates [string]:
+    %       Columns of 'df' to consider.
+    %
+    %Returns:
+    %   [string]
+    %       String array of columns of 'df' in 'candidates' which are not
+    %       all NaN.
+    
+    df_cols = string(df.Properties.VariableNames);
+    [candidates, ia] = intersect(df_cols, candidates, 'stable');
+    
+    testfunc = @(c) ~(isnumeric(c) && all(isnan(c)));    
+    out = candidates(varfun(testfunc, df(:, ia), 'OutputFormat', ...
+        'uniform'));
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/core/to_float_if_float.m b/Requirements/MEIGO/PEtabMEIGO/core/to_float_if_float.m
new file mode 100644
index 0000000000000000000000000000000000000000..41d0a64237c955664e1c1080da17fc408d07c9b1
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/core/to_float_if_float.m
@@ -0,0 +1,23 @@
+function out = to_float_if_float(x) %-> any
+    %Return input as float if possible, otherwise return as is.
+    %
+    %Parameters:
+    %   x [any]:
+    %       Anything.
+    %
+    %Returns:
+    %   "x" as float if possible, otherwise "x".
+    
+    if iscell(x)
+        x = x{:};
+    end
+    
+    if ischar(x)
+        x = string(x);
+    end
+    
+    out = double(x);
+    if isstring(x) && isnan(out)
+        out = x;
+    end            
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/libsbml_extension/Sbml.m b/Requirements/MEIGO/PEtabMEIGO/libsbml_extension/Sbml.m
new file mode 100644
index 0000000000000000000000000000000000000000..254670d11e8058824a3ad7355fd1851b0f30f672
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/libsbml_extension/Sbml.m
@@ -0,0 +1,101 @@
+classdef Sbml < handle & dynamicprops & matlab.mixin.CustomDisplay & ...
+        matlab.mixin.Copyable
+    %Wrapper class of libsbml SBML struct.
+    %
+    %Properties:
+    %   sbml (hidden) [libsbml struct]:
+    %       libsbml SBML model struct.
+    %   *others (dynamic) [any]:
+    %       Dynamic properties added in function of libsbml struct fields.
+    
+    properties (Hidden = true)
+        sbml struct = struct.empty();
+    end
+    
+    methods
+        %% CLASS CONSTRUCTOR
+        function obj = Sbml(modelpath)
+            %Sbml class constructor.
+            
+            if nargin == 0
+                return
+            end
+            
+            obj.sbml = TranslateSBML(modelpath);
+            
+            fields = string(fieldnames(obj.sbml));
+            P = map(@obj.addprop, fields);
+            for i = 1:numel(fields)
+                P(i).SetAccess = 'private';                
+                obj.(fields(i)) = obj.sbml.(fields(i));
+            end
+        end
+        
+        %% SETTERS AND GETTER
+        function out = get.sbml(obj)
+            %sbml property getter method.
+            
+            out = obj.sbml;
+        end
+        
+        %% OBJECT METHODS
+        function out = isElementById(obj, sym) %-> any
+            %TODO          
+            
+            tmp = flatten(obj.sbml);
+            out = any(map(@(x) isequal(sym, x), tmp));
+        end
+        
+        function out = getAssignmentRuleByVariable(obj, varid) %-> libsbml rule struct
+            %Returns SBML assignment rule with given ID.
+            
+            mask = strcmp('SBML_ASSIGNMENT_RULE', ...
+                {obj.rule.typecode}) & strcmp(varid, ...
+                {obj.rule.variable});
+            
+            out = obj.rule(mask);
+        end
+        
+        function out = getSpecies(obj, id) %-> libsbml species struct
+            %Returns SBML species with given ID.
+            
+            out = obj.species(strcmp(id, {obj.species.id}));
+        end
+        
+        function out = getCompartment(obj, id) %-> libsbml compartment struct
+            %Returns SBML compartment with given ID.
+            
+            out = obj.compartment(strcmp(id, {obj.compartment.id}));
+        end
+    end
+    
+    methods (Access = protected)
+        %% OVERLOADED METHODS
+        function propgrp = getPropertyGroups(obj)
+            %Customized Display of Class Sbml.
+            
+            if ~isscalar(obj) || isempty_ext(obj.sbml)
+                propgrp = ...
+                    getPropertyGroups@matlab.mixin.CustomDisplay(obj);
+            else
+                propList = obj.sbml;
+                
+                fields = string(fieldnames(propList));                
+                for i = 1:numel(fields)
+                    propList.(fields(i)) = obj.(fields(i));
+                end
+                
+                propgrp = matlab.mixin.util.PropertyGroup(propList);
+            end
+        end
+    end
+    
+    methods (Static)
+        function out = isSbml(input)
+            %Returns true if "input" is an instance of "Sbml" class.
+            
+            out = isa(input, 'Sbml');
+        end
+    end
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/lint/assert_no_leading_trailing_whitespace.m b/Requirements/MEIGO/PEtabMEIGO/lint/assert_no_leading_trailing_whitespace.m
new file mode 100644
index 0000000000000000000000000000000000000000..c5e48fcb86ff7d404600737896d7b380e2c9aeac
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/lint/assert_no_leading_trailing_whitespace.m
@@ -0,0 +1,22 @@
+function assert_no_leading_trailing_whitespace(names_list, name)
+    %Check that there is no trailing whitespace in elements of an Array or
+    %Cell Array of Strings.
+    %
+    %Arguments:
+    %   names_list [string]: 
+    %       List of names to check for whitespace.
+    %   name string: 
+    %       Name of 'names_list' for error messages.
+    %
+    %Raises:
+    %   [TrailingWhitespaceError]
+    %       If there is trailing whitespace.
+    
+    rex = '(?:^\s)|(?:\s$)';
+    testfunc = @(s) ~isstring(s) && ~isempty_ext(regexp(s, rex, 'once'));    
+    test = map(testfunc, names_list);
+    
+    if any(test)
+        error('%s:TrailingWhitespaceError', name)
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/lint/assert_noise_distributions_valid.m b/Requirements/MEIGO/PEtabMEIGO/lint/assert_noise_distributions_valid.m
new file mode 100644
index 0000000000000000000000000000000000000000..9ecab58916e7eb90d6d9edcb2a306073b6cd05c0
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/lint/assert_noise_distributions_valid.m
@@ -0,0 +1,38 @@
+function assert_noise_distributions_valid(observables_df)
+    %Ensure that noise distributions and transformation for observables are
+    %valid.
+    %
+    %Arguments:
+    %   observables_df [table]:
+    %       PEtab observables table.
+    %
+    %Raises:
+    %    [ObsTrafoInvalidError, NoiseDistrInvalidError]
+    %       If noise distribution or observable transformation is invalid.
+    
+    OBS_TRAFOS = ["", "lin", "log", "log10"];
+    NOISE_DISTR = ["", "normal", "laplace"];  
+    
+    cols = string(observable.Properties.VariableNames);    
+    if ismember('observableTransformation', cols)
+        trafo = observables_df.observableTransformation;
+        testfunc = @(x) ~(isnumeric(x) || ismember(x, OBS_TRAFOS));
+        
+        test = map(testfunc, trafo);
+        if any(test)
+            error('TRAFO:ObsTrafoInvalidError', ['Unrecognized ' ...
+                'observable transformation in observable table'])
+        end
+    end
+    
+    if ismember('noiseDistribution', cols)
+        noise = observables_df.noiseDistribution;
+        testfunc = @(x) ~(isnumeric(x) || ismember(x, NOISE_DISTR));
+        
+        test = map(testfunc, noise);
+        if any(test)
+            error('DISTR:NoiseDistrInvalidError', ['Unrecognized ' ...
+                'noise distribution in observable table'])
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/lint/measurement_table_has_timepoint_specific_mappings.m b/Requirements/MEIGO/PEtabMEIGO/lint/measurement_table_has_timepoint_specific_mappings.m
new file mode 100644
index 0000000000000000000000000000000000000000..3194172c74133a89c4821fa174b155e3b406172d
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/lint/measurement_table_has_timepoint_specific_mappings.m
@@ -0,0 +1,46 @@
+function out = measurement_table_has_timepoint_specific_mappings( ...
+    measurement_df) %-> bool
+    %Are there time-point or replicate specific assignments in the
+    %measurement table.
+    %
+    %Arguments:
+    %   measurement_df [table]:
+    %       PEtab measurement table.
+    %
+    %Returns:
+    %   bool
+    %       True if there are time-point or replicate specific parameter
+    %       assignments in the measurement table, false otherwise.
+    
+    cols = measurement_df.Properties.VariableNames;
+    if ismember('noiseParameters', cols)    
+        test = map(@isnumeric, measurement_df.noiseParameters);
+        
+        if iscell(measurement_df.noiseParameters)
+            measurement_df.noiseParameters(test) = {NaN};
+        elseif isnumeric(measurement_df.noiseParameters)
+            measurement_df.noiseParameters(test) = NaN;
+        end
+    else
+        measurement_df.noiseParameters = NaN(height(measurement_df), 1);
+    end
+    
+    grouping_cols = get_notnull_columns(measurement_df, ...
+        ["observableId", "simulationConditionId", ...
+        "preequilibrationConditionId", "observableParameters", ...
+        "noiseParameters"]);
+    grouped_df = unique(measurement_df(:, grouping_cols), ...
+        'rows', 'stable');
+    
+    grouping_cols = get_notnull_columns(grouped_df, ["observableId", ...
+        "simulationConditionId", "preequilibrationConditionId"]);
+    grouped_df2 = unique(grouped_df(:, grouping_cols), 'rows', ...
+        'stable');
+    
+    if height(grouped_df) ~= height(grouped_df2)
+        warning('Measurement table has timepoint-specific mappings');       
+        out = true;
+    else
+        out = false;
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/measurements/get_measurement_df.m b/Requirements/MEIGO/PEtabMEIGO/measurements/get_measurement_df.m
new file mode 100644
index 0000000000000000000000000000000000000000..857e20959fa8fc971f09707f47889d21b3d49c66
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/measurements/get_measurement_df.m
@@ -0,0 +1,28 @@
+function out = get_measurement_df(measurement_file_name) %-> [table]
+    %Read the provided measurement file into a 'table'.
+    %
+    %Arguments:
+    %   measurement_file_name [string, table, []]:
+    %                          Name of file to read from.
+    %
+    %Returns:
+    %   [table]
+    %       Measurements table.
+    
+    out = measurement_file_name;
+    if isempty_ext(measurement_file_name) || istable(measurement_file_name)
+        return
+    elseif ~exist(measurement_file_name, 'file')
+        error('GET_MEASUREMENT_DF:FileNotFoundError', ...
+            'No such file or directory')
+    end
+    
+    out = readtable(measurement_file_name, ...
+        'FileType', 'text', ...
+        'ReadVariableNames', true, ...
+        'PreserveVariableNames', true, ...
+        'Delimiter', 'tab');
+    
+    columns = string(out.Properties.VariableNames);
+    assert_no_leading_trailing_whitespace(columns, 'measurement')
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/measurements/get_rows_for_condition.m b/Requirements/MEIGO/PEtabMEIGO/measurements/get_rows_for_condition.m
new file mode 100644
index 0000000000000000000000000000000000000000..d76017242649aaf5ca05c0a4ee04809c2df3724b
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/measurements/get_rows_for_condition.m
@@ -0,0 +1,48 @@
+
+function out = get_rows_for_condition(measurement_df, ...
+    condition) %-> [table]
+    %Extract rows in 'measurement_df' for 'condition' according
+    %to 'preequilibrationConditionId' and 'simulationConditionId' in
+    %'condition'.
+    % 
+    %Arguments:
+    %   measurement_df [table]:
+    %       PEtab measurement table.
+    %   condition [table]:
+    %       Table with single row and columns
+    %       'preequilibrationConditionId' and 'simulationConditionId'.
+    %       Or dictionary with those keys.
+    % 
+    %Returns:
+    %   [table]
+    %       The subselection of rows in 'measurement_df' for the condition
+    %       'condition'.
+    
+    out = table();
+    condition.Count = [];
+    
+    if istable(condition)
+        condnames = string(condition.Properties.VariableNames);
+        condid = string(condition{1, :});
+    else
+        condnames = condition.keys;
+        condid = string(condition.values);
+    end
+    
+    if ismember('simulationConditionId', condnames)
+        simidx = strcmp(condnames, 'simulationConditionId');
+        measurement_df = measurement_df(strcmp( ...
+            measurement_df.simulationConditionId, condid{simidx}), :);
+        
+        out = measurement_df;
+    end
+    
+    if ismember('preequilibrationConditionId', condnames)
+        preeqidx = strcmp(condnames, 'preequilibrationConditionId');
+        measurement_df = measurement_df(strcmp( ...
+            measurement_df.preequilibrationConditionId, ...
+            condid{preeqidx}), :);
+        
+        out = measurement_df;
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/measurements/get_simulation_conditions.m b/Requirements/MEIGO/PEtabMEIGO/measurements/get_simulation_conditions.m
new file mode 100644
index 0000000000000000000000000000000000000000..61cceab421a242a274368bd5468eab02d91e3c87
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/measurements/get_simulation_conditions.m
@@ -0,0 +1,23 @@
+function out = get_simulation_conditions(measurement_df) %-> [table]
+    %Create a table of separate simulation conditions. A simulation
+    %condition is a specific combination of simulationConditionId and
+    %preequilibrationConditionId.
+    %
+    %Arguments:
+    %   measurement_df [table]:
+    %       PEtab measurement table.
+    %
+    %Returns:
+    %   [table]
+    %       Table with columns 'simulationConditionId' and
+    %       'preequilibrationConditionId'. All null columns will be
+    %       omitted.
+    
+    grouping_cols = get_notnull_columns(measurement_df, ...
+        ["preequilibrationConditionId", "simulationConditionId"]);
+    
+    out = measurement_df(:, grouping_cols);
+    [out, ~, ic] = unique(out, 'rows', 'stable');    
+    
+    out.Count = accumarray(ic, 1);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/measurements/split_parameter_replacement_list.m b/Requirements/MEIGO/PEtabMEIGO/measurements/split_parameter_replacement_list.m
new file mode 100644
index 0000000000000000000000000000000000000000..e2dfcda5ee37caf2c75b1a08b1a2c47cc2707975
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/measurements/split_parameter_replacement_list.m
@@ -0,0 +1,30 @@
+function out = split_parameter_replacement_list(list_string, delim) %-> string
+    %Split values in observableParameters and noiseParameters in
+    %measurement table.
+    %
+    %Arguments:
+    %   list_string string:
+    %       delim-separated stringified list.
+    %   delim Optional string/*[";"]:
+    %       delimiter.
+    %
+    %Returns:
+    %   cell
+    %       List of split values. Numeric values converted to float.    
+    
+    if nargin == 1
+        delim = ';';
+    end
+    
+    if isnumeric(list_string)
+        if isnan(list_string)
+            out = [];
+        else        
+            out = {list_string};
+        end
+    else
+        tmp = split(list_string, delim);
+        out = transpose(map(@to_float_if_float, tmp, 'UniformOutput', ...
+            false));
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/calculateProblemDesviation.m b/Requirements/MEIGO/PEtabMEIGO/meigo/calculateProblemDesviation.m
new file mode 100644
index 0000000000000000000000000000000000000000..3ff6a341db3523d31cbaeca46b39f9ccd887ef26
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/calculateProblemDesviation.m
@@ -0,0 +1,140 @@
+function [llh, chi2, simtable] = calculateProblemDesviation(problem, p, ...
+    sims)
+    %Calculates desviation measures (chi2 and log-likelihood) for a problem
+    %described in PEtab format.
+    %
+    %Arguments:
+    %   problem Problem:
+    %       Problem class object.
+    %   p [numeric]:
+    %       Vector of free parameters.
+    %   sims Optional bool/*false:
+    %       Whether to return simulations table.
+    %
+    %
+    
+    
+    if nargin == 2
+        sims = false;
+    end
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    
+    if ~sims
+        simtable = [];
+    end
+    
+    chi2 = 0;
+    llh = 0;
+    
+    status = writeDynFunc(problem, problem.folder, problem.sbml_model.id);
+    
+    simcond = problem.get_simulation_conditions_from_measurement_df;
+    simcond.Count = [];
+    
+    is_preeq = ismember('preequilibrationConditionId', ...
+        simcond.Properties.VariableNames);
+    
+    if sims
+        if is_preeq
+            simulations = problem.measurement_df(:, ["observableId" ...
+                "preequilibrationConditionId" "simulationConditionId" ...
+                "time"]);
+        else
+            simulations = problem.measurement_df(:, ["observableId" ...
+                "simulationConditionId" "time"]);
+        end
+        
+        simtable = simulations;
+        simtable.simulation = zeros(height(simtable), 1);
+        simstruct = table2struct(simulations);
+    end
+    
+    x0 = Dict();
+    simids = string(simcond.simulationConditionId);
+    if is_preeq
+        fprintf('Calculating preequilibration...\n')
+        
+        preeqids = string(unique(simcond.preequilibrationConditionId));        
+        
+        for i = 1:numel(preeqids)
+            c = cvarsForCondition(problem, preeqids(i));
+            x0i = eval(str2sym(parsex0(problem, preeqids(i))));
+            
+            [~, x0(preeqids(i))] = simulateForCondition(problem, ...
+                preeqids(i), x0i, p, true);
+        end
+        
+        x0i = string(simcond.preequilibrationConditionId);
+        
+        fprintf('Preequilibration succesfully completed.\n')
+    else     
+        for i = 1:numel(simids)
+            c = cvarsForCondition(problem, simids(i));
+            x0(simids(i)) = eval(str2sym(parsex0(problem, simids(i))));
+        end
+        
+        x0i = string(simcond.simulationConditionId);
+    end
+    
+    fprintf('Simulating...\n')
+    for i = 1:height(simcond)
+        if is_preeq
+            for j = 1:numel(x0i)
+                x0(x0i(j)) = eval(str2sym(parsex0(problem, simids(i), ...
+                    string(x0(x0i(j))))));
+            end
+        end
+        
+        [t, x] = simulateForCondition(problem, simids(i), x0(x0i(i)), p);     
+        
+        xdict = Dict();
+        for j = 1:numel(t)
+            xdict(string(t(j))) = x(j, :);
+        end
+        
+        optTable = getOptimizationTableForCondition(problem, simids(i));
+        optTable = parseOptTable(problem, optTable, p, xdict);
+        
+        for j = 1:height(optTable)
+            llh = llh + calculateSingleLlh(optTable.measurement(j), ...
+                optTable.simulation(j), ...
+                optTable.observableTransformation{j}, ...
+                optTable.noiseDistribution{j}, optTable.sigmas(j));
+            
+            chi2 = chi2 + calculateSingleChi2(optTable.measurement(j), ...
+                optTable.simulation(j), optTable.sigmas(j), ...
+                optTable.observableTransformation{j});
+        end        
+        
+        if sims
+            uniqcond = problem.get_simulation_conditions_from_measurement_df;
+            for j = 1:height(optTable)
+                row = struct();
+                
+                row.observableId = optTable.observableId{j};
+                row.simulationConditionId = ...
+                    uniqcond.simulationConditionId{i};
+                row.time = optTable.time(j);
+                
+                if is_preeq
+                    row.preequilibrationConditionId = ...
+                        uniqcond.preequilibrationConditionId{i};
+                end
+                
+                mask = false(1, numel(simstruct));
+                for k = 1:numel(simstruct)
+                    mask(k) = isequal(simstruct(k), row);
+                end
+                
+                simtable.simulation(mask) = optTable.simulation(j);
+            end
+        end
+    end
+    
+    fprintf('Simulation succesfully completed.\n')
+    
+    delete(fullfile(problem.folder, [problem.sbml_model.id '_dyn.m']));
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/calculateSingleChi2.m b/Requirements/MEIGO/PEtabMEIGO/meigo/calculateSingleChi2.m
new file mode 100644
index 0000000000000000000000000000000000000000..944d7bd761861bb0d0451f3cf070b374796a062d
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/calculateSingleChi2.m
@@ -0,0 +1,27 @@
+function out = calculateSingleChi2(measurement, simulation, noise_value, scale)
+    %Calculates single chi2 as:
+    %
+    %          chi2_i = (simulation_i - measure_i)^2 / noise_value
+    %
+    %Arguments:
+    %   measurement numeric:
+    %       Observable measurement unscaled.
+    %   simulation numeric:
+    %       Observable simulation unscaled.
+    %   noise_value numeric:
+    %       Observable noise value.
+    %   scale string:
+    %       Observable scale, "lin", "log" or "log10".
+    %
+    %Returns:
+    %   numeric
+    %       Single chi2.
+    
+    if strcmp(scale, 'lin')
+        out = ((simulation - measurement)/noise_value)^2;
+    elseif strcmp(scale, 'log')
+        out = ((log(simulation) - log(measurement))/noise_value)^2;
+    elseif strcmp(scale, 'log10')
+        out = ((log10(simulation) - log10(measurement))/noise_value)^2;
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/calculateSingleLlh.m b/Requirements/MEIGO/PEtabMEIGO/meigo/calculateSingleLlh.m
new file mode 100644
index 0000000000000000000000000000000000000000..cd37bbb54df1f05ca74df2fbf2af977c195511e1
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/calculateSingleLlh.m
@@ -0,0 +1,41 @@
+function llh = calculateSingleLlh(measurement, simulation, scale, ...
+    noise_distribution, noise_value)
+    %Calculates single log-likelihood.
+    %
+    %Arguments:
+    %   measurement numeric:
+    %       Observable measurement unscaled.
+    %   simulation numeric:
+    %       Observable simulation unscaled.
+    %   scale string:
+    %       Observable scale, "lin", "log" or "log10".
+    %   noise_distribution string:
+    %       Observable noise distribution, "normal" or "laplace".
+    %   noise_value numeric:
+    %       Observable noise value.
+    %
+    %Returns:
+    %   numeric
+    %       Single llh.
+    
+    m = measurement;
+    s = simulation;
+    sigma = noise_value;
+    
+    if strcmp(noise_distribution, 'normal') && strcmp(scale, 'lin')
+        nllh = 0.5*log(2*pi*sigma^2) + 0.5*((s-m)/sigma)^2;
+    elseif strcmp(noise_distribution, 'normal') && strcmp(scale, 'log')
+        nllh = 0.5*log(2*pi*sigma^2*m^2) + 0.5*((log(s)-log(m))/sigma)^2;
+    elseif strcmp(noise_distribution, 'normal') && strcmp(scale, 'log10')
+        nllh = 0.5*log(2*pi*sigma^2*m^2*log(10)^2) + ...
+            0.5*((log10(s)-log10(m))/sigma)^2;
+    elseif strcmp(noise_distribution, 'laplace') && strcmp(scale, 'lin')
+        nllh = log(2*sigma) + abs((s-m)/sigma);
+    elseif strcmp(noise_distribution, 'laplace') && strcmp(scale, 'log')
+        nllh = log(2*sigma*m) + abs((log(s)-log(m))/sigma);
+    elseif strcmp(noise_distribution, 'laplace') && strcmp(scale, 'log10')
+        nllh = log(2*sigma*m*log(10)) + abs((log10(s)-log10(m))/sigma);
+    end
+    
+    llh = - nllh;
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/cvarsForCondition.m b/Requirements/MEIGO/PEtabMEIGO/meigo/cvarsForCondition.m
new file mode 100644
index 0000000000000000000000000000000000000000..06c8301ed463807459aa2398b8d16db0993869e7
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/cvarsForCondition.m
@@ -0,0 +1,28 @@
+function out = cvarsForCondition(problem, condid)
+    %Returns condition dependent parameters for given condition id, as
+    %defined in condition table.
+    %
+    %Arguments:
+    %   problem Problem:
+    %       PEtab problem object.
+    %   condid string:
+    %       Condition identifyer.
+    %
+    %Returns:
+    %   [numeric]
+    %       condition dependent parameter values.
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    x = string(problem.amimodel.x);
+    
+    cvars = setdiff(problem.condition_df.Properties.VariableNames, ...
+        ["conditionId" "conditionName"]);
+    cvars = setdiff(cvars, x, 'stable');
+    
+    condition_df = problem.condition_df;
+    condition_df.Properties.RowNames = condition_df.conditionId;
+    
+    out = condition_df{condid, cvars};
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/getMeigoProblem.m b/Requirements/MEIGO/PEtabMEIGO/meigo/getMeigoProblem.m
new file mode 100644
index 0000000000000000000000000000000000000000..06546ef2af1d8b133fb9ea57ef960f04c3307883
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/getMeigoProblem.m
@@ -0,0 +1,25 @@
+function out = getMeigoProblem(folder, modelname, scaled_bounds)
+    %TODO
+    
+    out = struct();
+    
+    if nargin == 1
+        petab = Problem.from_yaml(folder);
+        scaled_bounds = false;
+    elseif nargin == 2
+        petab = Problem.from_yaml(folder, modelname);
+        scaled_bounds = false;
+    end
+    
+    out.f = @(p) calculateProblemDesviation(petab, p);
+    
+    if scaled_bounds
+        out.x_L = petab.lb_scaled;
+        out.x_U = petab.ub_scaled;        
+    else
+        out.x_L = petab.lb;
+        out.x_U = petab.ub;
+    end
+    
+    out.x_0 = petab.x_nominal_free;    
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/getOptimizationTableForCondition.m b/Requirements/MEIGO/PEtabMEIGO/meigo/getOptimizationTableForCondition.m
new file mode 100644
index 0000000000000000000000000000000000000000..c1a8c73b5d6c5a60ddb27b0a2ef1f52289c8d92e
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/getOptimizationTableForCondition.m
@@ -0,0 +1,59 @@
+function out = getOptimizationTableForCondition(problem, condid)
+    %TODO
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    
+    observable_df = problem.observable_df;
+    observable_df.Properties.RowNames = observable_df.observableId;
+    observable_df.observableId = [];
+    
+    mask = strcmp(problem.measurement_df.simulationConditionId, condid);    
+    out = problem.measurement_df(mask, ["observableId" ...
+        "measurement" "time"]);
+    
+    out.observableFormula = map( ...
+        @(o)observable_df.observableFormula(o), out.observableId);
+    
+    out.noiseFormula = map(@(o)observable_df.noiseFormula(o), ...
+        out.observableId);
+         
+    if ismember('observableParameters', ...
+            problem.measurement_df.Properties.VariableNames)
+        
+        out.observableParameters = ...
+            problem.measurement_df.observableParameters(mask);
+    end
+    
+    if ismember('noiseParameters', ...
+            problem.measurement_df.Properties.VariableNames)
+        
+        out.noiseParameters = ...
+            problem.measurement_df.noiseParameters(mask);
+    end
+         
+    if ismember('observableTransformation', ...
+            problem.observable_df.Properties.VariableNames)
+        
+        out.observableTransformation = map( ...
+            @(o)observable_df.observableTransformation(o), ...
+            out.observableId);
+    else
+        out.observableTransformation = ...
+            cellstr(repmat("lin", height(out), 1));
+    end
+    
+    if ismember('noiseDistribution', ...
+            problem.observable_df.Properties.VariableNames)
+        
+        out.noiseDistribution = map( ...
+            @(o)observable_df.noiseDistribution(o), out.observableId);
+    else
+        out.noiseDistribution = ...
+            cellstr(repmat("normal", height(out), 1));        
+    end
+    
+    out = parseObservableFormulas(problem, out, condid);
+    out = parseNoiseFormulas(problem, out, condid);    
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/parseExpression.m b/Requirements/MEIGO/PEtabMEIGO/meigo/parseExpression.m
new file mode 100644
index 0000000000000000000000000000000000000000..85844c9a82665be5f335e5179654de7d243258a9
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/parseExpression.m
@@ -0,0 +1,88 @@
+function out = parseExpression(problem, expression)
+    %TODO
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    
+    expression = [' ' char(expression) ' '];
+    rex = '(?<=[\\W\\s])%s(?=[\\W\\s])';
+    
+    x = string(problem.amimodel.x);
+    optpars = problem.x_free_ids;
+    
+    fixpars = problem.x_fixed_ids;
+    fixvals = problem.x_nominal_fixed;
+    
+    comps = string({problem.sbml_model.compartment.id});
+    compsize = ones(1, numel(comps));
+    for i = 1:numel(comps)
+        if problem.sbml_model.compartment(i).isSetSize
+            compsize(i) = problem.sbml_model.compartment(i).size;
+        end
+    end
+    
+    cvars = setdiff(problem.condition_df.Properties.VariableNames, ...
+        ["conditionId" "conditionName"], 'stable');
+    cvars = setdiff(cvars, x, 'stable');
+    
+    [fixcomps, mask] = setdiff(comps, cvars, 'stable');
+    fixcompsize = compsize(mask);
+    
+    for i = 1:numel(fixcompsize)
+        expression = regexprep(expression, sprintf(rex, fixcomps(i)), ...
+            sprintf('%f', fixcompsize(i)));
+    end
+    
+    for i = 1:numel(x)
+        expression = regexprep(expression, sprintf(rex, x(i)), ...
+            sprintf('x(%d)', i));
+    end
+    
+    for i = 1:numel(cvars)
+        expression = regexprep(expression, sprintf(rex, cvars(i)), ...
+            sprintf('c(%d)', i));
+    end
+    
+    for i = 1:numel(fixpars)
+        expression = regexprep(expression, sprintf(rex, fixpars(i)), ...
+            sprintf('%f', fixvals(i)));
+    end
+    
+    for i = 1:numel(optpars)
+        expression = regexprep(expression, sprintf(rex, optpars(i)), ...
+            sprintf('p(%d)', i));
+    end    
+    
+    init_states_ids = x;
+    for i = 1:numel(x)
+        state = problem.sbml_model.getSpecies(x(i));        
+        init_states_ids(i) = lower([char(x(i)) '0']);
+        
+        if state.isSetInitialConcentration
+            tmp = state.initialConcentration;
+        else
+            tmp = 1;
+        end
+        
+        expression = regexprep(expression, sprintf(rex, ...
+            init_states_ids(i)), sprintf('%f', tmp));
+    end
+    
+    otherpars = setdiff(problem.get_model_parameters, ...
+        union(problem.x_ids, init_states_ids, 'stable'), 'stable');
+    for i = 1:numel(otherpars)
+        mask = strcmp({problem.sbml_model.parameter.id}, otherpars(i));
+        
+        if problem.sbml_model.parameter(mask).isSetValue
+            tmp = problem.sbml_model.parameter(mask).value;
+        else
+            tmp = 1;
+        end
+        
+        expression = regexprep(expression, sprintf(rex, ...
+            otherpars(i)), sprintf('%f', tmp));
+    end
+    
+    out = expression(2:end - 1);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/parseNoiseFormulas.m b/Requirements/MEIGO/PEtabMEIGO/meigo/parseNoiseFormulas.m
new file mode 100644
index 0000000000000000000000000000000000000000..d363b70f843e530b845504017b62e75fb2bd3f12
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/parseNoiseFormulas.m
@@ -0,0 +1,69 @@
+function out = parseNoiseFormulas(problem, opt_problem, condid)
+    %TODO   
+    
+    out = opt_problem;
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    
+    if ~ismember('noiseParameters', out.Properties.VariableNames)
+        return;
+    end
+    
+    rex = '(?<=[\\W\\s])%s(?=[\\W\\s])';
+    
+    condition_df = problem.condition_df;
+    condition_df.Properties.RowNames = condition_df.conditionId;
+    condition_df.conditionId = [];
+    
+    cvars = setdiff(problem.condition_df.Properties.VariableNames, ...
+        ["conditionId", "conditionName"], 'stable');
+    cvars = Dict(cvars, condition_df{condid, cvars});    
+
+    for i = 1:height(out)
+        obsid = out.observableId{i};
+        formula = [' ' out.noiseFormula{i} ' '];
+        
+        if ismember('noiseParameters', out.Properties.VariableNames)
+            if isnumeric(out.noiseParameters)
+                noisepar = out.noiseParameters(i);
+            else
+                noisepar = out.noiseParameters{i};
+            end
+            noisepar = split_parameter_replacement_list(noisepar);            
+
+            for j = 1:numel(noisepar)
+                overridee = sprintf('noiseParameter%d_%s', j, obsid);
+                overrider = noisepar{j};
+                
+                formula = regexprep(formula, sprintf(rex, overridee), ...
+                    num2str(overrider));
+            end            
+        end
+        
+        if ~isempty(cvars.keys)
+            for j = 1:numel(cvars)
+                formula = regexprep(formula, sprintf(rex, cvars.keys(j)), ...
+                    num2str(cvars.values{j}));
+            end
+        end
+        
+        formula = formula(2:end - 1);
+        
+        tmp = to_float_if_float(formula);
+        if isstring(tmp)
+            out.noiseFormula{i} = formula;
+        else
+            out.noiseFormula{i} = tmp;
+        end
+    end
+    
+    if all(map(@isnumeric, out.noiseFormula))
+        out.noiseFormula = cell2mat(out.noiseFormula);
+    end
+    
+    if ismember('noiseParameters', out.Properties.VariableNames)
+        out.noiseParameters = [];
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/parseObservableFormulas.m b/Requirements/MEIGO/PEtabMEIGO/meigo/parseObservableFormulas.m
new file mode 100644
index 0000000000000000000000000000000000000000..f647908a55388c3de94998b233fa7c80bac01c82
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/parseObservableFormulas.m
@@ -0,0 +1,65 @@
+function out = parseObservableFormulas(problem, opt_problem, condid)
+    %TODO
+    
+    out = opt_problem;
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    
+    rex = '(?<=[\\W\\s])%s(?=[\\W\\s])';
+    
+    condition_df = problem.condition_df;
+    condition_df.Properties.RowNames = condition_df.conditionId;
+    condition_df.conditionId = [];
+    
+    cvars = setdiff(problem.condition_df.Properties.VariableNames, ...
+        ["conditionId", "conditionName"], 'stable');
+    cvars = Dict(cvars, condition_df{condid, cvars});
+    
+    for i = 1:height(out)
+        obsid = out.observableId{i};
+        formula = [' ' out.observableFormula{i} ' '];
+        
+        if ismember('observableParameters', out.Properties.VariableNames)
+            if isnumeric(out.observableParameters)
+                obspar = out.observableParameters(i);
+            else
+                obspar = out.observableParameters{i};
+            end
+            obspar = split_parameter_replacement_list(obspar);          
+            
+            for j = 1:numel(obspar)
+                overridee = sprintf('observableParameter%d_%s', j, obsid);
+                overrider = obspar{j};
+                
+                formula = regexprep(formula, sprintf(rex, overridee), ...
+                    num2str(overrider));
+            end            
+        end
+        
+        if ~isempty_ext(cvars.keys)
+            for j = 1:numel(cvars)
+                formula = regexprep(formula, sprintf(rex, cvars.keys(j)), ...
+                    num2str(cvars.values{j}));
+            end
+        end
+        
+        formula = formula(2:end - 1);
+        
+        tmp = to_float_if_float(formula);
+        if isstring(tmp)
+            out.observableFormula{i} = formula;
+        else
+            out.observableFormula{i} = tmp;
+        end
+    end
+        
+    if all(map(@isnumeric, out.observableFormula))
+        out.observableFormula = cell2mat(out.observableFormula);
+    end
+    
+    if ismember('observableParameters', out.Properties.VariableNames)
+        out.observableParameters = [];
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/parseOptTable.m b/Requirements/MEIGO/PEtabMEIGO/meigo/parseOptTable.m
new file mode 100644
index 0000000000000000000000000000000000000000..466c2fa88f3ba7c6e28082fa02121f7024778543
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/parseOptTable.m
@@ -0,0 +1,31 @@
+function out = parseOptTable(problem, optTable, p, xdict)
+    %TODO
+    
+    for i = 1:height(optTable)
+        x = xdict(string(optTable.time(i)));
+        
+        obsFormula = parseExpression(problem, ...
+            string(optTable.observableFormula{i}));        
+        optTable.observableFormula{i} = eval(obsFormula);
+        
+        if isnumeric(optTable.noiseFormula)
+            continue
+        end
+        
+        noiseFormula = parseExpression(problem, ...
+            string(optTable.noiseFormula{i}));
+        optTable.noiseFormula{i} = eval(noiseFormula);
+    end
+    
+    optTable.observableFormula = cell2mat(optTable.observableFormula);
+    mask = strcmp(optTable.Properties.VariableNames, 'observableFormula');
+    optTable.Properties.VariableNames{mask} = 'simulation';
+    
+    if ~isnumeric(optTable.noiseFormula)
+        optTable.noiseFormula = cell2mat(optTable.noiseFormula);
+    end
+    mask = strcmp(optTable.Properties.VariableNames, 'noiseFormula');
+    optTable.Properties.VariableNames{mask} = 'sigmas';
+    
+    out = optTable;
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/parsex0.m b/Requirements/MEIGO/PEtabMEIGO/meigo/parsex0.m
new file mode 100644
index 0000000000000000000000000000000000000000..e697612e2e45109145ab06ce26c836622747f643
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/parsex0.m
@@ -0,0 +1,41 @@
+function out = parsex0(problem, condid, preeq_x0)
+    %TODO
+    
+    if nargin == 2
+        preeq_x0 = [];
+    end
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    
+    if isempty_ext(preeq_x0)
+        x0 = string(problem.amimodel.x0);
+    else
+        x0 = preeq_x0;
+    end
+    
+    x = string(problem.amimodel.x);
+    cvars = setdiff(problem.condition_df.Properties.VariableNames, ...
+        ["conditionId" "conditionName"], 'stable');
+    
+    condition_df = problem.condition_df(:, cvars);
+    condition_df.Properties.RowNames = problem.condition_df.conditionId;
+    
+    cvals = condition_df{condid, cvars};
+    cdict = Dict(cvars, cvals);
+    
+    x0ids = intersect(x, cvars, 'stable');
+    
+    if ~isempty_ext(x0ids)
+        for i = 1:numel(x0ids)
+            x0(strcmp(x, x0ids(i))) = cdict(x0ids(i));
+        end
+    end
+    
+    for i = 1:numel(x0)
+        x0(i) = parseExpression(problem, x0(i));
+    end
+    
+    out = x0;
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/simulateForCondition.m b/Requirements/MEIGO/PEtabMEIGO/meigo/simulateForCondition.m
new file mode 100644
index 0000000000000000000000000000000000000000..de5e096ff0a85369bcad052706a081575a60a33c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/simulateForCondition.m
@@ -0,0 +1,44 @@
+function [t, x] = simulateForCondition(problem, condid, x0, p, is_preeq)
+    %TODO
+    
+    if nargin == 4
+        is_preeq = false;
+    end
+    
+    opt_table = getOptimizationTableForCondition(problem, condid);
+    cvars = cvarsForCondition(problem, condid);
+    
+    if is_preeq
+        tode = [1E-8; 1E8];
+    else
+        texp = unique(opt_table.time, 'sorted');
+        if numel(texp) == 1
+            tode = [1E-8; texp];
+        else
+            tode = union(texp, 1E-8, 'sort');
+        end
+    end
+    
+    str = [problem.sbml_model.id '_dyn'];
+    simfunc = @(t, x) feval(str, t, x, p, cvars);
+    
+    [t, x] = ode15s(simfunc, tode, x0);
+    
+    tdict = Dict();
+    for i = 1:numel(t)
+        tdict(string(t(i))) = x(i, :);
+    end
+    
+    if is_preeq
+        t = tode(end);
+        x = x(end, :);
+    else
+        t = texp;
+        
+        n = size(x);
+        x = zeros(numel(t), n(2));
+        for i = 1:numel(t)
+            x(i, :) = tdict(string(t(i)));
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/meigo/writeDynFunc.m b/Requirements/MEIGO/PEtabMEIGO/meigo/writeDynFunc.m
new file mode 100644
index 0000000000000000000000000000000000000000..09394f8ad65459af5ecd469191891af977233363
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/meigo/writeDynFunc.m
@@ -0,0 +1,26 @@
+function out = writeDynFunc(problem, funcfolder, modelname)
+    %TODO
+    
+    funcname = strcat(modelname, '_dyn');
+    filename = strcat(funcname, '.m');
+    filepath = fullfile(funcfolder, filename);
+    
+    if isempty_ext(problem.amimodel)
+        problem.getDynamics;
+    end
+    dx = string(problem.amimodel.xdot);
+    
+    fileId = fopen(filepath, 'w');
+    
+    fprintf(fileId, 'function dx = %s(t, x, p, c)\n', funcname);
+    fprintf(fileId, '\tdx = zeros(%d, 1);\n\n', numel(dx));    
+    
+    for i = 1:numel(dx)
+        dxi = parseExpression(problem, dx(i));
+        fprintf(fileId, '\tdx(%d) = %s;\n', i, dxi);
+    end
+    
+    fprintf(fileId, 'end');
+    
+    out = fclose(fileId);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/observables/get_observable_df.m b/Requirements/MEIGO/PEtabMEIGO/observables/get_observable_df.m
new file mode 100644
index 0000000000000000000000000000000000000000..f4678b960df097052a527a1a25edd2b55aeadfec
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/observables/get_observable_df.m
@@ -0,0 +1,33 @@
+function out = get_observable_df(observable_file_name) %-> [table]
+    %Read the provided observable file into a MATLAB table.
+    %
+    %Arguments:
+    %   observable_file_name string:
+    %       Name of the file to read from.
+    %
+    %Returns:
+    %   [table]
+    %       Observable table.
+    
+    out = observable_file_name;
+    if isempty_ext(observable_file_name) || istable(observable_file_name)
+        return
+    elseif ~exist(observable_file_name, 'file')
+        error('GET_OBSERVABLE_DF:FileNotFoundError', ...
+            'No such file or directory')
+    end
+    
+    out = readtable(out, ...
+        'FileType', 'text', ...
+        'ReadVariableNames', true, ...
+        'PreserveVariableNames', true, ...
+        'Delimiter', 'tab');
+    
+    columns = string(out.Properties.VariableNames);
+    if ~ismember('observableId', columns)
+        error('GET_OBSERVABLE_DF:MandatoryFieldNotInTableError', ...
+            'Observables table missing mandatory field "observableId"')
+    end
+    
+    assert_no_leading_trailing_whitespace(columns, 'observable')
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/observables/get_output_parameters.m b/Requirements/MEIGO/PEtabMEIGO/observables/get_output_parameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..44fba62e38a1461f059ac724179fbff763650758
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/observables/get_output_parameters.m
@@ -0,0 +1,26 @@
+function out = get_output_parameters(observable_df, sbml_model) %-> [string]
+    %Get output parameters.
+    %
+    %Returns IDs of parameters used in observable and noise formulas not 
+    %defined in the SBML model.
+    %
+    %Arguments:
+    %   observable_df [table]:
+    %       PEtab observable table.
+    %   sbml_model [Sbml]:
+    %       SBML model.
+    %
+    %Returns:
+    %   [string]
+    %       List of output parameter IDs.
+    
+    formulas = observable_df.observableFormula;
+    if ismember('noiseFormula', observable_df.Properties.VariableNames)
+        formulas = union(formulas, string(observable_df.noiseFormula));
+    end
+    
+    tmp = unique(flatten(map(@symvar, formulas, 'UniformOutput', ...
+        false)), 'stable');
+    out = tmp(~map(@sbml_model.isElementById, tmp));    
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_condition_parameters.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_condition_parameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..570318a8619dba249084ee5b64b1786df6c0381e
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_condition_parameters.m
@@ -0,0 +1,32 @@
+function apply_condition_parameters(par_mapping, scale_mapping, ...
+    condition_id, condition_df, sbml_model)
+    %Replace parameter IDs in parameter mapping dictionary by condition
+    %table parameter values (in-place).
+    %
+    %Parameters:
+    %   par_mapping (Dict): 
+    %       see get_parameter_mapping_for_condition.
+    %   condition_id (string, char): 
+    %       ID of condition to work on.
+    %   condition_df (table): 
+    %       PEtab condition table.
+    
+    condition_df.Properties.RowNames = condition_df.conditionId;
+    condition_df.conditionId = [];
+    
+    for i = 1:numel(condition_df.Properties.VariableNames)
+        overridee_id = condition_df.Properties.VariableNames{i};
+        
+        if strcmp(overridee_id, 'conditionName')
+            continue
+        elseif ~isempty_ext(sbml_model.getSpecies(overridee_id))
+            continue
+        elseif ~isempty_ext(sbml_model.getCompartment(overridee_id))
+            continue
+        end
+        
+        par_mapping(overridee_id) = to_float_if_float(condition_df{ ...
+            condition_id, overridee_id});
+        scale_mapping(overridee_id) = 'lin';
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_output_parameter_overrides.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_output_parameter_overrides.m
new file mode 100644
index 0000000000000000000000000000000000000000..87eae4eb6dbe55f16ca345e3c9099f59b01c6fa3
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_output_parameter_overrides.m
@@ -0,0 +1,30 @@
+function apply_output_parameter_overrides(mapping, cur_measurement_df)
+    %Apply output parameter overrides to the parameter mapping dict for a 
+    %given condition as defined in the measurement table 
+    %("observableParameter","noiseParameters").
+    %
+    %Parameters:
+    %   mapping (Dict): 
+    %       parameter mapping dict as obtained from
+    %       "get_parameter_mapping_for_condition".
+    %   cur_measurement_df (table):
+    %       Subset of the measurement table for the current condition.
+        
+    if ismember('observableParameters', ...
+            cur_measurement_df.Properties.VariableNames)
+        overrides = map(@split_parameter_replacement_list, ...
+            cur_measurement_df.observableParameters, 'UniformOutput', false);
+        wrapfunc = @(x, y) apply_overrides_for_observable(mapping, x, ...
+            'observable', y);
+        map(wrapfunc, cur_measurement_df.observableId, overrides);
+    end
+    
+    if ismember('noiseParameters', ...
+            cur_measurement_df.Properties.VariableNames)
+        overrides = map(@split_parameter_replacement_list, ...
+            cur_measurement_df.noiseParameters, 'UniformOutput', false);
+        wrapfunc = @(x, y) apply_overrides_for_observable(mapping, x, ...
+            'noise', y);
+        map(wrapfunc, cur_measurement_df.observableId, overrides);
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_overrides_for_observable.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_overrides_for_observable.m
new file mode 100644
index 0000000000000000000000000000000000000000..9bd57cce4fcfd6b72a9420afacab51a01d5a7465
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_overrides_for_observable.m
@@ -0,0 +1,32 @@
+function apply_overrides_for_observable(mapping, observable_id, ...
+    override_type, overrides)
+    %Apply parameter-overrides for observables and noises to mapping
+    %matrix.
+    %
+    %Parameters:
+    %	mapping (Dict): 
+    %   	mapping dict to which to apply overrides.
+    %	observable_id (string, char): 
+    %   	observable ID.
+    %   override_type (string, char): 
+    %   	'observable' or 'noise'
+    %	overrides ([string]): 
+    %   	list of overrides for noise or observable parameters.
+    
+    for i = 1:numel(overrides)
+        override = overrides{i};
+        
+        overridee_id = sprintf('%sParameter%d_%s', override_type, i, ...
+            observable_id);
+        
+        try
+            mapping(overridee_id) = override;
+        catch
+            error('APPLY_OVERRIDES_FOR_OBSERVABLE:TypeError', ...
+                ['Cannot override %s parameter %s for observable %s.' ...
+                'Ensure there exists an %d definition containing the ' ...
+                'correct number of placeholder parameters.'], ...
+                override_type, overridee_id, observable_id, override_type)
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_parameter_table.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_parameter_table.m
new file mode 100644
index 0000000000000000000000000000000000000000..01f4212a9175a09e7bad222fa1a1dc8b944c2393
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/apply_parameter_table.m
@@ -0,0 +1,97 @@
+function apply_parameter_table(par_mapping, scale_mapping, ...
+    parameter_df, scaled_parameters)
+    % Replace parameters from parameter table in mapping list for a given
+    % condition and set the corresponding scale.
+    %
+    % Replace non-estimated parameters by "nominalValues"
+    % (un-scaled / lin-scaled), replace estimated parameters by the 
+    % respective ID.
+    %
+    % Parameters:
+    %   par_mapping (Dict):
+    %        dict obtained from "get_parameter_mapping_for_condition".
+    %   scale_mapping (Dict):
+    %        Parameter scales dict obtained from 
+    %        "get_parameter_mapping_for_condition".
+    %   parameter_df (table):
+    %       PEtab parameter table.
+    %   scaled_parameters (bool):
+    %       Whether to scale parameters or not.
+    
+    if nargin == 3
+        scaled_parameters = false;        
+    elseif nargin == 2
+        parameter_df = table.empty();
+        scaled_parameters = false;
+    end
+    
+    if isempty_ext(parameter_df)
+        return
+    end
+    
+    parids = transpose(intersect(par_mapping.keys, ...
+        parameter_df.parameterId, 'stable'));
+    parameter_df.Properties.RowNames = parameter_df.parameterId;
+    parameter_df.parameterId = [];    
+    
+    scales = transpose(parameter_df.parameterScale(parids));    
+    scale_mapping.addpairs(parids, cellstr(scales));
+    
+    estpars = transpose(parameter_df.Properties.RowNames( ...
+        logical(parameter_df.estimate)));
+    nonestpars = transpose(setdiff(parameter_df.Properties.RowNames, ...
+        estpars, 'stable'));
+    
+    vals = transpose(parameter_df.nominalValue(nonestpars));
+    if scaled_parameters
+        scales = transpose(parameter_df.parameterScale(nonestpars));
+        vals = map(@scale, num2cell(vals), scales);
+    else
+        scale_mapping.addpairs(parids, cellstr(repmat("lin", 1, ...
+            numel(parids))));
+    end
+    
+    par_mapping.addpairs(nonestpars, vals);
+    par_mapping.addpairs(string(estpars), estpars);
+    
+    for i = 1:numel(par_mapping.keys)
+        problem_par = par_mapping.keys{i};
+        sim_par = par_mapping.values{i};
+        
+        if isnumeric(sim_par)
+            continue
+        end
+        
+        try            
+            par_mapping(problem_par) = par_mapping(sim_par);
+            scale_mapping(problem_par) = scale_mapping(sim_par);
+        catch
+            if isempty_ext(parameter_df)
+                error([]);
+            end
+            
+            if ismember('parameterScale', ...
+                    parameter_df.Properties.VariableNames)
+                scalestr = parameter_df.parameterScale{sim_par};
+            else
+                scalestr = 'lin';
+            end
+            
+            if ismember('estimate', ...
+                    parameter_df.Properties.VariableNames) && ...
+                        ~parameter_df.estimate(sim_par)
+                
+                val = parameter_df.nominalValue(sim_par);
+                if scaled_parameters
+                    val = scale(val, scalestr);
+                else
+                    scalestr = 'lin';
+                end
+                
+                par_mapping(problem_par) = val;
+            end
+            
+            scale_mapping(problem_par) = scalestr;
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/get_optimization_to_simulation_parameter_mapping.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/get_optimization_to_simulation_parameter_mapping.m
new file mode 100644
index 0000000000000000000000000000000000000000..fcb36f824471ad376e12b4ac17ad62215f717f70
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/get_optimization_to_simulation_parameter_mapping.m
@@ -0,0 +1,93 @@
+function [preeq, sim] = get_optimization_to_simulation_parameter_mapping( ...
+    condition_df, measurement_df, varargin) %-> [[Dict], [Dict]]
+    %Create list of mapping dicts from PEtab-problem to SBML
+    %parameters.
+    %
+    %Mapping can be performed in parallel. The number of threads is controlled
+    %by the environment variable with the name of petab.ENV_NUM_THREADS.
+    %
+    %Parameters:
+    %   condition_df, measurement_df table:
+    %       The dataframes in the PEtab format.
+    %   parameter_df Optional table/*[]:
+    %       Parameter table in PEtab format.
+    %   observable_df Optional table/*[]:
+    %       Observables table in PEtab format.
+    %   sbml_model Optional libsbml struct/*[]:
+    %       The sbml model with observables and noise specified
+    %       according to the PEtab format.
+    %   simulation_conditions Optional table/*[]:
+    %       Table of simulation conditions as created by
+    %       "petab.get_simulation_conditions".
+    %   warn_unmapped Optional bool/*true:
+    %       If "True", log warning regarding unmapped parameters
+    %   scaled_parameters Optional bool/*false:
+    %       Whether parameter values should be scaled.
+    %
+    %Returns:
+    %   [[Dict], [Dict]]:
+    %       Parameter value and parameter scale mapping for all
+    %       conditions.
+    
+    preeq = Dict();
+    sim = Dict();
+    
+    p = inputParser;
+    addRequired(p, 'condition_df', @istable);
+    addRequired(p, 'measurement_df', @istable);
+    addParameter(p, 'parameter_df', table.empty(), @istable);
+    addParameter(p, 'observable_df', table.empty(), @istable)
+    addParameter(p, 'sbml_model', Sbml.empty(), @Sbml.isSbml)
+    addParameter(p, 'simulation_conditions', table.empty(), @istable)
+    addParameter(p, 'warn_unmapped', true, @islogical)
+    addParameter(p, 'scaled_parameters', false, @islogical)
+    parse(p, condition_df, measurement_df, varargin{:});
+    
+    condition_df = p.Results.condition_df;
+    measurement_df = p.Results.measurement_df;
+    parameter_df = p.Results.parameter_df;
+    observable_df = p.Results.observable_df;
+    sbml_model = p.Results.sbml_model;
+    simulation_conditions = p.Results.simulation_conditions;
+    warn_unmapped = p.Results.warn_unmapped;
+    scaled_parameters = p.Results.scaled_parameters;
+    
+    perform_mapping_checks(measurement_df)
+    
+    if isempty_ext(simulation_conditions)
+        simulation_conditions = get_simulation_conditions(measurement_df);
+    end
+    
+    simulation_parameters = get_model_parameters(sbml_model, true);    
+    
+    if ~isempty_ext(observable_df)
+        output_parameters = get_output_parameters(observable_df, ...
+            sbml_model);
+        
+        simulation_parameters.addpairs(string(output_parameters), ...
+            NaN(1, numel(output_parameters)));
+    end
+    
+    tmp = cell(height(simulation_conditions), 4);
+    for i = 1:height(simulation_conditions)
+        condition = simulation_conditions(i, :);
+        
+        [tmp{i, :}] = map_condition(condition, measurement_df, ...
+            condition_df, parameter_df, sbml_model, ...
+            simulation_parameters, warn_unmapped, scaled_parameters);
+    end
+    
+    if ismember('preequilibrationConditionId', ...
+            simulation_conditions.Properties.VariableNames)
+        
+        for i = 1:height(simulation_conditions)
+            condid = simulation_conditions.preequilibrationConditionId{i};            
+            preeq(condid) = tmp(i, 1:2);
+        end
+    end
+    
+    for i = 1:height(simulation_conditions)
+        condid = simulation_conditions.simulationConditionId{i};
+        sim(condid) = tmp(i, 3:4);
+    end
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/get_parameter_mapping_for_condition.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/get_parameter_mapping_for_condition.m
new file mode 100644
index 0000000000000000000000000000000000000000..993555e52a046e38bf040e072d78ca59a211e2f8
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/get_parameter_mapping_for_condition.m
@@ -0,0 +1,85 @@
+function [par_mapping, scale_mapping] = ...
+    get_parameter_mapping_for_condition(condition_id, is_preeq, ...
+    cur_measurement_df, sbml_model, condition_df, varargin)
+    % Create dictionary of parameter value and parameter scale mappings 
+    % from PEtab-problem to SBML parameters for the given condition.
+    % 
+    % Parameters:
+    %   condition_id (string, char): 
+    %       Condition ID for which to perform mapping.
+    %   is_preeq (bool): 
+    %       If "True", output parameters will not be mapped.
+    %   cur_measurement_df (table): 
+    %       Measurement sub-table for current condition
+    %   condition_df (table):
+    %       PEtab condition DataFrame.
+    %   parameter_df *(table/[]):
+    %       PEtab parameter DataFrame.
+    %   sbml_model (Sbml):
+    %       The sbml model with observables and noise specified according to
+    %       the PEtab format used to retrieve simulation parameter IDs.     
+    %   simulation_parameters *(Dict/[]):
+    %       Model simulation parameter IDs mapped to parameter values (output
+    %       of "sbml/get_model_parameters(.., with_values=True)").
+    %       Optional, saves time if precomputed.
+    %   warn_unmapped *(bool/[]):
+    %       If "True", log warning regarding unmapped parameters.
+    %     
+    %   Returns:
+    %       ([Dict, Dict])
+    %           Tuple of two dictionaries. First dictionary mapping model 
+    %           parameter IDs to mapped parameters IDs to be estimated or 
+    %           to filled-in values in case of non-estimated parameters.
+    %           Second dictionary mapping model parameter IDs to their 
+    %           scale.
+    %           NaN is used where no mapping exists.
+    
+    p = inputParser;
+    addRequired(p, 'condition_id', @(x) isstring(x) || ischar(x));
+    addRequired(p, 'is_preeq', @islogical);
+    addRequired(p, 'cur_measurement_df', @istable);
+    addRequired(p, 'sbml_model', @Sbml.isSbml);
+    addRequired(p, 'condition_df', @istable);
+    addParameter(p, 'parameter_df', table.empty(), @istable);
+    addParameter(p, 'simulation_parameters', Dict.empty(), @Dict.isDict);
+    addParameter(p, 'warn_unmapped', true, @islogical);
+    addParameter(p, 'scaled_parameters', false, @islogical);
+    
+    parse(p, condition_id, is_preeq, cur_measurement_df, sbml_model, ...
+        condition_df, varargin{:});
+    
+    condition_id = p.Results.condition_id;
+    is_preeq = p.Results.is_preeq;
+    cur_measurement_df = p.Results.cur_measurement_df;
+    sbml_model = p.Results.sbml_model;
+    condition_df = p.Results.condition_df;
+    parameter_df = p.Results.parameter_df;
+    simulation_parameters = p.Results.simulation_parameters;
+    warn_unmapped = p.Results.warn_unmapped;
+    scaled_parameters = p.Results.scaled_parameters;
+    
+    perform_mapping_checks(cur_measurement_df);
+    
+    if isempty_ext(simulation_parameters)
+        simulation_parameters = get_model_parameters(sbml_model, true);
+    end
+    
+    par_mapping = simulation_parameters.copy;
+    
+    scale_mapping = Dict(par_mapping.keys, cellstr(repmat("lin", 1, ...
+        numel(par_mapping.keys))));  
+    
+    output_parameters_to_nan(par_mapping);
+    
+    apply_output_parameter_overrides(par_mapping, cur_measurement_df);
+    
+    if ~is_preeq
+        handle_missing_overrides(par_mapping, warn_unmapped);
+    end
+    
+    apply_condition_parameters(par_mapping, scale_mapping, ...
+        condition_id, condition_df, sbml_model);
+    
+    apply_parameter_table(par_mapping, scale_mapping, parameter_df, ...
+        scaled_parameters);    
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/handle_missing_overrides.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/handle_missing_overrides.m
new file mode 100644
index 0000000000000000000000000000000000000000..3a527a4bb96aa2dc6d14fefce567f88060f4df53
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/handle_missing_overrides.m
@@ -0,0 +1,39 @@
+function handle_missing_overrides(mapping_par_opt_to_par_sim, warn, ...
+    condition_id)
+    %Find all observable parameters and noise parameters that were not 
+    %mapped and set their mapping to NaN.
+    %
+    %Assumes that parameters matching "(noise|observable)Parameter[0-9]+_" 
+    %were all supposed to be overwritten.
+    %
+    %Parameters:
+    %    mapping_par_opt_to_par_sim (Dict):
+    %        Output of get_parameter_mapping_for_condition
+    %    warn *(bool/true):
+    %        If True, log warning regarding unmapped parameters
+    %    condition_id *((string, char)/[]):
+    %        Optional condition ID for more informative output
+    
+    if nargin == 2
+        condition_id = string.empty();
+    elseif nargin == 1
+        warn = true;
+        condition_id = string.empty();
+    end
+    
+    rex = '^(noise|observable)Parameter[0-9]+_';
+    
+    keys = mapping_par_opt_to_par_sim.keys;
+    vals = mapping_par_opt_to_par_sim.values;
+    
+    mask = map(@(s) ~isnumeric(s) && ~isempty_ext(regexp(s, rex)), vals);
+    
+    missed_vals = keys(mask);
+    mapping_par_opt_to_par_sim.addpairs(keys(mask), vals(mask));
+    
+    if ~isempty(missed_vals) && warn
+        warning('HANDLE_MISSING_OVERRIDES:UnmappedParsWarning', ...
+            ['Could not map all overrides for condition %s. Usually, ' ...
+            'this is just due to missing data points'], condition_id);
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/map_condition.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/map_condition.m
new file mode 100644
index 0000000000000000000000000000000000000000..d4f716a1b2620f84e6e0451dbaa68e1758e49170
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/map_condition.m
@@ -0,0 +1,46 @@
+function [par_map_preeq, scale_map_preeq, ...
+    par_map_sim, scale_map_sim] = map_condition(varargin)
+    %Helper function for computing of condition parameter mapping.
+    %See parameter_mapping/get_optimization_to_simulation_parameter_mapping
+    
+    [condition, measurement_df, condition_df, parameter_df, sbml_model, ...
+        simulation_parameters, warn_unmapped, scaled_parameters] = ...
+        varargin{:};
+    
+    cur_measurement_df = get_rows_for_condition(measurement_df, condition);
+    
+    test =  ~ismember('preequilibrationConditionId', ...
+        condition.Properties.VariableNames) || ...
+        ~isstring(condition.preequilibrationConditionId{:}) || ...
+        ~ischar(condition.preequilibrationConditionId{:}) || ...
+        isempty_ext(condition.preequilibrationConditionId{:});
+    
+    if test
+        par_map_preeq = Dict();
+        scale_map_preeq = Dict();
+    else
+        [par_map_preeq, scale_map_preeq] = ...
+            get_parameter_mapping_for_condition( ...
+            condition.preequilibrationConditionId{:}, ...
+            true, ...
+            cur_measurement_df, ...
+            sbml_model, ...
+            condition_df, ...
+            'parameter_df', parameter_df, ...
+            'simulation_parameters', simulation_parameters, ...
+            'warn_unmapped', warn_unmapped, ...
+            'scaled_parameters', scaled_parameters);
+    end
+    
+    [par_map_sim, scale_map_sim] = ...
+        get_parameter_mapping_for_condition( ...
+        condition.simulationConditionId{:}, ...
+        false, ...
+        cur_measurement_df, ...
+        sbml_model, ...
+        condition_df, ...
+        'parameter_df', parameter_df, ...
+        'simulation_parameters', simulation_parameters, ...
+        'warn_unmapped', warn_unmapped, ...
+        'scaled_parameters', scaled_parameters);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/output_parameters_to_nan.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/output_parameters_to_nan.m
new file mode 100644
index 0000000000000000000000000000000000000000..8a6c1782ef9c43ddcba728b8abd670d29882894f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/output_parameters_to_nan.m
@@ -0,0 +1,9 @@
+function output_parameters_to_nan(mapping)
+    %Set output parameters in mapping dictionary to NaN.
+    
+    rex = '^(noise|observable)Parameter[0-9]+_';
+    mask = map(@(s) ~isempty_ext(regexp(s, rex)), mapping.keys);
+    
+    tmp = mapping.keys(mask);
+    mapping.addpairs(tmp, NaN(1, numel(tmp)));
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/perform_mapping_checks.m b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/perform_mapping_checks.m
new file mode 100644
index 0000000000000000000000000000000000000000..744dd447522fa58944a906e7d66f7d70a59f6270
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameter_mapping/perform_mapping_checks.m
@@ -0,0 +1,9 @@
+function perform_mapping_checks(measurement_df)
+    %Check for PEtab features which we can't account for during parameter
+    %mapping.
+    
+    if measurement_table_has_timepoint_specific_mappings(measurement_df)
+        error('MAPPINGCHECKS:ValueError', ['Timepoint-specific ' ...
+            'parameter overrides currently unsupported']);
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameters/get_optimization_parameter_scales.m b/Requirements/MEIGO/PEtabMEIGO/parameters/get_optimization_parameter_scales.m
new file mode 100644
index 0000000000000000000000000000000000000000..42dba6014adec237cec9226679d20c1ae28411dc
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameters/get_optimization_parameter_scales.m
@@ -0,0 +1,20 @@
+function out = get_optimization_parameter_scales(parameter_df) %-> [Dict]
+    %Get Dictionary with optimization parameter IDs mapped to parameter
+    %scaling strings.
+    %
+    %Arguments:
+    %   parameter_df [table]:
+    %       PEtab parameter table.
+    %
+    %Returns:
+    %   [Dict]
+    %       Dictionary with optimization parameter IDs mapped to parameter
+    %       scaling strings.
+    
+    parameter_scales = parameter_df.parameterScale( ...
+        parameter_df.estimate == 1);
+    
+    out = Dict(get_optimization_parameters(parameter_df), ...
+        parameter_scales);
+end
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameters/get_optimization_parameters.m b/Requirements/MEIGO/PEtabMEIGO/parameters/get_optimization_parameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..1013821beb0df0b6fa4160acec036193796c48c9
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameters/get_optimization_parameters.m
@@ -0,0 +1,14 @@
+function out = get_optimization_parameters(parameter_df) %-> [string]
+    %Get list of optimization parameter IDs from parameter table.
+    %
+    %Arguments:
+    %   parameter_df [table]: 
+    %       PEtab parameter table
+    %
+    %Returns:
+    %   [string]
+    %       Array of IDs of parameters selected for optimization.
+    
+    out = transpose(string(parameter_df.parameterId( ...
+        parameter_df.estimate == 1)));
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameters/get_parameter_df.m b/Requirements/MEIGO/PEtabMEIGO/parameters/get_parameter_df.m
new file mode 100644
index 0000000000000000000000000000000000000000..416bd63b7df3452e82ea47208a29e1dcbcbd6bc1
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameters/get_parameter_df.m
@@ -0,0 +1,33 @@
+function out = get_parameter_df(parameter_file_name) %-> [table]
+    %Read the provided parameter file into a 'table'
+    %
+    %Arguments:
+    %   parameter_file_name string: 
+    %       Name of the file to read from.
+    %
+    %Returns:
+    %   [table]
+    %       Parameter table
+    
+    out = parameter_file_name;
+    if isempty_ext(parameter_file_name) || istable(parameter_file_name)
+        return
+    elseif ~exist(parameter_file_name, 'file')
+        error('GET_PARAMETER_DF:FileNotFoundError', ...
+            'No such file or directory')
+    end
+    
+    out = readtable(out, ...
+        'FileType', 'text', ...
+        'ReadVariableNames', true, ...
+        'PreserveVariableNames', true, ...
+        'Delimiter', 'tab');
+    
+    columns = string(out.Properties.VariableNames);
+    if ~ismember('parameterId', columns)
+        error('GET_PARAMETER_DF:MandatoryFieldNotInTableError', ...
+            'Parameters table missing mandatory field "parameterId"')
+    end
+    
+    assert_no_leading_trailing_whitespace(columns, 'parameter')
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/parameters/scale.m b/Requirements/MEIGO/PEtabMEIGO/parameters/scale.m
new file mode 100644
index 0000000000000000000000000000000000000000..ff2c8fc2f83ce98cdbd4c444440a41d564a4e748
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/parameters/scale.m
@@ -0,0 +1,24 @@
+function out = scale(parameter, scale_str) %-> numeric
+    %Scale parameter according to scale_str.
+    %
+    %Arguments:
+    %   parameter numeric:
+    %       Parameter to be scaled.
+    %   scale_str string:
+    %       One of 'lin' (synonymous with ''), 'log', 'log10'.
+    %
+    %Returns:
+    %   numeric
+    %       Parameter scaled according to scale_str.
+    
+    if ismember(scale_str, ["", "lin"])
+        out = parameter;
+    elseif strcmp(scale_str, 'log')
+        out = log(parameter);
+    elseif strcmp(scale_str, 'log10')
+        out = log10(parameter);
+    else
+        error('SCALE:InvalidParScalingError', ...
+            'Invalid parameter scaling: %s', scale_str)
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/problem/Problem.m b/Requirements/MEIGO/PEtabMEIGO/problem/Problem.m
new file mode 100644
index 0000000000000000000000000000000000000000..0429d904b559df7cfcda43bd1a96fca41b59b9ab
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/problem/Problem.m
@@ -0,0 +1,528 @@
+%PEtab Problem class
+
+classdef Problem < handle & matlab.mixin.Copyable & dynamicprops
+    %PEtab parameter estimation problem as defined by:
+    %
+    %- SBML model
+    %- condition table
+    %- measurement table
+    %- parameter table
+    %- observables table
+    %
+    %Optionally it may contain visualization tables.
+    %
+    %Properties:
+    %   sbml_model [Sbml object]:
+    %       SBML model.
+    %   condition_df [table]: 
+    %       PEtab condition table.
+    %   measurement_df [table]: 
+    %       PEtab measurement table.
+    %   parameter_df [table]: 
+    %       PEtab parameter table.
+    %   observable_df [table]: 
+    %       PEtab observables table.
+    %
+    %   amimodel [struct]:
+    %       AMICI model struct.
+    
+    properties (SetAccess = private)
+        folder string = [];
+    end
+    
+    properties
+        sbml_model Sbml = Sbml.empty();
+        condition_df table = table.empty();
+        measurement_df table = table.empty();
+        parameter_df table = table.empty();
+        observable_df table = table.empty();
+        
+        amimodel struct = struct.empty();
+    end
+    
+    methods
+        %% CLASS CONSTRUCTOR
+        function obj = Problem(folder, sbml_model, condition_df, ...
+                measurement_df, parameter_df, observable_df) %-> Problem
+            %Problem constructor.
+            
+            if nargin == 0
+                return
+            end
+            
+            obj.folder = folder;
+            
+            obj.sbml_model = sbml_model;
+            obj.condition_df = condition_df;
+            obj.measurement_df = measurement_df;
+            obj.parameter_df = parameter_df;
+            obj.observable_df = observable_df;
+        end
+        
+        %% OBJECT METHODS        
+        function getDynamics(obj)
+            %Loads AMICI model structure containing model dynamics.
+            
+            fprintf('Loading dynamics...\n')
+            
+            tmp = SBMLode(obj.sbml_model.sbml);
+            tmp.writeAMICI(obj.sbml_model.id, obj.folder);            
+                        
+            obj.amimodel = feval([obj.sbml_model.id ...
+                '_syms']);
+            
+            filename = fullfile(obj.folder, [obj.sbml_model.id ...
+                '_syms.m']);            
+            delete(filename);
+            
+            fprintf('Dynamics succesfully loaded.\n\n')
+        end
+        
+        function out = get_optimization_parameters(obj)
+            %Return string array of optimization parameter IDs.
+            %
+            %See parameter/get_optimization_parameters
+            
+            out = get_optimization_parameters(obj.parameter_df);
+        end
+        
+        function out = get_optimization_parameter_scales(obj)
+            %Return dictionary of optimization parameter scales.
+            %
+            %See parameters/get_optimization_parameter_scales
+            
+            out = get_optimization_parameter_scales(obj.parameter_df);
+        end
+        
+        function out = get_model_parameters(obj)
+            %See sbml/get_model_parameters
+            
+            out = get_model_parameters(obj.sbml_model);
+        end
+        
+        function out = get_observable_ids(obj)
+            %Returns string array of observable ids.
+            
+            out = transpose(string(obj.observable_df.observableId));
+        end
+        
+        function out = x_ids(obj) %-> [string]
+            %Parameter table parameter IDs.
+            
+            out = obj.get_x_ids;
+        end
+        
+        function out = x_free_ids(obj) %-> [string]
+            %Parameter table parameter IDs, for free parameters.
+            
+            out = obj.get_x_ids(true, false);
+        end
+        
+        function out = x_fixed_ids(obj) %-> [string]
+            %Parameter table parameter IDs, for fixed parameters.
+            
+            out = obj.get_x_ids(false);
+        end
+        
+        function out = x_nominal(obj)
+            %Parameter table nominal values.
+            
+            out = obj.get_x_nominal;
+        end
+        
+        function out = x_nominal_free(obj)
+            %Parameter table nominal values, for free parameters.
+            
+            out = obj.get_x_nominal(true, false);
+        end
+        
+        function out = x_nominal_fixed(obj)
+            %Parameter table nominal values, for fixed parameters.
+            
+            out = obj.get_x_nominal(false, true);
+        end
+        
+        function out = x_nominal_scaled(obj)
+            %Parameter table nominal values with applied parameter scaling.
+            
+            out = obj.get_x_nominal(true, true, true);
+        end
+        
+        function out = x_nominal_free_scaled(obj)
+            %Parameter table nominal values with applied parameter scaling,
+            %for free parameters.
+            
+            out = obj.get_x_nominal(true, false, true);
+        end
+        
+        function out = x_nominal_fixed_scaled(obj)
+            %Parameter table nominal values with applied parameter scaling,
+            %for fixed parameters.
+            
+            out = obj.get_x_nominal(false, true, true);
+        end
+        
+        function out = lb(obj)
+            %Parameter table lower bounds.
+            
+            out = obj.get_lb;
+        end
+        
+        function out = lb_scaled(obj)
+            %Parameter table lower bounds with applied parameter scaling.
+            
+            out = obj.get_lb(true, true, true);
+        end
+        
+                function out = ub(obj)
+            %Parameter table lower bounds.
+            
+            out = obj.get_ub;
+        end
+        
+        function out = ub_scaled(obj)
+            %Parameter table lower bounds with applied parameter scaling.
+            
+            out = obj.get_ub(true, true, true);
+        end
+        
+        function out = get_simulation_conditions_from_measurement_df(obj)
+            %See measurements/get_simulation_conditions
+            
+            out = get_simulation_conditions(obj.measurement_df);
+        end
+        
+        function [preeq, sim] = ...
+                get_optimization_to_simulation_parameter_mapping(obj, ...
+                warn_unmapped, scaled_parameters)
+            %See parameter_mapping/get_simulation_to_optimization_parameter_mapping
+            
+            if nargin == 2
+                scaled_parameters = false;
+            elseif nargin == 1
+                warn_unmapped = true;
+                scaled_parameters = false;
+            end
+            
+            [preeq, sim] = ...
+                get_optimization_to_simulation_parameter_mapping( ...
+                obj.condition_df, obj.measurement_df, 'parameter_df', ...
+                obj.parameter_df, 'observable_df', obj.observable_df, ...
+                'sbml_model', obj.sbml_model, 'warn_unmapped', ...
+                warn_unmapped, 'scaled_parameters', scaled_parameters);
+        end
+    end
+    
+    methods (Static)
+        %% STATIC METHODS
+        function out = from_files(varargin) %-> [Problem]
+            %Loads model and tables from files.
+            %
+            %Arguments:
+            %   folder Optional string/*["."]:
+            %       Model folder.
+            %   sbml_file Optional string/*[]:
+            %       SBML model.
+            %   condition_file Optional string/*[]: 
+            %       PEtab condition table.
+            %   measurement_file Optional string/*[]: 
+            %       PEtab measurement table.
+            %   parameter_file Optional string/*[]: 
+            %       PEtab parameter table.
+            %   observables_file Optional string/*[]: 
+            %       PEtab observables table.
+            %
+            %Returns:
+            %   [Problem]
+            %       PEtab Problem object.
+            
+            p = inputParser;
+            addParameter(p, 'folder', '.')
+            addParameter(p, 'sbml_file', Sbml.empty())
+            addParameter(p, 'condition_file', table.empty())
+            addParameter(p, 'measurement_file', table.empty())
+            addParameter(p, 'parameter_file', table.empty())
+            addParameter(p, 'observable_file', table.empty())
+            parse(p, varargin{:})
+            
+            folder = what(p.Results.folder).path;
+            
+            sbml_file = p.Results.sbml_file;
+            condition_file = p.Results.condition_file;
+            measurement_file = p.Results.measurement_file;
+            parameter_file = p.Results.parameter_file;
+            observable_file = p.Results.observable_file;            
+            
+            if ~isempty_ext(sbml_file)
+                sbml_model = Sbml(sbml_file);
+            end
+            
+            if ~isempty_ext(condition_file)
+                condition_df = get_condition_df(condition_file);
+            end
+            
+            if ~isempty(measurement_file)
+                measurement_df = concat_tables(measurement_file, ...
+                    @get_measurement_df);
+            end
+            
+            if ~isempty(parameter_file)
+                parameter_df = get_parameter_df(parameter_file);
+            end
+            
+            if ~isempty(observable_file)
+                observable_df = concat_tables(observable_file, ...
+                    @get_observable_df);
+            end
+            
+            out = Problem(folder, sbml_model, condition_df, ...
+                measurement_df, parameter_df, observable_df);
+        end
+        
+        function out = from_yaml(folderOrPath, modelname) %-> [Problem]
+            %Load model and tables as specified by YAML file.
+            %
+            %Arguments:
+            %   folder string:
+            %       PEtab configuration as dictionary or Path to the 
+            %       directory in which the yaml file is located.
+            %   modelname Optional string/*[]:
+            %       If specified, overrides the model component in the file
+            %       names. Defaults to the last component of 'folder'.
+            %
+            %Returns:
+            %   [Problem]
+            %       PEtab Problem object.            
+            
+            if nargin == 1
+                modelname = [];
+            end
+            
+            folderOrPath = char(folderOrPath);
+            modelname = char(modelname);
+            
+            if ~exist(folderOrPath)
+                error('FROM_FOLDER:FileNotFoundError', ...
+                    'No such file or directory')
+            end
+            
+            if isempty_ext(modelname)
+                [folder, ~] = fileparts(folderOrPath);
+            else
+                folder = folderOrPath;
+                folderOrPath = fullfile(folder, modelname + ".yaml");
+            end
+            
+            yaml_config = ReadYaml(char(folderOrPath));
+            
+            problem0 = yaml_config.problems{1};
+            
+            assert_single_condition_and_sbml_file(problem0);
+            
+            out = Problem.from_files('folder', folder, ...
+                'sbml_file', ...
+                fullfile(folder, problem0.sbml_files{1}), ...
+                'condition_file', ...
+                fullfile(folder, problem0.condition_files{1}), ...
+                'measurement_file', ...
+                fullfile(folder, problem0.measurement_files{1}), ...
+                'parameter_file', ...
+                fullfile(folder, yaml_config.parameter_file), ...
+                'observable_file', ...
+                fullfile(folder, problem0.observable_files{1}));
+        end
+    end
+        
+    methods (Access = public)
+        %% AUXILIAR METHODS
+        function out = x_free_indices(obj)
+            %Parameter table estimated parameter indices.
+            
+            out = transpose(find(obj.parameter_df.estimate));
+        end
+        
+        function out = x_fixed_indices(obj)
+            %Parameter table non-estimated parameter indices.
+            
+            out = transpose(find(~obj.parameter_df.estimate));
+        end       
+        
+        function out = apply_mask(obj, v, free, fixed) %-> [[string], [cell]]
+            %Apply mask of only free or only fixed values.
+            %
+            %Arguments:
+            %   v [[string], [cell]]:
+            %       The full array the mask is to be applied to.
+            %   free bool:
+            %       Whether to return free parameters, i.e., parameters to
+            %       estimate.
+            %   fixed bool:
+            %       Whether to return fixed parameters, i.e. parameters not
+            %       to estimate.
+            %
+            %Returns:
+            %   [[string], [cell]]
+            %       The reduced vector with applied mask.
+            
+            if nargin == 2
+                fixed = true;
+            elseif nargin == 1                
+                free = true;
+                fixed = true;
+            end
+            
+            if ~free && ~fixed
+                out = [];
+            elseif ~free
+                out = v(obj.x_fixed_indices);
+            elseif ~fixed
+                out = v(obj.x_free_indices);
+            else
+                out = v;
+            end
+        end
+        
+        function out = get_x_ids(obj, free, fixed) %-> [string]
+            %Generic function to get parameter ids.
+            %
+            %Parameters:
+            %   free bool:
+            %       Whether to return free parameters, i.e. parameters to 
+            %       estimate.
+            %   fixed bool:
+            %       Whether to return fixed parameters, i.e. parameters 
+            %       not to estimate.
+            %
+            %Returns
+            %   [string]
+            %       The parameter ids.
+            
+            if nargin == 2
+                fixed = true;
+            elseif nargin == 1
+                free = true;
+                fixed = true;
+            end
+            
+            v = transpose(string(obj.parameter_df.parameterId));
+            out = obj.apply_mask(v, free, fixed);
+        end
+        
+        function out = get_x_nominal(obj, free, fixed, scaled) %-> [numeric]
+            %Generic function to get parameter nominal values.
+            %
+            %Parameters:
+            %   free bool:
+            %       Whether to return free parameters, i.e. parameters to 
+            %       estimate.
+            %   fixed bool:
+            %       Whether to return fixed parameters, i.e. parameters 
+            %       not to estimate.
+            %   scaled bool:
+            %       Wheter to scale the values according to the parameter
+            %       scale, or return them on linear scale.
+            %
+            %Returns
+            %   [numeric]
+            %       The parameter nominal values.
+            
+            if nargin == 3
+                scaled = false;
+            elseif nargin == 2
+                fixed = true;
+                scaled = false;
+            elseif nargin == 1
+                free = true;
+                fixed = true;
+                scaled = false;
+            end
+            
+            v = obj.parameter_df.nominalValue;
+            
+            if scaled                
+                v = map(@scale, num2cell(v), ...
+                    obj.parameter_df.parameterScale);
+            end
+            
+            out = transpose(obj.apply_mask(v, free, fixed));
+        end
+        
+        function out = get_lb(obj, free, fixed, scaled) %-> [numeric]
+            %Generic function to get lower parameter bounds.
+            %
+            %Parameters:
+            %   free bool:
+            %       Whether to return free parameters, i.e. parameters to 
+            %       estimate.
+            %   fixed bool:
+            %       Whether to return fixed parameters, i.e. parameters 
+            %       not to estimate.
+            %   scaled bool:
+            %       Wheter to scale the values according to the parameter
+            %       scale, or return them on linear scale.
+            %
+            %Returns
+            %   [numeric]
+            %       The lower parameter bounds.
+            
+            if nargin == 3
+                scaled = false;
+            elseif nargin == 2
+                fixed = true;
+                scaled = false;
+            elseif nargin == 1
+                free = true;
+                fixed = true;
+                scaled = false;
+            end
+            
+            v = obj.parameter_df.lowerBound;
+            
+            if scaled                
+                v = map(@scale, num2cell(v), ...
+                    obj.parameter_df.parameterScale);
+            end
+            
+            out = transpose(obj.apply_mask(v, free, fixed));
+        end
+        
+        function out = get_ub(obj, free, fixed, scaled) %-> [numeric]
+            %Generic function to get upper parameter bounds.
+            %
+            %Parameters:
+            %   free bool:
+            %       Whether to return free parameters, i.e. parameters to
+            %       estimate.
+            %   fixed bool:
+            %       Whether to return fixed parameters, i.e. parameters
+            %       not to estimate.
+            %   scaled bool:
+            %       Wheter to scale the values according to the parameter
+            %       scale, or return them on linear scale.
+            %
+            %Returns
+            %   [numeric]
+            %       The upper parameter bounds.
+            
+            if nargin == 3
+                scaled = false;
+            elseif nargin == 2
+                fixed = true;
+                scaled = false;
+            elseif nargin == 1
+                free = true;
+                fixed = true;
+                scaled = false;
+            end
+            
+            v = obj.parameter_df.upperBound;
+            
+            if scaled
+                v = map(@scale, num2cell(v), ...
+                    obj.parameter_df.parameterScale);
+            end
+            
+            out = transpose(obj.apply_mask(v, free, fixed));
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/problem/get_default_condition_file_name.m b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_condition_file_name.m
new file mode 100644
index 0000000000000000000000000000000000000000..84ed373bd63b1ec1c43f281e0fefb536f5a912ba
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_condition_file_name.m
@@ -0,0 +1,19 @@
+function out = get_default_condition_file_name(model_name, folder) %-> string
+    %Get file name according to proposed convention.
+    %
+    %Arguments:
+    %   model_name string:
+    %       Name of the model.
+    %   folder string:
+    %       Path of the folder that contains the model files.
+    %
+    %Returns:
+    %   string:
+    %       Path of the condition file.
+    
+    warning('GET_DEFAULT_CONDITION_FILE_NAME:DeprecationWarning', ...
+        'This function will be removed in future releases')
+    
+    filename = sprintf('experimentalCondition_%s.tsv', model_name);
+    out = fullfile(folder, filename);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/problem/get_default_measurement_file_name.m b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_measurement_file_name.m
new file mode 100644
index 0000000000000000000000000000000000000000..b9233f2c8cb74ce6cc36d3a5b64c6fec1493fe4f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_measurement_file_name.m
@@ -0,0 +1,19 @@
+function out = get_default_measurement_file_name(model_name, folder) %-> string
+    %Get file name according to proposed convention.
+    %
+    %Arguments:
+    %   model_name string:
+    %       Name of the model.
+    %   folder string:
+    %       Path of the folder that contains the model files.
+    %
+    %Returns:
+    %   string:
+    %       Path of the measurements file.
+    
+    warning('GET_DEFAULT_MEASUREMENT_FILE_NAME:DeprecationWarning', ...
+        'This function will be removed in future releases')
+    
+    filename = sprintf('measurementData_%s.tsv', model_name);
+    out = fullfile(folder, filename);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/problem/get_default_observable_file_name.m b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_observable_file_name.m
new file mode 100644
index 0000000000000000000000000000000000000000..7265db5b4b75094a2657f44a753e601a45b2f6b5
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_observable_file_name.m
@@ -0,0 +1,19 @@
+function out = get_default_observable_file_name(model_name, folder) %-> string
+    %Get file name according to proposed convention.
+    %
+    %Arguments:
+    %   model_name string:
+    %       Name of the model.
+    %   folder string:
+    %       Path of the folder that contains the model files.
+    %
+    %Returns:
+    %   string:
+    %       Path of the observables file.
+    
+    warning('GET_DEFAULT_OBSERVABLE_FILE_NAME:DeprecationWarning', ...
+        'This function will be removed in future releases')
+    
+    filename = sprintf('observables_%s.tsv', model_name);
+    out = fullfile(folder, filename);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/problem/get_default_parameter_file_name.m b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_parameter_file_name.m
new file mode 100644
index 0000000000000000000000000000000000000000..c3364ac3ca388d813b4899f0cd5284d8373a503b
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_parameter_file_name.m
@@ -0,0 +1,19 @@
+function out = get_default_parameter_file_name(model_name, folder) %-> string
+    %Get file name according to proposed convention.
+    %
+    %Arguments:
+    %   model_name string:
+    %       Name of the model.
+    %   folder string:
+    %       Path of the folder that contains the model files.
+    %
+    %Returns:
+    %   string:
+    %       Path of the parameter file.
+    
+    warning('GET_DEFAULT_PARAMETER_FILE_NAME:DeprecationWarning', ...
+        'This function will be removed in future releases')
+    
+    filename = sprintf('parameters_%s.tsv', model_name);
+    out = fullfile(folder, filename);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/problem/get_default_sbml_file_name.m b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_sbml_file_name.m
new file mode 100644
index 0000000000000000000000000000000000000000..b8b321ca5a17f4f5f426912cbc9652bcfef47621
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/problem/get_default_sbml_file_name.m
@@ -0,0 +1,19 @@
+function out = get_default_sbml_file_name(model_name, folder) %-> string
+    %Get file name according to proposed convention.
+    %
+    %Arguments:
+    %   model_name string:
+    %       Name of the model.
+    %   folder string:
+    %       Path of the folder that contains the model files.
+    %
+    %Returns:
+    %   string:
+    %       Path of the sbml model.
+    
+    warning('GET_DEFAULT_SBML_FILE_NAME:DeprecationWarning', ...
+        'This function will be removed in future releases')
+    
+    filename = sprintf('model_%s.xml', model_name);
+    out = fullfile(folder, filename);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/sbml/get_model_parameters.m b/Requirements/MEIGO/PEtabMEIGO/sbml/get_model_parameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..80f3710ef654d4691a1590aa75c90615870ee234
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/sbml/get_model_parameters.m
@@ -0,0 +1,36 @@
+
+function out = get_model_parameters(sbml_model, with_values) %-> [string, [Dict]]
+    %Return SBML model parameters which are not AssignmentRule targets for
+    %observables or sigmas.
+    %
+    %Arguments:
+    %   sbml_model [libsbml struct]: 
+    %       SBML model struct.
+    %   with_values Optional bool/*false: 
+    %       If false, returns list of SBML model parameter IDs which are 
+    %       not AssignmentRule targets for observables or sigmas. If true,
+    %       returns a dictionary with those parameter IDs as key and
+    %       parameter values from the SBML model as values.
+    %
+    %Returns:
+    %   [string/[Dict]]
+    %       List of model parameters ids or dictionary with model 
+    %       parameter ids/values pairs.
+    
+    if nargin == 1
+        with_values = false;
+    end
+    
+    testfunc = @(id) isempty_ext( ...
+        sbml_model.getAssignmentRuleByVariable(id));    
+    mask = map(testfunc, {sbml_model.parameter.id});
+    
+    ids = string({sbml_model.parameter(mask).id});
+    vals = {sbml_model.parameter(mask).value};
+    
+    if with_values
+        out = Dict(ids, vals);
+    else
+        out = ids;
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/DateTime.m b/Requirements/MEIGO/PEtabMEIGO/yaml/DateTime.m
new file mode 100644
index 0000000000000000000000000000000000000000..7f04b345bf3177f54df4945797bae2d5b561413f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/DateTime.m
@@ -0,0 +1,209 @@
+classdef DateTime
+		Copyright (c) 2011
+		This program is a result of a joined cooperation of Energocentrum
+		PLUS, s.r.o. and Czech Technical University (CTU) in Prague.
+        The program is maintained by Energocentrum PLUS, s.r.o. and 
+        licensed under the terms of MIT license. Full text of the license 
+        is included in the program release.  		
+        Author(s): 
+		Jiri Cigler, Dept. of Control Engineering, CTU Prague & Automatic Control Laboratory, ETH Zurich		
+		Jan  Siroky, Energocentrum PLUS s.r.o.		
+        Implementation and Revisions:
+        Auth  Date        Description of change
+        ----  ---------   -------------------------------------------------
+        jc    01-Mar-11   First implementation
+        jc    30-Sep-11   Added function colon
+        jc    07-Jan-12   Added functions addtodate,datevec,weekday
+    properties
+        serialDate
+    end
+    methods
+import yaml.*;
+function this = DateTime(varargin)            if numel(varargin)==1 && isa(varargin{1},'java.util.Date')
+                    sec = varargin{1}.getTime/1000;                   
+                    this.serialDate=datenum(1970,1,1,0,0,sec);
+            else
+                this.serialDate=datenum(varargin{:});
+            end
+        end
+import yaml.*;
+function this = plus(this,val)            o =@plus;
+            this = doFun(this,o,val);
+        end
+import yaml.*;
+function this = minus(this,val)            o =@minus;
+            this = doFun(this,o,val);
+        end
+import yaml.*;
+function this = times(this,val)            o =@times;
+            this = doFun(this,o,val);
+        end
+import yaml.*;
+function this = mtimes(this,val)            o =@mtimes;
+            this = doFun(this,o,val);
+        end
+import yaml.*;
+function this = mrdivide(this,val)            o =@mrdivide;
+            this = doFun(this,o,val);
+        end
+import yaml.*;
+function this = rdivide(this,val)            o =@rdivide;
+            this = doFun(this,o,val);
+        end
+import yaml.*;
+function this = horzcat(this,varargin)            for i=1:numel(varargin)
+                this.serialDate = [this.serialDate, varargin{i}.serialDate];
+            end
+        end
+import yaml.*;
+function out = colon(this,step,to)            vect = [double(this):double(step):double(to)]';
+            out =DateTime(vect);
+        end
+import yaml.*;
+function this = vertcat(this,varargin)            for i=1:numel(varargin)
+                this.serialDate = [this.serialDate; varargin{i}.serialDate];
+            end
+        end
+import yaml.*;
+function this = ctranspose(this)            this.serialDate = this.serialDate';
+        end
+import yaml.*;
+function this = transpose(this)            this.serialDate = this.serialDate';
+        end
+import yaml.*;
+function  disp(this)            disp([this.serialDate])
+        end
+import yaml.*;
+function out = double(this)            out = this.serialDate;
+        end
+import yaml.*;
+function out = length(this)            out = length(this.serialDate);
+        end
+import yaml.*;
+function out = size(this,varargin)            out = size(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function out = numel(this)            out = numel(this.serialDate);
+        end
+import yaml.*;
+function out = isreal(this)            out = isreal(this.serialDate);
+        end
+import yaml.*;
+function out = isnan(this)            out = isnan(this.serialDate);
+        end
+import yaml.*;
+function out = isfinite(this)            out = isfinite(this.serialDate);
+        end
+import yaml.*;
+function out = le(this,B)            if isa(B,'DateTime')
+                out = le(this.serialDate,B.serialDate);
+            else
+                out = le(this.serialDate,B);
+            end
+        end
+import yaml.*;
+function out = lt(this,B)            fun=@lt;
+            if isa(B,'DateTime')
+                out = fun(this.serialDate,B.serialDate);
+            else
+                out = fun(this.serialDate,B);
+            end
+        end
+import yaml.*;
+function out = gt(this,B)            fun=@gt;
+            if isa(B,'DateTime')
+                out = fun(this.serialDate,B.serialDate);
+            else
+                out = fun(this.serialDate,B);
+            end
+        end
+import yaml.*;
+function out = eq(this,B)            fun=@eq;
+            if isa(B,'DateTime')
+                out = fun(this.serialDate,B.serialDate);
+            else
+                out = fun(this.serialDate,B);
+            end
+        end
+import yaml.*;
+function out = diff(this)            out = diff(this.serialDate);
+        end
+import yaml.*;
+function out = norm(this,varargin)            out = norm(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function [this k] = sort(this,varargin)            [this.serialDate k] = sort(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function this = subsref(this,S)            if isa(S.subs{1},'DateTime')
+                S.subs{1}=double(S.subs{1});
+            end
+            this.serialDate =  subsref(this.serialDate,S);
+        end
+import yaml.*;
+function idx = subsindex(this)            idx = double(this)-1;
+        end
+import yaml.*;
+function endidx = end(this,k,n)              if size(this.serialDate,1)==1 || size(this.serialDate,2)==1
+                endidx=numel(this.serialDate);
+            else
+                endidx = size(this.serialDate,k);
+            end
+        end
+import yaml.*;
+function this = subsasgn(this, S, B)            if not(isa(B,'DateTime'))
+                B=DateTime(B);
+            end
+            this.serialDate =subsasgn(this.serialDate, S, B);
+        end
+import yaml.*;
+function res = bsxfun(fun,A,B)            res = fun(A,B);
+        end
+import yaml.*;
+function out =superiorfloat (x,y,xi)            if isa(x,'DateTime') && isa(xi,'DateTime')
+                out = superiorfloat(x.serialDate,y,xi.serialDate);
+            elseif isa(x,'DateTime') && not(isa(xi,'DateTime'))
+                out = superiorfloat(x.serialDate,y,xi);
+            elseif not(isa(x,'DateTime')) && isa(xi,'DateTime')
+                out = superiorfloat(x,y,xi.serialDate);
+            else
+                out = superiorfloat(x,y,xi);
+            end
+        end
+import yaml.*;
+function this = floor(this)            this.serialDate = floor(this.serialDate);
+        end
+import yaml.*;
+function this = max(this,varargin)            this.serialDate = max(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function this = min(this,varargin)            this.serialDate = min(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function out = datestr(this,varargin)            out = datestr(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function out = addtodate(this,varargin)            out = addtodate(this.serialDate,varargin{:});
+        end
+import yaml.*;
+function varargout= datevec(this,varargin)            nout = nargout;
+            if nout <=1
+                varargout{1} = datevec(this.serialDate,varargin{:});
+            elseif nout ==2
+                [varargout{1} varargout{2}] = datevec(this.serialDate,varargin{:});
+            elseif nout ==3
+                [varargout{1} varargout{2} varargout{3}] = datevec(this.serialDate,varargin{:});
+            elseif nout ==4
+                [varargout{1} varargout{2} varargout{3} varargout{4}] = datevec(this.serialDate,varargin{:});
+            elseif nout ==5
+                [varargout{1} varargout{2} varargout{3} varargout{4} varargout{5} ] = datevec(this.serialDate,varargin{:});
+            elseif nout ==6
+                [varargout{1} varargout{2} varargout{3} varargout{4} varargout{5} varargout{6} ] = datevec(this.serialDate,varargin{:});
+            else 
+                error('Unknown function call');
+            end
+        end
+    end
+    methods (Access = private)
+import yaml.*;
+function this = doFun (this,o, val)
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/ReadYaml.m b/Requirements/MEIGO/PEtabMEIGO/yaml/ReadYaml.m
new file mode 100644
index 0000000000000000000000000000000000000000..5e8d084b452b90de94bbd0ee61f0b7c1269bcae6
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/ReadYaml.m
@@ -0,0 +1,34 @@
+function result = ReadYaml(filename, nosuchfileaction, makeords, treatasdata, dictionary)
+import yaml.*;
+if ~exist('nosuchfileaction','var')
+        nosuchfileaction = 0;
+    end;
+    if ~ismember(nosuchfileaction,[0,1])
+        error('nosuchfileexception parameter must be 0,1 or missing.');
+    end;
+    if ~exist('makeords','var')
+        makeords = 0;
+    end;
+    if ~ismember(makeords,[0,1])
+        error('makeords parameter must be 0,1 or missing.');
+    end;    
+    if(~exist('treatasdata','var'))
+        treatasdata = 0;
+    end;
+    if ~ismember(treatasdata,[0,1])
+        error('treatasdata parameter must be 0,1 or missing.');
+    end; 
+    ry = ReadYamlRaw(filename, 0, nosuchfileaction, treatasdata);
+    ry = deflateimports(ry);
+    if iscell(ry) &&         length(ry) == 1 &&         isstruct(ry{1}) &&         length(fields(ry{1})) == 1 &&         isfield(ry{1},'import')        
+        ry = ry{1};
+    end;
+    ry = mergeimports(ry);    
+    ry = doinheritance(ry);
+    ry = makematrices(ry, makeords);    
+    if exist('dictionary','var')
+        ry = dosubstitution(ry, dictionary);
+    end;
+    result = ry;
+    clear global nsfe;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/ReadYamlRaw.m b/Requirements/MEIGO/PEtabMEIGO/yaml/ReadYamlRaw.m
new file mode 100644
index 0000000000000000000000000000000000000000..cb88adcdf22872ed1b13773c697e4f7405ad5b0c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/ReadYamlRaw.m
@@ -0,0 +1,178 @@
+function result = ReadYamlRaw(filename, verbose, nosuchfileaction, treatasdata)
+import yaml.*;
+if ~exist('verbose','var')
+        verbose = 0;
+    end;
+    if ~exist('nosuchfileaction','var')
+        nosuchfileaction = 0;
+    end;
+    if ~ismember(nosuchfileaction,[0,1])
+        error('nosuchfileexception parameter must be 0,1 or missing.');
+    end;
+    if(~exist('treatasdata','var'))
+        treatasdata = 0;
+    end;
+    if ~ismember(treatasdata,[0,1])
+        error('treatasdata parameter must be 0,1 or missing.');
+    end;
+    [pth,~,~] = fileparts(mfilename('fullpath'));       
+    try
+        import('org.yaml.snakeyaml.*');
+        javaObject('Yaml');
+    catch
+        dp = [pth filesep 'external' filesep 'snakeyaml-1.9.jar'];
+        if not(ismember(dp, javaclasspath ('-dynamic')))
+        	javaaddpath(dp); % javaaddpath clears global variables!?
+        end
+        import('org.yaml.snakeyaml.*');
+    end;
+    setverblevel(verbose);
+    result = load_yaml(filename, nosuchfileaction, treatasdata);
+end
+function result = load_yaml(inputfilename, nosuchfileaction, treatasdata)
+import yaml.*;
+persistent nsfe;
+    if exist('nosuchfileaction','var') %isempty(nsfe) && 
+        nsfe = nosuchfileaction;
+    end;
+    persistent tadf;
+    if isempty(tadf) && exist('treatasdata','var')
+        tadf = treatasdata;
+    end;
+    yaml = org.yaml.snakeyaml.Yaml(); % It appears that Java objects cannot be persistent!?
+    if ~tadf
+        [filepath, filename, fileext] = fileparts(inputfilename);
+        if isempty(filepath)
+            pathstore = cd();
+        else
+            pathstore = cd(filepath);
+        end;
+    end;
+    try
+        if ~tadf
+            result = scan(yaml.load(fileread([filename, fileext])));
+        else
+            result = scan(yaml.load(inputfilename));
+        end;
+    catch ex
+        if ~tadf
+            cd(pathstore);
+        end;
+        switch ex.identifier
+            case 'MATLAB:fileread:cannotOpenFile'
+                if nsfe == 1
+                    error('MATLAB:MATYAML:FileNotFound', ['No such file to read: ',filename,fileext]);
+                elseif nsfe == 0
+                    warning('MATLAB:MATYAML:FileNotFound', ['No such file to read: ',filename,fileext]);
+                    result = struct();
+                    return;
+                end;
+        end;
+        rethrow(ex);
+    end;
+    if ~tadf
+        cd(pathstore);    
+    end;
+end
+function result = scan(r)
+import yaml.*;
+if isa(r, 'char')
+        result = scan_string(r);
+    elseif isa(r, 'double')
+        result = scan_numeric(r);
+    elseif isa(r, 'logical')
+        result = scan_logical(r);
+    elseif isa(r, 'java.util.Date')
+        result = scan_datetime(r);
+    elseif isa(r, 'java.util.List')
+        result = scan_list(r);
+    elseif isa(r, 'java.util.Map')
+        result = scan_map(r);
+    else
+        error(['Unknown data type: ' class(r)]);
+    end;
+end
+function result = scan_string(r)
+import yaml.*;
+result = char(r);
+end
+function result = scan_numeric(r)
+import yaml.*;
+result = double(r);
+end
+function result = scan_logical(r)
+import yaml.*;
+result = logical(r);
+end
+function result = scan_datetime(r)
+import yaml.*;
+result = DateTime(r);
+end
+function result = scan_list(r)
+import yaml.*;
+result = cell(r.size(),1);
+    it = r.iterator();
+    ii = 1;
+    while it.hasNext()
+        i = it.next();
+        result{ii} = scan(i);
+        ii = ii + 1;
+    end;
+end
+function result = scan_map(r)
+import yaml.*;
+it = r.keySet().iterator();
+    while it.hasNext()
+        next = it.next();
+        i = next;
+        ich = char(i);
+        if iskw_import(ich)
+            result.(ich) = perform_import(r.get(java.lang.String(ich)));
+        else
+            result.(genvarname(ich)) = scan(r.get(java.lang.String(ich)));
+        end;
+    end;
+    if not(exist('result','var'))
+        result={};
+    end
+end
+function result = iskw_import(r)
+import yaml.*;
+result = isequal(r, 'import');
+end
+function result = perform_import(r)
+import yaml.*;
+r = scan(r);
+    if iscell(r) && all(cellfun(@ischar, r))
+        result = cellfun(@load_yaml, r, 'UniformOutput', 0);
+    elseif ischar(r)
+        result = {load_yaml(r)};
+    else
+        disp(r);
+        error(['Importer does not unterstand given filename. '               'Invalid node displayed above.']);
+    end;
+end
+function setverblevel(level)
+import yaml.*;
+global verbose_readyaml;
+    verbose_readyaml = 0;
+    if exist('level','var')
+        verbose_readyaml = level;
+    end;
+end
+function result = getverblevel()
+import yaml.*;
+global verbose_readyaml; 
+    result = verbose_readyaml;
+end
+function info(level, text, value_to_display)
+import yaml.*;
+if getverblevel() >= level
+        fprintf(text);
+        if exist('value_to_display','var')
+            disp(value_to_display);
+        else
+            fprintf('\n');
+        end;
+    end;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file1.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file1.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4e9cb133fcc863d1593b717d9b6b7be2918a6704
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file1.yaml
@@ -0,0 +1,2 @@
+f1a: 47
+f1b: 78
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file2.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5f7b001f891d7b9d156cdb8209ede26e9e255bb3
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file2.yaml
@@ -0,0 +1,2 @@
+f2a: 99
+f2b: 111
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file3.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file3.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c5dcc51354bb0f961df323b185b89cb921cb1f2f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file3.yaml
@@ -0,0 +1,2 @@
+f3a: 999
+f3b: 142
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file4.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file4.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..dae7148e5756f785cd7339d933d9d20b59769ea6
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/file4.yaml
@@ -0,0 +1,2 @@
+f4a: 123
+f4b: 456
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f4f26e6480af14a27271e32a2dd747e73bb68dd6
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ca60ada8769d3baee727f7b24a8252a8c8c01f8b
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import.yaml
@@ -0,0 +1,7 @@
+ - import:
+    - ../test_primitives/time.yaml
+    - ../test_inheritance/inheritance.yaml
+    #- ..\test_primitives\time_variants.yaml    
+ - import: [../test_primitives/matrices.yaml, ../test_primitives/sequence_mapping.yaml]
+
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_def.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_def.mat
new file mode 100644
index 0000000000000000000000000000000000000000..00e7d05d6ee3dc815186dc6b078ad63f139b6011
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_def.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_def.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_def.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9fd7491004208f9b6fc4582431caebe4d6a081e8
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_def.yaml
@@ -0,0 +1,5 @@
+import: 
+    - file1.yaml 
+    - file2.yaml
+    - file3.yaml
+    - file4.yaml
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_nonex.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_nonex.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..eb9e5e4f85743bd02eeb6d768dfc7992a999c4fc
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_import/import_nonex.yaml
@@ -0,0 +1,7 @@
+import:
+    - time_variants.yaml
+    - inheritance.yaml
+    - non-exists.yaml
+import: [matrices.yaml, sequence_mapping.yaml, non-ex.yaml]
+
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8c17a76259f9457a6e9bb506e0581018828f14ea
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..37a73fa9c2aab05f4c6d7e17e0dd02fbaeca06b1
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance.yaml
@@ -0,0 +1,49 @@
+cars:
+    - color: blue
+      label: JJ-XX-1500
+      parent: 
+             - manufacturer.skoda
+             - insurance.mandatory.Allianz
+             - insurance.optional.Kooperativa             
+
+      ins_note: IMPORTANT_1 
+      info: {aaa: 2}
+
+    - color: red
+      label: DD-XX-1500
+      ins_note: IMPORTANT_2
+      parent : [ manufacturer.audi, insurance.mandatory.Allianz ]
+
+manufacturer:
+    skoda:
+        established: cca 1900
+        place: MB
+        info:
+            aaa: 1
+            bbb: 11
+    audi:
+        established: cca 1900
+        place: Germany
+
+insurance:
+    mandatory:
+        Allianz: 
+            ins_price: 4000 
+            ins_unit : CZK
+        Kooperativa: 
+            ins_price: 4100 
+            ins_unit : CZK
+            ins_note : umfty dumf
+                
+    optional:
+        CP: 
+            ins_price: 1000 CZK
+        Kooperativa: 
+            ins_price: 1100 CZK
+
+
+
+
+
+    
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_loop.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_loop.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..aded2247fc6a8e129fdec0548945340b384ea6f6
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_loop.yaml
@@ -0,0 +1,4 @@
+# loop in inheritance
+students:
+    s1: { name: jan, parent: students.s2}
+    s2: { name: pepa, parent: students.s1}
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_multiple.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_multiple.mat
new file mode 100644
index 0000000000000000000000000000000000000000..4fab3f36126d43766332af7eaa1f1a8d1a8f8c8b
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_multiple.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_multiple.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_multiple.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a436b19d32c41f48af660126bed71ac1e47a8dd0
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_inheritance/inheritance_multiple.yaml
@@ -0,0 +1,14 @@
+a:
+  v1: 10
+  parent: [b,c]
+  
+b:
+  w1: 111
+  parent: d
+  
+c:
+  w2: 798
+  parent: d
+  
+d:
+  x: 113
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/bug6.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/bug6.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..466dceb9427f3b34a43c7ecece07cea7d60c3e37
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/bug6.yaml
@@ -0,0 +1,8 @@
+# http://code.google.com/p/yamlmatlab/issues/detail?id=6
+# read-in this file in windows like environment
+test:
+  - [16.0, 2.0, 3.0, 13.0]
+  - [5.0, 11.0, 10.0, 8.0]
+  - [9.0, 7.0, 6.0, 12.0]
+  - [4.0, 14.0, 15.0, 1.0]
+  
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/dos_CRLF.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/dos_CRLF.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..656d628ec39fee1cdee23fe1a21d4646fe6deb13
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/dos_CRLF.yaml
@@ -0,0 +1,8 @@
+american:
+  - Boston Red Sox
+  - Detroit Tigers
+  - New York Yankees
+national:
+  - New York Mets
+  - Chicago Cubs
+  - Atlanta Braves
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/miscellaneous.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/miscellaneous.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bbd321a616e088da26928577cb1550f753056d1c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/miscellaneous.yaml
@@ -0,0 +1,5 @@
+null: ~
+true: y
+false: n
+string: '12345'
+foo: [] # see http://code.google.com/p/yamlmatlab/issues/detail?id=5
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/spec_chars_utf8.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/spec_chars_utf8.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5f282702bb03ef11d7184d19c80927b47f919764
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/spec_chars_utf8.yaml
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/unix_LF.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/unix_LF.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..656d628ec39fee1cdee23fe1a21d4646fe6deb13
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_misc/unix_LF.yaml
@@ -0,0 +1,8 @@
+american:
+  - Boston Red Sox
+  - Detroit Tigers
+  - New York Yankees
+national:
+  - New York Mets
+  - Chicago Cubs
+  - Atlanta Braves
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/floating_points.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/floating_points.mat
new file mode 100644
index 0000000000000000000000000000000000000000..7f55f681b3508285aa5ffd57f87169330ccb2b67
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/floating_points.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/floating_points.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/floating_points.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d09d5f5943830fe36916beeaa4639d6ae2d27ef1
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/floating_points.yaml
@@ -0,0 +1,6 @@
+canonical: 1.23015e+3
+exponential: 12.3015e+02
+sexagecimal: 20:30.15
+fixed: 1230.15
+negative_infinity: -.inf
+not_a_number: .NaN
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/indentation.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/indentation.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e9f09de3ce801f3d82703c4f5e82db372a51a4ab
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/indentation.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/indentation.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/indentation.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9f66d881c4b9ce7a9c66063dc24b3f43064295ec
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/indentation.yaml
@@ -0,0 +1,7 @@
+name: Mark McGwire
+accomplishment: >
+  Mark set a major league
+  home run record in 1998.
+stats: |
+  65 Home Runs
+  0.278 Batting Average
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/matrices.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/matrices.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f7f71b5ec923c8ade66fac634b07fcb65ea8fab0
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/matrices.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/matrices.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/matrices.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e33ea22cba8d6187230236aad37a5ebb8e2c7b1a
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/matrices.yaml
@@ -0,0 +1,13 @@
+---
+Matrix1: [[1, 5],[1 , 3]]
+Matrix2: 
+    - [2 , 3]
+    - [4 , 5]
+ColVect:
+    - [1]
+    - [2]
+RowVect: [1, 2]
+...
+
+
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/sequence_mapping.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/sequence_mapping.mat
new file mode 100644
index 0000000000000000000000000000000000000000..6573e0480c8956d1e5ce8803992da240569c8a48
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/sequence_mapping.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/sequence_mapping.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/sequence_mapping.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a9ffc950797b3ef9f38a44cbb97bb23dc8ae2627
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/sequence_mapping.yaml
@@ -0,0 +1,11 @@
+sequence:
+    -
+        name: Mark McGwire
+        hr:   65
+        avg:  0.278
+    -
+        name: Sammy Sosa
+        hr:   [63, 43]
+        avg:  
+            - 0.288
+            - 12
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/simple.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/simple.mat
new file mode 100644
index 0000000000000000000000000000000000000000..04738033078438fbf772885b92ed56917e1b2823
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/simple.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/simple.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/simple.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8759cf32e629159a2f485c95dfada3c9e006638e
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/simple.yaml
@@ -0,0 +1,3 @@
+- {name: John Smith, age: 33}
+- name: Mary Smith
+  age: 27
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time.mat
new file mode 100644
index 0000000000000000000000000000000000000000..47f81d65ef51c26beecd8a2f1bcf81d4b405c9d9
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1f5db0064e24dbe63ac9e10ba1adf761b1df3479
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time.yaml
@@ -0,0 +1,3 @@
+Data:
+  B1_S_SW:
+    [!!timestamp '2011-03-29T18:09:20.0000000+02:00', 23.80]
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time_variants.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time_variants.mat
new file mode 100644
index 0000000000000000000000000000000000000000..7f9a48bc7a766df1c5043c4385a1af68879062bb
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time_variants.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time_variants.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time_variants.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..49877da99a68d8879f48979264bda1939491f643
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/time_variants.yaml
@@ -0,0 +1,8 @@
+canonical: !!timestamp 2001-12-15T02:59:43.0Z
+iso8601: !!timestamp 2001-12-14t21:59:43.00-05:00
+spaced: !!timestamp 2001-12-14 21:59:43.00 -5
+date: !!timestamp 2002-12-14
+matrix: 
+    - [!!timestamp '2001-12-15T02:59:43.0Z', 1]
+    - [!!timestamp '2001-12-15T03:59:43.0Z', 2]
+    
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/usecase_struct_01.mat b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/usecase_struct_01.mat
new file mode 100644
index 0000000000000000000000000000000000000000..97bd8fc7a90749e497ebc3be2152d77500d74500
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/usecase_struct_01.mat differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/usecase_struct_01.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/usecase_struct_01.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d6c9aadfd24275924ebf19e73a8b39378aca21f0
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/usecase_struct_01.yaml
@@ -0,0 +1,566 @@
+in:
+- - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 01_q_Conv,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 2380.0,
+      Delta: 119.0}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 03_q_Conv,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1060.0,
+      Delta: 53.0}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_01_RadiantCeiling,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_02_RadiantCeiling,
+      ZoneName: 03_A1_ML_ME, ZoneID: '02', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_03_RadiantCeiling,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_01_RadiantCeiling,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_03_RadiantCeiling,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 07_q_Conv,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 2380.0,
+      Delta: 119.0}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 09_q_Conv,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1325.0,
+      Delta: 66.25}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_07_RadiantCeiling,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_08_RadiantCeiling,
+      ZoneName: 03_B1_ML_OS, ZoneID: '08', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_09_RadiantCeiling,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_07_RadiantCeiling,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_09_RadiantCeiling,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+- - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 04_q_Conv,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1700.0,
+      Delta: 85.0}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 06_q_Conv,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 2385.0,
+      Delta: 119.25}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_04_RadiantCeiling,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_05_RadiantCeiling,
+      ZoneName: 03_A2_ML_MI, ZoneID: '05', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_06_RadiantCeiling,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_04_RadiantCeiling,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_06_RadiantCeiling,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 19_q_Conv,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 850.0,
+      Delta: 42.5}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 21_q_Conv,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1325.0,
+      Delta: 66.25}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_19_RadiantCeiling,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_20_RadiantCeiling,
+      ZoneName: 03_D1_ML_UN, ZoneID: '20', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_21_RadiantCeiling,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_19_RadiantCeiling,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_21_RadiantCeiling,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+- - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 16_q_Conv,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 2380.0,
+      Delta: 119.0}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 18_q_Conv,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1060.0,
+      Delta: 53.0}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_16_RadiantCeiling,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_17_RadiantCeiling,
+      ZoneName: 03_C2_ML_ME, ZoneID: '17', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_18_RadiantCeiling,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_16_RadiantCeiling,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_18_RadiantCeiling,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 22_q_Conv,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 2380.0,
+      Delta: 119.0}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 24_q_Conv,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1325.0,
+      Delta: 66.25}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_22_RadiantCeiling,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_23_RadiantCeiling,
+      ZoneName: 03_D2_ML_MI, ZoneID: '23', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_24_RadiantCeiling,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_22_RadiantCeiling,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_24_RadiantCeiling,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+- - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 10_q_Conv,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1700.0,
+      Delta: 85.0}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 12_q_Conv,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 2650.0,
+      Delta: 132.5}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_10_RadiantCeiling,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_11_RadiantCeiling,
+      ZoneName: 03_B2_ML_MI, ZoneID: '11', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_12_RadiantCeiling,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_10_RadiantCeiling,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_12_RadiantCeiling,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 13_q_Conv,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 850.0,
+      Delta: 42.5}
+  - - {VarCategoryId: Q_CONV, VariableCategory: Convector heating rate, Identifier: 15_q_Conv,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: 1060.0,
+      Delta: 53.0}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_13_RadiantCeiling,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_14_RadiantCeiling,
+      ZoneName: 03_C1_ML_ME, ZoneID: '14', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPCR, VariableCategory: Zone Ceiling Panel Cooling Rate, Identifier: Hydronic_Low_Temp_Radiant_Cooling_Rate_15_RadiantCeiling,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_13_RadiantCeiling,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+  - - {VarCategoryId: ZCPHR, VariableCategory: Zone Ceiling Panel Heating Rate, Identifier: Hydronic_Low_Temp_Radiant_Heating_Rate_15_RadiantCeiling,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: SI, Unit: W, MinValue: 0.0, MaxValue: .NaN,
+      Delta: .NaN}
+out:
+- - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_A1_OL_SO,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_A1_ML_ME,
+      ZoneName: 03_A1_ML_ME, ZoneID: '02', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_A1_IL_OS,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_B1_OL_MI,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_B1_ML_OS,
+      ZoneName: 03_B1_ML_OS, ZoneID: '08', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_B1_IL_OS,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: totEPD, VariableCategory: Total Energy Power Demand, Identifier: Total Energy Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+  - - {VarCategoryId: totHPD, VariableCategory: Total Heat Power Demand, Identifier: Total Heat Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+- - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_A2_OL_SO,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_A2_ML_MI,
+      ZoneName: 03_A2_ML_MI, ZoneID: '05', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_A2_IL_MI,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_D1_OL_SO,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_D1_ML_UN,
+      ZoneName: 03_D1_ML_UN, ZoneID: '20', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_D1_IL_MI,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: totEPD, VariableCategory: Total Energy Power Demand, Identifier: Total Energy Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+  - - {VarCategoryId: totHPD, VariableCategory: Total Heat Power Demand, Identifier: Total Heat Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+- - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_C2_OL_MI,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_C2_ML_ME,
+      ZoneName: 03_C2_ML_ME, ZoneID: '17', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_C2_IL_OS,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_D2_OL_MI,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_D2_ML_MI,
+      ZoneName: 03_D2_ML_MI, ZoneID: '23', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_D2_IL_OS,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: totEPD, VariableCategory: Total Energy Power Demand, Identifier: Total Energy Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+  - - {VarCategoryId: totHPD, VariableCategory: Total Heat Power Demand, Identifier: Total Heat Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+- - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_B2_OL_SO,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_B2_ML_MI,
+      ZoneName: 03_B2_ML_MI, ZoneID: '11', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_B2_IL_OS,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_C1_OL_SO,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_C1_ML_ME,
+      ZoneName: 03_C1_ML_ME, ZoneID: '14', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: ZT, VariableCategory: Zone Temperature, Identifier: Zone_Mean_Air_Temperature_03_C1_IL_OS,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: SO, Unit: degC, MinValue: .NaN,
+      MaxValue: 200.0}
+  - - {VarCategoryId: totEPD, VariableCategory: Total Energy Power Demand, Identifier: Total Energy Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+  - - {VarCategoryId: totHPD, VariableCategory: Total Heat Power Demand, Identifier: Total Heat Power Demand,
+      ZoneName: '-', ZoneID: '-', VarType: SO, Unit: W, MinValue: 0.0, MaxValue: .NaN}
+dist:
+- - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 01_03_A1_OL_SO_equip,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 02_03_A1_ML_ME_equip,
+      ZoneName: 03_A1_ML_ME, ZoneID: '02', VarType: V, Unit: 2 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 03_03_A1_IL_OS_equip,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 01_03_A1_OL_SO_occup,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 02_03_A1_ML_ME_occup,
+      ZoneName: 03_A1_ML_ME, ZoneID: '02', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 03_03_A1_IL_OS_occup,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 01_03_A1_OL_SO_light,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 02_03_A1_ML_ME_light,
+      ZoneName: 03_A1_ML_ME, ZoneID: '02', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 03_03_A1_IL_OS_light,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_A1_OL_SO,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_A1_ML_ME,
+      ZoneName: 03_A1_ML_ME, ZoneID: '02', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_A1_IL_OS,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_A1_IL_OS,
+      ZoneName: 03_A1_IL_OS, ZoneID: '03', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_A1_OL_SO,
+      ZoneName: 03_A1_OL_SO, ZoneID: '01', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 07_03_B1_OL_MI_equip,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 08_03_B1_ML_OS_equip,
+      ZoneName: 03_B1_ML_OS, ZoneID: '08', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 09_03_B1_IL_OS_equip,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 07_03_B1_OL_MI_occup,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 08_03_B1_ML_OS_occup,
+      ZoneName: 03_B1_ML_OS, ZoneID: '08', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 09_03_B1_IL_OS_occup,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 07_03_B1_OL_MI_light,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 08_03_B1_ML_OS_light,
+      ZoneName: 03_B1_ML_OS, ZoneID: '08', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 09_03_B1_IL_OS_light,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_B1_OL_MI,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_B1_ML_OS,
+      ZoneName: 03_B1_ML_OS, ZoneID: '08', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_B1_IL_OS,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_B1_IL_OS,
+      ZoneName: 03_B1_IL_OS, ZoneID: '09', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_B1_OL_MI,
+      ZoneName: 03_B1_OL_MI, ZoneID: '07', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_A_Core,
+      ZoneName: 03_A_Core, ZoneID: A, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_B_Core,
+      ZoneName: 03_B_Core, ZoneID: B, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_C_Core,
+      ZoneName: 03_C_Core, ZoneID: C, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_D_Core,
+      ZoneName: 03_D_Core, ZoneID: D, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: ODBT, VariableCategory: Outdoor Dry Bulb Temperature, Identifier: Environment_Outdoor_Dry_Bulb,
+      ZoneName: Environment, ZoneID: '', VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+- - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 04_03_A2_OL_SO_equip,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 05_03_A2_ML_MI_equip,
+      ZoneName: 03_A2_ML_MI, ZoneID: '05', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 06_03_A2_IL_MI_equip,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 04_03_A2_OL_SO_occup,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 05_03_A2_ML_MI_occup,
+      ZoneName: 03_A2_ML_MI, ZoneID: '05', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 06_03_A2_IL_MI_occup,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 04_03_A2_OL_SO_light,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 05_03_A2_ML_MI_light,
+      ZoneName: 03_A2_ML_MI, ZoneID: '05', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 06_03_A2_IL_MI_light,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_A2_OL_SO,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_A2_ML_MI,
+      ZoneName: 03_A2_ML_MI, ZoneID: '05', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_A2_IL_MI,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_A2_IL_MI,
+      ZoneName: 03_A2_IL_MI, ZoneID: '06', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_A2_OL_SO,
+      ZoneName: 03_A2_OL_SO, ZoneID: '04', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 19_03_D1_OL_SO_equip,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 21_03_D1_IL_MI_equip,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 19_03_D1_OL_SO_occup,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 21_03_D1_IL_MI_occup,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 19_03_D1_OL_SO_light,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 20_03_D1_ML_UN_light,
+      ZoneName: 03_D1_ML_UN, ZoneID: '20', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 21_03_D1_IL_MI_light,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_D1_OL_SO,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_D1_ML_UN,
+      ZoneName: 03_D1_ML_UN, ZoneID: '20', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_D1_IL_MI,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_D1_IL_MI,
+      ZoneName: 03_D1_IL_MI, ZoneID: '21', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_D1_OL_SO,
+      ZoneName: 03_D1_OL_SO, ZoneID: '19', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_A_Core,
+      ZoneName: 03_A_Core, ZoneID: A, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_B_Core,
+      ZoneName: 03_B_Core, ZoneID: B, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_C_Core,
+      ZoneName: 03_C_Core, ZoneID: C, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_D_Core,
+      ZoneName: 03_D_Core, ZoneID: D, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: ODBT, VariableCategory: Outdoor Dry Bulb Temperature, Identifier: Environment_Outdoor_Dry_Bulb,
+      ZoneName: Environment, ZoneID: '', VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+- - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 16_03_C2_OL_MI_equip,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 17_03_C2_ML_ME_equip,
+      ZoneName: 03_C2_ML_ME, ZoneID: '17', VarType: V, Unit: 2 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 18_03_C2_IL_OS_equip,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 16_03_C2_OL_MI_occup,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 17_03_C2_ML_ME_occup,
+      ZoneName: 03_C2_ML_ME, ZoneID: '17', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 18_03_C2_IL_OS_occup,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 16_03_C2_OL_MI_light,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 17_03_C2_ML_ME_light,
+      ZoneName: 03_C2_ML_ME, ZoneID: '17', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 18_03_C2_IL_OS_light,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_C2_OL_MI,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_C2_ML_ME,
+      ZoneName: 03_C2_ML_ME, ZoneID: '17', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_C2_IL_OS,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_C2_IL_OS,
+      ZoneName: 03_C2_IL_OS, ZoneID: '18', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_C2_OL_MI,
+      ZoneName: 03_C2_OL_MI, ZoneID: '16', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 22_03_D2_OL_MI_equip,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 23_03_D2_ML_MI_equip,
+      ZoneName: 03_D2_ML_MI, ZoneID: '23', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 24_03_D2_IL_OS_equip,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 22_03_D2_OL_MI_occup,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 23_03_D2_ML_MI_occup,
+      ZoneName: 03_D2_ML_MI, ZoneID: '23', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 24_03_D2_IL_OS_occup,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 22_03_D2_OL_MI_light,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 23_03_D2_ML_MI_light,
+      ZoneName: 03_D2_ML_MI, ZoneID: '23', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 24_03_D2_IL_OS_light,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_D2_OL_MI,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_D2_ML_MI,
+      ZoneName: 03_D2_ML_MI, ZoneID: '23', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT11_03_D2_IL_OS,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_D2_IL_OS,
+      ZoneName: 03_D2_IL_OS, ZoneID: '24', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_D2_OL_MI,
+      ZoneName: 03_D2_OL_MI, ZoneID: '22', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_A_Core,
+      ZoneName: 03_A_Core, ZoneID: A, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_B_Core,
+      ZoneName: 03_B_Core, ZoneID: B, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_C_Core,
+      ZoneName: 03_C_Core, ZoneID: C, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_D_Core,
+      ZoneName: 03_D_Core, ZoneID: D, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: ODBT, VariableCategory: Outdoor Dry Bulb Temperature, Identifier: Environment_Outdoor_Dry_Bulb,
+      ZoneName: Environment, ZoneID: '', VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+- - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 10_03_B2_OL_SO_equip,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 11_03_B2_ML_MI_equip,
+      ZoneName: 03_B2_ML_MI, ZoneID: '11', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 12_03_B2_IL_OS_equip,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 10_03_B2_OL_SO_occup,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 11_03_B2_ML_MI_occup,
+      ZoneName: 03_B2_ML_MI, ZoneID: '11', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 12_03_B2_IL_OS_occup,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 10_03_B2_OL_SO_light,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 11_03_B2_ML_MI_light,
+      ZoneName: 03_B2_ML_MI, ZoneID: '11', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 12_03_B2_IL_OS_light,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_B2_OL_SO,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_B2_ML_MI,
+      ZoneName: 03_B2_ML_MI, ZoneID: '11', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_B2_IL_OS,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_B2_IL_OS,
+      ZoneName: 03_B2_IL_OS, ZoneID: '12', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_B2_OL_SO,
+      ZoneName: 03_B2_OL_SO, ZoneID: '10', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 13_03_C1_OL_SO_equip,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: V, Unit: 7 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 14_03_C1_ML_ME_equip,
+      ZoneName: 03_C1_ML_ME, ZoneID: '14', VarType: V, Unit: 2 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: EG, VariableCategory: Equipment Gains, Identifier: 15_03_C1_IL_OS_equip,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: V, Unit: 10 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 13_03_C1_OL_SO_occup,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 14_03_C1_ML_ME_occup,
+      ZoneName: 03_C1_ML_ME, ZoneID: '14', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: OG, VariableCategory: Occupancy Gains, Identifier: 15_03_C1_IL_OS_occup,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: V, Unit: '-', MinValue: '0', MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 13_03_C1_OL_SO_light,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 14_03_C1_ML_ME_light,
+      ZoneName: 03_C1_ML_ME, ZoneID: '14', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: LG, VariableCategory: Lighting Gains, Identifier: 15_03_C1_IL_OS_light,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: V, Unit: 6.6 W/m2, MinValue: '0',
+      MaxValue: '1'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_C1_OL_SO,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_C1_ML_ME,
+      ZoneName: 03_C1_ML_ME, ZoneID: '14', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: FP, VariableCategory: Fan Power, Identifier: FanPower_RLT10_03_C1_IL_OS,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: V, Unit: W, MinValue: '0', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_C1_IL_OS,
+      ZoneName: 03_C1_IL_OS, ZoneID: '15', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: SS, VariableCategory: SolarStuff, Identifier: SS_03_C1_OL_SO,
+      ZoneName: 03_C1_OL_SO, ZoneID: '13', VarType: V, Unit: W, MinValue: '-', MaxValue: '-'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_A_Core,
+      ZoneName: 03_A_Core, ZoneID: A, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_B_Core,
+      ZoneName: 03_B_Core, ZoneID: B, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_C_Core,
+      ZoneName: 03_C_Core, ZoneID: C, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: CT, VariableCategory: Core Temperature, Identifier: Zone_Mean_Air_Temperature_03_D_Core,
+      ZoneName: 03_D_Core, ZoneID: D, VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
+  - - {VarCategoryId: ODBT, VariableCategory: Outdoor Dry Bulb Temperature, Identifier: Environment_Outdoor_Dry_Bulb,
+      ZoneName: Environment, ZoneID: '', VarType: V, Unit: degC, MinValue: '-', MaxValue: '200'}
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/whitespaces.yaml b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/whitespaces.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ea016fe4888b5fba2132177c55cf8f626c84dc85
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/Data/test_primitives/whitespaces.yaml
@@ -0,0 +1,3 @@
+YAML: 1.0
+Image file: 00032009.jpg
+Contours count: 8
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/selftest_report.html b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/selftest_report.html
new file mode 100644
index 0000000000000000000000000000000000000000..5c2c362e5ae5be598b5f96cd4d4d2e0c2b9e21c7
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/selftest_report.html
@@ -0,0 +1 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"   "http://www.w3.org/TR/html4/strict.dtd"><HTML> <HEAD><TITLE>::SELFTEST REPORT::</TITLE><STYLE> H2{color:blue} #MainTest{border: 1px blue solid;} h3,h4,h5,h6 {display: inline;}     </STYLE></HEAD><BODY style="font-family:Arial, helvetica"><h1>Selftest report from:28-Nov-2012 15:17:38</h1><div id="MainTest"> <h2>test_ReadYaml</h2><div id="Test"><h3>test_ReadYaml: </h3>Passed <i></i> </div><table><tr><div id="Test"><h3>test_RY_FloatingPoints: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Import: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_ImportDef: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_ImportNonex: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Indentation: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Inheritance: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_InheritanceLoop: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_InheritanceMultiple: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Matrices: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_SequenceMapping: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Simple: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Time: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_TimeVariants: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_Whitespaces: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_RY_usecase_01: </h3>Passed <i></i> </div><table></table></tr></table></div><div id="MainTest"> <h2>test_WriteYaml</h2><div id="Test"><h3>test_WriteYaml: </h3>Passed <i></i> </div><table><tr><div id="Test"><h3>test_WY_ComplexStructure: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_FloatingPoints: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_Indentation: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_Matrices: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_SequenceMapping: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_Simple: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_Time: </h3>Passed <i></i> </div><table></table></tr><tr><div id="Test"><h3>test_WY_usecase_01: </h3><b style="color:red">Failed</b>, <i>Wrong values loaded</i> </div><table></table></tr></table></div></BODY></HTML>
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/selftest_yamlmatlab.m b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/selftest_yamlmatlab.m
new file mode 100644
index 0000000000000000000000000000000000000000..10353c4c3f2a71563c8de0298b0c6c71a4071e4e
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/selftest_yamlmatlab.m
@@ -0,0 +1,95 @@
+function  selftest_yamlmatlab(varargin)
+% This function tests consistency of YAMLMatlab, by default, the results
+% are stored in selftest_report.html in current work folder.
+% Example
+% >> selftest_yamlmatlab()
+% >> selftest_yamlmatlab(outFileName)
+%
+%  %======================================================================
+%{
+		Copyright (c) 2011
+		This program is a result of a joined cooperation of Energocentrum
+		PLUS, s.r.o. and Czech Technical University (CTU) in Prague.
+        The program is maintained by Energocentrum PLUS, s.r.o. and
+        licensed under the terms of MIT license. Full text of the license
+        is included in the program release.
+		
+        Author(s):
+		Jiri Cigler, Dept. of Control Engineering, CTU Prague 
+		Jan  Siroky, Energocentrum PLUS s.r.o.
+		
+        Implementation and Revisions:
+
+        Auth  Date        Description of change
+        ----  ---------   -------------------------------------------------
+        jc    25-May-11   First implementation        
+%}
+%======================================================================
+
+    fprintf('Running tests.\n');
+    outFname = 'selftest_report.html';
+    if numel(varargin)
+        outFname = varargin{1};
+    end
+
+    outStr = getHTMLHeader();
+
+    outStr = strcat(outStr,'<h1>Selftest report from:',datestr(now),'</h1>');
+
+    tests = dir([fileparts(which('selftest_yamlmatlab')) filesep 'test*.m']);
+
+    for test=tests'
+        [~,func]=fileparts(test.name);
+
+        fhandle = str2func(func);
+        stat = fhandle();
+    
+        outStr = strcat(outStr, '<div id="MainTest"> <h2>',func, '</h2>', stat2html(stat,func),'</div>');
+    
+    end
+
+    outStr = strcat(outStr,'</BODY></HTML>');
+
+
+    fid = fopen(outFname,'w');
+    fprintf(fid,outStr);
+    fclose(fid);
+    
+    fprintf('Opening internal browser.\n');
+   
+    web(outFname,'-new');
+end
+
+function html = stat2html(stat,name)
+    if not(isstruct(stat))
+        error('Input argument must be a struct');
+    end
+
+    html = '';
+
+    fn = fieldnames(stat);
+    if all(ismember({'ok','desc'},fn))
+        if stat.ok
+            flag = 'Passed';
+        else
+            flag = '<b style="color:red">Failed</b>,';
+        end
+        html = strcat(html,'<div id="Test"><h3>',name,': </h3> ', flag, ' <i>', stat.desc,'</i> </div>' );
+    end
+    html = [html, '<table>'];
+    for test = setdiff(fn',{'ok','desc'})
+        html = [html, '<tr>'];
+        html = strcat(html, stat2html(stat.(test{1}),test{1}));
+        html = [html, '</tr>'];
+    end
+    html = [html, '</table>'];
+end
+
+
+function str = getHTMLHeader()
+    str = [ '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"   "http://www.w3.org/TR/html4/strict.dtd">' ... 
+        '<HTML> ' ... 
+        '<HEAD>'... 
+        '<TITLE>::SELFTEST REPORT::</TITLE><STYLE> H2{color:blue} #MainTest{border: 1px blue solid;} h3,h4,h5,h6 {display: inline;}     </STYLE>'... 
+        '</HEAD><BODY style="font-family:Arial, helvetica">'];
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/test_ReadYaml.m b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/test_ReadYaml.m
new file mode 100644
index 0000000000000000000000000000000000000000..5dbf6f477e3279caedad696e883392062eb27125
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/test_ReadYaml.m
@@ -0,0 +1,351 @@
+function stat = test_ReadYaml()
+% this function tests reading in the yaml file
+
+stat.ok = 1;
+stat.desc = '';
+try
+    %stat.test_ReadYaml_SimpleStructure = test_ReadYaml_SimpleStructure();   
+    %stat.test_ReadYaml_DateTime = test_ReadYaml_DateTime();  
+    fprintf('Testing read ');
+    stat.test_RY_Matrices = test_RY_Matrices();
+    fprintf('.');
+    stat.test_RY_Whitespaces = test_RY_Whitespaces();
+    fprintf('.');
+    stat.test_RY_FloatingPoints = test_RY_FloatingPoints();
+    fprintf('.');
+    stat.test_RY_Indentation = test_RY_Indentation();
+    fprintf('.');
+    stat.test_RY_SequenceMapping = test_RY_SequenceMapping();
+    fprintf('.');
+    stat.test_RY_Simple = test_RY_Simple();
+    fprintf('.');
+    stat.test_RY_Time = test_RY_Time();
+    fprintf('.');
+    stat.test_RY_TimeVariants = test_RY_TimeVariants();
+    fprintf('.');
+    stat.test_RY_Import = test_RY_Import();
+    fprintf('.');
+    stat.test_RY_ImportDef = test_RY_ImportDef();
+    fprintf('.');
+    stat.test_RY_ImportNonex = test_RY_ImportNonex();
+    fprintf('.');
+    stat.test_RY_Inheritance = test_RY_Inheritance();
+    fprintf('.');
+    stat.test_RY_InheritanceMultiple = test_RY_InheritanceMultiple();
+    fprintf('.');
+    stat.test_RY_InheritanceLoop = test_RY_InheritanceLoop();
+    fprintf('.');
+    stat.test_RY_usecase_01 = test_RY_usecase_01();
+    fprintf('.\n');
+    
+catch    
+    stat.ok = 0;
+    stat.desc  = 'Program crash';
+end
+
+end
+
+function result = PTH_PRIMITIVES()
+    result = sprintf('Data%stest_primitives%s',filesep,filesep);
+end
+
+function result = PTH_IMPORT()
+    result = sprintf('Data%stest_import%s',filesep,filesep);
+end
+
+function result = PTH_INHERITANCE()
+    result = sprintf('Data%stest_inheritance%s',filesep,filesep);
+end
+
+function stat = test_RY_Matrices()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'matrices.yaml']);
+        tv = load([PTH_PRIMITIVES() 'matrices.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_FloatingPoints()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'floating_points.yaml']);
+        tv = load([PTH_PRIMITIVES() 'floating_points.mat']);
+        if ~isequalwithequalnans(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_Indentation()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'indentation.yaml']);
+        tv = load([PTH_PRIMITIVES() 'indentation.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_SequenceMapping()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'sequence_mapping.yaml']);
+        tv = load([PTH_PRIMITIVES() 'sequence_mapping.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_Simple()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'simple.yaml']);
+        tv = load([PTH_PRIMITIVES() 'simple.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_Time()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'time.yaml']);
+        tv = load([PTH_PRIMITIVES() 'time.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_TimeVariants()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'time_variants.yaml']);
+        tv = load([PTH_PRIMITIVES() 'time_variants.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_Import()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_IMPORT() 'import.yaml']);
+        tv = load([PTH_IMPORT() 'import.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_ImportDef()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_IMPORT() 'import_def.yaml']);
+        tv = load([PTH_IMPORT() 'import_def.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_ImportNonex()
+    stat.ok = 0;
+    stat.desc = 'Did not end with any exception.';
+    try
+        try
+            ry = ReadYaml([PTH_IMPORT() 'import_nonex.yaml'],1);
+        catch ex
+            if strcmp(ex.identifier, 'MATLAB:MATYAML:FileNotFound')
+                stat.desc = '';
+                stat.ok = 1;
+            else
+                rethrow(ex);
+            end;
+        end;      
+        
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_Inheritance()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_INHERITANCE() 'inheritance.yaml']);
+        tv = load([PTH_INHERITANCE() 'inheritance.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_InheritanceMultiple()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_INHERITANCE() 'inheritance_multiple.yaml']);
+        tv = load([PTH_INHERITANCE() 'inheritance_multiple.mat']);
+        if ~isequal(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_InheritanceLoop()
+    stat.ok = 0;
+    stat.desc = 'Did not end with any exception.';
+    try
+        try
+            ry = ReadYaml([PTH_INHERITANCE() 'inheritance_loop.yaml']);
+        catch ex
+            if strcmp(ex.identifier, 'MATLAB:MATYAML:inheritedtwice')
+                stat.desc = '';
+                stat.ok = 1;
+            else
+                rethrow(ex);
+            end;
+        end;      
+        
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_Whitespaces()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'whitespaces.yaml']);
+        if ~isfield(ry,'ImageFile') || ~isfield(ry,'ContoursCount')         
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+function stat = test_RY_usecase_01()
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        ry = ReadYaml([PTH_PRIMITIVES() 'usecase_struct_01.yaml']);
+        tv = load([PTH_PRIMITIVES() 'usecase_struct_01.mat']);
+        if ~isequalwithequalnans(ry, tv.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;
+end
+
+
+function stat = test_ReadYaml_SimpleStructure()
+
+stat.ok = 1;
+stat.desc = '';
+try
+    s = ReadYaml('simple.yaml');
+    
+    ages = [s.age];
+    
+    if not(isequal([33 27], ages))  || not(all(ismember({'John Smith', 'Mary Smith'}, {s.name}) ))
+        stat.desc  = ' Wrong values loaded';
+        stat.ok = 0;
+    end
+    
+catch   
+       stat.desc  = 'Program crash';
+       stat.ok = 0;
+end
+
+
+end
+
+function stat = test_ReadYaml_DateTime()
+
+stat.ok = 1;
+stat.desc = '';
+try
+    s = ReadYaml('time.yaml');
+    
+    if ~isa(s.Data.B1_S_SW{1},'DateTime')
+        stat.desc  = ' Wrong data type of datetick';
+        stat.ok = 0;
+    end
+    if isa(s.Data.B1_S_SW{2},'DateTime')
+        stat.desc  = ' Wrong data type of datetick';
+        stat.ok = 0;
+    end
+catch
+       stat.desc  = 'Program crash';
+       stat.ok = 0;
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/test_WriteYaml.m b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/test_WriteYaml.m
new file mode 100644
index 0000000000000000000000000000000000000000..65af6851723b97bf04105d5793dfcb323245f6a5
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/Tests/test_WriteYaml.m
@@ -0,0 +1,57 @@
+function stat = test_WriteYaml()
+
+stat.ok = 1;
+stat.desc = '';
+try
+    fprintf('Testing write ');
+    stat.test_WY_Matrices = test_WY_Universal(PTH_PRIMITIVES(), 'matrices');
+    fprintf('.');
+    stat.test_WY_FloatingPoints = test_WY_Universal(PTH_PRIMITIVES(), 'floating_points');
+    fprintf('.');
+    stat.test_WY_Indentation = test_WY_Universal(PTH_PRIMITIVES(), 'indentation');
+    fprintf('.');
+    stat.test_WY_SequenceMapping = test_WY_Universal(PTH_PRIMITIVES(), 'sequence_mapping');
+    fprintf('.');
+    stat.test_WY_Simple = test_WY_Universal(PTH_PRIMITIVES(), 'simple');
+    fprintf('.');
+    stat.test_WY_Time = test_WY_Universal(PTH_PRIMITIVES(), 'time');
+    fprintf('.');
+    stat.test_WY_ComplexStructure = test_WY_Universal(PTH_IMPORT(), 'import');
+    fprintf('.');
+    stat.test_WY_usecase_01 = test_WY_Universal(PTH_PRIMITIVES(), 'usecase_struct_01');    
+    fprintf('.\n');
+catch    
+    stat.ok = 0;
+    stat.desc  = 'Program crash';
+end
+
+end
+
+function result = PTH_PRIMITIVES()
+    result = sprintf('Data%stest_primitives%s',filesep,filesep);
+end
+
+function result = PTH_IMPORT()
+    result = sprintf('Data%stest_import%s',filesep,filesep);
+end
+
+function result = PTH_INHERITANCE()
+    result = sprintf('Data%stest_inheritance%s',filesep,filesep);
+end
+
+function stat = test_WY_Universal(path, filename)
+    stat.ok = 1;
+    stat.desc = '';
+    try
+        data = load([path, filesep, filename, '.mat']);
+        WriteYaml('~temporary.yaml',data.testval);
+        ry = ReadYaml('~temporary.yaml');
+        if ~isequalwithequalnans(ry, data.testval)
+            stat.desc  = 'Wrong values loaded';
+            stat.ok = 0;         
+        end;
+    catch
+        stat.ok = 0;
+        stat.desc = 'Crash';
+    end;    
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/WriteYaml.m b/Requirements/MEIGO/PEtabMEIGO/yaml/WriteYaml.m
new file mode 100644
index 0000000000000000000000000000000000000000..404dc1531a43b5753af7c4698ac641ce822933b7
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/WriteYaml.m
@@ -0,0 +1,194 @@
+function result = WriteYaml(filename, data, flowstyle)
+import yaml.*;
+if ~exist('flowstyle','var')
+        flowstyle = 0;
+    end;
+    if ~ismember(flowstyle, [0,1])
+        error('Flowstyle must be 0,1 or empty.');
+    end;
+    result = [];
+    [pth,~,~] = fileparts(mfilename('fullpath'));
+    try
+        import('org.yaml.snakeyaml.*');
+        javaObject('Yaml');
+    catch
+        dp = [pth filesep 'external' filesep 'snakeyaml-1.9.jar'];
+        if not(ismember(dp, javaclasspath ('-dynamic')))
+        	javaaddpath(dp); % javaaddpath clears global variables!?
+        end
+        import('org.yaml.snakeyaml.*');
+    end;
+    javastruct = scan(data);
+    dumperopts = DumperOptions();
+    dumperopts.setLineBreak(        javaMethod('getPlatformLineBreak',        'org.yaml.snakeyaml.DumperOptions$LineBreak'));
+    if flowstyle
+        classes = dumperopts.getClass.getClasses;
+        flds = classes(3).getDeclaredFields();
+        fsfld = flds(1);
+        if ~strcmp(char(fsfld.getName), 'FLOW')
+            error(['Accessed another field instead of FLOW. Please correct',            'class/field indices (this error maybe caused by new snakeyaml version).']);
+        end;
+        dumperopts.setDefaultFlowStyle(fsfld.get([]));
+    end;
+    yaml = Yaml(dumperopts);
+    output = yaml.dump(javastruct);
+    if ~isempty(filename)
+        fid = fopen(filename,'w');
+        fprintf(fid,'%s',char(output) );
+        fclose(fid);
+    else
+        result = output;
+    end;
+end
+function result = scan(r)
+import yaml.*;
+if ischar(r)
+        result = scan_char(r);
+    elseif iscell(r)
+        result = scan_cell(r);
+    elseif isord(r)
+        result = scan_ord(r);
+    elseif isstruct(r)
+        result = scan_struct(r);                
+    elseif isnumeric(r)
+        result = scan_numeric(r);
+    elseif islogical(r)
+        result = scan_logical(r);
+    elseif isa(r,'DateTime')
+        result = scan_datetime(r);
+    else
+        error(['Cannot handle type: ' class(r)]);
+    end
+end
+function result = scan_numeric(r)
+import yaml.*;
+if isempty(r)
+        result = java.util.ArrayList();
+    elseif(isinteger(r))
+        result = java.lang.Integer(r);
+    else
+        result = java.lang.Double(r);
+    end
+end
+function result = scan_logical(r)
+import yaml.*;
+if isempty(r)
+        result = java.util.ArrayList();
+    else
+        result = java.lang.Boolean(r);
+    end
+end
+function result = scan_char(r)
+import yaml.*;
+if isempty(r)
+        result = java.util.ArrayList();
+    else
+        result = java.lang.String(r);
+    end
+end
+function result = scan_datetime(r)
+import yaml.*;
+[Y, M, D, H, MN,S] = datevec(double(r));            
+	result = java.util.GregorianCalendar(Y, M-1, D, H, MN,S);
+	result.setTimeZone(java.util.TimeZone.getTimeZone('UTC'));
+end
+function result = scan_cell(r)
+import yaml.*;
+if(isrowvector(r))  
+        result = scan_cell_row(r);
+    elseif(iscolumnvector(r))
+        result = scan_cell_column(r);
+    elseif(ismymatrix(r))
+        result = scan_cell_matrix(r);
+    elseif(issingle(r));
+        result = scan_cell_single(r);
+    elseif(isempty(r))
+        result = java.util.ArrayList();
+    else
+        error('Unknown cell content.');
+    end;
+end
+function result = scan_ord(r)
+import yaml.*;
+if(isrowvector(r))
+        result = scan_ord_row(r);
+    elseif(iscolumnvector(r))
+        result = scan_ord_column(r);
+    elseif(ismymatrix(r))
+        result = scan_ord_matrix(r);
+    elseif(issingle(r))
+        result = scan_ord_single(r);
+    elseif(isempty(r))
+        result = java.util.ArrayList();
+    else
+        error('Unknown ordinary array content.');
+    end;
+end
+function result = scan_cell_row(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for ii = 1:size(r,2)
+        result.add(scan(r{ii}));
+    end;
+end
+function result = scan_cell_column(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for ii = 1:size(r,1)
+        tmp = r{ii};
+        if ~iscell(tmp)
+            tmp = {tmp};
+        end;
+        result.add(scan(tmp));
+    end;    
+end
+function result = scan_cell_matrix(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for ii = 1:size(r,1)
+        i = r(ii,:);
+        result.add(scan_cell_row(i));
+    end;
+end
+function result = scan_cell_single(r)
+import yaml.*;
+result = java.util.ArrayList();
+    result.add(scan(r{1}));
+end
+function result = scan_ord_row(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for i = r
+        result.add(scan(i));
+    end;
+end
+function result = scan_ord_column(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for i = 1:size(r,1)
+        result.add(scan_ord_row(r(i)));
+    end;
+end
+function result = scan_ord_matrix(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for i = r'
+        result.add(scan_ord_row(i'));
+    end;
+end
+function result = scan_ord_single(r)
+import yaml.*;
+result = java.util.ArrayList();
+    for i = r'
+        result.add(r);
+    end;
+end
+function result = scan_struct(r)
+import yaml.*;
+result = java.util.LinkedHashMap();
+    for i = fields(r)'
+        key = i{1};
+        val = r.(key);
+        result.put(key,scan(val));
+    end;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/assert_single_condition_and_sbml_file.m b/Requirements/MEIGO/PEtabMEIGO/yaml/assert_single_condition_and_sbml_file.m
new file mode 100644
index 0000000000000000000000000000000000000000..a3ed478ce78d5efb960f7a252a76f4df3629a49f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/assert_single_condition_and_sbml_file.m
@@ -0,0 +1,19 @@
+function assert_single_condition_and_sbml_file(problem_config)
+    %Check that there is only a single condition file and a single SBML
+    %file specified.
+    %
+    %Arguments:
+    %   problem_config [struct]:
+    %       Structure as defined in the YAML schema inside the `problems`
+    %       list.
+    % Raises:
+    %   [NotImplementedError]
+    %       If multiple condition or SBML files specified.
+    
+    if numel(problem_config.sbml_files) > 1 || ...
+            numel(problem_config.condition_files) > 1
+        
+        error('YAML:NotImplementedError', ['Support for multiple ' ...
+            'models or condition files is not yet implemented'])
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/datadump.m b/Requirements/MEIGO/PEtabMEIGO/yaml/datadump.m
new file mode 100644
index 0000000000000000000000000000000000000000..aa300312878c3a4e894bf5c1d592d392c9998ad3
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/datadump.m
@@ -0,0 +1,39 @@
+function datadump(data)
+import yaml.*;
+recurse(data, 0, []);
+end
+function result = recurse(data, level, addit)
+import yaml.*;
+indent = repmat(' | ',1,level);
+    if iscell(data) && ~ismymatrix(data)
+        result = iter_cell(data, level, addit);
+    elseif isstruct(data)
+        result = iter_struct(data, level, addit);
+    else
+        fprintf([indent,' +-Some data: ']);
+        disp(data);
+        result = data;
+    end;
+end
+function result = iter_cell(data, level, addit)
+import yaml.*;
+indent = repmat(' | ',1,level);
+    result = {};
+    fprintf([indent,'cell {\n']);
+    for i = 1:length(data)
+        result{i} = recurse(data{i}, level + 1, addit);
+    end;
+    fprintf([indent,'} cell\n']);
+end
+function result = iter_struct(data, level, addit)
+import yaml.*;
+indent = repmat(' | ',1,level);
+    result = struct();
+    fprintf([indent,'struct {\n']);
+    for i = fields(data)'
+        fld = char(i);
+        fprintf([indent,' +-field ',fld,':\n']);
+        result.(fld) = recurse(data.(fld), level + 1, addit);
+    end;
+    fprintf([indent,'} struct\n']);
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/deflateimports.m b/Requirements/MEIGO/PEtabMEIGO/yaml/deflateimports.m
new file mode 100644
index 0000000000000000000000000000000000000000..6da5f1c1da7f8ab6465350629b0513e3e60c798f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/deflateimports.m
@@ -0,0 +1,60 @@
+function result = deflateimports(r)
+import yaml.*;
+result = recurse(r, 0, []);
+end
+function result = recurse(data, level, addit)
+import yaml.*;
+if iscell(data) && ~ismymatrix(data)
+        result = iter_cell(data, level, addit);
+    elseif isstruct(data)
+        result = iter_struct(data, level, addit);
+    else
+        result = data;
+    end;
+end
+function result = iter_cell(data, level, addit)
+import yaml.*;
+result = {};
+    icollect = {};
+    ii = 1;
+    for i = 1:length(data)
+        datai = data{i};
+        if issingleimport(datai)
+            if ~iscell(datai.import)
+                datai.import = {datai.import};
+            end;
+            for j = 1:length(datai.import)
+                icollect{end + 1} = datai.import{j};
+            end;
+        else
+            result{ii} = recurse(datai, level + 1, addit);
+            ii = ii + 1;
+        end;
+    end;
+    if ~isempty(icollect)
+        result{end + 1} = struct('import',{icollect});
+    end;
+end
+function result = iter_struct(data, level, addit)
+import yaml.*;
+result = struct();
+    for i = fields(data)'
+        fld = char(i);
+        result.(fld) = recurse(data.(fld), level + 1, addit);
+    end;
+end
+function result = issingleimport_all(r)
+import yaml.*;
+result = all(cellfun(@issingleimport, r));
+end
+function result = issingleimport(r)
+import yaml.*;
+result = isstruct(r) && length(fields(r)) == 1 && isfield(r, 'import');
+end
+function result = addall(list1, list2)
+import yaml.*;
+for i = 1:length(list2)
+        list1{end + 1} = list2{i};
+    end;
+    result = list1;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/doinheritance.m b/Requirements/MEIGO/PEtabMEIGO/yaml/doinheritance.m
new file mode 100644
index 0000000000000000000000000000000000000000..4d0a58d9c9cc0d73ce9fc0b89c2ae9ba82d4fb59
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/doinheritance.m
@@ -0,0 +1,80 @@
+function result = doinheritance(r, tr)
+import yaml.*;
+if ~exist('tr','var')
+        tr = r;
+    end;
+    result = recurse(r, 0, {tr});
+end
+function result = recurse(data, level, addit)
+import yaml.*;
+if iscell(data) && ~ismymatrix(data)
+        result = iter_cell(data, level, addit);
+    elseif isstruct(data)
+        result = iter_struct(data, level, addit);
+    else
+        result = data;
+    end;
+end
+function result = iter_cell(data, level, addit)
+import yaml.*;
+result = {};
+    for i = 1:length(data)
+        result{i} = recurse(data{i}, level + 1, addit);
+    end;
+    for i = 1:length(data)
+        if isstruct(result{i}) && isfield(result{i}, kwd_parent())
+            result{i} = inherit(result{i}, result{i}.(kwd_parent()), [], addit{1}, {}); % !!!
+        end;
+    end;
+end
+function result = iter_struct(data, level, addit)
+import yaml.*;
+result = data;
+    for i = fields(data)'
+        fld = char(i);
+        result.(fld) = recurse(data.(fld), level + 1, addit);
+    end;
+    for i = fields(result)'
+        fld = char(i);
+        if isstruct(result.(fld)) && isfield(result.(fld), kwd_parent())
+            result.(fld) = inherit(result.(fld), result.(fld).(kwd_parent()), [], addit{1}, {});
+        end;
+    end;
+end
+function result = inherit(child, parent_chr, container, oaroot, loc_imported)
+import yaml.*;
+result = child;
+    if ~iscell(parent_chr)
+        parent_chr = {parent_chr};
+    end;
+    for i = length(parent_chr):-1:1
+        if contains(loc_imported, parent_chr{i})
+            error('MATLAB:MATYAML:inheritedtwice',['Cyclic inheritance: ', parent_chr{i}]);
+        end;
+        try
+            parentstruct = eval(['oaroot.',parent_chr{i}]);
+        catch ex
+            switch ex.identifier
+                case {'MATLAB:nonExistentField', 'MATLAB:badsubscript'}
+                    error('MATLAB:MATYAML:NonExistentParent', ['Parent was not found: ',parent_chr{i}]);
+            end;
+            rethrow(ex);
+        end;
+        if isstruct(parentstruct) && isfield(parentstruct, kwd_parent())
+            next_loc_imported = loc_imported;
+            next_loc_imported{end + 1} = parent_chr{i};
+            result = merge_struct(inherit(parentstruct, parentstruct.(kwd_parent()), [], oaroot, next_loc_imported), result, {'import'});
+        end;
+        result = merge_struct(parentstruct, result, {'import'});
+    end;
+end
+function result = contains(list, chr)
+import yaml.*;
+for i = 1:length(list)
+        if strcmp(list{i}, chr)
+            result = true;
+            return;
+        end;
+    end;
+    result = false;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/dosubstitution.m b/Requirements/MEIGO/PEtabMEIGO/yaml/dosubstitution.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3f304d2a195c59a972e10f70ef458bb138bdec7
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/dosubstitution.m
@@ -0,0 +1,34 @@
+function result = dosubstitution(r, dictionary)
+import yaml.*;
+if ~exist('dictionary','var')
+        dictionary = {};
+    end;
+    result = recurse(r, 0, dictionary);
+end
+function result = recurse(data, level, dictionary)
+import yaml.*;
+if iscell(data) && ~ismymatrix(data)
+        result = iter_cell(data, level, dictionary);
+    elseif isstruct(data)
+        result = iter_struct(data, level, dictionary);
+    elseif ischar(data) && isfield(dictionary, data)
+        result = dictionary.(data);
+    else
+        result = data;
+    end;
+end
+function result = iter_cell(data, level, dictionary)
+import yaml.*;
+result = {};
+    for i = 1:length(data)
+        result{i} = recurse(data{i}, level + 1, dictionary);
+    end;
+end
+function result = iter_struct(data, level, dictionary)
+import yaml.*;
+result = data;
+    for i = fields(data)'
+        fld = char(i);
+        result.(fld) = recurse(data.(fld), level + 1, dictionary);
+    end;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/external/LICENSE-2.0.txt b/Requirements/MEIGO/PEtabMEIGO/yaml/external/LICENSE-2.0.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/external/LICENSE-2.0.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/external/snakeyaml-1.9.jar b/Requirements/MEIGO/PEtabMEIGO/yaml/external/snakeyaml-1.9.jar
new file mode 100644
index 0000000000000000000000000000000000000000..7e24a71b982032d55a6f77047b2a015d14fe7220
Binary files /dev/null and b/Requirements/MEIGO/PEtabMEIGO/yaml/external/snakeyaml-1.9.jar differ
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/extras/GetYamlVals.m b/Requirements/MEIGO/PEtabMEIGO/yaml/extras/GetYamlVals.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3b69dfa9cc2c1059cb4ed62cb7b80a5af202c12
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/extras/GetYamlVals.m
@@ -0,0 +1,28 @@
+function [vals, timeaxis] = GetYamlVals(yamldata)
+% this function converts data formatted in yaml style (cells containing timestamps and values) 
+% into matlab user friendly matrices.
+
+% obtain number of samples
+n = max(size(yamldata));
+
+if n
+    if not(iscell(yamldata{1}))
+        timeaxis = double(yamldata{1});
+        vals   = cell2mat(yamldata(2:end));
+    else
+
+        % create output matrices
+        timeaxis =  NaN*ones(n,1);
+        if n % only if there are some elements of timeaxis
+            vals = NaN*ones(n,numel(yamldata{1})-1);
+        end
+        for i=1:n
+            timeaxis(i) = double(yamldata{i}{1});
+            vals(i,:)   = cell2mat(yamldata{i}(2:end));
+        end
+    end
+
+end
+
+end % end of function
+
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/extras/TimeVals2Cell.m b/Requirements/MEIGO/PEtabMEIGO/yaml/extras/TimeVals2Cell.m
new file mode 100644
index 0000000000000000000000000000000000000000..54e9fef238a30042e9835bbceb806a3e5b73bda5
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/extras/TimeVals2Cell.m
@@ -0,0 +1,13 @@
+function s = TimeVals2Cell(time,datavalues,header)
+% creates a typical struct with field named by header. Values are cell of
+% date and vals.
+% synopsis:
+%  s = TimeVals2Cell(time,datavalues,header)
+if ~iscell(header)
+    header = {header};
+end
+
+for i=1:numel(header)
+    s.(header{i}) = [num2cell(DateTime(time)) num2cell(datavalues(:,i))];
+end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/iscolumnvector.m b/Requirements/MEIGO/PEtabMEIGO/yaml/iscolumnvector.m
new file mode 100644
index 0000000000000000000000000000000000000000..d45a797a96326126d7b2ae82f0db966e69d04c49
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/iscolumnvector.m
@@ -0,0 +1,4 @@
+function result = iscolumnvector(obj)
+import yaml.*;
+result = isvector(obj) && size(obj,2) == 1 && size(obj,1) > 1 && ndims(obj) == 2;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/ismymatrix.m b/Requirements/MEIGO/PEtabMEIGO/yaml/ismymatrix.m
new file mode 100644
index 0000000000000000000000000000000000000000..0e438be232d6ab311dadfd461f1ef2b9b7896e1d
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/ismymatrix.m
@@ -0,0 +1,4 @@
+function result = ismymatrix(obj)
+import yaml.*;
+result = ndims(obj) == 2 && all(size(obj) > 1);
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/isord.m b/Requirements/MEIGO/PEtabMEIGO/yaml/isord.m
new file mode 100644
index 0000000000000000000000000000000000000000..7d1c1e609e28493296609eb4060237328682e81a
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/isord.m
@@ -0,0 +1,4 @@
+function result = isord(obj)
+import yaml.*;
+result = ~iscell(obj) && any(size(obj) > 1);
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/isrowvector.m b/Requirements/MEIGO/PEtabMEIGO/yaml/isrowvector.m
new file mode 100644
index 0000000000000000000000000000000000000000..224988167c6dacf56c6bbbe52c92f97bb04f551c
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/isrowvector.m
@@ -0,0 +1,4 @@
+function result = isrowvector(obj)
+import yaml.*;
+result = isvector(obj) && size(obj,1) == 1 && size(obj,2) > 1 && ndims(obj) == 2;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/issingle.m b/Requirements/MEIGO/PEtabMEIGO/yaml/issingle.m
new file mode 100644
index 0000000000000000000000000000000000000000..4aacc48edc634c119f9f8d4e8100f7732daaca1f
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/issingle.m
@@ -0,0 +1,4 @@
+function result = issingle(obj)
+import yaml.*;
+result = all(size(obj) == 1) ;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/kwd_parent.m b/Requirements/MEIGO/PEtabMEIGO/yaml/kwd_parent.m
new file mode 100644
index 0000000000000000000000000000000000000000..4d2aa3c6d7ad45c003a4b30c811ec6098061f718
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/kwd_parent.m
@@ -0,0 +1,4 @@
+function result = kwd_parent()
+import yaml.*;
+result = 'parent';
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/makematrices.m b/Requirements/MEIGO/PEtabMEIGO/yaml/makematrices.m
new file mode 100644
index 0000000000000000000000000000000000000000..3bea5a8c5712adf7730a96a11c57182d7c02a829
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/makematrices.m
@@ -0,0 +1,103 @@
+function result = makematrices(r, makeords)
+import yaml.*;
+result = recurse(r, 0, [], makeords);
+end
+function result = recurse(data, level, addit, makeords)
+import yaml.*;
+if iscell(data)
+        result = iter_cell(data, level, addit, makeords);
+    elseif isstruct(data)
+        result = iter_struct(data, level, addit, makeords);
+    else
+        result = scan_data(data, level, addit);
+    end;
+end
+function result = iter_cell(data, level, addit, makeords)
+import yaml.*;
+if  isvector(data) &&         iscell_all(data) &&         isvector_all(data) &&         isaligned_all(data) &&         ismatrixrow_all(data)
+        tmp = data;
+        tmp = cellfun(@cell2mat, tmp, 'UniformOutput', 0);
+        tmp = cellfun(@torow, tmp, 'UniformOutput', 0);
+        tmp = tocolumn(tmp);
+        tmp = cell2mat(tmp);
+        if ~makeords
+            tmp = num2cell(tmp);
+        end;
+        result = tmp;
+    elseif isempty(data)
+        result = [];
+    else   
+        result = {};
+        for i = 1:length(data)
+            result{i} = recurse(data{i}, level + 1, addit, makeords);
+        end;
+    end;
+end
+function result = iter_struct(data, level, addit, makeords)
+import yaml.*;
+result = struct();
+    for i = fields(data)'
+        fld = char(i);
+        result.(fld) = recurse(data.(fld), level + 1, addit, makeords);
+    end;
+end
+function result = scan_data(data, level, addit)
+import yaml.*;
+result = data;
+end
+function result = iscell_all(cellvec)
+import yaml.*;
+result = all(cellfun(@iscell, cellvec));
+end
+function result = isaligned_all(cellvec)
+import yaml.*;
+siz = numel(cellvec{1});
+    result = all(cellfun(@numel, cellvec) ==  siz);
+end
+function result = ismatrixrow_all(cellvec)
+import yaml.*;
+result = all(cellfun(@ismatrixrow, cellvec));
+end
+function result = ismatrixrow(cellvec)
+import yaml.*;
+result =         (isnumeric_all(cellvec) || islogical_all(cellvec) || isstruct_all(cellvec)) &&         issingle_all(cellvec) &&         iscompatible_all(cellvec);
+end
+function result = isnumeric_all(cellvec)
+import yaml.*;
+result = all(cellfun(@isnumeric, cellvec));
+end
+function result = islogical_all(cellvec)
+import yaml.*;
+result = all(cellfun(@islogical, cellvec));
+end
+function result = issingle_all(cellvec)
+import yaml.*;
+result = all(cellfun(@issingle, cellvec));
+end
+function result = iscompatible_all(cellvec)
+import yaml.*;
+result = true;
+    for i = 1:(length(cellvec) - 1)
+        result = result && iscompatible(cellvec{i}, cellvec{i + 1});
+    end
+end
+function result = iscompatible(obj1, obj2)
+import yaml.*;
+result = isequal(class(obj1), class(obj2));
+end
+function result = isvector_all(cellvec)
+import yaml.*;
+result = all(cellfun(@isvector, cellvec));
+end
+function result = isstruct_all(cellvec)
+import yaml.*;
+result = all(cellfun(@isstruct, cellvec));
+end
+function result = torow(vec)
+import yaml.*;
+result = tocolumn(vec).';
+end
+function result = tocolumn(vec)
+import yaml.*;
+result = vec(:);
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/merge_struct.m b/Requirements/MEIGO/PEtabMEIGO/yaml/merge_struct.m
new file mode 100644
index 0000000000000000000000000000000000000000..1ee3bc8401a1e129ba00f24f8ba3783a84f8158d
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/merge_struct.m
@@ -0,0 +1,26 @@
+function result = merge_struct(p, s, donotmerge, deep)
+import yaml.*;
+if ~( isstruct(p) && isstruct(s) )
+        error('Only structures can be merged.');
+    end;
+    if ~exist('donotmerge','var')
+        donotmerge = {};
+    end
+    if ~exist('deep','var')
+        deep = 0;
+    elseif strcmp(deep, 'deep')
+        deep = 1;
+    end;
+    result = p;
+    for i = fields(s)'
+        fld = char(i);
+        if any(cellfun(@(x)isequal(x, fld), donotmerge))
+            continue;
+        end;
+        if deep == 1 && isfield(result, fld) && isstruct(result.(fld)) && isstruct(s.(fld))
+            result.(fld) = merge_struct(result.(fld), s.(fld), donotmerge, deep);
+        else
+            result.(fld) = s.(fld);
+        end;
+    end;
+end
diff --git a/Requirements/MEIGO/PEtabMEIGO/yaml/mergeimports.m b/Requirements/MEIGO/PEtabMEIGO/yaml/mergeimports.m
new file mode 100644
index 0000000000000000000000000000000000000000..63643c7520679f62bff98680d8c8fb1938ef8de2
--- /dev/null
+++ b/Requirements/MEIGO/PEtabMEIGO/yaml/mergeimports.m
@@ -0,0 +1,82 @@
+function result = mergeimports(data, verb)
+import yaml.*;
+if ~exist('verb','var')
+        verb = 0;
+    end;
+    result = recurse(data, 0, [], verb);
+end
+function result = recurse(data, level, addit, verb)
+import yaml.*;
+indent = repmat(' | ',1,level); % for debugging
+    if iscell(data)
+        result = iter_cell(data, level, addit, verb);
+    elseif isstruct(data)
+        result = iter_struct(data, level, addit, verb);
+    else
+        if any(verb == 1) % for debugging
+            fprintf([indent,'Some data: ']);
+            disp(data);
+        end;
+        result = data;
+    end;
+end
+function result = iter_cell(data, level, addit, verb)
+import yaml.*;
+indent = repmat(' | ',1,level); % for debugging
+    result = {};
+    if any(verb == 1); fprintf([indent,'cell {\n']); end; % for debugging
+    for i = 1:length(data)
+        itemcontent = recurse(data{i}, level + 1, addit, verb);
+        result{end + 1} = itemcontent;
+    end;
+    if any(verb == 1); fprintf([indent,'} cell\n']); end; % for debugging
+end
+function result = iter_struct(data, level, addit, verb)
+import yaml.*;
+indent = repmat(' | ',1,level); % for debugging
+    result = struct();
+    collected_imports = {};
+    if any(verb == 1); fprintf([indent,'struct {\n']); end; % for debugging
+    for i = fields(data)'
+        fld = char(i);
+        if any(verb == 1); fprintf([indent,' +-field ',fld,':\n']); end; % for debugging
+        result.(fld) = recurse(data.(fld), level + 1, addit, verb);
+        if isequal(fld, 'import')
+            processed_import = process_import_field(result.(fld));
+            result = rmfield(result, 'import');
+            if isstruct(processed_import)
+                collected_imports{end+1} = processed_import;
+            else
+                disp(processed_import);
+                error('Expected struct, otherwise it cannot be merged with the rest.');
+            end;
+        end;
+    end;
+    for i = 1:length(collected_imports)
+        result = merge_struct(result, collected_imports{i}, {}, 'deep');
+    end;
+    if any(verb == 1); fprintf([indent,'} struct\n']); end; % for debugging
+end
+function result = process_import_field(data)
+import yaml.*;
+if iscell(data)
+        merged_structs = struct();
+        collected_nonstruct = {};
+        for i = 1:length(data)
+            if isstruct(data{i})
+                merged_structs = merge_struct(merged_structs, data{i}, {}, 'deep');
+            else
+                collected_nonstruct{end+1} = data{i};
+            end;
+        end;
+        if isempty(collected_nonstruct)
+            result = merged_structs;
+        elseif isempty(merged_structs)
+            result = collected_nonstruct;
+        else
+            result = {merged_structs; collected_nonstruct};
+        end;
+    else
+        error('BUG: import field should always contain a cell.');
+    end;
+end
diff --git a/Requirements/MEIGO/VNS/CeVNS.m b/Requirements/MEIGO/VNS/CeVNS.m
new file mode 100644
index 0000000000000000000000000000000000000000..95211ca5863b6bc43f771274680bb7e2f01ed465
--- /dev/null
+++ b/Requirements/MEIGO/VNS/CeVNS.m
@@ -0,0 +1,105 @@
+function Results = CeVNS(par_struct,n_iter,is_parallel)
+
+	n_threads=length(par_struct);
+	
+	Results=[];
+	f=[];
+	x=[];
+	temp_f=[];
+	Results.results_iter={};
+	
+	numeval=0;
+	neval=0;
+	time=0;
+
+	Nrunsmat(1,1,1:n_threads) = 1:n_threads; 
+
+	for iteration = 1:n_iter   
+		
+		tstart = tic;
+		
+		%results_iter=[];
+		
+%%%%%%%%%%%%JRB-Lukas -- With Matlab Parallel Computing Toolbox:  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+		if(is_parallel)
+            parfor thread=1:n_threads
+                results_iter(thread) = CeVNS_thread(par_struct, thread);
+            end
+			%results_iter = jpar_client('CeVNS_thread', par_struct, Nrunsmat);
+
+		%Don't use parallel computing, useful for debugging.	
+		else
+		
+			for thread=1:n_threads
+				
+                res=rvnds_hamming(...
+                    par_struct(thread).problem,...
+                    par_struct(thread).opts);
+
+				results_iter(thread).f=res.func;
+				results_iter(thread).time=res.time;
+				results_iter(thread).neval=res.neval;
+				results_iter(thread).numeval=res.numeval;
+				results_iter(thread).cpu_time=res.cpu_time;
+				results_iter(thread).fbest=res.fbest;
+				results_iter(thread).xbest=res.xbest;
+				
+			end
+			
+		end
+		
+		%Store the results from all threads in this iteration
+		Results.results_iter{iteration}=results_iter;
+		
+		x_0=[];
+		f_0=[];
+		
+		%concatenate all refsets and best solutions found
+		for thread=1:n_threads
+			x_0=[x_0;results_iter(thread).xbest];
+			f_0=[f_0;results_iter(thread).fbest];
+			if(iteration==1)
+				temp_f=[temp_f results_iter(thread).f(1)];
+			end
+			numeval=numeval+results_iter(thread).numeval;
+		end
+		
+		%Measure the duration of the iteration
+		time=[time toc(tstart)];
+		%Get an initial solution
+		if(iteration==1)
+			f=[f min(temp_f)];
+			%fi is the index of thread with best val
+			fi=find(min(temp_f));
+			x=[x;par_struct(fi(1)).problem.x_0];
+		end
+		
+		%Remove repeated elements from x_0 and f_0
+		[C ia ic]=unique(x_0,'rows');
+		x_0=x_0(sort(ia),:);
+		f_0=f_0(sort(ia));
+		
+		fbest=min(f_0);
+		xbest=x_0(find(f_0==fbest),:);
+
+		%Assign all refsets as initial solution
+		for thread=1:n_threads
+			par_struct(thread).problem.x_0=xbest(1,:);
+			par_struct(thread).problem.f_0=fbest(1);
+		end
+		
+		f=[f; fbest(1)];
+		x=[x; xbest(1,:)];
+		neval=[neval; numeval];
+		
+	end
+
+	Results.xbest=xbest;
+	Results.fbest=fbest;
+	Results.f=f;
+	Results.x=x;
+	Results.time=time;
+	Results.neval=neval;
+	Results.numeval=numeval;
+
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/VNS/CeVNS_thread.m b/Requirements/MEIGO/VNS/CeVNS_thread.m
new file mode 100644
index 0000000000000000000000000000000000000000..206661efa4748e35580be30bb9e23687355c71ca
--- /dev/null
+++ b/Requirements/MEIGO/VNS/CeVNS_thread.m
@@ -0,0 +1,22 @@
+function Results = CeVNS_thread(par_struct,Nruns)
+	
+    Results=[];
+		
+	%Reset the random seed.
+	randstate = 1e3*Nruns+ sum(100*clock);
+	rand('state',randstate);
+	randn('state',randstate);
+	
+	 res=rvnds_hamming(...
+        par_struct(Nruns).problem,...
+        par_struct(Nruns).opts);
+			
+	Results.f=res.func;
+	Results.time=res.time;
+	Results.neval=res.neval;
+	Results.numeval=res.numeval;
+	Results.cpu_time=res.cpu_time;
+	Results.fbest=res.fbest;
+	Results.xbest=res.xbest;
+		
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/VNS/get_CeVNS_options.m b/Requirements/MEIGO/VNS/get_CeVNS_options.m
new file mode 100644
index 0000000000000000000000000000000000000000..a28738c050a7debb3ee36aec2df2199f67de6c0e
--- /dev/null
+++ b/Requirements/MEIGO/VNS/get_CeVNS_options.m
@@ -0,0 +1,61 @@
+function par_struct = get_Cess_options(n_threads, npars, maxtime_per_iteration)
+	
+	%--- Problem definition: --------------------------------------------------
+	problem=[];
+	problem.x_L = [];
+	problem.x_U = [];
+	problem.x_0 = [];
+	problem.f  = '';
+	
+	%With use_local=0, the other parameters do not apply  
+	use_local1 = 0;    aggr1 = 1;   local_search1 = 1;   decomp1 = 0;       
+	use_local2 = 1;    aggr2 = 1;   local_search2 = 1;   decomp2 = 0;       
+	use_local3 = 1;    aggr3 = 1;   local_search3 = 1;   decomp3 = 1;       
+	use_local4 = 1;    aggr4 = 1;   local_search4 = 2;   decomp4 = 0;       
+	use_local5 = 1;    aggr5 = 1;   local_search5 = 2;   decomp5 = 1;       
+	use_local6 = 1;    aggr6 = 0;   local_search6 = 1;   decomp6 = 0;       
+	use_local7 = 1;    aggr7 = 0;   local_search7 = 1;   decomp7 = 1;       
+	use_local8 = 1;    aggr8 = 0;   local_search8 = 2;   decomp8 = 0;       
+	use_local9 = 1;    aggr9 = 0;   local_search9 = 2;   decomp9 = 1;       
+    %Repeat the first option. Here use should repeat the most efficient
+	use_local10 = 0;    aggr10 = 1;   local_search10 = 1;   decomp10 = 0;
+	
+	opts_use_local=[use_local1 use_local2 use_local3...
+					use_local4 use_local5 use_local6...
+					use_local7 use_local8 use_local9...
+					use_local10];
+					
+	opts_aggr=[aggr1 aggr3 aggr3 aggr4 aggr5 aggr6 aggr7 aggr8 aggr9 aggr10];
+	
+	opts_local_search= [local_search1 local_search2 local_search3...
+						local_search4 local_search5 local_search6...
+						local_search7 local_search8 local_search9... 
+						local_search10];
+						
+	opts_decomp=[decomp1 	decomp2 	decomp3...
+				 decomp4 	decomp5 	decomp6...
+				 decomp7 	decomp8 	decomp9...
+				 decomp10];
+				 
+	i=0;
+	counter=0;
+	while(i<n_threads)
+		i=i+1;
+		counter=counter+1;
+		par_struct(i).problem=problem;
+		par_struct(i).opts.use_local=opts_use_local(counter);
+		par_struct(i).opts.aggr=opts_aggr(counter);
+		par_struct(i).opts.maxtime=maxtime_per_iteration;
+        
+		par_struct(i).opts.local_search_type=opts_local_search(counter);
+		par_struct(i).opts.decomp=opts_decomp(counter);
+		par_struct(i).opts.maxeval=Inf;
+		
+		%If there are more than 10 threads or is a multiple of 10
+		%start recycling options or restart counter
+		if(counter==0)
+			counter=0;
+		end
+	end
+	
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/VNS/run_CeVNS.m b/Requirements/MEIGO/VNS/run_CeVNS.m
new file mode 100644
index 0000000000000000000000000000000000000000..0b9bda135ea4a1415da26de3514727d1cae67e00
--- /dev/null
+++ b/Requirements/MEIGO/VNS/run_CeVNS.m
@@ -0,0 +1,25 @@
+% Optimization settings:
+nthreads    = 2;            % number of threads
+n_iter      = 2;            % number of cooperative iterations
+is_parallel = true;         % parallel (true) or sequential (false)
+maxtime_per_iteration = 10; % time limit for each iteration
+
+% Number of parameters; bounds; and initial point:
+npars = 50;
+x_L   =-5*ones(1,npars);
+x_U   = 5*ones(1,npars);
+x_0   = round(rand(1,npars).*(x_U-x_L+1)+x_L-0.5);
+
+% Read default optimization settings:
+par_struct=get_CeVNS_options(nthreads,npars,maxtime_per_iteration);
+
+% Overwrite the following default options in par_struct:
+for i=1:nthreads		
+	par_struct(i).problem.f   = 'rosen10';
+	par_struct(i).problem.x_L = x_L;
+	par_struct(i).problem.x_U = x_U;
+	par_struct(i).problem.x_0 = x_0;	
+end
+
+% Run CeVNS:
+Results = CeVNS(par_struct,n_iter,is_parallel)
diff --git a/Requirements/MEIGO/VNS/rvnds_hamming.m b/Requirements/MEIGO/VNS/rvnds_hamming.m
new file mode 100644
index 0000000000000000000000000000000000000000..7f861a34bc4bc05c21beda7853901d11fbd79b0c
--- /dev/null
+++ b/Requirements/MEIGO/VNS/rvnds_hamming.m
@@ -0,0 +1,199 @@
+function [Results]=rvnds_hamming(problem,opts,varargin);
+
+if not(isfield(opts,'maxeval')) & not(isfield(opts,'maxtime'))
+    fprintf('WARNING:Either opts.maxeval or opts.maxtime must be defined as a stop criterion \n')
+    fprintf('Define any of these options and rerun \n')
+    Results=[];
+    return
+else
+    if not(isfield(opts,'maxeval'))
+        maxeval=1e12;
+    else
+        maxeval=opts.maxeval;
+    end
+    if not(isfield(opts,'maxtime'))
+        maxtime=1e12;
+    else
+        maxtime=opts.maxtime;
+    end
+end
+
+
+%Initialize time
+cpu_time=cputime;
+
+%Load default values for the options
+default=vns_defaults;
+
+if nargin<2, opts=[]; end
+
+%Set all options
+opts=vns_optset(default,opts);
+
+
+%Set all optiions
+opts=vns_optset(default,opts);
+    
+maxdist=opts.maxdist;
+use_local=opts.use_local;
+aggr=opts.aggr;
+local_search_type=opts.local_search_type;
+decomp=opts.decomp;
+ 
+fobj=problem.f;
+x_U=problem.x_U;
+x_L=problem.x_L;
+
+
+%Check if bounds have the same dimension
+if length(x_U)~=length(x_L)
+    disp('Upper and lower bounds have different dimension!!!!')
+    disp('EXITING')
+    Results=[];
+    return
+else
+    %Number of decision variables
+    nvar=length(x_L);
+end
+
+if not(isfield(problem,'x_0')), x0=round(rand(1,nvar).*(x_U-x_L+1)+(x_L-0.5)); else, x0=problem.x_0; end
+
+xcurrent=x0;
+xbest=x0;
+
+fbest=feval(fobj,x0,varargin{:});
+nfuneval=1;
+fcurrent=fbest;
+
+fprintf('Init. point: Bestf: %g      CPUTime: %f\n',fbest,cputime-cpu_time);
+
+Results.fbest=fbest;
+Results.xbest=x0;
+Results.func=fbest;
+Results.time=cputime-cpu_time;
+Results.neval=1;
+Results.numeval=1;
+Results.x=xbest;
+
+
+%Initial neighborhood is k=1
+kcurrent=1;
+
+%Maximum neighborhood
+kmax=floor(maxdist*nvar);
+
+ %Perturb at least one dimension
+ if not(kmax), kmax=1; end
+
+improve=0;
+
+while 1
+     xnew=xcurrent;
+     rand_var=randperm(nvar);
+     shaked_vars=rand_var(1:kcurrent);
+    for i=1:kcurrent
+        continuar=0;
+        while ~continuar
+            xnew(shaked_vars(i))=round(rand*(x_U(shaked_vars(i))-...
+                x_L(shaked_vars(i))+1)+(x_L(shaked_vars(i))-0.5));
+            if xnew(shaked_vars(i))~=xcurrent(shaked_vars(i));
+                continuar=1;
+            end
+        end
+    end
+    
+    fnew=feval(fobj,xnew,varargin{:});
+    
+    nfuneval=nfuneval+1;
+    
+    
+    if fnew<fbest
+        fbest=fnew;
+        xbest=xnew;
+        xcurrent=xnew;
+        fcurrent=fnew;
+        improve=1;
+        Results.func=[Results.func; fbest];
+        Results.time=[Results.time; cputime-cpu_time];
+        Results.neval=[Results.neval; nfuneval];
+		Results.x=[Results.x;xbest];
+    end
+    
+    if nfuneval>=maxeval | (cputime-cpu_time)>=maxtime
+        
+				fprintf('NFunEvals: %i  Bestf: %g      CPUTime: %f   \n',...
+            nfuneval,fbest,cputime-cpu_time);
+        fprintf('************************* \n')
+        fprintf('END OF THE OPTIMIZATION \n')
+        fprintf('Best solution value\t\t%g\n', fbest);
+        fprintf('Decision vector\n');
+        fprintf('\t%g\n', xbest');
+        fprintf('CPU time\t\t%g\n', cputime-cpu_time);
+        fprintf('Number of function evaluations\t\t%g\n\n', nfuneval);
+        
+        Results.xbest=xbest;
+        Results.fbest=fbest;
+        Results.func=[Results.func; fbest];
+        Results.time=[Results.time; cputime-cpu_time];
+        Results.neval=[Results.neval; nfuneval];
+		Results.x=[Results.x;xbest];
+        Results.numeval=nfuneval;
+        Results.cpu_time=cputime-cpu_time;
+        
+		% save Results in a file  
+		save VNS_report.mat Results problem opts  
+        return
+    end
+       
+    %Start the local phase 
+    if use_local
+        if ~aggr
+		%In the non-aggressive scheme we apply local search over the new point even if it does no outperformed xbest
+            f0=fnew;
+            x0=xnew;
+        elseif aggr & improve
+            f0=fcurrent;
+            x0=xcurrent;
+        end
+        
+        if ~aggr | improve
+		%In the aggressive scheme, it does not make sense to use the local search if xnew did not improve xbest
+            % tic
+             % fprintf('\nLOCAL SEARCH: Initial point function value: %g \n',...
+                 % f0);
+             [xout,fout,improve_local,evals_local,Results]=rvnds_local(x0,f0,...
+                 fobj,x_L,x_U,local_search_type,shaked_vars,decomp,nvar,...
+                 maxeval,maxtime,cpu_time,fbest,xbest,nfuneval, Results, varargin{:});
+             % fprintf('Local solution function value: %g \n', fout);
+             % fprintf('Number of function evaluations: %i \n', evals_local);
+             % fprintf('Computation time: %f \n\n', toc);
+             
+            nfuneval=nfuneval+evals_local;
+            if improve_local==2 %This means that the local search improved 
+                                %the best value
+                improve=1;
+                xbest=xout;
+                fbest=fout;
+            end
+        end
+    end
+    
+    
+    if improve
+        improve=0;
+        xcurrent=xbest;
+        fcurrent=fbest;
+        kcurrent=1;
+        
+        if ~use_local | improve_local<2
+            fprintf('NFunEvals: %i  Bestf: %g      CPUTime: %f   \n',...
+                nfuneval,fbest,cputime-cpu_time);
+        end
+        
+    else
+        kcurrent=kcurrent+1;
+        if kcurrent>kmax
+            kcurrent=1;
+        end
+    end
+end
diff --git a/Requirements/MEIGO/VNS/rvnds_local.m b/Requirements/MEIGO/VNS/rvnds_local.m
new file mode 100644
index 0000000000000000000000000000000000000000..99037e3001b34d540adc4cda7393c848a94d1d5f
--- /dev/null
+++ b/Requirements/MEIGO/VNS/rvnds_local.m
@@ -0,0 +1,164 @@
+function [xout,fout,improve,evals_local, Results]=rvnds_local(x0,f0,fobj,x_L,x_U,search_type,shaked_vars,decomp,nvar,maxevals,maxtime,cpu_time,fbest,xbest,nfuneval, Results, varargin)
+
+evals_local=0;
+last_var_used=0;
+
+fin=0;
+
+xcurrloc=x0;
+fcurrloc=f0;
+
+if decomp
+    u_vars=shaked_vars;     
+    n_u_vars=numel(shaked_vars);
+else
+    u_vars=1:nvar;
+    n_u_vars=nvar;
+end
+
+improve_solution=0;
+
+while ~fin
+    x_improvements=[];
+    f_improvements=[];
+    vars_improving=[];
+    exit_local=0;
+
+    possible_directions=repmat([-1 1],n_u_vars,1);
+
+
+    %Find variables touching bounds
+    aaa=find(xcurrloc(u_vars)==x_L(u_vars));
+    bbb=find(xcurrloc(u_vars)==x_U(u_vars));
+
+    %Adjust the possible directions. i.e., variables touching bounds
+    %can only go in one direction
+    possible_directions(aaa,1)=0;
+    possible_directions(bbb,2)=0;
+
+    %Choose the order of the variables to explore randomly
+    ccc=randperm(n_u_vars);
+    possible_directions=possible_directions(ccc,:);
+
+    local_improvement=0;
+    for i=1:n_u_vars
+        if u_vars(ccc(i))~=last_var_used
+            for j=1:2   %2 possible directions: +1 and -1 in the best case
+                exit_local=0;       %This has to be here or 1 level up???
+                if possible_directions(i,j)     %If we can move to that direction
+                    xtemp=xcurrloc;
+                    xtemp(u_vars(ccc(i)))=xcurrloc(u_vars(ccc(i)))+possible_directions(i,j);
+                    ftemp=feval(fobj,xtemp, varargin{:});
+                    evals_local=evals_local+1;
+					
+                    if ftemp<fcurrloc
+						local_improvement=1;
+						improve_solution=max(improve_solution,1);  %Avoid improve_solution=1 if it was =2 previously. This can only happen in best improvement
+
+                        if ftemp<fbest;
+                            fbest=ftemp;
+                            xbest=xtemp;
+                            improve_solution=2;
+							
+							Results.xbest=xbest;
+							Results.fbest=fbest;
+							Results.func=[Results.func; fbest];
+							Results.x=[Results.x;xbest];
+							Results.time=[Results.time; cputime-cpu_time];
+							Results.neval=[Results.neval; nfuneval+evals_local];
+							Results.numeval=nfuneval+evals_local;
+							Results.cpu_time=cputime-cpu_time;
+							
+							fprintf('NFunEvals: %i  Bestf: %g      CPUTime: %f   \n',nfuneval+evals_local,fbest,cputime-cpu_time);
+                        end
+
+
+
+                        %%go beyond
+                        parar=0;
+                        while ~parar
+                            if xtemp(u_vars(ccc(i)))==x_L(u_vars(ccc(i))) | xtemp(u_vars(ccc(i)))==x_U(u_vars(ccc(i)))
+                                %touching bounds!!!
+                                parar=1;
+                            else
+                                %Continue searching in the same direction
+                                xtemp2=xtemp;
+                                xtemp2(u_vars(ccc(i)))=xtemp(u_vars(ccc(i)))+possible_directions(i,j);
+                                ftemp2=feval(fobj,xtemp2,varargin{:});
+                                evals_local=evals_local+1;
+                                if ftemp2<fbest;
+                                    fbest=ftemp2;
+                                    xbest=xtemp2;
+                                    improve_solution=2;
+									Results.xbest=xbest;
+									Results.fbest=fbest;
+									Results.func=[Results.func; fbest];
+									Results.x=[Results.x;xbest];
+									Results.time=[Results.time; cputime-cpu_time];
+									Results.neval=[Results.neval; nfuneval+evals_local];
+									Results.numeval=nfuneval+evals_local;
+									Results.cpu_time=cputime-cpu_time;
+                                    fprintf('NFunEvals: %i  Bestf: %g      CPUTime: %f   \n',nfuneval+evals_local,fbest,cputime-cpu_time);
+                                end
+
+                                if ftemp2<ftemp
+                                    xtemp=xtemp2;
+                                    ftemp=ftemp2;
+                                else
+                                    parar=1;
+
+                                end
+                            end
+                        end
+                        %end of go beyond
+
+                        if search_type==1 %First improvement
+                            xcurrloc=xtemp;
+                            fcurrloc=ftemp;
+                            last_var_used=u_vars(ccc(i));
+                            exit_local=1;
+                            %                             pause
+
+                            break       %VER SI ESTE BREAK SALE DE LOS DOS FOR
+                        else %Best improvement
+                            x_improvements=[x_improvements;xtemp];
+                            f_improvements=[f_improvements;ftemp];
+                            vars_improving=[vars_improving;u_vars(ccc(i))];
+                        end
+                    end
+
+                    if (nfuneval+evals_local)>=maxevals | cputime-cpu_time>=maxtime
+                        improve=improve_solution;
+                        if search_type==2 & local_improvement
+                            [best_child,iii]=min(f_improvements);
+                            xout=x_improvements(iii,:);
+                            fout=best_child;
+                        else 
+                            xout=xcurrloc;
+                            fout=fcurrloc;
+                        end
+                        return
+                    end
+                end
+            end
+            if exit_local,  break; end
+        end
+    end
+ 
+    if ~local_improvement, fin=1; end       %Get out if the local search did not improve the current solution
+
+    if local_improvement & search_type==2 %Once we got out from the 2nd for loop, we check if we explore all the possible u_vars
+        [best_child,iii]=min(f_improvements);
+        xcurrloc=x_improvements(iii,:);
+        fcurrloc=best_child;
+        last_var_used=vars_improving(iii);
+    end
+end
+
+xout=xcurrloc;
+fout=fcurrloc;
+
+improve=improve_solution;
+
+
+
diff --git a/Requirements/MEIGO/VNS/untitled.m b/Requirements/MEIGO/VNS/untitled.m
new file mode 100644
index 0000000000000000000000000000000000000000..4e403355df16174ece2a65213b08d8fa2e01c8c2
--- /dev/null
+++ b/Requirements/MEIGO/VNS/untitled.m
@@ -0,0 +1,11 @@
+%A�adir c_L y c_U en los inputs despues de fobj, en la primera linea
+
+%Al principio
+
+n_out_f=nargout(problem.f);
+if n_out==2
+    constrained=1;
+else
+    constrained=0;
+end
+
diff --git a/Requirements/MEIGO/VNS/vns_defaults.m b/Requirements/MEIGO/VNS/vns_defaults.m
new file mode 100644
index 0000000000000000000000000000000000000000..236726900b206e502dfac7dacdf1dd67c59bf804
--- /dev/null
+++ b/Requirements/MEIGO/VNS/vns_defaults.m
@@ -0,0 +1,15 @@
+function [default]=vns_defaults
+
+%Assings default values for all the options
+default.maxeval                   =       1000;            %Maximum number of function evaluations
+default.maxtime                   =       60;              %Maximum CPU time
+default.maxdist                   =       0.5;             %Percentage of the problem dimension which will be perturbed in the furthest neighborhood (vary between 0-1)
+default.use_local                 =       1;               %Uses local search (1) or not (0)
+
+%The following options only apply if use_local is active
+default.aggr                      =       0;               %Aggressive search. The local search is only applied when the best solution has been improved (1=aggressive search, 0=non-aggressive search)
+default.local_search_type         =       1;               %Applies a first (=1) or a best (=2) improvement scheme for the local search
+default.decomp                    =       1;               %Decompose the local search (=1) using only the variables perturbed in the global phase
+
+
+
diff --git a/Requirements/MEIGO/VNS/vns_env.m b/Requirements/MEIGO/VNS/vns_env.m
new file mode 100644
index 0000000000000000000000000000000000000000..b27c42b13d0eab6fd4fa652c5e075b86750f8573
--- /dev/null
+++ b/Requirements/MEIGO/VNS/vns_env.m
@@ -0,0 +1,21 @@
+function [f]=vns_env(x,y)
+
+global cl cu ncu ncl fobj
+
+if ~isempty(cu)
+    [f,c]=feval(fobj,x);
+    
+    if size(c,2)==1;
+        c=c';
+    end
+    
+    temp1=c(ncu)-cu(ncu);
+    temp2=cl(ncl)-c(ncl);
+
+    temp1(temp1<0)=0;
+    temp2(temp2<0)=0;
+
+    f=f+1e6*(sum(temp1)+sum(temp2));
+else
+    [f]=feval(fobj,x);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/VNS/vns_optset.m b/Requirements/MEIGO/VNS/vns_optset.m
new file mode 100644
index 0000000000000000000000000000000000000000..8a373bb144679b8ec7f63e016e3d067cc48ad222
--- /dev/null
+++ b/Requirements/MEIGO/VNS/vns_optset.m
@@ -0,0 +1,19 @@
+function [opts] = vns_optset(default,opts)
+
+if not(isempty(opts));
+    opt_names=fieldnames(opts);
+    default_names=fieldnames(default);
+    
+    low_opt_names = lower(opt_names);
+    low_default_names = lower(default_names);
+
+    for i=1:length(opt_names)
+        j = strmatch(low_opt_names{i,:},low_default_names,'exact');
+        if isempty(j)
+            error(sprintf(['Unrecognized field name %s'], opt_names{i,:}));
+        end
+        value = opts.(opt_names{i,:});
+        default.(default_names{j,:}) = value;
+    end
+end
+opts=default;
diff --git a/Requirements/MEIGO/eSS/CeSS.m b/Requirements/MEIGO/eSS/CeSS.m
new file mode 100644
index 0000000000000000000000000000000000000000..06464331c3b90884a27616caedf05b8176b2eba9
--- /dev/null
+++ b/Requirements/MEIGO/eSS/CeSS.m
@@ -0,0 +1,112 @@
+function Results = CeSS(problem,opts)
+
+    %--- Read options, initialize variables: ------------------------------
+    par_struct = get_CeSS_options(problem,opts);
+ 	n_threads  = length(par_struct);	
+	Results    = [];
+	f          = [];
+	x          = [];
+	temp_f     = [];	    
+	numeval    = 0;
+	neval      = 0;
+	time       = 0;    
+    Results.results_iter = {};
+
+    %--- Perform iterations: ----------------------------------------------
+	for iteration = 1:opts.n_iter   		
+		tstart = tic;		
+		if(opts.is_parallel) % With parallel computing:
+            %-- JRB-Lukas -- With Matlab Parallel Computing Toolbox:  -----
+            myPOOL = parpool('local',n_threads);
+			parfor thread = 1:n_threads
+                results_iter(thread) = CeSS_thread(par_struct,thread);
+            end  
+            delete(myPOOL)
+            %-- With JPAR: ------------------------------------------------
+            % Nrunsmat(1,1,1:n_threads) = 1:n_threads;
+            % results_iter = jpar_client('CeSS_thread', par_struct, Nrunsmat);
+            %-- Distributed computation in cluster: -----------
+			% (NEEDS MATLAB DISTRIBUTED COMPUTING SERVER)
+            % ...
+        else % Without parallel computing (useful for debugging):	
+			for thread = 1:n_threads			
+				res = ess_kernel(par_struct(thread).problem, par_struct(thread).opts);
+				results_iter(thread).x=res.x;
+				results_iter(thread).f=res.f;
+				results_iter(thread).time=res.time;
+				results_iter(thread).refset_x=res.Refset.x;
+				results_iter(thread).refset_f=res.Refset.f;
+				results_iter(thread).neval=res.neval;
+				results_iter(thread).numeval=res.numeval;
+				results_iter(thread).cpu_time=res.cpu_time;
+				results_iter(thread).fbest=res.fbest;
+				results_iter(thread).xbest=res.xbest;				
+            end			
+        end		
+		% Store the results from all threads in this iteration
+		Results.results_iter{iteration} = results_iter;
+		% Concatenate all refsets and best solutions found
+        x_0 = [];
+		f_0 = [];
+		for thread=1:n_threads
+			x_0 = [x_0;results_iter(thread).refset_x;results_iter(thread).xbest];
+			f_0 = [f_0;results_iter(thread).refset_f;results_iter(thread).fbest];
+			if(iteration==1)
+				temp_f = [temp_f results_iter(thread).f(1)];
+			end
+			numeval = numeval+results_iter(thread).numeval;
+        end		
+		% Measure the duration of the iteration
+		time = [time toc(tstart)];		
+        % Get an initial solution
+		if(iteration==1)
+			f  = [f min(temp_f)];
+			fi = find(min(temp_f));
+			x  = [x;results_iter(fi(1)).x(1,:)];
+        end		
+		% Remove repeated elements from x_0 and f_0
+		[C ia ic] = unique(x_0,'rows');
+		x_0       = x_0(sort(ia),:);
+		f_0       = f_0(sort(ia));		
+		% Assign all refsets as initial solution
+		for thread = 1:n_threads
+			par_struct(thread).problem.x_0 = x_0;
+			par_struct(thread).problem.f_0 = f_0';
+        end		
+		fbest = min(f_0);
+		xbest = x_0(find(f_0==fbest),:);		
+		f     = [f; fbest(1)];
+		x     = [x; xbest(1,:)];
+		neval = [neval; numeval];		
+    end
+
+    %--- Put all the results together: ------------------------------------
+    total_vals = [0; f(1)];
+    for j = 1:opts.n_iter
+        t_vals = [];
+        f_vals = [];
+        for k = 1:n_threads            
+            t_vals = [t_vals time(j)+Results.results_iter{j}(k).time];
+            f_vals = [f_vals Results.results_iter{j}(k).f];
+        end
+        total_vals_thread = [t_vals; f_vals];
+        total_vals = [total_vals total_vals_thread];       
+    end    
+    [Times,I] = sort(total_vals(1,:));
+    Values    = total_vals(2,I);
+    Final     = [Times(1);Values(1)];
+    for m = 2:size(Values,2)    
+        if Values(m) <= Final(2,size(Final,2))
+            Final = [Final [Times(m); Values(m)] ];
+        end    
+    end    
+    Results.xbest     = xbest;
+	Results.fbest     = fbest;
+    Results.f_iter    = f;
+	Results.x_iter    = x;
+    Results.time_iter = time;
+	Results.time    = Final(1,:);
+    Results.f       = Final(2,:);
+	Results.neval   = neval;
+	Results.numeval = numeval;
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/CeSS_thread.m b/Requirements/MEIGO/eSS/CeSS_thread.m
new file mode 100644
index 0000000000000000000000000000000000000000..f484562401960fb2bd1b1131fc763907cf020cbb
--- /dev/null
+++ b/Requirements/MEIGO/eSS/CeSS_thread.m
@@ -0,0 +1,27 @@
+function Results = CeSS_thread(par_struct,Nruns)
+
+    %Pass ess options to ess_kernel:
+    ess_options = []; 
+    ess_options.ndiverse   = par_struct(Nruns).opts.ndiverse;
+    ess_options.maxtime    = par_struct(Nruns).opts.maxtime_cess;
+    ess_options.maxeval    = par_struct(Nruns).opts.maxeval;
+    ess_options.log_var    = par_struct(Nruns).opts.log_var;
+    ess_options.local      = par_struct(Nruns).opts.local;
+    ess_options.dim_refset = par_struct(Nruns).opts.dim_refset;
+    
+    %Run optimization:
+    res = ess_kernel(par_struct(Nruns).problem,ess_options);
+
+    %Store results:
+    Results.x        = res.x;
+    Results.f        = res.f;
+    Results.refset_x = res.Refset.x;
+    Results.refset_f = res.Refset.f;
+    Results.neval    = res.neval;
+    Results.numeval  = res.numeval;
+    Results.cpu_time = res.cpu_time;
+    Results.fbest    = res.fbest;
+    Results.xbest    = res.xbest;
+    Results.time     = res.time;
+		
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/datafiles/f01_o.mat b/Requirements/MEIGO/eSS/datafiles/f01_o.mat
new file mode 100644
index 0000000000000000000000000000000000000000..95103f808da334ba52037d53f4ca9d891fdc4b97
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f01_o.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f02_o.mat b/Requirements/MEIGO/eSS/datafiles/f02_o.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9ac9cfeb09176c8cf5cf8424569b0e0482f6a167
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f02_o.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f03_o.mat b/Requirements/MEIGO/eSS/datafiles/f03_o.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c76ca86fc66e5b5d92157a36b4874e3804e1c18c
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f03_o.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f04_opm.mat b/Requirements/MEIGO/eSS/datafiles/f04_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c2bf4ade951bb2dd7bdc9771f463110017366abf
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f04_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f05_opm.mat b/Requirements/MEIGO/eSS/datafiles/f05_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..059b8e22ffd6af5cae9ba2de9769bc0a53cb13a4
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f05_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f06_opm.mat b/Requirements/MEIGO/eSS/datafiles/f06_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..586b538ee2c85f827a4078051e67db67e00e17cf
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f06_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f07_op.mat b/Requirements/MEIGO/eSS/datafiles/f07_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..57f89a08eeca9b42467a9e97cdf81d13a6e54222
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f07_op.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f08_op.mat b/Requirements/MEIGO/eSS/datafiles/f08_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..423790eb87431795dd81c282a3fd263a3952fe1c
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f08_op.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f09_opm.mat b/Requirements/MEIGO/eSS/datafiles/f09_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f1f50a6ea48bd1b5ba7775ba3f498fbe58655e2b
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f09_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f10_opm.mat b/Requirements/MEIGO/eSS/datafiles/f10_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..602667869cc86835a577480470a58f84205dfff4
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f10_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f11_opm.mat b/Requirements/MEIGO/eSS/datafiles/f11_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f111eb57d08475277b305b8e2de0181496148139
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f11_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f12_op.mat b/Requirements/MEIGO/eSS/datafiles/f12_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..4b6c57c778a124603d0036adb5e4256934062168
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f12_op.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f13_op.mat b/Requirements/MEIGO/eSS/datafiles/f13_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..1fe74091578dd5eeb6f7867bf4284d9bef94331a
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f13_op.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f14_opm.mat b/Requirements/MEIGO/eSS/datafiles/f14_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8fd2c5937ecc07c69290a4ea98753724fdc685e4
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f14_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f15_opm.mat b/Requirements/MEIGO/eSS/datafiles/f15_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..10671d4009210b592717a133bb6009a95bec3313
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f15_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f16_opm.mat b/Requirements/MEIGO/eSS/datafiles/f16_opm.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c78f93afd9178971a79b5442922d135cd100c8bc
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f16_opm.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f17_op.mat b/Requirements/MEIGO/eSS/datafiles/f17_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..44312680dd1ad956de850bae24ae663b6b0cb512
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f17_op.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f18_op.mat b/Requirements/MEIGO/eSS/datafiles/f18_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..97bdc23cdb6e738132ea8839eb671b09e4f6a5a9
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f18_op.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f19_o.mat b/Requirements/MEIGO/eSS/datafiles/f19_o.mat
new file mode 100644
index 0000000000000000000000000000000000000000..6383a9083f8b7119eb1572860ddea1efa6776207
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f19_o.mat differ
diff --git a/Requirements/MEIGO/eSS/datafiles/f20_o.mat b/Requirements/MEIGO/eSS/datafiles/f20_o.mat
new file mode 100644
index 0000000000000000000000000000000000000000..470f1b6f67f637634dc4598f6a99da69f3647e7f
Binary files /dev/null and b/Requirements/MEIGO/eSS/datafiles/f20_o.mat differ
diff --git a/Requirements/MEIGO/eSS/ess_aux_local_checkfiles.m b/Requirements/MEIGO/eSS/ess_aux_local_checkfiles.m
new file mode 100644
index 0000000000000000000000000000000000000000..a8bbe4a190b6715ee1b9bbb8ac18332e7f35a153
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ess_aux_local_checkfiles.m
@@ -0,0 +1,38 @@
+function flag = ess_aux_local_checkfiles(filename, objname)
+% tests that filename exists in the current folder and contains objname in
+% the correct position by regular expression.
+% filename is the name of the file the local solver will call
+% objname is the objective function name, that is passed for ess.
+
+if ~strcmp(filename(end-1:end),'.m')
+    filename = [filename '.m'];
+end
+flag = 0;
+cdir = cd;
+fullname = [cdir '\' filename];
+f = exist(fullname,'file');
+if f == 0
+    % the file is not detected, return zero
+    flag = 0;
+    return
+end
+
+% hopefully, opening for reading does not cause accessibility issue
+fid = fopen(fullname,'r');
+if fid == -1
+    flag = -1;
+    return
+end
+tline = fgetl(fid);
+while ischar(tline)
+    k = strfind(tline,[objname '(x']);
+    if ~isempty(k)
+        % we found the objective in the file, the file is what we needed.
+        flag = 1;
+        return;
+    end
+    %disp(tline)
+    tline = fgetl(fid);
+end
+
+fclose(fid);
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/ess_kernel.m b/Requirements/MEIGO/eSS/ess_kernel.m
new file mode 100644
index 0000000000000000000000000000000000000000..3740efd0444349f30cd2e5a2864cb8faddc60bf8
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ess_kernel.m
@@ -0,0 +1,1178 @@
+
+function [Results]=ess_kernel(problem,opts,varargin)
+% function [Results]=ess_kernel(problem,opts,varargin)
+% Function   : eSS Release 2019 - last revised Oct-2019 - AFV
+% Written by : Process Engineering Group IIM-CSIC
+% Created on : 12/03/2008
+% Last Update: 29/10/2019
+% Email      : gingproc@iim.csic.es
+%
+% (c) CSIC, Spanish Council for Scientific Research
+%
+% Global optimization algorithm for MINLP's based on Scatter Search
+%
+%   eSS attempts to solve problems of the form:
+%       min F(x)  subject to:  ceq(x) = 0 (equality constraints)
+%        x                     c_L <= c(x) <= c_U (inequality constraints)
+%                              x_L <= x <= x_U (bounds on the decision
+%                              variables)
+%
+% Constraint functions, if applicable, must be declared in the same script as the
+% objective function as a second output argument:
+% e.g., [f,c]=myfunction(x)
+%       f=objective function value
+%       g=vector containing the constraints
+%       return
+% 
+% DW: [f, c, gf, gc] = myfunction(x)
+%       gf, gc: gradient of objective function and constraints
+%
+% Please have a look at the manual before using eSS
+%
+%       USAGE: Results=ess_kernel(problem,opts,p1,p2,....,pn);
+%
+% INPUT PARAMETERS:
+% ****************
+%   problem - Structure containing problem settings
+%       problem.f   = Name of the file containing the objective
+%                     function (String)
+%       problem.x_L = Lower bounds of decision variables (vector)
+%       problem.x_U = Upper bounds of decision variables (vector)
+%       problem.x_0 = Initial point(s) (optional; vector or matrix)
+%       problem.f_0 = Function values of initial point(s) (optional) These
+%       value MUST correspond to feasible points.
+%
+%       NOTE:The dimension of f_0 and x_0 may be different. For example, if
+%       we want to introduce 5 initial points but we only know the values
+%       for 3 of them, x_0 would have 5 rows whereas f_0 would have only 3
+%       elements. It is mandatory that the first 3 rows of x_0 correspond
+%       to the values of f_0
+%
+%       Additionally, fill the following fields if your problem has
+%       non-linear constraints
+%       problem.neq     = Number of equality constraints (Integer; do not define it
+%                         if there are no equality constraints)
+%       problem.c_L     = Lower bounds of nonlinear inequality constraints
+%                        (vector)
+%       problem.c_U     = Upper bounds of nonlinear inequality constraints
+%                         (vector)
+%       problem.int_var = Number of integer variables (Integer)
+%       problem.bin_var = Number of binary variables  (Integer)
+%       problem.vtr     = Objective function value to be reached (optional)
+%
+%
+% NOTE: The order of decision variables is x=[cont int bin]
+%
+%   opts - Structure containing options (if set as opts=[] defaults options
+%          will be loaded) Type "ssm_kernel" or "ssm_kernel('defaults')" to
+%          get the default options
+%
+%       User options
+%           opts.maxeval    = Maximum number of function evaluations
+%                             (Default 1000)
+%           opts.maxtime    = Maximum CPU time in seconds (Default 60)
+%           opts.iterprint  = Print each iteration on screen: 0-Deactivated
+%                             1-Activated (Default 1)
+%           opts.plot       = Plots convergence curves: 0-Deactivated,
+%                             1-Plot curves on line, 2-Plot final results
+%                             (Default 0)
+%           opts.weight     = Weight that multiplies the penalty term added
+%                             to the objective function in constrained
+%                             problems (Default 1e6)
+%           opts.log_var    = Indexes of the variables which will be used
+%                             to generate diverse solutions in different
+%                             orders of magnitude (vector)
+%           opts.tolc       = Maximum absolute violation of the constraints
+%                             (Default 1e-5)
+%           opts.prob_bound = Probability (0-1) of biasing the search towards
+%                             the bounds (Default 0.5)
+%           opts.inter_save = Saves results in a mat file in intermediate
+%                             iterations. Useful for very long runs
+%                             (Binary; Default = 0)
+%           opts.n_stuck    = Number of consecutive iterations without
+%                             significant improvement before the search
+%                             stops. Default = 0 (not applicable);
+%
+%       Global options
+%           opts.dim_refset         = Number of elements in Refset
+%                                     (Integer; automatically calculated)
+%           opts.ndiverse           = Number of solutions generated by the
+%                                     diversificator (Default 10*nvar)
+%           opts.combination        = Type of combination of Refset
+%                                     elements (Default 1)
+%                                     1: hyper-rectangles
+%                                     2: linear combinations
+%
+%       Local options
+%           opts.local.solver               = Choose local solver
+%                                             0: Local search deactivated
+%                                             'fmincon'(Default),
+%                                             'fminsearch', 'solnp'
+%                                             'n2fb','dn2fb','dhc','hooke'
+%                                             'ipopt','misqp','lsqnonlin'
+%           opts.local.tol                  = Level of tolerance in local
+%                                             search. 1: Relaxed; 2: Medium
+%                                             3: Tight (default: 2 in
+%                                             intermediate searches and 3
+%                                             in the final stage).
+%           opts.local.iterprint            = Print each iteration of local
+%                                             solver on screen (Binary;
+%                                             default = 0)
+%           opts.local.n1                   = Number of iterations
+%                                             before applying
+%                                             local search for the 1st time
+%                                             (Default 1)
+%           opts.local.n2                   = Minimum number of iterations
+%                                             in the global
+%                                             phase between 2 local calls
+%                                             (Default 10)
+%           opts.local.balance              = Balances between quality (=0)
+%                                             and diversity (=1) for
+%                                             choosing initial points for
+%                                             the local search (default
+%                                             0.5)
+%           opts.local.finish               = Applies local search to the
+%                                             best solution found once the
+%                                             optimization if finished
+%                                             (same values as
+%                                             opts.local.solver)
+%           opts.local.bestx                = When activated (i.e. =1) only
+%                                             applies local search to the
+%                                             best solution found to
+%                                             date,ignoring filters
+%                                             (Default=0)
+%
+%
+%   p1,p2... :  optional input parameters to be passed to the objective
+%   function
+%
+%
+% OUTPUT PARAMETERS:
+% *****************
+% A file called "ssm_report.mat" is generated containing.
+%
+%   problem - Structure containing problem settings
+%   opts    - Structure containing all options
+%   Results - Structure containing results
+%
+% Fields in Results
+%       Results.fbest                   = Best objective function value
+%                                         found after the optimization
+%       Results.xbest                   = Vector providing the best
+%                                         function value
+%       Results.cpu_time                = Time in seconds consumed in the
+%                                         optimization
+%       Results.f                       = Vector containing the best
+%                                         objective function value after each
+%                                         iteration
+%       Results.x                       = Matrix containing the best vector
+%                                         after each iteration
+%       Results.time                    = Vector containing the cpu time
+%                                         consumed after each iteration
+%       Results.neval                   = Vector containing the number of
+%                                         function evaluations after each
+%                                         iteration
+%       Results.numeval                 = Number of function evaluations
+%       Results.local_solutions         = Local solutions found by the
+%                                         local solver (in rows)
+%       Results.local_solutions_values  = Function values of the local
+%                                         solutions
+%       Results.end_crit                = Criterion to finish the
+%                                         optimization
+%                                         1: Maximal number of function
+%                                         evaluations achieved
+%                                         2: Maximum allowed CPU Time
+%                                         achieved
+%                                         3: Value to reach achieved
+%
+%              NOTE: To plot convergence curves type:
+%              stairs(Results.time,Results.f) or stairs(Results.neval,Results.f)
+% REFERENCES
+%
+% If you use eSS and publish the results, please cite the following papers:
+%
+% Egea, J.A., Balsa-Canto, E., Garc�a, M.S.G., Banga, J.R. (2009) Dynamic
+% optimization of nonlinear processes with an enhanced scatter search
+% method. Industrial & Engineering Chemistry Research 49(9): 4388-4401.
+%
+% Egea, J.A., Mart�, R., Banga, J.R. (2010) An evolutionary method for
+% complex-process optimization. Computers & Operations Research 37(2):
+% 315-324.
+
+
+global input_par
+global stopOptimization
+stopOptimization=0;
+
+%Initialize time
+tinit = tic; %cpu_time=cputime;
+
+fprintf('\n');
+fprintf('------------------------------------------------------------------------------ \n');
+fprintf(' eSS R2019 - Enhanced Scatter Search    \n');
+fprintf('<c> IIM-CSIC, Vigo, Spain -  email: gingproc@iim.csic.es \n');
+fprintf('------------------------------------------------------------------------------ \n\n');
+
+
+%Initialize the number of function evaluations and a stop variable
+nfuneval=0;
+fin=0;
+nreset=0;
+
+if not(isfield(opts,'maxeval')) & not(isfield(opts,'maxtime'))
+    fprintf('WARNING:Either opts.maxeval or opts.maxtime must be defined as a stop criterion \n')
+    fprintf('Define any of these options and rerun \n')
+    Results=[];
+    return
+else
+    if not(isfield(opts,'maxeval'))
+        maxeval=1e12;
+    else
+        maxeval=opts.maxeval;
+    end
+    if not(isfield(opts,'maxtime'))
+        maxtime=1e12;
+    else
+        maxtime=opts.maxtime;
+    end
+end
+
+%Load default values for the options
+default=ssm_defaults;
+loc=default.local;
+
+%Display default options
+if (nargin < 1) | (isstr(problem) & isequal(problem, 'defaults')) % pass default options
+    disp('Default options returned (type "help ssm_kernel" for help).');
+    fprintf('\n');
+    disp('Global options')
+    disp(default)
+    disp('Local options')
+    disp(loc)
+    Results = 'End of default options display';
+    return
+end
+
+if nargin<2, opts=[]; end
+
+% check regularization for iterative display of the reg. cost and penalty
+reg_flag = 0;
+if nargin == 5
+    if isfield(varargin{1},'nlpsol') && isfield(varargin{1}.nlpsol,'regularization') && varargin{1}.nlpsol.regularization.ison
+        reg_flag = 1;
+        amigo_inputs = varargin{1};
+        amigo_privstruct = varargin{2};
+    end
+end 
+
+%Set all options
+opts=ssm_optset(default,opts);
+
+%Extra input parameters for fsqp, n2fb and nomad
+if nargin>2
+    if strcmp(opts.local.finish,'n2fb') | strcmp(opts.local.finish,'dn2fb') |...
+            strcmp(opts.local.solver,'dn2fb') | strcmp(opts.local.solver,'n2fb') |...
+            strcmp(opts.local.solver,'fsqp') |strcmp(opts.local.finish,'fsqp')|...
+            strcmp(opts.local.solver,'nomad') |strcmp(opts.local.finish,'nomad')|...
+            strcmp(opts.local.solver,'nl2sol')|strcmp(opts.local.finish,'nl2sol')|...
+            strcmp(opts.local.solver,'lbfgsb')|strcmp(opts.local.finish,'lbfgsb')
+        input_par=varargin;
+    end
+end
+
+x_U=problem.x_U;
+x_L=problem.x_L;
+
+%Check if bounds have the same dimension
+if length(x_U)~=length(x_L)
+    disp('Upper and lower bounds have different dimension!!!!')
+    disp('EXITING')
+    Results=[];
+    return
+else
+    %Number of decision variables
+    nvar=length(x_L);
+end
+
+if not(isfield(problem,'x_0')), x_0=[]; else, x_0=problem.x_0; end
+
+if not(isfield(problem,'f_0'))
+    f_0=[];
+    fbest=inf;
+else
+    f_0=problem.f_0;
+    %Transform in column vector
+    if size(f_0,1)==1
+        f_0=f_0';
+    end
+    [fbest,iii]=min(f_0);
+    xbest=x_0(iii,:);
+end
+if not(isfield(problem,'neq')) | isempty(problem.neq), neq=0; else, neq=problem.neq; end
+if not(isfield(problem,'c_U')), c_U=[]; c_L=[]; else, c_U=problem.c_U; c_L=problem.c_L; end
+if not(isfield(problem,'int_var')) | isempty(problem.int_var), int_var=0; else, int_var=problem.int_var; end
+if not(isfield(problem,'bin_var')) | isempty(problem.bin_var), bin_var=0; else, bin_var=problem.bin_var; end
+if not(isfield(problem,'vtr')), vtr=[]; else, vtr=problem.vtr; end
+
+
+%Change to rows if necessary
+if size(x_L,2)==1, x_L=x_L'; end
+if size(x_U,2)==1, x_U=x_U'; end
+if size(c_L,2)==1, c_L=c_L'; end
+if size(c_U,2)==1, c_U=c_U'; end
+
+%User options
+iterprint=opts.iterprint;
+prob_bound=opts.prob_bound;
+inter_save=opts.inter_save;
+
+plot_results=opts.plot;
+weight=opts.weight;
+tolc=opts.tolc;
+log_var=opts.log_var;
+
+
+%Global options
+dim_refset=opts.dim_refset;
+if ischar(dim_refset) || isempty(dim_refset)
+    nnn=roots([1  -1 -10*nvar/1]);
+    iii=find(nnn>0);
+    dim_refset=ceil(nnn(iii));
+    if mod(dim_refset,2), dim_refset=dim_refset+1; end
+    if iterprint
+        fprintf('%-9s %i\n','Refset size automatically calculated:',  dim_refset);
+    end
+end
+
+ndiverse=opts.ndiverse;
+
+if ischar(ndiverse)
+    
+    ndiverse=10*nvar;
+    if iterprint
+        fprintf('%-9s %i\n','Number of diverse solutions automatically calculated:',  ndiverse);
+    end
+    
+elseif(isempty(ndiverse))
+    
+    ndiverse=10*nvar;
+    if iterprint
+        fprintf('%-9s %i\n','Number of diverse solutions automatically calculated:',  ndiverse);
+    end
+end
+
+if ndiverse<dim_refset
+    ndiverse=dim_refset;
+end
+
+initiate=opts.initiate;
+combin=opts.combination;
+n_stuck=opts.n_stuck;
+
+%Local options
+local_solver=opts.local.solver;
+local_tol=opts.local.tol;
+local_iterprint=opts.local.iterprint;
+local_n1=opts.local.n1;
+local_n2=opts.local.n2;
+if isstr(local_n1), local_n1=1; end
+if isstr(local_n2), local_n2=10;end
+
+
+local_balance=opts.local.balance;
+
+if isempty(opts.local.finish)
+    opts.local.finish=local_solver;
+    local_finish=local_solver;
+else
+    local_finish=opts.local.finish;
+end
+local_bestx=opts.local.bestx;
+
+
+%If there are equality constraints
+if neq
+    %Set the new bounds for all the constraints
+    c_L=[zeros(1,neq) c_L];
+    c_U=[zeros(1,neq) c_U];
+end
+
+if size(x_0,2)~=nvar, x_0=x_0'; end
+
+nconst=length(c_U);
+
+%Transform the objective function into a handle
+if isa(problem.f,'function_handle')
+    fobj = problem.f;
+    problem.f = func2str(problem.f);
+else
+    fobj=str2func(problem.f);
+end
+
+isFjacDefined = 0;
+if isfield(problem,'fjac') && ~isempty(problem.fjac)
+    isFjacDefined = 1;
+    
+	if ischar(problem.fjac)
+		fjac = str2func(problem.fjac);
+	elseif isa(problem.fjac,'function_handle')
+		fjac = problem.fjac;
+	else
+		error('fjac is neither a string nor a function handle.')
+	end
+end
+
+%Check if the objecttive function has 2 output arguments in constrained
+%problems
+if nconst
+    n_out_f=nargout(problem.f);
+    if n_out_f<2
+        fprintf('For constrained problems the objective function must have at least 2 output arguments \n');
+        fprintf('EXITING \n');
+        Results=[];
+        return
+    end
+    if local_solver & strcmp(local_solver,'fminsearch') | strcmp(local_solver,'hooke') | strcmp(local_solver,'dhc')
+        fprintf('Warning! %s might not provide the optimal solution for constrained problems \n',local_solver);
+    end
+end
+
+if (int_var+bin_var) & local_solver & not(strcmp(local_solver,'misqp'))
+    fprintf('For problems with integer and/or binary variables you must use MISQP as a local solver \n');
+    fprintf('EXITING \n');
+    Results=[];
+    return
+end
+
+if local_solver & strcmp(local_solver,'n2fb') | strcmp(local_solver,'dn2fb')| strcmp(local_solver,'nl2sol')
+    n_out_f=nargout(problem.f);
+    if n_out_f<3
+        fprintf('%s requires 3 output arguments \n',local_solver);
+        fprintf('EXITING \n');
+        Results=[];
+        return
+    else
+        %Generate a random point within the bounds
+        randx=rand(1,nvar).*(x_U-x_L)+x_L;
+        [f,g,R]=feval(fobj,randx,varargin{:});
+        ndata=length(R);
+        
+        if ~isempty(g) & g
+            fprintf('%s can not solve constrained problems \n',local_solver);
+            fprintf('EXITING \n');
+            Results=[];
+            return
+        end
+        
+        if length(R)<=1
+            fprintf('The third output argument must be a vector, not a scalar \n');
+            fprintf('EXITING \n');
+            Results=[];
+            return
+        end
+        nfuneval=nfuneval+1;
+    end
+else
+    ndata=[];
+end
+
+%DW 
+if opts.local.use_gradient_for_finish
+    %if ~local_finish | ~strcmp(local_finish,'fmincon')
+    %    fprintf(['opts.local.use_gradient_for_finish == 1, can only be used with fmincon for the moment\n']);
+    %    fprintf('EXITING \n');
+    %    Results=[];
+    %end
+    if nargout(problem.f) < 3
+        fprintf(['opts.local.use_gradient_for_finish == 1, but no gradients are provided by "' problem.f '"\n']);
+        fprintf('EXITING \n');
+        Results=[];
+        return
+    end
+end
+
+if local_finish & isempty(ndata) & strcmp(local_finish,'n2fb') | strcmp(local_finish,'dn2fb') | strcmp(local_finish,'nl2sol')
+    n_out_f=nargout(problem.f);
+    if n_out_f<3
+        fprintf('%s requires 3 output arguments \n',local_solver);
+        fprintf('EXITING \n');
+        Results=[];
+        return
+    else
+        %Generate a random point within the bounds
+        randx=rand(1,nvar).*(x_U-x_L)+x_L;
+        [f,g,R]=feval(fobj,randx,varargin{:});
+        ndata=length(R);
+        if ~isempty(g) & g
+            fprintf('%s can not solve constrained problems \n',local_solver);
+            fprintf('EXITING \n');
+            Results=[];
+            return
+        end
+        
+        if length(R)<=1
+            fprintf('The third output argument must be a vector, not a scalar \n');
+            fprintf('EXITING \n');
+            Results=[];
+            return
+        end
+        nfuneval=nfuneval+1;
+    end
+end
+
+%Pasamos a logaritmo
+xl_log=x_L;
+xu_log=x_U;
+
+aaa=find(xl_log(log_var)==0);
+
+xl_log(log_var(aaa))=eps;
+
+xl_log(log_var)=log(xl_log(log_var));
+xu_log(log_var)=log(xu_log(log_var));
+
+
+%Build auxiliary files in case local search is activated
+if local_solver
+    if isFjacDefined
+        ssm_aux_local(problem.f,problem.fjac,x_L,x_U,c_L,c_U,neq,local_solver,nvar,varargin{:});
+    else
+        ssm_aux_local(problem.f,[],x_L,x_U,c_L,c_U,neq,local_solver,nvar,varargin{:});
+    end
+end
+% ssm_aux_local(problem.f,x_L,x_U,c_L,c_U,neq,local_solver,nvar,varargin{:});
+%Initialize variables
+stage_1=1;
+n_minimo=0;
+n_critico=local_n1;
+denom=2;
+suit_to_local=ones(1,dim_refset);
+
+local_solutions=[];
+local_solutions_values=[];
+initial_points=[];
+
+Results.f=[];
+Results.x=[];
+Results.time=[];
+Results.neval=[];
+xbest=[];
+
+%Possible combinations among the dim_refset elements in Refset, taken in pairs
+ncomb=nchoosek(1:dim_refset,2);
+MaxSubSet=(dim_refset^2-dim_refset)/2;
+MaxSubSet2=2*MaxSubSet;
+
+
+%We generate 5 solutions
+solutions=zeros(ndiverse+5,nvar);
+
+for i=1:5
+    solutions(i,:)=(rand(1,nvar)+i-1)/5;
+end
+
+solutions(6:ndiverse+5,:)=rand(ndiverse,nvar);
+solutions=solutions.*repmat(xu_log-xl_log,ndiverse+5,1)+repmat(xl_log,ndiverse+5,1);
+
+% BUG FIXED - JRB - JUNE 2014
+%if (int_var) | (bin_var)
+%    solutions=ssm_round_int(solutions,int_var+bin_var,x_L,x_U);
+%end
+for i=1:ndiverse+5
+       solutions(i,log_var)=exp(solutions(i,log_var));
+end
+
+
+l_f_0=length(f_0);
+l_x_0=size(x_0,1);
+
+%Put x_0 without their corresponding f_0 values at the beginning of solutions
+solutions=[x_0(l_f_0+1:end,:); solutions];
+
+temp=l_x_0-l_f_0;
+
+sol=zeros(ndiverse+5+temp,nvar);
+sol_val=zeros(ndiverse+5+temp,1);
+sol_val_pen=zeros(ndiverse+5+temp,1);
+sol_pen=zeros(ndiverse+5+temp,1);
+sol_nlc=zeros(ndiverse+5+temp,nconst);
+
+counter=1;
+%Evaluate the set of solutions
+
+for i=1:ndiverse+5+temp
+    [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(solutions(i,:),x_L,x_U,fobj,nconst,c_L,c_U,...
+        tolc,weight,int_var,bin_var,varargin{:});
+    nfuneval=nfuneval+1;
+    if include
+        sol(counter,:)=x;
+        sol_val(counter)=val;
+        sol_val_pen(counter)=val_penalty;
+        sol_pen(counter)=pena;
+        sol_nlc(counter,:)=nlc;
+        counter=counter+1;
+    end
+    
+end
+
+sol(counter:end,:)=[];
+sol_val(counter:end)=[];
+sol_val_pen(counter:end)=[];
+sol_pen(counter:end)=[];
+sol_nlc(counter:end,:)=[];
+
+
+%Add points with f_0 values. We assume feasiblity
+
+sol=[x_0(1:l_f_0,:); sol];
+sol_val=[f_0; sol_val];
+sol_val_pen=[f_0; sol_val_pen];   %We assume feasible points in f_0
+sol_pen=[zeros(l_f_0,1);sol_pen];         %We assume feasible points in f_0
+sol_nlc=[NaN*ones(l_f_0,nconst); sol_nlc];     %We do not know these values, but we do not care. We assume feasibility
+
+%% Update: 11/11/2016 
+%% The following added by JEgea on Nov-2016 to handle REfSet with infeasible solutions
+%% JRB reported the problem found in constrained problems: when initial point is infeasible, and
+%% all the elements in the generated RefSet are also infeasible, eSS was printing obj=Inf, which was misleading
+if isfield(problem,'x_0')
+    %This is if only one solution in x_0 is defined
+    if sol_pen(1) > 0
+     fprintf('Initial Point (x_0): INFEASIBLE SOLUTION. Penalized value: %g \n', sol_val_pen(1));
+    else
+       fprintf('Initial Point (x_0): FEASIBLE SOLUTION. Objective function value: %g \n', sol_val_pen(1));
+    end
+end
+%%
+
+%Initialize Refset
+Refset=zeros(dim_refset,nvar);
+Refset_values=zeros(dim_refset,1);
+Refset_values_penalty=zeros(dim_refset,1);
+Refset_nlc=[];
+penalty=[];
+
+
+[aaa, iii]=sort(sol_val_pen);
+first_members=ceil(dim_refset/2);
+last_members=dim_refset-first_members;
+
+
+%Create the initial sorted Refset
+
+Refset=sol(iii(1:first_members),:);
+Refset_values=sol_val(iii(1:first_members));
+Refset_values_penalty=sol_val_pen(iii(1:first_members));
+penalty=sol_pen(iii(1:first_members));
+Refset_nlc=sol_nlc(iii(1:first_members),:);
+
+%The rest of Refset members are chosen randomly
+iii(1:first_members)=[];
+ooo=randperm(length(iii));
+%ooo=randperm(ndiverse+2+size(x_0,1)-first_members);
+
+Refset=[Refset; sol(iii(ooo(1:last_members)),:)];
+Refset_values=[Refset_values; sol_val(iii(ooo(1:last_members)))];
+Refset_values_penalty=[Refset_values_penalty; sol_val_pen(iii(ooo(1:last_members)))];
+penalty=[penalty; sol_val_pen(iii(ooo(1:last_members)))];
+Refset_nlc=[Refset_nlc; sol_nlc(iii(ooo(1:last_members)),:)];
+
+%Check best value
+ggg=find(penalty<=tolc);
+if not(isempty(ggg))
+    [fbest,iii]=min(Refset_values_penalty(ggg));
+    xbest=Refset((ggg(iii)),:);
+end
+
+cpu_time = toc(tinit);
+iter=0;
+if iterprint==1
+    if reg_flag
+        amigo_privstruct.theta = xbest;
+        amigo_privstruct.theta = AMIGO_scale_theta_back(amigo_privstruct.theta, amigo_inputs);
+        [objReg] = AMIGO_PEcostreg(amigo_privstruct.theta,amigo_inputs,amigo_privstruct);
+        reg_alpha = amigo_inputs.nlpsol.regularization.alpha;
+        fprintf('Initial Pop: NFunEvals: %i  Bestf: %g   Bestfit: %g   Pen: %g   CPUTime: %f    Var: %g \n',nfuneval,fbest,fbest - reg_alpha*objReg,objReg, cpu_time,var(Refset_values_penalty));
+    % else
+    %% Nov2016: correction when there is no feasible point    
+    elseif isinf(fbest)
+        fprintf('Initial Pop: NFunEvals: %i  NO FEASIBLE POINT FOUND  Bestf (penalized): %g      CPUTime: %f    Var: %g \n',nfuneval,Refset_values_penalty(1),cpu_time,var(Refset_values_penalty));
+    else
+        fprintf('Initial Pop: NFunEvals: %i  Bestf: %g      CPUTime: %f    Var: %g \n',nfuneval,fbest,cpu_time,var(Refset_values_penalty));
+    end
+end
+
+Results.f=[Results.f fbest];
+Results.x=[Results.x;xbest];
+Results.time=[Results.time cpu_time];
+Results.neval=[Results.neval nfuneval];
+
+%Sort the Refset
+[Refset_values_penalty,I]=sort(Refset_values_penalty);
+Refset_values=Refset_values(I);
+penalty=penalty(I);
+Refset=Refset(I,:);
+Refset_nlc=Refset_nlc(I,:);
+
+if combin==1, nrand=nvar; elseif combin==2, nrand=1; end
+
+final_ref=0;
+use_bestx=0;
+
+index1=ncomb(:,1);
+index2=ncomb(:,2);
+index=[index1;index2];
+
+
+diff_index=index2-index1;
+
+lb_p=1;         %Minimum ppp
+st_p=0.75;      %Defines maximum ppp. max(ppp)= lb_p+ st_p
+%Example: lb_p=1.25 and st_p=0.5 varies ppp from
+%1.25 to 1.75
+
+ppp=st_p*(diff_index-1)/(dim_refset-2)+lb_p;
+hyper_x_L=repmat(x_L,MaxSubSet,1);
+hyper_x_U=repmat(x_U,MaxSubSet,1);
+
+refset_change=zeros(1,dim_refset);
+
+while (not(fin))
+    child=zeros(MaxSubSet2,nvar);
+    child_values=zeros(MaxSubSet2,1);
+    child_values_penalty=zeros(MaxSubSet2,1);
+    child_penalty=zeros(MaxSubSet2,1);
+    child_nlc=zeros(MaxSubSet2,nconst);
+    
+    child_parent_index=zeros(MaxSubSet2,1);
+    counter=1;
+    continuar=0;
+    while ~continuar
+        %Sort Refset
+        %This is mandatory because the variable index is also sorted
+        [Refset_values_penalty,I]=sort(Refset_values_penalty);
+        Refset_values=Refset_values(I);
+        penalty=penalty(I);
+        Refset=Refset(I,:);
+        Refset_nlc=Refset_nlc(I,:);
+        
+        refset_change=refset_change(I);
+        
+        parents_index1=Refset(index1,:);
+        parents_index2=Refset(index2,:);
+        parents_index1_values_penalty=Refset_values_penalty(index1);
+        parents_index2_values_penalty=Refset_values_penalty(index2);
+        
+        denom22=max(abs(parents_index1),abs(parents_index2));
+        
+        denom22(find(~denom22))=1;
+        
+        AAA=abs((parents_index1-parents_index2)./denom22);
+        BBB=find(all(AAA'<1e-3));
+        if ~isempty(BBB)
+            %Check the index of worst element among the twins of index2
+            index_refset_out=max(index2(BBB));
+            include=0;
+            while ~include
+                %Generate a new random solution
+                new_refset_member=rand(1,nvar).*(xu_log-xl_log)+xl_log;
+                new_refset_member(log_var)=exp(new_refset_member(log_var));
+                
+                [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(new_refset_member,x_L,x_U,fobj,nconst,c_L,c_U,...
+                    tolc,weight,int_var,bin_var,varargin{:});
+                nfuneval=nfuneval+1;
+                if include
+                    Refset(index_refset_out,:)=x;
+                    Refset_values(index_refset_out)=val;
+                    Refset_values_penalty(index_refset_out)=val_penalty;
+                    Refset_nlc(index_refset_out,:)=nlc;
+                    penalty(index_refset_out)=pena;
+                    members_update(index_refset_out)=0;
+                end
+            end
+        else
+            continuar=1;
+        end
+    end
+    
+    candidate=Refset;
+    candidate_values=Refset_values;
+    candidate_values_penalty=Refset_values_penalty;
+    candidate_nlc=Refset_nlc;
+    candidate_penalty=penalty;
+    candidate_update=zeros(1,dim_refset);
+    
+    members_update=ones(1,dim_refset);
+    
+    factor=repmat(ppp,1,nvar).*(parents_index2-parents_index1)/1.5;
+    
+    v1=parents_index1-factor;
+    v2=parents_index2-factor;
+    v3=2*parents_index2-parents_index1-factor;
+    
+    aaa=find(v1<hyper_x_L);
+    if ~isempty(aaa)
+        rand_aaa=rand(1,length(aaa));
+        AAA=find(rand_aaa>prob_bound);
+        aaa=aaa(AAA);
+        v1(aaa)=hyper_x_L(aaa);
+    end
+    
+    bbb=find(v1>hyper_x_U);
+    if ~isempty(bbb)
+        rand_bbb=rand(1,length(bbb));
+        BBB=find(rand_bbb>prob_bound);
+        bbb=bbb(BBB);
+        v1(bbb)=hyper_x_U(bbb);
+    end
+    
+    ccc=find(v3<hyper_x_L);
+    if ~isempty(ccc)
+        rand_ccc=rand(1,length(ccc));
+        CCC=find(rand_ccc>prob_bound);
+        ccc=ccc(CCC);
+        v3(ccc)=hyper_x_L(ccc);
+    end
+    
+    ddd=find(v3>hyper_x_U);
+    if ~isempty(ddd)
+        rand_ddd=rand(1,length(ddd));
+        DDD=find(rand_ddd>prob_bound);
+        ddd=ddd(DDD);
+        v3(ddd)=hyper_x_U(ddd);
+    end
+    
+    if nrand>1
+        new_comb1=v1+(v2-v1).*rand(MaxSubSet,nrand);
+        new_comb2=v2+(v3-v2).*rand(MaxSubSet,nrand);
+    else
+        new_comb1=v1+(v2-v1)*rand;
+        new_comb2=v2+(v3-v2)*rand;
+    end
+    
+    new_comb=[new_comb1;new_comb2];
+    
+    for i=1:MaxSubSet2
+        %Evaluate
+        [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(new_comb(i,:),x_L,x_U,fobj,nconst,c_L,c_U,...
+            tolc,weight,int_var,bin_var,varargin{:});
+        nfuneval=nfuneval+1;
+        
+        if include
+            child(counter,:)=x;
+            child_values(counter)=val;
+            child_values_penalty(counter)=val_penalty;
+            child_penalty(counter)=pena;
+            child_nlc(counter,:)=nlc;
+            child_parent_index(counter)=index(i);
+            
+            counter=counter+1;
+            
+            if val_penalty<candidate_values_penalty(index(i))
+                %Update candidate
+                %This can be accelerated saving the index and replacing at
+                %the end with the best one
+                candidate(index(i),:)=x;
+                candidate_values_penalty(index(i))=val_penalty;
+                candidate_values(index(i))=val;
+                candidate_penalty(index(i))=pena;
+                candidate_nlc(index(i),:)=nlc;
+                candidate_update(index(i))=1;
+                members_update(index(i))=0;
+            end
+        end
+    end
+    
+    
+    %Check the stop criterion
+    if nfuneval>= maxeval
+        fin=1;
+    elseif toc(tinit)>=maxtime
+        fin=2;
+    elseif stopOptimization
+        fin=4;
+    elseif not(isempty(vtr))
+        if fbest<=vtr
+            fin=3;
+        end
+    end
+    
+    child(counter:end,:)=[];
+    child_values(counter:end)=[];
+    child_values_penalty(counter:end)=[];
+    child_penalty(counter:end)=[];
+    child_parent_index(counter:end)=[];
+    
+    
+    members_to_update=find(candidate_update==1);
+    for i=1:length(members_to_update)
+        [vector,vector_value,vector_penalty,vector_value_penalty,vector_nlc,new_child,new_child_value,...
+            new_child_penalty,new_child_value_penalty,new_child_nlc,nfuneval]=ssm_beyond(Refset(members_to_update(i),:),...
+            candidate(members_to_update(i),:),candidate_values_penalty(members_to_update(i)),fobj,nrand,tolc,weight,...
+            x_L,x_U,c_L,c_U,nconst,int_var,bin_var,nfuneval,prob_bound,varargin{:});
+        
+        if not(isempty(vector))
+            Refset(members_to_update(i),:)=vector;
+            Refset_values(members_to_update(i))=vector_value;
+            Refset_values_penalty(members_to_update(i))=vector_value_penalty;
+            penalty(members_to_update(i))=vector_penalty;
+            Refset_nlc(members_to_update(i),:)=vector_nlc;
+        else
+            Refset(members_to_update(i),:)=candidate(members_to_update(i),:);
+            Refset_values(members_to_update(i))=candidate_values(members_to_update(i));
+            Refset_values_penalty(members_to_update(i))=candidate_values_penalty(members_to_update(i));
+            penalty(members_to_update(i))=candidate_penalty(members_to_update(i));
+            Refset_nlc(members_to_update(i),:)=candidate_nlc(members_to_update(i),:);
+        end
+    end
+    
+    fbest_lastiter=fbest;
+    
+    ggg=find(penalty<=tolc);
+    if not(isempty(ggg))
+        [fbest_new,hhh]=min(Refset_values_penalty(ggg));
+        if fbest_new<fbest
+            xbest=Refset(ggg(hhh),:);
+            fbest=fbest_new;
+            use_bestx=1;
+            if inter_save
+                Results.fbest=fbest;
+                Results.xbest=xbest;
+                Results.numeval=nfuneval;
+                Results.end_crit=fin;
+                Results.cpu_time=toc(tinit); %cpu_time;
+                Results.Refset.x=Refset;
+                Results.Refset.f=Refset_values;
+                Results.Refset.fpen=Refset_values_penalty;
+                Results.Refset.const=Refset_nlc;
+                Results.Refset.penalty=penalty;
+                save ess_report problem opts Results
+            end
+        end
+    end
+    
+    iter=iter+1;
+    n_minimo=n_minimo+1;
+    
+    if iterprint==1
+        if reg_flag
+            % calculate the regularization term to substract from the objective.
+            amigo_privstruct.theta = xbest;
+            amigo_privstruct.theta = AMIGO_scale_theta_back(amigo_privstruct.theta, amigo_inputs);
+            [objReg] = AMIGO_PEcostreg(amigo_privstruct.theta,amigo_inputs,amigo_privstruct);
+            reg_alpha = amigo_inputs.nlpsol.regularization.alpha;
+            fprintf('Iteration: %i NFunEvals: %i  Bestf: %g   Bestfit: %g   Pen: %g   CPUTime: %f    Var: %g \n',iter,nfuneval,fbest,fbest - reg_alpha*objReg,objReg, toc(tinit),var(Refset_values_penalty));
+			%else
+            %% correction Nov-2016 - check if there are no feasible points
+        elseif isinf(fbest)
+            fprintf('Iteration: %i NFunEvals: %i  NO FEASIBLE POINT FOUND  Best Refset value (penalized): %g      CPUTime: %f    Var: %g \n',iter,nfuneval,Refset_values_penalty(1),toc(tinit),var(Refset_values_penalty));
+		else
+            fprintf('Iteration: %i NFunEvals: %i  Bestf: %g      CPUTime: %f    Var: %g \n',iter,nfuneval,fbest,toc(tinit),var(Refset_values_penalty));
+        end
+    end
+    
+    ddd=find(members_update);
+    eee=find(~members_update);
+    refset_change(ddd)=refset_change(ddd)+1;
+    refset_change(eee)=0;
+    fff=find(refset_change>=20);
+    if ~isempty(fff)
+        to_replace=numel(fff);
+        replaced=0;
+        while replaced<to_replace
+		% BUG FIXED JUNE-2014 - JRB
+		%            newsol=rand(1,nvar).*(xu_log-xl_log)+xl_log;
+            newsol=rand(1,nvar).*(xu_log-xl_log)+xl_log;
+            newsol(log_var)=exp(newsol(log_var)); 
+            [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(newsol,x_L,x_U,fobj,nconst,c_L,c_U,...
+                tolc,weight,int_var,bin_var,varargin{:});
+            nfuneval=nfuneval+1;
+            if include
+                Refset(fff(replaced+1),:)=x;
+                Refset_values(fff(replaced+1))=val;
+                Refset_values_penalty(fff(replaced+1))=val_penalty;
+                penalty(fff(replaced+1))=pena;
+                Refset_nlc(fff(replaced+1),:)=nlc;
+                refset_change(fff(replaced+1))=0;
+                replaced=replaced+1;
+            end
+        end
+    end
+    % if ((fbest<fbest_lastiter)/fbest_lastiter)>tolc %%% AFV test:
+    if ((fbest<fbest_lastiter)/fbest_lastiter)>tolc || (fbest<fbest_lastiter) 
+        Results.f=[Results.f fbest];
+        Results.x=[Results.x; xbest];
+        Results.time=[Results.time toc(tinit)];
+        Results.neval=[Results.neval nfuneval];
+        nreset=0;
+        if plot_results==1
+            stairs(Results.time,Results.f)
+            xlabel('CPU Time (s)');
+            ylabel('Objective Function Value (-)');
+            title(strcat('Best f:  ',num2str(fbest)))
+            drawnow
+        end
+    else
+        if n_stuck
+            nreset=nreset+1;
+            if nreset==n_stuck
+                fin=5;
+            end
+        end
+    end
+    
+    if local_solver & local_bestx & n_minimo>=n_critico
+        if use_bestx
+            ess_local_filters
+            n_minimo=0;
+        end
+    else
+        if (local_solver & n_minimo>=n_critico)
+            ess_local_filters
+            n_minimo=0;
+        end
+    end
+    fbest_lastiter=fbest;
+    
+    %Check the stopping criterion
+    if nfuneval>= maxeval
+        fin=1;
+    elseif toc(tinit)>=maxtime
+        fin=2;
+    elseif stopOptimization
+        fin=4;
+    elseif not(isempty(vtr))
+        if fbest<vtr
+            fin=3;
+        end
+    end
+    
+    if fin
+        fprintf('\n');
+        if local_finish & fin<3
+            final_ref=1;
+            if isempty(strmatch(local_solver,local_finish))
+                %ssm_aux_local(problem.f,x_L,x_U,c_L,c_U,neq,local_finish,nvar,varargin{:});
+                if isFjacDefined
+                    ssm_aux_local(problem.f,problem.fjac,x_L,x_U,c_L,c_U,neq,local_finish,nvar,varargin{:});
+                else
+                    ssm_aux_local(problem.f,[],x_L,x_U,c_L,c_U,neq,local_finish,nvar,varargin{:});
+                end
+            end
+            local_tol=3;
+            
+            if not(isempty(xbest))
+                x0=xbest;
+                f0=fbest;
+            else
+                x0=Refset(1,:);
+                f0=Refset_values_penalty(1);
+            end
+            if iterprint
+                fprintf('Final local refinement with: %s \n', upper(local_finish))
+                fprintf('Initial point function value: %f \n',f0);
+                tfinal = tic;
+            end
+            if isFjacDefined
+                [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,fjac,...
+                    local_finish,local_iterprint,local_tol,weight,nconst,tolc,opts.local,varargin{:});
+            else
+                [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,[],...
+                    local_finish,local_iterprint,local_tol,weight,nconst,tolc,opts.local,varargin{:});
+            end
+            %      [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,...
+            %    local_finish,local_iterprint,local_tol,weight,nconst,tolc,varargin{:});
+            
+            if iterprint
+                fprintf('Local solution function value: %f \n',fval);
+                fprintf('Number of function evaluations in the local search: %i \n',numeval);
+                fprintf('CPU Time of the local search: %f  seconds \n\n',toc(tfinal));
+            end
+            nfuneval=nfuneval+numeval;
+            %Evaluate the local solution
+            [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(x,x_L,x_U,fobj,nconst,c_L,c_U,...
+                tolc,weight,int_var,bin_var,varargin{:});
+            nfuneval=nfuneval+1;
+            if include && pena<=tolc
+                if val_penalty<fbest
+                    fbest=val_penalty;
+                    xbest=x;
+                    if fbest<vtr, fin=3; end
+                end
+            end
+            ssm_delete_files(local_finish,c_U);
+        end
+        cpu_time=toc(tinit);
+        Results.f=[Results.f fbest];
+        Results.x=[Results.x; xbest];
+        Results.neval=[Results.neval nfuneval];
+        Results.time=[Results.time cpu_time];
+        if iterprint
+            switch fin
+                case 1
+                    disp('Maximum number of function evaluations achieved')
+                case 2
+                    disp('Maximum computation time achieved')
+                case 3
+                    disp('Desired function value achieved')
+                case 4
+                    disp('Optimization stopped by the user')
+                case 5
+                    disp('Maximum number of iterations without significant improvement')
+            end
+		
+			%% Correction Nov2016
+			if isinf(fbest)
+				fprintf('NO FEASIBLE SOLUTION FOUND   Best Refset value (penalized)\t\t%g\n', Refset_values_penalty(1));
+				fprintf('Decision vector\n');
+				fprintf('\t%g\n', Refset(1,:)');
+			else
+				fprintf('Best solution value\t\t%g\n', fbest);
+				fprintf('Decision vector\n');
+				fprintf('\t%g\n', xbest');
+			end
+			
+            fprintf('CPU time\t\t%g\n', cpu_time);
+            fprintf('Number of function evaluations\t\t%g\n', nfuneval);
+        end
+        fclose all;
+        Results.fbest=fbest;
+        Results.xbest=xbest;
+        Results.numeval=nfuneval;
+        Results.end_crit=fin;
+        Results.cpu_time=cpu_time;
+        Results.Refset.x=Refset;
+        Results.Refset.f=Refset_values;
+        Results.Refset.fpen=Refset_values_penalty;
+        Results.Refset.const=Refset_nlc;
+        Results.Refset.penalty=penalty;
+        if plot_results==1 || plot_results==2
+            stairs(Results.time,Results.f)
+            xlabel('CPU Time (s)');
+            ylabel('Objective Function Value (-)');
+            title(strcat('Best f:  ',num2str(fbest)))
+        end
+        try
+            save ess_report problem opts Results
+        end
+        %Delete aux files
+        if local_solver & isempty(strmatch(local_solver,local_finish))
+%             ssm_delete_files(local_solver,c_U);
+        end
+        %     keyboard
+        return
+    end
+end
+
+%\-----------------------------------------------------/
+% Definition of objective for fminsearchbnd
+function fp = fminsobj(x,fun,c_L,c_U,weight,tolc)
+
+[f,c] = feval(fun,x);
+pen=ssm_penalty_function(x,c,c_L,c_U,tolc);
+
+fp=f+weight*pen;
+
+%n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
+
diff --git a/Requirements/MEIGO/eSS/ess_local_filters.m b/Requirements/MEIGO/eSS/ess_local_filters.m
new file mode 100644
index 0000000000000000000000000000000000000000..814db4fb731e83a6d3094ea06ee91bd4ed4c6912
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ess_local_filters.m
@@ -0,0 +1,180 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ess_local_filters.m 1133 2013-12-02 12:54:12Z attila $
+if stage_1==1
+    %In this first stage we apply the local search over the best solution
+    %found so far
+    [minimo,I]=min(child_values_penalty);
+    if minimo<fbest
+        x0=child(I,:);
+        f0=minimo;
+    else
+        x0=xbest;
+        f0=fbest;
+    end
+
+    %Switch to stage 2
+    n_critico=local_n2;
+
+    if local_bestx
+        use_bestx=0;    %not to go directly to stage 2
+    end
+    %use_bestx is a flag indicating that the best solution has been
+    %improved
+elseif stage_2==1;
+    if local_bestx && use_bestx
+        x0=xbest;
+        f0=fbest;
+        use_bestx=0;
+    else
+        %Calculate distance between our children and local_solutions+initial points
+        local_init=[local_solutions; initial_points];
+        xuxl=x_U-x_L;
+        child_norm=child./repmat(xuxl,size(child,1),1);
+        local_init_norm=local_init./repmat(xuxl,size(local_init,1),1);
+        dist=eucl_dist(child_norm',local_init_norm');
+        distance=dist';
+        [eee ooo]=sort(-min(distance,[],1));
+        [aaa uuu]=sort(child_values_penalty);
+        child_points=zeros(1,length(child_values_penalty));
+
+        www=local_balance;
+        for i=1:length(child_values_penalty)
+            child_points(ooo(i))=child_points(ooo(i))+www*i;
+            child_points(uuu(i))=child_points(uuu(i))+(1-www)*i;
+        end
+        [minimum,I]=min(child_points);
+        x0=child(I,:);
+        f0=child_values_penalty(I);
+    end
+end
+
+if iterprint
+    fprintf('Call local solver: %s \n', upper(local_solver))
+    fprintf('Initial point function value: %f \n',f0);
+    tic
+end
+
+%%% AFV 19/04/17: try-catch to avoid crashes due to errors in local search:
+try
+    if isFjacDefined
+            [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,fjac,...
+                local_solver,local_iterprint,local_tol,weight,nconst,tolc,opts.local,varargin{:});
+        else
+            [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,[],...
+                local_solver,local_iterprint,local_tol,weight,nconst,tolc,opts.local,varargin{:});
+    end
+catch
+    fprintf('The local search crashed \n');
+    x        = x0;
+    fval     = NaN;
+    exitflag = -1;
+    numeval  = 1;
+end
+%%% AFV: end of changes 19/04/17
+
+if iterprint
+    fprintf('Local solution function value: %g \n',fval);
+    fprintf('Number of function evaluations in the local search: %i \n',numeval);
+    fprintf('CPU Time of the local search: %f  seconds \n\n',toc);
+end
+
+initial_points=[initial_points; x0];
+
+%Careful with solnp and the reported number of evaluations
+
+nfuneval=nfuneval+numeval;
+if stage_1==1
+    stage_1=0;
+    stage_2=1;
+end
+
+%Evaluate the local solution
+[val,val_penalty,pena,nlc,include,x] = ssm_evalfc(x,x_L,x_U,fobj,nconst,c_L,c_U,...
+    tolc,weight,int_var,bin_var,varargin{:});
+nfuneval=nfuneval+1;
+if include && pena<=tolc
+    if val_penalty<fbest
+        fbest=val_penalty;
+        xbest=x;
+        if fbest<fbest_lastiter
+            Results.f=[Results.f fbest];
+            Results.x=[Results.x; xbest];
+            Results.time=[Results.time toc(tinit)];
+            Results.neval=[Results.neval nfuneval];
+            if plot_results==1
+                stairs(Results.time,Results.f)
+                xlabel('CPU Time (s)');
+                ylabel('Objective Function Value (-)');
+                title(strcat('Best f:  ',num2str(fbest)))
+                drawnow
+            end
+        end
+    end
+end
+
+%Check the stopping criterion
+if nfuneval>= maxeval
+    fin=1;
+    blacklist=ones(dim_refset);
+elseif toc(tinit)>=maxtime
+    fin=2;
+    blacklist=ones(dim_refset);
+elseif not(isempty(vtr))
+    if fbest<=vtr
+        fin=3;
+        blacklist=ones(dim_refset);
+    end
+end
+
+if include
+    if not(isempty(local_solutions))
+        %Add the found local solution to the list (if it is a new one)
+        adicionar_local=1;
+        [f,ind]=ssm_isdif2(x,local_solutions,1e-2,1);
+        %If it is too close to a previously found local solution, we do not
+        %add it
+        if f
+            adicionar_local=0;
+        end
+    else
+        %Add it if no local solutions have been found yet
+        adicionar_local=1;
+    end
+    if adicionar_local==1
+
+        %choose either this (replace the worst element in Refset)
+
+        %         [aaa,jjj]=max(Refset_values_penalty);
+        %
+        %         if val_penalty<Refset_values_penalty(jjj)
+        %             Refset(jjj,:)=x;
+        %             Refset_values(jjj)=val;
+        %             Refset_values_penalty(jjj)=val_penalty;
+        %             Refset_nlc(jjj,:)=nlc;
+        %             penalty(jjj)=pena;
+        %         end
+
+        %or this (Replace the initial point)
+
+        %         if val_penalty<f0
+        %             child(I,:)=x;
+        %             child_values(I)=val;
+        %             child_values_penalty(I)=val_penalty;
+        %             child_nlc(I,:)=nlc;
+        %         end
+
+        %or this (Replace the parent of the initial point)
+
+        if val_penalty<Refset_values_penalty(child_parent_index(I))
+            Refset(child_parent_index(I),:)=x;
+            Refset_values(child_parent_index(I))=val;
+            Refset_values_penalty(child_parent_index(I))=val_penalty;
+            Refset_nlc(child_parent_index(I),:)=nlc;
+            penalty(child_parent_index(I))=pena;
+
+            refset_change(child_parent_index(I))=0;
+        end
+        local_solutions=[local_solutions;x];
+        local_solutions_values=[local_solutions_values;fval];
+    end
+end
+
diff --git a/Requirements/MEIGO/eSS/eucl_dist note.txt b/Requirements/MEIGO/eSS/eucl_dist note.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b99629d48be3037e00c2aa261e7309e7c7f7778
--- /dev/null
+++ b/Requirements/MEIGO/eSS/eucl_dist note.txt	
@@ -0,0 +1,14 @@
+The script eucl_dist.m was originally created by Roland Bunschoten (see below) and was downloaded for The Mathworks -  Matlab Central - File Exchange
+
+http://www.mathworks.com/matlabcentral/fileexchange/loadCategory.do
+
+
+% Author   : Roland Bunschoten
+%            University of Amsterdam
+%            Intelligent Autonomous Systems (IAS) group
+%            Kruislaan 403  1098 SJ Amsterdam
+%            tel.(+31)20-5257524
+%            bunschot@wins.uva.nl
+
+
+Type help eucl_dist for more info
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/eucl_dist.m b/Requirements/MEIGO/eSS/eucl_dist.m
new file mode 100644
index 0000000000000000000000000000000000000000..578b719ae09909b964d51cc1fc4c3968da2b0e35
--- /dev/null
+++ b/Requirements/MEIGO/eSS/eucl_dist.m
@@ -0,0 +1,47 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/eucl_dist.m 770 2013-08-06 09:41:45Z attila $
+function d = distance(a,b)
+% DISTANCE - computes Euclidean distance matrix
+%
+% E = distance(A,B)
+%
+%    A - (DxM) matrix 
+%    B - (DxN) matrix
+%
+% Returns:
+%    E - (MxN) Euclidean distances between vectors in A and B
+%
+%
+% Description : 
+%    This fully vectorized (VERY FAST!) m-file computes the 
+%    Euclidean distance between two vectors by:
+%
+%                 ||A-B|| = sqrt ( ||A||^2 + ||B||^2 - 2*A.B )
+%
+% Example : 
+%    A = rand(400,100); B = rand(400,200);
+%    d = distance(A,B);
+%
+% Author   : Roland Bunschoten
+%            University of Amsterdam
+%            Intelligent Autonomous Systems (IAS) group
+%            Kruislaan 403  1098 SJ Amsterdam
+%            tel.(+31)20-5257524
+%            bunschot@wins.uva.nl
+% Last Rev : Oct 29 16:35:48 MET DST 1999
+% Tested   : PC Matlab v5.2 and Solaris Matlab v5.3
+% Thanx    : Nikos Vlassis
+%
+% Copyright notice: You are free to modify, extend and distribute 
+%    this code granted that the author of the original code is 
+%    mentioned as the original author of the code.
+
+if (nargin ~= 2)
+   error('Not enough input arguments');
+end
+
+if (size(a,1) ~= size(b,1))
+   error('A and B should be of same dimensionality');
+end
+
+aa=sum(a.*a,1); bb=sum(b.*b,1); ab=a'*b; 
+d = sqrt(abs(repmat(aa',[1 size(bb,2)]) + repmat(bb,[size(aa,2) 1]) - 2*ab));
diff --git a/Requirements/MEIGO/eSS/get_CeSS_options.m b/Requirements/MEIGO/eSS/get_CeSS_options.m
new file mode 100644
index 0000000000000000000000000000000000000000..9eb558d230ad09e1eda5414eb7b97d9b076fd186
--- /dev/null
+++ b/Requirements/MEIGO/eSS/get_CeSS_options.m
@@ -0,0 +1,50 @@
+function par_struct = get_CeSS_options(problem,opts) 
+
+	%--- Optimization settings, different for each thread: ----------------
+	dim1 = 0.5;   bal1 = 0;     n2_1 = 0;
+	dim2 = 1;     bal2 = 0;     n2_2 = 0;
+	dim3 = 2;     bal3 = 0;     n2_3 = 2;
+	dim4 = 3;     bal4 = 0;     n2_4 = 4;
+	dim5 = 5;     bal5 = 0.25;  n2_5 = 7;
+	dim6 = 5;     bal6 = 0.25;  n2_6 = 10;
+	dim7 = 7.5;   bal7 = 0.25;  n2_7 = 15;
+	dim8 = 10;    bal8 = 0.5;   n2_8 = 20;
+	dim9 = 12;    bal9 = 0.25;  n2_9 = 50;
+	dim10 = 15;   bal10 = 0.25; n2_10 = 100;
+
+	dim = [dim1 dim2 dim3 dim4 dim5 dim6 dim7 dim8 dim9 dim10];
+	bal = [bal1 bal2 bal3 bal4 bal5 bal6 bal7 bal8 bal9 bal10];
+	n2  = [n2_1 n2_2 n2_3 n2_4 n2_5 n2_6 n2_7 n2_8 n2_9 n2_10];
+
+	solver = {0,'dhc',0,'dhc',0,'dhc',0,'dhc',0,'dhc'}; % {'fmincon','dhc','fmincon','dhc','fmincon','dhc','fmincon','dhc','fmincon','dhc'}; 
+	finish = solver;
+    
+	opts.local.tol = 2;        
+	opts.local.iterprint = 0;
+    
+    %--- Create options structure for the parallel threads: ---------------
+	counter = 0;
+    for i=1:opts.n_threads
+		counter                          = counter+1;
+		par_struct(i).opts               = opts;
+		par_struct(i).problem            = problem;
+		nnn                              = roots([1  -1 -dim(counter)*numel(problem.x_L)]);
+		iii                              = find(nnn>0);
+		par_struct(i).opts.dim_refset    = ceil(nnn(iii));
+		par_struct(i).opts.local.balance = bal(counter);
+		par_struct(i).opts.local.n2      = n2(counter);
+        par_struct(i).opts.local.solver  = solver{counter}; 
+	    par_struct(i).opts.local.finish  = finish{counter};
+        if strcmpi(par_struct(i).opts.local.solver,'fmincon')
+            par_struct(i).opts.local.use_gradient_for_finish = 1; 
+        else
+            par_struct(i).opts.local.use_gradient_for_finish = 0;
+        end            
+        par_struct(i).opts.local.check_gradient_for_finish = 0; 
+		%If there are more than 10 threads, restart counter:
+		if(mod(counter,10)==0)
+			counter = 0;
+		end
+	end
+	
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/evaluate_grad.m b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/evaluate_grad.m
new file mode 100644
index 0000000000000000000000000000000000000000..1ad25fbbdeb1cfe347de4467a49622e0e6070ee7
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/evaluate_grad.m
@@ -0,0 +1,30 @@
+function [ df,dg,nfunc ] = evaluate_grad( x,f,g,ncont,nfunc,m,df,dg,FUN,neq,fobj,varargin)
+
+
+%EVAL_GRAD Gradient evaluation
+%
+    eps = 1.0d-7;
+
+    %gradients only for continuous variables
+    index=ncont;
+    feps=0;
+    wa1=zeros(1,m);
+    %nfunc=0;
+    for i=1:index
+        epsa = eps*max(1.0d-5,abs(x(i)));
+        epsi=1.0d0/epsa;
+        x(i)=x(i)+epsa;
+        [ feps,wa1 ] = ...
+            feval(FUN, x,neq,fobj,varargin{:});
+
+        nfunc=nfunc+1;
+
+        df(i)=epsi*(feps-f);
+        for j=1:m
+            dg(j,i)=epsi*(wa1(j)-g(j));
+        end
+        x(i)=x(i)-epsa;
+    end
+end
+
+
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/mi_sqp.m b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/mi_sqp.m
new file mode 100644
index 0000000000000000000000000000000000000000..031cbd2bc2002a5adaabe014ef008a6430e16a79
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/mi_sqp.m
@@ -0,0 +1,230 @@
+% ***********************************************************************
+% 
+% 
+%         AN IMPLEMENTATION OF A TRUST REGION METHOD FOR SOLVING
+%             MIXED-INTEGER NONLINEAR OPTIMIZATION PROBLEMS 
+% 
+% 
+%    MISQP SOLVES THE MIXED-INTEGER NONLINEAR PROGRAM (MINLP)
+% 
+%              MINIMIZE        F(X,Y)
+%              SUBJECT TO      G(J)(X,Y)   =  0  , J=1,...,ME
+%                              G(J)(X,Y)  >=  0  , J=ME+1,...,M
+%                              XL  <=  X  <=  XU
+%                              YL  <=  Y  <=  YU
+% 
+%    WHERE X IS A REAL AND Y AN INTEGER VARIABLE VECTOR.
+% 
+%    THE FORTRAN SUBROUTINE IS AN IMPLEMENTATION OF A MODIFIED SEQUENTIAL 
+%    QUADRATIC PROGRAMMING (SQP) METHOD. UNDER THE ASSUMPTION THAT INTEGER 
+%    VARIABLES HAVE A 'SMOOTH' INFLUENCE ON THE MODEL FUNCTIONS, I.E., THAT 
+%    FUNCTION VALUES DO NOT CHANGE TOO DRASTICALLY WHEN IN- OR DECREMENTING 
+%    AN INTEGER VALUE, SUCCESSIVE QUADRATIC APPROXIMATIONS ARE APPLIED.
+%    THE ALGORITHM IS STABILIZED BY A TRUST REGION METHOD WITH YUAN'S SECOND 
+%    ORDER CORRECTIONS. 
+% 
+%    IT IS NOT ASSUMED THAT THE MIXED-INTEGER PROGRAM IS RELAXABLE. IN OTHER 
+%    WORDS, FUNCTION VALUES ARE REQUIRED ONLY AT INTEGER POINTS. THE HESSIAN 
+%    OF THE LAGRANGIAN FUNCTION IS APPROXIMATED BY BFGS UPDATES SUBJECT TO 
+%    THE CONTINUOUS VARIABLES. DIAGONAL SECOND ORDER INFORMATION SUBJECT TO 
+%    THE INTEGER VARIABLES IS OBTAINED BY A DIFFERENCE FORMULA.
+% 
+% 
+%    USAGE:
+% 
+%       [x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = mi_sqp(m,me,mme,n,nint,nbin,x,f,g,...
+% 	df,dg,u,xl,xu,b,acc,accqp,maxit,maxpen,maxund,iprint,mode,ifail,rw,lrw,iw,...
+% 	liw,lw,llw)
+% 
+% 
+%    ARGUMENTS: (NMAX=N+1, MMAX=M+ME+1)
+% 
+%    M :       TOTAL NUMBER OF CONSTRAINTS.
+%    ME :      NUMBER OF EQUALITY CONSTRAINTS.
+%    N :       NUMBER OF OPTIMIZATION VARIABLES, CONTINUOUS AND INTEGER ONES.
+%    NINT :    NUMBER OF INTEGER VARIABLES, MUST BE LESS THAN OR EQUAL TO N.
+%    NBIN :    NUMBER OF BINARY VARIABLES, MUST BE LESS THAN OR EQUAL TO N.
+%    MME :     MUST BE EQUAL TO M+ME
+%    X(N+1) :  INITIALLY, X HAS TO CONTAIN STARTING VALUES. ON RETURN, X IS
+%              REPLACED BY THE CURRENT ITERATE. IN THE DRIVING PROGRAM
+%              THE ROW DIMENSION OF X HAS TO BE EQUAL TO NMAX.
+%    F :       F CONTAINS THE ACTUAL OBJECTIVE FUNCTION VALUE EVALUATED AT X.
+%    G(MME+1) : G CONTAINS THE ACTUAL CONSTRAINT FUNCTION VALUES AT X.
+%    DF(N+1) : DF CONTAINS THE GRADIENT OF THE OBJECTIVE FUNCTION.
+%    DG(MME+1,N+1) : DG CONTAINS GRADIENTS OF CONSTRAINTS IN THE FIRST M ROWS. 
+%              IN THE DRIVING PROGRAM THE ROW DIMENSION OF DG MUST BE EQUAL TO 
+%              MMAX.
+%    U(M+N+N) :  ON RETURN, U CONTAINS MULTIPLIERS. THE FIRST M LOCATIONS CONTAIN
+%              THE MULTIPLIERS OF THE M NONLINEAR CONSTRAINTS, THE SUBSEQUENT
+%              N LOCATIONS THE MULTIPLIERS SUBJECT TO THE LOWER BOUNDS, AND THE
+%              FINAL N LOCATIONS THE MULTIPLIERS SUBJECT TO THE UPPER BOUNDS.
+%              AT AN OPTIMAL SOLUTION, ALL MULTIPLIERS WITH RESPECT TO
+%              INEQUALITY CONSTRAINTS SHOULD BE NONNEGATIVE.
+%    XL(N+1),XU(N+1) : ON INPUT, THE ONE-DIMENSIONAL ARRAYS XL AND XU MUST
+%              CONTAIN THE UPPER AND LOWER BOUNDS OF THE VARIABLES.
+%    B(N+1,N+1) : ON RETURN, B CONTAINS THE LAST COMPUTED APPROXIMATION
+%              OF THE HESSIAN MATRIX OF THE LAGRANGIAN FUNCTION. 
+%              IN THE DRIVING PROGRAM, THE ROW DIMENSION OF C HAS TO BE EQUAL
+%              TO NMAX.
+%    ACC :     THE USER HAS TO SPECIFY THE DESIRED FINAL ACCURACY
+%              (E.G. 1.0D-7). THE TERMINATION ACCURACY SHOULD NOT BE SMALLER
+%              THAN THE ACCURACY BY WHICH GRADIENTS ARE COMPUTED. IF ACC IS
+%              LESS OR EQUAL TO ZERO, THEN THE MACHINE PRECISION IS COMPUTED 
+%              BY MISQP AND SUBSEQUENTLY MULTIPLIED BY 1.0D+4.
+%    ACCQP :   THE TOLERANCE IS NEEDED FOR THE QP SOLVER TO PERFORM SEVERAL 
+%              TESTS, FOR EXAMPLE WHETHER OPTIMALITY CONDITIONS ARE SATISFIED
+%              OR WHETHER A NUMBER IS CONSIDERED AS ZERO OR NOT. IF ACCQP IS
+%              LESS OR EQUAL TO ZERO, THEN THE MACHINE PRECISION IS COMPUTED 
+%              BY MISQP AND SUBSEQUENTLY MULTIPLIED BY 1.0D+4.
+%    MAXIT :   MAXIMUM NUMBER OF ITERATIONS, WHERE ONE ITERATION CORRESPONDS TO 
+%              ONE EVALUATION OF A SET OF GRADIENTS (E.G. 100).
+%    MAXPEN :  MAXIMUM NUMBER OF SUCCESSIVE INCREMENTS OF THE PENALTY PARAMETER
+%              WITHOUT SUCCESS (E.G. 50).
+%    MAXUND :  MAXIMUM NUMBER OF SUCCESSIVE ITERATIONS WITHOUT IMPROVEMENTS OF
+%              THE ITERATE X (E.G. 10).
+%    IPRINT :  SPECIFICATION OF THE DESIRED OUTPUT LEVEL.
+%       IPRINT = 0 :  NO OUTPUT OF THE PROGRAM.
+%       IPRINT = 1 :  ONLY A FINAL CONVERGENCE ANALYSIS IS GIVEN.
+%    MODE :    THE PARAMETER SPECIFIES THE DESIRED VERSION OF MISQP.
+%              FOR MODE<4, DERIVATIVE APPROXIMATIONS SUBJECT TO THE INTEGER
+%              VARIABLES ARE CALCULATED BY MISQP, AND ARE OTHERWISE TO BE
+%              PROVIDED BY THE USER. 
+%       MODE = 0 :    NORMAL EXECUTION (REVERSE COMMUNICATION!).
+%       MODE = 1 :    THE USER PROVIDES AN INITIAL GUESS FOR THE PENALTY
+%                     PARAMETER SIGMA, THE SCALING CONSTANT DELTA, AND THE 
+%                     INITIAL TRUST REGION RADII ITRC AND ITRI FOR CONTINUOUS 
+%                     AND INTEGER VARIABLES IN RW(1), RW(2), RW(3), AND RW(4). 
+%                     DEFAULT VALUES ARE     
+%                         RW(1) = 1.0D+1
+%                         RW(2) = 1.0D-2
+%                         RW(3) = 1.0D+1      
+%                         RW(4) = 1.0D+1     
+%    IFAIL :   THE PARAMETER SHOWS THE REASON FOR TERMINATING A SOLUTION
+%              PROCESS. INITIALLY IFAIL MUST BE SET TO ZERO. ON RETURN IFAIL
+%              COULD CONTAIN THE FOLLOWING VALUES:
+%       IFAIL =-2 :   COMPUTE GRADIENT VALUES SUBJECT TO THE VARIABLES STORED IN
+%                     X, AND STORE THEM IN DF AND DG. THEN CALL MISQP AGAIN, 
+%                     SEE BELOW.
+%       IFAIL =-1 :   COMPUTE OBJECTIVE FUNCTION AND ALL CONSTRAINT VALUES SUBJECT
+%                     THE VARIABLES FOUND IN X, AND STORE THEM IN F AND G. 
+%                     THEN CALL MISQP AGAIN, SEE BELOW.
+%       IFAIL = 0 :   THE OPTIMALITY CONDITIONS ARE SATISFIED.
+%       IFAIL = 1 :   THE ALGORITHM HAS BEEN STOPPED AFTER MAXIT ITERATIONS.
+%       IFAIL = 2 :   THERE ARE TOO MANY SUBITERATIONS TO FIX THE TRUST REGION,
+%                     MORE THAN MAXUND. 
+%       IFAIL = 3 :   THERE ARE MORE THAN MAXPEN CORRECTIONS OF THE PENALTY 
+%                     PARAMETER WITHOUT IMPROVEMENTS.
+%       IFAIL = 4 :   SEARCH ALGORITHM STOPPED, BUT THE FINAL ITERATE IS STILL 
+%                     INFEASIBLE.
+%       IFAIL = 5 :   SEARCH ALGORITHM STOPPED AND THE TRUST REGION RADIUS OF THE 
+%                     INTEGER VARIABLES IS 0. 
+%       IFAIL = 6 :   LENGTH OF A WORKING ARRAY IS TOO SHORT.
+%       IFAIL = 7 :   THERE ARE FALSE DIMENSIONS, FOR EXAMPLE M>MMAX OR N>=NMAX.
+%       IFAIL > 90 :  THE SOLUTION OF THE QUADRATIC PROGRAMMING SUBPROBLEM HAS BEEN 
+%                     TERMINATED WITH AN ERROR MESSAGE AND IFAIL IS SET TO IFQL+100.
+%       RW(LRW),LRW : RW IS A REAL WORKING ARRAY OF LENGTH LRW. LRW MUST BE 
+%                     AT LEAST lrw=100+19*max(1,m)+23*max(1,n)+max(1,m)*max(1,n).
+%       IW(LIW),LIW : THE USER HAS TO PROVIDE WORKING SPACE FOR AN INTEGER ARRAY
+%                     OF LENGTH LIW. LIW MUST BE AT LEAST max(nint+nbin,1)+15.
+%       LW(LLW),LLW : THE USER HAS TO PROVIDE WORKING SPACE FOR A LOGICAL ARRAY
+%                     OF LENGTH LLW. LLW MUST BE AT LEAST 15.
+% 
+% working arrays
+% 
+% lrw=100+19*max(1,m)+23*max(1,n)+max(1,m)*max(1,n);
+% rw=zeros(1,lrw);
+% liw=max(nint+nbin,1)+15;
+% iw=zeros(1,liw);
+% llw=15;
+% lw=zeros(1,llw);
+% 
+% 
+%    FUNCTION AND GRADIENT EVALUATION:
+% 
+%    THE USER HAS TO PROVIDE FUNCTIONS AND GRADIENTS IN THE SAME PROGRAM, WHICH
+%    EXECUTES ALSO MISQP, ACCORDING TO THE FOLLOWING RULES:
+% 
+%    1) CHOOSE STARTING VALUES FOR THE VARIABLES TO BE OPTIMIZED, AND STORE
+%       THEM IN X.
+% 
+%    2) COMPUTE OBJECTIVE AND ALL CONSTRAINT FUNCTION VALUES VALUES AT X AND
+%       STORE THEM IN F AND G, RESPECTIVELY. 
+% 
+%    3) COMPUTE GRADIENTS OF OBJECTIVE FUNCTION AND ALL CONSTRAINTS, AND
+%       STORE THEM IN DF AND DG, RESPECTIVELY. THE J-TH ROW OF DG CONTAINS
+%       THE GRADIENT OF THE J-TH CONSTRAINT, J=1,...,M. IN CASE OF MODE<4, 
+%       ONLY PARTIAL DERIVATIVES SUBJECT TO THE CONTINUOUS VARIABLES NEED TO 
+%       BE PROVIDED.
+% 
+%    4) SET IFAIL=0 AND EXECUTE MISQP.
+% 
+%    5) IF MISQP TERMINATES WITH IFAIL=0, THE INTERNAL STOPPING CRITERIA ARE 
+%       SATISFIED. 
+% 
+%    6) IN CASE OF IFAIL>0, AN ERROR OCCURRED.
+% 
+%    7) IF MISQP RETURNS WITH IFAIL=-1, COMPUTE OBJECTIVE FUNCTION VALUES AND
+%       CONSTRAINT VALUES FOR ALL VARIABLES FOUND IN X, STORE THEM IN F AND G,
+%       AND CALL MISQP AGAIN. 
+% 
+%    8) IF MISQP TERMINATES WITH IFAIL=-2, COMPUTE GRADIENT VALUES SUBJECT TO
+%       VARIABLES STORED IN X, AND STORE THEM IN DF AND DG. IN CASE OF MODE<4, 
+%       ONLY PARTIAL DERIVATIVES SUBJECT TO THE CONTINUOUS VARIABLES NEED TO 
+%       BE PROVIDED. THEN CALL MISQP AGAIN.
+% 
+% 
+% ***********************************************************************
+%             [NAGWare Gateway Generator]
+%
+%Copyright (c) 1993-97 by the Numerical Algorithms Group Ltd 2.0a
+%
+%
+% maximal n=100 and m=100 !!!!!!!!!!!
+%
+%m                                     integer
+%me                                    integer
+%mme                                   integer
+%n                                     integer
+%nint                                  integer
+%nbin                                  integer
+%x (n+1)                               real
+%f                                     real
+%g (mme+1)                             real
+%df (n+1)                              real
+%dg (mme+1,n+1)                        real
+%u (m+n+n)                             real
+%xl (n+1)                              real
+%xu (n+1)                              real
+%b (n+1,n+1)                           real
+%acc                                   real
+%accqp                                 real
+%maxit                                 integer
+%maxpen                                integer
+%maxund                                integer
+%iprint                                integer
+%mode                                  integer
+%ifail                                 integer
+%rw (lrw)                              real
+%lrw                                   integer
+%iw (liw)                              integer
+%liw                                   integer
+%lw (llw)                              logical
+%llw                                   integer
+%
+%[x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = mi_sqp(m,me,mme,n,nint,nbin,x,f,g,...
+%df,dg,u,xl,xu,b,acc,accqp,maxit,maxpen,maxund,iprint,mode,ifail,rw,lrw,iw,...
+%liw,lw,llw)
+%
+%
+ function [x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = mi_sqp(m,me,mme,n,nint,...
+ nbin,x,f,g,df,dg,u,xl,xu,b,acc,accqp,maxit,maxpen,maxund,iprint,mode,ifail,...
+ rw,lrw,iw,liw,lw,llw)
+%
+%
+%
+%Call the MEX function
+%
+ [x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = mi_sqpg(m,me,...
+ mme,n,nint,nbin,x,f,g,df,dg,u,xl,xu,b,acc,accqp,maxit,...
+ maxpen,maxund,iprint,mode,ifail,rw,lrw,iw,liw,lw,llw);
+%
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqp.m b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqp.m
new file mode 100644
index 0000000000000000000000000000000000000000..961f78d66e2ca8fd077a363cec8d7c13d94e079e
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqp.m
@@ -0,0 +1,286 @@
+ function [x,f,g,df,dg,u,xl,xu,b,ifail,rw,lrw,iw,liw,lw,...
+ llw] = misqp(m,me,n,nint,nbin,x,...
+ f,g,df,dg,u,xl,xu,b,acc,accqp,maxit,maxpen,maxund,resopt,nonmon,iprint,mode,...
+ ifail,rw,lrw,iw,liw,lw,llw)
+% ***********************************************************************
+% 
+%
+%    In order to speed up the interface, this version is limited to
+%    n <= 1000
+%    m <= 1000
+%    
+%    
+% 
+%         An Implementation of a Trust Region Method for Solving
+%             Mixed-Integer Nonlinear Optimization Problems 
+% 
+% 
+%    MISQP solves the mixed-integer nonlinear program (MINLP)
+% 
+%              minimize        F(X,Y)
+%              subject to      G(J)(X,Y)   =  0  , J=1,...,ME
+%                              G(J)(X,Y)  >=  0  , J=ME+1,...,M
+%                              XL  <=  X  <=  XU
+%                              YL  <=  Y  <=  YU
+% 
+%    where X is a real and y an integer variable vector.
+% 
+%    The Fortran subroutine is an implementation of a modified sequential 
+%    quadratic programming (SQP) method. Under the assumption that integer 
+%    variables have a 'smooth' influence on the model functions, i.e., that 
+%    function values do not change too drastically when in- or decrementing 
+%    an integer value, successive quadratic approximations are applied.
+%    The algorithm is stabilized by a trust region method with Yuan's second 
+%    order corrections. 
+% 
+%    It is not assumed that the mixed-integer program is relaxable. In other 
+%    words, function values are required only at integer points. The Hessian 
+%    of the Lagrangian function is approximated by BFGS updates subject to 
+%    the continuous variables. Derivative information subject to the integer 
+%    variables is obtained by a difference formula evaluated at grid points.
+% 
+% 
+%    USAGE:
+% 
+%       [x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = misqp(m,me,n,nint,nbin,x,...
+%                      f,g,df,dg,u,xl,xu,b,acc,accqp,maxit,maxpen,maxund,...
+%                      resopt,nonmon,iprint,mode,ifail,rw,lrw,iw,liw,lw,llw)
+% 
+% 
+%    ARGUMENTS:
+% 
+%    M :       Total number of constraints.
+%    ME :      Number of equality constraints.
+%    N :       Number of optimization variables, continuous and integer ones.
+%    NINT :    Number of integer variables, must be less than or equal to N.
+%    NBIN :    Number of binary variables, must be less than or equal to N.
+%    MNN :     Must be equal to M+N+N, dimensioning parameter of multiplier 
+%              vector.
+%    X(N+1) :    Initially, X has to contain starting values. On return, X is
+%              replaced by the current iterate. In the driving program
+%              the row dimension of X has to be equal to NMAX.
+%              X contains first the continuous, then the integer followed by
+%              the binary variables.
+%    F :       F contains the actual objective function value evaluated at X.
+%    G(M+ME+1) :  G contains the actual constraint function values at X.
+%    DF(N+1) :  DF contains the gradient values of the objective function.
+%    DG(M+ME+1,N+1) :  DG contains the gradient values of constraints
+%              in the first M rows. In the driving program, the row dimension
+%              of DG has to be equal to MMAX.
+%    U(M+N+N) :  On return, the first M locations contain
+%              the multipliers of the M nonlinear constraints, the subsequent
+%              N locations the multipliers subject to the lower bounds, and the
+%              final N locations the multipliers subject to the upper bounds.
+%              At an optimal solution, all multipliers with respect to
+%              inequality constraints should be nonnegative.
+%    XL(N+1),XU(N+1) :  On input, the one-dimensional arrays XL and XU must
+%              contain the upper and lower bounds of the variables, first
+%              for the continuous, then for the integer and subsequently for 
+%              the binary variables.
+%    B(N+1,N+1) :  On return, B contains the last computed approximation
+%              of the Hessian matrix of the Lagrangian function.
+%              In the driving program, the row dimension of C has to be equal
+%              to NMAX. 
+%    ACC :     The user has to specify the desired final accuracy
+%              (e.g. 1.0D-7). The termination accuracy should not be smaller
+%              than the accuracy by which gradients are computed. If ACC is
+%              less or equal to zero, then the machine precision is computed
+%              by MISQP and subsequently multiplied by 1.0D+4.
+%    ACCQP :   The tolerance is needed for the QP solver to perform several
+%              tests, for example whether optimality conditions are satisfied
+%              or whether a number is considered as zero or not. If ACCQP is
+%              less or equal to zero, then the machine precision is computed
+%              by MISQP and subsequently multiplied by 1.0D+4.
+%    MAXIT :   Maximum number of iterations, where one iteration corresponds to
+%              one evaluation of a set of gradients (e.g. 100).
+%    MAXPEN :  Maximum number of successive increments of the penalty parameter 
+%              without success (e.g. 50).
+%    MAXUND :  Maximum number of successive iterations without improvements
+%              of the iterate X (e.g. 10).
+%    RESOPT :  If set to TRUE and if integer variables exist, an additional 
+%              restart will be performed to check whether an improvement 
+%              is possible (recommended for functions with curved narrow valleys).
+%    NONMON :  Maximum number of successive iterations, which are to be 
+%              considered for the non-monotone trust region algorithm.
+%    IPRINT :  Specification of the desired output level.
+%           0 :  No output of the program.
+%           1 :  Only a final convergence analysis is given.
+%           2 :  One line of intermediate results is printed in each iteration.
+%           3 :  More detailed information is printed for each iteration.
+%           4 :  In addition, some messages of the QP solver are displayed.
+%    MODE :   The parameter allows to change some default tolerances.
+%           0 :   Use default values.
+%           1 :   User-provided penalty parameter SIGMA, scaling constant DELTA, 
+%                 and initial trust region radii ITRC and ITRI for continuous
+%                 and integer variables in RW(1), RW(2), RW(3), and RW(4).
+%                 Default values are
+%                   RW(1) = 10.0
+%                   RW(2) = 0.01 
+%                   RW(3) = 10.0
+%                   RW(4) = 10.0
+%    IOUT :    Integer indicating the desired output unit number, i.e., all
+%              write-statements start with 'WRITE(IOUT,... '.
+%    IFAIL :   The parameter shows the reason for terminating a solution
+%              process. Initially IFAIL must be set to zero. On return IFAIL
+%              could contain the following values:
+%          -2 :   Compute new gradient values in DF and DG, see above.
+%          -1 :   Compute new function values in F and G, see above.
+%           0 :   Optimality conditions satisfied.
+%           1 :   Termination after MAXIT iterations.
+%           2 :   More than MAXUND iterations for fixing trust region.
+%           3 :   More than MAXPEN updates of penalty parameter.
+%           4 :   Termination at infeasible iterate.
+%           5 :   Termination with zero trust region for integer variables.
+%           6 :   Length of a working array is too short.
+%           7 :   False dimensions, e.g., M$>$MMAX or N$>$=NMAX.
+%         >90 :   QP solver terminated with an error message IFQL, 
+%                 IFAIL = IFQL + 100.
+%    RW(LRW),LRW :  Real working array of length LRW, and LRW must be
+%                 at least 21*N + 10*M + 5*ME + 2*NONMON + 73.
+%    IW(LIW),LIW :  Integer working array of length LIW, where LIW must be 
+%                 at least (NINT+NBIN) + 14.
+%    LW(LLW),LLW :  Logical working array of length LLW, where LLW must be
+%                 at least 15.
+% 
+% 
+%    FUNCTION AND GRADIENT EVALUATION:
+% 
+%    The user has to provide functions and gradients in the same program, which
+%    executes also misqp, according to the following rules:
+% 
+%    1) Choose starting values for the variables to be optimized, and store
+%       them in X.
+% 
+%    2) Compute objective and all constraint function values values at X and
+%       store them in F and G, respectively. 
+% 
+%    3) Compute gradients of objective function and all constraints, and
+%       store them in DF and DG, respectively. The j-th row of DG contains
+%       the gradient of the j-th constraint, j=1,...,m. 
+% 
+%    4) Set IFAIL=0 and execute MISQP.
+% 
+%    5) If MISQP terminates with IFAIL=0, the internal stopping criteria are 
+%       satisfied. 
+% 
+%    6) In case of IFAIL>0, an error occurred.
+% 
+%    7) If MISQP returns with IFAIL=-1, compute objective function values and
+%       constraint values for all variables found in X, store them in F and G,
+%       and call MISQP again. 
+% 
+%    8) If MISQP terminates with IFAIL=-2, compute gradient values subject to
+%       variables stored in X, and store them in DF and DG. Only partial 
+%       derivatives subject to the continuous variables need to be provided. 
+%       Then call MISQP again.
+% 
+% 
+% 
+% 
+%    AUTHOR:     O. Exler
+%    -------     Department of Computer Science
+%                University of Bayreuth
+%                95440 Bayreuth
+%                Germany
+% 
+% 
+% 
+%    VERSION:    2.2.1 (06/2008) 
+%    --------
+% 
+% 
+% ***********************************************************************
+%
+%m                                     integer
+%me                                    integer
+%n                                     integer
+%nint                                  integer
+%nbin                                  integer
+%x (n+1)                               real
+%f                                     real
+%g (m+me+1)                            real
+%df (n+1)                              real
+%dg (m+me+1,n+1)                       real
+%u (m+n+n)                             real
+%xl (n+1)                              real
+%xu (n+1)                              real
+%b (n+1,n+1)                           real
+%acc                                   real
+%accqp                                 real
+%maxit                                 integer
+%maxpen                                integer
+%maxund                                integer
+%resopt                                logical
+%nonmon                                integer
+%iprint                                integer
+%mode                                  integer
+%ifail                                 integer
+%rw (lrw)                              real
+%lrw                                   integer
+%iw (liw)                              integer
+%liw                                   integer
+%lw (llw)                              logical
+%llw                                   integer
+%
+%[x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = misqp(m,me,n,nint,nbin,x,f,g,df,dg,...
+%u,xl,xu,b,acc,accqp,maxit,maxpen,maxund,resopt,nonmon,iprint,mode,ifail,rw,...
+%lrw,iw,liw,lw,llw)
+%
+%
+
+if ifail==0
+% WOKSPACE allocation
+%  RW(LRW),LRW :  Real working array of length LRW, and LRW must be
+%                 at least 22*N + 11*M + 
+%                 + 6*ME + 2*NONMON + 85.
+%  IW(LIW),LIW :  Integer working array of length LIW, where LIW must be 
+%                 at least (NINT+NBIN) + 16.
+%  LW(LLW),LLW :  Logical working array of length LLW, where LLW must be
+%                 at least 15.
+
+    lrw=22*n+11*m+6*me+2*nonmon+85;
+    rw=zeros(1,lrw);
+    liw=nint+nbin+16;
+    iw=zeros(1,liw);
+    llw=15;
+    lw=zeros(1,llw);
+end
+%
+%Call the MEX function
+%
+ [x,f,g,df,dg,u,xl,xu,b,ifail,rw,iw,lw] = misqpg(m,me,n,...
+ nint,nbin,x,f,g,df,dg,u,xl,xu,b,acc,accqp,maxit,maxpen,...
+ maxund,resopt,nonmon,iprint,mode,ifail,rw,lrw,iw,liw,lw,...
+ llw);
+
+if (size(x,2)==1)
+    x = x';
+end
+if (size(g,2)==1)
+    g = g';
+end
+if (size(df,2)==1)
+    df = df';
+end
+% if (size(dg,2)==m+me+1)
+%     dg = dg';
+% end
+if (size(u,2)==1)
+    u = u';
+end
+if (size(xl,2)==1)
+    xl = xl';
+end
+if (size(xu,2)==1)
+    xu = xu';
+end
+if (size(rw,2)==1)
+    rw = rw';
+end
+if (size(iw,2)==1)
+    iw = iw';
+end
+if (size(lw,2)==1)
+    lw = lw';
+end
+
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.exp b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.exp
new file mode 100644
index 0000000000000000000000000000000000000000..1c6a49041f6910d0933ab61ce278af2828883e60
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.exp differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexa64 b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexa64
new file mode 100644
index 0000000000000000000000000000000000000000..d54d910433fb8bc6ec17f076c6811b8ce201516e
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexa64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexglx b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexglx
new file mode 100644
index 0000000000000000000000000000000000000000..2428af176ae180b1a8eb93d7b82883a602885218
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexglx differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexw32 b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexw32
new file mode 100644
index 0000000000000000000000000000000000000000..536f641764908f6e75c165a7d625f5ac81c19283
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexw32 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexw64 b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexw64
new file mode 100644
index 0000000000000000000000000000000000000000..95d90223a02e6d516867befd1ceff14c3cf2720e
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/misqpg.mexw64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/run_misqp.m b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/run_misqp.m
new file mode 100644
index 0000000000000000000000000000000000000000..34bbadaff98bb5a89ade0ee6a7d02507974e07bd
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/run_misqp.m
@@ -0,0 +1,113 @@
+function [x,f,nfunc,ifail,g]=run_misqp(ncont,nint,nbin,m,xl,xu,x0,acc,FUN,neq,fobj,varargin)
+
+n=nint+ncont+nbin;
+
+me=neq;
+
+
+x=x0;
+
+% ALLOCATION MEMORY LOCAL SOLVER MISQP
+f_ls=0;
+g_ls=zeros(1,m+me+1);
+x_ls=zeros(1,n+1);
+xl_ls=zeros(1,n+1);
+xu_ls=zeros(1,n+1);
+u=zeros(1,m+n+n);
+b=zeros(n+1,n+1);
+dg=zeros(m+me+1,n+1);
+df=zeros(1,n+1);
+
+% working arrays
+lrw=[];
+rw=[];
+liw=[];
+iw=[];
+llw=[];
+lw=[];
+
+
+ifail=0;
+maxit=500;
+maxpen=50;
+maxund=50;
+mode=0;
+%iprint=0;
+%accqp = 1.0d-12;
+accqp = 1e-6;
+%acc=1e-3;
+
+resopt=1;
+nonmon=2;
+
+
+mme= m + me;
+iprint=0;
+
+nfunc = 0;
+ngrad = 0;
+
+% Calculate function
+nfunc=nfunc+1;
+
+[ f,g ] = feval(FUN, x,neq,fobj,varargin{:} );  % here you have to specify your function
+% which calculates the function
+% values
+
+
+[ df,dg,nfunc ] = evaluate_grad( x,f,g,ncont,nfunc,m,df,dg,FUN,neq,fobj,varargin{:});
+ngrad = ngrad+1;
+
+f_ls=double(f);
+g_ls(1:m)=double(g(1:m));
+x_ls(1:n)=double(x);
+xl_ls(1:n)=double(xl);
+xu_ls(1:n)=double(xu);
+
+%keyboard
+
+while(ifail <= 0)
+    %   keyboard
+    [x_ls,f_ls,g_ls,df,dg,u,xl_ls,xu_ls,b,ifail,rw,lrw,iw,liw,lw,llw] = ...
+        misqp(m,me,n,nint,nbin,x_ls,...
+        f_ls,g_ls,df,dg,u,xl_ls,xu_ls,b,acc,accqp,...
+        maxit,maxpen,maxund,resopt,nonmon,iprint,mode,ifail,rw,lrw,...
+        iw,liw,lw,llw);
+    %  keyboard
+    if (ifail == -1)
+        % Calculate function
+        nfunc=nfunc+1;
+        [ f,g ] =...
+            feval(FUN, x_ls(1:n),neq,fobj,varargin{:} );  % here you have to specify your function
+        % which calculates the function
+        % values
+
+        f_ls=f;
+        g_ls(1:m)=g(1:m);
+    end
+    if (ifail == -2)
+        % Calculate gradients
+        ngrad=ngrad+1;
+        [df,dg,nfunc]=evaluate_grad( x_ls(1:n),f_ls,g_ls(1:m),ncont,nfunc,m,df,dg,FUN,neq,fobj,varargin{:});
+        % here you have to specify your function
+        % which calculates the gradients
+    end
+    if (ifail>=0)
+        break
+    end
+
+end
+
+x=x_ls(1:n);
+f=f_ls;
+g=g_ls(1:m);
+%  keyboard
+
+if size(x,1)>1
+    x=x';
+end
+
+disp(ifail);
+
+end
+
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/test_MISQP.m b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/test_MISQP.m
new file mode 100644
index 0000000000000000000000000000000000000000..0538ea99d2a43fc7cb637bea124255e0f54de815
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/test_MISQP.m
@@ -0,0 +1,18 @@
+                                      
+xl=[0 0 0 0];                                          
+xu=[10 10 10 10];                                    
+x0=[3 4 5 1];                                               
+nint=3;
+ncont=1;
+nbin=0;
+m=3;
+neq=3;
+acc=1e-6;
+FUN='test_f';
+GRAD='evaluate_grad';
+
+fobj='test_f';
+
+
+run_misqp(ncont,nint,nbin,m,xl,xu,x0,acc,FUN,[],neq,fobj,[])
+
diff --git a/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/test_f.m b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/test_f.m
new file mode 100644
index 0000000000000000000000000000000000000000..5638cec723409f7abf513ba247973f05c4c398cc
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/MISQP/bin/test_f.m
@@ -0,0 +1,9 @@
+function [F,g]=test_f(x,neq,fobj,varargin)
+ F = x(2)^2 + x(3)^2 + 2.0*x(1)^2 + x(4)^2 - 5.0*x(2) - 5.0*x(3) - 21.0*x(1) + 7.0*x(4);
+ g(1) = x(2)^2 + x(3)^2 + x(1)^2 + x(4)^2 + x(2) - x(3) + x(1) - x(4);
+ g(2) = x(2)^2 + 2.0*x(3)^2 + x(1)^2 + 2.0*x(4)^2 - x(2) - x(4);
+ g(3) = 2.0*x(2)^2 + x(3)^2 + x(1)^2 + 2.0*x(2) - x(3) - x(4);
+ 
+ fprintf(1,'Constraint Violation=%e   FObj=%e\n',sum(g),F);
+
+end
diff --git a/Requirements/MEIGO/eSS/local_solvers/bobyqa/LICENCE.txt b/Requirements/MEIGO/eSS/local_solvers/bobyqa/LICENCE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f40998729f9d20523f013c55b026d349c36a4ec
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/bobyqa/LICENCE.txt
@@ -0,0 +1,18 @@
+BOBYQA---Bound Optimization BY Quadratic Approximation.
+Copyright (C) 2009 M. J. D. Powell (University of Cambridge)
+
+This package is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This package is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Lesser General Public License
+ https://www.gnu.org/copyleft/lesser.html
+for more details.
+
+Michael J. D. Powell <mjdp@cam.ac.uk>
+University of Cambridge
+Cambridge, UK.
diff --git a/Requirements/MEIGO/eSS/local_solvers/bobyqa/bobyqa.m b/Requirements/MEIGO/eSS/local_solvers/bobyqa/bobyqa.m
new file mode 100644
index 0000000000000000000000000000000000000000..0b9ba4f8846ab00327d452f4b423c1ea4dd3d9a9
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/bobyqa/bobyqa.m
@@ -0,0 +1,114 @@
+function varargout = bobyqa(fun,x0,lb,ub,varargin)
+% MatLab wrapper for the mexbobyqa.F routine, which ports Powell's BOBYQA
+% routine to MatLab. mexbobyqa.F needs th have been compiled via mex
+% before.
+%
+% Input:
+% fun     : objective function to be minimized
+% x0      : initial guess for parameters
+% lb, ub  : bounds for parameters
+% options : struct with options for the algorithm:
+%   Rhobeg, Rhoend, MaxFunEvals : see algorithm definition
+%
+% Output:
+% x   : best guess for parameters
+% fval: objective function at the solution, generally fval=fun(x)
+% exitflag:
+%   1 : The function converged to a solution x
+%   0 : Number of iterations exceeded options.MaxIter or number of function
+%       evaluations exceeded options.MaxFunEvals.
+%   -1: The algorithm was terminated inappropriately
+% output : struct with meta information:
+%   funcCount   : number of function evaluations
+%   algorithm   : name of the algorithm
+%   t_cpu       : cpu time
+%
+% Currently has 2nd mode with 0 input arguments returning a function handle
+% used by funHandleWrap.m to compute objective function values. This is
+% because via mexCallMATLAB only non-anonymous functions (e.g. defined in a
+% file) or global function handles can be called, but pesto uses anonymous
+% function handles. ATTENTION: This might be non-thread-safe.
+%
+% The current interface to Powell'S BOBYQA routine is rather rudimentary,
+% so feel free to improve on this.
+
+%% save objective funtion
+
+% sorry for being global
+global bobyqafun_sfbg;
+
+if nargin == 0
+    varargout{1} = bobyqafun_sfbg;
+    return;
+end
+
+%% main part
+
+if ~exist('mexbobyqa', 'file')
+    error(sprintf(['The mexbobyqa file does not exist. Please compile it first\n',...
+		'by running the file compile_mexbobyqa.m in the bobyqa directory.']));
+end
+
+bobyqafun_sfbg = fun;
+
+% check for options
+if (nargin > 4)
+    options = varargin{1};
+else
+    options = struct();
+end
+
+% interpret parameters
+
+N       = length(x0);
+
+if (isfield(options,'Npt') && ~isempty(options.Npt))
+    NPT		= options.Npt;
+else
+    NPT  = 2*N+1;
+end
+
+X       = x0;
+LB      = lb;
+UB      = ub;
+
+CALFUN  = func2str(fun);
+
+if (isfield(options,'Rhobeg') && ~isempty(options.Rhobeg))
+    RHOBEG		= options.Rhobeg;
+else
+    RHOBEG  = 1e-1;
+end
+
+if (isfield(options,'Rhoend') && ~isempty(options.Rhoend))
+    RHOEND		= options.Rhoend;
+else
+    RHOEND  = 1e-8;
+end
+
+if (isfield(options,'MaxFunEvals') && ~isempty(options.MaxFunEvals))
+    MAXFUN		= options.MaxFunEvals;
+else
+    MAXFUN  = 1000*N;
+end
+
+IPRINT = 0; % no output
+
+% track time
+starttime = cputime;
+
+% do optimization
+[ x,fval,feval ] = mexbobyqa(N,NPT,X,LB,UB,CALFUN,RHOBEG,RHOEND,MAXFUN,IPRINT);
+
+% meta information
+output.funcCount = feval;
+output.algorithm = 'BOBYQA';
+output.t_cpu = cputime - starttime;
+exitflag = 1; % extract it from fortran if you need it
+
+% return
+varargout{1} = x;
+varargout{2} = fval;
+varargout{3} = exitflag;
+varargout{4} = output;
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/bobyqa/bobyqaFunHandleWrap.m b/Requirements/MEIGO/eSS/local_solvers/bobyqa/bobyqaFunHandleWrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..84b2d384d78fdea0505b32d93d539f30da548772
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/bobyqa/bobyqaFunHandleWrap.m
@@ -0,0 +1,17 @@
+function [ y ] = bobyqaFunHandleWrap(x, calfun)
+% This is a wrapper to compute the objective function value. 
+% Called from within the mexbobyqa routine. 
+% funHandleWrap currently uses a global variable in bobyqa.m, 
+% the argument calfun is not used.
+%
+% Input:
+%   x: parameter vector
+%   calfun: objective function handle or string representation
+%
+% Output:
+%   y: objective function value
+
+fun = bobyqa();
+y = fun(x);
+
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/bobyqa/compile_mexbobyqa.m b/Requirements/MEIGO/eSS/local_solvers/bobyqa/compile_mexbobyqa.m
new file mode 100644
index 0000000000000000000000000000000000000000..a67925cd728e4dae51cec55c03a333ec5cd38547
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/bobyqa/compile_mexbobyqa.m
@@ -0,0 +1,9 @@
+% Run this file once in order to compile the mexbobyqa.F file to the mexbobyqa.mex***
+% format, which can be recognized by Matlab. Then you will be able to use the 
+% bobyqa.m function.
+
+% Required: Your current Matlab installation must be connected to a Fortran compiler. 
+% For further information see: 
+% https://mathworks.com/help/matlab/build-fortran-mex-files-1.html
+
+mex mexbobyqa.F
diff --git a/Requirements/MEIGO/eSS/local_solvers/bobyqa/mexbobyqa.F b/Requirements/MEIGO/eSS/local_solvers/bobyqa/mexbobyqa.F
new file mode 100644
index 0000000000000000000000000000000000000000..2cf1aba967c27f6ef194e7aecdda9312e1a304ff
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/bobyqa/mexbobyqa.F
@@ -0,0 +1,2230 @@
+#include <fintrf.h>
+C	Input:
+C	N,NPT,X,LB,UB,CALFUN,RHOBEG,RHOEND,MAXFUN,IPRINT
+C 	Output:
+C 	X     (giving the least calculated function value)
+C 	F     (CALFUN(X))
+C 	FEVAL (number of function evaluations)
+	SUBROUTINE MEXFUNCTION(NLHS,PLHS,NRHS,PRHS)
+
+C		input and output variables
+		MWPOINTER PLHS(*), PRHS(*)
+		INTEGER*8 NLHS,NRHS
+		
+C		mex stuff
+		INTEGER*8 MEXCALLMATLAB
+		MWPOINTER MXCREATEDOUBLEMATRIX,MXGETPR	,MXCREATENUMERICMATRIX
+		MWSIZE MXGETM,MXGETN
+		
+C 		get lengths of variables
+		
+C 		more variables
+		MWPOINTER p
+		REAL*8 rN,rNPT
+		INTEGER*8 N,NPT,WORKSPACE
+		
+C 		check input
+		IF (NRHS .LT. 10) THEN
+			CALL MEXERRMSGTXT('Wrong number of inputs.')
+		END IF
+		
+		p = MXGETPR(PRHS(1))
+		CALL MXCOPYPTRTOREAL8(p,rN,1)
+		N = INT(rN)
+		
+		p = MXGETPR(PRHS(2))
+		CALL MXCOPYPTRTOREAL8(p,rNPT,1)
+		NPT = INT(rNPT)
+		
+		WORKSPACE = INT((NPT+5)*(NPT+N)+3*N*(N+5)/2)
+		
+		CALL MAIN(N,NPT,WORKSPACE,NLHS,PLHS,NRHS,PRHS)
+
+		RETURN
+		
+	END
+			
+	SUBROUTINE MAIN (N,NPT,WORKSPACE,NLHS,PLHS,NRHS,PRHS)
+		
+C		input and output variables
+		MWPOINTER PLHS(*), PRHS(*)
+		INTEGER*8 N,NPT,WORKSPACE,NLHS,NRHS
+		
+C		mex stuff
+		INTEGER*8 MEXCALLMATLAB
+		MWPOINTER MXCREATEDOUBLEMATRIX,MXGETPR
+		MWSIZE MXGETM,MXGETN
+		
+C		more variables
+		MWPOINTER p
+		REAL*8 rIPRINT,rMAXFUN,rFEVAL
+		INTEGER*8 IPRINT,MAXFUN,FEVAL
+		REAL*8 X(N),RHOBEG,RHOEND,LB(N),UB(N),W(WORKSPACE)
+		REAL*8 F
+		
+C       interpret input
+		
+		p = MXGETPR(PRHS(3))
+		CALL MXCOPYPTRTOREAL8(p,X,N)
+		
+		p = MXGETPR(PRHS(4))
+		CALL MXCOPYPTRTOREAL8(p,LB,N)
+		
+		p = MXGETPR(PRHS(5))
+		CALL MXCOPYPTRTOREAL8(p,UB,N)
+		
+C 		simply take FUN from PRHS(6)
+		
+		p = MXGETPR(PRHS(7))
+		CALL MXCOPYPTRTOREAL8(p,RHOBEG,1)
+		
+		p = MXGETPR(PRHS(8))
+		CALL MXCOPYPTRTOREAL8(p,RHOEND,1)
+		
+		p = MXGETPR(PRHS(9))
+		CALL MXCOPYPTRTOREAL8(p,rMAXFUN,1)
+		MAXFUN = INT(rMAXFUN)
+		
+		p = MXGETPR(PRHS(10))
+		CALL MXCOPYPTRTOREAL8(p,rIPRINT,1)
+		IPRINT = INT(rIPRINT)	
+		
+C 		count function evaluations
+		FEVAL = 7
+		
+C 		do optimization
+		
+		CALL BOBYQA (N,NPT,X,LB,UB,RHOBEG,RHOEND,IPRINT,MAXFUN,W)
+		
+C 		write output
+		
+		PLHS(1) = MXCREATEDOUBLEMATRIX(N,1,0)
+		p = MXGETPR(PLHS(1))
+		CALL MXCOPYREAL8TOPTR(X,p,N)
+		
+		CALL CALFUN(N,X,F)
+		PLHS(2) = MXCREATEDOUBLEMATRIX(1,1,0)
+		p = MXGETPR(PLHS(2))
+		CALL MXCOPYREAL8TOPTR(F,p,1)
+		
+		rFEVAL = REAL(FEVAL)
+		PLHS(3) = MXCREATEDOUBLEMATRIX(1,1,0)
+		p = MXGETPR(PLHS(3))
+		CALL MXCOPYREAL8TOPTR(rFEVAL,p,1)
+
+		RETURN
+		
+		CONTAINS
+
+	SUBROUTINE CALFUN (N,X,F)
+	
+C 		input variables
+		INTEGER*8 N
+		REAL*8 X(*)
+C 		output variables
+		REAL*8 F
+		
+C 		more variables
+		MWPOINTER PLHS1(1),PRHS1(2),pX,pF
+		INTEGER*8 NLHS1,NRHS1
+		
+		NRHS1 = 2
+C 		first argument: x
+		PRHS1(1) = MXCREATEDOUBLEMATRIX(N,1,0)	
+		pX = MXGETPR(PRHS1(1))
+		CALL MXCOPYREAL8TOPTR(X,pX,N)
+C 		second argument: fun
+		PRHS1(2) = PRHS(6)
+		
+		NLHS1 = 1
+		
+		CALL MEXCALLMATLAB(NLHS1,PLHS1,NRHS1,PRHS1,'bobyqaFunHandleWrap')
+		
+		pF = MXGETPR(PLHS1(1))
+		CALL MXCOPYPTRTOREAL8(pF,F,1)
+	
+		FEVAL = FEVAL+1
+		
+		RETURN
+		
+	END SUBROUTINE CALFUN
+			
+	SUBROUTINE BOBYQA (N,NPT,X,XL,XU,RHOBEG,RHOEND,IPRINT,MAXFUN,W)
+      
+	  IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION X(*),XL(*),XU(*),W(*)
+	  
+C
+C     This subroutine seeks the least value of a function of many variables,
+C     by applying a trust region method that forms quadratic models by
+C     interpolation. There is usually some freedom in the interpolation
+C     conditions, which is taken up by minimizing the Frobenius norm of
+C     the change to the second derivative of the model, beginning with the
+C     zero matrix. The values of the variables are constrained by upper and
+C     lower bounds. The arguments of the subroutine are as follows.
+C
+C     N must be set to the number of variables and must be at least two.
+C     NPT is the number of interpolation conditions. Its value must be in
+C       the interval [N+2,(N+1)(N+2)/2]. Choices that exceed 2*N+1 are not
+C       recommended.
+C     Initial values of the variables must be set in X(1),X(2),...,X(N). They
+C       will be changed to the values that give the least calculated F.
+C     For I=1,2,...,N, XL(I) and XU(I) must provide the lower and upper
+C       bounds, respectively, on X(I). The construction of quadratic models
+C       requires XL(I) to be strictly less than XU(I) for each I. Further,
+C       the contribution to a model from changes to the I-th variable is
+C       damaged severely by rounding errors if XU(I)-XL(I) is too small.
+C     RHOBEG and RHOEND must be set to the initial and final values of a trust
+C       region radius, so both must be positive with RHOEND no greater than
+C       RHOBEG. Typically, RHOBEG should be about one tenth of the greatest
+C       expected change to a variable, while RHOEND should indicate the
+C       accuracy that is required in the final values of the variables. An
+C       error return occurs if any of the differences XU(I)-XL(I), I=1,...,N,
+C       is less than 2*RHOBEG.
+C     The value of IPRINT should be set to 0, 1, 2 or 3, which controls the
+C       amount of printing. Specifically, there is no output if IPRINT=0 and
+C       there is output only at the return if IPRINT=1. Otherwise, each new
+C       value of RHO is printed, with the best vector of variables so far and
+C       the corresponding value of the objective function. Further, each new
+C       value of F with its variables are output if IPRINT=3.
+C     MAXFUN must be set to an upper bound on the number of calls of CALFUN.
+C     The array W will be used for working space. Its length must be at least
+C       (NPT+5)*(NPT+N)+3*N*(N+5)/2.
+C
+C     SUBROUTINE CALFUN (N,X,F) has to be provided by the user. It must set
+C     F to the value of the objective function for the current values of the
+C     variables X(1),X(2),...,X(N), which are generated automatically in a
+C     way that satisfies the bounds given in XL and XU.
+C
+C     Return if the value of NPT is unacceptable.
+C
+      NP=N+1
+      IF (NPT .LT. N+2 .OR. NPT .GT. ((N+2)*NP)/2) THEN
+          PRINT 10
+   10     FORMAT (/4X,'Return from BOBYQA because NPT is not in',
+     1      ' the required interval')
+          GO TO 40
+      END IF
+C
+C     Partition the working space array, so that different parts of it can
+C     be treated separately during the calculation of BOBYQB. The partition
+C     requires the first (NPT+2)*(NPT+N)+3*N*(N+5)/2 elements of W plus the
+C     space that is taken by the last array in the argument list of BOBYQB.
+C
+      NDIM=NPT+N
+      IXB=1
+      IXP=IXB+N
+      IFV=IXP+N*NPT
+      IXO=IFV+NPT
+      IGO=IXO+N
+      IHQ=IGO+N
+      IPQ=IHQ+(N*NP)/2
+      IBMAT=IPQ+NPT
+      IZMAT=IBMAT+NDIM*N
+      ISL=IZMAT+NPT*(NPT-NP)
+      ISU=ISL+N
+      IXN=ISU+N
+      IXA=IXN+N
+      ID=IXA+N
+      IVL=ID+N
+      IW=IVL+NDIM
+C
+C     Return if there is insufficient space between the bounds. Modify the
+C     initial X if necessary in order to avoid conflicts between the bounds
+C     and the construction of the first quadratic model. The lower and upper
+C     bounds on moves from the updated X are set now, in the ISL and ISU
+C     partitions of W, in order to provide useful and exact information about
+C     components of X that become within distance RHOBEG from their bounds.
+C
+      ZERO=0.0D0
+      DO 30 J=1,N
+      TEMP=XU(J)-XL(J)
+      IF (TEMP .LT. RHOBEG+RHOBEG) THEN
+          PRINT 20
+   20     FORMAT (/4X,'Return from BOBYQA because one of the',
+     1      ' differences XU(I)-XL(I)'/6X,' is less than 2*RHOBEG.')
+          GO TO 40
+      END IF
+      JSL=ISL+J-1
+      JSU=JSL+N
+      W(JSL)=XL(J)-X(J)
+      W(JSU)=XU(J)-X(J)
+      IF (W(JSL) .GE. -RHOBEG) THEN
+          IF (W(JSL) .GE. ZERO) THEN
+              X(J)=XL(J)
+              W(JSL)=ZERO
+              W(JSU)=TEMP
+          ELSE
+              X(J)=XL(J)+RHOBEG
+              W(JSL)=-RHOBEG
+              W(JSU)=DMAX1(XU(J)-X(J),RHOBEG)
+          END IF
+      ELSE IF (W(JSU) .LE. RHOBEG) THEN
+          IF (W(JSU) .LE. ZERO) THEN
+              X(J)=XU(J)
+              W(JSL)=-TEMP
+              W(JSU)=ZERO
+          ELSE
+              X(J)=XU(J)-RHOBEG
+              W(JSL)=DMIN1(XL(J)-X(J),-RHOBEG)
+              W(JSU)=RHOBEG
+          END IF
+      END IF
+   30 CONTINUE
+C
+C     Make the call of BOBYQB.
+C
+      CALL BOBYQB (N,NPT,X,XL,XU,RHOBEG,RHOEND,IPRINT,MAXFUN,W(IXB),
+     1  W(IXP),W(IFV),W(IXO),W(IGO),W(IHQ),W(IPQ),W(IBMAT),W(IZMAT),
+     2  NDIM,W(ISL),W(ISU),W(IXN),W(IXA),W(ID),W(IVL),W(IW))
+   40 RETURN
+      END SUBROUTINE BOBYQA
+	  
+	  SUBROUTINE BOBYQB (N,NPT,X,XL,XU,RHOBEG,RHOEND,IPRINT,
+     1  MAXFUN,XBASE,XPT,FVAL,XOPT,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,
+     2  SL,SU,XNEW,XALT,D,VLAG,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION X(*),XL(*),XU(*),XBASE(*),XPT(NPT,*),FVAL(*),
+     1  XOPT(*),GOPT(*),HQ(*),PQ(*),BMAT(NDIM,*),ZMAT(NPT,*),
+     2  SL(*),SU(*),XNEW(*),XALT(*),D(*),VLAG(*),W(*)
+C
+C     The arguments N, NPT, X, XL, XU, RHOBEG, RHOEND, IPRINT and MAXFUN
+C       are identical to the corresponding arguments in SUBROUTINE BOBYQA.
+C     XBASE holds a shift of origin that should reduce the contributions
+C       from rounding errors to values of the model and Lagrange functions.
+C     XPT is a two-dimensional array that holds the coordinates of the
+C       interpolation points relative to XBASE.
+C     FVAL holds the values of F at the interpolation points.
+C     XOPT is set to the displacement from XBASE of the trust region centre.
+C     GOPT holds the gradient of the quadratic model at XBASE+XOPT.
+C     HQ holds the explicit second derivatives of the quadratic model.
+C     PQ contains the parameters of the implicit second derivatives of the
+C       quadratic model.
+C     BMAT holds the last N columns of H.
+C     ZMAT holds the factorization of the leading NPT by NPT submatrix of H,
+C       this factorization being ZMAT times ZMAT^T, which provides both the
+C       correct rank and positive semi-definiteness.
+C     NDIM is the first dimension of BMAT and has the value NPT+N.
+C     SL and SU hold the differences XL-XBASE and XU-XBASE, respectively.
+C       All the components of every XOPT are going to satisfy the bounds
+C       SL(I) .LEQ. XOPT(I) .LEQ. SU(I), with appropriate equalities when
+C       XOPT is on a constraint boundary.
+C     XNEW is chosen by SUBROUTINE TRSBOX or ALTMOV. Usually XBASE+XNEW is the
+C       vector of variables for the next call of CALFUN. XNEW also satisfies
+C       the SL and SU constraints in the way that has just been mentioned.
+C     XALT is an alternative to XNEW, chosen by ALTMOV, that may replace XNEW
+C       in order to increase the denominator in the updating of UPDATE.
+C     D is reserved for a trial step from XOPT, which is usually XNEW-XOPT.
+C     VLAG contains the values of the Lagrange functions at a new point X.
+C       They are part of a product that requires VLAG to be of length NDIM.
+C     W is a one-dimensional array that is used for working space. Its length
+C       must be at least 3*NDIM = 3*(NPT+N).
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      TEN=10.0D0
+      TENTH=0.1D0
+      TWO=2.0D0
+      ZERO=0.0D0
+      NP=N+1
+      NPTM=NPT-NP
+      NH=(N*NP)/2
+C
+C     The call of PRELIM sets the elements of XBASE, XPT, FVAL, GOPT, HQ, PQ,
+C     BMAT and ZMAT for the first iteration, with the corresponding values of
+C     of NF and KOPT, which are the number of calls of CALFUN so far and the
+C     index of the interpolation point at the trust region centre. Then the
+C     initial XOPT is set too. The branch to label 720 occurs if MAXFUN is
+C     less than NPT. GOPT will be updated if KOPT is different from KBASE.
+C
+      CALL PRELIM (N,NPT,X,XL,XU,RHOBEG,IPRINT,MAXFUN,XBASE,XPT,
+     1  FVAL,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,KOPT)
+      XOPTSQ=ZERO
+      DO 10 I=1,N
+      XOPT(I)=XPT(KOPT,I)
+   10 XOPTSQ=XOPTSQ+XOPT(I)**2
+      FSAVE=FVAL(1)
+      IF (NF .LT. NPT) THEN
+          IF (IPRINT .GT. 0) PRINT 390
+          GOTO 720
+      END IF
+      KBASE=1
+C
+C     Complete the settings that are required for the iterative procedure.
+C
+      RHO=RHOBEG
+      DELTA=RHO
+      NRESC=NF
+      NTRITS=0
+      DIFFA=ZERO
+      DIFFB=ZERO
+      ITEST=0
+      NFSAV=NF
+C
+C     Update GOPT if necessary before the first iteration and after each
+C     call of RESCUE that makes a call of CALFUN.
+C
+   20 IF (KOPT .NE. KBASE) THEN
+          IH=0
+          DO 30 J=1,N
+          DO 30 I=1,J
+          IH=IH+1
+          IF (I .LT. J) GOPT(J)=GOPT(J)+HQ(IH)*XOPT(I)
+   30     GOPT(I)=GOPT(I)+HQ(IH)*XOPT(J)
+          IF (NF .GT. NPT) THEN
+              DO 50 K=1,NPT
+              TEMP=ZERO
+              DO 40 J=1,N
+   40         TEMP=TEMP+XPT(K,J)*XOPT(J)
+              TEMP=PQ(K)*TEMP
+              DO 50 I=1,N
+   50         GOPT(I)=GOPT(I)+TEMP*XPT(K,I)
+          END IF
+      END IF
+C
+C     Generate the next point in the trust region that provides a small value
+C     of the quadratic model subject to the constraints on the variables.
+C     The integer NTRITS is set to the number "trust region" iterations that
+C     have occurred since the last "alternative" iteration. If the length
+C     of XNEW-XOPT is less than HALF*RHO, however, then there is a branch to
+C     label 650 or 680 with NTRITS=-1, instead of calculating F at XNEW.
+C
+   60 CALL TRSBOX (N,NPT,XPT,XOPT,GOPT,HQ,PQ,SL,SU,DELTA,XNEW,D,
+     1  W,W(NP),W(NP+N),W(NP+2*N),W(NP+3*N),DSQ,CRVMIN)
+      DNORM=DMIN1(DELTA,DSQRT(DSQ))
+      IF (DNORM .LT. HALF*RHO) THEN
+          NTRITS=-1
+          DISTSQ=(TEN*RHO)**2
+          IF (NF .LE. NFSAV+2) GOTO 650
+C
+C     The following choice between labels 650 and 680 depends on whether or
+C     not our work with the current RHO seems to be complete. Either RHO is
+C     decreased or termination occurs if the errors in the quadratic model at
+C     the last three interpolation points compare favourably with predictions
+C     of likely improvements to the model within distance HALF*RHO of XOPT.
+C
+          ERRBIG=DMAX1(DIFFA,DIFFB,DIFFC)
+          FRHOSQ=0.125D0*RHO*RHO
+          IF (CRVMIN .GT. ZERO .AND. ERRBIG .GT. FRHOSQ*CRVMIN)
+     1       GOTO 650
+          BDTOL=ERRBIG/RHO
+          DO 80 J=1,N
+          BDTEST=BDTOL
+          IF (XNEW(J) .EQ. SL(J)) BDTEST=W(J)
+          IF (XNEW(J) .EQ. SU(J)) BDTEST=-W(J)
+          IF (BDTEST .LT. BDTOL) THEN
+              CURV=HQ((J+J*J)/2)
+              DO 70 K=1,NPT
+   70         CURV=CURV+PQ(K)*XPT(K,J)**2
+              BDTEST=BDTEST+HALF*CURV*RHO
+              IF (BDTEST .LT. BDTOL) GOTO 650
+          END IF
+   80     CONTINUE
+          GOTO 680
+      END IF
+      NTRITS=NTRITS+1
+C
+C     Severe cancellation is likely to occur if XOPT is too far from XBASE.
+C     If the following test holds, then XBASE is shifted so that XOPT becomes
+C     zero. The appropriate changes are made to BMAT and to the second
+C     derivatives of the current model, beginning with the changes to BMAT
+C     that do not depend on ZMAT. VLAG is used temporarily for working space.
+C
+   90 IF (DSQ .LE. 1.0D-3*XOPTSQ) THEN
+          FRACSQ=0.25D0*XOPTSQ
+          SUMPQ=ZERO
+          DO 110 K=1,NPT
+          SUMPQ=SUMPQ+PQ(K)
+          SUM=-HALF*XOPTSQ
+          DO 100 I=1,N
+  100     SUM=SUM+XPT(K,I)*XOPT(I)
+          W(NPT+K)=SUM
+          TEMP=FRACSQ-HALF*SUM
+          DO 110 I=1,N
+          W(I)=BMAT(K,I)
+          VLAG(I)=SUM*XPT(K,I)+TEMP*XOPT(I)
+          IP=NPT+I
+          DO 110 J=1,I
+  110     BMAT(IP,J)=BMAT(IP,J)+W(I)*VLAG(J)+VLAG(I)*W(J)
+C
+C     Then the revisions of BMAT that depend on ZMAT are calculated.
+C
+          DO 150 JJ=1,NPTM
+          SUMZ=ZERO
+          SUMW=ZERO
+          DO 120 K=1,NPT
+          SUMZ=SUMZ+ZMAT(K,JJ)
+          VLAG(K)=W(NPT+K)*ZMAT(K,JJ)
+  120     SUMW=SUMW+VLAG(K)
+          DO 140 J=1,N
+          SUM=(FRACSQ*SUMZ-HALF*SUMW)*XOPT(J)
+          DO 130 K=1,NPT
+  130     SUM=SUM+VLAG(K)*XPT(K,J)
+          W(J)=SUM
+          DO 140 K=1,NPT
+  140     BMAT(K,J)=BMAT(K,J)+SUM*ZMAT(K,JJ)
+          DO 150 I=1,N
+          IP=I+NPT
+          TEMP=W(I)
+          DO 150 J=1,I
+  150     BMAT(IP,J)=BMAT(IP,J)+TEMP*W(J)
+C
+C     The following instructions complete the shift, including the changes
+C     to the second derivative parameters of the quadratic model.
+C
+          IH=0
+          DO 170 J=1,N
+          W(J)=-HALF*SUMPQ*XOPT(J)
+          DO 160 K=1,NPT
+          W(J)=W(J)+PQ(K)*XPT(K,J)
+  160     XPT(K,J)=XPT(K,J)-XOPT(J)
+          DO 170 I=1,J
+          IH=IH+1
+          HQ(IH)=HQ(IH)+W(I)*XOPT(J)+XOPT(I)*W(J)
+  170     BMAT(NPT+I,J)=BMAT(NPT+J,I)
+          DO 180 I=1,N
+          XBASE(I)=XBASE(I)+XOPT(I)
+          XNEW(I)=XNEW(I)-XOPT(I)
+          SL(I)=SL(I)-XOPT(I)
+          SU(I)=SU(I)-XOPT(I)
+  180     XOPT(I)=ZERO
+          XOPTSQ=ZERO
+      END IF
+      IF (NTRITS .EQ. 0) GOTO 210
+      GOTO 230
+C
+C     XBASE is also moved to XOPT by a call of RESCUE. This calculation is
+C     more expensive than the previous shift, because new matrices BMAT and
+C     ZMAT are generated from scratch, which may include the replacement of
+C     interpolation points whose positions seem to be causing near linear
+C     dependence in the interpolation conditions. Therefore RESCUE is called
+C     only if rounding errors have reduced by at least a factor of two the
+C     denominator of the formula for updating the H matrix. It provides a
+C     useful safeguard, but is not invoked in most applications of BOBYQA.
+C
+  190 NFSAV=NF
+      KBASE=KOPT
+      CALL RESCUE (N,NPT,XL,XU,IPRINT,MAXFUN,XBASE,XPT,FVAL,
+     1  XOPT,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,DELTA,KOPT,
+     2  VLAG,W,W(N+NP),W(NDIM+NP))
+C
+C     XOPT is updated now in case the branch below to label 720 is taken.
+C     Any updating of GOPT occurs after the branch below to label 20, which
+C     leads to a trust region iteration as does the branch to label 60.
+C
+      XOPTSQ=ZERO
+      IF (KOPT .NE. KBASE) THEN
+          DO 200 I=1,N
+          XOPT(I)=XPT(KOPT,I)
+  200     XOPTSQ=XOPTSQ+XOPT(I)**2
+      END IF
+      IF (NF .LT. 0) THEN
+          NF=MAXFUN
+          IF (IPRINT .GT. 0) PRINT 390
+          GOTO 720
+      END IF
+      NRESC=NF
+      IF (NFSAV .LT. NF) THEN
+          NFSAV=NF
+          GOTO 20
+      END IF
+      IF (NTRITS .GT. 0) GOTO 60
+C
+C     Pick two alternative vectors of variables, relative to XBASE, that
+C     are suitable as new positions of the KNEW-th interpolation point.
+C     Firstly, XNEW is set to the point on a line through XOPT and another
+C     interpolation point that minimizes the predicted value of the next
+C     denominator, subject to ||XNEW - XOPT|| .LEQ. ADELT and to the SL
+C     and SU bounds. Secondly, XALT is set to the best feasible point on
+C     a constrained version of the Cauchy step of the KNEW-th Lagrange
+C     function, the corresponding value of the square of this function
+C     being returned in CAUCHY. The choice between these alternatives is
+C     going to be made when the denominator is calculated.
+C
+  210 CALL ALTMOV (N,NPT,XPT,XOPT,BMAT,ZMAT,NDIM,SL,SU,KOPT,
+     1  KNEW,ADELT,XNEW,XALT,ALPHA,CAUCHY,W,W(NP),W(NDIM+1))
+      DO 220 I=1,N
+  220 D(I)=XNEW(I)-XOPT(I)
+C
+C     Calculate VLAG and BETA for the current choice of D. The scalar
+C     product of D with XPT(K,.) is going to be held in W(NPT+K) for
+C     use when VQUAD is calculated.
+C
+  230 DO 250 K=1,NPT
+      SUMA=ZERO
+      SUMB=ZERO
+      SUM=ZERO
+      DO 240 J=1,N
+      SUMA=SUMA+XPT(K,J)*D(J)
+      SUMB=SUMB+XPT(K,J)*XOPT(J)
+  240 SUM=SUM+BMAT(K,J)*D(J)
+      W(K)=SUMA*(HALF*SUMA+SUMB)
+      VLAG(K)=SUM
+  250 W(NPT+K)=SUMA
+      BETA=ZERO
+      DO 270 JJ=1,NPTM
+      SUM=ZERO
+      DO 260 K=1,NPT
+  260 SUM=SUM+ZMAT(K,JJ)*W(K)
+      BETA=BETA-SUM*SUM
+      DO 270 K=1,NPT
+  270 VLAG(K)=VLAG(K)+SUM*ZMAT(K,JJ)
+      DSQ=ZERO
+      BSUM=ZERO
+      DX=ZERO
+      DO 300 J=1,N
+      DSQ=DSQ+D(J)**2
+      SUM=ZERO
+      DO 280 K=1,NPT
+  280 SUM=SUM+W(K)*BMAT(K,J)
+      BSUM=BSUM+SUM*D(J)
+      JP=NPT+J
+      DO 290 I=1,N
+  290 SUM=SUM+BMAT(JP,I)*D(I)
+      VLAG(JP)=SUM
+      BSUM=BSUM+SUM*D(J)
+  300 DX=DX+D(J)*XOPT(J)
+      BETA=DX*DX+DSQ*(XOPTSQ+DX+DX+HALF*DSQ)+BETA-BSUM
+      VLAG(KOPT)=VLAG(KOPT)+ONE
+C
+C     If NTRITS is zero, the denominator may be increased by replacing
+C     the step D of ALTMOV by a Cauchy step. Then RESCUE may be called if
+C     rounding errors have damaged the chosen denominator.
+C
+      IF (NTRITS .EQ. 0) THEN
+          DENOM=VLAG(KNEW)**2+ALPHA*BETA
+          IF (DENOM .LT. CAUCHY .AND. CAUCHY .GT. ZERO) THEN
+              DO 310 I=1,N
+              XNEW(I)=XALT(I)
+  310         D(I)=XNEW(I)-XOPT(I)
+              CAUCHY=ZERO
+              GO TO 230
+          END IF
+          IF (DENOM .LE. HALF*VLAG(KNEW)**2) THEN
+              IF (NF .GT. NRESC) GOTO 190
+              IF (IPRINT .GT. 0) PRINT 320
+  320         FORMAT (/5X,'Return from BOBYQA because of much',
+     1          ' cancellation in a denominator.')
+              GOTO 720
+          END IF
+C
+C     Alternatively, if NTRITS is positive, then set KNEW to the index of
+C     the next interpolation point to be deleted to make room for a trust
+C     region step. Again RESCUE may be called if rounding errors have damaged
+C     the chosen denominator, which is the reason for attempting to select
+C     KNEW before calculating the next value of the objective function.
+C
+      ELSE
+          DELSQ=DELTA*DELTA
+          SCADEN=ZERO
+          BIGLSQ=ZERO
+          KNEW=0
+          DO 350 K=1,NPT
+          IF (K .EQ. KOPT) GOTO 350
+          HDIAG=ZERO
+          DO 330 JJ=1,NPTM
+  330     HDIAG=HDIAG+ZMAT(K,JJ)**2
+          DEN=BETA*HDIAG+VLAG(K)**2
+          DISTSQ=ZERO
+          DO 340 J=1,N
+  340     DISTSQ=DISTSQ+(XPT(K,J)-XOPT(J))**2
+          TEMP=DMAX1(ONE,(DISTSQ/DELSQ)**2)
+          IF (TEMP*DEN .GT. SCADEN) THEN
+              SCADEN=TEMP*DEN
+              KNEW=K
+              DENOM=DEN
+          END IF
+          BIGLSQ=DMAX1(BIGLSQ,TEMP*VLAG(K)**2)
+  350     CONTINUE
+          IF (SCADEN .LE. HALF*BIGLSQ) THEN
+              IF (NF .GT. NRESC) GOTO 190
+              IF (IPRINT .GT. 0) PRINT 320
+              GOTO 720
+          END IF
+      END IF
+C
+C     Put the variables for the next calculation of the objective function
+C       in XNEW, with any adjustments for the bounds.
+C
+C
+C     Calculate the value of the objective function at XBASE+XNEW, unless
+C       the limit on the number of calculations of F has been reached.
+C
+  360 DO 380 I=1,N
+      X(I)=DMIN1(DMAX1(XL(I),XBASE(I)+XNEW(I)),XU(I))
+      IF (XNEW(I) .EQ. SL(I)) X(I)=XL(I)
+      IF (XNEW(I) .EQ. SU(I)) X(I)=XU(I)
+  380 CONTINUE
+      IF (NF .GE. MAXFUN) THEN
+          IF (IPRINT .GT. 0) PRINT 390
+  390     FORMAT (/4X,'Return from BOBYQA because CALFUN has been',
+     1      ' called MAXFUN times.')
+          GOTO 720
+      END IF
+      NF=NF+1
+      CALL CALFUN (N,X,F)
+      IF (IPRINT .EQ. 3) THEN
+          PRINT 400, NF,F,(X(I),I=1,N)
+  400      FORMAT (/4X,'Function number',I6,'    F =',1PD18.10,
+     1       '    The corresponding X is:'/(2X,5D15.6))
+      END IF
+      IF (NTRITS .EQ. -1) THEN
+          FSAVE=F
+          GOTO 720
+      END IF
+C
+C     Use the quadratic model to predict the change in F due to the step D,
+C       and set DIFF to the error of this prediction.
+C
+      FOPT=FVAL(KOPT)
+      VQUAD=ZERO
+      IH=0
+      DO 410 J=1,N
+      VQUAD=VQUAD+D(J)*GOPT(J)
+      DO 410 I=1,J
+      IH=IH+1
+      TEMP=D(I)*D(J)
+      IF (I .EQ. J) TEMP=HALF*TEMP
+  410 VQUAD=VQUAD+HQ(IH)*TEMP
+      DO 420 K=1,NPT
+  420 VQUAD=VQUAD+HALF*PQ(K)*W(NPT+K)**2
+      DIFF=F-FOPT-VQUAD
+      DIFFC=DIFFB
+      DIFFB=DIFFA
+      DIFFA=DABS(DIFF)
+      IF (DNORM .GT. RHO) NFSAV=NF
+C
+C     Pick the next value of DELTA after a trust region step.
+C
+      IF (NTRITS .GT. 0) THEN
+          IF (VQUAD .GE. ZERO) THEN
+              IF (IPRINT .GT. 0) PRINT 430
+  430         FORMAT (/4X,'Return from BOBYQA because a trust',
+     1          ' region step has failed to reduce Q.')
+              GOTO 720
+          END IF
+          RATIO=(F-FOPT)/VQUAD
+          IF (RATIO .LE. TENTH) THEN
+              DELTA=DMIN1(HALF*DELTA,DNORM)
+          ELSE IF (RATIO .LE. 0.7D0) THEN
+              DELTA=DMAX1(HALF*DELTA,DNORM)
+          ELSE
+              DELTA=DMAX1(HALF*DELTA,DNORM+DNORM)
+          END IF
+          IF (DELTA .LE. 1.5D0*RHO) DELTA=RHO
+C
+C     Recalculate KNEW and DENOM if the new F is less than FOPT.
+C
+          IF (F .LT. FOPT) THEN
+              KSAV=KNEW
+              DENSAV=DENOM
+              DELSQ=DELTA*DELTA
+              SCADEN=ZERO
+              BIGLSQ=ZERO
+              KNEW=0
+              DO 460 K=1,NPT
+              HDIAG=ZERO
+              DO 440 JJ=1,NPTM
+  440         HDIAG=HDIAG+ZMAT(K,JJ)**2
+              DEN=BETA*HDIAG+VLAG(K)**2
+              DISTSQ=ZERO
+              DO 450 J=1,N
+  450         DISTSQ=DISTSQ+(XPT(K,J)-XNEW(J))**2
+              TEMP=DMAX1(ONE,(DISTSQ/DELSQ)**2)
+              IF (TEMP*DEN .GT. SCADEN) THEN
+                  SCADEN=TEMP*DEN
+                  KNEW=K
+                  DENOM=DEN
+              END IF
+  460         BIGLSQ=DMAX1(BIGLSQ,TEMP*VLAG(K)**2)
+              IF (SCADEN .LE. HALF*BIGLSQ) THEN
+                  KNEW=KSAV
+                  DENOM=DENSAV
+              END IF
+          END IF
+      END IF
+C
+C     Update BMAT and ZMAT, so that the KNEW-th interpolation point can be
+C     moved. Also update the second derivative terms of the model.
+C
+      CALL UPDATE (N,NPT,BMAT,ZMAT,NDIM,VLAG,BETA,DENOM,KNEW,W)
+      IH=0
+      PQOLD=PQ(KNEW)
+      PQ(KNEW)=ZERO
+      DO 470 I=1,N
+      TEMP=PQOLD*XPT(KNEW,I)
+      DO 470 J=1,I
+      IH=IH+1
+  470 HQ(IH)=HQ(IH)+TEMP*XPT(KNEW,J)
+      DO 480 JJ=1,NPTM
+      TEMP=DIFF*ZMAT(KNEW,JJ)
+      DO 480 K=1,NPT
+  480 PQ(K)=PQ(K)+TEMP*ZMAT(K,JJ)
+C
+C     Include the new interpolation point, and make the changes to GOPT at
+C     the old XOPT that are caused by the updating of the quadratic model.
+C
+      FVAL(KNEW)=F
+      DO 490 I=1,N
+      XPT(KNEW,I)=XNEW(I)
+  490 W(I)=BMAT(KNEW,I)
+      DO 520 K=1,NPT
+      SUMA=ZERO
+      DO 500 JJ=1,NPTM
+  500 SUMA=SUMA+ZMAT(KNEW,JJ)*ZMAT(K,JJ)
+      SUMB=ZERO
+      DO 510 J=1,N
+  510 SUMB=SUMB+XPT(K,J)*XOPT(J)
+      TEMP=SUMA*SUMB
+      DO 520 I=1,N
+  520 W(I)=W(I)+TEMP*XPT(K,I)
+      DO 530 I=1,N
+  530 GOPT(I)=GOPT(I)+DIFF*W(I)
+C
+C     Update XOPT, GOPT and KOPT if the new calculated F is less than FOPT.
+C
+      IF (F .LT. FOPT) THEN
+          KOPT=KNEW
+          XOPTSQ=ZERO
+          IH=0
+          DO 540 J=1,N
+          XOPT(J)=XNEW(J)
+          XOPTSQ=XOPTSQ+XOPT(J)**2
+          DO 540 I=1,J
+          IH=IH+1
+          IF (I .LT. J) GOPT(J)=GOPT(J)+HQ(IH)*D(I)
+  540     GOPT(I)=GOPT(I)+HQ(IH)*D(J)
+          DO 560 K=1,NPT
+          TEMP=ZERO
+          DO 550 J=1,N
+  550     TEMP=TEMP+XPT(K,J)*D(J)
+          TEMP=PQ(K)*TEMP
+          DO 560 I=1,N
+  560     GOPT(I)=GOPT(I)+TEMP*XPT(K,I)
+      END IF
+C
+C     Calculate the parameters of the least Frobenius norm interpolant to
+C     the current data, the gradient of this interpolant at XOPT being put
+C     into VLAG(NPT+I), I=1,2,...,N.
+C
+      IF (NTRITS .GT. 0) THEN
+          DO 570 K=1,NPT
+          VLAG(K)=FVAL(K)-FVAL(KOPT)
+  570     W(K)=ZERO
+          DO 590 J=1,NPTM
+          SUM=ZERO
+          DO 580 K=1,NPT
+  580     SUM=SUM+ZMAT(K,J)*VLAG(K)
+          DO 590 K=1,NPT
+  590     W(K)=W(K)+SUM*ZMAT(K,J)
+          DO 610 K=1,NPT
+          SUM=ZERO
+          DO 600 J=1,N
+  600     SUM=SUM+XPT(K,J)*XOPT(J)
+          W(K+NPT)=W(K)
+  610     W(K)=SUM*W(K)
+          GQSQ=ZERO
+          GISQ=ZERO
+          DO 630 I=1,N
+          SUM=ZERO
+          DO 620 K=1,NPT
+  620     SUM=SUM+BMAT(K,I)*VLAG(K)+XPT(K,I)*W(K)
+          IF (XOPT(I) .EQ. SL(I)) THEN
+              GQSQ=GQSQ+DMIN1(ZERO,GOPT(I))**2
+              GISQ=GISQ+DMIN1(ZERO,SUM)**2
+          ELSE IF (XOPT(I) .EQ. SU(I)) THEN
+              GQSQ=GQSQ+DMAX1(ZERO,GOPT(I))**2
+              GISQ=GISQ+DMAX1(ZERO,SUM)**2
+          ELSE
+              GQSQ=GQSQ+GOPT(I)**2
+              GISQ=GISQ+SUM*SUM
+          END IF
+  630     VLAG(NPT+I)=SUM
+C
+C     Test whether to replace the new quadratic model by the least Frobenius
+C     norm interpolant, making the replacement if the test is satisfied.
+C
+          ITEST=ITEST+1
+          IF (GQSQ .LT. TEN*GISQ) ITEST=0
+          IF (ITEST .GE. 3) THEN
+              DO 640 I=1,MAX0(NPT,NH)
+              IF (I .LE. N) GOPT(I)=VLAG(NPT+I)
+              IF (I .LE. NPT) PQ(I)=W(NPT+I)
+              IF (I .LE. NH) HQ(I)=ZERO
+              ITEST=0
+  640         CONTINUE
+          END IF
+      END IF
+C
+C     If a trust region step has provided a sufficient decrease in F, then
+C     branch for another trust region calculation. The case NTRITS=0 occurs
+C     when the new interpolation point was reached by an alternative step.
+C
+      IF (NTRITS .EQ. 0) GOTO 60
+      IF (F .LE. FOPT+TENTH*VQUAD) GOTO 60
+C
+C     Alternatively, find out if the interpolation points are close enough
+C       to the best point so far.
+C
+      DISTSQ=DMAX1((TWO*DELTA)**2,(TEN*RHO)**2)
+  650 KNEW=0
+      DO 670 K=1,NPT
+      SUM=ZERO
+      DO 660 J=1,N
+  660 SUM=SUM+(XPT(K,J)-XOPT(J))**2
+      IF (SUM .GT. DISTSQ) THEN
+          KNEW=K
+          DISTSQ=SUM
+      END IF
+  670 CONTINUE
+C
+C     If KNEW is positive, then ALTMOV finds alternative new positions for
+C     the KNEW-th interpolation point within distance ADELT of XOPT. It is
+C     reached via label 90. Otherwise, there is a branch to label 60 for
+C     another trust region iteration, unless the calculations with the
+C     current RHO are complete.
+C
+      IF (KNEW .GT. 0) THEN
+          DIST=DSQRT(DISTSQ)
+          IF (NTRITS .EQ. -1) THEN
+              DELTA=DMIN1(TENTH*DELTA,HALF*DIST)
+              IF (DELTA .LE. 1.5D0*RHO) DELTA=RHO
+          END IF
+          NTRITS=0
+          ADELT=DMAX1(DMIN1(TENTH*DIST,DELTA),RHO)
+          DSQ=ADELT*ADELT
+          GOTO 90
+      END IF
+      IF (NTRITS .EQ. -1) GOTO 680
+      IF (RATIO .GT. ZERO) GOTO 60
+      IF (DMAX1(DELTA,DNORM) .GT. RHO) GOTO 60
+C
+C     The calculations with the current value of RHO are complete. Pick the
+C       next values of RHO and DELTA.
+C
+  680 IF (RHO .GT. RHOEND) THEN
+          DELTA=HALF*RHO
+          RATIO=RHO/RHOEND
+          IF (RATIO .LE. 16.0D0) THEN
+              RHO=RHOEND
+          ELSE IF (RATIO .LE. 250.0D0) THEN
+              RHO=DSQRT(RATIO)*RHOEND
+          ELSE
+              RHO=TENTH*RHO
+          END IF
+          DELTA=DMAX1(DELTA,RHO)
+          IF (IPRINT .GE. 2) THEN
+              IF (IPRINT .GE. 3) PRINT 690
+  690         FORMAT (5X)
+              PRINT 700, RHO,NF
+  700         FORMAT (/4X,'New RHO =',1PD11.4,5X,'Number of',
+     1          ' function values =',I6)
+              PRINT 710, FVAL(KOPT),(XBASE(I)+XOPT(I),I=1,N)
+  710         FORMAT (4X,'Least value of F =',1PD23.15,9X,
+     1          'The corresponding X is:'/(2X,5D15.6))
+          END IF
+          NTRITS=0
+          NFSAV=NF
+          GOTO 60
+      END IF
+C
+C     Return from the calculation, after another Newton-Raphson step, if
+C       it is too short to have been tried before.
+C
+      IF (NTRITS .EQ. -1) GOTO 360
+  720 IF (FVAL(KOPT) .LE. FSAVE) THEN
+          DO 730 I=1,N
+          X(I)=DMIN1(DMAX1(XL(I),XBASE(I)+XOPT(I)),XU(I))
+          IF (XOPT(I) .EQ. SL(I)) X(I)=XL(I)
+          IF (XOPT(I) .EQ. SU(I)) X(I)=XU(I)
+  730     CONTINUE
+          F=FVAL(KOPT)
+      END IF
+      IF (IPRINT .GE. 1) THEN
+          PRINT 740, NF
+  740     FORMAT (/4X,'At the return from BOBYQA',5X,
+     1      'Number of function values =',I6)
+          PRINT 710, F,(X(I),I=1,N)
+      END IF
+      RETURN
+      END SUBROUTINE BOBYQB
+	  
+	  SUBROUTINE PRELIM (N,NPT,X,XL,XU,RHOBEG,IPRINT,MAXFUN,XBASE,
+     1  XPT,FVAL,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,KOPT)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION X(*),XL(*),XU(*),XBASE(*),XPT(NPT,*),FVAL(*),GOPT(*),
+     1  HQ(*),PQ(*),BMAT(NDIM,*),ZMAT(NPT,*),SL(*),SU(*)
+C
+C     The arguments N, NPT, X, XL, XU, RHOBEG, IPRINT and MAXFUN are the
+C       same as the corresponding arguments in SUBROUTINE BOBYQA.
+C     The arguments XBASE, XPT, FVAL, HQ, PQ, BMAT, ZMAT, NDIM, SL and SU
+C       are the same as the corresponding arguments in BOBYQB, the elements
+C       of SL and SU being set in BOBYQA.
+C     GOPT is usually the gradient of the quadratic model at XOPT+XBASE, but
+C       it is set by PRELIM to the gradient of the quadratic model at XBASE.
+C       If XOPT is nonzero, BOBYQB will change it to its usual value later.
+C     NF is maintaned as the number of calls of CALFUN so far.
+C     KOPT will be such that the least calculated value of F so far is at
+C       the point XPT(KOPT,.)+XBASE in the space of the variables.
+C
+C     SUBROUTINE PRELIM sets the elements of XBASE, XPT, FVAL, GOPT, HQ, PQ,
+C     BMAT and ZMAT for the first iteration, and it maintains the values of
+C     NF and KOPT. The vector X is also changed by PRELIM.
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      TWO=2.0D0
+      ZERO=0.0D0
+      RHOSQ=RHOBEG*RHOBEG
+      RECIP=ONE/RHOSQ
+      NP=N+1
+C
+C     Set XBASE to the initial vector of variables, and set the initial
+C     elements of XPT, BMAT, HQ, PQ and ZMAT to zero.
+C
+      DO 20 J=1,N
+      XBASE(J)=X(J)
+      DO 10 K=1,NPT
+   10 XPT(K,J)=ZERO
+      DO 20 I=1,NDIM
+   20 BMAT(I,J)=ZERO
+      DO 30 IH=1,(N*NP)/2
+   30 HQ(IH)=ZERO
+      DO 40 K=1,NPT
+      PQ(K)=ZERO
+      DO 40 J=1,NPT-NP
+   40 ZMAT(K,J)=ZERO
+C
+C     Begin the initialization procedure. NF becomes one more than the number
+C     of function values so far. The coordinates of the displacement of the
+C     next initial interpolation point from XBASE are set in XPT(NF+1,.).
+C
+      NF=0
+   50 NFM=NF
+      NFX=NF-N
+      NF=NF+1
+      IF (NFM .LE. 2*N) THEN
+          IF (NFM .GE. 1 .AND. NFM .LE. N) THEN
+              STEPA=RHOBEG
+              IF (SU(NFM) .EQ. ZERO) STEPA=-STEPA
+              XPT(NF,NFM)=STEPA
+          ELSE IF (NFM .GT. N) THEN
+              STEPA=XPT(NF-N,NFX)
+              STEPB=-RHOBEG
+              IF (SL(NFX) .EQ. ZERO) STEPB=DMIN1(TWO*RHOBEG,SU(NFX))
+              IF (SU(NFX) .EQ. ZERO) STEPB=DMAX1(-TWO*RHOBEG,SL(NFX))
+              XPT(NF,NFX)=STEPB
+          END IF
+      ELSE
+          ITEMP=(NFM-NP)/N
+          JPT=NFM-ITEMP*N-N
+          IPT=JPT+ITEMP
+          IF (IPT .GT. N) THEN
+              ITEMP=JPT
+              JPT=IPT-N
+              IPT=ITEMP
+          END IF
+          XPT(NF,IPT)=XPT(IPT+1,IPT)
+          XPT(NF,JPT)=XPT(JPT+1,JPT)
+      END IF
+C
+C     Calculate the next value of F. The least function value so far and
+C     its index are required.
+C
+      DO 60 J=1,N
+      X(J)=DMIN1(DMAX1(XL(J),XBASE(J)+XPT(NF,J)),XU(J))
+      IF (XPT(NF,J) .EQ. SL(J)) X(J)=XL(J)
+      IF (XPT(NF,J) .EQ. SU(J)) X(J)=XU(J)
+   60 CONTINUE
+      CALL CALFUN (N,X,F)
+      IF (IPRINT .EQ. 3) THEN
+          PRINT 70, NF,F,(X(I),I=1,N)
+   70      FORMAT (/4X,'Function number',I6,'    F =',1PD18.10,
+     1       '    The corresponding X is:'/(2X,5D15.6))
+      END IF
+      FVAL(NF)=F
+      IF (NF .EQ. 1) THEN
+          FBEG=F
+          KOPT=1
+      ELSE IF (F .LT. FVAL(KOPT)) THEN
+          KOPT=NF
+      END IF
+C
+C     Set the nonzero initial elements of BMAT and the quadratic model in the
+C     cases when NF is at most 2*N+1. If NF exceeds N+1, then the positions
+C     of the NF-th and (NF-N)-th interpolation points may be switched, in
+C     order that the function value at the first of them contributes to the
+C     off-diagonal second derivative terms of the initial quadratic model.
+C
+      IF (NF .LE. 2*N+1) THEN
+          IF (NF .GE. 2 .AND. NF .LE. N+1) THEN
+              GOPT(NFM)=(F-FBEG)/STEPA
+              IF (NPT .LT. NF+N) THEN
+                  BMAT(1,NFM)=-ONE/STEPA
+                  BMAT(NF,NFM)=ONE/STEPA
+                  BMAT(NPT+NFM,NFM)=-HALF*RHOSQ
+              END IF
+          ELSE IF (NF .GE. N+2) THEN
+              IH=(NFX*(NFX+1))/2
+              TEMP=(F-FBEG)/STEPB
+              DIFF=STEPB-STEPA
+              HQ(IH)=TWO*(TEMP-GOPT(NFX))/DIFF
+              GOPT(NFX)=(GOPT(NFX)*STEPB-TEMP*STEPA)/DIFF
+              IF (STEPA*STEPB .LT. ZERO) THEN
+                  IF (F .LT. FVAL(NF-N)) THEN
+                      FVAL(NF)=FVAL(NF-N)
+                      FVAL(NF-N)=F
+                      IF (KOPT .EQ. NF) KOPT=NF-N
+                      XPT(NF-N,NFX)=STEPB
+                      XPT(NF,NFX)=STEPA
+                  END IF
+              END IF
+              BMAT(1,NFX)=-(STEPA+STEPB)/(STEPA*STEPB)
+              BMAT(NF,NFX)=-HALF/XPT(NF-N,NFX)
+              BMAT(NF-N,NFX)=-BMAT(1,NFX)-BMAT(NF,NFX)
+              ZMAT(1,NFX)=DSQRT(TWO)/(STEPA*STEPB)
+              ZMAT(NF,NFX)=DSQRT(HALF)/RHOSQ
+              ZMAT(NF-N,NFX)=-ZMAT(1,NFX)-ZMAT(NF,NFX)
+          END IF
+C
+C     Set the off-diagonal second derivatives of the Lagrange functions and
+C     the initial quadratic model.
+C
+      ELSE
+          IH=(IPT*(IPT-1))/2+JPT
+          ZMAT(1,NFX)=RECIP
+          ZMAT(NF,NFX)=RECIP
+          ZMAT(IPT+1,NFX)=-RECIP
+          ZMAT(JPT+1,NFX)=-RECIP
+          TEMP=XPT(NF,IPT)*XPT(NF,JPT)
+          HQ(IH)=(FBEG-FVAL(IPT+1)-FVAL(JPT+1)+F)/TEMP
+      END IF
+      IF (NF .LT. NPT .AND. NF .LT. MAXFUN) GOTO 50
+      RETURN
+      END SUBROUTINE PRELIM
+	  
+	  SUBROUTINE RESCUE (N,NPT,XL,XU,IPRINT,MAXFUN,XBASE,XPT,
+     1  FVAL,XOPT,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,DELTA,
+     2  KOPT,VLAG,PTSAUX,PTSID,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION XL(*),XU(*),XBASE(*),XPT(NPT,*),FVAL(*),XOPT(*),
+     1  GOPT(*),HQ(*),PQ(*),BMAT(NDIM,*),ZMAT(NPT,*),SL(*),SU(*),
+     2  VLAG(*),PTSAUX(2,*),PTSID(*),W(*)
+C
+C     The arguments N, NPT, XL, XU, IPRINT, MAXFUN, XBASE, XPT, FVAL, XOPT,
+C       GOPT, HQ, PQ, BMAT, ZMAT, NDIM, SL and SU have the same meanings as
+C       the corresponding arguments of BOBYQB on the entry to RESCUE.
+C     NF is maintained as the number of calls of CALFUN so far, except that
+C       NF is set to -1 if the value of MAXFUN prevents further progress.
+C     KOPT is maintained so that FVAL(KOPT) is the least calculated function
+C       value. Its correct value must be given on entry. It is updated if a
+C       new least function value is found, but the corresponding changes to
+C       XOPT and GOPT have to be made later by the calling program.
+C     DELTA is the current trust region radius.
+C     VLAG is a working space vector that will be used for the values of the
+C       provisional Lagrange functions at each of the interpolation points.
+C       They are part of a product that requires VLAG to be of length NDIM.
+C     PTSAUX is also a working space array. For J=1,2,...,N, PTSAUX(1,J) and
+C       PTSAUX(2,J) specify the two positions of provisional interpolation
+C       points when a nonzero step is taken along e_J (the J-th coordinate
+C       direction) through XBASE+XOPT, as specified below. Usually these
+C       steps have length DELTA, but other lengths are chosen if necessary
+C       in order to satisfy the given bounds on the variables.
+C     PTSID is also a working space array. It has NPT components that denote
+C       provisional new positions of the original interpolation points, in
+C       case changes are needed to restore the linear independence of the
+C       interpolation conditions. The K-th point is a candidate for change
+C       if and only if PTSID(K) is nonzero. In this case let p and q be the
+C       integer parts of PTSID(K) and (PTSID(K)-p) multiplied by N+1. If p
+C       and q are both positive, the step from XBASE+XOPT to the new K-th
+C       interpolation point is PTSAUX(1,p)*e_p + PTSAUX(1,q)*e_q. Otherwise
+C       the step is PTSAUX(1,p)*e_p or PTSAUX(2,q)*e_q in the cases q=0 or
+C       p=0, respectively.
+C     The first NDIM+NPT elements of the array W are used for working space. 
+C     The final elements of BMAT and ZMAT are set in a well-conditioned way
+C       to the values that are appropriate for the new interpolation points.
+C     The elements of GOPT, HQ and PQ are also revised to the values that are
+C       appropriate to the final quadratic model.
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      ZERO=0.0D0
+      NP=N+1
+      SFRAC=HALF/DFLOAT(NP)
+      NPTM=NPT-NP
+C
+C     Shift the interpolation points so that XOPT becomes the origin, and set
+C     the elements of ZMAT to zero. The value of SUMPQ is required in the
+C     updating of HQ below. The squares of the distances from XOPT to the
+C     other interpolation points are set at the end of W. Increments of WINC
+C     may be added later to these squares to balance the consideration of
+C     the choice of point that is going to become current.
+C
+      SUMPQ=ZERO
+      WINC=ZERO
+      DO 20 K=1,NPT
+      DISTSQ=ZERO
+      DO 10 J=1,N
+      XPT(K,J)=XPT(K,J)-XOPT(J)
+   10 DISTSQ=DISTSQ+XPT(K,J)**2
+      SUMPQ=SUMPQ+PQ(K)
+      W(NDIM+K)=DISTSQ
+      WINC=DMAX1(WINC,DISTSQ)
+      DO 20 J=1,NPTM
+   20 ZMAT(K,J)=ZERO
+C
+C     Update HQ so that HQ and PQ define the second derivatives of the model
+C     after XBASE has been shifted to the trust region centre.
+C
+      IH=0
+      DO 40 J=1,N
+      W(J)=HALF*SUMPQ*XOPT(J)
+      DO 30 K=1,NPT
+   30 W(J)=W(J)+PQ(K)*XPT(K,J)
+      DO 40 I=1,J
+      IH=IH+1
+   40 HQ(IH)=HQ(IH)+W(I)*XOPT(J)+W(J)*XOPT(I)
+C
+C     Shift XBASE, SL, SU and XOPT. Set the elements of BMAT to zero, and
+C     also set the elements of PTSAUX.
+C
+      DO 50 J=1,N
+      XBASE(J)=XBASE(J)+XOPT(J)
+      SL(J)=SL(J)-XOPT(J)
+      SU(J)=SU(J)-XOPT(J)
+      XOPT(J)=ZERO
+      PTSAUX(1,J)=DMIN1(DELTA,SU(J))
+      PTSAUX(2,J)=DMAX1(-DELTA,SL(J))
+      IF (PTSAUX(1,J)+PTSAUX(2,J) .LT. ZERO) THEN
+          TEMP=PTSAUX(1,J)
+          PTSAUX(1,J)=PTSAUX(2,J)
+          PTSAUX(2,J)=TEMP
+      END IF
+      IF (DABS(PTSAUX(2,J)) .LT. HALF*DABS(PTSAUX(1,J))) THEN
+          PTSAUX(2,J)=HALF*PTSAUX(1,J)
+      END IF
+      DO 50 I=1,NDIM
+   50 BMAT(I,J)=ZERO
+      FBASE=FVAL(KOPT)
+C
+C     Set the identifiers of the artificial interpolation points that are
+C     along a coordinate direction from XOPT, and set the corresponding
+C     nonzero elements of BMAT and ZMAT.
+C
+      PTSID(1)=SFRAC
+      DO 60 J=1,N
+      JP=J+1
+      JPN=JP+N
+      PTSID(JP)=DFLOAT(J)+SFRAC
+      IF (JPN .LE. NPT) THEN
+          PTSID(JPN)=DFLOAT(J)/DFLOAT(NP)+SFRAC
+          TEMP=ONE/(PTSAUX(1,J)-PTSAUX(2,J))
+          BMAT(JP,J)=-TEMP+ONE/PTSAUX(1,J)
+          BMAT(JPN,J)=TEMP+ONE/PTSAUX(2,J)
+          BMAT(1,J)=-BMAT(JP,J)-BMAT(JPN,J)
+          ZMAT(1,J)=DSQRT(2.0D0)/DABS(PTSAUX(1,J)*PTSAUX(2,J))
+          ZMAT(JP,J)=ZMAT(1,J)*PTSAUX(2,J)*TEMP
+          ZMAT(JPN,J)=-ZMAT(1,J)*PTSAUX(1,J)*TEMP
+      ELSE
+          BMAT(1,J)=-ONE/PTSAUX(1,J)
+          BMAT(JP,J)=ONE/PTSAUX(1,J)
+          BMAT(J+NPT,J)=-HALF*PTSAUX(1,J)**2
+      END IF
+   60 CONTINUE
+C
+C     Set any remaining identifiers with their nonzero elements of ZMAT.
+C
+      IF (NPT .GE. N+NP) THEN
+          DO 70 K=2*NP,NPT
+          IW=(DFLOAT(K-NP)-HALF)/DFLOAT(N)
+          IP=K-NP-IW*N
+          IQ=IP+IW
+          IF (IQ .GT. N) IQ=IQ-N
+          PTSID(K)=DFLOAT(IP)+DFLOAT(IQ)/DFLOAT(NP)+SFRAC
+          TEMP=ONE/(PTSAUX(1,IP)*PTSAUX(1,IQ))
+          ZMAT(1,K-NP)=TEMP
+          ZMAT(IP+1,K-NP)=-TEMP
+          ZMAT(IQ+1,K-NP)=-TEMP
+   70     ZMAT(K,K-NP)=TEMP
+      END IF
+      NREM=NPT
+      KOLD=1
+      KNEW=KOPT
+C
+C     Reorder the provisional points in the way that exchanges PTSID(KOLD)
+C     with PTSID(KNEW).
+C
+   80 DO 90 J=1,N
+      TEMP=BMAT(KOLD,J)
+      BMAT(KOLD,J)=BMAT(KNEW,J)
+   90 BMAT(KNEW,J)=TEMP
+      DO 100 J=1,NPTM
+      TEMP=ZMAT(KOLD,J)
+      ZMAT(KOLD,J)=ZMAT(KNEW,J)
+  100 ZMAT(KNEW,J)=TEMP
+      PTSID(KOLD)=PTSID(KNEW)
+      PTSID(KNEW)=ZERO
+      W(NDIM+KNEW)=ZERO
+      NREM=NREM-1
+      IF (KNEW .NE. KOPT) THEN
+          TEMP=VLAG(KOLD)
+          VLAG(KOLD)=VLAG(KNEW)
+          VLAG(KNEW)=TEMP
+C
+C     Update the BMAT and ZMAT matrices so that the status of the KNEW-th
+C     interpolation point can be changed from provisional to original. The
+C     branch to label 350 occurs if all the original points are reinstated.
+C     The nonnegative values of W(NDIM+K) are required in the search below.
+C
+          CALL UPDATE (N,NPT,BMAT,ZMAT,NDIM,VLAG,BETA,DENOM,KNEW,W)
+          IF (NREM .EQ. 0) GOTO 350
+          DO 110 K=1,NPT
+  110     W(NDIM+K)=DABS(W(NDIM+K))
+      END IF
+C
+C     Pick the index KNEW of an original interpolation point that has not
+C     yet replaced one of the provisional interpolation points, giving
+C     attention to the closeness to XOPT and to previous tries with KNEW.
+C
+  120 DSQMIN=ZERO
+      DO 130 K=1,NPT
+      IF (W(NDIM+K) .GT. ZERO) THEN
+          IF (DSQMIN .EQ. ZERO .OR. W(NDIM+K) .LT. DSQMIN) THEN
+              KNEW=K
+              DSQMIN=W(NDIM+K)
+          END IF
+      END IF
+  130 CONTINUE
+      IF (DSQMIN .EQ. ZERO) GOTO 260
+C
+C     Form the W-vector of the chosen original interpolation point.
+C
+      DO 140 J=1,N
+  140 W(NPT+J)=XPT(KNEW,J)
+      DO 160 K=1,NPT
+      SUM=ZERO
+      IF (K .EQ. KOPT) THEN
+          CONTINUE
+      ELSE IF (PTSID(K) .EQ. ZERO) THEN
+          DO 150 J=1,N
+  150     SUM=SUM+W(NPT+J)*XPT(K,J)
+      ELSE
+          IP=PTSID(K)
+          IF (IP .GT. 0) SUM=W(NPT+IP)*PTSAUX(1,IP)
+          IQ=DFLOAT(NP)*PTSID(K)-DFLOAT(IP*NP)
+          IF (IQ .GT. 0) THEN
+              IW=1
+              IF (IP .EQ. 0) IW=2
+              SUM=SUM+W(NPT+IQ)*PTSAUX(IW,IQ)
+          END IF
+      END IF
+  160 W(K)=HALF*SUM*SUM
+C
+C     Calculate VLAG and BETA for the required updating of the H matrix if
+C     XPT(KNEW,.) is reinstated in the set of interpolation points.
+C
+      DO 180 K=1,NPT
+      SUM=ZERO
+      DO 170 J=1,N
+  170 SUM=SUM+BMAT(K,J)*W(NPT+J)
+  180 VLAG(K)=SUM
+      BETA=ZERO
+      DO 200 J=1,NPTM
+      SUM=ZERO
+      DO 190 K=1,NPT
+  190 SUM=SUM+ZMAT(K,J)*W(K)
+      BETA=BETA-SUM*SUM
+      DO 200 K=1,NPT
+  200 VLAG(K)=VLAG(K)+SUM*ZMAT(K,J)
+      BSUM=ZERO
+      DISTSQ=ZERO
+      DO 230 J=1,N
+      SUM=ZERO
+      DO 210 K=1,NPT
+  210 SUM=SUM+BMAT(K,J)*W(K)
+      JP=J+NPT
+      BSUM=BSUM+SUM*W(JP)
+      DO 220 IP=NPT+1,NDIM
+  220 SUM=SUM+BMAT(IP,J)*W(IP)
+      BSUM=BSUM+SUM*W(JP)
+      VLAG(JP)=SUM
+  230 DISTSQ=DISTSQ+XPT(KNEW,J)**2
+      BETA=HALF*DISTSQ*DISTSQ+BETA-BSUM
+      VLAG(KOPT)=VLAG(KOPT)+ONE
+C
+C     KOLD is set to the index of the provisional interpolation point that is
+C     going to be deleted to make way for the KNEW-th original interpolation
+C     point. The choice of KOLD is governed by the avoidance of a small value
+C     of the denominator in the updating calculation of UPDATE.
+C
+      DENOM=ZERO
+      VLMXSQ=ZERO
+      DO 250 K=1,NPT
+      IF (PTSID(K) .NE. ZERO) THEN
+          HDIAG=ZERO
+          DO 240 J=1,NPTM
+  240     HDIAG=HDIAG+ZMAT(K,J)**2
+          DEN=BETA*HDIAG+VLAG(K)**2
+          IF (DEN .GT. DENOM) THEN
+              KOLD=K
+              DENOM=DEN
+          END IF
+      END IF
+  250 VLMXSQ=DMAX1(VLMXSQ,VLAG(K)**2)
+      IF (DENOM .LE. 1.0D-2*VLMXSQ) THEN
+          W(NDIM+KNEW)=-W(NDIM+KNEW)-WINC
+          GOTO 120
+      END IF
+      GOTO 80
+C
+C     When label 260 is reached, all the final positions of the interpolation
+C     points have been chosen although any changes have not been included yet
+C     in XPT. Also the final BMAT and ZMAT matrices are complete, but, apart
+C     from the shift of XBASE, the updating of the quadratic model remains to
+C     be done. The following cycle through the new interpolation points begins
+C     by putting the new point in XPT(KPT,.) and by setting PQ(KPT) to zero,
+C     except that a RETURN occurs if MAXFUN prohibits another value of F.
+C
+  260 DO 340 KPT=1,NPT
+      IF (PTSID(KPT) .EQ. ZERO) GOTO 340
+      IF (NF .GE. MAXFUN) THEN
+          NF=-1
+          GOTO 350
+      END IF
+      IH=0
+      DO 270 J=1,N
+      W(J)=XPT(KPT,J)
+      XPT(KPT,J)=ZERO
+      TEMP=PQ(KPT)*W(J)
+      DO 270 I=1,J
+      IH=IH+1
+  270 HQ(IH)=HQ(IH)+TEMP*W(I)
+      PQ(KPT)=ZERO
+      IP=PTSID(KPT)
+      IQ=DFLOAT(NP)*PTSID(KPT)-DFLOAT(IP*NP)
+      IF (IP .GT. 0) THEN
+          XP=PTSAUX(1,IP)
+          XPT(KPT,IP)=XP
+      END IF
+      IF (IQ .GT. 0) THEN
+          XQ=PTSAUX(1,IQ)
+          IF (IP .EQ. 0) XQ=PTSAUX(2,IQ)
+          XPT(KPT,IQ)=XQ
+      END IF
+C
+C     Set VQUAD to the value of the current model at the new point.
+C
+      VQUAD=FBASE
+      IF (IP .GT. 0) THEN
+          IHP=(IP+IP*IP)/2
+          VQUAD=VQUAD+XP*(GOPT(IP)+HALF*XP*HQ(IHP))
+      END IF
+      IF (IQ .GT. 0) THEN
+          IHQ=(IQ+IQ*IQ)/2
+          VQUAD=VQUAD+XQ*(GOPT(IQ)+HALF*XQ*HQ(IHQ))
+          IF (IP .GT. 0) THEN
+              IW=MAX0(IHP,IHQ)-IABS(IP-IQ)
+              VQUAD=VQUAD+XP*XQ*HQ(IW)
+          END IF
+      END IF
+      DO 280 K=1,NPT
+      TEMP=ZERO
+      IF (IP .GT. 0) TEMP=TEMP+XP*XPT(K,IP)
+      IF (IQ .GT. 0) TEMP=TEMP+XQ*XPT(K,IQ)
+  280 VQUAD=VQUAD+HALF*PQ(K)*TEMP*TEMP
+C
+C     Calculate F at the new interpolation point, and set DIFF to the factor
+C     that is going to multiply the KPT-th Lagrange function when the model
+C     is updated to provide interpolation to the new function value.
+C
+      DO 290 I=1,N
+      W(I)=DMIN1(DMAX1(XL(I),XBASE(I)+XPT(KPT,I)),XU(I))
+      IF (XPT(KPT,I) .EQ. SL(I)) W(I)=XL(I)
+      IF (XPT(KPT,I) .EQ. SU(I)) W(I)=XU(I)
+  290 CONTINUE
+      NF=NF+1
+      CALL CALFUN (N,W,F)
+      IF (IPRINT .EQ. 3) THEN
+          PRINT 300, NF,F,(W(I),I=1,N)
+  300     FORMAT (/4X,'Function number',I6,'    F =',1PD18.10,
+     1      '    The corresponding X is:'/(2X,5D15.6))
+      END IF
+      FVAL(KPT)=F
+      IF (F .LT. FVAL(KOPT)) KOPT=KPT
+      DIFF=F-VQUAD
+C
+C     Update the quadratic model. The RETURN from the subroutine occurs when
+C     all the new interpolation points are included in the model.
+C
+      DO 310 I=1,N
+  310 GOPT(I)=GOPT(I)+DIFF*BMAT(KPT,I)
+      DO 330 K=1,NPT
+      SUM=ZERO
+      DO 320 J=1,NPTM
+  320 SUM=SUM+ZMAT(K,J)*ZMAT(KPT,J)
+      TEMP=DIFF*SUM
+      IF (PTSID(K) .EQ. ZERO) THEN
+          PQ(K)=PQ(K)+TEMP
+      ELSE
+          IP=PTSID(K)
+          IQ=DFLOAT(NP)*PTSID(K)-DFLOAT(IP*NP)
+          IHQ=(IQ*IQ+IQ)/2
+          IF (IP .EQ. 0) THEN
+              HQ(IHQ)=HQ(IHQ)+TEMP*PTSAUX(2,IQ)**2
+          ELSE
+              IHP=(IP*IP+IP)/2
+              HQ(IHP)=HQ(IHP)+TEMP*PTSAUX(1,IP)**2
+              IF (IQ .GT. 0) THEN
+                  HQ(IHQ)=HQ(IHQ)+TEMP*PTSAUX(1,IQ)**2
+                  IW=MAX0(IHP,IHQ)-IABS(IQ-IP)
+                  HQ(IW)=HQ(IW)+TEMP*PTSAUX(1,IP)*PTSAUX(1,IQ)
+              END IF
+          END IF
+      END IF
+  330 CONTINUE
+      PTSID(KPT)=ZERO
+  340 CONTINUE
+  350 RETURN
+      END SUBROUTINE RESCUE
+	  
+	  SUBROUTINE TRSBOX (N,NPT,XPT,XOPT,GOPT,HQ,PQ,SL,SU,DELTA,
+     1  XNEW,D,GNEW,XBDI,S,HS,HRED,DSQ,CRVMIN)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION XPT(NPT,*),XOPT(*),GOPT(*),HQ(*),PQ(*),SL(*),SU(*),
+     1  XNEW(*),D(*),GNEW(*),XBDI(*),S(*),HS(*),HRED(*)
+C
+C     The arguments N, NPT, XPT, XOPT, GOPT, HQ, PQ, SL and SU have the same
+C       meanings as the corresponding arguments of BOBYQB.
+C     DELTA is the trust region radius for the present calculation, which
+C       seeks a small value of the quadratic model within distance DELTA of
+C       XOPT subject to the bounds on the variables.
+C     XNEW will be set to a new vector of variables that is approximately
+C       the one that minimizes the quadratic model within the trust region
+C       subject to the SL and SU constraints on the variables. It satisfies
+C       as equations the bounds that become active during the calculation.
+C     D is the calculated trial step from XOPT, generated iteratively from an
+C       initial value of zero. Thus XNEW is XOPT+D after the final iteration.
+C     GNEW holds the gradient of the quadratic model at XOPT+D. It is updated
+C       when D is updated.
+C     XBDI is a working space vector. For I=1,2,...,N, the element XBDI(I) is
+C       set to -1.0, 0.0, or 1.0, the value being nonzero if and only if the
+C       I-th variable has become fixed at a bound, the bound being SL(I) or
+C       SU(I) in the case XBDI(I)=-1.0 or XBDI(I)=1.0, respectively. This
+C       information is accumulated during the construction of XNEW.
+C     The arrays S, HS and HRED are also used for working space. They hold the
+C       current search direction, and the changes in the gradient of Q along S
+C       and the reduced D, respectively, where the reduced D is the same as D,
+C       except that the components of the fixed variables are zero.
+C     DSQ will be set to the square of the length of XNEW-XOPT.
+C     CRVMIN is set to zero if D reaches the trust region boundary. Otherwise
+C       it is set to the least curvature of H that occurs in the conjugate
+C       gradient searches that are not restricted by any constraints. The
+C       value CRVMIN=-1.0D0 is set, however, if all of these searches are
+C       constrained.
+C
+C     A version of the truncated conjugate gradient is applied. If a line
+C     search is restricted by a constraint, then the procedure is restarted,
+C     the values of the variables that are at their bounds being fixed. If
+C     the trust region boundary is reached, then further changes may be made
+C     to D, each one being in the two dimensional space that is spanned
+C     by the current D and the gradient of Q at XOPT+D, staying on the trust
+C     region boundary. Termination occurs when the reduction in Q seems to
+C     be close to the greatest reduction that can be achieved.
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      ONEMIN=-1.0D0
+      ZERO=0.0D0
+C
+C     The sign of GOPT(I) gives the sign of the change to the I-th variable
+C     that will reduce Q from its value at XOPT. Thus XBDI(I) shows whether
+C     or not to fix the I-th variable at one of its bounds initially, with
+C     NACT being set to the number of fixed variables. D and GNEW are also
+C     set for the first iteration. DELSQ is the upper bound on the sum of
+C     squares of the free variables. QRED is the reduction in Q so far.
+C
+      ITERC=0
+      NACT=0
+      SQSTP=ZERO
+      DO 10 I=1,N
+      XBDI(I)=ZERO
+      IF (XOPT(I) .LE. SL(I)) THEN
+          IF (GOPT(I) .GE. ZERO) XBDI(I)=ONEMIN
+      ELSE IF (XOPT(I) .GE. SU(I)) THEN
+          IF (GOPT(I) .LE. ZERO) XBDI(I)=ONE
+      END IF
+      IF (XBDI(I) .NE. ZERO) NACT=NACT+1
+      D(I)=ZERO
+   10 GNEW(I)=GOPT(I)
+      DELSQ=DELTA*DELTA
+      QRED=ZERO
+      CRVMIN=ONEMIN
+C
+C     Set the next search direction of the conjugate gradient method. It is
+C     the steepest descent direction initially and when the iterations are
+C     restarted because a variable has just been fixed by a bound, and of
+C     course the components of the fixed variables are zero. ITERMAX is an
+C     upper bound on the indices of the conjugate gradient iterations.
+C
+   20 BETA=ZERO
+   30 STEPSQ=ZERO
+      DO 40 I=1,N
+      IF (XBDI(I) .NE. ZERO) THEN
+          S(I)=ZERO
+      ELSE IF (BETA .EQ. ZERO) THEN
+          S(I)=-GNEW(I)
+      ELSE
+          S(I)=BETA*S(I)-GNEW(I)
+      END IF
+   40 STEPSQ=STEPSQ+S(I)**2
+      IF (STEPSQ .EQ. ZERO) GOTO 190
+      IF (BETA .EQ. ZERO) THEN
+          GREDSQ=STEPSQ
+          ITERMAX=ITERC+N-NACT
+      END IF
+      IF (GREDSQ*DELSQ .LE. 1.0D-4*QRED*QRED) GO TO 190
+C
+C     Multiply the search direction by the second derivative matrix of Q and
+C     calculate some scalars for the choice of steplength. Then set BLEN to
+C     the length of the the step to the trust region boundary and STPLEN to
+C     the steplength, ignoring the simple bounds.
+C
+      GOTO 210
+   50 RESID=DELSQ
+      DS=ZERO
+      SHS=ZERO
+      DO 60 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          RESID=RESID-D(I)**2
+          DS=DS+S(I)*D(I)
+          SHS=SHS+S(I)*HS(I)
+      END IF
+   60 CONTINUE
+      IF (RESID .LE. ZERO) GOTO 90
+      TEMP=DSQRT(STEPSQ*RESID+DS*DS)
+      IF (DS .LT. ZERO) THEN
+          BLEN=(TEMP-DS)/STEPSQ
+      ELSE
+          BLEN=RESID/(TEMP+DS)
+      END IF
+      STPLEN=BLEN
+      IF (SHS .GT. ZERO) THEN
+          STPLEN=DMIN1(BLEN,GREDSQ/SHS)
+      END IF
+      
+C
+C     Reduce STPLEN if necessary in order to preserve the simple bounds,
+C     letting IACT be the index of the new constrained variable.
+C
+      IACT=0
+      DO 70 I=1,N
+      IF (S(I) .NE. ZERO) THEN
+          XSUM=XOPT(I)+D(I)
+          IF (S(I) .GT. ZERO) THEN
+              TEMP=(SU(I)-XSUM)/S(I)
+          ELSE
+              TEMP=(SL(I)-XSUM)/S(I)
+          END IF
+          IF (TEMP .LT. STPLEN) THEN
+              STPLEN=TEMP
+              IACT=I
+          END IF
+      END IF
+   70 CONTINUE
+C
+C     Update CRVMIN, GNEW and D. Set SDEC to the decrease that occurs in Q.
+C
+      SDEC=ZERO
+      IF (STPLEN .GT. ZERO) THEN
+          ITERC=ITERC+1
+          TEMP=SHS/STEPSQ
+          IF (IACT .EQ. 0 .AND. TEMP .GT. ZERO) THEN
+              CRVMIN=DMIN1(CRVMIN,TEMP)
+              IF (CRVMIN .EQ. ONEMIN) CRVMIN=TEMP
+          END IF 
+          GGSAV=GREDSQ
+          GREDSQ=ZERO
+          DO 80 I=1,N
+          GNEW(I)=GNEW(I)+STPLEN*HS(I)
+          IF (XBDI(I) .EQ. ZERO) GREDSQ=GREDSQ+GNEW(I)**2
+   80     D(I)=D(I)+STPLEN*S(I)
+          SDEC=DMAX1(STPLEN*(GGSAV-HALF*STPLEN*SHS),ZERO)
+          QRED=QRED+SDEC
+      END IF
+C
+C     Restart the conjugate gradient method if it has hit a new bound.
+C
+      IF (IACT .GT. 0) THEN
+          NACT=NACT+1
+          XBDI(IACT)=ONE
+          IF (S(IACT) .LT. ZERO) XBDI(IACT)=ONEMIN
+          DELSQ=DELSQ-D(IACT)**2
+          IF (DELSQ .LE. ZERO) GOTO 90
+          GOTO 20
+      END IF
+C
+C     If STPLEN is less than BLEN, then either apply another conjugate
+C     gradient iteration or RETURN.
+C
+      IF (STPLEN .LT. BLEN) THEN
+          IF (ITERC .EQ. ITERMAX) GOTO 190
+          IF (SDEC .LE. 0.01D0*QRED) GOTO 190
+          BETA=GREDSQ/GGSAV
+          GOTO 30
+      END IF
+   90 CRVMIN=ZERO
+C
+C     Prepare for the alternative iteration by calculating some scalars and
+C     by multiplying the reduced D by the second derivative matrix of Q.
+C
+  100 IF (NACT .GE. N-1) GOTO 190
+      DREDSQ=ZERO
+      DREDG=ZERO
+      GREDSQ=ZERO
+      DO 110 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          DREDSQ=DREDSQ+D(I)**2
+          DREDG=DREDG+D(I)*GNEW(I)
+          GREDSQ=GREDSQ+GNEW(I)**2
+          S(I)=D(I)
+      ELSE
+          S(I)=ZERO
+      END IF
+  110 CONTINUE
+      ITCSAV=ITERC
+      GOTO 210
+C
+C     Let the search direction S be a linear combination of the reduced D
+C     and the reduced G that is orthogonal to the reduced D.
+C
+  120 ITERC=ITERC+1
+      TEMP=GREDSQ*DREDSQ-DREDG*DREDG
+      IF (TEMP .LE. 1.0D-4*QRED*QRED) GOTO 190
+      TEMP=DSQRT(TEMP)
+      DO 130 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          S(I)=(DREDG*D(I)-DREDSQ*GNEW(I))/TEMP
+      ELSE
+          S(I)=ZERO
+      END IF
+  130 CONTINUE
+      SREDG=-TEMP
+C
+C     By considering the simple bounds on the variables, calculate an upper
+C     bound on the tangent of half the angle of the alternative iteration,
+C     namely ANGBD, except that, if already a free variable has reached a
+C     bound, there is a branch back to label 100 after fixing that variable.
+C
+      ANGBD=ONE
+      IACT=0
+      DO 140 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          TEMPA=XOPT(I)+D(I)-SL(I)
+          TEMPB=SU(I)-XOPT(I)-D(I)
+          IF (TEMPA .LE. ZERO) THEN
+              NACT=NACT+1
+              XBDI(I)=ONEMIN
+              GOTO 100
+          ELSE IF (TEMPB .LE. ZERO) THEN
+              NACT=NACT+1
+              XBDI(I)=ONE
+              GOTO 100
+          END IF
+          RATIO=ONE
+          SSQ=D(I)**2+S(I)**2
+          TEMP=SSQ-(XOPT(I)-SL(I))**2
+          IF (TEMP .GT. ZERO) THEN
+              TEMP=DSQRT(TEMP)-S(I)
+              IF (ANGBD*TEMP .GT. TEMPA) THEN
+                  ANGBD=TEMPA/TEMP
+                  IACT=I
+                  XSAV=ONEMIN
+              END IF
+          END IF
+          TEMP=SSQ-(SU(I)-XOPT(I))**2
+          IF (TEMP .GT. ZERO) THEN
+              TEMP=DSQRT(TEMP)+S(I)
+              IF (ANGBD*TEMP .GT. TEMPB) THEN
+                  ANGBD=TEMPB/TEMP
+                  IACT=I
+                  XSAV=ONE
+              END IF
+          END IF
+      END IF
+  140 CONTINUE
+C
+C     Calculate HHD and some curvatures for the alternative iteration.
+C
+      GOTO 210
+  150 SHS=ZERO
+      DHS=ZERO
+      DHD=ZERO
+      DO 160 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          SHS=SHS+S(I)*HS(I)
+          DHS=DHS+D(I)*HS(I)
+          DHD=DHD+D(I)*HRED(I)
+      END IF
+  160 CONTINUE
+C
+C     Seek the greatest reduction in Q for a range of equally spaced values
+C     of ANGT in [0,ANGBD], where ANGT is the tangent of half the angle of
+C     the alternative iteration.
+C
+      REDMAX=ZERO
+      ISAV=0
+      REDSAV=ZERO
+      IU=17.0D0*ANGBD+3.1D0
+      DO 170 I=1,IU
+      ANGT=ANGBD*DFLOAT(I)/DFLOAT(IU)
+      STH=(ANGT+ANGT)/(ONE+ANGT*ANGT)
+      TEMP=SHS+ANGT*(ANGT*DHD-DHS-DHS)
+      REDNEW=STH*(ANGT*DREDG-SREDG-HALF*STH*TEMP)
+      IF (REDNEW .GT. REDMAX) THEN
+          REDMAX=REDNEW
+          ISAV=I
+          RDPREV=REDSAV
+      ELSE IF (I .EQ. ISAV+1) THEN
+          RDNEXT=REDNEW
+      END IF
+  170 REDSAV=REDNEW
+C
+C     Return if the reduction is zero. Otherwise, set the sine and cosine
+C     of the angle of the alternative iteration, and calculate SDEC.
+C
+      IF (ISAV .EQ. 0) GOTO 190
+      IF (ISAV .LT. IU) THEN
+          TEMP=(RDNEXT-RDPREV)/(REDMAX+REDMAX-RDPREV-RDNEXT)
+          ANGT=ANGBD*(DFLOAT(ISAV)+HALF*TEMP)/DFLOAT(IU)
+      END IF
+      CTH=(ONE-ANGT*ANGT)/(ONE+ANGT*ANGT)
+      STH=(ANGT+ANGT)/(ONE+ANGT*ANGT)
+      TEMP=SHS+ANGT*(ANGT*DHD-DHS-DHS)
+      SDEC=STH*(ANGT*DREDG-SREDG-HALF*STH*TEMP)
+      IF (SDEC .LE. ZERO) GOTO 190
+C
+C     Update GNEW, D and HRED. If the angle of the alternative iteration
+C     is restricted by a bound on a free variable, that variable is fixed
+C     at the bound.
+C
+      DREDG=ZERO
+      GREDSQ=ZERO
+      DO 180 I=1,N
+      GNEW(I)=GNEW(I)+(CTH-ONE)*HRED(I)+STH*HS(I)
+      IF (XBDI(I) .EQ. ZERO) THEN
+          D(I)=CTH*D(I)+STH*S(I)
+          DREDG=DREDG+D(I)*GNEW(I)
+          GREDSQ=GREDSQ+GNEW(I)**2
+      END IF
+  180 HRED(I)=CTH*HRED(I)+STH*HS(I)
+      QRED=QRED+SDEC
+      IF (IACT .GT. 0 .AND. ISAV .EQ. IU) THEN
+          NACT=NACT+1
+          XBDI(IACT)=XSAV
+          GOTO 100
+      END IF
+C
+C     If SDEC is sufficiently small, then RETURN after setting XNEW to
+C     XOPT+D, giving careful attention to the bounds.
+C
+      IF (SDEC .GT. 0.01D0*QRED) GOTO 120
+  190 DSQ=ZERO
+      DO 200 I=1,N
+      XNEW(I)=DMAX1(DMIN1(XOPT(I)+D(I),SU(I)),SL(I))
+      IF (XBDI(I) .EQ. ONEMIN) XNEW(I)=SL(I)
+      IF (XBDI(I) .EQ. ONE) XNEW(I)=SU(I)
+      D(I)=XNEW(I)-XOPT(I)
+  200 DSQ=DSQ+D(I)**2
+      RETURN
+ 
+C     The following instructions multiply the current S-vector by the second
+C     derivative matrix of the quadratic model, putting the product in HS.
+C     They are reached from three different parts of the software above and
+C     they can be regarded as an external subroutine.
+C
+  210 IH=0
+      DO 220 J=1,N
+      HS(J)=ZERO
+      DO 220 I=1,J
+      IH=IH+1
+      IF (I .LT. J) HS(J)=HS(J)+HQ(IH)*S(I)
+  220 HS(I)=HS(I)+HQ(IH)*S(J)
+      DO 250 K=1,NPT
+      IF (PQ(K) .NE. ZERO) THEN
+          TEMP=ZERO
+          DO 230 J=1,N
+  230     TEMP=TEMP+XPT(K,J)*S(J)
+          TEMP=TEMP*PQ(K)
+          DO 240 I=1,N
+  240     HS(I)=HS(I)+TEMP*XPT(K,I)
+      END IF
+  250 CONTINUE
+      IF (CRVMIN .NE. ZERO) GOTO 50
+      IF (ITERC .GT. ITCSAV) GOTO 150
+      DO 260 I=1,N
+  260 HRED(I)=HS(I)
+      GOTO 120
+      END SUBROUTINE TRSBOX
+
+      SUBROUTINE UPDATE (N,NPT,BMAT,ZMAT,NDIM,VLAG,BETA,DENOM,
+     1  KNEW,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION BMAT(NDIM,*),ZMAT(NPT,*),VLAG(*),W(*)
+C
+C     The arrays BMAT and ZMAT are updated, as required by the new position
+C     of the interpolation point that has the index KNEW. The vector VLAG has
+C     N+NPT components, set on entry to the first NPT and last N components
+C     of the product Hw in equation (4.11) of the Powell (2006) paper on
+C     NEWUOA. Further, BETA is set on entry to the value of the parameter
+C     with that name, and DENOM is set to the denominator of the updating
+C     formula. Elements of ZMAT may be treated as zero if their moduli are
+C     at most ZTEST. The first NDIM elements of W are used for working space.
+C
+C     Set some constants.
+C
+      ONE=1.0D0
+      ZERO=0.0D0
+      NPTM=NPT-N-1
+      ZTEST=ZERO
+      DO 10 K=1,NPT
+      DO 10 J=1,NPTM
+   10 ZTEST=DMAX1(ZTEST,DABS(ZMAT(K,J)))
+      ZTEST=1.0D-20*ZTEST
+C
+C     Apply the rotations that put zeros in the KNEW-th row of ZMAT.
+C
+      JL=1
+      DO 30 J=2,NPTM
+      IF (DABS(ZMAT(KNEW,J)) .GT. ZTEST) THEN
+          TEMP=DSQRT(ZMAT(KNEW,1)**2+ZMAT(KNEW,J)**2)
+          TEMPA=ZMAT(KNEW,1)/TEMP
+          TEMPB=ZMAT(KNEW,J)/TEMP
+          DO 20 I=1,NPT
+          TEMP=TEMPA*ZMAT(I,1)+TEMPB*ZMAT(I,J)
+          ZMAT(I,J)=TEMPA*ZMAT(I,J)-TEMPB*ZMAT(I,1)
+   20     ZMAT(I,1)=TEMP
+      END IF
+      ZMAT(KNEW,J)=ZERO
+   30 CONTINUE
+C
+C     Put the first NPT components of the KNEW-th column of HLAG into W,
+C     and calculate the parameters of the updating formula.
+C
+      DO 40 I=1,NPT
+      W(I)=ZMAT(KNEW,1)*ZMAT(I,1)
+   40 CONTINUE
+      ALPHA=W(KNEW)
+      TAU=VLAG(KNEW)
+      VLAG(KNEW)=VLAG(KNEW)-ONE
+C
+C     Complete the updating of ZMAT.
+C
+      TEMP=DSQRT(DENOM)
+      TEMPB=ZMAT(KNEW,1)/TEMP
+      TEMPA=TAU/TEMP
+      DO 50 I=1,NPT
+   50 ZMAT(I,1)=TEMPA*ZMAT(I,1)-TEMPB*VLAG(I)
+C
+C     Finally, update the matrix BMAT.
+C
+      DO 60 J=1,N
+      JP=NPT+J
+      W(JP)=BMAT(KNEW,J)
+      TEMPA=(ALPHA*VLAG(JP)-TAU*W(JP))/DENOM
+      TEMPB=(-BETA*W(JP)-TAU*VLAG(JP))/DENOM
+      DO 60 I=1,JP
+      BMAT(I,J)=BMAT(I,J)+TEMPA*VLAG(I)+TEMPB*W(I)
+      IF (I .GT. NPT) BMAT(JP,I-NPT)=BMAT(I,J)
+   60 CONTINUE
+      RETURN
+      END SUBROUTINE UPDATE
+
+      SUBROUTINE ALTMOV (N,NPT,XPT,XOPT,BMAT,ZMAT,NDIM,SL,SU,KOPT,
+     1  KNEW,ADELT,XNEW,XALT,ALPHA,CAUCHY,GLAG,HCOL,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION XPT(NPT,*),XOPT(*),BMAT(NDIM,*),ZMAT(NPT,*),SL(*),
+     1  SU(*),XNEW(*),XALT(*),GLAG(*),HCOL(*),W(*)
+C
+C     The arguments N, NPT, XPT, XOPT, BMAT, ZMAT, NDIM, SL and SU all have
+C       the same meanings as the corresponding arguments of BOBYQB.
+C     KOPT is the index of the optimal interpolation point.
+C     KNEW is the index of the interpolation point that is going to be moved.
+C     ADELT is the current trust region bound.
+C     XNEW will be set to a suitable new position for the interpolation point
+C       XPT(KNEW,.). Specifically, it satisfies the SL, SU and trust region
+C       bounds and it should provide a large denominator in the next call of
+C       UPDATE. The step XNEW-XOPT from XOPT is restricted to moves along the
+C       straight lines through XOPT and another interpolation point.
+C     XALT also provides a large value of the modulus of the KNEW-th Lagrange
+C       function subject to the constraints that have been mentioned, its main
+C       difference from XNEW being that XALT-XOPT is a constrained version of
+C       the Cauchy step within the trust region. An exception is that XALT is
+C       not calculated if all components of GLAG (see below) are zero.
+C     ALPHA will be set to the KNEW-th diagonal element of the H matrix.
+C     CAUCHY will be set to the square of the KNEW-th Lagrange function at
+C       the step XALT-XOPT from XOPT for the vector XALT that is returned,
+C       except that CAUCHY is set to zero if XALT is not calculated.
+C     GLAG is a working space vector of length N for the gradient of the
+C       KNEW-th Lagrange function at XOPT.
+C     HCOL is a working space vector of length NPT for the second derivative
+C       coefficients of the KNEW-th Lagrange function.
+C     W is a working space vector of length 2N that is going to hold the
+C       constrained Cauchy step from XOPT of the Lagrange function, followed
+C       by the downhill version of XALT when the uphill step is calculated.
+C
+C     Set the first NPT components of W to the leading elements of the
+C     KNEW-th column of the H matrix.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      ZERO=0.0D0
+      CONST=ONE+DSQRT(2.0D0)
+      DO 10 K=1,NPT
+   10 HCOL(K)=ZERO
+      DO 20 J=1,NPT-N-1
+      TEMP=ZMAT(KNEW,J)
+      DO 20 K=1,NPT
+   20 HCOL(K)=HCOL(K)+TEMP*ZMAT(K,J)
+      ALPHA=HCOL(KNEW)
+      HA=HALF*ALPHA
+C
+C     Calculate the gradient of the KNEW-th Lagrange function at XOPT.
+C
+      DO 30 I=1,N
+   30 GLAG(I)=BMAT(KNEW,I)
+      DO 50 K=1,NPT
+      TEMP=ZERO
+      DO 40 J=1,N
+   40 TEMP=TEMP+XPT(K,J)*XOPT(J)
+      TEMP=HCOL(K)*TEMP
+      DO 50 I=1,N
+   50 GLAG(I)=GLAG(I)+TEMP*XPT(K,I)
+C
+C     Search for a large denominator along the straight lines through XOPT
+C     and another interpolation point. SLBD and SUBD will be lower and upper
+C     bounds on the step along each of these lines in turn. PREDSQ will be
+C     set to the square of the predicted denominator for each line. PRESAV
+C     will be set to the largest admissible value of PREDSQ that occurs.
+C
+      PRESAV=ZERO
+      DO 80 K=1,NPT
+      IF (K .EQ. KOPT) GOTO 80
+      DDERIV=ZERO
+      DISTSQ=ZERO
+      DO 60 I=1,N
+      TEMP=XPT(K,I)-XOPT(I)
+      DDERIV=DDERIV+GLAG(I)*TEMP
+   60 DISTSQ=DISTSQ+TEMP*TEMP
+      SUBD=ADELT/DSQRT(DISTSQ)
+      SLBD=-SUBD
+      ILBD=0
+      IUBD=0
+      SUMIN=DMIN1(ONE,SUBD)
+C
+C     Revise SLBD and SUBD if necessary because of the bounds in SL and SU.
+C
+      DO 70 I=1,N
+      TEMP=XPT(K,I)-XOPT(I)
+      IF (TEMP .GT. ZERO) THEN
+          IF (SLBD*TEMP .LT. SL(I)-XOPT(I)) THEN
+              SLBD=(SL(I)-XOPT(I))/TEMP
+              ILBD=-I
+          END IF
+          IF (SUBD*TEMP .GT. SU(I)-XOPT(I)) THEN
+              SUBD=DMAX1(SUMIN,(SU(I)-XOPT(I))/TEMP)
+              IUBD=I
+          END IF
+      ELSE IF (TEMP .LT. ZERO) THEN
+          IF (SLBD*TEMP .GT. SU(I)-XOPT(I)) THEN
+              SLBD=(SU(I)-XOPT(I))/TEMP
+              ILBD=I
+          END IF
+          IF (SUBD*TEMP .LT. SL(I)-XOPT(I)) THEN
+              SUBD=DMAX1(SUMIN,(SL(I)-XOPT(I))/TEMP)
+              IUBD=-I
+          END IF
+      END IF
+   70 CONTINUE
+C
+C     Seek a large modulus of the KNEW-th Lagrange function when the index
+C     of the other interpolation point on the line through XOPT is KNEW.
+C
+      IF (K .EQ. KNEW) THEN
+          DIFF=DDERIV-ONE
+          STEP=SLBD
+          VLAG=SLBD*(DDERIV-SLBD*DIFF)
+          ISBD=ILBD
+          TEMP=SUBD*(DDERIV-SUBD*DIFF)
+          IF (DABS(TEMP) .GT. DABS(VLAG)) THEN
+              STEP=SUBD
+              VLAG=TEMP
+              ISBD=IUBD
+          END IF
+          TEMPD=HALF*DDERIV
+          TEMPA=TEMPD-DIFF*SLBD
+          TEMPB=TEMPD-DIFF*SUBD
+          IF (TEMPA*TEMPB .LT. ZERO) THEN
+              TEMP=TEMPD*TEMPD/DIFF
+              IF (DABS(TEMP) .GT. DABS(VLAG)) THEN
+                  STEP=TEMPD/DIFF
+                  VLAG=TEMP
+                  ISBD=0
+              END IF
+          END IF
+C
+C     Search along each of the other lines through XOPT and another point.
+C
+      ELSE
+          STEP=SLBD
+          VLAG=SLBD*(ONE-SLBD)
+          ISBD=ILBD
+          TEMP=SUBD*(ONE-SUBD)
+          IF (DABS(TEMP) .GT. DABS(VLAG)) THEN
+              STEP=SUBD
+              VLAG=TEMP
+              ISBD=IUBD
+          END IF
+          IF (SUBD .GT. HALF) THEN
+              IF (DABS(VLAG) .LT. 0.25D0) THEN
+                  STEP=HALF
+                  VLAG=0.25D0
+                  ISBD=0
+              END IF
+          END IF
+          VLAG=VLAG*DDERIV
+      END IF
+C
+C     Calculate PREDSQ for the current line search and maintain PRESAV.
+C
+      TEMP=STEP*(ONE-STEP)*DISTSQ
+      PREDSQ=VLAG*VLAG*(VLAG*VLAG+HA*TEMP*TEMP)
+      IF (PREDSQ .GT. PRESAV) THEN
+          PRESAV=PREDSQ
+          KSAV=K
+          STPSAV=STEP
+          IBDSAV=ISBD
+      END IF
+   80 CONTINUE
+C
+C     Construct XNEW in a way that satisfies the bound constraints exactly.
+C
+      DO 90 I=1,N
+      TEMP=XOPT(I)+STPSAV*(XPT(KSAV,I)-XOPT(I))
+   90 XNEW(I)=DMAX1(SL(I),DMIN1(SU(I),TEMP))
+      IF (IBDSAV .LT. 0) XNEW(-IBDSAV)=SL(-IBDSAV)
+      IF (IBDSAV .GT. 0) XNEW(IBDSAV)=SU(IBDSAV)
+C
+C     Prepare for the iterative method that assembles the constrained Cauchy
+C     step in W. The sum of squares of the fixed components of W is formed in
+C     WFIXSQ, and the free components of W are set to BIGSTP.
+C
+      BIGSTP=ADELT+ADELT
+      IFLAG=0
+  100 WFIXSQ=ZERO
+      GGFREE=ZERO
+      DO 110 I=1,N
+      W(I)=ZERO
+      TEMPA=DMIN1(XOPT(I)-SL(I),GLAG(I))
+      TEMPB=DMAX1(XOPT(I)-SU(I),GLAG(I))
+      IF (TEMPA .GT. ZERO .OR. TEMPB .LT. ZERO) THEN
+          W(I)=BIGSTP
+          GGFREE=GGFREE+GLAG(I)**2
+      END IF
+  110 CONTINUE
+      IF (GGFREE .EQ. ZERO) THEN
+          CAUCHY=ZERO
+          GOTO 200
+      END IF
+C
+C     Investigate whether more components of W can be fixed.
+C
+  120 TEMP=ADELT*ADELT-WFIXSQ
+      IF (TEMP .GT. ZERO) THEN
+          WSQSAV=WFIXSQ
+          STEP=DSQRT(TEMP/GGFREE)
+          GGFREE=ZERO
+          DO 130 I=1,N
+          IF (W(I) .EQ. BIGSTP) THEN
+              TEMP=XOPT(I)-STEP*GLAG(I)
+              IF (TEMP .LE. SL(I)) THEN
+                  W(I)=SL(I)-XOPT(I)
+                  WFIXSQ=WFIXSQ+W(I)**2
+              ELSE IF (TEMP .GE. SU(I)) THEN
+                  W(I)=SU(I)-XOPT(I)
+                  WFIXSQ=WFIXSQ+W(I)**2
+              ELSE
+                  GGFREE=GGFREE+GLAG(I)**2
+              END IF
+          END IF
+  130     CONTINUE
+          IF (WFIXSQ .GT. WSQSAV .AND. GGFREE .GT. ZERO) GOTO 120
+      END IF
+C
+C     Set the remaining free components of W and all components of XALT,
+C     except that W may be scaled later.
+C
+      GW=ZERO
+      DO 140 I=1,N
+      IF (W(I) .EQ. BIGSTP) THEN
+          W(I)=-STEP*GLAG(I)
+          XALT(I)=DMAX1(SL(I),DMIN1(SU(I),XOPT(I)+W(I)))
+      ELSE IF (W(I) .EQ. ZERO) THEN
+          XALT(I)=XOPT(I)
+      ELSE IF (GLAG(I) .GT. ZERO) THEN
+          XALT(I)=SL(I)
+      ELSE
+          XALT(I)=SU(I)
+      END IF
+  140 GW=GW+GLAG(I)*W(I)
+C
+C     Set CURV to the curvature of the KNEW-th Lagrange function along W.
+C     Scale W by a factor less than one if that can reduce the modulus of
+C     the Lagrange function at XOPT+W. Set CAUCHY to the final value of
+C     the square of this function.
+C
+      CURV=ZERO
+      DO 160 K=1,NPT
+      TEMP=ZERO
+      DO 150 J=1,N
+  150 TEMP=TEMP+XPT(K,J)*W(J)
+  160 CURV=CURV+HCOL(K)*TEMP*TEMP
+      IF (IFLAG .EQ. 1) CURV=-CURV
+      IF (CURV .GT. -GW .AND. CURV .LT. -CONST*GW) THEN
+          SCALE=-GW/CURV
+          DO 170 I=1,N
+          TEMP=XOPT(I)+SCALE*W(I)
+  170     XALT(I)=DMAX1(SL(I),DMIN1(SU(I),TEMP))
+          CAUCHY=(HALF*GW*SCALE)**2
+      ELSE
+          CAUCHY=(GW+HALF*CURV)**2
+      END IF
+C
+C     If IFLAG is zero, then XALT is calculated as before after reversing
+C     the sign of GLAG. Thus two XALT vectors become available. The one that
+C     is chosen is the one that gives the larger value of CAUCHY.
+C
+      IF (IFLAG .EQ. 0) THEN
+          DO 180 I=1,N
+          GLAG(I)=-GLAG(I)
+  180     W(N+I)=XALT(I)
+          CSAVE=CAUCHY
+          IFLAG=1
+          GOTO 100
+      END IF
+      IF (CSAVE .GT. CAUCHY) THEN
+          DO 190 I=1,N
+  190     XALT(I)=W(N+I)
+          CAUCHY=CSAVE
+      END IF
+  200 RETURN
+      END SUBROUTINE ALTMOV
+
+	END SUBROUTINE MAIN
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/bobyqa/mexbobyqa.mexa64 b/Requirements/MEIGO/eSS/local_solvers/bobyqa/mexbobyqa.mexa64
new file mode 100644
index 0000000000000000000000000000000000000000..571dd28d2423a818b8fae0d78b6ebfa7830352a9
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/bobyqa/mexbobyqa.mexa64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/dhc/dhc.m b/Requirements/MEIGO/eSS/local_solvers/dhc/dhc.m
new file mode 100644
index 0000000000000000000000000000000000000000..b5493423025d69a79890da5975dd57851e9a801d
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/dhc/dhc.m
@@ -0,0 +1,318 @@
+function [fx,x,numeval]=dhc(fobj,x,initsize,thres,budget,x_L,x_U,weight,c_L,c_U,iterprint,tolc,varargin)
+
+% n_out=nargout(fobj);
+
+if ~isempty(c_L) | ~isempty(c_U)
+    n_out=2;
+else
+    n_out=1;
+end
+
+NDIM=size(x,2);
+THRESHOLD=thres;
+INIT_SIZE=initsize;
+
+numeval=0;
+
+v=zeros(1,NDIM);        %Inicializar los vi con ceros
+u=v;
+vi=-1;
+vvec=1;
+vr=-INIT_SIZE;
+xreal=x.*(x_U-x_L)+x_L;
+
+if n_out>1
+    [fx,cx]=feval(fobj,xreal,varargin{:});
+    penalty=ssm_penalty_function(xreal,cx,c_L,c_U,tolc);
+    fx=fx+weight*penalty;
+else
+    [fx]=feval(fobj,xreal,varargin{:});
+    cx=0;
+end
+
+numeval=numeval+1;
+fxv=1e30;
+
+%JRB
+nnn=0;
+
+while (abs(vr)>=THRESHOLD)
+    if (abs(vr)<2*THRESHOLD)
+        maxiter=2*NDIM;
+    else
+        maxiter=2;
+    end
+    iter=0;
+    while (fxv>=fx) & (iter<maxiter)
+        if iter==0
+            xv=x;
+        else
+            xv(vi+1)=xv(vi+1)-vr;               %OJO CON ESTO QUE NO LO TENGO CLARO
+        end
+        if (vvec)
+            vvec=0;
+        end
+        vr=-vr;
+        if (vr>0)
+            vi=mod((vi+1),NDIM);
+        end
+
+        xv(vi+1)=xv(vi+1)+vr;               %OJO TB CON ESTO
+
+        %Meter en bounds
+        aaa=find(xv<0);
+        bbb=find(xv>1);
+
+        xv(aaa)=0;
+        xv(bbb)=1;
+
+        xvreal=xv.*(x_U-x_L)+x_L;
+
+        if n_out>1
+            [fxv,cxv]=feval(fobj,xvreal,varargin{:});
+            penaltyv=ssm_penalty_function(xreal,cxv,c_L,c_U,tolc);
+            fxv=fxv+weight*penaltyv;
+        else
+            [fxv]=feval(fobj,xvreal,varargin{:});
+            cxv=0;
+        end
+
+        pen2=0;
+        aaa=find(xvreal<x_L);
+        bbb=find(xvreal>x_U);
+
+        if ~isempty(aaa)
+            pen2=pen2+sum((x_L(aaa)-xvreal(aaa)));
+        end
+
+        if ~isempty(bbb)
+            pen2=pen2+sum((xvreal(bbb)-x_U(bbb)));
+        end
+
+        fxv=fxv+weight*pen2;
+        
+        numeval=numeval+1;
+        iter=iter+1;
+        
+        if numeval>=budget
+            vr=thres/10;
+            break
+        end
+
+    end
+
+    if (fxv>=fx) | isnan(fxv)
+        fxv=1e30;
+        vr=vr/2;
+    else
+        fx=fxv;
+        x=xv;
+        %JRB
+        if iterprint
+%             nnn=nnn+1;
+%             plot(nnn,fx,'o');hold on;drawnow;
+            fprintf('%s %i %s %g \n','Nevals:', numeval, 'Fobj:',fx)
+        end
+        %JRB
+
+        if (iter==0)
+            if (vvec)
+                u=u+v;
+                v=v*2;
+                xv=xv+v;
+                vr=vr*2;
+            else
+                u(vi+1)=u(vi+1)+vr;         %OJOOOOOO!!!!!
+                vr=vr*2;
+                xv(vi+1)=xv(vi+1)+vr;       %OJOOOOOOOOOO!!!!
+            end
+            %Meter en bounds
+            aaa=find(xv<0);
+            bbb=find(xv>1);
+
+            xv(aaa)=0;
+            xv(bbb)=1;
+
+            xvreal=xv.*(x_U-x_L)+x_L;
+            
+            if n_out>1
+                [fxv,cxv]=feval(fobj,xvreal,varargin{:});
+                penaltyv=ssm_penalty_function(xreal,cxv,c_L,c_U,tolc);
+                fxv=fxv+weight*penaltyv;
+            else
+                [fxv]=feval(fobj,xvreal,varargin{:});
+                cxv=0;
+            end
+
+            pen2=0;
+            aaa=find(xvreal<x_L);
+            bbb=find(xvreal>x_U);
+
+            if ~isempty(aaa)
+                pen2=pen2+sum((x_L(aaa)-xvreal(aaa)));
+            end
+
+            if ~isempty(bbb)
+                pen2=pen2+sum((xvreal(bbb)-x_U(bbb)));
+            end
+
+            fxv=fxv+weight*pen2;
+
+            
+            numeval=numeval+1;
+
+            if numeval>=budget
+                vr=thres/10;
+                break
+            end
+        else
+            xv=xv+u;
+            xv(vi+1)=xv(vi+1)+vr;            %OJOOOOOOOOO!!!!
+
+            %Meter en bounds
+            aaa=find(xv<0);
+            bbb=find(xv>1);
+
+            xv(aaa)=0;
+            xv(bbb)=1;
+
+            xvreal=xv.*(x_U-x_L)+x_L;
+            
+            if n_out>1
+                [fxv,cxv]=feval(fobj,xvreal,varargin{:});
+                penaltyv=ssm_penalty_function(xreal,cxv,c_L,c_U,tolc);
+                fxv=fxv+weight*penaltyv;
+            else
+                [fxv]=feval(fobj,xvreal,varargin{:});
+                cxv=0;
+            end
+
+            pen2=0;
+            aaa=find(xvreal<x_L);
+            bbb=find(xvreal>x_U);
+
+            if ~isempty(aaa)
+                pen2=pen2+sum((x_L(aaa)-xvreal(aaa)));
+            end
+
+            if ~isempty(bbb)
+                pen2=pen2+sum((xvreal(bbb)-x_U(bbb)));
+            end
+
+            fxv=fxv+weight*pen2;
+
+            
+            numeval=numeval+1;
+
+            if numeval>=budget
+                vr=thres/10;
+                break
+            end
+
+
+            if (fxv>=fx) | isnan(fxv)
+                u=zeros(1,NDIM);
+                xv=x;
+                u(vi+1)=vr;                  %OJOOOOOOOOO!!!!
+                vr=vr*2;
+                xv(vi+1)=xv(vi+1)+vr;                     %OJOOOOOOOOO!!!!
+
+                %Meter en bounds
+                aaa=find(xv<0);
+                bbb=find(xv>1);
+
+                xv(aaa)=0;
+                xv(bbb)=1;
+
+                xvreal=xv.*(x_U-x_L)+x_L;
+
+                if n_out>1
+                    [fxv,cxv]=feval(fobj,xvreal,varargin{:});
+                    penaltyv=ssm_penalty_function(xreal,cxv,c_L,c_U,tolc);
+                    fxv=fxv+weight*penaltyv;
+                else
+                    [fxv]=feval(fobj,xvreal,varargin{:});
+                    cxv=0;
+                end
+
+                pen2=0;
+                aaa=find(xvreal<x_L);
+                bbb=find(xvreal>x_U);
+
+                if ~isempty(aaa)
+                    pen2=pen2+sum((x_L(aaa)-xvreal(aaa)));
+                end
+
+                if ~isempty(bbb)
+                    pen2=pen2+sum((xvreal(bbb)-x_U(bbb)));
+                end
+
+                fxv=fxv+weight*pen2;
+                numeval=numeval+1;
+                
+                if numeval>=budget
+                    vr=thres/10;
+                    break
+                end
+
+            else
+                x=xv;
+                fx=fxv;
+                u(vi+1)=u(vi+1)+vr;         %OJOOOOOOOOOO!
+                v=2*u;
+                vvec=1;
+                xv=xv+v;
+
+                %Meter en bounds
+                aaa=find(xv<0);
+                bbb=find(xv>1);
+
+                xv(aaa)=0;
+                xv(bbb)=1;
+
+                xvreal=xv.*(x_U-x_L)+x_L;
+                
+                if n_out>1
+                    [fxv,cxv]=feval(fobj,xvreal,varargin{:});
+                    penaltyv=ssm_penalty_function(xreal,cxv,c_L,c_U,tolc);
+                    fxv=fxv+weight*penaltyv;
+                else
+                    [fxv]=feval(fobj,xvreal,varargin{:});
+                    cxv=0;
+                end
+
+                pen2=0;
+                aaa=find(xvreal<x_L);
+                bbb=find(xvreal>x_U);
+
+                if ~isempty(aaa)
+                    pen2=pen2+sum((x_L(aaa)-xvreal(aaa)));
+                end
+
+                if ~isempty(bbb)
+                    pen2=pen2+sum((xvreal(bbb)-x_U(bbb)));
+                end
+
+                fxv=fxv+weight*pen2;
+                
+                numeval=numeval+1;
+                if numeval>=budget
+                    vr=thres/10;
+                    break
+                end
+
+
+                vr=0;
+                vr=sum(v.^2);
+                vr=sqrt(vr);
+            end
+        end
+    end
+end
+
+if fxv<fx & ~isnan(fxv)
+    fx=fxv;
+    x=xv;
+end
+
+x=x.*(x_U-x_L)+x_L;
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/MATLAB Central File Exchange - fminsearchbnd.URL b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/MATLAB Central File Exchange - fminsearchbnd.URL
new file mode 100644
index 0000000000000000000000000000000000000000..e8459fe96332280458514a69252d8fae79218d49
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/MATLAB Central File Exchange - fminsearchbnd.URL	
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=8277&objectType=file
diff --git a/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/fminsearchbnd note.txt b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/fminsearchbnd note.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a3c3229f06c75f6a27d324f243f9879a77192de3
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/fminsearchbnd note.txt	
@@ -0,0 +1,10 @@
+The script fminsearchbnd.m was originally created by John D'Errico (see below) and was downloaded for The Mathworks -  Matlab Central - File Exchange
+
+http://www.mathworks.com/matlabcentral/fileexchange/loadCategory.do
+
+% Author: John D'Errico
+% E-mail: woodchips@rochester.rr.com
+% Release: 4
+% Release date: 7/23/06
+
+Type help fminsearchbnd for more info
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/fminsearchbnd.m b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/fminsearchbnd.m
new file mode 100644
index 0000000000000000000000000000000000000000..95d419b70a4ba35e131c4cdd1cd2dee5875fbf11
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/fminsearchbnd.m
@@ -0,0 +1,304 @@
+function [x,fval,exitflag,output]=fminsearchbnd3(fun,x0,LB,UB,options,varargin)
+% FMINSEARCHBND: FMINSEARCH, but with bound constraints by transformation
+% usage: x=FMINSEARCHBND(fun,x0)
+% usage: x=FMINSEARCHBND(fun,x0,LB)
+% usage: x=FMINSEARCHBND(fun,x0,LB,UB)
+% usage: x=FMINSEARCHBND(fun,x0,LB,UB,options)
+% usage: x=FMINSEARCHBND(fun,x0,LB,UB,options,p1,p2,...)
+% usage: [x,fval,exitflag,output]=FMINSEARCHBND(fun,x0,...)
+% 
+% arguments:
+%  fun, x0, options - see the help for FMINSEARCH
+%
+%  LB - lower bound vector or array, must be the same size as x0
+%
+%       If no lower bounds exist for one of the variables, then
+%       supply -inf for that variable.
+%
+%       If no lower bounds at all, then LB may be left empty.
+%
+%       Variables may be fixed in value by setting the corresponding
+%       lower and upper bounds to exactly the same value.
+%
+%  UB - upper bound vector or array, must be the same size as x0
+%
+%       If no upper bounds exist for one of the variables, then
+%       supply +inf for that variable.
+%
+%       If no upper bounds at all, then UB may be left empty.
+%
+%       Variables may be fixed in value by setting the corresponding
+%       lower and upper bounds to exactly the same value.
+%
+% Notes:
+%
+%  If options is supplied, then TolX will apply to the transformed
+%  variables. All other FMINSEARCH parameters should be unaffected.
+%
+%  Variables which are constrained by both a lower and an upper
+%  bound will use a sin transformation. Those constrained by
+%  only a lower or an upper bound will use a quadratic
+%  transformation, and unconstrained variables will be left alone.
+%
+%  Variables may be fixed by setting their respective bounds equal.
+%  In this case, the problem will be reduced in size for FMINSEARCH.
+%
+%  The bounds are inclusive inequalities, which admit the
+%  boundary values themselves, but will not permit ANY function
+%  evaluations outside the bounds. These constraints are strictly
+%  followed.
+%
+%  If your problem has an EXCLUSIVE (strict) constraint which will
+%  not admit evaluation at the bound itself, then you must provide
+%  a slightly offset bound. An example of this is a function which
+%  contains the log of one of its parameters. If you constrain the
+%  variable to have a lower bound of zero, then FMINSEARCHBND may
+%  try to evaluate the function exactly at zero.
+%
+%
+% Example usage:
+% rosen = @(x) (1-x(1)).^2 + 105*(x(2)-x(1).^2).^2;
+%
+% fminsearch(rosen,[3 3])     % unconstrained
+% ans =
+%    1.0000    1.0000
+%
+% fminsearchbnd(rosen,[3 3],[2 2],[])     % constrained
+% ans =
+%    2.0000    4.0000
+%
+% See test_main.m for other examples of use.
+%
+%
+% See also: fminsearch, fminspleas
+%
+%
+% Author: John D'Errico
+% E-mail: woodchips@rochester.rr.com
+% Release: 4
+% Release date: 7/23/06
+
+% size checks
+xsize = size(x0);
+x0 = x0(:);
+n=length(x0);
+
+if (nargin<3) || isempty(LB)
+  LB = repmat(-inf,n,1);
+else
+  LB = LB(:);
+end
+if (nargin<4) || isempty(UB)
+  UB = repmat(inf,n,1);
+else
+  UB = UB(:);
+end
+
+if (n~=length(LB)) || (n~=length(UB))
+  error 'x0 is incompatible in size with either LB or UB.'
+end
+
+% set default options if necessary
+if (nargin<5) || isempty(options)
+  options = optimset('fminsearch');
+end
+
+% stuff into a struct to pass around
+params.args = varargin;
+params.LB = LB;
+params.UB = UB;
+params.fun = fun;
+params.n = n;
+params.OutputFcn = [];
+
+% 0 --> unconstrained variable
+% 1 --> lower bound only
+% 2 --> upper bound only
+% 3 --> dual finite bounds
+% 4 --> fixed variable
+params.BoundClass = zeros(n,1);
+for i=1:n
+  k = isfinite(LB(i)) + 2*isfinite(UB(i));
+  params.BoundClass(i) = k;
+  if (k==3) && (LB(i)==UB(i))
+    params.BoundClass(i) = 4;
+  end
+end
+
+% transform starting values into their unconstrained
+% surrogates. Check for infeasible starting guesses.
+x0u = x0;
+k=1;
+for i = 1:n
+  switch params.BoundClass(i)
+    case 1
+      % lower bound only
+      if x0(i)<=LB(i)
+        % infeasible starting value. Use bound.
+        x0u(k) = 0;
+      else
+        x0u(k) = sqrt(x0(i) - LB(i));
+      end
+      
+      % increment k
+      k=k+1;
+    case 2
+      % upper bound only
+      if x0(i)>=UB(i)
+        % infeasible starting value. use bound.
+        x0u(k) = 0;
+      else
+        x0u(k) = sqrt(UB(i) - x0(i));
+      end
+      
+      % increment k
+      k=k+1;
+    case 3
+      % lower and upper bounds
+      if x0(i)<=LB(i)
+        % infeasible starting value
+        x0u(k) = -pi/2;
+      elseif x0(i)>=UB(i)
+        % infeasible starting value
+        x0u(k) = pi/2;
+      else
+        x0u(k) = 2*(x0(i) - LB(i))/(UB(i)-LB(i)) - 1;
+        % shift by 2*pi to avoid problems at zero in fminsearch
+        % otherwise, the initial simplex is vanishingly small
+        x0u(k) = 2*pi+asin(max(-1,min(1,x0u(k))));
+      end
+      
+      % increment k
+      k=k+1;
+    case 0
+      % unconstrained variable. x0u(i) is set.
+      x0u(k) = x0(i);
+      
+      % increment k
+      k=k+1;
+    case 4
+      % fixed variable. drop it before fminsearch sees it.
+      % k is not incremented for this variable.
+  end
+  
+end
+% if any of the unknowns were fixed, then we need to shorten
+% x0u now.
+if k<=n
+  x0u(k:n) = [];
+end
+
+% were all the variables fixed?
+if isempty(x0u)
+  % All variables were fixed. quit immediately, setting the
+  % appropriate parameters, then return.
+  
+  % undo the variable transformations into the original space
+  x = xtransform(x0u,params);
+  
+  % final reshape
+  x = reshape(x,xsize);
+  
+  % stuff fval with the final value
+  fval = feval(params.fun,x,params.args{:});
+  
+  % fminsearchbnd was not called
+  exitflag = 0;
+  
+  output.iterations = 0;
+  output.funcount = 1;
+  output.algorithm = 'fminsearch';
+  output.message = 'All variables were held fixed by the applied bounds';
+  
+  % return with no call at all to fminsearch
+  return
+end
+
+% Check for an outputfcn. If there is any, then substitute my
+% own wrapper function.
+if ~isempty(options.OutputFcn)
+  params.OutputFcn = options.OutputFcn;
+  options.OutputFcn = @outfun_wrapper;
+end
+
+% now we can call fminsearch, but with our own
+% intra-objective function.
+[xu,fval,exitflag,output] = fminsearch(@intrafun,x0u,options,params);
+
+% undo the variable transformations into the original space
+x = xtransform(xu,params);
+
+% final reshape
+x = reshape(x,xsize);
+
+% Use a nested function as the OutputFcn wrapper
+  function stop = outfun_wrapper(x,varargin);
+    % we need to transform x first
+    xtrans = xtransform(x,params);
+    
+    % then call the user supplied OutputFcn
+    stop = params.OutputFcn(xtrans,varargin{1:(end-1)});
+    
+  end
+
+end % mainline end
+
+% ======================================
+% ========= begin subfunctions =========
+% ======================================
+function fval = intrafun(x,params)
+% transform variables, then call original function
+
+% transform
+xtrans = xtransform(x,params);
+
+% and call fun
+fval = feval(params.fun,xtrans,params.args{:});
+
+end % sub function intrafun end
+
+% ======================================
+function xtrans = xtransform(x,params)
+% converts unconstrained variables into their original domains
+
+xtrans = zeros(1,params.n);
+% k allows some variables to be fixed, thus dropped from the
+% optimization.
+k=1;
+for i = 1:params.n
+  switch params.BoundClass(i)
+    case 1
+      % lower bound only
+      xtrans(i) = params.LB(i) + x(k).^2;
+      
+      k=k+1;
+    case 2
+      % upper bound only
+      xtrans(i) = params.UB(i) - x(k).^2;
+      
+      k=k+1;
+    case 3
+      % lower and upper bounds
+      xtrans(i) = (sin(x(k))+1)/2;
+      xtrans(i) = xtrans(i)*(params.UB(i) - params.LB(i)) + params.LB(i);
+      % just in case of any floating point problems
+      xtrans(i) = max(params.LB(i),min(params.UB(i),xtrans(i)));
+      
+      k=k+1;
+    case 4
+      % fixed variable, bounds are equal, set it at either bound
+      xtrans(i) = params.LB(i);
+    case 0
+      % unconstrained variable.
+      xtrans(i) = x(k);
+      
+      k=k+1;
+  end
+end
+
+end % sub function xtransform end
+
+
+
+
+
diff --git a/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/license.txt b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..72049154128776d71261a3a2d67b294273fde2f8
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/fminsearchbnd/license.txt
@@ -0,0 +1,24 @@
+Copyright (c) 2006, John D'Errico
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are 
+met:
+
+    * Redistributions of source code must retain the above copyright 
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright 
+      notice, this list of conditions and the following disclaimer in 
+      the documentation and/or other materials provided with the distribution
+      
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/MEIGO/eSS/local_solvers/hj/hjobj.m b/Requirements/MEIGO/eSS/local_solvers/hj/hjobj.m
new file mode 100644
index 0000000000000000000000000000000000000000..63f23afa974ffa7a827a5b8df123e1bfcb8d9993
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/hj/hjobj.m
@@ -0,0 +1,48 @@
+%\-----------------------------------------------------/
+% Definition of objective for hooke and jeeves
+function hjout = hjobj(x,varargin)
+global hjfun hjxl hjxu hjcl hjcu hjweight hjtolc
+
+global n_fun_eval
+
+hjout=[];
+
+% n_out=nargout(hjfun);
+
+if ~isempty(hjcl) | ~isempty(hjcu)
+    n_out=2;
+else
+    n_out=1;
+end
+
+if size(x,2)==1
+    x=x';
+end
+
+if n_out>1
+[fff,ccc] = feval(hjfun,x,varargin{:});
+pen=ssm_penalty_function(x,ccc,hjcl,hjcu,hjtolc);
+else
+    [fff] = feval(hjfun,x,varargin{:});
+    pen=0;
+end
+    
+
+pen2=0;
+aaa=find(x<hjxl);
+bbb=find(x>hjxu);
+
+if ~isempty(aaa)
+    pen2=pen2+sum((hjxl(aaa)-x(aaa)));
+end
+
+if ~isempty(bbb)
+    pen2=pen2+sum((x(bbb)-hjxu(bbb)));
+end
+
+
+hjout=fff+hjweight*(pen+pen2);
+
+n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/hj/hooke note.txt b/Requirements/MEIGO/eSS/local_solvers/hj/hooke note.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f91a406f9daddc1983b2b4805de825d87ad07d54
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/hj/hooke note.txt	
@@ -0,0 +1,5 @@
+The script hooke.m was originally created by Prof. C.T. Kelley and was downloaded for his personal web page.
+
+http://www4.ncsu.edu/~ctk/darts/hooke.m
+
+We have slightly modified the code to adapt it to the (f)SSm framework.
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/hj/hooke.m b/Requirements/MEIGO/eSS/local_solvers/hj/hooke.m
new file mode 100644
index 0000000000000000000000000000000000000000..856087343ac06b97fd8db9206c42e6f7de2ef6b9
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/hj/hooke.m
@@ -0,0 +1,148 @@
+function [x, histout] = hooke(x0, f, budget, tol,iterprint,varargin)
+%
+% Hooke-Jeeves optimization
+%
+% C. T. Kelley, July 10, 1998
+%
+%
+% This code comes with no guarantee or warranty of any kind.
+%
+% function [x, histout] = hooke(x0, f, budget, scales, tol, v)
+%
+% inputs:
+%
+%       x0= initial iterate 
+%       f = objective function 
+%       budget = max f evals (default=50*number of variables)
+%                 The iteration will terminate after the iteration that
+%                 exhausts the budget
+%       scales = the decreasing sequence of stencil sizes
+%                 This is an optional argument and the default is
+%                 1, 1/2, ... 1/128
+%       tol = termination tolerance 
+%            difference is function values at successive iterations
+%            (default = 1.d-6)
+%       v = matrix of search directions (default $v = I$)
+%       target = value of f at which the iteration should be terminated
+%             This is an optional argument, which you SHOULD set to
+%             something reasonable for your problem. The default is
+%             as close to no limit as we can get, -1.d8
+%
+%
+% outputs:
+%
+%        final results = x
+%        iteration histor = histout itout x 5
+%        histout = iteration history, updated after each nonlinear iteration
+%                 = lhist x 2 array, the rows are
+%                   [fcount, fval, sval]
+%                   fcount = cumulative function evals
+%                   fval = current best function value
+%                   sval = current scale
+%
+% set debug = 1 to print iteration stats
+%
+debug=0;
+%
+%
+n=length(x0); fcount=0; bud=50*n; scal=-(3:30)'; scal=2.^scal; dir=eye(n);
+tolf=1.d-9; targ=-1.d8;
+
+%
+% cache control paramters
+%
+global cache_size cache cache_ptr cache_fvals
+cache_size=4*n; cache=zeros(n,cache_size); cache_ptr=0;
+cache_fvals=zeros(cache_size,1);
+%
+% count the incoming arguments
+%
+% if nargin > 2 bud=budget; end
+% if nargin > 3 scal=scales; end
+% if nargin > 4 tolf=tol; end
+% if nargin > 5 targ=target; end
+% if nargin > 6 targ=target; end
+% if nargin > 7 dir = v; end
+
+bud=budget;
+tolf=tol;
+%
+% main loop to sweep the scales
+%
+fcount=1; h=scal(1); fv=geval(f,x0,varargin{:}); 
+histout=[fcount,fv,h];
+fbest=fv;
+x=x0; nscal=length(scal); ns=0; 
+while (ns < nscal & fcount <= bud)
+    ns=ns+1; 
+    [x, sf, lhist, fcount] = hjsearch(x, f, scal(ns),dir, fcount,bud,varargin{:});
+    histout=[histout',lhist']'; 
+    if iterprint
+        fprintf('%s %i %s %g \n','Nevals:', histout(end,1), 'Fobj:',histout(end,2))
+    end
+%
+% end main loop
+%
+end
+%
+% Search with a single scale
+%
+function [x, sf, lhist, finc] = hjsearch(xb, f, h,dir, fcount,bud,varargin)
+x=xb; xc=x; sf=0; finc=fcount; lhist=[];
+[x, fv, sf, numf] = hjexplore(xb, xc, f, h, dir,[], varargin{:});
+finc=finc+numf;
+if sf==1 thist=[finc, fv, h]; lhist=[lhist',thist']'; end
+while sf==1 & finc < bud
+%
+% pattern move
+%
+    d=x-xb; xb=x; xc=x+d; fb=fv;
+    [x, fv, sf, numf] = hjexplore(xb, xc, f, h, dir,fb,varargin{:});
+    finc=finc+numf; 
+    if sf == 0 % pattern move fails!
+       [x, fv, sf, numf] = hjexplore(xb, xb, f, h, dir, fb,varargin{:});
+       finc=finc+numf; 
+    end
+    if sf==1 thist=[finc, fv, h]; lhist=[lhist',thist']'; end
+end
+%
+% exploratory move
+%
+function [x, fv, sf, numf] = hjexplore(xb, xc, f, h, dir, fbold,varargin);
+global cache_size cache cache_ptr cache_fvals
+n=length(xb); x=xb; numf=0;
+%if nargin == 5
+if isempty(fbold)
+    [fb,ctr]=geval(f,x,varargin{:});
+    numf=numf+ctr;
+else
+    fb=fbold;
+end
+fv=fb;
+xt=xc; sf=0; dirh=h*dir;
+fvold=fv;
+for k=1:n
+    p=xt+dirh(:,k); ft=feval(f,p,varargin{:}); numf=numf+1;
+    if(ft >= fb) p=xt-dirh(:,k); [ft,ctr]=geval(f,p,varargin{:}); numf=numf+ctr; end
+    if(ft < fb) sf=1; xt=p; fb=ft; end
+end
+if sf==1 x=xt; fv=fb; end
+%
+%
+function [fs,ctr]=geval(fh,xh,varargin)
+global cache_size cache cache_ptr cache_fvals
+for i=1:cache_size
+    nz(i)=norm(xh-cache(:,i));
+end
+[vz,iz]=min(nz);
+if vz == 0 & cache_ptr ~=0
+    fs=cache_fvals(iz);
+    ctr=0;
+else
+    fs=feval(fh,xh,varargin{:});
+    ctr=1;
+    cache_ptr=mod(cache_ptr,cache_size)+1;
+    cache(:,cache_ptr)=xh;
+    cache_fvals(cache_ptr)=fs;
+end
+
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/Ipopt - Trac.URL b/Requirements/MEIGO/eSS/local_solvers/ipopt/Ipopt - Trac.URL
new file mode 100644
index 0000000000000000000000000000000000000000..83a91c8de916ce490b9eac51d4eaf29df124ca3d
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/Ipopt - Trac.URL	
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://projects.coin-or.org/Ipopt
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/READMEfrom.IPOPT b/Requirements/MEIGO/eSS/local_solvers/ipopt/READMEfrom.IPOPT
new file mode 100644
index 0000000000000000000000000000000000000000..6bc3b97a64a26dd0c1a931a4ab396b2177a9ecb8
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/READMEfrom.IPOPT
@@ -0,0 +1,1269 @@
+### Output ###
+
+print_level                           -2 <= (          5) <= 12        
+   Output verbosity level.
+     Sets the default verbosity level for console output. The larger this
+     value the more detailed is the output.
+
+output_file                   ("")
+   File name of desired output file (leave unset for no file output).
+     NOTE: This option only works when read from the ipopt.opt options file!
+     An output file with this name will be written (leave unset for no file
+     output).  The verbosity level is by default set to "print_level", but can
+     be overridden with "file_print_level".  The file name is changed to use
+     only small letters.
+   Possible values:
+    - *                       [Any acceptable standard file name]
+
+file_print_level                       0 <= (          5) <= 12        
+   Verbosity level for output file.
+     NOTE: This option only works when read from the ipopt.opt options file!
+     Determines the verbosity level for the file specified by "output_file". 
+     By default it is the same as "print_level".
+
+print_user_options            ("no")
+   Print all options set by the user.
+     If selected, the algorithm will print the list of all options set by the
+     user including their values and whether they have been used.  In some
+     cases this information might be incorrect, due to the internal program
+     flow.
+   Possible values:
+    - no                      [don't print options]
+    - yes                     [print options]
+
+print_options_documentation   ("no")
+   Switch to print all algorithmic options.
+     If selected, the algorithm will print the list of all available
+     algorithmic options with some documentation before solving the
+     optimization problem.
+   Possible values:
+    - no                      [don't print list]
+    - yes                     [print list]
+
+print_timing_statistics       ("no")
+   Switch to print timing statistics.
+     If selected, the program will print the CPU usage (user time) for
+     selected tasks.
+   Possible values:
+    - no                      [don't print statistics]
+    - yes                     [print all timing statistics]
+
+print_info_string             ("no")
+   Enables printing of additional info string at end of iteration output.
+     This string contains some insider information about the current iteration.
+   Possible values:
+    - no                      [don't print string]
+    - yes                     [print string at end of each iteration output]
+
+
+
+### Convergence ###
+
+tol                                    0 <  (     1e-008) <  +inf      
+   Desired convergence tolerance (relative).
+     Determines the convergence tolerance for the algorithm.  The algorithm
+     terminates successfully, if the (scaled) NLP error becomes smaller than
+     this value, and if the (absolute) criteria according to "dual_inf_tol",
+     "primal_inf_tol", and "cmpl_inf_tol" are met.  (This is epsilon_tol in
+     Eqn. (6) in implementation paper).  See also "acceptable_tol" as a second
+     termination criterion.  Note, some other algorithmic features also use
+     this quantity to determine thresholds etc.
+
+s_max                                  0 <  (        100) <  +inf      
+   Scaling threshold for the NLP error.
+     (See paragraph after Eqn. (6) in the implementation paper.)
+
+max_iter                               0 <= (       3000) <  +inf      
+   Maximum number of iterations.
+     The algorithm terminates with an error message if the number of
+     iterations exceeded this number.
+
+dual_inf_tol                           0 <  (     0.0001) <  +inf      
+   Desired threshold for the dual infeasibility.
+     Absolute tolerance on the dual infeasibility. Successful termination
+     requires that the max-norm of the (unscaled) dual infeasibility is less
+     than this threshold.
+
+constr_viol_tol                        0 <  (     0.0001) <  +inf      
+   Desired threshold for the constraint violation.
+     Absolute tolerance on the constraint violation. Successful termination
+     requires that the max-norm of the (unscaled) constraint violation is less
+     than this threshold.
+
+compl_inf_tol                          0 <  (     0.0001) <  +inf      
+   Desired threshold for the complementarity conditions.
+     Absolute tolerance on the complementarity. Successful termination
+     requires that the max-norm of the (unscaled) complementarity is less than
+     this threshold.
+
+acceptable_tol                         0 <  (     1e-006) <  +inf      
+   "Acceptable" convergence tolerance (relative).
+     Determines which (scaled) overall optimality error is considered to be
+     "acceptable." There are two levels of termination criteria.  If the usual
+     "desired" tolerances (see tol, dual_inf_tol etc) are satisfied at an
+     iteration, the algorithm immediately terminates with a success message. 
+     On the other hand, if the algorithm encounters "acceptable_iter" many
+     iterations in a row that are considered "acceptable", it will terminate
+     before the desired convergence tolerance is met. This is useful in cases
+     where the algorithm might not be able to achieve the "desired" level of
+     accuracy.
+
+acceptable_iter                        0 <= (         15) <  +inf      
+   Number of "acceptable" iterates before triggering termination.
+     If the algorithm encounters this many successive "acceptable" iterates
+     (see "acceptable_tol"), it terminates, assuming that the problem has been
+     solved to best possible accuracy given round-off.  If it is set to zero,
+     this heuristic is disabled.
+
+acceptable_dual_inf_tol                0 <  (     1e+010) <  +inf      
+   "Acceptance" threshold for the dual infeasibility.
+     Absolute tolerance on the dual infeasibility. "Acceptable" termination
+     requires that the (max-norm of the unscaled) dual infeasibility is less
+     than this threshold; see also acceptable_tol.
+
+acceptable_constr_viol_tol             0 <  (       0.01) <  +inf      
+   "Acceptance" threshold for the constraint violation.
+     Absolute tolerance on the constraint violation. "Acceptable" termination
+     requires that the max-norm of the (unscaled) constraint violation is less
+     than this threshold; see also acceptable_tol.
+
+acceptable_compl_inf_tol               0 <  (       0.01) <  +inf      
+   "Acceptance" threshold for the complementarity conditions.
+     Absolute tolerance on the complementarity. "Acceptable" termination
+     requires that the max-norm of the (unscaled) complementarity is less than
+     this threshold; see also acceptable_tol.
+
+diverging_iterates_tol                 0 <  (     1e+020) <  +inf      
+   Threshold for maximal value of primal iterates.
+     If any component of the primal iterates exceeded this value (in absolute
+     terms), the optimization is aborted with the exit message that the
+     iterates seem to be diverging.
+
+
+
+### NLP Scaling ###
+
+nlp_scaling_method            ("gradient-based")
+   Select the technique used for scaling the NLP.
+     Selects the technique used for scaling the problem internally before it
+     is solved. For user-scaling, the parameters come from the NLP. If you are
+     using AMPL, they can be specified through suffixes ("scaling_factor")
+   Possible values:
+    - none                    [no problem scaling will be performed]
+    - user-scaling            [scaling parameters will come from the user]
+    - gradient-based          [scale the problem so the maximum gradient at
+                               the starting point is scaling_max_gradient]
+    - equilibration-based     [scale the problem so that first derivatives are
+                               of order 1 at random points (only available
+                               with MC19)]
+
+obj_scaling_factor                  -inf <  (          1) <  +inf      
+   Scaling factor for the objective function.
+     This option sets a scaling factor for the objective function. The scaling
+     is seen internally by Ipopt but the unscaled objective is reported in the
+     console output. If additional scaling parameters are computed (e.g.
+     user-scaling or gradient-based), both factors are multiplied. If this
+     value is chosen to be negative, Ipopt will maximize the objective
+     function instead of minimizing it.
+
+nlp_scaling_max_gradient               0 <  (        100) <  +inf      
+   Maximum gradient after NLP scaling.
+     This is the gradient scaling cut-off. If the maximum gradient is above
+     this value, then gradient based scaling will be performed. Scaling
+     parameters are calculated to scale the maximum gradient back to this
+     value. (This is g_max in Section 3.8 of the implementation paper.) Note:
+     This option is only used if "nlp_scaling_method" is chosen as
+     "gradient-based".
+
+nlp_scaling_obj_target_gradient         0 <= (          0) <  +inf      
+   Target value for objective function gradient size.
+     If a positive number is chosen, the scaling factor the objective function
+     is computed so that the gradient as the max norm of the given size at the
+     starting point.  This overrides nlp_scaling_max_gradient for the
+     objective function.
+
+
+
+### NLP ###
+
+nlp_lower_bound_inf                 -inf <  (    -1e+019) <  +inf      
+   any bound less or equal this value will be considered -inf (i.e. not lower
+   bounded).
+
+nlp_upper_bound_inf                 -inf <  (     1e+019) <  +inf      
+   any bound greater or this value will be considered +inf (i.e. not upper
+   bounded).
+
+fixed_variable_treatment      ("make_parameter")
+   Determines how fixed variables should be handled.
+   Possible values:
+    - make_parameter          [Remove fixed variable from optimization
+                               variables]
+    - make_constraint         [Add equality constraints fixing variables]
+    - relax_bounds            [Relax fixing bound constraintsThe main
+                               difference between those options is that the
+                               starting point in the "make_constraint" case
+                               still has the fixed variables at their given
+                               values, whereas in the case "make_parameter"
+                               the functions are always evaluated with the
+                               fixed values for those variables.  For Also,
+                               for "relax_bounds", the fixing bound
+                               constraints are relaxed (according to"
+                               bound_relax_factor"). For both
+                               "make_constraints" and "relax_bounds", bound
+                               multipliers are computed for the fixed
+                               variables.]
+
+dependency_detector           ("none")
+   Indicates which linear solver should be used to detect linearly dependent
+   equality constraints.
+     The default and available choices depend on how Ipopt has been compiled.
+   Possible values:
+    - none                    [don't check; no extra work at beginning]
+    - mumps                   [use MUMPS]
+    - wsmp                    [use WSMP]
+    - ma28                    [use MA28]
+
+dependency_detection_with_rhs ("no")
+   Indicates if the right hand sides of the constraints should be considered
+   during dependency detection
+   Possible values:
+    - no                      [only look at gradients]
+    - yes                     [also consider right hand side]
+
+point_perturbation_radius              0 <= (         10) <  +inf      
+   Maximal perturbation of an evaluation point.
+     If a random perturbation of a points is required, this number indicates
+     the maximal perturbation.  Currently, this is only used when we perturb
+     the initial point in order to get a random Jacobian for the linear
+     dependency detection of equality constraints.
+
+kappa_d                                0 <= (     1e-005) <  +inf      
+   Weight for linear damping term (to handle one-sided bounds).
+     (see Section 3.7 in implementation paper.)
+
+bound_relax_factor                     0 <= (     1e-008) <  +inf      
+   Factor for initial relaxation of the bounds.
+     Before start of the optimization, the bounds given by the user are
+     relaxed.  This option sets the factor for this relaxation.  If it is set
+     to zero, then then bounds relaxation is disabled. (See Eqn.(35) in
+     implementation paper.)
+
+honor_original_bounds         ("yes")
+   Indicates whether final points should be projected into original bounds.
+     Ipopt might relax the bounds during the optimization (see, e.g., option
+     "bound_relax_factor").  This option determines whether the final point
+     should be projected back into the user-provide original bounds after the
+     optimization.
+   Possible values:
+    - no                      [Leave final point unchanged]
+    - yes                     [Project final point back into original bounds]
+
+check_derivatives_for_naninf  ("no")
+   Indicates whether it is desired to check for Nan/Inf in derivative matrices
+     Activating this option will cause an error if an invalid number is
+     detected in the constraint Jacobians or the Lagrangian Hessian.  If this
+     is not activated, the test is skipped, and the algorithm might proceed
+     with invalid numbers and fail.
+   Possible values:
+    - no                      [Don't check (faster).]
+    - yes                     [Check Jacobians and Hessian for Nan and Inf.]
+
+jac_c_constant                ("no")
+   Indicates whether all equality constraints are linear
+     Activating this option will cause Ipopt to ask for the Jacobian of the
+     equality constraints only once from the NLP and reuse this information
+     later.
+   Possible values:
+    - no                      [Don't assume that all equality constraints are
+                               linear]
+    - yes                     [Assume that equality constraints Jacobian are
+                               constant]
+
+jac_d_constant                ("no")
+   Indicates whether all inequality constraints are linear
+     Activating this option will cause Ipopt to ask for the Jacobian of the
+     inequality constraints only once from the NLP and reuse this information
+     later.
+   Possible values:
+    - no                      [Don't assume that all inequality constraints
+                               are linear]
+    - yes                     [Assume that equality constraints Jacobian are
+                               constant]
+
+hessian_constant              ("no")
+   Indicates whether the problem is a quadratic problem
+     Activating this option will cause Ipopt to ask for the Hessian of the
+     Lagrangian function only once from the NLP and reuse this information
+     later.
+   Possible values:
+    - no                      [Assume that Hessian changes]
+    - yes                     [Assume that Hessian is constant]
+
+
+
+### Initialization ###
+
+bound_push                             0 <  (       0.01) <  +inf      
+   Desired minimum absolute distance from the initial point to bound.
+     Determines how much the initial point might have to be modified in order
+     to be sufficiently inside the bounds (together with "bound_frac").  (This
+     is kappa_1 in Section 3.6 of implementation paper.)
+
+bound_frac                             0 <  (       0.01) <= 0.5       
+   Desired minimum relative distance from the initial point to bound.
+     Determines how much the initial point might have to be modified in order
+     to be sufficiently inside the bounds (together with "bound_push").  (This
+     is kappa_2 in Section 3.6 of implementation paper.)
+
+slack_bound_push                       0 <  (       0.01) <  +inf      
+   Desired minimum absolute distance from the initial slack to bound.
+     Determines how much the initial slack variables might have to be modified
+     in order to be sufficiently inside the inequality bounds (together with
+     "slack_bound_frac").  (This is kappa_1 in Section 3.6 of implementation
+     paper.)
+
+slack_bound_frac                       0 <  (       0.01) <= 0.5       
+   Desired minimum relative distance from the initial slack to bound.
+     Determines how much the initial slack variables might have to be modified
+     in order to be sufficiently inside the inequality bounds (together with
+     "slack_bound_push").  (This is kappa_2 in Section 3.6 of implementation
+     paper.)
+
+constr_mult_init_max                   0 <= (       1000) <  +inf      
+   Maximum allowed least-square guess of constraint multipliers.
+     Determines how large the initial least-square guesses of the constraint
+     multipliers are allowed to be (in max-norm). If the guess is larger than
+     this value, it is discarded and all constraint multipliers are set to
+     zero.  This options is also used when initializing the restoration phase.
+     By default, "resto.constr_mult_init_max" (the one used in
+     RestoIterateInitializer) is set to zero.
+
+bound_mult_init_val                    0 <  (          1) <  +inf      
+   Initial value for the bound multipliers.
+     All dual variables corresponding to bound constraints are initialized to
+     this value.
+
+least_square_init_primal      ("no")
+   Least square initialization of the primal variables
+     If set to yes, Ipopt ignores the user provided point and solves a least
+     square problem for the primal variables (x and s), to fit the linearize
+     equality and inequality constraints.  This might be useful if the user
+     doesn't know anything about the starting point, or for solving an LP or
+     QP.
+   Possible values:
+    - no                      [take user-provided point]
+    - yes                     [overwrite user-provided point with least-square
+                               estimates]
+
+least_square_init_duals       ("no")
+   Least square initialization of all dual variables
+     If set to yes, Ipopt tries to compute least-square multipliers
+     (considering ALL dual variables).  If successful, the bound multipliers
+     are possibly corrected to be at least bound_mult_init_val. This might be
+     usefulif the user doesn't know anything about the starting point, or for
+     solving an LP or QP.
+   Possible values:
+    - no                      [use bound_mult_init_val and least-square
+                               equality constraint multipliers]
+    - yes                     [overwrite user-provided point wiht least-square
+                               estimates]
+
+
+
+### Barrier Parameter Update ###
+
+mu_max_fact                            0 <  (       1000) <  +inf      
+   Factor for initialization of maximum value for barrier parameter.
+     This option determines the upper bound on the barrier parameter.  This
+     upper bound is computed as the average complementarity at the initial
+     point times the value of this option. (Only used if option "mu_strategy"
+     is chosen as "adaptive".)
+
+mu_max                                 0 <  (     100000) <  +inf      
+   Maximum value for barrier parameter.
+     This option specifies an upper bound on the barrier parameter in the
+     adaptive mu selection mode.  If this option is set, it overwrites the
+     effect of mu_max_fact. (Only used if option "mu_strategy" is chosen as
+     "adaptive".)
+
+mu_min                                 0 <  (     1e-011) <  +inf      
+   Minimum value for barrier parameter.
+     This option specifies the lower bound on the barrier parameter in the
+     adaptive mu selection mode. By default, it is set to the minimum of 1e-11
+     and min("tol","compl_inf_tol")/("barrier_tol_factor"+1), which should be
+     a reasonable value. (Only used if option "mu_strategy" is chosen as
+     "adaptive".)
+
+adaptive_mu_globalization     ("obj-constr-filter")
+   Globalization strategy for the adaptive mu selection mode.
+     To achieve global convergence of the adaptive version, the algorithm has
+     to switch to the monotone mode (Fiacco-McCormick approach) when
+     convergence does not seem to appear.  This option sets the criterion used
+     to decide when to do this switch. (Only used if option "mu_strategy" is
+     chosen as "adaptive".)
+   Possible values:
+    - kkt-error               [nonmonotone decrease of kkt-error]
+    - obj-constr-filter       [2-dim filter for objective and constraint
+                               violation]
+    - never-monotone-mode     [disables globalization]
+
+adaptive_mu_kkterror_red_iters         0 <= (          4) <  +inf      
+   Maximum number of iterations requiring sufficient progress.
+     For the "kkt-error" based globalization strategy, sufficient progress
+     must be made for "adaptive_mu_kkterror_red_iters" iterations. If this
+     number of iterations is exceeded, the globalization strategy switches to
+     the monotone mode.
+
+adaptive_mu_kkterror_red_fact          0 <  (     0.9999) <  1         
+   Sufficient decrease factor for "kkt-error" globalization strategy.
+     For the "kkt-error" based globalization strategy, the error must decrease
+     by this factor to be deemed sufficient decrease.
+
+filter_margin_fact                     0 <  (     1e-005) <  1         
+   Factor determining width of margin for obj-constr-filter adaptive
+   globalization strategy.
+     When using the adaptive globalization strategy, "obj-constr-filter",
+     sufficient progress for a filter entry is defined as follows: (new obj) <
+     (filter obj) - filter_margin_fact*(new constr-voil) OR (new constr-viol)
+     < (filter constr-viol) - filter_margin_fact*(new constr-voil).  For the
+     description of the "kkt-error-filter" option see "filter_max_margin".
+
+filter_max_margin                      0 <  (          1) <  +inf      
+   Maximum width of margin in obj-constr-filter adaptive globalization
+   strategy.
+
+adaptive_mu_restore_previous_iterate("no")
+   Indicates if the previous iterate should be restored if the monotone mode
+   is entered.
+     When the globalization strategy for the adaptive barrier algorithm
+     switches to the monotone mode, it can either start from the most recent
+     iterate (no), or from the last iterate that was accepted (yes).
+   Possible values:
+    - no                      [don't restore accepted iterate]
+    - yes                     [restore accepted iterate]
+
+adaptive_mu_monotone_init_factor         0 <  (        0.8) <  +inf      
+   Determines the initial value of the barrier parameter when switching to the
+   monotone mode.
+     When the globalization strategy for the adaptive barrier algorithm
+     switches to the monotone mode and fixed_mu_oracle is chosen as
+     "average_compl", the barrier parameter is set to the current average
+     complementarity times the value of "adaptive_mu_monotone_init_factor".
+
+adaptive_mu_kkt_norm_type     ("2-norm-squared")
+   Norm used for the KKT error in the adaptive mu globalization strategies.
+     When computing the KKT error for the globalization strategies, the norm
+     to be used is specified with this option. Note, this options is also used
+     in the QualityFunctionMuOracle.
+   Possible values:
+    - 1-norm                  [use the 1-norm (abs sum)]
+    - 2-norm-squared          [use the 2-norm squared (sum of squares)]
+    - max-norm                [use the infinity norm (max)]
+    - 2-norm                  [use 2-norm]
+
+mu_strategy                   ("monotone")
+   Update strategy for barrier parameter.
+     Determines which barrier parameter update strategy is to be used.
+   Possible values:
+    - monotone                [use the monotone (Fiacco-McCormick) strategy]
+    - adaptive                [use the adaptive update strategy]
+
+mu_oracle                     ("quality-function")
+   Oracle for a new barrier parameter in the adaptive strategy.
+     Determines how a new barrier parameter is computed in each "free-mode"
+     iteration of the adaptive barrier parameter strategy. (Only considered if
+     "adaptive" is selected for option "mu_strategy").
+   Possible values:
+    - probing                 [Mehrotra's probing heuristic]
+    - loqo                    [LOQO's centrality rule]
+    - quality-function        [minimize a quality function]
+
+fixed_mu_oracle               ("average_compl")
+   Oracle for the barrier parameter when switching to fixed mode.
+     Determines how the first value of the barrier parameter should be
+     computed when switching to the "monotone mode" in the adaptive strategy.
+     (Only considered if "adaptive" is selected for option "mu_strategy".)
+   Possible values:
+    - probing                 [Mehrotra's probing heuristic]
+    - loqo                    [LOQO's centrality rule]
+    - quality-function        [minimize a quality function]
+    - average_compl           [base on current average complementarity]
+
+mu_init                                0 <  (        0.1) <  +inf      
+   Initial value for the barrier parameter.
+     This option determines the initial value for the barrier parameter (mu). 
+     It is only relevant in the monotone, Fiacco-McCormick version of the
+     algorithm. (i.e., if "mu_strategy" is chosen as "monotone")
+
+barrier_tol_factor                     0 <  (         10) <  +inf      
+   Factor for mu in barrier stop test.
+     The convergence tolerance for each barrier problem in the monotone mode
+     is the value of the barrier parameter times "barrier_tol_factor". This
+     option is also used in the adaptive mu strategy during the monotone mode.
+     (This is kappa_epsilon in implementation paper).
+
+mu_linear_decrease_factor              0 <  (        0.2) <  1         
+   Determines linear decrease rate of barrier parameter.
+     For the Fiacco-McCormick update procedure the new barrier parameter mu is
+     obtained by taking the minimum of mu*"mu_linear_decrease_factor" and
+     mu^"superlinear_decrease_power".  (This is kappa_mu in implementation
+     paper.) This option is also used in the adaptive mu strategy during the
+     monotone mode.
+
+mu_superlinear_decrease_power          1 <  (        1.5) <  2         
+   Determines superlinear decrease rate of barrier parameter.
+     For the Fiacco-McCormick update procedure the new barrier parameter mu is
+     obtained by taking the minimum of mu*"mu_linear_decrease_factor" and
+     mu^"superlinear_decrease_power".  (This is theta_mu in implementation
+     paper.) This option is also used in the adaptive mu strategy during the
+     monotone mode.
+
+mu_allow_fast_monotone_decrease("yes")
+   Allow skipping of barrier problem if barrier test is already met.
+     If set to "no", the algorithm enforces at least one iteration per barrier
+     problem, even if the barrier test is already met for the updated barrier
+     parameter.
+   Possible values:
+    - no                      [Take at least one iteration per barrier problem]
+    - yes                     [Allow fast decrease of mu if barrier test it met]
+
+tau_min                                0 <  (       0.99) <  1         
+   Lower bound on fraction-to-the-boundary parameter tau.
+     (This is tau_min in implementation paper.)  This option is also used in
+     the adaptive mu strategy during the monotone mode.
+
+sigma_max                              0 <  (        100) <  +inf      
+   Maximum value of the centering parameter.
+     This is the upper bound for the centering parameter chosen by the quality
+     function based barrier parameter update. (Only used if option "mu_oracle"
+     is set to "quality-function".)
+
+sigma_min                              0 <= (     1e-006) <  +inf      
+   Minimum value of the centering parameter.
+     This is the lower bound for the centering parameter chosen by the quality
+     function based barrier parameter update. (Only used if option "mu_oracle"
+     is set to "quality-function".)
+
+quality_function_norm_type    ("2-norm-squared")
+   Norm used for components of the quality function.
+     (Only used if option "mu_oracle" is set to "quality-function".)
+   Possible values:
+    - 1-norm                  [use the 1-norm (abs sum)]
+    - 2-norm-squared          [use the 2-norm squared (sum of squares)]
+    - max-norm                [use the infinity norm (max)]
+    - 2-norm                  [use 2-norm]
+
+quality_function_centrality   ("none")
+   The penalty term for centrality that is included in quality function.
+     This determines whether a term is added to the quality function to
+     penalize deviation from centrality with respect to complementarity.  The
+     complementarity measure here is the xi in the Loqo update rule. (Only
+     used if option "mu_oracle" is set to "quality-function".)
+   Possible values:
+    - none                    [no penalty term is added]
+    - log                     [complementarity * the log of the centrality
+                               measure]
+    - reciprocal              [complementarity * the reciprocal of the
+                               centrality measure]
+    - cubed-reciprocal        [complementarity * the reciprocal of the
+                               centrality measure cubed]
+
+quality_function_balancing_term("none")
+   The balancing term included in the quality function for centrality.
+     This determines whether a term is added to the quality function that
+     penalizes situations where the complementarity is much smaller than dual
+     and primal infeasibilities. (Only used if option "mu_oracle" is set to
+     "quality-function".)
+   Possible values:
+    - none                    [no balancing term is added]
+    - cubic                   [Max(0,Max(dual_inf,primal_inf)-compl)^3]
+
+quality_function_max_section_steps         0 <= (          8) <  +inf      
+   Maximum number of search steps during direct search procedure determining
+   the optimal centering parameter.
+     The golden section search is performed for the quality function based mu
+     oracle. (Only used if option "mu_oracle" is set to "quality-function".)
+
+quality_function_section_sigma_tol         0 <= (       0.01) <  1         
+   Tolerance for the section search procedure determining the optimal
+   centering parameter (in sigma space).
+     The golden section search is performed for the quality function based mu
+     oractle. (Only used if option "mu_oracle" is set to "quality-function".)
+
+quality_function_section_qf_tol         0 <= (          0) <  1         
+   Tolerance for the golden section search procedure determining the optimal
+   centering parameter (in the function value space).
+     The golden section search is performed for the quality function based mu
+     oractle. (Only used if option "mu_oracle" is set to "quality-function".)
+
+
+
+### Line Search ###
+
+alpha_red_factor                       0 <  (        0.5) <  1         
+   Fractional reduction of the trial step size in the backtracking line search.
+     At every step of the backtracking line search, the trial step size is
+     reduced by this factor.
+
+accept_every_trial_step       ("no")
+   Always accept the frist trial step.
+     Setting this option to "yes" essentially disables the line search and
+     makes the algorithm take aggressive steps, without global convergence
+     guarantees.
+   Possible values:
+    - no                      [don't arbitrarily accept the full step]
+    - yes                     [always accept the full step]
+
+alpha_for_y                   ("primal")
+   Method to determine the step size for constraint multipliers.
+     This option determines how the step size (alpha_y) will be calculated
+     when updating the constraint multipliers.
+   Possible values:
+    - primal                  [use primal step size]
+    - bound_mult              [use step size for the bound multipliers (good
+                               for LPs)]
+    - min                     [use the min of primal and bound multipliers]
+    - max                     [use the max of primal and bound multipliers]
+    - full                    [take a full step of size one]
+    - min_dual_infeas         [choose step size minimizing new dual
+                               infeasibility]
+    - safe_min_dual_infeas    [like "min_dual_infeas", but safeguarded by
+                               "min" and "max"]
+    - primal-and-full         [use the primal step size, and full step if
+                               delta_x <= alpga_for_y_tol]
+    - dual-and-full           [use the dual step size, and full step if
+                               delta_x <= alpga_for_y_tol]
+    - acceptor                [Call LSAcceptor to get step size for y]
+
+alpha_for_y_tol                        0 <= (         10) <  +inf      
+   Tolerance for switching to full equality multiplier steps.
+     This is only relevant if "alpha_for_y" is chosen "primal-and-full"or
+     "dual-and-full".  The step size for the equality constraintmultipliers is
+     taken to be one if the max-norm of the primal step isless than this
+     tolerance.
+
+tiny_step_tol                          0 <= (2.22045e-015) <  +inf      
+   Tolerance for detecting numerically insignificant steps.
+     If the search direction in the primal variables (x and s) is, in relative
+     terms for each component, less than this value, the algorithm accepts the
+     full step without line search.  If this happens repeatedly, the algorithm
+     will terminate with a corresponding exit message. The default value is 10
+     times machine precision.
+
+tiny_step_y_tol                        0 <= (       0.01) <  +inf      
+   Tolerance for quitting because of numerically insignificant steps.
+     If the search direction in the primal variables (x and s) is, in relative
+     terms for each component, repeatedly less than tiny_step_tol, and the
+     step in the y variables is smaller than this threshold, the algorithm
+     will terminate.
+
+watchdog_shortened_iter_trigger         0 <= (         10) <  +inf      
+   Number of shortened iterations that trigger the watchdog.
+     If the number of successive iterations in which the backtracking line
+     search did not accept the first trial point exceeds this number, the
+     watchdog procedure is activated.  Choosing "0" here disables the watchdog
+     procedure.
+
+watchdog_trial_iter_max                1 <= (          3) <  +inf      
+   Maximum number of watchdog iterations.
+     This option determines the number of trial iterations allowed before the
+     watchdog procedure is aborted and the algorithm returns to the stored
+     point.
+
+theta_max_fact                         0 <  (      10000) <  +inf      
+   Determines upper bound for constraint violation in the filter.
+     The algorithmic parameter theta_max is determined as theta_max_fact times
+     the maximum of 1 and the constraint violation at initial point.  Any
+     point with a constraint violation larger than theta_max is unacceptable
+     to the filter (see Eqn. (21) in implementation paper).
+
+theta_min_fact                         0 <  (     0.0001) <  +inf      
+   Determines constraint violation threshold in the switching rule.
+     The algorithmic parameter theta_min is determined as theta_min_fact times
+     the maximum of 1 and the constraint violation at initial point.  The
+     switching rules treats an iteration as an h-type iteration whenever the
+     current constraint violation is larger than theta_min (see paragraph
+     before Eqn. (19) in implementation paper).
+
+eta_phi                                0 <  (     1e-008) <  0.5       
+   Relaxation factor in the Armijo condition.
+     (See Eqn. (20) in implementation paper)
+
+delta                                  0 <  (          1) <  +inf      
+   Multiplier for constraint violation in the switching rule.
+     (See Eqn. (19) in implementation paper.)
+
+s_phi                                  1 <  (        2.3) <  +inf      
+   Exponent for linear barrier function model in the switching rule.
+     (See Eqn. (19) in implementation paper.)
+
+s_theta                                1 <  (        1.1) <  +inf      
+   Exponent for current constraint violation in the switching rule.
+     (See Eqn. (19) in implementation paper.)
+
+gamma_phi                              0 <  (     1e-008) <  1         
+   Relaxation factor in the filter margin for the barrier function.
+     (See Eqn. (18a) in implementation paper.)
+
+gamma_theta                            0 <  (     1e-005) <  1         
+   Relaxation factor in the filter margin for the constraint violation.
+     (See Eqn. (18b) in implementation paper.)
+
+alpha_min_frac                         0 <  (       0.05) <  1         
+   Safety factor for the minimal step size (before switching to restoration
+   phase).
+     (This is gamma_alpha in Eqn. (20) in implementation paper.)
+
+max_soc                                0 <= (          4) <  +inf      
+   Maximum number of second order correction trial steps at each iteration.
+     Choosing 0 disables the second order corrections. (This is p^{max} of
+     Step A-5.9 of Algorithm A in implementation paper.)
+
+kappa_soc                              0 <  (       0.99) <  +inf      
+   Factor in the sufficient reduction rule for second order correction.
+     This option determines how much a second order correction step must
+     reduce the constraint violation so that further correction steps are
+     attempted.  (See Step A-5.9 of Algorithm A in implementation paper.)
+
+obj_max_inc                            1 <  (          5) <  +inf      
+   Determines the upper bound on the acceptable increase of barrier objective
+   function.
+     Trial points are rejected if they lead to an increase in the barrier
+     objective function by more than obj_max_inc orders of magnitude.
+
+max_filter_resets                      0 <= (          5) <  +inf      
+   Maximal allowed number of filter resets
+     A positive number enables a heuristic that resets the filter, whenever in
+     more than "filter_reset_trigger" successive iterations the last rejected
+     trial steps size was rejected because of the filter.  This option
+     determine the maximal number of resets that are allowed to take place.
+
+filter_reset_trigger                   1 <= (          5) <  +inf      
+   Number of iterations that trigger the filter reset.
+     If the filter reset heuristic is active and the number of successive
+     iterations in which the last rejected trial step size was rejected
+     because of the filter, the filter is reset.
+
+corrector_type                ("none")
+   The type of corrector steps that should be taken (unsupported!).
+     If "mu_strategy" is "adaptive", this option determines what kind of
+     corrector steps should be tried.
+   Possible values:
+    - none                    [no corrector]
+    - affine                  [corrector step towards mu=0]
+    - primal-dual             [corrector step towards current mu]
+
+skip_corr_if_neg_curv         ("yes")
+   Skip the corrector step in negative curvature iteration (unsupported!).
+     The corrector step is not tried if negative curvature has been
+     encountered during the computation of the search direction in the current
+     iteration. This option is only used if "mu_strategy" is "adaptive".
+   Possible values:
+    - no                      [don't skip]
+    - yes                     [skip]
+
+skip_corr_in_monotone_mode    ("yes")
+   Skip the corrector step during monotone barrier parameter mode
+   (unsupported!).
+     The corrector step is not tried if the algorithm is currently in the
+     monotone mode (see also option "barrier_strategy").This option is only
+     used if "mu_strategy" is "adaptive".
+   Possible values:
+    - no                      [don't skip]
+    - yes                     [skip]
+
+corrector_compl_avrg_red_fact          0 <  (          1) <  +inf      
+   Complementarity tolerance factor for accepting corrector step
+   (unsupported!).
+     This option determines the factor by which complementarity is allowed to
+     increase for a corrector step to be accepted.
+
+kappa_sigma                            0 <  (     1e+010) <  +inf      
+   Factor limiting the deviation of dual variables from primal estimates.
+     If the dual variables deviate from their primal estimates, a correction
+     is performed. (See Eqn. (16) in the implementation paper.) Setting the
+     value to less than 1 disables the correction.
+
+recalc_y                      ("no")
+   Tells the algorithm to recalculate the equality and inequality multipliers
+   as least square estimates.
+     This asks the algorithm to recompute the multipliers, whenever the
+     current infeasibility is less than recalc_y_feas_tol. Choosing yes might
+     be helpful in the quasi-Newton option.  However, each recalculation
+     requires an extra factorization of the linear system.  If a limited
+     memory quasi-Newton option is chosen, this is used by default.
+   Possible values:
+    - no                      [use the Newton step to update the multipliers]
+    - yes                     [use least-square multiplier estimates]
+
+recalc_y_feas_tol                      0 <  (     1e-006) <  +inf      
+   Feasibility threshold for recomputation of multipliers.
+     If recalc_y is chosen and the current infeasibility is less than this
+     value, then the multipliers are recomputed.
+
+slack_move                             0 <= (1.81899e-012) <  +inf      
+   Correction size for very small slacks.
+     Due to numerical issues or the lack of an interior, the slack variables
+     might become very small.  If a slack becomes very small compared to
+     machine precision, the corresponding bound is moved slightly.  This
+     parameter determines how large the move should be.  Its default value is
+     mach_eps^{3/4}.  (See also end of Section 3.5 in implementation paper -
+     but actual implementation might be somewhat different.)
+
+
+
+### Warm Start ###
+
+warm_start_init_point         ("no")
+   Warm-start for initial point
+     Indicates whether this optimization should use a warm start
+     initialization, where values of primal and dual variables are given
+     (e.g., from a previous optimization of a related problem.)
+   Possible values:
+    - no                      [do not use the warm start initialization]
+    - yes                     [use the warm start initialization]
+
+warm_start_same_structure     ("no")
+   Indicates whether a problem with a structure identical to the previous one
+   is to be solved.
+     If "yes" is chosen, then the algorithm assumes that an NLP is now to be
+     solved, whose strcture is identical to one that already was considered
+     (with the same NLP object).
+   Possible values:
+    - no                      [Assume this is a new problem.]
+    - yes                     [Assume this is problem has known structure]
+
+warm_start_bound_push                  0 <  (      0.001) <  +inf      
+   same as bound_push for the regular initializer.
+
+warm_start_bound_frac                  0 <  (      0.001) <= 0.5       
+   same as bound_frac for the regular initializer.
+
+warm_start_slack_bound_push            0 <  (      0.001) <  +inf      
+   same as slack_bound_push for the regular initializer.
+
+warm_start_slack_bound_frac            0 <  (      0.001) <= 0.5       
+   same as slack_bound_frac for the regular initializer.
+
+warm_start_mult_bound_push             0 <  (      0.001) <  +inf      
+   same as mult_bound_push for the regular initializer.
+
+warm_start_mult_init_max            -inf <  (     1e+006) <  +inf      
+   Maximum initial value for the equality multipliers.
+
+warm_start_entire_iterate     ("no")
+   Tells algorithm whether to use the GetWarmStartIterate method in the NLP.
+   Possible values:
+    - no                      [call GetStartingPoint in the NLP]
+    - yes                     [call GetWarmStartIterate in the NLP]
+
+
+
+### Linear Solver ###
+
+linear_solver                 ("ma27")
+   Linear solver used for step computations.
+     Determines which linear algebra package is to be used for the solution of
+     the augmented linear system (for obtaining the search directions). Note,
+     the code must have been compiled with the linear solver you want to
+     choose. Depending on your Ipopt installation, not all options are
+     available.
+   Possible values:
+    - ma27                    [use the Harwell routine MA27]
+    - ma57                    [use the Harwell routine MA57]
+    - pardiso                 [use the Pardiso package]
+    - wsmp                    [use WSMP package]
+    - taucs                   [use TAUCS package (not yet working)]
+    - mumps                   [use MUMPS package]
+    - custom                  [use custom linear solver]
+
+linear_system_scaling         ("none")
+   Method for scaling the linear system.
+     Determines the method used to compute symmetric scaling factors for the
+     augmented system (see also the "linear_scaling_on_demand" option).  This
+     scaling is independentof the NLP problem scaling.  By default, MC19 is
+     only used if MA27 or MA57 are selected as linear solvers. This option is
+     only available if Ipopt has been compiled with MC19.
+   Possible values:
+    - none                    [no scaling will be performed]
+    - mc19                    [use the Harwell routine MC19]
+
+linear_scaling_on_demand      ("yes")
+   Flag indicating that linear scaling is only done if it seems required.
+     This option is only important if a linear scaling method (e.g., mc19) is
+     used.  If you choose "no", then the scaling factors are computed for
+     every linear system from the start.  This can be quite expensive.
+     Choosing "yes" means that the algorithm will start the scaling method
+     only when the solutions to the linear system seem not good, and then use
+     it until the end.
+   Possible values:
+    - no                      [Always scale the linear system.]
+    - yes                     [Start using linear system scaling if solutions
+                               seem not good.]
+
+
+
+### Step Calculation ###
+
+mehrotra_algorithm            ("no")
+   Indicates if we want to do Mehrotra's algorithm.
+     If set to yes, Ipopt runs as Mehrotra's predictor-corrector algorithm.
+     This works usually very well for LPs and convex QPs.  This automatically
+     disables the line search, and chooses the (unglobalized) adaptive mu
+     strategy with the "probing" oracle, and uses "corrector_type=affine"
+     without any safeguards; you should not set any of those options
+     explicitly in addition.  Also, unlessotherwise specified, the values of
+     "bound_push", "bound_frac", and "bound_mult_init_val" are set more
+     aggressive, and sets "alpha_for_y=bound_mult".
+   Possible values:
+    - no                      [Do the usual Ipopt algorithm.]
+    - yes                     [Do Mehrotra's predictor-corrector algorithm.]
+
+fast_step_computation         ("no")
+   Indicates if the linear system should be solved quickly.
+     If set to yes, the algorithm assumes that the linear system that is
+     solved to obtain the search direction, is solved sufficiently well. In
+     that case, no residuals are computed, and the computation of the search
+     direction is a little faster.
+   Possible values:
+    - no                      [Verify solution of linear system by computing
+                               residuals.]
+    - yes                     [Trust that linear systems are solved well.]
+
+min_refinement_steps                   0 <= (          1) <  +inf      
+   Minimum number of iterative refinement steps per linear system solve.
+     Iterative refinement (on the full unsymmetric system) is performed for
+     each right hand side.  This option determines the minimum number of
+     iterative refinements (i.e. at least "min_refinement_steps" iterative
+     refinement steps are enforced per right hand side.)
+
+max_refinement_steps                   0 <= (         10) <  +inf      
+   Maximum number of iterative refinement steps per linear system solve.
+     Iterative refinement (on the full unsymmetric system) is performed for
+     each right hand side.  This option determines the maximum number of
+     iterative refinement steps.
+
+residual_ratio_max                     0 <  (     1e-010) <  +inf      
+   Iterative refinement tolerance
+     Iterative refinement is performed until the residual test ratio is less
+     than this tolerance (or until "max_refinement_steps" refinement steps are
+     performed).
+
+residual_ratio_singular                0 <  (     1e-005) <  +inf      
+   Threshold for declaring linear system singular after failed iterative
+   refinement.
+     If the residual test ratio is larger than this value after failed
+     iterative refinement, the algorithm pretends that the linear system is
+     singular.
+
+residual_improvement_factor            0 <  (          1) <  +inf      
+   Minimal required reduction of residual test ratio in iterative refinement.
+     If the improvement of the residual test ratio made by one iterative
+     refinement step is not better than this factor, iterative refinement is
+     aborted.
+
+max_hessian_perturbation               0 <  (     1e+020) <  +inf      
+   Maximum value of regularization parameter for handling negative curvature.
+     In order to guarantee that the search directions are indeed proper
+     descent directions, Ipopt requires that the inertia of the (augmented)
+     linear system for the step computation has the correct number of negative
+     and positive eigenvalues. The idea is that this guides the algorithm away
+     from maximizers and makes Ipopt more likely converge to first order
+     optimal points that are minimizers. If the inertia is not correct, a
+     multiple of the identity matrix is added to the Hessian of the Lagrangian
+     in the augmented system. This parameter gives the maximum value of the
+     regularization parameter. If a regularization of that size is not enough,
+     the algorithm skips this iteration and goes to the restoration phase.
+     (This is delta_w^max in the implementation paper.)
+
+min_hessian_perturbation               0 <= (     1e-020) <  +inf      
+   Smallest perturbation of the Hessian block.
+     The size of the perturbation of the Hessian block is never selected
+     smaller than this value, unless no perturbation is necessary. (This is
+     delta_w^min in implementation paper.)
+
+perturb_inc_fact_first                 1 <  (        100) <  +inf      
+   Increase factor for x-s perturbation for very first perturbation.
+     The factor by which the perturbation is increased when a trial value was
+     not sufficient - this value is used for the computation of the very first
+     perturbation and allows a different value for for the first perturbation
+     than that used for the remaining perturbations. (This is bar_kappa_w^+ in
+     the implementation paper.)
+
+perturb_inc_fact                       1 <  (          8) <  +inf      
+   Increase factor for x-s perturbation.
+     The factor by which the perturbation is increased when a trial value was
+     not sufficient - this value is used for the computation of all
+     perturbations except for the first. (This is kappa_w^+ in the
+     implementation paper.)
+
+perturb_dec_fact                       0 <  (   0.333333) <  1         
+   Decrease factor for x-s perturbation.
+     The factor by which the perturbation is decreased when a trial value is
+     deduced from the size of the most recent successful perturbation. (This
+     is kappa_w^- in the implementation paper.)
+
+first_hessian_perturbation             0 <  (     0.0001) <  +inf      
+   Size of first x-s perturbation tried.
+     The first value tried for the x-s perturbation in the inertia correction
+     scheme.(This is delta_0 in the implementation paper.)
+
+jacobian_regularization_value          0 <= (     1e-008) <  +inf      
+   Size of the regularization for rank-deficient constraint Jacobians.
+     (This is bar delta_c in the implementation paper.)
+
+jacobian_regularization_exponent         0 <= (       0.25) <  +inf      
+   Exponent for mu in the regularization for rank-deficient constraint
+   Jacobians.
+     (This is kappa_c in the implementation paper.)
+
+perturb_always_cd             ("no")
+   Active permanent perturbation of constraint linearization.
+     This options makes the delta_c and delta_d perturbation be used for the
+     computation of every search direction.  Usually, it is only used when the
+     iteration matrix is singular.
+   Possible values:
+    - no                      [perturbation only used when required]
+    - yes                     [always use perturbation]
+
+
+
+### Restoration Phase ###
+
+expect_infeasible_problem     ("no")
+   Enable heuristics to quickly detect an infeasible problem.
+     This options is meant to activate heuristics that may speed up the
+     infeasibility determination if you expect that there is a good chance for
+     the problem to be infeasible.  In the filter line search procedure, the
+     restoration phase is called more quickly than usually, and more reduction
+     in the constraint violation is enforced before the restoration phase is
+     left. If the problem is square, this option is enabled automatically.
+   Possible values:
+    - no                      [the problem probably be feasible]
+    - yes                     [the problem has a good chance to be infeasible]
+
+expect_infeasible_problem_ctol         0 <= (      0.001) <  +inf      
+   Threshold for disabling "expect_infeasible_problem" option.
+     If the constraint violation becomes smaller than this threshold, the
+     "expect_infeasible_problem" heuristics in the filter line search are
+     disabled. If the problem is square, this options is set to 0.
+
+start_with_resto              ("no")
+   Tells algorithm to switch to restoration phase in first iteration.
+     Setting this option to "yes" forces the algorithm to switch to the
+     feasibility restoration phase in the first iteration. If the initial
+     point is feasible, the algorithm will abort with a failure.
+   Possible values:
+    - no                      [don't force start in restoration phase]
+    - yes                     [force start in restoration phase]
+
+soft_resto_pderror_reduction_factor         0 <= (     0.9999) <  +inf      
+   Required reduction in primal-dual error in the soft restoration phase.
+     The soft restoration phase attempts to reduce the primal-dual error with
+     regular steps. If the damped primal-dual step (damped only to satisfy the
+     fraction-to-the-boundary rule) is not decreasing the primal-dual error by
+     at least this factor, then the regular restoration phase is called.
+     Choosing "0" here disables the soft restoration phase.
+
+max_soft_resto_iters                   0 <= (         10) <  +inf      
+   Maximum number of iterations performed successively in soft restoration
+   phase.
+     If the soft restoration phase is performed for more than so many
+     iteratins in a row, the regular restoration phase is called.
+
+required_infeasibility_reduction         0 <= (        0.9) <  1         
+   Required reduction of infeasibility before leaving restoration phase.
+     The restoration phase algorithm is performed, until a point is found that
+     is acceptable to the filter and the infeasibility has been reduced by at
+     least the fraction given by this option.
+
+max_resto_iter                         0 <= (    3000000) <  +inf      
+   Maximum number of successive iterations in restoration phase.
+     The algorithm terminates with an error message if the number of
+     iterations successively taken in the restoration phase exceeds this
+     number.
+
+evaluate_orig_obj_at_resto_trial("yes")
+   Determines if the original objective function should be evaluated at
+   restoration phase trial points.
+     Setting this option to "yes" makes the restoration phase algorithm
+     evaluate the objective function of the original problem at every trial
+     point encountered during the restoration phase, even if this value is not
+     required.  In this way, it is guaranteed that the original objective
+     function can be evaluated without error at all accepted iterates;
+     otherwise the algorithm might fail at a point where the restoration phase
+     accepts an iterate that is good for the restoration phase problem, but
+     not the original problem.  On the other hand, if the evaluation of the
+     original objective is expensive, this might be costly.
+   Possible values:
+    - no                      [skip evaluation]
+    - yes                     [evaluate at every trial point]
+
+bound_mult_reset_threshold             0 <= (       1000) <  +inf      
+   Threshold for resetting bound multipliers after the restoration phase.
+     After returning from the restoration phase, the bound multipliers are
+     updated with a Newton step for complementarity.  Here, the change in the
+     primal variables during the entire restoration phase is taken to be the
+     corresponding primal Newton step. However, if after the update the
+     largest bound multiplier exceeds the threshold specified by this option,
+     the multipliers are all reset to 1.
+
+constr_mult_reset_threshold            0 <= (          0) <  +inf      
+   Threshold for resetting equality and inequality multipliers after
+   restoration phase.
+     After returning from the restoration phase, the constraint multipliers
+     are recomputed by a least square estimate.  This option triggers when
+     those least-square estimates should be ignored.
+
+
+
+### Derivative Checker ###
+
+derivative_test               ("none")
+   Enable derivative checker
+     If this option is enabled, a (slow) derivative test will be performed
+     before the optimization.  The test is performed at the user provided
+     starting point and marks derivative values that seem suspicious
+   Possible values:
+    - none                    [do not perform derivative test]
+    - first-order             [perform test of first derivatives at starting
+                               point]
+    - second-order            [perform test of first and second derivatives at
+                               starting point]
+
+derivative_test_perturbation           0 <  (     1e-008) <  +inf      
+   Size of the finite difference perturbation in derivative test.
+     This determines the relative perturbation of the variable entries.
+
+derivative_test_tol                    0 <  (     0.0001) <  +inf      
+   Threshold for indicating wrong derivative.
+     If the relative deviation of the estimated derivative from the given one
+     is larger than this value, the corresponding derivative is marked as
+     wrong.
+
+derivative_test_print_all     ("no")
+   Indicates whether information for all estimated derivatives should be
+   printed.
+     Determines verbosity of derivative checker.
+   Possible values:
+    - no                      [Print only suspect derivatives]
+    - yes                     [Print all derivatives]
+
+
+
+### Hessian Approximation ###
+
+limited_memory_max_history             0 <= (          6) <  +inf      
+   Maximum size of the history for the limited quasi-Newton Hessian
+   approximation.
+     This option determines the number of most recent iterations that are
+     taken into account for the limited-memory quasi-Newton approximation.
+
+limited_memory_update_type    ("bfgs")
+   Quasi-Newton update formula for the limited memory approximation.
+     Determines which update formula is to be used for the limited-memory
+     quasi-Newton approximation.
+   Possible values:
+    - bfgs                    [BFGS update (with skipping)]
+    - sr1                     [SR1 (not working well)]
+
+limited_memory_initialization ("scalar1")
+   Initialization strategy for the limited memory quasi-Newton approximation.
+     Determines how the diagonal Matrix B_0 as the first term in the limited
+     memory approximation should be computed.
+   Possible values:
+    - scalar1                 [sigma = s^Ty/s^Ts]
+    - scalar2                 [sigma = y^Ty/s^Ty]
+    - constant                [sigma = limited_memory_init_val]
+
+limited_memory_init_val                0 <  (          1) <  +inf      
+   Value for B0 in low-rank update.
+     The starting matrix in the low rank update, B0, is chosen to be this
+     multiple of the identity in the first iteration (when no updates have
+     been performed yet), and is constantly chosen as this value, if
+     "limited_memory_initialization" is "constant".
+
+limited_memory_max_skipping            1 <= (          2) <  +inf      
+   Threshold for successive iterations where update is skipped.
+     If the update is skipped more than this number of successive iterations,
+     we quasi-Newton approximation is reset.
+
+hessian_approximation         ("exact")
+   Indicates what Hessian information is to be used.
+     This determines which kind of information for the Hessian of the
+     Lagrangian function is used by the algorithm.
+   Possible values:
+    - exact                   [Use second derivatives provided by the NLP.]
+    - limited-memory          [Perform a limited-memory quasi-Newton
+                               approximation]
+
+hessian_approximation_space   ("nonlinear-variables")
+   Indicates in which subspace the Hessian information is to be approximated.
+   Possible values:
+    - nonlinear-variables     [only in space of nonlinear variables.]
+    - all-variables           [in space of all variables (without slacks)]
+
+
+
+### MA27 Linear Solver ###
+
+ma27_pivtol                            0 <  (     1e-008) <  1         
+   Pivot tolerance for the linear solver MA27.
+     A smaller number pivots for sparsity, a larger number pivots for
+     stability.  This option is only available if Ipopt has been compiled with
+     MA27.
+
+ma27_pivtolmax                         0 <  (     0.0001) <  1         
+   Maximum pivot tolerance for the linear solver MA27.
+     Ipopt may increase pivtol as high as pivtolmax to get a more accurate
+     solution to the linear system.  This option is only available if Ipopt
+     has been compiled with MA27.
+
+ma27_liw_init_factor                   1 <= (          5) <  +inf      
+   Integer workspace memory for MA27.
+     The initial integer workspace memory = liw_init_factor * memory required
+     by unfactored system. Ipopt will increase the workspace size by
+     meminc_factor if required.  This option is only available if Ipopt has
+     been compiled with MA27.
+
+ma27_la_init_factor                    1 <= (          5) <  +inf      
+   Real workspace memory for MA27.
+     The initial real workspace memory = la_init_factor * memory required by
+     unfactored system. Ipopt will increase the workspace size by
+     meminc_factor if required.  This option is only available if  Ipopt has
+     been compiled with MA27.
+
+ma27_meminc_factor                     1 <= (         10) <  +inf      
+   Increment factor for workspace size for MA27.
+     If the integer or real workspace is not large enough, Ipopt will increase
+     its size by this factor.  This option is only available if Ipopt has been
+     compiled with MA27.
+
+ma27_skip_inertia_check       ("no")
+   Always present inertia is correct.
+     Setting this option to "yes" essentially disables inertia check. This
+     option makes the algorithm non-robust and easily fail, but it might give
+     some insight into the necessity of interia control.
+   Possible values:
+    - no                      [check interia]
+    - yes                     [skip inertia check]
+
+ma27_ignore_singularity       ("no")
+   Enables MA27's ability to solve a linear system even if the matrix is
+   singular.
+     Setting this option to "yes" means that Ipopt will call MA27 to compute
+     solutions for right hand sides, even if MA27 has detected that the matrix
+     is singular (but is still able to solve the linear system). In some cases
+     this might be better than using Ipopt's heuristic of small perturbation
+     of the lower diagonal of the KKT matrix.
+   Possible values:
+    - no                      [Don't have MA27 solve singular systems]
+    - yes                     [Have MA27 solve singular systems]
+
+
+
+### Uncategorized ###
+
+warm_start_target_mu                -inf <  (          0) <  +inf      
+   Unsupported!
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/eval_g_ipopt.m b/Requirements/MEIGO/eSS/local_solvers/ipopt/eval_g_ipopt.m
new file mode 100644
index 0000000000000000000000000000000000000000..b58cece35cb4ddd5e80f8f843bb69bd75c64d55d
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/eval_g_ipopt.m
@@ -0,0 +1,28 @@
+function df = eval_g_ipopt(x)
+
+global n_fun_eval hjfun params
+
+neq=0;
+index=length(x);
+%EVAL_GRAD Gradient evaluation
+%  
+%    
+eps = 1.0d-7;
+
+[f] = feval(hjfun,x,params{:} );
+n_fun_eval=n_fun_eval+1;
+feps=0;
+df=zeros(1,index);
+for i=1:index
+    epsa = eps*max(1.0d-5,abs(x(i)));
+    epsi=1.0d0/epsa;
+    x(i)=x(i)+epsa;
+    [feps] = feval(hjfun,x,params{:});
+    n_fun_eval=n_fun_eval+1;
+                     
+    df(i)=epsi*(feps-f);
+%     for j=1:nconst
+%         dg(j,i)=epsi*(wa1(j)-g(j));
+%     end
+    x(i)=x(i)-epsa;
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/eval_j_ipopt.m b/Requirements/MEIGO/eSS/local_solvers/ipopt/eval_j_ipopt.m
new file mode 100644
index 0000000000000000000000000000000000000000..6e5a8c749374d01726d1408f9d7fc5c0bfac8533
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/eval_j_ipopt.m
@@ -0,0 +1,38 @@
+function [J] = eval_j_ipopt(x,returnStructureOnly)
+global n_fun_eval hjfun params
+
+neq=0;
+index=length(x);
+%EVAL_GRAD Gradient evaluation
+%
+%
+eps = 1.0d-7;
+
+[ f,g ] = feval(hjfun,x,params{:} );
+nconst=length(g);
+n_fun_eval=n_fun_eval+1;
+
+if returnStructureOnly
+    J = sparse(ones(nconst,index));
+else
+    feps=0;
+    wa1=zeros(1,nconst);
+
+    dg=zeros(nconst,index);
+
+    for i=1:index
+        epsa = eps*max(1.0d-5,abs(x(i)));
+        epsi=1.0d0/epsa;
+        x(i)=x(i)+epsa;
+        [feps,wa1] = feval(hjfun,x,params{:});
+        n_fun_eval=n_fun_eval+1;
+
+        %df(i)=epsi*(feps-f);
+        for j=1:nconst
+            %Vectorize this!!!!
+            dg(j,i)=epsi*(wa1(j)-g(j));
+        end
+        x(i)=x(i)-epsa;
+    end
+    J=sparse(dg);
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.m b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.m
new file mode 100644
index 0000000000000000000000000000000000000000..046f04a5d3cab687e627911fa909226ee1547f2e
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.m
@@ -0,0 +1,202 @@
+% IPOPT Call the IPOPT constrained, nonlinear solver. 
+%   The basic function call is
+%   
+%     [status x] = IPOPT(x0,lb,ub,constraintlb,constraintub,objfunc,...
+%                        gradfunc,constraintfunc,jacobianfunc,hessianfunc)
+%
+%   The first input argument x0 is either a matrix or a cell array of
+%   matrices. It declares the starting point for the solver.
+%
+%   The second and third input arguments lb and ub must be of the same
+%   structure as x0. They declare the lower and upper bounds on the
+%   variables, respectively. Set an entry of lb to Inf to declare no lower
+%   bound, and likewise for the upper bounds.
+%
+%   The fourth and fifth input arguments constraintlb and constraintub set
+%   the lower and upper bounds on the constraints, respectively. Each should
+%   be a vector of length equal to the number of constraints. As before, a
+%   bound is removed by setting the entry to Inf. An equality constraint is
+%   achieved by setting constraintlb(i) = constraintub(i).
+%
+%   If the solver successfully converges to a stationary point or terminated
+%   without an unrecoverable error, the function IPOPT outputs the candidate
+%   solution x, and the termination status of the algorithm is provided in
+%   the output "status". In all other cases, an error is thrown. The number
+%   of outputs is equal to the number of cell entries in x0. If x0 is a
+%   matrix, IPOPT produces a single output.
+%
+%   EXAMPLE. Here is an example of a basic call to IPOPT, in which the
+%   optimization variables are specified by an array of length n and another
+%   array of length m:
+%
+%   [status r s] = ipopt({r s},{ zeros(n,1) zeros(m,1) },...
+%                        { repmat(inf,n,1) repmat(inf,m,1) },lb,ub,...
+%                        @computeobjective,@computegradient,...
+%                        @computeconstraints',@computejacobian,...
+%                        @computeJGHessian,auxdata);
+%
+%   The optimization variables are bounded below by 0. The bounds on the
+%   equality and inequality constraints are specified by the MATLAB
+%   variables lb and ub. Upon convergence to a feasible, stationary point,
+%   the routine will return the values of the primal variables r and
+%   s. Also, auxiliary data ('auxdata') is passed to all the callback
+%   routines. For more information, continue reading below.
+%
+%   The remaining input arguments must be function handles for various 
+%   MATLAB routines (M-files or subfunctions):
+%
+%     objfunc         Calculates the objective function at the current
+%                     point. The routine must accept as many inputs as cell
+%                     entries in x0 (or one input if x0 is a matrix). The
+%                     output must be a scalar representing the objective
+%                     evaluated at the current point.
+%         
+%     gradfunc        Computes the gradient of the objective at the current
+%                     point. The input is the same as objfunc, but it must
+%                     return as many outputs as there are inputs, and each
+%                     of the outputs must have the same matrix structure
+%                     as its corresponding input.
+%
+%     constraintfunc  Evaluates the constraint functions at the current
+%                     point. The MATLAB routine must accept the same inputs
+%                     as objfunc. The return value is a vector of length
+%                     equal to the number of constraints (it must be of the
+%                     same length as constraintlb and constraintub). If
+%                     there are no constraints, constraintfunc may be set
+%                     to the empty string because the MATLAB callback
+%                     routine will never be called.
+%
+%     jacobianfunc    Evaluates the Jacobian of the constraints at the
+%                     current point. The inputs are the same as the
+%                     previously described callback functions, except that
+%                     it has an additional input "returnStructureOnly" which
+%                     will either true or false. If returnStructureOnly is
+%                     false, return the Jacobian matrix evaluated at the
+%                     specified point. If returnStructureOnly is true,
+%                     return a sparse matrix whereby an entry is zero if and
+%                     only if the Jacobian of the constraints is zero at
+%                     EVERY possible (feasible or non-feasible) point. The
+%                     output must always be an M x N sparse matrix, where M
+%                     is the number of constraints and N is the number of
+%                     variables. Type HELP SPARSE for more information on
+%                     constructing sparse matrices in MATLAB. If there
+%                     are no constraints, jacobianfunc may be set to the
+%                     empty string because the MATLAB callback routine
+%                     will never be called.
+%
+%     hessianfunc     Evaluates the Hessian of the Lagrangian at the current
+%                     point. Its inputs are the same as the objective and
+%                     gradient callback functions, but it also has three
+%                     additional inputs. The first additional input is
+%                     "sigma". It is a scalar factor on the
+%                     objective. The second additional input is "lambda",
+%                     which is a vector of length equal to the number of
+%                     constraints. The remaining additional input is
+%                     returnStructureOnly (see the description of
+%                     jacobianfunc above). The function should compute
+%                  
+%                       sigma*H + lambda(1)*G1 + ... + lambda(M)*GM
+%
+%                     where M is the number of constraints, H is the Hessian
+%                     of the objective and the G's are the Hessians of the
+%                     constraint functions. The output must always be an N x
+%                     N sparse, lower triangular matrix, where N is the
+%                     number of variables. In other words, if X is the
+%                     output value, then X must be the same as TRIL(X).
+%
+%   For more information on using functions and function handles in MATLAB,
+%   type HELP FUNCTION and HELP FUNCTION_HANDLE in the MATLAB prompt.
+%
+%   Optionally, one may choose to pass additional auxiliary data to the
+%   MATLAB callback routines listed above through the function call
+%   IPOPT(...,auxdata). If auxdata is the empty matrix, no extra information
+%   is passed. It is important to observe that the auxiliary data MAY NOT
+%   CHANGE through the course of the IPOPT optimization! The auxiliary data
+%   keep the same values as they possessed in the initial call. If you need
+%   variables that change over time, you may want to consider global
+%   variables (type HELP GLOBAL).
+%
+%   EXAMPLE (continued). Returning to the above example, the 5 callback
+%   routines would be of the following form:
+%
+%     function F        = computeobjective   (r,s,auxdata)
+%     function [dr, ds] = computegradient    (r,s,auxdata)
+%     function g        = computeconstraints (r,s,auxdata) 
+%     function J        = computejacobian    (r,s,returnStructOnly,auxdata)
+%     function H        = computehessian     (r,s,sigma,lambda,...
+%                                             returnStructOnly,auxdata)
+%
+%   IPOPT(...,auxdata,iterfunc) specifies a a function handle to an
+%   additional callback routine which is called once per algorithm
+%   iteration. The callback routine must take the form ITERFUNC(T,F,AUXDATA). 
+%   T is the current iteration of the algorithm. F is the current value of
+%   the objective. Finally, extra information may be passed through the
+%   input AUXDATA. No outputs are expected from iterfunc. Also note that the
+%   value of the optimization variables is not passed to this callback
+%   routine. If iterfunc is the empty string, no routine is called.
+%
+%   By default, the print level is set so that IPOPT displays the
+%   progress of the algorithm. However, if the user implements an
+%   iterative callback routine, the print level is automatically set so
+%   that IPOPT does not generate output to the MATLAB console.
+%
+%   IPOPT(...,auxdata,iterfunc,multipliers) specifies the initial values for
+%   the Lagrange multipliers. The input "multipliers" must have three
+%   fields. The field "zl" must be an array of length equal to the total
+%   number of optimization variables. It contains the initial values for the
+%   Lagrange multipliers associated with the lower bounds on the
+%   optimization variables. The field "zu" is an array of the same
+%   length. It contains the initial values for the upper bounds Lagrange
+%   multipliers. The field "lambda" must be an array of length equal to the
+%   number of constraints. It specifies the initial values for the Lagrange
+%   multipliers associated with the equality and inequality constraints.
+%
+%   These inputs may be followed by parameter/value pairs to modify the
+%   default IPOPT algorithm options. See the IPOPT documentation for more
+%   information. If the IPOPT option 'hessian_approximation' is set to
+%   'limited-memory', the Hessian callback routine will never be called
+%   so it may be set to the empty string.
+%
+%   [..., multipliers, numiter] = IPOPT(...) returns some additional
+%   information to the user: the values of the Lagrange multipliers at the
+%   solution (the multipliers corresponding to the lower bounds on the
+%   variables, the upper bounds on the variables, and the equality and
+%   inequality constraints), and the number of iterations needed to converge
+%   to the stationary point (provided it has converged at all).
+%
+%   Upon termination, the return value "status" will take on one of these
+%   following values (for a more up-to-date listing, see the IpReturnCodes.h
+%   header file in the IPOPT C++ source directory):
+%
+%       0  solved
+%       1  solved to acceptable level
+%       2  infeasible problem detected
+%       3  search direction becomes too small
+%       4  diverging iterates
+%       5  user requested stop
+%     
+%      -1  maximum number of iterations exceeded
+%      -2  restoration phase failed
+%      -3  error in step computation
+%     -10  not enough degrees of freedom
+%     -11  invalid problem definition
+%     -12  invalid option
+%     -13  invalid number detected
+%
+%    -100  unrecoverable exception
+%    -101  non-IPOPT exception thrown
+%    -102  insufficient memory
+%    -199  internal error
+%
+%   For more information, please consult: A. Wachter and L. T. Biegler. "On
+%   the Implementation of a Primal-Dual Interior Point Filter Line Search
+%   Algorithm for Large-Scale Nonlinear Programming." Mathematical
+%   Programming 106(1), pp. 25-57, 2006.
+%
+%   Copyright (C) 2007 Peter Carbonetto. All Rights Reserved.
+%   This code is published under the Common Public License.
+%
+%   Author: Peter Carbonetto
+%           Dept. of Computer Science
+%           University of British Columbia
+%           March 20, 2008
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexa64 b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexa64
new file mode 100644
index 0000000000000000000000000000000000000000..1c74a6f8ad413f230dbb4af1d5261a7a059d4327
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexa64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexmaci64 b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexmaci64
new file mode 100644
index 0000000000000000000000000000000000000000..a90e43a245aa1281d2afbc7ec14980eb07704327
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexmaci64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexw32 b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexw32
new file mode 100644
index 0000000000000000000000000000000000000000..b7cb64048bd5116301a9ce406cd54127c885a98f
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexw32 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexw64 b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexw64
new file mode 100644
index 0000000000000000000000000000000000000000..1edf82297ee959f7b576ff37ebcfc12a6e23e97b
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.mexw64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.readme b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.readme
new file mode 100644
index 0000000000000000000000000000000000000000..084cc0f2b73f07afb6ba216309bcf152c0ab21f8
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt.readme
@@ -0,0 +1,1437 @@
+### Output ###
+
+print_level                           -2 <= (          5) <= 12        
+   Output verbosity level.
+     Sets the default verbosity level for console output. The larger this
+     value the more detailed is the output.
+
+output_file                   ("")
+   File name of desired output file (leave unset for no file output).
+     NOTE: This option only works when read from the ipopt.opt options file!
+     An output file with this name will be written (leave unset for no file
+     output).  The verbosity level is by default set to "print_level", but can
+     be overridden with "file_print_level".  The file name is changed to use
+     only small letters.
+   Possible values:
+    - *                       [Any acceptable standard file name]
+
+file_print_level                       0 <= (          5) <= 12        
+   Verbosity level for output file.
+     NOTE: This option only works when read from the ipopt.opt options file!
+     Determines the verbosity level for the file specified by "output_file". 
+     By default it is the same as "print_level".
+
+print_user_options            ("no")
+   Print all options set by the user.
+     If selected, the algorithm will print the list of all options set by the
+     user including their values and whether they have been used.  In some
+     cases this information might be incorrect, due to the internal program
+     flow.
+   Possible values:
+    - no                      [don't print options]
+    - yes                     [print options]
+
+print_options_documentation   ("no")
+   Switch to print all algorithmic options.
+     If selected, the algorithm will print the list of all available
+     algorithmic options with some documentation before solving the
+     optimization problem.
+   Possible values:
+    - no                      [don't print list]
+    - yes                     [print list]
+
+print_timing_statistics       ("no")
+   Switch to print timing statistics.
+     If selected, the program will print the CPU usage (user time) for
+     selected tasks.
+   Possible values:
+    - no                      [don't print statistics]
+    - yes                     [print all timing statistics]
+
+option_file_name              ("")
+   File name of options file (to overwrite default).
+     By default, the name of the Ipopt options file is "ipopt.opt" - or
+     something else if specified in the IpoptApplication::Initialize call. If
+     this option is set by SetStringValue BEFORE the options file is read, it
+     specifies the name of the options file.  It does not make any sense to
+     specify this option within the options file.
+   Possible values:
+    - *                       [Any acceptable standard file name]
+
+print_info_string             ("no")
+   Enables printing of additional info string at end of iteration output.
+     This string contains some insider information about the current iteration.
+   Possible values:
+    - no                      [don't print string]
+    - yes                     [print string at end of each iteration output]
+
+
+
+### Convergence ###
+
+tol                                    0 <  (      1e-08) <  +inf      
+   Desired convergence tolerance (relative).
+     Determines the convergence tolerance for the algorithm.  The algorithm
+     terminates successfully, if the (scaled) NLP error becomes smaller than
+     this value, and if the (absolute) criteria according to "dual_inf_tol",
+     "primal_inf_tol", and "cmpl_inf_tol" are met.  (This is epsilon_tol in
+     Eqn. (6) in implementation paper).  See also "acceptable_tol" as a second
+     termination criterion.  Note, some other algorithmic features also use
+     this quantity to determine thresholds etc.
+
+s_max                                  0 <  (        100) <  +inf      
+   Scaling threshold for the NLP error.
+     (See paragraph after Eqn. (6) in the implementation paper.)
+
+max_iter                               0 <= (       3000) <  +inf      
+   Maximum number of iterations.
+     The algorithm terminates with an error message if the number of
+     iterations exceeded this number.
+
+dual_inf_tol                           0 <  (          1) <  +inf      
+   Desired threshold for the dual infeasibility.
+     Absolute tolerance on the dual infeasibility. Successful termination
+     requires that the max-norm of the (unscaled) dual infeasibility is less
+     than this threshold.
+
+constr_viol_tol                        0 <  (     0.0001) <  +inf      
+   Desired threshold for the constraint violation.
+     Absolute tolerance on the constraint violation. Successful termination
+     requires that the max-norm of the (unscaled) constraint violation is less
+     than this threshold.
+
+compl_inf_tol                          0 <  (     0.0001) <  +inf      
+   Desired threshold for the complementarity conditions.
+     Absolute tolerance on the complementarity. Successful termination
+     requires that the max-norm of the (unscaled) complementarity is less than
+     this threshold.
+
+acceptable_tol                         0 <  (      1e-06) <  +inf      
+   "Acceptable" convergence tolerance (relative).
+     Determines which (scaled) overall optimality error is considered to be
+     "acceptable." There are two levels of termination criteria.  If the usual
+     "desired" tolerances (see tol, dual_inf_tol etc) are satisfied at an
+     iteration, the algorithm immediately terminates with a success message. 
+     On the other hand, if the algorithm encounters "acceptable_iter" many
+     iterations in a row that are considered "acceptable", it will terminate
+     before the desired convergence tolerance is met. This is useful in cases
+     where the algorithm might not be able to achieve the "desired" level of
+     accuracy.
+
+acceptable_iter                        0 <= (         15) <  +inf      
+   Number of "acceptable" iterates before triggering termination.
+     If the algorithm encounters this many successive "acceptable" iterates
+     (see "acceptable_tol"), it terminates, assuming that the problem has been
+     solved to best possible accuracy given round-off.  If it is set to zero,
+     this heuristic is disabled.
+
+acceptable_dual_inf_tol                0 <  (      1e+10) <  +inf      
+   "Acceptance" threshold for the dual infeasibility.
+     Absolute tolerance on the dual infeasibility. "Acceptable" termination
+     requires that the (max-norm of the unscaled) dual infeasibility is less
+     than this threshold; see also acceptable_tol.
+
+acceptable_constr_viol_tol             0 <  (       0.01) <  +inf      
+   "Acceptance" threshold for the constraint violation.
+     Absolute tolerance on the constraint violation. "Acceptable" termination
+     requires that the max-norm of the (unscaled) constraint violation is less
+     than this threshold; see also acceptable_tol.
+
+acceptable_compl_inf_tol               0 <  (       0.01) <  +inf      
+   "Acceptance" threshold for the complementarity conditions.
+     Absolute tolerance on the complementarity. "Acceptable" termination
+     requires that the max-norm of the (unscaled) complementarity is less than
+     this threshold; see also acceptable_tol.
+
+acceptable_obj_change_tol              0 <= (      1e+20) <  +inf      
+   "Acceptance" stopping criterion based on objective function change.
+     If the relative change of the objective function (scaled by
+     Max(1,|f(x)|)) is less than this value, this part of the acceptable
+     tolerance termination is satisfied; see also acceptable_tol.  This is
+     useful for the quasi-Newton option, which has trouble to bring down the
+     dual infeasibility.
+
+diverging_iterates_tol                 0 <  (      1e+20) <  +inf      
+   Threshold for maximal value of primal iterates.
+     If any component of the primal iterates exceeded this value (in absolute
+     terms), the optimization is aborted with the exit message that the
+     iterates seem to be diverging.
+
+
+
+### NLP Scaling ###
+
+nlp_scaling_method            ("gradient-based")
+   Select the technique used for scaling the NLP.
+     Selects the technique used for scaling the problem internally before it
+     is solved. For user-scaling, the parameters come from the NLP. If you are
+     using AMPL, they can be specified through suffixes ("scaling_factor")
+   Possible values:
+    - none                    [no problem scaling will be performed]
+    - user-scaling            [scaling parameters will come from the user]
+    - gradient-based          [scale the problem so the maximum gradient at
+                               the starting point is scaling_max_gradient]
+    - equilibration-based     [scale the problem so that first derivatives are
+                               of order 1 at random points (only available
+                               with MC19)]
+
+obj_scaling_factor                  -inf <  (          1) <  +inf      
+   Scaling factor for the objective function.
+     This option sets a scaling factor for the objective function. The scaling
+     is seen internally by Ipopt but the unscaled objective is reported in the
+     console output. If additional scaling parameters are computed (e.g.
+     user-scaling or gradient-based), both factors are multiplied. If this
+     value is chosen to be negative, Ipopt will maximize the objective
+     function instead of minimizing it.
+
+nlp_scaling_max_gradient               0 <  (        100) <  +inf      
+   Maximum gradient after NLP scaling.
+     This is the gradient scaling cut-off. If the maximum gradient is above
+     this value, then gradient based scaling will be performed. Scaling
+     parameters are calculated to scale the maximum gradient back to this
+     value. (This is g_max in Section 3.8 of the implementation paper.) Note:
+     This option is only used if "nlp_scaling_method" is chosen as
+     "gradient-based".
+
+nlp_scaling_obj_target_gradient         0 <= (          0) <  +inf      
+   Target value for objective function gradient size.
+     If a positive number is chosen, the scaling factor the objective function
+     is computed so that the gradient has the max norm of the given size at
+     the starting point.  This overrides nlp_scaling_max_gradient for the
+     objective function.
+
+nlp_scaling_constr_target_gradient         0 <= (          0) <  +inf      
+   Target value for constraint function gradient size.
+     If a positive number is chosen, the scaling factor the constraint
+     functions is computed so that the gradient has the max norm of the given
+     size at the starting point.  This overrides nlp_scaling_max_gradient for
+     the constraint functions.
+
+
+
+### NLP ###
+
+nlp_lower_bound_inf                 -inf <  (     -1e+19) <  +inf      
+   any bound less or equal this value will be considered -inf (i.e. not lower
+   bounded).
+
+nlp_upper_bound_inf                 -inf <  (      1e+19) <  +inf      
+   any bound greater or this value will be considered +inf (i.e. not upper
+   bounded).
+
+fixed_variable_treatment      ("make_parameter")
+   Determines how fixed variables should be handled.
+     The main difference between those options is that the starting point in
+     the "make_constraint" case still has the fixed variables at their given
+     values, whereas in the case "make_parameter" the functions are always
+     evaluated with the fixed values for those variables.  Also, for
+     "relax_bounds", the fixing bound constraints are relaxed (according to"
+     bound_relax_factor"). For both "make_constraints" and "relax_bounds",
+     bound multipliers are computed for the fixed variables.
+   Possible values:
+    - make_parameter          [Remove fixed variable from optimization
+                               variables]
+    - make_constraint         [Add equality constraints fixing variables]
+    - relax_bounds            [Relax fixing bound constraints]
+
+dependency_detector           ("none")
+   Indicates which linear solver should be used to detect linearly dependent
+   equality constraints.
+     The default and available choices depend on how Ipopt has been compiled. 
+     This is experimental and does not work well.
+   Possible values:
+    - none                    [don't check; no extra work at beginning]
+    - mumps                   [use MUMPS]
+    - wsmp                    [use WSMP]
+    - ma28                    [use MA28]
+
+dependency_detection_with_rhs ("no")
+   Indicates if the right hand sides of the constraints should be considered
+   during dependency detection
+   Possible values:
+    - no                      [only look at gradients]
+    - yes                     [also consider right hand side]
+
+num_linear_variables                   0 <= (          0) <  +inf      
+   Number of linear variables
+     When the Hessian is approximated, it is assumed that the first
+     num_linear_variables variables are linear.  The Hessian is then not
+     approximated in this space.  If the get_number_of_nonlinear_variables
+     method in the TNLP is implemented, this option is ignored.
+
+kappa_d                                0 <= (      1e-05) <  +inf      
+   Weight for linear damping term (to handle one-sided bounds).
+     (see Section 3.7 in implementation paper.)
+
+bound_relax_factor                     0 <= (      1e-08) <  +inf      
+   Factor for initial relaxation of the bounds.
+     Before start of the optimization, the bounds given by the user are
+     relaxed.  This option sets the factor for this relaxation.  If it is set
+     to zero, then then bounds relaxation is disabled. (See Eqn.(35) in
+     implementation paper.)
+
+honor_original_bounds         ("yes")
+   Indicates whether final points should be projected into original bounds.
+     Ipopt might relax the bounds during the optimization (see, e.g., option
+     "bound_relax_factor").  This option determines whether the final point
+     should be projected back into the user-provide original bounds after the
+     optimization.
+   Possible values:
+    - no                      [Leave final point unchanged]
+    - yes                     [Project final point back into original bounds]
+
+check_derivatives_for_naninf  ("no")
+   Indicates whether it is desired to check for Nan/Inf in derivative matrices
+     Activating this option will cause an error if an invalid number is
+     detected in the constraint Jacobians or the Lagrangian Hessian.  If this
+     is not activated, the test is skipped, and the algorithm might proceed
+     with invalid numbers and fail.
+   Possible values:
+    - no                      [Don't check (faster).]
+    - yes                     [Check Jacobians and Hessian for Nan and Inf.]
+
+jac_c_constant                ("no")
+   Indicates whether all equality constraints are linear
+     Activating this option will cause Ipopt to ask for the Jacobian of the
+     equality constraints only once from the NLP and reuse this information
+     later.
+   Possible values:
+    - no                      [Don't assume that all equality constraints are
+                               linear]
+    - yes                     [Assume that equality constraints Jacobian are
+                               constant]
+
+jac_d_constant                ("no")
+   Indicates whether all inequality constraints are linear
+     Activating this option will cause Ipopt to ask for the Jacobian of the
+     inequality constraints only once from the NLP and reuse this information
+     later.
+   Possible values:
+    - no                      [Don't assume that all inequality constraints
+                               are linear]
+    - yes                     [Assume that equality constraints Jacobian are
+                               constant]
+
+hessian_constant              ("no")
+   Indicates whether the problem is a quadratic problem
+     Activating this option will cause Ipopt to ask for the Hessian of the
+     Lagrangian function only once from the NLP and reuse this information
+     later.
+   Possible values:
+    - no                      [Assume that Hessian changes]
+    - yes                     [Assume that Hessian is constant]
+
+
+
+### Initialization ###
+
+bound_push                             0 <  (       0.01) <  +inf      
+   Desired minimum absolute distance from the initial point to bound.
+     Determines how much the initial point might have to be modified in order
+     to be sufficiently inside the bounds (together with "bound_frac").  (This
+     is kappa_1 in Section 3.6 of implementation paper.)
+
+bound_frac                             0 <  (       0.01) <= 0.5       
+   Desired minimum relative distance from the initial point to bound.
+     Determines how much the initial point might have to be modified in order
+     to be sufficiently inside the bounds (together with "bound_push").  (This
+     is kappa_2 in Section 3.6 of implementation paper.)
+
+slack_bound_push                       0 <  (       0.01) <  +inf      
+   Desired minimum absolute distance from the initial slack to bound.
+     Determines how much the initial slack variables might have to be modified
+     in order to be sufficiently inside the inequality bounds (together with
+     "slack_bound_frac").  (This is kappa_1 in Section 3.6 of implementation
+     paper.)
+
+slack_bound_frac                       0 <  (       0.01) <= 0.5       
+   Desired minimum relative distance from the initial slack to bound.
+     Determines how much the initial slack variables might have to be modified
+     in order to be sufficiently inside the inequality bounds (together with
+     "slack_bound_push").  (This is kappa_2 in Section 3.6 of implementation
+     paper.)
+
+constr_mult_init_max                   0 <= (       1000) <  +inf      
+   Maximum allowed least-square guess of constraint multipliers.
+     Determines how large the initial least-square guesses of the constraint
+     multipliers are allowed to be (in max-norm). If the guess is larger than
+     this value, it is discarded and all constraint multipliers are set to
+     zero.  This options is also used when initializing the restoration phase.
+     By default, "resto.constr_mult_init_max" (the one used in
+     RestoIterateInitializer) is set to zero.
+
+bound_mult_init_val                    0 <  (          1) <  +inf      
+   Initial value for the bound multipliers.
+     All dual variables corresponding to bound constraints are initialized to
+     this value.
+
+bound_mult_init_method        ("constant")
+   Initialization method for bound multipliers
+     This option defines how the iterates for the bound multipliers are
+     initialized.  If "constant" is chosen, then all bound multipliers are
+     initialized to the value of "bound_mult_init_val".  If "mu-based" is
+     chosen, the each value is initialized to the the value of "mu_init"
+     divided by the corresponding slack variable.  This latter option might be
+     useful if the starting point is close to the optimal solution.
+   Possible values:
+    - constant                [set all bound multipliers to the value of
+                               bound_mult_init_val]
+    - mu-based                [initialize to mu_init/x_slack]
+
+least_square_init_primal      ("no")
+   Least square initialization of the primal variables
+     If set to yes, Ipopt ignores the user provided point and solves a least
+     square problem for the primal variables (x and s), to fit the linearized
+     equality and inequality constraints.  This might be useful if the user
+     doesn't know anything about the starting point, or for solving an LP or
+     QP.
+   Possible values:
+    - no                      [take user-provided point]
+    - yes                     [overwrite user-provided point with least-square
+                               estimates]
+
+least_square_init_duals       ("no")
+   Least square initialization of all dual variables
+     If set to yes, Ipopt tries to compute least-square multipliers
+     (considering ALL dual variables).  If successful, the bound multipliers
+     are possibly corrected to be at least bound_mult_init_val. This might be
+     useful if the user doesn't know anything about the starting point, or for
+     solving an LP or QP.  This overwrites option "bound_mult_init_method".
+   Possible values:
+    - no                      [use bound_mult_init_val and least-square
+                               equality constraint multipliers]
+    - yes                     [overwrite user-provided point with least-square
+                               estimates]
+
+
+
+### Barrier Parameter Update ###
+
+mu_max_fact                            0 <  (       1000) <  +inf      
+   Factor for initialization of maximum value for barrier parameter.
+     This option determines the upper bound on the barrier parameter.  This
+     upper bound is computed as the average complementarity at the initial
+     point times the value of this option. (Only used if option "mu_strategy"
+     is chosen as "adaptive".)
+
+mu_max                                 0 <  (     100000) <  +inf      
+   Maximum value for barrier parameter.
+     This option specifies an upper bound on the barrier parameter in the
+     adaptive mu selection mode.  If this option is set, it overwrites the
+     effect of mu_max_fact. (Only used if option "mu_strategy" is chosen as
+     "adaptive".)
+
+mu_min                                 0 <  (      1e-11) <  +inf      
+   Minimum value for barrier parameter.
+     This option specifies the lower bound on the barrier parameter in the
+     adaptive mu selection mode. By default, it is set to the minimum of 1e-11
+     and min("tol","compl_inf_tol")/("barrier_tol_factor"+1), which should be
+     a reasonable value. (Only used if option "mu_strategy" is chosen as
+     "adaptive".)
+
+adaptive_mu_globalization     ("obj-constr-filter")
+   Globalization strategy for the adaptive mu selection mode.
+     To achieve global convergence of the adaptive version, the algorithm has
+     to switch to the monotone mode (Fiacco-McCormick approach) when
+     convergence does not seem to appear.  This option sets the criterion used
+     to decide when to do this switch. (Only used if option "mu_strategy" is
+     chosen as "adaptive".)
+   Possible values:
+    - kkt-error               [nonmonotone decrease of kkt-error]
+    - obj-constr-filter       [2-dim filter for objective and constraint
+                               violation]
+    - never-monotone-mode     [disables globalization]
+
+adaptive_mu_kkterror_red_iters         0 <= (          4) <  +inf      
+   Maximum number of iterations requiring sufficient progress.
+     For the "kkt-error" based globalization strategy, sufficient progress
+     must be made for "adaptive_mu_kkterror_red_iters" iterations. If this
+     number of iterations is exceeded, the globalization strategy switches to
+     the monotone mode.
+
+adaptive_mu_kkterror_red_fact          0 <  (     0.9999) <  1         
+   Sufficient decrease factor for "kkt-error" globalization strategy.
+     For the "kkt-error" based globalization strategy, the error must decrease
+     by this factor to be deemed sufficient decrease.
+
+filter_margin_fact                     0 <  (      1e-05) <  1         
+   Factor determining width of margin for obj-constr-filter adaptive
+   globalization strategy.
+     When using the adaptive globalization strategy, "obj-constr-filter",
+     sufficient progress for a filter entry is defined as follows: (new obj) <
+     (filter obj) - filter_margin_fact*(new constr-viol) OR (new constr-viol)
+     < (filter constr-viol) - filter_margin_fact*(new constr-viol).  For the
+     description of the "kkt-error-filter" option see "filter_max_margin".
+
+filter_max_margin                      0 <  (          1) <  +inf      
+   Maximum width of margin in obj-constr-filter adaptive globalization
+   strategy.
+
+adaptive_mu_restore_previous_iterate("no")
+   Indicates if the previous iterate should be restored if the monotone mode
+   is entered.
+     When the globalization strategy for the adaptive barrier algorithm
+     switches to the monotone mode, it can either start from the most recent
+     iterate (no), or from the last iterate that was accepted (yes).
+   Possible values:
+    - no                      [don't restore accepted iterate]
+    - yes                     [restore accepted iterate]
+
+adaptive_mu_monotone_init_factor         0 <  (        0.8) <  +inf      
+   Determines the initial value of the barrier parameter when switching to the
+   monotone mode.
+     When the globalization strategy for the adaptive barrier algorithm
+     switches to the monotone mode and fixed_mu_oracle is chosen as
+     "average_compl", the barrier parameter is set to the current average
+     complementarity times the value of "adaptive_mu_monotone_init_factor".
+
+adaptive_mu_kkt_norm_type     ("2-norm-squared")
+   Norm used for the KKT error in the adaptive mu globalization strategies.
+     When computing the KKT error for the globalization strategies, the norm
+     to be used is specified with this option. Note, this options is also used
+     in the QualityFunctionMuOracle.
+   Possible values:
+    - 1-norm                  [use the 1-norm (abs sum)]
+    - 2-norm-squared          [use the 2-norm squared (sum of squares)]
+    - max-norm                [use the infinity norm (max)]
+    - 2-norm                  [use 2-norm]
+
+mu_strategy                   ("monotone")
+   Update strategy for barrier parameter.
+     Determines which barrier parameter update strategy is to be used.
+   Possible values:
+    - monotone                [use the monotone (Fiacco-McCormick) strategy]
+    - adaptive                [use the adaptive update strategy]
+
+mu_oracle                     ("quality-function")
+   Oracle for a new barrier parameter in the adaptive strategy.
+     Determines how a new barrier parameter is computed in each "free-mode"
+     iteration of the adaptive barrier parameter strategy. (Only considered if
+     "adaptive" is selected for option "mu_strategy").
+   Possible values:
+    - probing                 [Mehrotra's probing heuristic]
+    - loqo                    [LOQO's centrality rule]
+    - quality-function        [minimize a quality function]
+
+fixed_mu_oracle               ("average_compl")
+   Oracle for the barrier parameter when switching to fixed mode.
+     Determines how the first value of the barrier parameter should be
+     computed when switching to the "monotone mode" in the adaptive strategy.
+     (Only considered if "adaptive" is selected for option "mu_strategy".)
+   Possible values:
+    - probing                 [Mehrotra's probing heuristic]
+    - loqo                    [LOQO's centrality rule]
+    - quality-function        [minimize a quality function]
+    - average_compl           [base on current average complementarity]
+
+mu_init                                0 <  (        0.1) <  +inf      
+   Initial value for the barrier parameter.
+     This option determines the initial value for the barrier parameter (mu). 
+     It is only relevant in the monotone, Fiacco-McCormick version of the
+     algorithm. (i.e., if "mu_strategy" is chosen as "monotone")
+
+barrier_tol_factor                     0 <  (         10) <  +inf      
+   Factor for mu in barrier stop test.
+     The convergence tolerance for each barrier problem in the monotone mode
+     is the value of the barrier parameter times "barrier_tol_factor". This
+     option is also used in the adaptive mu strategy during the monotone mode.
+     (This is kappa_epsilon in implementation paper).
+
+mu_linear_decrease_factor              0 <  (        0.2) <  1         
+   Determines linear decrease rate of barrier parameter.
+     For the Fiacco-McCormick update procedure the new barrier parameter mu is
+     obtained by taking the minimum of mu*"mu_linear_decrease_factor" and
+     mu^"superlinear_decrease_power".  (This is kappa_mu in implementation
+     paper.) This option is also used in the adaptive mu strategy during the
+     monotone mode.
+
+mu_superlinear_decrease_power          1 <  (        1.5) <  2         
+   Determines superlinear decrease rate of barrier parameter.
+     For the Fiacco-McCormick update procedure the new barrier parameter mu is
+     obtained by taking the minimum of mu*"mu_linear_decrease_factor" and
+     mu^"superlinear_decrease_power".  (This is theta_mu in implementation
+     paper.) This option is also used in the adaptive mu strategy during the
+     monotone mode.
+
+mu_allow_fast_monotone_decrease("yes")
+   Allow skipping of barrier problem if barrier test is already met.
+     If set to "no", the algorithm enforces at least one iteration per barrier
+     problem, even if the barrier test is already met for the updated barrier
+     parameter.
+   Possible values:
+    - no                      [Take at least one iteration per barrier problem]
+    - yes                     [Allow fast decrease of mu if barrier test it met]
+
+tau_min                                0 <  (       0.99) <  1         
+   Lower bound on fraction-to-the-boundary parameter tau.
+     (This is tau_min in the implementation paper.)  This option is also used
+     in the adaptive mu strategy during the monotone mode.
+
+sigma_max                              0 <  (        100) <  +inf      
+   Maximum value of the centering parameter.
+     This is the upper bound for the centering parameter chosen by the quality
+     function based barrier parameter update. (Only used if option "mu_oracle"
+     is set to "quality-function".)
+
+sigma_min                              0 <= (      1e-06) <  +inf      
+   Minimum value of the centering parameter.
+     This is the lower bound for the centering parameter chosen by the quality
+     function based barrier parameter update. (Only used if option "mu_oracle"
+     is set to "quality-function".)
+
+quality_function_norm_type    ("2-norm-squared")
+   Norm used for components of the quality function.
+     (Only used if option "mu_oracle" is set to "quality-function".)
+   Possible values:
+    - 1-norm                  [use the 1-norm (abs sum)]
+    - 2-norm-squared          [use the 2-norm squared (sum of squares)]
+    - max-norm                [use the infinity norm (max)]
+    - 2-norm                  [use 2-norm]
+
+quality_function_centrality   ("none")
+   The penalty term for centrality that is included in quality function.
+     This determines whether a term is added to the quality function to
+     penalize deviation from centrality with respect to complementarity.  The
+     complementarity measure here is the xi in the Loqo update rule. (Only
+     used if option "mu_oracle" is set to "quality-function".)
+   Possible values:
+    - none                    [no penalty term is added]
+    - log                     [complementarity * the log of the centrality
+                               measure]
+    - reciprocal              [complementarity * the reciprocal of the
+                               centrality measure]
+    - cubed-reciprocal        [complementarity * the reciprocal of the
+                               centrality measure cubed]
+
+quality_function_balancing_term("none")
+   The balancing term included in the quality function for centrality.
+     This determines whether a term is added to the quality function that
+     penalizes situations where the complementarity is much smaller than dual
+     and primal infeasibilities. (Only used if option "mu_oracle" is set to
+     "quality-function".)
+   Possible values:
+    - none                    [no balancing term is added]
+    - cubic                   [Max(0,Max(dual_inf,primal_inf)-compl)^3]
+
+quality_function_max_section_steps         0 <= (          8) <  +inf      
+   Maximum number of search steps during direct search procedure determining
+   the optimal centering parameter.
+     The golden section search is performed for the quality function based mu
+     oracle. (Only used if option "mu_oracle" is set to "quality-function".)
+
+quality_function_section_sigma_tol         0 <= (       0.01) <  1         
+   Tolerance for the section search procedure determining the optimal
+   centering parameter (in sigma space).
+     The golden section search is performed for the quality function based mu
+     oracle. (Only used if option "mu_oracle" is set to "quality-function".)
+
+quality_function_section_qf_tol         0 <= (          0) <  1         
+   Tolerance for the golden section search procedure determining the optimal
+   centering parameter (in the function value space).
+     The golden section search is performed for the quality function based mu
+     oracle. (Only used if option "mu_oracle" is set to "quality-function".)
+
+
+
+### Line Search ###
+
+alpha_red_factor                       0 <  (        0.5) <  1         
+   Fractional reduction of the trial step size in the backtracking line search.
+     At every step of the backtracking line search, the trial step size is
+     reduced by this factor.
+
+accept_every_trial_step       ("no")
+   Always accept the first trial step.
+     Setting this option to "yes" essentially disables the line search and
+     makes the algorithm take aggressive steps, without global convergence
+     guarantees.
+   Possible values:
+    - no                      [don't arbitrarily accept the full step]
+    - yes                     [always accept the full step]
+
+alpha_for_y                   ("primal")
+   Method to determine the step size for constraint multipliers.
+     This option determines how the step size (alpha_y) will be calculated
+     when updating the constraint multipliers.
+   Possible values:
+    - primal                  [use primal step size]
+    - bound_mult              [use step size for the bound multipliers (good
+                               for LPs)]
+    - min                     [use the min of primal and bound multipliers]
+    - max                     [use the max of primal and bound multipliers]
+    - full                    [take a full step of size one]
+    - min_dual_infeas         [choose step size minimizing new dual
+                               infeasibility]
+    - safe_min_dual_infeas    [like "min_dual_infeas", but safeguarded by
+                               "min" and "max"]
+    - primal-and-full         [use the primal step size, and full step if
+                               delta_x <= alpha_for_y_tol]
+    - dual-and-full           [use the dual step size, and full step if
+                               delta_x <= alpha_for_y_tol]
+    - acceptor                [Call LSAcceptor to get step size for y]
+
+alpha_for_y_tol                        0 <= (         10) <  +inf      
+   Tolerance for switching to full equality multiplier steps.
+     This is only relevant if "alpha_for_y" is chosen "primal-and-full" or
+     "dual-and-full".  The step size for the equality constraint multipliers
+     is taken to be one if the max-norm of the primal step is less than this
+     tolerance.
+
+tiny_step_tol                          0 <= (2.22045e-15) <  +inf      
+   Tolerance for detecting numerically insignificant steps.
+     If the search direction in the primal variables (x and s) is, in relative
+     terms for each component, less than this value, the algorithm accepts the
+     full step without line search.  If this happens repeatedly, the algorithm
+     will terminate with a corresponding exit message. The default value is 10
+     times machine precision.
+
+tiny_step_y_tol                        0 <= (       0.01) <  +inf      
+   Tolerance for quitting because of numerically insignificant steps.
+     If the search direction in the primal variables (x and s) is, in relative
+     terms for each component, repeatedly less than tiny_step_tol, and the
+     step in the y variables is smaller than this threshold, the algorithm
+     will terminate.
+
+watchdog_shortened_iter_trigger         0 <= (         10) <  +inf      
+   Number of shortened iterations that trigger the watchdog.
+     If the number of successive iterations in which the backtracking line
+     search did not accept the first trial point exceeds this number, the
+     watchdog procedure is activated.  Choosing "0" here disables the watchdog
+     procedure.
+
+watchdog_trial_iter_max                1 <= (          3) <  +inf      
+   Maximum number of watchdog iterations.
+     This option determines the number of trial iterations allowed before the
+     watchdog procedure is aborted and the algorithm returns to the stored
+     point.
+
+theta_max_fact                         0 <  (      10000) <  +inf      
+   Determines upper bound for constraint violation in the filter.
+     The algorithmic parameter theta_max is determined as theta_max_fact times
+     the maximum of 1 and the constraint violation at initial point.  Any
+     point with a constraint violation larger than theta_max is unacceptable
+     to the filter (see Eqn. (21) in the implementation paper).
+
+theta_min_fact                         0 <  (     0.0001) <  +inf      
+   Determines constraint violation threshold in the switching rule.
+     The algorithmic parameter theta_min is determined as theta_min_fact times
+     the maximum of 1 and the constraint violation at initial point.  The
+     switching rules treats an iteration as an h-type iteration whenever the
+     current constraint violation is larger than theta_min (see paragraph
+     before Eqn. (19) in the implementation paper).
+
+eta_phi                                0 <  (      1e-08) <  0.5       
+   Relaxation factor in the Armijo condition.
+     (See Eqn. (20) in the implementation paper)
+
+delta                                  0 <  (          1) <  +inf      
+   Multiplier for constraint violation in the switching rule.
+     (See Eqn. (19) in the implementation paper.)
+
+s_phi                                  1 <  (        2.3) <  +inf      
+   Exponent for linear barrier function model in the switching rule.
+     (See Eqn. (19) in the implementation paper.)
+
+s_theta                                1 <  (        1.1) <  +inf      
+   Exponent for current constraint violation in the switching rule.
+     (See Eqn. (19) in the implementation paper.)
+
+gamma_phi                              0 <  (      1e-08) <  1         
+   Relaxation factor in the filter margin for the barrier function.
+     (See Eqn. (18a) in the implementation paper.)
+
+gamma_theta                            0 <  (      1e-05) <  1         
+   Relaxation factor in the filter margin for the constraint violation.
+     (See Eqn. (18b) in the implementation paper.)
+
+alpha_min_frac                         0 <  (       0.05) <  1         
+   Safety factor for the minimal step size (before switching to restoration
+   phase).
+     (This is gamma_alpha in Eqn. (20) in the implementation paper.)
+
+max_soc                                0 <= (          4) <  +inf      
+   Maximum number of second order correction trial steps at each iteration.
+     Choosing 0 disables the second order corrections. (This is p^{max} of
+     Step A-5.9 of Algorithm A in the implementation paper.)
+
+kappa_soc                              0 <  (       0.99) <  +inf      
+   Factor in the sufficient reduction rule for second order correction.
+     This option determines how much a second order correction step must
+     reduce the constraint violation so that further correction steps are
+     attempted.  (See Step A-5.9 of Algorithm A in the implementation paper.)
+
+obj_max_inc                            1 <  (          5) <  +inf      
+   Determines the upper bound on the acceptable increase of barrier objective
+   function.
+     Trial points are rejected if they lead to an increase in the barrier
+     objective function by more than obj_max_inc orders of magnitude.
+
+max_filter_resets                      0 <= (          5) <  +inf      
+   Maximal allowed number of filter resets
+     A positive number enables a heuristic that resets the filter, whenever in
+     more than "filter_reset_trigger" successive iterations the last rejected
+     trial steps size was rejected because of the filter.  This option
+     determine the maximal number of resets that are allowed to take place.
+
+filter_reset_trigger                   1 <= (          5) <  +inf      
+   Number of iterations that trigger the filter reset.
+     If the filter reset heuristic is active and the number of successive
+     iterations in which the last rejected trial step size was rejected
+     because of the filter, the filter is reset.
+
+corrector_type                ("none")
+   The type of corrector steps that should be taken (unsupported!).
+     If "mu_strategy" is "adaptive", this option determines what kind of
+     corrector steps should be tried.
+   Possible values:
+    - none                    [no corrector]
+    - affine                  [corrector step towards mu=0]
+    - primal-dual             [corrector step towards current mu]
+
+skip_corr_if_neg_curv         ("yes")
+   Skip the corrector step in negative curvature iteration (unsupported!).
+     The corrector step is not tried if negative curvature has been
+     encountered during the computation of the search direction in the current
+     iteration. This option is only used if "mu_strategy" is "adaptive".
+   Possible values:
+    - no                      [don't skip]
+    - yes                     [skip]
+
+skip_corr_in_monotone_mode    ("yes")
+   Skip the corrector step during monotone barrier parameter mode
+   (unsupported!).
+     The corrector step is not tried if the algorithm is currently in the
+     monotone mode (see also option "barrier_strategy").This option is only
+     used if "mu_strategy" is "adaptive".
+   Possible values:
+    - no                      [don't skip]
+    - yes                     [skip]
+
+corrector_compl_avrg_red_fact          0 <  (          1) <  +inf      
+   Complementarity tolerance factor for accepting corrector step
+   (unsupported!).
+     This option determines the factor by which complementarity is allowed to
+     increase for a corrector step to be accepted.
+
+nu_init                                0 <  (      1e-06) <  +inf      
+   Initial value of the penalty parameter.
+
+nu_inc                                 0 <  (     0.0001) <  +inf      
+   Increment of the penalty parameter.
+
+rho                                    0 <  (        0.1) <  1         
+   Value in penalty parameter update formula.
+
+kappa_sigma                            0 <  (      1e+10) <  +inf      
+   Factor limiting the deviation of dual variables from primal estimates.
+     If the dual variables deviate from their primal estimates, a correction
+     is performed. (See Eqn. (16) in the implementation paper.) Setting the
+     value to less than 1 disables the correction.
+
+recalc_y                      ("no")
+   Tells the algorithm to recalculate the equality and inequality multipliers
+   as least square estimates.
+     This asks the algorithm to recompute the multipliers, whenever the
+     current infeasibility is less than recalc_y_feas_tol. Choosing yes might
+     be helpful in the quasi-Newton option.  However, each recalculation
+     requires an extra factorization of the linear system.  If a limited
+     memory quasi-Newton option is chosen, this is used by default.
+   Possible values:
+    - no                      [use the Newton step to update the multipliers]
+    - yes                     [use least-square multiplier estimates]
+
+recalc_y_feas_tol                      0 <  (      1e-06) <  +inf      
+   Feasibility threshold for recomputation of multipliers.
+     If recalc_y is chosen and the current infeasibility is less than this
+     value, then the multipliers are recomputed.
+
+slack_move                             0 <= (1.81899e-12) <  +inf      
+   Correction size for very small slacks.
+     Due to numerical issues or the lack of an interior, the slack variables
+     might become very small.  If a slack becomes very small compared to
+     machine precision, the corresponding bound is moved slightly.  This
+     parameter determines how large the move should be.  Its default value is
+     mach_eps^{3/4}.  (See also end of Section 3.5 in implementation paper -
+     but actual implementation might be somewhat different.)
+
+
+
+### Warm Start ###
+
+warm_start_init_point         ("no")
+   Warm-start for initial point
+     Indicates whether this optimization should use a warm start
+     initialization, where values of primal and dual variables are given
+     (e.g., from a previous optimization of a related problem.)
+   Possible values:
+    - no                      [do not use the warm start initialization]
+    - yes                     [use the warm start initialization]
+
+warm_start_same_structure     ("no")
+   Indicates whether a problem with a structure identical to the previous one
+   is to be solved.
+     If "yes" is chosen, then the algorithm assumes that an NLP is now to be
+     solved, whose structure is identical to one that already was considered
+     (with the same NLP object).
+   Possible values:
+    - no                      [Assume this is a new problem.]
+    - yes                     [Assume this is problem has known structure]
+
+warm_start_bound_push                  0 <  (      0.001) <  +inf      
+   same as bound_push for the regular initializer.
+
+warm_start_bound_frac                  0 <  (      0.001) <= 0.5       
+   same as bound_frac for the regular initializer.
+
+warm_start_slack_bound_push            0 <  (      0.001) <  +inf      
+   same as slack_bound_push for the regular initializer.
+
+warm_start_slack_bound_frac            0 <  (      0.001) <= 0.5       
+   same as slack_bound_frac for the regular initializer.
+
+warm_start_mult_bound_push             0 <  (      0.001) <  +inf      
+   same as mult_bound_push for the regular initializer.
+
+warm_start_mult_init_max            -inf <  (      1e+06) <  +inf      
+   Maximum initial value for the equality multipliers.
+
+warm_start_entire_iterate     ("no")
+   Tells algorithm whether to use the GetWarmStartIterate method in the NLP.
+   Possible values:
+    - no                      [call GetStartingPoint in the NLP]
+    - yes                     [call GetWarmStartIterate in the NLP]
+
+
+
+### Linear Solver ###
+
+linear_solver                 ("ma27")
+   Linear solver used for step computations.
+     Determines which linear algebra package is to be used for the solution of
+     the augmented linear system (for obtaining the search directions). Note,
+     the code must have been compiled with the linear solver you want to
+     choose. Depending on your Ipopt installation, not all options are
+     available.
+   Possible values:
+    - ma27                    [use the Harwell routine MA27]
+    - ma57                    [use the Harwell routine MA57]
+    - pardiso                 [use the Pardiso package]
+    - wsmp                    [use WSMP package]
+    - mumps                   [use MUMPS package]
+    - custom                  [use custom linear solver]
+
+linear_system_scaling         ("none")
+   Method for scaling the linear system.
+     Determines the method used to compute symmetric scaling factors for the
+     augmented system (see also the "linear_scaling_on_demand" option).  This
+     scaling is independent of the NLP problem scaling.  By default, MC19 is
+     only used if MA27 or MA57 are selected as linear solvers. This option is
+     only available if Ipopt has been compiled with MC19.
+   Possible values:
+    - none                    [no scaling will be performed]
+    - mc19                    [use the Harwell routine MC19]
+
+linear_scaling_on_demand      ("yes")
+   Flag indicating that linear scaling is only done if it seems required.
+     This option is only important if a linear scaling method (e.g., mc19) is
+     used.  If you choose "no", then the scaling factors are computed for
+     every linear system from the start.  This can be quite expensive.
+     Choosing "yes" means that the algorithm will start the scaling method
+     only when the solutions to the linear system seem not good, and then use
+     it until the end.
+   Possible values:
+    - no                      [Always scale the linear system.]
+    - yes                     [Start using linear system scaling if solutions
+                               seem not good.]
+
+
+
+### Step Calculation ###
+
+mehrotra_algorithm            ("no")
+   Indicates if we want to do Mehrotra's algorithm.
+     If set to yes, Ipopt runs as Mehrotra's predictor-corrector algorithm.
+     This works usually very well for LPs and convex QPs.  This automatically
+     disables the line search, and chooses the (unglobalized) adaptive mu
+     strategy with the "probing" oracle, and uses "corrector_type=affine"
+     without any safeguards; you should not set any of those options
+     explicitly in addition.  Also, unless otherwise specified, the values of
+     "bound_push", "bound_frac", and "bound_mult_init_val" are set more
+     aggressive, and sets "alpha_for_y=bound_mult".
+   Possible values:
+    - no                      [Do the usual Ipopt algorithm.]
+    - yes                     [Do Mehrotra's predictor-corrector algorithm.]
+
+fast_step_computation         ("no")
+   Indicates if the linear system should be solved quickly.
+     If set to yes, the algorithm assumes that the linear system that is
+     solved to obtain the search direction, is solved sufficiently well. In
+     that case, no residuals are computed, and the computation of the search
+     direction is a little faster.
+   Possible values:
+    - no                      [Verify solution of linear system by computing
+                               residuals.]
+    - yes                     [Trust that linear systems are solved well.]
+
+min_refinement_steps                   0 <= (          1) <  +inf      
+   Minimum number of iterative refinement steps per linear system solve.
+     Iterative refinement (on the full unsymmetric system) is performed for
+     each right hand side.  This option determines the minimum number of
+     iterative refinements (i.e. at least "min_refinement_steps" iterative
+     refinement steps are enforced per right hand side.)
+
+max_refinement_steps                   0 <= (         10) <  +inf      
+   Maximum number of iterative refinement steps per linear system solve.
+     Iterative refinement (on the full unsymmetric system) is performed for
+     each right hand side.  This option determines the maximum number of
+     iterative refinement steps.
+
+residual_ratio_max                     0 <  (      1e-10) <  +inf      
+   Iterative refinement tolerance
+     Iterative refinement is performed until the residual test ratio is less
+     than this tolerance (or until "max_refinement_steps" refinement steps are
+     performed).
+
+residual_ratio_singular                0 <  (      1e-05) <  +inf      
+   Threshold for declaring linear system singular after failed iterative
+   refinement.
+     If the residual test ratio is larger than this value after failed
+     iterative refinement, the algorithm pretends that the linear system is
+     singular.
+
+residual_improvement_factor            0 <  (          1) <  +inf      
+   Minimal required reduction of residual test ratio in iterative refinement.
+     If the improvement of the residual test ratio made by one iterative
+     refinement step is not better than this factor, iterative refinement is
+     aborted.
+
+neg_curv_test_tol                      0 <  (          0) <  +inf      
+   Tolerance for heuristic to ignore wrong inertia.
+     If positive, incorrect inertia in the augmented system is ignored, and we
+     test if the direction is a direction of positive curvature.  This
+     tolerance determines when the direction is considered to be sufficiently
+     positive.
+
+max_hessian_perturbation               0 <  (      1e+20) <  +inf      
+   Maximum value of regularization parameter for handling negative curvature.
+     In order to guarantee that the search directions are indeed proper
+     descent directions, Ipopt requires that the inertia of the (augmented)
+     linear system for the step computation has the correct number of negative
+     and positive eigenvalues. The idea is that this guides the algorithm away
+     from maximizers and makes Ipopt more likely converge to first order
+     optimal points that are minimizers. If the inertia is not correct, a
+     multiple of the identity matrix is added to the Hessian of the Lagrangian
+     in the augmented system. This parameter gives the maximum value of the
+     regularization parameter. If a regularization of that size is not enough,
+     the algorithm skips this iteration and goes to the restoration phase.
+     (This is delta_w^max in the implementation paper.)
+
+min_hessian_perturbation               0 <= (      1e-20) <  +inf      
+   Smallest perturbation of the Hessian block.
+     The size of the perturbation of the Hessian block is never selected
+     smaller than this value, unless no perturbation is necessary. (This is
+     delta_w^min in implementation paper.)
+
+perturb_inc_fact_first                 1 <  (        100) <  +inf      
+   Increase factor for x-s perturbation for very first perturbation.
+     The factor by which the perturbation is increased when a trial value was
+     not sufficient - this value is used for the computation of the very first
+     perturbation and allows a different value for for the first perturbation
+     than that used for the remaining perturbations. (This is bar_kappa_w^+ in
+     the implementation paper.)
+
+perturb_inc_fact                       1 <  (          8) <  +inf      
+   Increase factor for x-s perturbation.
+     The factor by which the perturbation is increased when a trial value was
+     not sufficient - this value is used for the computation of all
+     perturbations except for the first. (This is kappa_w^+ in the
+     implementation paper.)
+
+perturb_dec_fact                       0 <  (   0.333333) <  1         
+   Decrease factor for x-s perturbation.
+     The factor by which the perturbation is decreased when a trial value is
+     deduced from the size of the most recent successful perturbation. (This
+     is kappa_w^- in the implementation paper.)
+
+first_hessian_perturbation             0 <  (     0.0001) <  +inf      
+   Size of first x-s perturbation tried.
+     The first value tried for the x-s perturbation in the inertia correction
+     scheme.(This is delta_0 in the implementation paper.)
+
+jacobian_regularization_value          0 <= (      1e-08) <  +inf      
+   Size of the regularization for rank-deficient constraint Jacobians.
+     (This is bar delta_c in the implementation paper.)
+
+jacobian_regularization_exponent         0 <= (       0.25) <  +inf      
+   Exponent for mu in the regularization for rank-deficient constraint
+   Jacobians.
+     (This is kappa_c in the implementation paper.)
+
+perturb_always_cd             ("no")
+   Active permanent perturbation of constraint linearization.
+     This options makes the delta_c and delta_d perturbation be used for the
+     computation of every search direction.  Usually, it is only used when the
+     iteration matrix is singular.
+   Possible values:
+    - no                      [perturbation only used when required]
+    - yes                     [always use perturbation]
+
+
+
+### Restoration Phase ###
+
+expect_infeasible_problem     ("no")
+   Enable heuristics to quickly detect an infeasible problem.
+     This options is meant to activate heuristics that may speed up the
+     infeasibility determination if you expect that there is a good chance for
+     the problem to be infeasible.  In the filter line search procedure, the
+     restoration phase is called more quickly than usually, and more reduction
+     in the constraint violation is enforced before the restoration phase is
+     left. If the problem is square, this option is enabled automatically.
+   Possible values:
+    - no                      [the problem probably be feasible]
+    - yes                     [the problem has a good chance to be infeasible]
+
+expect_infeasible_problem_ctol         0 <= (      0.001) <  +inf      
+   Threshold for disabling "expect_infeasible_problem" option.
+     If the constraint violation becomes smaller than this threshold, the
+     "expect_infeasible_problem" heuristics in the filter line search are
+     disabled. If the problem is square, this options is set to 0.
+
+start_with_resto              ("no")
+   Tells algorithm to switch to restoration phase in first iteration.
+     Setting this option to "yes" forces the algorithm to switch to the
+     feasibility restoration phase in the first iteration. If the initial
+     point is feasible, the algorithm will abort with a failure.
+   Possible values:
+    - no                      [don't force start in restoration phase]
+    - yes                     [force start in restoration phase]
+
+soft_resto_pderror_reduction_factor         0 <= (     0.9999) <  +inf      
+   Required reduction in primal-dual error in the soft restoration phase.
+     The soft restoration phase attempts to reduce the primal-dual error with
+     regular steps. If the damped primal-dual step (damped only to satisfy the
+     fraction-to-the-boundary rule) is not decreasing the primal-dual error by
+     at least this factor, then the regular restoration phase is called.
+     Choosing "0" here disables the soft restoration phase.
+
+max_soft_resto_iters                   0 <= (         10) <  +inf      
+   Maximum number of iterations performed successively in soft restoration
+   phase.
+     If the soft restoration phase is performed for more than so many
+     iterations in a row, the regular restoration phase is called.
+
+required_infeasibility_reduction         0 <= (        0.9) <  1         
+   Required reduction of infeasibility before leaving restoration phase.
+     The restoration phase algorithm is performed, until a point is found that
+     is acceptable to the filter and the infeasibility has been reduced by at
+     least the fraction given by this option.
+
+max_resto_iter                         0 <= (    3000000) <  +inf      
+   Maximum number of successive iterations in restoration phase.
+     The algorithm terminates with an error message if the number of
+     iterations successively taken in the restoration phase exceeds this
+     number.
+
+evaluate_orig_obj_at_resto_trial("yes")
+   Determines if the original objective function should be evaluated at
+   restoration phase trial points.
+     Setting this option to "yes" makes the restoration phase algorithm
+     evaluate the objective function of the original problem at every trial
+     point encountered during the restoration phase, even if this value is not
+     required.  In this way, it is guaranteed that the original objective
+     function can be evaluated without error at all accepted iterates;
+     otherwise the algorithm might fail at a point where the restoration phase
+     accepts an iterate that is good for the restoration phase problem, but
+     not the original problem.  On the other hand, if the evaluation of the
+     original objective is expensive, this might be costly.
+   Possible values:
+    - no                      [skip evaluation]
+    - yes                     [evaluate at every trial point]
+
+bound_mult_reset_threshold             0 <= (       1000) <  +inf      
+   Threshold for resetting bound multipliers after the restoration phase.
+     After returning from the restoration phase, the bound multipliers are
+     updated with a Newton step for complementarity.  Here, the change in the
+     primal variables during the entire restoration phase is taken to be the
+     corresponding primal Newton step. However, if after the update the
+     largest bound multiplier exceeds the threshold specified by this option,
+     the multipliers are all reset to 1.
+
+constr_mult_reset_threshold            0 <= (          0) <  +inf      
+   Threshold for resetting equality and inequality multipliers after
+   restoration phase.
+     After returning from the restoration phase, the constraint multipliers
+     are recomputed by a least square estimate.  This option triggers when
+     those least-square estimates should be ignored.
+
+
+
+### Derivative Checker ###
+
+derivative_test               ("none")
+   Enable derivative checker
+     If this option is enabled, a (slow) derivative test will be performed
+     before the optimization.  The test is performed at the user provided
+     starting point and marks derivative values that seem suspicious
+   Possible values:
+    - none                    [do not perform derivative test]
+    - first-order             [perform test of first derivatives at starting
+                               point]
+    - second-order            [perform test of first and second derivatives at
+                               starting point]
+
+derivative_test_perturbation           0 <  (      1e-08) <  +inf      
+   Size of the finite difference perturbation in derivative test.
+     This determines the relative perturbation of the variable entries.
+
+derivative_test_tol                    0 <  (     0.0001) <  +inf      
+   Threshold for indicating wrong derivative.
+     If the relative deviation of the estimated derivative from the given one
+     is larger than this value, the corresponding derivative is marked as
+     wrong.
+
+derivative_test_print_all     ("no")
+   Indicates whether information for all estimated derivatives should be
+   printed.
+     Determines verbosity of derivative checker.
+   Possible values:
+    - no                      [Print only suspect derivatives]
+    - yes                     [Print all derivatives]
+
+jacobian_approximation        ("exact")
+   Specifies technique to compute constraint Jacobian
+   Possible values:
+    - exact                   [user-provided derivatives]
+    - finite-difference-values [user-provided structure, values by finite
+                               differences]
+
+findiff_perturbation                   0 <  (      1e-07) <  +inf      
+   Size of the finite difference perturbation for derivative approximation.
+     This determines the relative perturbation of the variable entries.
+
+point_perturbation_radius              0 <= (         10) <  +inf      
+   Maximal perturbation of an evaluation point.
+     If a random perturbation of a points is required, this number indicates
+     the maximal perturbation.  This is for example used when determining the
+     center point at which the finite difference derivative test is executed.
+
+
+
+### Hessian Approximation ###
+
+limited_memory_max_history             0 <= (          6) <  +inf      
+   Maximum size of the history for the limited quasi-Newton Hessian
+   approximation.
+     This option determines the number of most recent iterations that are
+     taken into account for the limited-memory quasi-Newton approximation.
+
+limited_memory_update_type    ("bfgs")
+   Quasi-Newton update formula for the limited memory approximation.
+     Determines which update formula is to be used for the limited-memory
+     quasi-Newton approximation.
+   Possible values:
+    - bfgs                    [BFGS update (with skipping)]
+    - sr1                     [SR1 (not working well)]
+
+limited_memory_initialization ("scalar1")
+   Initialization strategy for the limited memory quasi-Newton approximation.
+     Determines how the diagonal Matrix B_0 as the first term in the limited
+     memory approximation should be computed.
+   Possible values:
+    - scalar1                 [sigma = s^Ty/s^Ts]
+    - scalar2                 [sigma = y^Ty/s^Ty]
+    - constant                [sigma = limited_memory_init_val]
+
+limited_memory_init_val                0 <  (          1) <  +inf      
+   Value for B0 in low-rank update.
+     The starting matrix in the low rank update, B0, is chosen to be this
+     multiple of the identity in the first iteration (when no updates have
+     been performed yet), and is constantly chosen as this value, if
+     "limited_memory_initialization" is "constant".
+
+limited_memory_init_val_max            0 <  (      1e+08) <  +inf      
+   Upper bound on value for B0 in low-rank update.
+     The starting matrix in the low rank update, B0, is chosen to be this
+     multiple of the identity in the first iteration (when no updates have
+     been performed yet), and is constantly chosen as this value, if
+     "limited_memory_initialization" is "constant".
+
+limited_memory_init_val_min            0 <  (      1e-08) <  +inf      
+   Lower bound on value for B0 in low-rank update.
+     The starting matrix in the low rank update, B0, is chosen to be this
+     multiple of the identity in the first iteration (when no updates have
+     been performed yet), and is constantly chosen as this value, if
+     "limited_memory_initialization" is "constant".
+
+limited_memory_max_skipping            1 <= (          2) <  +inf      
+   Threshold for successive iterations where update is skipped.
+     If the update is skipped more than this number of successive iterations,
+     we quasi-Newton approximation is reset.
+
+hessian_approximation         ("exact")
+   Indicates what Hessian information is to be used.
+     This determines which kind of information for the Hessian of the
+     Lagrangian function is used by the algorithm.
+   Possible values:
+    - exact                   [Use second derivatives provided by the NLP.]
+    - limited-memory          [Perform a limited-memory quasi-Newton
+                               approximation]
+
+hessian_approximation_space   ("nonlinear-variables")
+   Indicates in which subspace the Hessian information is to be approximated.
+   Possible values:
+    - nonlinear-variables     [only in space of nonlinear variables.]
+    - all-variables           [in space of all variables (without slacks)]
+
+
+
+### MA27 Linear Solver ###
+
+ma27_pivtol                            0 <  (      1e-08) <  1         
+   Pivot tolerance for the linear solver MA27.
+     A smaller number pivots for sparsity, a larger number pivots for
+     stability.  This option is only available if Ipopt has been compiled with
+     MA27.
+
+ma27_pivtolmax                         0 <  (     0.0001) <  1         
+   Maximum pivot tolerance for the linear solver MA27.
+     Ipopt may increase pivtol as high as pivtolmax to get a more accurate
+     solution to the linear system.  This option is only available if Ipopt
+     has been compiled with MA27.
+
+ma27_liw_init_factor                   1 <= (          5) <  +inf      
+   Integer workspace memory for MA27.
+     The initial integer workspace memory = liw_init_factor * memory required
+     by unfactored system. Ipopt will increase the workspace size by
+     meminc_factor if required.  This option is only available if Ipopt has
+     been compiled with MA27.
+
+ma27_la_init_factor                    1 <= (          5) <  +inf      
+   Real workspace memory for MA27.
+     The initial real workspace memory = la_init_factor * memory required by
+     unfactored system. Ipopt will increase the workspace size by
+     meminc_factor if required.  This option is only available if  Ipopt has
+     been compiled with MA27.
+
+ma27_meminc_factor                     1 <= (         10) <  +inf      
+   Increment factor for workspace size for MA27.
+     If the integer or real workspace is not large enough, Ipopt will increase
+     its size by this factor.  This option is only available if Ipopt has been
+     compiled with MA27.
+
+ma27_skip_inertia_check       ("no")
+   Always pretend inertia is correct.
+     Setting this option to "yes" essentially disables inertia check. This
+     option makes the algorithm non-robust and easily fail, but it might give
+     some insight into the necessity of inertia control.
+   Possible values:
+    - no                      [check inertia]
+    - yes                     [skip inertia check]
+
+ma27_ignore_singularity       ("no")
+   Enables MA27's ability to solve a linear system even if the matrix is
+   singular.
+     Setting this option to "yes" means that Ipopt will call MA27 to compute
+     solutions for right hand sides, even if MA27 has detected that the matrix
+     is singular (but is still able to solve the linear system). In some cases
+     this might be better than using Ipopt's heuristic of small perturbation
+     of the lower diagonal of the KKT matrix.
+   Possible values:
+    - no                      [Don't have MA27 solve singular systems]
+    - yes                     [Have MA27 solve singular systems]
+
+
+
+### MA57 Linear Solver ###
+
+ma57_pivtol                            0 <  (      1e-08) <  1         
+   Pivot tolerance for the linear solver MA57.
+     A smaller number pivots for sparsity, a larger number pivots for
+     stability. This option is only available if Ipopt has been compiled with
+     MA57.
+
+ma57_pivtolmax                         0 <  (     0.0001) <  1         
+   Maximum pivot tolerance for the linear solver MA57.
+     Ipopt may increase pivtol as high as ma57_pivtolmax to get a more
+     accurate solution to the linear system.  This option is only available if
+     Ipopt has been compiled with MA57.
+
+ma57_pre_alloc                         1 <= (          3) <  +inf      
+   Safety factor for work space memory allocation for the linear solver MA57.
+     If 1 is chosen, the suggested amount of work space is used.  However,
+     choosing a larger number might avoid reallocation if the suggest values
+     do not suffice.  This option is only available if Ipopt has been compiled
+     with MA57.
+
+
+
+### Pardiso Linear Solver ###
+
+pardiso_matching_strategy     ("complete+2x2")
+   Matching strategy to be used by Pardiso
+     This is IPAR(13) in Pardiso manual.  This option is only available if
+     Ipopt has been compiled with Pardiso.
+   Possible values:
+    - complete                [Match complete (IPAR(13)=1)]
+    - complete+2x2            [Match complete+2x2 (IPAR(13)=2)]
+    - constraints             [Match constraints (IPAR(13)=3)]
+
+pardiso_redo_symbolic_fact_only_if_inertia_wrong("no")
+   Toggle for handling case when elements were perturbed by Pardiso.
+     This option is only available if Ipopt has been compiled with Pardiso.
+   Possible values:
+    - no                      [Always redo symbolic factorization when
+                               elements were perturbed]
+    - yes                     [Only redo symbolic factorization when elements
+                               were perturbed if also the inertia was wrong]
+
+pardiso_repeated_perturbation_means_singular("no")
+   Interpretation of perturbed elements.
+     This option is only available if Ipopt has been compiled with Pardiso.
+   Possible values:
+    - no                      [Don't assume that matrix is singular if
+                               elements were perturbed after recent symbolic
+                               factorization]
+    - yes                     [Assume that matrix is singular if elements were
+                               perturbed after recent symbolic factorization]
+
+pardiso_out_of_core_power              0 <= (          0) <  +inf      
+   Enables out-of-core variant of Pardiso
+     Setting this option to a positive integer k makes Pardiso work in the
+     out-of-core variant where the factor is split in 2^k subdomains.  This is
+     IPARM(50) in the Pardiso manual.  This option is only available if Ipopt
+     has been compiled with Pardiso.
+
+pardiso_skip_inertia_check    ("no")
+   Always pretent inertia is correct.
+     Setting this option to "yes" essentially disables inertia check. This
+     option makes the algorithm non-robust and easily fail, but it might give
+     some insight into the necessity of inertia control.
+   Possible values:
+    - no                      [check inertia]
+    - yes                     [skip inertia check]
+
+pardiso_iter_tol_exponent           -inf <  (        -14) <  +inf      
+   
+
+pardiso_iterative             ("no")
+   
+   Possible values:
+    - no                      []
+    - yes                     []
+
+
+
+### MA28 Linear Solver ###
+
+ma28_pivtol                            0 <  (       0.01) <= 1         
+   Pivot tolerance for linear solver MA28.
+     This is used when MA28 tries to find the dependent constraints.
+
+
+
+### Uncategorized ###
+
+warm_start_target_mu                -inf <  (          0) <  +inf      
+   Unsupported!
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt_auxdata.m b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt_auxdata.m
new file mode 100644
index 0000000000000000000000000000000000000000..47b56217da1802b31e358c57e785db87eeea1a80
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt_auxdata.m
@@ -0,0 +1,42 @@
+function [x, info] = ipopt_auxdata(x0, funcs, options)
+% Wrapper function to implement auxdata functionality using Matlab function handles
+
+if ~isfield(options, 'auxdata')
+    % no auxdata given, call ipopt as normal
+    if isfield(funcs, 'iterfunc') && nargin(funcs.iterfunc) == 2
+        % check if iterfunc has only 2 inputs as before Ipopt version 3.11
+        funcs_old = funcs;
+        funcs.iterfunc = @(t, f, varstruct) funcs_old.iterfunc(t, f);
+    end
+    [x, info] = ipopt(x0, funcs, options);
+else
+    % remove auxdata from options structure and modify function handles
+    auxdata = options.auxdata;
+    options_new = rmfield(options, 'auxdata');
+    funcs_new.objective = @(x) funcs.objective(x, auxdata);
+    funcs_new.gradient  = @(x) funcs.gradient(x, auxdata);
+    if isfield(funcs, 'constraints')
+        funcs_new.constraints = @(x) funcs.constraints(x, auxdata);
+    end
+    if isfield(funcs, 'jacobian')
+        funcs_new.jacobian = @(x) funcs.jacobian(x, auxdata);
+    end
+    if isfield(funcs, 'jacobianstructure')
+        funcs_new.jacobianstructure = @() funcs.jacobianstructure(auxdata);
+    end
+    if isfield(funcs, 'hessian')
+        funcs_new.hessian = @(x, sigma, lambda) funcs.hessian(x, sigma, lambda, auxdata);
+    end
+    if isfield(funcs, 'hessianstructure')
+        funcs_new.hessianstructure = @() funcs.hessianstructure(auxdata);
+    end
+    if isfield(funcs, 'iterfunc')
+        % This assumes the pre-3.11 convention for iterfunc. If you would
+        % like to use the additional information that is available via the
+        % third input argument to iterfunc as of Ipopt version 3.11, you
+        % will need to modify this section by uncommenting the line below.
+        funcs_new.iterfunc = @(t, f, varstruct) funcs.iterfunc(t, f, auxdata);
+        % funcs_new.iterfunc = @(t, f, varstruct) funcs.iterfunc(t, f, varstruct, auxdata);
+    end
+    [x, info] = ipopt(x0, funcs_new, options_new);
+end
diff --git a/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt_declare.txt b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt_declare.txt
new file mode 100644
index 0000000000000000000000000000000000000000..046f04a5d3cab687e627911fa909226ee1547f2e
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ipopt/ipopt_declare.txt
@@ -0,0 +1,202 @@
+% IPOPT Call the IPOPT constrained, nonlinear solver. 
+%   The basic function call is
+%   
+%     [status x] = IPOPT(x0,lb,ub,constraintlb,constraintub,objfunc,...
+%                        gradfunc,constraintfunc,jacobianfunc,hessianfunc)
+%
+%   The first input argument x0 is either a matrix or a cell array of
+%   matrices. It declares the starting point for the solver.
+%
+%   The second and third input arguments lb and ub must be of the same
+%   structure as x0. They declare the lower and upper bounds on the
+%   variables, respectively. Set an entry of lb to Inf to declare no lower
+%   bound, and likewise for the upper bounds.
+%
+%   The fourth and fifth input arguments constraintlb and constraintub set
+%   the lower and upper bounds on the constraints, respectively. Each should
+%   be a vector of length equal to the number of constraints. As before, a
+%   bound is removed by setting the entry to Inf. An equality constraint is
+%   achieved by setting constraintlb(i) = constraintub(i).
+%
+%   If the solver successfully converges to a stationary point or terminated
+%   without an unrecoverable error, the function IPOPT outputs the candidate
+%   solution x, and the termination status of the algorithm is provided in
+%   the output "status". In all other cases, an error is thrown. The number
+%   of outputs is equal to the number of cell entries in x0. If x0 is a
+%   matrix, IPOPT produces a single output.
+%
+%   EXAMPLE. Here is an example of a basic call to IPOPT, in which the
+%   optimization variables are specified by an array of length n and another
+%   array of length m:
+%
+%   [status r s] = ipopt({r s},{ zeros(n,1) zeros(m,1) },...
+%                        { repmat(inf,n,1) repmat(inf,m,1) },lb,ub,...
+%                        @computeobjective,@computegradient,...
+%                        @computeconstraints',@computejacobian,...
+%                        @computeJGHessian,auxdata);
+%
+%   The optimization variables are bounded below by 0. The bounds on the
+%   equality and inequality constraints are specified by the MATLAB
+%   variables lb and ub. Upon convergence to a feasible, stationary point,
+%   the routine will return the values of the primal variables r and
+%   s. Also, auxiliary data ('auxdata') is passed to all the callback
+%   routines. For more information, continue reading below.
+%
+%   The remaining input arguments must be function handles for various 
+%   MATLAB routines (M-files or subfunctions):
+%
+%     objfunc         Calculates the objective function at the current
+%                     point. The routine must accept as many inputs as cell
+%                     entries in x0 (or one input if x0 is a matrix). The
+%                     output must be a scalar representing the objective
+%                     evaluated at the current point.
+%         
+%     gradfunc        Computes the gradient of the objective at the current
+%                     point. The input is the same as objfunc, but it must
+%                     return as many outputs as there are inputs, and each
+%                     of the outputs must have the same matrix structure
+%                     as its corresponding input.
+%
+%     constraintfunc  Evaluates the constraint functions at the current
+%                     point. The MATLAB routine must accept the same inputs
+%                     as objfunc. The return value is a vector of length
+%                     equal to the number of constraints (it must be of the
+%                     same length as constraintlb and constraintub). If
+%                     there are no constraints, constraintfunc may be set
+%                     to the empty string because the MATLAB callback
+%                     routine will never be called.
+%
+%     jacobianfunc    Evaluates the Jacobian of the constraints at the
+%                     current point. The inputs are the same as the
+%                     previously described callback functions, except that
+%                     it has an additional input "returnStructureOnly" which
+%                     will either true or false. If returnStructureOnly is
+%                     false, return the Jacobian matrix evaluated at the
+%                     specified point. If returnStructureOnly is true,
+%                     return a sparse matrix whereby an entry is zero if and
+%                     only if the Jacobian of the constraints is zero at
+%                     EVERY possible (feasible or non-feasible) point. The
+%                     output must always be an M x N sparse matrix, where M
+%                     is the number of constraints and N is the number of
+%                     variables. Type HELP SPARSE for more information on
+%                     constructing sparse matrices in MATLAB. If there
+%                     are no constraints, jacobianfunc may be set to the
+%                     empty string because the MATLAB callback routine
+%                     will never be called.
+%
+%     hessianfunc     Evaluates the Hessian of the Lagrangian at the current
+%                     point. Its inputs are the same as the objective and
+%                     gradient callback functions, but it also has three
+%                     additional inputs. The first additional input is
+%                     "sigma". It is a scalar factor on the
+%                     objective. The second additional input is "lambda",
+%                     which is a vector of length equal to the number of
+%                     constraints. The remaining additional input is
+%                     returnStructureOnly (see the description of
+%                     jacobianfunc above). The function should compute
+%                  
+%                       sigma*H + lambda(1)*G1 + ... + lambda(M)*GM
+%
+%                     where M is the number of constraints, H is the Hessian
+%                     of the objective and the G's are the Hessians of the
+%                     constraint functions. The output must always be an N x
+%                     N sparse, lower triangular matrix, where N is the
+%                     number of variables. In other words, if X is the
+%                     output value, then X must be the same as TRIL(X).
+%
+%   For more information on using functions and function handles in MATLAB,
+%   type HELP FUNCTION and HELP FUNCTION_HANDLE in the MATLAB prompt.
+%
+%   Optionally, one may choose to pass additional auxiliary data to the
+%   MATLAB callback routines listed above through the function call
+%   IPOPT(...,auxdata). If auxdata is the empty matrix, no extra information
+%   is passed. It is important to observe that the auxiliary data MAY NOT
+%   CHANGE through the course of the IPOPT optimization! The auxiliary data
+%   keep the same values as they possessed in the initial call. If you need
+%   variables that change over time, you may want to consider global
+%   variables (type HELP GLOBAL).
+%
+%   EXAMPLE (continued). Returning to the above example, the 5 callback
+%   routines would be of the following form:
+%
+%     function F        = computeobjective   (r,s,auxdata)
+%     function [dr, ds] = computegradient    (r,s,auxdata)
+%     function g        = computeconstraints (r,s,auxdata) 
+%     function J        = computejacobian    (r,s,returnStructOnly,auxdata)
+%     function H        = computehessian     (r,s,sigma,lambda,...
+%                                             returnStructOnly,auxdata)
+%
+%   IPOPT(...,auxdata,iterfunc) specifies a a function handle to an
+%   additional callback routine which is called once per algorithm
+%   iteration. The callback routine must take the form ITERFUNC(T,F,AUXDATA). 
+%   T is the current iteration of the algorithm. F is the current value of
+%   the objective. Finally, extra information may be passed through the
+%   input AUXDATA. No outputs are expected from iterfunc. Also note that the
+%   value of the optimization variables is not passed to this callback
+%   routine. If iterfunc is the empty string, no routine is called.
+%
+%   By default, the print level is set so that IPOPT displays the
+%   progress of the algorithm. However, if the user implements an
+%   iterative callback routine, the print level is automatically set so
+%   that IPOPT does not generate output to the MATLAB console.
+%
+%   IPOPT(...,auxdata,iterfunc,multipliers) specifies the initial values for
+%   the Lagrange multipliers. The input "multipliers" must have three
+%   fields. The field "zl" must be an array of length equal to the total
+%   number of optimization variables. It contains the initial values for the
+%   Lagrange multipliers associated with the lower bounds on the
+%   optimization variables. The field "zu" is an array of the same
+%   length. It contains the initial values for the upper bounds Lagrange
+%   multipliers. The field "lambda" must be an array of length equal to the
+%   number of constraints. It specifies the initial values for the Lagrange
+%   multipliers associated with the equality and inequality constraints.
+%
+%   These inputs may be followed by parameter/value pairs to modify the
+%   default IPOPT algorithm options. See the IPOPT documentation for more
+%   information. If the IPOPT option 'hessian_approximation' is set to
+%   'limited-memory', the Hessian callback routine will never be called
+%   so it may be set to the empty string.
+%
+%   [..., multipliers, numiter] = IPOPT(...) returns some additional
+%   information to the user: the values of the Lagrange multipliers at the
+%   solution (the multipliers corresponding to the lower bounds on the
+%   variables, the upper bounds on the variables, and the equality and
+%   inequality constraints), and the number of iterations needed to converge
+%   to the stationary point (provided it has converged at all).
+%
+%   Upon termination, the return value "status" will take on one of these
+%   following values (for a more up-to-date listing, see the IpReturnCodes.h
+%   header file in the IPOPT C++ source directory):
+%
+%       0  solved
+%       1  solved to acceptable level
+%       2  infeasible problem detected
+%       3  search direction becomes too small
+%       4  diverging iterates
+%       5  user requested stop
+%     
+%      -1  maximum number of iterations exceeded
+%      -2  restoration phase failed
+%      -3  error in step computation
+%     -10  not enough degrees of freedom
+%     -11  invalid problem definition
+%     -12  invalid option
+%     -13  invalid number detected
+%
+%    -100  unrecoverable exception
+%    -101  non-IPOPT exception thrown
+%    -102  insufficient memory
+%    -199  internal error
+%
+%   For more information, please consult: A. Wachter and L. T. Biegler. "On
+%   the Implementation of a Primal-Dual Interior Point Filter Line Search
+%   Algorithm for Large-Scale Nonlinear Programming." Mathematical
+%   Programming 106(1), pp. 25-57, 2006.
+%
+%   Copyright (C) 2007 Peter Carbonetto. All Rights Reserved.
+%   This code is published under the Common Public License.
+%
+%   Author: Peter Carbonetto
+%           Dept. of Computer Science
+%           University of British Columbia
+%           March 20, 2008
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/call_n2fb.m b/Requirements/MEIGO/eSS/local_solvers/n2fb/call_n2fb.m
new file mode 100644
index 0000000000000000000000000000000000000000..209c2c862ab6a8c18bda77da56e784ea73dff906
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/n2fb/call_n2fb.m
@@ -0,0 +1,75 @@
+%             [NAGWare Gateway Generator]
+%
+%Copyright (c) 1993-97 by the Numerical Algorithms Group Ltd 2.0a
+%
+%n2fb
+%
+%n                                     integer
+%p                                     integer
+%x (p)                                 real
+%b (2,p)                               real
+%iv (liv)                              integer
+%liv                                   integer
+%lv                                    integer
+%v (lv)                                real
+%ui (:)                                integer
+%ur (:)                                real
+%
+%[x,iv,v,ur] = n2fb(n,p,x,b,iv,liv,lv,v,ui,ur)
+%
+%
+% MRF 14/06/2005
+
+function fobj = call_n2fb(X,N,P,xl,xu,local_solver)
+
+
+%tic;
+
+% *** THE FOLLOWING CODE IS FOR CALLING N2FB.
+%
+  %   N = 21*8*16;
+  %   P = 36;
+     LIV = 82+4*P;
+     LTY = N;
+     LV = 98+P*(3*P+25)/2+7+P+N*(P+2)+P*(P+15)/2;
+%
+% *** Y VALUES...
+%
+    for i = 1:N
+        TY(i,2) = 0;
+    end
+%
+% ***  T VALUES...
+%
+    for i = 1:N
+        TY(i,1) = 0;
+    end
+%
+% *** SUPPLY LEAD DIMENSION OF TY IN UI(1)...
+% *** (MOST COMPILERS WOULD LET US SIMPLY PASS LTY FOR UI,
+% *** BUT SOME, E.G. WATFIV, WILL NOT.)
+%
+      UI(1) = LTY;
+      IV(1:LIV) = 0;
+      IV(17) = 2000; % MXFCAL
+      IV(18) = 3000; % MXITER
+      V(1:LV) = 0;
+
+
+      % *** SUPPLY BOUNDS...
+B(1,:)=xl;
+B(2,:)=xu;
+
+
+
+%Call the MEX function
+%
+if strmatch(local_solver,'n2fb')
+    [X,IV,V,TY] = wn2fb(N,P,X,B,IV,LIV,LV,V,UI,TY);
+else
+    %dn2fb
+    [X,IV,V,TY] = wdn2fb(N,P,X,B,IV,LIV,LV,V,UI,TY);
+end
+
+fobj=X';
+% CPU_time=toc
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/license.txt b/Requirements/MEIGO/eSS/local_solvers/n2fb/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0c2c6394059f4c0ba8f6c038c0c5faaa57cfc0e0
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/n2fb/license.txt
@@ -0,0 +1,9 @@
+N2FB is part of the PORT library, available at
+http://www.netlib.org/port/
+
+The entire PORT library is now available without charge for
+non-commercial use under a non-exclusive limited-use software
+agreement, see
+http://www.netlib.org/port/readme
+
+Please make sure you follow this agreement.
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexglx b/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexglx
new file mode 100644
index 0000000000000000000000000000000000000000..d947793451b845d4ba14881dcb44373ae714938f
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexglx differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexmaci64 b/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexmaci64
new file mode 100644
index 0000000000000000000000000000000000000000..03def95b2db15238d5105702ced2d1d2ae8cfcdc
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexmaci64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexw32 b/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexw32
new file mode 100644
index 0000000000000000000000000000000000000000..5fc5f8b024acd0ff9fddac7ecaf633731f775d3b
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/n2fb/wdn2fb.mexw32 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexglx b/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexglx
new file mode 100644
index 0000000000000000000000000000000000000000..3c394f650ce874c7ed973f4b0c54f6a35fba5f03
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexglx differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexw32 b/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexw32
new file mode 100644
index 0000000000000000000000000000000000000000..eb0d940f8e31a80b61633f7b0e97231779e3d8da
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexw32 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexw64 b/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexw64
new file mode 100644
index 0000000000000000000000000000000000000000..ebfafafa24036d0d9415852e10637b8ce000e95e
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/n2fb/wn2fb.mexw64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/call_nl2sol.m b/Requirements/MEIGO/eSS/local_solvers/nl2sol/call_nl2sol.m
new file mode 100644
index 0000000000000000000000000000000000000000..5468e50b3e9b78411792b2761215334ca51efa51
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nl2sol/call_nl2sol.m
@@ -0,0 +1,44 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/local_solvers/nl2sol/call_nl2sol.m 1983 2015-02-20 10:55:44Z attila $
+%
+function [x,fval,exitflag] = call_nl2sol(x0,grad, ndata, lb, ub,opts)
+
+ydata = zeros(ndata,1);
+
+% disp('ndata in call_nl2sol:')
+% disp(ndata)
+
+%nl2sol_tuned is a tuned version of that comes with OPTI Toolbox.
+% the tuning is essential if gradient is not provided: the perturbation parameter used to estimate the gradient and the Hessian should be adjusted to the precision of the computation of the objective (e.g. the relative tolerance of CVODES.)
+% the perturbation parameter
+
+		
+[x, fval, exitflag, iter, feval] = nl2sol_v2_1(@objf_nl2sol,grad,x0,ydata,lb,ub,opts); % version by Attila - needs testing
+%[x, fval, exitflag, iter, feval] = nl2sol(@objf_nl2sol,grad,x0,ydata,lb,ub,opts);
+
+% be sure:
+R = objf_nl2sol(x);
+fval = R(:)'*R(:);
+
+switch(exitflag)
+    case {3,4}
+        info.Status = 'Optimal';
+    case 0
+        info.Status = 'Exceeded Iterations';
+    case -1
+        info.Status = 'Infeasible / Could not Converge';
+    case -2
+        info.Status = 'NL2SOL Error';
+    case -5
+        info.Status = 'User Exited';
+    case 7
+        info.Status = 'Singular convergence';
+    case 8
+        info.Status = 'False convergence';
+    otherwise        
+        info.Status = 'NL2SOL exited';
+        if fval == 0
+            fval = inf;
+        end
+end
+fprintf('NL2SOL ended after %d iteration and %d function evaluation:\n', iter,feval);
+fprintf('       Results: %s\n',info.Status);
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.m b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.m
new file mode 100644
index 0000000000000000000000000000000000000000..f7cf6d0983406ccd1d07521aebcb5247d8e47d1f
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.m
@@ -0,0 +1,37 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/local_solvers/nl2sol/nl2sol.m 770 2013-08-06 09:41:45Z attila $
+% NL2SOL  Solve a NLS using NL2SOL
+%
+% THIS IS A LOW LEVEL FUNCTION - USE opti_nl2sol() INSTEAD!
+%
+% nl2sol uses the Adaptive Nonlinear Least Squares library.
+%
+%   [x,fval,exitflag,iter] = nl2sol(fun,grad,x0,ydata,opts)
+%
+%   Input arguments:
+%       fun - nonlinear fitting function handle
+%       grad - gradient of nonlinear fitting function handle (optional)
+%       x0 - initial solution guess
+%       ydata - fitting data
+%       opts - solver options (see below)
+%
+%   Return arguments:
+%       x - solution vector
+%       fval - objective value at the solution
+%       exitflag - exit status (see below)
+%       iter - number of iterations taken by the solver
+%
+%   Option Fields (all optional):
+%       tolfun - function tolerance
+%       maxiter - maximum solver iterations
+%       display - solver display level [0,1,2]
+%
+%   Return Status:
+%       1 - optimal / stopped by xtol or ftol or both
+%       0 - maximum iterations exceeded
+%      -1 - could not converge / tolerance too small
+%      -2 - nl2sol error / bad parameters / out of range
+%      -3 - unknown error
+%      -5 - user exit
+%
+%
+%   Copyright (C) 2011 Jonathan Currie (I2C2)
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.mexw32 b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.mexw32
new file mode 100644
index 0000000000000000000000000000000000000000..d3de3b87f11ccd8d4c683d59903e503cf9f05165
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.mexw32 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.mexw64 b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.mexw64
new file mode 100644
index 0000000000000000000000000000000000000000..ef7cb9632cc99e7e03c4408bc946cf3c6c9f1cda
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol.mexw64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexa64 b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexa64
new file mode 100644
index 0000000000000000000000000000000000000000..a396a72e47172d5f259b8b645e891854bb41135a
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexa64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexglx b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexglx
new file mode 100644
index 0000000000000000000000000000000000000000..54b43321f494f2f448faad7a33848b342074329f
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexglx differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexw32 b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexw32
new file mode 100644
index 0000000000000000000000000000000000000000..6e532e356a66b5f9fc3493374ad4ba653bb24b61
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexw32 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexw64 b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexw64
new file mode 100644
index 0000000000000000000000000000000000000000..ee0919a28aba18332dfad0ff5f3a96ea57c4c690
Binary files /dev/null and b/Requirements/MEIGO/eSS/local_solvers/nl2sol/nl2sol_v2_1.mexw64 differ
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/Contents.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/Contents.m
new file mode 100644
index 0000000000000000000000000000000000000000..bab8186c9c2c036b1cab5fd668e0be97f9417a66
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/Contents.m
@@ -0,0 +1,62 @@
+% NOMADm Software Package
+%   Version 3.3, February 2, 2005
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   NOMADm files:
+%      nomadm          - Executes the graphical user interface (GUI) and
+%                        callback functions for running the MADS optimizer.
+%      mads_batch      - Sets up user options and runs MADS without the GUI.
+%      mads            - Runs the mesh-adaptive direct search (MADS) filter
+%                        algorithm for solving constrained or unconstrained
+%                        nonlinear or mixed variable optimization problems.
+%      mads_defaults   - Sets the default values used by all the NOMADm files.
+%      nomadm_compile  - A utility that uses mex to compile a C/C++ or FORTRAN
+%                        user functions file so it can be called in MATLAB.
+%
+%   Documentation:
+%      nomadm_help.pdf - NOMADm User's Guide.
+%      nomadm.txt      - Summary of all software changes in recent versions.
+%      gpl.txt         - GNU General Public License.
+%
+%   Other packages (URLs provided below):
+%      dace            - DACE Toolbox - used for forming surrogate problems
+%      nw              - a package for constructing surrogates using the
+%                        Nadaraya-Watson estimator.
+%      cmaes           - Genetic algorithm - used to optimize surrogates
+%                        and as a Search option
+%
+%      dace:  http://www.imm.dtu.dk/~hbn/dace/
+%      nw:    http://en.afit.edu/enc/Faculty/MAbramson/nomadm.html
+%      cmaes: http://www.bionik.tu-berlin.de/user/niko/cmaes_inmatlab.html
+
+%*******************************************************************************
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   This file is part of the NOMADm software package.
+%
+%   NOMADm is free software; you can redistribute it and/or modify it under the
+%   terms of the GNU General Public License as published by the Free Software
+%   Foundation; either version 2 of the License, or (at your option) any later
+%   version.
+%
+%   NOMADm is distributed in the hope that it will be useful, but WITHOUT ANY
+%   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+%   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+%   details.
+%
+%   You should have received a copy of the GNU General Public License along
+%   with NOMADm; if not, write to the Free Software Foundation, Inc., 
+%   59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% ------------------------------------------------------------------------------
+%   Originally created, 2001.
+%   Last modified, 28 January 2005
+%
+%   Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%*******************************************************************************
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/LEEME.txt b/Requirements/MEIGO/eSS/local_solvers/nomadm/LEEME.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e2550047eae126ed3ac678ff69e0fdd175bb7f2c
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/LEEME.txt
@@ -0,0 +1,7 @@
+Realizar la llamada como
+
+[BestF,BestI,RunStats,RunSet]=mads_batch
+
+leer esto de Abramson
+
+if you would like to access this data directly, the call to mads from mads_batch.m has an output variable, called RunSet, which is a structure containing almost everything!  RunSet.bfp is a vector containing a sequential storage of the best feasible point f-values (used for plotting).  If you want to access the iterate data, you can access RunSet.iterate, which is the corresponding vector of iterates.  Each iterate is itself a structure containing fields p, x, n, f/gradf, c/gradc, h/gradh, etc., which correspond to the categorical variables, continuous variables, number of continuous variables, objective function value and gradient, gradient, constraint function values and Jacobian, and constraint violation function value and gradient, respectively.
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/Mark A. Abramson NOMADm Software.URL b/Requirements/MEIGO/eSS/local_solvers/nomadm/Mark A. Abramson NOMADm Software.URL
new file mode 100644
index 0000000000000000000000000000000000000000..35a125d59109bf8dfd506dbdc566207c78a07df2
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/Mark A. Abramson NOMADm Software.URL	
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=http://www.afit.edu/en/ENC/Faculty/MAbramson/NOMADm.html
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/gpl.txt b/Requirements/MEIGO/eSS/local_solvers/nomadm/gpl.txt
new file mode 100644
index 0000000000000000000000000000000000000000..695cf0c406f18c9d3333a31bd92f5ad7cf2f8809
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/gpl.txt
@@ -0,0 +1,262 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989,1991 Free Software Foundation, Inc.
+                         59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+The licenses for most software are designed to take away your freedom to share
+and change it.  By contrast, the GNU General Public License is intended to
+guarantee your freedom to share and change free software -- to make sure the
+software is free for all its users.  This General Public License applies to
+most of the Free Software Foundation's software and to any other program whose
+authors commit to using it.  (Some other Free Software Foundation software is
+covered by the GNU Library General Public License instead.)  You can apply it
+to your programs, too.
+
+When we speak of free software, we are referring to freedom, not price.  Our
+General Public Licenses are designed to make sure that you have the freedom to
+distribute copies of free software (and charge for this service if you wish),
+that you receive source code or can get it if you want it, that you can change
+the software or use pieces of it in new free programs; and that you know you
+can do these things.
+
+To protect your rights, we need to make restrictions that forbid anyone to deny
+you these rights or to ask you to surrender the rights.  These restrictions
+translate to certain responsibilities for you if you distribute copies of the
+software, or if you modify it.
+
+For example, if you distribute copies of such a program, whether gratis or for
+a fee, you must give the recipients all the rights that you have.  You must
+make sure that they, too, receive or can get the source code.  And you must
+show them these terms so they know their rights.
+
+We protect your rights with two steps: (1) copyright the software, and (2)
+offer you this license which gives you legal permission to copy, distribute,
+and/or modify the software.
+
+Also, for each author's protection and ours, we want to make certain that
+everyone understands that there is no warranty for this free software.  If the
+software is modified by someone else and passed on, we want its recipients to
+know that what they have is not the original, so that any problems introduced
+by others will not reflect on the original authors' reputations.
+
+Finally, any free program is threatened constantly by software patents.  We
+wish to avoid the danger that redistributors of a free program will
+individually obtain patent licenses, in effect making the program proprietary.
+To prevent this, we have made it clear that any patent must be licensed for
+everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and modification
+follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains a notice
+placed by the copyright holder saying it may be distributed under the terms of
+this General Public License.  The "Program", below, refers to any such program
+or work, and a "work based on the Program" means either the Program or any
+derivative work under copyright law: that is to say, a work containing the
+Program or a portion of it, either verbatim or with modifications and/or
+translated into another language.  (Hereinafter, translation is included
+without limitation in the term "modification".) Each licensee is addressed
+as "you".
+
+Activities other than copying, distribution and modification are not covered by
+this License; they are outside its scope.  The act of running the Program is
+not restricted, and the output from the Program is covered only if its contents
+constitute a work based on the Program (independent of having been made by
+running the Program).  Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's source code
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and
+disclaimer of warranty; keep intact all the notices that refer to this License
+and to the absence of any warranty; and give any other recipients of the
+Program a copy of this License along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and you may
+at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion of it,
+thus forming a work based on the Program, and copy and distribute such
+modifications or work under the terms of Section 1 above, provided that you
+also meet all of these conditions:
+
+   a) You must cause the modified files to carry prominent notices stating that
+   you changed the files and the date of any change.
+
+   b) You must cause any work that you distribute or publish, that in whole or
+   in part contains or is derived from the Program or any part thereof, to be
+   licensed as a whole at no charge to all third parties under the terms of
+   this License.
+
+   c) If the modified program normally reads commands interactively when run,
+   you must cause it, when started running for such interactive use in the most
+   ordinary way, to print or display an announcement including an appropriate
+   copyright notice and a notice that there is no warranty (or else, saying
+   that you provide a warranty) and that users may redistribute the program
+   under these conditions, and telling the user how to view a copy of this
+   License.  (Exception: if the Program itself is interactive but does not
+   normally print such an announcement, your work based on the Program is not
+   required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If identifiable
+sections of that work are not derived from the Program, and can be reasonably
+considered independent and separate works in themselves, then this License, and
+its terms, do not apply to those sections when you distribute them as separate
+works.  But when you distribute the same sections as part of a whole which is a
+work based on the Program, the distribution of the whole must be on the terms
+of this License, whose permissions for other licensees extend to the entire
+whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest your
+rights to work written entirely by you; rather, the intent is to exercise the
+right to control the distribution of derivative or collective works based on
+the Program.
+
+In addition, mere aggregation of another work not based on the Program with the
+Program (or with a work based on the Program) on a volume of a storage or
+distribution medium does not bring the other work under the scope of this
+License.
+
+  3. You may copy and distribute the Program (or a work based on it, under
+Section 2) in object code or executable form under the terms of Sections 1 and
+2 above provided that you also do one of the following:
+
+   a) Accompany it with the complete corresponding machine-readable source
+   code, which must be distributed under the terms of Sections 1 and 2 above on
+   a medium customarily used for software interchange; or,
+
+   b) Accompany it with a written offer, valid for at least three years, to
+   give any third party, for a charge no more than your cost of physically
+   performing source distribution, a complete machine-readable copy of the
+   corresponding source code, to be distributed under the terms of Sections 1
+   and 2 above on a medium customarily used for software interchange; or,
+
+   c) Accompany it with the information you received as to the offer to
+   distribute corresponding source code.  (This alternative is allowed only for
+   noncommercial distribution and only if you received the program in object
+   code or executable form with such an offer, in accord with Subsection b
+   above.)
+
+The source code for a work means the preferred form of the work for making
+modifications to it.  For an executable work, complete source code means all
+the source code for all modules it contains, plus any associated interface
+definition files, plus the scripts used to control compilation and installation
+of the executable.  However, as a special exception, the source code
+distributed need not include anything that is normally distributed (in either
+source or binary form) with the major components (compiler, kernel, and so on)
+of the operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the source
+code from the same place counts as distribution of the source code, even though
+third parties are not compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program except as
+expressly provided under this License.  Any attempt otherwise to copy, modify,
+sublicense or distribute the Program is void, and will automatically terminate
+your rights under this License.  However, parties who have received copies, or
+rights, from you under this License will not have their licenses terminated so
+long as such parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not signed it.
+However, nothing else grants you permission to modify or distribute the Program
+or its derivative works.  These actions are prohibited by law if you do not
+accept this License.  Therefore, by modifying or distributing the Program (or
+any work based on the Program), you indicate your acceptance of this License to
+do so, and all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the Program),
+the recipient automatically receives a license from the original licensor to
+copy, distribute or modify the Program subject to these terms and conditions.
+You may not impose any further restrictions on the recipients' exercise of the
+rights granted herein.  You are not responsible for enforcing compliance by
+third parties to this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues), conditions
+are imposed on you (whether by court order, agreement or otherwise) that
+contradict the conditions of this License, they do not excuse you from the
+conditions of this License.  If you cannot distribute so as to satisfy
+simultaneously your obligations under this License and any other pertinent
+obligations, then as a consequence you may not distribute the Program at all.
+For example, if a patent license would not permit royalty-free redistribution
+of the Program by all those who receive copies directly or indirectly through
+you, then the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply and
+the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents or
+other property right claims or to contest validity of any such claims; this
+section has the sole purpose of protecting the integrity of the free software
+distribution system, which is implemented by public license practices.  Many
+people have made generous contributions to the wide range of software
+distributed through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing to
+distribute software through any other system and a licensee cannot impose that
+choice.
+
+This section is intended to make thoroughly clear what is believed to be a
+consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in certain
+countries either by patents or by copyrighted interfaces, the original
+copyright holder who places the Program under this License may add an explicit
+geographical distribution limitation excluding those countries, so that
+distribution is permitted only in or among countries not thus excluded.  In
+such case, this License incorporates the limitation as if written in the body
+of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions of
+the General Public License from time to time.  Such new versions will be
+similar in spirit to the present version, but may differ in detail to address
+new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any later
+version", you have the option of following the terms and conditions either of
+that version or of any later version published by the Free Software Foundation.
+If the Program does not specify a version number of this License, you may
+choose any version ever published by the Free Software Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free programs
+whose distribution conditions are different, write to the author to ask for
+permission.  For software which is copyrighted by the Free Software Foundation,
+write to the Free Software Foundation; we sometimes make exceptions for this.
+Our decision will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
+THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE
+STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE
+PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE,
+YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT
+OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS
+OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN
+IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/mads.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/mads.m
new file mode 100644
index 0000000000000000000000000000000000000000..2700e0cb7e975c01ffb2776218984a3c40f32238
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/mads.m
@@ -0,0 +1,3609 @@
+function [BestF,BestI,RunData,varargout] = mads(Problem,iterate0,varargin)
+%MADS  Solver for nonlinear and mixed variable constrained optimization
+%
+%   Syntax:
+%      [BESTF,BESTI,RUNDATA] = mads(PROBLEM,ITERATE0)
+%      [BESTF,BESTI,RUNDATA] = mads(PROBLEM,ITERATE0,OPTIONS)
+%      [BESTF,BESTI,RUNDATA] = mads(PROBLEM,ITERATE0,OPTIONS,RUNDATA)
+%      [BESTF,BESTI,RUNDATA,CACHE] = mads(PROBLEM,ITERATE0)
+%      [BESTF,BESTI,RUNDATA,CACHE] = mads(PROBLEM,ITERATE0,OPTIONS)
+%      [BESTF,BESTI,RUNDATA,CACHE] = mads(PROBLEM,ITERATE0,OPTIONS,RUNDATA)
+%
+%   Description:
+%      MADS is an optimization algorithm for constrained nonlinear and mixed
+%      variable programming problems.  It employs the derivative-free class of
+%      mesh-adaptive direct search (MADS) filter algorithms, which are a
+%      generalization of the class of Generalized Pattern Search (GPS) methods.
+%      Derivatives are not necessary to run the algorithm, but if available can
+%      be used to make the algorithm faster and more efficient in finding a
+%      solution.
+%
+%      All the input and output variables are structures, each of which
+%      contains many parameters.  The variables BESTF and BESTI, contain the
+%      data describing the best feasible point and least infeasible point found
+%      by the algorithm.  RUNDATA contains statistics on the MADS run, such as
+%      final mesh size, number of iterations, number of function and gradient
+%      evaluations, and CPU time used.  CACHE contains data associated with
+%      every point evaluated during the run.
+%
+%      The input variable PROBLEM contains variables that describe the
+%      optimization problem to be solved.  In particular, it contains the names
+%      of all the files associated with the problem, such as the functions
+%      file, the linear constraints file, the discrete neighbors file for MVP
+%      problems, and the initial points file.  ITERATE0 is a structure
+%      describing all the initial iterates.  OPTIONS contains all user options
+%      and settings to be used during the run.  If not used as an input
+%      argument, MADS uses default settings, as specified in the MADS_DEFAULTS
+%      function.  Using RUNDATA as an input variable is only done within the
+%      NOMADm GUI setup, when resuming a previously stopped run.  It is not
+%      recommended for running in batch mode.
+%
+%      The user is referred to the User's Guide for more detailed help in
+%      understanding the input and output variables.
+%
+%   See also MADS_BATCH, MADS_DEFAULTS, NOMADM
+
+%*******************************************************************************
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   This file is part of the NOMADm software package.
+%
+%   NOMADm is free software; you can redistribute it and/or modify it under the
+%   terms of the GNU General Public License as published by the Free Software
+%   Foundation; either version 2 of the License, or (at your option) any later
+%   version.
+%
+%   NOMADm is distributed in the hope that it will be useful, but WITHOUT ANY
+%   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+%   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+%   details.
+%
+%   You should have received a copy of the GNU General Public License along with
+%   NOMADm; if not, write to the Free Software Foundation, Inc., 
+%   59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% ------------------------------------------------------------------------------
+%   Originally created, 2001.
+%   Last modified, 2 February 2005
+%
+%   Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%*******************************************************************************
+
+%*******************************************************************************
+% mads: Runs the Mesh-Adpative Direct Search (MADS) Filter Algorithm for
+%       solving constrained Mixed Variable Programming (MVP) problems.
+% ------------------------------------------------------------------------------
+% CALLED FUNCTIONS:
+%  processInput           = Initialize and validate input data and CACHE
+%    mads_defaults        =   Retrieves MADS parameter default settings
+%    checkErrors          =   Error check the input data
+%    createCache          =   Create and initialize the Cache
+%    createFilter         =   Create and initialize a filter
+%    makeFeasible         =   Convert infeasible starting point to feasible
+%  processOutput          = Process output and delete temporary files/variables
+%    plotHistory          =   Plot objective value vs number of function evals
+%    closeWorkspace       =   Close appdata and delete temporary files
+%  search                 = Perform MADS Search step
+%    lhs                  =   Perform Latin Hypercube Search on the MADS mesh
+%    ga                   =   Perform Genetic Algorithm
+%      setPenaltyTerm     =     Set penalty parameter for constrained problem
+%    recalSurrogate       =   Construct or recalibrate a surrogate
+%    optimizeSurrogate    =   Solve a surrogate optimization problem
+%  poll                   = Perform MADS Poll step
+%    standDirections      =   Retrieve standard mesh directions
+%      activeConstraints  =     Identify e-active (linear) constraints
+%      getTangentCone     =     Compute generators for the tangent cone
+%        removeRedundancy =       Remove redundant active constraints
+%      scaleDirections    =     Scale the directions used in the Poll step
+%    gradDirections       =   Retrieve gradient-pruned mesh directions
+%      dVector            =     Compute the appropriate descent direction
+%    madsDirections       =   Retrieve MADS mesh directions
+%    getPollOrder         =   Set the order in which iterates are polled
+%  mvpPoll                = Perform discrete neighbor and extended polling
+%    < User N >           =   User-defined problem discrete neighbor file
+%  update                 = Update MADS parameters and run statistics
+%    getPollCenter        =   Determine the next poll center
+%  updateOmega            = Update Omega and scale factors
+%    getScaleFactors      =   Compute scale factors, based on initial data
+%    < User O >           =   User-defined problem Omega file
+%  evalPointSet           = Evaluate functions at multiple trial points
+%    inOmega              =   Test if feasible w.r.t. linear constraints
+%    isCacheHit           =   Test if point is already in the Cache
+%    evalFunction         =   Evaluate problem functions at a given point
+%      < User F >         =     User-defined problem Function file
+%    updateCache          =   Update the Cache with the current iterate
+%    updateFilter         =   Update the filter and solutions vectors
+%      dominates          =     Tests if one iterate dominates another
+%      plotFilter         =     Update the current real-time filter plot
+%  evalRSPointSet         = Evalaute stochastic functions at multiple points
+%    RS                   =   Perform ranking and selection procedure
+%  terminate              = Tests if termination criteria are satisfied
+% ------------------------------------------------------------------------------
+% USER FUNCTION FILES needed for Optimization Problem: example
+%   example.m        = returns f(x,p), c(x,p), f'(x,p), c'(x,p)
+%   example_Omega.m  = returns A,l,u,plist, given parameter p
+%   example_x0.m     = returns initial iterate(s)
+%   example_N.m      = returns the set N of neighbor points 
+%   example_Param.m  = returns a structure Param of user parameters
+%   <Search file>    = optional function specifying Search procedure
+% ------------------------------------------------------------------------------
+% VARIABLES (only for the mads function):
+%  BestF        = final best feasible solution found
+%  BestI        = final least infeasible solution found
+%  RunData      = statistics measuring algorithm performance
+%    .delta     =   mesh size
+%    .nIter     =   cumulative number of iterations
+%    .nFunc     =   cumulative number of function evaluations
+%    .time      =   cumulative amount of CPU time expired
+%    .nFails    =   number of consecutive Poll failures
+%    .pcenter   =   current poll center
+%    .stopRun   =   flag for stopping run at the next iteration
+%  Cache        = structure containing previously evaluated iterates
+%    .Filter    =   structure containing filter data
+%  Problem      = structure containing optimization problem data
+%    .nameCache =   name of the base workspace Cache variable
+%    .isMVP     =   flag indicating a mixed variable problem
+%  iterate0     = initial iterate
+%  Options      = structure containing SEARCH and POLL parameters
+%    .Term      =   criteria for terminating the MADS function
+%  terminate    = inline function used to test stopping criteria
+%  success      = current iteration success or failure
+%*******************************************************************************
+
+% Set up and initialize inline termination function
+terminate = inline(['R.delta  <= T.delta  || R.nIter >= T.nIter || ', ...
+        'R.nFunc  >= T.nFunc  || R.time  >= T.time  || ', ...
+        'R.nFails >= T.nFails || R.stopRun'], 'T', 'R');
+
+% Initialize and verify validity of program variables
+[Problem,Options,RunData] = processInput(Problem,iterate0,varargin{:});
+tic;
+
+try
+    
+    % Main loop: Search, Poll, and Update parameters
+    while(~terminate(Options.Term,RunData))
+        Cache = getappdata(0,Problem.nameCache);
+        [success,TempFilter] = search(Problem,Options,RunData,Cache.Filter);
+        Cache = getappdata(0,Problem.nameCache);
+        Cache.Filter = TempFilter;
+        setappdata(0,Problem.nameCache,Cache);
+        if (~success)
+            [success,TempFilter,RunData] = poll(Problem,Options,RunData,...
+                RunData.pcenter,Cache.Filter);
+            Cache = getappdata(0,Problem.nameCache);
+            Cache.Filter = TempFilter;
+            setappdata(0,Problem.nameCache,Cache);
+        end
+        if (~success && Problem.isMVP)
+            success        = mvpPoll(Problem,Options,RunData);
+        end
+        [Problem,RunData] = update(Problem,Options,RunData,success);
+    end
+    [Cache,BestF,BestI] = processOutput(Problem,Options);
+    varargout = {Cache};
+catch
+    Cache = closeWorkspace(Problem);
+    varargout = {Cache};
+    rethrow(lasterror);
+end
+return;
+
+%*******************************************************************************
+% FUNCTIONS FOR PROCESSING INPUT DATA
+%*******************************************************************************
+%*******************************************************************************
+% processInput:  Initializes, validates, and processes input data
+% ------------------------------------------------------------------------------
+% Called by: mads
+% Calls:     madsDefaults, checkErrors,  updateOmega,   createCache,
+%            evalPointSet, makeFeasible, getPollCenter, update
+% VARIABLES:
+%  Problem          = structure containing optimization problem data
+%    .File          =   structure of file names
+%      .F           =     name of functions file
+%      .O           =     name of Omega file
+%      .N           =     name of discrete neighbor file
+%      .C           =     name of pre-existing Cache file
+%      .P           =     name of parameter file
+%    .nameCache     =   name of the base workspace Cache variable
+%    .fType         =   type of functions file (C=C, F=FORTRAN, M=MATLAB)
+%    .Omega         =   structure defining linear constraints l <=Ax <= u
+%    .iterate0      =   initial iterates
+%    .isMVP         =   flag indicating an MVP problem
+%    .adaptOmega    =   flag for updating an MVP's Omega parameters
+%    .maxNp         =   maximum number of categorical variables
+%    .maxNx         =   maximum number of continuous variables
+%    .maxNc         =   maximum number of nonlinear constraints
+%    .pollBasis     =   basis used to construct custom Poll directions
+%  Options          = structure of MADS parameters
+%    .tolBind       =   tolerance for flagging active linear constraints
+%    .pollStrategy  =   string code indicating choice of Poll strategy
+%    .pollOrder     =   string code indicating choice of Polling order
+%    .pollCenter    =   number of the filter point that is Poll center
+%    .delta0        =   initial mesh size
+%    .deltaMax      =   maximum mesh size
+%    .meshRefine    =   mesh refinement factor
+%    .meshCoarsen   =   mesh coarsening factor
+%    .hmin          =   minimum constraint violation of an infeasible point
+%    .hmax          =   maximum allowable constraint violation
+%    .Term          =   criteria for terminating the MADS function
+%      .delta       =     lowest allowed mesh size
+%      .nIter       =     maximum number of iterations
+%      .nFunc       =     maximum number of function calls
+%      .time        =     maximum allowable CPU time
+%      .nFails      =     maximum number of consecutive Poll failures
+%    .ePollTriggerF =   objective function extended poll trigger
+%    .ePollTriggerH =   constraint violation function extended poll trigger
+%    .nSearches     =   number of different SEARCH types to be used
+%    .Search(n)     =   structure containing parameters for each SEARCH
+%      .type        =     string code indicating choice of SEARCH strategy
+%      .label       =     long text label of SEARCH strategy
+%      .nIter       =     number of iterations to perform the SEARCH
+%      .nPoints     =     maximum number of points evaluated in SEARCH step
+%      .file        =     name of optional file containing the user SEARCH
+%    .computeGrad   =   flag for computing any available gradient
+%    .accelerate    =   flag for accelerating mesh refinement
+%    .useFilter     =   turns on/off the filter for nonlinear constraints
+%    .runStochastic =   flag to run as a stochastic optimization problem
+%    .plotFilter    =   turns on/off real-time filter plot
+%    .fplothandle   =   handle of the filter plot
+%    .loadCache     =   flag for loading Cache of iterates
+%  RunData          = structure of MADS run statistics and parameters
+%    .porder        =   fixed Poll order
+%    .scale         =   scale factors for scaling mesh directions
+%    .stopRun       =   flag for stopping MADS run immediately
+%  iterate0         = initial iterates
+%  Cache            = structure of all previously evaluated iterates
+%    .iterate       =   vector of all previously computed iterates
+%    .Filter        =   structure of filter data
+%      .plot        =     turns on/off filter plot
+%      .plothandle  =     handle for the axes of the plot
+%    .size          =   number of points in the Cache
+%  Defaults         = defaults for all MADS parameters
+%    .Options       =   Default values for Options
+%    .Types         =   list of strings corresponding to possible choices
+%      .poll        =     possible poll strategies
+%      .pollOrder   =   possible poll order strategies
+%  n0               = number of initial iterates
+%  ind              = index that identifies which error was flagged
+%  TempFilter       = used to reconstruct a filter from a previous run
+%    .plothandle    = temporary storage for Cache.Filter.plothandle
+%  Param            = user-defined parameters
+%    .maxNp         =   maximum number of categorical variables
+%    .maxNx         =   maximum number of continuous variables
+%    .pollBasis     =   basis used to construct custom Poll directions
+%    .pollOrder     =   fixed Poll order
+%  iterate          = initial iterate after being processed
+%*******************************************************************************
+function [Problem,Options,RunData] = processInput(Problem,iterate0,varargin)
+
+% Set Options, depending on the number of input arguments
+Defaults = mads_defaults('Truth');
+switch nargin
+    case {2}
+        Options = Defaults.Options;
+    case {3,4}
+        Options = deal(varargin{1});
+        Options.tolBind = Defaults.Options.tolBind;
+    otherwise
+        error('mads:input','Incorrect number of input arguments (processInput).');
+end
+
+% Process initial points into the proper format
+n0 = length(iterate0);
+if isstruct(iterate0(1))
+    [Problem.iterate0(1:n0).x] = deal(iterate0.x);
+    [Problem.iterate0(1:n0).p] = deal(iterate0.p);
+else
+    [Problem.iterate0(1:n0).x] = deal(iterate0);
+    [Problem.iterate0(1:n0).p] = deal({});
+end
+for k = 1:n0
+    Problem.iterate0(k).n = length(iterate0(k).x);
+end
+
+% Check input data for errors
+Problem.isMVP       = ~~exist(Problem.File.N,'file');
+Options.computeGrad = strncmpi(Options.pollStrategy,'Gradient',8);
+checkErrors(Problem,Options,Defaults.Types);
+
+% Add a bogus empty Search to the end of the list, for convenience
+if (Options.nSearches > 0)
+    Options.Search(end+1) = struct('type','None','label','None', ...
+        'nIter',Inf,'nPoints',0,'file','',...
+        'local',0,'merit',0);
+    Options.nSearches = Options.nSearches + 1;
+end
+
+% Adjust choices for specific Poll choices
+if (Options.computeGrad && Problem.fType == 'M' && ...
+        abs(nargout(Problem.File.F)) <= 2)
+    Options.computeGrad  = 0;
+    Options.pollStrategy = 'Standard_2n';
+    warning('Derivatives are not available; using standard 2n directions');
+end
+if strncmpi(Options.pollStrategy,'MADS',4)
+    Options.meshCoarsen = 4.0;
+    Options.meshRefine  = 0.25;
+    Options.accelerate  = 0;
+end
+
+% Change options if a filter is not used
+if (~Options.useFilter)
+    Options.pollCenter = 0;
+    Options.plotFilter = 0;
+    for k = 1:Options.nSearches
+        if (Options.Search(k).type(2) == 'P')
+            Options.Search(k).type = 'None';
+        end
+    end
+end
+
+% Clear any previous appdata
+if isappdata(0,Problem.nameCache)
+    rmappdata(0,Problem.nameCache);
+end
+if isappdata(0,'SUR')
+    rmappdata(0,'SUR');
+end
+
+% Initialize Cache or load a pre-existing one
+Cache = createCache(Options,Problem.File.C);
+setappdata(0,Problem.nameCache,Cache);
+
+%Initialize R&S Parameters
+if Options.runStochastic
+    RunData.RS           = Options.RS;
+    RunData.RS.iz        = RunData.RS.iz_const;
+    RunData.RS.alpha     = RunData.RS.alpha_const;
+    RunData.RS.F         = [];
+    RunData.RS.nFuncLeft = Options.Term.nFunc;
+else
+    RunData.RS = [];
+end
+
+% Set memory allocation variables and user-defined parameters
+Problem.maxNp = 2*length(Problem.iterate0(1).p);
+Problem.maxNx = (Problem.iterate0(1).n)*(2*Problem.isMVP + ~Problem.isMVP);
+if (exist(Problem.File.P,'file') == 2)
+    Param = feval(Problem.File.P);
+    setappdata(0,'PARAM',Param);
+    if (isfield(Param,'MaxNp')),     Problem.maxNp     = Param.maxNp; end
+    if (isfield(Param,'MaxNx')),     Problem.maxNx     = Param.maxNx; end
+    if (isfield(Param,'PollBasis')), Problem.pollBasis = Param.pollBasis; end
+    if (isfield(Param,'PollOrder')), RunData.porder    = Param.pollOrder; end
+end
+
+% Flag Custom Poll Order or Directions error
+if strncmp(Options.pollStrategy,'Custom',6) && ~isfield(Problem,'PollBasis')
+    error('mads:user','User-provided Poll Basis not found (processInput).');
+end
+if strcmp(Options.pollOrder,'Custom') && ~isfield(RunData,'porder')
+    error('mads:user','User-provided Poll Order not found (processInput).');
+end
+
+% Initialize Omega and process initial iterates
+[Problem.Omega,RunData.scale] = updateOmega(Problem,Options, ...
+    Problem.iterate0(1));
+if exist(Problem.File.O,'file')
+    Problem.adaptOmega = nargin(Problem.File.O) > 1;
+else
+    Problem.adaptOmega = 0;
+end
+
+% Process initial iterates
+[iterate,success,TempFilter,RunData.RS] = ...
+    evalPointSet(Problem,Problem.iterate0,1,Options,Cache.Filter,RunData.RS,2);
+Cache = getappdata(0,Problem.nameCache);
+Cache.Filter = TempFilter;
+setappdata(0,Problem.nameCache,Cache);
+
+% Create a valid Cache point if none exists
+if (~success || all(~isfinite([Cache.iterate(1:Cache.size).f])))
+    iterate = makeFeasible(Problem.iterate0(1),Problem.Omega);
+    [iterate,success,TempFilter,RunData.RS] = ...
+        evalPointSet(Problem,iterate,1,Options,Cache.Filter,RunData.RS,2);
+    Cache = getappdata(0,Problem.nameCache);
+    Cache.Filter = TempFilter;
+    setappdata(0,Problem.nameCache,Cache);
+end
+Problem.maxNc = length(iterate(1).c)*(2*Problem.isMVP + ~Problem.isMVP);
+
+% Initialize RunData parameters
+if (nargin >= 4)                      % For resuming previous run
+    RunData = varargin{2};
+    RunData.stopRun = 0;
+else
+    [Problem,RunData] = update(Problem,Options,RunData,-1);
+end
+
+return;
+
+%*******************************************************************************
+% checkErrors:  Check for errors in the input data.
+% ------------------------------------------------------------------------------
+% Called by: processInput
+% VARIABLES:
+%  Problem          = structure containing optimization problem data
+%    .File          =   structure of file names
+%      .F           =     name of functions file
+%      .O           =     name of Omega file
+%      .N           =     name of discrete neighbor file
+%      .C           =     name of pre-existing Cache file
+%      .P           =     name of parameter file
+%    .nameCache     =   name of the base workspace Cache variable
+%    .fType         =   type of functions file (C=C, F=FORTRAN, M=MATLAB)
+%    .Omega         =   structure defining linear constraints l <=Ax <= u
+%    .iterate0      =   initial iterates
+%    .isMVP         =   flag indicating an MVP problem
+%    .adaptOmega    =   flag for updating an MVP's Omega parameters
+%    .maxNp         =   maximum number of categorical variables
+%    .maxNx         =   maximum number of continuous variables
+%    .maxNc         =   maximum number of nonlinear constraints
+%    .pollBasis     =   basis used to construct custom Poll directions
+%  Options          = structure of MADS parameters
+%    .tolBind       =   tolerance for flagging active linear constraints
+%    .pollStrategy  =   string code indicating choice of Poll strategy
+%    .pollOrder     =   string code indicating choice of Polling order
+%    .pollCenter    =   number of the filter point that is Poll center
+%    .delta0        =   initial mesh size
+%    .deltaMax      =   maximum mesh size
+%    .meshRefine    =   mesh refinement factor
+%    .meshCoarsen   =   mesh coarsening factor
+%    .hmin          =   minimum constraint violation of an infeasible point
+%    .hmax          =   maximum allowable constraint violation
+%    .Term          =   criteria for terminating the MADS function
+%      .delta       =     lowest allowed mesh size
+%      .nIter       =     maximum number of iterations
+%      .nFunc       =     maximum number of function calls
+%      .time        =     maximum allowable CPU time
+%      .nFails      =     maximum number of consecutive Poll failures
+%    .ePollTriggerF =   objective function extended poll trigger
+%    .ePollTriggerH =   constraint violation function extended poll trigger
+%    .nSearches     =   number of different SEARCH types to be used
+%    .Search(n)     =   structure containing parameters for each SEARCH
+%      .type        =     string code indicating choice of SEARCH strategy
+%      .label       =     long text label of SEARCH strategy
+%      .nIter       =     number of iterations to perform the SEARCH
+%      .nPoints     =     maximum number of points evaluated in SEARCH step
+%      .file        =     name of optional file containing the user SEARCH
+%    .computeGrad   =   flag for computing any available gradient
+%    .accelerate    =   flag for accelerating mesh refinement
+%    .useFilter     =   turns on/off the filter for nonlinear constraints
+%    .plotFilter    =   turns on/off real-time filter plot
+%    .fplothandle   =   handle of the filter plot
+%    .loadCache     =   flag for loading Cache of iterates 
+%  indNone          = indices of Searches that are of type "None" 
+%  errorMsg         = cell array of error messages
+%  errorCheck       = vector of flags that track input data errors
+%*******************************************************************************
+function checkErrors(Problem,Options,Types)
+
+% Check input parameters for errors and display, if any
+errorMsg{1}  = 'Required Functions file not found';
+errorMsg{2}  = 'Required Omega file not found';
+errorMsg{3}  = 'Required discrete neighbors file not found';
+errorMsg{4}  = 'MVP initial iterate is missing categorical variables';
+errorMsg{5}  = 'Invalid choice of Search Method';
+errorMsg{6}  = 'Invalid choice of Poll Directions';
+errorMsg{7}  = 'Invalid choice of Polling Order';
+errorMsg{8}  = 'Invalid choice of Poll Center';
+errorMsg{9}  = 'Termination criteria must be positive numbers or infinity';
+errorMsg{10} = 'Termination criteria cannot all be infinite';
+errorMsg{11} = 'Initial Mesh Size must be a strictly positive number';
+errorMsg{12} = 'Maximum Mesh Size must be greater than Initial Mesh Size';
+errorMsg{13} = 'Mesh Refinement Factor must be a rational number in (0,1)';
+errorMsg{14} = 'Mesh Coarsening Factor must be a rational number > 1';
+errorMsg{15} = 'Min Filter Constraint Violation must be nonnegative';
+errorMsg{16} = 'Max Filter Constraint Violation must be positive';
+errorMsg{17} = 'Filter Constraint Violation Values must have Min < Max';
+errorMsg{18} = 'Extended Poll Triggers must be positive numbers';
+errorMsg{19} = 'Number of R&S samples must be positive';
+errorMsg{20} = 'Initial Indifference Zone parameter must be > 0';
+errorMsg{21} = 'Initial Alpha parameter must be a number in (0,1)';
+errorMsg{22} = 'R&S Decay Factors must be numbers in (0,1)';
+errorCheck(1) =~exist([Problem.File.F, '.', lower(Problem.fType)],'file');
+errorCheck(2) = exist(Problem.File.N,'file') && ~exist(Problem.File.O,'file');
+errorCheck(3) =~exist(Problem.File.N,'file') && ~isempty(Problem.iterate0(1).p);
+errorCheck(4) = exist(Problem.File.N,'file') &&  isempty(Problem.iterate0(1).p);
+errorCheck(5) = Options.nSearches > 0 && ...
+    any(~ismember({Options.Search(:).type}, Types.search));
+errorCheck(6)  = ~ismember(Options.pollStrategy, Types.poll);
+errorCheck(7)  = ~ismember(Options.pollOrder,    Types.pollOrder);
+errorCheck(8)  = ~isfinite(Options.pollCenter) || Options.pollCenter < 0;
+errorCheck(9)  = Options.Term.delta <= 0       || Options.Term.nIter <= 0 ...
+    || Options.Term.nFunc <= 0       || Options.Term.time  <= 0 ...
+    || isnan(Options.Term.delta)     || isnan(Options.Term.nIter) ...
+    || isnan(Options.Term.nFunc)     || isnan(Options.Term.time);
+errorCheck(10) = isinf(Options.Term.delta)     && isinf(Options.Term.nIter) ...
+    && isinf(Options.Term.nFunc)     && isinf(Options.Term.time);
+errorCheck(11) = ~isfinite(Options.delta0)     || Options.delta0 <= 0;
+errorCheck(12) = Options.delta0 > Options.deltaMax;
+errorCheck(13) = ~isfinite(Options.meshRefine) ...
+    || Options.meshRefine <= 0 || Options.meshRefine >= 1;
+errorChech(14) = ~isfinite(Options.meshCoarsen) || Options.meshCoarsen < 1;
+errorCheck(15) = ~isfinite(Options.hmin)        || Options.hmin <  0;
+errorCheck(16) = ~isfinite(Options.hmax)        || Options.hmax <= 0;
+errorCheck(17) = Options.hmax <= Options.hmin;
+errorCheck(18) = isnan(Options.ePollTriggerF)  || Options.ePollTriggerF <= 0 ...
+    || isnan(Options.ePollTriggerH)  || Options.ePollTriggerH <= 0;
+if Options.runStochastic
+    errorCheck(19) = ~isfinite(Options.RS.s0)       || Options.RS.s0 <= 0;
+    errorCheck(20) = ~isfinite(Options.RS.iz_const) || Options.RS.iz_const <= 0;
+    errorCheck(21) = ~isfinite(Options.RS.alpha_const) ...
+        || Options.RS.alpha_const <= 0 || Options.RS.alpha_const >= 1;
+    errorCheck(22) = ~isfinite(Options.RS.iz_rho) ...
+        || ~isfinite(Options.RS.alpha_rho) ...
+        || Options.RS.iz_rho <= 0  || Options.RS.alpha_rho <= 0 ...
+        || Options.RS.iz_rho >= 1  || Options.RS.alpha_rho >= 1;
+end
+ind = find(errorCheck);
+if ~isempty(ind),
+    error('mads:input',[errorMsg{ind(1)},' (checkErrors).']);
+end
+
+return
+
+%*******************************************************************************
+% createCache:  Create and initialize the Cache.
+% ------------------------------------------------------------------------------
+% Called by: processInput
+% Calls:     createFilter
+% VARIABLES:
+%  Cache            = structure containing a Cache of iterates
+%    .tol           =   tolerance for an iterate being in the cache
+%    .iterate       =   vector of iterates
+%      .n           =     size of the continuous variable space
+%      .x(nc)       =     values of continuous variables 
+%      .p(nd)       =     values of categorical variables
+%      .f           =     objective function value (f-value)
+%      .c(m)        =     constraint function values (c(x) <= 0)
+%      .h           =     constraint violation function value (h-value)
+%      .gradf(nc)   =     partial derivatives of f (if available)
+%      .gradc(m,nc) =     partial derivatives of c (if available)
+%      .gradh       =     partial derivatives of h (if available)
+%    .size          =   number of iterates
+%    .xnorm         =   vector of inf-norms of the iterates
+%    .pID           =   vector of unique IDs for categorical variables
+%    .isSurrPoint   =   vector of flags of points used in surrogate recal
+%    .bfp           =   vector of best cumulative feasible point f-values
+%    .lip           =   matrix of least infeasible point f- and h-values
+%    .nHits         =   number of Cache hits
+%    .Filter        =   structure containing filter data
+%  Options          = structure containing SEARCH and POLL parameters
+%    .computeGrad   =   logical indicating gradients are to be computed
+%    .hmin          =   minimum constraint violation of an infeasible point
+%    .hmax          =   maximum allowable constraint violation
+%    .plotFilter    =   logical for plotting real-time filter
+%    .fplothandle   =   handle for the real-time filter plot
+%    .tolCache      =   tolerance for a point to be a Cache point
+%    .CacheFile     =   name of file containing a pre-existing Cache
+%*******************************************************************************
+function Cache = createCache(Options,CacheFile)
+
+% A Cache file exists and will be used
+if (Options.loadCache && exist(CacheFile,'file'))
+    load(CacheFile,'Cache');
+    TempFilter = createFilter(0.1,1,0,1,Options.fplothandle);
+    Cache.Filter.plothandle = TempFilter.plothandle;
+    if (Cache.Filter.plot)
+        plotFilter(Cache.Filter,Cache.Filter.hmax,Cache.iterate,10);
+    end
+    
+    % A new Cache is constructed
+else
+    Cache = [];
+    Cache.tol                 = Options.tolCache;
+    Cache.iterate(1).x        = [];
+    Cache.iterate(1).p        = {};
+    Cache.iterate(1).n        = 0;
+    Cache.iterate(1).f        = [];
+    Cache.iterate(1).c        = [];
+    Cache.iterate(1).h        = [];
+    if (Options.computeGrad)
+        Cache.iterate(1).gradf = [];
+        Cache.iterate(1).gradc = [];
+        Cache.iterate(1).gradh = [];
+    end
+    Cache.size                = 0;
+    Cache.xnorm               = [];
+    Cache.pID                 = [];
+    Cache.isSurrPoint         = [];
+    Cache.nFunc               = [];
+    Cache.bfp                 = [];
+    Cache.lip                 = [];
+    Cache.nHits               = 0;
+    Cache.iterate(1)          = [];            % This is a key statement!
+    Cache.Filter = createFilter(Options.hmin,Options.hmax,0,...
+        Options.plotFilter,Options.fplothandle);
+end
+return
+
+%*******************************************************************************
+% createFilter:  Create and initialize a filter.
+% ------------------------------------------------------------------------------
+% Called by: processInput, mvpPoll
+% VARIABLES:
+%  Filter        = structure containing the filter
+%    .feasible   =   indices of feasible iterates, sorted by f-value
+%    .F          =   indices of iterates in the filter, sorted by h-value
+%    .hmin       =   minimum allowable h-value to be in Filter.F
+%    .hmax       =   maximum allowable h-value to be in Filter.F
+%    .strict     =   flag indicating that hmax is strictly enforced
+%    .plot       =   flag for plotting real-time filter
+%    .plothandle =   handle of the real-time filter plot
+%  hmin          =   input value for Filter.hmin
+%  hmax          =   input value for Filter.hmax
+%  strict        =   input value for Filter.strict
+%  plot          =   input value for Filter.plot
+%  plothandle    =   input value for Filter.plothandle
+%*******************************************************************************
+function Filter   = createFilter(hmin,hmax,strict,fplot,plothandle)
+if (hmin >= hmax)
+    error('mads:filter',['Attempt to create filter with ',...
+            'incompatible hmin/hmax (createFilter).']);
+end
+Filter.hmin       = hmin;
+Filter.hmax       = hmax;
+Filter.strict     = strict;
+Filter.plot       = fplot;
+Filter.F          = [];
+Filter.feasible   = [];
+if (isempty(plothandle) && fplot)
+    figure; plothandle = gca;
+    set([plothandle; get(plothandle,'Children')],'Visible','off');
+end
+Filter.plothandle = plothandle;
+return
+
+%*******************************************************************************
+% makeFeasible:  Projects an infeasible iterate (w.r.t. Omega) into Omega.
+% ------------------------------------------------------------------------------
+% Called by: processInput
+% Calls:     inOmega
+% VARIABLES:
+%  iterate    = current iterate that will be made feasible
+%    .x       =   continuous variables
+%    .p       =   categorical variables
+%  Omega      = structure defining linear constraints, l <= A*x <= u
+%    .A       =   matrix of linear coefficients
+%    .l       =   vector of lower bounds
+%    .u       =   vector of upper bounds
+%    .plist   =   list of allowable discrete variable values
+%  pass       = flag indicating if categorical variables are feasible
+%  [m,n]      = dimensions of linear constraint matrix Omega.A
+%  ind        = indices of infeasible lower and upper bounds
+%  c,A,b      = matrices that define the LP, min {c'x: Ax <= b}
+%  OptOptions = structure used in LP solver to set optimization options
+%  dist       = closest distance of iterate to Omega
+%  err        = error flag for LP solver
+%*******************************************************************************
+function iterate = makeFeasible(iterate,Omega)
+
+% Adjust categorical variables
+for k = 1:length(iterate.p)
+    if (ischar(iterate.p{k}))
+        pass = any(strcmp(iterate.p{k},Omega.plist{k}));
+    else
+        pass = ~isempty(find([Omega.plist{k}{:}] == iterate.p{k},1));
+    end
+    if (~pass)
+        iterate.p{k} = Omega.plist{k}{1};
+    end
+end
+
+% Adjust bounds if necessary
+[m,n] = size(Omega.A);
+if n <= m && all(all(Omega.A(1:n,:) == eye(n)))
+    ind = find(iterate.x - Omega.l(1:n) < 0.0);
+    iterate.x(ind) = deal(Omega.l(ind));
+    ind = find(iterate.x - Omega.u(1:n) > 0.0);
+    iterate.x(ind) = deal(Omega.u(ind));
+    if inOmega(iterate,Omega), return; end
+end
+
+% Set up linear program and remove non-finite rows
+c = [zeros(n,1); 1];
+b = [iterate.x; -iterate.x; Omega.u; -Omega.l];
+A = [ eye(n) ,  -ones(n,1); ...
+        -eye(n) ,  -ones(n,1); ...
+        Omega.A,  zeros(m,1); ...
+        -Omega.A,  zeros(m,1)];
+ind      = find(~isfinite(b));
+b(ind)   = [];
+A(ind,:) = [];
+
+% Solve LP and assess if new iterate is feasible
+[iterate.x,dist,err] = linprog(c,A,b,[],[],[],[],[],optimset('Display','off'));
+iterate.x(end) = [];
+if (err <= 0)
+    error('mads:initialPoint',['MADS unable to find feasible initial point ', ...
+            '(MakeFeasible).']);
+end
+return;
+
+%*******************************************************************************
+% FUNCTIONS CALLED BY MADS MAIN LOOP
+%*******************************************************************************
+%*******************************************************************************
+% search:  Performs the SEARCH step of the MADS/GPS algorithm.
+%          A finite number of points are evaluated according to the k-th Search
+%          strategy set by the variable Search(k).Type. (Default: no search)
+% ------------------------------------------------------------------------------
+% Called by: mads
+% Calls:     lhs, ga, recalSurrogate, optimizeSurrogate, evalPointSet, poll, 
+%            standDirections, updateOmega, gridsamp (DACE)
+% VARIABLES:
+%  success         = flag indicating success or failure of Poll step
+%  Filter          = structure of filter data
+%    .F            =   indices of Cache points in the filter
+%  Problem         = structure of optimization problem data
+%    .nameCache    =   name of the base workspace Cache variable
+%    .Omega        =   structure defining linear constraints
+%      .plist      =     list of allowable discrete variable values
+%    .isMVP        =   flag indicating an MVP problem
+%    .adaptOmega   =   flag for updating an MVP's Omega parameters
+%  Options         = structure of MADS parameters
+%    .pollComplete =   turns on/off evaluation of ALL Poll points
+%    .computeGrad  =   flag for computing any available gradients
+%    .SurOptimizer =   string containing name of surrogate optimizer
+%    .Search       =   vector of structures of Search data
+%    .nSearches    =   number fo different Searches used during run
+%    .pollStrategy =   string identifying selected Poll strategy
+%    .pollComplete =   flag for performing a complete Poll step
+%  RunData         = structure of run statistics and parameters
+%    .scale        =   scale factors for scaling of mesh directions
+%    .pcenter      =   current Poll center
+%      .n          =     number of continuous variables
+%    .delta        =   mesh size parameter
+%    .nIter        =   iteration count
+%  Cache           = structure containing of data on all past iterates
+%    .iterate      =   vector of previously processed iterates
+%    .size         =   number of iterates in Cache
+%    .tol          =   tolerance for determining if a point is in Cache
+%  full            = temporary storage of Options.pollComplete
+%  grad            = temporary storage of Options.computeGrad
+%  optimizer       = temporary storage of Options.SurOptimizer
+%  Cache           = temporary storage of Cache.iterate
+%  tol             = temporary storage of Cache.tol
+%  Search          = structure of Search data 
+%    .type         =   string indicating which search method to use
+%    .nIter        =   number of iterations to perform Search
+%    .nPoints      =   number of search points to be evaluated
+%    .file         =   optional name of user-defined Search file
+%    .dace         =   structure of DACE surrogate data
+%      .reg        =     regression function handle
+%      .corr       =     correlation function handle
+%      .theta      =     correlation function parameter
+%      .isotropic  =     flag indicating isotropic (all equal) theta values
+%    .nw           =   structure of NW surrogate data
+%      .kernel     =     name of NW kernel function
+%      .local      =     flag indicating if surrogate is restricted to a region
+%  surrogate       =   structure of surrogate data
+%    .recalibrator =     surrogate recalibration function filename
+%    .evaluatror   =     surrogate evaluation function filename
+%  pcenter         = temporary poll center
+%  D               = Mesh directions used in LHS
+%  S               = Search points to be evaluated
+%  N               = discrete neighbors of LHS points
+%  q               = number of mesh points in each direction
+%  LB,UB           = lower/upper bounds on continuous variables
+%  meshPoints      = mesh points for coarse mesh point evaluations
+%  param           = cell array of parameters output from user surrogate file.
+%*******************************************************************************
+function [success,Filter] = search(Problem,Options,RunData,Filter)
+
+Cache = getappdata(0,Problem.nameCache);
+success = 0;
+
+% Shortcuts
+full      = Options.pollComplete;
+grad      = Options.computeGrad;
+optimizer = Options.SurOptimizer;
+tol       = Cache.tol;
+
+% Include only iterates with the same categorical variable values (John Dunlap)
+if (Problem.isMVP)
+    pID = getpID(RunData.pcenter.p,Problem.Omega.plist);
+    ind = find(Cache.pID == pID);
+    Cache.iterate     = Cache.iterate(ind);
+    Cache.isSurrPoint = Cache.isSurrPoint(ind);
+end
+ind   = find(Cache.isSurrPoint);  
+Cache = Cache.iterate(ind);
+
+% Identify which Search will be performed
+if isempty(Options.Search), return, end
+Search      = Options.Search(1);
+Search.dace = Options.dace(1);
+Search.nw   = Options.nw(1);
+for k = 2:Options.nSearches
+    if (RunData.nIter >= sum([Options.Search(1:k-1).nIter]))
+        Search      = Options.Search(k);
+        Search.dace = Options.dace(k);
+        Search.nw   = Options.nw(k);
+    end
+end
+
+% Change Surrogate to LHS if Cache is empty
+if length(Cache) <= 1
+    switch upper(Search.type)
+        case {'DACE','NW','CUSTOMS'}
+            Search.type = 'LHS';
+            Search.nIter = 1;
+            Search.nPoints = 2*RunData.pcenter.n;
+            Search.file = '';
+    end 
+end
+
+% Initialize variables for DACE, NW, or Custom surrogates
+surrogate = [];
+if isappdata(0,'SUR'), surrogate = getappdata(0,'SUR'); end
+
+% Call appropriate Search functions
+switch upper(Search.type)
+    
+    % Do nothing
+    case {'NONE'}
+        return
+        
+        % Poll around best n filter points
+    case {'SPOLLI','CPOLLI','GPOLLI'}
+        Options.pollStrategy = 'Standard_2n';
+        if strcmp(Search.type,'CPollI')
+            Options.pollComplete = 1;
+        end
+        if strcmp(Search.type,'GPollI') && Options.computeGrad
+            Options.pollStrategy = 'Gradient_3n_L2';
+        end
+        for k = 1:min(length(Filter.F),Search.nPoints)
+            pcenter = Cache(Filter.F(k));
+            if (Problem.adaptOmega)
+                [Problem.Omega,RunData.scale] = updateOmega(Problem,Options,pcenter);
+            end
+            [success,Filter] = poll(Problem,Options,RunData,pcenter,Filter);
+            if (success), break, end
+        end
+        return
+        
+        % Latin Hypercube Search on the mesh
+    case 'LHS'
+        n = RunData.pcenter.n;
+        Options.removeRedundancy = 0;
+        [Problem.Omega,RunData.scale] = updateOmega(Problem,Options,RunData.pcenter);
+        scale = min(RunData.scale,RunData.scale/norm(RunData.scale,inf));
+        sdelta = RunData.delta * scale;
+        LB = fix((Problem.Omega.l(1:n) - RunData.pcenter.x)./sdelta);
+        UB = fix((Problem.Omega.u(1:n) - RunData.pcenter.x)./sdelta);
+        maxrand = 2^5;
+        LB(LB < -maxrand) = -maxrand/2;
+        UB(UB >  maxrand) =  maxrand/2;
+        z = lhs(UB-LB+1,Search.nPoints,2);
+        S = [];
+        if ~isempty(z)
+            z = z + repmat(LB,1,size(z,2));
+            for k = 1:size(z,2)
+                S(k).x = RunData.pcenter.x + sdelta.*z(:,k);
+                S(k).p = RunData.pcenter.p;
+            end
+        end
+        full = (RunData.nIter == 0);
+        
+        % Deterministic Sampling on a Coarse Mesh (requires DACE package)
+    case 'MESH'
+        n  = RunData.pcenter.n;
+        q  = ceil(Search.nPoints^(1/n));
+        Options.removeRedundancy = 0;
+        [Problem.Omega,RunData.scale] = updateOmega(Problem,Options,RunData.pcenter);
+        LB = Problem.Omega.l(1:n)';
+        UB = Problem.Omega.u(1:n)';
+        LB(~isfinite(LB)) = -1e+16;
+        UB(~isfinite(UB)) =  1e+16;
+        meshPoints = gridsamp([LB;UB],q);
+        for k = 1:size(meshPoints,1)
+            S(k).x = meshPoints(k,:)';
+            S(k).p = RunData.pcenter.p;
+        end
+        
+        % Genetic Algorithm
+    case 'GA'
+        Options.removeRedundancy = 0;
+        [Problem.Omega,RunData.scale] = updateOmega(Problem,Options,RunData.pcenter);
+        S = ga(Problem,Options,Search.nPoints,RunData,Cache,Filter);
+        
+        % DACE Surrogate
+    case 'DACE'
+        surrogate.recalibrator = 'dacefit';
+        surrogate.evaluator    = 'predictor';
+        if Search.merit
+            Search.merit = Search.merit/(2^RunData.nIter);
+        end
+        surrogate.merit = Search.merit;
+        surrogate.local = Search.local;
+        reg  = str2func(Search.dace.reg);
+        corr = str2func(Search.dace.corr);
+        if (Search.dace.isotropic)
+            n = strcmp(Search.dace.corr,'correxpg') + 1;
+        else
+            n = strcmp(Search.dace.corr,'correxpg') + Cache(end).n;
+        end
+        theta = ones(n,1)*Search.dace.theta;
+        surrogate = recalSurrogate(Cache,surrogate,optimizer,Filter,reg,corr,theta);
+        S = optimizeSurrogate(Problem,RunData.pcenter,surrogate,optimizer, ...
+            Search.nPoints,tol);
+        
+        % Nadaraya-Watson Surrogate
+    case 'NW'
+        surrogate.recalibrator = 'buildNW';
+        surrogate.evaluator    = 'evalNW';
+        if Search.merit
+            Search.merit = Search.merit/(2^RunData.nIter);
+        end
+        surrogate.merit = Search.merit;
+        surrogate.local = Search.local;
+        surrogate = recalSurrogate(Cache,surrogate,optimizer,Filter, ...
+            Search.nw.kernel,Search.nw.sigma, ...
+            Search.nw.lower, Search.nw.upper);
+        S = optimizeSurrogate(Problem,RunData.pcenter,surrogate,optimizer, ...
+            Search.nPoints,tol);
+        
+        % Custom surrogate method
+    case 'CUSTOMS'
+        if (~exist(Search.file,'file'))
+            error('mads:search:file',[Search.file '.m not found (search).']);
+        end
+        if upper(strcmp(optimizer,'CUSTOM'))
+            S = feval(Search.file,Problem,Cache,Search,surrogate,tol);
+        else
+            if Search.merit
+                Search.merit = Search.merit/(2^RunData.nIter);
+            end
+            surrogate.merit   = Search.merit;
+            surrogate.local   = Search.local;
+            [surrogate,param] = feval(Search.file);
+            surrogate = recalSurrogate(Cache,surrogate,optimizer,Filter,param{:});
+            S = optimizeSurrogate(Problem,RunData.pcenter,surrogate,optimizer, ...
+                Search.nPoints,tol);
+        end
+        
+        % Custom Search method
+    case 'CUSTOM'
+        if (~exist(Search.file,'file'))
+            error('mads:search:file',[Search.file '.m not found (search).']);
+        end
+        S = feval(Search.file,Problem,Options,RunData.delta,RunData.pcenter);
+        
+        % Invalid Search option
+    otherwise
+        S = [];
+        error('mads:search:choice','Invalid choice of Search Method (search).');
+end
+
+[S,success,Filter,RunData.RS] = evalPointSet(Problem,S,full,Options,Filter, ...
+    RunData.RS,2);
+return;
+
+%*******************************************************************************
+% poll: Performs the POLL step of the MADS algorithm.  Given a Poll center, a
+%       set of Poll direction vectors, and a mesh size parameter, the
+%       neighboring mesh points are evaluated, seeking an improved mesh point.
+% ------------------------------------------------------------------------------
+% Called by: mads, Search, mvpPoll
+% Calls:     standDirections, gradDirections, getPollOrder, evalPointSet
+% VARIABLES:
+%  success         = flag indicating success or failure of Poll step
+%  Filter          = structure describing the filter
+%  Problem         = structure describing the optimization problem
+%    .Omega        =   structure defining Omega = {x: l <= A*x <= u}
+%    .adaptOmega   =   flag for updating an MVP's Omega parameters
+%  Options         = structure containing various MADS parameters
+%    .computeGrad  =   flag for computing any available gradients
+%    .pollStrategy =   string identifying selected Poll strategy
+%    .pollOrder    =   string identifying selected Poll order strategy
+%    .pollComplete =   flag for performing a complete Poll step
+%    .tolBind      =   active constraint tolerance
+%  RunData         = structure of run statistics and parameters
+%    .scale        =   scale factors for scaling mesh directions
+%    .delta        =   mesh size parameter
+%    .goodD        =   index of successful Poll direction
+%    .porder       =   current poll order
+%  pcenter         = center of Poll set, around which Poll is performed
+%    .x            =   continuous variables
+%    .p            =   categorical variables
+%    .h            =   constraint violation function value
+%    .gradf        =   gradient of f
+%    .gradh        =   gradient of h
+%  D               = matrix whose columns form the direction vectors
+%  g               = gradient direction with which to prune
+%  infGrad         = indices of non-finite partial derivatives
+%  donef           = indices of zero partial derivatives of f
+%  doneh           = indices of zero partial derivatives of h
+%  surrogate       = structure of surrogate model data
+%  order           = order in which directions will be polled
+%  P               = The Poll set
+%*******************************************************************************
+function [success,Filter,varargout] = poll(Problem,Options,RunData,pcenter, ...
+    Filter)
+
+% A gradient poll without gradients available becomes a standard poll
+if (Options.computeGrad && ~isfield(pcenter, 'gradf'))
+    Options.pollStrategy = 'Standard_2n';
+end
+
+% Retrieve scaled Poll directions
+switch Options.pollStrategy
+    case {'Standard_2n','Standard_n+1','Custom_2n','Custom_n+1'}
+        D = standDirections(pcenter.x,Problem.Omega,Options.pollStrategy, ...
+            Options.tolBind,RunData.scale);
+    case {'MADS_2n','MADS_n+1'}
+        D = madsDirections(pcenter.x,Options.pollStrategy,RunData.delta, ...
+            RunData.scale);
+    case {'Gradient_2n','Gradient_n+1'}
+        D = standDirections(pcenter.x,Problem.Omega,Options.pollStrategy, ...
+            Options.tolBind,RunData.scale);
+        if (pcenter.h == 0)
+            g = pcenter.gradf;
+        else
+            g = pcenter.gradh;
+        end
+        infGrad = ~isfinite(g);
+        g(infGrad) = 0;
+        D(:,(infGrad'*D == 0 & g'*D > 0.0)) = [];
+    case {'Gradient_3n_L1','Gradient_3n_L2','Gradient_3n_LInf','Gradient_3n2n'}
+        D = [];
+        donef = all(pcenter.gradf == 0.0);
+        doneh = (isempty(pcenter.gradh) || all(pcenter.gradh) == 0.0);
+        if ~(donef && doneh)
+            D = gradDirections(pcenter,Problem.Omega,Options.pollStrategy,Filter, ...
+                RunData.delta,Options.tolBind,RunData.scale);
+        end
+    otherwise
+        error('mads:poll:choice','Invalid Poll strategy type (poll).');
+end
+
+% Construct the POLL set
+P = [];
+for k = 1:size(D,2)
+    P(k).x = pcenter.x + RunData.delta*D(:,k);
+    P(k).p = pcenter.p;
+end
+
+% Get surrogate information for setting surrogate Poll order
+surrogate = [];
+if isappdata(0,'SUR')
+    surrogate = getappdata(0,'SUR');
+end
+if strcmp(Options.pollOrder,'Surrogate') && isempty(surrogate)
+    Options.pollOrder = 'DynamicRanked';
+end
+
+% Set the polling order, and evaluate the POLL points
+order = getPollOrder(Options.pollOrder,D,P,RunData,surrogate);
+P = P(order);
+
+Problem.adaptOmega = 0;
+[P,success,Filter,RunData.RS] = evalPointSet(Problem,P,Options.pollComplete, ...
+    Options,Filter,RunData.RS,1);
+
+% Update parameters need for dynamic poll ordering
+if (success)
+    RunData.goodD  = D(:,success);
+    RunData.porder = order;
+    success = 1;
+end
+varargout = {RunData};
+return;
+
+%*******************************************************************************
+% mvpPoll:  Performs discrete neighbor and extended polls for MVP problems.
+% ------------------------------------------------------------------------------
+% Called by: mads
+% Calls:     evalPointSet, poll, getPollCenter, createFilter, updateOmega
+% VARIABLES:
+%  success         = flag indicating success or failure of MVP Poll step
+%  Problem         = structure describing the optimization problem
+%    .nameCache    =   name of the base workspace Cache variable
+%    .File.N       =   name of discrete neighbor file
+%    .Omega        =   structure defining linear constraints
+%      .plist      =     list of allowable discrete variable values
+%    .adaptOmega   =   flag for updating an MVP's Omega parameters
+%  Options         = structure containing various MADS parameters
+%    .pollComplete =   flag for performing a complete Poll step
+%    .pollCenter   =   code for identifying the Poll center
+%  RunData         = structure containing MADS run statistics
+%    .delta        =   current mesh size
+%    .pcenter      =   current Poll center
+%    .fxi          =   f-value threshold for triggering Extended Poll
+%    .scale        =   scale factors for scaling of mesh directions
+%  Cache           = database of all previously computed iterates
+%    .Filter       =   structure of parameters describing the main filter
+%      .hmin       =     minimum h-value of an infeasible point
+%      .hmax       =     maximum allowable h-value
+%  N               = discrete neighbors of the current poll center
+%    .f            =   objective function value
+%    .h            =   constraint violation function value
+%  BestF           = best feasible iterate
+%    .f            =   objective function value
+%  BestI           = least infeasible iterate
+%    .h            =   constraint violation function value
+%  fplusxi         = BestF.f + RunData.fxi
+%  hplusxi         = BestF.h + RunData.hxi (or hmax if this is too large)
+%  ePollF          = indices of N triggering Extended Poll due to f
+%  ePollH          = indices of N triggering Extended Poll due to h
+%  ePoll           = indices of N triggering Extended Poll due to f or h
+%  new             = temporary storage
+%  order           = sorted index for N by f-value or h-value
+%  pcenter         = current Extended Poll center
+%  nx              = number of continuous variables in pcenter
+%  Filter          = structure describing the temporary local filter
+%  ePsuccess       = flag indicating a successful Extended Poll step
+%  unfiltered      = flag indicating an unfiltered point has been found
+%*******************************************************************************
+function success = mvpPoll(Problem,Options,RunData)
+
+% Retrieve set of discrete neighbors
+N = feval(Problem.File.N,Problem,RunData.pcenter,Problem.Omega.plist, ...
+    RunData.delta);
+if isempty(N)
+    success = 0;
+    return;
+end
+
+% Evaluate set of discrete neighbors
+Cache = getappdata(0,Problem.nameCache);
+[N,success,TempFilter,RunData.RS] = evalPointSet(Problem,N,1,Options, ...
+    Cache.Filter,RunData.RS,1);
+Cache = getappdata(0,Problem.nameCache);
+Cache.Filter = TempFilter;
+setappdata(0,Problem.nameCache,Cache);
+N = N(find(~isempty([N.f])));
+success = ~~success;
+
+% If unsuccessful, begin extended poll around "good" discrete neighbors
+if (~success)
+    
+    % Determine candidate poll centers for extended polling
+    BestF = getPollCenter(0,Cache.Filter,Cache);
+    BestI = getPollCenter(1,Cache.Filter,Cache);
+    fplusxi = BestF.f + RunData.fxi;
+    hplusxi = min(BestI.h + RunData.hxi,Cache.Filter.hmax);
+    ePollF = find([N.h] <  Options.hmin & [N.f] < fplusxi);
+    ePollH = find([N.h] >= Options.hmin & [N.h] < hplusxi);
+    
+    % Determine the order in which extended poll centers get polled around
+    if (~isempty(ePollF))
+        [new,order] = sort(N(ePollF).f);
+        ePollF = ePollF(order);
+    end
+    if (~isempty(ePollH))
+        [new,order] = sort(N(ePollH).h);
+        ePollH = ePollH(order);
+    end
+    if (RunData.pcenter.h < Cache.Filter.hmin)
+        ePoll = [ePollF, ePollH];
+    else
+        ePoll = [ePollH, ePollF];
+    end
+    
+    % Search/Poll around each selected discrete neighbor using local filter
+    for k = 1:length(ePoll)
+        
+        % Create MVP filter and populate it with the discrete neighbor
+        pcenter = N(ePoll(k));
+        Filter = createFilter(Options.hmin,hplusxi,1,0,[]);
+        [unfiltered,Filter] = updateFilter(pcenter,Filter,Cache);      
+        if (Problem.adaptOmega)
+            [Problem.Omega,RunData.scale] = updateOmega(Problem,Options,pcenter);
+        end
+        
+        % Begin EXTENDED SEARCH step using same Search type is in the SEARCH step
+        TempRunData = RunData;
+        TempRunData.pcenter = pcenter;
+        TempOptions = Options;
+        for j = 1:Options.nSearches
+            TempOptions.Search(j) = Options.Search(j);
+        end
+        Cache        = getappdata(0,Problem.nameCache);
+        startCache   = Cache.size + 1;
+        [success,TempFilter] = search(Problem,TempOptions,TempRunData, ...
+            Cache.Filter);
+        Cache        = getappdata(0,Problem.nameCache);
+        endCache     = Cache.size;
+        Cache.Filter = TempFilter;
+        setappdata(0,Problem.nameCache,Cache);
+        
+        % If EXTENDED SEARCH was unsuccessful, test versus local filter      
+        if (~success)
+            for j = startCache:endCache
+                [unfiltered,Filter] = updateFilter(Cache.iterate(j),Filter,Cache);
+            end
+            pcenter = getPollCenter(Options.pollCenter,Filter,Cache);
+        end
+        
+        % Begin EXTENDED POLL
+        while (~success)
+            startCache = Cache.size + 1;
+            [ePsuccess,Filter] = poll(Problem,Options,RunData,pcenter,Filter);
+            Cache = getappdata(0,Problem.nameCache);
+            endCache = Cache.size;
+            
+            % If Extended Poll was unsuccessful, try next discrete neighbor
+            if (~ePsuccess), break; end
+            
+            % If Extended Poll step was successful, determine new incumbent
+            if (Options.pollComplete)
+                for j = startCache:endCache
+                    iterate = Cache.iterate(j);
+                    [unfiltered,TempFilter] = updateFilter(iterate,Cache.Filter,Cache);
+                    if (unfiltered)
+                        success = j;
+                        Cache.isSurrPoint(j) = 1;
+                    end
+                    Cache.Filter = TempFilter;
+                    setappdata(0,Problem.nameCache,Cache);
+                end
+            else
+                [iterate,iCache] = getPollCenter(Options.pollCenter,Filter,Cache);
+                if Options.runStochastic, Cache.size = iCache; end
+                [unfiltered,TempFilter] = updateFilter(iterate,Cache.Filter,Cache);
+                if (unfiltered)
+                    success = k;
+                    Cache.isSurrPoint(iCache) = 1;
+                end
+                Cache.Filter = TempFilter;
+                setappdata(0,Problem.nameCache,Cache);
+            end
+        end
+        if (success && ~Options.pollComplete), break; end
+    end
+end
+return
+
+%*******************************************************************************
+% update:  Updates MADS run parameters.
+% ------------------------------------------------------------------------------
+% Called by: mads, processInput
+% Calls:     getPollCenter, updateOmega, plotHistory
+% VARIABLES:
+%  Problem             = structure defining optimization problem
+%    .nameCache        =   name of the base workspace Cache variable
+%    .Omega            =   structure defining linear constraints
+%    .isMVP            =   flag indicating an MVP problem
+%    .adaptOmega       =   flag for updating an MVP's Omega parameters
+%  RunData             = structure holding MADS run statistics
+%    .delta            =   current mesh size
+%    .nIter            =   iteration count
+%    .nFunc            =   cumulative number of function evaluations
+%    .grad             =   cumulative number of gradient evaluations
+%    .time             =   cumulative CPU time used
+%    .nFails           =   current count of consecutive Poll failures
+%    .nCacheHits       =   cumulative number of Cache hits
+%    .nFunc0           =   function evaluations during initialization
+%    .pcenter          =   current poll center
+%    .fxi              =   f-value threshold for triggering Extended Poll
+%    .hxi              =   h-value threshold for triggering Extended Poll
+%    .goodD            =   index of the most recent successful direction
+%    .stopRun          =   flag for stopping run immediately
+%    .scale            =   scale factors for each continuous variable
+%  Options             = structure holding MADS parameters
+%    .computeGrad      =   flag for computing any available gradients
+%    .countCache    =   flag for counting Cache points as function calls
+%    .delta0           =   initial mesh size
+%    .deltaMax         =   maximum mesh size 
+%    .meshRefine       =   mesh size refinement factor
+%    .meshCoarsen      =   mesh size coarsening factor
+%    .accelerate       =   flag for decreasing the mesh refinement factor
+%    .ePollTriggerF    =   f-value trigger for executing extended POLL
+%    .ePollTriggerH    =   h-value trigger for executing extended POLL
+%    .pollCenter       =   code indicating which poll center to select
+%    .plotHistory2     =   turns on/off plot of f-value vs. #f-evals
+%    .plotColor        =   string indicating color of history plot line
+%    .stophandle       =   handle for external object that terminates run
+%    .runUntilFeasible =   flag for running MADS only until feasible
+%    .runOneIteration  =   flag for running MADS one iteration at a time
+%  success             = flag indicating iteration successful/failure
+%  Cache               = database of all previously computed iterates
+%    .size             =   number of iterates currently in the Cache
+%    .nHits            =   number of Cache hits
+%  Filter              = structure containing filter data
+%    .hmax             =   maximum allowable constraint violation h-value
+%    .feasible         =   indices of best feasible points in the Cache
+%  meshScaleFactor     = factor for increasing or decreasing mesh size
+%  BestF               = best feasible iterate found thus far
+%*******************************************************************************
+function [Problem,RunData] = update(Problem,Options,RunData,success)
+
+Cache = getappdata(0,Problem.nameCache);
+
+% Update run statistics for either initial or non-initial iterates
+if (success < 0)
+    RunData.delta       = Options.delta0;
+    RunData.nIter       = 0;
+    RunData.nFunc0      = (~Options.countCache)*Cache.size;
+    RunData.nFunc       = 0;
+    RunData.grad        = Options.computeGrad;
+    RunData.time        = 0;
+    RunData.nFails      = 0;
+    RunData.meshRefine  = Options.meshRefine;
+    RunData.meshCoarsen = Options.meshCoarsen;
+    RunData.hxi         = Options.ePollTriggerH*Cache.Filter.hmax;
+else
+    meshScaleFactor    = ~~success*RunData.meshCoarsen + ...
+        ~success*RunData.meshRefine;
+    RunData.delta      = min(meshScaleFactor*RunData.delta, Options.deltaMax);
+    RunData.nIter      = RunData.nIter + 1;
+    RunData.nFunc      = sum(Cache.nFunc(1:Cache.size)) - RunData.nFunc0;
+    RunData.grad       = RunData.grad + (Options.computeGrad && success);
+    RunData.time       = toc;
+    RunData.nFails     = ~success*(RunData.nFails + 1);
+    RunData.meshRefine = RunData.meshRefine/(1+(~success && Options.accelerate));
+end
+if Options.runStochastic
+    RunData.RS.nFuncLeft = Options.Term.nFunc - RunData.nFunc;
+end
+RunData.pcenter      = getPollCenter(Options.pollCenter,Cache.Filter,Cache);
+RunData.nCacheHits   = Cache.nHits;
+
+% Update StopRun flag, as appropriate
+RunData.stopRun = 0;
+if (~isempty(Options.stophandle))
+    RunData.stopRun = get(Options.stophandle,'UserData');
+end
+if (Options.runUntilFeasible && ~isempty(Cache.Filter.feasible))
+    RunData.stopRun = 1;
+end
+if (Options.runOneIteration)
+    RunData.stopRun = 1;
+end
+drawnow
+
+% For MVP, update Omega, scale factors, and extended poll thresholds
+if (Problem.isMVP && success)
+    if (Problem.adaptOmega)
+        [Problem.Omega,RunData.scale] = updateOmega(Problem,Options, ...
+            RunData.pcenter);
+    end
+    BestF = getPollCenter(0,Cache.Filter,Cache);
+    RunData.fxi = Options.ePollTriggerF*max(Options.Term.delta,abs(BestF.f));
+end
+if (Options.plotHistory2)
+    plotHistory(Options.hplothandle,Options.plotColor,Cache);
+end
+return
+
+%*******************************************************************************
+% FUNCTIONS CALLED BY MADS SEARCH ROUTINE
+%*******************************************************************************
+%*******************************************************************************
+% lhs:  Perform a Latin Hypercube Search for integer vectors
+% ------------------------------------------------------------------------------
+% Called by: search
+% VARIABLES:
+%  z        = matrix whose columns are LH vectors
+%  ngrid    = vector whose elements are the number of points in each dimension
+%  budget   = the maximum total number of points to be sampled
+%  strength = stength (desired number of points per dimension) of the LHS
+%  nPoints  = actual number of points generated
+%  nleft    = number of indices in each dimension not already chosen
+%  n        = dimension of sample space
+%  ilist    = indices of already chosen numbers in each direction
+%  endflag  = flag indicating usage of all points in a direction
+%*******************************************************************************
+function [z] = lhs(ngrid,budget,strength)
+
+% Initialize variables and determine the number of points to be evaluated
+n       = length(ngrid);
+[z,ilist{1:n}] = deal([]);
+nPoints = min(strength*max(ngrid), prod(ngrid));
+nPoints = min(nPoints,budget);
+nleft   = ngrid;
+
+% Begin main loop to generate LHS points
+for i = 1:nPoints
+    
+    % Generate random vector of integers between 0 and nleft
+    z(:,i) = fix(nleft.*rand(n,1) - eps);
+    
+    % Adjust and update indices, referencing only unused ones
+    for k = 1:n
+        endflag = 1;
+        for j = 1:length(ilist{k})
+            if (z(k,i) >= ilist{k}(j))
+                z(k,i) = z(k,i) + 1;
+            else
+                endflag = 0;            
+                break;
+            end
+        end
+        if isempty(j), j = 0; end
+        ilist{k} = [ilist{k}(1:j-1+endflag), z(k,i), ilist{k}(j+endflag:end)];
+        if (length(ilist{k}) >= ngrid(k)), ilist{k} = []; end
+        nleft(k) = ngrid(k) - length(ilist{k});
+    end
+end
+return;
+
+%*******************************************************************************
+% ga:  Perform Genetic Algorithm on a mesh, as part of Search.
+% ------------------------------------------------------------------------------
+% Called by: search
+% Calls:     setPenaltyTerm
+% VARIABLES:
+%  S         = Set of "good" iterates to be evaluated
+%  Problem   = structure of optimization problem data
+%  Options   = structure of user options
+%  nPoints   = number of points to return
+%  pcenter   = current Poll center
+%  iterate   = vector of iterates
+%  Filter    = index into iterate of filter and best feasible points
+%  arg       = temporary string used in writing penalty function file
+%  n         = number of continuous variables
+%  a         = parameter used in penalty function used in surrogate
+%  f         = name of penalty function
+%  fid       = file ID (handle) of penalty function
+%  LB,UB     = storage of upper and lower variable bounds for GA algorithm use
+%  options   = options for GA optimizer
+%  es,result = GA optimizer output variables
+%*******************************************************************************
+function S = ga(Problem,Options,nPoints,RunData,iterate,Filter)
+
+% Write penalty function file
+if Problem.isMVP
+    setappdata(0,'P',RunData.pcenter.p);
+    arg = '(x,p);';
+else
+    arg = '(x);';
+end
+a   = setPenaltyTerm(iterate,Filter);
+n   = RunData.pcenter.n;
+f   = 'gaPenalty';
+fid = fopen([f,'.m'], 'w');
+fprintf(fid,'%s\n',    ['function [z] = ', f, '(x);'           ], ...
+    ['n = ', int2str(n),';'                 ], ...
+    'if isappdata(0,''P'')'                 , ...
+    '   p = getappdata(0,''P'');'           , ...
+    'end'                                   , ...
+    ['[fx,cx] = ', Problem.File.F, arg      ]);
+if exist(Problem.File.O,'file')
+    fprintf(fid,'%s\n', ['[A,l,u] = ', Problem.File.O, '(n);'   ], ...
+        'A = [A(n+1:end,:); -A(n+1:end,:)];'    , ...
+        'b = [u(n+1:end,:); -l(n+1:end,:)];'    , ...
+        'ind = ~isfinite(b);'                   , ...
+        'b(ind)   = [];'                        , ...
+        'A(ind,:) = [];'                        , ...
+        'cx = [cx ; A*x - b];'                  );
+end
+fprintf(fid,'%s\n',     'cplus   = (cx > 0).*cx;'               , ...
+    'hx      = norm(cplus)^2;'              , ...
+    ['z       = fx + ', num2str(a), '*hx;'  ], ...
+    'return'                               );
+fclose(fid);
+rehash;
+
+% Set up bounds for the GA code (requires full set of finite variable bounds)
+LB = Problem.Omega.l(1:n);
+UB = Problem.Omega.u(1:n);
+LB(~isfinite(LB)) = -1/eps;
+UB(~isfinite(UB)) =  1/eps;
+
+% Call GA code
+options = es_options_new('TolX',Options.Term.delta,'SigmaFacStart', 1, ...
+    'LBound',LB,'UBound',UB,'scaling',RunData.scale);
+es      = es_new(n, LB, UB, options);
+es      = es_run(es, f, nPoints);               % minimize f with an ES struct
+result  = es_get(es, 'result');                 % get result
+S.x = result.x;                                 % return current best point
+S.p = RunData.pcenter.p;
+delete([f,'.m']);
+
+return
+
+%*******************************************************************************
+% setPenaltyTerm: Get penalty parameter for applying GA to constrained problem.
+% ------------------------------------------------------------------------------
+% Called by: ga, recalSurrogate
+% VARIABLES:
+%  a           = parameter used in penalty function used in surrogate or GA
+%  iterate     = vector of iterates
+%    .f        =   objective function value
+%    .h        =   constraint violation function value
+%  Filter      = index into iterate of filter and best feasible points
+%    .F        =   indices of filter points
+%    .feasible =   indices of best feasible solutions
+%  FF          = objective function values of filter points
+%  HH          = constraint violation function values of filter points
+%*******************************************************************************
+function a = setPenaltyTerm(iterate,Filter)
+
+% Compute penalty parameter
+FF = [iterate(Filter.F).f]';
+HH = [iterate(Filter.F).h]';
+if isempty(Filter.feasible)
+    a = 1000;
+else
+    FF = [iterate(Filter.feasible(1)).f; FF]';
+    HH = [iterate(Filter.feasible(1)).h; HH]';
+    a  = max((FF(1:end-1)-FF(2:end))./(HH(2:end)-HH(1:end-1)));
+    if isempty(a), a = 0.5; end
+end
+return
+
+%*******************************************************************************
+% recalSurrogate:  Construct or recalibrate a surrogate.
+% ------------------------------------------------------------------------------
+% Called by: search
+% Calls:     setPenaltyTerm
+% Calls: dacefit (DACE), buildNW (NW), or other surrogate-specific recalibrator
+% VARIABLES:
+%  iterate     = vector of iterates (all in the Cache)
+%  surrogate   = structure containing surrogate information
+%  optimizer   = string identifying the optimizer used to find S
+%  Filter      = indices into iterate that contain the filter
+%  X           = continuous variables values of iterates used for surrogate
+%  F,C         = objective and constraint values of iterates used for surrogate
+%  H           = constraint violation function values of surrogate iterates
+%  n           = number of points used to build surrogate
+%  nc          = number of nonlinear constraints
+%  FF,HH       = objective and constraint values of filter points
+%  a           = parameter used in penalty function used in surrogate
+%  distfactor  = factor used in defining a distance parameter
+%  maxDistance = largest distance between any two data sites
+%*******************************************************************************
+function surrogate = recalSurrogate(iterate,surrogate,optimizer,Filter,varargin)
+
+% Set up data sites and recalibrate surrogate
+X  = [iterate.x]';
+F  = [iterate.f]';
+H  = [iterate.h]';
+n  = length(iterate);
+nc = length(iterate(1).c);
+C  = zeros(n,nc);
+for k = 1:n
+    if ~isempty(iterate(k).c)
+        C(k,:) = iterate(k).c;
+    end
+end
+if strcmp(optimizer,'GA')
+    a = setPenaltyTerm(iterate,Filter);
+    [surrogate.f] = feval(surrogate.recalibrator,X,F+a*H,varargin{:});
+else
+    [surrogate.f] = feval(surrogate.recalibrator,X,F,varargin{:});
+    if (length(iterate(end).c) > 0)
+        surrogate.c = feval(surrogate.recalibrator,X,C,varargin{:});
+    end
+end
+
+% Compute trust region radius and distance and merit function penalty term
+if surrogate.local
+    maxDistance = 0;
+    for i = 1:length(F);
+        for j = 1:i-1
+            distance = norm(X(i,:) - X(j,:));
+            if (distance > maxDistance)
+                maxDistance = distance;
+            end
+        end
+    end
+else
+    maxDistance = inf;
+end
+surrogate.trust = maxDistance/2;
+surrogate.dist  = 10*surrogate.merit*(max(F) - min(F));
+surrogate.X = X;
+surrogate.F = F;
+return
+
+%*******************************************************************************
+% optimizeSurrogate:  Optimize a surrogate problem.
+% ------------------------------------------------------------------------------
+% Called by: search
+% Calls: dacefit (DACE), buildNW (NW), fmincon (Optimization Toolbox)
+% VARIABLES:
+%  S          = set of points generated to be evaluated
+%  Problem    = structure containing optimation problem data
+%    .Omega   =   structure defining feasible region
+%      .A     =     matrix of linear coefficients
+%      .l     =     vector of lower bounds
+%      .u     =     vector of upper bounds
+%  pcenter    = current Poll center
+%  surrogate  = structure containing surrogate information
+%  optimizer  = string identifying the optimizer used to find S
+%  nPoints    = number of points to be returned by the optimizer
+%  tol        = desired accuracy of optimizer
+%  f          = name of the surrogate objective function file
+%  C          = name of the surrogate constraints function file
+%  fid        = file ID (handle) for a surrogate problem file
+%  Sur        = structure of input data for running MADS on the surrogate
+%  SurRunData = RunData for MADS run on the surrogate problem
+%  SurCache   = Cache for the MADS run on the surrogate problem
+%  temp1,2    = temporary storage
+%  n          = number of continuous variables
+%  options    = options for GA optimizer
+%  es,result  = GA optimizer output variables
+%  sf         = surrogate function values of points from GA optimizer
+%  order      = indices of GA-produced iterates, sorted by sf
+%  y          = temporary storage
+%*******************************************************************************
+function S = optimizeSurrogate(Problem,pcenter,surrogate,optimizer,nPoints,tol)
+
+setappdata(0,'SUR',surrogate);
+
+% Construct and store MATLAB commands for computing a surrogate function value
+p{1}     = 'surrogate = getappdata(0,''SUR'');';
+p{end+1} = 'isLocal = 0;';
+p{end+1} = 'minDist = Inf;';
+p{end+1} = 'for k = 1:size(surrogate.X,1)';
+p{end+1} = '   normterm = norm(transpose(x) - surrogate.X(k,:));';
+p{end+1} = '   minDist  = min(minDist, normterm);';
+p{end+1} = '   if (normterm <= surrogate.trust)';
+p{end+1} = '      isLocal = 1;';
+p{end+1} = '      break';
+p{end+1} = '   end';
+p{end+1} = 'end';
+p{end+1} = 'fx = 1/eps;';
+p{end+1} = 'if isLocal';
+p{end+1} = '   fx = feval(surrogate.evaluator,x,surrogate.f);';
+p{end+1} = '   fx = fx - minDist*surrogate.dist;';
+p{end+1} = 'end';
+p{end+1} = 'if ~isfinite(fx), fx = 1/eps; end';
+
+switch optimizer
+    
+    % Call optimizer FMINCON    
+    case 'fmincon'
+        
+        % Write surrogate function files if they do not already exist
+        f   = 'SurObj';
+        if ~exist([f,'.m'],'file') 
+            fid = fopen([f,'.m'], 'w');
+            fprintf(fid,'%s\n',['function [fx] = ', f, '(x);'                  ]);
+            fprintf(fid,'%s\n',p{:});
+            fprintf(fid,'%s\n','return');
+            fclose(fid);
+            rehash
+        end
+        C = [];
+        if isfield(surrogate,'c')
+            C   = 'SurNLConst';
+            if ~exist([C,'.m'],'file')
+                fid = fopen([C,'.m'],'w');
+                fprintf(fid,'%s\n', ...
+                    ['function [C,Ceq] = ', C, '(x);'                 ], ...
+                    'surrogate = getappdata(0,''SUR'');'              , ...
+                    'if isfield(surrogate,''c'')'                     , ...
+                    '   C = feval(surrogate.evaluator,x,surrogate.c);', ...
+                    'end'                                             , ...
+                    'Ceq = [];'                                       , ...
+                    'return'                                         );
+                fclose(fid);
+                rehash
+            end
+        end
+        
+        % Call fmincon optimizer
+        warning('off','all');
+        if isempty(Problem.Omega.A) && isempty(C)
+            S.x = fminunc(f,pcenter.x,optimset('Display','off','TolX',tol));
+        else
+            S.x = fmincon(f,pcenter.x,[Problem.Omega.A; -Problem.Omega.A], ...
+                [Problem.Omega.u; -Problem.Omega.l],[],[],[],[], ...
+                C,optimset('Display','off','TolX',tol));
+        end
+        warning('on','all');
+        S.p = pcenter.p;
+        
+        % Call optimizer FMINCON
+    case 'mads'
+        
+        % Setup options for Surrogate optimization by MADS
+        Sur.Defaults          = mads_defaults('Surrogate');
+        Sur.Problem           = Problem;
+        Sur.Problem.nameCache = Sur.Defaults.nameCache;
+        Sur.Problem.File.F    = [Problem.File.F, '_Sur'];
+        Sur.Problem.File.C    = [Problem.File.C, '_Sur_Cache'];
+        
+        % Write surrogate function file for MADS if it does not already exist
+        f   = Sur.Problem.File.F;
+        if ~exist([f,'.m'],'file')
+            fid = fopen([f,'.m'], 'w');
+            fprintf(fid,'%s\n', ['function [fx,cx] = ', f, '(x);']);
+            fprintf(fid,'%s\n',p{:});
+            if isfield(surrogate,'c')
+                fprintf(fid,'%s\n','cx = feval(surrogate.evaluator,x,surrogate.c);');
+            else
+                fprintf(fid,'%s\n','cx = [];');
+            end
+            fprintf(fid,'%s\n',   'return');
+            fclose(fid);
+            rehash
+        end
+        
+        % Pass function to MADS optimizer
+        [temp1,temp2,SurRunData,SurCache] = mads(Sur.Problem,pcenter, ...
+            Sur.Defaults.Options);
+        
+        % Retrieve and evaluate a number of points
+        S = [SurCache.iterate(SurCache.Filter.feasible(1:nPoints)), ...
+                SurCache.iterate(SurCache.Filter.F(1:nPoints))];
+        
+        % Call Genetic Algorithm package as the surrogate optimizer
+    case 'cmaes'
+        LB = Problem.Omega.l(1:pcenter.n);
+        UB = Problem.Omega.u(1:pcenter.n);
+        options = es_options_new('TolX',tol,'SigmaFacStart',1,...
+            'LBound',LB,'UBound',UB);
+        sf = zeros(nPoints,1);
+        for k = 1:nPoints
+            es = es_new(pcenter.n, LB, UB, options);
+            es = es_run_mod(es, surrogate.evaluator, 100, {surrogate.f}); %minimize
+            result = es_get(es, 'result');
+            S(k).x = result.x;
+            S(k).p = pcenter.p;
+            sf(k)  = feval(surrogate.evaluator,S(k).x,surrogate.f);
+        end
+        [y,order] = sort(sf);              % Sort points by surrogate f-value
+        S = S(order);
+end
+return
+
+%*******************************************************************************
+% FUNCTIONS CALLED BY MADS POLL ROUTINE
+%*******************************************************************************
+%*******************************************************************************
+% standDirections: Returns directions that positively span the tangent cone
+%    at the current iterate, with respect to bound and linear constraints.
+% ------------------------------------------------------------------------------
+% Called by: search, poll
+% Calls:     activeConstraints, getTangentCone, scaleDirections
+% VARIABLES:
+%  D        = matrix whose columns form the positive spanning set
+%  x        = continuous variable values of the current iterate
+%  Omega    = structure whose fields define Omega = {x: l <= Ax <= u}
+%    .A     =   matrix of coefficients for the linear constraints
+%    .l     =   vector of lower bounds
+%    .u     =   vector of upper bounds
+%  strategy = code indicating chosen poll strategy
+%  tol      = tolerance for considering constraints active
+%  scale    = scale factors for scaling the appropriate Poll directions
+%  Ax       = A*x
+%  n        = number of columns of A
+%  I        = identity matrix
+%  W        = underlying basis of Poll directions
+%  B,N      = matrices whose columns together span the tangent cone
+%*******************************************************************************
+function D = standDirections(x,Omega,strategy,tol,scale)
+
+% Initialize variables
+Ax = Omega.A*x;
+n  = length(x);
+
+% Get user-provided Poll basis, if provided
+I = eye(n);
+W = I;
+if isappdata(0,'PARAM') && strncmp(strategy,'Custom',6)
+    if isfield(Param,'PollBasis')
+        Param = getappdata(0,'PARAM');
+        W = Param.pollBasis;
+    end
+end
+if ~((rank(W) == n) && all(size(W) == [n,n]))
+    error('mads:user:dim', ...
+        ['User Poll basis has incompatible size or is not a basis ',...
+            '(standDirections).']);
+end
+
+% Compute B and N, and scale each column in N
+if (isequal(Omega.A,I))   % Bound constraints
+    lactive = activeConstraints( Ax, Omega.l, Omega.u,tol);
+    uactive = activeConstraints(-Ax,-Omega.u,-Omega.l,tol);
+    active  = find(lactive | uactive);
+    B = I(:,active);
+    N = I(:,setdiff(1:n,active));
+    if isempty(active), N = W; end
+    B = scaleDirections(B,scale);
+    N = scaleDirections(N,scale);
+else                      % General linear constraints
+    [B,N] = getTangentCone(x,Omega,tol,scale);
+end
+
+% Form directions that positively span the tangent cone at x
+switch strategy
+    case {'Standard_n+1','Gradient_n+1','Custom_n+1'}
+        D = [-sum(N,2) N  B -B];
+    case {'Standard_2n', 'Gradient_2n', 'Custom_2n'}
+        D = [N -N B -B];
+    otherwise
+        error('mads:poll:choice','Invalid Poll strategy type (standDirections).');
+end
+D(:,~any(D)) = [];
+return;
+
+%*******************************************************************************
+% madsDirections:  Returns a random set of directions that positively span
+%    the tangent cone, with respect to bound and linear constraints.
+% ------------------------------------------------------------------------------
+% Called by: poll
+% Calls:     scaleDirections
+% VARIABLES:
+%  D        = matrix whose columns form the positive spanning set
+%  x        = continuous variable values of the current iterate
+%  strategy = code indicating chosen poll strategy
+%  delta    = mesh size parameter
+%  scale    = scale factors for scaling the appropriate Poll directions
+%  n        = number of continuous variables
+%  z        = reciprocal of the square root of the mesh size
+%  Z        = a random permutation of the integers 1-n
+%  L,M      = matrices used in forming the MADS directions
+%  B        = basis of directions
+%  V        = random permutation of the rows and columns of B
+%*******************************************************************************
+function D = madsDirections(x,strategy,delta,scale)
+
+n = length(x);
+z = 1/sqrt(delta);
+
+% Construct lower triangular nonsingular basis matrix
+Z = rand(n);
+L = tril(fix((2*z+1)*Z - eps), -1);
+M = diag(z*sign(diag(Z-0.5)));
+M(~M) = 1;
+B = L + M;
+
+% Randomly permute rows and columns of B
+V = B(randperm(n),randperm(n));
+
+% Construct positive basis
+switch strategy
+    case 'MADS_2n'
+        D = [V -V];
+    case 'MADS_n+1'
+        D = [V -sum(V,2)];
+    otherwise
+        error('mads:poll:choice','Invalid Poll strategy type (madsDirections).');
+end
+D = scaleDirections(D,scale);
+return
+
+%*******************************************************************************
+% gradDirections:  Compute Poll directions for a gradient-pruned Poll.
+% ------------------------------------------------------------------------------
+% Called by: poll
+% Calls:     activeConstraints, getTangentCone, dVector, scaleDirections
+% VARIABLES:
+%  D                 = set of directions generated by gradient-pruned polling
+%  iterate           = current iterate
+%  Omega             = structure describing feasible region
+%  strategy          = gradient poll type
+%  Filter            = structure of Cache indices of iterates in the filter
+%    .hmax           = max allowable constraint violation of any filter point
+%  delta             = mesh size parameter
+%  tol               = tolerence for determining if a constraint is active
+%  scale             = direction scale factors
+%  p                 = identifier for type of gradient-based direction
+%  infGrad           = flags for identifying unavailable partial derivatives
+%  g                 = gradient vector
+%  d                 = gradient-based descent vector
+%  B                 = indices of numerically binding nonlinear constraints
+%  m                 = number of binding nonlinear constraints, plus one
+%  tmax,LB,UB        = LP variables used for finding feasible descent direction
+%  f,A,Aeq,b,beq     = LP variables used for finding feasible descent direction
+%  OptOptions        = options used during LP solve
+%  X,FX              = solution of LP solve
+%  y                 = feasible descent direction (y = part of X)
+%  exitflag          = error flag for bad LP problem
+%  feasibleMeshPoint = flag indicating a feasible mesh point has been found
+%  z                 = closest mesh point to pcenter + y
+%  I                 = identity matrix
+%  Ax                = product of Omega.A and iterate.x
+%  feasible          = flag for indicating if poll center is feasible
+%  lactive           = flags for numerically active lower bounds of Ax
+%  uactive           = flags for numerically active upper bounds of Ax
+%  active            = flags for numerically active bound/linear constraints
+%  [B,N]             = tangent cone generating directions
+%  Bgood,Bbad        = partitioning of B to deal with unavailable partials
+%  Ngood,Nbad        = partitioning of N to deal with unavailable partials
+%  gradcB            = least squares approx of NLP tangent cone generators
+%  DN                = descent vectors in N
+%  NN                = [N, -N]
+%  descent           = descent vectors in I
+%  dhat              = sum of the chosen ascent and decent directions
+%*******************************************************************************
+function D = gradDirections(iterate,Omega,strategy,Filter,delta,tol,scale)
+
+% Determine type of pruning vector
+switch strategy
+    case 'Gradient_3n_L1'
+        p = 1;
+    case 'Gradient_3n_L2'
+        p = 2;
+    case 'Gradient_3n_LInf'
+        p = Inf;
+    case 'Gradient_3n2n'
+        p = 2;
+    otherwise
+        error('mads:poll:choice','Invalid Poll strategy type (gradDirections).')
+end
+
+% Compute the descent directions that will be used for pruning
+infGrad = ~isfinite(iterate.gradf);
+g = iterate.gradf;
+g(find(infGrad)) = 0;
+d = -dVector(g.*scale,p);
+descent = diag(-dVector(g,Inf));
+
+% Determine the index of binding and violated constraints
+B = find(iterate.c > -tol);
+if (~isempty(B))
+    
+    %  If hmax is exceeded, then use d = -gradh
+    if (iterate.h > Filter.hmax)
+        infGrad = [~isfinite(iterate.gradh) infGrad];
+        g = iterate.gradh;
+        g(find(infGrad)) = 0;
+        d = -dVector(g.*scale,p);
+        descent = diag(-dVector(g,Inf));
+        
+        % If hmax is not exceeded, solve LP to get descent direction in f and cB
+    else
+        tmax = delta^2;
+        m    = length(B)+1;
+        f    = [-1; zeros(iterate.n,1); zeros(m,1)];
+        A    = [ ones(m,1), zeros(m,iterate.n), -eye(m)];
+        Aeq  = [zeros(m,1), [iterate.gradf'; iterate.gradc(:,B)'], eye(m)];
+        b    =  zeros(m,1);
+        beq  =  zeros(m,1);
+        LB   = [0;   -Inf*ones(iterate.n,1); zeros(m,1)];
+        UB   = [tmax; Inf*ones(m + iterate.n,1) ];
+        OptOptions = optimset('Display','off');
+        [X,FX,exitflag] = linprog(f,A,b,Aeq,beq,LB,UB,[],OptOptions);
+        if (exitflag < 0), D = []; return, end
+        y    = X(2:iterate.n+1);
+        
+        % Modify descent direction so that the resulting point is on the mesh
+        m = 1;
+        feasibleMeshPoint = 0;
+        while (~feasibleMeshPoint)
+            m = m + 1;
+            z = iterate.x + delta*round((m*y - iterate.x)/delta);
+            feasibleMeshPoint = iterate.gradf'*z<0 & all(iterate.gradc(:,B)'*z<0);
+            if (m > 1e+3)
+                error('mads:poll:badGradient', ...
+                    'No feasible descent direction found (gradDirections).');
+            end
+        end
+        d = z;
+    end
+end
+
+% Add tangent cone generators and compensate for unavailable derivatives
+I = eye(iterate.n);
+if (isequal(Omega.A,I))
+    Ax = Omega.A*iterate.x;
+    lactive = activeConstraints( Ax, Omega.l, Omega.u,tol);
+    uactive = activeConstraints(-Ax,-Omega.u,-Omega.l,tol);
+    active  = lactive | uactive;
+    Bgood   = find(~infGrad(:,end) & xor(lactive,uactive));
+    Ngood   = find(~infGrad(:,end) & ~active);
+    Bbad    = find( infGrad(:,end) &  active);
+    Nbad    = find( infGrad(:,end) & ~active);
+    B       = [descent(:,Bgood) I(:,Bbad) -I(:,Bbad)];
+    DN      = I(:,Nbad);
+    dhat    = -sum([-descent(:,Ngood) DN],2);
+else
+    [B,N]   = getTangentCone(iterate.x,Omega,tol,scale);
+    Bgood   = find(B'*infGrad(:,end) == 0 & B'*g < 0);
+    Ngood   = find(N'*infGrad(:,end) == 0);
+    Bbad    = setdiff(1:size(B,2),Bgood);
+    Nbad    = setdiff(1:size(N,2),Ngood);
+    B       = [B(:,Bgood) B(:,Bbad) -B(:,Bbad)];
+    DN      = N(:,Nbad);
+    NN      = [N -N];
+    dhat    = -sum([NN(:,NN'*g > 0) DN],2);
+end
+if (~any(dhat) || isequal(d(:,end),dhat)), dhat = []; end
+if ~strcmp(strategy,'Gradient_3n2n'), descent = []; end
+D = [scaleDirections(d,scale), dhat, scaleDirections(descent,scale),B,DN];
+D(:,~any(D)) = [];
+return
+
+%*******************************************************************************
+% getTangentCone:  Compute and return tangent cone generators.
+% ------------------------------------------------------------------------------
+% Acknowledgement:  This mathematics for this algorithm were developed by 
+%    Robert Michael Lewis & Virginia Torczon (College of William & Mary)
+% ------------------------------------------------------------------------------
+% Called by: standDirections, gradDirections
+% Calls:     activeConstraints, removeRedundancy
+% VARIABLES:
+%  B       = V*inv(V'*V)
+%  N       = vectors than span the null space of V'
+%  x       = current iterate continuous variables
+%  Omega   = structure defining feasible region Omega = {x: l<=A*x<=u}
+%    .A    =   matrix of linear constraint coefficients
+%    .l    =   vector of constraint lower bounds
+%    .u    =   vector of constraint upper bounds
+%  tol     = tolerance within which constraints are considered active
+%  scale   = scale factors for scaling the appropriate Poll directions
+%  n       = number of continuous variables
+%  I       = identity matrix
+%  Ax      = A*x
+%  V       = matrix whose columns are normal to active linear constraints
+%  lactive = indices of linear constaints active at their lower bound
+%  uactive = indices of linear constaints active at their upper bound
+%  active  = indices of reformulated linear constraints
+%  A       = alternative storage of linear constraint coefficients
+%  b       = alternative storage of linear constraint bounds
+%  [Q,R]   = QR factorization of V
+%*******************************************************************************
+function [B,N] = getTangentCone(x,Omega,tol,scale)
+
+% Initialize variables
+n = length(x);
+I = eye(n);
+Ax = Omega.A*x;
+tolFinal = tol^2/2;
+
+% Compute V
+V = zeros(n,1);
+while (rank(V) ~= min(size(V)))
+    if (tol > tolFinal)
+        lactive = activeConstraints( Ax,  Omega.l,  Omega.u, tol);
+        uactive = activeConstraints(-Ax, -Omega.u, -Omega.l, tol);
+        V = [ Omega.A(find(uactive),:)', -Omega.A(find(lactive),:)' ];
+        tol = tol/2;
+    else
+        A = [Omega.A; -Omega.A]; 
+        b = [Omega.u; -Omega.l];
+        Ax = A*x;
+        active = activeConstraints(Ax, [Omega.l; -Omega.u], b, tol);
+        A = removeRedundancy(A, b, x, active);
+        V = A';
+        if rank(V) ~= min(size(V))
+            error('mads:constraints:degenerate', ...
+                ['Unable to remove degenerate nonredundant constraints ',...
+                    '(getTangentCone).']);
+        end
+    end
+end
+
+% Compute B and N
+if (isempty(V))
+    B = zeros(n,1);
+    B(:,1:end) = [];
+    N = scaleDirections(I,scale);
+else
+    [Q,R] = qr(V,0);
+    B = Q/R';
+    N = I - B*V';
+end
+
+% Zero out elements that are very small already
+N(abs(N) < 10*eps) = 0;
+B(abs(B) < 10*eps) = 0;
+return
+
+%*******************************************************************************
+% scaleDirections:  Scale each column by a vector of scale factors.
+% ------------------------------------------------------------------------------
+% Called by: standDirections, madsDirections, gradDirections
+% VARIABLES:
+%  Y     = output matrix
+%  X     = input matrix
+%  scale = vector of scale factors
+%*******************************************************************************
+function Y = scaleDirections(X,scale)
+if (isempty(X) || all(scale == 1))
+    Y = X;
+else
+    Y = diag(scale)*X;
+end
+return
+
+%*******************************************************************************
+% activeConstraints:  Check which constraint bounds are numerically active.
+% ------------------------------------------------------------------------------
+% Called by: standDirections, gradDirections, getTangentCone
+% VARIABLES:
+%  active = logicals indicating which constraints is numerically active
+%  x      = point in R^n to be tested 
+%  [a,b]  = upper and lower bounds on x
+%  tol    = error tolerance for e-active constraints
+%  infa   = indices of x having no lower bound
+%  infb   = indices of x having no upper bound, but having a lower bound
+%  finite = indices of x having finite lower and uppr bounds
+%*******************************************************************************
+function active = activeConstraints(x,a,b,tol)
+
+% Set status of each continuous variable
+infa   = find(isinf(a));
+infb   = find(isinf(b) & ~isinf(a));
+finite = isfinite(a.*b);
+one    = ones(length(infb),min(1,length(infb)));
+
+% Determine status of each variable
+active         = zeros(length(x),1);
+scale          = max([abs(x(infb)),abs(a(infb)),one],[],2);
+active(infb)   = (x(infb)  -a(infb)   <= tol*scale);
+scale          = max(b(finite)-a(finite),1);
+active(finite) = (x(finite)-a(finite) <= tol*scale);
+return
+
+%*******************************************************************************
+% removeRedundancy:  Removes rows of Ax <= b that are redundant.
+% ------------------------------------------------------------------------------
+% This algorithm is courtesy of Olga A. Brezhneva (Miami University, Ohio)
+% ------------------------------------------------------------------------------
+% Called by: getTangentCone
+% VARIABLES:
+%  AA     = matrix A with only nonredundant e-active constraints left
+%  bb     = vector b with only nonredundant e-active constraints left
+%  A      = coefficient matrix
+%  b      = right-hand side
+%  x      = current iterate continuous variables
+%  active = indices of the active constraints (rows) in A
+%  ind    = vector of indices
+%  bb     = b vector with only nonredundant e-active constraints left
+%  m      = length of bb
+%  res    = residual of current constraint
+%  px     = projection of x onto the current constraint boundary
+%  pres   = vector of residuals with respect to px
+%  NR     = logical indicating non-redundancy status
+%  xval   = optimal x with respect to the LP solver
+%  fval   = LP objective function value at xval
+%  i      = constraint counter
+%*******************************************************************************
+function [AA,bb] = removeRedundancy(A,b,x,active)
+
+% Form e-active constraints
+ind = find(active);
+AA  = A(ind,:);
+bb  = b(ind);
+
+% Begin loop through constraints
+i = 1;
+m = length(bb);
+while i <= m
+    
+    % Strategy 1: verification of nonredundancy
+    res  = bb(i) - AA(i,:)*x;
+    px   = x + AA(i,:)'*res;
+    pres = bb - AA*px;
+    pres(i) = 1;
+    NR = all(pres > 0);
+    
+    % Strategy 2: solve LP problem
+    if ~NR
+        ind    = 1:length(bb);
+        ind(i) = [];
+        warning('off','all');
+        [xval,fval] = linprog(-AA(i,:)',AA(ind,:),bb(ind),[],[],[],[],[], ...
+            optimset('Display','off'));
+        warning('on','all');
+        NR = (-fval > bb(i));
+    end
+    
+    % Delete constraint if redundant
+    if NR
+        i = i + 1;
+    else
+        AA(i,:) = [];
+        bb(i)   = [];
+        m = length(bb);
+    end
+end
+return
+
+%*******************************************************************************
+% dVector:  Returns the appropriate 3^n vector approximating v.
+% ------------------------------------------------------------------------------
+% Called by: gradDirections
+% VARIABLES:
+%  w = L-1, closest L-2, or L-Inf {-1,0,1}^n approximation to v
+%  v = input vector
+%  p = norm of the gradient
+%*******************************************************************************
+function w = dVector(v,p)
+switch p
+    case {1}
+        w = (abs(v) == max(abs(v))).*sign(v);
+    case {2}
+        w = v/norm(v,inf);
+        w(~isfinite(w) | abs(w) < tan(pi/8)) = 0;
+        w = sign(w);
+    case {inf}
+        w = sign(v);
+end
+return
+
+%*******************************************************************************
+% getPollOrder:  Returns the order in which to poll from the poll set.
+% ------------------------------------------------------------------------------
+% Called by: poll
+% VARIABLES:
+%  order     = resulting Poll order
+%  orderCode = string indicating user choice
+%  D         = set of Poll directions
+%  P         = the Poll set
+%  RunData   = structure of Run statistics and information
+%    .goodD  =   previous direction of the last successful iteration
+%    .porder =   poll order from the previous successful iteration
+%  n         = dimension of the optimization problem
+%  nD        = number of Poll directions
+%  norms     = norms of the columns of D
+%  angles    = angles between .goodD and the columns of D
+%  sf,sc,sh  = surrogate f-, c-, and h-values
+%*******************************************************************************
+function order = getPollOrder(orderCode,D,P,RunData,surrogate)
+
+% get the dimensions of D
+[n,nD] = size(D);
+
+% Construct the order according to user choice
+switch orderCode
+    case 'Consecutive'
+        order = 1:nD;
+    case 'Alternating'
+        switch nD
+            case {n+1}
+                order = [nD, 1:nD-1];
+            case {2*n}
+                order = reshape([1:n; n+1:2*n],1,nD);
+            otherwise
+                order = 1:nD;
+        end
+    case 'Random'
+        order = randperm(nD);
+    case {'Dynamic','DynamicRanked'}
+        order = 1:nD;
+        if isfield(RunData,'porder')
+            norms = zeros(nD,1);
+            for k = 1:nD
+                norms(k) = norm(D(:,k));
+            end
+            angles = (D'*RunData.goodD)./norms;
+            [y,order] = sort(-angles);
+            if strcmp(orderCode,'Dynamic')
+                k = find(RunData.porder == order(1));
+                order = [order(1) RunData.porder(1:k-1) RunData.porder(k+1:end)];
+            end
+        end
+    case 'Surrogate'
+        sf = feval(surrogate.evaluator,[P.x]',surrogate.f);
+        if isfield(surrogate,'c')
+            for k = 1:length(surrogate.c)
+                sc(:,k) = feval(surrogate.evaluator,[P.x]',surrogate.c(k));
+            end
+            sh = sum((sc > 0).*sc.*sc,2);
+        end
+        if (RunData.pcenter.h > 0)
+            [y,order] = sort(sh);
+        else
+            [y,order] = sort(sf);
+        end
+    case 'Custom'
+        order = RunData.porder;
+        if (length(order) ~= nD)
+            error('mads:poll:dim', ...
+                ['Poll directions and Poll orders have incompatible dimensions ', ...
+                    '(getPollOrder).']);
+        end
+end
+return
+
+%*******************************************************************************
+% FUNCTIONS CALLED BY MADS UPDATE ROUTINE
+%*******************************************************************************
+%*******************************************************************************
+% getPollCenter: Gets the POLL center based on CenterCode.
+% ------------------------------------------------------------------------------
+% Called by: processInput, processOutput, search, mvpPoll, update
+% VARIABLES:
+%  pcenter      = chosen POLL center
+%  iCache       = Cache index of poll center
+%  centerCode   = code indicating which point to POLL around
+%                 (0 = current solution; otherwise = Filter(centerCode))
+%  Filter       = sorted indices of Cache iterates in the filter
+%  Cache        = collection of all previous iterates
+%  closest      = min(centerCode, filter size)
+%  noFilter     = flag indicating no infeasible iterates have been found
+%  noFeasible   = flag indicating no feasible iterates have been found
+%  filterPoints = indices of valid filter points
+%*******************************************************************************
+function [pcenter,iCache] = getPollCenter(centerCode,Filter,Cache)
+
+% Determine status of filter vectors.  Error if both are empty.
+noFilter   = isempty(Filter.F);
+noFeasible = isempty(Filter.feasible);
+if (noFeasible && noFilter)
+    error('mads:pollCenter:badFilter', ...
+        'No suitable iterate to poll around (PollCenter).');
+end
+
+% Want current best feasible point.  If none, pick least infeasible point.
+if (centerCode == 0)
+    if (noFeasible)
+        iCache = Filter.F(1);
+    else
+        iCache = Filter.feasible(1);
+    end
+    
+    % Want particular filter point.  If none, pick current best feasible point.
+else
+    if (noFilter)
+        iCache = Filter.feasible(1);
+    else
+        filterPoints = find([Cache.iterate(Filter.F).h] < Filter.hmax);
+        if ~isempty(filterPoints)
+            closest = min(centerCode,filterPoints(end));
+        else
+            closest = 1;
+        end
+        iCache = Filter.F(closest);
+    end
+end
+
+pcenter = Cache.iterate(iCache);
+return;
+
+%*******************************************************************************
+% updateOmega:  Update the set of linear constraints .l <= .A*x <= .u.
+% ------------------------------------------------------------------------------
+% Parts of this routine are courtesy of Dennis & Schnabel textbook
+% ------------------------------------------------------------------------------
+% Called by: processInput, search, mvpPoll, update, evalPointSet
+% Calls:     getpID, < Omega File >
+% VARIABLES:
+%  Omega               = structure describing (linear) feasible region
+%    .A                =   coefficient matrix
+%    .l                =   vector of lower bounds
+%    .u                =   vector of upper bounds
+%    .plist            =   list of allowable categorical variable values
+%  newScale            = scale factors for constructing mesh
+%  Problem             = structure of problem data
+%    .File.O           =   name of file defining feasible region Omega
+%    .isMVP            =   flag indicating problem is an MVP problem
+%  Options             = structure of MADS options
+%    .removeRedundancy =   turns on/off removal of redundant constraints
+%    .scale            =   base for logarithmic scaling
+%  iterate             = current iterate
+%    .n                =   dimension of the continuous variable space
+%    .x                =   vector of continuous variable values
+%    .p                =   cell array of categorical variables
+%  n                   = number of continuous variables of iterate
+%  m                   = number of linear constraints
+%  [a,b]               = temporary storage of variable bounds
+%  scaleA              = vector of scales for scaling linear constraints
+%  AA,bb               = reformulation of linear constraints
+%  Redundant           = flags indicating redundant linear constraints
+%  ind                 = indices of nonredundant linear constraints
+%  indcopy             = temporary copy of ind
+%  xval,fval           = x-value and f-value of LP solution
+%**************************************************************************
+function [Omega,newScale] = updateOmega(Problem,Options,iterate)
+
+% Get parameters that define the linear constraints
+n = length(iterate.x);
+if exist(Problem.File.O,'file')
+    switch nargin(Problem.File.O) + 2*Problem.isMVP
+        case {1}
+            [A,l,u] = feval(Problem.File.O,n);          
+        case {2}
+            error('mads:constraints:badFileFormat', ...
+                'Non-MVP Omega file cannot have a second argument (updateOmega).');
+        case {3}
+            [A,l,u,plist] = feval(Problem.File.O,n);    
+        case {4}
+            [A,l,u,plist] = feval(Problem.File.O,n,iterate.p);    
+    end
+else
+    if (Problem.isMVP)
+        error('mads:constraints:file', ...
+            ['MVP problem missing its Omega file, ',Problem.File.O, ...
+                ' (updateOmega).']);
+    else
+        [A,l,u] = deal(eye(n),-Inf*ones(n,1),Inf*ones(n,1));
+    end
+end
+[m,n] = size(A);
+
+% Error check linear constraint parameters
+errorCheck = ~isempty(find(l - u > 0)) || size(l,1) ~= m || ...
+    all(size(l) ~= size(u))    || size(u,1) ~= m;
+if (errorCheck),
+    error('mads:constraints:dim','Invalid constraint dimensions (updateOmega).');
+end
+
+% Scale the linear constraints by their inf-norms and form Omega structure
+a = l(1:n);
+b = u(1:n);
+scaleA = max(abs(A),[],2);
+A = diag(1./scaleA)*A;
+l = l./scaleA;
+u = u./scaleA;
+
+%% Detect redundant linear constraints (due in part to Olga Brezhneva)
+ind = 1:m;
+if (Options.removeRedundancy)
+    AA = [-A; A];
+    bb = [-l; u;];
+    Redundant = ~isfinite(bb)';
+    ind = find(isfinite(bb));
+    for i = 1:length(ind)
+        indcopy = ind;
+        indcopy(i) = [];
+        warning('off','all');
+        [xval,fval] = linprog(-AA(ind(i),:)',AA(indcopy,:),bb(indcopy), ...
+            [],[],[],[],[],optimset('Display','off'));
+        warning('on','all');
+        if ~isempty(fval)
+            Redundant(ind(i)) = (-fval <= bb(ind(i)));
+        else
+            error('mads:constraints:LPerror', ...
+                ['linprog solver failed. Recheck LP formulation for removing ',...
+                    'redundant linear constraints (updateOmega).']);
+        end
+    end
+    
+    % Delete redundant linear constraints
+    ind = all(reshape(Redundant,m,2)');
+    A(ind,:)   = [];
+    l(ind)     = [];
+    u(ind)     = [];
+end
+
+% Form Omega structure and get new scale factors
+Omega = struct('A',full(A),'l',l,'u',u);
+if (Problem.isMVP)
+    Omega.plist = plist;
+    newScale = getScaleFactors(Options.scale,iterate,a,b,Problem.nameCache, ...
+        plist);
+else
+    newScale = getScaleFactors(Options.scale,iterate,a,b,Problem.nameCache);
+end
+return
+
+%*******************************************************************************
+% getScaleFactors:  Get scale factors for scaling directions.
+% ------------------------------------------------------------------------------
+% Called by: UpdateOmega
+% VARIABLES:
+%  newScale  = vector of scale factors for scaling of directions
+%  scale     = base of logarithmic scaling (0 = no scale)
+%  iterate   = current poll center
+%  [a,b]     = vectors of lower and upper bounds on continuous variables
+%  isMVP     = flag indicating problem is an MVP problem
+%  nameCache = name of the base workspace Cache variable
+%  typx      = "typical" values used for scaling if bounds are insufficient
+%  pID       = ID for the categorical variable values
+%  ind       = index used to match Cache points with the same pID
+%  zeroInf   = flags for zero or infinite values in [a,b]
+%  bad       = indices of variables with a and b both zero or infinite
+%  good      = indices of variables with a and b both finite and nonzero
+%  lhalf     = indices of variables with finite nonzero a and zero or infinite b
+%  rhalf     = indices of variables with finite nonzero b and zero or infinite a
+%  expScale  = exponents of the approximate ranges of the variables
+%  baseScale = factor for coverting from base b to base 10 logarithm
+%*******************************************************************************
+function newScale = getScaleFactors(scale,iterate,a,b,nameCache,varargin)
+
+% Compute scale factors, if selected
+n = length(iterate.x);
+if (scale)
+    
+    % Compute "typical" value of x for scaling
+    isMVP = (nargin > 5);
+    Cache = getappdata(0,nameCache);
+    if isempty(Cache.iterate)
+        typx = iterate.x;
+    else
+        if (isMVP)
+            pID = getpID(iterate.p,varargin{:});
+            ind = find(Cache.pID(1:Cache.size) == pID);
+            if isempty(ind)
+                typx = iterate.x;
+            else
+                typx = Cache.iterate(ind(1)).x;
+            end
+        else
+            typx = Cache.iterate(1).x;
+        end
+    end
+    
+    % Flag zero or infinite bounds, and categorize each variable's bounds
+    zeroInf = [ (~isfinite(a)|abs(a)<=eps), (~isfinite(b)|abs(b)<=0)];
+    good    = find(~any(zeroInf,2));
+    lhalf   = find(~zeroInf(:,1)  &  zeroInf(:,2));
+    rhalf   = find( zeroInf(:,1)  & ~zeroInf(:,2));
+    bad     = find(all(zeroInf,2) &  typx);
+    verybad = find(all(zeroInf,2) & ~typx);
+    
+    % Scale variables with finite nonzero bounds IAW D&S, ch 7 and pp. 278-9
+    baseScale       = 1/log10(scale);
+    expScale        = ones(n,1);
+    expScale(good)  = baseScale * (log10(abs(a(good)))+log10(abs(b(good))))/2;
+    expScale(lhalf) = baseScale *  log10(abs(a(lhalf)));
+    expScale(rhalf) = baseScale *  log10(abs(b(rhalf)));
+    expScale(bad)   = baseScale *  log10(abs(typx(bad)));
+    expScale(verybad) = 0;
+    newScale = scale.^round(expScale);
+else
+    newScale = ones(n,1);
+end
+return
+
+%*******************************************************************************
+% FUNCTIONS FOR EVALUATING FUNCTIONS AND UPDATING CACHE DATA
+%*******************************************************************************
+%*******************************************************************************
+% evalPointSet:  Evaluates the objective and constraint functions.
+% ------------------------------------------------------------------------------
+% Called by: processInput, search, poll, mvpPoll
+% Calls:     evalRSPointSet, updateOmega, inOmega, getpID, isCacheHit, 
+%            evalFunction, updateCache, updateFilter
+% VARIABLES:
+%  P              = set of iterates to be evaluated
+%  success        = logical indicating a successful iteration
+%  Filter         = updated filter
+%  RS             = structure of R&S parameters (unused if not stochastic)
+%  Problem        = structure containing problem parameters
+%    .File.O      =   name of Omega file
+%    .fType       =   type of functions file (C=C, F=FORTRAN, M=MATLAB)
+%    .isMVP       =   logical indicating if problem is n MVP
+%    .Omega       =   structure defining feasible region {x: l<=Ax<=u}
+%      .A         =     coefficient matrix
+%      .l         =     vector of lower bounds
+%      .u         =     vector of upper bounds
+%      .plist     =     list of valid categorical variables
+%    .nameCache   =   name of the base workspace Cache variable
+%  full           = flag indicating if all points in P will be evaluated
+%  Options        = structure of user options
+%    .computeGrad =   flag for computing gradients
+%  nP             = number of iterates to be evaluated
+%  pID            = categorical variable value ID
+%  xnorm          = 1-norm of iterate being evaluated
+%  hit            = flag indicating a Cache hit
+%  unfiltered     = logical indicating an iterate is unfiltered
+%*******************************************************************************
+function [P,success,Filter,RS] = evalPointSet(Problem,P,full,Options,Filter,...
+    RS,add2sur)
+
+success = 0;
+if (isempty(P)), return; end
+
+% Initialize output fields
+nP = length(P);
+for k = 1:nP
+    P(k).n = length(P(k).x);
+end
+[P.f,P.c,P.h] = deal([]);
+
+% Call R&S version if R&S problem
+if Options.runStochastic
+    [P,success,Filter,RS] = evalRSPointSet(Problem,P,Options,Filter,RS,add2sur);
+    return
+end
+
+if (Options.computeGrad)
+    [P.gradf,P.gradc,P.gradh] = deal([]);
+end
+
+% Evaluate each iterate, as appropriate
+for k = 1:nP
+    
+    % update MVP Omega parameters, as is necessary
+    if Problem.adaptOmega
+        [Problem.Omega] = updateOmega(Problem,Options,P(k));
+    end
+    
+    % Test if iterate lies in Omega
+    if (inOmega(P(k),Problem.Omega))
+        
+        % Give trial point unique IDs to expedite Cache searching
+        pID = 0;
+        if Problem.isMVP
+            pID = getpID(P(k).p,Problem.Omega.plist);
+        end
+        xnorm = norm(P(k).x,inf);
+        
+        % Test to see if the iterate is in the Cache
+        Cache = getappdata(0,Problem.nameCache);
+        hit = isCacheHit(Cache,P(k),xnorm,pID,50000);
+        Cache.nHits = Cache.nHits + hit;
+        setappdata(0,Problem.nameCache,Cache);
+        
+        % Evaluate function, store in Cache, and update Cache and filter
+        if (~hit)
+            P(k) = evalFunction(Problem.File.F,Problem.fType,P(k), ...
+                Options.computeGrad);
+            Cache = updateCache(Cache,Problem,P(k),xnorm,pID,1);
+            setappdata(0,Problem.nameCache,Cache);
+            if isfinite(P(k).h)
+                [unfiltered,Filter] = updateFilter(P(k),Filter,Cache);
+            else
+                unfiltered = 0;
+            end
+            if (unfiltered), success = k; end
+            if (add2sur == 2) || (add2sur == 1 && unfiltered)
+                Cache = getappdata(0,Problem.nameCache);
+                Cache.isSurrPoint(Cache.size) = 1;
+                setappdata(0,Problem.nameCache,Cache);
+            end
+            if (success && ~full), break; end
+        end
+    end
+end
+return
+
+%*******************************************************************************
+% getpID:  Get unique ID based on values of categorical variables.
+% ------------------------------------------------------------------------------
+% Called by: evalPointSet
+% VARIABLES:
+%  pID   = unique ID
+%  p     = cell array of categorical variables
+%  plist = cell array of allowable values for each categorical variable
+%  m     = vector of plist lengths for each categorical variable
+%  ind   = index of plist that matches the current categorical variable 
+%*******************************************************************************
+function pID = getpID(p,plist)
+
+np  = length(p);
+m   = zeros(np,1);
+pID = zeros(np,1);
+for k = 1:np
+    m(k) = length(plist{k});
+    if ischar(p{k})
+        ind = find(strcmp(p{k},plist{k}));
+    else
+        ind = find([plist{k}{:}] == p{k});
+    end
+    pID(k) = ind(1);
+end
+pID = pID'*[1; cumprod(m(1:end-1)+1)];
+return
+
+%*******************************************************************************
+% inOmega:  Test to see if point x satisfies l <= A*x <=u.
+% ------------------------------------------------------------------------------
+% Called by: makeFeasible, evalPointSet
+% VARIABLES:
+%  pass     = logical indicating is x satisfies l <= A*x <=u
+%  iterate  = current iterate
+%    .x     =   vector of continuous variables
+%    .p     =   cell array of categorical variables
+%  Omega    = feasible space with respect to bound and linear constraints
+%    .A     = coefficient matrix for linear and bound constraints
+%    .l     = lower bound vector for linear and bound constraints
+%    .u     = upper bound vector for linear and bound constraints
+%    .plist = cell array of lists of allowed categorical values in p
+%  Ax       = .A*x
+%*******************************************************************************
+function pass = inOmega(iterate,Omega)
+
+% Check for errors in categorical variables or Omega construction
+for k = 1:length(iterate.p)
+    if (ischar(iterate.p{k}))
+        pass = any(strcmp(iterate.p{k},Omega.plist{k}));
+    else
+        pass = ~isempty(find([Omega.plist{k}{:}] == iterate.p{k}));
+    end
+    if (~pass), return; end
+end
+
+% Check if iterate is in Omega
+Ax = Omega.A*iterate.x;
+pass = isempty(find(Omega.l > Ax)) && isempty(find(Omega.u < Ax));
+return;
+
+%*******************************************************************************
+% isCacheHit:  Test to see if point has already been evaluated previously.
+% ------------------------------------------------------------------------------
+% Called by: evalPointSet
+% VARIABLES:
+%  hit        = logical indicating that the iterate matches a Cache point
+%  Cache      = array of previously computed iterates
+%    .iterate =   vector of iterates
+%    .tol     =   tolerance for declaring a Cache hit w.r.t iterate.x
+%    .xnorm   =   vector of 1-norms of iterates in the Cache
+%    .pID     =   vector of IDs od categorical variable values
+%  iterate    = current point
+%    .x       =   coordinates of continuous  variables
+%    .p       =   coordinates of categorical variables
+%  xnorm      = 1-norm of iterate.x
+%  pID        = ID of categorical variable values
+%  looksize   = how far back into the Cache will be searched
+%  ind        = indices of Cache points that may match the current point
+%  xvalues    = temporary storage of Cache continuous variable values
+%*******************************************************************************
+function hit = isCacheHit(Cache,iterate,xnorm,pID,looksize)
+
+% Initialize Cache search
+hit = 0;
+ind = max(1,Cache.size-looksize):Cache.size;
+
+% Screen out iterates without sufficiently close x-norms (see Apostol, p49)
+ind = ind((abs(Cache.xnorm(ind) - xnorm) < Cache.tol));
+if isempty(ind), return, end
+
+% Screen out iterates with different categorical variable values
+if pID ~= 0
+    ind = ind(Cache.pID(ind) == pID);
+    if isempty(ind), return, end
+end
+
+% Finish search
+xvalues = [Cache.iterate(ind).x];
+ind = ind(max(abs(xvalues - repmat(iterate.x,1,length(ind))),[],1) < Cache.tol);
+hit = ~isempty(ind);
+return
+
+%*******************************************************************************
+% evalFunction:  Evaluates objective and constraint functions at a point.
+% ------------------------------------------------------------------------------
+% Called by: evalPointSet
+% Calls: < User F >
+% VARIABLES:
+%  f        = name of optimization problem functions file
+%  ftype    = type of functions file (F=FORTRAN, C=C/C++, M=MATLAB)
+%  iterate  = current iterate
+%    .x     =   coordinates of iterate
+%    .p     =   values of categorical variables
+%    .f     =   objective function value of iterate
+%    .c     =   constraint function values of iterate
+%    .h     =   constraint violation function value of iterate
+%    .gradf =   f'(x) at current iterate x
+%    .gradc =   c'(x) at current iterate x
+%    .gradh =   h'(x) at current iterate x
+%  grad     = flag for computing gradients, if available
+%  pchar    = categorical variables stored as character strings
+%  pint     = categorical variables stored as integers
+%  cflag    = flag for sorting out char and int categorical variables
+%  nc       = number of nonlinear constraints
+%  badValue = the value used when f(x) is complex (Inf)
+%  cplus    = vector of nonlinear constraint violations
+%*******************************************************************************
+function iterate = evalFunction(f,ftype,iterate,grad)
+
+switch upper(ftype)
+    
+    % Process a compiled Fortran functions file   
+    case {'F','C'}
+        if (isempty(iterate.p))
+            pchar = 0;
+            pint  = 0;
+        else
+            cflag = zeros(length(iterate.p),1);
+            for k = 1:length(iterate.p)
+                cflag(k) = ischar(iterate.p{k});
+            end
+            pchar = [iterate.p{find( cflag)}];
+            pint  = [iterate.p{find(~cflag)}];
+        end
+        
+        [nc,iterate.f,c,gradf,gradc] = feval(f,iterate.x,pint,pchar);
+        iterate.c = c(1:nc);
+        if (grad)
+            iterate.gradf = gradf;
+            iterate.gradc = gradc(:,1:nc);
+        end
+        
+        % Process a Matlab functions file   
+    case {'M'}
+        switch nargin(f) + 2*grad;
+            case {1}
+                if (nargout(f) == 1)
+                    iterate.f = feval(f,iterate.x);
+                    iterate.c = [];
+                else
+                    [iterate.f,iterate.c] = feval(f,iterate.x);
+                end
+            case {2}
+                if (nargout(f) == 1)
+                    iterate.f = feval(f,iterate.x,iterate.p);
+                    iterate.c = [];
+                else
+                    [iterate.f,iterate.c] = feval(f,iterate.x,iterate.p);
+                end
+            case {3}
+                [iterate.f,iterate.c,iterate.gradf,iterate.gradc] = feval(f,iterate.x);
+            case {4}
+                [iterate.f,iterate.c,iterate.gradf,iterate.gradc] = feval(f,iterate.x, ...
+                    iterate.p);
+            otherwise
+                error('mads:function:badVariables', ...
+                    'Error in FunctionEval logical input variables (functionEval).');
+        end
+    otherwise
+        error('mads:function:badType','Invalid Function Type (functionEval).');
+end
+
+% Prevent complex-valued functions
+badValue = realmax;
+if (~isreal(iterate.f)), iterate.f = badValue; end
+iterate.c(~isreal(iterate.c)) = badValue;
+if (grad)
+    iterate.gradf(~isreal(iterate.gradf)) = badValue;
+    iterate.gradc(~isreal(iterate.gradc)) = badValue;
+end
+
+% Compute h(x) (and h'(x) if available)
+cplus = (iterate.c > 0).*iterate.c;
+iterate.h = norm(cplus)^2;
+if (grad)
+    iterate.gradh = 2*iterate.gradc*cplus';
+end
+
+return;
+
+%*******************************************************************************
+% updateCache:  Update the Cache with the current iterate.
+% ------------------------------------------------------------------------------
+% Called by: EvalPointSet
+% VARIABLES:
+%  Cache      = structure containing data on all past iterates
+%    .iterate =   the previously computed iterates
+%    .size    =   current number of iterates in the Cache
+%    .tol     =   tolerance for determining if iterate was in Cache
+%    .xnorm   =   vector of 1-norms of previously computed iterates
+%    .pID     =   vector of categorical variable ID numbers
+%    .bfp     =   vector of best feasible points
+%    .lip     =   vector of least infeasible points
+%  Problem    = structure containing problem file names and parameters
+%    .isMVP   =   logical indicating if problem is an MVP
+%    .maxNc   =   maximum number of constraints to be added
+%    .maxNx   =   maximum number of continuous variables of any iterates
+%    .maxNp   =   maximum number of categorical variables of any iterates
+%  iterate    = current iterate
+%    .x       =   coordinates of iterate
+%    .p       =   values of categorical variables
+%    .n       =   number of continuous variables
+%    .f       =   objective function value of iterate
+%    .c       =   constraint function values of iterate
+%    .h       =   constraint violation function value of iterate
+%    .gradf   =   f'(x) at current iterate x
+%    .gradc   =   c'(x) at current iterate x
+%    .gradh   =   h'(x) at current iterate x
+%  xnorm      = 1-norm of the curent iterate
+%  pID        = categorical variable value ID of the current iterate
+%  nFunc      = number of function evaluations at point (=1, if not stochastic)
+%  n          = number of iterates for which memory is to be allocated
+%  ind        = index variable for additional chunks of memory
+%  p          = temporary storage
+%*******************************************************************************
+function Cache = updateCache(Cache,Problem,iterate,xnorm,pID,nFunc)
+
+% Allocate extra chunks of memory if more is required 
+if (Cache.size >= max(1024,length(Cache.iterate)))
+    n = 1024;
+    ind = length(Cache.iterate) + (1:n);
+    if (Problem.isMVP)
+        [p{1:Problem.maxNp}] = deal('            ');
+    else
+        p = {};   
+    end
+    [Cache.iterate(ind).x] = deal(zeros(Problem.maxNx,1));
+    [Cache.iterate(ind).p] = deal(p);
+    [Cache.iterate(ind).n] = deal(0);
+    [Cache.iterate(ind).f] = deal(0);
+    [Cache.iterate(ind).c] = deal(zeros(Problem.maxNc,1));
+    [Cache.iterate(ind).h] = deal(0);
+    Cache.xnorm(ind)       = deal(0);
+    Cache.pID(ind)         = deal(0);
+    Cache.bfp(ind)         = deal(0);
+    Cache.lip(:,ind)       = deal(0);
+    Cache.nFunc(ind)       = deal(0);
+    Cache.isSurrPoint(ind) = deal(0);
+    if (isfield(iterate,'gradf'))
+        [Cache.iterate(ind).gradf] = deal(zeros(Problem.maxNx,1));
+        [Cache.iterate(ind).gradc] = deal(zeros(Problem.maxNc,Problem.maxNx));
+        [Cache.iterate(ind).gradh] = deal(zeros(Problem.maxNx,1));
+    end
+end
+
+% Update Cache (.isSurrPoint is set to zero and updated later)
+Cache.size = Cache.size + 1;
+Cache.iterate(Cache.size)     = iterate;
+Cache.xnorm(Cache.size)       = xnorm;
+Cache.pID(Cache.size)         = pID;
+Cache.nFunc(Cache.size)       = nFunc;
+Cache.isSurrPoint(Cache.size) = 0;
+
+% Update the BFP and LIP function values in the Cache (used in plotting)
+feasible = (iterate.h < Cache.Filter.hmin);
+if (feasible)
+    if (Cache.size == 1)
+        Cache.bfp(Cache.size) = iterate.f;
+        Cache.lip(:,Cache.size) = [Inf; Inf];
+    else
+        Cache.bfp(Cache.size) = min(Cache.bfp(Cache.size-1),iterate.f);
+        Cache.lip(:,Cache.size) = Cache.lip(:,Cache.size-1);
+    end
+else
+    if (Cache.size == 1)
+        Cache.bfp(Cache.size) = Inf;
+        Cache.lip(:,Cache.size) = [iterate.f; iterate.h];
+    else
+        Cache.bfp(Cache.size) = Cache.bfp(Cache.size-1);
+        if (iterate.h < Cache.lip(Cache.size-1))
+            Cache.lip(:,Cache.size) = [iterate.f; iterate.h];
+        else
+            Cache.lip(:,Cache.size) = Cache.lip(:,Cache.size-1);
+        end
+    end
+end
+
+return
+
+%*******************************************************************************
+% FUNCTIONS FOR UPDATING AND PLOTTING THE FILTER
+%*******************************************************************************
+%*******************************************************************************
+% updateFilter:  Update the filter and solutions vectors, given in iterate.
+% ------------------------------------------------------------------------------
+% Called by: evalPointSet, mvpPoll
+% Calls:     dominates, plotFilter
+% VARIABLES:
+%  unfiltered  = logical indicating that the iterate is unfiltered
+%  Filter      = structure containing filter
+%    .hmin     =   minimum allowed constraint violation of filter point
+%    .hmax     =   maximum allowed constraint violation of filter point
+%    .strict   =   flag indicating that hmax is strictly enforced
+%    .plot     =   flag for displaying a real-time plot of the filter 
+%    .feasible =   sorted indices of feasible Cache iterates
+%    .F        =   sorted indices of Cache iterates in the filter
+%  iterate     = current iterate
+%    .x        =   coordinates of iterate
+%    .p        =   values of categorical variables
+%    .n        =   dimension of the continuous variables
+%    .f        =   objective function value of iterate
+%    .c        =   constraint function values of iterate
+%    .h        =   constraint violation function value of iterate
+%    .gradf    =   f'(x) at current iterate x
+%    .gradc    =   c'(x) at current iterate x
+%    .gradh    =   h'(x) at current iterate x
+%  Cache       = collection of all previously evaluated iterates
+%    .iterate  =   vector of iterates
+%    .size     =   number of iterates
+%  maxSolPts   = maximum number of feasible points to keep in filter
+%  ind         = indices used in sorting
+%  dominated   = flags indicating which filter points iterate dominates
+%  infeasible  = flags indicating which filter points exceed hmax
+%*******************************************************************************
+function [unfiltered,Filter] = updateFilter(iterate,Filter,Cache)
+
+maxSolPts = 10;
+feasible  = iterate.h <= Filter.hmin;
+
+% FEASIBLE CASE: Update sorted list of 10 best feasible solutions
+if (feasible)
+    fvalues = [Cache.iterate(Filter.feasible).f];
+    ind = find(fvalues > iterate.f);
+    if (isempty(ind))
+        if (isempty(Filter.feasible)), Filter.feasible(1) = Cache.size; end
+    else
+        Filter.feasible = [Filter.feasible(1:ind(1)-1); Cache.size; ...
+                Filter.feasible(ind(1):end)];
+        Filter.feasible(maxSolPts:end) = [];
+    end
+    unfiltered = (Filter.feasible(1) == Cache.size);
+    return;
+end
+
+% INFEASIBLE CASE
+
+% Initialize hmax and test to see if point is unfiltered
+if (~Filter.strict && isempty(Filter.F))
+    hmax = 10*iterate.h;
+elseif (~Filter.strict && Cache.iterate(Filter.F(1)).h >= Filter.hmax)
+    hmax = 10*Cache.iterate(Filter.F(1)).h;
+else
+    hmax = Filter.hmax;
+end
+unfiltered = iterate.h<hmax && ~any(dominates(Cache.iterate(Filter.F),iterate));
+
+% Delete newly dominated points, add the unfiltered point, and replot
+if (unfiltered)
+    dominated  = dominates(iterate,Cache.iterate(Filter.F));
+    infeasible = [Cache.iterate(Filter.F).h] >= hmax;
+    Filter.F(dominated | infeasible) = [];
+    hvalues = [Cache.iterate(Filter.F).h];
+    ind     = find(hvalues > iterate.h);
+    if (isempty(ind))
+        Filter.F(end+1) = Cache.size;
+    else
+        Filter.F = [Filter.F(1:ind(1)-1), Cache.size, Filter.F(ind(1):end)];
+    end
+    if (Filter.plot), plotFilter(Filter,hmax,Cache.iterate,maxSolPts); end
+end
+return;
+
+%*******************************************************************************
+% dominates:  Determines if x dominates y with respect to .f and .h values.
+% ------------------------------------------------------------------------------
+% Called by: updateFilter
+% VARIABLES:
+%  d    = logicals indicating whether or not x dominates y
+%  x,y  = two iterates to be compared
+%    .f =   objective function value
+%    .h =   constraint violation function value
+%*******************************************************************************
+function d = dominates(x,y)
+d = ~([y.f] < [x.f] | [y.h] < [x.h]);
+return
+
+%*******************************************************************************
+% plotFilter:  Plot the filter.
+% ------------------------------------------------------------------------------
+% Called by: updateFilter, processInput
+% VARIABLES:
+%  Filter        = structure containing the filter
+%    .F          = sorted indices of Cache iterates in the filter
+%    .feasible   = sorted indices of feasible Cache iterates
+%    .hmax       = maximum allowed constraint violation of filter point
+%    .plothandle = plot handle
+%  hmax          = the filter hmax for the plot only
+%  Cache         = collection of all previously evaluated iterates
+%    .f          =   objective function value
+%    .h          =   constraint violation function value
+%  nPoints       = number of filter points to plot
+%  nFilter       = number of iterates in the filter
+%  nSolutions    = number of feasible solutions
+%  nPlot         = number of feasible solutions to plot
+%  feasible_f    = vector of f-values of feasible points to be plotted
+%  h             = vector of h-values of filter points to be plotted
+%  f             = vector of f-values of filter points to be plotted
+%  pctAxis       = percentage of extra space between axes and data
+%  ax            = plot axis parameters
+%*******************************************************************************
+function plotFilter(Filter,hmax,Cache,nPoints)
+
+if (isempty(Filter.F) || isempty(Filter.feasible)), return; end
+nSolutions = length(Filter.feasible);
+nPlot      = min(nPoints,nSolutions);
+
+% Create feasible solutions vector and filter vectors for plotting
+feasible_f = [Cache(Filter.feasible(:)).f];
+[h,f] = stairs([Cache(Filter.F).h],[Cache(Filter.F).f]);
+h = [h(1); h];
+f = [max(Cache(Filter.feasible(nPlot)).f,Cache(Filter.F(1)).f); f];
+h(end+1) = hmax;
+f(end+1) = f(end);
+
+% Create filter plot
+axes(Filter.plothandle);
+set([Filter.plothandle; get(Filter.plothandle,'Children')],'Visible','on');
+plot(h,f,'k-',zeros(nPlot,1),feasible_f(1:nPlot),'b*');
+pctAxis = 0.02;
+ax = axis;
+ax(1:2) = ax(1:2) + pctAxis*(ax(2)-ax(1))*[-1,1];
+ax(3:4) = ax(3:4) + pctAxis*(ax(4)-ax(3))*[-1,1];
+line([h(end),h(end)],[f(end) ax(3)]);
+axis(ax);
+title('Filter','FontWeight', 'bold', 'FontSize',11);
+xlabel('Constraint Violation, h(x)', 'FontSize',12);
+ylabel('Objective Function, f(x)  ', 'FontSize',12);
+drawnow;
+
+return;
+
+%*******************************************************************************
+% processOuput:  Process output and delete temporary files and variables.
+% ------------------------------------------------------------------------------
+% Called by: mads
+% Calls:     getPollCenter, plotHistory
+% VARIABLES:
+%  Cache           = structure containing previously evaluated iterates
+%    .Filter       =   structure containing filter data
+%      .hmin       =     minimum allowable h value to be in Filter.F
+%  BestF           = best feasible point found
+%  BestI           = least infeasible point found
+%  Problem         = structure containing optimization problem data
+%    .File.P       =   name of parameter file
+%    .nameCache    =   name of the base workspace Cache variable
+%  Options         = structure of MADS parameters
+%    .plotHistory1 =   flag for plotting f-value vs function evals
+%    .hplothandle  =   handle of the history plot
+%    .plotColor    =   string indicating color of history plot line
+%  Param           = structure of output from user-provided Parameter file
+%*******************************************************************************
+function [Cache,BestF,BestI] = processOutput(Problem,Options)
+
+% Close workspace environment
+Cache = closeWorkspace(Problem);
+
+% Plot performance history
+if (Options.plotHistory1)
+    plotHistory(Options.hplothandle,Options.plotColor,Cache);
+end
+
+% Store Best Solutions
+BestF = getPollCenter(0,Cache.Filter,Cache);
+BestI = getPollCenter(1,Cache.Filter,Cache);
+if (BestF.h > Cache.Filter.hmin), BestF = []; end
+if (BestI.h < Cache.Filter.hmin), BestI = []; end
+
+% For any post-processing, call parameter file with BestF as an argument
+if (exist(Problem.File.P,'file') == 2) && (nargin(Problem.File.P) < 0)
+    Param = feval(Problem.File.P,BestF);
+    setappdata(0,'PARAM',Param);
+end
+return
+
+%*******************************************************************************
+% closeWorkspace:  Shuts down base workspace appdata and deletes temp files.
+% ------------------------------------------------------------------------------
+% Called by: mads, ProcessOutput
+% VARIABLES:
+%  Cache           = structure containing previously evaluated iterates
+%  Problem         = structure containing optimization problem data
+%    .File.F       =   name of functions file
+%    .nameCache    =   name of the base workspace Cache variable
+%  surrName        = string used in constructing surrogate problem filename
+%*******************************************************************************
+function Cache = closeWorkspace(Problem)
+
+% Store Cache and delete all base workspace appdata
+Cache = getappdata(0,Problem.nameCache);
+if isappdata(0,Problem.nameCache), rmappdata(0,Problem.nameCache); end
+if isappdata(0,'SUR'),             rmappdata(0,'SUR');             end
+if isappdata(0,'PARAM'),           rmappdata(0,'PARAM');           end
+if isappdata(0,'P'),               rmappdata(0,'P');               end
+
+% Delete function files used in search and surrogate optimization
+lastwarn('');
+if exist('gaPenalty','file'),  delete('gaPenalty.m'); end
+if exist('SurObj','file'),     delete('SurObj.m'); end
+if exist('SurNLConst','file'), delete('SurNLConst.m'); end
+surrName = [Problem.File.F, '_Sur'];
+if exist(surrName,'file'),           delete([surrName,'.m']); end
+if exist([surrName,'_Cache'],'file'),delete([surrName,'_Cache.m']); end
+if ~isempty(lastwarn)
+    warning(['Search or surrogate file found but not deleted. \n', ...
+            'File may have been moved from its original location. \n', ...
+            'Please delete the file manually.'],[]);
+end
+return
+
+%*******************************************************************************
+% plotHistory:  Plot optimal value vs. number of function evaluations.
+% ------------------------------------------------------------------------------
+% Called by: update, ProcessOutput
+% VARIABLES:
+%  handle  = handle of the plot axes
+%  color   = string code indicating color/linestyle of plot line
+%  Cache   = Cache of previously computed iterates
+%    .bfp  =   vector of best feasible f-values
+%    .lip  =   vector of least infeasible f- and h-values
+%    .size =   number of iterates in the Cache
+%*******************************************************************************
+function plotHistory(handle,color,Cache)
+
+% Set up history plot axes handle
+if isempty(handle)
+    figure; handle = gca;
+end
+
+% Construct f plot using outside axes handle, if avaliable
+axes(handle);
+set([handle; get(handle,'Children')],'Visible','on');
+if (any(isfinite(Cache.bfp)))
+    plot(cumsum(Cache.nFunc(1:Cache.size),2), ...
+        Cache.bfp(1:Cache.size)',  [color,'-'],'LineWidth',2);
+else
+    plot(cumsum(Cache.nFunc(1:Cache.size),2),...
+        Cache.lip(1,1:Cache.size)',[color,'-'],'LineWidth',2);
+end
+title( 'Performance History', 'FontWeight','bold', 'FontSize',11);
+xlabel('Number of Function Evaluations',           'FontSize',12);
+ylabel('Objective Function Value  ',               'FontSize',12);
+drawnow;
+return;
+
+%*******************************************************************************
+% FUNCTIONS FOR STOCHASTIC PROBLEMS USING RANKING AND SELECTION (R&S)
+%*******************************************************************************
+%*******************************************************************************
+% evalRSPointSet:  Evaluate a set of R&S candidate points
+% ------------------------------------------------------------------------------
+%     This function evaluates iterates to determine if feasible or infeasible.
+%     If feasible, the feasible iterates are sent to be processed by RandSfeas;
+%     and infeasible points are processes locally.
+%     Code written by John Dunlap, Todd Sriver, and Mark Abramson
+% ------------------------------------------------------------------------------
+% Called by: evalPointSet
+% Calls:     updateOmega, inOmega, getpID, isCacheHit, evalFunction, 
+%            updateCache, updateFilter, RS
+% VARIABLES:
+%  P              = set of iterates with structure
+%    .x           =   vector of continuous variables 
+%    .p           =   cell array of categorical variables
+%    .f           =   function value
+%  rssuccess      = index of best trial point (0 = incumbent)
+%  Filter         = updated filter
+%    .feasible    =   indices of feasible iterates
+%    .hmin        =   minimum h-value of an infeasible point
+%  RSData         = structure of R&S parameters
+%    .s0          =   number of initial replications per point
+%    .iz          =   indifference zone parameter
+%    .alpha       =   significance level alpha parameter
+%    .nFuncLeft   =   number of function evaluations left before termination
+%    .F           =   storage of function values in F
+%  Problem        = structure containing problem parameters
+%    .adaptOmega  =   flag for changing Omega of an MVp problem
+%    .Omega       =   substructure that defines the feasible region
+%    .isMVP       =   flag indicating the problem being solved is an MVP problem
+%    .nameCache   =   name of the appdata holding the Cache
+%    .File.F      =   name of the functions file
+%    .fType       =   type of functions file (M=Matlab, F=Fotran, C=C/C++)
+%  Pset           = set of iterates to be evaluated 
+%  Options        = structure of user options
+%  add2sur        = flag for including point in surrogate construction
+%  feas           = vector of feasible iterates
+%  infeas         = vector of infeasible iterates
+%  nP             = number of points to be evaluated
+%  pID            = unique ID for a specific categorical variable value
+%  xnorm          = norm of the continuous variables
+%  Cache          = structure of previously computed iterates
+%    .isSurrPoint =   flags indicating if points are used to build surrogates
+%    .size        =   number of iterates in the Cache
+%  .nHits         =   number of Cache hits
+%  hit            = flag indicating a Cache hit (previous computed iterate)
+%  feasible       = flag indicating a point is feasible
+%  fRSsuccess     = flag indicating R&S success with a feasible point
+%  iRSsuccess     = flag indicating R&S success with an infeasible point
+%  nf             = number of function evaluations
+%  unfiltered     = flag indicating if current trial point is unfiltered
+%  iterate        = temporary storage of current trial point
+%*******************************************************************************
+function [P,rssuccess,Filter,RSData] = ...
+    evalRSPointSet(Problem,Pset,Options,Filter,RSData,add2sur)
+
+% Initialize output variables
+[P,feas,infeas] = deal([]);
+rssuccess = 0;
+
+% Evaluate each iterate, as appropriate
+nP = length(Pset);
+for k = 1:nP
+    
+    % update MVP Omega parameters, as is necessary
+    if Problem.adaptOmega
+        [Problem.Omega] = updateOmega(Problem,Options,Pset(k));
+    end
+    
+    % Test if iterate lies in Omega
+    if (inOmega(Pset(k),Problem.Omega))
+        
+        % Give trial point unique IDs to expedite Cache searching
+        pID = 0;
+        if Problem.isMVP
+            pID = getpID(Pset(k).p,Problem.Omega.plist);
+        end
+        xnorm = norm(Pset(k).x,inf);
+        
+        % Test to see if the iterate is in the Cache
+        Cache = getappdata(0,Problem.nameCache);
+        hit = isCacheHit(Cache,Pset(k),xnorm,pID,50000);
+        Cache.nHits = Cache.nHits + hit;
+        setappdata(0,Problem.nameCache,Cache);
+        
+        % Evaluate function
+        if (hit)
+            P = [P,Pset(k)];
+        else
+            Pset(k) = evalFunction(Problem.File.F,Problem.fType,Pset(k), 0);
+            feasible  = Pset(k).h <= Filter.hmin;    
+            if (feasible)
+                feas = [feas,Pset(k)];
+            else
+                infeas = [infeas,Pset(k)];
+            end
+        end
+    end
+end
+
+[feas,fRSsuccess,Filter,RSData] = RS(Problem,feas,Filter,RSData);
+
+% Update Cache and filter for feasible points
+if ~isempty(feas)
+    Cache = getappdata(0,Problem.nameCache);
+    for j = 1:length(feas)
+        pID = 0;
+        if Problem.isMVP
+            pID = getpID(feas(j).p,Problem.Omega.plist);
+        end
+        nf = feas(j).nFunc;
+        Cache = updateCache(Cache,Problem, rmfield(feas(j),'nFunc'), ...
+            norm(feas(j).x,inf),pID, nf);
+        setappdata(0,Problem.nameCache,Cache);
+        if (fRSsuccess == j)
+            [unfiltered,Filter] = updateFilter(feas(j),Filter,Cache);
+            if (add2sur == 2) || (add2sur == 1 && unfiltered)
+                Cache = getappdata(0,Problem.nameCache);
+                Cache.isSurrPoint(Cache.size) = 1;
+                setappdata(0,Problem.nameCache,Cache);
+            end
+        end 
+    end
+    P = [P,rmfield(feas,'nFunc')];
+end
+
+% Evaluate and average infeasible points, update Cache and filter
+iRSsuccess = 0;
+unfiltered = 0;
+if ~isempty(infeas)
+    for i = 1:length(infeas)
+        R(1,i) = infeas(i).f;
+        for j = 2:RSData.s0
+            iterate = evalFunction(Problem.File.F,Problem.fType,infeas(i), 0);
+            R(j,i) = iterate.f;
+        end
+        pID = 0;
+        if Problem.isMVP
+            pID = getpID(infeas(i).p,Problem.Omega.plist);
+        end
+        nf = RSData.s0;
+        infeas(i).f = mean(R(:,i));
+        Cache = getappdata(0,Problem.nameCache);
+        Cache = updateCache(Cache,Problem, infeas(i), ...
+            norm(infeas(i).x,inf),pID, nf);
+        setappdata(0,Problem.nameCache,Cache);
+        if isfinite(infeas(i).h)
+            [unfiltered,Filter] = updateFilter(infeas(i),Filter,Cache);
+            if unfiltered, iRSsuccess = 1; end
+            if (add2sur == 2) || (add2sur == 1 && unfiltered)
+                Cache = getappdata(0,Problem.nameCache);
+                Cache.isSurrPoint(Cache.size) = 1;
+                setappdata(0,Problem.nameCache,Cache);
+            end
+        end
+    end
+    P = [P,infeas];
+end
+rssuccess = (fRSsuccess || iRSsuccess);
+
+% Update R&S parameters
+RSData.iz    = RSData.iz    * RSData.iz_rho;   
+RSData.alpha = RSData.alpha * RSData.alpha_rho;
+return;
+
+%*******************************************************************************
+% RS:  Execute the Screen and Selection Ranking & Selection (R&S) procedure.
+% ------------------------------------------------------------------------------
+%      See Pichitlamken, J. and B. L. Nelson, 
+%      "Selection-of-the-best procedures for optimization via simulation",
+%      Proceedings of the 2001 Winter Simulation Conference, pp. 401 - 407
+%      Code written by John Dunlap, Todd Sriver,and Mark Abramson
+% ------------------------------------------------------------------------------
+% Called by: evalRSPointSet
+% VARIABLES:
+%  P              = set of iterates with structure
+%    .x           =   vector of continuous variables 
+%    .p           =   cell array of categorical variables
+%    .f           =   function value
+%  fRSsuccess     = index of best trial point (0 = incumbent)
+%  Filter         = updated filter
+%    .feasible    =   indices of feasible iterates
+%  RSData         = structure of R&S parameters
+%    .s0          =   number of initial replications per point
+%    .iz          =   indifference zone parameter
+%    .alpha       =   significance level alpha parameter
+%    .nFuncLeft   =   number of function evaluations left before termination
+%    .F           =   storage of function values in F
+%  Problem        = structure containing optimization problem parameters
+%  emptyFilter    = flag indicating if the current filter is empty
+%  nP             = number of points to be evaluated
+%  C              = temporary storage of the points to be evaluated
+%  Cache          = Cache of data containing all previous computed iterates
+%    .iterate     =   vector of iterates
+%    .nFunc       =   numbers of function evaluations for each iterate
+%  funcall        = number of function calls
+%  F              = matrix of function values, by point and replication
+%  nF             = number of points to be evaluated
+%  S              = matrix of variances of the differences between the responses
+%  lambda         = R&S parameter
+%  a              = temporary storage
+%  Nmax           = maximum number of replications required
+%  meanvalue      = matrix of indices, mean responses, # function evaluations
+%  ssmDone        = flag indicating termination criteria have been met
+%  s              = replication counter
+%  I              = indices of iterates still requiring more replications
+%  Iold           = storage of previous iterations I matrix
+%  R              = temporary storage of responses
+%  minR           = minimum value in R
+%*******************************************************************************
+function [P,fRSsuccess,Filter,RSData] = RS(Problem,P,Filter,RSData)
+
+fRSsuccess = 0;
+if (isempty(P)), return; end
+emptyFilter = isempty(Filter.feasible);
+
+% Set up candidate points and store incumbent data
+nP = length(P);
+if emptyFilter
+    [C(1:nP).x] = deal(P(1:nP).x);
+    [C(1:nP).p] = deal(P(1:nP).p);
+    [C(1:nP).f] = deal(P(1:nP).f);
+else
+    Cache = getappdata(0,Problem.nameCache);
+    C(1).x = Cache.iterate(Filter.feasible(1)).x;
+    C(1).p = Cache.iterate(Filter.feasible(1)).p;
+    C(1).f = Cache.iterate(Filter.feasible(1)).f;
+    [C(2:nP+1).x] = deal(P(1:nP).x);
+    [C(2:nP+1).p] = deal(P(1:nP).p);
+    [C(2:nP+1).f] = deal(P(1:nP).f);
+end
+funcall = nP;
+
+%------------- STEP 1: Initialization ---------------
+
+% Initially evaluate each candidate point
+F(1,:) = [C.f];
+nF = size(F,2);
+for i = 1:nF
+    if (i == 1) && (size(RSData.F,1) >= RSData.s0)
+        F(1:RSData.s0,1) = RSData.F(1:RSData.s0,1);
+    else
+        for j = 2:RSData.s0
+            iterate = evalFunction(Problem.File.F,Problem.fType,C(i), 0);
+            F(j,i)  = iterate.f;
+            funcall = funcall + 1;
+        end
+    end
+end
+
+% Store in S the variance for each candidate pair
+S = zeros(nF);
+for i = 1:nF
+    for j = 1:i-1
+        S(i,j) = var(F(:,i)-F(:,j));
+        S(j,i) = S(i,j);
+    end
+end
+
+% ------------ STEP 2: Procedure parameters --------------
+
+% Compute maximum number of replications required
+lambda = RSData.iz / 2;            %Lambda parameter recommended on pp. 403
+a = ((RSData.s0-1)*S / (4*(RSData.iz-lambda)))* ...
+    (((nF-1)/(2*(RSData.alpha)))^(2/(RSData.s0-1))-1);
+a = a - diag(diag(a));
+Nmax = max(max(floor(a/lambda)));
+
+% Set termination flag if initial sample was enough; otherwise, next stage
+meanvalue = [];           %Matrix to store indices, mean responses, & nFunc         
+if (RSData.s0 > Nmax)
+    meanvalue = [meanvalue; (1:nF)', mean(F,1)', RSData.s0*ones(nF,1)];
+    ssmDone = 1;
+else
+    s = RSData.s0;
+    I = (1:nF)';             % stores set of candidates still in play
+    ssmDone = 0;
+end
+
+% If reached max function calls
+if ((funcall >= RSData.nFuncLeft) && ~ssmDone)
+    meanvalue = [meanvalue; I, mean(F(:,I))', s*ones(nF,1)];
+    ssmDone = 1;
+end
+
+% Begin main loop
+while (~ssmDone)
+    
+    % ------------ STEP 3: Screening --------------
+    
+    Iold = I;
+    I = []; 
+    R = zeros(nF,1);
+    R(Iold) = R(Iold) + sum(F(:,Iold))';
+    
+    for i = 1:length(Iold)
+        minR = realmax;
+        if (R(Iold(i))==Inf)
+            meanvalue = [meanvalue; Iold(i), mean(F(:,Iold(i))), s];
+        else
+            for j = 1:length(Iold)
+                if (i ~= j)
+                    minR = min(minR, R(Iold(j)) + a(Iold(i),Iold(j)));
+                end
+            end
+            if (R(Iold(i)) <= minR - s*lambda) % Note:<= because minimization
+                I = [I ; Iold(i)];
+            else
+                meanvalue = [meanvalue; Iold(i), mean(F(:,Iold(i))), s];
+            end
+        end
+    end
+    
+    % ------------ STEP 4: Stopping Rule --------------
+    
+    if isempty(I)                           % I is empty
+        ssmDone = 1;
+    elseif (length(I) == 1)                 % Only one candidate left
+        ssmDone = 1;
+        meanvalue = [meanvalue; I(1), mean(F(:,I(1))), s];
+        
+        % Take new observation from screening survivors, check extra stopping rule
+    else
+        s = s + 1;
+        for i = 1:length(I)
+            if (I(i) == 1) && (size(RSData.F,1) >= s)
+                F(s,1) = RSData.F(s,1);
+            else
+                iterate = evalFunction(Problem.File.F,Problem.fType,C(i), 0);
+                F(s,I(i)) = iterate.f;
+                funcall = funcall + 1;
+            end
+        end
+        
+        % Terminate: enough samples have been taken or max function calls exceeded
+        if (s == Nmax + 1) || (funcall >= RSData.nFuncLeft)
+            meanvalue = [meanvalue; I, mean(F(:,I))', s*ones(length(I),1)];
+            ssmDone = 1;
+        end
+    end
+end
+
+% Sort meanvalue matrix by mean
+meanvalue = sortrows(meanvalue,2);
+
+if emptyFilter
+    for i = 1:size(meanvalue,1)
+        P(meanvalue(i,1)).f     = meanvalue(i,2);
+        P(meanvalue(i,1)).nFunc = meanvalue(i,3);
+    end
+    fRSsuccess = meanvalue(1,1);          % Stores the index of best candidate
+else
+    if (meanvalue(1,1) ~= 1)
+        fRSsuccess = (meanvalue(1,1)-1);
+    end
+    
+    % Store the average function value and number of function evaluations
+    for i = 1:size(meanvalue,1)
+        if (meanvalue(i,1) ~= 1)
+            P(meanvalue(i,1)-1).f     = meanvalue(i,2);
+            P(meanvalue(i,1)-1).nFunc = meanvalue(i,3);
+        end
+    end
+end
+
+% Replace incumbent
+if emptyFilter
+    RSData.F = F(1:meanvalue(1,3),meanvalue(1,1));  
+    
+    %Replaces current history based on the number of replications for new
+    %incumbent.  Since it is not changed outside this function, it must be
+    %updated here.
+elseif (meanvalue(1,1) ~= 1) 
+    RSData.F = F(1:meanvalue(1,3),meanvalue(1,1));  
+    if (meanvalue(1,1) ~= 1)
+        for i = 1:size(meanvalue,1)
+            if (meanvalue(i,1) == 1)
+                nf = meanvalue(i,3);
+                temp = meanvalue(i,2);
+            end
+        end
+        if (nf > Cache.nFunc(Filter.feasible(1)))      %Only replace if more
+            Cache = getappdata(0,Problem.nameCache);    %observations
+            Cache.nFunc(Filter.feasible(1)) = nf;
+            Cache.iterate(Filter.feasible(1)).f = temp;
+            setappdata(0,Problem.nameCache,Cache);
+        end
+    end
+    
+    % If more data is available for incumbent
+elseif (size(RSData.F,1) < size(F(:,meanvalue(1,1)),1))
+    Cache = getappdata(0,Problem.nameCache);
+    Cache.iterate(Filter.feasible(1)).f = meanvalue(1,2);
+    Cache.nFunc(Filter.feasible(1)) = meanvalue(1,3);
+    setappdata(0,Problem.nameCache,Cache);
+    RSData.F = F(1:meanvalue(1,3),meanvalue(1,1));
+end
+return
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/mads_batch.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/mads_batch.m
new file mode 100644
index 0000000000000000000000000000000000000000..962cbba1336bceaec2c7c6ddea6001b8e52a6c48
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/mads_batch.m
@@ -0,0 +1,185 @@
+function [BestF,BestI,RunStats,RunSet] = mads_batch(problem_path,tol_nomad,nvar,nconst,iterprint)
+%MADS_BATCH  Sets up and runs the MADS algorithm without a GUI.
+%
+%   Syntax:
+%      mads_batch
+%
+%   Description:
+%      This function serves as a GUI-free alternative to NOMADm in setting
+%      up an optimization problem, setting various algorithm parameters and
+%      user options, and calling the MADS optimizer.  It first sets all of the
+%      variables to their default values, which are clearly stated in the
+%      MADS_DEFAULTS file.  To change a variable from its default value, the
+%      user must add a statement to this file to do so.  Some variable
+%      statements are included here for convenience, which can be change
+%      manually.
+%
+%   See also MADS_DEFAULTS, MADS
+
+%*******************************************************************************
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   This file is part of the NOMADm software package.
+%
+%   NOMADm is free software; you can redistribute it and/or modify it under the
+%   terms of the GNU General Public License as published by the Free Software
+%   Foundation; either version 2 of the License, or (at your option) any later
+%   version.
+%
+%   NOMADm is distributed in the hope that it will be useful, but WITHOUT ANY
+%   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+%   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+%   details.
+%
+%   You should have received a copy of the GNU General Public License along
+%   with NOMADm; if not, write to the Free Software Foundation, Inc., 
+%   59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% ------------------------------------------------------------------------------
+%   Originally created, 2001.
+%   Last modified, 31 January 2005
+%
+%   Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%*******************************************************************************
+
+%*******************************************************************************
+% mads_batch:  Runs MADS in batch mode.
+% ------------------------------------------------------------------------------
+% Calls:     mads_defaults, mads, < user initial points file >
+% Variables:
+%  Defaults    = structure of MADS default values (see mads_defaults)
+%  Options     = structure for options settings (see mads_defaults)
+%  problemPath = location of user problem files
+%  Problem     = structure of data for optimization problem
+%  newPath     = logical indicating if path is not the Matlab path
+%  iterate0    = structure of data for the initial iterate (see mads)
+%  BestF       = final best feasible solution found
+%  BestI       = final least infeasible solution found
+%  RunStats    = structure of MADS Run statistics (see mads)
+%*******************************************************************************
+
+% Set Options to their default values
+%clear variables
+Defaults = mads_defaults('Truth');
+Options  = Defaults.Options;
+Problem.nameCache = 'CACHE';
+
+%*******************************************************************************
+% MODIFY ONLY AFTER THIS POINT
+%*******************************************************************************
+
+% Specify Problem Files
+problemPath=problem_path;
+
+
+Problem.File.F = 'fobj_nomad';           % functions file
+Problem.File.O = 'fobj_nomad_Omega';     % Omega file (linear constraints)
+Problem.File.I = 'fobj_nomad_x0';        % initial Points file
+Problem.File.N = 'fobj_nomad_N';         % discrete neighbor file (MVP only)
+Problem.File.C = 'fobj_nomad_cache.mat'; % previously created Cache file
+Problem.File.P = 'fobj_nomad_Param';     % previously created Session file
+Problem.fType  = 'M';                   % type of Functions file {M,F,C}
+Problem.nc     = 0;                     % number of nonlinear constraints
+
+
+% Specify Choices for SEARCH
+Options.Search(1).type    = 'None';      % For choices, see mads_defaults
+Options.Search(1).nIter   = 0;           % Number of iterations for Search #1
+Options.Search(1).nPoints = 0;           % Number of poll or sample points
+Options.Search(1).file    = '';          % filename must include the full path
+Options.Search(1).local   = 0;           % flag to turn on trust region
+Options.Search(1).merit   = 0;           % flag to penalize clustered data
+Options.Search(2).type    = 'None';      % For choices, see mads_defaults
+Options.Search(2).nIter   = Inf;         % Number of iterations for Search #2
+Options.Search(2).nPoints = 0;           % Number of poll or sample points
+Options.Search(2).file    = '';          % filename must include the full path
+Options.Search(2).local   = 0;           % flag to turn on trust region
+Options.Search(2).merit   = 0;           % flag to penalize clustered data
+Options.nSearches = length(Options.Search);
+Options.SurOptimizer      = 'fmincon';
+
+% Specify Choices for POLL
+Options.pollStrategy    = 'Standard_2n'; % For choices, see mads_defaults
+Options.pollOrder       = 'Consecutive'; % For choices, see mads_defaults
+Options.pollCenter      = 0;             % Poll around n-th filter point
+Options.pollComplete    = 0;             % Flag for complete polling
+
+% Specify Termination Criteria
+
+%==========================================================================
+%JAE 09/05/07
+Options.Term.delta      = tol_nomad;      %mesh size
+%==========================================================================
+Options.Term.nIter      = Inf;           % maximum number of iterations
+Options.Term.nFunc      = 100*nvar;         % maximum number of function evals
+Options.Term.time       = Inf;           % maximum CPU time
+Options.Term.nFails     = Inf;           % max number of consecutive Poll fails
+
+% Choices for Mesh Control
+Options.delta0          = 1.0;           % initial mesh size
+Options.deltaMax        = Inf;           % bound on how coarse the mesh can get
+Options.meshRefine      = 0.5;           % mesh refinement factor
+Options.meshCoarsen     = 2.0;           % mesh coarsening factor
+
+% Choices for Filter management (for problems with nonlinear constraints)
+if ~nconst, nconst=1; end
+Options.hmin            = nconst*tol_nomad*tol_nomad;          % minimum infeasible point h-value
+%Options.hmin            =  1e-5;          % minimum
+%infeasible point h-value
+Options.hmax            = 1.0;           % maximum h-value of a filter point
+
+% Choices for EXTENDED POLL (for MVP problems)
+Options.ePollTriggerF   = 0.01;          % f-value Extended Poll trigger
+Options.ePollTriggerH   = 0.01;          % h-value Extended Poll trigger
+
+% MADS flag parameter values
+Options.loadCache        = 1;            % load pre-existing Cache file
+Options.countCache       = 1;            % count Cache points as function calls
+Options.runStochastic    = 0;            % runs problem as a stochastic problem
+Options.removeRedundancy = 1;            % discard redundant linear constraints
+Options.scale            = 2;            % scale directions using this log base
+Options.computeGrad      = 0;            % compute gradient, if available
+Options.plotFilter       = 0;            % plot the filter real-time
+
+%==========================================================================
+%JAE 26/08/05
+if iterprint
+    Options.plotHistory1     = 1;            % plot MADS performance 
+    Options.plotHistory2     = 1;            % plot MADS performance real-time
+else
+    Options.plotHistory1     = 0;            % plot MADS performance 
+    Options.plotHistory2     = 0;            % plot MADS performance real-time
+end
+%==========================================================================
+    
+Options.plotColor        = 'k';          % color of history plot
+
+%*******************************************************************************
+% DO NOT MODIFY AFTER THIS POINT
+%*******************************************************************************
+
+% Set up figure handles for real-time plots
+if (Problem.nc == 0)
+   Options.plotFilter = 0;
+end
+if (Options.plotFilter)
+   figure;
+   Options.fplothandle = gca;
+end
+if (Options.plotHistory2)
+   figure;
+   Options.hplothandle = gca;
+end
+% Set the path, get the initial iterates, call the optimizer
+newPath = isempty(strfind(upper(path),upper(problemPath)));
+addpath(problemPath);
+iterate0 = feval(Problem.File.I);
+[BestF,BestI,RunStats,RunSet] = mads(Problem,iterate0,Options);
+if newPath, rmpath(problemPath); end
+return
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/mads_defaults.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/mads_defaults.m
new file mode 100644
index 0000000000000000000000000000000000000000..784e7db6c96427602b16a00824d96c2d7a5dd1ee
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/mads_defaults.m
@@ -0,0 +1,435 @@
+function Defaults = mads_defaults(varargin)
+%MADS_DEFAULTS  Set default values for MADS parameters and options.
+%
+%   Syntax:
+%      DEFAULTS = mads_defaults(TYPEPROBLEM)
+%
+%   Description:
+%      MADS_DEFAULTS assigns default values for all variables passed into the
+%      MADS optimizer.  It stores these values in a structure named DEFAULTS.
+%      This function is called by several different NOMADm functions.
+%      TYPEPROBLEM is a string that is set to either "Truth" or "Surrogate",
+%      the former being used in almost all cases.  The only time "Surrogate" is
+%      used is when the MADS optimizer is called within its own search function
+%      to optimize a surrogate problem.
+%
+%   Note:
+%      It is strongly recommended that these variables not be edited, as it is
+%      the only place where these defaults are set.  This function is not meant
+%      to be run independently.
+%
+%   See also MADS, MADS_BATCH, NOMADM
+
+%*******************************************************************************
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   This file is part of the NOMADm software package.
+%
+%   NOMADm is free software; you can redistribute it and/or modify it under the
+%   terms of the GNU General Public License as published by the Free Software
+%   Foundation; either version 2 of the License, or (at your option) any later
+%   version.
+%
+%   NOMADm is distributed in the hope that it will be useful, but WITHOUT ANY
+%   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+%   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+%   details.
+%
+%   You should have received a copy of the GNU General Public License along with
+%   NOMADm; if not, write to the Free Software Foundation, Inc., 
+%   59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% ------------------------------------------------------------------------------
+%   Originally created, 2001.
+%   Last modified, 31 January 2005
+%
+%   Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%*******************************************************************************
+
+%*******************************************************************************
+% madsDefaults:  Sets default values for most of the MADS parameters
+% ------------------------------------------------------------------------------
+% Called by: NOMADm, nomadm_functions, mads, madsBatch
+% VARIABLES:
+%  Defaults            = structure containing all the default values
+%  Labels              = Long text labels for Search and Poll parameters
+%    .file             =   labels for types of user files
+%    .search           =   labels for types of Searches
+%    .daceRegression   =   labels for types of DACE regression functions
+%    .daceCorrelation  =   labels for types of DACE correlation functions
+%    .nwKernel         =   labels for types of Nadaraya-Watson kernel functions
+%    .pollStrategy     =   labels for types of Poll strategies
+%    .pollOrder        =   labels for types of Poll order strategies
+%    .pollCenter       =   labels for types of Poll centers
+%    .Parameters       =   labels for MADS parameters
+%      .mesh           =     labels for mesh parameters
+%      .term           =     labels for termination criteria parameters
+%      .other          =     labels for other MADS parameters
+%      .RS             =     labels for ranking and selection parameters
+%  Types               = Short text codes for Search and Poll choices
+%    .file             =   types of user files
+%    .search           =   types of Searches
+%    .daceRegression   =   types of DACE regression functions
+%    .daceCorrelation  =   types of DACE correlation functions
+%    .nwKernel         =   types of Nadaraya-Watson kernel functions
+%    .pollStrategy     =   types of Poll strategies
+%    .pollOrder        =   types of Poll order strategies
+%  FileExt             = string file name suffixes
+%    .F                =   functions file suffix
+%    .O                =   Omega file suffix
+%    .I                =   initial points file suffix
+%    .N                =   discrete neighbor file suffix
+%    .P                =   user parameter file suffix
+%    .C                =   cache file suffix
+%    .S                =   session file suffix
+%  maxSearches         = maximum number of different Search types in a run
+%  Choice              = integer choices of allowable strategies
+%    .search           =   choice of Search type 
+%    .daceReg          =   choice of DACE regression function
+%    .daceCorr         =   choice of DACE correlation function
+%    .pollStrategy     =   choice of Poll strategy
+%    .pollOrder        =   choice of Poll order strategy
+%    .pollCenter       =   choice of Poll center
+%  Options             = Values for the MADS Options structure
+%    .nSearches        =   number of different Search types used
+%    .Search           =   Search parameters
+%    .dace             =   DACE parameters
+%      .reg            =     regression function handle 
+%      .corr           =     correlation function handle
+%      .theta          =     initial guess of the theta fitting parameter
+%      .lower          =     lower bound for the theta parameter
+%      .upper          =     upper bound for the theta parameter
+%      .isotropic      =     flag indicating isotropic theta values
+%    .nw               =   NW parameters
+%      .kernel         =     string name of NW kernel function 
+%      .sigma          =     initial guess of the sigma fitting parameter
+%      .lower          =     lower bound for the sigma parameter
+%      .upper          =     upper bound for the sigma parameter
+%    .pollStrategy     =   short text code for default Poll strategy
+%    .pollOrder        =   short text code for default Poll order
+%    .pollCenter       =   numeric code for default choice of Poll center
+%    .pollComplete     =   turns on/off complete Polling
+%    .SurOptimizer     =   string identifying the surrogate optimizer
+%    .Term             =   values for termination criteria
+%      .delta          =     minimum mesh size
+%      .nIter          =     maximum number of iterations
+%      .nFunc          =     maximum number of function evaluations
+%      .time           =     maximum CPU time
+%      .nFails         =     maximum number of consecutive Poll failures
+%    .TermFlag         =   flags to turn on/off termination criteria
+%      .nIter          =     turns on/off number of iterations
+%      .nFunc          =     turns on/off number of function evaluations
+%      .time           =     turns on/off CPU time
+%      .nFails         =     turns on/off number of consecutive Poll failures
+%    .loadCache        =   turns on/off loading of a pre-existing Cache
+%    .countCache       =   flag for counting Cache points as function calls
+%    .useFilter        =   turns on/off filter for nonlinear constraints
+%    .removeRedundancy =   removes redundant linear constraints
+%    .accelerate       =   flag for accelerating mesh refinement
+%    .scale            =   base for logarithmic scaling (0 = no scaling)
+%    .plotFilter       =   turns on/off real-time filter plot
+%    .plotHistory1     =   turns on/off history plot
+%    .plotHistory2     =   turns on/off real-time history plot
+%    .delta0           =   initial mesh size
+%    .deltaMax         =   maximum mesh size
+%    .meshRefine       =   mesh refinement factor
+%    .meshCoarsen      =   mesh coarsening factor
+%    .tolCache         =   tolerance for ID-ing points already in Cache
+%    .hmin             =   minimum h-value of an infeasible point
+%    .hmax             =   maximum h-value of a filter point
+%    .ePollTriggerF    =   f-value Extended Poll trigger
+%    .ePollTriggerH    =   h-value Extended Poll trigger
+%    .runOneIteration  =   flag for running MADS one iteration at a time
+%    .runUntilFeasible =   flag for running MADS only unitl feasible
+%    .runCount         =   run counter
+%    .TermRel          =   flag for multiplying Term.delta by initial delta
+%    .tolBind          =   tolerance for ID-ing active linear constraints
+%    .RS               =   structure of ranking & selection options
+%      .s0             =     initial sample size
+%      .iz_const       =     initial value of the indifference zone parameter
+%      .iz_rho         =     decay rate of the indifference zone parameter
+%      .alpha_const    =     initial value of the alpha parameter
+%      .alpha_rho      =     decay rate of the alpha parameter
+%    .hplothandle      =   handle for history plot axes
+%    .fplothandle      =   handle for filter plot axes
+%    .stophandle       =   handle for Stop Run pushbutton
+%  Sur                 = structure with the same fields as Defaults.Options
+%  typeProblem         = string ID: "Truth" or "Surrogate"
+%*******************************************************************************
+
+% Labels for Search, Poll, and MADS Parameters
+Labels.file             = {'Functions'; 'Initial Points'; 'Linear Constraints';
+                           'Neighbors'; 'Parameter'};
+Labels.scale            = {'No Scaling';
+                           'Logarithmic Base-2 Scaling';
+                           'Logarithmic Base-10 Scaling'};
+Labels.search           = {'None';
+                           'Latin Hypercube Sampling';
+                           'Deterministic Sampling on coarse mesh';
+                           'Genetic Algorithm';
+                           'Standard Poll around first N filter points';
+                           'Complete Poll around first N filter points';
+                           'Gradient Poll around first N filter points';
+                           'Nadaraya-Watson Surrogate';
+                           'DACE Toolbox Surrogate';
+                           'Custom Search Function';
+                           'Custom Surrogate Function'};
+Labels.daceRegression   = {'Zero Order Polynomial';
+                           'First Order Polynomial';
+                           'Second Order Polynomial'};
+Labels.daceCorrelation  = {'Exponential';
+                           'General Exponential';
+                           'Gaussian';
+                           'Local Support, Linear';
+                           'Local Support, Spherical';
+                           'Local support, Cubic Polynomial';
+                           'Local Support, Cubic Spline'};
+Labels.nwKernel         = {'Gaussian';
+                           'Uniform';
+                           'Triangle';
+                           'Epanechnikov';
+                           'Quartic';
+                           'Tri-weight';
+                           'Cosinus'};
+Labels.optimizer        = {'FMINCON (MATLAB Optimization Toolbox)';
+                           'MADS';
+                           'CMA-ES (Genetic Algorithm)';
+                           'Custom'};
+Labels.pollStrategy     = {'Standard 2n e-directions';
+                           'Standard n+1 directions';
+                           'Custom 2n directions';
+                           'Custom n+1 directions';
+                           'MADS Random 2n directions';
+                           'MADS Random n+1 directions';
+                           'Gradient-pruned 2n e-directions';
+                           'Gradient-pruned n+1 directions';
+                           'Gradient-pruned 3^n using L-1 gradient';
+                           'Gradient-pruned 3^n using L-2 gradient';
+                           'Gradient-pruned 3^n using L-Inf gradient';
+                           'Gradient-pruned 3^n Descent Vectors'};
+Labels.pollOrder        = {'Consecutive';
+                           'Alternating';
+                           'Random';
+                           'Dynamic';
+                           'Dynamic Ranked';
+                           'Surrogate Ranked';
+                           'Custom'};
+Labels.pollCenter       = {'Best Feasible Point';
+                           'Least Infeasible Point';
+                           '2nd Least Infeasible Filter Point';
+                           '3rd Least Infeasible Filter Point';
+                           '4th Least Infeasible Filter Point';
+                           '5th Least Infeasible Filter Point'};
+Labels.Parameters.term  = {'Convergence Tolerance (Mesh Size):';
+                           'Maximum Number of Iterations:';
+                           'Maximum Number of Function Calls:';
+                           'Maximum CPU Time:';
+                           'Maximum Number of Consecutive Poll Failures:'};
+Labels.Parameters.mesh  = {'Initial Mesh Size:';
+                           'Maximum Mesh Size:';
+                           'Mesh Refinement Factor:';
+                           'Mesh Coarsening Factor:';
+                           'Cache Tolerance'};
+Labels.Parameters.other = {'Minimum Filter Constraint Violation:';
+                           'Maximum Filter Constraint Violation:';
+                           'MVP Objective Extended Poll Trigger:';
+                           'MVP Constraints Extended Poll Trigger:'};
+Labels.Parameters.RS    = {'R&S Initial Sample Size:';
+                           'R&S Initial Alpha Parameter:';
+                           'R&S Initial Indifference Zone Parameter:';
+                           'R&S Alpha Decay Factor:';
+                           'R&S Indifference Zone Decay Factor:'};
+Labels.coolCats         = {'Charles Audet','Keith Berrier','Olga Brezhneva',...
+                           'Gilles Couture','John Dennis','Thierry Dalon', ...
+                           'John Dunlap','Alison Marsden',...
+                           'Jacob Sondergaard','Todd Sriver'};
+
+% Names of help files 
+HelpDoc = struct('nomadm', 'nomadm_help.pdf', ...
+                 'dace',   'dace.pdf',        ...
+                 'nw',     'nw_help.pdf',     ...
+                 'cmaes',  'es_READ.ME',      ...
+                 'changes','nomadm.txt',      ...
+                 'license','gpl.txt');
+
+% Short text codes for Search, DACE Surrogates, and Poll parameters
+Types.file      = {'','_x0','_Omega','_N','_Param'};
+Types.search    = {'None','LHS','Mesh','GA','SPollI','CompI','GPollI', ...
+                   'NW','DACE','Custom','CustomS'};
+Types.daceReg   = {'regpoly0','regpoly1','regpoly2'};
+Types.daceCorr  = {'correxp','correxpg','corrgauss','corrlin',...
+                   'corrspherical','corrcubic','corrspline'};
+Types.nwKernel  = {'gaussian','uniform','triangle','Epanechnikov','quartic', ...
+                   'triweight','cosinus'};
+Types.optimizer = {'fmincon','mads','cmaes','custom'};
+Types.poll      = {'Standard_2n',     'Standard_n+1',   ...
+                   'Custom_2n',       'Custom_n+1',     ...
+                   'MADS_2n',         'MADS_n+1',       ...
+                   'Gradient_2n',     'Gradient_n+1',   ...
+                   'Gradient_3n_L1',  'Gradient_3n_L2', ...
+                   'Gradient_3n_LInf','Gradient_3n2n'};
+Types.pollOrder = {'Consecutive','Alternating','Random',...
+                   'Dynamic','DynamicRanked','Surrogate','Custom'};
+Types.plotColors = 'kbrmgkbrmg';
+
+% File Extentions
+FileExt.F = '';
+FileExt.O = '_Omega';
+FileExt.I = '_x0';
+FileExt.N = '_N';
+FileExt.P = '_Param';
+FileExt.C = '_Cache.mat';
+FileExt.S = '_Session.mat';
+
+% Choices for Search and Poll
+maxSearches = 8;
+Options.nSearches = 2;
+Choice.optimizer = 1;
+Options.SurOptimizer = Types.optimizer{Choice.optimizer};
+for k = 1:maxSearches
+   Choice.search(k)          = 1;
+   Choice.daceReg(k)         = 1;
+   Choice.daceCorr(k)        = 3;
+   Choice.nwKernel(k)        = 1;
+   Options.Search(k).type    = Types.search{Choice.search(k)};
+   Options.Search(k).label   = Labels.search{Choice.search(k)};
+   Options.Search(k).nIter   = 1;
+   Options.Search(k).nPoints = 1;
+   Options.Search(k).file    = '';
+   Options.Search(k).local   = 0;
+   Options.Search(k).merit   = 0;
+   Options.dace(k).reg       = Types.daceReg{Choice.daceReg(k)};
+   Options.dace(k).corr      = Types.daceCorr{Choice.daceCorr(k)};
+   Options.dace(k).theta     = 10;
+   Options.dace(k).lower     = 0.1;
+   Options.dace(k).upper     = 100000;
+   Options.dace(k).isotropic = 0;
+   Options.nw(k).kernel      = Types.nwKernel{Choice.nwKernel(k)};
+   Options.nw(k).sigma       = 0.5;
+   Options.nw(k).lower       = 0.1;
+   Options.nw(k).upper       = 3;
+end
+Options.Search(Options.nSearches).nIter = Inf;
+Choice.pollStrategy  = 1;
+Choice.pollOrder     = 1;
+Choice.pollCenter    = 1;
+Options.pollStrategy = Types.poll{Choice.pollStrategy};  
+Options.pollOrder    = Types.pollOrder{Choice.pollOrder};
+Options.pollCenter   = Choice.pollCenter - 1;
+Options.pollComplete = 0;
+
+% MADS Parameter Values
+Options.Term.delta        = 1e-4;
+Options.Term.nIter        = 1000;
+Options.Term.nFunc        = 50000;
+Options.Term.time         = 3600;
+Options.Term.nFails       = 50;
+Options.TermFlag.delta    = 1;
+Options.TermFlag.nIter    = 0;
+Options.TermFlag.nFunc    = 1;
+Options.TermFlag.time     = 0;
+Options.TermFlag.nFails   = 0;
+Options.TermFlag.relative = 0;
+Options.loadCache         = 1;
+Options.countCache        = 1;
+Options.useFilter         = 1;
+Options.removeRedundancy  = 1;
+Options.runStochastic     = 0;
+Options.accelerate        = 0;
+Options.scale             = 2;   % Base of logarithmic scaling (0 = none)
+Options.plotFilter        = 1;
+Options.plotHistory1      = 1;
+Options.plotHistory2      = 0;
+Options.plotColor         = Types.plotColors(1);
+Options.delta0            = 1.0;
+Options.deltaMax          = Inf;
+Options.meshRefine        = 0.5;
+Options.meshCoarsen       = 2.0;
+Options.tolCache          = Options.Term.delta;
+Options.hmin              = 1e-4;
+Options.hmax              = 1.0;
+Options.ePollTriggerF     = 0.01;
+Options.ePollTriggerH     = 0.05;
+Options.runOneIteration   = 0;
+Options.runUntilFeasible  = 0;
+Options.tolBind           = sqrt(Options.Term.delta);
+
+% R&S options
+Options.RS.s0            = 5;
+Options.RS.iz_const      = 100;
+Options.RS.iz_rho        = 0.95;
+Options.RS.alpha_const   = 0.80;
+Options.RS.alpha_rho     = 0.95;
+
+% Plot handles
+Options.hplothandle = [];
+Options.fplothandle = [];
+Options.stophandle  = [];
+
+% Surrogate defaults
+Sur.Options = Options;
+Sur.Options.nSearches         = 0;
+Sur.Options.Search            = [];
+Sur.Options.pollStrategy      = 'MADS_2n';
+Sur.Options.pollOrder         = 'Consecutive';
+Sur.Options.pollCenter        = 0;
+Sur.Options.pollComplete      = 0;
+Sur.Options.Term.delta        = 1e-4;
+Sur.Options.Term.nIter        = Inf;
+Sur.Options.Term.nFunc        = Inf;
+Sur.Options.Term.time         = Inf;
+Sur.Options.Term.nFails       = Inf;
+Sur.Options.TermFlag.delta    = 1;
+Sur.Options.TermFlag.nIter    = 0;
+Sur.Options.TermFlag.nFunc    = 0;
+Sur.Options.TermFlag.time     = 0;
+Sur.Options.TermFlag.nFails   = 0;
+Sur.Options.TermFlag.relative = 0;
+Sur.Options.loadCache         = 0;
+Sur.Options.countCache        = 0;
+Sur.Options.plotFilter        = 0;
+Sur.Options.plotHistory1      = 0;
+Sur.Options.plotHistory2      = 0;
+Sur.Options.delta0            = 1.0;
+Sur.Options.deltaMax          = Inf;
+Sur.Options.ePollTriggerF     = 0.01;
+Sur.Options.ePollTriggerH     = 0.05;
+Sur.Options.runOneIteration   = 0;
+Sur.Options.runUntilFeasible  = 0;
+Sur.Options.useFilter         = 0;
+Sur.Options.tolBind           = sqrt(Sur.Options.Term.delta);
+Sur.Options.tolCache          = Sur.Options.Term.delta;
+
+% Construct Default structure
+Defaults.Labels      = Labels;
+Defaults.Types       = Types;
+Defaults.FileExt     = FileExt;
+Defaults.Choice      = Choice;
+Defaults.HelpDoc     = HelpDoc;
+Defaults.maxSearches = maxSearches;
+
+% Determine if a "Truth" or "Surrogate" function is to be optimized 
+if nargin > 0,
+   typeProblem = varargin{1};
+else
+   typeProblem = 'Truth';
+end
+
+% Assign either Truth or Surrogate default values
+switch typeProblem
+case 'Truth'
+   Defaults.Options   = Options;
+   Defaults.nameCache = 'CACHE';
+case 'Surrogate'
+   Defaults.Options   = Sur.Options;
+   Defaults.nameCache = 'sCACHE';
+otherwise
+   error('Bad argument for mads_defaults: Must be "Truth" or "Surrogate"');
+end
+return
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm.m
new file mode 100644
index 0000000000000000000000000000000000000000..1d72ae1079a884dcba39ee7256a878c7849bb30b
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm.m
@@ -0,0 +1,3219 @@
+function nomadm
+%NOMADM   Execute the NOMADm graphic user interface (GUI).
+%
+%   Syntax:
+%      nomadm
+%
+%   Description:
+%      NOMADM launches the NOMADm GUI, which controls the setup of an
+%      optimization problem, setting of various algorithm parameters and
+%      options, running of the MADS algorithm for numerically solving the
+%      optimization problem, and viewing results.
+%
+%   See also MADS, MADS_BATCH, MADS_DEFAULTS, NOMADM_COMPILE
+
+%*******************************************************************************
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   This file is part of the NOMADm software package.
+%
+%   NOMADm is free software; you can redistribute it and/or modify it under the
+%   terms of the GNU General Public License as published by the Free Software
+%   Foundation; either version 2 of the License, or (at your option) any later
+%   version.
+%
+%   NOMADm is distributed in the hope that it will be useful, but WITHOUT ANY
+%   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+%   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+%   details.
+%
+%   You should have received a copy of the GNU General Public License along with
+%   NOMADm; if not, write to the Free Software Foundation, Inc., 
+%   59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% ------------------------------------------------------------------------------
+%   Originally created, 2001.
+%   Last modified, 2 February 2005
+%
+%   Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%*******************************************************************************
+
+%*******************************************************************************
+% nomadm: Runs the NOMADm user interface and associated callback functions.
+% ------------------------------------------------------------------------------
+% CALLED FUNCTIONS:
+%  nomadm_gui             = Launches the NOMADm GUI.
+%    selectProblem        =   Choose an optimization problem (CB)
+%    editFile             =   Edit a user file (CB)
+%    quitGUI              =   Close the GUI and quit the program (CB)
+%    editParameters       =   Change certain MADS parameter values (CB)
+%    selectPoll           =   Select Poll strategy, center, or order (CB)
+%    loadSession          =   Load user options from file (CB)
+%    resetSession         =   Reset parameters to default values (CB)
+%    saveSession          =   Save user options to file (CB)
+%    saveCache            =   Save the Cache to file for later use (CB)
+%    deleteFile           =   Delete a Cache or Session file (CB)
+%    clearRuns            =   Clears all data from with previous runs (CB)
+%    getHelp              =   View a help file (CB)
+%    getAbout             =   View information about this software (CB)
+%    copyPlot             =   Copy a plot to its own window (BD)
+%    runMADS              =   Run the MADS optimizer (CB)
+%      loadMADS           =     Transfer GUI values to MADS variables
+%    search_gui           =   Launch the Search screen GUI
+%      modifySearchScreen =     Change appearance of the Search screen (CB)
+%      loadUserSearchFile =     Load a user-specified Search file (CB)
+%      loadSearchOptions  =     Load user Search step choices (CB)
+%    dace_gui             =   Launch the DACE figure window
+%      loadDACEOptions    =     Load user DACE options (CB)
+%    nw_gui               =   Launch the NW figure window (CB)
+%      loadNWOptions      =     Load user NW options (CB)
+%    updateScreen         =   Update contents of the NOMADm figure window
+%      updateSearchLabels =     Update Search labels on the NOMADm window
+%    results_gui          =   Launch Results GUI, view results of run (CB)
+%      solution_gui       =     Launch Solution GUI, view solution (CB)
+%        changeView       =       Change view of page with Previous/Next buttons
+% ------------------------------------------------------------------------------
+% VARIABLES (only for the nomadm function):
+%  h                  = handle of pre-existing NOMADm figure window
+%  gui_var            = structure of all GUI variables
+%    .version         =   Version number for this software
+%    .path            =   Current path of the optimization problem files
+%    .newPath         =   flag for new path not already on the Matlab path
+%    .runCount        =   current MADS run number
+%    .runMax          =   maximum allowed MADS run number
+%    .noGrad          =   flag indicating initial availability of gradients
+%    .Defaults        =   substructure of parameter default values
+%    .Labels          =   substructure of NOMADm menu labels
+%    .Types           =   substructure of NOMADm types 
+%    .FileExt         =   substructure of possible file extensions
+%    .HelpDoc         =   substructure of help file names
+%    .maxSearches     =   maximum allowable number of Search types used
+%    .nameCache       =   name of the Cache that is saved as appdata
+%  guiFunction        = cell array of NOMADm function handle names
+%  gui_func           = sructure of handles for all NOMADm functions
+%  gui                = structure of GUI object handles
+%    .fig             =   handle for the main figure window
+%*******************************************************************************
+
+% Before launching the NOMADm GUI, make sure it is not already running
+h = findobj(0,'type','Figure','Tag','NOMADm_GUI');
+if ~isempty(h)
+   disp('Only one NOMADm window may run at a time');
+   figure(h);
+   return
+end
+
+% Declare basic GUI variables
+gui_var.newMatlab   = str2num(version('-release')) > 12;
+gui_var.version     = '3.3';
+gui_var.path        = '';
+gui_var.newPath     = 0;
+gui_var.runCount    = 0;
+gui_var.runMax      = 10;
+gui_var.noGrad      = 1;
+
+% Set up default values
+gui_var.Defaults    = mads_defaults('Truth');
+gui_var.Labels      = gui_var.Defaults.Labels;
+gui_var.Types       = gui_var.Defaults.Types;
+gui_var.FileExt     = gui_var.Defaults.FileExt;
+gui_var.HelpDoc     = gui_var.Defaults.HelpDoc;
+gui_var.maxSearches = gui_var.Defaults.maxSearches;
+gui_var.nameCache   = gui_var.Defaults.nameCache;
+
+% Set function handles for all nomadm functions used in the GUI
+guiFunction = {'selectProblem','editFile','quitGUI','editParameters',   ...
+               'selectPoll','toggleStochastic','loadSession','resetSession',...
+               'saveSession','saveCache', 'deleteFile','clearRuns','getHelp',...
+               'getAbout','search_gui','dace_gui','nw_gui','results_gui',...
+               'solution_gui','loadSearchOptions','loadDACEOptions',...
+               'loadNWOptions','copyPlot','runMADS','loadMADS',...
+               'loadUserSearchFile','changeView','updateScreen',...
+               'modifySearchScreen','updateSearchLabels'};
+gui_func = [];
+for k = 1:length(guiFunction)
+   gui_func.(guiFunction{k}) = str2func(guiFunction{k});
+end
+
+% Launch the NOMADm GUI and store GUI handles and variables as appdata
+gui = nomadm_gui(gui_var,gui_func);
+setappdata(gui.fig,'gui',gui);
+setappdata(gui.fig,'gui_func',gui_func);
+setappdata(gui.fig,'gui_var',gui_var);
+resetSession(1,0);
+return
+
+%*******************************************************************************
+% nomadm_gui:  Launch the NOMADm GUI.
+% ------------------------------------------------------------------------------
+% Calls: mads_defaults
+% VARIABLES:
+%  gui_var            = structure of GUI variables (descriptions above)
+%  gui_func           = structure of function handles with fields as names
+%  gui                = structure of all GUI object handles
+%    .fig             =   handle for the main figure window
+%    .TermFlag        =   structure of handles for termination checkboxes
+%      .nIter         =     handle for number of iterations
+%      .nFunc         =     handle for number of function evaluations
+%      .time          =     handle for CPU time
+%      .nFails        =     handle for number of consecutive Poll failures
+%    .problem         =   handle for text listing optimization problem name
+%    .searchLabel(k)  =   handles for Searches
+%    .pollStrategy    =   handle for Poll strategy
+%    .pollCenter      =   handle for Poll center
+%    .pollOrder       =   handle for Poll order type
+%    .Term            =   structure of handles for termination criteria
+%      .delta         =     handle for mesh size tolerance
+%      .nIter         =     handle for maximum number of MADS iterations
+%      .nFunc         =     handle for maximum number of function evaluations
+%      .time          =     handle for maximum CPU time
+%      .nFails        =     handle for max number of consec Poll failures
+%    .delta0          =   handle for initial mesh size
+%    .deltaMax        =   handle for maximum mesh size
+%    .meshRefine      =   handle for mesh refinement factor
+%    .meshCoarsen     =   handle for mesh coarsening factor
+%    .tolCache        =   handle for Cache tolerance
+%    .hmin            =   handle for minimum infeasible h-value
+%    .hmax            =   handle for maximum filter h-value
+%    .ePollXiF        =   handle for f-value Extended Poll trigger
+%    .ePollXiH        =   handle for h-value Extended Poll trigger
+%    .RS              =   structure of handles for ranking & selection
+%      .s0            =     handle for initial sample size
+%      .alpha_const   =     handle for the initial alpha value
+%      .iz_const      =     handle for the initial indifference zone parameter
+%      .alpha_rho     =     handle for the alpha decay factor
+%      .iz_rho        =     handle for the indifference zone decay factor
+%    .runStatus       =   handle for GUI figure window status bar
+%    .axesHistory     =   handle for the History plot axes
+%    .axesFilter      =   handle for the Filter plot axes
+%    .stopRun         =   handle for the Stop Run pushbutton
+%    .resumeRun       =   handle for the Resume Run pushbutton
+%    .Menu            =   structure of handles for the main menu
+%      .Problem       =     handle for the Problem menu
+%      .MADS          =     handle for the MADS menu
+%      .Options       =     handle for the Options menu
+%      .Session       =     handle for the Session menu
+%      .Cache         =     handle for the Cache menu
+%      .Run           =     handle for the Run menu
+%      .Results       =     handle for the Results menu
+%      .Help          =     handle for the Help menu
+%    .ProblemMenu     =   structure of handles for Problem menu items
+%    .MADSMenu        =   structure of handles for MADS menu items
+%    .OptionsMenu     =   structure of handles for Options menu items
+%    .SessionMenu     =   structure of handles for Session menu items
+%    .CacheMenu       =   structure of handles for Cache menu items
+%    .RunMenu         =   structure of handles for Run menu items
+%    .ResultsMenu     =   structure of handles for Results menu items
+%    .HelpMenu        =   structure of handles for Help menu items
+%   onoff             = cell array containing "on" and "off" strings
+%
+%   MANY other variables, primarily ones that are GUI.fig objects
+%*******************************************************************************
+function gui = nomadm_gui(gui_var,gui_func)
+onoff = {'on','off'};
+
+% Set up main figure window
+gui.fig = figure(...
+   'Name',                               'NOMADm Optimization Software',...
+   'Tag',                                'NOMADm_GUI', ...
+   'DefaultUIControlUnits',              'normalized', ...
+   'DefaultUIControlFontUnits',          'normalized', ...
+   'DefaultUIControlFontName',           'Helvetica',  ...
+   'DefaultUIControlFontSize',            0.72, ...,
+   'DefaultUIControlStyle',              'text', ...
+   'DefaultUIControlHorizontalAlignment','left', ...
+   'Units',                              'normalized', ...
+   'Position',                           [0.05 0.1 .9 .8], ...
+   'MenuBar',                            'none', ...
+   'NumberTitle',                        'off', ...
+   'CloseRequestFcn',                    {gui_func.quitGUI, gui_var});
+
+if gui_var.newMatlab
+
+   % Status bar
+   gui.statusbar = uipanel('Parent',gui.fig,'Position',[0, 0, 1, .04], ...
+                                            'BorderType','beveledout');
+   gui.runStatus = uicontrol(gui.statusbar, 'String','No problem selected', ...
+                                            'Position', [.01 0 .98 .88]);
+
+   % Panels for MADS Parameters
+   gui.MADSPanel   = uipanel('Parent',gui.fig,'Position',[.02,.745,.395,.20], ...
+                                              'BorderType','beveledout');
+   gui.TermPanel   = uipanel('Parent',gui.fig,'Position',[.02,.585,.395,.16], ...
+                                              'BorderType','beveledout');
+   gui.MeshPanel   = uipanel('Parent',gui.fig,'Position',[.02,.425,.395,.16], ...
+                                              'BorderType','beveledout');
+   gui.FilterPanel = uipanel('Parent',gui.fig,'Position',[.02,.295,.395,.13], ...
+                                              'BorderType','beveledout');
+   gui.RSPanel     = uipanel('Parent',gui.fig,'Position',[.02,.135,.395,.16], ...
+                                              'BorderType','beveledout');
+else
+   panelColor = [0.9255, 0.9137, 0.8471];
+   black = [.35 .35 .35];
+   white = [.95 .95 .95];
+   
+   uicontrol(gui.fig, 'Style','frame','Position',[0, .04, 1, .003], ...
+      'ForegroundColor',white,'BackgroundColor',white);
+   uicontrol(gui.fig, 'Style','frame','Position',[0,  0,  1, .04], ...
+      'ForegroundColor',panelColor,'BackgroundColor',panelColor);
+   gui.runStatus = uicontrol(gui.fig, 'String','No problem selected', ...
+                                      'Position', [.01 .003 .98 .03], ...
+                                      'BackgroundColor',panelColor);
+
+   % Frame box for the Display of MADS Parameters
+   gui.MADSPanel   = uicontrol(gui.fig,'Style','frame', ...
+                     'Position',       [.02,.745,.395,.20], ...
+                     'ForegroundColor',panelColor);
+   gui.TermPanel   = uicontrol(gui.fig,'Style','frame', ...
+                     'Position',       [.02,.585,.395,.16], ...
+                     'ForegroundColor',panelColor);
+   gui.MeshPanel   = uicontrol(gui.fig,'Style','frame', ...
+                     'Position',       [.02,.425,.395,.16], ...
+                     'ForegroundColor',panelColor);
+   gui.FilterPanel = uicontrol(gui.fig,'Style','frame', ...
+                     'Position',       [.02,.295,.395,.13], ...
+                     'ForegroundColor',panelColor);
+   gui.RSPanel = uicontrol(gui.fig,'Style','frame',...
+                     'Position',       [.02,.135,.395,.16], ...
+                     'ForegroundColor',panelColor);
+                  
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .295 .004 .65], ...
+        'ForegroundColor',white, 'BackgroundColor',white);     % Left side
+    uicontrol(gui.fig, 'Style','frame','Position',[.416 .295 .004 .65], ...
+        'ForegroundColor',black, 'BackgroundColor',black);     % Right side
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .943 .404 .003], ...
+        'ForegroundColor',white, 'BackgroundColor',white);     % Top
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .295 .404 .003], ...
+        'ForegroundColor',black, 'BackgroundColor',black);     % Bottom
+     
+    gui.RSBorder(1) = uicontrol(gui.fig, 'Style','frame',...
+        'Position', [.016 .135 .004 .16], ...
+        'ForegroundColor',white, 'BackgroundColor',white);     % Left side
+    gui.RSBorder(2) = uicontrol(gui.fig, 'Style','frame',...
+        'Position', [.416 .135 .004 .16], ...
+        'ForegroundColor',black, 'BackgroundColor',black);     % Right side
+    gui.RSBorder(3) = uicontrol(gui.fig, 'Style','frame',...
+        'Position', [.016 .292 .404 .003], ...
+        'ForegroundColor',white, 'BackgroundColor',white);     % Top
+    gui.RSBorder(4) = uicontrol(gui.fig, 'Style','frame',...
+        'Position', [.016 .135 .404 .003], ...
+        'ForegroundColor',black, 'BackgroundColor',black);     % Bottom
+ 
+    % Three separators in the MADS parameter box (2 per separator)
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .745 .404  .003], ...
+        'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .742 .404  .003], ...
+        'ForegroundColor','white','BackgroundColor','white');
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .585 .404  .003], ...
+        'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .582 .404  .003], ...
+        'ForegroundColor','white','BackgroundColor','white');
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .425 .404  .003], ...
+        'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+    uicontrol(gui.fig, 'Style','frame','Position',[.016 .422 .404  .003], ...
+        'ForegroundColor','white','BackgroundColor','white');
+
+end
+                                           
+% Display of the NOMADm object labels
+uicontrol(gui.fig, 'String','Optimization Problem: ', ...
+          'FontWeight','bold', ...
+          'BackgroundColor',[.8 .8 .8], ...
+          'HorizontalAlignment','right', ...
+          'Position',[.025 .955  .19  .035], ...
+          'ToolTipString',...
+          'The name of the currently selected optimization problem');
+uicontrol(gui.fig, 'String','MADS Parameter Settings', ...
+          'FontWeight','bold', ...
+          'HorizontalAlignment','center', ...
+          'Position',[.025 .905 .385 .03], ...
+          'ToolTipString',...
+          'Any of these values may be changed via the MADS Menu');
+uicontrol(gui.fig, 'String','Initial Search:', ...
+          'Position',[.025 .87  .11  .03], ...
+          'ToolTipString','The Strategy used in the initial MADS Search step');
+uicontrol(gui.fig, 'String','Search:', ...
+          'Position',[.025 .84  .11  .03], ...
+          'ToolTipString','The Strategy used in the MADS Search step');
+uicontrol(gui.fig, 'String','Poll Directions:', ...
+          'Position',[.025 .81  .11  .03], ...
+          'ToolTipString',...
+          'MADS Poll directions must positively span the problem domain');
+uicontrol(gui.fig, 'String','Poll Order:', ...
+          'Position',[.025 .78  .11  .03], ...
+          'ToolTipString','The order in which the MADS Poll set is evaluated');
+uicontrol(gui.fig, 'String','Poll Center:', ...
+          'Position',[.025 .75  .11  .03], ...
+          'ToolTipString', ...
+          'The point around which the MADS Poll step is performed');
+
+gui.TermFlag.delta  = uicontrol(gui.fig, ...
+          'String',   gui_var.Labels.Parameters.term{1}, ...
+          'Style',    'checkbox', ...
+          'Value',    1, ...
+          'Position', [.025 .71  .32  .03]);
+gui.TermFlag.nIter  = uicontrol(gui.fig, ...
+          'String',   gui_var.Labels.Parameters.term{2}, ...
+          'Style',    'checkbox', ...
+          'Position', [.025 .68 .32 .03]);
+gui.TermFlag.nFunc  = uicontrol(gui.fig, ...
+          'String',   gui_var.Labels.Parameters.term{3}, ...
+          'Style',    'checkbox', ...
+          'Position', [.025 .65 .32 .03]);
+gui.TermFlag.time   = uicontrol(gui.fig, ...
+          'String',   gui_var.Labels.Parameters.term{4}, ...
+          'Style',    'checkbox', ...
+          'Position', [.025 .62 .32 .03]);
+gui.TermFlag.nFails = uicontrol(gui.fig, ...
+          'String',   gui_var.Labels.Parameters.term{5}, ...
+          'Style',    'checkbox', ...
+          'Position', [.025 .59 .32 .03]);
+
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.mesh{1}, ...
+          'Position',[.025 .55  .32  .03], ...
+          'ToolTipString','The initial mesh size parameter value');
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.mesh{2}, ...
+          'Position',[.025 .52  .32  .03], ...
+          'ToolTipString','The maximum allowed mesh size');
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.mesh{3}, ...
+          'Position',[.025 .49  .32  .03], ...
+          'ToolTipString', ...
+          'Mesh size is reduced by this factor when an iteration fails');
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.mesh{4}, ...
+          'Position',[.025 .46  .32  .03], ...
+          'ToolTipString',...
+          'Mesh size is increased by this factor when an iteration succeeds');
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.mesh{5}, ...
+          'Position',[.025 .43  .32  .03], ...
+          'ToolTipString',...
+          ['Any two points whose distance is less than this value are', ...
+           ' assumed identical']);
+
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.other{1}, ...
+          'Position',[.025 .39  .32  .03], ...
+          'ToolTipString',...
+          'Minimum constraint violation function value of an infeasible point');
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.other{2}, ...
+          'Position',[.025 .36  .32  .03], ...
+          'ToolTipString',...
+          'Maximum constraint violation function value of any filter point');
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.other{3}, ...
+          'Position',[.025 .33  .32  .03], ...
+          'ToolTipString',...
+         ['If a discrete neighbor has objective function value within this',...
+          ' value of that of the incumbent, then extended polling is', ...
+          ' extended polling is performed around this neighbor point']);
+uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.other{4}, ...
+          'Position',[.025 .30  .32  .03], ...
+          'ToolTipString',...
+         ['If a discrete neighbor has constraint violation function value', ...
+          ' within this value of that of the incumbent, then extended' ...
+          ' polling is performed around this neighbor point']);
+gui.RSLabel(1) = uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.RS{1}, ...
+          'Position',[.025 .26  .32  .03], ...
+          'ToolTipString',...
+          'Ranking and Selection Parameters');
+gui.RSLabel(2) = uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.RS{2}, ...
+          'Position',[.025 .23  .32  .03], ...
+          'ToolTipString',...
+          'Ranking and Selection Parameters');
+gui.RSLabel(3) = uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.RS{3}, ...
+          'Position',[.025 .20  .32  .03], ...
+          'ToolTipString',...
+         'Ranking and Selection Parameters');
+gui.RSLabel(4) = uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.RS{4}, ...
+          'Position',[.025 .17  .32  .03], ...
+          'ToolTipString',...
+         'Ranking and Selection Parameters');
+gui.RSLabel(5) = uicontrol(gui.fig, 'String',gui_var.Labels.Parameters.RS{5}, ...
+          'Position',[.025 .14  .32  .03], ...
+          'ToolTipString',...
+         'Ranking and Selection Parameters');
+
+% Display of NOMADm object values (Problem Name, Parameter Settings, etc.)
+gui.problem        = uicontrol(gui.fig, 'String',          '', ...
+                                        'FontWeight',      'bold', ...
+                                        'ForegroundColor', 'red', ...
+                                        'BackgroundColor', [.8 .8 .8], ...
+                                        'Position', [.225 .955 .19 .035]);
+gui.searchLabel(1) = uicontrol(gui.fig, 'Position', [.14  .87 .27 .03], ...
+                                        'ForegroundColor','blue');
+gui.searchLabel(2) = uicontrol(gui.fig, 'Position', [.14  .84 .27 .03], ...
+                                        'ForegroundColor','blue');
+gui.pollStrategy   = uicontrol(gui.fig, 'Position', [.14  .81 .27 .03], ...
+                                        'ForegroundColor','blue');
+gui.pollOrder      = uicontrol(gui.fig, 'Position', [.14  .78 .27 .03], ...
+                                        'ForegroundColor','blue');
+gui.pollCenter     = uicontrol(gui.fig, 'Position', [.14  .75 .27 .03], ...
+                                        'ForegroundColor','blue');
+gui.Term.delta     = uicontrol(gui.fig, 'Position', [.35  .71 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.Term.nIter     = uicontrol(gui.fig, 'Position', [.35  .68 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.Term.nFunc     = uicontrol(gui.fig, 'Position', [.35  .65 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.Term.time      = uicontrol(gui.fig, 'Position', [.35  .62 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.Term.nFails    = uicontrol(gui.fig, 'Position', [.35  .59 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.delta0         = uicontrol(gui.fig, 'Position', [.35  .55 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.deltaMax       = uicontrol(gui.fig, 'Position', [.35  .52 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.meshRefine     = uicontrol(gui.fig, 'Position', [.35  .49 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.meshCoarsen    = uicontrol(gui.fig, 'Position', [.35  .46 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.tolCache       = uicontrol(gui.fig, 'Position', [.35  .43 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.hmin           = uicontrol(gui.fig, 'Position', [.35  .39 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.hmax           = uicontrol(gui.fig, 'Position', [.35  .36 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.ePollXiF       = uicontrol(gui.fig, 'Position', [.35  .33 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.ePollXiH       = uicontrol(gui.fig, 'Position', [.35  .30 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.RS.s0          = uicontrol(gui.fig, 'Position', [.35  .26 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.RS.alpha_const = uicontrol(gui.fig, 'Position', [.35  .23 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.RS.iz_const    = uicontrol(gui.fig, 'Position', [.35  .20 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.RS.alpha_rho   = uicontrol(gui.fig, 'Position', [.35  .17 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+gui.RS.iz_rho      = uicontrol(gui.fig, 'Position', [.35  .14 .06 .03], ...
+                                        'HorizontalAlignment','center', ...
+                                        'ForegroundColor','blue');
+
+% Additional ToolTips for NOMADm objects
+set([gui.searchLabel(1);gui.searchLabel(2)], ...
+    'ToolTipString','The Search screen is accessed in the MADS Menu');
+set([gui.pollStrategy;gui.pollOrder;gui.pollCenter], ...
+    'ToolTipString','Changing these values is done in the MADS Menu');
+set(gui.hmin,'ToolTipString','This value should be kept very small');
+set(gui.hmax,'ToolTipString', ...
+    'This value must be greater than Min Filter Constraint Violation');
+set(gui.TermFlag.delta,'ToolTipString',...
+    ['MADS terminates as soon as the mesh size parameter value falls', ...
+     ' below this value']);
+set([gui.TermFlag.nIter;gui.TermFlag.nFunc; ...
+     gui.TermFlag.time; gui.TermFlag.nFails], ...
+    'ToolTipString', ...
+    'Check the box to activate the corresponding termination criterion');
+set(gui.Term.delta,'ToolTipString', ...
+    ['This value must be positive and should be kept small as it measures,', ...
+     ' the accuracy of the solution']);
+set([gui.Term.nIter;gui.Term.nFunc;gui.Term.time;gui.Term.nFails], ...
+    'ToolTipString', ...
+    'Setting this value to ''Inf'' is the same as unchecking the box');
+
+% Display of 2 plot axes and Stop/Resume Run pushbuttons
+gui.axesHistory = axes('Parent',gui.fig, ...
+   'Position',            [.52 .605 .43 .33], ...
+   'FontUnits',           'normalized', ...
+   'FontSize',            .07, ...
+   'Box',                 'on', ...
+   'Visible',             'off', ...
+   'ButtonDownFcn',       gui_func.copyPlot);
+gui.axesFilter = axes('Parent',gui.fig, ...
+   'Position',            [.62 .13 .33 .33], ...
+   'FontUnits',           'normalized', ...
+   'FontSize',            .07, ...
+   'Box',                 'on', ...
+   'Visible',             'off', ...
+   'ButtonDownFcn',       gui_func.copyPlot);
+gui.stopRun = uicontrol(gui.fig, ...
+   'Style',               'pushbutton', ...
+   'String',              'Stop Run', ...
+   'Tag',                 'StopRun', ...
+   'FontWeight',          'bold', ...
+   'HorizontalAlignment', 'center', ...
+   'Position',            [.42 .50 .11 .045], ...
+   'FontSize',            .5, ...
+   'BackgroundColor',     [.8 .8 .8], ...
+   'Visible',             'off', ...
+   'Interruptible',       'off', ...
+   'UserData',            0, ...
+   'Callback',            'set(gcbo,''UserData'',1);');
+gui.resumeRun = uicontrol(gui.fig, ...
+   'Style',               'pushbutton', ...
+   'String',              'Resume Run', ...
+   'FontWeight',          'bold', ...
+   'HorizontalAlignment', 'center', ...
+   'Position',            [.42 .455 .11 .045], ...
+   'FontSize',            .5, ...
+   'BackgroundColor',     [.8 .8 .8], ...
+   'Visible',             'off', ...
+   'Interruptible',       'off', ...
+   'Callback',            {gui_func.runMADS, 2});
+
+% Set up Main Menu
+gui.Menu.Problem = uimenu(gui.fig,'Position',1,'Label','Problem');
+gui.Menu.MADS    = uimenu(gui.fig,'Position',2,'Label','MADS');
+gui.Menu.Options = uimenu(gui.fig,'Position',3,'Label','Options');
+gui.Menu.Session = uimenu(gui.fig,'Position',4,'Label','Session');
+gui.Menu.Cache   = uimenu(gui.fig,'Position',5,'Label','Cache');
+gui.Menu.Run     = uimenu(gui.fig,'Position',6,'Label','Run');
+gui.Menu.Results = uimenu(gui.fig,'Position',7,'Label','Results');
+gui.Menu.Help    = uimenu(gui.fig,'Position',8,'Label','Help');
+
+% Define Problem Menu
+gui.ProblemMenu.new     = uimenu(gui.Menu.Problem, 'Position',  1, ...
+   'Label',       'New Optimization Problem', ...
+   'Accelerator', 'N', ...
+   'Enable',      'on', ...
+   'Callback',    gui_func.selectProblem);
+for k = 1:length(gui_var.Types.file)
+    gui.ProblemMenu.edit(k) = uimenu(gui.Menu.Problem, 'Position', k+1, ...
+      'Label',    ['Edit ', gui_var.Labels.file{k}, ' File'], ...
+      'Visible',  'off', ...
+      'CallBack',  gui_func.editFile);
+end
+gui.ProblemMenu.quit = uimenu(gui.Menu.Problem, ...
+   'Position',    length(gui_var.Types.file)+2, ...
+   'Label',       'Quit NOMADm', ...
+   'Accelerator', 'Q', ...
+   'Callback',    {gui_func.quitGUI, gui_var});
+set([gui.ProblemMenu.edit(1);gui.ProblemMenu.quit],'Separator','on');
+
+% Define MADS Menu
+gui.MADSMenu.editTermParam  = uimenu(gui.Menu.MADS, 'Position', 1, ...
+   'Label',       'Edit Termination Parameters', ...
+   'UserData',    {gui_var.Labels.Parameters.term, ...
+                  [gui.Term.delta;gui.Term.nIter;gui.Term.nFunc; ...
+                  gui.Term.time;gui.Term.nFails]}, ...
+  'Callback',     gui_func.editParameters);
+gui.MADSMenu.editMeshParam  = uimenu(gui.Menu.MADS, 'Position', 2, ...
+   'Label',       'Edit Mesh Parameters', ...
+   'UserData',    {gui_var.Labels.Parameters.mesh, ...
+                  [gui.delta0;gui.deltaMax;gui.meshRefine; ...
+                  gui.meshCoarsen;gui.tolCache]}, ...
+   'Callback',    gui_func.editParameters);
+gui.MADSMenu.editOtherParam = uimenu(gui.Menu.MADS, 'Position', 3, ...
+   'Label',       'Edit Filter/MVP Parameters', ...
+   'UserData',    {gui_var.Labels.Parameters.other, ...
+                  [gui.hmin; gui.hmax; gui.ePollXiF; gui.ePollXiH]}, ...
+   'Callback',    gui_func.editParameters);
+gui.MADSMenu.editRSParam    = uimenu(gui.Menu.MADS, 'Position', 4, ...
+   'Label',       'Edit Ranking & Selection Parameters', ...
+   'UserData',    {gui_var.Labels.Parameters.RS, ...
+                  [gui.RS.s0; gui.RS.alpha_const; gui.RS.iz_const; ...
+                   gui.RS.alpha_rho; gui.RS.iz_rho]}, ...
+   'Callback',    gui_func.editParameters);
+   
+gui.MADSMenu.editSearch     = uimenu(gui.Menu.MADS, 'Position', 5, ...
+   'Separator',   'on', ...
+   'Label',       'Select Search Strategies', ...
+   'Callback',    gui_func.search_gui);
+gui.MADSMenu.pollStrategies = uimenu(gui.Menu.MADS, 'Position', 6, ...
+   'Separator',   'on', ...
+   'Label',       'Select Poll Directions');
+gui.MADSMenu.pollOrders     = uimenu(gui.Menu.MADS, 'Position', 7, ...
+   'Label',       'Select Poll Order');
+gui.MADSMenu.pollCenters    = uimenu(gui.Menu.MADS, 'Position', 8, ...
+   'Label',       'Select Poll Center');
+gui.MADSMenu.pollComplete   = uimenu(gui.Menu.MADS, 'Position', 9, ...
+   'Label',       'Complete Polling', ...
+   'Callback',    'umtoggle(gcbo);');
+
+% Define MADS Submenus
+for k = 1:length(gui_var.Labels.pollStrategy)
+   gui.MADSMenu.pollStrategy(k) = uimenu(gui.MADSMenu.pollStrategies, ...
+      'Position', k, ...
+      'Label',    gui_var.Labels.pollStrategy{k}, ...
+      'UserData', gui.pollStrategy, ...
+      'Callback', {gui_func.selectPoll,'Strategy'});
+   if strncmp(gui_var.Types.poll{k}, 'Gradient', 8)
+      set(gui.MADSMenu.pollStrategy(k),'Enable','off');
+   end
+end
+for k = 1:length(gui_var.Labels.pollCenter)
+   gui.MADSMenu.pollCenter(k) = uimenu(gui.MADSMenu.pollCenters, ...
+      'Position', k, ...
+      'Label',    gui_var.Labels.pollCenter{k}, ...
+      'UserData', gui.pollCenter, ...
+      'Callback', {gui_func.selectPoll,'Center'});
+end
+for k = 1:length(gui_var.Labels.pollOrder)
+   gui.MADSMenu.pollOrder(k) = uimenu(gui.MADSMenu.pollOrders, ...
+      'Position', k, ...
+      'Label',    gui_var.Labels.pollOrder{k}, ...
+      'UserData', gui.pollOrder, ...
+      'Callback', {gui_func.selectPoll,'Order'});
+end
+
+% Define Options Menu
+gui.OptionsMenu.useFilter         = uimenu(gui.Menu.Options, 'Position',1, ...
+   'Label',       'Use Filter for Nonlinear Constraints', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.OptionsMenu.removeRedundancy  = uimenu(gui.Menu.Options, 'Position',2, ...
+   'Label',       'Discard Redundant Linear Constraints', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.OptionsMenu.runStochastic     = uimenu(gui.Menu.Options, 'Position',3, ...
+   'Label',       'Run as Stochastic Optimization Problem', ...
+   'Callback',    gui_func.toggleStochastic);
+gui.OptionsMenu.scaleMenu         = uimenu(gui.Menu.Options, 'Position',4, ...
+   'Label',       'Scaling of Mesh Directions');
+gui.OptionsMenu.accelerate        = uimenu(gui.Menu.Options, 'Position',5, ...
+   'Label',       'Accelerate Convergence', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.OptionsMenu.TermFlag.relative = uimenu(gui.Menu.Options, 'Position',6, ...
+   'Label',       'Use Relative Termination Tolerance', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.OptionsMenu.plotHistory1      = uimenu(gui.Menu.Options, 'Position',7, ...
+   'Label',       'Plot History', 'Separator',   'on', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.OptionsMenu.plotHistory2      = uimenu(gui.Menu.Options, 'Position',8, ...
+   'Label',       'Plot History (Real-time)', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.OptionsMenu.plotFilter        = uimenu(gui.Menu.Options, 'Position',9, ...
+   'Label',       'Plot Filter (Real-time)', ...
+   'Callback',    'umtoggle(gcbo);');
+
+% Define Scale SubMenu of the Options Menu choice Scale
+for k = 1:length(gui_var.Labels.scale)
+   gui.scaleMenu(k) = uimenu(gui.OptionsMenu.scaleMenu, 'Position', k, ...
+      'Label',    gui_var.Labels.scale{k}, ...
+      'Callback', ['set(get(get(gcbo,''Parent''),''Children''),', ...
+                   ' ''Checked'',''off''); umtoggle(gcbo);']);
+end
+
+% Define Session Menu
+gui.SessionMenu.load   = uimenu(gui.Menu.Session, 'Position', 1, ...
+   'Label',       'Load Options from Session File', ...
+   'Enable',      'off', ...
+   'Callback',    gui_func.loadSession);
+gui.SessionMenu.save   = uimenu(gui.Menu.Session, 'Position', 2, ...
+   'Label',       'Save Options to Session File', ...
+   'Enable',      'off', ...
+   'Callback',    gui_func.saveSession);
+gui.SessionMenu.reset  = uimenu(gui.Menu.Session, 'Position', 3, ...
+   'Label',       'Reset Options to Defaults', ...
+   'Callback',    gui_func.resetSession);
+gui.SessionMenu.delete = uimenu(gui.Menu.Session, 'Position', 4, ...
+   'Label',       'Delete Session File', ...
+   'Enable',      'off', ...
+   'UserData',   {'Session File',gui_var.FileExt.S,gui.SessionMenu.load},...
+   'Callback',    gui_func.deleteFile);
+
+% Define Cache Menu
+gui.CacheMenu.load   = uimenu(gui.Menu.Cache, 'Position', 1, ...
+   'Label',       'Use Pre-Existing Cache File', ...
+   'Enable',      'off', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.CacheMenu.count  = uimenu(gui.Menu.Cache, 'Position', 2, ...
+   'Label',       'Count Cache Points as Function Calls', ...
+   'Enable',      'off', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.CacheMenu.save   = uimenu(gui.Menu.Cache, 'Position', 3, ...
+   'Label',       'Save Run Results to Cache File', ...
+   'Accelerator', 'S', ...
+   'Enable',      'off', ...
+   'Callback',    gui_func.saveCache);
+gui.CacheMenu.delete = uimenu(gui.Menu.Cache, 'Position', 4, ...
+   'Label',       'Delete Pre-Existing Cache File', ...
+   'Enable',      'off', ...
+   'UserData',    {'Cache File', gui_var.FileExt.C, ...
+                  [gui.CacheMenu.load; gui.CacheMenu.count]}, ...
+   'Callback',    gui_func.deleteFile);
+
+% Define Run Menu
+gui.RunMenu.exec         = uimenu(gui.Menu.Run,'Position',1, ...
+   'Label',       'Execute Next Run', ...
+   'Accelerator', 'R', ...
+   'Enable',      'off', ...
+   'Callback',    {gui_func.runMADS, 0});
+gui.RunMenu.resume       = uimenu(gui.Menu.Run,'Position',2, ...
+   'Label',       'Resume a Stopped Run', ...
+   'Enable',      'off', ...
+   'Callback',    {gui_func.runMADS, 2});
+gui.RunMenu.restart  = uimenu(gui.Menu.Run,'Position',3, ...
+   'Label',       'Restart Run from Current Point', ...
+   'Enable',      'off', ...
+   'Callback',    {gui_func.runMADS, 1});
+gui.RunMenu.oneIteration = uimenu(gui.Menu.Run,'Position',4, ...
+   'Separator',   'on', ...
+   'Label',       'Run One Iteration at a Time', ...
+   'Checked',     'off', ...
+   'Enable',      'off', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.RunMenu.execFeasible = uimenu(gui.Menu.Run,'Position',5, ...
+   'Label',       'Run Only Until Feasible', ...
+   'Checked',     'off', ...
+   'Enable',      'off', ...
+   'Callback',    'umtoggle(gcbo);');
+gui.RunMenu.clear        = uimenu(gui.Menu.Run,'Position',6, ...
+   'Separator',   'on', ...
+   'Label',       'Clear Previous Runs', ...
+   'Enable',      'off', ...
+   'Callback',    gui_func.clearRuns);
+
+% Define Results Menu
+set(gui.Menu.Results,'Visible','off');
+for k = 1:gui_var.runMax
+   gui.ResultsMenu(k) = uimenu(gui.Menu.Results,'Position',k, ...
+      'Label',          ['View Run # ' int2str(k)], ...
+      'Visible',        'off', ...
+      'ForegroundColor',gui_var.Types.plotColors(k), ...
+      'Accelerator',    int2str(mod(k,gui_var.runMax)), ...
+      'Callback',       gui_func.results_gui);
+end
+
+% Define Help Menu
+uimenu(gui.Menu.Help,'Position',1, ...
+   'Label',      'NOMADm Help', ...
+   'Accelerator','H', ...
+   'Visible',    onoff{2-~~exist(gui_var.HelpDoc.nomadm,'file')}, ...
+   'UserData',   gui_var.HelpDoc.nomadm,...
+   'Callback',   gui_func.getHelp);
+uimenu(gui.Menu.Help,'Position',2, ...
+   'Label',      'DACE Toolbox Help', ...
+   'Visible',    onoff{2-~~exist(gui_var.HelpDoc.dace,'file')}, ...
+   'UserData',   gui_var.HelpDoc.dace,...
+   'Callback',   gui_func.getHelp);
+uimenu(gui.Menu.Help,'Position',3, ...
+   'Label',      'N-W Toolbox Help', ...
+   'Visible',    onoff{2-~~exist(gui_var.HelpDoc.nw,'file')}, ...
+   'UserData',   gui_var.HelpDoc.nw,...
+   'Callback',   gui_func.getHelp);
+uimenu(gui.Menu.Help,'Position',4, ...
+   'Label',      'CMA-ES Toolbox Help', ...
+   'Visible',    onoff{2-~~exist(gui_var.HelpDoc.cmaes,'file')}, ...
+   'UserData',   gui_var.HelpDoc.cmaes,...
+   'Callback',   gui_func.getHelp);
+uimenu(gui.Menu.Help,'Position',5, ...
+   'Separator',  'on', ...
+   'Label',      'View List of Version Changes', ...
+   'Visible',    onoff{2-~~exist(gui_var.HelpDoc.changes,'file')}, ...
+   'UserData',   gui_var.HelpDoc.changes,...
+   'Callback',   gui_func.getHelp);
+uimenu(gui.Menu.Help,'Position',6, ...
+   'Label',      'View GNU Public License', ...
+   'Visible',    onoff{2-~~exist(gui_var.HelpDoc.license,'file')}, ...
+   'UserData',   gui_var.HelpDoc.license,...
+   'Callback',   gui_func.getHelp);
+uimenu(gui.Menu.Help,'Position',7, ...
+   'Separator',  'on', ...
+   'Label',      'About NOMADm', ...
+   'Callback',   {gui_func.getAbout,gui_var.version,gui_var.Labels.coolCats});
+return
+
+%*******************************************************************************
+% BEGINNING OF SIMPLE NOMADm GUI CALLBACK FUNCTIONS
+%*******************************************************************************
+
+%*******************************************************************************
+% selectProblem: Choose an optimization problem.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Problem-->New Optimization Problem)
+% Calls:     clearRuns, resetSession
+% VARIABLES:
+%  pFile             = filename of current optimization problem
+%  pPath             = pathname of current optimization problem
+%  gui_var           = structure of all GUI variables
+%    .path           =   path of current optimization problem
+%    .problemExt     =   filename extension of optimization problem 
+%    .problem        =   name of current optimization problem
+%    .FileExt        =   filename suffixes
+%      .O            =     Omega file suffix
+%      .I            =     initial points file suffix
+%      .N            =     discrete neighbors file suffix
+%      .P            =     user parameter file suffix
+%      .C            =     Cache file suffix
+%      .S            =     Session file suffix
+%    .noGrad         =   flag indicating initial availability of gradients
+%  gui               = structure of all GUI object handles
+%    .runStatus      =   handle for text bar at bottom of figure window
+%    .RunMenu        =   handles for Run menu items
+%    .ProblemMenu    =   handles for Problem menu items
+%    .MADSMenu       =   handles for MADS menu items
+%    .SessionMenu    =   handles for Session menu items
+%    .CacheMenu      =   handles for CacheMenu items
+%  nameProblem       = name of current optimization problem
+%  isConstrained     = flags problem as having linear constraints
+%  hasInitGuess      = flags problem as having an initial guess
+%  hasUserParam      = flags problem as having user parameters
+%  isMVP             = flags problem as being an MVP
+%  existCache        = flags problem as having an existing Cache file
+%  existSession      = flags problem as having an existing Session file
+%  pLabels           = strings of Poll strategy labels
+%*******************************************************************************
+function selectProblem(h,event)
+
+[pFile,pPath] = uigetfile({'*.m',        'Matlab M-files (*.m)';      ...
+                           '*.f; *.for', 'Fortran files (*.f,*.for)'; ...
+                           '*.c; *.C',   'C/C++ files (*.c,*.C)'},    ...
+                           'Select an Optimization Problem file');
+if (pFile)
+
+   % Reset all variables and retrieve GUI application data
+   clearRuns(1,0);
+   resetSession(1,0);
+   gui_var = getappdata(gcbf,'gui_var');
+   gui     = getappdata(gcbf,'gui');
+
+   % Set the path, removing only directories not there at startup
+   if gui_var.newPath
+      rmpath(gui_var.path);
+   end
+   gui_var.newPath = isempty(strfind(upper(path),upper(pPath)));
+   gui_var.path    = pPath;
+   if gui_var.newPath
+      addpath(gui_var.path);
+   end
+
+   % Load New Problem
+   [nameProblem, gui_var.problemExt] = strtok(pFile,'.');
+   set(gui.problem,             'String',nameProblem);
+   set(gui.runStatus,           'String','No runs performed');
+   set(gui.RunMenu.exec,        'Enable','on');
+   set(gui.RunMenu.oneIteration,'Enable','on');
+   set(gui.RunMenu.execFeasible,'Enable','on');
+
+   % Allow editing only of files that exist
+   isConstrained = exist([nameProblem,gui_var.FileExt.O,'.m'],'file');
+   isMVP         = exist([nameProblem,gui_var.FileExt.N,'.m'],'file');
+   hasInitGuess  = exist([nameProblem,gui_var.FileExt.I,'.m'],'file');
+   hasUserParam  = exist([nameProblem,gui_var.FileExt.P,'.m'],'file');
+   existCache    = exist([nameProblem,gui_var.FileExt.C],'file');
+   existSession  = exist([nameProblem,gui_var.FileExt.S],'file');
+   onoff = {'on','off'};
+   set(gui.ProblemMenu.edit(1),    'Visible', 'on');
+   set(gui.ProblemMenu.edit(2),    'Visible', onoff{1+~hasInitGuess});
+   set(gui.ProblemMenu.edit(3),    'Visible', onoff{1+~isConstrained});
+   set(gui.ProblemMenu.edit(4),    'Visible', onoff{1+~isMVP});
+   set(gui.ProblemMenu.edit(5),    'Visible', onoff{1+~hasUserParam});
+   set(gui.MADSMenu.pollOrder(end),'Enable',  onoff{1+~hasUserParam});
+   set(gui.SessionMenu.load,       'Enable',  onoff{1+~existSession});
+   set(gui.SessionMenu.save,       'Enable',  'on');
+   set(gui.SessionMenu.delete,     'Enable',  onoff{1+~existSession});
+   set(gui.CacheMenu.load,         'Enable',  onoff{1+~existCache});
+   set(gui.CacheMenu.count,        'Enable',  onoff{1+~existCache});
+   set(gui.CacheMenu.delete,       'Enable',  onoff{1+~existCache});      
+      
+   % Allow gradient options if functions file returns enough arguments
+   try
+      gui_var.noGrad = (abs(nargout(nameProblem)) <= 2);
+   catch
+      gui_var.noGrad = 0;
+   end
+   pLabels = char(gui_var.Labels.pollStrategy);
+   set(gui.MADSMenu.pollStrategy(find(pLabels(:,1) == 'G')), ...
+                               'Enable',onoff{1+gui_var.noGrad});
+   setappdata(gcbf,'gui_var',gui_var);
+end
+return
+
+%*******************************************************************************
+% editFile: Edit an optimization problem file.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Problem-->Edit XXXXX File)
+% VARIABLES:
+%  k             = Problem Menu position number of selected file
+%  ext           = filename extension of file to be edited
+%  filename      = full file name of file to be edited
+%  gui_var       = structure of all GUI variables
+%    .path       =   path of current optimization problem
+%    .problemExt =   filename extension of optimization problem 
+%    .Types.file =   strings of file suffixes
+%  gui.problem   = name of current optimization problem
+%*******************************************************************************
+function editFile(h,event)
+
+[h,fig] = gcbo;
+gui_var = getappdata(fig,'gui_var');
+gui     = getappdata(fig,'gui');
+
+k = get(h,'Position') - 1;
+if (k == 1)
+   ext = gui_var.problemExt;
+else
+   ext = '.m';
+end
+filename = fullfile(gui_var.path, [get(gui.problem,'String'),...
+                    gui_var.Types.file{k},ext]);
+edit(filename);
+clear(filename);
+return
+
+%*******************************************************************************
+% quitGUI: End program session.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Problem-->Quit NOMADm)
+%            nomadm_gui (Close Request Function for figure window)
+% VARIABLES:
+%  gui_var    = structure of all NOMADm variables
+%    .newPath = logical showing if the problem path is on the Matlab path
+%    .path    = path of current optimization problem
+%*******************************************************************************
+function quitGUI(h, event, gui_var)
+
+if gui_var.newPath
+   rmpath(gui_var.path);
+end
+if ishandle(gcbf)
+   delete(gcbf);
+end
+clear variables;
+clear functions;
+return
+
+%*******************************************************************************
+% editParameters: Edit parameters.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: MADS-->Edit Mesh Parameters)
+%            nomadm_gui (callback: MADS-->Edit Filter/MVP Parameters)
+%            nomadm_gui (callback: MADS-->Edit Termination Parameters)
+% VARIABLES:
+%  param   = User data storage
+%  header  = title of input dialog box
+%  labels  = text labels in input dialog box
+%  handles = handles to appropriate GUI figure objects
+%  defAns  = default answers that appear in input dialog box
+%  newAns  = new answers that appear in input dialog box
+%*******************************************************************************
+function editParameters(h,event)
+
+header  = get(gcbo,'Label');
+param   = get(gcbo,'UserData');
+[labels, handles] = deal(param{:});
+defAns  = get(handles, 'String');
+newAns  = inputdlg(labels,header,ones(length(defAns),1)*[1,45],defAns);
+if (~isempty(newAns))
+   set(handles, {'String'}, newAns);
+end
+return
+
+%*******************************************************************************
+% selectPoll: Select a Poll Strategy, Poll Center, or Poll Order.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: MADS-->Select Poll Directions), 
+%            nomadm_gui (callback: MADS-->Select Poll Center),
+%            nomadm_gui (callback: MADS-->Select Poll Order), 
+% VARIABLES:
+%  type            = string containing "Strategy", "Center", or "Order"
+%  gui_var.Choice  = user choices
+%  gui             = structure of NOMADm object handles
+%*******************************************************************************
+function selectPoll(h,event,type)
+
+% Update Poll option and screen
+gui_var = getappdata(gcbf,'gui_var');
+gui_var.Choice.(['poll',type]) = get(gcbo,'Position');
+set(get(gcbo,'UserData'),'String',get(gcbo,'Label'));
+setappdata(gcbf,'gui_var',gui_var);
+return
+
+%*******************************************************************************
+% toggleStochastic: Turn on and off flag for Running as a stochastic problem.
+% ------------------------------------------------------------------------------
+% Called by: updateScreen, nomadm_gui (callback: MADS-->
+%                                      Run as Stochastic Optimization Problem)
+% VARIABLES:
+%  gui                          = structure of NOMADm object handles
+%    .OptionsMenu.runStochastic = menu option for running stochastic problem
+%    .MADSMenu.editRSParam      = menu option for editing R&S parameters
+%    .RSPanel                   = handle of the R&S parameter display panel
+%    .RS                        = structure of handles for R&S parameter values
+%    .RSLabel                   = handles of R&S parameter display labels
+%  z                            = value of the menu item toggle switch
+%  flag                         = conversion of z to "on" or "off"
+%*******************************************************************************
+function toggleStochastic(h,event)
+
+% Determine if stochastic option is turned on or off
+gui     = getappdata(gcf,'gui');
+gui_var = getappdata(gcf,'gui_var');
+z = umtoggle(gui.OptionsMenu.runStochastic);
+if z == 1
+   flag = 'on';
+else
+   flag = 'off';
+end;
+
+% Turn on/off R&S displays
+set(gui.MADSMenu.editRSParam,   'Enable', flag);
+set([gui.RSPanel;gui.RSLabel'], 'Visible', flag);
+if ~gui_var.newMatlab
+   set([gui.RSBorder], 'Visible', flag);
+end
+rsfield = fieldnames(gui.RS);
+for k = 1:length(rsfield)
+   set(gui.RS.(rsfield{k}), 'Visible', flag);
+end
+return
+
+%*******************************************************************************
+% loadSession: Load session options from previously saved file.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Session-->Load Options from Session File)
+% Calls:     updateScreen
+% VARIABLES:
+%  sessionFile     = full path and name of session file
+%  gui_var         = structure of NOMADm variables
+%    .path         = path of current optimization problem
+%    .FileExt.S    = filename extension of session file
+%    .Choice       = current user choices
+%    .Options      = current option settings
+%  gui.problem     = object handle for Optimization Problem Name
+%  Session.Choice  = previously saved user choices 
+%  Session.Options = previously saved option settings
+%*******************************************************************************
+function loadSession(h,event)
+
+gui_var = getappdata(gcf,'gui_var');
+gui     = getappdata(gcf,'gui');
+
+sessionFile = fullfile(gui_var.path, ...
+              [get(gui.problem,'String'), gui_var.FileExt.S]);
+if exist(sessionFile,'file')
+   load(sessionFile);
+   gui_var.Choice  = Session.Choice;
+   gui_var.Options = Session.Options;
+   updateScreen(gui_var.Choice,gui_var.Options);
+   setappdata(gcf,'gui_var',gui_var);
+end
+return
+
+%*******************************************************************************
+% resetSession: Reset MADS Parameters to Default values.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Session-->Reset Options to Defaults),
+%            nomadm
+% Calls:     updateScreen
+% VARIABLES:
+%  gui_var.Choice           = current user choices
+%  gui_var.Options          = current option settings
+%  gui_var.Defaults.Choice  = default user choice settings
+%  gui_var.Defaults.Options = default options settings
+%*******************************************************************************
+function resetSession(h,event)
+
+gui_var = getappdata(gcf,'gui_var');
+gui_var.Choice  = gui_var.Defaults.Choice;
+gui_var.Options = gui_var.Defaults.Options;
+updateScreen(gui_var.Choice,gui_var.Options);
+setappdata(gcf,'gui_var',gui_var);
+return
+
+%*******************************************************************************
+% saveSession: Save session options to file for future retrieval.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Session-->Save Options to Session File)
+% Calls:     loadMADS
+% VARIABLES:
+%  sessionFile            = full path and name of session file
+%  gui_var                = structure of all GUI variables
+%    .path                =   path of current optimization problem
+%    .FileExt.S           =   filename extension of session file
+%    .Choice              =   current user choices
+%    .Options             =   current option settings
+%  gui                    = structure of GUI object handles
+%    .problem             =   name of current optimization problem
+%    .SessionMenu         =   handles for Session menu items
+%    .OptionsMenu         =   handles for Options menu items
+%    .runStatus           =   handle for figure window status bar
+%  Session                = previously saved options and parameters
+%    .Problem             =   optimization problem data
+%    .Choice              =   user choices 
+%    .Options             =   option settings
+%      .Term              =     termination criteria
+%        .iter            =       number of iterations
+%        .func            =       number of function evaluations
+%        .time            =       CPU time
+%        .fails           =       number of consecutive Poll failures
+%      .TermFlag.relative =     termination relative to initial mesh size
+%*******************************************************************************
+function saveSession(h,event)
+
+gui     = getappdata(gcbf,'gui');
+gui_var = getappdata(gcbf,'gui_var');
+
+sessionFile = [get(gui.problem,'String'), gui_var.FileExt.S];
+[Session.Problem,Session.Options] = loadMADS(gui,gui_var);
+Session.Options.Term.nIter  = get(gui.Term.nIter,  'String');
+Session.Options.Term.nFunc  = get(gui.Term.nFunc,  'String');
+Session.Options.Term.time   = get(gui.Term.time,   'String');
+Session.Options.Term.nFails = get(gui.Term.nFails, 'String');
+umtoggle(gui.OptionsMenu.TermFlag.relative);
+Session.Options.TermFlag.relative = umtoggle(gui.OptionsMenu.TermFlag.relative);
+Session.Choice = gui_var.Choice;
+save([gui_var.path, sessionFile],'Session');
+set(gui.runStatus,'String', ...
+   ['Session Options saved to file, ',sessionFile]);
+set([gui.SessionMenu.load; gui.SessionMenu.delete],'Enable','on');
+return
+
+%*******************************************************************************
+% saveCache: Save MADS run results in a .mat file for later retrieval.
+% ------------------------------------------------------------------------------
+% -
+% Called by: nomadm_gui (callback: Cache-->Save Run Results to Cache File),
+%            loadMADS
+% VARIABLES:
+%  gui             = structure of all GUI object handles
+%    .fig          =   handle for the GUI figure window
+%    .problem      =   name of current optimization problem
+%    .runStatus    =   handle for the GUI figure window status bar
+%    .CacheMenu    =   handles for Cache menu items
+%  gui_var         = structure of all GUI variables
+%    .runCount     =   MADS run number
+%    .path         =   path of current optimization problem
+%    .FileExt.C    =   default Cache filename suffix 
+%  CName           = name of Cache file
+%  RunSet(1).Cache = structure of MADS run data
+%  Cache           = storage of Cache for use by MADS
+%*******************************************************************************
+function saveCache(h,event)
+
+if isappdata(gcbf,'RunSet')
+   gui       = getappdata(gcbf,'gui');
+   gui_var   = getappdata(gcbf,'gui_var');
+   RunSet    = getappdata(gcbf,'RunSet');
+   setptr(gcf,'watch');
+   set(gui.runStatus, 'String', ...
+       ['Run # ',int2str(gui_var.runCount),' Cache being saved']);
+   CName = [get(gui.problem, 'String'), gui_var.FileExt.C];
+   Cache = RunSet(1).Cache;
+   save([gui_var.path, CName],'Cache');
+   set([gui.CacheMenu.load;gui.CacheMenu.count;gui.CacheMenu.delete], ...
+       'Enable','on');
+   set(gui.runStatus, 'String', ...
+       ['Run # ',int2str(gui_var.runCount),' Cache saved in ',CName]);
+   setptr(gcbf,'arrow');
+else
+   error('Cannot save.  Cache not found');
+end
+return
+
+%*******************************************************************************
+% deleteFile: Delete a Session or Cache file.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Session-->Delete Session File), 
+%            nomadm_gui (callback: Cache-->Delete Pre-Existing Cache File)
+% VARIABLES:
+%  param          = user data that identifies file to be deleted
+%  fileID         = string identifing file to be deleted
+%  fileExt        = filename suffix of file to be deleted
+%  handles        = handles of menu choices to be disabled
+%  file           = full path and name of file to be deleted
+%  deleteFile     = logical for deleting file
+%  gui_var.path   = path of current optimization problem
+%  gui            = structure of all GUI object handles
+%    .runStatus   =   object handle for figure window status bar
+%    .problem     =   name of current optimization problem
+%*******************************************************************************
+function deleteFile(h,event)
+
+gui_var = getappdata(gcbf,'gui_var');
+gui     = getappdata(gcbf,'gui');
+param   = get(gcbo,'UserData');
+[fileID,fileExt,handles] = deal(param{:});
+file  = fullfile(gui_var.path,[get(gui.problem,'String'),fileExt]);
+deleteFile = questdlg(['Are you sure you want to delete ',file,'?'], ...
+                      ['Delete ',fileID,'?'],'No');
+if strcmp(deleteFile, 'Yes')
+   delete(file);
+   set(gui.runStatus,'String', [fileID,', ',file,', has been deleted']);
+   set([handles; gcbo],'Enable','off');
+end
+return
+
+%*******************************************************************************
+% clearRuns: Clear figure window and reset all the appropriate variables.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Run-->Clear Previous Runs),
+%            selectProblem
+% VARIABLES:
+%  gui               = structure of all GUI object handles
+%    .fig            =   handle for GUI figure window
+%    .stopRun        =   handle for Stop Run pushbutton
+%    .resumeRun      =   handle for Resume Run pushbutton
+%    .axesHistory    =   handle for History plot
+%    .axesFilter     =   handle for Filter plot
+%    .ResultsMenu    =   handles for Results menu items
+%    .RunMenu        =   handles for Run menu items
+%    .CacheMenu      =   handles for Cache menu items
+%    .runStatus      =   handle for figure window status bar
+%  gui_var           = structure of all GUI variables
+%    .runMax         =   maximum nmber of MADS runs
+%    .runCount       =   MADS run counter
+%  RunSet            = structure of MADS run data
+%*******************************************************************************
+function clearRuns(h,event)
+
+% Delete application data
+if isappdata(gcbf,'RunSet')
+   rmappdata(gcbf,'RunSet');
+end
+if isappdata(0,'CACHE')
+   rmappdata(0,'CACHE');
+end
+if isappdata(0,'sCACHE')
+   rmappdata(0,'sCACHE');
+end
+if isappdata(0,'surrogate')
+   rmappdata(0,'surrogate');
+end
+
+% Reset properties of gui object handles
+gui = getappdata(gcbf,'gui');
+set([gui.RunMenu.clear; gui.CacheMenu.save],             'Enable', 'off');
+set([gui.RunMenu.resume;gui.RunMenu.restart],            'Enable', 'off');      
+set([gui.stopRun;       gui.resumeRun],                  'Visible','off');      
+set([gui.Menu.Results;  gui.ResultsMenu'],               'Visible','off');
+set([gui.axesFilter;    get(gui.axesFilter, 'Children')],'Visible','off');
+set([gui.axesHistory;   get(gui.axesHistory,'Children')],'Visible','off');
+set( gui.axesHistory,   'NextPlot','replace');
+set( gui.runStatus,     'String',  'All runs cleared');
+
+% Reset the run counter
+gui_var = getappdata(gcbf,'gui_var');
+gui_var.runCount = 0;
+setappdata(gcbf,'gui_var',gui_var);
+
+% Reset everything else
+cla;
+setptr(gcbf,'arrow');
+clear functions;
+return
+
+%*******************************************************************************
+% getHelp: View a Help file.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Help-->NOMADm Help),
+%            nomadm_gui (callback: Help-->DACE Toolbox Help),
+%            nomadm_gui (callback: Help-->NW Toolbox Help),
+%            nomadm_gui (callback: Help-->CMA-ES Toolbox Help),
+%            nomadm_gui (callback: Help-->View List of Version CHanges),
+%            nomadm_gui (callback: Help-->View GNU Public License),
+% VARIABLES:
+%  helpfile  = name of the help file to be displayed
+%  errormsg  = message to display when error is flagged
+%  errorflag = error flag for viewing failure
+%*******************************************************************************
+function getHelp(h,event)
+
+helpfile = which(get(gcbo,'UserData'));
+if isempty(helpfile)
+   errormsg = ['Error: Help file not found on the Matlab path.  ', ...
+               'Use "File-->Set Path" to add location to Matlab path.'];
+   errordlg(errormsg);
+end
+errorflag = web(['file:///', helpfile], '-browser');
+if (errorflag), errordlg('Error: Browser or help file not found'); end
+return
+
+%*******************************************************************************
+% getAbout: View author information.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Help-->About NOMADm)
+% VARIABLES:
+%    pversion     = current version number of this software
+%    contributors = list of people who have contributed to this software
+%*******************************************************************************
+function getAbout(h,event,pversion,contributors)
+
+msgbox({['NOMADm, version ',pversion], ...
+        'Copyright (c) 2001-2005 by Mark A. Abramson','', ...
+        'Special Thanks to:','', ...
+         contributors{:}},get(gcbo,'Label'));
+return
+
+%*******************************************************************************
+% copyPlot: Copy history or filter plot to a new screen.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (ButtonDown Function: History and Filter Plots)
+% VARIABLES:
+%  h1 = handle to new figure window
+%  h2 = handle to new axes on figure window
+%*******************************************************************************
+function copyPlot(h,event)
+
+h1 = figure;
+h2 = copyobj(gcbo,h1);
+set(h2,'Position','default','ButtonDownFcn','');
+return
+
+%*******************************************************************************
+% END OF SIMPLE NOMADm GUI CALLBACK FUNCTIONS
+%*******************************************************************************
+
+%*******************************************************************************
+% runMADS:  Assign GUI input fields to MADS variables and run MADS.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Run-->Execute Next Run)
+%            nomadm_gui (callback: Run-->Resume a Stopped Run)
+%            nomadm_gui (callback: Run-->Restart Run from Current Point)
+% Calls:     loadMADS, saveCache, mads
+% VARIABLES:
+%  restart           = flag for resuming previous run
+%  gui_var           = structure containing all GUI variables
+%    .runCount       =   current MADS run number
+%    .runMax         =   maximum allowed MADS run number
+%    .Options.runUntilFeasible = flag for running until a feasible poi
+%  gui_func          = structure of all NOMADm function handles
+%  gui               = structure of GUI object handles
+%    .fig            =   handle for the main figure window
+%    .stopRun        =   handle for Stop Run pushbutton
+%    .resumeRun      =   handle for Resume Run pushbutton
+%    .axesFilter     =   handle for Filter plot
+%    .axesHistory    =   handle for History plot
+%    .RunMenu        =   handles for Run menu items
+%    .ResultsMenu    =   handles for Results menu items
+%    .CacheMenu      =   handles for Cache menu items
+%    .runStatus      =   handle for figure window status bar
+%  RunSet            = global variable used to store MADS output data
+%    .BestF          =   best feasible solution found by MADS
+%    .BestI          =   best infeasible solution found by MADS
+%    .RunStats       =   structure of MADS run statistics
+%      .delta        =     current mesh size
+%      .time         =     current CPU time expended
+%      .Cache        =   structure of all processed MADS iterates
+%  Problem           = structure containing optimization problem data
+%    .File.I         =   name of initial points file
+%  Options           = structure containing MADS parameters
+%    .loadCache      =   flag for loading a pre-existing Cache file
+%    .countCache     =   flag for counting Cache points as function calls
+%    .delta0         =   initial mesh size
+%    .runCount       =   current MADS run number
+%  iterate0          = initial iterate
+%  BestF             = best feasible iterate found by MADS
+%  BestI             = least infeasible iterate found by MADS
+%  RunStats          = structure containing MADS run statistics
+%*******************************************************************************
+function runMADS(h,event,restart)
+
+% Get application data
+fig       = findobj(0,'Tag','NOMADm_GUI');
+gui_var   = getappdata(fig,'gui_var');
+gui_func  = getappdata(fig,'gui_func');
+gui       = getappdata(fig,'gui');
+if isappdata(fig,'RunSet')
+   RunSet = getappdata(fig,'RunSet');
+end
+
+% Set flag for running only until a feasible point is found
+if (restart == -1)
+   gui_var.Options.runUntilFeasible = 1;
+end
+
+lasterr('NOMADm interrupted by user');
+try
+catch
+end
+   % Change figure window, as appropriate
+   if (gui_var.runCount >= gui_var.runMax)
+      error('Too many MADS runs without clearing.');
+   end
+   setptr(fig,'watch');
+   set(gui.stopRun,   'Visible','on','UserData',0);
+   set(gui.resumeRun, 'Visible','off');
+   set(gui.RunMenu.clear,'Enable','on');
+   set([gui.axesFilter; get(gui.axesFilter,'Children')], 'Visible', 'off');
+   set(gui.axesFilter,'ButtonDownFcn','');
+   drawnow;
+
+   % Load MADS input data
+   [Problem,Options] = loadMADS(gui,gui_var);
+   Options.Search(Options.nSearches+1:end) = [];
+   
+   % Get initial point
+   if (restart > 0)
+      iterate0 = [RunSet(gui_var.runCount).BestF, ...
+                  RunSet(gui_var.runCount).BestI];
+   elseif (~restart && exist(Problem.File.I,'file'))
+      iterate0 = feval(Problem.File.I);
+   else
+      error(['Cannot find: ', Problem.File.I, '.m']);
+   end
+
+   % Set up and run MADS algorithm and store output
+   if (restart == 2)
+      saveCache(1,0);
+      set(gui.axesHistory, 'NextPlot','replacechildren');
+      Options.loadCache  = 1;
+      Options.countCache = 1;
+      Options.plotColor  = gui_var.Types.plotColors(gui_var.runCount);
+      Options.delta0     = RunSet(gui_var.runCount).RunStats.delta;
+      RunStats           = RunSet(gui_var.runCount).RunStats;
+      set(gui.runStatus,'String',['Resuming Run # ',int2str(gui_var.runCount)]);
+      [BestF,BestI,RunStats,RunSet(1).Cache] = mads(Problem,iterate0, ...
+                                                    Options,RunStats);
+      delete(fullfile(gui_var.path,Problem.File.C));
+      set([gui.CacheMenu.load; gui.CacheMenu.count; gui.CacheMenu.delete], ...
+          'Enable','off');
+   else
+      set(gui.runStatus,'String', ...
+                       ['Processing Run # ',int2str(gui_var.runCount+1)]);
+      [BestF,BestI,RunStats,RunSet(1).Cache] = mads(Problem,iterate0,Options);
+      gui_var.runCount = gui_var.runCount+1;
+   end
+   RunSet(gui_var.runCount).BestF    = BestF;
+   RunSet(gui_var.runCount).BestI    = BestI;
+   RunSet(gui_var.runCount).RunStats = RunStats;
+   if (RunStats.time > 60)
+      load train;
+      sound(y);
+   end
+
+% Perform these tasks if error in MADS run
+try
+catch
+   set(gui.runStatus,'String',['Run # ',int2str(gui_var.runCount+1),' failed']);
+   set([gui.axesFilter; get(gui.axesFilter, 'Children')],'Visible','off');
+   if (gui_var.runCount == 0)
+      set([gui.axesHistory; get(gui.axesHistory,'Children')],'Visible','off');
+   else
+      set(gui.axesHistory,'ButtonDownFcn',gui_func.copyPlot);
+   end
+   RunSet(1).Cache = [];
+   errordlg(lasterr,'MADS Runtime Error','modal'); beep
+   rethrow(lasterror)
+   rmappdata(0,'CACHE');
+end
+
+% Change figure window, as appropriate
+set(gui.axesHistory, 'NextPlot','add');
+set(gui.axesHistory, 'ButtonDownFcn',gui_func.copyPlot);
+set(gui.axesFilter,  'ButtonDownFcn',gui_func.copyPlot);
+
+if (gui_var.runCount > 0)
+   set([gui.CacheMenu.save;gui.RunMenu.resume;gui.RunMenu.restart],'Enable','on');
+   set([gui.Menu.Results; gui.ResultsMenu(gui_var.runCount)],'Visible','on');
+   set(gui.runStatus,'String',['Run # ',int2str(gui_var.runCount),' complete']);
+end
+set(gui.stopRun,   'Visible','off','UserData',0);
+set(gui.resumeRun, 'Visible','on');
+setptr(fig,'arrow');
+setappdata(fig,'gui_var',gui_var);
+setappdata(fig,'RunSet',RunSet);
+
+return
+
+%*******************************************************************************
+% loadMADS:  Assign GUI input fields to MADS variables.
+% ------------------------------------------------------------------------------
+% Called by: saveSession, runMADS
+% Calls:     nomadm_compile
+% VARIABLES:
+%  Problem              = structure containing optimization problem data
+%    .File              =   structure of problem file names
+%      .F               =   name of functions file
+%      .O               =   name of Omega file
+%      .I               =   name of initial points file
+%      .N               =   name of discrete neighbors file
+%      .C               =   name of Cache File
+%      .nameCache       =   name of the base workspace Cache variable
+%      .fType           =   type of functions file (M=MATLAB,F=FORTRAN,C=C)
+%  Options              = structure containing MADS parameters
+%    .nSearches         =   number of Search types used
+%    .Search(n)         =   structure of Search parameters
+%      .type            =     string identifying the type of Search
+%    .pollStrategy      =   string identifying selected Poll strategy
+%    .pollOrder         =   string identifying selected Poll order strategy
+%    .pollCenter        =   integer identifying selected Poll center
+%    .pollComplete      =   turns on/off complete Polling
+%    .loadCache         =   flag for loading a pre-existing Cache file
+%    .countCache        =   flag for counting Cache points as function calls
+%    .useFilter         =   use filter for nonlinear constraints
+%    .removeRedundancy  =   remove redundant linear constraints
+%    .runStochastic     =   flag for running as a stochastic problem
+%    .accelerate        =   flag for accelerating mesh refinement
+%    .scale             =   flag for scaling mesh directions
+%    .plotHistory1      =   turns on/off a history plot
+%    .plotHistory2      =   turns on/off a real-time history plot
+%    .plotFilter        =   turns on/off a real-time filter plot
+%    .runOneIteration   =   flag for running one MADS iteration at a time
+%    .runUntilFeasible  =   flag for running MADS only until feasible
+%    .runCount          =   MADS run counter
+%    .hplothandle       =   handle for history plot axes
+%    .fplothandle       =   handle for filter plot axes
+%    .stophandle        =   handle for Stop Run pushbutton
+%    .delta0            =   initial mesh size
+%    .deltaMax          =   maximum mesh size
+%    .meshRefine        =   mesh refinement factor
+%    .meshCoarsen       =   mesh coarsening factor
+%    .tolCache          =   tolerance for flagging point as being in Cache
+%    .hmin              =   minimum h-value of an infeasible point
+%    .hmax              =   maximum h-value of a filter point
+%    .ePollTriggerF     =   f-value Extended Poll trigger
+%    .ePollTriggerH     =   h-value Extended Poll trigger
+%    .Term              =   substructure containing MADS termination criteria
+%      .delta           =     mesh size parameter
+%      .iter            =     maximum number of MADS iterations
+%      .func            =     maximum number of function evaluations
+%      .time            =     maximum CPU time
+%      .fails           =     maximum number of consecutive Poll failures
+%    .TermFlag          =   substructure of termination criteria on/off switches
+%      .iter            =     turns on/off number of iterations
+%      .nFunc           =     turns on/off number of function evaluations
+%      .time            =     turns on/off CPU time
+%      .nFails          =     turns on/off number of consecutive Poll failures
+%      .relative        =     computes termination delta relative to .delta0
+%  gui_var              = structure containing all GUI variables
+%    .path              =   path of current optimization problem
+%    .problemExt        =   filename extension of optimization problem 
+%    .Options           =   current Options values
+%    .Types             = lists of possible type
+%      .Search          =   list of possible Search types
+%      .poll            =   list of possible Poll strategies
+%      .pollOrder       =   list of possible Poll order strategies
+%    .Choice            = user choices
+%      .pollStrategy    =   selected Poll strategy
+%      .pollCenter      =   selected Poll center
+%      .pollOrder       =   selected Poll order strategy
+%  gui                  = structure of GUI object handles
+%    .runStatus         =   handle for GUI figure window status bar
+%    .problem           =   name of current optimization problem
+%    .CacheMenu         =   handles for Cache menu items
+%    .MADSMenu          =   handles for MADS menu items
+%    .OptionsMenu       =   handles for Options menu items
+%    .RunMenu           =   handles for Run menu items
+%    .delta0            =   current initial mesh size
+%    .deltaMax          =   current maximum mesh size
+%    .meshRefine        =   current mesh refinement factor
+%    .meshCoarsen       =   current mesh coarsening factor
+%    .tolCache          =   current Cache tolerance
+%    .hmin              =   current minimum infeasible h-value
+%    .hmax              =   current maximum filter h-value
+%    .ePollXiF          =   current f-value Extended Poll trigger
+%    .ePollXiH          =   current h-value Extended Poll trigger
+%    .Term              =   structure of handles for current termination criteria
+%      .delta           =     current mesh size
+%      .nIter           =     current maximum number of MADS iterations
+%      .nFunc           =     current maximum number of function evaluations
+%      .time            =     current maximum CPU time
+%      .nFails          =   current max number of consecutive Poll failures
+%    .TermFlag          =   structure of handles for termination checkboxes
+%      .nIter           =     handle for number of iterations
+%      .nFunc           =     handle for number of function evaluations
+%      .time            =     handle for CPU time
+%      .nFails          =     handle for number of consecutive Poll failures
+%  nameProblem          = name of the optimization problem to be solved
+%  language             = programming language of functions file
+%  k                    = Search counter
+%  field                = cell array of field names of the gui.Term substructure
+%*******************************************************************************
+function [Problem,Options] = loadMADS(gui,gui_var)
+
+% Transfer Optimization Problem data from GUI into MADS input variables
+addpath(gui_var.path);
+Problem.nameCache = gui_var.nameCache;
+nameProblem = get(gui.problem,'String');
+
+ext = fieldnames(gui_var.FileExt);
+for k = 1:length(ext)
+   Problem.File.(ext{k}) = [nameProblem,gui_var.FileExt.(ext{k})];
+end
+
+% Compile non-Matlab Functions file, if possible
+Problem.fType  = upper(gui_var.problemExt(2));
+if ~strcmp(Problem.fType,'M')
+   language = nomadm_compile(Problem.fType, ...
+                           gui_var.path,Problem.File.F,gui_var.problemExt);
+   set(gui.runStatus,'String',['Compiling ',language,' function file']);
+end
+
+% Transfer user options from GUI into MADS input variables
+umtoggle(gui.scaleMenu(2));
+umtoggle(gui.scaleMenu(3));
+umtoggle(gui.CacheMenu.load);
+umtoggle(gui.CacheMenu.count);
+umtoggle(gui.MADSMenu.pollComplete);
+umtoggle(gui.OptionsMenu.useFilter);
+umtoggle(gui.OptionsMenu.removeRedundancy);
+umtoggle(gui.OptionsMenu.runStochastic);
+umtoggle(gui.OptionsMenu.accelerate);
+umtoggle(gui.OptionsMenu.plotFilter);
+umtoggle(gui.OptionsMenu.plotHistory1);
+umtoggle(gui.OptionsMenu.plotHistory2);
+umtoggle(gui.RunMenu.execFeasible);
+umtoggle(gui.RunMenu.oneIteration);
+umtoggle(gui.OptionsMenu.TermFlag.relative);
+
+Options = gui_var.Options;
+for k = 1:Options.nSearches
+   Options.Search(k).type = gui_var.Types.search{gui_var.Choice.search(k)};
+end
+Options.pollStrategy      = gui_var.Types.poll{gui_var.Choice.pollStrategy};
+Options.pollOrder         = gui_var.Types.pollOrder{gui_var.Choice.pollOrder};
+Options.pollCenter        = gui_var.Choice.pollCenter - 1;
+Options.pollComplete      = umtoggle(gui.MADSMenu.pollComplete);
+Options.loadCache         = umtoggle(gui.CacheMenu.load);
+Options.countCache        = umtoggle(gui.CacheMenu.count);
+Options.useFilter         = umtoggle(gui.OptionsMenu.useFilter);
+Options.removeRedundancy  = umtoggle(gui.OptionsMenu.removeRedundancy);
+Options.runStochastic     = umtoggle(gui.OptionsMenu.runStochastic);
+Options.accelerate        = umtoggle(gui.OptionsMenu.accelerate);
+Options.scale             =  2*umtoggle(gui.scaleMenu(2)) + ...
+                            10*umtoggle(gui.scaleMenu(3));
+Options.plotFilter        = umtoggle(gui.OptionsMenu.plotFilter);
+Options.plotHistory1      = umtoggle(gui.OptionsMenu.plotHistory1);
+Options.plotHistory2      = umtoggle(gui.OptionsMenu.plotHistory2);
+Options.runOneIteration   = umtoggle(gui.RunMenu.oneIteration);
+Options.runUntilFeasible  = umtoggle(gui.RunMenu.execFeasible);
+Options.TermFlag.relative = umtoggle(gui.OptionsMenu.TermFlag.relative);
+Options.plotColor         = gui_var.Types.plotColors(gui_var.runCount+1);
+Options.hplothandle       = gui.axesHistory;
+Options.fplothandle       = gui.axesFilter;
+Options.stophandle        = gui.stopRun;
+Options.delta0            = str2double(get(gui.delta0,      'String'));
+Options.deltaMax          = str2double(get(gui.deltaMax,    'String'));
+Options.meshRefine        = str2double(get(gui.meshRefine,  'String'));
+Options.meshCoarsen       = str2double(get(gui.meshCoarsen, 'String'));
+Options.tolCache          = str2double(get(gui.tolCache,    'String'));
+Options.hmin              = str2double(get(gui.hmin,        'String'));
+Options.hmax              = str2double(get(gui.hmax,        'String'));
+Options.ePollTriggerF     = str2double(get(gui.ePollXiF,    'String'));
+Options.ePollTriggerH     = str2double(get(gui.ePollXiH,    'String'));
+
+% Process Termination Criteria
+field = fieldnames(gui.Term);
+for k = 1:length(field)
+   Options.Term.(field{k})     = str2double(get(gui.Term.(field{k}),'String'));
+   Options.TermFlag.(field{k}) = get(gui.TermFlag.(field{k}),       'Value');
+   if ~Options.TermFlag.(field{k}), Options.Term.(field{k}) = Inf; end
+end
+if (Options.TermFlag.relative)
+   Options.Term.delta = Options.Term.delta*Options.delta0;
+end
+
+% Process RS Parameters
+field = fieldnames(gui.RS);
+for k = 1:length(field)
+   Options.RS.(field{k}) = str2double(get(gui.RS.(field{k}),'String'));
+end
+
+return
+
+%*******************************************************************************
+% search_gui:  Displays a user input screen to set Search parameters.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: MADS-->Select Search Strategies)
+% Calls:     modifySearchScreen, loadUserSearchFile, loadSearchOptions
+% VARIABLES:
+%  guiSearch         = structure for the Search GUI and its object handles
+%    .fig            =   handle for Search figure window
+%    .n              =   handle for Number of Search Types popup menu
+%    .SurOptimizer   =   handle for surrogate optimizer popup menu
+%    .Screen         = structure of handles for each k of n Searches
+%      .label        =   handle for Search text label
+%      .type         =   handle for popupmenu of possible Search types
+%      .nIter        =   handle for number of iterations field
+%      .nPoints      =   handle for number of Search points field
+%      .file         =   handle for string containing name of Search file
+%    .done           =   handle for Done pushbutton
+%    .cancel         =   handle for Cancel pushbutton   
+%  gui_var           = structure of GUI variables
+%    .maxSearches    = maximum number of Search types that can be selected
+%    .Labels         = long text labels used in popup menus
+%      .Search       =   labels used in each Search type popup menu
+%      .optimizer    =   labels for the surrogate optimizer to be used
+%    .Choice.Search  = integers recording Search type popup menu choices
+%    .Options.Search = vector of structures for each k of n Searches
+%      .nIter        =   number of iterations
+%      .nPoints      =   number of Search points
+%      .file         =   string containing name of optional Search file
+%  k                 = Search type counter
+%  row               = row location of current Search figure window object
+%  pathStr           = temporary storage for Search file path
+%  filename          = temporary storage for Search filename
+%  fileExt           = temporary storage for Search filename extension
+%*******************************************************************************
+function search_gui(h,event)
+
+gui_var  = getappdata(gcbf,'gui_var');
+gui_func = getappdata(gcbf,'gui_func');
+
+%Set up "Search Options" figure window
+guiSearch.fig = figure(...
+   'Name',                           'Set Options for MADS SEARCH step', ...
+   'Tag',                            'Search_GUI', ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.375, ...,
+   'DefaultUIControlStyle',           'text', ...
+   'WindowStyle',                     'modal', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.15 0.1 0.8 0.7], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+
+% Set up panel for Top deisplays
+panelColor = get(guiSearch.fig,'DefaultUIControlBackgroundColor');
+
+if gui_var.newMatlab
+   guiSearch.panel = uipanel('Parent',guiSearch.fig, ...
+                             'Position',[0, .9, 1, .1], ...
+                             'BorderType','beveledin', ...
+                             'BackgroundColor',panelColor);
+
+   % Display Number of Search Types and Surrogate Optimizer
+   uicontrol(guiSearch.panel, ...
+       'Style',           'text', ...
+       'String',          'Number of Search Types: ', ...
+       'Position',        [.12 0 .18 .6]);
+   guiSearch.n = uicontrol(guiSearch.panel, ...
+       'Style',           'popupmenu', ...
+       'String',          {'0','1','2','3','4','5','6','7','8'}, ...
+       'BackgroundColor', 'white', ...
+       'Value',           gui_var.Options.nSearches+1, ...
+       'Position',        [.31 .03 .05 .65], ...
+       'Callback',        gui_func.modifySearchScreen);
+   uicontrol(guiSearch.panel, ...
+       'Style',           'text', ...
+       'String',          'Surrogate Optimizer: ', ...
+       'Position',        [.45 0 .15 .6]);
+   guiSearch.SurOptimizer = uicontrol(guiSearch.panel, ...
+       'Style',           'popupmenu', ...
+       'String',          gui_var.Labels.optimizer, ...
+       'BackgroundColor', 'white', ...
+       'Value',           gui_var.Choice.optimizer, ...
+       'Position',        [.61 .03 .33 .65]);
+
+else
+   
+   % Additional figure window partitioning lines and panel
+   uicontrol(guiSearch.fig, 'Style','frame','Position', [0, .896, 1, .004],...
+       'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+   uicontrol(guiSearch.fig, 'Style','frame','Position', [0, .9,   1, .004],...
+       'ForegroundColor','white','BackgroundColor','white');
+   uicontrol(guiSearch.fig, 'Style','frame','Position',[0,  .9,  1, .1], ...
+      'ForegroundColor',panelColor,'BackgroundColor',panelColor);
+
+   % Display Number of Search Types and Surrogate Optimizer
+   uicontrol(guiSearch.fig, 'Style', 'text', ...
+       'String', 'Number of Search Types: ', ...
+       'Position', [.13 .905 .20 .06]);
+   guiSearch.n = uicontrol(guiSearch.fig, ...
+       'Style',           'popupmenu', ...
+       'String',          {'0','1','2','3','4','5','6','7','8'}, ...
+       'BackgroundColor', 'white', ...
+       'Value',           gui_var.Options.nSearches+1, ...
+       'Position',        [.35 .9125 .05 .06], ...
+       'Callback',        gui_func.modifySearchScreen);
+   uicontrol(guiSearch.fig, 'Style', 'text', ...
+       'String', 'Surrogate Optimizer: ', ...
+       'Position', [.48 .905 .15 .06]);
+   guiSearch.SurOptimizer = uicontrol(guiSearch.fig, ...
+       'Style',           'popupmenu', ...
+       'String',          gui_var.Labels.optimizer, ...
+       'BackgroundColor', 'white', ...
+       'Value',           gui_var.Choice.optimizer, ...
+       'Position',        [.63 .9125 .32 .06]);
+end
+
+
+% Text headers for the Search parameters
+set(guiSearch.fig,'DefaultUIControlBackgroundColor',[.8,.8,.8]);
+uicontrol(guiSearch.fig, 'Style', 'text', ...
+    'String', 'Search Strategy', ...
+    'Position', [.12 .80 .31 .06]);
+uicontrol(guiSearch.fig, 'Style', 'text', ...
+    'String', 'Number of Iterations', ...
+    'Position', [.45 .80 .15 .06]);
+uicontrol(guiSearch.fig, 'Style', 'text', ...
+    'String', 'Number of Points', ...
+    'Position', [.62 .80 .16 .06]);
+uicontrol(guiSearch.fig, 'Style', 'text', ...
+    'String', 'User File', ...
+    'Position', [.80 .80 .16 .06]);
+
+% Main loop for each of n Searches
+for k = 1:gui_var.maxSearches
+   row = .76 - .08*(k-1);
+
+   guiSearch.Screen(k).label = uicontrol(guiSearch.fig, ...
+      'Style',           'text', ...
+      'String',          ['Search #', int2str(k), ':'], ...
+      'Position',        [.03, row-.0075, .08, .06]);
+
+   % The data fields for each Search
+   guiSearch.Screen(k).type = uicontrol(guiSearch.fig, ...
+      'Style',           'popupmenu', ...
+      'String',          gui_var.Labels.search, ...
+      'BackgroundColor', 'white', ...
+      'Value',           gui_var.Choice.search(k), ...
+      'Position',        [.12, row, .31, .06], ...
+      'UserData',        {k,gui_var.Choice.search(k), ...
+                         gui_var.Options.Search(k).local, ...
+                         gui_var.Options.Search(k).merit}, ...
+      'Callback',        gui_func.loadUserSearchFile);
+   guiSearch.Screen(k).nIter = uicontrol(guiSearch.fig, ...
+      'Style',           'edit', ...
+      'String',          int2str(gui_var.Options.Search(k).nIter), ...
+      'BackgroundColor', 'white', ...
+      'FontSize',        .64, ...
+      'Position',        [.45, row+.02, .15, .04]);
+   guiSearch.Screen(k).nPoints = uicontrol(guiSearch.fig, ...
+      'Style',           'edit', ...
+      'String',          int2str(gui_var.Options.Search(k).nPoints), ...
+      'BackgroundColor', 'white', ...
+      'FontSize',        .64, ...
+      'Position',        [.62, row+.02, .16, .04]);
+   [pathStr,filename,fileExt] = fileparts(gui_var.Options.Search(k).file);
+   guiSearch.Screen(k).file = uicontrol(guiSearch.fig, ...
+      'Style',           'text', ...
+      'String',          [filename,fileExt], ...
+      'ForegroundColor', 'red', ...
+      'Position',        [.80, row, .16, .06], ...
+      'UserData',        pathStr);
+end
+
+% The Done and Cancel Buttons
+guiSearch.done = uicontrol(guiSearch.fig, ...
+   'Style',      'pushbutton', ...
+   'String',     'Done', ...
+   'FontWeight', 'bold', ...
+   'Position',   [.33, .04, .10, .08], ...
+   'UserData',   1, ...
+   'Callback',   gui_func.loadSearchOptions);
+guiSearch.cancel = uicontrol(guiSearch.fig, ...
+   'Style',      'pushbutton', ...
+   'String',     'Cancel', ...
+   'FontWeight', 'bold', ...
+   'Position',   [.50, .04, .10, .08], ...
+   'UserData',   0, ...
+   'Callback',   gui_func.loadSearchOptions);
+
+setappdata(guiSearch.fig,'guiSearch',guiSearch);
+modifySearchScreen(2,0);
+return
+
+%*******************************************************************************
+% modifySearchScreen: Modify the Search Input Screen.
+% ------------------------------------------------------------------------------
+% Called by: search_gui (callback: Number of Search Types popupmenu
+%            search_gui (directly)
+% VARIABLES:
+%  fig            = temporary storage of figure handles
+%  gui_var        = structure of all GUI variables
+%    .nSearches   =   handle for Number of Search Types popup menu
+%    .maxSearches =   maximum number of Search types allowed
+%  guiSearch      = structure of all Search window object handles
+%    .n           =   number of Search types popup menu
+%    .Screen(k)   =   Search fields for the Search #k
+%      .label     =     text label appearing on the Search Screen
+%      .type      =     type of Search
+%      .nIter     =     number of iterations
+%      .nPoints   =     number of Search points
+%      .file      =     file used during Search
+%    .done        =   handle for Search input screen Done button
+%    .cancel      =   handle for Search Input Screen Cancel button   
+%  nSearches      = number of Search types selected
+%  pos            = screen position of the final Search field
+%*******************************************************************************
+function modifySearchScreen(h,event)
+
+% Get application data
+fig       = findobj('Tag','NOMADm_GUI');
+gui_var   = getappdata(fig,'gui_var');
+fig       = findobj('Tag','Search_GUI');
+guiSearch = getappdata(fig,'guiSearch');
+
+% Turn on/off appropriate Search fields
+nSearches = get(guiSearch.n,'Value') - 1;
+for k = 1:gui_var.maxSearches
+   if (k <= nSearches)
+      set(guiSearch.Screen(k).label,   'Visible','on');
+      set(guiSearch.Screen(k).type,    'Visible','on');
+      set(guiSearch.Screen(k).nIter,   'Visible','on');
+      set(guiSearch.Screen(k).nPoints, 'Visible','on');
+      set(guiSearch.Screen(k).file,    'Visible','on');
+   else
+      set(guiSearch.Screen(k).label,   'Visible','off');
+      set(guiSearch.Screen(k).type,    'Visible','off','Value', 1);
+      set(guiSearch.Screen(k).nIter,   'Visible','off','String','1');
+      set(guiSearch.Screen(k).nPoints, 'Visible','off','String','1');
+      set(guiSearch.Screen(k).file,    'Visible','off','String','');
+   end
+end
+
+% Move Done and Cancel buttons
+if nSearches
+   pos = get(guiSearch.Screen(nSearches).type,'Position');
+else
+   pos = [.01, .82];
+end
+set(guiSearch.done,   'Position', [.33, pos(2)-.16, .10, .08]);
+set(guiSearch.cancel, 'Position', [.50, pos(2)-.16, .10, .08]);
+return
+
+%*******************************************************************************
+% loadUserSearchFile: Load a user-specified Search file.
+% ------------------------------------------------------------------------------
+% Called by: search_gui (callback: each Search Strategy popup menu)
+% Calls:     dace_gui, nw_gui
+% VARIABLES:
+%  fig                   = temporary storage of figure handles
+%  gui_var               = structure of all GUI variables
+%    .Types.search       =   list of possible Search types
+%    .maxSearches        =   maximum number of Searches that can be done
+%  guiSearch             = handles for all Search window objects
+%    .Screen.file        =   handle for Search figure window user file
+%  newValue              = number associated with Search menu choice
+%  userData              = temporary storage of GUI object user data
+%  k                     = Search number
+%  previousType          = previously selected Search type
+%  gui_func              = handles of all NOMADm callback functions
+%    .loadUserSearchFile = handle for the function of the same name
+%  SName, SPath          = name and path of user Search file
+%  spec                  = file types for use in input dialog boxes
+%*******************************************************************************
+function loadUserSearchFile(h,event)
+
+% Get application data
+fig       = findobj('Tag','NOMADm_GUI');
+gui_var   = getappdata(fig,'gui_var');
+gui_func  = getappdata(fig,'gui_func');
+fig       = findobj('Tag','Search_GUI');
+guiSearch = getappdata(fig,'guiSearch');
+
+newValue  = get(gcbo, 'Value');
+userData  = get(gcbo, 'UserData');
+[k,previousType,local,merit] = deal(userData{:});
+
+switch gui_var.Types.search{newValue}
+
+% Load a custom Search or Surrogate file 
+case {'Custom','CustomS'}
+   spec = {'*.m',        'Matlab M-files (*.m)'; ...
+           '*.f; *.for', 'Fortran files (*.f,*.for)'; ...
+           '*.c; *.C',   'C/C++ files (*.c,*.C)'};
+   [sName,sPath] = uigetfile(spec,['Choose File for Search #',int2str(k)]);
+   if (sName)
+      set(guiSearch.Screen(k).file, 'UserData', sPath);
+      set(guiSearch.Screen(k).file, 'String',   sName);
+      set(gcbo, 'UserData',{k,newValue});
+   else
+      set(gcbo, 'Value', previousType);
+   end
+
+% Load a DACE surrogate
+case {'DACE'}
+   dace_gui(k,gui_var,gui_func);
+   
+% Load a NW surrogate
+case {'NW'}
+   nw_gui(k,gui_var,gui_func);
+
+% Do not load a file
+otherwise
+   set(guiSearch.Screen(k).file, 'String', '');
+   set(gcbo, 'UserData',{k,newValue,local,merit});
+end
+return
+
+%*******************************************************************************
+% loadSearchOptions: Load selected Search parameters.
+% ------------------------------------------------------------------------------
+% Called by: search_gui (callback: Done and Cancel pushbuttons
+% Calls:     updateSearchLabels
+% VARIABLES:
+%  k                = Search number
+%  fig              = temporary storage of the appropriate figure handle
+%  gui_var          = structure of all GUI handles and variables
+%    .Choice        =   structure of user choices
+%      .search(k)   =     user Search choices
+%      .optimizer   =     choice of surrogate optimizer
+%    .Options       =   structure of MADS parameters settings
+%      .Search(k)   =     structure of user-selected k-th Search
+%      .nSearches   =     number of Search types to be used
+%    .Types         =   lists of possible types
+%      .Search      =   list of possible Search types
+%      .optimizer   =   list of possible surrogate optimizers
+%    .noGrad        =   flag indicating initial availability of gradients
+%  guiSearch        = handles for all Search window objects
+%    .n             = handle for the Number of Searches field
+%    .SurOptimizer = handle for the Surrogate Optimizer popup menu
+%    .Screen        = object handles for each Search
+%      .type        =   string identifying Search type
+%      .label       =   long text label for Search type
+%      .nIter       =   number of iterations to perform Search
+%      .nPoints     =   number of Search points
+%      .file        =   optional user file defining Search
+%  loadSearch       = flag indicating if Search options will be loaded
+%  Search           = temporary storage of gui_var.Options.Search(k)
+%  maxDisplay       = number of Search Types displayed on the main GUI
+%  searchLabel      = Search label that appears on the main GUI
+%*******************************************************************************
+function loadSearchOptions(h,event)
+
+fig       = findobj('Tag','NOMADm_GUI');
+gui       = getappdata(fig,'gui');
+gui_var   = getappdata(fig,'gui_var');
+guiSearch = getappdata(gcbf,'guiSearch');
+
+loadSearch = get(gcbo,'UserData');
+if loadSearch
+   gui_var.Options.nSearches    = get(guiSearch.n,'Value') - 1;
+   gui_var.Choice.optimizer     = get(guiSearch.SurOptimizer,'Value');
+   gui_var.Options.SurOptimizer = ...
+                   gui_var.Types.optimizer{gui_var.Choice.optimizer};
+   for k = 1:gui_var.Options.nSearches
+      gui_var.Choice.search(k) = get(guiSearch.Screen(k).type, 'Value');
+      Search.type = gui_var.Types.search{gui_var.Choice.search(k)};
+      if (gui_var.noGrad && strcmp(Search.type, 'GPollI'))
+         uiwait(msgbox('No derivatives available for this problem', ...
+                      ['Error in Search Type #', int2str(k)],'error','modal'));
+         return
+      end
+      Search.label   = gui_var.Labels.search{gui_var.Choice.search(k)};
+      Search.nIter   = str2double(get(guiSearch.Screen(k).nIter,  'String'));
+      Search.nPoints = str2double(get(guiSearch.Screen(k).nPoints,'String'));
+      Search.file    = fullfile(...
+                          get(guiSearch.Screen(k).file, 'UserData'), ...   
+                          get(guiSearch.Screen(k).file, 'String'));
+      UserData = get(guiSearch.Screen(k).type, 'UserData');
+      Search.local   = UserData{3};
+      Search.merit   = UserData{4};
+      gui_var.Options.Search(k) = Search;
+   end
+
+   % Update GUI Search fields
+   maxDisplay  = length(gui.searchLabel);
+   searchLabel = updateSearchLabels(maxDisplay, ...
+                       gui_var.Options.nSearches, gui_var.Options.Search);
+   for k = 1:maxDisplay
+      set(gui.searchLabel(k), 'String', searchLabel{k});
+   end
+end
+
+setappdata(fig,'gui_var',gui_var);
+close(guiSearch.fig);
+return
+
+%*******************************************************************************
+% dace_gui:  Displays a user input screen to set DACE Toolbox parameters.
+% ------------------------------------------------------------------------------
+% Called by: loadUserSearchFile
+% Calls:     loadDACEOptions
+% VARIABLES:
+%  k                    = Search number for this DACE screen
+%  guiDACE              = structure of all DACE window object handles
+%    .fig               =   DACE figure window
+%    .daceRegression    =   popup menu of regression functions
+%    .daceCorrelation   =   popup menu of correlation functions
+%    .daceTheta         =   field for estimating correlation parameter
+%    .daceLower         =   field for entering lower bound for theta
+%    .daceUpper         =   field for entering upper bound for theta
+%    .daceIsotropic     =   checkbox for isotropic correlations
+%    .done              =   the Done pushbutton
+%    .cancel            =   the Cancel pushbutton
+%  fig                  = handle for the NOMADm figure window
+%  gui_var              = structure of all GUI variables
+%    .Labels            =   labels for DACE function popup menus
+%      .daceRegression  =     labels for DACE regression functions
+%      .daceCorrelation =     labels for DACE correlation functions
+%    .Choice            =   integer choices for DACE functions
+%      .daceReg         =     choice for DACE regression function
+%      .daceCorr        =     choice for DACE correlation function
+%  gui_func             = structure of all GUI function handles
+%  Options              = structure of MADS options
+%    .dace              =   user-chosen DACE Toolbox parameters
+%      .theta           =   estimate for theta
+%      .lower           =   lower bound for theta
+%      .upper           =   upper bound for theta
+%      .isotropic       =   flag for isotropic theta
+%*******************************************************************************
+function guiDACE = dace_gui(k,gui_var,gui_func)
+
+% Set up "DACE Options" figure window
+guiDACE.fig = figure(...
+   'Name', ['DACE Toolbox Options (Search #', int2str(k),')'], ...
+   'Tag',  'DACE_GUI', ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.5, ...,
+   'DefaultUIControlStyle',           'text', ...
+   'WindowStyle',                     'modal', ...
+   'Resize',                          'on', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.25 0.30 0.40 0.40], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+if gui_var.newMatlab
+   uipanel;
+else
+   panelColor = get(guiDACE.fig,'DefaultUIControlBackgroundColor');
+   uicontrol(guiDACE.fig, 'Style','frame','Position',[0, 0, 1, 1], ...
+      'ForegroundColor',panelColor,'BackgroundColor',panelColor);
+
+end
+
+% Figure window shading to make it appear recessed
+uicontrol(guiDACE.fig, 'Style','frame','Position', [0, 0, 1, .004],    ...
+          'ForegroundColor','white','BackgroundColor','white');
+uicontrol(guiDACE.fig, 'Style','frame','Position', [.997, 0, .003, 1], ...
+          'ForegroundColor','white','BackgroundColor','white');
+uicontrol(guiDACE.fig, 'Style','frame','Position', [0, .996, 1, .004], ...
+          'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(guiDACE.fig, 'Style','frame','Position', [0, 0, .003, 1],    ...
+          'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+
+% Labels for DACE screen objects and data fields
+uicontrol(guiDACE.fig, ...
+      'Style',               'text', ...
+      'String',              'Regression Model: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .865 .34 .08]);
+guiDACE.reg                = uicontrol(guiDACE.fig, ...
+      'Style',               'popupmenu', ...
+      'String',              gui_var.Labels.daceRegression, ...
+      'BackgroundColor',     'white', ...
+      'Value',               gui_var.Choice.daceReg(k), ...
+      'Position',            [.37 .87 .60 .09]);
+
+uicontrol(guiDACE.fig, ...
+      'Style',               'text', ...
+      'String',              'Correlation Model: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .775 .34 .08]);
+guiDACE.corr               = uicontrol(guiDACE.fig, ...
+      'Style',               'popupmenu', ...
+      'String',              gui_var.Labels.daceCorrelation, ...
+      'BackgroundColor',     'white', ...
+      'Value',               gui_var.Choice.daceCorr(k), ...
+      'Position',            [.37 .78 .60 .09]);
+
+uicontrol(guiDACE.fig, ...
+      'Style',               'text', ...
+      'String',              'Theta Initial Guess: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .625 .34 .08]);
+guiDACE.theta              = uicontrol(guiDACE.fig, ...
+      'Style',               'edit', ...
+      'String',              num2str(gui_var.Options.dace(k).theta), ...
+      'FontSize',            .6, ...
+      'BackgroundColor',     'white', ...
+      'Position',            [.37 .64 .35 .08]);
+
+uicontrol(guiDACE.fig, ...
+      'Style',               'text', ...
+      'String',              'Theta Lower Bound: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .535 .34 .08]);
+guiDACE.lower              = uicontrol(guiDACE.fig, ...
+      'Style',               'edit', ...
+      'String',              num2str(gui_var.Options.dace(k).lower), ...
+      'BackgroundColor',     'white', ...
+      'FontSize',            .6, ...
+      'Position',            [.37 .55 .35 .08]);
+
+uicontrol(guiDACE.fig, ...
+      'Style',               'text', ...
+      'String',              'Theta Upper Bound: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .445 .34 .08]);
+guiDACE.upper              = uicontrol(guiDACE.fig, ...
+      'Style',               'edit', ...
+      'String',              num2str(gui_var.Options.dace(k).upper), ...
+      'BackgroundColor',     'white', ...
+      'FontSize',            .6, ...
+      'Position',            [.37 .46 .35 .08]);
+
+guiDACE.isotropic          = uicontrol(guiDACE.fig, ...
+      'Style',               'checkbox',  ...
+      'String',              'Isotropic', ...
+      'Value',               gui_var.Options.dace(k).isotropic,   ...
+      'Position',            [.75 .55 .20 .09]);
+  
+guiDACE.local              = uicontrol(guiDACE.fig, ...
+      'Style',               'checkbox', ...
+      'String',              'Restrict Model to Trust Region', ...
+      'Value',               gui_var.Options.Search(k).local, ...
+      'Position',            [.02 .30 .70 .09]);
+guiDACE.merit              = uicontrol(guiDACE.fig, ...
+      'Style',               'checkbox', ...
+      'String',              'Use Merit Function to Penalize Clustering', ...
+      'Value',               gui_var.Options.Search(k).merit, ...
+      'Position',            [.02 .21 .70 .09]);
+
+% The Done and Cancel Buttons
+guiDACE.done                 = uicontrol(guiDACE.fig, ...
+      'Style',               'pushbutton', ...
+      'String',              'Done', ...
+      'FontWeight',          'bold', ...
+      'Position',            [.27, .02, .18, .12], ...
+      'Callback',            {gui_func.loadDACEOptions, 1, k});
+guiDACE.cancel             = uicontrol(guiDACE.fig, ...
+      'Style',               'pushbutton', ...
+      'String',              'Cancel', ...
+      'FontWeight',          'bold', ...
+      'Position',            [.54, .02, .18, .12], ...
+      'Callback',            {gui_func.loadDACEOptions, 0, k});
+setappdata(guiDACE.fig,'guiDACE',guiDACE);
+return
+
+%*******************************************************************************
+% loadDACEOptions: Select a DACE surrogate option.
+% ------------------------------------------------------------------------------
+% Called by: dace_gui (callback: Done and Cancel pushbuttons)
+% VARIABLES:
+%  loadDACE           = flag indicating if DACE options are accepted
+%  k                  = Search number
+%  figSearch          = handle for Search figure window
+%  guiSearch          = structure of Search window object handles
+%    .Screen          =   handles for Search figure window objects
+%      .type          =     type of Search
+%      .file          =     optional user file defining Search
+%    .daceXXX         =   handles for DACE figure window objects
+%  figDACE            = handle for DACE figure window
+%  guiDACE            = structure of handles for DACE window objects
+%    .Reg             =   handle for regression function popup menu
+%    .Corr            =   handle for correlation function popup menu
+%    .Theta           =   handle for correlation parameter initial guess
+%    .Lower           =   handle for correlation parameter lower bound
+%    .Upper           =   handle for correlation parameter upper bound
+%    .Isotropic       =   handle for isotropic parameters check box
+%  fig                = handle for the NOMADm figure window
+%  gui_var            = structure of all GUI variables
+%    .Types           =   lists of possible types
+%      .daceReg       =     list of possible DACE regression functions
+%      .daceCorr      =     list of possible DACE correlation functions
+%    .Options.dace(k) =   structure of DACE parameters for Search k
+%  previousType       = previously selected Search type
+%  dace               = structure of DACE parameters
+%    .Reg             =   regression function handle
+%    .Corr            =   correlation function handle
+%    .Theta           =   initial guess for correlation parameters
+%    .Lower           =   lower bounds for correlation parameters
+%    .Upper           =   upper bounds for correlation parameters
+%    .Isotropic       =   flag for isotropic correlation parameters
+%*******************************************************************************
+function loadDACEOptions(h,event,loadDACE,k)
+
+figSearch = findobj('Tag','Search_GUI');
+guiSearch = getappdata(figSearch,'guiSearch');
+figDACE   = findobj('Tag','DACE_GUI');
+guiDACE   = getappdata(figDACE,'guiDACE');
+fig       = findobj('Tag', 'NOMADm_GUI');
+gui_var   = getappdata(fig,'gui_var');
+
+previousType = get(guiSearch.Screen(k).type,'UserData');
+if loadDACE
+   dace.reg       = gui_var.Types.daceReg{ get(guiDACE.reg, 'Value')};
+   dace.corr      = gui_var.Types.daceCorr{get(guiDACE.corr,'Value')};
+   dace.theta     = str2double(get(guiDACE.theta,'String'));
+   dace.lower     = str2double(get(guiDACE.lower,'String'));
+   dace.upper     = str2double(get(guiDACE.upper,'String'));
+   dace.isotropic = get(guiDACE.isotropic,'Value');
+   gui_var.Options.dace(k) = dace;
+   set(guiSearch.Screen(k).file, 'UserData', '','String',dace.reg);
+   set(guiSearch.Screen(k).type, ...
+      'UserData', {k,get(guiSearch.Screen(k).type,'Value'), ...
+                     get(guiDACE.local,'Value'), get(guiDACE.merit,'Value')});
+else
+   set(guiSearch.Screen(k).type, 'Value', previousType{2});
+end
+close(guiDACE.fig);
+return
+
+%*******************************************************************************
+% nw_gui:  Displays a user input screen to set NW Toolbox parameters.
+% ------------------------------------------------------------------------------
+% Called by: loadUserSearchFile
+% Calls:     loadNWOptions
+% VARIABLES:
+%  k                    = Search number for this NW screen
+%  guiNW                = structure of all NW window object handles
+%    .fig               =   NW figure window
+%    .nwKernel          =   popup menu of kernel functions
+%    .nwLocal           =   checkbox for restricting model to local region
+%    .done              =   the Done pushbutton
+%    .cancel            =   the Cancel pushbutton
+%  fig                  = handle for the NOMADm figure window
+%  gui_var              = structure of all GUI variables
+%    .Labels            =   labels for NW function popup menus
+%      .nwKernel        =     labels for NW Kernel functions
+%    .Choice            =   integer choices for NW functions
+%      .nwKernel        =     choice for NW kernel function
+%  gui_func             = structure of all GUI function handles
+%  Options              = structure of MADS options
+%    .nw                =   user-chosen NW Toolbox parameters
+%      .kernel          =   estimate for theta
+%*******************************************************************************
+function guiNW = nw_gui(k,gui_var,gui_func)
+
+% Set up "NW Options" figure window
+guiNW.fig = figure(...
+   'Name', ['NW Toolbox Options (Search #', int2str(k),')'], ...
+   'Tag',  'NW_GUI', ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.5, ...,
+   'DefaultUIControlStyle',           'text', ...
+   'WindowStyle',                     'modal', ...
+   'Resize',                          'on', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.25 0.30 0.40 0.40], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+if gui_var.newMatlab
+   uipanel;
+else
+   panelColor = get(guiNW.fig,'DefaultUIControlBackgroundColor');
+   uicontrol(guiNW.fig, 'Style','frame','Position',[0, 0, 1, 1], ...
+      'ForegroundColor',panelColor,'BackgroundColor',panelColor);
+
+end
+
+% Figure window shading to make it appear recessed
+uicontrol(guiNW.fig, 'Style','frame','Position', [0, 0, 1, .004],    ...
+          'ForegroundColor','white','BackgroundColor','white');
+uicontrol(guiNW.fig, 'Style','frame','Position', [.997, 0, .003, 1], ...
+          'ForegroundColor','white','BackgroundColor','white');
+uicontrol(guiNW.fig, 'Style','frame','Position', [0, .996, 1, .004], ...
+          'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(guiNW.fig, 'Style','frame','Position', [0, 0, .003, 1],    ...
+          'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+
+% Labels for NW screen objects and data fields
+uicontrol(guiNW.fig, ...
+      'Style',               'text', ...
+      'String',              'Kernel Function: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .855 .34 .08]);
+guiNW.kernel                = uicontrol(guiNW.fig, ...
+      'Style',               'popupmenu', ...
+      'String',              gui_var.Labels.nwKernel, ...
+      'BackgroundColor',     'white', ...
+      'Value',               gui_var.Choice.nwKernel(k), ...
+      'Position',            [.37 .86 .60 .09]);
+
+uicontrol(guiNW.fig, ...
+      'Style',               'text', ...
+      'String',              'Sigma Initial Guess: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .625 .34 .08]);
+guiNW.sigma                = uicontrol(guiNW.fig, ...
+      'Style',               'edit', ...
+      'String',              num2str(gui_var.Options.nw(k).sigma), ...
+      'FontSize',            .6, ...
+      'BackgroundColor',     'white', ...
+      'Position',            [.37 .64 .35 .08]);
+
+uicontrol(guiNW.fig, ...
+      'Style',               'text', ...
+      'String',              'Sigma Lower Bound: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .535 .34 .08]);
+guiNW.lower              = uicontrol(guiNW.fig, ...
+      'Style',               'edit', ...
+      'String',              num2str(gui_var.Options.nw(k).lower), ...
+      'BackgroundColor',     'white', ...
+      'FontSize',            .6, ...
+      'Position',            [.37 .55 .35 .08]);
+
+uicontrol(guiNW.fig, ...
+      'Style',               'text', ...
+      'String',              'Sigma Upper Bound: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .445 .34 .08]);
+guiNW.upper              = uicontrol(guiNW.fig, ...
+      'Style',               'edit', ...
+      'String',              num2str(gui_var.Options.nw(k).upper), ...
+      'BackgroundColor',     'white', ...
+      'FontSize',            .6, ...
+      'Position',            [.37 .46 .35 .08]);
+
+guiNW.local                = uicontrol(guiNW.fig, ...
+      'Style',               'checkbox', ...
+      'String',              'Restrict Model to Trust Region', ...
+      'Value',               gui_var.Options.Search(k).local, ...
+      'Position',            [.02 .30 .70 .09]);
+guiNW.merit                = uicontrol(guiNW.fig, ...
+      'Style',               'checkbox', ...
+      'String',              'Use Merit Function to Penalize Clustering', ...
+      'Value',               gui_var.Options.Search(k).merit, ...
+      'Position',            [.02 .21 .70 .09]);
+
+% The Done and Cancel Buttons
+guiNW.done                 = uicontrol(guiNW.fig, ...
+      'Style',               'pushbutton', ...
+      'String',              'Done', ...
+      'FontWeight',          'bold', ...
+      'Position',            [.27, .02, .18, .12], ...
+      'Callback',            {gui_func.loadNWOptions, 1, k});
+guiNW.cancel             = uicontrol(guiNW.fig, ...
+      'Style',               'pushbutton', ...
+      'String',              'Cancel', ...
+      'FontWeight',          'bold', ...
+      'Position',            [.54, .02, .18, .12], ...
+      'Callback',            {gui_func.loadNWOptions, 0, k});
+setappdata(guiNW.fig,'guiNW',guiNW);
+return
+
+%*******************************************************************************
+% loadNWOptions: Select a NW surrogate option.
+% ------------------------------------------------------------------------------
+% Called by: nw_gui (callback: Done and Cancel pushbuttons)
+% VARIABLES:
+%  loadNW             = flag indicating if NW options are accepted
+%  k                  = Search number
+%  figSearch          = handle for Search figure window
+%  guiSearch          = structure of Search window object handles
+%    .Screen          =   handles for Search figure window objects
+%      .type          =     type of Search
+%      .file          =     optional user file defining Search
+%    .nwXXX           =   handles for NW figure window objects
+%  figNW              = handle for NW figure window
+%  guiNW              = structure of handles for NW window objects
+%    .kernel          =   handle for kernel function popup menu
+%    .local           =   checkbox handle for using a trust region
+%  fig                = handle for the NOMADm figure window
+%  gui_var            = structure of all GUI variables
+%    .Types           =   lists of possible types
+%      .nwKernel      =     list of possible NW regression functions
+%    .Options.nw(k)   =   structure of NW parameters for Search k
+%  previousType       = previously selected Search type
+%  nw                 = structure of NW parameters
+%    .kernel          =   kernel function handle
+%*******************************************************************************
+function loadNWOptions(h,event,loadNW,k)
+
+figSearch = findobj('Tag','Search_GUI');
+guiSearch = getappdata(figSearch,'guiSearch');
+figNW     = findobj('Tag','NW_GUI');
+guiNW     = getappdata(figNW,'guiNW');
+fig       = findobj('Tag', 'NOMADm_GUI');
+gui_var   = getappdata(fig,'gui_var');
+
+previousType = get(guiSearch.Screen(k).type,'UserData');
+if loadNW
+   nw.kernel = gui_var.Types.nwKernel{get(guiNW.kernel,'Value')};
+   nw.sigma  = str2double(get(guiNW.sigma,'String'));
+   nw.lower  = str2double(get(guiNW.lower,'String'));;
+   nw.upper  = str2double(get(guiNW.upper,'String'));;
+   gui_var.Options.nw(k) = nw;
+   
+   set(guiSearch.Screen(k).file,'UserData','','String',nw.kernel);
+   set(guiSearch.Screen(k).type, ...
+      'UserData', {k,get(guiSearch.Screen(k).type,'Value'), ...
+                   get(guiNW.local,'Value'), get(guiNW.merit,'Value')});
+else
+   set(guiSearch.Screen(k).type, 'Value', previousType{2});
+end
+close(guiNW.fig);
+return
+
+%*******************************************************************************
+% updateScreen:  Displays a user input screen to set Search parameters.
+% ------------------------------------------------------------------------------
+% Called by: loadSession, resetSession
+% Calls:     updateSearchLabels
+% VARIABLES:
+%  Choice               = structure of menu choices
+%    .pollStrategy      =   integer choice of Poll strategy
+%    .pollOrder         =   integer choice of Poll order strategy
+%    .pollCenter        =   integer choice of Poll center
+%  Options              = structure of MADS parameters
+%    .nSearches         =   number of Search types used
+%    .Search(n)         =   structure of Search parameters
+%    .delta0            =   initial mesh size
+%    .deltaMax          =   maximum mesh size
+%    .meshRefine        =   mesh refinement factor
+%    .meshCoarsen       =   mesh coarsening factor
+%    .tolCache          =   tolerance for flagging point as being in Cache
+%    .hmin              =   minimum h-value of an infeasible point
+%    .hmax              =   maximum h-value of a filter point
+%    .ePollTriggerF     =   f-value Extended Poll trigger
+%    .ePollTriggerH     =   h-value Extended Poll trigger
+%    .Term              =   substructure containing MADS termination criteria
+%      .delta           =     mesh size parameter
+%      .iter            =     maximum number of MADS iterations
+%      .func            =     maximum number of function evaluations
+%      .time            =     maximum CPU time
+%      .fails           =     maximum number of consecutive Poll failures
+%    .TermFlag          =   substructure of termination criteria on/off switches
+%      .iter            =     turns on/off number of iterations
+%      .nFunc           =     turns on/off number of function evaluations
+%      .time            =     turns on/off CPU time
+%      .nFails          =     turns on/off number of consecutive Poll failures
+%    .scale             =   flag for scaling mesh directions
+%    .pollComplete      =   turns on/off complete Polling
+%    .TermFlag.relative =   computes termination delta relative to .delta0
+%    .useFilter         =   use filter for nonlinear constraints
+%    .removeRedundancy  =   remove redundant linear constraints
+%    .runStochastic     =   run as stochastic optimization problem
+%    .accelerate        =   flag for accelerating mesh refinement
+%    .plotHistory1      =   turns on/off a history plot
+%    .plotHistory2      =   turns on/off a real-time history plot
+%    .plotFilter        =   turns on/off a real-time filter plot
+%    .loadCache         =   flag for loading a pre-existing Cache file
+%    .countCache        =   flag for counting Cache points as function calls
+%    .runOneIteration   =   flag for running one MADS iteration at a time
+%    .runUntilFeasible  =   flag for running MADS only until feasible
+%  gui_var.Labels       = sub-structure of GUI labels
+%    .pollStrategy      =   Poll strategy label
+%    .pollCenter        =   Poll center label
+%    .pollOrder         =   Poll order label
+%  gui                  = structure of GUI object handles
+%    .SearchType(k)     =   current Search types
+%    .pollStrategy      =   current Poll strategy
+%    .pollCenter        =   current Poll center
+%    .pollOrder         =   current Poll order type
+%    .delta0            =   current initial mesh size
+%    .deltaMax          =   current maximum mesh size
+%    .meshRefine        =   current mesh refinement factor
+%    .meshCoarsen       =   current mesh coarsening factor
+%    .tolCache          =   current Cache tolerance
+%    .hmin              =   current minimum infeasible h-value
+%    .hmax              =   current maximum filter h-value
+%    .ePollXiF          =   current f-value Extended Poll trigger
+%    .ePollXiH          =   current h-value Extended Poll trigger
+%    .TermDelta         =   current mesh size termination criteria
+%    .TermIter          =   current maximum number of MADS iterations
+%    .TermFunc          =   current maximum number of function evaluations
+%    .TermTime          =   current maximum CPU time
+%    .TermFails         =   current max number of consec Poll failures
+%    .TermFlag          =   structure of handles for termination checkboxes
+%      .nIter           =     handle for number of iterations
+%      .nFunc           =     handle for number of function evaluations
+%      .time            =     handle for CPU time
+%      .nFails          =     handle for number of consecutive Poll failures
+%    .CacheMenu         =   Cache menu items
+%    .MADSMenu          =   MADS menu items
+%    .OptionsMenu       =   Options menu items
+%    .RunMenu           =   Run menu items
+%  onoff                = cell array of two strings "on" and "off"
+%  maxDisplay           = number of Search Types displayed on the main GUI
+%  searchLabel          = Search label that appears on the main GUI
+%*******************************************************************************
+function updateScreen(Choice,Options)
+
+fig     = findobj('Tag','NOMADm_GUI');
+gui_var = getappdata(fig,'gui_var');
+gui     = getappdata(fig,'gui');
+onoff   = {'on','off'};
+
+% Update GUI Search fields
+maxDisplay  = length(gui.searchLabel);
+searchLabel = updateSearchLabels(maxDisplay,Options.nSearches,Options.Search);
+for k = 1:maxDisplay
+   set(gui.searchLabel(k), 'String', searchLabel{k});
+end
+
+% Update other GUI fields
+set(gui.pollStrategy,'String',gui_var.Labels.pollStrategy(Choice.pollStrategy));
+set(gui.pollCenter,  'String',gui_var.Labels.pollCenter(Choice.pollCenter));
+set(gui.pollOrder,   'String',gui_var.Labels.pollOrder(Choice.pollOrder));
+set(gui.delta0,      'String', num2str(Options.delta0,       '%1.1f'));
+set(gui.deltaMax,    'String', num2str(Options.deltaMax,     '%2.1f'));
+set(gui.meshRefine,  'String', num2str(Options.meshRefine,   '%1.1f'));
+set(gui.meshCoarsen, 'String', num2str(Options.meshCoarsen,  '%1.1f'));
+set(gui.tolCache,    'String', num2str(Options.tolCache,     '%1.6g'));
+set(gui.hmin,        'String', num2str(Options.hmin,         '%1.5g'));
+set(gui.hmax,        'String', num2str(Options.hmax,         '%1.2f'));
+set(gui.ePollXiF,    'String', num2str(Options.ePollTriggerF,'%1.5g'));
+set(gui.ePollXiH,    'String', num2str(Options.ePollTriggerH,'%1.5g'));
+set(gui.Term.delta,  'String', num2str(Options.Term.delta,   '%1.5g'));
+field = fieldnames(gui.TermFlag);
+for k = 1:length(field)
+   set(gui.Term.(field{k}),     'String', Options.Term.(field{k}));
+   set(gui.TermFlag.(field{k}), 'Value',  Options.TermFlag.(field{k}));
+end
+field = fieldnames(gui.RS);
+for k = 1:length(field)
+   set(gui.RS.(field{k}), 'String', Options.RS.(field{k}));
+end
+set(gui.scaleMenu(1),    'Checked', onoff{1+~(Options.scale == 0)});
+set(gui.scaleMenu(2),    'Checked', onoff{1+~(Options.scale == 2)});
+set(gui.scaleMenu(3),    'Checked', onoff{1+~(Options.scale == 10)});
+set(gui.CacheMenu.load,  'Checked', onoff{2-Options.loadCache});
+set(gui.CacheMenu.count, 'Checked', onoff{2-Options.countCache});
+set(gui.MADSMenu.pollComplete,        'Checked', ...
+    onoff{2-Options.pollComplete});
+set(gui.OptionsMenu.TermFlag.relative,'Checked', ...
+    onoff{2-Options.TermFlag.relative});
+set(gui.OptionsMenu.useFilter,        'Checked', ...
+    onoff{2-Options.useFilter});
+set(gui.OptionsMenu.removeRedundancy, 'Checked', ...
+    onoff{2-Options.removeRedundancy});
+set(gui.OptionsMenu.runStochastic,    'Checked', ...
+    onoff{2-Options.runStochastic});
+set(gui.OptionsMenu.accelerate,  'Checked', onoff{2-Options.accelerate});
+set(gui.OptionsMenu.plotHistory1,'Checked', onoff{2-Options.plotHistory1});
+set(gui.OptionsMenu.plotHistory2,'Checked', onoff{2-Options.plotHistory2});
+set(gui.OptionsMenu.plotFilter,  'Checked', onoff{2-Options.plotFilter});
+set(gui.RunMenu.oneIteration,    'Checked', onoff{2-Options.runOneIteration});
+set(gui.RunMenu.execFeasible,    'Checked', onoff{2-Options.runUntilFeasible});
+set(gui.MADSMenu.editRSParam,    'Enable',  onoff{2-Options.runStochastic});
+
+gui_func = getappdata(gcf,'gui_func');
+gui_func.toggleStochastic(1,0);
+gui_func.toggleStochastic(1,0);
+return
+
+%*******************************************************************************
+% updateSearchLabels:  Displays the Search Labels on the main GUI.
+% ------------------------------------------------------------------------------
+% Called by: loadSearchOptions, updateScreen
+% VARIABLES:
+%  label          = cell array containing labels for each Search type
+%  maxDisplay     = number of Search types shown on the NOMADm GUI
+%  nSearches      = number of Search types
+%  Search(k)      = structure that describes the k-th Search
+%    .type        =   string identifying Search type
+%    .label       =   long text label for Search type
+%    .nIter       =   number of iterations to perform Search
+%    .nPoints     =   number of Search points
+%    .file        =   optional user file defining Search
+%  k              = Search type counter
+%  searchFilePath = path for optional Search file
+%  searchFile     = name of optional Search file
+%*******************************************************************************
+function label = updateSearchLabels(maxDisplay,nSearches,Search)
+
+% Initialize display parameters
+[label{1:maxDisplay}] = deal('None');
+if (nSearches > maxDisplay)
+   label{maxDisplay} = 'Multiple Search Types';
+   nSearches = maxDisplay - 1;
+end
+
+% Construct Search labels
+for k = 1:nSearches
+    [searchFilePath,searchFile] = fileparts(Search(k).file);
+    switch Search(k).type
+    case {'None'}
+       label{k} = Search(k).label; 
+    case {'LHS', 'Mesh','GA'}
+       label{k} = [int2str(Search(k).nPoints),'-pt. ',Search(k).label];
+    case {'SPollI','CPollI','GPollI'}
+       if (Search(k).nPoints == 1)
+         label{k} = strrep(Search(k).label(1:end-1), 'N ', '');
+       else
+         label{k} = strrep(Search(k).label,'N',int2str(Search(k).nPoints));
+       end
+    case {'DACE'}
+       label{k} = ['DACE Surrogate: ',   searchFile];
+    case {'NW'}
+       label{k} = ['N-W Surrogate: ',    searchFile];
+    case {'Custom'}
+       label{k} = ['Custom Search: ',    searchFile];
+    case {'CustomS'}
+       label{k} = ['Custom Surrogate: ', searchFile];
+    end
+    label{k} = [label{k}, ' (', int2str(Search(k).nIter), ')'];
+end
+return
+
+%*******************************************************************************
+% results_gui:  Displays Results from MADS run.
+% ------------------------------------------------------------------------------
+% Called by: nomadm_gui (callback: Results-->View Run #k)
+% Calls:     solutions_gui
+% VARIABLES:
+%  k               = run number
+%  gui_var         = structure of GUI variables
+%  gui_func        = structure of NOMADm figure window function handles 
+%  gui             = structure of NOMADm window object handles 
+%    .problem      =   display of the optimization problem name
+%    .Term         =   handles of termination criteria display
+%      .delta      =     display of mesh size termination criteria
+%      .nIter      =     display of maximum number of MADS iterations
+%      .nFunc      =     display of maximum number of function evaluations
+%      .time       =     display of maximum CPU time
+%      .nFails     =     display of maximum number of consecutive Poll failures
+%  RunSet          = structure containing all information about a MADS run
+%    .BestF        =   best feasible iterate for Run k
+%    .BestI        =   least infeasible iterate for Run k
+%    .RunStats     =   MADS Run k statistics (iterations, CPU time, etc.)
+%      .delta      =     final mesh size
+%      .nIter      =     total number of iterations
+%      .nFunc      =     total number of function evaluations
+%      .time       =     total CPU time expended
+%      .nFails     =     final number of consecutive Poll failures
+%      .stopRun    =     final value of Stop Run button
+%      .nCacheHits =     total number of Cache hits
+%  k               = run number
+%  digits          = number of digits accuracy to present on screen
+%  noYes           = cell array containing the strings "No" and "Yes"
+%  BestF, BestI    = best feasible and least infeasible solutions found
+%  isRS            = flag indicating if the R&S method was applied
+%  fig             = handle for the Results figure window
+%  Run             = structure of handles for run statistics display
+%    .delta        =   final mesh size
+%    .nIter        =   number of iterations
+%    .nFunc        =   number of function evaluations
+%    .nGrad        =   number of gradient evaluations
+%    .time         =   CPU time expended
+%    .nFails       =   number of consecutive Poll failures
+%    .stop         =   interrupted by user (Yes/No)
+%    .nCacheHits   =   number of Cache hits
+%    .RS           =   substructure od R&S parameters
+%      .iz         =     indifference zone parameter
+%      .alpha      =     alpha significance parameter
+%*******************************************************************************
+function results_gui(h,event)
+
+% Retrieve application data and initialize
+gui_func = getappdata(gcbf,'gui_func');
+gui_var  = getappdata(gcbf,'gui_var');
+gui      = getappdata(gcbf,'gui');
+RunSet   = getappdata(gcbf,'RunSet');
+k        = get(gcbo,'Position');
+digits   = 10;
+noYes    = {'No','Yes'};
+BestF    = RunSet(k).BestF;
+BestI    = RunSet(k).BestI;
+isRS     = ~isempty(RunSet(k).RunStats.RS);
+
+% Set up "Display Results" figure window
+fig = figure( ...
+   'Name',                           ['MADS Results for Problem: ', ...
+                                     get(gui.problem, 'String'), ...
+                                     ', Run #' int2str(k)], ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.375, ...,
+   'DefaultUIControlBackgroundColor', [.8 .8 .8], ...
+   'DefaultUIControlStyle',           'text', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.1 0.15 0.8 0.7], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+
+% Set up panels on the figure window
+if gui_var.newMatlab
+   uipanel('Parent',fig,'Position',[0,  0,  1,.63], ...
+                        'BorderType','beveledin','BackgroundColor',[.8 .8 .8]);
+   uipanel('Parent',fig,'Position',[0, .63,.5,.37], ...
+                        'BorderType','beveledin','BackgroundColor',[.8 .8 .8]);
+   uipanel('Parent',fig,'Position',[.5,.63,.5,.37], ...
+                        'BorderType','beveledin','BackgroundColor',[.8 .8 .8]);
+else
+   uicontrol(fig, 'Style','frame','Position', [0, .626, 1, .004],...
+      'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+   uicontrol(fig, 'Style','frame','Position', [0, .63, 1, .004],...
+      'ForegroundColor','white','BackgroundColor','white');
+   uicontrol(fig, 'Style','frame','Position', [.5, .63, .003, .37], ...
+      'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+   uicontrol(fig, 'Style','frame','Position', [.497, .63, .003, .37], ...
+      'ForegroundColor','white','BackgroundColor','white');
+end
+
+% Display Best Feasible Solution with pushbutton to view the solution
+uicontrol(fig, 'String','BEST FEASIBLE SOLUTION', ...
+         'FontWeight','bold', ...
+         'HorizontalAlignment','center','Position',[.02 .86 .46 .10]);
+
+if (isempty(RunSet(k).BestF))
+   uicontrol(fig, 'String','NO FEASIBLE ITERATES FOUND', ...
+         'HorizontalAlignment','center','Position',[.02 .77 .46 .08]);
+else
+   uicontrol(fig, 'String','Objective Function Value: ', ...
+         'HorizontalAlignment','left',  'Position',[.02 .80 .28 .08]);
+   uicontrol(fig, 'String','Constraint Violation Measure: ', ...
+         'HorizontalAlignment','left',  'Position',[.02 .74 .28 .08]);
+   uicontrol(fig, 'String',num2str(RunSet(k).BestF.f,digits), ...
+         'HorizontalAlignment','right', 'Position',[.30 .80 .18 .08]);
+   uicontrol(fig, 'String',num2str(RunSet(k).BestF.h,digits), ...
+         'HorizontalAlignment','right', 'Position',[.30 .74 .18 .08]);
+   uicontrol(fig,   'String',             'View Solution', ...
+                    'Style',              'pushbutton', ...
+                    'FontWeight',         'bold', ...
+                    'HorizontalAlignment','center', ...
+                    'Position',           [.02 .68 .46 .08], ...
+                    'UserData',           'Best Feasible', ...
+                    'Callback',           {gui_func.solution_gui,k,BestF});
+end
+
+% Display Least Infeasible Solution with pushbutton to view the solution
+uicontrol(fig, 'String','LEAST INFEASIBLE SOLUTION', ...
+         'FontWeight','bold', ...
+         'HorizontalAlignment','center','Position',[.52 .86 .46 .10]);
+
+if (isempty(RunSet(k).BestI))
+   uicontrol(fig, 'String','NO INFEASIBLE ITERATES FOUND ', ...
+         'HorizontalAlignment','center','Position',[.52 .77 .46 .08]);
+else
+   uicontrol(fig,'String','Objective Function Value: ', ...
+         'HorizontalAlignment','left',  'Position',[.52 .80 .28 .08]);
+   uicontrol(fig,'String','Constraint Violation Measure: ', ...
+         'HorizontalAlignment','left',  'Position',[.52 .74 .28 .08]);
+   uicontrol(fig,'String',num2str(RunSet(k).BestI.f,digits), ...
+         'HorizontalAlignment','right', 'Position',[.80 .80 .18 .08]);
+   uicontrol(fig,'String',num2str(RunSet(k).BestI.h,digits), ...
+         'HorizontalAlignment','right', 'Position',[.80 .74 .18 .08]);
+   uicontrol(fig,   'String',             'View Solution', ...
+                    'Style',              'pushbutton', ...
+                    'FontWeight',         'bold', ...
+                    'HorizontalAlignment','center', ...
+                    'Position',           [.52 .68 .46 .08], ...
+                    'UserData',           'Least Infeasible', ...
+                    'Callback',           {gui_func.solution_gui,k,BestI});
+end
+
+% Display Labels for MADS Run Statistics
+uicontrol(fig, 'String','RUN STATISTICS', ...
+   'FontWeight','bold', ...
+   'HorizontalAlignment','center','Position',[.30 .51 .40 .10]);
+uicontrol(fig, 'String','Final Mesh Size:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .45 .35 .08]);
+uicontrol(fig, 'String','MADS Iterations:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .40 .35 .08]);
+uicontrol(fig, 'String','Function Evaluations:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .35 .35 .08]);
+uicontrol(fig, 'String','Gradient Evaluations:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .30 .35 .08]);
+uicontrol(fig, 'String','CPU Time:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .25 .35 .08]);
+uicontrol(fig, 'String','Consecutive Poll Failures:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .20 .35 .08]);
+uicontrol(fig, 'String','Interrupted by User:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .15 .35 .08]);
+uicontrol(fig, 'String','Cache Hits:', ...
+   'HorizontalAlignment','left',  'Position',[.20 .10 .35 .08]);
+if isRS
+   uicontrol(fig, 'String','R&S Indifference Zone Parameter:', ...
+      'HorizontalAlignment','left',  'Position',[.20 .05 .35 .08]);
+   uicontrol(fig, 'String','R&S Alpha Parameter:', ...
+      'HorizontalAlignment','left',  'Position',[.20 .00 .35 .08]);
+end
+
+% Display MADS Run Statistics (Compare with termination criteria)
+Run.delta       = uicontrol(fig, ...
+   'String',num2str(RunSet(k).RunStats.delta,digits), ...
+   'HorizontalAlignment','right',  'Position',[.55 .45 .20 .08]);
+Run.nIter       = uicontrol(fig, ...
+   'String',int2str(RunSet(k).RunStats.nIter), ...
+   'HorizontalAlignment','right',  'Position',[.55 .40 .20 .08]);
+Run.nFunc       = uicontrol(fig, ...
+   'String',int2str(RunSet(k).RunStats.nFunc), ...
+   'HorizontalAlignment','right',  'Position',[.55 .35 .20 .08]);
+Run.nGrad       = uicontrol(fig, ...
+   'String',int2str(RunSet(k).RunStats.grad), ...
+   'HorizontalAlignment','right',  'Position',[.55 .30 .20 .08]);
+Run.time        = uicontrol(fig, ...
+   'String',num2str(RunSet(k).RunStats.time), ...
+   'HorizontalAlignment','right',  'Position',[.55 .25 .20 .08]);
+Run.nFails      = uicontrol(fig, ...
+   'String',num2str(RunSet(k).RunStats.nFails), ...
+   'HorizontalAlignment','right',  'Position',[.55 .20 .20 .08]);
+Run.stop        = uicontrol(fig, ...
+   'String',noYes{1+RunSet(k).RunStats.stopRun}, ...
+   'HorizontalAlignment','right',  'Position',[.55 .15 .20 .08]);
+Run.nCacheHits  = uicontrol(fig, ...
+   'String',num2str(RunSet(k).RunStats.nCacheHits), ...
+   'HorizontalAlignment','right',  'Position',[.55 .10 .20 .08]);
+if isRS
+   Run.RS.iz     = uicontrol(fig, ...
+      'String',num2str(RunSet(k).RunStats.RS.iz), ...
+      'HorizontalAlignment','right',  'Position',[.55 .05 .20 .08]);
+   Run.RS.alpha  = uicontrol(fig, ...
+      'String',num2str(RunSet(k).RunStats.RS.alpha), ...
+      'HorizontalAlignment','right',  'Position',[.55 .00 .20 .08]);
+end
+
+% Change colors for violated Termination Criteria
+if (RunSet(k).RunStats.delta < str2double(get(gui.Term.delta,'String')))
+   set(Run.delta,'FontWeight','bold','ForegroundColor','blue');
+end
+if (RunSet(k).RunStats.nIter >= str2double(get(gui.Term.nIter,'String')))
+   set(Run.nIter, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.nFunc >= str2double(get(gui.Term.nFunc,'String')))
+   set(Run.nFunc, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.time >= str2double(get(gui.Term.time,'String')))
+   set(Run.time, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.nFails >= str2double(get(gui.Term.nFails,'String')))
+   set(Run.nFails, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.stopRun)
+   set(Run.stop, 'FontWeight','bold','ForegroundColor','red');
+end
+return
+
+%*******************************************************************************
+% solution_gui: View MADS optimal solution.
+% ------------------------------------------------------------------------------
+% Called by: results_gui (callback: View Solution pushbutton)
+% Calls:     viewPrevious, viewNext
+% VARIABLES:
+%  iterate     = the best solution found by MADS
+%    .x        =   vector of continuous variable values
+%    .p        =   cell array of categorical variables
+%  fig         = handle for the NOMADm GUI
+%  gui_func    = handles for the NOMADm functions
+%  gui_var     = handles for all GUI variables
+%  gui.problem = name of current optimization problem
+%  label       = text for "Best Feasible" or "Least Infeasible" solution
+%  nX          = number of continuous variables
+%  nP          = number of categorical variables
+%  maxPage     = maximum number of variables displayed per page
+%  nPages      = number of pages to display
+%  onoff       = cell array containing "on" and "off"
+%  leftmargin  = left margin position of continuous variables display
+%  catmargin   = left margin position of categorical variables display
+%  pos         = vertical position of next variable
+%  xDisplay    = string conversion of the continuous variables
+%  x(k)        = handles of the k-th displayed continuous variable
+%    .ind      =   handle for the index label
+%    .val      =   handle for the variable values
+%  previousX   = handle for the continuous variables Previous push button
+%  nextX       = handle for the continuous variables Next push button
+%  pDisplay    = string conversion of the categorical variables
+%  p(k)        = handles of the k-th displayed categorical variable
+%    .ind      =   handle for the index label
+%    .val      =   handle for the variable values
+%  previousP   = handle for the categorical variables Previous push button
+%  nextP       = handle for the categorical variables Next push button
+%*******************************************************************************
+function solution_gui(h,event,k,iterate)
+
+fig      = findobj('Tag', 'NOMADm_GUI');
+gui_func = getappdata(fig,'gui_func');
+gui_var  = getappdata(fig,'gui_var');
+gui      = getappdata(fig,'gui');
+label    = get(gcbo,'UserData');
+nX       = length(iterate.x);
+nP       = length(iterate.p);
+maxPage  = 12;
+onoff    = {'on','off'};
+
+% Set up "Display Solution" figure window
+fig = figure('Name', ['MADS ',label,' Solution for Problem: ', ...
+                      get(gui.problem, 'String'),', Run #' int2str(k)], ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.375, ...,
+   'DefaultUIControlStyle',           'text', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.15 0.10 0.8 0.7], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+
+if gui_var.newMatlab
+   uipanel;
+else
+   panelColor = get(fig,'DefaultUIControlBackgroundColor');
+   uicontrol(fig, 'Style','frame','Position',[0, 0, 1, 1], ...
+      'ForegroundColor',panelColor,'BackgroundColor',panelColor);
+end
+
+% Set display margins
+if nP
+   leftmargin = .10;
+   catmargin  = .58;
+else
+   leftmargin = .30;
+   catmargin  = .58;
+end
+
+% Display continuous variables Solution Labels
+uicontrol(fig, 'String',             'CONTINUOUS VARIABLES', ...
+               'FontWeight',         'bold', ...
+               'HorizontalAlignment','center', ...
+               'Position',           [leftmargin .86 .32 .10]);
+uicontrol(fig, 'String',             'Index', ...
+               'HorizontalAlignment','left', ...
+               'Position',           [leftmargin .76 .07 .10]);
+uicontrol(fig, 'String',             'Value', ...
+               'HorizontalAlignment','right', ...
+               'Position',           [leftmargin+.09 .76 .23 .10]);
+
+% Display continuous variables
+[xDisplay{1:maxPage}] = deal('');
+for k = 1:nX
+   xDisplay{k} = num2str(iterate.x(k));
+end
+
+for k = 1:maxPage
+   pos = .76 - .05*k;
+   x(k).ind = uicontrol(fig, ...
+                        'String',             int2str(k), ...
+                        'HorizontalAlignment','left', ...
+                        'Position',           [leftmargin pos .05 .08]);
+   x(k).val = uicontrol(fig, ...
+                        'String',             xDisplay{k}, ...
+                        'HorizontalAlignment','right', ...
+                        'Position',           [leftmargin+.07 pos .25 .08]);
+end
+set([x(nX+1:end).ind, x(nX+1:end).val]', 'Visible','off');
+
+% Display Previous/Next pushbuttons for continuous variables
+previousX = uicontrol(fig, ...
+                      'Style',    'pushbutton', ...
+                      'String',   'Previous',   ...
+                      'Visible',  'off', ...
+                      'Position', [leftmargin+.07, .05, .08, .06], ...
+                      'Callback', {gui_func.changeView});
+nextX     = uicontrol(fig, ...
+                      'Style',    'pushbutton', ...
+                      'String',   'Next', ...
+                      'Visible',  onoff{2 - (nX > maxPage)}, ...
+                      'Position', [leftmargin+.19, .05, .08, .06], ...
+                      'Callback', {gui_func.changeView});
+set(previousX,'UserData',{-1,x,iterate.x,nextX});
+set(nextX,    'UserData',{ 1,x,iterate.x,previousX});
+
+% If MVP problem:
+if nP
+
+   % Convert the categorical variables into a cell array of strings
+   [pDisplay{1:maxPage}] = deal('');
+   for k = 1:nP
+      if ischar(iterate.p{k})
+         pDisplay{k} = iterate.p{k};
+      else
+         pDisplay{k} = num2str(iterate.p{k});
+      end
+   end
+
+   % Display categorical variables Solution Labels
+   uicontrol(fig, 'String',             'CATEGORICAL VARIABLES', ...
+                  'FontWeight',         'bold', ...
+                  'HorizontalAlignment','center', ...
+                  'Position',           [catmargin .86 .32 .10]);
+   uicontrol(fig, 'String',             'Index', ...
+                  'HorizontalAlignment','left', ...
+                  'Position',           [catmargin .76 .07 .10]);
+   uicontrol(fig, 'String',             'Value', ...
+                  'HorizontalAlignment','right', ...
+                  'Position',           [catmargin+.09 .76 .23 .10]);
+
+   % Display categorical variables
+   for k = 1:maxPage
+      pos = .76 - .05*k;
+      p(k).ind = uicontrol(fig, ...
+                           'String',             int2str(k), ...
+                           'HorizontalAlignment','left', ...
+                           'Position',           [catmargin pos .05 .08]);
+      p(k).val = uicontrol(fig, ...
+                           'String',             pDisplay{k}, ...
+                           'HorizontalAlignment','right', ...
+                           'Position',           [catmargin+.07 pos .25 .08]);
+   end
+   set([p(nP+1:end).ind, p(nP+1:end).val]', 'Visible','off');
+
+   % Display Previous/Next pushbuttons for categorical variables
+   previousP = uicontrol(fig, ...
+                         'Style',    'pushbutton', ...
+                         'String',   'Previous',   ...
+                         'Visible',  'off', ...
+                         'Position', [catmargin+.07, .05, .08, .06], ...
+                         'Callback', {gui_func.changeView});
+   nextP     = uicontrol(fig, ...
+                         'Style',    'pushbutton', ...
+                         'String',   'Next', ...
+                         'Visible',  onoff{2 - (nP > maxPage)}, ...
+                         'Position', [catmargin+.19, .05, .08, .06], ...
+                         'Callback', {gui_func.changeView});
+   set(previousP,'UserData',{-1,p,iterate.p,nextP});
+   set(nextP,    'UserData',{ 1,p,iterate.p,previousP});
+end
+return
+
+%*******************************************************************************
+% changeView: Change the view of a multi-page list of variable values.
+% ------------------------------------------------------------------------------
+% Called by: solutions_gui (callback: Previous/Next pushbuttons)
+% VARIABLES:
+%   maxPage     = maximum number of variables displayed on one page
+%   UserData    = storage for key items needed
+%   code        = an integer: magnitude = page #, sign = which button pressed
+%   solution    = handles for the on-screen display of the variable values
+%     .ind      =   handles for the variable indices
+%     .val      =   handles for the variable values
+%   iterate     = the solution vector
+%   otherhandle = handle of the push button not pressed
+%   whichButton = pushbutton indicator: Next = +1, Previous = -1
+%   iPage       = display page number
+%   n           = number of variables
+%   lastPage    = the total number of display pages
+%   newcode     = updated code variable assigned back to the pushbutton UserData
+%   nDisplay    = number of variables displayed on the current page
+%   ind         = index of variable to be displayed
+%   value       = variable value converted to string for display
+%*******************************************************************************
+function changeView(h,event)
+
+% Retrieve pushbutton parameters
+UserData = get(gcbo, 'UserData');
+[code,solution,iterate,otherhandle] = deal(UserData{:});
+
+% Set up page parameters and update pushbutton parameters for new page
+whichButton = sign(code);
+iPage       = abs(code);
+iPage       = iPage + whichButton;
+maxPage     = length(solution);
+n           = length(iterate);
+lastPage    = ceil(n/maxPage);
+newcode     = iPage*whichButton;
+set(gcbo,        'UserData',{ newcode,solution,iterate,otherhandle});
+set(otherhandle, 'UserData',{-newcode,solution,iterate,gcbo});
+
+% Set visibility of variable and index displays
+set([gcbo; otherhandle], 'Visible', 'on');
+nDisplay = maxPage;
+if (iPage == 1)
+   set(gcbo, 'Visible','off');
+end
+if (iPage == lastPage)
+   nDisplay = max(1,mod(n,maxPage));
+   set(gcbo, 'Visible','off');
+end
+
+% Update display of indices and variables for new page
+for k = 1:nDisplay
+   ind = k + (iPage-1)*maxPage;
+   if iscell(iterate)
+      if ischar(iterate{ind})
+         value = iterate{ind};
+      else
+         value = num2str(iterate{ind});
+      end
+   else
+      value = num2str(iterate(ind));
+   end
+   set(solution(k).ind, 'Visible','on','String',int2str(ind));
+   set(solution(k).val, 'Visible','on','String',value);
+end
+for k = nDisplay+1:maxPage
+   set([solution(k).ind; solution(k).val], 'Visible','off');
+end
+return
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm.txt b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3825fae3331983e5213b6d4b184f8b85b474abd2
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm.txt
@@ -0,0 +1,342 @@
+			NOMADm version 3.3
+			Summary of Changes
+
+
+Version 3.3 incorporates the following changes:
+
+NEW FEATURE:
+
+--  A ranking and selection (R&S) procedure for treating stochastic
+    optimization problems has been added.  Included in this feature are
+    additional R&S user options displayed on the main screen and editable
+    via the MADS menu.  In order to edit these parameters, the new Options
+    Menu option for running a stochastic problem must be checked.  New R&S
+    run parameters are also displayed on the Results screen if the run was
+    stochastic.
+
+CODE IMPROVEMENTS AND BUG FIXES:
+
+--  The Nadaraya-Watson surrogate functions have been altered and 
+    vectorized, with some parameters being moved back into higher mads
+    functions so that other classes of surrogates could use them.  The
+    input screen has additional parameters that can be tuned.  The crude
+    one-dimensional search to optimize the sigma parameter has been replaced
+    with an efficient golden section search function.
+
+--  The Latin hypercube function was altered significantly by moving all 
+    non-MADS lines of code into the higher level "search" function.  LHS
+    is now portable to other applications.  The number of LHS points
+    specified by the user now functions exactly that way.
+
+--  A new parameter has been added to allow the pruning of the Cache in
+    the construction and recalibration of surrogates.
+
+--  All the view screens have been modified, and several minor bugs were
+    corrected.
+
+
+
+			NOMADm version 3.2
+			Summary of Changes
+
+
+Version 3.2 started as a minor update, and is still minor when compared to 3.0,
+but it has in fact undergone a number of significant changes.  More variable
+names have changed and the code has undergone a stylistic and structural
+overhaul using "m-lint".  The user interface has been completely remade so
+that, rather than use two files and access callback functions through a
+switch-case construct, every function is in the same file, with callback
+functions handled by storing and retrieving function handles.
+
+
+NEW FEATURES:
+
+--  The Search function has been modified so that surrogates may be used in
+    solving mixed variable optimization problems.  Specifically, surrogates
+    are formed using only the Cache points with the same categorical
+    variable values as the current poll center or discrete neighbor.  
+    This means that multiple surrogates are constructed -- possibly as many
+    as one for every set of discrete variable values.
+
+--  An EXTENDED SEARCH step has been added to the MADS algorithm
+    immediately preceding the EXTENDED POLL step.  This was done by
+    inserting several lines of code, including a call to the Search
+    function, inside the mvpPoll function in mads.m.  At each iteration,
+    the SEARCH type and parameters used in SEARCH are also be used in
+    EXTENDED SEARCH.  While it would not be difficult to allow the user a
+    separate EXTENDED SEARCH type (with its own parameters), allowing a
+    different EXTENDED SEARCH for each discrete neighbor point would be
+    impractical and very difficult to program.
+
+--  Use of Nadaraya-Watson based surrogates has been added as a Search
+    option with several 7 different kernel functions.  In doing so, the
+    daceSurrogate function has been renamed recalSurrogate and is now used
+    to construct both DACE and N-W surrogates, depending on the input
+    arguments.  This new function can also handle custom surrogates, in
+    which case the user need only supply a simple interface file for using
+    an already existing outside surrogate code.
+
+--  A checkbox option has been added to turn on/off the mesh size
+    termination criterion.  An error trap has been added to force the user
+    to choose at least one stopping condition.
+
+
+CODE IMPROVEMENTS AND BUG FIXES
+
+--  The input dialog box launched prior to the Search Input screen has been
+    deleted.  The two user choices from the input dialog box were moved
+    directly onto the Search input screen as popup menus, so that all
+    Search data is now input on one screen in a more convenient manner.
+
+--  Deleted all path restrictions associated with the companion software,
+    dace and cmaes.  Now, if the user wishes to use dace or cmaes within
+    NOMADm, the user must install the program and add the path where its
+    files are stored to the Matlab path.  This is done using the 
+    File -->Set Path menu choice from the Matlab command window.
+
+--  Created a new processOutput function and a closeWorkspace function to take
+    care of error trapping and bookkeeping at the end of the run.
+
+--  The optimizeSurrogate function has been modified so that it creates
+    optimizer-specific surrogate function files only once (rather than
+    recreating them at every iteration) and then deletes them after the run is
+    complete.  This increases the speed and efficiency of the surrogate
+    optimization process.
+
+--  The viewing of best feasible and least infeasible solutions has been
+    completely redone.  For each of these two solutions, the two pushbuttons
+    for viewing continuous and categorical variables, respectively, have been
+    replaced by a single pushbutton for viewing all the variables at once.
+    Pressing this "View Solution" button launches a "Solutions" figure window,
+    where both categorical and continuous variable values are shown.  If there
+    are more than ten of either variable type, "Next" and "Previous"
+    pushbuttons appear to allow the user to view the variables up to 10 at a
+    time.
+
+--  Changed the way that the number of function evaluations is computed.
+    Specifically, a new field, nfunc, was added to Cache, which is a vector
+    with each element representing the number of function evaluations performed
+    at the corresponding point.  A value of 1 was put into each element of
+    Cache.nfunc, so that the sum is the number of function evaluations.  This
+    was done for future compatibility with stochastic problems.  Stochastic
+    problems typically require multiple function evaluations (replications) at
+    each point, which is incompatible with this software because the objective
+    and constraint functions are only evaluated a trial point if it is not
+    already in the Cache.  The new field allows the user to do several function
+    evaluations at the same point outside of NOMADm and store the average as
+    the function value and the number of replications in the corresponding
+    element Cache.nfunc.
+
+--  Replaced many logical operators & and | with short-circuit logical
+    operators && and ||, respectively to increase efficiency.
+
+--  The text color of each entry in the Results Menu now matches the color of
+    its curve in the history plot.
+
+--  Corrected a bug in mads_batch.m that generated a new figure window at every
+    iteration whenever real-time filter or history plotting was turned on.
+
+--  Corrected a bug that caused an error whenever the minimum constraint
+    violation function value was set to zero.
+
+--  Removed an error flag that disallowed more than one Cache hit at a time.
+    This was done because it is possible for this to happen.  If a trial point
+    is in very close proximity to a Cache point but just outside the threshold
+    for being a Cache hit, it is added to the Cache.  Then, if a third point
+    lies between these two points, it could fall beneath the Cache Hit
+    threshold for both points simultaneously, thus yielding two Cache hits at
+    the same time.
+
+--  Corrected a bug that made the lhs function incompatible with the
+    removeRedundancy flag being turned on (the default case) whenever linear
+    constraints are degenerate or variables are unbounded.  Since lhs needs the
+    original constraints (before redundant ones are removed), the fix was to
+    turn the flag off inside the search routine and call updateOmega before
+    calling lhs.
+
+--  Corrected a bug in changeProblem, in which the Matlab path was being
+    altered in an undesirable way.  Specifically, if the user selected a
+    problem stored in the NOMADm directory, and then chose another problem in a
+    different directory, then the first directory would be deleted from the
+    path, even if it was required to run the software.  A logical variable was
+    added so that, if the selected problem was already on the Matlab path, the
+    path would not be deleted.
+
+--  Fixed a bug that prevented the user from choosing the Cancel button on the
+    DACE figure window.
+
+--  Cleaned up some major bugs in ga and added a new getPenaltyTerm function
+    that the ga function uses to compute a penalty parameter in the case of 
+    nonlinear constraints.
+
+--  Corrected minor bugs in the search, processInput, getTangentCone,
+    evalFunction, and nomadm_compile functions.
+
+
+			NOMADm Version 3.00
+			Summary of Changes
+
+
+NOMADm 3.00 has many new features, improvements, and corrections.  The code has
+been extensively rewritten to make it faster, more efficient, and more
+compatible with typical MATLAB conventions.  Documentation includes a new
+User's Guide to replace the html help file, a Contents file, and this summary
+of changes.
+
+Many variable names have changed, making existing user cache and session files
+incompatible with the new code.  Since session files are not difficult to
+quickly reproduce, no attempt has been made to transition these files.  Old
+cache files are incompatible because of a new field in the "iterate" structure,
+called pID, which is described below.  To transition an old cache with the file
+name of MyProblem_Cache.mat, the following code should work to update it:
+
+    load('MyProblem_Cache',CACHE);
+    [CACHE.iterate.pID] = deal(0);
+    save('MyProblem_Cache',Cache);
+
+
+NEW FEATURES:
+
+-- The new mesh adaptive direct search (MADS) algorithm has been added to what
+was GPS by adding a new function, madsDirections, which generates the
+appropriate POLL directions.  It can be run with or without the filter, and
+it can use a 2n or n+1 positive basis.  Most references to GPS within the code
+and documentation have been replaced with the more general MADS terminology.
+
+-- The SEARCH step options have been greatly enhanced to allow a different
+SEARCH type to be employed at various times.  The user can now specify
+parameters for each of N searches, namely, the type of search, number of
+iterations to run the search, number of points to sample, and the filename of a
+user-provided search routine.
+
+-- Initial implementation of DACE surrogates as a SEARCH option has been added.
+The DACE package comes from researchers at DTU in Denmark.  Whenever this
+SEARCH type is selected from the Search options menu, a DACE popup window is
+launched which takes various options as input.  The DACE surrogate is
+recalibrated and then optimized using either MADS, fmincon (from the Matlab
+Optimization Toolbox) or the genetic algorithm package CMA-ES (from Germany).
+The option to use MADS is not recommended because it has not been fully tested
+and is VERY slow on the simplest of problems.
+
+-- A new function, processC, was added to the package, which enables the user
+to run MADS on problems in which the Functions file is written in "C".  If the
+functions file has not already been pre-compiled, then processC combines the
+Functions file with the appropriate commands for the Matlab mex compiler,
+compiles the code for the appropriate platform, and passes the filename to the
+optimizer so that the optimizer can seamlessly process and use the executable
+file.  Since the user should also be able to do this before running NOMADm, all
+the files for processing C and FORTRAN files were removed from the file,
+nomadm_functions.m, and stored under a new parent file, nomadm_compile.m.
+
+-- A new function, removeRedunancy, co-written with Olga Brezhneva, has been
+added to handle degenerate linear constraints.  An option has been added to
+allow the user to discard redundant constraints before beginning the iteration
+(via a more expensive approach, but done only once).  If this option is not
+selected, then deletion of redundant constraints is treated as needed within
+the new function during the iteration process.
+
+-- New poll order options have been added.  The "Custom" option allows the user
+to specify a poll order in the parameter file.  "Dynamic" poll ordering changes
+at every successful iteration, moving the previous successful direction (or, in
+MADS, the direction making the closest angle) to the top of the order.  
+"Dynamic Ranked" orders all the directions according to how small an angle they
+make with the previous successful direction.  "Surrogate" order does polling in
+order of surrogate value.
+
+-- A genetic algorithm code has been added as an additional SEARCH option.
+
+-- Deterministic sampling on a coarse mesh has been added as an additional
+SEARCH option.
+
+-- A maximum mesh size parameter has been added to prevent the mesh from
+getting too coarse.
+
+-- A user option for accelerating convergence has been added.  It divides the
+mesh refinement factor in half at every unsuccessful iteration.
+
+-- A termination criterion has been added that stops if the user sets a maximum
+number of consecutive POLL failures.
+
+-- A flag option has been added to the Run menu that allows the user to run the
+optimizer one iteration at a time, allowing for a change in parameters between
+iterations.
+
+-- An option has been added to the Run menu that allow the user to seek the
+first feasible point (with respect to the constraints in the Functions file),
+rather than seek the optimizer.
+
+-- The Cache Tolerance and MVP EXTENDED POLL triggers for the objective and
+constraint violation functions may now be edited by selecting the appropriate
+MADS menu choice.
+
+-- An option has been added to do base-2 or base-10 logarithmic scaling of
+directions.
+
+-- Custom POLL directions has been added to allow user to specify the
+underlying POLL directions basis.
+
+-- Options have been added to the NOMADm Help menu to allow viewing of the GNU
+General Public License (GPL) and this summary of changes.
+
+-- The html NOMADm Help file has been replaced with a more complete pdf User's
+Guide.
+
+-- Code documentation has been updated and improved to comply with current
+MATLAB standards for using "help" and "lookfor" commands.  A "Contents.m" file
+has been added as an overview for the package.
+
+
+CODE IMPROVEMENTS AND BUG FIXES:
+
+-- The Stop Run and Resume features are now much more stable and clearly
+defined, and push buttons for both are now included.  Some capability existed
+before, but the seamless transition of variable values was not entirely
+accurate.  This has been corrected.
+
+-- The Cache has a new field .pID and a function to compute its value.  This
+field is a unique ID number corresponding to a specific set of categorical
+variable values.  This speeds up searching the Cache, and it allows
+partitioning of that part of the Cache with the same discrete variable values.
+As a consequence, this greatly improves the process for scaling directions in
+the case of mixed variables.
+
+-- Computation of scale factors was moved from the Update function to the
+updateOmega function to facilitate scaling of MVP problems.
+
+-- The actual scaling of directions was moved to from the poll function to the
+various functions that compute POLL directions, so that a bug could be
+corrected to prevent tangent cone generators from being scaled.
+
+-- Added code in the updateOmega function to scale each linear constraint by
+the infinity norm of its coefficients.
+
+-- The "Constraints change ..." options in the Problem Menu has been deleted.
+Instead, whether or not to change the linear constraints during the
+optimization of an MVP problem is determined by the number of input arguments
+(1 or 2) that the Omega file function statement has.  If a second argument
+(the current values of the categorical variables) is included, then it is
+assumed that Omega is dependent on these values; otherwise, it is assumed that
+the linear constraints never change.
+
+-- The "Search Cache before Evaluating Function" menu choice has been removed
+as a user option.  Because the Cache structure is integrated so tightly into
+the code, not selecting this option has resulted in too many unforeseen
+problems.  Therefore, this function is now always done automatically.
+
+-- Reduced the size of the processInput function by putting the error checks in
+a separate function and moving all of the Cache construction and retrieval
+logic to the createCache function.
+
+-- For problems with no nonlinear constraints, the constraint violation
+function value no longer appears in the results display window.
+
+-- The filter now displays on the bottom right of the main window to allow for
+the display of more options.
+
+-- Minor bugs in DVector, LHS, and gradDirections were corrected.
+
+-- Added two lines to getTangentCone to zero out elements that are less than
+10*eps in magnitude.
+
+-- Added an error check in gradDirections to prevent an infinite loop if
+user-provided derivatives are in error.
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm_compile.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm_compile.m
new file mode 100644
index 0000000000000000000000000000000000000000..e8802da04f579998e04bc66cc7d957c5028d28e1
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm_compile.m
@@ -0,0 +1,292 @@
+function language = nomadm_compile(fileType,filePath,fileName,fileExt)
+%NOMADM_COMPILE  Uses MEX to compile a C and FORTRAN functions file.
+%
+%   Syntax:
+%      LANGUAGE = nomadm_compile(FILETYPE,FILEPATH,FILENAME,FILEEXT)
+%
+%   Desciption:
+%      NOMADM_COMPILE is a utility for compiling functions files that are
+%      written in C/C++ or FORTRAN for use with the MADS optimizer.  This can
+%      be done manually by following the instructions here, or automatically
+%      through the NOMADm GUI, in which case, it is called by NOMADM.  LANGUAGE
+%      is a string used by the NOMADm software to identify the programming
+%      language of the source code. If run separately, LANGUAGE is ignored.
+%
+%      FILETYPE is a 1-character string code that identifies the programming
+%      language in which the functions file is written.  The legal codes are
+%      F = FORTRAN and C = C/C++.  If called from nomadm, this code is obtained
+%      by taking the first character of the filename extension.  The variables,
+%      FILEPATH, FILENAME, and FILEEXT help to identify the location, filename,
+%      and filename extension, respectively, of the functions file.
+%
+%   See also MADS, NOMADM
+
+%*******************************************************************************
+%   Copyright (c) 2001-2005 by Mark A. Abramson
+%
+%   This file is part of the NOMADm software package.
+%
+%   NOMADm is free software; you can redistribute it and/or modify it under the
+%   terms of the GNU General Public License as published by the Free Software
+%   Foundation; either version 2 of the License, or (at your option) any later
+%   version.
+%
+%   NOMADm is distributed in the hope that it will be useful, but WITHOUT ANY
+%   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+%   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+%   details.
+%
+%   You should have received a copy of the GNU General Public License along
+%   with NOMADm; if not, write to the Free Software Foundation, Inc., 
+%   59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% ------------------------------------------------------------------------------
+%   Originally created, 2001.
+%   Last modified, 31 January 2005
+%
+%   Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%*******************************************************************************
+
+%*******************************************************************************
+% nomadm_compile: Construct a MEX gateway file for a non-MATLAB function file.
+% ------------------------------------------------------------------------------
+% Called by:  loadMADS
+% Calls:      compileFortran, compileC
+% VARIABLES:
+%  language = programming language of Functions file
+%  fileType = string code for functions file programming language
+%  filePath = current path where the non-Matlab functions file lies
+%  fileName = optimization problem name
+%  fileExt  = filename extention of the non-Matlab functions file
+%*******************************************************************************
+switch upper(fileType)
+   case 'F'
+      compileFortran(filePath,fileName,fileExt);
+      language = 'FORTRAN';
+   case 'C'
+      compileC(filePath,fileName,fileExt);
+      language = 'C';
+   case 'M'
+      warning('Matlab Function file found.  No compiling is necessary.');
+      language = 'Matlab';
+   otherwise
+      error('Unable to compile:  Incompatible File Type');
+end
+return
+
+%*******************************************************************************
+% compileFortran: Construct a MEX Fortran gateway file.
+% ------------------------------------------------------------------------------
+% Called by:  nomadm_compile
+% Calls:      getMexExt
+% VARIABLES:
+%  filePath    = current path where the Fortran functions file lies
+%  fileName    = optimization problem name
+%  fortranExt  = filename extention of the Fortran functions file
+%  userFile    = entire filename of the Fortran functions file
+%  wrapperFile = entire filename of gateway file
+%  execFile    = entire filename of the compiled executable functions file
+%  p           = cell array containing the Fortran commands to be executed
+%  fid         = file ID -- handle for the file that is being written
+%*******************************************************************************
+function compileFortran(filePath,fileName,fortranExt)
+
+% Construct the names of the gateway file and compiled file
+userFile    = [filePath,fileName,fortranExt];
+wrapperFile = [filePath,fileName,'g',fortranExt];
+execFile    = [filePath,fileName,getMexExt];
+
+% Construct a gateway file if one does not already exist
+if (~exist(wrapperFile,'file'))
+   p{1}     = 'C';
+   p{end+1} = 'C Usage: [nc,fx,cx,gradfx,gradcx] = ExamplePF(x,p1,p2)';
+   p{end+1} = 'C';
+   p{end+1} = '       SUBROUTINE MEXFUNCTION(NLHS,PLHS,NRHS,PRHS)';
+   p{end+1} = '       INTEGER NLHS, NRHS, PLHS(*), PRHS(*)';
+   p{end+1} = 'C';
+   p{end+1} = '       INTEGER MXCREATEFULL,MXGETPR,MXGETM,MXGETN';
+   p{end+1} = 'C';
+   p{end+1} = 'C KEEP THE ABOVE PORTION FOR USE IN ALL FORTRAN MEX FILES';
+   p{end+1} = 'C -------------------------------------------------------';
+   p{end+1} = 'C';
+   p{end+1} = '       INTEGER NCMAX,NXMAX,NPMAX,NC,NX,NP1,NP2';
+   p{end+1} = '       INTEGER PNC,PX,PP,PF,PC,PDF,PDC';
+   p{end+1} = '       PARAMETER (NCMAX = 10,NPMAX = 10, NXMAX = 100)';
+   p{end+1} = '       REAL*8  P1(NPMAX), X(NXMAX)';
+   p{end+1} = '       REAL*8  F,C(NCMAX),DF(NXMAX),DC(NXMAX,NCMAX)';
+   p{end+1} = '       CHARACTER P2(NPMAX)';
+   p{end+1} = 'C';
+   p{end+1} = '       IF (NRHS .NE. 3 .OR. NLHS .NE. 5) THEN';
+   p{end+1} = '          CALL MEXERRMSGTXT(''Invalid number of arguments'')';
+   p{end+1} = '       ENDIF';
+   p{end+1} = 'C';
+   p{end+1} = 'C Get input data and set up input data pointers';
+   p{end+1} = '       NX      = MAX(MXGETM(PRHS(1)),MXGETN(PRHS(1)))';
+   p{end+1} = '       NP1     = MAX(MXGETM(PRHS(2)),MXGETN(PRHS(2)))';
+   p{end+1} = '       NP2     = MAX(MXGETM(PRHS(3)),MXGETN(PRHS(3)))';
+   p{end+1} = '       PX      = MXGETPR(PRHS(1))';
+   p{end+1} = '       PP      = MXGETPR(PRHS(2))';
+   p{end+1} = 'C';
+   p{end+1} = '       IF (NX .GT. NXMAX .OR. MAX(NP1,NP2) .GT. NPMAX) THEN';
+   p{end+1} = '          CALL MEXERRMSGTXT(''Array sizes too small'')';
+   p{end+1} = '       ENDIF';
+   p{end+1} = 'C';
+   p{end+1} = 'C';
+   p{end+1} = 'C Allocate memory and set up pointers for output variables';
+   p{end+1} = '       PLHS(1) = MXCREATEFULL(1,1,0)';
+   p{end+1} = '       PLHS(2) = MXCREATEFULL(1,1,0)';
+   p{end+1} = '       PLHS(3) = MXCREATEFULL(1,NCMAX,0)';
+   p{end+1} = '       PLHS(4) = MXCREATEFULL(NX,1,0)';
+   p{end+1} = '       PLHS(5) = MXCREATEFULL(NX,NCMAX,0)';
+   p{end+1} = '       PNC     = MXGETPR(PLHS(1))';
+   p{end+1} = '       PF      = MXGETPR(PLHS(2))';
+   p{end+1} = '       PC      = MXGETPR(PLHS(3))';
+   p{end+1} = '       PDF     = MXGETPR(PLHS(4))';
+   p{end+1} = '       PDC     = MXGETPR(PLHS(5))';
+   p{end+1} = 'C';
+   p{end+1} = 'C Load data into Fortran arrays and call the main subroutine';
+   p{end+1} = '       CALL MXCOPYPTRTOREAL8(PX,X,NX)';
+   p{end+1} = '       CALL MXCOPYPTRTOREAL8(PP,P1,NP1)';
+   p{end+1} = '       STATUS = MXGETSTRING(PRHS(3),P2,NP2)';
+   p{end+1} = '       IF (STATUS .EQ. 1 .AND. NP2 .NE. 0) THEN';
+   p{end+1} = '          CALL MEXERRMSGTXT(''Character array too small'')';
+   p{end+1} = '       ENDIF';
+   p{end+1} =['       CALL ',fileName,'(NP1,NP2,NX,P1,P2,X,NC,F,C,DF,DC)'];
+   p{end+1} = 'C';
+   p{end+1} = 'C Load output into Matlab structures';
+   p{end+1} = '       CALL MXCOPYREAL8TOPTR(DFLOAT(NC),PNC,1)';
+   p{end+1} = '       CALL MXCOPYREAL8TOPTR(F,PF,1)';
+   p{end+1} = '       CALL MXCOPYREAL8TOPTR(C,PC,NC)';
+   p{end+1} = '       CALL MXCOPYREAL8TOPTR(DF,PDF,NX)';
+   p{end+1} = '       CALL MXCOPYREAL8TOPTR(DC,PDC,NC*NX)';
+   p{end+1} = '       RETURN';
+   p{end+1} = '       END';
+
+   fid = fopen(wrapperFile,'w');
+   fprintf(fid,'%s\n',p{:});
+   fclose(fid);
+end
+
+% Try to compile the files, if a compiled file does not already exist
+if (~exist(execFile,'file'))
+   mex(userFile,wrapperFile,'-outdir',filePath);
+end
+return
+
+%*******************************************************************************
+% processC:  Construct a MEX C gateway file.
+% ------------------------------------------------------------------------------
+% Called by:  nomadm_functions
+% Calls:      getMexExt
+% VARIABLES:
+%  filePath    = current path where the C functions files lies
+%  fileName    = optimization problem name
+%  cExt        = filename extention of the C functions file
+%  userFile    = entire filename of the C functions file
+%  wrapperFile = entire filename of gateway file
+%  execFile    = entire filename of the compiled executable functions file
+%  p           = cell array containing the C commands to be executed
+%  fid         = file ID -- handle for the file that is being written
+%*******************************************************************************
+function compileC(filePath,fileName,cExt)
+
+% Construct the names of the gateway file and compiled file
+userFile    = [filePath,fileName,cExt];
+wrapperFile = [filePath,fileName,'temp',cExt];
+execFile    = [filePath,fileName,getMexExt];
+
+% Construct a gateway file if one does not already exist
+if (~exist(execFile,'file'))
+   p{1}     = '#include "mex.h"';
+   p{2}     = ' ';
+   p{3}     = '/* Usage: [nc,fx,cx,gradfx,gradcx] = ExamplePC(x,p1,p2) */';
+   p{4}     = ' ';
+   fid = fopen(userFile,'r');
+   while ~feof(fid)
+      p{end+1} = fgetl(fid);
+   end
+   fclose(fid);
+   p{end+1} = ' ';
+   p{end+1} = 'void mexFunction(int nlhs, mxArray *plhs[],';
+   p{end+1} = '                 int nrhs, const mxArray *prhs[])';
+   p{end+1} = '{';
+   p{end+1} = 'unsigned nx, np1, np2;';
+   p{end+1} = 'const unsigned ncmax = 100;';
+   p{end+1} = 'double   *p1, *x, *pnc, *pf, *pc, *pdf, *pdc;';
+   p{end+1} = 'char     *p2;';
+   p{end+1} = ' ';
+   p{end+1} = '/* ERROR CHECK the number of input and output arguments */';
+   p{end+1} = 'if (nrhs != 3) mexErrMsgTxt("Must have 3 Input Arguments");';
+   p{end+1} = 'if (nlhs != 5) mexErrMsgTxt("Must have 5 Output Arguments");';
+   p{end+1} = ' ';
+   p{end+1} = '/* GET INPUT DATA and set up input data pointers */';
+   p{end+1} = 'nx  = (unsigned) mxGetNumberOfElements(prhs[0]);';
+   p{end+1} = 'np1 = (unsigned) mxGetNumberOfElements(prhs[1]);';
+   p{end+1} = 'np2 = (unsigned) mxGetNumberOfElements(prhs[2]);';
+   p{end+1} = 'x   = mxGetPr(prhs[0]);';
+   p{end+1} = 'p1  = mxGetPr(prhs[1]);';
+   p{end+1} = 'p2  = mxGetChars(prhs[2]);';
+   p{end+1} = ' ';
+   p{end+1} = '/* SET UP POINTERS AND MEMORY FOR OUTPUT VARIABLES */';
+   p{end+1} = 'plhs[0] = mxCreateScalarDouble(0);';
+   p{end+1} = 'plhs[1] = mxCreateScalarDouble(0);';
+   p{end+1} = 'plhs[2] = mxCreateDoubleMatrix(1,ncmax,mxREAL);';
+   p{end+1} = 'plhs[3] = mxCreateDoubleMatrix(nx,1,mxREAL);';
+   p{end+1} = 'plhs[4] = mxCreateDoubleMatrix(nx,ncmax,mxREAL);';
+   p{end+1} = 'pnc     = mxGetPr(plhs[0]);';
+   p{end+1} = 'pf      = mxGetPr(plhs[1]);';
+   p{end+1} = 'pc      = mxGetPr(plhs[2]);';
+   p{end+1} = 'pdf     = mxGetPr(plhs[3]);';
+   p{end+1} = 'pdc     = mxGetPr(plhs[4]);';
+   p{end+1} = ' ';
+   p{end+1} = '/* GET FUNCTION OUTPUT DATA */';
+   p{end+1} = [fileName,'(np1,np2,nx,p1,p2,x,pnc,pf,pc,pdf,pdc);'];
+   p{end+1} = '}';
+
+   % Write the wrapper file source code
+   fid = fopen(wrapperFile,'w');
+   fprintf(fid,'%s\n',p{:});
+   fclose(fid);
+
+   % Compile the wrapper file and delete its source code
+   mex(wrapperFile,'-outdir',filePath,'-output', fileName);
+   if (exist(wrapperFile,'file')), delete(wrapperFile); end
+end
+return
+
+%*******************************************************************************
+% GetMexExt:  Returns platform-dependent extension for an executable file.
+% ------------------------------------------------------------------------------
+% Called by: compileFortran, compileC
+% VARIABLES:
+%  mexext   = platform-dependent executable file extension
+%  computer = Matlab built-in string function indicating platform type
+%*******************************************************************************
+function mexext = getMexExt
+
+% Determine the platform-dependent extention of the compiled file
+switch computer
+case {'PCWIN','MAC2'}
+   mexext = '.dll';     % MS Windows, Mac
+case {'LNX86'}
+   mexext = '.mexglx';  % Linux Intel
+case {'SUN4','SOL2'}
+   mexext = '.mexsol';  % SUN Sparc, Solaris 2
+case {'SGI','SGI64'}
+   mexext = '.mexsg';   % Silicon Graphics
+case {'IBM_RS'}
+   mexext = '.mexrs6';  % IBM RS6000
+case {'ALPHA','AXP_VMSG','AXP_VMSIEEE','VAX_VMSG','VAX_VMSD'}
+   mexext = '.mexaxp';  % DEC Alpha, VAX/VMS
+case {'HP700'}
+   mexext = '.mexhp7';  % HP 9000/700 (also .mexhpx)
+otherwise
+   error('Unknown computer type');
+end
+return
diff --git a/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm_functions.m b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm_functions.m
new file mode 100644
index 0000000000000000000000000000000000000000..a86a04fd8cf5b13d8ad194af840d34c19e30b49a
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/nomadm/nomadm_functions.m
@@ -0,0 +1,1761 @@
+function nomadm_functions(choice,param);
+%NOMADM_FUNCTIONS  Run NOMADm GUI functions.
+%
+%   Syntax:
+%      nomadm_functions(CHOICE)
+%      nomadm_functions(CHOICE,PARAM)
+%
+%   Description:
+%      NOMADM_FUNCTIONS executes one of several NOMADm
+%      GUI functions.  CHOICE is a string that describes
+%      which GUI function is to be performed.  Most of
+%      the GUI functions are specified in callback
+%      functions associated with GUI objects, such as
+%      menu choices, pushbuttons, etc., as defined by
+%      the calling function NOMADm.  The optional
+%      variable PARAM is used to pass additional data
+%      needed by an individual GUI function.
+%
+%   Note:  This function should only be called by NOMADM 
+%   and not run independently.
+%
+%   See also NOMADM, MADS
+
+%**************************************************************************
+% Copyright (c) 2001-2004 by Mark A. Abramson
+%
+% This file is part of the NOMADm software package.
+%
+% NOMADm is free software; you can redistribute it and/or modify it under
+% the terms of the GNU General Public License as published by the Free
+% Software Foundation; either version 2 of the License, or (at your
+% option) any later version.
+%
+% NOMADm is distributed in the hope that it will be useful, but WITHOUT 
+% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+% for more details.
+%
+% You should have received a copy of the GNU General Public License along
+% with NOMADm; if not, write to the Free Software Foundation, Inc., 
+% 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+% -------------------------------------------------------------------------
+% Author information:
+%   Mark A. Abramson, LtCol, USAF, PhD
+%   Air Force Institute of Technology
+%   Department of Mathematics and Statistics
+%   2950 Hobson Way
+%   Wright-Patterson AFB, OH 45433
+%   (937) 255-3636 x4524
+%   Mark.Abramson@afit.edu
+%**************************************************************************
+
+
+%**************************************************************************
+% NOMADm_Functions:  Run GUI functions associated with NOMADm
+% -------------------------------------------------------------------------
+% Called by: NOMADm
+% Calls:     runMADS,       loadMADS,    updateScreen, 
+%            searchOptions, daceOptions, viewResults
+% VARIABLES:
+%  choice     = string defining user-selected menu choice
+%  param      = additional parameter passed with choice
+%  GUI        = structure containing all GUI handles and variables
+%  onoff      = cell array with two strings "on" and "off"
+%  filterSpec = cell array of file types for file input dialog boxes
+%  RunSet     = global variable used to store MADS output data
+%
+%  All other variable specified below before menu choice
+%**************************************************************************
+
+global GUI
+onoff = {'on','off'};
+filterSpec = {'*.m',        'Matlab M-files (*.m)'; ...
+              '*.f; *.for', 'Fortran files (*.f,*.for)'; ...
+              '*.c; *.C',   'C/C++ files (*.c,*.C)'};
+if isappdata(0,'RUNSET'), RunSet = getappdata(0,'RUNSET'); end
+
+% Perform only the operations indicated by the "choice" variable
+switch choice
+
+   %***********************************************************************
+   % ChangeProblem: Choose an optimization problem
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI               = structure of all GUI handles and variables
+   %    .Path           =   path of current optimization problem
+   %    .ProblemExt     =   filename extension of optimization problem 
+   %    .ProblemName    =   name of current optimization problem
+   %    .RunStatus      =   handle for text bar at bottom of figure window
+   %    .RunMenuXXX     =   handles for Run menu items
+   %    .ProblemMenuXXX =   handles for Problem menu items
+   %    .MADSMenuXXX    =   handles for MADS menu items
+   %    .SessionMenuXXX =   handles for Session menu items
+   %    .CacheMenuXXX   =   handles for CacheMenu items
+   %    .FileExt        =   filename suffixes
+   %      .O            =     Omega file suffix
+   %      .I            =     initial points file suffix
+   %      .N            =     discrete neighbors file suffix
+   %      .P            =     user parameter file suffix
+   %      .C            =     Cache file suffix
+   %      .S            =     Session file suffix
+   %    .NoGrad         =   flag indicating initial availability of gradients
+   %  PFile             = filename of current optimization problem
+   %  PPath             = pathname of current optimization problem
+   %  ProblemName       = name of current optimization problem
+   %  isConstrained     = flags problem as having linear constraints
+   %  hasInitGuess      = flags problem as having an initial guess
+   %  hasUserParam      = flags problem as having user parameters
+   %  isMVP             = flags problem as being an MVP
+   %  existCache        = flags problem as having an existing Cache file
+   %  existSession      = flags problem as having an existing Session file
+   %  PLabels           = strings of Poll strategy labels
+   %***********************************************************************
+case 'ChangeProblem'
+   [PFile,PPath] = uigetfile(filterSpec, ...
+                             'Select an Optimization Problem file');
+   if (PFile)
+      nomadm_functions('Clear');
+      nomadm_functions('ResetSession');
+      rmpath(GUI.Path);
+      GUI.Path = PPath;
+      addpath(GUI.Path);
+      [ProblemName, GUI.ProblemExt] = strtok(PFile,'.');
+      set(GUI.ProblemName,'String',ProblemName);
+      set(GUI.RunStatus,  'String','No runs performed');
+      set(GUI.RunMenuExec,        'Enable','on');
+      set(GUI.RunMenuOneIteration,'Enable','on');
+      set(GUI.RunMenuExecFeasible,'Enable','on');
+      
+      % Allow editing only of files that exist
+      isConstrained = exist([ProblemName,GUI.FileExt.O,'.m']);
+      hasInitGuess  = exist([ProblemName,GUI.FileExt.I,'.m']);
+      isMVP         = exist([ProblemName,GUI.FileExt.N,'.m']);
+      hasUserParam  = exist([ProblemName,GUI.FileExt.P,'.m']);
+      existCache    = exist([ProblemName,GUI.FileExt.C]);
+      existSession  = exist([ProblemName,GUI.FileExt.S]);
+      set(GUI.ProblemMenuEdit(1),     'Visible', 'on');
+      set(GUI.ProblemMenuEdit(2),     'Visible', onoff{1+~hasInitGuess});
+      set(GUI.ProblemMenuEdit(3),     'Visible', onoff{1+~isConstrained});
+      set(GUI.ProblemMenuEdit(4),     'Visible', onoff{1+~isMVP});
+      set(GUI.ProblemMenuEdit(5),     'Visible', onoff{1+~hasUserParam});
+      set(GUI.MADSMenuPollOrder(end), 'Enable',  onoff{1+~hasUserParam});
+      set(GUI.SessionMenuLoad,        'Enable',  onoff{1+~existSession});
+      set(GUI.SessionMenuSave,        'Enable',  'on');
+      set(GUI.SessionMenuDelete,      'Enable',  onoff{1+~existSession});
+      set(GUI.CacheMenuLoad,          'Enable',  onoff{1+~existCache});
+      set(GUI.CacheMenuCount,         'Enable',  onoff{1+~existCache});
+      set(GUI.CacheMenuDelete,        'Enable',  onoff{1+~existCache});      
+      
+      % Allow gradient options if functions file returns enough arguments
+      try
+         GUI.NoGrad = (abs(nargout(ProblemName)) <= 2);
+      catch
+         GUI.NoGrad = 0;
+      end
+      PLabels = char(GUI.Labels.PollStrategy);
+      set(GUI.MADSMenuPollStrategy(find(PLabels(:,1) == 'G')), ...
+                                  'Enable',onoff{1+GUI.NoGrad});
+   end
+
+   %***********************************************************************
+   % EditFile: Edit an optimization problem file
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  k              = Problem Menu position number of selected file
+   %  Ext            = filename extension of file to be edited
+   %  FileName       = full file name of file to be edited
+   %  GUI            = structure of all GUI handles and variables
+   %    .Path        =   path of current optimization problem
+   %    .ProblemExt  =   filename extension of optimization problem 
+   %    .ProblemName =   name of current optimization problem
+   %    .Types.File  = strings of file suffixes
+   %***********************************************************************
+case 'EditFile'
+   k = get(gcbo,'Position') - 1;
+   if (k == 1)
+      Ext = GUI.ProblemExt;
+   else
+      Ext = '.m';
+   end
+   FileName = fullfile(GUI.Path, ...
+                  [get(GUI.ProblemName,'String'),GUI.Types.File{k},Ext]);
+   edit(FileName);
+   clear(FileName);
+
+   %***********************************************************************
+   % Scaling: Set the variable scaling of an optimization problem
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI.ScaleMenu = handle for GUI Scaling submenu of MADS menu
+   %***********************************************************************
+case 'Scaling'
+   set(GUI.ScaleMenu,'Checked','off');
+   set(GUI.ScaleMenu(get(gcbo,'Position')),'Checked','on');   
+
+   %***********************************************************************
+   % LoadSession: Load session options from previously saved file
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     updateScreen
+   % VARIABLES:
+   %  SessionFile     = full path and name of session file
+   %  GUI.Path        = path of current optimization problem
+   %  GUI.ProblemName = name of current optimization problem
+   %  GUI.FileExt.S   = filename extension of session file
+   %  GUI.Choice      = current user choices
+   %  GUI.Options     = current option settings
+   %  Session.Choice  = previously saved user choices 
+   %  Session.Options = previously saved option settings
+   %***********************************************************************
+case 'LoadSession'
+   SessionFile = fullfile(GUI.Path, ...
+                 [get(GUI.ProblemName,'String'), GUI.FileExt.S]);
+   if exist(SessionFile,'file')
+      load(SessionFile);
+      GUI.Choice  = Session.Choice;
+      GUI.Options = Session.Options;
+      GUI = updateScreen('all', GUI.Choice, GUI.Options, GUI);
+   end
+
+   %***********************************************************************
+   % ResetSession: Reset MADS Parameters to Default values
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     updateScreen
+   % VARIABLES:
+   %  GUI.Choice           = current user choices
+   %  GUI.Options          = current option settings
+   %  GUI.Defaults.Choice  = default user choice settings
+   %  GUI.Defaults.Options = default options settings
+   %***********************************************************************
+case 'ResetSession'
+   GUI.Choice  = GUI.Defaults.Choice;
+   GUI.Options = GUI.Defaults.Options;
+   GUI = updateScreen('all', GUI.Choice, GUI.Options, GUI);
+
+   %***********************************************************************
+   % EditSearch: Edit Search Parameters
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     searchOptions
+   % VARIABLES:
+   %  NewAns                    = answers to an input dialog box
+   %  GUI.Options.nSearches     = number of Search types to be used
+   %  GUI.Options.SurrOptimizer = string ID for surrogate optimizer
+   %  GUI.SearchType            = handles for displayed Search types
+   %  nSearches                 = number of Search types selected
+   %***********************************************************************
+case 'EditSearch'
+   NewAns = inputdlg({'Number of Search types','Surrogate Optimizer'}, ...
+                      'Search Information', 1, ...
+                      {int2str(GUI.Options.nSearches), ...
+                       GUI.Options.SurrOptimizer});
+   if isempty(NewAns), return, end
+   nSearches = str2num(NewAns{1});
+   GUI.Options.SurrOptimizer = NewAns{2};
+   if isempty(nSearches) | length(nSearches) > 1, return, end
+   if (nSearches == 0)
+      set(GUI.SearchType(1:end), 'String', 'None');
+   else
+      GUI.Options.nSearches = nSearches;
+      searchOptions(nSearches,GUI.Options.SurrOptimizer);
+   end
+
+   %***********************************************************************
+   % LoadSearchOptions: Load selected Search parameters
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     updateScreen
+   % VARIABLES:
+   %  k               = Search number
+   %  GUI             = structure of all GUI handles and variables
+   %    .Choice       =   structure of user choices
+   %      .search(k)  =     user Search choices
+   %    .Options      =   structure of MADS parameters settings
+   %      .Search(k)  =     structure of user-selected k-th Search
+   %      .nSearches  = number of Search types to be used
+   %    .Types.Search = list of possible Search types
+   %    .figSearch    = handle for the Search figure window
+   %    .SearchScreen = handles for Search figure window objects
+   %    .NoGrad       =   flag indicating initial availability of gradients
+   %  Search          = temporary storage of GUI.Options.Search(k)
+   %    .type         =   string identifying Search type
+   %    .label        =   long text label for Search type
+   %    .nIter        =   number of iterations to perform Search
+   %    .nPoints      =   number of Search points
+   %    .file         =   optional user file defining Search
+   %***********************************************************************
+case 'LoadSearchOptions'
+   loadSearch = get(gcbo,'UserData');
+   if loadSearch
+      for k = 1:GUI.Options.nSearches
+         GUI.Choice.search(k) = get(GUI.SearchScreen(k).type, 'Value');
+         Search.type = GUI.Types.Search{GUI.Choice.search(k)};
+         if (GUI.NoGrad & strcmp(Search.type, 'GPollI'))
+            uiwait(msgbox('No derivatives available for this problem', ...
+                         ['Error in Search Type #', int2str(k)], ...
+                          'error','modal'));
+            return
+         end
+         Search.label   = GUI.Labels.Search{GUI.Choice.search(k)};
+         Search.nIter   = str2num( get(GUI.SearchScreen(k).nIter,  'String'));
+         Search.nPoints = str2num( get(GUI.SearchScreen(k).nPoints,'String'));
+         Search.file    = fullfile(get(GUI.SearchScreen(k).file, 'UserData'), ...   
+                                get(GUI.SearchScreen(k).file, 'String'));
+         GUI.Options.Search(k) = Search;
+      end
+      GUI = updateScreen('search', GUI.Choice,GUI.Options,GUI);
+   end
+   close(GUI.figSearch);
+
+   %***********************************************************************
+   % LoadDACEOptions: Select a DACE surrogate option
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  k                  = Search number
+   %  dace               = structure of DACE parameters
+   %    .Reg             =   handle for regression function
+   %    .Corr            =   handle for correlation function
+   %    .Theta           =   initial guess for correlation parameters
+   %    .Lower           =   lower bounds for correlation parameters
+   %    .Upper           =   upper bounds for correlation parameters
+   %    .Isotropic       =   flag for isotropic correlation parameters
+   %  GUI                = structure of all GUI handles and variables
+   %    .Types           =   lists of possible types
+   %      .daceReg       =     list of possible DACE regression functions
+   %      .daceCorr      =     list of possible DACE correlation functions
+   %    .SearchScreen    =   handles for Search figure window objects
+   %      .file          =     optional user file defining Search
+   %    .daceOptionsXXX  =   handles for DACE figure window objects
+   %    .Options.dace(k) =   structure of DACE parameters for Search k
+   %    .figDACE         =   handle for DACE figure window
+   %***********************************************************************
+case 'LoadDACEOptions'
+   k = get(gcbo, 'UserData');
+   if k
+      dace.Reg      = GUI.Types.daceReg{ get(GUI.daceOptionsReg, 'Value')};
+      dace.Corr     = GUI.Types.daceCorr{get(GUI.daceOptionsCorr,'Value')};
+      dace.Theta    = str2num(get(GUI.daceOptionsTheta,'String'));
+      dace.Lower    = str2num(get(GUI.daceOptionsLower,'String'));
+      dace.Upper    = str2num(get(GUI.daceOptionsUpper,'String'));
+      dace.Isotropic = get(GUI.daceOptionsIsotropic,'Value');
+      set(GUI.SearchScreen(k).file, 'UserData', '');
+      set(GUI.SearchScreen(k).file, 'String', dace.Reg);
+      GUI.Options.dace(k) = dace;      
+   end
+   close(GUI.figDACE);
+
+   %***********************************************************************
+   % LoadUserSearchFile: Load a user-specified Search file
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     daceOptions
+   % VARIABLES:
+   %  k                     = Search number
+   %  GUI.Types.Search      = list of possible Search types
+   %  GUI.SearchScreen.file = handle for Search figure window user file
+   %  SName, SPath          = name and path of user Search file
+   %  filterSpec            = file types for use in input dialog boxes
+   %***********************************************************************
+case 'LoadUserSearchFile'
+   k = get(gcbo, 'UserData');
+   switch GUI.Types.Search{get(gcbo, 'Value')}
+   case {'Custom','CustomS'}
+      [SName,SPath] = uigetfile(filterSpec, ...
+                               ['Choose File for Search #', int2str(k)]);
+      if (SName)
+         set(GUI.SearchScreen(k).file, 'UserData', SPath);
+         set(GUI.SearchScreen(k).file, 'String',   SName);
+      end
+   case {'DACE'}
+      daceOptions(k);
+   otherwise
+      set(GUI.SearchScreen(k).file, 'String', '');
+   end
+
+   %***********************************************************************
+   % Edit Parameters: Edit parameters
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  param   = User data storage
+   %  Title   = title of input dialog box
+   %  Labels  = text labels in input dialog box
+   %  Handles = handles to appropriate GUI figure objects
+   %  DefAns  = default answers that appear in input dialog box
+   %  NewAns  = new answers that appear in input dialog box
+   %***********************************************************************
+case 'EditParameters'
+   param   = get(gcbo,'UserData');
+   [Title, Labels, Handles] = deal(param{:});
+   DefAns  = get(Handles, 'String');
+   NewAns  = inputdlg(Labels,Title,ones(length(DefAns),1)*[1,45],DefAns);
+   if (~isempty(NewAns))
+      set(Handles, {'String'}, NewAns);
+   end
+
+   %***********************************************************************
+   % SelectPollXXX: Select a Poll Strategy, Poll Center, or Poll Order
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI.Choice      = user choices
+   %    .pollStrategy =   selected Poll strategy
+   %    .pollCenter   =   selected Poll center
+   %    .pollOrder    =   selected Poll order strategy
+   %  GUI.pollXXX     = GUI figure window objects for GUI.Choice items
+   %***********************************************************************
+case 'SelectPollStrategy'
+   GUI.Choice.pollStrategy = get(gcbo,'Position');
+   set(GUI.PollStrategy,'String', get(gcbo,'Label'));
+case 'SelectPollCenter'
+   GUI.Choice.pollCenter = get(gcbo,'Position');
+   set(GUI.PollCenter,'String', get(gcbo,'Label'));
+case 'SelectPollOrder'
+   GUI.Choice.pollOrder = get(gcbo,'Position');
+   set(GUI.PollOrder,'String', get(gcbo,'Label'));
+
+   %***********************************************************************
+   % Toggle: Toggle the check mark of a menu item
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   %***********************************************************************
+case 'Toggle'
+   umtoggle(gcbo);
+
+   %***********************************************************************
+   % SaveCache: Save MADS run results in a .mat file for later retrieval
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI             = structure of all GUI handles and variables
+   %    .fig          =   handle for the GUI figure window
+   %    .RunStatus    =   handle for the GUI figure window status bar
+   %    .RunCount     =   MADS run number
+   %    .ProblemName  =   name of current optimization problem
+   %    .Path         =   path of current optimization problem
+   %    .CacheMenuXXX =   handles for Cache menu items
+   %    .FileExt.C    =   default Cache filename suffix 
+   %  CName           = name of Cache file
+   %  RunSet(1).Cache = structure of MADS run data
+   %  Cache           = storage of Cache for use by MADS
+   %***********************************************************************
+case 'SaveCache'
+   setptr(GUI.fig,'watch');
+   set(GUI.RunStatus, 'String', ...
+       ['Run # ',int2str(GUI.RunCount),' Cache being saved']);
+   CName = [get(GUI.ProblemName, 'String'), GUI.FileExt.C];
+   Cache = RunSet(1).Cache;
+   save([GUI.Path, CName],'Cache');
+   set([GUI.CacheMenuLoad; GUI.CacheMenuCount;GUI.CacheMenuDelete], ...
+       'Enable','on');
+   set(GUI.RunStatus, 'String', ...
+       ['Run # ',int2str(GUI.RunCount),' Cache saved in ',CName]);
+   setptr(GUI.fig,'arrow');
+
+   %***********************************************************************
+   % SaveSession: Save session options to file for future retrieval
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     loadMADS
+   % VARIABLES:
+   %  SessionFile       = full path and name of session file
+   %  GUI               = structure of all GUI handles and variables
+   %    .Path           =   path of current optimization problem
+   %    .ProblemName    =   name of current optimization problem
+   %    .FileExt.S      =   filename extension of session file
+   %    .Choice         =   current user choices
+   %    .Options        =   current option settings
+   %    .SessionMenuXXX =   handles for Session menu items
+   %    .OptionsMenuXXX =   handles for Options menu items
+   %    .RunStatus      =   handle for figure window status bar
+   %  Session           = previously saved options and parameters
+   %    .Problem        =   optimization problem data
+   %    .Choice         =   user choices 
+   %    .Options        =   option settings
+   %      .Term         =     termination criteria
+   %        .iter       =       number of iterations
+   %        .func       =       number of function evaluations
+   %        .time       =       CPU time
+   %        .fails      =       number of consecutive Poll failures
+   %      .TermRel      =     termination relative to initial mesh size
+   %***********************************************************************
+case 'SaveSession'
+   SessionFile = [get(GUI.ProblemName,'String'), GUI.FileExt.S];
+   [Session.Problem,Session.Options] = loadMADS(0,GUI);
+   Session.Options.Term.iter  = get(GUI.TermIter,  'String');
+   Session.Options.Term.func  = get(GUI.TermFunc,  'String');
+   Session.Options.Term.time  = get(GUI.TermTime,  'String');
+   Session.Options.Term.fails = get(GUI.TermFails, 'String');
+   umtoggle(GUI.OptionsMenuTermRel);
+   Session.Options.TermRel   = umtoggle(GUI.OptionsMenuTermRel);
+   Session.Choice = GUI.Choice;
+   save([GUI.Path, SessionFile],'Session');
+   set(GUI.RunStatus,'String', ...
+       ['Session Options saved to file, ' SessionFile]);
+   set([GUI.SessionMenuLoad; GUI.SessionMenuDelete],'Enable','on');
+
+   %***********************************************************************
+   % DeleteFile: Delete a Session or Cache file
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  param          = user data that identifies file to be deleted
+   %  FileID         = string identifing file to be deleted
+   %  FileExt        = filename suffix of file to be deleted
+   %  handles        = handles of menu choices to be disabled
+   %  file           = full path and name of file to be deleted
+   %  deleteFile     = logical for deleting file
+   %  GUI            =   structure of all GUI handles and variables
+   %    .Path        =   path of current optimization problem
+   %    .ProblemName =   name of current optimization problem
+   %    .RunStatus   =   handle for figure window status bar
+   %***********************************************************************
+case 'DeleteFile'
+   param = get(gcbo,'UserData');
+   [FileID,FileExt,handles] = deal(param{:});
+   file  = fullfile(GUI.Path,[get(GUI.ProblemName,'String'), FileExt]);
+   deleteFile = questdlg(['Are you sure you want to delete ',file,'?'], ...
+                         ['Delete ',FileID,'?'],'No');
+   if strcmp(deleteFile, 'Yes')
+      delete(file);
+      set(GUI.RunStatus,'String', [FileID,', ',file,', has been deleted']);
+      set(handles,'Enable','off');
+   end
+   
+   %***********************************************************************
+   % Clear: Clear figure window and reset all the appropriate variables
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI               = structure of all GUI handles and variables
+   %    .fig            =   handle for GUI figure window
+   %    .StopRun        =   handle for Stop Run pushbutton
+   %    .ResumeRun      =   handle for Resume Run pushbutton
+   %    .axesHistory    =   handle for History plot
+   %    .axesFilter     =   handle for Filter plot
+   %    .ResultsMenuXXX =   handles for Results menu items
+   %    .RunMenuXXX     =   handles for Run menu items
+   %    .CacheMenuXXX   =   handles for Cache menu items
+   %    .RunStatus      =   handle for figure window status bar
+   %    .RunMax         =   maximum nmber of MADS runs
+   %    .RunCount       =   MADS run counter
+   %  RunSet            = structure of MADS run data
+   %***********************************************************************
+case 'Clear'
+   cla;
+   setptr(GUI.fig,'arrow');
+   set([GUI.axesHistory; get(GUI.axesHistory,'Children')],'Visible','off');
+   set([GUI.axesFilter;  get(GUI.axesFilter, 'Children')],'Visible','off');
+   set([GUI.StopRun; GUI.ResumeRun],                      'Visible','off');      
+   set([GUI.ResultsMenuView(1:GUI.RunMax)'],              'Visible','off');
+   set([GUI.ResultsMenu],                                 'Visible','off');
+   set([GUI.RunMenuClear;  GUI.CacheMenuSave],            'Enable', 'off');
+   set([GUI.RunMenuResume; GUI.RunMenuRestart],           'Enable', 'off');      
+   set(GUI.axesHistory, 'NextPlot','replace');
+   set(GUI.RunStatus,'String','All runs cleared');
+   GUI.RunCount = 0;
+   RunSet = [];
+   clear functions;
+   if isappdata(0,'RUNSET'), rmappdata(0,'RUNSET'); end
+
+   %***********************************************************************
+   % RunMADS: Run the MADS optimization algorithm
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     runMADS
+   % VARIABLES:
+   %  param                        = parameter indicating type of MADS run
+   %  GUI.Options.RunUntilFeasible = flag to run MADS only until feasible
+   %***********************************************************************
+case 'RunMADS'
+   if (param == -1), GUI.Options.RunUntilFeasible = 1; end
+   runMADS(param);
+
+   %***********************************************************************
+   % ViewResults: View the summary results of a MADS run
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % Calls:     viewResults
+   % VARIABLES:
+   %  GUI               = structure of all GUI handles and variables
+   %***********************************************************************
+case 'ViewResults'
+   viewResults(get(gcbo,'Position'), GUI);
+
+   %***********************************************************************
+   % BestX/BestP: View continuous/categorical variables of MADS solutions
+   % ----------------------------------------------------------------------
+   % Called by: viewResults
+   % VARIABLES:
+   %  BestLabel = label for viewing window
+   %  best      = user data for categorical variables pushbutton
+   %  n         = length of best
+   %  Add0Pts   = structure of viewing options
+   %  Best      = temporary storage of categorical variables
+   %***********************************************************************
+case 'BestX'
+   BestLabel = 'Best_Continuous_Variable_Values';
+   assignin('base',BestLabel,get(gcbo,'UserData'));
+   openvar(BestLabel);
+   clear(BestLabel);
+case 'BestP'
+   best = get(gcbo,'UserData');   
+   BestLabel = 'Best_Categorical_Variable_Values';
+   n = length(best);
+   for k = 1:n
+      if (~ischar(best{k})), best{k} = num2str([best{k}]); end
+   end
+   Add0pts = struct('Resize','on','WindowStyle','normal', ...
+                    'Interpreter','tex');
+   Best = inputdlg(cellstr(int2str([1:n]')),BestLabel,ones(n,1)*[1,50], ...
+                   best,Add0pts);
+   clear('Best');
+
+   %***********************************************************************
+   % CopyPlot: Copy history or filter plot to a new screen
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  h1   = handle to new figure window
+   %  h2   = handle to new axes on figure window
+   %***********************************************************************
+case 'CopyPlot'
+   h1 = figure;
+   h2 = copyobj(gcbo,h1);
+   set(h2,'Position','default','ButtonDownFcn','');
+
+   %***********************************************************************
+   % Help: View a Help file
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  errorflag = error flag for viewing failure
+   %***********************************************************************
+case 'Help'
+   errorflag = web(['file:///', which(get(gcbo,'UserData'))], '-browser');
+   if (errorflag), errordlg('Error: browser or help file not found'); end
+
+   %***********************************************************************
+   % About: View author information
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI.Program  =   Software name
+   %  GUI.PVersion =   Software version number
+   %***********************************************************************
+case 'About'
+   msgbox({[GUI.Program ',  Version ' GUI.PVersion], ...
+          'Copyright (c) 2001-2004 by Mark A. Abramson'}, ...
+          ['About ' GUI.Program]);
+
+   %***********************************************************************
+   % StopRun: Stop a MADS run
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI.StopRun  =   handle for Stop Run pushbutton
+   %***********************************************************************
+case 'StopRun'
+   set(gcbo,'UserData',1);
+
+   %***********************************************************************
+   % Quit: End program session
+   % ----------------------------------------------------------------------
+   % Called by: NOMADm
+   % VARIABLES:
+   %  GUI.Path =   path of current optimization problem
+   %  GUI.fig  = handle for GUI figure window
+   %***********************************************************************
+case 'Quit'
+   rmpath(GUI.Path);
+   if ishandle(GUI.fig)
+      delete(GUI.fig);
+   end
+   clear variables;
+   clear functions;
+end
+
+drawnow;
+return
+
+%**************************************************************************
+% UpdateScreen:  Displays a user input screen to set Search parameters.
+% -------------------------------------------------------------------------
+% Called by: nomadm_functions
+% Calls:     updateSearchLabels
+% VARIABLES:
+%  newGUI              = updated GUI
+%  updateType          = type of screen update
+%  Choice              = structure of menu choices
+%    .PollStrategy     =   integer choice of Poll strategy
+%    .PollOrder        =   integer choice of Poll order strategy
+%    .PollCenter       =   integer choice of Poll center
+%  Options             = structure of MADS parameters
+%    .nSearches        =   number of Search types used
+%    .Search(n)        =   structure of Search parameters
+%    .delta0           =   initial mesh size
+%    .deltaMax         =   maximum mesh size
+%    .meshRefine       =   mesh refinement factor
+%    .meshCoarsen      =   mesh coarsening factor
+%    .CacheTol         =   tolerance for flagging point as being in Cache
+%    .hmin             =   minimum h-value of an infeasible point
+%    .hmax             =   maximum h-value of a filter point
+%    .EPollTriggerF    =   f-value Extended Poll trigger
+%    .EPollTriggerH    =   h-value Extended Poll trigger
+%    .Term             =   substructure containing MADS termination criteria
+%      .delta          =     mesh size parameter
+%      .iter           =     maximum number of MADS iterations
+%      .func           =     maximum number of function evaluations
+%      .time           =     maximum CPU time
+%      .fails          =     maximum number of consecutive Poll failures
+%    .TermIterFlag     =   turns on/off .iter as termination criteria
+%    .TermFuncFlag     =   turns on/off .func as termination criteria
+%    .TermTimeFlag     =   turns on/off .time as termination criteria
+%    .TermFailsFlag    =   turns on/off .fails as termination criteria
+%    .scale            =   flag for scaling mesh directions
+%    .PollComplete     =   turns on/off complete Polling
+%    .TermRel          =   computes termination delta relative to .delta0
+%    .useFilter        =   use filter for nonlinear constraints
+%    .removeRedundancy = remove redundant linear constraints
+%    .accelerate       =   flag for accelerating mesh refinement
+%    .plotHistory1     =   turns on/off a history plot
+%    .plotHistory2     =   turns on/off a real-time history plot
+%    .plotFilter       =   turns on/off a real-time filter plot
+%    .loadCache        =   flag for loading a pre-existing Cache file
+%    .countCache       =   flag for counting Cache points as function calls
+%    .RunOneIteration  =   flag for running one MADS iteration at a time
+%    .RunUntilFeasible =   flag for running MADS only until feasible
+%  GUI                 = structure for GUI parameters
+%                        (These are all handles for GUI window objects)
+%    .SearchType(k)    =   current Search types
+%    .PollStrategy     =   current Poll strategy
+%    .PollCenter       =   current Poll center
+%    .PollOrder        =   current Poll order type
+%    .delta0           =   current initial mesh size
+%    .deltaMax         =   current maximum mesh size
+%    .meshRefine       =   current mesh refinement factor
+%    .meshCoarsen      =   current mesh coarsening factor
+%    .CacheTol         =   current Cache tolerance
+%    .hmin             =   current minimum infeasible h-value
+%    .hmax             =   current maximum filter h-value
+%    .EPollXiF         =   current f-value Extended Poll trigger
+%    .EPollXiH         =   current h-value Extended Poll trigger
+%    .TermDelta        =   current mesh size termination criteria
+%    .TermIter         =   current maximum number of MADS iterations
+%    .TermFunc         =   current maximum number of function evaluations
+%    .TermTime         =   current maximum CPU time
+%    .TermFails        =   current max number of consec Poll failures
+%    .TermIterFlag     =   current checkbox value for .TermIter
+%    .TermFuncFlag     =   current checkbox value for .TermFunc
+%    .TermTimeFlag     =   current checkbox value for .TermTime
+%    .TermFailsFlag    =   current checkbox value for .TermFails
+%    .CacheMenuXXX     =   Cache menu items
+%    .MADSMenuXXX      =   MADS menu items
+%    .OptionsMenuXXX   =   Options menu items
+%    .RunMenuXXX       =   Run menu items
+%  onoff               = cell array of two strings "on" and "off"
+%  maxDisplay          = number of Search Types displayed on the main GUI
+%  searchLabel         = Search label that appears on the main GUI
+%**************************************************************************
+function newGUI = updateScreen(updateType,Choice,Options,GUI);
+
+onoff = {'on','off'};
+
+% Update GUI Search fields
+maxDisplay = length(GUI.SearchType);
+searchLabel = updateSearchLabels(maxDisplay,Options.nSearches,Options.Search);
+for k = 1:maxDisplay
+   set(GUI.SearchType(k), 'String', searchLabel{k});
+end
+
+% Update other GUI fields
+if (strcmp(updateType, 'all'))
+   set(GUI.PollStrategy, 'String', ...
+       GUI.Labels.PollStrategy(Choice.pollStrategy));
+   set(GUI.PollCenter,   'String', ...
+       GUI.Labels.PollCenter(Choice.pollCenter));
+   set(GUI.PollOrder,    'String', ...
+       GUI.Labels.PollOrder(Choice.pollOrder));
+   set(GUI.delta0,       'String', num2str(Options.delta0,       '%1.1f'));
+   set(GUI.deltaMax,     'String', num2str(Options.deltaMax,     '%2.1f'));
+   set(GUI.MeshRefine,   'String', num2str(Options.meshRefine,   '%1.1f'));
+   set(GUI.MeshCoarsen,  'String', num2str(Options.meshCoarsen,  '%1.1f'));
+   set(GUI.CacheTol,     'String', num2str(Options.CacheTol,     '%1.6g'));
+   set(GUI.hmin,         'String', num2str(Options.hmin,         '%1.5g'));
+   set(GUI.hmax,         'String', num2str(Options.hmax,         '%1.2f'));
+   set(GUI.EPollXiF,     'String', num2str(Options.EPollTriggerF,'%1.5g'));
+   set(GUI.EPollXiH,     'String', num2str(Options.EPollTriggerH,'%1.5g'));
+   set(GUI.TermDelta,    'String', num2str(Options.Term.delta,   '%1.5g'));
+   set(GUI.TermIter,     'String', Options.Term.iter);
+   set(GUI.TermFunc,     'String', Options.Term.func);
+   set(GUI.TermTime,     'String', Options.Term.time);
+   set(GUI.TermFails,    'String', Options.Term.fails);
+   set(GUI.TermIterFlag,  'Value', Options.TermIterFlag);
+   set(GUI.TermFuncFlag,  'Value', Options.TermFuncFlag);
+   set(GUI.TermTimeFlag,  'Value', Options.TermTimeFlag);
+   set(GUI.TermFailsFlag, 'Value', Options.TermFailsFlag);
+   set(GUI.ScaleMenu(1),   'Checked', onoff{1+~(Options.scale == 0)});
+   set(GUI.ScaleMenu(2),   'Checked', onoff{1+~(Options.scale == 2)});
+   set(GUI.ScaleMenu(3),   'Checked', onoff{1+~(Options.scale == 10)});
+   set(GUI.CacheMenuLoad,  'Checked', onoff{2-Options.loadCache});
+   set(GUI.CacheMenuCount, 'Checked', onoff{2-Options.countCache});
+   set(GUI.MADSMenuPollComplete, ...
+                           'Checked', onoff{2-Options.PollComplete});
+   set(GUI.OptionsMenuTermRel, ...
+                           'Checked', onoff{2-Options.TermRel});
+   set(GUI.OptionsMenuUseFilter, ...
+                           'Checked', onoff{2-Options.useFilter});
+   set(GUI.OptionsMenuRemoveRedundancy, ...
+                           'Checked', onoff{2-Options.removeRedundancy});
+   set(GUI.OptionsMenuAccelerate, ...
+                           'Checked', onoff{2-Options.accelerate});
+   set(GUI.OptionsMenuPlotHistory1, ...
+                           'Checked', onoff{2-Options.plotHistory1});
+   set(GUI.OptionsMenuPlotHistory2, ...
+                           'Checked', onoff{2-Options.plotHistory2});
+   set(GUI.OptionsMenuPlotFilter, ...
+                           'Checked', onoff{2-Options.plotFilter});
+   set(GUI.RunMenuOneIteration, ...
+                           'Checked', onoff{2-Options.RunOneIteration});
+   set(GUI.RunMenuExecFeasible, ...
+                           'Checked', onoff{2-Options.RunUntilFeasible});
+end
+newGUI = GUI;
+return
+
+%**************************************************************************
+% updateSearchLabels:  Displays the Search Labels on the main GUI.
+% -------------------------------------------------------------------------
+% Called by: updateScreen
+% VARIABLES:
+%  label          = cell array containing labels for each Search type
+%  maxDisplay     = number of Search types shown on the NOMADm GUI
+%  nSearches      = number of Search types
+%  Search(k)      = structure that describes the k-th Search
+%    .type        =   string identifying Search type
+%    .label       =   long text label for Search type
+%    .nIter       =   number of iterations to perform Search
+%    .nPoints     =   number of Search points
+%    .file        =   optional user file defining Search
+%  k              = Search type counter
+%  searchFilePath = path for optional Search file
+%  searchFile     = name of optional Search file
+%**************************************************************************
+function label = updateSearchLabels(maxDisplay, nSearches, Search)
+
+% Initialize display parameters
+[label{1:maxDisplay}] = deal('None');
+if (nSearches > maxDisplay)
+   label{maxDisplay} = 'Multiple Search Types';
+   nSearches = maxDisplay - 1;
+end
+
+% Construct Search labels
+for k = 1:nSearches
+    [searchFilePath,searchFile] = fileparts(Search(k).file);
+    switch Search(k).type
+    case {'None'}
+       label{k} = Search(k).label; 
+    case {'LHS', 'Mesh','GA'}
+       label{k} = [int2str(Search(k).nPoints),'-pt. ',Search(k).label];
+    case {'SPollI','CPollI','GPollI'}
+       if (Search(k).nPoints == 1)
+         label{k} = strrep(Search(k).label(1:end-1), 'N ', '');
+       else
+         label{k} = strrep(Search(k).label,'N',int2str(Search(k).nPoints));
+       end
+    case {'DACE'}
+       label{k} = ['DACE Surrogate: ',   searchFile];
+    case {'Custom'}
+       label{k} = ['Custom Search: ',    searchFile];
+    case {'CustomS'}
+       label{k} = ['Custom Surrogate: ', searchFile];
+    end
+    label{k} = [label{k}, ' (', int2str(Search(k).nIter), ')'];
+end
+return
+
+%**************************************************************************
+% runMADS:  Assign GUI input fields to MADS variables and run MADS
+% -------------------------------------------------------------------------
+% Called by: nomadm_functions
+% Calls:     loadMADS, mads, nomad_functions('SaveCache')
+% VARIABLES:
+%  restart           = flag for resuming previous run
+%  GUI               = structure containing all GUI handles and variables
+%    .Program        =   Name of this software
+%    .RunCount       =   current MADS run number
+%    .RunMax         =   maximum allowed MADS run number
+%    .fig            =   handle for the main figure window
+%    .StopRun        =   handle for Stop Run pushbutton
+%    .ResumeRun      =   handle for Resume Run pushbutton
+%    .axesFilter     =   handle for Filter plot
+%    .axesHistory    =   handle for History plot
+%    .RunMenuXXX     =   handles for Run menu items
+%    .ResultsMenuXXX =   handles for Results menu items
+%    .CacheMenuXXX   =   handles for Cache menu items
+%    .RunStatus      =   handle for figure window status bar
+%  RunSet            = global variable used to store MADS output data
+%    .BestF          =   best feasible solution found by MADS
+%    .BestI          =   best infeasible solution found by MADS
+%    .RunStats       =   structure of MADS run statistics
+%      .delta        =     current mesh size
+%      .time         =     current CPU time expended
+%      .Cache        =   structure of all processed MADS iterates
+%  Problem           = structure containing optimization problem data
+%    .File.I         =   name of initial points file
+%  Options           = structure containing MADS parameters
+%    .loadCache      =   flag for loading a pre-existing Cache file
+%    .countCache     =   flag for counting Cache points as function calls
+%    .delta0         =   initial mesh size
+%    .RunCount       =   current MADS run number
+%  iterate0          = initial iterate
+%  BestF             = best feasible iterate found by MADS
+%  BestI             = least infeasible iterate found by MADS
+%  RunStats          = structure containing MADS run statistics
+%**************************************************************************
+function runMADS(restart);
+
+global GUI
+if isappdata(0,'RUNSET'), RunSet = getappdata(0,'RUNSET'); end
+
+lasterr([GUI.Program ' interrupted by user']);
+try
+   % Change figure window, as appropriate
+   if (GUI.RunCount >= GUI.RunMax)
+      error('Too many MADS runs without clearing.');
+   end
+   setptr(GUI.fig,'watch');
+   set(GUI.StopRun,  'Visible','on','UserData',0);
+   set(GUI.ResumeRun,'Visible','off');
+   set(GUI.RunMenuClear,'Enable','on');
+   set([GUI.axesFilter; get(GUI.axesFilter,'Children')], 'Visible', 'off');
+   set(GUI.axesFilter,'ButtonDownFcn','');
+   drawnow;
+
+   % Load MADS input data
+   [Problem,Options] = loadMADS(restart, GUI);
+
+   % Get initial point
+   if (restart > 0)
+      iterate0 = [RunSet(GUI.RunCount).BestF, RunSet(GUI.RunCount).BestI];
+   elseif (~restart & exist(Problem.File.I))
+      iterate0 = feval(Problem.File.I);
+   else
+      error(['Cannot find: ', Problem.File.I, '.m']);
+   end
+
+   % Set up and run MADS algorithm and store output
+   if (restart == 2)
+      nomadm_functions('SaveCache');
+      set(GUI.axesHistory, 'NextPlot','replacechildren');
+      Options.loadCache   = 1;
+      Options.countCache = 1;
+      Options.delta0 = RunSet(GUI.RunCount).RunStats.delta;
+      Options.plotColor = GUI.Types.PlotColors{GUI.RunCount};
+      set(GUI.RunStatus,'String', ...
+                       ['Resuming Run # ', int2str(GUI.RunCount)]);
+      RunStats = RunSet(GUI.RunCount).RunStats;
+      [BestF,BestI,RunStats,RunSet(1).Cache] = mads(Problem,iterate0, ...
+                                                    Options,RunStats);
+      delete(fullfile(GUI.Path,Problem.File.C));
+      set([GUI.CacheMenuLoad; GUI.CacheMenuCount; GUI.CacheMenuDelete], ...
+          'Enable','off');
+   else
+      set(GUI.RunStatus,'String', ...
+                       ['Run # ', int2str(GUI.RunCount+1), ' processing']);
+      [BestF,BestI,RunStats,RunSet(1).Cache] = mads(Problem,iterate0, ...
+                                                    Options);
+      GUI.RunCount = GUI.RunCount+1;
+   end
+   RunSet(GUI.RunCount).BestF    = BestF;
+   RunSet(GUI.RunCount).BestI    = BestI;
+   RunSet(GUI.RunCount).RunStats = RunStats;
+   if (RunStats.time > 60)
+      load train;
+      sound(y);
+   end
+
+% Perform these tasks if error in MADS run
+catch
+   set(GUI.RunStatus,'String', ...
+                    ['Run # ', int2str(GUI.RunCount+1), ' failed']);
+   set([GUI.axesFilter; get(GUI.axesFilter, 'Children')],'Visible','off');
+   if (GUI.RunCount == 0)
+      set([GUI.axesHistory; get(GUI.axesHistory,'Children')],'Visible', ...
+                                                             'off');
+   else
+      set(GUI.axesHistory,'ButtonDownFcn', ...
+                          'nomadm_functions(''CopyPlot'');');
+   end
+   RunSet(1).Cache = [];
+   errordlg(lasterr,'MADS Runtime Error','modal'); beep
+   error(lasterr);
+end
+
+% Change figure window, as appropriate
+set(GUI.axesHistory, 'NextPlot','add');
+set(GUI.axesHistory, 'ButtonDownFcn','nomadm_functions(''CopyPlot'');');
+set(GUI.axesFilter,  'ButtonDownFcn','nomadm_functions(''CopyPlot'');');
+
+if (GUI.RunCount > 0)
+   set([GUI.CacheMenuSave;GUI.RunMenuResume;GUI.RunMenuRestart],...
+       'Enable','on');
+   set([GUI.ResultsMenu; GUI.ResultsMenuView(GUI.RunCount)], ...
+       'Visible','on');
+   set(GUI.RunStatus,'String', ...
+                    ['Run # ', int2str(GUI.RunCount), ' complete']);
+end
+set(GUI.StopRun,   'Visible','off','UserData',0);
+set(GUI.ResumeRun, 'Visible','on');
+setptr(GUI.fig,'arrow');
+setappdata(0,'RUNSET',RunSet);
+
+return
+
+%**************************************************************************
+% loadMADS:  Assign GUI input fields to MADS variables and run MADS
+% -------------------------------------------------------------------------
+% Called by: nomadm_functions('SaveSession'), runMADS
+% Calls:     nomadm_compile
+% VARIABLES:
+%  Problem             = structure containing optimization problem data
+%    .File             =   structure of problem file names
+%      .F              =   name of functions file
+%      .O              =   name of Omega file
+%      .I              =   name of initial points file
+%      .N              =   name of discrete neighbors file
+%      .C              =   name of Cache File
+%      .CacheName      =   name of the base workspace Cache variable
+%      .FType          =   type of functions file (M=MATLAB,F=FORTRAN,C=C)
+%  Options             = structure containing MADS parameters
+%    .dacePath         =   path of the DACE Toolbox software
+%    .nSearches        =   number of Search types used
+%    .Search(n)        =   structure of Search parameters
+%      .type           =     string identifying the type of Search
+%    .PollStrategy     =   string identifying selected Poll strategy
+%    .PollOrder        =   string identifying selected Poll order strategy
+%    .PollCenter       =   integer identifying selected Poll center
+%    .PollComplete     =   turns on/off complete Polling
+%    .loadCache        =   flag for loading a pre-existing Cache file
+%    .countCache       =   flag for counting Cache points as function calls
+%    .useFilter        =   use filter for nonlinear constraints
+%    .removeRedundancy =   remove redundant linear constraints
+%    .accelerate       =   flag for accelerating mesh refinement
+%    .scale            =   flag for scaling mesh directions
+%    .plotHistory1     =   turns on/off a history plot
+%    .plotHistory2     =   turns on/off a real-time history plot
+%    .plotFilter       =   turns on/off a real-time filter plot
+%    .RunOneIteration  =   flag for running one MADS iteration at a time
+%    .RunUntilFeasible =   flag for running MADS only until feasible
+%    .TermRel          =   computes termination delta relative to .delta0
+%    .RunCount         =   MADS run counter
+%    .hplothandle      =   handle for history plot axes
+%    .fplothandle      =   handle for filter plot axes
+%    .stophandle       =   handle for Stop Run pushbutton
+%    .delta0           =   initial mesh size
+%    .deltaMax         =   maximum mesh size
+%    .meshRefine       =   mesh refinement factor
+%    .meshCoarsen      =   mesh coarsening factor
+%    .CacheTol         =   tolerance for flagging point as being in Cache
+%    .hmin             =   minimum h-value of an infeasible point
+%    .hmax             =   maximum h-value of a filter point
+%    .EPollTriggerF    =   f-value Extended Poll trigger
+%    .EPollTriggerH    =   h-value Extended Poll trigger
+%    .Term             =   substructure containing MADS termination criteria
+%      .delta          =     mesh size parameter
+%      .iter           =     maximum number of MADS iterations
+%      .func           =     maximum number of function evaluations
+%      .time           =     maximum CPU time
+%      .fails          =     maximum number of consecutive Poll failures
+%    .TermIterFlag     =   turns on/off .iter as termination criteria
+%    .TermFuncFlag     =   turns on/off .func as termination criteria
+%    .TermTimeFlag     =   turns on/off .time as termination criteria
+%    .TermFailsFlag    =   turns on/off .fails as termination criteria
+%  restart             = flag for resuming previous run
+%  GUI                 = structure containing all GUI handles and variables
+%    .Path             =   path of current optimization problem
+%    .ProblemExt       =   filename extension of optimization problem 
+%    .ProblemName      =   name of current optimization problem
+%    .RunStatus        =   handle for GUI figure window status bar
+%    .CacheMenuXXX     =   handles for Cache menu items
+%    .MADSMenuXXX      =   handles for MADS menu items
+%    .OptionsMenuXXX   =   handles for Options menu items
+%    .RunMenuXXX       =   handles for Run menu items
+%    .Options          =   current Options values
+%    .Types            = lists of possible type
+%      .Search         =   list of possible Search types
+%      .Poll           =   list of possible Poll strategies
+%      .PollOrder      =   list of possible Poll order strategies
+%    .Choice           = user choices
+%      .pollStrategy   =   selected Poll strategy
+%      .pollCenter     =   selected Poll center
+%      .pollOrder      =   selected Poll order strategy
+%                          (These are all handles for GUI window objects)
+%    .delta0           =   current initial mesh size
+%    .deltaMax         =   current maximum mesh size
+%    .meshRefine       =   current mesh refinement factor
+%    .meshCoarsen      =   current mesh coarsening factor
+%    .CacheTol         =   current Cache tolerance
+%    .hmin             =   current minimum infeasible h-value
+%    .hmax             =   current maximum filter h-value
+%    .EPollXiF         =   current f-value Extended Poll trigger
+%    .EPollXiH         =   current h-value Extended Poll trigger
+%    .TermDelta        =   current mesh size termination criteria
+%    .TermIter         =   current maximum number of MADS iterations
+%    .TermFunc         =   current maximum number of function evaluations
+%    .TermTime         =   current maximum CPU time
+%    .TermFails        =   current max number of consec Poll failures
+%    .TermIterFlag     =   current checkbox value for .TermIter
+%    .TermFuncFlag     =   current checkbox value for .TermFunc
+%    .TermTimeFlag     =   current checkbox value for .TermTime
+%    .TermFailsFlag    =   current checkbox value for .TermFails
+%  ProblemName         = name of the optimization problem to be solved
+%  language            = programming language of functions file
+%  k                   = Search counter
+%**************************************************************************
+function [Problem,Options] = loadMADS(restart,GUI);
+
+% Transfer Optimization Problem data from GUI into MADS input variables
+addpath(GUI.Path);
+ProblemName    = get(GUI.ProblemName, 'String');
+%Problem.File  = [ProblemName, GUI.FileExt];
+Problem.File.F = [ProblemName, GUI.FileExt.F];
+Problem.File.O = [ProblemName, GUI.FileExt.O];
+Problem.File.I = [ProblemName, GUI.FileExt.I];
+Problem.File.N = [ProblemName, GUI.FileExt.N];
+Problem.File.P = [ProblemName, GUI.FileExt.P];
+Problem.File.C = [ProblemName, GUI.FileExt.C];
+Problem.CacheName = GUI.CacheName;
+
+% Compile non-Matlab Functions file, if possible
+Problem.FType  = upper(GUI.ProblemExt(2));
+if ~strcmp(Problem.FType,'M')
+   language = nomadm_compile(Problem.FType, ...
+                             GUI.Path,Problem.File.F,GUI.ProblemExt);
+   set(GUI.RunStatus,'String',['Compiling ',language,' function file']);
+end
+
+% Transfer user options from GUI into MADS input variables
+umtoggle(GUI.ScaleMenu(2));
+umtoggle(GUI.ScaleMenu(3));
+umtoggle(GUI.CacheMenuLoad);
+umtoggle(GUI.CacheMenuCount);
+umtoggle(GUI.MADSMenuPollComplete);
+umtoggle(GUI.OptionsMenuUseFilter);
+umtoggle(GUI.OptionsMenuRemoveRedundancy);
+umtoggle(GUI.OptionsMenuAccelerate);
+umtoggle(GUI.OptionsMenuPlotFilter);
+umtoggle(GUI.OptionsMenuPlotHistory1);
+umtoggle(GUI.OptionsMenuPlotHistory2);
+umtoggle(GUI.RunMenuExecFeasible);
+umtoggle(GUI.RunMenuOneIteration);
+umtoggle(GUI.OptionsMenuTermRel);
+
+Options = GUI.Options;
+Options.dacePath = GUI.dacePath;
+Options.Search(Options.nSearches+1:end) = [];
+for k = 1:Options.nSearches
+   Options.Search(k).type = GUI.Types.Search{GUI.Choice.search(k)};
+end
+Options.PollStrategy     = GUI.Types.Poll{GUI.Choice.pollStrategy};
+Options.PollOrder        = GUI.Types.PollOrder{GUI.Choice.pollOrder};
+Options.PollCenter       = GUI.Choice.pollCenter - 1;
+Options.PollComplete     = umtoggle(GUI.MADSMenuPollComplete);
+Options.loadCache        = umtoggle(GUI.CacheMenuLoad);
+Options.countCache       = umtoggle(GUI.CacheMenuCount);
+Options.useFilter        = umtoggle(GUI.OptionsMenuUseFilter);
+Options.removeRedundancy = umtoggle(GUI.OptionsMenuRemoveRedundancy);
+Options.accelerate       = umtoggle(GUI.OptionsMenuAccelerate);
+Options.scale            =  2*umtoggle(GUI.ScaleMenu(2)) + ...
+                           10*umtoggle(GUI.ScaleMenu(3));
+Options.plotFilter       = umtoggle(GUI.OptionsMenuPlotFilter);
+Options.plotHistory1     = umtoggle(GUI.OptionsMenuPlotHistory1);
+Options.plotHistory2     = umtoggle(GUI.OptionsMenuPlotHistory2);
+Options.RunOneIteration  = umtoggle(GUI.RunMenuOneIteration);
+Options.RunUntilFeasible = umtoggle(GUI.RunMenuExecFeasible);
+Options.TermRel          = umtoggle(GUI.OptionsMenuTermRel);
+Options.plotColor        = GUI.Types.PlotColors{GUI.RunCount+1};
+Options.hplothandle      = GUI.axesHistory;
+Options.fplothandle      = GUI.axesFilter;
+Options.stophandle       = GUI.StopRun;
+Options.delta0           = str2double(get(GUI.delta0,      'String'));
+Options.deltaMax         = str2double(get(GUI.deltaMax,    'String'));
+Options.meshRefine       = str2double(get(GUI.MeshRefine,  'String'));
+Options.meshCoarsen      = str2double(get(GUI.MeshCoarsen, 'String'));
+Options.CacheTol         = str2double(get(GUI.CacheTol,    'String'));
+Options.hmin             = str2double(get(GUI.hmin,        'String'));
+Options.hmax             = str2double(get(GUI.hmax,        'String'));
+Options.EPollTriggerF    = str2double(get(GUI.EPollXiF,    'String'));
+Options.EPollTriggerH    = str2double(get(GUI.EPollXiH,    'String'));
+Options.Term.delta       = str2double(get(GUI.TermDelta,   'String'));
+Options.Term.iter        = str2double(get(GUI.TermIter,    'String'));
+Options.Term.func        = str2double(get(GUI.TermFunc,    'String'));
+Options.Term.time        = str2double(get(GUI.TermTime,    'String'));
+Options.Term.fails       = str2double(get(GUI.TermFails,   'String'));
+Options.TermIterFlag     = get(GUI.TermIterFlag,  'Value');
+Options.TermFuncFlag     = get(GUI.TermFuncFlag,  'Value');
+Options.TermTimeFlag     = get(GUI.TermTimeFlag,  'Value');
+Options.TermFailsFlag    = get(GUI.TermFailsFlag, 'Value');
+if (~Options.TermIterFlag),  Options.Term.iter  = Inf; end
+if (~Options.TermFuncFlag),  Options.Term.func  = Inf; end
+if (~Options.TermTimeFlag),  Options.Term.time  = Inf; end
+if (~Options.TermFailsFlag), Options.Term.fails = Inf; end
+if (Options.TermRel)
+   Options.Term.delta = Options.Term.delta*Options.delta0;
+end
+return
+
+%**************************************************************************
+% searchOptions:  Displays a user input screen to set Search parameters.
+% -------------------------------------------------------------------------
+% Called by: nomadm_functions
+% VARIABLES:
+%  n                 = number of Search types to be used during MADS run
+%  optimizer         = string identifying the surrogate optimizer
+%  GUI               = structure containing all GUI handles and variables
+%    .figSearch      = handle for Search figure window
+%    .maxSearches    = maximum number of Search types that can be selected
+%    .SearchScreen   = structure of handles for each k of n Searches
+%      .type         =   handle for popupmenu of possible Search types
+%      .nIter        =   handle for number of iterations field
+%      .nPoints      =   handle for number of Search points field
+%      .file         =   handle for string containing name of Search file
+%    .Labels.Search  = long text labels used in Search type popup menus
+%    .Choice.Search  = integers recording Search type popup menu choices
+%    .Options.Search = vector of structures for each k of n Searches
+%      .nIter        =   number of iterations
+%      .nPoints      =   number of Search points
+%      .file         =   string containing name of optional Search file
+%    .SubsFile       =   name of file that controls GUI callback functions
+%  k                 = Search type counter
+%  row               = row location of current Search figure window object
+%  visible           = flag for making unused Searches invisible
+%  PathStr           = temporary storage for Search file path
+%  FileName          = temporary storage for Search filename
+%  FileExt           = temporary storage for Search filename extension
+%**************************************************************************
+function searchOptions(n, optimizer);
+
+global GUI
+
+%Set up "Search Options" figure window
+GUI.figSearch = figure(...
+   'Name', 'Set Options for MADS SEARCH step', ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.375, ...,
+   'DefaultUIControlBackgroundColor', [.8 .8 .8], ...
+   'DefaultUIControlStyle',           'text', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.15 0.1 0.8 0.7], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+
+% Figure window shading to make it appear recessed
+uicontrol(GUI.figSearch, 'Style','frame','Position', [0, 0, 1, .004],   ...
+    'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figSearch, 'Style','frame','Position', [.997, 0 .003, 1], ...
+    'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figSearch, 'Style','frame','Position', [0, .996, 1, .004],...
+    'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(GUI.figSearch, 'Style','frame','Position', [0, 0, .003, 1],   ...
+    'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+
+% Additional figure window partitioning lines
+uicontrol(GUI.figSearch, 'Style','frame','Position', [0, .896, 1, .004],...
+    'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(GUI.figSearch, 'Style','frame','Position', [0, .9,   1, .004],...
+    'ForegroundColor','white','BackgroundColor','white');
+
+% Display Number of Search Types and Surrogate Optimizer
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', 'Number of Search Types: ', ...
+    'Position', [.13 .905 .20 .06]);
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', int2str(n), ...
+    'Position', [.35 .905 .05 .06]);
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', 'Surrogate Optimizer: ', ...
+    'Position', [.53 .905 .15 .06]);
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', optimizer, ...
+    'Position', [.75 .905 .10 .06]);
+
+% Text headers for the Search parameters
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', 'Search Strategy', ...
+    'Position', [.12 .80 .31 .06]);
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', 'Number of Iterations', ...
+    'Position', [.45 .80 .15 .06]);
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', 'Number of Points', ...
+    'Position', [.62 .80 .16 .06]);
+uicontrol(GUI.figSearch, 'Style', 'text', ...
+    'String', 'User File', ...
+    'Position', [.80 .80 .16 .06]);
+
+% Main loop for each of n Searches
+for k = 1:GUI.maxSearches
+   if (k <= n)
+      row = .76 - .08*(k-1);
+      visible = 'on';
+   else
+      visible = 'off';
+   end
+
+   uicontrol(GUI.figSearch, ...
+      'Style',           'text', ...
+      'String',          ['Search #', int2str(k), ':'], ...
+      'Visible',         visible, ...      
+      'Position',        [.03, row-.0075, .08, .06]);
+
+   % The data fields for each Search
+   GUI.SearchScreen(k).type = uicontrol(GUI.figSearch, ...
+      'Style',           'popupmenu', ...
+      'String',          GUI.Labels.Search, ...
+      'Visible',         visible, ...
+      'BackgroundColor', 'white', ...
+      'Value',           GUI.Choice.search(k), ...
+      'Position',        [.12, row, .31, .06], ...
+      'UserData',        k, ...
+      'Callback',        [GUI.SubsFile '(''LoadUserSearchFile'');']);
+   GUI.SearchScreen(k).nIter = uicontrol(GUI.figSearch, ...
+      'Style',           'edit', ...
+      'String',          int2str(GUI.Options.Search(k).nIter), ...
+      'Visible',         visible, ...
+      'BackgroundColor', 'white', ...
+      'FontSize',        .64, ...
+      'Position',        [.45, row+.02, .15, .04]);
+   GUI.SearchScreen(k).nPoints = uicontrol(GUI.figSearch, ...
+      'Style',           'edit', ...
+      'String',          int2str(GUI.Options.Search(k).nPoints), ...
+      'Visible',         visible, ...
+      'BackgroundColor', 'white', ...
+      'FontSize',        .64, ...
+      'Position',        [.62, row+.02, .16, .04]);
+   [PathStr,FileName,FileExt] = fileparts(GUI.Options.Search(k).file);
+   GUI.SearchScreen(k).file = uicontrol(GUI.figSearch, ...
+      'Style',           'text', ...
+      'String',          [FileName,FileExt], ...
+      'Visible',         visible, ...
+      'ForegroundColor', 'red', ...
+      'Position',        [.80, row, .16, .06], ...
+      'UserData',        PathStr);
+
+   % Set defaults for unseen Searches
+  if (k > n)
+     set(GUI.SearchScreen(k).type,    'String','None');
+     set(GUI.SearchScreen(k).nIter,   'String','1');
+     set(GUI.SearchScreen(k).nPoints, 'String','1');
+     set(GUI.SearchScreen(k).file,    'String','');
+  end
+end
+
+% The Done and Cancel Buttons
+uicontrol(GUI.figSearch, ...
+   'Style',      'pushbutton', ...
+   'String',     'Done', ...
+   'FontWeight', 'bold', ...
+   'Position',   [.33, row-.16, .10, .08], ...
+   'UserData',   1, ...
+   'Callback',   [GUI.SubsFile '(''LoadSearchOptions'');']);
+uicontrol(GUI.figSearch, ...
+   'Style',      'pushbutton', ...
+   'String',     'Cancel', ...
+   'FontWeight', 'bold', ...
+   'Position',   [.50, row-.16, .10, .08], ...
+   'UserData',   0, ...
+   'Callback',   [GUI.SubsFile '(''LoadSearchOptions'');']);
+
+return
+
+%**************************************************************************
+% daceOptions:  Displays a user input screen to set DACE Toolbox parameters.
+% -------------------------------------------------------------------------
+% Called by: nomadm_functions
+% VARIABLES:
+%  k                         = Search number for this DACE screen
+%  GUI                       = global variable holding all GUI variables
+%    .SubsFile               =   name of GUI callback functions file
+%    .figDACE                =   handle for DACE figure window
+%    .Labels                 =   labels for DACE function popup menus
+%      .daceRegression       =     labels for DACE regression functions
+%      .daceCorrelation      =     labels for DACE correlation functions
+%    .Choice                 =   integer choices for DACE functions
+%      .daceReg              =     choice for DACE regression function
+%      .daceCorr             =     choice for DACE correlation function
+%    .daceOptionsRegression  =   popup menu of regression functions
+%    .daceOptionsCorrelation =   popup menu of correlation functions
+%    .daceOptionsTheta       =   field for estimating correlation parameter
+%    .daceOptionsLower       =   filed for entering lower bound for theta
+%    .daceOptionsUpper       =   field for entering upper bound for theta
+%    .daceOptionsIsotropic   =   checkbox for isotropic correlations
+%  Options                   = structure of MADS options
+%    .dace                   =   user-chosen DACE Toolbox parameters
+%      .theta                =   estimate for theta
+%      .lower                =   lower bound for theta
+%      .upper                =   upper bound for theta
+%      .isotropic            =   flag for isotropic theta
+%**************************************************************************
+function daceOptions(k);
+
+global GUI
+
+% Set up "DACE Options" figure window
+GUI.figDACE = figure(...
+   'Name', ['DACE Toolbox Options (Search #', int2str(k),')'], ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.5, ...,
+   'DefaultUIControlBackgroundColor', [.8 .8 .8], ...
+   'DefaultUIControlStyle',           'text', ...
+   'WindowStyle',                     'modal', ...
+   'Resize',                          'on', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.25 0.35 0.40 0.35], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+
+% Figure window shading to make it appear recessed
+uicontrol(GUI.figDACE, 'Style','frame','Position', [0, 0, 1, .004],    ...
+          'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figDACE, 'Style','frame','Position', [.997, 0, .003, 1], ...
+          'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figDACE, 'Style','frame','Position', [0, .996, 1, .004], ...
+          'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(GUI.figDACE, 'Style','frame','Position', [0, 0, .003, 1],    ...
+          'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+
+% Labels for DACE screen objects and data fields
+uicontrol(GUI.figDACE, ...
+      'Style',               'text', ...
+      'String',              'Regression Model: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .855 .34 .09]);
+GUI.daceOptionsReg         = uicontrol(GUI.figDACE, ...
+      'Style',               'popupmenu', ...
+      'String',              GUI.Labels.daceRegression, ...
+      'BackgroundColor',     'white', ...
+      'Value',               GUI.Choice.daceReg(k), ...
+      'Position',            [.37 .85 .60 .11]);
+
+uicontrol(GUI.figDACE, ...
+      'Style',               'text', ...
+      'String',              'Correlation Model: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .725 .34 .09]);
+GUI.daceOptionsCorr        = uicontrol(GUI.figDACE, ...
+      'Style',               'popupmenu', ...
+      'String',              GUI.Labels.daceCorrelation, ...
+      'BackgroundColor',     'white', ...
+      'Value',               GUI.Choice.daceCorr(k), ...
+      'Position',            [.37 .72 .60 .11]);
+
+uicontrol(GUI.figDACE, ...
+      'Style',               'text', ...
+      'String',              'Theta: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .595 .34 .09]);
+GUI.daceOptionsTheta       = uicontrol(GUI.figDACE, ...
+      'Style',               'edit', ...
+      'String',              num2str(GUI.Options.dace(k).Theta), ...
+      'FontSize',            .6, ...
+      'BackgroundColor',     'white', ...
+      'Position',            [.37 .61 .35 .09]);
+
+uicontrol(GUI.figDACE, ...
+      'Style',               'text', ...
+      'String',              'Lower: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .465 .34 .09]);
+GUI.daceOptionsLower       = uicontrol(GUI.figDACE, ...
+      'Style',               'edit', ...
+      'String',              num2str(GUI.Options.dace(k).Lower), ...
+      'BackgroundColor',     'white', ...
+      'FontSize',            .6, ...
+      'Position',            [.37 .48 .35 .09]);
+
+uicontrol(GUI.figDACE, ...
+      'Style',               'text', ...
+      'String',              'Upper: ', ...
+      'HorizontalAlignment', 'right', ...
+      'FontSize',            .6, ...
+      'Position',            [.02 .335 .34 .09]);
+GUI.daceOptionsUpper       = uicontrol(GUI.figDACE, ...
+      'Style',               'edit', ...
+      'String',              num2str(GUI.Options.dace(k).Upper), ...
+      'BackgroundColor',     'white', ...
+      'FontSize',            .6, ...
+      'Position',            [.37 .35 .35 .09]);
+
+GUI.daceOptionsIsotropic   = uicontrol(GUI.figDACE, ...
+      'Style',               'checkbox',  ...
+      'String',              'Isotropic', ...
+      'Value',               GUI.Options.dace(k).Isotropic,   ...
+      'Position',            [.37 .23 .35 .11]);
+  
+% The Done and Cancel Buttons
+uicontrol(GUI.figDACE, ...
+   'Style',      'pushbutton', ...
+   'String',     'Done', ...
+   'FontWeight', 'bold', ...
+   'Position',   [.27, .05, .20, .14], ...
+   'UserData',   k, ...
+   'Callback',   [GUI.SubsFile '(''LoadDACEOptions'');']);
+uicontrol(GUI.figDACE, ...
+   'Style',      'pushbutton', ...
+   'String',     'Cancel', ...
+   'FontWeight', 'bold', ...
+   'Position',   [.54, .05, .20, .14], ...
+   'UserData',   0, ...
+   'Callback',   [GUI.SubsFile '(''LoadDACEOptions'');']);
+
+return
+
+%**************************************************************************
+% viewResults:  Displays Results from MADS run.
+% -------------------------------------------------------------------------
+% Called by: nomadm_functions
+% VARIABLES:
+%  k              = run number
+%  GUI            = structure containing handles for the user interface
+%    .SubsFile    =   name of GUI callback functions file
+%    .figResults  =   parent handle for the MADS Results screen
+%    .BestFFValue =   display of BFP objective function value
+%    .BestFHValue =   display of BFP constraint violation function value
+%    .ViewFXOpt   =   pushbutton for viewing BFP continuous variables
+%    .ViewFPOpt   =   pushbutton for viewing BFP categorical variables
+%    .BestIFValue =   display of LIP objective function value
+%    .BestIHValue =   display of LIP constraint violation function value
+%    .ViewIXOpt   =   pushbutton for viewing LIP continuous variables
+%    .ViewIPOpt   =   pushbutton for viewing LIP categorical variables
+%    .RunDelta    =   display of final mesh size
+%    .RunIter     =   display of number of iterations
+%    .RunFunc     =   display of number of function evaluations
+%    .RunGrad     =   display of number of gradient evaluations
+%    .RunTime     =   display of CPU time expended
+%    .RunFails    =   display of number of consecutive Poll failures
+%    .RunStop     =   display of whether or not run was interrupted by user
+%    .RunCHits    =   display of number of Cache hits
+%    .TermDelta   =   display of mesh size termination criteria
+%    .TermIter    =   display of maximum number of MADS iterations
+%    .TermFunc    =   display of maximum number of function evaluations
+%    .TermTime    =   display of maximum CPU time
+%    .TermFails   =   display of max number of consecutive Poll failures
+%  RunSet         = structure containing all information about a MADS run
+%    .BestF       =   best feasible iterate for Run k
+%    .BestI       =   least infeasible iterate for Run k
+%    .RunStats    =   MADS Run k statistics (iterations, CPU time, etc.)
+%      .delta     =     final mesh size
+%      .iter      =     total number of iterations
+%      .func      =     total number of function evaluations
+%      .time      =     total CPU time expended
+%      .fails     =     final number of consecutive Poll failures
+%      .stopRun   =     final value of Stop Run button
+%      .CacheHits =     total number of Cache hits
+%  digits         = number of digits accuracy to present on screen
+%  NoYes          = cell array containing the strings "No" and "Yes"
+%  figName        = title of the MADS Results screen
+%**************************************************************************
+function viewResults(k, GUI);
+
+RunSet = getappdata(0,'RUNSET');
+digits = 10;
+NoYes = {'No','Yes'};
+figName = ['MADS Results for Problem: ', ...
+          get(GUI.ProblemName,'String'), ', Run #' int2str(k)];
+
+% Set up "Display Results" figure window
+GUI.figResults = figure( ...
+   'Name',                           figName, ...
+   'DefaultUIControlUnits',          'normalized', ...
+   'DefaultUIControlFontUnits',      'normalized', ...
+   'DefaultUIControlFontName',       'Helvetica',  ...
+   'DefaultUIControlFontSize',        0.375, ...,
+   'DefaultUIControlBackgroundColor', [.8 .8 .8], ...
+   'DefaultUIControlStyle',           'text', ...
+   'Units',                           'normalized', ...
+   'Position',                        [0.1 0.15 0.8 0.7], ...
+   'MenuBar',                         'none', ...
+   'NumberTitle',                     'off');
+
+% Figure window shading to make it appear recessed
+uicontrol(GUI.figResults, 'Style','frame','Position', [0, 0, 1, .004], ...
+   'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figResults, 'Style','frame','Position', [.997, 0, .003, 1],...
+   'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figResults, 'Style','frame','Position', [0, .996, 1, .004],...
+   'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(GUI.figResults, 'Style','frame','Position', [0, 0, .003, 1], ...
+   'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+
+uicontrol(GUI.figResults, 'Style','frame','Position', [0, .536, 1, .004],...
+   'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(GUI.figResults, 'Style','frame','Position', [0, .54, 1, .004],...
+   'ForegroundColor','white','BackgroundColor','white');
+uicontrol(GUI.figResults, 'Style','frame','Position', [.5, .54, .003, .46], ...
+   'ForegroundColor',[.4 .4 .4],'BackgroundColor',[.4 .4 .4]);
+uicontrol(GUI.figResults, 'Style','frame','Position', [.497, .54, .003, .46], ...
+   'ForegroundColor','white','BackgroundColor','white');
+
+% Set up display of Best Feasible Solution
+uicontrol(GUI.figResults, 'String','BEST FEASIBLE SOLUTION', ...
+   'FontWeight','bold', ...
+   'HorizontalAlignment','center','Position',[.02 .86 .46 .10]);
+
+if (isempty(RunSet(k).BestF))
+   uicontrol(GUI.figResults, 'String','NO FEASIBLE ITERATES FOUND', ...
+      'HorizontalAlignment','center','Position',[.02 .77 .46 .08]);
+else
+   uicontrol(GUI.figResults, 'String','Objective Function Value: ', ...
+      'HorizontalAlignment','left',  'Position',[.02 .80 .28 .08]);
+   uicontrol(GUI.figResults, 'String','Constraint Violation Measure: ', ...
+      'HorizontalAlignment','left',  'Position',[.02 .74 .28 .08]);
+   GUI.BestFFValue = uicontrol(GUI.figResults, ...
+      'String',num2str(RunSet(k).BestF.f,digits), ...
+      'HorizontalAlignment','right', 'Position',[.30 .80 .18 .08]);
+   GUI.BestFHValue = uicontrol(GUI.figResults, ...
+      'String',num2str(RunSet(k).BestF.h,digits), ...
+      'HorizontalAlignment','right', 'Position',[.30 .74 .18 .08]);
+   GUI.ViewFXOpt = uicontrol(GUI.figResults, ...
+      'Style',               'pushbutton', ...
+      'String',              'View Continuous Variables', ...
+      'FontWeight',          'bold', ...
+      'HorizontalAlignment', 'center', ...
+      'Position',            [.02 .66 .46 .08], ...
+      'UserData',            RunSet(k).BestF.x, ...
+      'Callback',            'nomadm_functions(''BestX'');');
+   if (~isempty(RunSet(k).BestF.p))
+      GUI.ViewFPOpt = uicontrol(GUI.figResults, ...
+         'Style',               'pushbutton', ...
+         'String',              'View Categorical Variables', ...
+         'FontWeight',          'bold', ...
+         'HorizontalAlignment', 'center', ...
+         'Position',            [.02 .58 .46 .08], ...
+         'UserData',            RunSet(k).BestF.p, ...
+         'Callback',            'nomadm_functions(''BestP'');');
+   end
+end
+
+% Set up display of Least Infeasible Solution
+uicontrol(GUI.figResults, 'String','LEAST INFEASIBLE SOLUTION', ...
+   'FontWeight','bold', ...
+   'HorizontalAlignment','center','Position',[.52 .86 .46 .10]);
+
+if (isempty(RunSet(k).BestI))
+   uicontrol(GUI.figResults, 'String','NO INFEASIBLE ITERATES FOUND ', ...
+      'HorizontalAlignment','center','Position',[.52 .77 .46 .08]);
+else
+   uicontrol(GUI.figResults, 'String','Objective Function Value: ', ...
+      'HorizontalAlignment','left',  'Position',[.52 .80 .28 .08]);
+   uicontrol(GUI.figResults, 'String','Constraint Violation Measure: ', ...
+      'HorizontalAlignment','left',  'Position',[.52 .74 .28 .08]);
+   GUI.BestIFValue = uicontrol(GUI.figResults, ...
+      'String',num2str(RunSet(k).BestI.f,digits), ...
+      'HorizontalAlignment','right', 'Position',[.80 .80 .18 .08]);
+   GUI.BestIHValue = uicontrol(GUI.figResults, ...
+      'String',num2str(RunSet(k).BestI.h,digits), ...
+      'HorizontalAlignment','right', 'Position',[.80 .74 .18 .08]);
+
+% Set up pushbuttons for viewing solution vectors
+   GUI.ViewIXOpt = uicontrol(GUI.figResults, ...
+      'Style',               'pushbutton', ...
+      'String',              'View Continuous Variables', ...
+      'FontWeight',          'bold', ...
+      'HorizontalAlignment', 'center', ...
+      'Position',            [.52 .66 .46 .08], ...
+      'UserData',            RunSet(k).BestI.x, ...
+      'Callback',            'nomadm_functions(''BestX'');');
+   if (~isempty(RunSet(k).BestI.p))
+      GUI.ViewIPOpt = uicontrol(GUI.figResults, ...
+         'Style',               'pushbutton', ...
+         'String',              'View Categorical Variables', ...
+         'FontWeight',          'bold', ...
+         'HorizontalAlignment', 'center', ...
+         'Position',            [.52 .58 .46 .08], ...
+         'UserData',            RunSet(k).BestI.p, ...
+         'Callback',            'nomadm_functions(''BestP'');');
+   end
+end
+
+% Display Labels for MADS Run Statistics
+uicontrol(GUI.figResults, 'String','RUN STATISTICS', ...
+   'FontWeight','bold', ...
+   'HorizontalAlignment','center','Position',[.30 .42 .40 .10]);
+uicontrol(GUI.figResults, 'String','Final Mesh Size:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .36 .25 .08]);
+uicontrol(GUI.figResults, 'String','MADS Iterations:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .31 .25 .08]);
+uicontrol(GUI.figResults, 'String','Function Evaluations:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .26 .25 .08]);
+uicontrol(GUI.figResults, 'String','Gradient Evaluations:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .21 .25 .08]);
+uicontrol(GUI.figResults, 'String','CPU Time:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .16 .25 .08]);
+uicontrol(GUI.figResults, 'String','Consecutive Poll Failures:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .11 .25 .08]);
+uicontrol(GUI.figResults, 'String','Interrupted by User:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .06 .25 .08]);
+uicontrol(GUI.figResults, 'String','Cache Hits:', ...
+   'HorizontalAlignment','left',  'Position',[.25 .01 .25 .08]);
+
+% Display MADS Run Statistics (Compare with termination criteria)
+GUI.RunDelta = uicontrol(GUI.figResults, ...
+   'String',num2str(RunSet(k).RunStats.delta,digits), ...
+   'HorizontalAlignment','right',  'Position',[.50 .36 .20 .08]);
+GUI.RunIter  = uicontrol(GUI.figResults, ...
+   'String',int2str(RunSet(k).RunStats.iter), ...
+   'HorizontalAlignment','right',  'Position',[.50 .31 .20 .08]);
+GUI.RunFunc  = uicontrol(GUI.figResults, ...
+   'String',int2str(RunSet(k).RunStats.func), ...
+   'HorizontalAlignment','right',  'Position',[.50 .26 .20 .08]);
+GUI.RunGrad  = uicontrol(GUI.figResults, ...
+   'String',int2str(RunSet(k).RunStats.grad), ...
+   'HorizontalAlignment','right',  'Position',[.50 .21 .20 .08]);
+GUI.RunTime  = uicontrol(GUI.figResults, ...
+   'String',num2str(RunSet(k).RunStats.time), ...
+   'HorizontalAlignment','right',  'Position',[.50 .16 .20 .08]);
+GUI.RunFails = uicontrol(GUI.figResults, ...
+   'String',num2str(RunSet(k).RunStats.fails), ...
+   'HorizontalAlignment','right',  'Position',[.50 .11 .20 .08]);
+GUI.RunStop  = uicontrol(GUI.figResults, ...
+   'String',NoYes{1+RunSet(k).RunStats.stopRun}, ...
+   'HorizontalAlignment','right',  'Position',[.50 .06 .20 .08]);
+GUI.RunCHits = uicontrol(GUI.figResults, ...
+   'String',num2str(RunSet(k).RunStats.CacheHits), ...
+   'HorizontalAlignment','right',  'Position',[.50 .01 .20 .08]);
+
+% Change colors for violated Termination Criteria
+if (RunSet(k).RunStats.delta < str2num(get(GUI.TermDelta,'String')))
+   set(GUI.RunDelta,'FontWeight','bold','ForegroundColor','blue');
+end
+if (RunSet(k).RunStats.iter >= str2num(get(GUI.TermIter,'String')))
+   set(GUI.RunIter, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.func >= str2num(get(GUI.TermFunc,'String')))
+   set(GUI.RunFunc, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.time >= str2num(get(GUI.TermTime,'String')))
+   set(GUI.RunTime, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.fails >= str2num(get(GUI.TermFails,'String')))
+   set(GUI.RunFails, 'FontWeight','bold','ForegroundColor','red');
+end
+if (RunSet(k).RunStats.stopRun)
+   set(GUI.RunStop, 'FontWeight','bold','ForegroundColor','red');
+end
+return
diff --git a/Requirements/MEIGO/eSS/local_solvers/solnp/Original Web link.URL b/Requirements/MEIGO/eSS/local_solvers/solnp/Original Web link.URL
new file mode 100644
index 0000000000000000000000000000000000000000..ebc60b0c2e6518690dc7ef5425fa4b086abb3620
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/solnp/Original Web link.URL	
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=http://www.stanford.edu/~yyye/matlab/solnp.m
diff --git a/Requirements/MEIGO/eSS/local_solvers/solnp/solnp.m b/Requirements/MEIGO/eSS/local_solvers/solnp/solnp.m
new file mode 100644
index 0000000000000000000000000000000000000000..bb5a328e4557ecfd56cf3ea4c7113faacc115543
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/solnp/solnp.m
@@ -0,0 +1,652 @@
+function [p,jh,flag,ic,lambda,hess]=solnp(FUN,pb,ib,op,lambda,hess,...
+    iprint,fobj,scale,nconst,varargin)
+
+%The Function SOLNP solves nonlinear programs in standard form:
+%
+%        minimize              J(P)
+%        subject to            EC(P)  =0
+%                   IB(:,1)<=  IC(P)  <=IB(:,2)
+%                   PB(:,1)<=    P    <=PB(:,2).
+%where
+%
+%  J       : Cost objective scalar function
+%  EC      : Equality constraint vector function
+%  IC      : Inequality constraint vector function
+%  P       : Decision parameter vector
+%  IB, PB  : lower and upper bounds for IC and P.
+%
+%%% USAGE
+% [P,JH,FLAG,IC,LAMBDA,HESS]=SOLNP(FUN,PB,IB,OP,L,H,IPRINT,PAR1,PAR2,...)
+%  Output P       : optimal decision parameters
+%         JH      : optimization history (nfeval - function values)
+%         FLAG    : flag indicating whether SOLNP has converged.
+%         IC      : optimal values of inequality constraints
+%         LAMBDA  : optimal lagrangian multipliers
+%         HESSIAN : final estimate of the hessian
+%
+%  Input  FUN    : user-defined input function
+%                   [F]=FUN(P,IT)
+%                   F(1)        : cost objective function J value
+%                   F(2:NEC+NIC): constraint function values o
+%                   IT           : iteration number (used?)
+%                                >0 - major iteration
+%                                >0 - minor iteration
+%                                0 - any other call
+%
+%         PB = [P {PB}]
+%
+%            P   : any initial parameter within the parameter bound
+%            PB  : optional parameter bound
+%                  PB(:,1) is the lower bound for P, and
+%                  PB(:,2) is the upper bound for P.
+%
+%         IB = [{IC} IB] (optional)
+%
+%            IC  : (optional) best approximation values for inequality 
+%                  constraints (IC) within the bounds
+%            IB  : inequality constraint bound
+%                  IB(:,1) is the lower bound for IC, and
+%                  IB(:,2) is the upper bound for IC.
+%
+%         OP=[RHO,MAJIT,MINIT,MAXFN,DELTA,TOL] (all optional with defaults)
+%
+%           RHO  : penalty parameter (1)
+%           MAJIT: maximum number of major iterations (10)
+%           MINIT: maximum number of minor iterations (10)
+%           MAXFN: maximum number of funcion evaluations (500*no.variables)
+%           DELTA: relative step size in forward difference (1.e-5)
+%           TOL  : tolerance on feasibility and optimality (1.e-4)
+%
+%         IPRINT : flag for printing optimization process on screen
+%
+% Modified by Jose-Oscar H. Sendin
+% Process Engineering Group, IIM-CSIC
+% Latest update: August 23, 2006
+% -------------------------------------------------------------------------
+
+% check inputs --- JOHS
+if nargin < 2, error('Syntax error: SOLNP requires at least two input arguments!'); end
+if nargin < 7, iprint = 0;
+    if nargin < 6, hess = [];
+        if nargin < 5; lambda = [];
+            if nargin < 4, op = [];
+                if nargin < 3, ib = []; 
+                end, end, end, end, end
+
+om=['SOLNP--> ';'         '];
+
+% check bounds
+[np,n]=size(pb);  % np = number of parameters
+lpb=[1 0];
+% lpb(1) = refers to the presence of parameter bounds
+% lpb(2) = refers to constraints of either type
+if n==1, 
+    p=pb; pb=0; lpb(1)=0;
+elseif n==2, 
+    p=(pb(:,1)+pb(:,2))/2;
+elseif n==3, 
+    p=pb(:,1); pb=pb(:,2:3);
+else
+    error([om(1,:) 'Parameter array ''PB'' must have three columns or less']);
+end
+
+if lpb(1)==1,
+    if min(pb(:,2)-pb(:,1))<=0,
+        error([om(1,:) 'The lower bounds of the parameter constraints ';...
+                om(2,:) 'must be strictly less than the upper bounds.  ']);
+    elseif min([p-pb(:,1);pb(:,2)-p])<=0,
+        error([om(1,:) 'Initial parameter values must be within the bounds']);
+    end
+end
+% check constraints
+if isempty(ib) 
+    nic=0; % number of inequality constraints
+    ic=0;  
+else  
+    [nic, n]=size(ib);
+    if n==3,
+        ib0=ib(:,1);ib=ib(:,[2:3]);
+        if min([ib0-ib(:,1);ib(:,2)-ib0])<=0,
+            error([om(1,:) 'Initial inequalities must be within the bounds']);
+        end
+    elseif n==2,
+        if min(ib(:,2)-ib(:,1))<=0,
+            error([om(1,:) 'The lower bounds of the inequality constraints';...
+                   om(2,:) 'must be strictly less than the upper bounds.  ']);
+       end
+       ib0=(ib(:,1)+ib(:,2))/2;
+   elseif n==1,
+       ic=0; nic=0;
+   else
+       error([om(1,:) 'Inequality constraints must have 2 or 3 columns.']);
+   end
+   if nic>=1,
+       if lpb(1)==1,
+           pb=[ib; pb];
+       else
+           pb=ib;
+       end
+       p=[ib0; p]; % p contains the original variables + slack variables for
+                   % the inequalities
+   end
+end
+
+clear ib ib0
+if ( lpb(1)==1 | nic>0 ), lpb(2)=1; end
+
+% optimization parameters (including max fun evals)
+opd=[1 10 10 1000*np 1.0e-5 1.0e-4];  % default 
+
+if isempty(op),
+    op=opd;
+else
+    [m,n]=size(op);
+    if m>1, error([om(1,:) 'Control variables must be a vector']); end
+    if n<6, op=[op(1:n) opd(n+1:6)]; end
+end
+
+op(1)=max(op(1),0); 
+idx = find(op<=0);
+op(idx) = opd(idx);
+
+rho=op(1); maxit=op(2); minit=op(3); maxfn = op(4); delta=op(5); tol=op(6);
+
+clear op opd
+
+flag = 0;
+nfeval = 0;
+
+% evaluate initial guess
+
+ob=feval(FUN,p(nic+1:nic+np),varargin,fobj,nconst);
+nfeval = nfeval + 1;
+[m,n]=size(ob);
+if n>=2,
+    error([om(1,:) 'Cost function must return a column vector'])
+end
+if m<nic+1,
+    error([om(1,:) 'The number of constraints in your COST function does';...
+           om(2,:) 'not match the number specified in the call to SOLNP.']);  
+end 
+nc=m-1; % total number of constraints
+nec=nc-nic; % number of equality constraints
+clear m n
+
+j=ob(1);  % objective function value
+jh=[nfeval, j]; % optimization history
+t=zeros(3,1); % tolerances
+
+% lagrange multipliers
+if nc>=1,
+    if ( isempty(lambda) | lambda==0 ) 
+        lambda=zeros(nc,1);
+    end
+    constraint=ob(2:end);
+    if nic>=1,
+        if min([constraint(nec+1:nc)-pb(1:nic,1);...
+                    pb(1:nic,2)-constraint(nec+1:nc)]) > 0,
+            p(1:nic)=constraint(nec+1:nc); 
+        end
+        constraint(nec+1:nc)=constraint(nec+1:nc)-p(1:nic);
+    end
+    t(2)=norm(constraint);
+    if max([t(2)-10*tol, nic])<=0, %???
+        rho=0;
+    end
+else
+    lambda = 0;
+end
+
+% hessian
+if isempty(hess), 
+    hess=eye(np+nic); 
+end
+
+mu=np; 
+iteration=0;
+% begin iteration loop
+while iteration<maxit,
+    iteration=iteration+1;
+    op=[rho minit delta tol nec nic np lpb];
+    [p,lambda,hess,mu,subnev,info]=subnp(FUN,p,op,lambda,ob,pb,hess,mu,fobj,nconst,scale,varargin{:});
+    ob=feval(FUN,p(nic+1:nic+np),varargin,fobj,nconst);
+    nfeval = nfeval + subnev + 1;
+    
+    t(1)=(j-ob(1))/max(abs(ob(1)),1);
+    j=ob(1);
+    if nc>=1,
+        constraint=ob(2:nc+1); 
+        if nic>=1,
+            if min([constraint(nec+1:nc)-pb(1:nic,1);...
+                        pb(1:nic,2)-constraint(nec+1:nc)]) > 0,
+                p(1:nic)=constraint(nec+1:nc); 
+            end
+            constraint(nec+1:nc)=constraint(nec+1:nc)-p(1:nic);
+        end
+        t(3)=norm(constraint);
+        % update penalty weight
+        if t(3)<10*tol,
+            rho=0; mu=min(mu, tol);
+        end
+        if t(3)<5*t(2), 
+            rho=rho/5;
+        elseif t(3)>10*t(2), 
+            rho=5*max(rho, sqrt(tol)); 
+        end
+        if max([tol+t(1), t(2)-t(3)]) <= 0, 
+            lambda=0*lambda; hess=eye(size(hess)); 
+        end
+        t(2)=t(3);
+    end
+    % optimization history
+    jh=[jh; nfeval, j];
+    if iprint > 0,
+        fprintf(iprint,'iteration: %i; nfeval: %i; f: %g \n', iteration,nfeval,ob(1));
+        if info(1)==1, 
+            fprintf(iprint, '-- SOLNP -> %s\n\t%s\n\t%s\n\n', ...
+                'Redundant constraints were found. Poor',...
+                'intermediate results may result.  Suggest that you',...
+                'remove redundant constraints and re-OPTIMIZE.'); 
+        end
+        if info(2)==1, 
+            fprintf(iprint, '-- SOLNP -> %s\n\n', ...
+                'The linearized problem has no feasible solution.'); 
+        end
+        if info(3)==1, 
+            fprintf(iprint, '-- SOLNP -> %s\n\t%s\n\n', ...
+                'Minor optimization routine did not converge in the',...
+                'specified number of minor iterations.'); 
+        end
+    end
+    % termination
+    if norm([t(1) t(2)])<=tol, 
+        maxit = iteration;
+        flag = 1;
+    end
+    if nfeval > maxfn, break, end
+    if info(2)==1 & abs(t(1))<=eps & t(2)>tol, flag = -1; break, end % no progress
+end
+
+if nic>=1,
+    ic=p(1:nic);
+end
+p=p(nic+1:nic+np);
+
+if iprint
+    if flag == 1
+        fprintf(iprint,'-- Completed in %i iteration \n',iteration);
+    elseif flag == -1;
+        fprintf(iprint,'-- No feasible solution found \n');
+    elseif nfeval > maxfn,
+        fprintf(iprint,'-- Exiting after maximum number of function evaluations \n');
+    else
+        fprintf(iprint,'-- Exiting after maximum number of iterations \n');
+    end
+end
+return
+
+%  VARIABLE GLOSSARY:
+%-------------------------------------------------------------------------------
+%OB(1)      value of the cost objective function
+%CONSTRAINT:vector of constraint values
+%IB:        on input, contains the inequality constraint bounds + optionally
+%           the values of the inequality constraints.  Gets converted to a 
+%           NIC x 2 matrix of inequality constraint bounds.
+%IC:        NIC x 1 vector of inequality constraints
+%ITERATION: index for major iterations
+%J:         previous value of the cost objective function
+%JH:        history of the cost function
+%LPB (2):   vector flag which indicates the presence of parameter bounds
+%           and or inequality constraints.
+%             LPB(1) refers to parameter bounds, it is 0 if there are 
+%                    none, 1 if there are one or more.  
+%             LPB(2) refers to constraints of either type.
+%M:         number of rows of a matrix, usually temporary
+%N:         number of columns of a matrix, usually temporary
+%NC:        total number of constraints (=NEC+NIC)
+%NEC:       number of equality constraints
+%NIC:       number of inequality constraints
+%NP:        number of parameters
+%OPD:       vector of default optimization control variables
+%OP:        vector of control variables.
+%             It is passed in as:
+%               [RHO MAJIT MINIT DELTA TOL] (all optional)
+%             It is passed to ISISUBOPT as:
+%               [RHO MAJIT MINIT DELTA TOL NEC NIC NP LPB(1) LPB(2)]
+%P:         On input, contains the parameters to be optimized.  During the 
+%           optimization this vector contains: [PIC;P]  where PIC contains 
+%           pseudo parameters corresponding to the inequality constraints.
+%PB:        on input, optionally contains the parameter bounds + optionally
+%           the values of the parameters (one or the other or both can be 
+%           specified).  Gets converted to a NPB x 2 matrix of parameter bounds.
+%T (3):     vector of computed tolerances during optimization.
+%             T(1) is the difference of the objective values between two 
+%                  consecutive iterations
+%             T(2) is NORM(CONSTRAINT) before a major iteration
+%             T(3) is NORM(CONSTRAINT) after a major iteration
+
+
+%-------------------------------------------------------------------------------
+%  SUBNP
+%-------------------------------------------------------------------------------
+function [p,y,hess,mu,nfeval,info]=subnp(FUN,p0,op,yy,ob,pb,hess,mu,fobj,nconst,scale_temp,varargin)
+
+rho=op(1); maxit=op(2); delta=op(3); tol=op(4);   nec=op(5); 
+nic=op(6); np=op(7);    nc=nec+nic;  npic=np+nic; lpb=op(8:9); ch=1;
+clear op
+alp=[0 0 0];
+nfeval = 0;
+
+info = zeros(1,3);
+
+% make the scale for the cost, the equality constraints, the inequality
+% constraints, and the parameters
+if nec>0,
+    scale=[ob(1);ones(nec,1)*max(abs(ob(2:nec+1)))];
+else        
+    scale=1;
+end
+if lpb(2)==0,
+    scale=[scale; p0];
+else        
+    scale=[scale; ones(size(p0))];
+end
+
+%JAE 10/07/2006
+% scale_temp=varargin{2};
+scale=[scale_temp.f scale_temp.g scale_temp.x]';
+%
+
+
+scale=min(max(abs(scale),tol),1/tol);
+
+
+
+
+% scale the cost, the equality constraints, the inequality constraints, 
+% the parameters (inequality parameters AND actual parameters), 
+% and the parameter bounds if there are any
+% Also make sure the parameters are no larger than (1-tol) times their bounds
+ob=ob./scale(1:nc+1);  
+p0=p0./scale(nec+2:nc+np+1);
+if lpb(2)==1,
+    if lpb(1)==0,
+        mm=nic;
+    else 
+        mm=npic;
+    end
+    pb=pb./[scale(nec+2:nec+mm+1) scale(nec+2:nec+mm+1)];
+end
+
+% scale the lagrange multipliers and the Hessian
+if nc>=1,
+    yy=scale(2:nc+1).*yy/scale(1);
+end
+hess=hess.*(scale(nec+2:nc+np+1)*scale(nec+2:nc+np+1)')/scale(1);
+
+j=ob(1);
+a=[zeros(nec,nic);-eye(nic)];
+g=zeros(npic,1);
+
+% evaluate gradients using forward differences
+if nc>=1,
+    constraint=ob(2:nc+1);
+    for i=1:np, 
+        p0(nic+i)=p0(nic+i)+delta;
+        ob=feval(FUN,p0(nic+1:npic).*scale(nc+2:nc+np+1),varargin,fobj,nconst);
+        ob = ob./scale(1:nc+1);
+        g(nic+i)=(ob(1)-j)/delta;
+        a(:,nic+i)=(ob(2:nc+1)-constraint)/delta;
+        p0(nic+i)=p0(nic+i)-delta;
+    end
+    nfeval = nfeval + np;
+    if nic>=1,
+        constraint(nec+1:nec+nic)=constraint(nec+1:nec+nic)-p0(1:nic);
+    end
+    if cond(a)>1/eps,
+        info(1) = 1; % 'Redundant constraints';
+    end
+    b=a*p0-constraint;
+end
+
+% see if the current vector is feasible for the linearized problem
+if nc>=1,
+    ch=-1;
+    alp(1)=tol-max(abs(constraint));
+    if alp(1)<=0,
+        ch=1;
+        if lpb(2)==0,
+            p0=p0-a'*((a*a')\constraint);
+            alp(1)=1;
+        end
+    end
+    if alp(1)<=0,
+        p0(npic+1)=1;
+        a=[a, -constraint];
+        c=[zeros(1,npic), 1];
+        dx=ones(npic+1,1);
+        go=1; 
+        minit=0;
+        while go>=tol 
+            minit=minit+1;
+            gap=[p0(1:mm,1)-pb(:,1),pb(:,2)-p0(1:mm,1)];
+            gap=sort(gap')';
+            dx(1:mm)=gap(:,1);
+            dx(npic+1)=p0(npic+1);
+            if lpb(1)==0,
+                dx(mm+1:npic)=max([dx(1:mm);100])*ones(npic-mm,1);
+            end
+            y=(a*diag(dx))'\(dx.*c');
+            v=dx.*(dx.*(c'-a'*y));
+            if v(npic+1)>0,
+                z=p0(npic+1)/v(npic+1);
+                for i=1:mm,
+                    if v(i)<0,
+                        z=min(z,-(pb(i,2)-p0(i))/v(i));
+                    elseif v(i)>0, 
+                        z=min(z,(p0(i)-pb(i,1))/v(i)); 
+                    end
+                end
+                if z>= p0(npic+1)/v(npic+1),
+                    p0=p0-z*v; 
+                else
+                    p0=p0-0.9*z*v; 
+                end
+                go=p0(npic+1);
+                if minit >= 10, 
+                    go=0; 
+                end
+            else
+                go=0;
+                minit=10;
+            end
+        end
+        if minit>=10,
+            info(2) = 1; % 'Infeasible';
+        end
+        a=a(:,1:npic); 
+        b=a*p0(1:npic);
+    end
+end
+
+clear constraint c z v gap;
+
+p=p0(1:npic); 
+y=0; 
+if ch>0,
+    ob=feval(FUN,p(nic+1:npic).*scale(nc+2:nc+np+1),varargin,fobj,nconst);
+    ob = ob./scale(1:nc+1);
+    nfeval = nfeval + 1;
+end
+j=ob(1);
+
+if nic>=1,
+    ob(nec+2:nc+1)=ob(nec+2:nc+1)-p(1:nic);
+end
+
+if nc>=1,
+    ob(2:nc+1)=ob(2:nc+1)-a*p+b;
+    j=ob(1)-yy'*ob(2:nc+1)+rho*norm(ob(2:nc+1))^2;
+end
+
+minit=0; STOP = 0;
+while ~STOP 
+    minit=minit+1;
+    if ch>0,
+        for i=1:np,
+            p(nic+i)=p(nic+i)+delta;
+            obm=feval(FUN,p(nic+1:npic).*scale(nc+2:nc+np+1),varargin,fobj,nconst);
+            obm = obm./scale(1:nc+1);
+            if nic>0,
+                obm(nec+2:nc+1)=obm(nec+2:nc+1)-p(1:nic);
+            end
+            if nc>0,
+                obm(2:nc+1)=obm(2:nc+1)-a*p+b;
+                obm=obm(1)-yy'*obm(2:nc+1)+rho*norm(obm(2:nc+1))^2;
+            end
+            g(nic+i)=(obm-j)/delta;
+            p(nic+i)=p(nic+i)-delta;
+        end
+        nfeval = nfeval + np;
+        if nic>=1,
+            g(1:nic)=0*yy(nec+1:nc);
+        end
+    end
+    if minit>1,
+        yg=g-yg;
+        sx=p-sx;
+        sc(1)=sx'*hess*sx;
+        sc(2)=sx'*yg;
+        if sc(1)*sc(2)>0,
+            sx=hess*sx;
+            hess=hess-(sx*sx')/sc(1)+(yg*yg')/sc(2);
+        end
+    end
+    dx=0.01*ones(npic,1);
+    if lpb(2)==1,
+        gap=[p(1:mm,1)-pb(:,1),pb(:,2)-p(1:mm,1)];
+        gap=sort(gap')';
+        gap=gap(:,1)+sqrt(eps)*ones(mm,1);
+        dx(1:mm,1)=ones(mm,1)./gap;
+        if lpb(1)<=0,
+            dx(mm+1:npic)=min([dx(1:mm);0.01])*ones(npic-mm,1);
+        end
+    end
+    go=-1;
+    mu=mu/10;
+    while go<=0,
+        % using Cholesky factorization
+        [c,pdummy]=chol(hess+mu*diag(dx.*dx));
+        if pdummy > 0, p0 = p; break, end % ????????????????????
+        c=inv(c);
+        yg=c'*g;
+        if nc<=0,
+            u=-c*yg;
+        else 
+            y=(c'*a')\yg;
+            u=-c*(yg-(c'*a')*y);
+        end
+                
+        p0=u(1:npic)+p;
+        if lpb(2)==0,
+            go=1;
+        else
+            go=min([p0(1:mm)-pb(:,1);pb(:,2)-p0(1:mm)]);
+            mu=3*mu;
+        end
+    end
+    alp(1)=0;ob1=ob;ob2=ob1;sob(1)=j;sob(2)=j;
+    pt(:,1:2)=[p p];alp(3)=1.0;pt(:,3)=p0;
+    ob3=feval(FUN,pt(nic+1:npic,3).*scale(nc+2:nc+np+1),varargin,fobj,nconst);
+    ob3 = ob3./scale(1:nc+1);
+    nfeval = nfeval + 1;
+    sob(3)=ob3(1);
+    if nic>=1,
+        ob3(nec+2:nc+1)=ob3(nec+2:nc+1)-pt(1:nic,3);
+    end
+    if nc>=1,
+        ob3(2:nc+1)=ob3(2:nc+1)-a*pt(:,3)+b;
+        sob(3)=ob3(1)-yy'*ob3(2:nc+1)+rho*norm(ob3(2:nc+1))^2;
+    end
+    go=1;
+    while go>tol,
+        alp(2)=(alp(1)+alp(3))/2;
+        pt(:,2)=(1-alp(2))*p+alp(2)*p0;
+        ob2=feval(FUN,pt(nic+1:npic,2).*scale(nc+2:nc+np+1),varargin,fobj,nconst);
+        ob2 = ob2./scale(1:nc+1);
+        nfeval = nfeval + 1;
+        sob(2)=ob2(1);
+        if nic>=1,
+            ob2(nec+2:nc+1)=ob2(nec+2:nc+1)-pt(1:nic,2);
+        end
+        if nc>=1,
+            ob2(2:nc+1)=ob2(2:nc+1)-a*pt(:,2)+b;
+            sob(2)=ob2(1)-yy'*ob2(2:nc+1)+rho*norm(ob2(2:nc+1))^2;
+        end
+        obm=max(sob);
+        if obm<j,
+            obn=min(sob);
+            go=tol*(obm-obn)/(j-obm);
+        end
+        if sob(2)>=sob(1),
+            sob(3)=sob(2);ob3=ob2;alp(3)=alp(2);pt(:,3)=pt(:,2);
+        elseif sob(1)<=sob(3),
+            sob(3)=sob(2);ob3=ob2;alp(3)=alp(2);pt(:,3)=pt(:,2);
+        else
+            sob(1)=sob(2);ob1=ob2;alp(1)=alp(2);pt(:,1)=pt(:,2);
+        end
+        if go>=tol,
+            go=alp(3)-alp(1);
+        end
+    end
+    sx=p;yg=g;ch=1;
+    obn=min(sob);
+    
+    if j<=obn, STOP = 1; end
+
+    reduce=(j-obn)/(1+abs(j));
+    if reduce<tol, STOP = 1; end
+    
+    if sob(1)<sob(2),
+        j=sob(1);p=pt(:,1);ob=ob1;
+    elseif sob(3)<sob(2),
+        j=sob(3);p=pt(:,3);ob=ob3;
+    else 
+        j=sob(2);p=pt(:,2);ob=ob2;
+    end
+    if minit >= maxit, STOP = 1; end
+    clear ob1 ob2 ob3 pt;
+end
+
+p=p.*scale(nec+2:nc+np+1);  % unscale the parameter vector
+if nc>=1,
+    y=scale(1)*y./scale(2:nc+1); % unscale the lagrange multipliers
+end
+hess=scale(1)*hess./(scale(nec+2:nc+np+1)*scale(nec+2:nc+np+1)');
+
+if reduce>tol,
+    info(3) = 1; % 'Max number of minor iterations';
+end
+return
+
+%  VARIABLE GLOSSARY:
+%------------------------------------------------------------------------------
+%
+%ALP (4):   vector of ??. Alp(4) is "alpha"
+%CH:        "change"
+%CONSTRAINT:vector of constraint values
+%G:         gradient
+%GAP (2):   lower and upper "gap"
+%LPB (2):   vector flag which indicates the presence of parameter bounds
+%           and or inequality constraints.
+%             LPB(1) refers to parameter bounds, it is 0 if there are 
+%                    none, 1 if there are one or more.  
+%             LPB(2) refers to constraints of either type.
+%NC:        total number of constraints (=NEC+NIC)
+%NEC:       number of equality constraints
+%NIC:       number of inequality constraints
+%NP:        number of parameters
+%P0:        parameter vector on input
+%P:         parameter vector on output
+%SOB (3):   vector of ??
+%Z (5):     vector of ??
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/local_solvers/ydhc/ydhc.m b/Requirements/MEIGO/eSS/local_solvers/ydhc/ydhc.m
new file mode 100644
index 0000000000000000000000000000000000000000..221474fbde5fe0c533f17a5c9ecf0d8d3d302501
--- /dev/null
+++ b/Requirements/MEIGO/eSS/local_solvers/ydhc/ydhc.m
@@ -0,0 +1,400 @@
+function [x, fval, exitflag, output] = ydhc(fun,x0,lb,ub,options)
+% Optimization via Dynamic Hill Climbing.
+%
+% An implementation with slight modifications of the algorithm as described
+% in [De La Maza and Yuret. Dynamic Hill Climbing].
+%
+% Input:
+% fun     : objective function to be minimized
+% x0      : initial guess for parameters
+% lb, ub  : bounds for parameters, i.e. lb <= x <= ub; no value should be 
+%           inf and the difference ub-lb in no component be < 0
+% options : struct with options for the algorithm:
+%   TolX              : tolerance of parameter
+%   TolFun            : tolerance of objective function
+%   MaxFunEvals       : maximum number of evaluations of fun
+%   OutputFcn         : for visual output after each iteration
+%   InitialStepSize   : rel. to 1 (default 0.1)
+%   ExpandFactor      : factor of expansion upon success (default 2)
+%   ContractFactor    : factor of contraction upon failure (default 0.45)
+%   StuckSearchFactor : how far to expand again after got stuck (default 4)
+%   Barrier           : use barrier on bounds (default extreme barrier)
+%   Display           : off|iter|debug, text output (default off)
+%
+% Output:
+% x   : best guess for parameters
+% fval: objective function at the solution, generally fval=fun(x)
+% exitflag:
+%   1 : The function converged to a solution x
+%   0 : Number of function evaluations exceeded options.MaxFunEvals.
+%   -1: The algorithm was terminated inappropriately
+% output : struct with meta information:
+%   iterations  : number of iterations
+%   funcCount   : number of function evaluations
+%   algorithm   : name of the algorithm
+%   t_cpu       : cpu time
+%
+% History:
+% 2017/09/27 Yannik Schaelte
+
+% number of variables
+dim  = length(x0);
+
+% interpret options
+options  = f_get_options(options);
+% extract often used options
+tolX                = options.TolX;
+tolFun              = options.TolFun;
+maxFunEvals         = options.MaxFunEvals;
+initialStepSize     = options.InitialStepSize;
+expandFactor        = options.ExpandFactor;
+contractFactor      = options.ContractFactor;
+stuckSearchFactor   = options.StuckSearchFactor;
+barrier             = options.Barrier;
+
+% create column vectors
+lb      = lb(:);
+ub      = ub(:);
+x0      = x0(:);
+
+% normalize to unit square
+normalize   = @(x) f_normalize(x,lb,ub);
+denormalize = @(y) f_denormalize(y,lb,ub);
+y0      = normalize(x0);
+tolY    = tolX / norm(ub-lb);
+
+% output function for in-time analysis
+outputFcn = @(y,fval,funEvals,mode) f_output(y,denormalize,fval,funEvals,mode,options.OutputFcn);
+
+% max step size
+vmax = initialStepSize * ones(dim,1);
+
+% wrap function to consider boundaries
+fun = @(y,funEvals) f_wrap_fun(denormalize(y),fun,lb,ub,barrier,funEvals,maxFunEvals);
+
+% init run variables
+smax   = [vmax;-1];        % array of max step sizes, extra value for extra vector
+[step,norms]   = f_init_step(vmax); % matrix of step vectors
+xstep  = step;             % steps before last motion
+xnorms = norms;
+gradv  = zeros(dim,1);     % gradient vector
+gradi  = -1;               % index of gradient vector, -1 indicates gradv is not set
+prevj  = -1;               % index of last step taken
+stuck  = false;            % is process stuck (in min/max)? set when step sizes are small
+% then step vectors are increased
+done   = false;            % is some finishing criterion fulfilled?
+
+nVec   = 2*dim + 2;            % maximum index in step matrix
+opp_j  = @(j) f_opp_j(j,nVec); % short for opposite index in step matrix
+
+% init meta variables
+exitflag  = -1;        % flag indicating exit reason
+starttime = cputime;   % to measure time difference
+funEvals  = 0;         % function evaluations, should be <= maxFunEvals
+
+% init x, fval
+ybst      = y0;
+fbst      = fun(ybst,funEvals);
+funEvals  = funEvals + 1;
+
+outputFcn(ybst,fbst,funEvals,'init'); % create new figure and initialize
+outputFcn(ybst,fbst,funEvals,'iter'); % first iteration with start point
+
+% main loop
+while ~done
+    
+    if stuck
+        % choose the smallest step, if any is smaller than the maximum size
+        [v,j] = f_min(step,norms,smax);
+    else
+        % choose the largest step
+        [v,j] = f_max(step,norms);
+    end
+    
+    % textual output
+    f_display(options.Display,funEvals,fbst,norm(v));
+    
+    % j == -1 indicates minimum found
+    if j ~= -1 && funEvals <= maxFunEvals
+        % compute next x, fval
+        ycur = ybst + v;
+        fcur = fun(ycur,funEvals);
+        funEvals = funEvals + 1;
+        
+        delta_f = fcur - fbst;
+        
+        % is better estimate?
+        if delta_f < 0
+            ybst = ycur;
+            fbst = fcur;
+        end
+        
+        % is significantly better estimate?
+        if delta_f < 0 && (norm(v)>tolX/stuckSearchFactor || abs(delta_f) > tolFun)
+            % we are not stuck somewhere (anymore)
+            stuck = false; 
+            % contract opp step to not try the previous point next
+            step(:,opp_j(j)) = -contractFactor*v;
+            norms(opp_j(j)) = norm(step(:,opp_j(j)));
+            % if last step repeated, expand the current step
+            if j == prevj
+                v = expandFactor*v;
+            end
+            % xstep always contains the steps of the last time we moved
+            xstep = step;
+            xnorms = norms;
+            % record the last step
+            prevj = j;
+            % record step
+            step(:,j) = v;
+            norms(j) = norm(v);
+            
+            % update gradient vector
+            if gradi == -1
+                % if gradv empty, set gradv to current step and record index
+                gradv = v;
+                gradi = min([j, opp_j(j)]);
+            elseif gradi == min([j, opp_j(j)])
+                % if gradv is parallel to current step, add the current vector
+                gradv = (gradv + v);
+            else
+                % else update the extra vector
+                step(:,dim+1) = gradv + v;
+                norms(dim+1) = norm(gradv + v);
+                % set extra entry in smax to max of current step smax and gradv smax
+                % (bound for norm of gradient)
+                smax(dim+1)   = max([smax(min([j,opp_j(j)])),smax(gradi)]);
+                % set the opp step to - extra step
+                step(:,dim+2) = -contractFactor*step(:,dim+1);
+                norms(dim+2) = abs(contractFactor)*norms(dim+1);
+                % update gradv
+                gradi =-1;%        = min([j, opp_j(j)]);
+            end
+        else % not significantly better estimate
+            if stuck
+                % if already stuck, increase the current step size
+                step(:,j) = expandFactor*v;
+                norms(j) = norm(step(:,j));
+            elseif norm(step(:,j)) >= tolY
+                % if current step norm >= tolY, decrease the current step size
+                step(:,j) = contractFactor*v;
+                norms(j) = norm(step(:,j));
+            else
+                % else (norm < tolY): set the stuck flag and set all steps to
+                % expandFactor times the last recorded steps
+                stuck = true;
+                step = expandFactor * xstep;
+                norms = abs(expandFactor)*xnorms;
+            end
+        end
+        
+        % update output
+        outputFcn(ybst,fbst,funEvals,'iter');
+        
+    else % somehow done
+        done = true;
+        if funEvals <= maxFunEvals
+            % maybe found a local minimum
+            exitflag = 1;
+        else
+            % needed too long
+            exitflag = 0;
+        end
+    end
+    
+end
+
+% finalize output
+outputFcn(ybst,fbst,funEvals,'done');
+% textual output
+f_display(options.Display,funEvals,fbst,norm(v),true)
+
+% assign return values
+x                   = denormalize(ybst);
+fval                = fbst;
+output = struct();
+output.funcCount    = funEvals;
+output.iterations   = funEvals;
+output.algorithm    = 'Dynamic Hill Climb';
+output.t_cpu        = cputime - starttime;
+
+end % function
+
+
+%% helper functions
+
+
+function y = f_normalize(x,lb,ub)
+% normalize vector to [0,1]
+
+if any(~isfinite(lb)) || any(~isfinite(ub))
+    y = x;
+else
+    y = (x-lb)./abs(ub-lb);
+end
+
+end
+
+
+function x = f_denormalize(y,lb,ub)
+% denormalize vector from [0,1]
+
+if any(~isfinite(lb)) || any(~isfinite(ub))
+    x = y;
+else
+    x = y.*(ub-lb) + lb;
+end
+
+end
+
+
+function j_opp = f_opp_j(j,nVec)
+% short for opposite vector in step matrix
+
+j_opp = nVec - (j-1);
+
+end
+
+
+function fval = f_wrap_fun(x,fun,lb,ub,barrier,funEvals,maxFunEvals)
+% wrap around function to allow for a barrier function wrap
+
+% set fun to inf whenever conditions not fulfilled
+if ~isequal(barrier,'')
+    fval = fun(x);
+    fval = barrierFunction(fval, [], x, [lb, ub], funEvals, maxFunEvals, barrier);
+else
+    % extreme barrier
+    if any(x>ub) || any(x<lb)
+        fval = inf;
+    else
+        fval = fun(x);
+    end
+end
+
+end
+
+
+function [step,norms] = f_init_step(vmax)
+% create dim x (2*dim+2)-matrix containing the step proposals as columns
+% also return the norms of the steps to reduce computations
+
+dim  = length(vmax);
+
+nVec = 2*dim + 2;
+step = zeros(dim,nVec);
+norms = zeros(1,nVec);
+% 2 positions in the center reserved for gradient
+for j = 1:dim
+    initStepSize       = abs(vmax(j));
+    step(j,j)          = initStepSize;
+    step(j,nVec-(j-1)) = -initStepSize;
+    norms(j)           = initStepSize;
+    norms(nVec-(j-1))  = initStepSize;
+end
+
+end
+
+
+function [v_max,j_max] = f_max(step,norms)
+% find step with maximal norm
+
+[~,j_max] = max(norms);
+v_max = step(:,j_max);
+
+end
+
+
+function [v_min,j_min] = f_min(step,norms,smax)
+% find step with smallest norm, if one exists whose norm is smaller than
+% the corresponding smax max step size
+
+minnorm = -1;
+j_min   = -1; % -1 used as indicator in calling function
+v_min   = -1;
+nVec    = size(step,2);
+for j=1:nVec
+    vnorm = norms(j);
+    if ( vnorm <= smax(min([j, nVec-(j-1)])) && (vnorm < minnorm || minnorm < 0) && vnorm > 0) % tolerance % smax(min([j, nVec-(j-1)]))
+        minnorm = vnorm;
+        j_min = j;
+    end
+end
+
+if (j_min ~= -1)
+    v_min = step(:,j_min);
+end
+
+end
+
+
+function [ options ] = f_get_options(options_in)
+% fill non-existent fields with default values, and check validity
+
+options = struct();
+options.TolX                = 1e-8;
+options.TolFun              = 1e-8;
+options.MaxFunEvals         = Inf;
+options.OutputFcn           = nan;
+options.InitialStepSize     = 0.1;
+options.ExpandFactor        = 2.1;
+options.ContractFactor      = 0.47;
+options.StuckSearchFactor   = 4;
+options.Barrier             = '';
+options.Display             = 'off';
+
+% fill from input
+cell_fieldnames = fieldnames(options);
+cell_fieldnames_in = fieldnames(options_in);
+
+for jf = 1:length(cell_fieldnames_in)
+    fieldname = cell_fieldnames_in{jf};
+    if ~any(strcmp(cell_fieldnames,fieldname))
+        error(['Options field ' fieldname ' does not exist.']);
+    end
+    options.(fieldname) = options_in.(fieldname);
+end
+
+end
+
+
+function f_output(y,f_denormalize,fval,funEvals,state,outputFcn)
+% short for call to output function
+% state: 'init', 'iter', or 'done'
+
+if isa(outputFcn,'function_handle')
+    x = f_denormalize(y);
+    optimValues.fval = fval;
+    optimValues.iteration = funEvals;
+    outputFcn(x,optimValues,state);
+end
+
+end
+
+
+function f_display(display,funEvals,fbst,vnorm,final)
+% short for call to display on screen
+
+if nargin < 5, final = false; end
+
+if strcmp(display,'iter') || strcmp(display,'debug')
+    if (strcmp(display,'debug'))
+        show_output = true;
+    else
+        show_output = mod(funEvals,100) == 1;
+    end
+    
+    if show_output && ~final
+        if mod(funEvals,1000) == 1
+            fprintf('fevals\t|\tfbst\t|\tstepnorm\n');
+        end
+        fprintf(strcat('%d\t|\t%.8e\t|\t%.8e\n'),funEvals,fbst,vnorm);
+    end
+    
+    if final
+        fprintf('final: \t funEvals: %d, \t fbst: %.8e\n',funEvals,fbst); 
+    end
+
+end
+
+end
diff --git a/Requirements/MEIGO/eSS/ssm_aux_local.m b/Requirements/MEIGO/eSS/ssm_aux_local.m
new file mode 100644
index 0000000000000000000000000000000000000000..96e012c7c78c9f5c38c2b37c4eea173f33f0dcd7
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_aux_local.m
@@ -0,0 +1,454 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_aux_local.m 1804 2014-07-14 14:32:17Z attila $
+function ssm_aux_local(fobj,fjac,x_L,x_U,c_L,c_U,neq,local_solver,nvar,varargin)
+
+params=varargin;
+
+global n_upper n_lower ccuu ccll neqc nvarc
+
+nvarc=nvar;
+neqc=neq;
+
+n_upper=[];
+n_lower=[];
+ccll=[];
+ccuu=[];
+
+
+switch local_solver
+    case 'nomad'
+        if isempty(c_U)
+            n_upper=[];
+            n_lower=[];
+        else
+            %Number of nlc's
+            n_upper=[1:length(c_U)];
+            n_lower=n_upper;
+            clinf=find(c_L==-inf);
+            cuinf=find(c_U==inf);
+
+            %Upper bounded constraints
+            n_upper(cuinf)=[];
+
+            %Lower bounded contraints constraints
+            n_lower(clinf)=[];
+        end
+
+
+        %File with the parameters (for constrained problems)
+        if not(isempty(c_U))% | not(isempty(params))
+            fid=fopen('fobj_nomad_Param.m','w');
+            fprintf(fid,'function Param= f_Param\n');
+
+            fprintf(fid,'global params \n');
+            if not(isempty(c_U))
+                fprintf(fid,'Param.n_lower =[');
+                for i=1:length(n_lower)
+                    fprintf(fid,' %g;',n_lower(i));
+                end
+                fprintf(fid,' ];\n');
+
+                fprintf(fid,'Param.n_upper =[');
+                for i=1:length(n_upper)
+                    fprintf(fid,' %g;',n_upper(i));
+                end
+                fprintf(fid,' ];\n');
+                fprintf(fid,'Param.c_L =[');
+                for i=1:size(c_L,2)
+                    fprintf(fid,' %g;',c_L(i));
+                end
+                fprintf(fid,' ];\n');
+                fprintf(fid,'Param.c_U =[');
+                for i=1:size(c_U,2)
+                    fprintf(fid,' %g;',c_U(i));
+                end
+                fprintf(fid,' ];\n');
+            end
+
+            if not(isempty(params))
+                fprintf(fid,'Param.params =params; \n');
+                %                 for i=1:length(params)
+                %                     fprintf(fid,' %f;',params{i});
+                %                 end
+%                fprintf(fid,' };\n');
+            end
+            fclose(fid);
+        end
+
+        %File with objective function and constraints
+        fid=fopen('fobj_nomad.m','w');
+        if isempty(c_U)
+            fprintf(fid,'function [fx]= fobj_nomad (x)\n');
+        else
+            fprintf(fid,'function [fx,cx]= fobj_nomad (x)\n');
+            fprintf(fid,'Param=getappdata(0, ''PARAM'' );\n');
+        end
+
+        %If there are constraints
+        if not(isempty(c_U))
+            if not(isempty(params))
+                fprintf(fid,'global input_par \n');
+                fprintf(fid,'[fx ggg]= %s(x,input_par{:});\n',fobj);
+            else
+                fprintf(fid,'[fx ggg]= %s(x);\n',fobj);
+            end
+
+            fprintf(fid,'cx=[];\n');
+            fprintf(fid,'for i=1:length(Param.n_upper) \n');
+            fprintf(fid,'cx=[cx ggg(Param.n_upper(i))-Param.c_U(Param.n_upper(i))]; \n');
+            fprintf(fid,'end \n');
+
+            fprintf(fid,'for j=1:length(Param.n_lower) \n');
+            fprintf(fid,'cx=[cx Param.c_L(Param.n_lower(j))-ggg(Param.n_lower(j))]; \n');
+            fprintf(fid,'end \n');
+        else
+            if not(isempty(params))
+                fprintf(fid,'global input_par \n');
+                fprintf(fid,'[fx]= %s(x,input_par{:});\n',fobj);
+            else
+                fprintf(fid,'[fx]= %s(x);\n',fobj);
+            end
+        end
+
+        fprintf(fid,'return\n');
+        fclose(fid);
+
+        %File with bounds
+        fid=fopen('fobj_nomad_Omega.m','w');
+        fprintf(fid,'function [A,l,u]= fobj_nomad_Omega (n)\n');
+        fprintf(fid,'A = [eye(n)];\n');
+
+        fprintf(fid,'l= [');
+        for i=1:size(x_L,2)
+            fprintf(fid,' %g;',x_L(i));
+        end
+
+        fprintf(fid,' ];\n');
+        fprintf(fid,'u= [');
+        for i=1:size(x_U,2)
+            fprintf(fid,' %g;',x_U(i));
+        end
+        fprintf(fid,' ];\n');
+
+        fprintf(fid,'return\n');
+        fclose(fid);
+
+
+
+    case {'n2fb','dn2fb'}
+        %Creating objective function for n2fb and dn2fb
+        if nargout(fobj)<3
+            error('The objective function must have at least 3 arguments when using n2fb or dn2fb')
+        end
+        switch local_solver
+            case 'n2fb'
+                fid=fopen('objf_n2fb.m','w');
+                fprintf(fid,'function [R]= objf_n2fb (N,P,x,NF,R,LTY,TY)\n');
+            case 'dn2fb'
+                fid=fopen('objf_dn2fb.m','w');
+                fprintf(fid,'function [R]= objf_dn2fb (N,P,x,NF,R,LTY,TY)\n');
+        end
+        fprintf(fid,'global n_fun_eval \n');
+
+        if not(isempty(params))
+            fprintf(fid,'global input_par \n');
+            fprintf(fid,'[f,g,R]= %s(x,input_par{:});\n',fobj);
+        else
+            fprintf(fid,'[f,g,R]= %s(x);\n',fobj);
+        end
+
+        fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+        fprintf(fid,'return\n');
+        fclose(fid);
+    case 'nl2sol'
+        %Creating objective function for  nl2sol
+        if nargout(fobj)<3
+            error('The objective function must have at least 3 arguments when using nl2sol: F, constr, R')
+        end
+        % see if the 
+        flag = ess_aux_local_checkfiles('objf_nl2sol.m', fobj);
+        if flag == 0
+            fid=fopen('objf_nl2sol.m','w');
+            fprintf(fid,'function [R]= objf_nl2sol(x)\n');
+            fprintf(fid,'%% Objective function for NL2SOL in AMIGO\n%% Automatically generated in ssm_aux_local.m\n');
+            fprintf(fid,'global n_fun_eval \n');
+            
+            if not(isempty(params))
+                fprintf(fid,'global input_par \n');
+                fprintf(fid,'[f,g,R]= %s(x,input_par{:});\n',fobj);
+            else
+                fprintf(fid,'[f,g,R]= %s(x);\n',fobj);
+            end
+            
+            fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+            fprintf(fid,'return\n');
+            fclose(fid);
+        end
+
+        % creating the gradient function if defined
+        if ~isempty(fjac)
+            flag = ess_aux_local_checkfiles('fjac_nl2sol.m', fjac);
+            if flag == 0
+                fid=fopen('fjac_nl2sol.m','w');
+                fprintf(fid,'function [Jres]= fjac_nl2sol(x)\n');
+                fprintf(fid,'%% Jacobian of objective function for NL2SOL in AMIGO\n%% Automatically generated in ssm_aux_local.m\n');
+                fprintf(fid,'global n_jac_eval \n');
+                
+                if not(isempty(params))
+                    fprintf(fid,'global input_par \n');
+                    fprintf(fid,'[Jobj, Jg, Jres]= %s(x,input_par{:});\n',fjac);
+                else
+                    fprintf(fid,'[Jobj, Jg, Jres]= %s(x);\n',fjac);
+                end
+                %fprintf(fid,'[J]= %s(x,inputs);\n',fjac);
+                fprintf(fid,'n_jac_eval=n_jac_eval+1; \n\n');
+                fprintf(fid,'return\n');
+                fclose(fid);
+            end
+        end
+
+    case 'fsqp'
+        %File with the objective function and constraints
+        fid=fopen('fobj_fsqp.m','w');
+        fprintf(fid,'function [f]= fobj_fsqp (x,j)\n');
+        fprintf(fid,'global n_fun_eval \n');
+        if not(isempty(params))
+            fprintf(fid,'global input_par \n');
+            fprintf(fid,'[f]= %s(x,input_par{:});\n',fobj);
+        else
+            fprintf(fid,'[f]= %s(x);\n',fobj);
+        end
+
+        fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+        fprintf(fid,'return\n');
+        fclose(fid);
+
+        if not(isempty(c_U))
+            ccuu=c_U;
+            ccll=c_L;
+
+            if not(isempty(c_U))
+                %Number of nlc's
+                n_upper=[1:length(c_U)];
+                n_lower=n_upper;
+                clinf=find(c_L==-inf);
+                cuinf=find(c_U==inf);
+
+                %Upper bounded constraints
+                n_upper(cuinf)=[];
+
+                %Lower bounded constraints
+                n_lower(clinf)=[];
+            else
+                n_upper=[];
+                n_lower=[];
+            end
+
+
+
+
+            %File with the objective function and constraints
+            fid=fopen('constr_fsqp.m','w');
+            fprintf(fid,'function gj= constr_fsqp(x,j)\n');
+            fprintf(fid,'global n_upper n_lower ccuu ccll neqc \n');
+            fprintf(fid,'global n_fun_eval \n');
+            if not(isempty(params))
+                fprintf(fid,'global input_par \n');
+                fprintf(fid,'[fx ggg]= %s(x,input_par{:});\n',fobj);
+            else
+                fprintf(fid,'[fx ggg]= %s(x);\n',fobj);
+            end
+
+            fprintf(fid,'Amatrix=[];\n');
+            fprintf(fid,'c=[];\n');
+            fprintf(fid,'for i=1:length(n_upper) \n');
+            fprintf(fid,'c=[c ggg(n_upper(i))-ccuu(n_upper(i)-neqc)]; \n');
+            fprintf(fid,'end \n');
+
+            fprintf(fid,'for k=1:length(n_lower) \n');
+            fprintf(fid,'c=[c ccll(n_lower(k)-neqc)-ggg(n_lower(k))]; \n');
+            fprintf(fid,'end \n');
+
+
+
+            fprintf(fid,'for i=1:neqc \n');
+            fprintf(fid,'c=[c ggg(i)]; \n');
+            fprintf(fid,'end \n');
+
+            fprintf(fid,'gj=c(j); \n');
+            fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+            %fprintf(fid,'keyboard \n');
+            %fprintf(fid,'ggg\n');
+            %fprintf(fid,'c \n');
+            fprintf(fid,'return\n');
+            fclose(fid);
+        end
+
+    case 'ipopt'
+        %         %File with the objective function and constraints
+        %         fid=fopen('ipopt_f.m','w');
+        %         fprintf(fid,'function f= ipopt_f(x,Params)\n');
+        %         fprintf(fid,'global n_fun_eval \n');
+        %         fprintf(fid,'params=Params.params;\n');
+        %         fprintf(fid,'f= %s(x,params{:});\n',fobj);
+        %         fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+        %         fprintf(fid,'return\n');
+        %         fclose(fid);
+
+
+
+        %File with the objective function and constraints
+        fid=fopen('ipopt_f.m','w');
+        fprintf(fid,'function f=ipopt_f(x)\n');
+        fprintf(fid,'global n_fun_eval params \n');
+        fprintf(fid,'f= %s(x,params{:});\n',fobj);
+        fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+        fprintf(fid,'return\n');
+        fclose(fid);
+
+
+
+
+        if not(isempty(c_U))
+            ccuu=c_U;
+            ccll=c_L;
+            if isempty(c_U)
+                n_upper=[];
+                n_lower=[];
+            else
+                %Number of nlc's
+                n_upper=[1:length(c_U)];
+                n_lower=n_upper;
+                clinf=find(c_L==-inf);
+                cuinf=find(c_U==inf);
+
+                %Upper bounded constraints
+                n_upper(cuinf)=[];
+
+                %Lower bounded constraints
+                n_lower(clinf)=[];
+            end
+        
+
+        
+            fid2=fopen('ipopt_c.m','w');
+            fprintf(fid2,'function [c]= ipopt_f(x)\n');
+            fprintf(fid,'global n_fun_eval params \n');
+            fprintf(fid2,'[f,c]= %s(x,params{:});\n',fobj);
+            fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+            fprintf(fid2,'return\n');
+            fclose(fid2);
+        end
+
+
+        %             fid2=fopen('ipopt_c.m','w');
+        %             fprintf(fid2,'function ceq= ipopt_f(x,dummy)\n');
+        %             %We could use input parameters instead of global variables?
+        %             fprintf(fid2,'global n_upper n_lower ccuu ccll nvarc neqc \n');
+        %             fprintf(fid,'global n_fun_eval \n');
+        %             fprintf(fid,'params=dummy.params;\n');
+        %             fprintf(fid2,'[f,ggg]= %s(x,params{:});\n',fobj);
+        %             fprintf(fid2,'ceq=[];\n');
+        %             fprintf(fid2,'ceq=[ceq ggg(1:neqc)];\n');
+        %             fprintf(fid2,'clow=[];\n');
+        %             fprintf(fid2,'cupp=[];\n');
+        %             fprintf(fid2,'for i=1:length(n_upper) \n');
+        %             fprintf(fid2,'cupp=[cupp; ggg(n_upper(i))-ccuu(n_upper(i)-neqc)+x(nvarc+i)]; \n');
+        %             fprintf(fid2,'end \n');
+        %             fprintf(fid2,'for j=1:length(n_lower) \n');
+        %             fprintf(fid2,'clow=[clow; ggg(n_lower(j))-ccll(n_lower(j)-neqc)-x(nvarc+length(n_upper)+j)]; \n');
+        %             fprintf(fid2,'end \n');
+        %             % fprintf(fid2,'keyboard \n');
+        %             fprintf(fid2,'ceq=[ceq''; cupp; clow]; \n');
+        %
+        %             fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+        %             fprintf(fid2,'return\n');
+        %             fclose(fid2);
+
+
+
+case 'misqp'
+    if not(isempty(c_U))
+        ccuu=c_U;
+        ccll=c_L;
+        if isempty(c_U)
+            n_upper=[];
+            n_lower=[];
+        else
+            %Number of nlc's
+            n_upper=[1:length(c_U)];
+            n_lower=n_upper;
+            clinf=find(c_L==-inf);
+            cuinf=find(c_U==inf);
+
+            %Upper bounded constraints
+            n_upper(cuinf)=[];
+
+            %Lower bounded constraints
+            n_lower(clinf)=[];
+        end
+    end
+        case 'lbfgsb'
+        %Creating objective function for  lbfgsb
+        if nargout(fobj)< 3
+            error('The objective function must have 3 output arguments (f_obj 0 0)')
+        end
+        
+        fid=fopen('objf_lbfgsb.m','w');
+        fprintf(fid,'function [f]= objf_lbfgsb(x)\n');
+
+        fprintf(fid,'global n_fun_eval \n');
+
+        if not(isempty(params))
+            fprintf(fid,'global input_par \n');
+            fprintf(fid,'[f,g,R]= %s(x,input_par{:});\n',fobj);
+        else
+            fprintf(fid,'[f,g,R]= %s(x);\n',fobj);
+        end
+
+        fprintf(fid,'n_fun_eval=n_fun_eval+1; \n');
+        fprintf(fid,'return\n');
+        fclose(fid);
+        
+        
+        % creating the gradient function if defined
+        if ~isempty(fjac)
+            fid=fopen('fjac_lbfgsb.m','w');
+            fprintf(fid,'function [Jobj]= fjac_lbfgsb(x)\n');
+            fprintf(fid,'%% Automatically generated in ssm_aux_local.m\n');
+            fprintf(fid,'global n_jac_eval \n');
+            fprintf(fid,'global input_par \n\n');
+            fprintf(fid,'[Jobj, Jg, Jres]= %s(x,input_par{:});\n',fjac);           
+            fprintf(fid,'n_jac_eval=n_jac_eval+1; \n\n');
+            fprintf(fid,'return\n');
+            fclose(fid);
+        end
+
+    otherwise
+        if not(isempty(c_U))
+            ccuu=c_U;
+            ccll=c_L;
+            if isempty(c_U)
+                n_upper=[];
+                n_lower=[];
+            else
+                %Number of nlc's
+                n_upper=[1:length(c_U)];
+                n_lower=n_upper;
+                clinf=find(c_L==-inf);
+                cuinf=find(c_U==inf);
+
+                %Upper bounded constraints
+                n_upper(cuinf)=[];
+
+                %Lower bounded constraints
+                n_lower(clinf)=[];
+            end
+
+        end
+end
+rehash
+
+n_upper(1:neqc)=[];
+n_lower(1:neqc)=[];
+%ccll(1:neqc)=[];
+%ccuu(1:neqc)=[];
diff --git a/Requirements/MEIGO/eSS/ssm_beyond.m b/Requirements/MEIGO/eSS/ssm_beyond.m
new file mode 100644
index 0000000000000000000000000000000000000000..979a4984f9346728d463bf33589742722eddd7ca
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_beyond.m
@@ -0,0 +1,83 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_beyond.m 770 2013-08-06 09:41:45Z attila $
+function  [vector,vector_value,vector_penalty,vector_value_penalty,vector_nlc,...
+    new_child,new_child_value,new_child_penalty,new_child_value_penalty,new_child_nlc,nfuneval]=ssm_trascender(z1,z2,z2_val,fobj,nrand,tolc,weight,...
+    x_L,x_U,c_L,c_U,nconst,int_var,bin_var,nfuneval,prob_bound,varargin);
+
+continuar=1;
+denom=1;
+n_improve=1;
+
+
+vector=[];
+vector_value=[];
+vector_value_penalty=[];
+vector_penalty=[];
+vector_nlc=[];
+
+new_child=[];
+new_child_value=[];
+new_child_value_penalty=[];
+new_child_nlc=[];
+new_child_penalty=[];
+
+
+while continuar
+
+    %Continue
+    d=(z2-z1)/denom;
+    zv(1,:)=z2;
+    zv(2,:)=z2+d;
+
+    aaa=find(zv(2,:)<x_L);
+    bbb=find(zv(2,:)>x_U);
+
+    if ~isempty(aaa)
+        if rand>prob_bound
+            zv(2,aaa)=x_L(aaa);
+        end
+    end
+
+    if ~isempty(bbb)
+        if rand>prob_bound
+            zv(2,bbb)=x_U(bbb);
+        end
+    end
+
+    xnew=zv(1,:)+(zv(2,:)-zv(1,:)).*rand(1,nrand);   %non convex
+
+    %Evaluate
+    [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(xnew,x_L,x_U,fobj,nconst,c_L,c_U,...
+        tolc,weight,int_var,bin_var,varargin{:});
+    nfuneval=nfuneval+1;
+    if include
+        new_child=[new_child;x];
+        new_child_value=[new_child_value;val];
+        new_child_value_penalty=[new_child_value_penalty;val_penalty];
+        new_child_nlc=[new_child_nlc;nlc];
+        new_child_penalty=[new_child_penalty;pena];
+
+        if val_penalty<z2_val
+            z1=z2;
+            z2=xnew;
+            z2_val=val_penalty;
+
+            vector=x;
+            vector_value=val;
+            vector_value_penalty=val_penalty;
+            vector_penalty=pena;
+            vector_nlc=nlc;
+            n_improve=n_improve+1;
+
+            if n_improve==2;
+                denom=denom/2;
+                n_improve=0;
+            end
+        else
+            %If it does not improve, break the loop
+            break
+        end
+
+    else
+        continuar=0;
+    end
+end
diff --git a/Requirements/MEIGO/eSS/ssm_combination.m b/Requirements/MEIGO/eSS/ssm_combination.m
new file mode 100644
index 0000000000000000000000000000000000000000..103e7586165621320539efd484cf25e83dfd4cfb
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_combination.m
@@ -0,0 +1,176 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_combination.m 770 2013-08-06 09:41:45Z attila $
+function [new_comb,new_comb_values, new_comb_values_penalty,new_comb_nlc, new_comb_penalty,...
+    nfuneval,n_new]=ssm_combination(x1,x2,...
+    x1_val,x2_val,nrand,x_L,x_U,nconst,fobj,c_L,c_U,tolc,weight,nfuneval,int_var,bin_var,dim_refset,index,prob_bound,varargin);
+
+nvar=length(x1);
+%Maximum number of solutions evaluated = 100 by now
+new_comb=zeros(100,nvar);
+new_comb_values=zeros(100,1);
+new_comb_values_penalty=zeros(100,1);
+new_comb_penalty=zeros(100,1);
+new_comb_nlc=zeros(100,max(1,nconst));
+
+n_new=1;
+
+
+c=[];
+p=[];
+pval=[];
+
+
+%Auxliary vectors
+v=zeros(5,nvar);
+d=(x2-x1)/2;
+v(1,:)=x1-d;
+
+aaa=find(v(1,:)<x_L);
+bbb=find(v(1,:)>x_U);
+
+if ~isempty(aaa)
+    if rand>prob_bound
+        v(1,aaa)=x_L(aaa);
+    end
+end
+
+if ~isempty(bbb)
+    if rand>prob_bound
+        v(1,bbb)=x_U(bbb);
+    end
+end
+
+v(2,:)=x1;
+
+v(3,:)=x1+d;
+
+aaa=find(v(3,:)<x_L);
+bbb=find(v(3,:)>x_U);
+
+if ~isempty(aaa)
+    if rand>prob_bound
+        v(3,aaa)=x_L(aaa);
+    end
+end
+
+if ~isempty(bbb)
+    if rand>prob_bound
+        v(3,bbb)=x_U(bbb);
+    end
+end
+
+
+v(4,:)=x2;
+v(5,:)=x2+d;
+
+aaa=find(v(5,:)<x_L);
+bbb=find(v(5,:)>x_U);
+
+if ~isempty(aaa)
+    if rand>prob_bound
+        v(5,aaa)=x_L(aaa);
+    end
+end
+
+if ~isempty(bbb)
+    if rand>prob_bound
+        v(5,bbb)=x_U(bbb);
+    end
+end
+
+
+
+%If both elements belong to Refset1
+if (index(1)<=dim_refset/2) & (index(2)<=dim_refset/2)
+    c(1,:)=v(1,:)+(v(2,:)-v(1,:)).*rand(1,nrand);   %C1
+    p(1,:)=x1;
+    pval(1)=x1_val;
+    c(2,:)=v(2,:)+(v(3,:)-v(2,:)).*rand(1,nrand);   %C2
+    p(2,:)=x1;
+    pval(2)=x1_val;
+    c(3,:)=v(4,:)+(v(5,:)-v(4,:)).*rand(1,nrand);   %C3
+    p(3,:)=x2;
+    pval(3)=x2_val;
+
+    %2nd C2
+    c(4,:)=v(3,:)+(v(4,:)-v(3,:)).*rand(1,nrand);
+    p(4,:)=x2;
+    pval(4)=x2_val;
+
+
+    n_combin=4;
+
+    %%If both elements belong to Refset2
+elseif (index(1)>dim_refset/2) & (index(2)>dim_refset/2)
+    c(1,:)=v(2,:)+(v(3,:)-v(2,:)).*rand(1,nrand);
+    p(1,:)=x1;
+    pval(1)=x1_val;
+    a=rand;
+    if a<0.5
+        c(2,:)=v(2,:)+(v(1,:)-v(2,:)).*rand(1,nrand);          %C1
+        p(2,:)=x1;
+        pval(2)=x1_val;
+    else
+        c(2,:)=v(4,:)+(v(5,:)-v(4,:)).*rand(1,nrand);
+        p(2,:)=x2;
+        pval(2)=x2_val;
+    end
+    n_combin=2;
+
+    %One from Refset1, another one from Refset2
+else
+    c(1,:)=v(2,:)+(v(1,:)-v(2,:)).*rand(1,nrand);   %C1   %C1
+    p(1,:)=x1;
+    pval(1)=x1_val;
+    c(2,:)=v(2,:)+(v(3,:)-v(2,:)).*rand(1,nrand);   %C2
+    p(2,:)=x1;
+    pval(2)=x1_val;
+    c(3,:)=v(4,:)+(v(5,:)-v(4,:)).*rand(1,nrand);   %C3
+    p(3,:)=x2;
+    pval(3)=x2_val;
+    n_combin=3;
+end
+
+
+
+for i=1:n_combin;
+
+    %Evaluate
+    [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(c(i,:),x_L,x_U,fobj,nconst,...
+        c_L,c_U,tolc,weight,int_var,bin_var,varargin{:});
+
+    nfuneval=nfuneval+1;
+
+
+    if include
+        new_comb(n_new,:)=x;
+        new_comb_values(n_new)=val;
+        new_comb_values_penalty(n_new)=val_penalty;
+        new_comb_nlc(n_new,:)=nlc;
+        new_comb_penalty(n_new)=pena;
+        n_new=n_new+1;
+
+
+        if val_penalty<pval(i) & index(1)<=dim_refset/2
+            if not(index(2)>dim_refset/2 & i==3)
+
+                [vector,vector_value,vector_penalty,vector_value_penalty,vector_nlc,new_child,new_child_value,...
+                    new_child_penalty,new_child_value_penalty,new_child_nlc,nfuneval]=ssm_beyond(p(i,:),...
+                    x,val_penalty,fobj,nrand,tolc,weight,...
+                    x_L,x_U,c_L,c_U,nconst,int_var,bin_var,nfuneval,prob_bound,varargin{:});
+
+
+                new_child_index=length(new_child_value);
+
+
+                if ~isempty(new_child)
+                    new_comb(n_new:n_new+new_child_index-1,:)=new_child;
+                    new_comb_values(n_new:n_new+new_child_index-1)=new_child_value;
+                    new_comb_values_penalty(n_new:n_new+new_child_index-1)=new_child_value_penalty;
+                    new_comb_nlc(n_new:n_new+new_child_index-1,:)=new_child_nlc;
+                    new_comb_penalty(n_new:n_new+new_child_index-1)=new_child_penalty;
+                    n_new=n_new+new_child_index;
+                end
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/ssm_defaults.m b/Requirements/MEIGO/eSS/ssm_defaults.m
new file mode 100644
index 0000000000000000000000000000000000000000..a0a4cf9174ede1dc221f2cf16d7c7f01e13be06b
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_defaults.m
@@ -0,0 +1,70 @@
+
+function [default] = ssm_defaults
+
+%Assings default values for all the options
+
+%User options
+default.log_var                   =       [];              %Logarithmic interval division on variable i
+default.maxeval                   =       1000;            %Maximum number of function evaluations
+default.maxtime                   =       60;              %Maximum CPU time
+default.iterprint                 =       1;               %Print each iteration on screen
+default.plot                      =       0;               %Plots convergence curves
+default.weight                    =       1e6;             %Weight that multiplies the penalty term added to the objective function in constrained problems
+default.tolc                      =       1e-5;            %Maximum absolute violation of the constraints
+default.prob_bound                =       0.5;             %Probability of biasing the search towards the bounds
+default.strategy                  =       0;               %Search Strategy
+default.inter_save                =       0;               %Saves results in a report in intermediate iterations
+
+%Global options
+default.dim_refset                =       'auto';         %Number of elements in Refset
+default.ndiverse                  =       'auto';         %Number of solutions generated by the diversificator
+default.initiate                  =       1;              %Type of Refset initialization
+default.combination               =       1;              %Type of combination
+default.regenerate                =       3;              %Type of Refset regeneration
+default.delete                    =       'standard';     %Number of deleted elements when regeneration
+default.intens                    =       10;             %Iteration interval between intensification
+default.tolf                      =       1e-4;           %Function tolerance for joining the Refset
+default.diverse_criteria          =       1;              %Criteria for diversification in the Refset (1=euclidean distance, 2=tolerances)
+default.tolx                      =       1e-3;           %Variable tolerance for joining the Refset
+default.n_stuck                   =       0;              %Number of consecutive iterations without significant improvement before the search stops.
+
+%CeSS options
+default.n_threads                 =       1;              %Number of parallel threads
+default.n_iter                    =       1;              %Number of iterations
+default.is_parallel               =       false;          %Run optimization in parallel (true) or sequentially (false)
+default.maxtime_cess              =       300;            %Max time per iteration in CeSS
+
+%Local options
+default.local.solver              =       'fmincon';      %Choose local solver
+default.local.tol                 =       2;              %Level of tolerance in local search
+default.local.iterprint           =       0;              %Print each iteration on screen
+default.local.n1                  =       'default';      %Number of iterations before applying local search for the 1st time
+default.local.n2                  =       'default';      %Number of minimum iterations of global search between 2 local calls
+default.local.balance             =       0.5;            %Balances between quality (=0) and diversity (=1) for choosing initial points for the local search
+default.local.finish              =       [];             %Applies local search to the best solution found once the optimization if finished
+default.local.bestx               =       0;              %When activated (i.e. =1) only applies local search to the best solution found to date, ignoring filters
+default.local.merit_filter        =       1;              %Merit filter activation
+default.local.distance_filter     =       1;              %Distance filter activation
+default.local.thfactor            =       0.2;            %Merit filter relaxation parameter
+default.local.maxdistfactor       =       0.2;            %Distance filter relaxation parameter
+default.local.wait_maxdist_limit  =       20;             %Apply distance filter relaxation after this number of function evaluations without success in passing filter
+default.local.wait_th_limit       =       20;             %Apply merit filter relaxation after this number of function evaluations without success in passing filter
+default.local.use_gradient_for_finish   = 0;              %DW: (1) provide gradient to fmincon (0) don't
+default.local.check_gradient_for_finish = 0;              %DW: (1) use gradient checker on user-provided gradient (0) don't
+
+% local solver nl2sol options
+default.local.nl2sol.grad                = 'internalFD';  %Gradient computation of the Residuals 'internalFiniteDifference', MKLJac, AMIGO's or userdefined
+default.local.nl2sol.maxiter             =      500;
+default.local.nl2sol.maxfeval            =      550;
+default.local.nl2sol.display             =        1;
+default.local.nl2sol.tolrfun             =     1e-6;
+default.local.nl2sol.tolafun             =     1e-6;
+default.local.nl2sol.iterfun             =       [];     
+default.local.nl2sol.objrtol			 =     1e-5;
+
+% local solver lbfgsb options
+default.local.lbfgsb.grad                = 'mklJac';      %Gradient computation of the Residuals 'internalFiniteDifference', MKLJac, AMIGO's or userdefined
+default.local.lbfgsb.maxiter             =     300;
+default.local.lbfgsb.display             =        1;
+default.local.lbfgsb.tolrfun             =     1e-6;
+default.local.lbfgsb.iterfun             =       [];     
diff --git a/Requirements/MEIGO/eSS/ssm_delete_files.m b/Requirements/MEIGO/eSS/ssm_delete_files.m
new file mode 100644
index 0000000000000000000000000000000000000000..d093cee81ef9b30e03cf82dfda830be4fcbc361b
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_delete_files.m
@@ -0,0 +1,31 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_delete_files.m 770 2013-08-06 09:41:45Z attila $
+function delete_files(solver,c_U)
+switch solver
+    case 'nomad'
+        delete fobj_nomad.m
+        delete fobj_nomad_omega.m
+        delete fobj_nomad_x0.m
+
+        if ~isempty(c_U)
+            delete fobj_nomad_Param.m
+        end
+
+    case 'n2fb'
+        delete objf_n2fb.m
+
+    case 'dn2fb'
+        delete objf_dn2fb.m
+
+    case 'fsqp'
+        delete fobj_fsqp.m
+        if ~isempty(c_U)
+            delete constr_fsqp.m
+        end
+
+    case 'ipopt'
+        delete ipopt_f.m
+
+        if ~isempty(c_U)
+            delete ipopt_c.m
+        end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/ssm_diverse.m b/Requirements/MEIGO/eSS/ssm_diverse.m
new file mode 100644
index 0000000000000000000000000000000000000000..de55c9cbc1bdf484a2742e4eee17fc06f0dce78b
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_diverse.m
@@ -0,0 +1,43 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_diverse.m 770 2013-08-06 09:41:45Z attila $
+function fx=diverse(ndiverse,x_L,x_U)
+
+n=length(x_L);
+
+%Generates ndiverse diverse vectors between the bounds x_L and x_U
+
+f=ones(n,4);                     %Matrix of frequencies
+
+solutions=zeros(ndiverse,n);          %Matrix of solutions
+p=zeros(4,1);                    %Vector of probabilities
+
+
+
+%We generate 4 solutions
+for i=1:4
+solutions(i,:)=(rand(1,n)+i-1)/4;
+end
+
+for i=5:ndiverse                           %ndiverse-1 since we will add the user given solution later
+    for j=1:n
+        for k=1:4
+           p(k)=(1/f(j,k))/sum(1./f(j,:));
+        end
+        a=rand;
+        for m=1:4
+            if a<=sum(p(1:m))
+                solutions(i,j)=(rand+m-1)/4;
+                f(j,m)=f(j,m)+1;
+                break
+            end
+        end
+    end
+end
+
+%Put the variables inside the bounds
+a=repmat(x_U-x_L,[ndiverse,1]);
+b=repmat(x_L,[ndiverse,1]);
+
+
+solutions=solutions.*a+b;
+
+fx=solutions;
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/ssm_evalfc.m b/Requirements/MEIGO/eSS/ssm_evalfc.m
new file mode 100644
index 0000000000000000000000000000000000000000..7c2c1916305a3b25b22fd7bb4fe275f877a6c1ca
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_evalfc.m
@@ -0,0 +1,57 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_evalfc.m 1080 2013-11-08 12:17:11Z davidh $
+function [value,value_penalty,pena,nlc,include,x] = ssm_evalfc(x,x_L,x_U,fobj,nconst,c_L,c_U,...
+    tolc,weight,int_var,bin_var,varargin)
+
+include=1;
+
+%Transform into a row
+if size(x,2)==1
+    
+    x=x';
+    
+end
+
+
+if (int_var) || (bin_var)
+    
+    x=ssm_round_int(x,int_var+bin_var,x_L,x_U);
+    
+end
+
+%Adjust to bounds
+lower=find(x<x_L);
+upper=find(x>x_U);
+
+x(lower)=x_L(lower);
+x(upper)=x_U(upper);
+
+if nconst
+    
+    [value,nlc]=feval(fobj,x,varargin{:});
+    
+    %Transform into a row
+    if size(nlc,2)==1
+        
+        nlc=nlc';
+        
+    end
+    
+    pena=ssm_penalty_function(x,nlc,c_L,c_U,tolc);
+    value_penalty=value+weight*pena;
+       
+else
+    
+    value=feval(fobj,x,varargin{:});
+    nlc=0;
+    pena=0;
+    value_penalty=value;
+    
+end
+
+if isinf(value) || isnan(value)
+    
+    include=0;
+    
+end
+
+return
diff --git a/Requirements/MEIGO/eSS/ssm_isdif2.m b/Requirements/MEIGO/eSS/ssm_isdif2.m
new file mode 100644
index 0000000000000000000000000000000000000000..9c2a142517f93a2fd7d98dbb283ad0162cffdabd
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_isdif2.m
@@ -0,0 +1,29 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_isdif2.m 770 2013-08-06 09:41:45Z attila $
+function [f,ind,ind2]=isdif2(x,group,tol,flag)
+f=0;
+ind=[];
+ind2=[];
+
+for i=1:size(group,1)
+    num=abs(x-group(i,:));
+    denom=min([abs(x); abs(group(i,:))]);
+    denom(abs(denom)<eps)=1;
+    diference=num./denom;
+    aaa=find(diference>=tol);
+    
+    if flag==1
+        if isempty(aaa)
+            f=f+1;
+            ind=[ind i];
+        end
+    elseif flag==2
+        if length(aaa)~=length(x)
+            %If this happens, not all the variables comply with the
+            %tolerance
+            ind=[ind i];
+        else
+            ind2=[ind2 i];
+        end
+    end
+end
+return
diff --git a/Requirements/MEIGO/eSS/ssm_local_filters.m b/Requirements/MEIGO/eSS/ssm_local_filters.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3816883f2062b93bd840f2e463a3a9e4be0fbea
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_local_filters.m
@@ -0,0 +1,285 @@
+% BUG FIXED JUNE-2014 - JRB
+
+if stage_1==1
+    %                         Aplicamos el solver local sobre el mejor
+    %                         de los hijos, incluidos los del Refset.
+    [minimo,I]=min(child_values_penalty);
+    Threshold=min(minimo,fbest);
+    if minimo<fbest
+        x0=child(I,:);
+        f0=minimo;
+    else
+        x0=xbest;
+        f0=fbest;
+    end
+    apto=2;
+    %Pasamos al stage 2
+    n_critico=local_n2;
+    %Llamamos al solver local
+
+elseif stage_2==1;
+    if local_bestx
+        apto=2;
+        if use_local
+            x0=xbest;
+            f0=fbest;
+        else
+            apto=0;
+        end
+    else
+        %Tenemos que ver si pasa los filtros
+        %De momento decimos que el punto no pasa
+        %los filtros
+        apto=0;
+
+        %Si el filtro de merito esta activado
+        if merit_filter
+            if child_values_penalty(k)<Threshold
+                wait_Threshold=0;
+                apto=apto+1;
+            else
+                wait_Threshold=wait_Threshold+1;
+                if wait_Threshold==wait_th_limit;
+                    Threshold=Threshold+thfactor*(1.0+abs(Threshold));
+                    wait_Threshold=0;
+                end
+            end
+            %Si no esta activado, directamente pasa
+        else
+            apto=apto+1;
+        end
+
+        %Asi hemos hecho independientes el filtro de
+        %merito y el de distancia. Antes los tenia como
+        %dependientes. Si no pasaba el de merito no
+        %evaluaba el de distancia
+
+
+        %Vamos a por el filtro de la distancia
+        if distance_filter
+            lejano=0;
+            for m=1:size(local_solutions,1)
+                %Hallamos la distancia entre el punto y las soluciones
+                separacion=norm((child(k,:)-local_solutions(m,1))./(x_U-x_L));
+                %Si la separacion al minimo es mayor que maxdist para
+                %ese minimo
+                if  separacion>maxdist(m)
+                    lejano=lejano+1;
+                    %Reseteamos la espera para ese
+                    %minimo
+                    wait_maxdist(m)=0;
+                else
+                    wait_maxdist(m)=wait_maxdist(m)+1;
+                    %disp('NO pasa filtro de la distancia')
+                    if wait_maxdist(m)==wait_maxdist_limit;
+                        maxdist(m)=maxdist(m)*(1-maxdistfactor);
+                        wait_maxdist(m)=0;
+                    end
+                    break
+                end
+            end
+            if lejano==size(local_solutions,1)
+                %disp('Pasa filtro de la distancia')
+                apto=apto+1;
+            end
+            %Si no esta activado, pasamos de el
+        else
+            apto=apto+1;
+        end
+        %Vemos si esa solucion la tenemos
+        %ya porque podria ser que
+        %iniciaramos el local solver con x0
+        %y ya tuvieramos alguna
+        if apto==2
+            x0=child(k,:);
+            f0=child_values_penalty(k);
+        end
+    end
+end
+if apto==2
+    n_minimo=0;
+
+    if iterprint
+        fprintf('Call local solver: %s \n', upper(local_solver))
+        fprintf('Initial point function value: %f \n',f0);
+
+        tic
+    end
+    if isFjacDefined
+        [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,fjac,...
+            local_solver,local_iterprint,local_tol,weight,nconst,tolc,opts.local,varargin{:});
+    else
+        [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,[],...
+            local_solver,local_iterprint,local_tol,weight,nconst,tolc,opts.local,varargin{:});
+    end
+    if iterprint
+        fprintf('Local solution function value: %f \n',fval);
+        fprintf('Number of function evaluations in the local search: %i \n',numeval);
+        fprintf('CPU Time of the local search: %f  seconds \n\n',toc);
+    end
+
+    %Ojo, que solnp no da el numero de evaluaciones
+    %de funcion
+
+    nfuneval=nfuneval+numeval;
+
+% BUG FIXED JUNE-2014 - JRB - IF BLOCK BELOW REMOVED
+%    if stage_1==1
+%        stage_1=0;
+%        stage_2=1;
+%    end
+
+    %Evaluate the local solution
+    [val,val_penalty,pena,nlc,include,x] = ssm_evalfc(x,x_L,x_U,fobj,nconst,c_L,c_U,...
+        tolc,weight,int_var,bin_var,varargin{:});
+    nfuneval=nfuneval+1;
+    if include & pena<=tolc
+	% BUG FIXED JUNE-2014 - JRB INCLUDING IF BLOCK LINE BELOW
+	if stage_1==1, stage_1=0; stage_2=1; end
+        if val_penalty<fbest
+            fbest=val_penalty;
+            xbest=x;
+            if fbest<fbest_lastiter
+                Results.f=[Results.f fbest];
+                Results.x=[Results.x; xbest];
+                Results.time=[Results.time cputime-cpu_time];
+                Results.neval=[Results.neval nfuneval];
+                if plot_results==1
+                    stairs(Results.time,Results.f)
+                    xlabel('CPU Time (s)');
+                    ylabel('Objective Function Value (-)');
+                    title(strcat('Best f:  ',num2str(fbest)))
+                    drawnow
+                end
+            end
+        end
+
+
+
+        %Chequeamos el criterio de parada
+        if nfuneval>= maxeval
+            fin=1;
+            blacklist=ones(dim_refset);
+            break
+        elseif cputime-cpu_time>=maxtime
+            fin=2;
+            blacklist=ones(dim_refset);
+            break
+        elseif not(isempty(vtr))
+            if fbest<=vtr
+                fin=3;
+                blacklist=ones(dim_refset);
+                break
+            end
+        end
+
+
+
+
+
+        %A�adimos ese valor a los hijos
+
+        child=[child;x];
+
+        if nconst
+            [fffff,ggggg]=feval(fobj,x,varargin{:});
+        else
+            fffff=feval(fobj,x,varargin{:});
+            ggggg=0;
+        end
+
+        child_values=[child_values;fffff];
+
+        if size(ggggg,2)==1
+            ggggg=ggggg';
+        end
+
+        child_nlc=[child_nlc;ggggg];
+
+        nfuneval=nfuneval+1;
+
+        child_penalty=[child_penalty;ssm_penalty_function(x,child_nlc(k,:),c_L,c_U,tolc)];
+        child_values_penalty=[child_values_penalty;child_values(k)+weight*child_penalty(k)];
+
+
+        %A�adimos ese valor a los hijos. Habra que
+        %a�adir la opcion de que esto no sea asi
+        %Sustituimos a su padre
+
+        %En posteriores versiones habra que ver
+        %si compensa que el hijo mejorado
+        %reemplace al padre o si por el
+        %contrario se a�ade para que se
+        %combinen juntos.
+
+        %El nuevo Threshold pasa a ser el minimo
+        %obtenido.
+        if fval<Threshold
+            Threshold=fval;
+        end
+
+        if not(isempty(local_solutions))
+            %Vamos a ver si esa solucion ya la
+            %teniamos
+            %En principio decimos que es un nuevo
+            %local
+            adicionar_local=1;
+            %Comprobamos si ese minimo ya lo
+            %tenemos
+            [f,ind]=ssm_isdif2(x,local_solutions,1e-2,1);
+            %Si esta cerca de alguno
+            %actualizamos las distancias
+            if f
+                for i=length(ind)
+                    %Si es el mismo minimo
+                    %Actualizamos el maxdist para ese minimo
+                    maxdist(ind(i))=norm((child(k,:)-local_solutions(ind(i),:))./(x_U-x_L));
+                    %Y no a�adimos a la lista de
+                    %minimos puesto que ya lo
+                    %tenemos
+                    adicionar_local=0;
+                    %Una vez sabemos que es uno de
+                    %los que tenemos, ya podemos
+                    %salir del bucle for. No va a
+                    %ser ninguno de los otros si el
+                    %filtro esta bien hecho
+                    %break
+                end
+            end
+
+        else
+            %Si no habia ninguna solucion local, se
+            %a�ade
+            adicionar_local=1;
+        end
+        %Si tenemos que a�adir a la lista de
+        %soluciones locales, lo hacemos
+        if adicionar_local==1
+            local_solutions=[local_solutions;x];
+            local_solutions_values=[local_solutions_values;fval];
+            maxdist=[maxdist;norm((child(k,:)-x)./(x_U-x_L))];
+            wait_maxdist=[wait_maxdist; 0];
+        end
+        %Tanto si hemos a�adido minimos locales
+        %como si hemos actualizado las maxdist
+        %Vamos a chequear si las maxdist se
+        %solapan, siempre y cuando el filtro de la
+        %distancia este activado, porque si no no
+        %tiene sentido
+        if distance_filter
+            nlocals=size(local_solutions,1);
+            if nlocals>1
+                ncomb_local=nchoosek(1:nlocals,2);
+                number_of_comb=(nlocals^2-nlocals)/2;
+                for i=1:number_of_comb
+                    index=ncomb_local(i,:);
+                    ecart=norm((local_solutions(index(1),:)-local_solutions(index(2),:))./(x_U-x_L));
+                    while ecart<maxdist(index(1))+maxdist(index(2))
+                        maxdist(index(1))=0.9*maxdist(index(1));
+                        maxdist(index(2))=0.9*maxdist(index(2));
+                    end
+                end
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/ssm_localsolver.m b/Requirements/MEIGO/eSS/ssm_localsolver.m
new file mode 100644
index 0000000000000000000000000000000000000000..1f3077274c9bdd768a40c121c87769adef11e262
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_localsolver.m
@@ -0,0 +1,995 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_localsolver.m 2031 2015-08-24 11:49:26Z attila $
+function [x,fval,exitflag,numeval]=ssm_localsolver(X0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,fjac,...
+    local_solver,local_iterprint,local_tol,weight,nconst,tolc,local_opts,varargin)
+global ccll ccuu n_upper n_lower n_fun_eval
+
+global hjfun hjxl hjxu hjcl hjcu hjweight hjtolc
+hjfun=fobj;
+hjxl=x_L;
+hjxu=x_U;
+hjcl=c_L;
+hjcu=c_U;
+hjweight=weight;
+hjtolc=tolc;
+
+nvar=length(X0);
+
+%Scaling factors (can be useful for some local solvers). This could be
+%defined just once in the main ssm.m
+scale.x=x_U-x_L;
+
+f1=feval(fobj,X0,varargin{:});
+n_fun_eval=1;
+if nconst
+    g_u=c_U;
+    g_l=c_L;
+    
+    g_l(abs(g_l)==inf)=1;
+    g_u(abs(g_u)==inf)=1;
+    
+    g_l=abs(g_l);
+    g_u=abs(g_u);
+    
+    scale.g=max(g_l,g_u);
+else
+    scale.g=1;
+end
+
+if abs(f1)==inf || isnan(f1)
+    scale.f=1;
+else
+    scale.f=f1;
+end
+
+
+
+
+
+
+switch local_solver
+    case 'clssolve'
+        %clssolve
+        %no acepta restricciones lineales de igualdad
+        Prob = clsAssign(fobj, [], [], x_L, x_U, 'test', X0, ...
+            [], [], 0, [],[],[],...
+            [],[],[],nlc_fun,[],[],c_L,c_U);
+        %Prob.optParam.MaxIter=50;
+        
+        if local_iterprint, Prob.PriLevOpt = 2; end
+        
+        switch local_tol
+            case 1
+                Prob.optParam.eps_f=tolc*100;
+                Prob.optParam.eps_x=tolc*100;
+                Prob.optParam.eps_c=tolc*100;
+            case 2
+                Prob.optParam.eps_f=tolc;
+                Prob.optParam.eps_x=tolc;
+                Prob.optParam.eps_c=tolc;
+            case 3
+                Prob.optParam.eps_f=tolc/100;
+                Prob.optParam.eps_x=tolc/100;
+                Prob.optParam.eps_c=tolc/100;
+        end
+        
+        
+        Result=tomrun('clssolve',Prob);                        %Aplicamos el solver
+        
+        
+        x=Result.x_k';
+        fval=Result.r_k;
+        numeval=Result.ResEv;
+        %if Result.Iter<Prob.optParam.MaxIter
+        exitflag=1;
+        %else
+        %   exitflag=0;
+        %end
+        
+    case 'snopt'
+        %snopt
+        
+        %no acepta restricciones lineales de igualdad
+        
+        
+        Prob = simAssign(fobj, [], [], [], x_L, x_U, [], X0, ...
+            [], [], [], [], [], c_L, c_U);
+        
+        
+        
+        %                             Prob = conAssign(fobj, [], [], [],x_L, x_U, 'Test', X0,...
+        %         [],[],[],[],[],nlc_fun,[],[],[],c_L,c_U);
+        %
+        Prob.NumDiff=6;
+        %Prob.optParam.MaxIter=250;
+        
+        if local_iterprint, Prob.PriLevOpt = 2; end;
+        
+        switch local_tol
+            case 1
+                Prob.optParam.eps_f=tolc*100;
+                Prob.optParam.eps_x=tolc*100;
+                Prob.optParam.eps_c=tolc*100;
+            case 2
+                Prob.optParam.eps_f=tolc;
+                Prob.optParam.eps_x=tolc;
+                Prob.optParam.eps_c=tolc;
+            case 3
+                Prob.optParam.eps_f=tolc/100;
+                Prob.optParam.eps_x=tolc/100;
+                Prob.optParam.eps_c=tolc/100;
+        end
+        
+        Result=tomrun('snopt',Prob);                        %Aplicamos el solver
+        
+        x=Result.x_k';
+        fval=Result.f_k;
+        numeval=Result.FuncEv;
+        
+        %if Result.MinorIter<Prob.optParam.MaxIter
+        exitflag=1;
+        %else
+        %exitflag=0;
+        %end
+        
+        
+    case 'nomad'
+        %nomadm
+        global params
+        params=varargin;
+        nvar=length(X0);
+        problem_path=pwd;
+        %Fichero con el punto inicial
+        fid=fopen('fobj_nomad_x0.m','w');
+        fprintf(fid,'function iterate= fobj_nomad_x0\n');
+        fprintf(fid,'iterate(1).x= [');
+        for i=1:size(X0,2)
+            fprintf(fid,' %g;',X0(i));
+        end
+        fprintf(fid,' ];\n');
+        fprintf(fid,'iterate(1).p= {};\n');
+        fclose(fid);
+        
+        switch local_tol
+            case 1
+                tol_nomad=tolc*100;
+            case {2,3}
+                tol_nomad=tolc*10;
+                %             case 3
+                %                 tol_nomad=tolc;
+        end
+        if local_iterprint
+            close;
+        end
+        [BestF,BestI,RunStats,RunSet]=mads_batch(problem_path,tol_nomad,nvar,length(n_lower)+length(n_upper),local_iterprint);
+        clear('fobj_nomad_x0.m');
+        
+        
+        if ~isempty(BestF)
+            x=BestF.x';
+            fval=BestF.f;
+            exitflag=1;
+        else
+            x=X0;
+            fval=inf;
+            exitflag=-1;
+        end
+        
+        
+        numeval=RunStats.nFunc;
+        %if numeval<1000
+        
+        %else
+        %exitflag=0;
+        %end
+        %keyboard
+        
+        
+    case 'npsol'
+        %npsol
+        %no acepta restricciones lineales de igualdad
+        
+        Prob = simAssign(fobj, [], [], [], x_L, x_U, [], X0, ...
+            [], [], [], [], [], c_L, c_U);
+        %     Prob = conAssign, [], [], [],x_L, x_U, 'Test', X0,...
+        %         [],[],[],[],[],nlc_fun,[],[],[],c_L,c_U);
+        
+        %Prob.optParam.MaxIter=250;
+        
+        %Prob.PriLevOpt = 2;
+        Prob.NumDiff=6;
+        if local_iterprint, Prob.PriLevOpt = 2; end;
+        
+        switch local_tol
+            case 1
+                Prob.optParam.eps_f=tolc*100;
+                Prob.optParam.eps_x=tolc*100;
+                Prob.optParam.eps_c=tolc*100;
+            case 2
+                Prob.optParam.eps_f=tolc;
+                Prob.optParam.eps_x=tolc;
+                Prob.optParam.eps_c=tolc
+            case 3
+                Prob.optParam.eps_f=tolc/100;
+                Prob.optParam.eps_x=tolc/100;
+                Prob.optParam.eps_c=tolc/100;
+        end
+        
+        
+        Result=tomrun('npsol',Prob);                        %Aplicamos el solver
+        
+        x=Result.x_k';
+        fval=Result.f_k;
+        numeval=Result.FuncEv;
+        
+        %if Result.MinorIter<Prob.optParam.MaxIter
+        exitflag=1;
+        %else
+        %exitflag=0;
+        %end
+        
+        
+        
+    case 'solnp'
+        %solnp
+        %Fichero con el punto inicial
+        
+        cl=c_L;
+        cu=c_U;
+        
+        cl(1:neq)=[];
+        cu(1:neq)=[];
+        
+        aaa=find(X0==x_L);
+        bbb=find(X0==x_U);
+        X0(aaa)=X0(aaa)+0.001*abs(X0(aaa))+1e-10;
+        X0(bbb)=X0(bbb)-0.001*abs(X0(bbb))-1e-10;
+        
+        xxb=[X0' x_L' x_U'];
+        
+        lh=cl';
+        uh=cu';
+        
+        
+        lh(find(lh==-inf))=-1e5;
+        uh(find(uh==inf))=1e5;
+        
+        ib=[lh uh];
+        
+        if isempty(ib)
+            ib=0;
+        end
+        ro=1;
+        %Parece que aumentando las iteraciones menores afina mas, aunque
+        %presumiblemente va mas lento. Iria mejor para las iteraciones finales
+        maj_it=10*length(X0);
+        min_it=10;
+        
+        if local_tol==1
+            delta=1e-5;
+            epsilon=tolc*10;
+        elseif local_tol==2
+            delta=1e-5;
+            epsilon=tolc;
+        elseif local_tol==3
+            delta=1e-5;
+            epsilon=tolc/10;
+        end
+        
+        
+        
+        op=[ro maj_it min_it 0 delta epsilon];
+        
+        %         [x,oh]=solnp(xxb,ib,op);
+        %         x=x';
+        %         fval=oh(end);
+        %         numeval=n_fun_eval;
+        %         exitflag=1;
+        %
+        
+        [y1,oh,flag,inc,lambda,hess]=solnp(@snpfun,xxb,ib,op,[],[],local_iterprint,fobj,scale,nconst,varargin{:});
+        x=y1';
+        fval=oh(end);
+        numeval=n_fun_eval;
+        exitflag=flag;
+        
+    case 'nl2sol'
+        % nl2sol of OPTI Toolbox
+        
+        % gradient calculation of the residual:
+        if isempty(fjac)
+            % if no Jacobian is comming from AMIGO but
+            % ess_options orders to use mkl
+            if strcmpi(local_opts.nl2sol.grad,'mkl')
+                fjac = @(x) mklJac(@objf_nl2sol,x,ndata);
+                local_opts.nl2sol = rmfield(local_opts.nl2sol,'grad');
+            else
+                % neither the jacobian is given and the default is not mkl
+                fjac = [];
+                % NL2sol will use internal Finite Differences
+            end
+        else
+            % we already wrote the file fjac_nl2sol containing the
+            % interface to the external jacobian (AMIGO_PEjac)
+            fjac = @fjac_nl2sol;
+        end
+        
+        [x, fval,exitflag]=feval(@call_nl2sol,X0,fjac, ndata, x_L, x_U,local_opts.nl2sol);
+        
+        numeval=n_fun_eval+1;
+        
+    case {'n2fb','dn2fb'}
+        %n2fb
+        x=feval(@call_n2fb,X0, ndata, length(x_U), x_L, x_U,local_solver);
+        fval=feval(fobj,x,varargin{:});
+        exitflag=1;
+        numeval=n_fun_eval+1;
+        
+    case 'lbfgsb'
+        % lbfgsb of OPTI Toolbox
+        
+        % gradient calculation of the residual:
+        if isempty(fjac)
+            if strcmpi(local_opts.lbfgsb.grad,'mkl')
+                
+                fjac = @(x) mklJac(@objf_lbfgsb,x,1);
+                local_opts.lbfgsb = rmfield(local_opts.lbfgsb,'grad');
+            else
+                fjac = [];
+            end
+        else
+            fjac = @fjac_lbfgsb;
+        end
+        
+        [x, fval,exitflag]=feval(@call_lbfgsb,X0,fjac, x_L, x_U,local_opts.lbfgsb);
+        
+        numeval=n_fun_eval+1;
+    case 'dhc'
+        %dhc
+        nvar=numel(X0);
+        X0=(X0-x_L)./(x_U-x_L);
+        
+        %initsize=max((x_U-x_L)/2);
+        initsize=0.1;
+        
+        
+        if local_tol==1
+            thres=1e-6;
+        elseif local_tol==2
+            thres=1e-8;
+        elseif local_tol==3
+            thres=1e-10;
+        end
+        
+        [fval,x,numeval]=dhc(fobj,X0,initsize,thres,100*nvar,x_L,x_U,weight,c_L,c_U,local_iterprint,tolc,varargin{:});
+        exitflag=1;
+        
+    case 'ydhc'
+        % adapted implementation of dhc algorithm
+        
+        nvar = numel(X0);
+        
+        if local_tol == 1
+            thres = 1e-6;
+        elseif local_tol == 2
+            thres = 1e-8;
+        else % local_tol == 3
+            thres = 1e-10;
+        end
+        
+        options.MaxFunEvals = 100*nvar;
+        options.TolX = thres;
+        options.TolFun = thres;
+        
+        if local_iterprint
+            options.Display = 'iter';
+        else
+            options.Display = 'off';
+        end
+        
+        fun = @(x) feval(fobj, x, varargin{:});
+        
+        [x, fval, exitflag, output] = ydhc(fun, X0, x_L, x_U, options);
+        numeval = output.funcCount;
+        
+    case 'bobyqa'
+        % matlab interface to Powell's bobyqa algorithm for
+        % bound-constrained optimization
+        
+        nvar = numel(X0);
+        
+        options.MaxFunEvals = 100 * nvar;
+        
+        fun = @(x) feval(fobj, x, varargin{:});
+        [x, fval, exitflag, output] = bobyqa(fun, X0, x_L, x_U, options);
+        numeval = output.funcCount;
+        
+    case 'fsqp'
+        %fsqp
+        mode=110;
+        
+        iprint=0;   %Other values do not work
+        
+        nf=1;
+        
+        
+        nineqn=length(n_upper)+length(n_lower);
+        nineq=nineqn;
+        
+        neqn=neq;
+        neq=neqn;
+        
+        
+        miter=400;
+        
+        bigbnd=1e10;
+        bl=x_L;
+        bu=x_U;
+        
+        x0=X0';
+        
+        udelta=0;
+        
+        if local_tol==1
+            tol1=tolc*100;
+        elseif local_tol==2
+            tol1=tolc;
+        elseif local_tol==3
+            tol1=tolc/100;
+        end
+        
+        tol2=tol1;
+        
+        if nineq==0 && neq==0
+            constr_file='';
+        else
+            constr_file='constr_fsqp';
+        end
+        
+        [x,fval,g,lambda,info] = fsqp(mode,iprint,'fobj_fsqp',constr_file,'','',...
+            nf,nineqn,nineq,neqn,neq,miter,udelta,bigbnd,...
+            bl,bu,x0,tol1,tol2);
+        
+        
+        numeval=n_fun_eval;
+        x=x';
+        
+        if info==1 |info==2 |info==5 |info==6 | info==7 |info==9
+            exitflag=0;
+        else
+            exitflag=1;
+            
+        end
+        
+        
+    case 'ipopt'
+        global params
+        
+        params=varargin;
+        
+        
+        % The starting point.
+        x0  = X0;  % The starting point.
+        lb  = x_L;  % Lower bound on the variables.
+        ub  = x_U;  % Upper bound on the variables.
+        
+        
+        
+        if isempty(c_U) & not(neq);
+            nlc_fun='';
+            nlc_jac='';
+            lbc = [];   % Lower bounds on the constraint functions.
+            ubc = [];   % Upper bounds on the constraint functions.
+            
+        else
+            nlc_fun=@ipopt_c;
+            nlc_jac=@eval_j_ipopt;
+            lbc = c_L;   % Lower bounds on the constraint functions.
+            ubc = c_U;   % Upper bounds on the constraint functions.
+        end
+        
+        if local_iterprint
+            dsp=5;
+        else
+            dsp=2;
+        end
+        
+        [status x] = ipopt(x0,lb,ub,lbc,ubc,@ipopt_f,...
+            @eval_g_ipopt,nlc_fun,...
+            nlc_jac,'',[],'',[],'hessian_approximation','limited-memory',...
+            'mu_strategy','adaptive',...                 % Update strategy for barrier parameter ['adaptive','monotone']
+            'print_user_options','no',...                % Print all options set by the user
+            'print_level',dsp,...                         % Output verbosity level [2 <= 5 <= 12 ]
+            'nlp_scaling_method','gradient-based',...       % select the technique used for scaling the NLP ['none','user-scaling','gradient-based','equilibration-based']
+            'print_options_documentation','no',...       % Switch to print all algorithmic options ['yes','no']
+            'acceptable_dual_inf_tol',tolc,...% "Acceptance" threshold for the dual infeasibility [0 < 1e+10 < +inf]
+            'acceptable_constr_viol_tol',tolc,... % "Acceptance" threshold for the constraint violation [0 < 0.01 < +inf]
+            'max_iter',100,...                   % Maximal number of iterations allowed (Integer, >=0)
+            'ma27_pivtol',tolc,...            % Pivot tolerance for the linear solvers [0 < 1e-08 < 1]
+            'tol',tolc,...                    % Desired error tolerance (Double Precision, >0d0)[0 < 1e-08 < +inf]
+            'acceptable_tol',tolc,...         % "Acceptable" convergence tolerance (relative) (Double Precision, >0d0) [0 < 1e-06 < +inf]
+            'mu_init',1e-8,...                           % Initial value for the barrier parameter     [0 < 0.1 < +inf]
+            'mu_min',tolc,...                 % Minimum value for barrier parameter [0 < 1e-11 < +inf]
+            'bound_push',tolc,...             % Desired minimum absolute distance from the initial point to bound [0 < 0.01 < +inf]
+            'bound_frac',tolc,...
+            'derivative_test', 'none',...     % enable derivative checker ['none','first-order','second-order']);               % desired minimum relative distance from the initial point to bound [0 < 0.01 <= 0.5]
+            'check_derivatives_for_naninf','no');    %Indicates whether it is desired to check for Nan/Inf in derivative matrices ['no','yes']
+        
+        
+        
+        fval=feval(fobj,x,varargin{:});
+        exitflag=1;
+        numeval=n_fun_eval+1;
+        
+    case 'misqp'
+        
+        ncont=length(X0)-int_var-bin_var;
+        nint=int_var;
+        nbin=bin_var;
+        n=nint+ncont+nbin;
+        m=length(n_upper)+length(n_lower)+neq;
+        
+        
+        xl=x_L;
+        xu=x_U;
+        x0=X0;
+        
+        switch local_tol
+            case 1
+                acc=tolc*100;
+            case 2
+                acc=tolc;
+            case 3
+                acc=tolc/100;
+        end
+        
+        [x,fval,nfunc,ifail,g]=run_misqp(ncont,nint,nbin,m,xl,xu,x0,acc,@fobj_misqp,neq,fobj,varargin{:});
+        
+        
+        if ~isnan(fval) & ~isinf(fval) & all(g>=-tolc)
+            exitflag=1;
+        else
+            exitflag=-1;
+        end
+        
+        %        switch ifail
+        %            case 0
+        %                exitflag=1;
+        %            case 4
+        %                exitflag=-1;
+        %            otherwise
+        %                if all(g>=tolc)
+        %                    exitflag=1;
+        %                else
+        %                    exitflag=-1;
+        %                end
+        %        end
+        numeval=n_fun_eval;
+        
+        
+    case 'fminsearch'
+        switch local_tol
+            case 1
+                tolx=tolc*100;
+                tolf=tolc*100;
+            case 2
+                tolx=tolc;
+                tolf=tolc;
+            case 3
+                tolx=tolc/100;
+                tolf=tolc/100;
+            case 4
+                tolx=tolc/10000;
+                tolf=tolc/10000;
+        end
+        
+        if local_iterprint
+            dsp='iter';
+        else
+            dsp='off';
+        end
+        
+        nvar=length(X0);
+        
+        options=optimset('LargeScale','off','Display',dsp,'Tolx',tolx,'TolFun',tolf,'MaxFunEvals',200*nvar,'MaxIter',1000*nvar);
+        
+        %[x,fval,exitflag,OUTPUT]=fminsearch(@fmobj,X0,options,fobj,[]);
+        
+        %[x,fval,exitflag,OUTPUT]=fminsearchbnd(@fmobj,X0,x_L,x_U,options,fobj,[],varargin{:});
+        [x,fval,exitflag,OUTPUT]=fminsearchbnd(@fminsobj,X0,x_L,x_U,options,fobj,c_L,c_U,weight,tolc,varargin{:});
+        numeval=n_fun_eval;
+        
+        
+    case 'constrnew'
+        switch local_tol
+            case 1
+                options(2)=tolc*100;
+                options(3)=tolc*100;
+                options(4)=tolc*100;
+            case 2
+                options(2)=tolc*1000;
+                options(3)=tolc*1000;
+                options(4)=tolc*1000;
+            case 3
+                options(2)=tolc/100;
+                options(3)=tolc/100;
+                options(4)=tolc/100;
+            case 4
+                options(2)=tolc/10000;
+                options(3)=tolc/10000;
+                options(4)=tolc/10000;
+        end
+        
+        options(2)=1e-4;
+        options(3)=1e-4;
+        options(4)=tolc;
+        
+        
+        if local_iterprint
+            options(1)=1;
+        else
+            options(1)=-1;
+        end
+        
+        options(13)=neq;
+        
+        nvar=length(X0);
+        
+        
+        [x,OPTIONS,exitflag]=constrnew(@constr_obj,X0,options,x_L,x_U,[],fobj,neq,varargin{:});
+        fval=OPTIONS(8);
+        numeval=n_fun_eval;
+        
+        
+        
+    case 'lsqnonlin'
+        switch local_tol
+            case 1
+                tolx=tolc;
+                tolf=tolc;
+            case 2
+                tolx=tolc/100;
+                tolf=tolc/100;
+            case 3
+                tolx=tolc/1000;
+                tolf=tolc/1000;
+            case 4
+                tolx=tolc/100000;
+                tolf=tolc/100000;
+        end
+        
+        if local_iterprint
+            dsp='iter';
+        else
+            dsp='off';
+        end
+        
+        nvar=length(X0);
+        
+        % This set of options also works well
+        %options=optimset('LargeScale','off','LevenbergMarquardt','off','LineSearchType','cubicpoly','Display',dsp,'Tolx',tolx,'TolFun',tolf);%,'MaxFunEvals',100*nvar);
+        
+        
+        
+        %If the solution goes beyond the bounds, use this set of options
+        %         options=optimset('Display',dsp,'Tolx',tolx,'TolFun',tolf);%,'MaxFunEvals',100*nvar);
+        
+        % [x,resnorm,residual] = lsqnonlin(@lsqnonlin_fobj,X0,[],[],options,fobj,varargin{:});
+        
+        % This set of options (with largescale=on) to use the bounds
+        if isempty(fjac)
+            options=optimset('LargeScale','on','Display',dsp,'Tolx',tolx,'TolFun',tolf,'MaxIter',200);
+        else
+            % Jacobian is on:
+            options=optimset('Jacobian','on','LargeScale','on','Display',dsp,'Tolx',tolx,'TolFun',tolf,'MaxIter',200);
+        end
+        fval=feval(fobj,X0,varargin{:});
+        if isfinite(fval)
+            [x,resnorm,residual] = lsqnonlin(@lsqnonlin_fobj,X0,x_L,x_U,options,fobj,fjac,varargin{:});
+        else
+            x = nan(size(X0));
+            resnorm = inf;
+            residual = [];
+        end
+        exitflag=1;
+        fval=feval(fobj,x,varargin{:});
+        numeval=n_fun_eval;
+        
+    case 'hooke'
+        
+        [x, histout] = hooke(X0', @hjobj,200*length(X0),tolc,local_iterprint,varargin{:});
+        x=x';
+        fval=histout(end,2);
+        
+        numeval=n_fun_eval;
+        %        numeval=histout(end,1);
+        
+        exitflag=1;
+        
+    case 'fmincon'
+        
+        if isempty(c_U)
+            const_fun=[];
+        else
+            const_fun=@fmcon;
+        end
+        
+        switch local_tol
+            case 1
+                tolx=tolc*100;
+                tolf=tolc*100;
+                tolg=tolc*100;
+            case 2
+                tolx=tolc;
+                tolf=tolc;
+                tolg=tolc;
+            case 3
+                tolx=tolc/100;
+                tolf=tolc/100;
+                tolg=tolc/100;
+            case 4
+                tolx=tolc/10000;
+                tolf=tolc/10000;
+                tolg=tolc/10000;
+        end
+        % tolf=1e-9;
+        % tolx=1e-9;
+        if local_iterprint
+            dsp='iter';
+        else
+            dsp='off';
+        end
+        %DW
+        if local_opts.use_gradient_for_finish == 0
+            
+            options=optimset('LargeScale','off','Display',dsp,'Tolx',tolx,'TolFun',tolf,'Tolcon',tolg,'MaxSQPIter',100*length(X0),'MaxFunEvals',200*nvar,'MaxIter',200*nvar);
+            
+            [x,fval,exitflag,OUTPUT]=fmincon(@fmobj,X0,[],[],[],[],x_L,x_U,const_fun,options,fobj,neq,varargin{:});
+            
+        else
+            
+            %DW: provide gradient information
+            if local_opts.check_gradient_for_finish
+                options=optimset('LargeScale','off','Display',dsp,'Tolx',tolx,'TolFun',tolf,'Tolcon',tolg,'MaxSQPIter', ...
+                    100*length(X0),'MaxFunEvals',200*nvar,'MaxIter',200*nvar, ...
+                    'GradObj', 'on', 'DerivativeCheck', 'on'); %, 'SpecifyConstraintGradient', true);
+            else
+                options=optimset('LargeScale','off','Display',dsp,'Tolx',tolx,'TolFun',tolf,'Tolcon',tolg,'MaxSQPIter', ...
+                    100*length(X0),'MaxFunEvals',200*nvar,'MaxIter',200*nvar, ...
+                    'GradObj', 'on'); %, 'SpecifyConstraintGradient', true);
+            end
+            
+            [x,fval,exitflag,OUTPUT]=fmincon(@fmobjgrad,X0,[],[],[],[],x_L,x_U,const_fun,options,fobj,neq,varargin{:});
+            
+        end
+        
+        numeval=n_fun_eval;
+        
+    otherwise
+        error(['Local solver ' local_solver ' not recognized.']);
+        
+end
+% make sure x is a row vector.
+x = x(:).';
+
+%\-----------------------------------------------------/
+% Definition of constraints for constrnew
+function [f,g] = constr_obj(x,fun,neq,varargin)
+global n_fun_eval n_upper n_lower ccll ccuu
+
+[f,ggg] = feval(fun,x,varargin{:});
+
+g=ggg(1:neq);
+
+ninequ=length(n_upper);
+for i=1:ninequ
+    g=[g ggg(n_upper(i))-ccuu(n_upper(i))];
+end
+
+nineql=length(n_lower);
+for j=1:nineql
+    g=[g ccll(n_lower(j))-ggg(n_lower(j))];
+end
+
+n_fun_eval=n_fun_eval+1;
+return
+%\-----------------------------------------------------/
+
+
+
+%\-----------------------------------------------------/
+% Definition of objective for lsqnonlin
+function [fx, J] = lsqnonlin_fobj(x,fobj,fjac,varargin)
+global n_fun_eval
+
+if nargout > 1
+    [ff,g,R] = feval(fobj,x,varargin{:});
+    [GradObj,GradConstr, JacRes] = feval(fjac,x,varargin{:});
+    J = JacRes;
+else
+    [ff,g,R] = feval(fobj,x,varargin{:});
+end
+
+fx=R;
+
+n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
+
+
+
+%\-----------------------------------------------------/
+% Definition of objective for fminsearchbnd
+function fp = fminsobj(x,fun,c_L,c_U,weight,tolc,varargin)
+global n_fun_eval
+
+if isempty(who('n_fun_eval'))
+    n_fun_eval=1;
+end
+
+if ~isempty(c_L) || ~isempty(c_U)
+    [f,c] = feval(fun,x,varargin{:});
+else
+    [f] = feval(fun,x,varargin{:});
+    c=[];
+end
+
+pen=ssm_penalty_function(x,c,c_L,c_U,tolc);
+
+fp=f+weight*pen;
+
+n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
+
+
+
+%\-----------------------------------------------------/
+% Definition of objective for fmincon
+function f = fmobj(x,fun,neq,varargin)
+global n_fun_eval
+
+f = feval(fun,x,varargin{:});
+if isempty(who('n_fun_eval'))
+    n_fun_eval=1;
+end
+n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
+
+%\-----------------------------------------------------/
+% DW: Definition of objective for fmincon with gradient
+function [f,g] = fmobjgrad(x,fun,neq,varargin)
+global n_fun_eval
+
+[f, ~, g] = feval(fun,x,varargin{:});
+n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
+
+%\-----------------------------------------------------/
+% Definition of constraints for fmincon
+function [c,ceq] = fmcon(x,fun,neq,varargin)
+global n_fun_eval n_upper n_lower ccll ccuu
+
+c=[];
+ceq=[];
+[f,ggg] = feval(fun,x,varargin{:});
+
+ceq=ggg(1:neq);
+
+ninequ=length(n_upper);
+for i=1:ninequ
+    c=[c ggg(n_upper(i))-ccuu(n_upper(i))];
+end
+
+nineql=length(n_lower);
+for j=1:nineql
+    c=[c ccll(n_lower(j))-ggg(n_lower(j))];
+end
+
+n_fun_eval=n_fun_eval+1;
+return
+%\-----------------------------------------------------/
+
+
+
+%\-----------------------------------------------------/
+% Definition of objective and constraints for SOLNP
+function f = snpfun(x,par,fun,nconst)
+global n_fun_eval
+
+if nconst
+    [fobj,ci] = feval(fun,x,par{:});
+    ci = ci(:);
+else
+    [fobj] = feval(fun,x,par{:});
+    ci=[];
+end
+f = [fobj;
+    ci];
+n_fun_eval = n_fun_eval + 1;
+return
+%\-----------------------------------------------------/
+
+
+%\-----------------------------------------------------/
+% Definition of objective and constraints for misqp
+function [fx,cx]= fobj_misqp(x,neq,fobj,varargin)
+
+global n_fun_eval ccll ccuu n_upper n_lower
+
+c=[];
+
+if ~isempty(ccll) || ~isempty(ccuu)
+    [fx,ggg] = feval(fobj,x,varargin{:});
+else
+    [fx] = feval(fobj,x,varargin{:});
+    ggg=[];
+end
+n_fun_eval = n_fun_eval + 1;
+
+
+ninequ=length(n_upper);
+for i=1:ninequ
+    c=[c ccuu(n_upper(i))-ggg(n_upper(i))];
+end
+
+nineql=length(n_lower);
+for j=1:nineql
+    c=[c ggg(n_lower(j))-ccll(n_lower(j))];
+end
+
+cx=[ggg(1:neq) c];
+
+return
+%\-----------------------------------------------------/
+
+%
+% %\-----------------------------------------------------/
+% % Definition of objective for ipopt
+% function f= ipopt_f(x,Params)
+% global n_fun_eval
+% fun=str2func(Params.fun);
+% f=feval(fun,x);
+% n_fun_eval = n_fun_eval + 1;
+% return
+% %\-----------------------------------------------------/
+%
+%
+%
+% %\-----------------------------------------------------/
+% % Definition of constraints for ipopt
+% function ceq = ipopt_c(x,dummy)
+% global n_fun_eval
+% fun=str2func(dummy.fun);
+% neqc=dummy.neq;
+% nvar=dummy.nvar;
+% loc=dummy.loc;
+%
+% n_upper=loc.n_upper;
+% n_lower=loc.n_lower;
+% ccll=loc.ccll;
+% ccuu=loc.ccuu;
+%
+% [f,ggg]=feval(fun,x);
+% ceq=[];
+% ceq=[ceq ggg(1:neqc)];
+% clow=[];
+% cupp=[];
+%
+%
+% for i=1:length(n_upper)
+%     cupp=[cupp; ggg(n_upper(i))-ccuu(n_upper(i)-neqc)+x(nvar+i)];
+% end
+%
+% for j=1:length(n_lower)
+%     clow=[clow; ggg(n_lower(j))-ccll(n_lower(j)-neqc)-x(nvar+length(n_upper)+j)];
+% end
+%
+%
+% ceq=[ceq cupp clow];
+%
+% n_fun_eval=n_fun_eval+1;
+% return
+% %\-----------------------------------------------------/
+%
diff --git a/Requirements/MEIGO/eSS/ssm_mix.m b/Requirements/MEIGO/eSS/ssm_mix.m
new file mode 100644
index 0000000000000000000000000000000000000000..64d3add31bdae41b0b7964f0ff7e6d517750a000
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_mix.m
@@ -0,0 +1,33 @@
+function [method,obj_fun] = ssm_mix(i,nrun)
+
+%--------------------------------------------------------------------------
+% Define here the fraction of searches to perform with each method, and the
+% corresponding objective function:
+DHC       = 0.3; % Value between 0 and 1
+DHC_f     = 'like_MEIGO_B2'; % Objective function to use with DHC
+NL2SOL    = 0.2; % Value between 0 and 1
+NL2SOL_f  = 'likelihood_MEIGO_B2_NL2SOL'; % Objective function to use with NL2SOL
+FMINCON   = 0.5; % Value between 0 and 1
+FMINCON_f = 'like_MEIGO_B2'; % Objective function to use with FMINCON 
+
+%--------------------------------------------------------------------------
+if (DHC+NL2SOL+FMINCON ~= 1.0)
+    disp('Warning: the sum of the selected percentages of local methods is not equal to 100%. Default percentages will be assigned.')
+    % Default values:
+    DHC     = 0.3; 
+    NL2SOL  = 0.2; 
+    FMINCON = 0.5; 
+end
+if i <= round(nrun*DHC)
+    method = 'dhc'
+    obj_fun = DHC_f;
+else if i <= ( round(nrun*DHC) + round(nrun*NL2SOL) )
+        method = 'nl2sol'
+        obj_fun = NL2SOL_f;
+    else method = 'fmincon'
+        obj_fun = FMINCON_f;
+    end
+end
+
+end
+
diff --git a/Requirements/MEIGO/eSS/ssm_multistart.m b/Requirements/MEIGO/eSS/ssm_multistart.m
new file mode 100644
index 0000000000000000000000000000000000000000..ac32402bbeb71c0d70654aebba78a60de689bba7
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_multistart.m
@@ -0,0 +1,396 @@
+
+function Results_multistart = ssm_multistart(problem,opts,varargin)
+
+% Function   : ssm_multistart
+% Written by : Process Engineering Group IIM-CSIC (jegea@iim.csic.es)
+% Created on : 01/07/2005
+% Last Update: 05/11/2014 by A.Gabor
+%
+% Script to do multistart optimization (e.g. Multiple local optimization
+% starting from different initial points uniformly distributed withing the
+% bounds)
+%
+%
+%          Results_multistart=ssm_multistart(problem,opts,p1,p2,...,pn)
+%
+% Input Parameters:
+%         problem   - Structure containing problem
+%
+%               problem.f               = Name of the file containing the objective function
+%               problem.x_L             = Lower bounds of decision variables
+%               problem.x_U             = Upper bounds of decision variables
+%               problem.x_0             = Initial point(s) (optional)
+%
+%               Additionally, fill the following fields if your problem has
+%               non-linear constraints
+%
+%               problem.neq             = Number of equality constraints (do not define it if there are no equality constraints)
+%               problem.c_L             = Lower bounds of nonlinear constraints
+%               problem.c_U             = Upper bounds of nonlinear constraints
+%               problem.int_var         = Number of integer variables
+%               problem.bin_var         = Number of binary variables
+%               NOTE: The order of decision variables is x=[cont int bin]
+%
+%         opts      - Structure containing options
+%
+%           opts.ndiverse: Number of uniformly distributed points inside the bounds to do the multistart optimization (default 100)
+%
+%           Local options
+%               opts.local.solver             = Choose local solver ( default 'fmincon')
+%                                                     0: Local search deactivated
+%                                                     'fmincon' (Mathworks)
+%                                                     'clssolve' (Tomlab)
+%                                                     'snopt' (Tomlab)
+%                                                     'nomad' (Abramson)
+%                                                     'npsol' (Tomlab)
+%                                                     'solnp' (Ye)
+%                                                     'n2fb' (For parameter stimation problems. Single precision)
+%                                                     'dn2fb' (For parameter stimation problems. Double precision)
+%                                                     'dhc' (Yuret) Direct search
+%                                                     'fsqp'
+%                                                     'ipopt'
+%                                                     'misqp' (Exler) For mixed integer problems
+%               opts.local.tol                = Level of tolerance in local search
+%               opts.local.iterprint          = Print each iteration of local solver on screen
+%
+%   p1,p2... :  optional input parameters to be passed to the objective
+%   function
+%
+%
+% Output Parameters:
+%         Results_multistart      -Structure containing results
+%
+%               Results_multistart.fbest       :Best objective function value found after the multistart optimization
+%               Results_multistart.xbest       :Vector providing the best function value
+%               Results_multistart.x0          :Array containing the vectors used for the multistart optimization (in rows)
+%               Results_multistart.f0          :Vector containing the objective function values of the initial solutions used in the multistart optimization
+%               Results_multistart.func        :Vector containing the objective function values obtained after every local search
+%               Results_multistart.xxx         :Array containing the vectors provided by the local optimization (in rows)
+%               Results_multistart.no_conv     :Array containing the initial points that did not provide any solution when the local search was applied (in rows)
+%               Results_multistart.nfuneval    :Vector containing the number of function evaluations in every optimisation
+%               Results_multistart.time        :Total CPU time to carry out the multistart optimization
+
+%               NOTE: To plot an histogram of the results: hist(Results_multistart.func)
+
+global input_par
+cpu_time = cputime;
+fin = 0;
+
+%Extra input parameters for fsqp and n2fb
+if nargin>2
+    if  strcmp(opts.local.solver,'dn2fb') | strcmp(opts.local.solver,'n2fb') |...
+            strcmp(opts.local.solver,'fsqp') | strcmp(opts.local.solver,'nomad') | strcmp(opts.local.solver,'nl2sol')
+        input_par = varargin;
+    end
+end
+
+x_U = problem.x_U;
+x_L = problem.x_L;
+
+if not(isfield(problem,'neq')) | isempty(problem.neq)
+    neq = 0;
+else
+    neq = problem.neq;
+end
+
+if not(isfield(problem,'x_0'))
+    x_0 = [];
+else
+    x_0 = problem.x_0;
+end
+
+if not(isfield(problem,'c_U'))
+    c_U = [];
+    c_L = [];
+else
+    c_U = problem.c_U;
+    c_L = problem.c_L;
+end
+
+if not(isfield(problem,'int_var')) | isempty(problem.int_var)
+    int_var = 0;
+else
+    int_var = problem.int_var;
+end
+
+if not(isfield(problem,'bin_var')) | isempty(problem.bin_var)
+    bin_var = 0;
+else
+    bin_var = problem.bin_var;
+end
+
+if not(isfield(problem,'ndata'))
+    ndata = [];
+else
+    ndata = problem.ndata;
+end
+
+%Load default values & set options:
+default      = ssm_defaults;
+opts         = ssm_optset(default,opts);
+weight       = opts.weight;
+tolc         = opts.tolc;
+local_solver = opts.local.solver;
+% maxtime      = opts.maxtime;
+% maxeval      = opts.maxeval;
+
+%Check if bounds have the same dimension
+if length(x_U) ~= length(x_L)
+    disp('Upper and lower bounds have different dimension!!!!')
+    disp('EXITING')
+    Results_multistart = [];
+    return
+else
+    %Number of decision variables
+    nvar = length(x_L);
+end
+
+%Transformacion de variables de cadena en funciones para que la llamada con
+%feval sea mas rapida
+fobj = str2func(problem.f);
+
+isFjacDefined = 0;
+if isfield(problem,'fjac') & ~isempty(problem.fjac)
+    isFjacDefined = 1;
+    if ischar(problem.fjac)
+        fjac = str2func(problem.fjac);
+    elseif isa(problem.fjac,'function_handle')
+        fjac = problem.fjac;
+    else
+        error('fjac is neither a string nor a function handle.')
+    end
+end
+
+if (int_var + bin_var) & local_solver & not(strcmp(local_solver,'misqp'))
+    fprintf('For problems with integer and/or binary variables you must use MISQP as a local solver \n');
+    fprintf('EXITING \n');
+    Results_multistart = [];
+    return
+end
+
+if local_solver & strcmp(local_solver,'n2fb') | strcmp(local_solver,'dn2fb') | strcmp(local_solver,'nl2sol')
+    n_out_f = nargout(problem.f);
+    if n_out_f<3
+        fprintf('%s requires 3 output arguments \n',local_solver);
+        fprintf('EXITING \n');
+        Results_multistart = [];
+        return
+    else
+        %Generate a random point within the bounds
+        randx   = rand(1,nvar).*(x_U-x_L)+x_L;
+        [f g R] = feval(fobj,randx,varargin{:});
+        ndata   = length(R);
+    end
+else
+    ndata=[];
+end
+
+%If there are equality constraints
+if neq
+    %Set the new bounds for all the constraints
+    c_L = [-tolc*ones(1,neq) c_L];
+    c_U = [tolc*ones(1,neq) c_U];
+end
+nconst = length(c_U);
+if nconst
+    n_out_f = nargout(problem.f);
+    if n_out_f < 2
+        fprintf('For constrained problems the objective function must have at least 2 output arguments \n');
+        fprintf('EXITING \n');
+        Results_multistart=[];
+        return
+    end
+end
+
+% Load aux files:
+if isFjacDefined
+    ssm_aux_local(problem.f,problem.fjac,x_L,x_U,c_L,c_U,neq,local_solver,nvar,varargin{:});
+else
+    ssm_aux_local(problem.f,[],x_L,x_U,c_L,c_U,neq,local_solver,nvar,varargin{:});
+end
+
+if opts.ndiverse
+    multix = rand(opts.ndiverse,nvar);    
+    a      = repmat(x_U-x_L,[opts.ndiverse,1]);
+    b      = repmat(x_L,[opts.ndiverse,1]);
+    multix = multix.*a+b; % to put the variables inside the bounds
+else
+    multix = [];
+end
+multix = [x_0; multix];
+if (int_var) || (bin_var)
+    multix = ssm_round_int(multix,int_var+bin_var,x_L,x_U);
+end
+nrun     = size(multix,1);
+f0       = zeros(nrun,1);
+tic
+f0(1)    = feval(problem.f,multix(1,:),varargin{:}); 
+tf0      = toc;
+func     = zeros(nrun,1);
+xxx      = zeros(nrun,nvar);
+time     = zeros(nrun,1);
+nfuneval = zeros(nrun,1);
+no_conv  = [];
+x0       = [];
+
+for ind_search = 1:nrun
+    x0 = multix(ind_search,:);  
+    if strcmp(local_solver,'mix')
+        [this_local_solver,obj_fun] = ssm_mix(ind_search,nrun);
+        this_f                      = obj_fun;
+        fobj                        = str2func(this_f);        
+        %-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+        % If the solver from the 'mix' is NL2SOL:
+        %-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+        if nargin > 2 
+            if  strcmp(this_local_solver,'nl2sol'), input_par = varargin; end
+        end
+        if strcmp(this_local_solver,'nl2sol')
+            opts.local.use_gradient_for_finish = 0;
+            opts.local.check_gradient_for_finish = 0;
+            n_out_f = nargout(this_f);
+            if n_out_f<3
+                fprintf('%s requires 3 output arguments \n',this_local_solver);
+                fprintf('EXITING \n');
+                Results_multistart = [];
+                return
+            else
+                %Generate a random point within the bounds
+                randx   = rand(1,nvar).*(x_U-x_L)+x_L;
+                [f g R] = feval(fobj,randx,varargin{:});
+                ndata   = length(R);
+            end
+        else
+            ndata=[];
+        end
+        % If we are using NL2SOL and the Jacobian is provided:
+        isFjacDefined = 0;
+        if isfield(problem,'fjac') & ~isempty(problem.fjac)
+            isFjacDefined = 1;
+            if ischar(problem.fjac)
+                fjac = str2func(problem.fjac);
+            elseif isa(problem.fjac,'function_handle')
+                fjac = problem.fjac;
+            else
+                error('fjac is neither a string nor a function handle.')
+            end
+        end
+        if isFjacDefined
+            ssm_aux_local(this_f,problem.fjac,x_L,x_U,c_L,c_U,neq,this_local_solver,nvar,varargin{:});
+        else
+            ssm_aux_local(this_f,[],x_L,x_U,c_L,c_U,neq,this_local_solver,nvar,varargin{:});
+        end
+        %-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+        % If the solver from the 'mix' is DHC:
+        %-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+        opts.local.use_gradient_for_finish   = 0; % provide gradient?
+        opts.local.check_gradient_for_finish = 0; % check gradient?      
+        %-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+        %-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+    else
+        this_f = problem.f;
+        this_local_solver = opts.local.solver;
+    end   
+    f0(ind_search) = feval(this_f,x0,varargin{:});
+    if opts.local.iterprint
+        fprintf('\n');
+        fprintf('Local search number: %i \n',ind_search);
+        fprintf('Call local solver: %s \n', upper(this_local_solver))
+        fprintf('Initial point function value: %f \n',f0(ind_search));
+    end
+    tic
+    %[x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,[],...
+    %    this_local_solver,opts.local.iterprint,opts.local.tol,weight,nconst,tolc,opts.local,varargin{:});
+%%% AFV start handling errors: %%%
+  try
+    if isFjacDefined
+        [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,fjac,...
+            this_local_solver,opts.local.iterprint,opts.local.tol,weight,nconst,tolc,opts.local,varargin{:});
+    else
+        [x,fval,exitflag,numeval]=ssm_localsolver(x0,x_L,x_U,c_L,c_U,neq,ndata,int_var,bin_var,fobj,[],...
+            this_local_solver,opts.local.iterprint,opts.local.tol,weight,nconst,tolc,opts.local,varargin{:});
+    end
+  catch
+    fprintf('This local search produced an error \n');
+    x        = x0;
+    fval     = inf;
+    exitflag = -1;
+    numeval  = 1;
+  end
+%%% AFV end of error handling code %%%
+    time(ind_search) = toc;
+    if opts.local.iterprint
+        fprintf('Local solution function value: %f \n',fval);        
+        if exitflag<0
+            fprintf('Warning!!! This could be an infeasible solution: \n');
+        end        
+        fprintf('Number of function evaluations in the local search: %i \n',numeval);
+        fprintf('CPU Time of the local search: %f  seconds \n\n',time(ind_search));
+    end
+    
+    if exitflag<0 | isnan(fval) | isinf(fval)
+        no_conv = [no_conv;x0];
+    end
+    func(ind_search) = fval;
+    xxx(ind_search,:) = x;
+    nfuneval(ind_search) = numeval;
+    
+%     if sum(nfuneval) > maxeval
+%         fprintf('Multistart stopped after %d starts. Maximum number of function evaluation (%d) is reached.\n',ind_search,maxeval);
+%         fin = 1;
+%         break;
+%     elseif sum(time) > maxtime
+%         fprintf('Multistart stopped after %d starts. Maximum CPU computation time (%d) is reached.\n',ind_search,maxtime);
+%         fin = 2;
+%         break;
+%     end
+end
+
+[aaa,iii]                = min(func);
+Results_multistart.x0    = multix;
+Results_multistart.f0    = f0;
+Results_multistart.func  = func;
+Results_multistart.xxx   = xxx;
+Results_multistart.fbest = aaa;
+if ~isempty(xxx)
+    Results_multistart.xbest = xxx(iii,:);
+elseif ~isinf(f0)
+    disp('No feasible improvement of the cost function was achieved.')
+    Results_multistart.xbest = x0;
+else
+    Results_multistart.xbest = [];
+end
+Results_multistart.no_conv  = no_conv;
+Results_multistart.nfuneval = nfuneval;
+Results_multistart.time     = cputime-cpu_time;  % total CPU time
+Results_multistart.itime    = time;           % CPU time of each search.
+Results_multistart.end_crit = fin;
+% Compute the  convergence curve
+% initial cost and time:
+% [fconv(1) I]= min(f0);
+fconv(1) = f0(1);
+tconv(1) = tf0;
+com_time = tf0; % commulative time
+bestit   = multix(1,:);
+% add new point if the cost function is improved:
+for i = 1:length(func)
+    com_time = com_time + time(i); % add the CPU time.    
+    if func(i) < fconv(end)
+        fconv = [fconv;func(i)];
+        bestit = [bestit;xxx(i,:)];
+        tconv = [tconv;com_time];
+    elseif i == length(func)
+        % if not better, but the last point is processed
+        % duplicate the last point at the last time
+        fconv = [fconv;fconv(end)];
+        tconv = [tconv;com_time];
+        bestit = [bestit;bestit(end,:)];
+    end
+end
+
+Results_multistart.convcurve = [tconv, fconv];
+Results_multistart.bestit = bestit;
+% save ssm_multistart_report problem opts Results_multistart
+% ssm_delete_files(local_solver,c_U);
+
+return
diff --git a/Requirements/MEIGO/eSS/ssm_optset.m b/Requirements/MEIGO/eSS/ssm_optset.m
new file mode 100644
index 0000000000000000000000000000000000000000..d61e61403dfbb49670954daf2e0c2605882f3780
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_optset.m
@@ -0,0 +1,47 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_optset.m 770 2013-08-06 09:41:45Z attila $
+function [opts] = ssm_optset(default,opts)
+
+%Esto es para poner el campo 'local' el ultimo
+if isfield(opts,'local') & not(isempty(opts.local))
+    temp=opts.local;
+    opts=rmfield(opts,'local');
+    opts.local=temp;
+else
+    opts.local=default.local;
+end
+
+if not(isempty(opts));
+    opt_names=fieldnames(opts);
+    
+    opt_names_local=fieldnames(opts.local);
+    
+    
+    default_names=fieldnames(default);
+    default_names_local=fieldnames(default.local);
+    
+    low_opt_names = lower(opt_names);
+    low_default_names = lower(default_names);
+    
+    low_opt_names_local = lower(opt_names_local);
+    low_default_names_local = lower(default_names_local);
+    
+    for i=1:length(opt_names)-1
+        j = strmatch(low_opt_names{i,:},low_default_names,'exact');
+        if isempty(j)
+            error(sprintf(['Unrecognized field name %s'], opt_names{i,:}));
+        end
+        value = opts.(opt_names{i,:});
+        default.(default_names{j,:}) = value;
+    end
+
+    for i=1:length(opt_names_local)
+        j = strmatch(low_opt_names_local{i,:},low_default_names_local,'exact');
+        if isempty(j)
+            error(sprintf(['Unrecognized field name %s'], opt_names_local{i,:}));
+        end
+        value = opts.local.(opt_names_local{i,:});
+        default.local.(default_names_local{j,:}) = value;
+    end    
+    
+end
+opts=default;
diff --git a/Requirements/MEIGO/eSS/ssm_penalty_function.m b/Requirements/MEIGO/eSS/ssm_penalty_function.m
new file mode 100644
index 0000000000000000000000000000000000000000..72923d330d7c2de2b9a43001279db49f531d927e
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_penalty_function.m
@@ -0,0 +1,38 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_penalty_function.m 770 2013-08-06 09:41:45Z attila $
+function fx=penalty_function(x,nlc,c_L,c_U,tolc);
+
+P=[];
+
+if ~(isempty(nlc))
+
+
+    if size(nlc)~=size(c_U), nlc=nlc'; end
+    
+    a=find(nlc<c_L);
+    b=find(nlc>c_U);
+    
+    P=zeros(1,length(a)+length(b));
+    counter=1;
+    for i=1:size(a,2)
+       P(counter)=(c_L(a(i))-nlc(a(i)));
+        %P=[P (c_L(a(i))-nlc(a(i)))];%/(1+abs(c_L(a(i))))];
+        counter=counter+1;
+   end
+   
+    for i=1:size(b,2)
+        P(counter)=(nlc(b(i))-c_U(b(i)));
+   %     P=[P (nlc(b(i))-c_U(b(i)))];%/(1+abs(c_U(b(i))))];
+       counter=counter+1;
+    end
+
+end
+
+%maxP=max(P);
+
+if ~(isempty(P)) & max(P)>tolc
+    %The penalty is the maximum constraint violation
+    fx=max(P);
+else
+    fx=0;
+end
+return
diff --git a/Requirements/MEIGO/eSS/ssm_round_int.m b/Requirements/MEIGO/eSS/ssm_round_int.m
new file mode 100644
index 0000000000000000000000000000000000000000..280204fe6715c6d28eee53ad565aa4034ee88052
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssm_round_int.m
@@ -0,0 +1,12 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssm_round_int.m 770 2013-08-06 09:41:45Z attila $
+function xrounded=round_int(x,index,x_L,x_U)
+
+index=size(x,2)-index+1;
+
+index=index:size(x,2);
+
+for i=1:size(x,1)
+    x(i,index)=x_L(index)+floor(0.5+x(i,index)-x_L(index));
+end
+
+xrounded=x;
\ No newline at end of file
diff --git a/Requirements/MEIGO/eSS/ssmgo_test.m b/Requirements/MEIGO/eSS/ssmgo_test.m
new file mode 100644
index 0000000000000000000000000000000000000000..58138c2fa26015f33e451e5c6485e97a3bbdb21d
--- /dev/null
+++ b/Requirements/MEIGO/eSS/ssmgo_test.m
@@ -0,0 +1,323 @@
+% $Header: svn://172.19.32.13/trunk/AMIGO2R2016/Kernel/OPT_solvers/eSS/ssmgo_test.m 770 2013-08-06 09:41:45Z attila $
+function ssmgo_test(solver,nproblem,noptim,pnames,lb,ub,prob,options,test,param);
+
+% Function   : testssm
+% Written by : Process Engineering Group IIM-CSIC (jegea@iim.csic.es)
+% Created on : 20/04/2007
+% Last Update: 21/10/2010
+%
+% Script to perform several optimizations with SSm/eSS for different
+% problems 
+% using the same or different settings
+%
+%          Calling:
+%          ssmgo_test(nproblem,noptim,pnames,lb,ub,prob,options,test,param);
+%
+% Input Parameters:
+%        
+%                nproblem       = Number of problems to be tested (if you are testing the same problem n times, set nproblem=n, not 1).      
+%                noptim         = Number of optimizations to perform per problem 
+%                pames          = Cell array containing the names of the problems as strings
+%                lb             = Cell array containing the lower bounds for all problems. 
+%                ub             = Cell array containing the upper bounds for all problems. 
+%                problem        = Matrix and structure containing problem settings for each problem.
+%                                These settings are declared like in SSm but using indexes.
+%                                For example, if we want to set an initial point for problem 3 we would type problem(3).x_0=[0 1 2 3 4];% 
+%                opts           = General options for all problems. They are declared exactly the same way as in SSm
+%                test           = Matrix and structure declaring specific options for problems.
+%                param          = Structure declaring extra input parameters to be passed for every problem
+% 
+% Example: if the local solver chosen for all problems is fsqp except for problem 4 (for which we will choose misqp) we would write:
+% 
+%                       opts.local.solver='fsqp';
+%                       test(4).local.solver='misqp';
+%
+% If problem 5 has 3 extra input arguments, p1, p2 and p3, we would declare
+%       
+%                       param{5}={p1,p2,p3};          
+% 
+% 
+%  Output:
+%
+%   testssmgo generates two .mat files, one called Results_testssmgo_XXX.mat and testsummary_XXX.dat
+%   (where XXX is a number related to the date and time when the test was performed), containing the following variables:
+% 
+%       Results_testssmgo_XXX.mat: Problem setting, options and Results (with the same out-puts as in SSm) 
+%                                for each run under the format prob_px, opts_px and res_px_ry respectively,
+%                                where x is the problem number and y is the run number.
+% 
+%       testsummary_XXX.mat: Summary of some results:
+%                            
+%                           fbest_px: Vector containing the best value found in each run for problem x.
+%                           neval_px: Vector containing the number of function evaluations in each run for problem x.
+%                           time_px: Vector containing the CPU time consumed in each run for problem x.
+%                           best_values: Vector containing the best function value found for each problem after all the runs.
+%                           worst_values: Vector containing the worst function value found for each problem after all the runs.
+%                           mean_values: Vector containing the mean function value found for each problem after all the runs.
+%
+%
+%
+
+if nargin<10
+    param=[];
+    if nargin<9
+        test=[];
+    end
+else
+    aaa=length(param);
+    if aaa<nproblem
+        for i=aaa+1:nproblem
+            param{i}=[];
+        end
+    end
+end
+
+n_times=0;
+fff=[];
+neval=[];
+cpu_time=[];
+
+
+hhh=clock;
+
+flag=[strcat('Results_testssmgo_',num2str(hhh(1)),num2str(hhh(2)),num2str(hhh(3)),num2str(hhh(4)),num2str(hhh(5)))];
+flag2=[strcat('testsummary_',num2str(hhh(1)),num2str(hhh(2)),num2str(hhh(3)),num2str(hhh(4)),num2str(hhh(5)))];
+
+save(flag,'hhh');
+save(flag2,'hhh');
+
+
+fid=fopen('testssmgo_report.txt','w');
+fprintf(fid,'%50s \n','SSMGO TEST FILE REPORT');
+fprintf(fid,'%50s \n','**********************');
+fprintf(fid,'%s \n',strcat(date));
+fprintf(fid,'%s \n',  strcat(num2str(hhh(4)),':',num2str(hhh(5)),':',num2str(fix(hhh(6)))));
+fprintf(fid,'Solver: %s \n',upper(solver));
+fclose(fid);
+
+best_values=[];
+worst_values=[];
+mean_values=[];
+
+best_time=[];
+worst_time=[];
+mean_time=[];
+
+best_neval=[];
+worst_neval=[];
+mean_neval=[];
+
+size_test=length(test);
+
+problems_solved=zeros(nproblem,noptim);
+
+%Number of examples
+for nfunc=1:nproblem
+    clear mex
+    tiempo=[];
+    bestf=[];
+    evals=[];
+
+    
+    problem=[];
+    problem=prob(nfunc);
+    problem.f=pnames{nfunc};
+    problem.x_L=lb{nfunc};
+    problem.x_U=ub{nfunc};
+
+
+    opts=[];
+    opts.local=[];
+    opts=options;
+    
+    if not(isempty(test)) & nfunc<=size_test
+        
+        test_names=fieldnames(test(nfunc));
+
+        if isfield(test(nfunc),'local')
+            if not(isempty(test(nfunc).local))
+                test_names_local=fieldnames(test(nfunc).local);
+                for i=1:length(test_names_local)
+                    opts.local.(test_names_local{i,:}) = test(nfunc).local.(test_names_local{i,:});
+                end
+            end
+        end
+        
+        for i=1:length(test_names)
+            if ~isempty(test(nfunc).(test_names{i,:}))
+                opts.(test_names{i,:}) = test(nfunc).(test_names{i,:});
+            end
+        end
+    end
+    eval(['prob_p' num2str(nfunc) ' = problem;'])
+    eval(['opts_p' num2str(nfunc) ' = opts;'])
+    
+    eval(['save(flag, [''prob_p'' num2str(nfunc)], ''-append'');'])
+    eval(['save(flag, [''opts_p'' num2str(nfunc)], ''-append'');'])
+    
+    
+    %Number of optimizations per example
+    for j=1:noptim
+        %Set seed for random numbers
+        rand('state',j-1)
+
+        if isempty(param) | isempty(param{nfunc})
+            if strmatch(lower(solver),'ssm')
+                Results=ssm_kernel(problem,opts);
+            else
+                Results=ess_kernel(problem,opts);
+            end
+
+        else
+            if strmatch(lower(solver),'ssm')
+                Results=ssm_kernel(problem,opts,param{nfunc}{:});
+            else
+                Results=ess_kernel(problem,opts,param{nfunc}{:});
+            end
+        end
+
+        tiempo=[tiempo;Results.cpu_time];
+        bestf=[bestf;Results.fbest];
+        evals=[evals;Results.numeval];
+
+        if Results.end_crit==3
+            n_times=n_times+1;
+            problems_solved(nfunc,j)=1;
+        end
+
+        fff=[fff Results.fbest];
+        neval=[neval Results.numeval];
+        cpu_time=[cpu_time Results.cpu_time];
+
+        eval(['res_p' num2str(nfunc) '_r' num2str(j) ' = Results;'])
+        eval(['save(flag, [''res_p'' num2str(nfunc) ''_r'' num2str(j)], ''-append'');'])
+    end
+    
+    mean_tiempo=mean(tiempo);
+    mean_bestf=mean(bestf);
+    mean_evals=mean(evals);
+    
+    min_tiempo=min(tiempo);
+    min_bestf=min(bestf);
+    min_evals=min(evals);
+    
+    max_tiempo=max(tiempo);
+    max_bestf=max(bestf);
+    max_evals=max(evals);
+    
+    best_values=[best_values; min_bestf];
+    worst_values=[worst_values; max_bestf];
+    mean_values=[mean_values; mean_bestf];
+    
+    
+    best_time=[best_time; min_tiempo];
+    worst_time=[worst_time; max_tiempo];
+    mean_time=[mean_time; mean_tiempo];
+    
+    
+    best_neval=[best_neval; min_evals];
+    worst_neval=[worst_neval; max_evals];
+    mean_neval=[mean_neval; mean_evals];
+
+    
+    eval(['time_p' num2str(nfunc) ' = tiempo;'])
+    eval(['fbest_p' num2str(nfunc) ' = bestf;'])
+    eval(['neval_p' num2str(nfunc) ' = evals;'])
+    
+%     eval(['mean_time_p' num2str(nfunc) ' = mean_tiempo;'])
+%     eval(['mean_fbest_p' num2str(nfunc) ' = mean_bestf;'])
+%     eval(['mean_neval_p' num2str(nfunc) ' = mean_evals;'])
+%     
+%     eval(['min_time_p' num2str(nfunc) ' = min_tiempo;'])
+%     eval(['min_fbest_p' num2str(nfunc) ' = min_bestf;'])
+%     eval(['min_neval_p' num2str(nfunc) ' = min_evals;'])
+%     
+%     eval(['max_time_p' num2str(nfunc) ' = max_tiempo;'])
+%     eval(['max_fbest_p' num2str(nfunc) ' = max_bestf;'])
+%     eval(['max_neval_p' num2str(nfunc) ' = max_evals;'])
+
+
+  
+    eval(['save(flag2, [''time_p'' num2str(nfunc)],[''fbest_p'' num2str(nfunc)],[''neval_p'' num2str(nfunc)],''-append'');'])
+    eval(['save(flag2, ''best_values'' ,''worst_values'',''mean_values'',''problems_solved'',''-append'');'])
+    eval(['save(flag2, ''best_time'' ,''worst_time'',''mean_time'',''-append'');'])
+    eval(['save(flag2, ''best_neval'' ,''worst_neval'',''mean_neval'',''-append'');'])
+    eval(['save(flag2, ''solver'',''-append'');'])
+%     eval(['save(flag2, [''mean_time_p'' num2str(nfunc)],[''mean_fbest_p'' num2str(nfunc)],[''mean_neval_p'' num2str(nfunc)],''-append'');'])
+%     eval(['save(flag2, [''min_time_p'' num2str(nfunc)],[''min_fbest_p'' num2str(nfunc)],[''min_neval_p'' num2str(nfunc)],''-append'');'])
+%     eval(['save(flag2, [''max_time_p'' num2str(nfunc)],[''max_fbest_p'' num2str(nfunc)],[''max_neval_p'' num2str(nfunc)],''-append'');'])
+ 
+
+    
+
+    fid=fopen('testssmgo_report.txt','a');
+    fprintf(fid,'\n\n');
+    fprintf(fid,'=========================================================================================================== \n');
+    fprintf(fid,'%s %g \n','Problem',nfunc);
+    fprintf(fid,'********** \n');
+    fprintf(fid,'%s %s \n','Name: ',problem.f);
+    fprintf(fid,'%s %g \n','nvar: ',length(problem.x_L));
+    fprintf(fid,'\n');
+    fprintf(fid,'RESULTS in %g optimizations \n',noptim);
+    fprintf(fid,'*************************** \n');
+    if isfield(problem,'vtr') & not(isempty(problem.vtr))
+        fprintf(fid,'%s %g \n','Times the GO was found: ',n_times);
+    end
+    fprintf(fid,'%-10s  %-30s  %-50s  %-70s  \n','Run','Result','Nfuneval','CPU Time' );
+    
+
+    for k=1:length(fff)
+        fprintf(fid,'%-10g  %-30e  %-50g  %-70g  \n',k,fff(k),neval(k)',cpu_time(k) );         
+    end
+
+    fprintf(fid,'\n\n');
+    fprintf(fid,'%-25s %-40e  \n','Minimum function value:',min_bestf);
+    fprintf(fid,'%-25s %-40e  \n','Maximum function value:',max_bestf);
+    fprintf(fid,'%-25s %-40e  \n\n','Mean function value:',mean_bestf); 
+    
+    fprintf(fid,'%-25s %-40g  \n','Minimum func. eval.:',min_evals);
+    fprintf(fid,'%-25s %-40g  \n','Maximum func. eval.:',max_evals);
+    fprintf(fid,'%-25s %-40g  \n\n','Mean func. eval.:',round(mean_evals));
+    
+    fprintf(fid,'%-25s %-40g  \n','Minimum CPU time:',min_tiempo);
+    fprintf(fid,'%-25s %-40g  \n','Maximum CPU time:',max_tiempo);
+    fprintf(fid,'%-25s %-40g  \n\n','Mean CPU time:',mean_tiempo);
+    
+    fclose(fid);
+    
+    n_times=0;
+    fff=[];
+    neval=[];
+    cpu_time=[];
+    
+end
+
+fid=fopen('testssmgo_report.txt','a');
+
+fprintf(fid,'************************************************************************************ \n');
+fprintf(fid,'************************************************************************************ \n');
+
+fprintf(fid,'%s \n','Number of solved problems');
+
+for i=1:noptim
+    aaa=find(problems_solved(:,i));
+    fprintf(fid,'%s %i %s %i \n','Run',i,':',length(aaa));
+end
+fprintf(fid,'************************************************************************************ \n');
+fprintf(fid,'************************************************************************************ \n');
+
+bbb=sum(problems_solved');
+n_diff_prob=numel(find(bbb));
+fprintf(fid,'%s %i \n','Number of DIFFERENT solved problems: ',n_diff_prob);
+
+total_solved_prob=sum(sum(problems_solved));
+fprintf(fid,'%s %i \n','Number of TOTAL solved problems: ',total_solved_prob);
+
+ccc=sum(problems_solved);
+ddd=max(ccc);
+eee=numel(find(ccc==ddd));
+
+fprintf(fid,'%s %i %s %i %s \n','Maximum number of problems solved in a single run: ',ddd,' obtained ',eee,' times');
+
+
+fclose(fid);
diff --git a/Requirements/MEIGO/examples/TF.m b/Requirements/MEIGO/examples/TF.m
new file mode 100644
index 0000000000000000000000000000000000000000..9cd74519f70d30cbe4767c947a2fe8a5939abe56
--- /dev/null
+++ b/Requirements/MEIGO/examples/TF.m
@@ -0,0 +1,452 @@
+classdef TF
+% TESTFUNCTION Different toy test functions.
+%
+% There exist ample other test functions widely used to test optimization
+% algorithms in problematic situations.
+    
+    properties (Constant)
+        % labels
+        name     = 'name';
+        fun      = 'fun';
+        lb       = 'lb';
+        ub       = 'ub';
+        xbst     = 'xbst';
+        fbst     = 'fbst';
+        dim      = 'dim'; % Inf means arbitrary dim
+        smooth   = 'smooth'; % smooth in the sense of partially differentiable everywhere
+        convex   = 'convex';
+        unimodal = 'unimodal';
+                
+        % test simple_problems
+        ackley         = struct(TF.name, 'ackley', TF.fun, @TF.f_ackley, TF.lb, -6, TF.ub, 6, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+		alpine1        = struct(TF.name, 'alpine1', TF.fun, @TF.f_alpine1, TF.lb, -5, TF.ub, 5, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        beale          = struct(TF.name, 'beale', TF.fun, @TF.f_beale, TF.lb, -4.5, TF.ub, 4.5, TF.xbst, [3;0.5], TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        bohachevsky1   = struct(TF.name, 'bohachevsky1', TF.fun, @TF.f_bohachevsky1, TF.lb, -10, TF.ub, 12, TF.xbst, 0, TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        bohachevsky2   = struct(TF.name, 'bohachevsky2', TF.fun, @TF.f_bohachevsky2, TF.lb, -60, TF.ub, 50, TF.xbst, 0, TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        bohachevsky3   = struct(TF.name, 'bohachevsky3', TF.fun, @TF.f_bohachevsky3, TF.lb, -100, TF.ub, 100, TF.xbst, 0, TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+		booth          = struct(TF.name, 'booth', TF.fun, @TF.f_booth, TF.lb, -10, TF.ub, 10, TF.xbst, [1;3], TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+        bukin2     	   = struct(TF.name, 'bukin2', TF.fun, @TF.f_bukin2, TF.lb, [-15;-5], TF.ub, [-3;3], TF.xbst, [-10;0], TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+		bukin4    	   = struct(TF.name, 'bukin4', TF.fun, @TF.f_bukin2, TF.lb, [-15;-5], TF.ub, [-3;3], TF.xbst, [-10;0], TF.fbst, 0, TF.dim, 2, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        bukin6         = struct(TF.name, 'bukin6', TF.fun, @TF.f_bukin6, TF.lb, [-15;-5], TF.ub, [-3;3], TF.xbst, [-10;1], TF.fbst, 0, TF.dim, 2, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        cam3           = struct(TF.name, 'cam3', TF.fun, @TF.f_cam3, TF.lb, -5, TF.ub, 5, TF.xbst, 0, TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        colville       = struct(TF.name, 'colville', TF.fun, @TF.f_colville, TF.lb, -10, TF.ub, 10, TF.xbst, 1, TF.fbst, 0, TF.dim, 4, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        dixonprice     = struct(TF.name, 'dixonprice', TF.fun, @TF.f_dixonprice, TF.lb, -10, TF.ub, 10, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 1);
+        easom          = struct(TF.name, 'easom', TF.fun, @TF.f_easom, TF.lb, -10, TF.ub, 10, TF.xbst, pi, TF.fbst, -1, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        exponential    = struct(TF.name, 'exponential', TF.fun, @TF.f_exponential, TF.lb, -1, TF.ub, 2, TF.xbst, 0, TF.fbst, -1, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 1);
+        freudensteinroth = struct(TF.name, 'freudensteinroth', TF.fun, @TF.f_freudensteinroth, TF.lb, -10, TF.ub, 10, TF.xbst, [5;4], TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        goldsteinprice = struct(TF.name, 'goldsteinprice', TF.fun, @TF.f_goldsteinprice, TF.lb, -2, TF.ub, 2, TF.xbst, [0;-1], TF.fbst, 3, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        griewank       = struct(TF.name, 'griewank', TF.fun, @TF.f_griewank, TF.lb, -8, TF.ub, 8, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        hyperellipse   = struct(TF.name, 'hyperellipse', TF.fun, @TF.f_hyperellipse, TF.lb, -66, TF.ub, 66, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+        levy           = struct(TF.name, 'levy', TF.fun, @TF.f_levy, TF.lb, -10, TF.ub, 10, TF.xbst, 1, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        matyas         = struct(TF.name, 'matyas', TF.fun, @TF.f_matyas, TF.lb, -10, TF.ub, 10, TF.xbst, 0, TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+        max      	   = struct(TF.name, 'max', TF.fun, @TF.f_max, TF.lb, -100, TF.ub, 100, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 1, TF.unimodal, 1);	
+		mountainhole   = struct(TF.name, 'mountainhole', TF.fun, @TF.f_mountainhole, TF.lb, -5, TF.ub, 5, TF.xbst, [-sqrt(1/2);0], TF.fbst, -sqrt(1/2)*exp(-1/2), TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 1);
+        nesterov       = struct(TF.name, 'nesterov', TF.fun, @TF.f_nesterov, TF.lb, -10, TF.ub, 10, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 1, TF.unimodal, 1);
+        powellsum      = struct(TF.name, 'powellsum', TF.fun, @TF.f_powellsum, TF.lb, -2, TF.ub, 2, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 1, TF.unimodal, 1); 
+        powellsum2     = struct(TF.name, 'powellsum2', TF.fun, @TF.f_powellsum2, TF.lb, -2, TF.ub, 2, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 1, TF.unimodal, 1);
+        power2         = struct(TF.name, 'power2', TF.fun, @TF.f_power2, TF.lb, -10, TF.ub, 10, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+        power10  	   = struct(TF.name, 'power10', TF.fun, @TF.f_power10, TF.lb, -10, TF.ub, 9, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+        price1         = struct(TF.name, 'price1', TF.fun, @TF.f_price1, TF.lb, -50, TF.ub, 50, TF.xbst, 5, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        qing           = struct(TF.name, 'qing', TF.fun, @TF.f_qing, TF.lb, -500, TF.ub, 500, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        quartic        = struct(TF.name, 'quartic', TF.fun, @TF.f_quartic, TF.lb, -2, TF.ub, 2, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+		rastrigin      = struct(TF.name, 'rastrigin', TF.fun, @TF.f_rastrigin, TF.lb, -5.12, TF.ub, 5.12, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex,0, TF.unimodal, 0);
+        rosenbrock     = struct(TF.name, 'rosenbrock', TF.fun, @TF.f_rosenbrock, TF.lb, -2.5, TF.ub, 3, TF.xbst, 1, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        salomon        = struct(TF.name, 'salomon', TF.fun, @TF.f_salomon, TF.lb, -10, TF.ub, 10, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        schaffer2      = struct(TF.name, 'schaffer2', TF.fun, @TF.f_schaffer2, TF.lb, -4, TF.ub, 4, TF.xbst, 0, TF.fbst, 0, TF.dim, 2, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        schwefel1 	   = struct(TF.name, 'schwefel1', TF.fun, @TF.f_schwefel1, TF.lb, -100, TF.ub, 100, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+		schwefel2 	   = struct(TF.name, 'schwefel2', TF.fun, @TF.f_schwefel2, TF.lb, -100, TF.ub, 100, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+		schwefel4 	   = struct(TF.name, 'schwefel4', TF.fun, @TF.f_schwefel4, TF.lb, -6, TF.ub, 10, TF.xbst, 1, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0);
+        schwefel6      = struct(TF.name, 'schwefel6', TF.fun, @TF.f_schwefel6, TF.lb, -100, TF.ub, 100, TF.xbst, [1;3], TF.fbst, 0, TF.dim, 2, TF.smooth, 0, TF.convex, 1, TF.unimodal, 1);
+ 		step           = struct(TF.name, 'step', TF.fun, @TF.f_step, TF.lb, -1, TF.ub, 1, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        sumprod 	   = struct(TF.name, 'sumprod', TF.fun, @TF.f_sumprod, TF.lb, -2, TF.ub, 2, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 1)
+        xinsheyang1    = struct(TF.name, 'xinsheyang1', TF.fun, @TF.f_xinsheyang1, TF.lb, -2*pi, TF.ub, 2*pi, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 0, TF.convex, 0, TF.unimodal, 0);
+        xinsheyang2    = struct(TF.name, 'xinsheyang2', TF.fun, @TF.f_xinsheyang2, TF.lb, -15, TF.ub, 20, TF.xbst, 0, TF.fbst, -1, TF.dim, Inf, TF.smooth, 1, TF.convex, 0, TF.unimodal, 0); 
+        zakharov       = struct(TF.name, 'zakharov', TF.fun, @TF.f_zakharov, TF.lb, -5, TF.ub, 10, TF.xbst, 0, TF.fbst, 0, TF.dim, Inf, TF.smooth, 1, TF.convex, 1, TF.unimodal, 1);
+           
+        cell_tfs = {TF.ackley, TF.alpine1, TF.beale, TF.bohachevsky1, TF.bohachevsky2, TF.bohachevsky3, ...
+            TF.booth, TF.bukin2, TF.bukin4, TF.bukin6, TF.cam3, ...
+            TF.colville, TF.dixonprice, TF.easom, TF.exponential, ...
+            TF.freudensteinroth, TF.goldsteinprice, TF.griewank, ...
+            TF.himmelblau, TF.hyperellipse, TF.levy, TF.matyas, TF.max, TF.mountainhole, ...
+            TF.nesterov, TF.powellsum, ...
+            TF.powellsum2, TF.power2, TF.power4, TF.power10, TF.price1, ...
+            TF.qing, TF.quartic, TF.rastrigin, TF.rosenbrock, ...
+            TF.salomon, TF.schaffer2, TF.schwefel1, TF.schwefel2, ...
+            TF.schwefel4, TF.schwefel6, TF.step, TF.sumprod, ...
+            TF.xinsheyang1, TF.xinsheyang2, TF.zakharov};
+    end
+    
+    methods (Static)
+        
+        %% functions with known global minimum
+             
+        function [fval] = f_ackley(x)
+        % typical domain: [-33,33] or larger
+        % global minimum: [0] at [0,...,0]
+        % Problem: many local minima, one steep global minimum
+            a = 20;
+            b = 0.2;
+            c = 2*pi;
+            dim = length(x);
+            
+            fval = -a*exp(-b*sqrt(sum(x.^2)/dim)) - exp(sum(cos(c*x))/dim) + a + exp(1);
+        end
+        
+        function [fval] = f_alpine1(x)
+            fval = sum(abs(x.*sin(x)+0.1*x)); 
+        end
+          
+        function [fval] = f_beale(x)
+        % x\in\R^2
+        % typical domain: [-4.5,4.5]
+        % global minimum: [0] at [3,0.5]
+        % deep cross, global minimum in one direction
+           fval = (1.5-x(1)+x(1)*x(2))^2 + (2.25-x(1)+x(1)*x(2)^2)^2 + (2.625-x(1)+x(1)*x(2)^3)^2;
+        end
+    
+		function [fval] = f_bohachevsky1(x)
+		% x\in\R^2
+		% typical domain: [-100,100]
+		% global minimum: [0] at [0,0]
+		% unimodal
+			fval = x(1)^2+2*x(2)^2-0.3*cos(3*pi*x(1))-0.4*cos(4*pi*x(2)) + 0.7;
+        end
+        
+        function [fval] = f_bohachevsky2(x)
+		% x\in\R^2
+		% typical domain: [-100,100]
+		% global minimum: [0] at [0,0]
+		% unimodal
+			fval = x(1)^2+2*x(2)^2-0.3*cos(3*pi*x(1))*cos(4*pi*x(2)) + 0.3;
+		end
+		
+		function [fval] = f_bohachevsky3(x)
+		% x\in\R^2
+		% typical domain: [-100,100]
+		% global minimum: [0] at [0,0]
+		% unimodal
+			fval = x(1)^2+2*x(2)^2-0.3*cos(3*pi*x(1)+4*pi*x(2)) + 0.3;
+        end
+		
+        function [fval] = f_booth(x)
+        % x\in\R^2
+        % typical domain: [-10,10]
+        % global minimum: [0] at [1,3]
+        % rather streched valley
+            fval = (x(1)+2*x(2)-7)^2 + (2*x(1)+x(2)-5)^2;
+        end
+                
+        function [fval] = f_bukin2(x)
+        % x\in\R^2
+        % typical domain: [-15;-3]*[-5,3]
+        % global minimum: [0] at [-10,0]
+            fval = 100*(x(2)-0.01*x(1)^2+1)^2 + 0.01*(x(1)+10)^2;
+        end
+        
+		function [fval] = f_bukin4(x)
+        % x\in\R^2
+        % typical domain: [-15;-3]*[-5,3]
+        % global minimum: [0] at [-10,0]
+            fval = 100*x(2)^2 + 0.01*abs(x(1)+10);
+        end
+		
+		function [fval] = f_bukin6(x)
+        % x\in\R^2
+        % typical domain: [-15;-3]*[-5,3]
+        % global minimum: [0] at [-10,1]
+        % Problem: not smooth, very narrow slightly descending and crescent valley
+            fval = 100 * sqrt(abs(x(2)-0.01*x(1)^2)) + 0.01*abs(x(1)+10);
+        end
+        
+        function [fval] = f_cam3(x)
+        % x\in\R^2
+        % 3 local minima, global minimum [0] at [0,0]
+            fval = 2*x(1)^2 - 1.05*x(1)^4 + x(1)^6/6 + x(1)*x(2) + x(2)^2;
+        end
+		      
+        function [fval] = f_colville(x)
+        % x\in\R^4
+            x1=x(1);x2=x(2);x3=x(3);x4=x(4);
+            fval = 100*(x1^2-x2)^2 + (x1-1)^2 ...
+                + (x3-1)^2 + 90*(x3^2-x4)^2 ...
+                + 10.1*((x2-1)^2+(x4-1)^2)...
+                + 19.8*(x2-1)*(x4-1);
+        end
+        
+        function [fval] = f_dixonprice(x)
+            dim = length(x);
+            
+            w=zeros(dim,1);
+            for j=1:dim
+                w(j) = x(j)+2^(-(2^j-2)/(2^j));
+            end
+            
+            sum = 0;
+            for j=2:dim
+                sum = sum + j*(2*w(j)^2-w(j-1))^2;
+            end
+            
+            fval = (w(1)-1)^2 + sum;
+        end
+        
+        function [fval] = f_easom(x)
+        % x\in\R^2
+        % several local minima, one deep global minimum [-1] at [pi,pi]
+        % Problem: small area of attraction
+            fval = -cos(x(1))*cos(x(2))*exp(-(x(1)-pi)^2-(x(2)-pi)^2);
+        end
+        
+        function [fval] = f_exponential(x)
+            fval = -exp(-sum(x.^2)/2);
+        end
+        
+        function [fval] = f_freudensteinroth(x)
+            x1 = x(1);
+            x2 = x(2);
+            fval = ( x1-13+((5-x2)*x2-2)*x2 )^2 + ...
+                ( x1-29+((x2+1)*x2-14)*x2 )^2;
+        end
+        
+        function [fval] = f_goldsteinprice(x)
+            x1 = x(1);
+            x2 = x(2);
+            fval = ( 1 + (x1+x2+1)^2 * (19-14*x1+3*x1^2-14*x2+6*x1*x2+3*x2^2) ) * ...
+                ( 30 + (2*x1-3*x2)^2 * (18-32*x1+12*x1^2+48*x2-36*x1*x2+27*x2^2) );
+        end
+
+        function [fval] = f_griewank(x)
+        % typical domain: [-10,10], [-600,600] or larger
+        % global minimum: [0] at [0,...,0]
+        % Problem: many local minima, one slightly smaller
+            product = 1;
+            for j = 1:length(x)
+                product = product*cos(x(j)/sqrt(j));
+            end
+            fval = 1 + sum(x.^2)/4000 - product;
+        end
+        
+        function [fval] = f_hyperellipse(x)
+        % typical domain: [-66,66]
+        % global minimum: [0] at [0,...,0]
+            dim = length(x);
+            
+            fval = 0;
+            for j = 1:dim
+                fval = fval + j*x(j)^2;
+            end
+        end
+        
+        function [fval] = f_levy(x)
+            dim = length(x);
+            w = 1+(x-1)/4;
+
+            sum2 = 0;
+            for j = 1:(dim-1)
+                sum2 = sum2 + (w(j)-1)^2 * (1+10*(sin(pi*w(j)+1))^2);
+            end
+
+            fval = (sin(pi*w(1)))^2 + sum2 + (w(dim)-1)^2*(1+(sin(2*pi*w(dim)))^2);
+        end
+        
+        function [fval] = f_matyas(x)
+        % x\in\R^2
+        % global minimum: [0] at [0,0]
+            fval = x(1)^2+x(2)^2-x(1)*x(2);
+        end
+        		
+		function [fval] = f_max(x)
+            fval = max(abs(x));
+        end
+        
+        function [fval] = f_mountainhole(x)
+            fval = x(1) * exp(-(x(1)^2+x(2)^2));
+        end
+
+        function [fval] = f_nesterov(x)
+            fval = sum(x.^2)/2+sum(abs(x));
+        end
+        
+        function [fval] = f_powellsum(x)
+            % differentiable but not smooth
+            dim = length(x);
+            fval = 0;
+            for j = 1:dim
+                fval = fval + abs(x(j))^(j+1);
+            end
+        end
+        
+        function [fval] = f_powellsum2(x)
+            dim = length(x);
+            fval = 0;
+            for j = 1:dim
+                fval = fval + abs(x(j))^j;
+            end
+        end
+                
+        function [fval] = f_power2(x)
+        % global minimum: [0] at [0,...,0]
+        % convex, smooth
+            fval = sum(x.^2);
+        end
+
+        function [fval] = f_power10(x)
+            fval = sum(x.^10);
+        end
+        
+        function [fval] = f_price1(x)
+        % global minima at x_i = -+5
+            fval = sum((abs(x)-5).^2);
+        end
+        
+        function [fval] = f_qing(x)
+        % same global minima at 0, -sqrt(j)
+            dim = length(x);
+            w = zeros(dim,1);
+            for j=1:dim
+                w(j) = x(j) + sqrt(j);
+            end
+            
+            fval = sum((w.^2-1).^2);
+        end
+        
+        function [fval] = f_quartic(x)
+            dim = length(x);
+            
+            fval = 0;
+            for j=1:dim
+                fval = fval + j*x(j)^4;
+            end
+        end
+		    
+        function [fval] = f_rastrigin(x)
+        % global minimum: [0] at [0,...,0]
+        % typical domain: [-5.12,5.12]
+        % Problem: many evenly distributed local minima, one global minimum
+            dim = length(x);
+            fval = 10*dim + sum(x.^2-10*cos(2*pi*x));
+        end
+         
+		function [fval] = f_rosenbrock(x)
+		% x\in\R^2: fval = (1-x(1))^2+100*(x(2)-x(1)^2)^2;
+		% typical domain: [-2,-1]*[2,3]
+        % global minimum: [0] at [1,1]
+        % Problem: narrow, crescent valley
+        % for 4\leq dim\leq 7: local minimum at [-1,1,...,1]
+        % Multimodal/unimodal in different dimensions?
+			if length(x) < 2, error('dimension must be greater one'); end
+            fval = 100*sum((x(1:end-1).^2 - x(2:end)).^2) + sum((x(1:end-1)-1).^2);
+        end
+        
+        function [fval] = f_salomon(x)
+            tmp = sqrt(sum(x.^2));
+            fval = 1 - cos(2*pi*tmp) + 0.1*tmp;
+        end
+        
+        function [fval] = f_schaffer2(x)
+        % x\in\R^2
+        % typical domain: [-100,100]
+        % global minimum: [0] at [0,0]
+            fval = 0.5 + ( (sin(x(1)^2-x(2)^2)^2)-0.5 ) / ( 1+0.001*(x(1)^2+x(2)^2) )^2;
+        end
+        
+               
+		function [fval] = f_schwefel1(x)
+			fval = (sum(x.^2))^3;
+		end
+		
+		function [fval] = f_schwefel2(x)
+			dim = length(x);
+			fval = 0;
+			
+			for j=1:dim
+                sumj = sum(x(1:j));
+				fval = fval + sumj^2;
+			end
+		end
+		
+		function [fval] = f_schwefel4(x)
+			dim = length(x);
+			fval = 0;
+			for j=1:dim
+				fval = fval + (x(j)-1)^2 + (x(1)-x(j)^2)^2;
+			end
+        end
+        
+        function [fval] = f_schwefel6(x)
+            fval = max([abs(x(1)+2*x(2)-7), abs(2*x(1)+x(2)-5)]);
+        end
+        
+        function [fval] = f_step(x)
+            fval = sum(floor(abs(x)*100));
+        end
+        		
+		function [fval] = f_sumprod(x)
+			fval = sum(abs(x)) + prod(abs(x));
+        end
+        
+        function [fval] = f_xinsheyang1(x)
+            fval = sum(abs(x)) * exp(-sum(sin(x.^2)));
+        end
+		
+        function [fval] = f_xinsheyang2(x)
+            fval = exp(-sum((x/15).^10)) - 2*exp(-sum(x.^2)) * prod(cos(x).^2);
+        end
+        
+        function [fval] = f_zakharov(x)
+            dim = length(x);
+            
+            sum2 = 0;
+            for j=1:dim
+                sum2 = sum2 + 0.5*j*x(j);
+            end
+            
+            fval = sum(x.^2) + sum2^2 + sum2^4;
+        end
+        
+        %% helper functions
+        
+        function cell_problems = f_getTestFunctions(bool_arbdim)
+        % create list of testfunctions, either those for arbitrary dimension,
+        % or for fixed dimension
+        
+            cell_problems = cell(0);
+            nTFs = length(TF.cell_tfs);
+            index = 0;
+            for j=1:nTFs
+                if ( TF.cell_tfs{j}.dim == Inf ) == bool_arbdim
+                    index = index + 1;
+                    cell_problems{index} = TF.cell_tfs{j};
+                end
+            end
+        end
+        
+        function [lb,ub,xbst] = f_getVectors(simple_problem,dim)
+        % create vectors for the specified dimension
+        
+            if (length(simple_problem.lb) == 1)
+                lb = simple_problem.lb*ones(dim,1);
+            else
+                lb = simple_problem.lb;
+            end
+            
+            if (length(simple_problem.ub) == 1)
+                ub = simple_problem.ub*ones(dim,1);
+            else
+                ub = simple_problem.ub;
+            end
+            
+            if (length(simple_problem.xbst) == 1)
+                xbst = simple_problem.xbst*ones(dim,1);
+            else
+                xbst = simple_problem.xbst;
+            end
+        end
+        
+        function fun_with_noise = f_addNoise(fun)
+        % additive gaussian noise of variance 1e-4
+            fun_with_noise = @(x) fun(x) + C.noise_standard_deviation*randn(1);
+        end
+        
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/VNS_report.mat b/Requirements/MEIGO/examples/VNS_report.mat
new file mode 100644
index 0000000000000000000000000000000000000000..cee400060cafd358a6bde35bf007df6254e38752
Binary files /dev/null and b/Requirements/MEIGO/examples/VNS_report.mat differ
diff --git a/Requirements/MEIGO/examples/ex1.m b/Requirements/MEIGO/examples/ex1.m
new file mode 100644
index 0000000000000000000000000000000000000000..1c887702d2bccee9906999308d969f683e67caf7
--- /dev/null
+++ b/Requirements/MEIGO/examples/ex1.m
@@ -0,0 +1,18 @@
+function [f, c, gf, gc]=ex1(x) %DW
+    % f: objective function value; c: equality constraints; 
+    % gf: gradient of objective function; gc: gradient of constraints (not
+    % yet implemented)
+    f=4*x(1).*x(1)-2.1*x(1).^4+1/3*x(1).^6+x(1).*x(2)-4*x(2).*x(2)+4*x(2).^4;
+    
+    c=[];
+    
+    if nargout > 2
+        gf=[8*x(1)-8.4*x(1).^3+2*x(1).^5+x(2), ...
+            x(1)-8*x(2)+16*x(2).^3];
+        gc=[];
+    end
+return
+
+function F=old_ex1(x)
+    f=4*x(1).*x(1)-2.1*x(1).^4+1/3*x(1).^6+x(1).*x(2)-4*x(2).*x(2)+4*x(2).^4;
+return
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/ex2.m b/Requirements/MEIGO/examples/ex2.m
new file mode 100644
index 0000000000000000000000000000000000000000..e920820a66797193c4c5acf027352ed46e67288d
--- /dev/null
+++ b/Requirements/MEIGO/examples/ex2.m
@@ -0,0 +1,5 @@
+function [F,g]=ex2(x)
+F=-x(1)-x(2);
+g(1)=x(2)-2*x(1).^4+8*x(1).^3-8*x(1).^2;
+g(2)=x(2)-4*x(1).^4+32*x(1).^3-88*x(1).^2+96*x(1);
+return
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/ex3.m b/Requirements/MEIGO/examples/ex3.m
new file mode 100644
index 0000000000000000000000000000000000000000..050b268d4b67a02400be998feae08acc6815a692
--- /dev/null
+++ b/Requirements/MEIGO/examples/ex3.m
@@ -0,0 +1,19 @@
+function [f,g]=ex3(x,k1,k2,k3,k4)
+
+% k1=0.09755988;
+% k3=0.0391908;
+% k2=0.99*k1;
+% k4=0.9*k3;
+
+f=-x(4);
+
+%Equality constraints
+g(1)=x(4)-x(3)+x(2)-x(1)+k4*x(4).*x(6);
+g(2)=x(1)-1+k1*x(1).*x(5);
+g(3)=x(2)-x(1)+k2*x(2).*x(6);
+g(4)=x(3)+x(1)-1+k3*x(3).*x(5);
+
+%Inequality constraint
+g(5)=x(5).^0.5+x(6).^0.5;
+
+return
diff --git a/Requirements/MEIGO/examples/ex4.m b/Requirements/MEIGO/examples/ex4.m
new file mode 100644
index 0000000000000000000000000000000000000000..c1b80e33a5a76f82e90f44630f2ce9a96e2b478d
--- /dev/null
+++ b/Requirements/MEIGO/examples/ex4.m
@@ -0,0 +1,6 @@
+function [F,g]=ex4(x)
+F = x(2)^2 + x(3)^2 + 2.0*x(1)^2 + x(4)^2 - 5.0*x(2) - 5.0*x(3) - 21.0*x(1) + 7.0*x(4);
+g(1) = x(2)^2 + x(3)^2 + x(1)^2 + x(4)^2 + x(2) - x(3) + x(1) - x(4);
+g(2) = x(2)^2 + 2.0*x(3)^2 + x(1)^2 + 2.0*x(4)^2 - x(2) - x(4);
+g(3) = 2.0*x(2)^2 + x(3)^2 + x(1)^2 + 2.0*x(2) - x(3) - x(4);
+return
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/ex5.m b/Requirements/MEIGO/examples/ex5.m
new file mode 100644
index 0000000000000000000000000000000000000000..0fe78ee2e51cf519ad73071d07799b4dfb011df7
--- /dev/null
+++ b/Requirements/MEIGO/examples/ex5.m
@@ -0,0 +1,36 @@
+function [J,g,R]=ex5(x,texp,yexp)
+
+[tout,yout] = ode15s(@ex5_dynamics,texp,[100 0 0 0 0],[],x);
+
+R=(yout-yexp);
+R=reshape(R,numel(R),1);
+
+
+J = sum(sum((yout-yexp).^2));
+g=0;
+return
+
+%***************************************************
+%Function of the dynamic system
+function dy=ex5_dynamics(t,y,p)
+
+dy=zeros(5,1);  %Initialize the state variables
+
+
+dy(1)=-(p(1)+p(2))*y(1);
+dy(2)=p(1)*y(1);
+dy(3)=p(2)*y(1)-(p(3)+p(4))*y(3)+p(5)*y(5);
+dy(4)=p(3)*y(3);
+dy(5)=p(4)*y(3)-p(5)*y(5);
+
+return
+%***************************************************
+
+
+
+   
+     
+   
+ 
+ 
+ 
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/ex6.m b/Requirements/MEIGO/examples/ex6.m
new file mode 100644
index 0000000000000000000000000000000000000000..1b9e616177e74c89f855263e1e639163e3499e48
--- /dev/null
+++ b/Requirements/MEIGO/examples/ex6.m
@@ -0,0 +1,13 @@
+function [fval] = ex6(x)
+% Ackley's optimization test function. Problem: many local minima, one
+% steep global minimum fval = 0 at x = [0,...,0]
+
+a = 20;
+b = 0.2;
+c = 2*pi;
+dim = length(x);
+
+fval = -a*exp(-b*sqrt(sum(x.^2)/dim)) - exp(sum(cos(c*x))/dim) + a + exp(1);
+
+end
+
diff --git a/Requirements/MEIGO/examples/f17.m b/Requirements/MEIGO/examples/f17.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3aecea8f997be37ad7b487fa5fe060d79287fad
--- /dev/null
+++ b/Requirements/MEIGO/examples/f17.m
@@ -0,0 +1,44 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% F17: D/m-group Shifted Schwefel's Problem 1.2
+% D = 1000, m = 50, D/m = 20
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+function fit = f17(x)
+
+	[ps D] = size(x);
+	m = 50;
+	G = D/m;
+	
+	global initial_flag;
+	persistent o p;
+
+	if (isempty(initial_flag) || initial_flag == 0)	
+			load 'f17_op.mat';
+			initial_flag = 1;
+	end
+
+	if (D ~= 1000)
+        disp('F17 error: only support D = 1000 now');
+        error(17);
+    end
+
+	x = x-repmat(o,ps,1);
+	fit = 0;
+	for k = 1:G
+		index = ((k-1)*m+1):(k*m);
+		fit = fit + schwefel_func(x(:,p(index)));
+	end
+	
+end
+
+function fit = schwefel_func(x)
+
+	[ps D] = size(x);
+	fit = 0;
+	for i = 1:D
+		fit = fit + sum(x(:,1:i),2).^2;
+	end
+	
+end
+
+
+
diff --git a/Requirements/MEIGO/examples/f17_op.mat b/Requirements/MEIGO/examples/f17_op.mat
new file mode 100644
index 0000000000000000000000000000000000000000..44312680dd1ad956de850bae24ae663b6b0cb512
Binary files /dev/null and b/Requirements/MEIGO/examples/f17_op.mat differ
diff --git a/Requirements/MEIGO/examples/main_TF.m b/Requirements/MEIGO/examples/main_TF.m
new file mode 100644
index 0000000000000000000000000000000000000000..e70967e346134a94b1491333909d6418b689f40a
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_TF.m
@@ -0,0 +1,31 @@
+% In this example, we use problems from the TF class, which basically
+% contains diverse optimization test problems.
+
+% Feel free to try out also other problems and settings, e.g.
+% non-differentiable problems and the impact of noise.
+
+% test problem
+test_problem = TF.hyperellipse;
+
+% dimension
+dim = 20;
+
+% get values for dimension
+[lb,ub] = TF.f_getVectors(test_problem, dim);
+
+% set up MEIGO
+
+problem = struct();
+problem.f = test_problem.fun; % here we pass a function handle
+problem.x_L = lb;
+problem.x_U = ub;
+
+options = struct();
+options.maxeval = 200*dim;
+options.local.solver = 'fmincon';
+options.local.finish = 'fmincon';
+options.local.iterprint = 1;
+
+% run optimization
+
+results = MEIGO(problem, options, 'ESS');
diff --git a/Requirements/MEIGO/examples/main_ex1.m b/Requirements/MEIGO/examples/main_ex1.m
new file mode 100644
index 0000000000000000000000000000000000000000..953731d4b60ee56e3f7e732ac1e05855424bd12b
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_ex1.m
@@ -0,0 +1,32 @@
+clear mex;
+clear all;
+close all;
+
+
+% global optimum
+%
+%x*=[0.0898, -0.7127];
+% or    
+%x*=[-0.0898, 0.7127];
+%
+%f(x*)= -1.03163;
+
+
+	
+	
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+problem.f='ex1';                               %mfile containing the objective function
+problem.x_L=-1*ones(1,2);                      %lower bounds         
+problem.x_U=ones(1,2);                         %upper bounds
+
+opts.maxeval=500;
+opts.ndiverse=40;
+opts.local.use_gradient_for_finish = 1; %DW: provide gradient to fmincon
+opts.local.check_gradient_for_finish = 1; %DW: gradient checker
+opts.local.solver='fmincon';
+opts.local.finish='fmincon';
+opts.local.iterprint=1;
+%========================= END OF PROBLEM SPECIFICATIONS =====================
+
+Results=MEIGO(problem,opts,'ESS');
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/main_ex2.m b/Requirements/MEIGO/examples/main_ex2.m
new file mode 100644
index 0000000000000000000000000000000000000000..66b31b1a6f3c3992342d6c148543ed6c410e2da3
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_ex2.m
@@ -0,0 +1,23 @@
+clear mex;
+clear all;
+close all;
+
+% global optimum
+%
+%x*=[2.32952, 3.17849];
+%    
+%f(x*)=-5.50801
+
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+problem.f='ex2';                           %mfile containing the objective function
+problem.x_L=[0 0];                         %lower bounds         
+problem.x_U=[3 4];                         %upper bounds
+problem.c_L=[-inf -inf];
+problem.c_U=[2 36];
+
+opts.maxeval=750;
+opts.local.n1=2;
+opts.local.n2=3;
+%========================= END OF PROBLEM SPECIFICATIONS =====================
+Results=MEIGO(problem,opts,'ESS');
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/main_ex3.m b/Requirements/MEIGO/examples/main_ex3.m
new file mode 100644
index 0000000000000000000000000000000000000000..4cecf0b9120677a08704cc30630fbf14e5ad4bc9
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_ex3.m
@@ -0,0 +1,37 @@
+clear mex;
+clear all;
+close all;
+
+%global optimum
+%
+%x*=[0.77152
+% 	0.516994
+% 	0.204189
+% 	0.388811
+% 	3.0355
+% 	5.0973];
+% 
+%f(x*)= -0.388811;
+
+
+%====================== PROBLEM DEPENDENT DECLARATIONS=====================
+%=================== END OF PROBLEM DEPENDENT DECLARATIONS ================
+
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+problem.f='ex3';                                    
+problem.x_L=[0 0 0 0 0 0];      
+problem.x_U=[1 1 1 1 16 16];  
+problem.neq=4;
+problem.c_L=-inf;
+problem.c_U=4;
+   
+opts.maxtime=5;
+opts.local.solver='solnp';
+%========================= END OF PROBLEM SPECIFICATIONS =====================
+k1=0.09755988;
+k3=0.0391908;
+k2=0.99*k1;
+k4=0.9*k3;
+
+[Results]=MEIGO(problem,opts,'ESS',k1,k2,k3,k4);
diff --git a/Requirements/MEIGO/examples/main_ex4.m b/Requirements/MEIGO/examples/main_ex4.m
new file mode 100644
index 0000000000000000000000000000000000000000..b51253617e1077288686e60530990f5b9d9cd44a
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_ex4.m
@@ -0,0 +1,25 @@
+clear mex;
+clear all;
+close all;
+
+
+% global optimum
+%
+%x*=[2.23607, 0, 1, 0];
+%    
+%f(x*)=-40.9575;
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+problem.f='ex4';                                          
+problem.x_L=[0 0 0 0];                                          
+problem.x_U=[10 10 10 10];                                    
+problem.x_0=[3 4 5 1];                                               
+problem.int_var=3;
+problem.c_L=[-inf -inf -inf ];                               
+problem.c_U=[8 10 5];                     
+
+opts.local.solver='misqp';
+opts.maxtime=2;
+%========================= END OF PROBLEM SPECIFICATIONS =====================
+
+Results=MEIGO(problem,opts,'ESS');
diff --git a/Requirements/MEIGO/examples/main_ex5.m b/Requirements/MEIGO/examples/main_ex5.m
new file mode 100644
index 0000000000000000000000000000000000000000..ad04733d456aabe8db3e7cf95da4aa7dec4afab7
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_ex5.m
@@ -0,0 +1,46 @@
+clear mex;
+clear all;
+close all;
+
+
+% global optimum
+%
+%x*=[5.92585e-005
+%   2.9634e-005
+%   2.0471e-005
+%   0.000274465
+%   3.99821e-005];
+%    
+%f(x*)=19.8721
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+problem.f='ex5';           
+
+problem.x_L=zeros(1,5);
+problem.x_U=ones(1,5);
+
+problem.x_0=0.5*ones(1,5);
+opts.maxeval=1e3; 
+opts.log_var=[1:5];
+opts.local.solver='nl2sol';
+opts.inter_save=1;
+%========================= END OF PROBLEM SPECIFICATIONS =====================
+%time intervals
+
+texp=[0 1230 3060 4920 7800 10680 15030 22620 36420];
+ 
+% Distribution of species concentration
+ %	     y(1)    y(2)    y(3)    y(4)    y(5)
+ 
+ yexp=[ 100.0	 0.0	 0.0	 0.0     0.0
+    	88.35    7.3     2.3     0.4     1.75
+        76.4    15.6     4.5     0.7     2.8
+        65.1    23.1     5.3     1.1     5.8
+        50.4    32.9     6.0     1.5     9.3
+        37.5    42.7     6.0     1.9    12.0
+        25.9    49.1     5.9     2.2    17.0
+        14.0    57.4     5.1     2.6    21.0
+         4.5    63.1     3.8     2.9    25.7 ];
+
+
+Results=MEIGO(problem,opts,'ESS',texp,yexp);
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/main_ex6.m b/Requirements/MEIGO/examples/main_ex6.m
new file mode 100644
index 0000000000000000000000000000000000000000..5434f1660fee770b11deb34ef34e6e590c4b44eb
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_ex6.m
@@ -0,0 +1,28 @@
+% Here, we consider Ackley's optimization test function, which is defined
+% for arbitrary dimension and possesses many local minima with one steep
+% global minimum fval = 0 at x = [0,...,0].
+
+% consider the problem in dimension 100
+
+dim = 100;
+
+% create problem struct
+
+problem = struct();
+problem.f = 'ex6';
+problem.x_L = -20*ones(dim,1);
+problem.x_U = 20*ones(dim,1);
+
+% create options struct
+
+options = struct();
+options.maxeval = 2000;
+
+% as local solver, we consider ydhc. Alternatively, try e.g. dhc and
+% fmincon, or any other solver.
+options.local.solver = 'ydhc';
+options.local.iterprint = 0;
+
+% run optimization
+
+results = MEIGO(problem, options, 'ESS');
diff --git a/Requirements/MEIGO/examples/main_multistart_ex3.m b/Requirements/MEIGO/examples/main_multistart_ex3.m
new file mode 100644
index 0000000000000000000000000000000000000000..54054907ef0e952782ae30376431d1f4833409b6
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_multistart_ex3.m
@@ -0,0 +1,28 @@
+clear mex;
+clear all;
+close all;
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+problem.f='ex3';                                    
+problem.x_L=[0 0 0 0 0 0];      
+problem.x_U=[1 1 1 1 16 16];  
+problem.neq=4;
+problem.c_L=-inf;
+problem.c_U=4;
+
+opts.ndiverse=25;
+
+opts.local.solver='solnp';
+opts.local.iterprint=1;
+opts.local.tol=2;
+%=========================================================================
+k1=0.09755988;
+k3=0.0391908;
+k2=0.99*k1;
+k4=0.9*k3;
+
+Results_multistart=MEIGO(problem,opts,'MULTISTART',k1,k2,k3,k4);
+
+
+
+
diff --git a/Requirements/MEIGO/examples/main_rosen10.m b/Requirements/MEIGO/examples/main_rosen10.m
new file mode 100644
index 0000000000000000000000000000000000000000..2c4db2dcaa5d6a1ac1a2dc7b3b99cfe3e7c24bda
--- /dev/null
+++ b/Requirements/MEIGO/examples/main_rosen10.m
@@ -0,0 +1,12 @@
+clear all
+
+%========================= PROBLEM SPECIFICATIONS ===========================
+nvar=10;
+problem.x_L=-5*ones(1,nvar);
+problem.x_U=5*ones(1,nvar);
+problem.f='rosen10';
+
+opts.maxeval=1000;
+algorithm='VNS';
+
+[Results]=MEIGO(problem,opts,algorithm);
diff --git a/Requirements/MEIGO/examples/objf_n2fb.m b/Requirements/MEIGO/examples/objf_n2fb.m
new file mode 100644
index 0000000000000000000000000000000000000000..6f063f0219d3921e4a861926fd4d5cdc84deb047
--- /dev/null
+++ b/Requirements/MEIGO/examples/objf_n2fb.m
@@ -0,0 +1,6 @@
+function [R]= objf_n2fb (N,P,x,NF,R,LTY,TY)
+global n_fun_eval 
+global input_par 
+[f,g,R]= ex5(x,input_par{:});
+n_fun_eval=n_fun_eval+1; 
+return
diff --git a/Requirements/MEIGO/examples/objf_nl2sol.m b/Requirements/MEIGO/examples/objf_nl2sol.m
new file mode 100644
index 0000000000000000000000000000000000000000..143da622cb9c2dad7652b71ceb251910a3829c5b
--- /dev/null
+++ b/Requirements/MEIGO/examples/objf_nl2sol.m
@@ -0,0 +1,8 @@
+function [R]= objf_nl2sol(x)
+% Objective function for NL2SOL in AMIGO
+% Automatically generated in ssm_aux_local.m
+global n_fun_eval 
+global input_par 
+[f,g,R]= ex5(x,input_par{:});
+n_fun_eval=n_fun_eval+1; 
+return
diff --git a/Requirements/MEIGO/examples/rosen10.m b/Requirements/MEIGO/examples/rosen10.m
new file mode 100644
index 0000000000000000000000000000000000000000..2c87f635e44872345b3c32159cd71546eeae7c08
--- /dev/null
+++ b/Requirements/MEIGO/examples/rosen10.m
@@ -0,0 +1,8 @@
+function [f g]= rosen10(x)
+f=0;
+n=10;
+for i=1:n-1
+    f = f + 100*(x(i)^2 - x(i+1))^2 + (x(i)-1)^2;
+end
+g=[];
+return
\ No newline at end of file
diff --git a/Requirements/MEIGO/examples/run_cess.m b/Requirements/MEIGO/examples/run_cess.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3e332fa30769590ff1991ccc152026cfe1ce5c7
--- /dev/null
+++ b/Requirements/MEIGO/examples/run_cess.m
@@ -0,0 +1,26 @@
+nthreads=8;
+npars=1000;
+n_iter=4;
+is_parallel=false;
+%THis is too short for this problem, only for testing purposes
+maxtime_per_iteration=30;
+
+par_struct=get_CeSS_options(nthreads,npars,maxtime_per_iteration);
+x_L=-100*ones(1,npars);
+x_U= 100*ones(1,npars);
+
+for i=1:nthreads
+		
+	par_struct(i).problem.f='f17';
+	par_struct(i).problem.x_L=x_L;
+	par_struct(i).problem.x_U=x_U;
+	%DHC takes as bit to run, uncoment the next two lines for tests
+	par_struct(i).opts.local.solver  = 0; 
+	par_struct(i).opts.local.finish  = 0;
+	
+end
+
+Results = CeSS(par_struct,n_iter,is_parallel)
+
+plot(Results.time,log10(Results.f))
+
diff --git a/Requirements/MEIGO/examples/run_cevns.m b/Requirements/MEIGO/examples/run_cevns.m
new file mode 100644
index 0000000000000000000000000000000000000000..e582413c17bb34cbd2d5b6be388f6f2f22977b5d
--- /dev/null
+++ b/Requirements/MEIGO/examples/run_cevns.m
@@ -0,0 +1,23 @@
+nthreads=2;
+n_iter=2;
+is_parallel=true;
+npars=50;
+maxtime_per_iteration=10;
+
+x_L=-5*ones(1,npars);
+x_U= 5*ones(1,npars);;
+x_0= round(rand(1,npars).*(x_U-x_L+1)+x_L-0.5)
+
+par_struct=get_CeVNS_options(nthreads,npars,maxtime_per_iteration);
+
+for i=1:nthreads
+		
+	par_struct(i).problem.f='rosen10';
+	par_struct(i).problem.x_L=x_L;
+	par_struct(i).problem.x_U=x_U;
+	par_struct(i).problem.x_0=x_0;
+	
+end
+
+Results = CeVNS(par_struct,n_iter,is_parallel)
+
diff --git a/Requirements/MEIGO/examples/run_f17_CeSS.m b/Requirements/MEIGO/examples/run_f17_CeSS.m
new file mode 100644
index 0000000000000000000000000000000000000000..b1c73578b703196211126f1e6ec665e31a3c0525
--- /dev/null
+++ b/Requirements/MEIGO/examples/run_f17_CeSS.m
@@ -0,0 +1,27 @@
+nthreads=2;
+npars=1000;
+n_iter=2;
+is_parallel=true;
+%THis is too short for this problem, only for testing purposes
+maxtime_per_iteration=100;
+
+par_struct=get_CeSS_options(nthreads,npars,maxtime_per_iteration);
+x_L=-100*ones(1,npars);
+x_U= 100*ones(1,npars);
+
+for i=1:nthreads
+		
+	par_struct(i).problem.f='f17';
+	par_struct(i).problem.x_L=x_L;
+	par_struct(i).problem.x_U=x_U;
+    par_struct(i).opts.ndiverse    = 100;
+	%DHC takes as bit to run, uncoment the next two lines for tests
+	par_struct(i).opts.local.solver  = 0; 
+	par_struct(i).opts.local.finish  = 0;
+	
+end
+
+Results = CeSS(par_struct,n_iter,is_parallel);
+
+stairs(Results.time,Results.f)
+
diff --git a/Requirements/MEIGO/examples/run_rosen10_CeVNS.m b/Requirements/MEIGO/examples/run_rosen10_CeVNS.m
new file mode 100644
index 0000000000000000000000000000000000000000..4fbbbfd396e7c52b42b83ca11171bf9280b0bdd8
--- /dev/null
+++ b/Requirements/MEIGO/examples/run_rosen10_CeVNS.m
@@ -0,0 +1,23 @@
+nthreads=2;
+n_iter=2;
+is_parallel=true;
+npars=50;
+maxtime_per_iteration=10;
+
+x_L=-5*ones(1,npars);
+x_U= 5*ones(1,npars);
+x_0= round(rand(1,npars).*(x_U-x_L+1)+x_L-0.5)
+
+par_struct=get_CeVNS_options(nthreads,npars,maxtime_per_iteration);
+
+for i=1:nthreads
+		
+	par_struct(i).problem.f='rosen10';
+	par_struct(i).problem.x_L=x_L;
+	par_struct(i).problem.x_U=x_U;
+	par_struct(i).problem.x_0=x_0;
+	
+end
+
+Results = CeVNS(par_struct,n_iter,is_parallel)
+
diff --git a/Requirements/MEIGO/examples/ssm_multistart_report.mat b/Requirements/MEIGO/examples/ssm_multistart_report.mat
new file mode 100644
index 0000000000000000000000000000000000000000..6c51c54cc62d551075ea61e677feb74750ca3be4
Binary files /dev/null and b/Requirements/MEIGO/examples/ssm_multistart_report.mat differ
diff --git a/Requirements/MEIGO/examples/test_f17_R.m b/Requirements/MEIGO/examples/test_f17_R.m
new file mode 100644
index 0000000000000000000000000000000000000000..deb11a98e26bbc1b108935e54386dc693d71b058
--- /dev/null
+++ b/Requirements/MEIGO/examples/test_f17_R.m
@@ -0,0 +1,4 @@
+vals= [-55.63837 -29.29515 76.91292 -70.72446 -88.6223 34.59761 42.58014 43.84095 -37.24968 -88.62922 -13.92433 18.47268 -46.97284 -3.899489 -48.93648 -28.52707 30.40822 10.64226 37.66201 -7.330864 17.61975 -12.7718 -66.82842 -53.06068 49.17852 91.69659 -44.61534 79.0484 -50.49248 -78.71482 -32.52005 -54.33243 19.1632 68.06282 -31.69043 6.526317 -78.96385 -43.81164 -17.90101 44.00594 -55.86909 -22.6525 -35.14067 79.85491 -20.93575 -38.88341 -8.21867 62.19694 -17.57758 -87.68342 32.0641 -19.85405 -94.93675 -70.06901 -16.14505 -11.11363 -8.154407 -54.50516 -19.38111 19.55731 -64.89623 49.98066 -30.07584 -6.508359 51.00212 -39.28126 -77.33884 4.983717 83.25792 10.95227 -49.69448 -44.96362 21.38095 -92.63824 -20.71776 -7.09887 -56.40345 87.90221 -14.8683 -29.52678 72.10169 52.00494 80.88293 28.36979 93.81468 78.13319 -50.24049 63.88471 40.92324 94.77628 20.30175 -23.30854 -38.15823 20.68135 -76.43329 48.01677 73.869 -15.98886 -63.20269 44.04366 -0.4417519 -41.71894 16.97396 -34.911 -16.56334 -94.13958 14.66508 64.4511 -9.817153 -23.42312 20.4179 17.78645 24.60787 32.11578 22.17853 70.57244 97.04141 13.16653 -44.25048 -11.28893 -13.97992 -82.30369 -24.01997 44.43418 78.35995 -10.19244 -70.53609 100 -63.41508 -59.38287 96.01121 -61.46293 -39.52316 -0.3676696 8.16611 47.50307 -36.24436 -63.04253 -45.13914 24.45299 -97.39964 -4.385664 93.65236 55.79248 -82.29656 24.88417 79.71836 -64.72108 58.42748 3.128292 100 71.74405 11.65374 -4.664991 8.749373 32.5627 45.85869 14.76605 75.42471 27.91829 11.67631 -24.63464 -94.8552 100 -25.57866 -41.09543 93.0065 2.524419 74.23439 18.30568 4.250706 21.29711 79.90625 53.05375 -3.687255 46.02587 -50.03227 -60.58533 63.19704 30.30301 -14.25479 -44.5524 -76.40909 38.53171 -78.15215 -14.01362 48.60601 21.54324 70.21554 81.69902 -62.18553 29.78529 -54.80534 11.35394 -59.06067 23.17666 -0.7076625 -65.87989 -86.12915 94.76476 -13.40873 30.05348 37.37018 46.22336 26.30809 -9.783651 81.1419 50.59599 5.683065 86.54157 4.791406 88.79799 -88.36186 -89.65766 -84.01291 -15.75341 95.41515 49.74484 61.46832 2.334893 100 -40.94299 -22.76964 -67.59441 46.60291 11.12077 -16.25419 -33.76993 2.812487 63.41 48.54036 -11.21303 0.9693105 -91.49105 -23.06995 22.75607 -4.205014 12.5006 -58.69062 -93.64077 -79.94329 14.43823 -24.48267 -81.954 31.33618 86.24656 28.30287 28.50391 -25.01458 -0.6732046 -13.03878 30.31296 91.91192 -21.8002 37.54821 -5.237723 3.196825 -11.27963 12.81148 -44.96129 -69.98447 88.81319 -48.15285 -41.70142 -84.39979 97.94992 -36.69794 -49.68856 -18.91158 -87.85488 -35.05303 -58.81499 29.45362 -62.20422 -88.99188 -87.53123 27.46975 -47.86952 45.54325 -32.65762 84.33265 97.55331 44.28714 -13.97302 23.8664 -34.95153 -100 -58.3254 47.11408 93.42324 23.37193 72.96734 -93.98351 12.72894 21.37512 12.83399 79.80641 78.56436 -22.82061 42.46385 9.207172 -49.27394 92.26253 -97.30443 42.87323 80.08175 81.61404 7.760008 7.903414 -4.474042 97.40181 29.99904 -13.49435 32.81748 -93.82858 92.05119 -47.07774 66.97473 -33.30513 -21.84707 -43.96503 -50.67812 62.54844 56.95097 -55.90383 69.00225 46.59767 100 -95.465 -44.63434 6.221305 -79.92976 25.00824 13.38721 84.24958 -48.88065 -26.12387 -45.07326 84.07811 92.24922 94.48981 10.13552 -34.285 -13.38782 1.583644 84.76345 82.82631 -49.68879 36.59137 -77.94771 -72.86617 -36.12325 29.80232 -73.62946 -18.06081 13.70192 44.17531 -9.556479 -75.63516 9.803817 100 -1.933209 100 31.78599 -15.7081 69.22481 -5.441873 -40.48094 -6.266507 -16.97927 56.05683 -77.13031 -96.13861 44.39582 39.54063 -5.469381 3.513729 -58.04165 35.56485 8.922737 62.59985 67.23423 -64.61611 3.310308 29.2809 -20.9633 23.06161 0.05685982 3.60836 23.89767 51.67854 -49.11828 -41.05993 -72.18378 -35.87007 -78.22147 -0.5230105 -57.61175 -21.74506 -81.59584 -83.06063 -70.99506 93.5892 100 -12.12201 12.93404 -7.644971 63.59942 -59.87861 38.90391 48.37311 -32.67247 -50.44457 11.13464 -1.817205 24.19536 7.363582 31.95177 -7.537546 -17.55438 46.91347 5.259832 63.89024 53.61631 41.1543 83.03595 -26.90035 -29.56017 -9.34103 67.3533 -49.10909 -44.71861 73.25147 63.37675 -17.97986 -6.125484 -83.92473 -39.84025 77.79678 17.32294 -21.09947 34.01517 20.51945 18.83509 28.01916 -45.89293 95.43654 -3.534134 49.78287 83.98397 -95.48042 11.0474 -2.167301 95.65809 -48.78547 6.094292 48.12744 31.88629 -98.57887 30.59252 1.066333 -2.467645 30.90263 85.33793 14.88054 -3.63235 60.06704 21.70713 -32.49916 -14.44338 -28.70769 7.082488 61.92684 -38.97924 -44.46657 -79.69801 -40.53952 -86.50768 -4.94171 -2.498971 64.05529 21.27814 -21.64959 -91.39522 63.85087 79.85858 -91.04599 -100 32.76856 -66.77747 -12.63876 -18.32199 -94.60718 78.17946 -47.27625 19.60859 -61.56051 -79.53743 46.49503 44.67648 -100 -11.31108 21.00047 48.6027 51.15911 -37.5423 41.37316 62.14399 -41.55932 28.91934 -50.03192 45.08826 69.20058 -7.922209 -17.2732 -52.98193 59.9079 -42.5429 62.42045 -38.86125 69.04353 -84.3936 -36.22543 -89.57111 25.72332 -14.66273 78.32612 25.2427 -54.32783 42.79646 99.42749 55.28163 -47.97315 29.83089 41.86558 -86.84628 77.81446 61.45271 -43.7034 9.361471 -45.59556 0.2113391 49.4515 -50.03572 -64.8853 -46.03279 63.90938 -44.03152 55.14825 81.61456 71.57587 60.60939 91.18217 50.26973 -21.93969 -96.31729 65.48275 -32.35965 -49.7444 5.393051 -22.36147 21.05353 -71.41977 97.92295 -40.92574 -18.6 -57.43053 -40.88213 -79.40615 40.18845 -17.15066 9.186707 -23.34068 11.17206 100 1.287766 41.77232 -42.05432 -3.459653 55.04999 17.26686 -45.98301 -16.86628 60.29615 -8.632493 21.33778 53.09119 -47.9487 43.18297 -77.62437 -13.0887 42.55354 -28.97837 -53.43979 43.03966 24.01258 -62.232 29.94926 -7.284681 12.93577 62.11614 -8.579073 60.71158 76.96059 10.26027 78.10152 -95.4558 59.35091 71.38156 73.3765 -76.49351 -27.65327 -62.64178 30.88367 21.44695 42.26118 -11.66507 4.909831 58.5047 -89.52822 2.925237 91.24331 28.59443 49.28969 -26.17551 91.90051 -49.64159 -91.56188 -38.76571 -29.163 -16.20301 -31.10402 23.12314 52.98094 -31.35068 52.60566 6.407091 -66.4945 50.32658 95.66029 -7.059065 77.94888 -61.2711 -22.04986 73.05296 -43.43026 -7.10043 -12.6633 70.87095 -48.40027 5.322934 -32.73357 41.75976 -35.1441 -15.15218 87.59406 -51.61354 52.41878 74.68444 17.40725 6.370939 40.26543 -45.53306 -41.41033 -9.433077 -53.87686 -56.62688 -93.69068 56.77674 -17.88468 -61.73683 67.10373 62.44107 -95.93024 -28.36199 4.039078 4.908967 -17.61325 50.84414 -42.17655 55.1201 33.22621 51.12553 -79.5738 24.16641 -86.0921 -75.79854 51.89651 15.78704 -73.56854 5.161397 95.40419 -6.62984 59.44625 -67.01793 -36.73642 -72.27803 3.352279 40.94153 46.7013 25.88806 27.26913 -18.60235 -88.0302 48.76872 -22.64911 48.79894 -29.40798 48.01764 31.64496 81.52322 -13.21014 -68.51124 -35.80872 -5.744945 -57.27272 -45.20345 -86.88034 -71.79476 -42.33435 -53.91667 -2.295095 -10.71372 -26.25758 75.96419 -17.76443 13.41131 -28.15762 -81.96759 28.19768 -54.17973 13.87362 8.168777 -71.07251 20.30823 -68.32482 -100 -96.97937 -28.08865 -39.76055 -28.73535 -5.287256 -47.878 5.202834 9.351731 96.20673 28.7479 -61.41079 10.55048 31.02854 -10.0581 8.964566 -20.6514 13.61381 3.634969 22.93468 -85.60571 48.05056 -8.958394 -87.29271 35.53493 34.5683 -23.39808 12.23518 20.86937 28.37641 -29.80087 97.26417 -4.431645 12.93187 -2.822629 18.73358 86.13805 51.8555 75.67076 52.17652 -17.90682 55.47266 47.49392 90.66478 -34.02295 18.63533 20.81517 -50.5648 36.37375 96.71174 53.29692 -14.82689 39.24209 49.6376 58.85045 -49.00788 5.279443 -47.2877 -19.00344 -27.50233 -48.97804 -77.85777 70.85667 61.90108 74.09696 -57.81011 -43.10085 -79.464 48.44701 74.72306 -7.897505 11.30707 -56.80688 -7.453407 -5.029727 19.2387 -23.83462 -12.20997 43.01995 -86.63222 15.89054 -97.5444 38.17482 99.43316 -41.98447 -14.88638 -57.03735 5.0422 88.7151 31.06701 -17.75464 39.31328 3.918251 -46.5082 48.07438 10.48568 85.33222 42.1248 18.48971 40.49396 47.41933 12.39258 -17.70418 -18.11148 28.26856 58.04481 67.80624 27.03767 95.42685 -67.2112 -9.146149 64.88623 42.25614 77.16304 -33.73356 52.43976 7.431007 -59.80561 -99.55104 51.45645 40.055 85.94234 -63.91543 -15.34658 40.78133 -7.360411 -20.81001 19.68526 14.51795 26.31938 -18.82445 -23.69957 -19.12294 44.69902 -37.22877 60.23041 -36.14791 -80.12347 100 4.688142 -5.531215 -92.15339 67.09726 43.59556 -45.60884 -7.759013 19.98364 27.86443 5.721549 -0.7746054 53.47142 -97.45317 -17.73657 -62.53066 21.35384 -27.17501 14.45442 -52.93975 12.0053 -76.53591 57.78522 -17.95666 -14.54478 67.72382 78.00822 76.28284 44.16757 -92.91885 19.46314 65.30957 94.95336 -64.08291 44.14231 -12.02377 -16.73015 -16.82904 -14.81673 58.39794 61.34824 -84.25613 97.53689 44.12654 22.18507 58.37361 -64.34929 -21.26078 -29.55249 -31.5937 -25.05485 87.50832 -20.58631 -30.91295 16.64681 -31.64295 -4.179157 -30.78329 35.25216 -61.0899 52.23724 -11.73834 -45.96106 9.473393 19.5254 -46.71598 -48.99331 -6.292916 -76.56635 -13.38069 -9.620677 69.2504 -77.79222 -52.64545 94.78826 55.87314 -24.19208 -40.70062 77.71361 10.78314 3.077842 66.15806 -26.76064 21.1907 43.14354 79.92216 -62.76888 -37.6466 -73.65163 -55.07997 45.03548 3.783738 43.36179 -37.87668 -1.51275 90.14122 -16.88941 -9.259341 35.20066 19.40419 -36.46502 -29.38968 85.94077 -60.53022 34.00168 63.64996 -1.436917 31.67268 73.61916 30.07524 69.5966 -77.65935 -66.86804 73.58097 6.972569 -67.80558 -8.058319 -70.68979 -59.73317 66.93846 91.07743 -34.47377 -57.53293 75.72849 -64.00755 63.97447];
+f17(vals)
+%8.8332e+003 Matlab
+%8833.15
\ No newline at end of file
diff --git a/Requirements/MEIGO/gpl-3.0.txt b/Requirements/MEIGO/gpl-3.0.txt
new file mode 100644
index 0000000000000000000000000000000000000000..94a9ed024d3859793618152ea559a168bbcbb5e2
--- /dev/null
+++ b/Requirements/MEIGO/gpl-3.0.txt
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Requirements/MEIGO/install_MEIGO.m b/Requirements/MEIGO/install_MEIGO.m
new file mode 100644
index 0000000000000000000000000000000000000000..2836323ff3c096769e86e45eee2e25bebdef7c64
--- /dev/null
+++ b/Requirements/MEIGO/install_MEIGO.m
@@ -0,0 +1,12 @@
+%%%% -------------------------
+%%%% install_MEIGO
+%%%% -------------------------
+%
+% install_MEIGO adds the MEIGO toolbox files to the Matlab path.
+
+pwd_ssm=pwd;
+addpath(genpath(pwd_ssm))
+
+disp('  ')
+disp('  >>>>>>>> MEIGO has been added to the Matlab path <<<<<<<<')
+disp('  ')
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/.gitignore b/Requirements/PESTO-1.1.0/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..2ec36ba17278e134d8b384c9a4ffcf42305aaf54
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/.gitignore
@@ -0,0 +1,17 @@
+*~
+*.fig
+*.mexa64
+*.mexw64
+*.mexmaci64
+*.mexw32
+*.o
+*.out
+simulate_*.m
+doc/out/
+doc/config/Doxyfile
+doc/config/latexextras.sty
+doc/config/mtocpp_filter.sh
+DRAMToolbox
+*.asv
+examples/RAmPART_examples/results
+*ess_report.mat
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/@DRAMOptions/DRAMOptions.m b/Requirements/PESTO-1.1.0/@DRAMOptions/DRAMOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..a1e74d68113f30c6ce88bb42d9bb668558c3306c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@DRAMOptions/DRAMOptions.m
@@ -0,0 +1,190 @@
+classdef DRAMOptions < matlab.mixin.CustomDisplay
+   % DRAMOptions provides an option container to pass options 
+   % into the PestoSamplingOptions class for Delayed Rejection Adaption Metropolis (DRAM).
+   % The DRAM algorithm uses a delayed rejection scheme for better mixing.
+   % 
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties      
+      % This factor is used for regularization in cases where the single-chain proposal
+      % covariance matrices are ill conditioned. Larger values equal
+      % stronger regularization.
+      regFactor = 1e-6;
+      
+      % The number of tries in the delayed rejection scheme
+      nTry = 1;
+      
+      % Defines the level of verbosity 'silent', 'visual', 'debug' or 'text'
+      verbosityMode = 'text';
+      
+      %  Update the proposal density only every adaptionInterval time
+      adaptionInterval = 1;
+      
+   end
+   
+   methods
+      function obj = DRAMOptions(varargin)
+         % DRAMOptions Construct a new DRAMOptions object
+         %
+         %   OPTS = DRAMOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPTS = DRAMOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPTS = DRAMOptions(OLDOPTS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPTS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for DRAMOptions
+         %
+         % Parameters:
+         % varargin:
+         
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'DRAMOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+         end
+      end
+      
+      function new = copy(this)
+         % Creates a copy of the passed DRAMOptions instance
+         new = feval(class(this));
+         
+         p = properties(this);
+         for i = 1:length(p)
+            new.(p{i}) = this.(p{i});
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      function this = set.regFactor(this, value)
+         if(isnumeric(value) && value > 0)
+            this.regFactor = lower(value);
+         else
+            error(['Please specify a positive regularization factor for ill conditioned covariance'...
+                ' matrices of the adapted proposal density, e.g. ' ...
+                'PestoSamplingOptions.DRAM.regFactor = 1e-5']);
+         end
+      end
+      
+      function this = set.nTry(this, value)
+         if(isnumeric(value) && value > 0)
+            this.nTry = lower(value);
+         else
+            error(['Please specify a positive number of maximum tries, e.g. ' ...
+                'PestoSamplingOptions.DRAM.nTry = 3']);
+         end
+      end     
+      
+      function this = set.verbosityMode(this, value)
+         if (strcmp(value, 'text') || strcmp(value, 'silent') || strcmp(value, 'debug'))
+            this.verbosityMode = lower(value);
+         else
+            error(['Please specify a verbosity mode, e.g. ' ...
+                'PestoSamplingOptions.DRAM.verbosityMode = "text"']);
+         end
+      end           
+ 
+      function this = set.adaptionInterval(this, value)
+         if(isnumeric(value) && value > 0)
+            this.adaptionInterval = lower(value);
+         else
+            error(['Please specify the adaption inteval, e.g. ' ...
+                'PestoSamplingOptions.DRAM.adaptionInterval = 1']);
+         end
+      end        
+      
+   end
+end
diff --git a/Requirements/PESTO-1.1.0/@HOOptions/HOOptions.m b/Requirements/PESTO-1.1.0/@HOOptions/HOOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..e4acc25298ae3f2359f8ac4c0dd5b29e0bb8a545
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@HOOptions/HOOptions.m
@@ -0,0 +1,320 @@
+classdef HOOptions < matlab.mixin.CustomDisplay
+    % HOOptions provides an option container to pass options to
+    % the HierarchicalOptimization likelihood function.
+    %
+    % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+    
+    properties
+        % Determine whether optimal parameters are saved or not.
+        % * false: results are not saved
+        % * true: results are stored in the same folder in the file
+        %         analytical_results.mat
+        save = false;
+        
+        % Noise distribution assumption either Gaussian nosise
+        % (''normal'', default), or in Laplace noise (''laplace'').
+        distribution = 'normal';
+        
+        % Number of experiments.
+        n_exp = 1;
+        
+        % Number of observables.
+        n_obs = 1;
+        
+        % Maximal number of replicates.
+        max_repl = 1;
+        
+        % For the following options, the default is that all parameters
+        % are shared between observables and experiments.
+        
+        % Array containing the indices of the experiments
+        % that share a noise parameter.
+        expgroups_noise = [1];
+        % Array containing the indices of the experiments
+        % that share a scaling parameter.
+        expgroups_scaling = [1];
+        % Array containing the indices of the observables
+        % that share a noise parameter.
+        obsgroups_noise = [1];
+        %Array containing the indices of the observables
+        % that share a scaling parameter.
+        obsgroups_scaling = [1];
+        
+        % 1 x n_y array of strings indicating scale for the observable
+        % Valid options are "log","log10" and "lin" for log, log10 or
+        % unscaled comparison of data and simulation for the corresponding
+        % observable.
+        % use "" for default as specified in the model (fallback: 'lin')
+        scale = {};
+        
+        % 1 x n_y array of strings indicating whether noise is computed for
+        % all replicates together ('single') or individual parameters are
+        % computed ('multiple'):
+        % use "" for default as specified in the model (fallback: 'single')
+        noise = {};
+        
+        % 1 x n_y array of strings indicating whether scaling parmaeters are
+        % computed for all replicates together ('single') or individual parameters are
+        % computed ('multiple') or whether the observable is on an absolute
+        % sacel ('absolute')
+        % use "" for default as specified in the model (fallback: 'single')
+        scaling = {};
+        
+    end
+    
+    properties (Hidden)
+        % Name of the folder in which results are stored. If no folder is
+        % provided, a random foldername is generated.
+        foldername;
+    end
+    
+    methods
+        function obj = HOOptions(varargin)
+            %HOOOptions Construct a new HOOOptions object
+            %
+            %   OPTS = HOOptions() creates a set of options with each option set to its
+            %   default value.
+            %
+            %   OPTS = HOOOptions(PARAM, VAL, ...) creates a set of options with the named
+            %   parameters altered with the specified values.
+            %
+            %   OPTS = HOOOptions(OLDOPTS, PARAM, VAL, ...) creates a copy of OLDOPTS with
+            %   the named parameters altered with the specified value
+            %
+            %   Note to see the parameters, check the
+            %   documentation page for HOOptions
+            %
+            % Parameters:
+            %   varargin:
+
+    %             if nargin > 0
+    %                 
+    %                 % Deal with the case where the first input to the
+    %                 % constructor is a amioptions/struct object.
+    %                 if isa(varargin{1},'HOOptions')
+    %                     if strcmp(class(varargin{1}),class(obj))
+    %                         obj = varargin{1};
+    %                     else
+    %                         % Get the properties from options object passed
+    %                         % into the constructor.
+    %                         thisProps = properties(obj);
+    %                         % Set the common properties. Note that we
+    %                         % investigated first finding the properties that
+    %                         % are common to both objects and just looping over
+    %                         % those. We found that in most cases this was no
+    %                         % quicker than just looping over the properties of
+    %                         % the object passed in.
+    %                         for i = 1:length(thisProps)
+    %                             try %#ok
+    %                                 % Try to set one of the properties of the
+    %                                 % old object in the new one.
+    %                                 obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+    %                             end
+    %                         end
+    %                     end
+    %                     firstInputObj = true;
+    %                 elseif isstruct(varargin{1})
+    %                     fieldlist = fieldnames(varargin{1});
+    %                     for ifield = 1:length(fieldlist)
+    %                         obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+    %                     end
+    %                     firstInputObj = true;
+    %                 elseif isempty(varargin{1})
+    %                     firstInputObj = true;
+    %                 else
+    %                     firstInputObj = false;
+    %                 end
+    %                 
+    %                 % Extract the options that the caller of the constructor
+    %                 % wants to set.
+    %                 if firstInputObj
+    %                     pvPairs = varargin(2:end);
+    %                 else
+    %                     pvPairs = varargin;
+    %                 end
+    %                 
+    %                 % Loop through each param-value pair and just try to set
+    %                 % the option. When the option has been fully specified with
+    %                 % the correct case, this is fast. The catch clause deals
+    %                 % with partial matches or errors.
+    %                 haveCreatedInputParser = false;
+    %                 for i = 1:2:length(pvPairs)
+    %                     try
+    %                         obj.(pvPairs{i}) = pvPairs{i+1};
+    %                     catch ME %#ok
+    %                         
+    %                         % Create the input parser if we haven't already. We
+    %                         % do it here to avoid creating it if possible, as
+    %                         % it is slow to set up.
+    %                         if ~haveCreatedInputParser
+    %                             ip = inputParser;
+    %                             % Structures are currently not supported as
+    %                             % an input to optimoptions. Setting the
+    %                             % StructExpand property of the input parser to
+    %                             % false, forces the parser to treat the
+    %                             % structure as a single input and not a set of
+    %                             % param-value pairs.
+    %                             ip.StructExpand =  false;
+    %                             % Get list of option names
+    %                             allOptionNames = properties(obj);
+    %                             for j = 1:length(allOptionNames)
+    %                                 % Just specify an empty default as we already have the
+    %                                 % defaults in the options object.
+    %                                 ip.addParameter(allOptionNames{j}, []);
+    %                             end
+    %                             haveCreatedInputParser = true;
+    %                         end
+    %                         
+    %                         % Get the p-v pair to parse.
+    %                         thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+    %                         ip.parse(thisPair{:});
+    %                         
+    %                         % Determine the option that was specified in p-v pairs.
+    %                         % These options will now be matched even if only partially
+    %                         % specified (by 13a). Now set the specified value in the
+    %                         % options object.
+    %                         optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+    %                         obj.(optionSet{1}) = ip.Results.(optionSet{1});
+    %                     end
+    %                 end
+    %             end
+        end
+
+        % Part for checking the correct setting of options
+
+        function this = set.save(this, value)
+            if islogical(value)
+                this.save = value;
+            else
+                error('HOOptions.save must be a logical value.');
+            end
+        end
+
+        function this = set.max_repl(this, value)
+            if isscalar(value)
+                this.max_repl = value;
+            else
+                error('HOOptions.save must be a scalar.');
+            end
+        end
+
+        function this = set.n_exp(this, value)
+            if isscalar(value)
+                this.n_exp = value;
+                %warning('expgroups_noise and expgroups_scaling set to default');
+                this.expgroups_noise = {[1:this.n_exp]};
+                this.expgroups_scaling = {[1:this.n_exp]};
+            else
+                error('HOOptions.n_exp must be a scalar.');
+            end
+        end
+
+        function this = set.n_obs(this, value)
+            if isscalar(value)
+                this.n_obs = value;
+                %warning('obsgroups_noise, obsgroups_scaling, and scale set to default');
+                this.obsgroups_noise = {[1:this.n_obs]};
+                this.obsgroups_scaling = {[1:this.n_obs]};
+
+                this.scale = cell(1,this.n_obs);
+                this.scaling = cell(1,this.n_obs);
+                this.noise = cell(1,this.n_obs);
+                for i_obs = 1:this.n_obs
+                    this.scale{i_obs} = 'lin';
+                    this.scaling{i_obs} = 'single';
+                    this.noise{i_obs} = 'single';
+                end
+            else
+                error('HOOptions.n_obs must be a scalar.');
+            end
+        end
+
+        function this = set.expgroups_noise(this, value)
+            if iscell(value)
+                this.expgroups_noise = value;
+            else
+                error('HOOptions.expgroups_noise must be a cell array.');
+            end
+        end
+
+        function this = set.expgroups_scaling(this, value)
+            if iscell(value)
+                this.expgroups_scaling = value;
+            else
+                error('HOOptions.expgroups_scaling must be a cell array.');
+            end
+        end
+
+        function this = set.obsgroups_scaling(this, value)
+            if iscell(value)
+                this.obsgroups_scaling = value;
+            else
+                error('HOOptions.obsgroups_scaling must be a cell array.');
+            end
+        end
+
+        function this = set.obsgroups_noise(this, value)
+            if iscell(value)
+                this.obsgroups_noise = value;
+            else
+                error('HOOptions.obsgroups_noise must be a cell array.');
+            end
+        end
+
+        function this = set.distribution(this, value)
+            if (strcmp(value, 'normal') || strcmp(value, 'laplace'))
+                this.distribution = value;
+            else
+                error('HOOptions.distribution must be set to either "normal" or "laplace".');
+            end
+        end
+
+        function this = set.scale(this, value)
+            if ~isequal(this.n_obs,numel(value))
+                error('HOOptions.scale must have the dimension length n_obs');
+            end
+            for iStr = 1:length(value)
+                if (isempty(value{iStr}) || strcmp(value{iStr},''))
+                    this.scale{iStr} = 'lin';
+                elseif (strcmp(value{iStr}, 'lin') || strcmp(value{iStr}, 'log') ||...
+                        strcmp(value{iStr}, 'log10'))
+                    this.scale{iStr} = value{iStr};
+                else
+                    error('HOOptions.scale must have entries "lin", "log", or "log10"');
+                end
+            end
+        end
+
+        function this = set.noise(this, value)
+            if ~isequal(this.n_obs,numel(value))
+                error('HOOptions.scaling must have the dimension length n_obs');
+            end
+            for iStr = 1:length(value)
+                if (isempty(value{iStr}) || strcmp(value{iStr},''))
+                    this.noise{iStr} = value{iStr};
+                elseif (strcmp(value{iStr}, 'single') || strcmp(value{iStr}, 'multiple') )
+                    this.noise{iStr} = value{iStr};
+                else
+                    error('HOOptions.noise must have entries "single", or "multiple"');
+                end
+            end
+        end
+
+        function this = set.scaling(this, value)
+            if ~isequal(this.n_obs,numel(value))
+                error('HOOptions.scaling must have the dimension length n_obs');
+            end
+            for iStr = 1:length(value)
+                if (isempty(value{iStr}) || strcmp(value{iStr},''))
+                    this.scaling(iStr) = value(iStr);
+                elseif (strcmp(value(iStr), 'single') || strcmp(value(iStr), 'multiple')  ||...
+                        strcmp(value(iStr), 'absolute'))
+                    this.scaling(iStr) = value(iStr);
+                else
+                    error('HOOptions.scaling must have entries "single", "multiple", or "absolute"');
+                end
+            end
+        end
+        
+    end
+end
diff --git a/Requirements/PESTO-1.1.0/@MALAOptions/MALAOptions.m b/Requirements/PESTO-1.1.0/@MALAOptions/MALAOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..e168a3f481808d0129b5ef568693bbf7f96f1c99
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@MALAOptions/MALAOptions.m
@@ -0,0 +1,158 @@
+classdef MALAOptions < matlab.mixin.CustomDisplay
+   % MALAOptions provides an option container to pass options as subclass
+   % into the PestoSamplingOptions class for the Metropolis Adaptive Langevin Algorithm (MALA).
+   %
+   % Note: This algorithm uses gradients & Hessians either provided
+   % by the user or computed by finite differences.
+   %
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties      
+      % This factor is used for regularization in cases where the proposal covariance matrices are
+      % ill conditioned. Larger values equal stronger regularization.
+      regFactor = 1e-6;
+      
+   end
+   
+   
+   methods
+      function obj = MALAOptions(varargin)
+         % MALAOptions Construct a new MALAOptions object
+         %
+         %   OPTS = MALAOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPTS = MALAOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPTS = MALAOptions(OLDOPTS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPTS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for MALAOptions
+         %
+         % Parameters:
+         % varargin:
+
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'MALAOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+         end
+      end
+      
+      function new = copy(this)
+        % Creates a copy of the passed MALAOptions instance
+        
+         new = feval(class(this));
+         
+         p = properties(this);
+         for i = 1:length(p)
+            new.(p{i}) = this.(p{i});
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      function this = set.regFactor(this, value)
+         if(isnumeric(value) && value > 0)
+            this.regFactor = lower(value);
+         else
+            error(['Please specify a positive regularization factor for ill conditioned covariance'...
+                ' matrices of the adapted proposal density, e.g. ' ...
+                'PestoSamplingOptions.MALA.regFactor = 1e-5']);
+         end
+      end
+             
+      
+   end
+end
diff --git a/Requirements/PESTO-1.1.0/@PHSOptions/PHSOptions.m b/Requirements/PESTO-1.1.0/@PHSOptions/PHSOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..fd17013a0ebc6c7dae4cdc77eb1ceeb6b1ec3a6c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@PHSOptions/PHSOptions.m
@@ -0,0 +1,206 @@
+classdef PHSOptions < matlab.mixin.CustomDisplay
+   % PHSOptions provides an option container to set options for Parallel
+   % Hierarchical Sampling (PHS) in PestoSamplingOptions.PHS .
+   %
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties      
+      % Initial number of temperatures
+      nChains = 10;
+      
+      % Parameter which controlls the adaption degeneration
+      % velocity of the single-chain proposals.
+      % Value between 0 and 1.
+      % No adaption (classical Metropolis-Hastings) for 0.
+      alpha = 0.51;
+
+      % The higher the value the more it lowers the impact of early adaption steps.
+      memoryLength = 1;
+      
+      % Regularization factor for ill conditioned covariance matrices of the adapted proposal density.
+      % Regularization might happen if the eigenvalues of the covariance matrix strongly differ in order of
+      % magnitude. In this case, the algorithm adds a small diag-matrix to the covariance matrix with elements
+      % regFactor.
+      regFactor = 1e-6;
+      
+      % The number of iterations before the chains start to swap. 
+      % Might get used to ensure a proper local adaption of the single chains before exchanging them.
+      trainingTime = 1;      
+   end
+   
+   methods
+      function obj = PHSOptions(varargin)
+         % PHSOptions Construct a new PHSOptions object
+         %
+         %   OPHSS = PHSOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPHSS = PHSOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPHSS = PHSOptions(OLDOPHSS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPHSS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for PHSOptions
+         % 
+         % Parameters:
+         %  varargin:
+         % 
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'PHSOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+         end
+      end
+      
+      function new = copy(this)
+        % Creates a copy of the passed PHSOptions instance
+         new = feval(class(this));
+         
+         p = properties(this);
+         for i = 1:length(p)
+            new.(p{i}) = this.(p{i});
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      function this = set.regFactor(this, value)
+         if(isnumeric(value) && value > 0)
+            this.regFactor = lower(value);
+         else
+            error(['Please specify a positive regularization factor for ill conditioned covariance'...
+                ' matrices of the adapted proposal density, e.g. ' ...
+                'PestoSamplingOptions.PHS.regFactor = 1e-5']);
+         end
+      end
+      
+      function this = set.nChains(this, value)
+         if(value == floor(value) && value > 0)
+            this.nChains = lower(value);
+         else
+            error(['Please enter a positive integer for the number auxiliary chains,' ...
+               'e.g. PestoSamplingOptions.PHS.nChains = 10.']);
+         end
+      end            
+
+      function this = set.alpha(this, value)
+         if(isnumeric(value) && value > 0.5 && value < 1)
+            this.alpha = lower(value);
+         else
+            error(['Please an adaption decay constant between 0.5 and 1.0, e.g. PestoSamplingOptions.PHS.alpha = 0.51']);
+         end
+      end  
+      
+      function this = set.memoryLength(this, value)
+         if(value == floor(value) && value > 0)
+            this.memoryLength = lower(value);
+         else
+            error(['Please enter a positive interger memoryLength constant, '...
+               'e.g. PestoSamplingOptions.PHS.memoryLength = 1']);
+         end
+      end   
+      
+      function this = set.trainingTime(this, value)
+         if(value == floor(value) && value > 0)
+            this.trainingTime = lower(value);
+         else
+            error(['Please enter a positive interger training time constant, '...
+               'e.g. PestoSamplingOptions.PHS.trainingTime = 1']);
+         end
+      end         
+      
+   
+            
+   end
+end
diff --git a/Requirements/PESTO-1.1.0/@PTOptions/PTOptions.m b/Requirements/PESTO-1.1.0/@PTOptions/PTOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..4f8de4ab9d0a235aec67f97a27552af15bd14cd6
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@PTOptions/PTOptions.m
@@ -0,0 +1,241 @@
+classdef PTOptions < matlab.mixin.CustomDisplay
+   % PTOptions provides an option container to specify parallel tempering (PT) options 
+   % in PestoSamplingOptions.PT.
+   %
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties      
+      % Initial number of temperatures
+      nTemps = 10;
+      
+      % The initial temperatures are set by a power law to ^opt.exponentT.
+      exponentT = 4;
+      
+      % Parameter which controlls the adaption degeneration
+      % velocity of the single-chain proposals.
+      % Value between 0 and 1.
+      % No adaption (classical Metropolis-Hastings) for 0.
+
+      alpha = 0.51;
+
+      % Parameter which controlls the adaption degeneration velocity of
+      % the temperature adaption.
+      temperatureNu = 1e3;
+      
+      % The higher the value the more it lowers the impact of early adaption steps.
+      memoryLength = 1;
+      
+      % Regularization factor for ill conditioned covariance matrices of
+      % the adapted proposal density. Regularization might happen if the
+      % eigenvalues of the covariance matrix strongly differ in order of 
+      % magnitude. In this case, the algorithm adds a small diag-matrix to
+      % the covariance matrix with elements regFactor.
+      regFactor = 1e-6;
+      
+      % The number of swaps between tempered chains per iterations.
+      swapsPerIter = 1;
+      
+      % Scaling factor for temperature adaptation
+      temperatureEta = 100;
+      
+      % Maximum T - may be infinity
+      maxT = inf;
+
+   end
+   
+   methods
+      function obj = PTOptions(varargin)
+         % PTOptions Construct a new PTOptions object
+         %
+         %   OPTS = PTOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPTS = PTOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPTS = PTOptions(OLDOPTS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPTS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for PTOptions
+         %
+         % Parameters:
+         %  varargin:
+         
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'PTOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      function this = set.regFactor(this, value)
+         if(isnumeric(value) && value > 0)
+            this.regFactor = lower(value);
+         else
+            error(['Please specify a positive regularization factor for ill conditioned covariance'...
+                ' matrices of the adapted proposal density, e.g. ' ...
+                'PestoSamplingOptions.PT.regFactor = 1e-5']);
+         end
+      end
+      
+      function this = set.nTemps(this, value)
+         if(value == floor(value) && value > 0)
+            this.nTemps = lower(value);
+         else
+            error(['Please enter a positive integer for the number of temperatures, e.g. PestoSamplingOptions.nTemps = 10.']);
+         end
+      end    
+      
+      function this = set.exponentT(this, value)
+         if(isnumeric(value) && value > 0)
+            this.exponentT = lower(value);
+         else
+            error(['Please enter a positive double for the exponent of inital temperature heuristic' ...
+               ', e.g. PestoSamplingOptions.PT.exponentT = 4.']);
+         end
+      end          
+
+      function this = set.alpha(this, value)
+         if(isnumeric(value) && value > 0.5 && value < 1)
+            this.alpha = lower(value);
+         else
+            error('Please an adaption decay constant between 0.5 and 1.0, e.g. PestoSamplingOptions.PT.alpha = 0.51');
+         end
+      end  
+      
+      function this = set.temperatureNu(this, value)
+         if(isnumeric(value) && value > 0.0)
+            this.temperatureNu = lower(value);
+         else
+            error('Please an temperature adaption decay constant greater 0');
+         end
+      end   
+      
+      function this = set.memoryLength(this, value)
+         if(value == floor(value) && value > 0)
+            this.memoryLength = lower(value);
+         else
+            error(['Please enter a positive interger memoryLength constant, '...
+               'e.g. PestoSamplingOptions.PT.memoryLength = 1']);
+         end
+      end   
+      
+
+      function this = set.swapsPerIter(this, value)
+         if(value == floor(value) && value > 0)
+            this.swapsPerIter = lower(value);
+         else
+            error(['Please enter a positive integer for the swaps per iteration.']);
+         end
+      end 
+      
+      function this = set.temperatureEta(this, value)
+         if(value == floor(value) && value > 0)
+            this.temperatureEta = lower(value);
+         else
+            error(['Please enter a positive integer for the scaling factor temperatureEta.']);
+         end
+      end  
+      
+      function set.maxT(this, value)
+         if(value > 0)
+            this.maxT = lower(value);
+         else
+            error(['Please enter the maximum temperature. May be inf.']);
+         end
+      end        
+            
+   end
+end
diff --git a/Requirements/PESTO-1.1.0/@PestoOptions/PestoOptions.m b/Requirements/PESTO-1.1.0/@PestoOptions/PestoOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..32bd66505151fb855c0c5a71a37d99e423e73f35
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@PestoOptions/PestoOptions.m
@@ -0,0 +1,585 @@
+classdef PestoOptions < matlab.mixin.CustomDisplay
+    % PestoOptions provides an option container to pass options to various
+    % PESTO functions. Not all options are used by all functions, consult the respective function documentation for details.
+    %
+    % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+    
+    properties
+        % <!-- General options -->
+        
+        % Perform calculations sequentially (''sequential'', default), or
+        % in parallel (''parallel''). Parallel mode will speed-up the
+        % calculations on multi-core systems, but requires the
+        % [MATLAB Parallel Computing Toolbox](https://mathworks.com/products/parallel-computing/)
+        % to be installed.
+        comp_type = 'sequential';
+        
+        % Determine whether results are saved or not.
+        % * false: results are not saved
+        % * true: results are stored to an extra folder
+        save = false;
+        
+        % Name of the folder in which results are stored. If no folder is
+        % provided, a random foldername is generated.
+        foldername = strrep(datestr(now,31),' ','__');
+        
+        
+        
+        % <!-- Options for the objective function -->
+        
+        % Type of objective function provided: 'log-posterior' or 'negative log-posterior'
+        % Tells the algorithm that log-posterior or log-likelihood are provided so it performs
+        % a maximization of the objective function or that the negative
+        % log-posterior or negative log-likelihood are provided so that
+        % a minimization of the objective function is performed.
+        obj_type = 'log-posterior';
+        
+        % Maximum number of outputs, the objective function can provide:
+        % * 1 ... only objective value
+        % * 2 ... objective value with gradient
+        % * 3 ... objective value, gradient and Hessian
+        %
+        % (Missing values will be approximated by finite differences.)
+        % Don't confuse this with the number of outputs from the objective
+        % function that Pesto really calls! objOutNumber just tells Pesto,
+        % with how many outputs it can call the objective function. Also,
+        % optimization is still possible to be done without gradient
+        % information and without the Pesto FD routine.
+        objOutNumber = 3;
+        
+        % Parameter inidices to be fixed, if any
+        fixedParameters = [];
+        
+        % Values of fixed parameters, same sorting as indices, if any
+        fixedParameterValues = [];
+        
+        % Number of data points used for parameter estimation, which should
+        % be used to compute the BIC (optional)
+        nDatapoints = [];
+        
+        
+        % <!-- Options concerning the output -->
+        
+        % Output mode of algorithm:
+        % * 'visual': plots showing the progress are generated
+        % * 'text': optimization results for multi-start are printed on screen
+        % * 'silent': no output during the multi-start local optimization
+        % * 'debug': print extra debug information (only available in
+        % certain functions
+        mode = 'visual';
+        
+        % Figure handle in which results are printed. If no handle is
+        % provided, a new figure is used. TODO: move to plot options
+        fh = [];
+        
+        % Plotting options of class PestoPlottingOptions.m
+        plot_options = PestoPlottingOptions();
+        
+        
+        
+        % <!-- Options for getMultiStarts -->
+        
+        % Number of local optimizations.
+        n_starts = 20;
+        
+        % vector of indices which starts should be performed.
+        % default is 1:n_starts
+        start_index = [];
+        
+        % log-likelihood / log-posterior threshold for initialization of
+        % optimization.
+        init_threshold = -inf;
+        
+        % Offset between log-likelihood and sum of squared residuals
+        % (important only for lsqnonlin so far)
+        logPostOffset = [];
+        
+        % Which optimizer to use?
+        % Current options: ['fmincon', 'meigo-ess', 'meigo-vns', 'pswarm']
+        %
+        % For 'meigo-ess' or 'meigo-vns', MEIGO
+        % (http://gingproc.iim.csic.es/meigom.html) has to be installed
+        % separately.
+        %
+        % For 'pswarm' PSwarm (http://www.norg.uminho.pt/aivaz/pswarm/) has
+        % to be installed separately
+        localOptimizer = 'fmincon';
+        
+        % Options for the chosen local optimizer. Setting fmincon options as default local optimizer. See *help('fmincon')*
+        %
+        % MaxIter: fmincon default, necessary to be set for tracing
+        %
+        % Options for 'meigo-ess' are described in ess_kernel.m in the
+        % MEIGO folder.
+        localOptimizerOptions = optimset( ...
+            'algorithm', 'interior-point',...
+            'display', 'off', ...
+            'GradObj', 'on', ...
+            'MaxIter', 2000, ...
+            'PrecondBandWidth', inf);
+        
+        % Method used to propose starting points for fmincon. Can be
+        % * 'latin hypercube': latin hypercube sampling
+        % * 'uniform': uniform random sampling
+        % * 'user-supplied': user supplied function PestoOptions.init_fun
+        proposal = 'latin hypercube';
+        
+        % determine whether objective function, parameter values and
+        % computation time are stored over iterations
+        % * false:  not saved
+        % * true: stored in fields par_trace, fval_trace and time_trace
+        trace = false;
+        
+        % determine whether intermediate results are stored every
+        % 10 iterations
+        % * false: not saved
+        % * true: results are stored to an extra folder
+        tempsave = false;
+        
+        % clears the objective function before every multi-start.
+        % * false: persistent variables are preserved.
+        % * true: remove all temporary/persistent variables.
+        %
+        % WHEN TRUE THIS OPTION REMOVES ALL OBJECTIVE FUNCTION BREAK POINTS
+        resetobjective = false;
+        
+        
+        
+        % <!-- Options for getParameterProfiles -->
+        
+        % flag for profile calculation
+        % * true: profiles are calculated
+        % * false: profiles are not calculated
+        calc_profiles = true;
+        
+        % parameter bounds (can be removed in a future release, since
+        % parameters.min/max can be used instead)
+        % * .P.min ... lower bound for profiling parameters, having same
+        %   dimension as the parameter vector (default = parameters.min).
+        % * .P.max ... lower bound for profiling parameters, having same
+        %   dimension as the parameter vector (default = parameters.max).
+        P = {};
+        
+        % index MAP - parameter vector starting from which the
+        %       profile is calculated. This option is helpful if local
+        %       optima are present.
+        MAP_index = 1;
+        
+        % Minimal ratio down to which the profile is calculated
+        R_min = 0.03;
+        
+        % Indices of the parameters for which the profile is calculated.
+        %
+        % Default: profile_optim_index will be set to 1:parameters.number
+        % if left empty
+        parameter_index = [];
+        
+        % Indices of the parameters for which the profile is calculated by
+        % reoptimization.
+        profile_optim_index = [];
+        
+        % Indices of the parameters for which the profile is calculated by
+        % integration.
+        profile_integ_index = [];
+        
+        % How should profiles be computed (if no more precise options are
+        % set like profile_optim_index or profile_integ_index)?
+        % Possibilities: {'optimization' (default), 'integration', 'mixed'}
+        profile_method = 'default';
+        
+        
+        
+        % <!-- Detailed options for profile optimization -->
+        
+        % Optimizer options for profile likelihood
+        % *     .algorithm ... choice of algorithm
+        % *         = 'interior-point' (default)
+        % *         = 'trust-region-reflective'
+        % *         = 'active-set'
+        % *     .display ... output of optimization process
+        % *         = 'off' (default) ... no output
+        % *         = 'iter' ... output for every optimization step
+        % *     .MaxIter ... maximum of optimization steps
+        % *     .GradObj ... are gradients provided?
+        % *     .GradConstr ... do we have constraints?
+        % *     .TolCon ... Tolerance for constraints
+        profileOptimizationOptions = [];
+        
+        % Maximal relative decrease of ratio allowed for two adjacent
+        % points in the profile (default = 0.10) if options.dJ = 0;
+        dR_max = 0.10;
+        
+        % influences step size at small likelihood ratio values
+        dJ = 0.5;
+        
+        % options for the generation fo the next profile point
+        % *     .mode ... choice of proposal direction
+        % *         = 'multi-dimensional' (default) ... all parameters are updated.
+        % *             The direct is the same as between the last two points.
+        % *         = 'one-dimensional' ... only parameter for which profile is
+        % *             currently calculated is updated.
+        % *     .guess = 1e-2 ... guess for initial update stepsize
+        % *     .min = 1e-6 ... lower bound for update stepsize
+        % *     .min = 1e2 ... upper bound for update stepsize
+        % *     .update = 1.25 ... incremental change if stepsize is too large or
+        % *         too small, must be > 1.
+        options_getNextPoint = struct('mode', 'multi-dimensional', ...
+            'guess', 1e-2, ...
+            'min', 1e-6, ...
+            'max', 1, ...
+            'update', 1.25);
+        
+        
+        
+        % <!-- Detailed options for profile integration -->
+        
+        % Options for profile integration
+        % *     .type ... choice of ODE integrator
+        % *         = 'ode113' (default) ... Adams-Bashf.-Solver by Matlab
+        % *         = 'ode15s' ... BDF-Solver by Matlab
+        % *         = 'ode45' ... Runge-Kutta-Solver by Matlab
+        % *         = 'CVODE' ... BDF and AB-Solver by sundials (to be implemented!)
+        % *     .algorithm ... choice of algorithm (CVODE only)
+        % *         = 'Adams' (default) ... Adams-Bashford solver
+        % *         = 'BDF' ... BDF solver
+        % *     .nonlinSolver ... choice of nonlinear solver (CVODE only)
+        % *         = 'Newton' (default)
+        % *         = 'Functional'
+        % *     .linSolver ... choice of linear solver (CVODE only)
+        % *         = 'Dense' (default) ... solver for small problems
+        % *         = 'Band' ... solver for bigger problems
+        % *     .gamma ... Retraction factor
+        % *     .eps ... regularization for poorly conditioned Hessian
+        % *     .minCond ... Minimum condition number, when regularization is to be used
+        % *     .hessian ... how is the Hessian Matrix provided?
+        % *         = 'user-supplied' (default) ... Hessian is 3rd output of ObjFun
+        % *         = 'bfgs' ... BFGS approximation to Hessian
+        % *         = 'sr1' ... symmetric-rank 1 approximation to Hessian
+        % *     .gradient ... is a gradient provided?
+        % *     .MinStep ... minimum step size of the solver
+        % *     .MaxStep ... maximum step size of the solver
+        % *     .MaxNumSteps ... maximum steps to be taken
+        % *     .GradTol ... maximum remaining gradient to be tolerated
+        % *     .RelTol ... maximum relative integration error
+        % *     .AbsTol ... maximum absolute integration error
+        solver = struct('type', 'ode113', ...
+            'algorithm', 'Adams', ...
+            'nonlinSolver', 'Newton', ...
+            'linSolver', 'Dense', ...
+            'gamma', 0, ...
+            'eps', 1e-8, ...
+            'minCond', 1e-10, ...
+            'hessian', 'user-supplied', ...
+            'gradient', true, ...
+            'MaxStep', 0.1, ...
+            'MinStep', 1e-5, ...
+            'MaxNumSteps', 1e5, ...
+            'GradTol', 1, ...
+            'RelTol', 1e-4, ...
+            'AbsTol', 1e-6 ...
+            );
+        
+        
+        
+        % <!-- Options for getPropertyProfiles -->
+        
+        % Tolance for the maximal distance of the list point
+        % the lower and upper bounds for the properties.
+        boundary_tol = 1e-5;
+        
+        % Indices of the properties for which the profile is to be
+        % calculated (default = 1:properties.number, reoptimization only).
+        property_index = [];
+        
+        % Set MCMC options by calling an PestoSamplingOptions Class object
+        MCMC = PestoSamplingOptions();
+        
+        % Set Hierarchical Optimization options by calling an HOOptions Class object
+        HO = HOOptions();
+        
+    end
+    
+    properties (Hidden)
+    end
+    
+    methods
+        function obj = PestoOptions(varargin)
+            %PestoOptions Construct a new PestoOptions object
+            %
+            %   OPTS = PestoOptions() creates a set of options with each option set to its
+            %   default value.
+            %
+            %   OPTS = PestoOptions(PARAM, VAL, ...) creates a set of options with the named
+            %   parameters altered with the specified values.
+            %
+            %   OPTS = PestoOptions(OLDOPTS, PARAM, VAL, ...) creates a copy of OLDOPTS with
+            %   the named parameters altered with the specified value
+            %
+            %   Note to see the parameters, check the
+            %   documentation page for PestoOptions
+            %
+            % Parameters:
+            %   varargin:
+            
+            % adapted from SolverOptions
+            
+            if nargin > 0
+                
+                % Deal with the case where the first input to the
+                % constructor is a PestoOptions/struct object.
+                if isa(varargin{1},'PestoOptions')
+                    if strcmp(class(varargin{1}),class(obj))
+                        obj = varargin{1};
+                    else
+                        % Get the properties from options object passed
+                        % into the constructor.
+                        thisProps = properties(obj);
+                        % Set the common properties. Note that we
+                        % investigated first finding the properties that
+                        % are common to both objects and just looping over
+                        % those. We found that in most cases this was no
+                        % quicker than just looping over the properties of
+                        % the object passed in.
+                        for i = 1:length(thisProps)
+                            try %#ok
+                                % Try to set one of the properties of the
+                                % old object in the new one.
+                                obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                            end
+                        end
+                    end
+                    firstInputObj = true;
+                elseif isstruct(varargin{1})
+                    fieldlist = fieldnames(varargin{1});
+                    for ifield = 1:length(fieldlist)
+                        obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+                    end
+                    firstInputObj = true;
+                elseif isempty(varargin{1})
+                    firstInputObj = true;
+                else
+                    firstInputObj = false;
+                end
+                
+                % Extract the options that the caller of the constructor
+                % wants to set.
+                if firstInputObj
+                    pvPairs = varargin(2:end);
+                else
+                    pvPairs = varargin;
+                end
+                
+                % Loop through each param-value pair and just try to set
+                % the option. When the option has been fully specified with
+                % the correct case, this is fast. The catch clause deals
+                % with partial matches or errors.
+                haveCreatedInputParser = false;
+                for i = 1:2:length(pvPairs)
+                    try
+                        obj.(pvPairs{i}) = pvPairs{i+1};
+                    catch ME %#ok
+                        
+                        % Create the input parser if we haven't already. We
+                        % do it here to avoid creating it if possible, as
+                        % it is slow to set up.
+                        if ~haveCreatedInputParser
+                            ip = inputParser;
+                            % Structures are currently not supported as
+                            % an input to optimoptions. Setting the
+                            % StructExpand property of the input parser to
+                            % false, forces the parser to treat the
+                            % structure as a single input and not a set of
+                            % param-value pairs.
+                            ip.StructExpand =  false;
+                            % Get list of option names
+                            allOptionNames = properties(obj);
+                            for j = 1:length(allOptionNames)
+                                % Just specify an empty default as we already have the
+                                % defaults in the options object.
+                                ip.addParameter(allOptionNames{j}, []);
+                            end
+                            haveCreatedInputParser = true;
+                        end
+                        
+                        % Get the p-v pair to parse.
+                        thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                        ip.parse(thisPair{:});
+                        
+                        % Determine the option that was specified in p-v pairs.
+                        % These options will now be matched even if only partially
+                        % specified (by 13a). Now set the specified value in the
+                        % options object.
+                        optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                        obj.(optionSet{1}) = ip.Results.(optionSet{1});
+                    end
+                end
+            end
+            
+            % Add required subclasses
+            obj.MCMC = PestoSamplingOptions();
+            obj.HO = HOOptions;
+            obj.HO.foldername = obj.foldername;
+            
+        end
+        
+        function new = copy(this)
+            % Creates a copy of the passed PestoOptions instance
+            new = feval(class(this));
+            
+            p = properties(this);
+            for iProp = 1:length(p)
+                new.(p{iProp}) = this.(p{iProp});
+            end
+        end
+        
+        % Part for checking the correct setting of options
+        
+        function this = set.obj_type(this, value)
+            if(strcmpi(value, 'log-posterior') || strcmpi(value, 'negative log-posterior'))
+                this.obj_type = lower(value);
+            else
+                error('PestoOptions.obj_type must be ''log-posterior'' or ''negative log-posterior''.');
+            end
+        end
+        
+        function this = set.comp_type(this, value)
+            if(strcmpi(value, 'sequential') || strcmpi(value, 'parallel'))
+                this.comp_type = lower(value);
+            else
+                error('PestoOptions.comp_type must be ''sequential'' or ''parallel''.');
+            end
+        end
+
+        function this = set.n_starts(this, value)
+            if(isnumeric(value) && floor(value) == value && value > 0)
+                this.n_starts = value;
+                this.start_index = [];
+            else
+                error('PestoOptions.n_starts must be a positive integer value.');
+            end
+        end
+        
+        function this = set.mode(this, value)
+            this.mode = value;
+            if (strcmp(value, 'visual') || strcmp(value, 'text') || strcmp(value, 'silent') || strcmp(value, 'debug'))
+                this.mode = value;
+            else
+                error('PestoOptions.mode must be set to either "visual", "text", "silent" or "debug".');
+            end
+        end
+        
+        function this = set.proposal(this, value)
+            if (strcmp(value, 'latin hypercube') || strcmp(value, 'uniform') || strcmp(value, 'user-supplied'))
+                this.proposal = value;
+            else
+                error('PestoOptions.proposal must be set to either "latin hypercube", "uniform" or "user-supplied".');
+            end
+        end
+        
+        function this = set.save(this, value)
+            if islogical(value)
+                this.save = value;
+            else
+                error('PestoOptions.save must ba a logical value.');
+            end
+        end
+        
+        function this = set.tempsave(this, value)
+            if islogical(value)
+                this.tempsave = value;
+            else
+                error('PestoOptions.tempsave must ba a logical value.');
+            end
+        end
+        
+        function this = set.trace(this, value)
+            if islogical(value)
+                this.trace = value;
+            else
+                error('PestoOptions.trace must ba a logical value.');
+            end
+        end
+
+        function this = set.calc_profiles(this, value)
+            if islogical(value)
+                this.calc_profiles = value;
+            else
+                error('PestoOptions.calc_profiles must ba a logical value.');
+            end
+        end
+        
+        function this = set.resetobjective(this, value)
+            if islogical(value)
+                this.resetobjective = value;
+            else
+                error('PestoOptions.resetobjective must ba a logical value.');
+            end
+        end
+        
+        function this = set.start_index(this, value)
+            if isvector(value) || isempty(value)
+                this.start_index = value;
+            else
+                error(['PestoOptions.start_index must ba a numeric vector.']);
+            end
+        end
+        
+        function this = set.parameter_index(this, value)
+            if isvector(value) || isempty(value)
+                this.parameter_index = value;
+            else
+                error(['PestoOptions.parameter_index must ba a numeric vector.']);
+            end
+        end
+        
+        function this = set.property_index(this, value)
+            if isvector(value) || isempty(value)
+                this.property_index = value;
+            else
+                error(['PestoOptions.property_index must ba a numeric vector.']);
+            end
+        end
+        
+        function this = set.MAP_index(this, value)
+            if(isempty(value) || isnumeric(value) && floor(value) == value && value > 0)
+                this.MAP_index = value;
+            else
+                error('PestoOptions.MAP_index must be a positive integer value.');
+            end
+        end
+        
+        function this = set.dR_max(this, value)
+            if(isnumeric(value) && value >= 0 && value <= 1)
+                this.dR_max = value;
+            else
+                error('PestoOptions.dR_max positive numeric value between 0 and 1.');
+            end
+        end
+
+        function this = set.R_min(this, value)
+            if(isnumeric(value) && value >= 0 && value <= 1)
+                this.R_min = value;
+            else
+                error('PestoOptions.R_min positive numeric value between 0 and 1.');
+            end
+        end
+        
+        function this = set.foldername(this, value)
+            this.foldername = value;
+            this.HO.foldername = value;
+        end
+        
+        function this = set.localOptimizer(this, value)
+            if any(strcmp(value, {'fmincon', 'meigo-ess', 'meigo-vns', 'pswarm', 'lsqnonlin', 'cs', 'dhc', 'bobyqa'}))
+                this.localOptimizer = value;
+                
+                if strcmp(value, 'pswarm')
+                    this.localOptimizerOptions = PSwarm('defaults');
+                end
+            else
+                error('PestoOptions.localOptimizer only supports the following choices: fmincon, meigo-ess, meigo-vns, pswarm, lsqnonlin, cs, dhc, bobyqa.');
+            end
+        end
+        
+    end
+end
diff --git a/Requirements/PESTO-1.1.0/@PestoPlottingOptions/PestoPlottingOptions.m b/Requirements/PESTO-1.1.0/@PestoPlottingOptions/PestoPlottingOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..681d89c57d302dd3ff6c6521555255847acecd18
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@PestoPlottingOptions/PestoPlottingOptions.m
@@ -0,0 +1,456 @@
+% @file PestoPlottingOptions
+% @brief A class for checking and holding information on optimization
+% parameters
+
+classdef PestoPlottingOptions < matlab.mixin.CustomDisplay
+    % PestoPlottingOptions is a class for checking and holding information on optimization
+    % parameters
+    %
+    % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+    
+    properties
+        % Title of PESTO-generated plots
+        % * true: show
+        % * false: don't show
+        title = true;
+        
+        % Additional points to include in the plots, e.g. true
+        % parameter in the case of test examples
+        %
+        % Struct with the following fields
+        % * .par: n x m matrix of m additional points
+        % * .col: color used for additional points (default = [0,0,0]).
+        %                  This can also be a m x 3 matrix of colors.
+        % * .ls: line style (default = '-')
+        % * .lw: line width (default = 2)
+        % * .m: marker style (default = 's')
+        % * .ms: line width (default = 8)
+        % * .name: name of legend entry (default = 'add. point')
+        % * .property_MS: line width (default = 8).
+        % * .logPost
+        
+        add_points = struct('par', [], ...
+            'logPost', [], ...
+            'col', [0,0.8,0], ...
+            'ls', '-', ...
+            'lw', 1, ...
+            'm', 'd', ...
+            'ms', 8, ...
+            'name', 'add. point');
+        
+        % TODO: from plotmultistarts
+        mark_constraint = false;
+        
+        % TODO from plotparameteruncertainty
+        subplot_size_1D = [];
+        
+        % TODO
+        subplot_indexing_1D = [];
+        
+        % TODO 
+        labels = struct('y_always', true, ...
+            'y_name', []);
+        
+        % Indicates whether plots are redrawn or whether something
+        %  is added to the plot
+        % * true: extension of plot
+        % * false: new plot
+        hold_on = false;
+        
+        % Way of choosing x limits for plotting
+        % * 'dynamic': x limits depending on analysis results
+        % * 'static': x limits depending on parameters.min and .max or on
+        %          user-defined bound options.bounds.min and .max. The later are
+        %          used if provided.
+        interval = 'dynamic';
+        
+        % Draw bounds
+        % * true: yes
+        % * false: no
+        draw_bounds = true;
+        
+        % Bounds used for visualization if options.interval = 'static'
+        %
+        % struct with 
+        %  * .min: lower bound
+        %  * .max: upper bound
+        bounds = {};
+        
+        % Options for profile plots
+        %
+        % Struct with 
+        % * .plot_type: plot type
+        %   * = 0 (default if no profiles are provided) ... no plot
+        %   * = 1 (default if profiles are provided) ... likelihood ratio
+        %   * = 2 ... negative log-likelihood
+        % * .col: color of profile lines (default: [1,0,0])
+        % * .lw: line width of profile lines (default: 1.5)
+        P = struct('plot_type', 1, ...
+            'col', [1,0,0], ...
+            'lw', 2, ...
+            'name', 'P');
+        
+        % Options for sample plots
+        % * .plot_type: plot type
+        %   * = 0 (default if no samples are provided) ... no plot
+        %   * = 1 (default if samples are provided) ... histogram
+        %   * = 2 ... kernel-density estimates
+        % * .col ... color of profile lines (default: [0.7,0.7,0.7])
+        % * .hist_col ... color of histogram (default = [0.7,0.7,0.7])
+        % * .bins ... number of histogram bins (default: 30)
+        %   * = 'optimal' ... selection using Scott's rule
+        %   * = 'conservative' ... selection using Scott's rule / 2
+        %   * = N (with N being an integer) ... N bins
+        % * .sp_col: color of scatter plot (default = [0.7,0.7,0.7])
+        % * .sp_m: marker for scatter plot (default = '.')
+        % * .sp_ms: marker size for scatter plot (default = 5)
+        % * .name: name of legend entry (default = 'S')
+        S = struct('plot_type', 0, ...
+            'bins', 'conservative', ...
+            'scaling', [], ...
+            'hist_col',  [0.7,0.7,0.7], ...
+            'sp_col', [0.7,0.7,0.7], ...
+            'lin_col', [1,0,0], ...
+            'lin_lw', 2, ...
+            'sp_m', '.', ...
+            'sp_ms', 5, ...
+            'col', [1,0,0], 'lw', 2, ...
+            'PT', struct('sp_m', '.', ...
+                'sp_ms', 5, ...
+                'lw', 1.5, ...
+                'ind', [], ...
+                'col', [], ...
+                'plot_type', 0), ...
+            'name', 'S');
+        
+        % Options for multi-start optimization plots
+        %
+        % Struct with:
+        % * .plot_type: plot type
+        %   * = 0 (default if no MS are provided) ... no plot
+        %   * = 1 (default if MS are provided) ... likelihood ratio and
+        %               position of optima above threshold
+        %   * = 2 ... negative log-likelihood and position of optima
+        %               above threshold
+        % * .col: color of local optima (default: [1,0,0])
+        % * .lw: line width of local optima (default: 1.5)
+        % * .name_conv: name of legend entry (default = 'MS - conv.')
+        % * .name_nconv: name of legend entry (default = 'MS - not conv.')
+        % * .only_optimum: only optimum is plotted
+        
+        MS = struct('plot_type', 1, ...
+            'col', [1,0,0], ...
+            'lw' , 2, ...
+            'name_conv', 'MS - conv.', ...
+            'name_nconv', 'MS - not conv.', ...
+            'only_optimum', false);
+        
+        % Options for distribution approximation plots
+        % 
+        % Struct with:
+        % * .plot_type: plot type
+        %   * = 0 (default if no MS are provided) ... no plot
+        %   * = 1 (default if MS are provided) ... likelihood ratio
+        %   * = 2 ... negative log-likelihood
+        % * .col: color of approximation lines (default: [0,0,1])
+        % * .lw: line width of approximation lines (default: 1.5)
+        % * .sigma_level: sigma-level which is visualized (default = 2)
+        % * .name: name of legend entry (default = 'P_{app}')
+        
+        A = struct('plot_type', 1, ...
+            'col', [0,0,1], ...
+            'lw', 2, ...
+            'sigma_level', 2, ...
+            'name', 'P_{app}');
+        
+        % Option if a user provided sampling initialization should be used
+        % for plotting an approximation of the distribution
+        %
+        % * 'user-provided'
+        % * 'multistart' (default)
+        
+        MCMC = 'multistart';
+        
+        % Options for boundary visualization
+        % 
+        % Struct with 
+        % * .mark: marking of profile points which are on the boundary
+        %   * = 0 ... no visualization
+        %   * = 1 (default) ... indicates points which ar close to the
+        %               boundaries in one or more dimensions.
+        % * .eps: minimal distance from boundary for which points are
+        %           consider to e close do the boundary (default = 1e-4). Note
+        %               that a one-norm is used.
+        boundary = struct('mark', true, ...
+            'eps', 1e-4);
+        
+        % Options for confidence level plots
+        % 
+        % Struct with
+        % * .plot_type: plot type
+        %   * = 0 (default) ... no plot
+        %   * = 1 ... likelihood ratio
+        %   * = 2 ... negative log-likelihood
+        % * .alpha: visualized confidence level (default = 0.95)
+        % * .type: type of confidence interval
+        %   * = 'point-wise' (default) ... point-wise confidence interval
+        %   * = 'simultanous' ... point-wise confidence interval
+        %   * = {'point-wise','simultanous'} ... both
+        % * .col: color of profile lines (default: [0,0,0])
+        % * .lw: line width of profile lines (default: 1.5)
+        % * .name: name of legend entry (default = 'cut-off')
+        
+        CL = struct('plot_type', 0, ...
+            'alpha', 0.95, ...
+            'type', 'point-wise', ...
+            'col', [0,0,0], ...
+            'lw', 2,  ...
+            'name', 'cut-off');
+        
+        % Options for the way to plot confidence intervals
+        %
+        % Either all confidence intervals of one method are plotted to one
+        % window 'params', or the confidence intervals for one parameter 
+        % from all methods are plotted to one window 'methods', or 
+        % everthing is grouped together 'all'.
+        
+        group_CI_by = 'parprop';
+        
+        % Settings for 2D plot to position subplot axes.
+        % 
+        % Struct with:
+        % * .b1 ... offset from left and bottom border (default = 0.15)
+        % * .b2 ... offset from left and bottom border (default = 0.02)
+        % * .r ... relative width of subplots (default = 0.95)
+        op2D = struct('b1', 0.15, 'b2', 0.02, 'r', 0.95);
+        
+        % Legend options
+        % * .color: background color (default = 'none').
+        % * .box: legend outine (default = 'on').
+        % * .orientation: orientation of list (default = 'vertical')
+        
+        legend = struct('color', 'none', ...
+            'box', 'on', ...
+            'orientation', 'vertical', ...
+            'position', []);
+        
+        % Fontsize for labels
+        % * .tick: fontsize for ticklabels (default = 12)
+        fontsize = struct ('tick', 12);
+        
+        % figure handle for log-posterior trace plot
+        fh_logPost_trace = [];
+        
+        % figure handle for parameter trace plots.
+        fh_par_trace = [];
+        
+        % figure handle for the 1D parameter distribution plot.
+        fh_par_dis_1D = [];
+
+        % figure handle for the 2D parameter distribution plot.
+        fh_par_dis_2D = [];
+        
+        % plot type
+        plot_type = {'parameter','posterior'};
+        
+        % max
+        n_max = 1e4;
+    end
+    
+    properties (Hidden)
+    end
+    
+    methods
+    function obj = PestoPlottingOptions(varargin)
+            %PestoPlottingOptions Construct a new PestoPlottingOptions object
+            %
+            %   OPTS = PestoPlottingOptions() creates a set of options with each option set to its
+            %   default value.
+            %
+            %   OPTS = PestoPlottingOptions(PARAM, VAL, ...) creates a set of options with the named
+            %   parameters altered with the specified values.
+            %
+            %   OPTS = PestoPlottingOptions(OLDOPTS, PARAM, VAL, ...) creates a copy of OLDOPTS with
+            %   the named parameters altered with the specified value
+            %
+            %   Note to see the parameters, check the
+            %   documentation page for PestoPlottingOptions
+            %
+            % Parameters:
+            %   varargin:
+
+            
+            % adapted from SolverOptions
+            
+            if nargin > 0
+                
+                % Deal with the case where the first input to the
+                % constructor is a struct object.
+                if isa(varargin{1},'PestoPlottingOptions')
+                    if strcmp(class(varargin{1}),class(obj))
+                        obj = varargin{1};
+                    else
+                        % Get the properties from options object passed
+                        % into the constructor.
+                        thisProps = properties(obj);
+                        % Set the common properties. Note that we
+                        % investigated first finding the properties that
+                        % are common to both objects and just looping over
+                        % those. We found that in most cases this was no
+                        % quicker than just looping over the properties of
+                        % the object passed in.
+                        for i = 1:length(thisProps)
+                            try %#ok
+                                % Try to set one of the properties of the
+                                % old object in the new one.
+                                obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                            end
+                        end
+                    end
+                    firstInputObj = true;
+                elseif isstruct(varargin{1})
+                    fieldlist = fieldnames(varargin{1});
+                    for ifield = 1:length(fieldlist)
+                        obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+                    end
+                    firstInputObj = true;
+                elseif isempty(varargin{1})
+                    firstInputObj = true;
+                else
+                    firstInputObj = false;
+                end
+                
+                % Extract the options that the caller of the constructor
+                % wants to set.
+                if firstInputObj
+                    pvPairs = varargin(2:end);
+                else
+                    pvPairs = varargin;
+                end
+                
+                % Loop through each param-value pair and just try to set
+                % the option. When the option has been fully specified with
+                % the correct case, this is fast. The catch clause deals
+                % with partial matches or errors.
+                haveCreatedInputParser = false;
+                for i = 1:2:length(pvPairs)
+                    try
+                        obj.(pvPairs{i}) = pvPairs{i+1};
+                    catch ME %#ok
+                        
+                        % Create the input parser if we haven't already. We
+                        % do it here to avoid creating it if possible, as
+                        % it is slow to set up.
+                        if ~haveCreatedInputParser
+                            ip = inputParser;
+                            % Structures are currently not supported as
+                            % an input to optimoptions. Setting the
+                            % StructExpand property of the input parser to
+                            % false, forces the parser to treat the
+                            % structure as a single input and not a set of
+                            % param-value pairs.
+                            ip.StructExpand =  false;
+                            % Get list of option names
+                            allOptionNames = properties(obj);
+                            for j = 1:length(allOptionNames)
+                                % Just specify an empty default as we already have the
+                                % defaults in the options object.
+                                ip.addParameter(allOptionNames{j}, []);
+                            end
+                            haveCreatedInputParser = true;
+                        end
+                        
+                        % Get the p-v pair to parse.
+                        thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                        ip.parse(thisPair{:});
+                        
+                        % Determine the option that was specified in p-v pairs.
+                        % These options will now be matched even if only partially
+                        % specified (by 13a). Now set the specified value in the
+                        % options object.
+                        optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                        obj.(optionSet{1}) = ip.Results.(optionSet{1});
+                    end
+                end
+            end
+    end
+    
+    function new = copy(this)
+        % Creates a copy of the passed PestoPlottingOptions instance
+
+        new = feval(class(this));
+        
+        p = properties(this);
+        for i = 1:length(p)
+            new.(p{i}) = this.(p{i});
+        end
+    end
+
+        %% Part for checking the correct setting of options
+        
+        function this = set.MCMC(this, value)
+            if (strcmp(value, 'multistart') || strcmp(value, 'user-provided'))
+                this.MCMC = value;
+            else
+                error('PestoOptions.MCMC must be set to either "multistart" or "user-provided".');
+            end
+        end
+        
+        function this = set.interval(this, value)
+            if (strcmp(value, 'dynamic') || strcmp(value, 'static'))
+                this.interval = value;
+            else
+                error('PestoOptions.interval must be set to either "dynamic" or "static".');
+            end
+        end
+
+        function this = set.group_CI_by(this, value)
+            if (strcmp(value, 'parprop') || strcmp(value, 'methods') || strcmp(value, 'all'))
+                this.group_CI_by = value;
+            else
+                error('PestoOptions.group_CI_by must be set to either "parprop", "methods" or "all".');
+            end
+        end
+        
+        function this = set.n_max(this, value)
+            if(isnumeric(value) && value > 0)
+                this.n_max = value;
+            else
+                error('PestoOptions.n_max must be a positive number.');
+            end
+        end
+        
+        function this = set.title(this, value)
+            if islogical(value)
+                this.title = value;
+            else
+                error('PestoOptions.title must ba a logical value.');
+            end
+        end
+        
+        function this = set.draw_bounds(this, value)
+            if islogical(value)
+                this.draw_bounds = value;
+            else
+                error('PestoOptions.draw_bounds must ba a logical value.');
+            end
+        end
+        
+        function this = set.mark_constraint(this, value)
+            if islogical(value)
+                this.mark_constraint = value;
+            else
+                error('PestoOptions.mark_constraint must ba a logical value.');
+            end
+        end
+        
+        function this = set.hold_on(this, value)
+            if islogical(value)
+                this.hold_on = value;
+            else
+                error('PestoOptions.hold_on must ba a logical value.');
+            end
+        end
+        
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/@PestoSamplingOptions/PestoSamplingOptions.m b/Requirements/PESTO-1.1.0/@PestoSamplingOptions/PestoSamplingOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..6daae6e7e59746082304476a5d23811c18f7d2e6
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@PestoSamplingOptions/PestoSamplingOptions.m
@@ -0,0 +1,386 @@
+classdef PestoSamplingOptions < matlab.mixin.CustomDisplay
+   % PestoSamplingOptions provides an option container to pass options to
+   % various PESTO functions. Not all options are used by all functions,
+   % consult the respective function documentation for details.
+   %
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties
+      % <!-- General options -->
+      
+      % Type of objective function provided:
+      % 'log-posterior' (default) or 'negative log-posterior'
+      %
+      % Tells the algorithm that log-posterior or log-likelihood are
+      % provided so it takes into account the corect sign for perfoming
+      % all algorithms correctly.
+      obj_type = 'log-posterior';
+            
+      % Sampling algorithm, can be 'PT' (parallel tempering), 'PHS',
+      % (parallel hierarchical sampling), 'MALA' (Metropolis adjusted
+      % Langevin algorithm), or 'DRAM' (delayed rejection adapted
+      % Metropolis algorithm, only if the DRAM toolbox is installed).
+      % Default value is 'PT'
+      samplingAlgorithm = 'PT'
+      
+      % Number of iterations, integer (1e5 is not too high, e.g. 1e6 is a
+      % morereasonable value for reliable results, but computationally
+      % more intensive.
+      nIterations = 1e5;
+      
+      % Initialization points for all chains. If the algorithm uses
+      % multiple chains (as 'PT' and 'PHS'), one can specify multiple
+      % theta0,
+      % e.g.: opt.theta0 = repmat([0.1,1.5,-2.5,-0.5,0.4],opt.nTemps,1)';
+      % If there is just one chain, please specify as
+      % opt.theta0 = [1;2;3;4];
+      % It is recommendet to set theta0 by taking into account the
+      % results from a preceeding optimization (see Pesto examples).
+      theta0 = [];
+      
+      % Initial covariance matrices for all chains.
+      % Example for single-chain algorithms:
+      % opt.sigma0 = 1e5 * diag(ones(1,5));
+      % Example for multi-chain algorithms:
+      % opt.sigma0 = repmat(1e5*diag(ones(1,5)),opt.nTemps,1);
+      % It is recommendet to set sigma0 by taking into account the
+      % results from a preceeding optimization.
+      sigma0 = [];
+      
+      % Output mode for sampling algorithms (except DRAM, which has its
+      % own format), can be chosen as 'visual', 'text', 'silent', or
+      % 'debug'. Default: visual
+      mode = 'visual';
+      
+      % Some of the methods decide if debug mode should be on. This option
+      % can be used in cases, where RAM is a critical resource
+      debug = false;
+      
+      % Maximum number of outputs, the objective function can provide:
+      % * 1 ... only objective value
+      % * 2 ... objective value with gradient
+      % * 3 ... objective value, gradient and Hessian (Default)
+      %
+      % Missing values will be approximated by finite differences.
+      objOutNumber = 1;
+      
+      % If desired, intermediate save spots are saved during the run in the
+      % following file each saveEach > 0:
+      saveFileName = '';
+      saveEach = 0;
+      
+      % Parallel Tempering Options, an instance of PTOptions - this
+      % instance is also used for initalization in case no algorithm was
+      % specified
+      PT = PTOptions(); 
+      
+      % Parallel Hierarchical Sampling options, an instance of PHSOptions
+      PHS;
+            
+      % Metropolis Adaptive Langevin Algorithm options, an instance of
+      % MALAOptions
+      MALA;
+      
+      % Delayed Rejection Adaptive Metropolis options, an instance of
+      % DRAMOptions
+      DRAM;     
+      
+      % Region Based Parallel Tempering Options, an instance of RAMPARTOptions
+      RAMPART;  
+      
+   end
+      
+   methods
+      function obj = PestoSamplingOptions(varargin)
+         % PestoSamplingOptions Construct a new PestoSamplingOptions object
+         %
+         %   OPTS = PestoSamplingOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPTS = PestoSamplingOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPTS = PestoSamplingOptions(OLDOPTS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPTS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for PestoSamplingOptions
+         % Parameters:
+         % varargin:
+
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'PestoSamplingOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+            
+            % Add required subclasses
+            obj.PT = PTOptions;
+            
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      function this = set.obj_type(this, value)
+         if(strcmpi(value, 'log-posterior') || strcmpi(value, 'negative log-posterior'))
+            this.obj_type = lower(value);
+         else
+            error('PestoSamplingOptions.obj_type must be ''log-posterior'' or ''negative log-posterior''.');
+         end
+      end
+      
+      function this = set.mode(this, value)
+         if (strcmp(value, 'visual') || strcmp(value, 'text') || strcmp(value, 'silent') || strcmp(value, 'debug'))
+            this.mode = value;
+         else
+            error('PestoSamplingOptions.mode must be set to either "visual", "text", "silent" or "debug".');
+         end
+      end
+            
+      function this = set.nIterations(this, value)
+         if (value == floor(value) && value > 0)
+            this.nIterations = value;
+         else
+            error('Please enter the number of desired iterations as integer, e.g. opt.nIterations = 1e6.');
+         end
+      end
+      
+      function this = set.samplingAlgorithm(this, value)
+         if ~isstr(value) || isempty(value)
+            error('Please specify the algorithm which should be used, e.g. opt.samplingAlgorithm = ''PT''');
+         end
+         if (strcmp(value, 'MALA') || strcmp(value, 'DRAM') || strcmp(value, 'PT') || strcmp(value, 'PHS') ...
+               || strcmp(value, 'RAMPART'))
+            this.samplingAlgorithm = value;
+            switch value
+               case 'MALA'
+                  this.MALA = MALAOptions();
+                  this.DRAM = struct;
+                  this.PT   = struct;
+                  this.PHS  = struct;
+                  this.RAMPART  = struct;
+               case 'DRAM'
+                  this.MALA = struct;
+                  this.DRAM = DRAMOptions();
+                  this.PT   = struct;
+                  this.PHS  = struct;
+                  this.RAMPART  = struct;                  
+               case 'PT'
+                  this.MALA = struct;
+                  this.DRAM = struct;
+                  this.PT   = PTOptions();
+                  this.PHS  = struct;
+                  this.RAMPART  = struct;                  
+               case 'PHS'
+                  this.MALA = struct;
+                  this.DRAM = struct;
+                  this.PT   = struct;
+                  this.PHS  = PHSOptions();
+                  this.RAMPART  = struct;
+               case 'RAMPART'
+                  this.MALA = struct;
+                  this.DRAM = struct;
+                  this.PT   = struct;
+                  this.PHS  = struct;
+                  this.RAMPART  = RAMPARTOptions();                  
+            end
+         else
+            error('You have entered an sampling algorithm which does not exist.')
+         end
+      end
+      
+      function this = set.objOutNumber(this, value)
+         if value == floor(value) && ( value == 1 || value == 2 || value == 3 )
+            this.objOutNumber = lower(value);
+         else
+            error(['Please enter wheter finite differences and Hessians opt.objOutNumber = 1' ...
+               'or sensitivity based gradients and Hessians opt.objOutNumber = 3 should be used.']);
+         end
+      end
+      
+      function this = checkDependentDefaults(this, par)
+          % checkDependentDefaults sets default values for sampling options which are problem-specific
+          % and will be adapted to the problem properties in par.
+          % Should be called providing the parameter struct for dependent
+          % defaults as theta0. Does both, checking already set dependent
+          % options and defaulting based on par if not set yet.
+          %
+          % Parameters:
+          % par: parameters as passed getParameterSamples() to use for choosing default options
+          %
+          % Return values:
+          % this: the updated PestoSamplingOptions instance
+          
+         if ~isempty(this.theta0)
+            switch this.samplingAlgorithm
+               case {'DRAM','MALA'}
+                  if size(this.theta0,1) ~= par.number
+                     error('Please make sure opt.theta0, the par.number are consistent.')
+                  end
+               case 'PT'
+                  if size(this.theta0,1) ~= par.number || ...
+                        (size(this.theta0,2) ~= this.PT.nTemps && size(this.theta0,2) ~= 1)
+                     error('Please make sure opt.theta0, the par.number and opt.PT.nTemps are consistent.')
+                  end
+               case 'PHS'
+                  if size(this.theta0,1) ~= par.number || ...
+                        (size(this.theta0,2) ~= this.PHS.nChains && size(this.theta0,2) ~= 1)
+                     error('Please make sure opt.theta0, the par.number and opt.PHS.nChains are consistent.')
+                  end
+               case 'RAMPART'
+                  if size(this.theta0,1) ~= par.number || ...
+                        (size(this.theta0,2) ~= this.RAMPART.nTemps && size(this.theta0,2) ~= 1)
+                     error('Please make sure opt.theta0, the par.number and opt.RAMPART.nTemps are consistent.')
+                  end                  
+            end
+            
+         else
+            warning('No user-provided initial point found. Setting Initial points randomly.')    
+            par.min = par.min(:);
+            par.max = par.max(:);
+            switch this.samplingAlgorithm
+               case {'DRAM','MALA'}
+                  this.theta0 = bsxfun(@plus, par.min, ...
+                     bsxfun(@times, par.max - par.min, rand(par.number,1)));
+               case 'PT'
+                  this.theta0 = bsxfun(@plus, par.min, ...
+                     bsxfun(@times, par.max - par.min, rand(par.number,this.PT.nTemps)));
+               case 'PHS'
+                  this.theta0 = bsxfun(@plus, par.min, ...
+                     bsxfun(@times, par.max - par.min, rand(par.number,this.PHS.nChains)));
+               case 'RAMPART'
+                  this.theta0 = bsxfun(@plus, par.min, ...
+                     bsxfun(@times, par.max - par.min, rand(par.number,this.RAMPART.nTemps)));                  
+            end
+         end
+         if ~isempty(this.sigma0)
+            switch this.samplingAlgorithm
+               case {'DRAM','MALA'}
+                  if size(this.sigma0,1) ~= par.number || ...
+                        size(this.sigma0,2) ~= par.number
+                     error('Please make sure opt.sigma0, the par.number are consistent.')
+                  end
+               case 'PT'
+                  if size(this.sigma0,1) ~= par.number || ...
+                        size(this.sigma0,2) ~= par.number || ...
+                        (size(this.sigma0,3) ~= this.PT.nTemps && size(this.sigma0,3) ~= 1)
+                     error('Please make sure opt.sigma0, the par.number and opt.PT.nTemps are consistent.')
+                  end
+               case 'PHS'
+                  if size(this.sigma0,1) ~= par.number || ...
+                        size(this.sigma0,2) ~= par.number || ...
+                        (size(this.sigma0,3) ~= this.PHS.nChains && size(this.sigma0,3) ~= 1)
+                     error('Please make sure opt.sigma0, the par.number and opt.PHS.nChains are consistent.')
+                  end
+               case 'RAMPART'
+                  if size(this.sigma0,1) ~= par.number || ...
+                        size(this.sigma0,2) ~= par.number || ...
+                        (size(this.sigma0,3) ~= this.RAMPART.nTemps && size(this.sigma0,3) ~= 1)
+                     error('Please make sure opt.sigma0, the par.number and opt.RAMPART.nTemps are consistent.')
+                  end                  
+            end
+         else
+            warning('No user-provided initial covariance sigma0 found. Setting to default diagonal matrix.')
+            switch this.samplingAlgorithm
+               case {'DRAM','MALA'}
+                  this.sigma0 = 1e4 * diag(ones(1,par.number));
+               case 'PT'
+                  this.sigma0 = 1e4 * diag(ones(1,par.number));
+               case 'PHS'
+                  this.sigma0 = 1e4 * diag(ones(1,par.number));
+               case 'RAMPART'
+                  this.sigma0 = 1e4 * diag(ones(1,par.number));                  
+            end
+         end
+      end
+   end
+end
diff --git a/Requirements/PESTO-1.1.0/@RAMPARTOptions/RAMPARTOptions.m b/Requirements/PESTO-1.1.0/@RAMPARTOptions/RAMPARTOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..a1b00cb2bb9b0e19eaaf56b6a043cde4e7b33be4
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@RAMPARTOptions/RAMPARTOptions.m
@@ -0,0 +1,282 @@
+classdef RAMPARTOptions < matlab.mixin.SetGet
+   % RAMPARTOptions provides an option container to specify region based parallel tempering (RAMPART) options
+   % in PestoSamplingOptions.RAMPART.
+   %
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties
+      % Add required subclasses
+      RPOpt = RegionPredictionOptions;
+      
+      % Initial number of temperatures
+      nTemps = 10;
+      
+      % The initial temperatures are set by a power law to ^opt.exponentT.
+      exponentT = 1000;
+      
+      % Parameter which controlls the adaption degeneration
+      % velocity of the single-chain proposals.
+      % Value between 0 and 1.
+      % No adaption (classical Metropolis-Hastings) for 0.
+      
+      alpha = 0.51;
+      
+      % Parameter which controlls the adaption degeneration velocity of
+      % the temperature adaption.
+      temperatureNu = 1e3;
+      
+      % The higher the value the more it lowers the impact of early adaption steps.
+      memoryLength = 1;
+      
+      % Regularization factor for ill conditioned covariance matrices of
+      % the adapted proposal density. Regularization might happen if the
+      % eigenvalues of the covariance matrix strongly differ in order of
+      % magnitude. In this case, the algorithm adds a small diag-matrix to
+      % the covariance matrix with elements regFactor.
+      regFactor = 1e-6;
+      
+      % Scaling factor for temperature adaptation
+      temperatureEta = 10;
+      
+      % Maximum T - may be infinity
+      maxT = inf;
+      
+      % Fraction of iterations which are used to train a region predictor
+      trainPhaseFrac = 0.2;
+      
+      % Number of replicates in the cross validation used in the mode
+      % selection
+      nTrainReplicates = 5;
+      
+   end
+   
+   methods
+      function obj = RAMPARTOptions(varargin)
+         % RAMPARTOptions Construct a new RAMPARTOptions object
+         %
+         %   OPTS = RAMPARTOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPTS = RAMPARTOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPTS = RAMPARTOptions(OLDOPTS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPTS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for RAMPARTOptions
+         %
+         % Parameters:
+         %  varargin:
+         
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'RAMPARTOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      function set.regFactor(this, value)
+         if(isnumeric(value) && value > 0)
+            this.regFactor = lower(value);
+         else
+            error(['Please specify a positive regularization factor for ill conditioned covariance'...
+               ' matrices of the adapted proposal density, e.g. ' ...
+               'PestoSamplingOptions.PT.regFactor = 1e-5']);
+         end
+      end
+      
+      function set.nTemps(this, value)
+         if(value == floor(value) && value > 0)
+            this.nTemps = lower(value);
+         else
+            error(['Please enter a positive integer for the number of temperatures, e.g. PestoSamplingOptions.nTemps = 10.']);
+         end
+      end
+
+      
+      function set.nTrainReplicates(this, value)
+         if(value == floor(value) && value > 0)
+            this.nTrainReplicates = lower(value);
+         else
+            error(['Please enter a positive integer for the number of replicates for mode selection, e.g. PestoSamplingOptions.nTrainReplicates = 10.']);
+         end
+      end      
+      
+      
+      function set.exponentT(this, value)
+         if(isnumeric(value) && value > 0)
+            this.exponentT = lower(value);
+         else
+            error(['Please enter a positive double for the exponent of inital temperature heuristic' ...
+               ', e.g. PestoSamplingOptions.PT.exponentT = 4.']);
+         end
+      end
+      
+      function set.alpha(this, value)
+         if(isnumeric(value) && value > 0.5 && value < 1)
+            this.alpha = lower(value);
+         else
+            error(['Please use an adaption decay constant between 0.5 and 1.0, e.g. PestoSamplingOptions.RAMPART.alpha = 0.51']);
+         end
+      end
+      
+      function set.trainPhaseFrac(this, value)
+         if(isnumeric(value) && value >= 0.0 && value <= 1)
+            this.trainPhaseFrac = lower(value);
+         else
+            error(['The PestoSamplingOptions.RAMPART.trainPhaseFrac should be a value between 0 and 1.']);
+         end
+      end      
+      
+      function set.temperatureNu(this, value)
+         if(isnumeric(value) && value > 0.0)
+            this.temperatureNu = lower(value);
+         else
+            error(['Please an temperature adaption decay constant greater 0']);
+         end
+      end
+      
+      function set.memoryLength(this, value)
+         if(value == floor(value) && value > 0)
+            this.memoryLength = lower(value);
+         else
+            error(['Please enter a positive interger memoryLength constant, '...
+               'e.g. PestoSamplingOptions.PT.memoryLength = 1']);
+         end
+      end
+      
+      function set.temperatureEta(this, value)
+         if(value == floor(value) && value > 0)
+            this.temperatureEta = lower(value);
+         else
+            error(['Please enter a positive integer for the scaling factor temperatureEta.']);
+         end
+      end
+      
+      function set.maxT(this, value)
+         if(value > 0)
+            this.maxT = lower(value);
+         else
+            error(['Please enter the maximum temperature. May be inf.']);
+         end
+      end
+      
+   end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/@RegionPredictionOptions/RegionPredictionOptions.m b/Requirements/PESTO-1.1.0/@RegionPredictionOptions/RegionPredictionOptions.m
new file mode 100644
index 0000000000000000000000000000000000000000..40f8e75e119da4a11510e4ed1c570fc518fa52ba
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/@RegionPredictionOptions/RegionPredictionOptions.m
@@ -0,0 +1,213 @@
+classdef RegionPredictionOptions < matlab.mixin.SetGet
+   % RegionPredictionOptions provides an option container to specify the
+   % options of training of a region predictor trainEMGMM.m and its predicton routine
+   % predictFromGMM.m. This is required by the region based samplers as
+   % RBPT.
+   %
+   % This file is based on AMICI amioptions.m (http://icb-dcm.github.io/AMICI/)
+   
+   properties
+      % Sets the random seed for the GMM training
+      rng                    = 7;
+      
+      % The number of samples to train the GMM from
+      nSample                = NaN;
+      
+      % The fraction of the sample used to test the likelihood for each
+      % modeNumberCandidate
+      crossValFraction       = 0.2;
+      
+      % The function will train multiple GMMs with modeNumberCandidates
+      % modes. Afterwards with will compare the GMMs using a likelihood
+      % approach on a test set.
+      modeNumberCandidates   = [1,2,3,4,5,6,7,8];
+      
+      % Display mode either 'silent', 'text' or 'visual'
+      displayMode            = 'visual';
+      
+      % The maximum iterations for the EM algorithm. Should not be reached
+      % with proper tolerances.
+      maxEMiterations        = 100;
+      
+      % The dimension of the problem
+      nDim                   = NaN;
+      
+      % The EM algorithm uses only a randomly selected subset of the
+      % sample in each iteration. This is its size.
+      nSubsetSize            = 1000;
+      
+      % Lower parameter bound
+      lowerBound             = NaN;
+      
+      % Upper parameter bound
+      upperBound             = NaN;
+      
+      % Tolerances for the EM algorithm. If the differences between old and
+      % new values of the GMM fall below those tolerances, the EM
+      % terminates. Should usually be chosen relative to the parameter bounds.
+      tolMu                  = NaN;
+      tolSigma               = NaN;
+      
+      % If selected displayMode = 'visual', this option defines 2
+      % dimensions to be plotted against each other
+      dimensionsToPlot       = [1,2];
+      
+      % This is only used for prediction. In high dimensions modes are
+      % often only seperable in a subset of dimensions. Any non informative
+      % dimensions increase the 'noise' of the prediction can may be
+      % excluded for better robustness.
+      isInformative          = NaN;
+      
+   end
+   
+   methods
+      function obj = RegionPredictionOptions(varargin)
+         % RegionPredictionOptions Construct a new RegionPredictionOptions object
+         %
+         %   OPTS = RegionPredictionOptions() creates a set of options with
+         %   each option set to itsdefault value.
+         %
+         %   OPTS = RegionPredictionOptions(PARAM, VAL, ...) creates a set
+         %   of options with the named parameters altered with the
+         %   specified values.
+         %
+         %   OPTS = RegionPredictionOptions(OLDOPTS, PARAM, VAL, ...)
+         %   creates a copy of OLDOPTS with the named parameters altered
+         %   with the specified value
+         %
+         %   Note to see the parameters, check the
+         %   documentation page for RegionPredictionOptions
+         %
+         % Parameters:
+         %  varargin:
+         
+         % adapted from SolverOptions
+         
+         if nargin > 0
+            
+            % Deal with the case where the first input to the
+            % constructor is a amioptions/struct object.
+            if isa(varargin{1},'RegionPredictionOptions')
+               if strcmp(class(varargin{1}),class(obj))
+                  obj = varargin{1};
+               else
+                  % Get the properties from options object passed
+                  % into the constructor.
+                  thisProps = properties(obj);
+                  % Set the common properties. Note that we
+                  % investigated first finding the properties that
+                  % are common to both objects and just looping over
+                  % those. We found that in most cases this was no
+                  % quicker than just looping over the properties of
+                  % the object passed in.
+                  for i = 1:length(thisProps)
+                     try %#ok
+                        % Try to set one of the properties of the
+                        % old object in the new one.
+                        obj.(thisProps{i}) = varargin{1}.(thisProps{i});
+                     end
+                  end
+               end
+               firstInputObj = true;
+            elseif isstruct(varargin{1})
+               fieldlist = fieldnames(varargin{1});
+               for ifield = 1:length(fieldlist)
+                  obj.(fieldlist{ifield}) = varargin{1}.(fieldlist{ifield});
+               end
+               firstInputObj = true;
+            elseif isempty(varargin{1})
+               firstInputObj = true;
+            else
+               firstInputObj = false;
+            end
+            
+            % Extract the options that the caller of the constructor
+            % wants to set.
+            if firstInputObj
+               pvPairs = varargin(2:end);
+            else
+               pvPairs = varargin;
+            end
+            
+            % Loop through each param-value pair and just try to set
+            % the option. When the option has been fully specified with
+            % the correct case, this is fast. The catch clause deals
+            % with partial matches or errors.
+            haveCreatedInputParser = false;
+            for i = 1:2:length(pvPairs)
+               try
+                  obj.(pvPairs{i}) = pvPairs{i+1};
+               catch ME %#ok
+                  
+                  % Create the input parser if we haven't already. We
+                  % do it here to avoid creating it if possible, as
+                  % it is slow to set up.
+                  if ~haveCreatedInputParser
+                     ip = inputParser;
+                     % Structures are currently not supported as
+                     % an input to optimoptions. Setting the
+                     % StructExpand property of the input parser to
+                     % false, forces the parser to treat the
+                     % structure as a single input and not a set of
+                     % param-value pairs.
+                     ip.StructExpand =  false;
+                     % Get list of option names
+                     allOptionNames = properties(obj);
+                     for j = 1:length(allOptionNames)
+                        % Just specify an empty default as we already have the
+                        % defaults in the options object.
+                        ip.addParameter(allOptionNames{j}, []);
+                     end
+                     haveCreatedInputParser = true;
+                  end
+                  
+                  % Get the p-v pair to parse.
+                  thisPair = pvPairs(i:min(i+1, length(pvPairs)));
+                  ip.parse(thisPair{:});
+                  
+                  % Determine the option that was specified in p-v pairs.
+                  % These options will now be matched even if only partially
+                  % specified (by 13a). Now set the specified value in the
+                  % options object.
+                  optionSet = setdiff(allOptionNames, ip.UsingDefaults);
+                  obj.(optionSet{1}) = ip.Results.(optionSet{1});
+               end
+            end
+         end
+      end
+      
+      %% Part for checking the correct setting of options
+      
+      % TODO: Add checks
+      
+      function this = checkDependentDefaults(this, par)
+         % TODO: Add checks for dependent properties (related to parent
+         % classes).
+      end
+   end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/LICENSE b/Requirements/PESTO-1.1.0/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..dae3d73739a7e01d2f9c45d89cf43c2d72a8a3c0
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/LICENSE
@@ -0,0 +1,12 @@
+Copyright (c) 2016, Jan Hasenauer
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/PESTO-1.1.0/README.md b/Requirements/PESTO-1.1.0/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..03ead37e1140c815931436f54800a0ae52c2485b
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/README.md
@@ -0,0 +1,31 @@
+# PESTO - Parameter EStimation TOolbox
+
+PESTO is a widely applicable and highly customizable toolbox for parameter estimation in MathWorks MATLAB. It offers state-of-the art algorithms for optimization and uncertainty analysis, which work in a very generic manner, treating the objective function as a black box. Hence, PESTO can be used for any parameter estimation problem, which provides an objective function in MATLAB. PESTO has been used in various computational biology [research projects](https://github.com/ICB-DCM/PESTO/wiki#references).
+
+PESTO features include:
+* Multistart optimization
+* Sampling routines
+* Profile-likelihood analysis
+* Visualization routines
+* and more
+
+These functions are demonstrated in several systems biology examples included in the [`examples/`](examples/) directory.
+
+## Download & installation
+
+Clone the PESTO repository or download the latest [release archive](https://github.com/ICB-DCM/PESTO/releases).
+The top-level folder of the cloned repository or the unpacked archive needs to be added to the MATLAB search path (non-recursively).
+
+*Note:* Detailed instructions on how to modify your MATLAB search path are provided here: https://de.mathworks.com/help/matlab/matlab_env/add-remove-or-reorder-folders-on-the-search-path.html
+
+## Documentation
+
+PESTO usage is demonstrated in various [examples](examples/). Further documentation is available in [```doc/PESTO-doc.pdf```](doc/PESTO-doc.pdf).
+
+## Compatibility
+
+PESTO is implemented fully in MATLAB and compatible with MATLAB releases from R2014b up to at least 2017a running on Windows, Mac and Linux.
+
+## Licensing
+
+See [ ```LICENSE```](LICENSE) file in the PESTO source directory.
diff --git a/Requirements/PESTO-1.1.0/bobyqa/LICENCE.txt b/Requirements/PESTO-1.1.0/bobyqa/LICENCE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f40998729f9d20523f013c55b026d349c36a4ec
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/bobyqa/LICENCE.txt
@@ -0,0 +1,18 @@
+BOBYQA---Bound Optimization BY Quadratic Approximation.
+Copyright (C) 2009 M. J. D. Powell (University of Cambridge)
+
+This package is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This package is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Lesser General Public License
+ https://www.gnu.org/copyleft/lesser.html
+for more details.
+
+Michael J. D. Powell <mjdp@cam.ac.uk>
+University of Cambridge
+Cambridge, UK.
diff --git a/Requirements/PESTO-1.1.0/bobyqa/bobyqa.m b/Requirements/PESTO-1.1.0/bobyqa/bobyqa.m
new file mode 100644
index 0000000000000000000000000000000000000000..2f752e62e3c1dd69efc9e75d4f45fa6bee1a53ea
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/bobyqa/bobyqa.m
@@ -0,0 +1,111 @@
+function varargout = bobyqa(fun,x0,lb,ub,varargin)
+% MatLab wrapper for the mexbobyqa.F routine, which ports Powell's BOBYQA
+% routine to MatLab. mexbobyqa.F needs th have been compiled via mex
+% before.
+%
+% Input:
+% fun     : objective function to be minimized
+% x0      : initial guess for parameters
+% lb, ub  : bounds for parameters
+% options : struct with options for the algorithm:
+%   Rhobeg, Rhoend, MaxFunEvals : see algorithm definition
+%
+% Output:
+% x   : best guess for parameters
+% fval: objective function at the solution, generally fval=fun(x)
+% exitflag:
+%   1 : The function converged to a solution x
+%   0 : Number of iterations exceeded options.MaxIter or number of function
+%       evaluations exceeded options.MaxFunEvals.
+%   -1: The algorithm was terminated inappropriately
+% output : struct with meta information:
+%   funcCount   : number of function evaluations
+%   algorithm   : name of the algorithm
+%   t_cpu       : cpu time
+%
+% Currently has 2nd mode with 0 input arguments returning a function handle
+% used by funHandleWrap.m to compute objective function values. This is
+% because via mexCallMATLAB only non-anonymous functions (e.g. defined in a
+% file) or global function handles can be called, but pesto uses anonymous
+% function handles. ATTENTION: This might be not thread-safe.
+
+%% save objective funtion
+
+% sorry for being global
+global bobyqafun_sfbg;
+
+if nargin == 0
+    varargout{1} = bobyqafun_sfbg;
+    return;
+end
+
+%% main part
+
+if ~exist('mexbobyqa', 'file')
+    error(sprintf(['The mexbobyqa file does not exist. Please compile it first\n',...
+		'by running the file compile_mexbobyqa.m in the bobyqa directory.']));
+end
+
+bobyqafun_sfbg = fun;
+
+% check for options
+if (nargin > 4)
+    options = varargin{1};
+else
+    options = struct();
+end
+
+% interpret parameters
+
+N       = length(x0);
+
+if (isfield(options,'Npt') && ~isempty(options.Npt))
+    NPT		= options.Npt;
+else
+    NPT  = 2*N+1;
+end
+
+X       = x0;
+LB      = lb;
+UB      = ub;
+
+CALFUN  = func2str(fun);
+
+if (isfield(options,'Rhobeg') && ~isempty(options.Rhobeg))
+    RHOBEG		= options.Rhobeg;
+else
+    RHOBEG  = 1e-1;
+end
+
+if (isfield(options,'Rhoend') && ~isempty(options.Rhoend))
+    RHOEND		= options.Rhoend;
+else
+    RHOEND  = 1e-8;
+end
+
+if (isfield(options,'MaxFunEvals') && ~isempty(options.MaxFunEvals))
+    MAXFUN		= options.MaxFunEvals;
+else
+    MAXFUN  = 1000*N;
+end
+
+IPRINT = 0; % no output
+
+% track time
+starttime = cputime;
+
+% do optimization
+[ x,fval,feval ] = mexbobyqa(N,NPT,X,LB,UB,CALFUN,RHOBEG,RHOEND,MAXFUN,IPRINT);
+
+% meta information
+output.funcCount = feval;
+output.algorithm = 'BOBYQA';
+output.t_cpu = cputime - starttime;
+exitflag = 1;
+
+% return
+varargout{1} = x;
+varargout{2} = fval;
+varargout{3} = exitflag;
+varargout{4} = output;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/bobyqa/bobyqaFunHandleWrap.m b/Requirements/PESTO-1.1.0/bobyqa/bobyqaFunHandleWrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..84b2d384d78fdea0505b32d93d539f30da548772
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/bobyqa/bobyqaFunHandleWrap.m
@@ -0,0 +1,17 @@
+function [ y ] = bobyqaFunHandleWrap(x, calfun)
+% This is a wrapper to compute the objective function value. 
+% Called from within the mexbobyqa routine. 
+% funHandleWrap currently uses a global variable in bobyqa.m, 
+% the argument calfun is not used.
+%
+% Input:
+%   x: parameter vector
+%   calfun: objective function handle or string representation
+%
+% Output:
+%   y: objective function value
+
+fun = bobyqa();
+y = fun(x);
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/bobyqa/compile_mexbobyqa.m b/Requirements/PESTO-1.1.0/bobyqa/compile_mexbobyqa.m
new file mode 100644
index 0000000000000000000000000000000000000000..a67925cd728e4dae51cec55c03a333ec5cd38547
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/bobyqa/compile_mexbobyqa.m
@@ -0,0 +1,9 @@
+% Run this file once in order to compile the mexbobyqa.F file to the mexbobyqa.mex***
+% format, which can be recognized by Matlab. Then you will be able to use the 
+% bobyqa.m function.
+
+% Required: Your current Matlab installation must be connected to a Fortran compiler. 
+% For further information see: 
+% https://mathworks.com/help/matlab/build-fortran-mex-files-1.html
+
+mex mexbobyqa.F
diff --git a/Requirements/PESTO-1.1.0/bobyqa/mexbobyqa.F b/Requirements/PESTO-1.1.0/bobyqa/mexbobyqa.F
new file mode 100644
index 0000000000000000000000000000000000000000..2cf1aba967c27f6ef194e7aecdda9312e1a304ff
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/bobyqa/mexbobyqa.F
@@ -0,0 +1,2230 @@
+#include <fintrf.h>
+C	Input:
+C	N,NPT,X,LB,UB,CALFUN,RHOBEG,RHOEND,MAXFUN,IPRINT
+C 	Output:
+C 	X     (giving the least calculated function value)
+C 	F     (CALFUN(X))
+C 	FEVAL (number of function evaluations)
+	SUBROUTINE MEXFUNCTION(NLHS,PLHS,NRHS,PRHS)
+
+C		input and output variables
+		MWPOINTER PLHS(*), PRHS(*)
+		INTEGER*8 NLHS,NRHS
+		
+C		mex stuff
+		INTEGER*8 MEXCALLMATLAB
+		MWPOINTER MXCREATEDOUBLEMATRIX,MXGETPR	,MXCREATENUMERICMATRIX
+		MWSIZE MXGETM,MXGETN
+		
+C 		get lengths of variables
+		
+C 		more variables
+		MWPOINTER p
+		REAL*8 rN,rNPT
+		INTEGER*8 N,NPT,WORKSPACE
+		
+C 		check input
+		IF (NRHS .LT. 10) THEN
+			CALL MEXERRMSGTXT('Wrong number of inputs.')
+		END IF
+		
+		p = MXGETPR(PRHS(1))
+		CALL MXCOPYPTRTOREAL8(p,rN,1)
+		N = INT(rN)
+		
+		p = MXGETPR(PRHS(2))
+		CALL MXCOPYPTRTOREAL8(p,rNPT,1)
+		NPT = INT(rNPT)
+		
+		WORKSPACE = INT((NPT+5)*(NPT+N)+3*N*(N+5)/2)
+		
+		CALL MAIN(N,NPT,WORKSPACE,NLHS,PLHS,NRHS,PRHS)
+
+		RETURN
+		
+	END
+			
+	SUBROUTINE MAIN (N,NPT,WORKSPACE,NLHS,PLHS,NRHS,PRHS)
+		
+C		input and output variables
+		MWPOINTER PLHS(*), PRHS(*)
+		INTEGER*8 N,NPT,WORKSPACE,NLHS,NRHS
+		
+C		mex stuff
+		INTEGER*8 MEXCALLMATLAB
+		MWPOINTER MXCREATEDOUBLEMATRIX,MXGETPR
+		MWSIZE MXGETM,MXGETN
+		
+C		more variables
+		MWPOINTER p
+		REAL*8 rIPRINT,rMAXFUN,rFEVAL
+		INTEGER*8 IPRINT,MAXFUN,FEVAL
+		REAL*8 X(N),RHOBEG,RHOEND,LB(N),UB(N),W(WORKSPACE)
+		REAL*8 F
+		
+C       interpret input
+		
+		p = MXGETPR(PRHS(3))
+		CALL MXCOPYPTRTOREAL8(p,X,N)
+		
+		p = MXGETPR(PRHS(4))
+		CALL MXCOPYPTRTOREAL8(p,LB,N)
+		
+		p = MXGETPR(PRHS(5))
+		CALL MXCOPYPTRTOREAL8(p,UB,N)
+		
+C 		simply take FUN from PRHS(6)
+		
+		p = MXGETPR(PRHS(7))
+		CALL MXCOPYPTRTOREAL8(p,RHOBEG,1)
+		
+		p = MXGETPR(PRHS(8))
+		CALL MXCOPYPTRTOREAL8(p,RHOEND,1)
+		
+		p = MXGETPR(PRHS(9))
+		CALL MXCOPYPTRTOREAL8(p,rMAXFUN,1)
+		MAXFUN = INT(rMAXFUN)
+		
+		p = MXGETPR(PRHS(10))
+		CALL MXCOPYPTRTOREAL8(p,rIPRINT,1)
+		IPRINT = INT(rIPRINT)	
+		
+C 		count function evaluations
+		FEVAL = 7
+		
+C 		do optimization
+		
+		CALL BOBYQA (N,NPT,X,LB,UB,RHOBEG,RHOEND,IPRINT,MAXFUN,W)
+		
+C 		write output
+		
+		PLHS(1) = MXCREATEDOUBLEMATRIX(N,1,0)
+		p = MXGETPR(PLHS(1))
+		CALL MXCOPYREAL8TOPTR(X,p,N)
+		
+		CALL CALFUN(N,X,F)
+		PLHS(2) = MXCREATEDOUBLEMATRIX(1,1,0)
+		p = MXGETPR(PLHS(2))
+		CALL MXCOPYREAL8TOPTR(F,p,1)
+		
+		rFEVAL = REAL(FEVAL)
+		PLHS(3) = MXCREATEDOUBLEMATRIX(1,1,0)
+		p = MXGETPR(PLHS(3))
+		CALL MXCOPYREAL8TOPTR(rFEVAL,p,1)
+
+		RETURN
+		
+		CONTAINS
+
+	SUBROUTINE CALFUN (N,X,F)
+	
+C 		input variables
+		INTEGER*8 N
+		REAL*8 X(*)
+C 		output variables
+		REAL*8 F
+		
+C 		more variables
+		MWPOINTER PLHS1(1),PRHS1(2),pX,pF
+		INTEGER*8 NLHS1,NRHS1
+		
+		NRHS1 = 2
+C 		first argument: x
+		PRHS1(1) = MXCREATEDOUBLEMATRIX(N,1,0)	
+		pX = MXGETPR(PRHS1(1))
+		CALL MXCOPYREAL8TOPTR(X,pX,N)
+C 		second argument: fun
+		PRHS1(2) = PRHS(6)
+		
+		NLHS1 = 1
+		
+		CALL MEXCALLMATLAB(NLHS1,PLHS1,NRHS1,PRHS1,'bobyqaFunHandleWrap')
+		
+		pF = MXGETPR(PLHS1(1))
+		CALL MXCOPYPTRTOREAL8(pF,F,1)
+	
+		FEVAL = FEVAL+1
+		
+		RETURN
+		
+	END SUBROUTINE CALFUN
+			
+	SUBROUTINE BOBYQA (N,NPT,X,XL,XU,RHOBEG,RHOEND,IPRINT,MAXFUN,W)
+      
+	  IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION X(*),XL(*),XU(*),W(*)
+	  
+C
+C     This subroutine seeks the least value of a function of many variables,
+C     by applying a trust region method that forms quadratic models by
+C     interpolation. There is usually some freedom in the interpolation
+C     conditions, which is taken up by minimizing the Frobenius norm of
+C     the change to the second derivative of the model, beginning with the
+C     zero matrix. The values of the variables are constrained by upper and
+C     lower bounds. The arguments of the subroutine are as follows.
+C
+C     N must be set to the number of variables and must be at least two.
+C     NPT is the number of interpolation conditions. Its value must be in
+C       the interval [N+2,(N+1)(N+2)/2]. Choices that exceed 2*N+1 are not
+C       recommended.
+C     Initial values of the variables must be set in X(1),X(2),...,X(N). They
+C       will be changed to the values that give the least calculated F.
+C     For I=1,2,...,N, XL(I) and XU(I) must provide the lower and upper
+C       bounds, respectively, on X(I). The construction of quadratic models
+C       requires XL(I) to be strictly less than XU(I) for each I. Further,
+C       the contribution to a model from changes to the I-th variable is
+C       damaged severely by rounding errors if XU(I)-XL(I) is too small.
+C     RHOBEG and RHOEND must be set to the initial and final values of a trust
+C       region radius, so both must be positive with RHOEND no greater than
+C       RHOBEG. Typically, RHOBEG should be about one tenth of the greatest
+C       expected change to a variable, while RHOEND should indicate the
+C       accuracy that is required in the final values of the variables. An
+C       error return occurs if any of the differences XU(I)-XL(I), I=1,...,N,
+C       is less than 2*RHOBEG.
+C     The value of IPRINT should be set to 0, 1, 2 or 3, which controls the
+C       amount of printing. Specifically, there is no output if IPRINT=0 and
+C       there is output only at the return if IPRINT=1. Otherwise, each new
+C       value of RHO is printed, with the best vector of variables so far and
+C       the corresponding value of the objective function. Further, each new
+C       value of F with its variables are output if IPRINT=3.
+C     MAXFUN must be set to an upper bound on the number of calls of CALFUN.
+C     The array W will be used for working space. Its length must be at least
+C       (NPT+5)*(NPT+N)+3*N*(N+5)/2.
+C
+C     SUBROUTINE CALFUN (N,X,F) has to be provided by the user. It must set
+C     F to the value of the objective function for the current values of the
+C     variables X(1),X(2),...,X(N), which are generated automatically in a
+C     way that satisfies the bounds given in XL and XU.
+C
+C     Return if the value of NPT is unacceptable.
+C
+      NP=N+1
+      IF (NPT .LT. N+2 .OR. NPT .GT. ((N+2)*NP)/2) THEN
+          PRINT 10
+   10     FORMAT (/4X,'Return from BOBYQA because NPT is not in',
+     1      ' the required interval')
+          GO TO 40
+      END IF
+C
+C     Partition the working space array, so that different parts of it can
+C     be treated separately during the calculation of BOBYQB. The partition
+C     requires the first (NPT+2)*(NPT+N)+3*N*(N+5)/2 elements of W plus the
+C     space that is taken by the last array in the argument list of BOBYQB.
+C
+      NDIM=NPT+N
+      IXB=1
+      IXP=IXB+N
+      IFV=IXP+N*NPT
+      IXO=IFV+NPT
+      IGO=IXO+N
+      IHQ=IGO+N
+      IPQ=IHQ+(N*NP)/2
+      IBMAT=IPQ+NPT
+      IZMAT=IBMAT+NDIM*N
+      ISL=IZMAT+NPT*(NPT-NP)
+      ISU=ISL+N
+      IXN=ISU+N
+      IXA=IXN+N
+      ID=IXA+N
+      IVL=ID+N
+      IW=IVL+NDIM
+C
+C     Return if there is insufficient space between the bounds. Modify the
+C     initial X if necessary in order to avoid conflicts between the bounds
+C     and the construction of the first quadratic model. The lower and upper
+C     bounds on moves from the updated X are set now, in the ISL and ISU
+C     partitions of W, in order to provide useful and exact information about
+C     components of X that become within distance RHOBEG from their bounds.
+C
+      ZERO=0.0D0
+      DO 30 J=1,N
+      TEMP=XU(J)-XL(J)
+      IF (TEMP .LT. RHOBEG+RHOBEG) THEN
+          PRINT 20
+   20     FORMAT (/4X,'Return from BOBYQA because one of the',
+     1      ' differences XU(I)-XL(I)'/6X,' is less than 2*RHOBEG.')
+          GO TO 40
+      END IF
+      JSL=ISL+J-1
+      JSU=JSL+N
+      W(JSL)=XL(J)-X(J)
+      W(JSU)=XU(J)-X(J)
+      IF (W(JSL) .GE. -RHOBEG) THEN
+          IF (W(JSL) .GE. ZERO) THEN
+              X(J)=XL(J)
+              W(JSL)=ZERO
+              W(JSU)=TEMP
+          ELSE
+              X(J)=XL(J)+RHOBEG
+              W(JSL)=-RHOBEG
+              W(JSU)=DMAX1(XU(J)-X(J),RHOBEG)
+          END IF
+      ELSE IF (W(JSU) .LE. RHOBEG) THEN
+          IF (W(JSU) .LE. ZERO) THEN
+              X(J)=XU(J)
+              W(JSL)=-TEMP
+              W(JSU)=ZERO
+          ELSE
+              X(J)=XU(J)-RHOBEG
+              W(JSL)=DMIN1(XL(J)-X(J),-RHOBEG)
+              W(JSU)=RHOBEG
+          END IF
+      END IF
+   30 CONTINUE
+C
+C     Make the call of BOBYQB.
+C
+      CALL BOBYQB (N,NPT,X,XL,XU,RHOBEG,RHOEND,IPRINT,MAXFUN,W(IXB),
+     1  W(IXP),W(IFV),W(IXO),W(IGO),W(IHQ),W(IPQ),W(IBMAT),W(IZMAT),
+     2  NDIM,W(ISL),W(ISU),W(IXN),W(IXA),W(ID),W(IVL),W(IW))
+   40 RETURN
+      END SUBROUTINE BOBYQA
+	  
+	  SUBROUTINE BOBYQB (N,NPT,X,XL,XU,RHOBEG,RHOEND,IPRINT,
+     1  MAXFUN,XBASE,XPT,FVAL,XOPT,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,
+     2  SL,SU,XNEW,XALT,D,VLAG,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION X(*),XL(*),XU(*),XBASE(*),XPT(NPT,*),FVAL(*),
+     1  XOPT(*),GOPT(*),HQ(*),PQ(*),BMAT(NDIM,*),ZMAT(NPT,*),
+     2  SL(*),SU(*),XNEW(*),XALT(*),D(*),VLAG(*),W(*)
+C
+C     The arguments N, NPT, X, XL, XU, RHOBEG, RHOEND, IPRINT and MAXFUN
+C       are identical to the corresponding arguments in SUBROUTINE BOBYQA.
+C     XBASE holds a shift of origin that should reduce the contributions
+C       from rounding errors to values of the model and Lagrange functions.
+C     XPT is a two-dimensional array that holds the coordinates of the
+C       interpolation points relative to XBASE.
+C     FVAL holds the values of F at the interpolation points.
+C     XOPT is set to the displacement from XBASE of the trust region centre.
+C     GOPT holds the gradient of the quadratic model at XBASE+XOPT.
+C     HQ holds the explicit second derivatives of the quadratic model.
+C     PQ contains the parameters of the implicit second derivatives of the
+C       quadratic model.
+C     BMAT holds the last N columns of H.
+C     ZMAT holds the factorization of the leading NPT by NPT submatrix of H,
+C       this factorization being ZMAT times ZMAT^T, which provides both the
+C       correct rank and positive semi-definiteness.
+C     NDIM is the first dimension of BMAT and has the value NPT+N.
+C     SL and SU hold the differences XL-XBASE and XU-XBASE, respectively.
+C       All the components of every XOPT are going to satisfy the bounds
+C       SL(I) .LEQ. XOPT(I) .LEQ. SU(I), with appropriate equalities when
+C       XOPT is on a constraint boundary.
+C     XNEW is chosen by SUBROUTINE TRSBOX or ALTMOV. Usually XBASE+XNEW is the
+C       vector of variables for the next call of CALFUN. XNEW also satisfies
+C       the SL and SU constraints in the way that has just been mentioned.
+C     XALT is an alternative to XNEW, chosen by ALTMOV, that may replace XNEW
+C       in order to increase the denominator in the updating of UPDATE.
+C     D is reserved for a trial step from XOPT, which is usually XNEW-XOPT.
+C     VLAG contains the values of the Lagrange functions at a new point X.
+C       They are part of a product that requires VLAG to be of length NDIM.
+C     W is a one-dimensional array that is used for working space. Its length
+C       must be at least 3*NDIM = 3*(NPT+N).
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      TEN=10.0D0
+      TENTH=0.1D0
+      TWO=2.0D0
+      ZERO=0.0D0
+      NP=N+1
+      NPTM=NPT-NP
+      NH=(N*NP)/2
+C
+C     The call of PRELIM sets the elements of XBASE, XPT, FVAL, GOPT, HQ, PQ,
+C     BMAT and ZMAT for the first iteration, with the corresponding values of
+C     of NF and KOPT, which are the number of calls of CALFUN so far and the
+C     index of the interpolation point at the trust region centre. Then the
+C     initial XOPT is set too. The branch to label 720 occurs if MAXFUN is
+C     less than NPT. GOPT will be updated if KOPT is different from KBASE.
+C
+      CALL PRELIM (N,NPT,X,XL,XU,RHOBEG,IPRINT,MAXFUN,XBASE,XPT,
+     1  FVAL,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,KOPT)
+      XOPTSQ=ZERO
+      DO 10 I=1,N
+      XOPT(I)=XPT(KOPT,I)
+   10 XOPTSQ=XOPTSQ+XOPT(I)**2
+      FSAVE=FVAL(1)
+      IF (NF .LT. NPT) THEN
+          IF (IPRINT .GT. 0) PRINT 390
+          GOTO 720
+      END IF
+      KBASE=1
+C
+C     Complete the settings that are required for the iterative procedure.
+C
+      RHO=RHOBEG
+      DELTA=RHO
+      NRESC=NF
+      NTRITS=0
+      DIFFA=ZERO
+      DIFFB=ZERO
+      ITEST=0
+      NFSAV=NF
+C
+C     Update GOPT if necessary before the first iteration and after each
+C     call of RESCUE that makes a call of CALFUN.
+C
+   20 IF (KOPT .NE. KBASE) THEN
+          IH=0
+          DO 30 J=1,N
+          DO 30 I=1,J
+          IH=IH+1
+          IF (I .LT. J) GOPT(J)=GOPT(J)+HQ(IH)*XOPT(I)
+   30     GOPT(I)=GOPT(I)+HQ(IH)*XOPT(J)
+          IF (NF .GT. NPT) THEN
+              DO 50 K=1,NPT
+              TEMP=ZERO
+              DO 40 J=1,N
+   40         TEMP=TEMP+XPT(K,J)*XOPT(J)
+              TEMP=PQ(K)*TEMP
+              DO 50 I=1,N
+   50         GOPT(I)=GOPT(I)+TEMP*XPT(K,I)
+          END IF
+      END IF
+C
+C     Generate the next point in the trust region that provides a small value
+C     of the quadratic model subject to the constraints on the variables.
+C     The integer NTRITS is set to the number "trust region" iterations that
+C     have occurred since the last "alternative" iteration. If the length
+C     of XNEW-XOPT is less than HALF*RHO, however, then there is a branch to
+C     label 650 or 680 with NTRITS=-1, instead of calculating F at XNEW.
+C
+   60 CALL TRSBOX (N,NPT,XPT,XOPT,GOPT,HQ,PQ,SL,SU,DELTA,XNEW,D,
+     1  W,W(NP),W(NP+N),W(NP+2*N),W(NP+3*N),DSQ,CRVMIN)
+      DNORM=DMIN1(DELTA,DSQRT(DSQ))
+      IF (DNORM .LT. HALF*RHO) THEN
+          NTRITS=-1
+          DISTSQ=(TEN*RHO)**2
+          IF (NF .LE. NFSAV+2) GOTO 650
+C
+C     The following choice between labels 650 and 680 depends on whether or
+C     not our work with the current RHO seems to be complete. Either RHO is
+C     decreased or termination occurs if the errors in the quadratic model at
+C     the last three interpolation points compare favourably with predictions
+C     of likely improvements to the model within distance HALF*RHO of XOPT.
+C
+          ERRBIG=DMAX1(DIFFA,DIFFB,DIFFC)
+          FRHOSQ=0.125D0*RHO*RHO
+          IF (CRVMIN .GT. ZERO .AND. ERRBIG .GT. FRHOSQ*CRVMIN)
+     1       GOTO 650
+          BDTOL=ERRBIG/RHO
+          DO 80 J=1,N
+          BDTEST=BDTOL
+          IF (XNEW(J) .EQ. SL(J)) BDTEST=W(J)
+          IF (XNEW(J) .EQ. SU(J)) BDTEST=-W(J)
+          IF (BDTEST .LT. BDTOL) THEN
+              CURV=HQ((J+J*J)/2)
+              DO 70 K=1,NPT
+   70         CURV=CURV+PQ(K)*XPT(K,J)**2
+              BDTEST=BDTEST+HALF*CURV*RHO
+              IF (BDTEST .LT. BDTOL) GOTO 650
+          END IF
+   80     CONTINUE
+          GOTO 680
+      END IF
+      NTRITS=NTRITS+1
+C
+C     Severe cancellation is likely to occur if XOPT is too far from XBASE.
+C     If the following test holds, then XBASE is shifted so that XOPT becomes
+C     zero. The appropriate changes are made to BMAT and to the second
+C     derivatives of the current model, beginning with the changes to BMAT
+C     that do not depend on ZMAT. VLAG is used temporarily for working space.
+C
+   90 IF (DSQ .LE. 1.0D-3*XOPTSQ) THEN
+          FRACSQ=0.25D0*XOPTSQ
+          SUMPQ=ZERO
+          DO 110 K=1,NPT
+          SUMPQ=SUMPQ+PQ(K)
+          SUM=-HALF*XOPTSQ
+          DO 100 I=1,N
+  100     SUM=SUM+XPT(K,I)*XOPT(I)
+          W(NPT+K)=SUM
+          TEMP=FRACSQ-HALF*SUM
+          DO 110 I=1,N
+          W(I)=BMAT(K,I)
+          VLAG(I)=SUM*XPT(K,I)+TEMP*XOPT(I)
+          IP=NPT+I
+          DO 110 J=1,I
+  110     BMAT(IP,J)=BMAT(IP,J)+W(I)*VLAG(J)+VLAG(I)*W(J)
+C
+C     Then the revisions of BMAT that depend on ZMAT are calculated.
+C
+          DO 150 JJ=1,NPTM
+          SUMZ=ZERO
+          SUMW=ZERO
+          DO 120 K=1,NPT
+          SUMZ=SUMZ+ZMAT(K,JJ)
+          VLAG(K)=W(NPT+K)*ZMAT(K,JJ)
+  120     SUMW=SUMW+VLAG(K)
+          DO 140 J=1,N
+          SUM=(FRACSQ*SUMZ-HALF*SUMW)*XOPT(J)
+          DO 130 K=1,NPT
+  130     SUM=SUM+VLAG(K)*XPT(K,J)
+          W(J)=SUM
+          DO 140 K=1,NPT
+  140     BMAT(K,J)=BMAT(K,J)+SUM*ZMAT(K,JJ)
+          DO 150 I=1,N
+          IP=I+NPT
+          TEMP=W(I)
+          DO 150 J=1,I
+  150     BMAT(IP,J)=BMAT(IP,J)+TEMP*W(J)
+C
+C     The following instructions complete the shift, including the changes
+C     to the second derivative parameters of the quadratic model.
+C
+          IH=0
+          DO 170 J=1,N
+          W(J)=-HALF*SUMPQ*XOPT(J)
+          DO 160 K=1,NPT
+          W(J)=W(J)+PQ(K)*XPT(K,J)
+  160     XPT(K,J)=XPT(K,J)-XOPT(J)
+          DO 170 I=1,J
+          IH=IH+1
+          HQ(IH)=HQ(IH)+W(I)*XOPT(J)+XOPT(I)*W(J)
+  170     BMAT(NPT+I,J)=BMAT(NPT+J,I)
+          DO 180 I=1,N
+          XBASE(I)=XBASE(I)+XOPT(I)
+          XNEW(I)=XNEW(I)-XOPT(I)
+          SL(I)=SL(I)-XOPT(I)
+          SU(I)=SU(I)-XOPT(I)
+  180     XOPT(I)=ZERO
+          XOPTSQ=ZERO
+      END IF
+      IF (NTRITS .EQ. 0) GOTO 210
+      GOTO 230
+C
+C     XBASE is also moved to XOPT by a call of RESCUE. This calculation is
+C     more expensive than the previous shift, because new matrices BMAT and
+C     ZMAT are generated from scratch, which may include the replacement of
+C     interpolation points whose positions seem to be causing near linear
+C     dependence in the interpolation conditions. Therefore RESCUE is called
+C     only if rounding errors have reduced by at least a factor of two the
+C     denominator of the formula for updating the H matrix. It provides a
+C     useful safeguard, but is not invoked in most applications of BOBYQA.
+C
+  190 NFSAV=NF
+      KBASE=KOPT
+      CALL RESCUE (N,NPT,XL,XU,IPRINT,MAXFUN,XBASE,XPT,FVAL,
+     1  XOPT,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,DELTA,KOPT,
+     2  VLAG,W,W(N+NP),W(NDIM+NP))
+C
+C     XOPT is updated now in case the branch below to label 720 is taken.
+C     Any updating of GOPT occurs after the branch below to label 20, which
+C     leads to a trust region iteration as does the branch to label 60.
+C
+      XOPTSQ=ZERO
+      IF (KOPT .NE. KBASE) THEN
+          DO 200 I=1,N
+          XOPT(I)=XPT(KOPT,I)
+  200     XOPTSQ=XOPTSQ+XOPT(I)**2
+      END IF
+      IF (NF .LT. 0) THEN
+          NF=MAXFUN
+          IF (IPRINT .GT. 0) PRINT 390
+          GOTO 720
+      END IF
+      NRESC=NF
+      IF (NFSAV .LT. NF) THEN
+          NFSAV=NF
+          GOTO 20
+      END IF
+      IF (NTRITS .GT. 0) GOTO 60
+C
+C     Pick two alternative vectors of variables, relative to XBASE, that
+C     are suitable as new positions of the KNEW-th interpolation point.
+C     Firstly, XNEW is set to the point on a line through XOPT and another
+C     interpolation point that minimizes the predicted value of the next
+C     denominator, subject to ||XNEW - XOPT|| .LEQ. ADELT and to the SL
+C     and SU bounds. Secondly, XALT is set to the best feasible point on
+C     a constrained version of the Cauchy step of the KNEW-th Lagrange
+C     function, the corresponding value of the square of this function
+C     being returned in CAUCHY. The choice between these alternatives is
+C     going to be made when the denominator is calculated.
+C
+  210 CALL ALTMOV (N,NPT,XPT,XOPT,BMAT,ZMAT,NDIM,SL,SU,KOPT,
+     1  KNEW,ADELT,XNEW,XALT,ALPHA,CAUCHY,W,W(NP),W(NDIM+1))
+      DO 220 I=1,N
+  220 D(I)=XNEW(I)-XOPT(I)
+C
+C     Calculate VLAG and BETA for the current choice of D. The scalar
+C     product of D with XPT(K,.) is going to be held in W(NPT+K) for
+C     use when VQUAD is calculated.
+C
+  230 DO 250 K=1,NPT
+      SUMA=ZERO
+      SUMB=ZERO
+      SUM=ZERO
+      DO 240 J=1,N
+      SUMA=SUMA+XPT(K,J)*D(J)
+      SUMB=SUMB+XPT(K,J)*XOPT(J)
+  240 SUM=SUM+BMAT(K,J)*D(J)
+      W(K)=SUMA*(HALF*SUMA+SUMB)
+      VLAG(K)=SUM
+  250 W(NPT+K)=SUMA
+      BETA=ZERO
+      DO 270 JJ=1,NPTM
+      SUM=ZERO
+      DO 260 K=1,NPT
+  260 SUM=SUM+ZMAT(K,JJ)*W(K)
+      BETA=BETA-SUM*SUM
+      DO 270 K=1,NPT
+  270 VLAG(K)=VLAG(K)+SUM*ZMAT(K,JJ)
+      DSQ=ZERO
+      BSUM=ZERO
+      DX=ZERO
+      DO 300 J=1,N
+      DSQ=DSQ+D(J)**2
+      SUM=ZERO
+      DO 280 K=1,NPT
+  280 SUM=SUM+W(K)*BMAT(K,J)
+      BSUM=BSUM+SUM*D(J)
+      JP=NPT+J
+      DO 290 I=1,N
+  290 SUM=SUM+BMAT(JP,I)*D(I)
+      VLAG(JP)=SUM
+      BSUM=BSUM+SUM*D(J)
+  300 DX=DX+D(J)*XOPT(J)
+      BETA=DX*DX+DSQ*(XOPTSQ+DX+DX+HALF*DSQ)+BETA-BSUM
+      VLAG(KOPT)=VLAG(KOPT)+ONE
+C
+C     If NTRITS is zero, the denominator may be increased by replacing
+C     the step D of ALTMOV by a Cauchy step. Then RESCUE may be called if
+C     rounding errors have damaged the chosen denominator.
+C
+      IF (NTRITS .EQ. 0) THEN
+          DENOM=VLAG(KNEW)**2+ALPHA*BETA
+          IF (DENOM .LT. CAUCHY .AND. CAUCHY .GT. ZERO) THEN
+              DO 310 I=1,N
+              XNEW(I)=XALT(I)
+  310         D(I)=XNEW(I)-XOPT(I)
+              CAUCHY=ZERO
+              GO TO 230
+          END IF
+          IF (DENOM .LE. HALF*VLAG(KNEW)**2) THEN
+              IF (NF .GT. NRESC) GOTO 190
+              IF (IPRINT .GT. 0) PRINT 320
+  320         FORMAT (/5X,'Return from BOBYQA because of much',
+     1          ' cancellation in a denominator.')
+              GOTO 720
+          END IF
+C
+C     Alternatively, if NTRITS is positive, then set KNEW to the index of
+C     the next interpolation point to be deleted to make room for a trust
+C     region step. Again RESCUE may be called if rounding errors have damaged
+C     the chosen denominator, which is the reason for attempting to select
+C     KNEW before calculating the next value of the objective function.
+C
+      ELSE
+          DELSQ=DELTA*DELTA
+          SCADEN=ZERO
+          BIGLSQ=ZERO
+          KNEW=0
+          DO 350 K=1,NPT
+          IF (K .EQ. KOPT) GOTO 350
+          HDIAG=ZERO
+          DO 330 JJ=1,NPTM
+  330     HDIAG=HDIAG+ZMAT(K,JJ)**2
+          DEN=BETA*HDIAG+VLAG(K)**2
+          DISTSQ=ZERO
+          DO 340 J=1,N
+  340     DISTSQ=DISTSQ+(XPT(K,J)-XOPT(J))**2
+          TEMP=DMAX1(ONE,(DISTSQ/DELSQ)**2)
+          IF (TEMP*DEN .GT. SCADEN) THEN
+              SCADEN=TEMP*DEN
+              KNEW=K
+              DENOM=DEN
+          END IF
+          BIGLSQ=DMAX1(BIGLSQ,TEMP*VLAG(K)**2)
+  350     CONTINUE
+          IF (SCADEN .LE. HALF*BIGLSQ) THEN
+              IF (NF .GT. NRESC) GOTO 190
+              IF (IPRINT .GT. 0) PRINT 320
+              GOTO 720
+          END IF
+      END IF
+C
+C     Put the variables for the next calculation of the objective function
+C       in XNEW, with any adjustments for the bounds.
+C
+C
+C     Calculate the value of the objective function at XBASE+XNEW, unless
+C       the limit on the number of calculations of F has been reached.
+C
+  360 DO 380 I=1,N
+      X(I)=DMIN1(DMAX1(XL(I),XBASE(I)+XNEW(I)),XU(I))
+      IF (XNEW(I) .EQ. SL(I)) X(I)=XL(I)
+      IF (XNEW(I) .EQ. SU(I)) X(I)=XU(I)
+  380 CONTINUE
+      IF (NF .GE. MAXFUN) THEN
+          IF (IPRINT .GT. 0) PRINT 390
+  390     FORMAT (/4X,'Return from BOBYQA because CALFUN has been',
+     1      ' called MAXFUN times.')
+          GOTO 720
+      END IF
+      NF=NF+1
+      CALL CALFUN (N,X,F)
+      IF (IPRINT .EQ. 3) THEN
+          PRINT 400, NF,F,(X(I),I=1,N)
+  400      FORMAT (/4X,'Function number',I6,'    F =',1PD18.10,
+     1       '    The corresponding X is:'/(2X,5D15.6))
+      END IF
+      IF (NTRITS .EQ. -1) THEN
+          FSAVE=F
+          GOTO 720
+      END IF
+C
+C     Use the quadratic model to predict the change in F due to the step D,
+C       and set DIFF to the error of this prediction.
+C
+      FOPT=FVAL(KOPT)
+      VQUAD=ZERO
+      IH=0
+      DO 410 J=1,N
+      VQUAD=VQUAD+D(J)*GOPT(J)
+      DO 410 I=1,J
+      IH=IH+1
+      TEMP=D(I)*D(J)
+      IF (I .EQ. J) TEMP=HALF*TEMP
+  410 VQUAD=VQUAD+HQ(IH)*TEMP
+      DO 420 K=1,NPT
+  420 VQUAD=VQUAD+HALF*PQ(K)*W(NPT+K)**2
+      DIFF=F-FOPT-VQUAD
+      DIFFC=DIFFB
+      DIFFB=DIFFA
+      DIFFA=DABS(DIFF)
+      IF (DNORM .GT. RHO) NFSAV=NF
+C
+C     Pick the next value of DELTA after a trust region step.
+C
+      IF (NTRITS .GT. 0) THEN
+          IF (VQUAD .GE. ZERO) THEN
+              IF (IPRINT .GT. 0) PRINT 430
+  430         FORMAT (/4X,'Return from BOBYQA because a trust',
+     1          ' region step has failed to reduce Q.')
+              GOTO 720
+          END IF
+          RATIO=(F-FOPT)/VQUAD
+          IF (RATIO .LE. TENTH) THEN
+              DELTA=DMIN1(HALF*DELTA,DNORM)
+          ELSE IF (RATIO .LE. 0.7D0) THEN
+              DELTA=DMAX1(HALF*DELTA,DNORM)
+          ELSE
+              DELTA=DMAX1(HALF*DELTA,DNORM+DNORM)
+          END IF
+          IF (DELTA .LE. 1.5D0*RHO) DELTA=RHO
+C
+C     Recalculate KNEW and DENOM if the new F is less than FOPT.
+C
+          IF (F .LT. FOPT) THEN
+              KSAV=KNEW
+              DENSAV=DENOM
+              DELSQ=DELTA*DELTA
+              SCADEN=ZERO
+              BIGLSQ=ZERO
+              KNEW=0
+              DO 460 K=1,NPT
+              HDIAG=ZERO
+              DO 440 JJ=1,NPTM
+  440         HDIAG=HDIAG+ZMAT(K,JJ)**2
+              DEN=BETA*HDIAG+VLAG(K)**2
+              DISTSQ=ZERO
+              DO 450 J=1,N
+  450         DISTSQ=DISTSQ+(XPT(K,J)-XNEW(J))**2
+              TEMP=DMAX1(ONE,(DISTSQ/DELSQ)**2)
+              IF (TEMP*DEN .GT. SCADEN) THEN
+                  SCADEN=TEMP*DEN
+                  KNEW=K
+                  DENOM=DEN
+              END IF
+  460         BIGLSQ=DMAX1(BIGLSQ,TEMP*VLAG(K)**2)
+              IF (SCADEN .LE. HALF*BIGLSQ) THEN
+                  KNEW=KSAV
+                  DENOM=DENSAV
+              END IF
+          END IF
+      END IF
+C
+C     Update BMAT and ZMAT, so that the KNEW-th interpolation point can be
+C     moved. Also update the second derivative terms of the model.
+C
+      CALL UPDATE (N,NPT,BMAT,ZMAT,NDIM,VLAG,BETA,DENOM,KNEW,W)
+      IH=0
+      PQOLD=PQ(KNEW)
+      PQ(KNEW)=ZERO
+      DO 470 I=1,N
+      TEMP=PQOLD*XPT(KNEW,I)
+      DO 470 J=1,I
+      IH=IH+1
+  470 HQ(IH)=HQ(IH)+TEMP*XPT(KNEW,J)
+      DO 480 JJ=1,NPTM
+      TEMP=DIFF*ZMAT(KNEW,JJ)
+      DO 480 K=1,NPT
+  480 PQ(K)=PQ(K)+TEMP*ZMAT(K,JJ)
+C
+C     Include the new interpolation point, and make the changes to GOPT at
+C     the old XOPT that are caused by the updating of the quadratic model.
+C
+      FVAL(KNEW)=F
+      DO 490 I=1,N
+      XPT(KNEW,I)=XNEW(I)
+  490 W(I)=BMAT(KNEW,I)
+      DO 520 K=1,NPT
+      SUMA=ZERO
+      DO 500 JJ=1,NPTM
+  500 SUMA=SUMA+ZMAT(KNEW,JJ)*ZMAT(K,JJ)
+      SUMB=ZERO
+      DO 510 J=1,N
+  510 SUMB=SUMB+XPT(K,J)*XOPT(J)
+      TEMP=SUMA*SUMB
+      DO 520 I=1,N
+  520 W(I)=W(I)+TEMP*XPT(K,I)
+      DO 530 I=1,N
+  530 GOPT(I)=GOPT(I)+DIFF*W(I)
+C
+C     Update XOPT, GOPT and KOPT if the new calculated F is less than FOPT.
+C
+      IF (F .LT. FOPT) THEN
+          KOPT=KNEW
+          XOPTSQ=ZERO
+          IH=0
+          DO 540 J=1,N
+          XOPT(J)=XNEW(J)
+          XOPTSQ=XOPTSQ+XOPT(J)**2
+          DO 540 I=1,J
+          IH=IH+1
+          IF (I .LT. J) GOPT(J)=GOPT(J)+HQ(IH)*D(I)
+  540     GOPT(I)=GOPT(I)+HQ(IH)*D(J)
+          DO 560 K=1,NPT
+          TEMP=ZERO
+          DO 550 J=1,N
+  550     TEMP=TEMP+XPT(K,J)*D(J)
+          TEMP=PQ(K)*TEMP
+          DO 560 I=1,N
+  560     GOPT(I)=GOPT(I)+TEMP*XPT(K,I)
+      END IF
+C
+C     Calculate the parameters of the least Frobenius norm interpolant to
+C     the current data, the gradient of this interpolant at XOPT being put
+C     into VLAG(NPT+I), I=1,2,...,N.
+C
+      IF (NTRITS .GT. 0) THEN
+          DO 570 K=1,NPT
+          VLAG(K)=FVAL(K)-FVAL(KOPT)
+  570     W(K)=ZERO
+          DO 590 J=1,NPTM
+          SUM=ZERO
+          DO 580 K=1,NPT
+  580     SUM=SUM+ZMAT(K,J)*VLAG(K)
+          DO 590 K=1,NPT
+  590     W(K)=W(K)+SUM*ZMAT(K,J)
+          DO 610 K=1,NPT
+          SUM=ZERO
+          DO 600 J=1,N
+  600     SUM=SUM+XPT(K,J)*XOPT(J)
+          W(K+NPT)=W(K)
+  610     W(K)=SUM*W(K)
+          GQSQ=ZERO
+          GISQ=ZERO
+          DO 630 I=1,N
+          SUM=ZERO
+          DO 620 K=1,NPT
+  620     SUM=SUM+BMAT(K,I)*VLAG(K)+XPT(K,I)*W(K)
+          IF (XOPT(I) .EQ. SL(I)) THEN
+              GQSQ=GQSQ+DMIN1(ZERO,GOPT(I))**2
+              GISQ=GISQ+DMIN1(ZERO,SUM)**2
+          ELSE IF (XOPT(I) .EQ. SU(I)) THEN
+              GQSQ=GQSQ+DMAX1(ZERO,GOPT(I))**2
+              GISQ=GISQ+DMAX1(ZERO,SUM)**2
+          ELSE
+              GQSQ=GQSQ+GOPT(I)**2
+              GISQ=GISQ+SUM*SUM
+          END IF
+  630     VLAG(NPT+I)=SUM
+C
+C     Test whether to replace the new quadratic model by the least Frobenius
+C     norm interpolant, making the replacement if the test is satisfied.
+C
+          ITEST=ITEST+1
+          IF (GQSQ .LT. TEN*GISQ) ITEST=0
+          IF (ITEST .GE. 3) THEN
+              DO 640 I=1,MAX0(NPT,NH)
+              IF (I .LE. N) GOPT(I)=VLAG(NPT+I)
+              IF (I .LE. NPT) PQ(I)=W(NPT+I)
+              IF (I .LE. NH) HQ(I)=ZERO
+              ITEST=0
+  640         CONTINUE
+          END IF
+      END IF
+C
+C     If a trust region step has provided a sufficient decrease in F, then
+C     branch for another trust region calculation. The case NTRITS=0 occurs
+C     when the new interpolation point was reached by an alternative step.
+C
+      IF (NTRITS .EQ. 0) GOTO 60
+      IF (F .LE. FOPT+TENTH*VQUAD) GOTO 60
+C
+C     Alternatively, find out if the interpolation points are close enough
+C       to the best point so far.
+C
+      DISTSQ=DMAX1((TWO*DELTA)**2,(TEN*RHO)**2)
+  650 KNEW=0
+      DO 670 K=1,NPT
+      SUM=ZERO
+      DO 660 J=1,N
+  660 SUM=SUM+(XPT(K,J)-XOPT(J))**2
+      IF (SUM .GT. DISTSQ) THEN
+          KNEW=K
+          DISTSQ=SUM
+      END IF
+  670 CONTINUE
+C
+C     If KNEW is positive, then ALTMOV finds alternative new positions for
+C     the KNEW-th interpolation point within distance ADELT of XOPT. It is
+C     reached via label 90. Otherwise, there is a branch to label 60 for
+C     another trust region iteration, unless the calculations with the
+C     current RHO are complete.
+C
+      IF (KNEW .GT. 0) THEN
+          DIST=DSQRT(DISTSQ)
+          IF (NTRITS .EQ. -1) THEN
+              DELTA=DMIN1(TENTH*DELTA,HALF*DIST)
+              IF (DELTA .LE. 1.5D0*RHO) DELTA=RHO
+          END IF
+          NTRITS=0
+          ADELT=DMAX1(DMIN1(TENTH*DIST,DELTA),RHO)
+          DSQ=ADELT*ADELT
+          GOTO 90
+      END IF
+      IF (NTRITS .EQ. -1) GOTO 680
+      IF (RATIO .GT. ZERO) GOTO 60
+      IF (DMAX1(DELTA,DNORM) .GT. RHO) GOTO 60
+C
+C     The calculations with the current value of RHO are complete. Pick the
+C       next values of RHO and DELTA.
+C
+  680 IF (RHO .GT. RHOEND) THEN
+          DELTA=HALF*RHO
+          RATIO=RHO/RHOEND
+          IF (RATIO .LE. 16.0D0) THEN
+              RHO=RHOEND
+          ELSE IF (RATIO .LE. 250.0D0) THEN
+              RHO=DSQRT(RATIO)*RHOEND
+          ELSE
+              RHO=TENTH*RHO
+          END IF
+          DELTA=DMAX1(DELTA,RHO)
+          IF (IPRINT .GE. 2) THEN
+              IF (IPRINT .GE. 3) PRINT 690
+  690         FORMAT (5X)
+              PRINT 700, RHO,NF
+  700         FORMAT (/4X,'New RHO =',1PD11.4,5X,'Number of',
+     1          ' function values =',I6)
+              PRINT 710, FVAL(KOPT),(XBASE(I)+XOPT(I),I=1,N)
+  710         FORMAT (4X,'Least value of F =',1PD23.15,9X,
+     1          'The corresponding X is:'/(2X,5D15.6))
+          END IF
+          NTRITS=0
+          NFSAV=NF
+          GOTO 60
+      END IF
+C
+C     Return from the calculation, after another Newton-Raphson step, if
+C       it is too short to have been tried before.
+C
+      IF (NTRITS .EQ. -1) GOTO 360
+  720 IF (FVAL(KOPT) .LE. FSAVE) THEN
+          DO 730 I=1,N
+          X(I)=DMIN1(DMAX1(XL(I),XBASE(I)+XOPT(I)),XU(I))
+          IF (XOPT(I) .EQ. SL(I)) X(I)=XL(I)
+          IF (XOPT(I) .EQ. SU(I)) X(I)=XU(I)
+  730     CONTINUE
+          F=FVAL(KOPT)
+      END IF
+      IF (IPRINT .GE. 1) THEN
+          PRINT 740, NF
+  740     FORMAT (/4X,'At the return from BOBYQA',5X,
+     1      'Number of function values =',I6)
+          PRINT 710, F,(X(I),I=1,N)
+      END IF
+      RETURN
+      END SUBROUTINE BOBYQB
+	  
+	  SUBROUTINE PRELIM (N,NPT,X,XL,XU,RHOBEG,IPRINT,MAXFUN,XBASE,
+     1  XPT,FVAL,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,KOPT)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION X(*),XL(*),XU(*),XBASE(*),XPT(NPT,*),FVAL(*),GOPT(*),
+     1  HQ(*),PQ(*),BMAT(NDIM,*),ZMAT(NPT,*),SL(*),SU(*)
+C
+C     The arguments N, NPT, X, XL, XU, RHOBEG, IPRINT and MAXFUN are the
+C       same as the corresponding arguments in SUBROUTINE BOBYQA.
+C     The arguments XBASE, XPT, FVAL, HQ, PQ, BMAT, ZMAT, NDIM, SL and SU
+C       are the same as the corresponding arguments in BOBYQB, the elements
+C       of SL and SU being set in BOBYQA.
+C     GOPT is usually the gradient of the quadratic model at XOPT+XBASE, but
+C       it is set by PRELIM to the gradient of the quadratic model at XBASE.
+C       If XOPT is nonzero, BOBYQB will change it to its usual value later.
+C     NF is maintaned as the number of calls of CALFUN so far.
+C     KOPT will be such that the least calculated value of F so far is at
+C       the point XPT(KOPT,.)+XBASE in the space of the variables.
+C
+C     SUBROUTINE PRELIM sets the elements of XBASE, XPT, FVAL, GOPT, HQ, PQ,
+C     BMAT and ZMAT for the first iteration, and it maintains the values of
+C     NF and KOPT. The vector X is also changed by PRELIM.
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      TWO=2.0D0
+      ZERO=0.0D0
+      RHOSQ=RHOBEG*RHOBEG
+      RECIP=ONE/RHOSQ
+      NP=N+1
+C
+C     Set XBASE to the initial vector of variables, and set the initial
+C     elements of XPT, BMAT, HQ, PQ and ZMAT to zero.
+C
+      DO 20 J=1,N
+      XBASE(J)=X(J)
+      DO 10 K=1,NPT
+   10 XPT(K,J)=ZERO
+      DO 20 I=1,NDIM
+   20 BMAT(I,J)=ZERO
+      DO 30 IH=1,(N*NP)/2
+   30 HQ(IH)=ZERO
+      DO 40 K=1,NPT
+      PQ(K)=ZERO
+      DO 40 J=1,NPT-NP
+   40 ZMAT(K,J)=ZERO
+C
+C     Begin the initialization procedure. NF becomes one more than the number
+C     of function values so far. The coordinates of the displacement of the
+C     next initial interpolation point from XBASE are set in XPT(NF+1,.).
+C
+      NF=0
+   50 NFM=NF
+      NFX=NF-N
+      NF=NF+1
+      IF (NFM .LE. 2*N) THEN
+          IF (NFM .GE. 1 .AND. NFM .LE. N) THEN
+              STEPA=RHOBEG
+              IF (SU(NFM) .EQ. ZERO) STEPA=-STEPA
+              XPT(NF,NFM)=STEPA
+          ELSE IF (NFM .GT. N) THEN
+              STEPA=XPT(NF-N,NFX)
+              STEPB=-RHOBEG
+              IF (SL(NFX) .EQ. ZERO) STEPB=DMIN1(TWO*RHOBEG,SU(NFX))
+              IF (SU(NFX) .EQ. ZERO) STEPB=DMAX1(-TWO*RHOBEG,SL(NFX))
+              XPT(NF,NFX)=STEPB
+          END IF
+      ELSE
+          ITEMP=(NFM-NP)/N
+          JPT=NFM-ITEMP*N-N
+          IPT=JPT+ITEMP
+          IF (IPT .GT. N) THEN
+              ITEMP=JPT
+              JPT=IPT-N
+              IPT=ITEMP
+          END IF
+          XPT(NF,IPT)=XPT(IPT+1,IPT)
+          XPT(NF,JPT)=XPT(JPT+1,JPT)
+      END IF
+C
+C     Calculate the next value of F. The least function value so far and
+C     its index are required.
+C
+      DO 60 J=1,N
+      X(J)=DMIN1(DMAX1(XL(J),XBASE(J)+XPT(NF,J)),XU(J))
+      IF (XPT(NF,J) .EQ. SL(J)) X(J)=XL(J)
+      IF (XPT(NF,J) .EQ. SU(J)) X(J)=XU(J)
+   60 CONTINUE
+      CALL CALFUN (N,X,F)
+      IF (IPRINT .EQ. 3) THEN
+          PRINT 70, NF,F,(X(I),I=1,N)
+   70      FORMAT (/4X,'Function number',I6,'    F =',1PD18.10,
+     1       '    The corresponding X is:'/(2X,5D15.6))
+      END IF
+      FVAL(NF)=F
+      IF (NF .EQ. 1) THEN
+          FBEG=F
+          KOPT=1
+      ELSE IF (F .LT. FVAL(KOPT)) THEN
+          KOPT=NF
+      END IF
+C
+C     Set the nonzero initial elements of BMAT and the quadratic model in the
+C     cases when NF is at most 2*N+1. If NF exceeds N+1, then the positions
+C     of the NF-th and (NF-N)-th interpolation points may be switched, in
+C     order that the function value at the first of them contributes to the
+C     off-diagonal second derivative terms of the initial quadratic model.
+C
+      IF (NF .LE. 2*N+1) THEN
+          IF (NF .GE. 2 .AND. NF .LE. N+1) THEN
+              GOPT(NFM)=(F-FBEG)/STEPA
+              IF (NPT .LT. NF+N) THEN
+                  BMAT(1,NFM)=-ONE/STEPA
+                  BMAT(NF,NFM)=ONE/STEPA
+                  BMAT(NPT+NFM,NFM)=-HALF*RHOSQ
+              END IF
+          ELSE IF (NF .GE. N+2) THEN
+              IH=(NFX*(NFX+1))/2
+              TEMP=(F-FBEG)/STEPB
+              DIFF=STEPB-STEPA
+              HQ(IH)=TWO*(TEMP-GOPT(NFX))/DIFF
+              GOPT(NFX)=(GOPT(NFX)*STEPB-TEMP*STEPA)/DIFF
+              IF (STEPA*STEPB .LT. ZERO) THEN
+                  IF (F .LT. FVAL(NF-N)) THEN
+                      FVAL(NF)=FVAL(NF-N)
+                      FVAL(NF-N)=F
+                      IF (KOPT .EQ. NF) KOPT=NF-N
+                      XPT(NF-N,NFX)=STEPB
+                      XPT(NF,NFX)=STEPA
+                  END IF
+              END IF
+              BMAT(1,NFX)=-(STEPA+STEPB)/(STEPA*STEPB)
+              BMAT(NF,NFX)=-HALF/XPT(NF-N,NFX)
+              BMAT(NF-N,NFX)=-BMAT(1,NFX)-BMAT(NF,NFX)
+              ZMAT(1,NFX)=DSQRT(TWO)/(STEPA*STEPB)
+              ZMAT(NF,NFX)=DSQRT(HALF)/RHOSQ
+              ZMAT(NF-N,NFX)=-ZMAT(1,NFX)-ZMAT(NF,NFX)
+          END IF
+C
+C     Set the off-diagonal second derivatives of the Lagrange functions and
+C     the initial quadratic model.
+C
+      ELSE
+          IH=(IPT*(IPT-1))/2+JPT
+          ZMAT(1,NFX)=RECIP
+          ZMAT(NF,NFX)=RECIP
+          ZMAT(IPT+1,NFX)=-RECIP
+          ZMAT(JPT+1,NFX)=-RECIP
+          TEMP=XPT(NF,IPT)*XPT(NF,JPT)
+          HQ(IH)=(FBEG-FVAL(IPT+1)-FVAL(JPT+1)+F)/TEMP
+      END IF
+      IF (NF .LT. NPT .AND. NF .LT. MAXFUN) GOTO 50
+      RETURN
+      END SUBROUTINE PRELIM
+	  
+	  SUBROUTINE RESCUE (N,NPT,XL,XU,IPRINT,MAXFUN,XBASE,XPT,
+     1  FVAL,XOPT,GOPT,HQ,PQ,BMAT,ZMAT,NDIM,SL,SU,NF,DELTA,
+     2  KOPT,VLAG,PTSAUX,PTSID,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION XL(*),XU(*),XBASE(*),XPT(NPT,*),FVAL(*),XOPT(*),
+     1  GOPT(*),HQ(*),PQ(*),BMAT(NDIM,*),ZMAT(NPT,*),SL(*),SU(*),
+     2  VLAG(*),PTSAUX(2,*),PTSID(*),W(*)
+C
+C     The arguments N, NPT, XL, XU, IPRINT, MAXFUN, XBASE, XPT, FVAL, XOPT,
+C       GOPT, HQ, PQ, BMAT, ZMAT, NDIM, SL and SU have the same meanings as
+C       the corresponding arguments of BOBYQB on the entry to RESCUE.
+C     NF is maintained as the number of calls of CALFUN so far, except that
+C       NF is set to -1 if the value of MAXFUN prevents further progress.
+C     KOPT is maintained so that FVAL(KOPT) is the least calculated function
+C       value. Its correct value must be given on entry. It is updated if a
+C       new least function value is found, but the corresponding changes to
+C       XOPT and GOPT have to be made later by the calling program.
+C     DELTA is the current trust region radius.
+C     VLAG is a working space vector that will be used for the values of the
+C       provisional Lagrange functions at each of the interpolation points.
+C       They are part of a product that requires VLAG to be of length NDIM.
+C     PTSAUX is also a working space array. For J=1,2,...,N, PTSAUX(1,J) and
+C       PTSAUX(2,J) specify the two positions of provisional interpolation
+C       points when a nonzero step is taken along e_J (the J-th coordinate
+C       direction) through XBASE+XOPT, as specified below. Usually these
+C       steps have length DELTA, but other lengths are chosen if necessary
+C       in order to satisfy the given bounds on the variables.
+C     PTSID is also a working space array. It has NPT components that denote
+C       provisional new positions of the original interpolation points, in
+C       case changes are needed to restore the linear independence of the
+C       interpolation conditions. The K-th point is a candidate for change
+C       if and only if PTSID(K) is nonzero. In this case let p and q be the
+C       integer parts of PTSID(K) and (PTSID(K)-p) multiplied by N+1. If p
+C       and q are both positive, the step from XBASE+XOPT to the new K-th
+C       interpolation point is PTSAUX(1,p)*e_p + PTSAUX(1,q)*e_q. Otherwise
+C       the step is PTSAUX(1,p)*e_p or PTSAUX(2,q)*e_q in the cases q=0 or
+C       p=0, respectively.
+C     The first NDIM+NPT elements of the array W are used for working space. 
+C     The final elements of BMAT and ZMAT are set in a well-conditioned way
+C       to the values that are appropriate for the new interpolation points.
+C     The elements of GOPT, HQ and PQ are also revised to the values that are
+C       appropriate to the final quadratic model.
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      ZERO=0.0D0
+      NP=N+1
+      SFRAC=HALF/DFLOAT(NP)
+      NPTM=NPT-NP
+C
+C     Shift the interpolation points so that XOPT becomes the origin, and set
+C     the elements of ZMAT to zero. The value of SUMPQ is required in the
+C     updating of HQ below. The squares of the distances from XOPT to the
+C     other interpolation points are set at the end of W. Increments of WINC
+C     may be added later to these squares to balance the consideration of
+C     the choice of point that is going to become current.
+C
+      SUMPQ=ZERO
+      WINC=ZERO
+      DO 20 K=1,NPT
+      DISTSQ=ZERO
+      DO 10 J=1,N
+      XPT(K,J)=XPT(K,J)-XOPT(J)
+   10 DISTSQ=DISTSQ+XPT(K,J)**2
+      SUMPQ=SUMPQ+PQ(K)
+      W(NDIM+K)=DISTSQ
+      WINC=DMAX1(WINC,DISTSQ)
+      DO 20 J=1,NPTM
+   20 ZMAT(K,J)=ZERO
+C
+C     Update HQ so that HQ and PQ define the second derivatives of the model
+C     after XBASE has been shifted to the trust region centre.
+C
+      IH=0
+      DO 40 J=1,N
+      W(J)=HALF*SUMPQ*XOPT(J)
+      DO 30 K=1,NPT
+   30 W(J)=W(J)+PQ(K)*XPT(K,J)
+      DO 40 I=1,J
+      IH=IH+1
+   40 HQ(IH)=HQ(IH)+W(I)*XOPT(J)+W(J)*XOPT(I)
+C
+C     Shift XBASE, SL, SU and XOPT. Set the elements of BMAT to zero, and
+C     also set the elements of PTSAUX.
+C
+      DO 50 J=1,N
+      XBASE(J)=XBASE(J)+XOPT(J)
+      SL(J)=SL(J)-XOPT(J)
+      SU(J)=SU(J)-XOPT(J)
+      XOPT(J)=ZERO
+      PTSAUX(1,J)=DMIN1(DELTA,SU(J))
+      PTSAUX(2,J)=DMAX1(-DELTA,SL(J))
+      IF (PTSAUX(1,J)+PTSAUX(2,J) .LT. ZERO) THEN
+          TEMP=PTSAUX(1,J)
+          PTSAUX(1,J)=PTSAUX(2,J)
+          PTSAUX(2,J)=TEMP
+      END IF
+      IF (DABS(PTSAUX(2,J)) .LT. HALF*DABS(PTSAUX(1,J))) THEN
+          PTSAUX(2,J)=HALF*PTSAUX(1,J)
+      END IF
+      DO 50 I=1,NDIM
+   50 BMAT(I,J)=ZERO
+      FBASE=FVAL(KOPT)
+C
+C     Set the identifiers of the artificial interpolation points that are
+C     along a coordinate direction from XOPT, and set the corresponding
+C     nonzero elements of BMAT and ZMAT.
+C
+      PTSID(1)=SFRAC
+      DO 60 J=1,N
+      JP=J+1
+      JPN=JP+N
+      PTSID(JP)=DFLOAT(J)+SFRAC
+      IF (JPN .LE. NPT) THEN
+          PTSID(JPN)=DFLOAT(J)/DFLOAT(NP)+SFRAC
+          TEMP=ONE/(PTSAUX(1,J)-PTSAUX(2,J))
+          BMAT(JP,J)=-TEMP+ONE/PTSAUX(1,J)
+          BMAT(JPN,J)=TEMP+ONE/PTSAUX(2,J)
+          BMAT(1,J)=-BMAT(JP,J)-BMAT(JPN,J)
+          ZMAT(1,J)=DSQRT(2.0D0)/DABS(PTSAUX(1,J)*PTSAUX(2,J))
+          ZMAT(JP,J)=ZMAT(1,J)*PTSAUX(2,J)*TEMP
+          ZMAT(JPN,J)=-ZMAT(1,J)*PTSAUX(1,J)*TEMP
+      ELSE
+          BMAT(1,J)=-ONE/PTSAUX(1,J)
+          BMAT(JP,J)=ONE/PTSAUX(1,J)
+          BMAT(J+NPT,J)=-HALF*PTSAUX(1,J)**2
+      END IF
+   60 CONTINUE
+C
+C     Set any remaining identifiers with their nonzero elements of ZMAT.
+C
+      IF (NPT .GE. N+NP) THEN
+          DO 70 K=2*NP,NPT
+          IW=(DFLOAT(K-NP)-HALF)/DFLOAT(N)
+          IP=K-NP-IW*N
+          IQ=IP+IW
+          IF (IQ .GT. N) IQ=IQ-N
+          PTSID(K)=DFLOAT(IP)+DFLOAT(IQ)/DFLOAT(NP)+SFRAC
+          TEMP=ONE/(PTSAUX(1,IP)*PTSAUX(1,IQ))
+          ZMAT(1,K-NP)=TEMP
+          ZMAT(IP+1,K-NP)=-TEMP
+          ZMAT(IQ+1,K-NP)=-TEMP
+   70     ZMAT(K,K-NP)=TEMP
+      END IF
+      NREM=NPT
+      KOLD=1
+      KNEW=KOPT
+C
+C     Reorder the provisional points in the way that exchanges PTSID(KOLD)
+C     with PTSID(KNEW).
+C
+   80 DO 90 J=1,N
+      TEMP=BMAT(KOLD,J)
+      BMAT(KOLD,J)=BMAT(KNEW,J)
+   90 BMAT(KNEW,J)=TEMP
+      DO 100 J=1,NPTM
+      TEMP=ZMAT(KOLD,J)
+      ZMAT(KOLD,J)=ZMAT(KNEW,J)
+  100 ZMAT(KNEW,J)=TEMP
+      PTSID(KOLD)=PTSID(KNEW)
+      PTSID(KNEW)=ZERO
+      W(NDIM+KNEW)=ZERO
+      NREM=NREM-1
+      IF (KNEW .NE. KOPT) THEN
+          TEMP=VLAG(KOLD)
+          VLAG(KOLD)=VLAG(KNEW)
+          VLAG(KNEW)=TEMP
+C
+C     Update the BMAT and ZMAT matrices so that the status of the KNEW-th
+C     interpolation point can be changed from provisional to original. The
+C     branch to label 350 occurs if all the original points are reinstated.
+C     The nonnegative values of W(NDIM+K) are required in the search below.
+C
+          CALL UPDATE (N,NPT,BMAT,ZMAT,NDIM,VLAG,BETA,DENOM,KNEW,W)
+          IF (NREM .EQ. 0) GOTO 350
+          DO 110 K=1,NPT
+  110     W(NDIM+K)=DABS(W(NDIM+K))
+      END IF
+C
+C     Pick the index KNEW of an original interpolation point that has not
+C     yet replaced one of the provisional interpolation points, giving
+C     attention to the closeness to XOPT and to previous tries with KNEW.
+C
+  120 DSQMIN=ZERO
+      DO 130 K=1,NPT
+      IF (W(NDIM+K) .GT. ZERO) THEN
+          IF (DSQMIN .EQ. ZERO .OR. W(NDIM+K) .LT. DSQMIN) THEN
+              KNEW=K
+              DSQMIN=W(NDIM+K)
+          END IF
+      END IF
+  130 CONTINUE
+      IF (DSQMIN .EQ. ZERO) GOTO 260
+C
+C     Form the W-vector of the chosen original interpolation point.
+C
+      DO 140 J=1,N
+  140 W(NPT+J)=XPT(KNEW,J)
+      DO 160 K=1,NPT
+      SUM=ZERO
+      IF (K .EQ. KOPT) THEN
+          CONTINUE
+      ELSE IF (PTSID(K) .EQ. ZERO) THEN
+          DO 150 J=1,N
+  150     SUM=SUM+W(NPT+J)*XPT(K,J)
+      ELSE
+          IP=PTSID(K)
+          IF (IP .GT. 0) SUM=W(NPT+IP)*PTSAUX(1,IP)
+          IQ=DFLOAT(NP)*PTSID(K)-DFLOAT(IP*NP)
+          IF (IQ .GT. 0) THEN
+              IW=1
+              IF (IP .EQ. 0) IW=2
+              SUM=SUM+W(NPT+IQ)*PTSAUX(IW,IQ)
+          END IF
+      END IF
+  160 W(K)=HALF*SUM*SUM
+C
+C     Calculate VLAG and BETA for the required updating of the H matrix if
+C     XPT(KNEW,.) is reinstated in the set of interpolation points.
+C
+      DO 180 K=1,NPT
+      SUM=ZERO
+      DO 170 J=1,N
+  170 SUM=SUM+BMAT(K,J)*W(NPT+J)
+  180 VLAG(K)=SUM
+      BETA=ZERO
+      DO 200 J=1,NPTM
+      SUM=ZERO
+      DO 190 K=1,NPT
+  190 SUM=SUM+ZMAT(K,J)*W(K)
+      BETA=BETA-SUM*SUM
+      DO 200 K=1,NPT
+  200 VLAG(K)=VLAG(K)+SUM*ZMAT(K,J)
+      BSUM=ZERO
+      DISTSQ=ZERO
+      DO 230 J=1,N
+      SUM=ZERO
+      DO 210 K=1,NPT
+  210 SUM=SUM+BMAT(K,J)*W(K)
+      JP=J+NPT
+      BSUM=BSUM+SUM*W(JP)
+      DO 220 IP=NPT+1,NDIM
+  220 SUM=SUM+BMAT(IP,J)*W(IP)
+      BSUM=BSUM+SUM*W(JP)
+      VLAG(JP)=SUM
+  230 DISTSQ=DISTSQ+XPT(KNEW,J)**2
+      BETA=HALF*DISTSQ*DISTSQ+BETA-BSUM
+      VLAG(KOPT)=VLAG(KOPT)+ONE
+C
+C     KOLD is set to the index of the provisional interpolation point that is
+C     going to be deleted to make way for the KNEW-th original interpolation
+C     point. The choice of KOLD is governed by the avoidance of a small value
+C     of the denominator in the updating calculation of UPDATE.
+C
+      DENOM=ZERO
+      VLMXSQ=ZERO
+      DO 250 K=1,NPT
+      IF (PTSID(K) .NE. ZERO) THEN
+          HDIAG=ZERO
+          DO 240 J=1,NPTM
+  240     HDIAG=HDIAG+ZMAT(K,J)**2
+          DEN=BETA*HDIAG+VLAG(K)**2
+          IF (DEN .GT. DENOM) THEN
+              KOLD=K
+              DENOM=DEN
+          END IF
+      END IF
+  250 VLMXSQ=DMAX1(VLMXSQ,VLAG(K)**2)
+      IF (DENOM .LE. 1.0D-2*VLMXSQ) THEN
+          W(NDIM+KNEW)=-W(NDIM+KNEW)-WINC
+          GOTO 120
+      END IF
+      GOTO 80
+C
+C     When label 260 is reached, all the final positions of the interpolation
+C     points have been chosen although any changes have not been included yet
+C     in XPT. Also the final BMAT and ZMAT matrices are complete, but, apart
+C     from the shift of XBASE, the updating of the quadratic model remains to
+C     be done. The following cycle through the new interpolation points begins
+C     by putting the new point in XPT(KPT,.) and by setting PQ(KPT) to zero,
+C     except that a RETURN occurs if MAXFUN prohibits another value of F.
+C
+  260 DO 340 KPT=1,NPT
+      IF (PTSID(KPT) .EQ. ZERO) GOTO 340
+      IF (NF .GE. MAXFUN) THEN
+          NF=-1
+          GOTO 350
+      END IF
+      IH=0
+      DO 270 J=1,N
+      W(J)=XPT(KPT,J)
+      XPT(KPT,J)=ZERO
+      TEMP=PQ(KPT)*W(J)
+      DO 270 I=1,J
+      IH=IH+1
+  270 HQ(IH)=HQ(IH)+TEMP*W(I)
+      PQ(KPT)=ZERO
+      IP=PTSID(KPT)
+      IQ=DFLOAT(NP)*PTSID(KPT)-DFLOAT(IP*NP)
+      IF (IP .GT. 0) THEN
+          XP=PTSAUX(1,IP)
+          XPT(KPT,IP)=XP
+      END IF
+      IF (IQ .GT. 0) THEN
+          XQ=PTSAUX(1,IQ)
+          IF (IP .EQ. 0) XQ=PTSAUX(2,IQ)
+          XPT(KPT,IQ)=XQ
+      END IF
+C
+C     Set VQUAD to the value of the current model at the new point.
+C
+      VQUAD=FBASE
+      IF (IP .GT. 0) THEN
+          IHP=(IP+IP*IP)/2
+          VQUAD=VQUAD+XP*(GOPT(IP)+HALF*XP*HQ(IHP))
+      END IF
+      IF (IQ .GT. 0) THEN
+          IHQ=(IQ+IQ*IQ)/2
+          VQUAD=VQUAD+XQ*(GOPT(IQ)+HALF*XQ*HQ(IHQ))
+          IF (IP .GT. 0) THEN
+              IW=MAX0(IHP,IHQ)-IABS(IP-IQ)
+              VQUAD=VQUAD+XP*XQ*HQ(IW)
+          END IF
+      END IF
+      DO 280 K=1,NPT
+      TEMP=ZERO
+      IF (IP .GT. 0) TEMP=TEMP+XP*XPT(K,IP)
+      IF (IQ .GT. 0) TEMP=TEMP+XQ*XPT(K,IQ)
+  280 VQUAD=VQUAD+HALF*PQ(K)*TEMP*TEMP
+C
+C     Calculate F at the new interpolation point, and set DIFF to the factor
+C     that is going to multiply the KPT-th Lagrange function when the model
+C     is updated to provide interpolation to the new function value.
+C
+      DO 290 I=1,N
+      W(I)=DMIN1(DMAX1(XL(I),XBASE(I)+XPT(KPT,I)),XU(I))
+      IF (XPT(KPT,I) .EQ. SL(I)) W(I)=XL(I)
+      IF (XPT(KPT,I) .EQ. SU(I)) W(I)=XU(I)
+  290 CONTINUE
+      NF=NF+1
+      CALL CALFUN (N,W,F)
+      IF (IPRINT .EQ. 3) THEN
+          PRINT 300, NF,F,(W(I),I=1,N)
+  300     FORMAT (/4X,'Function number',I6,'    F =',1PD18.10,
+     1      '    The corresponding X is:'/(2X,5D15.6))
+      END IF
+      FVAL(KPT)=F
+      IF (F .LT. FVAL(KOPT)) KOPT=KPT
+      DIFF=F-VQUAD
+C
+C     Update the quadratic model. The RETURN from the subroutine occurs when
+C     all the new interpolation points are included in the model.
+C
+      DO 310 I=1,N
+  310 GOPT(I)=GOPT(I)+DIFF*BMAT(KPT,I)
+      DO 330 K=1,NPT
+      SUM=ZERO
+      DO 320 J=1,NPTM
+  320 SUM=SUM+ZMAT(K,J)*ZMAT(KPT,J)
+      TEMP=DIFF*SUM
+      IF (PTSID(K) .EQ. ZERO) THEN
+          PQ(K)=PQ(K)+TEMP
+      ELSE
+          IP=PTSID(K)
+          IQ=DFLOAT(NP)*PTSID(K)-DFLOAT(IP*NP)
+          IHQ=(IQ*IQ+IQ)/2
+          IF (IP .EQ. 0) THEN
+              HQ(IHQ)=HQ(IHQ)+TEMP*PTSAUX(2,IQ)**2
+          ELSE
+              IHP=(IP*IP+IP)/2
+              HQ(IHP)=HQ(IHP)+TEMP*PTSAUX(1,IP)**2
+              IF (IQ .GT. 0) THEN
+                  HQ(IHQ)=HQ(IHQ)+TEMP*PTSAUX(1,IQ)**2
+                  IW=MAX0(IHP,IHQ)-IABS(IQ-IP)
+                  HQ(IW)=HQ(IW)+TEMP*PTSAUX(1,IP)*PTSAUX(1,IQ)
+              END IF
+          END IF
+      END IF
+  330 CONTINUE
+      PTSID(KPT)=ZERO
+  340 CONTINUE
+  350 RETURN
+      END SUBROUTINE RESCUE
+	  
+	  SUBROUTINE TRSBOX (N,NPT,XPT,XOPT,GOPT,HQ,PQ,SL,SU,DELTA,
+     1  XNEW,D,GNEW,XBDI,S,HS,HRED,DSQ,CRVMIN)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION XPT(NPT,*),XOPT(*),GOPT(*),HQ(*),PQ(*),SL(*),SU(*),
+     1  XNEW(*),D(*),GNEW(*),XBDI(*),S(*),HS(*),HRED(*)
+C
+C     The arguments N, NPT, XPT, XOPT, GOPT, HQ, PQ, SL and SU have the same
+C       meanings as the corresponding arguments of BOBYQB.
+C     DELTA is the trust region radius for the present calculation, which
+C       seeks a small value of the quadratic model within distance DELTA of
+C       XOPT subject to the bounds on the variables.
+C     XNEW will be set to a new vector of variables that is approximately
+C       the one that minimizes the quadratic model within the trust region
+C       subject to the SL and SU constraints on the variables. It satisfies
+C       as equations the bounds that become active during the calculation.
+C     D is the calculated trial step from XOPT, generated iteratively from an
+C       initial value of zero. Thus XNEW is XOPT+D after the final iteration.
+C     GNEW holds the gradient of the quadratic model at XOPT+D. It is updated
+C       when D is updated.
+C     XBDI is a working space vector. For I=1,2,...,N, the element XBDI(I) is
+C       set to -1.0, 0.0, or 1.0, the value being nonzero if and only if the
+C       I-th variable has become fixed at a bound, the bound being SL(I) or
+C       SU(I) in the case XBDI(I)=-1.0 or XBDI(I)=1.0, respectively. This
+C       information is accumulated during the construction of XNEW.
+C     The arrays S, HS and HRED are also used for working space. They hold the
+C       current search direction, and the changes in the gradient of Q along S
+C       and the reduced D, respectively, where the reduced D is the same as D,
+C       except that the components of the fixed variables are zero.
+C     DSQ will be set to the square of the length of XNEW-XOPT.
+C     CRVMIN is set to zero if D reaches the trust region boundary. Otherwise
+C       it is set to the least curvature of H that occurs in the conjugate
+C       gradient searches that are not restricted by any constraints. The
+C       value CRVMIN=-1.0D0 is set, however, if all of these searches are
+C       constrained.
+C
+C     A version of the truncated conjugate gradient is applied. If a line
+C     search is restricted by a constraint, then the procedure is restarted,
+C     the values of the variables that are at their bounds being fixed. If
+C     the trust region boundary is reached, then further changes may be made
+C     to D, each one being in the two dimensional space that is spanned
+C     by the current D and the gradient of Q at XOPT+D, staying on the trust
+C     region boundary. Termination occurs when the reduction in Q seems to
+C     be close to the greatest reduction that can be achieved.
+C
+C     Set some constants.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      ONEMIN=-1.0D0
+      ZERO=0.0D0
+C
+C     The sign of GOPT(I) gives the sign of the change to the I-th variable
+C     that will reduce Q from its value at XOPT. Thus XBDI(I) shows whether
+C     or not to fix the I-th variable at one of its bounds initially, with
+C     NACT being set to the number of fixed variables. D and GNEW are also
+C     set for the first iteration. DELSQ is the upper bound on the sum of
+C     squares of the free variables. QRED is the reduction in Q so far.
+C
+      ITERC=0
+      NACT=0
+      SQSTP=ZERO
+      DO 10 I=1,N
+      XBDI(I)=ZERO
+      IF (XOPT(I) .LE. SL(I)) THEN
+          IF (GOPT(I) .GE. ZERO) XBDI(I)=ONEMIN
+      ELSE IF (XOPT(I) .GE. SU(I)) THEN
+          IF (GOPT(I) .LE. ZERO) XBDI(I)=ONE
+      END IF
+      IF (XBDI(I) .NE. ZERO) NACT=NACT+1
+      D(I)=ZERO
+   10 GNEW(I)=GOPT(I)
+      DELSQ=DELTA*DELTA
+      QRED=ZERO
+      CRVMIN=ONEMIN
+C
+C     Set the next search direction of the conjugate gradient method. It is
+C     the steepest descent direction initially and when the iterations are
+C     restarted because a variable has just been fixed by a bound, and of
+C     course the components of the fixed variables are zero. ITERMAX is an
+C     upper bound on the indices of the conjugate gradient iterations.
+C
+   20 BETA=ZERO
+   30 STEPSQ=ZERO
+      DO 40 I=1,N
+      IF (XBDI(I) .NE. ZERO) THEN
+          S(I)=ZERO
+      ELSE IF (BETA .EQ. ZERO) THEN
+          S(I)=-GNEW(I)
+      ELSE
+          S(I)=BETA*S(I)-GNEW(I)
+      END IF
+   40 STEPSQ=STEPSQ+S(I)**2
+      IF (STEPSQ .EQ. ZERO) GOTO 190
+      IF (BETA .EQ. ZERO) THEN
+          GREDSQ=STEPSQ
+          ITERMAX=ITERC+N-NACT
+      END IF
+      IF (GREDSQ*DELSQ .LE. 1.0D-4*QRED*QRED) GO TO 190
+C
+C     Multiply the search direction by the second derivative matrix of Q and
+C     calculate some scalars for the choice of steplength. Then set BLEN to
+C     the length of the the step to the trust region boundary and STPLEN to
+C     the steplength, ignoring the simple bounds.
+C
+      GOTO 210
+   50 RESID=DELSQ
+      DS=ZERO
+      SHS=ZERO
+      DO 60 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          RESID=RESID-D(I)**2
+          DS=DS+S(I)*D(I)
+          SHS=SHS+S(I)*HS(I)
+      END IF
+   60 CONTINUE
+      IF (RESID .LE. ZERO) GOTO 90
+      TEMP=DSQRT(STEPSQ*RESID+DS*DS)
+      IF (DS .LT. ZERO) THEN
+          BLEN=(TEMP-DS)/STEPSQ
+      ELSE
+          BLEN=RESID/(TEMP+DS)
+      END IF
+      STPLEN=BLEN
+      IF (SHS .GT. ZERO) THEN
+          STPLEN=DMIN1(BLEN,GREDSQ/SHS)
+      END IF
+      
+C
+C     Reduce STPLEN if necessary in order to preserve the simple bounds,
+C     letting IACT be the index of the new constrained variable.
+C
+      IACT=0
+      DO 70 I=1,N
+      IF (S(I) .NE. ZERO) THEN
+          XSUM=XOPT(I)+D(I)
+          IF (S(I) .GT. ZERO) THEN
+              TEMP=(SU(I)-XSUM)/S(I)
+          ELSE
+              TEMP=(SL(I)-XSUM)/S(I)
+          END IF
+          IF (TEMP .LT. STPLEN) THEN
+              STPLEN=TEMP
+              IACT=I
+          END IF
+      END IF
+   70 CONTINUE
+C
+C     Update CRVMIN, GNEW and D. Set SDEC to the decrease that occurs in Q.
+C
+      SDEC=ZERO
+      IF (STPLEN .GT. ZERO) THEN
+          ITERC=ITERC+1
+          TEMP=SHS/STEPSQ
+          IF (IACT .EQ. 0 .AND. TEMP .GT. ZERO) THEN
+              CRVMIN=DMIN1(CRVMIN,TEMP)
+              IF (CRVMIN .EQ. ONEMIN) CRVMIN=TEMP
+          END IF 
+          GGSAV=GREDSQ
+          GREDSQ=ZERO
+          DO 80 I=1,N
+          GNEW(I)=GNEW(I)+STPLEN*HS(I)
+          IF (XBDI(I) .EQ. ZERO) GREDSQ=GREDSQ+GNEW(I)**2
+   80     D(I)=D(I)+STPLEN*S(I)
+          SDEC=DMAX1(STPLEN*(GGSAV-HALF*STPLEN*SHS),ZERO)
+          QRED=QRED+SDEC
+      END IF
+C
+C     Restart the conjugate gradient method if it has hit a new bound.
+C
+      IF (IACT .GT. 0) THEN
+          NACT=NACT+1
+          XBDI(IACT)=ONE
+          IF (S(IACT) .LT. ZERO) XBDI(IACT)=ONEMIN
+          DELSQ=DELSQ-D(IACT)**2
+          IF (DELSQ .LE. ZERO) GOTO 90
+          GOTO 20
+      END IF
+C
+C     If STPLEN is less than BLEN, then either apply another conjugate
+C     gradient iteration or RETURN.
+C
+      IF (STPLEN .LT. BLEN) THEN
+          IF (ITERC .EQ. ITERMAX) GOTO 190
+          IF (SDEC .LE. 0.01D0*QRED) GOTO 190
+          BETA=GREDSQ/GGSAV
+          GOTO 30
+      END IF
+   90 CRVMIN=ZERO
+C
+C     Prepare for the alternative iteration by calculating some scalars and
+C     by multiplying the reduced D by the second derivative matrix of Q.
+C
+  100 IF (NACT .GE. N-1) GOTO 190
+      DREDSQ=ZERO
+      DREDG=ZERO
+      GREDSQ=ZERO
+      DO 110 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          DREDSQ=DREDSQ+D(I)**2
+          DREDG=DREDG+D(I)*GNEW(I)
+          GREDSQ=GREDSQ+GNEW(I)**2
+          S(I)=D(I)
+      ELSE
+          S(I)=ZERO
+      END IF
+  110 CONTINUE
+      ITCSAV=ITERC
+      GOTO 210
+C
+C     Let the search direction S be a linear combination of the reduced D
+C     and the reduced G that is orthogonal to the reduced D.
+C
+  120 ITERC=ITERC+1
+      TEMP=GREDSQ*DREDSQ-DREDG*DREDG
+      IF (TEMP .LE. 1.0D-4*QRED*QRED) GOTO 190
+      TEMP=DSQRT(TEMP)
+      DO 130 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          S(I)=(DREDG*D(I)-DREDSQ*GNEW(I))/TEMP
+      ELSE
+          S(I)=ZERO
+      END IF
+  130 CONTINUE
+      SREDG=-TEMP
+C
+C     By considering the simple bounds on the variables, calculate an upper
+C     bound on the tangent of half the angle of the alternative iteration,
+C     namely ANGBD, except that, if already a free variable has reached a
+C     bound, there is a branch back to label 100 after fixing that variable.
+C
+      ANGBD=ONE
+      IACT=0
+      DO 140 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          TEMPA=XOPT(I)+D(I)-SL(I)
+          TEMPB=SU(I)-XOPT(I)-D(I)
+          IF (TEMPA .LE. ZERO) THEN
+              NACT=NACT+1
+              XBDI(I)=ONEMIN
+              GOTO 100
+          ELSE IF (TEMPB .LE. ZERO) THEN
+              NACT=NACT+1
+              XBDI(I)=ONE
+              GOTO 100
+          END IF
+          RATIO=ONE
+          SSQ=D(I)**2+S(I)**2
+          TEMP=SSQ-(XOPT(I)-SL(I))**2
+          IF (TEMP .GT. ZERO) THEN
+              TEMP=DSQRT(TEMP)-S(I)
+              IF (ANGBD*TEMP .GT. TEMPA) THEN
+                  ANGBD=TEMPA/TEMP
+                  IACT=I
+                  XSAV=ONEMIN
+              END IF
+          END IF
+          TEMP=SSQ-(SU(I)-XOPT(I))**2
+          IF (TEMP .GT. ZERO) THEN
+              TEMP=DSQRT(TEMP)+S(I)
+              IF (ANGBD*TEMP .GT. TEMPB) THEN
+                  ANGBD=TEMPB/TEMP
+                  IACT=I
+                  XSAV=ONE
+              END IF
+          END IF
+      END IF
+  140 CONTINUE
+C
+C     Calculate HHD and some curvatures for the alternative iteration.
+C
+      GOTO 210
+  150 SHS=ZERO
+      DHS=ZERO
+      DHD=ZERO
+      DO 160 I=1,N
+      IF (XBDI(I) .EQ. ZERO) THEN
+          SHS=SHS+S(I)*HS(I)
+          DHS=DHS+D(I)*HS(I)
+          DHD=DHD+D(I)*HRED(I)
+      END IF
+  160 CONTINUE
+C
+C     Seek the greatest reduction in Q for a range of equally spaced values
+C     of ANGT in [0,ANGBD], where ANGT is the tangent of half the angle of
+C     the alternative iteration.
+C
+      REDMAX=ZERO
+      ISAV=0
+      REDSAV=ZERO
+      IU=17.0D0*ANGBD+3.1D0
+      DO 170 I=1,IU
+      ANGT=ANGBD*DFLOAT(I)/DFLOAT(IU)
+      STH=(ANGT+ANGT)/(ONE+ANGT*ANGT)
+      TEMP=SHS+ANGT*(ANGT*DHD-DHS-DHS)
+      REDNEW=STH*(ANGT*DREDG-SREDG-HALF*STH*TEMP)
+      IF (REDNEW .GT. REDMAX) THEN
+          REDMAX=REDNEW
+          ISAV=I
+          RDPREV=REDSAV
+      ELSE IF (I .EQ. ISAV+1) THEN
+          RDNEXT=REDNEW
+      END IF
+  170 REDSAV=REDNEW
+C
+C     Return if the reduction is zero. Otherwise, set the sine and cosine
+C     of the angle of the alternative iteration, and calculate SDEC.
+C
+      IF (ISAV .EQ. 0) GOTO 190
+      IF (ISAV .LT. IU) THEN
+          TEMP=(RDNEXT-RDPREV)/(REDMAX+REDMAX-RDPREV-RDNEXT)
+          ANGT=ANGBD*(DFLOAT(ISAV)+HALF*TEMP)/DFLOAT(IU)
+      END IF
+      CTH=(ONE-ANGT*ANGT)/(ONE+ANGT*ANGT)
+      STH=(ANGT+ANGT)/(ONE+ANGT*ANGT)
+      TEMP=SHS+ANGT*(ANGT*DHD-DHS-DHS)
+      SDEC=STH*(ANGT*DREDG-SREDG-HALF*STH*TEMP)
+      IF (SDEC .LE. ZERO) GOTO 190
+C
+C     Update GNEW, D and HRED. If the angle of the alternative iteration
+C     is restricted by a bound on a free variable, that variable is fixed
+C     at the bound.
+C
+      DREDG=ZERO
+      GREDSQ=ZERO
+      DO 180 I=1,N
+      GNEW(I)=GNEW(I)+(CTH-ONE)*HRED(I)+STH*HS(I)
+      IF (XBDI(I) .EQ. ZERO) THEN
+          D(I)=CTH*D(I)+STH*S(I)
+          DREDG=DREDG+D(I)*GNEW(I)
+          GREDSQ=GREDSQ+GNEW(I)**2
+      END IF
+  180 HRED(I)=CTH*HRED(I)+STH*HS(I)
+      QRED=QRED+SDEC
+      IF (IACT .GT. 0 .AND. ISAV .EQ. IU) THEN
+          NACT=NACT+1
+          XBDI(IACT)=XSAV
+          GOTO 100
+      END IF
+C
+C     If SDEC is sufficiently small, then RETURN after setting XNEW to
+C     XOPT+D, giving careful attention to the bounds.
+C
+      IF (SDEC .GT. 0.01D0*QRED) GOTO 120
+  190 DSQ=ZERO
+      DO 200 I=1,N
+      XNEW(I)=DMAX1(DMIN1(XOPT(I)+D(I),SU(I)),SL(I))
+      IF (XBDI(I) .EQ. ONEMIN) XNEW(I)=SL(I)
+      IF (XBDI(I) .EQ. ONE) XNEW(I)=SU(I)
+      D(I)=XNEW(I)-XOPT(I)
+  200 DSQ=DSQ+D(I)**2
+      RETURN
+ 
+C     The following instructions multiply the current S-vector by the second
+C     derivative matrix of the quadratic model, putting the product in HS.
+C     They are reached from three different parts of the software above and
+C     they can be regarded as an external subroutine.
+C
+  210 IH=0
+      DO 220 J=1,N
+      HS(J)=ZERO
+      DO 220 I=1,J
+      IH=IH+1
+      IF (I .LT. J) HS(J)=HS(J)+HQ(IH)*S(I)
+  220 HS(I)=HS(I)+HQ(IH)*S(J)
+      DO 250 K=1,NPT
+      IF (PQ(K) .NE. ZERO) THEN
+          TEMP=ZERO
+          DO 230 J=1,N
+  230     TEMP=TEMP+XPT(K,J)*S(J)
+          TEMP=TEMP*PQ(K)
+          DO 240 I=1,N
+  240     HS(I)=HS(I)+TEMP*XPT(K,I)
+      END IF
+  250 CONTINUE
+      IF (CRVMIN .NE. ZERO) GOTO 50
+      IF (ITERC .GT. ITCSAV) GOTO 150
+      DO 260 I=1,N
+  260 HRED(I)=HS(I)
+      GOTO 120
+      END SUBROUTINE TRSBOX
+
+      SUBROUTINE UPDATE (N,NPT,BMAT,ZMAT,NDIM,VLAG,BETA,DENOM,
+     1  KNEW,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION BMAT(NDIM,*),ZMAT(NPT,*),VLAG(*),W(*)
+C
+C     The arrays BMAT and ZMAT are updated, as required by the new position
+C     of the interpolation point that has the index KNEW. The vector VLAG has
+C     N+NPT components, set on entry to the first NPT and last N components
+C     of the product Hw in equation (4.11) of the Powell (2006) paper on
+C     NEWUOA. Further, BETA is set on entry to the value of the parameter
+C     with that name, and DENOM is set to the denominator of the updating
+C     formula. Elements of ZMAT may be treated as zero if their moduli are
+C     at most ZTEST. The first NDIM elements of W are used for working space.
+C
+C     Set some constants.
+C
+      ONE=1.0D0
+      ZERO=0.0D0
+      NPTM=NPT-N-1
+      ZTEST=ZERO
+      DO 10 K=1,NPT
+      DO 10 J=1,NPTM
+   10 ZTEST=DMAX1(ZTEST,DABS(ZMAT(K,J)))
+      ZTEST=1.0D-20*ZTEST
+C
+C     Apply the rotations that put zeros in the KNEW-th row of ZMAT.
+C
+      JL=1
+      DO 30 J=2,NPTM
+      IF (DABS(ZMAT(KNEW,J)) .GT. ZTEST) THEN
+          TEMP=DSQRT(ZMAT(KNEW,1)**2+ZMAT(KNEW,J)**2)
+          TEMPA=ZMAT(KNEW,1)/TEMP
+          TEMPB=ZMAT(KNEW,J)/TEMP
+          DO 20 I=1,NPT
+          TEMP=TEMPA*ZMAT(I,1)+TEMPB*ZMAT(I,J)
+          ZMAT(I,J)=TEMPA*ZMAT(I,J)-TEMPB*ZMAT(I,1)
+   20     ZMAT(I,1)=TEMP
+      END IF
+      ZMAT(KNEW,J)=ZERO
+   30 CONTINUE
+C
+C     Put the first NPT components of the KNEW-th column of HLAG into W,
+C     and calculate the parameters of the updating formula.
+C
+      DO 40 I=1,NPT
+      W(I)=ZMAT(KNEW,1)*ZMAT(I,1)
+   40 CONTINUE
+      ALPHA=W(KNEW)
+      TAU=VLAG(KNEW)
+      VLAG(KNEW)=VLAG(KNEW)-ONE
+C
+C     Complete the updating of ZMAT.
+C
+      TEMP=DSQRT(DENOM)
+      TEMPB=ZMAT(KNEW,1)/TEMP
+      TEMPA=TAU/TEMP
+      DO 50 I=1,NPT
+   50 ZMAT(I,1)=TEMPA*ZMAT(I,1)-TEMPB*VLAG(I)
+C
+C     Finally, update the matrix BMAT.
+C
+      DO 60 J=1,N
+      JP=NPT+J
+      W(JP)=BMAT(KNEW,J)
+      TEMPA=(ALPHA*VLAG(JP)-TAU*W(JP))/DENOM
+      TEMPB=(-BETA*W(JP)-TAU*VLAG(JP))/DENOM
+      DO 60 I=1,JP
+      BMAT(I,J)=BMAT(I,J)+TEMPA*VLAG(I)+TEMPB*W(I)
+      IF (I .GT. NPT) BMAT(JP,I-NPT)=BMAT(I,J)
+   60 CONTINUE
+      RETURN
+      END SUBROUTINE UPDATE
+
+      SUBROUTINE ALTMOV (N,NPT,XPT,XOPT,BMAT,ZMAT,NDIM,SL,SU,KOPT,
+     1  KNEW,ADELT,XNEW,XALT,ALPHA,CAUCHY,GLAG,HCOL,W)
+      IMPLICIT REAL*8 (A-H,O-Z)
+      DIMENSION XPT(NPT,*),XOPT(*),BMAT(NDIM,*),ZMAT(NPT,*),SL(*),
+     1  SU(*),XNEW(*),XALT(*),GLAG(*),HCOL(*),W(*)
+C
+C     The arguments N, NPT, XPT, XOPT, BMAT, ZMAT, NDIM, SL and SU all have
+C       the same meanings as the corresponding arguments of BOBYQB.
+C     KOPT is the index of the optimal interpolation point.
+C     KNEW is the index of the interpolation point that is going to be moved.
+C     ADELT is the current trust region bound.
+C     XNEW will be set to a suitable new position for the interpolation point
+C       XPT(KNEW,.). Specifically, it satisfies the SL, SU and trust region
+C       bounds and it should provide a large denominator in the next call of
+C       UPDATE. The step XNEW-XOPT from XOPT is restricted to moves along the
+C       straight lines through XOPT and another interpolation point.
+C     XALT also provides a large value of the modulus of the KNEW-th Lagrange
+C       function subject to the constraints that have been mentioned, its main
+C       difference from XNEW being that XALT-XOPT is a constrained version of
+C       the Cauchy step within the trust region. An exception is that XALT is
+C       not calculated if all components of GLAG (see below) are zero.
+C     ALPHA will be set to the KNEW-th diagonal element of the H matrix.
+C     CAUCHY will be set to the square of the KNEW-th Lagrange function at
+C       the step XALT-XOPT from XOPT for the vector XALT that is returned,
+C       except that CAUCHY is set to zero if XALT is not calculated.
+C     GLAG is a working space vector of length N for the gradient of the
+C       KNEW-th Lagrange function at XOPT.
+C     HCOL is a working space vector of length NPT for the second derivative
+C       coefficients of the KNEW-th Lagrange function.
+C     W is a working space vector of length 2N that is going to hold the
+C       constrained Cauchy step from XOPT of the Lagrange function, followed
+C       by the downhill version of XALT when the uphill step is calculated.
+C
+C     Set the first NPT components of W to the leading elements of the
+C     KNEW-th column of the H matrix.
+C
+      HALF=0.5D0
+      ONE=1.0D0
+      ZERO=0.0D0
+      CONST=ONE+DSQRT(2.0D0)
+      DO 10 K=1,NPT
+   10 HCOL(K)=ZERO
+      DO 20 J=1,NPT-N-1
+      TEMP=ZMAT(KNEW,J)
+      DO 20 K=1,NPT
+   20 HCOL(K)=HCOL(K)+TEMP*ZMAT(K,J)
+      ALPHA=HCOL(KNEW)
+      HA=HALF*ALPHA
+C
+C     Calculate the gradient of the KNEW-th Lagrange function at XOPT.
+C
+      DO 30 I=1,N
+   30 GLAG(I)=BMAT(KNEW,I)
+      DO 50 K=1,NPT
+      TEMP=ZERO
+      DO 40 J=1,N
+   40 TEMP=TEMP+XPT(K,J)*XOPT(J)
+      TEMP=HCOL(K)*TEMP
+      DO 50 I=1,N
+   50 GLAG(I)=GLAG(I)+TEMP*XPT(K,I)
+C
+C     Search for a large denominator along the straight lines through XOPT
+C     and another interpolation point. SLBD and SUBD will be lower and upper
+C     bounds on the step along each of these lines in turn. PREDSQ will be
+C     set to the square of the predicted denominator for each line. PRESAV
+C     will be set to the largest admissible value of PREDSQ that occurs.
+C
+      PRESAV=ZERO
+      DO 80 K=1,NPT
+      IF (K .EQ. KOPT) GOTO 80
+      DDERIV=ZERO
+      DISTSQ=ZERO
+      DO 60 I=1,N
+      TEMP=XPT(K,I)-XOPT(I)
+      DDERIV=DDERIV+GLAG(I)*TEMP
+   60 DISTSQ=DISTSQ+TEMP*TEMP
+      SUBD=ADELT/DSQRT(DISTSQ)
+      SLBD=-SUBD
+      ILBD=0
+      IUBD=0
+      SUMIN=DMIN1(ONE,SUBD)
+C
+C     Revise SLBD and SUBD if necessary because of the bounds in SL and SU.
+C
+      DO 70 I=1,N
+      TEMP=XPT(K,I)-XOPT(I)
+      IF (TEMP .GT. ZERO) THEN
+          IF (SLBD*TEMP .LT. SL(I)-XOPT(I)) THEN
+              SLBD=(SL(I)-XOPT(I))/TEMP
+              ILBD=-I
+          END IF
+          IF (SUBD*TEMP .GT. SU(I)-XOPT(I)) THEN
+              SUBD=DMAX1(SUMIN,(SU(I)-XOPT(I))/TEMP)
+              IUBD=I
+          END IF
+      ELSE IF (TEMP .LT. ZERO) THEN
+          IF (SLBD*TEMP .GT. SU(I)-XOPT(I)) THEN
+              SLBD=(SU(I)-XOPT(I))/TEMP
+              ILBD=I
+          END IF
+          IF (SUBD*TEMP .LT. SL(I)-XOPT(I)) THEN
+              SUBD=DMAX1(SUMIN,(SL(I)-XOPT(I))/TEMP)
+              IUBD=-I
+          END IF
+      END IF
+   70 CONTINUE
+C
+C     Seek a large modulus of the KNEW-th Lagrange function when the index
+C     of the other interpolation point on the line through XOPT is KNEW.
+C
+      IF (K .EQ. KNEW) THEN
+          DIFF=DDERIV-ONE
+          STEP=SLBD
+          VLAG=SLBD*(DDERIV-SLBD*DIFF)
+          ISBD=ILBD
+          TEMP=SUBD*(DDERIV-SUBD*DIFF)
+          IF (DABS(TEMP) .GT. DABS(VLAG)) THEN
+              STEP=SUBD
+              VLAG=TEMP
+              ISBD=IUBD
+          END IF
+          TEMPD=HALF*DDERIV
+          TEMPA=TEMPD-DIFF*SLBD
+          TEMPB=TEMPD-DIFF*SUBD
+          IF (TEMPA*TEMPB .LT. ZERO) THEN
+              TEMP=TEMPD*TEMPD/DIFF
+              IF (DABS(TEMP) .GT. DABS(VLAG)) THEN
+                  STEP=TEMPD/DIFF
+                  VLAG=TEMP
+                  ISBD=0
+              END IF
+          END IF
+C
+C     Search along each of the other lines through XOPT and another point.
+C
+      ELSE
+          STEP=SLBD
+          VLAG=SLBD*(ONE-SLBD)
+          ISBD=ILBD
+          TEMP=SUBD*(ONE-SUBD)
+          IF (DABS(TEMP) .GT. DABS(VLAG)) THEN
+              STEP=SUBD
+              VLAG=TEMP
+              ISBD=IUBD
+          END IF
+          IF (SUBD .GT. HALF) THEN
+              IF (DABS(VLAG) .LT. 0.25D0) THEN
+                  STEP=HALF
+                  VLAG=0.25D0
+                  ISBD=0
+              END IF
+          END IF
+          VLAG=VLAG*DDERIV
+      END IF
+C
+C     Calculate PREDSQ for the current line search and maintain PRESAV.
+C
+      TEMP=STEP*(ONE-STEP)*DISTSQ
+      PREDSQ=VLAG*VLAG*(VLAG*VLAG+HA*TEMP*TEMP)
+      IF (PREDSQ .GT. PRESAV) THEN
+          PRESAV=PREDSQ
+          KSAV=K
+          STPSAV=STEP
+          IBDSAV=ISBD
+      END IF
+   80 CONTINUE
+C
+C     Construct XNEW in a way that satisfies the bound constraints exactly.
+C
+      DO 90 I=1,N
+      TEMP=XOPT(I)+STPSAV*(XPT(KSAV,I)-XOPT(I))
+   90 XNEW(I)=DMAX1(SL(I),DMIN1(SU(I),TEMP))
+      IF (IBDSAV .LT. 0) XNEW(-IBDSAV)=SL(-IBDSAV)
+      IF (IBDSAV .GT. 0) XNEW(IBDSAV)=SU(IBDSAV)
+C
+C     Prepare for the iterative method that assembles the constrained Cauchy
+C     step in W. The sum of squares of the fixed components of W is formed in
+C     WFIXSQ, and the free components of W are set to BIGSTP.
+C
+      BIGSTP=ADELT+ADELT
+      IFLAG=0
+  100 WFIXSQ=ZERO
+      GGFREE=ZERO
+      DO 110 I=1,N
+      W(I)=ZERO
+      TEMPA=DMIN1(XOPT(I)-SL(I),GLAG(I))
+      TEMPB=DMAX1(XOPT(I)-SU(I),GLAG(I))
+      IF (TEMPA .GT. ZERO .OR. TEMPB .LT. ZERO) THEN
+          W(I)=BIGSTP
+          GGFREE=GGFREE+GLAG(I)**2
+      END IF
+  110 CONTINUE
+      IF (GGFREE .EQ. ZERO) THEN
+          CAUCHY=ZERO
+          GOTO 200
+      END IF
+C
+C     Investigate whether more components of W can be fixed.
+C
+  120 TEMP=ADELT*ADELT-WFIXSQ
+      IF (TEMP .GT. ZERO) THEN
+          WSQSAV=WFIXSQ
+          STEP=DSQRT(TEMP/GGFREE)
+          GGFREE=ZERO
+          DO 130 I=1,N
+          IF (W(I) .EQ. BIGSTP) THEN
+              TEMP=XOPT(I)-STEP*GLAG(I)
+              IF (TEMP .LE. SL(I)) THEN
+                  W(I)=SL(I)-XOPT(I)
+                  WFIXSQ=WFIXSQ+W(I)**2
+              ELSE IF (TEMP .GE. SU(I)) THEN
+                  W(I)=SU(I)-XOPT(I)
+                  WFIXSQ=WFIXSQ+W(I)**2
+              ELSE
+                  GGFREE=GGFREE+GLAG(I)**2
+              END IF
+          END IF
+  130     CONTINUE
+          IF (WFIXSQ .GT. WSQSAV .AND. GGFREE .GT. ZERO) GOTO 120
+      END IF
+C
+C     Set the remaining free components of W and all components of XALT,
+C     except that W may be scaled later.
+C
+      GW=ZERO
+      DO 140 I=1,N
+      IF (W(I) .EQ. BIGSTP) THEN
+          W(I)=-STEP*GLAG(I)
+          XALT(I)=DMAX1(SL(I),DMIN1(SU(I),XOPT(I)+W(I)))
+      ELSE IF (W(I) .EQ. ZERO) THEN
+          XALT(I)=XOPT(I)
+      ELSE IF (GLAG(I) .GT. ZERO) THEN
+          XALT(I)=SL(I)
+      ELSE
+          XALT(I)=SU(I)
+      END IF
+  140 GW=GW+GLAG(I)*W(I)
+C
+C     Set CURV to the curvature of the KNEW-th Lagrange function along W.
+C     Scale W by a factor less than one if that can reduce the modulus of
+C     the Lagrange function at XOPT+W. Set CAUCHY to the final value of
+C     the square of this function.
+C
+      CURV=ZERO
+      DO 160 K=1,NPT
+      TEMP=ZERO
+      DO 150 J=1,N
+  150 TEMP=TEMP+XPT(K,J)*W(J)
+  160 CURV=CURV+HCOL(K)*TEMP*TEMP
+      IF (IFLAG .EQ. 1) CURV=-CURV
+      IF (CURV .GT. -GW .AND. CURV .LT. -CONST*GW) THEN
+          SCALE=-GW/CURV
+          DO 170 I=1,N
+          TEMP=XOPT(I)+SCALE*W(I)
+  170     XALT(I)=DMAX1(SL(I),DMIN1(SU(I),TEMP))
+          CAUCHY=(HALF*GW*SCALE)**2
+      ELSE
+          CAUCHY=(GW+HALF*CURV)**2
+      END IF
+C
+C     If IFLAG is zero, then XALT is calculated as before after reversing
+C     the sign of GLAG. Thus two XALT vectors become available. The one that
+C     is chosen is the one that gives the larger value of CAUCHY.
+C
+      IF (IFLAG .EQ. 0) THEN
+          DO 180 I=1,N
+          GLAG(I)=-GLAG(I)
+  180     W(N+I)=XALT(I)
+          CSAVE=CAUCHY
+          IFLAG=1
+          GOTO 100
+      END IF
+      IF (CSAVE .GT. CAUCHY) THEN
+          DO 190 I=1,N
+  190     XALT(I)=W(N+I)
+          CAUCHY=CSAVE
+      END IF
+  200 RETURN
+      END SUBROUTINE ALTMOV
+
+	END SUBROUTINE MAIN
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/collectResults.m b/Requirements/PESTO-1.1.0/collectResults.m
new file mode 100644
index 0000000000000000000000000000000000000000..e2df0386e777de8e66a850e503fae6125004c972
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/collectResults.m
@@ -0,0 +1,125 @@
+function obj = collectResults(foldername)
+% collectResults() collects and plots the results stored in a common folder
+%
+% USAGE:
+% [parameters] = collectResults(foldername)
+%
+% Parameters:
+% foldername: Name of folder from which results are collected.
+%
+% Return values:
+% parameters: parameter struct.
+%
+% History:
+% 2014/06/12 Jan Hasenauer
+%% Initialization
+warning off;
+try
+    init = load(fullfile(foldername,'init'),'parameters');
+    obj = init.parameters;
+    type = 'parameters';
+catch
+    init = load(fullfile(foldername,'init'),'properties');
+    obj = init.properties;
+    type = 'properties';
+end
+warning on;
+
+%% Collection of data
+files = dir(fullfile(foldername,'*.csv'));
+
+ntheta = size(init.parameters.MS.par0,1);
+nstarts = init.parameters.MS.n_starts;
+
+obj.MS.logPost = NaN(nstarts,1);
+obj.MS.logPost0 = NaN(nstarts,1);
+obj.MS.par = NaN(ntheta,nstarts);
+obj.MS.par0 = NaN(ntheta,nstarts);
+obj.MS.gradient = NaN(ntheta,nstarts);
+obj.MS.hessian = NaN(ntheta,ntheta,nstarts);
+obj.MS.t_cpu = NaN(nstarts,1);
+obj.MS.n_objfun = NaN(nstarts,1);
+obj.MS.n_iter = NaN(nstarts,1);
+obj.MS.exitflag = NaN(nstarts,1);
+% should do this for prop and prop_Sigma aswell, but what are the dimensions?
+
+% Loop: files
+for j = 1:length(files)
+    % Read file
+    v = csvread(fullfile(foldername,files(j).name));
+    
+    % Determine index and fieldname
+    fn1 = files(j).name(1);
+    fn2 = files(j).name((strfind(files(j).name,'__')+2):(length(files(j).name)-4));
+    
+    % Assignment
+    switch fn1
+        case 'M' % -> Multi-start optimization results
+            i = str2num(files(j).name(3:(strfind(files(j).name,'__')-1)));
+            switch fn2
+                case 'logPost', obj.MS.logPost(i,1) = v;
+                case 'logPost0', obj.MS.logPost0(i,1) = v;
+                case 'par', obj.MS.par(:,i) = v;
+                case 'par0', obj.MS.par0(:,i) = v;
+                case 'gradient', obj.MS.gradient(:,i) = v;
+                case 'hessian', obj.MS.hessian(:,:,i) = v;
+                case 't_cpu', obj.MS.t_cpu(i,1) = v;
+                case 'n_objfun', obj.MS.n_objfun(i,1) = v;
+                case 'n_iter', obj.MS.n_iter(i,1) = v;
+                case 'exitflag', obj.MS.exitflag(i,1) = v;
+                case 'prop', obj.MS.prop(:,i) = v;
+                case 'prop_Sigma', obj.MS.prop_Sigma(:,:,i) = v;
+                case 'fval_trace'
+                    if(~isfield(obj.MS,'fval_trace'))
+                        obj.MS.fval_trace = NaN(size(v,1),nstarts);
+                    end
+                    obj.MS.fval_trace(:,i) = v;
+                case 'time_trace'
+                    if(~isfield(obj.MS,'time_trace'))
+                        obj.MS.time_trace = NaN(size(v,1),nstarts);
+                    end
+                    obj.MS.time_trace(:,i) = v;
+                case 'par_trace'
+                    if(~isfield(obj.MS,'par_trace'))
+                        obj.MS.par_trace = NaN(ntheta,size(v,2),nstarts);
+                    end
+                    obj.MS.par_trace(:,:,i) = v;
+            end
+        case 'P' % -> Profile calculation results
+            i = str2num(files(j).name(2:(strfind(files(j).name,'__')-1)));
+            switch fn2
+                case 'par', obj.P(i).par = v;
+                case 'logPost', obj.P(i).logPost = v;
+                case 'R', obj.P(i).R = v;
+                case 'exitflag', obj.P(i).exitflag = v;
+                case 'prop', obj.P(i).prop = v;
+            end
+    end
+end
+
+%% Sort and save results
+switch type
+    case 'parameters'
+        parameters = sortMultiStarts(obj);
+        save(fullfile(foldername,['parameters_' foldername]),'parameters');
+        obj = parameters;
+end
+
+%% Visualization
+switch type
+    case 'parameters'
+        if isfield(obj,'MS')
+            disp(['progress of MS = ' num2str(100*sum(~isnan(obj.MS.par(1,:)))/obj.MS.n_starts) '%']);
+            plotMultiStarts(obj);
+        end
+        if isfield(obj,'P')
+            plotParameterProfiles(obj);
+        end
+    case 'properties'
+        if isfield(obj,'MS')
+            plotPropertyMultiStarts(obj);
+        end
+        if isfield(obj,'P')
+            plotPropertyProfiles(obj);
+        end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/doc/LICENSE-mtoc++ b/Requirements/PESTO-1.1.0/doc/LICENSE-mtoc++
new file mode 100644
index 0000000000000000000000000000000000000000..17802c794a2ac372db9c527fa30c5f9ecc5f6ec7
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/LICENSE-mtoc++
@@ -0,0 +1,12 @@
+This folder contains parts of the mtoc++ tool from http://www.morepas.org/software/mtocpp/ which is redistributed under the following license:
+
+Copyright (c) 2012, Daniel Wirtz
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/PESTO-1.1.0/doc/MatlabDocMaker.m b/Requirements/PESTO-1.1.0/doc/MatlabDocMaker.m
new file mode 100644
index 0000000000000000000000000000000000000000..566d9d82125fe8cc2b728b25200c2e9b13eaebc6
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/MatlabDocMaker.m
@@ -0,0 +1,685 @@
+classdef MatlabDocMaker
+% MatlabDocMaker: Automated documentation creation using doxygen and mtoc++ from within MatLab
+%
+% Currently documentation creation for unix and windows environment is
+% supported.
+%
+% Prerequisites:
+% The following tools must be installed and present on the PATH or
+% reside inside the folder returned by
+% MatlabDocMaker.getConfigDirectory.
+% - \c mtocpp, \c mtocpp_post (the main tool)
+% - \c doxygen (mtoc++ is a filter for doxygen)
+%
+% Strongly recommended:
+% - \c latex Doxygen supports built-in latex formulas and
+% MatlabDocMaker/mtoc++ allows for easy extra latex inclusions and
+% notation in code
+% - \c dot Doxygen creates really nice inheritance graphs and
+% collaboration diagrams with dot.
+%
+% @author Daniel Wirtz @date 2011-10-13
+%
+% @change{1,5,dw,2013-12-03} Fixed default value selection for properties,
+% now not having set a description or logo does not cause an error to be
+% thrown.
+% 
+% @change{1,5,dw,2013-02-21} Fixed the callback for suggested direct documentation creation
+% after MatlabDocMaker.setup (Thanks to Aurelien Queffurust)
+%
+% @change{1,5,dw,2013-02-12} Also added the escaping for the Logo file. Thanks to Chris Olien
+% for the hint.
+%
+% @change{1,5,dw,2013-01-07} Included some backslash escaping for paths on windows platforms.
+% Thanks to MathWorks Pilot Engineer '''Arvind Jayaraman''' for providing the feedback and code!
+%
+% @change{1,4,dw,2012-10-18} Removed \c m4 dependency and included constant properties for
+% configuration file names.
+%
+% @new{1,4,dw,2012-10-16}
+% - Added two more configuration variables "ProjectDescription" and "ProjectLogo" for easier
+% configuration of the MatlabDocMaker in many cases. Thanks to Wolfgang
+% Mennerich <http://www.mathworks.com/matlabcentral/fileexchange/authors/272859> for the suggestion.
+% - Restructured the configuration, now only the project name function has to be implemented
+% (the preferences tag depends on it, there might be more than one project within the same
+% Matlab installation whos documentation is created using this tool). The rest can be provided
+% either at setup time or later via suitable setters for the version, description and logo.
+% - Automatically setting HaveDot in the doxygen config whenever its found on the environment
+% path.
+% - Added basic support for LaTeX documentation creation. Using the parameter 'latex'=true for
+% the create method creates the LaTeX version of the documentation in a folder "latex" in the
+% OutputDirectory (default behaviour)
+%
+% @change{1,4,dw,2012-09-27} Added automatic dot Graphviz tool detection on
+% call to create.
+%
+% @change{1,3,dw,2012-02-16}
+% - Now also collecting error messages from mtocpp_post and adding them to
+% the warnings.log file.
+% - Added the directive "LD_LIBRARY_PATH= " for unix systems, as MatLab
+% sets it inside its executing environment. This can lead to errors if
+% doxygen and/or mtoc++ have been built using never GLIBC (libstd) versions
+% than the one shipped with MatLab.
+%
+% @change{1,3,dw,2012-01-16}
+% - Properly using the correct file separators everywhere now
+% - Hyperlinked the log file so it can be opened directly
+%
+% @change{1,3,dw,2012-01-14} Not displaying the "generated warnings"-text if there have not
+% been any during documentation creation.
+%
+% @change{1,2,dw,2011-11-27}
+% - Included documentation creation for the Windows platform and
+% combined the old methods into one (small effective differences)
+% - No longer storing the doxygen binary file in the prefs as a lot of
+% tools must be present on the path anyways. The new paradigm is to
+% expect all required 3rd-party programmes to be available on PATH. As
+% backup the configuration files directory is
+% added to the Matlab PATH environment \b nonpermanently and any
+% executables found there will thus also be usable.
+% - Included checks for \c dot and \c latex at the setup stage to
+% recommend installation of those tools if not present (the default
+% doxygen settings in Doxyfile.m4 are to use both)
+%
+% @change{1,2,dw,2011-11-08} Improved the createUnix method by displaying the warnings and writing the output to
+% a log file afterwards. Not using cprintf anymore as this is 3rd party software.
+%
+% @change{1,2,dw,2011-11-07} Fixed a recursion bug caused by copy and paste. Now the preferences
+% are stored on an per-application basis.
+%
+% @change{1,2,dw,2011-11-04} Changed the name to MatlabDocMaker in
+% order to export it into the mtoc++ distribution later.
+%
+% @new{1,2,dw,2011-10-13} Added this class and moved documentation related
+% stuff here from the KerMor class.
+%
+% This class is part of the mtoc++ tool
+% - \c Homepage http://www.morepas.org/software/mtocpp/
+% - \c License http://www.morepas.org/software/mtocpp/docs/licensing.html
+%
+% Copyright (c) 2012, Daniel Wirtz
+% All rights reserved.
+%
+% Redistribution and use in source and binary forms, with or without
+% modification, are permitted only in compliance with the BSD license, see
+% http://www.opensource.org/licenses/bsd-license.php
+
+    properties(Constant)
+        % File name for the doxygen configuration file processed by the MatlabDocMaker.
+        %
+        % Assumed to reside in the MatlabDocMaker.getConfigDirectory
+        %
+        % @type char @default 'Doxyfile.template'
+        DOXYFILE_TEMPLATE = 'Doxyfile.template';
+        
+        % File name for the latex extras style file processed by the MatlabDocMaker.
+        %
+        % Assumed to reside in the MatlabDocMaker.getConfigDirectory.
+        % If not found, no latex extras are used.
+        %
+        % @type char @default 'latexextras.template'
+        LATEXEXTRAS_TEMPLATE = 'latexextras.template';
+        
+        % File name the mtoc++ configuration file.
+        %
+        % Assumed to reside in the MatlabDocMaker.getConfigDirectory.
+        % If not found, no special configuration is used.
+        %
+        % @type char @default 'mtocpp.conf'
+        MTOCPP_CONFIGFILE = 'mtocpp.conf';
+    end
+
+    methods(Static)
+        function name = getProjectName
+            % Returns the project name.
+            %
+            % @note Changing the return value of this method will require
+            % another execution of MatlabDocMaker.setup as the preferences
+            % storage key also depends on it.
+            %
+            % Return values:
+            % name: The project name @type char
+            
+            name = 'PESTO';
+            % Example:
+            % name = 'My mtoc++-powered project';
+        end
+    end
+    
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    %% End of user defined part.
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    
+    methods(Static, Sealed)
+        function dir = getOutputDirectory
+            % Returns the directory where the applications source files
+            % reside
+            %
+            % Return values:
+            % dir: The output directory @type char
+            dir = MatlabDocMaker.getPref('outdir');
+        end
+        
+        function dir = getSourceDirectory
+            % Returns the directory where the applications source files
+            % reside
+            %
+            % Return values:
+            % dir: The project source directory @type char
+            dir = MatlabDocMaker.getPref('srcdir');
+        end
+        
+        function dir = getConfigDirectory
+            % Returns the directory where the applications documentation
+            % configuration files reside
+            %
+            % This folder must contain at least the files "mtoc.conf" and
+            % "Doxyfile.template"
+            %
+            % Return values:
+            % dir: The documentation configuration directory @type char
+            dir = MatlabDocMaker.getPref('confdir');
+        end
+        
+        function desc = getProjectDescription
+            % Returns the short project description.
+            %
+            % Return values:
+            % desc: The short project description @type char @default []
+            %
+            % See also: setProjectDescription
+            desc =  MatlabDocMaker.getPref('proj_desc', '');
+        end
+        
+        function setProjectDescription(value)
+            % Sets the project description.
+            %
+            % Parameters:
+            % value: The description @type char
+            %
+            % See also: getProjectDescription
+            if ~ischar(value)
+                error('The description must be a char array.');
+            end
+            MatlabDocMaker.setPref('proj_desc', value);
+        end
+        
+        function version = getProjectVersion
+            % Returns the current version of the project.
+            %
+            % @note The built-in @@new and @@change tags from the
+            % Doxyfile.template support two-level versioning a la X.X.
+            %
+            % Return values:
+            % version: The project version @type char @default []
+            %
+            % See also: setProjectVersion
+            version = MatlabDocMaker.getPref('proj_ver', '0');
+        end
+        
+        function setProjectVersion(value)
+            % Sets the project version.
+            %
+            % Parameters:
+            % value: The version string @type char
+            %
+            % See also: getProjectVersion
+            if ~ischar(value)
+                error('The project version must be a char array.');
+            end
+            MatlabDocMaker.setPref('proj_ver', value);
+        end
+        
+        function fullPath = getProjectLogo
+            % Returns the logo image file for the project. Either an absolute path or a plain
+            % filename. For the latter case the image file is assumed to reside inside the
+            % directory returned by MatlabDocMaker.getConfigDirectory.
+            %
+            % Return values:
+            % logoFile: The projects logo image file. @type char @default []
+            %
+            % See also: setProjectLogo
+            logoFile = MatlabDocMaker.getPref('proj_logo','');
+            fullPath = '';
+            if ~isempty(logoFile)
+                if isempty(fileparts(logoFile))
+                    fullPath = fullfile(MatlabDocMaker.getConfigDirectory,logoFile);
+                else
+                    fullPath = logoFile;
+                end
+                if exist(fullPath,'file') ~= 2
+                    warning('MatlabDocMaker:getLogo',['Could not find logo file "%s".\n'...
+                        'No logo will be shown in documentation output.'],logoFile);
+                end
+            end
+        end
+        
+        function setProjectLogo(value)
+            % Sets the project logo. Set to '' to unset.
+            %
+            % See the doxygen documentation for valid logo file types (wont be checked here).
+            %
+            % Parameters:
+            % value: The logo file to use. Must be either an absolute path or a plain filename,
+            % in which case the image is assumed to reside inside the
+            % MatlabDocMaker.getConfigDirectory directory. @type char
+            %
+            % See also: getProjectLogo
+            if nargin < 1
+                [f, p] = uigetfile('*.*', 'Select project logo', pwd);
+                if f ~= 0
+                    value = fullfile(p,f);
+                else
+                    fprintf(2,'No file selected. Aborting.\n');
+                    return;
+                end
+            end
+            if ~ischar(value)
+                error('The project logo file must be a char array.');
+            end
+            if ~isempty(value)
+                fullPath = value;
+                if isempty(fileparts(value))
+                    fullPath = fullfile(MatlabDocMaker.getConfigDirectory,value);
+                end
+                if ~exist(fullPath,'file')
+                    error('Invalid logo file: Could not find "%s"',fullPath);
+                end
+            end
+            MatlabDocMaker.setPref('proj_logo', value);
+        end
+    end
+        
+    methods(Static)
+        
+        function open
+            % Opens the generated documentation.
+            %
+            % Depending on the system's type the generated index.html is opened in the system's
+            % default browser.
+            index = fullfile(MatlabDocMaker.getOutputDirectory, 'index.html');
+            if ispc
+                winopen(index);
+            else
+                [s, m] = system(sprintf('xdg-open "%s"',index));
+                if s ~= 0
+                    fprintf(2,'Could not find/execute xdg-open: %s',m);
+                    web(index);
+                end
+            end
+        end
+        
+        function create(varargin)
+            % Creates the Doxygen documentation
+            %
+            % Parameters:
+            % varargin: Optional parameters for creation.
+            % open: Set to true if the documentation should be opened after
+            % successful compilation @type logical @default false
+            % latex: Set to true if `\text{\LaTeX}` output should be generated, too. @type logical
+            % @default false
+           
+            %% Preparations
+            ip = inputParser;
+            ip.addParamValue('open',false,@islogical);
+            ip.addParamValue('latex',true,@islogical);
+            ip.parse(varargin{:});
+            genlatex = ip.Results.latex;
+            
+            % Check for correct setup
+            cdir = MatlabDocMaker.getConfigDirectory;
+            srcdir = MatlabDocMaker.getSourceDirectory;
+            outdir = MatlabDocMaker.getOutputDirectory;
+            % Check if doxygen config file template exists
+            doxyfile_in = fullfile(cdir,MatlabDocMaker.DOXYFILE_TEMPLATE);
+            if exist(doxyfile_in,'file') ~= 2
+                error('No doxygen configuration file template found at "%s"',doxyfile_in);
+            end
+            
+            lstr = '';
+            if genlatex
+                lstr = '(+Latex)';
+            end
+            fprintf(['Starting creation of doxygen/mtoc++ powered HTML%s documentation for "%s" (%s)\n'...
+                'Sources: %s\nOutput to: <a href="matlab:MatlabDocMaker.open">%s</a>\nCreating config files...'],lstr,...
+                MatlabDocMaker.getProjectName,MatlabDocMaker.getProjectVersion,...
+                srcdir,outdir);
+            
+            % Operation-system dependent strings
+            strs = struct;
+            if isunix
+                strs.null = '/dev/null';
+                strs.silencer = '';
+            elseif ispc
+                strs.null = 'NUL';
+                strs.silencer = '@'; % argh that took a while to remember..
+            else
+                error('Current platform not supported.');
+            end
+            
+            % Save current working dir and change into the KerMor home
+            % directory; only from there all classes and packages are
+            % detected properly.
+            curdir = pwd;
+            cd(srcdir);
+            
+            % Append the configuration file directory to the current PATH
+            pathadd = [pathsep cdir];
+            setenv('PATH',[getenv('PATH') pathadd]);
+            
+            mtoc_conf = fullfile(cdir,MatlabDocMaker.MTOCPP_CONFIGFILE);
+            filter = sprintf('%smtocpp',strs.silencer);
+            if exist(mtoc_conf,'file')
+                if isunix
+                    strs.filter = 'mtocpp_filter.sh';
+                    strs.farg = '$1';
+                elseif ispc
+                    strs.filter = 'mtocpp_filter.bat';
+                    strs.farg = '%1';
+                else
+                    error('Current platform not supported.');
+                end
+                %% Creation part
+                cdir = MatlabDocMaker.getConfigDirectory;
+                % Create "configured" filter script for inclusion in doxygen 
+                filter = fullfile(cdir,strs.filter);
+                f = fopen(filter,'w');
+                fprintf(f,'%smtocpp %s %s',strs.silencer,strs.farg,mtoc_conf);
+                fclose(f);
+                if isunix
+                    unix(['chmod +x ' filter]);
+                end
+            end
+            
+            %% Prepare placeholders in the Doxyfile template
+            m = {'_OutputDir_' strrep(outdir,'\','\\'); ...
+                 '_SourceDir_' strrep(MatlabDocMaker.getSourceDirectory,'\','\\');...
+                 '_ConfDir_' strrep(cdir,'\','\\');...
+                 '_ProjectName_' MatlabDocMaker.getProjectName; ...
+                 '_ProjectDescription_' MatlabDocMaker.getProjectDescription; ...
+                 '_ProjectLogo_' strrep(MatlabDocMaker.getProjectLogo,'\','\\'); ...
+                 '_ProjectVersion_' MatlabDocMaker.getProjectVersion; ...
+                 '_MTOCFILTER_' strrep(filter,'\','\\'); ...
+                 };
+             
+            % Check for latex extra stuff
+            texin = fullfile(cdir,MatlabDocMaker.LATEXEXTRAS_TEMPLATE);
+            latexextras = '';
+            if exist(texin,'file') == 2  
+                latexstr = strrep(fileread(texin),'_ConfDir_',strrep(cdir,'\','/'));
+                latexextras = fullfile(cdir,'latexextras.sty');
+                fid = fopen(latexextras,'w+'); fprintf(fid,'%s',latexstr); fclose(fid);
+            end
+            % Always use "/" for latex usepackage commands, so replace "\" (effectively windows
+            % only) by "/", and dont pass the extension ".sty" as latex automatically adds it.
+            m(end+1,:) = {'_LatexExtras_' strrep(latexextras(1:end-4),'\','/')};
+            L = 'NO';
+            if genlatex
+                L = 'YES';
+            end
+            m(end+1,:) = {'_GenLatex_',L};
+            
+            % Check how to set the HAVE_DOT flag
+            [s, ~] = system('dot -V');
+            if s == 0
+                HD = 'YES';
+            else
+                HD = 'NO';
+                fprintf('no "dot" found...');
+            end
+            m(end+1,:) = {'_HaveDot_',HD};
+            
+            % Read, replace & write doxygen config file
+            doxyfile = fullfile(cdir,'Doxyfile');
+            doxyconfstr = regexprep(fileread(doxyfile_in),m(:,1),m(:,2));
+            fid = fopen(doxyfile,'w'); fprintf(fid,'%s',doxyconfstr); fclose(fid);
+            
+            % Fix for unix systems where the MatLab installation uses older
+            % GLIBSTD libraries than doxygen/mtoc++
+            ldpath = '';
+            if isunix
+                setenv('PATH', [getenv('PATH'), ':/usr/local/mtocpp/bin/'])
+                ldpath = 'LD_LIBRARY_PATH= ';
+            end
+            % Call doxygen
+            fprintf('running doxygen with mtoc++ filter...');
+            [~,warn] = system(sprintf('%sdoxygen "%s" 1>%s',ldpath, doxyfile, strs.null));
+             
+            % Postprocess
+            fprintf('running mtoc++ postprocessor...');
+            [~,postwarn] = system(sprintf('%smtocpp_post "%s" 1>%s',ldpath,...
+                outdir, strs.null));
+            if ~isempty(postwarn)
+                warn = [warn sprintf('mtoc++ postprocessor messages:\n') postwarn];
+            end
+            
+            % Create latex document if desired
+            if genlatex
+                oldd = pwd;
+                latexerr = false;
+                latexdir = fullfile(outdir,'latex');
+                if exist(latexdir,'dir') == 7
+                    if exist(fullfile(latexdir,'refman.tex'),'file') == 2
+                        fprintf('compiling LaTeX output...');
+                        cd(latexdir);
+                        [s, latexmsg] = system('make');
+                        if s ~= 0
+                            warn = [warn sprintf('LaTeX compiler output:\n') latexmsg];
+                            latexerr = true;
+                        else
+                            copyfile(fullfile(latexdir,'refman.pdf'), fullfile(fileparts(mfilename('fullpath')),'PESTO-doc.pdf'))
+                        end
+                    else
+                        fprintf('cannot compile LaTeX output: no refman.tex found...');
+                    end
+                end
+                cd(oldd);
+            end
+            
+            % Tidy up
+            fprintf('cleaning up...');
+            if isfield(strs,'filter')
+                % delete(filter);
+            end
+            if ~isempty(latexextras)
+                % delete(latexextras);
+            end
+            % delete(doxyfile);
+            
+            %% Post generation phase 
+            cd(curdir);
+            % Restore PATH to previous value
+            curpath = getenv('PATH');
+            setenv('PATH',curpath(1:end-length(pathadd)));
+            fprintf('done!\n');
+            
+            % Process warnings
+            showchars = 800;
+            warn = strtrim(warn);
+            if ~isempty(warn)
+                dispwarn = [warn(1:min(showchars,length(warn))) ' [...]'];
+                fprintf('First %d characters of warnings generated during documentation creation:\n%s\n',showchars,dispwarn);
+                % Write to log file
+                log = fullfile(outdir,'warnings.log');
+                f = fopen(log,'w'); fprintf(f,'%s',warn); fclose(f);
+                fprintf(2,'MatlabDocMaker finished with warnings!\n');
+                fprintf('Complete log file at <a href="matlab:edit(''%s'')">%s</a>.\n',log,log);
+                % Check for latex log file
+                log = fullfile(outdir,'_formulas.log');
+                if exist(log,'file')
+                    fprintf('Found LaTeX formula log file. Check <a href="matlab:edit(''%s'')">%s</a> for any errors.\n',log,log);
+                end
+                % Check for errors on latex generation
+                if genlatex && latexerr
+                    log = fullfile(latexdir,'refman.log');
+                    fprintf('There have been errors with LaTeX compilation. See log file at <a href="matlab:edit(''%s'')">%s</a>.\n',log,log);
+                end
+            else
+                fprintf('MatlabDocMaker finished with no warnings!\n');
+            end
+            
+            % Open index.html if wanted
+            if ip.Results.open
+                MatlabDocMaker.open;
+            end
+        end
+        
+        function setup
+            % Runs the setup script for MatlabDocMaker and collects all
+            % necessary paths in order for the documentation creation to
+            % work properly.
+            
+            %% Validity checks
+            fprintf('<<<< Welcome to the MatlabDocMaker setup for your project "%s"! >>>>\n',MatlabDocMaker.getProjectName);
+            
+            %% Setup directories
+            % Source directory
+            srcdir = MatlabDocMaker.getPref('srcdir','');
+            word = 'keep';
+            if isempty(srcdir) || exist(srcdir,'dir') ~= 7
+                srcdir = pwd;
+                word = 'set';
+            end
+            str = sprintf('Do you want to %s %s as your projects source directory?\n(Y)es/(N)o?: ',word,strrep(srcdir,'\','\\'));
+            ds = lower(input(str,'s'));
+            if isequal(ds,'n')
+                d = uigetdir(srcdir,'Please select the projects source directory');
+                if d == 0
+                    error('No source directory specified. Aborting setup.');
+                end
+                srcdir = d;
+            end
+            MatlabDocMaker.setPref('srcdir',srcdir);
+            
+            % Config directory
+            confdir = MatlabDocMaker.getPref('confdir','');
+            word = 'keep';
+            if isempty(confdir) || exist(confdir,'dir') ~= 7
+                confdir = fullfile(srcdir,'documentation');
+                word = 'set';
+            end
+            str = sprintf('Do you want to %s %s as your documentation configuration files directory?\n(Y)es/(N)o?: ',word,strrep(confdir,'\','\\'));
+            ds = lower(input(str,'s'));
+            if isequal(ds,'n')
+                d = uigetdir(confdir,'Please select the documentation configuration directory');
+                if d == 0
+                    error('No documentation configuration directory specified. Aborting setup.');
+                end
+                confdir = d;
+            end
+            MatlabDocMaker.setPref('confdir',confdir);
+            
+            % Output directory
+            outdir = MatlabDocMaker.getPref('outdir','');
+            word = 'keep';
+            if isempty(outdir) || exist(outdir,'dir') ~= 7
+                outdir = confdir;
+                word = 'set';
+            end
+            str = sprintf('Do you want to %s %s as your documentation output directory?\n(Y)es/(N)o?: ',word,strrep(outdir,'\','\\'));
+            ds = lower(input(str,'s'));
+            if isequal(ds,'n')
+                d = uigetdir(outdir,'Please select the documentation output directory');
+                if d == 0
+                    error('No documentation output directory specified. Aborting setup.');
+                end
+                outdir = d;
+            end
+            MatlabDocMaker.setPref('outdir',outdir);
+            
+            %% Additional Project properties
+            if isequal(lower(input(['Do you want to specify further project details?\n'...
+                    'You can set them later using provided set methods. (Y)es/(N)o?: '],'s')),'y')
+                MatlabDocMaker.setPref('proj_ver',input('Please specify the project version, e.g. "0.1": ','s'));
+                MatlabDocMaker.setPref('proj_desc',input('Please specify a short project description: ','s'));
+                MatlabDocMaker.setProjectLogo;
+            end
+            
+            %% Check for necessary and recommended tools
+            hasall = true;
+            setenv('PATH',[getenv('PATH') pathsep confdir]);
+            fprintf('[Required] Checking for doxygen... ');
+            [st, vers] = system('doxygen --version');
+            if st == 0
+                fprintf(' found %s\n',vers(1:end-1));
+            else
+                fprintf(2,' not found!\n');
+                hasall = false;                
+            end
+            fprintf('[Required] Checking for mtoc++... ');
+            ldpath = '';
+            if isunix
+                ldpath = 'LD_LIBRARY_PATH= ';
+            end
+            [st, vers] = system(sprintf('%smtocpp --version',ldpath));
+            if st == 0
+                fprintf(' found %s\n',vers(1:end-1));
+            else
+                fprintf(2,' not found!\n');
+                hasall = false;
+            end
+            fprintf('[Recommended] Checking for dot... ');
+            [st, vers] = system('dot -V');
+            if st == 0
+                fprintf(' found %s\n',vers(1:end-1));
+            else
+                fprintf(2,'dot Graphviz tool not found!\nInstall dot for nicer class diagrams.\n');
+            end
+            fprintf('[Recommended] Checking for latex... ');
+            [st, vers] = system('latex --version');
+            if st == 0
+                fprintf(' found %s\n',vers(1:strfind(vers,sprintf('\n'))-1));
+            else
+                fprintf(2,'latex not found!\nA LaTeX installation available on the system path is strongly recommended with mtoc++.\n');
+            end
+            % Ghostscript
+            fprintf('[Recommended] Checking for ghostscript... ');
+            if ispc
+                [st, vers] = system('gswin32c --version');
+                if st ~= 0
+                    [st, vers] = system('gswin64c --version');
+                end
+            else
+                [st, vers] = system('gs --version');
+            end
+            if st == 0
+                fprintf(' found %s\n',vers(1:strfind(vers,sprintf('\n'))-1));
+            else
+                fprintf(2,'ghostscript not found!\nCreating LaTeX formulas might not work properly.\n');
+            end
+
+            if ~hasall
+                fprintf(2,'Please make sure all prerequisites can be found on PATH or copy the executables into %s.\n',confdir);
+                fprintf('<<<< MatlabDocMaker setup finished with warnings. >>>>\n');
+            else
+                fprintf('<<<< MatlabDocMaker setup successful. >>>>\nYou can now create your projects documentation by running <a href="matlab:MatlabDocMaker.create(''open'',true)">MatlabDocMaker.create</a>!\n');
+            end
+        end
+    end
+    
+    methods(Static, Access=private)
+        function value = getProjPrefTag
+            % Gets the tag for the MatLab preferences struct.
+            % 
+            % @change{0,7,dw,2013-04-02} Now also removing "~" and "-" characters from ProjectName tags for preferences.
+            str = regexprep(strrep(strtrim(MatlabDocMaker.getProjectName),' ','_'),'[^\d\w]','');
+            value = sprintf('MatlabDocMaker_on_%s',str);
+        end
+        
+        function value = getPref(name, default)
+            if nargin < 2
+                def = [];
+            else 
+                def = default;
+            end
+            value = getpref(MatlabDocMaker.getProjPrefTag,name,def);
+            if nargin < 2 && isempty(value)
+                error('MatlabDocMaker preferences not found/set correctly. (Re-)Run the MatlabDocMaker.setup method.');
+            end
+        end
+        
+        function value = setPref(name, value)
+            setpref(MatlabDocMaker.getProjPrefTag,name,value);
+        end
+    end
+end
diff --git a/Requirements/PESTO-1.1.0/doc/config/Doxyfile.template b/Requirements/PESTO-1.1.0/doc/config/Doxyfile.template
new file mode 100644
index 0000000000000000000000000000000000000000..ddbd3e441f55d9471a0ce1a1fa256e8442378ce9
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/config/Doxyfile.template
@@ -0,0 +1,2484 @@
+############################################################################
+
+# Doxyfile 1.8.11
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all text
+# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
+# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
+# for the list of possible encodings.
+# The default value is: UTF-8.
+
+############################################################################
+############################################################################
+################# mtoc++ related information ###############################
+############################################################################
+###########################################################################
+################## List of changes: #######################################
+################################################################################
+############### DEFAULT (DOXYGEN ONLY) CONFIGURATION ###########################
+################################################################################
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+############### MTOC++ RELATED CONFIGURATION ###################################
+################################################################################
+
+PROJECT_NAME           = "_ProjectName_"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         = _ProjectVersion_
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "_ProjectDescription_"
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           = "_ProjectLogo_"
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = "_OutputDir_"
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines.
+
+ALIASES                = "synupdate=\xrefitem synupdate \"Syntax Update\" \"Syntax needs to be updated\"" \
+                         "docupdate=\xrefitem docupdate \"Documentation Update\" \"Documentation needs to be updated\"" \
+                         "event=\xrefitem event \"Events\" \"List of all Events\"" \
+                         "default=\par Default:\n" \
+                         "type=<br><b>Type</b>: " \
+                         "changexref{2}=\xrefitem changelog\1_\2 \"Change in \1.\2\" \"Changes in _ProjectName_ Version \1.\2\"" \
+                         "change{4} = \changexref{\1,\2} (\ref \3, \4) " \
+                         "change{3} = \changexref{\1,\2} (\ref \3, undated) " \
+                         "newxref{2}=\xrefitem newfeat\1_\2 \"New in \1.\2\" \"New features in _ProjectName_ Version \1.\2\"" \
+                         "new{4} = \newxref{\1,\2} (\ref \3, \4) " \
+                         "new{3} = \newxref{\1,\2} (\ref \3, undated) " \
+                         "propclass{1}=\xrefitem propclass_\1 \"Property class \1\" \"Properties with level \1\""
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = YES
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
+# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
+# Fortran. In the later case the parser tries to guess whether the code is fixed
+# or free formatted code, this is the default for Fortran type files), VHDL. For
+# instance to make doxygen treat .inc files as Fortran files (default is PHP),
+# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+############### CRITICAL MTOC++ RELATED CONFIGURATION ##########################
+################################################################################
+
+EXTENSION_MAPPING      = .m=C++
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# (class|struct|union) declarations. If set to NO, these declarations will be
+# included in the documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES, upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = YES
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = YES
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = "_SourceDir_" \
+                         "_ConfDir_"
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: http://www.gnu.org/software/libiconv) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f, *.for, *.tcl,
+# *.vhd, *.vhdl, *.ucf, *.qsf, *.as and *.js.
+
+FILE_PATTERNS          = *.m \
+                         *.c \
+                         *.cc \
+                         *.cpp \
+                         *.mex \
+                         *.h \
+                         *.hh \
+                         *.hpp \
+                         *.dox \
+                         *.md
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                = doc/MatlabDocMaker.m \
+                         doc/config \
+                         doc/images \
+                         doc/out \
+                         DRAM \
+                         private \
+                         tests \
+                         README.md
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = YES
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = */examples/*/* \
+                         */examples/*.m
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             = doc/images  
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        = "*.m=_MTOCFILTER_"
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = YES
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE = doc/documentation.md
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# function all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see http://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse-libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = NO
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = "_OutputDir_"
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: http://developer.apple.com/tools/xcode/), introduced with
+# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "_ProjectName_ documentation"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = _ProjectName_._ProjectVersion_
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = _ProjectName_
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the master .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = ALL
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: http://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = _GenLatex_
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when enabling USE_PDFLATEX this option is only used for generating
+# bitmaps for formulas in the HTML output, but not in the Makefile that is
+# written to the output directory.
+# The default file is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = YES
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         = "_LatexExtras_"
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = YES
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's config
+# file, i.e. a series of assignments. You only have to provide replacements,
+# missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's config file. A template extensions file can be generated
+# using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sf.net) file that captures the
+# structure of the code including all documentation. Note that this feature is
+# still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             = LATEX_OUTPUT=1
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see:
+# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = _HaveDot_
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/Requirements/PESTO-1.1.0/doc/config/Doxyfile.template.bak b/Requirements/PESTO-1.1.0/doc/config/Doxyfile.template.bak
new file mode 100644
index 0000000000000000000000000000000000000000..fd82086fb0056796c33ccf92a2e0d7fd7b30ebb3
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/config/Doxyfile.template.bak
@@ -0,0 +1,1808 @@
+############################################################################
+# DOXYGEN CONFIGURATION FILE TEMPLATE (Doxygen version => 1.8.2)
+############################################################################
+#
+# IMPORTANT NOTICE: This file is included with the tool "mtoc++", and contains some changes
+# in order to make mtoc++ run together with doxygen. The settings in this file are a default
+# configuration for Doxygen which we thought might be useful in a MatLab setting/project.
+# USING MTOC++ DOES NOT EXCLUDE THE REQUIREMENT TO KNOW AND UNDERSTAND DOXYGEN ITSELF!
+# We've had lots of feedback and problem reports which actually had to do with settings purely
+# regarding doxygen, so we strongly recommend having a look through this file before contacting
+# us. Thanks!
+#
+############################################################################
+################# mtoc++ related information ###############################
+############################################################################
+# Feel free to make any changes within this doxygen configuration file to 
+# taylor the output towards your needs. Any changes made by us to the doxygen
+# config file in order to have mtoc++ running smoothly have been moved to the
+# END of the file in order to easily keep custom changes over new mtoc++ versions.
+#
+# Depending on the output preferred style, checkout the 
+# OPTIMIZE_OUTPUT_FOR_C and OPTIMIZE_OUTPUT_FOR_JAVA settings.
+#
+# Most importantly, this file gets processed (when using our tools, e.g. 
+# MatlabDocMaker) in order to replace some values:
+# - _ProjectName_: The project name configured in the tools
+#       (in MatlabDocMaker:MatlabDocMaker.getProjectVersion) 
+# - _ProjectVersion_: Is substituted by the value returned by 
+#       MatlabDocMaker.getProjectVersion inside MatLab. We decided to keep
+#       this flexible as project versions change over time and the documentation
+#       should of course reflect that with minimum effort (thus, only a change
+#       inside Matlab is necessary, where you're expected to be working anyways)
+# - _ProjectDescription_: A short description of the project
+# - _ProjectLogo_: An absolute path to an image file to include as project logo
+# - _OutputDir_: The output directory for the created documentation
+# - _SourceDir_: The source directory containing the files of the project
+# - _ConfDir_: The configuration directory for mtoc++, containing this file
+#       and some more.
+# - _FileSep_: The file separator character, "/" for linux and "\" for windows.
+# - _GenLatex_: Switch to tell doxygen to also generate LaTeX output.
+# - _HaveDot_: "YES" or "NO" depending on automatic GraphViz detection on MatlabDocMaker.create
+# Use these tags wherever you would insert the respective values.
+#
+# Furthermore, there are some settings that are included as convenience
+# (e.g. the @new tags) that can be removed (but will likely cause errors if
+# done wrongly). Check the ALIASES setting in the doxygen documentation.
+#
+# We recommend to leave
+# EXTRACT_PRIVATE   = NO
+# if you make extensive use of classes as these methods are of course not
+# thought to be public (cunning, isn't it?) and blow up the documentation.
+#
+# Last, have a look at DOCSET_FEEDNAME and DOCSET_BUNDLE_ID.
+#
+# Enjoy!
+#
+###########################################################################
+################## List of changes: #######################################
+#
+# mtoc++ 1.4: - Updated the doxyfile config to version 1.8.
+#             - Added placeholders for project description and logo
+#             - Set SOURCE_BROWSER = YES and FILTER_SOURCE_FILES = YES in
+#               order to have automatic inclusion of call graphs in the generated documentation.
+#             - Set EXLUDE_SYMLINKS = YES as default
+#
+# mtoc++ 1.4: - Added alias for an @events tag, creating a page of all events
+#			  - Changed naming convention for alias-tags new and change as newer doxygen
+#               versions seem not to recognize \1\2-like combinations of arguments any more (?)
+#               now pages named "newfeat\1_\2" with underscore are created, please update your static
+#               references in your misc documentation files
+#
+# mtoc++ 1.3: - Changed the default value of SHOW_FILES to YES in order to avoid more
+#               confusion about what mtoc++ actually does (NOT replacing the 
+#               requirement to know doxygen)
+#             - Included a warning in the beginning of this file
+#
+# mtoc++ 1.3: Included a new placeholder "_FILESEP_", as doxygen itself can manage
+#             using only "/" as file separator, however, the EXTRA_PACKAGES command
+#             leads to an inclusion line inside latex, which is not that tolerant.
+#
+# mtoc++ 1.2: Restructured this file during tests for Windows doc creation.
+#             - Config stuff is now at the END of the file.
+#             - New macro _MTOCFILTER_ for .sh and .bat file support.
+#
+# mtoc++ 1.2: First version to contain this file.
+#
+################################################################################
+
+############### DEFAULT (DOXYGEN ONLY) CONFIGURATION ###########################
+# The following settings can be adjusted to customize doxygen's behaviour and 
+# hence the output when using the tools like MatlabDocMaker
+################################################################################
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a hash (#) is considered a comment and will be ignored.
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ").
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding
+# "class=itcl::class" will allow you to use the command class in the
+# itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = YES
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
+# comments according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you
+# can mix doxygen, HTML, and XML commands with Markdown formatting.
+# Disable only in case of backward compatibilities issues.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented classes,
+# or namespaces to their corresponding documentation. Such a link can be
+# prevented in individual cases by by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penalty.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will roughly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE      = 0
+
+# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
+# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
+# their name and scope. Since this can be an expensive process and often the
+# same symbol appear multiple times in the code, doxygen keeps a cache of
+# pre-resolved symbols. If the cache is too small doxygen will become slower.
+# If the cache is too large, memory is wasted. The cache size is given by this
+# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = YES
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES   = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = YES
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page.
+# This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE            =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC       = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS       = YES
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output.
+# If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER           =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = YES
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code.
+# Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+# See on bottom of file for mtoc++ related HTML settings.
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+# for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is adviced to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the stylesheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME        = "_ProjectName_ documentation"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = _ProjectName_._ProjectVersion_
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = _ProjectName_
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE               =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING     =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+#  will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = ALL
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the
+# mathjax.org site, so you can quickly see the result without installing
+# MathJax, but it is strongly recommended to install a local copy of MathJax
+# before deployment.
+
+MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvantages are that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX          = YES
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER           =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE      = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA             =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD                =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader.
+# This is useful
+# if you want to understand what is going on.
+# On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED             = LATEX_OUTPUT=1
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+#
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+#
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH            =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will write a font called Helvetica to the output
+# directory and reference it in all dot files that doxygen generates.
+# When you want a differently looking font you can specify the font name
+# using DOT_FONTNAME. You need to make sure dot is able to find the font,
+# which can be done by putting it in a standard location or by setting the
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
+# containing the font.
+
+DOT_FONTNAME           = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the output directory to look for the
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a
+# different font using DOT_FONTNAME you can set the path where dot
+# can find it using this tag.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = YES
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS           =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = YES
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = YES
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP            = YES
+
+############### MTOC++ RELATED CONFIGURATION ###################################
+# The following are set by us or the tools (MatlabDocMaker) and should be 
+# changed with care in order to keep mtoc++ running
+################################################################################
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = "_ProjectName_"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER         = _ProjectVersion_
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "_ProjectDescription_"
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+# Recall that you can use all the macros like _ConfDir_ at this setting, too.
+
+PROJECT_LOGO           = "_ProjectLogo_"
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = "_OutputDir_"
+
+# What to generate? HTML by default, directly into _OutputDir_
+GENERATE_HTML          = YES
+HTML_OUTPUT            = "_OutputDir_"
+
+# Latex is an extra option.
+GENERATE_LATEX         = _GenLatex_
+
+# NO causes LaTeX to stop when errors occur
+LATEX_BATCHMODE        = YES
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = "synupdate=\xrefitem synupdate \"Syntax Update\" \"Syntax needs to be updated\"" \
+                         "docupdate=\xrefitem docupdate \"Documentation Update\" \"Documentation needs to be updated\"" \
+                         "event=\xrefitem event \"Events\" \"List of all Events\"" \
+                         "default=\par Default:\n" \
+                         "type=<br><b>Type</b>: " \
+                         "changexref{2}=\xrefitem changelog\1_\2 \"Change in \1.\2\" \"Changes in _ProjectName_ Version \1.\2\"" \
+                         "change{4} = \changexref{\1,\2} (\ref \3, \4) " \
+                         "change{3} = \changexref{\1,\2} (\ref \3, undated) " \
+                         "newxref{2}=\xrefitem newfeat\1_\2 \"New in \1.\2\" \"New features in _ProjectName_ Version \1.\2\"" \
+                         "new{4} = \newxref{\1,\2} (\ref \3, \4) " \
+                         "new{3} = \newxref{\1,\2} (\ref \3, undated) " \
+                         "propclass{1}=\xrefitem propclass_\1 \"Property class \1\" \"Properties with level \1\""
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = _HaveDot_
+                         
+############### CRITICAL MTOC++ RELATED CONFIGURATION ##########################
+# The following tags should NOT be changed in order to keep mtoc++ running
+################################################################################
+
+# assign C++-styled code interpretion to .m files
+EXTENSION_MAPPING = .m=C++
+
+# input is configured by MatlabDocMaker
+INPUT             = "_SourceDir_" "_ConfDir_"
+
+# doxygen bothers to look at .m files at all
+FILE_PATTERNS     = *.m \
+                    *.c \
+                    *.cc \
+                    *.cpp \
+                    *.mex \
+                    *.h \
+                    *.hh \
+                    *.hpp \
+
+# the link between mtoc++ and doxygen (the `' separates the macros)
+FILTER_PATTERNS   = *.m="_MTOCFILTER_"
+
+# latex styles inclusion file
+EXTRA_PACKAGES    = "_LatexExtras_"
+
+# leave empty so MatlabDocMaker can capture doxygen warnings
+WARN_LOGFILE      = 
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/doc/config/latexextras.template b/Requirements/PESTO-1.1.0/doc/config/latexextras.template
new file mode 100644
index 0000000000000000000000000000000000000000..5157945ff188e936b863b7bf13d60de19ad8ae55
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/config/latexextras.template
@@ -0,0 +1,15 @@
+% Additional LaTeX inclusions for mtoc++/doxygen tools
+%
+% Use the _ConfDir_ tag to insert the folder where this file resides.
+% Thus you can include more custom latex files/styles/packages which reside in this folder  
+
+% Default packages
+\usepackage{amsmath}
+\usepackage{amssymb}
+%\usepackage{amsfonts}
+%\usepackage{subfig}
+%\usepackage{bbm}
+
+% Inclusion example:
+% Please note that, independent of windows or unix, latex uses forward-slash-type paths in bibliography.
+%\input{_ConfDirFwdSlash_/myexternalstyle.sty}
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/doc/config/mtocpp b/Requirements/PESTO-1.1.0/doc/config/mtocpp
new file mode 100644
index 0000000000000000000000000000000000000000..abdcf3302169f9fbbe2f5bdb07036981d665941d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/config/mtocpp
@@ -0,0 +1 @@
+/usr/local/mtocpp/bin/mtocpp
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/doc/config/mtocpp.conf b/Requirements/PESTO-1.1.0/doc/config/mtocpp.conf
new file mode 100644
index 0000000000000000000000000000000000000000..114dfd65600e15b52b94fa4c7778b167bbd9c914
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/config/mtocpp.conf
@@ -0,0 +1,107 @@
+# ########################### mtoc++ configuration file ############################
+# This configuration file is not mandatory.
+# All default values are also hardcoded in mtocpp.
+
+# ########################### mtoc++ variables ############################
+# File Patterns
+ALL := *.m;
+
+# Flag indicating whether automatic struct fields or object members
+# documentation is generated.
+# The fields documentation types are
+#  - required fields,
+#  - optional fields and
+#  - generated fields.
+# PRINT_FIELDS := true;
+
+# Flag indicating whether undocumented field names are added to documentation
+# with documentation text equal to the field name.
+# AUTO_ADD_FIELDS := false;
+
+# Flag indicating whether undocumented parameters and return values are added
+# to documentation with documentation text equal to the parameter / return
+# value name.
+# AUTO_ADD_PARAMETERS := false;
+
+# Flag indicating whether undocumented member variables are added to
+# documentation with documentation text equal to the parameter / return value
+# name.
+# AUTO_ADD_CLASS_PROPERTIES := false;
+
+# Flag indicating whether undocumented classes are added to documentation with
+# documentation text equal to the class name.
+# AUTO_ADD_CLASSES := true;
+
+# Flag indication whether the first argument in abstract non-static methods
+# shall be a this pointer, and therefore removed in the C++ output.
+# REMOVE_FIRST_ARG_IN_ABSTRACT_METHODS := true
+
+# Flag indicating whether the string "of type" is parsed in the the first two
+# lines
+#   - of the documentation header of properties and
+#   - the documentation block of method/function parameters and return values.
+# If enabled, the word following the string "of type" is interpreted as the
+# type for the class property, the parameter or the return value. This
+# equivalent to using the mtocpp @type keyword, but enables the user to write
+# documentation also read-able in doc strings created with the MATLAB commands
+# 'help' or 'doc'.
+# ENABLE_OF_TYPE_PARSING := true;
+
+# Flag indicating whether the typename void shall be inserted for return values
+# with no specified type. If this is not set to true, the typename is
+# eliminated in the output by the postprocessor.
+# VOID_TYPE_IN_RETURN_VALUES := false;
+
+# Integer flag indicating whether return value names shall be printed in the
+# function synopsis. If this flag is deactivated only the type names are
+# written.
+# The flag can be set to either 0, 1 or 2:
+#   - 0: means that no return value names shall be printed at all.
+#   - 1: means that return value names shall be printed for return value lists
+#        with more than one element only.
+#   - 2: means that return value names shall be printed always.
+# PRINT_RETURN_VALUE_NAME := 2;
+
+# Flag indicating whether the documentation of fields in 'Required fields of param',
+# 'Optional fields of param' or 'Generated fields of retval' shall be copied,
+# in case the Parameter 'param' or 'retval' have a type.
+# COPY_TYPIFIED_FIELD_DOCU := false;
+
+# Flag indicating whether  documentation for subfunctions shall be generated.
+# By default their documentation strings are ignored.
+# GENERATE_SUBFUNTION_DOCUMENTATION := false;
+
+# Leave this ## there, it marks the end of variable definitions 
+# and switches the parser to mtoc++ rules!
+## 
+
+# ########################### mtoc++ rules ############################
+
+# ###############################################################
+# Default documentation for parameters
+# ###############################################################
+# Syntax:
+# add(params) = <pname> => """ <text> """;
+
+# ###############################################################
+# Default documentation for fields
+# ###############################################################
+# Syntax:
+# add(fields) = ( <pname>.<fieldname1> => """ <text1> """,
+#                 <pname>.<fieldname2> => """ <text2> """);
+
+# ###############################################################
+# Global group settings
+# ###############################################################
+# Syntax:
+# glob = <folder or filename (regexp allowed)> {
+#  groups = <groupref>;
+#  add(doc)      = """ <some extra doc for all files> """;
+#  add(extra)    = """ <text at end of comments> """;
+#  glob = <subfolder or files> {
+#    <statements>
+#  };
+# }
+ 
+# add(doc)      = """ docu for all functions !!! """;
+# add(extra)    = """ extra comments: @ref s_rand !!!! """;
diff --git a/Requirements/PESTO-1.1.0/doc/documentation.md b/Requirements/PESTO-1.1.0/doc/documentation.md
new file mode 100644
index 0000000000000000000000000000000000000000..e07418cede9173091afe956e7d5e2b969257c66a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/doc/documentation.md
@@ -0,0 +1,159 @@
+PESTO Documentation {#doc}
+===================
+
+# Introduction         {#intro}
+
+Computational models are commonly used in diverse disciplines such as computational biology, engineering, or meteorology. The parameterization of the these models is usually based on measurements or observations. The process of inferring model parameters from such data is called model calibration or parameter estimation. This parameter estimation is often not straightforward due to non-linearities in the model equations or due to the mere size and the resulting computational challenges. Therefore, efficient algorithms are required to provide robust results within acceptable time.
+
+PESTO is a freely available Parameter EStimation TOolbox for MATLAB (MathWorks) implementing a number of state-of-the-art algorithms for parameter estimation. It provides the following features, which are explained in more detail [below](@ref features):
+
+* Parameter estimation from measurement data by global optimization based on multi-start local optimization (some algorithms require the [MATLAB Optimization Toolbox](https://de.mathworks.com/products/optimization/)) 
+* Parameter sampling using Markov Chain Monte Carlo (MCMC) algorithms
+* Uncertainty analysis based on local approximations, parameter samples and profile-likelihood analysis (some algorithms require the  [MATLAB Optimization Toolbox](https://de.mathworks.com/products/optimization/)) 
+* Visualization routines for all analyses
+* Parallel processing (requires [MATLAB Parallel Computing Toolbox](https://mathworks.com/products/parallel-computing/)) 
+* ...
+
+PESTO functions can be applied to any user-provided formulation of an optimization problem with an objective function that can be evaluated in MATLAB. Besides the objective function, upper and lower bounds for the function parameters need to be specified.
+
+# Availability         {#availability}
+
+PESTO can be freely obtained from https://github.com/ICB-DCM/PESTO/ by downloading the zip archive at https://github.com/ICB-DCM/PESTO/archive/master.zip or cloning the `git` repository via
+```
+git clone git@github.com:ICB-DCM/PESTO.git
+```
+
+# Installation         {#installation}
+
+If the zip archive was downloaded, it needs to be unzipped and the main folder has to be added to the MATLAB search path (non-recursively). 
+
+If the repository was cloned, the main folder needs to be added to the MATLAB search path (non-recursively).
+
+*Note:* Detailed instructions on how to modify your MATLAB search path are provided on the [web](https://de.mathworks.com/help/matlab/matlab_env/add-remove-or-reorder-folders-on-the-search-path.html).
+
+## Third-party packages
+
+PESTO provides an interfaces to several other toolboxes which are not included in the PESTO archive:
+
+* PSwarm (optimizer): http://www.norg.uminho.pt/aivaz/pswarm/
+* MEIGO (optimizer): http://gingproc.iim.csic.es/meigo.html
+* DRAM (MCMC): http://helios.fmi.fi/~lainema/dram/
+
+To use their functionality, these toolboxes have to be installed separately. Please consult the respective user manuals for details.
+
+# Licensing         {#licensing}
+
+See ```LICENSE``` file in the PESTO source directory.
+
+# How to cite         {#citation}
+
+This section will be updated upon publication of PESTO.
+
+# Code organization         {#org}
+
+The end-user interface is provided by the MATLAB functions and classes in the top-level directory. PESTO [example](@ref examples) applications are provided in `/examples/`. All other folders only contain files used internally in PESTO.
+
+# Features ## {#features}
+
+PESTO implements a number of state-of-the-art algorithms related to parameter estimation. The main features are described below. Various [examples](@ref examples) demonstrate their application.
+
+## Notations and Terminology
+
+Since most of the examples use analytical approaches for computing the gradient of the respective objective function, which quantifies the deviation of the fit for the current model parameters from the actual measurement data, the usage of the term ‚sensitivity analysis‘ may be misleading. In our context, ‚sensitivity analysis‘ is used in the context of ODE or PDE models and describes the sensitivity of the ODE/PDE state with respect to the model parameters. Those state sensitivities can be implemented in the ODE/PDE system and then used for an analytical calculation of the sensitivity of the objective function. This objective functions sensitivity will always be called the objective function gradient in our context. Finally, the behavior of the objective function by the variation of single parameters in order to find possible (non-)identifiabilities will always be referred to as ‚uncertainty analysis‘.
+
+## Global optimization ### {#global-optimization}
+
+Non-linear optimization problems like those in parameter estimation problems tend to have multiple optima. Usually, nothing is known beforehand about their number or their location, but the user is interested in finding the global optimum. 
+There are different techniques for this kind of problem. PESTO provides a multi-start local optimization framework and provides an interface to two global optimizers.
+
+### Multi-start local optimization
+
+Multi-start local optimization has turned out to be a very efficient method for "global optimization": Here, random points from across the parameter space are chosen as starting points for local optimization. 
+If an adequate number of starting points spanning the domain of interest of the parameter space is selected, the lowest/highest minimum/maximum is accepted to be the global minimum/maximum. By default, ```fmincon``` from the MATLAB optimization toolbox is used as a local solver.
+
+Multi-start local optimization functionality is provided by getMultiStarts.m, getPropertyMultiStarts.m and the respective plotting routines plotMultiStarts.m and plotPropertyMultiStarts.m.
+See examples/conversion_reaction/mainConversionReaction.m for an example.
+
+### Global optimizers
+
+PESTO provides an interface to [PSwarm](http://www.norg.uminho.pt/aivaz/pswarm/) and [MEIGO](http://gingproc.iim.csic.es/meigo.html). Once these toolboxes have been installed - they are not included in the PESTO archive - 
+they can be used for parameter estimation. 
+These optimizers are also accessed via getMultiStarts.m by setting PestoOptions::localOptimizer and PestoOptions::localOptimizerOptions accordingly. 
+In principle, a single optimizer run (PestoOptions::n_starts = 1) should be enough for these global optimizers.
+
+An example of both global optimizers is included in mainConversionReaction.m, another example for PSwarm in mainTransfection.m and an additional example for MEIGO can be found in mainEnzymaticCatalysis.m.
+
+## Uncertainty analysis ### {#uncertainty-analysis}
+
+When parameters are inferred from measurement data, the deviation of the data from the fit for the best parameter guess is usually assumed to be of stochastic nature. This means that the estimated parameters themselves are stochastic and underly an uncertainty. This can be quantified by performing uncertainty analysis and computing confidence intervals.
+
+The easiest way to do this is using local approximations (based on the Hessian matrix of the objective function) at the best parameter guess. From those approximations, either threshold-based or mass-based methods can be used to compute confidence intervals for the inferred parameters. Another more reliable approach uses sampling based methods in combination with local approximations. It is described in more detail in the next section.
+
+The probably most reliable way to compute confidence intervals is a third approach, based on profile likelihoods. There are two different ways to compute them: In the classical optimization based approach, each model parameter is varied separately while the others are constantly reoptimized. In this way one finds profiles for every parameter. A more recent approach uses an ODE, which follows the path in parameter space which describes the profile. After the profile computation, one fixes a confidence level using the inverse chi-squared-distribution to get a threshold. This threshold, together with the profile likelihood, gives reliable confidence intervals for each parameter. In this way, non-identifiable parameters can be detected.
+
+Those functionalities are provided in getParameterProfiles.m, getPropertyProfiles.m (for the profile likelihoods), getParameterConfidenceIntervals.m and getPropertyConfidenceIntervals.m (for the confidence intervals). In order to get confidence intervals based on local approximations or sampling methods, one needs to run the routines getMultiStarts.m / getPropertyMultiStarts.m or getParameterSamples.m / getPropertySamples.m first. The respective visualization routines are plotParameterProfiles.m and plotPropertyProfiles.m.
+Examples for profile likelihoods can be found in mainConversionReaction.m and mainExampleRing.m (optimization based), mainEnzymaticCatalysis.m (integration based) and mainTransfection.m (a mixture of both).
+
+## Parameter sampling ### {#parameter-sampling}
+
+PESTO provides Markov Chain Monte Carlo (MCMC) algorithms for sampling the posterior distribution. Currently, two multi-chain methods (which can also be used in single-chain mode) and two additional single-chain methods can be chosen. The two multi-chain methods are [parallel tempering (PT)](https://en.wikipedia.org/wiki/Parallel_tempering), which is based on an adaptive version of the [Metropolis-Hastings algorithm (MH)](https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm), and [parallel hierarchical sampling (PHS)](https://arxiv.org/abs/0812.1484). For further single-chain sampling, also [Metropolis-adjusted Langevin algorithm (MALA)](https://en.wikipedia.org/wiki/Metropolis-adjusted_Langevin_algorithm) can be chosen. Additionally, PESTO provides an interface to the [Delayed Rejection Adaptive Metropolis (DRAM)](http://helios.fmi.fi/~lainema/dram/) toolbox.
+
+Details on the recommended settings can be found in PestoSamplingOptions.m and the corresponding option files for each algorithm. Examples for the algorithms can be found in mainConversionReaction.m (PT as single-chain algorithm), mainEnzymaticCatalysis.m (PT as multi-chain algorithm), mainTransfection.m (PHS as multi-chain algorithm) and mainExampleRing.m and mainExampleGauss.m (all algorithms, respectively).
+
+## Plotting ### {#plotting}
+
+An integral part of PESTO are its highly customizable plotting functions for each type of analysis.
+
+Details are provided in the documentation of the specific plotting functions:
+* plotMultiStarts.m
+* plotParameterProfiles.m
+* plotParameterSamples.m
+* plotParameterUncertainty.m
+* plotPropertyMultiStarts.m
+* plotPropertyProfiles.m
+* plotPropertySamples.m
+* plotPropertyUncertainty.m
+
+Here some examples: 
+
+Plot of model fit using plotMultiStarts.m:
+![](fig_fit.jpg "Plot of model fit using plotMultiStarts.m")
+@image latex "fig_fit.jpg" "Plot of model fit using plotMultiStarts.m" width=0.6\textwidth
+
+Plot of different variants of parameter confidence intervals using plotParameterUncertainty.m:
+![](fig_par_confint.jpg "Plot of different variants of parameter confidence intervals using plotParameterUncertainty.m")
+@image latex "fig_par_confint.jpg" "Plot of different variants of parameter confidence intervals using plotParameterUncertainty.m" width=0.7\textwidth
+
+2D plot of parameter samples using plotParameterSamples.m:
+![](fig_par_samples2d.jpg "2D plot of parameter samples using plotParameterSamples.m")
+@image latex "fig_par_samples2d.jpg" "2D plot of parameter samples using plotParameterSamples.m" width=0.7\textwidth
+
+Plot of parameter samples using plotParameterSamples.m:
+![](fig_par_samples.jpg "Plot of parameter samples using plotParameterSamples.m")
+@image latex "fig_par_samples.jpg" "Plot of parameter samples using plotParameterSamples.m" width=0.6\textwidth
+
+Plot of property samples using plotPropertySamples.m:
+![](fig_prop_samples.jpg "Plot of property samples using plotPropertySamples.m")
+@image latex "fig_prop_samples.jpg" "Plot of property samples using plotPropertySamples.m" width=0.6\textwidth
+
+See mainConversionReaction.m for live examples.
+
+## Properties ### {#properties}
+
+The above-mentioned methods for parameter estimation, confidence intervals, parameter profiles and parameter samples (getMultiStarts.m, getParameterConfidenceIntervals.m,
+getParameterProfiles.m, getParameterSamples.m) all operate on the objective function parameters  directly. However, sometimes not the parameters themselves, but some function thereof is of interest. 
+To this end, PESTO provides a simple interface to achieve this without having to change the objective function. Arbitrary user-provided functions which take the objective function parameter vector as an argument 
+are referred to as `properties'. After having used any of the getParameter*.m functions, the respective getProperty*.m function can be called, to evaluate a user-provided property function with 
+the parameters values/samples/confidences obtained from the getParameter*.m functions.
+
+The following functions are available to analyze and plot properties:
+* getPropertyConfidenceIntervals.m
+* getPropertyMultiStarts.m
+* getPropertyProfiles.m
+* getPropertySamples.m
+* plotPropertyMultiStarts.m
+* plotPropertyProfiles.m
+* plotPropertySamples.m
+* plotPropertyUncertainty.m
+
+See mainConversionReaction.m for examples.
diff --git a/Requirements/PESTO-1.1.0/doc/images/fig_fit.jpg b/Requirements/PESTO-1.1.0/doc/images/fig_fit.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e1e894625ea28933d0dec1f51ae138bdeebc2e79
Binary files /dev/null and b/Requirements/PESTO-1.1.0/doc/images/fig_fit.jpg differ
diff --git a/Requirements/PESTO-1.1.0/doc/images/fig_par_confint.jpg b/Requirements/PESTO-1.1.0/doc/images/fig_par_confint.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b33d7b6f83f40f81268aff399fdb5f4dc3f99cb2
Binary files /dev/null and b/Requirements/PESTO-1.1.0/doc/images/fig_par_confint.jpg differ
diff --git a/Requirements/PESTO-1.1.0/doc/images/fig_par_samples.jpg b/Requirements/PESTO-1.1.0/doc/images/fig_par_samples.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..2c63b46c7ee4fe6eedcb695c531500cddf7809ae
Binary files /dev/null and b/Requirements/PESTO-1.1.0/doc/images/fig_par_samples.jpg differ
diff --git a/Requirements/PESTO-1.1.0/doc/images/fig_par_samples2d.jpg b/Requirements/PESTO-1.1.0/doc/images/fig_par_samples2d.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..818d6661bb88089fe76a4173b348017083a7eb7d
Binary files /dev/null and b/Requirements/PESTO-1.1.0/doc/images/fig_par_samples2d.jpg differ
diff --git a/Requirements/PESTO-1.1.0/doc/images/fig_prop_samples.jpg b/Requirements/PESTO-1.1.0/doc/images/fig_prop_samples.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..52dbc4b89f2a5d264f5d51db9e12a465526ece8f
Binary files /dev/null and b/Requirements/PESTO-1.1.0/doc/images/fig_prop_samples.jpg differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/data/data_Bachmann.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/data/data_Bachmann.mat
new file mode 100644
index 0000000000000000000000000000000000000000..7e409311e83e35f8f4b1b6bbc9cfc40a936d075f
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/data/data_Bachmann.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/getOffsetScalingStd_Bachmann.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/getOffsetScalingStd_Bachmann.m
new file mode 100644
index 0000000000000000000000000000000000000000..c716f064a14fa6fbc06cb1ab3d9e42fc8268994f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/getOffsetScalingStd_Bachmann.m
@@ -0,0 +1,102 @@
+function D = getOffsetScalingStd_Bachmann(D)
+% getOffsetScalingStd_Bachmann() maps the offset, scaling and variance 
+% parameters to the corresponding conditions
+
+
+
+for cond = 1:36
+    D(cond).offset = nan(20,1);
+    D(cond).scaling = nan(20,1);
+    D(cond).std = [106; 106; 105; 111;
+        113; 113; 112; 108; 104;
+        110; 114; 107; 107; 107;
+        107; 107; 107 ;109; 105; 105]; % same for all conditions
+end
+
+% long
+D(1).offset([1:4,6]) = [52 44 32 36 58];
+D(1).scaling(1:6) = [92 84 68 76 102 98];
+D(1).name = 'long';
+
+% Concentration
+D(2).offset(11) = [57];
+D(2).name = 'Concentration';
+
+% RNA
+%D(3).offset([12:17]) = 1 �berall
+D(3).scaling([12:17]) = [72 73 74 63 64 65];
+D(3).name = 'RNA';
+
+% Act
+D(4).offset([1,2,3,6]) = [47 38 30 55];
+D(4).scaling([1,2,3,5,6]) = [87 78 66 101 95];
+D(5).offset = D(4).offset;
+D(5).scaling = D(4).scaling;
+D(4).name = 'ActD';
+D(5).name = 'ActD';
+
+% Fine
+D(6).offset([1,2]) = [51 43];
+D(6).scaling([1,2]) = [91 83];
+D(6).name = 'Fine';
+
+% CIsoe
+D(7).offset([1,2,3,4,6]) = [48 39 31 35 56];
+D(7).scaling([1,2,3,4,6]) = [88 79 67 75 96];
+D(8).offset = D(7).offset;
+D(8).scaling = D(7).scaling;
+D(7).name = 'CISoe';
+D(8).name = 'CISoe';
+
+% CISoe_pEpoR
+D(9).offset(2) = [40];
+D(9).scaling(2) = [80];
+D(10).offset = D(9).offset;
+D(10).scaling = D(9).scaling;
+D(9).name = 'CISoe_pEpoR';
+D(10).name = 'CISoe_pEpoR';
+
+% SOCS3oe
+D(11).offset([1,2,3,4,6]) = [54 46 34 37 60];
+D(11).scaling([1,2,3,4,6]) = [94 86 70 77 100];
+D(12).offset = D(11).offset;
+D(12).scaling = D(11).scaling;
+D(11).name = 'SOCS3oe';
+D(12).name = 'SOCS3oe';
+
+% SHP1oe
+D(13).offset([1 2 3  6 ]) = [53 45 33 59 ];
+D(13).scaling([1 2 3 5 6 18]) = [93 85 69 103 99 71];
+D(14).offset = D(13).offset;
+D(14).scaling = D(13).scaling;
+D(13).name = 'SHP1oe';
+D(14).name = 'SHP1oe';
+
+% DR 7 min -> group 1
+for cond = [15:19]
+    D(cond).offset([1,2]) = [50 42];
+    D(cond).scaling([1,2]) = [90 82];
+    D(cond).name = 'dose response 7 min';
+end
+% DR 10 min -> group 2
+for cond = [26:31]
+    D(cond).scaling([6]) = [97];
+    D(cond).name = 'dose response 10 min';
+end
+% DR 30 min -> group 3
+for cond = [20:25]
+    D(cond).offset([1,2]) = [49 41];
+    D(cond).scaling([1,2]) = [89 81];
+    D(cond).name = 'dose response 30 min';
+end
+% DR 90 min -> group 4
+for cond = 32:36
+    D(cond).scaling([19,20]) = [61 62];
+    D(cond).name = 'dose response 90 min';
+end
+
+for cond = 1:36
+    D(cond).offset = D(cond).offset-2;
+    D(cond).scaling = D(cond).scaling-2;
+    D(cond).std = D(cond).std-2;
+end
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/getSimulation_BachmannJakStat_offsetscaling.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/getSimulation_BachmannJakStat_offsetscaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..0afde165ba0e2c6b4e91d807427a74ad0cce7cc5
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/getSimulation_BachmannJakStat_offsetscaling.m
@@ -0,0 +1,49 @@
+function sol_ret = getSimulation_BachmannJakStat_offsetscaling(xi,sol,D,approach)
+% getSimulation_BachmannJakStat_offsetscaling() computes the offset and
+% scaling for the observables
+
+if size(xi,1) == 1
+    xi = xi';
+end
+for cond=1:numel(D)
+    switch approach
+        case 'standard'
+            offset = zeros(20,1);
+            offset(~isnan(D(cond).offset)) = 10.^xi(D(cond).offset(~isnan(D(cond).offset)));
+            scaling = ones(20,1);
+            scaling(~isnan(D(cond).scaling)) = 10.^xi(D(cond).scaling(~isnan(D(cond).scaling)));
+            s(1,:,1,cond) = scaling;
+            sol_ret(cond).y = bsxfun(@times,scaling,bsxfun(@plus,offset,sol(cond).y'))';
+            if ~isempty(sol(cond).sy)
+                sol(cond).sy(:,:,end+1:numel(xi)) = 0;
+                sol_ret(cond).sy = zeros(size(sol(cond).sy,1),size(sol(cond).sy,2),numel(xi));
+                doffset = zeros(1,20,numel(xi));
+                doffset(1,(~isnan(D(cond).offset)),D(cond).offset(~isnan(D(cond).offset))) = ...
+                    diag(10.^xi(D(cond).offset(~isnan(D(cond).offset)))*log(10));
+                dscaling = zeros(1,20,numel(xi));
+                dscaling(1,(~isnan(D(cond).scaling)),D(cond).scaling(~isnan(D(cond).scaling))) = ...
+                    diag(10.^xi(D(cond).scaling(~isnan(D(cond).scaling)))'*log(10));
+                
+                for iobs = 1:size(sol(cond).y,2)
+                    sol_ret(cond).sy(:,iobs,:) = bsxfun(@plus,(sol_ret(cond).sy(:,iobs,:)) + ...
+                        bsxfun(@times,sol(cond).y(:,iobs),dscaling(1,iobs,:)) + (sol(cond).sy(:,iobs,:))*scaling(iobs),...
+                        scaling(iobs)*doffset(1,iobs,:) + ...
+                        dscaling(1,iobs,:)*offset(iobs));
+                end
+            end
+        case 'hierarchical'
+            offset = zeros(20,1);
+            offset(~isnan(D(cond).offset)) = 10.^xi(D(cond).offset(~isnan(D(cond).offset)));
+            sol_ret(cond).y = (offset+sol(cond).y')';
+            if ~isempty(sol(cond).sy)
+                sol(cond).sy(:,:,end+1:numel(xi)) = 0;
+                sol_ret(cond).sy = sol(cond).sy;
+                doffset = zeros(1,20,numel(xi));
+                doffset(1,(~isnan(D(cond).offset)),D(cond).offset(~isnan(D(cond).offset))) = ...
+                    diag(10.^xi(D(cond).offset(~isnan(D(cond).offset)))*log(10));
+                for iobs = 1:size(sol(cond).y,2)
+                    sol_ret(cond).sy(:,iobs,:) = (sol_ret(cond).sy(:,iobs,:)) + doffset(1,iobs,:);
+                end
+            end
+    end  
+end
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/loadBachmannParameters.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/loadBachmannParameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..582f35fc382b085186a17e108011d14055cc3022
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/loadBachmannParameters.m
@@ -0,0 +1,122 @@
+function parameters = loadBachmannParameters(approach)
+% loadBachmannParameters() provides the parameter names.
+
+parameters.name = {...
+    'CISEqc'
+    'CISEqcOE'
+    'CISInh'
+    'CISRNADelay'
+    'CISRNATurn'
+    'CISTurn'
+    'EpoRActJAK2'
+    'EpoRCISInh'
+    'EpoRCISRemove'
+    'JAK2ActEpo'
+    'JAK2EpoRDeaSHP1'
+    'SHP1ActEpoR'
+    'SHP1Dea'
+    'SHP1ProOE'
+    'SOCS3Eqc'
+    'SOCS3EqcOE'
+    'SOCS3Inh'
+    'SOCS3RNADelay'
+    'SOCS3RNATurn'
+    'SOCS3Turn'
+    'STAT5ActEpoR'
+    'STAT5ActJAK2'
+    'STAT5Exp'
+    'STAT5Imp'
+    'init_EpoRJAK2'
+    'init_SHP1'
+    'init_STAT5'
+    'offset_CIS_actd'
+    'offset_CIS_cisoe'
+    'offset_CIS_long'
+    'offset_CIS_shp1oe'
+    'offset_CIS_socs3oe'
+    'offset_SOCS3_cisoe'
+    'offset_SOCS3_long'
+    'offset_SOCS3_socs3oe'
+    'offset_pEpoR_actd'
+    'offset_pEpoR_cisoe'
+    'offset_pEpoR_cisoe_pepor'
+    'offset_pEpoR_dr30'
+    'offset_pEpoR_dr7'
+    'offset_pEpoR_fine'
+    'offset_pEpoR_long'
+    'offset_pEpoR_shp1oe'
+    'offset_pEpoR_socs3oe'
+    'offset_pJAK2_actd'
+    'offset_pJAK2_cisoe'
+    'offset_pJAK2_dr30'
+    'offset_pJAK2_dr7'
+    'offset_pJAK2_fine'
+    'offset_pJAK2_long'
+    'offset_pJAK2_shp1oe'
+    'offset_pJAK2_socs3oe'
+    'offset_pSTAT5_actd'
+    'offset_pSTAT5_cisoe'
+    'offset_pSTAT5_conc'
+    'offset_pSTAT5_long'
+    'offset_pSTAT5_shp1oe'
+    'offset_pSTAT5_socs3oe'
+    'scale1_CIS_dr90'
+    'scale2_CIS_dr90'
+    'scale_CISRNA_foldA'
+    'scale_CISRNA_foldB'
+    'scale_CISRNA_foldC'
+    'scale_CIS_actd'
+    'scale_CIS_cisoe'
+    'scale_CIS_long'
+    'scale_CIS_shp1oe'
+    'scale_CIS_socs3oe'
+    'scale_SHP1_shp1oe'
+    'scale_SOCS3RNA_foldA'
+    'scale_SOCS3RNA_foldB'
+    'scale_SOCS3RNA_foldC'
+    'scale_SOCS3_cisoe'
+    'scale_SOCS3_long'
+    'scale_SOCS3_socs3oe'
+    'scale_pEpoR_actd'
+    'scale_pEpoR_cisoe'
+    'scale_pEpoR_cisoe_pepor'
+    'scale_pEpoR_dr30'
+    'scale_pEpoR_dr7'
+    'scale_pEpoR_fine'
+    'scale_pEpoR_long'
+    'scale_pEpoR_shp1oe'
+    'scale_pEpoR_socs3oe'
+    'scale_pJAK2_actd'
+    'scale_pJAK2_cisoe'
+    'scale_pJAK2_dr30'
+    'scale_pJAK2_dr7'
+    'scale_pJAK2_fine'
+    'scale_pJAK2_long'
+    'scale_pJAK2_shp1oe'
+    'scale_pJAK2_socs3oe'
+    'scale_pSTAT5_actd'
+    'scale_pSTAT5_cisoe'
+    'scale_pSTAT5_dr10'
+    'scale_pSTAT5_long'
+    'scale_pSTAT5_shp1oe'
+    'scale_pSTAT5_socs3oe'
+    'scale_tSTAT5_actd'
+    'scale_tSTAT5_long'
+    'scale_tSTAT5_shp1oe'
+    'sd_CIS_abs'
+    'sd_CIS_au'
+    'sd_JAK2EpoR_au'
+    'sd_RNA_fold'
+    'sd_SHP1_abs'
+    'sd_SHP1_au'
+    'sd_SOCS3_abs'
+    'sd_SOCS3_au'
+    'sd_STAT5_abs'
+    'sd_STAT5_au'
+    'sd_pSTAT5_rel'
+    };
+
+if strcmp(approach,'hierarchical')
+    parameters.name = parameters.name(1:58);
+end
+end
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/loadInitialConditions.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/loadInitialConditions.m
new file mode 100644
index 0000000000000000000000000000000000000000..fb64fb2468dabc2587d4b68bc2b67a5d10a55666
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/loadInitialConditions.m
@@ -0,0 +1,47 @@
+function D = loadInitialConditions(D)
+% loadInitialConditions() adds the fields init and sinit to D which
+% provides the initial conditions for the states and sensitivities for the
+% different conditions.
+
+for cond = [1:6,15:numel(D)]
+    D(cond).init = @(xi,u) [10.^xi(25);0;0;0;0;0;10.^xi(26);0;10.^xi(27);zeros(16,1)];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,25),10.^xi(26)*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(16,27)];
+end
+for cond=11:12
+    D(cond).init = @(xi,u) [10.^xi(25);0;0;0;0;0;10.^xi(26);0;10.^xi(27);zeros(15,1);u(3)*10.^(xi(15)+xi(16))];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,25),10.^xi(26)*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(15,27)
+        zeros(1,14), u(3)*10.^(xi(15)+xi(16))*log(10),u(3)*10.^(xi(15)+xi(16))*log(10),zeros(1,11)];
+end
+for cond=7:10
+    D(cond).init = @(xi,u)   [10.^xi(25);0;0;0;0;u(2);10.^xi(26);0;10.^xi(27);zeros(8,1);u(2) * 10.^(xi(2)+xi(1)); zeros(7,1)];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,25),10.^xi(26)*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(8,27);
+        u(2)*log(10)*10.^(xi(2)+xi(1)),u(2)*log(10)*10.^(xi(2)+xi(1)),zeros(1,25);
+        zeros(7,27)];
+end
+for cond = 13:14
+    D(cond).init = @(xi,u)  [10.^xi(25);0;0;0;0;0;10.^xi(26)*(1+(u(4)*10.^xi(14)));0;10.^xi(27);zeros(16,1)];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,13),u(4)*10.^(xi(14)+xi(26))*log(10),zeros(1,11),10.^xi(26)*(1+(u(4)*10.^xi(14)))*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(16,27)];
+    
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/logLikelihood_BachmannJakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/logLikelihood_BachmannJakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..baa7c6d97f71c0dc1c48bb1ddfe3707becc80e77
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/logLikelihood_BachmannJakStat.m
@@ -0,0 +1,165 @@
+function varargout = logLikelihood_BachmannJakStat(xi,D,options,approach)
+% logLikelihood_BachmannJakStat() computes the log-likelihood function for
+% the JAK-STAT model.
+%
+% USAGE:
+% * [logL] = logLikelihood_BachmannJakStat(...)
+% * [logL,dlogL] = logLikelihood_BachmannJakStat(...)
+% * [...] = logLikelihood_BachmannJakStat(xi,D,options,approach)
+%
+% Parameters
+%  xi: parameter for which log-likelihood is evaluated
+%  D: data (see logLikelihoodHierarchical.m for the definition of the
+%  data)
+%  options.MS.HO:  A HOOptions object holding various options for the algorithm
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%
+% Return values:
+%   varargout:
+%     logL: Log-Likelihood, only the log-likelihood will be returned, no
+%         sensitivity analysis is performed
+%     dlogL: Gradient of lLH, the log-likelihood and its gradient will be
+%         returned
+
+nderiv = nargout-1;
+
+if(nderiv>=1)
+    options.ami.sensi = 1;
+else
+    options.ami.sensi = 0;
+end
+
+% Simulation of conditions
+try
+    for cond = 1:numel(D)
+        options.ami.x0 = D(cond).init(xi,D(cond).u);
+        if options.ami.sensi
+            options.ami.sx0 = D(cond).sinit(xi,D(cond).u);
+        end
+        if cond == 13 || cond == 14
+            sol(cond) = simulate_BachmannJakStat_SHP1oe(D(cond).t,xi(1:27),D(cond).u,[],options.ami);
+        else
+            sol(cond) = simulate_BachmannJakStat(D(cond).t,xi(1:27),D(cond).u,[],options.ami);
+        end
+        assert(sol(cond).status>=0)
+    end
+catch
+    varargout{1} = NaN;
+    if nderiv>=1
+        varargout{2} = nan(numel(xi),1);
+    end
+    warning('simulation failed')
+    return;
+end
+
+switch approach
+    case 'hierarchical'
+        sol = getSimulation_BachmannJakStat_offsetscaling(xi,sol,D,approach);
+        if nderiv == 0
+            logL = logLikelihoodHierarchical(sol,D,options.MS.HO);
+        else
+            [logL,dlogL] = logLikelihoodHierarchical(sol,D,options.MS.HO);
+        end
+    case 'standard'
+        logL = 0;
+        dlogL=zeros(numel(xi),1);
+        sol = getSimulation_BachmannJakStat_offsetscaling(xi,sol,D,approach);
+        for cond = 1:numel(D)
+            % Map noise parameters
+            sigma2 = zeros(1,20,size(D(cond).my,3));
+            for r = 1:size(D(cond).my,3)
+                sigma2(1,:,r) = (10.^(xi(D(cond).std)));
+            end
+            if nargout > 1
+                dsigma2 = zeros(1,20,numel(xi),size(D(cond).my,3));
+                for iobs = 1:20
+                    dsigma2(1,iobs,D(cond).std(iobs),:) = dsigma2(1,iobs,D(cond).std(iobs),:) + ...
+                        10.^(xi(D(cond).std(iobs)))*log(10);
+                end
+            end
+            % compute difference between scaled simulation and data 
+            if cond == 3 % compared at a linear scale
+                y_sh = nan(size(D(cond).my));
+                y_sh(:,[12:17],:) = bsxfun(@minus,(D(cond).my(:,[12:17],:)),...
+                    (sol(cond).y(:,[12:17])));
+            elseif cond == 2 % observable 11 compared at a linear scale, rest at log10 scale
+                y_sh = nan(size(D(cond).my));
+                y_sh(:,11,:) = bsxfun(@minus,(D(cond).my(:,11,:)),(sol(cond).y(:,11)));
+                y_sh(:,[1:10,12:end],:) = bsxfun(@minus,log10(D(cond).my(:,[1:10,12:end],:)),...
+                    log10(sol(cond).y(:,[1:10,12:end])));
+            else % compared at a log10 scale
+                y_sh = bsxfun(@minus,log10(D(cond).my),log10(sol(cond).y));
+            end
+            
+            % compute log-likelihood value
+            switch options.MS.HO.distribution
+                case 'normal'
+                    logL = logL - sum(sum(nansum(0.5*bsxfun(@times,~isnan(D(cond).my),...
+                        log(2*pi*sigma2))+0.5*bsxfun(@rdivide,bsxfun(@power,y_sh,2),sigma2),1),3),2);
+                case 'laplace'
+                    logL = logL - sum(sum(nansum(bsxfun(@times,~isnan(D(cond).my),...
+                        log(2*sigma2))+bsxfun(@rdivide,abs(y_sh),sigma2),1),3),2);
+            end
+            % compute gradient
+            if nargout > 1
+                switch options.MS.HO.distribution
+                    case 'normal'
+                        if cond == 3 % compared at a linear scale
+                            iy = [12:17];
+                            temparg = bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                                bsxfun(@power,y_sh(:,iy,:),2),sigma2(:,iy,:))),sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:)) -...
+                                bsxfun(@times,permute(2*bsxfun(@rdivide,y_sh(:,iy,:),sigma2(:,iy,:)),[1,2,4,3]),sol(cond).sy(:,iy,:));
+                        elseif cond == 2 % observable 11 compared at a linear scale, rest at log10 scale
+                            iy = [1:10,12:20];
+                            temparg = bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                                bsxfun(@power,y_sh(:,iy,:),2),sigma2(:,iy,:))),sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:)) -...
+                                bsxfun(@times,1/log(10)*permute(2*bsxfun(@rdivide,y_sh(:,iy,:),sigma2(:,iy,:)),[1,2,4,3]),...
+                                bsxfun(@rdivide,sol(cond).sy(:,iy,:),sol(cond).y(:,iy)));
+                            iy = 11;
+                            temparg2 =  bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                                bsxfun(@power,y_sh(:,iy,:),2),sigma2(:,iy,:))),sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:)) -...
+                                bsxfun(@times,permute(2*bsxfun(@rdivide,y_sh(:,iy,:),sigma2(:,iy,:)),[1,2,4,3]),sol(cond).sy(:,iy,:));
+                            dlogL = dlogL - 0.5*(permute(sum(sum(nansum(temparg2,1),4),2),[3,2,1]));
+                        else % compared at a log10 scale
+                            temparg = bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                                bsxfun(@power,y_sh,2),sigma2)),sigma2),[1,2,4,3]),dsigma2) -...
+                                bsxfun(@times,1/log(10)*permute(2*bsxfun(@rdivide,y_sh,sigma2),[1,2,4,3]),...
+                                bsxfun(@rdivide,sol(cond).sy,sol(cond).y));
+                        end
+                    case 'laplace'
+                        if cond == 3 % compared at a linear scale
+                            iy = [12:17];
+                            temparg = bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,abs(y_sh(:,iy,:)),sigma2(:,iy,:))),...
+                                sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:))-...
+                                bsxfun(@times,permute(bsxfun(@rdivide,sign(y_sh(:,iy,:)),...
+                                sigma2(:,iy,:)),[1,2,4,3]),sol(cond).sy(:,iy,:));
+                        elseif cond == 2 % observable 11 compared at a linear scale, rest at log10 scale
+                            iy = [1:10,12:20];
+                            temparg =  bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                                abs(y_sh(:,iy,:)),sigma2(:,iy,:))),...
+                                sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:))-...
+                                bsxfun(@times,1/log(10)*permute(bsxfun(@rdivide,...
+                                sign(y_sh(:,iy,:)),sigma2(:,iy,:)),[1,2,4,3]),...
+                                bsxfun(@rdivide,sol(cond).sy(:,iy,:),sol(cond).y(:,iy)));
+                            iy = 11;
+                            temparg2 = bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,abs(y_sh(:,iy,:)),sigma2(:,iy,:))),...
+                                sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:))-...
+                                bsxfun(@times,permute(bsxfun(@rdivide,sign(y_sh(:,iy,:)),...
+                                sigma2(:,iy,:)),[1,2,4,3]),sol(cond).sy(:,iy,:));
+                            dlogL = dlogL - 0.5*(permute(sum(sum(nansum(temparg2,1),4),2),[3,2,1]));
+                        else % compared at a log10 scale
+                            temparg = bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,abs(y_sh),sigma2)),...
+                                sigma2),[1,2,4,3]),dsigma2)-...
+                                bsxfun(@times,1/log(10)*permute(bsxfun(@rdivide,sign(y_sh),sigma2),[1,2,4,3]),...
+                                bsxfun(@rdivide,sol(cond).sy,sol(cond).y));
+                        end
+                end
+                dlogL = dlogL - 0.5*(permute(sum(sum(nansum(temparg,1),4),2),[3,2,1]));
+            end
+        end
+end
+
+varargout{1} = logL;
+if nderiv>=1
+    varargout{2} = dlogL;
+end
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/mainBachmannJakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/mainBachmannJakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..e041f3b7f0afc7b4c1d56ea779a47c81fb49b340
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/mainBachmannJakStat.m
@@ -0,0 +1,20 @@
+% Main file of the Bachmann JAK-STAT signaling example.
+%
+% Demonstrates the use of:
+% * logLikelhoodHierarchical()
+%
+% Performs parameter estimation for the standard and hierarchical approach
+% and Gaussian and Laplace noise.
+
+
+clear all 
+close all
+clc
+
+compilation_BachmannJakStat
+
+runEstimation_BachmannJakStat('hierarchical','normal')
+runEstimation_BachmannJakStat('hierarchical','laplace')
+
+runEstimation_BachmannJakStat('standard','normal')
+runEstimation_BachmannJakStat('standard','laplace')
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/BachmannJakStat_SHP1oe_syms.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/BachmannJakStat_SHP1oe_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..66b8d70ee6ca521dc330cf6e671f169dfca123e0
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/BachmannJakStat_SHP1oe_syms.m
@@ -0,0 +1,11 @@
+function model = BachmannJakStat_SHP1oe_syms()
+% model for the simulation of experiment SHP1oe
+
+syms SHP1oe SHP1ProOE init_SHP1 SHP1Act SHP1
+
+model = BachmannJakStat_syms();
+
+model.sym.x0(7) = (init_SHP1 * (1 + (SHP1oe * SHP1ProOE))); 
+model.sym.y(18) = (SHP1 + SHP1Act)/init_SHP1;
+
+
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/BachmannJakStat_syms.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/BachmannJakStat_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..3b72aa66ca12a9b7569e764897f15a5e3b1cad01
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/BachmannJakStat_syms.m
@@ -0,0 +1,135 @@
+function model = BachmannJakStat_syms()
+
+syms t
+model.param = 'log10';
+
+%% PARAMETERS
+syms CISEqc CISEqcOE CISInh CISRNADelay  CISRNATurn CISTurn
+syms EpoRActJAK2 EpoRCISInh EpoRCISRemove JAK2ActEpo JAK2EpoRDeaSHP1 SHP1ActEpoR
+syms SHP1Dea SHP1ProOE SOCS3Eqc SOCS3EqcOE SOCS3Inh SOCS3RNADelay 
+syms SOCS3RNATurn SOCS3Turn STAT5ActEpoR STAT5ActJAK2 STAT5Exp STAT5Imp
+syms init_EpoRJAK2 init_SHP1 init_STAT5
+
+model.sym.p = [CISEqc
+CISEqcOE
+CISInh
+CISRNADelay
+CISRNATurn
+CISTurn
+EpoRActJAK2
+EpoRCISInh
+EpoRCISRemove
+JAK2ActEpo
+JAK2EpoRDeaSHP1
+SHP1ActEpoR
+SHP1Dea
+SHP1ProOE
+SOCS3Eqc
+SOCS3EqcOE
+SOCS3Inh
+SOCS3RNADelay
+SOCS3RNATurn
+SOCS3Turn
+STAT5ActEpoR
+STAT5ActJAK2
+STAT5Exp
+STAT5Imp
+init_EpoRJAK2
+init_SHP1
+init_STAT5];
+
+%% INPUT AND CONSTANTS
+syms ActD CISoe SOCS3oe SHP1oe Epo nuc cyt
+
+cyt = 0.4;
+nuc = 0.275;
+
+model.sym.k = [ActD CISoe SOCS3oe SHP1oe Epo];
+
+%% STATES
+syms EpoRJAK2 EpoRpJAK2 p1EpoRpJAK2 p2EpoRpJAK2 p12EpoRpJAK2 EpoRJAK2_CIS
+syms SHP1 SHP1Act STAT5 pSTAT5 npSTAT5 CISnRNA1 CISnRNA2
+syms CISnRNA3 CISnRNA4 CISnRNA5 CISRNA CIS
+syms SOCS3nRNA1 SOCS3nRNA2 SOCS3nRNA3 SOCS3nRNA4 SOCS3nRNA5 SOCS3RNA SOCS3
+
+model.sym.x = [EpoRJAK2;
+EpoRpJAK2;
+p1EpoRpJAK2;
+p2EpoRpJAK2;
+p12EpoRpJAK2;
+EpoRJAK2_CIS;
+SHP1;
+SHP1Act;
+STAT5;
+pSTAT5;
+npSTAT5;
+CISnRNA1;
+CISnRNA2;
+CISnRNA3;
+CISnRNA4;
+CISnRNA5;
+CISRNA;
+CIS;
+SOCS3nRNA1;
+SOCS3nRNA2;
+SOCS3nRNA3;
+SOCS3nRNA4;
+SOCS3nRNA5;
+SOCS3RNA;
+SOCS3];    
+
+model.sym.xdot = [EpoRpJAK2*(JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act + (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p12EpoRpJAK2 + (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p1EpoRpJAK2 + (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p2EpoRpJAK2 - (Epo*EpoRJAK2*JAK2ActEpo)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) ;
+ (Epo*EpoRJAK2*JAK2ActEpo)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (EpoRpJAK2*EpoRActJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (3*EpoRpJAK2*EpoRActJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) - EpoRpJAK2*(JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act ;
+ (EpoRpJAK2*EpoRActJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p1EpoRpJAK2 - (3*EpoRActJAK2*p1EpoRpJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ (3*EpoRpJAK2*EpoRActJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) - (EpoRActJAK2*p2EpoRpJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p2EpoRpJAK2 ;
+ (EpoRActJAK2*p2EpoRpJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p12EpoRpJAK2 + (3*EpoRActJAK2*p1EpoRpJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ -EpoRJAK2_CIS*(EpoRCISRemove / init_EpoRJAK2)*(p12EpoRpJAK2 + p1EpoRpJAK2) ;
+ SHP1Dea*SHP1Act - SHP1*(SHP1ActEpoR / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2) ;
+ SHP1*(SHP1ActEpoR / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2) - SHP1Dea*SHP1Act ;
+ (STAT5Exp*npSTAT5*nuc)/cyt - (STAT5*(STAT5ActJAK2 / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2))/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (STAT5*(STAT5ActEpoR / init_EpoRJAK2^2)*(p12EpoRpJAK2 + p1EpoRpJAK2)^2)/((CIS*(CISInh / CISEqc) + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ (STAT5*(STAT5ActJAK2 / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2))/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - STAT5Imp*pSTAT5 + (STAT5*(STAT5ActEpoR / init_EpoRJAK2^2)*(p12EpoRpJAK2 + p1EpoRpJAK2)^2)/((CIS*(CISInh / CISEqc) + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ (STAT5Imp*cyt*pSTAT5)/nuc - STAT5Exp*npSTAT5 ;
+ - CISnRNA1*CISRNADelay - (1 / init_STAT5)*CISRNATurn*npSTAT5*(ActD - 1) ;
+ CISnRNA1*CISRNADelay - CISnRNA2*CISRNADelay ;
+ CISnRNA2*CISRNADelay - CISnRNA3*CISRNADelay ;
+ CISnRNA3*CISRNADelay - CISnRNA4*CISRNADelay ;
+ CISnRNA4*CISRNADelay - CISnRNA5*CISRNADelay ;
+ (CISnRNA5*CISRNADelay*nuc)/cyt - CISRNA*CISRNATurn ;
+ CISRNA*CISEqc*CISTurn - CIS*CISTurn + CISoe*CISTurn*CISEqcOE * CISEqc ;
+ - SOCS3nRNA1*SOCS3RNADelay - (1 / init_STAT5)*SOCS3RNATurn*npSTAT5*(ActD - 1) ;
+ SOCS3nRNA1*SOCS3RNADelay - SOCS3nRNA2*SOCS3RNADelay ;
+ SOCS3nRNA2*SOCS3RNADelay - SOCS3nRNA3*SOCS3RNADelay ;
+ SOCS3nRNA3*SOCS3RNADelay - SOCS3nRNA4*SOCS3RNADelay ;
+ SOCS3nRNA4*SOCS3RNADelay - SOCS3nRNA5*SOCS3RNADelay ;
+ (SOCS3nRNA5*SOCS3RNADelay*nuc)/cyt - SOCS3RNA*SOCS3RNATurn ;
+ SOCS3RNA*SOCS3Eqc*SOCS3Turn - SOCS3*SOCS3Turn + SOCS3oe*SOCS3Turn*SOCS3EqcOE * SOCS3Eqc] ;
+
+model.sym.x0=sym(zeros(numel(model.sym.xdot),1));
+model.sym.x0(1) = init_EpoRJAK2;
+model.sym.x0(7) = init_SHP1; 
+model.sym.x0(9) = init_STAT5;
+
+%% OBSERVABLES
+model.sym.y = [1 / init_EpoRJAK2 *  2 * (EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2 + p12EpoRpJAK2);
+ 1 / init_EpoRJAK2 *  16 * (p1EpoRpJAK2 + p2EpoRpJAK2 + p12EpoRpJAK2);
+ 1 / CISEqc * CIS;
+ 1 / SOCS3Eqc * SOCS3;
+ 1 / init_STAT5 * (STAT5+pSTAT5);
+ 1 / init_STAT5 * pSTAT5;
+ STAT5;
+ SHP1 + SHP1Act;
+ CIS;
+ SOCS3;
+ 100*pSTAT5/(pSTAT5+STAT5);
+ SOCS3RNA;
+ SOCS3RNA;
+ SOCS3RNA;
+ CISRNA;
+ CISRNA;
+ CISRNA;
+ 1 / init_SHP1 * (SHP1 + SHP1Act) * (1 + (SHP1oe * SHP1ProOE));
+ 1 / CISEqc * CIS;
+ 1 / CISEqc * CIS];
+
+%% SIGMA
+model.sym.sigma_y = sym(ones(20,1));
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/compilation_BachmannJakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/compilation_BachmannJakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..ca2c35d1b8ba96ced7ecddf820a7d838f87176ca
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/models/compilation_BachmannJakStat.m
@@ -0,0 +1,3 @@
+[exdir,~,~]=fileparts(which('BachmannJakStat_syms.m'));
+amiwrap('BachmannJakStat','BachmannJakStat_syms',exdir)
+amiwrap('BachmannJakStat_SHP1oe','BachmannJakStat_SHP1oe_syms',exdir)
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/parameter_guesses_Bachmann.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/parameter_guesses_Bachmann.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e04a1ca90b6fadceb6deeebc52bdc623b5717a41
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/parameter_guesses_Bachmann.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/runEstimation_BachmannJakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/runEstimation_BachmannJakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..4a9910d3c10bd8ea7f81a829a65f9a01a24d2c2a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/BachmannJakStat/runEstimation_BachmannJakStat.m
@@ -0,0 +1,91 @@
+function [] = runEstimation_BachmannJakStat(approach,distribution)
+% runEstimation_BachmannJakStat() runs the parameter estimation for the
+% JAK-STAT signaling model by Bachmann et al. 
+%
+% USAGE:
+% * [] = runEstimation_BachmannJakStat('hierarchical','normal')
+%
+% Parameters
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%  distribution: 'normal' (Gaussian noise) or 'laplace' (Laplace noise) for
+%  the noise distribution
+
+parameters = loadBachmannParameters(approach);
+parameters.number = numel(parameters.name);
+parameters.min = -3*ones(parameters.number,1);
+parameters.max = 3*ones(parameters.number,1);
+
+parameters.max(1) = 4; %CISEqc
+parameters.max(3) = 12; %CISInh
+parameters.max(7) = 4; %EpoRActJAK2
+parameters.max(8) = 6; %EpoRCISInh
+parameters.max(10) = 9; %JAK2ActEpo
+parameters.max(11) = 4; %JAK2EpoRDeaSHP1
+parameters.max(20) = 4;
+parameters.min(28:end) = -5; %offsets
+
+load data_Bachmann
+D = getOffsetScalingStd_Bachmann(D);
+D = loadInitialConditions(D);
+
+for cond = 1:numel(D)
+    D(cond).my(:,[1:10,12:end],:) = 10.^D(cond).my(:,[1:10,12:end],:);
+end
+D(3).my = D(3).my - 1;
+
+options.MS = PestoOptions();
+options.MS.localOptimizerOptions = optimset('algorithm','interior-point',...
+    'display','iter',...
+    'GradObj','on',...
+    'MaxIter',5000,...
+    'TolFun',1e-10,...
+    'TolX',1e-10,...
+    'MaxFunEvals',40000,...
+    'PrecondBandWidth', inf);
+
+options.MS.comp_type = 'sequential';
+options.MS.n_starts = 100;
+options.MS.save = false;
+options.MS.foldername = ['results_BachmannJakStat_' approach '_' distribution];
+options.MS.HO.distribution = distribution;
+options.MS.HO.n_obs = 20;
+options.MS.HO.n_exp = 36;
+options.MS.HO.max_repl = 4;
+
+if strcmp(approach,'hierarchical')
+        for i = [1:10,18:20]
+            options.MS.HO.scale{i} = 'log10';
+        end
+        for i = [11:17]
+            options.MS.HO.scale{i}  = 'lin';
+        end
+        for i = [1:6,12:20]
+            options.MS.HO.scaling{i} = 'single';
+            options.MS.HO.noise{i} = 'single';
+        end
+        for i = 7:11
+            options.MS.HO.scaling{i} = 'absolute';
+            options.MS.HO.noise{i} = 'single';
+        end
+        for i = 1:20
+            options.MS.HO.obsgroups_scaling{i} = i;
+        end
+        options.MS.HO.obsgroups_noise = {[1,2],[3,19,20],4,[5,6],7,8,9,10,11,[12,13,14,15,16,17],18};
+        options.MS.HO.expgroups_scaling = {1,2,3,[4,5],6,[7,8],[9,10],[11,12],[13,14],...
+            [15:19],[20:25],[26:31],[32:36]};
+end
+
+
+load parameter_guesses_Bachmann par0
+parameters.guess = par0(1:parameters.number,1:options.MS.n_starts);
+
+% xi = parameters.guess(:,1)
+% [g,g_fd_f,g_fd_b,g_fd_c] = testGradient(xi,@(xi) ...
+%     logLikelihood_BachmannJakStat(xi,D,options,approach),1e-5);
+% [g,g_fd_f,g_fd_b,g_fd_c]
+
+parameters = getMultiStarts(parameters,@(xi) ...
+    logLikelihood_BachmannJakStat(xi,D,options,approach),options.MS);
+
+save(options.MS.foldername,'D','options','parameters','approach')
+
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/data/data_RafMekErk.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/data/data_RafMekErk.mat
new file mode 100644
index 0000000000000000000000000000000000000000..d9144f2000620d2c2cada53183c86eaa71399da2
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/data/data_RafMekErk.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/data/data_RafMekErk_standard.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/data/data_RafMekErk_standard.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9e019af8fba2e46f767b59d784c894202f36a135
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/data/data_RafMekErk_standard.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/getParameterOptions_RafMekErk.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/getParameterOptions_RafMekErk.m
new file mode 100644
index 0000000000000000000000000000000000000000..d49f545579fac5a82f95b901491e4ce6f33b004f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/getParameterOptions_RafMekErk.m
@@ -0,0 +1,72 @@
+function [parameters,options] = getParameterOptions_RafMekErk(approach)
+% getParameterOptions_RafMekErk() provides the parameters structs and
+% options needed for the optimization.
+%
+% USAGE:
+% [parameters,options] = getParameterOptions_RafMekErk(approach)
+%
+% Parameters:
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%
+% Return values
+% parameters: with fields name, number, min and max
+% options: with field MS a PestoOptions object and field llh a HOOptions
+% object
+
+
+options.MS = PestoOptions();
+options.MS.localOptimizer = 'fmincon';
+options.MS.localOptimizerOptions = optimset('algorithm','interior-point',...
+    'display','iter',...
+    'GradObj','on',...
+    'MaxIter',8000,...
+    'TolFun',1e-10,...
+    'TolX',1e-10,...
+    'MaxFunEvals',40000,...
+    'PrecondBandWidth', inf);
+options.MS.n_starts = 100;
+options.MS.mode = 'text';
+options.MS.save = false;
+options.MS.HO.n_obs = 2;
+options.MS.HO.n_exp = 3;
+options.MS.HO.max_repl = 4;
+
+load parameter_guesses_RafMekErk par0
+
+
+switch approach
+    case 'hierarchical'
+        parameters.name = {'log_{10}(kdf_Raf)','log_{10}(kp_Raf)','log_{10}(kdp_pMek)',...
+            'log_{10}(kp_pRaf_Mek)','log_{10}(kdp_pErk)','log_{10}(kp_pMek_Erk)',...
+            'log_{10}(K_pErk_inh)','log_{10}(sust_Ras_0)','log_{10}(ts_sust_Ras)',...
+            'log_{10}(ts_trans_Ras)','log_{10}(K_Sora)','log_{10}(K_UO)'};
+        parameters.guess = par0(1:length(parameters.name),1:options.MS.n_starts);
+        options.MS.HO.noise = {'multiple','multiple'};
+        options.MS.HO.scaling = {'multiple','multiple'};
+        
+        options.MS.HO.obsgroups_scaling = {1,2};
+        options.MS.HO.obsgroups_noise = {1,2};
+        
+    case 'standard'
+        parameters.name = {'log_{10}(kdf_Raf)','log_{10}(kp_Raf)','log_{10}(kdp_pMek)',...
+            'log_{10}(kp_pRaf_Mek)','log_{10}(kdp_pErk)','log_{10}(kp_pMek_Erk)',...
+            'log_{10}(K_pErk_inh)','log_{10}(sust_Ras_0)','log_{10}(ts_sust_Ras)',...
+            'log_{10}(ts_trans_Ras)','log_{10}(K_Sora)','log_{10}(K_UO)',...
+            'log_{10}(scale_pMek_20140430_gel1)','log_{10}(scale_pErk_20140430_gel1)',...
+            'log_{10}(scale_pMek_20140430_gel2)','log_{10}(scale_pErk_20140430_gel2)',...
+            'log_{10}(scale_pMek_20140505_gel1)','log_{10}(scale_pErk_20140505_gel1)',...
+            'log_{10}(scale_pMek_20140505_gel2)','log_{10}(scale_pErk_20140505_gel2)',...
+            'log_{10}(sigma_pMek_20140430_gel1)','log_{10}(sigma_pErk_20140430_gel1)',...
+            'log_{10}(sigma_pMek_20140430_gel2)','log_{10}(sigma_pErk_20140430_gel2)',...
+            'log_{10}(sigma_pMek_20140505_gel1)','log_{10}(sigma_pErk_20140505_gel1)',...
+            'log_{10}(sigma_pMek_20140505_gel2)','log_{10}(sigma_pErk_20140505_gel2)'
+            };
+        parameters.guess = par0(:,1:options.MS.n_starts);
+end
+parameters.number = length(parameters.name);
+parameters.min = -7*ones(parameters.number,1);
+parameters.max = 5*ones(parameters.number,1);
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/logLikelihood_RafMekErk_hierarchical.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/logLikelihood_RafMekErk_hierarchical.m
new file mode 100644
index 0000000000000000000000000000000000000000..2d2a915a77b235514eface401da28b38c3993634
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/logLikelihood_RafMekErk_hierarchical.m
@@ -0,0 +1,67 @@
+function [varargout] = logLikelihood_RafMekErk_hierarchical(xi,D,options)
+% logLikelihood_RafMekErk_hierarchical() computes the log-likelihood function for
+% the RAF/MEK/ERK model in the hierarchical case of optimization.
+%
+% USAGE:
+% * [lLH] = logLikelihood_RafMekErk_hierarchical(...)
+% * [lLH,gradlLH] = logLikelihood_RafMekErk_hierarchical(...)
+% * [...] = logLikelihood_RafMekErk_hierarchical(xi,D,options)
+
+% Parameters
+%  xi: parameter for which log-likelihood is evaluated
+%  D: data (see logLikelihoodHierarchical.m for the definition of the
+%  data)
+%  options.MS.HO: A HOOptions object holding various options for the algorithm
+%
+% Return values:
+%   varargout:
+%     lLH: Log-Likelihood, only the log-likelihood will be returned, no 
+%         sensitivity analysis is performed
+%     gradlLH: Gradient of lLH, the log-likelihood and its gradient will be 
+%         returned
+
+try
+     kappa = [zeros(1,2);[0,30];[5,0]];
+   n_e = size(D,2);
+   if nargout>1
+        options_simu.sensi = 1;
+    else
+        options_simu.sensi = 0;
+   end
+    %% SIMULATION
+    simulation = struct([]);
+    for j = 1:n_e %simulations for the different input values for Sora and UO126
+            sol = simulate_RafMekErk_hierarchical(D(j).t,xi,kappa(j,:),[],options_simu);        
+        if sol.status < 0 
+            error(['failed to integrate ODE for experiment ' num2str(j)])
+        end
+        
+       simulation(j).y = sol.y;
+       if nargout > 1
+            simulation(j).sy = sol.sy;
+       end
+    end
+    
+    %% LOG-LIKELIHOOD, GRADIENT
+    % observable 1
+    if nargout > 1
+        [lLH, gradlLH] = logLikelihoodHierarchical(simulation,D,options.MS.HO);        
+    else
+        lLH = logLikelihoodHierarchical(simulation,D,options.MS.HO);        
+    end
+    
+catch error_thrown
+    warning(['Evaluation of likelihood failed. ',error_thrown.message]);
+    lLH = -inf; 
+    gradlLH = zeros(length(xi),1);
+end
+
+switch nargout
+    case{0,1}
+        varargout{1} = lLH;
+    case 2
+        varargout{1} = lLH;
+        varargout{2} = gradlLH;
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/logLikelihood_RafMekErk_standard.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/logLikelihood_RafMekErk_standard.m
new file mode 100644
index 0000000000000000000000000000000000000000..b8a85d3f98c788e55f1113cae93bae768ceff2a5
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/logLikelihood_RafMekErk_standard.m
@@ -0,0 +1,171 @@
+ function [varargout] = logLikelihood_RafMekErk_standard(xi,D,options)
+% logLikelihood_RafMekErk_standard() computes the log-likelihood function for
+% the RAF/MEK/ERK model in the standard case of optimization.
+%
+% USAGE:
+% * [logL] = logLikelihood_RafMekErk_standard(...)
+% * [logL,dlogL] = logLikelihood_RafMekErk_standard(...)
+% * [...] = logLikelihood_RafMekErk_standard(xi,D,options)
+
+% Parameters
+%  xi: parameter for which log-likelihood is evaluated
+%  D: data with field measurement
+%  options.MS.HO: A HOOptions object holding various options for the algorithm
+%
+% Return values:
+%   varargout:
+%     logL: Log-Likelihood, only the log-likelihood will be returned, no 
+%         sensitivity analysis is performed
+%     dlogL: Gradient of lLH, the log-likelihood and its gradient will be 
+%         returned
+
+n_theta = 20; %number of parameters
+
+try
+    %global errorCount
+    u = D.conditions;
+    n_u = size(u,1);
+    n_sigma = length(xi)-n_theta;
+    n_r = size(D.measurement{1},2);    
+    theta = xi(1:n_theta);% (log10) parameters
+    noise2 = bsxfun(@times,ones(length(D.t{1}),n_r),xi(n_theta+1:n_theta+n_sigma)');    
+    J = 0;
+    if nargout>1
+        dJdtheta = zeros(length(xi),1);
+        options_simu.sensi = 1;
+    else
+        options_simu.sensi = 0;
+    end
+
+    for i = 1:n_u
+        t_m = D.t{i};
+        n_t = length(t_m);
+        sol = simulate_RafMekErk(t_m,theta,u(i,:),[],options_simu);
+
+        if sol.status < 0
+            error(['failed to integrate ODE for experiment ' num2str(i)])
+        end
+
+        y = sol.y(:);
+        S_theta = reshape(sol.sy,[],n_theta);
+        sigma2 = bsxfun(@power,10,noise2);
+        if nargout > 1
+            dsigma2dtheta = zeros(length(y),n_sigma);           
+            dsigma2dtheta(1:n_t,1) = log(10)*ones(n_t,1);
+            dsigma2dtheta(n_t+1:2*n_t,2) = log(10)*ones(n_t,1);
+            dsigma2dtheta(2*n_t+1:3*n_t,3) = log(10)*ones(n_t,1);
+            dsigma2dtheta(3*n_t+1:4*n_t,4) = log(10)*ones(n_t,1);
+            dsigma2dtheta(4*n_t+1:5*n_t,5) = log(10)*ones(n_t,1);
+            dsigma2dtheta(5*n_t+1:6*n_t,6) = log(10)*ones(n_t,1);
+            dsigma2dtheta(6*n_t+1:7*n_t,7) = log(10)*ones(n_t,1);
+            dsigma2dtheta(7*n_t+1:8*n_t,8) = log(10)*ones(n_t,1);
+
+            dsigmadtheta = [zeros(length(y),n_theta-n_r),...
+                zeros(length(y),n_r),bsxfun(@times,dsigma2dtheta,sigma2(:))];
+
+            % Parameter derivative
+            dyxi_ik = S_theta;
+            dyxi_ik_t = [dyxi_ik, zeros(length(y),n_sigma)];
+        end
+
+        %% Objective function (J)
+        if nargout>1
+            switch options.MS.HO.distribution
+                case 'normal'
+                    [J_i,grad_J] = J_normal(D.measurement{i}(:),y,sigma2(:),dyxi_ik_t,dsigmadtheta);
+                case 'laplace'
+                    [J_i,grad_J] = J_laplace(D.measurement{i}(:),y,sigma2(:),dyxi_ik_t,dsigmadtheta);
+            end
+            J = J + J_i;
+            dJdtheta = dJdtheta + grad_J;
+        else
+            switch options.MS.HO.distribution
+                case 'normal'
+                    J_i = J_normal(D.measurement{i}(:),y,sigma2(:),[],[]);
+                case 'laplace'
+                    J_i = J_laplace(D.measurement{i}(:),y,sigma2(:),[],[]);
+            end
+            J = J + J_i;
+        end
+    end
+    
+
+catch error_thrown
+    warning(['Evaluation of likelihood failed. ',error_thrown.message]);
+    J = inf;
+    dJdtheta = zeros(length(xi),1);
+end
+switch nargout
+    case{0,1}
+        varargout{1} = J;
+    case 2
+        varargout{1} = J;
+        varargout{2} = dJdtheta;
+end
+
+ end
+
+ 
+ function [varargout] = J_laplace(y_m,y,sigma2,dydtheta,dsigma2dtheta)
+%OUTPUT
+%loglikelihood: J
+%gradient: dJdtheta
+
+% calculation of loglikelihood value for non NaNs 
+ind = find(~isnan(y_m));
+J=sum((log(2*sigma2(ind))+abs(y_m(ind)-y(ind))./sigma2(ind)));
+
+if nargout > 1
+    %calculation of gradient with respect to theta
+    grad_J = zeros(size(y_m));
+    grad_J(ind) = -sign(y_m(ind)-y(ind))./sigma2(ind);
+
+    % calculation of gradient with respect to sigma^2
+    grad_J_sig = zeros(size(y_m));
+    grad_J_sig(ind) = 1./sigma2(ind).*(1-abs(y_m(ind)-y(ind))./sigma2(ind));
+
+    % grad_J = grad_J*dydtheta + grad_J*dydsigma2*dsigma2dtheta
+    dJdtheta = (grad_J' * dydtheta + grad_J_sig' * dsigma2dtheta)';
+end
+
+switch nargout
+    case{0,1}
+        varargout{1} = -J;
+    case 2
+        varargout{1} = -J;
+        varargout{2} = -dJdtheta;
+end
+
+ end
+
+ function [varargout] = J_normal(y_m,y,sigma2,dydtheta,dsigma2dtheta)
+%OUTPUT
+%loglikelihood: J
+%gradient: dJdtheta
+
+% calculation of loglikelihood value for non NaNs 
+ind = find(~isnan(y_m));
+J=sum(0.5*(log(2*pi*sigma2(ind))+(y_m(ind)-y(ind)).^2./sigma2(ind)));
+
+if nargout > 1
+    %calculation of gradient with respect to theta
+    grad_J = zeros(size(y_m));
+    grad_J(ind) = -(y_m(ind)-y(ind))./sigma2(ind);
+
+    % calculation of gradient with respect to sigma^2
+    grad_J_sig = zeros(size(y_m));
+    grad_J_sig(ind) = 0.5*1./sigma2(ind).*(1-(y_m(ind)-y(ind)).^2./sigma2(ind));
+
+    % grad_J = grad_J*dydtheta + grad_J*dydsigma2*dsigma2dtheta
+    dJdtheta = (grad_J' * dydtheta + grad_J_sig' * dsigma2dtheta)';
+end
+
+switch nargout
+    case{0,1}
+        varargout{1} = -J;
+    case 2
+        varargout{1} = -J;
+        varargout{2} = -dJdtheta;
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/mainRafMekErk.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/mainRafMekErk.m
new file mode 100644
index 0000000000000000000000000000000000000000..f674e0e8a77a3deed1b35343778e6c64b482fab9
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/mainRafMekErk.m
@@ -0,0 +1,19 @@
+% Main file of the RAF/MEK/ERK example.
+%
+% Demonstrates the use of:
+% * logLikelhoodHierarchical()
+%
+% Performs parameter estimation for the standard and hierarchical approach
+% and Gaussian and Laplace noise.
+
+clear all 
+close all
+clc
+
+compilation_RafMekErk
+
+runEstimation_RafMekErk('hierarchical','normal')
+runEstimation_RafMekErk('hierarchical','laplace')
+
+runEstimation_RafMekErk('standard','normal')
+runEstimation_RafMekErk('standard','laplace')
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/RafMekErk_hierarchical_syms.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/RafMekErk_hierarchical_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..ed20a6639e5f824836d9f883ece62cdd83031f2c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/RafMekErk_hierarchical_syms.m
@@ -0,0 +1,9 @@
+function [model] = RafMekErk_hierarchical_syms()
+
+model = RafMekErk_syms();
+     
+%% SYSTEM STRUCT
+model.sym.p = model.sym.p(1:12);
+model.sym.y = [model.sym.x(2),model.sym.x(3)];
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/RafMekErk_syms.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/RafMekErk_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..9890d92e58bef4c11fc34f38927c40708ee923a6
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/RafMekErk_syms.m
@@ -0,0 +1,64 @@
+function [model] = RafMekErk_syms()
+
+% paramterisation
+model.param = 'log10';
+
+%% STATES
+syms pRaf pMek pErk 
+
+x = [pRaf pMek pErk]; 
+
+%% TIME
+syms t
+
+%% PARAMETERS
+% Define parameters as symbolic variables:
+syms kdf_Raf kp_Raf kdp_pMek kp_pRaf_Mek kdp_pErk kp_pMek_Erk K_pErk_inh ...
+         sust_Ras_0 ts_sust_Ras ts_trans_Ras K_Sora K_UO... 
+         scale_pMek_20140430_gel1 scale_pErk_20140430_gel1 scale_pMek_20140430_gel2...
+         scale_pErk_20140430_gel2 scale_pMek_20140505_gel1 scale_pErk_20140505_gel1...
+         scale_pMek_20140505_gel2 scale_pErk_20140505_gel2
+     
+p = [kdf_Raf kp_Raf kdp_pMek kp_pRaf_Mek kdp_pErk kp_pMek_Erk K_pErk_inh ...
+         sust_Ras_0 ts_sust_Ras ts_trans_Ras K_Sora K_UO...
+         scale_pMek_20140430_gel1 scale_pErk_20140430_gel1 scale_pMek_20140430_gel2...
+         scale_pErk_20140430_gel2 scale_pMek_20140505_gel1 scale_pErk_20140505_gel1...
+         scale_pMek_20140505_gel2 scale_pErk_20140505_gel2]; % Sora UO];
+     
+%% DOSERESPONSE
+syms Sora UO
+k = [Sora UO];
+
+%% SYSTEM EQUATIONS
+xdot = sym(zeros(size(x)));
+
+RasGTP = sust_Ras_0+(1-exp(-t/ts_sust_Ras))*exp(-t/ts_trans_Ras);
+
+xdot(1) = kp_Raf*(1-pRaf)*(RasGTP)/(1+pErk/K_pErk_inh)-kdf_Raf*pRaf;
+xdot(2) = kp_pRaf_Mek*pRaf/(1+Sora/K_Sora)*(1-pMek)-kdp_pMek*pMek;
+xdot(3) = kp_pMek_Erk*pMek/(1+UO/K_UO)*(1-pErk)-kdp_pErk*pErk;
+
+%% INITIAL CONDITIONS
+x0(1) = ((K_pErk_inh*(sust_Ras_0) + (K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + (K_pErk_inh*kdp_pErk*(sust_Ras_0))/kp_pMek_Erk - (K_pErk_inh*kdp_pMek*kdp_pErk*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk)))/(2*(kdf_Raf/kp_Raf  + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdf_Raf)/kp_Raf + (K_pErk_inh*kdf_Raf*kdp_pErk)/(kp_Raf*kp_pMek_Erk) + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk));
+x0(2) = (((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk - (K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk)/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) - (K_pErk_inh*kdp_pMek*kdp_pErk*sust_Ras_0)/(kp_pRaf_Mek*kp_pMek_Erk)))/((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*(sust_Ras_0))/kp_pMek_Erk + (kdf_Raf*kdp_pMek*(2*K_pErk_inh + (K_pErk_inh*kdp_pErk)/kp_pMek_Erk + 2))/(kp_Raf*kp_pRaf_Mek) + (K_pErk_inh*kdp_pMek*(sust_Ras_0)*(kdp_pErk/kp_pMek_Erk + 2))/kp_pRaf_Mek);
+x0(3) = (((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk - (K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk)/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) - (K_pErk_inh*kdp_pMek*kdp_pErk*sust_Ras_0)/(kp_pRaf_Mek*kp_pMek_Erk)))/((kdp_pErk/kp_pMek_Erk + 1)*(K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0*(kdp_pErk/kp_pMek_Erk + 1)^2 + (kdf_Raf*kdp_pMek*kdp_pErk*(K_pErk_inh + (K_pErk_inh*kdp_pErk)/kp_pMek_Erk + 2))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) + (K_pErk_inh*kdp_pMek*kdp_pErk*(sust_Ras_0)*(kdp_pErk/kp_pMek_Erk + 1))/(kp_pRaf_Mek*kp_pMek_Erk));
+
+%% OBSERVABLES
+y = [scale_pMek_20140430_gel1*x(2);...
+     scale_pErk_20140430_gel1*x(3);...
+     scale_pMek_20140430_gel2*x(2);...
+     scale_pErk_20140430_gel2*x(3);...
+     scale_pMek_20140505_gel1*x(2);...
+     scale_pErk_20140505_gel1*x(3);...
+     scale_pMek_20140505_gel2*x(2);...
+     scale_pErk_20140505_gel2*x(3)];
+
+%% SYSTEM STRUCT
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/compilation_RafMekErk.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/compilation_RafMekErk.m
new file mode 100644
index 0000000000000000000000000000000000000000..03633a06cae8314f9eca181b3fac286634be73e4
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/models/compilation_RafMekErk.m
@@ -0,0 +1,9 @@
+%% compilation RafMekErk for standard
+[exdir,~,~]=fileparts(which('RafMekErk_syms.m'));
+% compile the model
+amiwrap('RafMekErk','RafMekErk_syms',exdir)
+
+%% compilation RafMekErk for hierarchical
+[exdir,~,~]=fileparts(which('RafMekErk_hierarchical_syms.m'));
+% compile the model
+amiwrap('RafMekErk_hierarchical','RafMekErk_hierarchical_syms',exdir)
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/parameter_guesses_RafMekErk.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/parameter_guesses_RafMekErk.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e8a008bd890d26bc673392c567bc2b6d1e5d603f
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/parameter_guesses_RafMekErk.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/runEstimation_RafMekErk.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/runEstimation_RafMekErk.m
new file mode 100644
index 0000000000000000000000000000000000000000..0c8e5295e732e00e22568fa6be80139d3a795d28
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/RafMekErk/runEstimation_RafMekErk.m
@@ -0,0 +1,35 @@
+function [] = runEstimation_RafMekErk(approach,distribution)
+% runEstimation_RafMekErk() runs the parameter estimation for the
+% RAF/MEK/ERK signaling model.
+%
+% USAGE:
+% * [] = runEstimation_JakStat('hierarchical','normal')
+%
+% Parameters
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%  distribution: 'normal' (Gaussian noise) or 'laplace' (Laplace noise) for
+%  the noise distribution
+
+switch approach
+    case 'standard'
+        load('data_RafMekErk_standard')
+    case 'hierarchical'
+        load('data_RafMekErk')
+end
+
+[parameters,options] = getParameterOptions_RafMekErk(approach);
+
+options.MS.HO.distribution = distribution;
+options.MS.foldername = ['results_RafMekErk_' approach '_' distribution];
+
+switch approach
+    case 'hierarchical'
+        parameters = getMultiStarts(parameters,@(xi) ...
+            logLikelihood_RafMekErk_hierarchical(xi,D,options),options.MS);
+    case 'standard'
+        parameters = getMultiStarts(parameters,@(xi) ...
+            logLikelihood_RafMekErk_standard(xi,D,options),options.MS);
+end
+save(options.MS.foldername,'parameters','D','options','approach')
+end
+
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/data/data_JakStat.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/data/data_JakStat.mat
new file mode 100644
index 0000000000000000000000000000000000000000..8aea1689823795dcb5976ee988c1075befe26282
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/data/data_JakStat.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/getParameterOptions_JakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/getParameterOptions_JakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..5c2db757a0e2b333db9206773ca4cf1369c2f548
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/getParameterOptions_JakStat.m
@@ -0,0 +1,66 @@
+function [parameters,options] = getParameterOptions_JakStat(approach,optimizer)
+% getParameterOptions_JakStat() provides the parameters structs and
+% options needed for the optimization.
+%
+% USAGE:
+% [parameters,options] = getParameterOptions_JakStat(approach)
+%
+% Parameters:
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%
+% Return values
+% parameters: with fields name, number, min and max
+% options: with field MS a PestoOptions object and field llh a HOOptions
+% object
+
+options.MS = PestoOptions();
+options.MS.n_starts = 100; 
+options.MS.mode = 'text';
+options.MS.localOptimizer = optimizer;
+options.MS.HO.n_obs = 3;
+options.MS.HO.n_exp = 1;
+
+switch optimizer
+    case 'fmincon'
+    options.MS.localOptimizerOptions = optimset('algorithm','interior-point',...
+        'display','iter',...
+        'GradObj','on',...
+        'MaxIter',2000,...
+        'MaxFunEvals',6400,...
+        'PrecondBandWidth', inf);
+    case 'pswarm'
+        options.MS.localOptimizerOptions.MaxIter = 5000;
+        options.MS.localOptimizerOptions.MaxObj = 40000;
+end
+
+load parameter_guesses_JakStat par0
+
+switch approach
+    case 'hierarchical'
+        parameters.name = {'log_{10}(p1)','log_{10}(p2)','log_{10}(p3)','log_{10}(p4)',...
+            'log_{10}(sp1)','log_{10}(sp2)','log_{10}(sp3)','log_{10}(sp4)','log_{10}(sp5)',...
+            'log_{10}(offset_{tSTAT})','log_{10}(offset_{pSTAT})'};
+        parameters.guess = par0(1:length(parameters.name),1:options.MS.n_starts);
+        options.MS.HO.noise = {'multiple','multiple','multiple'};
+        options.MS.HO.scaling = {'multiple','multiple','absolute'};
+        options.MS.HO.obsgroups_noise = {1,2,3};
+        options.MS.HO.obsgroups_scaling = {1,2,3};
+        
+    case 'standard'
+        
+        parameters.name = {'log_{10}(p1)','log_{10}(p2)','log_{10}(p3)','log_{10}(p4)',...
+            'log_{10}(sp1)','log_{10}(sp2)','log_{10}(sp3)','log_{10}(sp4)','log_{10}(sp5)',...
+            'log_{10}(offset_{tSTAT})','log_{10}(offset_{pSTAT})',...
+            'log_{10}(scale_{tSTAT})','log_{10}(scale_{pSTAT})',...
+            'log_{10}(\sigma_{pSTAT})','log_{10}(\sigma_{tSTAT})','log_{10}(\sigma_{pEpoR})'};
+        parameters.guess = par0(:,1:options.MS.n_starts);
+end
+
+parameters.number = length(parameters.name);
+parameters.min = -5*ones(parameters.number,1);
+parameters.max = 3*ones(parameters.number,1);
+parameters.max(4) = 6;
+parameters.max(2) = 6;
+parameters.min(9) = -6;
+parameters.min(4) = -3;
+parameters.min(2) = -3;
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/logLikelihood_JakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/logLikelihood_JakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..bed3184e6e83ec8c9e1b6dad3811d8d1b4bffb50
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/logLikelihood_JakStat.m
@@ -0,0 +1,161 @@
+function [varargout] = logLikelihood_JakStat(xi,D,options,approach)
+% logLikelihood_JakStat() computes the log-likelihood function for
+% the JAK-STAT model by Swameye et al. and Schelker et al.
+%
+% USAGE:
+% * [lLH] = logLikelihood_JakStat(...)
+% * [lLH,gradlLH] = logLikelihood_JakStat(...)
+% * [...] = logLikelihood_JakStat(xi,D,options,approach)
+%
+% Parameters
+%  xi: parameter for which log-likelihood is evaluated
+%  D: data (see logLikelihoodHierarchical.m for the definition of the
+%  data in the hierarchical case)
+%  options.MS.HO:  A HOOptions object holding various options for the algorithm
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%
+% Return values:
+%   varargout:
+%     lLH: Log-Likelihood, only the log-likelihood will be returned, no 
+%         sensitivity analysis is performed
+%     gradlLH: Gradient of lLH, the log-likelihood and its gradient will be 
+%         returned
+
+try
+    kappa(1) = 1.4;% Omega_cyt
+    kappa(2) = 0.45;% Omega_nuc
+    kappa(3) = 1; % init_STAT
+    options.ami.atol = 1e-12;
+    options.ami.rtol = 1e-12;
+    if nargout>1
+        options.ami.sensi = 1;
+    else
+        options.ami.sensi = 0;
+    end
+    
+    %% SIMULATION
+    switch approach
+        case 'hierarchical'
+            sol = simulate_JakStat_hierarchical(D.t,xi(1:11),kappa,[],options.ami);
+            simulation(1).y = sol.y;
+            if nargout > 1
+                simulation(1).sy = sol.sy;
+            end
+            %% LOG-LIKELIHOOD, GRADIENT
+            if nargout == 2
+                [lLH, gradlLH] = logLikelihoodHierarchical(simulation,D,options.MS.HO);
+            elseif nargout > 2
+                [lLH, gradlLH,HlLH] = logLikelihoodHierarchical(simulation,D,options.MS.HO);
+            else
+                lLH = logLikelihoodHierarchical(simulation,D,options.MS.HO);
+            end
+        case 'standard'
+            sol = simulate_JakStat(D.t,xi,kappa,[],options.ami);
+            my = sol.y;
+            if nargout>1
+                dmydxi = sol.sy;
+            end
+            %% LOGLIKELIHOOD, GRAD
+            logL = 0;
+            if nargout>1
+                grad = zeros(length(xi),1);
+                if nargout>2
+                    fish = zeros(length(xi),length(xi));
+                end
+            end
+            nt = size(my,1); %number of timepoins
+            no = size(my,2); %number of outputs
+            np = length(xi)-no; % number of dynamic parameters
+            
+            sigma = zeros(no,1);
+            for i = 1:no
+                sigma(i) = 10^xi(np+i);
+            end
+            
+            D.sigma_my = repmat(sigma',[nt,1]);
+            resmy = reshape((my-D.my)./(D.sigma_my),nt*no,1);
+            
+            switch options.MS.HO.distribution
+                case 'normal'
+                    if nargout>1
+                        sresmy = reshape(bsxfun(@times,dmydxi,1./(D.sigma_my)),nt*no,np);
+                        resmyc = reshape((my-D.my),nt*no,1);
+                    end
+                    for i = 1:no
+                        logL = logL - 0.5*nansum(log(2*pi*(sigma(i)).^2) + resmy((i-1)*nt+1:i*nt).^2);
+                    end
+                    if nargout>1
+                        % Compute Gradient with sensitivities
+                        dsigmadxi = zeros(length(xi),no);
+                        
+                        for i = 1:no
+                            dsigmadxi(np+i,i) = sigma(i)*log(10);
+                            grad(1:np) = grad(1:np) - nansum(bsxfun(@times,dmydxi(:,i+(0:no:np*no-i)),((resmyc((i-1)*nt+1:i*nt)))./(sigma(i).^2)))';
+                            grad = grad - nansum((1-resmy((i-1)*nt+1:i*nt).^2))*1/(sigma(i))*dsigmadxi(:,i);
+                            
+                        end
+                        if nargout>2
+                            for i=1:no
+                                dsigma2dxi = 2*sigma(i)*dsigmadxi(:,i);
+                                d2sigma2dxi2 = 2*(dsigmadxi(:,i)*dsigmadxi(:,i)');
+                                d2sigma2dxi2(np+i,np+i) = d2sigma2dxi2(np+i,np+i) + 2*sigma(i)^2*log(10)^2;
+                                G = resmy((i-1)*nt+1:i*nt).^2;
+                                Happ9_1 = nansum((1/(2*sigma(i)^4))*(1-2*G))*(dsigma2dxi*dsigma2dxi');
+                                Happ9_2 = -1*nansum((1/(2*sigma(i)^2))*(1-G))*d2sigma2dxi2;
+                                Happ78 = -1*dsigma2dxi*nansum(bsxfun(@times,[-1*dmydxi(:,i+(0:no:np*no-i)),zeros(nt,no)],((resmyc((i-1)*nt+1:i*nt)))))./(sigma(i).^4);
+                                Happ36 = Happ78';
+                                Happ1245 = -1*[-1*dmydxi(:,i+(0:no:np*no-i)),zeros(nt,no)]'*[-1*dmydxi(:,i+(0:no:np*no-i)),zeros(nt,no)]*1/(sigma(i)^2);
+                                fish = fish + Happ9_1+Happ9_2+Happ78+Happ36+Happ1245;
+                            end
+                        end
+                        
+                    end
+                case 'laplace'
+                    resmyc = reshape((my-D.my),nt*no,1);
+                    for i = 1:no
+                        logL = logL - nansum(log(2*sigma(i)) + abs(resmyc((i-1)*nt+1:i*nt))./sigma(i));
+                    end
+                    if nargout>1
+                        dbdxi = zeros(length(xi),no);
+                        
+                        for i = 1:no
+                            dbdxi(np+i,i) = sigma(i)*log(10);
+                            grad(1:np) = grad(1:np) - nansum(bsxfun(@times,(1/sigma(i))*dmydxi(:,i+(0:no:np*no-i)),sign(resmyc((i-1)*nt+1:i*nt))))';
+                            grad = grad + nansum(-(1/(sigma(i)))+ abs(resmyc((i-1)*nt+1:i*nt))./(sigma(i)^2))*dbdxi(:,i);
+                        end
+                    end
+            end
+    end
+    assert(sol.status>=0)
+catch error_thrown
+    warning(['Evaluation of likelihood failed. ',error_thrown.message]);
+    lLH = nan;
+    gradlLH = nan(length(xi),1);
+    logL = nan;
+    grad = nan(length(xi),1);
+end
+switch approach
+    case 'hierarchical'
+        switch nargout
+            case{0,1}
+                varargout{1} = lLH;
+            case 2
+                varargout{1} = lLH;
+                varargout{2} = gradlLH;
+            case 3
+                varargout{1} = lLH;
+                varargout{2} = gradlLH;
+                varargout{3} = HlLH;
+                
+        end
+    case 'standard'
+        switch nargout
+            case{0,1}
+                varargout{1} = logL;
+            case 2
+                varargout{1} = logL;
+                varargout{2} = grad;
+        end
+end
+end
+
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/mainSmallJakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/mainSmallJakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..262c516bfc54d560f4e2f3a227f2adcea1a914f1
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/mainSmallJakStat.m
@@ -0,0 +1,25 @@
+% Main file of the JakStat signaling model I  example.
+%
+% Demonstrates the use of:
+% * logLikelhoodHierarchical()
+%
+% Performs parameter estimation for the standard and hierarchical approach
+% and Gaussian and Laplace noise.
+
+clear all 
+close all
+clc
+
+compilation_JakStat
+%%
+runEstimation_JakStat('hierarchical','normal')
+runEstimation_JakStat('hierarchical','laplace')
+
+runEstimation_JakStat('standard','normal')
+runEstimation_JakStat('standard','laplace')
+%%
+runEstimation_JakStat('hierarchical','normal','pswarm')
+runEstimation_JakStat('hierarchical','laplace','pswarm')
+
+runEstimation_JakStat('standard','normal','pswarm')
+runEstimation_JakStat('standard','laplace','pswarm')
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/JakStat_hierarchical_syms.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/JakStat_hierarchical_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..3dc995b26d64328eec59febb1de14799cab62520
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/JakStat_hierarchical_syms.m
@@ -0,0 +1,14 @@
+function [model] = JakStat_hierarchical_syms()
+
+syms p1 p2 p3 p4 sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT
+syms Omega_cyt Omega_nuc init_STAT
+syms STAT pSTAT pSTAT_pSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+
+model = JakStat_syms();
+
+model.sym.p = model.sym.p(1:11);
+
+model.sym.y(1) = offset_pSTAT + 1/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+model.sym.y(2)= offset_tSTAT + 1/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/JakStat_syms.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/JakStat_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..02c5e242e96bd7349f8bb7835a9310d21e52b94e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/JakStat_syms.m
@@ -0,0 +1,57 @@
+function [model] = JakStat_syms()
+
+model.param = 'log10';
+
+% STATES
+syms STAT pSTAT pSTAT_pSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+
+x = [
+STAT, pSTAT, pSTAT_pSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+];
+
+% PARAMETERS
+syms p1 p2 p3 p4 sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT
+
+p = [p1,p2,p3,p4,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT];
+
+%CONSTANTS
+syms Omega_cyt Omega_nuc init_STAT
+
+k = [Omega_cyt,Omega_nuc, init_STAT];
+
+% INPUT 
+syms t
+u(1) = am_spline_pos(t, 5,0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+
+% SYSTEM EQUATIONS
+xdot = sym(zeros(size(x)));
+
+xdot(1) = (Omega_nuc*nSTAT5*p4 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+xdot(2) = -(2*p2*pSTAT^2 - STAT*init_STAT*p1*u(1))/init_STAT;
+xdot(3) = (p2*pSTAT^2 - init_STAT*p3*pSTAT_pSTAT)/init_STAT;
+xdot(4) = -(p4*(Omega_cyt*STAT - Omega_cyt*init_STAT + 2*Omega_nuc*nSTAT1 + Omega_nuc*nSTAT2 + Omega_nuc*nSTAT3 + Omega_nuc*nSTAT4 + Omega_nuc*nSTAT5 + Omega_cyt*pSTAT + 2*Omega_cyt*pSTAT_pSTAT))/Omega_nuc;
+xdot(5) = p4*(nSTAT1 - nSTAT2);
+xdot(6) = p4*(nSTAT2 - nSTAT3);
+xdot(7) = p4*(nSTAT3 - nSTAT4);
+xdot(8) = p4*(nSTAT4 - nSTAT5);
+
+% INITIAL CONDITIONS
+x0 = sym(zeros(size(x)));
+
+x0(1) = init_STAT;
+
+% OBSERVABLES
+y = sym(zeros(3,1));
+
+y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+y(3) = u(1);
+
+% SYSTEM STRUCT
+model.sym.x = x;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.k = k;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/compilation_JakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/compilation_JakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..2c8ce4f43238e55ecd9ad926e9ab5023a00ef11b
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/models/compilation_JakStat.m
@@ -0,0 +1,9 @@
+%% compilation JakStat for standard
+[exdir,~,~]=fileparts(which('JakStat_syms.m'));
+% compile the model
+amiwrap('JakStat','JakStat_syms',exdir)
+
+%% compilation JakStat hierarchical
+[exdir,~,~]=fileparts(which('JakStat_hierarchical_syms.m'));
+% compile the model
+amiwrap('JakStat_hierarchical','JakStat_hierarchical_syms',exdir)
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/parameter_guesses_JakStat.mat b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/parameter_guesses_JakStat.mat
new file mode 100644
index 0000000000000000000000000000000000000000..ae3ae05a514d4e968a8a86523d6bb3a7bfb8b08e
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/parameter_guesses_JakStat.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/runEstimation_JakStat.m b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/runEstimation_JakStat.m
new file mode 100644
index 0000000000000000000000000000000000000000..09866d0bdaa83574e173141fb8a9e1b13a0cd2f3
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/HierarchicalOptimization_examples/SmallJakStat/runEstimation_JakStat.m
@@ -0,0 +1,37 @@
+function [] = runEstimation_JakStat(varargin)
+% runEstimation_JakStat() runs the parameter estimation for the JAK-STAT
+% signalig model.
+%
+% USAGE:
+% * [] = runEstimation_JakStat('hierarchical','normal')
+% * [] = runEstimation_JakStat('hierarchical','normal','pswarm')
+%
+% Parameters
+%  approach: 'hierarchical' or 'standard' approach for the optimization
+%  distribution: 'normal' (Gaussian noise) or 'laplace' (Laplace noise) for
+%  the noise distribution
+%  optimizer: 'fmincon','pswarm',... see PTOptions local optimizer
+
+approach = varargin{1};
+distribution = varargin{2};
+if nargin > 2
+    optimizer = varargin{3};
+else
+    optimizer = 'fmincon';
+end
+
+load('data_JakStat.mat')
+[parameters,options] = getParameterOptions_JakStat(approach,optimizer);
+
+options.MS.HO.distribution = distribution;
+if nargin > 2
+    options.MS.foldername = ['results_SmallJakStat_' approach '_' distribution '_' optimizer];
+else
+    options.MS.foldername = ['results_SmallJakStat_' approach '_' distribution];
+end
+
+parameters = getMultiStarts(parameters,@(xi) ...
+    logLikelihood_JakStat(xi,D,options,approach),options.MS);
+
+save(options.MS.foldername,'parameters','D','options','optimizer','approach')
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/Figure1C.mat b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/Figure1C.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e8766ea7ffcad2c972b60b9c12501d29c32dfc63
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/Figure1C.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5A.mat b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5A.mat
new file mode 100644
index 0000000000000000000000000000000000000000..c82830a2f2944b644c7b2b6c417eff385df3a886
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5A.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5B.mat b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5B.mat
new file mode 100644
index 0000000000000000000000000000000000000000..722c8c652a70e3a005b361c5bd244b39a0caeabe
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5B.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5C.mat b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5C.mat
new file mode 100644
index 0000000000000000000000000000000000000000..a30a4ec837eedfa836712c94695c08c23c6957a5
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5C.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5D.mat b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5D.mat
new file mode 100644
index 0000000000000000000000000000000000000000..b0204cca3627bedf21c1f0229ad136571d88da9b
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Data/Saunders2011/FigureS5D.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_eq.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_eq.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3ff3fc0793dfe122b74280c5cc4b32d03e6767c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_eq.m
@@ -0,0 +1,111 @@
+function [model] = Pom1p_AP_syms_eq()
+
+%% CVODES OPTIONS
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) - a*x(1) + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - a*x(n_grid) + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - m*x(n_grid+1) + a*x(1);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - m*x(2*n_grid) + a*x(n_grid);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - a*x(i) + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - m*x(n_grid+i) + a*x(i);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+
+interpList = [17 18; 20 21; 23 24; 26 27; 29 30; 32 33; 34 35; 37 38; 40 41;
+    43 44; 46 47; 49 50; 52 53; 54 55; 57 58; 60 61; 63 64; 66 67; 68 69;
+    71 72; 74 75; 77 78; 80 81; 83 84; 86 87; 88 89; 91 92; 94 95; 97 98;
+   100 101; 103 104; 106 107; 108 109; 111 112; 114 115; 117 118; 120 121;
+   123 124; 125 126; 128 129; 131 132; 134 135; 137 138; 140 141; 143 144;
+   146 147; 148 149; 151 152; 154 155; 157 158; 159 160; 162 163; 165 166;
+   168 169; 171 172; 174 175; 177 178; 180 181; 183 184; 185 186];
+
+weight = [0.872357142857147 0.729428571428570 0.586500000000008 0.642571428571438...
+   0.314857142857137 0.186142857142853 0.872642857142856 0.914500000000007...
+   0.771571428571432 0.287499999999996 0.144571428571429 0.015857142857145...
+   0.057714285714284 0.729999999999997 0.786071428571432 0.458357142857143...
+   0.514428571428572 0.371500000000006 0.873214285714281 0.915071428571426...
+   0.786357142857144 0.657642857142860 0.699499999999996 0.201214285714288...
+   0.072499999999997 0.929571428571428 0.800857142857142 0.487357142857144...
+   0.344428571428574 0.386285714285715 0.072785714285708 0.114642857142855...
+   0.801142857142855 0.487642857142857 0.529500000000003 0.571357142857144...
+   0.243642857142855 0.114928571428566 0.801428571428572 0.843285714285717...
+   0.700357142857147 0.386857142857137 0.243928571428567 0.115214285714281...
+   0.157071428571423 0.014142857142857 0.700642857142863 0.571928571428569...
+   0.428999999999999 0.300285714285713 0.972571428571428 0.843857142857145...
+   0.885714285714284 0.742785714285723 0.784642857142856 0.300571428571429...
+   0.157642857142848 0.028928571428566 0.070785714285717 0.757285714285723]';
+
+
+y = sym(zeros(61,1));
+
+% y1 = (1-weight).*(x(interpList(:,1))/x(100))+weight.*(x(interpList(:,2))/x(100));
+y1 = (1-weight).*(x(interpList(:,1))+x(interpList(:,1)+n_grid))+weight.*(x(interpList(:,2))+x(interpList(:,2)+n_grid));
+
+y2 = 2*trapz(grid,x(1:n_grid)+x(1+n_grid:2*n_grid));
+
+y = [s_1*y1; y2];
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_ft.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_ft.m
new file mode 100644
index 0000000000000000000000000000000000000000..7888b15cbabd28cec45c4b7ca84f6a4059bc3947
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_ft.m
@@ -0,0 +1,80 @@
+function [model] = Pom1p_AP_syms_ft()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) - a*x(1) + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - a*x(n_grid) + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - m*x(n_grid+1) + a*x(1);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - m*x(2*n_grid) + a*x(n_grid);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - a*x(i) + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - m*x(n_grid+i) + a*x(i);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75);
+y = s_2*trapz(grid(Q),x(Q)+x(Q+n_grid));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_ht.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_ht.m
new file mode 100644
index 0000000000000000000000000000000000000000..5f80d14d468812b3f83dc9e065ca9b4667512fae
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_syms_ht.m
@@ -0,0 +1,80 @@
+function [model] = Pom1p_AP_syms_ht()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) - a*x(1) + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - a*x(n_grid) + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - m*x(n_grid+1) + a*x(1);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - m*x(2*n_grid) + a*x(n_grid);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - a*x(i) + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - m*x(n_grid+i) + a*x(i);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75 & grid>0);
+y = s_3*trapz(grid(Q),x(Q)+x(Q+n_grid));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_wrap.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_wrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..6616cbf47d4e28acfdf3fa16d74aa9f99a3efc35
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_AP_wrap.m
@@ -0,0 +1,25 @@
+% clear all
+% close all
+% clc
+
+%% COMPILATION
+
+[exdir,~,~]=fileparts(which('Pom1p_AP_wrap.m'));
+
+% compile the model
+amiwrap('Pom1p_AP_model_hess_eq','Pom1p_AP_syms_eq',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_AP_model_hess_eq']))
+
+% compile the full tip model
+amiwrap('Pom1p_AP_model_hess_ft','Pom1p_AP_syms_ft',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_AP_model_hess_ft']))
+
+% compile the model
+amiwrap('Pom1p_AP_model_hess_ht','Pom1p_AP_syms_ht',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_AP_model_hess_ht']))
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_eq.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_eq.m
new file mode 100644
index 0000000000000000000000000000000000000000..b8ba4f692858bd4f0a9e26caac4b6a3c0ebd5369
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_eq.m
@@ -0,0 +1,103 @@
+function [model] = Pom1p_MSP_syms_eq()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D a J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,a,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) - a*x(1).^2 + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - a*x(n_grid).^2 + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - a*x(i).^2 + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+interpList = [17 18; 20 21; 23 24; 26 27; 29 30; 32 33; 34 35; 37 38; 40 41;
+    43 44; 46 47; 49 50; 52 53; 54 55; 57 58; 60 61; 63 64; 66 67; 68 69;
+    71 72; 74 75; 77 78; 80 81; 83 84; 86 87; 88 89; 91 92; 94 95; 97 98;
+   100 101; 103 104; 106 107; 108 109; 111 112; 114 115; 117 118; 120 121;
+   123 124; 125 126; 128 129; 131 132; 134 135; 137 138; 140 141; 143 144;
+   146 147; 148 149; 151 152; 154 155; 157 158; 159 160; 162 163; 165 166;
+   168 169; 171 172; 174 175; 177 178; 180 181; 183 184; 185 186];
+
+weight = [0.872357142857147 0.729428571428570 0.586500000000008 0.642571428571438...
+   0.314857142857137 0.186142857142853 0.872642857142856 0.914500000000007...
+   0.771571428571432 0.287499999999996 0.144571428571429 0.015857142857145...
+   0.057714285714284 0.729999999999997 0.786071428571432 0.458357142857143...
+   0.514428571428572 0.371500000000006 0.873214285714281 0.915071428571426...
+   0.786357142857144 0.657642857142860 0.699499999999996 0.201214285714288...
+   0.072499999999997 0.929571428571428 0.800857142857142 0.487357142857144...
+   0.344428571428574 0.386285714285715 0.072785714285708 0.114642857142855...
+   0.801142857142855 0.487642857142857 0.529500000000003 0.571357142857144...
+   0.243642857142855 0.114928571428566 0.801428571428572 0.843285714285717...
+   0.700357142857147 0.386857142857137 0.243928571428567 0.115214285714281...
+   0.157071428571423 0.014142857142857 0.700642857142863 0.571928571428569...
+   0.428999999999999 0.300285714285713 0.972571428571428 0.843857142857145...
+   0.885714285714284 0.742785714285723 0.784642857142856 0.300571428571429...
+   0.157642857142848 0.028928571428566 0.070785714285717 0.757285714285723]';
+
+
+y = sym(zeros(61,1));
+
+y1 = (1-weight).*x(interpList(:,1))+weight.*x(interpList(:,2));
+y2 = 2*trapz(grid,x);
+
+y = [s_1*y1; y2];
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_ft.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_ft.m
new file mode 100644
index 0000000000000000000000000000000000000000..72ad9e7d54bac0da6fd0c1c39479d637e447ba5e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_ft.m
@@ -0,0 +1,74 @@
+function [model] = Pom1p_MSP_syms_ft()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D a J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,a,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) - a*x(1).^2 + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - a*x(n_grid).^2 + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - a*x(i).^2 + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75);
+y = s_2*trapz(grid(Q),x(Q));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_ht.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_ht.m
new file mode 100644
index 0000000000000000000000000000000000000000..d0932f55c7c110359bc5ae7e156a9018073cab95
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_syms_ht.m
@@ -0,0 +1,74 @@
+function [model] = Pom1p_MSP_syms_ht()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D a J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,a,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) - a*x(1).^2 + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - a*x(n_grid).^2 + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - a*x(i).^2 + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75 & grid>0);
+y = s_3*trapz(grid(Q),x(Q));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_wrap.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_wrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..d4091753bc37d1a76b974d8335be67a52a4320ae
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_MSP_wrap.m
@@ -0,0 +1,25 @@
+% clear all
+% close all
+% clc
+
+%% COMPILATION
+
+[exdir,~,~]=fileparts(which('Pom1p_MSP_wrap.m'));
+
+% compile the model
+amiwrap('Pom1p_MSP_model_hess_eq','Pom1p_MSP_syms_eq',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_MSP_model_hess_eq']))
+
+% compile the full tip model
+amiwrap('Pom1p_MSP_model_hess_ft','Pom1p_MSP_syms_ft',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_MSP_model_hess_ft']))
+
+% compile the model
+amiwrap('Pom1p_MSP_model_hess_ht','Pom1p_MSP_syms_ht',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_MSP_model_hess_ht']))
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..ea9251b8999cc41503778fb9c2e15b2f46329c8f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms.m
@@ -0,0 +1,84 @@
+function [model] = Pom1p_NLIC_syms()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-10; 
+% set the default relative tolerance
+% model.rtol = 1e-10; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'lin'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a b e J w_tea s_c s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,b,e,J,w_tea,s_c,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) + a*x(n_grid+1) -b*x(1)*x(n_grid+1) -m*x(1) + e*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) + a*x(2*n_grid) -b*x(n_grid)*x(2*n_grid) -m*x(n_grid) + e*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - a*x(n_grid+1) + b*x(1)*x(n_grid+1) + (1-e)*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - a*x(2*n_grid) + b*x(n_grid)*x(2*n_grid) + (1-e)*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) + a*x(n_grid+i) -b*x(i)*x(n_grid+i) -m*x(i) + e*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - a*x(n_grid+i) + b*x(i)*x(n_grid+i) + (1-e)*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+
+y =sym('y',[n_grid,1]);
+
+for i = 1:n_grid
+    y(i) = x(i)+s_c*x(i+n_grid);
+end
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_eq.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_eq.m
new file mode 100644
index 0000000000000000000000000000000000000000..2f69ee9f1b41922e8fc1225ad2c482865dc64b77
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_eq.m
@@ -0,0 +1,113 @@
+function [model] = Pom1p_NLIC_syms_eq()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-10; 
+% set the default relative tolerance
+% model.rtol = 1e-10; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a b e J w_tea s_c s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,b,e,J,w_tea,s_c,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) + a*x(n_grid+1) -b*x(1)*x(n_grid+1) -m*x(1) + e*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) + a*x(2*n_grid) -b*x(n_grid)*x(2*n_grid) -m*x(n_grid) + e*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - a*x(n_grid+1) + b*x(1)*x(n_grid+1) + (1-e)*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - a*x(2*n_grid) + b*x(n_grid)*x(2*n_grid) + (1-e)*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) + a*x(n_grid+i) -b*x(i)*x(n_grid+i) -m*x(i) + e*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - a*x(n_grid+i) + b*x(i)*x(n_grid+i) + (1-e)*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+
+interpList = [17 18; 20 21; 23 24; 26 27; 29 30; 32 33; 34 35; 37 38; 40 41;
+    43 44; 46 47; 49 50; 52 53; 54 55; 57 58; 60 61; 63 64; 66 67; 68 69;
+    71 72; 74 75; 77 78; 80 81; 83 84; 86 87; 88 89; 91 92; 94 95; 97 98;
+   100 101; 103 104; 106 107; 108 109; 111 112; 114 115; 117 118; 120 121;
+   123 124; 125 126; 128 129; 131 132; 134 135; 137 138; 140 141; 143 144;
+   146 147; 148 149; 151 152; 154 155; 157 158; 159 160; 162 163; 165 166;
+   168 169; 171 172; 174 175; 177 178; 180 181; 183 184; 185 186];
+
+weight = [0.872357142857147 0.729428571428570 0.586500000000008 0.642571428571438...
+   0.314857142857137 0.186142857142853 0.872642857142856 0.914500000000007...
+   0.771571428571432 0.287499999999996 0.144571428571429 0.015857142857145...
+   0.057714285714284 0.729999999999997 0.786071428571432 0.458357142857143...
+   0.514428571428572 0.371500000000006 0.873214285714281 0.915071428571426...
+   0.786357142857144 0.657642857142860 0.699499999999996 0.201214285714288...
+   0.072499999999997 0.929571428571428 0.800857142857142 0.487357142857144...
+   0.344428571428574 0.386285714285715 0.072785714285708 0.114642857142855...
+   0.801142857142855 0.487642857142857 0.529500000000003 0.571357142857144...
+   0.243642857142855 0.114928571428566 0.801428571428572 0.843285714285717...
+   0.700357142857147 0.386857142857137 0.243928571428567 0.115214285714281...
+   0.157071428571423 0.014142857142857 0.700642857142863 0.571928571428569...
+   0.428999999999999 0.300285714285713 0.972571428571428 0.843857142857145...
+   0.885714285714284 0.742785714285723 0.784642857142856 0.300571428571429...
+   0.157642857142848 0.028928571428566 0.070785714285717 0.757285714285723]';
+
+
+y = sym(zeros(61,1));
+xhelp = x(1:n_grid)+s_c*x(1+n_grid:2*n_grid);
+
+% y1 = (1-weight).*(x(interpList(:,1))/x(100))+weight.*(x(interpList(:,2))/x(100));
+y1 = (1-weight).*xhelp(interpList(:,1))+weight.*xhelp(interpList(:,2));
+
+y2 = 2*trapz(grid,xhelp);
+
+y = [s_1*y1; y2];
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_ft.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_ft.m
new file mode 100644
index 0000000000000000000000000000000000000000..29c77b7a13e1a114f83d785665d9804bdda57a4c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_ft.m
@@ -0,0 +1,80 @@
+function [model] = Pom1p_NLIC_syms_ft()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-10; 
+% set the default relative tolerance
+% model.rtol = 1e-10; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a b e J w_tea s_c s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,b,e,J,w_tea,s_c,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) + a*x(n_grid+1) -b*x(1)*x(n_grid+1) -m*x(1) + e*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) + a*x(2*n_grid) -b*x(n_grid)*x(2*n_grid) -m*x(n_grid) + e*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - a*x(n_grid+1) + b*x(1)*x(n_grid+1) + (1-e)*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - a*x(2*n_grid) + b*x(n_grid)*x(2*n_grid) + (1-e)*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) + a*x(n_grid+i) -b*x(i)*x(n_grid+i) -m*x(i) + e*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - a*x(n_grid+i) + b*x(i)*x(n_grid+i) + (1-e)*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75);
+y = s_2*trapz(grid(Q),x(Q)+s_c*x(Q+n_grid));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_ht.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_ht.m
new file mode 100644
index 0000000000000000000000000000000000000000..cac4040b7785f2370027926b8a5fe7ff34cd85a2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_syms_ht.m
@@ -0,0 +1,80 @@
+function [model] = Pom1p_NLIC_syms_ht()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-10; 
+% set the default relative tolerance
+% model.rtol = 1e-10; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('p',[2*n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D xi m a b e J w_tea s_c s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,xi,m,a,b,e,J,w_tea,s_c,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[2*n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+% p boundary
+xdot(1) = D*h*(x(2)-x(1)) + a*x(n_grid+1) -b*x(1)*x(n_grid+1) -m*x(1) + e*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) + a*x(2*n_grid) -b*x(n_grid)*x(2*n_grid) -m*x(n_grid) + e*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+% p_p boundary
+xdot(n_grid+1) = (D*xi)*h*(x(n_grid+2)-x(n_grid+1)) - a*x(n_grid+1) + b*x(1)*x(n_grid+1) + (1-e)*J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(2*n_grid) = (D*xi)*h*(x(2*n_grid-1)-x(2*n_grid)) - a*x(2*n_grid) + b*x(n_grid)*x(2*n_grid) + (1-e)*J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) + a*x(n_grid+i) -b*x(i)*x(n_grid+i) -m*x(i) + e*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+ xdot(n_grid+i) = (D*xi)*h*(x(n_grid+i-1)+x(n_grid+i+1)-2*x(n_grid+i)) - a*x(n_grid+i) + b*x(i)*x(n_grid+i) + (1-e)*J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75 & grid>0);
+y = s_3*trapz(grid(Q),x(Q)+s_c*x(Q+n_grid));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_wrap.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_wrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..e57ce06b04a97df27dd9ce95d725e267dfa0665d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_NLIC_wrap.m
@@ -0,0 +1,25 @@
+% clear all
+% close all
+% clc
+
+%% COMPILATION
+
+[exdir,~,~]=fileparts(which('Pom1p_NLIC_wrap.m'));
+
+% compile the model
+amiwrap('Pom1p_NLIC_model_hess_eq','Pom1p_NLIC_syms_eq',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_NLIC_model_hess_eq']))
+
+% compile the full tip model
+amiwrap('Pom1p_NLIC_model_hess_ft','Pom1p_NLIC_syms_ft',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_NLIC_model_hess_ft']))
+
+% compile the model
+amiwrap('Pom1p_NLIC_model_hess_ht','Pom1p_NLIC_syms_ht',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_NLIC_model_hess_ht']))
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_eq.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_eq.m
new file mode 100644
index 0000000000000000000000000000000000000000..853f7fc4707b831a84c1d77a87339520cb9433ba
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_eq.m
@@ -0,0 +1,105 @@
+function [model] = Pom1p_SDD_syms_eq()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('g',[n_grid,1]);
+%x = sym('p',[n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D m J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,m,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+xdot(1) = D*h*(x(2)-x(1)) - m*x(1) + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - m*x(n_grid) + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - m*x(i) + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+
+interpList = [17 18; 20 21; 23 24; 26 27; 29 30; 32 33; 34 35; 37 38; 40 41;
+    43 44; 46 47; 49 50; 52 53; 54 55; 57 58; 60 61; 63 64; 66 67; 68 69;
+    71 72; 74 75; 77 78; 80 81; 83 84; 86 87; 88 89; 91 92; 94 95; 97 98;
+   100 101; 103 104; 106 107; 108 109; 111 112; 114 115; 117 118; 120 121;
+   123 124; 125 126; 128 129; 131 132; 134 135; 137 138; 140 141; 143 144;
+   146 147; 148 149; 151 152; 154 155; 157 158; 159 160; 162 163; 165 166;
+   168 169; 171 172; 174 175; 177 178; 180 181; 183 184; 185 186];
+
+weight = [0.872357142857147 0.729428571428570 0.586500000000008 0.642571428571438...
+   0.314857142857137 0.186142857142853 0.872642857142856 0.914500000000007...
+   0.771571428571432 0.287499999999996 0.144571428571429 0.015857142857145...
+   0.057714285714284 0.729999999999997 0.786071428571432 0.458357142857143...
+   0.514428571428572 0.371500000000006 0.873214285714281 0.915071428571426...
+   0.786357142857144 0.657642857142860 0.699499999999996 0.201214285714288...
+   0.072499999999997 0.929571428571428 0.800857142857142 0.487357142857144...
+   0.344428571428574 0.386285714285715 0.072785714285708 0.114642857142855...
+   0.801142857142855 0.487642857142857 0.529500000000003 0.571357142857144...
+   0.243642857142855 0.114928571428566 0.801428571428572 0.843285714285717...
+   0.700357142857147 0.386857142857137 0.243928571428567 0.115214285714281...
+   0.157071428571423 0.014142857142857 0.700642857142863 0.571928571428569...
+   0.428999999999999 0.300285714285713 0.972571428571428 0.843857142857145...
+   0.885714285714284 0.742785714285723 0.784642857142856 0.300571428571429...
+   0.157642857142848 0.028928571428566 0.070785714285717 0.757285714285723]';
+
+
+y = sym(zeros(61,1));
+
+% y1 = (1-weight).*(x(interpList(:,1))/x(100))+weight.*(x(interpList(:,2))/x(100));
+y1 = (1-weight).*x(interpList(:,1))+weight.*x(interpList(:,2));
+y2 = 2*trapz(grid,x);
+
+y = [s_1*y1; y2];
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_ft.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_ft.m
new file mode 100644
index 0000000000000000000000000000000000000000..04d39e43deb6c8cc03a504470809dde8ded04b9b
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_ft.m
@@ -0,0 +1,73 @@
+function [model] = Pom1p_SDD_syms_ft()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('g',[n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D m J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,m,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+xdot(1) = D*h*(x(2)-x(1)) - m*x(1) + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - m*x(n_grid) + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - m*x(i) + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75);
+y = s_2*trapz(grid(Q),x(Q));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_ht.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_ht.m
new file mode 100644
index 0000000000000000000000000000000000000000..0a2e37c005deac3df6a15a04a38a5152525dc7ec
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_syms_ht.m
@@ -0,0 +1,73 @@
+function [model] = Pom1p_SDD_syms_ht()
+
+%% CVODES OPTIONS
+
+% set the default absolute tolerance
+% model.atol = 1e-8; 
+% set the default relative tolerance
+% model.rtol = 1e-8; 
+% set the default maximum number of integration steps
+% model.maxsteps = 1e4; 
+% set the parametrisation of the problem options are 'log', 'log10' and
+% 'lin' (default).
+model.param = 'log10'; 
+% model.noadjoint = true;
+
+%% PDE discretization
+n_grid = 200;
+grid = linspace(-7,7,n_grid);
+h = (n_grid/14)^2;
+
+%% STATES
+% create state syms: vector for p at each grid point (gridsize: 281 -> -7:0.05:7)
+x = sym('g',[n_grid,1]);
+
+%% PARAMETERS ( for these sensitivities will be computed )
+
+% create parameter syms
+syms D m J w_tea s_1 s_2 s_3
+
+% create parameter vector 
+p = [D,m,J,w_tea,s_1,s_2,s_3];
+
+%% CONSTANTS ( for these no sensitivities will be computed )
+% this part is optional and can be ommited
+
+% create parameter syms
+k = sym('k',[n_grid,1]);
+
+%% SYSTEM EQUATIONS
+
+% create symbolic variable for time
+syms t
+
+xdot = sym(zeros(size(x)));
+
+xdot(1) = D*h*(x(2)-x(1)) - m*x(1) + J*exp(-grid(1)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+xdot(n_grid) = D*h*(x(n_grid-1)-x(n_grid)) - m*x(n_grid) + J*exp(-grid(n_grid)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+
+for i = 2:n_grid-1
+ xdot(i) = D*h*(x(i-1)+x(i+1)-2*x(i)) - m*x(i) + J*exp(-grid(i)^2./(2*w_tea.^2))/(sqrt(2*pi)*w_tea);
+end
+
+%% INITIAL CONDITIONS
+
+x0 = sym(zeros(size(x)));
+
+for i = 1:n_grid
+    x0(i) = k(i);
+end
+
+%% OBSERVALES
+Q = find(abs(grid)<0.5*pi*1.75 & grid>0);
+y = s_3*trapz(grid(Q),x(Q));
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_wrap.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_wrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..24c9afcb83acf631be527fa7b667a3818e455588
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/Models/Pom1p_SDD_wrap.m
@@ -0,0 +1,26 @@
+% clear all
+% close all
+% clc
+
+%% COMPILATION
+
+[exdir,~,~]=fileparts(which('Pom1p_SDD_wrap.m'));
+
+% compile the model
+amiwrap('Pom1p_SDD_model_hess_eq','Pom1p_SDD_syms_eq',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_SDD_model_hess_eq']))
+
+% compile the full tip model
+amiwrap('Pom1p_SDD_model_hess_ft','Pom1p_SDD_syms_ft',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_SDD_model_hess_ft']))
+
+% compile the model
+amiwrap('Pom1p_SDD_model_hess_ht','Pom1p_SDD_syms_ht',exdir)
+
+% add the model to the path
+addpath(genpath([strrep(which('amiwrap.m'),'amiwrap.m','') 'models/Pom1p_SDD_model_hess_ht']))
+
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/logLikelihoodPom1.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/logLikelihoodPom1.m
new file mode 100644
index 0000000000000000000000000000000000000000..b50181bd42d4a201667dd41ed0e38090fb51af1c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/logLikelihoodPom1.m
@@ -0,0 +1,159 @@
+function [varargout] = logLikelihoodPom1(varargin)
+%function [ F ] = MLEPom1P_w_grad(p, options)
+% Calculates the MLE vector and gradient for fmincon for the kinetic parameters
+%
+% USAGE:
+% ======
+% [...] = logLikelihoodPom1(parameter,options)
+%
+% INPUTS:
+% =======
+% parameter ... log-parameter values in the order given by options.name
+% options ... structure needed to evaluate the Likelihood
+%   .options.datafile path to load options.Data file
+%   .disc     structure containing the PDE solver information
+%   .name     parameter names
+%   .sign     default: negative
+%   .grad_ind default: 1:length(p)
+%   .type     default: 'none'
+%
+% Outputs:
+% ========
+% F  ... negative log-Likelihood
+% dF ... gradient of negative log-Likelihood in the 
+%    order of options.name
+%
+% 2013/04/20 Sabrina Hock
+% 2016/10/17 Anna Fiedler
+
+%% CHECK AND ASSIGN INPUTS
+if nargin >= 1
+    p = varargin{1};
+else
+    error('logLikelihoodPom1 requires a parameter object as input.');
+end
+
+% Check and assign options
+if nargin == 2
+    options = varargin{2};
+else
+    error('logLikelihoodPom1 requires a option object as input.');
+end
+
+% Check function evaluation counter
+if strcmp(options.counter,'true')
+    global fcn_count
+    fcn_count = fcn_count + 1;
+end
+
+
+%% asign data
+n_data = [196,0,13,14,82];
+
+Data{1}.Y = options.Estdata{1}.Data(:,2);
+Data{1}.Sigma_Y = options.Estdata{1}.Data(:,3)./sqrt(n_data(1))';
+
+Data{2}.Y = options.Estdata{2}.Data(:,2);
+Data{2}.Sigma_Y = options.Estdata{2}.Data(:,3)./sqrt(n_data(3));
+
+Data{3}.Y = options.Estdata{3}.Data(:,2);
+Data{3}.Sigma_Y = options.Estdata{3}.Data(:,3)./sqrt(n_data(4));
+
+Data{4}.Y = options.Estdata{4}.Data(1);
+Data{4}.Sigma_Y = options.Estdata{4}.Data(2)./sqrt(n_data(5));
+
+% asign model functions
+modelEq = str2func(['simulate_Pom1p_',options.model_type,'_model_hess_eq']);
+modelFt = str2func(['simulate_Pom1p_',options.model_type,'_model_hess_ft']);
+modelHt = str2func(['simulate_Pom1p_',options.model_type,'_model_hess_ht']);
+
+% asign options
+options_simu.sensi = 1;
+options_simu.maxsteps = 1e6;
+
+% asign dimensions
+n_grid = length(options.disc.p);
+switch options.model_type 
+    case 'SDD'
+        n_comp = 1;
+    case 'MSP'
+        n_comp = 1;
+    case 'AP'
+        n_comp = 2;
+    case 'NLIC'
+        n_comp = 2;
+end
+
+%% compute objective function value     
+J = 0;
+dJ = 0;
+        
+% solve stedy state PDE
+T = 500;
+flag_ss = 0;
+n = 1;
+n_max = 10;
+x0 = zeros(n_grid*n_comp,1);
+while (n < n_max) && (flag_ss == 0)
+    sol = modelEq(T,p,x0,[],options_simu);
+    if sum(sol.xdot.^2) < 1e-6
+        flag_ss = 1;
+    elseif sol.status < 0
+        break
+    else
+        x0 = sol.x(end,:);
+        options_simu.sx0 = squeeze(sol.sx(end,:,:));
+        T = 2*T;
+    end
+end
+if flag_ss
+    % Data set 1 - mean intensity profiles
+    J = J - 0.5*sum(sum(log(2*pi*Data{1}.Sigma_Y.^2) + (Data{1}.Y-sol.y(end,1:end-1)').^2./(Data{1}.Sigma_Y.^2)));
+    dJ = dJ + permute(sol.sy(end,1:end-1,:),[3,2,1])*((Data{1}.Y-sol.y(end,1:end-1)')./(Data{1}.Sigma_Y.^2));
+    
+    % Data set 4 - total molecule number
+    J = J - 0.5*sum(sum(log(2*pi*Data{4}.Sigma_Y.^2) + (Data{4}.Y-sol.y(end,end)).^2./(Data{4}.Sigma_Y.^2)));
+    dJ = dJ + permute(sol.sy(end,end,:),[3,2,1])*((Data{4}.Y-sol.y(end,end))./(Data{4}.Sigma_Y.^2));
+else
+    error('not converged');
+end
+
+% Data set 2 - full tip FRAP
+% solve PDE for full tip bleaching
+Q{3} = find(abs(options.disc.p)<0.5*pi*1.75);
+x0 = squeeze(sol.x(end,:));
+sx0 = squeeze(sol.sx(end,:,:));
+for n = 1:n_comp
+    x0((n-1)*n_grid+Q{3}) = 0;
+    sx0((n-1)*n_grid+Q{3},:) = 0;
+end
+
+options_simu.sx0 = sx0;
+sol_full = modelFt(options.Estdata{2}.Data(:,1),p,x0,[],options_simu);
+J = J - 0.5*sum(sum(log(2*pi*Data{2}.Sigma_Y.^2) + ((Data{2}.Y-sol_full.y).^2./(Data{2}.Sigma_Y.^2))));
+dJ = dJ + permute(sol_full.sy,[3,1,2])*((Data{2}.Y-sol_full.y)./(Data{2}.Sigma_Y.^2));
+
+% Data set 2 - half tip FRAP
+% solve PDE for half tip bleaching
+Q{4} = find(options.disc.p<0.5*pi*1.75 & options.disc.p>0);
+x0 = squeeze(sol.x(end,:));
+sx0 = squeeze(sol.sx(end,:,:));
+for n = 1:n_comp
+    x0((n-1)*n_grid+Q{4}) = 0;
+    sx0((n-1)*n_grid+Q{4},:) = 0;
+end
+
+options_simu.sx0 = sx0;
+sol_half = modelHt(options.Estdata{3}.Data(:,1),p,x0,[],options_simu);
+J = J - 0.5*sum(sum(log(2*pi*Data{3}.Sigma_Y.^2) + ((Data{3}.Y-sol_half.y).^2./(Data{3}.Sigma_Y.^2))));
+dJ = dJ + permute(sol_half.sy,[3,1,2])*((Data{3}.Y-sol_half.y)./(Data{3}.Sigma_Y.^2));
+
+switch nargout
+    case 1
+        varargout{1} = J;  
+    case 2 
+        varargout{1} = J;
+        varargout{2} = dJ(options.grad_ind);
+end
+end
+
diff --git a/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/mainPom1.m b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/mainPom1.m
new file mode 100644
index 0000000000000000000000000000000000000000..af83e54243b8569e67619925772f0af86a1e4bb3
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/Pom1p_gradient_formation/mainPom1.m
@@ -0,0 +1,133 @@
+% Main file of Pom1 example
+%
+% Demonstrates the use of:
+% * getMultiStarts()
+% 
+% This example provides four models for Pom1 gradient formation. The SDD 
+% and NLIC were adapted from Saunders et al. (2012). The AP was adapted 
+% from Hachet et al. (2011) and the MSP from Hersch et al. (2015).
+
+clear all;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed random number generator
+rng(0);
+
+%% Model Definition
+% The models are provided as AMICI syms files in the folder Models
+addpath('Models');
+
+%% Data
+% load data provided in Saunders et. al (2011)
+% absolute file paths can be used instead of relative ones
+options.optionsLogPost.Estdata{1} = load('./Data/Saunders2011/FigureS5A.mat');
+options.optionsLogPost.Estdata{2} = load('./Data/Saunders2011/FigureS5C.mat');
+options.optionsLogPost.Estdata{3} = load('./Data/Saunders2011/FigureS5D.mat');
+options.optionsLogPost.Estdata{4} = load('./Data/Saunders2011/Figure1C.mat');
+
+%% GENREAL PARAMETERS
+options.startdate = datestr(now,'yyyy-mm-dd');
+options.starttime = datestr(now,'HH-MM');
+
+% choose gradient formation model
+% 'SDD' : source diffusion degradation model
+% 'NLIC': non-linear clustering model
+% 'AP'  : autophosphorylation model
+% 'MSP' : multi-site phosphorylation model
+model = 'MSP'; % 'SDD';
+
+%% parameters
+switch model
+    case 'SDD'
+        % Set 5 basic kinetic parameters
+        parameters_est.number = 7;
+        parameters_est.guess = log10(exp([-0.5,-3,5,-2,-7.184617366,-9.44,-8.69]')); %log
+        parameters_est.min = [  -2,  -5,  0,   -1.5,   -5,   -5, -5]';
+        parameters_est.max = [   2,   2,  4,      2,   -2,   -2, -2]';
+        parameters_est.name = {'D','mu','J','w_tea','s_1','s_2','s_3'};
+        Pom1p_SDD_wrap;
+    case 'MSP'
+        % Set 5 basic kinetic parameters
+        parameters_est.number = 7;
+        parameters_est.guess = log10(exp([-1.8,-9,6,-1.45,-7.133,-9.44,-8.69]'));
+        parameters_est.min = [  -2, -5,  0,   -1.5,   -5,   -5, -5]';
+        parameters_est.max = [   2,  2,  4,      2,   -2,   -2, -2]';
+        parameters_est.name = {'D','a','J','w_tea','s_1','s_2','s_3'};
+        Pom1p_MSP_wrap;
+    case 'AP'
+        % Set 6 basic kinetic parameters
+        parameters_est.number = 9;
+        parameters_est.guess = log10(exp([-2,-4,-2,-1.7, 5, 0,-6.1836,-8.7,-8]'));
+        parameters_est.min =   [-2,  -5,  -5, -5,  0,   -1.5,   -5,   -5, -5]';
+        parameters_est.max =   [ 2,   0,   2,  2,  4,      2,   -2,   -2, -2]';
+        parameters_est.name = {'D','xi','mu','a','J','w_tea','s_1','s_2','s_3'};
+        Pom1p_AP_wrap;
+    case 'NLIC'
+        % Set 7 basic kinetic parameters
+        parameters_est.number = 12;
+        parameters_est.guess = log10(exp([-2,-4,-5,-10,-10,log(0.9),4,-1.45,0.6,-8.3705,-8.5,-7.6]'));
+        parameters_est.min = [ -2,  -5,  - 5, -5, -5, -8,  0,   -1.5,  1.2,  -5, -5, -5]';
+        parameters_est.max = [  2,   0,    2,  2,  2,  0,  4,      2,    3,  -2, -2, -2]';
+        parameters_est.name = {'D','xi','mu','a','b','e','J','w_tea','s_c','s_1','s_2','s_3'};
+        Pom1p_NLIC_wrap;
+end
+
+%% OPTIMIZATION OPTIONS
+% Check and assign options
+options.optionsMultistart = PestoOptions();
+options.optionsMultistart.obj_type = 'log-posterior';
+options.optionsMultistart.comp_type = 'sequential';
+options.optionsMultistart.localOptimizerOptions = optimset(options.optionsMultistart.localOptimizerOptions,...
+   'Algorithm','interior-point',...
+   'Display','off',...
+   'GradObj','on',...
+   'TolFun',1e-8,...
+   'TolX',1e-8,...
+   'MaxFunEvals',3000*parameters_est.number,...
+   'MaxIter',600);                
+options.optionsMultistart.n_starts = 5;
+options.optionsMultistart.proposal = 'uniform';
+options.optionsMultistart.mode = 'text';
+options.optionsMultistart.save = true;
+options.optionsMultistart.fh = [];
+
+%% Set-up pde grid
+% grid: -7:7 with 0.1, R = 1.75
+% equidistant grid
+% Changes in the grid have to be carried out in the model files as well!
+
+n_grid = 200;
+p = linspace(-7,7,200);
+options.optionsLogPost.disc = struct('p',p);
+
+%% LIKELIHOOD OPTIONS
+options.optionsLogPost.counter = 'false';
+options.optionsLogPost.grad_ind = (1:parameters_est.number)';
+options.optionsLogPost.name = parameters_est.name;
+options.optionslogPost.plot = 'true';
+options.optionsLogPost.model_type = model;
+
+% log-likelihood function
+objectiveFunction = @(theta) logLikelihoodPom1(theta,options.optionsLogPost);
+
+%% MULTI-START OPTIMIZATION
+disp('Start: Multi-start optimization');
+
+[parameters_est,fh1] = getMultiStarts(parameters_est,objectiveFunction,...
+    options.optionsMultistart);
+
+% save results
+if options.optionsMultistart.save
+    % create directory for estimation results
+    if isdir(options.startdate)==0
+        mkdir(options.startdate);
+    end
+    save([options.startdate,'/EstPom1P_',...
+        options.optionsLogPost.model_type,'_',options.starttime,'.mat'],...
+        'parameters_est','options','objectiveFunction');
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/BachmannJakStat_SHP1oe_syms.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/BachmannJakStat_SHP1oe_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..66b8d70ee6ca521dc330cf6e671f169dfca123e0
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/BachmannJakStat_SHP1oe_syms.m
@@ -0,0 +1,11 @@
+function model = BachmannJakStat_SHP1oe_syms()
+% model for the simulation of experiment SHP1oe
+
+syms SHP1oe SHP1ProOE init_SHP1 SHP1Act SHP1
+
+model = BachmannJakStat_syms();
+
+model.sym.x0(7) = (init_SHP1 * (1 + (SHP1oe * SHP1ProOE))); 
+model.sym.y(18) = (SHP1 + SHP1Act)/init_SHP1;
+
+
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/BachmannJakStat_syms.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/BachmannJakStat_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..3b72aa66ca12a9b7569e764897f15a5e3b1cad01
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/BachmannJakStat_syms.m
@@ -0,0 +1,135 @@
+function model = BachmannJakStat_syms()
+
+syms t
+model.param = 'log10';
+
+%% PARAMETERS
+syms CISEqc CISEqcOE CISInh CISRNADelay  CISRNATurn CISTurn
+syms EpoRActJAK2 EpoRCISInh EpoRCISRemove JAK2ActEpo JAK2EpoRDeaSHP1 SHP1ActEpoR
+syms SHP1Dea SHP1ProOE SOCS3Eqc SOCS3EqcOE SOCS3Inh SOCS3RNADelay 
+syms SOCS3RNATurn SOCS3Turn STAT5ActEpoR STAT5ActJAK2 STAT5Exp STAT5Imp
+syms init_EpoRJAK2 init_SHP1 init_STAT5
+
+model.sym.p = [CISEqc
+CISEqcOE
+CISInh
+CISRNADelay
+CISRNATurn
+CISTurn
+EpoRActJAK2
+EpoRCISInh
+EpoRCISRemove
+JAK2ActEpo
+JAK2EpoRDeaSHP1
+SHP1ActEpoR
+SHP1Dea
+SHP1ProOE
+SOCS3Eqc
+SOCS3EqcOE
+SOCS3Inh
+SOCS3RNADelay
+SOCS3RNATurn
+SOCS3Turn
+STAT5ActEpoR
+STAT5ActJAK2
+STAT5Exp
+STAT5Imp
+init_EpoRJAK2
+init_SHP1
+init_STAT5];
+
+%% INPUT AND CONSTANTS
+syms ActD CISoe SOCS3oe SHP1oe Epo nuc cyt
+
+cyt = 0.4;
+nuc = 0.275;
+
+model.sym.k = [ActD CISoe SOCS3oe SHP1oe Epo];
+
+%% STATES
+syms EpoRJAK2 EpoRpJAK2 p1EpoRpJAK2 p2EpoRpJAK2 p12EpoRpJAK2 EpoRJAK2_CIS
+syms SHP1 SHP1Act STAT5 pSTAT5 npSTAT5 CISnRNA1 CISnRNA2
+syms CISnRNA3 CISnRNA4 CISnRNA5 CISRNA CIS
+syms SOCS3nRNA1 SOCS3nRNA2 SOCS3nRNA3 SOCS3nRNA4 SOCS3nRNA5 SOCS3RNA SOCS3
+
+model.sym.x = [EpoRJAK2;
+EpoRpJAK2;
+p1EpoRpJAK2;
+p2EpoRpJAK2;
+p12EpoRpJAK2;
+EpoRJAK2_CIS;
+SHP1;
+SHP1Act;
+STAT5;
+pSTAT5;
+npSTAT5;
+CISnRNA1;
+CISnRNA2;
+CISnRNA3;
+CISnRNA4;
+CISnRNA5;
+CISRNA;
+CIS;
+SOCS3nRNA1;
+SOCS3nRNA2;
+SOCS3nRNA3;
+SOCS3nRNA4;
+SOCS3nRNA5;
+SOCS3RNA;
+SOCS3];    
+
+model.sym.xdot = [EpoRpJAK2*(JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act + (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p12EpoRpJAK2 + (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p1EpoRpJAK2 + (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p2EpoRpJAK2 - (Epo*EpoRJAK2*JAK2ActEpo)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) ;
+ (Epo*EpoRJAK2*JAK2ActEpo)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (EpoRpJAK2*EpoRActJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (3*EpoRpJAK2*EpoRActJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) - EpoRpJAK2*(JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act ;
+ (EpoRpJAK2*EpoRActJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p1EpoRpJAK2 - (3*EpoRActJAK2*p1EpoRpJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ (3*EpoRpJAK2*EpoRActJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) - (EpoRActJAK2*p2EpoRpJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p2EpoRpJAK2 ;
+ (EpoRActJAK2*p2EpoRpJAK2)/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (JAK2EpoRDeaSHP1 / init_SHP1)*SHP1Act*p12EpoRpJAK2 + (3*EpoRActJAK2*p1EpoRpJAK2)/((EpoRCISInh*EpoRJAK2_CIS + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ -EpoRJAK2_CIS*(EpoRCISRemove / init_EpoRJAK2)*(p12EpoRpJAK2 + p1EpoRpJAK2) ;
+ SHP1Dea*SHP1Act - SHP1*(SHP1ActEpoR / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2) ;
+ SHP1*(SHP1ActEpoR / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2) - SHP1Dea*SHP1Act ;
+ (STAT5Exp*npSTAT5*nuc)/cyt - (STAT5*(STAT5ActJAK2 / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2))/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - (STAT5*(STAT5ActEpoR / init_EpoRJAK2^2)*(p12EpoRpJAK2 + p1EpoRpJAK2)^2)/((CIS*(CISInh / CISEqc) + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ (STAT5*(STAT5ActJAK2 / init_EpoRJAK2)*(EpoRpJAK2 + p12EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2))/(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1) - STAT5Imp*pSTAT5 + (STAT5*(STAT5ActEpoR / init_EpoRJAK2^2)*(p12EpoRpJAK2 + p1EpoRpJAK2)^2)/((CIS*(CISInh / CISEqc) + 1)*(SOCS3*(SOCS3Inh / SOCS3Eqc) + 1)) ;
+ (STAT5Imp*cyt*pSTAT5)/nuc - STAT5Exp*npSTAT5 ;
+ - CISnRNA1*CISRNADelay - (1 / init_STAT5)*CISRNATurn*npSTAT5*(ActD - 1) ;
+ CISnRNA1*CISRNADelay - CISnRNA2*CISRNADelay ;
+ CISnRNA2*CISRNADelay - CISnRNA3*CISRNADelay ;
+ CISnRNA3*CISRNADelay - CISnRNA4*CISRNADelay ;
+ CISnRNA4*CISRNADelay - CISnRNA5*CISRNADelay ;
+ (CISnRNA5*CISRNADelay*nuc)/cyt - CISRNA*CISRNATurn ;
+ CISRNA*CISEqc*CISTurn - CIS*CISTurn + CISoe*CISTurn*CISEqcOE * CISEqc ;
+ - SOCS3nRNA1*SOCS3RNADelay - (1 / init_STAT5)*SOCS3RNATurn*npSTAT5*(ActD - 1) ;
+ SOCS3nRNA1*SOCS3RNADelay - SOCS3nRNA2*SOCS3RNADelay ;
+ SOCS3nRNA2*SOCS3RNADelay - SOCS3nRNA3*SOCS3RNADelay ;
+ SOCS3nRNA3*SOCS3RNADelay - SOCS3nRNA4*SOCS3RNADelay ;
+ SOCS3nRNA4*SOCS3RNADelay - SOCS3nRNA5*SOCS3RNADelay ;
+ (SOCS3nRNA5*SOCS3RNADelay*nuc)/cyt - SOCS3RNA*SOCS3RNATurn ;
+ SOCS3RNA*SOCS3Eqc*SOCS3Turn - SOCS3*SOCS3Turn + SOCS3oe*SOCS3Turn*SOCS3EqcOE * SOCS3Eqc] ;
+
+model.sym.x0=sym(zeros(numel(model.sym.xdot),1));
+model.sym.x0(1) = init_EpoRJAK2;
+model.sym.x0(7) = init_SHP1; 
+model.sym.x0(9) = init_STAT5;
+
+%% OBSERVABLES
+model.sym.y = [1 / init_EpoRJAK2 *  2 * (EpoRpJAK2 + p1EpoRpJAK2 + p2EpoRpJAK2 + p12EpoRpJAK2);
+ 1 / init_EpoRJAK2 *  16 * (p1EpoRpJAK2 + p2EpoRpJAK2 + p12EpoRpJAK2);
+ 1 / CISEqc * CIS;
+ 1 / SOCS3Eqc * SOCS3;
+ 1 / init_STAT5 * (STAT5+pSTAT5);
+ 1 / init_STAT5 * pSTAT5;
+ STAT5;
+ SHP1 + SHP1Act;
+ CIS;
+ SOCS3;
+ 100*pSTAT5/(pSTAT5+STAT5);
+ SOCS3RNA;
+ SOCS3RNA;
+ SOCS3RNA;
+ CISRNA;
+ CISRNA;
+ CISRNA;
+ 1 / init_SHP1 * (SHP1 + SHP1Act) * (1 + (SHP1oe * SHP1ProOE));
+ 1 / CISEqc * CIS;
+ 1 / CISEqc * CIS];
+
+%% SIGMA
+model.sym.sigma_y = sym(ones(20,1));
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/bestxi.mat b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/bestxi.mat
new file mode 100644
index 0000000000000000000000000000000000000000..cae4c96c5769f8a03dc613a15e3d146121e06b02
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/bestxi.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/data_Bachmann.mat b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/data_Bachmann.mat
new file mode 100644
index 0000000000000000000000000000000000000000..48d805b6340c82fdcdf69b6a2b1298641173d157
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/data_Bachmann.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/exampleOptimizationResults.mat b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/exampleOptimizationResults.mat
new file mode 100644
index 0000000000000000000000000000000000000000..6fdcdc746de7d2bc0d218a0150eb24076bda5f15
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/exampleOptimizationResults.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/fillDataStruct.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/fillDataStruct.m
new file mode 100644
index 0000000000000000000000000000000000000000..7c1e0a607623d44bd82ee0ac172d950fb3afa0d0
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/fillDataStruct.m
@@ -0,0 +1,139 @@
+function D = fillDataStruct(D)
+% maps the offset, scaling and variance parameters to the corresponding
+% conditions
+
+for cond = 1:36
+    D(cond).offset = nan(20,1);
+    D(cond).scaling = nan(20,1);
+    D(cond).std = [106; 106; 105; 111;
+                113; 113; 112; 108; 104;
+                110; 114; 107; 107; 107; 
+                107; 107; 107 ;109; 105; 105]; % same for all conditions
+end
+
+% long
+D(1).offset([1:4,6]) = [52 44 32 36 58];
+D(1).scaling(1:6) = [92 84 68 76 102 98];
+D(1).name = 'long';
+
+% Concentration
+D(2).offset(11) = [57];
+D(2).name = 'Concentration';
+
+% RNA
+%D(3).offset([12:17]) = 1 �berall
+D(3).scaling([12:17]) = [72 73 74 63 64 65];
+D(3).name = 'RNA';
+
+% Act
+D(4).offset([1,2,3,6]) = [47 38 30 55];
+D(4).scaling([1,2,3,5,6]) = [87 78 66 101 95];
+D(5).offset = D(4).offset;
+D(5).scaling = D(4).scaling;
+D(4).name = 'ActD';
+D(5).name = 'ActD';
+
+% Fine
+D(6).offset([1,2]) = [51 43];
+D(6).scaling([1,2]) = [91 83];
+D(6).name = 'Fine';
+
+% CIsoe
+D(7).offset([1,2,3,4,6]) = [48 39 31 35 56];
+D(7).scaling([1,2,3,4,6]) = [88 79 67 75 96];
+D(8).offset = D(7).offset;
+D(8).scaling = D(7).scaling;
+D(7).name = 'CISoe';
+D(8).name = 'CISoe';
+
+% CISoe_pEpoR 
+D(9).offset(2) = [40];
+D(9).scaling(2) = [80];
+D(10).offset = D(9).offset;
+D(10).scaling = D(9).scaling;
+D(9).name = 'CISoe_pEpoR';
+D(10).name = 'CISoe_pEpoR';
+
+% SOCS3oe
+D(11).offset([1,2,3,4,6]) = [54 46 34 37 60];
+D(11).scaling([1,2,3,4,6]) = [94 86 70 77 100];
+D(12).offset = D(11).offset;
+D(12).scaling = D(11).scaling;
+D(11).name = 'SOCS3oe';
+D(12).name = 'SOCS3oe';
+
+% SHP1oe
+D(13).offset([1 2 3  6 ]) = [53 45 33 59 ];
+D(13).scaling([1 2 3 5 6 18]) = [93 85 69 103 99 71];
+D(14).offset = D(13).offset;
+D(14).scaling = D(13).scaling;
+D(13).name = 'SHP1oe';
+D(14).name = 'SHP1oe';
+
+% DR 7 min -> group 1
+for cond = [15:19]
+D(cond).offset([1,2]) = [50 42];
+D(cond).scaling([1,2]) = [90 82];
+D(cond).name = 'dose response 7 min';
+end
+% DR 10 min -> group 2
+for cond = [26:31]
+D(cond).scaling([6]) = [97];
+D(cond).name = 'dose response 10 min';
+end
+% DR 30 min -> group 3
+for cond = [20:25]
+D(cond).offset([1,2]) = [49 41];
+D(cond).scaling([1,2]) = [89 81];
+D(cond).name = 'dose response 30 min';
+end
+% DR 90 min -> group 4
+for cond = 32:36
+D(cond).scaling([19,20]) = [61 62];
+D(cond).name = 'dose response 90 min';
+end
+
+for cond = 1:36
+    D(cond).offset = D(cond).offset-2;
+    D(cond).scaling = D(cond).scaling-2;
+    D(cond).std = D(cond).std-2;
+end
+for cond = [1:6,15:numel(D)]
+    D(cond).init = @(xi,u) [10.^xi(25);0;0;0;0;0;10.^xi(26);0;10.^xi(27);zeros(16,1)];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,25),10.^xi(26)*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(16,27)];
+end
+for cond=11:12
+    D(cond).init = @(xi,u) [10.^xi(25);0;0;0;0;0;10.^xi(26);0;10.^xi(27);zeros(15,1);u(3)*10.^(xi(15)+xi(16))];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,25),10.^xi(26)*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(15,27)
+        zeros(1,14), u(3)*10.^(xi(15)+xi(16))*log(10),u(3)*10.^(xi(15)+xi(16))*log(10),zeros(1,11)];
+end
+for cond=7:10
+    D(cond).init = @(xi,u)   [10.^xi(25);0;0;0;0;u(2);10.^xi(26);0;10.^xi(27);zeros(8,1);u(2) * 10.^(xi(2)+xi(1)); zeros(7,1)];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,25),10.^xi(26)*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(8,27);
+        u(2)*log(10)*10.^(xi(2)+xi(1)),u(2)*log(10)*10.^(xi(2)+xi(1)),zeros(1,25);
+        zeros(7,27)];
+end
+for cond = 13:14
+    D(cond).init = @(xi,u)  [10.^xi(25);0;0;0;0;0;10.^xi(26)*(1+(u(4)*10.^xi(14)));0;10.^xi(27);zeros(16,1)];
+    D(cond).sinit = @(xi,u) [zeros(1,24),10.^xi(25)*log(10),0,0;
+        zeros(5,27);
+        zeros(1,13),u(4)*10.^(xi(14)+xi(26))*log(10),zeros(1,11),10.^xi(26)*(1+(u(4)*10.^xi(14)))*log(10),0;
+        zeros(1,27);
+        zeros(1,26),10.^xi(27)*log(10);
+        zeros(16,27)];    
+end
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/getSimulation_Bachmann_JAKSTAT_offsetscaling.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/getSimulation_Bachmann_JAKSTAT_offsetscaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..832ab0703ac8e6c790611f10fa6179655dfc5230
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/getSimulation_Bachmann_JAKSTAT_offsetscaling.m
@@ -0,0 +1,62 @@
+function sol_ret = getSimulation_Bachmann_JAKSTAT_offsetscaling(xi,sol,D,options)
+
+% check dimension of parameters
+if size(xi,1) == 1
+    xi = xi';
+end
+
+for cond=1:numel(D)
+    if options.llh.original % (observable = scaling*simulation + offset)
+        offset = zeros(20,1);
+        offset(~isnan(D(cond).offset)) = 10.^xi(D(cond).offset(~isnan(D(cond).offset)));
+        scaling = ones(20,1);
+        scaling(~isnan(D(cond).scaling)) = 10.^xi(D(cond).scaling(~isnan(D(cond).scaling)));
+        c(1,:,1,cond) = scaling;
+        sol_ret(cond).y = bsxfun(@plus,offset,bsxfun(@times,scaling,sol(cond).y'))';
+        
+        if options.ami.sensi
+            sol(cond).sy(:,:,end+1:numel(xi)) = 0;
+            sol_ret(cond).sy = zeros(size(sol(cond).sy,1),size(sol(cond).sy,2),numel(xi));
+            
+            doffset = zeros(1,20,numel(xi));
+            doffset(1,(~isnan(D(cond).offset)),D(cond).offset(~isnan(D(cond).offset))) = ...
+                diag(10.^xi(D(cond).offset(~isnan(D(cond).offset)))*log(10));
+            
+            dscaling = zeros(1,20,numel(xi));
+            dscaling(1,(~isnan(D(cond).scaling)),D(cond).scaling(~isnan(D(cond).scaling))) = ...
+                diag(10.^xi(D(cond).scaling(~isnan(D(cond).scaling)))'*log(10));
+            
+            for iobs = 1:size(sol(cond).y,2)
+                sol_ret(cond).sy(:,iobs,:) = bsxfun(@plus,bsxfun(@plus,...
+                    bsxfun(@times,sol(cond).y(:,iobs),dscaling(1,iobs,:)), ...
+                    (sol(cond).sy(:,iobs,:))*scaling(iobs)),...
+                    doffset(1,iobs,:));
+            end
+        end
+    else % modified version (observable = scaling*(simulation + offset)
+        offset = zeros(20,1);
+            offset(~isnan(D(cond).offset)) = 10.^xi(D(cond).offset(~isnan(D(cond).offset)));
+            scaling = ones(20,1);
+            scaling(~isnan(D(cond).scaling)) = 10.^xi(D(cond).scaling(~isnan(D(cond).scaling)));
+            c(1,:,1,cond) = scaling;
+            sol_ret(cond).y = bsxfun(@times,scaling,bsxfun(@plus,offset,sol(cond).y'))';
+            if options.ami.sensi
+                sol(cond).sy(:,:,end+1:numel(xi)) = 0;
+                sol_ret(cond).sy = zeros(size(sol(cond).sy,1),size(sol(cond).sy,2),numel(xi));
+             
+                doffset = zeros(1,20,numel(xi));
+                doffset(1,(~isnan(D(cond).offset)),D(cond).offset(~isnan(D(cond).offset))) = ...
+                    diag(10.^xi(D(cond).offset(~isnan(D(cond).offset)))*log(10));
+                dscaling = zeros(1,20,numel(xi));
+                dscaling(1,(~isnan(D(cond).scaling)),D(cond).scaling(~isnan(D(cond).scaling))) = ...
+                    diag(10.^xi(D(cond).scaling(~isnan(D(cond).scaling)))'*log(10));
+                
+                for iobs = 1:size(sol(cond).y,2)
+                    sol_ret(cond).sy(:,iobs,:) = bsxfun(@plus,(sol_ret(cond).sy(:,iobs,:)) + ...
+                        bsxfun(@times,sol(cond).y(:,iobs),dscaling(1,iobs,:)) + (sol(cond).sy(:,iobs,:))*scaling(iobs),...
+                        scaling(iobs)*doffset(1,iobs,:) + ...
+                        dscaling(1,iobs,:)*offset(iobs));
+                end
+            end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/logLikelihood_Bachmann_rampart.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/logLikelihood_Bachmann_rampart.m
new file mode 100644
index 0000000000000000000000000000000000000000..69e5d36da534524581f0c3fb81f4150d51886d0b
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Bachmann_JakStat/logLikelihood_Bachmann_rampart.m
@@ -0,0 +1,124 @@
+function varargout = logLikelihood_Bachmann(xi,D,options)
+nderiv = nargout-1;
+if(nderiv>=1)
+    options.ami.sensi = 1;
+else
+    options.ami.sensi = 0;
+end
+% Simulation of conditions
+try
+    for cond = 1:numel(D)
+        options.ami.x0 = D(cond).init(xi,D(cond).u);
+        if options.ami.sensi
+            options.ami.sx0 = D(cond).sinit(xi,D(cond).u);
+        end
+        if cond == 13 || cond == 14
+            sol(cond) = simulate_BachmannJakStat_SHP1oe(D(cond).t,xi(1:27),D(cond).u,[],options.ami);
+        else
+            sol(cond) = simulate_BachmannJakStat(D(cond).t,xi(1:27),D(cond).u,[],options.ami);
+        end
+        temp_status(cond) = sol(cond).status;
+    end
+catch
+    varargout{1} = NaN;
+    if nderiv>=1
+        varargout{2} = nan(numel(xi),1);
+    end
+    warning('simulation failed')
+    return;
+end
+if any(temp_status<0)
+    varargout{1} = nan;
+    if nderiv>=1
+        varargout{2} = nan(numel(xi),1);
+    end
+    warning('simulation failed');
+    return;
+end
+
+nlogL = 0;
+dnlogL=zeros(numel(xi),1);
+sol = getSimulation_Bachmann_JAKSTAT_offsetscaling(xi,sol,D,options);
+for cond = 1:numel(D)
+    % Map variance parameters
+    sigma2 = zeros(1,20,size(D(cond).my,3));
+    if options.llh.original
+        for r = 1:size(D(cond).my,3)
+            sigma2(1,:,r) = (10.^(2*xi(D(cond).std)));
+        end
+        if cond == 11 || cond == 12
+            sigma2(1,6) = sigma2(1,6) + D(cond).u(3)*10.^(2*xi(113));
+        end
+    else
+        for r = 1:size(D(cond).my,3)
+            sigma2(1,:,r) = (10.^(xi(D(cond).std)));
+        end
+    end
+    if nargout > 1
+        if options.llh.original
+            dsigma2 = zeros(1,20,numel(xi),size(D(cond).my,3));
+            for iobs = 1:20
+                dsigma2(1,iobs,D(cond).std(iobs),:) = dsigma2(1,iobs,D(cond).std(iobs),:) + ...
+                    2*10.^(2*xi(D(cond).std(iobs)))*log(10);
+            end
+            if cond == 11 || cond == 12
+                dsigma2(1,6,113) = dsigma2(1,6,113) + D(cond).u(3)*2*10.^(2*xi(113))*log(10);
+            end
+        else
+            dsigma2 = zeros(1,20,numel(xi),size(D(cond).my,3));
+            for iobs = 1:20
+                dsigma2(1,iobs,D(cond).std(iobs),:) = dsigma2(1,iobs,D(cond).std(iobs),:) + ...
+                    10.^(xi(D(cond).std(iobs)))*log(10);
+            end
+        end
+    end
+    if cond == 2 && options.llh.original %pSTAT_rel not on log scale
+        y_ch = nan(size(D(cond).my));
+        y_ch(:,11,:) = bsxfun(@minus,(D(cond).my(:,11,:)),(sol(cond).y(:,11)));
+        y_ch(:,[1:10,12:end],:) = bsxfun(@minus,(D(cond).my(:,[1:10,12:end],:)),...
+            (sol(cond).y(:,[1:10,12:end])));
+    else
+        y_ch = bsxfun(@minus,log10(D(cond).my),log10(sol(cond).y));
+    end
+    
+    nlogL = nlogL + 0.5*(sum(sum(nansum(bsxfun(@times,~isnan(D(cond).my),...
+        log(2*pi*sigma2))+bsxfun(@rdivide,bsxfun(@power,y_ch,2),sigma2),1),3),2));
+    if nargout > 1
+        if cond == 2 && options.llh.original
+            iy = [1:10,12:20];
+            dnlogL = dnlogL + 0.5*(permute(sum(sum(nansum(...
+                bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                bsxfun(@power,y_ch(:,iy,:),2),sigma2(:,iy,:))),sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:)) -...
+                bsxfun(@times,1/log(10)*permute(2*bsxfun(@rdivide,y_ch(:,iy,:),sigma2(:,iy,:)),[1,2,4,3]),...
+                bsxfun(@rdivide,sol(cond).sy(:,iy,:),sol(cond).y(:,iy)))...
+                ,1),4),2),[3,2,1]));
+            iy = 11;
+            dnlogL = dnlogL + 0.5*(permute(sum(sum(nansum(...
+                bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                bsxfun(@power,y_ch(:,iy,:),2),sigma2(:,iy,:))),sigma2(:,iy,:)),[1,2,4,3]),dsigma2(:,iy,:,:)) -...
+                bsxfun(@times,permute(2*bsxfun(@rdivide,y_ch(:,iy,:),sigma2(:,iy,:)),[1,2,4,3]),sol(cond).sy(:,iy,:))...
+                ,1),4),2),[3,2,1]));
+        else
+            dnlogL = dnlogL + 0.5*(permute(sum(sum(nansum(...
+                bsxfun(@times,permute(bsxfun(@rdivide,(1-bsxfun(@rdivide,...
+                bsxfun(@power,y_ch,2),sigma2)),sigma2),[1,2,4,3]),dsigma2) -...
+                bsxfun(@times,1/log(10)*permute(2*bsxfun(@rdivide,y_ch,sigma2),[1,2,4,3]),...
+                bsxfun(@rdivide,sol(cond).sy,sol(cond).y))...
+                ,1),4),2),[3,2,1]));
+        end
+    end
+end
+
+% if isfield(options.llh,'parameter_prior')
+%     nlogL = nlogL + 0.5*nansum((xi-options.llh.parameter_prior.mean).^2....
+%         / options.llh.parameter_prior.sigma2);
+%     if nargout > 1
+%         dnlogL = nansum([dnlogL,(xi-options.llh.parameter_prior.mean)....
+%             / options.llh.parameter_prior.sigma2],2);
+%     end
+% end
+
+varargout{1} = -nlogL;
+if nderiv>=1
+    varargout{2} = -dnlogL;
+end
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Banana/bananaLLH.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Banana/bananaLLH.m
new file mode 100644
index 0000000000000000000000000000000000000000..4a315ba9542e5c5b92ff5073648b55f11f3204a4
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Banana/bananaLLH.m
@@ -0,0 +1,9 @@
+function llh = bananaLLH( theta )
+
+   t = linspace(0,1,101);
+   X = theta(1) * (1-exp(-theta(2) * t));
+   d = [0.00300970067893022 0.00665959226569197 -0.000955950427737410 0.0163200999871406 0.00630602720690914 -0.0113825158147590 -0.00541481902709891 0.00520038980150608 0.0213718069496413 0.0165729323023027 0.0232420295073312 0.0208637190206789 0.0229973805721590 0.0169323348150834 0.0312731233767299 0.0441180311626104 0.0337876512714904 0.0261245421794418 0.0585111832733452 0.0281102293169161 0.0313127387645332 0.0477757581727388 0.0575986721217150 0.0480583799340222 0.0535880547905150 0.0288771428106876 0.0380008942508774 0.0708768117409631 0.0580506480141715 0.0649177868005986 0.0465307008662812 0.0669660840334922 0.0656588849465678 0.0603452480842966 0.0636771852352871 0.0523249865852781 0.0831089656285460 0.0761292965515737 0.0818340975029384 0.0698866729662230 0.0741613659134849 0.0719491653234356 0.107546088924441 0.0754271026882274 0.109443863087684 0.0849665566507211 0.0913754504323348 0.0865790806861904 0.0780914333054673 0.0969360691902993 0.104142666379560 0.102941802122591 0.104188867997799 0.0869133853987718 0.0850951160753666 0.113564114081587 0.104088928285487 0.105699556714389 0.112702892687693 0.111967675037476 0.112046606310626 0.116397747568882 0.131443915571569 0.127129227885255 0.106850088027157 0.119892136303722 0.117884392018306 0.123676811165650 0.125052463703964 0.139496731291039 0.125390540811436 0.129042907598063 0.145089110257380 0.134118368870722 0.158567776816641 0.131559932635721 0.124511364184778 0.134851088606248 0.160817124740244 0.152132693272153 0.144366600131027 0.158374329532566 0.153739461371015 0.154566591192723 0.179113156957748 0.159129507645844 0.144707318655566 0.156626932077213 0.143620191199112 0.152862655107254 0.174700867169434 0.170788005335972 0.166094156833030 0.177886133214851 0.187948883502206 0.173988206183158 0.190421263016800 0.171501833631737 0.175079742251658 0.177538313202452 0.181050497495496];
+   theta(3) = -1.5229;
+   llh = -0.5*log(2*pi*(10^theta(3))^2) -0.5*sum((d-X).^2)/(2*10^theta(3)^2);
+   
+end
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Gauss/define_Gauss_LLH.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Gauss/define_Gauss_LLH.m
new file mode 100644
index 0000000000000000000000000000000000000000..25f8b990950857b2e881d95c3c00e71a991e3bfc
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Gauss/define_Gauss_LLH.m
@@ -0,0 +1,19 @@
+% Definition of the Gaussian mixture
+angle       = 2*pi/8;
+n           = 2;  % dimension of the sum of multivariate normal distributions
+dimi        = 18; % additional dimensions whose parameters are independently normally distributed
+scale       = blkdiag(1e0*[500,0;0,1]);
+
+% Setting of mean, rotation and covariance of the sum of multivariate
+% normal distributions
+mu = [-50,50;-50,50];
+rot1 = [cos(angle),-sin(angle);sin(angle),cos(angle)];
+rot1 = blkdiag(rot1,diag( ones(length(scale) - length(rot1), 1) ));
+cov1 = rot1'*scale*rot1;
+sig = repmat(cov1,1,1,n);
+
+% Definition of log-posterior function
+logP = @(theta) simulateGaussLLH(theta, mu, sig);
+
+% Call with logP([mu(:,1)',25*ones(1,dimi)]) for evaluation at one of the
+% optimal values.
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Gauss/simulateGaussLLH.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Gauss/simulateGaussLLH.m
new file mode 100644
index 0000000000000000000000000000000000000000..02f60ce267a875ad200fd03955c55a8dfa077b73
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Gauss/simulateGaussLLH.m
@@ -0,0 +1,42 @@
+% Simulation function for examples/GaussExample
+%
+% simulateGauss.m computes a log-likelihood which is constructed from a
+% Gaussian mixture model. The code is base on papers from Liang & Wong
+% (2001) and Lacki et al. (2015)
+%
+% Parameters:
+%  par: Model parameters
+%  mu: mean value of the model
+%  sigma: standard deviation of the model
+%
+% Return values:
+%  llh: double, value of log-likelihood
+
+
+
+function [ llh ] = simulateGaussLLH( par, mu, sigma )
+   
+   % Dimension of the model
+   n = size(mu,2);
+   p = size(mu,1);
+   if size(par,1) == 1
+      par = par';
+   end
+   
+   % Computing the log-likelihood in a robust fashion
+   logs = nan(1,n);
+   for j = 1:n
+      logs(j) = -0.5*p*log(2*pi) -0.5*det(sigma(1:p,1:p,j)) ...
+         -0.5*(par(1:p)-mu(1:p,j))'/sigma(1:p,1:p,j)*(par(1:p)-mu(1:p,j));
+   end
+   maxLogs = max(logs);
+   llh = maxLogs + log(sum(exp(logs-maxLogs)));
+   
+   % Additional dimensions whose parameters are independently normally
+   % distributed
+   m = length(par);
+   for i = p+1:m
+      llh = llh - log(1*sqrt(2*pi)) - 0.5 * ((par(i)-25)/1)^2; 
+   end
+   
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/JakStat/jakstat_pesto_syms.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/JakStat/jakstat_pesto_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..c490bdc92d6dcb20c81ec11c8f947f1c0d3bf173
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/JakStat/jakstat_pesto_syms.m
@@ -0,0 +1,64 @@
+function [model] = jakstat_pesto_syms()
+% jakstat_pesto_syms for examples/jakstat_signaling
+%
+% creates an amimodel-object for the AMICI solver
+%
+% Parameters: 
+% 
+% Return values:
+%  model: amimodel object
+
+
+
+%% States
+syms STAT pSTAT pSTAT_pSTAT npSTAT_npSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+
+model.sym.x = [
+    STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+    ];
+
+%% Parameters
+syms p1 p2 p3 p4 init_STAT Omega_cyt Omega_nuc sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT sigma_pSTAT sigma_tSTAT sigma_pEpoR
+
+model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+model.param = 'log10';
+model.sym.k = [Omega_cyt,Omega_nuc];
+
+%% Inputs
+syms t
+
+u(1) = am_spline_pos(t, 5, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+
+%% Right hand side of the ODE
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+
+%% Initial concentrations
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = init_STAT;
+
+%% Observables
+model.sym.y = sym(zeros(3,1));
+
+model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+model.sym.y(3) = u(1);
+
+%% Variances
+model.sym.sigma_y = sym(size(model.sym.y));
+
+model.sym.sigma_y(1) = sigma_pSTAT;
+model.sym.sigma_y(2) = sigma_tSTAT;
+model.sym.sigma_y(3) = sigma_pEpoR;
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/JakStat/logLikelihoodJakstat_rampart.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/JakStat/logLikelihoodJakstat_rampart.m
new file mode 100644
index 0000000000000000000000000000000000000000..a43bb3d4326cf7af64ecf2babb35c2f5ad8b73b5
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/JakStat/logLikelihoodJakstat_rampart.m
@@ -0,0 +1,62 @@
+function varargout = logLikelihoodJakstat(theta, amiData)
+% Objective function for examples/jakstat_signaling
+%
+% logLikelihoodJakstat.m provides the log-likelihood, its gradient and an
+% the Hessian matrix for the model for the JakStat signaling pathway as
+% defined in jakstat_pesto_syms.m
+%
+% USAGE:
+% [llh] = getParameterProfiles(theta, amiData)
+% [llh, sllh] = getParameterProfiles(theta, amiData)
+% [llh, sllh, s2llh] = getParameterProfiles(theta, amiData)
+%
+% Parameters:
+%  theta: Model parameters
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no
+%         sensitivity analysis is performed
+%     sllh: Gradient of llh, The LogLikelihood and its gradient will be
+%         returned, first order adjoint sensitivity analysis is performed
+%     s2llh: Hessian of llh, The LogLikelihood, its gradient and the
+%         Hessian matrix will be returned, second order adjoint sensitivity
+%         analysis is performed
+
+
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see jakstat_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% papers on the JakStat signaling pathway by Swameye et al. and Schelker et
+% al.
+
+%% AMICI
+% Setting the options for the AMICI solver
+
+amiOptions.rtol = 1e-12;
+amiOptions.atol = 1e-12;
+amiOptions.sensi_meth = 'adjoint';
+
+%% Objective Function Evaluation
+% Assignment
+if (nargout == 1)
+    amiOptions.sensi = 0;
+    sol = simulate_jakstat_pesto([], theta, amiData.condition, amiData, amiOptions);
+    varargout{1} = sol.llh;
+elseif (nargout == 2)
+    amiOptions.sensi = 1;
+    sol = simulate_jakstat_pesto([], theta, amiData.condition, amiData, amiOptions);
+    varargout{1} = sol.llh;
+    varargout{2} = sol.sllh;
+elseif (nargout == 3)
+    amiOptions.sensi = 2;
+    sol = simulate_jakstat_pesto([], theta, amiData.condition, amiData, amiOptions);
+    varargout{1} = sol.llh;
+    varargout{2} = sol.sllh;
+    varargout{3} = sol.s2llh;
+end
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/D0.mat b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/D0.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9e8b3a7a5c143eb9147a098a65f17016b05a6b10
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/D0.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/logLikelihoodRafMekErk_rampart.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/logLikelihoodRafMekErk_rampart.m
new file mode 100644
index 0000000000000000000000000000000000000000..3c9f242a4966d60fc82da72dd27748c5b8261439
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/logLikelihoodRafMekErk_rampart.m
@@ -0,0 +1,123 @@
+ function [varargout] = logLikelihoodRafMekErk(theta, amiData, amiOptions)
+% Objective function for examples/rafMekErk_signaling
+%
+% logLikelihoodRafMekErk.m provides the log-likelihood, its gradient and an 
+% the Hessian matrix for the model for the JakStat signaling pathway as
+% defined in rafMekErk_pesto_syms.m
+% 
+% USAGE:
+% [llh] = logLikelihoodRafMekErk(theta)
+% [llh, sllh] = logLikelihoodRafMekErk(theta)
+% [llh, sllh, s2llh] = logLikelihoodRafMekErk(theta)
+%
+% Parameters:
+%  theta: Model parameters 
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no 
+%         sensitivity analysis is performed
+%     sllh: Gradient of llh, The LogLikelihood and its gradient will be 
+%         returned, first order adjoint sensitivity analysis is performed
+%     s2llh: Hessian of llh, The LogLikelihood, its gradient and the 
+%         Hessian matrix will be returned, second order adjoint sensitivity 
+%         analysis is performed
+
+
+
+    %% Model Definition
+    % The ODE model is set up using the AMICI toolbox. To access the AMICI
+    % model setup, see jakstat_pesto_syms.m
+    % For a detailed description for the biological model see the referenced
+    % papers on the JakStat signaling pathway by Swameye et al. and Schelker et
+    % al.
+
+
+    
+    %% Objective Function Evaluation
+    
+    % Initialization
+    llh = 0;
+    sllh = zeros(28, 1);
+    s2llh = zeros(28, 28);
+    
+    % Integration
+    if (nargout == 1)
+        amiOptions.sensi = 0;
+        for j = 1 : 3
+            sol = simulate_rafMekErk_pesto(amiData(j).t, theta, amiData(j).condition, amiData(j), amiOptions);
+            if sol.status < 0
+                llh = -inf;
+            end
+            llh = llh + sol.llh;
+        end
+        
+    elseif (nargout == 2)
+        amiOptions.sensi = 1;
+        for j = 1 : 3
+            sol = simulate_rafMekErk_pesto(amiData(j).t, theta, amiData(j).condition, amiData(j), amiOptions);
+            if sol.status < 0
+                llh = -inf;
+            end
+            llh = llh + sol.llh;
+            sllh = sllh + sol.sllh;
+        end
+        
+    elseif (nargout == 3)
+        amiOptions.sensi = 2;
+        for j = 1 : 3
+            sol = simulate_rafMekErk_pesto(amiData(j).t, theta, amiData(j).condition, amiData(j), amiOptions);
+            if sol.status < 0
+                llh = -inf;
+            end
+            
+            % Hessian matrix
+            hessian = zeros(28);       % preallocation
+            nT = length(amiData(j).t);       % timepoints
+            res = amiData(j).Y - sol.y;
+            res(isnan(res)) = 0;
+            for iT = 1 : nT
+                if (~isnan(amiData(j).Y(iT,1)))
+                    resi = res(iT,1);
+                    sigma = sol.sigmay(iT,1);
+                    sy(:) = sol.sy(iT,1,:);
+                    s2y(:,:) = sol.s2y(iT,1,:,:);
+                    ssigmay(:) = sol.ssigmay(iT,1,:);
+                    s2sigmay(:,:) = sol.s2sigmay(iT,1,:,:);
+
+                    contrib_o2 = resi/sigma^2 * s2y ...
+                        + (resi^2/sigma^3 - 1/sigma) * s2sigmay;
+                    cross = 2*resi/sigma^3 * (sy'*ssigmay + ssigmay'*sy);
+                    sigma_cross = 3*resi^2/sigma^4 * (ssigmay'*ssigmay);
+
+                    hessian = hessian ...
+                        - (sy'*sy - ssigmay'*ssigmay) / sigma^2 ...     FIM contribution
+                        - cross ...                                     cross terms
+                        - sigma_cross ...                               sigma terms 1st order
+                        + contrib_o2;                                 % 2nd order derivatives
+                end
+            end
+            llh = llh + sol.llh;
+            sllh = sllh + sol.sllh;
+            s2llh = s2llh + hessian;
+        end
+
+    end
+    
+    % Assignment
+    switch (nargout)
+        case{0,1}
+            varargout{1} = llh;
+            
+        case 2
+            varargout{1} = llh;
+            varargout{2} = sllh;
+            
+        case 3
+            varargout{1} = llh;
+            varargout{2} = sllh;
+            varargout{3} = s2llh;
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/rafMekErk_pesto_syms.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/rafMekErk_pesto_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..17211ac553b1c4ca059af2cf62201cd34f50e2f6
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/RafMekErk/rafMekErk_pesto_syms.m
@@ -0,0 +1,80 @@
+function [model] = rafMekErk_pesto_syms()
+
+%% CVODES options
+
+% paramterisation
+model.param = 'log10';
+
+%% States
+
+syms pRaf pMek pErk
+x = [pRaf pMek pErk]; 
+
+%% Time
+
+syms t
+
+%% Parameters
+
+syms kdf_Raf kp_Raf kdp_pMek kp_pRaf_Mek kdp_pErk kp_pMek_Erk K_pErk_inh ...
+         sust_Ras_0 ts_sust_Ras ts_trans_Ras K_Sora K_UO ... 
+         scale_pMek_20140430_gel1 scale_pErk_20140430_gel1 scale_pMek_20140430_gel2 ...
+         scale_pErk_20140430_gel2 scale_pMek_20140505_gel1 scale_pErk_20140505_gel1...
+         scale_pMek_20140505_gel2 scale_pErk_20140505_gel2 ...
+         sigma_pMek_20140430_gel1 sigma_pErk_20140430_gel1 sigma_pMek_20140430_gel2 ...
+         sigma_pErk_20140430_gel2 sigma_pMek_20140505_gel1 sigma_pErk_20140505_gel1 ...
+         sigma_pMek_20140505_gel2 sigma_pErk_20140505_gel2
+p = [kdf_Raf kp_Raf kdp_pMek kp_pRaf_Mek kdp_pErk kp_pMek_Erk K_pErk_inh ...
+         sust_Ras_0 ts_sust_Ras ts_trans_Ras K_Sora K_UO ...
+         scale_pMek_20140430_gel1 scale_pErk_20140430_gel1 scale_pMek_20140430_gel2 ...
+         scale_pErk_20140430_gel2 scale_pMek_20140505_gel1 scale_pErk_20140505_gel1 ...
+         scale_pMek_20140505_gel2 scale_pErk_20140505_gel2 ...
+         sigma_pMek_20140430_gel1 sigma_pErk_20140430_gel1 sigma_pMek_20140430_gel2 ...
+         sigma_pErk_20140430_gel2 sigma_pMek_20140505_gel1 sigma_pErk_20140505_gel1 ...
+         sigma_pMek_20140505_gel2 sigma_pErk_20140505_gel2]; 
+
+%% Constants
+
+syms Sora UO
+k = [Sora UO];
+
+%% Time evolution
+
+xdot = sym(zeros(size(x)));
+
+RasGTP = sust_Ras_0+(1-exp(-t/ts_sust_Ras))*exp(-t/ts_trans_Ras);
+
+xdot(1) = kp_Raf*(1-pRaf)*(RasGTP)/(1+pErk/K_pErk_inh)-kdf_Raf*pRaf;
+xdot(2) = kp_pRaf_Mek*pRaf/(1+Sora/K_Sora)*(1-pMek)-kdp_pMek*pMek;
+xdot(3) = kp_pMek_Erk*pMek/(1+UO/K_UO)*(1-pErk)-kdp_pErk*pErk;
+
+%% Initial conditions
+
+x0(1) = ((K_pErk_inh*(sust_Ras_0) + (K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + (K_pErk_inh*kdp_pErk*(sust_Ras_0))/kp_pMek_Erk - (K_pErk_inh*kdp_pMek*kdp_pErk*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk)))/(2*(kdf_Raf/kp_Raf  + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdf_Raf)/kp_Raf + (K_pErk_inh*kdf_Raf*kdp_pErk)/(kp_Raf*kp_pMek_Erk) + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk));
+x0(2) = (((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk - (K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk)/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) - (K_pErk_inh*kdp_pMek*kdp_pErk*sust_Ras_0)/(kp_pRaf_Mek*kp_pMek_Erk)))/((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*(sust_Ras_0))/kp_pMek_Erk + (kdf_Raf*kdp_pMek*(2*K_pErk_inh + (K_pErk_inh*kdp_pErk)/kp_pMek_Erk + 2))/(kp_Raf*kp_pRaf_Mek) + (K_pErk_inh*kdp_pMek*(sust_Ras_0)*(kdp_pErk/kp_pMek_Erk + 2))/kp_pRaf_Mek);
+x0(3) = (((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk - (K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk)/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) - (K_pErk_inh*kdp_pMek*kdp_pErk*sust_Ras_0)/(kp_pRaf_Mek*kp_pMek_Erk)))/((kdp_pErk/kp_pMek_Erk + 1)*(K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0*(kdp_pErk/kp_pMek_Erk + 1)^2 + (kdf_Raf*kdp_pMek*kdp_pErk*(K_pErk_inh + (K_pErk_inh*kdp_pErk)/kp_pMek_Erk + 2))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) + (K_pErk_inh*kdp_pMek*kdp_pErk*(sust_Ras_0)*(kdp_pErk/kp_pMek_Erk + 1))/(kp_pRaf_Mek*kp_pMek_Erk));
+
+%% Observables
+
+y = [scale_pMek_20140430_gel1*x(2);scale_pErk_20140430_gel1*x(3); ...
+    scale_pMek_20140430_gel2*x(2);scale_pErk_20140430_gel2*x(3); ...
+     scale_pMek_20140505_gel1*x(2);scale_pErk_20140505_gel1*x(3); ...
+     scale_pMek_20140505_gel2*x(2);scale_pErk_20140505_gel2*x(3)];
+
+%% Noise
+
+sigma = [sigma_pMek_20140430_gel1 sigma_pErk_20140430_gel1 sigma_pMek_20140430_gel2 ...
+         sigma_pErk_20140430_gel2 sigma_pMek_20140505_gel1 sigma_pErk_20140505_gel1 ...
+         sigma_pMek_20140505_gel2 sigma_pErk_20140505_gel2];
+
+%% Output
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+model.sym.sigma_y = sigma;
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Ring/mainExampleRing.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Ring/mainExampleRing.m
new file mode 100644
index 0000000000000000000000000000000000000000..8011c4ec4d9380463b86ced55974ac19ad968a6a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Ring/mainExampleRing.m
@@ -0,0 +1,150 @@
+%% Preliminary
+clear all
+close all
+clc
+
+%% Problem initialization
+
+% Settings for this example
+radius = 50;
+sigma = 5;
+dimi = 18; % extraDimensions
+logP = @(theta) simulateRingLLH(theta, radius, sigma, dimi);
+ringDimension = 2;
+
+% Set required sampling options for Parallel Tempering
+par.number = ringDimension + dimi;
+par.min    = [-200;-200;-20*ones(dimi,1)];
+par.max    = [200;200;20*ones(dimi,1)];
+par.name   = {};
+for i = 1 : dimi + 2
+   par.name{end+1} = ['\theta_' num2str(i)];
+end
+
+% Sampling Options
+rng('shuffle')
+options                     = PestoSamplingOptions();
+options.objOutNumber        = 1;
+options.nIterations         = 1e4;
+options.mode                = 'text';
+
+% % Using PT
+% options.samplingAlgorithm   = 'PT';
+% options.PT.nTemps           = 40;
+% options.PT.exponentT        = 1000;   
+% options.PT.maxT             = 2000;
+% options.PT.alpha            = 0.51;
+% options.PT.temperatureNu    = 1e4;
+% options.PT.memoryLength     = 1;
+% options.PT.regFactor        = 1e-8;
+% options.PT.temperatureEta   = 10;
+% options.PT.temperatureAdaptionScheme = 'Vousden16'; 
+% 
+% randoms                     = randn(2,options.PT.nTemps);
+% squareSum                   = sqrt(sum(randoms.^2));
+% randomPointsOnRing          = randoms ./ squareSum;
+% % plot(randomPointsOnRing(1,:),randomPointsOnRing(2,:),'.')
+% options.theta0              = [radius*randomPointsOnRing;zeros(dimi,options.PT.nTemps)];
+% options.sigma0              = 1e6*diag(ones(1,dimi+2));
+
+% Using RBPT
+options.samplingAlgorithm     = 'RBPT';
+options.RBPT.nTemps           = 30;
+options.RBPT.exponentT        = 1000;   
+options.RBPT.maxT             = 2000;
+options.RBPT.alpha            = 0.51;
+options.RBPT.temperatureNu    = 1e3;
+options.RBPT.memoryLength     = 1;
+options.RBPT.regFactor        = 1e-8;
+options.RBPT.temperatureEta   = 10;
+
+options.RBPT.trainPhaseFrac   = 0.1;
+
+options.RBPT.RPOpt.rng                  = 'shuffle';
+options.RBPT.RPOpt.nSample              = floor(options.nIterations*options.RBPT.trainPhaseFrac)-1;
+options.RBPT.RPOpt.crossValFraction     = 0.2;
+options.RBPT.RPOpt.modeNumberCandidates = [1,2:2:20];
+options.RBPT.RPOpt.displayMode          = 'visual';
+options.RBPT.RPOpt.maxEMiterations      = 100;
+options.RBPT.RPOpt.nDim                 = par.number;
+options.RBPT.RPOpt.nSubsetSize          = 1000;
+options.RBPT.RPOpt.lowerBound           = par.min;
+options.RBPT.RPOpt.upperBound           = par.max;
+options.RBPT.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+options.RBPT.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+options.RBPT.RPOpt.dimensionsToPlot     = [1,2];
+options.RBPT.RPOpt.isInformative        = [1,1,zeros(1,options.RBPT.RPOpt.nDim-2)];
+
+randoms                     = randn(2,options.RBPT.nTemps);
+squareSum                   = sqrt(sum(randoms.^2));
+randomPointsOnRing          = randoms ./ squareSum;
+% plot(randomPointsOnRing(1,:),randomPointsOnRing(2,:),'.')
+options.theta0              = [radius*randomPointsOnRing;zeros(dimi,options.RBPT.nTemps)];
+options.sigma0              = 1e6*diag(ones(1,dimi+2));
+
+% Perform the parameter estimation via sampling
+par = getParameterSamples(par, logP, options);
+
+%%
+% Additional visualization
+figure('Name', 'Chain analysis and theoretical vs true sampling distribution');
+
+% Visualize the mixing properties and the exploration of the chain
+subplot(2,1,1);
+plot(squeeze(par.S.par(:,:,1))');
+
+% ...and their theoretical distribution
+subplot(2,1,2); 
+% plot_Gauss_LH();
+hold on;
+plot(squeeze(par.S.par(1,:,1))',squeeze(par.S.par(2,:,1))','.'); 
+for k = unique(par.S.newLabel)'
+   plot_gaussian_ellipsoid([par.S.par(1,end,1),par.S.par(2,end,1)], ...
+      par.S.sigmaScale(end,1,k)*par.S.sigmaHist(1:2,1:2,1,k))
+end
+hold off;
+
+
+% All tempered chains
+figure
+for j = 1:length(squeeze(par.S.par(1,1,:)))
+   subplot(ceil(sqrt(length(squeeze(par.S.par(1,1,:))))),ceil(sqrt(length(squeeze(par.S.par(1,1,:))))),j)
+   plot(par.S.par(1:2,:,j)');
+   title(num2str(par.S.temperatures(end,j)))
+end
+
+% Swap Ratios
+figure
+title('Swapping Ratios')
+bar(par.S.accSwap./par.S.propSwap)
+
+% Temepratures
+figure
+title('Temperatures')
+plot(log10(par.S.temperatures))
+
+% Regions
+figure
+for j = 1:length(squeeze(par.S.par(1,1,:)))
+   subplot(ceil(sqrt(length(squeeze(par.S.par(1,1,:))))),ceil(sqrt(length(squeeze(par.S.par(1,1,:))))),j)
+   histogram(par.S.newLabel(1:end,j))
+end
+
+% modeSelection
+figure;
+plot(par.S.regions.lh);hold all; plot(max(par.S.regions.lh'),'linewidth',2,'color',[0,0,0]);xlabel('nModes');ylabel('LLH of randomly selected test set')
+
+
+%% ACT
+addpath('C:\Users\GEYAW\Home\Matlab_Home\2016_12_20_GIT_PESTO_Paper_Code\AnalysisPipelineTools')
+acf = iact(squeeze(par.S.par(:,:,1))')
+max(acf)
+
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Ring/simulateRingLLH.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Ring/simulateRingLLH.m
new file mode 100644
index 0000000000000000000000000000000000000000..1c648f19de97eee027fc7dc794d4fbc8172fe812
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/Ring/simulateRingLLH.m
@@ -0,0 +1,24 @@
+function [ llh ] = simulateRingLLH( par, radius, sigma, extra )
+% Simulation function for examples/RingExample
+%
+% simulateRingLLH.m provides the log-likelihood for the hyper ring example.
+% 
+% Parameters:
+%  par: Model parameters
+%  radius:radius of the ring
+%  sigma: thickness of the ring
+%  extra: number of non-ring distributed extra dimensions. (These are idependently 
+%         normal distributed)
+%
+% Return values:
+%  llh: double, value of log-likelihood / log-posterior
+   
+   normalPar = par(end-extra+1:end);
+   ringPar   = par(1:end-extra);
+
+   squares = ringPar.^2;
+   llh = - 0.5 * ( (sqrt(sum(squares)) - radius)^2 / sigma^2 );
+   
+   llh = llh - 0.5 * log(2*pi)*extra - 0.5 * sum(normalPar.^2);
+   
+end
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/logLikelihoodT_rampart.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/logLikelihoodT_rampart.m
new file mode 100644
index 0000000000000000000000000000000000000000..f7e12d3663df78d9853b2fad8b6ecd71a000e490
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/logLikelihoodT_rampart.m
@@ -0,0 +1,53 @@
+function [logL] = logLikelihoodT(varargin)
+% Objective function for examples/mRNA_transfection
+%
+% logLikelihoodT.m provides the log-likelihood
+% 
+% Parameters:
+%   varargin:
+%     theta: Model parameters
+%     t: vector of time points
+%     D: measurement data
+%
+% Return values:
+%   logL: double, value of log-likelihood
+
+
+%% Initialization
+% Initialization of observable sensitivities
+
+theta = varargin{1}; 
+theta = theta(:);
+t     = varargin{2};
+D     = varargin{3};
+
+% Parameter assignment
+t0     = 10.^theta(1);
+kTL_m0 = 10.^theta(2);
+beta   = 10.^theta(3);
+delta  = 10.^theta(4);
+sigma  = 10.^theta(5);
+
+%% Evaluation of likelihood function
+% Simulation
+
+% State
+X = zeros(length(t),2);
+if abs(delta-beta) > 1e-8
+   X(t>t0,:) = [exp(-delta*(t(t>t0)-t0)),...
+        kTL_m0 * (exp(-beta*(t(t>t0)-t0)) - exp(-delta*(t(t>t0)-t0))) / (delta-beta)];
+else
+   % L'Hospital arround beta = delta
+   X(t>t0,:) = [exp(-delta*(t(t>t0)-t0)),...
+        kTL_m0 * (t(t>t0)-t0).*exp(-delta*(t(t>t0)-t0))];
+end
+       
+% Chain rule and Observables
+Y = X(:,2);
+
+%% Objective Function Evaluation
+% Log-likelihood
+logL = - 1/2 * sum(log(2*pi*sigma^2) + ((D-Y) ./ sigma).^2);
+
+end
+                  
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/mRNA_data_exp.mat b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/mRNA_data_exp.mat
new file mode 100644
index 0000000000000000000000000000000000000000..f632cdc7637ccc9fdca3d048a690bf671d5f16f8
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/mRNA_data_exp.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/setData_mRNA.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/setData_mRNA.m
new file mode 100644
index 0000000000000000000000000000000000000000..ea908364b10f15d46119be9f858be4f377e76eb3
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/mRNA_Transfection/setData_mRNA.m
@@ -0,0 +1,53 @@
+
+t = (0:0.2:10)';
+ym = [   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   1.8309
+   3.3559
+   4.6091
+   5.4235
+   5.9757
+   6.6298
+   7.0080
+   7.8280
+   7.5852
+   7.9247
+   7.8363
+   8.0107
+   7.7077
+   7.5316
+   7.4208
+   7.5734
+   7.3197
+   7.1489
+   7.1987
+   6.8493
+   6.6425
+   6.6268
+   6.1223
+   6.1078
+   5.9242
+   5.6034
+   5.4618
+   5.1281
+   4.9489
+   4.8930
+   4.7747
+   4.7750
+   4.3095
+   4.2211
+   4.0416
+   3.7485
+   3.7164
+   3.4799
+   3.5286
+   3.2785];
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/main.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/main.m
new file mode 100644
index 0000000000000000000000000000000000000000..ec0c461f2dbdc7b83a9003cbea55a3455f73eeec
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/main.m
@@ -0,0 +1,73 @@
+% This file shows how to execute several PESTO examples using the
+% RAmPART-sampler. The options are set in selectRun.m and the results are
+% getting stored in [pwd filesep 'results'].
+
+% Add pathes of PESTO and the examples
+addpath(['..' filesep '..']);
+addpath([pwd filesep 'Banana']);
+addpath([pwd filesep 'Ring']);
+addpath([pwd filesep 'Gauss']);
+addpath([pwd filesep 'Bachmann_JakStat']);
+addpath([pwd filesep 'JakStat']);
+addpath([pwd filesep 'RafMekErk']);
+addpath([pwd filesep 'mRNA_Transfection']);
+
+% Add you AMICI path here (necessary for some of the examples)
+if exist('amiwrap.m')~=2
+    error('Please add the AMICI toolbox to your path environment.')
+end
+
+% Add results folder for SAVE files
+if exist([pwd filesep 'results'],'dir')~=7
+    mkdir([pwd filesep 'results'])
+end
+
+%% Run RAmPART in RING example
+% The results are getting stored in '/results'. For detailed options, see
+% selectRun.m
+selectRun(101,[pwd filesep 'results']);
+
+%% Run RAmPART in the RING example with another random seed
+selectRun(102,[pwd filesep 'results']);
+
+%% Run RAmPART in the GAUSS example
+selectRun(301,[pwd filesep 'results']);
+
+%% Run Parallel Tempering in the GAUSS example
+selectRun(201,[pwd filesep 'results']);
+
+%% Run RAmPART in the JakStat example 
+% (has to be compiled via AMICI)
+amiwrap('jakstat_pesto','jakstat_pesto_syms',[],false);
+selectRun(701,[pwd filesep 'results']);
+
+%% Run RAmPART in mRNA-transfection example with experimental data 
+% (has to be compiled via AMICI)
+selectRun(1301,[pwd filesep 'results']);
+
+%% Run RB-AM in mRNA-transfection example with experimental data
+selectRun(1701,[pwd filesep 'results']);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/examples/RAmPART_examples/selectRun.m b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/selectRun.m
new file mode 100644
index 0000000000000000000000000000000000000000..583bbd49f22b5f89fe4fa9f90149aa9125c4c989
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/RAmPART_examples/selectRun.m
@@ -0,0 +1,1155 @@
+% This files purpose is to select a certain set of sampling options.MCMC from a
+% large pool of predefined examples. The input parameter b defines which of
+% the 2100 predefined option sets will be selected. A summary of the
+% selected sampling problems and algorithm:
+%
+%   1-100: Ring   + PT
+% 101-200: Ring   + RAMPART
+% 201-300: Gauss  + PT
+% 301-400: Gauss  + RAMPART
+% 401-500: Banana + PT
+% 501-600: Banana + RAMPART
+% 601-700: JakStat+ PT
+% 701-800: JakStat+ RAMPART
+% 801-900: mRNA   + PT
+% 901-1000: mRNA  + RAMPART
+% 1001-1100: RafMekErk + PT
+% 1101-1200: RafMekErk + RAMPART
+% 1201-1300: mRNA (exp) + PT
+% 1301-1400: mRNA (exp) + RAMPART
+% 1401-1500: Ring + RegionOnly
+% 1501-1600: Gauss + RegionOnly
+% 1601-1700: JakStat + RegionOnly
+% 1701-1800: mRNA (exp) + RegionOnly
+% 1801-1900: Bachmann + PT
+% 1901-2000: Bachmann + RAMPART
+% 2001-2100: Bachmann + RegionOnly
+% 
+% If two options.MCMC sets do possess the same sampling problem and algorithm,
+% they differ in their random seed. The results will be stored will running
+% in SAVE file. After the run terminated, a res_b.mat file will be created
+% and stores the final results.
+%
+% Written by benjamin ballnus (2017)
+
+function selectRun( b, targetDir )
+
+   if isstr(b)
+      b = eval(b);
+   end
+   disp(['--- Starting run ' num2str(b) ' ---'])
+   
+   rng(b);
+   
+   % General Sampling options.MCMC
+   options                          = PestoOptions();
+   options.MCMC                     = PestoSamplingOptions();
+   options.MCMC.objOutNumber        = 1;
+   options.MCMC.nIterations         = 1e5;
+   options.MCMC.mode                = 'text';
+   options.MCMC.debug               = false;
+   
+
+   
+   if b <= 100       % Ring + PT
+      
+      % Settings for this example
+      radius = 50;
+      sigma = 0.5;
+      dimi = 18; % extraDimensions
+      logP = @(theta) simulateRingLLH(theta, radius, sigma, dimi);
+      ringDimension = 2;
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.number = ringDimension + dimi;
+      par.min    = [-200;-200;-20*ones(dimi,1)];
+      par.max    = [200;200;20*ones(dimi,1)];
+      par.name   = {};
+      for i = 1 : dimi + 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 40;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 2000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e4;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      randoms                     = randn(2,options.MCMC.PT.nTemps);
+      squareSum                   = sqrt(sum(randoms.^2));
+      randomPointsOnRing          = [randoms(1,:) ./ squareSum; randoms(2,:) ./ squareSum];
+      options.MCMC.theta0              = [radius*randomPointsOnRing;zeros(dimi,options.MCMC.PT.nTemps)];
+      options.MCMC.sigma0              = 1e6*diag(ones(1,dimi+2));
+      
+   elseif b <= 200   % Ring + RAMPART
+      
+      % Settings for this example
+      radius = 50;
+      sigma = 0.5;
+      dimi = 18; % extraDimensions
+      logP = @(theta) simulateRingLLH(theta, radius, sigma, dimi);
+      ringDimension = 2;
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.number = ringDimension + dimi;
+      par.min    = [-200;-200;-20*ones(dimi,1)];
+      par.max    = [200;200;20*ones(dimi,1)];
+      par.name   = {};
+      for i = 1 : dimi + 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 40;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:20;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [1,1,ones(1,options.MCMC.RAMPART.RPOpt.nDim-2)];
+      
+      randoms                     = randn(2,options.MCMC.RAMPART.nTemps);
+      squareSum                   = sqrt(sum(randoms.^2));
+      randomPointsOnRing          = [randoms(1,:) ./ squareSum; randoms(2,:) ./ squareSum];
+      options.MCMC.theta0              = [radius*randomPointsOnRing;zeros(dimi,options.MCMC.RAMPART.nTemps)];
+      options.MCMC.sigma0              = 1e6*diag(ones(1,dimi+2));
+      
+   elseif b <= 300   % Gauss + PT
+      
+      define_Gauss_LLH();
+      gaussDimension = 2 + dimi;
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.number = gaussDimension;
+      par.min    = [-100;-100;-100*ones(dimi,1)];
+      par.max    = [100;100;100*ones(dimi,1)];
+      par.name   = {};
+      for i = 1 : dimi + 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 40;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 2000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e4;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      options.MCMC.theta0              = repmat([mu(1,:),repmat(25,1,dimi)]',1,options.MCMC.PT.nTemps);
+      options.MCMC.theta0(:,1:2:end)   = repmat([mu(2,:),repmat(25,1,dimi)]',1,ceil(options.MCMC.PT.nTemps/2));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,dimi+2));
+      
+   elseif b <= 400   % Gauss + RAMPART
+      
+      define_Gauss_LLH();
+      gaussDimension = 2 + dimi;
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.number = gaussDimension;
+      par.min    = [-100;-100;-100*ones(dimi,1)];
+      par.max    = [100;100;100*ones(dimi,1)];
+      par.name   = {};
+      for i = 1 : dimi + 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 40;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:10;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [1,1,ones(1,options.MCMC.RAMPART.RPOpt.nDim-2)];
+      
+      options.MCMC.theta0              = repmat([mu(1,:),repmat(25,1,dimi)]',1,options.MCMC.RAMPART.nTemps);
+      options.MCMC.theta0(:,1:2:end)   = repmat([mu(2,:),repmat(25,1,dimi)]',1,ceil(options.MCMC.RAMPART.nTemps/2));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,dimi+2));
+      
+   elseif b <= 500   % Banana + PT
+      
+      % Settings for this example
+      logP = @(theta) bananaLLH(theta);
+      par.number = 2;
+      par.min    = [0;0];
+      par.max    = [5;5];
+      par.name   = {};
+      for i = 1 : 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 20;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 2000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e3;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      options.MCMC.theta0              = [1;0.2];
+      options.MCMC.sigma0              = 1e6*diag(ones(1,2));
+      
+   elseif b <= 600   % Banana + RAMPART
+      
+      % Settings for this example
+      logP = @(theta) bananaLLH(theta);
+      par.number = 2;
+      par.min    = [0;0];
+      par.max    = [5;5];
+      par.name   = {};
+      for i = 1 : 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 20;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = [1:15];
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [1,1];
+      
+      options.MCMC.theta0              = [1;0.2];
+      options.MCMC.sigma0              = 1e6*diag(ones(1,2));
+      
+   elseif b <= 700         % JakStat PT
+      
+      warning off;
+      
+      % Experimental data is read out from an .xls-file and written to an AMICI
+      % object which is used for the ODE integration
+      datatable         = xlsread('pnas_data_original.xls');
+      amiData.t         = datatable(:,1);       % time points
+      amiData.Y         = datatable(:,[2,4,6]); % measurement
+      amiData.condition = [1.4,0.45];           % initial conditions 
+      amiData.Sigma_Y   = NaN(size(amiData.Y)); % preallocation of variances
+      amiData           = amidata(amiData);     % calling the AMICI routine
+      
+      % objective function
+      logP = @(theta) logLikelihoodJakstat_rampart(theta, amiData);
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.min     = -5 * ones(17,1);
+      par.max     =  3 * ones(17,1);
+      par.max(4)  =  6;
+      par.max(2)  =  6;
+      par.min(10) = -6;
+      par.min(4)  = -3;
+      par.min(2)  = -3;
+      par.number  = length(par.min);
+      par.name    = {'log_{10}(p1)','log_{10}(p2)','log_{10}(p3)','log_{10}(p4)','log_{10}(init_{STAT})',...
+         'log_{10}(sp1)','log_{10}(sp2)','log_{10}(sp3)','log_{10}(sp4)','log_{10}(sp5)',...
+         'log_{10}(offset_{tSTAT})','log_{10}(offset_{pSTAT})','log_{10}(scale_{tSTAT})','log_{10}(scale_{pSTAT})',...
+         'log_{10}(\sigma_{pSTAT})','log_{10}(\sigma_{tSTAT})','log_{10}(\sigma_{pEpoR})'};
+      
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 60;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 4000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e4;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      %       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+      %          rand(par.number,options.MCMC.PT.nTemps));
+      optimum = [0.602656039696963;5.99158941975455;-0.954928696723120;-0.0111612709630796;2.99159087292026;-2.80956590680809;-0.255716320541754;-0.0765445346531297;-0.407313978699970;-5.46184329322403;-0.731536104114366;-0.654123977718441;-0.108667272925215;0.0100555269616438;-1.42650133555338;-1.34879659859495;-1.16004385000543];
+      options.MCMC.theta0              = repmat(optimum,1,options.MCMC.PT.nTemps);
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));
+      
+      
+   elseif b <= 800      % JakStat RAMPART
+      
+      warning off;
+      
+      % Experimental data is read out from an .xls-file and written to an AMICI
+      % object which is used for the ODE integration
+      datatable         = xlsread('pnas_data_original.xls');
+      amiData.t         = datatable(:,1);       % time points
+      amiData.Y         = datatable(:,[2,4,6]); % measurement
+      amiData.condition = [1.4,0.45];           % initial conditions
+      amiData.Sigma_Y   = NaN(size(amiData.Y)); % preallocation of variances
+      amiData           = amidata(amiData);     % calling the AMICI routine
+      
+      % objective function
+      logP = @(theta) logLikelihoodJakstat_rampart(theta, amiData);
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.min     = -5 * ones(17,1);
+      par.max     =  3 * ones(17,1);
+      par.max(4)  =  6;
+      par.max(2)  =  6;
+      par.min(10) = -6;
+      par.min(4)  = -3;
+      par.min(2)  = -3;
+      par.number  = length(par.min);
+      par.name    = {'log_{10}(p1)','log_{10}(p2)','log_{10}(p3)','log_{10}(p4)','log_{10}(init_{STAT})',...
+         'log_{10}(sp1)','log_{10}(sp2)','log_{10}(sp3)','log_{10}(sp4)','log_{10}(sp5)',...
+         'log_{10}(offset_{tSTAT})','log_{10}(offset_{pSTAT})','log_{10}(scale_{tSTAT})','log_{10}(scale_{pSTAT})',...
+         'log_{10}(\sigma_{pSTAT})','log_{10}(\sigma_{tSTAT})','log_{10}(\sigma_{pEpoR})'};
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 60;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 4000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:5;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = zeros(1,options.MCMC.RAMPART.RPOpt.nDim);
+         options.MCMC.RAMPART.RPOpt.isInformative([11,13]) = ones(1,2);
+      
+      optimum = [0.602656039696963;5.99158941975455;-0.954928696723120;-0.0111612709630796;2.99159087292026;-2.80956590680809;-0.255716320541754;-0.0765445346531297;-0.407313978699970;-5.46184329322403;-0.731536104114366;-0.654123977718441;-0.108667272925215;0.0100555269616438;-1.42650133555338;-1.34879659859495;-1.16004385000543];
+      
+      %       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+      %          rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.theta0              = repmat(optimum,1,options.MCMC.RAMPART.nTemps);
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));
+      
+   elseif b <= 900      % mRNA + PT
+      
+      % Objective
+      setData_mRNA();
+      logP = @(theta) logLikelihoodT_rampart(theta, t, ym);
+
+      % Parameters
+      par.min    = [-2; -5; -5; -5; -2];
+      par.max    = [log10(max(t)); 5; 5; 5; 2];
+      par.number = 5;
+      par.name   = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+         'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+   
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 30;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 2000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e4;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      options.MCMC.theta0 = repmat([0.15,1.08,-2.8,-0.9,0.4],options.MCMC.PT.nTemps,1);
+      options.MCMC.theta0(1:2:end) = repmat([0.15,1.08,-0.9,-2.8,0.4],floor(options.MCMC.PT.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';
+      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.PT.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));      
+      
+   elseif b <= 1000      % mRNA + RAMPART
+      
+      % Objective
+      setData_mRNA();
+      logP = @(theta) logLikelihoodT_rampart(theta, t, ym);
+
+      % Parameters
+      par.min    = [-2; -5; -5; -5; -2];
+      par.max    = [log10(max(t)); 5; 5; 5; 2];
+      par.number = 5;
+      par.name   = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+         'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 30;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:5;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [0,0,1,1,0];
+
+      options.MCMC.theta0 = repmat([0.15,1.08,-2.8,-0.9,0.4],options.MCMC.RAMPART.nTemps,1);
+      options.MCMC.theta0(1:2:end) = repmat([0.15,1.08,-0.9,-2.8,0.4],floor(options.MCMC.RAMPART.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';
+            
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));  
+      
+   elseif b <= 1100      % RafMekErk + PT
+      
+
+      % Experimental data is read out from an .mat-file and written to an AMICI
+      % data object which is used for the ODE integration
+      load('D0.mat');
+      u = D.conditions;
+      nU = size(u,1);
+
+      % Clean up data and make Amici-readable data out of it
+      for j = 1 : nU
+          amiData(j) = struct(...
+              't', D.t{j}, ...
+              'condition', D.conditions(j,:), ...
+              'Y', D.measurement{j} ...
+              );
+          amiD(j) = amidata(amiData(j));
+      end
+
+      % Create amioptions.MCMC-object to not always recreate it in objective function
+      amioptions.MCMC.maxsteps = 1e6;
+      amioptions.MCMC.atol = 1e-15;
+      amioptions.MCMC.rtol = 1e-12;
+      amioptions.MCMC.sensi_meth = 'forward';
+      amiO = amioption(amioptions.MCMC);      
+      
+      % 12 dynamic parameters, 8 scaling parameters, 8 sigma parameters
+      par.min = -7 * ones(28,1);
+      par.min(7) = -10;
+%       par.min(9) = -7;
+      par.max = 7 * ones(28,1);
+%       par.max(1:3) = 5;
+%       par.max(4) = 6;
+%       par.max(13:20) = 8;
+
+      par.number = 28;
+      par.name = {'log_{10}(kdf_Raf)','log_{10}(kp_Raf)','log_{10}(kdp_pMek)',...
+                         'log_{10}(kp_pRaf_Mek)','log_{10}(kdp_pErk)','log_{10}(kp_pMek_Erk)',...
+                         'log_{10}(K_pErk_inh)','log_{10}(sust_Ras_0)','log_{10}(ts_sust_Ras)',...
+                         'log_{10}(ts_trans_Ras)','log_{10}(K_Sora)','log_{10}(K_UO)',... 
+                         'log_{10}(scale_pMek_20140430_gel1)','log_{10}(scale_pErk_20140430_gel1)',...
+                         'log_{10}(scale_pMek_20140430_gel2)','log_{10}(scale_pErk_20140430_gel2)',...
+                         'log_{10}(scale_pMek_20140505_gel1)','log_{10}(scale_pErk_20140505_gel1)',...
+                         'log_{10}(scale_pMek_20140505_gel2)','log_{10}(scale_pErk_20140505_gel2)',... 
+                         'log_{10}(sigma_pMek_20140430_gel1)','log_{10}(sigma_pErk_20140430_gel1)',...
+                         'log_{10}(sigma_pMek_20140430_gel2)','log_{10}(sigma_pErk_20140430_gel2)',...
+                         'log_{10}(sigma_pMek_20140505_gel1)','log_{10}(sigma_pErk_20140505_gel1)',...
+                         'log_{10}(sigma_pMek_20140505_gel2)','log_{10}(sigma_pErk_20140505_gel2)'...
+                         };      
+      
+      % objective Function
+      logP = @(theta) logLikelihoodRafMekErk_rampart(theta, amiD, amiO);
+   
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 60;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 4000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e4;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      optimum1 = [0.404532178719901;-1.15199399735599;0.930623459247375;2.71445919845768;-0.125144085595772;1.63943821480100;-8.98577780466755;-1.43704741758692;-5.27770166035246;0.163454278114226;-0.0445397976707693;-1.24520623848911;5.49568012427599;4.15069090975213;5.71501808332924;4.07817396618450;5.96251942807430;4.55279893540699;5.95903913014744;4.29659988404802;-0.316178065736042;-0.690385801416485;-0.459585483896793;-0.680920141427490;-0.765609871936958;0.476755979240735;0.775957941229954;-0.818768235958571];
+      optimum2 = [0.926511372501099;6.99579833870349;1.17185210856726;-3.61310413146387;0.0188980857493824;1.47223873395504;-8.96389735779425;-3.16579353623682;0.989814843382916;-0.0801788473454721;-0.184494576458966;-1.54936659538483;5.67169362588144;4.61429383149028;6.02052813634127;4.62493966792032;6.13829825473690;5.02084724343902;6.26433183945048;4.83503058750866;-0.317783912906717;-0.723090417277320;-0.499911273455874;-0.690768862127518;-0.754124432339130;0.464530016945866;0.777064306879496;-0.696271233254615];
+      
+      options.MCMC.theta0 = repmat(optimum1',options.MCMC.PT.nTemps,1);
+      options.MCMC.theta0(1:2:end) = repmat(optimum2',floor(options.MCMC.PT.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';      
+      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.PT.nTemps));
+      options.MCMC.sigma0              = 1e+6*diag(ones(1,par.number));      
+      
+   elseif b <= 1200      % RafMekErk + RAMPART
+      
+
+      % Experimental data is read out from an .mat-file and written to an AMICI
+      % data object which is used for the ODE integration
+      load('D0.mat');
+      u = D.conditions;
+      nU = size(u,1);
+
+      % Clean up data and make Amici-readable data out of it
+      for j = 1 : nU
+          amiData(j) = struct(...
+              't', D.t{j}, ...
+              'condition', D.conditions(j,:), ...
+              'Y', D.measurement{j} ...
+              );
+          amiD(j) = amidata(amiData(j));
+      end
+
+      % Create amioptions.MCMC-object to not always recreate it in objective function
+      amioptions.MCMC.maxsteps = 1e6;
+      amioptions.MCMC.atol = 1e-15;
+      amioptions.MCMC.rtol = 1e-12;
+      amioptions.MCMC.sensi_meth = 'forward';
+      amiO = amioption(amioptions.MCMC);      
+      
+      % 12 dynamic parameters, 8 scaling parameters, 8 sigma parameters
+      par.min = -7 * ones(28,1);
+      par.min(7) = -10;
+%       par.min(9) = -7;
+      par.max = 7 * ones(28,1);
+%       par.max(1:3) = 5;
+%       par.max(4) = 6;
+%       par.max(13:20) = 8;
+
+      par.number = 28;
+      par.name = {'log_{10}(kdf_Raf)','log_{10}(kp_Raf)','log_{10}(kdp_pMek)',...
+                         'log_{10}(kp_pRaf_Mek)','log_{10}(kdp_pErk)','log_{10}(kp_pMek_Erk)',...
+                         'log_{10}(K_pErk_inh)','log_{10}(sust_Ras_0)','log_{10}(ts_sust_Ras)',...
+                         'log_{10}(ts_trans_Ras)','log_{10}(K_Sora)','log_{10}(K_UO)',... 
+                         'log_{10}(scale_pMek_20140430_gel1)','log_{10}(scale_pErk_20140430_gel1)',...
+                         'log_{10}(scale_pMek_20140430_gel2)','log_{10}(scale_pErk_20140430_gel2)',...
+                         'log_{10}(scale_pMek_20140505_gel1)','log_{10}(scale_pErk_20140505_gel1)',...
+                         'log_{10}(scale_pMek_20140505_gel2)','log_{10}(scale_pErk_20140505_gel2)',... 
+                         'log_{10}(sigma_pMek_20140430_gel1)','log_{10}(sigma_pErk_20140430_gel1)',...
+                         'log_{10}(sigma_pMek_20140430_gel2)','log_{10}(sigma_pErk_20140430_gel2)',...
+                         'log_{10}(sigma_pMek_20140505_gel1)','log_{10}(sigma_pErk_20140505_gel1)',...
+                         'log_{10}(sigma_pMek_20140505_gel2)','log_{10}(sigma_pErk_20140505_gel2)'...
+                         };      
+      
+      % objective Function
+      logP = @(theta) logLikelihoodRafMekErk_rampart(theta, amiD, amiO);
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 60;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 4000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.5;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:5;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = ones(1,length(par.min));
+
+      optimum1 = [0.404532178719901;-1.15199399735599;0.930623459247375;2.71445919845768;-0.125144085595772;1.63943821480100;-8.98577780466755;-1.43704741758692;-5.27770166035246;0.163454278114226;-0.0445397976707693;-1.24520623848911;5.49568012427599;4.15069090975213;5.71501808332924;4.07817396618450;5.96251942807430;4.55279893540699;5.95903913014744;4.29659988404802;-0.316178065736042;-0.690385801416485;-0.459585483896793;-0.680920141427490;-0.765609871936958;0.476755979240735;0.775957941229954;-0.818768235958571];
+      optimum2 = [0.926511372501099;6.99579833870349;1.17185210856726;-3.61310413146387;0.0188980857493824;1.47223873395504;-8.96389735779425;-3.16579353623682;0.989814843382916;-0.0801788473454721;-0.184494576458966;-1.54936659538483;5.67169362588144;4.61429383149028;6.02052813634127;4.62493966792032;6.13829825473690;5.02084724343902;6.26433183945048;4.83503058750866;-0.317783912906717;-0.723090417277320;-0.499911273455874;-0.690768862127518;-0.754124432339130;0.464530016945866;0.777064306879496;-0.696271233254615];
+      
+      options.MCMC.theta0 = repmat(optimum1',options.MCMC.RAMPART.nTemps,1);
+      options.MCMC.theta0(1:2:end) = repmat(optimum2',floor(options.MCMC.RAMPART.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';   
+      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));  
+            
+   elseif b <= 1300      % mRNA(exp) + PT
+      
+      % Objective
+      load('mRNA_data_exp');
+      logP = @(theta) logLikelihoodT_rampart(theta, t, ym);
+
+      % Parameters
+      par.min    = [-2; -5; -5; -5; -2];
+      par.max    = [log10(max(t)); 5; 5; 5; 2];
+      par.number = 5;
+      par.name   = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+         'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+   
+      % Using PT
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 30;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 2000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e4;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10;
+      
+      options.MCMC.theta0 = repmat([0.15,1.08,-2.8,-0.9,0.4],options.MCMC.PT.nTemps,1);
+      options.MCMC.theta0(1:2:end) = repmat([0.15,1.08,-0.9,-2.8,0.4],floor(options.MCMC.PT.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';
+      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.PT.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));      
+      
+   elseif b <= 1400      % mRNA(exp) + RAMPART
+      
+      % Objective
+      load('mRNA_data_exp');
+      logP = @(theta) logLikelihoodT_rampart(theta, t, ym);
+
+      % Parameters
+      par.min    = [-2; -5; -5; -5; -2];
+      par.max    = [log10(max(t)); 5; 5; 5; 2];
+      par.number = 5;
+      par.name   = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+         'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 30;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:5;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [0,0,1,1,0];
+
+      options.MCMC.theta0 = repmat([0.15,1.08,-2.8,-0.9,0.4],options.MCMC.RAMPART.nTemps,1);
+      options.MCMC.theta0(1:2:end) = repmat([0.15,1.08,-0.9,-2.8,0.4],floor(options.MCMC.RAMPART.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';
+            
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));  
+      
+   elseif b <= 1500   % Ring + RegionOnly
+      
+      % Settings for this example
+      radius = 50;
+      sigma = 5;
+      dimi = 18; % extraDimensions
+      logP = @(theta) simulateRingLLH(theta, radius, sigma, dimi);
+      ringDimension = 2;
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.number = ringDimension + dimi;
+      par.min    = [-200;-200;-20*ones(dimi,1)];
+      par.max    = [200;200;20*ones(dimi,1)];
+      par.name   = {};
+      for i = 1 : dimi + 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 1;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:20;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [1,1,ones(1,options.MCMC.RAMPART.RPOpt.nDim-2)];
+      
+      randoms                     = randn(2,options.MCMC.RAMPART.nTemps);
+      squareSum                   = sqrt(sum(randoms.^2));
+      randomPointsOnRing          = [randoms(1,:) ./ squareSum; randoms(2,:) ./ squareSum];
+      options.MCMC.theta0              = [radius*randomPointsOnRing;zeros(dimi,options.MCMC.RAMPART.nTemps)];
+      options.MCMC.sigma0              = 1e6*diag(ones(1,dimi+2));     
+      
+   elseif b <= 1600   % Gauss + RegionOnly
+      
+      define_Gauss_LLH();
+      gaussDimension = 2 + dimi;
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.number = gaussDimension;
+      par.min    = [-100;-100;-100*ones(dimi,1)];
+      par.max    = [100;100;100*ones(dimi,1)];
+      par.name   = {};
+      for i = 1 : dimi + 2
+         par.name{end+1} = ['\theta_' num2str(i)];
+      end
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 1;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:10;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [1,1,ones(1,options.MCMC.RAMPART.RPOpt.nDim-2)];
+      
+      options.MCMC.theta0              = repmat([mu(1,:),repmat(25,1,dimi)]',1,options.MCMC.RAMPART.nTemps);
+      options.MCMC.theta0(:,1:2:end)   = repmat([mu(2,:),repmat(25,1,dimi)]',1,ceil(options.MCMC.RAMPART.nTemps/2));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,dimi+2));       
+      
+   elseif b <= 1700      % JakStat + RegionOnly
+      
+      warning off;
+      
+      % Experimental data is read out from an .xls-file and written to an AMICI
+      % object which is used for the ODE integration
+      datatable         = xlsread('pnas_data_original.xls');
+      amiData.t         = datatable(:,1);       % time points
+      amiData.Y         = datatable(:,[2,4,6]); % measurement
+      amiData.condition = [1.4,0.45];           % initial conditions
+      amiData.Sigma_Y   = NaN(size(amiData.Y)); % preallocation of variances
+      amiData           = amidata(amiData);     % calling the AMICI routine
+      
+      % objective function
+      logP = @(theta) logLikelihoodJakstat_rampart(theta, amiData);
+      
+      % Set required sampling options.MCMC for Parallel Tempering
+      par.min     = -5 * ones(17,1);
+      par.max     =  3 * ones(17,1);
+      par.max(4)  =  6;
+      par.max(2)  =  6;
+      par.min(10) = -6;
+      par.min(4)  = -3;
+      par.min(2)  = -3;
+      par.number  = length(par.min);
+      par.name    = {'log_{10}(p1)','log_{10}(p2)','log_{10}(p3)','log_{10}(p4)','log_{10}(init_{STAT})',...
+         'log_{10}(sp1)','log_{10}(sp2)','log_{10}(sp3)','log_{10}(sp4)','log_{10}(sp5)',...
+         'log_{10}(offset_{tSTAT})','log_{10}(offset_{pSTAT})','log_{10}(scale_{tSTAT})','log_{10}(scale_{pSTAT})',...
+         'log_{10}(\sigma_{pSTAT})','log_{10}(\sigma_{tSTAT})','log_{10}(\sigma_{pEpoR})'};
+      
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 1;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 4000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:5;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = zeros(1,options.MCMC.RAMPART.RPOpt.nDim);
+         options.MCMC.RAMPART.RPOpt.isInformative([11,13]) = ones(1,2);
+      
+      optimum = [0.602656039696963;5.99158941975455;-0.954928696723120;-0.0111612709630796;2.99159087292026;-2.80956590680809;-0.255716320541754;-0.0765445346531297;-0.407313978699970;-5.46184329322403;-0.731536104114366;-0.654123977718441;-0.108667272925215;0.0100555269616438;-1.42650133555338;-1.34879659859495;-1.16004385000543];
+      
+      %       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+      %          rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.theta0              = repmat(optimum,1,options.MCMC.RAMPART.nTemps);
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number)); 
+      
+   elseif b <= 1800      % mRNA(exp) + RegionOnly
+      
+      % Objective
+      load('mRNA_data_exp');
+      logP = @(theta) logLikelihoodT_rampart(theta, t, ym);
+
+      % Parameters
+      par.min    = [-2; -5; -5; -5; -2];
+      par.max    = [log10(max(t)); 5; 5; 5; 2];
+      par.number = 5;
+      par.name   = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+         'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 1;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 2000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:5;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = [0,0,1,1,0];
+
+      options.MCMC.theta0 = repmat([0.15,1.08,-2.8,-0.9,0.4],options.MCMC.RAMPART.nTemps,1);
+      %options.MCMC.theta0(1:2:end) = repmat([0.15,1.08,-0.9,-2.8,0.4],floor(options.MCMC.RAMPART.nTemps/2),1);
+      options.MCMC.theta0 = options.MCMC.theta0';
+            
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%                rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,par.number));            
+
+   elseif b <= 1900      % Bachmann + PT
+      
+      % Objective
+      objoptions.MCMC.llh.original = false;
+      objoptions.MCMC.ami = amioption();
+      load data_Bachmann
+      D = fillDataStruct(D);
+      for cond = 1:numel(D)
+         D(cond).my(:,[1:10,12:end],:) = 10.^D(cond).my(:,[1:10,12:end],:);
+      end
+      D(3).my = D(3).my - 1; %instead of having observable 1 + scaling*...
+      logP = @(xi) logLikelihood_Bachmann_rampart(xi,D,objoptions.MCMC);
+
+      % Parameters
+      par.name = {'CISEqc' 'CISEqcOE' 'CISInh' 'CISRNADelay' 'CISRNATurn' 'CISTurn' 'EpoRActJAK2' 'EpoRCISInh' 'EpoRCISRemove' 'JAK2ActEpo' 'JAK2EpoRDeaSHP1' 'SHP1ActEpoR' 'SHP1Dea' 'SHP1ProOE' 'SOCS3Eqc' 'SOCS3EqcOE' 'SOCS3Inh' 'SOCS3RNADelay' 'SOCS3RNATurn' 'SOCS3Turn' 'STAT5ActEpoR' 'STAT5ActJAK2' 'STAT5Exp' 'STAT5Imp' 'init_EpoRJAK2' 'init_SHP1' 'init_STAT5' 'offset_CIS_actd' 'offset_CIS_cisoe' 'offset_CIS_long' 'offset_CIS_shp1oe' 'offset_CIS_socs3oe' 'offset_SOCS3_cisoe' 'offset_SOCS3_long' 'offset_SOCS3_socs3oe' 'offset_pEpoR_actd' 'offset_pEpoR_cisoe' 'offset_pEpoR_cisoe_pepor' 'offset_pEpoR_dr30' 'offset_pEpoR_dr7' 'offset_pEpoR_fine' 'offset_pEpoR_long' 'offset_pEpoR_shp1oe' 'offset_pEpoR_socs3oe' 'offset_pJAK2_actd' 'offset_pJAK2_cisoe' 'offset_pJAK2_dr30' 'offset_pJAK2_dr7' 'offset_pJAK2_fine' 'offset_pJAK2_long' 'offset_pJAK2_shp1oe' 'offset_pJAK2_socs3oe' 'offset_pSTAT5_actd' 'offset_pSTAT5_cisoe' 'offset_pSTAT5_conc' 'offset_pSTAT5_long' 'offset_pSTAT5_shp1oe' 'offset_pSTAT5_socs3oe' 'scale1_CIS_dr90' 'scale2_CIS_dr90' 'scale_CISRNA_foldA' 'scale_CISRNA_foldB' 'scale_CISRNA_foldC' 'scale_CIS_actd' 'scale_CIS_cisoe' 'scale_CIS_long' 'scale_CIS_shp1oe' 'scale_CIS_socs3oe' 'scale_SHP1_shp1oe' 'scale_SOCS3RNA_foldA' 'scale_SOCS3RNA_foldB' 'scale_SOCS3RNA_foldC' 'scale_SOCS3_cisoe' 'scale_SOCS3_long' 'scale_SOCS3_socs3oe' 'scale_pEpoR_actd' 'scale_pEpoR_cisoe' 'scale_pEpoR_cisoe_pepor' 'scale_pEpoR_dr30' 'scale_pEpoR_dr7' 'scale_pEpoR_fine' 'scale_pEpoR_long' 'scale_pEpoR_shp1oe' 'scale_pEpoR_socs3oe' 'scale_pJAK2_actd' 'scale_pJAK2_cisoe' 'scale_pJAK2_dr30' 'scale_pJAK2_dr7' 'scale_pJAK2_fine' 'scale_pJAK2_long' 'scale_pJAK2_shp1oe' 'scale_pJAK2_socs3oe' 'scale_pSTAT5_actd' 'scale_pSTAT5_cisoe' 'scale_pSTAT5_dr10' 'scale_pSTAT5_long' 'scale_pSTAT5_shp1oe' 'scale_pSTAT5_socs3oe' 'scale_tSTAT5_actd' 'scale_tSTAT5_long' 'scale_tSTAT5_shp1oe' 'sd_CIS_abs' 'sd_CIS_au' 'sd_JAK2EpoR_au' 'sd_RNA_fold' 'sd_SHP1_abs' 'sd_SHP1_au' 'sd_SOCS3_abs' 'sd_SOCS3_au' 'sd_STAT5_abs' 'sd_STAT5_au' 'sd_pSTAT5_rel'}';
+      par.number = numel(par.name);
+      par.min = -3*ones(par.number,1);
+      par.max = 3*ones(par.number,1);
+      par.max(1) = 4; %CISEqc
+      par.max(3) = 12; %CISInh
+      par.max(7) = 4; %EpoRActJAK2
+      par.max(8) = 6; %EpoRCISInh
+      par.max(10) = 9; %JAK2ActEpo
+      par.max(11) = 4; %JAK2EpoRDeaSHP1
+      par.max(20) = 4;
+      par.min(28:58) = -5;
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm   = 'PT';
+      options.MCMC.PT.nTemps           = 40;
+      options.MCMC.PT.exponentT        = 1000;
+      options.MCMC.PT.maxT             = 4000;
+      options.MCMC.PT.alpha            = 0.51;
+      options.MCMC.PT.temperatureNu    = 1e3;
+      options.MCMC.PT.memoryLength     = 1;
+      options.MCMC.PT.regFactor        = 1e-8;
+      options.MCMC.PT.temperatureEta   = 10; 
+      
+      
+      optimum = [2.86232606827069;-0.502422096739780;7.77937388641153;-0.393646663793657;-1.85337064914425;-1.65901012248591;-0.175527452205663;5.99397608126439;0.490269030104304;5.85352772075863;2.16686363292317;-2.99986709031978;-2.25320253141448;0.456199501389603;2.64311819543564;-0.604270991425694;1.77559679621343;0.410241141785733;-2.32677227864291;3.40449741907585;1.22956039234025;-1.31297329585788;-0.931061619929439;-1.85706903313810;-0.00373865219961764;1.42691975775748;1.90174965449851;-3.39144949591912;-1.88907312866097;-3.01878329883187;-3.12594445482639;-2.64645394418856;-2.10780761271563;-2.58994176591354;-2.11582628736949;-0.984233935041619;-0.871845604168948;0.0883871544681648;-0.845868353456512;-0.452427352285251;0.0188289954680599;-1.76120946707599;-0.821264685061566;-1.04633758126566;-1.71646648220882;-1.96613083832404;-1.87144766441740;-1.04477332646742;-1.27211922209546;-2.05440146916893;-1.95695556365195;-1.42330654319352;-2.58986281643283;-1.40588456742250;-0.0845463676862642;-2.94418740847154;-1.13764939569610;-2.05312240695405;1.52409878482981;1.48687667467431;1.88683701780059;1.92619688227464;1.69711856419154;1.36154777163715;0.366291220995710;1.42794596627500;1.88106519340287;1.60809766780178;-0.648639531426019;2.10803048516793;2.12856567194553;2.22110552337757;1.56051868967470;1.58688091151516;0.516924060920506;-0.722685373800055;-0.627905450768051;-0.940534708488127;-0.408051538041791;-1.08669789463075;-1.22154877980665;-0.586335130650139;-0.683586709729490;-0.181921006454804;-0.0491423326597203;0.312646332255249;0.284766108155061;-0.302115105988178;-0.384808502783200;0.0399802252689929;0.388258611599171;0.209344910164416;-0.139109318743327;0.264292566436898;-0.131312730877646;-0.0123451102873752;-0.128224545687396;-0.0820554178530755;-0.109691986924721;-0.129796340260603;-0.180176620892595;-2.28935329635148;-1.85718836487494;-1.43352832153068;-1.33528935625950;-2.37543694657685;-2.22410218355462;-1.97671407431685;-2.34945983489515;-1.84512430315369;-1.54202056243394;-1.74136317513865];
+      options.MCMC.theta0 = repmat(optimum,1,options.MCMC.PT.nTemps);      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%           rand(par.number,options.MCMC.PT.nTemps));
+      
+%       options.MCMC.theta0              = repmat(opt1,1,options.MCMC.PT.nTemps);
+%       options.MCMC.theta0(:,1:2:end)   = repmat(opt2,1,ceil(options.MCMC.PT.nTemps/2));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,112));      
+      
+   elseif b <= 2000      % Bachmann + RAMPART
+      
+      % Objective
+      objoptions.MCMC.llh.original = false;
+      objoptions.MCMC.ami = amioption();
+      load data_Bachmann
+      D = fillDataStruct(D);
+      for cond = 1:numel(D)
+         D(cond).my(:,[1:10,12:end],:) = 10.^D(cond).my(:,[1:10,12:end],:);
+      end
+      D(3).my = D(3).my - 1; %instead of having observable 1 + scaling*...
+      logP = @(xi) logLikelihood_Bachmann_rampart(xi,D,objoptions.MCMC);
+
+      % Parameters
+      par.name = {'CISEqc' 'CISEqcOE' 'CISInh' 'CISRNADelay' 'CISRNATurn' 'CISTurn' 'EpoRActJAK2' 'EpoRCISInh' 'EpoRCISRemove' 'JAK2ActEpo' 'JAK2EpoRDeaSHP1' 'SHP1ActEpoR' 'SHP1Dea' 'SHP1ProOE' 'SOCS3Eqc' 'SOCS3EqcOE' 'SOCS3Inh' 'SOCS3RNADelay' 'SOCS3RNATurn' 'SOCS3Turn' 'STAT5ActEpoR' 'STAT5ActJAK2' 'STAT5Exp' 'STAT5Imp' 'init_EpoRJAK2' 'init_SHP1' 'init_STAT5' 'offset_CIS_actd' 'offset_CIS_cisoe' 'offset_CIS_long' 'offset_CIS_shp1oe' 'offset_CIS_socs3oe' 'offset_SOCS3_cisoe' 'offset_SOCS3_long' 'offset_SOCS3_socs3oe' 'offset_pEpoR_actd' 'offset_pEpoR_cisoe' 'offset_pEpoR_cisoe_pepor' 'offset_pEpoR_dr30' 'offset_pEpoR_dr7' 'offset_pEpoR_fine' 'offset_pEpoR_long' 'offset_pEpoR_shp1oe' 'offset_pEpoR_socs3oe' 'offset_pJAK2_actd' 'offset_pJAK2_cisoe' 'offset_pJAK2_dr30' 'offset_pJAK2_dr7' 'offset_pJAK2_fine' 'offset_pJAK2_long' 'offset_pJAK2_shp1oe' 'offset_pJAK2_socs3oe' 'offset_pSTAT5_actd' 'offset_pSTAT5_cisoe' 'offset_pSTAT5_conc' 'offset_pSTAT5_long' 'offset_pSTAT5_shp1oe' 'offset_pSTAT5_socs3oe' 'scale1_CIS_dr90' 'scale2_CIS_dr90' 'scale_CISRNA_foldA' 'scale_CISRNA_foldB' 'scale_CISRNA_foldC' 'scale_CIS_actd' 'scale_CIS_cisoe' 'scale_CIS_long' 'scale_CIS_shp1oe' 'scale_CIS_socs3oe' 'scale_SHP1_shp1oe' 'scale_SOCS3RNA_foldA' 'scale_SOCS3RNA_foldB' 'scale_SOCS3RNA_foldC' 'scale_SOCS3_cisoe' 'scale_SOCS3_long' 'scale_SOCS3_socs3oe' 'scale_pEpoR_actd' 'scale_pEpoR_cisoe' 'scale_pEpoR_cisoe_pepor' 'scale_pEpoR_dr30' 'scale_pEpoR_dr7' 'scale_pEpoR_fine' 'scale_pEpoR_long' 'scale_pEpoR_shp1oe' 'scale_pEpoR_socs3oe' 'scale_pJAK2_actd' 'scale_pJAK2_cisoe' 'scale_pJAK2_dr30' 'scale_pJAK2_dr7' 'scale_pJAK2_fine' 'scale_pJAK2_long' 'scale_pJAK2_shp1oe' 'scale_pJAK2_socs3oe' 'scale_pSTAT5_actd' 'scale_pSTAT5_cisoe' 'scale_pSTAT5_dr10' 'scale_pSTAT5_long' 'scale_pSTAT5_shp1oe' 'scale_pSTAT5_socs3oe' 'scale_tSTAT5_actd' 'scale_tSTAT5_long' 'scale_tSTAT5_shp1oe' 'sd_CIS_abs' 'sd_CIS_au' 'sd_JAK2EpoR_au' 'sd_RNA_fold' 'sd_SHP1_abs' 'sd_SHP1_au' 'sd_SOCS3_abs' 'sd_SOCS3_au' 'sd_STAT5_abs' 'sd_STAT5_au' 'sd_pSTAT5_rel'}';
+      par.number = numel(par.name);
+      par.min = -3*ones(par.number,1);
+      par.max = 3*ones(par.number,1);
+      par.max(1) = 4; %CISEqc
+      par.max(3) = 12; %CISInh
+      par.max(7) = 4; %EpoRActJAK2
+      par.max(8) = 6; %EpoRCISInh
+      par.max(10) = 9; %JAK2ActEpo
+      par.max(11) = 4; %JAK2EpoRDeaSHP1
+      par.max(20) = 4;
+      par.min(28:58) = -5;
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 40;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 4000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:10;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = ones(1,par.number);
+      
+      optimum = [2.86232606827069;-0.502422096739780;7.77937388641153;-0.393646663793657;-1.85337064914425;-1.65901012248591;-0.175527452205663;5.99397608126439;0.490269030104304;5.85352772075863;2.16686363292317;-2.99986709031978;-2.25320253141448;0.456199501389603;2.64311819543564;-0.604270991425694;1.77559679621343;0.410241141785733;-2.32677227864291;3.40449741907585;1.22956039234025;-1.31297329585788;-0.931061619929439;-1.85706903313810;-0.00373865219961764;1.42691975775748;1.90174965449851;-3.39144949591912;-1.88907312866097;-3.01878329883187;-3.12594445482639;-2.64645394418856;-2.10780761271563;-2.58994176591354;-2.11582628736949;-0.984233935041619;-0.871845604168948;0.0883871544681648;-0.845868353456512;-0.452427352285251;0.0188289954680599;-1.76120946707599;-0.821264685061566;-1.04633758126566;-1.71646648220882;-1.96613083832404;-1.87144766441740;-1.04477332646742;-1.27211922209546;-2.05440146916893;-1.95695556365195;-1.42330654319352;-2.58986281643283;-1.40588456742250;-0.0845463676862642;-2.94418740847154;-1.13764939569610;-2.05312240695405;1.52409878482981;1.48687667467431;1.88683701780059;1.92619688227464;1.69711856419154;1.36154777163715;0.366291220995710;1.42794596627500;1.88106519340287;1.60809766780178;-0.648639531426019;2.10803048516793;2.12856567194553;2.22110552337757;1.56051868967470;1.58688091151516;0.516924060920506;-0.722685373800055;-0.627905450768051;-0.940534708488127;-0.408051538041791;-1.08669789463075;-1.22154877980665;-0.586335130650139;-0.683586709729490;-0.181921006454804;-0.0491423326597203;0.312646332255249;0.284766108155061;-0.302115105988178;-0.384808502783200;0.0399802252689929;0.388258611599171;0.209344910164416;-0.139109318743327;0.264292566436898;-0.131312730877646;-0.0123451102873752;-0.128224545687396;-0.0820554178530755;-0.109691986924721;-0.129796340260603;-0.180176620892595;-2.28935329635148;-1.85718836487494;-1.43352832153068;-1.33528935625950;-2.37543694657685;-2.22410218355462;-1.97671407431685;-2.34945983489515;-1.84512430315369;-1.54202056243394;-1.74136317513865];
+      options.MCMC.theta0 = repmat(optimum,1,options.MCMC.RAMPART.nTemps);      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%           rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,112));
+ 
+   elseif b <= 2100      % Bachmann + RegionOnly
+      
+      % Objective
+      objoptions.MCMC.llh.original = false;
+      objoptions.MCMC.ami = amioption();
+      load data_Bachmann
+      D = fillDataStruct(D);
+      for cond = 1:numel(D)
+         D(cond).my(:,[1:10,12:end],:) = 10.^D(cond).my(:,[1:10,12:end],:);
+      end
+      D(3).my = D(3).my - 1; %instead of having observable 1 + scaling*...
+      logP = @(xi) logLikelihood_Bachmann_rampart(xi,D,objoptions.MCMC);
+
+      % Parameters
+      par.name = {'CISEqc' 'CISEqcOE' 'CISInh' 'CISRNADelay' 'CISRNATurn' 'CISTurn' 'EpoRActJAK2' 'EpoRCISInh' 'EpoRCISRemove' 'JAK2ActEpo' 'JAK2EpoRDeaSHP1' 'SHP1ActEpoR' 'SHP1Dea' 'SHP1ProOE' 'SOCS3Eqc' 'SOCS3EqcOE' 'SOCS3Inh' 'SOCS3RNADelay' 'SOCS3RNATurn' 'SOCS3Turn' 'STAT5ActEpoR' 'STAT5ActJAK2' 'STAT5Exp' 'STAT5Imp' 'init_EpoRJAK2' 'init_SHP1' 'init_STAT5' 'offset_CIS_actd' 'offset_CIS_cisoe' 'offset_CIS_long' 'offset_CIS_shp1oe' 'offset_CIS_socs3oe' 'offset_SOCS3_cisoe' 'offset_SOCS3_long' 'offset_SOCS3_socs3oe' 'offset_pEpoR_actd' 'offset_pEpoR_cisoe' 'offset_pEpoR_cisoe_pepor' 'offset_pEpoR_dr30' 'offset_pEpoR_dr7' 'offset_pEpoR_fine' 'offset_pEpoR_long' 'offset_pEpoR_shp1oe' 'offset_pEpoR_socs3oe' 'offset_pJAK2_actd' 'offset_pJAK2_cisoe' 'offset_pJAK2_dr30' 'offset_pJAK2_dr7' 'offset_pJAK2_fine' 'offset_pJAK2_long' 'offset_pJAK2_shp1oe' 'offset_pJAK2_socs3oe' 'offset_pSTAT5_actd' 'offset_pSTAT5_cisoe' 'offset_pSTAT5_conc' 'offset_pSTAT5_long' 'offset_pSTAT5_shp1oe' 'offset_pSTAT5_socs3oe' 'scale1_CIS_dr90' 'scale2_CIS_dr90' 'scale_CISRNA_foldA' 'scale_CISRNA_foldB' 'scale_CISRNA_foldC' 'scale_CIS_actd' 'scale_CIS_cisoe' 'scale_CIS_long' 'scale_CIS_shp1oe' 'scale_CIS_socs3oe' 'scale_SHP1_shp1oe' 'scale_SOCS3RNA_foldA' 'scale_SOCS3RNA_foldB' 'scale_SOCS3RNA_foldC' 'scale_SOCS3_cisoe' 'scale_SOCS3_long' 'scale_SOCS3_socs3oe' 'scale_pEpoR_actd' 'scale_pEpoR_cisoe' 'scale_pEpoR_cisoe_pepor' 'scale_pEpoR_dr30' 'scale_pEpoR_dr7' 'scale_pEpoR_fine' 'scale_pEpoR_long' 'scale_pEpoR_shp1oe' 'scale_pEpoR_socs3oe' 'scale_pJAK2_actd' 'scale_pJAK2_cisoe' 'scale_pJAK2_dr30' 'scale_pJAK2_dr7' 'scale_pJAK2_fine' 'scale_pJAK2_long' 'scale_pJAK2_shp1oe' 'scale_pJAK2_socs3oe' 'scale_pSTAT5_actd' 'scale_pSTAT5_cisoe' 'scale_pSTAT5_dr10' 'scale_pSTAT5_long' 'scale_pSTAT5_shp1oe' 'scale_pSTAT5_socs3oe' 'scale_tSTAT5_actd' 'scale_tSTAT5_long' 'scale_tSTAT5_shp1oe' 'sd_CIS_abs' 'sd_CIS_au' 'sd_JAK2EpoR_au' 'sd_RNA_fold' 'sd_SHP1_abs' 'sd_SHP1_au' 'sd_SOCS3_abs' 'sd_SOCS3_au' 'sd_STAT5_abs' 'sd_STAT5_au' 'sd_pSTAT5_rel'}';
+      par.number = numel(par.name);
+      par.min = -3*ones(par.number,1);
+      par.max = 3*ones(par.number,1);
+      par.max(1) = 4; %CISEqc
+      par.max(3) = 12; %CISInh
+      par.max(7) = 4; %EpoRActJAK2
+      par.max(8) = 6; %EpoRCISInh
+      par.max(10) = 9; %JAK2ActEpo
+      par.max(11) = 4; %JAK2EpoRDeaSHP1
+      par.max(20) = 4;
+      par.min(28:58) = -5;
+   
+      % Using RAMPART
+      options.MCMC.samplingAlgorithm     = 'RAMPART';
+      options.MCMC.RAMPART.nTemps           = 10;
+      options.MCMC.RAMPART.exponentT        = 1000;
+      options.MCMC.RAMPART.maxT             = 4000;
+      options.MCMC.RAMPART.alpha            = 0.51;
+      options.MCMC.RAMPART.temperatureNu    = 1e3;
+      options.MCMC.RAMPART.memoryLength     = 1;
+      options.MCMC.RAMPART.regFactor        = 1e-8;
+      options.MCMC.RAMPART.temperatureEta   = 10;
+      
+      options.MCMC.RAMPART.trainPhaseFrac   = 0.1;
+      options.MCMC.RAMPART.nTrainReplicates = 5;
+      
+      options.MCMC.RAMPART.RPOpt.rng                  = b;
+      options.MCMC.RAMPART.RPOpt.nSample              = floor(options.MCMC.nIterations*options.MCMC.RAMPART.trainPhaseFrac)-1;
+      options.MCMC.RAMPART.RPOpt.crossValFraction     = 0.2;
+      options.MCMC.RAMPART.RPOpt.modeNumberCandidates = 1:10;
+      options.MCMC.RAMPART.RPOpt.displayMode          = 'silent';
+      options.MCMC.RAMPART.RPOpt.maxEMiterations      = 100;
+      options.MCMC.RAMPART.RPOpt.nDim                 = par.number;
+      options.MCMC.RAMPART.RPOpt.nSubsetSize          = 1000;
+      options.MCMC.RAMPART.RPOpt.lowerBound           = par.min;
+      options.MCMC.RAMPART.RPOpt.upperBound           = par.max;
+      options.MCMC.RAMPART.RPOpt.tolMu                = 1e-4 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.tolSigma             = 1e-2 * (par.max(1)-par.min(1));
+      options.MCMC.RAMPART.RPOpt.dimensionsToPlot     = [1,2];
+      options.MCMC.RAMPART.RPOpt.isInformative        = ones(1,par.number);
+      
+      optimum = [2.86232606827069;-0.502422096739780;7.77937388641153;-0.393646663793657;-1.85337064914425;-1.65901012248591;-0.175527452205663;5.99397608126439;0.490269030104304;5.85352772075863;2.16686363292317;-2.99986709031978;-2.25320253141448;0.456199501389603;2.64311819543564;-0.604270991425694;1.77559679621343;0.410241141785733;-2.32677227864291;3.40449741907585;1.22956039234025;-1.31297329585788;-0.931061619929439;-1.85706903313810;-0.00373865219961764;1.42691975775748;1.90174965449851;-3.39144949591912;-1.88907312866097;-3.01878329883187;-3.12594445482639;-2.64645394418856;-2.10780761271563;-2.58994176591354;-2.11582628736949;-0.984233935041619;-0.871845604168948;0.0883871544681648;-0.845868353456512;-0.452427352285251;0.0188289954680599;-1.76120946707599;-0.821264685061566;-1.04633758126566;-1.71646648220882;-1.96613083832404;-1.87144766441740;-1.04477332646742;-1.27211922209546;-2.05440146916893;-1.95695556365195;-1.42330654319352;-2.58986281643283;-1.40588456742250;-0.0845463676862642;-2.94418740847154;-1.13764939569610;-2.05312240695405;1.52409878482981;1.48687667467431;1.88683701780059;1.92619688227464;1.69711856419154;1.36154777163715;0.366291220995710;1.42794596627500;1.88106519340287;1.60809766780178;-0.648639531426019;2.10803048516793;2.12856567194553;2.22110552337757;1.56051868967470;1.58688091151516;0.516924060920506;-0.722685373800055;-0.627905450768051;-0.940534708488127;-0.408051538041791;-1.08669789463075;-1.22154877980665;-0.586335130650139;-0.683586709729490;-0.181921006454804;-0.0491423326597203;0.312646332255249;0.284766108155061;-0.302115105988178;-0.384808502783200;0.0399802252689929;0.388258611599171;0.209344910164416;-0.139109318743327;0.264292566436898;-0.131312730877646;-0.0123451102873752;-0.128224545687396;-0.0820554178530755;-0.109691986924721;-0.129796340260603;-0.180176620892595;-2.28935329635148;-1.85718836487494;-1.43352832153068;-1.33528935625950;-2.37543694657685;-2.22410218355462;-1.97671407431685;-2.34945983489515;-1.84512430315369;-1.54202056243394;-1.74136317513865];
+      options.MCMC.theta0 = repmat(optimum,1,options.MCMC.RAMPART.nTemps);
+
+      
+%       options.MCMC.theta0              = bsxfun(@times,par.min+(par.max-par.min),...
+%           rand(par.number,options.MCMC.RAMPART.nTemps));
+      options.MCMC.sigma0              = 1e6*diag(ones(1,112));      
+      
+   end
+   
+   % Perform the parameter estimation via sampling and save each 500
+   % iterations
+   targetFile = [targetDir filesep 'SAVE_' num2str(b)];
+   options.MCMC.saveFileName = targetFile;
+   options.MCMC.saveEach     = 500;
+   
+   tic
+   res = getParameterSamples(par, logP, options);
+   calcTime = toc;
+   smpl = squeeze(res.S.par(:,:,1));
+   
+   % Save final result
+   if ~exist([targetDir filesep 'results'],'dir')
+      mkdir([targetDir filesep 'results']);
+   end
+   meta=res.S; meta.par=[];
+   targetFile = [targetDir filesep 'res_' num2str(b)];   
+   save(targetFile,'par','options','smpl','calcTime','meta');
+   
+end
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/logLikelihoodCR.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/logLikelihoodCR.m
new file mode 100644
index 0000000000000000000000000000000000000000..be518b3efbe1643d9783b2a9e3175590b8e883df
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/logLikelihoodCR.m
@@ -0,0 +1,115 @@
+function [logL, dlogLdtheta, FIM] = logLikelihoodCR(theta, t, Y, sigma2, scale)
+% Objective function for examples/conversion_reaction
+%
+% logLikelihood.m provides the log-likelihood, its gradient and an 
+% approximation of the Hessian matrix based on Fisher information matrix
+% (FIM) for the conversion reaction process.
+% 
+% Parameters:
+%  theta: Model parameters [theta_1, theta_2]'
+%  t: vector of time points
+%  Y: measurement vector
+%  sigma2: variance of the measurements (noise)
+%  scale: 'lin' or 'log'
+%
+% Return values:
+%  logL: double, value of log-likelihood
+%  dlogLdtheta: double vector, gradient of log-likelihood
+%  FIM: double array, negative Fisher information matrix, 
+%   an approximation of Hessian of log-likelihood
+
+
+
+%% Model Definition
+% Definition of the biological process:
+% Interconversion of two species (X_1 and X_2) following first-order mass 
+% action kinetics with the parameters theta_1 and theta_2 respectively
+%
+% Reaction:
+% X_1 -> X_2, rate = theta_1 * [X_1]
+% X_2 -> X_1, rate = theta_2 * [X_2]
+%
+% State of the system:
+% x   = [x_1, x_2] with
+% x_1 = [X_1]
+% x_2 = [X_2]
+%
+% Augmented state:
+% (In order to get gradient information, the state of the system is
+% augmented by forward sensitivities. Here, s_{theta_i}^j defines the 
+% sensitivity of x_j = [X_j] with respect to parameter theta_i)
+% X = [x_1; x_2; s_{theta_1}^1; s_{theta_1}^2; s_{theta_2}^1; s_{theta_2}^2]
+%
+% Measurement:
+% Y = x_2
+%
+% Observables of the system:
+% y(t) = h(theta, x(t))
+%
+% Measurement noise:
+% We assume additive normally distributed noise with mean 0 and standard
+% deviation 0.015 ( = sqrt(sigma2))
+%
+% Right hand side of the ODE of the system:
+% f = @(t,x,theta) [- theta(1) * x(1) + theta(2) * x(2);...
+%                   + theta(1) * x(1) - theta(2) * x(2)];
+
+% Number of states, parameters, observables
+n_x = 2;
+n_theta = 2;
+n_y = 1;
+
+% Initial values
+x0 = @(theta) [1; 0; 0; 0; 0; 0];
+
+% Right hand side of the ODE (augmented system)
+f = @(t,x,theta) [- theta(1) * x(1) + theta(2) * x(2);...
+                  + theta(1) * x(1) - theta(2) * x(2);...
+                  - theta(1) * x(3) + theta(2) * x(4) - x(1);...
+                  + theta(1) * x(3) - theta(2) * x(4) + x(1);...
+                  - theta(1) * x(5) + theta(2) * x(6) + x(2);...
+                  + theta(1) * x(5) - theta(2) * x(6) - x(2)];
+
+% Measurement function              
+h = @(x,theta) x(:,2);
+dhdx = @(x,theta) [0, 1];
+
+%% Simulation and ODE Integration
+% Initialization of observable sensitivities
+
+dydtheta = zeros(length(t), n_theta * n_y);
+switch scale
+    case 'lin'
+        odeOptions = odeset('RelTol', 1e-5, 'AbsTol', 1e-8);
+        [~,X] = ode15s(@(t,x) f(t,x,theta), t, x0(theta), odeOptions);
+        y = h(X(:,1:n_x), theta);
+        for i = 1:n_theta
+            dxdxi_i = X(:, i*n_x+(1:n_x));
+            dydtheta(1:length(t), (i-1)*n_y+(1:n_y)) = dxdxi_i*dhdx(X, theta)';
+        end
+    case 'log'
+        odeOptions = odeset('RelTol', 1e-5, 'AbsTol', 1e-8);
+        [~,X] = ode15s(@(t,x) f(t, x, exp(theta)), t, x0(exp(theta)), odeOptions);
+        y = h(X(:,1:n_x), exp(theta));
+        for i = 1:n_theta
+            dxdxi_i = X(:, i*n_x+(1:n_x))*exp(theta(i));
+            dydtheta(1:length(t), (i-1)*n_y+(1:n_y)) = dxdxi_i*dhdx(X, exp(theta))';
+        end
+    otherwise
+        error('Scale argument must be either "lin" or "log".')
+end
+
+%% Objective Function Evaluation
+% Initialization of output values
+logL = 0;
+dlogLdtheta = zeros(n_theta, 1);
+FIM = zeros(n_theta, n_theta);
+
+% Assignment
+for i = 1:n_y
+    logL = logL - 0.5*sum(log(2*pi*sigma2) + (Y(:,i)-y(:,i)).^2/sigma2);
+    dlogLdtheta = dlogLdtheta + dydtheta(:,i+(0:n_y:n_theta*n_y-i))' * ((Y(:,i)-y(:,i))/sigma2);
+    FIM = FIM - dydtheta(:,i+(0:n_y:n_theta*n_y-i))' * dydtheta(:,i+(0:n_y:n_theta*n_y-i))/sigma2;
+end
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/mainConversionReaction.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/mainConversionReaction.m
new file mode 100644
index 0000000000000000000000000000000000000000..b12a819b09f224b6ac6f279f21526a7aad01d29a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/mainConversionReaction.m
@@ -0,0 +1,310 @@
+% Main file of the conversion reaction example
+%
+% Demonstrates the use of:
+% * getMultiStarts()
+% * getParameterProfiles()
+% * getParameterSamples()
+% * getParameterConfidenceIntervals()
+% * getPropertyMultiStarts()
+% * getPropertyProfiles()
+% * getPropertySamples()
+% * getPropertyConfidenceIntervals()
+%
+% Demonstrates furthermore:
+% * how to use the MEIGO and the PSwarm toolbox for optimization (commented code version)
+%
+% This example provides a model for the interconversion of two species 
+% (X_1 and X_2) following first-order mass action kinetics with the 
+% parameters theta_1 and theta_2 respectively:
+%
+% * X_1 -> X_2, rate = theta_1 * [X_1]
+% * X_2 -> X_1, rate = theta_2 * [X_2]
+%
+% Measurement of [X_2] are provided as: Y = [X_2]
+%
+% This file provides time-series measurement data Y and 
+% performs a multistart maximum likelihood parameter estimation based on
+% these measurements, demonstrating the use of getMultiStarts(). The model 
+% fit is then visualized.
+% 
+% Profile likelihood calculation is done using getParameterProfiles() 
+% applying a classical optimization algorithm and plotted.
+%
+% Single-chain Monte-Carlo sampling is performed by getParameterSamples() 
+% and plotted in 1D and 2D.
+
+
+
+%% Preliminary
+clear all;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed the random number generator. Seeding the random number generator
+% ensures that everytime this example is run, the same sequence of random
+% numbers is generated, and thus, the same starting points for multi-start 
+% optimization will be used. This is helpful for debugging or comparing
+% results across different machines. 
+% Results might vary though if PestoOptions.comp_type is set to 'parallel'
+rng(0);
+
+%% Model Definition
+% See logLikelihoodCR.m for a detailed description
+
+%% Data
+% We fix an artificial data set. It consists of a vector of time points t
+% and a measurement vector y. This data was created using the parameter 
+% values which are assigned to theta_true and by adding normally distributed 
+% measurement noise with variance sigma2. 
+
+% True parameters
+theta_true = [-2.5;-2];
+
+% Time points, measurement noise and measurement data
+t = (0:10)';
+sigma2 = 0.015^2;
+y = [0.0244; 0.0842; 0.1208; 0.1724; 0.2315; 0.2634; ... 
+    0.2831; 0.3084; 0.3079; 0.3097; 0.3324];
+
+
+%% Definition of the Parameter Estimation Problem
+% In order to run any PESTO routine, at least the parameters struct with 
+% the fields shown here and the objective function need to be defined, 
+% since they are mandatory for getMultiStarts, which is usually the first 
+% routine needed for any parameter estimation problem
+
+% parameters
+parameters.name = {'log_{10}(k_1)','log_{10}(k_2)'};
+parameters.min = [-7,-7];
+parameters.max = [ 3, 3];
+parameters.number = length(parameters.name);
+
+% Log-likelihood function
+objectiveFunction = @(theta) logLikelihoodCR(theta, t, y, sigma2, 'log');
+
+% properties (parameter function to be analyzed)
+properties.name = {'log_{10}(k_1)','log_{10}(k_2)',...
+                   'log_{10}(k_1)-log_{10}(k_2)','log_{10}(k_1)^2',...
+                   'x_2(t=3)','x_2(t=10)'};
+properties.function = {@propertyFunction_theta1,...
+                       @propertyFunction_theta2,...
+                       @propertyFunction_theta1_minus_theta2,...
+                       @propertyFunction_theta1_square,...
+                       @(theta) propertyFunction_x2(theta,3,'log'),...
+                       @(theta) propertyFunction_x2(theta,10,'log')};
+properties.min = [-2.6;-2.2;-5;-10; 0; 0];
+properties.max = [-2.4;-1.7; 5; 10; 1; 1];
+properties.number = length(properties.name);
+
+
+%% Multi-start local optimization
+% A multi-start local optimization is performed within the bounds defined in
+% parameters.min and .max in order to infer the unknown parameters from 
+% measurement data. Therefore, a PestoOptions object is created and
+% some of its properties are set accordingly.
+
+% Options
+optionsPesto = PestoOptions();
+optionsPesto.obj_type = 'log-posterior';
+optionsPesto.n_starts = 20;
+optionsPesto.comp_type = 'sequential';
+optionsPesto.mode = 'visual';
+optionsPesto.plot_options.add_points.par = theta_true;
+optionsPesto.plot_options.add_points.logPost = objectiveFunction(theta_true);
+optionsPesto.plot_options.add_points.prop = nan(properties.number,1);
+for j = 1 : properties.number
+    optionsPesto.plot_options.add_points.prop(j) = properties.function{j}(optionsPesto.plot_options.add_points.par);
+end
+
+% % The example can also be run in parallel mode: Uncomment this, if wanted
+% optionsMultistart.comp_type = 'parallel'; 
+% optionsMultistart.mode = 'text';
+% optionsMultistart.save = true; 
+% optionsMultistart.foldername = 'results';
+% n_workers = 4;
+
+% Open parpool
+if strcmp(optionsPesto.comp_type, 'parallel') && (n_workers >= 2)
+    parpool(n_workers); 
+else
+    optionsPesto.comp_type = 'sequential';
+end
+
+% Optimization
+parameters = getMultiStarts(parameters, objectiveFunction, optionsPesto);
+
+
+%% Choosing different optimizers
+
+% Besides the default fmincon local optimizer, alternative optimizers can be chosen. 
+% Currently, PESTO provides an interface to MEIGO and PSwarm, which have to be installed separately.
+% These algorithms aim at finding the global optimum, and therefore, a
+% low number or a single optimizer run should be enough.
+
+% MEIGO
+% ----------------
+
+% The following uses the MEIGO toolbox with default settings:
+% (Install MEIGO from http://gingproc.iim.csic.es/meigom.html and
+% uncomment:
+
+% MeigoOptions = struct(...
+%     'maxeval', 1e4, ...
+%     'local', struct('solver', 'fmincon', ...
+%     'finish', 'fmincon', ...
+%     'iterprint', 1) ...
+%     );
+% 
+% optionsMultistartMeigo = optionsPesto;
+% optionsMultistartMeigo.localOptimizer = 'meigo-ess';
+% optionsMultistartMeigo.localOptimizerOptions = MeigoOptions;
+% optionsMultistartMeigo.n_starts = 2;
+% parameters = getMultiStarts(parameters, objectiveFunction, optionsMultistartMeigo);
+
+% PSWARM
+% ----------------
+
+% % This section uses PSwarm, a particle swarm optimizer
+% % (Install from http://www.norg.uminho.pt/aivaz/pswarm/ and uncomment)
+% 
+% optionsMultistartPSwarm = optionsPesto;
+% optionsMultistartPSwarm.localOptimizer = 'pswarm';
+% optionsMultistartPSwarm.n_starts = 10;
+% parameters = getMultiStarts(parameters, objectiveFunction, optionsMultistartPSwarm);
+
+% DHC
+% ----------------
+
+% Now we also have a look at the derivative-free optimizer provided in
+% dynamicHillClimb.m. Since the optimizer has no information about
+% gradients, it is recommended to choose rather small tolerances and a
+% higher number of function evaluations. Every such function evaluation
+% will be less expensive because no derivatives are computed.
+% 
+% optionsPesto.localOptimizer = 'dhc';
+% optionsPesto.localOptimizerOptions.TolX   = 1e-10;
+% optionsPesto.localOptimizerOptions.TolFun = 1e-10;
+% optionsPesto.localOptimizerOptions.MaxFunEvals = 1000;
+% optionsPesto.localOptimizerOptions.Display = 'iter';
+% parameters = getMultiStarts(parameters, objectiveFunction, optionsPesto);
+
+%% Visualization of fit
+% The measured data is visualized in plot, together with fit for the best
+% parameter value found during getMultiStarts
+
+if strcmp(optionsPesto.mode,'visual')
+    % Simulation
+    tsim = linspace(t(1),t(end),100);
+    ysim = simulateConversionReaction(exp(parameters.MS.par(:,1)),tsim);
+
+    % Plot: Fit
+    figure('Name','Conversion reaction: Visualization of fit');
+    plot(t,y,'bo'); hold on;
+    plot(tsim,ysim,'r-'); 
+    xlabel('time t');
+    ylabel('output y');
+    legend('data','fit');
+end
+
+
+%% Profile likelihood calculation -- Parameters
+% The uncertainty of the estimated parameters is visualized by computing
+% and plotting profile likelihoods. In getParameterProfiles, this is done
+% by using repeated reoptimization, if standard setings are used.
+parameters = getParameterProfiles(parameters, objectiveFunction, optionsPesto);
+
+
+%% Markov Chain Monte Carlo sampling -- Parameters
+% Values for the parameters are sampled by using an Parallel Tempering (PT)
+% algorithm. This way, the underlying probability density of the parameter 
+% distribution can be captured. Since only one temperature is used, this is
+% effectively an adapted Metropolis algorithm single-chain algorithm.
+
+% Building a struct covering all sampling options:
+optionsPesto.MCMC.nIterations = 1e4;
+optionsPesto.MCMC.mode = optionsPesto.mode;
+
+% PT specific options:
+optionsPesto.MCMC.samplingAlgorithm   = 'PT';
+optionsPesto.MCMC.PT.nTemps           = 1;
+
+% Initialize the chains by making use of the preceeding multi-start local
+% optimization, all of them starting from the same point
+optionsPesto.MCMC.theta0 = parameters.MS.par(:,1); 
+optionsPesto.MCMC.sigma0 = 0.5 * inv(squeeze(parameters.MS.hessian(:,:,1)));
+
+% Run the sampling
+parameters = getParameterSamples(parameters, objectiveFunction, optionsPesto);
+
+
+%% Confidence interval evaluation -- Parameters
+% Confidence intervals to the confidence levels fixed in the array
+% alpha
+% are computed based on local approximations from the Hessian matrix at the
+% optimum, based on the profile likelihoods and on the parameter sampling.
+
+alpha = [0.9,0.95,0.99];
+parameters = getParameterConfidenceIntervals(parameters, alpha, optionsPesto);
+
+
+%% Evaluation of properties for multi-start local optimization results -- Properties
+% The values of the properties are evaluated at the end points of the
+% multi-start optimization runs by getPropertyMultiStarts.
+
+optionsProperties = optionsPesto;
+optionsProperties.fh = [];
+properties = getPropertyMultiStarts(properties,parameters,optionsProperties);
+
+
+%% Profile likelihood calculation -- Properties
+% Profile likelihoods are computed for the properties in the same fashion,
+% as they were computed for the parameters.
+
+properties = getPropertyProfiles(properties, parameters, objectiveFunction, optionsProperties);
+
+
+%% Evaluation of properties for sampling results -- Properties
+% From the samples of the parameters, the properties are calculated and
+% hence a probability distribution for the properties can be reconstructed
+% from that.
+
+properties = getPropertySamples(properties, parameters, optionsProperties);
+
+
+%% Confidence interval evaluation -- Properties
+% As for the parameters, confidence intervals are computed for the
+% properties in different fashion, based on local approximations, profile
+% likelihoods and samples.
+
+properties = getPropertyConfidenceIntervals(properties, alpha, optionsProperties);
+
+
+%% Comparison of calculated parameter profiles
+
+if strcmp(optionsPesto.mode, 'visual')
+    % Open figure
+    figure('Name','Conversion reaction: Comparison of parameter profiles');
+    
+    % Loop: parameters
+    for i = 1:min(parameters.number, properties.number)
+        subplot(ceil(parameters.number/ceil(sqrt(parameters.number))),ceil(sqrt(parameters.number)),i);
+        plot(parameters.P(i).par(i,:),parameters.P(i).R,'bx-'); hold on;
+        plot(properties.P(i).prop,properties.P(i).R,'r-o');
+        xlabel(properties.name{i});
+        ylabel('likelihood ratio');
+        if i == 1
+            legend({'unconst. opt. (= standard)','unconst. op. (= new)'},'color','none');
+        end
+    end
+end
+
+
+%% Close the pools of parallel working threads
+
+if strcmp(optionsPesto.comp_type, 'parallel') && (n_workers >= 2)
+    delete(gcp('nocreate'))
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1.m
new file mode 100644
index 0000000000000000000000000000000000000000..d937f08e5a710d4e07ddbc34c17e552c4a6ef5f4
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1.m
@@ -0,0 +1,22 @@
+function [f, grad_f, hess_f] = propertyFunction_theta1(theta)
+% propertyFunction_theta1 for examples/conversion_reaction
+%
+% returns the the first reaction rate as defined in logLikelihood.m with 
+% derivatives
+%
+% Parameters: 
+%  theta: Model parameters [theta_1, theta_2]'
+%
+% Return values:
+%  f: double, value of property function
+%  grad_f: double vector, gradient of property function
+%  hess_f: double array, hessian of property function
+
+
+
+%% Property Function Evaluation
+f = theta(1);
+grad_f = [1; 0];
+hess_f = [0, 0; 0, 0];
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1_minus_theta2.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1_minus_theta2.m
new file mode 100644
index 0000000000000000000000000000000000000000..7a15e4ee02d9e41533b36b03547ecdc36e177957
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1_minus_theta2.m
@@ -0,0 +1,22 @@
+function [f, grad_f, hess_f] = propertyFunction_theta1_minus_theta2(theta)
+% propertyFunction_theta1_minus_theta2 for examples/conversion_reaction
+%
+% returns the difference of the reaction rates as defined in 
+% logLikelihood.m with derivatives
+%
+% Parameters: 
+%  theta: Model parameters [theta_1, theta_2]'
+%
+% Return values:
+%  f: double, value of property function
+%  grad_f: double vector, gradient of property function
+%  hess_f: double array, hessian of property function
+
+
+
+%% Property Function Evaluation
+f = theta(1) - theta(2);
+grad_f = [1; -1];
+hess_f = [0, 0; 0, 0];
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1_square.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1_square.m
new file mode 100644
index 0000000000000000000000000000000000000000..1b64f1ccfa64bccc25983ef3d3e8ea9ded891541
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta1_square.m
@@ -0,0 +1,22 @@
+function [f, grad_f, hess_f] = propertyFunction_theta1_square(theta)
+% propertyFunction_theta1_square for examples/conversion_reaction
+%
+% returns the square of the first reaction rate as defined in 
+% logLikelihood.m with derivatives
+%
+% Parameters: 
+%  theta: Model parameters [theta_1, theta_2]'
+%
+% Return values:
+%  f: double, value of property function
+%  grad_f: double vector, gradient of property function
+%  hess_f: double array, hessian of property function
+
+
+
+%% Property Function Evaluation
+f = theta(1)^2;
+grad_f = [2*theta(1); 0];
+hess_f = [2, 0; 0, 0];
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta2.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta2.m
new file mode 100644
index 0000000000000000000000000000000000000000..f36c918ba53757d070b4e1fc29e71dd9fa1aebd8
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_theta2.m
@@ -0,0 +1,22 @@
+function [f, grad_f, hess_f] = propertyFunction_theta2(theta)
+% propertyFunction_theta2 for examples/conversion_reaction
+%
+% returns the the second reaction rate as defined in logLikelihood.m with 
+% derivatives
+%
+% Parameters: 
+%  theta: Model parameters [theta_1, theta_2]'
+%
+% Return values:
+%  f: double, value of property function
+%  grad_f: double vector, gradient of property function
+%  hess_f: double array, hessian of property function
+
+
+
+%% Property Function Evaluation
+f = theta(2);
+grad_f = [0; 1];
+hess_f = [0, 0; 0, 0];
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_x2.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_x2.m
new file mode 100644
index 0000000000000000000000000000000000000000..dfee81fed0f80d6106a05a88fe7f1f281134fe16
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/propertyFunction_x2.m
@@ -0,0 +1,47 @@
+function [f, grad_f] = propertyFunction_x2(theta, T, scale)
+% propertyFunction_x2 for examples/conversion_reaction
+%
+% returns the value of x_2 at time T as defined in logLikelihood.m with 
+% derivatives
+%
+% Parameters: 
+%  theta: Model parameters [theta_1, theta_2]'
+%  T: stopping time for simulation
+%  scale: 'lin' or 'log'
+%
+% Return values:
+%  f: double, value of property function
+%  grad_f: double vector, gradient of property function
+
+
+
+%% Model Definition
+% For more details, see logLikelihood.m
+
+% Initial values
+x0 = @(theta) [1; 0; 0; 0; 0; 0];
+
+% Right hand side of the ODE
+f = @(t,x,theta) [- theta(1) * x(1) + theta(2) * x(2);...
+                  + theta(1) * x(1) - theta(2) * x(2);...
+                  - theta(1) * x(3) + theta(2) * x(4) - x(1);...
+                  + theta(1) * x(3) - theta(2) * x(4) + x(1);...
+                  - theta(1) * x(5) + theta(2) * x(6) + x(2);...
+                  + theta(1) * x(5) - theta(2) * x(6) - x(2)];
+
+%% Simulation and ODE Integration
+switch scale
+    case 'lin'
+        [~,X] = ode15s(@(t,x) f(t,x,theta),[0,T],x0(theta));
+    case 'log'
+        [~,X] = ode15s(@(t,x) f(t,x,exp(theta)),[0,T],x0(exp(theta)));
+        X(:,3:4) = exp(theta(1))*X(:,3:4);
+        X(:,5:6) = exp(theta(2))*X(:,5:6);
+end
+
+%% Property Function Evaluation
+% Assignment
+f = X(end,2);
+grad_f = [X(end,4); X(end,6)];
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/conversion_reaction/simulateConversionReaction.m b/Requirements/PESTO-1.1.0/examples/conversion_reaction/simulateConversionReaction.m
new file mode 100644
index 0000000000000000000000000000000000000000..735b24f944705ce74f286735dfe9dd3063897f0e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/conversion_reaction/simulateConversionReaction.m
@@ -0,0 +1,31 @@
+function [y] = simulateConversionReaction(theta, t)
+% simulateConversionReaction for examples/conversion_reaction
+%
+% simulateConversionReaction performs a simulation of the conversion 
+% reaction model for the given timepoints t and parameters theta
+%
+% Parameters:
+%  theta: Model parameters [theta_1, theta_2]'
+%  t: vector of time points
+%
+% Return values:
+%  y: double vector, values of the observable Y = [x_2] at time points t
+
+
+
+%% Model Definition
+% Initial values
+x0 = @(theta) [1;0];
+
+% Right hand side of the ODE
+f = @(t,x,theta) [- theta(1) * x(1) + theta(2) * x(2);...
+                  + theta(1) * x(1) - theta(2) * x(2)];
+
+% Measurement function 
+h = @(x,theta) x(:,2);
+
+%% Simulation and Assignment
+[~,X] = ode15s(@(t,x) f(t,x,theta),t,x0(theta));
+y = h(X, theta);
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/getInitialConcentrations.m b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/getInitialConcentrations.m
new file mode 100644
index 0000000000000000000000000000000000000000..cf727e553bb109fc6f2e53f58e26485aabe04278
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/getInitialConcentrations.m
@@ -0,0 +1,6 @@
+function con0 = getInitialConcentrations()
+
+    con0 = nan(4, 1);
+    con0(:, 1) = [  1.3084374;   2.5016300;   0.3232196;   1.5389289];
+
+ end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/getMeasuredData.m b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/getMeasuredData.m
new file mode 100644
index 0000000000000000000000000000000000000000..20216915dc872788fdea4deaec92458772c83643
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/getMeasuredData.m
@@ -0,0 +1,55 @@
+function yMeasure = getMeasuredData()
+
+yMeasure = nan(1, 50 , 2);
+yMeasure(1, 1, :) = [1.3244      1.5386];
+yMeasure(1, 2, :) = [0.58495      1.6576];
+yMeasure(1, 3, :) = [0.34931      1.6084];
+yMeasure(1, 4, :) = [0.2424      1.7396];
+yMeasure(1, 5, :) = [0.32102      1.7862];
+yMeasure(1, 6, :) = [0.23102       1.929];
+yMeasure(1, 7, :) = [-0.0050333       1.892];
+yMeasure(1, 8, :) = [0.19572      2.0183];
+yMeasure(1, 9, :) = [0.068784       2.111];
+yMeasure(1, 10, :) = [0.022116      2.2016];
+yMeasure(1, 11, :) = [0.056302      2.2833];
+yMeasure(1, 12, :) = [0.0071388      2.2664];
+yMeasure(1, 13, :) = [0.0089219      2.2403];
+yMeasure(1, 14, :) = [0.087921      2.3273];
+yMeasure(1, 15, :) = [0.082555      2.3578];
+yMeasure(1, 16, :) = [0.081864      2.5721];
+yMeasure(1, 17, :) = [0.043644      2.4648];
+yMeasure(1, 18, :) = [-0.051116      2.5714];
+yMeasure(1, 19, :) = [0.044404      2.5605];
+yMeasure(1, 20, :) = [0.089414      2.6484];
+yMeasure(1, 21, :) = [0.031771      2.5976];
+yMeasure(1, 22, :) = [0.058539      2.5955];
+yMeasure(1, 23, :) = [0.042675      2.6225];
+yMeasure(1, 24, :) = [-0.0092716      2.7443];
+yMeasure(1, 25, :) = [0.020202      2.7356];
+yMeasure(1, 26, :) = [-0.034216      2.7577];
+yMeasure(1, 27, :) = [0.049238      2.8602];
+yMeasure(1, 28, :) = [-0.052839      2.8241];
+yMeasure(1, 29, :) = [-0.049209      2.8384];
+yMeasure(1, 30, :) = [-0.036498      2.9258];
+yMeasure(1, 31, :) = [-0.14347      2.8229];
+yMeasure(1, 32, :) = [0.075439      2.9137];
+yMeasure(1, 33, :) = [0.019577      2.9354];
+yMeasure(1, 34, :) = [-0.034617      2.8952];
+yMeasure(1, 35, :) = [0.071471      2.9312];
+yMeasure(1, 36, :) = [-0.08278      2.8742];
+yMeasure(1, 37, :) = [-0.0024658      2.8865];
+yMeasure(1, 38, :) = [-0.009565      2.9598];
+yMeasure(1, 39, :) = [0.018339      3.0007];
+yMeasure(1, 40, :) = [0.017902      3.1033];
+yMeasure(1, 41, :) = [-0.041097      2.9494];
+yMeasure(1, 42, :) = [0.00054081      3.0004];
+yMeasure(1, 43, :) = [-0.0062971      2.9947];
+yMeasure(1, 44, :) = [0.033242      2.9094];
+yMeasure(1, 45, :) = [0.056436      2.9909];
+yMeasure(1, 46, :) = [0.057158      2.9295];
+yMeasure(1, 47, :) = [-0.041561      3.0672];
+yMeasure(1, 48, :) = [0.0054217      2.9864];
+yMeasure(1, 49, :) = [-0.059216      3.0411];
+yMeasure(1, 50, :) = [-0.054244      3.0138];
+
+ end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/logLikelihoodEC.m b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/logLikelihoodEC.m
new file mode 100644
index 0000000000000000000000000000000000000000..4f6ff74803fd73e7ad928ba09b9f61528d1a7eec
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/logLikelihoodEC.m
@@ -0,0 +1,154 @@
+function varargout = logLikelihoodEC(theta, yMeasured, sigma2, con0, nTimepoints, nMeasure)
+% Objective function for examples/enzymatic_catalysis
+%
+% logLikelihood.m provides the log-likelihood, its gradient and an 
+% approximation of the Hessian matrix based on Fisher information matrix
+% (FIM) for the enzymatic catalysis example.
+% 
+% Parameters:
+%  theta: Model parameters [theta_1, theta_2, theta_3, theta_4]'
+%  yMeasured: measurement array returned from getMeasuredData()
+%  sigma2: variance of the measurements (noise)
+%  con0: inititial concentrations of the experiments returnd 
+%    from getInitialConcentrations()
+%  nTimepoints: number of Time points (equidistad between 0 and 5)
+%  nMeasure: number of experiments
+%
+% Return values:
+%  J: double, value of log-likelihood
+%  gradJ: double vector, gradient of log-likelihood
+%  FIM: double array, negative Fisher information matrix, 
+%    an approximation of Hessian of log-likelihood
+
+
+
+%% Model Definition
+% Definition of the biological process:
+% A species X_1 is bound to an enzyme X_2. They form a complex X_3 which 
+% falls apart to the product X_4 and the enzyme X_2 again. The reaction 
+% follows first-order mass action kinetics with the parameters theta_1 to
+% theta_4
+%
+% Reaction:
+% * X_1 + X_2 -> X_3, rate = theta_1 * [X_1] * [X_2]
+% * X_3 -> X_1 + X_2, rate = theta_2 * [X_3]
+% * X_3 -> X_4 + X_2, rate = theta_3 * [X_3]
+% * X_4 + X_2 -> X_3, rate = theta_4 * [X_4] * [X_2]
+%
+% State of the system:
+% x = [x_1; x_2; x_3; x_4]
+% x_1 = [X_1]
+% x_2 = [X_2]
+% x_3 = [X_3]
+% x_4 = [X_4]
+%
+% Augmented state:
+% (In order to get gradient information, the state of the system is
+% augmented by forward sensitivities. Here, s_{theta_i}^j defines the 
+% sensitivity of x_j = [X_j] with respect to parameter theta_i)
+% X = [x_1; x_2; s_{theta_1}^1; s_{theta_1}^2; ...; s_{theta_2}^1; s_{theta_2}^2; ...]
+%
+% Measurements:
+% Y = [x_1; x_4]
+%
+% Observables of the system:
+% y(t) = h(theta, x(t))
+%
+% Measurement noise:
+% We assume additive normally ditributed noise with mean 0 and standard
+% deviation sqrt(sigma2)
+%
+% Right hand side of the original ODE of the system:
+% f = @(theta, x) [...
+%     - theta(1)*x(1)*x(2) + theta(2)*x(3);...
+%     - theta(1)*x(1)*x(2) + (theta(2)+theta(3))*x(3) - theta(4)*x(2)*x(4);...
+%       theta(1)*x(1)*x(2) - (theta(2)+theta(3))*x(3) + theta(4)*x(2)*x(4);...
+%       theta(3)*x(3) - theta(4)*x(2)*x(4)]
+
+% Number of states, parameters, obeservables
+nStates = 4;
+nParams = 4;
+nObserv = 2;
+
+% Creation of the time vector and initialization for return values
+t     = linspace(0, 5, nTimepoints)';
+Y     = nan(nTimepoints, nObserv);
+J     = 0;
+gradJ = zeros(nParams, 1);
+FIM   = zeros(nParams, nParams);
+
+if (nargout > 1)
+% Right hand side of the ODE (augmented system)
+f = @(theta, x) [...
+    - theta(1)*x(1)*x(2) + theta(2)*x(3);...
+    - theta(1)*x(1)*x(2) + (theta(2)+theta(3))*x(3) - theta(4)*x(2)*x(4);...
+      theta(1)*x(1)*x(2) - (theta(2)+theta(3))*x(3) + theta(4)*x(2)*x(4);...
+      theta(3)*x(3) - theta(4)*x(2)*x(4);...
+    - x(1)*x(2) - theta(1)*(x(5)*x(2)+x(1)*x(6)) + theta(2)*x(7);...
+    - x(1)*x(2) - theta(1)*(x(5)*x(2)+x(1)*x(6)) + (theta(2)+theta(3))*x(7) - theta(4)*(x(6)*x(4)+x(2)*x(8));...
+      x(1)*x(2) + theta(1)*(x(5)*x(2)+x(1)*x(6)) - (theta(2)+theta(3))*x(7) + theta(4)*(x(6)*x(4)+x(2)*x(8));...
+      theta(3)*x(7) - theta(4)*(x(6)*x(4)+x(2)*x(8));...
+      x(3) - theta(1)*(x(9)*x(2)+x(1)*x(10)) + theta(2)*x(11);...
+      x(3) - theta(1)*(x(9)*x(2)+x(1)*x(10)) + (theta(2)+theta(3))*x(11) - theta(4)*(x(10)*x(4)+x(2)*x(12));...
+    - x(3) + theta(1)*(x(9)*x(2)+x(1)*x(10)) - (theta(2)+theta(3))*x(11) + theta(4)*(x(10)*x(4)+x(2)*x(12));...
+      theta(3)*x(11) - theta(4)*(x(10)*x(4)+x(2)*x(12));...
+    - theta(1)*(x(13)*x(2)+x(1)*x(14)) + theta(2)*x(15);...
+      x(3) - theta(1)*(x(13)*x(2)+x(1)*x(14)) + (theta(2)+theta(3))*x(15) - theta(4)*(x(14)*x(4)+x(2)*x(16));...
+    - x(3) + theta(1)*(x(13)*x(2)+x(1)*x(14)) - (theta(2)+theta(3))*x(15) + theta(4)*(x(14)*x(4)+x(2)*x(16));...
+      x(3) + theta(3)*x(15) - theta(4)*(x(14)*x(4)+x(2)*x(16));...
+    - theta(1)*(x(17)*x(2)+x(1)*x(18)) + theta(2)*x(19);...
+    - x(2)*x(4) - theta(1)*(x(17)*x(2)+x(1)*x(18)) + (theta(2)+theta(3))*x(19) - theta(4)*(x(18)*x(4)+x(2)*x(20));...
+      x(2)*x(4) + theta(1)*(x(17)*x(2)+x(1)*x(18)) - (theta(2)+theta(3))*x(19) + theta(4)*(x(18)*x(4)+x(2)*x(20));...
+    - x(2)*x(4) + theta(3)*x(19) - theta(4)*(x(18)*x(4)+x(2)*x(20))];
+    fillX = zeros(16,1);
+else
+    f = @(theta, x) [...
+        - theta(1)*x(1)*x(2) + theta(2)*x(3);...
+        - theta(1)*x(1)*x(2) + (theta(2)+theta(3))*x(3) - theta(4)*x(2)*x(4);...
+          theta(1)*x(1)*x(2) - (theta(2)+theta(3))*x(3) + theta(4)*x(2)*x(4);...
+          theta(3)*x(3) - theta(4)*x(2)*x(4)];
+    fillX = [];
+end
+
+% Measurement functions
+h = @(x,theta) [x(:,1), x(:,4)];
+dhdx = @(x,theta) [1, 0, 0, 0; 0, 0, 0, 1];
+    
+
+%% Simulation and ODE Integration
+% Initialization of observable sensitivities
+dydtheta = zeros(length(t), nParams * nObserv);
+
+% Loop over the experiments and simulation for each experiment
+for iMeasure = 1 : nMeasure
+    % Simulation
+    odeOptions = odeset('RelTol', 1e-6, 'AbsTol', 1e-10);
+    [~,X] = ode15s(@(t,x) f(exp(theta),x), t, [con0(:,iMeasure); fillX], odeOptions);
+    y = h(X(:,1:nStates), exp(theta));
+    Y(:, :) = yMeasured(iMeasure, :, :);
+    if (nargout > 1)
+        for iTheta = 1 : nParams
+            dxdxi_i = X(:, iTheta * nStates + (1:nStates)) * exp(theta(iTheta));
+            dydtheta(1:length(t), (iTheta-1) * nObserv + (1 : nObserv)) = dxdxi_i * dhdx(X, exp(theta))';
+        end
+    end
+
+    % Computation and assignment of the objective function and its
+    % derivatives
+    for iObserv = 1 : nObserv
+        J = J - 0.5 * sum(log(2*pi*sigma2) + (Y(:,iObserv) - y(:,iObserv)).^2 / sigma2);
+        if (nargout > 1)
+            gradJ = gradJ + dydtheta(:,iObserv + (0 : nObserv : nParams*nObserv - iObserv))' * ((Y(:,iObserv) - y(:,iObserv)) / sigma2);
+            FIM = FIM - dydtheta(:,iObserv + (0 : nObserv : nParams*nObserv - iObserv))' * dydtheta(:,iObserv + (0 : nObserv : nParams*nObserv - iObserv))/sigma2;
+        end
+    end
+end
+
+% Normalization by the number of experiments
+varargout{1} = J / nMeasure;
+if (nargout > 1)
+    varargout{2} = gradJ / nMeasure;
+    varargout{3} = FIM / nMeasure;
+end
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/mainEnzymaticCatalysis.m b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/mainEnzymaticCatalysis.m
new file mode 100644
index 0000000000000000000000000000000000000000..9e0813e3c87ae046176daa566a073b0e7be45e9e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/mainEnzymaticCatalysis.m
@@ -0,0 +1,212 @@
+% Main file of the enzymatic catalysis example
+%
+% Demonstrates the use of:
+% * getParameterSamples()
+% * getMultiStarts()
+% * getParameterProfiles()
+% * getParameterConfidenceIntervals()
+%
+% Demonstrates furthermore:
+% * how to do sampling without multi-start local optimization beforehand
+% * how to use the MEIGO toolbox for optimization (commented)
+% * how to compute profile likelihoods via the integration method
+% * how to use plotting functions outside the get... routines
+% * the reliability of sampling and profiling in the case of
+%   non-identifiabilites
+% * how to use diagnosis tool (e.g. plotMCMCDiagnosis and
+%   plotMultiStartDiagnosis)
+%
+% This example provides a model for the reaction of a species X_1 to a
+% species X_4, which is catalyzed by an enzyme X_2.
+%
+% * X_1 + X_2 -> X_3, rate = theta_1 * [X_1] * [X_2]
+% * X_3 -> X_1 + X_2, rate = theta_2 * [X_3]
+% * X_3 -> X_4 + X_2, rate = theta_3 * [X_3]
+% * X_4 + X_2 -> X_3, rate = theta_4 * [X_4] * [X_2]
+%
+% Measurements of [X_1] and [X_4] are provided as: Y = [[X_1]; [X_4]]
+%
+% This file sets a parameter vector, creates and saves artificial
+% measurement data as a time series and performs a multi-start local
+% optimization based on these measurements, demonstrating the use of
+% getMultiStarts().
+%
+% Parameter sampling is done first without prior information from
+% optimization, then with information from optimization.
+%
+% Parameter optimization is done using multi-start local optimization.
+%
+% The Profile likelihoods are calculated by integrating an ODE following
+% the profile path using getParameterProfiles with the option
+% optionsPesto.profile_method = 'integration'.
+
+
+
+%% Preliminary
+clear;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed random number generator
+rng(0);
+
+%% Model Definition
+% See logLikelihood.m for a detailed description
+
+%% Create Artificial Data for Parameter Estimation
+% The necessary variables are set (Parameter bounds, variance, ...)
+nTimepoints = 50;      % Time points of Measurement
+nMeasure    = 1;        % Number of experiments
+sigma2      = 0.05^2;   % Variance of Measurement noise
+lowerBound  = -10;      % Lower bound for parameters
+upperBound  = 5;        % Upper bound for parameters
+theta       = [1.1770; -2.3714; -0.4827; -5.5387]; % True parameter values
+
+% Creation of data
+% Once the two files getMeasuredData.m and getInitialConcentrations.m are
+% written, the two following lines can be commented
+display(' Write new measurement data...');
+performNewMeasurement(theta, nMeasure, nTimepoints, sigma2);
+
+% The measurement data is read out from the files where it is saved
+yMeasured = getMeasuredData();
+con0 = getInitialConcentrations();
+
+%% Generation of the structs and options for PESTO
+% The structs and the PestoOptions object, which are necessary for the 
+% PESTO routines to work are created and set to convenient values
+
+% parameters
+display(' Prepare structs and options...')
+parameters.name   = {'log(theta_1)', 'log(theta_2)', 'log(theta_3)', 'log(theta_4)'};
+parameters.min    = lowerBound * ones(4, 1);
+parameters.max    = upperBound * ones(4, 1);
+parameters.number = length(parameters.name);
+
+% objective function
+objectiveFunction = @(theta) logLikelihoodEC(theta, yMeasured, sigma2, con0, nTimepoints, nMeasure);
+
+% PestoOptions
+optionsPesto           = PestoOptions();
+optionsPesto.obj_type  = 'log-posterior';
+optionsPesto.comp_type = 'sequential'; 
+optionsPesto.mode      = 'visual';
+optionsPesto.plot_options.add_points.par = theta;
+optionsPesto.plot_options.add_points.logPost = objectiveFunction(theta);
+
+%% Parameter Sampling
+% Covering all sampling options in one struct
+display(' Sampling without prior information...');
+optionsPesto.MCMC.nIterations  = 1e4;
+
+% PT (with only 1 chain -> AM) specific options:
+optionsPesto.MCMC.samplingAlgorithm = 'PT';
+optionsPesto.MCMC.PT.nTemps         = 6;
+optionsPesto.MCMC.PT.exponentT      = 6;    
+optionsPesto.MCMC.PT.regFactor      = 1e-8;
+
+% Initialize the chains by choosing a random initial point and a 'large'
+% covariance matrix
+optionsPesto.MCMC.theta0 = lowerBound * ones(4, 1) + ...
+    (upperBound * ones(4, 1) - lowerBound * ones(4, 1)) .* rand(4,1); 
+optionsPesto.MCMC.sigma0 = 1e5 * eye(4);
+
+% Run the sampling
+parameters = getParameterSamples(parameters, objectiveFunction, optionsPesto);
+
+% Use a diagnosis tool to see, how plotting worked (see burn-in etc.)
+plotMCMCdiagnosis(parameters, 'parameters');
+
+%% Calculate Confidence Intervals
+% Confidence Intervals for the Parameters are inferred from the local 
+% optimization and the sampling information.
+
+% Set alpha levels
+alphaLevels = [0.8, 0.9, 0.95, 0.99];
+
+display(' Computing confidence intervals...');
+parameters = getParameterConfidenceIntervals(parameters, alphaLevels, optionsPesto);
+
+
+%% Perform Multistart optimization
+% A multi-start local optimization is performed within the bound defined in
+% parameters.min and .max in order to infer the unknown parameters from 
+% measurement data.
+
+optionsPesto.n_starts = 10;
+
+% % The following section uses the MEIGO toolbox with following settings:
+% % (Install MEIGO from http://gingproc.iim.csic.es/meigom.html and
+% % uncomment:
+
+% MeigoOptions = struct(...
+%     'maxeval', 1000, ...
+%     'local', struct('solver', 'fmincon', ...
+%     'finish', 'fmincon', ...
+%     'iterprint', 0) ...
+%     );
+% optionsPesto.localOptimizer = 'meigo-ess';
+% optionsPesto.localOptimizerOptions = MeigoOptions;
+% optionsPesto.n_starts = 5;
+
+% Options for an alternative multi-start local optimization
+% (Comment out the Meigo code)
+display(' Optimizing parameters...');
+parameters = getMultiStarts(parameters, objectiveFunction, optionsPesto);
+
+% Use a diagnosis tool to see, how optimization worked (only works with fmincon)
+% plotMultiStartDiagnosis(parameters);
+
+
+%% Calculate Confidence Intervals
+% Confidence Intervals for the Parameters are inferred from the local 
+% optimization and the sampling information.
+display(' Computing confidence intervals...');
+parameters = getParameterConfidenceIntervals(parameters, alphaLevels, optionsPesto);
+
+
+%% Calculate Profile Likelihoods
+% The result of the sampling is compared with profile likelihoods.
+optionsPesto.profile_method = 'integration';
+optionsPesto.solver.gamma = 1;
+optionsPesto.objOutNumber = 2;
+optionsPesto.solver.hessian = 'user-supplied';
+
+display(' Computing parameter profiles...');
+parameters = getParameterProfiles(parameters, objectiveFunction, optionsPesto);
+
+
+%% Do additional plots
+% In order to check how well sampling and profiling agree with each other,
+% we do two additional plots.
+PlottingOptionsSampling = PestoPlottingOptions();
+PlottingOptionsSampling.S.plot_type = 1;
+PlottingOptionsSampling.S.ind = 1;
+
+fh = figure('Name','plotParameterSamples - 1D');
+plotParameterSamples(parameters,'1D',fh,[],PlottingOptionsSampling);
+
+fh = figure('Name','plotParameterSamples - 2D');
+plotParameterSamples(parameters,'2D',fh,[],PlottingOptionsSampling);
+
+%% Perform a second Sampling, now based on Multistart Optimization
+% To compare the effect of previous multi-start optimization, we perform a
+% second sampling.
+optionsPesto.MCMC.theta0 = parameters.MS.par(:,1); 
+optionsPesto.MCMC.sigma0 = 0.5*inv(squeeze(parameters.MS.hessian(:,:,1)));
+
+% Run the sampling
+display(' Sampling with information from optimization...');
+optionsPesto.MCMC.nIterations  = 2e3;
+parametersNew = parameters;
+parametersNew = getParameterSamples(parametersNew, objectiveFunction, optionsPesto);
+
+
+%% Calculate Confidence Intervals
+% Confidence Intervals for the Parameters are inferred from the local 
+% optimization, the sampling and the profile information.
+parameters = getParameterConfidenceIntervals(parametersNew, alphaLevels, optionsPesto);
diff --git a/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/performNewMeasurement.m b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/performNewMeasurement.m
new file mode 100644
index 0000000000000000000000000000000000000000..981321d2ef48ccaae14509d1d46706490dd27887
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/enzymatic_catalysis/performNewMeasurement.m
@@ -0,0 +1,77 @@
+function performNewMeasurement(theta, nMeasure, nTimepoints, sigma2)
+% performNewMeasurement.m for examples/enzymatic_catalysis
+%
+% creates artificial data for the parameter estimation of the enzymatic 
+% catalysis example for a given number of time points and a given number of
+% measurements with different initial conditions of the chemical species.
+% 
+% Parameters:
+%  theta: Model parameters [theta_1, theta_2, theta_3, theta_4]'
+%  nMeasure: number of experiments
+%  nTimepoints: number of Time points (equidistad between 0 and 5)
+%  sigma2: variance of the measurements (noise)
+%
+% Return values:
+%  No return values, but the files getInitialConcentrations.m and
+%   getMeasuredData.m are written to the folder of this example
+    
+
+
+%% Model Definition
+% For more details, see logLikelihood.m
+
+%% Creation of initial concentrations
+% Writing the initial concentrations using a log-normal distribution
+con0 = exp(normrnd(0, 0.5, 4, nMeasure));
+
+% Create file with initial concentrations
+[exdir, ~, ~] = fileparts(which('performNewMeasurement.m'));
+fid = fopen([exdir '/getInitialConcentrations.m'], 'w');
+fprintf(fid, 'function con0 = getInitialConcentrations()\n\n');
+fprintf(fid, ['    con0 = nan(4, ' num2str(nMeasure) ');\n']);
+
+% Write initial concentrations
+for iMeasure = 1 : nMeasure
+    fprintf(fid, ['    con0(:, ' num2str(iMeasure) ') = [']);
+    fprintf(fid, '%11.7f; %11.7f; %11.7f; %11.7f];\n', ...
+        con0(1, iMeasure), con0(2, iMeasure), con0(3, iMeasure), con0(4, iMeasure));
+end
+
+% Close file
+fprintf(fid, '\n end');
+fclose(fid);
+
+%% Creation of measurement data
+% Right hand side of the ODE
+f = @(theta, x) [...
+    - theta(1)*x(1)*x(2) + theta(2)*x(3);...
+    - theta(1)*x(1)*x(2) + (theta(2)+theta(3))*x(3) - theta(4)*x(2)*x(4);...
+      theta(1)*x(1)*x(2) - (theta(2)+theta(3))*x(3) + theta(4)*x(2)*x(4);...
+      theta(3)*x(3) - theta(4)*x(2)*x(4)];
+
+% Creation of the time vector and the observable function
+t = linspace(0, 5, nTimepoints);
+h = @(x,theta) [x(:,1), x(:,4)];
+
+% Create file with measurement data
+fid = fopen([exdir '/getMeasuredData.m'], 'w');
+fprintf(fid, 'function yMeasure = getMeasuredData()\n\n');
+fprintf(fid, ['yMeasure = nan(' num2str(nMeasure) ', ' num2str(nTimepoints) ' , 2);\n']);
+
+% Write the measurement data
+for iMeasure = 1 : nMeasure                
+    [~,X] = ode15s(@(t,x) f(exp(theta),x), t, con0(:,iMeasure));
+    y = h(X(:,1:4), exp(theta));
+    y = y + normrnd(0, sqrt(sigma2), nTimepoints, 2);
+    for iTime = 1 : nTimepoints
+        fprintf(fid, ['yMeasure(' num2str(iMeasure) ', ' num2str(iTime) ', :) = [']);
+        fprintf(fid, num2str(y(iTime, :)));
+        fprintf(fid, '];\n');
+    end
+end
+
+% Close file
+fprintf(fid, '\n end');
+fclose(fid);
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/erbb_signaling/erbb_signaling_pesto_syms.m b/Requirements/PESTO-1.1.0/examples/erbb_signaling/erbb_signaling_pesto_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..ed0efd7ee84cdaa74283196dc9c8afff8b7265df
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/erbb_signaling/erbb_signaling_pesto_syms.m
@@ -0,0 +1,1067 @@
+function model = erbb_signaling_pesto_syms()
+% erbb_signaling_pesto_syms for examples/erbb_signaling
+%
+% creates an amimodel-object for the AMICI solver
+%
+% Parameters: 
+% 
+% Return values:
+%  model: amimodel object
+
+
+
+%% STATES
+syms c2 c3 c288 c335 c117 c336 c286 c499 c500 c501 c4 c10 c11 c141 c145 c140 c146 c143 c147 c155 c159 c154 c160 c156 c161 c492 c493 c494 c502 c504 c503 c505 c506 c507 c105 c123 c124 c125 c126 c116 c122 c127 c128 c284 c129 c427 c130 c428 c131 c429 c132 c436 c133 c439 c134 c442 c135 c483 c136 c516 c137 c517 c138 c345 c139 c355 c168 c421 c169 c422 c170 c23 c12 c7 c25 c88 c27 c89 c29 c90 c34 c91 c35 c92 c36 c93 c37 c94 c189 c195 c190 c196 c191 c197 c198 c204 c199 c205 c200 c206 c207 c213 c208 c214 c209 c215 c216 c222 c217 c223 c218 c224 c225 c231 c226 c232 c227 c233 c243 c249 c244 c250 c245 c251 c252 c258 c253 c259 c254 c260 c234 c240 c235 c241 c236 c242 c300 c301 c303 c304 c306 c307 c309 c310 c312 c313 c315 c316 c318 c319 c321 c322 c357 c358 c360 c361 c366 c367 c369 c370 c372 c373 c375 c376 c378 c379 c381 c382 c363 c364 c384 c385 c387 c388 c390 c391 c393 c394 c396 c397 c399 c400 c402 c403 c9 c404 c401 c398 c395 c392 c389 c386 c365 c383 c380 c377 c374 c371 c368 c362 c359 c323 c320 c317 c314 c311 c308 c305 c302 c239 c238 c237 c257 c256 c255 c248 c247 c246 c230 c229 c228 c221 c220 c219 c212 c211 c210 c203 c202 c201 c194 c193 c192 c68 c67 c66 c65 c21 c20 c18 c19 c6 c5 c8 c15 c17 c32 c63 c33 c64 c347 c349 c348 c350 c351 c353 c508 c512 c354 c356 c148 c162 c149 c163 c150 c164 c289 c290 c337 c338 c291 c293 c294 c296 c297 c299 c14 c165 c166 c167 c151 c152 c153 c341 c344 c343 c346 c16 c157 c22 c40 c39 c180 c181 c182 c183 c184 c185 c24 c26 c28 c69 c43 c71 c31 c171 c172 c173 c174 c175 c176 c41 c42 c70 c72 c45 c38 c30 c44 c73 c46 c75 c76 c47 c74 c48 c49 c50 c51 c77 c53 c78 c52 c54 c79 c55 c56 c57 c58 c80 c81 c82 c59 c83 c60 c61 c84 c62 c85 c86 c425 c13 c518 c519 c339 c340 c95 c96 c97 c98 c101 c102 c99 c419 c103 c100 c420 c287 c486 c104 c447 c263 c445 c261 c446 c262 c454 c324 c457 c405 c460 c408 c106 c453 c452 c448 c449 c450 c451 c467 c468 c469 c470 c471 c107 c108 c112 c495 c109 c496 c110 c111 c497 c113 c498 c114 c280 c281 c282 c415 c283 c417 c418 c416 c87 c531 c330 c331 c332 c509 c510 c511 c513 c461 c444 c462 c279 c482 c426 c455 c463 c464 c465 c466 c473 c476 c479 c489 c431 c432 c433 c434 c435 c437 c438 c440 c474 c475 c477 c478 c480 c481 c491 c490 c410 c409 c430 c488 c487 c264 c265 c266 c267 c268 c269 c325 c472 c484 c485 c520 c521 c522 c523 c411 c412 c456 c424 c407 c142 c144 c158 c532 c525 c526 c527 c528 c524 c529 c530 c115 c121 c550 c551 c552 c553 c554 c555 c556 c557 c558
+model.sym.x = [c2,c3,c288,c335,c117,c336,c286,c499,c500,c501,c4,c10,c11,c141,c145,c140,c146,c143,c147,c155,c159,c154,c160,c156,c161,c492,c493,c494,c502,c504,c503,c505,c506,c507,c105,c123,c124,c125,c126,c116,c122,c127,c128,c284,c129,c427,c130,c428,c131,c429,c132,c436,c133,c439,c134,c442,c135,c483,c136,c516,c137,c517,c138,c345,c139,c355,c168,c421,c169,c422,c170,c23,c12,c7,c25,c88,c27,c89,c29,c90,c34,c91,c35,c92,c36,c93,c37,c94,c189,c195,c190,c196,c191,c197,c198,c204,c199,c205,c200,c206,c207,c213,c208,c214,c209,c215,c216,c222,c217,c223,c218,c224,c225,c231,c226,c232,c227,c233,c243,c249,c244,c250,c245,c251,c252,c258,c253,c259,c254,c260,c234,c240,c235,c241,c236,c242,c300,c301,c303,c304,c306,c307,c309,c310,c312,c313,c315,c316,c318,c319,c321,c322,c357,c358,c360,c361,c366,c367,c369,c370,c372,c373,c375,c376,c378,c379,c381,c382,c363,c364,c384,c385,c387,c388,c390,c391,c393,c394,c396,c397,c399,c400,c402,c403,c9,c404,c401,c398,c395,c392,c389,c386,c365,c383,c380,c377,c374,c371,c368,c362,c359,c323,c320,c317,c314,c311,c308,c305,c302,c239,c238,c237,c257,c256,c255,c248,c247,c246,c230,c229,c228,c221,c220,c219,c212,c211,c210,c203,c202,c201,c194,c193,c192,c68,c67,c66,c65,c21,c20,c18,c19,c6,c5,c8,c15,c17,c32,c63,c33,c64,c347,c349,c348,c350,c351,c353,c508,c512,c354,c356,c148,c162,c149,c163,c150,c164,c289,c290,c337,c338,c291,c293,c294,c296,c297,c299,c14,c165,c166,c167,c151,c152,c153,c341,c344,c343,c346,c16,c157,c22,c40,c39,c180,c181,c182,c183,c184,c185,c24,c26,c28,c69,c43,c71,c31,c171,c172,c173,c174,c175,c176,c41,c42,c70,c72,c45,c38,c30,c44,c73,c46,c75,c76,c47,c74,c48,c49,c50,c51,c77,c53,c78,c52,c54,c79,c55,c56,c57,c58,c80,c81,c82,c59,c83,c60,c61,c84,c62,c85,c86,c425,c13,c518,c519,c339,c340,c95,c96,c97,c98,c101,c102,c99,c419,c103,c100,c420,c287,c486,c104,c447,c263,c445,c261,c446,c262,c454,c324,c457,c405,c460,c408,c106,c453,c452,c448,c449,c450,c451,c467,c468,c469,c470,c471,c107,c108,c112,c495,c109,c496,c110,c111,c497,c113,c498,c114,c280,c281,c282,c415,c283,c417,c418,c416,c87,c531,c330,c331,c332,c509,c510,c511,c513,c461,c444,c462,c279,c482,c426,c455,c463,c464,c465,c466,c473,c476,c479,c489,c431,c432,c433,c434,c435,c437,c438,c440,c474,c475,c477,c478,c480,c481,c491,c490,c410,c409,c430,c488,c487,c264,c265,c266,c267,c268,c269,c325,c472,c484,c485,c520,c521,c522,c523,c411,c412,c456,c424,c407,c142,c144,c158,c532,c525,c526,c527,c528,c524,c529,c530,c115,c121,c550,c551,c552,c553,c554,c555,c556,c557,c558];
+
+%% PARAMETERS
+model.param = 'log10';
+syms EGFR_t ERK_t AKT_t k1d k2 kd2 k2b kd2b k3 kd3 k4 kd4 k4b kd4b k5 kd5 k5b kd5b kd5c k6 k8 kd8 kd8b k8b k10 k10b kd10 k13 kd13 k14 kd14 k15 kd15 k16 k16b k17 kd17 k18 kd18 k19 kd19 k20 kd20 k21 kd21 k22 kd22 k23 kd23 kd24 k25 kd25 k28 kd28 k28b kd28b k29 kd29 kd32 k32 kd33 k33 kd34 k34 kd35 k35 k36 kd36 kd37 k37 k40 kd40 k41 kd41 k42 kd42 kd43 k43 kd44 kd45 k45 kd47 k47 k48 kd48 kd49 k49 k50 kd50 kd52 kd53 k53 kd55 k55 kd56 k56 kd57 k57 k58 kd58 k52 k44 k60 kd60 k61 kd61 kd63 k64 kd64 kd65 k65 k66 kd66 k67 kd67 kd68 k68 kd68b k69 kd69 k70 kd70 k71 kd71 k72 kd72 k73 kd73 k74 kd74 kd75 k75 k76 kd76 kd60d k22b kd22b kd34b k34b k94b k94 kd94 k95 kd95 k96 kd96 kd6b k7 kd7 k62b kd60b k60c k60b KD_iressa_wt kd97 KD_iressa_mt kd97c Kinh2 kd98 k98 Kinh4 kd99 k99 Kinh3 kd100 k100 k101 kd101 k102 kd102 k103 kd103 k104 kd104 k105 kd105 k106 kd106 k106b kd106b k107 kd107 k108 kd108 k109 kd109 k110 kd110 kd111 k111 k112 kd112 k113 kd113 k114 kd114 k115 kd115 kd116 k117 kd117 k118 kd118 kd119 k120 kd120 k120b kd120b Ks k121 kd121 k123 kd123 k6b KD_ATP k123h kd123h KD kd_v853
+model.sym.p = [EGFR_t,ERK_t,AKT_t,k1d,k2,kd2,k2b,kd2b,k3,kd3,k4,kd4,k4b,kd4b,k5,kd5,k5b,kd5b,kd5c,k6,k8,kd8,kd8b,k8b,k10,k10b,kd10,k13,kd13,k14,kd14,k15,kd15,k16,k16b,k17,kd17,k18,kd18,k19,kd19,k20,kd20,k21,kd21,k22,kd22,k23,kd23,kd24,k25,kd25,k28,kd28,k28b,kd28b,k29,kd29,kd32,k32,kd33,k33,kd34,k34,kd35,k35,k36,kd36,kd37,k37,k40,kd40,k41,kd41,k42,kd42,kd43,k43,kd44,kd45,k45,kd47,k47,k48,kd48,kd49,k49,k50,kd50,kd52,kd53,k53,kd55,k55,kd56,k56,kd57,k57,k58,kd58,k52,k44,k60,kd60,k61,kd61,kd63,k64,kd64,kd65,k65,k66,kd66,k67,kd67,kd68,k68,kd68b,k69,kd69,k70,kd70,k71,kd71,k72,kd72,k73,kd73,k74,kd74,kd75,k75,k76,kd76,kd60d,k22b,kd22b,kd34b,k34b,k94b,k94,kd94,k95,kd95,k96,kd96,kd6b,k7,kd7,k62b,kd60b,k60c,k60b,KD_iressa_wt,kd97,KD_iressa_mt,kd97c,Kinh2,kd98,k98,Kinh4,kd99,k99,Kinh3,kd100,k100,k101,kd101,k102,kd102,k103,kd103,k104,kd104,k105,kd105,k106,kd106,k106b,kd106b,k107,kd107,k108,kd108,k109,kd109,k110,kd110,kd111,k111,k112,kd112,k113,kd113,k114,kd114,k115,kd115,kd116,k117,kd117,k118,kd118,kd119,k120,kd120,k120b,kd120b,Ks,k121,kd121,k123,kd123,k6b,KD_ATP,k123h,kd123h,KD,kd_v853];
+
+%% CONDITIONS
+syms c1 c515 c285 c514
+model.sym.k = [c1,c515,c285,c514];
+
+%%
+% DYNAMICS
+time = sym('t');
+
+model.sym.xdot = [c516*kd120 - c2*k6 + c517*kd120 - c2*stepfunc(time, 1799.99, 0, 1800, 1) + c6*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c3*stepfunc(time, 1799.99, 0, 1800, 0.0033) + c105*c531*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c2*c142*k120b - c2*c144*k120b - c1*c2*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c4*kd2 + c145*kd2b + c146*kd2b + c147*kd2b + c500*kd2 + c527*kd2 + c550*kd2 + c504*kd2b + c505*kd2b + c507*kd2b - c3^2*k2 - c3*stepfunc(time, 1799.99, 0, 1800, 0.0033) - c3*c499*k2 - c3*c526*k2 - c3*c529*k2 - c3*c140*k2b - c3*c141*k2b - c3*c143*k2b - c3*c502*k2b - c3*c503*k2b - c3*c506*k2b + c1*c2*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c335*stepfunc(time, 1799.99, 0, 1800, 0) - c288*kd103 + c140*c141*k103 - c1*c288*stepfunc(time, 1799.99, 0, 1800, 0), ...
+c168*kd123 - c335*k7 + c337*kd7 + c341*kd8 - c335*kd103 - c335*stepfunc(time, 1799.99, 0, 1800, 0) - c14*c335*k8 + c87*c331*k103 - c105*c335*k123 + c1*c288*stepfunc(time, 1799.99, 0, 1800, 0), ...
+c336*stepfunc(time, 1799.99, 0, 1800, 0) - c117*kd103 + c141*c143*k103 - c1*c117*k1d, ...
+c139*kd123 - c336*k7 + c338*kd7 + c344*kd8 - c336*kd103 - c336*stepfunc(time, 1799.99, 0, 1800, 0) - c14*c336*k8 + c87*c332*k103 - c105*c336*k123 + c1*c117*k1d, ...
+c499*stepfunc(time, 1799.99, 0, 1800, 0.0033) - c286*kd97 - c1*c286*stepfunc(time, 1799.99, 0, 1800, 10000000) + (c285*c531*kd97)/KD_iressa_wt, ...
+c500*kd2 + c501*kd2 + c551*kd2 + c554*kd2 + c492*kd2b + c493*kd2b + c494*kd2b - c499^2*k2 - c499*stepfunc(time, 1799.99, 0, 1800, 0.0033) - c3*c499*k2 - c499*c526*k2 - c499*c529*k2 - c140*c499*k2b - c141*c499*k2b - c143*c499*k2b + c1*c286*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c115*stepfunc(time, 1799.99, 0, 1800, 1) - c500*kd2 - c105*c500*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c3*c499*k2, ...
+c499^2*k2 - c501*kd2, ...
+c3^2*k2 - c4*kd2 + c116*stepfunc(time, 1799.99, 0, 1800, 1) - c4*c105*stepfunc(time, 1799.99, 0, 1800, 0.000000018704), ...
+c11*kd2 - 2*c10*kd10 + c159*kd2b + c160*kd2b + c161*kd2b - c10^2*k2 + c6*c16*k10b + c16*c530*k10b - c10*c154*k2b - c10*c155*k2b - c10*c156*k2b, ...
+c86*kd60 - c11*kd2 - c11*k60 + c415*kd95 + c10^2*k2 + c126*stepfunc(time, 1799.99, 0, 1800, 1) - c11*c105*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c11*c280*k95, ...
+c117*kd103 - c141*k6b + c145*kd2b + c155*kd6b + c284*kd103 + c288*kd103 + c345*kd120 + c355*kd120 + c492*kd2b + c502*kd98 + c513*kd103 - c87*c141*k103 - c140*c141*k103 - c141*c143*k103 - c141*c142*k120 - c141*c144*k120 - c141*c285*k98 - c141*c503*k103 - c3*c141*k2b - c141*c499*k2b, ...
+c122*stepfunc(time, 1799.99, 0, 1800, 1) - c145*kd2b - c105*c145*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c3*c141*k2b, ...
+c146*kd2b - c140*k6b + c154*kd6b + c142*kd119 + c288*kd103 + c493*kd2b + c506*kd100 + c510*kd103 - c140*c141*k103 - c140*c285*k100 - c140*c502*k103 - c3*c140*k2b - c140*c499*k2b - c140*c514*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c127*stepfunc(time, 1799.99, 0, 1800, 1) - c146*kd2b - c105*c146*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c3*c140*k2b, ...
+c117*kd103 - c143*k6b + c147*kd2b + c156*kd6b + c144*kd119 + c494*kd2b + c503*kd99 + c511*kd103 - c141*c143*k103 - c143*c285*k99 - c143*c502*k103 - c3*c143*k2b - c143*c499*k2b - c143*c514*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c128*stepfunc(time, 1799.99, 0, 1800, 1) - c147*kd2b - c105*c147*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c3*c143*k2b, ...
+c141*k6b - c155*k60b + c86*kd60b - c155*kd6b + c159*kd2b + c421*kd120 + c422*kd120 - c155*c157*k120 - c155*c158*k120 - c10*c155*k2b, ...
+c86*kd60b - c159*k62b - c159*kd2b + c416*kd95 + c123*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c159*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c159*c280*k95 + c10*c155*k2b, ...
+c140*k6b - c154*k60b + c157*kd10 + c86*kd60b - c154*kd6b + c160*kd2b - c154*c515*k10b - c10*c154*k2b, ...
+c86*kd60b - c160*k62b - c160*kd2b + c281*kd95 + c124*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c160*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c160*c280*k95 + c10*c154*k2b, ...
+c143*k6b - c156*k60b + c86*kd60b - c156*kd6b + c161*kd2b - c10*c156*k2b, ...
+c86*kd60b - c161*k62b - c161*kd2b + c282*kd95 + c125*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c161*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c161*c280*k95 + c10*c156*k2b, ...
+c141*c499*k2b - c492*kd2b, ...
+c140*c499*k2b - c493*kd2b, ...
+c143*c499*k2b - c494*kd2b, ...
+c504*kd2b - c502*kd98 - c502*k6b + c508*kd6b + c509*kd103 + c510*kd103 + c511*kd103 + c141*c285*k98 - c87*c502*k103 - c140*c502*k103 - c143*c502*k103 - c3*c502*k2b, ...
+c3*c502*k2b - c504*kd2b, ...
+c505*kd2b - c503*kd99 - c503*k6b + c512*kd6b + c513*kd103 + c143*c285*k99 - c141*c503*k103 - c3*c503*k2b, ...
+c3*c503*k2b - c505*kd2b, ...
+c507*kd2b - c506*kd100 + c140*c285*k100 - c3*c506*k2b, ...
+c3*c506*k2b - c507*kd2b, ...
+c116*kd123 + c122*kd123 + c123*kd123 + c124*kd123 + c125*kd123 + c126*kd123 + c127*kd123 + c128*kd123 + c129*kd123 + c130*kd123 + c131*kd123 + c132*kd123 + c133*kd123 + c134*kd123 + c135*kd123 + c136*kd123 + c137*kd123 + c138*kd123 + c139*kd123 + c168*kd123 + c169*kd123 + c170*kd123 + c115*kd123h + c121*kd123h + c555*kd123 + c557*kd123 + c556*kd123h + c558*kd123h + c2*stepfunc(time, 1799.99, 0, 1800, 1) + c115*stepfunc(time, 1799.99, 0, 1800, 1) + c116*stepfunc(time, 1799.99, 0, 1800, 1) + c121*stepfunc(time, 1799.99, 0, 1800, 1) + c122*stepfunc(time, 1799.99, 0, 1800, 1) + c123*stepfunc(time, 1799.99, 0, 1800, 1) + c124*stepfunc(time, 1799.99, 0, 1800, 1) + c125*stepfunc(time, 1799.99, 0, 1800, 1) + c126*stepfunc(time, 1799.99, 0, 1800, 1) + c127*stepfunc(time, 1799.99, 0, 1800, 1) + c128*stepfunc(time, 1799.99, 0, 1800, 1) + c129*stepfunc(time, 1799.99, 0, 1800, 1) + c130*stepfunc(time, 1799.99, 0, 1800, 1) + c131*stepfunc(time, 1799.99, 0, 1800, 1) + c132*stepfunc(time, 1799.99, 0, 1800, 1) + c133*stepfunc(time, 1799.99, 0, 1800, 1) + c134*stepfunc(time, 1799.99, 0, 1800, 1) + c135*stepfunc(time, 1799.99, 0, 1800, 1) + c136*stepfunc(time, 1799.99, 0, 1800, 1) + c137*stepfunc(time, 1799.99, 0, 1800, 1) + c138*stepfunc(time, 1799.99, 0, 1800, 1) + c139*stepfunc(time, 1799.99, 0, 1800, 1) + c168*stepfunc(time, 1799.99, 0, 1800, 1) + c169*stepfunc(time, 1799.99, 0, 1800, 1) + c170*stepfunc(time, 1799.99, 0, 1800, 1) + c524*stepfunc(time, 1799.99, 0, 1800, 1) + c555*stepfunc(time, 1799.99, 0, 1800, 1) + c556*stepfunc(time, 1799.99, 0, 1800, 1) + c557*stepfunc(time, 1799.99, 0, 1800, 1) + c558*stepfunc(time, 1799.99, 0, 1800, 1) - c4*c105*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c11*c105*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c145*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c146*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c147*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c159*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c160*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c161*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c284*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c345*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c355*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c421*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c422*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c427*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c428*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c429*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c436*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c439*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c442*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c483*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c500*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c516*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c517*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c527*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c531*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c532*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c550*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c551*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c552*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c105*c553*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - 3*c5*c105*k123 - c8*c105*k123 - 4*c5*c105*k123h - c105*c148*k123 - 2*c105*c149*k123 - 2*c105*c150*k123 - c105*c162*k123 - c105*c163*k123 - c105*c164*k123 - c105*c289*k123 - c105*c335*k123 - c105*c336*k123 - c105*c337*k123 - c105*c338*k123 - c105*c445*k123 - c105*c446*k123 - c105*c447*k123 - c105*c454*k123 - c105*c457*k123 - c105*c460*k123 - c105*c486*k123, ...
+c105*c159*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c123*stepfunc(time, 1799.99, 0, 1800, 1) - c123*kd123 + c105*c162*k123, ...
+c105*c160*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c124*stepfunc(time, 1799.99, 0, 1800, 1) - c124*kd123 + c105*c163*k123, ...
+c105*c161*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c125*stepfunc(time, 1799.99, 0, 1800, 1) - c125*kd123 + c105*c164*k123, ...
+c11*c105*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c126*stepfunc(time, 1799.99, 0, 1800, 1) - c126*kd123 + c8*c105*k123, ...
+c4*c105*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c116*stepfunc(time, 1799.99, 0, 1800, 1) - c116*kd123 + c5*c105*k123, ...
+c105*c145*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c122*stepfunc(time, 1799.99, 0, 1800, 1) - c122*kd123 + c105*c148*k123, ...
+c105*c146*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c127*stepfunc(time, 1799.99, 0, 1800, 1) - c127*kd123 + c105*c149*k123, ...
+c105*c147*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c128*stepfunc(time, 1799.99, 0, 1800, 1) - c128*kd123 + c105*c150*k123, ...
+c129*stepfunc(time, 1799.99, 0, 1800, 1) - c284*kd103 - c105*c284*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c87*c141*k103, ...
+c105*c284*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c129*stepfunc(time, 1799.99, 0, 1800, 1) - c129*kd123 + c105*c289*k123, ...
+c464*kd108 - c427*kd105 + c130*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c427*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c225*c426*k105 - c427*c463*k108, ...
+c105*c427*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c130*stepfunc(time, 1799.99, 0, 1800, 1) - c130*kd123 + c105*c445*k123, ...
+c465*kd108 - c428*kd105 + c131*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c428*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c226*c426*k105 - c428*c463*k108, ...
+c105*c428*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c131*stepfunc(time, 1799.99, 0, 1800, 1) - c131*kd123 + c105*c446*k123, ...
+c466*kd108 - c429*kd105 + c132*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c429*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c227*c426*k105 - c429*c463*k108, ...
+c105*c429*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c132*stepfunc(time, 1799.99, 0, 1800, 1) - c132*kd123 + c105*c447*k123, ...
+c473*kd108 - c436*kd105 + c133*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c436*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c312*c426*k105 - c436*c463*k108, ...
+c105*c436*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c133*stepfunc(time, 1799.99, 0, 1800, 1) - c133*kd123 + c105*c454*k123, ...
+c476*kd108 - c439*kd105 + c134*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c439*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c381*c426*k105 - c439*c463*k108, ...
+c105*c439*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c134*stepfunc(time, 1799.99, 0, 1800, 1) - c134*kd123 + c105*c457*k123, ...
+c479*kd108 - c442*kd105 + c135*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c442*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c384*c426*k105 - c442*c463*k108, ...
+c105*c442*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c135*stepfunc(time, 1799.99, 0, 1800, 1) - c135*kd123 + c105*c460*k123, ...
+c489*kd108 - c483*kd105 + c136*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c483*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c23*c426*k105 - c463*c483*k108, ...
+c105*c483*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c136*stepfunc(time, 1799.99, 0, 1800, 1) - c136*kd123 + c105*c486*k123, ...
+c137*stepfunc(time, 1799.99, 0, 1800, 1) - c516*kd120 - c105*c516*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c2*c142*k120b, ...
+c105*c516*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c137*stepfunc(time, 1799.99, 0, 1800, 1) - c137*kd123 + c105*c149*k123, ...
+c138*stepfunc(time, 1799.99, 0, 1800, 1) - c517*kd120 - c105*c517*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c2*c144*k120b, ...
+c105*c517*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c138*stepfunc(time, 1799.99, 0, 1800, 1) - c138*kd123 + c105*c150*k123, ...
+c139*stepfunc(time, 1799.99, 0, 1800, 1) - c345*kd120 - c105*c345*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c141*c144*k120, ...
+c105*c345*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c139*stepfunc(time, 1799.99, 0, 1800, 1) - c139*kd123 + c105*c336*k123, ...
+c168*stepfunc(time, 1799.99, 0, 1800, 1) - c355*kd120 - c105*c355*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c141*c142*k120, ...
+c105*c355*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c168*stepfunc(time, 1799.99, 0, 1800, 1) - c168*kd123 + c105*c335*k123, ...
+c86*kd60b - c421*k62b - c421*kd120 + c169*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c421*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c155*c157*k120, ...
+c105*c421*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c169*stepfunc(time, 1799.99, 0, 1800, 1) - c169*kd123 + c105*c337*k123, ...
+c86*kd60b - c422*k62b - c422*kd120 + c170*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c422*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c155*c158*k120, ...
+c105*c422*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c170*stepfunc(time, 1799.99, 0, 1800, 1) - c170*kd123 + c105*c338*k123, ...
+c7*kd4 - c23*k6 + c25*kd17 - c23*kd63 + c99*kd101 + c483*kd105 + c18*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c23*k4 + c15*c22*k16 - c23*c24*k17 - c23*c103*k101 - c23*c426*k105, ...
+c9*k15 + c7*kd4 - c12*kd15 + c88*kd4 + c89*kd4 + c90*kd4 + c91*kd4 + c92*kd4 + c93*kd4 + c94*kd4 + c195*kd4 + c196*kd4 + c197*kd4 + c204*kd4 + c205*kd4 + c206*kd4 + c213*kd4 + c214*kd4 + c215*kd4 + c222*kd4 + c223*kd4 + c224*kd4 + c231*kd4 + c232*kd4 + c233*kd4 + c240*kd4 + c241*kd4 + c242*kd4 + c249*kd4 + c250*kd4 + c251*kd4 + c258*kd4 + c259*kd4 + c260*kd4 + c301*kd4 + c304*kd4 + c307*kd4 + c310*kd4 + c313*kd4 + c316*kd4 + c319*kd4 + c322*kd4 + c358*kd4 + c361*kd4 + c364*kd4 + c367*kd4 + c370*kd4 + c373*kd4 + c376*kd4 + c379*kd4 + c382*kd4 + c385*kd4 + c388*kd4 + c391*kd4 + c394*kd4 + c397*kd4 + c400*kd4 + c403*kd4 - c12*c23*k4 - c12*c25*k4 - c12*c27*k4 - c12*c29*k4 - c12*c34*k4 - c12*c35*k4 - c12*c36*k4 - c12*c37*k4 - c12*c252*k4 - c12*c253*k4 - c12*c254*k4 - c12*c189*k4b - c12*c190*k4b - c12*c191*k4b - c12*c198*k4b - c12*c199*k4b - c12*c200*k4b - c12*c207*k4b - c12*c208*k4b - c12*c209*k4b - c12*c216*k4b - c12*c217*k4b - c12*c218*k4b - c12*c225*k4b - c12*c226*k4b - c12*c227*k4b - c12*c234*k4b - c12*c235*k4b - c12*c236*k4b - c12*c243*k4b - c12*c244*k4b - c12*c245*k4b - c12*c300*k4b - c12*c303*k4b - c12*c306*k4b - c12*c309*k4b - c12*c312*k4b - c12*c315*k4b - c12*c318*k4b - c12*c321*k4b - c12*c357*k4b - c12*c360*k4b - c12*c363*k4b - c12*c366*k4b - c12*c369*k4b - c12*c372*k4b - c12*c375*k4b - c12*c378*k4b - c12*c381*k4b - c12*c384*k4b - c12*c387*k4b - c12*c390*k4b - c12*c393*k4b - c12*c396*k4b - c12*c399*k4b - c12*c402*k4b, ...
+c9*c18*k5 - c7*kd5 - c7*kd4 + c12*c23*k4, ...
+c27*kd18 - c25*kd17 - c25*k6 + c27*kd19 + c29*kd20 + c29*kd21 - c25*kd34 + c88*kd4 + c95*kd64 + c19*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c25*k4 + c23*c24*k17 - c25*c26*k18 - c25*c26*k21 - c25*c28*k19 + c15*c30*k34 - c25*c43*k20 - c25*c59*k64, ...
+c9*c19*k5 - c88*kd5 - c88*kd4 + c12*c25*k4, ...
+c89*kd4 - c27*kd18 - c27*kd19 - c27*k6 + c20*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c27*k4 + c25*c26*k18 + c25*c28*k19, ...
+c9*c20*k5 - c89*kd5 - c89*kd4 + c12*c27*k4, ...
+c90*kd4 - c29*kd20 - c29*kd21 - c29*k6 + c21*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c29*k4 + c25*c26*k21 + c25*c43*k20, ...
+c9*c21*k5 - c90*kd5 - c90*kd4 + c12*c29*k4, ...
+c35*kd25 - c34*kd24 - c34*k6 - c34*kd37 + c91*kd4 + c419*kd101 + c65*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c34*k4 + c22*c33*k16 - c24*c34*k25 + c15*c39*k37 - c34*c103*k101, ...
+c12*c34*k4 - c91*kd5 - c91*kd4 + c9*c65*k5, ...
+c36*kd18 - c35*k6 + c36*kd19 + c37*kd20 + c37*kd21 - c35*kd25 - c35*kd32 - c35*kd41 + c92*kd4 + c97*kd64 + c66*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c35*k4 - c26*c35*k18 - c26*c35*k21 - c28*c35*k19 + c24*c34*k25 + c15*c38*k32 - c35*c43*k20 + c30*c33*k41 - c35*c59*k64, ...
+c12*c35*k4 - c92*kd5 - c92*kd4 + c9*c66*k5, ...
+c93*kd4 - c36*kd18 - c36*kd19 - c36*k6 + c67*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c36*k4 + c26*c35*k18 + c28*c35*k19, ...
+c12*c36*k4 - c93*kd5 - c93*kd4 + c9*c67*k5, ...
+c94*kd4 - c37*kd20 - c37*kd21 - c37*k6 + c68*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c12*c37*k4 + c26*c35*k21 + c35*c43*k20, ...
+c12*c37*k4 - c94*kd5 - c94*kd4 + c9*c68*k5, ...
+c195*kd4 - c189*kd24 + c198*kd25 - c189*kd37 + c22*c180*k16 + c39*c151*k37 - c24*c189*k25 - c12*c189*k4b, ...
+c9*c192*k5 - c195*kd5b - c195*kd4 + c12*c189*k4b, ...
+c196*kd4 - c190*kd24 + c199*kd25 - c190*kd37 + c22*c181*k16 + c39*c152*k37 - c24*c190*k25 - c12*c190*k4b, ...
+c9*c193*k5 - c196*kd5b - c196*kd4 + c12*c190*k4b, ...
+c197*kd4 - c191*kd24 + c200*kd25 - c191*kd37 + c22*c182*k16 + c39*c153*k37 - c24*c191*k25 - c12*c191*k4b, ...
+c9*c194*k5 - c197*kd5b - c197*kd4 + c12*c191*k4b, ...
+c204*kd4 - c198*kd25 + c207*kd18 + c207*kd19 - c198*kd32 + c216*kd20 + c216*kd21 - c198*kd41 + c38*c151*k32 + c24*c189*k25 - c26*c198*k18 - c26*c198*k21 - c28*c198*k19 + c30*c180*k41 - c43*c198*k20 - c12*c198*k4b, ...
+c9*c201*k5 - c204*kd5b - c204*kd4 + c12*c198*k4b, ...
+c205*kd4 - c199*kd25 + c208*kd18 + c208*kd19 - c199*kd32 + c217*kd20 + c217*kd21 - c199*kd41 + c38*c152*k32 + c24*c190*k25 - c26*c199*k18 - c26*c199*k21 - c28*c199*k19 + c30*c181*k41 - c43*c199*k20 - c12*c199*k4b, ...
+c9*c202*k5 - c205*kd5b - c205*kd4 + c12*c199*k4b, ...
+c206*kd4 - c200*kd25 + c209*kd18 + c209*kd19 - c200*kd32 + c218*kd20 + c218*kd21 - c200*kd41 + c38*c153*k32 + c24*c191*k25 - c26*c200*k18 - c26*c200*k21 - c28*c200*k19 + c30*c182*k41 - c43*c200*k20 - c12*c200*k4b, ...
+c9*c203*k5 - c206*kd5b - c206*kd4 + c12*c200*k4b, ...
+c213*kd4 - c207*kd18 - c207*kd19 + c26*c198*k18 + c28*c198*k19 - c12*c207*k4b, ...
+c9*c210*k5 - c213*kd5b - c213*kd4 + c12*c207*k4b, ...
+c214*kd4 - c208*kd18 - c208*kd19 + c26*c199*k18 + c28*c199*k19 - c12*c208*k4b, ...
+c9*c211*k5 - c214*kd5b - c214*kd4 + c12*c208*k4b, ...
+c215*kd4 - c209*kd18 - c209*kd19 + c26*c200*k18 + c28*c200*k19 - c12*c209*k4b, ...
+c9*c212*k5 - c215*kd5b - c215*kd4 + c12*c209*k4b, ...
+c222*kd4 - c216*kd20 - c216*kd21 + c26*c198*k21 + c43*c198*k20 - c12*c216*k4b, ...
+c9*c219*k5 - c222*kd5b - c222*kd4 + c12*c216*k4b, ...
+c223*kd4 - c217*kd20 - c217*kd21 + c26*c199*k21 + c43*c199*k20 - c12*c217*k4b, ...
+c9*c220*k5 - c223*kd5b - c223*kd4 + c12*c217*k4b, ...
+c224*kd4 - c218*kd20 - c218*kd21 + c26*c200*k21 + c43*c200*k20 - c12*c218*k4b, ...
+c9*c221*k5 - c224*kd5b - c224*kd4 + c12*c218*k4b, ...
+c231*kd4 - c225*kd24 + c234*kd17 + c427*kd105 + c22*c151*k16 - c24*c225*k17 - c225*c426*k105 - c12*c225*k4b, ...
+c9*c228*k5 - c231*kd5b - c231*kd4 + c12*c225*k4b, ...
+c232*kd4 - c226*kd24 + c235*kd17 + c428*kd105 + c22*c152*k16 - c24*c226*k17 - c226*c426*k105 - c12*c226*k4b, ...
+c9*c229*k5 - c232*kd5b - c232*kd4 + c12*c226*k4b, ...
+c233*kd4 - c227*kd24 + c236*kd17 + c429*kd105 + c22*c153*k16 - c24*c227*k17 - c227*c426*k105 - c12*c227*k4b, ...
+c9*c230*k5 - c233*kd5b - c233*kd4 + c12*c227*k4b, ...
+c249*kd4 - c243*kd18 - c243*kd19 + c26*c234*k18 + c28*c234*k19 - c12*c243*k4b, ...
+c9*c246*k5 - c249*kd5b - c249*kd4 + c12*c243*k4b, ...
+c250*kd4 - c244*kd18 - c244*kd19 + c26*c235*k18 + c28*c235*k19 - c12*c244*k4b, ...
+c9*c247*k5 - c250*kd5b - c250*kd4 + c12*c244*k4b, ...
+c251*kd4 - c245*kd18 - c245*kd19 + c26*c236*k18 + c28*c236*k19 - c12*c245*k4b, ...
+c9*c248*k5 - c251*kd5b - c251*kd4 + c12*c245*k4b, ...
+c258*kd4 - c252*kd20 - c252*kd21 - c12*c252*k4 + c26*c234*k21 + c43*c234*k20, ...
+c12*c252*k4 - c258*kd5b - c258*kd4 + c9*c255*k5, ...
+c259*kd4 - c253*kd20 - c253*kd21 - c12*c253*k4 + c26*c235*k21 + c43*c235*k20, ...
+c12*c253*k4 - c259*kd5b - c259*kd4 + c9*c256*k5, ...
+c260*kd4 - c254*kd20 - c254*kd21 - c12*c254*k4 + c26*c236*k21 + c43*c236*k20, ...
+c12*c254*k4 - c260*kd5b - c260*kd4 + c9*c257*k5, ...
+c240*kd4 - c234*kd17 + c243*kd18 + c243*kd19 - c234*kd34 + c252*kd20 + c252*kd21 + c30*c151*k34 + c24*c225*k17 - c26*c234*k18 - c26*c234*k21 - c28*c234*k19 - c43*c234*k20 - c12*c234*k4b, ...
+c9*c237*k5 - c240*kd5b - c240*kd4 + c12*c234*k4b, ...
+c241*kd4 - c235*kd17 + c244*kd18 + c244*kd19 - c235*kd34 + c253*kd20 + c253*kd21 + c30*c152*k34 + c24*c226*k17 - c26*c235*k18 - c26*c235*k21 - c28*c235*k19 - c43*c235*k20 - c12*c235*k4b, ...
+c9*c238*k5 - c241*kd5b - c241*kd4 + c12*c235*k4b, ...
+c242*kd4 - c236*kd17 + c245*kd18 + c245*kd19 - c236*kd34 + c254*kd20 + c254*kd21 + c30*c153*k34 + c24*c227*k17 - c26*c236*k18 - c26*c236*k21 - c28*c236*k19 - c43*c236*k20 - c12*c236*k4b, ...
+c9*c239*k5 - c242*kd5b - c242*kd4 + c12*c236*k4b, ...
+c301*kd4 - c300*kd24 + c303*kd25 - c300*kd37 + c22*c297*k16 - c24*c300*k25 + c39*c291*k37 - c12*c300*k4b, ...
+c9*c302*k5 - c301*kd5b - c301*kd4 + c12*c300*k4b, ...
+c304*kd4 + c306*kd18 + c306*kd19 - c303*kd25 + c309*kd20 + c309*kd21 - c303*kd32 - c303*kd41 - c26*c303*k18 + c24*c300*k25 - c26*c303*k21 - c28*c303*k19 + c38*c291*k32 - c43*c303*k20 + c30*c297*k41 - c12*c303*k4b, ...
+c9*c305*k5 - c304*kd5b - c304*kd4 + c12*c303*k4b, ...
+c307*kd4 - c306*kd18 - c306*kd19 + c26*c303*k18 + c28*c303*k19 - c12*c306*k4b, ...
+c9*c308*k5 - c307*kd5b - c307*kd4 + c12*c306*k4b, ...
+c310*kd4 - c309*kd20 - c309*kd21 + c26*c303*k21 + c43*c303*k20 - c12*c309*k4b, ...
+c9*c311*k5 - c310*kd5b - c310*kd4 + c12*c309*k4b, ...
+c313*kd4 + c315*kd17 - c312*kd63 + c436*kd105 + c22*c291*k16 - c24*c312*k17 - c312*c426*k105 - c12*c312*k4b, ...
+c9*c314*k5 - c313*kd5b - c313*kd4 + c12*c312*k4b, ...
+c316*kd4 - c315*kd17 + c318*kd18 + c318*kd19 + c321*kd20 + c321*kd21 - c315*kd34 + c24*c312*k17 + c30*c291*k34 - c26*c315*k18 - c26*c315*k21 - c28*c315*k19 - c43*c315*k20 - c12*c315*k4b, ...
+c9*c317*k5 - c316*kd5b - c316*kd4 + c12*c315*k4b, ...
+c319*kd4 - c318*kd18 - c318*kd19 + c26*c315*k18 + c28*c315*k19 - c12*c318*k4b, ...
+c9*c320*k5 - c319*kd5b - c319*kd4 + c12*c318*k4b, ...
+c322*kd4 - c321*kd20 - c321*kd21 + c26*c315*k21 + c43*c315*k20 - c12*c321*k4b, ...
+c9*c323*k5 - c322*kd5b - c322*kd4 + c12*c321*k4b, ...
+c358*kd4 - c357*kd24 + c363*kd25 - c357*kd37 + c22*c351*k16 - c24*c357*k25 + c39*c341*k37 - c12*c357*k4b, ...
+c9*c359*k5b - c358*kd5b - c358*kd4 + c12*c357*k4b, ...
+c361*kd4 - c360*kd24 + c366*kd25 - c360*kd37 + c22*c354*k16 - c24*c360*k25 + c39*c344*k37 - c12*c360*k4b, ...
+c9*c362*k5b - c361*kd5b - c361*kd4 + c12*c360*k4b, ...
+c367*kd4 + c372*kd18 - c366*kd25 + c372*kd19 - c366*kd32 + c378*kd20 + c378*kd21 - c366*kd41 + c24*c360*k25 - c26*c366*k18 - c26*c366*k21 - c28*c366*k19 + c38*c344*k32 + c30*c354*k41 - c43*c366*k20 - c12*c366*k4b, ...
+c9*c368*k5b - c367*kd5b - c367*kd4 + c12*c366*k4b, ...
+c370*kd4 - c369*kd18 - c369*kd19 + c26*c363*k18 + c28*c363*k19 - c12*c369*k4b, ...
+c9*c371*k5b - c370*kd5b - c370*kd4 + c12*c369*k4b, ...
+c373*kd4 - c372*kd18 - c372*kd19 + c26*c366*k18 + c28*c366*k19 - c12*c372*k4b, ...
+c9*c374*k5b - c373*kd5b - c373*kd4 + c12*c372*k4b, ...
+c376*kd4 - c375*kd20 - c375*kd21 + c26*c363*k21 + c43*c363*k20 - c12*c375*k4b, ...
+c9*c377*k5b - c376*kd5b - c376*kd4 + c12*c375*k4b, ...
+c379*kd4 - c378*kd20 - c378*kd21 + c26*c366*k21 + c43*c366*k20 - c12*c378*k4b, ...
+c9*c380*k5b - c379*kd5b - c379*kd4 + c12*c378*k4b, ...
+c382*kd4 + c387*kd17 - c381*kd63 + c439*kd105 + c22*c341*k16 - c24*c381*k17 - c381*c426*k105 - c12*c381*k4b, ...
+c9*c383*k5b - c382*kd5b - c382*kd4 + c12*c381*k4b, ...
+c364*kd4 + c369*kd18 - c363*kd25 + c369*kd19 - c363*kd32 + c375*kd20 + c375*kd21 - c363*kd41 + c24*c357*k25 - c26*c363*k18 - c26*c363*k21 - c28*c363*k19 + c38*c341*k32 + c30*c351*k41 - c43*c363*k20 - c12*c363*k4b, ...
+c9*c365*k5b - c364*kd5b - c364*kd4 + c12*c363*k4b, ...
+c385*kd4 + c390*kd17 - c384*kd24 + c442*kd105 + c22*c344*k16 - c24*c384*k17 - c384*c426*k105 - c12*c384*k4b, ...
+c9*c386*k5b - c385*kd5b - c385*kd4 + c12*c384*k4b, ...
+c388*kd4 - c387*kd17 + c393*kd18 + c393*kd19 + c399*kd20 + c399*kd21 - c387*kd34 + c30*c341*k34 + c24*c381*k17 - c26*c387*k18 - c26*c387*k21 - c28*c387*k19 - c43*c387*k20 - c12*c387*k4b, ...
+c9*c389*k5b - c388*kd5b - c388*kd4 + c12*c387*k4b, ...
+c391*kd4 - c390*kd17 + c396*kd18 + c396*kd19 + c402*kd20 + c402*kd21 - c390*kd34 + c30*c344*k34 + c24*c384*k17 - c26*c390*k18 - c26*c390*k21 - c28*c390*k19 - c43*c390*k20 - c12*c390*k4b, ...
+c9*c392*k5b - c391*kd5b - c391*kd4 + c12*c390*k4b, ...
+c394*kd4 - c393*kd18 - c393*kd19 + c26*c387*k18 + c28*c387*k19 - c12*c393*k4b, ...
+c9*c395*k5b - c394*kd5b - c394*kd4 + c12*c393*k4b, ...
+c397*kd4 - c396*kd18 - c396*kd19 + c26*c390*k18 + c28*c390*k19 - c12*c396*k4b, ...
+c9*c398*k5b - c397*kd5b - c397*kd4 + c12*c396*k4b, ...
+c400*kd4 - c399*kd20 - c399*kd21 + c26*c387*k21 + c43*c387*k20 - c12*c399*k4b, ...
+c9*c401*k5b - c400*kd5b - c400*kd4 + c12*c399*k4b, ...
+c403*kd4 - c402*kd20 - c402*kd21 + c26*c390*k21 + c43*c390*k20 - c12*c402*k4b, ...
+c9*c404*k5b - c403*kd5b - c403*kd4 + c12*c402*k4b, ...
+c7*kd5 - c9*k15 + c12*kd15 + c88*kd5 + c89*kd5 + c90*kd5 + c91*kd5 + c92*kd5 + c93*kd5 + c94*kd5 + c195*kd5b + c196*kd5b + c197*kd5b + c204*kd5b + c205*kd5b + c206*kd5b + c213*kd5b + c214*kd5b + c215*kd5b + c222*kd5b + c223*kd5b + c224*kd5b + c231*kd5b + c232*kd5b + c233*kd5b + c240*kd5b + c241*kd5b + c242*kd5b + c249*kd5b + c250*kd5b + c251*kd5b + c258*kd5b + c259*kd5b + c260*kd5b + c301*kd5b + c304*kd5b + c307*kd5b + c310*kd5b + c313*kd5b + c316*kd5b + c319*kd5b + c322*kd5b + c358*kd5b + c361*kd5b + c364*kd5b + c367*kd5b + c370*kd5b + c373*kd5b + c376*kd5b + c379*kd5b + c382*kd5b + c385*kd5b + c388*kd5b + c391*kd5b + c394*kd5b + c397*kd5b + c400*kd5b + c403*kd5b - c9*c18*k5 - c9*c19*k5 - c9*c20*k5 - c9*c21*k5 - c9*c65*k5 - c9*c66*k5 - c9*c67*k5 - c9*c68*k5 - c9*c192*k5 - c9*c193*k5 - c9*c194*k5 - c9*c201*k5 - c9*c202*k5 - c9*c203*k5 - c9*c210*k5 - c9*c211*k5 - c9*c212*k5 - c9*c219*k5 - c9*c220*k5 - c9*c221*k5 - c9*c228*k5 - c9*c229*k5 - c9*c230*k5 - c9*c237*k5 - c9*c238*k5 - c9*c239*k5 - c9*c246*k5 - c9*c247*k5 - c9*c248*k5 - c9*c255*k5 - c9*c256*k5 - c9*c257*k5 - c9*c302*k5 - c9*c305*k5 - c9*c308*k5 - c9*c311*k5 - c9*c314*k5 - c9*c317*k5 - c9*c320*k5 - c9*c323*k5 - c9*c359*k5b - c9*c362*k5b - c9*c365*k5b - c9*c368*k5b - c9*c371*k5b - c9*c374*k5b - c9*c377*k5b - c9*c380*k5b - c9*c383*k5b - c9*c386*k5b - c9*c389*k5b - c9*c392*k5b - c9*c395*k5b - c9*c398*k5b - c9*c401*k5b - c9*c404*k5b, ...
+c86*kd60 - c404*k60c - c404*kd20 - c404*kd21 + c403*kd5b + c26*c392*k21 + c71*c392*k20 - c9*c404*k5b, ...
+c86*kd60 - c401*k60c - c401*kd20 - c401*kd21 + c400*kd5b + c26*c389*k21 + c71*c389*k20 - c9*c401*k5b, ...
+c86*kd60 - c398*k60c - c398*kd18 - c398*kd19 + c397*kd5b + c26*c392*k18 + c69*c392*k19 - c9*c398*k5b, ...
+c86*kd60 - c395*k60c - c395*kd18 - c395*kd19 + c394*kd5b + c26*c389*k18 + c69*c389*k19 - c9*c395*k5b, ...
+c86*kd60 - c392*k60c - c392*kd17 + c398*kd18 + c398*kd19 + c404*kd20 + c404*kd21 - c392*kd34 + c391*kd5b + c30*c346*k34 + c24*c386*k17 - c26*c392*k18 - c26*c392*k21 - c69*c392*k19 - c71*c392*k20 - c9*c392*k5b, ...
+c86*kd60 - c389*k60c - c389*kd17 + c395*kd18 + c395*kd19 + c401*kd20 + c401*kd21 - c389*kd34 + c388*kd5b + c30*c343*k34 + c24*c383*k17 - c26*c389*k18 - c26*c389*k21 - c69*c389*k19 - c71*c389*k20 - c9*c389*k5b, ...
+c86*kd60 - c386*k60c + c392*kd17 - c386*kd63 + c385*kd5b + c22*c346*k16 - c24*c386*k17 - c9*c386*k5b, ...
+c86*kd60 - c365*k60c + c371*kd18 - c365*kd25 + c371*kd19 - c365*kd32 + c377*kd20 + c377*kd21 - c365*kd41 + c364*kd5b + c24*c359*k25 - c26*c365*k18 - c26*c365*k21 + c38*c343*k32 + c30*c353*k41 - c69*c365*k19 - c71*c365*k20 - c9*c365*k5b, ...
+c86*kd60 - c383*k60c + c389*kd17 - c383*kd24 + c382*kd5b + c22*c343*k16 - c24*c383*k17 - c9*c383*k5b, ...
+c86*kd60 - c380*k60c - c380*kd20 - c380*kd21 + c379*kd5b + c26*c368*k21 + c71*c368*k20 - c9*c380*k5b, ...
+c86*kd60 - c377*k60c - c377*kd20 - c377*kd21 + c376*kd5b + c26*c365*k21 + c71*c365*k20 - c9*c377*k5b, ...
+c86*kd60 - c374*k60c - c374*kd18 - c374*kd19 + c373*kd5b + c26*c368*k18 + c69*c368*k19 - c9*c374*k5b, ...
+c86*kd60 - c371*k60c - c371*kd18 - c371*kd19 + c370*kd5b + c26*c365*k18 + c69*c365*k19 - c9*c371*k5b, ...
+c86*kd60 - c368*k60c + c374*kd18 - c368*kd25 + c374*kd19 - c368*kd32 + c380*kd20 + c380*kd21 - c368*kd41 + c367*kd5b + c24*c362*k25 - c26*c368*k18 - c26*c368*k21 + c38*c346*k32 + c30*c356*k41 - c69*c368*k19 - c71*c368*k20 - c9*c368*k5b, ...
+c86*kd60 - c362*k60c - c362*kd24 + c368*kd25 - c362*kd37 + c361*kd5b + c22*c356*k16 - c24*c362*k25 + c39*c346*k37 - c9*c362*k5b, ...
+c86*kd60 - c359*k60c - c359*kd24 + c365*kd25 - c359*kd37 + c358*kd5b + c22*c353*k16 - c24*c359*k25 + c39*c343*k37 - c9*c359*k5b, ...
+c86*kd60 - c323*k60b - c323*kd20 - c323*kd21 + c322*kd5b - c9*c323*k5 + c26*c317*k21 + c71*c317*k20, ...
+c86*kd60 - c320*k60b - c320*kd18 - c320*kd19 + c319*kd5b - c9*c320*k5 + c26*c317*k18 + c69*c317*k19, ...
+c86*kd60 - c317*k60b - c317*kd17 + c320*kd18 + c320*kd19 + c323*kd20 + c323*kd21 - c317*kd34 + c316*kd5b - c9*c317*k5 + c24*c314*k17 + c30*c293*k34 - c26*c317*k18 - c26*c317*k21 - c69*c317*k19 - c71*c317*k20, ...
+c86*kd60 - c314*k60b + c317*kd17 - c314*kd63 + c313*kd5b - c9*c314*k5 + c22*c293*k16 - c24*c314*k17, ...
+c86*kd60 - c311*k60b - c311*kd20 - c311*kd21 + c310*kd5b - c9*c311*k5 + c26*c305*k21 + c71*c305*k20, ...
+c86*kd60 - c308*k60b - c308*kd18 - c308*kd19 + c307*kd5b - c9*c308*k5 + c26*c305*k18 + c69*c305*k19, ...
+c308*kd18 + c308*kd19 - c305*kd25 + c311*kd20 + c311*kd21 - c305*kd32 - c305*kd41 + c304*kd5b - c9*c305*k5 - c26*c305*k18 + c24*c302*k25 - c26*c305*k21 + c38*c293*k32 + c30*c299*k41 - c69*c305*k19 - c71*c305*k20, ...
+c86*kd60 - c302*k60b - c302*kd24 + c305*kd25 - c302*kd37 + c301*kd5b - c9*c302*k5 + c22*c299*k16 - c24*c302*k25 + c39*c293*k37, ...
+c86*kd60 - c239*k60b - c239*kd17 + c248*kd18 + c248*kd19 - c239*kd34 + c257*kd20 + c257*kd21 + c242*kd5b + c30*c167*k34 - c9*c239*k5 + c24*c230*k17 - c26*c239*k18 - c26*c239*k21 - c69*c239*k19 - c71*c239*k20, ...
+c86*kd60 - c238*k60b - c238*kd17 + c247*kd18 + c247*kd19 - c238*kd34 + c256*kd20 + c256*kd21 + c241*kd5b + c30*c166*k34 - c9*c238*k5 + c24*c229*k17 - c26*c238*k18 - c26*c238*k21 - c69*c238*k19 - c71*c238*k20, ...
+c86*kd60 - c237*k60b - c237*kd17 + c246*kd18 + c246*kd19 - c237*kd34 + c255*kd20 + c255*kd21 + c240*kd5b + c30*c165*k34 - c9*c237*k5 + c24*c228*k17 - c26*c237*k18 - c26*c237*k21 - c69*c237*k19 - c71*c237*k20, ...
+c86*kd60 - c257*k60b - c257*kd20 - c257*kd21 + c260*kd5b - c9*c257*k5 + c26*c239*k21 + c71*c239*k20, ...
+c86*kd60 - c256*k60b - c256*kd20 - c256*kd21 + c259*kd5b - c9*c256*k5 + c26*c238*k21 + c71*c238*k20, ...
+c86*kd60 - c255*k60b - c255*kd20 - c255*kd21 + c258*kd5b - c9*c255*k5 + c26*c237*k21 + c71*c237*k20, ...
+c86*kd60 - c248*k60b - c248*kd18 - c248*kd19 + c251*kd5b - c9*c248*k5 + c26*c239*k18 + c69*c239*k19, ...
+c86*kd60 - c247*k60b - c247*kd18 - c247*kd19 + c250*kd5b - c9*c247*k5 + c26*c238*k18 + c69*c238*k19, ...
+c86*kd60 - c246*k60b - c246*kd18 - c246*kd19 + c249*kd5b - c9*c246*k5 + c26*c237*k18 + c69*c237*k19, ...
+c86*kd60 - c230*k60b - c230*kd24 + c239*kd17 + c233*kd5b + c22*c167*k16 - c9*c230*k5 - c24*c230*k17, ...
+c86*kd60 - c229*k60b - c229*kd24 + c238*kd17 + c232*kd5b + c22*c166*k16 - c9*c229*k5 - c24*c229*k17, ...
+c86*kd60 - c228*k60b - c228*kd24 + c237*kd17 + c231*kd5b + c22*c165*k16 - c9*c228*k5 - c24*c228*k17, ...
+c86*kd60 - c221*k60b - c221*kd20 - c221*kd21 + c224*kd5b - c9*c221*k5 + c26*c203*k21 + c71*c203*k20, ...
+c86*kd60 - c220*k60b - c220*kd20 - c220*kd21 + c223*kd5b - c9*c220*k5 + c26*c202*k21 + c71*c202*k20, ...
+c86*kd60 - c219*k60b - c219*kd20 - c219*kd21 + c222*kd5b - c9*c219*k5 + c26*c201*k21 + c71*c201*k20, ...
+c86*kd60 - c212*k60b - c212*kd18 - c212*kd19 + c215*kd5b - c9*c212*k5 + c26*c203*k18 + c69*c203*k19, ...
+c86*kd60 - c211*k60b - c211*kd18 - c211*kd19 + c214*kd5b - c9*c211*k5 + c26*c202*k18 + c69*c202*k19, ...
+c86*kd60 - c210*k60b - c210*kd18 - c210*kd19 + c213*kd5b - c9*c210*k5 + c26*c201*k18 + c69*c201*k19, ...
+c86*kd60 - c203*k60b - c203*kd25 + c212*kd18 + c212*kd19 - c203*kd32 + c221*kd20 + c221*kd21 - c203*kd41 + c206*kd5b - c9*c203*k5 + c38*c167*k32 + c24*c194*k25 - c26*c203*k18 - c26*c203*k21 + c30*c185*k41 - c69*c203*k19 - c71*c203*k20, ...
+c86*kd60 - c202*k60b - c202*kd25 + c211*kd18 + c211*kd19 - c202*kd32 + c220*kd20 + c220*kd21 - c202*kd41 + c205*kd5b - c9*c202*k5 + c38*c166*k32 + c24*c193*k25 - c26*c202*k18 - c26*c202*k21 + c30*c184*k41 - c69*c202*k19 - c71*c202*k20, ...
+c86*kd60 - c201*k60b - c201*kd25 + c210*kd18 + c210*kd19 - c201*kd32 + c219*kd20 + c219*kd21 - c201*kd41 + c204*kd5b - c9*c201*k5 + c38*c165*k32 + c24*c192*k25 - c26*c201*k18 - c26*c201*k21 + c30*c183*k41 - c69*c201*k19 - c71*c201*k20, ...
+c86*kd60 - c194*k60b - c194*kd24 + c203*kd25 - c194*kd37 + c197*kd5b - c9*c194*k5 + c22*c185*k16 - c24*c194*k25 + c39*c167*k37, ...
+c86*kd60 - c193*k60b - c193*kd24 + c202*kd25 - c193*kd37 + c196*kd5b - c9*c193*k5 + c22*c184*k16 - c24*c193*k25 + c39*c166*k37, ...
+c86*kd60 - c192*k60b - c192*kd24 + c201*kd25 - c192*kd37 + c195*kd5b - c9*c192*k5 + c22*c183*k16 - c24*c192*k25 + c39*c165*k37, ...
+c37*k6 - c68*k60 - c68*kd20 - c68*kd21 + c94*kd5 + c86*kd60 - c68*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c68*k5 + c26*c66*k21 + c66*c71*k20, ...
+c36*k6 - c67*k60 - c67*kd18 - c67*kd19 + c93*kd5 + c86*kd60 - c67*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c67*k5 + c26*c66*k18 + c66*c69*k19, ...
+c35*k6 - c66*k60 + c67*kd18 + c67*kd19 + c68*kd20 + c68*kd21 - c66*kd25 + c92*kd5 - c66*kd32 - c66*kd41 + c86*kd60 + c98*kd64 - c66*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c66*k5 + c17*c38*k32 - c26*c66*k18 - c26*c66*k21 + c24*c65*k25 + c30*c64*k41 - c66*c69*k19 - c66*c71*k20 - c66*c83*k64, ...
+c34*k6 - c65*k60 - c65*kd24 + c66*kd25 + c91*kd5 - c65*kd37 + c86*kd60 + c420*kd101 - c65*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c65*k5 + c17*c39*k37 + c22*c64*k16 - c24*c65*k25 - c65*c103*k101, ...
+c29*k6 - c21*k60 - c21*kd20 - c21*kd21 + c90*kd5 + c86*kd60 - c21*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c21*k5 + c19*c26*k21 + c19*c71*k20, ...
+c27*k6 - c20*k60 - c20*kd18 - c20*kd19 + c89*kd5 + c86*kd60 - c20*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c20*k5 + c19*c26*k18 + c19*c69*k19, ...
+c23*k6 - c18*k60 + c7*kd5 + c19*kd17 - c18*kd63 + c86*kd60 + c100*kd101 - c18*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c18*k5 + c17*c22*k16 - c18*c24*k17 - c18*c103*k101, ...
+c25*k6 - c19*k60 - c19*kd17 + c20*kd18 + c20*kd19 + c21*kd20 + c21*kd21 - c19*kd34 + c88*kd5 + c86*kd60 + c96*kd64 - c19*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c9*c19*k5 + c18*c24*k17 - c19*c26*k18 - c19*c26*k21 + c17*c30*k34 - c19*c69*k19 - c19*c71*k20 - c19*c83*k64, ...
+c2*k6 - c6*k60 + c10*kd10 + c86*kd60 + c518*kd120 + c519*kd120 - c6*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c6*c16*k10b - c6*c157*k120b - c6*c158*k120b, ...
+c15*kd8 - c5*k6 - c5*kd102 + c116*kd123 + c115*kd123h + c121*kd123h + c555*kd123 + c557*kd123 + c556*kd123h + c558*kd123h + c330^2*k102 + c8*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c5*c14*k8 - 3*c5*c105*k123 - 4*c5*c105*k123h, ...
+c5*k6 + c17*kd8 + c126*kd123 + c415*kd94 - c8*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c8*c14*k8 - c8*c105*k123 - c8*c280*k94, ...
+c32*kd22 - c15*kd8 - c15*k6 + c25*kd34 + c35*kd32 + c33*kd37 + c34*kd37 + c23*kd63 + c17*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c5*c14*k8 - c15*c22*k16 - c15*c31*k22 - c15*c30*k34 - c15*c38*k32 - c15*c39*k37 - c15*c40*k37, ...
+c15*k6 - c17*k60 - c17*kd8 + c19*kd34 + c18*kd63 + c63*kd22 + c66*kd32 + c64*kd37 + c65*kd37 + c86*kd60 - c17*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c8*c14*k8 - c17*c22*k16 - c17*c31*k22 - c17*c30*k34 - c17*c38*k32 - c17*c39*k37 - c17*c40*k37, ...
+c33*kd23 - c32*k23 - c32*kd22 - c32*k6 + c63*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c15*c31*k22, ...
+c32*k6 - c63*k23 - c63*k60 - c63*kd22 + c64*kd23 + c86*kd60 - c63*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c17*c31*k22, ...
+c32*k23 - c33*k6 - c33*kd23 + c34*kd24 - c33*kd37 + c35*kd41 + c64*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c22*c33*k16 + c15*c40*k37 - c30*c33*k41, ...
+c33*k6 + c63*k23 - c64*k60 - c64*kd23 + c65*kd24 - c64*kd37 + c66*kd41 + c86*kd60 - c64*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c17*c40*k37 - c22*c64*k16 - c30*c64*k41, ...
+c351*kd23 - c347*k6b - c347*k23 + c349*kd6b - c347*kd22b + c31*c341*k22, ...
+c347*k6b - c349*k60c - c349*k23 + c86*kd60 + c353*kd23 - c349*kd6b - c349*kd22b + c31*c343*k22, ...
+c354*kd23 - c348*k23 - c348*kd22 - c348*k6 + c350*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c31*c344*k22, ...
+c348*k6 - c350*k23 - c350*k60c + c86*kd60 - c350*kd22 + c356*kd23 - c350*stepfunc(time, 1799.99, 0, 1800, 0.00005) + c31*c346*k22, ...
+c347*k23 - c351*k6b - c351*kd23 + c357*kd24 - c351*kd37 + c363*kd41 + c353*kd6b - c22*c351*k16 + c40*c341*k37 - c30*c351*k41, ...
+c349*k23 - c353*k60c + c351*k6b + c86*kd60 - c353*kd23 + c359*kd24 - c353*kd37 + c365*kd41 - c353*kd6b - c22*c353*k16 + c40*c343*k37 - c30*c353*k41, ...
+c502*k6b - c508*kd6b, ...
+c503*k6b - c512*kd6b, ...
+c348*k23 - c354*k6b - c354*kd23 + c360*kd24 - c354*kd37 + c366*kd41 + c356*kd6b - c22*c354*k16 + c40*c344*k37 - c30*c354*k41, ...
+c350*k23 - c356*k60c + c354*k6b + c86*kd60 - c356*kd23 + c362*kd24 - c356*kd37 + c368*kd41 - c356*kd6b - c22*c356*k16 + c40*c346*k37 - c30*c356*k41, ...
+c151*kd8 - c148*k7 + c162*kd7 + c122*kd123 - c148*kd102 - c14*c148*k8 - c105*c148*k123 + c87*c330*k102, ...
+c148*k7 - c162*kd7 + c123*kd123 + c165*kd8b + c416*kd94 - c105*c162*k123 - c162*c280*k94 - c14*c162*k8b, ...
+c163*kd7 - c149*k7 + c127*kd123 - c149*kd102 + c152*kd8b + c137*kd123 - 2*c105*c149*k123 + c330*c331*k102 - c14*c149*k8b, ...
+c149*k7 - c163*kd7 + c124*kd123 + c166*kd8b + c281*kd94 - c105*c163*k123 - c163*c280*k94b - c14*c163*k8b, ...
+c164*kd7 - c150*k7 + c128*kd123 - c150*kd102 + c153*kd8b + c138*kd123 - 2*c105*c150*k123 + c330*c332*k102 - c14*c150*k8b, ...
+c150*k7 - c164*kd7 + c125*kd123 + c167*kd8b + c282*kd94 - c105*c164*k123 - c164*c280*k94b - c14*c164*k8b, ...
+c129*kd123 - c289*k7 + c290*kd7 + c291*kd8 - c289*kd96 + c87^2*k96 - c14*c289*k8 - c105*c289*k123, ...
+c289*k7 - c290*kd7 + c293*kd8 + c283*kd94 - c14*c290*k8 - c280*c290*k94, ...
+c335*k7 + c169*kd123 - c337*kd7 + c343*kd8 + c417*kd94 - c14*c337*k8 - c105*c337*k123 - c280*c337*k94, ...
+c336*k7 + c170*kd123 - c338*kd7 + c346*kd8 + c418*kd94 - c14*c338*k8 - c105*c338*k123 - c280*c338*k94, ...
+c293*kd7 - c291*kd8 - c291*k7 + c297*kd37 + c303*kd32 + c300*kd37 + c315*kd34 + c312*kd63 + c294*kd22b + c14*c289*k8 - c22*c291*k16 - c31*c291*k22 - c30*c291*k34 - c38*c291*k32 - c39*c291*k37 - c40*c291*k37, ...
+c291*k7 - c293*k60b + c86*kd60 - c293*kd7 - c293*kd8 + c299*kd37 + c305*kd32 + c302*kd37 + c317*kd34 + c314*kd63 + c296*kd22b + c14*c290*k8 - c22*c293*k16 - c31*c293*k22 - c30*c293*k34 - c38*c293*k32 - c39*c293*k37 - c40*c293*k37, ...
+c296*kd7 - c294*k23 - c294*k7 + c297*kd23 - c294*kd22b + c31*c291*k22, ...
+c294*k7 - c296*k23 - c296*k60b + c86*kd60 - c296*kd7 + c299*kd23 - c296*kd22b + c31*c293*k22, ...
+c294*k23 - c297*k7 + c299*kd7 - c297*kd23 + c300*kd24 - c297*kd37 + c303*kd41 - c22*c297*k16 - c30*c297*k41 + c40*c291*k37, ...
+c297*k7 + c296*k23 - c299*k60b + c86*kd60 - c299*kd7 - c299*kd23 + c302*kd24 - c299*kd37 + c305*kd41 - c22*c299*k16 - c30*c299*k41 + c40*c293*k37, ...
+c15*kd8 + c17*kd8 + c151*kd8 + c152*kd8b + c153*kd8b + c165*kd8b + c166*kd8b + c167*kd8b + c291*kd8 + c293*kd8 + c341*kd8 + c343*kd8 + c344*kd8 + c346*kd8 - c5*c14*k8 - c8*c14*k8 - c14*c148*k8 - c14*c289*k8 - c14*c290*k8 - c14*c335*k8 - c14*c336*k8 - c14*c337*k8 - c14*c338*k8 - c14*c149*k8b - c14*c150*k8b - c14*c162*k8b - c14*c163*k8b - c14*c164*k8b, ...
+c183*kd37 + c192*kd37 + c201*kd32 + c228*kd24 - c165*kd8b + c237*kd34 + c174*kd22b - c22*c165*k16 - c31*c165*k22 - c30*c165*k34 - c38*c165*k32 - c39*c165*k37 - c40*c165*k37 + c14*c162*k8b, ...
+c184*kd37 + c193*kd37 + c202*kd32 + c229*kd24 - c166*kd8b + c238*kd34 + c175*kd22b - c22*c166*k16 - c31*c166*k22 - c30*c166*k34 - c38*c166*k32 - c39*c166*k37 - c40*c166*k37 + c14*c163*k8b, ...
+c185*kd37 + c194*kd37 + c203*kd32 + c230*kd24 - c167*kd8b + c239*kd34 + c176*kd22b - c22*c167*k16 - c31*c167*k22 - c30*c167*k34 - c38*c167*k32 - c39*c167*k37 - c40*c167*k37 + c14*c164*k8b, ...
+c180*kd37 - c151*kd8 + c189*kd37 + c198*kd32 + c225*kd24 + c234*kd34 + c171*kd22b + c14*c148*k8 - c22*c151*k16 - c31*c151*k22 - c30*c151*k34 - c38*c151*k32 - c39*c151*k37 - c40*c151*k37, ...
+c181*kd37 + c190*kd37 + c199*kd32 + c226*kd24 - c152*kd8b + c235*kd34 + c172*kd22b - c22*c152*k16 - c31*c152*k22 - c30*c152*k34 - c38*c152*k32 - c39*c152*k37 - c40*c152*k37 + c14*c149*k8b, ...
+c182*kd37 + c191*kd37 + c200*kd32 + c227*kd24 - c153*kd8b + c236*kd34 + c173*kd22b - c22*c153*k16 - c31*c153*k22 - c30*c153*k34 - c38*c153*k32 - c39*c153*k37 - c40*c153*k37 + c14*c150*k8b, ...
+c351*kd37 - c341*kd8 + c357*kd37 + c363*kd32 + c387*kd34 + c381*kd63 + c347*kd22b + c14*c335*k8 - c22*c341*k16 - c31*c341*k22 - c30*c341*k34 - c38*c341*k32 - c39*c341*k37 - c40*c341*k37, ...
+c348*kd22 - c344*kd8 + c354*kd37 + c360*kd37 + c366*kd32 + c384*kd24 + c390*kd34 + c14*c336*k8 - c22*c344*k16 - c31*c344*k22 - c30*c344*k34 - c38*c344*k32 - c39*c344*k37 - c40*c344*k37, ...
+c353*kd37 - c343*kd8 + c359*kd37 + c365*kd32 + c383*kd24 + c389*kd34 + c349*kd22b + c14*c337*k8 - c22*c343*k16 - c31*c343*k22 - c30*c343*k34 - c38*c343*k32 - c39*c343*k37 - c40*c343*k37, ...
+c350*kd22 - c346*kd8 + c356*kd37 + c362*kd37 + c368*kd32 + c392*kd34 + c386*kd63 + c14*c338*k8 - c22*c346*k16 - c31*c346*k22 - c30*c346*k34 - c38*c346*k32 - c39*c346*k37 - c40*c346*k37, ...
+2*c10*kd10 - c16*k61 + c13*kd61 - c6*c16*k10b - c16*c530*k10b, ...
+c421*kd120 - c157*kd10 + c518*kd120 - c6*c157*k120b - c155*c157*k120 + c154*c515*k10b, ...
+c34*kd24 + c39*kd24 + c30*kd35 + c18*kd63 + c23*kd63 + c65*kd24 + c189*kd24 + c190*kd24 + c191*kd24 + c192*kd24 + c193*kd24 + c194*kd24 + c225*kd24 + c226*kd24 + c227*kd24 + c228*kd24 + c229*kd24 + c230*kd24 + c300*kd24 + c302*kd24 + c312*kd63 + c314*kd63 + c357*kd24 + c359*kd24 + c360*kd24 + c362*kd24 + c383*kd24 + c384*kd24 + c381*kd63 + c386*kd63 - c15*c22*k16 - c17*c22*k16 - c22*c33*k16 - c22*c40*k16 - c22*c24*k35 - c22*c64*k16 - c22*c151*k16 - c22*c152*k16 - c22*c153*k16 - c22*c165*k16 - c22*c166*k16 - c22*c167*k16 - c22*c180*k16 - c22*c181*k16 - c22*c182*k16 - c22*c183*k16 - c22*c184*k16 - c22*c185*k16 - c22*c291*k16 - c22*c293*k16 - c22*c297*k16 - c22*c299*k16 - c22*c341*k16 - c22*c343*k16 - c22*c344*k16 - c22*c346*k16 - c22*c351*k16 - c22*c353*k16 - c22*c354*k16 - c22*c356*k16, ...
+c39*kd24 - c40*k36 + c31*kd36 + c33*kd37 + c38*kd33 + c64*kd37 + c180*kd37 + c181*kd37 + c182*kd37 + c183*kd37 + c184*kd37 + c185*kd37 + c297*kd37 + c299*kd37 + c351*kd37 + c353*kd37 + c354*kd37 + c356*kd37 - c22*c40*k16 - c15*c40*k37 - c17*c40*k37 - c30*c40*k33 - c40*c151*k37 - c40*c152*k37 - c40*c153*k37 - c40*c165*k37 - c40*c166*k37 - c40*c167*k37 - c40*c291*k37 - c40*c293*k37 - c40*c341*k37 - c40*c343*k37 - c40*c344*k37 - c40*c346*k37, ...
+c34*kd37 - c39*kd24 + c38*kd40 + c65*kd37 + c189*kd37 + c190*kd37 + c191*kd37 + c192*kd37 + c193*kd37 + c194*kd37 + c300*kd37 + c302*kd37 + c357*kd37 + c359*kd37 + c360*kd37 + c362*kd37 + c22*c40*k16 - c15*c39*k37 - c17*c39*k37 - c24*c39*k40 - c39*c151*k37 - c39*c152*k37 - c39*c153*k37 - c39*c165*k37 - c39*c166*k37 - c39*c167*k37 - c39*c291*k37 - c39*c293*k37 - c39*c341*k37 - c39*c343*k37 - c39*c344*k37 - c39*c346*k37, ...
+c171*k23 - c180*kd23 + c189*kd24 - c180*kd37 + c198*kd41 - c22*c180*k16 + c40*c151*k37 - c30*c180*k41, ...
+c172*k23 - c181*kd23 + c190*kd24 - c181*kd37 + c199*kd41 - c22*c181*k16 + c40*c152*k37 - c30*c181*k41, ...
+c173*k23 - c182*kd23 + c191*kd24 - c182*kd37 + c200*kd41 - c22*c182*k16 + c40*c153*k37 - c30*c182*k41, ...
+c174*k23 - c183*kd23 + c192*kd24 - c183*kd37 + c201*kd41 - c22*c183*k16 + c40*c165*k37 - c30*c183*k41, ...
+c175*k23 - c184*kd23 + c193*kd24 - c184*kd37 + c202*kd41 - c22*c184*k16 + c40*c166*k37 - c30*c184*k41, ...
+c176*k23 - c185*kd23 + c194*kd24 - c185*kd37 + c203*kd41 - c22*c185*k16 + c40*c167*k37 - c30*c185*k41, ...
+c19*kd17 + c25*kd17 + c35*kd25 + c30*kd35 + c38*kd40 + c66*kd25 + c101*kd64 + c102*kd64 + c198*kd25 + c199*kd25 + c200*kd25 + c201*kd25 + c202*kd25 + c203*kd25 + c234*kd17 + c235*kd17 + c236*kd17 + c237*kd17 + c238*kd17 + c239*kd17 + c303*kd25 + c305*kd25 + c315*kd17 + c317*kd17 + c363*kd25 + c365*kd25 + c366*kd25 + c368*kd25 + c387*kd17 + c389*kd17 + c390*kd17 + c392*kd17 - c18*c24*k17 - c23*c24*k17 - c22*c24*k35 - c24*c34*k25 - c24*c39*k40 - c24*c65*k25 - c24*c59*k64 - c24*c83*k64 - c24*c189*k25 - c24*c190*k25 - c24*c191*k25 - c24*c192*k25 - c24*c193*k25 - c24*c194*k25 - c24*c225*k17 - c24*c226*k17 - c24*c227*k17 - c24*c228*k17 - c24*c229*k17 - c24*c230*k17 - c24*c300*k25 - c24*c302*k25 - c24*c312*k17 - c24*c314*k17 - c24*c357*k25 - c24*c359*k25 - c24*c360*k25 - c24*c362*k25 - c24*c381*k17 - c24*c383*k17 - c24*c384*k17 - c24*c386*k17, ...
+c20*kd18 + c21*kd21 + c27*kd18 + c29*kd21 + c36*kd18 + c37*kd21 + c67*kd18 + c68*kd21 + c207*kd18 + c208*kd18 + c209*kd18 + c210*kd18 + c211*kd18 + c212*kd18 + c216*kd21 + c217*kd21 + c218*kd21 + c219*kd21 + c220*kd21 + c221*kd21 + c243*kd18 + c244*kd18 + c245*kd18 + c246*kd18 + c247*kd18 + c248*kd18 + c252*kd21 + c253*kd21 + c254*kd21 + c255*kd21 + c256*kd21 + c257*kd21 + c306*kd18 + c308*kd18 + c309*kd21 + c311*kd21 + c318*kd18 + c320*kd18 + c321*kd21 + c323*kd21 + c264*kd112 + c265*kd112 + c266*kd112 + c267*kd112 + c268*kd112 + c269*kd112 + c369*kd18 + c371*kd18 + c372*kd18 + c374*kd18 + c375*kd21 + c377*kd21 + c378*kd21 + c380*kd21 + c393*kd18 + c395*kd18 + c396*kd18 + c398*kd18 + c399*kd21 + c401*kd21 + c402*kd21 + c404*kd21 + c325*kd112 - c19*c26*k18 - c19*c26*k21 - c25*c26*k18 - c25*c26*k21 - c26*c35*k18 - c26*c35*k21 - c26*c66*k18 - c26*c66*k21 - c26*c104*k112 - c26*c198*k18 - c26*c199*k18 - c26*c200*k18 - c26*c198*k21 - c26*c201*k18 - c26*c199*k21 - c26*c202*k18 - c26*c200*k21 - c26*c203*k18 - c26*c201*k21 - c26*c202*k21 - c26*c203*k21 - c26*c234*k18 - c26*c235*k18 - c26*c236*k18 - c26*c234*k21 - c26*c237*k18 - c26*c235*k21 - c26*c238*k18 - c26*c236*k21 - c26*c239*k18 - c26*c237*k21 - c26*c238*k21 - c26*c239*k21 - c26*c303*k18 - c26*c305*k18 - c26*c303*k21 - c26*c305*k21 - c26*c315*k18 - c26*c317*k18 - c26*c315*k21 - c26*c317*k21 - c26*c261*k112 - c26*c262*k112 - c26*c263*k112 - c26*c363*k18 - c26*c365*k18 - c26*c363*k21 - c26*c366*k18 - c26*c365*k21 - c26*c368*k18 - c26*c366*k21 - c26*c368*k21 - c26*c387*k18 - c26*c389*k18 - c26*c387*k21 - c26*c390*k18 - c26*c389*k21 - c26*c392*k18 - c26*c390*k21 - c26*c392*k21 - c26*c324*k112 - c26*c405*k112 - c26*c408*k112, ...
+c27*kd19 + c36*kd19 + c42*kd28 + c207*kd19 + c208*kd19 + c209*kd19 + c243*kd19 + c244*kd19 + c245*kd19 + c306*kd19 + c318*kd19 + c264*kd113 + c265*kd113 + c266*kd113 + c267*kd113 + c268*kd113 + c269*kd113 + c369*kd19 + c372*kd19 + c393*kd19 + c396*kd19 + c325*kd113 - c25*c28*k19 - c28*c35*k19 - c28*c41*k28 - c28*c104*k113 - c28*c198*k19 - c28*c199*k19 - c28*c200*k19 - c28*c234*k19 - c28*c235*k19 - c28*c236*k19 - c28*c303*k19 - c28*c315*k19 - c28*c261*k113 - c28*c262*k113 - c28*c263*k113 - c28*c363*k19 - c28*c366*k19 - c28*c387*k19 - c28*c390*k19 - c28*c324*k113 - c28*c405*k113 - c28*c479*k113, ...
+c20*kd19 + c67*kd19 + c70*kd28 + c210*kd19 + c211*kd19 + c212*kd19 + c246*kd19 + c247*kd19 + c248*kd19 + c308*kd19 + c320*kd19 + c371*kd19 + c374*kd19 + c395*kd19 + c398*kd19 - c19*c69*k19 - c41*c69*k28 - c66*c69*k19 - c69*c201*k19 - c69*c202*k19 - c69*c203*k19 - c69*c237*k19 - c69*c238*k19 - c69*c239*k19 - c69*c305*k19 - c69*c317*k19 - c69*c365*k19 - c69*c368*k19 - c69*c389*k19 - c69*c392*k19, ...
+c29*kd20 + c37*kd20 + c42*kd29 + c216*kd20 + c217*kd20 + c218*kd20 + c252*kd20 + c253*kd20 + c254*kd20 + c309*kd20 + c321*kd20 + c375*kd20 + c378*kd20 + c399*kd20 + c402*kd20 - c25*c43*k20 - c35*c43*k20 - c43*c45*k29 - c43*c198*k20 - c43*c199*k20 - c43*c200*k20 - c43*c234*k20 - c43*c235*k20 - c43*c236*k20 - c43*c303*k20 - c43*c315*k20 - c43*c363*k20 - c43*c366*k20 - c43*c387*k20 - c43*c390*k20, ...
+c21*kd20 + c68*kd20 + c70*kd29 + c219*kd20 + c220*kd20 + c221*kd20 + c255*kd20 + c256*kd20 + c257*kd20 + c311*kd20 + c323*kd20 + c377*kd20 + c380*kd20 + c401*kd20 + c404*kd20 - c19*c71*k20 - c66*c71*k20 - c71*c72*k29 - c71*c201*k20 - c71*c202*k20 - c71*c203*k20 - c71*c237*k20 - c71*c238*k20 - c71*c239*k20 - c71*c305*k20 - c71*c317*k20 - c71*c365*k20 - c71*c368*k20 - c71*c389*k20 - c71*c392*k20, ...
+c40*k36 + c32*kd22 - c31*kd36 + c63*kd22 + c171*kd22b + c172*kd22b + c173*kd22b + c174*kd22b + c175*kd22b + c176*kd22b + c348*kd22 + c350*kd22 + c294*kd22b + c296*kd22b + c347*kd22b + c349*kd22b - c15*c31*k22 - c17*c31*k22 - c31*c151*k22 - c31*c152*k22 - c31*c153*k22 - c31*c165*k22 - c31*c166*k22 - c31*c167*k22 - c31*c291*k22 - c31*c293*k22 - c31*c341*k22 - c31*c343*k22 - c31*c344*k22 - c31*c346*k22, ...
+c180*kd23 - c171*k23 - c171*kd22b + c31*c151*k22, ...
+c181*kd23 - c172*k23 - c172*kd22b + c31*c152*k22, ...
+c182*kd23 - c173*k23 - c173*kd22b + c31*c153*k22, ...
+c183*kd23 - c174*k23 - c174*kd22b + c31*c165*k22, ...
+c184*kd23 - c175*k23 - c175*kd22b + c31*c166*k22, ...
+c185*kd23 - c176*k23 - c176*kd22b + c31*c167*k22, ...
+c42*kd28 + c46*kd43 + c70*kd28 + c73*kd43 - c28*c41*k28 - 2*c41*c44*k43 - c41*c69*k28, ...
+c28*c41*k28 - c42*kd29 - c42*kd28 + c43*c45*k29, ...
+c41*c69*k28 - c70*kd29 - c70*kd28 + c71*c72*k29, ...
+c70*kd29 + c73*kd42 + c74*kd45 + c76*kd47 + c74*kd52 + c76*kd52 + c484*kd114 - c44*c72*k42 - c47*c72*k44 - c71*c72*k29 - c72*c75*k44 - c72*c75*k45 - c72*c77*k47 - c72*c497*k114, ...
+c42*kd29 + c46*kd42 + c48*kd45 + c50*kd47 + c48*kd52 + c50*kd52 + c472*kd114 - c43*c45*k29 - c44*c45*k42 - c45*c47*k44 - c45*c49*k44 - c45*c49*k45 - c45*c51*k47 - c45*c497*k114, ...
+c35*kd32 - c38*kd33 - c38*kd40 + c66*kd32 + c198*kd32 + c199*kd32 + c200*kd32 + c201*kd32 + c202*kd32 + c203*kd32 + c303*kd32 + c305*kd32 + c363*kd32 + c365*kd32 + c366*kd32 + c368*kd32 - c15*c38*k32 - c17*c38*k32 + c24*c39*k40 + c30*c40*k33 - c38*c151*k32 - c38*c152*k32 - c38*c153*k32 - c38*c165*k32 - c38*c166*k32 - c38*c167*k32 - c38*c291*k32 - c38*c293*k32 - c38*c341*k32 - c38*c343*k32 - c38*c344*k32 - c38*c346*k32, ...
+c19*kd34 + c25*kd34 - c30*kd35 + c38*kd33 + c35*kd41 + c66*kd41 + c198*kd41 + c199*kd41 + c200*kd41 + c201*kd41 + c202*kd41 + c203*kd41 + c234*kd34 + c235*kd34 + c236*kd34 + c237*kd34 + c238*kd34 + c239*kd34 + c303*kd41 + c305*kd41 + c315*kd34 + c317*kd34 + c363*kd41 + c365*kd41 + c366*kd41 + c368*kd41 + c387*kd34 + c389*kd34 + c390*kd34 + c392*kd34 - c15*c30*k34 - c17*c30*k34 + c22*c24*k35 - c30*c40*k33 - c30*c33*k41 - c30*c64*k41 - c30*c151*k34 - c30*c152*k34 - c30*c153*k34 - c30*c165*k34 - c30*c166*k34 - c30*c167*k34 - c30*c180*k41 - c30*c181*k41 - c30*c182*k41 - c30*c183*k41 - c30*c184*k41 - c30*c185*k41 - c30*c291*k34 - c30*c293*k34 - c30*c297*k41 - c30*c299*k41 - c30*c341*k34 - c30*c343*k34 - c30*c344*k34 - c30*c346*k34 - c30*c351*k41 - c30*c353*k41 - c30*c354*k41 - c30*c356*k41, ...
+c46*kd42 + c46*kd43 + c73*kd42 + c73*kd43 - 2*c41*c44*k43 - c44*c45*k42 - c44*c72*k42, ...
+c41*c44*k43 - c73*kd43 - c73*kd42 + c44*c72*k42, ...
+c41*c44*k43 - c46*kd43 - c46*kd42 + c44*c45*k42, ...
+c74*kd45 + c78*kd49 + c76*kd52 + c79*kd50 - c53*c75*k49 - c53*c75*k50 - c72*c75*k44 - c72*c75*k45, ...
+c72*c75*k44 - c76*kd52 - c76*kd47 + c72*c77*k47, ...
+c48*kd52 + c54*kd49 + c74*kd52 + c79*kd49 - c45*c47*k44 - 2*c47*c53*k49 - c47*c72*k44, ...
+c47*c72*k44 - c74*kd52 - c74*kd45 + c72*c75*k45, ...
+c45*c47*k44 - c48*kd52 - c48*kd45 + c45*c49*k45, ...
+c48*kd45 + c52*kd49 + c50*kd52 + c54*kd50 - c45*c49*k44 - c45*c49*k45 - c49*c53*k49 - c49*c53*k50, ...
+c45*c49*k44 - c50*kd52 - c50*kd47 + c45*c51*k47, ...
+c50*kd47 + c52*kd48 + c56*kd44 + c58*kd44 + c56*kd53 + c58*kd55 - c45*c51*k47 - c51*c53*k48 - c51*c55*k52 - c51*c57*k52 - c51*c57*k53 - c51*c59*k55, ...
+c76*kd47 + c80*kd44 + c78*kd48 + c82*kd44 + c80*kd53 + c82*kd55 - c53*c77*k48 - c55*c77*k52 - c72*c77*k47 - c77*c81*k52 - c77*c81*k53 - c77*c83*k55, ...
+c52*kd48 + c52*kd49 + c54*kd49 + c54*kd50 + c78*kd48 + c78*kd49 + c79*kd49 + c79*kd50 - 2*c47*c53*k49 - c49*c53*k49 - c49*c53*k50 - c51*c53*k48 - c53*c75*k49 - c53*c75*k50 - c53*c77*k48, ...
+c53*c75*k49 - c78*kd49 - c78*kd48 + c53*c77*k48, ...
+c49*c53*k49 - c52*kd49 - c52*kd48 + c51*c53*k48, ...
+c47*c53*k49 - c54*kd50 - c54*kd49 + c49*c53*k50, ...
+c47*c53*k49 - c79*kd50 - c79*kd49 + c53*c75*k50, ...
+c56*kd44 + c62*kd57 + c80*kd44 + c85*kd57 - c51*c55*k52 - 2*c55*c60*k57 - c55*c77*k52, ...
+c51*c55*k52 - c56*kd53 - c56*kd44 + c51*c57*k53, ...
+c58*kd44 + c56*kd53 + c61*kd57 + c62*kd58 - c51*c57*k52 - c51*c57*k53 - c57*c60*k57 - c57*c60*k58, ...
+c51*c57*k52 - c58*kd55 - c58*kd44 + c51*c59*k55, ...
+c55*c77*k52 - c80*kd53 - c80*kd44 + c77*c81*k53, ...
+c82*kd44 + c80*kd53 + c84*kd57 + c85*kd58 - c60*c81*k57 - c60*c81*k58 - c77*c81*k52 - c77*c81*k53, ...
+c77*c81*k52 - c82*kd55 - c82*kd44 + c77*c83*k55, ...
+c58*kd55 + c61*kd56 + c95*kd64 + c95*kd65 + c97*kd64 + c97*kd65 + c101*kd64 + c101*kd65 + c431*kd110 + c431*kd111 + c433*kd110 + c433*kd111 + c435*kd110 + c435*kd111 + c438*kd110 + c438*kd111 + c474*kd110 + c474*kd111 + c477*kd110 + c477*kd111 + c480*kd110 + c480*kd111 - c24*c59*k64 - c25*c59*k64 - c35*c59*k64 - c51*c59*k55 - c59*c60*k56 - c59*c99*k65 - c59*c103*k65 - c59*c419*k65 - c59*c409*k111 - c59*c410*k111 - c59*c430*k111 - c59*c445*k110 - c59*c446*k110 - c59*c447*k110 - c59*c454*k110 - c59*c457*k110 - c59*c460*k110 - c59*c486*k110 - c59*c487*k111 - c59*c488*k111 - c59*c490*k111 - c59*c491*k111, ...
+c82*kd55 + c84*kd56 + c96*kd64 + c96*kd65 + c98*kd64 + c98*kd65 + c102*kd64 + c102*kd65 + c432*kd110 + c432*kd111 + c434*kd110 + c434*kd111 + c437*kd110 + c437*kd111 + c440*kd110 + c440*kd111 + c475*kd110 + c475*kd111 + c478*kd110 + c478*kd111 + c481*kd110 + c481*kd111 - c19*c83*k64 - c24*c83*k64 - c60*c83*k56 - c66*c83*k64 - c77*c83*k55 - c83*c100*k65 - c83*c103*k65 - c83*c420*k65 - c83*c409*k111 - c83*c410*k111 - c83*c430*k111 - c83*c445*k110 - c83*c446*k110 - c83*c447*k110 - c83*c454*k110 - c83*c457*k110 - c83*c460*k110 - c83*c486*k110 - c83*c487*k111 - c83*c488*k111 - c83*c490*k111 - c83*c491*k111, ...
+c61*kd56 + c61*kd57 + c62*kd57 + c62*kd58 + c84*kd56 + c84*kd57 + c85*kd57 + c85*kd58 + c520*kd116 - c60*stepfunc(time, 2659.99, 0, 2660, 0.0150356) - 2*c55*c60*k57 - c57*c60*k57 - c57*c60*k58 - c59*c60*k56 - c60*c81*k57 - c60*c81*k58 - c60*c83*k56, ...
+c57*c60*k57 - c61*kd57 - c61*kd56 + c59*c60*k56, ...
+c60*c81*k57 - c84*kd57 - c84*kd56 + c60*c83*k56, ...
+c55*c60*k57 - c62*kd58 - c62*kd57 + c57*c60*k58, ...
+c55*c60*k57 - c85*kd58 - c85*kd57 + c60*c81*k58, ...
+c6*k60 + c11*k60 + c17*k60 + c18*k60 + c19*k60 + c20*k60 + c21*k60 + c63*k60 + c64*k60 + c65*k60 + c66*k60 + c67*k60 + c68*k60 + c154*k60b + c155*k60b + c156*k60b + c159*k62b + c160*k62b + c161*k62b + c192*k60b + c193*k60b + c194*k60b + c201*k60b + c202*k60b + c203*k60b + c210*k60b + c211*k60b + c212*k60b + c219*k60b + c220*k60b + c221*k60b + c228*k60b + c229*k60b + c230*k60b + c237*k60b + c238*k60b + c239*k60b + c246*k60b + c247*k60b + c248*k60b + c255*k60b + c256*k60b + c257*k60b + c293*k60b + c296*k60b + c299*k60b + c302*k60b + c308*k60b + c311*k60b + c314*k60b + c317*k60b + c320*k60b + c323*k60b + c339*k62b + c340*k62b + c349*k60c + c350*k60c + c353*k60c + c356*k60c + c359*k60c + c362*k60c + c365*k60c + c368*k60c + c371*k60c + c374*k60c + c377*k60c + c380*k60c + c383*k60c + c386*k60c + c389*k60c + c392*k60c + c395*k60c + c398*k60c + c401*k60c + c404*k60c + c421*k62b + c422*k62b + c425*k60b + c518*k62b + c519*k62b - 68*c86*kd60 - 12*c86*kd60b, ...
+c86*kd60 - c425*k60b + c283*kd95 - c280*c425*k95, ...
+c16*k61 - c13*kd61, ...
+c86*kd60b - c518*k62b - c518*kd120 + c6*c157*k120b, ...
+c86*kd60b - c519*k62b - c519*kd120 + c6*c158*k120b, ...
+c86*kd60b - c339*k62b + c417*kd95 - c280*c339*k95, ...
+c86*kd60b - c340*k62b + c418*kd95 - c280*c340*k95, ...
+c25*c59*k64 - c95*kd65 - c95*kd64 + c59*c99*k65, ...
+c19*c83*k64 - c96*kd65 - c96*kd64 + c83*c100*k65, ...
+c35*c59*k64 - c97*kd65 - c97*kd64 + c59*c419*k65, ...
+c66*c83*k64 - c98*kd65 - c98*kd64 + c83*c420*k65, ...
+c24*c59*k64 - c101*kd65 - c101*kd64 + c59*c103*k65, ...
+c24*c83*k64 - c102*kd65 - c102*kd64 + c83*c103*k65, ...
+c95*kd65 - c99*kd101 - c59*c99*k65 + c23*c103*k101, ...
+c97*kd65 - c419*kd101 + c34*c103*k101 - c59*c419*k65, ...
+c101*kd65 + c102*kd65 + c99*kd101 + c100*kd101 + c419*kd101 + c420*kd101 - c18*c103*k101 - c23*c103*k101 - c59*c103*k65 - c34*c103*k101 - c83*c103*k65 - c65*c103*k101, ...
+c96*kd65 - c100*kd101 + c18*c103*k101 - c83*c100*k65, ...
+c98*kd65 - c420*kd101 + c65*c103*k101 - c83*c420*k65, ...
+c104*kd66 + c261*kd66 + c262*kd67 + c263*kd66 + c324*kd67 + c405*kd67 + c408*kd66 - c287*c445*k66 - c287*c446*k67 - c287*c447*k66 - c287*c454*k67 - c287*c457*k67 - c287*c460*k66 - c287*c486*k66, ...
+c104*kd66 + c136*kd123 + c431*kd110 + c432*kd110 + c489*kd107 + c522*kd118 - c59*c486*k110 - c83*c486*k110 - c105*c486*k123 - c287*c486*k66 - c463*c486*k107 - c486*c521*k118, ...
+c264*kd112 - c104*kd66 + c264*kd113 + c448*kd68 + c448*kd106b - c26*c104*k112 - c28*c104*k113 - c104*c106*k68 - c104*c444*k106b + c287*c486*k66, ...
+c132*kd123 + c263*kd66 + c412*kd118 + c438*kd110 + c440*kd110 + c466*kd107 - c59*c447*k110 - c83*c447*k110 - c105*c447*k123 - c287*c447*k66 - c447*c463*k107 - c447*c521*k118, ...
+c267*kd112 - c263*kd66 + c267*kd113 + c451*kd68 + c451*kd106b - c26*c263*k112 - c28*c263*k113 - c106*c263*k68 + c287*c447*k66 - c263*c444*k106b, ...
+c130*kd123 + c261*kd66 + c424*kd118 + c433*kd110 + c434*kd110 + c464*kd107 - c59*c445*k110 - c83*c445*k110 - c105*c445*k123 - c287*c445*k66 - c445*c463*k107 - c445*c521*k118, ...
+c265*kd112 - c261*kd66 + c265*kd113 + c449*kd68 + c449*kd106b - c26*c261*k112 - c28*c261*k113 - c106*c261*k68 + c287*c445*k66 - c261*c444*k106b, ...
+c131*kd123 + c262*kd67 + c411*kd118 + c435*kd110 + c437*kd110 + c465*kd107 - c59*c446*k110 - c83*c446*k110 - c105*c446*k123 - c287*c446*k67 - c446*c463*k107 - c446*c521*k118, ...
+c266*kd112 - c262*kd67 + c266*kd113 + c450*kd68 + c450*kd106b - c26*c262*k112 - c28*c262*k113 - c106*c262*k68 + c287*c446*k67 - c262*c444*k106b, ...
+c133*kd123 + c324*kd67 + c473*kd107 + c474*kd110 + c475*kd110 + c523*kd118 - c59*c454*k110 - c83*c454*k110 - c105*c454*k123 - c287*c454*k67 - c454*c463*k107 - c454*c521*k118, ...
+c268*kd112 + c268*kd113 - c324*kd67 + c452*kd68 + c452*kd106 - c26*c324*k112 - c28*c324*k113 - c106*c324*k68 + c287*c454*k67 - c324*c444*k106, ...
+c134*kd123 + c405*kd67 + c456*kd118 + c476*kd107 + c477*kd110 + c478*kd110 - c59*c457*k110 - c83*c457*k110 - c105*c457*k123 - c287*c457*k67 - c457*c463*k107 - c457*c521*k118, ...
+c269*kd112 + c269*kd113 - c405*kd67 + c453*kd106 + c453*kd68b - c26*c405*k112 - c28*c405*k113 - c106*c405*k68 + c287*c457*k67 - c405*c444*k106, ...
+c135*kd123 + c408*kd66 + c407*kd118 + c479*kd107 + c480*kd110 + c481*kd110 - c59*c460*k110 - c83*c460*k110 - c105*c460*k123 - c287*c460*k66 - c460*c463*k107 - c460*c521*k118, ...
+c325*kd112 - c408*kd66 + c455*kd106 - c26*c408*k112 + c287*c460*k66 - c408*c444*k106, ...
+c108*kd69 + c111*kd76 + c448*kd68 + c449*kd68 + c450*kd68 + c451*kd68 + c452*kd68 + c495*kd69 + c462*kd109 + c482*kd109 + c453*kd68b + c467*kd68b + c468*kd68b + c469*kd68b + c470*kd68b + c471*kd68b - c104*c106*k68 - c106*c107*k69 - c106*c112*k69 - c106*c109*k76 - c106*c261*k68 - c106*c262*k68 - c106*c263*k68 - c106*c279*k109 - c106*c324*k68 - c106*c405*k68 - c106*c453*k68 - c106*c467*k68 - c106*c468*k68 - c106*c469*k68 - c106*c470*k68 - c106*c461*k109, ...
+c467*kd106 - c453*kd106 - c453*kd68b + c467*kd68b + c106*c405*k68 - c106*c453*k68 + c405*c444*k106 - c444*c453*k106, ...
+c106*c324*k68 - c452*kd106 - c452*kd68 + c324*c444*k106, ...
+c104*c106*k68 - c448*kd106b - c448*kd68 + c104*c444*k106b, ...
+c106*c261*k68 - c449*kd106b - c449*kd68 + c261*c444*k106b, ...
+c106*c262*k68 - c450*kd106b - c450*kd68 + c262*c444*k106b, ...
+c106*c263*k68 - c451*kd106b - c451*kd68 + c263*c444*k106b, ...
+c468*kd106 - c467*kd106 - c467*kd68b + c468*kd68b + c106*c453*k68 - c106*c467*k68 + c444*c453*k106 - c444*c467*k106, ...
+c469*kd106 - c468*kd106 - c468*kd68b + c469*kd68b + c106*c467*k68 - c106*c468*k68 + c444*c467*k106 - c444*c468*k106, ...
+c470*kd106 - c469*kd106 - c469*kd68b + c470*kd68b + c106*c468*k68 - c106*c469*k68 + c444*c468*k106 - c444*c469*k106, ...
+c471*kd106 - c470*kd106 - c470*kd68b + c471*kd68b + c106*c469*k68 - c106*c470*k68 + c444*c469*k106 - c444*c470*k106, ...
+c106*c470*k68 - c471*kd68b - c471*kd106 + c444*c470*k106, ...
+c108*kd69 + c114*kd75 - c106*c107*k69 - c107*c113*k75, ...
+c110*kd70 - c108*kd69 + c106*c107*k69 - c108*c109*k70, ...
+c110*kd71 + c114*kd73 + c495*kd69 + c498*kd75 - c106*c112*k69 - c111*c112*k71 - c112*c113*k73 - c112*c113*k75, ...
+c496*kd70 - c495*kd69 + c106*c112*k69 - c109*c495*k70, ...
+c110*kd70 + c111*kd76 + c496*kd70 - c108*c109*k70 - c106*c109*k76 - c109*c495*k70, ...
+c109*c495*k70 - c496*kd72 - c496*kd70 + c111*c497*k72, ...
+c108*c109*k70 - c110*kd71 - c110*kd70 + c111*c112*k71, ...
+c110*kd71 - c111*kd76 + c496*kd72 + c106*c109*k76 - c111*c112*k71 - c111*c497*k72, ...
+c496*kd72 + c498*kd74 + c472*kd114 + c472*kd115 + c484*kd114 + c484*kd115 - c45*c497*k114 - c111*c497*k72 - c72*c497*k114 - c113*c497*k74 - 2*c485*c497*k115, ...
+c114*kd73 + c114*kd75 + c498*kd74 + c498*kd75 - c107*c113*k75 - c112*c113*k73 - c112*c113*k75 - c113*c497*k74, ...
+c112*c113*k75 - c498*kd75 - c498*kd74 + c113*c497*k74, ...
+c107*c113*k75 - c114*kd75 - c114*kd73 + c112*c113*k73, ...
+c281*kd94 + c281*kd95 + c282*kd94 + c282*kd95 + c283*kd94 + c283*kd95 + c415*kd94 + c415*kd95 + c416*kd94 + c416*kd95 + c417*kd94 + c417*kd95 + c418*kd94 + c418*kd95 - c8*c280*k94 - c11*c280*k95 - c159*c280*k95 - c160*c280*k95 - c161*c280*k95 - c162*c280*k94 - c163*c280*k94b - c164*c280*k94b - c280*c290*k94 - c280*c337*k94 - c280*c338*k94 - c280*c339*k95 - c280*c340*k95 - c280*c425*k95, ...
+c160*c280*k95 - c281*kd95 - c281*kd94 + c163*c280*k94b, ...
+c161*c280*k95 - c282*kd95 - c282*kd94 + c164*c280*k94b, ...
+c8*c280*k94 - c415*kd95 - c415*kd94 + c11*c280*k95, ...
+c280*c290*k94 - c283*kd95 - c283*kd94 + c280*c425*k95, ...
+c280*c337*k94 - c417*kd95 - c417*kd94 + c280*c339*k95, ...
+c280*c338*k94 - c418*kd95 - c418*kd94 + c280*c340*k95, ...
+c159*c280*k95 - c416*kd95 - c416*kd94 + c162*c280*k94, ...
+c148*kd102 + c289*kd96 + c284*kd103 + c335*kd103 + c336*kd103 + c509*kd103 - c87^2*k96 - c87*c141*k103 - c87*c330*k102 - c87*c331*k103 - c87*c332*k103 - c87*c502*k103, ...
+c286*kd97 + c2*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c531*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - (c285*c531*kd97)/KD_iressa_wt, ...
+c5*kd102 + c148*kd102 + c149*kd102 + c150*kd102 - c330^2*k102 - c87*c330*k102 - c330*c331*k102 - c330*c332*k102, ...
+c149*kd102 + c335*kd103 - c87*c331*k103 - c330*c331*k102, ...
+c150*kd102 + c336*kd103 - c87*c332*k103 - c330*c332*k102, ...
+c87*c502*k103 - c509*kd103, ...
+c140*c502*k103 - c510*kd103, ...
+c143*c502*k103 - c511*kd103, ...
+c141*c503*k103 - c513*kd103, ...
+c462*kd104 + c462*kd109 - c106*c461*k109 - c444*c461*k104, ...
+c452*kd106 + c453*kd106 + c455*kd106 + c462*kd104 + c467*kd106 + c468*kd106 + c469*kd106 + c470*kd106 + c471*kd106 + c482*kd104 + c448*kd106b + c449*kd106b + c450*kd106b + c451*kd106b - c104*c444*k106b - c279*c444*k104 - c324*c444*k106 - c261*c444*k106b - c262*c444*k106b - c263*c444*k106b - c405*c444*k106 - c408*c444*k106 - c444*c453*k106 - c444*c461*k104 - c444*c467*k106 - c444*c468*k106 - c444*c469*k106 - c444*c470*k106, ...
+c106*c461*k109 - c462*kd109 - c462*kd104 + c444*c461*k104, ...
+c482*kd104 + c482*kd109 - c106*c279*k109 - c279*c444*k104, ...
+c106*c279*k109 - c482*kd109 - c482*kd104 + c279*c444*k104, ...
+c427*kd105 + c428*kd105 + c429*kd105 + c436*kd105 + c439*kd105 + c442*kd105 + c483*kd105 - c23*c426*k105 - c225*c426*k105 - c226*c426*k105 - c227*c426*k105 - c312*c426*k105 - c381*c426*k105 - c384*c426*k105, ...
+c408*c444*k106 - c455*kd106, ...
+c464*kd107 + c464*kd108 + c465*kd107 + c465*kd108 + c466*kd107 + c466*kd108 + c473*kd107 + c473*kd108 + c476*kd107 + c476*kd108 + c479*kd107 + c479*kd108 + c489*kd107 + c489*kd108 - c427*c463*k108 - c428*c463*k108 - c429*c463*k108 - c436*c463*k108 - c439*c463*k108 - c442*c463*k108 - c445*c463*k107 - c446*c463*k107 - c447*c463*k107 - c454*c463*k107 - c457*c463*k107 - c460*c463*k107 - c463*c483*k108 - c463*c486*k107, ...
+c427*c463*k108 - c464*kd108 - c464*kd107 + c445*c463*k107, ...
+c428*c463*k108 - c465*kd108 - c465*kd107 + c446*c463*k107, ...
+c429*c463*k108 - c466*kd108 - c466*kd107 + c447*c463*k107, ...
+c436*c463*k108 - c473*kd108 - c473*kd107 + c454*c463*k107, ...
+c439*c463*k108 - c476*kd108 - c476*kd107 + c457*c463*k107, ...
+c325*kd113 - c479*kd107 - c479*kd108 - c28*c479*k113 + c442*c463*k108 + c460*c463*k107, ...
+c463*c483*k108 - c489*kd108 - c489*kd107 + c463*c486*k107, ...
+c59*c486*k110 - c431*kd111 - c431*kd110 + c59*c488*k111, ...
+c83*c486*k110 - c432*kd111 - c432*kd110 + c83*c488*k111, ...
+c59*c430*k111 - c433*kd111 - c433*kd110 + c59*c445*k110, ...
+c83*c430*k111 - c434*kd111 - c434*kd110 + c83*c445*k110, ...
+c59*c409*k111 - c435*kd111 - c435*kd110 + c59*c446*k110, ...
+c83*c409*k111 - c437*kd111 - c437*kd110 + c83*c446*k110, ...
+c59*c410*k111 - c438*kd111 - c438*kd110 + c59*c447*k110, ...
+c83*c410*k111 - c440*kd111 - c440*kd110 + c83*c447*k110, ...
+c59*c454*k110 - c474*kd111 - c474*kd110 + c59*c490*k111, ...
+c83*c454*k110 - c475*kd111 - c475*kd110 + c83*c490*k111, ...
+c59*c457*k110 - c477*kd111 - c477*kd110 + c59*c491*k111, ...
+c83*c457*k110 - c478*kd111 - c478*kd110 + c83*c491*k111, ...
+c59*c460*k110 - c480*kd111 - c480*kd110 + c59*c487*k111, ...
+c83*c460*k110 - c481*kd111 - c481*kd110 + c83*c487*k111, ...
+c456*kd117 + c477*kd111 + c478*kd111 - c59*c491*k111 - c83*c491*k111 - c491*c521*k117, ...
+c474*kd111 + c475*kd111 + c523*kd117 - c59*c490*k111 - c83*c490*k111 - c490*c521*k117, ...
+c412*kd117 + c438*kd111 + c440*kd111 - c59*c410*k111 - c83*c410*k111 - c410*c521*k117, ...
+c411*kd117 + c435*kd111 + c437*kd111 - c59*c409*k111 - c83*c409*k111 - c409*c521*k117, ...
+c424*kd117 + c433*kd111 + c434*kd111 - c59*c430*k111 - c83*c430*k111 - c430*c521*k117, ...
+c431*kd111 + c432*kd111 + c522*kd117 - c59*c488*k111 - c83*c488*k111 - c488*c521*k117, ...
+c407*kd117 + c480*kd111 + c481*kd111 - c59*c487*k111 - c83*c487*k111 - c487*c521*k117, ...
+c26*c104*k112 - c264*kd113 - c264*kd112 + c28*c104*k113, ...
+c26*c261*k112 - c265*kd113 - c265*kd112 + c28*c261*k113, ...
+c26*c262*k112 - c266*kd113 - c266*kd112 + c28*c262*k113, ...
+c26*c263*k112 - c267*kd113 - c267*kd112 + c28*c263*k113, ...
+c26*c324*k112 - c268*kd113 - c268*kd112 + c28*c324*k113, ...
+c26*c405*k112 - c269*kd113 - c269*kd112 + c28*c405*k113, ...
+c26*c408*k112 - c325*kd113 - c325*kd112 + c28*c479*k113, ...
+c45*c497*k114 - c472*kd115 - c472*kd114 + c485*c497*k115, ...
+c72*c497*k114 - c484*kd115 - c484*kd114 + c485*c497*k115, ...
+c472*kd115 + c484*kd115 - 2*c485*c497*k115, ...
+c60*stepfunc(time, 2659.99, 0, 2660, 0.0150356) - c520*kd116, ...
+c407*kd117 + c407*kd118 + c411*kd117 + c411*kd118 + c412*kd117 + c412*kd118 + c424*kd117 + c424*kd118 + c456*kd117 + c456*kd118 + c522*kd117 + c522*kd118 + c523*kd117 + c523*kd118 - c409*c521*k117 - c410*c521*k117 - c430*c521*k117 - c445*c521*k118 - c446*c521*k118 - c447*c521*k118 - c454*c521*k118 - c457*c521*k118 - c460*c521*k118 - c486*c521*k118 - c487*c521*k117 - c488*c521*k117 - c490*c521*k117 - c491*c521*k117, ...
+c486*c521*k118 - c522*kd118 - c522*kd117 + c488*c521*k117, ...
+c454*c521*k118 - c523*kd118 - c523*kd117 + c490*c521*k117, ...
+c409*c521*k117 - c411*kd118 - c411*kd117 + c446*c521*k118, ...
+c410*c521*k117 - c412*kd118 - c412*kd117 + c447*c521*k118, ...
+c457*c521*k118 - c456*kd118 - c456*kd117 + c491*c521*k117, ...
+c430*c521*k117 - c424*kd118 - c424*kd117 + c445*c521*k118, ...
+c460*c521*k118 - c407*kd118 - c407*kd117 + c487*c521*k117, ...
+c355*kd120 - c142*kd119 + c516*kd120 - c2*c142*k120b - c141*c142*k120 + c140*c514*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c345*kd120 - c144*kd119 + c517*kd120 - c2*c144*k120b - c141*c144*k120 + c143*c514*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c422*kd120 + c519*kd120 - c6*c158*k120b - c155*c158*k120, ...
+c525*kd97c + c524*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c532*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - (c285*c532*kd97c)/KD_iressa_mt, ...
+c526*stepfunc(time, 1799.99, 0, 1800, 0.0033) - c525*kd97c - c1*c525*stepfunc(time, 1799.99, 0, 1800, 10000000) + (c285*c532*kd97c)/KD_iressa_mt, ...
+c527*kd2 + c528*kd2 + c553*kd2 + c554*kd2 - c526^2*k2 - c526*stepfunc(time, 1799.99, 0, 1800, 0.0033) - c3*c526*k2 - c499*c526*k2 - c526*c529*k2 + c1*c525*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c121*stepfunc(time, 1799.99, 0, 1800, 1) - c527*kd2 - c105*c527*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c3*c526*k2, ...
+c526^2*k2 - c528*kd2, ...
+c530*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c524*stepfunc(time, 1799.99, 0, 1800, 1) - c524*k6 + c529*stepfunc(time, 1799.99, 0, 1800, 0.0033) + c105*c532*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c1*c524*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c550*kd2 + c551*kd2 + c552*kd2 + c553*kd2 - c529^2*k2 - c529*stepfunc(time, 1799.99, 0, 1800, 0.0033) - c3*c529*k2 - c499*c529*k2 - c526*c529*k2 + c1*c524*stepfunc(time, 1799.99, 0, 1800, 10000000), ...
+c524*k6 + c10*kd10 - c530*stepfunc(time, 1799.99, 0, 1800, 0.00005) - c16*c530*k10b, ...
+c105*c500*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c115*stepfunc(time, 1799.99, 0, 1800, 1) - c115*kd123h + c5*c105*k123h, ...
+c105*c527*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c121*stepfunc(time, 1799.99, 0, 1800, 1) - c121*kd123h + c5*c105*k123h, ...
+c555*stepfunc(time, 1799.99, 0, 1800, 1) - c550*kd2 - c105*c550*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c3*c529*k2, ...
+c556*stepfunc(time, 1799.99, 0, 1800, 1) - c551*kd2 - c105*c551*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c499*c529*k2, ...
+c529^2*k2 - c552*kd2 + c557*stepfunc(time, 1799.99, 0, 1800, 1) - c105*c552*stepfunc(time, 1799.99, 0, 1800, 0.000000018704), ...
+c558*stepfunc(time, 1799.99, 0, 1800, 1) - c553*kd2 - c105*c553*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) + c526*c529*k2, ...
+c499*c526*k2 - c554*kd2, ...
+c105*c550*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c555*stepfunc(time, 1799.99, 0, 1800, 1) - c555*kd123 + c5*c105*k123, ...
+c105*c551*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c556*stepfunc(time, 1799.99, 0, 1800, 1) - c556*kd123h + c5*c105*k123h, ...
+c105*c552*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c557*stepfunc(time, 1799.99, 0, 1800, 1) - c557*kd123 + c5*c105*k123, ...
+c105*c553*stepfunc(time, 1799.99, 0, 1800, 0.000000018704) - c558*stepfunc(time, 1799.99, 0, 1800, 1) - c558*kd123h + c5*c105*k123h];
+
+%%
+% INITIALIZATION
+
+model.sym.x0 = [0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+462000, ...
+0, ...
+6230, ...
+0, ...
+794, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+1200000000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+1236601486306181/274877906944, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+534751, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+5563133012360561/4398046511104, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+3992271744873267/68719476736, ...
+0, ...
+0, ...
+0, ...
+0, ...
+1100000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+4888098843603763/68719476736, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+88914000, ...
+50000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+3020000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+124480, ...
+0, ...
+0, ...
+0, ...
+0, ...
+695000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+84351/5, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+35565600, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+905000, ...
+0, ...
+0, ...
+0, ...
+300416000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+450000, ...
+0, ...
+0, ...
+70000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+1080000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+608466986032169/274877906944, ...
+393639, ...
+0, ...
+7710448984837325/137438953472, ...
+0, ...
+6519299934833869/68719476736, ...
+0, ...
+1000000, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0, ...
+0];
+
+%% Observables
+
+% [ERB_B1_P_tot; ERK_PP; AKT_PP]
+model.sym.y = [(2*c5 + 2*c7 + 2*c8 + 2*c15 + 2*c17 + 2*c18 + 2*c19 + 2*c20 + 2*c21 + 2*c23 + 2*c25 + 2*c27 + 2*c29 + 2*c32 + 2*c33 + 2*c34 + 2*c35 + 2*c36 + 2*c37 + 2*c63 + 2*c64 + 2*c65 + 2*c66 + 2*c67 + 2*c68 + 2*c88 + 2*c89 + 2*c90 + 2*c91 + 2*c92 + 2*c93 + 2*c94 + 2*c95 + 2*c96 + 2*c97 + 2*c98 + 2*c99 + 2*c100 + 2*c104 + c130 + c131 + c132 + 2*c136 + c148 + c149 + c150 + c151 + c152 + c153 + c162 + c163 + c164 + c165 + c166 + c167 + c171 + c172 + c173 + c174 + c175 + c176 + c180 + c181 + c182 + c183 + c184 + c185 + c189 + c190 + c191 + c192 + c193 + c194 + c195 + c196 + c197 + c198 + c199 + c200 + c201 + c202 + c203 + c204 + c205 + c206 + c207 + c208 + c209 + c210 + c211 + c212 + c213 + c214 + c215 + c216 + c217 + c218 + c219 + c220 + c221 + c222 + c223 + c224 + c225 + c226 + c227 + c228 + c229 + c230 + c231 + c232 + c233 + c234 + c235 + c236 + c237 + c238 + c239 + c240 + c241 + c242 + c243 + c244 + c245 + c246 + c247 + c248 + c249 + c250 + c251 + c252 + c253 + c254 + c255 + c256 + c257 + c258 + c259 + c260 + c261 + c262 + c263 + 2*c264 + c265 + c266 + c267 + c281 + c282 + c409 + c410 + c411 + c412 + 2*c415 + c416 + 2*c419 + 2*c420 + c427 + c428 + c429 + 2*c431 + 2*c432 + c433 + c434 + c435 + c437 + c438 + c440 + c445 + c446 + c447 + 2*c448 + c449 + c450 + c451 + c464 + c465 + c466 + 2*c483 + 2*c486 + 2*c489)/EGFR_t, ...
+(c59 + c61 + c83 + c84 + c95 + c96 + c97 + c98 + c101 + c102 + c431 + c432 + c433 + c434 + c435 + c437 + c438 + c440 + c474 + c475 + c477 + c478 + c480 + c481)/ERK_t, ...
+(c472 + c484 + c497 + c498)/AKT_t];
+
+end
+
+
+
+function r = pow(x,y)
+    r = x^y;
+end
+
+
+
+function r = power(x,y)
+    r = x^y;
+end
+
+
+
+function r = stepfunc2(t,t_start,v_start,t_end,v_end)
+    r = am_piecewise(v_start,am_lt(t,t_start),v_end,am_gt(t,t_end),(v_end-v_start)/(t_end-t_start)*(t-t_start)+v_start);
+end
+
+
+
+function r = stepfunc(t,t_start,v_start,t_end,v_end)
+    r = am_piecewise(v_start,am_lt(t,t_start),am_piecewise(v_end,am_gt(t,t_end),(v_start+v_end)/2+(v_end-v_start)/2*sin(3.14/2*(2*t-t_end-t_start)/(t_end-t_start))));
+end
+
diff --git a/Requirements/PESTO-1.1.0/examples/erbb_signaling/erbb_signaling_pnom.mat b/Requirements/PESTO-1.1.0/examples/erbb_signaling/erbb_signaling_pnom.mat
new file mode 100644
index 0000000000000000000000000000000000000000..fe17bf05675fc72f241dd46d8f5a434d8e99f986
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/erbb_signaling/erbb_signaling_pnom.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/erbb_signaling/getData_ErbB_signaling.m b/Requirements/PESTO-1.1.0/examples/erbb_signaling/getData_ErbB_signaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..9964bfd2ba5df4423f2bc540660c88e5b862ff66
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/erbb_signaling/getData_ErbB_signaling.m
@@ -0,0 +1,236 @@
+function [ DD ] = getData_ErbB_signaling()
+% getData_erbb_signaling.m for examples/Chen2009
+%
+% getData_erbb_signaling.m provides measurement data for the parameter 
+% estimation of the erbb_signaling example file. 
+%
+% Parameters:
+%  void
+%
+% Return values:
+%  D: struct, containing the time-points of measurement, the measured Data, 
+%      the variance and the initial conditions
+
+
+
+%% Write measured data into a table
+% Cell line: A431
+
+% pAkt
+M = [...
+    0	0	0;...
+    2.5	0	0;...
+    5	24	0.26;...
+    7.5	34	0.59;...
+    10	40	2.2;...
+    15	50	2;...
+    30	64	1.4;...
+    45	52	3.4;...
+    60	49	2.2;...
+    1.2e+02	57	7.3;...
+    ];
+
+D(1).t = M(:,1)*60+1800; % minutes -> sec + preequi
+D(1).condition = [5e-9,0,0,0];
+D(1).Y(:,3) = M(:,2);
+D(1).Sigma_Y(:,3) = M(:,3);
+
+% pErbB1
+M= [...
+    0	0	0;...
+    2.5	65	7.3;...
+    5	72	6.7;...
+    7.5	75	8.8;...
+    10	77	4.6;...
+    15	83	4.6;...
+    30	87	2.4;...
+    45	98	2.3;...
+    60	87	13;...
+    1.2e+02	86	13;...
+    ];
+
+D(1).Y(:,1) = M(:,2);
+D(1).Sigma_Y(:,1) = M(:,3);
+
+% pERK
+M = [...
+    0	0	0;...
+    2.5	60	0.36;...
+    5	88	1.8;...
+    7.5	97	1.4;...
+    10	98	1.1;...
+    15	86	3;...
+    30	65	2.7;...
+    45	56	2.8;...
+    60	50	3.6;...
+    1.2e+02	46	1.4;...
+    ];
+
+D(1).Y(:,2) = M(:,2);
+D(1).Sigma_Y(:,2) = M(:,3);
+
+% pAkt
+M = [...
+    0	0	0;...
+    2.5	45	4.6;...
+    5	79	3.1;...
+    7.5	86	4.5;...
+    10	97	3.1;...
+    15	91	2.8;...
+    30	85	2.7;...
+    45	72	2.5;...
+    60	73	1.7;...
+    1.2e+02	68	2.2;...
+    ];
+
+D(2).t = M(:,1)*60+1800; % minutes -> sec + preequi
+D(2).condition = [0,0,0,5e-9];
+D(2).Y(:,3) = M(:,2);
+D(2).Sigma_Y(:,3) = M(:,3);
+
+% pErbB1
+M= [...
+    0	0	0;...
+    2.5	0	0;...
+    5	0	0;...
+    7.5	0	0;...
+    10	0	0;...
+    15	0	0;...
+    30	0	0;...
+    45	0	0;...
+    60	0	0;...
+    1.2e+02	0	0;...
+    ];
+
+D(2).Y(:,1) = M(:,2);
+D(2).Sigma_Y(:,1) = M(:,3);
+
+% pERK
+M = [...
+    0	0	0;...
+    2.5	9.7	3.3;...
+    5	46	6.7;...
+    7.5	58	1.8;...
+    10	54	3.9;...
+    15	26	4.2;...
+    30	27	2.6;...
+    45	24	1.1;...
+    60	23	0.84;...
+    1.2e+02	17	2.2;...
+    ];
+
+D(2).Y(:,2) = M(:,2);
+D(2).Sigma_Y(:,2) = M(:,3);
+
+% pAkt
+M = [...
+    0	0	0;...
+    2.5	1.7	0.88;...
+    5	44	11;...
+    7.5	43	5.5;...
+    10	50	3;...
+    15	45	4.4;...
+    30	35	5;...
+    45	40	14;...
+    60	28	9.6;...
+    1.2e+02	28	5.5;...
+    ];
+
+D(3).t = M(:,1)*60+1800; % minutes -> sec + preequi
+D(3).condition = [1e-11,0,0,0];
+D(3).Y(:,3) = M(:,2);
+D(3).Sigma_Y(:,3) = M(:,3);
+
+% pErbB1
+M= [...
+    0	0	0;...
+    2.5	0	0;...
+    5	0	0;...
+    7.5	0	0;...
+    10	0	0;...
+    15	0	0;...
+    30	0	0;...
+    45	0	0;...
+    60	0	0;...
+    1.2e+02	0	0;...
+    ];
+
+D(3).Y(:,1) = M(:,2);
+D(3).Sigma_Y(:,1) = M(:,3);
+
+% pERK
+M = [...
+    0	0	0;...
+    2.5	8.8	2.2;...
+    5	43	8.8;...
+    7.5	46	5.7;...
+    10	40	3.2;...
+    15	26	2.4;...
+    30	27	0.28;...
+    45	18	3.5;...
+    60	11	2.4;...
+    1.2e+02	2.7	0.65;...
+    ];
+
+D(3).Y(:,2) = M(:,2);
+D(3).Sigma_Y(:,2) = M(:,3);
+
+% pAkt
+M = [...
+    0	0	0;...
+    2.5	1.7	0.88;...
+    5	44	11;...
+    7.5	43	5.5;...
+    10	50	3;...
+    15	45	4.4;...
+    30	35	5;...
+    45	40	14;...
+    60	28	9.6;...
+    1.2e+02	28	5.5;...
+    ];
+
+D(4).t = M(:,1)*60+1800; % minutes -> sec + preequi
+D(4).condition = [0,0,0,1e-10];
+D(4).Y(:,3) = M(:,2);
+D(4).Sigma_Y(:,3) = M(:,3);
+
+% pErbB1
+M= [...
+    0	0	0;...
+    2.5	0	0;...
+    5	0	0;...
+    7.5	0	0;...
+    10	0	0;...
+    15	0	0;...
+    30	0	0;...
+    45	0	0;...
+    60	0	0;...
+    1.2e+02	0	0;...
+    ];
+
+D(4).Y(:,1) = M(:,2);
+D(4).Sigma_Y(:,1) = M(:,3);
+
+% pERK
+M = [...
+    0	0	0;...
+    2.5	8.8	2.2;...
+    5	43	8.8;...
+    7.5	46	5.7;...
+    10	40	3.2;...
+    15	26	2.4;...
+    30	27	0.28;...
+    45	18	3.5;...
+    60	11	2.4;...
+    1.2e+02	2.7	0.65;...
+    ];
+
+D(4).Y(:,2) = M(:,2);
+D(4).Sigma_Y(:,2) = M(:,3);
+
+for iD = 1:length(D)
+    D(iD).Sigma_Y = D(iD).Sigma_Y + 0.1*ones(size(D(iD).Sigma_Y));
+    DD(iD) = amidata(D(iD));
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/erbb_signaling/logLikelihoodErbBSignaling.m b/Requirements/PESTO-1.1.0/examples/erbb_signaling/logLikelihoodErbBSignaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..be151fa7141297c4746a9423fb4b598eb765ed31
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/erbb_signaling/logLikelihoodErbBSignaling.m
@@ -0,0 +1,58 @@
+function varargout = logLikelihoodErbBSignaling(theta, D)
+% Objective function for examples/erbb_signaling
+%
+% logLikelihoodErbBSignaling.m provides the log-likelihood and its gradient 
+% for the model defined in erbb_signaling_pesto_syms.m
+% 
+% USAGE:
+% [llh] = logLikelihoodErbBSignaling(theta, amiData)
+% [llh, sllh] = logLikelihoodErbBSignaling(theta, amiData)
+%
+% Parameters:
+%  theta: Model parameters 
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no 
+%         sensitivity analysis is performed
+%     sllh: Gradient of llh, The LogLikelihood and its gradient will be 
+%         returned, first order adjoint sensitivity analysis is performed
+
+
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see erbb_signaling_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% papers on the ErbB signaling pathways by Chen et al.
+
+%% AMICI
+% Setting the options for the AMICI solver
+optionsAmici = amioption;
+optionsAmici.atol = 1e-8;
+optionsAmici.maxsteps = 2e5;
+optionsAmici.interpType = 2;
+
+if(nargout > 1)
+    optionsAmici.sensi = 1;
+    optionsAmici.sensi_meth = 'adjoint';
+    sol = simulate_erbb_pesto(D.t, theta, D.condition, D, optionsAmici);
+    if(sol.status < 0)
+        error('integration error');
+    else
+        varargout{1} = sol.llh;
+        varargout{2} = sol.sllh;
+    end
+else
+    optionsAmici.sensi = 0;
+    sol = simulate_erbb_pesto(D.t, theta, D.condition, D, optionsAmici);
+    if(sol.status<0)
+        error('integration error');
+    else
+        varargout{1} = sol.llh;
+    end
+end
+    
+end
+
diff --git a/Requirements/PESTO-1.1.0/examples/erbb_signaling/mainErbBSignaling.m b/Requirements/PESTO-1.1.0/examples/erbb_signaling/mainErbBSignaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..986d4fbc330bb883c97f406a3c1289e1e16101aa
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/erbb_signaling/mainErbBSignaling.m
@@ -0,0 +1,94 @@
+% Main file of the erbb_signaling example
+%
+% Demonstrates the use of:
+% * getMultiStarts()
+%
+% This example is a rather big biological model. It is included here to 
+% show the ability of PESTO to handle ODE-based models with some hundred 
+% state variables and some hundred parameters. This model is taken from the
+% paper "Input-output behavior of ErbB signaling pathways as revealed by a 
+% mass action model trained against dynamic data", by Chen et al., in 2009,
+% PubMed, vol.5, no.239 (see https://www.ncbi.nlm.nih.gov/pubmed/19156131).
+%
+% The data used is measurement data provided in the publication.
+%
+% This file performs a multistart local optimization based on measured data 
+% from the referenced papers, demonstrating the use of getMultiStarts().
+
+
+
+%% Preliminary
+% Clean up
+
+clear all;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed random number generator
+rng(0);
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see erbb_signaling_pesto_syms.m
+% For a detailed description of the biological model see the referenced
+% papers on the ErbB signaling pathways by Chen et al.
+
+[exdir,~,~] = fileparts(which('mainErbBSignaling.m'));
+try
+    amiwrap('erbb_pesto', 'erbb_signaling_pesto_syms', exdir);
+catch ME
+    warning('There was a problem with the AMICI toolbox (available at https://github.com/ICB-DCM/AMICI), which is needed to run this example file. The original error message was:');
+    rethrow(ME);
+end
+
+%% Data
+% Experimental data is read out and written to an AMICI-data object which 
+% is used for the ODE integration
+
+load('erbb_signaling_pnom.mat');
+D = getData_ErbB_signaling();
+
+%% Generation of the structs and options for PESTO
+% The structs and the PestoOptions object, which are necessary for the 
+% PESTO routines to work are created and set to convenient values
+
+% Set the best value of theta
+theta = log10(pnom);
+theta(isinf(theta)) = log10(eps);
+
+% Write the parameters struct
+parameters.min = theta - 2;
+parameters.max = theta + 3;
+parameters.number = length(theta);
+
+% Set the PESTO-options
+optionsMultistart           = PestoOptions();
+optionsMultistart.n_starts  = 5;
+optionsMultistart.comp_type = 'sequential';
+optionsMultistart.mode      = 'text';
+optionsMultistart.localOptimizerOptions = optimset('Algorithm','interior-point',...
+    'GradObj', 'on',...
+    'Display', 'iter', ...
+    'MaxIter', 1000,...
+    'TolFun', 0,...
+    'TolX', 1e-10,...
+    'MaxFunEvals', 2000);
+
+% Set the objective function
+objectiveFunction = @(theta) logLikelihoodErbBSignaling(theta, D(1));
+
+%% Perform Multistart optimization
+% A multi-start local optimization is performed within the bound defined in
+% parameters.min and .max in order to infer the unknown parameters from 
+% measurement data.
+
+% REMARK: The problem is rather intermediate to large-scale, each 
+% evaluation of the objective function takes a while, parameter space is
+% high dimensional. Hence, optimization takes a while (up to some hours)
+% for this example.
+fprintf('\n Perform optimization...');
+parameters_adjoint = getMultiStarts(parameters, objectiveFunction, optionsMultistart);
diff --git a/Requirements/PESTO-1.1.0/examples/examples_documentation.md b/Requirements/PESTO-1.1.0/examples/examples_documentation.md
new file mode 100644
index 0000000000000000000000000000000000000000..97542e7ef7a7736c91ed2796548e90895faa5f3d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/examples_documentation.md
@@ -0,0 +1,58 @@
+Examples
+========
+
+# Examples {#examples}
+
+## Overview {#overview}
+
+PESTO comes with a number of ready-to-run examples to demonstrate its usage and functionality. The examples mostly stem from computational biology and 
+comprise ordinary and partial differential equation (ODE / PDE), and Gaussian mixture models. 
+More background information is provided in the respective example folder in the `main*.m` script.
+The three first example files toghether demonstrate basically all features and tools of PESTO.
+
+The following examples are included: 
+* *Conversion reaction*, the simplest example and demonstrating most of the PESTO features (`examples/conversion_reaction/mainConversionReaction.m`, ODE)
+* *mRNA transfection*, another very simple example, also demonstrating many of the PESTO features (`examples/mRNA_transfection/mainTransfection.m`, ODE)
+* *Enzymatic catalysis*, the third small example case, also demonstrating a variety of the PESTO features (`examples/enzymatic_catalysis/mainEnzymaticCatalysis.m`, ODE)
+* *Gaussian mixture*, a benchmark model for the MCMC sampling routines in PESTO (`examples/GaussExample/mainExampleGauss.m`)
+* *Hyperring*, a second benchmark model (with non-identifiabilities) for the MCMC sampling routines in PESTO, (`examples/RingExample/mainExampleRing.m`)
+* *Pom1p gradient formation*, a PDE problem which is discretized in space and reformulated as ODE § (`examples/Pom1p_gradient_formation/mainPom1.m`, PDE)
+* *Jak-Stat-signaling*, a challenging example for the optimization routines in PESTO, § (`examples/jakstat_signaling/mainJakstatSignaling.m`, ODE)
+* *ERBB signaling*, largest model among the examples § (`examples/erbb_signaling/mainErbBSignaling.m`, ODE)
+
+§ These models require the freely available AMICI toolbox to run (http://icb-dcm.github.io/AMICI/).
+
+The following table provides an overview of which of the PESTO functions are demonstrated in the different examples: 
+ 
+|                           | conversion reaction | enzymatic catalysis | Gaussian mixture | Hyperring | transfection | Pom1p | JakStat | ErbB |
+|:-------------------------:|:-------------------:|:-------------------:|:----------------:|:---------:|:------------:|:-----:|:-------:|:----:|
+| getMultiStarts()          |          X          |           X         |                  |     X     |      X       |   X   |    X    |  X   |
+| plotMultiStarts()         |          X          |           X         |                  |     X     |      X       |   X   |    X    |  X   |
+| plotMultiStartDiagnosis() |                     |           X         |                  |           |              |       |         |      |
+| getParameterProfiles()    |          X          |           X         |                  |     X     |      X       |       |    X    |      |
+| plotParameterProfiles()   |          X          |           X         |                  |     X     |      X       |       |    X    |      |
+| getParameterSamples()     |          X          |           X         |          X       |     X     |      X       |       |         |      |
+| plotParameterSamples()    |          X          |           X         |          X       |     X     |      X       |       |         |      |
+| plotMCMCdiagnosis()       |                     |           X         |          X       |           |              |       |         |      |
+| getParameterConfidenceIntervals() |  X          |           X         |                  |     X     |      X       |       |         |      |
+| plotConfidenceIntervals() |          X          |           X         |                  |     X     |      X       |       |         |      |
+| getPropertyMultiStarts()  |          X          |                     |                  |     X     |      X       |       |         |      |
+| plotPropertyMultiStarts() |          X          |                     |                  |     X     |      X       |       |         |      |
+| getPropertyProfiles()     |          X          |                     |                  |           |      X       |       |         |      |
+| plotPropertyProfiles()    |          X          |                     |                  |           |      X       |       |         |      |
+| getPropertySamples()      |          X          |                     |                  |     X     |      X       |       |         |      |
+| plotPropertySamples()     |          X          |                     |                  |     X     |      X       |       |         |      |
+| getPropertyConfidenceIntervals() |   X          |                     |                  |           |      X       |       |         |      |
+| testGradient()            |                     |                     |                  |           |              |       |         |      |
+| collectResults()          |                     |                     |                  |           |              |       |         |      |
+
+In addition to the principal routines, the examples also highlight how analysis results may look like in certain situations (especially in the case of modelling related problems), or how the results from the PESTO routines can be manipulated (the following list is of course non-exhaustive):
+* *multi-modal posterior distributions* (transfection and Gaussian mixture)
+* *structurally non-identifiable parameters* (Hyperring, transfection, jakstat)
+* *practically non-identifiable parameters* (enzymatic catalysis, jakstat)
+* *analysis of sampling results and Markov chain properties* (enzymatic catalysis, Gaussian mixture, and Hyperring)
+* *cutting off burn-in phase of Markov chain after sampling* (transfection)
+* *advanced usage of PESTO plotting routines* (Gaussian mixture)
+* *integration of profile likelihoods* (enzymatic catalysis, transfection, jakstat)
+* *usage of non-default sampling algorithms* (transfection, Gaussian mixture, Hyperring)
+* *using parallelization* (enzymatic catalysis, transfection, jakstat)
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/jakstat_signaling/compare_optimization_methods.mat b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/compare_optimization_methods.mat
new file mode 100644
index 0000000000000000000000000000000000000000..cdb0f8cdccfb71571ae9b65d89b7942b911ca2b6
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/compare_optimization_methods.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/jakstat_signaling/jakstat_pesto_syms.m b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/jakstat_pesto_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..c490bdc92d6dcb20c81ec11c8f947f1c0d3bf173
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/jakstat_pesto_syms.m
@@ -0,0 +1,64 @@
+function [model] = jakstat_pesto_syms()
+% jakstat_pesto_syms for examples/jakstat_signaling
+%
+% creates an amimodel-object for the AMICI solver
+%
+% Parameters: 
+% 
+% Return values:
+%  model: amimodel object
+
+
+
+%% States
+syms STAT pSTAT pSTAT_pSTAT npSTAT_npSTAT nSTAT1 nSTAT2 nSTAT3 nSTAT4 nSTAT5
+
+model.sym.x = [
+    STAT, pSTAT, pSTAT_pSTAT, npSTAT_npSTAT, nSTAT1, nSTAT2, nSTAT3, nSTAT4, nSTAT5 ...
+    ];
+
+%% Parameters
+syms p1 p2 p3 p4 init_STAT Omega_cyt Omega_nuc sp1 sp2 sp3 sp4 sp5 offset_tSTAT offset_pSTAT scale_tSTAT scale_pSTAT sigma_pSTAT sigma_tSTAT sigma_pEpoR
+
+model.sym.p = [p1,p2,p3,p4,init_STAT,sp1,sp2,sp3,sp4,sp5,offset_tSTAT,offset_pSTAT,scale_tSTAT,scale_pSTAT,sigma_pSTAT,sigma_tSTAT,sigma_pEpoR];
+model.param = 'log10';
+model.sym.k = [Omega_cyt,Omega_nuc];
+
+%% Inputs
+syms t
+
+u(1) = am_spline_pos(t, 5, 0.0, sp1, 5.0, sp2, 10.0, sp3, 20.0, sp4, 60.0, sp5, 0, 0.0);
+
+%% Right hand side of the ODE
+model.sym.xdot = sym(zeros(size(model.sym.x)));
+
+model.sym.xdot(1) = (Omega_nuc*p4*nSTAT5 - Omega_cyt*STAT*p1*u(1))/Omega_cyt;
+model.sym.xdot(2) = STAT*p1*u(1) - 2*p2*pSTAT^2;
+model.sym.xdot(3) = p2*pSTAT^2 - p3*pSTAT_pSTAT;
+model.sym.xdot(4) = -(Omega_nuc*p4*npSTAT_npSTAT - Omega_cyt*p3*pSTAT_pSTAT)/Omega_nuc;
+model.sym.xdot(5) = -p4*(nSTAT1 - 2*npSTAT_npSTAT);
+model.sym.xdot(6) = p4*(nSTAT1 - nSTAT2);
+model.sym.xdot(7) = p4*(nSTAT2 - nSTAT3);
+model.sym.xdot(8) = p4*(nSTAT3 - nSTAT4);
+model.sym.xdot(9) = p4*(nSTAT4 - nSTAT5);
+
+%% Initial concentrations
+model.sym.x0 = sym(zeros(size(model.sym.x)));
+
+model.sym.x0(1) = init_STAT;
+
+%% Observables
+model.sym.y = sym(zeros(3,1));
+
+model.sym.y(1) = offset_pSTAT + scale_pSTAT/init_STAT*(pSTAT + 2*pSTAT_pSTAT);
+model.sym.y(2) = offset_tSTAT + scale_tSTAT/init_STAT*(STAT + pSTAT + 2*(pSTAT_pSTAT));
+model.sym.y(3) = u(1);
+
+%% Variances
+model.sym.sigma_y = sym(size(model.sym.y));
+
+model.sym.sigma_y(1) = sigma_pSTAT;
+model.sym.sigma_y(2) = sigma_tSTAT;
+model.sym.sigma_y(3) = sigma_pEpoR;
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/jakstat_signaling/logLikelihoodJakstat.m b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/logLikelihoodJakstat.m
new file mode 100644
index 0000000000000000000000000000000000000000..a9d26ed71c2c7324d5cf1989d240830960356b99
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/logLikelihoodJakstat.m
@@ -0,0 +1,62 @@
+function varargout = logLikelihoodJakstat(theta, amiData)
+% Objective function for examples/jakstat_signaling
+%
+% logLikelihoodJakstat.m provides the log-likelihood, its gradient and an 
+% the Hessian matrix for the model for the JakStat signaling pathway as
+% defined in jakstat_pesto_syms.m
+% 
+% USAGE:
+% [llh] = logLikelihoodJakstat(theta, amiData)
+% [llh, sllh] = logLikelihoodJakstat(theta, amiData)
+% [llh, sllh, s2llh] = logLikelihoodJakstat(theta, amiData)
+%
+% Parameters:
+%  theta: Model parameters 
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no 
+%         sensitivity analysis is performed
+%     sllh: Gradient of llh, The LogLikelihood and its gradient will be 
+%         returned, first order adjoint sensitivity analysis is performed
+%     s2llh: Hessian of llh, The LogLikelihood, its gradient and the 
+%         Hessian matrix will be returned, second order adjoint sensitivity 
+%         analysis is performed
+
+
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see jakstat_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% papers on the JakStat signaling pathway by Swameye et al. and Schelker et
+% al.
+
+    %% AMICI
+    % Setting the options for the AMICI solver
+
+    amiOptions.rtol = 1e-12;
+    amiOptions.atol = 1e-14;
+    amiOptions.sensi_meth = 'adjoint';
+
+    %% Objective Function Evaluation
+    % Assignment
+    if (nargout == 1)
+        amiOptions.sensi = 0;
+        sol = simulate_jakstat_pesto([], theta, amiData.condition, amiData, amiOptions);
+        varargout{1} = sol.llh;  
+    elseif (nargout == 2)
+        amiOptions.sensi = 1;
+        sol = simulate_jakstat_pesto([], theta, amiData.condition, amiData, amiOptions);
+        varargout{1} = sol.llh;
+        varargout{2} = sol.sllh;
+    elseif (nargout == 3)
+        amiOptions.sensi = 2;
+        sol = simulate_jakstat_pesto([], theta, amiData.condition, amiData, amiOptions);
+        varargout{1} = sol.llh;
+        varargout{2} = sol.sllh;
+        varargout{3} = sol.s2llh;
+    end
+    
+end
diff --git a/Requirements/PESTO-1.1.0/examples/jakstat_signaling/logLikelihoodJakstatLsqnonlin.m b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/logLikelihoodJakstatLsqnonlin.m
new file mode 100644
index 0000000000000000000000000000000000000000..61ef62844a77dd3d225fcc5b3fd97699660e18d9
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/logLikelihoodJakstatLsqnonlin.m
@@ -0,0 +1,76 @@
+function varargout = logLikelihoodJakstatLsqnonlin(theta, amiData)
+% Objective function for examples/rafmekerk_signaling
+%
+% logLikelihoodJakstatLsqnonlin.m provides the residuals, their Jacobian 
+% and the log-likelihood for the model for the JakStat signaling pathway 
+% as defined in jakstat_pesto_syms.m
+% 
+% USAGE:
+% [res] = logLikelihoodJakstatLsqnonlin(theta, amiData)
+% [res, sres] = logLikelihoodJakstatLsqnonlin(theta, amiData)
+% [res, ~, llh] = logLikelihoodJakstatLsqnonlin(theta, amiData)
+%
+% Parameters:
+%  theta: Model parameters 
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     res: residuals of simulation vs data
+%     sres: Jacobian of the residuals, i.e. partial derivatives of the
+%         residuals w.r.t. to model parameters
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no 
+%         sensitivity analysis is performed
+
+
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see jakstat_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% papers on the JakStat signaling pathway by Swameye et al. and Schelker et
+% al.
+
+    nPar = 17;
+    nTime = 16;
+    nObs = 3;
+    
+    %% AMICI
+    % Setting the options for the AMICI solver
+    amiOptions = amioption();
+    amiOptions.rtol = 1e-9;
+    amiOptions.atol = 1e-12;
+    amiOptions.sensi_meth = 'forward';
+    if (nargout == 2)
+        % If sensitivities are requested
+        amiOptions.sensi = 1;
+    else
+        % If only residuals or the likelihood is requested
+        amiOptions.sensi = 0;
+    end
+    
+    % Run simulation
+    sol = simulate_jakstat_pesto(amiData.t, theta, amiData.condition, amiData, amiOptions);
+    
+    % Set residuals
+    nanIndex = isnan(amiData.Y(:));
+    res = (sol.y(:) - amiData.Y(:)) ./ sol.sigmay(:);
+    res(nanIndex) = 0;
+    res_sigma = sqrt(log(2*pi*sol.sigmay(:).^2) - log(2*pi*10^(-5)^2));
+    res_sigma_tmp = res_sigma;
+    res_sigma_tmp(nanIndex) = 0;
+    varargout{1} = [res; res_sigma_tmp];
+    
+    if (nargout == 2)
+        sres1 = ((1 ./ sol.sigmay(:)) * ones(1,nPar)) .* reshape(sol.sy, nTime*nObs, nPar);
+        sres2 = (((sol.y(:) - amiData.Y(:)) ./ sol.sigmay(:).^2) * ones(1,nPar)) .* reshape(sol.ssigmay, nTime*nObs, nPar);
+        sres3 = ((1 ./ (res_sigma .* sol.sigmay(:))) * ones(1,nPar)) .* reshape(sol.ssigmay, nTime*nObs, nPar);
+        sres = [sres1 - sres2; sres3];
+        sres([nanIndex; nanIndex], :) = 0;
+        varargout{2} = sres;
+    elseif (nargout == 3)
+        varargout{2} = [];
+        varargout{3} = sol.llh;
+    end
+    
+end
diff --git a/Requirements/PESTO-1.1.0/examples/jakstat_signaling/mainJakstatSignaling.m b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/mainJakstatSignaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..deafd034fd16a44f9639356313bebf073b8f7665
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/jakstat_signaling/mainJakstatSignaling.m
@@ -0,0 +1,209 @@
+% Main file of the JakStat signaling example
+%
+% Demonstrates the use of:
+% * getMultiStarts()
+% * getParameterProfiles()
+%
+% Demostrates furhtermore
+% * how to implement a user-supplied guess for intial parameters
+% * that non-evaluable points in parameter space can occur
+% * how different optimization methods perform (multi-start local, hybrid,
+%   global) -> Not necessary to perform computations, data-sheet is in this
+%   folder and can be loaded (comparison_optimization_methods.mat)
+% * how providing Hessians can improve optimization
+% * how to use profile calculation in hybrid mode on a complex example
+% * how to use parallelization
+%
+% This example provides a model for the JakStat signaling pathway with an
+% time resolved input of the drug EPO. The model has been taken from the
+% papers "Identification of nucleocytoplasmic cycling as a remote sensor in 
+% cellular signaling by databased modeling" by Swameye et al. in 2003, 
+% PNAS, vol.100, no.3 (see http://www.pnas.org/content/100/3/1028.long) and
+% "Comprehensive estimation of input signals and dynamics in biochemical 
+% reaction networks" by Schelker et al. in 2012, Bioinformatics, vol.28 
+% (see http://bioinformatics.oxfordjournals.org/content/28/18/i529.full).
+%
+% The data used is measurement data provided in the publications.
+%
+% This file performs a multistart local optimization based on measured data 
+% from the referenced papers, demonstrating the use of getMultiStarts().
+
+
+%% Preliminary
+
+clear;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed random number generator
+rng(0);
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see jakstat_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% papers on the JakStat signaling pathway by Swameye et al. and Schelker et
+% al.
+
+[exdir,~,~]=fileparts(which('mainJakstatSignaling.m'));
+try
+    amiwrap('jakstat_pesto','jakstat_pesto_syms', exdir, 1);
+catch ME
+    warning('This PESTO example uses the AMICI toolbox (available at https://github.com/ICB-DCM/AMICI). Unfortunately, there was a problem with AMICI when trying to run this example file. Please check if AMICI is properly installed to run this example. The original error message was:');
+    rethrow(ME);
+end
+
+%% Data
+% Experimental data is read out from an .xls-file and written to an AMICI
+% object which is used for the ODE integration
+datatable         = xlsread(fullfile(exdir,'pnas_data_original.xls'));
+amiData.t         = datatable(:,1);       % time points
+amiData.Y         = datatable(:,[2,4,6]); % measurement
+amiData.condition = [1.4,0.45];           % initial conditions
+amiData.Sigma_Y   = NaN(size(amiData.Y)); % preallocation of variances
+amiData           = amidata(amiData);     % calling the AMICI routine
+
+%% Generation of the structs and options for PESTO
+% The structs and the PestoOptions object, which are necessary for the 
+% PESTO routines to work are created and set to convenient values
+
+% parameters
+parameters.min     = -5 * ones(17,1);
+parameters.max     =  3 * ones(17,1);
+parameters.max(4)  =  6;
+parameters.max(2)  =  6;
+parameters.min(10) = -6;
+parameters.min(4)  = -3;
+parameters.min(2)  = -3;
+parameters.number  = length(parameters.min);
+parameters.name    = {'log_{10}(p1)','log_{10}(p2)','log_{10}(p3)','log_{10}(p4)','log_{10}(init_{STAT})',...
+    'log_{10}(sp1)','log_{10}(sp2)','log_{10}(sp3)','log_{10}(sp4)','log_{10}(sp5)',...
+    'log_{10}(offset_{tSTAT})','log_{10}(offset_{pSTAT})','log_{10}(scale_{tSTAT})','log_{10}(scale_{pSTAT})',...
+    'log_{10}(\sigma_{pSTAT})','log_{10}(\sigma_{tSTAT})','log_{10}(\sigma_{pEpoR})'};
+
+% Initial guess for the parameters
+par0 = bsxfun(@plus,parameters.min,bsxfun(@times,parameters.max ...
+       - parameters.min, lhsdesign(50,parameters.number,'smooth','off')'));
+parameters.guess = par0(:,1:50);
+
+% objective function
+objectiveFunction = @(theta) logLikelihoodJakstat(theta, amiData);
+
+% PestoOptions
+optionsPesto          = PestoOptions();
+optionsPesto.trace    = true;
+optionsPesto.proposal = 'user-supplied';
+optionsPesto.obj_type = 'log-posterior';
+optionsPesto.mode     = 'visual';
+
+%% Perform optimization
+% A parameters optimization is performed within the bound defined in
+% parameters.min and .max in order to infer the unknown parameters from 
+% measurement data.
+
+% REMARK: The optimization in this case is rather challenging and the
+% box constraints in the parameter space are set generously. So
+% optimization will encounter many points in which the ODE can not be
+% evaluated, leading to warnings of the ODE simulator AMICI. This is
+% expected behavior and no bug. It demonstrates paramter estimation for
+% a complicated example.
+
+% Different parameter optimization methods are compared with each other.
+% The uncommented version is a simple multi-start local optimization.
+% A version with a hybrid optimization technique (MEIGO-ESS) is also
+% implemented and commented, as well as a purely global optimization scheme
+% (PSwarm). The two alternative (and global) optimization methods are run
+% three times, to ensure that the found optimum is indeed the global one.
+
+
+% Multi-start local optimization part (fmincon)
+% optionsPesto.n_starts = 25;
+% optionsPesto.localOptimizer = 'fmincon';
+% optionsPesto.localOptimizerOptions = optimset(...
+%     'Algorithm', 'interior-point',...
+%     'GradObj', 'on',...
+%     'Display', 'iter', ... 'Hessian', 'on', ... uncomment this to use the Hessian for optimization 
+%     'MaxIter', 1000,...
+%     'TolFun', 1e-10,...
+%     'MaxFunEvals', 1000*parameters.number);
+
+% Multi-start local optimization part (lsqnonlin)
+optionsPesto.n_starts = 25;
+optionsPesto.localOptimizer = 'lsqnonlin';
+optionsPesto.obj_type = 'log-posterior';
+optionsPesto.localOptimizerOptions  = optimset(...
+    'Algorithm', 'trust-region-reflective',...
+    'MaxIter', 1000,...
+    'TolFun', 1e-10,...
+    'GradObj', 'on', ...
+    'Display', 'off', ...
+    'Jacobian', 'on', ...
+    'TolX', 1e-12,...
+    'TolGrad', 1e-6, ...
+    'PrecondBandWidth', Inf,...
+    'MaxFunEvals', 2000*parameters.number);
+objectiveFunction = @(theta) logLikelihoodJakstatLsqnonlin(theta, amiData);
+    
+% % Hybrid-type optimization part (requires the MEIGO toolbox)
+% % (Install MEIGO from http://gingproc.iim.csic.es/meigom.html and
+% % uncomment):
+%
+% optionsPestoHybrid.obj_type = 'log-posterior';
+% optionsPestoHybrid.localOptimizer = 'meigo-ess';
+% optionsPestoHybrid.n_starts = 10;
+% MeigoOptions = struct(...
+%     'maxeval', 2e4, ...
+%     'local', struct('solver', 'fmincon', ...
+%     'finish', 'fmincon', ...
+%     'iterprint', 1) ...
+%     );
+% optionsPestoHybrid.localOptimizerOptions = MeigoOptions;
+
+% % Global optimization part (requires the PSwarm toolbox)
+% % (Install from http://www.norg.uminho.pt/aivaz/pswarm/ and uncomment)
+% optionsPestoGlobal = optionsPesto.copy;
+% optionsPestoGlobal.localOptimizer = 'pswarm';
+% optionsPestoGlobal.localOptimizerOptions.MaxObj  = 10000;
+
+% The example can also be run in parallel mode: Uncomment the following, if wanted
+% optionsPesto.comp_type = 'parallel'; 
+% optionsPesto.mode = 'text';
+% % optionsPesto.save = true; 
+% optionsPesto.foldername = 'results';
+% n_workers = 10;
+
+if strcmp(optionsPesto.comp_type, 'parallel') && (n_workers >= 2)
+    parpool(n_workers); 
+else
+    optionsPesto.comp_type = 'sequential';
+end
+    
+% Run getMultiStarts
+fprintf('\n Perform optimization...');
+parametersMultistart = getMultiStarts(parameters, objectiveFunction, optionsPesto);
+% parametersHybrid = getMultiStarts(parameters, objectiveFunction, optionsPestoHybrid);
+% parametersGlobal = getMultiStarts(parameters, objectiveFunction, optionsPestoGlobal);
+
+
+%% Perform uncertainty analysis
+% The uncertainty of the estimated parameters is visualized by computing
+% and plotting profile likelihoods. Different mathod can be used.
+
+% Use the hybrid approach for profiles: uncomment this, if wanted
+% optionsPesto.profile_method = 'integration';
+
+% Profile likelihood calculation
+optionsPesto.parameter_index = [2, 3, 5, 9, 10, 11, 12, 15];
+parametersMultistart = getParameterProfiles(parametersMultistart, objectiveFunction, optionsPesto);
+
+
+%% Cleaning up
+
+% Close parpool
+if strcmp(optionsPesto.comp_type, 'parallel') && (n_workers >= 2)
+    delete(gcp('nocreate'))
+end
diff --git a/Requirements/PESTO-1.1.0/examples/mRNA_transfection/logLikelihoodT.m b/Requirements/PESTO-1.1.0/examples/mRNA_transfection/logLikelihoodT.m
new file mode 100644
index 0000000000000000000000000000000000000000..8af54332acad766b249af61ff6b203b71cfe226e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/mRNA_transfection/logLikelihoodT.m
@@ -0,0 +1,104 @@
+function [logL, dlogLdtheta, FIM] = logLikelihoodT(varargin)
+% Objective function for examples/mRNA_transfection
+%
+% logLikelihoodT.m provides the log-likelihood, its gradient and an 
+% approximation of the Hessian matrix based on Fisher information matrix
+% (FIM) for the conversion reaction process.
+% 
+% Parameters:
+%   varargin:
+%     theta: Model parameters
+%     t: vector of time points
+%     D: measurement data
+%
+% Return values:
+%   logL: double, value of log-likelihood
+%   dlogLdtheta: double vector, gradient of the log-likelihood
+%   FIM: double array, approximation of the Hessian matrix based on the
+%       Fisher information matrix
+
+
+
+%% Model Definition
+% Definition of the biological process:
+% Some text I still need to write
+%
+% Reaction:
+% m -> m + G, rate: k_TL * [m]
+% G -> 0    , rate: beta
+% m -> 0    , rate: delta
+% 
+% State of the system:
+% X = [X_1, X_2] with
+% X_1 = [G]: eGFP concentration
+% X_2 = [m]: mRNA concentration
+%
+% Dynamics:
+% dX_1/dt = k_TL * X_2 - beta * X_1
+% dX_2/dt = -delta * X_2
+%
+% Measurement:
+% Y = X_2
+%
+% Observables of the system:
+% y(t) = h(theta, x(t))
+%
+% Measurement noise:
+% sigma, parameter to be estimated from the data
+
+%% Initialization
+% Initialization of observable sensitivities
+
+theta = varargin{1}; 
+theta = theta(:);
+t     = varargin{2};
+D     = varargin{3};
+
+% Parameter assignment
+t0     = 10.^theta(1);
+kTL_m0 = 10.^theta(2);
+beta   = 10.^theta(3);
+delta  = 10.^theta(4);
+sigma  = 10.^theta(5);
+
+%% Evaluation of likelihood function
+% Simulation
+
+% State
+X = [exp(-delta*(t-t0)) .* (t>t0), ...
+     kTL_m0 * (exp(-beta*(t-t0)) - exp(-delta*(t-t0))) / (delta-beta) .* (t>t0)];
+ 
+% State sensitivities
+SX(:,:,1) = -X*[-delta,0;kTL_m0,-beta]';
+SX(:,:,2) = [zeros(size(t)), ...
+             (exp(-beta*(t-t0)) - exp(-delta*(t-t0))) / (delta-beta) .* (t>t0)];
+SX(:,:,3) = [zeros(size(t)), ...
+             kTL_m0 * ( (-(t-t0).*exp( -beta*(t-t0))) / (delta-beta) + ...
+             (exp(-beta*(t-t0)) - exp(-delta*(t-t0))) / (delta-beta)^2 ) .* (t>t0)];
+SX(:,:,4) = [-exp(-delta*(t-t0)) .* (t-t0) .* (t>t0), ...
+             kTL_m0 * ( ((t-t0).*exp(-delta*(t-t0))) / (delta-beta) - ...
+             (exp(-beta*(t-t0)) - exp(-delta*(t-t0))) / (delta-beta)^2 ) .* (t>t0)];
+       
+% Chain rule and Observables
+SX = bsxfun(@times, SX, 10.^permute(theta(1:4), [3,2,1]) * log(10));
+Y = X(:,2);
+SY = squeeze(SX(:,2,:));
+
+%% Objective Function Evaluation
+% Log-likelihood
+logL = - 1/2 * sum(log(2*pi*sigma^2) + ((D-Y) ./ sigma).^2);
+
+% Gradient
+dlogLdtheta(1:4,1) = 1/(sigma^2) * sum(bsxfun(@times,(D-Y), SY))';
+dlogLdtheta(5,1)   = - sum(1/sigma - (D-Y).^2 ./ (sigma^3)) * (10.^theta(5) * log(10));
+
+% Fisher information matrix
+FIM = zeros(5,5);
+FIM = FIM - 1/sigma^2 * [SY, zeros(length(t),1)]' * [SY, zeros(length(t),1)];
+FIM(5,1:4) = FIM(5,1:4) - (2/sigma) * dlogLdtheta(1:4)' * (10.^theta(5) * log(10));
+FIM(1:4,5) = FIM(1:4,5) - (2/sigma) * dlogLdtheta(1:4) * (10.^theta(5) * log(10));
+FIM(5,5)   = FIM(5,5) - sum(-(1/sigma^2) + 3*(D-Y).^2 ./ sigma^4) * (10.^theta(5) * log(10))^2 ...
+                      - sum( (1/sigma)   -   (D-Y).^2 ./ sigma^3) * (10.^theta(5) * log(10)^2);
+                  
+end
+                  
diff --git a/Requirements/PESTO-1.1.0/examples/mRNA_transfection/mainTransfection.m b/Requirements/PESTO-1.1.0/examples/mRNA_transfection/mainTransfection.m
new file mode 100644
index 0000000000000000000000000000000000000000..8690b4b0c9736273120291dcba0e46538ef7ff3a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/mRNA_transfection/mainTransfection.m
@@ -0,0 +1,381 @@
+% Main file of the mRNA transfection example
+%
+% Demonstrates the use of:
+% * getMultiStarts()
+% * getParameterProfiles()
+% * getParameterSamples()
+% * getParameterConfidenceIntervals()
+% * getPropertyMultiStarts()
+% * getPropertyProfiles()
+% * getPropertySamples()
+% * getPropertyConfidenceIntervals()
+%
+% Demonstrates furthermore:
+% * how to carry out uncertainty analysis for local (non-global) optima
+% * how to use a multi-chain method for sampling which is initialized at
+%   different parameter optima
+% * how to use the PHS algorithm for sampling
+% * how to deal with burn-in time for sampling algorithms and how to plot
+%   only the samples which are important for the posterior
+% * how to use the PSwarm toolbox for optimization (commented code version)
+%   and what problems may occur when no gradient based approach is used
+% * How to use the profile computation mode 'mixed'
+% * How to use Hessian matrices computed by the automated finite difference
+%   scheme of PESTO (in getParameterProfiles)
+%
+% This example is a model for mRNA transfection, taken from the paper
+% "Single-cell mRNA transfection studies: Delivery, kinetics and statistics
+% by numbers", by Leonhardt C et al., Nanomedicine: NBM, 2014, vol.10
+% (see http://dx.doi.org/10.1016/j.nano.2013.11.008)
+%
+% The data used is measurement data provided in the publication.
+%
+% This file provides time-series measurement data Y and
+% performs a multistart maximum likelihood parameter estimation based on
+% these measurements, demonstrating the use of getMultiStarts(). The model
+% fit is then visualized.
+% 
+% Profile likelihood calculation is done by optimization and integration
+% using getParameterProfiles() with the option 
+% optionsMultistart.profile_method = 'mixed'to have comparison of both
+% methods.
+%
+% Multi-chain Monte-Carlo sampling is performed by getParameterSamples()
+
+
+
+%% Preliminary
+clear all;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed random number generator
+rng(0);
+
+%% Model Definition
+% See logLikelihoodT.m for a detailed description
+
+%% Data
+% We fix a data set. It consists of a vector of time points t and a
+% measurement vector ym. This data is taken from the referenced publication.
+
+t = (0:0.2:10)';
+ym = [   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   0
+   1.8309
+   3.3559
+   4.6091
+   5.4235
+   5.9757
+   6.6298
+   7.0080
+   7.8280
+   7.5852
+   7.9247
+   7.8363
+   8.0107
+   7.7077
+   7.5316
+   7.4208
+   7.5734
+   7.3197
+   7.1489
+   7.1987
+   6.8493
+   6.6425
+   6.6268
+   6.1223
+   6.1078
+   5.9242
+   5.6034
+   5.4618
+   5.1281
+   4.9489
+   4.8930
+   4.7747
+   4.7750
+   4.3095
+   4.2211
+   4.0416
+   3.7485
+   3.7164
+   3.4799
+   3.5286
+   3.2785];
+
+%% Definition of the Parameter Estimation Problem
+% In order to run any PESTO routine, at least the parameters struct with
+% the fields shown here and the objective function need to be defined,
+% since they are mandatory for getMultiStarts, which is usually the first
+% routine needed for any parameter estimation problem.
+% In this case, also a properties struct is created. For this struct,
+% basically the same routines can be called as for the parameters, just the
+% naming is different. Therefore, basically the same fields as for the
+% parameters struct have to be created.
+
+% Parameters
+parameters.min    = [-2; -5; -5; -5; -2];
+parameters.max    = [log10(max(t)); 5; 5; 5; 2];
+parameters.number = 5;
+parameters.name   = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+   'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+
+% Properties
+properties.function = {@(theta) propertyFunction_theta(theta,1),...
+   @(theta) propertyFunction_theta(theta,2),...
+   @(theta) propertyFunction_theta(theta,3),...
+   @(theta) propertyFunction_theta(theta,4),...
+   @(theta) propertyFunction_theta(theta,5)};
+properties.min      = [-2; -5; -5; -5; -2];
+properties.max      = [log10(max(t)); 5; 5; 5; 2];
+properties.number   = length(properties.min);
+properties.name     = {'log_{10}(t_0)';'log_{10}(k_{TL}*m_0)';...
+   'log_{10}(\beta)';'log_{10}(\delta)';'log_{10}(\sigma)'};
+
+% Objective function (Log-likelihood)
+objectiveFunction = @(theta) logLikelihoodT(theta, t, ym);
+
+%% Multi-start local optimization
+% A multi-start local optimization is performed within the bounds defined in
+% parameters.min and .max in order to infer the unknown parameters from
+% measurement data. Therefore, a PestoOptions object is created and
+% some of its properties are set. Since the field obj_type is set to
+% 'log-posterior', the objective function is maximized.
+
+% Options
+optionsPesto           = PestoOptions();
+optionsPesto.obj_type  = 'log-posterior';
+optionsPesto.comp_type = 'sequential';
+optionsPesto.mode      = 'visual';
+optionsPesto.n_starts  = 15;
+optionsPesto.plot_options.group_CI_by = 'methods';
+
+% The example can also be run in parallel mode: Uncomment this, if wanted
+% optionsMultistart.comp_type = 'parallel';
+% optionsMultistart.mode = 'silent';
+% optionsMultistart.save = true;
+% optionsMultistart.foldername = 'results';
+% n_workers = 20;
+
+% Open matlabpool
+if (strcmp(optionsPesto.comp_type, 'parallel') && (n_workers >= 2))
+   parpool(n_workers);
+end
+
+% This section uses PSwarm, a particle swarm optimizer
+% (Install from http://www.norg.uminho.pt/aivaz/pswarm/ and uncomment)
+% 
+% optionsPestoPSwarm = optionsPesto.copy();
+% optionsPestoPSwarm.localOptimizer = 'pswarm';
+% optionsPestoPSwarm.localOptimizerOptions.MaxObj  = 25000;
+% optionsPestoPSwarm.localOptimizerOptions.MaxIter = 1000;
+% optionsPestoPSwarm.localOptimizerOptions.Size    = 100;
+% optionsPestoPSwarm.localOptimizerOptions.Social  = 0.5;
+% optionsPestoPSwarm.localOptimizerOptions.Cognitial = 0.9;
+% optionsPestoPSwarm.localOptimizerOptions.IPrint  = -1;
+% 
+% parameters = getMultiStarts(parameters, objectiveFunction, optionsPestoPSwarm);
+
+
+% This section uses multi-start local optimization
+parameters = getMultiStarts(parameters, objectiveFunction, optionsPesto);
+
+%% Collection of results, check for bimodality
+
+% Check if a second optimum was found, which is good enough
+for iMode = 2 : optionsPesto.n_starts
+   if (parameters.MS.logPost(iMode) > 39.5)
+      if (abs(parameters.MS.par(3,iMode) - parameters.MS.par(3,1)) > 0.1)
+         MAP_index2 = iMode;
+         break;
+      end
+   end
+end
+
+% Create information for a second parameter struct
+parametersAlt = parameters;
+
+%% Visualization of fit
+% The measured data is visualized in a plot, together with fit for the best
+% parameter value found during getMultiStarts.
+
+if strcmp(optionsPesto.mode,'visual')
+   % Simulation
+   tsim = linspace(t(1), t(end), 100);
+   ysim = simulate_mRNA_Transfection(10.^parameters.MS.par(:,1), tsim);
+   
+   % Plot: Fit
+   figure();
+   plot(t,ym,'bo'); hold on;
+   plot(tsim,ysim,'r-');
+   xlabel('time t');
+   ylabel('output y');
+   legend('data', 'fit');
+end
+
+%% Profile likelihood calculation -- Parameters
+% The uncertainty of the estimated parameters is visualized by computing
+% and plotting profile likelihoods. In getParameterProfiles, this is done
+% by using repeated reoptimization. The information about the profiles is
+% then written to the parameters struct.
+
+% Profiles are computed using optimization and integratiob by 
+% getParameterProfiles() with profile_method = 'mixed'.
+% Profiles for parameters 1, 2, and 5 are integrated, profiles for
+% parameters 3 and 4 are optimized.
+optionsPesto.profile_method      = 'mixed';
+optionsPesto.profile_optim_index = [2 3];
+optionsPesto.profile_integ_index = [1 4 5];
+
+% Hessians for profile integration should be calculated by finite
+% differences, so PESTO gets told that he objective function can only
+% compute 2 outputs (objective and gradient), hence it will compute the 
+% necessary Hessians by finite differences.
+optionsPesto.objOutNumber = 2;
+
+parameters = getParameterProfiles(parameters, objectiveFunction, optionsPesto);
+
+% Computation for the second mode
+optionsPesto.fh = [];
+optionsPesto.MAP_index = MAP_index2;
+
+% Now only the profiles 3 and 4 should be recomputed, since all the other
+% profiles are identical for the second mode
+optionsPesto.parameter_index = [3 4];
+optionsPesto.profile_optim_index = 4;
+optionsPesto.profile_integ_index = 3;
+parametersAlt = getParameterProfiles(parametersAlt, objectiveFunction, optionsPesto);
+
+% Reset the default value
+optionsPesto.objOutNumber = 3;
+
+%% Markov Chain Monte Carlo sampling -- Parameters
+% Values for the parameters are sampled by using an Parallel Tempering (PT)
+% algorithm. This way, the underlying probability density of the parameter
+% distribution can be captured.
+
+% Building a struct covering all sampling options:
+optionsPesto.MCMC.nIterations = 1e5;
+trainingTime = ceil(optionsPesto.MCMC.nIterations / 5);
+
+% PHS specific options:
+optionsPesto.MCMC.samplingAlgorithm = 'PHS';
+optionsPesto.MCMC.objOutNumber      = 1;
+optionsPesto.MCMC.PHS.nChains       = 4;
+optionsPesto.MCMC.PHS.alpha         = 0.51;
+optionsPesto.MCMC.PHS.memoryLength  = 1;
+optionsPesto.MCMC.PHS.regFactor     = 1e-6;
+optionsPesto.MCMC.PHS.trainingTime  = trainingTime;
+
+
+optionsPesto.MCMC.theta0(:,[1 3]) = parameters.MS.par(:, [1 1]);
+optionsPesto.MCMC.sigma0(:,:,[1 3]) = repmat(inv(squeeze(parameters.MS.hessian(:, :, 1))), [1 1 2]);
+optionsPesto.MCMC.theta0(:,[2 4]) = parameters.MS.par(:, [MAP_index2 MAP_index2]);
+optionsPesto.MCMC.sigma0(:,:,[2 4]) = repmat(inv(squeeze(parameters.MS.hessian(:, :, MAP_index2))), [1 1 2]);
+
+% Run the sampling
+parameters = getParameterSamples(parameters, objectiveFunction, optionsPesto);
+
+% Now, the plots for the sampling include the burn-in phase, which the
+% sampling algorithm needs to explore the posterior. Those burn-in samples
+% corrupt the shape of the posterior, if they are not removed from the
+% histogram. So we clean the parameters.S struct from them (it may yet be
+% good to retain a copy of all samples, to do some more datailed analysis
+% and diagnosis with it.
+
+% Cleaning up
+parameters.S.par(:,1:trainingTime,:) = [];
+parameters.S.logPost(1:trainingTime,:) = [];
+
+% Plotting of the new sampling set
+optionsPesto.plot_options.S.plot_type = 1;
+optionsPesto.plot_options.S.ind = 1;
+optionsPesto.plot_options.S.bins = 'optimal';
+fh = figure('Name','plotParameterSamples after CleanUp - 1D');
+plotParameterSamples(parameters,'1D',fh,[],optionsPesto.plot_options);
+fh = figure('Name','plotParameterSamples after CleanUp - 2D');
+plotParameterSamples(parameters,'2D',fh,[],optionsPesto.plot_options);
+
+
+%% Confidence interval evaluation -- Parameters
+% Confidence intervals to the confidence levels fixed in the array alpha
+% are computed based on local approximations from the Hessian matrix at the
+% optimum, based on the profile likelihoods and on the parameter sampling.
+
+alpha = [0.9,0.95,0.99];
+
+% Computation for the first mode
+optionsPesto.MAP_index = 1;
+optionsPesto.parameter_index = 1 : parameters.number;
+parameters = getParameterConfidenceIntervals(parameters, alpha, optionsPesto);
+
+% Computation for the second mode
+optionsPesto.MAP_index = MAP_index2;
+optionsPesto.parameter_index = [3, 4];
+parametersAlt = getParameterConfidenceIntervals(parametersAlt, alpha, optionsPesto);
+
+%% Evaluation of properties for multi-start local optimization results -- Properties
+% The values of the properties are evaluated at the end points of the
+% multi-start optimization runs by getPropertyMultiStarts.
+
+optionsPesto.MAP_index = 1;
+optionsPesto.parameter_index = 1 : parameters.number;
+properties = getPropertyMultiStarts(properties, parameters, optionsPesto);
+
+%% Profile likelihood calculation -- Properties
+% Profile likelihoods are computed for the properties in the same fashion,
+% as they were computed for the parameters.
+
+properties = getPropertyProfiles(properties, parameters, objectiveFunction, optionsPesto);
+
+%% Evaluation of properties for sampling results -- Properties
+% From the samples of the parameters, the properties are calculated and
+% hence a probability distribution for the properties can be reconstructed
+% from that.
+
+properties = getPropertySamples(properties, parameters, optionsPesto);
+
+%% Confidence interval evaluation -- Properties
+% As for the parameters, confidence intervals are computed for the
+% properties in different fashion, based on local approximations, profile
+% likelihoods and samples.
+
+properties = getPropertyConfidenceIntervals(properties, alpha);
+
+%% Comparison of calculated parameter profiles
+
+if strcmp(optionsPesto.mode, 'visual')
+   % Open figure
+   figure
+   
+   % Loop: parameters
+   for i = 1:parameters.number
+      subplot(ceil(parameters.number/ceil(sqrt(parameters.number))),ceil(sqrt(parameters.number)),i);
+      plot(parameters.P(i).par(i,:),parameters.P(i).R,'bx-'); hold on;
+      plot(properties.P(i).prop, properties.P(i).R,'r-o');
+      xlabel(properties.name{i});
+      ylabel('likelihood ratio');
+      if i == 1
+         legend('unconst. opt. (= standard)','unconst. op. (= new)');
+      end
+   end
+end
+
+%% Close the pools of parallel working threads
+
+if strcmp(optionsPesto.comp_type, 'parallel')
+   delete(gcp('nocreate'));
+end
diff --git a/Requirements/PESTO-1.1.0/examples/mRNA_transfection/propertyFunction_theta.m b/Requirements/PESTO-1.1.0/examples/mRNA_transfection/propertyFunction_theta.m
new file mode 100644
index 0000000000000000000000000000000000000000..3c9e364086c505faa95930cab0dde516d94bae22
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/mRNA_transfection/propertyFunction_theta.m
@@ -0,0 +1,30 @@
+function varargout = propertyFunction_theta(theta, i)
+% propertyFunction_theta for examples/mRNA_transfection
+%
+% returns the value of the i-th parameter as defined in 
+% logLikelihood.m with derivatives
+%
+% Parameters: 
+%  theta: parameter vector
+%  i: index for the parameter
+%
+% Return values:
+%  f: double, value of property function
+%  grad_f: double vector, gradient of property function
+%  hess_f: double array, hessian of property function
+
+
+
+%% Property Function Evaluation
+n = length(theta);
+
+f         = theta(i);
+grad_f    = zeros(n, 1);
+grad_f(i) = 1;
+hess_f    = zeros(n, n);
+
+varargout{1} = f;
+varargout{2} = grad_f;
+varargout{3} = hess_f;
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/data.mat b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/data.mat
new file mode 100644
index 0000000000000000000000000000000000000000..9e8b3a7a5c143eb9147a098a65f17016b05a6b10
Binary files /dev/null and b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/data.mat differ
diff --git a/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/logLikelihoodRME.m b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/logLikelihoodRME.m
new file mode 100644
index 0000000000000000000000000000000000000000..6b012731337bd521b401e3b14d35ebefcadf49c7
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/logLikelihoodRME.m
@@ -0,0 +1,97 @@
+ function [varargout] = logLikelihoodRME(theta, amiData)
+% Objective function for examples/rafmekerk_signaling
+%
+% logLikelihoodRME.m provides the log-likelihood, its gradient and an the 
+% Hessian matrix for the model for the JakStat signaling pathway as
+% defined in rafmekerk_pesto_syms.m
+% 
+% USAGE:
+% [llh] = logLikelihoodRME(theta, amiData)
+% [llh, sllh] = logLikelihoodRME(theta, amiData)
+% [llh, sllh, s2llh] = logLikelihoodRME(theta, amiData)
+%
+% Parameters:
+%  theta: Model parameters 
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no 
+%         sensitivity analysis is performed
+%     sllh: Gradient of llh, The LogLikelihood and its gradient will be 
+%         returned, first order adjoint sensitivity analysis is performed
+%     s2llh: Hessian of llh, The LogLikelihood, its gradient and the 
+%         Hessian matrix will be returned, second order adjoint sensitivity 
+%         analysis is performed
+    
+
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see rafmekerk_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% paper by Fiedler et al.
+
+    nPar = 28;
+    
+    % Set options according to function call
+    amiOptions.sensi_meth = 'forward';
+    if (nargout > 1)
+        amiOptions.sensi = 1;
+        if (nargout > 2)
+            amiOptions.sensi_meth = 'adjoint';
+            amiOptions.sensi = 2;
+        end
+    end
+    amiOptions.maxsteps = 1e5;
+    amiOptions.atol = 1e-14;
+    amiOptions.rtol = 1e-10;
+    amiO = amioption(amiOptions);
+    
+    try
+        % Set number of conditions
+        n_u = size(amiData, 2);
+
+        % Initialize output
+        llh = 0;
+        sllh = zeros(nPar, 1);
+        s2llh = zeros(nPar, nPar);
+
+        for iCondition = 1 : n_u
+            % Simulate the condition
+            sol = simulate_rafmekerk_pesto(amiData(iCondition).t, theta, amiData(iCondition).condition, amiData(iCondition), amiO);
+
+            % Sum up contribution from conditions
+            if (sol.status ~= 0)
+                sol.llh = inf;
+                break;
+            end
+            llh = llh + sol.llh;
+            if nargout > 1
+                sllh = sllh + sol.sllh;
+                if nargout > 2
+                    s2llh = s2llh + sol.s2llh;
+                end
+            end
+        end
+
+    catch error_thrown
+
+        warning(['Evaluation of likelihood failed. ',error_thrown.message]);
+        varargout{1} = inf;
+        varargout{2} = inf(nPar, 1);
+    end
+
+    switch (nargout)
+        case{0,1}
+            varargout{1} = llh;
+        case 2
+            varargout{1} = llh;
+            varargout{2} = sllh;
+        case 3
+            varargout{1} = llh;
+            varargout{2} = sllh;
+            varargout{3} = s2llh;
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/logLikelihoodRMELsqnonlin.m b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/logLikelihoodRMELsqnonlin.m
new file mode 100644
index 0000000000000000000000000000000000000000..b4eb34fe7142766ca443e4ba4043579ed0bc3e1e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/logLikelihoodRMELsqnonlin.m
@@ -0,0 +1,113 @@
+ function [varargout] = logLikelihoodRMELsqnonlin(theta, amiData)
+% Objective function for examples/rafmekerk_signaling
+%
+% logLikelihoodRMELsqnonlin.m provides the residuals, their Jacobian and 
+% an the log-likelihood for the model for the RafMekErk signaling pathway 
+% as defined in rafmekerk_pesto_syms.m
+% 
+% USAGE:
+% [res] = logLikelihoodRMELsqnonlin(theta, amiData)
+% [res, sres] = logLikelihoodRMELsqnonlin(theta, amiData)
+% [res, ~, llh] = logLikelihoodRMELsqnonlin(theta, amiData)
+%
+% Parameters:
+%  theta: Model parameters 
+%  amiData: an amidata object for the AMICI solver
+%
+% Return values:
+%   varargout:
+%     res: residuals of simulation vs data
+%     sres: Jacobian of the residuals, i.e. partial derivatives of the
+%         residuals w.r.t. to model parameters
+%     llh: Log-Likelihood, only the LogLikelihood will be returned, no 
+%         sensitivity analysis is performed
+
+
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see rafmekerk_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% paper by Fiedler et al.
+
+    nPar = 28;
+    nData = 56;
+    
+    % Set options according to function call
+    if (nargout == 2)
+        amiOptions.sensi = 1;
+    else
+        amiOptions.sensi = 0;
+    end
+    amiOptions.sensi_meth = 'forward';
+    amiOptions.maxsteps = 1e5;
+    amiOptions.atol = 1e-14;
+    amiOptions.rtol = 1e-10;
+    amiO = amioption(amiOptions);
+    
+    try
+        % Set number of conditions
+        nCondition = size(amiData, 2);
+
+        % Initialize output
+        res = zeros(2*nData, 1);
+        if (nargout == 2)
+            sres = zeros(2*nData, nPar);
+        elseif (nargout == 3)
+            llh = 0;
+        end
+
+        for iData = 1 : nCondition
+            % Simulate the condition
+            sol = simulate_rafmekerk_pesto(amiData(iData).t, theta, amiData(iData).condition, amiData(iData), amiO);
+
+            % Sum up contribution from conditions
+            if (sol.status ~= 0)
+                error('Integration of ODE failed!');
+            end
+
+            nanIndex = isnan(amiData(iData).Y(:));
+            thisRes = (sol.y(:) - amiData(iData).Y(:)) ./ sol.sigmay(:);
+            thisRes(nanIndex) = 0;
+            thisRes_sigma = sqrt(log(2*pi*sol.sigmay(:).^2) - log(2*pi*10^(-5)^2));
+            thisRes_sigma_tmp = thisRes_sigma;
+            thisRes_sigma_tmp(nanIndex) = 0;
+            res = [res; thisRes; thisRes_sigma_tmp];
+            
+            if (nargout == 2)
+                sres1 = ((1 ./ sol.sigmay(:)) * ones(1,nPar)) .* reshape(sol.sy, nData, nPar);
+                sres2 = (((sol.y(:) - amiData(iData).Y(:)) ./ sol.sigmay(:).^2) * ones(1,nPar)) .* reshape(sol.ssigmay, nData, nPar);
+                sres3 = ((1 ./ (thisRes_sigma .* sol.sigmay(:))) * ones(1,nPar)) .* reshape(sol.ssigmay, nData, nPar);
+                thisSRes = [sres1 - sres2; sres3];
+                thisSRes([nanIndex; nanIndex], :) = 0;
+                sres = [sres; thisSRes];
+            elseif (nargout == 3)
+                llh = llh + sol.llh;
+            end
+        end
+
+    catch error_thrown
+
+        warning(['Evaluation of likelihood failed. ',error_thrown.message]);
+        res = inf(2*nData,1);
+        if (nargout == 2)
+            sres = zeros(2*nData,nPar);
+        elseif (nargout == 3)
+            sres = zeros(2*nData,nPar);
+            llh = inf;
+        end
+    end
+
+    switch (nargout)
+        case{0,1}
+            varargout{1} = res;
+        case 2
+            varargout{1} = res;
+            varargout{2} = sres;
+        case 3
+            varargout{1} = res;
+            varargout{2} = [];
+            varargout{3} = llh;
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/mainRafMekErkSignaling.m b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/mainRafMekErkSignaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..a40800494f1b2b8bc707ce2e70b93059f67a32a6
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/mainRafMekErkSignaling.m
@@ -0,0 +1,147 @@
+% Main file of the RafMekErk signaling example
+%
+% Demonstrates the use of:
+% * getMultiStarts()
+%
+% Demostrates furhtermore
+% * that non-evaluable points in parameter space can occur
+% * how different local optimization methods perform (fmincon and
+%   lsqnonlin)
+% * how to use lsqnonlin as local optimizer
+%
+% This example provides a model for the RafMekErk signaling pathway with
+% the different treatment conditions. The model has been taken from the
+% publication "Tailored parameter optimization methods for ordinary
+% differential equation models with steady-state constraints" by Fiedler et
+% al., 2016, in "BMC Systems Biology".
+%
+% The data used is measurement data provided in the publications.
+%
+% This file performs a multistart local optimization based on measured data 
+% from the referenced papers, demonstrating the use of getMultiStarts().
+
+
+%% Preliminary
+
+clear;
+close all;
+clc;
+
+TextSizes.DefaultAxesFontSize = 14;
+TextSizes.DefaultTextFontSize = 18;
+set(0,TextSizes);
+
+% Seed random number generator
+rng(0);
+
+%% Model Definition
+% The ODE model is set up using the AMICI toolbox. To access the AMICI
+% model setup, see rafmekerk_pesto_syms.m
+% For a detailed description for the biological model see the referenced
+% paper by Fiedler et al.
+
+% Wrap models for AMICI simulation, if necessary
+[exdir,~,~] = fileparts(which('rafmekerk_pesto_syms.m'));
+try
+    amiwrap('rafmekerk_pesto','rafmekerk_pesto_syms',exdir,1);
+catch ME
+    warning('This example uses the additional toolbox AMICI for ODE simulation (freely available at https://github.com/ICB-DCM/AMICI). It seems that AMICI is not or not proeperly installed, since using it resulted in an error. The original error message was:');
+    rethrow(ME);
+end
+
+%% Data
+% Load data
+load('./data.mat');
+u   = D.conditions;
+n_u = size(u,1);
+n_theta = 20;
+n_sigma = 8;
+
+% Clean up data and make Amici-readable data out of it
+for j = 1 : n_u
+    amiData(j) = struct(...
+        't', D.t{j}, ...
+        'condition', D.conditions(j,:), ...
+        'Y', D.measurement{j} ...
+        );
+end
+amiD(1) = amidata(amiData(1));
+amiD(2) = amidata(amiData(2));
+amiD(3) = amidata(amiData(3));
+
+
+%% Generation of the structs and options for PESTO
+% The structs and the PestoOptions object, which are necessary for the 
+% PESTO routines to work are created and set to convenient values
+
+% parameters struct
+% 12 dynamic parameters, 8 scaling parameters, 8 sigma parameters
+parameters.number     =  n_theta + n_sigma;
+parameters.min        = -5 * ones(28,1);
+parameters.min(7)     = -10;
+parameters.min(9)     = -7;
+parameters.max        = 4 * ones(28,1);
+parameters.max(1:3)   = 5;
+parameters.max(4)     = 6;
+parameters.max(13:20) = 8;
+parameters.name = {'log_{10}(kdf_{Raf})','log_{10}(kp_{Raf})','log_{10}(kdp_{pMek})',...
+                   'log_{10}(kp_{pRaf_{Mek}})','log_{10}(kdp_{pErk})','log_{10}(kp_{pMek_{Erk}})',...
+                   'log_{10}(K_{pErk_{inh}})','log_{10}(sust_{Ras_0})','log_{10}(ts_{sust_{Ras}})',...
+                   'log_{10}(ts_{trans_{Ras}})','log_{10}(K_{Sora})','log_{10}(K_{UO})',... 
+                   'log_{10}(scale_{pMek_{20140430_{gel1}}})','log_{10}(scale_{pErk_{20140430_{gel1}}})',...
+                   'log_{10}(scale_{pMek_{20140430_{gel2}}})','log_{10}(scale_{pErk_{20140430_{gel2}}})',...
+                   'log_{10}(scale_{pMek_{20140505_{gel1}}})','log_{10}(scale_{pErk_{20140505_{gel1}}})',...
+                   'log_{10}(scale_{pMek_{20140505_{gel2}}})','log_{10}(scale_{pErk_{20140505_{gel2}}})',... 
+                   'log_{10}(sigma_{pMek_{20140430_{gel1}}})','log_{10}(sigma_{pErk_{20140430_{gel1}}})',...
+                   'log_{10}(sigma_{pMek_{20140430_{gel2}}})','log_{10}(sigma_{pErk_{20140430_{gel2}}})',...
+                   'log_{10}(sigma_{pMek_{20140505_{gel1}}})','log_{10}(sigma_{pErk_{20140505_{gel1}}})',...
+                   'log_{10}(sigma_{pMek_{20140505_{gel2}}})','log_{10}(sigma_{pErk_{20140505_{gel2}}})'...
+                   };
+
+% objective function
+objectiveFunction = @(theta) logLikelihoodRME(theta, amiD);
+
+
+%% Perform optimization
+% A parameters optimization is performed within the bounds defined in
+% parameters.min and .max in order to infer the unknown parameters from 
+% measurement data.
+
+% REMARK: The optimization in this case is rather challenging and the
+% box constraints in the parameter space are set generously. So
+% optimization will encounter many points in which the ODE can not be
+% evaluated, leading to warnings of the ODE simulator AMICI. This is
+% expected behavior and no bug. It demonstrates paramter estimation for
+% a complicated example.
+
+% Different local optimization methods are compared with each other.
+% The uncommented version is a default fmincon optimization, the commented
+% part demonstrates the use of lsqnonlin, which performs better on this
+% example.
+
+optionsPesto = PestoOptions();
+optionsPesto.n_starts = 25; 
+optionsPesto.mode = 'visual';
+optionsPesto.proposal = 'latin hypercube';
+optionsPesto.trace = false;
+optionsPesto.obj_type = 'log-posterior';
+optionsPesto.localOptimizer = 'fmincon';
+optionsPesto.localOptimizerOptions.Algorithm = 'interior-point';
+optionsPesto.localOptimizerOptions.TolX = 1e-12;
+optionsPesto.localOptimizerOptions.TolFun = 1e-10;
+optionsPesto.localOptimizerOptions.Display = 'iter';
+optionsPesto.localOptimizerOptions.GradObj = 'on';
+optionsPesto.localOptimizerOptions.Hessian = 'on';
+optionsPesto.localOptimizerOptions.MaxFunEvals = 10000;
+optionsPesto.localOptimizerOptions.MaxIter = 500;
+
+% % This example can be run using lsqnonlin as local optimizer
+% objectiveFunction = @(theta) logLikelihoodRMELsqnonlin(theta, amiD);
+% optionsPesto.localOptimizer = 'lsqnonlin';
+% optionsPesto.localOptimizerOptions.Algorithm = 'trust-region-reflective';
+% optionsPesto.localOptimizerOptions.GradObj = 'on';
+% optionsPesto.localOptimizerOptions.Hessian = 'off';
+% optionsPesto.localOptimizerOptions.Jacobian = 'on';
+
+% Run optimization with fmincon (+Hessians} or Lsqnonlin
+parameters = getMultiStarts(parameters, objectiveFunction, optionsPesto);
diff --git a/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/rafmekerk_pesto_syms.m b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/rafmekerk_pesto_syms.m
new file mode 100644
index 0000000000000000000000000000000000000000..c138129b9c3526d28d87a1acc039b2bd5025c927
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/rafmekerk_signaling/rafmekerk_pesto_syms.m
@@ -0,0 +1,80 @@
+function [model] = rafmekerk_pesto_syms()
+
+%% CVODES OPTIONS
+model.param = 'log10';
+%% STATES
+syms pRaf pMek pErk 
+
+x = [pRaf pMek pErk];
+%% TIME
+syms t
+
+%% PARAMETERS
+% Define parameters as symbolic variables:
+syms kdf_Raf kp_Raf kdp_pMek kp_pRaf_Mek kdp_pErk kp_pMek_Erk K_pErk_inh ...
+         sust_Ras_0 ts_sust_Ras ts_trans_Ras K_Sora K_UO ... 
+         scale_pMek_20140430_gel1 scale_pErk_20140430_gel1 scale_pMek_20140430_gel2 ...
+         scale_pErk_20140430_gel2 scale_pMek_20140505_gel1 scale_pErk_20140505_gel1 ...
+         scale_pMek_20140505_gel2 scale_pErk_20140505_gel2 ...
+         sigma_pMek_20140430_gel1 sigma_pErk_20140430_gel1 sigma_pMek_20140430_gel2 ...
+         sigma_pErk_20140430_gel2 sigma_pMek_20140505_gel1 sigma_pErk_20140505_gel1 ...
+         sigma_pMek_20140505_gel2 sigma_pErk_20140505_gel2
+     
+p = [kdf_Raf kp_Raf kdp_pMek kp_pRaf_Mek kdp_pErk kp_pMek_Erk K_pErk_inh ...
+         sust_Ras_0 ts_sust_Ras ts_trans_Ras K_Sora K_UO ...
+         scale_pMek_20140430_gel1 scale_pErk_20140430_gel1 scale_pMek_20140430_gel2 ...
+         scale_pErk_20140430_gel2 scale_pMek_20140505_gel1 scale_pErk_20140505_gel1 ...
+         scale_pMek_20140505_gel2 scale_pErk_20140505_gel2 ...
+         sigma_pMek_20140430_gel1 sigma_pErk_20140430_gel1 sigma_pMek_20140430_gel2 ...
+         sigma_pErk_20140430_gel2 sigma_pMek_20140505_gel1 sigma_pErk_20140505_gel1 ...
+         sigma_pMek_20140505_gel2 sigma_pErk_20140505_gel2];
+     
+%% INPUT 
+% Define input as symbolic variable
+
+%% DOSERESPONSE
+syms Sora UO
+k = [Sora UO];
+
+%% SYSTEM EQUATIONS
+xdot = sym(zeros(size(x)));
+
+RasGTP = sust_Ras_0+(1-exp(-t/ts_sust_Ras))*exp(-t/ts_trans_Ras);
+xdot(1) = kp_Raf*(1-pRaf)*(RasGTP)/(1+pErk/K_pErk_inh)-kdf_Raf*pRaf;
+xdot(2) = kp_pRaf_Mek*pRaf/(1+Sora/K_Sora)*(1-pMek)-kdp_pMek*pMek;
+xdot(3) = kp_pMek_Erk*pMek/(1+UO/K_UO)*(1-pErk)-kdp_pErk*pErk;
+
+%% INITIAL CONDITIONS
+
+x0(1) = ((K_pErk_inh*(sust_Ras_0) + (K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + (K_pErk_inh*kdp_pErk*(sust_Ras_0))/kp_pMek_Erk - (K_pErk_inh*kdp_pMek*kdp_pErk*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk)))/(2*(kdf_Raf/kp_Raf  + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdf_Raf)/kp_Raf + (K_pErk_inh*kdf_Raf*kdp_pErk)/(kp_Raf*kp_pMek_Erk) + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk));
+x0(2) = (((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk - (K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk)/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) - (K_pErk_inh*kdp_pMek*kdp_pErk*sust_Ras_0)/(kp_pRaf_Mek*kp_pMek_Erk)))/((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*(sust_Ras_0))/kp_pMek_Erk + (kdf_Raf*kdp_pMek*(2*K_pErk_inh + (K_pErk_inh*kdp_pErk)/kp_pMek_Erk + 2))/(kp_Raf*kp_pRaf_Mek) + (K_pErk_inh*kdp_pMek*(sust_Ras_0)*(kdp_pErk/kp_pMek_Erk + 2))/kp_pRaf_Mek);
+x0(3) = (((K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0 + (K_pErk_inh*kdp_pErk*sust_Ras_0)/kp_pMek_Erk - (K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk)/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) - (K_pErk_inh*kdp_pMek*kdp_pErk*sust_Ras_0)/(kp_pRaf_Mek*kp_pMek_Erk)))/((kdp_pErk/kp_pMek_Erk + 1)*(K_pErk_inh^2*(sust_Ras_0)^2 + (2*K_pErk_inh^2*kdp_pErk*(sust_Ras_0)^2)/kp_pMek_Erk + (K_pErk_inh^2*kdp_pErk^2*(sust_Ras_0)^2)/kp_pMek_Erk^2 + (K_pErk_inh^2*kdp_pMek^2*kdp_pErk^2*(sust_Ras_0 + kdf_Raf/kp_Raf)^2)/(kp_pRaf_Mek^2*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk^2*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk^2) + (2*K_pErk_inh^2*kdp_pMek*kdp_pErk*(sust_Ras_0)*(sust_Ras_0 + kdf_Raf/kp_Raf))/(kp_pRaf_Mek*kp_pMek_Erk) + (4*K_pErk_inh*kdf_Raf*kdp_pMek*kdp_pErk*(sust_Ras_0))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk))^(1/2) + K_pErk_inh*sust_Ras_0*(kdp_pErk/kp_pMek_Erk + 1)^2 + (kdf_Raf*kdp_pMek*kdp_pErk*(K_pErk_inh + (K_pErk_inh*kdp_pErk)/kp_pMek_Erk + 2))/(kp_Raf*kp_pRaf_Mek*kp_pMek_Erk) + (K_pErk_inh*kdp_pMek*kdp_pErk*(sust_Ras_0)*(kdp_pErk/kp_pMek_Erk + 1))/(kp_pRaf_Mek*kp_pMek_Erk));
+
+%% OBSERVABLES
+
+y = [scale_pMek_20140430_gel1*x(2);...
+     scale_pErk_20140430_gel1*x(3);...
+     scale_pMek_20140430_gel2*x(2);...
+     scale_pErk_20140430_gel2*x(3);...
+     scale_pMek_20140505_gel1*x(2);...
+     scale_pErk_20140505_gel1*x(3);...
+     scale_pMek_20140505_gel2*x(2);...
+     scale_pErk_20140505_gel2*x(3)];
+
+%% VARAINCES
+
+sigma = [sigma_pMek_20140430_gel1 sigma_pErk_20140430_gel1 sigma_pMek_20140430_gel2 ...
+         sigma_pErk_20140430_gel2 sigma_pMek_20140505_gel1 sigma_pErk_20140505_gel1 ...
+         sigma_pMek_20140505_gel2 sigma_pErk_20140505_gel2];
+
+%% SYSTEM STRUCT
+
+model.sym.x = x;
+model.sym.k = k;
+model.sym.xdot = xdot;
+model.sym.p = p;
+model.sym.x0 = x0;
+model.sym.y = y;
+model.sym.sigma_y = sigma;
+
+end
diff --git a/Requirements/PESTO-1.1.0/examples/runTestExamples.m b/Requirements/PESTO-1.1.0/examples/runTestExamples.m
new file mode 100644
index 0000000000000000000000000000000000000000..52d40aba3e521c51c169062c4c8498082764ec21
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/examples/runTestExamples.m
@@ -0,0 +1,11 @@
+function runTestExamples()
+% runTestExamples runs some examples for the PESTO toolbox, to test if new
+% implementations cause problems
+
+mainConversionReaction;
+mainEnzymaticCatalysis;
+mainTransfection;
+mainErbBSignaling;
+mainJakstatSignaling;
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/getConfidenceIntervals.m b/Requirements/PESTO-1.1.0/getConfidenceIntervals.m
new file mode 100644
index 0000000000000000000000000000000000000000..a18a279cec29e260e0050b99f6d9b67d42aa698c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getConfidenceIntervals.m
@@ -0,0 +1,179 @@
+function pStruct = getConfidenceIntervals(pStruct, alpha, type, varargin)
+    % getConfidenceIntervals() calculates the confidence intervals for the 
+    % model parameters or properties. This is done by four approaches:
+    % The values of CI.local_PL and CI.PL are determined by the point on which 
+    % a threshold according to the confidence level alpha (calculated by a 
+    % chi2-distribution) is reached. local_PL computes this point by a local
+    % approximation around the MAP estimate using the Hessian matrix, PL uses 
+    % the profile likelihoods instead.
+    % The value of CI.local_B is computed by using the cummulative distribution
+    % function of a local approximation of the profile based on the Hessian
+    % matrix at the MAP estimate.
+    % The value of CI.S is calculated using samples for the model parameters
+    % and the according percentiles based on the confidence levels alpha.
+    %
+    % USAGE:
+    % * pStruct = getConfidenceIntervals(pStruct, alpha)
+    %
+    % Parameters:
+    %   pStruct: parameter or properties struct
+    %   alpha: vector with desired confidence levels for the intervals
+    %   varargin: 
+    %    options: A PestoOptions instance
+    %
+    % Return values:
+    %   pStruct: updated parameter or properties struct
+    %
+    % Generated fields of parameters:
+    %   CI: Information about confidence levels
+    %     * local_PL: Threshold based approach, uses a local approximation by
+    %         the Hessian matrix at the MAP estimate
+    %         (requires parameters.MS, e.g. from getMultiStarts)
+    %     * PL: Threshold based approach, uses profile likelihoods 
+    %         (requires parameters.P, e.g. from getParameterProfiles)
+    %     * local_B: Mass based approach, uses a local approximation by
+    %         the Hessian matrix at the MAP estimate
+    %         (requires parameters.MS, e.g. from getMultiStarts)
+    %     * S: Bayesian approach, uses percentiles based on samples
+    %         (requires parameters.S, e.g. from getParameterSamples)
+
+
+    %% Checking and assigning inputs
+    if length(varargin) >= 1
+        options = handleOptionArgument(varargin{1});
+    else
+        options = PestoOptions();
+    end
+
+    % Maximum posterior index
+    iMAP = options.MAP_index;
+    if (isempty(iMAP))
+        iMAP = 1;
+    end
+
+    % set names for fields in pStruct
+    if strcmp(type, 'par')
+        p_index = 'parameter_index';
+    else
+        p_index = 'property_index';
+    end
+    
+    % parameter index
+    if isempty(options.(p_index))
+        options.(p_index) = 1 : pStruct.number;
+    end
+    
+    % Initialization
+    pStruct.CI.alpha_levels = alpha;
+
+    % Loop: alpha levels
+    for iConfLevel = 1:length(alpha)
+        % Loop: Parameters
+        for iP = options.(p_index)
+            if isfield(pStruct,'MS')
+                pStruct = getCIfromOptimization(pStruct, alpha(iConfLevel), type, iMAP, iP, iConfLevel, options);
+            end
+
+            % Confidence intervals computed using profile likelihood
+            if isfield(pStruct,'P')
+                pStruct = getCIfromProfiles(pStruct, alpha(iConfLevel), type, iMAP, iP, iConfLevel);
+            end
+
+            % Confidence intervals computed using sample
+            if isfield(pStruct,'S')
+                pStruct.CI.S(iP,:,iConfLevel) = prctile(pStruct.S.(type)(iP,:,1),50 + 100*[-alpha(iConfLevel)/2, alpha(iConfLevel)/2]);
+            end
+        end
+    end
+
+    %% Output
+    switch options.mode
+        case 'visual'
+            plotConfidenceIntervals(pStruct, alpha, [], options);
+            disp('-> Calculation of confidence intervals for parameters FINISHED.');
+        case 'text'
+            disp('-> Calculation of confidence intervals for parameters FINISHED.');
+        case 'silent' % no output
+    end
+
+end
+
+
+function pStruct = getCIfromOptimization(pStruct, alpha, type, iMAP, iP, iConfLevel, options)
+
+    if strcmp(type, 'par')
+        % Inversion of Hessian
+        if isempty(options.fixedParameters)
+            Sigma = pinv(pStruct.MS.hessian(:,:,iMAP));
+        else
+            Sigma = nan(pStruct.number);
+            ind = setdiff(1:pStruct.number,options.fixedParameters);
+            Sigma(ind,ind) = pinv(pStruct.MS.hessian(ind,ind,iMAP));
+        end
+    else
+        Sigma = pStruct.MS.prop_Sigma(:,:,iMAP);
+    end
+
+    % Confidence intervals computed using local approximation and a
+    % threshold (-> similar to PL-based confidence intervals)
+    pStruct.CI.local_PL(iP,1,iConfLevel) = pStruct.MS.(type)(iP,iMAP) - sqrt(icdf('chi2',alpha,1)*Sigma(iP,iP));
+    pStruct.CI.local_PL(iP,2,iConfLevel) = pStruct.MS.(type)(iP,iMAP) + sqrt(icdf('chi2',alpha,1)*Sigma(iP,iP));
+
+    % Confidence intervals computed using local approximation and the
+    % probability mass (-> similar to Bayesian confidence intervals)
+    pStruct.CI.local_B(iP,1,iConfLevel)  = icdf('norm',  (1-alpha)/2,pStruct.MS.(type)(iP,iMAP),sqrt(Sigma(iP,iP)));
+    pStruct.CI.local_B(iP,2,iConfLevel)  = icdf('norm',1-(1-alpha)/2,pStruct.MS.(type)(iP,iMAP),sqrt(Sigma(iP,iP)));
+    
+end
+
+
+function pStruct = getCIfromProfiles(pStruct, alpha, type, iMAP, iP, iConfLevel)
+
+    if ~isempty(pStruct.P(iP).(type))
+        % left bound
+        if strcmp(type, 'par')
+            ind  = find(pStruct.P(iP).(type)(iP,:) <= pStruct.MS.(type)(iP,iMAP));
+            j = find(pStruct.P(iP).R(ind) <= exp(-icdf('chi2',alpha,1)/2),1,'last');
+            if ~isempty(j)
+                pStruct.CI.PL(iP,1,iConfLevel) = interp1(pStruct.P(iP).R(ind([j,j+1])),...
+                    pStruct.P(iP).(type)(iP,ind([j,j+1])),exp(-icdf('chi2',alpha,1)/2));
+            else
+                pStruct.CI.PL(iP,1,iConfLevel) = -inf;
+            end
+        else
+            ind  = find(pStruct.P(iP).(type) <= pStruct.MS.(type)(iP,1));
+            j = find(pStruct.P(iP).R(ind) <= exp(-icdf('chi2',alpha,1)/2),1,'last');
+            if ~isempty(j)
+                pStruct.CI.PL(iP,1,iConfLevel) = interp1(pStruct.P(iP).R(ind([j,j+1])),...
+                    pStruct.P(iP).(type)(ind([j,j+1])),exp(-icdf('chi2',alpha,1)/2));
+            else
+                pStruct.CI.PL(iP,1,iConfLevel) = -inf;
+            end
+        end
+        
+        % right bound
+        if strcmp(type, 'par')
+            ind  = find(pStruct.P(iP).(type)(iP,:) >= pStruct.MS.(type)(iP,iMAP));
+            j = find(pStruct.P(iP).R(ind) <= exp(-icdf('chi2',alpha,1)/2),1,'first');
+            if ~isempty(j)
+                pStruct.CI.PL(iP,2,iConfLevel) = interp1(pStruct.P(iP).R(ind([j-1,j])),...
+                    pStruct.P(iP).(type)(iP,ind([j-1,j])),exp(-icdf('chi2',alpha,1)/2));
+            else
+                pStruct.CI.PL(iP,2,iConfLevel) = inf;
+            end
+        else
+            ind  = find(pStruct.P(iP).(type) >= pStruct.MS.(type)(iP,1));
+            j = find(pStruct.P(iP).R(ind) <= exp(-icdf('chi2',alpha,1)/2),1,'first');
+            if ~isempty(j)
+                pStruct.CI.PL(iP,2,iConfLevel) = interp1(pStruct.P(iP).R(ind([j-1,j])),...
+                    pStruct.P(iP).(type)(ind([j-1,j])),exp(-icdf('chi2',alpha,1)/2));
+            else
+                pStruct.CI.PL(iP,2,iConfLevel) = inf;
+            end
+        end
+
+    else
+        pStruct.CI.PL(iP,[1,2],iConfLevel) = nan(1,2);
+    end
+
+end
diff --git a/Requirements/PESTO-1.1.0/getMultiStarts.m b/Requirements/PESTO-1.1.0/getMultiStarts.m
new file mode 100644
index 0000000000000000000000000000000000000000..64521e0a7e20c0283812bb4d9848aab30206c19d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getMultiStarts.m
@@ -0,0 +1,625 @@
+function [parameters,fh] = getMultiStarts(parameters, objective_function, varargin)
+% getMultiStarts() computes the maximum a posterior estimate of the
+% parameters of a user-supplied posterior function. Therefore, a
+% multi-start local optimization is used. The parameters from the best
+% value of the posterior function arethen used as the global optimum.
+% To ensure that the found maximum is a global one, a sufficiently high
+% number of multistarts must be done. Those starts can be initialized with
+% either randomly sampled parameter values, following either a uniform
+% distribution or a latin hypercube, or they can be sampled by a user
+% provided initial function (provided as option.init_fun).
+%
+% Note: This function can exploit up to (n_start + 1) workers when running
+% in 'parallel' mode.
+%
+% USAGE:
+% * [...] = getMultiStarts(parameters,objective_function)
+% * [...] = getMultiStarts(parameters,objective_function,options)
+% * [parameters,fh] = getMultiStarts(...)
+%
+% getMultiStarts() uses the following PestoOptions members:
+%  * PestoOptions::start_index
+%  * PestoOptions::n_starts
+%  * PestoOptions::mode
+%  * PestoOptions::fh
+%  * PestoOptions::fmincon
+%  * PestoOptions::proposal
+%  * PestoOptions::save
+%  * PestoOptions::foldername
+%  * PestoOptions::trace
+%  * PestoOptions::comp_type
+%  * PestoOptions::tempsave
+%  * PestoOptions::resetobjective
+%  * PestoOptions::obj_type
+%  * PestoOptions::init_threshold
+%  * PestoOptions::plot_options
+%
+% Parameters:
+%   parameters: parameter struct
+%   objective_function: objective function to be optimized.
+%       This function should accept one input, the parameter vector.
+%   varargin:
+%     options: A PestoOptions object holding various options for the
+%         algorithm.
+%
+% Required fields of parameters:
+%   number: Number of parameters
+%   min: Lower bound for each parameter
+%   max: upper bound for each parameter
+%   name = {'name1', ...}: names of the parameters
+%   guess: initial guess for the parameters (Optional, will be initialized
+%       empty if not provided)
+%   init_fun: function to draw starting points for local optimization, must
+%       have the structure init_fun(theta_0, theta_min, theta_max).
+%       (Only required if proposal == 'user-supplied')
+%
+% Return values:
+%   parameters: updated parameter object
+%   fh: figure handle
+%
+% Generated fields of parameters:
+%   MS: information about multi-start optimization
+%     * par0(:,i): starting point yielding ith MAP
+%     * par(:,i): ith MAP
+%     * logPost(i): log-posterior for ith MAP
+%     * logPost0(i): log-posterior for starting point yielding ith MAP
+%     * gradient(_,i): gradient of log-posterior at ith MAP
+%     * hessian(:,:,i): hessian of log-posterior at ith MAP
+%     * n_objfun(i): # objective evaluations used to calculate ith MAP
+%     * n_iter(i): # iterations used to calculate ith MAP
+%     * t_cpu(i): CPU time for calculation of ith MAP
+%     * exitflag(i): exitflag the optimizer returned for ith MAP
+%     * par_trace(:,:,i): parameter trace for ith MAP
+%         (if options.trace == true)
+%     * fval_trace(:,i): objective function value trace for ith MAP
+%         (if options.trace == true)
+%     * time_trace(:,i): computation time trace for ith MAP
+%         (if options.trace == true)
+
+
+global error_count
+
+%% Check inputs
+if length(varargin) >= 1
+    options = handleOptionArgument(varargin{1});
+else
+    options = PestoOptions();
+end
+
+if isempty(options.start_index)
+    options.start_index = 1:options.n_starts;
+end
+parameters = parametersSanityCheck(parameters);
+
+if (strcmp(options.localOptimizer, 'fmincon') && ( ~isfield(options.localOptimizerOptions, 'MaxFunEvals') || isempty(options.localOptimizerOptions.MaxFunEvals) ) )
+    options.localOptimizerOptions.MaxFunEvals = 200*parameters.number;
+end
+
+%% Initialization and figure generation
+fh = [];
+switch options.mode
+    case 'visual'
+        if (isempty(options.fh) || ~isvalid(options.fh))
+            fh = figure('Name', 'getMultiStarts');
+        else
+            fh = figure(options.fh);
+        end
+    case 'text'
+        fprintf(' \nOptimization:\n=============\n');
+    case 'silent' % no output
+        % Force fmincon to be silent.
+        if isfield(options.localOptimizerOptions, 'Display')
+            options.localOptimizerOptions.Display = 'off';
+        end
+end
+
+%% Definition of index set of optimized parameters
+freePars = setdiff(1:parameters.number, options.fixedParameters);
+if isempty(parameters.guess)
+    parameters.guess = zeros(parameters.number,0);
+end
+    
+%% Sampling of starting points
+switch options.proposal
+    case 'latin hypercube'
+        % Sampling from latin hypercube
+        par0_tmp = [parameters.guess(freePars,:),...
+            bsxfun(@plus,parameters.min(freePars),bsxfun(@times,parameters.max(freePars) - parameters.min(freePars),...
+            lhsdesign(options.n_starts - size(parameters.guess,2),length(freePars),'smooth','off')'))];
+    case 'uniform'
+        % Sampling from uniform distribution
+        par0_tmp = [parameters.guess(freePars,:),...
+            bsxfun(@plus,parameters.min,bsxfun(@times,parameters.max - parameters.min,...
+            rand(parameters.number,options.n_starts - size(parameters.guess,2))))];
+    case 'user-supplied'
+        % Sampling from user-supplied function
+        if (~isfield(parameters, 'init_fun') || isempty(parameters.init_fun))
+            if size(parameters.guess,2) < options.n_starts
+                error('You did not define an initial function and do not provide enough starting points in parameters.guess. Aborting.');
+            else
+                par0_tmp = parameters.guess(:,1:options.n_starts);
+            end
+        else
+            par0_tmp = [parameters.guess,...
+                parameters.init_fun(parameters.guess,parameters.min,parameters.max,options.n_starts - size(parameters.guess,2))];
+        end
+end
+% Correct for fixed parameters
+par0(freePars,:) = par0_tmp;
+par0(options.fixedParameters,:) = options.fixedParameterValues(:) * ones(1,options.n_starts);
+par0 = par0(:,options.start_index);
+parameters.MS.par0 = par0;
+
+%% Preparation of folder
+if or(options.save,options.tempsave)
+    if(~exist(fullfile(pwd,options.foldername),'dir'))
+        mkdir(fullfile(pwd,options.foldername))
+    end
+    % only save the init mat for the first start index, not every one if they are called seperately
+    if(and(options.save,~isempty(find(options.start_index == 1, 1))))
+        save([options.foldername '/init'],'parameters','-v7.3');
+    end
+end
+
+%% Initialization
+if isfield(options.localOptimizerOptions, 'MaxIter')
+    maxOptimSteps = options.localOptimizerOptions.MaxIter;
+elseif isfield(options.localOptimizerOptions, 'maxeval')
+    maxOptimSteps = options.localOptimizerOptions.maxeval;
+end
+parameters.MS.par = nan(parameters.number,length(options.start_index));
+parameters.MS.logPost0 = nan(length(options.start_index),1);
+parameters.MS.logPost = nan(length(options.start_index),1);
+parameters.MS.gradient = nan(parameters.number,length(options.start_index));
+parameters.MS.hessian  = nan(parameters.number,parameters.number,length(options.start_index));
+parameters.MS.n_objfun = nan(length(options.start_index),1);
+parameters.MS.n_iter = nan(length(options.start_index),1);
+parameters.MS.t_cpu = nan(length(options.start_index),1);
+parameters.MS.exitflag = nan(length(options.start_index),1);
+parameters.MS.AIC = nan(length(options.start_index),1);
+parameters.MS.BIC = nan(length(options.start_index),1);
+if(options.trace)
+    parameters.MS.par_trace = nan(parameters.number,maxOptimSteps+1,length(options.start_index));
+    parameters.MS.fval_trace = nan(maxOptimSteps+1,length(options.start_index));
+    parameters.MS.time_trace = nan(maxOptimSteps+1,length(options.start_index));
+end
+
+% Define the negative log-posterior funtion
+% (fmincon needs the neagtive log posterior for optimization)
+negLogPost = setObjectiveWrapper(objective_function, options, 'negative log-posterior', [], [], true, true);
+
+% Check, if Hessian should be used and if a Hessian function was set,
+% otherwise use the third output of the objective function instead
+if (strcmp(options.localOptimizer, 'fmincon') && ...
+        strcmp(options.localOptimizerOptions.Hessian, 'on'))
+    
+    if (~isfield(options.localOptimizerOptions, 'HessFcn') ...
+            || isempty(options.localOptimizerOptions.HessFcn))
+        
+        % this only works for box-constraints at the moment
+        options.localOptimizerOptions.HessFcn = @(varargin) HessianWrap(negLogPost, varargin);
+    end
+end
+
+waitbarFields1 = {'logPost', 'logPost0', 'n_objfun', 'n_iter', 't_cpu', 'exitflag'};
+waitbarFields2 = {'par', 'par0', 'gradient', 'fval_trace', 'time_trace'};
+waitbarFields3 = {'hessian', 'par_trace'};
+
+%% Multi-start local optimization -- SEQUENTIAL
+if strcmp(options.comp_type, 'sequential')
+    
+    % Matlab parallel toolbox seems to have problems with our outfun...
+    if isfield(options.localOptimizerOptions, 'OutputFcn')
+        options.localOptimizerOptions.OutputFcn = @outfun_fmincon;
+    end
+    
+    % initialize the waitbar
+    if(strcmp(options.mode,'visual'))
+        waitBar = waitbar(0, '1', 'name', 'Parameter estimation in process, please wait...', 'CreateCancelBtn', 'setappdata(gcbf, ''canceling'', 1)');
+        stringTimePrediction = updateWaitBar(nan);
+        waitbar(0, waitBar, stringTimePrediction);
+        C = onCleanup(@() delete(waitBar));
+    end
+    
+    % Loop: Multi-starts
+    for iMS = 1 : length(options.start_index)
+        % reset the objective function
+        if(options.resetobjective)
+            fun = functions(objective_function);
+            s_start = strfind(fun.function,')')+1;
+            s_end = strfind(fun.function,'(')-1;
+            clear(fun.function(s_start(1):s_end(2)));
+        end
+        
+        % Reset error count
+        error_count = 0;
+        
+        % Test evaluation of objective function at starting point
+        % Only for multi-start local, since other optimizers use a
+        % different initialization
+        if strcmp(options.localOptimizer, 'fmincon')
+            if (strcmp(options.localOptimizerOptions.Hessian, 'on'))
+                % Depending on the algorithm, the Hessian gets called
+                % seperately (IP) or with the objective function (TR), so
+                % different cases have to be checked.
+                if strcmp(options.localOptimizerOptions.Algorithm, 'interior-point')
+                    [negLogPost0,~] = negLogPost(par0(freePars,iMS));
+                else
+                    [negLogPost0,~,~] = negLogPost(par0(freePars,iMS));
+                end
+            elseif (strcmp(options.localOptimizerOptions.GradObj, 'on'))
+                [negLogPost0,~] = negLogPost(par0(freePars,iMS));
+            else
+                negLogPost0 = negLogPost(par0(freePars,iMS));
+            end
+            parameters.MS.logPost0(iMS) = -negLogPost0;
+        elseif (strcmp(options.localOptimizer, 'lsqnonlin'))
+            if (strcmp(options.localOptimizerOptions.Jacobian, 'on'))
+                [residuals,~] = negLogPost(par0(freePars,iMS));
+            else
+                residuals = negLogPost(par0(freePars,iMS));
+            end
+            negLogPost0 = 0.5 * sum(residuals.^2);
+            parameters.MS.logPost0(iMS) = -negLogPost0;
+        elseif (any(strcmp(options.localOptimizer, {'dhc','cs','bobyqa'})))
+            negLogPost0 = negLogPost(par0(freePars,iMS));
+        else
+            negLogPost0 = nan;
+        end
+        
+        % Optimization
+        startTimeLocalOptimization = cputime;
+        if (isnan(negLogPost0) || (negLogPost0 < -options.init_threshold))
+            
+            %% do optimization with chosen algorithm
+            try
+                switch options.localOptimizer
+                    case 'fmincon'
+                        % fmincon as local optimizer
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+                            = performOptimizationFmincon(parameters, negLogPost, par0(:,iMS), options);
+
+                    case {'meigo-ess', 'meigo-vns'}
+                        % Use the MEIGO toolbox as local / global optimizer
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+                            = performOptimizationMeigo(parameters, negLogPost, par0(:,iMS), options);
+
+                    case 'pswarm'
+                        % Optimization using a swarm based global optimizer PSwarm
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+                            = performOptimizationPswarm(parameters, negLogPost, par0(:,iMS), options);
+
+                    case 'lsqnonlin'
+                        % Optimization using dynamic hill climbin as local optimizer
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter, logPostOffset] ...
+                            = performOptimizationLsqnonlin(parameters, negLogPost, par0(:,iMS), options);
+                        if ~isempty(logPostOffset)
+                            options.logPostOffset = logPostOffset;
+                        end
+
+                    case 'cs'
+                        % Optimization using randomized coordinate search as local optimizer
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+                            = performOptimizationCoordinateSearch(parameters, negLogPost, par0(:,iMS), options);
+
+                    case 'dhc'
+                        % Optimization using dynamic hill climbing as local optimizer
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+                            = performOptimizationDhc(parameters, negLogPost, par0(:,iMS), options);
+
+                    case 'bobyqa'
+                        % Optimization using bobya as local optimizer
+                        [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+                            = performOptimizationBobyqa(parameters, negLogPost, par0(:,iMS), options);
+                end
+            catch ErrMsg
+                warning(['Multi-start number ' num2str(iMS) ' failed. More details on the error:']);
+                display(['Last Error in function ' ErrMsg.stack(1).name ', line ' ...
+                    num2str(ErrMsg.stack(1).line) ', file ' ErrMsg.stack(1).file '.']);
+                
+                % Assign values to exitflag, gradient etc. to avoid
+                % failure when assigning results
+                exitflag       = nan;
+                n_objfun       = nan;
+                n_iter         = nan;
+                negLogPost_opt = nan;
+                par_opt        = nan(size(freePars));
+                hessian_opt    = nan(length(freePars));
+            end
+            
+            % Assignment of results
+            parameters.MS.t_cpu(iMS) = cputime - startTimeLocalOptimization;
+            parameters.MS.exitflag(iMS) = exitflag;
+            parameters.MS.logPost0(iMS) = -negLogPost0;
+            parameters.MS.logPost(iMS) = -negLogPost_opt;
+            parameters.MS.par(:,iMS) = par_opt;
+            parameters.MS.gradient(freePars,iMS) = gradient_opt(:);
+            parameters.MS.hessian(freePars,freePars,iMS) = hessian_opt(:,:);
+            parameters.MS.n_objfun(iMS) = n_objfun;
+            parameters.MS.n_iter(iMS) = n_iter;
+            parameters.MS.AIC(iMS) = 2*length(freePars) + 2*negLogPost_opt;
+            if ~isempty(options.nDatapoints)
+                parameters.MS.BIC(iMS) = log(options.nDatapoints)*length(freePars) + 2*negLogPost_opt;
+            end
+            
+        end
+        
+        % Save
+        if options.save
+            saveResults(parameters,options,iMS)
+        end
+        
+        % Output
+        if strcmp(options.mode,'visual')
+            fh = plotMultiStarts(parameters, fh, options.plot_options);
+        elseif strcmp(options.mode,'text')
+            fprintf('%d / %d:\t fval = %.15f, t = %.6f\n', ...
+                iMS, length(options.start_index), parameters.MS.logPost(iMS), parameters.MS.t_cpu(iMS));
+        end
+        
+        % Abort the calculation if the waitbar is cancelled
+        if(strcmp(options.mode,'visual'))
+            if getappdata(waitBar, 'canceling')
+                parameters.MS.n_starts = iMS;
+                for iWaitbarField = 1:6
+                    parameters.MS.(waitbarFields1{iWaitbarField}) = ...
+                        parameters.MS.(waitbarFields1{iWaitbarField})(1:iMS, :);
+                end
+                for iWaitbarField = 1:5
+                    if (isfield(parameters.MS, waitbarFields2{iWaitbarField}))
+                        parameters.MS.(waitbarFields2{iWaitbarField}) = ...
+                            parameters.MS.(waitbarFields2{iWaitbarField})(:, 1:iMS);
+                    end
+                end
+                for iWaitbarField = 1:2
+                    if (isfield(parameters.MS, waitbarFields3{iWaitbarField}))
+                        parameters.MS.(waitbarFields3{iWaitbarField}) = ...
+                            parameters.MS.(waitbarFields3{iWaitbarField})(:, :, 1:iMS);
+                    end
+                end
+                
+                break;
+            end
+        end
+        
+        % update the waitbar
+        if(strcmp(options.mode,'visual'))
+            stringTimePrediction = updateWaitBar(nanmedian(parameters.MS.t_cpu(1:iMS)) * (length(options.start_index) - iMS));
+            waitbar(iMS / length(options.start_index), waitBar, stringTimePrediction);
+        end
+    end
+    
+    % Order
+    parameters = sortMultiStarts(parameters);
+end
+
+%% Multi-start local optimization -- PARALLEL
+% TODO: adapt parallel mode to sequential mode
+if strcmp(options.comp_type,'parallel')
+    
+    % Initialization
+    par = nan(parameters.number,length(options.start_index));
+    logPost0 = nan(length(options.start_index),1);
+    logPost = nan(length(options.start_index),1);
+    gradient = nan(parameters.number,length(options.start_index));
+    hessian  = nan(parameters.number,parameters.number,length(options.start_index));
+    n_objfun = nan(length(options.start_index),1);
+    n_iter = nan(length(options.start_index),1);
+    t_cpu = nan(length(options.start_index),1);
+    exitflag = nan(length(options.start_index),1);
+    
+    % reset the objective function
+    if(options.resetobjective)
+        fun = functions(objective_function);
+        s_start = strfind(fun.function,')')+1;
+        s_end = strfind(fun.function,'(')-1;
+        clear(fun.function(s_start(1):s_end(2)));
+    end
+    negLogPost = setObjectiveWrapper(objective_function, options, 'negative log-posterior', [], [], false, true);
+    
+    % Loop: Mutli-starts
+    parfor iMS = options.start_index
+        
+        % Evaluation of objective function at starting point
+        if (strcmp(options.localOptimizerOptions.Hessian, 'on'))
+            % Depending on the algorithm, the Hessian gets called
+            % seperately (IP) or with the objective function (TR), so
+            % different cases have to be checked.
+            if strcmp(options.localOptimizerOptions.Algorithm, 'interior-point')
+                [negLogPost0,~] = negLogPost(parameters.MS.par0(:,iMS));
+            else
+                [negLogPost0,~,~] = negLogPost(parameters.MS.par0(:,iMS));
+            end
+        elseif (strcmp(options.localOptimizerOptions.GradObj, 'on'))
+            [negLogPost0,~] = negLogPost(parameters.MS.par0(:,iMS));
+        else
+            negLogPost0 = negLogPost(parameters.MS.par0(:,iMS));
+        end
+        
+        % Optimization
+        startTimeLocalOptimization = cputime;
+        if negLogPost0 < -options.init_threshold
+            % Optimization using fmincon
+            [theta,J_opt,exitflag(iMS),results_fmincon,~,gradient_opt,hessian_opt] = ...
+                fmincon(negLogPost,...  % negative log-posterior function
+                parameters.MS.par0(:,iMS),...    % initial parameter
+                parameters.constraints.A  ,parameters.constraints.b  ,... % linear inequality constraints
+                parameters.constraints.Aeq,parameters.constraints.beq,... % linear equality constraints
+                parameters.min,...     % lower bound
+                parameters.max,...     % upper bound
+                [],options.localOptimizerOptions);   % options
+            
+            % Assignment
+            logPost(iMS) = -J_opt;
+            par(:,iMS) = theta;
+            gradient(:,iMS) = gradient_opt;
+            if isempty(hessian_opt)
+                if strcmp(options.localOptimizerOptions.Hessian,'on')
+                    [~,~,hessian_opt] = objectiveWrap(theta,objective_function,options.obj_type,options.objOutNumber);
+                end
+            elseif max(abs(hessian_opt(:))) == 0
+                if strcmp(options.localOptimizerOptions.Hessian,'on')
+                    [~,~,hessian_opt] = objectiveWrap(theta,objective_function,options.obj_type,options.objOutNumber);
+                end
+            end
+            hessian(:,:,iMS) = full(hessian_opt);
+            n_objfun(iMS) = results_fmincon.funcCount;
+            n_iter(iMS) = results_fmincon.iterations;
+        end
+        t_cpu(iMS) = cputime - startTimeLocalOptimization;
+        
+        % Save
+        if options.save
+            saveResults(parameters,options,iMS)
+        end
+        
+        % Output
+        switch options.mode
+            case 'text', disp(['  ' num2str(iMS,'%d') '/' num2str(length(options.start_index),'%d')]);
+            case {'silent','visual'} % no output
+        end
+    end
+    
+    % Assignment
+    parameters.MS.par = par;
+    parameters.MS.logPost0 = logPost0;
+    parameters.MS.logPost = logPost;
+    parameters.MS.gradient = gradient;
+    parameters.MS.hessian  = hessian;
+    parameters.MS.n_objfun = n_objfun;
+    parameters.MS.n_iter = n_iter;
+    parameters.MS.t_cpu = t_cpu;
+    parameters.MS.exitflag = exitflag;
+    parameters = sortMultiStarts(parameters);
+    
+    % Output
+    switch options.mode
+        case 'visual', fh = plotMultiStarts(parameters,fh,options.plot_options);
+        case {'text','silent'} % no output
+    end
+    
+end
+
+%% Output
+switch options.mode
+    case {'visual','text'}, disp('-> Multi-start optimization FINISHED.');
+    case 'silent' % no output
+end
+
+% Clear Output Function
+options.localOptimizerOptions.OutputFcn = [];
+
+%% Nested function for storing of objective function and parameter values
+    function stop = outfun_fmincon(x,optimValues,state)
+        
+        switch state
+            case 'init'
+                % do nothing
+            case 'interrupt'
+                % do nothing
+            case 'iter'
+                if(options.trace)
+                    parameters.MS.par_trace(:,optimValues.iteration+1,iMS) = x;
+                    parameters.MS.time_trace(optimValues.iteration+1,iMS) = cputime - startTimeLocalOptimization;
+                    if isfield(optimValues, 'fval')
+                        parameters.MS.fval_trace(optimValues.iteration+1,iMS) = optimValues.fval;
+                    else
+                        parameters.MS.fval_trace(optimValues.iteration+1,iMS) = optimValues.resnorm;
+                    end
+                end
+                if(options.tempsave)
+                    if optimValues.iteration>0
+                        if(mod(optimValues.iteration,10) == 0)
+                            saveResults(parameters,options,iMS);
+                        end
+                    end
+                end
+            case 'done'
+                % do nothing
+        end
+        
+        if error_count <= 20
+            stop = false;
+        else
+            warning('Too many failed objective function evaluations.')
+            stop = true;
+        end
+        
+    end
+end
+
+
+%% Waitbar Update
+function stringTimePrediction = updateWaitBar(timePredicted)
+% stringTimePrediction estimates the remaining time to display in the waitbar
+%
+% Parameters:
+%  timePredicted: Predicted time in seconds
+%
+% Return values:
+%  stringTimePrediction: String, Updating Message
+
+if isnan(timePredicted)
+    stringTimePrediction = 'Unknown.';
+elseif (timePredicted < 60)
+    stringTimePrediction = 'One minute or less...';
+elseif (timePredicted >= 60 && timePredicted < 3600)
+    stringTimePrediction = ['About ' num2str(round(timePredicted/60)) + 1 ' minutes'];
+elseif (timePredicted >= 3600 && timePredicted < 72000)
+    hours = floor(timePredicted/3600);
+    minutes = round((timePredicted - 3600*hours) / 600) * 10;
+    if (hours == 1)
+        stringTimePrediction = ['About 1 hour'];
+    else
+        stringTimePrediction = ['About ' num2str(hours) ' hours'];
+    end
+    if (minutes == 0)
+        stringTimePrediction = strcat(stringTimePrediction, '...');
+    else
+        stringTimePrediction = strcat(stringTimePrediction, [' and ' num2str(minutes) ' minutes...']);
+    end
+elseif (timePredicted >= 72000 && timePredicted < 36 * 3600)
+    stringTimePrediction = 'Roughly 1 day...';
+elseif (timePredicted >= 36 * 3600 && timePredicted < 2 * 365 * 24 * 3600)
+    stringTimePrediction = ['About ' num2str(round(timePredicted / 24 * 3600)) ' days...'];
+elseif (timePredicted >= 2 * 365 * 24 * 3600 && timePredicted < 100 * 365 * 24 * 3600)
+    stringTimePrediction = ['Oh boy! Quite some years... Maybe about ' num2str(round(timePredicted / 365 * 24 * 3600)) ' of them...'];
+elseif (timePredicted >= 100 * 365 * 24 * 3600 && timePredicted < 1e7 * 365 * 24 * 3600)
+    stringTimePrediction = 'Well... Maybe your children, or grand-children... No, not evem them...';
+else
+    stringTimePrediction = 'Kingdoms will rise, civilization will decline, stars will fade - but your calculation...(!) ;)';
+end
+stringTimePrediction = ['Predicted remaining waiting time: ', stringTimePrediction];
+
+end
+
+
+%% Saving results
+function saveResults(parameters,options,iMS)
+
+    % saveResults saves Multi-start results to disk
+    %
+    % Parameters:
+    %  parameters: Parameter struct passed to getMultiStarts
+    %  options: getMultiStarts options
+    %  i: multi-start index
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__logPost.csv']),parameters.MS.logPost(iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__logPost0.csv']),parameters.MS.logPost0(iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__par.csv']),parameters.MS.par(:,iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__par0.csv']),parameters.MS.par0(:,iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__gradient.csv']),parameters.MS.gradient(:,iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__hessian.csv']),parameters.MS.hessian(:,:,iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__t_cpu.csv']),parameters.MS.t_cpu(iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__n_objfun.csv']),parameters.MS.n_objfun(iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__n_iter.csv']),parameters.MS.n_iter(iMS),'delimiter',',','precision',12);
+    dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__exitflag.csv']),parameters.MS.exitflag(iMS),'delimiter',',','precision',12);
+    if(options.trace)
+        dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__par_trace.csv']),parameters.MS.par_trace(:,:,iMS),'delimiter',',','precision',12);
+        dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__fval_trace.csv']),parameters.MS.fval_trace(:,iMS),'delimiter',',','precision',12);
+        dlmwrite(fullfile(pwd,options.foldername ,['MS' num2str(options.start_index(iMS),'%d') '__time_trace.csv']),parameters.MS.time_trace(:,iMS),'delimiter',',','precision',12);
+    end
+    
+    % Commented out due to long saving times in case of large models
+%     save([options.foldername '/init'],'parameters','-v7.3');
+
+end
diff --git a/Requirements/PESTO-1.1.0/getParameterConfidenceIntervals.m b/Requirements/PESTO-1.1.0/getParameterConfidenceIntervals.m
new file mode 100644
index 0000000000000000000000000000000000000000..3735fedbe5a0990b178bbdfc3a7984e15f1bd898
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getParameterConfidenceIntervals.m
@@ -0,0 +1,50 @@
+function parameters = getParameterConfidenceIntervals(parameters, alpha, varargin)
+% getParameterConfidenceIntervals() calculates the confidence intervals 
+% for the model parameters. This is done by four approaches:
+% The values of CI.local_PL and CI.PL are determined by the point on which 
+% a threshold according to the confidence level alpha (calculated by a 
+% chi2-distribution) is reached. local_PL computes this point by a local
+% approximation around the MAP estimate using the Hessian matrix, PL uses 
+% the profile likelihoods instead.
+% The value of CI.local_B is computed by using the cummulative distribution
+% function of a local approximation of the profile based on the Hessian
+% matrix at the MAP estimate.
+% The value of CI.S is calculated using samples for the model parameters
+% and the according percentiles based on the confidence levels alpha.
+%
+% USAGE:
+% * parameters = getParameterConfidenceIntervals(parameters, alpha)
+%
+% Parameters:
+%   parameters: parameter struct
+%   alpha: vector with desired confidence levels for the intervals
+%   varargin: 
+%    options: A PestoOptions instance
+%
+% Return values:
+%   parameters: updated parameter struct
+%
+% Generated fields of parameters:
+%   CI: Information about confidence levels
+%     * local_PL: Threshold based approach, uses a local approximation by
+%         the Hessian matrix at the MAP estimate
+%         (requires parameters.MS, e.g. from getMultiStarts)
+%     * PL: Threshold based approach, uses profile likelihoods 
+%         (requires parameters.P, e.g. from getParameterProfiles)
+%     * local_B: Mass based approach, uses a local approximation by
+%         the Hessian matrix at the MAP estimate
+%         (requires parameters.MS, e.g. from getMultiStarts)
+%     * S: Bayesian approach, uses percentiles based on samples
+%         (requires parameters.S, e.g. from getParameterSamples)
+
+
+    %% Checking and assigning inputs
+    if length(varargin) >= 1
+        options = handleOptionArgument(varargin{1});
+    else
+        options = PestoOptions();
+    end
+
+    parameters = getConfidenceIntervals(parameters, alpha, 'par', options);
+
+end
diff --git a/Requirements/PESTO-1.1.0/getParameterProfiles.m b/Requirements/PESTO-1.1.0/getParameterProfiles.m
new file mode 100644
index 0000000000000000000000000000000000000000..1dc7e2b5504a28a60af42b00e95045f691fb24ad
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getParameterProfiles.m
@@ -0,0 +1,242 @@
+function [parameters,fh] = getParameterProfiles(parameters, objective_function, varargin)
+% getParameterProfiles.m calculates the profiles likelihoods for the model 
+% parameters, starting from the maximum a posteriori estimate. This
+% calculation is done by fixing the i-th parameter and repeatedly
+% reoptimizing the likelihood/posterior estimate (for all i). The initial 
+% guess for the next reoptimization point is computed by extrapolation from
+% the previous points to ensure a quick optimization.
+%
+% Note: This function can exploit up to (n_theta + 1) workers when running
+% in 'parallel' mode.
+%
+% USAGE:
+% [...] = getParameterProfiles(parameters, objective_function)
+% [...] = getParameterProfiles(parameters, objective_function, options)
+% [parameters, fh] = getParameterProfiles(...)
+%
+% getParameterProfiles() uses the following PestoOptions members:
+%  * PestoOptions::calc_profiles
+%  * PestoOptions::comp_type
+%  * PestoOptions::dJ
+%  * PestoOptions::dR_max
+%  * PestoOptions::fh
+%  * PestoOptions::MAP_index
+%  * PestoOptions::mode
+%  * PestoOptions::obj_type
+%  * PestoOptions::options_getNextPoint .guess .min .max .update .mode
+%  * PestoOptions::parameter_index
+%  * PestoOptions::parameter_method_index
+%  * PestoOptions::profile_method
+%  * PestoOptions::profileOptimizationOptions
+%  * PestoOptions::plot_options
+%  * PestoOptions::R_min
+%  * PestoOptions::save
+%
+% Parameters:
+%   parameters: parameter struct
+%   objective_function: objective function to be optimized. 
+%       This function should accept one input, the parameter vector.
+%   varargin:
+%     options: A PestoOptions object holding various options for the 
+%         algorithm.
+%
+% Required fields of parameters:
+%   number: Number of parameters
+%   min: Lower bound for each parameter
+%   max: upper bound for each parameter
+%   name = {'name1', ...}: names of the parameters
+%   MS: results of global optimization, obtained using for instance 
+%       the routine 'getMultiStarts.m'. MS has to contain at least
+%     * par: sorted list n_theta x n_starts of parameter estimates.
+%          The first entry is assumed to be the best one.
+%     * logPost: sorted list n_starts x 1 of of log-posterior values
+%          corresponding to the parameters listed in .par.
+%     * hessian: Hessian matrix (or approximation) at the optimal point
+%
+% Return values:
+%   parameters: updated parameter struct
+%   fh: figure handle
+%
+% Generated fields of parameters:
+%   P(i): profile for i-th parameter
+%     * par: MAPs along profile
+%     * logPost: maximum log-posterior along profile
+%     * R: ratio
+%
+% History:
+% * 2012/05/16 Jan Hasenauer
+% * 2014/06/12 Jan Hasenauer
+% * 2016/10/04 Daniel Weindl
+% * 2016/10/12 Paul Stapor
+
+    %% Check and assign inputs
+    if length(varargin) >= 1
+        options = handleOptionArgument(varargin{1});
+    else
+        options = PestoOptions();
+    end
+
+    % Check if MultiStart was launched before and was successful
+    if(~isfield(parameters, 'MS'))
+        error('No information from optimization available. Please run getMultiStarts() before getParameterProfiles.');
+    end
+    if (isempty(options.MAP_index))
+        options.MAP_index = 1;
+    end
+    if any(isnan([parameters.MS.par(:,options.MAP_index); parameters.MS.logPost(options.MAP_index)]))
+        error(['It seems like the multi-start index from which you want to start a ' ...
+            'profile calculation was not successful. Please check your multi-start ' ...
+            'results and options.MAP_index!']);
+    end
+                
+    % Check and assign options
+    options.P.min = parameters.min;
+    options.P.max = parameters.max;
+    if isempty(options.profileOptimizationOptions)
+        options.profileOptimizationOptions = options.localOptimizerOptions;
+    end
+    if (~isfield(options.profileOptimizationOptions, 'MaxFunEvals') ...
+                || isempty(options.profileOptimizationOptions.MaxFunEvals)) 
+        options.profileOptimizationOptions.MaxFunEvals = 200 * parameters.number;
+    end
+    
+    % Check for emptiness of options
+    if (strcmp(options.localOptimizer, 'lsqnonlin') && isempty(options.logPostOffset))
+        residuals = objective_function(parameters.MS.par(:,1));
+        logPostOffset = - parameters.MS.logPost(1) - 0.5 * sum(residuals.^2);
+        options.logPostOffset = logPostOffset;
+    end
+
+    % Check for emptiness of options
+    if isempty(union(union(options.profile_optim_index, options.profile_integ_index), options.parameter_index))
+        options.parameter_index = 1 : parameters.number;
+    end
+    
+    % Process, which profiles should be computed in which manner
+    if strcmp(options.profile_method, 'default')
+        if (isempty(options.profile_optim_index) && isempty(options.profile_integ_index))
+            options.profile_method = 'optimization';
+        elseif (~isempty(options.profile_optim_index) && isempty(options.profile_integ_index))
+            options.profile_method = 'optimization';
+        elseif (isempty(options.profile_optim_index) && ~isempty(options.profile_integ_index))
+            options.profile_method = 'integration';
+        elseif (~isempty(options.profile_optim_index) && ~isempty(options.profile_integ_index))
+            options.profile_method = 'mixed';
+        end
+    end
+    
+    switch options.profile_method  
+        case 'optimization'
+            options.parameter_index = setdiff(union(options.profile_optim_index, options.parameter_index), options.fixedParameters);
+            options.profile_optim_index = transpose(options.parameter_index(:));
+            
+        case 'integration'
+            options.parameter_index = setdiff(union(options.profile_integ_index, options.parameter_index), options.fixedParameters);
+            options.profile_integ_index = transpose(options.parameter_index(:));
+            
+        case 'mixed'
+            % If profiles are to be computed in a mixed manner, the correpsonding
+            % indices must be set properly
+            options.parameter_index = setdiff(union(options.profile_optim_index, options.profile_integ_index), options.fixedParameters);
+            options.profile_optim_index = transpose(setdiff(options.profile_optim_index(:), options.fixedParameters(:)));
+            options.profile_integ_index = transpose(setdiff(options.profile_integ_index(:), options.fixedParameters(:)));
+            
+        otherwise
+                error('Unknown profile computationg method. Please choose optimization, integration, mixed, or default');
+    end
+    
+    % We don't want to depend on the transposition of the parameter index
+    options.parameter_index = transpose(options.parameter_index(:));
+    
+    % Check that parameters for which profiles are computed are not fixed
+    if any(ismember(options.parameter_index, options.fixedParameters))
+        options.profile_optim_index = setdiff(options.profile_optim_index, options.fixedParameters);
+        options.profile_integ_index = setdiff(options.profile_integ_index, options.fixedParameters);
+        warning('Profiles will not be computed for fixed parameters!');
+    end
+
+    %% Initialization and figure generation
+    fh = [];
+    switch options.mode
+        case 'visual'
+            if (isempty(options.fh) || ~isvalid(options.fh))
+                fh = figure('Name','getParameterProfiles');
+            else
+                fh = figure(options.fh);
+            end
+        case 'text'
+            fprintf(' \nProfile likelihood caculation:\n===============================\n');
+        case 'silent' % no output
+            % Force fmincon to be silent.
+            options.profileOptimizationOptions.display = 'off';
+    end
+
+    %% Initialization of parameter struct
+    for iPar = transpose(options.parameter_index(:))
+        parameters.P(iPar).par = parameters.MS.par(:,options.MAP_index);
+        parameters.P(iPar).logPost = parameters.MS.logPost(options.MAP_index);
+        parameters.P(iPar).R = exp(parameters.MS.logPost(options.MAP_index)-parameters.MS.logPost(1));
+    end
+
+    %% Preperation of folder
+    if options.save
+        [~,~,~] = mkdir(options.foldername);
+        save([options.foldername '/init'],'parameters');
+    end
+    
+    %% Profile calculation
+    if options.calc_profiles
+        switch options.profile_method
+            case 'optimization'
+                [parameters, fh] = getParProfilesByOptimization(parameters, objective_function, options,fh);
+
+            case 'integration'
+                [parameters, fh] = getParProfilesByIntegration(parameters, objective_function, options, fh);
+
+            case 'mixed'
+                if strcmp(options.comp_type,'sequential')
+                    for j = options.parameter_index
+                        tempOptions = options;
+                        if sum(j == options.profile_integ_index) == 1
+                            tempOptions.profile_integ_index = j;
+                            [parameters, fh] = getParProfilesByIntegration(parameters, objective_function, tempOptions, fh);
+                        elseif sum(j == options.profile_integ_index) == 0
+                            tempOptions.profile_optim_index = j;
+                            [parameters, fh] = getParProfilesByOptimization(parameters, objective_function, tempOptions, fh);
+                        else
+                            error('Some really strange error for the profile calculation indices occured');
+                        end
+                    end
+
+                elseif strcmp(options.comp_type,'parallel')
+                    parfor j = options.parameter_index
+                        tempOptions = options;
+                        if sum(j == options.profile_integ_index) == 1
+                            tempOptions.profile_integ_index = j;
+                            getParProfilesByIntegration(parameters, objective_function, tempOptions, fh);
+                        elseif sum(j == options.profile_integ_index) == 0
+                            tempOptions.profile_optim_index = j;
+                            getParProfilesByOptimization(parameters, objective_function, tempOptions, fh);
+                        else
+                            error('Some really strange error for the profile calculation indices occured');
+                        end
+                    end
+
+                    % Output
+                    switch options.mode
+                        case 'visual', fh = plotParameterProfiles(parameters,'1D',fh,options.parameter_index,options.plot_options);
+                        case 'text' % no output
+                        case 'silent' % no output
+                    end
+                end
+        end
+
+    end
+
+    %% Output
+    switch options.mode
+        case {'visual','text'}, disp('-> Profile calculation for parameters FINISHED.');
+        case 'silent' % no output
+    end
+
+end
diff --git a/Requirements/PESTO-1.1.0/getParameterSamples.m b/Requirements/PESTO-1.1.0/getParameterSamples.m
new file mode 100644
index 0000000000000000000000000000000000000000..94b54ce5a283674c8bc56ffe8df5f5b99394cc8a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getParameterSamples.m
@@ -0,0 +1,90 @@
+function parameters = getParameterSamples(parameters, objFkt, options)
+   % getParameterSamples.m performs MCMC sampling of the posterior
+   %   distribution. 
+   %
+   %   Note, the DRAM library routine tooparameters.minox is
+   %   used internally. This function is capable of sampling with MH, AM,
+   %   DRAM, MALA, PT, PHS and RBPT. The sampling plotting routines should no longer
+   %   be contained in here but as standalone scripts capable of using the
+   %   resulting par.S.
+   %
+   % Parameters:
+   %   parameters: parameter struct covering model options and results obtained by
+   %               optimization, profiles and sampling. Optimization results
+   %               can be used for initialization.
+   %   objFkt: Objective function which measures the difference of model output and data
+   %   options:   An options object holding various options for the
+   %              sampling. Depending on the algorithm and particular flavor,
+   %              different options must be set: For details, please visit
+   %              PestoSamplingOptions.m
+   %
+   % Required fields of parameters:
+   %  min: Lower parameter bounds
+   %  max: Upper parameter bounds
+   %  number: Number of parameters
+   %
+   % Return values:
+   %  parameters: The provided parameters struct
+   %
+   % Generated fields of parameters:
+   %  S: The obtained sampling results
+   %
+   % History:
+   % * 2012/07/11 Jan Hasenauer
+   % * 2015/04/29 Jan Hasenauer
+   % * 2016/10/17 Benjamin Ballnus
+   % * 2016/10/19 Daniel Weindl
+   % * 2016/11/04 Paul Stapor
+   % * 2017/02/01 Benjamin Ballnus
+   
+   
+   
+   %% Check and assign inputs, note that theta0 and sigma0 are always set manually outside this function
+   options.MCMC = options.MCMC.checkDependentDefaults(parameters);
+   
+   %% Wrap objective function
+   logPosterior = setObjectiveWrapper(objFkt, options, 'log-posterior', [], [], false, true);
+   
+   %% Selection of sampling procedure
+   switch options.MCMC.samplingAlgorithm
+      
+      % DRAM
+      case 'DRAM'
+         parameters.S = performDRAM( logPosterior, parameters, options.MCMC );
+         
+      % MALA
+      case 'MALA'
+         parameters.S = performMALA( logPosterior, parameters, options.MCMC );
+         
+      % MH, AM and PT
+      case 'PT'
+         parameters.S = performPT( logPosterior, parameters, options.MCMC );
+         
+      % PHS
+      case 'PHS'
+         parameters.S = performPHS( logPosterior, parameters, options.MCMC );
+         
+      % RBPT
+      case 'RAMPART'
+         parameters.S = performRAMPART( logPosterior, parameters, options.MCMC );
+   end
+   
+   %% Output
+  	switch options.mode
+        case 'visual'
+            samplingPlottingOpt = PestoPlottingOptions();
+            samplingPlottingOpt.S.plot_type = 1;
+            samplingPlottingOpt.S.ind = 1;
+            fh = figure('Name','plotParameterSamples - 1D');
+            plotParameterSamples(parameters,'1D',fh,[],samplingPlottingOpt);
+            fh = figure('Name','plotParameterSamples - 2D');
+            plotParameterSamples(parameters,'2D',fh,[],samplingPlottingOpt);
+            disp('-> Sampling FINISHED.');
+        case 'text', disp('-> Sampling FINISHED.');
+        case 'silent'
+    end
+   
+end
+
+
+
diff --git a/Requirements/PESTO-1.1.0/getPropertyConfidenceIntervals.m b/Requirements/PESTO-1.1.0/getPropertyConfidenceIntervals.m
new file mode 100644
index 0000000000000000000000000000000000000000..526261df03622e1171cc9ef115796aae6121be55
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getPropertyConfidenceIntervals.m
@@ -0,0 +1,46 @@
+function properties = getPropertyConfidenceIntervals(properties, alpha, varargin)
+% getPropertyConfidenceIntervals.m calculates the confidence intervals 
+% for the model properties. This is done by three approaches:
+% The values of CI.local_PL and CI.PL are determined by the point on which 
+% a threshold according to the confidence level alpha (calculated by a 
+% chi2-distribution) is reached. local_PL computes this point by a local
+% approximation around the MAP estimate using the Hessian matrix, PL uses 
+% the profile likelihoods instead.
+% The value of CI.local_B is computed by using the cummulative distribution
+% function of a local approximation of the profile based on the Hessian
+% matrix at the MAP estimate.
+%
+% USAGE:
+% * properties = getPropertyConfidenceIntervals(properties, alpha)
+%
+% Parameters:
+%   properties: property struct
+%   alpha: vector with desired confidence levels for the intervals
+%   varargin: 
+%    options: A PestoOptions instance
+%
+% Return values:
+%   properties: updated properties struct
+%
+% Generated fields of properties:
+%   CI: Information about confidence levels
+%     * local_PL: Threshold based approach, uses a local approximation by
+%         the Hessian matrix at the MAP estimate
+%         (requires parameters.MS, e.g. from getMultiStarts)
+%     * PL: Threshold based approach, uses profile likelihoods 
+%         (requires parameters.P, e.g. from getParameterProfiles)
+%     * local_B: Mass based approach, uses a local approximation by
+%         the Hessian matrix at the MAP estimate
+%         (requires parameters.MS, e.g. from getMultiStarts)
+
+
+    %% Checking and assigning inputs
+    if length(varargin) >= 1
+        options = handleOptionArgument(varargin{1});
+    else
+        options = PestoOptions();
+    end
+
+    properties = getConfidenceIntervals(properties, alpha, 'prop', options);
+
+end
diff --git a/Requirements/PESTO-1.1.0/getPropertyMultiStarts.m b/Requirements/PESTO-1.1.0/getPropertyMultiStarts.m
new file mode 100644
index 0000000000000000000000000000000000000000..2ee026e1fd3cb94fb704cdb03b65696f9770bda2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getPropertyMultiStarts.m
@@ -0,0 +1,173 @@
+function [properties,fh] = getPropertyMultiStarts(properties, parameters, varargin)
+% getPropertyMultiStarts.m evaluates the properties for the different
+%   mutli-start results.
+%
+% USAGE:
+% [...] = getPropertyMultiStarts(properties,parameters)
+% [...] = getPropertyMultiStarts(properties,parameters,options)
+% [parameters,fh] = getPropertyMultiStarts(...)
+%
+% getPropertyMultiStarts() uses the following PestoOptions members:
+%  * PestoOptions::mode
+%  * PestoOptions::fh
+%  * PestoOptions::save
+%  * PestoOptions::foldername
+%  * PestoOptions::comp_type
+%
+% Parameters:
+%   parameters: parameter struct containing at least:
+%      MS: information about multi-start optimization
+%   properties: property struct containing at least:
+%     number: Number of properties
+%     min: lower bound for property values       
+%     max: upper bound for property values       
+%     name = {'name1',...}: names of the properties 
+%     function = {'function1',...}: functions to evaluate property  
+%         values. These functions provide the values of the respective  
+%         properties and the corresponding 1st and 2nd order
+%         derivatives.
+%   varargin:
+%     options: A PestoOptions object holding the options for the algorithm.
+%
+% Return values:
+%   properties: updated parameter object containing:
+%     MS: properties for multi-start optimization results
+%       * par(:,i): ith MAP
+%       * logPost(i): log-posterior for ith MAP
+%       * exitflag(i): exit flag of ith MAP
+%       * prop(j,i): values of jth property for ith MAP
+%       * prop_Sigma(:,:,i): covariance of properties for ith MAP
+% fh: figure handle
+%
+% History:
+% * 2015/03/03 Jan Hasenauer
+% * 2016/04/10 Daniel Weindl
+
+%% Check and assign inputs
+if length(varargin) >= 1
+    options = handleOptionArgument(varargin{1});
+else
+    options = PestoOptions();
+end
+
+properties = propertySanityCheck(properties);
+
+%% Initialization and figure generation
+fh = [];
+switch options.mode
+    case 'visual'
+        if (isempty(options.fh) || ~isvalid(options.fh))
+            fh = figure('Name','getPropertyMultiStarts');
+        else
+            fh = figure(options.fh);
+        end
+    case 'text'
+        fprintf(' \nProperty evaluation:\n====================\n');
+end
+
+%% Initialization
+properties.MS.par = parameters.MS.par;
+properties.MS.logPost = parameters.MS.logPost;
+properties.MS.exitflag = parameters.MS.exitflag;
+properties.MS.prop = nan(properties.number,length(properties.MS.logPost));
+properties.MS.prop_Sigma = nan(properties.number,properties.number,length(properties.MS.logPost));
+
+%% Preperation of folder
+if options.save
+    rmdir(options.foldername,'s'); 
+    mkdir(options.foldername);
+    save([options.foldername '/properties_init'],'properties');
+end
+
+%% Evaluation of properties for multi-start results -- SEQUENTIAL
+if strcmp(options.comp_type,'sequential')
+
+% Loop: Multi-start results
+for j = 1:length(properties.MS.logPost)
+    % Loop: Properties
+    G = nan(parameters.number,properties.number);
+    if (~isnan(properties.MS.logPost(j)))
+        for i = 1:properties.number
+            try
+                [properties.MS.prop(i,j),G(:,i)] = properties.function{i}(properties.MS.par(:,j));
+            catch
+                properties.MS.prop(i,j) = properties.function{i}(properties.MS.par(:,j));
+            end
+        end
+        properties.MS.prop_Sigma(:,:,j) = G'*pinv(squeeze(parameters.MS.hessian(:,:,j)))*G;
+    end
+    
+    % Save
+    if options.save
+        dlmwrite([options.foldername '/properties_MS' num2str(i,'%d') '__prop.csv'],properties.MS.prop(:,j),'delimiter',',','precision',12);
+        dlmwrite([options.foldername '/properties_MS' num2str(i,'%d') '__prop_Sigma.csv'],properties.MS.prop_Sigma(:,:,j),'delimiter',',','precision',12);
+    end
+    
+    % Output
+    if (mod(j,100) == 0) || (j == length(properties.MS.logPost))
+        str = ['Property evaluation for multi-start results completed to ' num2str(100*j/length(properties.MS.logPost),'%d') ' %'];
+        switch options.mode
+            case 'visual', fh = plotPropertyMultiStarts(properties,fh);
+            case 'text', disp(str);
+            case 'silent' % no output
+        end
+    end
+end
+
+end
+
+%% Evaluation of properties for multi-start results -- PARALLEL
+if strcmp(options.comp_type,'parallel')
+
+% Initialization
+prop = nan(properties.number,length(properties.MS.logPost));
+prop_Sigma = nan(properties.number,properties.number,length(properties.MS.logPost));
+
+% Create local partial copies of the parameter and the propertry struct
+para_num = parameters.number;
+para_hes = parameters.MS.hessian;
+para_MS_par = parameters.MS.par;
+prop_num = properties.number;
+prop_fun = properties.function;
+prop_logPost = properties.MS.logPost;
+opt_save = options.save;
+opt_folder = options.foldername;
+
+% Loop: Multi-start results
+parfor i = 1:length(prop_logPost)
+    % Loop: Properties
+    P = nan(prop_num, 1);
+    G = nan(para_num, prop_num);
+    if (~isnan(prop_logPost(i)))
+        for j = 1 : prop_num
+            try
+                [P(j),G(:,j)] = prop_fun{j}(para_MS_par(:,i));
+            catch
+                P(j) = prop_fun{j}(para_MS_par(:,i));
+            end
+        end
+        % Assignment
+        prop(:,i) = P;
+        prop_Sigma(:,:,i) = G' * pinv(squeeze(para_hes(:,:,i))) * G;
+    end
+    
+    % Save
+    if (opt_save)
+        dlmwrite([opt_folder '/properties_MS' num2str(i,'%d') '__prop.csv'],prop(:,i),'delimiter',',','precision',12);
+        dlmwrite([opt_folder '/properties_MS' num2str(i,'%d') '__prop_Sigma.csv'],prop_Sigma(:,:,i),'delimiter',',','precision',12);
+    end
+end
+
+% Assignment
+properties.MS.prop = prop;
+properties.MS.prop_Sigma = prop_Sigma;
+
+end
+
+%% Output
+switch options.mode
+    case {'visual','text'}, disp('-> Property evaluation for multi-start results FINISHED.');
+    case 'silent' % no output
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/getPropertyProfiles.m b/Requirements/PESTO-1.1.0/getPropertyProfiles.m
new file mode 100644
index 0000000000000000000000000000000000000000..89dbc2aa20b2dc8f2af144069996d83f86dba741
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getPropertyProfiles.m
@@ -0,0 +1,726 @@
+function [properties,fh] = getPropertyProfiles(properties, parameters, objective_function, varargin)
+% getPropertyProfiles.m calculates the profiles of user-supplied property
+% functions, starting from the maximum a posteriori estimate. This
+% calculation is done by varying the value of each property function
+% respectively, starting from the value of this function at the global
+% optimum and by reoptimizing the likelihood/posterior estimate in each 
+% variational step of the property. The initial guess for the next 
+% reoptimization point is computed by extrapolation from the previous 
+% points to ensure a quick optimization.
+%
+% Note: This function can exploit up to (n_theta + 1) workers when running
+% in 'parallel' mode.
+%
+% USAGE:
+% [...] = getPropertyProfiles(properties, parameters, objective_function)
+% [...] = getPropertyProfiles(properties, parameters, objective_function, options)
+% [parameters, fh] = getPropertyProfiles(...)
+%
+% % getPropertyProfiles() uses the following PestoOptions members:
+%  * PestoOptions::boundary
+%  * PestoOptions::calc_profiles
+%  * PestoOptions::comp_type
+%  * PestoOptions::dJ
+%  * PestoOptions::dR_max
+%  * PestoOptions::fh
+%  * PestoOptions::fmincon
+%  * PestoOptions::foldername
+%  * PestoOptions::MAP_index
+%  * PestoOptions::mode
+%  * PestoOptions::obj_type
+%  * PestoOptions::options_getNextPoint .guess .min .max .update .mode
+%  * PestoOptions::plot_options
+%  * PestoOptions::property_index
+%  * PestoOptions::R_min
+%  * PestoOptions::save
+%
+% Parameters:
+%   properties: property struct
+%   parameters: parameter struct
+%   objective_function: objective function to be optimized. 
+%       This function should accept one input, the parameter vector.
+%   varargin:
+%     options: A PestoOptions object holding various options for the 
+%         algorithm.
+%
+% Required fields of properties:
+%   number: Number of properties
+%   min: Lower bound for each properties
+%   max: upper bound for each properties    
+%   name = {'name1', ...}: names of the properties   
+%   function = {'function1', ...}: functions to evaluate property  
+%       values. These functions provide the values of the respective  
+%       properties and the corresponding 1st and 2nd order
+%       derivatives.
+%
+% Required fields of parameters:
+%   number: Number of parameters
+%   min: Lower bound for each parameter
+%   max: upper bound for each parameter    
+%   name = {'name1', ...}: names of the parameters       
+%   MS: results of global optimization, obtained using for instance 
+%       the routine 'getMultiStarts.m'. MS has to contain at least
+%     * par: sorted list n_theta x n_starts of parameter estimates.
+%          The first entry is assumed to be the best one.
+%     * logPost: sorted list n_starts x 1 of of log-posterior values
+%          corresponding to the parameters listed in .par.
+%     * hessian: Hessian matrix (or approximation) at the optimal point
+% 
+%
+% Return values:
+%   properties: updated property struct
+%   fh: figure handle
+%
+% Generated fields of properties:
+%   P(i): profile for i-th parameter
+%     * prop: MAPs along profile
+%     * par: MAPs along profile
+%     * logPost: maximum log-posterior along profile
+%     * R: ratio
+%
+% History:
+% * 2012/03/02 Jan Hasenauer
+% * 2016/04/10 Daniel Weindl
+% * 2016/10/12 Paul Stapor
+
+%% Check and assign inputs
+if length(varargin) >= 1
+    options = handleOptionArgument(varargin{1});
+else
+    options = PestoOptions();
+end
+
+% Check and assign options
+%TODO
+options.plot_options.mark_constraint = false;
+options.P.min = parameters.min;
+options.P.max = parameters.max;
+options.MAP_index = 1;
+
+% Warning if objective function gradient is not available
+if isempty(options.profileOptimizationOptions)
+    options.profileOptimizationOptions = options.localOptimizerOptions;
+end
+if ~strcmp(options.profileOptimizationOptions.GradObj, 'on')
+    warning('For efficient and reliable optimization, getPropertyProfiles.m requires gradient information.')
+end
+
+%% Initialization and figure generation
+fh = [];
+switch options.mode
+    case 'visual'
+        if (isempty(options.fh) || ~isvalid(options.fh))
+            fh = figure('Name','getPropertyProfiles');
+        else
+            fh = figure(options.fh);
+        end
+    case 'text'
+        fprintf(' \nProfile likelihood caculation:\n===============================\n');
+    case 'silent' % no output
+        % Force fmincon to be silent.
+        options.profileOptimizationOptions.Display = 'off';
+end
+
+% Check, if MultiStart was launched before
+if(~isfield(parameters, 'MS'))
+    error('No information from multi-start local optimization available. Please run getMultiStarts() before getParameterProfiles.');
+end
+
+% Check and assign options
+options.P.min = properties.min;
+options.P.max = properties.max;
+if isempty(options.property_index)
+    options.property_index = 1:properties.number;
+end
+if (isempty(options.MAP_index))
+    options.MAP_index = 1;
+end
+
+options.profileOptimizationOptions.algorithm = 'interior-point';
+options.profileOptimizationOptions.MaxIter = 400;
+options.profileOptimizationOptions.TolCon = 1e-4;
+options.profileOptimizationOptions.MaxFunEvals = 200*parameters.number;
+
+%% Initialization of property struct
+for i = options.property_index
+    properties.P(i).prop = properties.MS.prop(i,options.MAP_index);
+    properties.P(i).par = properties.MS.par(:,options.MAP_index);
+    properties.P(i).logPost = properties.MS.logPost(options.MAP_index);
+    properties.P(i).R = 1;
+end
+logPost_max = properties.MS.logPost(1);
+
+%% Preperation of folder
+if options.save
+    [~,~,~] = mkdir(options.foldername);
+    save([options.foldername '/init'],'properties');
+end
+
+%% Profile calculation -- SEQUENTIAL
+if strcmp(options.comp_type,'sequential') && options.calc_profiles
+    
+    % Profile calculation
+    for i = options.property_index
+        % Initialization
+        P_prop = properties.MS.prop(i,options.MAP_index);
+        P_par = parameters.MS.par(:,options.MAP_index);
+        P_logPost = parameters.MS.logPost(options.MAP_index);
+        P_R = exp(parameters.MS.logPost(options.MAP_index)-parameters.MS.logPost(1));
+        if isfield(parameters.MS,'exitflag')
+            P_exitflag = parameters.MS.exitflag(options.MAP_index);
+        else
+            P_exitflag = NaN;
+        end
+                
+        if ((P_prop <= properties.min(i)) || (properties.max(i) <= P_prop)) && ~strcmp(options.mode,'silent')
+            warning(['MAP of ' num2str(i) ordstr(i) ' property not between respective minimum and maximum.']);
+        end
+        
+        % Compute profile for in- and decreasing property
+        for s = [-1,1]
+            % Starting point
+            prop = properties.MS.prop(i,options.MAP_index);
+            theta  = parameters.MS.par(:,options.MAP_index);
+            logPost = parameters.MS.logPost(options.MAP_index);
+            
+            computeProfile = (logPost >= (log(options.R_min) + parameters.MS.logPost(1))) && ...
+                    (prop > (properties.min(i)+options.boundary_tol)) && ...
+                    ((properties.max(i)-options.boundary_tol) > prop);
+                
+            % Sequential update    
+            while computeProfile
+                
+                % Proposal of next profile point
+                J_exp = -(log(1-options.dR_max)+options.dJ*(logPost-logPost_max)+logPost);
+
+                % Optimization
+                [theta,prop,exitflag] = ...
+                    fmincon(@(theta) prop_fun(theta,properties.function{i},properties.min(i),properties.max(i),s),...
+                                        theta,...
+                                        parameters.constraints.A  ,parameters.constraints.b  ,... % linear inequality constraints
+                                        parameters.constraints.Aeq,parameters.constraints.beq,... % linear equality constraints
+                                        parameters.min,...   % lower bound
+                                        parameters.max,...   % upper bound
+                                        @(theta) obj_con(theta,objective_function,-J_exp,options.obj_type),...
+                                        options.profileOptimizationOptions);    % options
+
+                % Adaptation of signs                    
+                if s == +1
+                    prop = -prop;
+                end
+
+                % Reoptimization at boundary
+                if (prop <= properties.min(i)) || (properties.max(i) <= prop)
+                    [theta,J_opt] = ...
+                        fmincon(@(theta) obj(theta,objective_function,options.obj_type),...
+                                            theta,...
+                                            parameters.constraints.A  ,parameters.constraints.b  ,... % linear inequality constraints
+                                            parameters.constraints.Aeq,parameters.constraints.beq,... % linear equality constraints
+                                            parameters.min,...   % lower bound
+                                            parameters.max,...   % upper bound
+                                            @(theta) prop_con_fun(theta,properties.function{i},properties.min(i),properties.max(i),s),...
+                                            options.profileOptimizationOptions);    % options
+                else
+                    J_opt = obj(theta,objective_function,options.obj_type);
+                end
+                
+                % Assignment of log-posterior
+                logPost = -J_opt;
+                
+                % Sorting
+                switch s
+                    case -1
+                        P_prop = [prop,P_prop];
+                        P_par = [theta,P_par];
+                        P_logPost = [logPost,P_logPost];
+                        P_R = [exp(logPost - parameters.MS.logPost(1)),P_R];
+                        P_exitflag = [exitflag,P_exitflag];
+                    case +1
+                        P_prop = [P_prop,prop];
+                        P_par = [P_par,theta];
+                        P_logPost = [P_logPost,logPost];
+                        P_R = [P_R,exp(logPost - parameters.MS.logPost(1))];
+                        P_exitflag = [P_exitflag,exitflag];
+                end
+                
+                % Assignment
+                properties.P(i).prop = P_prop;
+                properties.P(i).par = P_par;
+                properties.P(i).logPost = P_logPost;
+                properties.P(i).R = P_R;
+                properties.P(i).exitflag = P_exitflag;
+                
+                % Save
+                if options.save
+                    dlmwrite([options.foldername '/properties_P' num2str(i,'%d') '__prop.csv'],P_prop,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/properties_P' num2str(i,'%d') '__par.csv'],P_par,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/properties_P' num2str(i,'%d') '__logPost.csv'],P_logPost,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/properties_P' num2str(i,'%d') '__R.csv'],P_R,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/properties_P' num2str(i,'%d') '__exitflag.csv'],P_exitflag,'delimiter',',','precision',12);
+                end
+                
+                % Output
+                str = [num2str(i,'%d') ordstr(i) ' P: point ' num2str(length(properties.P(i).R)-1,'%d') ', R = ' ...
+                    num2str(exp(- J_opt - properties.MS.logPost(1)),'%.3e')];
+                switch options.mode
+                    case 'visual', fh = plotPropertyProfiles(properties,'1D',fh,options.property_index,options.plot_options);
+                    case 'text', disp(str);
+                    case 'silent' % no output
+                end
+                
+                % Condition for the while-loop
+                computeProfile = (logPost >= (log(options.R_min) + parameters.MS.logPost(1))) && ...
+                    (prop > (properties.min(i)+options.boundary_tol)) && ...
+                    ((properties.max(i)-options.boundary_tol) > prop);
+            end
+        end
+    end
+elseif strcmp(options.comp_type,'parallel') && options.calc_profiles
+    %% Profile calculation -- PARALLEL
+    
+    % Assignement of profile
+    P = properties.P;
+    
+    % Profile calculation
+    parfor i = options.property_index
+        % Initialization
+        P_prop = properties.MS.prop(i,options.MAP_index);
+        P_par = parameters.MS.par(:,options.MAP_index);
+        P_logPost = parameters.MS.logPost(options.MAP_index);
+        P_R = exp(parameters.MS.logPost(options.MAP_index)-parameters.MS.logPost(1));
+        if isfield(parameters.MS,'exitflag')
+            P_exitflag = parameters.MS.exitflag(options.MAP_index);
+        else
+            P_exitflag = NaN;
+        end
+                
+        if ((P_prop <= properties.min(i)) || (properties.max(i) <= P_prop)) && ~strcmp(options.mode,'silent')
+            warning(['MAP of ' num2str(i) ordstr(i) ' property not between respective minimum and maximum.']);
+        end
+        
+        % Compute profile for in- and decreasing property
+        for s = [-1,1]
+            % Starting point
+            prop = properties.MS.prop(i,options.MAP_index);
+            theta  = parameters.MS.par(:,options.MAP_index);
+            logPost = parameters.MS.logPost(options.MAP_index);
+            
+            computeProfile = (logPost >= (log(options.R_min) + parameters.MS.logPost(1))) && ...
+                    (prop > (properties.min(i)+options.boundary_tol)) && ...
+                    ((properties.max(i)-options.boundary_tol) > prop);
+                
+            % Sequential update
+            while computeProfile
+                
+                % Proposal of next profile point
+                J_exp = -(log(1-options.dR_max)+options.dJ*(logPost-logPost_max)+logPost);
+        
+                % Optimization
+                [theta,prop,exitflag] = ...
+                    fmincon(@(theta) prop_fun(theta,properties.function{i},properties.min(i),properties.max(i),s),...
+                    theta,...
+                    parameters.constraints.A  ,parameters.constraints.b  ,... % linear inequality constraints
+                    parameters.constraints.Aeq,parameters.constraints.beq,... % linear equality constraints
+                    parameters.min,...   % lower bound
+                    parameters.max,...   % upper bound
+                    @(theta) obj_con(theta,objective_function,-J_exp,options.obj_type),...
+                    options.profileOptimizationOptions);    % options
+                
+                % Adaptation of signs
+                if s == +1
+                    prop = -prop;
+                end
+                
+                % Reoptimization at boundary
+                if (prop <= properties.min(i)) || (properties.max(i) <= prop)
+                    [theta,J_opt] = ...
+                        fmincon(@(theta) obj(theta,objective_function,options.obj_type),...
+                        theta,...
+                        parameters.constraints.A  ,parameters.constraints.b  ,... % linear inequality constraints
+                        parameters.constraints.Aeq,parameters.constraints.beq,... % linear equality constraints
+                        parameters.min,...   % lower bound
+                        parameters.max,...   % upper bound
+                        @(theta) prop_con_fun(theta,properties.function{i},properties.min(i),properties.max(i),s),...
+                        options.profileOptimizationOptions);    % options
+                else
+                    J_opt = obj(theta,objective_function,options.obj_type);
+                end
+                
+                % Assignment of log-posterior
+                logPost = -J_opt;
+                
+                % Sorting
+                switch s
+                    case -1
+                        P_prop = [prop,P_prop];
+                        P_par = [theta,P_par];
+                        P_logPost = [logPost,P_logPost];
+                        P_R = [exp(logPost - parameters.MS.logPost(1)),P_R];
+                        P_exitflag = [exitflag,P_exitflag];
+                    case +1
+                        P_prop = [P_prop,prop];
+                        P_par = [P_par,theta];
+                        P_logPost = [P_logPost,logPost];
+                        P_R = [P_R,exp(logPost - parameters.MS.logPost(1))];
+                        P_exitflag = [P_exitflag,exitflag];
+                end
+                
+                % Assignment
+                P(i).prop = P_prop;
+                P(i).par = P_par;
+                P(i).logPost = P_logPost;
+                P(i).R = P_R;
+                P(i).exitflag = P_exitflag;
+                
+                % Save
+                if options.save
+                    dlmwrite([options.foldername '/property_P' num2str(i,'%d') '__prop.csv'],P_prop,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/property_P' num2str(i,'%d') '__par.csv'],P_par,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/property_P' num2str(i,'%d') '__logPost.csv'],P_logPost,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/property_P' num2str(i,'%d') '__R.csv'],P_R,'delimiter',',','precision',12);
+                    dlmwrite([options.foldername '/property_P' num2str(i,'%d') '__exitflag.csv'],P_exitflag,'delimiter',',','precision',12);
+                end
+                
+                % Condition for the while-loop
+                computeProfile = (logPost >= (log(options.R_min) + parameters.MS.logPost(1))) && ...
+                    (prop > (properties.min(i)+options.boundary_tol)) && ...
+                    ((properties.max(i)-options.boundary_tol) > prop);
+            end
+        end
+    end
+    
+    % Assignment
+    properties.P = P;
+    
+    % Output
+    switch options.mode
+        case 'visual', fh = plotPropertyProfiles(properties,'1D',fh,options.property_index,options.plot_options);
+        case 'text' % no output
+        case 'silent' % no output
+    end
+    
+end
+
+%% Output
+switch options.mode
+    case {'visual','text'}, disp('-> Profile calculation for properties FINISHED.');
+    case 'silent' % no output
+end
+
+end
+
+
+%% Objetive function interface
+% This function is used as interface to the user-provided objective
+% function. It adapts the sign and supplies the correct number of outputs.
+% Furthermore, it catches errors in the user-supplied objective function.
+%   theta ... parameter vector
+%   fun ... user-supplied objective function
+%   type ... type of user-supplied objective function
+function varargout = obj(theta,fun,type)
+
+try
+    switch nargout
+        case {0,1}
+            J = fun(theta);
+            if isnan(J)
+                error('J is NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {-J};
+                case 'negative log-posterior' , varargout = { J};
+            end
+        case 2
+            [J,G] = fun(theta);
+            if max(isnan([J;G(:)]))
+                error('J and/or G contain a NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {-J,-G};
+                case 'negative log-posterior' , varargout = { J, G};
+            end
+        case 3
+            [J,G,H] = fun(theta);
+            if max(isnan([J;G(:);H(:)]))
+                error('J, G and/or H contain a NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {-J,-G,-H};
+                case 'negative log-posterior' , varargout = { J, G, H};
+            end
+    end
+catch
+    switch nargout
+        case {0,1}
+            varargout = {inf};
+        case 2
+            varargout = {inf,zeros(length(theta),1)};
+        case 3
+            varargout = {inf,zeros(length(theta),1),zeros(length(theta))};
+    end
+end
+
+end
+
+%% Constrained objetive function interface
+% This function is used as interface to the user-provided objective
+% function. It adapts the sign and supplies the correct number of outputs.
+% Furthermore, it catches errors in the user-supplied objective function.
+%   theta ... parameter vector
+%   fun ... user-supplied objective function
+%   fun_min ... minimum objective function
+%   type ... type of user-supplied objective function
+function varargout = obj_con(theta,fun,fun_min,type)
+
+try
+    switch nargout
+        case {0,1}
+            J = fun(theta);
+            if isnan(J)
+                error('J is NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {fun_min-J};
+                case 'negative log-posterior' , varargout = {fun_min+J};
+            end
+        case 2
+            J = fun(theta);
+            if isnan(J)
+                error('J is NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {fun_min-J,[]};
+                case 'negative log-posterior' , varargout = {fun_min+J,[]};
+            end
+        case 3
+            [J,G] = fun(theta);
+            if max(isnan([J;G(:)]))
+                error('J and/or G contain a NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {fun_min-J,[],-G};
+                case 'negative log-posterior' , varargout = {fun_min+J,[], G};
+            end
+        case 4
+            [J,G] = fun(theta);
+            if max(isnan([J;G(:)]))
+                error('J and/or G contain a NaN.')
+            end
+            switch type
+                case 'log-posterior'          , varargout = {fun_min-J,[],-G,[]};
+                case 'negative log-posterior' , varargout = {fun_min+J,[], G,[]};
+            end
+    end
+catch
+    switch nargout
+        case {0,1}
+            varargout = {inf};
+        case 2
+            varargout = {inf,[]};
+        case 3
+            varargout = {inf,[],zeros(length(theta),1)};
+        case 4
+            varargout = {inf,[],zeros(length(theta),1),[]};
+    end
+end
+
+end
+
+%% Property function interface
+% This function is used as interface to the user-provided property
+% function. It adapts the sign and supplies the correct number of outputs.
+% Furthermore, it catches errors in the user-supplied objective function.
+%   theta ... parameter vector
+%   fun ... user-supplied property function
+%   prop_min ... minumum property value of interest (= profile boundary)
+%   prop_max ... maximum property value of interest (= profile boundary)
+%   s ... compute profile for increasing (s = +1) and decreasing (s = -1) property
+function varargout = prop_fun(theta,fun,prop_min,prop_max,s)
+
+if s == -1
+    try
+        switch nargout
+            case {0,1}
+                prop = fun(theta);
+                if prop < prop_min
+                    prop = prop_min;
+                end
+                if isnan(prop)
+                    error('prop is NaN.')
+                end
+                varargout = {prop};
+            case 2
+                [prop,propG] = fun(theta);
+                if prop < prop_min
+                    prop = prop_min;
+                    propG = zeros(size(propG));
+                end
+                if max(isnan([prop;propG(:)]))
+                    error('prop and/or propG contain a NaN.')
+                end
+                varargout = {prop,propG};
+            case 3
+                [prop,propG,propH] = fun(theta);
+                if prop < prop_min
+                    prop = prop_min;
+                    propG = zeros(size(propG));
+                    propH = zeros(size(propH));
+                end
+                if max(isnan([prop;propG(:);propH(:)]))
+                    error('prop, propG and/or propH contain a NaN.')
+                end
+                varargout = {prop,propG,propH};
+        end
+    catch
+        switch nargout
+            case {0,1}
+                varargout = {inf};
+            case 2
+                varargout = {inf,zeros(length(theta),1)};
+            case 3
+                varargout = {inf,zeros(length(theta),1),zeros(length(theta))};
+        end
+    end
+elseif s == +1
+    try
+        switch nargout
+            case {0,1}
+                prop = fun(theta);
+                if prop > prop_max
+                    prop = prop_max;
+                end
+                if isnan(prop)
+                    error('prop is NaN.')
+                end
+                varargout = {-prop};
+            case 2
+                [prop,propG] = fun(theta);
+                if prop > prop_max
+                    prop = prop_max;
+                    propG = zeros(size(propG));
+                end
+                if max(isnan([prop;propG(:)]))
+                    error('prop and/or propG contain a NaN.')
+                end
+                varargout = {-prop,-propG};
+            case 3
+                [prop,propG,propH] = fun(theta);
+                if prop > prop_max
+                    prop = prop_max;
+                    propG = zeros(size(propG));
+                    propH = zeros(size(propH));
+                end
+                if max(isnan([prop;propG(:);propH(:)]))
+                    error('prop, propG and/or propH contain a NaN.')
+                end
+                varargout = {-prop,-propG,-propH};
+        end
+    catch
+        switch nargout
+            case {0,1}
+                varargout = {inf};
+            case 2
+                varargout = {inf,zeros(length(theta),1)};
+            case 3
+                varargout = {inf,zeros(length(theta),1),zeros(length(theta))};
+        end
+    end    
+end
+
+end
+
+%% Property constraint function interface
+% This function is used as interface to the user-provided property
+% function. It adapts the sign and supplies the correct number of outputs.
+% Furthermore, it catches errors in the user-supplied objective function.
+%   theta ... parameter vector
+%   fun ... user-supplied property function
+%   prop_min ... minumum property value of interest (= profile boundary)
+%   prop_max ... maximum property value of interest (= profile boundary)
+%   s ... compute profile for increasing (s = +1) and decreasing (s = -1) property
+function varargout = prop_con_fun(theta,fun,prop_min,prop_max,s)
+
+if s == -1
+    try
+        switch nargout
+            case {0,1}
+                prop = fun(theta);
+                if isnan(prop)
+                    error('prop is NaN.')
+                end
+                varargout = {prop-prop_min};
+            case 2
+                prop = fun(theta);
+                if isnan(prop)
+                    error('prop is NaN.')
+                end
+                varargout = {prop-prop_min,[]};
+            case 3
+                [prop,propG] = fun(theta);
+                if max(isnan([prop;propG(:)]))
+                    error('prop and/or propG contain a NaN.')
+                end
+                varargout = {prop-prop_min,[],propG};
+            case 4
+                [prop,propG] = fun(theta);
+                if max(isnan([prop;propG(:)]))
+                    error('prop and/or propG contain a NaN.')
+                end
+                varargout = {prop-prop_min,[],propG,[]};
+        end
+    catch
+        switch nargout
+            case {0,1}
+                varargout = {inf};
+            case 2
+                varargout = {inf,[]};
+            case 3
+                varargout = {inf,[],zeros(length(theta),1)};
+            case 4
+                varargout = {inf,[],zeros(length(theta),1),[]};
+        end
+    end
+elseif s == +1
+    try
+        switch nargout
+            case {0,1}
+                prop = fun(theta);
+                if isnan(prop)
+                    error('prop is NaN.')
+                end
+                varargout = {prop_max-prop};
+            case 2
+                prop = fun(theta);
+                if isnan(prop)
+                    error('prop is NaN.')
+                end
+                varargout = {prop_max-prop,[]};
+            case 3
+                [prop,propG] = fun(theta);
+                if max(isnan([prop;propG(:)]))
+                    error('prop and/or propG contain a NaN.')
+                end
+                varargout = {prop_max-prop,[],-propG};
+            case 4
+                [prop,propG] = fun(theta);
+                if max(isnan([prop;propG(:)]))
+                    error('prop and/or propG contain a NaN.')
+                end
+                varargout = {prop_max-prop,[],-propG,[]};
+        end
+    catch
+        switch nargout
+            case {0,1}
+                varargout = {inf};
+            case 2
+                varargout = {inf,[]};
+            case 3
+                varargout = {inf,[],zeros(length(theta),1)};
+            case 4
+                varargout = {inf,[],zeros(length(theta),1),[]};
+        end
+    end
+end
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/getPropertySamples.m b/Requirements/PESTO-1.1.0/getPropertySamples.m
new file mode 100644
index 0000000000000000000000000000000000000000..3142952a4cc040cf104be29af1cad6951cc87ba3
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/getPropertySamples.m
@@ -0,0 +1,176 @@
+function [properties,fh] = getPropertySamples(properties, parameters, varargin)
+% getPropertySamples.m evaluates the properties for the sampled parameters.
+%
+% USAGE:
+% [...] = getPropertySamples(properties,parameters)
+% [...] = getPropertySamples(properties,parameters,options)
+% [parameters,fh] = getPropertySamples(...)
+%
+% getPropertySamples() uses the following PestoOptions members:
+%  * PestoOptions::property_index
+%  * PestoOptions::mode
+%  * PestoOptions::fh
+%  * PestoOptions::save
+%  * PestoOptions::foldername
+%  * PestoOptions::comp_type
+%  * PestoOptions::plot_options
+%  * PestoOptions::MCMC.thinning
+%
+% Parameters:
+%   properties: property struct
+%   parameters: parameter struct
+%   varargin:
+%     options: A PestoOptions object holding various options for the 
+%         algorithm.
+%
+% Required fields of properties:
+%   number: number of parameter
+%   min: lower bound for property values       
+%   max: upper bound for property values       
+%   name: = {'name1',...} ... names of the parameters       
+%   function: = {'function1',...} ... functions to evaluate property  
+%       values. These functions provide the values of the respective  
+%       properties and the corresponding 1st and 2nd order
+%       derivatives.
+%
+% Required fields of parameters:
+%   S: parameter and posterior sample.
+%     logPost ... log-posterior function along chain
+%     par  ... parameters along chain
+%   *Note* This struct is obtained using getSamples.m.
+%
+% Return values:
+%   properties: updated parameter object
+%   fh: figure handle
+%
+% Generated fields of properties:
+%  S: properties for sampling results
+%    * par(*,i): ith samples parameter vector
+%    * logPost(i): log-posterior for ith samples parameter vector
+%    * prop(j,i): values of jth property for ith samples parameter vector
+%    * prop_Sigma(*,*,i): covariance of properties for ith samples 
+%          parameter vector
+%
+% History:
+% * 2015/04/01 Jan Hasenauer
+% * 2016/10/04 Daniel Weindl
+
+%% Check and assign inputs
+if length(varargin) >= 1
+    options = handleOptionArgument(varargin{1});
+else
+    options = PestoOptions();
+end
+
+properties = propertySanityCheck(properties);
+
+% Check initial guess
+if ~isfield(parameters,'guess')
+    parameters.guess = [];
+end
+
+% Check and assign options
+options.property_index = 1:properties.number;
+
+%% Initialization and figure generation
+fh = [];
+switch options.mode
+    case 'visual'
+        if (isempty(options.fh) || ~isvalid(options.fh))
+            fh = figure('Name','getPropertySamples');
+        else
+            fh = figure(options.fh);
+        end
+    case 'text'
+        fprintf(' \nProperty evaluation:\n====================\n');
+end
+
+%% Initialization
+properties.S.par = parameters.S.par;
+properties.S.logPost = parameters.S.logPost;
+properties.S.prop = nan(properties.number,length(properties.S.logPost));
+
+%% Preperation of folder
+if options.save
+    rmdir(options.foldername,'s'); 
+    mkdir(options.foldername);
+    save([options.foldername '/properties_init'],'properties');
+end
+
+%% Evaluation of properties for multi-start results -- SEQUENTIAL
+if strcmp(options.comp_type,'sequential')
+
+    % Loop: Multi-start results
+    for j = 1:length(properties.S.logPost)
+        % Loop: Properties
+        for i = options.property_index
+            properties.S.prop(i,j) = properties.function{i}(properties.S.par(:,j));
+        end
+
+        % Save
+        if options.save
+            dlmwrite([options.foldername '/properties_S' num2str(i,'%d') '__prop.csv'],properties.S.prop(:,j),'delimiter',',','precision',12);
+        end
+
+        % Output
+        if (mod(j,ceil(length(properties.S.logPost)/100)) == 0) || (j == length(properties.S.logPost))
+            str = ['Property evaluation for MCMC sampling completed to ' num2str(100*j/length(properties.S.logPost),'%d') ' %'];
+            switch options.mode
+                case 'visual', fh = plotPropertySamples(properties,'1D',fh,options.property_index,options.plot_options);
+                case 'text', disp(str);
+                case 'silent' % no output
+            end
+        end
+    end
+
+    % Output
+    switch options.mode
+        % Set the correct options        
+        case 'visual' 
+            options.plot_options.S.plot_type = 1;
+            fh = plotPropertySamples(properties,'1D',fh,options.property_index,options.plot_options);
+    end
+
+end
+
+%% Evaluation of properties for multi-start results -- PARALLEL
+if strcmp(options.comp_type, 'parallel')
+
+    % Initialization
+    prop = nan(properties.number,length(properties.S.logPost));
+
+    % Create local partial copies of the propertry struct
+    prop_num = properties.number;
+    prop_fun = properties.function;
+    prop_S_par = properties.S.par;
+    opt_save = options.save;
+    opt_ind = options.property_index;
+    opt_folder = options.foldername;
+
+    % Loop: Multi-start results
+    parfor i = 1:length(properties.S.logPost)
+        % Loop: Properties
+        P = nan(prop_num, 1);
+        for j = opt_ind
+            P(j) = prop_fun{j}(prop_S_par(:,i));
+        end
+        prop(:,i) = P;
+
+        % Save
+        if (opt_save)
+            dlmwrite([opt_folder '/properties_S' num2str(i,'%d') '__prop.csv'],prop(:,i),'delimiter',',','precision',12);
+        end
+    end
+
+    % Assignment
+    properties.S.prop = prop;
+
+end
+
+%% Output
+switch options.mode
+    case {'visual','text'}, disp('-> Property evaluation for samples FINISHED.');
+    case 'silent' % no output
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/logLikelihoodHierarchical.m b/Requirements/PESTO-1.1.0/logLikelihoodHierarchical.m
new file mode 100644
index 0000000000000000000000000000000000000000..1bd0b440d0630d0398f78dfa6b74d3c72bab99a2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/logLikelihoodHierarchical.m
@@ -0,0 +1,254 @@
+function [varargout] = logLikelihoodHierarchical(simulation,D,options)
+% logLikelihoodHierarchical() computes the value of the log-likelihood function,
+% its gradient and its approximated Hessian. Two noise distributions are
+% supported, Gaussian (normal) and Laplace noise. The optimal scaling and noise
+% parameters are calculated analytically (see optimalScaling.m and
+% optimalNoise.m). Data and simulation can be compared on a linear or
+% logarithmic scale.
+%
+% USAGE:
+% * [...]                = logLikelihoodHierarchical(simulation,D,options)
+% * [llH]                = logLikelihoodHierarchical(...)
+% * [llH,gradlLH]        = logLikelihoodHierarchical(...)
+% * [llH,gradlLH,HlLH]   = logLikelihoodHierarchical(...)
+%
+% Parameters:
+%   simulation: (1 x #experiments) struct with fields
+%       * y: simulation of the output for the different experiments for a theta
+%            in which the values nlLH, gradnlLH, FIMnlLH will be computed
+%       * sy: simulation of sy, the sensitivities of the output vector, for the different experiments
+%            for a theta in which the values nlLH, gradnlLH, FIMnlLH will be computed
+%   D: (1 x #experiments) struct containing data with two fields
+%       * t: time points
+%       * my: # time points x # observables x # replicates
+%   options: HOOptions object holding the options for the
+%         definition of scaling and noise parameters
+%
+% Return values:
+%   lLh: value of the loglikelihood function in theta
+%   gradlLH: value of gradient of the loglikelihood function
+%                 in theta
+%   HlLH: approximation of the Hessian of the loglikelihood function (only
+%   supported for Gaussian/normal noise)
+%
+% Note: all observables/experiments that share a scaling parameter
+%       need to also share the noise parameter!
+%% INITIALIZATION
+n_e = size(D,2); %number of experiments
+n_y = size(D(1).my,2); %number of observables
+n_r = size(D(1).my,3); %number of replicates
+
+if ~isequal(options.n_exp,n_e)
+    error('number of experiments indicated in options not the same as in D')
+end
+
+ind_lin = [];
+ind_log10 = [];
+ind_log = [];
+for iy = 1:n_y
+    switch options.scale{iy}
+        case 'lin'
+            ind_lin = [ind_lin,iy];
+        case 'log'
+            ind_log = [ind_log,iy];
+        case 'log10'
+            ind_log10 = [ind_log10,iy];
+    end
+end
+
+if nargout > 1
+    n_theta = size(simulation(1).sy,3);%number of parameters
+end
+
+lLH = 0;
+if nargout > 1
+    gradlLH = zeros(n_theta,1);
+    if nargout >  2
+        if(strcmp(options.distribution,'laplace'))
+            error('No user supplied Fisher information matrix available for the Laplace distribution.');
+        else
+            HlLH = zeros(n_theta,n_theta);
+        end
+    end
+end
+
+try
+    for j = 1:n_e
+        assert(size(D(j).my,3) <= options.max_repl)
+    end
+catch
+    error('check maximal number of replicates in options.max_repl')
+end
+
+
+% Initialization for for scaling and noise parameters
+s = zeros(1,n_y,options.max_repl,n_e); % vector including scaling factors
+noise = zeros(1,n_y,options.max_repl,n_e); % vector including noises
+
+if nargout > 1
+    ds = zeros(1,n_y,n_theta,options.max_repl,n_e);
+end
+
+
+%% optimal values for the scaling parameters
+for ie = 1:numel(options.expgroups_scaling)
+    ind_e = options.expgroups_scaling{ie};
+    for iy = 1:numel(options.obsgroups_scaling)
+        scale = options.scale{options.obsgroups_scaling{iy}(1)};
+        ind_y = options.obsgroups_scaling{iy};
+        if strcmp(options.distribution,'normal') || nargout <= 1
+            temps = optimalScaling(ind_y,simulation(ind_e),D(ind_e),options,scale);
+            for ir = 1:size(temps,3)
+                s(:,ind_y,ir,ind_e) = temps(:,:,ir);
+            end
+        else
+            [temps,tempds] = ...
+                optimalScaling(ind_y,simulation(ind_e),D(ind_e),options,scale);
+            for ir = 1:size(temps,3)
+                s(:,ind_y,ir,ind_e) = temps(:,:,ir);
+                for iiy = 1:numel(ind_y)
+                    for iie = 1:numel(ind_e)
+                        ds(:,ind_y(iiy),:,ir,ind_e(iie)) = tempds(:,:,:,ir);
+                    end
+                end
+            end
+        end
+    end
+end
+
+%% optimal values for the noise parameters
+for ie = 1:numel(options.expgroups_noise)
+    ind_e = options.expgroups_noise{ie};
+    for iy = 1:numel(options.obsgroups_noise)
+        scale = options.scale{(options.obsgroups_noise{iy}(1))};
+        ind_y = options.obsgroups_noise{iy};
+        ind_e = options.expgroups_noise{ie};
+        [tempnoise] = ...
+            optimalNoise(ind_y,simulation(ind_e),D(ind_e),options,s(:,:,:,ind_e),scale);
+        for ir = 1:size(tempnoise,3)
+            noise(:,ind_y,ir,ind_e)=tempnoise(:,:,ir);
+        end
+        
+    end
+end
+
+%% save scaling and noise parameters
+% s and noise have dimensions: 
+% (1 x # observables x max # replicates x # experiments/conditions) 
+if options.save
+    save([options.foldername '/analytical_results.mat'],'s','noise');
+end
+
+%% computing loglikelihood, gradient and approximation Hessian
+for j = 1:n_e
+    n_r = size(D(j).my,3);
+    y_sh = nan(size(D(j).my));
+    if nargout > 1
+        dy_sh= nan(size(D(j).my,1),size(D(j).my,2),size(D(j).my,3),n_theta);
+    end
+    noise_j = noise(:,:,1:size(D(j).my,3),j);
+    s_j = s(:,:,1:size(D(j).my,3),j);
+    if strcmp(options.distribution,'laplace') && nargout > 1
+        ds_j = ds(:,:,:,:,j);
+    end
+    if ~isempty(ind_lin)
+        y_sh(:,ind_lin,:) = bsxfun(@minus,D(j).my(:,ind_lin,:),...
+            bsxfun(@times,s_j(:,ind_lin,1:n_r),simulation(j).y(:,ind_lin)));
+        if nargout > 1
+            switch options.distribution
+                case 'normal'
+                    % derivatives with respect to noise and s neglected
+                    % because they are 0
+                    dy_sh(:,ind_lin,:,:) = -bsxfun(@times,s_j(:,ind_lin,1:n_r),...
+                        permute(repmat(simulation(j).sy(:,ind_lin,:),[1,1,1,n_r]),[1,2,4,3]));
+                case 'laplace'
+                    % derivatives with respect to noise neglected
+                    dy_sh(:,ind_lin,:,:) = bsxfun(@times,permute(ds_j(:,ind_lin,:,1:n_r),[1,2,4,3]),simulation(j).y(:,ind_lin)) +...
+                        bsxfun(@times,s_j(:,ind_lin,1:n_r),permute(repmat(simulation(j).sy(:,ind_lin,:),[1,1,1,n_r]),[1,2,4,3]));
+            end
+        end
+    end
+    
+    if ~isempty(ind_log)
+        y_sh(:,ind_log,:) = bsxfun(@minus,log(D(j).my(:,ind_log,:)),...
+            log(bsxfun(@times,s_j(:,ind_log,1:n_r),simulation(j).y(:,ind_log))));
+        if nargout > 1
+            switch options.distribution
+                case 'normal'
+                    dy_sh(:,ind_log,:,:) = -bsxfun(@ldivide,simulation(j).y(:,ind_log),...
+                        permute(repmat(simulation(j).sy(:,ind_log,:),[1,1,1,n_r]),[1,2,4,3]));
+                case 'laplace'
+                    dy_sh(:,ind_log,:,:) = permute(bsxfun(@ldivide,bsxfun(@times,s_j(:,ind_log,:),simulation(j).y(:,ind_log)),...
+                        permute(bsxfun(@plus,bsxfun(@times,permute(ds_j(:,ind_log,:,1:n_r),[1,2,4,3]),simulation(j).y(:,ind_log)),...
+                        bsxfun(@times,permute(s_j(:,ind_lin,1:n_r),[1,2,4,3]),...
+                        simulation(j).sy(:,ind_lin,:))),[1,2,4,3])),[1,2,4,3]);
+            end
+        end
+    end
+    
+    if ~isempty(ind_log10)
+        y_sh(:,ind_log10,:) = bsxfun(@minus,log10(D(j).my(:,ind_log10,:)),...
+            log10(bsxfun(@times,s_j(:,ind_log10,1:n_r),simulation(j).y(:,ind_log10))));
+        if nargout > 1
+            switch options.distribution
+                case 'normal'
+                    dy_sh(:,ind_log10,:,:) = -bsxfun(@ldivide,simulation(j).y(:,ind_log10)*log(10),...
+                        permute(repmat(simulation(j).sy(:,ind_log10,:),[1,1,1,n_r]),[1,2,4,3]));
+                case 'laplace'
+                    dy_sh(:,ind_log10,:,:) = 1/log(10)*bsxfun(@ldivide,...
+                        bsxfun(@times,s_j(:,ind_log10,1:n_r),simulation(j).y(:,ind_log10)),...
+                        bsxfun(@plus,bsxfun(@times,permute(ds_j(:,ind_log10,:,1:n_r),[1,2,4,3]),...
+                        simulation(j).y(:,ind_log10)),...
+                        bsxfun(@times,s_j(:,ind_log10,1:n_r),...
+                        permute(repmat(simulation(j).sy(:,ind_log10,:),[1,1,1,n_r]),...
+                        [1,2,4,3]))));
+            end
+        end
+    end
+    switch options.distribution
+        case 'normal'
+            temparg = 0.5*(bsxfun(@times,~isnan(D(j).my),log(2*pi*noise_j))+...
+                bsxfun(@rdivide,bsxfun(@power,y_sh,2),noise_j));
+        case 'laplace'
+            temparg = bsxfun(@times,~isnan(D(j).my),log(2*noise_j))+...
+                bsxfun(@rdivide,abs(y_sh),noise_j);
+            
+    end
+    lLH = lLH - sum(sum(nansum(temparg,1),3),2);
+    
+    if nargout > 1
+        switch options.distribution
+            case 'normal'
+                gradlLH = gradlLH - squeeze(sum(sum(nansum(...
+                    bsxfun(@times,bsxfun(@rdivide,y_sh,noise_j),...
+                    dy_sh),1),2),3));
+                if nargout > 2
+                    % approximated Hessian
+                    for i1 = 1:n_theta
+                        for i2 = 1:n_theta
+                            HlLH(i1,i2) = HlLH(i1,i2) - ...
+                                nansum(nansum(nansum(bsxfun(@rdivide,...
+                                bsxfun(@times,dy_sh(:,:,:,i1),dy_sh(:,:,:,i2)),noise_j))));
+                        end
+                    end
+                end
+            case 'laplace'
+                gradlLH = gradlLH + squeeze(sum(sum(nansum(...
+                    bsxfun(@times,bsxfun(@rdivide,sign(y_sh),noise_j),...
+                    dy_sh),1),2),3));
+        end
+    end
+end
+switch nargout
+    case{0,1}
+        varargout{1} = lLH;
+    case 2
+        varargout{1} = lLH;
+        varargout{2} = gradlLH;
+    case 3
+        varargout{1} = lLH;
+        varargout{2} = gradlLH;
+        varargout{3} = HlLH;
+end
+end
+
diff --git a/Requirements/PESTO-1.1.0/meigoDummy.m b/Requirements/PESTO-1.1.0/meigoDummy.m
new file mode 100644
index 0000000000000000000000000000000000000000..cc89c80b6bc9f80b9fe39214ba801bb508ee95aa
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/meigoDummy.m
@@ -0,0 +1,45 @@
+function varargout = meigoDummy(theta, fun, varargin)
+% Objective function wrapper for MEIGO / PSwarm / ... which need objective
+% function *file*name* and cannot use function handles directly. 
+% 
+% Parameters:
+%   theta: parameter vector
+%   fun: objective function handle
+%   varargin: 
+%
+% Return values:
+% f: Objective function value
+
+if(nargin(fun) == 1)
+    switch nargout
+        case 1
+            [f] = fun(theta);
+            varargout{1} = f;
+        case 2
+            [f,g] = fun(theta);
+            varargout{1} = f;
+            varargout{2} = g;
+        case 3
+            [f,g,h] = fun(theta);
+            varargout{1} = f;
+            varargout{2} = g;
+            varargout{3} = h;
+    end
+else
+    switch nargout
+        case 1
+            [f] = fun(theta, varargin);
+            varargout{1} = f;
+        case 2
+            [f,g] = fun(theta, varargin);
+            varargout{1} = f;
+            varargout{2} = g;
+        case 3
+            [f,g,h] = fun(theta, varargin);
+            varargout{1} = f;
+            varargout{2} = g;
+            varargout{3} = h;
+    end
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/plotConfidenceIntervals.m b/Requirements/PESTO-1.1.0/plotConfidenceIntervals.m
new file mode 100644
index 0000000000000000000000000000000000000000..5b2b21e23eec894eaa3cb1a574f3b98efb8ece48
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotConfidenceIntervals.m
@@ -0,0 +1,315 @@
+function fh = plotConfidenceIntervals(pStruct, alpha, varargin)
+% plotConfidenceIntervals.m visualizes confidence itervals stored in either
+% the parameters or properties struct .CI
+%
+% USAGE:
+% fh = plotParameterUncertainty(pStruct)
+% fh = plotParameterUncertainty(pStruct, methods)
+% fh = plotParameterUncertainty(pStruct, methods, options)
+%
+% plotMultiStarts() uses the following PestoPlottingOptions members:
+%  * PestoPlottingOptions::P
+%  * PestoPlottingOptions::S
+%  * PestoPlottingOptions::MS
+%  * PestoPlottingOptions::boundary
+%  * PestoPlottingOptions::subplot_size_1D
+%  * PestoPlottingOptions::subplot_indexing_1D
+%  * PestoPlottingOptions::CL
+%  * PestoPlottingOptions::hold_on
+%  * PestoPlottingOptions::interval
+%  * PestoPlottingOptions::bounds
+%  * PestoPlottingOptions::A
+%  * PestoPlottingOptions::add_points
+%  * PestoPlottingOptions::labels
+%  * PestoPlottingOptions::legend
+%  * PestoPlottingOptions::op2D
+%  * PestoPlottingOptions::fontsize
+%
+% Parameters:
+%   pStruct: either the parameter or the property struct containing 
+%       information about parameters and results of optimization (.MS) 
+%       and uncertainty analysis (.P and .S). This structures is the output
+%       of plotMultiStarts.m, getProfiles.m or plotSamples.m.
+%  alpha: significance levels
+%   varargin:
+%     method: integer array, from which method confidence intervals 
+%         should be plotted: 
+%     options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+%   fh: figure handle
+%
+% History:
+% * 2016/11/14 Paul Stapor
+% * 2017/12/27 Jan Hasenauer
+
+%% Check and assign input
+
+% Check which methods should be used to plot Confidence Intervals
+if (length(varargin) >= 1)
+    if(~isempty(varargin{1}))
+        methIn = varargin{1};
+        boolWarning = true;
+    else
+        methIn = {'local_PL', 'PL', 'local_B', 'S'};
+        boolWarning = false;
+    end
+else
+    methIn = {'local_PL', 'PL', 'local_B', 'S'};
+end
+methods = checkMeth(methIn, pStruct, boolWarning);
+numConf = methods.num;
+
+% Assignment of user-provided options
+if (length(varargin) >= 2)
+    if (~isa(varargin{2}, 'PestoOptions'))
+        error('Argument 2 is not of type PestoOptions.')
+    end
+    allOptions = varargin{2};
+    options = allOptions.plot_options.copy();
+else
+    allOptions = PestoOptions();
+    options = PestoPlottingOptions();
+end
+
+%% Check what exactly should be plotted
+
+if isfield(pStruct, 'function')
+    type = 'Properties';
+    if isempty(allOptions.property_index)
+        pIndexSet = 1 : pStruct.number;
+    else
+        pIndexSet = allOptions.property_index;
+    end
+else
+    type = 'Parameters';
+    if isempty(allOptions.parameter_index)
+        pIndexSet = 1 : pStruct.number;
+    else
+        pIndexSet = allOptions.parameter_index;
+    end
+end
+
+% Check, if pStruct has all necessary fieds
+pStruct = checkSanityOfStructs(pStruct, ['p' type(2:end)]);
+
+numP = length(pIndexSet);
+iMAP = allOptions.MAP_index;
+if isempty(iMAP)
+    iMAP = 1;
+end
+
+switch options.group_CI_by
+    case 'parprop'
+        indexSet = pIndexSet;
+        indexLen = length(pIndexSet);
+    case 'methods'
+        indexSet = 1 : numConf;
+        indexLen = numConf;
+    case 'all'
+        indexLen = 1;
+    otherwise
+        error('Call to undefinded grouping method plot plot of confidence intervals.');
+end
+        
+%% Initialize the figure generation
+sqrtPlots = ceil(sqrt(indexLen));
+if ((sqrtPlots-1)*sqrtPlots >= indexLen)
+    plots = [sqrtPlots-1, sqrtPlots];
+else
+    plots = [sqrtPlots, sqrtPlots];
+end
+
+% Open figure
+fh = figure('Name', ['plotConfidenceIntervals - ' type]);
+pos = nan(indexLen, 4);
+
+%% Generate the Plots
+switch options.group_CI_by
+    case 'parprop'
+        for iP = 1 : indexLen %indexSet
+            subplot(plots(1), plots(2), iP);
+            pos(iP,:) = get(gca, 'Position');
+            del = 0.1 / plots(2);
+            offsetLabels = 0.1;
+            step = (1 - offsetLabels) / plots(2);
+            pos(iP,:) = [mod((iP-1), plots(2))*step + del/2 + offsetLabels, pos(iP, 2), step-del, pos(iP, 4)];
+            hold on;
+
+            set(gca, 'YLim', [0.5, numConf + 0.5]);
+            ylabel('');
+            xlabel(pStruct.name{indexSet(iP)});
+            if (mod(iP-1, plots(2)) == 0)
+                set(gca, 'ytick', 1 : numConf, 'yticklabel', methods.name);
+            else
+                set(gca, 'ytick', 1 : numConf, 'yticklabel', '');
+            end
+            box on;
+
+            for j = 1 : numConf
+                CI = pStruct.CI.(methods.type{j});
+                if not((j == 1) && isnan(CI(indexSet(iP),1,1)))
+                    for k = methods.numLevels : -1 : 1
+                        h = methods.bars(k);
+                        if (CI(indexSet(iP),1,k) == -inf)
+                            CI(indexSet(iP),1,k) = pStruct.min(indexSet(iP));
+                        end
+                        if ((CI(indexSet(iP),2,k)) == inf)
+                            CI(indexSet(iP),2,k) = pStruct.max(indexSet(iP));
+                        end
+                        patch([CI(indexSet(iP),1,k), CI(indexSet(iP),2,k), CI(indexSet(iP),2,k), CI(indexSet(iP),1,k)], [j-h, j-h, j+h, j+h], 'k', 'FaceColor', methods.colors(j,:,k), 'EdgeColor', 'k');
+                    end
+                end
+                if isfield(pStruct, 'MS')
+                    if (strcmp(type, 'Parameters'))
+                        plot([pStruct.MS.par(indexSet(iP),1), pStruct.MS.par(indexSet(iP),1)], [j-0.4, j+0.4], 'k-', 'linewidth', 2);
+                    else
+                        plot([pStruct.MS.prop(indexSet(iP),1), pStruct.MS.prop(indexSet(iP),1)], [j-0.4, j+0.4], 'k-', 'linewidth', 2);
+                    end
+                end
+            end
+
+            if (options.draw_bounds)
+                xLimits = get(gca, 'XLim');
+                if (xLimits(1) <= pStruct.min(indexSet(iP)) && xLimits(2) >= pStruct.min(indexSet(iP)))
+                    plot([pStruct.min(indexSet(iP)), pStruct.min(indexSet(iP))], [0.5, numConf+0.5], 'b--', 'linewidth', 2);
+                    set(gca, 'XLim', [pStruct.min(indexSet(iP)), xLimits(2)]);
+                end
+                xLimits = get(gca, 'XLim');
+                if (xLimits(1) <= pStruct.max(indexSet(iP)) && xLimits(2) >= pStruct.max(indexSet(iP)))
+                    plot([pStruct.max(indexSet(iP)), pStruct.max(indexSet(iP))], [0.5, numConf+0.5], 'b--', 'linewidth', 2);
+                    set(gca, 'XLim', [xLimits(1), pStruct.max(indexSet(iP))]);
+                end
+            end
+            hold off;
+        end
+        
+        % Relocate the images to where I want them to be. Don't try to go
+        % for a more intelligent solution. I did, and it made me alomost
+        % mad... The Matlab syntax for figure handles is, well... o.O'
+        fig = gcf;
+        fig.Children = flip(fig.Children);
+        for iP = 1 : indexLen %indexSet 
+            set(fig.Children(iP), 'Position', pos(iP,:));
+        end
+        
+    case 'methods'
+        for iM = indexSet
+            subplot(plots(1), plots(2), iM);
+            pos(iM,:) = get(gca, 'Position');
+            del = 0.1 / plots(2);
+            offsetLabels = 0.1;
+            step = (1 - offsetLabels) / plots(2);
+            pos(iM,:) = [mod((iM-1), plots(2))*step + del/2 + offsetLabels, pos(iM, 2), step-del, pos(iM, 4)];
+            hold on;
+            
+            set(gca, 'YLim', [0.5, numP + 0.5]);
+            title(methods.name{iM});
+            ylabel('');
+            xlabel('');
+            if (iM == 1 || iM == 3)
+                set(gca, 'ytick', 1 : numP, 'yticklabel', pStruct.name(pIndexSet));
+            else
+                set(gca, 'ytick', 1 : numP, 'yticklabel', '');
+            end
+            box on;
+
+            XMin = min(pStruct.min);
+            XMax = max(pStruct.max);
+            ax = gca;
+            iP = 1;
+            for j = pIndexSet
+                CI = pStruct.CI.(methods.type{iM});
+                for k = methods.numLevels : -1 : 1;
+                    h = methods.bars(k);
+                    CI(iM,1,k) = max(CI(iM,1,k), XMin);
+                    CI(iM,1,k) = min(CI(iM,1,k), XMax);
+                    patch([CI(j,1,k), CI(j,2,k), CI(j,2,k), CI(j,1,k)], [iP-h, iP-h, iP+h, iP+h], 'k', 'FaceColor', methods.colors(iM,:,k), 'EdgeColor', 'k');
+                end
+                if isfield(pStruct, 'MS')
+                    if (strcmp(type, 'Parameters'))
+                        plot([pStruct.MS.par(j,iMAP), pStruct.MS.par(j,iMAP)], [j-0.4, j+0.4], 'k-', 'linewidth', 2);
+                    else
+                        plot([pStruct.MS.prop(j,iMAP), pStruct.MS.prop(j,iMAP)], [j-0.4, j+0.4], 'k-', 'linewidth', 2);
+                    end
+                end
+                iP = iP + 1;
+            end
+
+            if (options.draw_bounds)
+                limits = [ax.XLim(1), ax.XLim(2)];
+                pIndex1 = [pStruct.min(pIndexSet(1)); pStruct.min(pIndexSet); pStruct.min(pIndexSet(end))];
+                pIndex2 = [pStruct.max(pIndexSet(1)); pStruct.max(pIndexSet); pStruct.max(pIndexSet(end))];
+                plot(pIndex1, 0 : numP+1, 'b--', 'linewidth', 2);
+                plot(pIndex2, 0 : numP+1, 'b--', 'linewidth', 2);
+                set(gca, 'XLim', limits);
+            end
+            hold off;
+        end
+        
+        fig = gcf;
+        fig.Children = flip(fig.Children);
+        for iM = indexSet 
+            set(fig.Children(iM), 'Position', pos(iM,:));
+        end
+        
+    case 'all'
+        
+end
+
+end
+
+
+
+function methodsOut = checkMeth(methodsIn, pStruct, boolWarning)
+    % checkMeth
+    %
+    % Parameters:
+    %  methodsIn:
+    %  pStruct: 
+    %  boolWarning:
+    %
+    % Return values:
+    %  methodsOut:
+    tempMethType = {'PL', 'local_PL', 'local_B', 'S'};
+    tempMethName = {'Profile L.', 'L.App, th.', 'L.App, mass', 'Bay., Sampl.'};
+
+    checkMeth = zeros(1,4);
+    for j = 1 : 4
+        for k = 1 : length(methodsIn)
+            if (strcmp(methodsIn{k}, tempMethType{j}))
+                if (isfield(pStruct.CI, methodsIn{k}))
+                    checkMeth(j) = 1;
+                else
+                    if boolWarning
+                        warning(['You wanted to plot confidence intervals using the method ' methodsIn{k} ...
+                        ', but you did not pass the data to do so. This confidence intervals will not be plotted.']);
+                    end
+                end
+            end
+        end
+    end
+    
+    iMeth = 0;
+    for j = 1 : 4
+        if (checkMeth(j) == 1)
+            iMeth = iMeth + 1;
+            methodsOut.type{iMeth} = tempMethType{j};
+            methodsOut.name{iMeth} = tempMethName{j};
+        end
+    end
+    methodsOut.numLevels = length(pStruct.CI.alpha_levels);
+    methodsOut.levels = pStruct.CI.alpha_levels;
+    methodsOut.num = length(methodsOut.name);
+    methodsOut.bars = linspace(0.3, 0.15, methodsOut.numLevels);
+    colors = nan(methodsOut.num, 3, methodsOut.numLevels);
+    tempColors = [0.1, 0.1, 0.7; 0.6, 0, 0; 0, 0.45, 0; 0.4, 0.3, 0];
+    tempColorStep = [0.25, 0.25, 0.1; 0.1, 0.2, 0.2; 0.2, 0.15, 0.2; 0.15, 0.15, 0.2];
+    colors(:,:,1) = tempColors(1:methodsOut.num,:);
+    colorStep = tempColorStep(1:methodsOut.num,:);
+    for j = 2 : methodsOut.numLevels
+        colors(:,:,j) = min(colors(:,:,j-1) + colorStep, 1);
+    end
+    methodsOut.colors = colors;
+end
+
diff --git a/Requirements/PESTO-1.1.0/plotMCMCdiagnosis.m b/Requirements/PESTO-1.1.0/plotMCMCdiagnosis.m
new file mode 100644
index 0000000000000000000000000000000000000000..45dbc0f2be9b4cba3cd599b8f1bc9bce5a574a4d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotMCMCdiagnosis.m
@@ -0,0 +1,224 @@
+function [fh] = plotMCMCdiagnosis(parameters, varargin)
+% plotMCMCdiagnosis.m visualizes the Markov chains generated by getSamples.m.
+%
+% USAGE:
+% fh = plotMCMCdiagnosis(parameters)
+% fh = plotMCMCdiagnosis(parameters,type)
+% fh = plotMCMCdiagnosis(parameters,type,fh)
+% fh = plotMCMCdiagnosis(parameters,type,fh,I)
+% fh = plotMCMCdiagnosis(parameters,type,fh,I,options)
+%
+% Parameters:
+% parameters: parameter struct containing information about parameters
+%       and results of optimization (.MS) and uncertainty analysis
+%       (.S). This structures is the output of plotMultiStarts.m,
+%       getProfiles.m or plotSamples.m.
+% varargin:
+% type: string indicating the type of visualization:
+%       'parameters' (default) and 'log-posterior'
+% fh: handle of figure. If no figure handle is provided, a new figure
+%       is opened.
+% I: index of parameters which are updated. If no index is provided
+%       all parameters are updated.
+% options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+% fh: figure handle
+%
+% History:
+% * 2014/06/20 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+%% Check and assign inputs
+
+% Check, if parameters has all necessary fieds
+parameters = checkSanityOfStructs(parameters, 'parameters');
+
+% Plot type
+type = 'parameters';
+if nargin >= 2 && ~isempty(varargin{1})
+    type = varargin{1};
+    if ~max(strcmp({'parameters','log-posterior'},type))
+        error('The ''type'' of plot is unknown. ''type'' can only be ''parameters'' or ''log-posterior''.')
+    end
+end
+
+% Figure handle
+if nargin >= 3 && ~isempty(varargin{2})
+    fh = figure(varargin{2});
+else
+    fh = figure('Name','MCMC diagnosis');
+end
+
+% Index of subplot which is updated
+I = 1:parameters.number;
+if nargin >= 4 && ~isempty(varargin{3})
+    I = varargin{3};
+end
+
+% Options
+options = PestoPlottingOptions();
+options.plot_type = {'parameter','posterior'};
+options.n_max = 1e4;
+
+% Default sample plotting options
+%   0 => no plot of mean
+%   1 => plot of mean
+options.S.plot_type = 1; 
+options.S.col = [1,0,0];
+options.S.ls = '';
+options.S.lw = 1;
+options.S.m = '.';
+options.S.ms = 5;
+options.S.mean_col = [0.5,0,0];
+options.S.mean_lw = 1.5;
+options.S.col = [0,0,1];
+
+% Local optima
+%   0 => no plot
+%   1 => plot
+if isfield(parameters,'MS')
+    options.MS.plot_type = 1;
+else
+    options.MS.plot_type = 0; 
+end
+options.MS.col = [1,0,0];
+options.MS.lw = 1.5;
+
+% Confidence level
+options.CL.plot_type = options.MS.plot_type;
+options.CL.alpha = 0.95;
+options.CL.type = 'point-wise'; % 'simultanous', {'point-wise','simultanous'}
+options.CL.col = [1,0,0];
+options.CL.lw = 1.5;
+
+if length(varargin) >= 5
+    options = setdefault(handlePlottingOptionArgument(varargin{5}), options);
+end
+
+
+%% Initialization
+% Number of MCMC samples
+j_max = length(parameters.S.logPost);
+
+% Thinning factot
+th = ceil(j_max/options.n_max);
+
+%% Plot: Parameter chains
+if strcmp(type,'parameters')
+    
+% Compute number of subfigure
+s = round(sqrt(length(I))*[1,1]);
+if prod(s) < length(I)
+    s(2) = s(2) + 1;
+end
+
+% Loop: Parameter
+for l = 1:length(I)
+    legstr = {};
+    
+    % Assign parameter index
+    i = I(l);
+    
+    % Open subplot
+    subplot(s(1),s(2),l);
+    
+    % Hold on/off
+    if options.hold_on
+        hold on;
+    else
+        hold off;
+    end
+
+    % Plot: MCMC sample
+    J = 1:th:j_max;
+    plot(J,parameters.S.par(i,J),[options.S.ls options.S.m],...
+        'linewidth',options.S.lw,'markersize',options.S.ms,'color',options.S.col);
+    hold on;
+    legstr{1} = 'MCMC sample';
+    
+    % Plot: MCMC sample mean
+    if options.S.plot_type
+        plot([0,j_max],mean(parameters.S.par(i,:))*[1,1],...
+            'linewidth',options.S.mean_lw,'color',options.S.mean_col);
+        legstr{end+1} = 'MCMC sample mean';
+    end
+
+    % Plot: MAP estimate
+    if options.MS.plot_type
+        plot([0,j_max],parameters.MS.par(i,1)*[1,1],'-',...
+            'linewidth',options.MS.lw,'color',options.MS.col);
+        legstr{end+1} = 'MAP';
+    end
+    
+    % Limits
+    xlim([0,j_max]);
+    switch options.interval
+        case 'static'
+            yl = [parameters.min(i),parameters.max(i)];
+        case 'dynamic'
+            yl = [min(parameters.S.par(i,:)),max(parameters.S.par(i,:))];
+    end
+    ylim(yl);
+    
+    % Legend
+    if l == 1
+        legend(legstr,'location','SouthEast');
+    end
+    
+    % Labels
+    xlabel('sample path');
+    ylabel(parameters.name(i));
+
+end
+
+end
+
+%% Plot: log-Posterior chain
+if strcmp(type,'log-posterior')
+
+    % Hold on/off
+    if options.hold_on
+        hold on;
+    else
+        hold off;
+    end
+    
+    % Plot: MCMC posterior
+    J = 1:th:j_max;
+    plot(J,parameters.S.logPost(J),[options.S.ls options.S.m],...
+        'linewidth',options.S.lw,'markersize',options.S.ms,'color',options.S.col);
+    hold on;
+    legstr{1} = 'MCMC sample';
+    
+    % Plot: MAP estimate
+    if options.MS.plot_type
+        plot([0,j_max],parameters.MS.logPost(1)*[1,1],'-',...
+            'linewidth',options.MS.lw,'color',options.MS.col);
+        legstr{end+1} = 'MAP';
+    end
+    
+    % Plot: Confidence level
+    if options.CL.plot_type
+        if max(strcmp(options.CL.type,'point-wise'))
+            plot([0,j_max],[1,1]*(parameters.MS.logPost(1)-chi2inv(options.CL.alpha,1)/2),'--','linewidth',options.CL.lw,'color',options.CL.col);
+            legstr{end+1} = ['point-wise ' num2str(100*options.CL.alpha) '% conf. interval'];
+        end
+        if max(strcmp(options.CL.type,'simultanous'))
+            plot([0,j_max],[1,1]*(parameters.MS.logPost(1)-chi2inv(options.CL.alpha,parameters.number)/2),':','linewidth',options.CL.lw,'color',options.CL.col);
+            legstr{end+1} = ['simultanous ' num2str(100*options.CL.alpha) '% conf. interval'];
+        end
+    end
+    
+    % Limits
+    xlim([0,j_max]);
+    
+    % Legend
+    legend(legstr,'location','SouthEast');
+    
+    % Labels
+    xlabel('sample path');
+    ylabel('log-posterior');
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/plotMultiStartDiagnosis.m b/Requirements/PESTO-1.1.0/plotMultiStartDiagnosis.m
new file mode 100644
index 0000000000000000000000000000000000000000..c1383dc9cbf4c6e9261c467c6046df92486e4c29
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotMultiStartDiagnosis.m
@@ -0,0 +1,213 @@
+% plotMultiStartRunTimes plots the distributions of comutation time,
+% iterations and objective function evaluations of the result of the
+% multi-start optimization stored in parameters
+%
+% USAGE:
+% ======
+% fh = plotMultiStartRunTimes(parameters)
+% fh = plotMultiStartRunTimes(parameters,fh,options)
+%
+% INPUTS:
+% =======
+% parameters ... parameter struct containing information about parameters
+%   and log-posterior.about
+% fh ... handle of figure in which distributions are plotted. If no
+%   figure handle is provided, a new figure is opened.
+% options ... options of plotting
+%   .title ... switches plot title off (default = 'off').
+%   .col ... colors used for the different histograms, has to be a 3x3 matrix
+%       (default: grey = [0.4286,0.4286,0.4286;
+%                         0.5714,0.5714,0.5714;
+%                         0.7143,0.7143,0.7143];).
+%
+% Outputs:
+% ========
+% fh .. figure handle
+
+function fh = plotMultiStartDiagnosis(varargin)
+    
+    %% CHECK AND ASSIGN INPUTS
+    %Assign parameters
+    if nargin >= 1
+        parameters = varargin{1};
+    else
+        error('plotMultiStartRunTimes requires a parameter object as input.');
+    end
+    
+    %Open figure
+    if nargin >= 2
+        if ~isempty(varargin{2})
+            fh = figure(varargin{2});
+        else
+            fh = figure;
+        end
+    else
+        fh = figure;
+    end
+    
+    % Options
+    options.title = 'off';
+    options.col = [0.2081,0.1663,0.5292;
+        0.1986,0.7214,0.6310;
+        0.9763,0.9831,0.0538];
+    
+    if nargin == 3
+        options = setdefault(varargin{3},options);
+    end
+    
+    %% SORT RESULTS
+    [parameters] = sortMultiStarts(parameters);
+    
+    %% PLOT DISTRIBUTION COMPUTATION TIME
+    subplot(3,3,9)
+    cpu_time_runs = parameters.MS.t_cpu;
+    cpu_time_runs(cpu_time_runs == 0) = NaN;
+    getHistogram(cpu_time_runs/60,options.col(2,:),{'cpu time single start [min]'},[])
+    if strcmp(options.title,'on')
+        title({'CPU time per'; 'optimization'});
+    end
+    
+    
+    %% PLOT DISTRIBUTION ITERATIONS
+    subplot(3,3,3)
+    getHistogram(parameters.MS.n_iter,options.col(2,:),{'objective function'; 'iterations single start'},[])
+    if strcmp(options.title,'on')
+        title({'Number of iterations'; 'per optimization'});
+    end
+    
+    %% PLOT DISTRIBUTION OBJECTIVE FUNCTION EVALUATIONS
+    subplot(3,3,6)
+    if isfield(options,'bounds')
+        limits_x = [options.bounds.min(3),options.bounds.max(3)];
+    else
+        limits_x = [];
+    end
+    
+    getHistogram(parameters.MS.n_objfun,options.col(3,:),{'objective function'; 'evaluations single start'},[])
+    
+    if strcmp(options.title,'on')
+        title({'Number of objective function'; 'evaluations per optimization'});
+    end
+    
+    %% PLOT logPost
+    subplot(3,3,1)
+    startidx = 1:parameters.MS.n_starts;
+    
+    if(isfield(parameters.MS,'fval_trace'));
+        min_fval = transpose(min(parameters.MS.fval_trace));
+        minLP = min(min_fval);
+        plot(startidx(isnan(parameters.MS.logPost)),min_fval(isnan(parameters.MS.logPost))-minLP+1,'rx')
+        hold on
+    else
+        minLP = min(-parameters.MS.logPost);
+    end
+    plot(startidx,-parameters.MS.logPost-minLP+1,'k.')
+    xlim([0,parameters.MS.n_starts])
+    xlabel('start index')
+    ylabel('-logPost+min(logPost)+1')
+    set(gca,'YScale','log')
+    lim_y = get(gca,'YLim');
+    lim_y(1) = 10^(-0.5);
+    ylim(lim_y);
+    
+    
+    %% PLOT FMINCON EXITFLAG
+    if(isfield(parameters.MS,'exitflag'))
+        subplot(3,3,4)
+        eflag = parameters.MS.exitflag;
+        eflag(eflag>3) = -2;
+        eflag(eflag<-2) = -2;
+        plot(1:parameters.MS.n_starts,eflag,'k.')
+        unfinished = NaN(size(eflag));
+        unfinished(isnan(parameters.MS.logPost)) = 4;
+        hold on
+        plot(1:parameters.MS.n_starts,unfinished,'rx')
+        set(gca,'YTick',-2:4)
+        set(gca,'YTickLabel',{'other','output fcn','feval/iter','gradient','change in x','change in f','not finished'})
+        xlabel('start index')
+        ylabel('stopping condition')
+        xlim([0,parameters.MS.n_starts])
+        ylim([-2.5,4.5])
+    end
+    
+    %% PLOT FMINCON Gradient
+    if(isfield(parameters.MS,'gradient'))
+        subplot(3,3,7)
+        ngrad  = sqrt(sum(parameters.MS.gradient.^2));
+        plot(1:parameters.MS.n_starts,ngrad,'k.')
+        set(gca,'YScale','log')
+        xlabel('start index')
+        ylabel('norm of gradient')
+        xlim([0,parameters.MS.n_starts])
+    end
+    
+    %% PLOT fval_trace
+    if(isfield(parameters.MS,'fval_trace'))
+        subplot(3,3,2)
+        getLinePlot(parameters.MS.fval_trace,~isnan(parameters.MS.logPost))
+        xlabel('iteration')
+        ylabel('-logPost+min(logPost)+1')
+        set(gca,'YScale','log')
+    end
+    
+    %% PLOT diff par_trace
+    if(isfield(parameters.MS,'par_trace'))
+        subplot(3,3,5)
+        par_step = permute(sqrt(sum(diff(parameters.MS.par_trace,1,2).^2,1)),[2,3,1]);
+        getLinePlot([NaN(1,size(par_step,2));par_step],~isnan(parameters.MS.logPost))
+        xlabel('iteration')
+        ylabel('norm of parameter step')
+        set(gca,'YScale','log')
+    end
+    
+    
+    %% PLOT time_trace
+    if(isfield(parameters.MS,'time_trace'))
+        subplot(3,3,8)
+        getLinePlot(parameters.MS.time_trace/60,~isnan(parameters.MS.logPost))
+        xlabel('iteration')
+        ylabel('computation time [min]')
+    end
+    
+end
+
+function getHistogram(x,color,xlbl,limx)
+    if(any(~isnan(x)))
+        logx = log10(x);
+        nbin = getBins(logx,'optimal');
+        [N,X] = hist(logx,nbin);
+        he = bar(X,N,1.0,'FaceColor',color);
+        ylim([0,max(he.YData)+1]);
+        ylabel('count');
+        if(isempty(limx))
+            limx = [min(logx)-0.5,max(logx)+0.5];
+        end
+        xlim(limx);
+        xlabel(xlbl);
+        xticks = get(gca,'XTick');
+        while length(xticks)>5
+            xticks = xticks(1:2:end);
+        end
+        set(gca,'XTick',xticks);
+        set(gca,'XTickLabel',arrayfun(@(x) ['10^{' num2str(x) '}'],get(gca,'XTick'),'UniformOutput',false));
+    end
+end
+
+function getLinePlot(y,group)
+    nmaxiter = size(y,1);
+    l1 = plot(1:nmaxiter,y(:,group),'k-');
+    if(any(any(~isnan(y(:,not(group))))))
+        hold on
+        l2 = plot(transpose(1:nmaxiter),y(:,not(group)),'r-');
+        legend([l1(1),l2(1)],{'finished start','unfinished start'},'Location','best')
+        setLineTransparency(l2,0.2);
+    end
+    setLineTransparency(l1,0.4);
+
+end
+
+function setLineTransparency(lines,trans)
+    for il = 1:length(lines)
+        lines(il).Color(4) = trans;
+    end
+end
diff --git a/Requirements/PESTO-1.1.0/plotMultiStarts.m b/Requirements/PESTO-1.1.0/plotMultiStarts.m
new file mode 100644
index 0000000000000000000000000000000000000000..7974f68d57e8814d0e28761d1dc3ac38e2797f02
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotMultiStarts.m
@@ -0,0 +1,203 @@
+function fh = plotMultiStarts(parameters, varargin)
+% plotMultiStarts plots the result of the multi-start 
+% optimization stored in parameters.
+%
+% USAGE:
+% fh = plotMultiStarts(parameters)
+% fh = plotMultiStarts(parameters,fh)
+% fh = plotMultiStarts(parameters,fh,options)
+%
+% plotMultiStarts() uses the following PestoPlottingOptions members:
+%  * PestoPlottingOptions::add_points
+%  * PestoPlottingOptions::title
+%  * PestoPlottingOptions::draw_bounds
+%
+% Parameters:
+% parameters: parameter struct containing information about parameters
+%   and log-posterior.
+% varargin:
+% fh: handle of figure in which profile likelihood is plotted. If no
+%   figure handle is provided, a new figure is opened.
+% options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+% fh: figure handle
+%
+% History: 
+% * 2012/05/31 Jan Hasenauer
+% * 2016/10/07 Daniel Weindl
+
+%% CHECK AND ASSIGN INPUTS
+
+% Check, if parameters has all necessary fieds
+parameters = checkSanityOfStructs(parameters, 'parameters');
+
+% Open figure
+if length(varargin) >= 1 && ~isempty(varargin{1}) && isvalid(varargin{1})
+    fh = figure(varargin{1});
+else
+    fh = figure('Name','plotMultiStarts');
+end
+
+% Options
+defaultOptions = PestoPlottingOptions();
+defaultOptions.add_points.par = [];
+defaultOptions.add_points.logPost = [];
+defaultOptions.add_points.col = [0,0.8,0];
+defaultOptions.add_points.ls = '-';
+defaultOptions.add_points.lw = 1;
+defaultOptions.add_points.m = 'd';
+defaultOptions.add_points.ms = 8;
+defaultOptions.add_points.name = 'add. point';
+
+if length(varargin) >= 2
+    options = varargin{2};
+    options = handlePlottingOptionArgument(options);
+    options = setdefault(options, defaultOptions);
+    options.add_points = setdefault(options.add_points, defaultOptions.add_points);
+else
+    options = defaultOptions;
+end
+
+%% SORT RESULTS
+[parameters] = sortMultiStarts(parameters);
+
+%% CLUSTERING
+n_starts = length(parameters.MS.logPost);
+if (n_starts > 1)
+    clust = cluster(linkage(pdist(parameters.MS.logPost)),'cutoff',0.1,'criterion','distance');
+else
+    clust = 1;
+end
+uclust = unique(clust);
+    
+for iclust = 1:length(uclust)
+    sizecluster(iclust) = sum(clust == uclust(iclust));
+end
+
+%% ASSIGN COLORS
+Col = colormap(gray(n_starts+ceil(n_starts/3)));
+Col = Col.^(1/3);
+Col(1,:) = [1,0,0];
+
+% sort clusters
+for iclust = 1:length(uclust)
+    Jclust(iclust) = max(parameters.MS.logPost(find(clust == uclust(iclust))));
+end
+Jclust(isnan(Jclust)) = -Inf;
+[~,idx] = sort(Jclust,'descend');
+uclust = uclust(idx);
+sizecluster = sizecluster(idx);
+
+if(sizecluster(1)>1)
+    ColClust = [1,0,0;flipud(parula(max(sum(sizecluster>1)-1,0)))];
+else
+    ColClust = flipud(parula(sum(sizecluster>1)));
+end
+
+for iclust = 1:length(uclust)
+    if(sizecluster(iclust)>1)
+    Col(clust == uclust(iclust),:) = repmat(ColClust(sum(sizecluster(1:iclust)>1),:),[sizecluster(iclust),1]);
+    end
+end
+
+%% PLOT OBJECTIVES
+subplot(2,2,1);
+n_finished_starts = 0;
+for j = 1 : n_starts
+    if ~isnan(parameters.MS.logPost(j))
+        n_finished_starts = j;
+    else
+        break;
+    end
+end
+
+plot(1:n_finished_starts,parameters.MS.logPost(1:n_finished_starts),'-','color',0.9*[1,1,1],'linewidth',2);
+hold on;
+for j = n_finished_starts:-1:1
+    plot(j,parameters.MS.logPost(j),'o','color',Col(j,:),'linewidth',2);
+    hold on;
+end
+if ~isempty(options.add_points.logPost)
+    if length(options.add_points.logPost) == 1
+        if (n_starts == 1)
+            addPointsX = [0.85 1.15];
+            addPointsY = options.add_points.logPost * [1 1];
+        else
+            addPointsX = 1 : n_starts;
+            addPointsY = options.add_points.logPost * ones(size(1:n_starts));
+        end
+        plot(addPointsX,addPointsY,options.add_points.ls,'color',...
+            options.add_points.col(1,:),'linewidth',options.add_points.lw); 
+        hold on;
+    else
+        plot(1:length(options.add_points.logPost),options.add_points.logPost,...
+            options.add_points.ls,'color',options.add_points.col(1,:),...
+            'linewidth',options.add_points.lw,'marker',options.add_points.m,...
+            'markersize',options.add_points.ms); hold on;        
+    end
+end
+hold off;
+xlim([1-0.2,n_starts+0.2]);
+xlabel('start');
+ylabel('log-likelihood');
+if options.title
+    title('all estimates');
+end
+
+%% PLOT TOP TEN OBJECTIVES
+subplot(2,2,3);
+plot(1:min(n_starts,10),parameters.MS.logPost(1:min(n_starts,10)),'-','color',0.9*[1,1,1],'linewidth',2); hold on;
+for j = min(n_starts,10):-1:1
+    plot(j,parameters.MS.logPost(j),'o','color',Col(j,:),'linewidth',2); hold on;
+end
+if ~isempty(options.add_points.logPost)
+    if length(options.add_points.logPost) == 1
+        plot(1:min(n_starts,10),options.add_points.logPost*ones(size(1:min(n_starts,10))),...
+            options.add_points.ls,'color',options.add_points.col(1,:),...
+            'linewidth',options.add_points.lw); hold on;
+    else
+        plot(1:min(length(options.add_points.logPost),10),options.add_points.logPost(1:min(length(options.add_points.logPost),10)),...
+            options.add_points.ls,'color',options.add_points.col(1,:),...
+            'linewidth',options.add_points.lw,'marker',options.add_points.m,...
+            'markersize',options.add_points.ms); hold on;        
+    end
+end
+hold off;
+xlim([1-0.2,min(n_starts,10)+0.2]);
+if(any(~isnan(parameters.MS.logPost(1:min(n_starts,10)))))
+    ylim([min(parameters.MS.logPost(1),min(parameters.MS.logPost(1:min(n_starts,10)))-1),parameters.MS.logPost(1)+1]);
+end
+xlabel('start');
+ylabel('log-likelihood');
+if options.title
+    title('top 10 estimates');
+end
+
+%% PLOT PARAMETERS
+subplot(2,2,[2,4]);
+for j = n_finished_starts:-1:1
+    plot(parameters.MS.par(:,j)',1:parameters.number,'-o','color',Col(j,:),'linewidth',2); hold on;
+end
+plot(parameters.MS.par(:,1)',1:parameters.number,'r-o','linewidth',2); hold on;
+if options.draw_bounds
+    plot(parameters.min([1,1:parameters.number,parameters.number])',[0.99,1:parameters.number,parameters.number+0.01],'b--','linewidth',2); hold on;
+    plot(parameters.max([1,1:parameters.number,parameters.number])',[0.99,1:parameters.number,parameters.number+0.01],'b--','linewidth',2); hold on;
+end
+if ~isempty(options.add_points.logPost)
+    for j = 1:size(options.add_points.par,2)
+        plot(options.add_points.par(:,j)',1:parameters.number,options.add_points.ls,...
+            'color',options.add_points.col(1,:),'linewidth',options.add_points.lw,...
+            'marker',options.add_points.m,'markersize',options.add_points.ms); hold on;
+    end
+end
+hold off;
+ylim([1-0.01,parameters.number+0.01]);
+ylabel(' ');
+xlabel('parameter value');
+set(gca,'ytick',1:parameters.number,'yticklabel',parameters.name)
+
+if options.title
+    title('estimated parameters');
+end
+drawnow;
diff --git a/Requirements/PESTO-1.1.0/plotParameterProfiles.m b/Requirements/PESTO-1.1.0/plotParameterProfiles.m
new file mode 100644
index 0000000000000000000000000000000000000000..72e09da9e41f7574400ae5e8fc583e1f28b5ec15
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotParameterProfiles.m
@@ -0,0 +1,49 @@
+function fh = plotParameterProfiles(parameters, varargin)
+% plotParameterProfiles.m visualizes profile likelihood.
+% Note: This routine provides an interface for plotUncertainty.m.
+%
+% USAGE:
+% fh = plotParameterProfiles(parameters)
+% fh = plotParameterProfiles(parameters,type)
+% fh = plotParameterProfiles(parameters,type,fh)
+% fh = plotParameterProfiles(parameters,type,fh,I)
+% fh = plotParameterProfiles(parameters,type,fh,I,options)
+%
+% Parameters:
+%   parameters: parameter struct containing information about parameters
+%     and results of optimization (.MS) and uncertainty analysis
+%     (.P and .S). This structures is the output of plotMultiStarts.m,
+%     getProfiles.m or plotSamples.m.
+%   varargin:
+%     type: string indicating the type of visualization: '1D' or '2D'
+%     fh: handle of figure. If no figure handle is provided, a new figure
+%         is opened.
+%     I: index of parameters which are updated. If no index is provided
+%         all parameters are updated.
+%     options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+%   fh: figure handle
+%
+% History:
+% * 2012/05/31 Jan Hasenauer
+% * 2014/06/20 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+
+
+switch length(varargin) 
+    case 0
+        fh = plotParameterUncertainty(parameters);
+    case 1
+        fh = plotParameterUncertainty(parameters, varargin{1});
+    case 2
+        fh = plotParameterUncertainty(parameters, varargin{1}, varargin{2});
+    case 3
+        fh = plotParameterUncertainty(parameters, varargin{1}, varargin{2}, varargin{3});
+    case 4
+        fh = plotParameterUncertainty(parameters, varargin{1}, varargin{2}, varargin{3}, varargin{4});
+    otherwise
+        error('Too many arguments for plotPropertyProfiles().');
+end
+end
diff --git a/Requirements/PESTO-1.1.0/plotParameterSamples.m b/Requirements/PESTO-1.1.0/plotParameterSamples.m
new file mode 100644
index 0000000000000000000000000000000000000000..cb6b1fbe91d4c85cbdf0a8281e26d779f832d2c3
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotParameterSamples.m
@@ -0,0 +1,48 @@
+function fh = plotParameterSamples(parameters, varargin)
+% plotParameterSamples.m visualizes MCMC samples.
+% Note: This routine provides an interface for plotUncertainty.m.
+%
+% USAGE:
+% fh = plotParameterSamples(parameters)
+% fh = plotParameterSamples(parameters,type)
+% fh = plotParameterSamples(parameters,type,fh)
+% fh = plotParameterSamples(parameters,type,fh,I)
+% fh = plotParameterSamples(parameters,type,fh,I,options)
+%
+% Parameters:
+% varargin:
+% parameters: parameter struct containing information about parameters
+%       and results of optimization (.MS) and uncertainty analysis
+%       (.P and .S). This structures is the output of plotMultiStarts.m,
+%       getProfiles.m or plotSamples.m.
+% type: string indicating the type of visualization: '1D' or '2D'
+% fh: handle of figure. If no figure handle is provided, a new figure
+%       is opened.
+% I: index of parameters which are updated. If no index is provided
+%       all parameters are updated.
+% options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+% fh: figure handle
+%
+% History:
+% * 2012/05/31 Jan Hasenauer
+% * 2014/06/20 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+    switch length(varargin) 
+        case 0
+            fh = plotParameterUncertainty(parameters);
+        case 1
+            fh = plotParameterUncertainty(parameters, varargin{1});
+        case 2
+            fh = plotParameterUncertainty(parameters, varargin{1}, varargin{2});
+        case 3
+            fh = plotParameterUncertainty(parameters, varargin{1}, varargin{2}, varargin{3});
+        case 4
+            fh = plotParameterUncertainty(parameters, varargin{1}, varargin{2}, varargin{3}, varargin{4});
+        otherwise
+            error('Too many arguments for plotParameterSamples().');
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/plotParameterUncertainty.m b/Requirements/PESTO-1.1.0/plotParameterUncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..cb3543b44a784e059e661a99e14800b13b5c54be
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotParameterUncertainty.m
@@ -0,0 +1,796 @@
+function fh = plotParameterUncertainty(parameters, varargin)
+% plotParameterUncertainty.m visualizes profile likelihood and MCMC samples
+% stored in parameters.
+%
+% USAGE:
+% fh = plotParameterUncertainty(parameters)
+% fh = plotParameterUncertainty(parameters,type)
+% fh = plotParameterUncertainty(parameters,type,fh)
+% fh = plotParameterUncertainty(parameters,type,fh,I)
+% fh = plotParameterUncertainty(parameters,type,fh,I,options)
+%
+% plotMultiStarts() uses the following PestoPlottingOptions members:
+%  * PestoPlottingOptions::P
+%  * PestoPlottingOptions::S
+%  * PestoPlottingOptions::MS
+%  * PestoPlottingOptions::boundary
+%  * PestoPlottingOptions::subplot_size_1D
+%  * PestoPlottingOptions::subplot_indexing_1D
+%  * PestoPlottingOptions::CL
+%  * PestoPlottingOptions::hold_on
+%  * PestoPlottingOptions::interval
+%  * PestoPlottingOptions::bounds
+%  * PestoPlottingOptions::A
+%  * PestoPlottingOptions::add_points
+%  * PestoPlottingOptions::labels
+%  * PestoPlottingOptions::legend
+%  * PestoPlottingOptions::op2D
+%  * PestoPlottingOptions::fontsize
+%
+% Parameters:
+%   parameters: parameter struct containing information about parameters
+%       and results of optimization (.MS) and uncertainty analysis
+%       (.P and .S). This structures is the output of plotMultiStarts.m,
+%       getProfiles.m or plotSamples.m.
+%   varargin:
+%     type: string indicating the type of visualization: '1D' or '2D'
+%     fh: handle of figure. If no figure handle is provided, a new figure
+%         is opened.
+%     I: index of parameters which are updated. If no index is provided
+%         all parameters are updated.
+%     options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+%   fh: figure handle
+%
+% History:
+% * 2012/05/31 Jan Hasenauer
+% * 2014/06/20 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+%% Check and assign inputs
+% Plot type
+type = '1D';
+if length(varargin) >= 1 && ~isempty(varargin{1})
+    type = varargin{1};
+    if ~max(strcmp({'1D','2D'},type))
+        error('The ''type'' of plot is unknown.')
+    end
+end
+
+% Check, if parameters has all necessary fieds
+parameters = checkSanityOfStructs(parameters, 'parameters');
+
+% Open figure
+if length(varargin) >= 2 && ~isempty(varargin{2})
+    fh = figure(varargin{2});
+else
+    fh = figure('Name','plotParameterUncertainty');
+end
+
+% Index of subplot which is updated
+I = 1:parameters.number;
+if length(varargin) >= 3
+    if ~isempty(varargin{3})
+        I = varargin{3};
+        if ~isnumeric(I) || max(abs(I - round(I)) > 0)
+            error('I is not an integer vector.');
+        end
+    end
+end
+
+% Options
+% General plot options
+if length(varargin) >= 4
+    options = handlePlottingOptionArgument(varargin{4});
+else
+    options = PestoPlottingOptions();
+end
+
+if ~isfield(parameters,'P')
+    options.P.plot_type = 0; 
+    options.boundary.mark = 0;
+end
+
+if ~isfield(parameters,'S')
+    options.S.plot_type = 0;
+end
+
+if ~isfield(parameters,'MS')
+    options.MS.plot_type = 0; 
+end
+
+% Subplot arrangement
+if isempty(options.subplot_size_1D)
+    options.subplot_size_1D = round(sqrt(length(I))*[1,1]);
+    if prod(options.subplot_size_1D) < length(I)
+        options.subplot_size_1D(2) = options.subplot_size_1D(2) + 1;
+    end
+end
+if isempty(options.subplot_indexing_1D)
+    options.subplot_indexing_1D = 1:length(I);
+end
+
+%% INITALIZATION
+% Maximum a posterior estimate
+if (isfield(parameters, 'MS'))
+    logPost_max = max(parameters.MS.logPost);
+else
+    logPost_max = max(parameters.S.logPost);
+end
+
+% Degrees of freedom (for chi^2 test)
+dof = 1;
+if max(strcmp(options.CL.type,'simultanous'))
+    dof = parameters.number;
+end
+
+%% 1D Parameter distributions
+if strcmp(type,'1D')
+
+% Compute number of subfigure
+
+% Loop: Parameter
+for l = 1:length(I)
+    % Initialization of legend
+    legh = [];
+    legs = {};
+
+    % Assign parameter index
+    i = I(l);
+    
+    % Open subplot
+    subplot(options.subplot_size_1D(1),options.subplot_size_1D(2),options.subplot_indexing_1D(l));
+    
+    % Hold on/off
+    if options.hold_on
+        hold on;
+    else
+        hold off;
+    end
+    
+    % Boundaries
+    switch options.interval
+        case 'dynamic'
+            xl = [+inf,-inf];
+            
+            if isfield(parameters,'MS')
+                if max(strcmp(options.CL.type,'point-wise'))
+                    L = find(parameters.MS.logPost(:) > (parameters.MS.logPost(1)-chi2inv(options.CL.alpha,1)/2));
+                end
+                if max(strcmp(options.CL.type,'simultanous'))
+                    L = find(parameters.MS.logPost(:) > (parameters.MS.logPost(1)-chi2inv(options.CL.alpha,parameters.number)/2));
+                end
+                xl(1) = min(xl(1),min(parameters.MS.par(i,L)));
+                xl(2) = max(xl(2),max(parameters.MS.par(i,L)));
+            else
+                xl(1) = parameters.min(i);
+                xl(2) = parameters.max(i);
+            end
+        
+            flag_plot_P = 0;
+            if options.P.plot_type >= 1
+                if length(parameters.P) >= i
+                    if ~isempty(parameters.P(i).par)
+                        xl(1) = min(xl(1), min(parameters.P(i).par(i,:)));
+                        xl(2) = max(xl(2), max(parameters.P(i).par(i,:)));
+                        flag_plot_P = 1;
+                    end
+                end
+            end
+            
+            if xl(1) == xl(2)
+                xl(1) = xl(1) - 1e-10;
+                xl(2) = xl(2) + 1e-10;
+            end
+        case 'static'
+            if ~isempty(options.bounds)
+                xl = [options.bounds.min(i),options.bounds.max(i)];
+            else
+                xl = [parameters.min(i),parameters.max(i)];
+            end
+            flag_plot_P = 0;
+            if options.P.plot_type >= 1
+                if length(parameters.P) >= i
+                    if ~isempty(parameters.P(i).par)
+                        flag_plot_P = 1;
+                    end
+                end
+            end
+    end
+
+    % Plot: Visualizaion of MCMC samples of tempered posterior distribution
+    h = [];
+    switch options.S.plot_type
+        case 0
+            % no plot
+        case 1
+            % histogram
+                for k = 1
+                    switch options.S.bins
+                        case 'optimal'
+                            h = 3.49*std(parameters.S.par(i,:,k))/(length(parameters.S.par(i,:,k))^(1/3));
+                            nbin = round((max(parameters.S.par(i,:,k))-min(parameters.S.par(i,:,k)))/h);
+                        case 'conservative'
+                            h = 2*3.49*std(parameters.S.par(i,:,k))/(length(parameters.S.par(i,:,k))^(1/3));
+                            nbin = round((max(parameters.S.par(i,:,k))-min(parameters.S.par(i,:,k)))/h);
+                        otherwise
+                            nbin = options.S.bins;
+                    end
+                    [N,X] = hist(parameters.S.par(i,:,k),nbin);
+                    h = bar(X,N/max(N),1,'facecolor',options.S.hist_col(k,:),'edgecolor',[0.4,0.4,0.4]);
+                    hold on;
+                    
+                    if strcmp(options.interval, 'dynamic')
+                        xl(1) = min(xl(1), min(X));
+                        xl(2) = max(xl(2), max(X));
+                    end
+                    % bar(X,N/max(N),1,'facecolor','none','edgecolor',options.S.col(k,:)); hold on;
+                end
+        case 2
+            % kernel-density estimate
+             for k = options.S.ind:-1:1
+                 x_grid = linspace(min(parameters.S.par(i,:,k)),max(parameters.S.par(i,:,k)),100);
+                 [KDest] = getKernelDensityEstimate(squeeze(parameters.S.par(i,:,k)),x_grid);
+                 h = plot(x_grid,KDest/max(KDest),'-','color',options.S.sp_col(k,:),'linewidth',options.S.lw); hold on;
+             end
+        otherwise
+            error('Selected value for ''options.S.plot_type'' is not available.');
+    end
+
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.S.name;
+    end
+
+    % Plot: Local approximation
+    h = [];
+    switch options.A.plot_type
+        case 0
+            % no plot
+        case 1
+            if (isfield(parameters, 'MS'))
+                if isfield(parameters.MS,'hessian')
+                    ind_not_nan = find(~isnan(diag(parameters.MS.hessian(:,:,1))));
+                    j = find(i==ind_not_nan);
+                    if ~isempty(j)
+                        % Standard deviation of Gaussian approximation of
+                        % profile
+                        Sigma = pinv(parameters.MS.hessian(ind_not_nan,ind_not_nan,1));
+                        sigma = sqrt(Sigma(j,j));
+                        % Get grid
+                        par_grid = parameters.MS.par(i,1) + sigma*linspace(-4,4,100);
+                        par_grid = par_grid(find((parameters.min(i) <= par_grid).*(par_grid <= parameters.max(i))));
+                        % Calculation of objectiev function approximation
+                        J = parameters.MS.gradient(i,1)*(par_grid-parameters.MS.par(i,1)) + 0.5*((par_grid-parameters.MS.par(i,1))/sigma).^2;
+                        % Plot
+                        h = plot(par_grid,exp(-J),'-','linewidth',options.A.lw,'color',options.A.col); hold on;
+                    end
+                else
+                    warning('No hessian provided in .MS. Approximation in not plotted.');
+                end
+            else
+                
+            end
+        case 2
+            if isfield(parameters.MS,'hessian')
+                % negative log-likelihood
+                Sigma = pinv(parameters.MS.hessian(:,:,1));
+                sigma = sqrt(Sigma(i,i));
+                % Get grid
+                par_grid = parameters.MS.par(i,1) + sigma*linspace(-4,4,100);
+                par_grid = par_grid(find((parameters.min(i) <= par_grid).*(par_grid <= parameters.max(i))));
+                % Calculation of objectiev function approximation
+                % - with non-zero gradient
+%                 ind_I = [1:i-1,i+1:parameters.number];
+%                 dtheta_i = -parameters.MS.par(i,1)+par_grid;
+%                 dtheta_ind_I = -pinv(parameters.MS.hessian(ind_I,ind_I,1))*bsxfun(@plus,parameters.MS.hessian(ind_I,i,1)*dtheta_i,parameters.MS.gradient(ind_I,1));
+%                 dtheta = [dtheta_ind_I(1:i-1,:);dtheta_i;dtheta_ind_I(i:end,:)];
+%                 J = nan(1,size(dtheta,2));
+%                 for l = 1:size(dtheta,2)
+%                     J(l) = parameters.MS.gradient(:,1)'*dtheta(:,l) + 0.5*dtheta(:,l)'*parameters.MS.hessian(:,:,1)*dtheta(:,l);
+%                 end
+                J = parameters.MS.gradient(i,1)*(par_grid-parameters.MS.par(i,1)) + 0.5*((par_grid-parameters.MS.par(i,1))/sigma).^2;
+                % - with zero gradient
+%                 J = 0.5*((par_grid-parameters.MS.par(i,1))/sigma).^2;
+                % Plot
+                h = plot(par_grid,J,'-','linewidth',options.A.lw,'color',options.A.col); hold on;
+            else
+                warning('No hessian provided in .MS. Approximation in not plotted.');
+            end
+        otherwise
+            error('Selected value for ''options.A.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.A.name;
+    end
+
+    % Plot: Profile likelihood
+    h = [];
+    switch options.P.plot_type * flag_plot_P
+        case 0
+            % no plot
+        case 1
+            % likelihood ratio
+            h = plot(parameters.P(i).par(i,:),exp(parameters.P(i).logPost - logPost_max),'-','linewidth',options.P.lw,'color',options.P.col); hold on;
+        case 2
+            % negative log-likelihood
+            h = plot(parameters.P(i).par(i,:),parameters.P(i).logPost,'-','linewidth',options.P.lw,'color',options.P.col); hold on;
+        otherwise
+            error('Selected value for ''options.P.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.P.name;
+    end
+    
+    % Plot: Additional points
+    h = [];
+    if ~isempty(options.add_points.par)
+        % Check dimension:
+        if size(options.add_points.par,1) ~= parameters.number
+            warning(['The matrix options.add_points.par should possess ' num2str(parameters.number) ' rows.']);
+        else
+            for j = 1:size(options.add_points.par,2)
+                if size(options.add_points.col,1) == size(options.add_points.par,2)
+                    l = j;
+                else
+                    l = 1;
+                end
+                h = plot(options.add_points.par(i,j)*[1,1],[0,1.05],options.add_points.ls,'color',options.add_points.col(l,:),'linewidth',options.add_points.lw);
+            end
+        end
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.add_points.name;
+    end
+    
+    % Bounds
+    if (options.P.plot_type >= 1) * flag_plot_P
+        switch options.boundary.mark
+            case 0
+                % no plot
+            case 1
+                ind = find(sum( bsxfun(@gt,parameters.min+options.boundary.eps,parameters.P(i).par)...
+                               +bsxfun(@gt,parameters.P(i).par,parameters.max-options.boundary.eps),1));
+                if ~isempty(ind)
+                    switch options.P.plot_type
+                        case 1
+                            % likelihood ratio
+                            plot(parameters.P(i).par(i,ind),exp(parameters.P(i).logPost(ind) - logPost_max),'x','linewidth',options.P.lw,'color',options.P.col); hold on;    
+                        case 2
+                            % negative log-likelihood
+                            plot(parameters.P(i).par(i,ind),parameters.P(i).logPost(ind),'x','linewidth',options.P.lw,'color',options.P.col); hold on;    
+                    end
+                end
+            otherwise
+                error('Selected value for ''options.boundary.mark'' is not available.');
+        end
+    end
+    
+    % Plot: Local optima
+    if isfield(parameters,'MS')
+        h_conv = [];
+        h_nconv = [];
+        if options.MS.only_optimum
+            ind = 1;
+        else
+            ind = find(parameters.MS.logPost >= parameters.MS.logPost(1)-chi2inv(options.CL.alpha,dof)/2);
+        end
+        ind_conv = ind(find(min((parameters.MS.exitflag(ind) > 0)+(parameters.MS.exitflag(ind) == -3),1)));
+        ind_nconv = setdiff(ind,ind_conv);
+        switch options.MS.plot_type
+            case 0
+                % no plot
+            case 1
+                % likelihood ratio
+                h_conv = plot(parameters.MS.par(i,ind_conv),exp(parameters.MS.logPost(ind_conv)-logPost_max),'o','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+                h_nconv = plot(parameters.MS.par(i,ind_nconv),exp(parameters.MS.logPost(ind_nconv)-logPost_max),'s','linewidth',options.MS.lw,'color',options.MS.col);
+            case 2
+                % negative log-likelihood
+                h_conv = plot(parameters.MS.par(i,ind_conv),parameters.MS.logPost(ind_conv),'o','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+                h_nconv = plot(parameters.MS.par(i,ind_nconv),parameters.MS.logPost(ind_nconv),'s','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+            otherwise
+                error('Selected value for ''options.MS.plot_type'' is not available.');
+        end
+        if ~isempty(h_conv)
+            legh(end+1) = h_conv;
+            legs{end+1} = options.MS.name_conv;
+        end
+        if ~isempty(h_nconv)
+            legh(end+1) = h_nconv;
+            legs{end+1} = options.MS.name_nconv;
+        end
+    end
+    
+    % Limits
+    % x
+    if strcmp(options.interval,'static')
+        xl = [parameters.min(i),parameters.max(i)];
+    end
+    xlim(xl);
+
+    % y
+    switch options.P.plot_type
+        case {0,1}
+            % likelihood ratio
+            ylim([0,1.1]);
+        case 2
+            % Best choice not clear => automatic assignment
+    end
+    
+    % Plot: Confidence levels
+    h = [];
+    switch options.CL.plot_type
+        case 0
+            % no plot
+        case 1
+            % likelihood ratio
+            if max(strcmp(options.CL.type,'point-wise'))
+                plot(xl,[1,1]*exp(-chi2inv(options.CL.alpha,1)/2),'--','color',options.CL.col);
+            end
+            if max(strcmp(options.CL.type,'simultanous'))
+                plot(xl,[1,1]*exp(-chi2inv(options.CL.alpha,parameters.number)/2),':','linewidth',options.CL.lw,'color',options.CL.col);
+            end
+        case 2
+            % negative log-likelihood
+            if max(strcmp(options.CL.type,'point-wise'))
+                plot(xl,[1,1]*(parameters.MS.logPost(1)-chi2inv(options.CL.alpha,1)/2),'--','linewidth',options.CL.lw,'color',options.CL.col);
+            end
+            if max(strcmp(options.CL.type,'simultanous'))
+                plot(xl,[1,1]*(parameters.MS.logPost(1)-chi2inv(options.CL.alpha,parameters.number)/2),':','linewidth',options.CL.lw,'color',options.CL.col);
+            end
+        otherwise
+            error('Selected value for ''options.CL.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.CL.name;
+    end
+    
+    % Labels
+    xlabel(parameters.name(i));
+    if (mod(options.subplot_indexing_1D(l),options.subplot_size_1D(2)) == 1) || (length(I) == 1) || options.labels.y_always
+        if isempty(options.labels.y_name)
+            switch options.CL.plot_type
+                case 0
+                    % no plot
+                    ylabel('post. prob., p');
+                case 1
+                    % likelihood ratio
+                    ylabel('ratio, R');
+                case 2
+                    % negative log-likelihood
+                    ylabel('log-profile, log(PL)');
+            end
+        else
+            ylabel(options.labels.y_name);
+        end
+    else
+        set(gca,'Ytick',[]);
+    end
+    set(gca,'fontsize',options.fontsize.tick);
+
+    % Legend
+    if l == 1
+        if isempty(options.legend.position)
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation);
+        else
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation,'position',options.legend.position);
+        end
+    end
+end
+
+end
+
+
+%% 2D Parameter distributions
+if strcmp(type,'2D')
+    
+% Loop: Parameter
+for l1 = 1:length(I)
+for l2 = 1:length(I)
+    % Initialization of legend
+    legh = [];
+    legs = {};
+
+    % Assign parameter index
+    i1 = I(l1);
+    i2 = I(l2);
+    
+    % Open subplot
+    d = (1-options.op2D.b1-options.op2D.b2)/length(I);
+    subplot('Position',[options.op2D.b1+(l1-1)*d,...
+                        options.op2D.b1+(length(I)-l2)*d,...
+                        options.op2D.r*d,options.op2D.r*d]);
+    
+    % Hold on/off
+    if options.hold_on
+        hold on;
+    else
+        hold off;
+    end
+    
+    % Boundaries
+    switch options.interval
+        case 'dynamic'
+            xl1 = [+inf,-inf];
+            xl2 = [+inf,-inf];
+            
+            flag_plot_P_i1 = 0;
+            flag_plot_P_i2 = 0;
+            if options.P.plot_type >= 1
+                if length(parameters.P) >= i1
+                    if ~isempty(parameters.P(i1).par)
+                        xl1(1) = min(xl1(1),min(parameters.P(i1).par(i1,:)));
+                        xl1(2) = max(xl1(2),max(parameters.P(i1).par(i1,:)));
+                        flag_plot_P_i1 = 1;
+                    end
+                end
+                if length(parameters.P) >= i2
+                    if ~isempty(parameters.P(i2).par)
+                        xl2(1) = min(xl2(1),min(parameters.P(i2).par(i2,:)));
+                        xl2(2) = max(xl2(2),max(parameters.P(i2).par(i2,:)));
+                        flag_plot_P_i2 = 1;
+                    end
+                end
+            end
+
+            if options.S.plot_type >= 1
+                xl1(1) = min(xl1(1),min(parameters.S.par(i1,:)));
+                xl1(2) = max(xl1(2),max(parameters.S.par(i1,:)));
+                xl2(1) = min(xl2(1),min(parameters.S.par(i2,:)));
+                xl2(2) = max(xl2(2),max(parameters.S.par(i2,:)));
+            end
+
+        case 'static'
+            if ~isempty(options.bounds)
+                xl1 = [options.bounds.min(i1),options.bounds.max(i1)];
+                xl2 = [options.bounds.min(i2),options.bounds.max(i2)];
+            else
+                xl1 = [parameters.min(i1),parameters.max(i1)];
+                xl2 = [parameters.min(i2),parameters.max(i2)];
+            end
+    end
+                    
+    % Plot: MCMC samples of tempered posterior distribution
+    h = [];
+    switch options.S.plot_type
+        case 0
+            % no plot
+        case 1
+            % scatter plot
+             for k = 1:options.S.ind
+                 h = plot(parameters.S.par(i1,:,k),parameters.S.par(i2,:,k),options.S.sp_m,...
+                     'color',options.S.sp_col(k,:),'markersize',options.S.sp_ms); hold on;
+             end
+        case 2
+            % kernel-density estimate
+             for k = options.S.ind:-1:1
+                 x1_line = linspace(min(parameters.S.par(i1,:,k)),max(parameters.S.par(i1,:,k)),100);
+                 x2_line = linspace(min(parameters.S.par(i2,:,k)),max(parameters.S.par(i2,:,k)),100);
+                 [x1_grid, x2_grid] = meshgrid(x1_line, x2_line);
+                 x_grid = transpose([x1_grid(:), x2_grid(:)]);
+                 [KDest] = getKernelDensityEstimate([squeeze(parameters.S.par(i1,:,k)); squeeze(parameters.S.par(i2,:,k))], x_grid);
+                 KDest = reshape(KDest, length(x1_line), length(x2_line));
+                 [~,h] = contour(x1_line, x2_line, KDest/max(max(KDest)),'-','color',options.S.sp_col(k,:),'linewidth',options.S.lw); 
+                 hold on;
+             end
+        otherwise
+            error('Selected value for ''options.S.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.S.name;
+    end
+
+    % Plot: Local approximation
+    h = [];
+    switch options.A.plot_type
+        case 0
+            % no plot
+        case {1,2}
+            if strcmp(options.MCMC, 'user-provided')
+                if isfield(parameters, 'user')
+                    userProv = 'all';
+                    if ((~isfield(parameters.user, 'theta_0')) || isempty(parameters.user.theta_0))
+                        userProv = 'sigmaOnly';
+                    end
+                    if ((~isfield(parameters.user, 'Sigma_0')) || isempty(parameters.user.Sigma_0))
+                        userProv = 'no';
+                    end
+                else
+                    userProv = 'no';
+                end
+            else
+                userProv = 'no';
+            end
+            
+            plot_appr = false;
+            
+            switch userProv
+                case 'no'
+                    if (isfield(parameters, 'MS') && isfield(parameters.MS, 'hessian') && (size(parameters.MS.hessian,3) >= 1))
+                        Sigma = pinv(parameters.MS.hessian([i1,i2],[i1,i2],1));
+                        theta_0 = parameters.MS.par([i1,i2],1);
+                        plot_appr = true;
+                    elseif isfield(parameters, 'MS')
+                        warning('No valid values for sigma found! No plotting approximation.');
+                    end
+                case 'sigmaOnly'
+                    if (~isfield(parameters, 'MS') || ~isfield(parameters.MS, 'par') || isempty(parameters.MS.par,3))
+                        Sigma = parameters.user.Sigma_0([i1,i2],[i1,i2]);
+                        theta_0 = parameters.MS.par([i1,i2],1);
+                        plot_appr = true;
+                    else
+                        warning('No valid values for theta found! No plotting approximation.');
+                    end
+                case 'all'
+                    Sigma = parameters.user.Sigma_0([i1,i2],[i1,i2]);
+                    theta_0 = parameters.user.theta_0([i1,i2]);
+                    plot_appr = true;
+            end
+            
+            if plot_appr
+                X = getEllipse(theta_0, Sigma, options.A.sigma_level);
+                h = plot(X(1,:),X(2,:),'-','linewidth',options.A.lw/1.5,'color',options.A.col); hold on;
+            end
+            
+        otherwise
+            error('Selected value for ''options.A.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.A.name;
+    end
+    
+    % Plot: Local optima
+    if isfield(parameters,'MS')
+        h_conv = [];
+        h_nconv = [];
+        if options.MS.only_optimum
+            ind = 1;
+        else
+            ind = find(parameters.MS.logPost >= parameters.MS.logPost(1)-chi2inv(options.CL.alpha,dof)/2);
+        end
+        ind_conv = ind(find(min((parameters.MS.exitflag(ind) > 0)+(parameters.MS.exitflag(ind) == -3),1)));
+        ind_nconv = setdiff(ind,ind_conv);
+        switch options.P.plot_type
+            case 0
+                % no plot
+            case {1,2}
+                h_conv = plot(parameters.MS.par(i1,ind_conv),parameters.MS.par(i2,ind_conv),'o','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+                h_nconv = plot(parameters.MS.par(i1,ind_nconv),parameters.MS.par(i2,ind_nconv),'s','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+            otherwise
+                error('Selected value for ''options.MS.plot_type'' is not available.');
+        end
+        if ~isempty(h_conv)
+            legh(end+1) = h_conv;
+            legs{end+1} = options.MS.name_conv;
+        end
+        if ~isempty(h_nconv)
+            legh(end+1) = h_nconv;
+            legs{end+1} = options.MS.name_nconv;
+        end
+    end
+    % Plot: Profile likelihood
+    h = [];
+    switch options.P.plot_type
+        case 0
+            % no plot
+        case {1,2}
+            if flag_plot_P_i1
+                h = plot(parameters.P(i1).par(i1,:),parameters.P(i1).par(i2,:),'-','linewidth',options.P.lw,'color',options.P.col*0.8); hold on;
+            end
+            if flag_plot_P_i2
+                h = plot(parameters.P(i2).par(i1,:),parameters.P(i2).par(i2,:),'-','linewidth',options.P.lw,'color',options.P.col*0.6); hold on;
+            end
+        otherwise
+            error('Selected value for ''options.P.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.P.name;
+    end
+    
+    % Plot: Additional points
+    h = [];
+    if ~isempty(options.add_points.par)
+        % Check dimension:
+        if size(options.add_points.par,1) ~= parameters.number
+            warning(['The matrix options.add_points.par should possess ' num2str(parameters.number) ' rows.']);
+        else
+            for j = 1:size(options.add_points.par,2)
+                if size(options.add_points.col,1) == size(options.add_points.par,2)
+                    l = j;
+                else
+                    l = 1;
+                end
+                h = plot(options.add_points.par(i1,j),options.add_points.par(i2,j),options.add_points.m,...
+                    'color',options.add_points.col(l,:),'linewidth',options.add_points.lw,'markersize',options.add_points.ms);
+            end
+        end
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.add_points.name;
+    end
+    
+    % Bounds
+    switch options.boundary.mark
+        case 0
+            % no plot
+        case 1
+            % i1
+            if length(parameters.P) >= i1
+                if ~isempty(parameters.P(i1).par)
+                    ind = find(sum( bsxfun(@gt,parameters.min+options.boundary.eps,parameters.P(i1).par)...
+                                    +bsxfun(@gt,parameters.P(i1).par,parameters.max-options.boundary.eps),1));
+                    if ~isempty(ind)
+                        switch options.P.plot_type
+                            case {1,2}
+                                plot(parameters.P(i1).par(i1,ind),parameters.P(i1).par(i2,ind),'x','linewidth',options.P.lw,'color',options.P.col*0.8); hold on;    
+                        end
+                    end
+                end
+            end
+            
+            % i2
+            if length(parameters.P) >= i2
+                if ~isempty(parameters.P(i2).par)
+                    ind = find(sum( bsxfun(@gt,parameters.min+options.boundary.eps,parameters.P(i2).par)...
+                                    +bsxfun(@gt,parameters.P(i2).par,parameters.max-options.boundary.eps),1));
+                    if ~isempty(ind)
+                        switch options.P.plot_type
+                            case {1,2}
+                                plot(parameters.P(i2).par(i1,ind),parameters.P(i2).par(i2,ind),'x','linewidth',options.P.lw,'color',options.P.col*0.6); hold on;    
+                        end
+                    end
+                end
+            end
+        otherwise
+            error('Selected value for ''options.boundary.mark'' is not available.');
+    end
+        
+    % Limits
+    if ~isinf(xl1(1))
+        xlim(xl1);
+    end
+    if ~isinf(xl2(1))
+        ylim(xl2);
+    end
+
+    % Labels
+    if l2 == length(I)
+        xlabel(parameters.name(i1));
+    else
+        set(gca,'xticklabel',[]);
+    end
+    if i1 == 1
+        ylabel(parameters.name(i2));
+    else
+        set(gca,'yticklabel',[]);
+    end
+    set(gca,'fontsize',options.fontsize.tick);
+    
+    % Legend
+    if (l1 == 1) && (l2 == 1)
+        if isempty(options.legend.position)
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation);
+        else
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation,'position',options.legend.position);
+        end
+    end
+
+end
+end
+
+end
+
+
+%% Update plot
+drawnow;
+
+
diff --git a/Requirements/PESTO-1.1.0/plotPropertyMultiStarts.m b/Requirements/PESTO-1.1.0/plotPropertyMultiStarts.m
new file mode 100644
index 0000000000000000000000000000000000000000..1a24533942b4a21e2aaa9cdc83f12618d07b81cf
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotPropertyMultiStarts.m
@@ -0,0 +1,96 @@
+function fh = plotPropertyMultiStarts(properties, varargin)
+% plotPropertyMultiStarts plots the result of the multi-start optimization stored in properties.
+%
+% USAGE:
+% fh = plotPropertyMultiStarts(properties)
+% fh = plotPropertyMultiStarts(properties,fh)
+% fh = plotPropertyMultiStarts(properties,fh,options)
+%
+% Parameters:
+% varargin:
+% properties: property struct containing information about properties
+%   and log-posterior.
+% fh: handle of figure in which profile likelihood is plotted. If no
+%   figure handle is provided, a new figure is opened.
+% options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+% fh: figure handle
+%
+% History:
+% * 2015/03/03 Jan Hasenauer
+
+%% CHECK AND ASSIGN INPUTS
+% Open figure
+if length(varargin) >= 1 && ~isempty(varargin{1})
+    fh = figure(varargin{1});
+else
+    fh = figure('Name','plotPropertyMultiStarts');
+end
+
+% Check, if properties has all necessary fieds
+properties = checkSanityOfStructs(properties, 'properties');
+
+% Options
+if length(varargin) >= 2
+    options = handlePlottingOptionArgument(varargin{2});
+else
+    options = PestoPlottingOptions();
+end
+
+%% ASSIGN COLORS
+i = length(properties.MS.logPost);
+Col = colormap(gray(i+ceil(i/3)));
+Col = Col.^(1/3);
+Col(1,:) = [1,0,0];
+
+%% PLOT OBJECTIVES
+subplot(2,2,1);
+plot(1:i,properties.MS.logPost,'-','color',0.9*[1,1,1],'linewidth',2); hold on;
+for j = i:-1:1
+    plot(j,properties.MS.logPost(j),'o','color',Col(j,:),'linewidth',2); hold on;
+end
+hold off;
+xlim([1-0.2,i+0.2]);
+xlabel('start');
+ylabel('log-likelihood');
+if options.title
+    title('all estimates');
+end
+
+%% PLOT TOP TEN OBJECTIVES
+subplot(2,2,3);
+plot(1:min(i,10),properties.MS.logPost(1:min(i,10)),'-','color',0.9*[1,1,1],'linewidth',2); hold on;
+for j = min(i,10):-1:1
+    plot(j,properties.MS.logPost(j),'o','color',Col(j,:),'linewidth',2); hold on;
+end
+hold off;
+xlim([1-0.2,min(i,10)+0.2]);
+
+ylim([min(properties.MS.logPost(1),min(properties.MS.logPost(1:min(i,10)))-1),properties.MS.logPost(1)+1]);
+xlabel('start');
+ylabel('log-likelihood');
+if options.title
+    title('top 10 estimates');
+end
+
+%% PLOT PROPERTIES
+subplot(2,2,[2,4]);
+for j = i:-1:1
+    plot(properties.MS.prop(:,j)',1:properties.number,'-o','color',Col(j,:),'linewidth',2); hold on;
+end
+plot(properties.MS.prop(:,1)',1:properties.number,'r-o','linewidth',2); hold on;
+if options.draw_bounds
+    plot(properties.min([1,1:properties.number,properties.number])',[0.99,1:properties.number,properties.number+0.01],'b--','linewidth',2); hold on;
+    plot(properties.max([1,1:properties.number,properties.number])',[0.99,1:properties.number,properties.number+0.01],'b--','linewidth',2); hold on;
+end
+hold off;
+ylim([1-0.01,properties.number+0.01]);
+ylabel(' ');
+xlabel('parameters values');
+set(gca,'ytick',1:properties.number,'yticklabel',properties.name)
+
+if options.title
+    title('estimated parameters');
+end
+drawnow;
diff --git a/Requirements/PESTO-1.1.0/plotPropertyProfiles.m b/Requirements/PESTO-1.1.0/plotPropertyProfiles.m
new file mode 100644
index 0000000000000000000000000000000000000000..ddf23be9f00cdeb8194c0c1ce5101256a7d3ce3d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotPropertyProfiles.m
@@ -0,0 +1,45 @@
+function fh = plotPropertyProfiles(properties, varargin)
+% plotPropertyProfiles.m visualizes profile likelihood of model properties.
+% Note: This routine provides an interface for plotPropertyUncertainty.m.
+%
+% USAGE:
+% fh = plotPropertyProfiles(properties)
+% fh = plotPropertyProfiles(properties,type)
+% fh = plotPropertyProfiles(properties,type,fh)
+% fh = plotPropertyProfiles(properties,type,fh,I)
+% fh = plotPropertyProfiles(properties,type,fh,I,options)
+%
+% Parameters:
+%   properties: property struct containing information about properties
+%       and results of optimization (.MS) and uncertainty analysis
+%       (.P and .S).
+%   varargin:
+%     type: string indicating the type of visualization: '1D' or '2D'
+%     fh: handle of figure. If no figure handle is provided, a new figure
+%         is opened.
+%     I: index of properties which are updated. If no index is provided
+%         all properties are updated.
+%     options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+%   fh: figure handle
+%
+% History:
+% * 2015/03/02 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+switch length(varargin) 
+    case 0
+        fh = plotPropertyUncertainty(properties);
+    case 1
+        fh = plotPropertyUncertainty(properties, varargin{1});
+    case 2
+        fh = plotPropertyUncertainty(properties, varargin{1}, varargin{2});
+    case 3
+        fh = plotPropertyUncertainty(properties, varargin{1}, varargin{2}, varargin{3});
+    case 4
+        fh = plotPropertyUncertainty(properties, varargin{1}, varargin{2}, varargin{3}, varargin{4});
+    otherwise
+        error('Too many arguments for plotPropertyProfiles().');
+end
+end
diff --git a/Requirements/PESTO-1.1.0/plotPropertySamples.m b/Requirements/PESTO-1.1.0/plotPropertySamples.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3447bf3ef8da1f607ac3eb8701df98bec0ada31
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotPropertySamples.m
@@ -0,0 +1,45 @@
+function fh = plotPropertySamples(properties, varargin)
+% plotPropertySamples.m visualizes samples of model properties.
+% Note: This routine provides an interface for plotPropertyUncertainty.m.
+%
+% USAGE:
+% fh = plotPropertySamples(properties)
+% fh = plotPropertySamples(properties,type)
+% fh = plotPropertySamples(properties,type,fh)
+% fh = plotPropertySamples(properties,type,fh,I)
+% fh = plotPropertySamples(properties,type,fh,I,options)
+%
+% Parameters:
+% varargin:
+% properties: property struct containing information about properties
+%       and results of optimization (.MS) and uncertainty analysis
+%       (.P and .S).
+% type: string indicating the type of visualization: '1D' or '2D'
+% fh: handle of figure. If no figure handle is provided, a new figure
+%       is opened.
+% I: index of properties which are updated. If no index is provided
+%       all properties are updated.
+% options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+% fh: figure handle
+%
+% History:
+% * 2015/04/01 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+switch length(varargin) 
+    case 0
+        fh = plotPropertyUncertainty(properties);
+    case 1
+        fh = plotPropertyUncertainty(properties, varargin{1});
+    case 2
+        fh = plotPropertyUncertainty(properties, varargin{1}, varargin{2});
+    case 3
+        fh = plotPropertyUncertainty(properties, varargin{1}, varargin{2}, varargin{3});
+    case 4
+        fh = plotPropertyUncertainty(properties, varargin{1}, varargin{2}, varargin{3}, varargin{4});
+    otherwise
+        error('Too many arguments for plotPropertySamples().');
+end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/plotPropertyUncertainty.m b/Requirements/PESTO-1.1.0/plotPropertyUncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..9e5b108a8f15f3195efac13f5b23913415ae334b
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/plotPropertyUncertainty.m
@@ -0,0 +1,633 @@
+function fh = plotPropertyUncertainty(properties, varargin)
+% plotPropertyUncertainty.m visualizes profile likelihood and MCMC samples
+% stored in properties.
+%
+% USAGE:
+% fh = plotPropertyUncertainty(properties,type)
+% fh = plotPropertyUncertainty(properties,type,fh)
+% fh = plotPropertyUncertainty(properties,type,fh,I)
+% fh = plotPropertyUncertainty(properties,type,fh,I,options)
+%
+% Parameters:
+%   properties: properties struct.
+%   varargin:
+%     type: string indicating the type of visualization: '1D'
+%     fh: handle of figure. If no figure handle is provided, a new figure
+%         is opened.
+%     I: index of properties which are updated. If no index is provided
+%         all parameters are updated.
+%     options: options of plotting as instance of PestoPlottingOptions
+%
+% Return values:
+%   fh: figure handle
+%
+% History:
+% * 2012/05/31 Jan Hasenauer
+% * 2014/06/20 Jan Hasenauer
+% * 2016/10/10 Daniel Weindl
+
+%% Check and assign inputs
+% Plot type
+type = '1D';
+if length(varargin) >= 1 && ~isempty(varargin{1})
+    type = varargin{1};
+    if ~max(strcmp({'1D','2D'},type))
+        error('The ''type'' of plot is unknown.')
+    end
+end
+
+% Check, if properties has all necessary fieds
+properties = checkSanityOfStructs(properties, 'properties');
+
+% Open figure
+if length(varargin) >= 2 && ~isempty(varargin{2})
+    fh = figure(varargin{2});
+else
+    fh = figure('Name','plotPropertyUncertainty');
+end
+
+% Index of subplot which is updated
+I = 1:properties.number;
+if length(varargin) >= 3 && ~isempty(varargin{3})
+    I = varargin{3};
+    if ~isnumeric(I) || max(abs(I - round(I)) > 0)
+        error('I is not an integer vector.');
+    end
+end
+
+% Options
+defaultOptions = PestoPlottingOptions();
+if isfield(properties,'S')
+    if isfield(properties.S,'PT');
+        defaultOptions.S.PT.plot_type = defaultOptions.S.plot_type;
+        defaultOptions.S.PT.ind = 1:size(properties.S.PT.prop,3);
+        defaultOptions.S.PT.col = [linspace(0,1,size(properties.S.PT.prop,3))',...
+                            0.2*ones(size(properties.S.PT.prop,3),1),...
+                            linspace(1,0,size(properties.S.PT.prop,3))'];
+    end
+end
+
+if ~isfield(properties,'MS')
+    defaultOptions.MS.plot_type = 0; 
+end
+
+% Assignment of user-provided options
+if length(varargin) >= 4
+    options = handlePlottingOptionArgument(varargin{4});
+    options = setdefault(options, defaultOptions);
+else
+    options = defaultOptions;
+end
+if ~isfield(properties,'P')
+    options.P.plot_type = 0; 
+end
+
+if ~isfield(properties,'S')
+    options.S.plot_type = 0; 
+end
+
+
+% Subplot arrangement
+if ~isfield(options,'subplot_size_1D')
+    options.subplot_size_1D = round(sqrt(length(I))*[1,1]);
+    if prod(options.subplot_size_1D) < length(I)
+        options.subplot_size_1D(2) = options.subplot_size_1D(2) + 1;
+    end
+end
+if ~isfield(options,'subplot_indexing_1D')
+    options.subplot_indexing_1D = 1:length(I);
+end
+
+%% INITALIZATION
+% Maximum a posterior estimate
+if isfield(properties,'MS')
+    logPost_max = max(properties.MS.logPost);
+end
+
+% Degrees of freedom (for chi^2 test)
+dof = 1;
+if max(strcmp(options.CL.type,'simultanous'))
+    dof = properties.number;
+end
+
+%% 1D Parameter distributions
+if strcmp(type,'1D')
+    
+% Compute number of subfigure
+s = round(sqrt(length(I))*[1,1]);
+if prod(s) < length(I)
+    s(2) = s(2) + 1;
+end
+
+% Loop: Parameter
+for l = 1:length(I)
+    % Initialization of legend
+    legh = [];
+    legs = {};
+
+    % Assign parameter index
+    i = I(l);
+    
+    % Open subplot
+    subplot(options.subplot_size_1D(1),options.subplot_size_1D(2),options.subplot_indexing_1D(l));
+        
+    % Hold on/off
+    if options.hold_on
+        hold on;
+    else
+        hold off;
+    end
+    
+    % Boundaries
+    switch options.interval
+        case 'dynamic'
+            xl = [+inf,-inf];
+            
+            if isfield(properties,'MS')
+                if max(strcmp(options.CL.type,'point-wise'))
+                    L = find(properties.MS.logPost(:) > (properties.MS.logPost(1)-chi2inv(options.CL.alpha,1)/2));
+                end
+                if max(strcmp(options.CL.type,'simultanous'))
+                    L = find(properties.MS.logPost(:) > (properties.MS.logPost(1)-chi2inv(options.CL.alpha,properties.numbe)/2));
+                end
+                xl(1) = min(xl(1),min(properties.MS.prop(i,L)));
+                xl(2) = max(xl(2),max(properties.MS.prop(i,L)));
+            end
+            
+            flag_plot_P = 0;
+            if options.P.plot_type >= 1
+                if length(properties.P) >= i
+                    if ~isempty(properties.P(i).par)
+                        xl(1) = min(xl(1),min(properties.P(i).prop));
+                        xl(2) = max(xl(2),max(properties.P(i).prop));
+                        flag_plot_P = 1;
+                    end
+                end
+            end
+
+            if options.S.plot_type >= 1
+                xl(1) = min(xl(1),min(properties.S.prop(i,:)));
+                xl(2) = max(xl(2),max(properties.S.prop(i,:)));
+            end
+            
+            if xl(1) == xl(2)
+                xl(1) = xl(1) - 1e-10;
+                xl(2) = xl(2) + 1e-10;
+            end
+        case 'static'
+            if isfield(options,bounds)
+                xl = [options.bounds.min(i),options.bounds.max(i)];
+            else
+                xl = [properties.min(i),properties.max(i)];
+            end
+    end
+
+    % Plot: Visualizaion of MCMC samples of posterior distribution
+    h = [];
+    switch options.S.plot_type
+        case 0
+            % no plot
+        case 1
+            % histogram
+            S = properties.S.prop(i,~isnan(properties.S.prop(i,:)));
+            switch options.S.bins
+                case 'optimal'
+                    b = 3.49*std(S)/(length(S)^(1/3));
+                    nbin = round((max(S)-min(S))/b);
+                case 'conservative'
+                    b = 2*3.49*std(S)/(length(S)^(1/3));
+                    nbin = round((max(S)-min(S))/b);
+                otherwise
+                    nbin = options.S.bins;
+            end
+            [N,X] = hist(S,nbin);
+            h = bar(X,N/max(N),1,'facecolor',options.S.hist_col); hold on;
+        case 2
+            % kernel-density estimate
+            x_grid = linspace(min(properties.S.prop(i,:)),max(properties.S.prop(i,:)),100);
+            [KDest] = getKernelDensityEstimate(squeeze(properties.S.prop(i,:)),x_grid);
+            h = plot(x_grid,KDest/max(KDest),'-','color',options.S.lin_col,'linewidth',options.S.lin_lw); hold on;
+        otherwise
+            error('Selected value for ''options.S.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.S.name;
+    end
+
+    % Plot: Local approximation
+    h = [];
+    switch options.A.plot_type
+        case 0
+            % no plot
+        case 1
+            % likelihood ratio
+            if isfield(properties.MS,'prop_Sigma')
+                % Get grid
+                prop_grid = properties.MS.prop(i,1) + sqrt(properties.MS.prop_Sigma(i,i,1))*linspace(-5,5,100);
+                prop_grid = prop_grid(find((properties.min(i) <= prop_grid).*(prop_grid <= properties.max(i))));
+                % Plot
+                h = plot(prop_grid,exp(-0.5*((prop_grid-properties.MS.prop(i,1)).^2/properties.MS.prop_Sigma(i,i,1))),'-','linewidth',options.A.lw,'color',options.A.col); hold on;
+            else
+                warning('No hessian provided in .MS. Approximation in not plotted.');
+            end
+        case 2
+            % negative log-likelihood
+            if isfield(properties.MS,'prop_Sigma')
+                % Get grid
+                prop_grid = properties.MS.prop(i,1) + sqrt(properties.MS.prop_Sigma(i,i,1))*linspace(-5,5,100);
+                prop_grid = prop_grid(find((properties.min(i) <= prop_grid).*(prop_grid <= properties.max(i))));
+                % Plot
+                h = plot(prop_grid,-logPost_max+0.5*((prop_grid-properties.MS.prop(i,1)).^2/properties.MS.prop_Sigma(i,i,1)),'-','linewidth',options.A.lw,'color',options.A.col); hold on;
+            else
+                warning('No hessian provided in .MS. Approximation in not plotted.');
+            end
+        otherwise
+            error('Selected value for ''options.A.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.A.name;
+    end
+
+    % Plot: Profile likelihood
+    h = [];
+    switch options.P.plot_type * flag_plot_P
+        case 0
+            % no plot
+        case 1
+            % likelihood ratio
+            h = plot(properties.P(i).prop,exp(properties.P(i).logPost - logPost_max),'-','linewidth',options.P.lw,'color',options.P.col); hold on;
+        case 2
+            % negative log-likelihood
+            h = plot(properties.P(i).prop,properties.P(i).logPost,'-','linewidth',options.P.lw,'color',options.P.col); hold on;
+        otherwise
+            error('Selected value for ''options.P.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.P.name;
+    end
+    
+    % Plot: Additional points
+    h = [];
+    if ~isempty(options.add_points) && ~isempty(options.add_points.par)
+        % Check dimension:
+        if size(options.add_points.prop,1) ~= properties.number
+            warning(['The matrix options.add_points.par should possess ' num2str(properties.number) ' rows.']);
+        else
+            for j = 1:size(options.add_points.prop,2)
+                if size(options.add_points.col,1) == size(options.add_points.prop,2)
+                    l = j;
+                else
+                    l = 1;
+                end
+                h = plot(options.add_points.prop(i,j)*[1,1],[0,1.05],options.add_points.ls,'color',options.add_points.col(l,:),'linewidth',options.add_points.lw);
+            end
+        end
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.add_points.name;
+    end
+        
+    % Plot: Local optima
+    h_conv = [];
+    h_nconv = [];
+    if options.MS.only_optimum
+        ind = 1;
+    else
+        ind = find(properties.MS.logPost >= properties.MS.logPost(1)-chi2inv(options.CL.alpha,dof)/2);
+    end
+    ind_conv = ind(find(min((properties.MS.exitflag(ind) > 0)+(properties.MS.exitflag(ind) == -3),1)));
+    ind_nconv = setdiff(ind,ind_conv);
+    switch options.MS.plot_type
+        case 0
+            % no plot
+        case 1
+            % likelihood ratio
+            h_conv = plot(properties.MS.prop(i,ind_conv),exp(properties.MS.logPost(ind_conv)-logPost_max),'o','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+            h_nconv = plot(properties.MS.prop(i,ind_nconv),exp(properties.MS.logPost(ind_nconv)-logPost_max),'s','linewidth',options.MS.lw,'color',options.MS.col);
+        case 2
+            % negative log-likelihood
+            h_conv = plot(properties.MS.prop(i,ind_conv),properties.MS.logPost(ind_conv),'o','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+            h_nconv = plot(properties.MS.prop(i,ind_nconv),properties.MS.logPost(ind_nconv),'s','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+        otherwise
+            error('Selected value for ''options.MS.plot_type'' is not available.');
+    end
+    if ~isempty(h_conv)
+        legh(end+1) = h_conv;
+        legs{end+1} = options.MS.name_conv;
+    end
+    if ~isempty(h_nconv)
+        legh(end+1) = h_nconv;
+        legs{end+1} = options.MS.name_nconv;
+    end
+        
+    % Limits
+%     % x
+%     if strcmp(options.interval,'static')
+%         xl = [properties.min(i),properties.max(i)];
+%     end
+%     xlim(xl);
+
+    % y
+    switch options.P.plot_type
+        case {0,1}
+            % likelihood ratio
+            ylim([0,1.1]);
+        case 2
+            % Best choice not clear => automatic assignment
+    end
+    
+    % Plot: Confidence levels
+    h = [];
+    switch options.CL.plot_type
+        case 0
+            % no plot
+        case 1
+            % likelihood ratio
+            if max(strcmp(options.CL.type,'point-wise'))
+                plot(xl,[1,1]*exp(-chi2inv(options.CL.alpha,1)/2),'--','color',options.CL.col);
+            end
+            if max(strcmp(options.CL.type,'simultanous'))
+                plot(xl,[1,1]*exp(-chi2inv(options.CL.alpha,properties.number)/2),':','linewidth',options.CL.lw,'color',options.CL.col);
+            end
+        case 2
+            % negative log-likelihood
+            if max(strcmp(options.CL.type,'point-wise'))
+                h = plot(xl,[1,1]*(properties.MS.logPost(1)-chi2inv(options.CL.alpha,1)/2),'--','linewidth',options.CL.lw,'color',options.CL.col);
+            end
+            if max(strcmp(options.CL.type,'simultanous'))
+                h = plot(xl,[1,1]*(properties.MS.logPost(1)-chi2inv(options.CL.alpha,properties.number)/2),':','linewidth',options.CL.lw,'color',options.CL.col);
+            end
+        otherwise
+            error('Selected value for ''options.CL.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.CL.name;
+    end
+    
+    % Labels
+    xlabel(properties.name(i));
+    if (mod(options.subplot_indexing_1D(l),options.subplot_size_1D(2)) == 1) || (length(I) == 1) || options.labels.y_always
+        if isempty(options.labels.y_name)
+            switch options.CL.plot_type
+                case 0
+                    % no plot
+                    ylabel('post. prob., p');
+                case 1
+                    % likelihood ratio
+                    ylabel('ratio, R');
+                case 2
+                    % negative log-likelihood
+                    ylabel('log-profile, log(PL)');
+            end
+        else
+            ylabel(options.labels.y_name);
+        end
+    else
+        set(gca,'Ytick',[]);
+    end
+    set(gca,'fontsize',options.fontsize.tick);
+    
+    % Legend
+    if l == 1
+        if isempty(options.legend.position)
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation);
+        else
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation,'position',options.legend.position);
+        end
+    end
+end
+
+end
+
+
+%% 2D Parameter distributions
+if strcmp(type,'2D')
+    
+% Loop: Parameter
+for l1 = 1:length(I)
+for l2 = 1:length(I)
+    % Initialization of legend
+    legh = [];
+    legs = {};
+
+    % Assign parameter index
+    i1 = I(l1);
+    i2 = I(l2);
+    
+    % Open subplot
+%    subplot(length(I),length(I),(i2-1)*length(I)+i1);
+    d = (1-options.op2D.b1-options.op2D.b2)/length(I);
+    subplot('Position',[options.op2D.b1+(l1-1)*d,...
+                        options.op2D.b1+(length(I)-l2)*d,...
+                        options.op2D.r*d,options.op2D.r*d]);
+    
+    if options.hold_on
+        hold on;
+    else
+        hold off;
+    end
+    
+    % Boundaries
+    switch options.interval
+        case 'dynamic'
+            xl1 = [+inf,-inf];
+            xl2 = [+inf,-inf];
+            
+            if options.P.plot_type >= 1
+                flag_plot_P_i1 = 0;
+                if length(properties.P) >= i1
+                    if ~isempty(properties.P(i1).prop)
+                        xl1(1) = min(xl1(1),min(properties.P(i1).prop(:)));
+                        xl1(2) = max(xl1(2),max(properties.P(i1).prop(:)));
+                        flag_plot_P_i1 = 1;
+                    end
+                end
+                flag_plot_P_i2 = 0;
+                if length(properties.P) >= i2
+                    if ~isempty(properties.P(i2).prop)
+                        xl2(1) = min(xl2(1),min(properties.P(i2).prop(:)));
+                        xl2(2) = max(xl2(2),max(properties.P(i2).prop(:)));
+                        flag_plot_P_i2 = 1;
+                    end
+                end
+            end
+
+            if options.S.plot_type >= 1
+                xl1(1) = min(xl1(1),min(properties.S.prop(i1,:)));
+                xl1(2) = max(xl1(2),max(properties.S.prop(i1,:)));
+                xl2(1) = min(xl2(1),min(properties.S.prop(i2,:)));
+                xl2(2) = max(xl2(2),max(properties.S.prop(i2,:)));
+            end
+
+        case 'static'
+            if isfield(options,bounds)
+                xl1 = [options.bounds.min(i1),options.bounds.max(i1)];
+                xl2 = [options.bounds.min(i2),options.bounds.max(i2)];
+            else
+                xl1 = [properties.min(i1),properties.max(i1)];
+                xl2 = [properties.min(i2),properties.max(i2)];
+            end
+    end
+
+    % Plot: MCMC samples
+    h = [];
+    switch options.S.plot_type
+        case 0
+            % no plot
+        case 1
+            % scatter plot
+            h = plot(properties.S.prop(i1,:),properties.S.prop(i2,:),options.S.sp_m,...
+                'color',options.S.sp_col,'markersize',options.S.sp_ms); hold on;
+        otherwise
+            error('Selected value for ''options.S.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.S.name;
+    end
+
+    % Plot: Local approximation
+    h = [];
+    switch options.A.plot_type
+        case 0
+            % no plot
+        case {1,2}
+            if isfield(properties.MS,'prop_Sigma')
+                % plot
+                X = getEllipse(properties.MS.prop([i1,i2],1),properties.MS.prop_Sigma([i1,i2],[i1,i2],1),options.A.sigma_level);
+                h = plot(X(1,:),X(2,:),'-','linewidth',options.A.lw/1.5,'color',options.A.col); hold on;
+            else
+                warning('No covariance matrix provided in properties.MS. Approximation in not plotted.');
+            end
+        otherwise
+            error('Selected value for ''options.A.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.A.name;
+    end
+
+    % Plot: Local optima
+    h_conv = [];
+    h_nconv = [];
+    ind = find(properties.MS.logPost >= properties.MS.logPost(1)-chi2inv(options.CL.alpha,dof)/2);
+    ind_conv = ind(find(min((properties.MS.exitflag(ind) > 0)+(properties.MS.exitflag(ind) == -3),1)));
+    ind_nconv = setdiff(ind,ind_conv);
+    switch options.P.plot_type
+        case 0
+            % no plot
+        case {1,2}
+            h_conv = plot(properties.MS.prop(i1,ind_conv),properties.MS.prop(i2,ind_conv),'o','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+            h_nconv = plot(properties.MS.prop(i1,ind_nconv),properties.MS.prop(i2,ind_nconv),'s','linewidth',options.MS.lw,'color',options.MS.col); hold on;
+        otherwise
+            error('Selected value for ''options.MS.plot_type'' is not available.');
+    end
+    if ~isempty(h_conv)
+        legh(end+1) = h_conv;
+        legs{end+1} = options.MS.name_conv;
+    end
+    if ~isempty(h_nconv)
+        legh(end+1) = h_nconv;
+        legs{end+1} = options.MS.name_nconv;
+    end
+
+    % Plot: Profile likelihood
+    h = [];
+    switch options.P.plot_type
+        case 0
+            % no plot
+        case {1,2}
+            % Calculation and visualization of property i2 along profile for property i1
+            if flag_plot_P_i1
+                P_prop = ones(length(properties.P(i1).prop),1);
+                for k = 1:length(properties.P(i1).prop)
+                    P_prop(k) = properties.function{i2}(properties.P(i1).par(:,k));
+                end
+                h = plot(properties.P(i1).prop,P_prop,'-','linewidth',options.P.lw,'color',options.P.col*0.8); hold on;
+            end
+                
+            % Calculation and visualization of property i1 along profile for property i2
+            if flag_plot_P_i2
+                P_prop = ones(length(properties.P(i2).prop),1);
+                for k = 1:length(properties.P(i2).prop)
+                    P_prop(k) = properties.function{i1}(properties.P(i2).par(:,k));
+                end
+                h = plot(P_prop,properties.P(i2).prop,'-','linewidth',options.P.lw,'color',options.P.col*0.6); hold on;
+            end
+            
+        otherwise
+            error('Selected value for ''options.P.plot_type'' is not available.');
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.P.name;
+    end
+    
+    % Plot: Additional points
+    h = [];
+    if ~isempty(options.add_points.par)
+        % Check dimension:
+        if size(options.add_points.par,1) ~= properties.number
+            warning(['The matrix options.add_points.par should possess ' num2str(properties.number) ' rows.']);
+        else
+            for j = 1:size(options.add_points.par,2)
+                if size(options.add_points.col,1) == size(options.add_points.par,2)
+                    l = j;
+                else
+                    l = 1;
+                end
+                h = plot(options.add_points.par(i1,j),options.add_points.par(i2,j),options.add_points.m,...
+                    'color',options.add_points.col(l,:),'linewidth',options.add_points.lw,'markersize',options.add_points.ms);
+            end
+        end
+    end
+    if ~isempty(h)
+        legh(end+1) = h;
+        legs{end+1} = options.add_points.name;
+    end
+        
+    % Limits
+    if ~isinf(xl1(1))
+        xlim(xl1);
+    end
+    if ~isinf(xl2(1))
+        ylim(xl2);
+    end
+
+    % Labels
+    if l2 == length(I)
+        xlabel(properties.name(i1));
+    else
+        set(gca,'xticklabel',[]);
+    end
+    if i1 == 1
+        ylabel(properties.name(i2));
+    else
+        set(gca,'yticklabel',[]);
+    end
+    set(gca,'fontsize',options.fontsize.tick);
+    
+    % Legend
+    if (l1 == 1) && (l2 == 1)
+        if isempty(options.legend.position)
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation);
+        else
+            legend(legh,legs,'color',options.legend.color,'box',options.legend.box,'orientation',options.legend.orientation,'position',options.legend.position);
+        end
+    end
+
+end
+end
+
+end
+
+
+%% Update plot
+drawnow;
+
+
diff --git a/Requirements/PESTO-1.1.0/private/HessianWrap.m b/Requirements/PESTO-1.1.0/private/HessianWrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..7e15b4781bfba160ad6077470bf4c597bba5a13b
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/HessianWrap.m
@@ -0,0 +1,16 @@
+%% Hessian function for optimization
+function Hessian = HessianWrap(negLogPost, varargin)
+% This function is a dummy for the Hessian function from fmincon
+    
+    if (nargin == 0)
+        error('No parameter vector provided the Hessian function!');
+    else
+        theta = varargin{1}{1};
+    end
+    
+    [llh, ~, Hessian] = negLogPost(theta);
+    
+    if ~isfinite(llh)
+        Hessian = inf(size(Hessian));
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/PTEESwapProbability.m b/Requirements/PESTO-1.1.0/private/PTEESwapProbability.m
new file mode 100644
index 0000000000000000000000000000000000000000..ec263546655f4c6e195562dc7422af22899d7cae
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/PTEESwapProbability.m
@@ -0,0 +1,9 @@
+function p = PTEESwapProbability(logP)
+  p = zeros(length(logP));
+  for k1 = 2:length(logP)
+      for k2 = 1:k1-1
+          p(k2,k1) = exp(-abs(logP(k1)-logP(k2)));
+      end
+  end
+  p = p/sum(p(:));
+end  
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/barrierFunction.m b/Requirements/PESTO-1.1.0/private/barrierFunction.m
new file mode 100644
index 0000000000000000000000000000000000000000..c69bb51ecd0d008725775df9192fa365154c8b3e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/barrierFunction.m
@@ -0,0 +1,117 @@
+function varargout = barrierFunction(objective, gradient, theta, bounds, iteration, maxIter, method)
+%% Documentation of barrierFunction
+% barrierFunction() applies barrier or penalty funcions (logarithmic or
+% polynomial) to a given objective function value and its gradient. It is
+% supposed to enforce parameter bounds for optimizers, which do not respect
+% parameter bounds by themselves.
+
+% USAGE:
+% * [...] = barrierFunction(objective, gradient, theta, borders, iteration, maxIter, method)
+% * [llh] = barrierFunction()
+% * [llh, sllh] = barrierFunction()
+%
+% Parameters:
+%   objective: numeric value of objective function
+%   gradient: numeric values (vector) of objective function gradient
+%   theta: parameter vector
+%   bounds: matrix, size = [length(theta), 2] with lower (1st column) and 
+%       upper (2nd column) bounds
+%   iteration: iteration number of optimization
+%   maxIter: maximum iteration number of optimization
+%   method: type of barrier function: 'soft-barrier' or 'log-barrier'
+%
+% Return values:
+%   llh: log-likelihood value with additional barrier value
+%   sllh: gradient values with additional barrier gradient
+
+
+%% Main Routine
+    
+    if isempty(gradient)
+        gradient = zeros(size(theta));
+    end
+    
+    % The input is passed to the different algorithms
+    switch(method)
+        case 'soft-barrier'
+            [objective, gradient] = softBarrier(objective, gradient, theta, bounds);
+            
+        case 'log-barrier'
+            [objective, gradient] = logBarrier(objective, gradient, theta, bounds, iteration, maxIter);
+            
+        case 'log-adaptive'           
+            [objective, gradient] = logAdaptiveBarrier(objective, gradient, theta, bounds, iteration, maxIter);
+ 
+        otherwise
+            error('Call to a non-existing update method');
+    end
+    
+    switch nargout
+        case 1
+            varargout = {objective};
+        case 2
+            varargout = {objective, gradient};
+        case 3
+            varargout = {objective, gradient, []};
+    end
+end
+
+
+
+function [objective, gradient] = softBarrier(objective, gradient, theta, bounds)
+% Very simple barrier function, applies a polynomial of third order to
+% those parameters which are outside the borders. Since the input is only
+% changed if parameter bounds are violated, it is actually a penalty
+% function.
+%
+% IMPORTANT: The routines assumes the objective function to be a NEGATIVE
+% log-posterior, i.e. it is made for minimizing.
+
+    scale = 100;
+    
+    for iPar = 1 : size(bounds, 1)
+        % Lower bounds
+        if (theta(iPar) < bounds(iPar, 1))
+            objective = objective + ...
+                scale * (bounds(iPar, 1) - theta(iPar))^3;
+            gradient(iPar) = gradient(iPar) + ...
+                3 * scale * (bounds(iPar, 1) - theta(iPar))^2;
+                
+        % Upper bounds
+        elseif (theta(iPar) > bounds(iPar, 2))
+            objective = objective + ...
+                scale * (theta(iPar) - bounds(iPar, 2))^3;
+            gradient(iPar) = gradient(iPar) - ...
+                3 * scale * (theta(iPar) - bounds(iPar, 2))^2;
+            
+        end
+    end
+
+end
+
+
+
+function [objective, gradient] = logBarrier(objective, gradient, theta, bounds, iteration, maxIter)
+% Simple log-barrier function, inspired from the interior-point algorithm. 
+% Applies a negative logarithm to the diffeernce of parameters
+% and the bounds. Since it is active also in the interior of the box, this
+% is a classical barrier function.
+%
+% IMPORTANT: The routines assumes the objective function to be a NEGATIVE
+% log-posterior, i.e. it is made for minimizing.
+
+    % Scaling for barrier, which takes iteration into account
+    scale = 8*(iteration/maxIter) + 2;
+    scale = 10^scale;
+    
+    % Parabola, which determines the barrier
+    parabola = - (theta - bounds(:,1)) .* (theta - bounds(:,2));
+    parabola = parabola ./ (0.5*(bounds(:,2) - bounds(:,1)).^2);
+    
+    % Setting the values
+    barrObjective = - sum(1/scale * log(parabola));
+    barrGradient = - 1/scale * (2*theta - theta.*(bounds(:,1)+bounds(:,2))) ./ ((theta - bounds(:,1)) .* (theta - bounds(:,2)));
+    
+    objective = objective + barrObjective;
+    gradient  = gradient  + barrGradient;
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/checkSanityOfStructs.m b/Requirements/PESTO-1.1.0/private/checkSanityOfStructs.m
new file mode 100644
index 0000000000000000000000000000000000000000..f487921427086a1437944a54ee2652437a6d2888
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/checkSanityOfStructs.m
@@ -0,0 +1,64 @@
+function pStruct = checkSanityOfStructs(pStruct, type)
+% checkSanityOfStructs.m checks if the necessary fields of the parameters
+% or the properties struct are set. If necessary fields are missing but can
+% unambiguously, this will be done. Otherwise, an error will be displayed.
+%
+% USAGE:
+% pStruct = checkSanityOfStructs(pStruct, type)
+%
+% Parameters:
+%   pStruct: parameters or properties struct.
+%   type: string, either 'parameters' or 'properties'
+%
+% Return values:
+%   pSturct: struct containing informations about the parameters or the
+%       properties
+%
+% History:
+% * 2017/05/21 Paul Stapor
+
+
+
+    % See which struct should be checked
+    if ~(strcmp(type, 'parameters') || strcmp(type, 'properties'))
+        error('The given type of struct is invalid. Only parameters and properties and be checked by this function.');
+    else
+        if strcmp(type, 'parameters')
+            short_type = 'par';
+        else
+            short_type = 'prop';
+        end
+    end
+
+    % The least necessary information are lower and upper bounds for parameters
+    if ~isfield(pStruct, 'min')
+        error(['The struct ' type ' has no lower bounds provided.']);
+    end
+    if ~isfield(pStruct, 'max')
+        error(['The struct ' type ' has no upper bounds provided.']);
+    end
+
+    % Upper and lower bounds need to have the same length
+    if ~all(size(pStruct.min) == size(pStruct.max))
+        error(['The vectors for the lower and upper bounds of' type ' do not have the same size.']); 
+    end
+
+    % The number of pStruct needs to be set accordingly
+    if ~isfield(pStruct, 'number')
+        pStruct.number = length(pStruct.min);
+    else
+        if (length(pStruct.min) ~= pStruct.number)
+            warning(['The size of struct ' type ' was set incorrectly in ' type '.number. This was corrected.']);
+        end
+    end
+
+    % The names of the parameters have to be set correctly
+    if ~isfield(pStruct, 'name')
+        pStruct.name = arrayfun(@(x) [short_type num2str(x)], 1:pStruct.number, 'UniformOutput', false);
+    else
+        if (length(pStruct.name) ~= pStruct.number)
+            error(['The names for the struct ' type ' did not have the correct length. Either provide them with correct length or leave ' type '.name empty.']);
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/coordinateSearch.m b/Requirements/PESTO-1.1.0/private/coordinateSearch.m
new file mode 100644
index 0000000000000000000000000000000000000000..1bb4e09d44ed07236b95f28175f1ba5abed16696
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/coordinateSearch.m
@@ -0,0 +1,245 @@
+function [ x, fval, exitflag, output ] = coordinateSearch( fun, x0, lb, ub, options )
+% Performs a simple coordinate search with random update of search
+% directions after a failure in improving the current value.
+%
+% Input:
+% fun     : objective function to be minimized
+% x0      : initial guess for parameters
+% lb, ub  : bounds for parameters
+% options : struct with options for the algorithm:
+%   TolX              : tolerance of parameter
+%   TolFun            : tolerance of objective function, currently not used
+%   MaxFunEvals       : maximum number of evaluations of fun
+%   MaxIter           : maximum number of iterations
+%   OutputFcn         : for visual output after each iteration
+%   Delta             : initial step size (rel. to 1)
+%   ExpandFactor      : (default 3.5)
+%   ContractFactor    : (default 0.35)
+%   Barrier           : use barrier on bounds (default none)
+%
+% Output:
+% x   : best guess for parameters
+% fval: objective function at the solution, generally fval=fun(x)
+% exitflag: 
+%   1 : The function converged to a solution x
+%   0 : Number of iterations exceeded options.MaxIter or number of function 
+%       evaluations exceeded options.MaxFunEvals.
+%   -1: The algorithm was terminated inappropriately
+% output : struct with meta information:
+%   iterations  : number of iterations
+%   funcCount   : number of function evaluations
+%   algorithm   : name of the algorithm
+%   t_cpu       : cpu time
+%
+% History:
+% 2017/09/27 Yannik Schaelte
+
+    dim = length(x0);
+    
+    % have to stay below max values
+    jIter = 0;
+    funcCount = 0;
+    
+    [tolX,tolFun,maxIter,maxFunEvals,outputFcn,delta,expandFactor,contractFactor,barrier] = f_extractOptions(options,dim);
+    if (isa(outputFcn,'function_handle'))
+        visual = true;
+    else
+        visual = false;
+    end
+    
+    x0 = x0(:);
+    lb = lb(:);
+    ub = ub(:);  
+    normalize   = @(x) f_normalize(x,lb,ub);
+    denormalize = @(y) f_denormalize(y,lb,ub); 
+    y0      = normalize(x0);
+    tolY    = tolX / norm(ub-lb);
+    
+    % wrap function to consider boundaries
+    fun = @(y,jIter) f_wrap_fun(denormalize(y),fun,lb,ub,barrier,jIter,maxIter);
+    
+    % measure time
+    starttime = cputime;
+    
+    % iteratively improved variables
+    ybst = y0;
+    fbst = fun(y0,jIter);
+    funcCount = funcCount + 1;
+    
+    % search directions
+    step = [eye(dim), -eye(dim)];
+    
+    if (visual)
+        f_output(denormalize(ybst),fbst,jIter,'init',outputFcn); % create new figure and initialize
+        f_output(denormalize(ybst),fbst,jIter,'iter',outputFcn); % first iteration with start point and jIter = 0
+    end
+    
+    % update search directions if last iter was not successful
+    iterSuccessful = true;
+    % iterate cyclically over search directions to improve performance
+    jSpinner = 1;
+    jPrev    = 0;
+    
+    while ( delta > tolY && jIter <= maxIter && funcCount <= maxFunEvals )
+        
+        if (~iterSuccessful)
+            U = f_createRandomOrthogonalMatrix(dim);
+            step = [U,-U];
+        end
+    
+        iterSuccessful = false;
+        for j=1:2*dim
+            ycur = ybst + delta*step(:,jSpinner);
+            fcur = fun(ycur,jIter);
+            funcCount = funcCount + 1;
+            % simulate finite differences
+            if (fcur < fbst)
+                ybst = ycur;
+                fbst = fcur;
+                
+                % alternatively: expand always
+                if (jSpinner == jPrev), delta = expandFactor * delta; end
+                jPrev = jSpinner;
+                
+                iterSuccessful = true;
+                break;
+            end
+            
+            % update coordinate index
+            if jSpinner == 2*dim
+                jSpinner = 1;
+            else
+                jSpinner = jSpinner + 1;
+            end
+        end
+        
+        if (~iterSuccessful)
+            delta = contractFactor * delta;
+        end
+        
+        jIter = jIter + 1;
+        
+        % update output
+        if (visual)
+            f_output(denormalize(ybst),fbst,jIter,'iter',outputFcn); 
+        end
+    
+    end
+    
+    x    = denormalize(ybst);
+    fval = fbst;
+    
+    if ( delta <= tolY )
+        exitflag = 1;
+    else
+        % needed too long
+        exitflag = 0;
+    end
+    
+    output.funcCount    = funcCount;
+    output.iterations   = jIter;
+    output.algorithm    = 'Coordinate Search';
+    output.t_cpu        = cputime - starttime;
+    
+    % finalize output
+    if (visual)
+        f_output(x,fbst,jIter,'done',outputFcn); 
+    end
+
+end
+
+function y = f_normalize(x,lb,ub)
+    y = (x-lb)./abs(ub-lb);
+end
+
+function x = f_denormalize(y,lb,ub)
+    x = y.*(ub-lb) + lb;
+end
+
+function [tolX,tolFun,maxIter,maxFunEvals,outputFcn,delta,expandFactor,contractFactor,barrier] = f_extractOptions(options,dim)
+% interpret options
+
+    if (isfield(options,'TolX'))
+        tolX    = options.TolX;
+    else
+        tolX    = 1e-6;
+    end
+    
+    if (isfield(options,'TolFun'))
+        tolFun  = options.TolFun;
+    else
+        tolFun  = 1e-6;
+    end
+    
+    if (isfield(options,'MaxIter'))
+        maxIter = options.MaxIter;
+    else
+        maxIter = 200*dim;
+    end
+    
+    if (isfield(options,'MaxFunEvals'))
+        maxFunEvals = options.MaxFunEvals;
+    else
+        maxFunEvals = 400*dim;
+    end
+    
+    if (isfield(options,'OutputFcn'))
+        outputFcn = options.OutputFcn;
+    else
+        outputFcn = nan;
+    end
+    
+    if (isfield(options,'Delta'))
+        delta          = options.Delta; % mesh size
+    else
+        delta          = 0.05;
+    end
+    
+    if (isfield(options,'ExpandFactor'))
+        expandFactor   = options.ExpandFactor;
+    else
+        expandFactor   = 3.5;
+    end
+    
+    if (isfield(options,'ContractFactor'))
+        contractFactor = options.ContractFactor;
+    else
+        contractFactor = 0.35;
+    end
+    
+    if (isfield(options,'Barrier'))
+        barrier        = options.Barrier;
+    else
+        barrier        = '';
+    end
+    
+end
+
+function fval = f_wrap_fun(x,fun,lb,ub,barrier,jIter,maxIter)
+% set fun to inf whenever conditions not fulfilled
+    if (~isequal(barrier,''))
+        fval = fun(x);
+        fval = barrierFunction(fval, [], x, [lb, ub], jIter, maxIter, barrier);
+    else
+        if (any(x>ub) || any(x<lb))
+            fval = inf;
+        else
+            fval = fun(x);
+        end        
+    end
+end
+
+function U = f_createRandomOrthogonalMatrix(dim)
+    M = randn(dim,dim);
+    [Q,R] = qr(M);
+    D = diag(R);
+    D = diag(D)./abs(D);
+    U = Q * D;
+end
+
+function f_output(x,fval,iter,state,outputFcn)
+% short for call to output function
+    optimValues.fval = fval;
+    optimValues.iteration = iter;
+    outputFcn(x,optimValues,state);
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/dynamicHillClimb.m b/Requirements/PESTO-1.1.0/private/dynamicHillClimb.m
new file mode 100644
index 0000000000000000000000000000000000000000..b94088741a583c134fd19ffb4e343fce84621b4f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/dynamicHillClimb.m
@@ -0,0 +1,409 @@
+function [x, fval, exitflag, output] = dynamicHillClimb(fun,x0,lb,ub,options)
+% An implementation with slight modifications of the "Dynamic Hill
+% Climbing" algorithm as described in [De La Maza and Yuret. Dynamic Hill
+% Climbing].
+%
+% Input:
+% fun     : objective function to be minimized
+% x0      : initial guess for parameters
+% lb, ub  : bounds for parameters, i.e. lb <= x <= ub; no value should be 
+%           inf and the difference ub-lb in no component be < 0
+% options : struct with options for the algorithm:
+%   TolX              : tolerance of parameter
+%   TolFun            : tolerance of objective function
+%   MaxFunEvals       : maximum number of evaluations of fun
+%   OutputFcn         : for visual output after each iteration
+%   InitialStepSize   : rel. to 1 (default 0.1)
+%   ExpandFactor      : factor of expansion upon success (default 2)
+%   ContractFactor    : factor of contraction upon failure (default 0.45)
+%   StuckSearchFactor : how far to expand again after got stuck (default 4)
+%   Barrier           : use barrier on bounds (default extreme barrier)
+%   Display           : off|iter|debug, text output (default off)
+%
+% Output:
+% x   : best guess for parameters
+% fval: objective function at the solution, generally fval=fun(x)
+% exitflag:
+%   1 : The function converged to a solution x
+%   0 : Number of function evaluations exceeded options.MaxFunEvals.
+%   -1: The algorithm was terminated inappropriately
+% output : struct with meta information:
+%   iterations  : number of iterations
+%   funcCount   : number of function evaluations
+%   algorithm   : name of the algorithm
+%   t_cpu       : cpu time
+%
+% History:
+% 2017/09/27 Yannik Schaelte
+
+% number of variables
+dim  = length(x0);
+
+% interpret options
+options  = f_validateOptions(options,dim);
+% extract often used options
+tolX                = options.TolX;
+tolFun              = options.TolFun;
+maxFunEvals         = options.MaxFunEvals;
+initialStepSize     = options.InitialStepSize;
+expandFactor        = options.ExpandFactor;
+contractFactor      = options.ContractFactor;
+stuckSearchFactor   = options.StuckSearchFactor;
+barrier             = options.Barrier;
+
+% create column vectors
+lb      = lb(:);
+ub      = ub(:);
+x0      = x0(:);
+
+% normalize to unit square
+normalize   = @(x) f_normalize(x,lb,ub);
+denormalize = @(y) f_denormalize(y,lb,ub);
+y0      = normalize(x0);
+tolY    = tolX / norm(ub-lb);
+
+% output function for in-time analysis
+outputFcn = @(y,fval,funEvals,mode) f_output(y,denormalize,fval,funEvals,mode,options.OutputFcn);
+
+% max step size
+vmax = initialStepSize * ones(dim,1);
+
+% wrap function to consider boundaries
+fun = @(y,funEvals) f_wrap_fun(denormalize(y),fun,lb,ub,barrier,funEvals,maxFunEvals);
+
+% init run variables
+smax   = [vmax;-1];        % array of max step sizes, extra value for extra vector
+[step,norms]   = f_init_step(vmax); % matrix of step vectors
+xstep  = step;             % steps before last motion
+xnorms = norms;
+gradv  = zeros(dim,1);     % gradient vector
+gradi  = -1;               % index of gradient vector, -1 indicates gradv is not set
+prevj  = -1;               % index of last step taken
+stuck  = false;            % is process stuck (in min/max)? set when step sizes are small
+% then step vectors are increased
+done   = false;            % is some finishing criterion fulfilled?
+
+nVec   = 2*dim + 2;            % maximum index in step matrix
+opp_j  = @(j) f_opp_j(j,nVec); % short for opposite index in step matrix
+
+% init meta variables
+exitflag  = -1;        % flag indicating exit reason
+starttime = cputime;   % to measure time difference
+funEvals  = 0;         % function evaluations, should be <= maxFunEvals
+
+% init x, fval
+ybst      = y0;
+fbst      = fun(ybst,funEvals);
+funEvals  = funEvals + 1;
+
+outputFcn(ybst,fbst,funEvals,'init'); % create new figure and initialize
+outputFcn(ybst,fbst,funEvals,'iter'); % first iteration with start point
+
+% main loop
+while ~done
+    
+    if stuck
+        % choose the smallest step, if any is smaller than the maximum size
+        [v,j] = f_min(step,norms,smax);
+    else
+        % choose the largest step
+        [v,j] = f_max(step,norms);
+    end
+    
+    % textual output
+    f_display(options.Display,funEvals,fbst,norm(v));
+    
+    % j == -1 indicates minimum found
+    if j ~= -1 && funEvals <= maxFunEvals
+        % compute next x, fval
+        ycur = ybst + v;
+        fcur = fun(ycur,funEvals);
+        funEvals = funEvals + 1;
+        
+        delta_f = fcur - fbst;
+        
+        % is better estimate?
+        if delta_f < 0
+            ybst = ycur;
+            fbst = fcur;
+        end
+        
+        % is significantly better estimate?
+        if delta_f < 0 && (norm(v)>tolX/stuckSearchFactor || abs(delta_f) > tolFun)
+            % we are not stuck somewhere (anymore)
+            stuck = false; 
+            % contract opp step to not try the previous point next
+            step(:,opp_j(j)) = -contractFactor*v;
+            norms(opp_j(j)) = norm(step(:,opp_j(j)));
+            % if last step repeated, expand the current step
+            if j == prevj
+                v = expandFactor*v;
+            end
+            % xstep always contains the steps of the last time we moved
+            xstep = step;
+            xnorms = norms;
+            % record the last step
+            prevj = j;
+            % record step
+            step(:,j) = v;
+            norms(j) = norm(v);
+            
+            % update gradient vector
+            if gradi == -1
+                % if gradv empty, set gradv to current step and record index
+                gradv = v;
+                gradi = min([j, opp_j(j)]);
+            elseif gradi == min([j, opp_j(j)])
+                % if gradv is parallel to current step, add the current vector
+                gradv = (gradv + v);
+            else
+                % else update the extra vector
+                step(:,dim+1) = gradv + v;
+                norms(dim+1) = norm(gradv + v);
+                % set extra entry in smax to max of current step smax and gradv smax
+                % (bound for norm of gradient)
+                smax(dim+1)   = max([smax(min([j,opp_j(j)])),smax(gradi)]);
+                % set the opp step to - extra step
+                step(:,dim+2) = -contractFactor*step(:,dim+1);
+                norms(dim+2) = abs(contractFactor)*norms(dim+1);
+                % update gradv
+                gradi =-1;%        = min([j, opp_j(j)]);
+            end
+        else % not significantly better estimate
+            if stuck
+                % if already stuck, increase the current step size
+                step(:,j) = expandFactor*v;
+                norms(j) = norm(step(:,j));
+            elseif norm(step(:,j)) >= tolY
+                % if current step norm >= tolY, decrease the current step size
+                step(:,j) = contractFactor*v;
+                norms(j) = norm(step(:,j));
+            else
+                % else (norm < tolY): set the stuck flag and set all steps to
+                % expandFactor times the last recorded steps
+                stuck = true;
+                step = expandFactor * xstep;
+                norms = abs(expandFactor)*xnorms;
+            end
+        end
+        
+        % update output
+        outputFcn(ybst,fbst,funEvals,'iter');
+        
+    else % somehow done
+        done = true;
+        if funEvals <= maxFunEvals
+            % maybe found a local minimum
+            exitflag = 1;
+        else
+            % needed too long
+            exitflag = 0;
+        end
+    end
+    
+end
+
+% finalize output
+outputFcn(ybst,fbst,funEvals,'done');
+
+% assign return values
+x                   = denormalize(ybst);
+fval                = fbst;
+output = struct();
+output.funcCount    = funEvals;
+output.iterations   = funEvals;
+output.algorithm    = 'Dynamic Hill Climb';
+output.t_cpu        = cputime - starttime;
+
+end % function
+
+
+%% helper functions
+
+function y = f_normalize(x,lb,ub)
+% normalize vector to [0,1]
+
+y = (x-lb)./abs(ub-lb);
+
+end
+
+function x = f_denormalize(y,lb,ub)
+% denormalize vector from [0,1]
+
+x = y.*(ub-lb) + lb;
+
+end
+
+function j_opp = f_opp_j(j,nVec)
+% short for opposite vector in step matrix
+
+j_opp = nVec - (j-1);
+
+end
+
+function fval = f_wrap_fun(x,fun,lb,ub,barrier,funEvals,maxFunEvals)
+% wrap around function to allow for a barrier function wrap
+
+% set fun to inf whenever conditions not fulfilled
+if ~isequal(barrier,'')
+    fval = fun(x);
+    fval = barrierFunction(fval, [], x, [lb, ub], funEvals, maxFunEvals, barrier);
+else
+    % extreme barrier
+    if any(x>ub) || any(x<lb)
+        fval = inf;
+    else
+        fval = fun(x);
+    end
+end
+
+end
+
+function [step,norms] = f_init_step(vmax)
+% create dim x (2*dim+2)-matrix containing the step proposals as columns
+% also return the norms of the steps to reduce computations
+
+dim  = length(vmax);
+
+nVec = 2*dim + 2;
+step = zeros(dim,nVec);
+norms = zeros(1,nVec);
+% 2 positions in the center reserved for gradient
+for j = 1:dim
+    initStepSize       = abs(vmax(j));
+    step(j,j)          = initStepSize;
+    step(j,nVec-(j-1)) = -initStepSize;
+    norms(j)           = initStepSize;
+    norms(nVec-(j-1))  = initStepSize;
+end
+
+end
+
+function [v_max,j_max] = f_max(step,norms)
+% find step with maximal norm
+
+[~,j_max] = max(norms);
+v_max = step(:,j_max);
+
+end
+
+function [v_min,j_min] = f_min(step,norms,smax)
+% find step with smallest norm, if one exists whose norm is smaller than
+% the corresponding smax max step size
+
+minnorm = -1;
+j_min   = -1; % -1 used as indicator in calling function
+v_min   = -1;
+nVec    = size(step,2);
+for j=1:nVec
+    vnorm = norms(j);
+    if ( vnorm <= smax(min([j, nVec-(j-1)])) && (vnorm < minnorm || minnorm < 0) && vnorm > 0) % tolerance % smax(min([j, nVec-(j-1)]))
+        minnorm = vnorm;
+        j_min = j;
+    end
+end
+
+if (j_min ~= -1)
+    v_min = step(:,j_min);
+end
+
+end
+
+function [ optionsDhc ] = f_validateOptions(options,dim)
+% fill empty or invalid fields with default values
+
+optionsDhc = struct();
+
+% interpret options
+
+if (isfield(options,'TolX') && ~isempty(options.TolX))
+    optionsDhc.TolX    = options.TolX;
+else
+    optionsDhc.TolX    = 1e-8;
+end
+
+if (isfield(options,'TolFun') && ~isempty(options.TolFun))
+    optionsDhc.TolFun  = options.TolFun;
+else
+    optionsDhc.TolFun  = 1e-8;
+end
+
+if (isfield(options,'MaxFunEvals') && ~isempty(options.MaxFunEvals))
+    optionsDhc.MaxFunEvals = options.MaxFunEvals;
+else
+    optionsDhc.MaxFunEvals = 1000*dim;
+end
+
+if (isfield(options,'OutputFcn') && ~isempty(options.OutputFcn))
+    optionsDhc.OutputFcn = options.OutputFcn;
+else
+    optionsDhc.OutputFcn = nan;
+end
+
+% adjustment parameters
+
+if (isfield(options,'InitialStepSize') && ~isempty(options.InitialStepSize))
+    optionsDhc.InitialStepSize           = options.InitialStepSize;
+else
+    optionsDhc.InitialStepSize           = 0.1;
+end
+
+if (isfield(options,'ExpandFactor') && ~isempty(options.ExpandFactor))
+    optionsDhc.ExpandFactor              = options.ExpandFactor;
+else
+    optionsDhc.ExpandFactor              = 2.1;
+end
+
+if (isfield(options,'ContractFactor') && ~isempty(options.ContractFactor))
+    optionsDhc.ContractFactor            = options.ContractFactor;
+else
+    optionsDhc.ContractFactor            = 0.47;
+end
+
+if (isfield(options,'StuckSearchFactor') && ~isempty(options.StuckSearchFactor))
+    optionsDhc.StuckSearchFactor         = options.StuckSearchFactor;
+else
+    optionsDhc.StuckSearchFactor         = 4;
+end
+
+if (isfield(options,'Barrier'))
+    optionsDhc.Barrier                   = options.Barrier;
+else
+    optionsDhc.Barrier                   = '';
+end
+
+if (isfield(options,'Display') && ~isempty(options.Display))
+    optionsDhc.Display                   = options.Display;
+else
+    optionsDhc.Display                   = 'off';
+end
+
+end
+
+function f_output(y,f_denormalize,fval,funEvals,state,outputFcn)
+% short for call to output function
+% state: 'init', 'iter', or 'done'
+
+if isa(outputFcn,'function_handle')
+    x = f_denormalize(y);
+    optimValues.fval = fval;
+    optimValues.iteration = funEvals;
+    outputFcn(x,optimValues,state);
+end
+
+end
+
+function f_display(display,funEvals,fbst,vnorm)
+% short for call to display on screen
+
+if (strcmp(display,'iter') || strcmp(display,'debug'))
+    if (strcmp(display,'debug'))
+        show_output = true;
+    else
+        show_output = mod(funEvals,100) == 0;
+    end
+    
+    if (show_output), fprintf(strcat('%d\t|\t%.15f\t|\t%.15f\n'),funEvals,fbst,vnorm); end
+end
+
+end
diff --git a/Requirements/PESTO-1.1.0/private/getBins.m b/Requirements/PESTO-1.1.0/private/getBins.m
new file mode 100644
index 0000000000000000000000000000000000000000..edb04ac74560b78c83ac9088498377160d6c29c2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getBins.m
@@ -0,0 +1,33 @@
+%getBins calcualtes the number of bins in a histogramm for the vector
+%values according to the option (optimal [default] or conservative)
+%
+% USAGE:
+% ======
+% nbin = getBins(values,option)
+%
+% INPUTS:
+% =======
+% values ... vector for which histogramm should be plotted.
+% option ... options for the number of bins (optimal [default] and
+% conservative)
+%
+% Outputs:
+% ========
+% nbins .. number of bins for histogram
+
+function [nbin] = getBins(values,option)
+
+switch option
+    case 'optimal'
+        h = 3.49*nanstd(values)/(length(values)^(1/3));
+        nbin = round((max(values)-min(values))/h);
+    case 'conservative'
+        h = 2*3.49*nanstd(values)/(length(values)^(1/3));
+        nbin = round((max(values)-min(values))/h);
+    otherwise %'optimal' and the rest [default]
+        h = 3.49*nanstd(values)/(length(values)^(1/3));
+        nbin = round((max(values)-min(values))/h);
+end
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/private/getConstraints.m b/Requirements/PESTO-1.1.0/private/getConstraints.m
new file mode 100644
index 0000000000000000000000000000000000000000..2a39a108fa039c8ff4d7e49fd322576d19fc86a7
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getConstraints.m
@@ -0,0 +1,32 @@
+%% Constraint generation
+% This function is used to generate the linear constraints for the
+% reduced system. 
+%   theta ... parameter vector
+%   parameter struct ...
+%   I ... index set of optimized parameters
+function [A,b,Aeq,beq] = getConstraints(theta,parameters,I)
+
+% Index set of parameters which are eliminated
+i = setdiff(1:parameters.number,I);
+
+% Reduction of constraints to remaining dimensions
+if ~isempty(parameters.constraints.A)
+    A = parameters.constraints.A(:,I);
+    if ~isempty(i)
+        b = parameters.constraints.b - parameters.constraints.A(:,i)*theta(i);
+    end
+else
+    A = [];
+    b = [];
+end
+if ~isempty(parameters.constraints.Aeq)
+    Aeq = parameters.constraints.Aeq(:,I);
+    if ~isempty(i)
+        beq = parameters.constraints.beq - parameters.constraints.Aeq(:,i)*theta(i);
+    end
+else
+    Aeq = [];
+    beq = [];
+end
+
+end
diff --git a/Requirements/PESTO-1.1.0/private/getEllipse.m b/Requirements/PESTO-1.1.0/private/getEllipse.m
new file mode 100644
index 0000000000000000000000000000000000000000..646bc00df47d46ea6cfd256e289613519feaf5a2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getEllipse.m
@@ -0,0 +1,24 @@
+function X = getEllipse(m,C,d)
+% TODO
+%
+% Parameters:
+% m:
+% C:
+% d:
+%
+% Return values:
+% X:
+phi = linspace(0,2*pi,100);
+
+[V,L] = eig(C);
+if max(diag(L)) < 1e-8
+    X = m;
+elseif min(diag(L)) > 1e-8
+    X = bsxfun(@plus,d*sqrtm(squeeze(C))*[cos(phi);sin(phi)],m(:));
+else
+    [~,i] = max(diag(L));
+%     V(:,i)*sqrt(L(i,i))
+%     (V(:,i)*sqrt(L(i,i)))*(V(:,i)*sqrt(L(i,i)))'
+%     C
+    X = [m(:)-d*sqrt(L(i,i))*V(:,i),m(:)+d*sqrt(L(i,i))*V(:,i)];
+end
diff --git a/Requirements/PESTO-1.1.0/private/getFiniteDifferences.m b/Requirements/PESTO-1.1.0/private/getFiniteDifferences.m
new file mode 100644
index 0000000000000000000000000000000000000000..150df176c040e83881613ce56678d62956fa6f5c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getFiniteDifferences.m
@@ -0,0 +1,146 @@
+function varargout = getFiniteDifferences(theta, objectiveFunction, mode)
+
+% This function computes the gradient and, if necessary, the Hessian of
+% the objective function by a finite difference scheme, if the
+% objective function itself does not provide this information.
+%
+% Parameters:
+%   theta: parameter vector
+%   objectiveFunction: the original objective function
+%   mode: double, specifying if grad, Hessian or both should be computed:
+%           1: gradient
+%           2: gradient and Hessian
+%           3: Hessian from gradient output of original obj. fun
+%
+% Return values (depend on mode):
+%   gradient: mode == 1
+%   [objective, gradient, Hessian]: mode == 2
+%   Hessian: mode == 3
+
+    persistent lastParameter;
+    persistent fdStepParameter;
+    persistent fdStepGradient;
+    
+    nPar = length(theta);
+    
+    switch mode
+        case 1
+        % Compute gradient from an objective function, which returns only
+        % one value
+        
+            % Compute new step size if necessary
+            if isempty(lastParameter)
+                fdStepParameter = getStepSizeFD(theta, objectiveFunction, 1);
+                lastParameter = theta;
+            elseif (sum((theta - lastParameter).^2) > 0.5 * sqrt(nPar))
+                fdStepParameter = getStepSizeFD(theta, objectiveFunction, 1);
+                lastParameter = theta;
+            end
+            
+            % Initialize gradient
+            G = zeros(nPar, 1);
+            
+            % Use FD scheme
+            for j = 1 : nPar
+                % Set the step
+                delta = zeros(nPar, 1);
+                delta(j) = fdStepParameter(j);
+                
+                % Gradient computation
+                Jplus = objectiveFunction(theta + delta);
+                Jminus = objectiveFunction(theta - delta);
+                G(j) = (Jplus - Jminus) / (2 * fdStepParameter(j));
+            end
+            
+            % Assign output
+            varargout{1} = G;
+            
+        case 2
+        % Compute objective value, gradient and Hessian from an objective 
+        % function, which returns only one value
+            
+            % Compute new step size if necessary
+            if isempty(lastParameter)
+                fdStepParameter = getStepSizeFD(theta, objectiveFunction, 1);
+                lastParameter = theta;
+            elseif (sum((theta - lastParameter).^2) > 0.5 * sqrt(nPar))
+                fdStepParameter = getStepSizeFD(theta, objectiveFunction, 1);
+                lastParameter = theta;
+            end
+            
+            % Initialize gradient
+            G = zeros(nPar, 1);
+            H = zeros(nPar, nPar);
+            
+            % Objective function at given parameter vector
+            J = objectiveFunction(theta);
+            
+            % Do FD
+            for j = 1 : nPar
+                % Set the step
+                delta = zeros(nPar, 1);
+                delta(j) = fdStepParameter(j);
+                
+                % Gradient and diagonal of the Hessian
+                Jplus = objectiveFunction(theta + delta);
+                Jminus = objectiveFunction(theta - delta);
+                G(j) = (Jplus - Jminus) / (2 * fdStepParameter(j));
+                H(j,j) = (Jplus + Jminus - 2*J) / (fdStepParameter(j)^2);
+                
+                % Rest of the Hessian
+                for k = 1 : j-1
+                    % Set steps
+                    delta1 = delta;
+                    delta2 = delta;
+                    delta1(k) = fdStepParameter(k);
+                    delta2(k) = -fdStepParameter(k);
+                    
+                    % Compute values
+                    Jpp = objectiveFunction(theta + delta1);
+                    Jpm = objectiveFunction(theta + delta2);
+                    Jmp = objectiveFunction(theta - delta2);
+                    Jmm = objectiveFunction(theta - delta1);
+                    H(j, k) = (Jpp - Jpm - Jmp + Jmm) ...
+                        / (4 * fdStepParameter(j) * fdStepParameter(k));
+                    H(k, j) = H(j, k);
+                end
+            end
+            
+            % Assign output
+            varargout{1} = J;
+            varargout{2} = G;
+            varargout{3} = H;
+            
+        case 3
+        % Compute Hessian from an objective function which only provides
+        % the gradient
+            
+            % Compute step size if necessary
+            if isempty(lastParameter)
+                fdStepGradient = getStepSizeFD(theta, objectiveFunction, 2);
+                lastParameter = theta;
+            elseif (sum((theta - lastParameter).^2) > 0.5 * sqrt(nPar))
+                fdStepGradient = getStepSizeFD(theta, objectiveFunction, 2);
+                lastParameter = theta;
+            end
+            
+            % Initialize gradient
+            H = zeros(nPar, nPar);
+            
+            % Use FD scheme
+            for j = 1 : nPar
+                % Set the step
+                delta = zeros(nPar, 1);
+                delta(j) = fdStepGradient(j);
+                
+                % Gradient computation
+                [~, Gplus] = objectiveFunction(theta + delta);
+                [~, Gminus] = objectiveFunction(theta - delta);
+                H(:,j) = (Gplus - Gminus) / (2 * fdStepGradient(j));
+            end
+            
+            % Assign output
+            varargout{1} = H;
+            
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/getKernelDensityEstimate.m b/Requirements/PESTO-1.1.0/private/getKernelDensityEstimate.m
new file mode 100644
index 0000000000000000000000000000000000000000..6bae5800791167a556a76e5e6f8ddb3e8c263e27
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getKernelDensityEstimate.m
@@ -0,0 +1,127 @@
+function [KDest,Sigma] = getKernelDensityEstimate(varargin)
+% kde_simple.m computes the kernel density estimate KDest at X given the sample P.
+% The bandwidth can be determined using different methods (see below).
+%
+% USAGE:
+% [KDest,Sigma] = kde_simple(P,X,Sigma,options)
+%
+% Parameters:
+% varargin:
+% P: D x N - matrix, where each column defines a member of the sample.
+% X: D x Ngrid - matrix, where each column defines a point
+%       at which the kernel density estimate is determined.
+% Sigma: kernel bandwidth. (If a kernel bandwidth is provided, it is
+%       used. Otherwise, the bandwidth is computed from the data.)
+% options: options for the algorithm<pre>
+%   .bw_selection ... bandwidth selction methods:
+%       = 'scott' ... Scott's rule
+%       = 'gen scott' (default) ... generalized Scott's rule
+%       = 'user' ... bandwidth is provided
+%   .kernel ... type of kernel:
+%       = 'normal' (default) ... multi-variate Gausian kernel
+%       = 'log-normal' ... multi-variate log-normal kernel</pre>
+%
+% Return values:
+% KDest: kernel density estimate at points defined by X.
+% Sigma: covariance matrix of Gaussian kernel detemined
+%           using the generalized Scott's rule.
+%
+% History:
+% * 07/10/2010 - Jan Hasenauer
+% * modified 14/01/2011 - Jan Hasenauer
+
+%% CHECK/ASSIGN INPUTS
+if nargin >= 2
+    P = varargin{1};
+    X = varargin{2};
+else
+    error('Not enough inputs!');
+end
+
+Sigma = [];
+if nargin >= 3
+    Sigma = varargin{3};
+end
+if ~isempty(Sigma)
+    if (size(Sigma,1) ~= size(Sigma,2)) || (size(Sigma,2) ~= size(P,1))
+        error('Dimension of data D and bandwidth Sigma does not agree.');
+    end
+end
+
+% Check options
+options.bw_selection = 'scott';
+options.kernel = 'normal';
+if nargin == 4
+    options = setdefault(varargin{4},options);
+end
+if ~isempty(Sigma)
+    options.bw_selection = 'user';
+end
+
+% Check dimension
+if size(P,1) ~= size(X,1)
+    error('Dimensionality of sample members and grid points must agree!');
+end
+
+%% INITIALIZATION
+% Assign dimensions
+D = size(P,1);
+N = size(P,2);
+Ngrid = size(X,2);
+% Adapt coordinates dependent on kernel shape
+% (We adapt the coordinates instead of the kernel
+%  shape to ensure computational efficiency.)
+switch options.kernel
+    case 'normal'
+        Xc = X;
+    case 'log-normal'
+        % Check positivity of grid and data points
+        if (multimin(P) <= 0) || (multimin(X) <= 0)
+            % error
+            error('Data or grid points contain negative values or zeros. => log-normal kernels can not be used.');
+        end
+        P = log(P);
+        Xc = log(X);
+        % I do not know how the generalize Scott's rule would look in this
+        % cases. This has to be checked in the future. Till then it is not
+        % allowed in combination with log-normal kernels.
+        options.bw_selection = 'scott';
+    otherwise
+        % error
+        error('This option is not available.');
+end
+% Compute kernal shape, bandwidth, and scaling constant
+if isempty(Sigma)
+    switch options.bw_selection
+        case 'scott'
+            Sigma = diag((var(P')) * N^(-2/(D+4)));
+        case 'gen scott';
+            Sigma = cov(P') * N^(-2/(D+4));
+        case 'user'
+            % Nothing has to be done.
+        otherwise
+            % error
+            error('This option is not available.');
+    end
+end
+% invSigma = inv(Sigma);
+c = 1/((2*pi)^(D/2)*sqrt(det(Sigma))) * 1/N;
+% Initialize KDest
+KDest = zeros(1,Ngrid);
+
+%% CALCULATION OF DENSITY
+for i = 1:N
+    % Updata of complete density
+    KDest = KDest + c*exp(-0.5*sum(bsxfun(@minus,Xc,P(:,i)).*(Sigma\bsxfun(@minus,Xc,P(:,i))),1));
+end
+
+
+% Adapt kde required for log-normal kernels
+switch options.kernel
+    case 'normal'
+        % Nothing has to be done!
+    case 'log-normal'
+        KDest = KDest./prod(X,1);
+end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/getNextProfilePoint.m b/Requirements/PESTO-1.1.0/private/getNextProfilePoint.m
new file mode 100644
index 0000000000000000000000000000000000000000..d7b02e644e3b4bcf70c7df0b5bbd74343df0a641
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getNextProfilePoint.m
@@ -0,0 +1,127 @@
+%% getNextProfilePoint is a support function for the profile calculation
+%   and is called by computeProfile. It determines the length of the 
+%   update step given update direction, parameter constraints,
+%   log-posterior and target log posterior.
+%
+% USAGE:
+% ======
+% function [theta_next,logPost] = getNextPoint(theta,theta_min,theta_max,dtheta,logPost_target,objective_function)
+%
+% INPUTS:
+% =======
+% theta ... starting parameter   
+% theta_min ... lower bound for parameters   
+% theta_max ... upper bound for parameters   
+% dtheta ... upper direction
+% logPost_target ... target value for log-posterior
+% objective_function ... log-posterior of model as function of the parameters.
+%
+% Outputs:
+% ========
+% theta_next ... parameter proposal
+% logPost ... log-posterior at proposed parameter
+%
+% 2012/07/12 Jan Hasenauer
+
+function [theta,J] = getNextProfilePoint(...
+    theta, theta_min, theta_max, dtheta, c, c_min, c_max, c_update, ...
+    J_target, objFun, constraints, update_mode, j, optimizer)
+
+    % Initialization
+    % 1) modification of dtheta
+    switch update_mode
+        case 'multi-dimensional'
+            % nothing has to be done
+        case 'one-dimensional'
+            dtheta([1:j-1,j+1:end]) = 0;
+    end
+    % 2) Settinf the ojective function
+    obj = @(theta) objWrap(theta, objFun, optimizer);
+
+    % 1) line search
+    if dtheta(j) > 0 % increasing
+        c_bound = (theta_max(j)-theta(j))/dtheta(j);
+    else
+        c_bound = (theta_min(j)-theta(j))/dtheta(j);
+    end
+    if c_bound > c_min
+        c_max = min(c_max,c_bound);
+        c = min(max(c,c_min),c_max);
+        search = 1;
+    else
+        c_min = c_bound;
+        c_max = c_bound;
+        c = c_bound;
+        search = 0;
+    end
+    % 2) inequality constraints
+    if ~isempty(constraints.A)
+        A = constraints.A;
+        b = constraints.b;
+    else
+        A = zeros(1,length(theta));
+        b = 1;
+    end
+    % 3) parameter projection
+    theta_fun = @(c) max(min(theta + c*dtheta,theta_max),theta_min);
+
+    % Search
+    theta = theta_fun(c);
+    if  min(A*theta <= b)
+        J = obj(theta);
+    else
+        J = inf;
+    end
+
+    if search == 1
+        if J > J_target % => initial c too large
+            stop = 0;
+            while stop == 0
+                c = min(max(c/c_update,c_min),c_max);
+                theta = theta_fun(c);
+                if c == c_min % lower bound reached
+                    stop = 1;
+                    J = obj(theta);
+                elseif min(A*theta <= b) % feasible
+                    J = obj(theta);
+                    if J <= J_target % objective smaller than target value
+                        stop = 1;
+                    end
+                end
+            end
+        else % => initial c too small
+            stop = 0;
+            while stop == 0
+                cn = min(max(c*c_update,c_min),c_max);
+                thetan = theta_fun(cn);
+                if min(A*theta <= b) % feasible
+                    Jn = obj(thetan);
+                    if Jn <= J_target % objective smaller than target value
+                        c = cn;
+                        theta = thetan;
+                        J = Jn;
+                        if cn == c_max % upper bound reached
+                            stop = 1;
+                        end
+                    else
+                        stop = 1;
+                    end
+                else
+                    stop = 1;
+                end
+            end
+        end
+    end
+
+end
+
+function J = objWrap(theta, objFun, optimizer)
+
+    if strcmp(optimizer, 'fmincon')
+        J = objFun(theta);
+    elseif strcmp(optimizer, 'lsqnonlin')
+        [~, ~, J] = objFun(theta);
+    else
+        error('Unknown optimzer for profile calculation!');
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/getParProfilesByIntegration.m b/Requirements/PESTO-1.1.0/private/getParProfilesByIntegration.m
new file mode 100644
index 0000000000000000000000000000000000000000..df3fa476151dbe0e45550a54cec1ec0697536aad
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getParProfilesByIntegration.m
@@ -0,0 +1,1002 @@
+function [parameters, fh] = getParProfilesByIntegration(parameters, objective_function, options, varargin)
+% getParProfilesByIntegration.m calculates the profiles likelihoods for the
+% model parameters, starting from the maximum a posteriori estimate. 
+% This is done by integrating an ODE which follows the optimal path for a
+% given parameter.
+%
+% USAGE:
+% [...] = getParameterProfiles(parameters, objective_function)
+% [...] = getParameterProfiles(parameters, objective_function, options)
+% [parameters, fh] = getParameterProfiles(...)
+%
+% getParProfilesByIntegration() uses the following PestoOptions members:
+%  * PestoOptions::calc_profiles
+%  * PestoOptions::comp_type
+%  * PestoOptions::dJ
+%  * PestoOptions::dR_max
+%  * PestoOptions::fh
+%  * PestoOptions::MAP_index
+%  * PestoOptions::mode
+%  * PestoOptions::obj_type
+%  * PestoOptions::options_getNextPoint .guess .min .max .update .mode
+%  * PestoOptions::parameter_index
+%  * PestoOptions::profile_method
+%  * PestoOptions::profileOptimizationOptions
+%  * PestoOptions::plot_options
+%  * PestoOptions::R_min
+%  * PestoOptions::save
+%  * PestoOptions::solver .AbsTol .algorithm .eps .gamma .hessian 
+%       .linSolver .MaxStep .MaxNumSteps .minCond .MinStep .nonlinSolver 
+%       .RelTol .type
+%
+% Parameters:
+%   parameters: parameter struct
+%   objectiveFunction: objective function to be optimized. 
+%       This function should accept one input, the parameter vector and
+%       return the objective value, its gradient and, if possible, the
+%       Hessian matrix.
+%   options: A PestoOptions object
+%   varargin:
+%     fh: A figure handle. If not provided, a figure will be generated.
+%
+% Required fields of parameters:
+%   number: Number of parameters
+%   min: Lower bound for each parameter
+%   max: upper bound for each parameter
+%   name = {'name1', ...}: names of the parameters
+%   MS: results of global optimization, obtained using for instance 
+%       the routine 'getMultiStarts.m'. MS has to contain at least
+%     * par: sorted list n_theta x n_starts of parameter estimates.
+%          The first entry is assumed to be the best one.
+%     * logPost: sorted list n_starts x 1 of of log-posterior values
+%          corresponding to the parameters listed in .par.
+%     * hessian: Hessian matrix (or approximation) at the optimal point
+%
+% Return values:
+%   parameters: updated parameter struct
+%   fh: figure handle
+%
+% Generated fields of parameters:
+%   P(i): profile for i-th parameter
+%     * par: MAPs along profile
+%     * logPost: maximum log-posterior along profile
+%     * R: ratio
+%
+% History:
+% 2013/10/05 FF original code from thesis
+% 2014/04/09 Sabrina Hross - completely reworked
+% 2016/11/21 Paul Stapor
+% 2017/02/02 Paul Stapor - PESTO version of the code
+
+    %% CHECK AND ASSIGN INPUTS
+    if (nargin >= 4)
+        fh = varargin{1};
+        options.fh = fh;
+    else
+        fh = [];
+    end
+    
+    %% Check for fixed parameters
+    if ~isempty(options.fixedParameters)
+        error('Fixed parameters are currently not supported by getParProfilesByIntegration.');
+    end
+    
+    %% Preperation of folder
+    if options.save
+        [~,~,~] = mkdir(options.foldername);
+        save([options.foldername '/init'],'parameters');
+    end
+
+    %% Profile calculation -- SEQUENTIAL
+    
+    % Profile calculation
+    if strcmp(options.comp_type, 'sequential')
+        
+        for j = options.profile_integ_index
+            parameters = integrateProfileForParameterI(parameters, objective_function, j, options, fh);
+        end
+        
+        
+    elseif strcmp(options.comp_type, 'parallel')
+        parfor j = options.profile_integ_index
+            integrateProfileForParameterI(parameters, objective_function, j, options, fh);
+        end
+        
+        % Output
+        if strcmp(options.profile_method, 'integration')
+            switch options.mode
+                case 'visual', fh = plotParameterProfiles(parameters,'1D',fh,options.parameter_index,options.plot_options);
+                case 'text' % no output
+                case 'silent' % no output
+            end
+        end
+    end
+end
+
+
+
+function parameters = integrateProfileForParameterI(parameters, objectiveFunction, iPar, options, fh)
+ 
+
+    % Define global variables for communication across ODE solver
+    global llhHistory;
+    global yCorrection;
+    global ObjFuncCounter;
+    global reOptSteps;
+    global intSteps;
+    ObjFuncCounter = 0;
+    lastCounter = 0;
+
+    % Initial condition (used only for Profile integration)
+    t0 = parameters.MS.par(iPar, options.MAP_index);
+    
+    % Set objective function handle
+    negLogPost = setObjectiveWrapper(objectiveFunction, options, 'negative log-posterior', [], [], true, true);
+    
+    switch options.solver.type
+        case 'CVODE'            
+            cvodeOptions = CVodeSetOptions('RelTol', options.solver.RelTol, ...
+                'AbsTol', options.solver.AbsTol, ...
+                'MaxStep', options.solver.MaxStep, ...
+                'MinStep', options.solver.MinStep, ...
+                'LinearSolver', options.solver.linSolver, ...
+                'MaxNumSteps', options.solver.MaxNumSteps ...
+            );
+        
+        case {'ode45', 'ode23', 'ode23s', 'ode23t', 'ode15s', 'ode113'}
+            odeMatlabOptions = odeset('RelTol', options.solver.RelTol, ...
+                'AbsTol', options.solver.AbsTol, ...
+                'MaxStep', options.solver.MaxStep ...
+            );
+
+        case 'ode15sDAE' 
+            daeMatlabOptions = odeset('RelTol', options.solver.RelTol, ...
+                'AbsTol', options.solver.AbsTol, ...
+                'MStateDependence', 'strong', ...
+                'MaxStep', options.solver.MaxStep, ...
+                'MassSingular', 'yes', ...
+                'OutputFcn', checkOptimality...
+                );
+    end
+
+    % Check if user-supplied parameter function -> ToBeDone ... Later
+    parameterFunction = @(theta, index) SingleParameter(theta, index);
+    ySize = parameters.number;
+    
+    % !!! IMPORTANT: Think carefully, if this is correct for general 
+    % parameter functions...
+    % lambda = -(DG' * parameters.MS.gradient(:,1)) / (DG' * DG);
+
+    %% Compute profile for in- and decreasing theta_i
+    for s = [1, -1]
+
+        % Set bound for considered parameter (ONLY integrate profiles)
+        borders = [parameters.min, parameters.max];
+        switch s
+            case 1
+                T = parameters.max(iPar);
+            case -1
+                T = parameters.min(iPar);
+        end 
+
+        % Starting point
+        theta  = parameters.MS.par(:, options.MAP_index);
+        llhHistory = parameters.MS.logPost(options.MAP_index);
+        reachedEnd = 0;
+        OutputFunction = @(t, y, flag) checkOptimality(t, y, flag, s, iPar, ...
+            parameters.MS.logPost(1), objectiveFunction, borders, options);
+
+        if ~strcmp(options.solver.hessian, 'user-supplied')
+            approximateHessian(parameters.MS.par(:,options.MAP_index), -parameters.MS.gradient(:,options.MAP_index), parameters.MS.hessian(:,:,options.MAP_index), [], 'init');
+        end
+        
+        % Pre-Output
+        if (strcmp(options.mode, 'text'))
+            fprintf('\n  |  Integrating Parameter %4i, s = %2i  |', iPar, s);
+            fprintf('\n  |======================================|');
+            fprintf('\n  | Running axis |  Optimality |  Ratio  |');
+            fprintf('\n  |--------------|-------------|---------|');
+        end
+        
+        % Get the computation time
+        startTimeProfile = cputime;
+        
+        intSteps = 0;
+        optSteps = 0;
+        reOptSteps = 0;
+        
+        % Switch between different methods
+        while (reachedEnd == 0)
+
+            if (s == 1)
+                theta = theta(:,end);
+            else
+                theta = theta(:,1);
+            end
+            llhHistory = llhHistory(end);
+
+            switch options.solver.type
+                case {'ode45', 'ode15s', 'ode113','ode23', 'ode23s', 'ode23t'}
+                    odeMatlabOptions.OutputFcn = OutputFunction;
+                    odeMatlabOptions.Events = @(t,y) getEndProfile(t, s, y, iPar, borders, negLogPost, options, parameters.MS.logPost(1));
+                    if (strcmp(options.solver.type, 'ode15s'))
+                        [~,y] = ode15s(@(t,y) getRhsRed(t, s, y, iPar, borders, negLogPost, parameterFunction, options),[s*theta(iPar), s*T], theta, odeMatlabOptions); 
+                    elseif (strcmp(options.solver.type, 'ode45'))
+                        error('ode45 is currently not implemented for profiling.');
+                        % [~,y] = ode45(@(t,y) getRhsRed(t, s, y, j, borders, negLogPost, parameterFunction, options),[s*theta(j), s*T], theta, odeMatlabOptions);  
+                    elseif (strcmp(options.solver.type, 'ode113'))
+                        [~,y] = ode113(@(t,y) getRhsRed(t, s, y, iPar, borders, negLogPost, parameterFunction, options),[s*theta(iPar), s*T], theta, odeMatlabOptions); 
+                    elseif (strcmp(options.solver.type, 'ode23s'))
+                        [~,y] = ode23s(@(t,y) getRhsRed(t, s, y, iPar, borders, negLogPost, parameterFunction, options),[s*theta(iPar), s*T], theta, odeMatlabOptions);  
+                    elseif (strcmp(options.solver.type, 'ode23t'))
+                        [~,y] = ode23t(@(t,y) getRhsRed(t, s, y, iPar, borders, negLogPost, parameterFunction, options),[s*theta(iPar), s*T], theta, odeMatlabOptions);
+                    elseif (strcmp(options.solver.type, 'ode23'))
+                        [~,y] = ode23(@(t,y) getRhsRed(t, s, y, iPar, borders, negLogPost, parameterFunction, options),[s*theta(iPar), s*T], theta, odeMatlabOptions);
+                    end
+
+
+                    % If yCorrection is set to inf, then the ODE is too stiff, 
+                    % some steps of optimization based calculation have to be done
+                    if (yCorrection == inf)
+                        addY = doOptimizationSteps(parameters, y, objectiveFunction, borders, iPar, s, options);
+                        y = [y; addY];
+                        optSteps = optSteps + 3;
+                    else
+                    % If reoptimization has to be done, correct the values in y by the optimized ones
+                        for iLine = size(yCorrection, 2) : -1 : 1
+                            % Not sure: Either all entries are nan, or none
+                            % of them, so it if sufficient to test the 1st?
+                            if ~isnan(yCorrection(1,iLine))
+                                y(end + 1 - iLine, :) = yCorrection(:,iLine)';
+                            end
+                        end
+                    end
+
+                    if (s == 1)
+                        theta = y';
+                    else
+                        theta = fliplr(y');
+                    end
+
+                case 'CVODE' 
+                    error('CVODE is currently not implemented for profiling.');
+%                     cvodeOptions.RootsFn = @(t,y) getEndProfile(t, s, y, j, borders, objective_function, options, parameters.MS.logPost(1));
+%                     CVodeInit(@(t,y,data) getRhsRed(t, s, y, j, borders, objective_function, parameterFunction, options), options.solver.algorithm, options.solver.nonlinSolver, s*t0, theta, cvodeOptions);
+% 
+%                     killCounter = 0;
+%                     reachedEndCVODE = 0;
+%                     iTer = 1;
+%                     y = nan(ySize, 100);
+%                     t = nan(1, 100);
+%                     while (reachedEndCVODE == 0)
+%                         try
+%                             if(killCounter == 1)
+%                                 t_00 = t_tmp  + 1e-4;
+%                                 y_00 = y_tmp;
+%                                 cvodeOptions = CVodeSetOptions('RelTol', options.solver.RelTol, ...
+%                                                 'AbsTol', options.solver.AbsTol, ...
+%                                                 'MaxStep', options.solver.MaxStep, ...
+%                                                 'MinStep', options.solver.MinStep, ...
+%                                                 'LinearSolver', options.solver.linSolver, ...'StabilityLimDet', true, ...
+%                                                 'MaxNumSteps', options.solver.MaxNumSteps ...'MaxOrder', 12
+%                                                 );
+%                                 CVodeInit(@(t,y,data) getRhsRed(t, s, y, j, borders, objective_function, parameterFunction, options), 'BDF', 'Newton', s*t_00, y_00, cvodeKillOptions);  
+%                                 killCounter = 0;
+%                             end
+%                             [~, t_tmp, y_tmp] = CVode(s*T, 'OneStep');
+%                         catch
+%                             t_000 = t_tmp  + 0.025;
+%                             while(s*t_000 - s*t_tmp > 0)
+%                                 t_00 = t_tmp  + 5e-5;
+%                                 y_00 = y_tmp;
+%                                 cvodeKillOptions = CVodeSetOptions('RelTol', 1e-3, ...
+%                                     'AbsTol', 1e-5, ...
+%                                     'MaxStep', options.solver.MaxStep,...
+%                                     'MinStep', 1e-4, ...
+%                                     'LinearSolver', options.solver.linSolver, ...'StabilityLimDet', true, ...
+%                                     'MaxNumSteps', options.solver.MaxNumSteps ...'MaxOrder', 12
+%                                     );
+%                                 CVodeInit(@(t,y,data) getRhsRed(t, s, y, j, borders, objective_function, parameterFunction, options), options.solver.algorithm, options.solver.nonlinSolver, s*t_00, y_00, cvodeOptions);  
+%                                 [~, t_tmp, y_tmp] = CVode(s*(t_00 + 0.025), 'OneStep');
+%                             end
+%                             killCounter = 1;
+%                         end
+%                         y(:, iTer) = y_tmp;
+%                         t(1, iTer) = t_tmp;
+%                         if ((cvodeOptions.RootsFn(t_tmp, y_tmp) < 0) || ((s*T - t_tmp) < 0))
+%                             reachedEndCVODE = 1;
+%                         end
+%                         iTer = iTer + 1;
+%                         if (abs(iTer/100) < 0.001)
+%                             y = [y, zeros(ySize, 100)];
+%                             t = [t, zeros(1, 100)];
+%                         end
+%                     end
+%                     y = y(1:ySize, 1:iTer-1);
+%                     if (s == 1)
+%                         theta = y(:,:);
+%                     else
+%                         theta = fliplr(y(:,:));
+%                     end
+%                     t = t(1:iTer-1);
+% 
+%                     %release CVODE Worksspace
+%                     CVodeFree;               
+
+                case 'ode15sDAE' 
+                    error('ode15sDAE is currently not implemented for profiling.');
+                    daeMatlabOptions.Mass = @(t, y) getMassmatrixDAE(t, s, y, iPar, negLogPost, parameterFunction);
+                    daeMatlabOptions.Events = @(t,y) getEndProfile(t, s, y, iPar, borders, negLogPost, options, parameters.MS.logPost(1));
+                    [~, y] = ode15s(@(t,y) getRhsDAE(t, s, y, 1, iPar, negLogPost, options), [s*t0, s*T], theta, daeMatlabOptions);
+
+                    if (s == 1)
+                        theta = y';
+                    else
+                        theta = fliplr(y');
+                    end
+            end
+
+            %% Write results to the parameters struct
+            switch s
+                case 1
+                    parameters.P(iPar).logPost = [parameters.P(iPar).logPost, llhHistory];
+                    parameters.P(iPar).R = [parameters.P(iPar).R, exp(llhHistory - parameters.MS.logPost(1))];
+                    parameters.P(iPar).par = [parameters.P(iPar).par, theta];
+
+                    if ((parameters.P(iPar).R(end) <= options.R_min) ...
+                            || parameters.P(iPar).par(iPar, end) >= borders(iPar, 2))
+                        reachedEnd = 1;
+                    end
+
+                case -1
+                    parameters.P(iPar).logPost = [fliplr(llhHistory), parameters.P(iPar).logPost];
+                    parameters.P(iPar).R = [exp(fliplr(llhHistory) - parameters.MS.logPost(1)), parameters.P(iPar).R];
+                    parameters.P(iPar).par = [theta, parameters.P(iPar).par];
+
+                    if ((parameters.P(iPar).R(1) <= options.R_min) ...
+                            || parameters.P(iPar).par(iPar, 1) <= borders(iPar, 1))
+                        reachedEnd = 1;
+                    end
+            end
+
+        end
+
+        % Get computation time
+        parameters.P(iPar).t_cpu(round((s+3)/2)) = cputime - startTimeProfile;
+        parameters.P(iPar).optSteps(round((s+3)/2)) = optSteps;
+        parameters.P(iPar).intSteps(round((s+3)/2)) = intSteps;
+        parameters.P(iPar).reOptSteps(round((s+3)/2)) = reOptSteps;
+        
+        % Final output and storage
+        if (strcmp(options.mode, 'text'))
+            fprintf('\n  |======================================|\n');
+            fprintf('\n  Total RHS evaluations: %i', ObjFuncCounter - lastCounter);
+            fprintf('\n  Total Steps: %i\n', length(llhHistory));
+        end
+        lastCounter = ObjFuncCounter;
+
+        % Save
+        if (options.save)
+            dlmwrite([options.foldername '/P' num2str(iPar,'%d') '__par.csv'],P_par,'delimiter',',','precision',12);
+            dlmwrite([options.foldername '/P' num2str(iPar,'%d') '__logPost.csv'],P_logPost,'delimiter',',','precision',12);
+            dlmwrite([options.foldername '/P' num2str(iPar,'%d') '__R.csv'],P_R,'delimiter',',','precision',12);
+        end  
+
+        % Output
+        if ~strcmp(options.comp_type,'parallel')
+            switch options.mode
+                case 'visual', fh = plotParameterProfiles(parameters, '1D', fh, options.parameter_index, options.plot_options);
+                case 'text'   % no output
+                case 'silent' % no output
+            end
+        end        
+    end 
+
+end
+
+
+
+function status = checkOptimality(t, y, flag, s, ind, logPostMax, objectiveFunction, borders, options)
+    
+    % Assume successful Check
+    status = 0;
+    persistent lastT;
+    persistent CounterMinStep;
+    global llhHistory;
+    global yCorrection;
+    global reOptSteps;
+    global intSteps;
+    
+    % Initialize persistent variables in the beginning
+    if strcmp(flag, 'init')
+        lastT = t(1);
+        CounterMinStep = 0;
+        
+    elseif strcmp(flag, 'done')
+        lastT = [];
+        clear CounterMinStep;
+        
+    else
+        yCorrection = nan(size(y));
+        logPost = setObjectiveWrapper(objectiveFunction, options, 'log-posterior', [], [], true, true);
+        
+        for iT = 1 : length(t)
+            % Check if Minimum step size was violated
+            dt = t(iT) - lastT;
+            if (dt < options.solver.MinStep)
+                CounterMinStep = CounterMinStep + 1;
+            else
+                CounterMinStep = 0;
+            end
+            lastT = t(iT);
+
+            % Abort and start reoptimization, if minimum step size was violated
+            if (CounterMinStep >= 10)
+                display('Violated minimum step size at least 10 times in a row. Doing some optimization steps!');
+                yCorrection = inf;
+                status = 1;
+            end
+
+            % Check, if first optimality is violated, reoptimize if necessary
+            [L, GL] = logPost(y(:,iT));
+            GL(ind) = 0;
+            violateBounds = (y(:,iT) <= (borders(:,1) + options.solver.AbsTol)) ...
+                + (y(:,iT) >= (borders(:,2) - options.solver.AbsTol));
+            GL(logical(violateBounds)) = 0;
+            
+            % Update Hessian, if approximation method ist used
+            if (~strcmp(options.solver.hessian, 'user-supplied'))
+                approximateHessian(y(:,iT), -GL, [], options.solver.hessian, 'write');
+            end
+            
+            if (sqrt(sum(GL.^2)) > options.solver.GradTol)
+                isBord = 0;
+                for bord = reshape(borders, [1 numel(borders)])
+                    if (abs(y(ind) - bord) < 1e-8)
+                        display('Lost optimal path at border!');
+                        isBord = 1;
+                    end
+                end
+                if ~isBord
+                    display('Lost optimal path, doing a reoptimization!');
+                    [newY, L, GL] = reoptimizePath(y(:,iT), ind, objectiveFunction, borders, options);
+                    y(:,iT) = [newY(1:ind-1); y(ind,iT); newY(ind:end)];
+                    yCorrection(:,iT) = y(:,iT);
+                    reOptSteps = reOptSteps + 1;
+                    status = 1;
+                end
+            end
+            
+            % Write ratio and increase counter
+            R = exp(L - logPostMax);
+            intSteps = intSteps + 1;
+            
+            if (strcmp(options.mode, 'text'))
+                fprintf('\n  |  %11.8f | %11.7f | %7.5f |', ...
+                    s*t(iT), sqrt(sum(GL.*GL)), R);
+            end
+            llhHistory = [llhHistory, L];
+            if (R < options.R_min)
+                status = 1;
+            end
+        end
+        
+    end
+end
+
+
+
+function [newY, newL, newGL] = reoptimizePath(theta, iPar, objectiveFunction, borders, options)
+    
+    I1 = (1 : iPar-1)';
+    I2 = (iPar+1 : length(theta))';
+    I = [I1; I2];
+    
+    % options.profileOptimizationOptions.Display = 'off';
+    negLogPostReduced = setObjectiveWrapper(objectiveFunction, options, 'negative log-posterior', iPar, theta(iPar), true, true);
+    
+    if (~isfield(options.profileOptimizationOptions, 'HessFcn') ...
+        || isempty(options.profileOptimizationOptions.HessFcn))
+        % this only works for box-constraints at the moment
+        options.profileOptimizationOptions.HessFcn = @(varargin) HessianWrap(negLogPostReduced, varargin);
+    end 
+        
+    % Optimization
+    [newY, newL, ~, ~, ~, newGL, newHL] = ...
+        fmincon(negLogPostReduced,...
+        theta(I),...
+        [], [],... % linear inequality constraints
+        [], [],... % linear equality constraints
+        borders(I,1),...   % lower bound
+        borders(I,2),...   % upper bound
+        [],options.profileOptimizationOptions);    % options
+    newL = -newL;
+    newGL = -newGL;
+    newHL = -newHL;
+    
+    if ~strcmp(options.solver.hessian, 'user-supplied')
+        theta = [newY(1:iPar-1); theta(iPar); newY(iPar:end)];
+        tmpHL = [newHL(1:iPar-1,1:iPar-1), zeros(iPar-1,1), newHL(1:iPar-1,iPar:end);...
+            zeros(1,length(theta)); newHL(iPar:end,1:iPar-1), zeros(length(theta)-iPar,1), newHL(iPar:end,iPar:end)];
+        tmpHL(iPar,iPar) = inf;
+        tmpGL = [newGL(1:iPar-1); inf; newGL(iPar:end)];
+        approximateHessian(theta, -tmpGL, tmpHL, options.solver.hessian, 'reinit');
+    end
+end
+
+
+
+function y = doOptimizationSteps(parameters, thetaFull, objectiveFunction, borders, iPar, s, options)
+    
+    global llhHistory;
+    
+    % Initialize everything
+    y = [];
+    theta = (thetaFull(end, :))';
+    I1 = (1 : iPar-1)';
+    I2 = (iPar+1 : length(theta))';
+    I = [I1; I2];
+    stepCounter = 1;
+    
+    % Initialize direction
+    dtheta = zeros(length(thetaFull(end, :)),1);
+    dtheta(iPar) = s * options.options_getNextPoint.guess;
+        
+    % dtheta = (thetaFull(end, :) - thetaFull(end-10, :))';
+    borders(iPar,:) = [options.P.min(iPar), options.P.max(iPar)];
+    logPost = parameters.MS.logPost(options.MAP_index);
+    logPost_max = parameters.MS.logPost(1);
+    negLogPost = setObjectiveWrapper(objectiveFunction, options, 'negative log-posterior', [], [], true, true);
+    
+    % Sequential update
+    while (options.P.min(iPar) < theta(iPar)) && (theta(iPar) < options.P.max(iPar)) && ...
+            (logPost >= (log(options.R_min) + logPost_max) && ...
+            stepCounter < 5)
+    
+        % Proposal of next profile point
+        [theta_next,~] = ...
+            getNextProfilePoint(theta, ...
+            borders(:,1), ...
+            borders(:,2), ...
+            dtheta/abs(dtheta(iPar)), ...
+            abs(dtheta(iPar)), ...
+            options.options_getNextPoint.min, ...
+            options.options_getNextPoint.max, ...
+            options.options_getNextPoint.update, ...
+            -( log(1-options.dR_max) + options.dJ * (logPost-logPost_max) + logPost ), ...
+            negLogPost,...
+            parameters.constraints, ...
+            options.options_getNextPoint.mode, ...
+            iPar, ...
+            options.localOptimizer);
+        negLogPostReduced = setObjectiveWrapper(objectiveFunction, options, 'negative log-posterior', iPar, theta_next(iPar), true, true);
+        
+        % Construction of reduced linear constraints
+        [A,b,Aeq,beq] = getConstraints(theta, parameters, I);
+        
+        if (~isfield(options.profileOptimizationOptions, 'HessFcn') ...
+            || isempty(options.profileOptimizationOptions.HessFcn))
+            % this only works for box-constraints at the moment
+            options.profileOptimizationOptions.HessFcn = @(varargin) HessianWrap(negLogPostReduced, varargin);
+        end 
+        % Optimization
+        [theta_I_opt, L, ~, ~, ~, newGL, newHL] = ...
+            fmincon(negLogPostReduced, ...
+            theta_next(I),...
+            A  ,b  ,... % linear inequality constraints
+            Aeq,beq,... % linear equality constraints
+            parameters.min(I),...   % lower bound
+            parameters.max(I),...   % upper bound
+            [],...
+            options.profileOptimizationOptions);    % options
+        
+        % Restore full vector and determine update direction
+        logPost = -L;
+        dtheta = [theta_I_opt(I1); theta_next(iPar); theta_I_opt(I2-1)] - theta;
+        theta = theta + dtheta;
+        
+        llhHistory = [llhHistory, logPost];
+        R = exp(-L - parameters.MS.logPost(1));
+        if (strcmp(options.mode, 'text'))
+            fprintf('\n  |  %11.8f | %11.7f | %7.5f |', ...
+                theta(iPar), sqrt(sum(newGL.^2)), R);
+        end
+        y = [y, theta];
+        stepCounter = stepCounter + 1;
+    end
+    
+    if ~strcmp(options.solver.hessian, 'user-supplied')
+        tmpHL = [newHL(1:iPar-1,1:iPar-1), zeros(iPar-1,1), newHL(1:iPar-1,iPar:end);...
+            zeros(1,length(theta)); newHL(iPar:end,1:iPar-1), zeros(length(theta)-iPar,1), newHL(iPar:end,iPar:end)];
+        tmpHL(iPar,iPar) = inf;
+        tmpGL = [newGL(1:iPar-1); inf; newGL(iPar:end)];
+        approximateHessian(theta, -tmpGL, tmpHL, options.solver.hessian, 'reinit');
+    end
+    y = y';
+    
+end
+
+
+
+%% SingleParameter is a support function for the profile integration
+%  Provides function handles for the parameter function its
+%  gradient and hessian for a single parameter profile
+% 
+% USAGE:
+% =====
+% [...] = SingleParameter(theta, index)
+%     
+% INPUTS:
+% =======
+% theta ... parameter values
+% index ... index of parameter for which the profile should be computed
+% 
+% OUTPUTS:
+% ========
+% g   ... parameter value
+% dg  ... gradient
+% ddg ... hessian
+% 
+% 2015/11/20 Sabrina Hross
+% 2017/02/20 Paul Stapor
+
+function [varargout] = SingleParameter(theta, index)
+        
+    switch nargout
+        case 1
+          varargout{1} = theta(index, :);   
+        case 2
+            varargout{1} = theta(index, :);
+
+            dg = zeros(length(theta),1); dg(index) = 1;
+            varargout{2} = dg;
+        case 3
+            varargout{1} = theta(index,:);
+            dg = zeros(length(theta),1); dg(index) = 1;
+            varargout{2} = dg;
+            varargout{3} = zeros(length(theta),length(theta));
+    end
+    
+end
+
+
+
+%% getEndProfile is a support function for the profile integration
+%   and is called in integrateProfile. It gives the Rootfunction for CVODES
+%   to end the profile calculation if the profile falls below the threshold
+%   before the parameter bounds are reached.
+%
+% USAGE:
+% ======
+% function [R,FLAG] = getEndProfile(theta)
+%
+% INPUTS:
+% =======
+% theta ... parameter   
+%
+% Outputs:
+% ========
+% CVODE
+% R ... Root function
+% FLAG ... =0 if successful ~=0 if failed
+% ODE15s
+% R ... Root function
+% isterminate ... =1 to terminate at root
+% direction ... =0 find zeros independent of direction
+%
+% 2015/11/19 Sabrina Hross
+% 2017/02/20 Paul Stapor
+
+function [varargout] = getEndProfile(t, s, y, ind, borders, negLogPost, options, logPostMax)
+
+    L = negLogPost(y);
+    R = logPostMax - log(options.R_min) + L;
+
+    if strcmp(options.solver.type, 'CVODE')
+        if (t < borders(ind, 2)) && (t > borders(ind, 1))
+            varargout{1} = R;
+        else
+            % display('stopped at parameter boundary')
+            varargout{1} = 0;
+        end
+        varargout{2} = 0; % flag
+    else
+        withinBorders = false;
+        if (s == 1)
+            if (t < borders(ind, 2)) && (t > borders(ind, 1))
+                withinBorders = true;
+            end
+        else
+            if (t < s*borders(ind, 1)) && (t > s*borders(ind, 2))
+                withinBorders = true;
+            end
+        end
+        
+        if withinBorders
+            varargout{1} = R;
+        else
+            % display('stopped at parameter boundary')
+            varargout{1} = 0;
+        end
+        varargout{2} = 1; % isterminal
+        varargout{3} = 0; % locate all zeros
+    end
+    
+end
+
+
+
+function [dPar_dc, flag, new_Data] = getRhsRed(~, direction, par, ind, borders, negLogPost, ~, options)
+    
+    % set parameters
+    nPar = length(par);
+    flag = 0;
+    
+    global ObjFuncCounter;
+    ObjFuncCounter = ObjFuncCounter + 1;
+    
+    switch options.solver.hessian
+        case 'user-supplied'
+            [~, gradLLH, hessLLH] = negLogPost(par);
+        case {'bfgs', 'sr1', 'dfp'}
+            [~, gradLLH] = negLogPost(par);
+            hessLLH = approximateHessian(par, -gradLLH, [], options.solver.hessian, 'read');
+        otherwise
+            error('Unknown type of Hessian computation.');
+    end
+    
+    if (sum(sum(isnan(hessLLH)))>0) || sum(isnan(gradLLH))>0 || (sum(sum(isinf(hessLLH)))>0) || sum(isinf(gradLLH))>0
+        disp('Warning: Undefined model output')
+        flag = -1;
+        dPar_dc = nan(size(par));
+        new_Data = [];
+        return;
+    end
+
+    % right handside of ODE
+    try    
+        % Reduce linear system by implicit funtion theorem
+        lhsMatrix = hessLLH;
+        lhsMatrix(:,ind) = [];
+        lhsMatrix(ind,:) = [];
+        rhsVector = -direction * hessLLH(:,ind) - options.solver.gamma * gradLLH;
+        rhsVector(ind) = [];
+        
+        % Check for invertibility of the RHS
+        if (rcond(lhsMatrix) < options.solver.minCond) || isnan(rcond(lhsMatrix))
+            dPar_dc = pinv(lhsMatrix, options.solver.eps) * rhsVector;
+        else
+            dPar_dc = lhsMatrix \ rhsVector;
+        end
+        dPar_dc = [dPar_dc(1:ind-1); direction; dPar_dc(ind:end)];
+    catch
+        dPar_dc = zeros(nPar, 1);
+        dPar_dc(ind) = direction;
+    end
+    
+    % Check, if parameter bounds are violated
+    rebuildSystem = 0;
+    parDown = [];
+    parUp = [];
+    for iPar = 1 : nPar
+        if (iPar ~= ind)
+            if (par(iPar) <= borders(iPar, 1) + options.solver.RelTol)
+                if(dPar_dc(iPar) < 0)
+                    gradLLH(iPar) = 0;
+                    hessLLH(iPar,:) = 0;
+                    hessLLH(:,iPar) = 0;
+                    hessLLH(iPar,iPar) = -1;
+                    rebuildSystem = 1;
+                    parUp = [parUp, iPar];
+                end
+            elseif (par(iPar) >= borders(iPar, 2) - options.solver.RelTol)
+                if(dPar_dc(iPar) > 0)
+                    gradLLH(iPar) = 0;
+                    hessLLH(iPar,:) = 0;
+                    hessLLH(:,iPar) = 0;
+                    hessLLH(iPar,iPar) = -1;
+                    rebuildSystem = 1;
+                    parDown = [parDown, iPar];
+                end
+            end
+        end
+    end
+    
+    if (rebuildSystem == 1)
+        try    
+            % Reduce linear system by implicit funtion theorem
+            lhsMatrix = hessLLH;
+            lhsMatrix(:,ind) = [];
+            lhsMatrix(ind,:) = [];
+            rhsVector = -direction * hessLLH(:,ind) - options.solver.gamma * gradLLH;
+            rhsVector(ind) = [];
+
+            % Check for invertibility of the RHS
+            if (rcond(lhsMatrix) < options.solver.minCond) || isnan(rcond(lhsMatrix))
+                dPar_dc = pinv(lhsMatrix, options.solver.eps) * rhsVector;
+            else
+                dPar_dc = lhsMatrix \ rhsVector;
+            end
+            dPar_dc = [dPar_dc(1:ind-1); direction; dPar_dc(ind:end)];
+        catch ME
+            dPar_dc = zeros(nPar, 1);
+            dPar_dc(ind) = direction;
+        end
+    end
+    new_Data = [];
+end
+
+
+
+function hessian = approximateHessian(theta, grad, hess, method, flag)
+    
+    persistent lastTheta;
+    persistent lastGrad;
+    persistent lastHess;
+    
+    if strcmp(flag, 'init')
+        hessian = [];
+        
+        % Replace old by new values for next call
+        lastGrad = grad;
+        lastHess = hess;
+        lastTheta = theta;
+    elseif strcmp(flag, 'reinit')
+        % Replace old by new values for next call
+        lastTheta = theta;    
+        [~,ind] = max(max(hess));
+        ind = ind(1);
+        lastHess = [hess(1:ind-1,1:ind-1), lastHess(1:ind-1,ind), hess(1:ind-1,ind+1:end); ...
+            lastHess(ind,:); hess(ind+1:end,1:ind-1), lastHess(ind+1:end,ind), hess(ind+1:end,ind+1:end)];
+        lastGrad = [grad(1:ind-1); lastGrad(ind); grad(ind+1:end)];
+
+    elseif strcmp(flag, 'write')
+        if (theta == lastTheta)
+            hessian = lastHess;
+        else
+            switch method
+                case 'bfgs'
+                    delTheta = theta - lastTheta;
+                    delGrad = grad - lastGrad;
+                    u = delGrad * delGrad' / (delGrad' * delTheta);
+                    v = lastHess * (delTheta * delTheta') * lastHess / (delTheta' * lastHess * delTheta);
+                    hessian = lastHess + u - v;
+                case 'sr1'
+                    delTheta = theta - lastTheta;
+                    delGrad = grad - lastGrad;
+                    u = delGrad - lastHess * delTheta;
+                    v = u * u' / (u' * delTheta);
+                    hessian = lastHess + v;
+                case 'dfp'
+                    delTheta = theta - lastTheta;
+                    delGrad = grad - lastGrad;
+                    gamma = 1 / (delGrad' * delTheta);
+                    u1 = eye(length(theta)) - gamma * (delGrad * delTheta');
+                    u2 = eye(length(theta)) - gamma * (delTheta * delGrad');
+                    v = gamma * (delGrad * delGrad'); 
+                    hessian = u1 * lastHess * u2 + v;
+            end
+            
+            % Replace old by new values for next call
+            lastGrad = grad;
+            lastHess = hessian;
+            lastTheta = theta;
+        end
+        
+    elseif strcmp(flag, 'read')
+        hessian = lastHess;
+    end
+    
+end
+
+
+
+%% getRhsDAE is a support function for the profile integration
+%   and is called in integrateProfile. It determines the right hand side of
+%   of the problem in the DAE formulation.
+%
+% USAGE:
+% ======
+% function [dth,flag,new_Data] = getRhsDAE(u, s, data)
+%
+% INPUTS:
+% =======
+% u ... current state (not used but given by IDAS)
+% s ... step direction (not used by IDAS, fixed input)  
+% y ... current parameter set 
+% yp ... parameter slope
+% options ... options for profile integration
+%   .solver    ... solver options determining gradient and hessian
+%   calculation
+%   .paramFunc ... parameter function
+%
+% Outputs:
+% ========
+% dth ... parameter proposal
+% flag ... needed by IDAS
+% new_Data ... needed by IDAS
+%
+% 2013/11/16 Sabrina Hock
+% 2016/02/06 Sabrina Hross
+
+function [dth, flag] = getRhsDAE(~, s, y, yp, ind, negLogPost, options)
+
+    % set parameters
+    npar = length(y);
+    flag = 0;
+    
+    [~,GL] = negLogPost(y);
+
+    if (sum(isnan(GL)) > 0 || sum(isinf(GL)) > 0)
+        disp('Warning: Undefined model output')
+        flag = -1;
+    end
+
+    b = [-GL(1 : ind-1) * s * options.solver.gamma; ...
+             -GL(ind+1 : npar) * s * options.solver.gamma; ...
+             1];
+
+    switch options.solver.type
+        case 'ode15sDAE'
+            dth = b;        
+        case 'IDAS'
+            Mt = getMassmatrixDAE(1,s,y,options);
+            dth = Mt*yp-b;
+    end
+end
+
+
+
+%% getMassmatrixDAE is a support function for the profile integration
+%   and is called by integrateProfileDAE. It determines the Massmatrix of
+%   of the problem in the DAE formulation.
+%
+% USAGE:
+% ======
+% function [dth,flag,new_Data] = getMassmatrixDAE(u, y, data)
+%
+% INPUTS:
+% =======
+% u ... current state (not used but given by IDAS) 
+% y ... current parameter set 
+% options ... options for profile integration
+%   .solver    ... solver options determining gradient and hessian
+%   calculation
+%   .paramFunc ... parameter function
+%
+% Outputs:
+% ========
+% MT ... Massmatrix
+%
+% 2013/11/16 Sabrina Hock
+% 2016/02/06 Sabrina Hross
+% 2016/11/21 Paul Stapor
+
+function Mt = getMassmatrixDAE(c ,s, y, ind, negLogPost, parameterFunction)
+
+    % set parameters
+    npar = length(y);
+    
+    [~, GL, HL] = negLogPost(y);
+    
+    if (sum(sum(isnan(HL)))>0) || (sum(sum(isinf(HL)))>0) 
+        disp('Warning: Undefined model output')
+    end
+
+    % calculate hessian of parameter function
+    [~,GG,~] = parameterFunction(th, ind);
+    GG=s*GG;
+
+    A1 = [HL(1 : ind-1, :); HL(ind+1 : npar, :); s*GG'];
+         
+    %Massmatrix
+    Mt = A1;
+    
+    GL1 = GL; 
+    GL1(ind) = 0;
+    if (isempty(c))
+        display(['Jacobian Evaluation around theta = ' y']);
+    else
+        display(['Running axis: ' num2str(s*c) '   Optimality: ', num2str(sqrt(GL1' * GL1)), '    condition number: ', num2str(rcond(A1))]);
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/getParProfilesByOptimization.m b/Requirements/PESTO-1.1.0/private/getParProfilesByOptimization.m
new file mode 100644
index 0000000000000000000000000000000000000000..ae3aeed72bc489f3e817283119484b3e290a8d68
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getParProfilesByOptimization.m
@@ -0,0 +1,373 @@
+function [parameters,fh] = getParProfilesByOptimization(parameters, objective_function, options, varargin)
+% getParProfilesByOptimization.m calculates the profiles likelihoods for the model 
+% parameters, starting from the maximum a posteriori estimate. This
+% calculation is done by fixing the i-th parameter and repeatedly
+% reoptimizing the likelihood/posterior estimate (for all i). The initial 
+% guess for the next reoptimization point is computed by extrapolation from
+% the previous points to ensure a quick optimization.
+%
+% Note: This function can exploit up to (n_theta + 1) workers when running
+% in 'parallel' mode.
+%
+% USAGE:
+% [...] = getParameterProfiles(parameters, objective_function)
+% [...] = getParameterProfiles(parameters, objective_function, options)
+% [parameters, fh] = getParameterProfiles(...)
+%
+% getParProfilesByOptimization() uses the following PestoOptions members:
+%  * PestoOptions::calc_profiles
+%  * PestoOptions::comp_type
+%  * PestoOptions::dJ
+%  * PestoOptions::dR_max
+%  * PestoOptions::fh
+%  * PestoOptions::MAP_index
+%  * PestoOptions::mode
+%  * PestoOptions::obj_type
+%  * PestoOptions::options_getNextPoint .guess .min .max .update .mode
+%  * PestoOptions::parameter_index
+%  * PestoOptions::profile_method
+%  * PestoOptions::profileOptimizationOptions
+%  * PestoOptions::plot_options
+%  * PestoOptions::R_min
+%  * PestoOptions::save
+%
+% Parameters:
+%   parameters: parameter struct
+%   objective_function: objective function to be optimized. 
+%       This function should accept one input, the parameter vector.
+%   varargin:
+%     options: A PestoOptions object holding various options for the 
+%         algorithm.
+%
+% Required fields of parameters:
+%   number: Number of parameters
+%   min: Lower bound for each parameter
+%   max: upper bound for each parameter
+%   name = {'name1', ...}: names of the parameters
+%   MS: results of global optimization, obtained using for instance 
+%       the routine 'getMultiStarts.m'. MS has to contain at least
+%     * par: sorted list n_theta x n_starts of parameter estimates.
+%          The first entry is assumed to be the best one.
+%     * logPost: sorted list n_starts x 1 of of log-posterior values
+%          corresponding to the parameters listed in .par.
+%     * hessian: Hessian matrix (or approximation) at the optimal point
+%
+% Return values:
+%   properties: updated parameter struct
+%   fh: figure handle
+%
+% Generated fields of parameters:
+%   P(i): profile for i-th parameter
+%     * par: MAPs along profile
+%     * logPost: maximum log-posterior along profile
+%     * R: ratio
+%
+% History:
+% * 2012/05/16 Jan Hasenauer
+% * 2014/06/12 Jan Hasenauer
+% * 2016/10/04 Daniel Weindl
+% * 2016/10/12 Paul Stapor
+
+    %% No check of inputs (except figure), already done in getParameterProfiles
+
+    % Depending on parallel computation mode, the figure will be updated
+    if (nargin >= 4)
+        fh = varargin{1};
+        options.fh = fh;
+    else
+        fh = [];
+    end
+    
+%     %% Check for fixed parameters
+%     if ~isempty(options.fixedParameters)
+%         error('Fixed parameters are currently not supported by getParProfilesByOptimization.');
+%     end
+
+    %% Profile calculation
+    if strcmp(options.comp_type,'sequential')
+        for iPar = options.profile_optim_index
+            % Define the negative log-posterior function
+            % (fmincon needs the neagtive log posterior for optimization)
+            % with the profile parameter fixed
+            parameters = optimizeProfileForParameterI(parameters, objective_function, iPar, options, fh);
+        end
+
+    elseif strcmp(options.comp_type,'parallel')
+        parfor iPar = options.profile_optim_index
+            % Define the negative log-posterior function
+            % (fmincon needs the neagtive log posterior for optimization)
+            % with the profile parameter fixed
+            optimizeProfileForParameterI(parameters, objective_function, iPar, options, fh);
+        end
+
+        % Output
+        if strcmp(options.profile_method, 'optimization')
+            switch options.mode
+                case 'visual', fh = plotParameterProfiles(parameters,'1D',fh,options.parameter_index,options.plot_options);
+                case 'text' % no output
+                case 'silent' % no output
+            end
+        end
+    end
+
+% %% REOPTIMIZE PROFILE FROM THE BORDER
+% if strcmp(options.reoptimize,'true')
+% disp('');
+% disp('Re-optimization of profile');
+% % Loop: Parameters
+% for i = options.parameter_index
+%     disp('');
+%     % Index set
+%     I1 = [1:i-1]';
+%     I2 = [i+1:parameters.number]';
+%     I  = [I1;I2];
+%     % Likelihood function option
+%     options.logPost_options.grad_ind = I(:);
+%     options.logPost_options.sign = 'negative';
+% 
+%     %% COMPUTE OPTIMUM FOR IN-/DECREASING THETA
+%     for s = [-1,1]
+%         % Find set
+%         if s == -1
+%             ind = find(parameters.P(i).par(i,:) < parameters.MS.par(i));
+%             ind = ind(2:end);
+%         else
+%             ind = find(parameters.P(i).par(i,:) > parameters.MS.par(i));
+%             ind = ind(end-1:-1:1);
+%         end
+%  
+%         % Loop: Index points
+%         for k = ind
+%             % Starting point
+%             theta_next = parameters.P(i).par(:,k+s);
+%             theta_next(i) = parameters.P(i).par(i,k);
+%             theta_i = theta_next(i);
+%             
+%             % Modification of options struct
+%             options_fmincon = options.fmincon;
+%             if isfield(options.fmincon,'TypicalX')
+%                 if ~isempty(options.fmincon.TypicalX)
+%                     options_fmincon.TypicalX = options_fmincon.TypicalX(I);
+%                 end
+%             end
+%             if isfield(options.fmincon,'FinDiffRelStep')
+%                 if ~isempty(options.fmincon.FinDiffRelStep)
+%                     options_fmincon.FinDiffRelStep = options_fmincon.FinDiffRelStep(I);
+%                 end
+%             end
+%             
+%             % Linear constraints
+%             if ~isempty(parameters.constraints.A)
+%                 A = parameters.constraints.A(:,I);
+%                 b = parameters.constraints.b - 10^-10 - parameters.constraints.A(:,i)*theta_i;
+%             else
+%                 A = [];
+%                 b = [];
+%             end
+%             if ~isempty(parameters.constraints.Aeq)
+%                 Aeq = parameters.constraints.Aeq(:,I) - parameters.constraints.Aeq(:,i)*theta_i;
+%                 beq = parameters.constraints.beq;
+%             else
+%                 Aeq = [];
+%                 beq = [];
+%             end
+%             
+%             % Optimize
+%             [theta_next,J_opt] = ...
+%                 fmincon(@(theta_I) objective_function([theta_I(I1);theta_next(i);theta_I(I2-1)],options.logPost_options),...     % negative log-likelihood function
+%                                     theta_next(I),...        % initial parameter
+%                                     A  ,b  ,...             % linear inequality constraints
+%                                     Aeq,beq,...             % linear equality constraints
+%                                     parameters.min(I),...   % lower bound
+%                                     parameters.max(I),...   % upper bound
+%                                     [],options_fmincon);    % options
+%             logPost = -J_opt;
+%             
+%             % Assignment
+%             if -J_opt > parameters.P(i).logPost(k);
+%                 parameters.P(i).par(I,k) = theta_next;
+%                 parameters.P(i).logPost(k) = logPost;
+%                 parameters.P(i).R(k) = exp(logPost - parameters.MS.logPost);
+%             end
+%             
+%             % Update plot
+%             if strcmp(options.plot,'true')
+%                 fh = plotP(parameters,fh,options.parameter_index,options.plot_options);
+%             end
+%             
+%             % Output command line
+%             disp([num2str(i,'%d') '-th P: point ' num2str(k,'%d') ...
+%                 ' -> ' num2str(ind(end)-s,'%d')]);
+%         end
+%     end
+%     disp('');
+% end
+% end
+% 
+%  
+
+end
+
+function [parameters] = optimizeProfileForParameterI(parameters, objective_function, iPar, options, fh)
+
+    % Initialization
+    logPost_max = parameters.MS.logPost(1);
+    Profile_par = parameters.MS.par(:,options.MAP_index);
+    Profile_logPost = parameters.MS.logPost(options.MAP_index);
+    Profile_ratio = exp(parameters.MS.logPost(options.MAP_index)-parameters.MS.logPost(1));
+    
+    % Construction of index set
+    I1 = (1 : iPar-1)';
+    I2 = (iPar+1 : parameters.number)';
+    
+    % Create options ans parameters for the reduced problem 
+    optionsRed = struct(...
+        'localOptimizer', options.localOptimizer, ...
+        'localOptimizerOptions', options.profileOptimizationOptions, ...
+        'fixedParameters', [options.fixedParameters; iPar], ...
+        'fixedParameterValues', [options.fixedParameterValues; nan], ...
+        'objOutNumber', options.objOutNumber, ...
+        'obj_type', options.obj_type, ...
+        'logPostOffset', options.logPostOffset);
+    
+    optionsFull = struct(...
+        'localOptimizer', options.localOptimizer, ...
+        'localOptimizerOptions', options.profileOptimizationOptions, ...
+        'fixedParameters', [], ...
+        'fixedParameterValues', [], ...
+        'objOutNumber', options.objOutNumber, ...
+        'obj_type', options.obj_type);
+    negLogPostFull = setObjectiveWrapper(objective_function, optionsFull, 'negative log-posterior', [], [], true, true);
+    
+    % Compute profile for in- and decreasing theta_i
+    for s = [-1,1]
+        % Starting point
+        theta  = parameters.MS.par(:, options.MAP_index);
+        logPostValue = parameters.MS.logPost(options.MAP_index);
+
+        % Lower and upper bounds for profiles
+        theta_min = [parameters.min(I1); options.P.min(iPar); parameters.min(I2)];
+        theta_max = [parameters.max(I1); options.P.max(iPar); parameters.max(I2)];
+
+        % Initialize direction
+        dtheta = zeros(parameters.number,1);
+        dtheta(iPar) = s*options.options_getNextPoint.guess;
+
+        % Get the computation time
+        startTimeProfile = cputime;
+        stepCount = 0;
+
+        % Sequential update
+        while (options.P.min(iPar) < theta(iPar)) && (theta(iPar) < options.P.max(iPar)) && ...
+                (logPostValue >= (log(options.R_min) + parameters.MS.logPost(1)))
+
+            % Proposal of next profile point
+            [theta_next,J_exp] = ...
+                getNextProfilePoint(theta, ...
+                    theta_min, ...
+                    theta_max,...
+                    dtheta/abs(dtheta(iPar)), ...
+                    abs(dtheta(iPar)), ...
+                    options.options_getNextPoint.min, ...
+                    options.options_getNextPoint.max, ...
+                    options.options_getNextPoint.update, ...
+                    -(log(1-options.dR_max) + options.dJ * (logPostValue-logPost_max) + logPostValue), ...
+                    negLogPostFull,...
+                    parameters.constraints, ...
+                    options.options_getNextPoint.mode, ...
+                    iPar, ...
+                    options.localOptimizer);
+            optionsRed.fixedParameterValues(end) = theta_next(iPar);
+            negLogPostReduced = setObjectiveWrapper(objective_function, optionsRed, 'negative log-posterior', [], [], true, true);
+            
+            % Check, if Hessian should be used and if a Hessian function was set,
+            % otherwise use the third output of the objective function instead
+            % (only works for box constraints atm)
+            useHessianWrap = strcmp(options.profileOptimizationOptions.Hessian, 'on') ...
+                && (~isfield(options.profileOptimizationOptions, 'HessFcn') ...
+                || isempty(options.profileOptimizationOptions.HessFcn));
+            if useHessianWrap
+                options.profileOptimizationOptions.HessFcn = @(varargin) HessianWrap(negLogPostReduced, varargin);
+            end
+            
+            % Optimization
+            if (length(optionsRed.fixedParameters) == parameters.number)
+                negLogPostValue = negLogPostReduced([]);
+                par_opt(:) = theta_next;
+            else
+                try
+                    switch options.localOptimizer
+                        case 'fmincon'
+                            [negLogPostValue, par_opt] = ...
+                                performOptimizationFmincon(parameters, negLogPostReduced, theta_next, optionsRed);
+                        case 'lsqnonlin'
+                            [negLogPostValue, par_opt] = ...
+                                performOptimizationLsqnonlin(parameters, negLogPostReduced, theta_next, optionsRed);
+                    end
+                    stepCount = stepCount + 1;
+                catch errMsg
+                    par_opt = theta_next;
+                    negLogPostValue = inf;
+                end
+            end
+
+            % Restore full vector and determine update direction
+            logPostValue = -negLogPostValue;
+            dtheta = par_opt(:) - theta;
+            theta  = par_opt(:);
+
+            % Sorting
+            switch s
+                case -1
+                    Profile_par = [theta,Profile_par];
+                    Profile_logPost = [logPostValue,Profile_logPost];
+                    Profile_ratio = [exp(logPostValue - parameters.MS.logPost(1)),Profile_ratio];
+                case +1
+                    Profile_par = [Profile_par,theta];
+                    Profile_logPost = [Profile_logPost,logPostValue];
+                    Profile_ratio = [Profile_ratio,exp(logPostValue - parameters.MS.logPost(1))];
+            end
+
+            % Assignment
+            parameters.P(iPar).par = Profile_par;
+            parameters.P(iPar).logPost = Profile_logPost;
+            parameters.P(iPar).R = Profile_ratio;
+
+            % Save
+            if options.save
+                dlmwrite([options.foldername '/P' num2str(iPar,'%d') '__par.csv'],Profile_par,'delimiter',',','precision',12);
+                dlmwrite([options.foldername '/P' num2str(iPar,'%d') '__logPost.csv'],Profile_logPost,'delimiter',',','precision',12);
+                dlmwrite([options.foldername '/P' num2str(iPar,'%d') '__R.csv'],Profile_ratio,'delimiter',',','precision',12);
+            end
+
+            % Output
+            if ~strcmp(options.comp_type,'parallel')
+                switch(iPar)
+                    case 1
+                        ordstr = 'st';
+                    case 2
+                        ordstr = 'nd';
+                    case 3
+                        ordstr = 'rd';
+                    otherwise
+                        ordstr = '-th';
+                end
+                str = [num2str(iPar,'%d') ordstr ' P: point ' num2str(length(parameters.P(iPar).R)-1,'%d') ', R = ' ...
+                    num2str(exp(- negLogPostValue - parameters.MS.logPost(1)),'%.3e') ' (optimized) / '...
+                    num2str(exp(- J_exp - parameters.MS.logPost(1)),'%.3e') ' (predicted)'];
+                switch options.mode
+                    case 'visual', fh = plotParameterProfiles(parameters,'1D',fh,options.parameter_index,options.plot_options);
+                    case 'text', disp(str);
+                    case 'silent' % no output
+                end
+            end
+        end
+
+        parameters.P(iPar).t_cpu(round((s+3)/2)) = cputime - startTimeProfile;
+        parameters.P(iPar).optSteps(round((s+3)/2)) = stepCount;
+        parameters.P(iPar).intSteps(round((s+3)/2)) = 0;
+        parameters.P(iPar).reOptSteps(round((s+3)/2)) = 0;
+    end
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/private/getStepSizeFD.m b/Requirements/PESTO-1.1.0/private/getStepSizeFD.m
new file mode 100644
index 0000000000000000000000000000000000000000..ba669be6579e8599c6f8cf9719d88b90d7650020
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/getStepSizeFD.m
@@ -0,0 +1,89 @@
+function fdStepSize = getStepSizeFD(theta, objectiveFunction, mode)
+
+% This function computes the optimal step size for finite differences.
+%
+% Parameters:
+%   theta: parameter vector
+%   objectiveFunction: the original objective function
+%   mode: double, specifying if the output of the original objective func.
+%           1: only objective value is passed
+%           2: gradients are computed
+%
+% Return values:
+%   fdStepSize: vector of step sizes
+
+    % Initialization
+    nPar = length(theta);
+    fdStepSize = zeros(nPar, 1);
+
+    switch mode
+        case 1
+        % The original objective funcion can only compute the objective,
+        % step sizes for the gradient are needed
+        
+            for j = 1 : nPar
+                delta = zeros(nPar,1);
+                gradients = zeros(1,7);
+                qualityVector = zeros(1,7);
+
+                % Compute gradient for different step sizes
+                for k = 3 : 9
+                    delta(j) = 10^(-k);
+                    Jplus = objectiveFunction(theta + delta);
+                    Jminus = objectiveFunction(theta - delta);
+                    gradients(k-2) = 0.5 * 10^k * (Jplus - Jminus);
+                end
+
+                % Compare gradients for different step sizes
+                for k = 2 : 6
+                    qualityVector(k) = 0.5 * (abs(gradients(k-1) - gradients(k)) ...
+                        + abs(gradients(k+1) - gradients(k)));
+                end
+                qualityVector(1) = abs(gradients(1) - gradients(2));
+                qualityVector(7) = abs(gradients(5) - gradients(6));
+
+                % Choose step sizes with best stability properties
+                [maxQual, ind] = min(qualityVector);
+                fdStepSize(j) = 10^(-ind-3);
+
+                if (maxQual > 0.1)
+                    warning('Could not find a good step size for finite differences. Please check the accuracy of your objetive function.');
+                end
+            end
+        
+        case 2
+        % The original objective funcion can compute the gradient, step 
+        % sizes for the Hessian are needed
+        
+            for j = 1 : nPar
+                delta = zeros(nPar,1);
+                hessians = zeros(nPar,7);
+                qualityVector = zeros(1,7);
+
+                % Compute gradient for different step sizes
+                for k = 3 : 9
+                    delta(j) = 10^(-k);
+                    [~,Gplus] = objectiveFunction(theta + delta);
+                    [~,Gminus] = objectiveFunction(theta - delta);
+                    hessians(:,k-2) = 0.5 * 10^k * (Gplus - Gminus);
+                end
+
+                % Compare gradients for different step sizes
+                for k = 2 : 6
+                    qualityVector(k) = 0.5 * (sum(abs(hessians(:,k-1) - hessians(:,k)).^2) ...
+                        + sum(abs(hessians(:,k+1) - hessians(:,k)).^2));
+                end
+                qualityVector(1) = sum(abs(hessians(:,1) - hessians(:,2)));
+                qualityVector(7) = sum(abs(hessians(:,5) - hessians(:,6)));
+
+                % Choose step sizes with best stability properties
+                [maxQual, ind] = min(qualityVector);
+                fdStepSize(j) = 10^(-ind-3);
+                
+                if (maxQual > 0.1 * nPar)
+                    warning('Could not find a good step size for finite differences. Please check the accuracy of your objetive function.');
+                end
+            end
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/handleOptionArgument.m b/Requirements/PESTO-1.1.0/private/handleOptionArgument.m
new file mode 100644
index 0000000000000000000000000000000000000000..197b3bca8a3a8586f7a365652c653de3b74bad97
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/handleOptionArgument.m
@@ -0,0 +1,10 @@
+function [ options ] = handleOptionArgument( options )
+    %HANDLEOPTIONARGUMENT Check argument type or autocreate PestoOptions
+    %from struct (deprecated)
+    if isstruct(options)
+        warning('Options argument is not of type PestoOptions: Initializing PestoOption instance from user-provided struct. Make sure all options are set correctly in PestoOptions(myOptionsStruct).');
+        options = PestoOptions(options);
+    elseif ~isa(options, 'PestoOptions')
+        error('Options argument is neither of type PestoOptions nor struct.')
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/handlePlottingOptionArgument.m b/Requirements/PESTO-1.1.0/private/handlePlottingOptionArgument.m
new file mode 100644
index 0000000000000000000000000000000000000000..614b54478671ca32a43bba62a11e197bc38d6548
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/handlePlottingOptionArgument.m
@@ -0,0 +1,15 @@
+function [ options ] = handlePlottingOptionArgument( options )
+    %HANDLEPLOTTINGOPTIONARGUMENT Check argument type or autocreate PestoPlottingOptions
+    %from struct (deprecated). Returns a *copy* of the user-provided
+    %object (because some plotting routines make changes to the object which are incompatible to other plotting routines).
+    
+    if isa(options, 'PestoPlottingOptions')
+        options = options.copy();
+    elseif isstruct(options)
+        warning('Options argument is not of type PestoPlottingOptions: Initializing PestoPlottingOptions instance from user-provided struct. Make sure all options are set correctly in PestoPlottingOptions(myOptionsStruct).');
+        options = PestoPlottingOptions(options);
+    else
+        error('Options argument is neither of type PestoPlottingOptions nor struct.')
+    end
+end
+
diff --git a/Requirements/PESTO-1.1.0/private/logmvnpdf.m b/Requirements/PESTO-1.1.0/private/logmvnpdf.m
new file mode 100644
index 0000000000000000000000000000000000000000..112b7b49799ee2c6efc35365aefe5425e99935e9
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/logmvnpdf.m
@@ -0,0 +1,199 @@
+function y = logmvnpdf(X, Mu, Sigma)
+% logmvnpdf Multivariate normal probability density function (pdf).
+%   Y = MVNPDF(X) returns the probability density of the multivariate normal
+%   distribution with zero mean and identity covariance matrix, evaluated at
+%   each row of X.  Rows of the N-by-D matrix X correspond to observations or
+%   points, and columns correspond to variables or coordinates.  Y is an
+%   N-by-1 vector.
+%
+%   Y = MVNPDF(X,MU) returns the density of the multivariate normal
+%   distribution with mean MU and identity covariance matrix, evaluated
+%   at each row of X.  MU is a 1-by-D vector, or an N-by-D matrix, in which
+%   case the density is evaluated for each row of X with the corresponding
+%   row of MU.  MU can also be a scalar value, which MVNPDF replicates to
+%   match the size of X.
+%
+%   Y = MVNPDF(X,MU,SIGMA) returns the density of the multivariate normal
+%   distribution with mean MU and covariance SIGMA, evaluated at each row
+%   of X.  SIGMA is a D-by-D matrix, or an D-by-D-by-N array, in which case
+%   the density is evaluated for each row of X with the corresponding page
+%   of SIGMA, i.e., MVNPDF computes Y(I) using X(I,:) and SIGMA(:,:,I).
+%   If the covariance matrix is diagonal, containing variances along the 
+%   diagonal and zero covariances off the diagonal, SIGMA may also be
+%   specified as a 1-by-D matrix or a 1-by-D-by-N array, containing 
+%   just the diagonal. Pass in the empty matrix for MU to use its default 
+%   value when you want to only specify SIGMA.
+%
+%   If X is a 1-by-D vector, MVNPDF replicates it to match the leading
+%   dimension of MU or the trailing dimension of SIGMA.
+%
+%   Example:
+%
+%      mu = [1 -1]; Sigma = [.9 .4; .4 .3];
+%      [X1,X2] = meshgrid(linspace(-1,3,25)', linspace(-3,1,25)');
+%      X = [X1(:) X2(:)];
+%      p = mvnpdf(X, mu, Sigma);
+%      surf(X1,X2,reshape(p,25,25));
+%
+%   See also MVTPDF, MVNCDF, MVNRND, NORMPDF.
+%   Copyright 1993-2011 The MathWorks, Inc.
+
+if nargin<1
+    error(message('stats:mvnpdf:TooFewInputs'));
+elseif ndims(X)~=2
+    error(message('stats:mvnpdf:InvalidData'));
+end
+
+% Get size of data.  Column vectors provisionally interpreted as multiple scalar data.
+[n,d] = size(X);
+if d<1
+    error(message('stats:mvnpdf:TooFewDimensions'));
+end
+
+% Assume zero mean, data are already centered
+if nargin < 2 || isempty(Mu)
+    X0 = X;
+
+% Get scalar mean, and use it to center data
+elseif numel(Mu) == 1
+    X0 = X - Mu;
+
+% Get vector mean, and use it to center data
+elseif ndims(Mu) == 2
+    [n2,d2] = size(Mu);
+    if d2 ~= d % has to have same number of coords as X
+        error(message('stats:mvnpdf:ColSizeMismatch'));
+    elseif n2 == n % lengths match
+        X0 = X - Mu;
+    elseif n2 == 1 % mean is a single row, rep it out to match data
+        X0 = bsxfun(@minus,X,Mu);
+    elseif n == 1 % data is a single row, rep it out to match mean
+        n = n2;
+        X0 = bsxfun(@minus,X,Mu);  
+    else % sizes don't match
+        error(message('stats:mvnpdf:RowSizeMismatch'));
+    end
+    
+else
+    error(message('stats:mvnpdf:BadMu'));
+end
+
+% Assume identity covariance, data are already standardized
+if nargin < 3 || isempty(Sigma)
+    % Special case: if Sigma isn't supplied, then interpret X
+    % and Mu as row vectors if they were both column vectors
+    if (d == 1) && (numel(X) > 1)
+        X0 = X0';
+        d = size(X0,2);
+    end
+    xRinv = X0;
+    logSqrtDetSigma = 0;
+    
+% Single covariance matrix
+elseif ndims(Sigma) == 2
+    sz = size(Sigma);
+    if sz(1)==1 && sz(2)>1
+        % Just the diagonal of Sigma has been passed in.
+        sz(1) = sz(2);
+        sigmaIsDiag = true;
+    else
+        sigmaIsDiag = false;
+    end
+    
+    % Special case: if Sigma is supplied, then use it to try to interpret
+    % X and Mu as row vectors if they were both column vectors.
+    if (d == 1) && (numel(X) > 1) && (sz(1) == n)
+        X0 = X0';
+        d = size(X0,2);
+    end
+    
+    %Check that sigma is the right size
+    if sz(1) ~= sz(2)
+        error(message('stats:mvnpdf:BadCovariance'));
+    elseif ~isequal(sz, [d d])
+        error(message('stats:mvnpdf:CovSizeMismatch'));
+    else
+        if sigmaIsDiag
+            if any(Sigma<=0)
+                error(message('stats:mvnpdf:BadDiagSigma'));
+            end
+            R = sqrt(Sigma);
+            xRinv = bsxfun(@rdivide,X0,R);
+            logSqrtDetSigma = sum(log(R));
+        else
+            % Make sure Sigma is a valid covariance matrix
+            [R,err] = cholcov(Sigma,0);
+            if err ~= 0
+                error(message('stats:mvnpdf:BadMatrixSigma'));
+            end
+            % Create array of standardized data, and compute log(sqrt(det(Sigma)))
+            xRinv = X0 / R;
+            logSqrtDetSigma = sum(log(diag(R)));
+        end
+    end
+    
+% Multiple covariance matrices
+elseif ndims(Sigma) == 3
+    
+    sz = size(Sigma);
+    if sz(1)==1 && sz(2)>1
+        % Just the diagonal of Sigma has been passed in.
+        sz(1) = sz(2);
+        Sigma = reshape(Sigma,sz(2),sz(3))';
+        sigmaIsDiag = true;
+    else
+        sigmaIsDiag = false;
+    end
+
+    % Special case: if Sigma is supplied, then use it to try to interpret
+    % X and Mu as row vectors if they were both column vectors.
+    if (d == 1) && (numel(X) > 1) && (sz(1) == n)
+        X0 = X0';
+        [n,d] = size(X0);
+    end
+    
+    % Data and mean are a single row, rep them out to match covariance
+    if n == 1 % already know size(Sigma,3) > 1
+        n = sz(3);
+        X0 = repmat(X0,n,1); % rep centered data out to match cov
+    end
+
+    % Make sure Sigma is the right size
+    if sz(1) ~= sz(2)
+        error(message('stats:mvnpdf:BadCovarianceMultiple'));
+    elseif (sz(1) ~= d) || (sz(2) ~= d) % Sigma is a stack of dxd matrices
+        error(message('stats:mvnpdf:CovSizeMismatchMultiple'));
+    elseif sz(3) ~= n
+        error(message('stats:mvnpdf:CovSizeMismatchPages'));
+    else
+        if sigmaIsDiag
+            if any(any(Sigma<=0))
+                error(message('stats:mvnpdf:BadDiagSigma'));
+            end
+            R = sqrt(Sigma);
+            xRinv = X0./R;
+            logSqrtDetSigma = sum(log(R),2);
+        else
+            % Create array of standardized data, and vector of log(sqrt(det(Sigma)))
+            xRinv = zeros(n,d,superiorfloat(X0,Sigma));
+            logSqrtDetSigma = zeros(n,1,class(Sigma));
+            for i = 1:n
+                % Make sure Sigma is a valid covariance matrix
+                [R,err] = cholcov(Sigma(:,:,i),0);
+                if err ~= 0
+                    error(message('stats:mvnpdf:BadMatrixSigmaMultiple'));
+                end
+                xRinv(i,:) = X0(i,:) / R;
+                logSqrtDetSigma(i) = sum(log(diag(R)));
+            end
+        end
+    end
+   
+elseif ndims(Sigma) > 3
+    error(message('stats:mvnpdf:BadCovariance'));
+end
+
+% The quadratic form is the inner products of the standardized data
+quadform = sum(xRinv.^2, 2);
+
+y = -0.5*quadform - logSqrtDetSigma - d*log(2*pi)/2;
diff --git a/Requirements/PESTO-1.1.0/private/objectiveWrap.m b/Requirements/PESTO-1.1.0/private/objectiveWrap.m
new file mode 100644
index 0000000000000000000000000000000000000000..81fef8bb6ddeea4f442ea895f09401253ffd965f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/objectiveWrap.m
@@ -0,0 +1,126 @@
+function varargout = objectiveWrap(theta, objectiveFunction, wrapperOptions, varargin)
+
+    % This function is used as interface to the user-provided objective
+    % function. It adapts the sign and supplies the correct number of outputs.
+    % Furthermore, it catches errors in the user-supplied objective function.
+    %   theta ... parameter vector
+    %   fun ... user-supplied objective function
+    %   options ... cell array with following fields
+    %       * {1} ... type 'log-posterior' or 'negative log-posterior'
+    %       * {2} ... index set with fixed parameter values
+    %       * {3} ... fixed parameter values corresponding to the index set
+    %       * {4} ... maximum number of outputs of the objective function
+    %       * {5} ... optimizer (fmincon, meigo-ess, lsqnonlin, delos, ...)
+    %       * {6} ... global error count (true or false)
+    %       * {7} ... display warnings
+    
+    % Process input
+    objSign = wrapperOptions{1};
+    fixedTheta = wrapperOptions{2};
+    outNumber = wrapperOptions{4};
+    optimizer = wrapperOptions{5};
+    countErrors = wrapperOptions{6};
+    showWarnings = wrapperOptions{7};
+    if isempty(fixedTheta)
+        longTheta = theta;
+        freeInd = 1 : length(theta);
+    else
+        nTheta = length(theta) + length(fixedTheta);
+        freeInd = 1:nTheta;
+        freeInd(fixedTheta) = [];
+        longTheta = nan(nTheta,1);
+        longTheta(freeInd) = theta;
+        longTheta(fixedTheta) = wrapperOptions{3};
+    end
+    
+%     if (~isempty(varargin))
+%         minibatch = varargin{1};
+%     end
+
+    global error_count;
+    
+    try
+        switch nargout
+            case {0,1}
+                J = objectiveFunction(longTheta);
+                varargout = {objSign * J};
+                
+            case 2
+                switch outNumber
+                    case 1
+                        J = objectiveFunction(longTheta);
+                        G = getFiniteDifferences(longTheta, objectiveFunction, 1);
+                    case {2, 3}
+                        [J, G] = objectiveFunction(longTheta);
+                end
+                
+                if strcmp(optimizer, 'lsqnonlin')
+                    varargout = {objSign * J, objSign * G(:,freeInd)};
+                else
+                    varargout = {objSign * J, objSign * G(freeInd)};
+                end
+                if any(any(~isfinite(G)))
+                    error('Gradient contains NaNs or Infs')
+                end
+                
+            case 3
+                switch outNumber
+                    case 1
+                        [J, G, H] = getFiniteDifferences(longTheta, objectiveFunction, 2);
+                    case 2
+                        [J, G] = objectiveFunction(longTheta);
+                        H = getFiniteDifferences(longTheta, objectiveFunction, 3);
+                    case 3
+                        [J, G, H] = objectiveFunction(longTheta);
+                end
+                
+                if strcmp(optimizer, 'lsqnonlin')
+                    varargout = {objSign * J, [], objSign * H};
+                else
+                    varargout = {objSign * J, objSign * G(freeInd), objSign * H(freeInd, freeInd)};
+                end
+                if any(any(~isfinite(G)))
+                    error('Gradient contains NaNs or Infs')
+                end
+                if any(any(~isfinite(H)))
+                    error('Hessian contains NaNs or Infs')
+                end
+        end
+
+        if countErrors
+            % Reset error count
+            error_count = max(error_count - 1, 0);
+        end
+        
+    catch error_msg
+        % Display a warning with error message
+        if showWarnings
+            warning(['Evaluation of likelihood failed because: ' error_msg.message]);
+            display(['Last Error in function ' error_msg.stack(1).name ', line ' ...
+                num2str(error_msg.stack(1).line) ', file ' error_msg.stack(1).file '.']);
+        end
+        if countErrors
+            % Increase error count
+            error_count = error_count + 1;
+        end
+        
+        % Derive output
+        switch nargout
+            case {0,1}
+                varargout = {inf};
+            case 2
+                if strcmp(optimizer, 'lsqnonlin')
+                    varargout = {inf(size(J)), zeros(length(J), length(freeInd))};
+                else
+                    varargout = {inf, zeros(length(freeInd),1)};
+                end
+            case 3
+                if strcmp(optimizer, 'lsqnonlin')
+                    varargout = {inf(size(J)), zeros(length(J), length(freeInd)), inf};
+                else
+                    varargout = {inf,zeros(length(freeInd),1),zeros(length(freeInd))};
+                end
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/optimalNoise.m b/Requirements/PESTO-1.1.0/private/optimalNoise.m
new file mode 100644
index 0000000000000000000000000000000000000000..683563621cbc7c7a5c9103f068fff41e2b790f7f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/optimalNoise.m
@@ -0,0 +1,96 @@
+function [noise] = optimalNoise(varargin)
+% optimalNoise() computes the optimal the noise parameters.
+%
+% USAGE:
+% * [noise] = optimalNoise(iy,simulation,D,options,s,scale)
+%
+% Parameters
+%  iy: index of observable for which the optimal noise parameter
+%  for other inputs see logLikelihoodHierarchical.m and optimalScaling.m
+%
+% Return values:
+%   noise: optimal variance (for Gaussian noise) or scale parameter 
+%           (for Laplace noise) corresponding to observable i
+
+%% input assignment
+iy = varargin{1};
+simulation = varargin{2};
+D = varargin{3};
+options = varargin{4};
+s = varargin{5};
+if nargin == 6
+    scale = varargin{6};
+else
+    scale = 'lin';
+end
+
+%% determine scenario
+if(strcmp(options.noise{iy(1)},'multiple') && ...
+        strcmp(options.scaling{iy(1)},'single'))
+    warning(['In options.(',num2str(iy(1)),...
+        ') you combined noise:multiple and scaling:single which is not valid.']);
+end
+
+%% initialization of dimensions
+n_e = size(D,2); %number of experiments
+
+%% computation of optimal noise
+try
+    switch options.noise{iy(1)}
+        case 'multiple'
+            noisei = zeros(1,1,1);
+            mult_fact = zeros(1,1,1);
+        case 'single'
+            noisei = zeros(1,1);
+            mult_fact = zeros(1,1);
+    end
+    for j = 1:n_e
+        switch options.noise{iy(1)}
+            case 'multiple'
+                mult_fact = mult_fact + sum(sum(~isnan(D(j).my(:,iy,:)),1),2);
+            case 'single'
+                mult_fact = mult_fact + sum(sum(sum(~isnan(D(j).my(:,iy,:)),1),3));
+        end
+        switch scale
+            case 'log'
+                y_sh = bsxfun(@minus,log(D(j).my(:,iy,:)),...
+                    log(bsxfun(@times,s(:,iy,1:size(D(j).my,3),j),simulation(j).y(:,iy))));
+            case 'log10'
+                y_sh = bsxfun(@minus,log10(D(j).my(:,iy,:)),...
+                    log10(bsxfun(@times,s(:,iy,1:size(D(j).my,3),j),simulation(j).y(:,iy))));
+            case 'lin'
+                y_sh = bsxfun(@minus,D(j).my(:,iy,:),...
+                    bsxfun(@times,s(:,iy,1:size(D(j).my,3),j),simulation(j).y(:,iy)));
+        end
+        switch options.distribution
+            case 'normal'
+                %computing the optimal variance parameter
+                switch options.noise{iy(1)}
+                    case 'multiple'
+                        noisei = noisei + sum(nansum(bsxfun(@power,y_sh,2),1),2);
+                    case 'single'
+                        noisei = noisei + sum(sum(nansum(bsxfun(@power,y_sh,2),1),3));
+                end
+            case 'laplace'
+                %computing the optimal scale parameter
+                switch options.noise{iy(1)}
+                    case 'multiple'
+                        noisei = noisei + sum(nansum(abs(y_sh),1),2);
+                    case 'single'
+                        noisei = noisei + sum(sum(nansum(abs(y_sh),1),3));
+                end
+        end
+    end
+    noise = bsxfun(@rdivide,noisei,mult_fact);
+    if strcmp(options.noise{iy(1)},'single')
+        noise = bsxfun(@times,ones(1,1,options.max_repl),noise);
+    end
+catch
+    error(['Dimensions of data sharing parameters need to match when using multiple noise parameters for the replicates.']);
+end
+
+% Note: If for all j there are Nans in D(j).my(:,i,r)
+% sir and noiseir are NaN aswell.
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/private/optimalScaling.m b/Requirements/PESTO-1.1.0/private/optimalScaling.m
new file mode 100644
index 0000000000000000000000000000000000000000..f2fb2ed8439a028e23b23345ff5e7c7db3266f4a
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/optimalScaling.m
@@ -0,0 +1,288 @@
+function [varargout] = optimalScaling(varargin)
+% optimalScaling() computes the optimal scaling parameters.
+%
+% USAGE:
+% * [...]  = optimalScaling(iy,simulation,D,options)
+% * [...]  = optimalScaling(iy,simulation,D,options,scale)
+% * [s,ds] = optimalScaling(...)
+%
+% Parameters:
+%  iy: observable index for which the scaling parameter and the
+%      noise should be computed
+%  for the other inputs see loglikelihoodHierarchical.m
+%
+% Return values:
+%   s: (1 x # observables x max # replicates x # experiments/conditions)
+%       the optimal scaling parameter for observable i
+%   ds: (1 x 1 x n_theta x n_r) matrix with the derivatives of the scaling parameters
+
+iy = varargin{1};
+simulation = varargin{2};
+D = varargin{3};
+options = varargin{4};
+
+if nargin == 5
+    scale = varargin{5};
+else
+    scale = 'lin';
+end
+
+%% CHECK SCENARIO
+for iiy = 1:numel(iy)
+    if(strcmp(options.noise{iy(iiy)},'multiple') && ...
+            strcmp(options.scaling{iy(iiy)},'single'))
+        error(['In options.(',num2str(iy(iiy)),...
+            ') you combined noise:multiple and scaling:single which is not valid.']);
+    end
+end
+% all data points that are used for the calculation of a scaling
+% parameters need to have the same noise parameter!
+
+scaling = options.scaling{iy(1)};
+noise = options.noise{iy(1)};
+for iiy = 1:numel(iy)
+    if ~strcmp(options.noise{iy(iiy)},noise) || ...
+            ~strcmp(options.scaling{iy(iiy)},scaling)
+        if ~strcmp(options.scaling{iy(iiy)},'absolute')
+            error('different assumptions')
+        end
+    end
+end
+
+%% INITIALIZATION OF DIMENSIONS
+n_e = size(D,2); %number of experiments
+n_r = size(D(1).my,3); %number of replicates
+if nargout > 1
+    n_theta = size(simulation(1).sy,3); %number of parameters
+end
+%% COMPUTATION OF SCALING PARAMETER AND ITS GRADIENT
+try
+    switch scaling
+        case 'absolute'
+            s = ones(1,1,n_r);
+            if nargout > 1
+                ds = zeros(1,1,n_theta,options.max_repl);
+            end
+        case 'multiple'
+            switch options.distribution
+                case 'normal'
+                    switch scale
+                        case 'lin'
+                            sir_z = zeros(1,1,n_r);
+                            sir_n = zeros(1,1,n_r);
+                            %calculating the optimal scaling parameters s_ir
+                            for j = 1:n_e %loop over all experiments
+                                sir_z = sir_z + nansum(nansum(bsxfun(@times,D(j).my(:,iy,:),simulation(j).y(:,iy)),1),2);
+                                sir_n = sir_n + sum(sum(bsxfun(@power,bsxfun(@times,~isnan(D(j).my(:,iy,:)),...
+                                    simulation(j).y(:,iy)),2),1),2);
+                            end
+                            s = bsxfun(@rdivide,sir_z,sir_n);
+                        case {'log','log10'}
+                            logmy = zeros(1,1,n_r);
+                            logy = zeros(1,1,n_r);
+                            multfact = 0;
+                            for j = 1:n_e
+                                logmy = logmy + nansum(nansum(log(D(j).my(:,iy,:)),1),2);
+                                logy  = logy + sum(sum(bsxfun(@times,~isnan(D(j).my(:,iy,:)),...
+                                    log(simulation(j).y(:,iy))),1),2);
+                                multfact = multfact + sum(sum(~isnan(D(j).my(:,iy,:)),1),2);
+                            end
+                            s = exp(bsxfun(@rdivide,logmy-logy,multfact));
+                    end
+                case 'laplace'
+                    for ir = 1:n_r
+                        candidates = [];
+                        grad_candidates = [];
+                        for j = 1:n_e
+                            for iiy = 1:numel(iy)
+                                for it = 1:size(D(j).my,1)
+                                    if ~isnan(D(j).my(it,iy(iiy),ir))
+                                        candidates = [candidates;bsxfun(@rdivide,...
+                                            D(j).my(it,iy(iiy),ir),simulation(j).y(it,iy(iiy)))];
+                                        if nargout > 1
+                                            grad_candidates = [grad_candidates;-bsxfun(@rdivide,...
+                                                simulation(j).sy(it,iy(iiy),:),simulation(j).y(it,iy(iiy)))];
+                                        end
+                                    end
+                                end
+                            end
+                        end
+                        if isempty(candidates)
+                            s(1,1,ir) = nan;
+                        else
+                            [candidates,I] = sort(candidates); 
+                            middle = (candidates(1:end-1,:,:)+candidates(2:end,:,:))/2;
+                            dJds = zeros(size(middle));
+                            for cand = 1:size(dJds,1) 
+                                for j = 1:n_e
+                                    for iiy = 1:numel(iy)
+                                        for it = 1:size(D(j).my,1)
+                                            if ~isnan(D(j).my(it,iy(iiy),ir))
+                                                switch scale
+                                                    case 'lin'
+                                                        yh_s = bsxfun(@minus,bsxfun(@rdivide,...
+                                                            D(j).my(it,iy(iiy),ir),simulation(j).y(it,iy(iiy))),middle(cand,:,:));
+                                                        dJds(cand,1) = dJds(cand,1) - nansum(bsxfun(@times,...
+                                                            abs(simulation(j).y(it,iy(iiy))),sign(yh_s)),1);
+                                                    case 'log'
+                                                        yh_s = bsxfun(@minus,log(D(j).my(it,iy(iiy),ir)),...
+                                                            log(middle(cand,:,:)*simulation(j).y(it,iy(iiy))));
+                                                        dJds(cand,1) = dJds(cand,1) - nansum(bsxfun(@ldivide,...
+                                                            middle(cand,:,:),sign(yh_s)),1);
+                                                    case 'log10'
+                                                        yh_s = bsxfun(@minus,log(D(j).my(it,iy(iiy),ir)),...
+                                                            log(middle(cand,:,:)*simulation(j).y(it,iy(iiy))));
+                                                        dJds(cand,1) = dJds(cand,1) - nansum(bsxfun(@ldivide,...
+                                                            middle(cand,:,:),sign(yh_s)/log(10)),1);
+                                                end
+                                            end
+                                        end
+                                    end
+                                end
+                            end
+                            s_opt_r = find(dJds==0);
+                            if isempty(s_opt_r)
+                                s_opt_r = find(bsxfun(@times,dJds(1:end-1,1)<= 0,dJds(2:end,1,1)>=0))+1;
+                            end
+                            if ~isempty(s_opt_r)
+                                s(1,1,ir) = candidates(s_opt_r);
+                            else
+                                if dJds(1,1) > 0
+                                    s_opt_r = 1;
+                                else
+                                    s_opt_r = size(dJds,1);
+                                end
+                                s(1,1,ir) = candidates(s_opt_r);
+                            end
+                            
+                            if nargout > 1
+                                grad_candidates = grad_candidates(I,:);
+                                ds_i = s(1,1,ir)*squeeze(grad_candidates(s_opt_r,:,:));
+                                ds(1,1,:,ir) = ds_i';
+                            end
+                        end
+                    end
+            end
+        case 'single'
+            switch options.distribution
+                case 'normal'
+                    switch scale
+                        case 'lin'
+                            si_z = zeros(1,1);
+                            si_n = zeros(1,1);
+                            for j = 1:n_e
+                                %calculating the optimal scaling parameters c_ir
+                                si_z = si_z + sum(sum(nansum(bsxfun(@times,D(j).my(:,iy,:),simulation(j).y(:,iy)),1),3));
+                                si_n = si_n + sum(sum(sum(bsxfun(@power,bsxfun(@times,~isnan(D(j).my(:,iy,:)),...
+                                    simulation(j).y(:,iy)),2),1),3));
+                            end
+                            s = bsxfun(@times,ones(1,1,n_r),bsxfun(@rdivide,si_z,si_n));
+                        case {'log','log10'}
+                            logmy = zeros(1,1);
+                            logy = zeros(1,1);
+                            multfact = 0;
+                            for j = 1:n_e
+                                logmy = logmy + sum(sum(sum(nansum(log(D(j).my(:,iy,:))))));
+                                logy  = logy + sum(sum(sum((bsxfun(@times,~isnan(D(j).my(:,iy,:)),...
+                                    log(simulation(j).y(:,iy)))))));
+                                multfact = multfact + sum(sum(sum(~isnan(D(j).my(:,iy,:)))));
+                            end
+                            s = bsxfun(@times,ones(1,1,n_r),exp((logmy-logy)/multfact));
+                    end
+                case 'laplace'
+                    candidates = [];
+                    grad_candidates = [];
+                    for j = 1:n_e
+                        for iiy = 1:numel(iy)
+                            for it = 1:size(D(j).my,1)
+                                for ir = 1:n_r
+                                    if ~isnan(D(j).my(it,iy(iiy),ir))
+                                        candidates = [candidates;reshape(bsxfun(@rdivide,...
+                                            D(j).my(it,iy(iiy),ir),simulation(j).y(it,iy(iiy))),[],1)];
+                                        if nargout > 1
+                                            grad_candidates = [grad_candidates;repmat(-bsxfun(@rdivide,...
+                                                simulation(j).sy(it,iy(iiy),:),simulation(j).y(it,iy(iiy))),[n_r,1])];
+                                        end
+                                    end
+                                end
+                            end
+                        end
+                        
+                    end
+                    if isempty(candidates)
+                        s = nan(1,1,n_r);
+                        if nargout > 1
+                            ds = nan(1,1,n_theta,n_r);
+                        end
+                    else
+                        [candidates,I] = sort(candidates); %candidates for c_ir, should be n_e*n_y*n_t
+                        middle = (candidates(1:end-1,:,:)+candidates(2:end,:,:))/2;
+                        dJds = zeros(size(middle));
+                        for cand = 1:size(dJds,1)
+                            for j = 1:n_e
+                                for iiy = 1:numel(iy)
+                                    for it = 1:size(D(j).my,1)
+                                        for ir = 1:n_r
+                                            if ~isnan(D(j).my(it,iy(iiy),ir))
+                                                switch scale
+                                                    case 'lin'
+                                                        yh_s = bsxfun(@minus,bsxfun(@rdivide,...
+                                                            D(j).my(it,iy(iiy),ir),simulation(j).y(it,iy(iiy))),middle(cand,:,:));
+                                                        dJds(cand,1) = dJds(cand,1) - sum(nansum(bsxfun(@times,...
+                                                            abs(simulation(j).y(it,iy(iiy))),sign(yh_s)),1),3);
+                                                    case 'log'
+                                                        yh_s = bsxfun(@minus,log(D(j).my(it,iy(iiy),ir)),...
+                                                            log(middle(cand,:,:)*simulation(j).y(it,iy(iiy))));
+                                                        dJds(cand,1) = dJds(cand,1) - sum(nansum(bsxfun(@ldivide,...
+                                                            middle(cand,:,:),sign(yh_s)),1),3);
+                                                    case 'log10'
+                                                        yh_s = bsxfun(@minus,log(D(j).my(it,iy(iiy),ir)),...
+                                                            log(middle(cand,:,:)*simulation(j).y(it,iy(iiy))));
+                                                        dJds(cand,1) = dJds(cand,1) - sum(nansum(bsxfun(@ldivide,...
+                                                            middle(cand,:,:),sign(yh_s)/log(10)),1),3);
+                                                end
+                                            end
+                                        end
+                                    end
+                                end
+                            end
+                        end
+                        if ~isempty(dJds)
+                            s_opt = find(dJds==0);
+                            if isempty(s_opt)
+                                s_opt = find(bsxfun(@times,dJds(1:end-1,1)<= 0,dJds(2:end,1)>=0))+1;
+                            end
+                            if isempty(s_opt) && dJds(1) > 0
+                                s_opt = 1;
+                            end
+                            s = bsxfun(@times,ones(1,1,n_r),candidates(s_opt));
+                            if nargout > 1
+                                grad_candidates = grad_candidates(I,:);
+                                ds_i = s(1,1,1)*squeeze(grad_candidates(s_opt,:,:));
+                                for ir = 1:n_r
+                                    ds(1,1,:,ir) = ds_i';
+                                end
+                            end
+                        end
+                    end
+            end
+    end
+catch
+    error(['error for calculation of scaling parameter of observable ' num2str(iy)]);
+end
+
+if(any(s == 0))
+    warning(['At least one of the computed scaling parameters for observable is 0.']);
+end
+
+switch nargout
+    case{0,1}
+        varargout{1} = s;
+    case 2
+        varargout{1} = s;
+        varargout{2} = ds;
+end
+
+% Note: If for all j there are Nans in D(j).my(:,i,r)
+% sir and sigma2ir are NaN as well.
+
diff --git a/Requirements/PESTO-1.1.0/private/ordstr.m b/Requirements/PESTO-1.1.0/private/ordstr.m
new file mode 100644
index 0000000000000000000000000000000000000000..4576211f4a3c4335f373b270c11c892f4c0d389c
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/ordstr.m
@@ -0,0 +1,13 @@
+function ord = ordstr(number)
+switch(number)
+    case 1
+        ord = 'st';
+    case 2
+        ord = 'nd';
+    case 3
+        ord = 'rd';
+    otherwise
+        ord = '-th';
+end
+
+end
diff --git a/Requirements/PESTO-1.1.0/private/parametersSanityCheck.m b/Requirements/PESTO-1.1.0/private/parametersSanityCheck.m
new file mode 100644
index 0000000000000000000000000000000000000000..523b13a5a8cf3b3ad50e7624b4277f2fe1cc91e5
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/parametersSanityCheck.m
@@ -0,0 +1,61 @@
+function [ parameters ] = parametersSanityCheck( parameters )
+% parametersAreValid Checks if the provided parameters are okay.
+
+% Check parameters:
+if ~isfield(parameters,'min') || ~isfield(parameters,'max')
+    error('Algorithm requires lower and upper bounds');
+else
+    parameters.min = parameters.min(:);
+    parameters.max = parameters.max(:);
+end
+
+if length(parameters.min) ~= length(parameters.max)
+    error('Dimension of parameters.min and parameters.max does not agree.');
+else
+    if max(parameters.min >= parameters.max)
+        error('There exists at least one i for which parameters.min(i) >= parameters.max(i).');
+    end
+end
+
+if(any(isnan(parameters.min)) || any(isinf(parameters.min)))
+   error('parameters.min contains NaN of Inf values.'); 
+end
+
+if(any(isnan(parameters.max)) || any(isinf(parameters.max)))
+   error('parameters.max contains NaN of Inf values.'); 
+end
+
+if ~isfield(parameters,'number')
+    parameters.number = length(parameters.min);
+else
+    if parameters.number ~= length(parameters.min)
+        error('Dimension mismatch: parameters.number ~= length(parameters.min).');
+    end
+end
+
+if isfield(parameters,'guess')
+    if ~isempty(parameters.guess);
+        if size(parameters.guess,1) ~= length(parameters.max)
+            error('Dimension of parameters.guess does not agree with dimesion of parameters.min and .max.');
+        end
+    end
+end
+
+constr.A = [];
+constr.b = [];
+constr.Aeq = [];
+constr.beq = [];
+
+if isfield(parameters,'constraints')
+    parameters.constraints = setdefault(parameters.constraints,constr);
+else
+    parameters.constraints = constr;
+end
+
+% Check initial guess
+if ~isfield(parameters,'guess')
+    parameters.guess = [];
+end
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/private/performDRAM.m b/Requirements/PESTO-1.1.0/private/performDRAM.m
new file mode 100644
index 0000000000000000000000000000000000000000..9606a5e302d2a6a818d596879f0d3ef45bf71de8
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performDRAM.m
@@ -0,0 +1,122 @@
+function res = performDRAM( logPostHandle, par, opt )
+   
+   % performDRAM.m uses an Delayed Rejection Adaptive Metropolis algorithm to sample from an objective function
+   % 'logPostHandle' by using the DRAM library routine tooparameters.minox.
+   % It provides the interface to the MATLAB tooparameters.minox for
+   % delayed rejection adaptive metropolis sampling developed by
+   % H. Haario et al. (2006), DRAM: Efficient adaptive MCMC,
+   % Stat. Comp., 4(16):339-354.
+   %
+   % The options 'opt' cover:
+   % opt.theta0                  : The inital parameter points for each of the
+   %                               tempered chains
+   % opt.sigma0                  : The inital proposal covariance matrix of
+   %                               the parameters
+   % par.min and par.max         : The lower and upper bounds for the
+   %                               parameters. Proposed points outside this
+   %                               area are getting rejected
+   % par.number                  : Number of parameters
+   % opt.nIterations             : Number of desired sampling iterations
+   % opt.DRAM.regFactor          : This factor is used for regularization in
+   %                               cases where the single-chain proposal
+   %                               covariance matrices are ill conditioned.
+   %                               Larger values equal stronger
+   %                               regularization.
+   % opt.DRAM.nTry               : The number of tries in the delayed
+   %                               rejection scheme
+   % opt.DRAM.verbosityMode      : Defines the level of verbosity 'silent', 'visual',
+   %                               'debug' or 'text'
+   % opt.DRAM.adaptionInterval   : Updates the proposal density only every opt.DRAM.adaptionInterval
+   %                               time
+   %
+   %
+   % It returns a struct 'res' covering:
+   % res.par               : The Markov chain of the parameters for each temperature
+   % res.logPost           : The objective value corresponding to parameter
+   %                         vector for each temperature
+   %
+   %
+   % Written by Benjamin Ballnus 2/2017
+   
+   
+   % Initialization
+   nPar = par.number;
+   
+   dramOptions.adaptint    = opt.DRAM.adaptionInterval;
+   dramOptions.method      = 'dram';
+   dramOptions.nsimu       = opt.nIterations;
+   dramOptions.ntry        = opt.DRAM.nTry;
+   dramOptions.printint    = 0;
+   dramOptions.qcov        = opt.sigma0;
+   dramOptions.stats       = 0;
+   dramOptions.updatesigma = 0;
+   dramOptions.waitbar     = 0;
+   dramOptions.qcov_adjust = opt.DRAM.regFactor;
+   dramOptions.initqcovn   = 1;
+   
+   % Build the interface
+   params = {};
+   for i = 1:nPar
+      params{i} = {['Parameter ' num2str(i)],...
+         opt.theta0(i),...
+         par.min(i),...
+         par.max(i)};
+   end
+   
+   model.ssfun = logPostHandle;
+   model.sigma2 = 1;
+   model.N = 1;
+   
+   % Visularization of progress
+   switch opt.DRAM.verbosityMode
+      case 'silent'
+         dramOptions.verbosity = 0;
+      case 'text'
+         dramOptions.verbosity = 1;
+      case 'debug'
+         dramOptions.verbosity = 2;
+      case 'visual'
+         dramOptions.verbosity = 0;
+         dramOptions.waitbar   = 1;
+   end
+   
+   if ~exist('mcmcrun.m', 'file')
+      if ~exist('DRAM', 'dir')
+         error('The file mcmcrun  and the folder DRAM were not found in the MATLAB search path. It seems like the DRAM toolbox is not properly installed. DRAM can be obtained from http://helios.fmi.fi/~lainema/mcmc/ .');
+      else
+         error('The file mcmcrun was not found in the MATLAB search path, although a DRAM folder is there. Maybe the DRAM toolbox is not properly installed. DRAM can be obtained from http://helios.fmi.fi/~lainema/mcmc/ .');
+      end
+   end
+   
+   % Suit the number of inputs to the DRAM toolbox format
+   model.ssfun = @(theta,dummy) -model.ssfun(theta);
+   
+   % Perform the sampling
+   try
+      [res, Theta, ~, Obj] = mcmcrun(model, [], params, dramOptions);
+   catch ME
+      warning('There was a problem with calling the DRAM toolbox, maybe it is not properly installed. The original error message was:');
+      rethrow(ME);
+   end
+   
+   % Reassignment
+   res.logPost = -0.5 * Obj;
+   res.par     = Theta';
+   
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/private/performMALA.m b/Requirements/PESTO-1.1.0/private/performMALA.m
new file mode 100644
index 0000000000000000000000000000000000000000..23a2e440bfac7dd1191dddd9ee23fc7603113fa2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performMALA.m
@@ -0,0 +1,178 @@
+function res = performMALA( logPostHandle, par, opt )
+   
+   % performPT.m uses single-chain MALA to sample from the posterior given by
+   % 'logPostHandle' as a function of the parameters. MALA uses gradients and hessian to improve
+   % the convergence rate. 'logPostHandle' must return the cost function
+   % value, gradient and hessian at the current parameter point.
+   %
+   % The options 'opt' cover:
+   % opt.theta0                  : The initial parameter points for each of the
+   %                               tempered chains
+   % par.min and par.max         : The lower and upper bounds for the
+   %                               parameters. Proposed points outside this
+   %                               area are getting rejected
+   % par.number                  : Number of parameters
+   % opt.nIterations             : Number of desired sampling iterations
+   % opt.MALA.regFactor          : This factor is used for regularization in
+   %                               cases where the proposal
+   %                               covariance matrices are ill conditioned.
+   %                               Larger values equal stronger
+   %                               regularization.
+   %
+   %
+   % It returns a struct 'res' covering:
+   % res.par               : The Markov chain of the parameters
+   % res.logPost           : The objective value corresponding to parameter
+   %                         vector
+   % res.acc               : The cumulative acceptance rate of the chains
+   %
+   %
+   % Written by Benjamin Ballnus 2/2017
+   
+   
+   % Initialization
+   nIter = opt.nIterations;
+   theta0 = opt.theta0;
+   thetaMin = par.min;
+   thetaMax = par.max;
+   regFactor = opt.MALA.regFactor;
+   nPar = par.number;
+   
+   res.par = nan(nPar, nIter);
+   res.logPost = nan(nIter, 1);
+   res.acc = nan(nIter, 1);
+   res.sigmaScale = nan(nIter, 1);
+   
+   acc = 0;
+   theta = theta0;
+   
+   sigmaProp = nan(nPar,nPar);
+   logPostProp = nan(1,1);
+   
+   % Testing of starting point
+   [logPost,G,H] = logPostHandle(theta0);
+   if logPost < inf && ~isnan(logPost)
+      [~,sigma] = getProposal(theta0,G,H,regFactor,thetaMin,thetaMax);
+   else
+      error('log-posterior undefined at initial point.');
+   end
+   
+   msg = '';
+   tic; dspTime = toc;   
+   
+   % Perform MCMC
+   for i = 1:(nIter)
+      
+      % Reporting Progress
+      switch opt.mode
+         case {'visual','text'}
+            if toc-dspTime > 0.5
+               fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+               msg = ['Progress: ' num2str(i/(nIter)*100,'%2.2f') ' %%\n'];
+               fprintf(1,msg);
+               dspTime = toc;
+            end
+         case 'silent'
+      end
+      
+      % Propose
+      thetaProp = mvnrnd(theta,sigma)';
+      
+      % Check for Bounds
+      if (sum(thetaProp < thetaMin) + sum(thetaProp > thetaMax)) == 0
+         
+         inbounds = 1;
+         
+         % Compute log-posterior, gradient and hessian
+         [logPostProp,GProp,HProp] = logPostHandle(thetaProp);
+         
+         % Update mu and Sigma of proposal
+         if logPostProp < inf
+            [~,sigmaProp] = getProposal(thetaProp,GProp,HProp,regFactor,thetaMin,thetaMax);
+         end
+         
+         % Regularization of proposal sigma
+         [~,p] = cholcov(sigmaProp,0);
+         if p ~= 0
+            sigmaProp = sigmaProp + regFactor*eye(nPar);
+            sigmaProp = (sigmaProp+sigmaProp')/2;
+            [~,p] = cholcov(sigmaProp,0);
+            if p ~= 0
+               sigmaProp = sigmaProp + max(max(sigmaProp))/1000*eye(nPar);
+               sigmaProp = (sigmaProp+sigmaProp')/2;
+            end
+         end
+         
+      else
+         inbounds = 0;
+      end
+      
+      % Transition and Acceptance Probabilities
+      if (inbounds == 1) && (logPostProp > -inf)
+         logTransFor = logmvnpdf(theta, thetaProp, sigma);
+         logTransBack = logmvnpdf(thetaProp, theta, sigmaProp);
+         pAcc = min(0, logPostProp - logPost + logTransBack - logTransFor);
+      else
+         pAcc = -inf;
+      end
+      
+      % Accept or reject
+      if log(rand) <= pAcc
+         acc             = acc + 1;
+         theta           = thetaProp;
+         logPost         = logPostProp;
+         sigma           = sigmaProp;
+      end
+      
+      % Regularization of Sigma
+      [~,p] = cholcov(sigma,0);
+      if p ~= 0
+         sigma = sigma + regFactor*eye(nPar);
+         sigma = (sigma+sigma')/2;
+         [~,p] = cholcov(sigma,0);
+         if p ~= 0
+            sigma = sigma + max(max(sigma))*eye(nPar);
+            sigma = (sigma+sigma')/2;
+         end
+      end
+      
+      % Store iteration
+      res.par(:,i,:) = theta;
+      res.logPost(i,:) = logPost;
+      res.acc(i,:) = 100*acc/i;
+   end
+end
+
+
+
+
+%% Proposal calculating function
+% This function determines the mean and covariance of the MALA proposal and
+% regularised / adaptive variants of it.
+%   theta ... current parameter vector
+%   grad ... gradient of log-posterior
+%   H ... hessian or hessian approximation of log-posterior
+%   beta ... regularisation parameter
+%   lb ... lower bound for theta, needed for MALA some day...
+%   ub ... upper bound for theta, needed for MALA some day...
+
+function [mu,Sigma] = getProposal(theta, grad, H, beta, lb, ub)
+   
+   % Regularisation
+   [~,p] = cholcov(-H,0);
+   if p ~= 0
+      k = 0;
+      while p ~= 0
+         H_k = H - 10^k*beta*eye(length(theta));
+         [~,p] = cholcov(-H_k,0);
+         k = k+1;
+      end
+      H = H_k;
+   end
+   
+   % Newton step
+   Sigma = -inv(H);
+   Sigma = 0.5*(Sigma+Sigma');
+   mu = theta - H\grad;
+   
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationBobyqa.m b/Requirements/PESTO-1.1.0/private/performOptimizationBobyqa.m
new file mode 100644
index 0000000000000000000000000000000000000000..645dfec7bb7ebc8330ebe6ee613cf099f97fac68
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationBobyqa.m
@@ -0,0 +1,40 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+    = performOptimizationBobyqa(parameters, negLogPost, par0, options)
+
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    optionsBobyqa = options.localOptimizerOptions;
+    
+    % Set bounds
+    lowerBounds = parameters.min;
+    upperBounds = parameters.max;
+    
+    % run Bobyqa
+    [par_opt, negLogPost_opt, exitflag, output] = bobyqa(...
+        negLogPost,...
+        par0,...
+        lowerBounds(freePars),...
+        upperBounds(freePars),...
+        optionsBobyqa);
+    
+    % Assignment of results
+    n_objfun  = output.funcCount;
+    n_iter    = output.funcCount;
+    par_opt(freePars) = par_opt;
+    par_opt(options.fixedParameters) = options.fixedParameterValues;
+    
+    % Assignment of gradient and Hessian
+    try
+        [~, gradient_opt, hessian_opt] = negLogPost(par_opt);
+        hessian_opt(freePars,freePars) = hessian_opt;
+        hessian_opt(options.fixedParameters,options.fixedParameters) = nan;
+        gradient_opt(freePars) = gradient_opt;
+        gradient_opt(options.fixedParameters) = nan;
+    catch
+        warning('Could not compute Hessian and gradient at optimum after optimization.');
+        if (options.objOutNumber == 3)
+            warning('options.objOutNumber is set to 3, but your objective function can not provide 3 outputs. Please set objOutNumber accordingly!');
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationCoordinateSearch.m b/Requirements/PESTO-1.1.0/private/performOptimizationCoordinateSearch.m
new file mode 100644
index 0000000000000000000000000000000000000000..72b2a65b74642235cb0c6c3345348fc102df82c1
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationCoordinateSearch.m
@@ -0,0 +1,47 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+    = performOptimizationCoordinateSearch(parameters, negLogPost, par0, options)
+
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    optionsCS.TolX        = options.localOptimizerOptions.TolX;
+    optionsCS.TolFun      = options.localOptimizerOptions.TolFun;
+    optionsCS.MaxIter     = options.localOptimizerOptions.MaxIter;
+	optionsCS.MaxFunEvals = options.localOptimizerOptions.MaxFunEvals;
+    
+	if (isfield(options.localOptimizerOptions,'Barrier') && ~isempty(options.localOptimizerOptions.Barrier))
+		optionsCS.Barrier = options.localOptimizerOptions.Barrier;
+    end
+    
+    % Set bounds
+    lowerBounds = parameters.min;
+    upperBounds = parameters.max;
+  
+    % Run CS
+    [par_opt, negLogPost_opt, exitflag, output] = coordinateSearch(...
+        negLogPost,...
+        par0,...
+        lowerBounds(freePars),...
+        upperBounds(freePars),...
+        optionsCS);
+    
+    % Assignment of results
+    n_objfun = output.funcCount;
+    n_iter   = output.iterations;
+    par_opt(freePars) = par_opt;
+    par_opt(options.fixedParameters) = options.fixedParameterValues;
+    
+    % Assignment of gradient and Hessian
+    try
+        [~, gradient_opt, hessian_opt] = negLogPost(par_opt);
+        hessian_opt(freePars,freePars) = hessian_opt;
+        hessian_opt(options.fixedParameters,options.fixedParameters) = nan;
+        gradient_opt(freePars) = G_opt;
+        gradient_opt(options.fixedParameters) = nan;
+    catch
+        warning('Could not compute Hessian and gradient at optimum after optimization.');
+        if (options.objOutNumber == 3)
+            warning('options.objOutNumber is set to 3, but your objective function can not provide 3 outputs. Please set objOutNumber accordingly!');
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationDhc.m b/Requirements/PESTO-1.1.0/private/performOptimizationDhc.m
new file mode 100644
index 0000000000000000000000000000000000000000..3646cd0d3308da3cb336da08a15692e5547b3db5
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationDhc.m
@@ -0,0 +1,40 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+    = performOptimizationDhc(parameters, negLogPost, par0, options)
+       
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    optionsDHC = options.localOptimizerOptions;
+    
+    % Set bounds
+    lowerBounds = parameters.min;
+    upperBounds = parameters.max;
+  
+    % run DHC
+    [par_opt, negLogPost_opt, exitflag, output] = dynamicHillClimb(...
+        negLogPost,...
+        par0,...
+        lowerBounds(freePars),...
+        upperBounds(freePars),...
+        optionsDHC);
+    
+    % Assignment of results
+    n_objfun  = output.funcCount;
+    n_iter    = output.iterations;
+    par_opt(freePars) = par_opt;
+    par_opt(options.fixedParameters) = options.fixedParameterValues;
+    
+    % Assignment of gradient and Hessian
+    try
+        [~, gradient_opt, hessian_opt] = negLogPost(par_opt);
+        hessian_opt(freePars,freePars) = hessian_opt;
+        hessian_opt(options.fixedParameters,options.fixedParameters) = nan;
+        gradient_opt(freePars) = gradient_opt;
+        gradient_opt(options.fixedParameters) = nan;
+    catch
+        warning('Could not compute Hessian and gradient at optimum after optimization.');
+        if (options.objOutNumber == 3)
+            warning('options.objOutNumber is set to 3, but your objective function can not provide 3 outputs. Please set objOutNumber accordingly!');
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationFmincon.m b/Requirements/PESTO-1.1.0/private/performOptimizationFmincon.m
new file mode 100644
index 0000000000000000000000000000000000000000..28fd21650438359aa85ea9c4238217c6e16c8560
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationFmincon.m
@@ -0,0 +1,57 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+    = performOptimizationFmincon(parameters, negLogPost, par0, options)
+
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    
+    % Set nonlinear constraints
+    if isfield(parameters,'nonlcon')
+        nonlcon = parameters.nonlcon;
+    else
+        nonlcon = [];
+    end
+    
+    % Adapt constraints according to fixed parameters
+    if ~isempty(parameters.constraints.A)
+        freeCon.A = parameters.constraints.A(:,freePars);
+        freeCon.b = parameters.constraints.b - parameters.constraints.A(:,options.fixedParameters) * options.fixedParameterValues;
+    else
+        freeCon.A = [];
+        freeCon.b = [];
+    end
+    if ~isempty(parameters.constraints.Aeq)
+        freeCon.Aeq = parameters.constraints.Aeq(:,freePars);
+        freeCon.beq = parameters.constraints.beq - parameters.constraints.Aeq(:,options.fixedParameters) * options.fixedParameterValues;
+    else
+        freeCon.Aeq = [];
+        freeCon.beq = [];
+    end
+    
+    [par_opt, negLogPost_opt, exitflag, results_fmincon, ~, gradient_opt, hessian_opt] = ...                                              
+        fmincon(negLogPost, ...  % negative log-likelihood function
+        par0(freePars), ...    % initial parameter
+        freeCon.A, freeCon.b, ... % linear inequality constraints
+        freeCon.Aeq, freeCon.beq, ... % linear equality constraints
+        parameters.min(freePars), ...     % lower bound
+        parameters.max(freePars), ...     % upper bound
+        nonlcon, ...            % nonlinear constraints
+        options.localOptimizerOptions);   % options
+
+    % Assignment of disgnosis
+    n_objfun = results_fmincon.funcCount;
+    n_iter = results_fmincon.iterations;
+    
+    % Adapt results for fixed parameter values
+    par_opt(freePars) = par_opt;
+    par_opt(options.fixedParameters) = options.fixedParameterValues;
+    
+    % Assignment of gradient and Hessian
+    if isempty(hessian_opt)
+        hessian_opt = nan(parameters.number);
+    elseif max(hessian_opt(:)) == 0
+        if strcmp(options.localOptimizerOptions.Hessian,'on')
+            [~,~,hessian_opt] = negLogPost(par_opt);
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationLsqnonlin.m b/Requirements/PESTO-1.1.0/private/performOptimizationLsqnonlin.m
new file mode 100644
index 0000000000000000000000000000000000000000..f0bc4246ffd7f3a09cd0995c953710a565289170
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationLsqnonlin.m
@@ -0,0 +1,39 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter, logPostOffset] ...
+    = performOptimizationLsqnonlin(parameters, negLogPost, par0, options)
+
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    options.localOptimizerOptions.Algorithm = 'trust-region-reflective';
+    
+    % Run lsqnonlin
+    [par_opt, chi2value, ~, exitflag, results_lsqnonlin, ~, jacobian_opt] = lsqnonlin(...
+        negLogPost,...
+        par0(freePars), ...
+        parameters.min(freePars), ...
+        parameters.max(freePars), ...
+        options.localOptimizerOptions);
+    
+    % Compute likelihood value from residuals and offset
+    if isempty(options.logPostOffset)
+        [~,~,negLogPost_opt] = negLogPost(par_opt);
+        logPostOffset = negLogPost_opt - 0.5 * chi2value;
+        options.logPostOffset = logPostOffset;
+    else
+        logPostOffset = [];
+    end
+    
+    % Assignment of results
+    negLogPost_opt = 0.5 * chi2value + options.logPostOffset;
+    par_opt(freePars) = par_opt;
+    par_opt(options.fixedParameters) = options.fixedParameterValues;
+    n_objfun = results_lsqnonlin.funcCount;
+    n_iter = results_lsqnonlin.iterations;
+    
+    % Assigment of Hessian (gradient is not computed)
+    gradient_opt = nan(size(par_opt));
+    if ~isempty(jacobian_opt)
+        hessian_sqrt = full(jacobian_opt);
+        hessian_opt = hessian_sqrt' * hessian_sqrt;
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationMeigo.m b/Requirements/PESTO-1.1.0/private/performOptimizationMeigo.m
new file mode 100644
index 0000000000000000000000000000000000000000..495f8633b39977c2f5aaf78212b4be82978e9e9f
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationMeigo.m
@@ -0,0 +1,51 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+    = performOptimizationMeigo(parameters, negLogPost, par0, options)
+
+    % Check if MEIGO is implemented
+    if ~exist('MEIGO', 'file')
+        error('MEIGO not found. This feature requires the "MEIGO" toolbox to be installed. See http://gingproc.iim.csic.es/meigo.html for download and installation instructions.');
+    end
+
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    
+    % Define MEIGO problem
+    problem.f = 'meigoDummy';
+    problem.x_L = parameters.min;
+    problem.x_U = parameters.max;
+    problem.x_0 = par0;
+
+    %TODO
+    % parameters.constraints.A  ,parameters.constraints.b  ,... % linear inequality constraints
+    % parameters.constraints.Aeq,parameters.constraints.beq,... % linear equality constraints
+    
+    % Run Meigo
+    if strcmp(options.localOptimizer, 'meigo-vns')
+        meigoAlgo = 'VNS';
+    else
+        meigoAlgo = 'ESS';
+    end
+    objFunHandle = @(theta) negLogPost(theta');
+    Results = MEIGO(problem, options.localOptimizerOptions, meigoAlgo, objFunHandle);
+    n_objfun = Results.numeval;
+    n_iter = size(Results.neval, 2);
+
+    exitflag= Results.end_crit;
+    negLogPost_opt = Results.fbest;
+    par_opt = Results.xbest(:);
+    
+    % Assignment of gradient and Hessian
+    try
+        [~, gradient_opt, hessian_opt] = negLogPost(Results.xbest);
+        hessian_opt(freePars,freePars) = hessian_opt;
+        hessian_opt(options.fixedParameters,options.fixedParameters) = nan;
+        gradient_opt(freePars) = gradient_opt;
+        gradient_opt(options.fixedParameters) = nan;
+    catch
+        warning('Could not compute Hessian and gradient at optimum after optimization.');
+        if (options.objOutNumber == 3)
+            warning('options.objOutNumber is set to 3, but your objective function can not provide 3 outputs. Please set objOutNumber accordingly!');
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performOptimizationPswarm.m b/Requirements/PESTO-1.1.0/private/performOptimizationPswarm.m
new file mode 100644
index 0000000000000000000000000000000000000000..deaa55790cdbd160212ec296d046c289fecc24ad
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performOptimizationPswarm.m
@@ -0,0 +1,44 @@
+function [negLogPost_opt, par_opt, gradient_opt, hessian_opt, exitflag, n_objfun, n_iter] ...
+    = performOptimizationPswarm(parameters, negLogPost, par0, options)
+
+    % Check if PSwarm is implemented
+    if ~exist('PSwarm', 'file')
+        error('PSwarm not found. This feature requires the "PSwarm" toolbox to be installed. See http://www.norg.uminho.pt/aivaz/pswarm/ for download and installation instructions.');
+    end
+    
+    % Definition of index set of optimized parameters
+    freePars = setdiff(1:parameters.number, options.fixedParameters);
+    
+    % Define PSwarm problem
+    problem = struct();
+    problem.ObjFunction= 'meigoDummy';
+    problem.LB = parameters.min;
+    problem.UB = parameters.max;
+    problem.A = parameters.constraints.A;
+    problem.b = parameters.constraints.b;
+
+    % Run PSwarm
+    objFunHandle = @(theta) negLogPost(theta);
+    [par_opt, negLogPost_opt, RunData] = PSwarm(problem, struct('x', par0(:)), options.localOptimizerOptions, objFunHandle);
+
+    % Assignment of results
+    exitflag = nan;
+    n_objfun = RunData.ObjFunCounter;
+    n_iter = RunData.IterCounter;
+    par_opt(options.fixedParameters) = options.fixedParameterValues;
+    
+    % Assignment of gradient and Hessian
+    try
+        [~, gradient_opt, hessian_opt] = negLogPost(par_opt);
+        hessian_opt(freePars,freePars) = hessian_opt;
+        hessian_opt(options.fixedParameters,options.fixedParameters) = nan;
+        gradient_opt(freePars) = gradient_opt;
+        gradient_opt(options.fixedParameters) = nan;
+    catch
+        warning('Could not compute Hessian and gradient at optimum after optimization.');
+        if (options.objOutNumber == 3)
+            warning('options.objOutNumber is set to 3, but your objective function can not provide 3 outputs. Please set objOutNumber accordingly!');
+        end
+    end
+                        
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/performPHS.m b/Requirements/PESTO-1.1.0/private/performPHS.m
new file mode 100644
index 0000000000000000000000000000000000000000..82899da115500f7bb49f3ed7a606099d5b9983fe
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performPHS.m
@@ -0,0 +1,247 @@
+function res = performPHS( logPostHandle, par, opt )
+   
+   % performPHS.m uses Parallel Hierarchical Sampling algorithm to sample from an objective function
+   % 'logPostHandle'. The code is based on [RigatMira2012].
+   % The 'mother' chain is swaped with one of the auxillary chains in each iteration.
+   %
+   % The options 'opt' cover:
+   % opt.theta0                  : The inital parameter points for each of the
+   %                               tempered chains
+   % opt.sigma0                  : The inital proposal covariance matrix of
+   %                               the parameters
+   % par.min and par.max         : The lower and upper bounds for the
+   %                               parameters. Proposed points outside this
+   %                               area are getting rejected
+   % par.number                  : Number of parameters
+   % opt.nIterations             : Number of desired sampling iterations
+   % opt.PHS.nChains             : Number of chains (1 'mother'-chain and opt.PHS.nChains-1
+   %                               auxillary chains)
+   % opt.PHS.alpha               : Control parameter for adaption decay.
+   %                               Needs values between 0 and 1. Higher values
+   %                               lead to faster decays, meaning that new
+   %                               iterations influence the single-chain
+   %                               proposal adaption only very weakly very
+   %                               quickly.
+   % opt.PHS.memoryLength        : Control parameter for adaption. Higher
+   %                               values supress strong ealy adaption.
+   % opt.PHS.regFactor           : This factor is used for regularization in
+   %                               cases where the single-chain proposal
+   %                               covariance matrices are ill conditioned.
+   %                               nChainsarger values equal stronger
+   %                               regularization.
+   % opt.PHS.trainingTime        : The iterations before the first chain swap
+   %                               is invoked
+   %
+   %
+   % It returns a struct 'res' covering:
+   % res.par               : The Markov chain of the parameters for each temperature
+   % res.logPost           : The objective value corresponding to parameter
+   %                         vector for each temperature
+   % res.acc               : The cummulative acceptance rate of the chains
+   % res.propSwap          : Number of times a swap between chains
+   %                         was proposed
+   % res.sigmaScale        : The scaling factor of the single-chain proposal
+   %                         covariance matrices, which is adapted to
+   %                         accomplish an overall 23% acceptance rate
+   % res.sigmaHist         : Single-chain proposal covariance matrix
+   %
+   %
+   % Written by Benjamin Ballnus 2/2017
+   
+   
+   % Initialization
+   nChains = opt.PHS.nChains;
+   nIter = opt.nIterations;
+   theta0 = opt.theta0;
+   sigma0 = opt.sigma0;
+   thetaMin = par.min;
+   thetaMax = par.max;
+   alpha = opt.PHS.alpha;
+   memoryLength = opt.PHS.memoryLength;
+   regFactor = opt.PHS.regFactor;
+   nPar = par.number;
+   trainingTime = opt.PHS.trainingTime;
+   
+   res.par = nan(nPar, nIter, nChains);
+   res.logPost = nan(nIter, nChains);
+   res.acc = nan(nIter, nChains);
+   res.sigmaScale = nan(nIter, nChains);
+   
+   swapindex = nan(1,opt.nIterations);
+   acc = zeros(1,nChains);
+   sigmaScale = ones(1,nChains);
+   switch size(theta0,2)
+      case 1
+         theta = repmat(theta0,[1,nChains]);
+      case nChains
+         theta = theta0;
+      otherwise
+         error('Dimension of options.theta0 is incorrect.');
+   end
+   
+   muHist = theta;
+   switch size(sigma0,3)
+      case 1
+         sigmaHist = repmat(sigma0,[1,1,nChains]);
+      case nChains
+         sigmaHist = sigma0;
+      otherwise
+         error('Dimension of options.Sigma0 is incorrect.');
+   end
+   sigmaProp = nan(nPar,nPar,nChains);
+   logPost = nan(nChains,1);
+   logPostProp = nan(nChains,1);
+   for l = 1:nChains
+      logPost(l) = logPostHandle(theta(:,l));
+   end
+   sigma = sigmaHist;
+   
+   msg = '';
+   tic; dspTime = toc;   
+   
+   % Perform MCMC
+   for i = 1:(nIter)
+      
+      % Reporting Progress
+      switch opt.mode
+         case {'visual','text'}
+            if toc-dspTime > 0.5
+               fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+               msg = ['Progress: ' num2str(i/(nIter)*100,'%2.2f') ' %%\n'];
+               fprintf(1,msg);
+               dspTime = toc;
+            end
+         case 'silent'
+      end
+      
+      % Swap mother chain with one of the auxillary chains
+      if trainingTime <= i
+         swapindex(i) = randi(nChains-1)+1;
+         if i > 1
+            tmp =  theta(:,1);
+            theta(:,1) = theta(:,swapindex(i));
+            theta(:,swapindex(i)) = tmp;
+            
+            tmp = muHist(:,1);
+            muHist(:,1) = muHist(:,swapindex(i));
+            muHist(:,swapindex(i)) = tmp;
+            
+            tmp =  logPost(1);
+            logPost(1) = logPost(swapindex(i));
+            logPost(swapindex(i)) = tmp;
+            
+            tmp =  sigma(:,:,1);
+            sigma(:,:,1) = sigma(:,:,swapindex(i));
+            sigma(:,:,swapindex(i)) = tmp;
+            
+            tmp =  sigmaHist(:,:,1);
+            sigmaHist(:,:,1) = sigmaHist(:,:,swapindex(i));
+            sigmaHist(:,:,swapindex(i)) = tmp;
+         end
+      end
+      
+      % Do MCMC step for each temperature
+      for l = 2:nChains
+         
+         % Propose
+         thetaProp(:,l) = mvnrnd(theta(:,l),sigma(:,:,l))';
+         
+         % Check for Bounds
+         if (sum(thetaProp(:,l) < thetaMin) + sum(thetaProp(:,l) > thetaMax)) == 0
+            
+            inbounds = 1;
+            
+            % Proposed posterior value
+            logPostProp(l) = logPostHandle(thetaProp(:,l));
+            
+            % New sigma
+            sigmaProp(:,:,l) = sigmaScale(l)^2 * sigmaHist(:,:,l);
+            
+            % Regularization of propos sigma
+            [~,p] = cholcov(sigmaProp(:,:,l),0);
+            if p ~= 0
+               sigmaProp(:,:,l) = sigmaProp(:,:,l) + regFactor*eye(nPar);
+               sigmaProp(:,:,l) = (sigmaProp(:,:,l)+sigmaProp(:,:,l)')/2;
+               [~,p] = cholcov(sigmaProp(:,:,l),0);
+               if p ~= 0
+                  sigmaProp(:,:,l) = sigmaProp(:,:,l) + max(max(sigmaProp(:,:,l)))/1000*eye(nPar);
+                  sigmaProp(:,:,l) = (sigmaProp(:,:,l)+sigmaProp(:,:,l)')/2;
+               end
+            end
+            
+         else
+            inbounds = 0;
+         end
+         
+         % Transition and Acceptance Propbabilities
+         if (inbounds == 1) && (logPostProp(l) > -inf)
+            logTransFor(l) = 1;
+            logTransBack(l) = 1;
+            pAcc(l) = min(0, logPostProp(l) - logPost(l) + logTransBack(l) - logTransFor(l));
+         else
+            pAcc(l) = -inf;
+         end
+         
+         % Accept or reject
+         if log(rand) <= pAcc(l)
+            acc(l)             = acc(l) + 1;
+            theta(:,l)         = thetaProp(:,l);
+            logPost(l)         = logPostProp(l);
+         end
+         
+      end
+      
+      % Update Proposal
+      for l = 2:nChains
+         % Updating of mean and covariance
+         [muHist(:,l),sigmaHist(:,:,l)] = ...
+            updateStatistics(muHist(:,l), sigmaHist(:,:,l), ...
+            theta(:,l), ...
+            max(i+1,memoryLength), alpha);
+         sigmaScale(l) = sigmaScale(l)*exp((exp(pAcc(l))-0.234)/(i+1)^alpha);
+         
+         % Set sigma for the next iteration (recently added like this)
+         sigma(:,:,l) = sigmaScale(l)*sigmaHist(:, :, l);
+         sigma(:,:,l) = sigmaScale(l)*sigma(:,:,l);
+         
+         % Regularization of Sigma
+         [~,p] = cholcov(sigma(:,:,l),0);
+         if p ~= 0
+            sigma(:,:,l) = sigma(:,:,l) + regFactor*eye(nPar);
+            sigma(:,:,l) = (sigma(:,:,l)+sigma(:,:,l)')/2;
+            [~,p] = cholcov(sigma(:,:,l),0);
+            if p ~= 0
+               sigma(:,:,l) = sigma(:,:,l) + max(max(sigma(:,:,l)))*eye(nPar);
+               sigma(:,:,l) = (sigma(:,:,l)+sigma(:,:,l)')/2;
+            end
+         end
+         
+      end
+      
+      % Store iteration
+      res.par(:,i,:) = theta;
+      res.logPost(i,:) = logPost;
+      res.acc(i,:) = 100*acc/i;
+      res.sigmaScale(i,:) = sigmaScale;
+      res.sigmaHist = sigmaHist;
+   end
+   
+    switch opt.mode
+        case {'visual','text'}
+               fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+        case 'silent'
+    end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Requirements/PESTO-1.1.0/private/performPT.m b/Requirements/PESTO-1.1.0/private/performPT.m
new file mode 100644
index 0000000000000000000000000000000000000000..511e1210bf6305e8d07a13af3404fac437106d71
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performPT.m
@@ -0,0 +1,331 @@
+function res = performPT( logPostHandle, par, opt )
+   
+   % performPT.m uses an Parallel Tempering algorithm to sample
+   % from an objective function
+   % 'logPostHandle'. The tempered chains are getting swapped. 
+   % The temperatures are getting adapted as well as the
+   % proposal density covariance matrix. The proposal adaptation is done
+   % for each region separately to increase locale mixing.
+   %
+   %
+   % The options 'opt' cover:
+   % opt.theta0                  : The initial parameter points for each of the
+   %                               tempered chains
+   % opt.sigma0                  : The initial proposal covariance matrix of
+   %                               the parameters
+   % par.min and par.max         : The lower and upper bounds for the
+   %                               parameters. Proposed points outside this
+   %                               area are getting rejected
+   % par.number                  : Number of parameters
+   % opt.nIterations             : Number of desired sampling iterations
+   % opt.PT.nTemps               : Number of tempered chains
+   % opt.PT.exponentT            : The exponent of the power law for initial
+   %                               temperatures. Higher Values lead to more
+   %                               separated initial temperatures.
+   % opt.PT.alpha                : Control parameter for adaption decay.
+   %                               Needs values between 0 and 1. Higher values
+   %                               lead to faster decays, meaning that new
+   %                               iterations influence the single-chain
+   %                               proposal adaption only very weakly very
+   %                               quickly.
+   % opt.PT.temperatureNu     : Control parameter for adaption decay of the
+   %                               temperature adaption. Sample properties as
+   %                               described for opt.PT.alpha.
+   % opt.PT.memoryLength         : Control parameter for adaption. Higher
+   %                               values suppress strong early adaption.
+   % opt.PT.regFactor            : This factor is used for regularization in
+   %                               cases where the single-chain proposal
+   %                               covariance matrices are ill conditioned.
+   %                               Larger values equal stronger
+   %                               regularization.
+   % opt.PT.temperatureAdaptionScheme: Defines the temperature adaption scheme.
+   %                               Either 'Vousden16' or 'Lacki15'.
+   % opt.PT.swapsPerIter         : Number of swaps between temperatures
+   %                               per iteration.
+   %
+   %
+   % It returns a struct 'res' covering:
+   % res.par               : The Markov chain of the parameters for each temperature
+   % res.logPost           : The objective value corresponding to parameter
+   %                         vector for each temperature
+   % res.acc               : The cumulative acceptance rate of the chains
+   % res.accSwap           : The acceptance rate of swaps between tempered chains
+   % res.propSwap          : Number of times a swap between tempered chains
+   %                         was proposed
+   % res.sigmaScale        : The scaling factor of the single-chain proposal
+   %                         covariance matrices, which is adapted to
+   %                         accomplish an overall 23% acceptance rate
+   % res.sigmaHist         : Single-chain proposal covariance matrix
+   % res.temperatures      : The temperatures of all tempered chains
+   %
+   %
+   % Written by Benjamin Ballnus 2/2017
+   
+   
+   % Initialization
+   doDebug              = opt.debug;
+   
+   saveEach             = opt.saveEach;
+   saveFileName         = opt.saveFileName;   
+   
+   nTemps               = opt.PT.nTemps;
+   nIter                = opt.nIterations;
+   theta0               = opt.theta0;
+   sigma0               = opt.sigma0;
+   thetaMin             = par.min;
+   thetaMax             = par.max;
+   exponentT            = opt.PT.exponentT;
+   alpha                = opt.PT.alpha;
+   temperatureNu        = opt.PT.temperatureNu;
+   memoryLength         = opt.PT.memoryLength;
+   regFactor            = opt.PT.regFactor;
+   nPar                 = par.number;
+   temperatureEta       = opt.PT.temperatureEta;
+   
+   
+   
+   S = zeros(1,nTemps-2);
+   
+   if doDebug     
+      res.par              = nan(nPar, nIter, nTemps);
+      res.logPost          = nan(nIter, nTemps);
+      res.acc              = nan(nIter, nTemps);
+      res.accSwap          = nan(nIter, nTemps, nTemps);
+      res.sigmaScale       = nan(nIter, nTemps);
+      res.temperatures     = nan(nIter, nTemps);
+   else
+      res.par              = nan(nPar, nIter);
+      res.logPost          = nan(nIter, 1);      
+   end
+   
+   maxT = opt.PT.maxT;
+   T = linspace(1,maxT^(1/exponentT),nTemps).^exponentT;
+   beta = 1./T;
+   
+   % Special case of AM: necessary due to linspace behavior
+   if nTemps == 1
+      T    = 1;
+      beta = 1;
+   end
+   
+   acc = zeros(1,nTemps);
+   accSwap = zeros(1,nTemps-1);
+   propSwap = zeros(1,nTemps-1);
+   sigmaScale = ones(1,nTemps);
+   switch size(theta0,2)
+      case 1
+         theta = repmat(theta0,[1,nTemps]);
+      case nTemps
+         theta = theta0;
+      otherwise
+         error('Dimension of options.theta0 is incorrect.');
+   end
+   muHist = theta;
+      
+   % Regularization sigma0
+   for l = 1:size(sigma0,3)
+      [~,p] = cholcov(sigma0(:,:,l),0);
+      if p ~= 0
+         sigma0(:,:,l) = sigma0(:,:,l) + regFactor*eye(nPar);
+         sigma0(:,:,l) = (sigma0(:,:,l)+sigma0(:,:,l)')/2;
+         [~,p] = cholcov(sigma0(:,:,l),0);
+         if p ~= 0
+            sigma0(:,:,l) = sigma0(:,:,l) + max(max(sigma0(:,:,l)))/1000*eye(nPar);
+            sigma0(:,:,l) = (sigma0(:,:,l)+sigma0(:,:,l)')/2;
+         end
+      end
+   end
+   
+   switch size(sigma0,3)
+      case 1
+         sigmaHist = repmat(sigma0,[1,1,nTemps]);
+      case nTemps
+         sigmaHist = sigma0;
+      otherwise
+         error('Dimension of options.Sigma0 is incorrect.');
+   end
+   logPost = nan(nTemps,1);
+   logPostProp = nan(nTemps,1);
+   for l = 1:nTemps
+      logPost(l) = logPostHandle(theta(:,l));
+   end
+   sigma = sigmaHist;
+   
+   msg = '';
+   timer = tic; dspTime      = toc(timer);
+   
+   j = 0;
+   i = 1;
+   
+   % Reset Progress
+   if (saveEach ~= 0) && ~isempty(saveFileName) && ...
+         exist([saveFileName '.mat'],'file')==2
+      switch opt.mode
+         case {'visual','text'}
+            disp('Restoring aborted run...')
+      end
+      try
+         load(saveFileName);
+      catch
+         disp('File corrupt.');
+      end
+   end   
+   
+   % Perform MCMC
+   while i <= nIter
+      
+      j = j + 1; % Relative Index for each Phase
+      
+      % Save progress - nice for grid computing
+      if (saveEach ~= 0) && ~isempty(saveFileName) && mod(i,saveEach)==0
+         save(saveFileName);
+      end      
+      
+      % Reporting Progress
+      switch opt.mode
+         case {'visual','text'}
+            if toc(timer)-dspTime > 0.5 
+               fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+               msg = ['Progress: ' num2str(i/(nIter)*100,'%2.2f') ' %%\n'];
+               fprintf(1,msg);
+               dspTime = toc(timer); 
+            end
+         case 'silent'
+      end
+      
+      
+      % Do MCMC step for each temperature
+      for l = 1:nTemps
+         
+         % Propose
+         thetaProp(:,l) = mvnrnd(theta(:,l),sigma(:,:,l))';
+         
+         % Check for Bounds
+         if (sum(thetaProp(:,l) < thetaMin) + sum(thetaProp(:,l) > thetaMax)) == 0
+            
+            inbounds = 1;
+            
+            % Proposed posterior value
+            logPostProp(l) = logPostHandle(thetaProp(:,l)); 
+            
+         else
+            inbounds = 0;
+         end
+         
+         % Transition and Acceptance Probabilities      
+         if (inbounds == 1) && (logPostProp(l) > -inf) && (logPostProp(l) < inf)
+            logTransFor(l) = 1;
+            logTransBack(l) = 1;
+            pAcc(l) = beta(l)*(logPostProp(l)-logPost(l)) + logTransBack(l) - logTransFor(l);
+            if isnan(pAcc(l))       % May happen if the objective function has numerical problems
+               pAcc(l) = -inf;
+            elseif pAcc(l) > 0       % Do not use min, due to NaN behavior in Matlab
+               pAcc(l) = 0;
+            end
+         else
+            pAcc(l) = -inf;
+         end
+         
+         % Accept or reject
+         if log(rand) <= pAcc(l)
+            acc(l)             = acc(l) + 1;
+            theta(:,l)         = thetaProp(:,l);
+            logPost(l)         = logPostProp(l);
+         end
+         
+      end
+      
+      % Update Proposal
+      for l = 1:nTemps
+         % Updating of mean and covariance
+         [muHist(:,l),sigmaHist(:,:,l)] = ...
+            updateStatistics(muHist(:,l), sigmaHist(:,:,l), ...
+            theta(:,l), ...
+            max(j+1,memoryLength), alpha);
+         sigmaScale(l) = sigmaScale(l)*exp((exp(pAcc(l))-0.234)/(j+1)^alpha);
+         
+         % Set sigma for the next iteration (recently added like this)
+         sigma(:,:,l) = sigmaScale(l)*sigmaHist(:, :, l);
+         sigma(:,:,l) = sigmaScale(l)*sigma(:,:,l);
+         
+         % Regularization of Sigma
+         [~,p] = cholcov(sigma(:,:,l),0);
+         if p ~= 0
+            sigma(:,:,l) = sigma(:,:,l) + regFactor*eye(nPar);
+            sigma(:,:,l) = (sigma(:,:,l)+sigma(:,:,l)')/2;
+            [~,p] = cholcov(sigma(:,:,l),0);
+            if p ~= 0
+               sigma(:,:,l) = sigma(:,:,l) + max(max(sigma(:,:,l)))*eye(nPar);
+               sigma(:,:,l) = (sigma(:,:,l)+sigma(:,:,l)')/2;
+            end
+         end
+         
+      end
+      
+      % Swaps between all adjacent chains as in Vousden16
+      if nTemps > 1
+         dBeta = beta(1:end-1) - beta(2:end);
+         for l = nTemps:-1:2
+            pAccSwap(l-1) = dBeta(l-1) .* (logPost(l)-logPost(l-1))';
+            A(l-1) = log(rand) < pAccSwap(l-1);
+            propSwap(l-1) = propSwap(l-1) + 1;
+            accSwap(l-1) = accSwap(l-1) + A(l-1);
+            % As usually implemented when using PT
+            if A(l-1)
+               theta(:,[l,l-1]) = theta(:,[l-1,l]);
+               logPost([l,l-1]) = logPost([l-1,l]);
+            end
+         end
+      end
+      
+      if nTemps > 1
+         dBeta = beta(1:end-1) - beta(2:end);
+         for l = nTemps:-1:2
+            pAccSwap(l-1) = dBeta(l-1) .* (logPost(l)-logPost(l-1))';
+            A(l-1) = log(rand) < pAccSwap(l-1);
+            propSwap(l-1) = propSwap(l-1) + 1;
+            accSwap(l-1) = accSwap(l-1) + A(l-1);
+            % As usually implemented when using PT
+            if A(l-1)
+               theta(:,[l,l-1]) = theta(:,[l-1,l]);
+               logPost([l,l-1]) = logPost([l-1,l]);
+            end
+         end
+      end
+      
+      % Adaptation of the temperature values (Vousden 2016)
+      if nTemps > 1
+         
+         % Vousden python Code & Paper
+         kappa = temperatureNu / ( j + 1 + temperatureNu ) / temperatureEta;
+         dS = kappa*(A(1:end-1)-A(2:end)); 
+         dT = diff(1./beta(1:end-1));
+         dT = dT .* exp(dS);
+         beta(1:end-1) = 1./cumsum([1,dT]); 
+      end
+      
+      % Store iteration
+      if doDebug     
+         res.par(:,i,:)          = theta;
+         res.logPost(i,:)        = logPost;
+         res.acc(i,:)            = 100*acc/j;
+         res.propSwap            = propSwap;
+         res.accSwap             = accSwap;
+         res.ratioSwap           = accSwap ./ propSwap;
+         res.sigmaScale(i,:)     = sigmaScale;
+         res.sigmaHist           = sigmaHist;
+         res.temperatures(i,:)   = 1./beta;
+      else
+         res.par(:,i)            = theta(:,1);
+         res.logPost(i)          = logPost(1);         
+      end
+      
+      i = i + 1; 
+   end
+   
+   switch opt.mode
+      case {'visual','text'}
+         fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+      case 'silent'
+   end
+end
diff --git a/Requirements/PESTO-1.1.0/private/performRAMPART.m b/Requirements/PESTO-1.1.0/private/performRAMPART.m
new file mode 100644
index 0000000000000000000000000000000000000000..2adfb12714f2247955360cb0936bf01e299c2bb4
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/performRAMPART.m
@@ -0,0 +1,550 @@
+function res = performRAMPART( logPostHandle, par, opt )
+   
+   % performRAMPART.m uses an Region-based adaptive PARallel Tempering algorithm to sample
+   % from an objective function
+   % 'logPostHandle'. The tempered chains are getting swapped. 
+   % The temperatures are getting adapted as well as the
+   % proposal density covariance matrix. The proposal adaptation is done
+   % for each region separately to increase locale mixing.
+   %
+   %
+   % The options 'opt' cover:
+   % opt.theta0                  : The initial parameter points for each of the
+   %                               tempered chains
+   % opt.sigma0                  : The initial proposal covariance matrix of
+   %                               the parameters
+   % par.min and par.max         : The lower and upper bounds for the
+   %                               parameters. Proposed points outside this
+   %                               area are getting rejected
+   % par.number                  : Number of parameters
+   % opt.nIterations             : Number of desired sampling iterations
+   % opt.RAMPART.nTemps          : Number of tempered chains
+   % opt.RAMPART.exponentT       : The exponent of the power law for initial
+   %                               temperatures. Higher Values lead to more
+   %                               separated initial temperatures.
+   % opt.RAMPART.alpha           : Control parameter for adaption decay.
+   %                               Needs values between 0 and 1. Higher values
+   %                               lead to faster decays, meaning that new
+   %                               iterations influence the single-chain
+   %                               proposal adaption only very weakly very
+   %                               quickly.
+   % opt.RAMPART.temperatureNu   : Control parameter for adaption decay of the
+   %                               temperature adaption. Sample properties as
+   %                               described for opt.RAMPART.alpha.
+   % opt.RAMPART.memoryLength    : Control parameter for adaption. Higher
+   %                               values suppress strong early adaption.
+   % opt.RAMPART.regFactor       : This factor is used for regularization in
+   %                               cases where the single-chain proposal
+   %                               covariance matrices are ill conditioned.
+   %                               Larger values equal stronger
+   %                               regularization.
+   %
+   %
+   % It returns a struct 'res' covering:
+   % res.par               : The Markov chain of the parameters for each temperature
+   % res.logPost           : The objective value corresponding to parameter
+   %                         vector for each temperature
+   % res.acc               : The cumulative acceptance rate of the chains
+   % res.accSwap           : The acceptance rate of swaps between tempered chains
+   % res.propSwap          : Number of times a swap between tempered chains
+   %                         was proposed
+   % res.sigmaScale        : The scaling factor of the single-chain proposal
+   %                         covariance matrices, which is adapted to
+   %                         accomplish an overall 23% acceptance rate
+   % res.sigmaHist         : Single-chain proposal covariance matrix
+   % res.temperatures      : The temperatures of all tempered chains
+   %
+   %
+   % Written by Benjamin Ballnus 2/2017
+   
+   
+   % Initialization
+   doDebug           = opt.debug;
+   
+   nTemps            = opt.RAMPART.nTemps;
+   nIter             = opt.nIterations;
+   theta0            = opt.theta0;
+   sigma0            = opt.sigma0;
+   thetaMin          = par.min;
+   thetaMax          = par.max;
+   exponentT         = opt.RAMPART.exponentT;
+   alpha             = opt.RAMPART.alpha;
+   temperatureNu     = opt.RAMPART.temperatureNu;
+   memoryLength      = opt.RAMPART.memoryLength;
+   regFactor         = opt.RAMPART.regFactor;
+   nPar              = par.number;
+   temperatureEta    = opt.RAMPART.temperatureEta;
+   useSmallWorld     = true;
+   
+   nTrainReplicates  = opt.RAMPART.nTrainReplicates;
+   
+   trainPhaseFrac    = opt.RAMPART.trainPhaseFrac;
+   nPhase            = floor(trainPhaseFrac * nIter);
+   
+   nRegionNumbers    = length(opt.RAMPART.RPOpt.modeNumberCandidates);
+   nMaxRegions       = max(opt.RAMPART.RPOpt.modeNumberCandidates);
+   regionPredOpt     = opt.RAMPART.RPOpt;
+   
+   saveEach          = opt.saveEach;
+   saveFileName      = opt.saveFileName;
+   
+     
+   if doDebug
+      res.par           = nan(nPar, nIter, nTemps);
+      res.logPost       = nan(nIter, nTemps);
+      res.acc           = nan(nIter, nTemps, nMaxRegions);
+      res.accSwap       = nan(nIter, nTemps, nTemps);
+      res.sigmaScale    = nan(nIter, nTemps, nMaxRegions);
+      res.temperatures  = nan(nIter, nTemps);
+      res.newLabel      = nan(nIter, nTemps);
+      res.oldLabel      = nan(nIter, nTemps);
+   else
+      res.par           = nan(nPar, nIter);
+      res.logPost       = nan(nIter, 1);  
+      res.newLabel      = nan(nIter, 1);      
+   end
+   
+   maxT              = opt.RAMPART.maxT;
+   T                 = linspace(1,maxT^(1/exponentT),nTemps).^exponentT;
+   beta              = 1./T;
+   
+   % Special case of AM: necessary due to linspace behavior
+   if nTemps == 1
+      T    = 1;
+      beta = 1;
+   end
+   
+   oL                = nan(1,nTemps);
+   nL                = nan(1,nTemps);
+   acc               = zeros(nTemps,nMaxRegions);
+   accSwap           = zeros(1,nTemps-1);
+   propSwap          = zeros(1,nTemps-1);
+   sigmaScale        = ones(nTemps,nMaxRegions);
+   sigmaScaleGlobal  = ones(nTemps,1);
+   switch size(theta0,2)
+      case 1
+         theta       = repmat(theta0,[1,nTemps]);
+      case nTemps
+         theta       = theta0;
+      otherwise
+         error('Dimension of options.theta0 is incorrect.');
+   end
+   muHist            = repmat(theta, [1, 1, nMaxRegions]);
+   muHistGlobal      = theta;
+      
+   % Regularization sigma0
+   for l = 1:size(sigma0,3)
+      [~,p] = cholcov(sigma0(:,:,l),0);
+      if p ~= 0
+         sigma0(:,:,l) = sigma0(:,:,l) + regFactor*eye(nPar);
+         sigma0(:,:,l) = (sigma0(:,:,l)+sigma0(:,:,l,k)')/2;
+         [~,p] = cholcov(sigma0(:,:,l),0);
+         if p ~= 0
+            sigma0(:,:,l) = sigma0(:,:,l) + max(max(sigma0(:,:,l)))/1000*eye(nPar);
+            sigma0(:,:,l) = (sigma0(:,:,l)+sigma0(:,:,l)')/2;
+         end
+      end
+   end
+   
+   switch size(sigma0,3)
+      case 1
+         sigmaHist   = repmat(sigma0,[1,1,nTemps]);
+      case nTemps
+         sigmaHist   = sigma0;
+      otherwise
+         error('Dimension of options.Sigma0 is incorrect.');
+   end
+   sigmaHistGlobal = sigmaHist;   
+   sigmaHist = repmat( sigmaHist, [1, 1, 1, nMaxRegions] );
+   
+   logPost           = nan(nTemps,1);
+   logPostProp       = nan(nTemps,1);
+   for l = 1:nTemps
+      logPost(l)     = logPostHandle(theta(:,l));
+   end
+   sigma             = sigmaHist;
+   sigmaGlobal       = sigmaHistGlobal;
+   
+   msg               = '';
+   timer = tic; dspTime      = toc(timer);
+   
+   j = zeros(nTemps,nMaxRegions); 
+   i = 1;
+   
+   % Reset Progress
+   if (saveEach ~= 0) && ~isempty(saveFileName) && ...
+         exist([saveFileName '.mat'],'file')==2
+      switch opt.mode
+         case {'visual','text'}
+            disp('Restoring aborted run...')
+      end
+      try
+         load(saveFileName);
+      catch
+         disp('File corrupt.');
+      end
+   end
+   % Perform MCMC
+   while i <= nIter
+      
+      % Save progress - nice for grid computing
+      if (saveEach ~= 0) && ~isempty(saveFileName) && mod(i,saveEach)==0
+         save(saveFileName);
+      end
+      
+      % Reporting Progress
+      switch opt.mode
+         case {'visual','text'}
+            if toc(timer)-dspTime > 0.5
+               eraser = repmat('\b',1,numel(msg)-1);
+               msg = ['Progress: ' num2str(i/(nIter)*100,'%2.2f ') ...
+                  ' (Current Posterior: ' num2str(logPost(1)) ') \n'];
+               fprintf([eraser msg]);
+               dspTime = toc(timer);
+            end
+         case 'silent'
+      end
+      
+      
+      % Do MCMC step for each temperature
+      for l = 1:nTemps
+         
+         % Get region label of current point. Learn from posterior sample
+         if (i == nPhase) && (l == 1) 
+            
+            % Train GMM to get label predictions for future points
+            lh = nan(nTrainReplicates,length(regionPredOpt.modeNumberCandidates));
+            trainedGMMModels = {};
+            for rep = 1:nTrainReplicates
+               if strcmp(regionPredOpt.displayMode,'visual') 
+                  close all;
+               end
+               
+               % Train GMM replicate
+               [lh(rep,:), trainedGMMModels{rep}] = trainEMGMM(squeeze(res.par(:,ceil(nPhase/2):nPhase-1,1))',regionPredOpt);
+               
+               % Likelihood with BIC adaption using the likelihood, and
+               % number of estimated parameters: n               x w
+               %                                 n*d             x mu
+               %                                 n*(d*(d-1)/2+d) x Sigma
+               nGauss = regionPredOpt.modeNumberCandidates;
+               nDim   = sum(regionPredOpt.isInformative);
+               lh(rep,:) = lh(rep,:) - log(nPhase-1)*(nGauss +nGauss*nDim +nGauss*((nDim-1)*nDim/2+nDim));               
+               [~,bestModeNumber] = max(lh(rep,:));               
+               
+               % Display
+               if strcmp(regionPredOpt.displayMode,'text') || strcmp(regionPredOpt.displayMode,'visual') 
+                  disp(['The current replicate found nModes=' ...
+                     num2str(regionPredOpt.modeNumberCandidates(bestModeNumber))...
+                     ' to suit the give data best.']);
+               end
+            end
+            
+            % Select the best performing GMM fit
+            lh = lh';
+            [~,bestModeNumber]          = max(lh(:));
+            res.regions.lh              = lh;
+            res.regions.trainedGMModels = trainedGMMModels{ceil(bestModeNumber/nRegionNumbers)};
+            bestGMM                     = ...
+               trainedGMMModels{ceil(bestModeNumber/nRegionNumbers)}(mod(bestModeNumber-1,nRegionNumbers)+1);
+            
+            % Build GMM prediction function for future predictions (using
+            % MATLABs build-in implementation / currently needs some
+            % workarround for nModes == 1
+            regionPredOpt.isInformative = logical(regionPredOpt.isInformative);
+            if bestGMM.nModes ~= 1
+               % Prepare covariance for MATLAB build-in GMM
+               bestGMM.sigma = shiftdim(bestGMM.sigma(:,regionPredOpt.isInformative,...
+                                                              regionPredOpt.isInformative),1);
+               % Regularize covariances if necessary
+               for k = 1:size(bestGMM.sigma,3)
+                  [~,p] = cholcov(squeeze(bestGMM.sigma(:,:,k)),0);
+                  if p ~= 0
+                     bestGMM.sigma(:,:,k) = bestGMM.sigma(:,:,k) + ...
+                        regFactor*eye(size(bestGMM.sigma,1));
+                     bestGMM.sigma(:,:,k) = (bestGMM.sigma(:,:,k) + bestGMM.sigma(:,:,k)')/2;
+                     [~,p] = cholcov(bestGMM.sigma(:,:,k),0);
+                     if p ~= 0
+                        bestGMM.sigma(:,:,k) = bestGMM.sigma(:,:,k) + ...
+                           max(max(bestGMM.sigma(:,:,k)))*regFactor*eye(size(bestGMM.sigma,1));
+                        bestGMM.sigma(:,:,k) = (bestGMM.sigma(:,:,k)+bestGMM.sigma(:,:,k)')/2;
+                     end
+                  end    
+               end
+               
+               % Construct MATLAB GMM object
+               gmmObj = gmdistribution(bestGMM.mu(:,regionPredOpt.isInformative),...
+                                       bestGMM.sigma,...
+                                       bestGMM.w);
+            else
+               % Prepare covariance for MATLAB build-in GMM
+               bestGMM.sigma = shiftdim(bestGMM.sigma(1,regionPredOpt.isInformative,...
+                                                              regionPredOpt.isInformative),1);
+               % Regularize covariances if necessary
+               [~,p] = cholcov(squeeze(bestGMM.sigma(:,:,1)),0);
+               if p ~= 0
+                  bestGMM.sigma(:,:,1) = bestGMM.sigma(:,:,1) + ...
+                     regFactor*eye(size(bestGMM.sigma,1));
+                  bestGMM.sigma(:,:,1) = (bestGMM.sigma(:,:,1) + bestGMM.sigma(:,:,1)')/2;
+                  [~,p] = cholcov(bestGMM.sigma(:,:,1),0);
+                  if p ~= 0
+                     bestGMM.sigma(:,:,1) = bestGMM.sigma(:,:,1) + ...
+                        max(max(bestGMM.sigma(:,:,1)))*regFactor*eye(size(bestGMM.sigma,1));
+                     bestGMM.sigma(:,:,1) = (bestGMM.sigma(:,:,1)+bestGMM.sigma(:,:,1)')/2;
+                  end
+               end
+               
+               % Construct MATLAB GMM object
+               gmmObj = gmdistribution(bestGMM.mu(1,regionPredOpt.isInformative),...
+                                       bestGMM.sigma,...
+                                       bestGMM.w(1));               
+            end
+            
+            % Display the successfully trained GMM progress
+            if strcmp(regionPredOpt.displayMode,'text') || strcmp(regionPredOpt.displayMode,'visual') 
+               disp(['After bootstrapping ' num2str(mod(bestModeNumber-1,nRegionNumbers)+1) ...
+                  ' modes were found optimal.']);
+               disp(' '); msg = '';
+            end
+            
+            % Reset local adaptation: Initialize all sigma to the recently adapted one, since this
+            % is usually a better guess than sigma0. Also initialize theta
+            % within the GMM centers. Needs predictions of the old points
+            j = ceil(nPhase / bestGMM.nModes) * ones(nTemps,nMaxRegions);
+            
+            [~,oldLabels]=max(posterior(gmmObj,res.par(regionPredOpt.isInformative,1:nPhase-1)')');
+            for n = 1:bestGMM.nModes
+               oldSigmas(:,:,n) = cov(res.par(:,find(oldLabels==n))');
+            end
+            
+            for m = 1:nTemps
+               % Use the so far trained sigma as global sigma
+               sigmaHistGlobal(:,:,m)  = squeeze(sigma(:,:,m,1));
+               sigmaGlobal(:,:,m)      = squeeze(sigma(:,:,m,1));
+               muHistGlobal(:,m)       = squeeze(muHist(:,m,1));
+               sigmaScaleGlobal(m)     = sigmaScale(m,1);
+               
+               % Initialize the locals sigmas with the GMM covariances
+               for n = 1:bestGMM.nModes
+                  sigma(:,:,m,n)     = oldSigmas(:,:,n);
+                  sigmaHist(:,:,m,n) = oldSigmas(:,:,n);
+                  sigmaScale(m,n)    = 1;
+                  muHist(:,m,n)      = bestGMM.mu(n,:);
+                  acc(m,n)           = 0;
+               end
+               
+            end
+
+            
+            % Predict old label
+            [~,oL(l)]=max(posterior(gmmObj,theta(regionPredOpt.isInformative,l)'));
+            
+         elseif (i == nPhase)
+            
+            % Predict old label
+            [~,oL(l)]=max(posterior(gmmObj,theta(regionPredOpt.isInformative,l)'));
+  
+            
+         elseif (i > nPhase)
+            oL(l) = nL(l);
+         else
+            oL(l) = 1;
+         end
+
+         % Relative Index for local adaptation for each temperature and
+         % each region
+         j(l,oL(l)) = j(l,oL(l)) + 1;          
+         
+         % Propose (50% chance of local sigma and 50% chance of global sigma)
+         if rand < 0.5 || ~useSmallWorld
+            thetaProp = mvnrnd(theta(:,l),sigma(:,:,l,oL(l)))';
+         else
+            thetaProp = mvnrnd(theta(:,l),sigmaGlobal(:,:,l))';
+         end
+         
+         % Get region label of proposed point 
+         if i > nPhase
+            [~,nL(l)]=max(posterior(gmmObj,thetaProp(regionPredOpt.isInformative)'));
+         else
+            nL(l) = 1;
+         end
+         
+         % Check for Bounds
+         if (sum(thetaProp < thetaMin) + sum(thetaProp > thetaMax)) == 0
+            
+            inbounds = 1;
+            
+            % Proposed posterior value
+            logPostProp(l) = logPostHandle(thetaProp);
+              
+         else
+            inbounds = 0;
+         end
+         
+         % Transition and Acceptance Probabilities      
+         if (inbounds == 1) && (logPostProp(l) > -inf) && (logPostProp(l) < inf)
+            
+            % Transitions probabilities may differer if the proposed point
+            % lays within a different region. The contribution of the
+            % global component is symmetric
+            if nL(l) ~= oL(l)
+               
+               if useSmallWorld
+                  % For numerical stability
+                  globalContribution = logmvnpdf(thetaProp, theta(:,l), sigmaGlobal(:,:,l));
+                  localFor           = logmvnpdf(thetaProp, theta(:,l), sigma(:,:,l,oL(l)));
+                  localBack          = logmvnpdf(theta(:,l), thetaProp, sigma(:,:,l,nL(l)));
+
+                  maxContFor         = max(globalContribution,localFor);
+                  maxContBack        = max(globalContribution,localBack);
+
+                  logTransFor(l)  = maxContFor + log( exp( globalContribution - maxContFor) +...
+                                                     exp( localFor - maxContFor));
+                  logTransBack(l) = maxContBack + log( exp( globalContribution - maxContBack) +...
+                                                     exp( localBack - maxContBack));  
+               else
+                  logTransFor(l)  = logmvnpdf(thetaProp, theta(:,l), sigma(:,:,l,oL(l)));
+                  logTransBack(l) = logmvnpdf(theta(:,l), thetaProp, sigma(:,:,l,nL(l)));
+               end
+               
+            else
+               logTransFor(l)  = 0;     
+               logTransBack(l) = 0;                  
+            end
+            log_pAcc(l) = beta(l)*(logPostProp(l)-logPost(l)) + logTransBack(l) - logTransFor(l);
+            
+            % Do not use min, due to NaN behavior in Matlab
+            if isnan(log_pAcc(l))       % May happen if the objective function has numerical problems
+               log_pAcc(l) = -inf;            
+            elseif log_pAcc(l) > 0       
+               log_pAcc(l) = 0;
+            end
+         else
+            log_pAcc(l) = -inf;
+         end
+         
+         % Accept or reject
+         if log(rand) <= log_pAcc(l)
+            acc(l,oL(l))       = acc(l,oL(l)) + 1;
+            theta(:,l)         = thetaProp;
+            logPost(l)         = logPostProp(l);
+         else
+            % The new label of the next iteration will be needed as old
+            % label
+            nL(l)              = oL(l);            
+         end
+         
+      end
+      
+      % Update Proposal
+      for l = 1:nTemps
+         % Updating of mean and covariance
+         [muHist(:,l,oL(l)),sigmaHist(:,:,l,oL(l))] = ...
+            updateStatistics(muHist(:,l,oL(l)), sigmaHist(:,:,l,oL(l)), ...
+            theta(:,l), ...
+            max(j(l,oL(l))+1,memoryLength), alpha);
+         sigmaScale(l,oL(l)) = sigmaScale(l,oL(l))*...
+            exp((exp(log_pAcc(l))-0.234)/(j(l,oL(l))+1)^alpha);
+         
+         if useSmallWorld
+            [muHistGlobal(:,l),sigmaHistGlobal(:,:,l)] = ...
+               updateStatistics(muHistGlobal(:,l), sigmaHistGlobal(:,:,l), ...
+               theta(:,l), ...
+               max(i,memoryLength), alpha);
+            sigmaScaleGlobal(l) = sigmaScaleGlobal(l)*...
+               exp((exp(log_pAcc(l))-0.234)/(i)^alpha); 
+         end
+         
+         % Set sigma for the next iteration (recently added like this)
+         sigma(:,:,l,oL(l)) = sigmaScale(l,oL(l))^2 * sigmaHist(:,:,l,oL(l));
+         if useSmallWorld
+            sigmaGlobal(:,:,l) = sigmaScaleGlobal(l)^2 * sigmaHistGlobal(:,:,l);
+         end
+         
+         % Regularization of Sigma
+         [~,p] = cholcov(sigma(:,:,l,oL(l)),0);
+         if p ~= 0
+            sigma(:,:,l,oL(l)) = sigma(:,:,l,oL(l)) + regFactor*eye(nPar);
+            sigma(:,:,l,oL(l)) = (sigma(:,:,l,oL(l))+sigma(:,:,l,oL(l))')/2;
+            [~,p] = cholcov(sigma(:,:,l,oL(l)),0);
+            if p ~= 0
+               sigma(:,:,l,oL(l)) = sigma(:,:,l,oL(l)) + max(max(sigma(:,:,l,oL(l))))*eye(nPar);
+               sigma(:,:,l,oL(l)) = (sigma(:,:,l,oL(l))+sigma(:,:,l,oL(l))')/2;
+            end
+         end
+         if useSmallWorld
+            [~,p] = cholcov(sigmaGlobal(:,:,l),0);
+            if p ~= 0
+               sigmaGlobal(:,:,l) = sigmaGlobal(:,:,l) + regFactor*eye(nPar);
+               sigmaGlobal(:,:,l) = (sigmaGlobal(:,:,l)+sigmaGlobal(:,:,l)')/2;
+               [~,p] = cholcov(sigmaGlobal(:,:,l),0);
+               if p ~= 0
+                  sigmaGlobal(:,:,l) = sigmaGlobal(:,:,l) + max(max(sigmaGlobal(:,:,l)))*eye(nPar);
+                  sigmaGlobal(:,:,l) = (sigmaGlobal(:,:,l)+sigmaGlobal(:,:,l)')/2;
+               end
+            end   
+         end
+         
+      end
+      
+      % Swaps between all adjacent chains as in Vousden16
+      if nTemps > 1
+         dBeta = beta(1:end-1) - beta(2:end);
+         for l = nTemps:-1:2
+            log_pAccSwap(l-1) = dBeta(l-1) .* (logPost(l)-logPost(l-1))';
+            A(l-1) = log(rand) < log_pAccSwap(l-1);
+            propSwap(l-1) = propSwap(l-1) + 1;
+            accSwap(l-1) = accSwap(l-1) + A(l-1);
+            % As usually implemented when using PT
+            if A(l-1)
+               theta(:,[l,l-1]) = theta(:,[l-1,l]);
+               logPost([l,l-1]) = logPost([l-1,l]);
+               nL([l,l-1])      = nL([l-1,l]);
+            end
+         end
+      end
+      
+      % Adaptation of the temperature values (Vousden 2016)
+      if nTemps > 1
+         
+         % Vousden python Code & Paper
+         kappa = temperatureNu / ( j(l,oL(l)) + 1 + temperatureNu ) / temperatureEta;
+         dS = kappa*(A(1:end-1)-A(2:end)); 
+         dT = diff(1./beta(1:end-1));
+         dT = dT .* exp(dS);
+         beta(1:end-1) = 1./cumsum([1,dT]);
+    
+      end
+      
+      % Store iteration
+      if doDebug
+         res.par(:,i,:)          = theta;
+         res.logPost(i,:)        = logPost;
+         res.j                   = j;
+         res.acc(i,:,:)          = 100*acc./j;
+         res.propSwap            = propSwap;
+         res.accSwap             = accSwap;
+         res.ratioSwap           = accSwap ./ propSwap;
+         res.sigmaScale(i,:,:)   = sigmaScale;
+         res.sigmaHist           = sigmaHist;
+         res.sigmaHistGlobal     = sigmaHistGlobal;
+         res.temperatures(i,:)   = 1./beta;
+         res.newLabel(i,:)       = nL(:);
+         res.oldLabel(i,:)       = oL(:);
+      else
+         res.par(:,i)            = theta(:,1);
+         res.logPost(i)          = logPost(1);
+         res.newLabel(i,:)       = nL(1);
+      end
+      
+      i = i + 1;
+
+   end
+   
+   switch opt.mode
+      case {'visual','text'}
+         fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+      case 'silent'
+   end
+   
+end
diff --git a/Requirements/PESTO-1.1.0/private/plot_gaussian_ellipsoid.m b/Requirements/PESTO-1.1.0/private/plot_gaussian_ellipsoid.m
new file mode 100644
index 0000000000000000000000000000000000000000..a172c4f7590f886543eb684c315ce2fa696cfa3d
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/plot_gaussian_ellipsoid.m
@@ -0,0 +1,114 @@
+function h = plot_gaussian_ellipsoid(m, C, sdwidth, npts, axh)
+% PLOT_GAUSSIAN_ELLIPSOIDS plots 2-d and 3-d Gaussian distributions
+%
+% H = PLOT_GAUSSIAN_ELLIPSOIDS(M, C) plots the distribution specified by 
+%  mean M and covariance C. The distribution is plotted as an ellipse (in 
+%  2-d) or an ellipsoid (in 3-d).  By default, the distributions are 
+%  plotted in the current axes. H is the graphics handle to the plotted 
+%  ellipse or ellipsoid.
+%
+% PLOT_GAUSSIAN_ELLIPSOIDS(M, C, SD) uses SD as the standard deviation 
+%  along the major and minor axes (larger SD => larger ellipse). By 
+%  default, SD = 1. Note: 
+%  * For 2-d distributions, SD=1.0 and SD=2.0 cover ~ 39% and 86% 
+%     of the total probability mass, respectively. 
+%  * For 3-d distributions, SD=1.0 and SD=2.0 cover ~ 19% and 73%
+%     of the total probability mass, respectively.
+%  
+% PLOT_GAUSSIAN_ELLIPSOIDS(M, C, SD, NPTS) plots the ellipse or 
+%  ellipsoid with a resolution of NPTS (ellipsoids are generated 
+%  on an NPTS x NPTS mesh; see SPHERE for more details). By
+%  default, NPTS = 50 for ellipses, and 20 for ellipsoids.
+%
+% PLOT_GAUSSIAN_ELLIPSOIDS(M, C, SD, NPTS, AX) adds the plot to the
+%  axes specified by the axis handle AX.
+%
+% Examples: 
+% -------------------------------------------
+%  % Plot three 2-d Gaussians
+%  figure; 
+%  h1 = plot_gaussian_ellipsoid([1 1], [1 0.5; 0.5 1]);
+%  h2 = plot_gaussian_ellipsoid([2 1.5], [1 -0.7; -0.7 1]);
+%  h3 = plot_gaussian_ellipsoid([0 0], [1 0; 0 1]);
+%  set(h2,'color','r'); 
+%  set(h3,'color','g');
+% 
+%  % "Contour map" of a 2-d Gaussian
+%  figure;
+%  for sd = [0.3:0.4:4],
+%    h = plot_gaussian_ellipsoid([0 0], [1 0.8; 0.8 1], sd);
+%  end
+%
+%  % Plot three 3-d Gaussians
+%  figure;
+%  h1 = plot_gaussian_ellipsoid([1 1  0], [1 0.5 0.2; 0.5 1 0.4; 0.2 0.4 1]);
+%  h2 = plot_gaussian_ellipsoid([1.5 1 .5], [1 -0.7 0.6; -0.7 1 0; 0.6 0 1]);
+%  h3 = plot_gaussian_ellipsoid([1 2 2], [0.5 0 0; 0 0.5 0; 0 0 0.5]);
+%  set(h2,'facealpha',0.6);
+%  view(129,36); set(gca,'proj','perspective'); grid on; 
+%  grid on; axis equal; axis tight;
+% -------------------------------------------
+% 
+%  Gautam Vallabha, Sep-23-2007, Gautam.Vallabha@mathworks.com
+
+%  Revision 1.0, Sep-23-2007
+%    - File created
+%  Revision 1.1, 26-Sep-2007
+%    - NARGOUT==0 check added.
+%    - Help added on NPTS for ellipsoids
+
+if ~exist('sdwidth', 'var'), sdwidth = 1; end
+if ~exist('npts', 'var'), npts = []; end
+if ~exist('axh', 'var'), axh = gca; end
+
+if numel(m) ~= length(m), 
+    error('M must be a vector'); 
+end
+if ~( all(numel(m) == size(C)) )
+    error('Dimensionality of M and C must match');
+end
+if ~(isscalar(axh) && ishandle(axh) && strcmp(get(axh,'type'), 'axes'))
+    error('Invalid axes handle');
+end
+
+set(axh, 'nextplot', 'add');
+
+switch numel(m)
+   case 2, h=show2d(m(:),C,sdwidth,npts,axh);
+   case 3, h=show3d(m(:),C,sdwidth,npts,axh);
+   otherwise
+      error('Unsupported dimensionality');
+end
+
+if nargout==0,
+    clear h;
+end
+
+%-----------------------------
+function h = show2d(means, C, sdwidth, npts, axh)
+if isempty(npts), npts=50; end
+% plot the gaussian fits
+tt=linspace(0,2*pi,npts)';
+x = cos(tt); y=sin(tt);
+ap = [x(:) y(:)]';
+[v,d]=eig(C); 
+d = sdwidth * sqrt(d); % convert variance to sdwidth*sd
+bp = (v*d*ap) + repmat(means, 1, size(ap,2)); 
+h = plot(bp(1,:), bp(2,:), '-', 'parent', axh, 'linewidth', 1.5, 'color', 'black');
+
+%-----------------------------
+function h = show3d(means, C, sdwidth, npts, axh)
+if isempty(npts), npts=20; end
+[x,y,z] = sphere(npts);
+ap = [x(:) y(:) z(:)]';
+[v,d]=eig(C); 
+if any(d(:) < 0)
+   fprintf('warning: negative eigenvalues\n');
+   d = max(d,0);
+end
+d = sdwidth * sqrt(d); % convert variance to sdwidth*sd
+bp = (v*d*ap) + repmat(means, 1, size(ap,2)); 
+xp = reshape(bp(1,:), size(x));
+yp = reshape(bp(2,:), size(y));
+zp = reshape(bp(3,:), size(z));
+h = surf(axh, xp,yp,zp);
diff --git a/Requirements/PESTO-1.1.0/private/propertySanityCheck.m b/Requirements/PESTO-1.1.0/private/propertySanityCheck.m
new file mode 100644
index 0000000000000000000000000000000000000000..b1164abe17309d7d5c96a62d91d8add35f537898
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/propertySanityCheck.m
@@ -0,0 +1,27 @@
+function [ properties ] = propertySanityCheck( properties )
+%propertiesAreValid Checks if the provided properties are okay.
+
+% Check properties:
+if ~isfield(properties,'min') || ~isfield(properties,'max')
+    error('Algorithm requires lower and upper bounds');
+else
+    properties.min = properties.min(:);
+    properties.max = properties.max(:);
+end
+if length(properties.min) ~= length(properties.max)
+	error('Dimension of properties.min and properties.max does not agree.');
+else
+    if max(properties.min >= properties.max)
+        error('There exists at least one i for which properties.min(i) >= properties.max(i).');
+    end
+end
+if ~isfield(properties,'number')
+    properties.number = length(properties.min);
+else
+    if properties.number ~= length(properties.min)
+        error('Dimension mismatch: properties.number ~= length(properties.min).');
+    end
+end
+
+end
+
diff --git a/Requirements/PESTO-1.1.0/private/setObjectiveWrapper.m b/Requirements/PESTO-1.1.0/private/setObjectiveWrapper.m
new file mode 100644
index 0000000000000000000000000000000000000000..6a04360db994dd85de942669950d25955488199e
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/setObjectiveWrapper.m
@@ -0,0 +1,52 @@
+function wrapperFunction = setObjectiveWrapper(objective_function, options, type, fixedParameters, fixedParameterValues, countErrors, showWarnings)
+    
+    % This function sets the objective wrapper for PESTO. It returns the
+    % function handle of the wrapper function with all wrapper options set.
+    %
+    % Parameters:
+    %   objective_function: objective function of the user
+    %   options: PestoOptions object
+    %   type: what kind of output should the wrapper give? A maximization
+    %       (log-posterior) or a minimization problem (negative ...)?
+    %   fixedParameters: Additional Parameters, which should be fixed
+    %   fixedParameterValues: Values of fixed parameters
+    %   countErrors: Boolean, if error should be counted
+    %   showWarnings: Boolean, if warnings should be displayed
+    %
+    %   wrapperOptions (cell-array) to be written
+    %       * {1} ... type 'log-posterior' or 'negative log-posterior'
+    %       * {2} ... index set with fixed parameter values
+    %       * {3} ... fixed parameter values corresponding to the index set
+    %       * {4} ... maximum number of outputs of the objective function
+    %       * {5} ... optimizer (fmincon, meigo-ess, lsqnonlin, delos, ...)
+    %       * {6} ... global error count (true or false)
+    %       * {7} ... display warnings
+    
+    wrapperOptions = cell(1,7);
+    if strcmp(options.obj_type, 'log-posterior')
+        if strcmp(type, 'log-posterior')
+            wrapperOptions{1} = 1;
+        elseif strcmp(type, 'negative log-posterior')
+            wrapperOptions{1} = -1;
+        end
+    elseif strcmp(options.obj_type, 'negative log-posterior')
+        if strcmp(type, 'log-posterior')
+            wrapperOptions{1} = -1;
+        elseif strcmp(type, 'negative log-posterior')
+            wrapperOptions{1} = 1;
+        end
+    end
+    wrapperOptions{2} = [options.fixedParameters(:); fixedParameters(:)];
+    wrapperOptions{3} = [options.fixedParameterValues(:); fixedParameterValues(:)];
+    wrapperOptions{4} = options.objOutNumber;
+    wrapperOptions{5} = options.localOptimizer;
+    wrapperOptions{6} = countErrors;
+    wrapperOptions{7} = showWarnings;
+
+    if strcmp(wrapperOptions{5}, 'delos')
+        wrapperFunction = @(theta, miniBatch) objectiveWrap(theta,objective_function,wrapperOptions,miniBatch);
+    else
+        wrapperFunction = @(theta) objectiveWrap(theta,objective_function,wrapperOptions);
+    end
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/private/setdefault.m b/Requirements/PESTO-1.1.0/private/setdefault.m
new file mode 100644
index 0000000000000000000000000000000000000000..38c706e4a2b73f18d6d29a572dc95923df14b0d2
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/setdefault.m
@@ -0,0 +1,43 @@
+function object = setdefault(object, defaultobject)
+% setdefault sets the not defined fields of the structure object to the 
+% default values specified in the structure default object.
+%
+% Usage:
+% [object] = setdefault(object, defaultobject)
+%
+% Parameters:
+% object: The object on which default values are to be set
+% defaultobject: Structure with default values
+%
+% Return values:
+% object: The object with the original settings and default values for
+% unset options
+
+% Checks whether input object is empty
+if isempty(object)
+    % If no input is provided return default
+    object = defaultobject;
+elseif isstruct(object)
+    % Loop over all elements of object and defaultobject
+    for j = 1:max(length(defaultobject),length(object))
+        % Number of elements in object smaller than number of
+        % elements in defaultobject?
+        if j <= length(object)
+            % Generate list of field names
+            fieldlist = fieldnames(defaultobject);
+            for i = 1:length(fieldlist)
+                % Checks whether field exists
+                if any(strcmp(fieldnames(object),fieldlist{i}))
+                    % Field exists -> call setdefault.m and set all subfields to the default values
+                    object = setfield(object,{j},fieldlist{i},...
+                               setdefault(getfield(object,{j},fieldlist{i}),getfield(defaultobject,fieldlist{i})));
+                else    
+                    % Field does not exist -> set to default value
+                    object = setfield(object,{j},fieldlist{i},getfield(defaultobject,fieldlist{i}));
+                end
+            end
+        else
+          	object(j) = defaultobject(j);
+        end
+    end
+end
diff --git a/Requirements/PESTO-1.1.0/private/trainEMGMM.m b/Requirements/PESTO-1.1.0/private/trainEMGMM.m
new file mode 100644
index 0000000000000000000000000000000000000000..156023c551063b7638651935c2c850ac88d81351
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/trainEMGMM.m
@@ -0,0 +1,225 @@
+function [likelihoodOfTestSet, res] = trainEMGMM(sample, opt)
+   % This function provides the interface for an EstimationMaximation (EM)
+   % algorithm. A gaussian mixture displayModel (GMM) is trained to suit a given data
+   % set. The E-step labels all data points related to one of the GMM displayModes.
+   % The M-step updates the GMM parameters. The algorithm is initialized using
+   % kmeans. Estimates the optimal number of GMM displayModes by measuing the
+   % likelihoods of test data set given the trained GMM with
+   % n-displayModes. The results of this function may be be used to predict
+   % labels of future sets.
+   %
+   % OUTPUT: 
+   %  likelihood: Likelihood for the prediction of the test set given the
+   %     trained GMM for each opt.modeNumberCandidates.
+   %  res       : The results for optimized GMM parameters for each
+   %     opt.modeNumberCandidates.
+   %
+   % Written by Benjamin Ballnus (2017)
+   
+   %% Options
+%    oldSeed=rng; oldSeed = oldSeed.Seed;
+%    rng(opt.rng);
+   nSample              = ceil(0.5 * opt.nSample);
+   crossValFraction     = opt.crossValFraction;
+   modeNumberCandidates = opt.modeNumberCandidates;
+   displayMode          = opt.displayMode;
+   maxEMiterations      = opt.maxEMiterations;
+   nDim                 = opt.nDim;
+   nSubsetSize          = opt.nSubsetSize;
+   lowerB               = opt.lowerBound;
+   upperB               = opt.upperBound;
+   tolMu                = opt.tolMu;
+   tolSigma             = opt.tolSigma;
+   dimensionsToPlot     = opt.dimensionsToPlot;
+   isInformative        = logical(opt.isInformative);
+   
+   
+   %% Partition data into training and test set & initialization
+%    testSetIndices   = randperm(length(sample),floor(length(sample)*crossValFraction));
+%    testSetPositions = zeros(1,length(sample));changed so that it works for very short mcmc as well/kajsa
+   testSetIndices   = randperm(size(sample,1),floor(size(sample,1)*crossValFraction));
+   testSetPositions = zeros(1,size(sample,1)); 
+   testSetPositions(testSetIndices) = ones(1,length(testSetIndices));
+   testSet = sample(logical(testSetPositions),:);
+   sample = sample(~logical(testSetPositions),:);
+   likelihoodOfTestSet = zeros(1,length(modeNumberCandidates));
+   
+   %% EM for multiple number of displayModes
+   for nModes = modeNumberCandidates
+      
+      %% Refreshing initialization if nModes changes
+      
+      % WORKARROUND: Matlab automatically squeezes trailing dimensions with size 1 :(
+      if nModes == 1
+         setTrail = 1;
+         nModes = 2;
+      else
+         setTrail = 0;
+      end
+      
+      w              = ones(nModes,1) / nModes;
+      sigma          = shiftdim(repmat(diag(ones(nDim,1)),1,1,nModes),2);
+      msg            = '';
+      tic; dspTime = toc;
+      
+      % WORKARROUND - care for Bugs
+      if setTrail
+         nModes = nModes-1;
+      end
+      
+      mu             = repmat(lowerB,1,nModes)'.*ones(nModes,nDim) + ...
+                        repmat((upperB-lowerB),1,nModes)'.*rand(nModes,nDim);
+      
+      
+      initClassifier = kmeans(sample(:,isInformative),nModes);
+      r              = zeros(ceil((1-crossValFraction)*nSample),nModes);
+      for j = 1:nModes; r(:,j) = r(:,j) + (initClassifier == j); end
+      
+      
+      %% Open figure
+      if strcmp(displayMode,'visual')
+         hold all
+         drawnow;
+      end
+      
+      %% Determine informative dimensions.
+      % Dimensions with larger overlap of all displayModes are likely
+      % to be mono-modal and thus bad for classification.
+      % TODO: Find a robust way to do this automatically
+      isInformative = logical(isInformative);      
+      
+      %% Do EM for nModes
+      for i = 1:maxEMiterations
+         
+         %% Reporting Progress
+         switch displayMode
+            case {'visual'}
+               if toc-dspTime > 0.01 || i==nSample
+                  fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+                  msg = ['Progress: ' num2str(i/(maxEMiterations)*100,'%2.2f') ' %%\n'];
+                  fprintf(1,msg);
+                  dspTime = toc;
+                  try
+                     delete(hS);
+                  end
+                  hS = plot(sample(:,dimensionsToPlot(1)),sample(:,dimensionsToPlot(2)),'b.');
+                  for j = 1:nModes
+                     try
+                        delete(h(j))
+                     end
+                     if prod(~isnan(mu(j,dimensionsToPlot))) && ...
+                           prod(prod(~isnan(sigma(j,dimensionsToPlot,dimensionsToPlot)))) && ...
+                           ~isnan(w(j))
+                        h(j) = plot_gaussian_ellipsoid(squeeze(mu(j,dimensionsToPlot)),...
+                           w(j)*squeeze(sigma(j,dimensionsToPlot,dimensionsToPlot)));
+                     end
+                  end
+                  drawnow;
+               end
+            case {'text'}
+               if toc-dspTime > 0.5
+                  fprintf(1, repmat('\b',1,numel(msg)-2)) ;
+                  msg = ['Progress: ' num2str(i/(nSample)*100,'%2.2f') ' %%\n'];
+                  fprintf(1,msg);
+                  dspTime = toc;
+               end
+            case 'silent'
+         end
+         
+         %% Regularize sigma
+         for j = 1:nModes
+            [~,p] = cholcov(squeeze(sigma(j,isInformative,isInformative)),0);
+            if p ~= 0
+               cntDummy = 0;
+               while p ~= 0 && cntDummy < 1e4
+                  cntDummy = cntDummy + 1;
+                  sigma(j,isInformative,isInformative) = squeeze(sigma(j,isInformative,isInformative)) + 1e-1*eye(sum(isInformative));
+                  sigma(j,isInformative,isInformative) = (squeeze(sigma(j,isInformative,isInformative))+squeeze(sigma(j,isInformative,isInformative))')/2;
+                  [~,p] = cholcov(squeeze(sigma(j,isInformative,isInformative)),0);
+               end
+               if cntDummy >= 1e4
+                  error(['The regularization of sigma failed while trying' ...
+                     ' to estimate a GMM using EM. This is often due to' ...
+                     ' too small test samples used for training.']);
+               end
+            end
+         end
+         
+         %% E-step for a random subset of samples
+         selectedIdxs = randi(ceil((1-crossValFraction)*nSample),1,nSubsetSize);
+         for k = selectedIdxs
+            denom = 0;
+            for j = 1:nModes
+               pDummy = mvnpdf( sample(k,isInformative)', squeeze(mu(j,isInformative))', squeeze(sigma(j,isInformative,isInformative)) );
+               r(k,j) = w(j) * pDummy;
+               denom = denom + w(j) * pDummy;
+            end
+            if denom > 0
+               r(k,:) = r(k,:) / denom;
+            end
+         end
+         
+         %% M-step
+         muOld = mu;
+         sigmaOld = sigma;
+         for j = 1:nModes
+            sumDummy = sum(r(:,j));
+            w(j) = sumDummy/nSample;
+            mu(j,isInformative) = sum(bsxfun(@times,r(:,j),sample(:,isInformative)))/sumDummy;
+            sigma(j,isInformative,isInformative) = (bsxfun(@times,r(:,j),sample(:,isInformative)))'*sample(:,isInformative) / sumDummy - mu(j,isInformative)'*mu(j,isInformative);
+         end
+         
+         %% Break if terminiation condition was reached before i == nAlg
+         if logical(max(abs(muOld(:)-mu(:))) < tolMu) & ...
+               logical(max(abs((sigmaOld(:)-sigma(:)))) < tolSigma)
+            disp('Terminated because movement tolerances were reached.')
+            break
+         end
+      end
+      
+      %% Regularize Sigma in cases where its no longer invertable
+      for j = 1:nModes
+         if abs(det(squeeze(sigma(j,isInformative,isInformative)))) < 1e-10
+            factor = 1e-10;
+            while abs(det(squeeze(sigma(j,isInformative,isInformative)))) < 1e-10
+               sigma(j,isInformative,isInformative) = ...
+                  squeeze(sigma(j,isInformative,isInformative)) + factor*eye(sum(isInformative));
+               factor = factor * 2;
+            end
+         end
+      end
+      
+      %% Tag likelihood of GMM with nModes
+      idx = find(nModes == modeNumberCandidates);      
+      logNormPdf = @(x,w,mu,Sigma) log(w) - 0.5*length(x)*log(2*pi) -0.5*log(det(Sigma)) - 0.5*(x-mu)'/Sigma*(x-mu);
+      for k = 1:size(testSet,1)
+         logVals = nan(1,nModes);
+         for j = 1:nModes
+            logVals(j) = logNormPdf( testSet(k,isInformative)', ...
+               w(j), ...
+               squeeze(mu(j,isInformative))', ...
+               squeeze(sigma(j,isInformative,isInformative)));
+         end
+         maxVal = max(logVals);
+         expDiffVals = exp(logVals - maxVal);
+         logContributionOfPoint = maxVal + log(sum(expDiffVals));
+
+         likelihoodOfTestSet(idx) = likelihoodOfTestSet(idx) + logContributionOfPoint;
+      end
+      
+      %% Save results
+      res(idx).nModes   = nModes;
+      res(idx).mu       = mu;
+      res(idx).sigma    = sigma;
+      res(idx).w        = w;
+      res(idx).testLLH  = likelihoodOfTestSet(idx);
+      for i = 1:nModes
+         res(idx).detSigma(i) = det(squeeze(sigma(i,:,:)));
+      end
+      
+   end
+%    rng(oldSeed);
+end
+
+
+
diff --git a/Requirements/PESTO-1.1.0/private/updateStatistics.m b/Requirements/PESTO-1.1.0/private/updateStatistics.m
new file mode 100644
index 0000000000000000000000000000000000000000..3cde2add32fb0bdb9b07f8ae496dfdfee0205352
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/private/updateStatistics.m
@@ -0,0 +1,25 @@
+function [mu, Sigma] = updateStatistics(mu, Sigma, theta, i, decay)
+% updateStatistics updates the estimates of the sample mean and the sample
+% covariance for use in adaptive Markov chain Monte-Carlo sampling.
+%
+% USAGE:
+% [mu,Sigma] = updateStatistics(mu, Sigma, theta, i, decay, eps)
+%
+% Parameters:
+% mu: current estimate of mean
+% Sigma: current estimate of covariance
+% i: generation
+% decay: decay rate
+%
+% Return values:
+% m: updated estimate of mean
+% Sigma: updated estimate of covariance
+
+% Update rate
+gamma = 1/(i^decay);
+
+% Updating of mu and Sigma
+mu = (1-gamma)*mu + gamma*theta;
+Sigma = (1-gamma)*Sigma + gamma*(theta-mu)*(theta-mu)';
+
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/runPestoTests.m b/Requirements/PESTO-1.1.0/runPestoTests.m
new file mode 100644
index 0000000000000000000000000000000000000000..ede06275a94c80a70b3c20e1ee0eb2b04aacfbc7
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/runPestoTests.m
@@ -0,0 +1,6 @@
+function runPestoTests()
+    % runPestoTests Run a set of PESTO unit tests
+    import matlab.unittest.TestSuite
+    run(TestSuite.fromFolder('tests'))
+end
+
diff --git a/Requirements/PESTO-1.1.0/sortMultiStarts.m b/Requirements/PESTO-1.1.0/sortMultiStarts.m
new file mode 100644
index 0000000000000000000000000000000000000000..d9e5b31c3242f5ee3e87ac93eb813c73729c5895
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/sortMultiStarts.m
@@ -0,0 +1,88 @@
+function [parameters] = sortMultiStarts(parameters)
+% sortMultiStarts.m sorts the multi-start results from highest to lowest logarithm of the posterior probability 'logPost'.
+%
+% USAGE:
+% [parameters] = sortMultiStart(parameters)
+%
+% Parameters:
+% parameters: parameters struct
+%
+% Return values:
+% parameters: parameter struct with sorted MS
+%
+% History:
+% * 2014/06/12 Jan Hasenauer
+
+%% Sort
+[~,ind] = sort(parameters.MS.logPost,1,'descend');
+ind = ind([find(~isnan(parameters.MS.logPost(ind)));...
+           find( isnan(parameters.MS.logPost(ind)))]);
+if(isfield(parameters.MS,'fval_trace'))
+    min_fval = transpose(min(parameters.MS.fval_trace(:,isnan(parameters.MS.logPost(ind)))));
+    [~,sort_unfinished] = sort(min_fval,1,'ascend');
+    ind_unfinished = ind(find( isnan(parameters.MS.logPost(ind))));
+    ind = [ind(~isnan(parameters.MS.logPost(ind)));...
+           ind_unfinished(sort_unfinished)];    
+end
+
+%% Assignment of variables which are always contained in the struct
+if isfield(parameters.MS,'par0')
+    parameters.MS.par0 = parameters.MS.par0(:,ind);
+end
+
+if isfield(parameters.MS,'par')
+    parameters.MS.par = parameters.MS.par(:,ind);
+end
+
+if isfield(parameters.MS,'logPost0')
+    parameters.MS.logPost0 = parameters.MS.logPost0(ind);
+end
+
+if isfield(parameters.MS,'logPost')
+    parameters.MS.logPost = parameters.MS.logPost(ind);
+end
+
+if isfield(parameters.MS,'gradient')
+    parameters.MS.gradient = parameters.MS.gradient(:,ind);
+end
+
+if isfield(parameters.MS,'hessian')
+    parameters.MS.hessian = parameters.MS.hessian(:,:,ind);
+end
+
+if isfield(parameters.MS,'n_objfun')
+    parameters.MS.n_objfun = parameters.MS.n_objfun(ind);
+end
+
+if isfield(parameters.MS,'n_iter')
+    parameters.MS.n_iter = parameters.MS.n_iter(ind);
+end
+
+if isfield(parameters.MS,'t_cpu')
+    parameters.MS.t_cpu = parameters.MS.t_cpu(ind);
+end
+
+if isfield(parameters.MS,'exitflag')
+    parameters.MS.exitflag = parameters.MS.exitflag(ind);
+end
+
+if isfield(parameters.MS,'AIC')
+    parameters.MS.AIC = parameters.MS.AIC(ind);
+end
+
+if isfield(parameters.MS,'BIC')
+    parameters.MS.BIC = parameters.MS.BIC(ind);
+end
+
+%% Assignment of variables which are not always contained in the struct
+if isfield(parameters.MS,'par_trace')
+    parameters.MS.par_trace = parameters.MS.par_trace(:,:,ind);
+end
+
+if isfield(parameters.MS,'fval_trace')
+    parameters.MS.fval_trace = parameters.MS.fval_trace(:,ind);
+end
+
+if isfield(parameters.MS,'time_trace')
+    parameters.MS.time_trace = parameters.MS.time_trace(:,ind);
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/testGradient.m b/Requirements/PESTO-1.1.0/testGradient.m
new file mode 100644
index 0000000000000000000000000000000000000000..b829ed3a75cba8acaec4a55aacaa1accdf084095
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/testGradient.m
@@ -0,0 +1,313 @@
+function [g, g_fd_f, g_fd_b, g_fd_c] = testGradient(varargin)
+    % testGradient.m calculates finite difference approximations to the
+    %   gradient to check an analytical version.
+    %
+    %   backward differences: g_fd_f = (f(theta+eps*e_i) - f(theta))/eps\n
+    %   forward differences:  g_fd_b = (f(theta) - f(theta-eps*e_i))/eps\n
+    %   central differences:  g_fd_c = (f(theta+eps*e_i) - f(theta-eps*e_i))/(2*eps)\n
+    %
+    %   in order to work with tensors of order n the gradient must be returned as tensor of
+    %   order n+1 where the n+1th tensor dimension indexes the parameters with respect to which
+    %   the differentiation was carried out
+    %
+    % USAGE:
+    % [...] = testGradient(theta,fun,eps,il,ig)
+    % [g,g_fd_f,g_fd_b,g_fd_c] = testGradient(...)
+    %
+    % Parameters:
+    % varargin:
+    % theta: parameter vector at which gradient is evaluated.
+    % fun: function of theta for which gradients are checked.
+    % eps: epsilon used for finite difference approximation of gradient (eps = 1e-4).
+    % il: argout index/fieldname at which function values are returned (default = 1).
+    % ig: argout index/fieldname at which gradient values are returned (default = 2).
+    %
+    % Return values:
+    % g: gradient computed by f
+    % g_fd_f: backward differences
+    % g_fd_b: forward differences
+    % g_fd_c: central differences
+    %
+    % History:
+    % * 2014/06/11 Jan Hasenauer
+    % * 2015/01/16 Fabian Froehlich
+    % * 2015/04/03 Jan Hasenauer
+    % * 2015/07/28 Fabian Froehlich
+    
+    theta = varargin{1};
+    fun = varargin{2};
+    if nargin >= 3
+        eps = varargin{3};
+    else
+        eps = 1e-4;
+    end
+    
+    if nargin >= 4
+        il = varargin{4};
+    else
+        il = 1;
+    end
+    
+    if nargin >= 5
+        ig = varargin{5};
+    else
+        ig = 2;
+    end
+    
+    if nargin >= 6
+        if(~isempty(varargin{6}))
+            plist = varargin{6};
+        else
+            plist = 1:length(theta);
+        end
+    else
+        plist = 1:length(theta);
+    end
+    
+    if nargin >= 7
+        fplot = varargin{7};
+    else
+        fplot = false;
+    end
+    
+    
+    theta = theta(:);
+    
+    if(~ischar(ig))
+        % Evaluation of function and gradient
+        if(ig<0 || round(ig)~=ig)
+            error('gradient argout index must be positive')
+        end
+        
+        str_1 = '[';
+        ip = 1;
+        while true
+            if(~ischar(il))
+                if(ip==ig)
+                    str_1 = [str_1 'g'];
+                elseif(ip==il)
+                    str_1 = [str_1 'l'];
+                else
+                    str_1 = [str_1 '~'];
+                end
+                if ip == max(ig,il);
+                    eval([str_1 '] = fun(theta);']);
+                    break;
+                else
+                    str_1 = [str_1 ','];
+                end
+                ip=ip+1;
+            else
+                if(ip==ig)
+                    str_1 = [str_1 'g'];
+                else
+                    str_1 = [str_1 '~'];
+                end
+                if ip == max(ig);
+                    eval([str_1 '] = fun(theta);']);
+                    break;
+                else
+                    str_1 = [str_1 ','];
+                end
+                ip=ip+1;
+            end
+        end
+    else
+        struct = fun(theta);
+        eval(['g = struct.' ig ';']);
+    end
+    sg = size(g);
+    if((numel(sg) == 2) && (sg(end) == 1))
+        g = g(plist);
+    else
+        eval(['g = g(' repmat(':,',1,numel(sg)-1) 'plist);'])
+    end
+    
+    
+    % Computation of finite difference gradient
+    g_fd_f = nan(size(g));
+    g_fd_b = nan(size(g));
+    g_fd_c = nan(size(g));
+    
+    if(~ischar(il))
+        if(il<0)
+            error('function argout index must be positive')
+        end
+        if(round(il)~=il)
+            error('function argout index must be positive')
+        end
+        str_2 = '[';
+        % Evaluation of function and gradient
+        ip = 1;
+        while true
+            if(ip==il)
+                str_2 = [str_2 'l'];
+            else
+                str_2 = [str_2 '~'];
+            end
+            if ip == max(il);
+                break;
+            else
+                str_2 = [str_2 ','];
+            end
+            ip=ip+1;
+        end
+    else
+        struct = fun(theta);
+        eval(['l = struct.' il ';']);
+    end
+    
+    for ip = 1:length(plist)
+        disp(['computing FD for parameter index ' num2str(plist(ip))])
+        % function evaluation
+        if(~ischar(il))
+            eval([str_2 '_i_f] = fun(theta+[zeros(plist(ip)-1,1);eps;zeros(length(theta)-plist(ip),1)]);']);
+            eval([str_2 '_i_b] = fun(theta-[zeros(plist(ip)-1,1);eps;zeros(length(theta)-plist(ip),1)]);']);
+        else
+            struct_i_f = fun(theta+[zeros(plist(ip)-1,1);eps;zeros(length(theta)-plist(ip),1)]);
+            eval(['l_i_f = struct_i_f.' il ';']);
+            struct_i_b = fun(theta-[zeros(plist(ip)-1,1);eps;zeros(length(theta)-plist(ip),1)]);
+            eval(['l_i_b = struct_i_b.' il ';']);
+        end
+        
+        if(length(plist)==1)
+            % forward differences
+            eval(['g_fd_f(' repmat(':,',1,numel(size(g))) 'ip) = (l_i_f-l)/eps;'])
+            
+            % backward differences
+            eval(['g_fd_b(' repmat(':,',1,numel(size(g))) 'ip) = -(l_i_b-l)/eps;'])
+            
+            % central differences
+            eval(['g_fd_c(' repmat(':,',1,numel(size(g))) 'ip) = (l_i_f-l_i_b)/(2*eps);'])
+        elseif(sg(end)==1)
+            eval(['g_fd_f(' repmat(':,',1,numel(size(g))-2) 'ip) = (l_i_f-l)/eps;'])
+            
+            % backward differences
+            eval(['g_fd_b(' repmat(':,',1,numel(size(g))-2) 'ip) = -(l_i_b-l)/eps;'])
+            
+            % central differences
+            eval(['g_fd_c(' repmat(':,',1,numel(size(g))-2) 'ip) = (l_i_f-l_i_b)/(2*eps);'])
+        else
+            % forward differences
+            eval(['g_fd_f(' repmat(':,',1,numel(size(g))-1) 'ip) = (l_i_f-l)/eps;'])
+            
+            % backward differences
+            eval(['g_fd_b(' repmat(':,',1,numel(size(g))-1) 'ip) = -(l_i_b-l)/eps;'])
+            
+            % central differences
+            eval(['g_fd_c(' repmat(':,',1,numel(size(g))-1) 'ip) = (l_i_f-l_i_b)/(2*eps);'])
+        end
+    end
+    
+    if(fplot)
+        figure
+        
+        
+        subplot(2,3,1)
+        error_plot(g_fd_f(:),g_fd_b(:),g_fd_c(:))
+        legend('FDf','FDb','Location','NorthWest')
+        ylabel('FDc')
+        xlabel('derivative value')
+        title('if points do not lie on diagonal, change step-size')
+        
+        subplot(2,3,2)
+        error_plot(g_fd_f(:)-g_fd_c(:),g_fd_b(:)-g_fd_c(:),g(:)-g_fd_c(:))
+        legend('FDf','FDb','Location','NorthWest')
+        xlabel('difference to FDc')
+        title('if red and blue dots do not agree, change step-size')
+        
+        subplot(2,3,3)
+        error_plot(g(:),g_fd_c(:),g(:)-g_fd_c(:))
+        title('if red dots lie above diagonal, check gradient implementation')
+        
+        subplot(2,3,4)
+        ratio_plot(g_fd_f(:),g_fd_c(:),g_fd_f(:)./g_fd_c(:),g_fd_f(:)-g_fd_c(:))
+        legend('FDf','FDc','Location','NorthWest')
+        ylabel('ratio FDf/FDc')
+        xlabel('derivative value')
+        title('if points do not lie on horizontal line change step-size')
+        
+        subplot(2,3,5)
+        ratio_plot(g_fd_f(:)-g_fd_c(:),g_fd_b(:)-g_fd_c(:),g(:)./g_fd_c(:),g_fd_f(:)-g_fd_c(:))
+        legend('FDf','FDb','Location','NorthWest')
+        xlabel('difference to FDc')
+        title('if red and blue dots do not agree, change step-size')
+        
+        
+        subplot(2,3,6)
+        ratio_plot(g(:),g_fd_c(:),g(:)./g_fd_c(:),g_fd_f(:)-g_fd_c(:))
+        title('if red dots do not lie on horizontal, check gradient implementation')
+    end
+end
+
+function error_plot(g1,g2,ee)
+    % Plots the differences between gradient and finite differences
+    %
+    % Parameters:
+    % g1: Gradient
+    % g2: Finite differences
+    % ee:
+    
+    scatter(abs(g1),abs(ee),'rx')
+    hold on
+    scatter(abs(g2),abs(ee),'bo')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    e = [abs(ee);abs(g1);abs(g2)];
+    mine = min(e(e>0))*0.5;
+    maxe = max(e(e>0))*2;
+    if(isempty(mine))
+        mine = 1e-1;
+        maxe = 1e0;
+    end
+    xlim([mine,maxe])
+    ylim([mine,maxe])
+    if(isempty(mine))
+        mine = 1e-1;
+        maxe = 1e0;
+    end
+    plot([mine,maxe],[mine,maxe],'k:');
+    legend('Gradient','FDc','Location','NorthWest')
+    xlabel('derivative value')
+    ylabel('difference |Gradient-FDc|')
+    axis square
+    box on
+end
+
+function ratio_plot(g1,g2,rr,ee)
+    % Plots the differences between gradient and finite differences
+    %
+    % Parameters:
+    % g1: Gradient
+    % g2: Finite differences
+    % rr:
+    % ee:
+    
+    scatter(abs(g1),abs(rr),'rx')
+    hold on
+    scatter(abs(g2),abs(rr),'bo')
+    set(gca,'YScale','log')
+    set(gca,'XScale','log')
+    e = [abs(ee);abs(g1);abs(g2)];
+    mine = min(e(e>0))*0.5;
+    maxe = max(e(e>0))*2;
+    if(isempty(mine))
+        mine = 1e-1;
+        maxe = 1e0;
+    end
+    r = [abs(rr)];
+    minr = min(r(r>0))*0.5;
+    maxr = max(r(r>0))*2;
+    xlim([mine,maxe])
+    try
+        ylim([minr,maxr])
+    catch
+        ylim([1e-1,1e1])
+    end
+    plot([mine,maxe],[1,1],'k:');
+    legend('Gradient','FDc','Location','SouthEast')
+    xlabel('derivative value')
+    ylabel('ratio Gradient/FDc')
+    axis square
+    box on
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/tests/ConversionReactionTest.m b/Requirements/PESTO-1.1.0/tests/ConversionReactionTest.m
new file mode 100644
index 0000000000000000000000000000000000000000..41e99f3adb834fabd8cf7c78b81a37145d4e90f0
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/tests/ConversionReactionTest.m
@@ -0,0 +1,175 @@
+%% Test Class Definition
+classdef ConversionReactionTest < matlab.unittest.TestCase
+    properties
+        oldPath
+        parameters
+        theta_true = [-2.5;-2];
+        llh_true = 32.275546152684690;
+        t = (0:10)';        % time points
+        sigma2 = 0.015^2;   % measurement noise
+        y = [0.0244; 0.0842; 0.1208; 0.1724; 0.2315; 0.2634; ...
+            0.2831; 0.3084; 0.3079; 0.3097; 0.3324]; % Measurement data
+        objectiveFunction
+    end
+    
+    methods(TestMethodSetup)
+        function initializeRng(testCase)
+            rng(0)
+        end
+        
+        function setPath(testCase)
+            testCase.oldPath = path();
+            addpath(fullfile(fileparts(mfilename('fullpath')), '..','examples', 'conversion_reaction'));
+        end
+        
+        function setupParameters(testCase)
+            testCase.parameters.name = {'log_{10}(k_1)','log_{10}(k_2)'};
+            testCase.parameters.min = [-7,-7];
+            testCase.parameters.max = [ 3, 3];
+            testCase.parameters.number = length(testCase.parameters.name);
+        end
+        
+        function setupObjectiveFunction(testCase)
+            testCase.objectiveFunction = @(theta) logLikelihoodCR(theta, testCase.t, testCase.y, testCase.sigma2, 'log');
+        end
+                
+    end
+    
+    methods(TestMethodTeardown)
+        function restorePath(testCase)
+            path(testCase.oldPath);
+        end
+    end
+    
+    %% Test Method Block
+    methods (Test)
+        function testObjectiveFunction(testCase)
+            actLLH = testCase.objectiveFunction(testCase.theta_true);
+            testCase.fatalAssertEqual(actLLH, testCase.llh_true, 'AbsTol', eps, 'Likelihood function result is wrong.')
+        end
+        
+        function testGetMultiStartsOptionStruct(testCase)
+            % check autoconversion to PestoOptions
+            optionsMS.obj_type = 'log-posterior';
+            optionsMS.n_starts = 1;
+            optionsMS.comp_type = 'sequential';
+            optionsMS.mode = 'silent';
+
+            multiStartParams = getMultiStarts(testCase.parameters, testCase.objectiveFunction, optionsMS);
+            testCase.verifyMultiStartResults(multiStartParams, optionsMS);
+        end
+        
+        function testGetMultiStartsFminconSingleStart(testCase)
+            optionsMS = PestoOptions();
+            optionsMS.obj_type = 'log-posterior';
+            optionsMS.n_starts = 1;
+            optionsMS.comp_type = 'sequential';
+            optionsMS.mode = 'silent';
+
+            multiStartParams = getMultiStarts(testCase.parameters, testCase.objectiveFunction, optionsMS);
+            testCase.verifyMultiStartResults(multiStartParams, optionsMS);
+        end
+        
+        function testGetMultiStartsFmincon(testCase)
+            optionsMultistart = PestoOptions();
+            optionsMultistart.obj_type = 'log-posterior';
+            optionsMultistart.n_starts = 4;
+            optionsMultistart.comp_type = 'sequential';
+            optionsMultistart.mode = 'silent';
+
+            multiStartParams = getMultiStarts(testCase.parameters, testCase.objectiveFunction, optionsMultistart);
+            testCase.verifyMultiStartResults(multiStartParams, optionsMultistart);
+        end
+        
+        function testGetMultiStartsMeigo(testCase)
+            testCase.assumeTrue(exist('MEIGO', 'file') == 2,'MEIGO not in path.');
+            
+            MeigoOptions = struct(...
+                'maxeval', 1e3, ...
+                'iterprint', 0, ...
+                'local', struct('solver', 'fmincon', ...
+                'finish', 'fmincon', ...
+                'iterprint', 0) ...
+                );
+            
+            optionsMultistartMeigo = PestoOptions();
+            optionsMultistartMeigo.obj_type = 'log-posterior';
+            optionsMultistartMeigo.comp_type = 'sequential';
+            optionsMultistartMeigo.mode = 'silent';
+            optionsMultistartMeigo.localOptimizer = 'meigo-ess';
+            optionsMultistartMeigo.localOptimizerOptions = MeigoOptions;
+            optionsMultistartMeigo.n_starts = 2;
+            
+            parametersMeigo = getMultiStarts(testCase.parameters, testCase.objectiveFunction, optionsMultistartMeigo);
+            testCase.verifyMultiStartResults(parametersMeigo, optionsMultistartMeigo);
+        end
+        
+        function testSamplingPT(testCase)
+            optionsMultistart = PestoOptions();
+            optionsMultistart.obj_type = 'log-posterior';
+            optionsMultistart.n_starts = 1;
+            optionsMultistart.comp_type = 'sequential';
+            optionsMultistart.mode = 'silent';
+            multiStartParams = getMultiStarts(testCase.parameters, testCase.objectiveFunction, optionsMultistart);
+            testCase.verifyMultiStartResults(multiStartParams, optionsMultistart);
+
+            optionsSampling = PestoSamplingOptions();
+            optionsSampling.nIterations = 100;
+            optionsSampling.mode = 'silent';
+            
+            optionsSampling.samplingAlgorithm   = 'PT';
+            optionsSampling.PT.nTemps           = 3;
+            optionsSampling.PT.exponentT        = 4;
+            optionsSampling.PT.temperatureAdaptionScheme = 'Lacki15';
+            
+            optionsSampling.theta0 = multiStartParams.MS.par(:,1);
+            optionsSampling.sigma0 = 0.5 * inv(squeeze(multiStartParams.MS.hessian(:,:,1)));
+            
+            % Run the sampling
+            getParameterSamples(multiStartParams, testCase.objectiveFunction, optionsSampling);
+        end
+        
+        function testConfidenceIntervals(testCase)
+            
+            options = PestoOptions();
+            options.obj_type = 'log-posterior';
+            options.n_starts = 1;
+            options.comp_type = 'sequential';
+            options.mode = 'silent';
+            
+            multiStartParams = getMultiStarts(testCase.parameters, testCase.objectiveFunction, options);
+            
+            alpha = [0.9, 0.95, 0.99];
+            multiStartParams = getParameterConfidenceIntervals(multiStartParams, alpha, options);
+        end
+    end
+    
+    methods
+        function verifyMultiStartResults(testCase, multiStartParams, optionsMultistart)
+            numStarts = optionsMultistart.n_starts;
+            numParams = testCase.parameters.number;
+            
+            testCase.assertEqual(multiStartParams.MS.n_starts, optionsMultistart.n_starts, 'Incorrect number of starts');
+            
+            testCase.verifySize(multiStartParams.MS.par0, [numParams, numStarts], 'Error in par0 dimensions.');
+            testCase.verifySize(multiStartParams.MS.par, [numParams, numStarts], 'Error in par dimensions.');
+            testCase.verifySize(multiStartParams.MS.logPost0, [numStarts, 1], 'Error in logPost0 dimensions.');
+            testCase.verifySize(multiStartParams.MS.logPost, [numStarts, 1], 'Error in logPost dimensions.');
+            testCase.verifySize(multiStartParams.MS.gradient, [numParams, numStarts], 'Error in gradient dimensions.');
+            testCase.verifySize(multiStartParams.MS.n_objfun, [numStarts, 1], 'Error in n_objfun dimensions.');
+            testCase.verifySize(multiStartParams.MS.n_iter, [numStarts, 1], 'Error in n_iter dimensions.');
+            testCase.verifySize(multiStartParams.MS.t_cpu, [numStarts, 1], 'Error in t_cpu dimensions.');
+            testCase.verifySize(multiStartParams.MS.exitflag, [numStarts, 1], 'Error in exitflag dimensions.');
+            
+            if numStarts == 1
+                testCase.verifySize(multiStartParams.MS.hessian, [numParams, numParams], 'Error in hessian dimensions.');
+            else
+                testCase.verifySize(multiStartParams.MS.hessian, [numParams, numParams, numStarts], 'Error in hessian dimensions.');
+            end
+
+            testCase.assertEqual(multiStartParams.MS.logPost, ones(numStarts, 1) * testCase.llh_true, 'RelTol', 1e-2, 'Incorrect optimal log likelihood')
+            testCase.assertEqual(multiStartParams.MS.par, repmat(testCase.theta_true, 1, numStarts), 'RelTol', 1e-1, 'Incorrect optimal parameters.')
+            
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/PESTO-1.1.0/tests/RosenbrockTest.m b/Requirements/PESTO-1.1.0/tests/RosenbrockTest.m
new file mode 100644
index 0000000000000000000000000000000000000000..6e5d587efb226093b7b28034436651c590727395
--- /dev/null
+++ b/Requirements/PESTO-1.1.0/tests/RosenbrockTest.m
@@ -0,0 +1,70 @@
+function RosenbrockTest()
+    % This is a test with a Rosenbrock function for Pesto
+
+    % Cleaning up
+    clear all;
+    close all;
+    clc;
+    
+    % Define objective function and true parameter value
+    objectiveFunction = @(x) rosenbrock(x, 1, 100);
+    theta_true = [1; 1];
+
+    % General Options
+    options = PestoOptions();
+    options.obj_type = 'negative log-posterior';
+    options.comp_type = 'sequential';
+    
+    % OPtimization options
+    options.localOptimizer = 'fmincon';
+    options.n_starts = 10;
+    
+    % Profile options
+    options.profile_method = 'integration';
+%     options.profile_optim_index = 1;
+%     options.profile_integ_index = 2;
+    options.solver.hessian = 'user-supplied';
+    options.solver.gamma = 100;
+    options.solver.type = 'ode113';
+    options.solver.RelTol = 1e-8;
+    options.solver.AbsTol = 1e-10;
+    
+    % Sampling Options
+    optionsSampling = PestoSamplingOptions();
+    optionsSampling.nIterations = 1e5;
+    optionsSampling.obj_type = 'negative log-posterior';
+    optionsSampling.samplingAlgorithm   = 'PT';
+    optionsSampling.PT.regFactor        = 1e-8;
+    optionsSampling.PT.nTemps        = 1;
+    optionsSampling.PT.temperatureAdaptionScheme = 'Lacki15';
+
+
+    % Plotting Options
+    options.mode = 'visual';
+    options.plot_options.add_points.par = theta_true;
+    options.plot_options.add_points.logPost = objectiveFunction(theta_true);
+
+    % Parameter setting
+    parameters.min = [-10, -10];
+    parameters.max = [10, 10];
+    parameters.number = 2;
+    parameters.name = {'x', 'y'};
+
+    % Call the routies
+    parameters = getMultiStarts(parameters, objectiveFunction, options);
+    parameters = getParameterProfiles(parameters, objectiveFunction, options);
+    optionsSampling.theta0 = parameters.MS.par(:, 1);
+    for j = 1 : optionsSampling.PT.nTemps
+        optionsSampling.sigma0(:,:,j) = inv(squeeze(parameters.MS.hessian(:, :, 1))); %drawFromMSinteger(j))));
+    end
+    parameters = getParameterSamples(parameters, objectiveFunction, optionsSampling);
+    getParameterConfidenceIntervals(parameters, [0.8, 0.9,0.95,0.99]);
+end
+
+function [y, dy, ddy] = rosenbrock(x, a, b)
+    y = (a - x(1))^2 + b * (x(2) - x(1)^2)^2;
+    dy = [2 * (x(1) - a) - 4 * b * x(1) * (x(2) - x(1)^2); ...
+        2 * b * (x(2) - x(1)^2)];
+    ddy = [2*x(1) - 4*b*x(2) + 12*b*x(1)^2, -4*b*x(1); ...
+        -4*b*x(1), 2*b];
+end
\ No newline at end of file
diff --git a/Requirements/Statistical_tests/Benjamini_Hochberg.m b/Requirements/Statistical_tests/Benjamini_Hochberg.m
new file mode 100644
index 0000000000000000000000000000000000000000..be4588ba74d7e508baee35977418fe515277a3e4
--- /dev/null
+++ b/Requirements/Statistical_tests/Benjamini_Hochberg.m
@@ -0,0 +1,56 @@
+function [reject,resulttable] = Benjamini_Hochberg(pvalues,testnames,falseDiscoveryRate)
+% Function written by Kajsa Tunedal 2022.
+%Performs benjamini hochberg correction.
+%Also implemented in the fdr_BH in multiple testing toolbox on matlab file
+%share - which seems to give the same result.
+indnan = isnan(pvalues);
+if sum(indnan) == length(pvalues)
+    resulttable = NaN;
+    reject = nan(size(pvalues));
+elseif sum(~indnan) == 1
+    %only one comparison valid - no correction needed
+    resulttable = table;
+    [resulttable.pvalueSorted,resulttable.sortindex] = sort(pvalues);
+    resulttable.comparison = testnames(resulttable.sortindex)';
+    resulttable.rank = [1,nan(1,length(pvalues)-1)]';
+    resulttable.criticalValue = [falseDiscoveryRate,nan(1,length(pvalues)-1)]';
+    resulttable.reject = nan(size(pvalues));
+    resulttable.reject(~indnan) = pvalues(~indnan) <= falseDiscoveryRate;
+    reject = pvalues;
+    reject(~isnan(reject)) = pvalues(~indnan) <= falseDiscoveryRate;
+else
+    resulttable = table;
+    % Sort p-values and rank them from smallest to largest
+    [resulttable.pvalueSorted,resulttable.sortindex] = sort(pvalues);
+    resulttable.comparison = testnames(resulttable.sortindex)';
+    resulttable.rank = [1:length(pvalues)]';
+    
+    % Create index to go back to the original order of comparisons
+    [~,resulttable.indexback] = ismember(pvalues,resulttable.pvalueSorted);
+    
+    % Critical value: (k/m)*Q, where Q is the given false discovery rate (number of expected false
+    % discoveries / total number of discoveries)
+    resulttable.criticalValue = falseDiscoveryRate.*(resulttable.rank./length(testnames(~indnan)));
+    
+    % Find the largest pvalue that is smaller than the critical value
+    breakpoint = resulttable.pvalueSorted < resulttable.criticalValue;
+    breakpoint = find(breakpoint,1,'last');
+    % All values with rank above and equal to the breakpoint are considered
+    % significant (even if their p-value would be larger than the critical value)
+    resulttable.reject = zeros(size(pvalues));
+    resulttable.reject(1:breakpoint) = 1;
+    reject = resulttable.reject;
+    
+    if sum(indnan)>0
+        indnansorted = isnan(resulttable.pvalueSorted);
+        resulttable.rank(indnansorted) = NaN;
+        resulttable.criticalValue(indnansorted) = NaN;
+        resulttable.reject(indnansorted) = NaN;
+        reject(indnan) = NaN;
+        reject(~indnan)= resulttable.reject(resulttable.indexback(resulttable.indexback~=0));
+    else
+            reject = reject(resulttable.indexback);
+    end
+    
+end
+end
\ No newline at end of file
diff --git a/Requirements/Statistical_tests/license_swtest.txt b/Requirements/Statistical_tests/license_swtest.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5653791318d2c079208fecffa9396727443e49ae
--- /dev/null
+++ b/Requirements/Statistical_tests/license_swtest.txt
@@ -0,0 +1,24 @@
+Copyright (c) 2009, Ahmed Ben Saïda
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/Statistical_tests/swtest.m b/Requirements/Statistical_tests/swtest.m
new file mode 100644
index 0000000000000000000000000000000000000000..8a23cf8767c7008dd848b4db857dac5acf17455b
--- /dev/null
+++ b/Requirements/Statistical_tests/swtest.m
@@ -0,0 +1,266 @@
+function [H, pValue, W] = swtest(x, alpha)
+%SWTEST Shapiro-Wilk parametric hypothesis test of composite normality.
+%   [H, pValue, SWstatistic] = SWTEST(X, ALPHA) performs the
+%   Shapiro-Wilk test to determine if the null hypothesis of
+%   composite normality is a reasonable assumption regarding the
+%   population distribution of a random sample X. The desired significance 
+%   level, ALPHA, is an optional scalar input (default = 0.05).
+%
+%   The Shapiro-Wilk and Shapiro-Francia null hypothesis is: 
+%   "X is normal with unspecified mean and variance."
+%
+%   This is an omnibus test, and is generally considered relatively
+%   powerful against a variety of alternatives.
+%   Shapiro-Wilk test is better than the Shapiro-Francia test for
+%   Platykurtic sample. Conversely, Shapiro-Francia test is better than the
+%   Shapiro-Wilk test for Leptokurtic samples.
+%
+%   When the series 'X' is Leptokurtic, SWTEST performs the Shapiro-Francia
+%   test, else (series 'X' is Platykurtic) SWTEST performs the
+%   Shapiro-Wilk test.
+% 
+%    [H, pValue, SWstatistic] = SWTEST(X, ALPHA)
+%
+% Inputs:
+%   X - a vector of deviates from an unknown distribution. The observation
+%     number must exceed 3 and less than 5000.
+%
+% Optional inputs:
+%   ALPHA - The significance level for the test (default = 0.05).
+%  
+% Outputs:
+%  SWstatistic - The test statistic (non normalized).
+%
+%   pValue - is the p-value, or the probability of observing the given
+%     result by chance given that the null hypothesis is true. Small values
+%     of pValue cast doubt on the validity of the null hypothesis.
+%
+%     H = 0 => Do not reject the null hypothesis at significance level ALPHA.
+%     H = 1 => Reject the null hypothesis at significance level ALPHA.
+%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                Copyright (c) 17 March 2009 by Ahmed Ben Sa�da          %
+%                 Department of Finance, IHEC Sousse - Tunisia           %
+%                       Email: ahmedbensaida@yahoo.com                   %
+%                    $ Revision 3.0 $ Date: 18 Juin 2014 $               %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%
+% References:
+%
+% - Royston P. "Remark AS R94", Applied Statistics (1995), Vol. 44,
+%   No. 4, pp. 547-551.
+%   AS R94 -- calculates Shapiro-Wilk normality test and P-value
+%   for sample sizes 3 <= n <= 5000. Handles censored or uncensored data.
+%   Corrects AS 181, which was found to be inaccurate for n > 50.
+%   Subroutine can be found at: http://lib.stat.cmu.edu/apstat/R94
+%
+% - Royston P. "A pocket-calculator algorithm for the Shapiro-Francia test
+%   for non-normality: An application to medicine", Statistics in Medecine
+%   (1993a), Vol. 12, pp. 181-184.
+%
+% - Royston P. "A Toolkit for Testing Non-Normality in Complete and
+%   Censored Samples", Journal of the Royal Statistical Society Series D
+%   (1993b), Vol. 42, No. 1, pp. 37-43.
+%
+% - Royston P. "Approximating the Shapiro-Wilk W-test for non-normality",
+%   Statistics and Computing (1992), Vol. 2, pp. 117-119.
+%
+% - Royston P. "An Extension of Shapiro and Wilk's W Test for Normality
+%   to Large Samples", Journal of the Royal Statistical Society Series C
+%   (1982a), Vol. 31, No. 2, pp. 115-124.
+%
+
+%
+% Ensure the sample data is a VECTOR.
+%
+
+if numel(x) == length(x)
+    x  =  x(:);               % Ensure a column vector.
+else
+    error(' Input sample ''X'' must be a vector.');
+end
+
+%
+% Remove missing observations indicated by NaN's and check sample size.
+%
+
+x  =  x(~isnan(x));
+
+if length(x) < 3
+   error(' Sample vector ''X'' must have at least 3 valid observations.');
+end
+
+if length(x) > 5000
+    warning('Shapiro-Wilk test might be inaccurate due to large sample size ( > 5000).');
+end
+
+%
+% Ensure the significance level, ALPHA, is a 
+% scalar, and set default if necessary.
+%
+
+if (nargin >= 2) && ~isempty(alpha)
+   if ~isscalar(alpha)
+      error(' Significance level ''Alpha'' must be a scalar.');
+   end
+   if (alpha <= 0 || alpha >= 1)
+      error(' Significance level ''Alpha'' must be between 0 and 1.'); 
+   end
+else
+   alpha  =  0.05;
+end
+
+% First, calculate the a's for weights as a function of the m's
+% See Royston (1992, p. 117) and Royston (1993b, p. 38) for details
+% in the approximation.
+
+x       =   sort(x); % Sort the vector X in ascending order.
+n       =   length(x);
+mtilde  =   norminv(((1:n)' - 3/8) / (n + 1/4));
+weights =   zeros(n,1); % Preallocate the weights.
+
+if kurtosis(x) > 3
+    
+    % The Shapiro-Francia test is better for leptokurtic samples.
+    
+    weights =   1/sqrt(mtilde'*mtilde) * mtilde;
+
+    %
+    % The Shapiro-Francia statistic W' is calculated to avoid excessive
+    % rounding errors for W' close to 1 (a potential problem in very
+    % large samples).
+    %
+
+    W   =   (weights' * x)^2 / ((x - mean(x))' * (x - mean(x)));
+
+    % Royston (1993a, p. 183):
+    nu      =   log(n);
+    u1      =   log(nu) - nu;
+    u2      =   log(nu) + 2/nu;
+    mu      =   -1.2725 + (1.0521 * u1);
+    sigma   =   1.0308 - (0.26758 * u2);
+
+    newSFstatistic  =   log(1 - W);
+
+    %
+    % Compute the normalized Shapiro-Francia statistic and its p-value.
+    %
+
+    NormalSFstatistic =   (newSFstatistic - mu) / sigma;
+    
+    % Computes the p-value, Royston (1993a, p. 183).
+    pValue   =   1 - normcdf(NormalSFstatistic, 0, 1);
+    
+else
+    
+    % The Shapiro-Wilk test is better for platykurtic samples.
+
+    c    =   1/sqrt(mtilde'*mtilde) * mtilde;
+    u    =   1/sqrt(n);
+
+    % Royston (1992, p. 117) and Royston (1993b, p. 38):
+    PolyCoef_1   =   [-2.706056 , 4.434685 , -2.071190 , -0.147981 , 0.221157 , c(n)];
+    PolyCoef_2   =   [-3.582633 , 5.682633 , -1.752461 , -0.293762 , 0.042981 , c(n-1)];
+
+    % Royston (1992, p. 118) and Royston (1993b, p. 40, Table 1)
+    PolyCoef_3   =   [-0.0006714 , 0.0250540 , -0.39978 , 0.54400];
+    PolyCoef_4   =   [-0.0020322 , 0.0627670 , -0.77857 , 1.38220];
+    PolyCoef_5   =   [0.00389150 , -0.083751 , -0.31082 , -1.5861];
+    PolyCoef_6   =   [0.00303020 , -0.082676 , -0.48030];
+
+    PolyCoef_7   =   [0.459 , -2.273];
+
+    weights(n)   =   polyval(PolyCoef_1 , u);
+    weights(1)   =   -weights(n);
+    
+    if n > 5
+        weights(n-1) =   polyval(PolyCoef_2 , u);
+        weights(2)   =   -weights(n-1);
+    
+        count  =   3;
+        phi    =   (mtilde'*mtilde - 2 * mtilde(n)^2 - 2 * mtilde(n-1)^2) / ...
+                (1 - 2 * weights(n)^2 - 2 * weights(n-1)^2);
+    else
+        count  =   2;
+        phi    =   (mtilde'*mtilde - 2 * mtilde(n)^2) / ...
+                (1 - 2 * weights(n)^2);
+    end
+        
+    % Special attention when n = 3 (this is a special case).
+    if n == 3
+        % Royston (1992, p. 117)
+        weights(1)  =   1/sqrt(2);
+        weights(n)  =   -weights(1);
+        phi = 1;
+    end
+
+    %
+    % The vector 'WEIGHTS' obtained next corresponds to the same coefficients
+    % listed by Shapiro-Wilk in their original test for small samples.
+    %
+
+    weights(count : n-count+1)  =  mtilde(count : n-count+1) / sqrt(phi);
+
+    %
+    % The Shapiro-Wilk statistic W is calculated to avoid excessive rounding
+    % errors for W close to 1 (a potential problem in very large samples).
+    %
+
+    W   =   (weights' * x) ^2 / ((x - mean(x))' * (x - mean(x)));
+
+    %
+    % Calculate the normalized W and its significance level (exact for
+    % n = 3). Royston (1992, p. 118) and Royston (1993b, p. 40, Table 1).
+    %
+
+    newn    =   log(n);
+
+    if (n >= 4) && (n <= 11)
+    
+        mu      =   polyval(PolyCoef_3 , n);
+        sigma   =   exp(polyval(PolyCoef_4 , n));    
+        gam     =   polyval(PolyCoef_7 , n);
+    
+        newSWstatistic  =   -log(gam-log(1-W));
+    
+    elseif n > 11
+    
+        mu      =   polyval(PolyCoef_5 , newn);
+        sigma   =   exp(polyval(PolyCoef_6 , newn));
+    
+        newSWstatistic  =   log(1 - W);
+    
+    elseif n == 3
+        mu      =   0;
+        sigma   =   1;
+        newSWstatistic  =   0;
+    end
+
+    %
+    % Compute the normalized Shapiro-Wilk statistic and its p-value.
+    %
+
+    NormalSWstatistic   =   (newSWstatistic - mu) / sigma;
+    
+    % NormalSWstatistic is referred to the upper tail of N(0,1),
+    % Royston (1992, p. 119).
+    pValue       =   1 - normcdf(NormalSWstatistic, 0, 1);
+    
+    % Special attention when n = 3 (this is a special case).
+    if n == 3
+        pValue  =   6/pi * (asin(sqrt(W)) - asin(sqrt(3/4)));
+        % Royston (1982a, p. 121)
+    end
+    
+end
+
+%
+% To maintain consistency with existing Statistics Toolbox hypothesis
+% tests, returning 'H = 0' implies that we 'Do not reject the null 
+% hypothesis at the significance level of alpha' and 'H = 1' implies 
+% that we 'Reject the null hypothesis at significance level of alpha.'
+%
+
+H  = (alpha >= pValue);
\ No newline at end of file
diff --git a/Requirements/matplotlib/cividis.m b/Requirements/matplotlib/cividis.m
new file mode 100644
index 0000000000000000000000000000000000000000..38cbd6129ac0615d878db066ece270f3da8509f0
--- /dev/null
+++ b/Requirements/matplotlib/cividis.m
@@ -0,0 +1,83 @@
+function [map,num] = cividis(N)
+% Perceptually uniform sequential colormap from MatPlotLib. Designed for colorblind.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = cividis
+%  map = cividis(N)
+%
+% Colormap designed by Jamie R. Nuñez, Christopher R. Anderton, Ryan S. Renslow.
+%
+% Developed with consideration for color vision deficiency to enable accurate
+% interpretation of scientific data. Full paper available here:
+% <https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0199239>
+% The RGB data is from here: <https://doi.org/10.1371/journal.pone.0199239.s002>
+%
+% Note VIRIDIS replaced the awful JET as the MatPlotLib default colormap.
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(cividis(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(cividis)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(cividis)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also INFERNO MAGMA PLASMA TWILIGHT TWILIGHT_SHIFTED VIRIDIS
+% TAB10 TAB20 TAB20B TAB20C 
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:cividis:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.0000,0.1262,0.3015;0.0000,0.1292,0.3077;0.0000,0.1321,0.3142;0.0000,0.1350,0.3205;0.0000,0.1379,0.3269;0.0000,0.1408,0.3334;0.0000,0.1437,0.3400;0.0000,0.1465,0.3467;0.0000,0.1492,0.3537;0.0000,0.1519,0.3606;0.0000,0.1546,0.3676;0.0000,0.1574,0.3746;0.0000,0.1601,0.3817;0.0000,0.1629,0.3888;0.0000,0.1657,0.3960;0.0000,0.1685,0.4031;0.0000,0.1714,0.4102;0.0000,0.1743,0.4172;0.0000,0.1773,0.4241;0.0000,0.1798,0.4307;0.0000,0.1817,0.4347;0.0000,0.1834,0.4363;0.0000,0.1852,0.4368;0.0000,0.1872,0.4368;0.0000,0.1901,0.4365;0.0000,0.1930,0.4361;0.0000,0.1958,0.4356;0.0000,0.1987,0.4349;0.0000,0.2015,0.4343;0.0000,0.2044,0.4336;0.0000,0.2073,0.4329;0.0055,0.2101,0.4322;0.0236,0.2130,0.4314;0.0416,0.2158,0.4308;0.0576,0.2187,0.4301;0.0710,0.2215,0.4293;0.0827,0.2244,0.4287;0.0932,0.2272,0.4280;0.1030,0.2300,0.4274;0.1120,0.2329,0.4268;0.1204,0.2357,0.4262;0.1283,0.2385,0.4256;0.1359,0.2414,0.4251;0.1431,0.2442,0.4245;0.1500,0.2470,0.4241;0.1566,0.2498,0.4236;0.1630,0.2526,0.4232;0.1692,0.2555,0.4228;0.1752,0.2583,0.4224;0.1811,0.2611,0.4220;0.1868,0.2639,0.4217;0.1923,0.2667,0.4214;0.1977,0.2695,0.4212;0.2030,0.2723,0.4209;0.2082,0.2751,0.4207;0.2133,0.2780,0.4205;0.2183,0.2808,0.4204;0.2232,0.2836,0.4203;0.2281,0.2864,0.4202;0.2328,0.2892,0.4201;0.2375,0.2920,0.4200;0.2421,0.2948,0.4200;0.2466,0.2976,0.4200;0.2511,0.3004,0.4201;0.2556,0.3032,0.4201;0.2599,0.3060,0.4202;0.2643,0.3088,0.4203;0.2686,0.3116,0.4205;0.2728,0.3144,0.4206;0.2770,0.3172,0.4208;0.2811,0.3200,0.4210;0.2853,0.3228,0.4212;0.2894,0.3256,0.4215;0.2934,0.3284,0.4218;0.2974,0.3312,0.4221;0.3014,0.3340,0.4224;0.3054,0.3368,0.4227;0.3093,0.3396,0.4231;0.3132,0.3424,0.4236;0.3170,0.3453,0.4240;0.3209,0.3481,0.4244;0.3247,0.3509,0.4249;0.3285,0.3537,0.4254;0.3323,0.3565,0.4259;0.3361,0.3593,0.4264;0.3398,0.3622,0.4270;0.3435,0.3650,0.4276;0.3472,0.3678,0.4282;0.3509,0.3706,0.4288;0.3546,0.3734,0.4294;0.3582,0.3763,0.4302;0.3619,0.3791,0.4308;0.3655,0.3819,0.4316;0.3691,0.3848,0.4322;0.3727,0.3876,0.4331;0.3763,0.3904,0.4338;0.3798,0.3933,0.4346;0.3834,0.3961,0.4355;0.3869,0.3990,0.4364;0.3905,0.4018,0.4372;0.3940,0.4047,0.4381;0.3975,0.4075,0.4390;0.4010,0.4104,0.4400;0.4045,0.4132,0.4409;0.4080,0.4161,0.4419;0.4114,0.4189,0.4430;0.4149,0.4218,0.4440;0.4183,0.4247,0.4450;0.4218,0.4275,0.4462;0.4252,0.4304,0.4473;0.4286,0.4333,0.4485;0.4320,0.4362,0.4496;0.4354,0.4390,0.4508;0.4388,0.4419,0.4521;0.4422,0.4448,0.4534;0.4456,0.4477,0.4547;0.4489,0.4506,0.4561;0.4523,0.4535,0.4575;0.4556,0.4564,0.4589;0.4589,0.4593,0.4604;0.4622,0.4622,0.4620;0.4656,0.4651,0.4635;0.4689,0.4680,0.4650;0.4722,0.4709,0.4665;0.4756,0.4738,0.4679;0.4790,0.4767,0.4691;0.4825,0.4797,0.4701;0.4861,0.4826,0.4707;0.4897,0.4856,0.4714;0.4934,0.4886,0.4719;0.4971,0.4915,0.4723;0.5008,0.4945,0.4727;0.5045,0.4975,0.4730;0.5083,0.5005,0.4732;0.5121,0.5035,0.4734;0.5158,0.5065,0.4736;0.5196,0.5095,0.4737;0.5234,0.5125,0.4738;0.5272,0.5155,0.4739;0.5310,0.5186,0.4739;0.5349,0.5216,0.4738;0.5387,0.5246,0.4739;0.5425,0.5277,0.4738;0.5464,0.5307,0.4736;0.5502,0.5338,0.4735;0.5541,0.5368,0.4733;0.5579,0.5399,0.4732;0.5618,0.5430,0.4729;0.5657,0.5461,0.4727;0.5696,0.5491,0.4723;0.5735,0.5522,0.4720;0.5774,0.5553,0.4717;0.5813,0.5584,0.4714;0.5852,0.5615,0.4709;0.5892,0.5646,0.4705;0.5931,0.5678,0.4701;0.5970,0.5709,0.4696;0.6010,0.5740,0.4691;0.6050,0.5772,0.4685;0.6089,0.5803,0.4680;0.6129,0.5835,0.4673;0.6168,0.5866,0.4668;0.6208,0.5898,0.4662;0.6248,0.5929,0.4655;0.6288,0.5961,0.4649;0.6328,0.5993,0.4641;0.6368,0.6025,0.4632;0.6408,0.6057,0.4625;0.6449,0.6089,0.4617;0.6489,0.6121,0.4609;0.6529,0.6153,0.4600;0.6570,0.6185,0.4591;0.6610,0.6217,0.4583;0.6651,0.6250,0.4573;0.6691,0.6282,0.4562;0.6732,0.6315,0.4553;0.6773,0.6347,0.4543;0.6813,0.6380,0.4532;0.6854,0.6412,0.4521;0.6895,0.6445,0.4511;0.6936,0.6478,0.4499;0.6977,0.6511,0.4487;0.7018,0.6544,0.4475;0.7060,0.6577,0.4463;0.7101,0.6610,0.4450;0.7142,0.6643,0.4437;0.7184,0.6676,0.4424;0.7225,0.6710,0.4409;0.7267,0.6743,0.4396;0.7308,0.6776,0.4382;0.7350,0.6810,0.4368;0.7392,0.6844,0.4352;0.7434,0.6877,0.4338;0.7476,0.6911,0.4322;0.7518,0.6945,0.4307;0.7560,0.6979,0.4290;0.7602,0.7013,0.4273;0.7644,0.7047,0.4258;0.7686,0.7081,0.4241;0.7729,0.7115,0.4223;0.7771,0.7150,0.4205;0.7814,0.7184,0.4188;0.7856,0.7218,0.4168;0.7899,0.7253,0.4150;0.7942,0.7288,0.4129;0.7985,0.7322,0.4111;0.8027,0.7357,0.4090;0.8070,0.7392,0.4070;0.8114,0.7427,0.4049;0.8157,0.7462,0.4028;0.8200,0.7497,0.4007;0.8243,0.7532,0.3984;0.8287,0.7568,0.3961;0.8330,0.7603,0.3938;0.8374,0.7639,0.3915;0.8417,0.7674,0.3892;0.8461,0.7710,0.3869;0.8505,0.7745,0.3843;0.8548,0.7781,0.3818;0.8592,0.7817,0.3793;0.8636,0.7853,0.3766;0.8681,0.7889,0.3739;0.8725,0.7926,0.3712;0.8769,0.7962,0.3684;0.8813,0.7998,0.3657;0.8858,0.8035,0.3627;0.8902,0.8071,0.3599;0.8947,0.8108,0.3569;0.8992,0.8145,0.3538;0.9037,0.8182,0.3507;0.9082,0.8219,0.3474;0.9127,0.8256,0.3442;0.9172,0.8293,0.3409;0.9217,0.8330,0.3374;0.9262,0.8367,0.3340;0.9308,0.8405,0.3306;0.9353,0.8442,0.3268;0.9399,0.8480,0.3232;0.9444,0.8518,0.3195;0.9490,0.8556,0.3155;0.9536,0.8593,0.3116;0.9582,0.8632,0.3076;0.9628,0.8670,0.3034;0.9674,0.8708,0.2990;0.9721,0.8746,0.2947;0.9767,0.8785,0.2901;0.9814,0.8823,0.2856;0.9860,0.8862,0.2807;0.9907,0.8901,0.2759;0.9954,0.8940,0.2708;1.0000,0.8979,0.2655;1.0000,0.9018,0.2600;1.0000,0.9057,0.2593;1.0000,0.9094,0.2634;1.0000,0.9131,0.2680;1.0000,0.9169,0.2731];
+num = size(raw,1);
+%
+% With small extrapolation when N>num:
+vec = linspace(0,num+1,N+2);
+map = interp1(1:num,raw,vec(2:N+1),'linear','extrap');
+% Interpolation only for all values of N:
+%map = interp1(1:num,raw,linspace(1,num,N),'spline')
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cividis
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/html/matplotlib_doc.html b/Requirements/matplotlib/html/matplotlib_doc.html
new file mode 100644
index 0000000000000000000000000000000000000000..ecfef58af69eb2a3ea8044b789f10c06b483a47a
--- /dev/null
+++ b/Requirements/matplotlib/html/matplotlib_doc.html
@@ -0,0 +1,180 @@
+
+<!DOCTYPE html
+  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+   <!--
+This HTML was auto-generated from MATLAB code.
+To make changes, update the MATLAB code and republish this document.
+      --><title>Perceptually Uniform Colormaps from MatPlotLib</title><meta name="generator" content="MATLAB 9.4"><link rel="schema.DC" href="http://purl.org/dc/elements/1.1/"><meta name="DC.date" content="2022-03-05"><meta name="DC.source" content="matplotlib_doc.m"><style type="text/css">
+html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td{margin:0;padding:0;border:0;outline:0;font-size:100%;vertical-align:baseline;background:transparent}body{line-height:1}ol,ul{list-style:none}blockquote,q{quotes:none}blockquote:before,blockquote:after,q:before,q:after{content:'';content:none}:focus{outine:0}ins{text-decoration:none}del{text-decoration:line-through}table{border-collapse:collapse;border-spacing:0}
+
+html { min-height:100%; margin-bottom:1px; }
+html body { height:100%; margin:0px; font-family:Arial, Helvetica, sans-serif; font-size:10px; color:#000; line-height:140%; background:#fff none; overflow-y:scroll; }
+html body td { vertical-align:top; text-align:left; }
+
+h1 { padding:0px; margin:0px 0px 25px; font-family:Arial, Helvetica, sans-serif; font-size:1.5em; color:#d55000; line-height:100%; font-weight:normal; }
+h2 { padding:0px; margin:0px 0px 8px; font-family:Arial, Helvetica, sans-serif; font-size:1.2em; color:#000; font-weight:bold; line-height:140%; border-bottom:1px solid #d6d4d4; display:block; }
+h3 { padding:0px; margin:0px 0px 5px; font-family:Arial, Helvetica, sans-serif; font-size:1.1em; color:#000; font-weight:bold; line-height:140%; }
+
+a { color:#005fce; text-decoration:none; }
+a:hover { color:#005fce; text-decoration:underline; }
+a:visited { color:#004aa0; text-decoration:none; }
+
+p { padding:0px; margin:0px 0px 20px; }
+img { padding:0px; margin:0px 0px 20px; border:none; }
+p img, pre img, tt img, li img, h1 img, h2 img { margin-bottom:0px; } 
+
+ul { padding:0px; margin:0px 0px 20px 23px; list-style:square; }
+ul li { padding:0px; margin:0px 0px 7px 0px; }
+ul li ul { padding:5px 0px 0px; margin:0px 0px 7px 23px; }
+ul li ol li { list-style:decimal; }
+ol { padding:0px; margin:0px 0px 20px 0px; list-style:decimal; }
+ol li { padding:0px; margin:0px 0px 7px 23px; list-style-type:decimal; }
+ol li ol { padding:5px 0px 0px; margin:0px 0px 7px 0px; }
+ol li ol li { list-style-type:lower-alpha; }
+ol li ul { padding-top:7px; }
+ol li ul li { list-style:square; }
+
+.content { font-size:1.2em; line-height:140%; padding: 20px; }
+
+pre, code { font-size:12px; }
+tt { font-size: 1.2em; }
+pre { margin:0px 0px 20px; }
+pre.codeinput { padding:10px; border:1px solid #d3d3d3; background:#f7f7f7; }
+pre.codeoutput { padding:10px 11px; margin:0px 0px 20px; color:#4c4c4c; }
+pre.error { color:red; }
+
+@media print { pre.codeinput, pre.codeoutput { word-wrap:break-word; width:100%; } }
+
+span.keyword { color:#0000FF }
+span.comment { color:#228B22 }
+span.string { color:#A020F0 }
+span.untermstring { color:#B20000 }
+span.syscmd { color:#B28C00 }
+
+.footer { width:auto; padding:10px 0px; margin:25px 0px 0px; border-top:1px dotted #878787; font-size:0.8em; line-height:140%; font-style:italic; color:#878787; text-align:left; float:none; }
+.footer p { margin:0px; }
+.footer a { color:#878787; }
+.footer a:hover { color:#878787; text-decoration:underline; }
+.footer a:visited { color:#878787; }
+
+table th { padding:7px 5px; text-align:left; vertical-align:middle; border: 1px solid #d6d4d4; font-weight:bold; }
+table td { padding:7px 5px; text-align:left; vertical-align:top; border:1px solid #d6d4d4; }
+
+
+
+
+
+  </style></head><body><div class="content"><h1>Perceptually Uniform Colormaps from MatPlotLib</h1><!--introduction--><p>The <a href="www.mathworks.com/matlabcentral/fileexchange/62729">MatPlotLib Perceptually Uniform Colormaps</a> submission includes the default colormap family and default line colororder family from MatPlotLib 2 and 3. This document shows examples of their usage.</p><!--/introduction--><h2>Contents</h2><div><ul><li><a href="#1">Overview</a></li><li><a href="#2"><tt>VIRIDIS</tt></a></li><li><a href="#3"><tt>CIVIDIS</tt></a></li><li><a href="#4"><tt>INFERNO</tt></a></li><li><a href="#5"><tt>MAGMA</tt></a></li><li><a href="#6"><tt>PLASMA</tt></a></li><li><a href="#7"><tt>TWILIGHT</tt></a></li><li><a href="#8"><tt>TWILIGHT_SHIFTED</tt></a></li><li><a href="#9"><tt>TAB10</tt></a></li><li><a href="#10"><tt>TAB20</tt></a></li><li><a href="#11"><tt>TAB20B</tt></a></li><li><a href="#12"><tt>TAB20C</tt></a></li></ul></div><h2 id="1">Overview</h2><pre class="codeinput">matplotlib_plot()
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_01.png" alt=""> <h2 id="2"><tt>VIRIDIS</tt></h2><div><ul><li>Sequential</li><li>Perceptually uniform</li><li>Default colormap for MatPlotLib 2 and 3</li></ul></div><pre class="codeinput">close()
+load <span class="string">spine</span>
+image(X)
+colormap(viridis)
+colorbar()
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_02.png" alt=""> <h2 id="3"><tt>CIVIDIS</tt></h2><div><ul><li>Sequential</li><li>Perceptually uniform</li><li>Optimized for color-vision deficiency</li></ul></div><pre class="codeinput">colormap(cividis)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_03.png" alt=""> <h2 id="4"><tt>INFERNO</tt></h2><div><ul><li>Sequential</li><li>Perceptually uniform</li></ul></div><pre class="codeinput">colormap(inferno)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_04.png" alt=""> <h2 id="5"><tt>MAGMA</tt></h2><div><ul><li>Sequential</li><li>Perceptually uniform</li></ul></div><pre class="codeinput">colormap(magma)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_05.png" alt=""> <h2 id="6"><tt>PLASMA</tt></h2><div><ul><li>Sequential</li><li>Perceptually uniform</li></ul></div><pre class="codeinput">colormap(plasma)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_06.png" alt=""> <h2 id="7"><tt>TWILIGHT</tt></h2><div><ul><li>Cyclical</li><li>Perceptually uniform</li></ul></div><pre class="codeinput">colormap(twilight)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_07.png" alt=""> <h2 id="8"><tt>TWILIGHT_SHIFTED</tt></h2><div><ul><li>Cyclical</li><li>Perceptually uniform</li></ul></div><pre class="codeinput">colormap(twilight_shifted)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_08.png" alt=""> <h2 id="9"><tt>TAB10</tt></h2><div><ul><li>Qualitative</li><li>Default line ColorOrder for MatPlotLib 2 and 3</li><li>Named VEGA10 in MatPlotLib 2</li></ul></div><pre class="codeinput">N = 10;
+X = linspace(0,pi*3,1000);
+Y = bsxfun(@(x,n)n*sin(x+2*n*pi/N), X(:), 1:N);
+clf()
+axes(<span class="string">'ColorOrder'</span>,tab10(N),<span class="string">'NextPlot'</span>,<span class="string">'replacechildren'</span>)
+plot(X,Y, <span class="string">'linewidth'</span>,4)
+legend(<span class="string">'location'</span>,<span class="string">'eastoutside'</span>)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_09.png" alt=""> <h2 id="10"><tt>TAB20</tt></h2><div><ul><li>Qualitative</li><li>Named VEGA20 in MatPlotLib 2</li></ul></div><pre class="codeinput">N = 20;
+Y = bsxfun(@(x,n)n*sin(x+2*n*pi/N), X(:), 1:N);
+clf()
+axes(<span class="string">'ColorOrder'</span>,tab20(N),<span class="string">'NextPlot'</span>,<span class="string">'replacechildren'</span>)
+plot(X,Y, <span class="string">'linewidth'</span>,4)
+legend(<span class="string">'location'</span>,<span class="string">'eastoutside'</span>)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_10.png" alt=""> <h2 id="11"><tt>TAB20B</tt></h2><div><ul><li>Qualitative</li><li>Named VEGA20B in MatPlotLib 2</li></ul></div><pre class="codeinput">clf()
+axes(<span class="string">'ColorOrder'</span>,tab20b(N),<span class="string">'NextPlot'</span>,<span class="string">'replacechildren'</span>)
+plot(X,Y, <span class="string">'linewidth'</span>,4)
+legend(<span class="string">'location'</span>,<span class="string">'eastoutside'</span>)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_11.png" alt=""> <h2 id="12"><tt>TAB20C</tt></h2><div><ul><li>Qualitative</li><li>Named VEGA20C in MatPlotLib 2</li></ul></div><pre class="codeinput">clf()
+axes(<span class="string">'ColorOrder'</span>,tab20c(N),<span class="string">'NextPlot'</span>,<span class="string">'replacechildren'</span>)
+plot(X,Y, <span class="string">'linewidth'</span>,4)
+legend(<span class="string">'location'</span>,<span class="string">'eastoutside'</span>)
+</pre><img vspace="5" hspace="5" src="matplotlib_doc_12.png" alt=""> <p class="footer"><br><a href="https://www.mathworks.com/products/matlab/">Published with MATLAB&reg; R2018a</a><br></p></div><!--
+##### SOURCE BEGIN #####
+%% Perceptually Uniform Colormaps from MatPlotLib
+% The <www.mathworks.com/matlabcentral/fileexchange/62729
+% MatPlotLib Perceptually Uniform Colormaps> submission includes the
+% default colormap family and default line colororder family from
+% MatPlotLib 2 and 3. This document shows examples of their usage.
+%% Overview
+matplotlib_plot()
+%% |VIRIDIS|
+% * Sequential
+% * Perceptually uniform
+% * Default colormap for MatPlotLib 2 and 3
+close()
+load spine
+image(X)
+colormap(viridis)
+colorbar()
+%% |CIVIDIS|
+% * Sequential
+% * Perceptually uniform
+% * Optimized for color-vision deficiency
+colormap(cividis)
+%% |INFERNO|
+% * Sequential
+% * Perceptually uniform
+colormap(inferno)
+%% |MAGMA|
+% * Sequential
+% * Perceptually uniform
+colormap(magma)
+%% |PLASMA|
+% * Sequential
+% * Perceptually uniform
+colormap(plasma)
+%% |TWILIGHT|
+% * Cyclical
+% * Perceptually uniform
+colormap(twilight)
+%% |TWILIGHT_SHIFTED|
+% * Cyclical
+% * Perceptually uniform
+colormap(twilight_shifted)
+%% |TAB10|
+% * Qualitative
+% * Default line ColorOrder for MatPlotLib 2 and 3
+% * Named VEGA10 in MatPlotLib 2
+N = 10;
+X = linspace(0,pi*3,1000);
+Y = bsxfun(@(x,n)n*sin(x+2*n*pi/N), X(:), 1:N);
+clf()
+axes('ColorOrder',tab10(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+%% |TAB20|
+% * Qualitative
+% * Named VEGA20 in MatPlotLib 2
+N = 20;
+Y = bsxfun(@(x,n)n*sin(x+2*n*pi/N), X(:), 1:N);
+clf()
+axes('ColorOrder',tab20(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+%% |TAB20B|
+% * Qualitative
+% * Named VEGA20B in MatPlotLib 2
+clf()
+axes('ColorOrder',tab20b(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+%% |TAB20C|
+% * Qualitative
+% * Named VEGA20C in MatPlotLib 2
+clf()
+axes('ColorOrder',tab20c(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+##### SOURCE END #####
+--></body></html>
\ No newline at end of file
diff --git a/Requirements/matplotlib/inferno.m b/Requirements/matplotlib/inferno.m
new file mode 100644
index 0000000000000000000000000000000000000000..49ff95ccd1015a0b38a1273fbea33605528f013a
--- /dev/null
+++ b/Requirements/matplotlib/inferno.m
@@ -0,0 +1,83 @@
+function [map,num] = inferno(N)
+% Perceptually uniform sequential colormap from MatPlotLib.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = inferno
+%  map = inferno(N)
+%
+% Colormap designed by Nathaniel J. Smith and Stefan van der Walt.
+%
+% For MatPlotLib 2.0 improved colormaps were created in the perceptually
+% uniform colorspace CAM02-UCS. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% The RGB data is from here: <https://bids.github.io/colormap/>
+%
+% Note VIRIDIS replaced the awful JET as the MatPlotLib default colormap.
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(inferno(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(inferno)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(inferno)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also CIVIDIS MAGMA PLASMA TWILIGHT TWILIGHT_SHIFTED VIRIDIS
+% TAB10 TAB20 TAB20B TAB20C
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:inferno:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.001462,0.000466,0.013866; 0.002267,0.001270,0.018570; 0.003299,0.002249,0.024239; 0.004547,0.003392,0.030909; 0.006006,0.004692,0.038558; 0.007676,0.006136,0.046836; 0.009561,0.007713,0.055143; 0.011663,0.009417,0.063460; 0.013995,0.011225,0.071862; 0.016561,0.013136,0.080282; 0.019373,0.015133,0.088767; 0.022447,0.017199,0.097327; 0.025793,0.019331,0.105930; 0.029432,0.021503,0.114621; 0.033385,0.023702,0.123397; 0.037668,0.025921,0.132232; 0.042253,0.028139,0.141141; 0.046915,0.030324,0.150164; 0.051644,0.032474,0.159254; 0.056449,0.034569,0.168414; 0.061340,0.036590,0.177642; 0.066331,0.038504,0.186962; 0.071429,0.040294,0.196354; 0.076637,0.041905,0.205799; 0.081962,0.043328,0.215289; 0.087411,0.044556,0.224813; 0.092990,0.045583,0.234358; 0.098702,0.046402,0.243904; 0.104551,0.047008,0.253430; 0.110536,0.047399,0.262912; 0.116656,0.047574,0.272321; 0.122908,0.047536,0.281624; 0.129285,0.047293,0.290788; 0.135778,0.046856,0.299776; 0.142378,0.046242,0.308553; 0.149073,0.045468,0.317085; 0.155850,0.044559,0.325338; 0.162689,0.043554,0.333277; 0.169575,0.042489,0.340874; 0.176493,0.041402,0.348111; 0.183429,0.040329,0.354971; 0.190367,0.039309,0.361447; 0.197297,0.038400,0.367535; 0.204209,0.037632,0.373238; 0.211095,0.037030,0.378563; 0.217949,0.036615,0.383522; 0.224763,0.036405,0.388129; 0.231538,0.036405,0.392400; 0.238273,0.036621,0.396353; 0.244967,0.037055,0.400007; 0.251620,0.037705,0.403378; 0.258234,0.038571,0.406485; 0.264810,0.039647,0.409345; 0.271347,0.040922,0.411976; 0.277850,0.042353,0.414392; 0.284321,0.043933,0.416608; 0.290763,0.045644,0.418637; 0.297178,0.047470,0.420491; 0.303568,0.049396,0.422182; 0.309935,0.051407,0.423721; 0.316282,0.053490,0.425116; 0.322610,0.055634,0.426377; 0.328921,0.057827,0.427511; 0.335217,0.060060,0.428524; 0.341500,0.062325,0.429425; 0.347771,0.064616,0.430217; 0.354032,0.066925,0.430906; 0.360284,0.069247,0.431497; 0.366529,0.071579,0.431994; 0.372768,0.073915,0.432400; 0.379001,0.076253,0.432719; 0.385228,0.078591,0.432955; 0.391453,0.080927,0.433109; 0.397674,0.083257,0.433183; 0.403894,0.085580,0.433179; 0.410113,0.087896,0.433098; 0.416331,0.090203,0.432943; 0.422549,0.092501,0.432714; 0.428768,0.094790,0.432412; 0.434987,0.097069,0.432039; 0.441207,0.099338,0.431594; 0.447428,0.101597,0.431080; 0.453651,0.103848,0.430498; 0.459875,0.106089,0.429846; 0.466100,0.108322,0.429125; 0.472328,0.110547,0.428334; 0.478558,0.112764,0.427475; 0.484789,0.114974,0.426548; 0.491022,0.117179,0.425552; 0.497257,0.119379,0.424488; 0.503493,0.121575,0.423356; 0.509730,0.123769,0.422156; 0.515967,0.125960,0.420887; 0.522206,0.128150,0.419549; 0.528444,0.130341,0.418142; 0.534683,0.132534,0.416667; 0.540920,0.134729,0.415123; 0.547157,0.136929,0.413511; 0.553392,0.139134,0.411829; 0.559624,0.141346,0.410078; 0.565854,0.143567,0.408258; 0.572081,0.145797,0.406369; 0.578304,0.148039,0.404411; 0.584521,0.150294,0.402385; 0.590734,0.152563,0.400290; 0.596940,0.154848,0.398125; 0.603139,0.157151,0.395891; 0.609330,0.159474,0.393589; 0.615513,0.161817,0.391219; 0.621685,0.164184,0.388781; 0.627847,0.166575,0.386276; 0.633998,0.168992,0.383704; 0.640135,0.171438,0.381065; 0.646260,0.173914,0.378359; 0.652369,0.176421,0.375586; 0.658463,0.178962,0.372748; 0.664540,0.181539,0.369846; 0.670599,0.184153,0.366879; 0.676638,0.186807,0.363849; 0.682656,0.189501,0.360757; 0.688653,0.192239,0.357603; 0.694627,0.195021,0.354388; 0.700576,0.197851,0.351113; 0.706500,0.200728,0.347777; 0.712396,0.203656,0.344383; 0.718264,0.206636,0.340931; 0.724103,0.209670,0.337424; 0.729909,0.212759,0.333861; 0.735683,0.215906,0.330245; 0.741423,0.219112,0.326576; 0.747127,0.222378,0.322856; 0.752794,0.225706,0.319085; 0.758422,0.229097,0.315266; 0.764010,0.232554,0.311399; 0.769556,0.236077,0.307485; 0.775059,0.239667,0.303526; 0.780517,0.243327,0.299523; 0.785929,0.247056,0.295477; 0.791293,0.250856,0.291390; 0.796607,0.254728,0.287264; 0.801871,0.258674,0.283099; 0.807082,0.262692,0.278898; 0.812239,0.266786,0.274661; 0.817341,0.270954,0.270390; 0.822386,0.275197,0.266085; 0.827372,0.279517,0.261750; 0.832299,0.283913,0.257383; 0.837165,0.288385,0.252988; 0.841969,0.292933,0.248564; 0.846709,0.297559,0.244113; 0.851384,0.302260,0.239636; 0.855992,0.307038,0.235133; 0.860533,0.311892,0.230606; 0.865006,0.316822,0.226055; 0.869409,0.321827,0.221482; 0.873741,0.326906,0.216886; 0.878001,0.332060,0.212268; 0.882188,0.337287,0.207628; 0.886302,0.342586,0.202968; 0.890341,0.347957,0.198286; 0.894305,0.353399,0.193584; 0.898192,0.358911,0.188860; 0.902003,0.364492,0.184116; 0.905735,0.370140,0.179350; 0.909390,0.375856,0.174563; 0.912966,0.381636,0.169755; 0.916462,0.387481,0.164924; 0.919879,0.393389,0.160070; 0.923215,0.399359,0.155193; 0.926470,0.405389,0.150292; 0.929644,0.411479,0.145367; 0.932737,0.417627,0.140417; 0.935747,0.423831,0.135440; 0.938675,0.430091,0.130438; 0.941521,0.436405,0.125409; 0.944285,0.442772,0.120354; 0.946965,0.449191,0.115272; 0.949562,0.455660,0.110164; 0.952075,0.462178,0.105031; 0.954506,0.468744,0.099874; 0.956852,0.475356,0.094695; 0.959114,0.482014,0.089499; 0.961293,0.488716,0.084289; 0.963387,0.495462,0.079073; 0.965397,0.502249,0.073859; 0.967322,0.509078,0.068659; 0.969163,0.515946,0.063488; 0.970919,0.522853,0.058367; 0.972590,0.529798,0.053324; 0.974176,0.536780,0.048392; 0.975677,0.543798,0.043618; 0.977092,0.550850,0.039050; 0.978422,0.557937,0.034931; 0.979666,0.565057,0.031409; 0.980824,0.572209,0.028508; 0.981895,0.579392,0.026250; 0.982881,0.586606,0.024661; 0.983779,0.593849,0.023770; 0.984591,0.601122,0.023606; 0.985315,0.608422,0.024202; 0.985952,0.615750,0.025592; 0.986502,0.623105,0.027814; 0.986964,0.630485,0.030908; 0.987337,0.637890,0.034916; 0.987622,0.645320,0.039886; 0.987819,0.652773,0.045581; 0.987926,0.660250,0.051750; 0.987945,0.667748,0.058329; 0.987874,0.675267,0.065257; 0.987714,0.682807,0.072489; 0.987464,0.690366,0.079990; 0.987124,0.697944,0.087731; 0.986694,0.705540,0.095694; 0.986175,0.713153,0.103863; 0.985566,0.720782,0.112229; 0.984865,0.728427,0.120785; 0.984075,0.736087,0.129527; 0.983196,0.743758,0.138453; 0.982228,0.751442,0.147565; 0.981173,0.759135,0.156863; 0.980032,0.766837,0.166353; 0.978806,0.774545,0.176037; 0.977497,0.782258,0.185923; 0.976108,0.789974,0.196018; 0.974638,0.797692,0.206332; 0.973088,0.805409,0.216877; 0.971468,0.813122,0.227658; 0.969783,0.820825,0.238686; 0.968041,0.828515,0.249972; 0.966243,0.836191,0.261534; 0.964394,0.843848,0.273391; 0.962517,0.851476,0.285546; 0.960626,0.859069,0.298010; 0.958720,0.866624,0.310820; 0.956834,0.874129,0.323974; 0.954997,0.881569,0.337475; 0.953215,0.888942,0.351369; 0.951546,0.896226,0.365627; 0.950018,0.903409,0.380271; 0.948683,0.910473,0.395289; 0.947594,0.917399,0.410665; 0.946809,0.924168,0.426373; 0.946392,0.930761,0.442367; 0.946403,0.937159,0.458592; 0.946903,0.943348,0.474970; 0.947937,0.949318,0.491426; 0.949545,0.955063,0.507860; 0.951740,0.960587,0.524203; 0.954529,0.965896,0.540361; 0.957896,0.971003,0.556275; 0.961812,0.975924,0.571925; 0.966249,0.980678,0.587206; 0.971162,0.985282,0.602154; 0.976511,0.989753,0.616760; 0.982257,0.994109,0.631017; 0.988362,0.998364,0.644924];
+num = size(raw,1);
+%
+% With small extrapolation when N>num:
+vec = linspace(0,num+1,N+2);
+map = interp1(1:num,raw,vec(2:N+1),'linear','extrap');
+% Interpolation only for all values of N:
+%map = interp1(1:num,raw,linspace(1,num,N),'spline')
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%inferno
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/license.txt b/Requirements/matplotlib/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d114eb38bb7ec9f6e80e163eecc5902ad26584e4
--- /dev/null
+++ b/Requirements/matplotlib/license.txt
@@ -0,0 +1,27 @@
+Copyright (c) 2022, Stephen Cobeldick
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution
+
+* Neither the name of  nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/matplotlib/magma.m b/Requirements/matplotlib/magma.m
new file mode 100644
index 0000000000000000000000000000000000000000..6e658e0d4b5608557376b981bbe0d04ef8903b7d
--- /dev/null
+++ b/Requirements/matplotlib/magma.m
@@ -0,0 +1,83 @@
+function [map,num] = magma(N)
+% Perceptually uniform sequential colormap from MatPlotLib.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = magma
+%  map = magma(N)
+%
+% Colormap designed by Nathaniel J. Smith and Stefan van der Walt.
+%
+% For MatPlotLib 2.0 improved colormaps were created in the perceptually
+% uniform colorspace CAM02-UCS. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% The RGB data is from here: <https://bids.github.io/colormap/>
+%
+% Note VIRIDIS replaces the awful JET as the MatPlotLib default colormap.
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(magma(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(magma)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(magma)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also CIVIDIS INFERNO PLASMA TWILIGHT TWILIGHT_SHIFTED VIRIDIS
+% TAB10 TAB20 TAB20B TAB20C
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:magma:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.001462,0.000466,0.013866; 0.002258,0.001295,0.018331; 0.003279,0.002305,0.023708; 0.004512,0.003490,0.029965; 0.005950,0.004843,0.037130; 0.007588,0.006356,0.044973; 0.009426,0.008022,0.052844; 0.011465,0.009828,0.060750; 0.013708,0.011771,0.068667; 0.016156,0.013840,0.076603; 0.018815,0.016026,0.084584; 0.021692,0.018320,0.092610; 0.024792,0.020715,0.100676; 0.028123,0.023201,0.108787; 0.031696,0.025765,0.116965; 0.035520,0.028397,0.125209; 0.039608,0.031090,0.133515; 0.043830,0.033830,0.141886; 0.048062,0.036607,0.150327; 0.052320,0.039407,0.158841; 0.056615,0.042160,0.167446; 0.060949,0.044794,0.176129; 0.065330,0.047318,0.184892; 0.069764,0.049726,0.193735; 0.074257,0.052017,0.202660; 0.078815,0.054184,0.211667; 0.083446,0.056225,0.220755; 0.088155,0.058133,0.229922; 0.092949,0.059904,0.239164; 0.097833,0.061531,0.248477; 0.102815,0.063010,0.257854; 0.107899,0.064335,0.267289; 0.113094,0.065492,0.276784; 0.118405,0.066479,0.286321; 0.123833,0.067295,0.295879; 0.129380,0.067935,0.305443; 0.135053,0.068391,0.315000; 0.140858,0.068654,0.324538; 0.146785,0.068738,0.334011; 0.152839,0.068637,0.343404; 0.159018,0.068354,0.352688; 0.165308,0.067911,0.361816; 0.171713,0.067305,0.370771; 0.178212,0.066576,0.379497; 0.184801,0.065732,0.387973; 0.191460,0.064818,0.396152; 0.198177,0.063862,0.404009; 0.204935,0.062907,0.411514; 0.211718,0.061992,0.418647; 0.218512,0.061158,0.425392; 0.225302,0.060445,0.431742; 0.232077,0.059889,0.437695; 0.238826,0.059517,0.443256; 0.245543,0.059352,0.448436; 0.252220,0.059415,0.453248; 0.258857,0.059706,0.457710; 0.265447,0.060237,0.461840; 0.271994,0.060994,0.465660; 0.278493,0.061978,0.469190; 0.284951,0.063168,0.472451; 0.291366,0.064553,0.475462; 0.297740,0.066117,0.478243; 0.304081,0.067835,0.480812; 0.310382,0.069702,0.483186; 0.316654,0.071690,0.485380; 0.322899,0.073782,0.487408; 0.329114,0.075972,0.489287; 0.335308,0.078236,0.491024; 0.341482,0.080564,0.492631; 0.347636,0.082946,0.494121; 0.353773,0.085373,0.495501; 0.359898,0.087831,0.496778; 0.366012,0.090314,0.497960; 0.372116,0.092816,0.499053; 0.378211,0.095332,0.500067; 0.384299,0.097855,0.501002; 0.390384,0.100379,0.501864; 0.396467,0.102902,0.502658; 0.402548,0.105420,0.503386; 0.408629,0.107930,0.504052; 0.414709,0.110431,0.504662; 0.420791,0.112920,0.505215; 0.426877,0.115395,0.505714; 0.432967,0.117855,0.506160; 0.439062,0.120298,0.506555; 0.445163,0.122724,0.506901; 0.451271,0.125132,0.507198; 0.457386,0.127522,0.507448; 0.463508,0.129893,0.507652; 0.469640,0.132245,0.507809; 0.475780,0.134577,0.507921; 0.481929,0.136891,0.507989; 0.488088,0.139186,0.508011; 0.494258,0.141462,0.507988; 0.500438,0.143719,0.507920; 0.506629,0.145958,0.507806; 0.512831,0.148179,0.507648; 0.519045,0.150383,0.507443; 0.525270,0.152569,0.507192; 0.531507,0.154739,0.506895; 0.537755,0.156894,0.506551; 0.544015,0.159033,0.506159; 0.550287,0.161158,0.505719; 0.556571,0.163269,0.505230; 0.562866,0.165368,0.504692; 0.569172,0.167454,0.504105; 0.575490,0.169530,0.503466; 0.581819,0.171596,0.502777; 0.588158,0.173652,0.502035; 0.594508,0.175701,0.501241; 0.600868,0.177743,0.500394; 0.607238,0.179779,0.499492; 0.613617,0.181811,0.498536; 0.620005,0.183840,0.497524; 0.626401,0.185867,0.496456; 0.632805,0.187893,0.495332; 0.639216,0.189921,0.494150; 0.645633,0.191952,0.492910; 0.652056,0.193986,0.491611; 0.658483,0.196027,0.490253; 0.664915,0.198075,0.488836; 0.671349,0.200133,0.487358; 0.677786,0.202203,0.485819; 0.684224,0.204286,0.484219; 0.690661,0.206384,0.482558; 0.697098,0.208501,0.480835; 0.703532,0.210638,0.479049; 0.709962,0.212797,0.477201; 0.716387,0.214982,0.475290; 0.722805,0.217194,0.473316; 0.729216,0.219437,0.471279; 0.735616,0.221713,0.469180; 0.742004,0.224025,0.467018; 0.748378,0.226377,0.464794; 0.754737,0.228772,0.462509; 0.761077,0.231214,0.460162; 0.767398,0.233705,0.457755; 0.773695,0.236249,0.455289; 0.779968,0.238851,0.452765; 0.786212,0.241514,0.450184; 0.792427,0.244242,0.447543; 0.798608,0.247040,0.444848; 0.804752,0.249911,0.442102; 0.810855,0.252861,0.439305; 0.816914,0.255895,0.436461; 0.822926,0.259016,0.433573; 0.828886,0.262229,0.430644; 0.834791,0.265540,0.427671; 0.840636,0.268953,0.424666; 0.846416,0.272473,0.421631; 0.852126,0.276106,0.418573; 0.857763,0.279857,0.415496; 0.863320,0.283729,0.412403; 0.868793,0.287728,0.409303; 0.874176,0.291859,0.406205; 0.879464,0.296125,0.403118; 0.884651,0.300530,0.400047; 0.889731,0.305079,0.397002; 0.894700,0.309773,0.393995; 0.899552,0.314616,0.391037; 0.904281,0.319610,0.388137; 0.908884,0.324755,0.385308; 0.913354,0.330052,0.382563; 0.917689,0.335500,0.379915; 0.921884,0.341098,0.377376; 0.925937,0.346844,0.374959; 0.929845,0.352734,0.372677; 0.933606,0.358764,0.370541; 0.937221,0.364929,0.368567; 0.940687,0.371224,0.366762; 0.944006,0.377643,0.365136; 0.947180,0.384178,0.363701; 0.950210,0.390820,0.362468; 0.953099,0.397563,0.361438; 0.955849,0.404400,0.360619; 0.958464,0.411324,0.360014; 0.960949,0.418323,0.359630; 0.963310,0.425390,0.359469; 0.965549,0.432519,0.359529; 0.967671,0.439703,0.359810; 0.969680,0.446936,0.360311; 0.971582,0.454210,0.361030; 0.973381,0.461520,0.361965; 0.975082,0.468861,0.363111; 0.976690,0.476226,0.364466; 0.978210,0.483612,0.366025; 0.979645,0.491014,0.367783; 0.981000,0.498428,0.369734; 0.982279,0.505851,0.371874; 0.983485,0.513280,0.374198; 0.984622,0.520713,0.376698; 0.985693,0.528148,0.379371; 0.986700,0.535582,0.382210; 0.987646,0.543015,0.385210; 0.988533,0.550446,0.388365; 0.989363,0.557873,0.391671; 0.990138,0.565296,0.395122; 0.990871,0.572706,0.398714; 0.991558,0.580107,0.402441; 0.992196,0.587502,0.406299; 0.992785,0.594891,0.410283; 0.993326,0.602275,0.414390; 0.993834,0.609644,0.418613; 0.994309,0.616999,0.422950; 0.994738,0.624350,0.427397; 0.995122,0.631696,0.431951; 0.995480,0.639027,0.436607; 0.995810,0.646344,0.441361; 0.996096,0.653659,0.446213; 0.996341,0.660969,0.451160; 0.996580,0.668256,0.456192; 0.996775,0.675541,0.461314; 0.996925,0.682828,0.466526; 0.997077,0.690088,0.471811; 0.997186,0.697349,0.477182; 0.997254,0.704611,0.482635; 0.997325,0.711848,0.488154; 0.997351,0.719089,0.493755; 0.997351,0.726324,0.499428; 0.997341,0.733545,0.505167; 0.997285,0.740772,0.510983; 0.997228,0.747981,0.516859; 0.997138,0.755190,0.522806; 0.997019,0.762398,0.528821; 0.996898,0.769591,0.534892; 0.996727,0.776795,0.541039; 0.996571,0.783977,0.547233; 0.996369,0.791167,0.553499; 0.996162,0.798348,0.559820; 0.995932,0.805527,0.566202; 0.995680,0.812706,0.572645; 0.995424,0.819875,0.579140; 0.995131,0.827052,0.585701; 0.994851,0.834213,0.592307; 0.994524,0.841387,0.598983; 0.994222,0.848540,0.605696; 0.993866,0.855711,0.612482; 0.993545,0.862859,0.619299; 0.993170,0.870024,0.626189; 0.992831,0.877168,0.633109; 0.992440,0.884330,0.640099; 0.992089,0.891470,0.647116; 0.991688,0.898627,0.654202; 0.991332,0.905763,0.661309; 0.990930,0.912915,0.668481; 0.990570,0.920049,0.675675; 0.990175,0.927196,0.682926; 0.989815,0.934329,0.690198; 0.989434,0.941470,0.697519; 0.989077,0.948604,0.704863; 0.988717,0.955742,0.712242; 0.988367,0.962878,0.719649; 0.988033,0.970012,0.727077; 0.987691,0.977154,0.734536; 0.987387,0.984288,0.742002; 0.987053,0.991438,0.749504];
+num = size(raw,1);
+%
+% With small extrapolation when N>num:
+vec = linspace(0,num+1,N+2);
+map = interp1(1:num,raw,vec(2:N+1),'linear','extrap');
+% Interpolation only for all values of N:
+%map = interp1(1:num,raw,linspace(1,num,N),'spline')
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%magma
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/matplotlib_doc.m b/Requirements/matplotlib/matplotlib_doc.m
new file mode 100644
index 0000000000000000000000000000000000000000..94f75de96ee57dd9c79b46deb7c8b119c6468d42
--- /dev/null
+++ b/Requirements/matplotlib/matplotlib_doc.m
@@ -0,0 +1,75 @@
+%% Perceptually Uniform Colormaps from MatPlotLib
+% The <www.mathworks.com/matlabcentral/fileexchange/62729
+% MatPlotLib Perceptually Uniform Colormaps> submission includes the
+% default colormap family and default line colororder family from
+% MatPlotLib 2 and 3. This document shows examples of their usage.
+%% Overview
+matplotlib_plot()
+%% |VIRIDIS|
+% * Sequential
+% * Perceptually uniform
+% * Default colormap for MatPlotLib 2 and 3
+close()
+load spine
+image(X)
+colormap(viridis)
+colorbar()
+%% |CIVIDIS|
+% * Sequential
+% * Perceptually uniform
+% * Optimized for color-vision deficiency
+colormap(cividis)
+%% |INFERNO|
+% * Sequential
+% * Perceptually uniform
+colormap(inferno)
+%% |MAGMA|
+% * Sequential
+% * Perceptually uniform
+colormap(magma)
+%% |PLASMA|
+% * Sequential
+% * Perceptually uniform
+colormap(plasma)
+%% |TWILIGHT|
+% * Cyclical
+% * Perceptually uniform
+colormap(twilight)
+%% |TWILIGHT_SHIFTED|
+% * Cyclical
+% * Perceptually uniform
+colormap(twilight_shifted)
+%% |TAB10|
+% * Qualitative
+% * Default line ColorOrder for MatPlotLib 2 and 3
+% * Named VEGA10 in MatPlotLib 2
+N = 10;
+X = linspace(0,pi*3,1000);
+Y = bsxfun(@(x,n)n*sin(x+2*n*pi/N), X(:), 1:N);
+clf()
+axes('ColorOrder',tab10(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+%% |TAB20|
+% * Qualitative
+% * Named VEGA20 in MatPlotLib 2
+N = 20;
+Y = bsxfun(@(x,n)n*sin(x+2*n*pi/N), X(:), 1:N);
+clf()
+axes('ColorOrder',tab20(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+%% |TAB20B|
+% * Qualitative
+% * Named VEGA20B in MatPlotLib 2
+clf()
+axes('ColorOrder',tab20b(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
+%% |TAB20C|
+% * Qualitative
+% * Named VEGA20C in MatPlotLib 2
+clf()
+axes('ColorOrder',tab20c(N),'NextPlot','replacechildren')
+plot(X,Y, 'linewidth',4)
+legend('location','eastoutside')
\ No newline at end of file
diff --git a/Requirements/matplotlib/plasma.m b/Requirements/matplotlib/plasma.m
new file mode 100644
index 0000000000000000000000000000000000000000..cd42b7be491f19c84b6344832ab3ed0928552979
--- /dev/null
+++ b/Requirements/matplotlib/plasma.m
@@ -0,0 +1,83 @@
+function [map,num] = plasma(N)
+% Perceptually uniform sequential colormap from MatPlotLib.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = plasma
+%  map = plasma(N)
+%
+% Colormap designed by Nathaniel J. Smith and Stefan van der Walt.
+%
+% For MatPlotLib 2.0 improved colormaps were created in the perceptually
+% uniform colorspace CAM02-UCS. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% The RGB data is from here: <https://bids.github.io/colormap/>
+%
+% Note VIRIDIS replaces the awful JET as the MatPlotLib default colormap.
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(plasma(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(plasma)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(plasma)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also CIVIDIS INFERNO MAGMA TWILIGHT TWILIGHT_SHIFTED VIRIDIS
+% TAB10 TAB20 TAB20B TAB20C
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:plasma:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.050383,0.029803,0.527975; 0.063536,0.028426,0.533124; 0.075353,0.027206,0.538007; 0.086222,0.026125,0.542658; 0.096379,0.025165,0.547103; 0.105980,0.024309,0.551368; 0.115124,0.023556,0.555468; 0.123903,0.022878,0.559423; 0.132381,0.022258,0.563250; 0.140603,0.021687,0.566959; 0.148607,0.021154,0.570562; 0.156421,0.020651,0.574065; 0.164070,0.020171,0.577478; 0.171574,0.019706,0.580806; 0.178950,0.019252,0.584054; 0.186213,0.018803,0.587228; 0.193374,0.018354,0.590330; 0.200445,0.017902,0.593364; 0.207435,0.017442,0.596333; 0.214350,0.016973,0.599239; 0.221197,0.016497,0.602083; 0.227983,0.016007,0.604867; 0.234715,0.015502,0.607592; 0.241396,0.014979,0.610259; 0.248032,0.014439,0.612868; 0.254627,0.013882,0.615419; 0.261183,0.013308,0.617911; 0.267703,0.012716,0.620346; 0.274191,0.012109,0.622722; 0.280648,0.011488,0.625038; 0.287076,0.010855,0.627295; 0.293478,0.010213,0.629490; 0.299855,0.009561,0.631624; 0.306210,0.008902,0.633694; 0.312543,0.008239,0.635700; 0.318856,0.007576,0.637640; 0.325150,0.006915,0.639512; 0.331426,0.006261,0.641316; 0.337683,0.005618,0.643049; 0.343925,0.004991,0.644710; 0.350150,0.004382,0.646298; 0.356359,0.003798,0.647810; 0.362553,0.003243,0.649245; 0.368733,0.002724,0.650601; 0.374897,0.002245,0.651876; 0.381047,0.001814,0.653068; 0.387183,0.001434,0.654177; 0.393304,0.001114,0.655199; 0.399411,0.000859,0.656133; 0.405503,0.000678,0.656977; 0.411580,0.000577,0.657730; 0.417642,0.000564,0.658390; 0.423689,0.000646,0.658956; 0.429719,0.000831,0.659425; 0.435734,0.001127,0.659797; 0.441732,0.001540,0.660069; 0.447714,0.002080,0.660240; 0.453677,0.002755,0.660310; 0.459623,0.003574,0.660277; 0.465550,0.004545,0.660139; 0.471457,0.005678,0.659897; 0.477344,0.006980,0.659549; 0.483210,0.008460,0.659095; 0.489055,0.010127,0.658534; 0.494877,0.011990,0.657865; 0.500678,0.014055,0.657088; 0.506454,0.016333,0.656202; 0.512206,0.018833,0.655209; 0.517933,0.021563,0.654109; 0.523633,0.024532,0.652901; 0.529306,0.027747,0.651586; 0.534952,0.031217,0.650165; 0.540570,0.034950,0.648640; 0.546157,0.038954,0.647010; 0.551715,0.043136,0.645277; 0.557243,0.047331,0.643443; 0.562738,0.051545,0.641509; 0.568201,0.055778,0.639477; 0.573632,0.060028,0.637349; 0.579029,0.064296,0.635126; 0.584391,0.068579,0.632812; 0.589719,0.072878,0.630408; 0.595011,0.077190,0.627917; 0.600266,0.081516,0.625342; 0.605485,0.085854,0.622686; 0.610667,0.090204,0.619951; 0.615812,0.094564,0.617140; 0.620919,0.098934,0.614257; 0.625987,0.103312,0.611305; 0.631017,0.107699,0.608287; 0.636008,0.112092,0.605205; 0.640959,0.116492,0.602065; 0.645872,0.120898,0.598867; 0.650746,0.125309,0.595617; 0.655580,0.129725,0.592317; 0.660374,0.134144,0.588971; 0.665129,0.138566,0.585582; 0.669845,0.142992,0.582154; 0.674522,0.147419,0.578688; 0.679160,0.151848,0.575189; 0.683758,0.156278,0.571660; 0.688318,0.160709,0.568103; 0.692840,0.165141,0.564522; 0.697324,0.169573,0.560919; 0.701769,0.174005,0.557296; 0.706178,0.178437,0.553657; 0.710549,0.182868,0.550004; 0.714883,0.187299,0.546338; 0.719181,0.191729,0.542663; 0.723444,0.196158,0.538981; 0.727670,0.200586,0.535293; 0.731862,0.205013,0.531601; 0.736019,0.209439,0.527908; 0.740143,0.213864,0.524216; 0.744232,0.218288,0.520524; 0.748289,0.222711,0.516834; 0.752312,0.227133,0.513149; 0.756304,0.231555,0.509468; 0.760264,0.235976,0.505794; 0.764193,0.240396,0.502126; 0.768090,0.244817,0.498465; 0.771958,0.249237,0.494813; 0.775796,0.253658,0.491171; 0.779604,0.258078,0.487539; 0.783383,0.262500,0.483918; 0.787133,0.266922,0.480307; 0.790855,0.271345,0.476706; 0.794549,0.275770,0.473117; 0.798216,0.280197,0.469538; 0.801855,0.284626,0.465971; 0.805467,0.289057,0.462415; 0.809052,0.293491,0.458870; 0.812612,0.297928,0.455338; 0.816144,0.302368,0.451816; 0.819651,0.306812,0.448306; 0.823132,0.311261,0.444806; 0.826588,0.315714,0.441316; 0.830018,0.320172,0.437836; 0.833422,0.324635,0.434366; 0.836801,0.329105,0.430905; 0.840155,0.333580,0.427455; 0.843484,0.338062,0.424013; 0.846788,0.342551,0.420579; 0.850066,0.347048,0.417153; 0.853319,0.351553,0.413734; 0.856547,0.356066,0.410322; 0.859750,0.360588,0.406917; 0.862927,0.365119,0.403519; 0.866078,0.369660,0.400126; 0.869203,0.374212,0.396738; 0.872303,0.378774,0.393355; 0.875376,0.383347,0.389976; 0.878423,0.387932,0.386600; 0.881443,0.392529,0.383229; 0.884436,0.397139,0.379860; 0.887402,0.401762,0.376494; 0.890340,0.406398,0.373130; 0.893250,0.411048,0.369768; 0.896131,0.415712,0.366407; 0.898984,0.420392,0.363047; 0.901807,0.425087,0.359688; 0.904601,0.429797,0.356329; 0.907365,0.434524,0.352970; 0.910098,0.439268,0.349610; 0.912800,0.444029,0.346251; 0.915471,0.448807,0.342890; 0.918109,0.453603,0.339529; 0.920714,0.458417,0.336166; 0.923287,0.463251,0.332801; 0.925825,0.468103,0.329435; 0.928329,0.472975,0.326067; 0.930798,0.477867,0.322697; 0.933232,0.482780,0.319325; 0.935630,0.487712,0.315952; 0.937990,0.492667,0.312575; 0.940313,0.497642,0.309197; 0.942598,0.502639,0.305816; 0.944844,0.507658,0.302433; 0.947051,0.512699,0.299049; 0.949217,0.517763,0.295662; 0.951344,0.522850,0.292275; 0.953428,0.527960,0.288883; 0.955470,0.533093,0.285490; 0.957469,0.538250,0.282096; 0.959424,0.543431,0.278701; 0.961336,0.548636,0.275305; 0.963203,0.553865,0.271909; 0.965024,0.559118,0.268513; 0.966798,0.564396,0.265118; 0.968526,0.569700,0.261721; 0.970205,0.575028,0.258325; 0.971835,0.580382,0.254931; 0.973416,0.585761,0.251540; 0.974947,0.591165,0.248151; 0.976428,0.596595,0.244767; 0.977856,0.602051,0.241387; 0.979233,0.607532,0.238013; 0.980556,0.613039,0.234646; 0.981826,0.618572,0.231287; 0.983041,0.624131,0.227937; 0.984199,0.629718,0.224595; 0.985301,0.635330,0.221265; 0.986345,0.640969,0.217948; 0.987332,0.646633,0.214648; 0.988260,0.652325,0.211364; 0.989128,0.658043,0.208100; 0.989935,0.663787,0.204859; 0.990681,0.669558,0.201642; 0.991365,0.675355,0.198453; 0.991985,0.681179,0.195295; 0.992541,0.687030,0.192170; 0.993032,0.692907,0.189084; 0.993456,0.698810,0.186041; 0.993814,0.704741,0.183043; 0.994103,0.710698,0.180097; 0.994324,0.716681,0.177208; 0.994474,0.722691,0.174381; 0.994553,0.728728,0.171622; 0.994561,0.734791,0.168938; 0.994495,0.740880,0.166335; 0.994355,0.746995,0.163821; 0.994141,0.753137,0.161404; 0.993851,0.759304,0.159092; 0.993482,0.765499,0.156891; 0.993033,0.771720,0.154808; 0.992505,0.777967,0.152855; 0.991897,0.784239,0.151042; 0.991209,0.790537,0.149377; 0.990439,0.796859,0.147870; 0.989587,0.803205,0.146529; 0.988648,0.809579,0.145357; 0.987621,0.815978,0.144363; 0.986509,0.822401,0.143557; 0.985314,0.828846,0.142945; 0.984031,0.835315,0.142528; 0.982653,0.841812,0.142303; 0.981190,0.848329,0.142279; 0.979644,0.854866,0.142453; 0.977995,0.861432,0.142808; 0.976265,0.868016,0.143351; 0.974443,0.874622,0.144061; 0.972530,0.881250,0.144923; 0.970533,0.887896,0.145919; 0.968443,0.894564,0.147014; 0.966271,0.901249,0.148180; 0.964021,0.907950,0.149370; 0.961681,0.914672,0.150520; 0.959276,0.921407,0.151566; 0.956808,0.928152,0.152409; 0.954287,0.934908,0.152921; 0.951726,0.941671,0.152925; 0.949151,0.948435,0.152178; 0.946602,0.955190,0.150328; 0.944152,0.961916,0.146861; 0.941896,0.968590,0.140956; 0.940015,0.975158,0.131326];
+num = size(raw,1);
+%
+% With small extrapolation when N>num:
+vec = linspace(0,num+1,N+2);
+map = interp1(1:num,raw,vec(2:N+1),'linear','extrap');
+% Interpolation only for all values of N:
+%map = interp1(1:num,raw,linspace(1,num,N),'spline')
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%plasma
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/tab10.m b/Requirements/matplotlib/tab10.m
new file mode 100644
index 0000000000000000000000000000000000000000..8e4973a80c37f87f1aedbdc5f2503f75007a727f
--- /dev/null
+++ b/Requirements/matplotlib/tab10.m
@@ -0,0 +1,89 @@
+function [map,num] = tab10(N)
+% Qualitative colormap from MatPlotLib, for plots using the line ColorOrder.
+% In MatPlotLib 2 it is named VEGA10, for MatPlotLib 3 was renamed TAB10.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = tab10
+%  map = tab10(N)
+%
+% For MatPlotLib 2.0 improved colormaps were created for plot lines of
+% categorical data. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% VEGA10/TAB10 is the default Line Color Order for MatPlotLib 2 and 3.
+%
+% MATLAB axes ColorOrder (note that this is NOT the axes COLORMAP):
+% <https://www.mathworks.com/help/matlab/creating_plots/defining-the-color-of-lines-for-plotting.html>
+% <https://www.mathworks.com/help/matlab/graphics_transition/why-are-plot-lines-different-colors.html>
+%
+%% Examples %%
+%
+%%% PLOT using matrices:
+% N = 10;
+% axes('ColorOrder',tab10(N),'NextPlot','replacechildren')
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% plot(X,Y, 'linewidth',4)
+%
+%%% PLOT in a loop:
+% N = 10;
+% set(0,'DefaultAxesColorOrder',tab10(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% for n = 1:N
+%     plot(X(:),Y(:,n), 'linewidth',4);
+%     hold all
+% end
+%
+%%% LINE using matrices:
+% N = 10;
+% set(0,'DefaultAxesColorOrder',tab10(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*cos(x+2*n*pi/N), X(:), 1:N);
+% line(X(:),Y)
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also TAB20 TAB20B TAB20C
+% CIVIDIS INFERNO MAGMA PLASMA TWILIGHT TWLIGHT_SHIFTED VIRIDIS
+% MAXDISTCOLOR BREWERMAP CUBEHELIX LINES PARULA COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:tab10:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+hex = ['#1f77b4','#ff7f0e','#2ca02c','#d62728','#9467bd','#8c564b','#e377c2','#7f7f7f','#bcbd22','#17becf'];
+raw = sscanf(hex.','#%2x%2x%2x',[3,Inf]).';
+num = size(raw,1);
+%
+map = raw(1+mod(0:N-1,num),:) / 255;
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%tab10
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/tab20.m b/Requirements/matplotlib/tab20.m
new file mode 100644
index 0000000000000000000000000000000000000000..9e3b8682004d71e4e153ee891218ae55fc0f539a
--- /dev/null
+++ b/Requirements/matplotlib/tab20.m
@@ -0,0 +1,89 @@
+function [map,num] = tab20(N)
+% Qualitative colormap from MatPlotLib, for plots using the line ColorOrder.
+% In MatPlotLib 2 it is named VEGA20, for MatPlotLib 3 was renamed TAB20.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = tab20
+%  map = tab20(N)
+%
+% For MatPlotLib 2.0 improved colormaps were created for plot lines of
+% categorical data. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% VEGA10/TAB10 is the default Line Color Order for MatPlotLib 2 and 3.
+%
+% MATLAB axes ColorOrder (note that this is NOT the axes COLORMAP):
+% <https://www.mathworks.com/help/matlab/creating_plots/defining-the-color-of-lines-for-plotting.html>
+% <https://www.mathworks.com/help/matlab/graphics_transition/why-are-plot-lines-different-colors.html>
+%
+%% Examples %%
+%
+%%% PLOT using matrices:
+% N = 20;
+% axes('ColorOrder',tab20(N),'NextPlot','replacechildren')
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% plot(X,Y, 'linewidth',4)
+%
+%%% PLOT in a loop:
+% N = 20;
+% set(0,'DefaultAxesColorOrder',tab20(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% for n = 1:N
+%     plot(X(:),Y(:,n), 'linewidth',4);
+%     hold all
+% end
+%
+%%% LINE using matrices:
+% N = 20;
+% set(0,'DefaultAxesColorOrder',tab20(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*cos(x+2*n*pi/N), X(:), 1:N);
+% line(X(:),Y)
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also TAB10 TAB20B TAB20C
+% CIVIDIS INFERNO MAGMA PLASMA TWILIGHT TWLIGHT_SHIFTED VIRIDIS
+% MAXDISTCOLOR BREWERMAP CUBEHELIX LINES PARULA COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:tab20:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+hex = ['#1f77b4';'#aec7e8';'#ff7f0e';'#ffbb78';'#2ca02c';'#98df8a';'#d62728';'#ff9896';'#9467bd';'#c5b0d5';'#8c564b';'#c49c94';'#e377c2';'#f7b6d2';'#7f7f7f';'#c7c7c7';'#bcbd22';'#dbdb8d';'#17becf';'#9edae5'];
+raw = sscanf(hex.','#%2x%2x%2x',[3,Inf]).';
+num = size(raw,1);
+%
+map = raw(1+mod(0:N-1,num),:) / 255;
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%tab20
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/tab20b.m b/Requirements/matplotlib/tab20b.m
new file mode 100644
index 0000000000000000000000000000000000000000..cb2bbaec951cc133a2ab9539affc7dcce6e66857
--- /dev/null
+++ b/Requirements/matplotlib/tab20b.m
@@ -0,0 +1,89 @@
+function [map,num] = tab20b(N)
+% Qualitative colormap from MatPlotLib, for plots using the line ColorOrder.
+% In MatPlotLib 2 it is named VEGA20B, for MatPlotLib 3 was renamed TAB20B.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = tab20b
+%  map = tab20b(N)
+%
+% For MatPlotLib 2.0 improved colormaps were created for plot lines of
+% categorical data. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% VEGA10/TAB10 is the default Line Color Order for MatPlotLib 2 and 3.
+%
+% MATLAB axes ColorOrder (note that this is NOT the axes COLORMAP):
+% <https://www.mathworks.com/help/matlab/creating_plots/defining-the-color-of-lines-for-plotting.html>
+% <https://www.mathworks.com/help/matlab/graphics_transition/why-are-plot-lines-different-colors.html>
+%
+%% Examples %%
+%
+%%% PLOT using matrices:
+% N = 20;
+% axes('ColorOrder',tab20b(N),'NextPlot','replacechildren')
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% plot(X,Y, 'linewidth',4)
+%
+%%% PLOT in a loop:
+% N = 20;
+% set(0,'DefaultAxesColorOrder',tab20b(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% for n = 1:N
+%     plot(X(:),Y(:,n), 'linewidth',4);
+%     hold all
+% end
+%
+%%% LINE using matrices:
+% N = 20;
+% set(0,'DefaultAxesColorOrder',tab20b(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*cos(x+2*n*pi/N), X(:), 1:N);
+% line(X(:),Y)
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also TAB10 TAB20 TAB20C
+% CIVIDIS INFERNO MAGMA PLASMA TWILIGHT TWLIGHT_SHIFTED VIRIDIS
+% MAXDISTCOLOR BREWERMAP CUBEHELIX LINES PARULA COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:tab20b:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+hex = ['#393b79';'#5254a3';'#6b6ecf';'#9c9ede';'#637939';'#8ca252';'#b5cf6b';'#cedb9c';'#8c6d31';'#bd9e39';'#e7ba52';'#e7cb94';'#843c39';'#ad494a';'#d6616b';'#e7969c';'#7b4173';'#a55194';'#ce6dbd';'#de9ed6'];
+raw = sscanf(hex.','#%2x%2x%2x',[3,Inf]).';
+num = size(raw,1);
+%
+map = raw(1+mod(0:N-1,num),:) / 255;
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%tab20b
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/tab20c.m b/Requirements/matplotlib/tab20c.m
new file mode 100644
index 0000000000000000000000000000000000000000..76f38d6beb260b863716d3f90a1814ddf1fd096e
--- /dev/null
+++ b/Requirements/matplotlib/tab20c.m
@@ -0,0 +1,89 @@
+function [map,num] = tab20c(N)
+% Qualitative colormap from MatPlotLib, for plots using the line ColorOrder.
+% In MatPlotLib 2 it is named VEGA20C, for MatPlotLib 3 was renamed TAB20C.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = tab20c
+%  map = tab20c(N)
+%
+% For MatPlotLib 2.0 improved colormaps were created for plot lines of
+% categorical data. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% VEGA10/TAB10 is the default Line Color Order for MatPlotLib 2 and 3.
+%
+% MATLAB axes ColorOrder (note that this is NOT the axes COLORMAP):
+% <https://www.mathworks.com/help/matlab/creating_plots/defining-the-color-of-lines-for-plotting.html>
+% <https://www.mathworks.com/help/matlab/graphics_transition/why-are-plot-lines-different-colors.html>
+%
+%% Examples %%
+%
+%%% PLOT using matrices:
+% N = 20;
+% axes('ColorOrder',tab20c(N),'NextPlot','replacechildren')
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% plot(X,Y, 'linewidth',4)
+%
+%%% PLOT in a loop:
+% N = 20;
+% set(0,'DefaultAxesColorOrder',tab20c(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*sin(x+2*n*pi/N), X(:), 1:N);
+% for n = 1:N
+%     plot(X(:),Y(:,n), 'linewidth',4);
+%     hold all
+% end
+%
+%%% LINE using matrices:
+% N = 20;
+% set(0,'DefaultAxesColorOrder',tab20c(N))
+% X = linspace(0,pi*3,1000);
+% Y = bsxfun(@(x,n)sqrt(n)*cos(x+2*n*pi/N), X(:), 1:N);
+% line(X(:),Y)
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also TAB10 TAB20 TAB20B
+% CIVIDIS INFERNO MAGMA PLASMA TWILIGHT TWLIGHT_SHIFTED VIRIDIS
+% MAXDISTCOLOR BREWERMAP CUBEHELIX LINES PARULA COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:tab20c:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+hex = ['#3182bd';'#6baed6';'#9ecae1';'#c6dbef';'#e6550d';'#fd8d3c';'#fdae6b';'#fdd0a2';'#31a354';'#74c476';'#a1d99b';'#c7e9c0';'#756bb1';'#9e9ac8';'#bcbddc';'#dadaeb';'#636363';'#969696';'#bdbdbd';'#d9d9d9'];
+raw = sscanf(hex.','#%2x%2x%2x',[3,Inf]).';
+num = size(raw,1);
+%
+map = raw(1+mod(0:N-1,num),:) / 255;
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%tab20c
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/test_viridis.m b/Requirements/matplotlib/test_viridis.m
new file mode 100644
index 0000000000000000000000000000000000000000..5702a4f9419544ccf7149422842dd2c340ef2fc0
--- /dev/null
+++ b/Requirements/matplotlib/test_viridis.m
@@ -0,0 +1,181 @@
+
+x = 1:10;
+y = ones(1,10);
+
+namesavatar = {'pulmonary','LA','MV','LV','AV','AA','peripheral'};
+namesavatar2 = {'pulmonary','MV','LA','AV','LV','AA','peripheral'};
+namesavatar3 = {'pulmonary','LA','MV','LV','AV','peripheral','AA'};
+
+namesFat = {'Glycerol','NEFA','TAG'};
+namesFat2 = {'Glycerol','Glycerol A','Glycerol V','NEFA','NEFA A','NEFA V','TAG','TAG A','TAG V'};
+
+
+names = namesavatar;
+N = length(names);
+c = viridis(N);
+% c = [c(2:2:end,:);c(1:2:end,:)];
+% c= circshift(c,-1);
+% c(3,:) = c(1,:);
+% c(5,:) = c(4,:);
+c_rgb = round(c.*255,0);
+for i = 1:size(c_rgb,1)
+    c_hex{i} = rgb2hex(c_rgb(i,:));
+end
+
+% new color
+c2_rgb = [166,206,227
+31,120,180
+178,223,138
+51,160,44
+251,154,153
+227,26,28
+253,191,111];
+c2 = c2_rgb./255;
+c2_hex = {'#a6cee3'
+'#1f78b4'
+'#b2df8a'
+'#33a02c'
+'#fb9a99'
+'#e31a1c'
+'#fdbf6f'};
+c3_hex= circshift(c2_hex,3);
+c3 = circshift(c2,3);
+c2_hex= circshift(c2_hex,1);
+c2 = circshift(c2,1);
+c2(1,:) = [0.5 0.5 0.5];
+% c2 = c3;
+% c2 = [c2(6:-1:5,:);c2(2:-1:1,:);c2(4:-1:3,:);c2(7,:)];
+
+%third color
+c4_hex = {'008080','70a494','b4c8a8','f6edbd','edbb8a','de8a5a','ca562c'};
+c4_hex = circshift(c4_hex,4);
+c4 = zeros(length(c4_hex),3);
+for i = 1:length(c4_hex)
+    c4(i,:) = hex2rgb(c4_hex{i});
+end
+% c4(3,:) = c4(3,:)*0.9;
+c4 = circshift(c4,4);
+
+f = figure('Name','Viridis color map test');
+f.Units = 'Normalized';
+f.OuterPosition = [0 0 1 1];
+subplot(2,3,1)
+for i = 1:N
+    plot(x,x*i,'color',c(i,:),'LineWidth',4)
+    hold on
+%     plot(x,x*i+0.2,'o','color',c(i,:),'LineWidth',2)
+%     hold on
+end
+legend(names,'location','northwest')
+
+
+subplot(2,3,2)
+for i = 1:N
+    plot(x,x*i,'color',c2(i,:),'LineWidth',4)
+    hold on
+%     plot(x,x*i+0.2,'o','color',c2(i,:),'LineWidth',2)
+%     hold on
+end
+legend(names,'location','northwest')
+
+subplot(2,3,3)
+for i = 1:N
+    plot(x,x*i,'color',c4(i,:),'LineWidth',4)
+    hold on
+%     plot(x,x*i+0.2,'o','color',c2(i,:),'LineWidth',2)
+%     hold on
+end
+legend(names,'location','northwest')
+
+
+simtime = [0,0.00100000000000000,0.00200000000000000,0.00300000000000000,0.00400000000000000,0.00500000000000000,0.00600000000000000,0.00700000000000000,0.00800000000000000,0.00900000000000000,0.0100000000000000,0.0110000000000000,0.0120000000000000,0.0130000000000000,0.0140000000000000,0.0150000000000000,0.0160000000000000,0.0170000000000000,0.0180000000000000,0.0190000000000000,0.0200000000000000,0.0210000000000000,0.0220000000000000,0.0230000000000000,0.0240000000000000,0.0250000000000000,0.0260000000000000,0.0270000000000000,0.0280000000000000,0.0290000000000000,0.0300000000000000,0.0310000000000000,0.0320000000000000,0.0330000000000000,0.0340000000000000,0.0350000000000000,0.0360000000000000,0.0370000000000000,0.0380000000000000,0.0390000000000000,0.0400000000000000,0.0410000000000000,0.0420000000000000,0.0430000000000000,0.0440000000000000,0.0450000000000000,0.0460000000000000,0.0470000000000000,0.0480000000000000,0.0490000000000000,0.0500000000000000,0.0510000000000000,0.0520000000000000,0.0530000000000000,0.0540000000000000,0.0550000000000000,0.0560000000000000,0.0570000000000000,0.0580000000000000,0.0590000000000000,0.0600000000000000,0.0610000000000000,0.0620000000000000,0.0630000000000000,0.0640000000000000,0.0650000000000000,0.0660000000000000,0.0670000000000000,0.0680000000000000,0.0690000000000000,0.0700000000000000,0.0710000000000000,0.0720000000000000,0.0730000000000000,0.0740000000000000,0.0750000000000000,0.0760000000000000,0.0770000000000000,0.0780000000000000,0.0790000000000000,0.0800000000000000,0.0810000000000000,0.0820000000000000,0.0830000000000000,0.0840000000000000,0.0850000000000000,0.0860000000000000,0.0870000000000000,0.0880000000000000,0.0890000000000000,0.0900000000000000,0.0910000000000000,0.0920000000000000,0.0930000000000000,0.0940000000000000,0.0950000000000000,0.0960000000000000,0.0970000000000000,0.0980000000000000,0.0990000000000000,0.100000000000000,0.101000000000000,0.102000000000000,0.103000000000000,0.104000000000000,0.105000000000000,0.106000000000000,0.107000000000000,0.108000000000000,0.109000000000000,0.110000000000000,0.111000000000000,0.112000000000000,0.113000000000000,0.114000000000000,0.115000000000000,0.116000000000000,0.117000000000000,0.118000000000000,0.119000000000000,0.120000000000000,0.121000000000000,0.122000000000000,0.123000000000000,0.124000000000000,0.125000000000000,0.126000000000000,0.127000000000000,0.128000000000000,0.129000000000000,0.130000000000000,0.131000000000000,0.132000000000000,0.133000000000000,0.134000000000000,0.135000000000000,0.136000000000000,0.137000000000000,0.138000000000000,0.139000000000000,0.140000000000000,0.141000000000000,0.142000000000000,0.143000000000000,0.144000000000000,0.145000000000000,0.146000000000000,0.147000000000000,0.148000000000000,0.149000000000000,0.150000000000000,0.151000000000000,0.152000000000000,0.153000000000000,0.154000000000000,0.155000000000000,0.156000000000000,0.157000000000000,0.158000000000000,0.159000000000000,0.160000000000000,0.161000000000000,0.162000000000000,0.163000000000000,0.164000000000000,0.165000000000000,0.166000000000000,0.167000000000000,0.168000000000000,0.169000000000000,0.170000000000000,0.171000000000000,0.172000000000000,0.173000000000000,0.174000000000000,0.175000000000000,0.176000000000000,0.177000000000000,0.178000000000000,0.179000000000000,0.180000000000000,0.181000000000000,0.182000000000000,0.183000000000000,0.184000000000000,0.185000000000000,0.186000000000000,0.187000000000000,0.188000000000000,0.189000000000000,0.190000000000000,0.191000000000000,0.192000000000000,0.193000000000000,0.194000000000000,0.195000000000000,0.196000000000000,0.197000000000000,0.198000000000000,0.199000000000000,0.200000000000000,0.201000000000000,0.202000000000000,0.203000000000000,0.204000000000000,0.205000000000000,0.206000000000000,0.207000000000000,0.208000000000000,0.209000000000000,0.210000000000000,0.211000000000000,0.212000000000000,0.213000000000000,0.214000000000000,0.215000000000000,0.216000000000000,0.217000000000000,0.218000000000000,0.219000000000000,0.220000000000000,0.221000000000000,0.222000000000000,0.223000000000000,0.224000000000000,0.225000000000000,0.226000000000000,0.227000000000000,0.228000000000000,0.229000000000000,0.230000000000000,0.231000000000000,0.232000000000000,0.233000000000000,0.234000000000000,0.235000000000000,0.236000000000000,0.237000000000000,0.238000000000000,0.239000000000000,0.240000000000000,0.241000000000000,0.242000000000000,0.243000000000000,0.244000000000000,0.245000000000000,0.246000000000000,0.247000000000000,0.248000000000000,0.249000000000000,0.250000000000000,0.251000000000000,0.252000000000000,0.253000000000000,0.254000000000000,0.255000000000000,0.256000000000000,0.257000000000000,0.258000000000000,0.259000000000000,0.260000000000000,0.261000000000000,0.262000000000000,0.263000000000000,0.264000000000000,0.265000000000000,0.266000000000000,0.267000000000000,0.268000000000000,0.269000000000000,0.270000000000000,0.271000000000000,0.272000000000000,0.273000000000000,0.274000000000000,0.275000000000000,0.276000000000000,0.277000000000000,0.278000000000000,0.279000000000000,0.280000000000000,0.281000000000000,0.282000000000000,0.283000000000000,0.284000000000000,0.285000000000000,0.286000000000000,0.287000000000000,0.288000000000000,0.289000000000000,0.290000000000000,0.291000000000000,0.292000000000000,0.293000000000000,0.294000000000000,0.295000000000000,0.296000000000000,0.297000000000000,0.298000000000000,0.299000000000000,0.300000000000000,0.301000000000000,0.302000000000000,0.303000000000000,0.304000000000000,0.305000000000000,0.306000000000000,0.307000000000000,0.308000000000000,0.309000000000000,0.310000000000000,0.311000000000000,0.312000000000000,0.313000000000000,0.314000000000000,0.315000000000000,0.316000000000000,0.317000000000000,0.318000000000000,0.319000000000000,0.320000000000000,0.321000000000000,0.322000000000000,0.323000000000000,0.324000000000000,0.325000000000000,0.326000000000000,0.327000000000000,0.328000000000000,0.329000000000000,0.330000000000000,0.331000000000000,0.332000000000000,0.333000000000000,0.334000000000000,0.335000000000000,0.336000000000000,0.337000000000000,0.338000000000000,0.339000000000000,0.340000000000000,0.341000000000000,0.342000000000000,0.343000000000000,0.344000000000000,0.345000000000000,0.346000000000000,0.347000000000000,0.348000000000000,0.349000000000000,0.350000000000000,0.351000000000000,0.352000000000000,0.353000000000000,0.354000000000000,0.355000000000000,0.356000000000000,0.357000000000000,0.358000000000000,0.359000000000000,0.360000000000000,0.361000000000000,0.362000000000000,0.363000000000000,0.364000000000000,0.365000000000000,0.366000000000000,0.367000000000000,0.368000000000000,0.369000000000000,0.370000000000000,0.371000000000000,0.372000000000000,0.373000000000000,0.374000000000000,0.375000000000000,0.376000000000000,0.377000000000000,0.378000000000000,0.379000000000000,0.380000000000000,0.381000000000000,0.382000000000000,0.383000000000000,0.384000000000000,0.385000000000000,0.386000000000000,0.387000000000000,0.388000000000000,0.389000000000000,0.390000000000000,0.391000000000000,0.392000000000000,0.393000000000000,0.394000000000000,0.395000000000000,0.396000000000000,0.397000000000000,0.398000000000000,0.399000000000000,0.400000000000000,0.401000000000000,0.402000000000000,0.403000000000000,0.404000000000000,0.405000000000000,0.406000000000000,0.407000000000000,0.408000000000000,0.409000000000000,0.410000000000000,0.411000000000000,0.412000000000000,0.413000000000000,0.414000000000000,0.415000000000000,0.416000000000000,0.417000000000000,0.418000000000000,0.419000000000000,0.420000000000000,0.421000000000000,0.422000000000000,0.423000000000000,0.424000000000000,0.425000000000000,0.426000000000000,0.427000000000000,0.428000000000000,0.429000000000000,0.430000000000000,0.431000000000000,0.432000000000000,0.433000000000000,0.434000000000000,0.435000000000000,0.436000000000000,0.437000000000000,0.438000000000000,0.439000000000000,0.440000000000000,0.441000000000000,0.442000000000000,0.443000000000000,0.444000000000000,0.445000000000000,0.446000000000000,0.447000000000000,0.448000000000000,0.449000000000000,0.450000000000000,0.451000000000000,0.452000000000000,0.453000000000000,0.454000000000000,0.455000000000000,0.456000000000000,0.457000000000000,0.458000000000000,0.459000000000000,0.460000000000000,0.461000000000000,0.462000000000000,0.463000000000000,0.464000000000000,0.465000000000000,0.466000000000000,0.467000000000000,0.468000000000000,0.469000000000000,0.470000000000000,0.471000000000000,0.472000000000000,0.473000000000000,0.474000000000000,0.475000000000000,0.476000000000000,0.477000000000000,0.478000000000000,0.479000000000000,0.480000000000000,0.481000000000000,0.482000000000000,0.483000000000000,0.484000000000000,0.485000000000000,0.486000000000000,0.487000000000000,0.488000000000000,0.489000000000000,0.490000000000000,0.491000000000000,0.492000000000000,0.493000000000000,0.494000000000000,0.495000000000000,0.496000000000000,0.497000000000000,0.498000000000000,0.499000000000000,0.500000000000000,0.501000000000000,0.502000000000000,0.503000000000000,0.504000000000000,0.505000000000000,0.506000000000000,0.507000000000000,0.508000000000000,0.509000000000000,0.510000000000000,0.511000000000000,0.512000000000000,0.513000000000000,0.514000000000000,0.515000000000000,0.516000000000000,0.517000000000000,0.518000000000000,0.519000000000000,0.520000000000000,0.521000000000000,0.522000000000000,0.523000000000000,0.524000000000000,0.525000000000000,0.526000000000000,0.527000000000000,0.528000000000000,0.529000000000000,0.530000000000000,0.531000000000000,0.532000000000000,0.533000000000000,0.534000000000000,0.535000000000000,0.536000000000000,0.537000000000000,0.538000000000000,0.539000000000000,0.540000000000000,0.541000000000000,0.542000000000000,0.543000000000000,0.544000000000000,0.545000000000000,0.546000000000000,0.547000000000000,0.548000000000000,0.549000000000000,0.550000000000000,0.551000000000000,0.552000000000000,0.553000000000000,0.554000000000000,0.555000000000000,0.556000000000000,0.557000000000000,0.558000000000000,0.559000000000000,0.560000000000000,0.561000000000000,0.562000000000000,0.563000000000000,0.564000000000000,0.565000000000000,0.566000000000000,0.567000000000000,0.568000000000000,0.569000000000000,0.570000000000000,0.571000000000000,0.572000000000000,0.573000000000000,0.574000000000000,0.575000000000000,0.576000000000000,0.577000000000000,0.578000000000000,0.579000000000000,0.580000000000000,0.581000000000000,0.582000000000000,0.583000000000000,0.584000000000000,0.585000000000000,0.586000000000000,0.587000000000000,0.588000000000000,0.589000000000000,0.590000000000000,0.591000000000000,0.592000000000000,0.593000000000000,0.594000000000000,0.595000000000000,0.596000000000000,0.597000000000000,0.598000000000000,0.599000000000000,0.600000000000000,0.601000000000000,0.602000000000000,0.603000000000000,0.604000000000000,0.605000000000000,0.606000000000000,0.607000000000000,0.608000000000000,0.609000000000000,0.610000000000000,0.611000000000000,0.612000000000000,0.613000000000000,0.614000000000000,0.615000000000000,0.616000000000000,0.617000000000000,0.618000000000000,0.619000000000000,0.620000000000000,0.621000000000000,0.622000000000000,0.623000000000000,0.624000000000000,0.625000000000000,0.626000000000000,0.627000000000000,0.628000000000000,0.629000000000000,0.630000000000000,0.631000000000000,0.632000000000000,0.633000000000000,0.634000000000000,0.635000000000000,0.636000000000000,0.637000000000000,0.638000000000000,0.639000000000000,0.640000000000000,0.641000000000000,0.642000000000000,0.643000000000000,0.644000000000000,0.645000000000000,0.646000000000000,0.647000000000000,0.648000000000000,0.649000000000000,0.650000000000000,0.651000000000000,0.652000000000000,0.653000000000000,0.654000000000000,0.655000000000000,0.656000000000000,0.657000000000000,0.658000000000000,0.659000000000000,0.660000000000000,0.661000000000000,0.662000000000000,0.663000000000000,0.664000000000000,0.665000000000000,0.666000000000000,0.667000000000000,0.668000000000000,0.669000000000000,0.670000000000000,0.671000000000000,0.672000000000000,0.673000000000000,0.674000000000000,0.675000000000000,0.676000000000000,0.677000000000000,0.678000000000000,0.679000000000000,0.680000000000000,0.681000000000000,0.682000000000000,0.683000000000000,0.684000000000000,0.685000000000000,0.686000000000000,0.687000000000000,0.688000000000000,0.689000000000000,0.690000000000000,0.691000000000000,0.692000000000000,0.693000000000000,0.694000000000000,0.695000000000000,0.696000000000000,0.697000000000000,0.698000000000000,0.699000000000000,0.700000000000000,0.701000000000000,0.702000000000000,0.703000000000000,0.704000000000000,0.705000000000000,0.706000000000000,0.707000000000000,0.708000000000000,0.709000000000000,0.710000000000000,0.711000000000000,0.712000000000000,0.713000000000000,0.714000000000000,0.715000000000000,0.716000000000000,0.717000000000000,0.718000000000000,0.719000000000000,0.720000000000000,0.721000000000000,0.722000000000000,0.723000000000000,0.724000000000000,0.725000000000000,0.726000000000000,0.727000000000000,0.728000000000000,0.729000000000000,0.730000000000000,0.731000000000000,0.732000000000000,0.733000000000000,0.734000000000000,0.735000000000000,0.736000000000000,0.737000000000000,0.738000000000000,0.739000000000000,0.740000000000000,0.741000000000000,0.742000000000000,0.743000000000000,0.744000000000000,0.745000000000000,0.746000000000000,0.747000000000000,0.748000000000000,0.749000000000000,0.750000000000000,0.751000000000000,0.752000000000000,0.753000000000000,0.754000000000000,0.755000000000000,0.756000000000000,0.757000000000000,0.758000000000000,0.759000000000000,0.760000000000000,0.761000000000000,0.762000000000000,0.763000000000000,0.764000000000000,0.765000000000000,0.766000000000000,0.767000000000000,0.768000000000000,0.769000000000000,0.770000000000000,0.771000000000000,0.772000000000000,0.773000000000000,0.774000000000000];
+Q_MV = [-6.97151914942784e-07,-7.08682527368761e-07,-7.19914303289674e-07,-7.30822279513001e-07,-7.41397767271705e-07,-7.51647874497661e-07,-7.61593685428622e-07,-7.71267382742501e-07,-7.80708676916502e-07,-7.89960928064968e-07,-7.99067338239898e-07,-8.08067521482488e-07,-8.16994691118727e-07,-8.25873618989572e-07,-8.34719444792606e-07,-8.43537337288234e-07,-8.52322956248251e-07,-8.61063608346682e-07,-8.69739957744223e-07,-8.78328116239525e-07,-8.86801927575183e-07,-8.95135251621221e-07,-9.03304063904042e-07,-9.11288224635275e-07,-9.19072776691355e-07,-9.26648714003301e-07,-9.34013207780192e-07,-9.41169244095433e-07,-9.48124915727501e-07,-9.54892275992926e-07,-9.61486004375963e-07,-9.67921995190139e-07,-9.74215977611901e-07,-9.80382295139744e-07,-9.86432912475215e-07,-9.92376724816253e-07,-9.98219179983663e-07,-1.00396221998184e-06,-1.00960451284755e-06,-1.01514192499276e-06,-1.02056818387618e-06,-1.02587564113680e-06,-1.03105607862233e-06,-1.03610149817687e-06,-1.04100480328863e-06,-1.04576035079368e-06,-1.05036433197582e-06,-1.05481496726433e-06,-1.05911252126110e-06,-1.06325914972256e-06,-1.06725860803085e-06,-1.07111586136112e-06,-1.07483664636443e-06,-1.07842700522581e-06,-1.08189285676452e-06,-1.08523961854989e-06,-1.08847191121029e-06,-1.09159337205276e-06,-1.09460655793612e-06,-1.09751295901069e-06,-1.10031308845428e-06,-1.10300665318186e-06,-1.10559277027239e-06,-1.10807021877307e-06,-1.11043767404764e-06,-1.11269394914799e-06,-1.11483819298964e-06,-1.11687003606550e-06,-1.11878968944336e-06,-1.12059798296331e-06,-1.12229635176376e-06,-1.12388677706598e-06,-1.12537168672372e-06,-1.12675383407645e-06,-1.12803616195653e-06,-1.12922167442776e-06,-1.13031330445729e-06,-1.13131381242988e-06,-1.13222571230057e-06,-1.13305122184142e-06,-1.13379224628573e-06,-1.13445038675293e-06,-1.13502697702078e-06,-1.13552313426234e-06,-1.13593982666469e-06,-1.13627794198132e-06,-1.13653835767539e-06,-1.13672200243180e-06,-1.13682990865105e-06,-1.13686324941896e-06,-1.13682335800408e-06,-1.13671173662483e-06,-1.13653004066902e-06,-1.13628006804896e-06,-1.13596371697193e-06,-1.13558295712502e-06,-1.13513979303681e-06,-1.13463621571836e-06,-1.13407418246560e-06,-1.13345558260537e-06,-1.13278222139861e-06,-1.13205580725703e-06,-1.13127795389515e-06,-1.13045017703075e-06,-1.12957391450938e-06,-1.12865053828401e-06,-1.12768137087236e-06,-1.12666770808931e-06,-1.12561083518586e-06,-1.12451202437725e-06,-1.12337264072858e-06,-1.12219396721068e-06,-1.12097738796580e-06,-1.11972430093056e-06,-1.11843612915523e-06,-1.11711431537790e-06,-1.11576031284195e-06,-1.11437557411747e-06,-1.11296154051818e-06,-1.11151963171416e-06,-1.11005123981519e-06,-1.10855771822906e-06,-1.10704038062306e-06,-1.10550049827835e-06,-1.10393929956465e-06,-1.10235797271010e-06,-1.10075766847763e-06,-1.09913950678001e-06,-1.09750458212137e-06,-1.09585395876803e-06,-1.09418869395309e-06,-1.09250982670352e-06,-1.09081838775229e-06,-1.08911539870385e-06,-1.08740187395061e-06,-1.08567881926010e-06,-1.08394723150579e-06,-1.08220809488207e-06,-1.08046237980503e-06,-1.07871103852705e-06,-1.07695500328880e-06,-1.07519518385566e-06,-1.07343246197409e-06,-1.07166769724118e-06,-1.06990172390727e-06,-1.06813534500239e-06,-1.06636933957385e-06,-1.06460446240601e-06,-1.06284143985039e-06,-1.06108097342536e-06,-1.05932374512608e-06,-1.05757042046201e-06,-1.05582164204511e-06,-1.05407803772555e-06,-1.05234021863698e-06,-1.05060877925015e-06,-1.04888430144839e-06,-1.04716734660308e-06,-1.04545846292140e-06,-1.04375817964145e-06,-1.04206701102894e-06,-1.04038545187044e-06,-1.03871397831021e-06,-1.03705304791355e-06,-1.03540309849389e-06,-1.03376454813664e-06,-1.03213779584046e-06,-1.03052322124460e-06,-1.02892118521063e-06,-1.02733203030216e-06,-1.02575608143727e-06,-1.02419364656136e-06,-1.02264501730339e-06,-1.02111046958628e-06,-1.01959026416946e-06,-1.01808464710340e-06,-1.01659385008345e-06,-1.01511809068819e-06,-1.01365757256120e-06,-1.01221248545206e-06,-1.01078300526563e-06,-1.00936929399147e-06,-1.00797149959490e-06,-1.00658975606344e-06,-1.00522418333440e-06,-1.00387488731169e-06,-1.00254195985826e-06,-1.00122547892453e-06,-9.99925508626568e-07,-9.98642099395700e-07,-9.97375288137951e-07,-9.96125098395398e-07,-9.94891540493555e-07,-9.93674611658872e-07,-9.92474296091152e-07,-9.91290564977005e-07,-9.90123376435208e-07,-9.88972675311931e-07,-9.87838393115095e-07,-9.86720447640899e-07,-9.85618742407617e-07,-9.84533166314831e-07,-9.83463593025392e-07,-9.82409880084465e-07,-9.81371868297608e-07,-9.80349380781213e-07,-9.79342221733775e-07,-9.78350175416193e-07,-9.77373004734955e-07,-9.76410449742164e-07,-9.75462225930444e-07,-9.74528022311911e-07,-9.73607499252541e-07,-9.72700286029874e-07,-9.71805978079266e-07,-9.70924133891551e-07,-9.70054271522150e-07,-9.69195864668561e-07,-9.68348338269770e-07,-9.67511063577635e-07,-9.66683352646428e-07,-9.65864452182293e-07,-9.65053536689201e-07,-9.64249700842312e-07,-9.63451951013210e-07,-9.62659195864506e-07,-9.61870235923616e-07,-9.61083752037267e-07,-9.60298292599502e-07,-9.59512259436712e-07,-9.58723892223767e-07,-9.57931251295512e-07,-9.57132198708198e-07,-9.56324377395761e-07,-9.55505188256621e-07,-9.54671764998055e-07,-9.53820946557582e-07,-9.52949246914538e-07,-9.52052822100717e-07,-9.51127434217196e-07,-9.50168412266085e-07,-9.49170609611899e-07,-9.48128357851656e-07,-9.47035417038604e-07,-9.45884922374327e-07,-9.44669326154086e-07,-9.43380336760026e-07,-9.42008852920383e-07,-9.40544894810979e-07,-9.38977530807147e-07,-9.37294800857295e-07,-9.35483639254793e-07,-9.33529795367107e-07,-9.31417752269997e-07,-9.29130618273167e-07,-9.26650112305105e-07,-9.23956419840841e-07,-9.21028158263562e-07,-9.17842309381821e-07,-9.14374172388219e-07,-9.10597331053189e-07,-9.06483646959142e-07,-9.02003278219136e-07,-8.97124724108041e-07,-8.91814933259209e-07,-8.86039408195856e-07,-8.79762428662765e-07,-8.72947288498699e-07,-8.65543986419896e-07,-8.57401381093125e-07,-8.48449840577665e-07,-8.38646947126779e-07,-8.27952784056274e-07,-8.16330942456040e-07,-8.03749627663881e-07,-7.90182828506095e-07,-7.75611533529303e-07,-7.60024952142739e-07,-7.43421697607605e-07,-7.25810880491610e-07,-7.07213055918100e-07,-6.87660967873614e-07,-6.67200027421483e-07,-6.45888482411524e-07,-6.23797227041590e-07,-6.01009229194227e-07,-5.77618564092902e-07,-5.53729065444892e-07,-5.29452627388685e-07,-5.04907211486836e-07,-4.80214631828207e-07,-4.55498205803110e-07,-4.30880365558978e-07,-4.06480328963506e-07,-3.82411921404057e-07,-3.58781630616255e-07,-3.35686959469682e-07,-3.13215122750708e-07,-2.91442112276296e-07,-2.70432134839191e-07,-2.50237408086254e-07,-2.30898284176786e-07,-2.12443659276007e-07,-1.94891619421089e-07,-1.78250269796909e-07,-1.62518694523515e-07,-1.47687997022707e-07,-1.33742376249062e-07,-1.20660199628729e-07,-1.08415043199793e-07,-9.69766738711515e-08,-8.63119521573601e-08,-7.63856576780864e-08,-6.71612118797069e-08,-5.86013141754816e-08,-5.06684835301275e-08,-4.33255130652945e-08,-3.65358434413120e-08,-3.02638622961426e-08,-2.44751376078400e-08,-1.91365931757451e-08,-1.42166331799384e-08,-9.68522493190623e-09,-5.51394475503157e-09,-1.67599477430334e-09,0.0853869272329554,0.681940827456608,1.80693970398334,3.41518027636022,5.46483427608725,7.91722174984223,10.7365940224859,13.8899236212084,17.3467072439259,21.0787761429690,25.0601205521120,29.2667214334891,33.6764014152407,38.2686698149639,43.0245960719052,47.9266826552144,52.9587489710463,58.1058255889870,63.3540563627238,68.6906046649208,74.1035746761408,79.5819329206992,85.1154340088148,90.6945624220435,96.3104685659822,101.954918372617,107.620240264349,113.299282975993,118.985370636803,124.672268319216,130.354144254859,136.025540952446,141.681343707272,147.316756518700,152.927275822574,158.508670411333,164.056959538219,169.568396182540,175.039448801877,180.466787386282,185.847268251159,191.177922414388,196.455942920874,201.678675152691,206.843606259771,211.948357077446,216.990673308128,221.968418774715,226.879567815130,231.722201053087,236.494496005107,241.194726331831,245.821253465395,250.372524867744,254.847068712446,259.243490057799,263.560469099146,267.796756079629,271.951167711575,276.022590790646,280.009971008499,283.912316551411,287.728695099168,291.458230989942,295.100104057447,298.653547739556,302.117847862293,305.492341373641,308.776414889747,311.969503429735,315.071089343958,318.080701316801,320.997913399642,323.822344082095,326.553655415244,329.191552187512,331.735781145499,334.186130251995,336.542427976296,338.804542613760,340.972381631920,343.045891040305,345.025054781110,346.909894138138,348.700467161722,350.396868107622,351.999226887951,353.507708532570,354.922512659358,356.243872951940,357.472056643632,358.607364006466,359.650127844285,360.600712988977,361.459515799035,362.226963659684,362.903514483943,363.489656214008,363.985906322468,364.392811312874,364.710946219277,364.940914177657,365.083345733677,365.138898430336,365.108256461389,364.992129899127,364.791254368432,364.506390454568,364.138323195094,363.687861576832,363.155837976475,362.543107698894,361.850548341853,361.079059596976,360.229562151285,359.302997235040,358.300326714336,357.222532259126,356.070614301977,354.845594191092,353.548508190709,352.180406427928,350.742362665977,349.235465836584,347.660819549055,346.019542954553,344.312770525754,342.541649612236,340.707341802287,338.811021789954,336.853876649844,334.837105435748,332.761918497993,330.629536939637,328.441192126314,326.198125163995,323.901586290095,321.552834286168,319.153135925621,316.703765432095,314.206003932741,311.661138906297,309.070463631350,306.435276637945,303.756881162757,301.036584607069,298.275697997272,295.475535448082,292.637413628863,289.762651233312,286.852568452696,283.908486452789,280.931726854685,277.923611219651,274.885460538227,271.818594723735,268.724332110369,265.603988956046,262.458878950163,259.290312726450,256.099597381058,252.888035996045,249.656927168417,246.407564544877,243.141236362416,239.859225015667,236.562806588404,233.253250379939,229.931818491822,226.599765421986,223.258337648576,219.908773204573,216.552301260619,213.190141724041,209.823504850118,206.453590857930,203.081589549794,199.708679937870,196.336029880050,192.964795724347,189.596121960453,186.231140878414,182.870972235144,179.516722929210,176.169486683750,172.830343737364,169.500360543024,166.180589475162,162.872068545070,159.575821124620,156.292855678298,153.024165503602,149.770728479862,146.533506825523,143.313446863924,140.111478797580,136.928516490992,133.765457262017,130.623181681810,127.502553383335,124.404418878470,121.329607383704,118.278930654417,115.253182814758,112.253140241183,109.279561407694,106.333186742098,103.414738505602,100.524920684688,97.6644188869204,94.8339002417871,92.0340133102912,89.2653880009157,86.5286355059822,83.8243482350705,81.1530997562119,78.5154447480063,75.9119189612618,73.3430391884942,70.8093032408624,68.3111899328249,65.8491590747723,63.4236514736300,61.0350889412951,58.6838743107785,56.3703914599688,54.0950053429557,51.8580620288417,49.6598887479610,47.5007939454178,45.3808788849657,43.3006921686417,41.2610122666827,39.2627365032034,37.3069349466055,35.3948210149601,33.5277416528983,31.7071698363709,29.9346903306446,28.2119920026926,26.5408641348201,24.9231824417418,23.3609045917600,21.8560672357923,20.4107757681330,19.0271861395074,17.7075101489016,16.4540022807679,15.2689468531983,14.1546527009524,13.1134431597024,12.1476449515967,11.2595794133859,10.4515529557486,9.72584513342661,9.08469937661671,8.53031275011021,8.06482495527236,7.69030908601125,7.40876105729286,7.22208994184202,7.13210837008220,7.14052381475893,7.24892878412284,7.45879303121503,7.77145562127944,8.18811730973451,8.70983377324866,9.33750915358686,10.0718906431551,10.9135631550003,11.8629453972292,12.9202851561292,14.0856574087773,15.3589611272335,16.7399179966001,18.2280704394155,19.8227825194551,21.5232397089318,23.3284479981096,25.2372382095191,27.2482647363138,29.3600107804243,31.5707901546185,33.8787493447356,36.2818727092632,38.7779870167005,41.3647641107442,44.0397274187437,46.8002578069199,49.6435957068393,52.5668482515154,55.5669969280392,58.6409015086358,61.7853060420495,64.9968434600006,68.2720461559857,71.6073469479494,74.9990915660949,78.4435381313851,81.9368677694311,85.4751873936497,89.0545409514093,92.6709095844342,96.3202224393985,99.9983589364044,103.701157575764,107.424418957968,111.163913149864,114.915384436499,118.674557195635,122.437140701896,126.198834571480,129.955333514095,133.702332707254,137.435532163165,141.150641447971,144.843384642297,148.509503795794,152.144764197827,155.744958035977,159.305910456551,162.823482404942,166.293572994022,169.712123860688,173.075124141561,176.378614453157,179.618690029631,182.791503937047,185.893270681588,188.920269883179,191.868849717414,194.735430168372,197.516506262317,200.208651334913,202.808520270720,205.312852664731,207.718475917037,210.022308291454,212.221361945614,214.312745919680,216.293669073230,218.161442970473,219.913484716350,221.547319741042,223.060584526217,224.451029266398,225.716520460109,226.855043425253,227.864704731651,228.743734542446,229.490488855629,230.103451636797,230.581236833794,230.922590263367,231.126391359538,231.191654773185,231.117531812297,230.903311712344,230.548422726286,230.052433023973,229.415051391001,228.636127717627,227.715653268933,226.653760728189,225.450724006169,224.106957810189,222.623016967722,220.999595500606,219.237525447171,217.337775430915,215.301448975812,213.129782569748,210.824143479093,208.386027318876,205.817055384539,203.118971752655,200.293640159437,197.343040667174,194.269266129997,191.074518471545,187.761104788122,184.331433291895,180.788009109454,177.133429951699,173.370381671563,169.501633726368,165.530034561891,161.458506935194,157.290043193260,153.027700524157,148.674596197177,144.233902807815,139.708843542951,135.102687480784,130.418744939377,125.660362886597,120.830920424120,115.933824355414,110.972504848372,105.950411201779,100.871007723338,95.7377697259914,90.5541796484461,85.3237233048381,80.0498862674549,74.7361503853898,69.3859904411842,63.4486916671579,53.4738209939056,39.3599073116361,21.4024233650985,-1.36799344338260e-07,-1.57321708563208e-07,-1.77239708380810e-07,-1.96632478849586e-07,-2.15558053794481e-07,-2.34061017066922e-07,-2.52176827451287e-07,-2.69934465873410e-07,-2.87358139506566e-07,-3.04468431755920e-07,-3.21283106611408e-07,-3.37817688509111e-07,-3.54085891165467e-07,-3.70099941967934e-07,-3.85870830504880e-07,-4.01408506559656e-07,-4.16722033184078e-07,-4.31819713090900e-07,-4.46709190414264e-07,-4.61397534690192e-07,-4.75891310651550e-07,-4.90196636799261e-07,-5.04319234801674e-07,-5.18264471631233e-07,-5.32037395711662e-07,-5.45642767954492e-07,-5.59085088800420e-07,-5.72368621749944e-07,-5.85497413995878e-07,-5.98475314580295e-07,-6.11305990459438e-07,-6.23992940752165e-07,-6.36539509463031e-07,-6.48948896852505e-07,-6.61224169645078e-07,-6.73368129433641e-07,-6.85363052068535e-07,-6.97152330291881e-07];
+Q_AV = [28.0913443268302,54.8319096711077,86.4097805610145,119.858843950558,152.388678024766,181.599657324373,205.641685490651,223.306488308558,234.052598983338,237.969594150090,235.694404705324,228.294338109162,217.131703243028,203.723538504166,189.607455117647,176.222075161445,164.808167784925,156.334635753583,151.451780811636,150.472451761299,153.380346344138,159.862760261099,169.363481462701,181.150733152847,194.392786255416,208.234869772545,221.870522695813,234.601463236199,245.882015299069,255.346560869880,262.818333578135,268.301935069685,271.961738897149,274.090083443623,275.068613228332,275.327271070899,275.304093314269,275.409057462120,275.994146606378,277.331454475333,279.600035009736,282.881288687151,287.162997661660,292.350213358313,298.281742980175,304.750216312662,311.523731090616,318.367126197744,325.061223731869,331.418552257809,337.294828073470,342.595465437131,347.277322102353,351.346111263894,354.850066225414,357.870891335474,360.513018217469,362.892438760561,365.125773434952,367.320690022047,369.568081926268,371.936497475382,374.469131227181,377.183160002448,380.071299703833,383.105137359576,386.239914082947,389.419958137182,392.584521620271,395.673222723483,398.630902293778,401.411513952635,403.980785957671,406.317580356067,408.414074572805,410.274867245422,411.915121107449,413.358005696395,414.631944483153,415.767656011612,416.795458317060,417.742812092496,418.632512396747,419.481380333744,420.299698698788,421.091164416407,421.853458747216,422.579198210663,423.257226029745,423.874035726427,424.415221370181,424.866899050086,425.216796473341,425.455183714129,425.575456392657,425.574384242694,425.452072130626,425.211651232864,424.858755945938,424.400846456058,423.846503879513,423.204685879483,422.484044989848,421.692373563241,420.836162562135,419.920376058463,418.948260932962,417.921476160233,416.840220956636,415.703476484967,414.509496145050,413.255976160192,411.940526521382,410.560995346810,409.115703910090,407.603684956196,406.024774511805,404.379657470770,402.669871946289,400.897639007130,399.065765740326,397.177443952748,395.236074998494,393.245084586140,391.207743260025,389.127057397103,387.005652648438,384.845751765822,382.649134699906,380.417137903277,378.150786382719,375.850796462541,373.517711975124,371.151966926596,368.754002398551,366.324332602864,363.863599106223,361.372641788956,358.852491389362,356.304395569451,353.729784727851,351.130242784231,348.507476485866,345.863239789613,343.199305430118,340.517424220429,337.819282979400,335.106490706319,332.380506371160,329.642653789106,326.894124866703,324.136017621476,321.369294185927,318.594856730786,315.813552156003,313.026196909320,310.233604046553,307.436594788060,304.636024801699,301.832785250089,299.027807885681,296.222061513890,293.416546704377,290.612283726744,287.810301212800,285.011621226467,282.217247248072,279.428154037845,276.645275723810,273.869498252961,271.101656161906,268.342532358381,265.592860272385,262.853328080779,260.124584594559,257.407246176612,254.701903964935,252.009130414566,249.329485677675,246.663522721114,244.011790012396,241.374832499568,238.753191360363,236.147402558331,233.557994541332,230.985485089160,228.430377555374,225.893156950062,223.374286320968,220.874203740366,218.393320056238,215.932017469964,213.490648940389,211.069538356728,208.668981363310,206.289246668000,203.930577561248,201.593193609767,199.277292378539,196.983050654370,194.710625162895,192.460152752016,190.231750066922,188.025512685292,185.841513698667,183.679801784521,181.540398783677,179.423296992503,177.328456247490,175.255800819776,173.205216159097,171.176545543021,169.169586654976,167.184088062239,165.219745530316,163.276198096028,161.353023811019,159.449735052226,157.565773282026,155.700503135375,153.853205713639,152.023070970260,150.209189078846,148.410540679399,146.625985903563,144.854252083843,143.093920053092,141.343408938351,139.600959347211,137.864614835646,136.132201534236,134.401305795224,132.669249706896,130.933064305132,129.189460296078,127.434796089634,125.665042932147,123.875746919412,122.061987668950,120.218333434837,118.338792460339,116.416760384613,114.444963881084,112.415398317129,110.319264101268,108.146897963836,105.887697271437,103.530044812928,101.061226590381,98.4673507858944,95.7332600421769,92.8424393552914,89.7769409272876,86.5172935537880,83.0424261020488,79.3295983761936,75.3543374886164,71.0903948785462,66.5097214802739,61.5824726628986,56.2770457764465,50.5601473943604,44.3969286467099,37.7511718109192,30.5855652106314,22.8620297797119,14.5421695024674,5.58781499823122,-1.04393707685960e-08,-1.30110471661074e-08,-1.66175954509002e-08,-2.13075651457556e-08,-2.71260452064919e-08,-3.41136728827639e-08,-4.23055548443044e-08,-5.17301226336238e-08,-6.24079437124591e-08,-7.43505295693012e-08,-8.75591830760944e-08,-1.02023936801283e-07,-1.17722638954953e-07,-1.34620242558084e-07,-1.52668362785365e-07,-1.71805142980148e-07,-1.91955478791884e-07,-2.13031631421032e-07,-2.34934227947606e-07,-2.57553649096435e-07,-2.80771761468450e-07,-3.04463952353851e-07,-3.28501376803757e-07,-3.52753348129463e-07,-3.77089758220724e-07,-4.01383446062836e-07,-4.25512409240818e-07,-4.49361784002212e-07,-4.72825527098273e-07,-4.95807751288511e-07,-5.18223692833070e-07,-5.40000304909296e-07,-5.61076490730893e-07,-5.81403010839067e-07,-6.00942100077349e-07,-6.19666851166247e-07,-6.37560406496288e-07,-6.54615027688953e-07,-6.70831075199468e-07,-6.86215955560716e-07,-7.00783068493069e-07,-7.14550786092264e-07,-7.27541488717654e-07,-7.39780678832804e-07,-7.51296171226941e-07,-7.62117383003273e-07,-7.72274711547376e-07,-7.81799004197307e-07,-7.90721112058390e-07,-7.99071527500703e-07,-8.06880092066059e-07,-8.14175769324393e-07,-8.20986473685863e-07,-8.27338950595356e-07,-8.33258696632424e-07,-8.38769915382086e-07,-8.43895501411767e-07,-8.48657027917283e-07,-8.53074432279739e-07,-8.57166192431885e-07,-8.60949730589236e-07,-8.64441452092854e-07,-8.67656781660901e-07,-8.70610207874761e-07,-8.73315332933443e-07,-8.75784925962984e-07,-8.78030977693096e-07,-8.80064755494360e-07,-8.81896857494708e-07,-8.83537265495951e-07,-8.84995394664644e-07,-8.86280141811689e-07,-8.87399929116405e-07,-8.88362747682174e-07,-8.89176194547424e-07,-8.89847508043973e-07,-8.90383600624960e-07,-8.90791088113729e-07,-8.91076315901222e-07,-8.91245382012598e-07,-8.91304158961165e-07,-8.91258311684828e-07,-8.91113314563013e-07,-8.90874464877006e-07,-8.90546896025850e-07,-8.90135587295076e-07,-8.89645373824835e-07,-8.89080953381888e-07,-8.88446893577721e-07,-8.87747636293864e-07,-8.86987502708833e-07,-8.86170695872821e-07,-8.85301304037856e-07,-8.84383301841134e-07,-8.83420552346088e-07,-8.82416807227447e-07,-8.81375707874880e-07,-8.80300784909882e-07,-8.79195458646903e-07,-8.78063038216302e-07,-8.76906721626764e-07,-8.75729594718502e-07,-8.74534631025362e-07,-8.73324690738130e-07,-8.72102520524875e-07,-8.70870752506663e-07,-8.69631904987210e-07,-8.68388379867396e-07,-8.67142465190841e-07,-8.65896332803317e-07,-8.64652040118456e-07,-8.63411529485163e-07,-8.62176628625559e-07,-8.60949051517630e-07,-8.59730398760336e-07,-8.58522162830102e-07,-8.57325718536822e-07,-8.56142337532212e-07,-8.54973181820109e-07,-8.53819306582974e-07,-8.52681663766467e-07,-8.51561103376040e-07,-8.50458376199410e-07,-8.49374135694755e-07,-8.48308940741506e-07,-8.47263258424334e-07,-8.46237467019259e-07,-8.45231858936407e-07,-8.44246643769374e-07,-8.43281951480276e-07,-8.42337835692314e-07,-8.41414277058848e-07,-8.40511186692640e-07,-8.39628409647471e-07,-8.38765728444559e-07,-8.37922866633815e-07,-8.37099492378735e-07,-8.36295222053952e-07,-8.35509623845069e-07,-8.34742221340900e-07,-8.33992497108530e-07,-8.33259896241872e-07,-8.32543829874975e-07,-8.31843678649839e-07,-8.31158796134565e-07,-8.30488512178625e-07,-8.29832136201887e-07,-8.29188960408895e-07,-8.28558262922076e-07,-8.27939310827996e-07,-8.27331363130831e-07,-8.26733673608181e-07,-8.26145493564429e-07,-8.25566074477497e-07,-8.24994670535289e-07,-8.24430541058526e-07,-8.23872952807187e-07,-8.23321182168191e-07,-8.22774516942115e-07,-8.22232259056936e-07,-8.21693725930026e-07,-8.21158251645829e-07,-8.20625189445223e-07,-8.20093912529756e-07,-8.19563815658422e-07,-8.19034316325092e-07,-8.18504855740847e-07,-8.17974899980482e-07,-8.17443940570810e-07,-8.16911495473203e-07,-8.16377112162758e-07,-8.15840355711868e-07,-8.15300833041388e-07,-8.14758170299500e-07,-8.14212024017794e-07,-8.13662079402018e-07,-8.13108053163299e-07,-8.12549685620412e-07,-8.11986739224953e-07,-8.11419014852495e-07,-8.10846339040013e-07,-8.10268563551321e-07,-8.09685567207542e-07,-8.09097255780142e-07,-8.08503558360056e-07,-8.07904429779148e-07,-8.07299848987148e-07,-8.06689817966981e-07,-8.06074361171687e-07,-8.05453524465673e-07,-8.04827374240609e-07,-8.04195996600854e-07,-8.03559496474509e-07,-8.02917996547083e-07,-8.02271636205891e-07,-8.01620570526263e-07,-8.00964969263740e-07,-8.00305015828191e-07,-7.99640906241808e-07,-7.98972848092673e-07,-7.98301059492389e-07,-7.97625768041170e-07,-7.96947209801934e-07,-7.96265628285402e-07,-7.95581273448914e-07,-7.94894400711816e-07,-7.94205269990016e-07,-7.93514144751948e-07,-7.92821291098041e-07,-7.92126976865598e-07,-7.91431470760922e-07,-7.90735041520318e-07,-7.90037957101500e-07,-7.89340483906719e-07,-7.88642886038827e-07,-7.87945424591300e-07,-7.87248356973129e-07,-7.86551936269333e-07,-7.85856410637694e-07,-7.85162022742216e-07,-7.84469009223629e-07,-7.83777600207168e-07,-7.83088018868553e-07,-7.82400480991244e-07,-7.81715194555397e-07,-7.81032359419899e-07,-7.80352167039769e-07,-7.79674800198531e-07,-7.79000432760007e-07,-7.78329229456968e-07,-7.77661345728010e-07,-7.76996927591269e-07,-7.76336111545127e-07,-7.75679024497152e-07,-7.75025783724903e-07,-7.74376496868603e-07,-7.73731261952568e-07,-7.73090167432874e-07,-7.72453292270509e-07,-7.71820706029710e-07,-7.71192469000350e-07,-7.70568632342734e-07,-7.69949238253241e-07,-7.69334320149605e-07,-7.68723902874678e-07,-7.68118002917387e-07,-7.67516628649448e-07,-7.66919780576510e-07,-7.66327451602392e-07,-7.65739627305176e-07,-7.65156286223836e-07,-7.64577400154140e-07,-7.64002934452545e-07,-7.63432848346881e-07,-7.62867095252608e-07,-7.62305623093503e-07,-7.61748374625604e-07,-7.61195287763340e-07,-7.60646295906746e-07,-7.60101328268771e-07,-7.59560310228572e-07,-7.59023163591674e-07,-7.58489806939653e-07,-7.57960155972628e-07,-7.57434123818842e-07,-7.56911621331299e-07,-7.56392557386861e-07,-7.55876839185382e-07,-7.55364372541087e-07,-7.54855062176547e-07,-7.54348811966064e-07,-7.53845525207338e-07,-7.53345104886091e-07,-7.52847453922555e-07,-7.52352475403447e-07,-7.51860072804197e-07,-7.51370150202444e-07,-7.50882612481599e-07,-7.50397365523322e-07,-7.49914316388574e-07,-7.49433373487321e-07,-7.48954446737012e-07,-7.48477447709838e-07,-7.48002289768746e-07,-7.47528888192250e-07,-7.47057160288089e-07,-7.46587025495881e-07,-7.46118405375405e-07,-7.45651224419431e-07,-7.45185408312564e-07,-7.44720885338248e-07,-7.44257585684967e-07,-7.43795441420936e-07,-7.43334386456867e-07,-7.42874356491869e-07,-7.42415288913657e-07,-7.41957122700944e-07,-7.41499798406336e-07,-7.41043257971264e-07,-7.40587444690094e-07,-7.40132303199674e-07,-7.39677779351572e-07,-7.39223819947007e-07,-7.38770372883545e-07,-7.38317386985820e-07,-7.37864811841300e-07,-7.37412597785209e-07,-7.36960695808919e-07,-7.36509057452945e-07,-7.36057634719403e-07,-7.35606380000341e-07,-7.35155246045039e-07,-7.34704185841703e-07,-7.34253152568404e-07,-7.33802099530841e-07,-7.33350980110894e-07,-7.32899747717570e-07,-7.32448355745376e-07,-7.31996757537401e-07,-7.31544906356808e-07,-7.31092755362062e-07,-7.30640257602331e-07,-7.30187365950021e-07,-7.29734033205810e-07,-7.29280211994471e-07,-7.28825854852057e-07,-7.28370914076874e-07,-7.27915342062263e-07,-7.27459091002385e-07,-7.27002113084068e-07,-7.26544360486097e-07,-7.26085785419670e-07,-7.25626340169137e-07,-7.25165977148093e-07,-7.24704648937335e-07,-7.24242308337244e-07,-7.23778908451529e-07,-7.23314402706832e-07,-7.22848744953734e-07,-7.22381889497045e-07,-7.21913791172015e-07,-7.21444405428943e-07,-7.20973688380414e-07,-7.20501596875031e-07,-7.20028088563652e-07,-7.19553121978208e-07,-7.19076656603934e-07,-7.18598652928186e-07,-7.18119072521628e-07,-7.17637878118279e-07,-7.17155033669375e-07,-7.16670504414403e-07,-7.16184256930734e-07,-7.15696259235983e-07,-7.15206480841912e-07,-7.14714892749944e-07,-7.14221467612041e-07,-7.13726179716345e-07,-7.13229005123141e-07,-7.12729921588616e-07,-7.12228908771874e-07,-7.11725948153313e-07,-7.11221023188340e-07,-7.10714119253836e-07,-7.10205223800577e-07,-7.09694326321302e-07,-7.09181418433484e-07,-7.08666493882511e-07,-7.08149548589645e-07,-7.07630580695564e-07,-7.07109590579874e-07,-7.06586580895938e-07,-7.06061556593803e-07,-7.05534524942943e-07,-7.05005495556594e-07,-7.04474480404687e-07,-7.03941493833384e-07,-7.03406552575950e-07,-7.02869675764441e-07,-7.02330884935424e-07,-7.01790204032821e-07,-7.01247659410429e-07,-7.00703279832194e-07,-7.00157096468193e-07,-6.99609142886753e-07,-6.99059455044100e-07,-6.98508071271839e-07,-6.97955032261583e-07,-6.97400381046241e-07,-6.96844162978139e-07,-6.96286425704270e-07,-6.95727219138742e-07,-6.95166595432230e-07,-6.94604608938331e-07,-6.94041316176895e-07,-6.93476775794387e-07,-6.92911048521303e-07,-6.92344197126611e-07,-6.91776286369214e-07,-6.91207382946479e-07,-6.90637555439848e-07,-6.90066874257603e-07,-6.89495411574773e-07,-6.88923241270255e-07,-6.88350438861190e-07,-6.87777081434650e-07,-6.87203247576718e-07,-6.86629017299013e-07,-6.86054471962753e-07,-6.85479694200440e-07,-6.84904767835265e-07,-6.84329777798340e-07,-6.83754810043865e-07,-6.83179951462359e-07,-6.82605289792081e-07,-6.82030913528780e-07,-6.81456911833923e-07,-6.80883374441549e-07,-6.80310391563926e-07,-6.79738053796163e-07,-6.79166452019959e-07,-6.78595677306679e-07,-6.78025820819934e-07,-6.77456973717860e-07,-6.76889227055294e-07,-6.76322671686039e-07,-6.75757398165434e-07,-6.75193496653414e-07,-6.74631056818263e-07,-6.74070167741282e-07,-6.73510917822546e-07,-6.72953394687953e-07,-6.72397685097770e-07,-6.71843874856849e-07,-6.71292048726691e-07,-6.70742290339546e-07,-6.70194682114704e-07,-6.69649305177136e-07,-6.69106239278631e-07,-6.68565562721567e-07,-6.68027352285443e-07,-6.67491683156284e-07,-6.66958628859016e-07,-6.66428261192921e-07,-6.65900650170221e-07,-6.65375863957882e-07,-6.64853968822674e-07,-6.64335029079537e-07,-6.63819107043280e-07,-6.63306262983623e-07,-6.62796555083598e-07,-6.62290039401292e-07,-6.61786769834920e-07,-6.61286798091210e-07,-6.60790173657041e-07,-6.60296943774321e-07,-6.59807153418017e-07,-6.59320845277309e-07,-6.58838059739781e-07,-6.58358834878576e-07,-6.57883206442455e-07,-6.57411207848654e-07,-6.56942870178467e-07,-6.56478222175465e-07,-6.56017290246249e-07,-6.41806007709697e-07,-6.15890632832612e-07,-5.92181926365991e-07,-5.69723420951764e-07,-5.48179572236320e-07,-5.27361223492122e-07,-5.07139267800386e-07,-4.87434621254771e-07,-4.68189307712849e-07,-4.49358807176678e-07,-4.30907730542921e-07,-4.12807172052345e-07,-3.95033004847209e-07,-3.77564730656218e-07,-3.60384675115218e-07,-3.43477407590228e-07,-3.26829312035693e-07,-3.10428262298597e-07,-2.94263373303502e-07,-2.78324802776086e-07,-2.62603597899066e-07,-2.47091568660168e-07,-2.31781185843824e-07,-2.16665496813351e-07,-2.01738055486151e-07,-1.86992863546916e-07,-1.72424320849291e-07,-1.58027183070493e-07,-1.43796525393700e-07,-1.29727711285006e-07,-1.15816365292642e-07,-1.02058349361110e-07,-8.84497420564010e-08,-7.49868202671454e-08,-6.16660430155389e-08,-4.84840370760692e-08,-3.54375841513236e-08,-2.25236093949267e-08,-9.73917110512024e-09,0.335646101384842,9.07206370951858,28.0828562730498];
+Q_AC = [5.57715794800023,5.84568222973429,6.37824761583616,7.26687325082305,8.59295022550981,10.4204926607239,12.7915669386019,15.7240392028993,19.2115563810071,23.2255080462460,27.7185528296492,32.6292457567730,37.8872741833241,43.4188245824986,49.1516576971507,55.0195419058299,60.9657825863627,66.9456753584964,72.9278042401608,78.8942046302428,84.8394820212752,90.7690607849937,96.6967890235348,102.642132440613,108.627253799931,114.674201880238,120.802430767034,127.026844283532,133.356421460135,139.793500011275,146.333707641784,152.966452728045,159.675886431271,166.442189125745,173.243061048353,180.055252450450,186.856022040825,193.624407277955,200.342232521051,206.994796675787,213.571222092447,220.064488714567,226.471157898693,232.790862667076,239.025623077202,245.179061586722,251.255593803292,257.259662951639,263.195072390372,269.064463667906,274.868958967366,280.607986203312,286.279273317349,291.878992699588,297.402030192177,302.842339697404,308.193345982415,313.448349712982,318.600913289194,323.645185401184,328.576158753221,333.389837151681,338.083312075412,342.654751580936,347.103314715022,351.429006222025,355.632485169554,359.714857878475,363.677462591559,367.521674882110,371.248738937877,374.859637067166,378.355005716367,381.735098379329,384.999790431030,388.148620043882,391.180862392426,394.095624741288,396.891945658396,399.568898750729,402.125684148485,404.561709311960,406.876644886337,409.070462009493,411.143442562862,413.096171507500,414.929508092412,416.644544881384,418.242555835557,419.724941755845,421.093176190198,422.348753689545,423.493151247710,424.527795976040,425.454045742159,426.273181755723,426.986411266687,427.594879320126,428.099687621601,428.501918060841,428.802656481016,429.003017243401,429.104164428712,429.107329455881,429.013822092710,428.825035182658,428.542448994021,428.167621758371,427.702182920287,427.147821960462,426.506267396393,425.779280975952,424.968638276905,424.076116552908,423.103485389274,422.052498125594,420.924887865618,419.722365567846,418.446619787273,417.099321524701,415.682127403114,414.196685666573,412.644641425979,411.027641964106,409.347341584593,407.605404151051,405.803505538309,403.943333139678,402.026595660179,400.054979661779,398.030212212183,395.954004594985,393.828070256128,391.654114850608,389.433833482687,387.168906636261,384.860999522002,382.511756639282,380.122803825903,377.695745279140,375.232165346491,372.733628952514,370.201680068991,367.637848258247,365.043647111501,362.420574211121,359.770112254762,357.093732423610,354.392887718672,351.669018346931,348.923549853684,346.157895527501,343.373447732748,340.571583202549,337.753659652848,334.921012885020,332.074963500744,329.216801398556,326.347798388574,323.469202097683,320.582236571689,317.688102625259,314.787977041705,311.883014128642,308.974344985239,306.063077837512,303.150299105512,300.237073378962,297.324443577648,294.413431110426,291.505035940856,288.600236538805,285.699989742105,282.805230561246,279.916871953827,277.035804590512,274.162896633372,271.298993555431,268.444917986373,265.601469621749,262.769425226979,259.949538708899,257.142541236796,254.349141421973,251.570025496603,248.805857551270,246.057279796387,243.324912822236,240.609355844286,237.911186926964,235.230963181794,232.569220937515,229.926475881737,227.303223175920,224.699937547511,222.117073364426,219.555064694813,217.014325366993,214.495249027406,211.998209193544,209.523559312483,207.071632826850,204.642743244382,202.237184204390,199.855229535936,197.497133303866,195.163129834102,192.853433712537,190.568239749167,188.307722898707,186.072038129998,183.861320237146,181.675683585398,179.515221784671,177.380007283744,175.270090877994,173.185501123141,171.126243646628,169.092300347183,167.083628471796,165.100159557721,163.141798225253,161.208420804982,159.299873780968,157.415972028983,155.556496826459,153.721193608245,151.909769439605,150.121890175131,148.357177269363,146.615204201906,144.895492476597,143.197507150904,141.520651848059,139.864263200527,138.227604669211,136.609859678289,135.010124000809,133.427397325105,131.860573926854,130.308432366147,128.769624123489,127.242661244131,125.725902188479,124.217536877862,122.715570430120,121.217804502151,119.721817888746,118.224944498636,116.724250385439,115.216509019487,113.698170765948,112.165336195534,110.613722542855,109.038629203800,107.434902380324,105.796895131904,104.118426459666,102.392738665930,100.612451625833,98.7695194997325,96.8551803555706,94.8599070335168,92.7733644886192,90.5843602865794,88.2808028736461,85.8496611339452,83.2769305676364,80.5512228327389,77.6983642593514,74.7377007278026,71.6826682824960,68.5464707806599,65.3420466728996,62.0820398135127,58.7787714658178,55.4442146207662,52.0899701942925,48.7272456110031,45.3668353319164,42.0191033085097,38.6939678069365,35.4008876627249,32.1488509356526,28.9463659061051,25.8014524138339,22.7216367444474,19.7139472625181,16.7849122523770,13.9405588419303,11.1864142813505,8.52750792279860,5.96837550073970,3.51306395940600,1.16513832593828,-1.07231077490796,-3.19665787133835,-5.20573279851675,-7.09780948087557,-8.87159381153070,-10.5262112737159,-12.0611924874017,-13.4764594109450,-14.7723091205236,-15.9494002107913,-17.0087344323344,-17.9516415519338,-18.7797616010907,-19.4950278900269,-20.0996495026881,-20.5960934583798,-20.9870669648859,-21.2755002712475,-21.4645269482262,-21.5574679404128,-21.5578134215064,-21.4692044777220,-21.2954169886545,-21.0403441895896,-20.7079799566900,-20.3024021386963,-19.8277567399655,-19.2882421280985,-18.6880943680805,-18.0315720950282,-17.3229428695530,-16.5664690257783,-15.7663947239120,-14.9269335994344,-14.0522567384398,-13.1464814060258,-12.2136602475592,-11.2577713038777,-10.2827084576250,-9.29227259087739,-8.29016354183599,-7.27997230568309,-6.26517446182010,-5.24912342821841,-4.23504513782587,-3.22603289859949,-2.22504290232344,-1.23489047756838,-0.258246820315554,0.702363756259741,1.64456578249045,2.56613428729813,3.46499588294637,4.33922912823441,5.18706468073319,6.00688481062894,6.79722244211181,7.55675991034375,8.28432710705521,8.97889945747780,9.63959525418724,10.2656729846827,10.8565279347676,11.4116889428702,11.9308143733622,12.4136883819084,12.8602163559429,13.2704207741856,13.6444362109271,13.9825048714483,14.2849712546200,14.5522774436335,14.7849575183290,14.9836326775273,15.1490054885270,15.2818549135171,15.3830304789483,15.4534472741057,15.4940799046072,15.5059587723409,15.4901614444747,15.4478112756467,15.3800689693648,15.2881297328045,15.1732170933731,15.0365776601149,14.8794776504265,14.7031967010513,14.5090240505135,14.2982547673278,14.0721841279657,13.8321047133974,13.5793019320768,13.3150503777825,13.0406105512427,12.7572248380939,12.4661149267087,12.1684790148253,11.8654886582017,11.5582860008064,11.2479814441880,10.9356515257963,10.6223369195397,10.3090405847266,9.99672610391750,9.68631622137727,9.37869157329647,9.07468959877750,8.77510362564741,8.48068212826529,8.19212815424424,7.91009891560317,7.63520553893185,7.36801296886891,7.10904001912836,6.85875956517957,6.61759887247033,6.38594005386399,6.16412064978982,5.95243432448035,5.75113167157435,5.56042112228998,5.38046994931900,5.21140535956221,5.05331566881866,4.90625155155617,4.77022735892654,4.64522249824421,4.53118286722193,4.42802233634879,4.33562427290591,4.25384287116953,4.18250532719349,4.12141317068202,4.07034337512068,4.02905083197068,3.99726939972027,3.97471379674264,3.96108121278032,3.95605288121505,3.95929581544623,3.97046420202237,3.98920129908639,4.01514042936427,4.04790723528530,4.08712072367566,4.13239462960077,4.18333898198697,4.23956153734465,4.30066901700799,4.36626852237570,4.43596807651349,4.50937841911362,4.58611413691148,4.66579451263091,4.74804474840327,4.83249664627747,4.91878954307533,5.00657119621265,5.09549861378158,5.18523869041793,5.27546881168342,5.36587755469517,5.45616512455323,5.54604380023060,5.63523843130345,5.72348682531802,5.81054003862502,5.89616261506907,5.98013278667777,6.06224263113309,6.14229817970472,6.22011947500182,6.29554058150027,6.36840955204585,6.43858835256089,6.50595274660395,6.57039214146235,6.63180939769557,6.69012060419887,6.74525482088597,6.79715379107420,6.84577162564756,6.89107446107969,6.93304009340441,6.97165759021899,7.00692688279124,7.03885834032157,7.06747232838548,7.09279875355177,7.11487659613695,7.13375343301636,7.14948495236845,7.16213446217977,7.17177239428645,7.17847582851316,7.18232797053706,7.18341761596691,7.18183867544603,7.17768970514760,7.17107342456753,7.16209622292178,7.15086767383629,7.13750006831409,7.12210796339190,7.10480773910091,7.08571716311137,7.06495496757442,7.04264044133672,7.01889303745188,6.99383199511643,6.96757597637778,6.94024271880633,6.91194870499385,6.88280884909909,6.85293620047992,6.82244166462565,6.79143374169850,6.76001828287914,6.72829826454761,6.69637358025558,6.66434085043451,6.63229324975876,6.60032035202168,6.56850799231524,6.53693814625542,6.50568882596060,6.47483399245388,6.44444348412049,6.41458296081249,6.38531386315981,6.35669338661804,6.32877446975683,6.30160579637138,6.27523181214845,6.24969275038689,6.22502467094217,6.20125951229168,6.17842515446274,6.15654549138013,6.13564051241134,6.11572639302735,6.09681559911632,6.07891698395552,6.06203590424917,6.04617434367117,6.03133103970353,6.01750161418357,6.00467870846085,5.99285212301432,5.98200896070503,5.97213377281578,5.96320870723520,5.95521365827613,5.94812641764049,5.94192282602740,5.93657692488107,5.93206110779301,5.92834627109856,5.92540196323130,5.92319645533673,5.92169722132070,5.92087048367135,5.92068191933474,5.92109649411780,5.92207869226786,5.92359262851066,5.92560215575871,5.92807102262110,5.93096297474565,5.93424186829837,5.93787177181103,5.94181706164358,5.94604254964685,5.95051358194462,5.95519605429540,5.96005657740075,5.96506253432031,5.97018211493841,5.97538441213850,5.98063949707583,5.98591846444524,5.99119344029634,5.99643762096419,6.00162543876877,6.00673248124078,6.01173554819385,6.01661268402294,6.02134318592247,6.02590762723921,6.03028786608046,6.03446705010993,6.03842961991428,6.04216130732788,6.04564913037724,6.04888137812631,6.05184760173635,6.05453859855844,6.05694638560920,6.05906418494634,6.06088639093459,6.06240854712046,6.06362730753597,6.06454041211368,6.06514664576713,6.06544580523611,6.06543864965329,6.06512687533713,6.06451307336321,6.06360065930633,6.06239387247850,6.06089768753858,6.05911780744968,6.05706060421505,6.05473305399511,6.05214271346674,6.04929767040435,6.04620649452032,6.04287818937508,6.03932214739733,6.03554811264611,6.03156613184253,6.02738650744710,6.02301976118344,6.01847658899738,6.01376783093645,6.00890441293141,6.00389732510025,5.99875757761129,5.99349616958995,5.98812405392645,5.98265210152659,5.97709107800419,5.97145160562549,5.96574414426659,5.95997895779849,5.95416609849714,5.94831537344164,5.94243633106189,5.93653823661012,5.93063005881307,5.92472045266115,5.91881774253246,5.91292991146992,5.90706458798377,5.90122903732277,5.89543015315849,5.88967444955988,5.88396805711459,5.87831671773130,5.87272578240052,5.86720020898085,5.86174456301380,5.85636301974350,5.85105936588842,5.84583700223695,5.84069894814435,5.83564784757636,5.83068597583967,5.82581524678017,5.82103722078390,5.81635311377991,5.81176380707519,5.80726985777315,5.80287150970017,5.79856870488029,5.79436109555195,5.79024805663784,5.78622869857037,5.78230188041814,5.77846622328273,5.77472012392306,5.77106176854829,5.76748914672114,5.76400006532444,5.76059216254995,5.75726292186657,5.75400968592357,5.75082967034620,5.74771997738525,5.74467760938490,5.74169948203406,5.73878243736833,5.73592325649133,5.73311867198677,5.73036537999523,5.72766005193090,5.72499934581608,5.72237991721285,5.71979842973382,5.71725156511568,5.71473603284137,5.71224857929855,5.70978599646401,5.70734513010563,5.70492288749511,5.70251624462684,5.70012225293959,5.69773804553967,5.69536084292579,5.69298795821712,5.69061680188798,5.68824488601356,5.68586982803281,5.68348935403550,5.68110130158203,5.67870362206546,5.67629438262638,5.67387176763210,5.67143407973281,5.66897974050779,5.66650729071593,5.66401539016518,5.66150281721624,5.65896846793656,5.65641135492072,5.65383060579430,5.65122546141789,5.64859527380901,5.64593950379910,5.64325771844362,5.64054958820265,5.63781488391008,5.63505347354893,5.63226531885051,5.62945047173488,5.62660907061007,5.62374133654683,5.62084756934605,5.61792814351503,5.61498350416888,5.61201416287263,5.60902069343947,5.60600372769975,5.60296395125526,5.59990209923235,5.59681895204746,5.59371533119750,5.59059209509939,5.58745013505485,5.58429037104673,5.58111374776217,5.57792123064951,5.57471380232346,5.57149245837258,5.56825820418082,5.56501205121867,5.56175501367940,5.55848810520907,5.55521233576588,5.55192870861017,5.54863821747734,5.54534184377210,5.54204055406279,5.53873529772748,5.53542700442130,5.53211658216216,5.52880491531888,5.52549286271356,5.52218125596319,5.51887089798976,5.51556256164316,5.51225698840924,5.50895488735683,5.50565693431151,5.50236377079981,5.49907600365520,5.49579420428474,5.49251890839792,5.48925061569491,5.48598978975948,5.48273685797745,5.47949221160598,5.47625620598550,5.47302916085283,5.46981136074033,5.46660305546301,5.46351247854702,5.47859391080385,5.57713271631180];
+dT = [0,0.0200000000000000,0.0400000000000000,0.0600000000000000,0.0790000000000000,0.0990000000000000,0.119000000000000,0.139000000000000,0.159000000000000,0.179000000000000,0.199000000000000,0.218000000000000,0.238000000000000,0.258000000000000,0.278000000000000,0.298000000000000,0.318000000000000,0.338000000000000,0.357000000000000,0.377000000000000,0.397000000000000,0.417000000000000,0.437000000000000,0.457000000000000,0.476000000000000,0.496000000000000,0.516000000000000,0.536000000000000,0.556000000000000,0.576000000000000,0.596000000000000,0.615000000000000,0.635000000000000,0.655000000000000,0.675000000000000,0.695000000000000,0.715000000000000,0.735000000000000,0.754000000000000,0.774000000000000];
+dMV = [-8.36203098297119,28.3732814788818,55.8705177307129,67.6144866943359,61.0760116577148,49.1858406066895,37.5954971313477,31.9774932861328,32.6449127197266,33.4272232055664,33.9666442871094,34.2937850952148,32.6856803894043,30.6470470428467,28.5793323516846,31.0762310028076,40.6717109680176,68.2914657592773,127.972457885742,219.217773437500,314.172363281250,370.932403564453,375.702575683594,333.823547363281,273.260314941406,207.018661499023,146.974548339844,92.5733795166016,45.3673820495606,12.8591918945313,7.54059743881226,42.2849693298340,114.366851806641,191.032958984375,231.183013916016,213.026443481445,142.304000854492,56.7912635803223,-8.08049011230469,-28.3833808898926];
+dAV = [61.8173980712891,145.900756835938,278.003417968750,369.900390625000,429.065246582031,420.858093261719,401.205841064453,364.409973144531,315.086547851563,263.210998535156,216.296234130859,172.979827880859,125.907966613770,73.6790390014648,25.5174446105957,-4.44148683547974,-10.9211616516113,-3.14720511436462,7.10270595550537,14.4191102981567,20.5342292785645,24.2467708587647,23.5863590240479,18.0702629089355,11.7607002258301,7.03433895111084,2.23553490638733,-3.36217164993286,-7.44901943206787,-6.86342954635620,-2.11557292938232,4.35276937484741,7.53827190399170,8.08802795410156,9.04480552673340,11.3468732833862,10.3893375396729,3.87578821182251,-2.55210447311401,7.78755378723145];
+dAC = [19.7609941661031,73.1262550104432,250.618209783233,377.732152540579,405.070757011808,405.132058696228,382.355454288503,339.477586270731,288.608164511433,247.086663166879,208.486436976204,173.669245526034,135.109248674560,92.6066027396284,43.6351527764188,8.00206858520270,-2.85246024208947,-2.48056516384596,-1.97640069885336,1.91600418203788,10.5151904454428,20.6225625583695,26.2624425537290,25.6981993321001,23.1794080165933,21.4158520959803,20.9306018044325,20.1408197591648,19.1334669349436,18.7508414240735,18.5362465920636,17.6338538802780,16.1957961829107,13.4401119730132,11.6045028709803,12.2665905784388,13.2067438497322,10.8240617026118,6.56860001009449,4.17572237099022];
+
+subplot(2,3,4)
+indMV = find(strcmp(names,'MV'));
+indAV = find(strcmp(names,'AV'));
+indAA = find(strcmp(names,'AA'));
+% plot(x,x*indMV,'color',c(indMV,:),'LineWidth',4)
+% hold on
+% plot(x,x*indAV,'color',c(indAV,:),'LineWidth',4)
+% hold on
+% plot(x,x*indAA,'color',c(indAA,:),'LineWidth',4)
+% hold on
+plot(simtime,Q_MV,'color',c(indMV,:),'LineWidth',2)
+hold on
+plot(simtime,Q_AV,'color',c(indAV,:),'LineWidth',2)
+hold on
+plot(simtime,Q_AC,'color',c(indAA,:),'LineWidth',2)
+hold on
+plot(dT,dMV,'o','color',c(indMV,:),'LineWidth',1.5)
+hold on
+plot(dT,dAV,'o','color',c(indAV,:),'LineWidth',1.5)
+hold on
+plot(dT,dAC,'o','color',c(indAA,:),'LineWidth',1.5)
+hold on
+% legend({'MV','AV','AA'},'location','northwest')
+legend({'MV','AV','AA'},'location','northeast')
+
+subplot(2,3,5)
+indMV = find(strcmp(names,'MV'));
+indAV = find(strcmp(names,'AV'));
+indAA = find(strcmp(names,'AA'));
+% plot(x,x*indMV,'color',c2(indMV,:),'LineWidth',4)
+% hold on
+% plot(x,x*indAV,'color',c2(indAV,:),'LineWidth',4)
+% hold on
+% plot(x,x*indAA,'color',c2(indAA,:),'LineWidth',4)
+% hold on
+plot(simtime,Q_MV,'color',c2(indMV,:),'LineWidth',2)
+hold on
+plot(simtime,Q_AV,'color',c2(indAV,:),'LineWidth',2)
+hold on
+plot(simtime,Q_AC,'color',c2(indAA,:),'LineWidth',2)
+hold on
+plot(dT,dMV,'o','color',c2(indMV,:),'LineWidth',1.5)
+hold on
+plot(dT,dAV,'o','color',c2(indAV,:),'LineWidth',1.5)
+hold on
+plot(dT,dAC,'o','color',c2(indAA,:),'LineWidth',1.5)
+hold on
+% legend({'MV','AV','AA'},'location','northwest')
+legend({'MV','AV','AA'},'location','northeast')
+
+
+subplot(2,3,6)
+indMV = find(strcmp(names,'MV'));
+indAV = find(strcmp(names,'AV'));
+indAA = find(strcmp(names,'AA'));
+% plot(x,x*indMV,'color',c4(indMV,:),'LineWidth',4)
+% hold on
+% plot(x,x*indAV,'color',c4(indAV,:),'LineWidth',4)
+% hold on
+% plot(x,x*indAA,'color',c4(indAA,:),'LineWidth',4)
+% hold on
+plot(simtime,Q_MV,'color',c4(indMV,:),'LineWidth',2)
+hold on
+plot(simtime,Q_AV,'color',c4(indAV,:),'LineWidth',2)
+hold on
+plot(simtime,Q_AC,'color',c4(indAA,:),'LineWidth',2)
+hold on
+plot(dT,dMV,'o','color',c4(indMV,:),'LineWidth',1.5)
+hold on
+plot(dT,dAV,'o','color',c4(indAV,:),'LineWidth',1.5)
+hold on
+plot(dT,dAC,'o','color',c4(indAA,:),'LineWidth',1.5)
+hold on
+% legend({'MV','AV','AA'},'location','northwest')
+legend({'MV','AV','AA'},'location','northeast')
+
+
+
+
+
+
+
diff --git a/Requirements/matplotlib/twilight.m b/Requirements/matplotlib/twilight.m
new file mode 100644
index 0000000000000000000000000000000000000000..6e99fcb729b0a519a73320800a99fee7af259cda
--- /dev/null
+++ b/Requirements/matplotlib/twilight.m
@@ -0,0 +1,78 @@
+function [map,num] = twilight(N)
+% Perceptually uniform cyclic colormap from MatPlotLib.
+%
+% Copyright (c) 2015 Bastian Bechtold
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = twilight
+%  map = twilight(N)
+%
+% Colormap designed by Bastian Bechtold.
+%
+% Cyclic colormaps are designed for plotting data that repeats, therefore the
+% colormap loops around (the first and last colors tend to the same color).
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(twilight(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(twilight)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(twilight)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also CIVIDIS INFERNO MAGMA PLASMA TWILIGHT_SHIFTED VIRIDIS
+% TAB10 TAB20 TAB20B TAB20C
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:twilight:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.95588623,0.91961077,0.95812116;0.94967876,0.91615763,0.95315546;0.94353853,0.91268927,0.94824212;0.9374452,0.90921449,0.94337733;0.93140447,0.90573033,0.93856712;0.92542215,0.90223373,0.93381777;0.91947392,0.89873478,0.92912752;0.91357865,0.89522463,0.92450721;0.90772105,0.89170929,0.91995838;0.90189106,0.88819234,0.91548457;0.8960938,0.8846711,0.91109116;0.89031153,0.88115247,0.90677917;0.88453669,0.87763908,0.90255063;0.87877004,0.87413042,0.89840629;0.87299914,0.87063131,0.89434535;0.86721094,0.86714674,0.89036725;0.86141058,0.86367475,0.88646923;0.85559299,0.86021735,0.88264858;0.84974682,0.85677881,0.87890418;0.84387192,0.85335917,0.87523342;0.83797164,0.84995717,0.87163289;0.83204469,0.84657319,0.86810058;0.82609045,0.84320733,0.86463493;0.82010052,0.83986227,0.86123767;0.81408416,0.83653448,0.85790541;0.80804251,0.83322322,0.85463767;0.80197661,0.82992779,0.85143441;0.79588772,0.82664733,0.84829592;0.78977733,0.82338091,0.8452227;0.78364717,0.82012747,0.84221541;0.7774989,0.81688599,0.83927495;0.77133274,0.81365586,0.83640309;0.76515383,0.81043494,0.83359933;0.75896452,0.80722199,0.83086447;0.75276734,0.80401573,0.82819926;0.74656497,0.80081486,0.82560433;0.74036019,0.79761806,0.82308018;0.73415594,0.79442399,0.82062712;0.72795524,0.79123135,0.81824533;0.7217612,0.78803884,0.81593475;0.71557653,0.78484528,0.81369544;0.70940398,0.78164957,0.81152729;0.70324772,0.77845022,0.80942895;0.69711099,0.77524608,0.8073995;0.69099696,0.77203607,0.8054378;0.68490872,0.76881916,0.80354253;0.67884928,0.76559441,0.80171222;0.67282151,0.76236096,0.79994524;0.66682814,0.75911802,0.79823983;0.66087179,0.7558649,0.79659413;0.65495439,0.75260107,0.7950067;0.64907877,0.74932586,0.79347499;0.64324724,0.74603878,0.79199677;0.63746171,0.74273942,0.79056997;0.63172396,0.73942747,0.7891925;0.62603562,0.73610266,0.78786229;0.62039814,0.73276477,0.78657732;0.61481293,0.72941363,0.78533547;0.60928127,0.72604912,0.7841347;0.60380419,0.72267116,0.78297314;0.59838267,0.71927971,0.78184895;0.59301756,0.71587476,0.78076036;0.58770967,0.7124563,0.77970565;0.5824597,0.70902436,0.77868317;0.57726849,0.70557897,0.77769104;0.5721366,0.70212016,0.77672775;0.56706445,0.69864803,0.7757921;0.56205254,0.69516262,0.77488269;0.55710135,0.69166401,0.7739982;0.55221135,0.68815225,0.77313735;0.54738299,0.68462741,0.77229891;0.54261669,0.68108954,0.7714817;0.53791302,0.6775387,0.77068427;0.53327235,0.67397494,0.76990557;0.52869499,0.67039831,0.76914482;0.52418136,0.66680884,0.76840101;0.51973187,0.66320657,0.76767313;0.51534697,0.65959152,0.76696023;0.51102708,0.6559637,0.76626135;0.50677264,0.65232312,0.76557558;0.50258409,0.64866978,0.76490201;0.49846187,0.64500368,0.76423976;0.49440652,0.64132483,0.7635876;0.49041839,0.63763319,0.76294498;0.48649792,0.63392874,0.76231111;0.48264558,0.63021144,0.76168515;0.4788618,0.62648125,0.76106626;0.47514703,0.62273814,0.76045361;0.4715017,0.61898207,0.75984637;0.46792623,0.61521297,0.75924371;0.46442103,0.6114308,0.75864479;0.4609865,0.6076355,0.7580488;0.45762301,0.60382702,0.7574549;0.45433091,0.60000529,0.75686228;0.45111051,0.59617026,0.75626997;0.44796212,0.59232188,0.75567717;0.44488599,0.58846006,0.75508316;0.44188237,0.58458473,0.7544871;0.43895145,0.58069584,0.75388814;0.43609336,0.5767933,0.75328544;0.43330824,0.57287707,0.75267815;0.43059613,0.56894708,0.75206541;0.42795705,0.56500326,0.75144639;0.42539095,0.56104556,0.75082021;0.42289775,0.55707392,0.75018601;0.42047728,0.55308828,0.74954294;0.41812934,0.54908859,0.74889012;0.41585365,0.54507481,0.7482267;0.41364987,0.54104688,0.7475518;0.41151761,0.53700476,0.74686455;0.40945636,0.53294843,0.74616402;0.40746562,0.52887785,0.74544937;0.40554478,0.52479298,0.74471976;0.4036932,0.52069379,0.74397434;0.40191012,0.51658025,0.74321222;0.40019476,0.51245234,0.74243254;0.39854625,0.50831006,0.74163443;0.39696364,0.50415338,0.74081703;0.39544595,0.4999823,0.73997947;0.39399211,0.49579683,0.7391209;0.39260099,0.49159695,0.73824046;0.39127141,0.48738268,0.73733729;0.39000213,0.48315403,0.73641054;0.38879184,0.478911,0.73545936;0.3876392,0.47465363,0.73448291;0.38654279,0.47038193,0.73348035;0.38550116,0.46609593,0.73245082;0.38451281,0.46179566,0.73139351;0.3835762,0.45748116,0.73030757;0.38268975,0.45315247,0.72919218;0.38185182,0.44880962,0.7280465;0.38106076,0.44445268,0.72686969;0.38031486,0.44008169,0.72566094;0.37961245,0.43569671,0.72441943;0.37895177,0.43129778,0.72314434;0.37833106,0.42688498,0.72183484;0.37774855,0.42245837,0.72049011;0.37720243,0.41801803,0.71910933;0.37669089,0.41356403,0.71769166;0.37621211,0.40909646,0.71623627;0.37576424,0.4046154,0.71474232;0.37534545,0.40012094,0.71320896;0.3749539,0.39561319,0.71163536;0.37458773,0.39109226,0.71002064;0.3742451,0.38655825,0.70836394;0.37392415,0.38201129,0.7066644;0.37362303,0.3774515,0.70492111;0.37333991,0.37287903,0.70313318;0.37307294,0.36829402,0.70129969;0.37282029,0.36369664,0.69941971;0.37258013,0.35908705,0.69749231;0.37235064,0.35446544,0.6955165;0.37212999,0.349832,0.69349132;0.3719164,0.34518697,0.69141574;0.37170804,0.34053056,0.68928875;0.37150314,0.33586303,0.68710929;0.37130003,0.33118458,0.68487633;0.37109685,0.32649557,0.68258873;0.3708918,0.32179632,0.68024534;0.37068312,0.31708718,0.67784499;0.37046904,0.31236853,0.67538648;0.3702478,0.3076408,0.67286859;0.37001764,0.30290445,0.67029004;0.3697768,0.29815996,0.66764952;0.36952351,0.29340788,0.6649457;0.36925602,0.28864881,0.66217719;0.36897256,0.28388339,0.65934258;0.36867134,0.27911233,0.6564404;0.36835059,0.27433641,0.65346914;0.3680085,0.26955647,0.65042726;0.36764328,0.26477344,0.64731318;0.36725311,0.25998832,0.64412527;0.3668366,0.25520194,0.64086184;0.36639158,0.2504157,0.63752117;0.36591607,0.24563096,0.63410149;0.36540817,0.24084915,0.63060103;0.36486595,0.23607183,0.62701797;0.36428747,0.2313007,0.62335047;0.36367073,0.2265376,0.61959664;0.36301372,0.22178452,0.61575461;0.36231439,0.21704365,0.61182247;0.36157068,0.21231734,0.60779834;0.36078129,0.20760765,0.60367993;0.35994327,0.20291779,0.59946566;0.35905442,0.19825076,0.59515371;0.35811253,0.19360973,0.59074229;0.35711536,0.18899812,0.5862297;0.35606065,0.18441957,0.5816143;0.35494612,0.17987796,0.57689459;0.35377006,0.17537711,0.57206861;0.35252969,0.17092163,0.56713551;0.35122252,0.1665162,0.56209448;0.34984626,0.16216558,0.55694478;0.34839867,0.15787473,0.5516859;0.34687754,0.15364873,0.54631766;0.34528103,0.14949272,0.54083967;0.34360674,0.1454121,0.535253;0.34185263,0.14141215,0.5295588;0.34001688,0.13749807,0.52375852;0.33809785,0.13367489,0.51785407;0.33609404,0.12994744,0.51184794;0.33400409,0.12632016,0.50574349;0.33182701,0.12279709,0.49954424;0.32956205,0.11938176,0.49325427;0.32720876,0.11607711,0.48687817;0.32476698,0.1128854,0.48042104;0.32223661,0.10980755,0.47389029;0.31961836,0.10684434,0.46729116;0.31691312,0.10399563,0.46062961;0.31412208,0.10126033,0.45391229;0.31124668,0.09863647,0.44714607;0.30828872,0.09612127,0.44033795;0.30525021,0.09371113,0.433495;0.30213347,0.09140049,0.42662674;0.29894109,0.08918489,0.41973884;0.29567576,0.08705943,0.41283683;0.2923403,0.08501829,0.40592705;0.28893761,0.08305536,0.39901552;0.28547067,0.08116432,0.39210787;0.28194249,0.07933875,0.38520933;0.27835606,0.07757226,0.37832469;0.27471434,0.07585853,0.37145825;0.27102024,0.07419145,0.36461386;0.26727656,0.0725651,0.35779486;0.263486,0.07097387,0.35100416;0.25965113,0.06941247,0.34424417;0.2557744,0.06787594,0.33751691;0.2518586,0.06635773,0.33082656;0.24790678,0.06485041,0.32417842;0.24392,0.06335391,0.31756813;0.23990011,0.0618647,0.31099621;0.23584881,0.06037959,0.30446287;0.23176762,0.05889569,0.29796805;0.22765793,0.05741044,0.29151145;0.2235249,0.0559091,0.28510781;0.21936673,0.05439937,0.2787442;0.21518395,0.05288082,0.27241805;0.21097738,0.05135188,0.26612831;0.20675095,0.04980177,0.25988492;0.20250558,0.04822872,0.25368699;0.19823879,0.04664038,0.24752274;0.19395092,0.04503581,0.24139075;0.18964939,0.04339464,0.2353118;0.18532874,0.04173194,0.22926588;0.18098806,0.04004406,0.22324832;0.17663372,0.03832764,0.21727622;0.1722628,0.0366263,0.21133883;0.16787203,0.03494898,0.20542535;0.16346916,0.03327796,0.19955633;0.15904897,0.03162694,0.19371576;0.15460852,0.03000286,0.18789489;0.15015881,0.02838308,0.18212224;0.1456879,0.02679372,0.17636536;0.14120085,0.02522488,0.17063713;0.13669847,0.02367601,0.16493914;0.13217294,0.02216185,0.15925166;0.13715771,0.0238647,0.16279915;0.142138,0.02560107,0.16632081;0.14712696,0.02735575,0.16981697;0.15211729,0.02913553,0.17328696;0.15711127,0.03093684,0.17673054;0.1621132,0.03275335,0.18014741;0.16711334,0.03459602,0.18353723;0.17212778,0.03644357,0.18689953;0.17714184,0.03831372,0.19023414;0.18216272,0.04019623,0.19354057;0.18719181,0.04204197,0.19681833;0.19222138,0.04385446,0.20006748;0.19726438,0.04562162,0.20328673;0.20231059,0.04735883,0.20647637;0.20736026,0.04906721,0.20963605;0.21242374,0.05073417,0.21276409;0.21748944,0.05237662,0.21586133;0.22256097,0.05399093,0.21892687;0.2276448,0.05556951,0.22195906;0.2327317,0.05712593,0.22495882;0.23782409,0.05865801,0.2279252;0.24292948,0.06015655,0.23085593;0.24803856,0.06163518,0.23375227;0.25315165,0.06309447,0.23661359;0.25827753,0.06452336,0.23943683;0.26340901,0.06593256,0.24222299;0.26854476,0.0673248,0.24497172;0.27368637,0.06869883,0.24768176;0.27883959,0.07004759,0.25035015;0.28399705,0.0713821,0.2529784;0.28915882,0.07270312,0.2555656;0.29432497,0.07401148,0.25811079;0.29950154,0.07529967,0.26061023;0.30468256,0.07657683,0.26306525;0.30986729,0.07784489,0.26547507;0.31505561,0.07910492,0.2678386;0.32024732,0.0803581,0.2701547;0.32544482,0.08160204,0.27242069;0.33064667,0.08283969,0.27463586;0.33585053,0.08407525,0.27680013;0.34105598,0.08531029,0.27891231;0.34626256,0.08654644,0.28097121;0.35146972,0.08778547,0.28297562;0.35667687,0.08902924,0.28492434;0.36188334,0.09027973,0.28681618;0.36708839,0.09153902,0.28864998;0.37229131,0.09280915,0.2904245;0.37749189,0.09409153,0.29213802;0.38268807,0.09539008,0.29379048;0.38787885,0.09670726,0.29538088;0.39306317,0.09804561,0.29690835;0.39823991,0.09940776,0.29837204;0.40340787,0.10079637,0.29977124;0.40856581,0.10221419,0.30110533;0.41371275,0.10366356,0.30237338;0.41884758,0.10514695,0.30357463;0.42396841,0.1066678,0.3047094;0.42907377,0.10822892,0.30577763;0.43416218,0.10983307,0.3067794;0.43923211,0.11148296,0.30771496;0.44428204,0.11318118,0.30858474;0.44931042,0.11493024,0.30938934;0.45431572,0.11673249,0.31012956;0.45929645,0.11859012,0.31080632;0.46425232,0.12050381,0.31141829;0.46918047,0.12247703,0.31196941;0.47407948,0.12451142,0.31246122;0.47894794,0.12660841,0.31289546;0.48378454,0.12876919,0.31327402;0.48858861,0.13099415,0.31359736;0.49335851,0.13328448,0.3138686;0.4980928,0.13564099,0.31409096;0.50279043,0.13806389,0.31426689;0.50745058,0.1405531,0.31439855;0.51207262,0.14310825,0.31448774;0.51665528,0.1457293,0.31453872;0.52119791,0.14841559,0.31455424;0.52569995,0.15116629,0.31453693;0.53016101,0.15398036,0.31448913;0.53458045,0.1568568,0.31441462;0.53895794,0.15979435,0.31431622;0.54329324,0.16279163,0.31419663;0.54758618,0.16584718,0.31405871;0.55183659,0.16895949,0.3139054;0.55604443,0.17212695,0.31373936;0.56020971,0.17534794,0.31356335;0.56433247,0.1786208,0.31338008;0.56841285,0.18194387,0.31319183;0.57245099,0.1853155,0.31300097;0.57644706,0.18873401,0.31281029;0.58040129,0.19219776,0.31262196;0.58431392,0.19570523,0.31243779;0.58818523,0.19925487,0.31225983;0.59201548,0.20284508,0.31209072;0.59580496,0.20647443,0.31193222;0.59955398,0.2101416,0.31178574;0.60326283,0.21384527,0.31165305;0.60693181,0.21758404,0.31153632;0.61056126,0.22135662,0.31143744;0.61415144,0.22516202,0.3113573;0.61770261,0.22899913,0.31129746;0.62121505,0.23286692,0.3112594;0.62468917,0.23676405,0.31124564;0.6281251,0.24068989,0.31125653;0.63152309,0.24464358,0.3112934;0.63488335,0.24862429,0.3113576;0.63820616,0.25263112,0.31145067;0.64149182,0.25666317,0.31157436;0.64474038,0.26072,0.31172919;0.64795203,0.26480095,0.3119164;0.65112691,0.26890541,0.31213721;0.65426523,0.27303275,0.31239299;0.65736724,0.27718218,0.31268539;0.66043291,0.28135348,0.31301496;0.66346234,0.28554617,0.31338289;0.66645563,0.28975979,0.31379035;0.66941285,0.29399391,0.31423853;0.67233423,0.29824791,0.31472899;0.67521975,0.30252154,0.31526265;0.67806939,0.30681452,0.31584052;0.68088318,0.3111265,0.31646379;0.68366117,0.31545715,0.31713364;0.68640337,0.31980615,0.31785128;0.68910996,0.324173,0.31861821;0.69178081,0.32855759,0.31943534;0.6944159,0.33295966,0.32030382;0.69701522,0.33737894,0.32122489;0.69957876,0.34181516,0.32219978;0.70210653,0.34626807,0.3232297;0.7045986,0.35073729,0.32431605;0.70705492,0.35522263,0.32545997;0.70947542,0.3597239,0.32666265;0.7118601,0.36424085,0.32792534;0.71420894,0.36877323,0.3292493;0.71652194,0.37332079,0.3306358;0.71879913,0.37788325,0.33208612;0.72104061,0.38246028,0.3336016;0.72324628,0.38705172,0.33518339;0.72541618,0.3916573,0.33683277;0.72755035,0.39627674,0.33855099;0.72964884,0.40090978,0.34033932;0.73171172,0.40555611,0.34219899;0.73373911,0.41021541,0.34413127;0.73573115,0.41488736,0.34613738;0.73768789,0.41957169,0.34821851;0.73960949,0.42426807,0.35037584;0.7414961,0.42897616,0.35261056;0.74334793,0.43369562,0.35492382;0.74516521,0.43842607,0.35731674;0.74694821,0.44316712,0.35979044;0.74869724,0.44791835,0.36234598;0.75041257,0.4526794,0.36498439;0.75209454,0.45744986,0.36770666;0.75374356,0.46222929,0.37051374;0.75536003,0.46701725,0.37340656;0.75694444,0.47181326,0.37638597;0.75849733,0.47661683,0.37945279;0.76001934,0.48142741,0.38260777;0.76151097,0.48624456,0.38585161;0.76297286,0.49106776,0.38918495;0.76440573,0.49589647,0.39260837;0.76581031,0.50073015,0.39612236;0.76718741,0.50556824,0.39972737;0.76853788,0.51041015,0.40342376;0.76986291,0.51525513,0.40721173;0.77116324,0.52010271,0.41109152;0.77243989,0.5249523,0.41506327;0.77369391,0.52980327,0.41912699;0.77492645,0.53465502,0.42328264;0.77613869,0.53950688,0.42753006;0.77733187,0.54435824,0.43186902;0.77850729,0.54920844,0.43629918;0.77966679,0.55405656,0.44081985;0.78081138,0.55890219,0.4454307;0.78194248,0.56374468,0.45013112;0.7830616,0.5685834,0.45492037;0.78417029,0.57341769,0.45979765;0.78527014,0.57824693,0.46476204;0.78636281,0.58307048,0.46981252;0.78744997,0.58788771,0.474948;0.78853333,0.59269801,0.48016727;0.78961491,0.59750067,0.48546886;0.79069671,0.60229498,0.49085119;0.79178009,0.6070806,0.49631312;0.79286688,0.61185698,0.50185312;0.7939589,0.61662359,0.50746956;0.79505802,0.62137992,0.51316075;0.79616609,0.62612549,0.51892492;0.79728497,0.63085984,0.52476024;0.79841652,0.63558252,0.53066483;0.7995626,0.64029314,0.53663673;0.80072505,0.64499131,0.54267394;0.80190568,0.64967668,0.54877442;0.80310632,0.65434893,0.55493609;0.80432873,0.65900778,0.56115682;0.80557466,0.66365295,0.56743447;0.80684582,0.66828424,0.57376686;0.80814389,0.67290145,0.58015179;0.8094705,0.67750443,0.58658707;0.81082722,0.68209304,0.59307049;0.81221558,0.68666721,0.59959981;0.81363705,0.69122688,0.60617284;0.81509306,0.69577202,0.61278737;0.81658494,0.70030265,0.6194412;0.81811398,0.70481883,0.62613217;0.81968139,0.70932062,0.63285811;0.82128832,0.71380816,0.63961689;0.82293582,0.71828159,0.64640643;0.82462489,0.7227411,0.65322464;0.82635642,0.72718691,0.66006948;0.82813124,0.73161926,0.66693898;0.82995006,0.73603846,0.67383115;0.83181351,0.74044483,0.68074409;0.83372214,0.74483873,0.68767592;0.83567636,0.74922057,0.69462479;0.83767708,0.75359061,0.70158791;0.83972535,0.75794913,0.70856199;0.84181991,0.76229704,0.71554745;0.84396065,0.76663495,0.72254259;0.84614733,0.77096352,0.72954568;0.8483795,0.77528348,0.73655503;0.85065653,0.77959564,0.74356888;0.85297758,0.7839009,0.75058542;0.8553436,0.7881998,0.75759877;0.8577521,0.79249376,0.76460878;0.86020061,0.79678427,0.77161459;0.8626872,0.80107277,0.77861331;0.86520968,0.80536087,0.78560141;0.86776571,0.8096503,0.79257445;0.87035656,0.81394216,0.79951954;0.87297684,0.81823907,0.80643635;0.87562545,0.82254271,0.81331573;0.87830287,0.82685434,0.8201464;0.88101291,0.83117417,0.82691355;0.88376436,0.8355008,0.83359813;0.88656419,0.83983241,0.84019282;0.88942615,0.84416471,0.84668696;0.89236612,0.84849196,0.85307571;0.89540326,0.85280703,0.85935491;0.89854578,0.85710498,0.86554325;0.90180023,0.86138156,0.87165915;0.90516762,0.86563454,0.87772373;0.90864556,0.86986351,0.88375343;0.91222303,0.87407051,0.8897753;0.91589042,0.87825797,0.89580632;0.91963903,0.88242879,0.9018554;0.92345937,0.88658601,0.90793267;0.92734253,0.89073234,0.914049;0.93128235,0.89487013,0.92020762;0.93527444,0.89900167,0.92640565;0.93931328,0.90312833,0.93265281;0.94339574,0.90725141,0.93895042;0.9475205,0.91137261,0.94528884;0.95168443,0.9154922,0.95167893;0.95588623,0.91961077,0.95812116];
+num = size(raw,1);
+%
+% Interpolate ensuring that the first & last colors are not the same:
+vec = linspace(1,num,N+1);
+map = interp1(1:num,raw,vec(1:N),'spline');
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%twilight
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/twilight_shifted.m b/Requirements/matplotlib/twilight_shifted.m
new file mode 100644
index 0000000000000000000000000000000000000000..90089e5e6312093ce05543be9a901290cb9212d9
--- /dev/null
+++ b/Requirements/matplotlib/twilight_shifted.m
@@ -0,0 +1,79 @@
+function [map,num] = twilight_shifted(N)
+% Perceptually uniform cyclic colormap from MatPlotLib.
+%
+% Copyright (c) 2015 Bastian Bechtold
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = twilight_shifted
+%  map = twilight_shifted(N)
+%
+% Colormap designed by Bastian Bechtold.
+%
+% Cyclic colormaps are designed for plotting data that repeats, therefore the
+% colormap loops around (the first and last colors tend to the same color).
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(twilight_shifted(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(twilight_shifted)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(twilight_shifted)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also CIVIDIS INFERNO MAGMA PLASMA TWILIGHT VIRIDIS
+% TAB10 TAB20 TAB20B TAB20C
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:twilight:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.95588623,0.91961077,0.95812116;0.94967876,0.91615763,0.95315546;0.94353853,0.91268927,0.94824212;0.9374452,0.90921449,0.94337733;0.93140447,0.90573033,0.93856712;0.92542215,0.90223373,0.93381777;0.91947392,0.89873478,0.92912752;0.91357865,0.89522463,0.92450721;0.90772105,0.89170929,0.91995838;0.90189106,0.88819234,0.91548457;0.8960938,0.8846711,0.91109116;0.89031153,0.88115247,0.90677917;0.88453669,0.87763908,0.90255063;0.87877004,0.87413042,0.89840629;0.87299914,0.87063131,0.89434535;0.86721094,0.86714674,0.89036725;0.86141058,0.86367475,0.88646923;0.85559299,0.86021735,0.88264858;0.84974682,0.85677881,0.87890418;0.84387192,0.85335917,0.87523342;0.83797164,0.84995717,0.87163289;0.83204469,0.84657319,0.86810058;0.82609045,0.84320733,0.86463493;0.82010052,0.83986227,0.86123767;0.81408416,0.83653448,0.85790541;0.80804251,0.83322322,0.85463767;0.80197661,0.82992779,0.85143441;0.79588772,0.82664733,0.84829592;0.78977733,0.82338091,0.8452227;0.78364717,0.82012747,0.84221541;0.7774989,0.81688599,0.83927495;0.77133274,0.81365586,0.83640309;0.76515383,0.81043494,0.83359933;0.75896452,0.80722199,0.83086447;0.75276734,0.80401573,0.82819926;0.74656497,0.80081486,0.82560433;0.74036019,0.79761806,0.82308018;0.73415594,0.79442399,0.82062712;0.72795524,0.79123135,0.81824533;0.7217612,0.78803884,0.81593475;0.71557653,0.78484528,0.81369544;0.70940398,0.78164957,0.81152729;0.70324772,0.77845022,0.80942895;0.69711099,0.77524608,0.8073995;0.69099696,0.77203607,0.8054378;0.68490872,0.76881916,0.80354253;0.67884928,0.76559441,0.80171222;0.67282151,0.76236096,0.79994524;0.66682814,0.75911802,0.79823983;0.66087179,0.7558649,0.79659413;0.65495439,0.75260107,0.7950067;0.64907877,0.74932586,0.79347499;0.64324724,0.74603878,0.79199677;0.63746171,0.74273942,0.79056997;0.63172396,0.73942747,0.7891925;0.62603562,0.73610266,0.78786229;0.62039814,0.73276477,0.78657732;0.61481293,0.72941363,0.78533547;0.60928127,0.72604912,0.7841347;0.60380419,0.72267116,0.78297314;0.59838267,0.71927971,0.78184895;0.59301756,0.71587476,0.78076036;0.58770967,0.7124563,0.77970565;0.5824597,0.70902436,0.77868317;0.57726849,0.70557897,0.77769104;0.5721366,0.70212016,0.77672775;0.56706445,0.69864803,0.7757921;0.56205254,0.69516262,0.77488269;0.55710135,0.69166401,0.7739982;0.55221135,0.68815225,0.77313735;0.54738299,0.68462741,0.77229891;0.54261669,0.68108954,0.7714817;0.53791302,0.6775387,0.77068427;0.53327235,0.67397494,0.76990557;0.52869499,0.67039831,0.76914482;0.52418136,0.66680884,0.76840101;0.51973187,0.66320657,0.76767313;0.51534697,0.65959152,0.76696023;0.51102708,0.6559637,0.76626135;0.50677264,0.65232312,0.76557558;0.50258409,0.64866978,0.76490201;0.49846187,0.64500368,0.76423976;0.49440652,0.64132483,0.7635876;0.49041839,0.63763319,0.76294498;0.48649792,0.63392874,0.76231111;0.48264558,0.63021144,0.76168515;0.4788618,0.62648125,0.76106626;0.47514703,0.62273814,0.76045361;0.4715017,0.61898207,0.75984637;0.46792623,0.61521297,0.75924371;0.46442103,0.6114308,0.75864479;0.4609865,0.6076355,0.7580488;0.45762301,0.60382702,0.7574549;0.45433091,0.60000529,0.75686228;0.45111051,0.59617026,0.75626997;0.44796212,0.59232188,0.75567717;0.44488599,0.58846006,0.75508316;0.44188237,0.58458473,0.7544871;0.43895145,0.58069584,0.75388814;0.43609336,0.5767933,0.75328544;0.43330824,0.57287707,0.75267815;0.43059613,0.56894708,0.75206541;0.42795705,0.56500326,0.75144639;0.42539095,0.56104556,0.75082021;0.42289775,0.55707392,0.75018601;0.42047728,0.55308828,0.74954294;0.41812934,0.54908859,0.74889012;0.41585365,0.54507481,0.7482267;0.41364987,0.54104688,0.7475518;0.41151761,0.53700476,0.74686455;0.40945636,0.53294843,0.74616402;0.40746562,0.52887785,0.74544937;0.40554478,0.52479298,0.74471976;0.4036932,0.52069379,0.74397434;0.40191012,0.51658025,0.74321222;0.40019476,0.51245234,0.74243254;0.39854625,0.50831006,0.74163443;0.39696364,0.50415338,0.74081703;0.39544595,0.4999823,0.73997947;0.39399211,0.49579683,0.7391209;0.39260099,0.49159695,0.73824046;0.39127141,0.48738268,0.73733729;0.39000213,0.48315403,0.73641054;0.38879184,0.478911,0.73545936;0.3876392,0.47465363,0.73448291;0.38654279,0.47038193,0.73348035;0.38550116,0.46609593,0.73245082;0.38451281,0.46179566,0.73139351;0.3835762,0.45748116,0.73030757;0.38268975,0.45315247,0.72919218;0.38185182,0.44880962,0.7280465;0.38106076,0.44445268,0.72686969;0.38031486,0.44008169,0.72566094;0.37961245,0.43569671,0.72441943;0.37895177,0.43129778,0.72314434;0.37833106,0.42688498,0.72183484;0.37774855,0.42245837,0.72049011;0.37720243,0.41801803,0.71910933;0.37669089,0.41356403,0.71769166;0.37621211,0.40909646,0.71623627;0.37576424,0.4046154,0.71474232;0.37534545,0.40012094,0.71320896;0.3749539,0.39561319,0.71163536;0.37458773,0.39109226,0.71002064;0.3742451,0.38655825,0.70836394;0.37392415,0.38201129,0.7066644;0.37362303,0.3774515,0.70492111;0.37333991,0.37287903,0.70313318;0.37307294,0.36829402,0.70129969;0.37282029,0.36369664,0.69941971;0.37258013,0.35908705,0.69749231;0.37235064,0.35446544,0.6955165;0.37212999,0.349832,0.69349132;0.3719164,0.34518697,0.69141574;0.37170804,0.34053056,0.68928875;0.37150314,0.33586303,0.68710929;0.37130003,0.33118458,0.68487633;0.37109685,0.32649557,0.68258873;0.3708918,0.32179632,0.68024534;0.37068312,0.31708718,0.67784499;0.37046904,0.31236853,0.67538648;0.3702478,0.3076408,0.67286859;0.37001764,0.30290445,0.67029004;0.3697768,0.29815996,0.66764952;0.36952351,0.29340788,0.6649457;0.36925602,0.28864881,0.66217719;0.36897256,0.28388339,0.65934258;0.36867134,0.27911233,0.6564404;0.36835059,0.27433641,0.65346914;0.3680085,0.26955647,0.65042726;0.36764328,0.26477344,0.64731318;0.36725311,0.25998832,0.64412527;0.3668366,0.25520194,0.64086184;0.36639158,0.2504157,0.63752117;0.36591607,0.24563096,0.63410149;0.36540817,0.24084915,0.63060103;0.36486595,0.23607183,0.62701797;0.36428747,0.2313007,0.62335047;0.36367073,0.2265376,0.61959664;0.36301372,0.22178452,0.61575461;0.36231439,0.21704365,0.61182247;0.36157068,0.21231734,0.60779834;0.36078129,0.20760765,0.60367993;0.35994327,0.20291779,0.59946566;0.35905442,0.19825076,0.59515371;0.35811253,0.19360973,0.59074229;0.35711536,0.18899812,0.5862297;0.35606065,0.18441957,0.5816143;0.35494612,0.17987796,0.57689459;0.35377006,0.17537711,0.57206861;0.35252969,0.17092163,0.56713551;0.35122252,0.1665162,0.56209448;0.34984626,0.16216558,0.55694478;0.34839867,0.15787473,0.5516859;0.34687754,0.15364873,0.54631766;0.34528103,0.14949272,0.54083967;0.34360674,0.1454121,0.535253;0.34185263,0.14141215,0.5295588;0.34001688,0.13749807,0.52375852;0.33809785,0.13367489,0.51785407;0.33609404,0.12994744,0.51184794;0.33400409,0.12632016,0.50574349;0.33182701,0.12279709,0.49954424;0.32956205,0.11938176,0.49325427;0.32720876,0.11607711,0.48687817;0.32476698,0.1128854,0.48042104;0.32223661,0.10980755,0.47389029;0.31961836,0.10684434,0.46729116;0.31691312,0.10399563,0.46062961;0.31412208,0.10126033,0.45391229;0.31124668,0.09863647,0.44714607;0.30828872,0.09612127,0.44033795;0.30525021,0.09371113,0.433495;0.30213347,0.09140049,0.42662674;0.29894109,0.08918489,0.41973884;0.29567576,0.08705943,0.41283683;0.2923403,0.08501829,0.40592705;0.28893761,0.08305536,0.39901552;0.28547067,0.08116432,0.39210787;0.28194249,0.07933875,0.38520933;0.27835606,0.07757226,0.37832469;0.27471434,0.07585853,0.37145825;0.27102024,0.07419145,0.36461386;0.26727656,0.0725651,0.35779486;0.263486,0.07097387,0.35100416;0.25965113,0.06941247,0.34424417;0.2557744,0.06787594,0.33751691;0.2518586,0.06635773,0.33082656;0.24790678,0.06485041,0.32417842;0.24392,0.06335391,0.31756813;0.23990011,0.0618647,0.31099621;0.23584881,0.06037959,0.30446287;0.23176762,0.05889569,0.29796805;0.22765793,0.05741044,0.29151145;0.2235249,0.0559091,0.28510781;0.21936673,0.05439937,0.2787442;0.21518395,0.05288082,0.27241805;0.21097738,0.05135188,0.26612831;0.20675095,0.04980177,0.25988492;0.20250558,0.04822872,0.25368699;0.19823879,0.04664038,0.24752274;0.19395092,0.04503581,0.24139075;0.18964939,0.04339464,0.2353118;0.18532874,0.04173194,0.22926588;0.18098806,0.04004406,0.22324832;0.17663372,0.03832764,0.21727622;0.1722628,0.0366263,0.21133883;0.16787203,0.03494898,0.20542535;0.16346916,0.03327796,0.19955633;0.15904897,0.03162694,0.19371576;0.15460852,0.03000286,0.18789489;0.15015881,0.02838308,0.18212224;0.1456879,0.02679372,0.17636536;0.14120085,0.02522488,0.17063713;0.13669847,0.02367601,0.16493914;0.13217294,0.02216185,0.15925166;0.13715771,0.0238647,0.16279915;0.142138,0.02560107,0.16632081;0.14712696,0.02735575,0.16981697;0.15211729,0.02913553,0.17328696;0.15711127,0.03093684,0.17673054;0.1621132,0.03275335,0.18014741;0.16711334,0.03459602,0.18353723;0.17212778,0.03644357,0.18689953;0.17714184,0.03831372,0.19023414;0.18216272,0.04019623,0.19354057;0.18719181,0.04204197,0.19681833;0.19222138,0.04385446,0.20006748;0.19726438,0.04562162,0.20328673;0.20231059,0.04735883,0.20647637;0.20736026,0.04906721,0.20963605;0.21242374,0.05073417,0.21276409;0.21748944,0.05237662,0.21586133;0.22256097,0.05399093,0.21892687;0.2276448,0.05556951,0.22195906;0.2327317,0.05712593,0.22495882;0.23782409,0.05865801,0.2279252;0.24292948,0.06015655,0.23085593;0.24803856,0.06163518,0.23375227;0.25315165,0.06309447,0.23661359;0.25827753,0.06452336,0.23943683;0.26340901,0.06593256,0.24222299;0.26854476,0.0673248,0.24497172;0.27368637,0.06869883,0.24768176;0.27883959,0.07004759,0.25035015;0.28399705,0.0713821,0.2529784;0.28915882,0.07270312,0.2555656;0.29432497,0.07401148,0.25811079;0.29950154,0.07529967,0.26061023;0.30468256,0.07657683,0.26306525;0.30986729,0.07784489,0.26547507;0.31505561,0.07910492,0.2678386;0.32024732,0.0803581,0.2701547;0.32544482,0.08160204,0.27242069;0.33064667,0.08283969,0.27463586;0.33585053,0.08407525,0.27680013;0.34105598,0.08531029,0.27891231;0.34626256,0.08654644,0.28097121;0.35146972,0.08778547,0.28297562;0.35667687,0.08902924,0.28492434;0.36188334,0.09027973,0.28681618;0.36708839,0.09153902,0.28864998;0.37229131,0.09280915,0.2904245;0.37749189,0.09409153,0.29213802;0.38268807,0.09539008,0.29379048;0.38787885,0.09670726,0.29538088;0.39306317,0.09804561,0.29690835;0.39823991,0.09940776,0.29837204;0.40340787,0.10079637,0.29977124;0.40856581,0.10221419,0.30110533;0.41371275,0.10366356,0.30237338;0.41884758,0.10514695,0.30357463;0.42396841,0.1066678,0.3047094;0.42907377,0.10822892,0.30577763;0.43416218,0.10983307,0.3067794;0.43923211,0.11148296,0.30771496;0.44428204,0.11318118,0.30858474;0.44931042,0.11493024,0.30938934;0.45431572,0.11673249,0.31012956;0.45929645,0.11859012,0.31080632;0.46425232,0.12050381,0.31141829;0.46918047,0.12247703,0.31196941;0.47407948,0.12451142,0.31246122;0.47894794,0.12660841,0.31289546;0.48378454,0.12876919,0.31327402;0.48858861,0.13099415,0.31359736;0.49335851,0.13328448,0.3138686;0.4980928,0.13564099,0.31409096;0.50279043,0.13806389,0.31426689;0.50745058,0.1405531,0.31439855;0.51207262,0.14310825,0.31448774;0.51665528,0.1457293,0.31453872;0.52119791,0.14841559,0.31455424;0.52569995,0.15116629,0.31453693;0.53016101,0.15398036,0.31448913;0.53458045,0.1568568,0.31441462;0.53895794,0.15979435,0.31431622;0.54329324,0.16279163,0.31419663;0.54758618,0.16584718,0.31405871;0.55183659,0.16895949,0.3139054;0.55604443,0.17212695,0.31373936;0.56020971,0.17534794,0.31356335;0.56433247,0.1786208,0.31338008;0.56841285,0.18194387,0.31319183;0.57245099,0.1853155,0.31300097;0.57644706,0.18873401,0.31281029;0.58040129,0.19219776,0.31262196;0.58431392,0.19570523,0.31243779;0.58818523,0.19925487,0.31225983;0.59201548,0.20284508,0.31209072;0.59580496,0.20647443,0.31193222;0.59955398,0.2101416,0.31178574;0.60326283,0.21384527,0.31165305;0.60693181,0.21758404,0.31153632;0.61056126,0.22135662,0.31143744;0.61415144,0.22516202,0.3113573;0.61770261,0.22899913,0.31129746;0.62121505,0.23286692,0.3112594;0.62468917,0.23676405,0.31124564;0.6281251,0.24068989,0.31125653;0.63152309,0.24464358,0.3112934;0.63488335,0.24862429,0.3113576;0.63820616,0.25263112,0.31145067;0.64149182,0.25666317,0.31157436;0.64474038,0.26072,0.31172919;0.64795203,0.26480095,0.3119164;0.65112691,0.26890541,0.31213721;0.65426523,0.27303275,0.31239299;0.65736724,0.27718218,0.31268539;0.66043291,0.28135348,0.31301496;0.66346234,0.28554617,0.31338289;0.66645563,0.28975979,0.31379035;0.66941285,0.29399391,0.31423853;0.67233423,0.29824791,0.31472899;0.67521975,0.30252154,0.31526265;0.67806939,0.30681452,0.31584052;0.68088318,0.3111265,0.31646379;0.68366117,0.31545715,0.31713364;0.68640337,0.31980615,0.31785128;0.68910996,0.324173,0.31861821;0.69178081,0.32855759,0.31943534;0.6944159,0.33295966,0.32030382;0.69701522,0.33737894,0.32122489;0.69957876,0.34181516,0.32219978;0.70210653,0.34626807,0.3232297;0.7045986,0.35073729,0.32431605;0.70705492,0.35522263,0.32545997;0.70947542,0.3597239,0.32666265;0.7118601,0.36424085,0.32792534;0.71420894,0.36877323,0.3292493;0.71652194,0.37332079,0.3306358;0.71879913,0.37788325,0.33208612;0.72104061,0.38246028,0.3336016;0.72324628,0.38705172,0.33518339;0.72541618,0.3916573,0.33683277;0.72755035,0.39627674,0.33855099;0.72964884,0.40090978,0.34033932;0.73171172,0.40555611,0.34219899;0.73373911,0.41021541,0.34413127;0.73573115,0.41488736,0.34613738;0.73768789,0.41957169,0.34821851;0.73960949,0.42426807,0.35037584;0.7414961,0.42897616,0.35261056;0.74334793,0.43369562,0.35492382;0.74516521,0.43842607,0.35731674;0.74694821,0.44316712,0.35979044;0.74869724,0.44791835,0.36234598;0.75041257,0.4526794,0.36498439;0.75209454,0.45744986,0.36770666;0.75374356,0.46222929,0.37051374;0.75536003,0.46701725,0.37340656;0.75694444,0.47181326,0.37638597;0.75849733,0.47661683,0.37945279;0.76001934,0.48142741,0.38260777;0.76151097,0.48624456,0.38585161;0.76297286,0.49106776,0.38918495;0.76440573,0.49589647,0.39260837;0.76581031,0.50073015,0.39612236;0.76718741,0.50556824,0.39972737;0.76853788,0.51041015,0.40342376;0.76986291,0.51525513,0.40721173;0.77116324,0.52010271,0.41109152;0.77243989,0.5249523,0.41506327;0.77369391,0.52980327,0.41912699;0.77492645,0.53465502,0.42328264;0.77613869,0.53950688,0.42753006;0.77733187,0.54435824,0.43186902;0.77850729,0.54920844,0.43629918;0.77966679,0.55405656,0.44081985;0.78081138,0.55890219,0.4454307;0.78194248,0.56374468,0.45013112;0.7830616,0.5685834,0.45492037;0.78417029,0.57341769,0.45979765;0.78527014,0.57824693,0.46476204;0.78636281,0.58307048,0.46981252;0.78744997,0.58788771,0.474948;0.78853333,0.59269801,0.48016727;0.78961491,0.59750067,0.48546886;0.79069671,0.60229498,0.49085119;0.79178009,0.6070806,0.49631312;0.79286688,0.61185698,0.50185312;0.7939589,0.61662359,0.50746956;0.79505802,0.62137992,0.51316075;0.79616609,0.62612549,0.51892492;0.79728497,0.63085984,0.52476024;0.79841652,0.63558252,0.53066483;0.7995626,0.64029314,0.53663673;0.80072505,0.64499131,0.54267394;0.80190568,0.64967668,0.54877442;0.80310632,0.65434893,0.55493609;0.80432873,0.65900778,0.56115682;0.80557466,0.66365295,0.56743447;0.80684582,0.66828424,0.57376686;0.80814389,0.67290145,0.58015179;0.8094705,0.67750443,0.58658707;0.81082722,0.68209304,0.59307049;0.81221558,0.68666721,0.59959981;0.81363705,0.69122688,0.60617284;0.81509306,0.69577202,0.61278737;0.81658494,0.70030265,0.6194412;0.81811398,0.70481883,0.62613217;0.81968139,0.70932062,0.63285811;0.82128832,0.71380816,0.63961689;0.82293582,0.71828159,0.64640643;0.82462489,0.7227411,0.65322464;0.82635642,0.72718691,0.66006948;0.82813124,0.73161926,0.66693898;0.82995006,0.73603846,0.67383115;0.83181351,0.74044483,0.68074409;0.83372214,0.74483873,0.68767592;0.83567636,0.74922057,0.69462479;0.83767708,0.75359061,0.70158791;0.83972535,0.75794913,0.70856199;0.84181991,0.76229704,0.71554745;0.84396065,0.76663495,0.72254259;0.84614733,0.77096352,0.72954568;0.8483795,0.77528348,0.73655503;0.85065653,0.77959564,0.74356888;0.85297758,0.7839009,0.75058542;0.8553436,0.7881998,0.75759877;0.8577521,0.79249376,0.76460878;0.86020061,0.79678427,0.77161459;0.8626872,0.80107277,0.77861331;0.86520968,0.80536087,0.78560141;0.86776571,0.8096503,0.79257445;0.87035656,0.81394216,0.79951954;0.87297684,0.81823907,0.80643635;0.87562545,0.82254271,0.81331573;0.87830287,0.82685434,0.8201464;0.88101291,0.83117417,0.82691355;0.88376436,0.8355008,0.83359813;0.88656419,0.83983241,0.84019282;0.88942615,0.84416471,0.84668696;0.89236612,0.84849196,0.85307571;0.89540326,0.85280703,0.85935491;0.89854578,0.85710498,0.86554325;0.90180023,0.86138156,0.87165915;0.90516762,0.86563454,0.87772373;0.90864556,0.86986351,0.88375343;0.91222303,0.87407051,0.8897753;0.91589042,0.87825797,0.89580632;0.91963903,0.88242879,0.9018554;0.92345937,0.88658601,0.90793267;0.92734253,0.89073234,0.914049;0.93128235,0.89487013,0.92020762;0.93527444,0.89900167,0.92640565;0.93931328,0.90312833,0.93265281;0.94339574,0.90725141,0.93895042;0.9475205,0.91137261,0.94528884;0.95168443,0.9154922,0.95167893;0.95588623,0.91961077,0.95812116];
+num = size(raw,1);
+raw = flipud(circshift(raw,[fix(num/2),0]));
+%
+% Interpolate ensuring that the first & last colors are not the same:
+vec = linspace(1,num,N+1);
+map = interp1(1:num,raw,vec(1:N),'spline');
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%twilight_shifted
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/matplotlib/virdis_colors.mat b/Requirements/matplotlib/virdis_colors.mat
new file mode 100644
index 0000000000000000000000000000000000000000..15f62e51ec9e21c101ef8f66f0a337edb9f0e28b
Binary files /dev/null and b/Requirements/matplotlib/virdis_colors.mat differ
diff --git a/Requirements/matplotlib/viridis.m b/Requirements/matplotlib/viridis.m
new file mode 100644
index 0000000000000000000000000000000000000000..c17486784ec3d0f22019663f9f7815b109530074
--- /dev/null
+++ b/Requirements/matplotlib/viridis.m
@@ -0,0 +1,83 @@
+function [map,num] = viridis(N)
+% Perceptually uniform sequential colormap from MatPlotLib.
+%
+% Copyright (c) 2017-2022 Stephen Cobeldick
+%
+%%% Syntax:
+%  map = viridis
+%  map = viridis(N)
+%
+% Colormap designed by Eric Firing, Nathaniel J. Smith, and Stefan van der Walt.
+%
+% For MatPlotLib 2.0 improved colormaps were created in the perceptually
+% uniform colorspace CAM02-UCS. The new colormaps are introduced here:
+% <http://matplotlib.org/2.0.0rc2/users/dflt_style_changes.html>
+% The RGB data is from here: <https://bids.github.io/colormap/>
+%
+% Note VIRIDIS replaces the awful JET as the MatPlotLib default colormap.
+%
+%% Examples %%
+%
+%%% Plot the scheme's RGB values:
+% rgbplot(viridis(256))
+%
+%%% New colors for the COLORMAP example:
+% load spine
+% image(X)
+% colormap(viridis)
+%
+%%% New colors for the SURF example:
+% [X,Y,Z] = peaks(30);
+% surfc(X,Y,Z)
+% colormap(viridis)
+% axis([-3,3,-3,3,-10,5])
+%
+%% Input and Output Arguments %%
+%
+%%% Inputs (**=default):
+% N = NumericScalar, N>=0, an integer to define the colormap length.
+%   = []**, same length as MATLAB's inbuilt colormap functions.
+%
+%%% Outputs:
+% map = NumericMatrix, size Nx3, a colormap of RGB values between 0 and 1.
+%
+% See also CIVIDIS INFERNO MAGMA PLASMA TWILIGHT TWILIGHT_SHIFTED
+% TAB10 TAB20 TAB20B TAB20C
+% BREWERMAP CUBEHELIX MAXDISTCOLOR PARULA LINES COLORMAP SET
+
+if nargin<1 || isnumeric(N)&&isequal(N,[])
+	N = cmDefaultN();
+else
+	assert(isscalar(N)&&isfinite(N)&&isreal(N),...
+		'SC:viridis:N:NotRealFiniteScalarNumeric',...
+		'First argument <N> must be a real finite numeric scalar.')
+end
+%
+raw = [0.267004,0.004874,0.329415; 0.268510,0.009605,0.335427; 0.269944,0.014625,0.341379; 0.271305,0.019942,0.347269; 0.272594,0.025563,0.353093; 0.273809,0.031497,0.358853; 0.274952,0.037752,0.364543; 0.276022,0.044167,0.370164; 0.277018,0.050344,0.375715; 0.277941,0.056324,0.381191; 0.278791,0.062145,0.386592; 0.279566,0.067836,0.391917; 0.280267,0.073417,0.397163; 0.280894,0.078907,0.402329; 0.281446,0.084320,0.407414; 0.281924,0.089666,0.412415; 0.282327,0.094955,0.417331; 0.282656,0.100196,0.422160; 0.282910,0.105393,0.426902; 0.283091,0.110553,0.431554; 0.283197,0.115680,0.436115; 0.283229,0.120777,0.440584; 0.283187,0.125848,0.444960; 0.283072,0.130895,0.449241; 0.282884,0.135920,0.453427; 0.282623,0.140926,0.457517; 0.282290,0.145912,0.461510; 0.281887,0.150881,0.465405; 0.281412,0.155834,0.469201; 0.280868,0.160771,0.472899; 0.280255,0.165693,0.476498; 0.279574,0.170599,0.479997; 0.278826,0.175490,0.483397; 0.278012,0.180367,0.486697; 0.277134,0.185228,0.489898; 0.276194,0.190074,0.493001; 0.275191,0.194905,0.496005; 0.274128,0.199721,0.498911; 0.273006,0.204520,0.501721; 0.271828,0.209303,0.504434; 0.270595,0.214069,0.507052; 0.269308,0.218818,0.509577; 0.267968,0.223549,0.512008; 0.266580,0.228262,0.514349; 0.265145,0.232956,0.516599; 0.263663,0.237631,0.518762; 0.262138,0.242286,0.520837; 0.260571,0.246922,0.522828; 0.258965,0.251537,0.524736; 0.257322,0.256130,0.526563; 0.255645,0.260703,0.528312; 0.253935,0.265254,0.529983; 0.252194,0.269783,0.531579; 0.250425,0.274290,0.533103; 0.248629,0.278775,0.534556; 0.246811,0.283237,0.535941; 0.244972,0.287675,0.537260; 0.243113,0.292092,0.538516; 0.241237,0.296485,0.539709; 0.239346,0.300855,0.540844; 0.237441,0.305202,0.541921; 0.235526,0.309527,0.542944; 0.233603,0.313828,0.543914; 0.231674,0.318106,0.544834; 0.229739,0.322361,0.545706; 0.227802,0.326594,0.546532; 0.225863,0.330805,0.547314; 0.223925,0.334994,0.548053; 0.221989,0.339161,0.548752; 0.220057,0.343307,0.549413; 0.218130,0.347432,0.550038; 0.216210,0.351535,0.550627; 0.214298,0.355619,0.551184; 0.212395,0.359683,0.551710; 0.210503,0.363727,0.552206; 0.208623,0.367752,0.552675; 0.206756,0.371758,0.553117; 0.204903,0.375746,0.553533; 0.203063,0.379716,0.553925; 0.201239,0.383670,0.554294; 0.199430,0.387607,0.554642; 0.197636,0.391528,0.554969; 0.195860,0.395433,0.555276; 0.194100,0.399323,0.555565; 0.192357,0.403199,0.555836; 0.190631,0.407061,0.556089; 0.188923,0.410910,0.556326; 0.187231,0.414746,0.556547; 0.185556,0.418570,0.556753; 0.183898,0.422383,0.556944; 0.182256,0.426184,0.557120; 0.180629,0.429975,0.557282; 0.179019,0.433756,0.557430; 0.177423,0.437527,0.557565; 0.175841,0.441290,0.557685; 0.174274,0.445044,0.557792; 0.172719,0.448791,0.557885; 0.171176,0.452530,0.557965; 0.169646,0.456262,0.558030; 0.168126,0.459988,0.558082; 0.166617,0.463708,0.558119; 0.165117,0.467423,0.558141; 0.163625,0.471133,0.558148; 0.162142,0.474838,0.558140; 0.160665,0.478540,0.558115; 0.159194,0.482237,0.558073; 0.157729,0.485932,0.558013; 0.156270,0.489624,0.557936; 0.154815,0.493313,0.557840; 0.153364,0.497000,0.557724; 0.151918,0.500685,0.557587; 0.150476,0.504369,0.557430; 0.149039,0.508051,0.557250; 0.147607,0.511733,0.557049; 0.146180,0.515413,0.556823; 0.144759,0.519093,0.556572; 0.143343,0.522773,0.556295; 0.141935,0.526453,0.555991; 0.140536,0.530132,0.555659; 0.139147,0.533812,0.555298; 0.137770,0.537492,0.554906; 0.136408,0.541173,0.554483; 0.135066,0.544853,0.554029; 0.133743,0.548535,0.553541; 0.132444,0.552216,0.553018; 0.131172,0.555899,0.552459; 0.129933,0.559582,0.551864; 0.128729,0.563265,0.551229; 0.127568,0.566949,0.550556; 0.126453,0.570633,0.549841; 0.125394,0.574318,0.549086; 0.124395,0.578002,0.548287; 0.123463,0.581687,0.547445; 0.122606,0.585371,0.546557; 0.121831,0.589055,0.545623; 0.121148,0.592739,0.544641; 0.120565,0.596422,0.543611; 0.120092,0.600104,0.542530; 0.119738,0.603785,0.541400; 0.119512,0.607464,0.540218; 0.119423,0.611141,0.538982; 0.119483,0.614817,0.537692; 0.119699,0.618490,0.536347; 0.120081,0.622161,0.534946; 0.120638,0.625828,0.533488; 0.121380,0.629492,0.531973; 0.122312,0.633153,0.530398; 0.123444,0.636809,0.528763; 0.124780,0.640461,0.527068; 0.126326,0.644107,0.525311; 0.128087,0.647749,0.523491; 0.130067,0.651384,0.521608; 0.132268,0.655014,0.519661; 0.134692,0.658636,0.517649; 0.137339,0.662252,0.515571; 0.140210,0.665859,0.513427; 0.143303,0.669459,0.511215; 0.146616,0.673050,0.508936; 0.150148,0.676631,0.506589; 0.153894,0.680203,0.504172; 0.157851,0.683765,0.501686; 0.162016,0.687316,0.499129; 0.166383,0.690856,0.496502; 0.170948,0.694384,0.493803; 0.175707,0.697900,0.491033; 0.180653,0.701402,0.488189; 0.185783,0.704891,0.485273; 0.191090,0.708366,0.482284; 0.196571,0.711827,0.479221; 0.202219,0.715272,0.476084; 0.208030,0.718701,0.472873; 0.214000,0.722114,0.469588; 0.220124,0.725509,0.466226; 0.226397,0.728888,0.462789; 0.232815,0.732247,0.459277; 0.239374,0.735588,0.455688; 0.246070,0.738910,0.452024; 0.252899,0.742211,0.448284; 0.259857,0.745492,0.444467; 0.266941,0.748751,0.440573; 0.274149,0.751988,0.436601; 0.281477,0.755203,0.432552; 0.288921,0.758394,0.428426; 0.296479,0.761561,0.424223; 0.304148,0.764704,0.419943; 0.311925,0.767822,0.415586; 0.319809,0.770914,0.411152; 0.327796,0.773980,0.406640; 0.335885,0.777018,0.402049; 0.344074,0.780029,0.397381; 0.352360,0.783011,0.392636; 0.360741,0.785964,0.387814; 0.369214,0.788888,0.382914; 0.377779,0.791781,0.377939; 0.386433,0.794644,0.372886; 0.395174,0.797475,0.367757; 0.404001,0.800275,0.362552; 0.412913,0.803041,0.357269; 0.421908,0.805774,0.351910; 0.430983,0.808473,0.346476; 0.440137,0.811138,0.340967; 0.449368,0.813768,0.335384; 0.458674,0.816363,0.329727; 0.468053,0.818921,0.323998; 0.477504,0.821444,0.318195; 0.487026,0.823929,0.312321; 0.496615,0.826376,0.306377; 0.506271,0.828786,0.300362; 0.515992,0.831158,0.294279; 0.525776,0.833491,0.288127; 0.535621,0.835785,0.281908; 0.545524,0.838039,0.275626; 0.555484,0.840254,0.269281; 0.565498,0.842430,0.262877; 0.575563,0.844566,0.256415; 0.585678,0.846661,0.249897; 0.595839,0.848717,0.243329; 0.606045,0.850733,0.236712; 0.616293,0.852709,0.230052; 0.626579,0.854645,0.223353; 0.636902,0.856542,0.216620; 0.647257,0.858400,0.209861; 0.657642,0.860219,0.203082; 0.668054,0.861999,0.196293; 0.678489,0.863742,0.189503; 0.688944,0.865448,0.182725; 0.699415,0.867117,0.175971; 0.709898,0.868751,0.169257; 0.720391,0.870350,0.162603; 0.730889,0.871916,0.156029; 0.741388,0.873449,0.149561; 0.751884,0.874951,0.143228; 0.762373,0.876424,0.137064; 0.772852,0.877868,0.131109; 0.783315,0.879285,0.125405; 0.793760,0.880678,0.120005; 0.804182,0.882046,0.114965; 0.814576,0.883393,0.110347; 0.824940,0.884720,0.106217; 0.835270,0.886029,0.102646; 0.845561,0.887322,0.099702; 0.855810,0.888601,0.097452; 0.866013,0.889868,0.095953; 0.876168,0.891125,0.095250; 0.886271,0.892374,0.095374; 0.896320,0.893616,0.096335; 0.906311,0.894855,0.098125; 0.916242,0.896091,0.100717; 0.926106,0.897330,0.104071; 0.935904,0.898570,0.108131; 0.945636,0.899815,0.112838; 0.955300,0.901065,0.118128; 0.964894,0.902323,0.123941; 0.974417,0.903590,0.130215; 0.983868,0.904867,0.136897; 0.993248,0.906157,0.143936];
+num = size(raw,1);
+%
+% With small extrapolation when N>num:
+vec = linspace(0,num+1,N+2);
+map = interp1(1:num,raw,vec(2:N+1),'linear','extrap');
+% Interpolation only for all values of N:
+%map = interp1(1:num,raw,linspace(1,num,N),'spline')
+%
+map = max(0,min(1,map));
+%
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%viridis
+function N = cmDefaultN()
+% Get the colormap size from the current figure or default colormap.
+try
+	F = get(groot,'CurrentFigure');
+catch %#ok<CTCH> pre HG2
+	N = size(get(gcf,'colormap'),1);
+	return
+end
+if isempty(F)
+	N = size(get(groot,'DefaultFigureColormap'),1);
+else
+	N = size(F.Colormap,1);
+end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%cmDefaultN
\ No newline at end of file
diff --git a/Requirements/spider_plot/LICENSE.txt b/Requirements/spider_plot/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..68b8f85b741761c261db8da7365fa723202846f6
--- /dev/null
+++ b/Requirements/spider_plot/LICENSE.txt
@@ -0,0 +1,24 @@
+Copyright (c) 2020-2021, Moses
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Requirements/spider_plot/README.md b/Requirements/spider_plot/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..86449fd74ed3cb7b45d1ad96cd71a8b35a33d05e
--- /dev/null
+++ b/Requirements/spider_plot/README.md
@@ -0,0 +1,658 @@
+[![View spider_plot on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://www.mathworks.com/matlabcentral/fileexchange/59561-spider_plot)
+
+# spider_plot
+Create a spider or radar plot with customizable individual axes.
+
+The three functions included have the same functionality but with 3 different implementation:
+- **spider_plot()** is compatible with most MATLAB versions.
+- **spider_plot_R2019b()** is compatible with R2019b and above. It uses the new argument validation feature.
+- **spider_plot_class()** is compatible with R2019b and above. It uses the new chart class feature.
+
+## Syntax:
+**spider_plot(P)**
+
+**spider_plot(P, Name, Value, ...)**
+
+**h = spider_plot(_)**
+
+## Input Arguments:
+*(Required)*
+
+- **P** - The data points used to plot the spider chart. The rows are the groups of data and the columns are the data points.
+          The axes labels and axes limits are automatically generated if not specified.
+          [vector | matrix]
+
+## Output Arguments:
+*(Optional)*
+- **h**                - Figure handle of spider plot.
+                         [figure object]
+
+## Name-Value Pair Arguments:
+*(Optional)*
+  
+- **AxesLabels**       - Used to specify the label each of the axes.
+                         [auto-generated (default) | cell of strings | 'none']
+
+- **AxesInterval**     - Used to change the number of intervals displayed between the webs.
+                         [3 (default) | integer]
+
+- **AxesPrecision**    - Used to change the precision level on the value displayed on the axes.
+                         [1 (default) | integer | vector]
+                         
+- **AxesDisplay**      - Used to change the number of axes in which the axes text are displayed. 'None' or 'one' can be used to simplify the plot appearance for normalized data.
+                         ['all' (default) | 'none' | 'one' | 'data']
+
+- **AxesLimits**       - Used to manually set the axes limits. A matrix of 2 x size(P, 2). The top row is the minimum axes limits and the bottow row is the maximum axes limits.
+                         [auto-scaled (default) | matrix]
+
+- **FillOption**       - Used to toggle fill color option.
+                         ['off' (default) | 'on' | cell array of character vectors]
+
+- **FillTransparency** - Used to set fill color transparency.
+                         [0.1 (default) | scalar in range (0, 1) | vector]
+                     
+- **Color**            - Used to specify the line color, specified as an RGB triplet. The intensities must be in the range (0, 1).
+                         [MATLAB colors (default) | RGB triplet]
+
+- **LineStyle**        - Used to change the line style of the plots.
+                         ['-' (default) | '--' | ':' | '-.' | 'none' | cell array of character vectors]
+
+- **LineWidth**        - Used to change the line width, where 1 point is  1/72 of an inch.
+                         [0.5 (default) | positive value | vector]
+                         
+- **LineTransparency** - Used to set the line color transparency.
+                         [1 (default) | scalar in range (0, 1) | vector]
+
+- **Marker**           - Used to change the marker symbol of the plots.
+                         ['o' (default) | '*' | 's' | 'd' | '+' | '.' | 'x' | '^' | 'v' | 'h' | 'none' | cell array of character vectors]
+
+- **MarkerSize**       - Used to change the marker size, where 1 point is 1/72 of an inch.
+                         [36 (default) | positive value | vector]
+                         
+- **MarkerTransparency** - Used to set the marker color transparency.
+                         [1 (default) | scalar in range (0, 1) | vector]
+                         
+- **AxesFont**         - Used to change the font type of the values displayed on the axes.
+                         [Helvetica (default) | supported font name]
+                         
+- **LabelFont**        - Used to change the font type of the labels.
+                         [Helvetica (default) | supported font name]                     
+                     
+- **AxesFontSize**     - Used to change the font size of the values displayed on the axes.
+                         [10 (default) | scalar value greater than zero]
+                         
+- **AxesFontColor**    - Used to change the font color of the values displayed on the axes.
+                         [black (default) | RGB triplet]
+                         
+- **LabelFontSize**    - Used to change the font size of the labels.
+                         [10 (default) | scalar value greater than zero]
+                         
+- **Direction**        - Used to change the direction of rotation of the plotted data and axis labels.
+                         ['clockwise' (default) | 'counterclockwise']
+                         
+- **AxesDirection**    - Used to change the direction of axes.
+                         ['normal' (default) | 'reverse' | cell array of character vectors]
+                         
+- **AxesLabelsOffset** - Used to adjust the position offset of the axes labels.
+                         [0.2 (default) | positive value]
+
+- **AxesDataOffset**   - Used to adjust the position offset of the data labels when AxesDisplay is set to 'data'.
+                         [0.1 (default) | positive value]
+                         
+- **AxesScaling**      - Used to change the scaling of the axes.
+                         ['linear' (default) | 'log' | cell array of character vectors]
+                         
+- **AxesColor**        - Used to change the color of the spider axes.
+                         [grey (default) | RGB triplet | hexadecimal color code]
+                         
+- **AxesLabelsEdge**   - Used to change the edge color of the axes labels.
+                         [black (default) | RGB triplet | hexadecimal color code | 'none']
+
+- **AxesOffset**       - Used to change to axes offset from the origin.
+                         [1 (default) | any integer less than the axes interval]
+
+- **AxesZoom**         - Used to change zoom of axes.
+                         [0.7 (default) | scalar in range (0, 1)]
+
+- **AxesHorzAlign**    - Used to change the horizontal alignment of axes tick labels.
+                         ['center' (default) | 'left' | 'right' | 'quadrant']
+
+- **AxesVertAlign**    - Used to change the vertical aligment of axes tick labels.
+                         ['middle' (default) | 'top' | 'cap' | 'bottom' | 'baseline' | 'quadrant']
+
+- **PlotVisible**      - Used to change the visibility of the plotted lines and markers.
+                         ['on' (default) | 'off']
+
+- **AxesTickLabels**   - Used to change the axes tick labels.
+                         ['data' (default) | cell array of character vectors]
+
+- **AxesInterpreter**  - Used to change the text interpreter of axes labels and axes tick labels.
+                         ['tex' (default) | 'latex' | 'none' | cell array of character vectors]
+
+- **BackgroundColor**  - Used to change the color of the background.
+                         ['white' (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+
+- **MinorGrid**        - Used to toggle the minor grid.
+                         ['off' (default) | 'on']
+
+- **MinorGridInterval**- Used to change number of minor grid lines in between the major grid lines.
+                         [2 (default) | integer value greater than zero]
+
+- **AxesZero**         - Used to add a reference axes at value zero.
+                         ['off' (default) | 'on']
+
+- **AxesZeroColor**    - Used to change the color of the zero reference axes.
+                         ['black' (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+
+- **AxesZeroWidth**    - Used to change the line width of the zero reference axes.
+                         [2 (default) | positive value]
+
+- **AxesRadial**       - Used to toggle radial axes.
+                         ['on' (default) | 'off']
+
+- **AxesAngular**      - Used to toggle angular axes.
+                         ['on' (default) | 'off']
+
+- **AxesShaded**       - Used to toggle shaded area around axes.
+                         ['off' (default) | 'on']
+
+- **AxesShadedLimits** - Used to set the limits of the shaded area. A matrix of 2 x size(P, 2). The top row is the minimum axes limits and the bottow row is the maximum axes limits.
+                         [AxesLimits (default) | matrix]
+
+- **AxesShadedColor**  - Used to change the color of the shaded area.
+                         ['green' | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+
+- **AxesShadedTransparency**- Used to the shaded area transparency.
+                              [0.2 (default) | scalar in range (0, 1)] 
+
+- **AxesLabelsRotate** - Used to rotate the axes labels to be aligned with axes.
+                         ['off' (default) | 'on']
+
+
+*(spider_plot_class only properties)*
+- **LegendLabels**      - Used to add the labels to the legend.
+                          [cell array of character vectors]
+                         
+- **LegendHandle**      - Used to customize legend settings.
+                          [legend handle object]
+                         
+- **TiledLayoutHandle** - Used to customize tiled layout settings.
+                          [tiled chart layout handle object]
+
+- **TiledLegendHandle** - Used to customize tiled legend settings.
+                          [legend handle object of tiled layout]
+
+- **NextTileIter**      - Iterates with consecutive tile plots.
+                          [1 (default)]
+                         
+## Examples:
+### Example 1: Minimal number of arguments. All optional arguments are set to their default values. Axes labels and limits are automatically set.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];   
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P);
+
+% Legend settings
+legend('D1', 'D2', 'D3', 'Location', 'southoutside');
+```
+<p align="center">
+  <img src="screenshot/example1.PNG">
+</p>
+
+
+### Example 2: Manually setting the axes limits and axes precision. All other optional arguments are set to their default values.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];   
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesLimits', [1, 2, 1, 1, 1; 10, 8, 9, 5, 10],... % [min axes limits; max axes limits]
+    'AxesPrecision', [0, 1, 1, 1, 1]);
+```
+<p align="center">
+  <img src="screenshot/example2.png">
+</p>
+
+
+### Example 3: Set fill option on. The fill transparency can be adjusted.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];   
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesLabels', {'S1', 'S2', 'S3', 'S4', 'S5'},...
+    'AxesInterval', 2,...
+    'FillOption', {'on', 'on', 'off'},...
+    'FillTransparency', [0.2, 0.1, 0.1]);
+```
+<p align="center">
+  <img src="screenshot/example3.PNG">
+</p>
+
+
+  ### Example 4: Maximum number of arguments.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];   
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesLabels', {'S1', 'S2', 'S3', 'S4', 'S5'},...
+    'AxesInterval', 4,...
+    'AxesPrecision', 0,...
+    'AxesDisplay', 'one',...
+    'AxesLimits', [1, 2, 1, 1, 1; 10, 8, 9, 5, 10],...
+    'FillOption', 'on',...
+    'FillTransparency', 0.2,...
+    'Color', [1, 0, 0; 0, 1, 0; 0, 0, 1],...
+    'LineStyle', {'--', '-', '--'},...
+    'LineWidth', [1, 2, 3],...
+    'LineTransparency', 1,...
+    'Marker', {'o', 'd', 's'},...
+    'MarkerSize', [8, 10, 12],...
+    'MarkerTransparency', 1,...
+    'AxesFont', 'Times New Roman',...
+    'LabelFont', 'Times New Roman',...
+    'AxesFontSize', 12,...
+    'LabelFontSize', 10,...
+    'Direction', 'clockwise',...
+    'AxesDirection', {'reverse', 'normal', 'normal', 'normal', 'normal'},...
+    'AxesLabelsOffset', 0.2,...
+    'AxesDataOffset', 0.1,...
+    'AxesScaling', 'linear',...
+    'AxesColor', [0.6, 0.6, 0.6],...
+    'AxesLabelsEdge', 'none',...
+    'AxesOffset', 1,...
+    'AxesZoom', 1,...
+    'AxesHorzAlign', 'quadrant',...
+    'AxesVertAlign', 'quadrant',...
+    'PlotVisible', 'on',...
+    'AxesTickLabels', 'data',...
+    'AxesInterpreter', 'tex',...
+    'BackgroundColor' , 'w',...
+    'MinorGrid', 'off',...
+    'MinorGridInterval', 2,...
+    'AxesZero', 'off',...
+    'AxesZeroColor', 'k',...
+    'AxesZeroWidth', 2,...
+    'AxesRadial', 'on',...
+    'AxesAngular', 'on',...
+    'AxesShaded', 'off',...
+    'AxesShadedLimits', [],...
+    'AxesShadedColor', 'g',...
+    'AxesShadedTransparency', 0.2,...
+    'AxesLabelsRotate', 'off');
+```
+<p align="center">
+  <img src="screenshot/example4.png">
+</p>
+
+
+  ### Example 5: Excel-like radar charts.
+```matlab
+% Initialize data points
+D1 = [5 0 3 4 4]; 
+D2 = [2 1 5 5 4];
+P = [D1; D2];
+
+% Spider plot
+spider_plot(P,...
+    'AxesInterval', 5,...
+    'AxesPrecision', 0,...
+    'AxesDisplay', 'one',...
+    'AxesLimits', [0, 0, 0, 0, 0; 5, 5, 5, 5, 5],...
+    'FillOption', 'on',...
+    'FillTransparency', 0.1,...
+    'Color', [139, 0, 0; 240, 128, 128]/255,...
+    'LineWidth', 4,...
+    'Marker', 'none',...
+    'AxesFontSize', 14,...
+    'LabelFontSize', 10,...
+    'AxesColor', [0.8, 0.8, 0.8],...
+    'AxesLabelsEdge', 'none',...
+    'AxesRadial', 'off');
+
+% Title and legend settings
+title(sprintf('Excel-like Radar Chart'),...
+    'FontSize', 14);
+legend_str = {'D1', 'D2'};
+legend(legend_str, 'Location', 'southoutside');
+```
+<p align="center">
+  <img src="screenshot/example5.png">
+</p>
+
+
+  ### Example 6: Logarithimic scale on specified axes. Axes limits and axes intervals can be individually set as well.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 1];
+D2 = [5 8 7 2 10];
+D3 = [8 2 1 4 100];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesInterval', 2,...
+    'AxesPrecision', 0,...
+    'AxesFontSize', 10,...
+    'AxesLabels', {'Linear Scale', 'Linear Scale', 'Linear Scale', 'Linear Scale', 'Logarithimic Scale'},...
+    'AxesScaling', {'linear', 'linear', 'linear', 'linear', 'log'},...
+    'AxesLimits', [1, 1, 1, 1, 1; 10, 10, 10, 10, 100]);
+    
+% Legend properties
+legend('D1', 'D2', 'D3', 'Location', 'northeast');
+```
+<p align="center">
+  <img src="screenshot/example6.png">
+</p>
+
+
+  ### Example 7a: Spider plot with tiledlayout feature in R2019b.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Titled layout
+t = tiledlayout(2, 2);
+
+% Tile 1
+nexttile;
+spider_plot_R2019b(P,...
+    'AxesInterval', 1,...
+    'AxesPrecision', 0);
+
+% Tile 2
+nexttile;
+spider_plot_R2019b(P,...
+    'AxesInterval', 1,...
+    'AxesPrecision', 0);
+
+% Tile 3
+nexttile(3, [1, 2]);
+spider_plot_R2019b(P,...
+    'AxesInterval', 1,...
+    'AxesPrecision', 0);
+
+% Tile properties
+t.TileSpacing = 'compact';
+t.Padding = 'compact';
+title(t, 'Spider Plots');
+```
+<p align="center">
+  <img src="screenshot/example7.PNG">
+</p>
+
+### Example 7b: Spider plot class with tiledlayout feature.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+close all;
+clc;
+
+% Individual spider plots
+figure;
+s1 = spider_plot_class(P);
+s1.LegendLabels = {'Data1a', 'Data1b', 'Data1c'};
+s1.AxesZoom = 1;
+s1.AxesHorzAlign = 'quadrant';
+s1.AxesVertAlign = 'quadrant';
+
+figure;
+s2 = spider_plot_class(P);
+s2.LegendLabels = {'Data2a', 'Data2b', 'Data2c'};
+s2.AxesZoom = 1;
+s2.AxesHorzAlign = 'center';
+s2.AxesVertAlign = 'top';
+
+figure;
+s3 = spider_plot_class(P);
+s3.LegendLabels = {'Data3a', 'Data3b', 'Data3c'};
+s3.AxesZoom = 1;
+s3.AxesHorzAlign = 'left';
+s3.AxesVertAlign = 'middle';
+
+% Tiled layout
+s1.tiledlayout(2, 2);
+
+% Next tiles
+s1.nexttile(s1);
+s1.nexttile(s2);
+s1.nexttile(s3, 3, [1, 2]);
+
+% Tiled layout settings
+s1.TiledLayoutHandle.TileSpacing = 'none';
+s1.TiledLayoutHandle.Padding = 'compact';
+title(s1.TiledLayoutHandle, "Spider Plots");
+
+% Legend settings
+s1.tiledlegend('FontSize', 8);
+s1.TiledLegendHandle.Layout.TileSpan = [1, 2];
+s1.TiledLegendHandle.Layout.Tile = 1;
+```
+<p align="center">
+  <img src="screenshot/example7b.PNG">
+</p>
+
+### Example 8: Spider plot with values only on data points.
+```matlab
+% Initialize data points
+D1 = [1 3 4 1 2];
+D2 = [5 8 7 5 9];
+P = [D1; D2];
+
+% Spider plot
+s = spider_plot_class(P);
+s.AxesLimits = [1, 1, 1, 1, 1; 10, 10, 10, 10, 10];
+s.AxesDisplay = 'data';
+s.AxesLabelsOffset = 0.2;
+s.AxesDataOffset = 0.1;
+s.AxesFontColor = [0, 0, 1; 1, 0, 0];
+
+% Legend properties
+s.LegendLabels = {'D1', 'D2'};
+s.LegendHandle.Location = 'northeastoutside';
+```
+<p align="center">
+  <img src="screenshot/example8.PNG">
+</p>
+
+### Example 9: Spider plot with text as axes tick labels.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesTickLabels', {'first', 'second', 'third', 'fourth'});
+```
+<p align="center">
+  <img src="screenshot/example9.png">
+</p>
+
+### Example 10: Spider plot with interpreter setting customized for each axes label.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesLabels', {'\beta=1', '$\int_1^{20} x^2 dx$', '$\mathcal{O}$', 'Normal', 'Normal'},...
+    'AxesInterpreter', {'tex', 'latex', 'latex', 'none', 'none'});
+```
+<p align="center">
+  <img src="screenshot/example10.PNG">
+</p>
+
+### Example 11: Spider plot with shaded area around axes.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2];
+D2 = [5 8 7 2 9];
+D3 = [8 2 1 4 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+      'AxesShaded', 'on',...
+      'AxesShadedLimits', [5.5, 4, 3, 2, 4; 7, 6.5, 6, 3.5, 6]); % [min axes limits; max axes limits]
+```
+<p align="center">
+  <img src="screenshot/example11.png">
+</p>
+
+### Example 12: Spider plot with rotated axes labels. This is useful when you have many labels that would otherwise overlap.
+```matlab
+% Initialize data points
+D1 = [5 3 9 1 2 2 9 3 1 9 8 7 2 3 6];
+D2 = [5 8 7 2 9 7 6 4 8 9 2 1 8 2 4];
+D3 = [8 2 1 4 6 1 8 4 2 3 7 5 6 1 6];
+P = [D1; D2; D3];
+
+% Spider plot
+spider_plot(P,...
+    'AxesLimits', [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;...
+    10 10 10 10 10 10 10 10 10 10 10 10 10 10 10],...
+    'AxesInterval', 5,...
+    'AxesDisplay', 'one',...
+    'AxesPrecision', 0,...
+    'AxesLabelsRotate', 'on',...
+    'AxesLabelsOffset', 0.1,...
+    'AxesRadial', 'off');
+```
+<p align="center">
+  <img src="screenshot/example12.png">
+</p>
+
+## Author:
+Moses Yoo, (juyoung.m.yoo at gmail dot com)
+- 2022-03-23: Adjust rotated axes label alignment to be closer to axes.
+
+- 2022-03-21: Allow axes labels to be rotated to be aligned with axes.
+
+- 2022-03-17: Allow a shaded band to be plotted around the axes.
+
+- 2022-02-14: Add support for reference axes at value zero. Allow for toggling radial and angular axes on or off.
+
+- 2022-01-23: Add ability to change figure/axes background color. Allow for toggling minor grid lines.
+
+- 2022-01-03: Fix legend to include line and marker attributes.
+
+- 2021-11-24: Fix axes labels misalignment. Add option to set offset for data display values.
+
+- 2021-11-09: Add option to change the text interpreter of axes labels and axes tick labels.
+
+- 2021-11-01: Allow for plot lines and markers to be hidden. Allow for custom text of axes tick labels.
+
+- 2021-04-17: Fix data display values when log scale is set.
+
+- 2021-04-13: Add option to adjust line and marker transparency.
+
+- 2021-04-08: Add option for data values to be displayed on axes. Add support to adjust axes font colors.
+
+- 2021-03-19: Allow legend to be global in tiledlayout in spider_plot_class. Allow axes values to be shifted. Allow axes zoom level to be adjusted.
+
+- 2021-03-17: Implement tiledlayout and nexttile compatibility in spider_plot_class.
+
+- 2020-12-09: Allow fill option and fill transparency for each data group.
+
+- 2020-12-01: Added support for adjust the axes offset from origin.
+
+- 2020-11-30: Allow for one data group without specified axes limits.
+
+- 2020-11-30: Added support for changing axes and label font type.
+
+- 2020-10-08: Adjust axes precision to be set to one or more axis.
+
+- 2020-09-30: Updated examples and added ability to reverse axes direction.
+
+- 2020-07-05: Added feature to change spider axes and axes labels edge color.
+
+- 2020-06-17: Allow logarithmic scale to be set to one or more axis.
+
+- 2020-03-26: Added feature to allow different line styles, line width, marker type, and marker sizes for the data groups.
+
+- 2020-02-17: Major revision in converting the function into a custom chart class. New feature introduced in R2019b.
+
+- 2020-02-12: Fixed condition and added error checking for when only one data group is plotted.
+
+- 2020-01-27: Corrected bug where only 7 entries were allowed in legend.
+
+- 2020-01-06: Added support for subplot and tiledlayout feature (tiledlayout introduced in R2019b).
+
+- 2019-11-27: Add option to change axes to logarithmic scale.
+
+- 2019-11-15: Add feature to customize the plot rotational direction and the offset position of the axis labels.
+
+- 2019-10-28: Major revision in implementing the new function argument validation feature introduced in R2019b. Replaced previous method of error checking and setting of default values.
+
+- 2019-10-23: Minor revision to set starting axes as the vertical line. Add customization option for font sizes and axes display.
+  
+- 2019-10-16: Minor revision to add name-value pairs for customizing color, marker, and line settings.
+  
+- 2019-10-08: Another major revision to convert to name-value pairs and add color fill option.
+  
+- 2019-09-17: Major revision to improve speed, clarity, and functionality
+
+## Special Thanks:
+Special thanks to the following people for their feature recommendations and bug finds.
+- Gabriela Andrade
+- Andrés Garcia
+- Jiro Doke
+- Alex Grenyer
+- Tobias Kern
+- Omar Hadri
+- Zafar Ali
+- Christophe Hurlin
+- Sean de Wolski
+- Roman
+- Mariusz Sepczuk
+- Mohamed Abubakr
+- Maruis Mueller
+- Nicolai
+- Jingwei Too
+- Cedric Jamet
+- Richard Ruff
+- Marie-Kristin Schreiber
+- Jean-Baptise Billaud
+- Juan Carlos Vargas Rubio
+- Anthony Wang
+- Hanting Zhu
+- Pauline Oeuvray
+- Oliver Nicholls
+- Yu-Chi Chen
+- Fabrizio De Caro
+- Waqas Ahmad
+- Mario Di Siena
+- Rebecca
+- Nikolaos Koutsouleris
+
+[![View spider_plot on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://www.mathworks.com/matlabcentral/fileexchange/59561-spider_plot)
\ No newline at end of file
diff --git a/Requirements/spider_plot/spider_plot.m b/Requirements/spider_plot/spider_plot.m
new file mode 100644
index 0000000000000000000000000000000000000000..7599e993a6de52cfb3eebaca0d4ebef336f10b3b
--- /dev/null
+++ b/Requirements/spider_plot/spider_plot.m
@@ -0,0 +1,1571 @@
+function varargout = spider_plot(P, varargin)
+%spider_plot Create a spider or radar plot with individual axes.
+%
+% Syntax:
+%   spider_plot(P)
+%   spider_plot(P, Name, Value, ...)
+%   h = spider_plot(_)
+%
+% Input Arguments:
+%   (Required)
+%   P                - The data points used to plot the spider chart. The
+%                      rows are the groups of data and the columns are the
+%                      data points. The axes labels and axes limits are
+%                      automatically generated if not specified.
+%                      [vector | matrix]
+%
+% Output Arguments:
+%   (Optional)
+%   h                - Figure handle of spider plot.
+%                      [figure object]
+%
+% Name-Value Pair Arguments:
+%   (Optional)
+%   AxesLabels       - Used to specify the label each of the axes.
+%                      [auto-generated (default) | cell array of character vectors | 'none']
+%
+%   AxesInterval     - Used to change the number of intervals displayed
+%                      between the webs.
+%                      [3 (default) | integer]
+%
+%   AxesPrecision    - Used to change the precision level on the value
+%                      displayed on the axes.
+%                      [1 (default) | integer | vector]
+%
+%   AxesDisplay      - Used to change the number of axes in which the
+%                      axes text are displayed. 'None' or 'one' can be used
+%                      to simplify the plot appearance for normalized data.
+%                      ['all' (default) | 'none' | 'one' | 'data']
+%
+%   AxesLimits       - Used to manually set the axes limits. A matrix of
+%                      2 x size(P, 2). The top row is the minimum axes
+%                      limits and the bottow row is the maximum axes limits.
+%                      [auto-scaled (default) | matrix]
+%
+%   FillOption       - Used to toggle fill color option.
+%                      ['off' (default) | 'on' | cell array of character vectors]
+%
+%   FillTransparency - Used to set fill color transparency.
+%                      [0.1 (default) | scalar in range (0, 1) | vector]
+%
+%   Color            - Used to specify the line color, specified as an RGB
+%                      triplet. The intensities must be in the range (0, 1).
+%                      [MATLAB colors (default) | RGB triplet]
+%
+%   LineStyle        - Used to change the line style of the plots.
+%                      ['-' (default) | '--' | ':' | '-.' | 'none' | cell array of character vectors]
+%
+%   LineWidth        - Used to change the line width, where 1 point is
+%                      1/72 of an inch.
+%                      [0.5 (default) | positive value | vector]
+%
+%   LineTransparency - Used to set the line color transparency.
+%                      [1 (default) | scalar in range (0, 1) | vector]
+%
+%   Marker           - Used to change the marker symbol of the plots.
+%                      ['o' (default) | 'none' | '*' | 's' | 'd' | ... | cell array of character vectors]
+%
+%   MarkerSize       - Used to change the marker size, where 1 point is
+%                      1/72 of an inch.
+%                      [36 (default) | positive value | vector | vector]
+%
+%   MarkerTransparency-Used to set the marker color transparency.
+%                      [1 (default) | scalar in range (0, 1)]
+%
+%   AxesFont         - Used to change the font type of the values
+%                      displayed on the axes.
+%                      [Helvetica (default) | supported font name]
+%
+%   LabelFont        - Used to change the font type of the labels.
+%                      [Helvetica (default) | supported font name]
+%
+%   AxesFontSize     - Used to change the font size of the values
+%                      displayed on the axes.
+%                      [10 (default) | scalar value greater than zero]
+%
+%   AxesFontColor    - Used to change the font color of the values
+%                      displayed on the axes.
+%                      [black (default) | RGB triplet]
+%
+%   LabelFontSize    - Used to change the font size of the labels.
+%                      [10 (default) | scalar value greater than zero]
+%
+%   Direction        - Used to change the direction of rotation of the
+%                      plotted data and axis labels.
+%                      ['clockwise' (default) | 'counterclockwise']
+%
+%   AxesDirection    - Used to change the direction of axes.
+%                      ['normal' (default) | 'reverse' | cell array of character vectors]
+%
+%   AxesLabelsOffset - Used to adjust the position offset of the axes
+%                      labels.
+%                      [0.2 (default) | positive value]
+%
+%   AxesDataOffset   - Used to adjust the position offset of the data labels
+%                      when AxesDisplay is set to 'data'.
+%                      [0.1 (default) | positive value]
+%
+%   AxesScaling      - Used to change the scaling of the axes.
+%                      ['linear' (default) | 'log' | cell array of character vectors]
+%
+%   AxesColor        - Used to change the color of the spider axes.
+%                      [grey (default) | RGB triplet | hexadecimal color code]
+%
+%   AxesLabelsEdge   - Used to change the edge color of the axes labels.
+%                      [black (default) | RGB triplet | hexadecimal color code | 'none']
+%
+%   AxesOffset       - Used to change to axes offset from the origin.
+%                      [1 (default) | any integer less than the axes interval]
+%
+%   AxesZoom         - Used to change zoom of axes.
+%                      [0.7 (default) | scalar in range (0, 1)]
+%
+%   AxesHorzAlign    - Used to change the horizontal alignment of axes tick labels.
+%                      ['center' (default) | 'left' | 'right' | 'quadrant']
+%
+%   AxesVertAlign    - Used to change the vertical aligment of axes tick labels.
+%                      ['middle' (default) | 'top' | 'cap' | 'bottom' | 'baseline' | 'quadrant']
+%
+%   PlotVisible      - Used to change the visibility of the plotted lines and markers.
+%                      ['on' (default) | 'off']
+%
+%   AxesTickLabels   - Used to change the axes tick labels.
+%                      ['data' (default) | cell array of character vectors]
+%
+%   AxesInterpreter  - Used to change the text interpreter of axes labels and axes tick labels.
+%                      ['tex' (default) | 'latex' | 'none' | cell array of character vectors]
+%
+%   BackgroundColor  - Used to change the color of the background.
+%                      ['white' (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+%
+%   MinorGrid        - Used to toggle the minor grid.
+%                      ['off' (default) | 'on']
+%
+%   MinorGridInterval- Used to change number of minor grid lines in between the major grid lines.
+%                      [2 (default) | integer value greater than zero]
+%
+%   AxesZero         - Used to add a reference axes at value zero.
+%                      ['off' (default) | 'on']
+%
+%   AxesZeroColor    - Used to change the color of the zero reference axes.
+%                      ['black' (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+%
+%   AxesZeroWidth    - Used to change the line width of the zero reference axes.
+%                      [2 (default) | positive value]
+%
+%   AxesRadial       - Used to toggle radial axes.
+%                      ['on' (default) | 'off']
+%
+%   AxesAngular      - Used to toggle angular axes.
+%                      ['on' (default) | 'off']
+% 
+%   AxesShaded       - Used to toggle shaded area around axes.
+%                      ['off' (default) | 'on']
+%
+%   AxesShadedLimits - Used to set the limits of the shaded area. A matrix of
+%                      2 x size(P, 2). The top row is the minimum axes
+%                      limits and the bottow row is the maximum axes limits.
+%                      [AxesLimits (default) | matrix]
+%
+%   AxesShadedColor  - Used to change the color of the shaded area.
+%                      ['green' | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+%
+%   AxesShadedTransparency- Used to the shaded area transparency.
+%                           [0.2 (default) | scalar in range (0, 1)]      
+%
+%   AxesLabelsRotate - Used to rotate the axes labels to be aligned with axes.
+%                      ['off' (default) | 'on']
+%
+% Examples:
+%   % Example 1: Minimal number of arguments. All non-specified, optional
+%                arguments are set to their default values. Axes labels
+%                and limits are automatically generated and set.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot(P);
+%   legend('D1', 'D2', 'D3', 'Location', 'southoutside');
+%
+%   % Example 2: Manually setting the axes limits and axes precision.
+%                All non-specified, optional arguments are set to their
+%                default values.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot(P,...
+%       'AxesLimits', [1, 2, 1, 1, 1; 10, 8, 9, 5, 10],... % [min axes limits; max axes limits]
+%       'AxesPrecision', [0, 1, 1, 1, 1]);
+%
+%   % Example 3: Set fill option on. The fill transparency can be adjusted.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot(P,...
+%       'AxesLabels', {'S1', 'S2', 'S3', 'S4', 'S5'},...
+%       'AxesInterval', 2,...
+%       'FillOption', {'on', 'on', 'off'},...
+%       'FillTransparency', [0.2, 0.1, 0.1]);
+%
+%   % Example 4: Maximum number of arguments.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot(P,...
+%       'AxesLabels', {'S1', 'S2', 'S3', 'S4', 'S5'},...
+%       'AxesInterval', 4,...
+%       'AxesPrecision', 0,...
+%       'AxesDisplay', 'one',...
+%       'AxesLimits', [1, 2, 1, 1, 1; 10, 8, 9, 5, 10],...
+%       'FillOption', 'on',...
+%       'FillTransparency', 0.2,...
+%       'Color', [1, 0, 0; 0, 1, 0; 0, 0, 1],...
+%       'LineStyle', {'--', '-', '--'},...
+%       'LineWidth', [1, 2, 3],...
+%       'LineTransparency', 1,...
+%       'Marker', {'o', 'd', 's'},...
+%       'MarkerSize', [8, 10, 12],...
+%       'MarkerTransparency', 1,...
+%       'AxesFont', 'Times New Roman',...
+%       'LabelFont', 'Times New Roman',...
+%       'AxesFontColor', 'k',...
+%       'AxesFontSize', 12,...
+%       'LabelFontSize', 10,...
+%       'Direction', 'clockwise',...
+%       'AxesDirection', {'reverse', 'normal', 'normal', 'normal', 'normal'},...
+%       'AxesLabelsOffset', 0.2,...
+%       'AxesDataOffset', 0.1,...
+%       'AxesScaling', 'linear',...
+%       'AxesColor', [0.6, 0.6, 0.6],...
+%       'AxesLabelsEdge', 'none',...
+%       'AxesOffset', 1,...
+%       'AxesZoom', 1,...
+%       'AxesHorzAlign', 'quadrant',...
+%       'AxesVertAlign', 'quadrant',...
+%       'PlotVisible', 'on',...
+%       'AxesTickLabels', 'data',...
+%       'AxesInterpreter', 'tex',...
+%       'BackgroundColor' , 'w',...
+%       'MinorGrid', 'off',...
+%       'MinorGridInterval', 2,...
+%       'AxesZero', 'off',...
+%       'AxesZeroColor', 'k',...
+%       'AxesZeroWidth', 2,...
+%       'AxesRadial', 'on',...
+%       'AxesAngular', 'on',...
+%       'AxesShaded', 'off',...
+%       'AxesShadedLimits', [],...
+%       'AxesShadedColor', 'g',...
+%       'AxesShadedTransparency', 0.2,...
+%       'AxesLabelsRotate', 'off');
+%
+%   % Example 5: Excel-like radar charts.
+%
+%   D1 = [5 0 3 4 4];
+%   D2 = [2 1 5 5 4];
+%   P = [D1; D2];
+%   spider_plot(P,...
+%       'AxesInterval', 5,...
+%       'AxesPrecision', 0,...
+%       'AxesDisplay', 'one',...
+%       'AxesLimits', [0, 0, 0, 0, 0; 5, 5, 5, 5, 5],...
+%       'FillOption', 'on',...
+%       'FillTransparency', 0.1,...
+%       'Color', [139, 0, 0; 240, 128, 128]/255,...
+%       'LineWidth', 4,...
+%       'Marker', 'none',...
+%       'AxesFontSize', 14,...
+%       'LabelFontSize', 10,...
+%       'AxesColor', [0.8, 0.8, 0.8],...
+%       'AxesLabelsEdge', 'none',...
+%       'AxesRadial', 'off');
+%   title('Excel-like Radar Chart',...
+%       'FontSize', 14);
+%   legend_str = {'D1', 'D2'};
+%   legend(legend_str, 'Location', 'southoutside');
+%
+%   % Example 6: Logarithimic scale on specified axes. Axes limits and axes
+%                intervals can be individually set as well.
+%
+%   D1 = [5 3 9 1 1];
+%   D2 = [5 8 7 2 10];
+%   D3 = [8 2 1 4 100];
+%   P = [D1; D2; D3];
+%   spider_plot(P,...
+%       'AxesInterval', 2,...
+%       'AxesPrecision', 0,...
+%       'AxesFontSize', 10,...
+%       'AxesLabels', {'Linear Scale', 'Linear Scale', 'Linear Scale', 'Linear Scale', 'Logarithimic Scale'},...
+%       'AxesScaling', {'linear', 'linear', 'linear', 'linear', 'log'},...
+%       'AxesLimits', [1, 1, 1, 1, 1; 10, 10, 10, 10, 100]);
+%   legend('D1', 'D2', 'D3', 'Location', 'northeast');
+%
+%   % Example 7: Spider plot with subplot feature.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   subplot(1, 2, 1)
+%   spider_plot(P,...
+%       'AxesInterval', 1,...
+%       'AxesPrecision', 0);
+%   subplot(1, 2, 2)
+%   spider_plot(P,...
+%       'AxesInterval', 1,...
+%       'AxesPrecision', 0);
+%
+%   % Example 8: Spider plot with values only on data points.
+%   
+%   D1 = [1 3 4 1 2];
+%   D2 = [5 8 7 5 9];
+%   P = [D1; D2];
+%   spider_plot(P,...
+%       'AxesLimits', [1, 1, 1, 1, 1; 10, 10, 10, 10, 10],...
+%       'AxesDisplay', 'data',...
+%       'AxesLabelsOffset', 0.2,...
+%       'AxesDataOffset', 0.1,...
+%       'AxesFontColor', [0, 0, 1; 1, 0, 0]);
+%   legend('D1', 'D2', 'Location', 'southoutside');
+%
+%   % Example 9: Spider plot with shaded area around axes.
+%   
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot(P,...
+%       'AxesShaded', 'on',...
+%       'AxesShadedLimits', [5.5, 4, 3, 2, 4; 7, 6.5, 6, 3.5, 6]); % [min axes limits; max axes limits]
+%
+% Author:
+%   Moses Yoo, (juyoung.m.yoo at gmail dot com)
+%   2022-03-24: Add support for NaN values. Plot NaN values at origin.
+%   2022-03-23: Adjust rotated axes label alignment to be closer to axes.
+%   2022-03-21: Allow axes labels to be rotated to be aligned with axes.
+%   2022-03-17: Allow a shaded band to be plotted around the axes.
+%   2022-02-14: -Add support for reference axes at value zero.
+%               -Allow for toggling radial and angular axes on or off.
+%   2022-01-23: -Add ability to change figure/axes background color.
+%               -Allow for toggling minor grid lines.
+%   2022-01-03: Fix legend to include line and marker attributes.
+%   2021-11-24: Fix axes labels misalignment. Add option to set offset for
+%               data display values.
+%   2021-11-09: Add option to change the text interpreter of axes labels
+%               and axes tick labels.
+%   2021-11-01: -Allow for plot lines and markers to be hidden.
+%               -Allow for custom text of axes tick labels.
+%   2021-04-17: Fix data display values when log scale is set.
+%   2021-04-13: Add option to adjust line and marker transparency.
+%   2021-04-08: -Add option for data values to be displayed on axes.
+%               -Add support to adjust axes font colors.
+%   2021-03-19: -Allow axes values to be shifted.
+%               -Allow axes zoom level to be adjusted.
+%   2020-12-09: Allow fill option and fill transparency for each data group.
+%   2020-12-01: Added support for adjust the axes offset from origin.
+%   2020-11-30: Allow for one data group without specified axes limits.
+%   2020-11-30: Added support for changing axes and label font type.
+%   2020-11-06: Fix bug in reverse axes direction feature.
+%   2020-10-08: Adjust axes precision to be set to one or more axis.
+%   2020-09-30: Updated examples and added ability to reverse axes direction.
+%   2020-07-05: Added feature to change spider axes and axes labels edge color.
+%   2020-06-17: Allow logarithmic scale to be set to one or more axis.
+%   2020-03-26: Added feature to allow different line styles, line width,
+%               marker type, and marker sizes for the data groups.
+%   2020-02-12: Fixed condition and added error checking for when only one
+%               data group is plotted.
+%   2020-01-27: Corrected bug where only 7 entries were allowed in legend.
+%   2020-01-06: Added support for subplot feature.
+%   2019-11-27: Add option to change axes to logarithmic scale.
+%   2019-11-15: Add feature to customize the plot rotational direction and
+%               the offset position of the axis labels.
+%   2019-10-23: Minor revision to set starting axes as the vertical line.
+%               Add customization option for font sizes and axes display.
+%   2019-10-16: Minor revision to add name-value pairs for customizing
+%               color, marker, and line settings.
+%   2019-10-08: Another major revision to convert to name-value pairs and
+%               add color fill option.
+%   2019-09-17: Major revision to improve speed, clarity, and functionality
+%
+% Special Thanks:
+%   Special thanks to Gabriela Andrade, Andrés Garcia, Alex Grenyer,
+%   Tobias Kern, Zafar Ali, Christophe Hurlin, Roman, Mariusz Sepczuk,
+%   Mohamed Abubakr, Nicolai, Jingwei Too, Cedric Jamet, Richard Ruff,
+%   Marie-Kristin Schreiber, Juan Carlos Vargas Rubio, Anthony Wang,
+%   Pauline Oeuvray, Oliver Nicholls, Yu-Chi Chen, Fabrizio De Caro,
+%   Waqas Ahmad, Mario Di Siena, Rebecca & Nikolaos Koutsouleris for their
+%   feature recommendations and bug finds.
+
+%%% Data Properties %%%
+% Point properties
+[num_data_groups, num_data_points] = size(P);
+
+% Number of optional arguments
+numvarargs = length(varargin);
+
+% Check for even number of name-value pair argments
+if mod(numvarargs, 2) == 1
+    error('Error: Please check name-value pair arguments');
+end
+
+% Create default labels
+axes_labels = cell(1, num_data_points);
+
+% Iterate through number of data points
+for ii = 1:num_data_points
+    % Default axes labels
+    axes_labels{ii} = sprintf('Label %i', ii);
+end
+
+% Default arguments
+axes_interval = 3;
+axes_precision = 1;
+axes_display = 'all';
+axes_limits = [min(P, [], 1); max(P, [], 1)];
+fill_option = 'off';
+fill_transparency = 0.2;
+colors = lines(num_data_groups);
+line_style = '-';
+line_width = 2;
+line_transparency = 1;
+marker_type = 'o';
+marker_size = 36;
+marker_transparency = 1;
+axes_font = 'Helvetica';
+label_font = 'Helvetica';
+axes_font_size = 10;
+axes_font_color = [0, 0, 0];
+label_font_size = 10;
+direction = 'clockwise';
+axes_direction = 'normal';
+axes_labels_offset = 0.2;
+axes_data_offset = 0.1;
+axes_scaling = 'linear';
+axes_color = [0.6, 0.6, 0.6];
+axes_labels_edge = 'k';
+axes_offset = 1;
+axes_zoom = 0.7;
+axes_horz_align = 'center';
+axes_vert_align = 'middle';
+plot_visible = 'on';
+axes_tick_labels = 'data';
+axes_interpreter = 'tex';
+background_color = 'w';
+minor_grid = 'off';
+minor_grid_interval = 2;
+axes_zero = 'off';
+axes_zero_color = [0.6, 0.6, 0.6];
+axes_zero_width = 2;
+axes_radial = 'on';
+axes_angular = 'on';
+axes_shaded = 'off';
+axes_shaded_limits = axes_limits;
+axes_shaded_color = 'g';
+axes_shaded_transparency = 0.2;
+axes_labels_rotate = 'off';
+
+% Check if optional arguments were specified
+if numvarargs > 1
+    % Initialze name-value arguments
+    name_arguments = varargin(1:2:end);
+    value_arguments = varargin(2:2:end);
+    
+    % Iterate through name-value arguments
+    for ii = 1:length(name_arguments)
+        % Set value arguments depending on name
+        switch lower(name_arguments{ii})
+            case 'axeslabels'
+                axes_labels = value_arguments{ii};
+            case 'axesinterval'
+                axes_interval = value_arguments{ii};
+            case 'axesprecision'
+                axes_precision = value_arguments{ii};
+            case 'axesdisplay'
+                axes_display = value_arguments{ii};
+            case 'axeslimits'
+                axes_limits = value_arguments{ii};
+            case 'filloption'
+                fill_option = value_arguments{ii};
+            case 'filltransparency'
+                fill_transparency = value_arguments{ii};
+            case 'color'
+                colors = value_arguments{ii};
+            case 'linestyle'
+                line_style = value_arguments{ii};
+            case 'linewidth'
+                line_width = value_arguments{ii};
+            case 'linetransparency'
+                line_transparency = value_arguments{ii};
+            case 'marker'
+                marker_type = value_arguments{ii};
+            case 'markersize'
+                marker_size = value_arguments{ii};
+            case 'markertransparency'
+                marker_transparency = value_arguments{ii};
+            case 'axesfont'
+                axes_font = value_arguments{ii};
+            case 'labelfont'
+                label_font = value_arguments{ii};
+            case 'axesfontsize'
+                axes_font_size = value_arguments{ii};
+            case 'axesfontcolor'
+                axes_font_color = value_arguments{ii};
+            case 'labelfontsize'
+                label_font_size = value_arguments{ii};
+            case 'direction'
+                direction = value_arguments{ii};
+            case 'axesdirection'
+                axes_direction = value_arguments{ii};
+            case 'axeslabelsoffset'
+                axes_labels_offset = value_arguments{ii};
+            case 'axesdataoffset'
+                axes_data_offset = value_arguments{ii};
+            case 'axesscaling'
+                axes_scaling = value_arguments{ii};
+            case 'axescolor'
+                axes_color = value_arguments{ii};
+            case 'axeslabelsedge'
+                axes_labels_edge = value_arguments{ii};
+            case 'axesoffset'
+                axes_offset = value_arguments{ii};
+            case 'axeszoom'
+                axes_zoom = value_arguments{ii};
+            case 'axeshorzalign'
+                axes_horz_align = value_arguments{ii};
+            case 'axesvertalign'
+                axes_vert_align = value_arguments{ii};
+            case 'plotvisible'
+                plot_visible = value_arguments{ii};
+            case 'axesticklabels'
+                axes_tick_labels = value_arguments{ii};
+            case 'axesinterpreter'
+                axes_interpreter = value_arguments{ii};
+            case 'backgroundcolor'
+                background_color = value_arguments{ii};
+            case 'minorgrid'
+                minor_grid = value_arguments{ii};
+            case 'minorgridinterval'
+                minor_grid_interval = value_arguments{ii};
+            case 'axeszero'
+                axes_zero = value_arguments{ii};
+            case 'axeszerowidth'
+                axes_zero_width = value_arguments{ii};
+            case 'axeszerocolor'
+                axes_zero_color = value_arguments{ii};
+            case 'axesradial'
+                axes_radial = value_arguments{ii};
+            case 'axesangular'
+                axes_angular = value_arguments{ii};
+            case 'axesshaded'
+                axes_shaded = value_arguments{ii};
+            case 'axesshadedlimits'
+                axes_shaded_limits = value_arguments{ii};
+            case 'axesshadedcolor'
+                axes_shaded_color = value_arguments{ii};
+            case 'axesshadedtransparency'
+                axes_shaded_transparency = value_arguments{ii};
+            case 'axeslabelsrotate'
+                axes_labels_rotate = value_arguments{ii};
+            otherwise
+                error('Error: Please enter in a valid name-value pair.');
+        end
+    end
+    
+end
+
+%%% Error Check %%%
+% Check if axes labels is a cell
+if iscell(axes_labels)
+    % Check if the axes labels are the same number as the number of points
+    if length(axes_labels) ~= num_data_points
+        error('Error: Please make sure the number of labels is the same as the number of points.');
+    end
+else
+    % Check if valid char entry
+    if ~contains(axes_labels, 'none')
+        error('Error: Please enter in valid labels or "none" to remove labels.');
+    end
+end
+
+% Check if the axes limits same length as the number of points
+if size(axes_limits, 1) ~= 2 || size(axes_limits, 2) ~= num_data_points
+    error('Error: Please make sure the min and max axes limits match the number of data points.');
+end
+
+% Lower and upper limits
+lower_limits = axes_limits(1, :);
+upper_limits = axes_limits(2, :);
+
+% Difference in upper and lower limits
+diff_limits = upper_limits - lower_limits;
+
+% Check to make sure upper limit is greater than lower limit
+if any(diff_limits < 0)
+    error('Error: Please make sure max axes limits are greater than the min axes limits.');
+end
+
+% Check the range of axes limits
+if any(diff_limits == 0)
+    error('Error: Please set the axes limits and make sure the min and max axes limits are different.');
+end
+
+% Check if axes precision is numeric
+if isnumeric(axes_precision)
+    % Check is length is one
+    if length(axes_precision) == 1
+        % Repeat array to number of data points
+        axes_precision = repmat(axes_precision, num_data_points, 1);
+    elseif length(axes_precision) ~= num_data_points
+        error('Error: Please specify the same number of axes precision as number of data points.');
+    end
+else
+    error('Error: Please make sure the axes precision is a numeric value.');
+end
+
+% Check if axes properties are an integer
+if floor(axes_interval) ~= axes_interval || any(floor(axes_precision) ~= axes_precision)
+    error('Error: Please enter in an integer for the axes properties.');
+end
+
+% Check if axes properties are positive
+if axes_interval < 1 || any(axes_precision < 0)
+    error('Error: Please enter a positive value for the axes properties.');
+end
+
+% Check if axes display is valid char entry
+if ~ismember(axes_display, {'all', 'none', 'one', 'data'})
+    error('Error: Invalid axes display entry. Please enter in "all", "none", or "one" to set axes text.');
+end
+
+% Check if fill option is valid
+if any(~ismember(fill_option, {'off', 'on'}))
+    error('Error: Please enter either "off" or "on" for fill option.');
+end
+
+% Check if fill transparency is valid
+if any(fill_transparency < 0) || any(fill_transparency > 1)
+    error('Error: Please enter a transparency value between [0, 1].');
+end
+
+% Check if line transparency is valid
+if any(line_transparency < 0) || any(line_transparency > 1)
+    error('Error: Please enter a transparency value between [0, 1].');
+end
+
+% Check if marker transparency is valid
+if any(marker_transparency < 0) || any(marker_transparency > 1)
+    error('Error: Please enter a transparency value between [0, 1].');
+end
+
+% Check if font size is greater than zero
+if axes_font_size <= 0 || label_font_size <= 0
+    error('Error: Please enter a font size greater than zero.');
+end
+
+% Check if direction is valid char entry
+if ~ismember(direction, {'counterclockwise', 'clockwise'})
+    error('Error: Invalid direction entry. Please enter in "counterclockwise" or "clockwise" to set direction of rotation.');
+end
+
+% Check if axes direction is valid char entry
+if ~ismember(axes_direction, {'normal', 'reverse'})
+    error('Error: Invalid axes direction entry. Please enter in "normal" or "reverse" to set axes direction.');
+end
+
+% Check if axes labels offset is positive
+if axes_labels_offset < 0
+    error('Error: Please enter a positive for the axes labels offset.');
+end
+
+% Check if axes data offset is positive
+if axes_data_offset < 0
+    error('Error: Please enter a positive for the axes data offset.');
+end
+
+% Check if axes scaling is valid
+if any(~ismember(axes_scaling, {'linear', 'log'}))
+    error('Error: Invalid axes scaling entry. Please enter in "linear" or "log" to set axes scaling.');
+end
+
+% Check if axes offset is valid
+if floor(axes_offset)~=axes_offset || axes_offset < 0 || axes_offset > axes_interval
+    error('Error: Invalid axes offset entry. Please enter in an integer value that is between [0, axes_interval].');
+end
+
+% Check if axes zoom value is valid
+if ~isnumeric(axes_zoom) || length(axes_zoom) ~= 1 || axes_zoom < 0 || axes_zoom > 1
+    error('Error: Please enter an axes zoom value between [0, 1].');
+end
+
+% Check if axes horizontal alignment is valid
+if any(~ismember(axes_horz_align, {'center', 'left', 'right', 'quadrant'}))
+    error('Error: Invalid axes horizontal alignment entry.');
+end
+
+% Check if axes vertical alignment is valid
+if any(~ismember(axes_vert_align, {'middle', 'top', 'cap', 'bottom', 'baseline', 'quadrant'}))
+    error('Error: Invalid axes vertical alignment entry.');
+end
+
+% Check if plot visible is valid
+if ~ismember(plot_visible, {'on', 'off'})
+    error('Error: Invalid plot visible entry. Please enter in "on" or "off" to set plot visiblity.');
+end
+
+% Check if axes interpreter is valid
+if any(~ismember(axes_interpreter, {'tex', 'latex', 'none'}))
+    error('Error: Please enter either "tex", "latex", or "none" for axes interpreter option.');
+end
+
+% Check if minor grid is valid
+if ~ismember(minor_grid, {'on', 'off'})
+    error('Error: Invalid minor grid entry. Please enter in "on" or "off" to toggle minor grid.');
+end
+
+% Check if axes zero is valid
+if ~ismember(axes_zero, {'on', 'off'})
+    error('Error: Invalid axes zero entry. Please enter in "on" or "off" to set axes visiblity.');
+end
+
+% Check if axes radial is valid
+if ~ismember(axes_radial, {'on', 'off'})
+    error('Error: Invalid axes radial entry. Please enter in "on" or "off" to set axes visiblity.');
+end
+
+% Check if axes angular is valid
+if ~ismember(axes_angular, {'on', 'off'})
+    error('Error: Invalid axes angular entry. Please enter in "on" or "off" to set axes visiblity.');
+end
+
+% Check if axes zero line width is numeric
+if ~isnumeric(axes_zero_width)
+    error('Error: Please make sure the axes zero width is a numeric value.');
+end
+
+% Check if minor grid interval is valid
+if floor(minor_grid_interval)~=minor_grid_interval || minor_grid_interval < 0
+    error('Error: Invalid minor grid interval entry. Please enter in an integer value that is positive.');
+end
+
+% Check if axes shaded is valid
+if any(~ismember(axes_shaded, {'off', 'on'}))
+    error('Error: Please enter either "off" or "on" for axes shaded option.');
+end
+
+% Check if axes shaded transparency is valid
+if axes_shaded_transparency < 0 || axes_shaded_transparency > 1
+    error('Error: Please enter a transparency value between [0, 1].');
+end
+
+% Check if axes shaded limits is empty
+if isempty(axes_shaded_limits)
+    axes_shaded_limits = axes_limits;
+end
+
+% Check if the axes shaded limits same length as the number of points
+if size(axes_shaded_limits, 1) ~= 2 || size(axes_shaded_limits, 2) ~= num_data_points
+    error('Error: Please make sure the min and max axes shaded limits match the number of data points.');
+end
+
+% Check if within min and max axes limits
+if any(axes_shaded_limits(1, :) < axes_limits(1, :)) ||...
+        any(axes_shaded_limits(2, :) > axes_limits(2, :))
+    error('Error: Please make sure the axes shaded limits are within the min and max axes limits.');
+end
+
+% Check if axes labels rotate is valid
+if any(~ismember(axes_labels_rotate, {'off', 'on'}))
+    error('Error: Please enter either "off" or "on" for axes labels rotate option.');
+end
+
+% Check if axes interpreter is a char
+if ischar(axes_interpreter)
+    % Convert to cell array of char
+    axes_interpreter = cellstr(axes_interpreter);
+    
+    % Repeat cell to number of data groups
+    axes_interpreter = repmat(axes_interpreter, length(axes_labels), 1);
+elseif iscellstr(axes_interpreter)
+    % Check is length is one
+    if length(axes_interpreter) == 1
+        % Repeat cell to number of data groups
+        axes_interpreter = repmat(axes_interpreter, length(axes_labels), 1);
+    elseif length(axes_interpreter) ~= length(axes_labels)
+        error('Error: Please specify the same number of axes interpreters as axes labels.');
+    end
+else
+    error('Error: Please make sure the axes interpreter is a char or a cell array of char.');
+end
+
+% Check if axes tick labels is valid
+if iscell(axes_tick_labels)
+    if length(axes_tick_labels) ~= axes_interval+1
+        error('Error: Invalid axes tick labels entry. Please enter in a cell array with the same length of axes interval + 1.');
+    end
+else
+    if ~strcmp(axes_tick_labels, 'data')
+        error('Error: Invalid axes tick labels entry. Please enter in "data" or a cell array of desired tick labels.');
+    end
+end
+
+% Check if axes scaling is a cell
+if iscell(axes_scaling)
+    % Check is length is one
+    if length(axes_scaling) == 1
+        % Repeat array to number of data groups
+        axes_scaling = repmat(axes_scaling, num_data_points, 1);
+    elseif length(axes_scaling) ~= num_data_points
+        error('Error: Please specify the same number of axes scaling as number of data points.');
+    end
+else
+    % Repeat array to number of data groups
+    axes_scaling = repmat({axes_scaling}, num_data_points, 1);
+end
+
+% Check if line style is a char
+if ischar(line_style)
+    % Convert to cell array of char
+    line_style = cellstr(line_style);
+    
+    % Repeat cell to number of data groups
+    line_style = repmat(line_style, num_data_groups, 1);
+elseif iscellstr(line_style)
+    % Check is length is one
+    if length(line_style) == 1
+        % Repeat cell to number of data groups
+        line_style = repmat(line_style, num_data_groups, 1);
+    elseif length(line_style) ~= num_data_groups
+        error('Error: Please specify the same number of line styles as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line style is a char or a cell array of char.');
+end
+
+% Check if line width is numeric
+if isnumeric(line_width)
+    % Check is length is one
+    if length(line_width) == 1
+        % Repeat array to number of data groups
+        line_width = repmat(line_width, num_data_groups, 1);
+    elseif length(line_width) ~= num_data_groups
+        error('Error: Please specify the same number of line width as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line width is a numeric value.');
+end
+
+% Check if marker type is a char
+if ischar(marker_type)
+    % Convert to cell array of char
+    marker_type = cellstr(marker_type);
+    
+    % Repeat cell to number of data groups
+    marker_type = repmat(marker_type, num_data_groups, 1);
+elseif iscellstr(marker_type)
+    % Check is length is one
+    if length(marker_type) == 1
+        % Repeat cell to number of data groups
+        marker_type = repmat(marker_type, num_data_groups, 1);
+    elseif length(marker_type) ~= num_data_groups
+        error('Error: Please specify the same number of line styles as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line style is a char or a cell array of char.');
+end
+
+% Check if line width is numeric
+if isnumeric(marker_size)
+    if length(marker_size) == 1
+        % Repeat array to number of data groups
+        marker_size = repmat(marker_size, num_data_groups, 1);
+    elseif length(marker_size) ~= num_data_groups
+        error('Error: Please specify the same number of line width as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line width is numeric.');
+end
+
+% Check if axes direction is a cell
+if iscell(axes_direction)
+    % Check is length is one
+    if length(axes_direction) == 1
+        % Repeat array to number of data points
+        axes_direction = repmat(axes_direction, num_data_points, 1);
+    elseif length(axes_direction) ~= num_data_points
+        error('Error: Please specify the same number of axes direction as number of data points.');
+    end
+else
+    % Repeat array to number of data points
+    axes_direction = repmat({axes_direction}, num_data_points, 1);
+end
+
+% Check if fill option is a cell
+if iscell(fill_option)
+    % Check is length is one
+    if length(fill_option) == 1
+        % Repeat array to number of data groups
+        fill_option = repmat(fill_option, num_data_groups, 1);
+    elseif length(fill_option) ~= num_data_groups
+        error('Error: Please specify the same number of fill option as number of data groups.');
+    end
+else
+    % Repeat array to number of data groups
+    fill_option = repmat({fill_option}, num_data_groups, 1);
+end
+
+% Check if fill transparency is numeric
+if isnumeric(fill_transparency)
+    % Check is length is one
+    if length(fill_transparency) == 1
+        % Repeat array to number of data groups
+        fill_transparency = repmat(fill_transparency, num_data_groups, 1);
+    elseif length(fill_transparency) ~= num_data_groups
+        error('Error: Please specify the same number of fill transparency as number of data groups.');
+    end
+else
+    error('Error: Please make sure the transparency is a numeric value.');
+end
+
+% Check if line transparency is numeric
+if isnumeric(line_transparency)
+    % Check is length is one
+    if length(line_transparency) == 1
+        % Repeat array to number of data groups
+        line_transparency = repmat(line_transparency, num_data_groups, 1);
+    elseif length(line_transparency) ~= num_data_groups
+        error('Error: Please specify the same number of line transparency as number of data groups.');
+    end
+else
+    error('Error: Please make sure the transparency is a numeric value.');
+end
+
+% Check if marker transparency is numeric
+if isnumeric(marker_transparency)
+    % Check is length is one
+    if length(marker_transparency) == 1
+        % Repeat array to number of data groups
+        marker_transparency = repmat(marker_transparency, num_data_groups, 1);
+    elseif length(marker_transparency) ~= num_data_groups
+        error('Error: Please specify the same number of marker transparency as number of data groups.');
+    end
+else
+    error('Error: Please make sure the transparency is a numeric value.');
+end
+
+% Check if axes display is data
+if strcmp(axes_display, 'data')
+    if size(axes_font_color, 1) ~= num_data_groups
+        % Check axes font color dimensions
+        if size(axes_font_color, 1) == 1 && size(axes_font_color, 2) == 3
+            axes_font_color = repmat(axes_font_color, num_data_groups, 1);
+        else
+            error('Error: Please specify axes font color as a RGB triplet normalized to 1.');
+        end
+    end
+end
+
+%%% Axes Scaling Properties %%%
+% Selected data
+P_selected = P;
+            
+% Check axes scaling option
+log_index = strcmp(axes_scaling, 'log');
+
+% If any log scaling is specified
+if any(log_index)
+    % Initialize copy
+    P_log = P_selected(:, log_index);
+    
+    % Logarithm of base 10, account for numbers less than 1
+    P_log = sign(P_log) .* log10(abs(P_log));
+    
+    % Minimum and maximun log limits
+    min_limit = min(min(fix(P_log)));
+    max_limit = max(max(ceil(P_log)));
+    recommended_axes_interval = max_limit - min_limit;
+    
+    % Warning message
+    warning('For the log scale values, recommended axes limit is [%i, %i] with an axes interval of %i.',...
+        10^min_limit, 10^max_limit, recommended_axes_interval);
+    
+    % Replace original
+    P_selected(:, log_index) = P_log;
+end
+
+%%% Figure Properties %%%
+% Grab current figure
+fig = gcf;
+if nargout > 1
+    error('Error: Too many output arguments assigned.');
+end
+varargout{1} = fig;
+
+% Set figure background
+fig.Color = background_color;
+
+% Reset axes
+cla reset;
+
+% Current axes handle
+ax = gca;
+ax.Color = background_color;
+
+% Axis limits
+hold on;
+axis square;
+scaling_factor = 1 + (1 - axes_zoom);
+axis([-1, 1, -1, 1] * scaling_factor);
+
+% Axis properties
+ax.XTickLabel = [];
+ax.YTickLabel = [];
+ax.XColor = 'none';
+ax.YColor = 'none';
+
+% Polar increments
+theta_increment = 2*pi/num_data_points;
+full_interval = axes_interval + 1;
+rho_offset = axes_offset/full_interval;
+
+%%% Scale Data %%%
+% Check if axes shaded is on
+if strcmp(axes_shaded, 'on')
+    P_selected = [P_selected; axes_shaded_limits];
+end
+
+% Pre-allocation
+P_scaled = zeros(size(P_selected));
+axes_range = zeros(3, num_data_points);
+
+% Check axes scaling option
+axes_direction_index = strcmp(axes_direction, 'reverse');
+
+% Iterate through number of data points
+for ii = 1:num_data_points
+    % Check for one data group and no axes limits
+    if num_data_groups == 1 && isempty(axes_limits)
+        % Group of points
+        group_points = P_selected(:, :);
+    else
+        % Group of points
+        group_points = P_selected(:, ii);
+    end
+    
+    % Check for log axes scaling option
+    if log_index(ii)
+        % Minimum and maximun log limits
+        min_value = min(fix(group_points));
+        max_value = max(ceil(group_points));
+    else
+        % Automatically the range of each group
+        min_value = min(group_points);
+        max_value = max(group_points);
+    end
+    
+    % Range of min and max values
+    range = max_value - min_value;
+    
+    % Check if axes_limits is not empty
+    if ~isempty(axes_limits)
+        % Check for log axes scaling option
+        if log_index(ii)
+            % Logarithm of base 10, account for numbers less than 1
+            axes_limits(:, ii) = sign(axes_limits(:, ii)) .* log10(abs(axes_limits(:, ii)));
+        end
+        
+        % Manually set the range of each group
+        min_value = axes_limits(1, ii);
+        max_value = axes_limits(2, ii);
+        range = max_value - min_value;
+        
+        % Check if the axes limits are within range of points
+        if min_value > min(group_points) || max_value < max(group_points)
+            error('Error: Please make sure the manually specified axes limits are within range of the data points.');
+        end
+    end
+    
+    % Check if range is valid
+    if range == 0
+        error('Error: Range of data values is not valid. Please specify the axes limits.');
+    end
+    
+    % Scale points to range from [0, 1]
+    P_scaled(:, ii) = ((P_selected(:, ii) - min_value) / range);
+    
+    % If reverse axes direction is specified
+    if axes_direction_index(ii)
+        % Store to array
+        axes_range(:, ii) = [max_value; min_value; range];
+        P_scaled(:, ii) = -(P_scaled(:, ii) - 1);
+    else
+        % Store to array
+        axes_range(:, ii) = [min_value; max_value; range];
+    end
+    
+    % Add offset of [rho_offset] and scaling factor of [1 - rho_offset]
+    P_scaled(:, ii) = P_scaled(:, ii) * (1 - rho_offset) + rho_offset;
+end
+
+% Check if axes shaded is on
+if strcmp(axes_shaded, 'on')
+    P_shaded = P_scaled(end-1:end, :);
+    P_scaled = P_scaled(1:end-2, :);
+end
+
+%%% Polar Axes %%%
+% Polar coordinates
+rho_increment = 1/full_interval;
+rho = 0:rho_increment:1;
+
+% Check rotational direction
+switch direction
+    case 'counterclockwise'
+        % Shift by pi/2 to set starting axis the vertical line
+        theta = (0:theta_increment:2*pi) + (pi/2);
+    case 'clockwise'
+        % Shift by pi/2 to set starting axis the vertical line
+        theta = (0:-theta_increment:-2*pi) + (pi/2);
+end
+
+% Remainder after using a modulus of 2*pi
+theta = mod(theta, 2*pi);
+
+% Check if axes radial is toggled on
+if strcmp(axes_radial, 'on')
+    % Iterate through each theta
+    for ii = 1:length(theta)-1
+        % Convert polar to cartesian coordinates
+        [x_axes, y_axes] = pol2cart(theta(ii), rho);
+
+        % Plot webs
+        h = plot(x_axes, y_axes,...
+            'LineWidth', 1.5,...
+            'Color', axes_color);
+
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if axes angular is toggled on
+if strcmp(axes_angular, 'on')
+    % Iterate through each rho
+    for ii = 2:length(rho)
+        % Convert polar to cartesian coordinates
+        [x_axes, y_axes] = pol2cart(theta, rho(ii));
+
+        % Plot axes
+        h = plot(x_axes, y_axes,...
+            'Color', axes_color);
+
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if minor grid is toggled on
+if strcmp(minor_grid, 'on')
+    % Polar coordinates
+    rho_minor_increment = 1/(full_interval*minor_grid_interval);
+    rho_minor = rho(2):rho_minor_increment:1;
+    rho_minor = setdiff(rho_minor, rho(2:end));
+
+    % Iterate through each rho minor
+    for ii = 1:length(rho_minor)
+        % Convert polar to cartesian coordinates
+        [x_axes, y_axes] = pol2cart(theta, rho_minor(ii));
+
+        % Plot axes
+        h = plot(x_axes, y_axes, '--',...
+            'Color', axes_color,...
+            'LineWidth', 0.5);
+
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if axes zero is toggled on
+if strcmp(axes_zero, 'on') && strcmp(axes_display, 'one')
+     % Scale points to range from [0, 1]
+    zero_scaled = (0 - min_value) / range;
+    
+    % If reverse axes direction is specified
+    if strcmp(axes_direction, 'reverse')
+        zero_scaled = -zero_scaled - 1;
+    end
+
+    % Add offset of [rho_offset] and scaling factor of [1 - rho_offset]
+    zero_scaled = zero_scaled * (1 - rho_offset) + rho_offset;
+
+    % Convert polar to cartesian coordinates
+    [x_axes, y_axes] = pol2cart(theta, zero_scaled);
+
+    % Plot webs
+    h = plot(x_axes, y_axes,...
+        'LineWidth', axes_zero_width,...
+        'Color', axes_zero_color);
+
+    % Turn off legend annotation
+    h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+end
+
+% Set end index depending on axes display argument
+switch axes_display
+    case 'all'
+        theta_end_index = length(theta)-1;
+    case 'one'
+        theta_end_index = 1;
+    case 'none'
+        theta_end_index = 0;
+    case 'data'
+        theta_end_index = 0;
+end
+
+% Rho start index and offset interval
+rho_start_index = axes_offset+1;
+offset_interval = full_interval - axes_offset;
+
+% Alignment for axes labels
+horz_align = axes_horz_align;
+vert_align = axes_vert_align;
+
+% Iterate through each theta
+for ii = 1:theta_end_index
+    % Convert polar to cartesian coordinates
+    [x_axes, y_axes] = pol2cart(theta(ii), rho);
+    
+    % Check if horizontal alignment is quadrant based
+    if strcmp(axes_horz_align, 'quadrant')
+        % Alignment based on quadrant
+        [horz_align, ~] = quadrant_position(theta(ii));
+    end
+    
+    % Check if vertical alignment is quadrant based
+    if strcmp(axes_vert_align, 'quadrant')
+        % Alignment based on quadrant
+        [~, vert_align] = quadrant_position(theta(ii));
+    end
+    
+    % Iterate through points on isocurve
+    for jj = rho_start_index:length(rho)
+        % Axes increment range
+        min_value = axes_range(1, ii);
+        range = axes_range(3, ii);
+        
+        % If reverse axes direction is specified
+        if axes_direction_index(ii)
+            % Axes increment value
+            axes_value = min_value - (range/offset_interval) * (jj-rho_start_index);
+        else
+            % Axes increment value
+            axes_value = min_value + (range/offset_interval) * (jj-rho_start_index);
+        end
+        
+        % Check for log axes scaling option
+        if log_index(ii)
+            % Exponent to the tenth power
+            axes_value = 10^axes_value;
+        end
+        
+        % Display axes text
+        if strcmp(axes_tick_labels, 'data')
+            text_str = sprintf(sprintf('%%.%if', axes_precision(ii)), axes_value);
+        else
+            text_str = axes_tick_labels{jj-axes_offset};
+        end
+
+        t = text(x_axes(jj), y_axes(jj), text_str,...
+            'Units', 'Data',...
+            'Color', axes_font_color,...
+            'FontName', axes_font,...
+            'FontSize', axes_font_size,...
+            'HorizontalAlignment', horz_align,...
+            'VerticalAlignment', vert_align);
+
+        % Apply to axes tick labels only when not data
+        if iscellstr(axes_tick_labels)
+            t.Interpreter = axes_interpreter{1};
+        end
+    end
+end
+
+%%% Plot %%%
+% Fill option index
+fill_option_index = strcmp(fill_option, 'on');
+
+% Check if any NaNs detected
+if any(isnan(P_scaled), 'all')
+    % Set value to zero
+    nan_index = isnan(P_scaled);
+    P_scaled(nan_index) = 0;
+end
+
+% Iterate through number of data groups
+for ii = 1:num_data_groups
+    % Convert polar to cartesian coordinates
+    [x_points, y_points] = pol2cart(theta(1:end-1), P_scaled(ii, :));
+    
+    % Make points circular
+    x_circular = [x_points, x_points(1)];
+    y_circular = [y_points, y_points(1)];
+    
+    % Plot data points
+    h = plot(x_circular, y_circular,...
+        'LineStyle', line_style{ii},...
+        'Color', colors(ii, :),...
+        'LineWidth', line_width(ii),...
+        'Visible', plot_visible);
+    h.Color(4) = line_transparency(ii);
+    
+    % Turn off legend annotation
+    h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+
+    h = scatter(x_circular, y_circular,...
+        'Marker', marker_type{ii},...
+        'SizeData', marker_size(ii),...
+        'MarkerFaceColor', colors(ii, :),...
+        'MarkerEdgeColor', colors(ii, :),...
+        'MarkerFaceAlpha', marker_transparency(ii),...
+        'MarkerEdgeAlpha', marker_transparency(ii),...
+        'Visible', plot_visible);
+    
+    % Turn off legend annotation
+    h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+
+    % Plot empty line with combined attributes for legend
+    plot(nan, nan,...
+        'Marker', marker_type{ii},...
+        'MarkerSize', marker_size(ii)/6,...
+        'MarkerFaceColor', colors(ii, :),...
+        'MarkerEdgeColor', colors(ii, :),...
+        'LineStyle', line_style{ii},...
+        'Color', colors(ii, :),...
+        'LineWidth', line_width(ii),...
+        'Visible', plot_visible);
+    
+    % Iterate through number of data points
+    if strcmp(axes_display, 'data')
+        for jj = 1:num_data_points
+            % Convert polar to cartesian coordinates
+            [current_theta, current_rho] = cart2pol(x_points(jj), y_points(jj));
+            [x_pos, y_pos] = pol2cart(current_theta, current_rho+axes_data_offset);
+            
+            % Display axes text
+            data_value = P(ii, jj);
+            text_str = sprintf(sprintf('%%.%if', axes_precision(jj)), data_value);
+            text(x_pos, y_pos, text_str,...
+                'Units', 'Data',...
+                'Color', axes_font_color(ii, :),...
+                'FontName', axes_font,...
+                'FontSize', axes_font_size,...
+                'HorizontalAlignment', 'center',...
+                'VerticalAlignment', 'middle');
+        end
+    end
+    
+    % Check if fill option is toggled on
+    if fill_option_index(ii)
+        % Fill area within polygon
+        h = patch(x_circular, y_circular, colors(ii, :),...
+            'EdgeColor', 'none',...
+            'FaceAlpha', fill_transparency(ii));
+        
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if axes shaded is on
+if strcmp(axes_shaded, 'on')
+    % Polar verticies of patch
+    P_shaded = [P_shaded, P_shaded(:, 1)];
+    P_shaded = [P_shaded(1, :), P_shaded(2, :)];
+    patch_rho = reshape(P_shaded, 1, []);
+    patch_theta = [theta, theta];
+
+    % Convert polar to cartesian coordinates
+    [x_points, y_points] = pol2cart(patch_theta, patch_rho);
+
+    % Interweave lower and upper limits
+    x_points = reshape(x_points, [], 2)';
+    y_points = reshape(y_points, [], 2)';
+
+    x_points = x_points(:);
+    y_points = y_points(:);
+
+    % Increment through groups of four vertices at a time
+    for ii = 1:2:length(x_points)-2
+        % Verticies and face points
+        v = [x_points(ii:ii+3), y_points(ii:ii+3)];
+        f = [1 2 4 3];
+        
+        % Patch polygon
+        h = patch('Faces', f, 'Vertices', v,...
+            'FaceColor', axes_shaded_color,...
+            'EdgeColor', 'none',...
+            'FaceAlpha', axes_shaded_transparency);
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Find object handles
+text_handles = findobj(ax.Children,...
+    'Type', 'Text');
+patch_handles = findobj(ax.Children,...
+    'Type', 'Patch');
+isocurve_handles = findobj(ax.Children,...
+    'Color', axes_color,...
+    '-and', 'Type', 'Line');
+plot_handles = findobj(ax.Children, '-not',...
+    'Color', axes_color,...
+    '-and', 'Type', 'Line');
+
+% Manually set the stack order
+uistack(plot_handles, 'bottom');
+uistack(patch_handles, 'bottom');
+uistack(isocurve_handles, 'bottom');
+uistack(text_handles, 'top');
+
+%%% Labels %%%
+% Check if axes labels rotate is on
+if strcmp(axes_labels_rotate, 'on')
+    % Find number of degrees to rotate text by
+    rotate_deg = rad2deg(text_rotation(theta));
+
+    % Find the horizontal alignments to align closer to axes
+    horz_aligns = text_alignment(theta);
+else
+    % No rotation
+    rotate_deg = zeros(1, length(theta));
+end
+
+% Check labels argument
+if ~strcmp(axes_labels, 'none')
+    % Iterate through number of data points
+    for ii = 1:length(axes_labels)
+        % Horizontal text alignment by quadrant
+        [horz_align, ~] = quadrant_position(theta(ii));
+
+        % Check if axes labels rotate is on
+        if strcmp(axes_labels_rotate, 'on')
+            % Adjust horizontal text alignment
+            horz_align = horz_aligns{ii};
+        end
+
+        % Convert polar to cartesian coordinates
+        [x_pos, y_pos] = pol2cart(theta(ii), rho(end)+axes_labels_offset);
+        
+        % Display text label
+        text(x_pos, y_pos, axes_labels{ii},...
+            'Units', 'Data',...
+            'HorizontalAlignment', horz_align,...
+            'VerticalAlignment', 'middle',...
+            'EdgeColor', axes_labels_edge,...
+            'BackgroundColor', background_color,...
+            'FontName', label_font,...
+            'FontSize', label_font_size,...
+            'Interpreter', axes_interpreter{ii},...
+            'Rotation', rotate_deg(ii));
+    end
+end
+
+    function horz_aligns = text_alignment(theta)
+        % Pre-allocate cell
+        horz_aligns = cell(length(theta), 1);
+        horz_aligns(:) = {'center'};
+
+        % Iterate through each theta
+        for kk = 1:length(theta)
+            % Adjust horizontal alignment accordingly
+            if theta(kk) <= pi/2
+                horz_aligns{kk} = 'left';
+            elseif theta(kk) < 3*pi/2
+                horz_aligns{kk} = 'right';
+            elseif theta(kk) <= 2*pi
+                horz_aligns{kk} = 'left';
+            end
+        end
+    end
+
+    function rotate_deg = text_rotation(theta)
+        % Find how much to rotate text
+        rotate_deg = theta;
+
+        % Iterate through each theta
+        for kk = 1:length(theta)
+            % Adjust sign and rotation accordingly
+            if theta(kk) == 0
+                rotate_deg(kk) = 0;
+            elseif theta(kk) > 0 && theta(kk) <= pi/2
+                rotate_deg(kk) = theta(kk);
+            elseif theta(kk) > pi/2 && theta(kk) < pi
+                rotate_deg(kk) = -(pi - theta(kk));
+            elseif theta(kk) == pi
+                rotate_deg(kk) = 0;
+            elseif theta(kk) > pi && theta(kk) < 3*pi/2
+                rotate_deg(kk) = -(pi - theta(kk));
+            elseif theta(kk) >= 3*pi/2
+                rotate_deg(kk) = -(2*pi - theta(kk));
+            end
+        end
+    end
+
+    function [horz_align, vert_align] = quadrant_position(theta_point)
+        % Find out which quadrant the point is in
+        if theta_point == 0
+            quadrant = 0;
+        elseif theta_point == pi/2
+            quadrant = 1.5;
+        elseif theta_point == pi
+            quadrant = 2.5;
+        elseif theta_point == 3*pi/2
+            quadrant = 3.5;
+        elseif theta_point == 2*pi
+            quadrant = 0;
+        elseif theta_point > 0 && theta_point < pi/2
+            quadrant = 1;
+        elseif theta_point > pi/2 && theta_point < pi
+            quadrant = 2;
+        elseif theta_point > pi && theta_point < 3*pi/2
+            quadrant = 3;
+        elseif theta_point > 3*pi/2 && theta_point < 2*pi
+            quadrant = 4;
+        end
+        
+        % Adjust label alignment depending on quadrant
+        switch quadrant
+            case 0
+                horz_align = 'left';
+                vert_align = 'middle';
+            case 1
+                horz_align = 'left';
+                vert_align = 'bottom';
+            case 1.5
+                horz_align = 'center';
+                vert_align = 'bottom';
+            case 2
+                horz_align = 'right';
+                vert_align = 'bottom';
+            case 2.5
+                horz_align = 'right';
+                vert_align = 'middle';
+            case 3
+                horz_align = 'right';
+                vert_align = 'top';
+            case 3.5
+                horz_align = 'center';
+                vert_align = 'top';
+            case 4
+                horz_align = 'left';
+                vert_align = 'top';
+        end
+    end
+end
\ No newline at end of file
diff --git a/Requirements/spider_plot/spider_plot_R2019b.m b/Requirements/spider_plot/spider_plot_R2019b.m
new file mode 100644
index 0000000000000000000000000000000000000000..18a237510b2291f0b88e3da92c2caac6a4669183
--- /dev/null
+++ b/Requirements/spider_plot/spider_plot_R2019b.m
@@ -0,0 +1,1372 @@
+function varargout = spider_plot_R2019b(P, options)
+%spider_plot_R2019b Create a spider or radar plot with individual axes.
+%
+% Syntax:
+%   spider_plot_R2019b(P)
+%   spider_plot_R2019b(P, Name, Value, ...)
+%   h = spider_plot_R2019b(_)
+%
+% Input Arguments:
+%   (Required)
+%   P                - The data points used to plot the spider chart. The
+%                      rows are the groups of data and the columns are the
+%                      data points. The axes labels and axes limits are
+%                      automatically generated if not specified.
+%                      [vector | matrix]
+%
+% Output Arguments:
+%   (Optional)
+%   h                - Figure handle of spider plot.
+%                      [figure object]
+%
+% Name-Value Pair Arguments:
+%   (Optional)
+%   AxesLabels       - Used to specify the label each of the axes.
+%                      [auto-generated (default) | cell array of character vectors | 'none']
+%
+%   AxesInterval     - Used to change the number of intervals displayed
+%                      between the webs.
+%                      [3 (default) | integer]
+%
+%   AxesPrecision    - Used to change the precision level on the value
+%                      displayed on the axes.
+%                      [1 (default) | integer | vector]
+%
+%   AxesDisplay      - Used to change the number of axes in which the
+%                      axes text are displayed. 'None' or 'one' can be used
+%                      to simplify the plot appearance for normalized data.
+%                      ['all' (default) | 'none' | 'one' | 'data']
+%
+%   AxesLimits       - Used to manually set the axes limits. A matrix of
+%                      2 x size(P, 2). The top row is the minimum axes
+%                      limits and the bottow row is the maximum axes limits.
+%                      [auto-scaled (default) | matrix]
+%
+%   FillOption       - Used to toggle fill color option.
+%                      ['off' (default) | 'on' | cell array of character vectors]
+%
+%   FillTransparency - Used to set fill color transparency.
+%                      [0.1 (default) | scalar in range (0, 1) | vector]
+%
+%   Color            - Used to specify the line color, specified as an RGB
+%                      triplet. The intensities must be in the range (0, 1).
+%                      [MATLAB colors (default) | RGB triplet]
+%
+%   LineStyle        - Used to change the line style of the plots.
+%                      ['-' (default) | '--' | ':' | '-.' | 'none' | cell array of character vectors]
+%
+%   LineWidth        - Used to change the line width, where 1 point is
+%                      1/72 of an inch.
+%                      [0.5 (default) | positive value | vector]
+%
+%   LineTransparency - Used to set the line color transparency.
+%                      [1 (default) | scalar in range (0, 1) | vector]
+%
+%   Marker           - Used to change the marker symbol of the plots.
+%                      ['o' (default) | 'none' | '*' | 's' | 'd' | ... | cell array of character vectors]
+%
+%   MarkerSize       - Used to change the marker size, where 1 point is
+%                      1/72 of an inch.
+%                      [36 (default) | positive value | vector]
+%
+%   MarkerTransparency-Used to set the marker color transparency.
+%                      [1 (default) | scalar in range (0, 1) | vector]
+%
+%   AxesFont         - Used to change the font type of the values
+%                      displayed on the axes.
+%                      [Helvetica (default) | supported font name]
+%
+%   LabelFont        - Used to change the font type of the labels.
+%                      [Helvetica (default) | supported font name]
+%
+%   AxesFontSize     - Used to change the font size of the values
+%                      displayed on the axes.
+%                      [10 (default) | scalar value greater than zero]
+%
+%   AxesFontColor    - Used to change the font color of the values
+%                      displayed on the axes.
+%                      [black (default) | RGB triplet]
+%
+%   LabelFontSize    - Used to change the font size of the labels.
+%                      [10 (default) | scalar value greater than zero]
+%
+%   Direction        - Used to change the direction of rotation of the
+%                      plotted data and axis labels.
+%                      ['clockwise' (default) | 'counterclockwise']
+%
+%   AxesDirection     - Used to change the direction of axes.
+%                      ['normal' (default) | 'reverse' | cell array of character vectors]
+%
+%   AxesLabelsOffset - Used to adjust the position offset of the axes
+%                      labels.
+%                      [0.2 (default) | positive value]
+%
+%   AxesDataOffset   - Used to adjust the position offset of the data labels
+%                      when AxesDisplay is set to 'data'.
+%                      [0.1 (default) | positive value]
+%
+%   AxesScaling      - Used to change the scaling of the axes.
+%                      ['linear' (default) | 'log' | cell array of character vectors]
+%
+%   AxesColor        - Used to change the color of the spider axes.
+%                      [grey (default) | RGB triplet | hexadecimal color code]
+%
+%   AxesLabelsEdge   - Used to change the edge color of the axes labels.
+%                      [black (default) | RGB triplet | hexadecimal color code | 'none']
+%
+%   AxesOffset       - Used to change to axes offset from the origin.
+%                      [1 (default) | any integer less than the axes interval]
+%
+%   AxesZoom         - Used to change zoom of axes.
+%                      [0.7 (default) | scalar in range (0, 1)]
+%
+%   AxesHorzAlign    - Used to change the horizontal alignment of axes tick labels.
+%                      ['center' (default) | 'left' | 'right' | 'quadrant']
+%
+%   AxesVertAlign    - Used to change the vertical aligment of axes tick labels.
+%                      ['middle' (default) | 'top' | 'cap' | 'bottom' | 'baseline' | 'quadrant']
+%
+%   PlotVisible      - Used to change the visibility of the plotted lines and markers.
+%                      ['on' (default) | 'off']
+%
+%   AxesTickLabels   - Used to change the axes tick labels.
+%                      ['data' (default) | cell array of character vectors]
+%
+%   AxesInterpreter  - Used to change the text interpreter of axes labels and axes tick labels.
+%                      ['tex' (default) | 'latex' | 'none' | cell array of character vectors]
+%
+%   BackgroundColor  - Used to change the color of the background.
+%                      [white (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+%
+%   MinorGrid        - Used to toggle the minor grid.
+%                      ['off' (default) | 'on']
+%
+%   MinorGridInterval- Used to change number of minor grid lines in between the major grid lines.
+%                      [2 (default) | integer value greater than zero]
+%
+%   AxesZero         - Used to add a reference axes at value zero.
+%                      ['off' (default) | 'on']
+%
+%   AxesZeroColor    - Used to change the color of the zero reference axes.
+%                      ['black' (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+%
+%   AxesZeroWidth    - Used to change the line width of the zero reference axes.
+%                      [2 (default) | positive value]
+%
+%   AxesRadial       - Used to toggle radial axes.
+%                      ['on' (default) | 'off']
+%
+%   AxesAngular      - Used to toggle angular axes.
+%                      ['on' (default) | 'off']
+%
+%   AxesShaded       - Used to toggle shaded area around axes.
+%                      ['off' (default) | 'on']
+%
+%   AxesShadedLimits - Used to set the limits of the shaded area. A matrix of
+%                      2 x size(P, 2). The top row is the minimum axes
+%                      limits and the bottow row is the maximum axes limits.
+%                      [AxesLimits (default) | matrix]
+%
+%   AxesShadedColor  - Used to change the color of the shaded area.
+%                      ['green' | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+%
+%   AxesShadedTransparency- Used to the shaded area transparency.
+%                           [0.2 (default) | scalar in range (0, 1)]  
+%
+%   AxesLabelsRotate - Used to rotate the axes labels to be aligned with axes.
+%                      ['off' (default) | 'on']
+%
+% Examples:
+%   % Example 1: Minimal number of arguments. All non-specified, optional
+%                arguments are set to their default values. Axes labels
+%                and limits are automatically generated and set.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot_R2019b(P);
+%   legend('D1', 'D2', 'D3', 'Location', 'southoutside');
+%
+%   % Example 2: Manually setting the axes limits and axes precision.
+%                All non-specified, optional arguments are set to their
+%                default values.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot_R2019b(P,...
+%       'AxesLimits', [1, 2, 1, 1, 1; 10, 8, 9, 5, 10],... % [min axes limits; max axes limits]
+%       'AxesPrecision', [0, 1, 1, 1, 1]);
+%
+%   % Example 3: Set fill option on. The fill transparency can be adjusted.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot_R2019b(P,...
+%       'AxesLabels', {'S1', 'S2', 'S3', 'S4', 'S5'},...
+%       'AxesInterval', 2,...
+%       'FillOption', {'on', 'on', 'off'},...
+%       'FillTransparency', [0.2, 0.1, 0.1]);
+%
+%   % Example 4: Maximum number of arguments.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot_R2019b(P,...
+%       'AxesLabels', {'S1', 'S2', 'S3', 'S4', 'S5'},...
+%       'AxesInterval', 4,...
+%       'AxesPrecision', 0,...
+%       'AxesDisplay', 'one',...
+%       'AxesLimits', [1, 2, 1, 1, 1; 10, 8, 9, 5, 10],...
+%       'FillOption', 'on',...
+%       'FillTransparency', 0.2,...
+%       'Color', [1, 0, 0; 0, 1, 0; 0, 0, 1],...
+%       'LineStyle', {'--', '-', '--'},...
+%       'LineWidth', [1, 2, 3],...
+%       'LineTransparency', 1,...
+%       'Marker', {'o', 'd', 's'},...
+%       'MarkerSize', [8, 10, 12],...
+%       'MarkerTransparency', 1,...
+%       'AxesFont', 'Times New Roman',...
+%       'LabelFont', 'Times New Roman',...
+%       'AxesFontSize', 12,...
+%       'AxesFontColor', 'k',...
+%       'LabelFontSize', 10,...
+%       'Direction', 'clockwise',...
+%       'AxesDirection', {'reverse', 'normal', 'normal', 'normal', 'normal'},...
+%       'AxesLabelsOffset', 0.2,...
+%       'AxesDataOffset', 0.1,...
+%       'AxesScaling', 'linear',...
+%       'AxesColor', [0.6, 0.6, 0.6],...
+%       'AxesLabelsEdge', 'none',...
+%       'AxesOffset', 1,...
+%       'AxesZoom', 1,...
+%       'AxesHorzAlign', 'quadrant',...
+%       'AxesVertAlign', 'quadrant',...
+%       'PlotVisible', 'on',...
+%       'AxesTickLabels', 'data',...
+%       'AxesInterpreter', 'tex',...
+%       'BackgroundColor' , 'w',...
+%       'MinorGrid', 'off',...
+%       'MinorGridInterval', 2,...
+%       'AxesZero', 'off',...
+%       'AxesZeroColor', 'k',...
+%       'AxesZeroWidth', 2,...
+%       'AxesRadial', 'on',...
+%       'AxesAngular', 'on',...
+%       'AxesShaded', 'off',...
+%       'AxesShadedLimits', [],...
+%       'AxesShadedColor', 'g',...
+%       'AxesShadedTransparency', 0.2,...
+%       'AxesLabelsRotate', 'on');
+%
+%   % Example 5: Excel-like radar charts.
+%
+%   D1 = [5 0 3 4 4];
+%   D2 = [2 1 5 5 4];
+%   P = [D1; D2];
+%   spider_plot_R2019b(P,...
+%       'AxesInterval', 5,...
+%       'AxesPrecision', 0,...
+%       'AxesDisplay', 'one',...
+%       'AxesLimits', [0, 0, 0, 0, 0; 5, 5, 5, 5, 5],...
+%       'FillOption', 'on',...
+%       'FillTransparency', 0.1,...
+%       'Color', [139, 0, 0; 240, 128, 128]/255,...
+%       'LineWidth', 4,...
+%       'Marker', 'none',...
+%       'AxesFontSize', 14,...
+%       'LabelFontSize', 10,...
+%       'AxesColor', [0.8, 0.8, 0.8],...
+%       'AxesLabelsEdge', 'none',...
+%       'AxesRadial', 'off');
+%   title('Excel-like Radar Chart',...
+%       'FontSize', 14);
+%   legend_str = {'D1', 'D2'};
+%   legend(legend_str, 'Location', 'southoutside');
+%
+%   % Example 6: Logarithimic scale on specified axes. Axes limits and axes
+%                intervals can be individually set as well.
+%
+%   D1 = [5 3 9 1 1];
+%   D2 = [5 8 7 2 10];
+%   D3 = [8 2 1 4 100];
+%   P = [D1; D2; D3];
+%   spider_plot_R2019b(P,...
+%       'AxesInterval', 2,...
+%       'AxesPrecision', 0,...
+%       'AxesFontSize', 10,...
+%       'AxesLabels', {'Linear Scale', 'Linear Scale', 'Linear Scale', 'Linear Scale', 'Logarithimic Scale'},...
+%       'AxesScaling', {'linear', 'linear', 'linear', 'linear', 'log'},...
+%       'AxesLimits', [1, 1, 1, 1, 1; 10, 10, 10, 10, 100]);
+%   legend('D1', 'D2', 'D3', 'Location', 'northeast');
+%
+%   % Example 7: Spider plot with tiledlayout feature in R2019b.
+%
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   t = tiledlayout(2, 2);
+%   nexttile;
+%   spider_plot_R2019b(P,...
+%       'AxesInterval', 1,...
+%       'AxesPrecision', 0);
+%   nexttile;
+%   spider_plot_R2019b(P,...
+%       'AxesInterval', 1,...
+%       'AxesPrecision', 0);
+%   nexttile(3, [1, 2]);
+%   spider_plot_R2019b(P,...
+%       'AxesInterval', 1,...
+%       'AxesPrecision', 0);
+%   t.TileSpacing = 'compact';
+%   t.Padding = 'compact';
+%   title(t, 'Spider Plots');
+%
+%   % Example 8: Spider plot with values only on data points.
+%   
+%   D1 = [1 3 4 1 2];
+%   D2 = [5 8 7 5 9];
+%   P = [D1; D2];
+%   spider_plot_R2019b(P,...
+%       'AxesLimits', [1, 1, 1, 1, 1; 10, 10, 10, 10, 10],...
+%       'AxesDisplay', 'data',...
+%       'AxesLabelsOffset', 0.2,...
+%       'AxesDataOffset', 0.1,...
+%       'AxesFontColor', [0, 0, 1; 1, 0, 0]);
+%   legend('D1', 'D2', 'Location', 'southoutside');
+%
+%   % Example 9: Spider plot with shaded area around axes.
+%   
+%   D1 = [5 3 9 1 2];
+%   D2 = [5 8 7 2 9];
+%   D3 = [8 2 1 4 6];
+%   P = [D1; D2; D3];
+%   spider_plot(P,...
+%       'AxesShaded', 'on',...
+%       'AxesShadedLimits', [5.5, 4, 3, 2, 4; 7, 6.5, 6, 3.5, 6]); % [min axes limits; max axes limits]
+%
+% Author:
+%   Moses Yoo, (juyoung.m.yoo at gmail dot com)
+%   2022-03-24: Add support for NaN values. Plot NaN values at origin.
+%   2022-03-23: Adjust rotated axes label alignment to be closer to axes.
+%   2022-03-21: Allow axes labels to be rotated to be aligned with axes.
+%   2022-03-17: Allow a shaded band to be plotted around the axes.
+%   2022-02-14: -Add support for reference axes at value zero.
+%               -Allow for toggling radial and angular axes on or off.
+%   2022-01-23: -Add ability to change figure/axes background color.
+%               -Allow for toggling minor grid lines.
+%   2022-01-03: Fix legend to include line and marker attributes.
+%   2021-11-24: Fix axes labels misalignment. Add option to set offset for
+%               data display values.
+%   2021-11-09: Add option to change the text interpreter of axes labels
+%               and axes tick labels.
+%   2021-11-01: -Allow for plot lines and markers to be hidden.
+%               -Allow for custom text of axes tick labels.
+%   2021-09-16: Fix bug for default colors when data groups exceeds 7.
+%   2021-04-17: Fix data display values when log scale is set.
+%   2021-04-13: Add option to adjust line and marker transparency.
+%   2021-04-08: -Add option for data values to be displayed on axes.
+%               -Add support to adjust axes font colors.
+%   2021-03-19: -Allow axes values to be shifted.
+%               -Allow axes zoom level to be adjusted.
+%   2020-12-09: Allow fill option and fill transparency for each data group.
+%   2020-12-01: Added support for adjust the axes offset from origin.
+%   2020-11-30: Allow for one data group without specified axes limits.
+%   2020-11-30: Added support for changing axes and label font type.
+%   2020-11-06: Fix bug in reverse axes direction feature.
+%   2020-10-08: Adjust axes precision to be set to one or more axis.
+%   2020-09-30: -Updated examples.
+%               -Added feature to change spider axes and axes labels edge color.
+%               -Allow logarithmic scale to be set to one or more axis.
+%               -Added feature to allow different line styles, line width,
+%                marker type, and marker sizes for the data groups.
+%               -Allow ability to reverse axes direction.
+%   2020-02-12: Fixed condition and added error checking for when only one
+%               data group is plotted.
+%   2020-01-27: Corrected bug where only 7 entries were allowed in legend.
+%   2020-01-06: Added support for tiledlayout feature introduced in R2019b.
+%   2019-11-27: Add option to change axes to logarithmic scale.
+%   2019-11-15: Add feature to customize the plot rotational direction and
+%               the offset position of the axis labels.
+%   2019-10-28: Major revision in implementing the new function argument
+%               validation feature introduced in R2019b. Replaced previous
+%               method of error checking and setting of default values.
+%   2019-10-23: Minor revision to set starting axes as the vertical line.
+%               Add customization option for font sizes and axes display.
+%   2019-10-16: Minor revision to add name-value pairs for customizing
+%               color, Marker, and line settings.
+%   2019-10-08: Another major revision to convert to name-value pairs and
+%               add color fill option.
+%   2019-09-17: Major revision to improve speed, clarity, and functionality
+%
+% Special Thanks:
+%   Special thanks to Gabriela Andrade, Andrés Garcia, Jiro Doke,
+%   Alex Grenyer, Omar Hadri, Zafar Ali, Christophe Hurlin, Roman,
+%   Mariusz Sepczuk, Mohamed Abubakr, Nicolai, Jingwei Too,
+%   Cedric Jamet, Richard Ruff, Marie-Kristin Schreiber,
+%   Juan Carlos Vargas Rubio, Anthony Wang, Hanting Zhu, Pauline Oeuvray,
+%   Oliver Nicholls, Yu-Chi Chen, Fabrizio De Caro, Waqas Ahmad,
+%   Mario Di Siena, Rebecca & Nikolaos Koutsouleris for their feature
+%   recommendations and bug finds.
+
+%%% Argument Validation %%%
+arguments
+    P (:, :) double
+    options.AxesLabels {validateAxesLabels(options.AxesLabels, P)} = cellstr("Label " + (1:size(P, 2)))
+    options.AxesInterval (1, 1) double {mustBeInteger, mustBePositive} = 3
+    options.AxesPrecision (:, :) double {mustBeInteger, mustBeNonnegative} = 1
+    options.AxesDisplay char {mustBeMember(options.AxesDisplay, {'all', 'none', 'one', 'data'})} = 'all'
+    options.AxesLimits double {validateAxesLimits(options.AxesLimits, P)} = [min(P, [], 1); max(P, [], 1)]
+    options.FillOption {mustBeMember(options.FillOption, {'off', 'on'})} = 'off'
+    options.FillTransparency double {mustBeGreaterThanOrEqual(options.FillTransparency, 0), mustBeLessThanOrEqual(options.FillTransparency, 1)} = 0.2
+    options.Color = get(groot,'defaultAxesColorOrder')
+    options.LineStyle = '-'
+    options.LineWidth (:, :) double {mustBePositive} = 2
+    options.LineTransparency double {mustBeGreaterThanOrEqual(options.LineTransparency, 0), mustBeLessThanOrEqual(options.LineTransparency, 1)} = 1
+    options.Marker = 'o'
+    options.MarkerSize (:, :) double {mustBePositive} = 36
+    options.MarkerTransparency double {mustBeGreaterThanOrEqual(options.MarkerTransparency, 0), mustBeLessThanOrEqual(options.MarkerTransparency, 1)} = 1
+    options.AxesFont char = 'Helvetica'
+    options.LabelFont char = 'Helvetica'
+    options.AxesFontSize (1, 1) double {mustBePositive} = 10
+    options.AxesFontColor = [0, 0, 0]
+    options.LabelFontSize (1, 1) double {mustBePositive} = 10
+    options.Direction char {mustBeMember(options.Direction, {'counterclockwise', 'clockwise'})} = 'clockwise'
+    options.AxesDirection = 'normal'
+    options.AxesLabelsOffset (1, 1) double {mustBeNonnegative} = 0.2
+    options.AxesDataOffset (1, 1) double {mustBeNonnegative} = 0.1
+    options.AxesScaling = 'linear'
+    options.AxesColor = [0.6, 0.6, 0.6]
+    options.AxesLabelsEdge = 'k'
+    options.AxesOffset (1, 1) double {mustBeNonnegative, mustBeInteger} = 1
+    options.AxesZoom double {mustBeGreaterThanOrEqual(options.AxesZoom, 0), mustBeLessThanOrEqual(options.AxesZoom, 1)} = 0.7 % Axes scale
+    options.AxesHorzAlign char {mustBeMember(options.AxesHorzAlign, {'center', 'left', 'right', 'quadrant'})} = 'center' % Horizontal alignment of axes labels
+    options.AxesVertAlign char {mustBeMember(options.AxesVertAlign, {'middle', 'top', 'cap', 'bottom', 'baseline', 'quadrant'})} = 'middle' % Vertical alignment of axes labels
+    options.PlotVisible {mustBeMember(options.PlotVisible, {'off', 'on'})} = 'on'
+    options.AxesTickLabels {mustBeText} = 'data'
+    options.AxesInterpreter {mustBeText} = 'tex'
+    options.BackgroundColor = [1, 1, 1];
+    options.MinorGrid {mustBeMember(options.MinorGrid, {'off', 'on'})} = 'off'
+    options.MinorGridInterval (1, 1) double {mustBePositive, mustBeInteger} = 2
+    options.AxesZero {mustBeMember(options.AxesZero, {'off', 'on'})} = 'off'
+    options.AxesZeroColor = [0, 0, 0];
+    options.AxesZeroWidth (1, 1) double {mustBePositive} = 2
+    options.AxesRadial {mustBeMember(options.AxesRadial, {'off', 'on'})} = 'on'
+    options.AxesAngular {mustBeMember(options.AxesAngular, {'off', 'on'})} = 'on'
+    options.AxesShaded {mustBeMember(options.AxesShaded, {'off', 'on'})} = 'off'
+    options.AxesShadedLimits = [min(P); max(P)]
+    options.AxesShadedColor = 'g'
+    options.AxesShadedTransparency double {mustBeGreaterThanOrEqual(options.AxesShadedTransparency, 0), mustBeLessThanOrEqual(options.AxesShadedTransparency, 1)} = 0.2 % Shading alpha
+    options.AxesLabelsRotate {mustBeMember(options.AxesLabelsRotate, {'off', 'on'})} = 'off'
+end
+
+%%% Data Properties %%%
+% Point properties
+[num_data_groups, num_data_points] = size(P);
+
+%%% Validate Colors
+% Check if there is enough colors
+if size(options.Color, 1) < num_data_groups
+    warning('Warning: Default colors have been applied to match the number of data group. Please enter in "Color" option if specific colors are desired.');
+    options.Color = lines(num_data_groups);
+end
+
+%%% Validate Properties
+% Check if axes offset is valid
+if options.AxesOffset > options.AxesInterval
+    error('Error: Invalid axes offset entry. Please enter in an integer value that is between [0, axes_interval].');
+end
+
+% Check if axes shaded limits is empty
+if isempty(options.AxesShadedLimits)
+    options.AxesShadedLimits = options.AxesLimits;
+end
+
+%%% Validate Axes Precision
+% Check if axes precision is numeric
+if isnumeric(options.AxesPrecision)
+    % Check is length is one
+    if length(options.AxesPrecision) == 1
+        % Repeat array to number of data points
+        options.AxesPrecision = repmat(options.AxesPrecision, num_data_points, 1);
+    elseif length(options.AxesPrecision) ~= num_data_points
+        error('Error: Please specify the same number of axes precision as number of data points.');
+    end
+else
+    error('Error: Please make sure the axes precision is a numeric value.');
+end
+
+%%% Validate Line Style
+% Check if line style is a char
+if ischar(options.LineStyle)
+    % Convert to cell array of char
+    options.LineStyle = cellstr(options.LineStyle);
+    
+    % Repeat cell to number of data groups
+    options.LineStyle = repmat(options.LineStyle, num_data_groups, 1);
+elseif iscellstr(options.LineStyle) %#ok<*ISCLSTR>
+    % Check is length is one
+    if length(options.LineStyle) == 1
+        % Repeat cell to number of data groups
+        options.LineStyle = repmat(options.LineStyle, num_data_groups, 1);
+    elseif length(options.LineStyle) ~= num_data_groups
+        error('Error: Please specify the same number of line styles as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line style is a char or a cell array of char.');
+end
+
+%%% Validate Line Width
+% Check if line width is numeric
+if isnumeric(options.LineWidth)
+    % Check is length is one
+    if length(options.LineWidth) == 1
+        % Repeat array to number of data groups
+        options.LineWidth = repmat(options.LineWidth, num_data_groups, 1);
+    elseif length(options.LineWidth) ~= num_data_groups
+        error('Error: Please specify the same number of line width as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line width is a numeric value.');
+end
+
+%%% Validate Marker
+% Check if marker type is a char
+if ischar(options.Marker)
+    % Convert to cell array of char
+    options.Marker = cellstr(options.Marker);
+    
+    % Repeat cell to number of data groups
+    options.Marker = repmat(options.Marker, num_data_groups, 1);
+elseif iscellstr(options.Marker)
+    % Check is length is one
+    if length(options.Marker) == 1
+        % Repeat cell to number of data groups
+        options.Marker = repmat(options.Marker, num_data_groups, 1);
+    elseif length(options.Marker) ~= num_data_groups
+        error('Error: Please specify the same number of line styles as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line style is a char or a cell array of char.');
+end
+
+%%% Validate Marker Size
+% Check if line width is numeric
+if isnumeric(options.MarkerSize)
+    if length(options.MarkerSize) == 1
+        % Repeat array to number of data groups
+        options.MarkerSize = repmat(options.MarkerSize, num_data_groups, 1);
+    elseif length(options.MarkerSize) ~= num_data_groups
+        error('Error: Please specify the same number of line width as number of data groups.');
+    end
+else
+    error('Error: Please make sure the line width is numeric.');
+end
+
+%%% Validate Axes Scaling
+% Check if axes scaling is valid
+if any(~ismember(options.AxesScaling, {'linear', 'log'}))
+    error('Error: Invalid axes scaling entry. Please enter in "linear" or "log" to set axes scaling.');
+end
+
+% Check if axes scaling is a cell
+if iscell(options.AxesScaling)
+    % Check is length is one
+    if length(options.AxesScaling) == 1
+        % Repeat array to number of data points
+        options.AxesScaling = repmat(options.AxesScaling, num_data_points, 1);
+    elseif length(options.AxesScaling) ~= num_data_points
+        error('Error: Please specify the same number of axes scaling as number of data points.');
+    end
+else
+    % Repeat array to number of data points
+    options.AxesScaling = repmat({options.AxesScaling}, num_data_points, 1);
+end
+
+%%% Validate Axes Direction
+% Check if axes direction is a cell
+if iscell(options.AxesDirection)
+    % Check is length is one
+    if length(options.AxesDirection) == 1
+        % Repeat array to number of data points
+        options.AxesDirection = repmat(options.AxesDirection, num_data_points, 1);
+    elseif length(options.AxesDirection) ~= num_data_points
+        error('Error: Please specify the same number of axes direction as number of data points.');
+    end
+else
+    % Repeat array to number of data points
+    options.AxesDirection = repmat({options.AxesDirection}, num_data_points, 1);
+end
+
+%%% Validate Fill Option
+% Check if fill option is a cell
+if iscell(options.FillOption)
+    % Check is length is one
+    if length(options.FillOption) == 1
+        % Repeat array to number of data groups
+        options.FillOption = repmat(options.FillOption, num_data_groups, 1);
+    elseif length(options.FillOption) ~= num_data_groups
+        error('Error: Please specify the same number of fill option as number of data groups.');
+    end
+else
+    % Repeat array to number of data groups
+    options.FillOption = repmat({options.FillOption}, num_data_groups, 1);
+end
+
+%%% Validate Fill Transparency
+% Check if fill transparency is numeric
+if isnumeric(options.FillTransparency)
+    % Check is length is one
+    if length(options.FillTransparency) == 1
+        % Repeat array to number of data groups
+        options.FillTransparency = repmat(options.FillTransparency, num_data_groups, 1);
+    elseif length(options.FillTransparency) ~= num_data_groups
+        error('Error: Please specify the same number of fill transparency as number of data groups.');
+    end
+else
+    error('Error: Please make sure the transparency is a numeric value.');
+end
+
+%%% Validate Line Transparency
+% Check if line transparency is numeric
+if isnumeric(options.LineTransparency)
+    % Check is length is one
+    if length(options.LineTransparency) == 1
+        % Repeat array to number of data groups
+        options.LineTransparency = repmat(options.LineTransparency, num_data_groups, 1);
+    elseif length(options.LineTransparency) ~= num_data_groups
+        error('Error: Please specify the same number of line transparency as number of data groups.');
+    end
+else
+    error('Error: Please make sure the transparency is a numeric value.');
+end
+
+%%% Validate Marker Transparency
+% Check if marker transparency is numeric
+if isnumeric(options.MarkerTransparency)
+    % Check is length is one
+    if length(options.MarkerTransparency) == 1
+        % Repeat array to number of data groups
+        options.MarkerTransparency = repmat(options.MarkerTransparency, num_data_groups, 1);
+    elseif length(options.MarkerTransparency) ~= num_data_groups
+        error('Error: Please specify the same number of marker transparency as number of data groups.');
+    end
+else
+    error('Error: Please make sure the transparency is a numeric value.');
+end
+
+%%% Validate Axes Font Color
+% Check if axes display is data
+if strcmp(options.AxesDisplay, 'data')
+    if size(options.AxesFontColor, 1) ~= num_data_groups
+        % Check axes font color dimensions
+        if size(options.AxesFontColor, 1) == 1 && size(options.AxesFontColor, 2) == 3
+            options.AxesFontColor = repmat(options.AxesFontColor, num_data_groups, 1);
+        else
+            error('Error: Please specify axes font color as a RGB triplet normalized to 1.');
+        end
+    end
+end
+
+%%% Validate Axes Tick Labels
+% Check if axes tick labels is valid
+if iscell(options.AxesTickLabels)
+    if length(options.AxesTickLabels) ~= options.AxesInterval+1
+        error('Error: Invalid axes tick labels entry. Please enter in a cell array with the same length of axes interval + 1.');
+    end
+else
+    if ~strcmp(options.AxesTickLabels, 'data')
+        error('Error: Invalid axes tick labels entry. Please enter in "data" or a cell array of desired tick labels.');
+    end
+end
+
+%%% Validate Axes Interpreter
+% Check if axes interpreter is valid
+if any(~ismember(options.AxesInterpreter, {'tex', 'latex', 'none'}))
+    error('Error: Please enter either "tex", "latex", or "none" for axes interpreter option.');
+end
+
+% Check if axes interpreter is a char
+if ischar(options.AxesInterpreter)
+    % Convert to cell array of char
+    options.AxesInterpreter = cellstr(options.AxesInterpreter);
+    
+    % Repeat cell to number of axes labels
+    options.AxesInterpreter = repmat(options.AxesInterpreter, length(options.AxesLabels), 1);
+elseif iscellstr(options.AxesInterpreter)
+    % Check is length is one
+    if length(options.AxesInterpreter) == 1
+        % Repeat cell to number of axes labels
+        options.AxesInterpreter = repmat(options.AxesInterpreter, length(options.AxesLabels), 1);
+    elseif length(options.AxesInterpreter) ~= length(options.AxesLabels)
+        error('Error: Please specify the same number of axes interpreters as axes labels.');
+    end
+else
+    error('Error: Please make sure the axes interpreter is a char or a cell array of char.');
+end
+
+%%% Validate Axes Shaded Limits
+% Check if the axes shaded limits same length as the number of points
+if size(options.AxesShadedLimits, 1) ~= 2 || size(options.AxesShadedLimits, 2) ~= num_data_points
+    error('Error: Please make sure the min and max axes shaded limits match the number of data points.');
+end
+
+% Check if within min and max axes limits
+if any(options.AxesShadedLimits(1, :) < options.AxesLimits(1, :)) ||...
+        any(options.AxesShadedLimits(2, :) > options.AxesLimits(2, :))
+    error('Error: Please make sure the axes shaded limits are within the min and max axes limits.');
+end
+
+%%% Axes Scaling Properties %%%
+% Selected data
+P_selected = P;
+
+% Check axes scaling option
+log_index = strcmp(options.AxesScaling, 'log');
+
+% If any log scaling is specified
+if any(log_index)
+    % Initialize copy
+    P_log = P_selected(:, log_index);
+    
+    % Logarithm of base 10, account for numbers less than 1
+    P_log = sign(P_log) .* log10(abs(P_log));
+    
+    % Minimum and maximun log limits
+    min_limit = min(min(fix(P_log)));
+    max_limit = max(max(ceil(P_log)));
+    recommended_axes_interval = max_limit - min_limit;
+    
+    % Warning message
+    warning('For the log scale values, recommended axes limit is [%i, %i] with an axes interval of %i.',...
+        10^min_limit, 10^max_limit, recommended_axes_interval);
+    
+    % Replace original
+    P_selected(:, log_index) = P_log;
+end
+
+%%% Figure Properties %%%
+% Grab current figure
+fig = gcf;
+if nargout > 1
+    error('Error: Too many output arguments assigned.');
+end
+varargout{1} = fig;
+
+% Set figure background
+fig.Color = options.BackgroundColor;
+
+% Reset axes
+cla reset;
+
+% Current axes handle
+ax = gca;
+ax.Color = options.BackgroundColor;
+
+% Axis limits
+scaling_factor = 1 + (1 - options.AxesZoom);
+hold on;
+axis square;
+axis([-1, 1, -1, 1] * scaling_factor);
+
+% Axis properties
+ax.XTickLabel = [];
+ax.YTickLabel = [];
+ax.XColor = 'none';
+ax.YColor = 'none';
+
+% Polar increments
+theta_increment = 2*pi/num_data_points;
+full_interval = options.AxesInterval+1;
+rho_offset = options.AxesOffset/full_interval;
+
+%%% Scale Data %%%
+% Check if axes shaded is on
+if strcmp(options.AxesShaded, 'on')
+    P_selected = [P_selected; options.AxesShadedLimits];
+end
+
+% Pre-allocation
+P_scaled = zeros(size(P_selected));
+axes_range = zeros(3, num_data_points);
+
+% Check axes scaling option
+axes_direction_index = strcmp(options.AxesDirection, 'reverse');
+
+% Iterate through number of data points
+for ii = 1:num_data_points
+    % Check for one data group and no axes limits
+    if num_data_groups == 1 && isempty(options.AxesLimits)
+        % Group of points
+        group_points = P_selected(:, :);
+    else
+        % Group of points
+        group_points = P_selected(:, ii);
+    end
+    
+    % Check for log axes scaling option
+    if log_index(ii)
+        % Minimum and maximun log limits
+        min_value = min(fix(group_points));
+        max_value = max(ceil(group_points));
+    else
+        % Automatically the range of each group
+        min_value = min(group_points);
+        max_value = max(group_points);
+    end
+    
+    % Range of min and max values
+    range = max_value - min_value;
+    
+    % Check if options.AxesLimits is not empty
+    if ~isempty(options.AxesLimits)
+        % Check for log axes scaling option
+        if log_index(ii)
+            % Logarithm of base 10, account for numbers less than 1
+            options.AxesLimits(:, ii) = sign(options.AxesLimits(:, ii)) .* log10(abs(options.AxesLimits(:, ii)));
+        end
+            
+        % Manually set the range of each group
+        min_value = options.AxesLimits(1, ii);
+        max_value = options.AxesLimits(2, ii);
+        range = max_value - min_value;
+        
+        % Check if the axes limits are within range of points
+        if min_value > min(group_points) || max_value < max(group_points)
+            error('Error: Please make sure the manually specified axes limits are within range of the data points.');
+        end
+    end
+    
+    % Check if range is valid
+    if range == 0
+        error('Error: Range of data values is not valid. Please specify the axes limits.');
+    end
+    
+    % Scale points to range from [0, 1]
+    P_scaled(:, ii) = ((P_selected(:, ii) - min_value) / range);
+    
+    % If reverse axes direction is specified
+    if axes_direction_index(ii)
+        % Store to array
+        axes_range(:, ii) = [max_value; min_value; range];
+        P_scaled(:, ii) = -(P_scaled(:, ii) - 1);
+    else
+        % Store to array
+        axes_range(:, ii) = [min_value; max_value; range];
+    end
+    
+    % Add offset of [rho_offset] and scaling factor of [1 - rho_offset]
+    P_scaled(:, ii) = P_scaled(:, ii) * (1 - rho_offset) + rho_offset;
+end
+
+% Check if axes shaded is on
+if strcmp(options.AxesShaded, 'on')
+    P_shaded = P_scaled(end-1:end, :);
+    P_scaled = P_scaled(1:end-2, :);
+end
+
+%%% Polar Axes %%%
+% Polar coordinates
+rho_increment = 1/full_interval;
+rho = 0:rho_increment:1;
+
+% Check specified direction of rotation
+switch options.Direction
+    case 'counterclockwise'
+        % Shift by pi/2 to set starting axis the vertical line
+        theta = (0:theta_increment:2*pi) + (pi/2);
+    case 'clockwise'
+        % Shift by pi/2 to set starting axis the vertical line
+        theta = (0:-theta_increment:-2*pi) + (pi/2);
+end
+
+% Remainder after using a modulus of 2*pi
+theta = mod(theta, 2*pi);
+
+% Check if axes radial is toggled on
+if strcmp(options.AxesRadial, 'on')
+    % Iterate through each theta
+    for ii = 1:length(theta)-1
+        % Convert polar to cartesian coordinates
+        [x_axes, y_axes] = pol2cart(theta(ii), rho);
+
+        % Plot webs
+        h = plot(x_axes, y_axes,...
+            'LineWidth', 1.5,...
+            'Color', options.AxesColor);
+
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if axes angular is toggled on
+if strcmp(options.AxesAngular, 'on')
+    % Iterate through each rho
+    for ii = 2:length(rho)
+        % Convert polar to cartesian coordinates
+        [x_axes, y_axes] = pol2cart(theta, rho(ii));
+
+        % Plot axes
+        h = plot(x_axes, y_axes,...
+            'Color', options.AxesColor);
+
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if minor grid is toggled on
+if strcmp(options.MinorGrid, 'on')
+    % Polar coordinates
+    rho_minor_increment = 1/(full_interval*options.MinorGridInterval);
+    rho_minor = rho(2):rho_minor_increment:1;
+    rho_minor = setdiff(rho_minor, rho(2:end));
+
+    % Iterate through each rho minor
+    for ii = 1:length(rho_minor)
+        % Convert polar to cartesian coordinates
+        [x_axes, y_axes] = pol2cart(theta, rho_minor(ii));
+
+        % Plot axes
+        h = plot(x_axes, y_axes, '--',...
+            'Color', options.AxesColor,...
+            'LineWidth', 0.5);
+
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if axes zero is toggled on
+if strcmp(options.AxesZero, 'on') && strcmp(options.AxesDisplay, 'one')
+     % Scale points to range from [0, 1]
+    zero_scaled = (0 - min_value) / range;
+    
+    % If reverse axes direction is specified
+    if strcmp(options.AxesDirection, 'reverse')
+        zero_scaled = -zero_scaled - 1;
+    end
+
+    % Add offset of [rho_offset] and scaling factor of [1 - rho_offset]
+    zero_scaled = zero_scaled * (1 - rho_offset) + rho_offset;
+
+    % Convert polar to cartesian coordinates
+    [x_axes, y_axes] = pol2cart(theta, zero_scaled);
+
+    % Plot webs
+    h = plot(x_axes, y_axes,...
+        'LineWidth', options.AxesZeroWidth,...
+        'Color', options.AxesZeroColor);
+
+    % Turn off legend annotation
+    h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+end
+
+% Set end index depending on axes display argument
+switch options.AxesDisplay
+    case 'all'
+        theta_end_index = length(theta)-1;
+    case 'one'
+        theta_end_index = 1;
+    case 'none'
+        theta_end_index = 0;
+    case 'data'
+        theta_end_index = 0;
+end
+
+% Rho start index and offset interval
+rho_start_index = options.AxesOffset+1;
+offset_interval = full_interval - options.AxesOffset;
+
+% Alignment for axes labels
+horz_align = options.AxesHorzAlign;
+vert_align = options.AxesVertAlign;
+
+% Iterate through each theta
+for ii = 1:theta_end_index
+    % Convert polar to cartesian coordinates
+    [x_axes, y_axes] = pol2cart(theta(ii), rho);
+    
+    % Check if horizontal alignment is quadrant based
+    if strcmp(options.AxesHorzAlign, 'quadrant')
+        % Alignment based on quadrant
+        [horz_align, ~] = quadrant_position(theta(ii));
+    end
+    
+    % Check if vertical alignment is quadrant based
+    if strcmp(options.AxesVertAlign, 'quadrant')
+        % Alignment based on quadrant
+        [~, vert_align] = quadrant_position(theta(ii));
+    end
+                
+    % Iterate through points on isocurve
+    for jj = rho_start_index:length(rho)
+        % Axes increment range
+        min_value = axes_range(1, ii);
+        range = axes_range(3, ii);
+        
+        % If reverse axes direction is specified
+        if axes_direction_index(ii)
+            % Axes increment value
+            axes_value = min_value - (range/offset_interval) * (jj-rho_start_index);
+        else
+            % Axes increment value
+            axes_value = min_value + (range/offset_interval) * (jj-rho_start_index);
+        end
+        
+        % Check for log axes scaling option
+        if log_index(ii)
+            % Exponent to the tenth power
+            axes_value = 10^axes_value;
+        end
+        
+        % Display axes text
+        if strcmp(options.AxesTickLabels, 'data')
+            text_str = sprintf(sprintf('%%.%if', options.AxesPrecision(ii)), axes_value);
+        else
+            text_str = options.AxesTickLabels{jj-options.AxesOffset};
+        end
+
+        t = text(x_axes(jj), y_axes(jj), text_str,...
+            'Units', 'Data',...
+            'Color', options.AxesFontColor,...
+            'FontName', options.AxesFont,...
+            'FontSize', options.AxesFontSize,...
+            'HorizontalAlignment', horz_align,...
+            'VerticalAlignment', vert_align);
+
+        % Apply to axes tick labels only when not data
+        if iscellstr(options.AxesTickLabels)
+            t.Interpreter = options.AxesInterpreter{1};
+        end
+    end
+end
+
+%%% Plot %%%
+% Fill option index
+fill_option_index = strcmp(options.FillOption, 'on');
+
+% Check if any NaNs detected
+if any(isnan(P_scaled), 'all')
+    % Set value to zero
+    nan_index = isnan(P_scaled);
+    P_scaled(nan_index) = 0;
+end
+
+% Iterate through number of data groups
+for ii = 1:num_data_groups
+    % Convert polar to cartesian coordinates
+    [x_points, y_points] = pol2cart(theta(1:end-1), P_scaled(ii, :));
+    
+    % Make points circular
+    x_circular = [x_points, x_points(1)];
+    y_circular = [y_points, y_points(1)];
+    
+    % Plot data points
+    h = plot(x_circular, y_circular,...
+        'LineStyle', options.LineStyle{ii},...
+        'Color', options.Color(ii, :),...
+        'LineWidth', options.LineWidth(ii),...
+        'Visible', options.PlotVisible);
+    h.Color(4) = options.LineTransparency(ii);
+    
+    % Turn off legend annotation
+    h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+
+    h = scatter(x_circular, y_circular,...
+        'Marker', options.Marker{ii},...
+        'SizeData', options.MarkerSize(ii),...
+        'MarkerFaceColor', options.Color(ii, :),...
+        'MarkerEdgeColor', options.Color(ii, :),...
+        'MarkerFaceAlpha', options.MarkerTransparency(ii),...
+        'MarkerEdgeAlpha', options.MarkerTransparency(ii),...
+        'Visible', options.PlotVisible);
+    
+    % Turn off legend annotation
+    h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+
+    % Plot empty line with combined attributes for legend
+    plot(nan, nan,...
+        'Marker', options.Marker{ii},...
+        'MarkerSize', options.MarkerSize(ii)/6,...
+        'MarkerFaceColor', options.Color(ii, :),...
+        'MarkerEdgeColor', options.Color(ii, :),...
+        'LineStyle', options.LineStyle{ii},...
+        'Color', options.Color(ii, :),...
+        'LineWidth', options.LineWidth(ii),...
+        'Visible', options.PlotVisible);
+        
+    % Iterate through number of data points
+    if strcmp(options.AxesDisplay, 'data')
+        for jj = 1:num_data_points
+            % Convert polar to cartesian coordinates
+            [current_theta, current_rho] = cart2pol(x_points(jj), y_points(jj));
+            [x_pos, y_pos] = pol2cart(current_theta, current_rho+options.AxesDataOffset);
+            
+            % Display axes text
+            data_value = P(ii, jj);
+            text_str = sprintf(sprintf('%%.%if', options.AxesPrecision(jj)), data_value);
+            text(x_pos, y_pos, text_str,...
+                'Units', 'Data',...
+                'Color', options.AxesFontColor(ii, :),...
+                'FontName', options.AxesFont,...
+                'FontSize', options.AxesFontSize,...
+                'HorizontalAlignment', 'center',...
+                'VerticalAlignment', 'middle');
+        end
+    end
+    
+    % Check if fill option is toggled on
+    if fill_option_index(ii)
+        % Fill area within polygon
+        h = patch(x_circular, y_circular, options.Color(ii, :),...
+            'EdgeColor', 'none',...
+            'FaceAlpha', options.FillTransparency(ii));
+        
+        % Turn off legend annotation
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Check if axes shaded is on
+if strcmp(options.AxesShaded, 'on')
+    % Polar verticies of patch
+    P_shaded = [P_shaded, P_shaded(:, 1)];
+    P_shaded = [P_shaded(1, :), P_shaded(2, :)];
+    patch_rho = reshape(P_shaded, 1, []);
+    patch_theta = [theta, theta];
+
+    % Convert polar to cartesian coordinates
+    [x_points, y_points] = pol2cart(patch_theta, patch_rho);
+
+    % Interweave lower and upper limits
+    x_points = reshape(x_points, [], 2)';
+    y_points = reshape(y_points, [], 2)';
+
+    x_points = x_points(:);
+    y_points = y_points(:);
+
+    % Increment through groups of four vertices at a time
+    for ii = 1:2:length(x_points)-2
+        % Verticies and face points
+        v = [x_points(ii:ii+3), y_points(ii:ii+3)];
+        f = [1 2 4 3];
+        
+        % Patch polygon
+        h = patch('Faces', f, 'Vertices', v,...
+            'FaceColor', options.AxesShadedColor,...
+            'EdgeColor', 'none',...
+            'FaceAlpha', options.AxesShadedTransparency);
+        h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+    end
+end
+
+% Get object type of children
+children_type = get(fig.Children, 'Type');
+
+% Check if children is titled layout
+if strcmp(children_type, 'titledlayout')
+    % Set handle to axes children
+    obj = ax.Children;
+else
+    % Set handle to axes
+    obj = ax;
+end
+
+% Find object handles
+text_handles = findobj(obj.Children,...
+    'Type', 'Text');
+patch_handles = findobj(obj.Children,...
+    'Type', 'Patch');
+isocurve_handles = findobj(obj.Children,...
+    'Color', options.AxesColor,...
+    '-and', 'Type', 'Line');
+plot_handles = findobj(obj.Children, '-not',...
+    'Color', options.AxesColor,...
+    '-and', 'Type', 'Line');
+
+% Manually set the stack order
+uistack(plot_handles, 'bottom');
+uistack(patch_handles, 'bottom');
+uistack(isocurve_handles, 'bottom');
+uistack(text_handles, 'top');
+
+%%% Labels %%%
+% Check if axes labels rotate is on
+if strcmp(options.AxesLabelsRotate, 'on')
+    % Find number of degrees to rotate text by
+    rotate_deg = rad2deg(text_rotation(theta));
+
+    % Find the horizontal alignments to align closer to axes
+    horz_aligns = text_alignment(theta);
+else
+    % No rotation
+    rotate_deg = zeros(1, length(theta));
+end
+
+% Check labels argument
+if ~strcmp(options.AxesLabels, 'none')
+    % Iterate through number of data points
+    for ii = 1:length(options.AxesLabels)
+        % Horizontal text alignment by quadrant
+        [horz_align, ~] = quadrant_position(theta(ii));
+
+        % Check if axes labels rotate is on
+        if strcmp(options.AxesLabelsRotate, 'on')
+            % Adjust horizontal text alignment
+            horz_align = horz_aligns{ii};
+        end
+
+        % Convert polar to cartesian coordinates
+        [x_pos, y_pos] = pol2cart(theta(ii), rho(end)+options.AxesLabelsOffset);
+        
+        % Display text label
+        text(x_pos, y_pos, options.AxesLabels{ii},...
+            'Units', 'Data',...
+            'HorizontalAlignment', horz_align,...
+            'VerticalAlignment', 'middle',...
+            'EdgeColor', options.AxesLabelsEdge,...
+            'BackgroundColor', options.BackgroundColor,...
+            'FontName', options.LabelFont,...
+            'FontSize', options.LabelFontSize,...
+            'Interpreter', options.AxesInterpreter{ii},...
+            'Rotation', rotate_deg(ii));
+    end
+end
+
+end
+
+function horz_aligns = text_alignment(theta)
+% Pre-allocate cell
+horz_aligns = cell(length(theta), 1);
+horz_aligns(:) = {'center'};
+
+% Iterate through each theta
+for kk = 1:length(theta)
+    % Adjust horizontal alignment accordingly
+    if theta(kk) <= pi/2
+        horz_aligns{kk} = 'left';
+    elseif theta(kk) < 3*pi/2
+        horz_aligns{kk} = 'right';
+    elseif theta(kk) <= 2*pi
+        horz_aligns{kk} = 'left';
+    end
+end
+
+end
+
+function rotate_deg = text_rotation(theta)
+% Find how much to rotate text
+rotate_deg = theta;
+
+% Iterate through each theta
+for kk = 1:length(theta)
+    % Adjust sign and rotation accordingly
+    if theta(kk) == 0
+        rotate_deg(kk) = 0;
+    elseif theta(kk) > 0 && theta(kk) <= pi/2
+        rotate_deg(kk) = theta(kk);
+    elseif theta(kk) > pi/2 && theta(kk) < pi
+        rotate_deg(kk) = -(pi - theta(kk));
+    elseif theta(kk) == pi
+        rotate_deg(kk) = 0;
+    elseif theta(kk) > pi && theta(kk) < 3*pi/2
+        rotate_deg(kk) = -(pi - theta(kk));
+    elseif theta(kk) >= 3*pi/2
+        rotate_deg(kk) = -(2*pi - theta(kk));
+    end
+end
+
+end
+
+function [horz_align, vert_align] = quadrant_position(theta_point)
+% Find out which quadrant the point is in
+if theta_point == 0
+    quadrant = 0;
+elseif theta_point == pi/2
+    quadrant = 1.5;
+elseif theta_point == pi
+    quadrant = 2.5;
+elseif theta_point == 3*pi/2
+    quadrant = 3.5;
+elseif theta_point == 2*pi
+    quadrant = 0;
+elseif theta_point > 0 && theta_point < pi/2
+    quadrant = 1;
+elseif theta_point > pi/2 && theta_point < pi
+    quadrant = 2;
+elseif theta_point > pi && theta_point < 3*pi/2
+    quadrant = 3;
+elseif theta_point > 3*pi/2 && theta_point < 2*pi
+    quadrant = 4;
+end
+
+% Adjust label alignment depending on quadrant
+switch quadrant
+    case 0
+        horz_align = 'left';
+        vert_align = 'middle';
+    case 1
+        horz_align = 'left';
+        vert_align = 'bottom';
+    case 1.5
+        horz_align = 'center';
+        vert_align = 'bottom';
+    case 2
+        horz_align = 'right';
+        vert_align = 'bottom';
+    case 2.5
+        horz_align = 'right';
+        vert_align = 'middle';
+    case 3
+        horz_align = 'right';
+        vert_align = 'top';
+    case 3.5
+        horz_align = 'center';
+        vert_align = 'top';
+    case 4
+        horz_align = 'left';
+        vert_align = 'top';
+end
+end
+
+%%% Custom Validation Functions %%%
+% Validate axes labels
+function validateAxesLabels(axes_labels, P)
+if ~strcmp(axes_labels, 'none')
+    validateattributes(axes_labels, {'cell'}, {'size', [1, size(P, 2)]}, mfilename, 'axes_labels')
+end
+end
+
+% Validate axes limits
+function validateAxesLimits(axes_limits, P)
+if ~isempty(axes_limits)
+    validateattributes(axes_limits, {'double'}, {'size', [2, size(P, 2)]}, mfilename, 'axes_limits')
+    
+    % Lower and upper limits
+    lower_limits = axes_limits(1, :);
+    upper_limits = axes_limits(2, :);
+    
+    % Difference in upper and lower limits
+    diff_limits = upper_limits - lower_limits;
+    
+    % Check to make sure upper limit is greater than lower limit
+    if any(diff_limits < 0)
+        error('Error: Please make sure max axes limits are greater than the min axes limits.');
+    end
+    
+    % Check the range of axes limits
+    if any(diff_limits == 0)
+        error('Error: Please make sure the min and max axes limits are different.');
+    end
+end
+end
\ No newline at end of file
diff --git a/Requirements/spider_plot/spider_plot_R2019b_examples.mlx b/Requirements/spider_plot/spider_plot_R2019b_examples.mlx
new file mode 100644
index 0000000000000000000000000000000000000000..06656a1f7fefa187e094b0f439d54a4254395095
Binary files /dev/null and b/Requirements/spider_plot/spider_plot_R2019b_examples.mlx differ
diff --git a/Requirements/spider_plot/spider_plot_class.m b/Requirements/spider_plot/spider_plot_class.m
new file mode 100644
index 0000000000000000000000000000000000000000..bf8091519f7c9f4f1b2062491cac70b387e2e4fb
--- /dev/null
+++ b/Requirements/spider_plot/spider_plot_class.m
@@ -0,0 +1,2186 @@
+classdef spider_plot_class < matlab.graphics.chartcontainer.ChartContainer & ...
+        matlab.graphics.chartcontainer.mixin.Legend
+    %spider_plot_class Create a spider or radar plot with individual axes.
+    %
+    % Syntax:
+    %   s = spider_plot_class(P)
+    %   s = spider_plot_class(P, Name, Value, ...)
+    %   s = spider_plot_class(parent, ___)
+    %
+    % Input Arguments:
+    %   (Required)
+    %   P                - The data points used to plot the spider chart. The
+    %                      rows are the groups of data and the columns are the
+    %                      data points. The axes labels and axes limits are
+    %                      automatically generated if not specified.
+    %                      [vector | matrix]
+    %
+    % Name-Value Pair Arguments:
+    %   (Optional)
+    %   AxesLabels       - Used to specify the label each of the axes.
+    %                      [auto-generated (default) | array of strings | 'none']
+    %
+    %   AxesInterval     - Used to change the number of intervals displayed
+    %                      between the webs.
+    %                      [3 (default) | integer]
+    %
+    %   AxesPrecision    - Used to change the precision level on the value
+    %                      displayed on the axes.
+    %                      [1 (default) | integer | vector]
+    %
+    %   AxesDisplay      - Used to change the number of axes in which the
+    %                      axes text are displayed. 'None' or 'one' can be used
+    %                      to simplify the plot appearance for normalized data.
+    %                      ['all' (default) | 'none' | 'one' | 'data']
+    %
+    %   AxesLimits       - Used to manually set the axes limits. A matrix of
+    %                      2 x size(P, 2). The top row is the minimum axes
+    %                      limits and the bottow row is the maximum axes limits.
+    %                      [auto-scaled (default) | matrix]
+    %
+    %   FillOption       - Used to toggle fill color option.
+    %                      ['off' (default) | 'on' | cell array of character vectors]
+    %
+    %   FillTransparency - Used to set fill color transparency.
+    %                      [0.1 (default) | scalar in range (0, 1) | vector]
+    %
+    %   Color            - Used to specify the line color, specified as an RGB
+    %                      triplet. The intensities must be in the range (0, 1).
+    %                      [MATLAB Color (default) | RGB triplet]
+    %
+    %   LineStyle        - Used to change the line style of the plots.
+    %                      ['-' (default) | '--' | ':' | '-.' | 'none']
+    %
+    %   LineWidth        - Used to change the line width, where 1 point is
+    %                      1/72 of an inch.
+    %                      [0.5 (default) | positive value]
+    %
+    %   LineTransparency - Used to set the line color transparency.
+    %                      [1 (default) | scalar in range (0, 1) | vector]
+    %
+    %   Marker           - Used to change the marker symbol of the plots.
+    %                      ['o' (default) | 'none' | '*' | 's' | 'd' | ...]
+    %
+    %   MarkerSize       - Used to change the marker size, where 1 point is
+    %                      1/72 of an inch.
+    %                      [36 (default) | positive value]
+    %
+    %   MarkerTransparency-Used to set the marker color transparency.
+    %                      [1 (default) | scalar in range (0, 1) | vector]
+    %
+    %   AxesFont         - Used to change the font type of the values
+    %                      displayed on the axes.
+    %                      [Helvetica (default) | supported font name]
+    %
+    %   LabelFont        - Used to change the font type of the labels.
+    %                      [Helvetica (default) | supported font name]
+    %
+    %   AxesFontSize     - Used to change the font size of the values
+    %                      displayed on the axes.
+    %                      [10 (default) | scalar value greater than zero]
+    %
+    %   AxesFontColor    - Used to change the font color of the values
+    %                      displayed on the axes.
+    %                      [black (default) | RGB triplet]
+    %
+    %   LabelFontSize    - Used to change the font size of the labels.
+    %                      [10 (default) | scalar value greater than zero]
+    %
+    %   Direction        - Used to change the direction of rotation of the
+    %                      plotted data and axis labels.
+    %                      ['clockwise' (default) | 'counterclockwise']
+    %
+    %   AxesDirection    - Used to change the direction of axes.
+    %                      ['normal' (default) | 'reverse' | cell array of character vectors]
+    %
+    %   AxesLabelsOffset - Used to adjust the position offset of the axes
+    %                      labels.
+    %                      [0.2 (default) | positive value]
+    %
+    %   AxesDataOffset   - Used to adjust the position offset of the data labels
+    %                      when AxesDisplay is set to 'data'.
+    %                      [0.1 (default) | positive value]
+    %
+    %   AxesScaling      - Used to change the scaling of the axes.
+    %                      ['linear' (default) | 'log' | cell array of character vectors]
+    %
+    %   AxesColor        - Used to change the color of the spider axes.
+    %                      [grey (default) | RGB triplet | hexadecimal color code]
+    %
+    %   AxesLabelsEdge   - Used to change the edge color of the axes labels.
+    %                      [black (default) | RGB triplet | hexadecimal color code | 'none']
+    %
+    %   LegendLabels     - Used to add the labels to the legend.
+    %                      [cell array of character vectors]
+    %
+    %   LegendHandle     - Used to customize legend settings. 
+    %                      [legend handle object]
+    %
+    %   AxesOffset       - Used to change to axes offset from the origin.
+    %                      [1 (default) | any integer less than the axes interval]
+    %
+    %   AxesZoom         - Used to change zoom of axes.
+    %                      [0.7 (default) | scalar in range (0, 1)]
+    %
+    %   AxesHorzAlign    - Used to change the horizontal alignment of axes tick labels.
+    %                      ['center' (default) | 'left' | 'right' | 'quadrant']
+    %
+    %   AxesVertAlign    - Used to change the vertical aligment of axes tick labels.
+    %                      ['middle' (default) | 'top' | 'cap' | 'bottom' | 'baseline' | 'quadrant']
+    %
+    %   TiledLayoutHandle- Used to customize tiled layout settings. 
+    %                      [tiled chart layout handle object]
+    %
+    %   TiledLegendHandle- Used to customize tiled legend settings. 
+    %                      [legend handle object of tiled layout]
+    %
+    %   NextTileIter     - Iterates with consecutive tile plots. 
+    %                      [1 (default)]
+    %
+    %   PlotVisible      - Used to change the visibility of the plotted lines and markers.
+    %                      ['on' (default) | 'off']
+    %
+    %   AxesTickLabels   - Used to change the axes tick labels.
+    %                      ['data' (default) | cell array of character vectors]
+    %
+    %   AxesInterpreter  - Used to change the text interpreter of axes labels and axes tick labels.
+    %                      ['tex' (default) | 'latex' | 'none'  | cell array of character vectors]
+    %
+    %   BackgroundColor  - Used to change the color of the background.
+    %                      [white (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+    %
+    %   MinorGrid        - Used to toggle the minor grid.
+    %                      ['off' (default) | 'on']
+    %
+    %   MinorGridInterval- Used to change number of minor grid lines in between the major grid lines.
+    %                      [2 (default) | integer value greater than zero]
+    %
+    %   AxesZero         - Used to add a reference axes at value zero.
+    %                      ['off' (default) | 'on']
+    %
+    %   AxesZeroColor    - Used to change the color of the zero reference axes.
+    %                      ['black' (default) | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+    %
+    %   AxesZeroWidth    - Used to change the line width of the zero reference axes.
+    %                      [2 (default) | positive value]
+    %
+    %   AxesRadial       - Used to toggle radial axes.
+    %                      ['on' (default) | 'off']
+    %
+    %   AxesAngular      - Used to toggle angular axes.
+    %                      ['on' (default) | 'off']
+    %
+    %   AxesShaded       - Used to toggle shaded area around axes.
+    %                      ['off' (default) | 'on']
+    %
+    %   AxesShadedLimits - Used to set the limits of the shaded area. A matrix of
+    %                      2 x size(P, 2). The top row is the minimum axes
+    %                      limits and the bottow row is the maximum axes limits.
+    %                      [AxesLimits (default) | matrix]
+    %
+    %   AxesShadedColor  - Used to change the color of the shaded area.
+    %                      ['green' | RGB triplet | hexadecimal color code | 'r' | 'g' | 'b' | ...]
+    %
+    %   AxesShadedTransparency- Used to the shaded area transparency.
+    %                           [0.2 (default) | scalar in range (0, 1)]
+    %
+    %   AxesLabelsRotate - Used to rotate the axes labels to be aligned with axes.
+    %                      ['off' (default) | 'on']
+    %
+    % Output Arguments:
+    %   (Optional)
+    %   s                - Returns a chart class object. These are unique
+    %                      identifiers, which you can use to query and
+    %                      modify properties of the spider chart.
+    %                      [chart class object]
+    %
+    % Examples:
+    %   % Example 1: Minimal number of arguments. All non-specified, optional
+    %                arguments are set to their default values. Axes labels
+    %                and limits are automatically generated and set.
+    %
+    %   D1 = [5 3 9 1 2];
+    %   D2 = [5 8 7 2 9];
+    %   D3 = [8 2 1 4 6];
+    %   P = [D1; D2; D3];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.LegendLabels = {'D1', 'D2', 'D3'};
+    %   s.LegendHandle.Location = 'southoutside';
+    %
+    %   % Example 2: Manually setting the axes limits and axes precision.
+    %                All non-specified, optional arguments are set to their
+    %                default values.
+    %
+    %   D1 = [5 3 9 1 2];
+    %   D2 = [5 8 7 2 9];
+    %   D3 = [8 2 1 4 6];
+    %   P = [D1; D2; D3];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesLimits = [1, 2, 1, 1, 1; 10, 8, 9, 5, 10]; % [min axes limits; max axes limits]
+    %   s.AxesPrecision = [0, 1, 1, 1, 1];
+    %
+    %   % Example 3: Set fill option on. The fill transparency can be adjusted.
+    %
+    %   D1 = [5 3 9 1 2];
+    %   D2 = [5 8 7 2 9];
+    %   D3 = [8 2 1 4 6];
+    %   P = [D1; D2; D3];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesLabels = {'S1', 'S2', 'S3', 'S4', 'S5'};
+    %   s.AxesInterval = 2;
+    %   s.FillOption = {'on', 'on', 'off'};
+    %   s.FillTransparency = [0.2, 0.1, 0.1];
+    %
+    %   % Example 4: Maximum number of arguments.
+    %
+    %   D1 = [5 3 9 1 2];
+    %   D2 = [5 8 7 2 9];
+    %   D3 = [8 2 1 4 6];
+    %   P = [D1; D2; D3];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesLabels = {'S1', 'S2', 'S3', 'S4', 'S5'};
+    %   s.AxesInterval = 4;
+    %   s.AxesPrecision = 0;
+    %   s.AxesDisplay = 'one';
+    %   s.AxesLimits = [1, 2, 1, 1, 1; 10, 8, 9, 5, 10];
+    %   s.FillOption = 'on';
+    %   s.FillTransparency =  0.2;
+    %   s.Color = [1, 0, 0; 0, 1, 0; 0, 0, 1];
+    %   s.LineStyle = '--';
+    %   s.LineWidth = 3;
+    %   s.LineTransparency = 1;
+    %   s.Marker =  'd';
+    %   s.MarkerSize = 10;
+    %   s.MarkerTransparency = 1;
+    %   s.AxesFont = 'Times New Roman';
+    %   s.LabelFont = 'Times New Roman';
+    %   s.AxesFontSize = 12;
+    %   s.AxesFontColor = 'k';
+    %   s.LabelFontSize = 10;
+    %   s.Direction = 'clockwise';
+    %   s.AxesDirection = {'reverse', 'normal', 'normal', 'normal', 'normal'};
+    %   s.AxesLabelsOffset = 0.2;
+    %   s.AxesDataOffset = 0.1;
+    %   s.AxesScaling = 'linear';
+    %   s.AxesOffset = 1;
+    %   s.LegendLabels = {'D1', 'D2', 'D3'};
+    %   s.LegendHandle.Location = 'northeastoutside';
+    %   s.PlotVisible = 'on';
+    %   s.AxesTickLabels = 'data';
+    %   s.AxesInterpreter =  'tex';
+    %   s.BackgroundColor = 'w';
+    %   s.MinorGrid = 'off';
+    %   s.MinorGridInterval = 2;
+    %   s.AxesZero = 'off';
+    %   s.AxesZeroColor = 'k';
+    %   s.AxesZeroWidth = 2;
+    %   s.AxesRadial = 'on';
+    %   s.AxesAngular = 'on';
+    %   s.AxesShaded = 'off';
+    %   s.AxesShadedLimits = [];
+    %   s.AxesShadedColor = 'g';
+    %   s.AxesShadedTransparency = 0.2;
+    %   s.AxesLabelsRotate = 'on';
+    %
+    %   % Example 5: Excel-like radar charts.
+    %
+    %   D1 = [5 0 3 4 4];
+    %   D2 = [2 1 5 5 4];
+    %   P = [D1; D2];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesInterval = 5;
+    %   s.AxesPrecision = 0;
+    %   s.AxesDisplay = 'one';
+    %   s.AxesLimits = [0, 0, 0, 0, 0; 5, 5, 5, 5, 5];
+    %   s.FillOption = 'on';
+    %   s.FillTransparency = 0.1;
+    %   s.Color = [139, 0, 0; 240, 128, 128]/255;
+    %   s.LineWidth = 4;
+    %   s.Marker = 'none';
+    %   s.AxesFontSize = 14;
+    %   s.LabelFontSize = 10;
+    %   s.AxesColor = [0.8, 0.8, 0.8];
+    %   s.AxesLabelsEdge = 'none';
+    %   s.AxesRadial = 'off';
+    %   title('Excel-like Radar Chart',...
+    %       'FontSize', 14);
+    %   s.LegendLabels = {'D1', 'D2'};
+    %
+    %   % Example 6: Logarithimic scale on all axes. Axes limits and axes
+    %                intervals are automatically set to factors of 10.
+    %
+    %   D1 = [5 3 9 1 1];
+    %   D2 = [5 8 7 2 10];
+    %   D3 = [8 2 1 4 100];
+    %   P = [D1; D2; D3];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesInterval = 2;
+    %   s.AxesPrecision = 0;
+    %   s.AxesFontSize = 10;
+    %   s.AxesLabels = {'Linear Scale', 'Linear Scale', 'Linear Scale', 'Linear Scale', 'Logarithimic Scale'};
+    %   s.AxesScaling = {'linear', 'linear', 'linear', 'linear', 'log'};
+    %   s.AxesLimits = [1, 1, 1, 1, 1; 10, 10, 10, 10, 100];
+    %   s.LegendLabels = {'D1', 'D2', 'D3'};
+    %
+    %   % Example 7: Spider plot with tiledlayout.
+    %
+    %   D1 = [5 3 9 1 2];
+    %   D2 = [5 8 7 2 9];
+    %   D3 = [8 2 1 4 6];
+    %   P = [D1; D2; D3];
+    %   close all;
+    %   figure;
+    %   s1 = spider_plot_class(P);
+    %   s1.LegendLabels = {'Data1a', 'Data1b', 'Data1c'};
+    %   s1.AxesZoom = 1;
+    %   s1.AxesHorzAlign = 'quadrant';
+    %   s1.AxesVertAlign = 'quadrant';
+    %   figure;
+    %   s2 = spider_plot_class(P);
+    %   s2.LegendLabels = {'Data2a', 'Data2b', 'Data2c'};
+    %   s2.AxesZoom = 1;
+    %   s2.AxesHorzAlign = 'center';
+    %   s2.AxesVertAlign = 'top';
+    %   figure;
+    %   s3 = spider_plot_class(P);
+    %   s3.LegendLabels = {'Data3a', 'Data3b', 'Data3c'};
+    %   s3.AxesZoom = 1;
+    %   s3.AxesHorzAlign = 'left';
+    %   s3.AxesVertAlign = 'middle';
+    %   s1.tiledlayout(2, 2);
+    %   s1.nexttile(s1);
+    %   s1.nexttile(s2);
+    %   s1.nexttile(s3, 3, [1, 2]);
+    %   s1.TiledLayoutHandle.TileSpacing = 'none';
+    %   s1.TiledLayoutHandle.Padding = 'compact';
+    %   title(s1.TiledLayoutHandle, "Spider Plots");
+    %   s1.tiledlegend('FontSize', 8);
+    %   s1.TiledLegendHandle.Layout.TileSpan = [1, 2];
+    %   s1.TiledLegendHandle.Layout.Tile = 1;
+    %
+    % Example 8: Spider plot with values only on data points.
+    %   
+    %   D1 = [1 3 4 1 2];
+    %   D2 = [5 8 7 5 9];
+    %   P = [D1; D2];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesLimits = [1, 1, 1, 1, 1; 10, 10, 10, 10, 10];
+    %   s.AxesDisplay = 'data';
+    %   s.AxesLabelsOffset = 0.2;
+    %   s.AxesDataOffset = 0.1;
+    %   s.AxesFontColor = [0, 0, 1; 1, 0, 0];
+    %   s.LegendLabels = {'D1', 'D2'};
+    %   s.LegendHandle.Location = 'northeastoutside';
+    %
+    %   % Example 9: Spider plot with shaded area around axes.
+    %   
+    %   D1 = [5 3 9 1 2];
+    %   D2 = [5 8 7 2 9];
+    %   D3 = [8 2 1 4 6];
+    %   P = [D1; D2; D3];
+    %   if exist('s', 'var')
+    %       delete(s);
+    %   end
+    %   s = spider_plot_class(P);
+    %   s.AxesShaded = 'on';
+    %   s.AxesShadedLimits = [5.5, 4, 3, 2, 4; 7, 6.5, 6, 3.5, 6]; % [min axes limits; max axes limits]
+    %
+    % Author:
+    %   Moses Yoo, (juyoung.m.yoo at gmail dot com)
+    %   2022-03-24: Add support for NaN values. Plot NaN values at origin.
+    %   2022-03-23: Adjust rotated axes label alignment to be closer to axes.
+    %   2022-03-21: Allow axes labels to be rotated to be aligned with axes.
+    %   2022-03-17: Allow a shaded band to be plotted around the axes.
+    %   2022-02-14: -Add support for reference axes at value zero.
+    %               -Allow for toggling radial and angular axes on or off.
+    %   2022-01-23: -Add ability to change figure/axes background color.
+    %               -Allow for toggling minor grid lines.
+    %   2022-01-03: Fix legend to include line and marker attributes.
+    %   2021-11-24: Fix axes labels misalignment. Add option to set offset for
+    %               data display values.
+    %   2021-11-09: Add option to change the text interpreter of axes labels
+    %               and axes tick labels.
+    %   2021-11-01: -Allow for plot lines and markers to be hidden.
+    %               -Allow for custom text of axes tick labels.
+    %   2021-04-17: Fix data display values when log scale is set.
+    %   2021-04-13: Add option to adjust line and marker transparency.
+    %   2021-04-08: -Add option for data values to be displayed on axes.
+    %               -Add support to adjust axes font colors.
+    %   2021-03-19: -Allow legend to be global in tiledlayout.
+    %               -Allow axes values to be shifted.
+    %               -Allow axes zoom level to be adjusted.
+    %   2021-03-17: Implement tiledlayout and nexttile compatibility.
+    %   2020-12-09: Allow fill option and fill transparency for each data group.
+    %   2020-12-01: Added support for adjust the axes offset from origin.
+    %   2020-11-30: Allow for one data group without specified axes limits.
+    %   2020-11-30: Added support for changing axes and label font type.
+    %   2020-11-06: Fix bug in reverse axes direction feature.
+    %   2020-10-08: Adjust axes precision to be set to one or more axis.
+    %   2020-10-01: Fix legend feature with inherited legend class.
+    %   2020-09-30: -Fix axes limit bug. Updated examples.
+    %               -Added feature to change spider axes and axes labels edge color.
+    %               -Allow logarithmic scale to be set to one or more axis.
+    %               -Added feature to allow different line styles, line width,
+    %                marker type, and marker sizes for the data groups.
+    %               -Allow ability to reverse axes direction.
+    %   2020-02-17: Major revision in converting the function into a custom
+    %               chart class. New feature introduced in R2019b.
+    %   2020-02-12: Fixed condition and added error checking for when only one
+    %               data group is plotted.
+    %   2020-01-27: Corrected bug where only 7 entries were allowed in legend.
+    %   2020-01-06: Added support for tiledlayout feature introduced in R2019b.
+    %   2019-11-27: Add option to change axes to logarithmic scale.
+    %   2019-11-15: Add feature to customize the plot rotational direction and
+    %               the offset position of the axis labels.
+    %   2019-10-28: Major revision in implementing the new function argument
+    %               validation feature introduced in R2019b. Replaced previous
+    %               method of error checking and setting of default values.
+    %   2019-10-23: Minor revision to set starting axes as the vertical line.
+    %               Add customization option for font sizes and axes display.
+    %   2019-10-16: Minor revision to add name-value pairs for customizing
+    %               color, Marker, and line settings.
+    %   2019-10-08: Another major revision to convert to name-value pairs and
+    %               add color fill option.
+    %   2019-09-17: Major revision to improve speed, clarity, and functionality
+    %
+    % Special Thanks:
+    %   Special thanks to Gabriela Andrade, Andrés Garcia, Alex Grenyer,
+    %   Omar Hadri, Zafar Ali, Christophe Hurlin, Roman, Mariusz Sepczuk,
+    %   Mohamed Abubakr, Maruis Mueller, Nicolai, Jingwei Too,
+    %   Cedric Jamet, Richard Ruff, Marie-Kristin Schreiber, Jean-Baptise
+    %   Billaud, Juan Carlos Vargas Rubio, Anthony Wang, Pauline Oeuvray
+    %   Oliver Nicholls, Yu-Chi Chen, Fabrizio De Caro, Waqas Ahmad,
+    %   Mario Di Siena, Rebecca & Nikolaos Koutsouleris for their feature
+    %   recommendations and bug finds. A huge thanks to Jiro Doke and
+    %   Sean de Wolski for demonstrating the implementation of argument
+    %   validation and custom chart class introduced in R2019b.
+    
+    %%% Public, SetObservable Properties %%%
+    properties(Access = public, SetObservable)
+        % Property validation and defaults
+        P (:, :) double
+        AxesLabels cell % Axes labels
+        LegendLabels cell % Legend labels
+        LegendHandle % Legend handle
+        AxesInterval (1, 1) double {mustBeInteger, mustBePositive} = 3 % Number of axes grid lines
+        AxesPrecision (:, :) double {mustBeInteger, mustBeNonnegative} = 1 % Tick precision
+        AxesDisplay char {mustBeMember(AxesDisplay, {'all', 'none', 'one', 'data'})} = 'all'  % Number of tick label groups shown on axes
+        AxesLimits double = [] % Axes limits
+        FillOption {mustBeMember(FillOption, {'on', 'off'})} = 'off' % Whether to shade data
+        FillTransparency double {mustBeGreaterThanOrEqual(FillTransparency, 0), mustBeLessThanOrEqual(FillTransparency, 1)} = 0.2 % Shading alpha
+        Color = get(groot,'defaultAxesColorOrder') % Color order
+        LineStyle = '-' % Data line style
+        LineWidth (:, :) double {mustBePositive} = 2 % Data line width
+        LineTransparency double {mustBeGreaterThanOrEqual(LineTransparency, 0), mustBeLessThanOrEqual(LineTransparency, 1)} = 1 % Shading alpha
+        Marker = 'o' % Data marker
+        MarkerSize (:, :) double {mustBePositive} = 36 % Data marker size
+        MarkerTransparency double {mustBeGreaterThanOrEqual(MarkerTransparency, 0), mustBeLessThanOrEqual(MarkerTransparency, 1)} = 1 % Shading alpha
+        AxesFont char ='Helvetica' % Axes tick font type
+        AxesFontColor = [0, 0, 0] % Axes font color
+        LabelFont char = 'Helvetica' % Label font type
+        AxesFontSize (1, 1) double {mustBePositive} = 10 % Axes tick font size
+        LabelFontSize (1, 1) double {mustBePositive} = 10 % Label font size
+        Direction char {mustBeMember(Direction, {'counterclockwise', 'clockwise'})} = 'clockwise'
+        AxesDirection = 'normal'
+        AxesLabelsOffset (1, 1) double {mustBeNonnegative} = 0.2 % Offset position of axes labels
+        AxesDataOffset (1, 1) double {mustBeNonnegative} = 0.1 % Offset position of axes data labels
+        AxesScaling = 'linear' % Scaling of axes
+        AxesColor = [0.6, 0.6, 0.6] % Axes color
+        AxesLabelsEdge = 'k' % Axes label color
+        AxesOffset (1, 1) double {mustBeNonnegative, mustBeInteger} = 1 % Axes offset
+        AxesZoom double {mustBeGreaterThanOrEqual(AxesZoom, 0), mustBeLessThanOrEqual(AxesZoom, 1)} = 0.7 % Axes scale
+        AxesHorzAlign char {mustBeMember(AxesHorzAlign, {'center', 'left', 'right', 'quadrant'})} = 'center' % Horizontal alignment of axes labels
+        AxesVertAlign char {mustBeMember(AxesVertAlign, {'middle', 'top', 'cap', 'bottom', 'baseline', 'quadrant'})} = 'middle' % Vertical alignment of axes labels
+        TiledLayoutHandle % Tiled layout handle
+        TiledLegendHandle % Tiled legend handle
+        PlotVisible {mustBeMember(PlotVisible, {'off', 'on'})} = 'on'
+        AxesTickLabels {mustBeText} = 'data'
+        AxesInterpreter {mustBeText} = 'tex'
+        BackgroundColor = [1, 1, 1]
+        MinorGrid {mustBeMember(MinorGrid, {'off', 'on'})} = 'off'
+        MinorGridInterval (1, 1) double {mustBePositive, mustBeInteger} = 2
+        AxesZero {mustBeMember(AxesZero, {'off', 'on'})} = 'off'
+        AxesZeroColor = [0, 0, 0];
+        AxesZeroWidth (1, 1) double {mustBePositive} = 2
+        AxesRadial {mustBeMember(AxesRadial, {'off', 'on'})} = 'on'
+        AxesAngular {mustBeMember(AxesAngular, {'off', 'on'})} = 'on'
+        AxesShaded {mustBeMember(AxesShaded, {'off', 'on'})} = 'off'
+        AxesShadedLimits double = []
+        AxesShadedColor = 'g'
+        AxesShadedTransparency double {mustBeGreaterThanOrEqual(AxesShadedTransparency, 0), mustBeLessThanOrEqual(AxesShadedTransparency, 1)} = 0.2 % Shading alpha
+        AxesLabelsRotate {mustBeMember(AxesLabelsRotate, {'off', 'on'})} = 'off'
+    end
+
+    %%% Private, NonCopyable, Transient Properties %%%
+    properties(Access = private, NonCopyable, Transient)
+        % Data line object
+        DataLines = gobjects(0);
+        ScatterPoints = gobjects(0);
+        NanPoints = gobjects(0);
+        
+        % Background web object
+        ThetaAxesLines = gobjects(0);
+        RhoAxesLines = gobjects(0);
+        RhoMinorLines = gobjects(0);
+        
+        % Fill shade object
+        FillPatches = gobjects(0);
+        AxesPatches = gobjects(0);
+        
+        % Web axes tick values
+        AxesValues = [];
+        
+        % Axes label object
+        AxesTextLabels = gobjects(0);
+        AxesTickText = gobjects(0);
+        AxesDataLabels = gobjects(0);
+        
+        % Initialize toggle state
+        InitializeToggle = true;
+        
+        % NextTile iterator
+        NextTileIter (1, 1) double {mustBeInteger, mustBePositive} = 1 
+    end
+    
+    %%% Protected, Dependent, Hidden Properties %%%
+    properties(Access = protected, Dependent, Hidden)
+        NumDataGroups
+        NumDataPoints
+    end
+    
+    methods
+        %%% Constructor Methods %%%
+        function obj = spider_plot_class(parentOrP, varargin)
+            % Validate number of input arguments
+            narginchk(1, inf);
+            
+            % Check if first argument is a graphic object or data
+            if isa(parentOrP, 'matlab.graphics.Graphics')
+                % spider_plot_class(parent, P, Name, Value, ...)
+                args = [{parentOrP, 'P'}, varargin];
+            else
+                % spider_plot_class(P, Name, Value, ...)
+                args = [{'P', parentOrP}, varargin];
+            end
+            
+            % Call superclass constructor method
+            obj@matlab.graphics.chartcontainer.ChartContainer(args{:});
+        end
+        
+        %%% Set Methods %%%
+        function set.P(obj, value)
+            % Set property
+            obj.P = value;
+            
+            % Toggle re-initialize to true if P was changed
+            obj.InitializeToggle = true; %#ok<*MCSUP>
+        end
+        
+        function set.AxesLabels(obj, value)
+            % Validate axes labels
+            validateAxesLabels(value, obj.P);
+            
+            % Set property
+            obj.AxesLabels = value;
+            
+            % Toggle re-initialize to true if AxesLabels was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.LegendLabels(obj, value)
+            % Validate legend labels
+            validateLegendLabels(value, obj.P);
+            
+            % Set property
+            obj.LegendLabels = value;
+            obj.LegendVisible = 'on';
+            
+            % Set legend handle
+            obj.LegendHandle = getLegend(obj);
+            obj.LegendHandle.Color = obj.BackgroundColor;
+            
+            % Toggle re-initialize to true if LegendLabels was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesInterval(obj, value)
+            % Set property
+            obj.AxesInterval = value;
+            
+            % Toggle re-initialize to true if AxesInterval was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesPrecision(obj, value)
+            % Set property
+            obj.AxesPrecision = value;
+            
+            % Toggle re-initialize to true if AxesPrecision was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesDisplay(obj, value)
+            % Set property
+            obj.AxesDisplay = value;
+            
+            % Toggle re-initialize to true if AxesDisplay was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesLimits(obj, value)
+            % Set property
+            obj.AxesLimits = value;
+            
+            % Toggle re-initialize to true if AxesLimits was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.FillOption(obj, value)
+            % Set property
+            obj.FillOption = value;
+            
+            % Toggle re-initialize to true if FillOption was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.FillTransparency(obj, value)
+            % Set property
+            obj.FillTransparency = value;
+            
+            % Toggle re-initialize to true if FillTransparency was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.Color(obj, value)
+            % Set property
+            obj.Color = value;
+            
+            % Toggle re-initialize to true if Color was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.LineStyle(obj, value)
+            % Set property
+            obj.LineStyle = value;
+            
+            % Toggle re-initialize to true if LineStyle was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.LineWidth(obj, value)
+            % Set property
+            obj.LineWidth = value;
+            
+            % Toggle re-initialize to true if LineWidth was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.LineTransparency(obj, value)
+            % Set property
+            obj.LineTransparency = value;
+            
+            % Toggle re-initialize to true if LineTransparency was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.Marker(obj, value)
+            % Set property
+            obj.Marker = value;
+            
+            % Toggle re-initialize to true if Marker was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.MarkerSize(obj, value)
+            % Set property
+            obj.MarkerSize = value;
+            
+            % Toggle re-initialize to true if MarkerSize was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.MarkerTransparency(obj, value)
+            % Set property
+            obj.MarkerTransparency = value;
+            
+            % Toggle re-initialize to true if MarkerTransparency was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesFont(obj, value)
+            % Set property
+            obj.AxesFont = value;
+            
+            % Toggle re-initialize to true if AxesFont was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.LabelFont(obj, value)
+            % Set property
+            obj.LabelFont = value;
+            
+            % Toggle re-initialize to true if LabelFont was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesFontSize(obj, value)
+            % Set property
+            obj.AxesFontSize = value;
+            
+            % Toggle re-initialize to true if AxesFontSize was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesFontColor(obj, value)
+            % Set property
+            obj.AxesFontColor = value;
+            
+            % Toggle re-initialize to true if AxesFontColor was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.LabelFontSize(obj, value)
+            % Set property
+            obj.LabelFontSize = value;
+            
+            % Toggle re-initialize to true if LabelFontSize was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.Direction(obj, value)
+            % Set property
+            obj.Direction = value;
+            
+            % Toggle re-initialize to true if Direction was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesDirection(obj, value)
+            % Set property
+            obj.AxesDirection = value;
+            
+            % Toggle re-initialize to true if Direction was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesLabelsOffset(obj, value)
+            % Set property
+            obj.AxesLabelsOffset = value;
+            
+            % Toggle re-initialize to true if AxesLabelsOffset was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesScaling(obj, value)
+            % Set property
+            obj.AxesScaling = value;
+            
+            % Toggle re-initialize to true if AxesScaling was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesColor(obj, value)
+            % Set property
+            obj.AxesColor = value;
+            
+            % Toggle re-initialize to true if AxesColor was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesLabelsEdge(obj, value)
+            % Set property
+            obj.AxesLabelsEdge = value;
+            
+            % Toggle re-initialize to true if AxesLabelsEdge was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesOffset(obj, value)
+            % Set property
+            obj.AxesOffset = value;
+            
+            % Toggle re-initialize to true if AxesOffset was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesZoom(obj, value)
+            % Set property
+            obj.AxesZoom = value;
+            
+            % Toggle re-initialize to true if AxesZoom was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesHorzAlign(obj, value)
+            % Set property
+            obj.AxesHorzAlign = value;
+            
+            % Toggle re-initialize to true if AxesHorzAlign was changed
+            obj.InitializeToggle = true;
+        end
+        
+        function set.AxesVertAlign(obj, value)
+            % Set property
+            obj.AxesVertAlign = value;
+            
+            % Toggle re-initialize to true if AxesVertAlign was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesTickLabels(obj, value)
+            % Set property
+            obj.AxesTickLabels = value;
+            
+            % Toggle re-initialize to true if AxesTickLabels was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesInterpreter(obj, value)
+            % Set property
+            obj.AxesInterpreter = value;
+            
+            % Toggle re-initialize to true if AxesInterpreter was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.BackgroundColor(obj, value)
+            % Set property
+            obj.BackgroundColor = value;
+            
+            % Toggle re-initialize to true if BackgroundColor was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.MinorGrid(obj, value)
+            % Set property
+            obj.MinorGrid = value;
+            
+            % Toggle re-initialize to true if MinorGrid was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.MinorGridInterval(obj, value)
+            % Set property
+            obj.MinorGridInterval = value;
+            
+            % Toggle re-initialize to true if MinorGridInterval was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesZero(obj, value)
+            % Set property
+            obj.AxesZero = value;
+            
+            % Toggle re-initialize to true if AxesZero was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesZeroColor(obj, value)
+            % Set property
+            obj.AxesZeroColor = value;
+            
+            % Toggle re-initialize to true if AxesZeroColor was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesZeroWidth(obj, value)
+            % Set property
+            obj.AxesZeroWidth = value;
+            
+            % Toggle re-initialize to true if AxesZeroWidth was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesRadial(obj, value)
+            % Set property
+            obj.AxesRadial = value;
+            
+            % Toggle re-initialize to true if AxesRadial was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesAngular(obj, value)
+            % Set property
+            obj.AxesAngular = value;
+            
+            % Toggle re-initialize to true if AxesAngular was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesShaded(obj, value)
+            % Set property
+            obj.AxesShaded = value;
+            
+            % Toggle re-initialize to true if AxesShaded was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesShadedLimits(obj, value)
+            % Set property
+            obj.AxesShadedLimits = value;
+            
+            % Toggle re-initialize to true if AxesShadedLimits was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesShadedColor(obj, value)
+            % Set property
+            obj.AxesShadedColor = value;
+            
+            % Toggle re-initialize to true if AxesShadedColor was changed
+            obj.InitializeToggle = true;
+        end
+
+        function set.AxesShadedTransparency(obj, value)
+            % Set property
+            obj.AxesShadedTransparency = value;
+            
+            % Toggle re-initialize to true if AxesShadedTransparency was changed
+            obj.InitializeToggle = true;
+        end
+        
+        %%% Get Methods %%%
+        function num_data_points = get.NumDataPoints(obj)
+            % Get number of data points
+            num_data_points = size(obj.P, 2);
+        end
+        
+        function num_data_groups = get.NumDataGroups(obj)
+            % Get number of data groups
+            num_data_groups = size(obj.P, 1);
+        end
+        
+        function axes_labels = get.AxesLabels(obj)
+            % Check if value is empty
+            if isempty(obj.AxesLabels)
+                % Set axes labels
+                axes_labels = cellstr("Label " + (1:obj.NumDataPoints));
+            else
+                % Keep axes labels
+                axes_labels = obj.AxesLabels;
+            end
+        end
+        
+        function legend_labels = get.LegendLabels(obj)
+            % Check if value is empty
+            if isempty(obj.LegendLabels)
+                % Set legend labels
+                legend_labels = cellstr("Data " + (1:obj.NumDataGroups));
+            else
+                % Keep legend labels
+                legend_labels = obj.LegendLabels;
+            end
+        end
+        
+        function color = get.Color(obj)
+            % Check if value is empty
+            if isempty(obj.Color)
+                % Set color order
+                color = lines(obj.NumDataGroups);
+            else
+                % Keep color order
+                color = obj.Color;
+            end
+        end
+        
+        function axes_limits = get.AxesLimits(obj)
+            % Check if value is empty
+            if isempty(obj.AxesLimits)
+                axes_limits = [min(obj.P, [], 1); max(obj.P, [], 1)];
+            else
+                % Validate axes limits
+                validateAxesLimits(obj.AxesLimits, obj.P);
+
+                % Get property
+                axes_limits = obj.AxesLimits;
+            end
+        end
+
+        function axes_shaded_limits = get.AxesShadedLimits(obj)
+            % Get property
+            if isempty(obj.AxesShadedLimits)
+                axes_shaded_limits = obj.AxesLimits;
+            else
+                % Check if the axes shaded limits same length as the number of points
+                if size(obj.AxesShadedLimits, 1) ~= 2 || size(obj.AxesShadedLimits, 2) ~= obj.NumDataPoints
+                    error('Error: Please make sure the min and max axes shaded limits match the number of data points.');
+                end
+
+                % Check if within min and max axes limits
+                if any(obj.AxesShadedLimits(1, :) < obj.AxesLimits(1, :)) ||...
+                        any(obj.AxesShadedLimits(2, :) > obj.AxesLimits(2, :))
+                    error('Error: Please make sure the axes shaded limits are within the min and max axes limits.');
+                end
+
+                % Get property
+                axes_shaded_limits = obj.AxesShadedLimits;
+            end
+        end
+
+        function axes_precision = get.AxesPrecision(obj)
+            % Check if axes precision is numeric
+            if isnumeric(obj.AxesPrecision)
+                % Check is length is one
+                if length(obj.AxesPrecision) == 1
+                    % Repeat array to number of data points
+                    obj.AxesPrecision = repmat(obj.AxesPrecision, obj.NumDataPoints, 1);
+                elseif length(obj.AxesPrecision) ~= obj.NumDataPoints
+                    error('Error: Please specify the same number of axes precision as number of data points.');
+                end
+            else
+                error('Error: Please make sure the axes precision is a numeric value.');
+            end
+            
+            % Get property
+            axes_precision = obj.AxesPrecision;
+        end
+        
+        function axes_scaling = get.AxesScaling(obj)
+            % Check if axes scaling is valid
+            if any(~ismember(obj.AxesScaling, {'linear', 'log'}))
+                error('Error: Invalid axes scaling entry. Please enter in "linear" or "log" to set axes scaling.');
+            end
+            
+            % Check if axes scaling is a cell
+            if iscell(obj.AxesScaling)
+                % Check is length is one
+                if length(obj.AxesScaling) == 1
+                    % Repeat array to number of data groups
+                    obj.AxesScaling = repmat(obj.AxesScaling, obj.NumDataPoints, 1);
+                elseif length(obj.AxesScaling) ~= obj.NumDataPoints
+                    error('Error: Please specify the same number of axes scaling as number of data points.');
+                end
+            else
+                % Repeat array to number of data groups
+                obj.AxesScaling = repmat({obj.AxesScaling}, obj.NumDataPoints, 1);
+            end
+            
+            % Get property
+            axes_scaling = obj.AxesScaling;
+        end
+        
+        function line_style = get.LineStyle(obj)
+            % Check if line style is a char
+            if ischar(obj.LineStyle)
+                % Convert to cell array of char
+                obj.LineStyle = cellstr(obj.LineStyle);
+                
+                % Repeat cell to number of data groups
+                obj.LineStyle = repmat(obj.LineStyle, obj.NumDataGroups, 1);
+            elseif iscellstr(obj.LineStyle) %#ok<*ISCLSTR>
+                % Check is length is one
+                if length(obj.LineStyle) == 1
+                    % Repeat cell to number of data groups
+                    obj.LineStyle = repmat(obj.LineStyle, obj.NumDataGroups, 1);
+                elseif length(obj.LineStyle) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of line styles as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the line style is a char or a cell array of char.');
+            end
+            
+            % Get property
+            line_style = obj.LineStyle;
+        end
+        
+        function line_width = get.LineWidth(obj)
+            % Check if line width is numeric
+            if isnumeric(obj.LineWidth)
+                % Check is length is one
+                if length(obj.LineWidth) == 1
+                    % Repeat array to number of data groups
+                    obj.LineWidth = repmat(obj.LineWidth, obj.NumDataGroups, 1);
+                elseif length(obj.LineWidth) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of line width as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the line width is a numeric value.');
+            end
+            
+            % Get property
+            line_width = obj.LineWidth;
+        end
+        
+        function marker_style = get.Marker(obj)
+            % Check if marker type is a char
+            if ischar(obj.Marker)
+                % Convert to cell array of char
+                obj.Marker = cellstr(obj.Marker);
+                
+                % Repeat cell to number of data groups
+                obj.Marker = repmat(obj.Marker, obj.NumDataGroups, 1);
+            elseif iscellstr(obj.Marker)
+                % Check is length is one
+                if length(obj.Marker) == 1
+                    % Repeat cell to number of data groups
+                    obj.Marker = repmat(obj.Marker, obj.NumDataGroups, 1);
+                elseif length(obj.Marker) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of line styles as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the line style is a char or a cell array of char.');
+            end
+            
+            % Get property
+            marker_style = obj.Marker;
+        end
+        
+        function marker_size = get.MarkerSize(obj)
+            % Check if line width is numeric
+            if isnumeric(obj.MarkerSize)
+                if length(obj.MarkerSize) == 1
+                    % Repeat array to number of data groups
+                    obj.MarkerSize = repmat(obj.MarkerSize, obj.NumDataGroups, 1);
+                elseif length(obj.MarkerSize) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of line width as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the line width is numeric.');
+            end
+            
+            % Get property
+            marker_size = obj.MarkerSize;
+        end
+        
+        function axes_direction = get.AxesDirection(obj)
+            % Check if axes direction is a cell
+            if iscell(obj.AxesDirection)
+                % Check is length is one
+                if length(obj.AxesDirection) == 1
+                    % Repeat array to number of data points
+                    obj.AxesDirection = repmat(obj.AxesDirection, obj.NumDataPoints, 1);
+                elseif length(obj.AxesDirection) ~= obj.NumDataPoints
+                    error('Error: Please specify the same number of axes direction as number of data points.');
+                end
+            else
+                % Repeat array to number of data points
+                obj.AxesDirection = repmat({obj.AxesDirection}, obj.NumDataPoints, 1);
+            end
+            
+            % Get property
+            axes_direction = obj.AxesDirection;
+        end
+
+        function axes_offset = get.AxesOffset(obj)
+            % Check if axes offset is valid
+            if obj.AxesOffset > obj.AxesInterval
+                error('Error: Invalid axes offset entry. Please enter in an integer value that is between [0, axes_interval].');
+            end
+            
+            % Get property
+            axes_offset = obj.AxesOffset;
+        end
+        
+        function fill_option = get.FillOption(obj)
+            % Check if fill option is a cell
+            if iscell(obj.FillOption)
+                % Check is length is one
+                if length(obj.FillOption) == 1
+                    % Repeat array to number of data groups
+                    obj.FillOption = repmat(obj.FillOption, obj.NumDataGroups, 1);
+                elseif length(obj.FillOption) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of fill options as number of data groups.');
+                end
+            else
+                % Repeat array to number of data groups
+                obj.FillOption = repmat({obj.FillOption}, obj.NumDataGroups, 1);
+            end
+            
+            % Get property
+            fill_option = obj.FillOption;
+        end
+
+        function fill_transparency = get.FillTransparency(obj)
+            % Check if fill transparency is numeric
+            if isnumeric(obj.FillTransparency)
+                % Check is length is one
+                if length(obj.FillTransparency) == 1
+                    % Repeat array to number of data groups
+                    obj.FillTransparency = repmat(obj.FillTransparency, obj.NumDataGroups, 1);
+                elseif length(obj.FillTransparency) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of fill transparency as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the fill transparency is a numeric value.');
+            end
+            
+            % Get property
+            fill_transparency = obj.FillTransparency;
+        end
+        
+        function line_transparency = get.LineTransparency(obj)
+            % Check if line transparency is numeric
+            if isnumeric(obj.LineTransparency)
+                % Check is length is one
+                if length(obj.LineTransparency) == 1
+                    % Repeat array to number of data groups
+                    obj.LineTransparency = repmat(obj.LineTransparency, obj.NumDataGroups, 1);
+                elseif length(obj.LineTransparency) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of line transparency as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the line transparency is a numeric value.');
+            end
+            
+            % Get property
+            line_transparency = obj.LineTransparency;
+        end
+        
+        function marker_transparency = get.MarkerTransparency(obj)
+            % Check if marker transparency is numeric
+            if isnumeric(obj.MarkerTransparency)
+                % Check is length is one
+                if length(obj.MarkerTransparency) == 1
+                    % Repeat array to number of data groups
+                    obj.MarkerTransparency = repmat(obj.MarkerTransparency, obj.NumDataGroups, 1);
+                elseif length(obj.MarkerTransparency) ~= obj.NumDataGroups
+                    error('Error: Please specify the same number of marker transparency as number of data groups.');
+                end
+            else
+                error('Error: Please make sure the marker transparency is a numeric value.');
+            end
+            
+            % Get property
+            marker_transparency = obj.MarkerTransparency;
+        end
+        
+        function axes_font_color = get.AxesFontColor(obj)
+            % Check if axes display is data
+            if strcmp(obj.AxesDisplay, 'data')
+                if size(obj.AxesFontColor, 1) ~= obj.NumDataGroups
+                    % Check axes font color dimensions
+                    if size(obj.AxesFontColor, 1) == 1 && size(obj.AxesFontColor, 2) == 3
+                        obj.AxesFontColor = repmat(obj.AxesFontColor, obj.NumDataGroups, 1);
+                    else
+                        error('Error: Please specify axes font color as a RGB triplet normalized to 1.');
+                    end
+                end
+            end
+            
+            % Get property
+            axes_font_color = obj.AxesFontColor;
+        end
+
+        function axes_tick_text = get.AxesTickLabels(obj)
+            % Check if axes tick labels is valid
+            if iscell(obj.AxesTickLabels)
+                if length(obj.AxesTickLabels) ~= obj.AxesInterval+1
+                    error('Error: Invalid axes tick labels entry. Please enter in a cell array with the same length of axes interval + 1.');
+                end
+            else
+                if ~strcmp(obj.AxesTickLabels, 'data')
+                    error('Error: Invalid axes tick labels entry. Please enter in "data" or a cell array of desired tick labels.');
+                end
+            end
+
+            % Get property
+            axes_tick_text = obj.AxesTickLabels;
+        end
+
+        function axes_interpreter = get.AxesInterpreter(obj)
+            % Check if axes interpreter is valid
+            if any(~ismember(obj.AxesInterpreter, {'tex', 'latex', 'none'}))
+                error('Error: Please enter either "tex", "latex", or "none" for axes interpreter option.');
+            end
+
+            % Check if axes interpreter is a char
+            if ischar(obj.AxesInterpreter)
+                % Convert to cell array of char
+                obj.AxesInterpreter = cellstr(obj.AxesInterpreter);
+                
+                % Repeat cell to number of axes labels
+                obj.AxesInterpreter = repmat(obj.AxesInterpreter, length(obj.AxesLabels), 1);
+            elseif iscellstr(obj.AxesInterpreter)
+                % Check is length is one
+                if length(obj.AxesInterpreter) == 1
+                    % Repeat cell to number of axes labels
+                    obj.AxesInterpreter = repmat(obj.AxesInterpreter, length(obj.AxesLabels), 1);
+                elseif length(obj.AxesInterpreter) ~= length(obj.AxesLabels)
+                    error('Error: Please specify the same number of axes interpreters as number of axes labels.');
+                end
+            else
+                error('Error: Please make sure the axes interpreter is a char or a cell array of char.');
+            end
+            
+            % Get property
+            axes_interpreter = obj.AxesInterpreter;
+        end
+    end
+    
+    methods (Access = public)
+        function title(obj, title_text, varargin)
+            % Get axes and title handles
+            ax = getAxes(obj);
+            tlt = ax.Title;
+            
+            % Set title string
+            tlt.String = title_text;
+            
+            % Initialze name-value arguments
+            name_arguments = varargin(1:2:end);
+            value_arguments = varargin(2:2:end);
+            
+            % Iterate through name-value arguments
+            for ii = 1:length(name_arguments)
+                % Set name value pair
+                name = name_arguments{ii};
+                value = value_arguments{ii};
+                tlt.(name) = value;
+            end
+        end
+        
+        function tiledlayout(obj, varargin)
+            % Figure properties
+            fig = figure;
+            fig.Color = obj.BackgroundColor;
+            
+            % Tiled layout
+            obj.TiledLayoutHandle = tiledlayout(fig, varargin{:});
+            drawnow;
+        end
+        
+        function nexttile(obj, object_handle, varargin)
+            % Copy over axes
+            object_axes = getAxes(object_handle);
+            current_axes = copyobj(object_axes, obj.TiledLayoutHandle);
+            
+            % Check input variable length
+            switch length(varargin)
+                case 2
+                    tile_location = varargin{1};
+                    span = varargin{2};
+                case 1
+                    % Check first variable length
+                    if length(varargin{1}) == 1
+                        tile_location = varargin{1};
+                        span = [1, 1];
+                    else
+                        tile_location = obj.NextTileIter;
+                        span = varargin{1};
+                    end
+                case 0
+                    tile_location = obj.NextTileIter;
+                    span = [1, 1];
+                otherwise
+                    error("Error using nexttile. Invalid arguments.")
+            end
+               
+            % Axes settings
+            current_axes.Layout.Tile = tile_location;
+            current_axes.Layout.TileSpan = span;
+            
+            % Iterate next tile number
+            obj.NextTileIter = obj.NextTileIter + 1;
+        end
+        
+        function tiledlegend(obj, varargin)
+            % Relevant graphic handles
+            current_axes = gca;
+            axes_handles = findobj(obj.TiledLayoutHandle, 'Type', 'axes');
+            line_handles = cell(length(axes_handles), 1);
+            
+            % Iterate through axes handles
+            for ii = 1:length(axes_handles)
+                % Find and store all line handles
+                line_handles{ii} = findobj(axes_handles(ii), 'Type', 'line');
+            end
+            
+            % Concatenate contents of array
+            line_handles = vertcat(line_handles{:});
+            
+            % Create and store legend handle
+            obj.TiledLegendHandle = legend(current_axes, line_handles(:), varargin{:});
+            obj.TiledLegendHandle.Color = obj.BackgroundColor;
+        end
+    end
+    
+    methods (Access = protected)
+        %%% Setup Methods %%%
+        function setup(obj)
+            % Figure properties
+            fig = gcf;
+            fig.Color = obj.BackgroundColor;
+            
+            % Axis properties
+            scaling_factor = 1 + (1 - obj.AxesZoom);
+            ax = getAxes(obj);
+            ax.Color = obj.BackgroundColor;
+            hold(ax, 'on');
+            axis(ax, 'square');
+            axis(ax, 'off');
+            axis(ax, [-1, 1, -1, 1] * scaling_factor);
+        end
+        
+        %%% Update Methods %%%
+        function update(obj)
+            % Check re-initialize toggle
+            if obj.InitializeToggle
+                % Reset graphic objects
+                reset_objects(obj);
+                initialize(obj);
+                
+                % Set initialize toggle to false
+                obj.InitializeToggle = false;
+            end
+            
+            % Update plot appearance
+            update_plot(obj);
+        end
+        
+        function reset_objects(obj)
+            % Delete old objects
+            delete(obj.DataLines);
+            delete(obj.ScatterPoints);
+            delete(obj.NanPoints);
+            delete(obj.ThetaAxesLines);
+            delete(obj.RhoAxesLines);
+            delete(obj.RhoMinorLines);
+            delete(obj.FillPatches);
+            delete(obj.AxesPatches);
+            delete(obj.AxesTextLabels);
+            delete(obj.AxesTickText);
+            delete(obj.AxesDataLabels);
+            
+            % Reset object with empty objects
+            obj.DataLines = gobjects(0);
+            obj.ScatterPoints = gobjects(0);
+            obj.NanPoints = gobjects(0);
+            obj.ThetaAxesLines = gobjects(0);
+            obj.RhoAxesLines = gobjects(0);
+            obj.RhoMinorLines = gobjects(0);
+            obj.FillPatches = gobjects(0);
+            obj.AxesPatches = gobjects(0);
+            obj.AxesValues = [];
+            obj.AxesTextLabels = gobjects(0);
+            obj.AxesTickText = gobjects(0);
+            obj.AxesDataLabels = gobjects(0);
+        end
+        
+        function initialize(obj)
+            % Figure properties
+            fig = gcf;
+            fig.Color = obj.BackgroundColor;
+
+            % Axis properties
+            scaling_factor = 1 + (1 - obj.AxesZoom);
+            ax = getAxes(obj);
+            ax.Color = obj.BackgroundColor;
+            hold(ax, 'on');
+            axis(ax, 'square');
+            axis(ax, 'off');
+            axis(ax, [-1, 1, -1, 1] * scaling_factor);
+            
+            % Legend properties
+            obj.LegendHandle = getLegend(obj);
+            obj.LegendHandle.Color = obj.BackgroundColor;
+            
+            % Selected data
+            P_selected = obj.P;
+            
+            % Check axes scaling option
+            log_index = strcmp(obj.AxesScaling, 'log');
+            
+            % If any log scaling is specified
+            if any(log_index)
+                % Initialize copy
+                P_log = P_selected(:, log_index);
+                
+                % Logarithm of base 10, account for numbers less than 1
+                P_log = sign(P_log) .* log10(abs(P_log));
+                
+                % Minimum and maximun log limits
+                min_limit = min(min(fix(P_log)));
+                max_limit = max(max(ceil(P_log)));
+                recommended_axes_interval = max_limit - min_limit;
+                
+                % Warning message
+                warning('For the log scale values, recommended axes limit is [%i, %i] with an axes interval of %i.',...
+                    10^min_limit, 10^max_limit, recommended_axes_interval);
+                
+                % Replace original
+                P_selected(:, log_index) = P_log;
+            end
+            
+            % Axes handles
+            ax = getAxes(obj);
+            
+            % Polar increments
+            theta_increment = 2*pi/obj.NumDataPoints;
+            full_interval = obj.AxesInterval+1;
+            rho_offset = obj.AxesOffset/full_interval;
+            
+            %%% Scale Data %%%
+            % Check if axes shaded is on
+            if strcmp(obj.AxesShaded, 'on')
+                P_selected = [P_selected; obj.AxesShadedLimits];
+            end
+
+            % Pre-allocation
+            P_scaled = zeros(size(P_selected));
+            axes_range = zeros(3, obj.NumDataPoints);
+            
+            % Check axes scaling option
+            axes_direction_index = strcmp(obj.AxesDirection, 'reverse');
+            
+            % Iterate through number of data points
+            for ii = 1:obj.NumDataPoints
+                % Check for one data group and no axes limits
+                if obj.NumDataGroups == 1 && isempty(obj.AxesLimits)
+                    % Group of points
+                    group_points = P_selected(:, :);
+                else
+                    % Group of points
+                    group_points = P_selected(:, ii);
+                end
+                
+                % Check for log axes scaling option
+                if log_index(ii)
+                    % Minimum and maximun log limits
+                    min_value = min(fix(group_points));
+                    max_value = max(ceil(group_points));
+                else
+                    % Automatically the range of each group
+                    min_value = min(group_points);
+                    max_value = max(group_points);
+                end
+                
+                % Range of min and max values
+                range = max_value - min_value;
+                
+                % Check if axes_limits is not empty
+                if ~isempty(obj.AxesLimits)
+                    % Check for log axes scaling option
+                    if log_index(ii)
+                        % Logarithm of base 10, account for numbers less than 1
+                        obj.AxesLimits(:, ii) = sign(obj.AxesLimits(:, ii)) .* log10(abs(obj.AxesLimits(:, ii)));
+                    end
+                    
+                    % Manually set the range of each group
+                    min_value = obj.AxesLimits(1, ii);
+                    max_value = obj.AxesLimits(2, ii);
+                    range = max_value - min_value;
+                    
+                    % Check if the axes limits are within range of points
+                    if min_value > min(group_points) || max_value < max(group_points)
+                        error('Error: Please make sure the manually specified axes limits are within range of the data points.');
+                    end
+                end
+                
+                % Check if range is valid
+                if range == 0
+                    error('Error: Range of data values is not valid. Please specify the axes limits.');
+                end
+                
+                % Scale points to range from [0, 1]
+                P_scaled(:, ii) = ((P_selected(:, ii) - min_value) / range);
+                
+                % If reverse axes direction is specified
+                if axes_direction_index(ii)
+                    % Store to array
+                    axes_range(:, ii) = [max_value; min_value; range];
+                    P_scaled(:, ii) = -(P_scaled(:, ii) - 1);
+                else
+                    % Store to array
+                    axes_range(:, ii) = [min_value; max_value; range];
+                end
+                
+                % Add offset of [rho_offset] and scaling factor of [1 - rho_offset]
+                P_scaled(:, ii) = P_scaled(:, ii) * (1 - rho_offset) + rho_offset;
+            end
+
+            % Check if axes shaded is on
+            if strcmp(obj.AxesShaded, 'on')
+                P_shaded = P_scaled(end-1:end, :);
+                P_scaled = P_scaled(1:end-2, :);
+            end
+            
+            %%% Polar Axes %%%
+            % Polar coordinates
+            rho_increment = 1/full_interval;
+            rho = 0:rho_increment:1;
+            
+            % Check specified direction of rotation
+            switch obj.Direction
+                case 'counterclockwise'
+                    % Shift by pi/2 to set starting axis the vertical line
+                    theta = (0:theta_increment:2*pi) + (pi/2);
+                case 'clockwise'
+                    % Shift by pi/2 to set starting axis the vertical line
+                    theta = (0:-theta_increment:-2*pi) + (pi/2);
+            end
+            
+            % Remainder after using a modulus of 2*pi
+            theta = mod(theta, 2*pi);
+            
+            % Check if axes radial is toggled on
+            if strcmp(obj.AxesRadial, 'on')
+                % Iterate through each theta
+                for ii = 1:length(theta)-1
+                    % Convert polar to cartesian coordinates
+                    [x_axes, y_axes] = pol2cart(theta(ii), rho);
+
+                    % Plot
+                    obj.ThetaAxesLines(ii) = line(ax, x_axes, y_axes,...
+                        'LineWidth', 1.5, ...
+                        'Color', obj.AxesColor,...
+                        'HandleVisibility', 'off');
+                end
+            end
+
+            % Check if axes angular is toggled on
+            if strcmp(obj.AxesAngular, 'on')
+                % Iterate through each rho
+                for ii = 2:length(rho)
+                    % Convert polar to cartesian coordinates
+                    [x_axes, y_axes] = pol2cart(theta, rho(ii));
+
+                    % Plot
+                    obj.RhoAxesLines(ii-1) = line(ax, x_axes, y_axes,...
+                        'Color', obj.AxesColor,...
+                        'HandleVisibility', 'off');
+                end
+            end
+
+            % Check if minor grid is toggled on
+            if strcmp(obj.MinorGrid, 'on')
+                % Polar coordinates
+                rho_minor_increment = 1/(full_interval*obj.MinorGridInterval);
+                rho_minor = rho(2):rho_minor_increment:1;
+                rho_minor = setdiff(rho_minor, rho(2:end));
+
+                % Iterate through each rho minor
+                for ii = 1:length(rho_minor)
+                    % Convert polar to cartesian coordinates
+                    [x_axes, y_axes] = pol2cart(theta, rho_minor(ii));
+
+                    % Plot
+                    obj.RhoMinorLines(ii) = line(ax, x_axes, y_axes,...
+                        'LineStyle', '--',...
+                        'Color', obj.AxesColor,...
+                        'LineWidth', 0.5,...
+                        'HandleVisibility', 'off');
+                end
+            end
+
+            % Check if axes zero is toggled on
+            if strcmp(obj.AxesZero, 'on') && strcmp(obj.AxesDisplay, 'one')
+                % Scale points to range from [0, 1]
+                zero_scaled = (0 - min_value) / range;
+
+                % If reverse axes direction is specified
+                if strcmp(obj.AxesDirection, 'reverse')
+                    zero_scaled = -zero_scaled - 1;
+                end
+
+                % Add offset of [rho_offset] and scaling factor of [1 - rho_offset]
+                zero_scaled = zero_scaled * (1 - rho_offset) + rho_offset;
+
+                % Convert polar to cartesian coordinates
+                [x_axes, y_axes] = pol2cart(theta, zero_scaled);
+
+                % Plot webs
+                h = plot(x_axes, y_axes,...
+                    'LineWidth', obj.AxesZeroWidth,...
+                    'Color', obj.AxesZeroColor);
+
+                % Turn off legend annotation
+                h.Annotation.LegendInformation.IconDisplayStyle = 'off';
+            end
+
+            % Set end index depending on axes display argument
+            switch obj.AxesDisplay
+                case 'all'
+                    theta_end_index = length(theta)-1;
+                case 'one'
+                    theta_end_index = 1;
+                case 'none'
+                    theta_end_index = 0;
+                case 'data'
+                    theta_end_index = 0;
+            end
+            
+            % Rho start index and offset interval
+            rho_start_index = obj.AxesOffset+1;
+            offset_interval = full_interval - obj.AxesOffset;
+
+            %%% Plot %%%
+            % Initialize data children
+            for ii = 1:obj.NumDataGroups
+                obj.FillPatches(ii) = patch(nan, nan, nan,...
+                    'Parent', ax,...
+                    'EdgeColor', 'none',...
+                    'HandleVisibility', 'off');
+                obj.DataLines(ii) = line(nan, nan,...
+                    'Parent', ax);
+                obj.ScatterPoints(ii) = scatter(nan, nan,...
+                    'Parent', ax);
+                obj.NanPoints(ii) = plot(nan, nan,...
+                    'Parent', ax);
+                
+                % Turn off legend annotation
+                obj.DataLines(ii).Annotation.LegendInformation.IconDisplayStyle = 'off';
+                obj.ScatterPoints(ii).Annotation.LegendInformation.IconDisplayStyle = 'off';
+                obj.FillPatches(ii).Annotation.LegendInformation.IconDisplayStyle = 'off';
+            end
+                
+            % Check if any NaNs detected
+            if any(isnan(P_scaled), 'all')
+                % Set value to zero
+                nan_index = isnan(P_scaled);
+                P_scaled(nan_index) = 0;
+            end
+
+            % Iterate through number of data groups
+            for ii = 1:obj.NumDataGroups
+                % Convert polar to cartesian coordinates
+                [x_points, y_points] = pol2cart(theta(1:end-1), P_scaled(ii, :));
+                
+                % Make points circular
+                x_circular = [x_points, x_points(1)];
+                y_circular = [y_points, y_points(1)];
+                
+                % Plot data points
+                obj.DataLines(ii).XData = x_circular;
+                obj.DataLines(ii).YData = y_circular;
+                
+                % Plot data points
+                obj.ScatterPoints(ii).XData = x_circular;
+                obj.ScatterPoints(ii).YData = y_circular;
+                
+                % Check if fill option is toggled on
+                obj.FillPatches(ii).XData = x_circular;
+                obj.FillPatches(ii).YData = y_circular;
+                
+                % Check axes display setting
+                if strcmp(obj.AxesDisplay, 'data')
+                    % Iterate through number of data points
+                    for jj = 1:obj.NumDataPoints
+                        % Convert polar to cartesian coordinates
+                        [current_theta, current_rho] = cart2pol(x_points(jj), y_points(jj));
+                        [x_pos, y_pos] = pol2cart(current_theta, current_rho+obj.AxesDataOffset);
+
+                        % Display axes text
+                        obj.AxesDataLabels(ii, jj) = text(ax, x_pos, y_pos, '',...
+                            'Units', 'Data',...
+                            'Color', obj.AxesFontColor(ii, :),...
+                            'FontName', obj.AxesFont,...
+                            'FontSize', obj.AxesFontSize,...
+                            'HorizontalAlignment', 'center',...
+                            'VerticalAlignment', 'middle',...
+                            'Visible', 'off');
+                    end
+                end
+            end
+
+            % Check if axes shaded is on
+            if strcmp(obj.AxesShaded, 'on')
+                % Polar verticies of patch
+                P_shaded = [P_shaded, P_shaded(:, 1)];
+                P_shaded = [P_shaded(1, :), P_shaded(2, :)];
+                patch_rho = reshape(P_shaded, 1, []);
+                patch_theta = [theta, theta];
+
+                % Convert polar to cartesian coordinates
+                [x_points, y_points] = pol2cart(patch_theta, patch_rho);
+
+                % Interweave lower and upper limits
+                x_points = reshape(x_points, [], 2)';
+                y_points = reshape(y_points, [], 2)';
+
+                x_points = x_points(:);
+                y_points = y_points(:);
+
+                % Increment through groups of four vertices at a time
+                for ii = 1:2:length(x_points)-2
+                    % Verticies and face points
+                    v = [x_points(ii:ii+3), y_points(ii:ii+3)];
+                    f = [1 2 4 3];
+
+                    % Patch polygon
+                    obj.AxesPatches(ii) = patch('Parent', ax,...
+                        'Faces', f, 'Vertices', v,...
+                        'FaceColor', obj.AxesShadedColor,...
+                        'EdgeColor', 'none',...
+                        'FaceAlpha', obj.AxesShadedTransparency);
+                    obj.AxesPatches(ii).Annotation.LegendInformation.IconDisplayStyle = 'off';
+                end
+            end
+
+            %%% Labels %%%
+            % Check if axes labels rotate is on
+            if strcmp(obj.AxesLabelsRotate, 'on')
+                % Find number of degrees to rotate text by
+                rotate_deg = rad2deg(obj.text_rotation(theta));
+
+                % Find the horizontal alignments to align closer to axes
+                horz_aligns = obj.text_alignment(theta);
+            else
+                % No rotation
+                rotate_deg = zeros(1, length(theta));
+            end
+
+            % Iterate through number of data points
+            for ii = 1:obj.NumDataPoints
+                % Horizontal text alignment by quadrant
+                [horz_align, ~] = obj.quadrant_position(theta(ii));
+
+                % Check if axes labels rotate is on
+                if strcmp(obj.AxesLabelsRotate, 'on')
+                    % Adjust horizontal text alignment
+                    horz_align = horz_aligns{ii};
+                end
+
+                % Convert polar to cartesian coordinates
+                [x_pos, y_pos] = pol2cart(theta(ii), rho(end)+obj.AxesLabelsOffset);
+
+                % Display text label
+                obj.AxesTextLabels(ii) = text(ax, x_pos, y_pos, '',...
+                    'Units', 'Data',...
+                    'HorizontalAlignment', horz_align,...
+                    'VerticalAlignment', 'middle',...
+                    'EdgeColor', obj.AxesLabelsEdge,...
+                    'BackgroundColor', obj.BackgroundColor,...
+                    'FontName', obj.LabelFont,...
+                    'FontSize', obj.LabelFontSize,...
+                    'Rotation', rotate_deg(ii),...
+                    'Visible', 'off');
+            end
+            
+            % Alignment for axes labels
+            horz_align = obj.AxesHorzAlign;
+            vert_align = obj.AxesVertAlign;
+            
+            % Iterate through each theta
+            for ii = 1:theta_end_index
+                % Convert polar to cartesian coordinates
+                [x_axes, y_axes] = pol2cart(theta(ii), rho);
+                
+                % Check if horizontal alignment is quadrant based
+                if strcmp(obj.AxesHorzAlign, 'quadrant')
+                    % Alignment based on quadrant
+                    [horz_align, ~] = obj.quadrant_position(theta(ii));
+                end
+                
+                % Check if vertical alignment is quadrant based
+                if strcmp(obj.AxesVertAlign, 'quadrant')
+                    % Alignment based on quadrant
+                    [~, vert_align] = obj.quadrant_position(theta(ii));
+                end
+                
+                % Iterate through points on isocurve
+                for jj = rho_start_index:length(rho)
+                    % Axes increment value
+                    min_value = axes_range(1, ii);
+                    range = axes_range(3, ii);
+                    
+                    % If reverse axes direction is specified
+                    if axes_direction_index(ii)
+                        % Axes increment value
+                        axes_value = min_value - (range/offset_interval) * (jj-rho_start_index);
+                    else
+                        % Axes increment value
+                        axes_value = min_value + (range/offset_interval) * (jj-rho_start_index);
+                    end
+                    
+                    % Check for log axes scaling option
+                    if log_index(ii)
+                        % Exponent to the tenth power
+                        axes_value = 10^axes_value;
+                    end
+                    
+                    % Display axes text
+                    obj.AxesValues(ii, jj) = axes_value;
+                    obj.AxesTickText(ii, jj) = text(ax, x_axes(jj), y_axes(jj), '',...
+                        'Units', 'Data',...
+                        'Color', obj.AxesFontColor,...
+                        'FontName', obj.AxesFont,...
+                        'FontSize', obj.AxesFontSize,...
+                        'HorizontalAlignment', horz_align,...
+                        'VerticalAlignment', vert_align,...
+                        'Visible', 'off');
+                end
+            end
+             
+            % Keep only valid entries
+            obj.AxesValues = obj.AxesValues(:, rho_start_index:end);
+            obj.AxesTickText = obj.AxesTickText(:, rho_start_index:end);
+        end
+        
+        function update_plot(obj)
+            % Fill option index
+            fill_option_index = strcmp(obj.FillOption, 'on');
+
+            % Iterate through patch objects
+            for ii = 1:numel(obj.FillPatches)
+                % Check fill option argument
+                if fill_option_index(ii)
+                    % Fill in patch with specified color and transparency
+                    obj.FillPatches(ii).FaceColor = obj.Color(ii, :);
+                    obj.FillPatches(ii).FaceAlpha = obj.FillTransparency(ii);
+                else
+                    % Set no patch color
+                    obj.FillPatches(ii).FaceColor = 'none';
+                end
+            end
+            
+            % Iterate through data line objects
+            for ii = 1:numel(obj.DataLines)
+                % Set line settings
+                obj.DataLines(ii).LineStyle = obj.LineStyle{ii};
+                obj.DataLines(ii).Color = obj.Color(ii, :);
+                obj.DataLines(ii).LineWidth = obj.LineWidth(ii);
+                obj.DataLines(ii).DisplayName = obj.LegendLabels{ii};
+                obj.DataLines(ii).Color(4) = obj.LineTransparency(ii);
+                obj.DataLines(ii).Visible = obj.PlotVisible;
+                
+                % Set scatter settings
+                obj.ScatterPoints(ii).Marker = obj.Marker{ii};
+                obj.ScatterPoints(ii).SizeData = obj.MarkerSize(ii);
+                obj.ScatterPoints(ii).MarkerFaceColor = obj.Color(ii, :);
+                obj.ScatterPoints(ii).MarkerEdgeColor = obj.Color(ii, :);
+                obj.ScatterPoints(ii).MarkerFaceAlpha = obj.MarkerTransparency(ii);
+                obj.ScatterPoints(ii).MarkerEdgeAlpha = obj.MarkerTransparency(ii);
+                obj.ScatterPoints(ii).Visible = obj.PlotVisible;
+
+                % Set legend settings
+                obj.NanPoints(ii).Marker = obj.Marker{ii};
+                obj.NanPoints(ii).MarkerSize = obj.MarkerSize(ii)/6;
+                obj.NanPoints(ii).MarkerFaceColor = obj.Color(ii, :);
+                obj.NanPoints(ii).MarkerEdgeColor = obj.Color(ii, :);
+                obj.NanPoints(ii).LineStyle = obj.LineStyle{ii};
+                obj.NanPoints(ii).Color = obj.Color(ii, :);
+                obj.NanPoints(ii).LineWidth = obj.LineWidth(ii);
+                obj.NanPoints(ii).DisplayName = obj.LegendLabels{ii};
+                obj.NanPoints(ii).Visible = obj.PlotVisible;
+            end
+            
+            % Check axes labels argument
+            if strcmp(obj.AxesLabels, 'none')
+                % Set axes text labels to invisible
+                set(obj.AxesTextLabels, 'Visible', 'off')
+            else
+                % Set axes text labels to visible
+                set(obj.AxesTextLabels, 'Visible', 'on')
+                
+                % Iterate through number of data points
+                for ii = 1:obj.NumDataPoints
+                    % Display text label
+                    obj.AxesTextLabels(ii).String = obj.AxesLabels{ii};
+                    obj.AxesTextLabels(ii).FontName = obj.LabelFont;
+                    obj.AxesTextLabels(ii).FontSize = obj.LabelFontSize;
+                    obj.AxesTextLabels(ii).EdgeColor = obj.AxesLabelsEdge;
+                    obj.AxesTextLabels(ii).Interpreter = obj.AxesInterpreter{ii};
+                end
+            end
+            
+            % Check axes axes display argument
+            if strcmp(obj.AxesDisplay, 'none') || strcmp(obj.AxesDisplay, 'data')
+                % Set axes tick label invisible
+                set(obj.AxesTickText, 'Visible', 'off')
+            else
+                % Set axes tick label visible
+                set(obj.AxesTickText, 'Visible', 'on')
+                
+                % Iterate through axes values rows
+                for ii = 1:size(obj.AxesValues, 1)
+                    % Iterate through axes values columns
+                    for jj = 1:size(obj.AxesValues, 2)
+                        % Display axes text
+                        if strcmp(obj.AxesTickLabels, 'data')
+                            text_str = sprintf(sprintf('%%.%if', obj.AxesPrecision(ii)), obj.AxesValues(ii, jj));
+                        else
+                            text_str = obj.AxesTickLabels{jj};
+                        end
+
+                        % Display and set axes tick label settings
+                        obj.AxesTickText(ii, jj).String = text_str;
+                        obj.AxesTickText(ii, jj).FontName = obj.AxesFont;
+                        obj.AxesTickText(ii, jj).FontSize = obj.AxesFontSize;
+                        obj.AxesTickText(ii, jj).Color = obj.AxesFontColor;
+
+                        % Apply to axes tick labels only when not data
+                        if iscellstr(obj.AxesTickLabels)
+                            obj.AxesTickText(ii, jj).Interpreter = obj.AxesInterpreter{1};
+                        end
+                    end
+                end
+            end
+            
+            % Check axes display
+            if strcmp(obj.AxesDisplay, 'data')
+                % Set axes data label visible
+                set(obj.AxesDataLabels, 'Visible', 'on')
+                
+                % Iterate through axes values rows
+                for ii = 1:size(obj.AxesDataLabels, 1)
+                    % Iterate through axes values columns
+                    for jj = 1:size(obj.AxesDataLabels, 2)
+                        % Display axes text
+                        text_str = sprintf(sprintf('%%.%if', obj.AxesPrecision(ii)), obj.P(ii, jj));
+                        obj.AxesDataLabels(ii, jj).String = text_str;
+                        obj.AxesDataLabels(ii, jj).FontName = obj.AxesFont;
+                        obj.AxesDataLabels(ii, jj).FontSize = obj.AxesFontSize;
+                        obj.AxesDataLabels(ii, jj).Color = obj.AxesFontColor(ii, :);
+                    end
+                end
+            else
+                % Set axes data label invisible
+                set(obj.AxesDataLabels, 'Visible', 'off')
+            end
+        end
+
+        function horz_aligns = text_alignment(~, theta)
+            % Pre-allocate cell
+            horz_aligns = cell(length(theta), 1);
+            horz_aligns(:) = {'center'};
+
+            % Iterate through each theta
+            for kk = 1:length(theta)
+                % Adjust horizontal alignment accordingly
+                if theta(kk) <= pi/2
+                    horz_aligns{kk} = 'left';
+                elseif theta(kk) < 3*pi/2
+                    horz_aligns{kk} = 'right';
+                elseif theta(kk) <= 2*pi
+                    horz_aligns{kk} = 'left';
+                end
+            end
+        end
+
+        function rotate_deg = text_rotation(~, theta)
+            % Find how much to rotate text
+            rotate_deg = theta;
+
+            % Iterate through each theta
+            for kk = 1:length(theta)
+                % Adjust sign and rotation accordingly
+                if theta(kk) == 0
+                    rotate_deg(kk) = 0;
+                elseif theta(kk) > 0 && theta(kk) <= pi/2
+                    rotate_deg(kk) = theta(kk);
+                elseif theta(kk) > pi/2 && theta(kk) < pi
+                    rotate_deg(kk) = -(pi - theta(kk));
+                elseif theta(kk) == pi
+                    rotate_deg(kk) = 0;
+                elseif theta(kk) > pi && theta(kk) < 3*pi/2
+                    rotate_deg(kk) = -(pi - theta(kk));
+                elseif theta(kk) >= 3*pi/2
+                    rotate_deg(kk) = -(2*pi - theta(kk));
+                end
+            end
+        end
+
+        function [horz_align, vert_align] = quadrant_position(~, theta_point)
+            % Find out which quadrant the point is in
+            if theta_point == 0
+                quadrant = 0;
+            elseif theta_point == pi/2
+                quadrant = 1.5;
+            elseif theta_point == pi
+                quadrant = 2.5;
+            elseif theta_point == 3*pi/2
+                quadrant = 3.5;
+            elseif theta_point == 2*pi
+                quadrant = 0;
+            elseif theta_point > 0 && theta_point < pi/2
+                quadrant = 1;
+            elseif theta_point > pi/2 && theta_point < pi
+                quadrant = 2;
+            elseif theta_point > pi && theta_point < 3*pi/2
+                quadrant = 3;
+            elseif theta_point > 3*pi/2 && theta_point < 2*pi
+                quadrant = 4;
+            end
+            
+            % Adjust label alignment depending on quadrant
+            switch quadrant
+                case 0
+                    horz_align = 'left';
+                    vert_align = 'middle';
+                case 1
+                    horz_align = 'left';
+                    vert_align = 'bottom';
+                case 1.5
+                    horz_align = 'center';
+                    vert_align = 'bottom';
+                case 2
+                    horz_align = 'right';
+                    vert_align = 'bottom';
+                case 2.5
+                    horz_align = 'right';
+                    vert_align = 'middle';
+                case 3
+                    horz_align = 'right';
+                    vert_align = 'top';
+                case 3.5
+                    horz_align = 'center';
+                    vert_align = 'top';
+                case 4
+                    horz_align = 'left';
+                    vert_align = 'top';
+            end
+        end
+        
+    end
+    
+end
+
+%%% Custom Validation Functions %%%
+% Validate axes labels
+function validateAxesLabels(axes_labels, P)
+if ~strcmp(axes_labels, 'none')
+    validateattributes(axes_labels, {'cell'}, {'size', [1, size(P, 2)]}, mfilename, 'axes_labels')
+end
+end
+
+% Validate legend labels
+function validateLegendLabels(legend_labels, P)
+if ~strcmp(legend_labels, 'none')
+    validateattributes(legend_labels, {'cell'}, {'size', [1, size(P, 1)]}, mfilename, 'legend_labels')
+end
+end
+
+% Validate axes limits
+function validateAxesLimits(axes_limits, P)
+if ~isempty(axes_limits)
+    validateattributes(axes_limits, {'double'}, {'size', [2, size(P, 2)]}, mfilename, 'axes_limits')
+    
+    % Lower and upper limits
+    lower_limits = axes_limits(1, :);
+    upper_limits = axes_limits(2, :);
+    
+    % Difference in upper and lower limits
+    diff_limits = upper_limits - lower_limits;
+    
+    % Check to make sure upper limit is greater than lower limit
+    if any(diff_limits < 0)
+        error('Error: Please make sure max axes limits are greater than the min axes limits.');
+    end
+    
+    % Check the range of axes limits
+    if any(diff_limits == 0)
+        error('Error: Please make sure the min and max axes limits are different.');
+    end
+end
+end
\ No newline at end of file
diff --git a/Requirements/spider_plot/spider_plot_class_examples.mlx b/Requirements/spider_plot/spider_plot_class_examples.mlx
new file mode 100644
index 0000000000000000000000000000000000000000..9789e9623068ef230805fbfd4c740992d32481f6
Binary files /dev/null and b/Requirements/spider_plot/spider_plot_class_examples.mlx differ
diff --git a/Requirements/spider_plot/spider_plot_examples.mlx b/Requirements/spider_plot/spider_plot_examples.mlx
new file mode 100644
index 0000000000000000000000000000000000000000..6d643ca52299f96abb7ffae52d1db1c81eb9e555
Binary files /dev/null and b/Requirements/spider_plot/spider_plot_examples.mlx differ
diff --git a/Simulation/IC_avatar.mat b/Simulation/IC_avatar.mat
new file mode 100644
index 0000000000000000000000000000000000000000..e09d55489a35c66b9340ef7a88030c3d1d06e032
Binary files /dev/null and b/Simulation/IC_avatar.mat differ
diff --git a/Simulation/Setup.m b/Simulation/Setup.m
new file mode 100644
index 0000000000000000000000000000000000000000..13f9c869e3591e06db6bff1ab552a3c8948067e9
--- /dev/null
+++ b/Simulation/Setup.m
@@ -0,0 +1,80 @@
+function []=Setup(patientNums,doParamEst,datename,patRange,dataFolder,doPV,method,continueMCMC)
+
+pathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+pathbase = [pathbase{1},filesep, 'cardiovascularavatar_T2D_HT'];
+
+addpath(genpath(pathbase))
+addpath([pathbase filesep 'Parameters'])
+addpath([pathbase filesep 'Modelfiles'])
+
+addpath([pathbase filesep 'Requirements' filesep 'PESTO-1.1.0'])
+addpath([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab'])
+addpath([pathbase filesep 'Requirements' filesep 'MEIGO'])
+
+run([pathbase filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab' filesep 'installAMICI.m'])
+run([pathbase filesep 'Requirements' filesep 'MEIGO' filesep 'install_MEIGO.m'])
+
+%METHOD:
+% inverse profile likelihood: 'invPL'
+% inverse prediction profile likelihood: 'invPredPL'
+% profile likelihood: 'PL'
+% "normal" parameter optimization: 'opt'
+
+
+if doParamEst
+    %% if no patientnums given, find all
+    patientNums = findPatientRange(patientNums,patRange,dataFolder);
+    
+    %% create folders to save results in
+    % Find names of results folder depending on what type of param
+    % estimation method
+    if nargin > 5
+        if strcmp(method,'invPL') || strcmp(method,'PL')
+            if doPV
+                resultsfolder = 'Parameters/ParameterUncertaintyPV';
+            else
+                resultsfolder = 'Parameters/ParameterUncertainty';
+            end
+        elseif strcmp(method,'invPredPL')
+            if doPV
+                resultsfolder = 'Parameters/UncertaintyPV';
+            else
+                resultsfolder = 'Parameters/Uncertainty';
+            end
+        elseif strcmp(method,'MCMC')
+                resultsfolder = 'Parameters/MCMC';
+        elseif strcmp(method,'HEALTH')
+            resultsfolder = 'Parameters/ESS';
+        elseif doPV
+            resultsfolder = 'Parameters/Fitted to PV';
+        else
+            resultsfolder = 'Parameters';
+        end
+    else
+        resultsfolder = 'Parameters';
+    end
+    resultsfolder = fullfile(pathbase,resultsfolder);
+    
+    disp(['num pats: ' num2str(length(patientNums))])
+    if continueMCMC
+        disp('continuing on old mcmc run')
+    else
+        for p = 1:length(patientNums)
+            if strcmp(method,'invPL')
+                folder = fullfile(resultsfolder, ['P' patientNums{p}]);
+            else
+                folder = fullfile(resultsfolder, ['P' patientNums{p} '_' datename]);
+            end
+            if isempty(dir(folder))
+                mkdir(folder)
+                disp(['folder created: ' folder])
+            else
+                disp(['using existing folder: ' folder])
+            end
+        end
+    end
+    clear folder
+end
+
+disp('Path setup done.')
+end
diff --git a/Simulation/calc_norm_factor.m b/Simulation/calc_norm_factor.m
new file mode 100644
index 0000000000000000000000000000000000000000..83637b6540fc22640f14147448753cf06668db64
--- /dev/null
+++ b/Simulation/calc_norm_factor.m
@@ -0,0 +1,12 @@
+function norm_factor = calc_norm_factor(T,k_syst,k_diast,m1,m2)
+N=200;      %Length of the time axis vector
+T_axis=linspace(0,T,N);
+
+Ts = k_syst*T;
+Td = k_diast*T;
+g1=(T_axis/Ts).^m1;
+g2=(T_axis/Td).^m2;
+prod=(g1./(1+g1)).*(1./(1+g2));
+norm_factor = max(prod);
+
+end
\ No newline at end of file
diff --git a/Simulation/cohortTable.m b/Simulation/cohortTable.m
new file mode 100644
index 0000000000000000000000000000000000000000..191c332572395077ade137de3e2201b283ea7065
--- /dev/null
+++ b/Simulation/cohortTable.m
@@ -0,0 +1,66 @@
+function [groupTable2,statstable,meanTable,medianTable,checkMean,checkNormality,meanTableCategorical,checkMeanCategorical,allscapisdata,stattestTable] = cohortTable(patNums,paramdata,plotFolderName)
+
+%% Load data
+inputpathbase = split(pwd,'cardiovascularavatar_HEALTH_T2D_HT');
+loadpath = [inputpathbase{1},'/cardiovascularavatar_HEALTH_T2D_HT/Data'];
+
+load(fullfile(loadpath,'scapisdata_HEALTH.mat'),'scapisdata_HEALTH')
+load(fullfile(loadpath,'bpData.mat'),'bpData');
+
+%% sort scapisdata in the same order at patNums (and remove patients not in patnums)
+patinds = zeros(size(patNums));
+patindsBPdata = zeros(size(patNums));
+for p = 1:length(patNums)
+    patientNumnoP=removeUnderscore(patNums(p));
+    patientNum = ['P' patientNumnoP{1}];
+    patinds(p) = find(strcmp(scapisdata_HEALTH.healthIDs,patientNum));
+        patindsBPdata(p) = find(strcmp(bpData.patnums,patNums(p)));
+end
+scapisdata_HEALTH_cohort = scapisdata_HEALTH(patinds,:);
+allscapisdata = scapisdata_HEALTH(patinds,:);
+
+% HR used  (during MRI)
+scapisdata_HEALTH_cohort.HR = zeros(size(scapisdata_HEALTH_cohort.HR)); %removes the other HR data
+for p = 1:length(patNums)
+    scapisdata_HEALTH_cohort.HR(p) = round(60/paramdata{p}.T,1);
+end
+
+% BP used (before MRI)
+scapisdata_HEALTH_cohort.SBP = bpData.SBP(patindsBPdata);
+scapisdata_HEALTH_cohort.DBP = bpData.DBP(patindsBPdata);
+
+
+%remove cells from numerical values
+varnames = scapisdata_HEALTH_cohort.Properties.VariableNames;
+for i = 1:length(varnames)
+    if iscell(scapisdata_HEALTH_cohort.(varnames{i}))
+        if isnumeric(scapisdata_HEALTH_cohort.(varnames{i}){1})
+            scapisdata_HEALTH_cohort.(varnames{i}) = [scapisdata_HEALTH_cohort.(varnames{i}){:}]';
+        end
+    end
+end
+
+%% Run statistics
+%numeric variables
+datanames = {'age','diabDuration','weight','height','BMI','HR','SBP','DBP','SBPhome','DBPhome','EAratio','Eeprimratio','CapillaryP_glucose1','hbA1c','HDL','LDL','TG'};
+tablenames =  {'Age','DiabetesDuration','Weight','Height','BMI','HR','SBP','DBP','SBPhome','DBPhome','EAratio','Eeprimratio','CapillaryPGlucose','hbA1c','HDL','LDL','TG'};
+[groupTable2,statstable,meanTable,checkMean,checkNormality,~,~,medianTable,stattestTable,statdocumenttable] = runStatisticalComparison('numeric',patNums,scapisdata_HEALTH_cohort,datanames,tablenames);%ttest
+
+%categorical variables
+categoricalDatanames = {'sex','smoking','insulinUse'};
+categoricalTablenames= {'Sex_men','Smoking','InsulinUse'};
+for n = 1:length(categoricalDatanames)
+        scapisdata_HEALTH_cohort.(categoricalDatanames{n}) = logical(scapisdata_HEALTH_cohort.(categoricalDatanames{n}));
+end
+[groupTable2Categorical,statstableCategorical,meanTableCategorical,checkMeanCategorical,checkNormalityCategorical,~,~,medianTableCategorical,stattestTableCat,statdocumenttableCategorical] = runStatisticalComparison('categorical',patNums,scapisdata_HEALTH_cohort,categoricalDatanames,categoricalTablenames);
+
+%combine tables
+stattestTable = [stattestTable,stattestTableCat(:,3:end)];
+groupTable2 = [groupTable2,groupTable2Categorical(:,4:end)];
+statstable = [statstable;statstableCategorical];
+checkNormality = [checkNormality;checkNormalityCategorical];
+statdocumenttable = [statdocumenttable;statdocumenttableCategorical];
+
+%save table for statistical summary document
+writetable(statdocumenttable,fullfile(plotFolderName,'statisticssummary_cohort.xlsx'))
+end
\ No newline at end of file
diff --git a/Simulation/costFunction_HEALTH.m b/Simulation/costFunction_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..9f3fd8bb02c675d52bf9c886ddde52bfbd0c067b
--- /dev/null
+++ b/Simulation/costFunction_HEALTH.m
@@ -0,0 +1,184 @@
+function [cost] = costFunction_HEALTH(theta,constants,allparams,simulationOptions,numHeartBeats,data,ind,dispErrors,doPlot)
+% Calculates the cost for the Avatar model. 
+
+%convert the parameters back after optimization
+allparams(ind.estParams) = 10.^theta;
+theta = allparams;
+
+T = constants(ind.T);
+
+%% SIMULATE THE MODEL FOR THE GIVEN PARAM
+simulationOptions.x0 = data.IC;
+datatime = data.MV(:,1)';
+simtime = sort([datatime,0:0.001:T]);
+simtime = unique(simtime);
+datatimeinds = find(ismember(simtime,datatime));
+try
+    simLast = simulate_avatarHEALTH_short(theta,constants,simulationOptions,numHeartBeats,ind,simtime);
+catch myError
+    disp("!!Error when simulating!!")
+    disp(myError.message)
+    cost = 1e99; %Return an extremly large cost if the simulation fails and there is an error.
+    return %This command causes the cost function to stop here, and it does not read the subsequent lines
+end 
+
+
+nansum = sum(isnan(simLast.x(:)));
+if (simLast.status<0) || (nansum > 0) %if simulation is NaN (ie the simulation failed)
+    cost = 1e10;
+    doPlot = 0;
+    if dispErrors
+        disp(['Simulation failed. Nan sum ' num2str(nansum) ', Status ' num2str(simLast.status)])
+    end
+else
+    %% calculate cost for each of the three blood flow measurements
+    indsyst = 1:ind.tdiast; %systole
+    inddiast = ind.tdiast:length(datatime); %diastole
+    
+    % which simulations and parameters to be compared with data
+    datanames = {'MV','AV','AC','PV'};
+    simnames = datanames;
+    dataparams = {'Emax_LV','Caa','Ctot','Rtot','ElCo'};
+    
+    weightedCosts = zeros(1,length(datanames));
+    residuals = cell(1,length(datanames));
+    compSims = cell(1,length(datanames));
+    compTime = cell(1,length(datanames));
+    compDatas = cell(1,length(datanames));
+    oscillationPunishment = zeros(1,length(datanames));
+    highresSims = cell(1,length(datanames));
+    highresTime = cell(1,length(datanames));
+    pkLocs = cell(1,length(datanames));
+
+    for i = 1:length(datanames)
+        if strcmp('MV',datanames{i})
+            dataind = inddiast;
+        elseif strcmp('PV',datanames{i}) 
+            dataind = 1:length(datatime);
+        else
+            dataind = indsyst;
+            Npeaks = 1;
+        end
+        simind = datatimeinds(dataind);
+        compSims{i} = simLast.x(simind,ind.(simnames{i}))';
+        compTime{i} = simLast.t(simind);
+        indt = find(ismember(round(simLast.t,2),round(compTime{i},2)));
+        highresSims{i} = simLast.x(indt(1):indt(end),ind.(simnames{i}))';
+        highresTime{i} = simLast.t(indt(1):indt(end));
+        
+        if ~strcmp('MV',datanames{i}) &&  ~strcmp('PV',datanames{i})
+            [pks,pkLocs{i}] = findpeaks(highresSims{i},'NPeaks',Npeaks+1);
+            if length(pks) > Npeaks %if more than expected num of peaks: add cost punishment
+                oscillationPunishment(i) = 30;
+            end
+        end
+        compDatas{i} = data.(datanames{i})(dataind,:);
+        residuals{i} = (compSims{i} - compDatas{i}(:,2)').^2;
+        weightedCosts(i) = sum(residuals{i})/mean(compDatas{i}(:,2))/length(compSims{i}); %normalize number of datapoints
+    end
+    
+    %% Brachial/Aortic pressure
+    maxAorticPressure = max(simLast.y(:,ind.brachialPressure));
+    minAorticPressure = min(simLast.y(:,ind.brachialPressure));
+    
+    % diffparam determining difference between brachial and aortic systolic
+    % pressure (data from anglo-cardiff trial II
+    % http://dx.doi.org/10.1161/HYPERTENSIONAHA.107.105445) 8.6 mean value
+    lb = 0.1;ub =18.9;
+    diffparam = max(min(data.SBP-maxAorticPressure,ub),lb);%parameter determining the difference between brachial and aortic SBP
+    
+    estimatedSBP = maxAorticPressure + diffparam;
+    estimatedDBP = minAorticPressure;
+
+    costSBP = (data.SBP - estimatedSBP)^2;
+    costDBP = (data.DBP - estimatedDBP)^2;
+    
+    costSBPWeighted = costSBP /data.SBP;
+    costDBPWeighted= costDBP/data.DBP;
+    weightedCosts = [weightedCosts,costSBPWeighted,costDBPWeighted];
+    
+    %% Parameters
+    paramcosts = zeros(1,length(data.params));
+    paramcostsWeighted = zeros(1,length(data.params));
+    for p = 1:length(dataparams)
+        pval = theta(ind.(dataparams{p}));
+        dval = data.params.(dataparams{p});
+        paramcosts(p) = ((pval - dval(1))^2);
+        paramcostsWeighted(p) = ((pval - dval(1))^2)/dval(1);
+    end
+    weightedCosts = [weightedCosts,paramcostsWeighted];
+    
+    %% punishment if Emax < Emin (non physiological)
+    emaxEminPunishment = 0;
+    if theta(ind.Emax_LA) < theta(ind.Emin_LA)
+        emaxEminPunishment = 200 + (theta(ind.Emin_LA)-theta(ind.Emax_LA))*10000;
+    end
+    if theta(ind.Emax_LV) < theta(ind.Emin_LV)
+        emaxEminPunishment = emaxEminPunishment + 200 + (theta(ind.Emin_LV)-theta(ind.Emax_LV))*10000;
+    end
+    
+    %% Final cost
+    % (AV + AC/2 to even out 2 measurments around systole from AV & AC compared
+    % to 1 measurement in diastiole from MV
+    SBPweight = 3;
+    DBPweight = 3;
+    paramweight = 3;
+    
+    cost = weightedCosts(4) + weightedCosts(1) + (weightedCosts(2) + weightedCosts(3))/2 ...
+        +sum(oscillationPunishment) + emaxEminPunishment ...
+        + sum(paramcostsWeighted)*paramweight + costSBPWeighted*SBPweight + costDBPWeighted*DBPweight;
+end
+
+%% Plotting
+if doPlot
+    f = figure('Name','Cost plot');
+    f.Units = 'Normalized';
+    f.OuterPosition = [0 0 1 1 ];
+    sgtitle(sprintf('Cost: %0.2f (pure: %0.2f)', cost,sum(weightedCosts)))
+    hold on
+    for i = 1:length(compDatas)
+        subplot(2,3,i)
+        if (i == 2 || i == 3)
+            title(sprintf('%s: %0.2f (pure %0.2f)',datanames{i},weightedCosts(i)/2,weightedCosts(i)))
+        end
+        hold on
+        plot(compDatas{i}(:,1),compDatas{i}(:,2),'ko-','LineWidth',2)
+         if strcmp(datanames{i},'PV')
+             stdv = 0.3;
+         else
+             stdv = 0.15;
+         end
+        errorbar(compDatas{i}(:,1),compDatas{i}(:,2),ones(1,length(compDatas{i}))*mean(compDatas{i}(:,2)*stdv),'k','LineWidth',1.5)
+        plot(highresTime{i},highresSims{i},'r--','LineWidth',2)
+        plot(compTime{i},compSims{i},'r*','LineWidth',2)
+        for p = 1:length(pkLocs{i})
+            plot(highresTime{i}(pkLocs{i}(p)),highresSims{i}(pkLocs{i}(p)),'bo','LineWidth',2)
+        end
+        legend({'Data','Simulation'})
+    end
+    
+    subplot(2,3,i+1)
+    title(sprintf('Params: %0.2f (pure %0.2f)',sum(paramcostsWeighted)*paramweight,sum(paramcostsWeighted)))
+    hold on
+    for p = 1:length(dataparams)
+        pval = theta(ind.(dataparams{p}));
+        dval = data.params.(dataparams{p});
+        plot(p,log10(pval),'r*','LineWidth',2)
+        plot(p,log10(dval(1)),'ko','LineWidth',2)
+    end
+    xticks(1:length(dataparams))
+   xticklabels(dataparams);
+   ylabel('Param value (log10)')
+   
+   subplot(2,3,i+2)
+   title(sprintf('Cost SBP: %0.2f (pure %0.2f), Cost DBP: %0.2f (pure %0.2f)',costSBPWeighted*DBPweight,costSBPWeighted,costDBPWeighted*DBPweight,costDBPWeighted))
+   hold on
+   plot(simLast.t,simLast.y(:,ind.brachialPressure),'r-','LineWidth',2)
+   plot(simLast.t(simLast.y(:,ind.brachialPressure) == maxAorticPressure),estimatedSBP,'r*')
+   plot(simLast.t(simLast.y(:,ind.brachialPressure) == minAorticPressure),estimatedDBP,'r*')
+   yline(data.SBP,'k-','LineWidth',2);
+   yline(data.DBP,'k-','LineWidth',2);
+   xlim([0 simLast.t(end)])
+end
+
+end
\ No newline at end of file
diff --git a/Simulation/costFunction_HEALTH_allcalculations.m b/Simulation/costFunction_HEALTH_allcalculations.m
new file mode 100644
index 0000000000000000000000000000000000000000..9ceb6c55e94786fa30f353fe5a4e057b737c79ea
--- /dev/null
+++ b/Simulation/costFunction_HEALTH_allcalculations.m
@@ -0,0 +1,188 @@
+function [cost,simLast,residuals,SVdiffs,costs,rmse,weightedCosts,percenterror,MAPE] = costFunction_HEALTH_allcalculations(theta,constants,allparams,simulationOptions,numHeartBeats,data,ind,datanames)
+
+% Calculates the cost for the Avatar model. 
+allparams(ind.estParams) = 10.^theta;
+theta = allparams;
+
+T = constants(ind.T);
+
+%% SIMULATE THE MODEL FOR THE GIVEN PARAM
+simulationOptions.x0 = data.IC;
+datatime = data.MV(:,1)';
+simtime = sort([datatime,0:0.001:T]);
+simtime = unique(simtime);
+datatimeinds = find(ismember(simtime,datatime));
+try
+    simLast = simulate_avatarHEALTH_short(theta,constants,simulationOptions,numHeartBeats,ind,simtime);
+catch myError
+    disp("!!Error when simulating!!")
+    disp(myError.message)
+    cost = 1e99; %Return an extremly large cost if the simulation fails and there is an error.
+    return %This command causes the cost function to stop here, and it does not read the subsequent lines
+end 
+
+nansum = sum(isnan(simLast.x(:)));
+if (simLast.status<0) || (nansum > 0) %if simulation is NaN
+    cost = 1e10;
+    residuals = NaN;
+    SVdiffs = NaN;
+    costs = NaN;
+    MAPE = NaN;
+    simLast = NaN;
+    rmse = NaN;
+    weightedCosts = NaN;
+    percenterror = NaN;
+    disp(['Simulation failed. Nan sum ' num2str(nansum) ', Status ' num2str(simLast.status)])
+else
+    %% calculate cost for each of the four blood flow measurements
+    indsyst = 1:ind.tdiast; %syst
+    inddiast = ind.tdiast:length(datatime); %diast
+    
+    if nargin < 9
+        datanames = {'MV','AV','AC','PV'};%{'MV','AV','AC','PV'};
+    end
+    simnames = datanames;
+    dataparams = {'Emax_LV','Caa','Ctot','Rtot','ElCo'};
+    
+    costs = zeros(1,length(datanames));
+    rmse = zeros(1,length(datanames));
+    weightedCosts = zeros(1,length(datanames));
+    residuals = cell(1,length(datanames)+2+length(dataparams));
+    MAPE = zeros(1,length(datanames)+2+length(dataparams));
+    compSims = cell(1,length(datanames));
+    compTime = cell(1,length(datanames));
+    compDatas = cell(1,length(datanames));
+    SVdiffs = zeros(1,length(datanames));
+    oscillationPunishment = zeros(1,length(datanames));
+    highresSims = cell(1,length(datanames));
+    highresTime = cell(1,length(datanames));
+    %pkLocs = cell(1,length(datanames));
+    percenterror.all = zeros(1,length(datanames)+2+length(dataparams));
+    percenterror.flow = 0;
+    alldatasum=0;
+    allresidualssum=0;
+    for i = 1:length(datanames)
+        if strcmp('MV',datanames{i})
+            dataind = inddiast;
+        elseif strcmp('PV',datanames{i}) %PV
+            dataind = 1:length(datatime);
+        else
+            dataind = indsyst;
+            Npeaks = 1;
+        end
+        simind = datatimeinds(dataind);
+        compSims{i} = simLast.x(simind,ind.(simnames{i}))';
+        compTime{i} = simLast.t(simind);
+        indt = find(ismember(round(simLast.t,2),round(compTime{i},2)));
+        highresSims{i} = simLast.x(indt(1):indt(end),ind.(simnames{i}))';
+        highresTime{i} = simLast.t(indt(1):indt(end));
+        
+%         if ~strcmp('MV',datanames{i}) &&  ~strcmp('PV',datanames{i})
+%             [pks,pkLocs{i}] = findpeaks(highresSims{i},'NPeaks',Npeaks+1);
+%             if length(pks) > Npeaks %if more than expected num of peaks
+%                 %disp('oscillationPunishment, but not included in cost')
+%                 %oscillationPunishment(i) = 30;
+%             end
+%         end
+        
+        compDatas{i} = data.(datanames{i})(dataind,:);
+        residuals{i} = (compSims{i} - compDatas{i}(:,2)');
+        weightedCosts(i) = sum(residuals{i}.^2)/mean(compDatas{i}(:,2))/length(compSims{i}); %normalize num of datapoints
+        
+        costs(i) = sum(residuals{i}.^2);
+        rmse(i) = sqrt(sum(residuals{i}.^2)/length(compSims{i}));
+        % Look at SV (total blood volume through the AV/MV/AC during the cardiac
+        % cycle)
+        SVdiffs(i) = trapz(compTime{i},compSims{i}) - trapz(compTime{i},compDatas{i}(:,2)');
+        percenterror.all(i) = 100*sum(abs(residuals{i}))/sum(compDatas{i}(:,2));
+        allresidualssum = allresidualssum+sum(abs(residuals{i}));
+        alldatasum = alldatasum+sum(compDatas{i}(:,2));
+        
+        MAPE(i) = 100*sum(abs(residuals{i}./compDatas{i}(:,2)'));
+    end
+    flowcosts = costs;
+    percenterror.flow = 100*allresidualssum/alldatasum;
+    
+    %rmse all flow
+    rmseflow=0;n=0;
+    for i = 1:length(datanames)
+        rmseflow = rmseflow+sum(residuals{i}.^2);
+        n = length(compSims{i})+n;
+    end
+    rmseflow = sqrt(rmseflow/n);
+    rmse = [rmse,rmseflow];
+    
+    numdatapoints = n;
+    %% Brachial/Aortic pressure
+    maxAorticPressure = max(simLast.y(:,ind.brachialPressure));
+    minAorticPressure = min(simLast.y(:,ind.brachialPressure));
+    
+    % diffparam determining difference between brachial and aortic systolic
+    % pressure (data from anglo-cardiff trial II
+    % http://dx.doi.org/10.1161/HYPERTENSIONAHA.107.105445) 8.6 mean value
+    lb = 0.1;ub =18.9;
+    diffparam = max(min(data.SBP-maxAorticPressure,ub),lb);%parameter determining the difference between brachial and aortic SBP
+    
+    estimatedSBP = maxAorticPressure + diffparam;
+    estimatedDBP = minAorticPressure;
+
+    costSBP = (data.SBP - estimatedSBP)^2;
+    costDBP = (data.DBP - estimatedDBP)^2;
+    
+    costSBPWeighted = costSBP /data.SBP;
+    costDBPWeighted= costDBP/data.DBP;
+    weightedCosts = [weightedCosts,costSBPWeighted,costDBPWeighted];
+ 
+    residuals(length(datanames)+1:length(datanames)+2) = {data.SBP - estimatedSBP,data.DBP - estimatedDBP};
+    percenterror.all(length(datanames)+1:length(datanames)+2) = 100*[abs(data.SBP - estimatedSBP)/data.SBP, abs(data.DBP - estimatedDBP)/data.DBP];
+    rmse = [rmse,sqrt((costSBP+costDBP)/2)];
+    
+    MAPE(length(datanames)+1) = 100*abs((data.SBP - estimatedSBP)/data.SBP);
+    MAPE(length(datanames)+2) = 100*abs((data.DBP - estimatedDBP)/data.DBP);
+    numdatapoints = numdatapoints+2;
+    %% parameters
+    paramdatasum=0;paramresidualsum=0;
+    paramcosts = zeros(1,length(data.params));
+    paramcostsWeighted = zeros(1,length(data.params));
+    for p = 1:length(dataparams)
+        pval = theta(ind.(dataparams{p}));
+        dval = data.params.(dataparams{p});
+        paramcosts(p) = ((pval - dval(1))^2);
+        paramcostsWeighted(p) = ((pval - dval(1))^2)/dval(1);
+        residuals(length(datanames)+2+p) = {pval - dval(1)};
+        percenterror.all(length(datanames)+2+p) = 100*(abs(pval - dval(1)))/dval(1);
+        paramresidualsum = paramresidualsum+abs(pval - dval(1));
+        paramdatasum = paramdatasum+dval(1);
+        MAPE(length(datanames)+2+p) = 100*abs((dval(1) - pval)/dval(1));
+        numdatapoints = numdatapoints+1;
+    end
+    weightedCosts = [weightedCosts,paramcostsWeighted];
+    
+    costs = [costs,costSBP+costDBP,paramcosts];
+    rmse = [rmse,sqrt(sum(paramcosts)/length(paramcosts))];
+    percenterror.params = 100*(paramresidualsum+abs(data.SBP - estimatedSBP)+abs(data.DBP - estimatedDBP))/(data.SBP+data.DBP+paramdatasum);
+    percenterror.sumall = 100*(allresidualssum+paramresidualsum+abs(data.SBP - estimatedSBP)+abs(data.DBP - estimatedDBP))/(data.SBP+data.DBP+paramdatasum+alldatasum);
+    MAPE = sum(MAPE)/numdatapoints;
+    
+    %% punishment if Emax < Emin (non physiological)
+    emaxEminPunishment = 0;
+    if theta(ind.Emax_LA) < theta(ind.Emin_LA)
+        emaxEminPunishment = 200 + (theta(ind.Emin_LA)-theta(ind.Emax_LA))*10000;
+    end
+    if theta(ind.Emax_LV) < theta(ind.Emin_LV)
+        emaxEminPunishment = emaxEminPunishment + 200 + (theta(ind.Emin_LV)-theta(ind.Emax_LV))*10000;
+    end
+    
+    %% Final cost
+    % (AV + AC/2 to even out 2 measurments around systole from AV & AC compared
+    % to 1 measurement in diastiole from MV
+    SBPweight = 3;
+    DBPweight = 3;
+    paramweight = 3;
+    
+    cost = weightedCosts(4) + weightedCosts(1) + (weightedCosts(2) + weightedCosts(3))/2 ...
+        +sum(oscillationPunishment) + emaxEminPunishment ...
+        + sum(paramcostsWeighted)*paramweight + costSBPWeighted*SBPweight + costDBPWeighted*DBPweight;%costMAPWeighted*BPweight;% + costLA;
+end
+
+end 
\ No newline at end of file
diff --git a/Simulation/findAllParams.m b/Simulation/findAllParams.m
new file mode 100644
index 0000000000000000000000000000000000000000..360f5b3863ae0d34355ebf71291b4573fb5ecb22
--- /dev/null
+++ b/Simulation/findAllParams.m
@@ -0,0 +1,181 @@
+function [patNumsSims,bestparams,bestcosts,meanparams,allokParams,...
+    allokCosts,minValuesparams,maxValuesparams,numsincluded,data,inds,constants,medianparams] = findAllParams(resultsFolder,patNumsOrig,patNumsPlot,paramNames,data,inds,constants)
+
+%% Load saved results if possible
+%load saved results if it exists
+loadResults = 1;
+loadfiles=dir(sprintf('./Parameters/MCMC/allokparams_*'));
+if loadResults && ~isempty(loadfiles)
+    % Always load the latest results
+    [~,latestfolderInd] = max([loadfiles.datenum]);
+    foldernames = {loadfiles.name};
+    folderpaths = {loadfiles.folder};
+    loadfilename = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+    load(loadfilename,'patNumsSims','bestparams','bestcosts','meanparams','medianparams','allokParams',...
+        'allokCosts','minValuesparams','maxValuesparams','numsincluded','data','inds','constants');
+    fprintf('findAllParams: Loading existing results from %s \n',loadfilename)
+    
+    % In patient-specific predictions (eg. when running createFigures_hypertensionT2D_predictions),
+    % only the results for one subject at a time is wanted.
+    % Thus, we remove all other subjects:
+    removenow = ~ismember(patNumsSims,patNumsPlot);
+    if sum(removenow) > 0
+        disp('findAllParams: removing all subjects not wanted. Wanted subjects:')
+        disp(patNumsPlot)
+        allokParams(removenow) = [];
+        allokCosts(removenow) = [];
+        bestparams(:,removenow) = [];
+        bestcosts(removenow) = [];
+        meanparams(:,removenow) = [];
+        medianparams(:,removenow) = [];
+        data(removenow) = [];
+        constants(:,removenow) = [];
+        minValuesparams(:,removenow) = [];
+        maxValuesparams(:,removenow) = [];
+        inds(removenow) = [];
+        numsincluded.MCMC(removenow) = [];
+        numsincluded.ESS(removenow) = [];
+        patNumsSims(removenow) = [];
+    end
+        
+else
+    %pre-define vectors
+    patNumsSims = [];
+    maxValuesparams = zeros(length(paramNames),length(patNumsOrig));
+    minValuesparams= zeros(length(paramNames),length(patNumsOrig));
+    allokParams = cell(1,length(patNumsOrig));
+    allokCosts = cell(1,length(patNumsOrig));
+    meanparams = zeros(length(paramNames),length(patNumsOrig));
+    medianparams = zeros(length(paramNames),length(patNumsOrig));
+    bestparams= zeros(length(paramNames),length(patNumsOrig));
+    bestcosts= zeros(length(patNumsOrig),1);
+    numsincluded.MCMC = nan(1,length(patNumsOrig));
+    numsincluded.ESS = nan(1,length(patNumsOrig));
+    
+    %settings for findBestParams
+    loadmean=0;
+    loadsummaryfile=0;
+    
+    % Load parameters for each subject p
+    for p = 1:size(patNumsOrig,2)
+        patientNum = patNumsOrig{p};
+        
+        %% Load ESS params
+        % find latest patientfolder with ESS optimizations
+        loadresultsfolder = [resultsFolder '/P' patientNum '_*'];
+        folders = dir(loadresultsfolder);
+        if isempty(folders)
+            disp(['findAllParams: OBS couldnt load ESS parameters for p' patientNum, ' (no prev folder)'])
+            foundESS = false;
+        else
+            foundESS = true;
+            [~,latestfolderInd] = max([folders.datenum]);
+            foldernames = {folders.name};
+            folderpaths = {folders.folder};
+            
+            folderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+            if isempty(dir([folderName,'/opt-*'])) && doOptimization && length(foldernames) > 1%new empty folder created, so take the next latest one if it exists
+                folderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd-1});
+            end
+            [bestessParam,bestessCost,allparamsESS,~,~] = findBestParams(folderName,loadsummaryfile,length(paramNames),loadmean);
+        end
+        %% Load MCMC params
+        % Find patient folder
+        folders = dir(['Parameters/MCMC/P' patientNum '_*']);
+        if length(folders) < 1
+            foundMCMC = false;
+            bestMCMCcost = bestessCost;
+        else
+            %find latest folder
+            [~,latestfolderInd] = max([folders.datenum]);
+            foldernames = {folders.name};
+            folderpaths = {folders.folder};
+            folder = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+            
+            % Load min & max for all parameters in this patient folder
+            files = dir(fullfile(folder,'parameters-*'));
+            if isempty(files)
+                foundMCMC = false;
+                bestMCMCcost = bestessCost;
+            else
+                foundMCMC = true;
+                load(fullfile(files(1).folder,files(1).name),'parameters');
+                allMCMCparams = 10.^(parameters.S.par);
+                allMCMCcosts = -parameters.S.logPost;
+                [bestMCMCcost,bestMCMCind] = min(allMCMCcosts);
+                bestMCMCparams = allMCMCparams(:,bestMCMCind);
+                
+                %best of mcmc and ess
+                if bestMCMCcost < bestessCost
+                    %fprintf('MCMC opt lower cost (MCMC %0.2f vs ESS %0.2f)\n',bestMCMCcost,bestessCost)
+                    bestparams(:,p) = bestMCMCparams;
+                    bestcosts(p) = bestMCMCcost;
+                else
+                    %fprintf('ESS opt lower cost (MCMC %0.2f vs ESS %0.2f)\n',bestMCMCcost,bestessCost)
+                    bestparams(:,p) = bestessParam';
+                    bestcosts(p) = bestessCost;
+                end
+            end
+        end
+        
+        if foundESS
+            patNumsSims = [patNumsSims,{patNumsPlot{p}}];
+            %% Combine all params
+            if foundMCMC
+                allparams = [allparamsESS(:,2:end);allMCMCparams'];
+                allcosts = [allparamsESS(:,1);allMCMCcosts];
+            else
+                disp('findAllParams: no MCMC params found')
+                allparams = allparamsESS(:,2:end);
+                allcosts = allparamsESS(:,1);
+            end
+            
+            %include all params within +10% of best MCMC cost
+            okinds = allcosts <= bestMCMCcost*1.10;
+            allokParams{p} = allparams(okinds,:);
+            allokCosts{p} = allcosts(okinds,:);
+            meanparams(:,p) = mean(allokParams{p});
+            medianparams(:,p) = median(allokParams{p});
+            
+            minValuesparams(:,p) = min(allokParams{p},[],1);
+            maxValuesparams(:,p) = max(allokParams{p},[],1);
+            
+            if foundMCMC
+                numsincluded.MCMC(p) = sum(allMCMCcosts <= bestMCMCcost*1.1);
+            else
+                numsincluded.MCMC(p) = NaN;
+            end
+            numsincluded.ESS(p) = sum(allparamsESS(:,1) <= bestMCMCcost*1.1);
+        end
+    end
+    
+    %% remove subjects where no parameters were loaded
+    if isempty(patNumsSims)
+        removeindex = 1:length(patNumsPlot);
+    else
+        removeindex = ~ismember(patNumsPlot,patNumsSims);
+        allokParams(removeindex) = [];
+        allokCosts(removeindex) = [];
+        bestparams(:,removeindex) = [];
+        bestcosts(removeindex) = [];
+        meanparams(:,removeindex) = [];
+        medianparams(:,removeindex) = [];
+        data(removeindex) = [];
+        constants(:,removeindex) = [];
+        minValuesparams(:,removeindex) = [];
+        maxValuesparams(:,removeindex) = [];
+        inds(removeindex) = [];
+        numsincluded.MCMC(removeindex) = [];
+        numsincluded.ESS(removeindex) = [];
+    end
+    
+    %% Save results
+    savefilename = sprintf('./Parameters/MCMC/allokparams_%s',datestr(now,'yymmdd-HHMM'));
+    save(savefilename,'patNumsSims','bestparams','bestcosts','meanparams','medianparams','allokParams',...
+        'allokCosts','minValuesparams','maxValuesparams','numsincluded','removeindex','data','inds','constants');
+    
+end
+
+
+
+end
\ No newline at end of file
diff --git a/Simulation/findBestParams.m b/Simulation/findBestParams.m
new file mode 100644
index 0000000000000000000000000000000000000000..09537a11650f34866d856afd23f69eff6c9b70cf
--- /dev/null
+++ b/Simulation/findBestParams.m
@@ -0,0 +1,49 @@
+function [bestparams,bestcostAll,allparams,bestconstants,meanparams,medianparams] = findBestParams(folderName,loadsummaryfile,numParams,loadMean)
+% Load parameters with lowest cost
+if nargin <3
+    numParams = 22;
+else
+    numParams = numParams+1;
+end
+
+meanparams = NaN;
+medianparams = NaN;
+files = dir(fullfile(folderName,'opt-*'));
+summaryfile = dir(fullfile(folderName,'bestparam*'));
+if isempty(files)
+    disp('findBestParams: ERROR - emtpy load folder')
+    bestparams  =NaN;
+    bestcostAll = NaN;
+    allparams  =NaN;
+    bestconstants = NaN;
+elseif ~loadsummaryfile || (loadsummaryfile && isempty(summaryfile)) || loadMean
+    bestcostAll = 1e100;
+    allparams = zeros(length(files),numParams);
+    for f = 1:length(files)
+        load(fullfile(files(f).folder,files(f).name),'optParam','bestcost','constants')
+        allparams(f,1) = bestcost;
+        if f == 1 && length(optParam) ~= length(allparams(f,2:end)) %if wrong param length
+            allparams = zeros(length(files),length(optParam)+1);
+            disp('findBestParams: OBS length of parameter vectors does not match!')
+        end
+        allparams(f,2:end) = optParam;
+        if bestcost < bestcostAll
+            bestparams = optParam;
+            bestcostAll = bestcost;
+            bestconstants = constants;
+        end
+    end
+    
+    okinds = allparams(:,1) <= bestcostAll*1.10;%1.05
+    meanparams = mean(allparams(okinds,2:end));
+    medianparams = median(allparams(okinds,2:end));
+    
+    if loadsummaryfile
+        save(sprintf('%s/bestparam(%0.3f).mat',files(f).folder,bestcostAll),'bestparams','bestcostAll','bestconstants','allparams')
+    end
+else
+    %load summaryfile
+    fprintf('Findbestparams: Loaded summaryfile %s \n',summaryfile(1).name)
+    load(fullfile(summaryfile(1).folder,summaryfile(1).name),'bestparams','bestcostAll','bestconstants','allparams')
+end
+end
\ No newline at end of file
diff --git a/Simulation/findSimulationUncertainty.m b/Simulation/findSimulationUncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..5a2e7fe8b9167b39664622ca17357b42ebe6d30c
--- /dev/null
+++ b/Simulation/findSimulationUncertainty.m
@@ -0,0 +1,192 @@
+function [minmaxSim] = findSimulationUncertainty(patNums,parameters,constants,inds,data,options,bestParams,saveResults,loadResults)
+%parameters: cell with one or several parameter sets for each patient
+%constants: cell with constant values for each patient
+
+%% Load saved results if possible
+loadfiles=dir(sprintf('../Parameters/MCMC/minmaxsims_*'));
+if loadResults && ~isempty(loadfiles)
+    [~,latestfolderInd] = max([loadfiles.datenum]);
+    foldernames = {loadfiles.name};
+    folderpaths = {loadfiles.folder};
+    loadfilename = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+    load(loadfilename,'minmaxSim');
+    fprintf('findSimulationUncertainty: Loading results from %s \n',loadfilename)
+    
+    
+else
+    %% Simulation settings
+    numHeartBeats = 20;
+    step = 0.001;
+    
+    %% Setup variables
+    minmaxSim.States.min = cell(size(parameters));
+    minmaxSim.States.max = cell(size(parameters));
+    minmaxSim.States.best = cell(size(parameters));
+    
+    minmaxSim.Observables.min = cell(size(parameters));
+    minmaxSim.Observables.max = cell(size(parameters));
+    minmaxSim.Observables.best = cell(size(parameters));
+    
+    minmaxSim.Observables.all = cell(size(parameters));
+    minmaxSim.States.all = cell(size(parameters));
+    
+    minmaxSim.pressurenames = {'pLA','pLV','pAo','pPV'};
+    minmaxSim.pressureindexes = [17,18,1,13];
+    for pr = 1:length(minmaxSim.pressurenames)
+        minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).max = cell(size(parameters));
+        minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).min = cell(size(parameters));
+        minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).best = cell(size(parameters));
+        minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).max = cell(size(parameters));
+        minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).min = cell(size(parameters));
+        minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).best = cell(size(parameters));
+    end
+    
+    %% Run simulations
+    w = warning('off','all');
+    for p = 1:size(parameters,2)%for each subject
+        T = constants(inds{p}.T,p);
+        simtime = sort([data{p}.time,0:step:T]);
+        simtime = unique(simtime);
+        options.x0 = data{p}.IC;
+        
+        parameters{p} = parameters{p}';
+        %simulate best paramset
+        if ~isempty(bestParams)
+            simLast = simulate_avatarHEALTH_short(bestParams(:,p),constants(:,p),options,numHeartBeats,inds{p},simtime);
+            [estimatedSBP,estimatedDBP] = brachialpressure(simLast,inds{p},data{p});
+            minmaxSim.States.best{p} = simLast.x;
+            minmaxSim.Observables.best{p} = simLast.y;
+            minmaxSim.SBP.best{p} = estimatedSBP;
+            minmaxSim.DBP.best{p} = estimatedDBP;
+            SVsim=trapz(simLast.t,simLast.x(:,inds{p}.AV));
+            EFsim = 100*SVsim/max(simLast.x(:,5));
+            minmaxSim.SV.best{p} = SVsim;
+            minmaxSim.EF.best{p} = EFsim;
+            
+            minmaxSim.States.min{p} = simLast.x;
+            minmaxSim.States.max{p} = simLast.x;
+            minmaxSim.Observables.min{p} = simLast.y;
+            minmaxSim.Observables.max{p} = simLast.y;
+            minmaxSim.time{p} = simLast.t;
+            
+            minmaxSim.SBP.max{p} = estimatedSBP;
+            minmaxSim.SBP.min{p} = estimatedSBP;
+            minmaxSim.DBP.max{p} = estimatedDBP;
+            minmaxSim.DBP.min{p} = estimatedDBP;
+            minmaxSim.SV.max{p} = SVsim;
+            minmaxSim.SV.min{p} = SVsim;
+            minmaxSim.EF.max{p} = EFsim;
+            minmaxSim.EF.min{p} = EFsim;
+            
+            for pr = 1:length(minmaxSim.pressurenames)
+                thispressure = simLast.y(:,minmaxSim.pressureindexes(pr));
+                minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).max{p} = mean(thispressure);
+                minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).min{p} = mean(thispressure);
+                minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).best{p} = mean(thispressure);
+                minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).max{p} = max(thispressure)-min(thispressure);
+                minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).min{p} = max(thispressure)-min(thispressure);
+                minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).best{p} = max(thispressure)-min(thispressure);
+            end
+            
+        end
+        
+        %reduce number of simulated params if they are too many
+        numparams=size(parameters{p},2);
+        if numparams>2000
+            fprintf('The number of simulated parameter sets is reduced from %d to %d\n',numparams,2000)
+            ind=round(linspace(1,numparams,2000));
+            %always include last paramset
+            paramsToSim = parameters{p}(:,[ind,numparams]);
+        else
+            paramsToSim = parameters{p};
+        end
+        
+        % Simulate all parameter sets
+        fprintf('Simulating %d parameter sets...\n',size(paramsToSim,2))
+        for s = 1:size(paramsToSim,2)%for each parameter set
+%             fprintf('Simulating paramset %d/%d\n',s,size(paramsToSim,2))
+            simLast = simulate_avatarHEALTH_short(paramsToSim(:,s),constants(:,p),options,numHeartBeats,inds{p},simtime);
+            [estimatedSBP,estimatedDBP] = brachialpressure(simLast,inds{p},data{p});
+            SVsim=trapz(simLast.t,simLast.x(:,inds{p}.AV));
+            EFsim = 100*SVsim/max(simLast.x(:,5));
+            if isempty(bestParams) && s == 1
+                minmaxSim.States.min{p} = simLast.x;
+                minmaxSim.States.max{p} = simLast.x;
+                minmaxSim.Observables.min{p} = simLast.y;
+                minmaxSim.Observables.max{p} = simLast.y;
+                minmaxSim.time{p} = simLast.t;
+                minmaxSim.SBP.max{p} = estimatedSBP;
+                minmaxSim.SBP.min{p} = estimatedSBP;
+                minmaxSim.DBP.max{p} = estimatedDBP;
+                minmaxSim.DBP.min{p} = estimatedDBP;
+                minmaxSim.SV.max{p} = SVsim;
+                minmaxSim.SV.min{p} = SVsim;
+                minmaxSim.EF.max{p} = EFsim;
+                minmaxSim.EF.min{p} = EFsim;
+                
+                minmaxSim.States.best{p} = NaN(size(simLast.x));
+                minmaxSim.Observables.best{p} = NaN(size(simLast.y));
+                minmaxSim.SBP.best{p} = NaN;
+                minmaxSim.DBP.best{p} = NaN;
+                minmaxSim.SV.best{p} = NaN;
+                minmaxSim.EF.best{p} = NaN;
+                
+                for pr = 1:length(minmaxSim.pressurenames)
+                    thispressure = simLast.y(:,minmaxSim.pressureindexes(pr));
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).max{p} = mean(thispressure);
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).min{p} = mean(thispressure);
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).best{p} = NaN;
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).max{p} = max(thispressure)-min(thispressure);
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).min{p} = max(thispressure)-min(thispressure);
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).best{p} = NaN;
+                end
+                
+                for obs = 1:size(simLast.y,2)
+                    minmaxSim.all{obs}{p} =  zeros(size(parameters{p},1),length(simtime));
+                end
+            else
+                % Save the maximum and minimum values for each simulated variable in a struct
+                minmaxSim.States.min{p} = min(simLast.x,minmaxSim.States.min{p});
+                minmaxSim.States.max{p} = max(simLast.x,minmaxSim.States.max{p});
+                minmaxSim.Observables.min{p} = min(simLast.y,minmaxSim.Observables.min{p});
+                minmaxSim.Observables.max{p} = max(simLast.y,minmaxSim.Observables.max{p});
+                minmaxSim.SBP.max{p} = max(estimatedSBP,minmaxSim.SBP.max{p});
+                minmaxSim.SBP.min{p} = min(estimatedSBP,minmaxSim.SBP.min{p});
+                minmaxSim.DBP.max{p} = max(estimatedDBP,minmaxSim.DBP.max{p});
+                minmaxSim.DBP.min{p} = min(estimatedDBP,minmaxSim.DBP.min{p});
+                minmaxSim.SV.max{p} = max(SVsim,minmaxSim.SV.max{p});
+                minmaxSim.SV.min{p} = min(SVsim,minmaxSim.SV.min{p});
+                minmaxSim.EF.max{p} = max(EFsim,minmaxSim.EF.max{p});
+                minmaxSim.EF.min{p} = min(EFsim,minmaxSim.EF.min{p});
+                
+                for pr = 1:length(minmaxSim.pressurenames)
+                    thispressure = simLast.y(:,minmaxSim.pressureindexes(pr));
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).max{p} = max(mean(thispressure),minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).max{p});
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).min{p} = min(mean(thispressure),minmaxSim.([minmaxSim.pressurenames{pr} 'mean']).min{p});
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).max{p} = max(max(thispressure)-min(thispressure),minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).max{p});
+                    minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).min{p} = min(max(thispressure)-min(thispressure),minmaxSim.([minmaxSim.pressurenames{pr} 'diff']).min{p});
+                end
+            end
+        end
+    end
+    w = warning('on','all');
+    if saveResults
+        save(sprintf('../Parameters/MCMC/minmaxsims_%s',datestr(now,'yymmdd-hhMM')),'minmaxSim','patNums');
+    end
+end
+
+end
+
+function [estimatedSBP,estimatedDBP] = brachialpressure(simLast,ind,data)
+    %% Brachial/Aortic pressure
+    maxAorticPressure = max(simLast.y(:,ind.brachialPressure));
+    minAorticPressure = min(simLast.y(:,ind.brachialPressure));
+    % diffparam determining difference between brachial and aortic systolic
+    % pressure (data from anglo-cardiff trial II
+    % http://dx.doi.org/10.1161/HYPERTENSIONAHA.107.105445) 8.6 mean value
+    lb = 0.1;ub =18.9;
+    diffparam = max(min(data.SBP-maxAorticPressure,ub),lb);%parameter determining the difference between brachial and aortic SBP
+    
+    estimatedSBP = maxAorticPressure + diffparam;
+    estimatedDBP = minAorticPressure;
+end
diff --git a/Simulation/iccalcs.m b/Simulation/iccalcs.m
new file mode 100644
index 0000000000000000000000000000000000000000..acab8ec9641145800066ee4fac8de17f42ddfb51
--- /dev/null
+++ b/Simulation/iccalcs.m
@@ -0,0 +1,211 @@
+function [ICs,dICs] = iccalcs(paramValues,constants,paramNames,constantsNames,data,ind,simulation)
+% Calculate the initial conditions for a specific subject.
+
+%% Pre-calculations otherwise made in the simulate function
+T = constants(strcmp('T',constantsNames));
+
+% Calculate normalizing factors for elastance function based on the parameters
+constants(end) = calc_norm_factor(T,paramValues(ind.k_syst_LV),paramValues(ind.k_diast_LV),paramValues(ind.m1_LV),paramValues(ind.m2_LV));
+constants(end-1) = calc_norm_factor(T,paramValues(ind.k_syst_LA),paramValues(ind.k_diast_LA),paramValues(ind.m1_LA),paramValues(ind.m2_LA));
+
+%onset_LV: range set to 1-2 instead of -0.5 to 0.5 --> take onset_LV-1.5
+paramValues(ind.onset_LV) = paramValues(ind.onset_LV) - 1.5;
+%onset LA: adapted after onset LV to be close enough
+paramValues(ind.onset_LA) = 1 + paramValues(ind.onset_LV) - paramValues(ind.onset_LA);
+
+%% Set values 
+%Params
+Cpvc = paramValues(strcmp('Cpvc',paramNames));
+Rpu = paramValues(strcmp('Rpu',paramNames));
+Rpv = paramValues(strcmp('Rpv',paramNames));
+Lpv  = paramValues(strcmp('Lpv',paramNames));
+Rtot  = paramValues(strcmp('Rtot',paramNames));
+Ctot  = paramValues(strcmp('Ctot',paramNames));
+ElCo  = paramValues(strcmp('ElCo',paramNames));
+Caa  = paramValues(strcmp('Caa',paramNames));
+Emax_LA  = paramValues(strcmp('Emax_LA',paramNames));
+Emax_LV  = paramValues(strcmp('Emax_LV',paramNames));
+Emin_LA  = paramValues(strcmp('Emin_LA',paramNames));
+Emin_LV  = paramValues(strcmp('Emin_LV',paramNames));
+Lao  = paramValues(strcmp('Lao',paramNames));
+Lav  = paramValues(strcmp('Lav',paramNames));
+Lmv  = paramValues(strcmp('Lmv',paramNames));
+Ppu  = paramValues(strcmp('Ppu',paramNames));
+Rao  = paramValues(strcmp('Rao',paramNames));
+Rmv  = paramValues(strcmp('Rmv',paramNames));
+k_diast_LA  = paramValues(strcmp('k_diast_LA',paramNames));
+k_diast_LV  = paramValues(strcmp('k_diast_LV',paramNames));
+k_syst_LA  = paramValues(strcmp('k_syst_LA',paramNames));
+k_syst_LV  = paramValues(strcmp('k_syst_LV',paramNames));
+m1_LA  = paramValues(strcmp('m1_LA',paramNames));
+m1_LV  = paramValues(strcmp('m1_LV',paramNames));
+m2_LA  = paramValues(strcmp('m2_LA',paramNames));
+m2_LV  = paramValues(strcmp('m2_LV',paramNames));
+onset_LA  = paramValues(strcmp('onset_LA',paramNames));
+onset_LV  = paramValues(strcmp('onset_LV',paramNames));
+% V0_LA  = paramValues(strcmp('V0_LA',paramNames));
+% V0_LV = paramValues(strcmp('V0_LV',paramNames));
+
+%Constants
+V0_LA  = constants(strcmp('V0_LA',constantsNames));
+V0_LV = constants(strcmp('V0_LV',constantsNames));
+tdiast  = constants(strcmp('tdiast',constantsNames));
+Ks_LA = constants(strcmp('Ks_LA',constantsNames));
+Ks_LV = constants(strcmp('Ks_LV',constantsNames));
+RLAvisc = constants(strcmp('RLAvisc',constantsNames));
+RLVvisc = constants(strcmp('RLVvisc',constantsNames));
+Raa = constants(strcmp('Raa',constantsNames));
+Rpc = constants(strcmp('Rpc',constantsNames));
+Rpvc = constants(strcmp('Rpvc',constantsNames));
+rho_blood = constants(strcmp('rho_blood',constantsNames));
+norm_factor_LA = constants(strcmp('norm_factor_LA',constantsNames));
+norm_factor_LV= constants(strcmp('norm_factor_LV',constantsNames));
+
+
+
+Cpc = Ctot-Caa;
+Rpr = Rtot-Rao;
+
+%% From data:
+Qpv = data.PV(1,2);
+Qmv = 0;
+Qav = max(data.AV(1,2),0);
+Qaa = max(data.AC(1,2),0);
+Paa = data.DBP - Raa*(Qav - Qaa); %P_aortic= Raa*(Qav - Qaa)  + Paa
+Vlv = data.EDV;
+if isnan(data.LaESV(2))
+    %disp('No LA ESV value in data - setting to 65 in initial conditions calculation.')
+    Vla = 65*2; %Mean laesv: 67.35, median 62, min 29, max 163. Setting missing value --> 65.
+else
+    Vla = data.LaESV(2)*2; %OBS: Simple estimation
+end
+
+mv_open = 0;
+if Qav > 0
+    av_open = 1;
+else
+    av_open = 0;
+end
+
+%% Derived based on data-vars
+qLA = Qpv - Qmv;
+qLV = Qmv - Qav;
+Qcaa = Qav - Qaa;
+dPaa = Qcaa/Caa;
+
+%% The rest
+% By assuming values to Qin/Qpvc/dPpvc and to Qpr/Qpc/dPpc, the rest of the initial conditions can be set from that and from data 
+
+% Qpvc = dPpvc*Cpvc;
+% Qin = Qpv + Qpvc;
+Qin = 1.05*Qpv; % assumption
+Qpvc = Qin - Qpv;
+dPpvc = Qpvc/Cpvc;
+
+% Qpc = dPpc*Cpc;
+% Qpr = Qaa - Qpc;
+Qpr = Qaa*0.95; % assumption
+Qpc = Qaa - Qpr;
+dPpc = Qpc/Cpc;
+
+% From the assumptions we can now get:
+Ppc = Qpr*Rpr - Rpc*Qpc;
+Ppvc = Ppu - Rpu*Qin - Rpvc*Qpvc;
+%dQaa = (Paa + Raa*Qcaa - Rao*Qaa - Rpc*Qpc - Ppc)/Lao; %set below
+%dQpv = (Ppvc + Rpvc*Qpvc - Rpv*Qpv - P_LA)/Lpv; % set below
+
+%%
+Ts_LA = k_syst_LA*T;
+Td_LA = k_diast_LA*T;
+ula = T - onset_LA*T;
+
+Ts_LV = k_syst_LV*T;
+Td_LV = k_diast_LV*T;
+ulv = T - onset_LV*T;
+
+if ulv < T
+    nLV = 0;
+else
+    nLV = 1;
+end
+% nLV = am_stepfun(ulv,T,1,2*T,2);
+tlv = ulv - nLV*T;
+g1_LV = (tlv/Ts_LV)^m1_LV;
+g2_LV = (tlv/Td_LV)^m2_LV;
+Elv = (1/norm_factor_LV)*(Emax_LV-Emin_LV)*(g1_LV/(1+ g1_LV)) *(1./(1 + g2_LV)) + Emin_LV;
+
+if ula < T
+    nLA = 0;
+else
+    nLA = 1;
+end
+% nLA= am_stepfun(ula,T,1,2*T,2);
+tla = ula - nLA*T;
+g1_LA = (tla/Ts_LA)^m1_LA;
+g2_LA = (tla/Td_LA)^m2_LA;
+Ela = (1/norm_factor_LA)*(Emax_LA-Emin_LA)*(g1_LA/(1+ g1_LA)) *(1/(1 + g2_LA)) + Emin_LA;
+
+P_LA = Ela*(Vla - V0_LA)*(1-Ks_LA*qLA);
+P_LV = Elv*(Vlv - V0_LV)*(1-Ks_LV*qLV);
+
+Vf =0.00001;
+Ron = 0.00001; %1.0000e-05
+Goff = 1e-08;
+Pvalve = Vf*(1-Ron*Goff);
+
+P_Dmv = mv_open*(Qmv*Ron + Pvalve)  + (1-mv_open)*(Qmv*(1/Goff));
+Rav = Qav * rho_blood/(2*ElCo^2)* (0.06/133.322);
+P_Dav = av_open*(Qav*Ron + Pvalve)  + (1-av_open)*(Qav*(1/Goff));
+Qpc_comp = (Qaa*Rpr - Ppc)/(Rpr+Rpc);
+
+
+Qpr_comp = (Ppc + Rpc*dPpc*Cpc)/Rpr;
+Qpvc_comp = (Ppu-Rpu*Qpv - Ppvc)/(Rpu+Rpvc);
+Qin_comp = (Ppu-Rpvc*dPpvc*Cpvc - Ppvc)/Rpu;
+
+% Set derivatives at t=0
+dPpvc_comp = (Ppu - Rpu*Qpv - Ppvc)/(Cpvc*(Rpu + Rpvc)); % Ppvc
+dQpv = (Ppvc + Rpvc*Qpvc - Rpv*Qpv - P_LA)/Lpv; %Qpv
+dVla = qLA;%Qpv - Qmv; %Vla
+dQmv = (P_LA - (RLAvisc+Rmv)*Qmv - P_Dmv - P_LV)/Lmv;%Qmv
+dVlv = qLV;%Qmv-Qav ; % Vlv
+dQav = (P_LV - (RLVvisc+Rav)*Qav - P_Dav - Raa*Qcaa - Paa)/Lav; %Qav
+% dPaa = (Qav-Qaa)/Caa; %Paa 
+dQaa = (Paa + Raa*Qcaa - Rao*Qaa - Rpc*Qpc - Ppc)/Lao; %Qaa
+dPpc_comp = (Qaa*Rpr - Ppc)/(Cpc*(Rpr+Rpc));
+
+%% Sum up
+dICs = [dPpvc,dQpv,dVla,dQmv,dVlv,dQav,dPaa,dQaa,dPpc,0,0];
+ICs = [Ppvc,Qpv,Vla,Qmv,Vlv,Qav,Paa,Qaa,Ppc,mv_open,av_open];
+
+if sum(isnan(ICs)) > 0
+    disp('!!! Initial conditions contains NaN values. Check the data. !!!')
+end
+
+%% Check that all conditions are fullfilled
+values = [Qpr,Qpc,dPpvc,dPpc,Qpvc,Qin]';
+compValues = [Qpr_comp,Qpc_comp,dPpvc_comp,dPpc_comp,Qpvc_comp,Qin_comp]';
+compareTable = table(values, compValues,(values-compValues)./values);%diff = 0
+
+kcl1 = Qin - Qpvc-Qpv;
+kcl2 = Qpv - qLA - Qmv;
+kcl3 = Qmv - qLV - Qav;
+kcl4 = Qav - Qcaa - Qaa;
+kcl5 = Qaa - Qpc - Qpr;
+kvl1 = Ppu-Rpu*Qin - Rpvc*Qpvc - Ppvc;
+kvl2 = Ppvc + Rpvc*Qpvc - Lpv*dQpv - Rpv*Qpv - P_LA;
+kvl3 = P_LA - RLAvisc*Qmv - P_Dmv - Lmv*dQmv - Rmv*Qmv - P_LV;
+kvl4 = P_LV - RLVvisc*Qav - P_Dav - Lav*dQav - Rav*Qav - Raa*Qcaa - Paa;
+kvl5 = Paa + Raa*Qcaa - Rao*Qaa - Lao*dQaa - Rpc*Qpc - Ppc;
+kvl6 = Ppc + Rpc*Qpc - Qpr*Rpr;
+kcl_c1 = Qin - dPpvc*Cpvc - Qpv;
+kcl_c2 = Qav - dPaa*Caa - Qaa;
+kcl_c3 = Qaa - dPpc*Cpc - Qpr;
+
+lawTable = table(kcl1,kcl2,kcl3,kcl4,kcl5,kvl1,kvl2,kvl3,kvl4,kvl5,kvl6,kcl_c1,kcl_c2,kcl_c3);
+
+if nargin > 6
+    simVScalc = table(simulation.x0,simulation.x(1,:)',ICs',ICs'-simulation.x(1,:)')
+end
+
+end
\ No newline at end of file
diff --git a/Simulation/loadData_HEALTH.m b/Simulation/loadData_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..7f5ab8fe1c5eead064513389286e457f69657275
--- /dev/null
+++ b/Simulation/loadData_HEALTH.m
@@ -0,0 +1,11 @@
+function [data,extradata,paramdata] = loadData_HEALTH(patientNum)
+
+inputpathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+inputpath = [inputpathbase{1},filesep 'cardiovascularavatar_T2D_HT' filesep 'Data'];
+try
+    load(fullfile(inputpath,['inputdata_avatarmodel_P',patientNum,'.mat']),'data','extradata','paramdata')
+catch
+    load(fullfile(inputpath,['inputdata_avatarmodel_',patientNum,'.mat']),'data','extradata','paramdata')
+end
+
+end
diff --git a/Simulation/loadParamBounds_HEALTH.m b/Simulation/loadParamBounds_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..8883303d7601fd88b2f5116c73b755f84b9eba95
--- /dev/null
+++ b/Simulation/loadParamBounds_HEALTH.m
@@ -0,0 +1,72 @@
+function [lb,ub] = loadParamBounds_HEALTH(ind,paramUncertainty)
+%difference from casas et al: 1e-3-1 instead of -0.5 - 0.5
+%(convertion: onset_LV = (onset_LV_old*T + T)/T
+%onset_LV: 1:2 instead of -0.5:0.5 --->take -1.5 when simulating
+%onset LV: reduced the interval -> -0.1 - 0.1 (1.4-1.6) instead of 1-2
+%onset LA: adapted based on LV before simulation: onsetLA = 1 + onsetLV - onsetLA
+% -> new bounds: from 0.425:1 to 0.12:0.25
+% See specific table in the manuscript.
+
+% Litterature values
+littnames = {'Rtot' 'Ctot' 'ElCo' 'Caa' 'Emax_LA' 'Emax_LV' 'Emin_LA' 'Emin_LV' 'Lao' 'Lav' 'Lmv' 'Ppu' 'Rao' 'Rmv' 'k_diast_LA' 'k_diast_LV' 'k_syst_LA' 'k_syst_LV' 'm1_LA' 'm1_LV' 'm2_LA' 'm2_LV' 'onset_LA' 'onset_LV','V0_LA','V0_LV'};
+littVals = [0.94,1.48,4.7945,0.1, 0.170,3,0.080,0.080,0.00050,0.0004,0.00020,7.40,0.040,0.0037510,0.18,0.45200,0.110,0.2690,1.320,1.32,13.1,27.4,0.15,0.001]; %, 3, 10
+
+lb = zeros(size(littVals));
+ub = zeros(size(littVals));
+ub([1,13,14]) = littVals([1,13,14]).*5; %resistances (casas et al 2)  %factor3 was slightly too low ub for Rao, so increased it
+lb([1,13,14]) = littVals([1,13,14])./5;%factor 3 too low for rmv -> broadened the lower bound too
+ub(9:11) = littVals(9:11).*6; % inertance (casas et al 5)
+lb(9:11) = littVals(9:11)./6;
+ub([2,4]) = littVals([2,4]).*7; % compliance (casas et al 6)
+lb([2,4]) = littVals([2,4])./7;
+
+ub(5:8) = littVals(5:8).*3; %Emax Emin LA & LV (casas et al 2) (Emax_LV set from data)
+lb([6,8]) = littVals([6,8])./3; %Emax and Emin LV lb same as before (casas et al 2) (but Emax_LV set from data)
+lb([5,7]) = littVals([5,7])./6; %Emax and Emin LA lb lowered to allow for no LA contraction in diseased patients
+
+ub(15:16) = littVals(15:16).*3; % kdiast LA & LV (casas et al 2)
+lb(15:16) = littVals(15:16)./3;
+ub(16) = 0.9; % kdiast LV ub set to 0.9 (was unneccesarily wide)
+ub(17:18) = littVals(17:18).*5; % ksyst LA & LV (casas et al 2). 3 before
+lb(17:18) = littVals(17:18)./5; %
+
+ub(19:22) = littVals(19:22).*3; % m1 and m2 LA & LV (casas et al 2)
+lb(19:22) = littVals(19:22)./3; % 
+
+ub(12) = littVals(12).*3; % Ppu prev: 12
+lb(12) = littVals(12)./3; % Ppu prev: 6
+
+ub(23:24) = [0.25,1.6]; % onset La & Lv, set so that they are physiologically reasonable close
+lb(23:24) = [0.12,1.4]; % onset La & Lv
+
+% Parameters for pulmonary veins % casas et al: kept constant since no data in pulmonary veins
+pvconstants = [4,0.01,0.002,0.00050];%{'Cpvc','Rpu','Rpv','Lpv'}
+pvlb  = pvconstants./[7,5,5,6]; %c,r,r,l 
+pvub  = pvconstants.*[7,5,5,6]; %c,r,r,l
+lb = [pvlb,lb]; 
+ub = [pvub,ub];
+
+% Caa, Aao, EOA_ao, Emax_LV, Ctot and Rtot are calculated from data and 
+% get their bounds from there, but still above 0 for the lower bound  
+if nargin >1 && ~isempty(paramUncertainty)
+    multfactor = 0.75; %+-75% of the data value
+    lb(ind.Caa)= max(0.01,paramUncertainty.Caa-paramUncertainty.Caa*multfactor);
+    ub(ind.Caa)= paramUncertainty.Caa+paramUncertainty.Caa*multfactor;
+
+    lb(ind.ElCo)=max(0.1,paramUncertainty.ElCo-paramUncertainty.ElCo*multfactor);
+    ub(ind.ElCo)=paramUncertainty.ElCo+paramUncertainty.ElCo*multfactor;
+    
+    lb(ind.Emax_LV)=max(0.1,paramUncertainty.Emax_LV-paramUncertainty.Emax_LV*multfactor);
+    ub(ind.Emax_LV)=paramUncertainty.Emax_LV+paramUncertainty.Emax_LV*multfactor;
+    
+    lb(ind.Ctot)=max(0.1,paramUncertainty.Ctot-paramUncertainty.Ctot*multfactor);
+    ub(ind.Ctot)=paramUncertainty.Ctot+paramUncertainty.Ctot*multfactor;
+    
+    lb(ind.Rtot)=max(0.1,paramUncertainty.Rtot-paramUncertainty.Rtot*multfactor);
+    ub(ind.Rtot)=paramUncertainty.Rtot+paramUncertainty.Rtot*multfactor;
+end
+
+%make sure no bounds are below or equal to 0
+lb(lb<=0) = 1e-7;
+
+end
\ No newline at end of file
diff --git a/Simulation/loadParameters_HEALTH.m b/Simulation/loadParameters_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..e004a04d582276c0b3037fd6dce75cd23e3e6bba
--- /dev/null
+++ b/Simulation/loadParameters_HEALTH.m
@@ -0,0 +1,160 @@
+function [paramValues,constants,paramNames,constantsNames,units,ind,dataParams] = loadParameters_HEALTH(paramdata)
+% Set parameter values
+
+%% Initial parameter values from literature
+%Density
+rho_blood=1.06; %g/ml
+
+%Pulmonary vessels (from Sun, also in Tann�)
+Ppu=7.4;
+Rpu=0.01;
+Rpvc=0.01;
+Cpvc=4;
+Lpv=0.0005;
+Rpv=0.002;
+
+%Varying elastance function
+m1_LA=1.32;    %()         Mynard et al.
+m2_LA=13.1;    %()         Mynard et al.
+Emin_LA=0.08;  %(mmHg/mL)  Mynard et al.
+Emax_LA=0.17;  %(mmHg/mL)  Mynard et al.
+V0_LA=3;       %(mL)       Mynard et al.
+Ks_LA=10e-9;   %(s/mL)     Mynard et al.
+onset_LA=0.15; %()         modified value - 0.85  Mynard et al.
+k_syst_LA=0.110;%(s) Systolic time constant (Mynard et al.)
+k_diast_LA=0.180;%(s)Diastolic time constant (Mynard et al.)
+
+%Viscous resistance
+RLAvisc=0.0001;
+
+%Mitral valve parameters
+Rmv=3.751e-3;
+Lmv=0.0002;
+
+%Left ventricle parameters
+
+%Varying elastance function
+m1_LV=1.32;            %()         Mynard et al.
+m2_LV=27.4;            %()         Mynard et al.
+Emin_LV=0.08;          %(mmHg/mL)  Mynard et al.
+V0_LV=10;              %(mL)       Mynard et al.
+Ks_LV=4e-9;            %(s/mL)     Mynard et al.
+onset_LV=0.001+1.5;    %()Mynard et al.    %log10(0) = -inf --> set to 1e-3 (+1.5 for opt)
+k_syst_LV=0.269;
+k_diast_LV=0.452;
+
+%Calculate the normalizing factor (Mynard et al.)
+norm_factor_LV = calc_norm_factor(paramdata.T,k_syst_LV,k_diast_LV,m1_LV,m2_LV);
+norm_factor_LA= calc_norm_factor(paramdata.T,k_syst_LA,k_diast_LA,m1_LA,m2_LA);
+
+%Viscous resistance
+RLVvisc=0.0001;         %Sun et al.
+
+%Aortic valve parameters
+Lav=0.0004;             %mmHg*s^2/mL
+
+%Ascending aorta parameters
+Raa=0.01;
+Rao=0.04;
+Lao=5e-4;
+
+%Peripheral vessels parameters
+Rpc=0.01;
+
+%% Secondary parameters computed from patient data
+HR=60*1/paramdata.T;          %Heart rate (beats/min)
+PP=paramdata.SBP-paramdata.DBP;         %Peak pressure
+MAP=paramdata.DBP+(1/3+HR*0.0012)*(paramdata.SBP-paramdata.DBP); % Bel�ns calculation of MAP, takes HR in consideration azminia M, Trivedi A, Molnar J, Elbzour M, Guerrero M, Salem Y, Ahmed A, Khosla S, Lubell DL . Validation of a new formula for mean arterial pressure calculation: the new formula is superior to the standard formula. Catheter Cardiovasc Interv 2004; 63: 419�425.
+
+%% Calculate parameters on a subject-specific basis
+%Calcualted automatically based on the input measurements:
+B_av=rho_blood/(2*paramdata.ElCo^2);
+maxQav = max(paramdata.AV_Flow);
+deltaPconst = 0.06/133.322;% tagit bort 0.9 h�r.
+deltaP_av = B_av*(maxQav^2)*deltaPconst; %Pressure gradient accross the aortic valve
+k=0.9; %Constant to relate systolic blood pressure and end systolic blood pressure: Pes=k*Ps
+Emax_LV=k*(paramdata.SBP+deltaP_av)/(paramdata.ESV_seg-V0_LV); %Maximal elastance of the LV
+
+
+meanQav = mean(paramdata.AV_Flow);
+Ctot=meanQav/PP;  %Total compliance of the system
+
+Rtot=MAP/meanQav;     %Total resistance of the system
+
+
+%% Data-based parameters
+% Caa, Aao, EOA_ao, Emax_LV, Ctot and Rtot are calculated from data 
+dataParams.Emax_LV = Emax_LV;
+dataParams.Ctot = Ctot;
+dataParams.Rtot = Rtot;
+dataParams.ElCo = paramdata.ElCo;
+dataParams.Caa = paramdata.Caa;%pwv fr full aorta, volume fr ascao
+
+%% Set parameters to be optimized and constant parameter values
+paramNames = {'Cpvc' 'Rpu' 'Rpv' 'Lpv' 'Rtot' 'Ctot' 'ElCo' 'Caa' 'Emax_LA' 'Emax_LV' 'Emin_LA' 'Emin_LV' 'Lao' 'Lav'...
+    'Lmv' 'Ppu' 'Rao' 'Rmv' 'k_diast_LA' 'k_diast_LV' 'k_syst_LA'...
+    'k_syst_LV' 'm1_LA' 'm1_LV' 'm2_LA' 'm2_LV' 'onset_LA' 'onset_LV'};
+constantsNames = {'aaCorr' 'avCorr' 'mvCorr' 'tdiast' 'Ks_LA' 'Ks_LV'...
+    'V0_LA' 'V0_LV' 'RLAvisc' 'RLVvisc' 'Raa' 'Rpc' 'Rpvc' 'T' 'rho_blood' 'norm_factor_LA' 'norm_factor_LV'};
+constants = [0 0 0 paramdata.tdiast Ks_LA Ks_LV V0_LA V0_LV RLAvisc RLVvisc Raa Rpc Rpvc paramdata.T rho_blood norm_factor_LA norm_factor_LV];
+
+%R: 'mmHg*s/ml'
+%C:'ml/mmHg
+%L: 'mmHg*s^2/ml'
+units.param = {'ml/mmHg','mmHg*s/ml','mmHg*s/ml','mmHg*s^2/ml','mmHg*s/ml',...
+    'ml/mmHg','cm^2','ml/mmHg','ml/mmHg','ml/mmHg','ml/mmHg','ml/mmHg',...
+    'mmHg*s^2/ml','mmHg*s^2/ml','mmHg*s^2/ml','mmHg','mmHg*s/ml','mmHg*s/ml',...
+    '-','-','-','-','-','-','-','-','s','s'};
+units.constant = {'ml','ml','ml','s','s/ml','s/ml','ml','ml','mmHg*s/ml','mmHg*s/ml','mmHg*s/ml','mmHg*s/ml','s','g/ml','-','-'};
+
+Caalitterature=0.1;
+Emax_LVlitterature = 3;
+paramValues = [Cpvc Rpu Rpv Lpv Rtot Ctot paramdata.ElCo Caalitterature Emax_LA Emax_LVlitterature Emin_LA Emin_LV Lao Lav Lmv Ppu Rao Rmv k_diast_LA k_diast_LV k_syst_LA k_syst_LV m1_LA m1_LV m2_LA m2_LV onset_LA onset_LV];
+
+%% indices for easy access to model parameters, states and observables
+ind.MV = 4;
+ind.AV = 6;
+ind.AC = 8;
+ind.LV = 5;
+ind.PV = 2;
+ind.aaCorrVol = 19;
+ind.avCorrVol = 20;
+ind.mvCorrVol = 21;
+ind.pvCorrVol = 22;
+ind.Vla = 23;
+ind.aorticPressure = 1;
+ind.brachialPressure = 25;
+
+ind.k_syst_LV = strcmp(paramNames,'k_syst_LV');
+ind.k_diast_LV = strcmp(paramNames,'k_diast_LV');
+ind.m1_LV = strcmp(paramNames,'m1_LV');
+ind.m2_LV= strcmp(paramNames,'m2_LV');
+ind.k_syst_LA = strcmp(paramNames,'k_syst_LA');
+ind.k_diast_LA = strcmp(paramNames,'k_diast_LA');
+ind.m1_LA = strcmp(paramNames,'m1_LA');
+ind.m2_LA = strcmp(paramNames,'m2_LA');
+
+ind.Emax_LA = strcmp(paramNames,'Emax_LA');
+ind.Emin_LA = strcmp(paramNames,'Emin_LA');
+ind.Emax_LV = strcmp(paramNames,'Emax_LV');
+ind.Emin_LV = strcmp(paramNames,'Emin_LV');
+
+ind.onset_LV = strcmp(paramNames,'onset_LV');
+ind.onset_LA = strcmp(paramNames,'onset_LA');
+
+ind.Caa = strcmp(paramNames,'Caa');
+ind.ElCo = strcmp(paramNames,'ElCo');
+ind.Ctot = strcmp(paramNames,'Ctot');
+ind.Rtot = strcmp(paramNames,'Rtot');
+
+ind.avCorr = strcmp(constantsNames,'avCorr');
+ind.mvCorr = strcmp(constantsNames,'mvCorr');
+ind.aaCorr = strcmp(constantsNames,'aaCorr');
+
+ind.tdiast = paramdata.indtdiast;
+
+ind.T = strcmp(constantsNames,'T');
+
+
+
+end
\ No newline at end of file
diff --git a/Simulation/setup_simulations_HEALTH.m b/Simulation/setup_simulations_HEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..5c2be7898c7ce1fdba08a13939deeb96b20d75d9
--- /dev/null
+++ b/Simulation/setup_simulations_HEALTH.m
@@ -0,0 +1,146 @@
+function [patNums,data,extradata,paramValues,constants,...
+    paramNames,constantsNames,ynames,xnames,simulationoptions,inds,...
+    origParamvalues,units,loadedcosts,meanParams,medianParams,paramuncertainty] =setup_simulations_HEALTH(patNumsOrig,resultsFolder,doOptimization)
+
+loadMCMC=1;
+dataFolder = 'Data';
+if ~doOptimization 
+    Setup('',0)
+end
+%names in the model
+ynames = {'P_Aortic','Pperipheral','pressGrad MV','P Dmv','mv open','P Dav','av open','pressgrad AV','Ela','Elv','Qcaa','Qpc','P pulmvein','Qpvc','qLA','qLV','pLA','pLV','aaCorr','avCorr','mvCorr','pvCorr','Vla','Vlv','P_Brachial'};
+xnames = {'Ppvc','Qpv','Vla','Qmv','Vlv','Qav','Paa','Qaa','Ppc','mv_open','av_open'};
+
+%% select patients (if not specified)
+if isempty(patNumsOrig)
+    folders = dir([dataFolder '/*_P*']);
+    names = {folders.name};
+    patNumsOrig = cell(1,length(names));
+    for n = 1:length(names)
+        patNumsOrig{n} = names{n}(end-5:end-4);
+        if strcmp(patNumsOrig{n}(1),'P')
+            patNumsOrig{n} = patNumsOrig{n}(2);
+        end
+    end
+end
+numPatients = length(patNumsOrig);
+
+%% Load data and parameters
+origParamvalues= cell(1,length(patNumsOrig));
+data = cell(1,length(patNumsOrig));
+extradata = cell(1,length(patNumsOrig));
+paramdata = cell(1,length(patNumsOrig));
+nparams = 28;
+nconstants = 17;
+constants = nan(nconstants,length(patNumsOrig));
+paramValues = nan(nparams,length(patNumsOrig));
+meanParams = nan(nparams,length(patNumsOrig));
+medianParams = nan(nparams,length(patNumsOrig));
+
+loadedcosts =zeros(length(patNumsOrig),1);
+
+patNumsNoSim = [];
+patNumsNoSimNums = [];
+patNums = patNumsOrig;
+inds = cell(length(patNumsOrig),1);
+for p = 1:length(patNumsOrig)
+    patientNum = patNums{p};
+
+    % Format subject number if needed
+    if strcmp(patientNum(end),'_')
+        patNums{p} = patientNum(1);
+    end
+    
+    % Load data
+    [data{p},extradata{p},paramdata{p}] = loadData_HEALTH(patientNum);
+    [origParamvalues{p},constants(:,p),paramNames,constantsNames,units,inds{p},data{p}.params] = loadParameters_HEALTH(paramdata{p});
+
+    % Load ESS opt parameters
+    if doOptimization || ~loadMCMC
+        % find the latest patientfolder with optimizations
+        loadresultsfolder = fullfile(resultsFolder, ['P' patientNum '_*']);
+        folders = dir(loadresultsfolder);
+        if isempty(folders)
+            disp(['SETUP: OBS couldnt load opt parameters for p' patientNum, ' (no prev folder), setting to litterature+data values (prev folder: ' loadresultsfolder ')'])
+            patNumsNoSim = [patNumsNoSim,p];
+            patNumsNoSimNums = [patNumsNoSimNums,{patientNum}];
+            paramValues(:,p) = origParamvalues{p};
+            loadedcosts(p) = 1e10;
+        else
+            [~,latestfolderInd] = max([folders.datenum]);
+            foldernames = {folders.name};
+            folderpaths = {folders.folder};
+            
+            folderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd});
+            if isempty(dir([folderName,filesep, 'opt-*'])) && doOptimization && length(foldernames) > 1%new empty folder created, so take the next latest one if it exists
+                folderName = fullfile(folderpaths{latestfolderInd},foldernames{latestfolderInd-1});
+            end
+            
+            if doOptimization
+                loadsummaryfile = 0;
+            else
+                loadsummaryfile = 1;
+            end
+            loadmean=1;
+            [param,loadedcosts(p),~,loadedconstants,meanparam,medianparam] = findBestParams(folderName,loadsummaryfile,length(paramNames),loadmean);
+            
+            if isnan(param)
+                patNumsNoSim = [patNumsNoSim,p];
+                patNumsNoSimNums = [patNumsNoSimNums,{patientNum}];
+                disp(['SETUP: OBS couldnt load opt parameters for p' patientNum ' (empty folder), setting to litterature+data values'])
+                paramValues(:,p) = origParamvalues{p};
+            else
+                paramValues(:,p) = param;
+                meanParams(:,p) = meanparam;
+                medianParams(:,p) = medianparam;
+            end
+        end
+         fprintf('SETUP: Loaded parameter values with cost %0.2f for p%s\n',loadedcosts(p),patientNum)
+    end
+end
+
+if loadMCMC && ~doOptimization
+    fprintf('SETUP: Loading MCMC and ESS parameters...\n')
+    [patNums,paramValues,loadedcosts,meanParams,paramuncertainty.allokParams,...
+    paramuncertainty.allokCosts,paramuncertainty.minValuesparams,...
+    paramuncertainty.maxValuesparams,paramuncertainty.numincluded,...
+    data,inds,constants,medianParams] = findAllParams(resultsFolder,patNumsOrig,patNums,paramNames,data,inds,constants);
+    fprintf('SETUP: Loaded paramvalues from both MCMC and ESS optimizations for %d subjects\n',length(patNums))
+else
+    paramuncertainty = NaN;
+end
+
+
+%% Simulation settings
+% sensi: sensitivity order - 0 = no calculation of sensitivities (default)
+% maxsteps: maximum number of integration steps
+simulationoptions = amioption('sensi',0,'maxsteps',1e4);
+% set simulation tolerances
+simulationoptions.atol = 1e-16;
+simulationoptions.rtol = 1e-8;
+
+% Calculate initial conditions for each subject based on the parameter values and data
+ICs = zeros(length(patNums),length(xnames));
+for p = 1:length(patNums)
+    [ICs(p,:),~] = iccalcs(paramValues(:,p),constants(:,p),paramNames,constantsNames,data{p},inds{p});
+    data{p}.IC = ICs(p,:)';
+end
+
+%% Format the function output
+if numPatients == 1 && doOptimization
+    patNums = patNums{1};
+    data = data{1};
+    extradata= extradata{1};
+    inds= inds{1};
+    origParamvalues = origParamvalues{1};
+else
+    %exclude patients for whom parameters could not be loaded with findBestParams
+    patNums(patNumsNoSim)= [];
+    data(patNumsNoSim)= [];
+    extradata(patNumsNoSim)= [];
+    constants(:,patNumsNoSim)= [];
+    paramValues(:,patNumsNoSim) = [];
+    origParamvalues(patNumsNoSim) = [];
+end
+
+end
\ No newline at end of file
diff --git a/Simulation/simulatePredictionUncertainty.m b/Simulation/simulatePredictionUncertainty.m
new file mode 100644
index 0000000000000000000000000000000000000000..2c09e4d66b4df58de8fe488e208dfee27375e468
--- /dev/null
+++ b/Simulation/simulatePredictionUncertainty.m
@@ -0,0 +1,13 @@
+function [minmaxSim,minmaxSim2] = simulatePredictionUncertainty(patNums,allParams,bestparamsESS,allParams2,bestparamsESS2,constants,inds,data,options)
+w = warning('off','all');
+% Simulate using all minmax parameter sets
+saveResults=0;
+loadResults=0;
+if isempty(allParams)
+    minmaxSim = NaN;
+else
+    [minmaxSim] = findSimulationUncertainty(patNums,allParams,constants,inds,data,options,bestparamsESS,saveResults,loadResults);
+end
+[minmaxSim2] = findSimulationUncertainty(patNums,allParams2,constants,inds,data,options,bestparamsESS2,saveResults,loadResults);
+w = warning('on','all');
+end
diff --git a/Simulation/simulate_avatarHEALTH.m b/Simulation/simulate_avatarHEALTH.m
new file mode 100644
index 0000000000000000000000000000000000000000..fc8c8f29e867620a4fa06474ef84994d232be07f
--- /dev/null
+++ b/Simulation/simulate_avatarHEALTH.m
@@ -0,0 +1,54 @@
+function [simAmi,sol] = simulate_avatarHEALTH(theta,constants,options,numHeartBeats,ind,simtime)
+% Do a simulation of the avatar model. First, set parameter values, then
+% simulate a number of heartbeats one at a time.
+%step = 0.001; %good resolution when plotting simulation
+%step = T/39; %comparing to data (since there are 40 timeframes)
+%ind is a struct containing indexes for the parameters
+%options contains simulation options
+T = constants(ind.T);
+
+% Calculate normalizing factors for elastance function based on the parameters
+norm_factor_LV = calc_norm_factor(T,theta(ind.k_syst_LV),theta(ind.k_diast_LV),theta(ind.m1_LV),theta(ind.m2_LV));
+norm_factor_LA= calc_norm_factor(T,theta(ind.k_syst_LA),theta(ind.k_diast_LA),theta(ind.m1_LA),theta(ind.m2_LA));
+constants(end) = norm_factor_LV;
+constants(end-1) = norm_factor_LA;
+
+%onset_LV: range set to 1-2 instead of -0.5 to 0.5 --> take onset_LV-1.5
+theta(ind.onset_LV) = theta(ind.onset_LV) - 1.5;
+%onset LA: adapted after onset LV to be close enough
+theta(ind.onset_LA) = 1 + theta(ind.onset_LV) - theta(ind.onset_LA);
+
+% First simulation of one heartbeat - to get the sizes of x and y
+simtime = simtime+T;
+options.tstart = T;
+sol = simulate_avatar_HEALTH_fast(simtime,theta, constants, [], options);
+
+options.x0 = sol.x(end,:)';
+simlen = length(sol.t)-1;
+simAmi.x = zeros(simlen*numHeartBeats,size(sol.x,2));
+simAmi.y = zeros(simlen*numHeartBeats,size(sol.y,2));
+simAmi.t = zeros(simlen*numHeartBeats,size(sol.t,2));
+
+simAmi.x(1:length(sol.t),:) = sol.x;
+simAmi.y(1:length(sol.t),:) = sol.y;
+simAmi.t(1:length(sol.t)) = sol.t;
+
+% The rest of the simulations
+for i = 1:numHeartBeats-1
+    sol = simulate_avatar_HEALTH_fast(simtime,theta, constants, [], options);
+
+    %start next sim with end values from this sim
+    options.x0 = sol.x(end,:)';
+    
+    %save this sim together with the rest
+    simAmi.x(simlen*i+2:simlen*(i+1)+1,:) = sol.x(2:end,:);
+    simAmi.y(simlen*i+2:simlen*(i+1)+1,:) = sol.y(2:end,:);
+    simAmi.t(simlen*i+2:simlen*(i+1)+1)   = sol.t(2:end)+T*i;
+end
+
+ % To compare with data we use the last heartbeat when a "steady state" is established.
+ % We need to round the time to 3 digits, and start at t=0 to be able to
+ % compare with data.
+sol.t = round(sol.t-T,3);
+
+end
\ No newline at end of file
diff --git a/Simulation/simulate_avatarHEALTH_short.m b/Simulation/simulate_avatarHEALTH_short.m
new file mode 100644
index 0000000000000000000000000000000000000000..61f3d6a813dd70f7b4949a726f9cd1983d06d5a6
--- /dev/null
+++ b/Simulation/simulate_avatarHEALTH_short.m
@@ -0,0 +1,42 @@
+function [sol] = simulate_avatarHEALTH_short(theta,constants,options,numHeartBeats,ind,simtime)
+% Do a simulation of the avatar model. First, set parameter values, then
+% simulate a number of heartbeats one at a time.
+%step = 0.001; %good resolution when plotting simulation
+%step = T/39; %comparing to data (since there are 40 timeframes)
+%ind is a struct containing indexes for the parameters
+%options contains simulation options
+T = constants(ind.T);
+
+% Calculate normalizing factors for elastance function based on the parameters
+constants(end) = calc_norm_factor(T,theta(ind.k_syst_LV),theta(ind.k_diast_LV),theta(ind.m1_LV),theta(ind.m2_LV));
+constants(end-1) = calc_norm_factor(T,theta(ind.k_syst_LA),theta(ind.k_diast_LA),theta(ind.m1_LA),theta(ind.m2_LA));
+
+%onset_LV: range set to 1-2 instead of -0.5 to 0.5 --> take onset_LV-1.5
+theta(ind.onset_LV) = theta(ind.onset_LV) - 1.5;
+%onset LA: adapted after onset LV to be close enough
+theta(ind.onset_LA) = 1 + theta(ind.onset_LV) - theta(ind.onset_LA);
+
+simtime = simtime+T;
+options.tstart = T;
+
+sol.x = NaN;
+for i = 1:numHeartBeats
+    solbefore = sol.x;
+    sol = simulate_avatar_HEALTH_fast(simtime,theta, constants, [], options);
+    
+    %if reaches steady state earlier, there is no need to do extra
+    %simulations
+    if abs(sum(solbefore(:) - sol.x(:))) < 1
+        break
+    end
+    %start next sim with end values from this sim
+    options.x0 = sol.x(end,:)';
+end
+
+ % To compare with data we use the last heartbeat when a "steady state" is established.
+ % We need to round the time to 3 digits, and start at t=0 to be able to
+ % compare with data.
+sol.t = round(sol.t-T,3);
+
+
+end
\ No newline at end of file
diff --git a/Tools/categoricaltestTable.m b/Tools/categoricaltestTable.m
new file mode 100644
index 0000000000000000000000000000000000000000..26b55fc626693a32fb974aa92e0c3f1eb8c432fc
--- /dev/null
+++ b/Tools/categoricaltestTable.m
@@ -0,0 +1,75 @@
+function [groupTable,statisticsTable,meanTable,stattestTable] = categoricaltestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable,indexes,stattestTable)
+
+% calculate categorical test
+for t = 1:length(tablenames)
+    bothgroups = indexes{comparison.compinds(1)} | indexes{comparison.compinds(2)};
+    totalGroupInd = indexes{comparison.compinds(1)}(bothgroups);
+    totalVariables = data.(datanames{t})(bothgroups);
+    if sum(totalVariables) == length(totalVariables) %groups are the same for this variable. sum(totalVariables) == 0 || 
+        statisticsTable.reject{comparison.statind}(t)= NaN;
+        meanTable.(tablenames{t})(comparison.pind)= NaN;
+        statisticsTable.statistics{comparison.statind}{t} = NaN;
+        groupTable.(tablenames{t}){comparison.pind}  = NaN;
+        statisticsTable.pvalues{comparison.statind}(t) = NaN;
+        stattestTable.(tablenames{t}){comparison.pind} = ' - ';
+    else
+        %calculate expected values from chi2
+        [dochi2,chi2res.chi2,chi2res.p,chi2res.expected,chi2res.calculated] = chi2calc(totalGroupInd,totalVariables);
+        %use chi2 if possible (large enough groups), otherwise use fisher
+        if ~dochi2
+            %use fisher
+            [statisticsTable.reject{comparison.statind}(t),...
+                meanTable.(tablenames{t})(comparison.pind),...
+                statisticsTable.statistics{comparison.statind}{t}] = fishertest(chi2res.calculated);
+            stattestTable.(tablenames{t}){comparison.pind} = 'fisher';
+        else
+            %use chi2
+            statisticsTable.reject{comparison.statind}(t) = chi2res.p < 0.005;
+            meanTable.(tablenames{t})(comparison.pind) = chi2res.p;
+            statisticsTable.statistics{comparison.statind}{t} = chi2res;
+            stattestTable.(tablenames{t}){comparison.pind} = 'chi2';
+        end
+        statisticsTable.statistics{comparison.statind}{t}.chi2 = chi2res.chi2;
+        statisticsTable.statistics{comparison.statind}{t}.expected = chi2res.expected;
+        statisticsTable.statistics{comparison.statind}{t}.calculated = chi2res.calculated;
+        statisticsTable.statistics{comparison.statind}{t}.chi2pval = chi2res.p;
+        if meanTable.(tablenames{t})(comparison.pind) < 0.0001
+            groupTable.(tablenames{t}){comparison.pind}  = '<0.0001*';
+        elseif meanTable.(tablenames{t})(comparison.pind) <= 0.05
+            groupTable.(tablenames{t}){comparison.pind}  = sprintf('%0.4f*',meanTable.(tablenames{t})(comparison.pind));
+        else
+            groupTable.(tablenames{t}){comparison.pind}  = sprintf('%0.4f',meanTable.(tablenames{t})(comparison.pind));
+        end
+        statisticsTable.pvalues{comparison.statind}(t) = meanTable.(tablenames{t})(comparison.pind);
+    end
+
+end
+
+
+%%%%
+    function [dochi2,chi2calc,pcalc,expected,calculated] = chi2calc(rows,columns)
+        % gives the same results as:
+        %[chi2res.tbl, chi2res.chi2,chi2res.p,chi2res.labels] = crosstab(totalGroupInd,totalVariables);
+        tabletotal = length(rows);
+        expected(1,1) = (sum(~rows)*sum(~columns))/tabletotal;
+        expected(1,2) = (sum(~rows)*sum(columns))/tabletotal;
+        expected(2,1) = (sum(rows)*sum(~columns))/tabletotal;
+        expected(2,2) = (sum(rows)*sum(columns))/tabletotal;
+        
+        calculated(1,1) = sum(~rows & ~columns);
+        calculated(1,2) = sum(~rows & columns);
+        calculated(2,1) = sum(rows & ~columns);
+        calculated(2,2) = sum(rows & columns);
+        chi2calc = sum(sum(((calculated-expected).^2)./expected));
+        df = 1;%(r-1)*(c-1) = (2-1)*(2-1)
+        pcalc = 1-chi2cdf(chi2calc,df);
+        
+        %chi2 is ok if all expected values are >=1 and at least 50% >= 5
+        if sum(expected(:)>=5) >= 2 && sum(expected(:)>=1) == 4
+            dochi2 = 1;
+        else
+            dochi2 = 0;
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/Tools/createResultsTable.m b/Tools/createResultsTable.m
new file mode 100644
index 0000000000000000000000000000000000000000..adce7f161f7c163ca411098195e9b68b5c86c883
--- /dev/null
+++ b/Tools/createResultsTable.m
@@ -0,0 +1,13 @@
+function nicetable = createResultsTable(origintable, groups, comparisons,savefile,filename)
+
+grouprows = ismember(origintable.Group,groups);
+comprows = ismember(origintable.Group,comparisons);
+nicetable = rows2vars(origintable(grouprows | comprows,:));
+
+if savefile
+    writetable(nicetable,[filename,'.xlsx'])
+end
+
+end
+
+
diff --git a/Tools/fixUnderscore.m b/Tools/fixUnderscore.m
new file mode 100644
index 0000000000000000000000000000000000000000..afc6dbd5fb34f0fc738fdcdd82cf9391d788c226
--- /dev/null
+++ b/Tools/fixUnderscore.m
@@ -0,0 +1,26 @@
+function fixedStrings =  fixUnderscore(stringList)
+%takes a cell array with strings and finds any underscores in the strings
+%outputs the cell array fixedStrings with the same strings with the extra
+%underscores. Useful when creating texts to plot.
+
+fixedStrings = stringList;
+for s = 1:length(stringList)
+    if ismember('_',stringList{s})
+        ind = strfind(stringList{s},'_');
+        part1 = stringList{s}(1:ind(1)-1);
+        part2 = stringList{s}(ind(1):end);
+        part2 = join(split(part2(2:end),''),'_');
+        part2 = part2{1};
+        word = [part1 part2(1:end-1)];
+        doubleind = strfind(word,'___');
+        if ~isempty(doubleind)
+            word(doubleind) = [];
+            word(doubleind) = ' ';
+        end
+        fixedStrings{s} = word;
+    end
+end
+
+end
+
+
diff --git a/Tools/loadGroupIndexes.m b/Tools/loadGroupIndexes.m
new file mode 100644
index 0000000000000000000000000000000000000000..b6cee09760c59ee22bab5ef91ca9eae61573a527
--- /dev/null
+++ b/Tools/loadGroupIndexes.m
@@ -0,0 +1,45 @@
+function [groups] = loadGroupIndexes(usedPatNums)
+% load groups
+inputpathbase = split(pwd,'cardiovascularavatar_T2D_HT');
+datapath = [inputpathbase{1},'cardiovascularavatar_T2D_HT',filesep,'Data'];
+load(fullfile(datapath,'scapisdata_HEALTH.mat'),'SCAPISdata_HEALTH')
+
+usedPatNums=removeUnderscore(usedPatNums);
+
+%% sort and group on scapis home pressure and T2D data
+% healthIDs are anonymized IDs connected to the input data and optimized parameters for each subject.
+patinds = zeros(size(usedPatNums));
+usedPatNumsP = cell(size(usedPatNums));
+for p = 1:length(usedPatNums)
+    patientNum=removeUnderscore(usedPatNums(p));
+    patientNum = ['P' patientNum{1}];
+    usedPatNumsP{p} = patientNum;
+    patinds(p) = find(strcmp(SCAPISdata_HEALTH.healthIDs,patientNum));
+end
+patnumcheck = strcmp(SCAPISdata_HEALTH.healthIDs(patinds),usedPatNumsP');
+if sum(patnumcheck) ~= length(usedPatNums)
+    disp('OBS! check the group indexes')
+end
+
+groups.hypertensionHome = logical(SCAPISdata_HEALTH.HTgroup(patinds));
+groups.nothypertensionHome = ~groups.hypertensionHome;
+groups.T2D = SCAPISdata_HEALTH.T2Dgroup(patinds);
+groups.Control = ~groups.T2D;
+
+groups.hypertensionMR = logical(SCAPISdata_HEALTH.HTgroupMR(patinds));
+groups.nothypertensionMR = ~groups.hypertensionMR;
+
+% four groups but highBP defined as home bp (SBP >=135 or DBP>=85)
+groups.T2D_HT_home = groups.T2D & groups.hypertensionHome;
+groups.C_HT_home = groups.Control & groups.hypertensionHome;
+groups.T2D_NT_home = groups.T2D & groups.nothypertensionHome;
+groups.C_NT_home = groups.Control & groups.nothypertensionHome;
+
+% create indexes for the four groups 
+groups.fourgroupsHBP = cell(size(groups.T2D_HT_home));
+groups.fourgroupsHBP(groups.C_NT_home) = {'HBP C'};
+groups.fourgroupsHBP(groups.T2D_NT_home) = {'HBP T2D'};
+groups.fourgroupsHBP(groups.C_HT_home) = {'HBP HT'};
+groups.fourgroupsHBP(groups.T2D_HT_home) = {'HBP T2D & HT'};
+
+end
\ No newline at end of file
diff --git a/Tools/nonparametrictestTable.m b/Tools/nonparametrictestTable.m
new file mode 100644
index 0000000000000000000000000000000000000000..f55a302d45f3c2ac7ae68c2d33838880754c0f32
--- /dev/null
+++ b/Tools/nonparametrictestTable.m
@@ -0,0 +1,40 @@
+function [groupTable2,statisticsTable,meanTable,stattestTable] = nonparametrictestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,toTest,stattestTable)
+% calculate Wilcoxon rank sum test [p,h,stats] = ranksum(x,y)
+% for each variable in the tablenames list
+
+for i = 1:length(toTest)
+    t = toTest(i);
+    d1 = data.(datanames{t})(indexes{comparison.compinds(1)});
+    d2 = data.(datanames{t})(indexes{comparison.compinds(2)});
+    if sum(isnan(d1)) == length(d1) || sum(isnan(d2)) == length(d2) %if one of the groups is full of NaN values
+        meanTable.(tablenames{t})(comparison.pind) = NaN;
+        statisticsTable.reject{comparison.statind}(t) = NaN;
+        statisticsTable.statistics{comparison.statind}{t} = NaN;
+        groupTable2.(tablenames{t}){comparison.pind} = ' - ';
+        statisticsTable.pvalues{comparison.statind}(t) = NaN;
+        statisticsTable.rejectBonferroni{comparison.statind}(t) = NaN;
+        stattestTable.(tablenames{t}){comparison.pind} = ' - ';
+    else
+        d1 = d1(~isnan(d1));
+        d2 = d2(~isnan(d2));
+
+        % Wilcoxon rank sum test
+        [meanTable.(tablenames{t})(comparison.pind),...
+            statisticsTable.reject{comparison.statind}(t),...
+            statisticsTable.statistics{comparison.statind}{t}] = ...
+            ranksum(d1,d2,'alpha',0.05);
+        if meanTable.(tablenames{t})(comparison.pind) < 0.0001 %0.0001
+            groupTable2.(tablenames{t}){comparison.pind}  = '<0.0001*';
+        elseif meanTable.(tablenames{t})(comparison.pind) <= 0.05
+            groupTable2.(tablenames{t}){comparison.pind}  = sprintf('%0.4f*',meanTable.(tablenames{t})(comparison.pind));%0.3f *
+        else
+            groupTable2.(tablenames{t}){comparison.pind}  = sprintf('%0.4f',meanTable.(tablenames{t})(comparison.pind));
+        end
+        statisticsTable.pvalues{comparison.statind}(t) = meanTable.(tablenames{t})(comparison.pind);
+        
+        stattestTable.(tablenames{t}){comparison.pind} = 'Wilcoxon rank sum';
+    end
+end
+
+
+end
diff --git a/Tools/removeUnderscore.m b/Tools/removeUnderscore.m
new file mode 100644
index 0000000000000000000000000000000000000000..a697353a71d19b6ccab2fb9e517515c2d020e6ca
--- /dev/null
+++ b/Tools/removeUnderscore.m
@@ -0,0 +1,20 @@
+function fixedStrings =  removeUnderscore(stringList,replacement)
+%takes a cell array with strings and removes any underscores in the strings
+%outputs the cell array fixedStrings with the same strings without the
+%underscores.
+
+fixedStrings = stringList;
+for s = 1:length(stringList)
+    if ismember('_',stringList{s})
+        ind = strfind(stringList{s},'_');
+        if nargin < 2
+            fixedStrings{s}(ind) = [];
+        else
+            fixedStrings{s}(ind) = replacement;
+        end
+    end
+end
+
+end
+
+
diff --git a/Tools/runStatisticalComparison.m b/Tools/runStatisticalComparison.m
new file mode 100644
index 0000000000000000000000000000000000000000..0d9b1d84841f536fa0ce9ee3886fe7ea6cc66971
--- /dev/null
+++ b/Tools/runStatisticalComparison.m
@@ -0,0 +1,368 @@
+function [groupTable2,statisticsTable,meanTable,checkMean,checkNormality,...
+    numRejectedHyp,rejecttables,medianTable,stattestTable,...
+    statdocumenttable] = runStatisticalComparison(testName,patNums,data,datanames,tablenames)
+% grouptable2: with strings eg "mean +-sd"
+% groupTable: with pure results, mean std and pvalues separatly
+% statisticsTable: with all statistics saved: statistics, confidence
+% intervals, rejection true/false and p-values
+
+pathbase = split(pwd,'cardiovascularavatar_HEALTH_T2D_HT');
+addpath(fullfile(pathbase{1},'cardiovascularavatar_HEALTH_T2D_HT/Requirements/Statistical_tests'))
+
+%% load group indexes based on patNums
+[groups] = loadGroupIndexes(patNums);
+
+%% setup tables
+groupNames = {'Controls HBP','T2D HBP',...
+    'Hypertensive HBP','Hypertensive T2D HBP'};
+
+compNames = {
+    'HBP: control vs hypertensive', ...
+    'HBP: T2D vs hypertensive T2D',...
+    'HBP: Hypertensive vs hypertensive & T2D',...
+    'HBP: control vs T2D',...
+    'HBP: control vs hypertensive T2D',...
+    'HBP: Hypertensive vs T2D'};
+
+tablenamesSD = strcat('sd',tablenames);
+tablenamesIQR = strcat('iqr',tablenames);
+
+meanTable = table();
+indexes = {groups.C_NT_home,groups.T2D_NT_home,...
+    groups.C_HT_home,groups.T2D_HT_home}';
+
+meanTable.Group = [groupNames,compNames]';
+for g = 1:length(indexes)
+    meanTable.N(g) = sum(indexes{g});
+end
+meanTable.N(g+1:end)  = nan(length(compNames),1);
+
+groupTable2 = table;
+groupTable2.Group = meanTable.Group;
+groupTable2.N = meanTable.N;
+groupTable2.correctedP = cell(size(meanTable.N));
+
+%normality check tables
+checkMean = table;
+checkMean.Group = meanTable.Group;
+checkMeanall = table;
+checkMeanall.names = tablenames';
+checkMeanall.mean = nan(size(tablenames))';
+checkMeanall.std = nan(size(tablenames))';
+checkMeanall.perc = nan(size(tablenames))';
+
+checkNormality.isnormal = nan(length(tablenames),length(indexes)+1);
+checkNormality.pvalNormality = nan(length(tablenames),length(indexes)+1);
+checkNormality.sdPercMean = nan(length(tablenames),length(indexes)+1);
+checkNormality.groupNames = [groupNames,{'all'}];
+checkNormality.tablenames = tablenames;
+
+%mean and median tables
+for t = 1:length(tablenames)
+    meanTable.(tablenames{t}) =nan(size(meanTable.Group));
+    groupTable2.(tablenames{t}) = cell(size(groupTable2.Group));
+    checkMean.(tablenames{t}) =nan(size(meanTable.Group));
+end
+medianTable = meanTable;
+for t = 1:length(tablenamesSD)
+    meanTable.(tablenamesSD{t}) =nan(size(meanTable.Group));
+    medianTable.(tablenamesIQR{t}) = nan(size(medianTable.Group)); 
+end
+medianTable.mediansubjects = cell(size(medianTable.Group));
+medianTable.groupsubjects = cell(size(medianTable.Group));
+for g = 1:length(medianTable.Group)
+    medianTable.mediansubjects{g} = cell(1,length(tablenames));
+    medianTable.groupsubjects{g} = cell(1,length(tablenames));
+end
+meanTable.meansubjects=medianTable.mediansubjects;
+meanTable.groupsubjects=medianTable.groupsubjects;
+
+%table for which statistical test that was performed
+stattestTable = groupTable2(:,[1:2,4:end]);
+
+% create statistics table
+groupComparisonNames= compNames;
+statistics = cell(size(groupComparisonNames));
+confidenceIntervals = cell(size(groupComparisonNames));
+pvalues = cell(size(groupComparisonNames));
+reject = pvalues;
+for n = 1:length(groupComparisonNames)
+    statistics{n} =cell(size(tablenames));
+    confidenceIntervals{n} =cell(size(tablenames));
+    pvalues{n} = nan(size(tablenames));
+    reject{n} =zeros(size(tablenames));%logical
+end
+
+rejectBenjH2=reject;
+statisticsTable = table(groupComparisonNames,statistics,confidenceIntervals,pvalues,reject,rejectBenjH2);
+
+
+
+%% fill tables - calculate mean, median and std for each group and each variable in the tablenames
+for ind = 1:length(indexes)
+    for t = 1:length(tablenames)
+        %check for normal distribution using a Shapiro-Wilk parametric hypothesis test of composite normality
+        if ~strcmp('categorical',testName)
+            if ind == 1
+                try
+                [checkNormality.isnormal(t,length(indexes)+1), checkNormality.pvalNormality(t,length(indexes)+1), ~] = swtest(data.(datanames{t}), 0.005);
+                catch e
+                    fprintf('Shapiro-w could not run for %s! The message was:\n%s\n',tablenames{t},e.message);
+                    checkNormality.isnormal(t,length(indexes)+1) = 0;
+                    checkNormality.pvalNormality(t,length(indexes)+1) = 0;
+                end
+                checkNormality.sdPercMean(t,length(indexes)+1) = 100* nanstd(data.(datanames{t}))/nanmean(data.(datanames{t}));
+            end
+            thisvariable=data.(datanames{t})(indexes{ind});
+            if length(thisvariable(~isnan(thisvariable))) > 2
+                try
+                    [checkNormality.isnormal(t,ind), checkNormality.pvalNormality(t,ind), ~] = swtest(thisvariable, 0.005);
+                catch e
+                    fprintf('Shapiro-w could not run for %s! The message was:\n%s\n',tablenames{t},e.message);
+                    checkNormality.isnormal(t,ind)=0;
+                    checkNormality.pvalNormality(t,ind)=NaN;
+                end
+            else
+                checkNormality.isnormal(t,ind)=0;
+                checkNormality.pvalNormality(t,ind)=NaN;
+            end
+            checkNormality.sdPercMean(t,ind) = 100* nanstd(thisvariable)/nanmean(thisvariable);
+        end
+        
+        allvalues = data.(datanames{t})(indexes{ind});
+        patNumsind = patNums(indexes{ind});
+        medianTable.groupsubjects{ind}{t} = patNumsind;
+        meanTable.groupsubjects{ind}{t} = patNumsind;
+        
+        %calculate mean & standard deviation
+        meanTable.(tablenames{t})(ind) = mean(allvalues,'omitnan');
+        meanTable.(tablenamesSD{t})(ind) = std(allvalues,'omitnan');
+        [mindiff,meanPat] = min(abs(allvalues- meanTable.(tablenamesSD{t})(ind)));
+        meanTable.meansubjects{ind}{t} = patNumsind{meanPat};%mean subject for the variable t in group ind
+        
+        %calculate median& interquartile range
+        medianTable.(tablenames{t})(ind) = median(allvalues,'omitnan');
+        medianTable.(tablenamesIQR{t})(ind) = iqr(allvalues);%or use quantile(allvalues,[0.25 0.75])
+        [mindiff,medianPat] = min(abs(allvalues-medianTable.(tablenames{t})(ind)));
+        medianTable.mediansubjects{ind}{t} = patNumsind{medianPat};%median subject for the variable t in group ind
+    end
+end
+
+%% Define comparison indexes for all group comparisons
+comparisons = {};
+comparisongroups = cell(6,2);
+
+% four groups based on home blood pressure
+[comparisongroups{1:6,1}] = deal('fourgroups_hbp');
+[comparisongroups{1:6,2}] = deal({'Controls HBP','Hypertensive HBP','Hypertensive T2D HBP','T2D HBP'});
+           
+comparisons{1}.name = 'HBP: control vs hypertensive';
+comparisons{1}.compinds = [find(strcmp(meanTable.Group,'Controls HBP')),find(strcmp(meanTable.Group,'Hypertensive HBP'))];
+
+comparisons{2}.name = 'HBP: T2D vs hypertensive T2D';
+comparisons{2}.compinds = [find(strcmp(meanTable.Group,'Hypertensive T2D HBP')),find(strcmp(meanTable.Group,'T2D HBP'))];
+
+comparisons{3}.name = 'HBP: Hypertensive vs hypertensive & T2D';
+comparisons{3}.compinds = [find(strcmp(meanTable.Group,'Hypertensive HBP')),find(strcmp(meanTable.Group,'Hypertensive T2D HBP'))];
+
+comparisons{4}.name = 'HBP: control vs T2D';
+comparisons{4}.compinds = [find(strcmp(meanTable.Group,'T2D HBP')),find(strcmp(meanTable.Group,'Controls HBP'))];
+
+comparisons{5}.name = 'HBP: control vs hypertensive T2D';
+comparisons{5}.compinds = [find(strcmp(meanTable.Group,'Controls HBP')),find(strcmp(meanTable.Group,'Hypertensive T2D HBP'))];
+
+comparisons{6}.name = 'HBP: Hypertensive vs T2D';
+comparisons{6}.compinds = [find(strcmp(meanTable.Group,'Hypertensive HBP')),find(strcmp(meanTable.Group,'T2D HBP'))];
+
+    
+for c = 1:length(comparisons)
+    comparisons{c}.pind = find(strcmp(meanTable.Group,comparisons{c}.name));
+    comparisons{c}.statind = find(strcmp(statisticsTable.groupComparisonNames,comparisons{c}.name));
+end
+
+checkNormality.isnormalComparisongroups = nan(length(tablenames),length(comparisons));
+checkNormality.isnormalComparisongroupNames = cell(1,length(comparisons));
+checkNormality.isnormalComparisongroupNamesAll = cell(1,length(comparisons));
+
+%% make the comparisons
+lastgroup = '';
+for c = 1:length(comparisons)
+    comparison = comparisons{c};
+    switch testName
+        case 'nonparametric'
+            indnormal = zeros(size(tablenames));
+            [groupTable2,statisticsTable,meanTable,stattestTable] = nonparametrictestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,1:length(tablenames),stattestTable);
+        case 'ttest'
+            indnormal = ones(size(tablenames));
+            [groupTable2,statisticsTable,meanTable,stattestTable] = ttestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,1:length(tablenames),stattestTable);
+        case 'numeric'
+            compgroups = ismember(checkNormality.groupNames,[comparisongroups{c,2},{'all'}]);%indexes for the groups in the comparison. 'all' is to test for all subjects
+            indnormal = sum(checkNormality.isnormal(:,compgroups),2) == length(comparisongroups{c,2})+1; %check if all groups in the comparison are normally distributed
+            [groupTable2,statisticsTable,meanTable,stattestTable] = ttestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,find(indnormal),stattestTable);
+            [groupTable2,statisticsTable,meanTable,stattestTable] = nonparametrictestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,find(~indnormal),stattestTable);
+        case 'categorical'
+            indnormal = ones(size(tablenames));
+            [groupTable2,statisticsTable,meanTable,stattestTable] = categoricaltestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,stattestTable);
+    end
+    checkNormality.isnormalComparisongroupNamesAll{c} = comparisongroups{c,2};
+    checkNormality.isnormalComparisongroups(:,c) = indnormal;
+    if ~strcmp(comparisongroups{c,1},lastgroup)
+        checkNormality.isnormalComparisongroupNames{c} = comparisongroups{c,1};
+    end
+    lastgroup = comparisongroups{c,1};
+    
+    %add pvalues to the median table as well
+    for t = 1:length(tablenames)
+        medianTable.(tablenames{t})(comparison.pind) = meanTable.(tablenames{t})(comparison.pind);
+    end
+    checkNormality.normalDistributed_4groups = indnormal;
+end
+
+%% put mean, median or percentage values into the grouptable
+for ind = 1:length(indexes)
+    for t = 1:length(tablenames)
+        isnormal = checkNormality.normalDistributed_4groups(t);
+        if strcmp('categorical',testName)
+            groupTable2.(tablenames{t}){ind} = sprintf('%0.2f%%',meanTable.(tablenames{t})(ind)*100);
+            stattestTable.(tablenames{t}){ind} = 'categorical';
+        elseif isnormal
+            % put together a string with mean and std
+            if isnan(meanTable.(tablenames{t})(ind))
+                groupTable2.(tablenames{t}){ind} = ' - ';
+            else
+                groupTable2.(tablenames{t}){ind} = sprintf('%0.2f (+-%0.2f)',meanTable.(tablenames{t})(ind),meanTable.(tablenamesSD{t})(ind));
+            end
+            stattestTable.(tablenames{t}){ind} = 'normal';
+        elseif  ~isnormal
+            %string with median and interquartile range
+            if isnan(medianTable.(tablenames{t})(ind))
+                groupTable2.(tablenames{t}){ind} = ' - ';
+            else
+                groupTable2.(tablenames{t}){ind} = sprintf('%0.2f (%0.2f)',medianTable.(tablenames{t})(ind),medianTable.(tablenamesIQR{t})(ind));
+            end
+            stattestTable.(tablenames{t}){ind} = 'notnormal';
+        end
+    end
+end
+
+%% correct p-values 
+compinds = zeros(6,1);pinds= zeros(6,1);
+rownames = {
+    'HBP: control vs hypertensive',...
+    'HBP: T2D vs hypertensive T2D',...
+    'HBP: Hypertensive vs hypertensive & T2D',...
+    'HBP: control vs T2D',...
+    'HBP: control vs hypertensive T2D',...
+    'HBP: Hypertensive vs T2D'};
+rejectBenjH2= nan(1,length(rownames));
+
+for r = 1:length(rownames)
+    compinds(r) = find(strcmp(statisticsTable.groupComparisonNames,rownames{r}));
+    pinds(r) = find(strcmp(meanTable.Group,rownames{r}));
+end
+rejectany4hbp = zeros(length(tablenames),2);
+for t = 1:length(tablenames)
+    pvals = zeros(size(compinds));
+    reject = zeros(size(compinds));
+    for c = 1:length(compinds)
+        pvals(c) = statisticsTable.pvalues{compinds(c)}(t);
+        reject(c) = statisticsTable.reject{compinds(c)}(t);
+    end
+    % correct pvalues Benjamini-Hochberg
+    [rejectBenjH2(1:6),resulttableBenjH] = Benjamini_Hochberg(pvals(1:6),rownames(1:6),0.05);
+        
+    for c = 1:length(compinds)
+        statisticsTable.rejectBenjH2{compinds(c)}(t) = rejectBenjH2(c);
+    end
+    
+    %sum pvalues from differenttests in a table
+        rejecttables.(tablenames{t}) = table(pvals,rejectBenjH2','VariableNames',...
+        {'pOrig','rBenjH2'},'Rownames',rownames);
+        rejectany4hbp(t,:) = [sum(reject(1:6)),sum(rejectBenjH2(1:6))];
+
+    %replace table with the corrected values for reject or not
+    for c = 1:length(compinds)
+        if isnan(rejectBenjH2(c))
+            groupTable2.(tablenames{t}){pinds(c)}  = ' - ';
+        elseif rejectBenjH2(c) && statisticsTable.pvalues{compinds(c)}(t) < 0.0001 %0.001
+            groupTable2.(tablenames{t}){pinds(c)}  = '<0.0001*';%0.001
+        elseif rejectBenjH2(c)
+            groupTable2.(tablenames{t}){pinds(c)}  = sprintf('%0.4f*',statisticsTable.pvalues{compinds(c)}(t));%0.3f
+        else
+            groupTable2.(tablenames{t}){pinds(c)}  = sprintf('%0.4f',statisticsTable.pvalues{compinds(c)}(t));
+        end
+        groupTable2.correctedP{pinds(c)} = 'BenjaminiHochberg';
+    end
+
+end
+numRejectedHyp.HBP = array2table(rejectany4hbp,'Rownames',tablenames,'VariableNames',{'r','rBenjH2'});
+
+
+%% Create table for statistics document
+tosummarize = {comparisons{1:6}};
+
+statdocumenttable = table;
+groups4hbp = {'Controls HBP','T2D HBP','Hypertensive HBP','Hypertensive T2D HBP'};
+groupnamesshort = {'C','T2D','HT','T2D+HT'};
+statdocumenttable.variable = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.group = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.mean = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.sdgroup = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.sd = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.ngroup = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.n = cell(length(tablenames)*length(tosummarize),1);
+n=1;
+for t =1:length(tablenames)
+    isnormal=checkNormality.isnormalComparisongroups(t,1:6);
+    allarenormal = sum(isnormal)==length(isnormal);
+    statdocumenttable.variable{n} = tablenames{t};
+    for g = 1:length(groups4hbp)
+        statdocumenttable.group{n} = groupnamesshort{g};
+        statdocumenttable.sdgroup{n} = groupnamesshort{g};
+        statdocumenttable.ngroup{n} = groupnamesshort{g};
+        groupind = strcmp(medianTable.Group,groups4hbp{g});
+        %median, SD,n
+        statdocumenttable.n{n} = medianTable.N(groupind);
+        if strcmp(testName,'categorical')
+            statdocumenttable.mean{n} =sprintf('%0.2f%%',meanTable.(tablenames{t})(groupind)*100);
+            statdocumenttable.sd{n} = '-';
+        elseif allarenormal
+            statdocumenttable.mean{n} = meanTable.(tablenames{t})(groupind);
+            statdocumenttable.sd{n} = meanTable.(tablenamesSD{t})(groupind);
+        else
+            statdocumenttable.mean{n} = medianTable.(tablenames{t})(groupind);
+            statdocumenttable.sd{n} = medianTable.(tablenamesIQR{t})(groupind);
+        end
+        n = n+1;
+    end
+    n = n+2;%add two empty rows
+end
+
+%pvals
+compnamesshort = {'C vs HT','T2D vs HT+T2D','HT vs HT+T2D','C vs T2D','C vs HT+T2D','HT vs T2D'};
+statdocumenttable.comp = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.p = cell(length(tablenames)*length(tosummarize),1);
+statdocumenttable.testtype = cell(length(tablenames)*length(tosummarize),1);
+n=1;
+for t = 1:length(tablenames)
+    isnormal=checkNormality.isnormalComparisongroups(t,1:6);
+    %pvals
+    for c = 1:length(tosummarize)
+        comp = tosummarize{c}.name;
+        statdocumenttable.comp{n} = compnamesshort{c};
+        statdocumenttable.p{n} = groupTable2.(tablenames{t}){find(strcmp(meanTable.Group,comp))};
+        if strcmp(testName,'categorical')
+            statdocumenttable.testtype{n} = [stattestTable.(tablenames{t}){tosummarize{c}.pind},', Benjamini Hochberg'];
+        elseif isnormal(c)
+            statdocumenttable.testtype{n} = 't-test, Benjamini Hochberg';
+        else
+            statdocumenttable.testtype{n} = 'Wilcoxon ranked sum, Benjamini Hochberg';
+        end
+        n = n+1;
+    end
+end
+
+end
+
+
+
diff --git a/Tools/saveAllFigures.m b/Tools/saveAllFigures.m
new file mode 100644
index 0000000000000000000000000000000000000000..49ddca75720a0a5fc96c1acfa3698ba3a22ce42e
--- /dev/null
+++ b/Tools/saveAllFigures.m
@@ -0,0 +1,17 @@
+function saveAllFigures(plotFolderName,saveFigs)
+
+if nargin < 2 || (nargin == 2 && saveFigs)
+    disp('Saving figures...')    
+    FigList = findobj(allchild(0), 'flat', 'Type', 'figure');
+    for fig = 1:length(FigList)
+        currFig = FigList(fig);
+        figName = currFig.Name;
+        exportgraphics(currFig,[fullfile(plotFolderName,figName) '.pdf'],'ContentType','vector')
+        close(currFig)
+        %fprintf('%0.1f \n',100*fig/length(FigList))
+    end
+else
+    disp('Not saving any figures.')
+end
+
+end
\ No newline at end of file
diff --git a/Tools/ttestTable.m b/Tools/ttestTable.m
new file mode 100644
index 0000000000000000000000000000000000000000..cc4a0c77efa680e0a13547b4660c377d1b878ff0
--- /dev/null
+++ b/Tools/ttestTable.m
@@ -0,0 +1,39 @@
+function [groupTable2,statisticsTable,meanTable,stattestTable] = ttestTable(comparison,data,datanames,tablenames,statisticsTable,meanTable,groupTable2,indexes,toTest,stattestTable)
+% calculate unpaired t-test (Two-sample t-test with pooled or unpooled
+% variance estimate.) H = ttest2(X,Y). This function performs an unpaired
+% two-sample t-test.
+% for each variable in the tablenames list
+for i = 1:length(toTest)
+    t = toTest(i);
+    d1 =data.(datanames{t})(indexes{comparison.compinds(1)});
+    d2 = data.(datanames{t})(indexes{comparison.compinds(2)});
+    if sum(isnan(d1)) == length(d1) || sum(isnan(d2)) == length(d2) %if one of the groups is full of NaN values
+        meanTable.(tablenames{t})(comparison.pind) = NaN;
+        statisticsTable.reject{comparison.statind}(t) = NaN;
+        statisticsTable.statistics{comparison.statind}{t} = NaN;
+        groupTable2.(tablenames{t}){comparison.pind} = ' - ';
+        statisticsTable.pvalues{comparison.statind}(t) = NaN;
+        statisticsTable.rejectBonferroni{comparison.statind}(t) = NaN;
+        stattestTable.(tablenames{t}){comparison.pind} = ' - ';
+    else
+        d1 = d1(~isnan(d1));
+        d2 = d2(~isnan(d2));
+        [statisticsTable.reject{comparison.statind}(t),...
+            meanTable.(tablenames{t})(comparison.pind),...
+            statisticsTable.confidenceIntervals{comparison.statind}{t},...
+            statisticsTable.statistics{comparison.statind}{t}] = ...
+            ttest2(d1,d2,'Alpha',0.05,'Vartype','equal');
+        if meanTable.(tablenames{t})(comparison.pind) < 0.0001 %0.0001
+            groupTable2.(tablenames{t}){comparison.pind}  = '<0.0001*';
+        elseif meanTable.(tablenames{t})(comparison.pind) <= 0.05
+            groupTable2.(tablenames{t}){comparison.pind}  = sprintf('%0.4f*',meanTable.(tablenames{t})(comparison.pind));%0.3f
+        else
+            groupTable2.(tablenames{t}){comparison.pind}  = sprintf('%0.4f',meanTable.(tablenames{t})(comparison.pind));
+        end
+        statisticsTable.pvalues{comparison.statind}(t) = meanTable.(tablenames{t})(comparison.pind);
+    end
+    stattestTable.(tablenames{t}){comparison.pind} = 'unpaired ttest';
+
+end
+
+end
diff --git a/createFigures_hypertensionT2D.m b/createFigures_hypertensionT2D.m
new file mode 100644
index 0000000000000000000000000000000000000000..f58445f63b1df0495ed314be5a2c16c0340db049
--- /dev/null
+++ b/createFigures_hypertensionT2D.m
@@ -0,0 +1,187 @@
+%% Main script 
+% avatar model applied on data from HEALTH study to evalute hemodynamics in T2D and hypertension
+% Script to simulate several individuals and plot the results
+
+close all
+clear
+
+disp('*** Re-creating results for model training, validation, and group comparisons. This might take several minutes. ***')
+
+
+%% Set up: Load data, optimization results, and settings
+% Add dependencies to matlab path
+addpath(['.' filesep 'Requirements' filesep 'matplotlib']) 
+addpath(['.' filesep 'Tools'])
+addpath(['.' filesep 'Simulation'])
+
+% Load data and optimizaton results for all subjects
+resultsFolder = 'Parameters/ESS';
+[patNums, data,extradata,bestparamValues,constants,paramNames,...
+    constantsNames,ynames,xnames,options,inds,origParamvalues,...
+    units,loadedcosts,meanParams,medianParams,paramuncertainty] =setup_simulations_HEALTH([],resultsFolder,0);
+
+% Create a folder to save the resulting figures in
+thispath = split(pwd,'cardiovascularavatar_T2D_HT');
+plotFolderName = fullfile(thispath{1},'cardiovascularavatar_T2D_HT',['Resultfigures_',datestr(now,'yymmdd_HHMM')]);
+mkdir(plotFolderName)
+
+%% Simulate all subjects
+datanames = {'MV','AV','AC','PV'};
+numflows = length(datanames);
+maxSVdiffData = zeros(size(patNums));
+simLast = cell(1,length(patNums));
+simCostFunc = cell(1,length(patNums));
+rmse = zeros(size(patNums));rmseFlow = zeros(size(patNums));
+rmsePressure=zeros(size(patNums));rmseParam=zeros(size(patNums));
+SVdiffstot = zeros(size(patNums));
+cost = zeros(size(patNums));
+fittedcost = zeros(size(patNums));
+percenterrorFlow = zeros(1,length(patNums));
+percenterrorParamsansBP = zeros(1,length(patNums));
+percenterrorTotal=zeros(1,length(patNums));
+SVdiffs = zeros(length(patNums),numflows);
+warning('off','all');
+numHeartBeats = 20; %maximum number of heartbeats to simulate
+for p = 1:length(patNums)
+    fprintf('Simulating subject %d/%d...\n',p,length(patNums))
+    % Calculate cost and fit to data
+    inds{p}.estParams = 1:length(bestparamValues(:,p));
+    [cost(p),simCostFunc{p},~,SVdiffs(p,:),~,rmses,~,percenterror,MAPE(p)] = costFunction_HEALTH_allcalculations(log10(bestparamValues(:,p)),constants(:,p),bestparamValues(:,p),options,numHeartBeats,data{p},inds{p},datanames);
+    fittedcost(p) = costFunction_HEALTH(log10(bestparamValues(:,p)),constants(:,p),bestparamValues(:,p),options,numHeartBeats,data{p},inds{p},1,0);
+    SVdiffstot(p) = sum(abs(SVdiffs(p,:)));
+    rmse(p) = sum(rmses);
+    rmseFlow(p) = rmses(numflows+1);
+    rmsePressure(p) = rmses(numflows+2);
+    rmseParam(p) = rmses(numflows+3);
+    percenterrorFlow(p) = percenterror.flow;
+    percenterrorParamsansBP(p) = percenterror.params;
+    percenterrorTotal(p)=percenterror.sumall;
+    
+    %calculate difference in stroke volume (SV) in the data
+    dataSV = zeros(size(datanames));
+    for d = 1:length(datanames)
+        dataSV(d) = trapz(data{p}.time,data{p}.(datanames{d})(:,2));
+    end
+    maxSVdiffData(p) = max(dataSV) - min(dataSV);
+    
+    % Simulate
+    step = 0.001;
+    T = constants(inds{p}.T,p);
+    simtime = sort([data{p}.time,0:step:T]);
+    simtime = unique(simtime);
+    options.x0 = data{p}.IC;
+    [~,simLast{p}] = simulate_avatarHEALTH(bestparamValues(:,p),constants(:,p),options,numHeartBeats,inds{p},simtime);
+end
+warning('on','all');
+
+
+%% Create a table of costs and fit to data (Table 3)
+costs = {fittedcost',rmseFlow,rmsePressure,rmseParam,SVdiffstot,maxSVdiffData,percenterrorTotal,MAPE}';
+means = zeros(size(costs));mins = zeros(size(costs));maxs = zeros(size(costs));medians = zeros(size(costs));
+for c = 1:length(costs)
+    means(c) = round(mean(costs{c}),1);
+    medians(c) = round(median(costs{c}),1);
+    mins(c) = round(min(costs{c}),1);
+    maxs(c) = round(max(costs{c}),1);
+end
+costTableMean = table(means,medians,mins,maxs,'VariableNames',...
+    {'Mean','Median','Min','Max'},'RowNames',...
+    {'Cost','RMSE blood flow (ml/s)','RMSE pressure (mmHg)','RMSE parameters (-)'...
+    'Sum of |SV simulation - SV data| (ml)','Max difference within SV data (ml)',...
+    'Total error (%)','MAPE (%)'});
+
+%Save cost table
+writetable(costTableMean,fullfile(plotFolderName,'costtable.xlsx'),"WriteRowNames",1)
+
+%% Plot results
+% Load parameter bounds
+[bounds.lb,bounds.ub] = loadParamBounds_HEALTH(inds{1},[]);
+lbs = zeros(length(patNums),length(paramNames));
+ubs=lbs;
+for p = 1:length(patNums)
+[lbs(p,:),ubs(p,:)] = loadParamBounds_HEALTH(inds{p},data{p}.params);
+end
+
+% Create table with the parameter bounds (for supplementary)
+varnames = {'min lb','max lb','mean lb','min ub','max ub','mean ub'};
+lbubtable = table(min(lbs)',max(lbs)',mean(lbs)',min(ubs)',max(ubs)',mean(ubs)','Rownames',paramNames,'Variablenames',varnames);
+writetable(lbubtable,fullfile(plotFolderName,'parameter_bounds.xlsx'),"WriteRowNames",1)
+
+% Load (or simulate)the simulation uncertainty for all subjects
+cd Simulation
+loadResults=1;
+[minmaxSim] = findSimulationUncertainty(patNums,paramuncertainty.allokParams,constants,inds,data,options,bestparamValues,1,loadResults);
+cd ..
+
+% Plot the figures
+cd Plotting
+plotmedian=1;
+
+disp('Plotting fit to data...')
+plot_fitToData_uncertainty(minmaxSim,patNums,bestparamValues,paramuncertainty,paramNames,data,inds,fittedcost,plotFolderName);
+
+disp('Plotting fit to data: validation...')
+plot_validation_uncertainty(minmaxSim,paramuncertainty,bestparamValues,constants,simLast,inds,options,data,extradata,patNums,xnames,plotFolderName)
+%%
+disp('Plotting box plot of parameter differences...')
+[testTableParameters,meantableParameters,mediantableParameters,...
+    statisticsTableParams,numRejectedHypParameters] = plot_parameterDifferences(paramNames,medianParams,patNums,bounds,inds{p},units,plotFolderName);
+
+disp('Plotting spider plots of parameter differences...')
+plot_spiderparams(paramNames,medianParams,patNums,bounds,inds{p},plotFolderName,statisticsTableParams,numRejectedHypParameters,mediantableParameters);
+
+disp('Plotting clusters and PCA results...')
+[clusterindex,groupedinbothFinal] = clusterCalculation(medianParams,constants,2,paramNames,constantsNames,patNums,plotFolderName);
+
+disp('Plotting box plot of prediction differences...')
+[testTablePredictions] = plot_predictionDifferences(simLast,patNums,ynames,plotFolderName);
+
+cd ..
+
+%% Calculate subject specific standard deviations vs group standard deviations/interquartile ranges (supplementary)
+allParamSDs = zeros(length(paramuncertainty.allokParams),length(paramNames));
+allParamIQRs = zeros(length(paramuncertainty.allokParams),length(paramNames));
+for p = 1:length(paramuncertainty.allokParams)
+    allParamSDs(p,:)=std(paramuncertainty.allokParams{p});
+    allParamIQRs(p,:)=iqr(paramuncertainty.allokParams{p});
+end
+
+[groups] = loadGroupIndexes(patNums);
+groupnames = {'Controls HBP','T2D HBP','Hypertensive HBP','Hypertensive T2D HBP'};
+groupinds = {groups.C_NT_home,groups.T2D_NT_home, groups.C_HT_home,groups.T2D_HT_home};
+groupSD = zeros(1,length(paramNames));
+pooledSubjectSD = zeros(1,length(paramNames));
+groupIQR = zeros(1,length(paramNames));
+medianIQRvsgroup = zeros(1,length(paramNames));
+for param = 1:length(paramNames)
+    for g = 1:length(groupinds)
+        groupSD(param,g) = meantableParameters.(['sd' paramNames{param}])(strcmp(meantableParameters.Group,groupnames{g}));
+        pooledSubjectSD(param,g) = sqrt(sum(allParamSDs(groupinds{g},param).^2)/length(paramNames));
+        
+        groupIQR(param,g) = mediantableParameters.(['iqr' paramNames{param}])(strcmp(meantableParameters.Group,groupnames{g}));
+        medianIQRvsgroup(param,g) = median(100.*allParamIQRs(groupinds{g},param)./groupIQR(param,g));
+    end
+end
+
+individual_vs_groupSD=table(100*pooledSubjectSD./groupSD,'Rownames',paramNames','Variablenames',{'Pooled SD % of group SD'});
+individual_vs_groupIQR=table(medianIQRvsgroup(:,1),medianIQRvsgroup(:,2),medianIQRvsgroup(:,3),medianIQRvsgroup(:,4),'Rownames',paramNames','Variablenames',{'Controls','T2D','Hypertensive','Hypertensive T2D'});
+
+%save the tables
+writetable(individual_vs_groupIQR,fullfile(plotFolderName,'individual_vs_groupIQR.xlsx'),"WriteRowNames",1)
+writetable(individual_vs_groupSD,fullfile(plotFolderName,'individual_vs_groupSD.xlsx'),"WriteRowNames",1)
+
+%% Save other results
+disp('Saving tables with group differences...')
+%create excel files with statistics results
+comparisons4hbb= {'HBP: control vs hypertensive', ...
+    'HBP: T2D vs hypertensive T2D',...
+    'HBP: Hypertensive vs hypertensive & T2D',...
+    'HBP: control vs T2D',...
+    'HBP: control vs hypertensive T2D',...
+    'HBP: Hypertensive vs T2D'};
+groups4hbp = {'Controls HBP','T2D HBP','Hypertensive HBP','Hypertensive T2D HBP'};
+parameters_4groups_hbp = createResultsTable(testTableParameters, groups4hbp, comparisons4hbb,1,fullfile(plotFolderName,'parameters_4groups_hbp'));
+predictions_4groups_hbp = createResultsTable(testTablePredictions, groups4hbp, comparisons4hbb,1,fullfile(plotFolderName,'predictions_4groups_hbp'));
+
+
+fprintf('***\nDONE. The figures and tables are saved in %s.\nTo re-create figures with subject-specific predicitons, run createFigures_hypertensionT2D_predictions.\n***\n',plotFolderName)
diff --git a/createFigures_hypertensionT2D_predictions.m b/createFigures_hypertensionT2D_predictions.m
new file mode 100644
index 0000000000000000000000000000000000000000..8a491f735534c404674ee37b0c6a63d76757c5d1
--- /dev/null
+++ b/createFigures_hypertensionT2D_predictions.m
@@ -0,0 +1,97 @@
+function [] = createFigures_hypertensionT2D_predictions()
+% Simulate and plot subject-specific predictions with uncertainty
+disp('*** Re-creating results for subject-specific predictions with uncertainty. This might take several minutes. ***')
+
+%% Setup
+close all
+clear
+
+% Create a folder to save the resulting figures in
+thispath = split(pwd,'cardiovascularavatar_T2D_HT');
+plotFolderName = fullfile(thispath{1},'cardiovascularavatar_T2D_HT',['Resultfigures_predictions_',datestr(now,'yymmdd_HHMM')]);
+mkdir(plotFolderName)
+
+% Add dependencies to matlab path
+addpath '.\Requirements\matplotlib'
+addpath '.\Tools'
+addpath '.\Simulation'
+
+resultfolder = 'Parameters/ESS';
+
+% Load which subjects to simulate
+load('./Parameters/bestpatients.mat','pbestT2Dh','pbestT2Dn','pbestCn','pbestCh')
+pC= pbestCn;
+pT2D=pbestT2Dn;
+pHT= pbestCh;
+pHTT2D = pbestT2Dh;
+
+%% Load paramvalues and simulate for one person from each group
+%This takes several minutes
+disp('*** Simulating uncertainty for the control subject... *** ')
+[~,data_CNT,~,bestparams_CNT,constants_CNT,paramNames,constantsNames,ynames,xnames,options,inds_CNT,~,~,~,~,~,paramuncertainty_CNT] = setup_simulations_HEALTH({pC},resultfolder,0);
+[~,minmaxSimCNT] = simulatePredictionUncertainty({pC},[],[],paramuncertainty_CNT.allokParams,bestparams_CNT,constants_CNT,inds_CNT,data_CNT,options);
+
+disp('*** Simulating uncertainty for the T2D subject... *** ')
+[~,data_T2DNT,~,bestparams_T2DNT,constants_T2DNT,~,~,~,~,~,inds_T2DNT,~,~,~,~,~,paramuncertainty_T2DNT] = setup_simulations_HEALTH({pT2D},resultfolder,0);
+[~,minmaxSimT2DNT] = simulatePredictionUncertainty({pT2D},[],[],paramuncertainty_T2DNT.allokParams,bestparams_T2DNT,constants_T2DNT,inds_T2DNT,data_T2DNT,options);
+
+disp('*** Simulating uncertainty for the HT subject... *** ')
+[~,data_CHT,~,bestparams_CHT,constants_CHT,~,~,~,~,~,inds_CHT,~,~,~,~,~,paramuncertainty_CHT] = setup_simulations_HEALTH({pHT},resultfolder,0);
+[~,minmaxSimCHT] = simulatePredictionUncertainty({pHT},[],[],paramuncertainty_CHT.allokParams,bestparams_CHT,constants_CHT,inds_CHT,data_CHT,options);
+
+disp('*** Simulating uncertainty for the HT+T2D subject... *** ')
+[~,data_T2DHT,~,bestparams_T2DHT,constants_T2DHT,~,~,~,~,~,inds_T2DHT,~,~,~,~,~,paramuncertainty_T2DHT] = setup_simulations_HEALTH({pHTT2D},resultfolder,0);
+[~,minmaxSimT2DHT] = simulatePredictionUncertainty({pHTT2D},[],[],paramuncertainty_T2DHT.allokParams,bestparams_T2DHT,constants_T2DHT,inds_T2DHT,data_T2DHT,options);
+
+%% Plot the simulations of the subjects from the 4 groups
+magmacols = flip(magma(4));
+colors = num2cell(magmacols,2);
+simulationNames = {'Control','T2D','Hypertensive',sprintf('T2D &\nhypertensive')}';
+simulations = {minmaxSimCNT,minmaxSimT2DNT,minmaxSimCHT,minmaxSimT2DHT};
+plotPredictionUncertaintyNice(simulations,simulationNames,xnames,ynames,'Subjects from 4 groups',colors)
+
+%% Simulate prediction: control to reduced m2LV in HT+T2D
+% Set parameter values for the prediction
+allParams = paramuncertainty_CNT.allokParams;%parameters for the control subject
+allParams2 = allParams;
+bestparams2 = bestparams_CNT;
+
+% set which parameters to change
+paramsToChange = {'m2_LV'};
+paramsToChange_inds = [find(strcmp(paramNames,'m2_LV'))];
+
+%set the change in m2LV so that the value in the best parameter set is changed to 20
+fractionChange = 20/bestparams_CNT(paramsToChange_inds(1),1);
+
+% change of m2LV in all parameter sets based on the same fraction
+for pat = 1:size(allParams)
+    for param = 1:length(paramsToChange)
+        allParams2{pat}(:,paramsToChange_inds(param)) = allParams{pat}(:,paramsToChange_inds(param))*fractionChange(param);
+        bestparams2(paramsToChange_inds(param),pat) = bestparams_CNT(paramsToChange_inds(param),pat)*fractionChange(param);
+    end
+end
+
+% Save information about the changed parameters in the prediciton
+hr_range_control = [bestparams_CNT(paramsToChange_inds(1),1);min(allParams{1}(:,paramsToChange_inds(1))); max(allParams{1}(:,paramsToChange_inds(1)))];
+hr_range_prediction = [bestparams2(paramsToChange_inds(1),1);min(allParams2{1}(:,paramsToChange_inds(1))); max(allParams2{1}(:,paramsToChange_inds(1)))];
+HRpredictiontable = table(hr_range_control,hr_range_prediction,'Variablenames',{'m2_L_V Control','m2_L_V Prediction'},'Rownames',{'Best value','Minimum value','Maximum value'});
+writetable(HRpredictiontable,fullfile(plotFolderName,'m2predictiontable.xlsx'),"WriteRowNames",1)
+
+% Simulate the predicted diastolic function. This takes several minutes.
+disp('*** Simulating the prediction of reducted diastolic function... *** ')
+constants2 = constants_CNT;
+[~,minmax_HTT2D_m2] = simulatePredictionUncertainty({pC},[],[],allParams2,bestparams2,constants2,inds_CNT,data_CNT,options);
+
+% Plot results
+magmacols = flip(magma(4));
+colors = num2cell(magmacols([1,4],:),2);
+simulationNamesShort = {'Healthy control',sprintf('Predicted\ndiastolic dysfunction')}';
+simulations = {minmaxSimCNT,minmax_HTT2D_m2};
+plotPredictionUncertaintyNice(simulations,simulationNamesShort,xnames,ynames,'Predictions healthy to t2d+ht - m2change',colors)
+
+%% Save figures
+saveAllFigures(plotFolderName)
+
+fprintf('***\nDONE. The figures and tables are saved in %s.\nTo re-create the rest of the figures and tables, run createFigures_hypertensionT2D.\n***\n',plotFolderName)
+
+end
diff --git a/license.txt b/license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c7094995e3b0011d8f86af13ed5311507bd20e17
--- /dev/null
+++ b/license.txt
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Kajsa Tunedal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/simpleModelSimulation.m b/simpleModelSimulation.m
new file mode 100644
index 0000000000000000000000000000000000000000..1a37a5b0ee7294dd92a23e708e55a6cc0b5d8f14
--- /dev/null
+++ b/simpleModelSimulation.m
@@ -0,0 +1,143 @@
+% This is an example script that shows how to create a basic simulation
+% using the cardiovascular mathematical model and plot some basic results.
+
+clear
+
+%% Setup amici toolbox and make sure the simulation and model scripts are accessable
+addpath(genpath(['.' filesep]))
+run(['.' filesep 'Requirements' filesep 'AMICI-0.10.11_SS_eventFix' filesep 'matlab' filesep 'installAMICI.m'])
+run(['.' filesep 'Requirements' filesep 'MEIGO' filesep 'install_MEIGO.m'])
+
+%% Set parameter values and parameter names
+paramNames = {'Cpvc' 'Rpu' 'Rpv' 'Lpv' 'Rtot' 'Ctot' 'ElCo' 'Caa' 'Emax_LA' 'Emax_LV' 'Emin_LA' 'Emin_LV' 'Lao' 'Lav'...
+    'Lmv' 'Ppu' 'Rao' 'Rmv' 'k_diast_LA' 'k_diast_LV' 'k_syst_LA'...
+    'k_syst_LV' 'm1_LA' 'm1_LV' 'm2_LA' 'm2_LV' 'onset_LA' 'onset_LV'};
+constantsNames = {'aaCorr' 'avCorr' 'mvCorr' 'tdiast' 'Ks_LA' 'Ks_LV'...
+    'V0_LA' 'V0_LV' 'RLAvisc' 'RLVvisc' 'Raa' 'Rpc' 'Rpvc' 'T' 'rho_blood' 'norm_factor_LA' 'norm_factor_LV'};
+
+parameterValues = [4,0.01,0.002,0.0005,1.24,2.1,2.5758,0.10,0.17,3,0.08,0.08,0.0005,0.0004,0.0002,7.4,0.040,0.003751,0.18,0.452,0.11,0.269,1.32,1.32,13.1,27.4,0.15,1.501];
+constants = [0,0,0,0.45,1.0e-08,4.0e-09,3,10,0.0001,0.0001,0.01,0.01,0.01,1,1.06,0.558,0.6093];
+parameterValuesOriginal = parameterValues;
+
+%% Set simulation settings
+step = 0.001; % simulation time step
+T = constants(strcmp('T',constantsNames));%length of cardiac cycle
+simtime = 0:step:T; %time vector to be simulated (for each heartbeat)
+options.x0 = [7.322,7.751,94.333,7.751,14.789,7.751,7.275,7.751,6.965,1,1]'; % initial conditions for the simulation
+
+% set indexes needed in the simulation function simulate_avatarHEALTH
+indexes.T = strcmp('T',constantsNames);
+indexes.k_syst_LV = strcmp('k_syst_LV',paramNames);
+indexes.k_syst_LA = strcmp('k_syst_LA',paramNames);
+indexes.k_diast_LA = strcmp('k_diast_LA',paramNames);
+indexes.k_diast_LV = strcmp('k_diast_LV',paramNames);
+indexes.m1_LA = strcmp('m1_LA',paramNames);
+indexes.m1_LV = strcmp('m1_LV',paramNames);
+indexes.m2_LA = strcmp('m2_LA',paramNames);
+indexes.m2_LV = strcmp('m2_LV',paramNames);
+indexes.onset_LV = strcmp('onset_LV',paramNames);
+indexes.onset_LA = strcmp('onset_LA',paramNames);
+
+%% Simulate the model for one heartbeat (note: the model is not in steady state)
+% Calculate normalizing factors for elastance function based on the parameters
+constants(end) = calc_norm_factor(T,parameterValues(indexes.k_syst_LV),parameterValues(indexes.k_diast_LV),parameterValues(indexes.m1_LV),parameterValues(indexes.m2_LV));
+constants(end-1) = calc_norm_factor(T,parameterValues(indexes.k_syst_LA),parameterValues(indexes.k_diast_LA),parameterValues(indexes.m1_LA),parameterValues(indexes.m2_LA));
+
+%onset_LV: range set to 1-2 instead of -0.5 to 0.5 --> take onset_LV-1.5
+parameterValues(indexes.onset_LV) = parameterValues(indexes.onset_LV) - 1.5;
+%onset LA: adapted after onset LV to be close enough
+parameterValues(indexes.onset_LA) = 1 + parameterValues(indexes.onset_LV) - parameterValues(indexes.onset_LA);
+
+% set simulation time - it cannot start at 0 so we set it to +T, and then
+% remove it again after the simulation
+simtime = simtime+T;
+options.tstart = T;
+
+% Do the model simulation 
+% simulate_avatar_HEALTH_fast is generated by the AMICI toolbox by running GenerateModels.m in the folder Modelfiles.
+simpleSimulation = simulate_avatar_HEALTH_fast(simtime,parameterValues, constants, [], options);
+simpleSimulation.t = simpleSimulation.t-T; %remove the offset T again
+
+
+%% Create a basic results plot of some of the model states and observables
+%define the names in the model
+ynames = {'P_Aortic','Pperipheral','pressGrad MV','P Dmv','mv open','P Dav','av open','pressgrad AV','Ela','Elv','Qcaa','Qpc','P pulmvein','Qpvc','qLA','qLV','pLA','pLV','aaCorr','avCorr','mvCorr','pvCorr','Vla','Vlv','P_Brachial'};
+xnames = {'Ppvc','Qpv','Vla','Qmv','Vlv','Qav','Paa','Qaa','Ppc','mv_open','av_open'};
+
+% create the plots
+figure('Name','SimpleSimulationExample_notInSteadyState')
+tiledlayout(2,2)
+nexttile
+plot(simpleSimulation.t,simpleSimulation.x(:,strcmp(xnames,'Qmv')),'k-','LineWidth',1.5)
+title('Blood flow in the mitral valve')
+xlabel('Time (ms)')
+ylabel('Blood flow (ml/s')
+
+nexttile
+plot(simpleSimulation.t,simpleSimulation.x(:,strcmp(xnames,'Qav')),'k-','LineWidth',1.5)
+title('Blood flow in the aortic valve')
+xlabel('Time (ms)')
+ylabel('Blood flow (ml/s')
+
+nexttile
+plot(simpleSimulation.t,simpleSimulation.x(:,strcmp(xnames,'Qpv')),'k-','LineWidth',1.5)
+title('Blood flow in the pulmonary veins')
+xlabel('Time (ms)')
+ylabel('Blood flow (ml/s')
+
+nexttile
+plot(simpleSimulation.t,simpleSimulation.y(:,strcmp(ynames,'P_Aortic')),'k-','LineWidth',1.5)
+title('Pressure in the aorta')
+xlabel('Time (ms)')
+ylabel('Blood pressure (mmHg')
+
+
+%% Simulate the model for several heartbeats
+% simulate_avatarHEALTH creates repeated simulations of one heartbeat and
+% puts all the heartbeats simulations together (simAll) as well as sends out the
+% last simulated heartbeat (simLast) (assumed to be at steady state).
+% The heartbeat simulations are created with the basic simulation function
+% simulate_avatar_HEALTH_fast that is generated by the AMICI toolbox
+numHeartBeats = 20; %number of heartbeats to simulate
+[simAll,simLast] = simulate_avatarHEALTH(parameterValuesOriginal,constants,options,numHeartBeats,indexes,simtime);
+
+%% Create a basic results plot of some of the model states and observables for several heartbeats
+%define the names in the model
+ynames = {'P_Aortic','Pperipheral','pressGrad MV','P Dmv','mv open','P Dav','av open','pressgrad AV','Ela','Elv','Qcaa','Qpc','P pulmvein','Qpvc','qLA','qLV','pLA','pLV','aaCorr','avCorr','mvCorr','pvCorr','Vla','Vlv','P_Brachial'};
+xnames = {'Ppvc','Qpv','Vla','Qmv','Vlv','Qav','Paa','Qaa','Ppc','mv_open','av_open'};
+
+% create the plots
+figure('Name','SimpleSimulationExample_severalheartbeats')
+tiledlayout(2,2)
+nexttile
+hold on
+plot(simAll.t,simAll.x(:,strcmp(xnames,'Qmv')),'k-','LineWidth',1.5)
+plot(simLast.t+T*numHeartBeats,simLast.x(:,strcmp(xnames,'Qmv')),'r-','LineWidth',1.5)
+title('Blood flow in the mitral valve')
+xlabel('Time (ms)')
+ylabel('Blood flow (ml/s')
+
+nexttile
+hold on
+plot(simAll.t,simAll.x(:,strcmp(xnames,'Qav')),'k-','LineWidth',1.5)
+plot(simLast.t+T*numHeartBeats,simLast.x(:,strcmp(xnames,'Qav')),'r-','LineWidth',1.5)
+title('Blood flow in the aortic valve')
+xlabel('Time (ms)')
+ylabel('Blood flow (ml/s')
+
+nexttile
+hold on
+plot(simAll.t,simAll.x(:,strcmp(xnames,'Qpv')),'k-','LineWidth',1.5)
+plot(simLast.t+T*numHeartBeats,simLast.x(:,strcmp(xnames,'Qpv')),'r-','LineWidth',1.5)
+title('Blood flow in the pulmonary veins')
+xlabel('Time (ms)')
+ylabel('Blood flow (ml/s')
+
+nexttile
+hold on
+plot(simAll.t,simAll.y(:,strcmp(ynames,'P_Aortic')),'k-','LineWidth',1.5)
+plot(simLast.t+T*numHeartBeats,simLast.y(:,strcmp(ynames,'P_Aortic')),'r-','LineWidth',1.5)
+title('Pressure in the aorta')
+xlabel('Time (ms)')
+ylabel('Blood pressure (mmHg')
+